From afce9df09e688d6565abb91abc581b59d8f739a5 Mon Sep 17 00:00:00 2001 From: Corey Johnson Date: Fri, 4 May 2012 09:18:45 -0700 Subject: [PATCH] Forgot to add these files --- Atom/Resources/aliasCursor.png | Bin Atom/Resources/cellCursor.png | Bin Atom/Resources/chrome.pak | Bin 2648514 -> 2848459 bytes Atom/Resources/contextMenuCursor.png | Bin Atom/Resources/copyCursor.png | Bin Atom/Resources/deleteButton.png | Bin Atom/Resources/deleteButton.tiff | Bin Atom/Resources/deleteButton@2x.png | Bin Atom/Resources/deleteButtonPressed.png | Bin Atom/Resources/deleteButtonPressed.tiff | Bin Atom/Resources/deleteButtonPressed@2x.png | Bin Atom/Resources/eastResizeCursor.png | Bin Atom/Resources/eastWestResizeCursor.png | Bin Atom/Resources/en.lproj/locale.pak | Bin 2747 -> 2043 bytes Atom/Resources/helpCursor.png | Bin Atom/Resources/inputSpeech.png | Bin Atom/Resources/inputSpeech.tiff | Bin Atom/Resources/linkCursor.png | Bin Atom/Resources/missingImage.png | Bin Atom/Resources/missingImage.tiff | Bin Atom/Resources/missingImage@2x.png | Bin Atom/Resources/moveCursor.png | Bin Atom/Resources/noDropCursor.png | Bin Atom/Resources/noneCursor.png | Bin Atom/Resources/northEastResizeCursor.png | Bin .../northEastSouthWestResizeCursor.png | Bin Atom/Resources/northResizeCursor.png | Bin Atom/Resources/northSouthResizeCursor.png | Bin Atom/Resources/northWestResizeCursor.png | Bin .../northWestSouthEastResizeCursor.png | Bin Atom/Resources/nullPlugin.png | Bin Atom/Resources/nullPlugin@2x.png | Bin Atom/Resources/panIcon.png | Bin Atom/Resources/progressCursor.png | Bin Atom/Resources/southEastResizeCursor.png | Bin Atom/Resources/southResizeCursor.png | Bin Atom/Resources/southWestResizeCursor.png | Bin Atom/Resources/textAreaResizeCorner.png | Bin Atom/Resources/textAreaResizeCorner.tiff | Bin Atom/Resources/textAreaResizeCorner@2x.png | Bin Atom/Resources/urlIcon.png | Bin Atom/Resources/verticalTextCursor.png | Bin Atom/Resources/waitCursor.png | Bin Atom/Resources/westResizeCursor.png | Bin Atom/Resources/zoomInCursor.png | Bin Atom/Resources/zoomOutCursor.png | Bin cef/include/capi/cef_app_capi.h | 122 ++++ cef/include/capi/cef_base_capi.h | 85 +++ cef/include/capi/cef_browser_capi.h | 322 +++++++++ cef/include/capi/cef_client_capi.h | 147 +++++ cef/include/capi/cef_command_line_capi.h | 169 +++++ cef/include/capi/cef_content_filter_capi.h | 80 +++ cef/include/capi/cef_cookie_capi.h | 158 +++++ cef/include/capi/cef_display_handler_capi.h | 117 ++++ cef/include/capi/cef_dom_capi.h | 441 +++++++++++++ cef/include/capi/cef_download_handler_capi.h | 77 +++ cef/include/capi/cef_drag_data_capi.h | 143 ++++ cef/include/capi/cef_drag_handler_capi.h | 84 +++ cef/include/capi/cef_find_handler_capi.h | 77 +++ cef/include/capi/cef_focus_handler_capi.h | 93 +++ cef/include/capi/cef_frame_capi.h | 217 ++++++ cef/include/capi/cef_jsdialog_handler_capi.h | 92 +++ cef/include/capi/cef_keyboard_handler_capi.h | 82 +++ cef/include/capi/cef_life_span_handler_capi.h | 114 ++++ cef/include/capi/cef_load_handler_capi.h | 99 +++ cef/include/capi/cef_menu_handler_capi.h | 88 +++ cef/include/capi/cef_nplugin_capi.h | 49 ++ cef/include/capi/cef_origin_whitelist_capi.h | 102 +++ .../capi/cef_permission_handler_capi.h | 72 ++ cef/include/capi/cef_print_handler_capi.h | 96 +++ cef/include/capi/cef_proxy_handler_capi.h | 69 ++ cef/include/capi/cef_render_handler_capi.h | 118 ++++ cef/include/capi/cef_request_capi.h | 261 ++++++++ cef/include/capi/cef_request_handler_capi.h | 159 +++++ .../capi/cef_resource_bundle_handler_capi.h | 95 +++ cef/include/capi/cef_response_capi.h | 119 ++++ cef/include/capi/cef_scheme_capi.h | 226 +++++++ cef/include/capi/cef_storage_capi.h | 116 ++++ cef/include/capi/cef_stream_capi.h | 224 +++++++ cef/include/capi/cef_task_capi.h | 96 +++ cef/include/capi/cef_url_capi.h | 67 ++ cef/include/capi/cef_v8_capi.h | 615 +++++++++++++++++ cef/include/capi/cef_v8context_handler_capi.h | 81 +++ cef/include/capi/cef_web_plugin_capi.h | 110 ++++ cef/include/capi/cef_web_urlrequest_capi.h | 143 ++++ cef/include/capi/cef_xml_reader_capi.h | 278 ++++++++ cef/include/capi/cef_zip_reader_capi.h | 148 +++++ cef/include/cef_app.h | 123 ++++ cef/include/cef_base.h | 154 +++++ cef/include/cef_browser.h | 335 ++++++++++ cef/include/cef_client.h | 176 +++++ cef/include/cef_command_line.h | 160 +++++ cef/include/cef_content_filter.h | 68 ++ cef/include/cef_cookie.h | 147 +++++ cef/include/cef_display_handler.h | 117 ++++ cef/include/cef_dom.h | 429 ++++++++++++ cef/include/cef_download_handler.h | 65 ++ cef/include/cef_drag_data.h | 126 ++++ cef/include/cef_drag_handler.h | 77 +++ cef/include/cef_find_handler.h | 68 ++ cef/include/cef_focus_handler.h | 88 +++ cef/include/cef_frame.h | 220 +++++++ cef/include/cef_jsdialog_handler.h | 87 +++ cef/include/cef_keyboard_handler.h | 76 +++ cef/include/cef_life_span_handler.h | 105 +++ cef/include/cef_load_handler.h | 94 +++ cef/include/cef_menu_handler.h | 80 +++ cef/include/cef_origin_whitelist.h | 99 +++ cef/include/cef_permission_handler.h | 64 ++ cef/include/cef_print_handler.h | 91 +++ cef/include/cef_proxy_handler.h | 57 ++ cef/include/cef_render_handler.h | 119 ++++ cef/include/cef_request.h | 255 ++++++++ cef/include/cef_request_handler.h | 171 +++++ cef/include/cef_resource_bundle_handler.h | 82 +++ cef/include/cef_response.h | 104 +++ cef/include/cef_scheme.h | 222 +++++++ cef/include/cef_storage.h | 110 ++++ cef/include/cef_stream.h | 210 ++++++ cef/include/cef_task.h | 89 +++ cef/include/cef_url.h | 60 ++ cef/include/cef_v8.h | 618 ++++++++++++++++++ cef/include/cef_v8context_handler.h | 73 +++ cef/include/cef_web_plugin.h | 97 +++ cef/include/cef_web_urlrequest.h | 135 ++++ cef/include/cef_xml_reader.h | 268 ++++++++ cef/include/cef_zip_reader.h | 141 ++++ cef/include/wrapper/cef_byte_read_handler.h | 88 +++ cef/include/wrapper/cef_xml_object.h | 188 ++++++ cef/include/wrapper/cef_zip_archive.h | 132 ++++ .../cpptoc/permission_handler_cpptoc.cc | 67 ++ .../cpptoc/permission_handler_cpptoc.h | 37 ++ .../cpptoc/resource_bundle_handler_cpptoc.cc | 98 +++ .../cpptoc/resource_bundle_handler_cpptoc.h | 37 ++ .../ctocpp/cookie_manager_ctocpp.cc | 175 +++++ cef/libcef_dll/ctocpp/cookie_manager_ctocpp.h | 52 ++ .../ctocpp/web_plugin_info_ctocpp.cc | 83 +++ .../ctocpp/web_plugin_info_ctocpp.h | 45 ++ 138 files changed, 12913 insertions(+) mode change 100755 => 100644 Atom/Resources/aliasCursor.png mode change 100755 => 100644 Atom/Resources/cellCursor.png mode change 100755 => 100644 Atom/Resources/chrome.pak mode change 100755 => 100644 Atom/Resources/contextMenuCursor.png mode change 100755 => 100644 Atom/Resources/copyCursor.png mode change 100755 => 100644 Atom/Resources/deleteButton.png mode change 100755 => 100644 Atom/Resources/deleteButton.tiff mode change 100755 => 100644 Atom/Resources/deleteButton@2x.png mode change 100755 => 100644 Atom/Resources/deleteButtonPressed.png mode change 100755 => 100644 Atom/Resources/deleteButtonPressed.tiff mode change 100755 => 100644 Atom/Resources/deleteButtonPressed@2x.png mode change 100755 => 100644 Atom/Resources/eastResizeCursor.png mode change 100755 => 100644 Atom/Resources/eastWestResizeCursor.png mode change 100755 => 100644 Atom/Resources/en.lproj/locale.pak mode change 100755 => 100644 Atom/Resources/helpCursor.png mode change 100755 => 100644 Atom/Resources/inputSpeech.png mode change 100755 => 100644 Atom/Resources/inputSpeech.tiff mode change 100755 => 100644 Atom/Resources/linkCursor.png mode change 100755 => 100644 Atom/Resources/missingImage.png mode change 100755 => 100644 Atom/Resources/missingImage.tiff mode change 100755 => 100644 Atom/Resources/missingImage@2x.png mode change 100755 => 100644 Atom/Resources/moveCursor.png mode change 100755 => 100644 Atom/Resources/noDropCursor.png mode change 100755 => 100644 Atom/Resources/noneCursor.png mode change 100755 => 100644 Atom/Resources/northEastResizeCursor.png mode change 100755 => 100644 Atom/Resources/northEastSouthWestResizeCursor.png mode change 100755 => 100644 Atom/Resources/northResizeCursor.png mode change 100755 => 100644 Atom/Resources/northSouthResizeCursor.png mode change 100755 => 100644 Atom/Resources/northWestResizeCursor.png mode change 100755 => 100644 Atom/Resources/northWestSouthEastResizeCursor.png mode change 100755 => 100644 Atom/Resources/nullPlugin.png mode change 100755 => 100644 Atom/Resources/nullPlugin@2x.png mode change 100755 => 100644 Atom/Resources/panIcon.png mode change 100755 => 100644 Atom/Resources/progressCursor.png mode change 100755 => 100644 Atom/Resources/southEastResizeCursor.png mode change 100755 => 100644 Atom/Resources/southResizeCursor.png mode change 100755 => 100644 Atom/Resources/southWestResizeCursor.png mode change 100755 => 100644 Atom/Resources/textAreaResizeCorner.png mode change 100755 => 100644 Atom/Resources/textAreaResizeCorner.tiff mode change 100755 => 100644 Atom/Resources/textAreaResizeCorner@2x.png mode change 100755 => 100644 Atom/Resources/urlIcon.png mode change 100755 => 100644 Atom/Resources/verticalTextCursor.png mode change 100755 => 100644 Atom/Resources/waitCursor.png mode change 100755 => 100644 Atom/Resources/westResizeCursor.png mode change 100755 => 100644 Atom/Resources/zoomInCursor.png mode change 100755 => 100644 Atom/Resources/zoomOutCursor.png create mode 100644 cef/include/capi/cef_app_capi.h create mode 100644 cef/include/capi/cef_base_capi.h create mode 100644 cef/include/capi/cef_browser_capi.h create mode 100644 cef/include/capi/cef_client_capi.h create mode 100644 cef/include/capi/cef_command_line_capi.h create mode 100644 cef/include/capi/cef_content_filter_capi.h create mode 100644 cef/include/capi/cef_cookie_capi.h create mode 100644 cef/include/capi/cef_display_handler_capi.h create mode 100644 cef/include/capi/cef_dom_capi.h create mode 100644 cef/include/capi/cef_download_handler_capi.h create mode 100644 cef/include/capi/cef_drag_data_capi.h create mode 100644 cef/include/capi/cef_drag_handler_capi.h create mode 100644 cef/include/capi/cef_find_handler_capi.h create mode 100644 cef/include/capi/cef_focus_handler_capi.h create mode 100644 cef/include/capi/cef_frame_capi.h create mode 100644 cef/include/capi/cef_jsdialog_handler_capi.h create mode 100644 cef/include/capi/cef_keyboard_handler_capi.h create mode 100644 cef/include/capi/cef_life_span_handler_capi.h create mode 100644 cef/include/capi/cef_load_handler_capi.h create mode 100644 cef/include/capi/cef_menu_handler_capi.h create mode 100644 cef/include/capi/cef_nplugin_capi.h create mode 100644 cef/include/capi/cef_origin_whitelist_capi.h create mode 100644 cef/include/capi/cef_permission_handler_capi.h create mode 100644 cef/include/capi/cef_print_handler_capi.h create mode 100644 cef/include/capi/cef_proxy_handler_capi.h create mode 100644 cef/include/capi/cef_render_handler_capi.h create mode 100644 cef/include/capi/cef_request_capi.h create mode 100644 cef/include/capi/cef_request_handler_capi.h create mode 100644 cef/include/capi/cef_resource_bundle_handler_capi.h create mode 100644 cef/include/capi/cef_response_capi.h create mode 100644 cef/include/capi/cef_scheme_capi.h create mode 100644 cef/include/capi/cef_storage_capi.h create mode 100644 cef/include/capi/cef_stream_capi.h create mode 100644 cef/include/capi/cef_task_capi.h create mode 100644 cef/include/capi/cef_url_capi.h create mode 100644 cef/include/capi/cef_v8_capi.h create mode 100644 cef/include/capi/cef_v8context_handler_capi.h create mode 100644 cef/include/capi/cef_web_plugin_capi.h create mode 100644 cef/include/capi/cef_web_urlrequest_capi.h create mode 100644 cef/include/capi/cef_xml_reader_capi.h create mode 100644 cef/include/capi/cef_zip_reader_capi.h create mode 100644 cef/include/cef_app.h create mode 100644 cef/include/cef_base.h create mode 100644 cef/include/cef_browser.h create mode 100644 cef/include/cef_client.h create mode 100644 cef/include/cef_command_line.h create mode 100644 cef/include/cef_content_filter.h create mode 100644 cef/include/cef_cookie.h create mode 100644 cef/include/cef_display_handler.h create mode 100644 cef/include/cef_dom.h create mode 100644 cef/include/cef_download_handler.h create mode 100644 cef/include/cef_drag_data.h create mode 100644 cef/include/cef_drag_handler.h create mode 100644 cef/include/cef_find_handler.h create mode 100644 cef/include/cef_focus_handler.h create mode 100644 cef/include/cef_frame.h create mode 100644 cef/include/cef_jsdialog_handler.h create mode 100644 cef/include/cef_keyboard_handler.h create mode 100644 cef/include/cef_life_span_handler.h create mode 100644 cef/include/cef_load_handler.h create mode 100644 cef/include/cef_menu_handler.h create mode 100644 cef/include/cef_origin_whitelist.h create mode 100644 cef/include/cef_permission_handler.h create mode 100644 cef/include/cef_print_handler.h create mode 100644 cef/include/cef_proxy_handler.h create mode 100644 cef/include/cef_render_handler.h create mode 100644 cef/include/cef_request.h create mode 100644 cef/include/cef_request_handler.h create mode 100644 cef/include/cef_resource_bundle_handler.h create mode 100644 cef/include/cef_response.h create mode 100644 cef/include/cef_scheme.h create mode 100644 cef/include/cef_storage.h create mode 100644 cef/include/cef_stream.h create mode 100644 cef/include/cef_task.h create mode 100644 cef/include/cef_url.h create mode 100644 cef/include/cef_v8.h create mode 100644 cef/include/cef_v8context_handler.h create mode 100644 cef/include/cef_web_plugin.h create mode 100644 cef/include/cef_web_urlrequest.h create mode 100644 cef/include/cef_xml_reader.h create mode 100644 cef/include/cef_zip_reader.h create mode 100644 cef/include/wrapper/cef_byte_read_handler.h create mode 100644 cef/include/wrapper/cef_xml_object.h create mode 100644 cef/include/wrapper/cef_zip_archive.h create mode 100644 cef/libcef_dll/cpptoc/permission_handler_cpptoc.cc create mode 100644 cef/libcef_dll/cpptoc/permission_handler_cpptoc.h create mode 100644 cef/libcef_dll/cpptoc/resource_bundle_handler_cpptoc.cc create mode 100644 cef/libcef_dll/cpptoc/resource_bundle_handler_cpptoc.h create mode 100644 cef/libcef_dll/ctocpp/cookie_manager_ctocpp.cc create mode 100644 cef/libcef_dll/ctocpp/cookie_manager_ctocpp.h create mode 100644 cef/libcef_dll/ctocpp/web_plugin_info_ctocpp.cc create mode 100644 cef/libcef_dll/ctocpp/web_plugin_info_ctocpp.h diff --git a/Atom/Resources/aliasCursor.png b/Atom/Resources/aliasCursor.png old mode 100755 new mode 100644 diff --git a/Atom/Resources/cellCursor.png b/Atom/Resources/cellCursor.png old mode 100755 new mode 100644 diff --git a/Atom/Resources/chrome.pak b/Atom/Resources/chrome.pak old mode 100755 new mode 100644 index bbe61def7c898db72a7fa61497ba7c7028b35b95..e6bcdc36a2591f44c79233e8b3e6ec14a30df885 GIT binary patch delta 132397 zcmd4433wA#7chLY&rF)OY14JmHm!6?X$wU`c3N7NBFg|}6R-_!3Wc^QP0Au*S``Eo z5Co2(Y=R;R0e3pL)SMc+-gEdn3531>X2zcge*2HlL%R2?0p|0OO4m@3C8=A33=W)HHDC6 z#yzQoEH@g`2zkMn(vpxDjgMpzvckABn~;^p2ip*`%GmjSLRK5C4-m4(II1lnFBz>5 z60+7fv^^o~jLSO^^0M)7e7<75)X`1IdgHY&guH6hN=;}_$YsUJXguHHiq7NY( zjsJOwkWI$IeuTVXY(IdI&Bp3NLbe#!jUZ&JvHeIw-ZXw#M94Pd;8H@i8`s(i*CO2}0g8em{$l zJ;v^H3289yIzz}_t`v*r^c6`R*=t(s}?B8X=DC#3UbEy@nQuzYm8Z@AfFrm zSfL733RZ z-a!SqWK27zAm19pKUI*+ZsV{o6y%C=>IDV4YJBptf?PAs`d&f4GYtQIcE61+0?XHX02|@`G_wu#(&{IzyD?N8{~KCHcwt zB+Av##y7&1r#E{ar=-;5Wcl;n4#BSuO7FuHHWD#@S5_jo1w%UG4BB!3&# z?Udvn!^T!Bi7G6Anv$r)2F+0tP1xe4N}>(>_<1GKg{@w$ zB*Xb{Ur>?}ym7UXJj{1lrz9i!@>i8)6u)Gnl8ol}Zc&m)`0Lx1q==8%r6k3C5BF{* zvGEi4D#;jr#eO9z;SU~El2ZPsBT8cD6Hh2f8QM!Nfp287bS7?^U0+uGKU{HPDSSOGb&VW@-)ApT1B4WKXs|dJYF$XMdtIFGgM>&KcZem zp55R=zw0Fxd7l6F6%|>= z8(&wE<$RaTD)ItfzD-45<~41lOG+fCfoQqQEIZC-@&WN z4mW=xK}~k@h8Ak#;X9ZVLrr$^3tOwn+x+ea)Z`uhT6;BlmyhV8CcF9ETs3)* zuk4{Fd-!DqYSO^(@24hv`P&24N)MP)uW{jGA$R8!w4@LxTzCMS7zg_@k=+pbZQPkGzRYVsLBZ-bhg=67vUlQaCcTh-(&Z``RS zpYvVbR+BII^7qu_OMc1wYVsAo_d_-Ln!or5K{E9Es zoFonTk>8Qx){vk0 z3+Wp2GjC|6A;0h)?$?lCdHaJJ@*BUflZO1x@9w4{fAH7xG~`b{qPK?p#pm|bkiYp# zK|}uGmlbLVG4CI)Aqw;DQ5vE&$JtQn%msE0QJZVaHAG`xQ>h_Z^O1=fqBH+it09az z`B4pF%>y6PxCv*T@wkTQ%^PNENRau{xf)_HD;8)-usQQN4GA%i01XK>&wN2cjOMMY zG$hRY)mjY+H?yy5h{@b`qlQG7ZCf-X(mZdwhD4cny`>@1=5OECkQlRZuZF~$yX@Bx z-duiAL(JwSM>HhPy!W_<#G9{wsv+(KbIj)&VlnslT0;`e6EA8=l6l2t4Y|*J@H-7@ zVgBich9sL4?`TMhx!*4ul4_p%hlZq?U;al!tmfk?ElD^3rPGp@W^0g^WSED9YDuQK z-lQd2=1tLB(#m|+tR=0@nnW$hHfJYmNgMNMtCrkvo|CC154g=cvbChG`9fPQX=gTc z)RG6y9lB~sd$YZ}mUJ*L?5QOk&Aa<(NhkBQ{#w%695Gl+x|nl^X-QXe9|{IxcPqzZi- zQb?N6;-eH|6^5NjA?bp{eIbRk6jJY`kPKl~Vk*fL`lY3kEFsyNN?Hl&>8Yf((7I(R z$re7#NF{9qS5_*yU-%H84+syoP9<%HeeF|8J7H?qRPvy(saq;(FHFfvB^`uY`0OZL z&rKzrgm1d1lFkC3pGvw22l3fe*xn>K9Xq zO*peMm5dQu=B1GmVN!k?DHVqHNF#P(azPp?6Z-T^BV&cD_#7wX4NN2D!tOz7#64c< zHaLw;5Y~@KBNal&qBK$|tkzjcm2jG|5{IDUtfX29(Obzx;VM3B1f#)9oWe?cx`eNT zt)y0PgjmTWVO^+|Ocq)htz?QYD#A*p3b%MGc~qE^W+l@E($-3*3$t^rWQGvh-%1`6 zj^NYn7K#U0Nu3Z~WF_^&kt!>BTo~|_l{_J&&bE>#1;-pKnJFxtYbCRUTljoR==-#l z%of_uvywT&(FImASI{o9lBb1Li>>4tp(9wyJi)QdO6Ci%ykI2@gbpjLe3)7$A}gP?QoPA9Jko%f`Z*M*Dt+$cF12nn=%aM9 zQ<(H|I`IfAkEfHjgh3b6$u7b1Lppg|a4TDqcZ9OAmgHTbZ&FLLTR7dOC3#OM%L{Kw z_6XeyTapGLrVQs3%hQg`ToRF0I;Up+%7+*4Jn`l1G48q6vzL?w8%E^MuBjj6 z-gRc+de64&lRvq+?uk2Jb~!qArSp?3GgkeAzaHtG9J6T7AG6Aaa;KC_8j{Y(RqL)k z_rP-ZIOhICs)y@Ka&qeqg&u3Mq1D3B_?)OMC6TAu;sxtIX`gs`pKDb(&Ot6I;PA#a z14GM(YRv{?n~?S^wl6yqoWaCw`}A<1Me2bOi75%M_72ORxbLku*JV~Deez*ZNG`Xq z`@Yn3|7d0(e_+L+*`}nKy%WP){kHATTc=c=X1o$yaM~T`IXL@he8`kX_$?>Kj$is? zyVHGYSmDaab0lluAG1Rflof`CHme?MKi^eTwB><@_1%;Wz0NPYU+;W3_s-E%>)Tsq znP-&L4G6i_=KIaN*0Be620#CwlTRi0`%rQF48P;tn_nLO?Dx19^A!F1?kIV4VN}Ce zGHuh^bMx(!7yTH1b<$zCPWk7f^?x<=jwD~Sm{B`u1344d`h%^NTd&{f^upQK$g?dQ zwC8&^d~zpdoa(cOVuPoAXe{0^z-{=kOuul5?%3fQ9sYA6Ym5EuuU|Voe}rl=anz?S z`f&a2P2`5EN7p;K1ySG3dbR8|>-WFx33}jBYgEDEitJmVX}`1@SG;50!uBUwcfnr` z9S*!3^49pWnMTEHb-B9YpmB^Ubm#ZuH1X|sb}ViXohUw| zIQXP__n7lbJ$0jFNXNPt7Cq8o;?zg_8jkg@{^t9|>z*4});2uRFt=_(!{wMS-)mj_ z)(=Pi_!ty-#=g4d;T9_vyuGuH@lFSoS@{XkJ8fw>t5nmHyL|le+#}bX-GBJw`ZCAD zsF_ThGK*Ya^w_0`=N_mXR2Xzh^+MhFD<8}pwy5(@bN5%RPW|HTs|#|~IlIoy?_coF ziEi(RLwjOrKl6!iuRgKvhlGz>tvd420n?R!$DX?|J>j{z>GAF#yprCp_mEsu-JUDk z-tXHwvFPcf%H!`>*Mw^Z-pFY4zGZabkN26a!mx3w{z^^Pth}7(BCjn-eo}wT@cr@wwcMG_J>Gul z$&a4C+GV|pkQVi?&mWXNG<5zT>-qf1ev!&67u$t*s^33i=h@3?L&8#LzZP2gL;c6? zb4^cGz}zq1Pq|d_=TD)-8NG4E^gp63A6B*>!RT#?8TsEQyH_Tx)E0Z(2TpD1Q59Qt zGVzai6exmC}H-t6A}-Cwp|R}6jh$C80hKKEPw%U!$v zl1HZFOk&%!SAv&Mex++qMRw`c7iLWVy>8fu?xT(;4W3omWlO`_kO>Q~rCCS$1}o%<(6|8DHHp>0>o>H2vMnX6V@2|pHGaV+VBt~1QKp;LY|TH;Jeg67!3 z@9MY4-%yMk`}(H0zkPm34%?dRd@|{|ZNCmxhSVo5*frwmQS)P8TE6V1EvNs9J$7~0 zsI-ZTAJ%r(x<7tbAN%UDq>|io&jnpv{7Grg@q;#WFMjU8C{5w1b%VNG>s!`YofB~^ zWbw4a;SIr=ZGL#?#Qb*W7usIeY0WQ>-}dXT$@2$os$!P#3kH-g+*_e*vGCig5vndX zl&k>mF5sh%|S=@;4XrE@}Ug8EA`{&Mvnhuw$2{dm|fiw7v4 zzWmXehj)Cmf6IiH#+uxey0r~cSGRsj{iCKj=jqM|lb=3vZPEULuLX@$1jmlNG`)>_ zl(OUYkA4|7`1Y$+bLZA;i}gaKdDL6hId2^t)9P5%1Fe293GFIeK70J-9zTEHtrH#e zCo|9HCw?`n>+B`}9C_UTX%Y<$~sE^_3N$$z}}SJ_zi{pSu(|HBYH=cyJiJ+{W)>E)a*#fn4qo`%uI z?wo>b;{@i=q(wQMs$E$-u*4orD3IJ)cX1-`pmtNmiR-`qesu8uPQjd z+}>&EMoY#Q1&Z}=j(aoutx(UhGlq;KZ_cYc+rQvN%WHYt59(gKs2*s3b98!@{)K0^ z-9DXHYzfMD{cydg?)laiN-aT8*0&Db3V&)In-c4;-yJ^~7F}F=xn201H?6Dw?pU`Y ze(>vy#yoJkZ%y*C^T*GTj{DwuHuUC5#)48_Sb=bJIV(b&Aa|^QB z?X5@7XOmhf4jg!7v-?_`MPC&Z+*VyZdAJu<24it&($GJ7e^lmTu1?kUe)HMLFE(5| zvh@1KJBnS33T@RN-*;YB7hL?@qA_RIFL(a;T>oen>ZG~m8y?Q#{Z`~9Fn&;0qu_O)?S z)}4*5%RMydyElLR)xPxl_FajEZ*=Lpc3t$xlXAjF%zq^N*nhH$M{Db|&d*o4TuXYlqQq4&OOgyIuLzj?9|Gg9Pf4Sw4;ESTcs6`SE~d`syFItsPmg_1vFlV;Ggq()VBrckTF(iO>A0`+*H#Wjplz?~k8ViyGl> z)9#6=?5Co#6`rVU<|7%e`xMxDkKtYU?%FE4cI|3OaZ%)B1+u3me-Lqp#q zn#&V)X#=0ke_=53SPTbN_nrARd8YcY!y9Hk*>Y?9)g6x9Sv~*0~<$2Dx5}hNCo7=rJ>50L^Q(G^3_)!1V!=LFh*V<QtF`Zj#95|sHFjrhg)6J9yvFGgY_4&6j>>9BmA%U4gobyx2vdd4=^BiWaRpVS z_9>Q@mTYS$XuVl$hF)8=$trG!1qKG`!##Cdw7;lSJ*rB%;o=)}$7IQ*PdL^(BJ%y@f= ztDqG5S6)_buR)O3ouu;W8i&i_np$nA)i|!Y)&)`XVd}({ zms!#hn?hOuoMF5#KE3 zRgKlGUMa1vb&jLB;ljn(aM&_euQragy8_#V>~lfkeD%n?o1!h@V0jL@68=!a{nxc` zK=KXka;@0U5-^@gh|)UkwwjW0u=Rnca9;XdP=!O)qrzT^V~X9bs;#K##6ewKT{N7& zp)CVpPp}5wx~>g_KW}IwVyjW1oJkon@va)X{UQ5QfqsOomqKH~y5AIZzY|A?;<8Vs z5|w7{B=g!nrP_vSRyx>abJ+u7Ap37rkJ&f1mT)RDIepotj_6n!n4;S2wi;aUX z2Lwg4z6K!UZ*8KdtLKqlwOzOfN~}B}l#wD@JLI%9M8{jLGAEnD;25S!FieJJpYm5j61{KdB@t^;BOQ6;Y*l0Jr4-*Fsceh`)oHLe9F$NQfU-oieu~wDmG5P|5uJKJ;elvHx84p zqG;a3?jBuGJRK4fT3cO;4q>pQXeeQjYe4s72+=XEi>h#>rILO&SIIb0Voc688`4`MHpg2g!>;1+G+(Eh&c>P>R5X>7Llmx5eIjzc8 z;erH%ZUmeU)@k64a9zUx-JrvfvrH@mkBHU6vtxqPU=7v9sD@N0i6|c^LdBa@?x5C; ziq8KoOK`k6C?0l}1cm9^JZQ0CKnjT}a|9eK4oZMtr9lzV)CGyth(^q!7=UFs7i|z* zlEnh!7_3@MO&XQU<|<(jhF-Gyk}PrJV#ny`-^(d&5fB=wi;eeM)j-h-kWzT&bEZcZ zaon2`)qgXNqTRNjh(oqo7o(<{3axgVquNSCPHl9CMRbXUjUf$wnNVIWx+cG`RO!v@ zO|g&>6cNUXP9350AoLZJiEpk#CvGx^cy>@|BTSq)m7-92uu2sXQIuFxTZ6%$%ddef zQ9bPP@Qbkmb+!Kspr7lvVq7Ym${eCX%M5=+>E?N!j?vwUqO;BjSdgtV zneLkF(fr13n;}Lk1sa}Dvvmg)&4XPiHCRMco=f-Zf?8-rq7z}w5M7cAZ9Uu`tqV`d znpEyA7pFF2cS8hde#7sjMC}VBHo+|T|A5)r3*59 zJ%-&yQ)RXiS3jIVrA?tGHWBtdz(uwwb(BmfbPOsVJI*D}O|3{AO_P*68*4!QZ;aVs zbGd9KsFID9+ul`Ks*5`8-=1H}V+yrgsBzwJoJRlv?Os( zU*e(xm)M1*3HZv2c2_E+c7}eM~`>vl{bT zj+(3@oc_CP6&3l7eND4^T2Ikg)ll70Z-DtvhXliwxgoKzV7jg>sTp{Tp}q4cI%|T& z9Z}Jt{@uqer-89jmtdk_2V*YGLNkF$HI%bSP}~QN-6s!ltkJ&`oqSuNTZJwG)uv=Z zrpuA(51;czJQHu_0{arkTd@5V8XMAN2qAH>DOT^-5F}m-4QDFKoi2Noy#|imF+?jW zATb#gBCc%$1MfzLMwKBme2LrtSX7ZunG zDoSD~0<9+KV&a;sKE~m4IVy3e8wJ@EzzK>2bqunyDO-+7Uih_u4O_}D1VPt$ef zdT2927a8rSwqxF@zkPC{ZA==bwj8xJCH5hM`ohG;C`4yYnPNPz&DM?9z?S*CHLSV8#>2=(x>nGyZ>R-2A7%`xG})UNFiz!n zBe7awO)MJ=!lOYNSieXY(sKqkrp9iY(1|OtVVs^cq-E>YZQCSuw1`IKzoL_~EuG-- zBHhwtQ7!*l9nYBObgxChlXG|@bZZ|U>gm2wcQTY~>@W4oDbQ!PE;!246=(9^jEf4S@x^q<-q@gIAo ztz7(3jYed$qoy=zbQY#nQCQL5TAC2^W)t|GK4vzv63_fmq@ zy#4SkaOCXMO@p-WScB(}i@NnnxGy-^2p?YxiGn@r^{wF9uW+?O`>KACp2|cbvT2;7 z1}3H$qM@#XP7Oz2)ep0XMSd#hfSYyowvjL}f=y1q}49EpoE>3Qi}-QgAr4z{A{1wqF!uzNi77&MGz zbnwh@hJzhr<6}G z!SsOn6PQGiAkT^6OsE333_`M22Qg|-n4TG+463qCDj$nE6N(!)hcNBoXe5&Yb$UkQ zVS<^NYVjw|y{X-;rP)^)AHob!k8@R4Kz1i)pjd9e^1&rIEvXt@{-_=PjzK9p)ta$G z@i6T5HeEs(6vr?|&%7{3rSUNU88?BMBC#v$VI~BA9l^W@#a)rYn^BC;^L7-oMB#&G zz*@mPN}-KVHxkJ^{4jG3ohaq&%~*!zQ3Oy~)JR4^?dv;<*x7cs#K zXl=zN2E;S0r%xQS#jgogTqUrV=64qd1&tG~<L76ySWXxx!QL3g3R}7`YCvszK>GC%@?QMqncI%J&Cs73la&9j5Mx52#!-eDhZw2 zp?h+|ylAusKH~!qC7MO`7%yrD>?y-RnP6u&hEUNJBNbdTqQMFZSTaq_Ous8o6oNF$GILpo!E-TiR5hxTO_DMK(qMjJ}) ziH)w#K~)|T4etI-S%kDk+FZE@%OCWYfX~bkVi$TqMK#hW+TE|lp;~Vp%j_0yU6|*> z0A`=suiFch38A8C)D3ggOt9BT!wip&N1J`F9Q*fpIg_Y>k7Af4=r;s$9V=v(DLuEU znOVl(863^6_O{!q2Uppu@wdE??d)A%iYw4Kvek68(eA`~2hAHx@HAqT=Q;9s&!op0 z7BlQ#Hap?iOeQ|2@x4bCU7n(5M8xBnJcnTvq2i2=#Q0e81{+{75Np=Fle;z zyF?tCj6w{lu!yei<9}kUTBjX7L3y>y*bg*^bqK38YxOkLTGnWa3msW2*#vT z>MgQ=LL|80YeB0!24{h&j%fQVB@UDxToa|MycVa_s09~>F*ft|LE>o78nn~76_agK zoiy&EtVOD&PL{auBI=%%C}sU@6YLgmVBxgbM64o36s@n}GIWMLD;$&2f6Jj>V~c?e zx?O2WcSF;rBq6ZSLQ5IqvLG_CCG_{chNwVFdM?HY_8JvSgH0*lkrqFzq1;)P?CfQ+VUBdIil1b<0^3*CxoS~U+47tDH`by4 zI>WDt!g3c~1fC|Y{z_o5W|%43-NUC7Vphn%PV+c?y5Xzn%o2BDG&YXC^sZ6+fMn{+ zopN7gs=Ly?A&oU@laxvt)XJ(Epn@X$`F-~ey_2Dzwh9^}(`?{T zNf9P^_J-MTe={g>Kb4AY4gCe2zjwl8^3m8jGKvuvX5o}q&@cJG;xpR6BEnw1>u&@wwQ^StN zg~0hmjN0IxEMQ!R`@IGpjf)V!huxh~gX4>E{va%3hNc%((d~V>KTCAVsBF?4$WPrI z;-o0U;@Q23iB@#*&y@K=VSa_$40++30;S<6bd5!0Dr{8~&^v(f^ z9=Kf{9|Jv(G6j)EQgk`EcI;RLLQ|DnUg}KqtUJp5p$>1R432-zMZgQkn6M}uXHf{p zVSZJv-`z1K4RSw^al|x_7ps8fvlt6}|9OlRNfDRI>|`xwTm`#!}f^2#q_26$3G zV@4>{f^DoFLQgX$Z8iQHQVqqY8A}5FN;hgGb>wgpODRT#UVW!f`7l7uM#ARPi~;IS zGgGqr+RI!BDrNL~J1Xt?A}LNYU31bkisa9k1o+`J64dq#J{Fx}B9mz1`+uqS=xLnG z1#e@taPrkxTVv9c`JIARh^pDRo+r6L0oFXB99(KV)CEiH0nong$L&>PGHDtPvy zPUk7O%`DTInrSKxZ0*ch(Dfrm4@VCm6Z-weBn1Zw2iS(-_LCJVHVRgL!^EhmkAT}} zm~hYIzcEiKg2nB-jeCt-{=pa(D(ok`@iWuG*mU!*)zkS;CRw}WA{*wpp=6&@Fo;f+ z78sb$Ccv@Bbu1*P*;ZZ=>aSu`7*SAAgdnRW=8kpoAZ7~+`iuwB*ryZf{{0J%BgYO zb3@6CF#5xzdFEz7Rsvh|KXN7n##z`9)4fGV+j7t46cQrJ*MWOHp>y1{W2SDmG!xIGy%6IkA}Ih7R@tVAgqblA*tk@p}6 zT3Oi)xSD`_RKvbw!t=Z0Zhdb|FGYcLi?#$KgqVnjZ4nROcMl zp`#J27GC+%Pz<5H5#xI&4BcSkm!TZEd$U8qJuArJ$tz$7;(oh!#t2SImIxTw!{+p; z7V!E6HbOJbj>&3Ra}hWGoqw1MgYPG>2`$8rxWgGI{+K3`+w|FAsT9^^hnnH$1U9T~ zCQZChNM9172-~_xJulYA`kG7%4T=i3cuZqbiGJ&itHih@DF20mh%Nn%bZ zX4>djb+5%W+{S&ZQW7BFzYw+xd<1-z6s6DYK{s=ISM{cGg|;!?vFvC`@_S3lpk;Y< z=R~PgBK=OnK$1;{XC5E_MR$Q#UTW3tLiWxLckv$i;N11=q$rm5T(m@3O`IKJsaI?;%AjX15F4HHc>w|%&ah0vEiC>`dSh}?{-~6U zEH9;JZV-*nG}1PtRE*1Q8xv4NmN&UnEc7#Tw4w|_O|^Kq3SlIcOG8^o`y&orVCQ{} zOEwR|M5QvK&iImDV%OkEC7bA$m{DGZsmweobrdb-hCe?MWn=mW+w_v=JO3ae@gvK} z;Kn|nh&4qj?sA!Y-fT$l66sGP?nd#_L@7;%4s&t0PseID+KtjmIa2ODDNsa1-#ni* z({75f9+FB2#7B*Hl$vb!qCILXlEvD;o6c%6Rp>?JZe&0?U8EaOMh5~<0N}AZzuH+% zs-Y;{4KDH(N0DYntGoweXm<+bajSBP$mJf1+cKb{pPo@zV0RVUR%w|53n%C^MJp55 zXl1gnJ{?aygQ|~&&-;h#akm8>-`t7{ETW49-g997BQ2*Ru{({aTzr9+b0QK{^vBl1 z$cWs=kwH|HJSR>2+&#b&!vf_{9AapwWV3L$dkxi=dkm2n%VV)O-T=kGh;VWIS>O0W zj>;Gjd-edad!Ws0tk-R_rN_PdGe=ga=vhlV~FSq{rWKQp)~)P!VyKm{*ew zrHIU{Gqu&j>AVcvkfQ)Ud*yAN?jvl{IJL|Ft>H%5@!Aeb2-*){fGDe+tZTHC;zcUy zKVAx{k|KFBkhI5(hB|?;P531_C@;|uVRGHeGO6Uh(T z#UWKqnO5Y}JFuO%ghOb@ST&r#WZ)n{!0Au<-Y|U-Vs?6sIBdNV9|`@x2@MIy7&5cU zA%;pc%o6Q1mYU(&4dFrVCZ(clkn;USm3EsG9dKzt6olIkN?qf;woL{Jgb*!uql*cQ zAiOoD{tO#Wv5BJ5R0W-0q&`0<9!F{9jdu{}7*NA4=`so}ZCdFVz<;FcBBCjuL* zgE5t?IX(;dC9_#(i=UzC0k&go#0WZ8J}7S}LHR6K!~=cOsm_sNgY=XmmP+=Yj;=4E z&xu~G(1#1QI@oa5=gZ(W&qj0%Xsrnjus}saY z*{Fg((S$W01)Cm0RD}+jo+uDE`2_gdz!EvRP8;_ZCfRv;KLt*r;I@ekzt3CtFFFZp z#<20CTelq!iYRJiFm>l*L_!mvwCw_gZ8wXn)oG#Hj{F30K6g8Dq7?^^2n*sY{ zOmtOE>tnebebesxSdIxXRG0E9@qjEVjy9?J@g}BLu@L>Uw^(8p<%bxYiun{-Gn;cmuy6ny<+Fc#lT4A(5*Q|isC|-U+}Hgv_v-$? zsGM(L0y!t=!$eQ%-%z8FnFA~M$Pqt-;(WY0EPz;%!|+wNpai#<91%OUH8jKFOL`-B zFvH=y%7G4wl?$vQPf`Q)v!HY|?oE^2z2xBKDGFXFBEI{2+OEV_Q6ef}Ke;F^prX&P zHDkrxRGI#jR20kRLe7z5x2R~~;7_I@1JWbrBrD6SXaE;Te1^qKHZ~}UCpt}Ag*%XN zzX0N{E;#V0g~SLsphye^@y1!+0G-}B(gebZ%L{4V&^`^rlc^aPq2i7oF|#)XZ)lln zp04I?!~*n(&gd|eX5qPyyP zXJ!EiLdQ8r1|WoE4+oh-#Fl$Zan;yF9#K-mnNY5T&|2G z8PEbH8EZBDMiEf~pmaC3Ogk*gpW9w465};-SOGm+x?f9oGoq!XDLxu8{%@>7&XkKp z;VnC9SjR0348Ar+n%NvqODiws%@K~9{r%>8jYHR}31hqx!Od{fiJfRx1KhixkW*tY zpr+K0A-(8Ty@?-u@il;|^KVhVPdx);2x^5Qsi29F;0UQ}+(1uo4)YqC)W)n3O~XL@DmFsV ziJm8oVDO_@6FNFrhgO=(K(2#r0aI_YVPLt%8rI)-unJ`cw{!&C8FM9jXGNNnmeG*? zAl|rwDf0+ucsV!*T2Exd;aE~sl$g2p+qi>$#h{+9F!%&ejsWFsu9V6Zb6zyb>`UM_ z&blRk?t?(N@cs7s;Ko+kQnB&1=`EK!Gk=&hW z5Mytc_@yD1vVv0~JH`Es@bUW*X1Zl4J5h@H(ACHh7ws-3k^U*?C^tP{M$Z~I;`U94#hsa=my)hClF|Fh z@4CCl=dGGTq7jllNz+HH)3zMI;bsZ0laa(M*W(KHd(H-M-Duy;dTdcK6B3qpy; zRvaNY&Ctj}KUX3(B5sB7xdfQ_HJh%a7_GP_NOKJ-eiL*Wa!c-k3PhudQ4(-LFam_- z23_JkX7`z*B2W~P=vP~#G(oa*i2p$Gz^I6LuTIKxM&(Hk+bE^*Mrv@RMgl+fgdrlC zCeW!d@x~;gy^t*aU`#JaCZdtJcK0Gqtd}`P%vw+y1M$G#3Gv}^ty||mm?SxMN|qo0 zC<6vwHbl1-{jNMYk$1o}6>f*dk41zIc7FX-@TjwFF{IuQ0A2r~uw=r2SPa+k(O#^VpKqRBHe ziFgSTvUdeXwD+$i10%cq;ToN~KP*jwL>L0#Xu`}C;Sc0P2!GudWrnOQGuHvTCc71R zl8IDGvu!bJOIPGOS>*qGvsjTCiCN|-n$+@E7a8}jwV`efAK@81k!3^L{Ocw{ADigl z*rjE8D=eJK_Vbk2vyVjJF+k&L9MqeuSd-_crR+8ZSLqy^g%niT(_r{AHaQC4^BmPv zvufF5Ghkbb~#Ygj%Mw@l&}`ot#iUOotV2?_1;5<3f$Gr1^Oy^>`N0oN|Vux;!XXz>D@ z#EJ_Kv=g4TFR=Z!;;uWqdPO|Bl3}U9#jpxE*M^IR(A1Df$Y>R!hqu?TJv|@2#QvpF z;_2yWZ?K)g^fEilCo*`&-=0IbnSdr2VbRO%K4~i-imKCz`^+RxgK<4>EOWoY&c0Xa zsCyMe!-DnfVt1n|$$M2XaKl5l^x8i$r6y|GT}4@R&nb;?X|cpPNran)l=VP7B!Q0K zA0>243X5sd=VZu9dlI8gGEm4Qx&` zWmq{Du57@-Zt(^-@m~P0H&gcgYiyDH*?XLJY*ZAidX3dV-5NaylU`@rNBC~K3>c@& zud`+M90|n?sNTr-g7@BFSq3-Biih~YvymMX*xc4lnB6nFH@0tDvJ69Rz zEk@0eM+zFMxEOeNE6WX#B~^6lqI<;jNF`oUVK40`@y1)L>G!)r22tWYi1b&}g8@-t z0QF54%L5d}1;U5yJJRKxMUcDQ5Sff;>Lmk(mkx}@wQ=#dXk#u~(lWU4a#*-l9`3(q zg-1i5?FPer|5{guo^c!n^^s$EV%K6bu;5PSbPB0yMFG^$jW+?`g5!d4OS^0*ag!c* zfK64{A>kK1=a;(8&;rIDU^m0{lUi1foGTeOh^}oq!S)f`C&$Zs(I(1y)&PD`{q^fw zmJ2tX_`%`c;m`=YsO?xXmkxDwtLld{f-KOYb#Mx7S;OeS@^dibdGH{c7KW1_*z{sl z9ISFN!Ek;X8w`Klj?g_Qj=9&$i7%q5Yr;f&a9;jIPvPUOamP2Y5qToKpOyF4qL+?V z;zh4DzH}R&^2gJBHMSDpju)?vRt|P;=O3QRmm^drsLi2G|qLswc` zSuGts^Mprm{S5RLnWDyzQ2!bq4L61daqvP|9NUlDV_TLJ4~SbjTX3}vfB5DD==l7K zyEZMR32Qlcwn>?GxLFh#slhk|@4rfHrH{rnrm^CYc;8Yk4OqR2R`U_`J< zBfU>Nt&McomX(#$oVZk*rY=MZG4q9cw36^lH)e*Kl;Qo%qmyv2mUsh`*o>5%Z3Gj; zRjlZguw$yJu?&xEisxR33@X4D1|(V10-NwJ$Cj*8OLBIBW@<{L6M9H9a)o~I?$Rwp zT42k_AY4u=$J_V}p;2y$5P3=}r4>cDNU0Xrjr{A1A+?OXWlM~ReQO}n>O>%H;I$SN zj)!#UGSaLiT!(Tk4=SiQ)y{*tlz&C2ROr7`>uWI_LhP!e< zqyz^C!?FKxEZq9Zq=#=`;R=;WNzi3Iw-v6h=f3lN_A2+j5^A1L2={D!ol8-|b2qt2 z&y`J_K?_O2!C|yA-Z^oJ3-*||a}!nK=`+tl54T?dLw0c`aJ*$gjOW-cZnnZR>>W<6 zfQR4ZjzG$8&ZgmLHVC%v#{HwKc5^OI*n1q_HLboGaB>a4W3x%{J_=q~m#d<~^<{nnSjw4(znZAji za3+uG6Rt*~Lt9M)J-pBm9qS99acOY;D3<^?k8(R;?J=ad{c+^m)#KdHp07@DdlWK; zg?qVhID7;j=RS-Kg4IJ3G!Q>DK?h%-;qO zxaZ-^Gu(98@S@QG#b>z}@n}0)&UJ;V&$*{OKYq^jP^d5` z3U!}xJPiGkTLC|O$=weFPlrZrRTT~@X0x@ z3vlPTw_(5>b0n;o5FP|m=9mp|^B@Zj6# zo^Vcuvz{9{aSZG^9~1(Sm$?S~8wuPRsJ+772RFme%&fS=nQ6TcIB>kXctZ(%H$k%0!a*()>9X*Ml^+n)u+h?QZLR?m5o zf8fUJ>E3R8O}^|Zac$Hag*W*w{t1GDQj7zrTWeAX6X{KTTP{T!Szn3A@HdyD`hN{Q zY*pybhcvk_q;Y9|=>YT}LW(&B5MQZ>gy8Fr_#UjkmdVK z4^ZQxy1Z-LV^!&6WAT99SX}4DYb^%;W{806d7*kwX`Egm4PJdW+=$w?wLTTveiIZb zj;Er%Ip*F3;|;LkI*Zdu@9wL(*F7j{;^AJX8WPGtWe5F#Ji|Kb3l(k})=t38n0(e1 zhklTJ1zM95+;88sB){BAb9{9B{k@9(Y7Lg|EcXM(FVN6QzX=AsXO4w_ZS;EBUV#@R z|MM++ns+St{w<>p&Z{E%)FzaR@n?U#3-A1z z5TFp2wI)8QRO-b4Srb-o6J8eF-G+=8Xd`g3i@pSNPp@~>o1yE)a6N2}2xaM66?K%< zL#jI#ixiO1`*}Knt1F&)9_zwOan^O!zo!6Oj=q6DB0cSL^`L?+8(Gw0u&u$pHMjEh z<@%16QAx?pQAt@z8BqT!XYTBB3@I2a-aF;H)=s>J4EJBx$YY!(Iu~(LB~I zui&ws>K`IB$w@entuwgn3=Z$R;pm@@$Uy%gO}(V37nQ;DWeLfYg9hr`Dv-PLN8_o`wS)AB6;M^EuVs;D(eqfLp}#%@ zc3(o@-eQP889}ojVG=##hv?fWJgbK4Ur|8*aQ!QuYs2+_D0N&BTI3oRT$rj)0CtrA zEL<3+pXaF@t?x=(sUM|}0nZF3()0Nv`Y)6!M^!&?bCI#|^-hBUx;?AMTeNKYP9Tgn znV?O%sRTN9j*Qkgs_qGpw5lL>-Z>=H5L`oqfe4? zLF(2z4QMwHV4c=f^)e~~g1VwnSdX|?K>B&!u45di?lO8Z&jDE6s69HsBX4I=4 z6{Uml(6=$Qr-*`1aI-4tjaW5kmNAb;?XtWxwFyS=hPA-YU^~c1gnL`{i5E_E74waW zkX~ohC(~~DJVIdgQaU3PH;=$VN92Q0RHDxkD_Q?bC7S0%o={dMw!~z}*RiPmcw82J z<6Kr(;3cSeqD%3Qfrv++FZ2}n{Y4!ymX~s&{@7@GG+NGp zih?Z@E5g7(<+vWb^8gcU_EOapF_O?4wwCChGk9&D=qez`t~WLL^hK$@7zT7S-sh<- z)lXMOHe+*XE~KsotzcfQF4luL;Ehp+ID9=9TYxoACT8g4Mg&(T%Cda2U*4t&U7j_jLBohx4!*C^r$Nyq1VF z6q>2{+F^)32;O$-H>#;Xfw8kb%2QXXKcj$Qll6J9Y_fhPq>MIaX`S@1a9Ci#6up_H zYXy|U-C+C_eVp%vYT_qG3^1qYA4c;~>B2D&ovPm<{cZu*rt1H}-!Ec)`djY_nWo>S zfNgX2iEweczBiV2o1l;Ibep07TALbp9UZn@ZJSCZ4A)ptg?#taLBx~#BT|SdE_5qq z>Jzkd;Q*&Q?|IBwc-5aDIIKAt8y+6;sY(hsd(PBn8N`4TvtAge^u#L~=i$|IOJ?eg z((FUrgblZ|&CzgRrvA%}KrBe0H~>QPRK74v|0B$QN?!)&-oxFB5wrE?;J^Wc#k2Lx zwbJmxzzRMR8jfHlFzzXR$bA8s)=Dw9DH3ZtM~bqJr^ukyY<;nqRmDpttaJ3s)fyU< zRlwF_Q#ACNr!S#)n1#pY>$RRO^YuH!Va$vAmY(S^=^Jnhs!Orw@vf zlULL5(ld;RW^m#ZG`$tX?9%sw@oj?c3E>&JOK*-&YL%XD$!UVblHN+hLuZHOrO z@FaLe#TX0+y&d;FbrLIF#`h^AY{||d_0$o*g{g1DVFL`-m?tAwQnO*{f1d@<24+06JC_|W> z5W|B!AP^Erf=Cqub)G>hTidEwJNUKzDs=F*bs$i`wblu$)^D8v$2u`+ZLR&P|Ia?> z-uv!-?*(YT{jL96zxC6#!n^mLv(GvE?6c24`|M%liq7_p>pJFQZ%pZ;F^(-VQCyyd6-csp#%R2?R zlAe_<$hjd9tYY^m%j#qbp54{{Q1+_r<&F5mx}hJDMPH4W7gt0W`2a2 z&s-0F?zk0V2YRiH^#xKM?gCAoSLpD>n+hFYZR3bJ(G8H7FZ!0lN%eop&&g}WVxHLr zme+7rN!9Jm4jc95sJ?8L=V`|XuaEY|9Bw{p$8Y_XV_b#-;e*>9ZfTE@0wG){2U2J4 z4TFq-e!HW53QGsWXz9xi7d6i)&W$hmZ%5EU*;y`?j$VnNDR+ES;D|r;wqt786nC{R zQe5O|6YeF5A-h1k{q*+Oiu}^FFY$Ixv;)_`(Q#g1eAkPP+>Bni9Wi3JXd;%}q2Q1> z1(BsqdoY{4Bnt7+jL@|Gl$5v9T`@!!>|U*N3c;O(m}7^Eoj$nCRxr%yr9A&zYy@yf zORi7%_7nza_n)vKfApCrzgXK-wLp-u)&<<{?lzbVY)0IqC?@s0YkeM%J*gbc-{A<* z|6Ev*H+~U^QDiyHuy8>Bola);;;jMMI42ktsNsC5rYGO8=H-ZY^qn=nQtDfz+RkKn zdUQ%_r}T5D0Y!R>iMIImBw=^Lq)ho8I7svHiFOqj?cfYmRC}78lt)myX`Qbs83c@9 zIc)F(kukEB-DN~CQU}T|lsbhZ)0&_vD8VIyIZ!KSQRoi_%Qujhz^`z!CQn&uVed+T zD+_^%SN{$wls5$Zc9}ck;{fV*?f9hQl)N1fwV6DiVlt5jpEOe^Fj=bP#0Y$ltsF)ES*! zGkSS;(u`S91kWZ8AcBg_-7#rRwBf>>$HGr|t(lJP{UW8i*HUe%VKyVlEe(w8UZH`jvBcQpVR$!+d+(yQ#oWuUzT#ot?z(W(e$Ry-LB6IOP}! zPF|)|cF3WI#BHs#(6(}Hy0@dip9A+DocAu@RGNurSIhPx+=<`CHeJhSRFF-ISa&8UH5Qwo;mI70{H@^r_Kgg+vB^dQRyu4B(Mdq3(FZ)FO$4sC)2ITXRM7L%t8RZ=2oApSM1%VtgHDSN!txgOwf^R9i(os za++%jd=OjJQn5i=$90+jWPO9vOD}Ut#uld6&-@N->!^uXn$qVR?wUFPxB-M!T#H8R zi!DVht}S*`1%cEhma;r^OfbShoL4urpQ-Twi8--0Zi05I#P7ns4m^cFSp5BWFoCP?aA{h zy(b--uK7hsA9hPhI(e{+sCPy0@hNr>YimeVFiZ!)w2J|1T}&&v@Mb0UNP4@mB)R9N zR2eckg}$224e*)M+J%&AMotZ}n53-~Xl9{>0(d#o4>}6GrtP@*WZQ8n1Q;WxzU1IY zr|O^eyT1EvT;Gd<#?r9AB;rjSuoYmk%#vE(f>2DE=D?u2#7o&xBZtHZMBA%STvCWE zW)?B4v?8bOfVIOq$X+dI!~Y*B;M=3A+Q|A_Dw>VvH1koL<#DsXNKHrm#dY=;Gx?j= zw}Bz^6wu+ul0doshNsJ%>4jH;kOzgx8c3X9g#4%1qKs}^XjYOatM{}@FU2b&!TXY1 zszc<#Zp1sle2BIN8!M^X!ee<7Z{+wNrBpFq^%JlCuSy|`M&Hls)-mB z+B!C1#l(o4l16MoT$QOE5f{BCVtxZ1Tr=WiR@1&*k6LK{BBvkeRrCClP47iZ=&xs>{(mZxdl!`wI{8cwou_0e5_cNSO4-zcQL)fzD47#}Z{ zZH!22V_t#`Q=8GKh?^-Is6C*R_DgF=&Vp$ev-@vCeCf9xL>|vD@gJRJPK#JBxjE%RHE8v_9o88Y$dQbi^~A@Nrp?z*OymN{$r5 zivfwkFFLACRK%8Wrbo7iqtaXRJt=Mf=XY_l+5C91&6lo4y6G^&Y?r;~&ZVNi`NK}E zN@g6Ax@mrw&!1oyaxgu*Hctm1?%m*1=-G1$3d*djFGa$kqA&bqy{A2FsSAY3km#amht=NH>4-g* zB&PRT)T{39(R*+T34rD=2EB&=<}dnJ=wX5Ec7hB{C<9y3``#Z>7)v0D4m2{b)5{so zk^~*h{rA#=nEHBak55hrv!N2DzHQH?ZBw)8=;)!R z?f!peX<#Y;69X}@ebT;H8^uih?Z3OVI-1f|6YNGPy|uX#r(!zvy2FOB=KB0G>tjj! z-#(OdUD8K#o*DBg&Zj3Elp%R@zXcS_K*S^#p9}!iPj^)eI;{Yn_mOd#v_%T@F5Y_wSnAU zOmgnermwS|gM`yWygJ9(qtdV5@px#W&uPnqIpD4t9v?mRyZnOq<3-MgJaox^mvfL* ze|OG7c>Ss#+#l-x!&1&@X%$~+gUcT#_fUB6tf_LAWKOWhzg6RWB!lMGIp@UvhA?8w8s0lfGg(eP50}bwG{a>AT#((!$Ck)NM{G0RYOj@(k?TT;z z!daamoy#8khjT+_y!I>S-5KoJrPATAF{OX~+Ic09q~!LUuJM`W<+mSj4dOvn(fSwQ za5OXnxwbJp(_{Rb8LpxXVFQX|=3SYtDe*TlUBRG{`1Px>>#}?peXo$IT)$D|nqYkE zQ(XRlj$iD;ZLKqrN*aa;$VeOipvZMr9!>hJAUC(O<4kxqQ+S{&OlJ&q4VPR1_Otw2 z-&#T8@fWuxsx zOx#I2m|8?4<>VVOevQU^5NfwoxIi)hy`;9w2zV6zo>N_?f2r-je$8QJ^cP$de(IMX z?uW1x$5>!gAUzYfEU!u9MO(*89Hn3)mHYv&AM4wro3;0}Z!_{s#h%L#k}}vmCy%>^ zP!wyaRxJs)%+RnhTbmd*6p-!dQ-!#^diQGeceMsIe?u+JZnz>=X-BIJ>?;~+ zzQhxzdj`4ugHhV9;Y@^ug(t9v*hB~bEGGI+ktt;Tl%7lV}5tdyqf z;;nDR;$tHjc|m#RqIls@7c$O&Jrxd~-+n*eODzZCno-v02-2bZkWbkYbmhj&hPkfI zpfBoO1r+IX_~MV&yQ&Igyt(zAZAhq|F&ulsBja6ua-ZS)!o{=LCCq-BkSBnm=h{lh zv&&n3rqskEyH+bj^* z9jLq=m|KSh01&2Xb<42Xy28$zT7y)OD-;)pL>SQu*ue7rA2MSA2Dgt0F_b{MIs8 zOO6OnM%htUEiGE+s+qc|bK{ED6>x-N_?#2IhhGTy2oVRHpBPcbL##t&ixC{AB=ahk)##VLqY@UszI7mjo@@7T5_IrHA1Ufj%T};bXy3|^|WKzy-uFz&pv(5FQ zgHf+#rE5@pd(_pEiL{rn3>DUo@lRK{JejVl#2dIA()_5a!KXK2bY?uv-}p;V|B}>r zb=N;Q<&APst>ejhN=hSs?M5dsIXWa_* zdf^SsRYvJ8>Q(f6SCFH)zdA*eQ}z1EJr<{{`f5ASF)g;7GemYt3u89mwc?Q)+7U$} zUGI!(ORAxFk}mIXO{6ogc6sPK?XH_?a);}bNDAmZ)<>)%iEf&Y=!{D{T;*xI^1nq? zsoreTP|U4E=?PnAQy%w!88LAn<~avFd>dHl_KhwZ-MrVA8=rlttD&+%?$;bgLd41t z3>(|vifC6WTV?V*7)7ct>;REBthEK`_z%7L@dxg8-D@vro*KJkMNCBQmb(a+2izj{ zcQorKu1j;}m-rJuaa}X9a9&rke=gnJ03VB8Z>jn8qxymo?xgS3@PRAbZ?(vNgvvSo zNB3}g=#L21^xVVFMO6B-yCh!sp-ai~rnHvu8m3)4^YdtZH8L``9d*Gq{M$$JhUCJw zdgZ*X_zQOThohvw&i+RCe2z*GXmTH?+$ru#eyE?~9v2pVI9;ojCxRl1QxM+JHB;PA z%kQhZ+mpWI4XvN*-av<^x}ywi`ZRZaz78x((Z53tyM3B_DE)exd*;sR?j{J7)HK~) zMH}uY^TjWl?w*wye`2Ql2N|?_mU{ynlA^N_%m4W~ZaaNG%l&v3Z-2i!OaD?rGtYKE z?tl^Ms^trXr%X5H&vyTbvS+*Bpd+*0d*VChxDREG1d5gT$L$ z`G$6Uh5!VS+uVgaZ+GX}IpPhkkZERCTO)r4rhlGwFT*F==dcxuNxsvf93K>rVw(%su8&9$Y#A)hkyM#f=U-B(f zA>Hd?&=0fj3dEh*Fck5-9(=>?jX(CZ``h+@m&5;d6~(cN_Ip%AnZ`$C!NK`Qe8YS0 zyK_#uraV6n6vXR4cK>W@d_6MTWzd`To}1z~4);8qO@C87PAWSBU;V2`dz4aEsj$mJ zr$~_}4h(fG+q$}YgfL7^uRF`**NpM3D=M#M`>}+8pLnPP=GHM0y|chm#tsQBBN3Y5 z8IQ+Rm?)&5_vr9qPYFHybB{vBzl8(pp_QJJ__BqbOXfM5kBK8Os}tzp?VgIkyxkeE z{peu`^}Y9S z_^kMkf8m*%Pg!1$G4T}CDnH+gR5y*8IBnd#rzl?}3#MgR2zU6$y`Djt7OvE_-*do2 zU(L6<Gmw!}xQ0iD3!iWn!dD=cBD+!#pg;YG_iX0&Mfpal z`29cfew~qcrXT%>_ZNxB_=OL6znD%329~K#bMEOXnmaxaqQw`f2&dHm50dX6_nvnF z?bvTC35ab6gur1JY9hEKinh+{Xx~iR<|~8ZrDqo+$MmtG&ODmfT3D6{$d#{`tETPy zZKYJ^QT)_Xu9nf^|H{uz`s%W_LEdMfHK{+V&=ukDn|BUS z`TinhXD;I6-CJHY2A^_-A%2c?8rfHp_Q6{q$osNLv|D?ilH-EX1jvSzfdi&J^czn84X|;yJfG z57X0|lrm}vyFy;m_vrE%62#L-n-s|{W6bEV^O-B&dWljiDmsm?T#fc#g4ug8s*H{| zZdSSlvYYa4cmnq@+?8}uknFX3_uQ-z)o2OL8 zU)!qOYomr66qR;ds~|Xc5yHYDvQNK8vajxjMH`~jMM_RA1p0k*eg!SPG>~7b(VieMji=%`#pKic zD-?CG3}~!f^ucBv3MkomGZiC(I2R5}`j#^)xuQOw^w{y@B7w#JFlc4p`cS1xHFc~y zo7Xhm8b{J5yd^zN_0aILNFg2WbJ(V&OrW*-^k6M-MV3CKppooajtX?IFNXGLcaJ$s zYt^aQ6w<1mg5~kD(|1j=wjGc=umQ*gN98{#Q+h#-T4F0E3Q)4XQgxKdQOGLYdMejh z5>P^kUd`tiIV!zkca*QB@l*#V=QLbdF#RBMBIt}x%bZ|Zcs1!3p6sSzjRyZ=3Z#9< zi$hKe%b-1*eG2m4NO?izRF%-J3>Q5R+>h1pypTknO-vwt=|tKQSzbP;!ly?HeD+?! z;|$<1yohx{gh97w;bfwtP88x4JywnjUd82%Vk?=4XtM^8X2y|@(K416ba47#ozsf3 zC8e)P=D)fO$1UqKB$pSnFaTqG2k4f!mAvJmd&c0zQ<{APeG@!Uj3sqH5Ftv9P9~^A zNK6!cEff%O;Lg+=Ge?2rgnZmho<JQx`xK28A!uN&>_pk zn|Tt%zSDcseMgu2%##I>0wbm#>+CWeQxtn#QhmunG5Uou${QF6{~th6ZxV{EoZQ@> zWD=5{L*#HMw__UBm`p}tQi8a9^5iAN9tg4K7rcpLLdWzkmLx&Y@mVgYf!L+ESDPle zM43n=VJ6pHnxIE6qRoGDsU#}lb(+-Y&&n>eVa#Hbh%hj3}+gP%xOeqOgf&*jt z`o7X@Kx4tx3M?&OJRP70%teytS;1P^ctb21L%PBX!i_-}=A`75q4*S>G0cR;H$@sX zAgdxm`+)<|i8m0P){Wxx~H{u^=xML8ybwuO@7dk(;p^iyTj)j zEXScKA>+DOf$5 z1K=Q@y!**T((hqbB!ipBcu3;M%tS3hw%*r-*bLBY`YG9xc?+f;pM(RWIJHs>+x?%8 z@Wto8S*=5d5@$A0Fc6H*vH{SM>av+r(tLn(>X}jiMSpbhtO`;MlB8a$;g_HAmH(j( zuc8c3g`WUZXANXy7t;55YF?}c2g>PUIEF4A4?0Cj*^cfySB+%hHEn$}x4cmk-Ze2O zxvGpCBhL=7Yr8}k1SZloGn5TQ9^VjC!y7w9Lj&K8S5Set%#T{DRa=i ztDvKO{yrrSmlyl)Qvy_apWwCIc)nS0>S_p%-<Rheed*1X^QtLjYxWL?-gM<8o6>U|l#HyD|9Jio5mLtx4-{VSd zzCN6;olhu5RcXpfD=rgM?g14%;SJ?=L@#cGF0qr&*sn~;Z!sRfxnCKO__$}k64bl- z+wTB98p@#6=eVD#G9UQz?f_6AjH^d?^!nI#JYu8n(aa!v@p!mLV{?7 z-kW9fq#w1>2|c@$xu3M>McD3tRqAsNH4jJ+mX>%YY zqG4o-AyZzy+fi7DykYfazlwSz*0hLqLSyHc0GbipRMoZJ4Ym8NpD8J z*0(%epQSCPEx+{!Z1VTi1gNHyg3^yD78>My6Pos#r&i+s`F%=Zy!JQBygYH;sL@_* zA>E?bt>n1jCR?~{b*z2;LcUY)?5M-t1}qb*_?A+yMt9$2s~o^Y9Fc6Sf@MT;mXkKd z%x7U(Ey2^*JvN>7-efC|qycWJ#n5XCW@y%<08L-|{WIf_KCSF`(MPW+i-&4Uz;uU* z;27qENJ1o``K?Ga0E2%=yyaEpwG8^`24p_y9E+D{brcuV8^1wnhqbROf5}i_8$4xW zTYIb4`KhZnc2H9cLF~65KvD9OgPH`6TAh+I544j zQ71AD3%S(vQf!e{-=t27wQ~{7-E2^rcuiMi6nV=mhuXwP)PbY~`R)8e$|NMy-FZkE zuBP$|o=@86_Z3r_)0gYiC{E*d6$^?7(v3%y$uwmK906A-h~M2>54m^Z6}TC^<5Oj@ z7Mj7lxOk_QWFU`*nz(Dx>G3|pq|8pw$qPrf)nz!mI!{_Z3jk>ArAVmzaT842XTR=4 z@H-?>p=%E*j)5$K$szYo8`SibO{Irs7dvRd?_ibw{UV>QUYu#gZFCYPr6|*dIAy1W zpDCA&KUGtrGMs!lt6-h^cvOumOGpZ5`hAmW#b1?k2b=~Z>ib*?!72hZhh_W|6}YL9 z@l~HIs|)D;EZ^+a7W#oU9dv45JN<2GhBdS7tCU3Lyz_3l5Jp2AyQf6EIM%2*Bart! z+(Vz8Sy7JPvI5$=O$&hP7hvt|DL_h+`#@W{xQ?0EHI-(%d=c8^ z@MRB?08%lZdL2ZET|U1w%4pHc)5POSQ8&o<(v@N4Z(K57Z z@2KIXz!;nU&~a0sxHp+8uQe&LMUpVc$;fKAx|3tdS7=p@gRkC}V5)WNJG*=4$OTz- zsa9*e_HPaQBt_RjwQ(tuhlx>*$Bz->7bg@SFL{gUUeU6sITgy5$QGs?q^kjfEnl^< zn<~?Zk*<m?rz9NzyURB)qfw&HM3l))DOKNWDhw+xkWDDh-l9?7KU}_{RQ?Ls zIIKQ$%9DYmTo=+AsNfdle=%0JNxiS=I%XkinFw1r9AD`1ji4cJpG!N$n);NcO}YG< zy*_o+DaV^myGvJleOFR`p>G;CyV-@lv1eK|$7XiR+9>@*W0iw7U5}anbqghqGB%Au ztAEy*P>jjig{ie=K-i}X!37Mx5w$5khtL^OmCrXhBNAWf^F5L^Al>T5zHRO%^i3Kx@&@($wSsT>OqYu^EKrg!dg4elf#dbo zZzCDtxyL*K2f8a3uh zfY(sWgpi_=?+>*nkW`%>`@C3nYJ=8<{{yXsfoa^KljC)oemR?@#I$Y|p)5cmZy3R8 zj3wnTD<_DT7CrlzQb8?yT)EW#n*xMa{{*4Cf3O$UaT)E{u8#c?e%i`jsGat|h~(ba zyrP^dm3d{gJ{PT@RE%6ie^8VhA(~SCpOkOp%2PFBW`R5X?uV|zon^j)v`P`$R*1y3 z%3!sUR=uex1)994&zDMF&*XzO#zOQN#eV(6|d_*rsPEB7rlzgEGCDqKT~E=Zzd(yU z^e@WH_~#>iFXYg+3BGWA+1pSp&~M&RU_SV+;&+&5nZEO`viK~%&tHjK*jShF5w_Yo z;B2LTk(1Qg$vRO?oEcD^d`m~)RR+(NzrpV~_={c{6||bT`Z2wpY;GD{oZX0xCg47F z&3nq2a_zDdS2wPm95Y6J4*iTkFL)y|4TtqmHr39I1P5CzwkI=WCLb0bPkCX(3_Z-bzrQ{YQLk$>Aj|VIc?P4`jWKD6M;8JHKIMV5;3(4(*lGt_Sr2@6=-H7aaVC1Vl_t+X2(Mc_y0Fr-9aisg}rIK74CaX{~> z*$4}xg@3tizTf3eNZUefLG!)X2G9P9;vDvGvXEVB8iT$$K?fot(I*;5zzR+(!TK8Q z7^7Wi37wRfC@8U;WzG(3izF(vW|^Ln)-+mW@-y25 z88WN*jk@;`IItQLG?$JN|miIv|NfNEK~HbqWBH$ z!%l9YP6EPeRFPzsD&bb?5-x6irMB&4;w+>b^PqGIfN>{I64Q7Fvn*LhD@96Yod@4%{ z+VK>e?U-c*`e7Mt>@YrYU7om-CES_UnM87Sl1ug1sIeG<=vE@#tC3x9ZHmK&RhSPH zN*whhtV^T=M~!}$i@+!1Te9Z{f+a1CMY~q4#{DMk8|X8^3z+QBDk+ER+E%D7pW`y%ikOyJ-At*4uK8b%vK zJmoZ)YYWIHn~fp^Zk@SaPd87>iDEZg*Usc@xgRO^HU!MHAdp9uz_Jt_xp&j0<4Tf` zkepKU_x^53tEhY-5|83=jfnXDovUg0mBk?;>y#&kpv@rqZd!Np%>rwR$)=F2lWj; z0*s37i4SRfZzK}L$Q5uZ6sBAaRwwpL(_Q!?%}Cw6c?n-cEr^oU2b7-Q43F!w_Z4Tp z!H8)0VqXL~R;1yJ#xG1$tMLbO1Nxd4jbn_bIifW83W5`&v4Bo!OoQAtjRNUJi$^Jz zR{`*B?TO70$23#-sQ!JWWQ=w9*3NiIFHPqmPBg>EJ!;tD3u;W=1XG{3wAz)omHb@U zZPB?U|NKPip74?K@|4ON!I< z@s}7=o5~d;<3*7Hi6Z(ch%VP>LhGU!?6{Qvrn!2tXdVDX)S-u_t0g%?kwnq@V%4G} zsP9iyJE_uUgmr#(k&UTG*RYs0HgcPx!x#8rCRXTM+N+70|NMxm#fFepmBZpjKF1sn&W^BD`%>Kxj;X%**TOlX4sU$)rQr$-Bb(% z(gz_;WQF#PpnX$>Masy8MM{U2e|IkeBI;6+48fX0N=eyS*dY-BNh4OHa?)nn9}IL~ zQaP)}Y1_QwLGM>tvu(%L|Cn7CF=0mn6YRZ1dXZ1RC_q*bFvYN-xy)PgX+fZW#t;Jd@|km1Cv8;Q{|_`TOMLf_|hF(^s1L3vC->4~wHo z-dx=_oHetF$>Vmkqcj863`?sF8b|~Qg(AvSSY%reYa&qsGnzzZ0BJzdzpm(9w>|=6 zB6xG-v+44_t4{A@*CN_J!WL|RVwopFuPOButU^IWsj3w1$@jB5)^DU}hI;@#Kiid0 zJ>Rl<>`4Ia8bDO1wkL6s_`~1&W_yf6lCTz$cc!Pb211=+amJczFc3T(Vy?c@M(}T< zCw*_x&fob4(aXQ{&7jgqfzxzeo0ntwu!`aeAv-$+Wvg|tB zi3m{lm1I-h{kToo9rc|{2k!Tcm}YcQE=dz{aQ8&4*7X~^SDS?ktAQ1INym>P$Kp*Z zp|z>2E4C-pGKfY2A}~&Uv@GuOHSjLQ812!PnXzeh=v#GiwU&kXMLE2YbkjZOXpJoG zue4RPVCI~d#M5u`U?;ArT}Al?^hr!ntQZf_-bWGDwR4QK(m4eN>;?*H-?K5cnVinv}C zINqQAbKme8+R+Ko+mHsjTh0at5;JYW5=H!yg+2t(1(xs z>P-DPF#x9Ao0q75`uLZHb`w7nvxDG^?a}q!F_uKdZYSRA#L8}fDI@^m7-51R{lHi0 zGRQdQ94VZ1HW@s?&b<;0n$3F$1w$vBlIfx?W& zC(!&gIA}~-rKmQ|iI)z)k3daNKI8Kw#wHnRVnR+5K5Or@u$yV@a^wy*8qv-ux@JSl zh-O_=HGN}+vv}u)`MK4nT}fQ8CS!K{C%%y;qyhO*IkH3Ffe-C@)HvIg8{fUaH|$dK zJRM3KHt)nEz6;{3p7Wg-Amyi^z5`RBOnr3<;+{rkJ8ii#Y&LCM><9{;SMsiJ+faJ< z%7REfuOl{GUqriSB7Wr2Z-#TJzR;gdzr3N$N$#r(0yMJFzlSOx0}nlXYhE_3JL)W= zNw?+Y#S0YwluUa31w=MH_XwgF&hh&<*kByB5@%s58LJMw{h_c;>DK)2O#2!gc^~;9 z=AGkH9a`~j?t>7K$X4c8;-CBd&t&Cx#a487wbH$>tZ#tm}7(V+T|DedX{Y<9cuF1CY#I33rHC}3)ieXXnxSiMZdNXcd*(= z;h#nCedciuYSDm;X4wH`@p^Hg$r=%kxFH=0)))J0==F_xuIwr}8X;W)9{U^x*|r!P zL3DP-Clvc{%~&jIik=8TMC%P46S`m>1alA#$+aRFb_}sj?OKr;xNYlRZ7GAi5aLw@ zZC?vtgyVB;x%5nle;sXagq7%jl|waiSIBRp-5X16`ebZ<4NEWk0wnIZ`8CBxuSNV7 zK`0tnUPzfD+A%L*&6g^#SZgzNl%kdAk9p?P;~ydJ@bYs1gbarTX)vHI5lgessAZs= zT1I#S(5ZL9gNf(A&cfhZj0)tcMl%^@2>7?_X>UpVxeEV~47&F=7zAE;KIr1Zf&P3d zD#HjiHTnHnZLLeGp$6Oky5asjT0GeA&cq?kJIG&}f#9Fx1HNJ@p=yX_)I;dOEHcO4 zLVq3LKS+xQ`90J)$nT@Rl`!sGxx_z!-8*0wILKe5Wm)Kl2XXw zlcAXqMVoAGOta5Y2hwMw&}4LpzlvKc6piN_)JE*2N~8bah0E?)DiUT4@;^-X)cA9& zEM0*rPooeXT9s*-)wH|Pzc6gD4Y?)C2%%DiitizMb$q~1OD7>4$C>BAaQVB8#tDPb zopXoyV>EEJzmnb>;;)Su${LQ$z9_bCeP>s+YqQoi21dUh>c6zOyG?lRHsiPe*Rs`Z zuyAABDX~$+r`Gtd&!rLfzzU;pDhM-sgnx!jyHciO%l&1vV{JjLSigdrtJ5r8eI4ja zUt>Jm&JTxdntc;RHx$$)pj4%SqAj>2Aj@X>0yTQ9A_@33XjPTVN7K9-n4t?-hf9fu z`pfC7<$lF7&RkiAqU|7nXNUOJ_%}xQ54q@<*Z2m+cTe@-=9liu+Tga9V_B_Q;ulUw zxzuqjBCq~viNA=-F7Q8VDY;?4BNzuo-JSjLGJjr%e^g{hWJE(vWD|Q*S3?}FSbs?c z-LpD8kk%FYZMjS{hy*z$>L1`VlTID2X+v{Aj`~Y>4)xozxg32E^|zTz!BMHax1`*G zB@Mf;3pWn0A3mDyUG6`FzHaqL#Hb5cQK|t(kVb4T<*`!sHTP)I2Espf#8O( z@Ynhb)EPvD1-fU2|9S@HrGX6D`I{mSHBSb4{;<_wlbdLCpk~@?G)?s}|KGW$hxRx6 zhtr`m5s$ZPCCFL4YidL?y4@4~x%8Wr{xWY$+f=?A$CJG!D79>~w^mx-`L=l727hTdtEqVw&A!3^2l1oyMt?K^h8RXD}OIyl4etd5nPe9%c0I4~L(%Sd3-6$4z>H+uX0fkN#Wq^+Nc zhzrtX`}_sj{FZk2`GPF1qf4J2AZ0N3AxwqnImaQPzDoo3G}f#BA^u{a zI^5yW=MDD+tFYKR=)_|<9=DVtLVshqYO8C(7BXF*>?#DeU}1!jH6Hf{s9{euPy_J$ zMnI{sYrj7~zM)LLERYZ?;~$S!voq*`uP`?r9IL*YiI9?F8-%a=Iz$!taJ>2&?VG47 z^vw#ykM6rk&7tPGkXg2$q23k0b&~p7=5V=fVu`H69^E~s6QLzw7m3|^QD;xIoxP5$ zx;Da(U_p$}fEp@2#w^XWzaNJK@A^w-C>YCUwfunn(KwvqP2ZGFb50u{<-SH)Nk>B%vF0bv1cXK zVHTwACKlq*J3;fGgtOV#|Aqawun(ed-EYCGADOQKrPSfZMOE6 zr59Ztt9MC9o1tTYkk95DD4SG7)2vu1*rIC{m^L@*Ws09QciQwt(-+K{HMeQebSjUk z!2#wnDMiq5ZNmiGa}zw0k_)0o@b1S3&fJ1S*BEQbG{M6EUq`VZBpt7&a8|qqg_c7r zt*)q>S5CUup6vEEuV#JLz4rb{Md9XxUw=F5-gBG>&TWJYg?o-=VrE?3Hc<%Pj)U z)bN@|S;{Xj(Qsj=NNbR+l(msU_qqTtVYdt8=}Tz--w_dm_m}v*3)Gi9Hdq?ro^~qT zySfY;txExC-*x@2j5^+q)( zg9cxvdh#_s0ttNIRycXxbg^1HMt9Ok1DV&0DZIG3|5bF$#p)2+-=nG-TjIaGSesz%d@Z?d2njtd*RCV*d-i{y0&{gA}g}VB5k-r zEull+{Cs-yYSo=6>&2qO5#HCjSpE`K!~CY|NmI{8SASCt8TF85Bl ziK;oGPtAdT_9y)dvcK5YQ0&Z$v1rmMwT6JnRtAy$BRTwaTV9lE2I&~C}559%ff!zEk zZ`2Dmc687~v2Zzg7TJnv(v@nMnyyo8XhVqUZ zfBibOK0D3E=)75_bldnrd*J-|m)}wk*wR#b_Pc6TPMY_h-K$Q>OMOrE52%w394Cty z39cJo^MJZ3vywT8J|QP5eE28o=XrE^WT7qCUupWrM`|to&o9*HDQ^I-i*|nu!u#Z5 z_43o`46Ti;kDo@l_`qMPL$gu`9iR7z8Y&B>6?VWkcD|;n@vB}@%TIf}KX^@b=ZF{} z{SDW^Wc+7G)b}!lw_tx|88s8=>9^JJDT_tu@xQ85*-5v(t9nld zU-!JLewle11!>(!Y9RjL`|1;?Tl(3P59Nr%TOM!zSk1}ocN78YJf20|L1*8hmpA zDOIiwc&PT;z{4^XF&<~rd#@FGsP(!)6{1hZ=5AcK93iLZcnc!e9J(%$M}5}?Y%nN= z6E+@$JFgEE(JMa*d+DM7QC!)a(UmU$8s4l~2TKbXyq7+@r8tk?xDip6KKa;QNXLF% z?4`@D4@3v!V$%|!WhD}lMSCiwP5`D4IAKE^?520F4=iP~5&e0_4T0e`{l{oYl$0S? zYV7fCHv~3k#Q%O{U`A$q(k+3F8S$TP$KQNT)zpD}x;^Aw=~UuVZVkNGNOOJ_ROp7I z0bFap5V%p1TwJ7UL$ou&1z~{uz2?L@sW{ss2|AD9vn`4 z9|?|$Pdgg;19JRi2D9l?d(cZuGVy17bI?f}2Zy}Wm(7n~1NF65wTIl(Pd z{cKRBmve$dSLFs&bYf}5Pn9;nekeCMg9b*?!1iN-Txzxj3+z&Mv77WqdKMqc$$tA%&`hhKYEKj#1r91M1b5yt(r<>oyKSoc`Kn~1>k){tMxg|n> z%nMG<#J`bfWH_CjAN&O!hyWqWZVwKo!}&TcUMjDTsy1R{athzeAQl?O~0(xqNG8KNr{|zXJ$~Svvk1d`SQ5(;M0C!-y`j0doedoqs~=tzX<18Xdo+BB*8}q%Hs~3*qHO z0Z`0$NPm2OARa{r#n&$e20Q8I+w`x!gYb3lAS|v2_}9GK^$)iM@%Vf&sP3%9kH$)r z7|Oq%pAo^uLuIgtnnQRuA%u7Cow8P#KCHwPzs%(VgYorI{<^*qHALIBgYg&{qBn6K zKTf_wf1DV`c+$IjPX6kL`u zB90e%85yJaLrh~*O(ntaW3upO5EYaL&!tO;z$t76Bm~l~d?pP2I7CdsIII^{nB z_?N?iFwZc63vK|$D=G*oEHl7W)1T|n&!ob=Zvkdvd128P8Z}_5mlev(9MwSEriZ5d zUrz#)Q9L_eMeLTaHu-9#zXv}^JSp; zmMYA>*y#?>jAY}wH;7A9t%kNYx`w0z_}vfysG0}>t~mZAnw&TkALg~--K0A#AAZUo z)(r)yc6-R&$#ZJZB*v!lu(T#0X-RGJZ)Zkom>p-+utA|5x}gRXWf|SH@@)YQG$dM*mog1yO%J*poodx_Lk zFIA+doX*uQ!XOe$2uN|!vL?)kV8V$t)Y23Yd#y@h4J81itf4X!bTK%wh6Hl}!`0T1 z0EZ^dNG`nBjcw>gmX`!~POKqOqpyL5tFt1*=q{eeNxbbF^9aO5cWKPJ@em4b9}irv zKaK$kX3Z=*bMzQGQ4$(MUk``KAz(7cLe(AT0xDjp)H^*ijgDUkbbft3CT-YdAs795 zL~yKR(FqKR!PUQsF0B6;e?)(88;M^SYbiZ28ovY*KO6~GQFJqglvH=oC`{fPpMgVN z!M|p|z@z>u;G`!?z;y)1#BRF#AqbZlqXFf?dzso;qL|9yMMK{jgd% zerFUZ+NJj;G6qn7|59pS=KTZv*Ue)vXwN7e`Jh=Z?dJVajO|zrex3a}{+Pzmfc>j> zECe*{UnL}HR_tU4#)FX7H3HP}eJIj3E;x(?u}&I?cL`#R+z(u}Hv*_A_ue?2X@EC) zY3UE}CkfOup8`~3IVH80w46lmMQiE0CZ>K2H4T@Is&a;t+H;?Q_5^zoLlnzAsZrVW zT_`8Gh-fqk%DQ{;RV>dRrx{bnM0^EnDx`gjfe(Q;$n~GYJ49BZ2r~jo=9V)yNo0d#WKIi#m-{f%@&^@ki82H!#r( zFF9Gm*=TA-5Cpi0K?W$?Ah&}9TrORQGybH5`tA%<<5d#;^V7kB5*^ZK#N0;nkAbr9 zP65hxPfu+_eARcQl(`mP7n~Q;1|xF1f=`H&bM@P%sV<+;Im@-UIKms@sl4;@~BjquYlOx!XS zmQ(g^*n2diggBPy`!?op5vFH*J!VpT0L;PkuC?6r*JH~T<@DVe8i|Hrftc}ek%9Eu z4}%_l0BMY&?Mnbb@S@{`v9azd3K{1|!QIewfR3*Kxo!VZ$Zs4^C#j)mF!O>LzjnHh#7BIj79axC23h-k1TYm)Ue(%!65%G8hC{u8e_1dvmoFj9n z_nMHPQE`$LJrR2^HcU5p7K1A$PMGV15DRX83Dl2u|QWKy{K* ztZq$GG2kng>_5ht`=jj8C>rwf;E>GW!)f2RNFAJdFeC^sxtYU9$T34~YxpR6EX!t%3>`!yj;sb4zUgc1VXL|&wDTow9j~5; zwI?(j7DY>u_&EK1{iDED|0)(ou$qBLkWGftL`+dSZHl1eesw5JT$x|=|!)~xx^-D}Z$!#QP=(YQR@2xk49JF;6*59Mc zf@`UHG{|N5-vSD~%K9Zxzl-Xd(2ecU;7EF{66YK7?!a;|2jIV&&ZyPPi5iR{aO7?C zgD_P8JWzn&z26I+Nk142^a=7DF@_pe1eJ`jw4pXMLLE2WK6EHzF?Dw$cftyIP(>P8 zF|h9(ET;7^6NfL#4NGMVs^5f>k({S5k9Z5bNq5plMDBjWn)dQGPat z4{3EQf0dQ!wSNS}SEMM~4M3*%DR&Xk76>_siju=lTmVtvb zZiY8AZ$WtI$*N?s!$GK@!W}ndk_BWmDf(p^-d&q7PxQ9`5=I{g5TT3Y;N- z2~vJ_HKt2K4~6jIAuu7moJ#-sj{qzqXNKgW`si!<1eHZgaPaM;FkDeo021>q0HF`I z+rJ%*U>f$F8}Vl~jKmpc4b*)TFdx^vvL+aRWliYjWx}1q!TCjIb?gp?}cq&B2=MglxrOrm)F#^*vGX45g3voQYs7eXIo(47NH zo%HyuLLcpZ&*h|{hw=x|;SWnevhN{8cjqAx@53*J7Tx}6QC>zj?K^-BT8H0u+Ue%M z2QzB#U`mXzD^EO?K>e`W_L3k`Jv4( ztSv5Vf$LoimP2eD#r_pC+mmkZqP^rxY#BaMi?<=iDq~L0f{}Y{WgA-z@dX(Jsb!O< z+6ro3m|y17-$?^BI`VsDed^DEgJ8fBFq~g@Jy4<2Q!jeTsc&0h4(+~FwR_nDkgYaW z$D;7FUfh{9eQ$|7Y(D4gltFxj<8y0t-`^4WhV|lGxY&|WDBKmF^2i^I(qC__x zxeTc!mLW z`d|*7(LwW9BT_s2`3OIOVWxKKnk9K?7XG@;rQxQ+@9D_Pijo;k1~WGe7~S0<1&;Lt zP{y`q7H15K7Q%((vB7@FSU4@MfNd#okg)R99E~i5QMUrYNm}7LQP&>pSk<$d4h)Ce z%kQW7y$&<|(2g#cCC%E2!1imh+%C3k(4o}{V`V|Tux2`VrDrf5nC;5TZI3RGwNIz$ z0hmfReyHTS4AUd=h3@rumAnaBgjagzn`*FEt~{-rfQ$ZHR-bl3sxMJ|PP=A@>g%58 z9U<`aW^~XZD4q^P+EW8zgBfFdM`rCu0+rgYgwM#-en?Lz2{YLV3k4l%JbU`kcf6ku z@_xCtFNohR7wr*3m$poDx&p zR!SP}3*;GX@2l{srCpK{r?3IZMyO$suPPI?wWq?P1o{IzX@D=70DGXq6FMERAsC)> zvocH#5_}tEO?UZWlDGcm{A`+6>&|PDBNSeI2GvP)!8p?NQA=@!HIMfoy}Is=%e!GT z+ObM*np$jXeS6WCT{T5VBS0_nm*#(prn<#`0AIO8&-J;|84%sosTK<#xp8gXvK((5 zR?9xi#EL6@<}NJ;jF$DVvtt+70uv0{{xkU4>eR69QR%*7%hN|d-Y*Kq2|F)>otN-X zv60&ycF_NX!;Uz%?a$7NNNUoM5W8kcBpZR<{31h^K|E<6~duPJJ3{gQqzj7PSgwRpwR zz87s3?g}x81@mUinmv6XI=bqpvz+eff!XJQ12+5e#6V)*BH(po6I@X_7HSMWC9xG7 zdGSYj+TcLah5`^3IW=ZvGpr1SAI0GAhzVi3NqIL=B3E-;H`TYnr|YJ_=i%hAGMpd( zWL3B$Q%YCI$0j^U>3BFSq%3E4YqTdy<$r-XDAG_=P{of4zGPYW>@o`?lQTh{ZLA$I z!`yHT((JIZk{sGzh(&hed!c+fc6pJ5N`LLJE!X05i%207EH`Dm1*hXjEoOqTAQLaA zLTcgcHVIo`*^wA`OC)-PdwwW13qGO3|3=#SXiHRp;SbF*1Uo~FM6kpeZI=jF4Hk6= zRcNmBM#0ELI`NJ-NcXJs=7th)heePRwH`aUOhiCOqD5*!S9H@fbe>J9=|oO`kZ$=P zw2izUhDt6Fe!C*@&x%-kJK`aBb@vEUP+k&AudLpz8c-90GU3FuaNG7#JSqlkBjwOIv{=<}w`~7!HKR2%taNxUNG41x5G>!8(y6=Az1Qr6N%e zj~U^(2*2o2qiFs^MM0Z}FD^Au5eB>*99A#YP%ld5R4}=4nE~`(Ww@BWi(fX4JjH99 zaNmk`)7{@M8juy)GJ!T!g{RS1RpA2K@)+!w*Q?%~U}u*m6~}~=p0Oj+wg(*}kl77x zQX0>DuPS^id1}H$Gaq-j>AGaTO^86J+gS}fJ+;NxMRh*L9}sajuX+FBBc95r_|{%mF3+L1&nOH1oY1}+v$ zLrR(xB14C^aSeWlBoAUGY6}kSnBT&slyeIYlfs_fxbSXR#Ax69D*RsA_5ECJN~Zzj z%&xXp9=%x8h(je?(HXW5#1MZ)6rB!^Yp6>DU9shy_>$q!?j_z34Lzf%fY#m!!)fH% z%b`_c!vXq7MtCtD8XK+=nZa;kgq8PdZk{qW0&@q>ab(l;9~WIh$H#@|t}=xxRM^pA7H!^Ahb`8-g|k@LdqXzBUksdV1b@Xp?Z zgQQN&GRzT2SgHbFUe4!!Ub)g83|L)Wr!PLeMqNA17TXcgQ3PD7il!6*J~URs< zhRDvh2*5&__7a7@{Xy8-D}zEZh?KUY3nafo>jrRX=D0lZ#psv(lIX8igi~rK_tf<1 zJam#deYvd2tc^n>@qqPG31)*F)q0=m5^vLwlD^I_QF(|3OL&2&K`(@87;+}sGw{dd zxhczwQ?;^2V;TQUL!yeEt>oV@ax}lc1>AYidmYkibH6P05Fo`Y7Ei(p1tN>{Av!Q#8DaxoPVB zB$Ou|8chqIBad{GuLW#&&EJa#1Q`wRLE&8lDR?#64YIuLXE$fCEwCIi`cbT zoNW=Z%;NKh%6eToyfM#517hK@xt+rhXw_p26g`j#Z7nGtL!}?X zmj+UzgMJYU7dyB+`aB7_J7j)y5&=BFM)X&Dr*Lo%tH7KHNhD-yI@*&L^rn}egB1cN zTBjq;{Rz^&X?mth)R?exS#-lFb_MLHIcJXnfh$V-Z;dRPHg68>bcMfWH+#0lG=71a5a%IOb#-3ShSIS} z>qdz8or(6N?W;Pw+Im*6i?B{&UE4RJEc18QRabCIh6p)U`}5q!l=D#|MX2Z43+K@1 ztHNifz(dn2j*=lzYY;^9#yo^r|Fp>CfbPpU#86+=1rt>#$Ali23NZ&ZtPY1uOsMA2uQDQ!)@&C=?nB}*TUl|p zu11x@JanT}f7Jk33Y8T%T4MRo2W{bM^LoXSL}J3yaC!XfHQ_4*kbI(R>EQKc4dPdP z@3!z)nVwB}Suq~O*0ZszBT})1?!7Xs#Q*cAvT&w{ql;?3m)%@B{_NG^Kjh@Li3jrD zR0cnN`4GS5_Oi_dxpP5!7stqTM_646Zv+{8tV+K9|7!aZz^JOL|7M?=tdp5+v%J{? zNg$adY_dbx1Z4?}C<2C%3=j#KkO@l!zDTXL?ogFuwN=p8))i3es8ts0QWpfY*8b}P zxYX^dLj9^%YyJPuz3;twGZ_~9{r_DwbKhOgJ@?#m&pr1n-tbb6HGp-IH%s2Hh*u_( z(1cn+{v6*a&Sz9O!6LF-WTxJiR^7|ng>TEzl$#wd<;baRz2D`d}>ijr0zJ|HGJHIUXvcA&)w|H0<5NeD@?|G8UfG+Az2Y zu_jCe#-{pr3+;t{Ao0`DsG~93_^4w|j%`(Q*GjF1I<=UXOh*rRN&-oMk%CQ!K;oQm zxSQ&u5FhvKcMPV^eV&{lp;lzWX8BV}GW-|tFVV~O`FM`C#)*s?RKGjZUK=abu5`Hf zLdEZ`WYG^k!u*~Pt3>-=@C+1VRwN%YVQy7kI_Ecnd zh7q<<;)JXRJuVZ1;-YIrAJ2W((LZG))g1IJpukg(V(Hz8I?g=9ib5`=BcD4;p|_gW zp(dl`)wHt%t^^(wsEUuQ%8qY~l=ZwY+!(X%fHyk!4Of$QX^B=N1zFk=q$`+ko1nc< zI|3XFj;zl(0uv=COhQLYwLRnKT^8d5jY_BR}@b|w;iIe`-<82WB6UeY?R z^uUW@tH(r#Zu11_nl~L~l=`M)EVAgTt53JT@9FV@(LycI-P6$0f)Exb!uqF8wrD|vGdDF$CA4T@ zqO&-~kocQ3ZR1f<68}V~P&Ds+{y-}yIvw<*U*}k(=S*@AOq--DuaXQ}g^OMLn$X7i(&^8>BGcbT(49n80wYq%xv{ka_oK)E8^t@41W zB4!s3N2a2-P(-8Ft@F<66pzT%c!i|` z0tr7T&&8_&H7vLEKTECO>RsC7Wlc|O+uEQ^R3vnMa5mQJ<0C5L5ND1`ADr)82m2nU zlNMj#ypFCbMbP8?1x}NRHTHs#et*8R-+)sChQ6Uo?r7l`4Vra@r83W05}Hf<_u#Gm zpxKpG$b-i!hcE%EzdEmYa9^THoIzqcgkah5&t=o^%$8P{Rpz-`bGF@aJ%6ZaTCTq`zdP(?kcKgE)NC1J0?@$A9Mh2BDqZ zt^z9Xy3(V*-#cAt)cK-w0v+TS37KR8EH-dmVj|LInkc^X?QeOilGdro}8z0#L| zaNbXr7chyzZ#fJ9gAU4Ha2{hY*3uteaF!(Lz;|j0K;qhh=C8sm`+#%=alw5%@RpD1j$6mp{*zzopQ1Az*Bii(evm5xU z0sSnv*$T78X36D>-2)uu#$k>PqLg&zGR z$3>3k-Ja;iEZ4Ut8qkP9*#Dh_5S-(NBQ5b>s1~XJVd#1H9&%ej7OUxB# z$biY(WhtZDOS1B-)E1}V*s$uLj>E`E4LWzyHkWH-;XK@$z0B;rT3hnEUC(pCSQlMd zhIn;5w`XP1+iOiGTCKR;xxB!TC|AwnsFC7*%<7*yxuMZJcVl9w-7&%yO85}X8tM8fC6iw=7A~gz z(TGEJe4)z}wTyOMZ^=R_2i=VRY>Mmslr$Veu)=T^o7Cb_Fz(NG*6F}RCX46KR(b3) z%}L9Gpk4!0fV|!K21fbp19-4Mu*juU2CX%{c9qR);yN}}mAT!-^$%Pg0%A0&H$5z91J zZW_8E=OR}XRV;Qzq7N)~9ZsVoP38hQo?cH5)w$JN6n&%F^+cvw<^yWL(^q38&mkoG zc`IC{`6!uyXP1?oVJImgmC@^0xN@w99>omKJ{O0;fyFMH>~{P`$Uie~ma8#t8orBN zGvP;%n7LnG;<931<_)fKeHNOq&|P$Jl`A9q!Uk7QzOCAe_~QH$kJDpvM+@-TN=L`L z@j&5&-PH1{UA>tc83uIr*Q;Gi%=u7!uWVb^GewOvM!qqH@H+k?*JR=_2EwZ3(XFmY z+0$AVY7fVR_;dZq@~PQN8-MC5H|ga~U$~0Q+OO%f03XT!9;NOH8VLpJm%) zE;rTPWyzvo)U_vC@u=(G)LvFr$iVSJLm|W_sEoqPwAWyn4MHkBU<(JKtOIe9b;-TC zD-r^&^DR|-DUk=Y>{Olv!UP}|x!o{QuVJWIg{tpAT&%HiNZ3cPip4OXaXfrQiV0kL z|AXPwp2c8vXrRY2raKO8Z4ua)_MCC=G~#y_j~RxW5}njs;Vz<;%d#x#LO?lsb+J8* zC2G6`(XEf-e7f{eOO{+B6an}AF@^&$J7idpg=`~Ie8Q%r3u}>4Cv0cQzk2kt+fLY~ z%d!(F%jbFwI64tc%KvWjJGp<3Q?`EAGQO1es2{l=-S|6;w?gI{uR`dMq?J@tA4s47 z$SE^vL(p@-v-o;fbBB!_=7U+f_RU~BWb9MiTm*cY^$=z+-=PrVZc+^I(}hVNIvkAP zTWW>24z+@qgBWspsFzLuP;aP;##lGTT56>k&D|?FmR==7Y$oZ8YgI#oodl2?FK23N zM0#r$fDe>mf zJ+HW6$iK%mG}`&9>tGt6=w6!ox@#w0{tiz0*AKZI)cb}jlOA1&11#syuKE-o^}geB zra`QTj{dW&D>Z}pt1P5ZKXT>KedppI2i}J8vf~X`Pr6l?IyzbGhcpr$cGUH58qIRr zGm*fOlWEd`_gsN!+k37_DRISn-go(E=Z6rg{``S!7;X8)RT#bSude*~T9A5EzM`U{=!@(4|LgB`m;L3H|40sr9J&J)DMPKC)R;$9Qjq9pr4Q zyD0kkhpvc;3fE>8(yo8ma$_-pqCY?3O3R?Y-(4*<Z&z;`jYxGb zgNNcnsqX2t^ch57I=5eejcjRd&v?BNU|iMQsfwN~A<8WmD-%j|bwq|j)~6*Fw<~27 z)ug$7X1z12JqLtd@GnFgmZ{|XjK;#_v4G8ZyY3`pyho!rRrAE6l z-TTuT1vM?jlRAdeu68~YvLNPD%lU5<1)JfafP=3URguj>n?Js&9GR=r?)$TmzT>zp zy;n3pNwuj^C1Q5m0$EB{;MtLF)<)LWvO9+;UBNX5dMm{bMAh%+Y&s%AU#tWcP^^>U zxdMuXb&I8hP%Fq{vUpJ9%3`pAJOzEx48@{5VZ|25^dlG?EuufMxQp^hneWc5=0tHV zc>8PaX%9;aP@M^iCreBS;*|JvRP>%Q_uUAnv?-^IRyf^1u45q8mWW9uWMJ);hxKr> zC&LHYaX#`6C-uQN~lxZNLb-^ z-w}OUaVx3x)8})G-QuBTPKfo-;SSaG3H(7s9Ic{{z3!((y~&?kS?4|CA#Mw9xMUkV~(*$C<0N zggblW=umATu$jKcB}C0`#C|<~m(^?%AAwVPy`S5chE~yk^miZ1ur%q^M?3BY9ef;g z=S1JGc5g_bcRsWfW(ZQD9p5?Ow3q@r!M32gJF!s|jsB5B_kWj}7yYP?>EQOk?#s_) z*40DYd&_hPgc?xa1xT)OuG?Lq-WjP!aaZ=!ss@|dTIYrF^2v%ZxfhTU1^a@DmvV=? zOX-|jOa;-#p>9(OrH{bq7bgn^G#HE*9VUs|BRYQO_&r#Gg%RN1vi|O83;2n&n^qbhl-gdH;*u zK)&}Zwsf8v?QVCL6shLEn&v>=eks)u{c1n6mO-n4H&fn{;+TuGLi$h0K*Kk8tMc9E zPAowPIHkHsp~H_9ck1tXATfT==~M6c{=%}}SiRsxz5KvjU?frD`;0_~UxQX5#CoyQLwU?>!JSt{sui^q~L zZbvvXK~!=nT<(%w2n%Xw_(F|qAssw$1;X*pyagQajk6Ff`1q`B^9=Zi#ZCm~Q#?^4 zNg@qssB7xH8Pf$t#sdWxme|fgOE@NCM`AOYqI=JC-=9u54#nXmwrTqn(9pT&yDRAP zl^FZ+D_lcN+G$6-e&lkbV#!c5K%cz`4fU8o+2iTZ$NA~>X@}i)9xt$O83($=wpP~x z!Vjl~kb4KGiq_jidB|6))peOY2I=|IR-JZKWWx;?yEhH%LayQ26=qcs0E<)lWqWB+ zZMI4E|A9C?mu6py`E41TT__Ttq%oNRW`(Z47O7+EMr2pg!J`H6MSniqL`&AYGon{r z=)MBc7>gnBt~e(vcTO@YXEpi^p^z4ans|nfV|Kcb!uEx1lPc@Z?QC!B=I8js7g`3) zN&XG%1DX&vo7}KQs=X0WTQ>D;yCGR?^4(HcM2F5r#t1pow#RJf*&=(9zv~Z=C|`XPY@?C!||Bk z>|RY9&MJ0C_cpsXXXjcF!x|1+5;ofTh)oeLNK;z7nwQU7whRP;smslt9Nu79)S4IW zgv2=r=CPr*taIQbBMU}R{cy#@k0qJq$y@6WRsxr_FKY9uc;dfHXuQ>BD(i^U;39gf5CvfcEz4>4W~-y1PbbYYOKKc51j~yt z3b~^g)zKY4aaX6N!Z@qp+^kZ%_%(YDoBY(-f%D&8?Y7WoSGgZTUV$A~yS-_~YPt08 z?be#;r`Ne(&nc3gstKcz=9Zc{G7+kvYL^3kb2^sGoX*jQ({X+|=+bcv3QAr3l)J#> zZ(h?K2A`EhzrNC3Fv4G_@!fF89KjvL=8I3Xkc{cj(FH~2NrvU~BQ`9LQKbzlX($;R z875^K+Iy?}d}LrYx|G`&LZrs71VGa-qNpl&|SFF!fDFXC#9R+iW~O8JJL+ZGr^CMueg=TRIDiH zqLZ%D^!#bo5~p!b!YXkdwYN+}gt~c}{wAhe^q76~ohi z?=USQ@5M?%-r3N;i$EAtU;-O~1AZ=yU0@lJt-+5mWOu)*F92g{Qxvo8gsD64RiI(X zLOj&n{F2Ejdd!d=t?tQk($8KpAu`Tt13^I&6YC(Wv%wjku~YFj-!AM~0u5d{ZEQncFPEu-;Avg`$Fc~cwC%4S$kkuNXLHb^by zU3!MgO*?Lch2{EnN(KFTol@?TJ)D9-=y15mo~;hVT!?lI!2Nj7pR)2qH^qsN1)D@I z5hmm89%XSs!erOc_2-$3wH1IkDoM8ilY(zXS7obeCmn3YIlVR{36>6bDnWX=N5PJG zFw35wFerW2p#{6X{`gy_JP$=M73Ny?Tjq zNtsRu;f~3CVQq(XC3{ zs(=WAn-1M&vggAs!vMnq0YkaoX&)F8nx_E@I=a?cM9NUb6ubZC{+!RhVaWbIZ zt6GaLI=8UIjjV-CXzI!uuIvy5ke2c+M`Uz+`Ur(@gA zg`?@3)rvjELNBjG5D%mvnofVb5ckCPCQClqBg(XVm5VJ8tHCUAm2;Oa70HZr@7^Z; zE8B(UogFrQ5wUR6u|dL=HxxmGKI%qDr9d8xC;((0y}Zb7iXL2}Y)R>t1YRll%Qp;h z{R+{E^I+Nd;yT4a{*TRwX3w3hzcwqM&Y5jNcSFce#*=$$J z08DIeqq^r!B_m*^+TJrAN51MdkByRSa7|beTU@lEt?O~)922sdX!PoWTw1zOxhg}f z3t6|o9JAmWyCuiiGjT$C3FM3(#UgIuDsxu%AEn%#R+uy@7zjBdzew}tQc0sF;=F>Vl*L16o)P^K?u&G}q_aOY;3yQ}~ zV4(>jaCV%r6XWn0j@fwFFk@nQ>&ir`SEDET8)2qP<+A*wavM!-+^ zW8jGwW6>I0Zs@MWeO5b-DgRfQWyRpsNk9^_8G@5&9jl1&@3`*qv~3)%s@mA=_+Mp~ zE-?0LKvL3~)~Lv-;)4nektZR zyZjrMB%z#^#}Ko-GV;zty1IXI_PUa-dHLko;mWAu%YYijgUL>%x{y5S)Lku1HR(j5 zx#%3BITOlyoiN!WPUm=#oJQPC`nOO@l6!`Am~aPz9<;R$H$Y*J zi*@9YN=CP(QQ;MhZd{p#TwrScmeXnsnVf+gc zY2#_duqgs>aclkrTjSNo%Iqz||3zHnxuP!)XgF~t%z=AX$A(aNd`&MWlJNlX{;uUqD~AoM_SO#?QSBWxcxV-BN(O;9HjY+2OglZrn z540pTfOVbrR=;hoO6NMXe~P&%oBskNqTs}0+<|wlRI+;Gjz+Oga74nnhFkn~P62ZdtEh*RTVPV@l>C4D_@`^QphI6~cX6 z9zR{7<&)R5mR2H9QovkLT+50%;!~w;DQm9`!N9UttsBQ9kco`hfVvXuFtYPtHxBDc zH06CN=Gb=>1NdS*ENbNJ_VChX_~LC4M8h_Qt3s`_;oCmr?J^tE`?BVjftQLQo`PPb zt0yRfqaw_vI*lqrXw^lF28iIQ!2y0lapgGQMOBpx8)`0GTqQm)yomoEP%c7!3c`)d zU9(JvAMKTRL8Qj!E=*hity&`DP^?!iwuA>6ZyH?WMN8fz2AJ7JupG;&;){hs6+G)#vBg7BFNHoj*uaY1AVAtc`w`HA(Vki@tXLOh%Y8m z=yAJMOiwh_)8!7#HSC4pVECp2j*Y3826@7Baf-08KGF;O2vzFCy+!UV^`l&kn1BVE z73*W1t9~LUgH83Y)d#?wV(>^zv~~CDv=^DE-N+0P@BpD!Gg(C*R(Q=aMG1MZPi>7h zbuh56_&zBDKUmrqoEE7yH3{p@M7Iv{b3@+BgfG1G`Z!cyX?6~Xi39ovhE<9wMyeSD ze>iiXKak98ZKxbs*M_h(u&xo0*f{0jHbuT`a0$z|Tc8f=QZfckf<*~T7!mv;ZuvFZ zj;T5zMf3e3SB>5%730+W0<`CPZ&l}YexJVJqbBbE>c0{?qjpb$sp9+emm`5n3R(^C z%I^o>0IfSMR?AZM*b-~N1fwGw>NWWf=TzYDD-Ki*>qOI7FV?s=q0x8b!Ca63kvoY77vwmjLesL?-;3sSk@lK>qo2` z#tNn#q2M_=#bwYB#6Iad5!`CFz2o*#=Qevr8sqn0zs??7*oMDY%OzmtACt+t716b~ zJPFt0Q696UK@`gVQBQWP%es*et1)@GPNM^;;mh)A^{=|}ahE^WDW#e-gHl|WR4mX{ z55VYnlcg|kkrW?PpjT+RL3aM1C#tkX@=DEO#A z$K;T%?q|eshsvuz^I5}&LW#1u*R(;5c^1Dz~#oD8}V79dB zw^nDb+J{d2C+kDH-5Qa_pzBv@145Gm4K0R5EyOmJqQr!I6F^QFK%Bqg9;!}J-4gTcK!p4~Oi}K}-@L*X| z%WEEYY$c$9uK_rD8`aP~{N`#K-K1%@r(qoCK4LS;ZKx-G;WP%?dCJC&sK);i#u@^g zQE}h|q3wotVIu3uQB@m3L^s#2dYZupNBZv0D(#K$K(`0cPJ7inL?cP{2F+GgY_QA1 zp4MToi9tiO!?}7W1XM9LRQn1x$>2ad@yWH4bwvb>Pz?cc8RJ+o2K8?d7Ey3{n$^!! zmd-%ao;Aw2yjWm(QI@(^8Ji3-O~UX@;I&$yQ1D&B%`Vns@vEqqi)`GM68f$iF59Bh z@U^f-|K(bxBrm=$?OUr9B|`9*wF-QuKq<2AH)|EARUJ3>d@ZbIR9hLeHVjvT3aX?+_>6&0@VX-q&xbZ^%9q zaHSY_QQSCin9;}~xtu1D9D_o$$-zA;*+BHxTBXc@Dxeu2H{$Ug7D{yJNksF%beugu z%^&vD?n(9m)c6eY*o<9Rn3?L`NGWzp6^)-{&!k_?u@s7a5{Mbk14i2w-q5GwHmWW} z+civ{x=>&&gv5bQf;Hg$Q}vLdLI_sH+)So?fgaJ=EQm}RB4A?#%8QeHP@NUUvBQHT zWqNe!6`rChV-H4%)HF7F7ceTi6`5WAJ<0H8A|EHz#fr@K35SuSE?%M(!sEG z$Td5&dPQ0lwW=ye&K2=fR65b_c9xjTpOmAjsAfj0`xr^q7YCvN(IUb%-MmqmO9fAt zWabE7qZ&}rZ4bh|nD<51N$6FR4`YmnnvZ&IWh%dkJu+$Uh;;bQoU+_F9!&?H$W$^! zRjMt>D+Fp#Bn6r2)ZmzqA`ka`NB^?w=cH zA3~d7aSiA<3+XdpWGGmHWDmxZK;;y4;7OZbIfG*=KbC+@oJBPIVw)|4kE>4lvJeK` zf6R3knkKL6?CyaR4_#2`uFSz^7eO6ZvK94HBhZBZ4c;ijZ0HtYZdhwYZAz9RQV^-mq zzSvJRcH!-Nl2b!4Vmk7LD`#jN2R3W~e!Dw0BNy#`r)wYM;$^hV>dwo-xdXL?wCG`m z4K35FE;E7)Ea|Y>dm}nmsmBAm5S#$W>6x-Y{1g^<=S`cd3v;US#wgzzp%wxawg!^~ z&3MvoF6@h2zBeRcT5joyW?l#r;DSxc3nI>FqaJfHB0z!5+{$@jp;+WwCEr6Se1%eL zKAUrjHMb+}Q0I@7NmM;A%aqZ@`bTQKTyYe`{8w)m6Z*JmT{Q2%l(kv(#gCK*Dkv$+ zQiCdR`~{kIx#B7ibBD>9=FUr(UJm7w6V4kO9l^RqI_)PQRhUc76yBE&l6 z4%iYP0;uSvA2#{vgM~(WFIRS?=8Ab~PB7H)jLoKKzl=V|u`)VQmv5gR`yKO3Hk7H} z$gJiul&UnMVbkzst~5KOP9Uj2rUHu}wt0ugjB0hBr0(WRl`>^=%s=}4<}OZ3ITu;O zWN(#K#0su~hPIjrA~ahT!v_rj?zAG-=|p~1TpC_qX{gGFtytHn=O@adRIg@|5o;BR z1BL26UbvwntVbqiGz+!R=9lw5Y^ax2%0z`{F@_r_oct_8h&A7lTRal3DZ=Bs#xQz~ zTD>M#Su0|VsrprfNwuHfFlXkpnP-pW4_bBFHO#J1=eJ(sZAHL-R;$282BG{BHgHvQ4-VbcYuXUjAIC8}FN$ni zs<5j;AMS{*xk{OqIv|E@ZHWwGUkqJ1wrOksf*GSbWK62q7gcH%Mw++ z8(a57%AY9QmQ}i~p*Y*dj+Ja0DQqF6EJeyOSMf;xP-PKqh4&?x6xPYl#Z7Ec#DCz{ zt6vL5O(A_or$4OpOO19uqP&?x=RT^yZg!0$1E#dB8o*_|<53v$H$S12c~)V&abg0T z9h=lgR79D=GH@si)ZG54Ql@$6i9lsoMZH6(Bg%JYjezigs~Q?v;m{9*lX>{>HsiiwQzSpXJgdMg*=_n z7@nz!KDImr`3mHSadm%xE{KRVWY>OClYVh~QE8UCa|N-dp%!g^NGTfH1`EqR#9M6< zJ7%OLW_aXRdj%MHmjh#rjHDG$EB%XkB#uY{dRIwD*b?u4S_!xe-`cT@_(89V)!cm5 zq<=lFw9rM*D2{Sjty_GRC%WJ?TpjZlT}SAiXOt+tb}K?!c0Q|QTW}+u&+)>s501Q> zUF^`zars6d@B_gbjqy*~{m)!yf%cs{WX}=W(u#;)<9Fs{((Q*76K#AJ=IPhpV$Psz zpT!1z@L6R}fe1|j4GP}&MeYHre-5PSeqI?6o&TINC53MNgR(GRtrb@(ib}2&+S_C= ziOzaK*_aZ2;YH;DAy?KR=+ zkrevt6Q(?Unr(E|VFf{|0RYW>-C{;4G$k!XPW!A^l;PCziZX)kdPP}ES+ByC_I%9=HBVS~Be;I#kN>-eQV3>k281%7B;KEuTPGz{j zB{tUdT;g?ue&aRgW~&~W>_AWZFSnP`!8>iHluFuvC;aV|J8gEzQhEr^1c)_Q)IO+Z ztYuKH-1}P5-hH-`YWaiBT;a|vJQD?seo$^)Z3bf7IavXE`A(aKX7N9+zaL=yakRzh zMf{JBwau|t2%a0l-vl+6S~`YIiU?dU3uR@!PC{EXV7(0bj&LU2F90zEYm?0OI~N|cQu9dvy4O~Fe%tbn za92o0?Hu878+(S3-6g5Q3nY%*qyxf}LHcrs@3UnDnv%B{2$8366J5Uq*?JHCFe|(F z{{=W2eGBe|BvRPZj0b=P)3+GAQ*EmFeMaAK15XdEjz`-6T%nyFIEI+(*EK5$FMLi; zDQ#{-&h!<{N>1-YjS;GEkixr1BXzlJkolM|-@vB)L;I=?Az&3NCcm@v0!de2O8vXx z2BFrp(1X9rw4V>TMlk7wZKqu(#T8mG#i<%3(jW#q3(=BfUod}BABUxcjd&Y0`%jt3 zUp~QR%4i!n5Qos7xp~FT*#>I+=csTgy zF!^FD%#g7x`e7E&u0`5)QHQp#REkSu)ta=H@+5V1|A~ZUYHSTL;>Z|=)ZwZdVkj6XVt$E=)gr$X zpFnE6ICw0ZG`4^^L+fb&5?k@?=Ju8~aJNI^Ye7unrNo$I3eK;x!UgmBf?!BLC5*NB zfZ%Nq+l|!tQ%ezB3qwrNxE9(Bk<9L7-9dHL@_%(|Wqpdh9bWX#QpKsJs1xzYr&phJdZ(QotkrpX zIsn@2>Z;ZG{YSIY--gijbXC$xKEGbMhH=z)@<|T*&n7A77zc4T*fLt|gK(E5cyXs@zOR=DagT3XwFYMlD5M!$Fp-uT zKCZk!z)KSXchF1&K_d_!3P$YHVFCwxpi|ykG?BAbiG{H_3*V7 zwW_r2%kXrlsnM{lu~XbZS>T`@=DeahP3B`gTOz}iBcT~H5o4>GxK;)pCR=EG-q^$! z*F>u!SchEgwY2e{CVxLEZ|T<&jyeNT2o_i8Ewua1&9WrERrMMFVi z@8Vfh0v*5CL)!Z&Lij*20UD6CG+`U}q6!r9r3!l|3@=a>SvVzPv4(KXtgE8EXCZ^w z(S12Nv$XqEtS-+={z^t&YNrxvm4anJ7pCtj+W%Odr#EpY}XWhP3i~Gn);UpV+)Sk&QPl^{E=-az0Ir)*}}FtQmfXofl09r#B-6}j35RReR!kF=gIC^pr<*Z2wS zLGDd$-x@}eTQjkH>>=h;>!(1UhjT=?2-U||`7j&lN@VEkuQL%1M#EsTR}tkv#kEn2 zF)XRLNSux5v``mpUDzj^g(^m(l*VGH7s8o5T3Wgp=6lTpGgKbA)#$OD%95 z1&69t`2a>$0fDT(1XPQ)(J!1Fk0HLkxISZ2bwPN`@pzH$uJB4V7pCeW&$0ohf)@X% zf@&;QkAfkkxKO+~$mtlU*wHHv203jkqWVkIRwLkn#-fd+bY?7GEFan%mQiH^1_J5@ zUKliO?D+GU-$!IOqnX46bX6AZFRgF2hvxO-`^kD3%Ue(DL9c6;{euwcGfRFkoS$(i zkTjPFY?6Hq-~~PQs9QwSW2_<*_ACMcG z{pZWqYdE5LAH@-jI8|{v^A6(-0u9 zkA|ZdTSF^-%VBM27Tz4NSakx zT-FPt6KKr&4SpK5Y6dNUpSMliM|8!;0O!n|HIrF7#6qN~OK6Yp{!yr95zV`smrfJ$ zuTdOlRL3UQoj^y3t{>sCWQZ1YXqd-N8}}Dw)4Lmyq33}Sp1FG7Id0K zn5p64FwbtfB-=_)+?t!+%R(DKRV|am*~3MW>f}eZVQFlbi%hAy8!+d#_A*`8UNog) z+Vt9>2$90oHIKw)cx9>-1*5#o1N8kH)&QHqmQ~1;sK)kHS+X3`s88mSlYk@GE-X|- zh#SHJDB>nC)A=6I(V#mKbL`SVNZ!~R%5Er*hmMUZcnsRzGh_-$I zwH`-m0qav_(BHNQH;x|ovE!ADO!?ln7Ir5bXR~b&;!F5~1F##roW+T~P8wUxihZZ`1FjfVOgo4!)9rG*4LxnWt zQHPg?y<3>?)>1F%!>CqLB6;s9Pjz%4g(Z)v|YjSM-z^v6!r$&eOI1rGJ zQ-vKp;3)|t0Y)C=9Ri6WSz3M6Q9^t6I|ftdK2Oe&5c0E&2L(xYtgHb3C3;21FQ`{y zt+9PjgX(u@+G}H_vCU!-6miGm+OdK6z2F%r#;iy_X2RU?5O!pbXWDZ04!Nwod3j_Z zw~S0f*Fn7x0lZL=E%t7N77g{7+oCIKc9uwd6EVn1e4-+1<*}z71E}t0 z&sN&^vZo@uGb{o=^2R6YL66JSUv!PrCihuK|CEhXbI`MZ0#7-L)3rLzJfnpbBC{X) z+)SwjIswyl;f{qKI=K(Q2e1@vI?Z zXz?0?H2?#&_i0B!B-yn-;|NTYqFWL=VyZQ~TbvAOU^r3lAi4NW73D7lf;;}6CO~+WXUY%}#-_zq$&7FH1S`cwL67Cu) z@!B1hQKn$~<9f?+lg$lLPzn}2gd`lHHtXtcS<_7~9(PpGRZDX$wDX^y5{{w&5=x>c zjyuZIveiXkcJ#=%p1sBA2mvMbx))p(>Ru5xIvc{)ec8f36&4%b$6>$8X-cV~$XnbG zmUR3>&>#y*5Ivx!l@kC`)T(dUytSF?-^F%shxYe%cJDIn?|<99XVdhLU^U1p3ifB5 z$ZA()bm(qwj|*JLYBnB_=VJKE8gAi6B)_X16ZaD#y}^SV>xideKxJ&yFV;q~n$BKm z&k@2^4w+E928V*$k8S|UC@?foqwNVGAe18Tq&Dz4Z#{z8$TUNSLst65#t?}cpGd@^ z&jm0*kAeT-c$S}x6VQ;XSrclH25MEltFfphv9DJWh7gthMI9`)8pZ?8dqo7nGg<_R zF{np*6tQL)iEVh86kvHP19a(Tqxi_q?eU-IL2(1?+}M|1y`}iX7QM#LUKx^Ik_bMi z@shBaco&7F6YoUC3xkeMn(3$yG>A$XYMr9yyGBFR=tNL$WKIY%4?C7Oz}0Z3Fxro= zpt~T>lQNi=Sy+X|&}(dhQud!mD_veEjXzuh)7-~OZ5b@}MCdQ;N}ZXq1}&-dmeVss z!8s1SP?$~!#@g~|->opUI_|Kg(>>ctthu;0u35!c!dwt`xTDlXtDi0@N{P_9>q{L} zO(muHdn^9V<@t0oPFZI{v%N6d58qpoN#2`F@_OZ#!AFTz7Dd=KR{~N4l` zx^{Z6D%+3!X6CLn5sM}z6HSm5U0Q&vUVg$cAZvq{31_6Y4a^ot2yQnT;JD+AvLvpU zYT0{oy26nW3xOv3il1k%I#HOA;;sVir^;Ck!*UL1e;nY9Gi`FyVzi7Y>&1pSkMZ+e zPpfbE0IRgBUW^A7mVAIZ6&|$qhVlMGe8gd-H-=s@&!C7uqzxv3jYn8KVI(694l5Y+ z8wB}8Tvm!P9!3U&eQm&%k%A>ncn9jsz63kKp(^oeRaGq{b@0 zw-=rC?V70|k+lgHzfchM5uU7^de6ZoRTW5)I)-2t}m)sespd`WD?Sl z-J?C(wCPymISvSM{qGhxP+UMa$m4pX z*EoI1WVp1)xd#5lVa=&^XK#Hq_7DN%xp#t z`=&DH(Sng_SQUsl1<>Qg=-&rwT^y1DU!qfrynjh4YUt`}?uprfvTy9%5Y?aODWaYy zGtZ;V*IDe*x)Sd_bLkzIHxR}7^TAiq*DvkG;=sOTME8QojrE3nFb_53doPcNfe ze;ga`cSP&@`R-3g?mki38$jYf#UA~p$~P&+PF}p3ZeOYw=T3-oue&)-JeiHFro@$HlKsL5M79GnB^pD=Y)>oBUl(bItqV>L6DTQ$$ipJ65J-!zQNB_Rl*EyUv zZ3kGpT70I|`Z}r)`yAB$p|6@A%JO@t-4!T^KK`L^W-9&iQ(qB{``DM6E7Me{fP=6C zcFHaF6=fqtT5~rPBrsSd-={twUH^$Mo9h1P%b@EgW5Odo@s(w#wRA%M_`>JGohe9T zmN`7MZ(g83ZTZ4y6W=y3bCl9;_xcL83JU+Kr|Z8!7bm{(by)43(FkS>Eh}rf!!^P= z6$G^PtALA+EDL170?0dD{9p3AzO|vpli6#uW@8QpN}{Rxfyc9>Wp;l-p1#cWet$$? zbhAILsi?(fh_qL-KZ_ho3m==cD?gYNl@FFPMwM!=xbUi60p{9mQl;)(wI z_&?Hqr{7VlUK7|(`Aizqk#=8+6_LT~hXNtmKdPeLwf-wjI;7ZQ7tpN7{ibMWxc}Bb z8WgFIEb^D8@E=sV*gsGFG5)jc;^+?-`)?SZtzM$oWt}!(T~suQrB}?dw$?i-w5*wP z;kB*ml*Sa$l!QA*c{^cii03wh=2?e_1(Cq73xZ`ZcH|KIBy3PNr zfXtTwnf~Cw1M`1iozCwF=OS!5{cL}c0Nu#{d<98_M2eb;UMF;23Ilb;KTCgu__G%MND?xG1OPkazy?NGPZNPodL`t%8l={))R z5)^YeO(zgG_=$$WI89BOe3qxbElI`GztbdX1k zB>tuPzeD#Y9&DIMJHqQEW_Xo#Dlt5!Og1#@`^df&Fo_QR!#Fk^C zO*i;W^s^oQ*n`h2JNz4|^H167bi;PPjgAcWn0ph~5le6y)N8wvr+PA|lRp88h2>^3 zZZ$V4y8=VyYWyE@dyg>#ttbvv2D0Jr@!TkvCgII86`Iazclh(n^pAo5Vmkj`|G4Pa z_xk&#(6Wc|d)@v19kgsiAde30^uJ2(jR6}K+~+S++MAcc$8UoGrxSM~unuUf@ZX`G z>%Da}>orIQS$FvgMQ!@YgZ^uy%OCMS42Apwzd5bhyCHhwfWO;BE$;^GDRt4AfAZg1 zNcXM@WK-pjeS@MkANl_)C7*#7rsX5OaCcZi^`H2QqI*8}XXM#~eex)I$I?qBK7~g7 zH-x0?>wH-(I-2NT`vPWfvfAF(wzVu0bBZBa{i?5@XE0!wi^z7Nc=V{#ehYzO+iwDP z-ykkxfj7zcqDR{Ob)e>~!Nawt(oe(KS<=pB1=>8==c0-d;BD7kkdZD8L+bkjqmc#0 zu_qf>DC>ms**jJM!2wYc7iSQye$Vf_vAmXc{W6d~755QVBy*0C`nsWP`y~G%kL{$> zOF9fKKH#sIHE0MjjHv(kzC8eDyo7cjVX7LP6Czl1H$>v?%YC`zUF^%GAFd3PMgQ`Z zpK`7I-c z3O)8D2(|leUs)<5Y+KhsWPa>!Up{@d%l{co-Gmv`Z46}6*x&l|qLmN%$EQ&5hCnI* z&ZjL8`)?v;qx@M+k9`}k(yWbvNAxBobYiE!gm(Vczm|?~2#k+rYzhoEIog|{S6LD2 zg1=B`oy4FZm9gF%nu~1ox3z&B8WDzsUN9Ckcd){jLt9hJ{pmIJ!|I}ymj_-;k9J=b zn3`g?@XmofNQk!IgPYy>R&a=Y^8tP1Y^>QWm!pf~d;NLzKYmEO8fWom85)&1R@5hw zXuV(_-g?@;F5q-)L)64U&9Ve&o2FO!eRS^mALu9Pd)2OnK>GpN^M1i+z` zF5e(pG6zgpU?R%|3TISR48nrTQ$pB}G2_p4)= z5Uk%I+^KVq1j_0}N-I+HC;aKarW(6Khz;W<&ggXL) zqaS|XkF+lT<1eidh{Tzu_ZDhxg9%j3(Z0sePcjG>odJZW>hlZ%o&3E3P1-3YLcY)a z-hP1z6DCMzaS}2`&W<+P>c(!q?Y4ls?4-4*Zmn;iwkHy4y^EDi3f=4m(XRQu&pCjV zANA@#;qN1x>c7qnbHbCAZ8e-f71V=s{{qw>zV%C0wJ{+HWbxw zgrMYo2Itkj246PPHewG9^)kRHvxJBqfIG@@|T0Ia#!%H9ft%XwXWNA;UO5rzf z@Kk>8FG~+JG&E4-5Pwn1V5Ic$l~(B@saClLCLJ)V2mjy{Y2H{TjVF8_mZeGw%7ufnAnTOyI1|GaasAQ*aj?_8Ne#WodSUyCI zQNi_L!_XXA)5Tg2d2tceDs6D|$5|sI%Zb5c=a6gtEOzJ6uAROKv}&i%=8l`T%Gl7c zL^K`$2tuoJ3FepafUi*Y!m3bZ8F*g}Y`WUoF;GJn6zIsfsU=ArMf-mP(kQ77sla=OO8Wluw|H=A~bp_+3+Ui_3eAYX;JVczf;@4w;6neR3hTt2Sp z$e)jm^t!Umwh_CpobyWK;l{?})%MYsS=(QD>xY?FR_rim+%ef-XdmL8zCZjE*X89; zy>NYW>QfJ9{N;zg=$LX#__~+Jl(+gF^xS=a`qTUis*8Km8^+%~Z^AiOu6pCW&wK8u zeCMmLZmzs)ZC-x32b+9<_~7&5*IoAR@ameH!+%@* z(LXM6e)7pDJ1Z(Gmj7VsgSTIM2ckAcY`?Gj!G~Xd^X8EwHTQ0vmBlEJ9#~=8{cEgch zTLyjp`R5~kWxwuS@2`G2=kBAA2XDD+>s?iMwf*$@)`AI37R=B4!^Zi?SNAiezB1(f zzx^%ujYrC^onorr(^8sw%UwI#dY`yG_3QiR-}~xE-Md!Z+SU8m^g9o4zi8)RSKf)y z`3FC*EWWz*$D40_FztWF-TLSMy5y3p6h(P<)}5cc^zzHE{B7;DpZ@5RPgZ{XkC78h z?+m}|@QO({EZOvfw>KTxd*5pp54rWg?jcpP&q>*GSJnS%-!}ZZyI;Hbt3AEuC%(Js zvR7Yyb@0K@ryN)onOJrC9LtLjuHU$El4*0>Ev}Jn_v+QFcR#du?{}ZPSb0VBqnjd; zhdzG1W7;`wW5Vi+}s+Hll;~zV`9{-fyQLdEm&(_kLf0dKF(8sKy zNjXBRS=8tz$n=LTEk9bwKD-c49I@8`zvq2yJ9nbVXNpz;}P1yTHi-#CtEZXp=$Q}X@qvMtFIxnn|1t!(6?*= zO`tvOMK1z<$1V>e&|Y?CIDz)D9hwnnKTCBY&;fQ|KLQ(l5B+z-*cME|o zuwL5;bdg0n2y}^EwTnQ%vBmodbeVncD1m-wTb?A)m2!6SF9f>EuDL*A zq7qK4k)l#A&O?fZasy1|QdGvx_mZMv+)f`U8qVGHm!c7zIarEDaxKH8XcSivB}JpT z#r33U47abL6qR%L)=r8ha33a1(M0YjFGZ8MXWgXeeJ;3{ z6iw#3_LZV3TzQ5RP36`(q-Yvt?DDMjnJ3HPOF zJ-6|(6n)B_c_u|0I3<#yja)sM3~l1lNEzD9O;^d#XPlsuq0hPB3^KHZ(|XF#7hIgT z3~epv2KdR4z|9Ymp)a|ep)$0MyBQ%v+c|Sx8TyKA*+7QA<_em~&^O%T<}$Q{+t)&d zc5?UI$WS%s+d+nQaUD`*Xg62ZRffLhKI|z&d$^;iGV~qyEKP>?a>3a$w2$kWBSZVS z@;n(jz^yBkp@ZD%5*a$gl}m@q&|xlWvuqkEjd$&>sI7yCPa{D^U(JStLXE{Pv z-yU*ASUdEVBZ;-FpBzc8A7;vt%zCuH9LcTE2Fj7b8eAYpN^93*IU=p)WpYGW*Nv1T z+IqTNUXB>6bfO%otWi_sNNr7>Ax9ePpa|<3R)Hd|N|ORbS?hTz zP_#A8M}cCj)BP2wu2rxrP(AB!brdMps*O^h`sLQRdJ5FQI-sEfHMGu;Q=mrHo$(6P z*m|?20yVLk+bK|-wPmsbHMJJ-3e?QHxSIksx9)pSf#R+A`zTO?)i*_{ zma9N5tsf3npjOtSLlmgB^;xL`wXp_|P@uNfu45F)z?Y9#AS2JtR3H;yo?GmT%=|LF z4O#fBMnB}qXSVW3UVPV;{)po*edCX;{I;Y1$eaK6i9hn;kEsKYFaNby0J8D*It3s< ze&V12mFQKtX()F9VRBKe9gn1@j*t3qT?Kj-LZiC_nUO0II`# zn*&i8f4ST{5QXz!`vjs0ewS|`isbj%0#Ot{*gp_O^GskMisAd>XI=hCP#~(ur$z>% zSY8(!i0bpL>Ib3*ytY9gYRFH<&qn;jhJmOtKcZ0}YQlfkI1t70=}iJrQ@%r7AZo^+ z!q4V>|E7T`o^ReP5GC+mH7gH9iTtkSfv5$a5g&+J@^nHVYQ@jR&(=KIA`rFVKWG(* z+VXAM1fq7lwQV3u;$OB4MD2M;QXuNUAI8sQzIFRR)REtTpPhKVLm*1w@8BoT&rJ?Q zo%s!XAnL-;=^BW-^1tI}H@-=?K-8U|oe@}$dhneK15r=D5Mc7dh-(O-!#r$Ha9hLBQnH`n#T}e9{%3sykQ5j#r z+0iimaj+c?=gVX5XauiJw4;&y9{e1|_iSNDqj_x?I~v39$*`kxzRd_b8e7i$jI^V1 zeE(5)G@hS1+KwjhSMhTq-*Su{P2!`*+R^*`-tl%cnSU|Sj;8RHlkI3KA2ZF4rt$q} z*wJ);=`1^%!AH-rqnZ4&xpp**uRGt4X7g)5u%kJAvr0Rf%O3$dn#U(Ew4?dF?PELo zfH!TlqYA#f>1TFS$;-d6BjCfnw4()lm#^$-AwOz|9WCNN-epIN`Gb4xXbC@KpB*jb z$%A&Zj6ZhRj+XNaj@r=*KKlnds^aaZ>}Vx_@w6R%$XD~hXcd2HeK7in|KrnO^fCW( zV=!9H*ZV9OeZv2YpKJKRp9iD0JXyXa7_H+g@pC=j{)=GrDgOt4Zs6B!4MrRJ4ni>6 z#D{ztj5hO)w*{lm_^Dq7qtE%l-vpyAe8rw%^aY=EDj03$`~Mz{1b!$s48G+1%0tjL zzNIk)ZO2p-g1+MWHV8pq^9|aDpl^6xuMlid|s~F$(1)vYL(b6=iIHI zo8@#%)K%Y2OP)bfd&lmryK2+)Hij-!R&~~eZ_zQkx+FdiF(ihyP7JcG{E5l*k|%yD z^UKN5?W(iVW2Z5GGygn!{D9(dSwG*u-S1q`(I<+nKV|hF`s!K#0RtZI58{5{mCL7Z zVmoX`1<_MD%lA*m$6nIy_)u4#8}Q!z(y@me_OxI2ZVpjeiic|k>%x0Z)b ze=@@JTFEN5Q$fJdn5tisH#PE&wk|w$=|YFm$pODsD#PwKU0IKtJ?J^zHek#M>C(2j zw-zeC-srFT(bRK;*VxH9GoLi_xwf=Z@%`o6CCei|6pZof(6wnl9r<=$LfPm=y3ynA zcMkvS(1*KDT^iJ8&G)M>wLcn_RTk~B_50k_<(E=-*(Mkjx%&p@RZpYWe9fgvUd7!Q zvh0EJ=!74}9a;E%!h;q~ndi-SEg9iGWAptB{=Ge(-rRMf-6xNJykAnV_ZGRoaOUDo za^;@o%^#<d(#%{O%#W=0QE53z7Z0wfiRP zr-t5>vZOPCh?tzb1l(&t1HSRgFX@y^#pZiP-nZJ3o?|fT`Px&P`MlI~v z&e+*7cIWCI?=_G1OEXVf-+FqBV*MAPWkxDvPGtB~mY%^)jPUSS+d8oGu}mAe%4XQz zpfmq6!LyZDL>+&!Uzfn8Avv8B|4LR%8o2yI?eM7 zJ=5^P2X&M;#@0!Xx#RPt@ zHLdf#^1H??Z^qvHdT4t0>XR#5x4HLeAV?k(FTB%Rv`e0%_1oGeeRx8AX28LpNtob(;%4_8+nNwGv z^tceim$QA2ReMF$9awMaF@I_G@Nd8N{qlBbcMtsvFH2ptcii3()cMe?1{daLtWzqQ zeKauO>rqozcU!l-McB+k!CUt8CyAui)^EC8n6-0kM^9Okac6p8p2_ySw(q2*k;l_(_k5qH@36zqJ4E@KwW#ai3SO zY)T)4>gEym0+-imu(72nWevUJyR^&K$*Nu#{Et<&9&v=SzfYKX_u}rT zq-D>(%hVoQJgD!3eYO@W4i~fq)6chF{$ZUsp-{KMk=1g$dNdh~5nmFTwr^+Ez{htn zOGQboJGI)-B7OW+zSI2b(K;s`T(6;nw49XA*6R3p&MWo%gIC7QP-?gI68117znru_ z)-lrZ*XJu|g?vAu!swGd_1@6-5$#iR`?cB}AN+Cl{7&uKfA7z9_Tm4C(tdSgXp=Kz z9>2`r-srsW=i@OuAD=tg_p+`+lB?m5dbiwJK7ar1RTWRD z63;7A(@vlC_~?1^>IR?g=^0Q#k3C!I*(q=O;Cc@xEQ{*dD`A6#8@sr2>D7A2==G=D zt9mUPVtCK%hx4e}&n>b~5f4TUKmVTg@z{tH4|_})df01)%%WH}Flg`UyPqN-)Y|X9 z-=`Cky;d$-^Ks!%ujpfzRei$mj@njk87BK+vN?8B@35G8*-fe{u1Sw@S4LOYKMIp# zh_z!0X}T(BibVItA321N*VZO0&fj-*oCr}5M*VDEb&US)9`)&-gpFXK{sPd(kHPd{B(X>4Y}lBGYkUox%Ux`mcpUe-t1;OK=%lh%A&QLwA$4%LGA z@|NmT>npz0l?`@eUMW^IQZ132uJB`bphp9Pe6Du+?n=r2OMiW4&7n=hJ5M~8h{@sO ziYIdig)Tdp)H#ON=1JDh)S45M?uCb#z8ZTw@8-&QMaHNkv!@@`SV2*{9lUy z%Y@Gt$*G5lZA$aAN^%SGBMXZPN(xGb7dj#{bMv!p&20VMH6bNAxy31&107i})SabA)6SyEl7g-!MY;I{VD>_# zIndu(*u>^<3v-SbM~{x9iyS4TMft8FaDlLWwu10b*_t(TO=lZ53eqAeBaAUov?RA! z*i)tWT1(_8{pDrMG#?w#7c!;@cvBkSSqaAs<w9LuP%MP`Tq@5qoc^_`k;<3V4CVoTiV?`vGWlAqdktubG$imX%oDeAZ zR^=xQf1>C{D6_=wktI-=VzflO1!=0QD)%)UeQkbtKk*?s`se05vLWcH!VaTSjH=-O z&@YarbNkyu{J<|(X%^tAqJR(z9x3`s|NqSHL-+jK;iWoUrx;mlxuNc}{I43j&edD4 z^bGp1+C#QnS=r^kYWlx|L+Gba4kqf0`|Y1r8x7y!lfNxD-&W)(#MqBf%#rP;Qrk%I zkt;3j{tnaM+D87%$Qb>_iCudMgu~9;AVye1c7waPIJY>H4$ff%WV3;CB>-TU+AKr#QqvqvTEfXq#)tojp~xYrv;SX(L8M-yzDeFr-)+ z^STxTFbvo<3|;e2SeR0f-4bq!$IJY|2F^(S7dXQeWO@!~TEI1&elD=a8<vr6m<T;#p`VS+8x+P#7Ok1n$3giD!c>}*rsRgXBbFg-ua;}iRUb)r`kLM}XknljM z4DRY&Y{!hkLJU)zf}(DY;u5@zHR3p=v?$Lhi}@%YJ5X(XtO{pQ91!ab2Ds`)tD$-` zo?*0?AES#*E6sHc*b*-yj)o2&dwa8C*Q#8>kVt`ZfD5 zhNI7wBVqDcrH8QhSEUCB8@tmcIP^%Vf@Xgy|ANiy6k%|_wVsBwju^4_K2?5Az^(C0 zoiN~q5+uR~DS0>$_S7LgVMR-lf&q2N)XG+*ztB2@>?VZcK9j-HWIRSeQ*tQ*2~9|U(6+%W$Zdo$EQLHKfyq2>Ft{6O5YBcb*ATF}EB>z2gY4@BaT)m~BupYHq5DX(h$527qAI)ap#;_>O|&2v$kq47~O>|f~xN1SV)`XqlS$=NC)H( z#iMl3^sebP40lt{z-4(GZ93ObOXlO<8n=t&pdn{wh08$pW`+0Hkd$)uPn$?WFn&e` z$YJV6Oa!`JWUw%P7wID*GAeVG2HEIvnuZIk+883f6+1GDvT~Zdp;{LU>rzk_ZW~hS zC>oAQ7&a{>P2j(WY;A5mti+LDj88t1PpZ{Pn7fCx5L8x1e%Fklj>KY!xkVeH>0Xi% zbbHD1O$;K{IoWQSo6c%z&mhv?TQ!lnP6`}ev7btU_6o`aq9v44s6$XsWFUF$H2@xa z;KK2by^^7ol8OV}6E6i!R#Nq$*AuUf0z*>02)Im9!{9TT@`WX8O79X?2WcuiB(1n~ zzyQptS`-Y6EXm01;26$hzFq9d4si^{oE!@yx2U;7Q+BloH}-etXXiPxL!mQCndP{} zXd1M?V@}?ep*oP6MUIR?qG;a4P~Q_^8>pn9cS9-)4yh@F(rs73x=hMb@X=6n6gt;x z-+%#Y3{)NAo`FgrV6K|7K~gwwn`EMlgph8g8c5!hf?+A66Tb1J+DHUHD~0((Q4lpz zXzxdTDiQt)pq44&g@g)*ISfU@<^CRFa4du}!<{h7D)bMh77;`~%#NmvDyNjl$D9`L zwxEfmSVG8)qJk7q_ya@1(fU+W;y-VWOXtbLA}Y^O;t1)Vfi08Q8i}ssEc%SQyovYVdj}ErfQb7$9U= zpx~jJ!owa^J!syOnj>89Nol3NX{CkP*w{)caSSf5h3L8Bw@4CIF`Vf&?DFy=M}Cdr zR*W$`3oFG**vuJ*G-&3r&GZ)k@|q`Lm5N_k;C@hN=9P0Lsc4{>~)E< zxh+PtULpD==|c|9EzZr%bNE+gP<=>|R56ds22Cc_oCt-b^{G&>b=Szj>phBf;pcCe z)F%c=7)}`)VB6G%!6g|*0~{qHXL2*GoPwc_qSh`0Pb3}J9=l4xt1aa#d{aghDB;di zqYTIo)iWS&xMn#VeWJ=0_Kl@F`@^xrdNZVchynLsMd=~ox~~!Lq*$=rS%sO|t8r!v z%w9#cgDinFfbBbqhF|yK$Ig%Ny5*}WJ0q%6B3fXwgsPTwh*W$Ta)LII_@!HJNuC4v z!&G=Z7us~o$aMNsobZR+aXky#9hNtCfwMy7j#Z&#+~X7|OY zH&UF~-JnUW_i)?LTt`_G=hHSCZm**vO-`m6lAA4BiLRZ(eT#wk#mq5jS*1mo21+o1 zFn1%R*EyXXZwf=<*cr-b!_^`#)U5b5?u!G75W({GRHRzm59f)A07BZQRDEm-WX$yS zGvIa+H3Z}z?rP*bZ}@ySHCXWbmTE`9m;?*^daoP8oI_fj@ZAxL(&}G}D@m8D1<3H9TWWQQzD30JBl=N7O=?>CjRQv0;vZYvsr*$-sMvIe_!LT%|3s zJ5A&|HKl3TPnVI`MeG50qg7TYe2H22ua7Am6z-*D%$w>GxF}f6F|`VuW4WjitMs;a zYeHNFaQqRa52`f}=2zXEqU><_5oLnxS5%_Pxw{y6 z@h|v1ro1f9mEqmQh2j$vw~GxzzsHm(ba_nW2`gSv5{XX4s#*sU2UP@JNxvz9&Slu` zkYL1W)Bp*+r*=(qDZTogZ(r;@qno``Xn}GW{Xy+QzulTZxFn}r*DlOxt+7M8f)1)( z_$t=Ifi8enLMn+(sC^1LymmG269SP+y52t(dcZLyt$-~``c&=eB_ur9+8_jMl(-nr;PSBk2&hPvcSE z4ArpMR}BeN!VoQe+W-p!>1|+}N{1=kW5L2snmTaI zPH%)`DOf;6Ps7I>P2gQloJNTHV%qDNx3zOb0K3jMm%2PM!Yf!0IwmtI<# z$e>|YFWN4Yyhr!<7S;`=o2Z?G!=^teg-|e=#yBE+6UevR2K7YY{=ah@(6H<>X@`~T zXp8n8=K&ByX@%xStX%xajinYg^7Y*&zvRTH#K8|4vQEsi0H|v zga{*ZMGnV5uvlPI2dqRluovDDdU}how70e7093f0|0#=1GeSoOLJXVTY zME{Ij=p4ov!5GHWg**9J(x-M(?c#c$bvhC*l*zx&U6wo!Wo)?ya=WTd{k`; z6s|@vOQbL{hB*#B>N2;5*7cZm1l)~f+Q`JNFsD9a5cv8`5dq&eUNI8^3brQ94g$`{G3{J^_@<0eNNmcCAmHm}Odfodjki ztW986LDxj481^MH?+cw;Fs%rf-;&u5om$~ll$_FAVQDModl=N3=_>4O&8P@C+=i(G zkJ~VfAi6En6b83tw!yp&*mv{dFTF}=*N&Meg_8hwkSfSvcw;Z%f7*CkflhKQ-sSnXf*g^^;G2DOjWU_#I z-$y4@zsDE|f$Yu9W7^kvJ>6_6NsMW^w4lG$goqYcQZ`v z0%;WPOk%K-aA%y3gcB>7o5IcynXcI7{1LMohEP79F!P`{DWreQbSI!{inj^!Z!sP) zHpixfjfHsIQ+6BWFlP-D3ftE((XjAC#)oz)dy&{M%MilWGT&iJSjX%XHm_&aOQk6# zIgs&@Ru7wGWLq(Ls$Rkv3W=s-@h*c}$$vQ>_V|Fqc`1y0@5`4Xd@$qom`q-UNSdfnc z1lUx0zJ&>cW?wKtG7eRWfv19G~dPaBw$Vp(V_MwV-k++W(E_` zbPw~9aA^;NBaLVGF)!iQ{mcwS8V@bfCnGOr(D5@Bm2k6<``lqrKbD@j>QL0)zjw})Gdvqa_U)^jce-Jpb>eYm5S-jW>LF?lrKqX~Y$#%L>d z;u7g~41{5!w+>>iWAQQXI&(yPcnTwKU`8)Yy2<=PK>95vM>uecxvzkm518*nHYSI@ z8D?JyJH%0-{etv@X+L34#mi^j6!dz8IoSJ;Fc;qThN7bmW)PwmP;1rx{}#*$MN)*OlT&?aJ1oZw^O+#6P$^s)8W9$!z!^B&^UGDsstr z^~5iy<(ZM6l~Yh-t%uTLx%kgbolaL3UWr%)J_MQCLws{~tQEicAG<|G*%Gs}@qjLK zE~3bhhYh@JTZU7iDUNiFz01oG2s;U~p9@ZJ2^mR>Q;GioSN6b{X2_AQN@v>yDVeDi zYu%7K^}$yvl~tH)QKhS4lYulsq+JyuOt7o47O}OtDi##+s(hFeuNndN1l3ScQ!&8d z1XTfyPE@@Tyj!YXNrcokDlDF_wN?E^M;7FFEzQcp<|bTdk9#hS52C=4r1FOwNvfM9 zu5MjaR8S<~$_Yx>40zn85YknZ48L|&6-&j4%<=9j1KjC``>%)%QV96dO2CosL6}H- zs$L42@2QrD33(G$-s7PKul9wt3bk5LDb?wO>w6}t)(ZDYwXKCnzLC(gy;>vi9n?N5 zA{_26(_lAX548@K3{g|U(w^!Rugb-kG0j=1?gLL3s!u|!j}HsJ5~EyDELQK9!GYyC zz$t1B!h_}N5|dEAReekcT@I>^F2`@jHbzh3&_4Ah0y-a5n_%7nbpz32Njj(w5^fz( zPcgv80F1Od+iUc~>~rdGTR>u8Ru6-MH6Fq+Kg|v)u>Kk|^bgW>f(v`Ca^XslrlB6} zjWvmIv9-o57#eGKvv4I@uK}M9n&yy}!N?UZ=?=}KuyCUtnoyV#s_6(^vZe(@rD_;q zP_jnj1rxO<7LMj<{DJ=w!%*E{gO$(znm#^Q2~%TLc#?*NO?qrq4WFcG;_VUzqWmi8 zZyTDCSBg!2R~i0*&WT#=R+^;AhF*zUXJ0iGysyE2&mle>lrFMr;n@3{Ev_J*bL2TQ zHA+}JS@ZC988-N)X#Q~NQtPH-V-hQ(!SH;lCK$S}=Qwen70`MbhN{y;Rb2&ELsQD~ z;o>w+efVyg#t42(am#drK>_4+Y_CL2*JKIvrfZB+_+%EIX3huLKi)5kreM=-O-~qC zp*0J2=4g@#D4DBifYWEz&DF%h&AA$12$<&M4NFt4Bt*~C6bT>B)6^$~pXX~PNnp)R z(Mp)4QNf(^T29;=6)dmRJOUld$%VzBDU=ARMH(C`!_XUH=VE+%rx$A`h%j5BY>B1` ze7-~zR112)%B32c2z*;fS{ASmji$;X6DB&1nuX;{HJ4%PGEEEN@G_0r@+SOsW2uf|UX%YQZ~ zgpP+aluY>asAd)cJI;C;h2F<}_hivKS;Vaa?pqcJV`{(5r zV{fjb$RGB+(hR8eT@j^SQTy|Rc3!Pd$R)HRYkyxOw2oTeLT8EApQu#;Wm0V#>z|un zjQNqM0y+bK{%}UBjR46_O$4ksgi(zbuwp+$u1%B3MC246Dz!QZExuwK+`oyxP(^F~ zl@Q>etq=%LoXJQoKOV#zs3yXR&$SooyAc1&>)OsRy{(1;j~m+S z@cf202E=dzu?$)tpz6C)PC)(&neEURgb@1^#lLV zX2SP>Xw#u`n_2^nZ)vfI=a#mO(^M2&4Y`NYuXf$ihQsY!+60Kctql=+-PZPz2wU%H zv2l`mPg@9cA7VNm{Xk2@&3oD%(C|K1d%wP~%@8ZRA?^V#JO5C77QT6;-6Z5c)}E6H z9iM8~O5n+JtwZSdLR&2rf(Tt$JT&~#R|6a4btdrItY%ASrq913$l$1*ll=OPi84j_7RVQv|_5n|V2NtO_;R#9cH z#{QvDIF0oLbq8+?92-rkVB|11Uzw4YI{=e2jGM_u%AFrj)!tyXx_d>`9zCL_@zH4* zT-|<+&fi_)w#GzN&AIqmy@%!RvC=R{ zXU3T~ayk??oh6kDm#YpE$55s)x7*I&Wjed%p}P()Nogod3yOX%9P+n%X)WDhXCk{T_rr?~Y(PLT6+Be0T)v!YC z8w8u4Da_Dm5vzox(HaeG2DS&#KA4Z}*um05$^zEX5%yeW&BEB<+2dgn9Jc7pde{Qr zQpX2p3t?%4e?zH$|OaW__iGFmLTdwDvpThVy`W+p>Z=T+&ai-3` z4y1wKD7}{zhf5OkvG$1*tU_Etw$M;9b|*4XsG6q_6qe7^?`#SO$Jlhjv7`EUDMWX` zqB8r0{u35nn2wwHIK@ei zTt}IsDAL90aeT!O$78Zn^7Dqn@e-_R&N+;&z#S$7152aS;X>qdy1Y(seoqlJk&7zu%3Yfq`@E)HxN>OG5QdrD>@rIVV1(660+rnvsmhcVSqlQ4L?EE zFZ%kzH;myY8EhSgaltte?yiDH@kSM-u?7t+)*0r5-eAxRBUpn`0=v7>*gq*^lXEf= zEa9czfZdIAz9D5~KIULznlShU8}xqtv1#onO3cr0m0MhxmoZ%AZ#WODYgSQiVF^w` z3xRPS2EFJ-!x--7iOvxsvt1p8Fr%RXP8l*8KBBc^YOa5mjQjx(f9IjHM#`*kv&!S` zJl=!FegG=*^&Rgsl8Z796&Z-|hD+u)CCr4QJm{S@%Z-w+Hdf6>PZ zeF6-{vUipQ9YYN5ghe5S1ri}X%&<=hE35Seu+}r!DjVQ*t?u;MP+HM;T$$M@=XdH=P*V<*?2>9*goEX?_WO;bX-)st) zFu^bxZoH2x?)NibzB0w2gPs$y#eP576b@feMjbq8Z%%;9nFe3DJsE@TeEa+nUgho0 zb~8MmXlMs3reOT=dt~qwaBT`H)CYq^3sK+cC|IsE_JoaXv4TGKAwIm6j}6Vhz%i^7 z;HV!B-ol?B8*tjt8QQ23PJCj(9;CDD42{6N-Vg&kYpf&1rvpF57~9I7Rwx{&jh;&E ztSQOG8vVGsM!m=-=IV@IuM3|=8LbUmJS(j@r=ZN0IM+sWdthw9wrRJ5c33?uC>kD8 zJF8BV3gGvh&J0(hjh<#Pz1v9}*%()Fojb`ATGut&?QXvPABKmj^@fzjZ@h9YZd`lL z$TXLc>;x{9e!B{09W*H3sE#;;++u5(>0_*8tX+*`TCPv1_Ay!%?)RU3 zjLrPr6W3l)O=EW%G%ND;WpFy_0E`%+{-L3uu^DkbwcTidR9~Z7?VicS3t+gf(Z}zt zqE6y2{nMcEK!y$Qt-eN^-PPgET0?2~PCFHO_ZCMAcYKXs5OB)Rm?32O8=nw0OGynh z+G^fM1{%|A-p>RY8`r!Wf{bxB?|yjI#e{sPct3A98k^$W88?2smGAowm-y!;ki+qd5YcrWR7_-svJ>304V^RODydmt|WO(u~m9av|XNDXGcC|I>6{1rG^X1v! z7&=0b#%KiIVB}%B!N|ekV52S6&7iwtns%!Ed{KeuR&!+6sNOYs(9k*9Xovk3MvW_? zd3-L8pPZj%P($_(!z>66HlBxjI}Co1J{hyU=u|VvFzXox+5m4)@Xhm3O0dg3W2Yew z%#}tXF$|(BjmbhnwZT&YpYAqv@%ne}4;N2jDQ5oG(AFXz@INtgIIJ?--GV1UWi*gA zsaO!T(O{Kg;R4AAuxP!jGAKxlwlBe&|tN>S^2-WnsLxD5x!WDX~cHO5DPsH85+XuLk1s4lxFTEHRw!XeW}l3 zgAJNj;0S|ewzmrMTN-`;huJqSGMY8+{+MAneZ#C74-Ny8!vlp)6B!oqWg>o}D##0YR}vs$Trdw#3|hZ-A*1mr~8TcO74 ze{E)hAL|%xHEo447Yu`FVYAVANDgC1>*Q1oJr_e~Pwz&g`<7xcBy{EK#=fp}@dMFd z#I7TS4rK-}KhtIpvAx?b(a~kq3-|m?JtQz9 z&@==_1erMSs&7)$-LU(wg>zEj{UFmxDZF3D?LFY?#yHDr^VgOOcK|QLh;kW=dsVo47bYu{Ye* zQb>s~jVBea?Jhj3cRV;b()z6AKd& zZ?MRu`xg{p`ozpa^lc=8HP+M^Qks}7J|f-z9T?}SVyc8$cTBzzeMGM-|9hiu_|8*F zZeh6X?^VwJ|5Sl7Le!jV7L``3tLtcsTMSRi#ze{0roa>mJ`FLBTN;?G(652X_ce+)Z-}EPGa8z>bJ%z`JS-5D%0xQ*iC?eL zm#+=AYu^7m^mR_e{SAkl)|WVaUFQnwIbZ+h6};JnFk9W4C3J9h#9vO@cW<-E%fx$) zHHRmLzOj<-D8lVr=Jr1}haJ~2inM8LO21d4W_vnD{Pi=2J_nu zYxqbUG>gTgAo4t!xZ}{dE^A7zHNKk-J2_Vki>VR3C1OJSJE-qEHa8Ms%pVOqDvcp< zCl|Zmn-4Ym!HPu|6$~2Tp%KWgretI4+hkuWoxK(iZ^K@rNd0Srn#DoYQy+XGFU*7^ zf;lFN0BaLH)#bn6Ot7 zGWn{yII;?gvN6tG8v8LQi!m>JTxhc3L8FUJ^97MXISZYV-s0N6C|v`H^EJ%6_>uf&w` zZrQnxSPVQZ!2%V7?5%!ll*;QG3yy}El&~Tbt8JZ1O(8g?N*FrSq!m-Et`wO3g+pbg zY1pJI!+|uME3Xt%$C-S*VANvM572puiHEwgIS*m$64ShT#xmy}P|Tj+TtUVj|4zqD zKKK{@#OtAvj$wt4A{+?797J?kxJse(lptf1e`xW}Nbcrul{!fvbyQFogPq4E7}*Eo zOMSo}H?74Pe2G7p?AAE!h@eAi)ryW`S6a2dkn@A7K}Y!PDrt#yl(epOFVKBwCbJa( zE=28emtQ(06pl~C+1;P{nj85<;>66N5;0bR?`YHv;Y==bipCqhW?yZsCeA{W4SQ>s z*~}|J<8S8t3W{j1ywCVy3}QA34x0p`XkkjTs?*xAUe zgbk6{$3J%*jwoxxY+53;VwcJY=`m)tKt`K~nT5~Vnq~M_X_DFOQU>@wW)5cdvnVUK z;d`QYA}u&Kve2v-UbHiRgu@0M%m*Mh&xoy&S2#~qbD0fs#l;gc%yQ86HS1g|a9W|6 z1YJjSioSM?DH$j7;SduX--%Q52G~3dI91uB3k`2 zm0}&fi$eqi^9}f|v$?hQokF2i7qgmxe#KS=zDOzl(n_dM+SPoXfO+qkJz#2gb2B*I z-P}VM)5H9X5PpBpj5W5KL%eA)rI~Yt*=c5+YjJ3%8sB&Q!W*ZRPG(qf>nNDxjdNJ? zGR=M9=S*{5!J1|E!>Q_cKcRV%S>?PMBit=8f2sqB^=7e$3r8eRjx~pX?>O^F;qW-~ zNfPrye3oI0%|Y;ZnmHI&RM0XNz7?I6?fxAX$ewAAhv`aR3i?bp--R}nW*jK0#AiQa zhB-p0H`AP~gs7L8i)>nmgG(!?;@MRhIFH4r)U2TKNR9y*w;jc>ajTCRzMpHuw+i;- ztQ)^q8Uxlo6Q-E0X3Pih?Hrc_InOany!qC(Fe3}@UNP2D^{-tb22Hg!B@xBAk;5N$ z&9ynh$Bdz-M(pjV5zc-U<^Y(!*uxH$3o#z9Z*NdxG7@dbh}VjYKM;2{k&to%M?&^j z;KbYKSFi#RRnJBVs!DSd&O5KbE8aQ>Ctci`j)RJIz-+@m!(;Y_f%9-A%+>;jV>*CY z3oB;h&d0&*1Akq?J~nX#@pBaLAJTI85%A{WQDVWd00Z^T06#3i*zkU-g{vH>(ZcBk zX01j{Ji(^73tW8tZh?6T+{sodph8>)~UxXFU*0$z0GDq z4qpxNQ46eKjwCU`nB#@5JIzHBA!WDuF$u~xJ{mZ(f~CZCb~Vg9WIhT)ATHaa!H$n< zhs|Rk>U;AxL3_k(m%@!{KD59eH*0-`!aL^X5(P##?9GO%AGE=O8|C zdEH12M-&#lKq@WMqyqLwG{ryMq_&)>HAlJ{XBZ}HEJq1(f%uBRaV-Vyb(Tn2uCt`U zxKa4$Cc+cdtPsFjib6I1Z(Tx!C%FbIoNr<&72b=p=o}FD39WX<2>B`t4d1M>c))@c zmQ`@=fXD0dHn1VyhgOfo9{N1@PcB44MU|y7B>wh)+WYeGsEVxbr#nff(^)!u`gY%Y z`*x?hvq1K+B}&4UfC34-D3AmaAQI9c3HufX60CR&WH*);_|A<`>VRWBmtlA`~Lej73^DkojP^Ssj9P>6F>zzisfXAdfZ|P_bWE| zQ>=7phs6>LBjdnPm^DFhElRS#+em6EOHH6YzeC@bKE%uUKOVQ#7#V7Fz4Y2AEK@ZN z^|zm}EVs-cxOQl{vw@%&soyDRHZT5N_ z)!%(@85R=SP!IdRPk*!&hq9M#5`MB=Fe=Wb`OUCjC*9AMiMm>K%+HoRx|jx-__79D zz>Sc%vpP0OP5i}T(d%m(4tWGTJdZR8C5cp7Y7M0gr=3vRv7^nn9Jf1R^jj<>)4-|D z1lsK>zoE!CJXJ6 z^-L;m)n4!ocA<$b8HI3KZ5LAM>o`Z=+iXWF~etn4L>VV`jfZVE3! zM|V5TT8E``0I3+jl8&Pr-Y!6PUC$hrZSGVUJ-P%twJnAaf?m;PprsBATC%5M5PT-p zSt!?|h#%Zxx&j*HNiD{C(HTvdbwUHl4OotDvro{{a(fA8DlG?WfEX6aea#w1|EL#C z)RqZ|AVVgp0mDb#6zWJ8!f5+YYc#DJ?quizwRF~Su#pb0U~LagHPfhB*h|R7Rn`xv zp7R6)GV6<12!aI}c7{dqS~r1~+81ISWA~$b4vgF<0E}RLKQMT$oSv-*;Gi$)L-W29 z%1QbLt39E&6GuCX6^4y-FldhE18Xoij@UW3AdMsErnAl*YBO0OfTamJR5=ysGB6$G zSgx+0*5ZyCScxM}t8ZHbYu}m!tX)y<%umne{**PHHOBFoK>9_$XtTzE3X2o^}rYzaLww^;RPdnk>L^)JP$eUYU$7 z$?+?={eZn;^y*+Cm+l)6nBB4kWT8iHzahwtnfNPp_p#hx*s`yG14Vk&bq?)T_wqZS zE*qUF+@sustX#t|G*Gn}*w-W18*a^|=$)u`qq=`v;moCpWvF{(IEWu-c{>hax2BbW zmIMdR8RfeV0Y`eY!V5oA1~9c<0hqky*egLWneP;wRJu%n%d2v5TAtB;9@~z9cU+DH zAYX{E_SRs%VmQWgzzt%xV>sBx#^KmH!CCPh*Y|SzdIY`3fqj5bMoqi?<$h%s;`N5{ z&2AeoSCcx}-fI{Cr?y^?Vr=IjNv3Wa&(~F8&s|?h+j6{Sw;gAPQ$_Hzgx*+~r{-eW z4isbE{R@+aYd>oey;Fjra*hCUA4d!%xNST*N|;7Bp9k0QL`(uk@Vd8;hg=uj8@vyH4WKm>xGpnr@(uDUBLJrd z@1j|;*dYg|qDHq?lIYF?tTf-OJR`VSd(7i9E5~U;kBsjp`Uz26F&5cBz9edxq|uf* z`su!I8E07r$IoRCbjz4{8!|Yx>@momcGcFnVC8Qq|;zCT35a)@NS ze8x1a21j{b{st4!_wUoC{H@j9%9l(rXpB00rTs-CT2BKHYnVf3Vq80)w3b z90?9P2=4&6bOY$?xsb+g&?A|r0xmbGLpub3WbITTU7PG*3Yh50B);Hed(hm@fe`Ha zP~23Zvlzbq3PC?4fdn=t{ zHRyA5>1_4&BVl=Trn(Cl<49|5ig2^<7hC-xj|q;G*G+%e*`F>y4AOGu1eTz(99x}B zu>4%W({g8k1o5=$8Q?J=KH|)zwhSC1xVXD;S>Zd^fSxt!04TWzgkJh#En5$(sVF3>HZy?+z^1rA!dfAae|ylW0Rd2xdVX zSb_bd5D(6`vq6~3wO^a~Y;m1J#&g6&56pAfQb&=SBQSyUoRbR|7_i>!Cc$#wD zX`&}jF^SJ+o$TYWY+lm0*pi(7@S%3B#<8Sx3#cBdK|CpeRK#lflirn;w0MI$?cHN+{^o8>Q zWLz+$1+N;kjQ56Vw*f$f>+TwWP>kCLZWyRzfp!T2p2Pb1m5YV68{8zs)5d<*DB2lf z?MH2gt$4_XOypnwM0V>SX{*9nES3ub&u-j~@Jp1=g8+2XW(*!TCXnl~^7?#^Mt$Lt z!8%f_$&vb37oXSMu^sXcU;NT+O-U<`&i$N%kQk$6%MXD2IkA{vE;#)QJ9a| z*Rp@LU!!;S`)+|cmjgEq2hh^n`<wI3>sk9}lKP^Ss1^rxgBt#Q*D3$Eb4!*f+wIGn|8 zXfd_wp^N$V@Q4gtx2&FE8cq{0+LP4pzOlX*tv!G6SN_~ITNE{1g!O8}RwzSSN7y3O z<1w~>-lD!e+4fvvWaR{^p_(Ie|^muce$TW`Cjpn)6ZY^FlhUDpzdD>P_v zOd^?|LetyR&)p5rXsK-Xq@8{x)`9!rl`SO&=V1{=<)Put?te3q@veyt0< z0W$S0?Kvlq3WJZ$HcK8;3o_x2iYZMtYwpTn8`RYG6}P)q7{y&n7O47P;U>CVloWb% zv$sJRg82m|qfB3n4?KinVq7KD-Qv?AQ@qUOW1WIW`_}nLtZ7!)Z9*(qwe1<3H%0CL zmhGZm9e3OotEY$GvzeeMadM_3S>1ZVb}%g9?F4?o--8wZy7z74Bh{v}wj)tgchOcI z3-`i<>&Cz-aeZBFk&>sVmoD0#1yU!7p_Hx{Z=%O^qDy^ai(_6CZA%cPcC%=U?pmps z4kn11csAMjxMMTDA18Vg?yQ!9g29hDY=Amvuoq~!WyXupc8?b)>+5IIy8WUR0Tf3x z`ZcgU9#dWIth#KjYXBwXbO--rMc|jQ5tuZfxW zYg&(5ZH$Z|5dKx|iQ=dbT0d8eR%cm6?7$5fBA!wXCPlZ0OHu8jm_pk##VGn@i5a)8 zUPm#F&lCkC%s}cJFep0tp^``)nc`HnvX{68zLA*;XI=@a=}JV8+FT-9Lez%_iw|Y+ zP6(aAV!lCi(a}cqIeM=6BX(7(7)$aT(N3$q;&9lWcGSa~x^gxAF<$kGtrm6RTJigE z+I(7+Xx$;vMpdiC0qVd_;y#^Wc0DxI8`b}87L#=}6oDbt>aC(Xgx(>sST#Nm8#Cy_9x;{f-XD$|iZ`&!&=BGQY!}mL{UH&Trf-N*>XE(TgEyaEYXCK( zV|ze^*|cxx(+&piL2FA*)0qO!P;Vo%F!BfR(TD(p2P1qO8myBpC0Lq2pY=p-k@l48 zK%Z!t894Z77KA4^VD+{@ja?(E=&8ANFdIUb#%G{29y%yU8nu?`?48L86M_&yH@^xe z-pCCG0B>5gEXa8}77J%__wiwFE4vrMfhH?n5S#55;a zvXAKZSS_E*VF3Q=&PKC0i;bWqtELs60vcf7eKtI4CA074&W~7oeBlGb^z{f}_Ufgf zL=ZT^v>qL6B(rC6umUF=sYhbhQL!d&o+$YF1zW(dC@^D&x=Vk_A_w^e1M7uqI<-|a-dLN zZUBk6;~$^<@2(q-Z3u36%5BRu(1DN6toQFos_rAo)Y0lNz{f&hz^!zvEV-%r1YDtZ z+!Yrp_|;5#dyHXWi}I~Nqkj@hqSy?IlslY!cJqEOCZu2I28h9c1vI*z3s875ljbAuRJ5S&?n$ZGHmpp$>bRsIxO^@W@OTSc~v z+)|Vi%|I~*Z=Mo#y$z+DRjE+ZiT%b9Mi2iYCdFtlgqaej9<=Em(F*RFdsQsN3Iz~{ zSz<7}=uR&h=~$_l91)-vG$%|-r@t17BK-OvxF9A5W)i?E?T4R$`IZ*@fFAoVIQ@d| zb69{gu?6)*HCPb(nx%PmYY_Vq{be*T_(&h8(n2=c0sCap7H)hqtY}grcblHJ0Ip_`N&5cD)=W@T(av!k|EJsgXQ^%my zvalX(KuPDLW28=V6$8S+#?X>w^by4(I{a-CA|-Sgp5tbd1;#*W@YxDn#t1eu6N-68sR(B#+ zWHR|fOlamF0W|Bv>ok@@n>yek?&FPOng^aX0z1h^-Z{o*Fy!Ge>sT{1?~vH98W9_y zGg8;6?K|c;qDv8<mN2Oqv5e}Pxj;5Z+l+%*qdrR_+%vS6`DGh6>y zTH3>YS-ThUP+W|ZLAzq4kGp5|qd8`2Biinamjrc9th7(ppAS-*iHKF&sSoyREcAtM zYco#GXCK(wygVdViW_I^#Z1?=9q&(ujfW-49d}(ieVq?g?W!|MO#AX!L)_S&^{6Hy zIXQvpt+jf~hoJpd&X(#b=-{oUO!IY#OJm*eIIolsQ5X~8)=gUFZaj=}HeVA-t=-w1 zKMM`5L_-TX>+{W;H+SP{w`Ma0gLKY9CSnBL#@fxy?m7_ktQr`p84&l)mbXA7JlA5JX%$E%D*DWj1;Xs@a&E1Rmc^>UZkc5bAP#MsP+3D)}p;AAc z<=4az%8N)$pz1k}P*^Bw@)W}kgca)+qXm+2o*G{!eW_D#8ZP~4B&8}E4}i@v$v48$ z<)QE)jwobs^BONDs*A=*m63c~2G4Ebj2<#~?iEv|T{N)@{$HPQ$qB3!g4k5RXryGC zv^gVacgu~KxW7287Yjt{oLyJbl;xMTXsK0lX!k$dUNIL&z2r@WWvi)55@UYt`lhTL z8u~Q~YbwCy|5xsAe3w=<#+h71XAVM+QMTBM=;%avB-~Xk9oBPAd9!BU%pF}bQH=%( zh!|MC7#jDTb#MsLF-tP2pU#kA7HM1{Emk)ykfL?m7lQiOLTOA0U0ourQ14wT{h*`9 zbyB3dYq_++q~5$%Iu8qo`=$Bx_j{#c^*{GZ7od_`m>fwDZkLkva7DdyD{#!b869oj zE{T+L8oiC)DvhU@Yp`=DnG6TK4{gB3*~&OL7kF(%a+3Pm2I*u>u#pfr-=>-(_|ibf zQTqB?`rBht2KRBwqt1yLawL7(oEVd!c_r`#yW^fimQo1LT-yEy!|mcIY{u^igyXJ3YBhfzhSPj8pnL+H_Lvo`VT#;o4+ zgmlWF9@ry=#s!OoVruXc^&$3N)4llX+TWxIHo>SrN(-oBv$Tpr4r8-(&^QlE#T@hm z&^N2!9+p;^X;T$k7hgOKP53>>rIl*VyHa%omF3yt`E>>SPqXo;U;SM=7)jf{m0Xl` zUMf`go|ndk>vl&(Qv-G@Py%Hvm2%&-risllQj+)?Gyh4Wb;=VA(};C0S5W{xhA{$lDUop-qtc zz#*ua*8eP7RaKV%5JD~Yz_;Qir~F&G?L#<~Seh#LChNq=81?;Bd4`^HT(V?jLJDH4 z`GOX5^x1^)h48AOo#BanQNsi9o;OF7(JNLiLUodfFo= zYgE$EOa3H;QeJk%(X^ky?{zsa35hSnKu;IQ9X+g+@TcTt>U|S#)6E0m-u}`}a!45cet=v@U-pA)e$`+( zMNbb5mB*-G50y9QEIoIJkMHAl_v5%k`cs+wsj43?Z`D)B%TX~@@k;_c_ueWm4hdyJ zuxRCIc_v+)9B+ux+G+8*$f3_h%Ok1vRYM}(Rw3I%;QE7>m&ro^xiw9`P&$m7Blu0= zo7s-}r4FC-mlo|BmHQ3pD1+7IqDpzKK@$|8A0zkG`+m2Nk(1StDrb+tprjT_5ssE~`W(bRCKToC49^P;#X zfgUIClqb+lbL2@Dc5?Q03ddDiOjb4{y098(uxXCmLEi5WD)5m{%|^PsT6R#%U2-}l zMmyuwiUv7XpTt}oOoyI6lW!S@GfRR7+BjEM=uD%$&FIgkU0(S#&1eOyiwlKb!{3_Z zTLPKt_<8b39i3Z)!JTfFJK*bgPYVJnbhgN61BK{Ht6WBt7Ra$i7N3&I%;dNVN+ivf zBeal}BNoWA8ooe&GfX|RRNktiv7v~mxOchSMEDleVJqa%b!vW_oUV^XgzdWKp}slO zK^bVh|0#ok-rH!f^upnUg`#48Fb5+JCZ2Rj>k2E{_p-rC-=)DB{N&%r_XLLUVpwCqdq(YUIY-@imkiUsDeK@Dbj3EfkW9ZvZVipZ5mS?#z}I%& zCzsQudEjPK?!yWd-7k9t;|MFqpE-U=%dH#*XyCa;tCgm@7Cwz(cwQgtk)cX&} zYYY)g$kkj$?5s;dT$K-CebreP6HoV#fMHSTi*jO^mObwl3qr3BNVcf+UX)iw(m&0n z*{b{(xi*~M9|^mv1K+{)>xm06iCFL|)@9L25Yf_;@?=_hQVyqK-^u1!Tp!JE8C=t> zy%)4hRdY|t8{;YeGdV#uf5u4bkbePc|IsH%wEo|6I}QGqoT`raT>e>4%JVVV>cd~k zA4F09Px2VL`zJYFP5xQF1a~jha3a-VwhvJEnCy3ilOf)IA5DlwNY%&$d*U3*Twxcf zW&oZUXRfdhp*<_?Bh)J^?3rU}j5$0-S4aD;u(wyr;m-BellD>c$T_$M7NV6X!vcOY z1X;{fN>%rpqUetwLkyVpSLBZ#hVXUOpWvzR+Ac(vy82i9<{SpgS~xHC&eBdPOc>_3 zzmU3_{W3O4*K9ht4aQWH`XOxZj>B+Hc<~P~)05BGg{W?&z8VN;&?}Fjlj<|}5q(%E z(;MbD`@FXV`tUXmMrzj^IBhdl)gvM@4I+?=l^+S+7l?8E7`=MatQ=n4BkUN9a*!L10ci!nis$=S{FbJsP9fe7MrR>5wsoKK;~wFSR}tokF(J za2In?R^HN%p~upd9LoM6&ZwSH6a-v+H5Kus@GKXhp3P7ogf*Rv%~CV6m2AD*l&=iY zt8esGZugLLDxN$`!v$k3o}p&d;q-_Yh8!hnQ~&5hcr_h5Rry+v2rVy9Q`~y>Y_;+c zjIX96C<&_-YHF!pLZ!2m#P%6VR6L7*iqj_xgX?RCbPcfmGtE#kSQ{_RP>$+p=}cv- z8aqn?txuY*45w+cl_B)_Y-KY2JX`sJzO7e2qkr6~G|{Lzh+uNz9Fz(g8x&?x7#~Ha z<|vtTbq@MJT>^VaWYn;5zR`4KiejWkrXm9Bw++gRY+@Gmjk$`TqqB_)ZfSpO3?Fp| zC^^6Us;k9qQyudjj7#*og$nyh?`Fc@)eL+byD#IehBMh?2B^2GzP5YAN~N0Is+8&A_glGL{o{OP2-b3=C0R{g zs4UZ|TNWvkbp4hFB8;%u9dqgy7qP!4vd|2EuLQlj72#1EipaS{$x7~)(d2D`(^nuB zRV-0*v=Ak%&E>Rmi2}>wrAluW|09N~`?^D^V5zc0eGiW+I{N%>c;M#~+At7j-kHml zsYDMWHqnM8F)SU&?P& z&QSa+C08A?N_k7~gfvhyV>TSh`G5H3gupi)ygSaW-g=i(p^Nk5O3sZgCl~DJ!wdwr3QyU{lXj;stR}Pj9S>m zkp>+bjz=H6(Q!-nN_A<3;}2=H!sSR(rxiHfg4F_ZWIJGx!xD-($au9)cTUIkpp&`C@!uW? z-_E)B>+6#_`vQ#)@DsMdw5K%&e#ZM)mXGNb(_WJ?9|0{=6C#!A?1`Pq6_XMK} zw!`edU89FV(dPdv;QSw?fb&YE`urKkRg=sY97qJ&X&iTJkA)99U8eqDIC8p#Mx(i3 zI2yZtpZ&ryv+MV$FCFE&V)f8>jt_Ne{C_!K8mFEfmKyt1`Yi8wFJtLLx$u?^17U<( zGMTbxd9zx*S?pRTi;G2c_9d4>O`o{J(h76k#hi#W)Xi)yQUae#5U>C$El|@Mz~05_ z>jD=HB(J6l2&UzMUf_RHZM5K;>n5sw&y_&?zfR4gvtOqcss-Pq{xb@1bQ;mwmf~s) zemv&N4)^6ybc)+{=quO0&_K4jGt70nF2Y|`A)OIj-eGVhs9E8z4}*=WF^R72;j#XL z+00-%YhEkmh^{0Xn+6<|d21JE->5)8`XSq8R`W#H7+tXEdnH#wJ}E<823mXBl}N_% zu0-|rO4n39-8{i%qL^{6{v?ifMW{Q*xuW&dd!p++bxd+0Jjo>2=mPrcxTlal@Ot8D z)VrQ?dg3G?^mM65F%}`VcV2GOB69qan%aKK178^@Jjo$SLp`l}(e0!OURM&mu+o!6 z9sfxUqtUr&;@Uf|aLVlPtPktgvf&;H_S34&-_mV0m@4}G-=V-~r9W60d&;I!phf8!~xf|a1m%Ak##N75s-&9!* z$_sPIG;^)nM#I;-AB*nF{4!|FlZYr&x<3lu9%Pf1OeNr^hg#fmH1Mrtr8`Hw^IrF| zFwT78mM{t)R|-A-)MfX(pMwB#%_URqR=0!F*Seyp^AeEVe1|8R&c6@zd*MZQG;O)v zlS*%tdZN|MTiq5Nm9)E)Xx|hMl&#y{iF9R!)#5MRn~ZF4yc9_XbRLm1HhC=SXq{(uDMg*|M9@@o8dQ-( zPz!`HNsS!r*&sj@q_%zmoON-(r#BA$qI`m_fAqX7l%BoA^P_rcif5mWX4H97Y`$tZ zfHK?&5aOEotzN3B^9bqw0{_E4IE{H=ibqNEk41r3NVp=O&s||ZeOQDwuJk#hO5Ot=y5Td~i z0w&nqu$}lN98m-NA??~J;Kz_D9!n@r@vT&PpU0}ssPQ1!u6{Alr+T!flu~AR%4p6E z&k5C4=P59%m*#r@9NIT0Qz;v9+o)l+;)zlZH3OMcEbd{%8QKKARQ9@|VE&9}H*I>(Glh<-9t3pOr$GW&LF;#H zcAHh}ArAy?)JdkffA{=ZUGx{vyioPQKYJe6t4P?LNqrL15@@soWtW7cwcBVDrKPI7 f9cg%v${v~)yXNqyH2g`&pA7uTR1c5p6_fGbujd{w diff --git a/Atom/Resources/contextMenuCursor.png b/Atom/Resources/contextMenuCursor.png old mode 100755 new mode 100644 diff --git a/Atom/Resources/copyCursor.png b/Atom/Resources/copyCursor.png old mode 100755 new mode 100644 diff --git a/Atom/Resources/deleteButton.png b/Atom/Resources/deleteButton.png old mode 100755 new mode 100644 diff --git a/Atom/Resources/deleteButton.tiff b/Atom/Resources/deleteButton.tiff old mode 100755 new mode 100644 diff --git a/Atom/Resources/deleteButton@2x.png b/Atom/Resources/deleteButton@2x.png old mode 100755 new mode 100644 diff --git a/Atom/Resources/deleteButtonPressed.png b/Atom/Resources/deleteButtonPressed.png old mode 100755 new mode 100644 diff --git a/Atom/Resources/deleteButtonPressed.tiff b/Atom/Resources/deleteButtonPressed.tiff old mode 100755 new mode 100644 diff --git a/Atom/Resources/deleteButtonPressed@2x.png b/Atom/Resources/deleteButtonPressed@2x.png old mode 100755 new mode 100644 diff --git a/Atom/Resources/eastResizeCursor.png b/Atom/Resources/eastResizeCursor.png old mode 100755 new mode 100644 diff --git a/Atom/Resources/eastWestResizeCursor.png b/Atom/Resources/eastWestResizeCursor.png old mode 100755 new mode 100644 diff --git a/Atom/Resources/en.lproj/locale.pak b/Atom/Resources/en.lproj/locale.pak old mode 100755 new mode 100644 index 9425bdf36c54dc95343b22b963254d236fb0386f..00fc0cba9760b1ce9240c86627db0da44a786d86 GIT binary patch delta 674 zcmWO2TTISz9LMpWp3<02o2;=MN*|I#M4X)ICtkNf3r6gACE3VczT%#YjR{gk6 zf3QaXaJ|y_>jn+OjT(WQG#WQ62lqQ454aGcgWgW+yaNw;Hy-vrtalubIDtpqfepTg zao@+tFR{^Y@tD8haev1X{*6ukizl6)7Q!iKV6(IEw6pPyb1~rpJR7-~w73M%xeQxf zh3CB$FF1~EZo!N0!FKoIC1(x};j(k_ip%k;Yq7%-UUL^-cQ4*>5^uU6JDrst!Y%K? e+kSv|ocV;@^+)XTPYhuo{c(RvGPS*UXyQLRLw+a# delta 1388 zcmb8sTWl3o6b9fetrU%^FIZzDy3wveD;=#^6j1nUp%g?cv|tQMoObr%Ogf!`nK`Wo zTLLZPA5twy+bT|r%a>eGK-4Lr4`al zC&`m^vZQFGxU@7$nHpm)oGqC}~C09`ezKt*GJNS+s#t?lMm*{&ay-ukk=%(-EJUxnE z=rLTPAE4}drH-S9eu#jcK$d=lU335+Q>9MQ$);mq+nBS(NqLQ4OHruU8hZGbR1|W z=<>b5c65>tuS>-yEJWv8#mvsXo1)wP@o{KUp^4Iqf&>c(4os~@(V1ywsY&!so}4-t}f~O E3wT#{^#A|> diff --git a/Atom/Resources/helpCursor.png b/Atom/Resources/helpCursor.png old mode 100755 new mode 100644 diff --git a/Atom/Resources/inputSpeech.png b/Atom/Resources/inputSpeech.png old mode 100755 new mode 100644 diff --git a/Atom/Resources/inputSpeech.tiff b/Atom/Resources/inputSpeech.tiff old mode 100755 new mode 100644 diff --git a/Atom/Resources/linkCursor.png b/Atom/Resources/linkCursor.png old mode 100755 new mode 100644 diff --git a/Atom/Resources/missingImage.png b/Atom/Resources/missingImage.png old mode 100755 new mode 100644 diff --git a/Atom/Resources/missingImage.tiff b/Atom/Resources/missingImage.tiff old mode 100755 new mode 100644 diff --git a/Atom/Resources/missingImage@2x.png b/Atom/Resources/missingImage@2x.png old mode 100755 new mode 100644 diff --git a/Atom/Resources/moveCursor.png b/Atom/Resources/moveCursor.png old mode 100755 new mode 100644 diff --git a/Atom/Resources/noDropCursor.png b/Atom/Resources/noDropCursor.png old mode 100755 new mode 100644 diff --git a/Atom/Resources/noneCursor.png b/Atom/Resources/noneCursor.png old mode 100755 new mode 100644 diff --git a/Atom/Resources/northEastResizeCursor.png b/Atom/Resources/northEastResizeCursor.png old mode 100755 new mode 100644 diff --git a/Atom/Resources/northEastSouthWestResizeCursor.png b/Atom/Resources/northEastSouthWestResizeCursor.png old mode 100755 new mode 100644 diff --git a/Atom/Resources/northResizeCursor.png b/Atom/Resources/northResizeCursor.png old mode 100755 new mode 100644 diff --git a/Atom/Resources/northSouthResizeCursor.png b/Atom/Resources/northSouthResizeCursor.png old mode 100755 new mode 100644 diff --git a/Atom/Resources/northWestResizeCursor.png b/Atom/Resources/northWestResizeCursor.png old mode 100755 new mode 100644 diff --git a/Atom/Resources/northWestSouthEastResizeCursor.png b/Atom/Resources/northWestSouthEastResizeCursor.png old mode 100755 new mode 100644 diff --git a/Atom/Resources/nullPlugin.png b/Atom/Resources/nullPlugin.png old mode 100755 new mode 100644 diff --git a/Atom/Resources/nullPlugin@2x.png b/Atom/Resources/nullPlugin@2x.png old mode 100755 new mode 100644 diff --git a/Atom/Resources/panIcon.png b/Atom/Resources/panIcon.png old mode 100755 new mode 100644 diff --git a/Atom/Resources/progressCursor.png b/Atom/Resources/progressCursor.png old mode 100755 new mode 100644 diff --git a/Atom/Resources/southEastResizeCursor.png b/Atom/Resources/southEastResizeCursor.png old mode 100755 new mode 100644 diff --git a/Atom/Resources/southResizeCursor.png b/Atom/Resources/southResizeCursor.png old mode 100755 new mode 100644 diff --git a/Atom/Resources/southWestResizeCursor.png b/Atom/Resources/southWestResizeCursor.png old mode 100755 new mode 100644 diff --git a/Atom/Resources/textAreaResizeCorner.png b/Atom/Resources/textAreaResizeCorner.png old mode 100755 new mode 100644 diff --git a/Atom/Resources/textAreaResizeCorner.tiff b/Atom/Resources/textAreaResizeCorner.tiff old mode 100755 new mode 100644 diff --git a/Atom/Resources/textAreaResizeCorner@2x.png b/Atom/Resources/textAreaResizeCorner@2x.png old mode 100755 new mode 100644 diff --git a/Atom/Resources/urlIcon.png b/Atom/Resources/urlIcon.png old mode 100755 new mode 100644 diff --git a/Atom/Resources/verticalTextCursor.png b/Atom/Resources/verticalTextCursor.png old mode 100755 new mode 100644 diff --git a/Atom/Resources/waitCursor.png b/Atom/Resources/waitCursor.png old mode 100755 new mode 100644 diff --git a/Atom/Resources/westResizeCursor.png b/Atom/Resources/westResizeCursor.png old mode 100755 new mode 100644 diff --git a/Atom/Resources/zoomInCursor.png b/Atom/Resources/zoomInCursor.png old mode 100755 new mode 100644 diff --git a/Atom/Resources/zoomOutCursor.png b/Atom/Resources/zoomOutCursor.png old mode 100755 new mode 100644 diff --git a/cef/include/capi/cef_app_capi.h b/cef/include/capi/cef_app_capi.h new file mode 100644 index 000000000..8741966d6 --- /dev/null +++ b/cef/include/capi/cef_app_capi.h @@ -0,0 +1,122 @@ +// Copyright (c) 2012 Marshall A. Greenblatt. All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the name Chromium Embedded +// Framework nor the names of its contributors may be used to endorse +// or promote products derived from this software without specific prior +// written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +// --------------------------------------------------------------------------- +// +// This file was generated by the CEF translator tool and should not edited +// by hand. See the translator.README.txt file in the tools directory for +// more information. +// + +#ifndef CEF_INCLUDE_CAPI_CEF_APP_CAPI_H_ +#define CEF_INCLUDE_CAPI_CEF_APP_CAPI_H_ +#pragma once + +#ifdef __cplusplus +extern "C" { +#endif + +#include "include/capi/cef_base_capi.h" + + +/// +// This function should be called on the main application thread to initialize +// CEF when the application is started. The |application| parameter may be NULL. +// A return value of true (1) indicates that it succeeded and false (0) +// indicates that it failed. +/// +CEF_EXPORT int cef_initialize(const struct _cef_settings_t* settings, + struct _cef_app_t* application); + +/// +// This function should be called on the main application thread to shut down +// CEF before the application exits. +/// +CEF_EXPORT void cef_shutdown(); + +/// +// Perform a single iteration of CEF message loop processing. This function is +// used to integrate the CEF message loop into an existing application message +// loop. Care must be taken to balance performance against excessive CPU usage. +// This function should only be called on the main application thread and only +// if cef_initialize() is called with a CefSettings.multi_threaded_message_loop +// value of false (0). This function will not block. +/// +CEF_EXPORT void cef_do_message_loop_work(); + +/// +// Run the CEF message loop. Use this function instead of an application- +// provided message loop to get the best balance between performance and CPU +// usage. This function should only be called on the main application thread and +// only if cef_initialize() is called with a +// CefSettings.multi_threaded_message_loop value of false (0). This function +// will block until a quit message is received by the system. +/// +CEF_EXPORT void cef_run_message_loop(); + +/// +// Quit the CEF message loop that was started by calling cef_run_message_loop(). +// This function should only be called on the main application thread and only +// if cef_run_message_loop() was used. +/// +CEF_EXPORT void cef_quit_message_loop(); + +/// +// Implement this structure to provide handler implementations. Methods will be +// called on the thread indicated. +/// +typedef struct _cef_app_t { + /// + // Base structure. + /// + cef_base_t base; + + /// + // Return the handler for resource bundle events. If + // CefSettings.pack_loading_disabled is true (1) a handler must be returned. + // If no handler is returned resources will be loaded from pack files. This + // function is called on multiple threads. + /// + struct _cef_resource_bundle_handler_t* ( + CEF_CALLBACK *get_resource_bundle_handler)(struct _cef_app_t* self); + + /// + // Return the handler for proxy events. If not handler is returned the default + // system handler will be used. This function is called on the IO thread. + /// + struct _cef_proxy_handler_t* (CEF_CALLBACK *get_proxy_handler)( + struct _cef_app_t* self); +} cef_app_t; + + +#ifdef __cplusplus +} +#endif + +#endif // CEF_INCLUDE_CAPI_CEF_APP_CAPI_H_ diff --git a/cef/include/capi/cef_base_capi.h b/cef/include/capi/cef_base_capi.h new file mode 100644 index 000000000..0323520c5 --- /dev/null +++ b/cef/include/capi/cef_base_capi.h @@ -0,0 +1,85 @@ +// Copyright (c) 2011 Marshall A. Greenblatt. All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the name Chromium Embedded +// Framework nor the names of its contributors may be used to endorse +// or promote products derived from this software without specific prior +// written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + + +#ifndef CEF_INCLUDE_CAPI_CEF_BASE_CAPI_H_ +#define CEF_INCLUDE_CAPI_CEF_BASE_CAPI_H_ + +#ifdef __cplusplus +extern "C" { +#endif + +#include "include/internal/cef_export.h" +#include "include/internal/cef_string.h" +#include "include/internal/cef_string_list.h" +#include "include/internal/cef_string_map.h" +#include "include/internal/cef_string_multimap.h" +#include "include/internal/cef_types.h" + +/// +// Structure defining the reference count implementation functions. All +// framework structures must include the cef_base_t structure first. +/// +typedef struct _cef_base_t { + /// + // Size of the data structure. + /// + size_t size; + + /// + // Increment the reference count. + /// + int (CEF_CALLBACK *add_ref)(struct _cef_base_t* self); + + /// + // Decrement the reference count. Delete this object when no references + // remain. + /// + int (CEF_CALLBACK *release)(struct _cef_base_t* self); + + /// + // Returns the current number of references. + /// + int (CEF_CALLBACK *get_refct)(struct _cef_base_t* self); +} cef_base_t; + + +// Check that the structure |s|, which is defined with a cef_base_t member named +// |base|, is large enough to contain the specified member |f|. +#define CEF_MEMBER_EXISTS(s, f) \ + ((intptr_t)&((s)->f) - (intptr_t)(s) + sizeof((s)->f) <= (s)->base.size) + +#define CEF_MEMBER_MISSING(s, f) (!CEF_MEMBER_EXISTS(s, f) || !((s)->f)) + + +#ifdef __cplusplus +} +#endif + +#endif // CEF_INCLUDE_CAPI_CEF_BASE_CAPI_H_ diff --git a/cef/include/capi/cef_browser_capi.h b/cef/include/capi/cef_browser_capi.h new file mode 100644 index 000000000..60f8f4789 --- /dev/null +++ b/cef/include/capi/cef_browser_capi.h @@ -0,0 +1,322 @@ +// Copyright (c) 2012 Marshall A. Greenblatt. All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the name Chromium Embedded +// Framework nor the names of its contributors may be used to endorse +// or promote products derived from this software without specific prior +// written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +// --------------------------------------------------------------------------- +// +// This file was generated by the CEF translator tool and should not edited +// by hand. See the translator.README.txt file in the tools directory for +// more information. +// + +#ifndef CEF_INCLUDE_CAPI_CEF_BROWSER_CAPI_H_ +#define CEF_INCLUDE_CAPI_CEF_BROWSER_CAPI_H_ +#pragma once + +#ifdef __cplusplus +extern "C" { +#endif + +#include "include/capi/cef_base_capi.h" + + +/// +// Structure used to represent a browser window. The functions of this structure +// may be called on any thread unless otherwise indicated in the comments. +/// +typedef struct _cef_browser_t { + /// + // Base structure. + /// + cef_base_t base; + + /// + // Call this function before destroying a contained browser window. This + // function performs any internal cleanup that may be needed before the + // browser window is destroyed. + /// + void (CEF_CALLBACK *parent_window_will_close)(struct _cef_browser_t* self); + + /// + // Closes this browser window. + /// + void (CEF_CALLBACK *close_browser)(struct _cef_browser_t* self); + + /// + // Returns true (1) if the browser can navigate backwards. + /// + int (CEF_CALLBACK *can_go_back)(struct _cef_browser_t* self); + + /// + // Navigate backwards. + /// + void (CEF_CALLBACK *go_back)(struct _cef_browser_t* self); + + /// + // Returns true (1) if the browser can navigate forwards. + /// + int (CEF_CALLBACK *can_go_forward)(struct _cef_browser_t* self); + + /// + // Navigate forwards. + /// + void (CEF_CALLBACK *go_forward)(struct _cef_browser_t* self); + + /// + // Reload the current page. + /// + void (CEF_CALLBACK *reload)(struct _cef_browser_t* self); + + /// + // Reload the current page ignoring any cached data. + /// + void (CEF_CALLBACK *reload_ignore_cache)(struct _cef_browser_t* self); + + /// + // Stop loading the page. + /// + void (CEF_CALLBACK *stop_load)(struct _cef_browser_t* self); + + /// + // Set focus for the browser window. If |enable| is true (1) focus will be set + // to the window. Otherwise, focus will be removed. + /// + void (CEF_CALLBACK *set_focus)(struct _cef_browser_t* self, int enable); + + /// + // Retrieve the window handle for this browser. + /// + cef_window_handle_t (CEF_CALLBACK *get_window_handle)( + struct _cef_browser_t* self); + + /// + // Retrieve the window handle of the browser that opened this browser. Will + // return NULL for non-popup windows. This function can be used in combination + // with custom handling of modal windows. + /// + cef_window_handle_t (CEF_CALLBACK *get_opener_window_handle)( + struct _cef_browser_t* self); + + /// + // Returns true (1) if the window is a popup window. + /// + int (CEF_CALLBACK *is_popup)(struct _cef_browser_t* self); + + // Returns true (1) if a document has been loaded in the browser. + int (CEF_CALLBACK *has_document)(struct _cef_browser_t* self); + + /// + // Returns the client for this browser. + /// + struct _cef_client_t* (CEF_CALLBACK *get_client)(struct _cef_browser_t* self); + + /// + // Returns the main (top-level) frame for the browser window. + /// + struct _cef_frame_t* (CEF_CALLBACK *get_main_frame)( + struct _cef_browser_t* self); + + /// + // Returns the focused frame for the browser window. This function should only + // be called on the UI thread. + /// + struct _cef_frame_t* (CEF_CALLBACK *get_focused_frame)( + struct _cef_browser_t* self); + + /// + // Returns the frame with the specified name, or NULL if not found. This + // function should only be called on the UI thread. + /// + struct _cef_frame_t* (CEF_CALLBACK *get_frame)(struct _cef_browser_t* self, + const cef_string_t* name); + + /// + // Returns the names of all existing frames. This function should only be + // called on the UI thread. + /// + void (CEF_CALLBACK *get_frame_names)(struct _cef_browser_t* self, + cef_string_list_t names); + + /// + // Search for |searchText|. |identifier| can be used to have multiple searches + // running simultaniously. |forward| indicates whether to search forward or + // backward within the page. |matchCase| indicates whether the search should + // be case-sensitive. |findNext| indicates whether this is the first request + // or a follow-up. + /// + void (CEF_CALLBACK *find)(struct _cef_browser_t* self, int identifier, + const cef_string_t* searchText, int forward, int matchCase, + int findNext); + + /// + // Cancel all searches that are currently going on. + /// + void (CEF_CALLBACK *stop_finding)(struct _cef_browser_t* self, + int clearSelection); + + /// + // Get the zoom level. + /// + double (CEF_CALLBACK *get_zoom_level)(struct _cef_browser_t* self); + + /// + // Change the zoom level to the specified value. + /// + void (CEF_CALLBACK *set_zoom_level)(struct _cef_browser_t* self, + double zoomLevel); + + /// + // Clear the back/forward browsing history. + /// + void (CEF_CALLBACK *clear_history)(struct _cef_browser_t* self); + + /// + // Open developer tools in its own window. + /// + void (CEF_CALLBACK *show_dev_tools)(struct _cef_browser_t* self); + + /// + // Explicitly close the developer tools window if one exists for this browser + // instance. + /// + void (CEF_CALLBACK *close_dev_tools)(struct _cef_browser_t* self); + + /// + // Returns true (1) if window rendering is disabled. + /// + int (CEF_CALLBACK *is_window_rendering_disabled)(struct _cef_browser_t* self); + + /// + // Get the size of the specified element. This function should only be called + // on the UI thread. + /// + int (CEF_CALLBACK *get_size)(struct _cef_browser_t* self, + enum cef_paint_element_type_t type, int* width, int* height); + + /// + // Set the size of the specified element. This function is only used when + // window rendering is disabled. + /// + void (CEF_CALLBACK *set_size)(struct _cef_browser_t* self, + enum cef_paint_element_type_t type, int width, int height); + + /// + // Returns true (1) if a popup is currently visible. This function should only + // be called on the UI thread. + /// + int (CEF_CALLBACK *is_popup_visible)(struct _cef_browser_t* self); + + /// + // Hide the currently visible popup, if any. + /// + void (CEF_CALLBACK *hide_popup)(struct _cef_browser_t* self); + + /// + // Invalidate the |dirtyRect| region of the view. This function is only used + // when window rendering is disabled and will result in a call to + // HandlePaint(). + /// + void (CEF_CALLBACK *invalidate)(struct _cef_browser_t* self, + const cef_rect_t* dirtyRect); + + /// + // Get the raw image data contained in the specified element without + // performing validation. The specified |width| and |height| dimensions must + // match the current element size. On Windows |buffer| must be width*height*4 + // bytes in size and represents a BGRA image with an upper-left origin. This + // function should only be called on the UI thread. + /// + int (CEF_CALLBACK *get_image)(struct _cef_browser_t* self, + enum cef_paint_element_type_t type, int width, int height, + void* buffer); + + /// + // Send a key event to the browser. + /// + void (CEF_CALLBACK *send_key_event)(struct _cef_browser_t* self, + enum cef_key_type_t type, int key, int modifiers, int sysChar, + int imeChar); + + /// + // Send a mouse click event to the browser. The |x| and |y| coordinates are + // relative to the upper-left corner of the view. + /// + void (CEF_CALLBACK *send_mouse_click_event)(struct _cef_browser_t* self, + int x, int y, enum cef_mouse_button_type_t type, int mouseUp, + int clickCount); + + /// + // Send a mouse move event to the browser. The |x| and |y| coordinates are + // relative to the upper-left corner of the view. + /// + void (CEF_CALLBACK *send_mouse_move_event)(struct _cef_browser_t* self, int x, + int y, int mouseLeave); + + /// + // Send a mouse wheel event to the browser. The |x| and |y| coordinates are + // relative to the upper-left corner of the view. + /// + void (CEF_CALLBACK *send_mouse_wheel_event)(struct _cef_browser_t* self, + int x, int y, int delta); + + /// + // Send a focus event to the browser. + /// + void (CEF_CALLBACK *send_focus_event)(struct _cef_browser_t* self, + int setFocus); + + /// + // Send a capture lost event to the browser. + /// + void (CEF_CALLBACK *send_capture_lost_event)(struct _cef_browser_t* self); +} cef_browser_t; + + +/// +// Create a new browser window using the window parameters specified by +// |windowInfo|. All values will be copied internally and the actual window will +// be created on the UI thread. This function call will not block. +/// +CEF_EXPORT int cef_browser_create(cef_window_info_t* windowInfo, + struct _cef_client_t* client, const cef_string_t* url, + const struct _cef_browser_settings_t* settings); + +/// +// Create a new browser window using the window parameters specified by +// |windowInfo|. This function should only be called on the UI thread. +/// +CEF_EXPORT cef_browser_t* cef_browser_create_sync(cef_window_info_t* windowInfo, + struct _cef_client_t* client, const cef_string_t* url, + const struct _cef_browser_settings_t* settings); + + +#ifdef __cplusplus +} +#endif + +#endif // CEF_INCLUDE_CAPI_CEF_BROWSER_CAPI_H_ diff --git a/cef/include/capi/cef_client_capi.h b/cef/include/capi/cef_client_capi.h new file mode 100644 index 000000000..639acdae9 --- /dev/null +++ b/cef/include/capi/cef_client_capi.h @@ -0,0 +1,147 @@ +// Copyright (c) 2012 Marshall A. Greenblatt. All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the name Chromium Embedded +// Framework nor the names of its contributors may be used to endorse +// or promote products derived from this software without specific prior +// written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +// --------------------------------------------------------------------------- +// +// This file was generated by the CEF translator tool and should not edited +// by hand. See the translator.README.txt file in the tools directory for +// more information. +// + +#ifndef CEF_INCLUDE_CAPI_CEF_CLIENT_CAPI_H_ +#define CEF_INCLUDE_CAPI_CEF_CLIENT_CAPI_H_ +#pragma once + +#ifdef __cplusplus +extern "C" { +#endif + +#include "include/capi/cef_base_capi.h" + + +/// +// Implement this structure to provide handler implementations. +/// +typedef struct _cef_client_t { + /// + // Base structure. + /// + cef_base_t base; + + /// + // Return the handler for browser life span events. + /// + struct _cef_life_span_handler_t* (CEF_CALLBACK *get_life_span_handler)( + struct _cef_client_t* self); + + /// + // Return the handler for browser load status events. + /// + struct _cef_load_handler_t* (CEF_CALLBACK *get_load_handler)( + struct _cef_client_t* self); + + /// + // Return the handler for browser request events. + /// + struct _cef_request_handler_t* (CEF_CALLBACK *get_request_handler)( + struct _cef_client_t* self); + + /// + // Return the handler for browser display state events. + /// + struct _cef_display_handler_t* (CEF_CALLBACK *get_display_handler)( + struct _cef_client_t* self); + + /// + // Return the handler for focus events. + /// + struct _cef_focus_handler_t* (CEF_CALLBACK *get_focus_handler)( + struct _cef_client_t* self); + + /// + // Return the handler for keyboard events. + /// + struct _cef_keyboard_handler_t* (CEF_CALLBACK *get_keyboard_handler)( + struct _cef_client_t* self); + + /// + // Return the handler for context menu events. + /// + struct _cef_menu_handler_t* (CEF_CALLBACK *get_menu_handler)( + struct _cef_client_t* self); + + /// + // Return the handler for browser permission events. + /// + struct _cef_permission_handler_t* (CEF_CALLBACK *get_permission_handler)( + struct _cef_client_t* self); + + /// + // Return the handler for printing events. + /// + struct _cef_print_handler_t* (CEF_CALLBACK *get_print_handler)( + struct _cef_client_t* self); + + /// + // Return the handler for find result events. + /// + struct _cef_find_handler_t* (CEF_CALLBACK *get_find_handler)( + struct _cef_client_t* self); + + /// + // Return the handler for JavaScript dialog events. + /// + struct _cef_jsdialog_handler_t* (CEF_CALLBACK *get_jsdialog_handler)( + struct _cef_client_t* self); + + /// + // Return the handler for V8 context events. + /// + struct _cef_v8context_handler_t* (CEF_CALLBACK *get_v8context_handler)( + struct _cef_client_t* self); + + /// + // Return the handler for off-screen rendering events. + /// + struct _cef_render_handler_t* (CEF_CALLBACK *get_render_handler)( + struct _cef_client_t* self); + + /// + // Return the handler for drag events. + /// + struct _cef_drag_handler_t* (CEF_CALLBACK *get_drag_handler)( + struct _cef_client_t* self); +} cef_client_t; + + +#ifdef __cplusplus +} +#endif + +#endif // CEF_INCLUDE_CAPI_CEF_CLIENT_CAPI_H_ diff --git a/cef/include/capi/cef_command_line_capi.h b/cef/include/capi/cef_command_line_capi.h new file mode 100644 index 000000000..a5a5ea9fc --- /dev/null +++ b/cef/include/capi/cef_command_line_capi.h @@ -0,0 +1,169 @@ +// Copyright (c) 2012 Marshall A. Greenblatt. All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the name Chromium Embedded +// Framework nor the names of its contributors may be used to endorse +// or promote products derived from this software without specific prior +// written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +// --------------------------------------------------------------------------- +// +// This file was generated by the CEF translator tool and should not edited +// by hand. See the translator.README.txt file in the tools directory for +// more information. +// + +#ifndef CEF_INCLUDE_CAPI_CEF_COMMAND_LINE_CAPI_H_ +#define CEF_INCLUDE_CAPI_CEF_COMMAND_LINE_CAPI_H_ +#pragma once + +#ifdef __cplusplus +extern "C" { +#endif + +#include "include/capi/cef_base_capi.h" + + +/// +// Structure used to create and/or parse command line arguments. Arguments with +// '--', '-' and, on Windows, '/' prefixes are considered switches. Switches +// will always precede any arguments without switch prefixes. Switches can +// optionally have a value specified using the '=' delimiter (e.g. +// "-switch=value"). An argument of "--" will terminate switch parsing with all +// subsequent tokens, regardless of prefix, being interpreted as non-switch +// arguments. Switch names are considered case-insensitive. This structure can +// be used before cef_initialize() is called. +/// +typedef struct _cef_command_line_t { + /// + // Base structure. + /// + cef_base_t base; + + /// + // Initialize the command line with the specified |argc| and |argv| values. + // The first argument must be the name of the program. This function is only + // supported on non-Windows platforms. + /// + void (CEF_CALLBACK *init_from_argv)(struct _cef_command_line_t* self, + int argc, const char* const* argv); + + /// + // Initialize the command line with the string returned by calling + // GetCommandLineW(). This function is only supported on Windows. + /// + void (CEF_CALLBACK *init_from_string)(struct _cef_command_line_t* self, + const cef_string_t* command_line); + + /// + // Constructs and returns the represented command line string. Use this + // function cautiously because quoting behavior is unclear. + /// + // The resulting string must be freed by calling cef_string_userfree_free(). + cef_string_userfree_t (CEF_CALLBACK *get_command_line_string)( + struct _cef_command_line_t* self); + + /// + // Get the program part of the command line string (the first item). + /// + // The resulting string must be freed by calling cef_string_userfree_free(). + cef_string_userfree_t (CEF_CALLBACK *get_program)( + struct _cef_command_line_t* self); + + /// + // Set the program part of the command line string (the first item). + /// + void (CEF_CALLBACK *set_program)(struct _cef_command_line_t* self, + const cef_string_t* program); + + /// + // Returns true (1) if the command line has switches. + /// + int (CEF_CALLBACK *has_switches)(struct _cef_command_line_t* self); + + /// + // Returns true (1) if the command line contains the given switch. + /// + int (CEF_CALLBACK *has_switch)(struct _cef_command_line_t* self, + const cef_string_t* name); + + /// + // Returns the value associated with the given switch. If the switch has no + // value or isn't present this function returns the NULL string. + /// + // The resulting string must be freed by calling cef_string_userfree_free(). + cef_string_userfree_t (CEF_CALLBACK *get_switch_value)( + struct _cef_command_line_t* self, const cef_string_t* name); + + /// + // Returns the map of switch names and values. If a switch has no value an + // NULL string is returned. + /// + void (CEF_CALLBACK *get_switches)(struct _cef_command_line_t* self, + cef_string_map_t switches); + + /// + // Add a switch to the end of the command line. If the switch has no value + // pass an NULL value string. + /// + void (CEF_CALLBACK *append_switch)(struct _cef_command_line_t* self, + const cef_string_t* name); + + /// + // Add a switch with the specified value to the end of the command line. + /// + void (CEF_CALLBACK *append_switch_with_value)( + struct _cef_command_line_t* self, const cef_string_t* name, + const cef_string_t* value); + + /// + // True if there are remaining command line arguments. + /// + int (CEF_CALLBACK *has_arguments)(struct _cef_command_line_t* self); + + /// + // Get the remaining command line arguments. + /// + void (CEF_CALLBACK *get_arguments)(struct _cef_command_line_t* self, + cef_string_list_t arguments); + + /// + // Add an argument to the end of the command line. + /// + void (CEF_CALLBACK *append_argument)(struct _cef_command_line_t* self, + const cef_string_t* argument); +} cef_command_line_t; + + +/// +// Create a new cef_command_line_t instance. +/// +CEF_EXPORT cef_command_line_t* cef_command_line_create(); + + +#ifdef __cplusplus +} +#endif + +#endif // CEF_INCLUDE_CAPI_CEF_COMMAND_LINE_CAPI_H_ diff --git a/cef/include/capi/cef_content_filter_capi.h b/cef/include/capi/cef_content_filter_capi.h new file mode 100644 index 000000000..e9ed878a4 --- /dev/null +++ b/cef/include/capi/cef_content_filter_capi.h @@ -0,0 +1,80 @@ +// Copyright (c) 2012 Marshall A. Greenblatt. All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the name Chromium Embedded +// Framework nor the names of its contributors may be used to endorse +// or promote products derived from this software without specific prior +// written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +// --------------------------------------------------------------------------- +// +// This file was generated by the CEF translator tool and should not edited +// by hand. See the translator.README.txt file in the tools directory for +// more information. +// + +#ifndef CEF_INCLUDE_CAPI_CEF_CONTENT_FILTER_CAPI_H_ +#define CEF_INCLUDE_CAPI_CEF_CONTENT_FILTER_CAPI_H_ +#pragma once + +#ifdef __cplusplus +extern "C" { +#endif + +#include "include/capi/cef_base_capi.h" + + +/// +// Structure to implement for filtering response content. The functions of this +// structure will always be called on the UI thread. +/// +typedef struct _cef_content_filter_t { + /// + // Base structure. + /// + cef_base_t base; + + /// + // Set |substitute_data| to the replacement for the data in |data| if data + // should be modified. + /// + void (CEF_CALLBACK *process_data)(struct _cef_content_filter_t* self, + const void* data, int data_size, + struct _cef_stream_reader_t** substitute_data); + + /// + // Called when there is no more data to be processed. It is expected that + // whatever data was retained in the last process_data() call, it should be + // returned now by setting |remainder| if appropriate. + /// + void (CEF_CALLBACK *drain)(struct _cef_content_filter_t* self, + struct _cef_stream_reader_t** remainder); +} cef_content_filter_t; + + +#ifdef __cplusplus +} +#endif + +#endif // CEF_INCLUDE_CAPI_CEF_CONTENT_FILTER_CAPI_H_ diff --git a/cef/include/capi/cef_cookie_capi.h b/cef/include/capi/cef_cookie_capi.h new file mode 100644 index 000000000..d5c6d9bb6 --- /dev/null +++ b/cef/include/capi/cef_cookie_capi.h @@ -0,0 +1,158 @@ +// Copyright (c) 2012 Marshall A. Greenblatt. All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the name Chromium Embedded +// Framework nor the names of its contributors may be used to endorse +// or promote products derived from this software without specific prior +// written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +// --------------------------------------------------------------------------- +// +// This file was generated by the CEF translator tool and should not edited +// by hand. See the translator.README.txt file in the tools directory for +// more information. +// + +#ifndef CEF_INCLUDE_CAPI_CEF_COOKIE_CAPI_H_ +#define CEF_INCLUDE_CAPI_CEF_COOKIE_CAPI_H_ +#pragma once + +#ifdef __cplusplus +extern "C" { +#endif + +#include "include/capi/cef_base_capi.h" + + +/// +// Structure used for managing cookies. The functions of this structure may be +// called on any thread unless otherwise indicated. +/// +typedef struct _cef_cookie_manager_t { + /// + // Base structure. + /// + cef_base_t base; + + /// + // Set the schemes supported by this manager. By default only "http" and + // "https" schemes are supported. Must be called before any cookies are + // accessed. + /// + void (CEF_CALLBACK *set_supported_schemes)(struct _cef_cookie_manager_t* self, + cef_string_list_t schemes); + + /// + // Visit all cookies. The returned cookies are ordered by longest path, then + // by earliest creation date. Returns false (0) if cookies cannot be accessed. + /// + int (CEF_CALLBACK *visit_all_cookies)(struct _cef_cookie_manager_t* self, + struct _cef_cookie_visitor_t* visitor); + + /// + // Visit a subset of cookies. The results are filtered by the given url + // scheme, host, domain and path. If |includeHttpOnly| is true (1) HTTP-only + // cookies will also be included in the results. The returned cookies are + // ordered by longest path, then by earliest creation date. Returns false (0) + // if cookies cannot be accessed. + /// + int (CEF_CALLBACK *visit_url_cookies)(struct _cef_cookie_manager_t* self, + const cef_string_t* url, int includeHttpOnly, + struct _cef_cookie_visitor_t* visitor); + + /// + // Sets a cookie given a valid URL and explicit user-provided cookie + // attributes. This function expects each attribute to be well-formed. It will + // check for disallowed characters (e.g. the ';' character is disallowed + // within the cookie value attribute) and will return false (0) without + // setting the cookie if such characters are found. This function must be + // called on the IO thread. + /// + int (CEF_CALLBACK *set_cookie)(struct _cef_cookie_manager_t* self, + const cef_string_t* url, const struct _cef_cookie_t* cookie); + + /// + // Delete all cookies that match the specified parameters. If both |url| and + // values |cookie_name| are specified all host and domain cookies matching + // both will be deleted. If only |url| is specified all host cookies (but not + // domain cookies) irrespective of path will be deleted. If |url| is NULL all + // cookies for all hosts and domains will be deleted. Returns false (0) if a + // non- NULL invalid URL is specified or if cookies cannot be accessed. This + // function must be called on the IO thread. + /// + int (CEF_CALLBACK *delete_cookies)(struct _cef_cookie_manager_t* self, + const cef_string_t* url, const cef_string_t* cookie_name); + + /// + // Sets the directory path that will be used for storing cookie data. If + // |path| is NULL data will be stored in memory only. Returns false (0) if + // cookies cannot be accessed. + /// + int (CEF_CALLBACK *set_storage_path)(struct _cef_cookie_manager_t* self, + const cef_string_t* path); +} cef_cookie_manager_t; + + +/// +// Returns the global cookie manager. By default data will be stored at +// CefSettings.cache_path if specified or in memory otherwise. +/// +CEF_EXPORT cef_cookie_manager_t* cef_cookie_manager_get_global_manager(); + +/// +// Creates a new cookie manager. If |path| is NULL data will be stored in memory +// only. Returns NULL if creation fails. +/// +CEF_EXPORT cef_cookie_manager_t* cef_cookie_manager_create_manager( + const cef_string_t* path); + + +/// +// Structure to implement for visiting cookie values. The functions of this +// structure will always be called on the IO thread. +/// +typedef struct _cef_cookie_visitor_t { + /// + // Base structure. + /// + cef_base_t base; + + /// + // Method that will be called once for each cookie. |count| is the 0-based + // index for the current cookie. |total| is the total number of cookies. Set + // |deleteCookie| to true (1) to delete the cookie currently being visited. + // Return false (0) to stop visiting cookies. This function may never be + // called if no cookies are found. + /// + int (CEF_CALLBACK *visit)(struct _cef_cookie_visitor_t* self, + const struct _cef_cookie_t* cookie, int count, int total, + int* deleteCookie); +} cef_cookie_visitor_t; + + +#ifdef __cplusplus +} +#endif + +#endif // CEF_INCLUDE_CAPI_CEF_COOKIE_CAPI_H_ diff --git a/cef/include/capi/cef_display_handler_capi.h b/cef/include/capi/cef_display_handler_capi.h new file mode 100644 index 000000000..5f2ea0fb9 --- /dev/null +++ b/cef/include/capi/cef_display_handler_capi.h @@ -0,0 +1,117 @@ +// Copyright (c) 2012 Marshall A. Greenblatt. All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the name Chromium Embedded +// Framework nor the names of its contributors may be used to endorse +// or promote products derived from this software without specific prior +// written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +// --------------------------------------------------------------------------- +// +// This file was generated by the CEF translator tool and should not edited +// by hand. See the translator.README.txt file in the tools directory for +// more information. +// + +#ifndef CEF_INCLUDE_CAPI_CEF_DISPLAY_HANDLER_CAPI_H_ +#define CEF_INCLUDE_CAPI_CEF_DISPLAY_HANDLER_CAPI_H_ +#pragma once + +#ifdef __cplusplus +extern "C" { +#endif + +#include "include/capi/cef_base_capi.h" + + +/// +// Implement this structure to handle events related to browser display state. +// The functions of this structure will be called on the UI thread. +/// +typedef struct _cef_display_handler_t { + /// + // Base structure. + /// + cef_base_t base; + + /// + // Called when the navigation state has changed. + /// + void (CEF_CALLBACK *on_nav_state_change)(struct _cef_display_handler_t* self, + struct _cef_browser_t* browser, int canGoBack, int canGoForward); + + /// + // Called when a frame's address has changed. + /// + void (CEF_CALLBACK *on_address_change)(struct _cef_display_handler_t* self, + struct _cef_browser_t* browser, struct _cef_frame_t* frame, + const cef_string_t* url); + + /// + // Called when the size of the content area has changed. + /// + void (CEF_CALLBACK *on_contents_size_change)( + struct _cef_display_handler_t* self, struct _cef_browser_t* browser, + struct _cef_frame_t* frame, int width, int height); + + /// + // Called when the page title changes. + /// + void (CEF_CALLBACK *on_title_change)(struct _cef_display_handler_t* self, + struct _cef_browser_t* browser, const cef_string_t* title); + + /// + // Called when the browser is about to display a tooltip. |text| contains the + // text that will be displayed in the tooltip. To handle the display of the + // tooltip yourself return true (1). Otherwise, you can optionally modify + // |text| and then return false (0) to allow the browser to display the + // tooltip. + /// + int (CEF_CALLBACK *on_tooltip)(struct _cef_display_handler_t* self, + struct _cef_browser_t* browser, cef_string_t* text); + + /// + // Called when the browser receives a status message. |text| contains the text + // that will be displayed in the status message and |type| indicates the + // status message type. + /// + void (CEF_CALLBACK *on_status_message)(struct _cef_display_handler_t* self, + struct _cef_browser_t* browser, const cef_string_t* value, + enum cef_handler_statustype_t type); + + /// + // Called to display a console message. Return true (1) to stop the message + // from being output to the console. + /// + int (CEF_CALLBACK *on_console_message)(struct _cef_display_handler_t* self, + struct _cef_browser_t* browser, const cef_string_t* message, + const cef_string_t* source, int line); +} cef_display_handler_t; + + +#ifdef __cplusplus +} +#endif + +#endif // CEF_INCLUDE_CAPI_CEF_DISPLAY_HANDLER_CAPI_H_ diff --git a/cef/include/capi/cef_dom_capi.h b/cef/include/capi/cef_dom_capi.h new file mode 100644 index 000000000..1807ea203 --- /dev/null +++ b/cef/include/capi/cef_dom_capi.h @@ -0,0 +1,441 @@ +// Copyright (c) 2012 Marshall A. Greenblatt. All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the name Chromium Embedded +// Framework nor the names of its contributors may be used to endorse +// or promote products derived from this software without specific prior +// written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +// --------------------------------------------------------------------------- +// +// This file was generated by the CEF translator tool and should not edited +// by hand. See the translator.README.txt file in the tools directory for +// more information. +// + +#ifndef CEF_INCLUDE_CAPI_CEF_DOM_CAPI_H_ +#define CEF_INCLUDE_CAPI_CEF_DOM_CAPI_H_ +#pragma once + +#ifdef __cplusplus +extern "C" { +#endif + +#include "include/capi/cef_base_capi.h" + + +/// +// Structure to implement for visiting the DOM. The functions of this structure +// will be called on the UI thread. +/// +typedef struct _cef_domvisitor_t { + /// + // Base structure. + /// + cef_base_t base; + + /// + // Method executed for visiting the DOM. The document object passed to this + // function represents a snapshot of the DOM at the time this function is + // executed. DOM objects are only valid for the scope of this function. Do not + // keep references to or attempt to access any DOM objects outside the scope + // of this function. + /// + void (CEF_CALLBACK *visit)(struct _cef_domvisitor_t* self, + struct _cef_domdocument_t* document); +} cef_domvisitor_t; + + +/// +// Structure used to represent a DOM document. The functions of this structure +// should only be called on the UI thread. +/// +typedef struct _cef_domdocument_t { + /// + // Base structure. + /// + cef_base_t base; + + /// + // Returns the document type. + /// + enum cef_dom_document_type_t (CEF_CALLBACK *get_type)( + struct _cef_domdocument_t* self); + + /// + // Returns the root document node. + /// + struct _cef_domnode_t* (CEF_CALLBACK *get_document)( + struct _cef_domdocument_t* self); + + /// + // Returns the BODY node of an HTML document. + /// + struct _cef_domnode_t* (CEF_CALLBACK *get_body)( + struct _cef_domdocument_t* self); + + /// + // Returns the HEAD node of an HTML document. + /// + struct _cef_domnode_t* (CEF_CALLBACK *get_head)( + struct _cef_domdocument_t* self); + + /// + // Returns the title of an HTML document. + /// + // The resulting string must be freed by calling cef_string_userfree_free(). + cef_string_userfree_t (CEF_CALLBACK *get_title)( + struct _cef_domdocument_t* self); + + /// + // Returns the document element with the specified ID value. + /// + struct _cef_domnode_t* (CEF_CALLBACK *get_element_by_id)( + struct _cef_domdocument_t* self, const cef_string_t* id); + + /// + // Returns the node that currently has keyboard focus. + /// + struct _cef_domnode_t* (CEF_CALLBACK *get_focused_node)( + struct _cef_domdocument_t* self); + + /// + // Returns true (1) if a portion of the document is selected. + /// + int (CEF_CALLBACK *has_selection)(struct _cef_domdocument_t* self); + + /// + // Returns the selection start node. + /// + struct _cef_domnode_t* (CEF_CALLBACK *get_selection_start_node)( + struct _cef_domdocument_t* self); + + /// + // Returns the selection offset within the start node. + /// + int (CEF_CALLBACK *get_selection_start_offset)( + struct _cef_domdocument_t* self); + + /// + // Returns the selection end node. + /// + struct _cef_domnode_t* (CEF_CALLBACK *get_selection_end_node)( + struct _cef_domdocument_t* self); + + /// + // Returns the selection offset within the end node. + /// + int (CEF_CALLBACK *get_selection_end_offset)(struct _cef_domdocument_t* self); + + /// + // Returns the contents of this selection as markup. + /// + // The resulting string must be freed by calling cef_string_userfree_free(). + cef_string_userfree_t (CEF_CALLBACK *get_selection_as_markup)( + struct _cef_domdocument_t* self); + + /// + // Returns the contents of this selection as text. + /// + // The resulting string must be freed by calling cef_string_userfree_free(). + cef_string_userfree_t (CEF_CALLBACK *get_selection_as_text)( + struct _cef_domdocument_t* self); + + /// + // Returns the base URL for the document. + /// + // The resulting string must be freed by calling cef_string_userfree_free(). + cef_string_userfree_t (CEF_CALLBACK *get_base_url)( + struct _cef_domdocument_t* self); + + /// + // Returns a complete URL based on the document base URL and the specified + // partial URL. + /// + // The resulting string must be freed by calling cef_string_userfree_free(). + cef_string_userfree_t (CEF_CALLBACK *get_complete_url)( + struct _cef_domdocument_t* self, const cef_string_t* partialURL); +} cef_domdocument_t; + + +/// +// Structure used to represent a DOM node. The functions of this structure +// should only be called on the UI thread. +/// +typedef struct _cef_domnode_t { + /// + // Base structure. + /// + cef_base_t base; + + /// + // Returns the type for this node. + /// + enum cef_dom_node_type_t (CEF_CALLBACK *get_type)( + struct _cef_domnode_t* self); + + /// + // Returns true (1) if this is a text node. + /// + int (CEF_CALLBACK *is_text)(struct _cef_domnode_t* self); + + /// + // Returns true (1) if this is an element node. + /// + int (CEF_CALLBACK *is_element)(struct _cef_domnode_t* self); + + /// + // Returns true (1) if this is a form control element node. + /// + int (CEF_CALLBACK *is_form_control_element)(struct _cef_domnode_t* self); + + /// + // Returns the type of this form control element node. + /// + // The resulting string must be freed by calling cef_string_userfree_free(). + cef_string_userfree_t (CEF_CALLBACK *get_form_control_element_type)( + struct _cef_domnode_t* self); + + /// + // Returns true (1) if this object is pointing to the same handle as |that| + // object. + /// + int (CEF_CALLBACK *is_same)(struct _cef_domnode_t* self, + struct _cef_domnode_t* that); + + /// + // Returns the name of this node. + /// + // The resulting string must be freed by calling cef_string_userfree_free(). + cef_string_userfree_t (CEF_CALLBACK *get_name)(struct _cef_domnode_t* self); + + /// + // Returns the value of this node. + /// + // The resulting string must be freed by calling cef_string_userfree_free(). + cef_string_userfree_t (CEF_CALLBACK *get_value)(struct _cef_domnode_t* self); + + /// + // Set the value of this node. Returns true (1) on success. + /// + int (CEF_CALLBACK *set_value)(struct _cef_domnode_t* self, + const cef_string_t* value); + + /// + // Returns the contents of this node as markup. + /// + // The resulting string must be freed by calling cef_string_userfree_free(). + cef_string_userfree_t (CEF_CALLBACK *get_as_markup)( + struct _cef_domnode_t* self); + + /// + // Returns the document associated with this node. + /// + struct _cef_domdocument_t* (CEF_CALLBACK *get_document)( + struct _cef_domnode_t* self); + + /// + // Returns the parent node. + /// + struct _cef_domnode_t* (CEF_CALLBACK *get_parent)( + struct _cef_domnode_t* self); + + /// + // Returns the previous sibling node. + /// + struct _cef_domnode_t* (CEF_CALLBACK *get_previous_sibling)( + struct _cef_domnode_t* self); + + /// + // Returns the next sibling node. + /// + struct _cef_domnode_t* (CEF_CALLBACK *get_next_sibling)( + struct _cef_domnode_t* self); + + /// + // Returns true (1) if this node has child nodes. + /// + int (CEF_CALLBACK *has_children)(struct _cef_domnode_t* self); + + /// + // Return the first child node. + /// + struct _cef_domnode_t* (CEF_CALLBACK *get_first_child)( + struct _cef_domnode_t* self); + + /// + // Returns the last child node. + /// + struct _cef_domnode_t* (CEF_CALLBACK *get_last_child)( + struct _cef_domnode_t* self); + + /// + // Add an event listener to this node for the specified event type. If + // |useCapture| is true (1) then this listener will be considered a capturing + // listener. Capturing listeners will recieve all events of the specified type + // before the events are dispatched to any other event targets beneath the + // current node in the tree. Events which are bubbling upwards through the + // tree will not trigger a capturing listener. Separate calls to this function + // can be used to register the same listener with and without capture. See + // WebCore/dom/EventNames.h for the list of supported event types. + /// + void (CEF_CALLBACK *add_event_listener)(struct _cef_domnode_t* self, + const cef_string_t* eventType, struct _cef_domevent_listener_t* listener, + int useCapture); + + + // The following functions are valid only for element nodes. + + /// + // Returns the tag name of this element. + /// + // The resulting string must be freed by calling cef_string_userfree_free(). + cef_string_userfree_t (CEF_CALLBACK *get_element_tag_name)( + struct _cef_domnode_t* self); + + /// + // Returns true (1) if this element has attributes. + /// + int (CEF_CALLBACK *has_element_attributes)(struct _cef_domnode_t* self); + + /// + // Returns true (1) if this element has an attribute named |attrName|. + /// + int (CEF_CALLBACK *has_element_attribute)(struct _cef_domnode_t* self, + const cef_string_t* attrName); + + /// + // Returns the element attribute named |attrName|. + /// + // The resulting string must be freed by calling cef_string_userfree_free(). + cef_string_userfree_t (CEF_CALLBACK *get_element_attribute)( + struct _cef_domnode_t* self, const cef_string_t* attrName); + + /// + // Returns a map of all element attributes. + /// + void (CEF_CALLBACK *get_element_attributes)(struct _cef_domnode_t* self, + cef_string_map_t attrMap); + + /// + // Set the value for the element attribute named |attrName|. Returns true (1) + // on success. + /// + int (CEF_CALLBACK *set_element_attribute)(struct _cef_domnode_t* self, + const cef_string_t* attrName, const cef_string_t* value); + + /// + // Returns the inner text of the element. + /// + // The resulting string must be freed by calling cef_string_userfree_free(). + cef_string_userfree_t (CEF_CALLBACK *get_element_inner_text)( + struct _cef_domnode_t* self); +} cef_domnode_t; + + +/// +// Structure used to represent a DOM event. The functions of this structure +// should only be called on the UI thread. +/// +typedef struct _cef_domevent_t { + /// + // Base structure. + /// + cef_base_t base; + + /// + // Returns the event type. + /// + // The resulting string must be freed by calling cef_string_userfree_free(). + cef_string_userfree_t (CEF_CALLBACK *get_type)(struct _cef_domevent_t* self); + + /// + // Returns the event category. + /// + enum cef_dom_event_category_t (CEF_CALLBACK *get_category)( + struct _cef_domevent_t* self); + + /// + // Returns the event processing phase. + /// + enum cef_dom_event_phase_t (CEF_CALLBACK *get_phase)( + struct _cef_domevent_t* self); + + /// + // Returns true (1) if the event can bubble up the tree. + /// + int (CEF_CALLBACK *can_bubble)(struct _cef_domevent_t* self); + + /// + // Returns true (1) if the event can be canceled. + /// + int (CEF_CALLBACK *can_cancel)(struct _cef_domevent_t* self); + + /// + // Returns the document associated with this event. + /// + struct _cef_domdocument_t* (CEF_CALLBACK *get_document)( + struct _cef_domevent_t* self); + + /// + // Returns the target of the event. + /// + struct _cef_domnode_t* (CEF_CALLBACK *get_target)( + struct _cef_domevent_t* self); + + /// + // Returns the current target of the event. + /// + struct _cef_domnode_t* (CEF_CALLBACK *get_current_target)( + struct _cef_domevent_t* self); +} cef_domevent_t; + + +/// +// Structure to implement for handling DOM events. The functions of this +// structure will be called on the UI thread. +/// +typedef struct _cef_domevent_listener_t { + /// + // Base structure. + /// + cef_base_t base; + + /// + // Called when an event is received. The event object passed to this function + // contains a snapshot of the DOM at the time this function is executed. DOM + // objects are only valid for the scope of this function. Do not keep + // references to or attempt to access any DOM objects outside the scope of + // this function. + /// + void (CEF_CALLBACK *handle_event)(struct _cef_domevent_listener_t* self, + struct _cef_domevent_t* event); +} cef_domevent_listener_t; + + +#ifdef __cplusplus +} +#endif + +#endif // CEF_INCLUDE_CAPI_CEF_DOM_CAPI_H_ diff --git a/cef/include/capi/cef_download_handler_capi.h b/cef/include/capi/cef_download_handler_capi.h new file mode 100644 index 000000000..50f1f4bd1 --- /dev/null +++ b/cef/include/capi/cef_download_handler_capi.h @@ -0,0 +1,77 @@ +// Copyright (c) 2012 Marshall A. Greenblatt. All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the name Chromium Embedded +// Framework nor the names of its contributors may be used to endorse +// or promote products derived from this software without specific prior +// written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +// --------------------------------------------------------------------------- +// +// This file was generated by the CEF translator tool and should not edited +// by hand. See the translator.README.txt file in the tools directory for +// more information. +// + +#ifndef CEF_INCLUDE_CAPI_CEF_DOWNLOAD_HANDLER_CAPI_H_ +#define CEF_INCLUDE_CAPI_CEF_DOWNLOAD_HANDLER_CAPI_H_ +#pragma once + +#ifdef __cplusplus +extern "C" { +#endif + +#include "include/capi/cef_base_capi.h" + + +/// +// Structure used to handle file downloads. The functions of this structure will +// always be called on the UI thread. +/// +typedef struct _cef_download_handler_t { + /// + // Base structure. + /// + cef_base_t base; + + /// + // A portion of the file contents have been received. This function will be + // called multiple times until the download is complete. Return |true (1)| to + // continue receiving data and |false (0)| to cancel. + /// + int (CEF_CALLBACK *received_data)(struct _cef_download_handler_t* self, + void* data, int data_size); + + /// + // The download is complete. + /// + void (CEF_CALLBACK *complete)(struct _cef_download_handler_t* self); +} cef_download_handler_t; + + +#ifdef __cplusplus +} +#endif + +#endif // CEF_INCLUDE_CAPI_CEF_DOWNLOAD_HANDLER_CAPI_H_ diff --git a/cef/include/capi/cef_drag_data_capi.h b/cef/include/capi/cef_drag_data_capi.h new file mode 100644 index 000000000..f2fff0d97 --- /dev/null +++ b/cef/include/capi/cef_drag_data_capi.h @@ -0,0 +1,143 @@ +// Copyright (c) 2012 Marshall A. Greenblatt. All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the name Chromium Embedded +// Framework nor the names of its contributors may be used to endorse +// or promote products derived from this software without specific prior +// written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +// --------------------------------------------------------------------------- +// +// This file was generated by the CEF translator tool and should not edited +// by hand. See the translator.README.txt file in the tools directory for +// more information. +// + +#ifndef CEF_INCLUDE_CAPI_CEF_DRAG_DATA_CAPI_H_ +#define CEF_INCLUDE_CAPI_CEF_DRAG_DATA_CAPI_H_ +#pragma once + +#ifdef __cplusplus +extern "C" { +#endif + +#include "include/capi/cef_base_capi.h" + + +/// +// Structure used to represent drag data. The functions of this structure may be +// called on any thread. +/// +typedef struct _cef_drag_data_t { + /// + // Base structure. + /// + cef_base_t base; + + /// + // Returns true (1) if the drag data is a link. + /// + int (CEF_CALLBACK *is_link)(struct _cef_drag_data_t* self); + + /// + // Returns true (1) if the drag data is a text or html fragment. + /// + int (CEF_CALLBACK *is_fragment)(struct _cef_drag_data_t* self); + + /// + // Returns true (1) if the drag data is a file. + /// + int (CEF_CALLBACK *is_file)(struct _cef_drag_data_t* self); + + /// + // Return the link URL that is being dragged. + /// + // The resulting string must be freed by calling cef_string_userfree_free(). + cef_string_userfree_t (CEF_CALLBACK *get_link_url)( + struct _cef_drag_data_t* self); + + /// + // Return the title associated with the link being dragged. + /// + // The resulting string must be freed by calling cef_string_userfree_free(). + cef_string_userfree_t (CEF_CALLBACK *get_link_title)( + struct _cef_drag_data_t* self); + + /// + // Return the metadata, if any, associated with the link being dragged. + /// + // The resulting string must be freed by calling cef_string_userfree_free(). + cef_string_userfree_t (CEF_CALLBACK *get_link_metadata)( + struct _cef_drag_data_t* self); + + /// + // Return the plain text fragment that is being dragged. + /// + // The resulting string must be freed by calling cef_string_userfree_free(). + cef_string_userfree_t (CEF_CALLBACK *get_fragment_text)( + struct _cef_drag_data_t* self); + + /// + // Return the text/html fragment that is being dragged. + /// + // The resulting string must be freed by calling cef_string_userfree_free(). + cef_string_userfree_t (CEF_CALLBACK *get_fragment_html)( + struct _cef_drag_data_t* self); + + /// + // Return the base URL that the fragment came from. This value is used for + // resolving relative URLs and may be NULL. + /// + // The resulting string must be freed by calling cef_string_userfree_free(). + cef_string_userfree_t (CEF_CALLBACK *get_fragment_base_url)( + struct _cef_drag_data_t* self); + + /// + // Return the extension of the file being dragged out of the browser window. + /// + // The resulting string must be freed by calling cef_string_userfree_free(). + cef_string_userfree_t (CEF_CALLBACK *get_file_extension)( + struct _cef_drag_data_t* self); + + /// + // Return the name of the file being dragged out of the browser window. + /// + // The resulting string must be freed by calling cef_string_userfree_free(). + cef_string_userfree_t (CEF_CALLBACK *get_file_name)( + struct _cef_drag_data_t* self); + + /// + // Retrieve the list of file names that are being dragged into the browser + // window. + /// + int (CEF_CALLBACK *get_file_names)(struct _cef_drag_data_t* self, + cef_string_list_t names); +} cef_drag_data_t; + + +#ifdef __cplusplus +} +#endif + +#endif // CEF_INCLUDE_CAPI_CEF_DRAG_DATA_CAPI_H_ diff --git a/cef/include/capi/cef_drag_handler_capi.h b/cef/include/capi/cef_drag_handler_capi.h new file mode 100644 index 000000000..8e74f3586 --- /dev/null +++ b/cef/include/capi/cef_drag_handler_capi.h @@ -0,0 +1,84 @@ +// Copyright (c) 2012 Marshall A. Greenblatt. All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the name Chromium Embedded +// Framework nor the names of its contributors may be used to endorse +// or promote products derived from this software without specific prior +// written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +// --------------------------------------------------------------------------- +// +// This file was generated by the CEF translator tool and should not edited +// by hand. See the translator.README.txt file in the tools directory for +// more information. +// + +#ifndef CEF_INCLUDE_CAPI_CEF_DRAG_HANDLER_CAPI_H_ +#define CEF_INCLUDE_CAPI_CEF_DRAG_HANDLER_CAPI_H_ +#pragma once + +#ifdef __cplusplus +extern "C" { +#endif + +#include "include/capi/cef_base_capi.h" + + +/// +// Implement this structure to handle events related to dragging. The functions +// of this structure will be called on the UI thread. +/// +typedef struct _cef_drag_handler_t { + /// + // Base structure. + /// + cef_base_t base; + + /// + // Called when the browser window initiates a drag event. |dragData| contains + // the drag event data and |mask| represents the type of drag operation. + // Return false (0) for default drag handling behavior or true (1) to cancel + // the drag event. + /// + int (CEF_CALLBACK *on_drag_start)(struct _cef_drag_handler_t* self, + struct _cef_browser_t* browser, struct _cef_drag_data_t* dragData, + enum cef_drag_operations_mask_t mask); + + /// + // Called when an external drag event enters the browser window. |dragData| + // contains the drag event data and |mask| represents the type of drag + // operation. Return false (0) for default drag handling behavior or true (1) + // to cancel the drag event. + /// + int (CEF_CALLBACK *on_drag_enter)(struct _cef_drag_handler_t* self, + struct _cef_browser_t* browser, struct _cef_drag_data_t* dragData, + enum cef_drag_operations_mask_t mask); +} cef_drag_handler_t; + + +#ifdef __cplusplus +} +#endif + +#endif // CEF_INCLUDE_CAPI_CEF_DRAG_HANDLER_CAPI_H_ diff --git a/cef/include/capi/cef_find_handler_capi.h b/cef/include/capi/cef_find_handler_capi.h new file mode 100644 index 000000000..b729bd1e3 --- /dev/null +++ b/cef/include/capi/cef_find_handler_capi.h @@ -0,0 +1,77 @@ +// Copyright (c) 2012 Marshall A. Greenblatt. All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the name Chromium Embedded +// Framework nor the names of its contributors may be used to endorse +// or promote products derived from this software without specific prior +// written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +// --------------------------------------------------------------------------- +// +// This file was generated by the CEF translator tool and should not edited +// by hand. See the translator.README.txt file in the tools directory for +// more information. +// + +#ifndef CEF_INCLUDE_CAPI_CEF_FIND_HANDLER_CAPI_H_ +#define CEF_INCLUDE_CAPI_CEF_FIND_HANDLER_CAPI_H_ +#pragma once + +#ifdef __cplusplus +extern "C" { +#endif + +#include "include/capi/cef_base_capi.h" + + +/// +// Implement this structure to handle events related to find results. The +// functions of this structure will be called on the UI thread. +/// +typedef struct _cef_find_handler_t { + /// + // Base structure. + /// + cef_base_t base; + + /// + // Called to report find results returned by cef_browser_t::find(). + // |identifer| is the identifier passed to cef_browser_t::find(), |count| is + // the number of matches currently identified, |selectionRect| is the location + // of where the match was found (in window coordinates), |activeMatchOrdinal| + // is the current position in the search results, and |finalUpdate| is true + // (1) if this is the last find notification. + /// + void (CEF_CALLBACK *on_find_result)(struct _cef_find_handler_t* self, + struct _cef_browser_t* browser, int identifier, int count, + const cef_rect_t* selectionRect, int activeMatchOrdinal, + int finalUpdate); +} cef_find_handler_t; + + +#ifdef __cplusplus +} +#endif + +#endif // CEF_INCLUDE_CAPI_CEF_FIND_HANDLER_CAPI_H_ diff --git a/cef/include/capi/cef_focus_handler_capi.h b/cef/include/capi/cef_focus_handler_capi.h new file mode 100644 index 000000000..17de32c64 --- /dev/null +++ b/cef/include/capi/cef_focus_handler_capi.h @@ -0,0 +1,93 @@ +// Copyright (c) 2012 Marshall A. Greenblatt. All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the name Chromium Embedded +// Framework nor the names of its contributors may be used to endorse +// or promote products derived from this software without specific prior +// written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +// --------------------------------------------------------------------------- +// +// This file was generated by the CEF translator tool and should not edited +// by hand. See the translator.README.txt file in the tools directory for +// more information. +// + +#ifndef CEF_INCLUDE_CAPI_CEF_FOCUS_HANDLER_CAPI_H_ +#define CEF_INCLUDE_CAPI_CEF_FOCUS_HANDLER_CAPI_H_ +#pragma once + +#ifdef __cplusplus +extern "C" { +#endif + +#include "include/capi/cef_base_capi.h" + + +/// +// Implement this structure to handle events related to focus. The functions of +// this structure will be called on the UI thread. +/// +typedef struct _cef_focus_handler_t { + /// + // Base structure. + /// + cef_base_t base; + + /// + // Called when the browser component is about to loose focus. For instance, if + // focus was on the last HTML element and the user pressed the TAB key. |next| + // will be true (1) if the browser is giving focus to the next component and + // false (0) if the browser is giving focus to the previous component. + /// + void (CEF_CALLBACK *on_take_focus)(struct _cef_focus_handler_t* self, + struct _cef_browser_t* browser, int next); + + /// + // Called when the browser component is requesting focus. |source| indicates + // where the focus request is originating from. Return false (0) to allow the + // focus to be set or true (1) to cancel setting the focus. + /// + int (CEF_CALLBACK *on_set_focus)(struct _cef_focus_handler_t* self, + struct _cef_browser_t* browser, enum cef_handler_focus_source_t source); + + /// + // Called when a new node in the the browser gets focus. The |node| value may + // be NULL if no specific node has gained focus. The node object passed to + // this function represents a snapshot of the DOM at the time this function is + // executed. DOM objects are only valid for the scope of this function. Do not + // keep references to or attempt to access any DOM objects outside the scope + // of this function. + /// + void (CEF_CALLBACK *on_focused_node_changed)( + struct _cef_focus_handler_t* self, struct _cef_browser_t* browser, + struct _cef_frame_t* frame, struct _cef_domnode_t* node); +} cef_focus_handler_t; + + +#ifdef __cplusplus +} +#endif + +#endif // CEF_INCLUDE_CAPI_CEF_FOCUS_HANDLER_CAPI_H_ diff --git a/cef/include/capi/cef_frame_capi.h b/cef/include/capi/cef_frame_capi.h new file mode 100644 index 000000000..4009ac63c --- /dev/null +++ b/cef/include/capi/cef_frame_capi.h @@ -0,0 +1,217 @@ +// Copyright (c) 2012 Marshall A. Greenblatt. All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the name Chromium Embedded +// Framework nor the names of its contributors may be used to endorse +// or promote products derived from this software without specific prior +// written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +// --------------------------------------------------------------------------- +// +// This file was generated by the CEF translator tool and should not edited +// by hand. See the translator.README.txt file in the tools directory for +// more information. +// + +#ifndef CEF_INCLUDE_CAPI_CEF_FRAME_CAPI_H_ +#define CEF_INCLUDE_CAPI_CEF_FRAME_CAPI_H_ +#pragma once + +#ifdef __cplusplus +extern "C" { +#endif + +#include "include/capi/cef_base_capi.h" + + +/// +// Structure used to represent a frame in the browser window. The functions of +// this structure may be called on any thread unless otherwise indicated in the +// comments. +/// +typedef struct _cef_frame_t { + /// + // Base structure. + /// + cef_base_t base; + + /// + // Execute undo in this frame. + /// + void (CEF_CALLBACK *undo)(struct _cef_frame_t* self); + + /// + // Execute redo in this frame. + /// + void (CEF_CALLBACK *redo)(struct _cef_frame_t* self); + + /// + // Execute cut in this frame. + /// + void (CEF_CALLBACK *cut)(struct _cef_frame_t* self); + + /// + // Execute copy in this frame. + /// + void (CEF_CALLBACK *copy)(struct _cef_frame_t* self); + + /// + // Execute paste in this frame. + /// + void (CEF_CALLBACK *paste)(struct _cef_frame_t* self); + + /// + // Execute delete in this frame. + /// + void (CEF_CALLBACK *del)(struct _cef_frame_t* self); + + /// + // Execute select all in this frame. + /// + void (CEF_CALLBACK *select_all)(struct _cef_frame_t* self); + + /// + // Execute printing in the this frame. The user will be prompted with the + // print dialog appropriate to the operating system. + /// + void (CEF_CALLBACK *print)(struct _cef_frame_t* self); + + /// + // Save this frame's HTML source to a temporary file and open it in the + // default text viewing application. + /// + void (CEF_CALLBACK *view_source)(struct _cef_frame_t* self); + + /// + // Returns this frame's HTML source as a string. This function should only be + // called on the UI thread. + /// + // The resulting string must be freed by calling cef_string_userfree_free(). + cef_string_userfree_t (CEF_CALLBACK *get_source)(struct _cef_frame_t* self); + + /// + // Returns this frame's display text as a string. This function should only be + // called on the UI thread. + /// + // The resulting string must be freed by calling cef_string_userfree_free(). + cef_string_userfree_t (CEF_CALLBACK *get_text)(struct _cef_frame_t* self); + + /// + // Load the request represented by the |request| object. + /// + void (CEF_CALLBACK *load_request)(struct _cef_frame_t* self, + struct _cef_request_t* request); + + /// + // Load the specified |url|. + /// + void (CEF_CALLBACK *load_url)(struct _cef_frame_t* self, + const cef_string_t* url); + + /// + // Load the contents of |string_val| with the optional dummy target |url|. + /// + void (CEF_CALLBACK *load_string)(struct _cef_frame_t* self, + const cef_string_t* string_val, const cef_string_t* url); + + /// + // Load the contents of |stream| with the optional dummy target |url|. + /// + void (CEF_CALLBACK *load_stream)(struct _cef_frame_t* self, + struct _cef_stream_reader_t* stream, const cef_string_t* url); + + /// + // Execute a string of JavaScript code in this frame. The |script_url| + // parameter is the URL where the script in question can be found, if any. The + // renderer may request this URL to show the developer the source of the + // error. The |start_line| parameter is the base line number to use for error + // reporting. + /// + void (CEF_CALLBACK *execute_java_script)(struct _cef_frame_t* self, + const cef_string_t* jsCode, const cef_string_t* scriptUrl, + int startLine); + + /// + // Returns true (1) if this is the main (top-level) frame. + /// + int (CEF_CALLBACK *is_main)(struct _cef_frame_t* self); + + /// + // Returns true (1) if this is the focused frame. This function should only be + // called on the UI thread. + /// + int (CEF_CALLBACK *is_focused)(struct _cef_frame_t* self); + + /// + // Returns the name for this frame. If the frame has an assigned name (for + // example, set via the iframe "name" attribute) then that value will be + // returned. Otherwise a unique name will be constructed based on the frame + // parent hierarchy. The main (top-level) frame will always have an NULL name + // value. + /// + // The resulting string must be freed by calling cef_string_userfree_free(). + cef_string_userfree_t (CEF_CALLBACK *get_name)(struct _cef_frame_t* self); + + /// + // Returns the globally unique identifier for this frame. + /// + int64 (CEF_CALLBACK *get_identifier)(struct _cef_frame_t* self); + + /// + // Returns the parent of this frame or NULL if this is the main (top-level) + // frame. This function should only be called on the UI thread. + /// + struct _cef_frame_t* (CEF_CALLBACK *get_parent)(struct _cef_frame_t* self); + + /// + // Returns the URL currently loaded in this frame. + /// + // The resulting string must be freed by calling cef_string_userfree_free(). + cef_string_userfree_t (CEF_CALLBACK *get_url)(struct _cef_frame_t* self); + + /// + // Returns the browser that this frame belongs to. + /// + struct _cef_browser_t* (CEF_CALLBACK *get_browser)(struct _cef_frame_t* self); + + /// + // Visit the DOM document. + /// + void (CEF_CALLBACK *visit_dom)(struct _cef_frame_t* self, + struct _cef_domvisitor_t* visitor); + + /// + // Get the V8 context associated with the frame. This function should only be + // called on the UI thread. + /// + struct _cef_v8context_t* (CEF_CALLBACK *get_v8context)( + struct _cef_frame_t* self); +} cef_frame_t; + + +#ifdef __cplusplus +} +#endif + +#endif // CEF_INCLUDE_CAPI_CEF_FRAME_CAPI_H_ diff --git a/cef/include/capi/cef_jsdialog_handler_capi.h b/cef/include/capi/cef_jsdialog_handler_capi.h new file mode 100644 index 000000000..36ed63ef4 --- /dev/null +++ b/cef/include/capi/cef_jsdialog_handler_capi.h @@ -0,0 +1,92 @@ +// Copyright (c) 2012 Marshall A. Greenblatt. All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the name Chromium Embedded +// Framework nor the names of its contributors may be used to endorse +// or promote products derived from this software without specific prior +// written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +// --------------------------------------------------------------------------- +// +// This file was generated by the CEF translator tool and should not edited +// by hand. See the translator.README.txt file in the tools directory for +// more information. +// + +#ifndef CEF_INCLUDE_CAPI_CEF_JSDIALOG_HANDLER_CAPI_H_ +#define CEF_INCLUDE_CAPI_CEF_JSDIALOG_HANDLER_CAPI_H_ +#pragma once + +#ifdef __cplusplus +extern "C" { +#endif + +#include "include/capi/cef_base_capi.h" + + +/// +// Implement this structure to handle events related to JavaScript dialogs. The +// functions of this structure will be called on the UI thread. +/// +typedef struct _cef_jsdialog_handler_t { + /// + // Base structure. + /// + cef_base_t base; + + /// + // Called to run a JavaScript alert message. Return false (0) to display the + // default alert or true (1) if you displayed a custom alert. + /// + int (CEF_CALLBACK *on_jsalert)(struct _cef_jsdialog_handler_t* self, + struct _cef_browser_t* browser, struct _cef_frame_t* frame, + const cef_string_t* message); + + /// + // Called to run a JavaScript confirm request. Return false (0) to display the + // default alert or true (1) if you displayed a custom alert. If you handled + // the alert set |retval| to true (1) if the user accepted the confirmation. + /// + int (CEF_CALLBACK *on_jsconfirm)(struct _cef_jsdialog_handler_t* self, + struct _cef_browser_t* browser, struct _cef_frame_t* frame, + const cef_string_t* message, int* retval); + + /// + // Called to run a JavaScript prompt request. Return false (0) to display the + // default prompt or true (1) if you displayed a custom prompt. If you handled + // the prompt set |retval| to true (1) if the user accepted the prompt and + // request and |result| to the resulting value. + /// + int (CEF_CALLBACK *on_jsprompt)(struct _cef_jsdialog_handler_t* self, + struct _cef_browser_t* browser, struct _cef_frame_t* frame, + const cef_string_t* message, const cef_string_t* defaultValue, + int* retval, cef_string_t* result); +} cef_jsdialog_handler_t; + + +#ifdef __cplusplus +} +#endif + +#endif // CEF_INCLUDE_CAPI_CEF_JSDIALOG_HANDLER_CAPI_H_ diff --git a/cef/include/capi/cef_keyboard_handler_capi.h b/cef/include/capi/cef_keyboard_handler_capi.h new file mode 100644 index 000000000..ff96b3312 --- /dev/null +++ b/cef/include/capi/cef_keyboard_handler_capi.h @@ -0,0 +1,82 @@ +// Copyright (c) 2012 Marshall A. Greenblatt. All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the name Chromium Embedded +// Framework nor the names of its contributors may be used to endorse +// or promote products derived from this software without specific prior +// written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +// --------------------------------------------------------------------------- +// +// This file was generated by the CEF translator tool and should not edited +// by hand. See the translator.README.txt file in the tools directory for +// more information. +// + +#ifndef CEF_INCLUDE_CAPI_CEF_KEYBOARD_HANDLER_CAPI_H_ +#define CEF_INCLUDE_CAPI_CEF_KEYBOARD_HANDLER_CAPI_H_ +#pragma once + +#ifdef __cplusplus +extern "C" { +#endif + +#include "include/capi/cef_base_capi.h" + + +/// +// Implement this structure to handle events related to keyboard input. The +// functions of this structure will be called on the UI thread. +/// +typedef struct _cef_keyboard_handler_t { + /// + // Base structure. + /// + cef_base_t base; + + /// + // Called when the browser component receives a keyboard event. This function + // is called both before the event is passed to the renderer and after + // JavaScript in the page has had a chance to handle the event. |type| is the + // type of keyboard event, |code| is the windows scan-code for the event, + // |modifiers| is a set of bit- flags describing any pressed modifier keys and + // |isSystemKey| is true (1) if Windows considers this a 'system key' message + // (see http://msdn.microsoft.com/en-us/library/ms646286(VS.85).aspx). If + // |isAfterJavaScript| is true (1) then JavaScript in the page has had a + // chance to handle the event and has chosen not to. Only RAWKEYDOWN, KEYDOWN + // and CHAR events will be sent with |isAfterJavaScript| set to true (1). + // Return true (1) if the keyboard event was handled or false (0) to allow + // continued handling of the event by the renderer. + /// + int (CEF_CALLBACK *on_key_event)(struct _cef_keyboard_handler_t* self, + struct _cef_browser_t* browser, enum cef_handler_keyevent_type_t type, + int code, int modifiers, int isSystemKey, int isAfterJavaScript); +} cef_keyboard_handler_t; + + +#ifdef __cplusplus +} +#endif + +#endif // CEF_INCLUDE_CAPI_CEF_KEYBOARD_HANDLER_CAPI_H_ diff --git a/cef/include/capi/cef_life_span_handler_capi.h b/cef/include/capi/cef_life_span_handler_capi.h new file mode 100644 index 000000000..be5fe1290 --- /dev/null +++ b/cef/include/capi/cef_life_span_handler_capi.h @@ -0,0 +1,114 @@ +// Copyright (c) 2012 Marshall A. Greenblatt. All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the name Chromium Embedded +// Framework nor the names of its contributors may be used to endorse +// or promote products derived from this software without specific prior +// written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +// --------------------------------------------------------------------------- +// +// This file was generated by the CEF translator tool and should not edited +// by hand. See the translator.README.txt file in the tools directory for +// more information. +// + +#ifndef CEF_INCLUDE_CAPI_CEF_LIFE_SPAN_HANDLER_CAPI_H_ +#define CEF_INCLUDE_CAPI_CEF_LIFE_SPAN_HANDLER_CAPI_H_ +#pragma once + +#ifdef __cplusplus +extern "C" { +#endif + +#include "include/capi/cef_base_capi.h" + + +/// +// Implement this structure to handle events related to browser life span. The +// functions of this structure will be called on the UI thread. +/// +typedef struct _cef_life_span_handler_t { + /// + // Base structure. + /// + cef_base_t base; + + /// + // Called before a new popup window is created. The |parentBrowser| parameter + // will point to the parent browser window. The |popupFeatures| parameter will + // contain information about the style of popup window requested. Return false + // (0) to have the framework create the new popup window based on the + // parameters in |windowInfo|. Return true (1) to cancel creation of the popup + // window. By default, a newly created popup window will have the same client + // and settings as the parent window. To change the client for the new window + // modify the object that |client| points to. To change the settings for the + // new window modify the |settings| structure. + /// + int (CEF_CALLBACK *on_before_popup)(struct _cef_life_span_handler_t* self, + struct _cef_browser_t* parentBrowser, + const struct _cef_popup_features_t* popupFeatures, + struct _cef_window_info_t* windowInfo, const cef_string_t* url, + struct _cef_client_t** client, + struct _cef_browser_settings_t* settings); + + /// + // Called after a new window is created. + /// + void (CEF_CALLBACK *on_after_created)(struct _cef_life_span_handler_t* self, + struct _cef_browser_t* browser); + + /// + // Called when a modal window is about to display and the modal loop should + // begin running. Return false (0) to use the default modal loop + // implementation or true (1) to use a custom implementation. + /// + int (CEF_CALLBACK *run_modal)(struct _cef_life_span_handler_t* self, + struct _cef_browser_t* browser); + + /// + // Called when a window has recieved a request to close. Return false (0) to + // proceed with the window close or true (1) to cancel the window close. If + // this is a modal window and a custom modal loop implementation was provided + // in run_modal() this callback should be used to restore the opener window to + // a usable state. + /// + int (CEF_CALLBACK *do_close)(struct _cef_life_span_handler_t* self, + struct _cef_browser_t* browser); + + /// + // Called just before a window is closed. If this is a modal window and a + // custom modal loop implementation was provided in run_modal() this callback + // should be used to exit the custom modal loop. + /// + void (CEF_CALLBACK *on_before_close)(struct _cef_life_span_handler_t* self, + struct _cef_browser_t* browser); +} cef_life_span_handler_t; + + +#ifdef __cplusplus +} +#endif + +#endif // CEF_INCLUDE_CAPI_CEF_LIFE_SPAN_HANDLER_CAPI_H_ diff --git a/cef/include/capi/cef_load_handler_capi.h b/cef/include/capi/cef_load_handler_capi.h new file mode 100644 index 000000000..baea13038 --- /dev/null +++ b/cef/include/capi/cef_load_handler_capi.h @@ -0,0 +1,99 @@ +// Copyright (c) 2012 Marshall A. Greenblatt. All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the name Chromium Embedded +// Framework nor the names of its contributors may be used to endorse +// or promote products derived from this software without specific prior +// written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +// --------------------------------------------------------------------------- +// +// This file was generated by the CEF translator tool and should not edited +// by hand. See the translator.README.txt file in the tools directory for +// more information. +// + +#ifndef CEF_INCLUDE_CAPI_CEF_LOAD_HANDLER_CAPI_H_ +#define CEF_INCLUDE_CAPI_CEF_LOAD_HANDLER_CAPI_H_ +#pragma once + +#ifdef __cplusplus +extern "C" { +#endif + +#include "include/capi/cef_base_capi.h" + + +/// +// Implement this structure to handle events related to browser load status. The +// functions of this structure will be called on the UI thread. +/// +typedef struct _cef_load_handler_t { + /// + // Base structure. + /// + cef_base_t base; + + /// + // Called when the browser begins loading a frame. The |frame| value will + // never be NULL -- call the is_main() function to check if this frame is the + // main frame. Multiple frames may be loading at the same time. Sub-frames may + // start or continue loading after the main frame load has ended. This + // function may not be called for a particular frame if the load request for + // that frame fails. + /// + void (CEF_CALLBACK *on_load_start)(struct _cef_load_handler_t* self, + struct _cef_browser_t* browser, struct _cef_frame_t* frame); + + /// + // Called when the browser is done loading a frame. The |frame| value will + // never be NULL -- call the is_main() function to check if this frame is the + // main frame. Multiple frames may be loading at the same time. Sub-frames may + // start or continue loading after the main frame load has ended. This + // function will always be called for all frames irrespective of whether the + // request completes successfully. + /// + void (CEF_CALLBACK *on_load_end)(struct _cef_load_handler_t* self, + struct _cef_browser_t* browser, struct _cef_frame_t* frame, + int httpStatusCode); + + /// + // Called when the browser fails to load a resource. |errorCode| is the error + // code number and |failedUrl| is the URL that failed to load. To provide + // custom error text assign the text to |errorText| and return true (1). + // Otherwise, return false (0) for the default error text. See + // net\base\net_error_list.h for complete descriptions of the error codes. + /// + int (CEF_CALLBACK *on_load_error)(struct _cef_load_handler_t* self, + struct _cef_browser_t* browser, struct _cef_frame_t* frame, + enum cef_handler_errorcode_t errorCode, const cef_string_t* failedUrl, + cef_string_t* errorText); +} cef_load_handler_t; + + +#ifdef __cplusplus +} +#endif + +#endif // CEF_INCLUDE_CAPI_CEF_LOAD_HANDLER_CAPI_H_ diff --git a/cef/include/capi/cef_menu_handler_capi.h b/cef/include/capi/cef_menu_handler_capi.h new file mode 100644 index 000000000..7cf2b9ad8 --- /dev/null +++ b/cef/include/capi/cef_menu_handler_capi.h @@ -0,0 +1,88 @@ +// Copyright (c) 2012 Marshall A. Greenblatt. All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the name Chromium Embedded +// Framework nor the names of its contributors may be used to endorse +// or promote products derived from this software without specific prior +// written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +// --------------------------------------------------------------------------- +// +// This file was generated by the CEF translator tool and should not edited +// by hand. See the translator.README.txt file in the tools directory for +// more information. +// + +#ifndef CEF_INCLUDE_CAPI_CEF_MENU_HANDLER_CAPI_H_ +#define CEF_INCLUDE_CAPI_CEF_MENU_HANDLER_CAPI_H_ +#pragma once + +#ifdef __cplusplus +extern "C" { +#endif + +#include "include/capi/cef_base_capi.h" + + +/// +// Implement this structure to handle events related to browser context menus. +// The functions of this structure will be called on the UI thread. +/// +typedef struct _cef_menu_handler_t { + /// + // Base structure. + /// + cef_base_t base; + + /// + // Called before a context menu is displayed. Return false (0) to display the + // default context menu or true (1) to cancel the display. + /// + int (CEF_CALLBACK *on_before_menu)(struct _cef_menu_handler_t* self, + struct _cef_browser_t* browser, + const struct _cef_menu_info_t* menuInfo); + + /// + // Called to optionally override the default text for a context menu item. + // |label| contains the default text and may be modified to substitute + // alternate text. + /// + void (CEF_CALLBACK *get_menu_label)(struct _cef_menu_handler_t* self, + struct _cef_browser_t* browser, enum cef_menu_id_t menuId, + cef_string_t* label); + + /// + // Called when an option is selected from the default context menu. Return + // false (0) to execute the default action or true (1) to cancel the action. + /// + int (CEF_CALLBACK *on_menu_action)(struct _cef_menu_handler_t* self, + struct _cef_browser_t* browser, enum cef_menu_id_t menuId); +} cef_menu_handler_t; + + +#ifdef __cplusplus +} +#endif + +#endif // CEF_INCLUDE_CAPI_CEF_MENU_HANDLER_CAPI_H_ diff --git a/cef/include/capi/cef_nplugin_capi.h b/cef/include/capi/cef_nplugin_capi.h new file mode 100644 index 000000000..d6adf1bf0 --- /dev/null +++ b/cef/include/capi/cef_nplugin_capi.h @@ -0,0 +1,49 @@ +// Copyright (c) 2011 Marshall A. Greenblatt. All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the name Chromium Embedded +// Framework nor the names of its contributors may be used to endorse +// or promote products derived from this software without specific prior +// written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + + +#ifndef CEF_INCLUDE_CAPI_CEF_NPLUGIN_CAPI_H_ +#define CEF_INCLUDE_CAPI_CEF_NPLUGIN_CAPI_H_ + +#ifdef __cplusplus +extern "C" { +#endif + +#include "include/internal/cef_nplugin_types.h" + +/// +// Register a plugin with the system. Returns true (1) on success. +/// +CEF_EXPORT int cef_register_plugin(const cef_plugin_info_t* plugin_info); + +#ifdef __cplusplus +} +#endif + +#endif // CEF_INCLUDE_CAPI_CEF_NPLUGIN_CAPI_H_ diff --git a/cef/include/capi/cef_origin_whitelist_capi.h b/cef/include/capi/cef_origin_whitelist_capi.h new file mode 100644 index 000000000..e6fb2d1ac --- /dev/null +++ b/cef/include/capi/cef_origin_whitelist_capi.h @@ -0,0 +1,102 @@ +// Copyright (c) 2012 Marshall A. Greenblatt. All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the name Chromium Embedded +// Framework nor the names of its contributors may be used to endorse +// or promote products derived from this software without specific prior +// written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +// --------------------------------------------------------------------------- +// +// This file was generated by the CEF translator tool and should not edited +// by hand. See the translator.README.txt file in the tools directory for +// more information. +// + +#ifndef CEF_INCLUDE_CAPI_CEF_ORIGIN_WHITELIST_CAPI_H_ +#define CEF_INCLUDE_CAPI_CEF_ORIGIN_WHITELIST_CAPI_H_ +#pragma once + +#ifdef __cplusplus +extern "C" { +#endif + +#include "include/capi/cef_base_capi.h" + + +/// +// Add an entry to the cross-origin access whitelist. +// +// The same-origin policy restricts how scripts hosted from different origins +// (scheme + domain + port) can communicate. By default, scripts can only access +// resources with the same origin. Scripts hosted on the HTTP and HTTPS schemes +// (but no other schemes) can use the "Access-Control-Allow-Origin" header to +// allow cross-origin requests. For example, https://source.example.com can make +// XMLHttpRequest requests on http://target.example.com if the +// http://target.example.com request returns an "Access-Control-Allow-Origin: +// https://source.example.com" response header. +// +// Scripts in separate frames or iframes and hosted from the same protocol and +// domain suffix can execute cross-origin JavaScript if both pages set the +// document.domain value to the same domain suffix. For example, +// scheme://foo.example.com and scheme://bar.example.com can communicate using +// JavaScript if both domains set document.domain="example.com". +// +// This function is used to allow access to origins that would otherwise violate +// the same-origin policy. Scripts hosted underneath the fully qualified +// |source_origin| URL (like http://www.example.com) will be allowed access to +// all resources hosted on the specified |target_protocol| and |target_domain|. +// If |allow_target_subdomains| is true (1) access will also be allowed to all +// subdomains of the target domain. +// +// This function cannot be used to bypass the restrictions on local or display +// isolated schemes. See the comments on CefRegisterCustomScheme for more +// information. +// +// This function may be called on any thread. Returns false (0) if +// |source_origin| is invalid or the whitelist cannot be accessed. +/// +CEF_EXPORT int cef_add_cross_origin_whitelist_entry( + const cef_string_t* source_origin, const cef_string_t* target_protocol, + const cef_string_t* target_domain, int allow_target_subdomains); + +/// +// Remove an entry from the cross-origin access whitelist. Returns false (0) if +// |source_origin| is invalid or the whitelist cannot be accessed. +/// +CEF_EXPORT int cef_remove_cross_origin_whitelist_entry( + const cef_string_t* source_origin, const cef_string_t* target_protocol, + const cef_string_t* target_domain, int allow_target_subdomains); + +/// +// Remove all entries from the cross-origin access whitelist. Returns false (0) +// if the whitelist cannot be accessed. +/// +CEF_EXPORT int cef_clear_cross_origin_whitelist(); + +#ifdef __cplusplus +} +#endif + +#endif // CEF_INCLUDE_CAPI_CEF_ORIGIN_WHITELIST_CAPI_H_ diff --git a/cef/include/capi/cef_permission_handler_capi.h b/cef/include/capi/cef_permission_handler_capi.h new file mode 100644 index 000000000..13db70eb9 --- /dev/null +++ b/cef/include/capi/cef_permission_handler_capi.h @@ -0,0 +1,72 @@ +// Copyright (c) 2012 Marshall A. Greenblatt. All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the name Chromium Embedded +// Framework nor the names of its contributors may be used to endorse +// or promote products derived from this software without specific prior +// written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +// --------------------------------------------------------------------------- +// +// This file was generated by the CEF translator tool and should not edited +// by hand. See the translator.README.txt file in the tools directory for +// more information. +// + +#ifndef CEF_INCLUDE_CAPI_CEF_PERMISSION_HANDLER_CAPI_H_ +#define CEF_INCLUDE_CAPI_CEF_PERMISSION_HANDLER_CAPI_H_ +#pragma once + +#ifdef __cplusplus +extern "C" { +#endif + +#include "include/capi/cef_base_capi.h" + + +/// +// Implement this structure to handle events related to browser permissions. The +// functions of this structure will be called on the UI thread. +/// +typedef struct _cef_permission_handler_t { + /// + // Base structure. + /// + cef_base_t base; + + /// + // Called on the UI thread before a script extension is loaded. Return false + // (0) to let the extension load normally. + /// + int (CEF_CALLBACK *on_before_script_extension_load)( + struct _cef_permission_handler_t* self, struct _cef_browser_t* browser, + struct _cef_frame_t* frame, const cef_string_t* extensionName); +} cef_permission_handler_t; + + +#ifdef __cplusplus +} +#endif + +#endif // CEF_INCLUDE_CAPI_CEF_PERMISSION_HANDLER_CAPI_H_ diff --git a/cef/include/capi/cef_print_handler_capi.h b/cef/include/capi/cef_print_handler_capi.h new file mode 100644 index 000000000..be5cfc78e --- /dev/null +++ b/cef/include/capi/cef_print_handler_capi.h @@ -0,0 +1,96 @@ +// Copyright (c) 2012 Marshall A. Greenblatt. All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the name Chromium Embedded +// Framework nor the names of its contributors may be used to endorse +// or promote products derived from this software without specific prior +// written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +// --------------------------------------------------------------------------- +// +// This file was generated by the CEF translator tool and should not edited +// by hand. See the translator.README.txt file in the tools directory for +// more information. +// + +#ifndef CEF_INCLUDE_CAPI_CEF_PRINT_HANDLER_CAPI_H_ +#define CEF_INCLUDE_CAPI_CEF_PRINT_HANDLER_CAPI_H_ +#pragma once + +#ifdef __cplusplus +extern "C" { +#endif + +#include "include/capi/cef_base_capi.h" + + +/// +// Implement this structure to handle events related to printing. The functions +// of this structure will be called on the UI thread. +/// +typedef struct _cef_print_handler_t { + /// + // Base structure. + /// + cef_base_t base; + + /// + // Called to allow customization of standard print options before the print + // dialog is displayed. |printOptions| allows specification of paper size, + // orientation and margins. Note that the specified margins may be adjusted if + // they are outside the range supported by the printer. All units are in + // inches. Return false (0) to display the default print options or true (1) + // to display the modified |printOptions|. + /// + int (CEF_CALLBACK *get_print_options)(struct _cef_print_handler_t* self, + struct _cef_browser_t* browser, + struct _cef_print_options_t* printOptions); + + /// + // Called to format print headers and footers. |printInfo| contains platform- + // specific information about the printer context. |url| is the URL if the + // currently printing page, |title| is the title of the currently printing + // page, |currentPage| is the current page number and |maxPages| is the total + // number of pages. Six default header locations are provided by the + // implementation: top left, top center, top right, bottom left, bottom center + // and bottom right. To use one of these default locations just assign a + // string to the appropriate variable. To draw the header and footer yourself + // return true (1). Otherwise, populate the approprate variables and return + // false (0). + /// + int (CEF_CALLBACK *get_print_header_footer)(struct _cef_print_handler_t* self, + struct _cef_browser_t* browser, struct _cef_frame_t* frame, + const struct _cef_print_info_t* printInfo, const cef_string_t* url, + const cef_string_t* title, int currentPage, int maxPages, + cef_string_t* topLeft, cef_string_t* topCenter, cef_string_t* topRight, + cef_string_t* bottomLeft, cef_string_t* bottomCenter, + cef_string_t* bottomRight); +} cef_print_handler_t; + + +#ifdef __cplusplus +} +#endif + +#endif // CEF_INCLUDE_CAPI_CEF_PRINT_HANDLER_CAPI_H_ diff --git a/cef/include/capi/cef_proxy_handler_capi.h b/cef/include/capi/cef_proxy_handler_capi.h new file mode 100644 index 000000000..2628002d6 --- /dev/null +++ b/cef/include/capi/cef_proxy_handler_capi.h @@ -0,0 +1,69 @@ +// Copyright (c) 2012 Marshall A. Greenblatt. All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the name Chromium Embedded +// Framework nor the names of its contributors may be used to endorse +// or promote products derived from this software without specific prior +// written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +// --------------------------------------------------------------------------- +// +// This file was generated by the CEF translator tool and should not edited +// by hand. See the translator.README.txt file in the tools directory for +// more information. +// + +#ifndef CEF_INCLUDE_CAPI_CEF_PROXY_HANDLER_CAPI_H_ +#define CEF_INCLUDE_CAPI_CEF_PROXY_HANDLER_CAPI_H_ +#pragma once + +#ifdef __cplusplus +extern "C" { +#endif + +#include "include/capi/cef_base_capi.h" + + +/// +// Implement this structure to handle proxy resolution events. +/// +typedef struct _cef_proxy_handler_t { + /// + // Base structure. + /// + cef_base_t base; + + /// + // Called to retrieve proxy information for the specified |url|. + /// + void (CEF_CALLBACK *get_proxy_for_url)(struct _cef_proxy_handler_t* self, + const cef_string_t* url, struct _cef_proxy_info_t* proxy_info); +} cef_proxy_handler_t; + + +#ifdef __cplusplus +} +#endif + +#endif // CEF_INCLUDE_CAPI_CEF_PROXY_HANDLER_CAPI_H_ diff --git a/cef/include/capi/cef_render_handler_capi.h b/cef/include/capi/cef_render_handler_capi.h new file mode 100644 index 000000000..53fc5d8e5 --- /dev/null +++ b/cef/include/capi/cef_render_handler_capi.h @@ -0,0 +1,118 @@ +// Copyright (c) 2012 Marshall A. Greenblatt. All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the name Chromium Embedded +// Framework nor the names of its contributors may be used to endorse +// or promote products derived from this software without specific prior +// written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +// --------------------------------------------------------------------------- +// +// This file was generated by the CEF translator tool and should not edited +// by hand. See the translator.README.txt file in the tools directory for +// more information. +// + +#ifndef CEF_INCLUDE_CAPI_CEF_RENDER_HANDLER_CAPI_H_ +#define CEF_INCLUDE_CAPI_CEF_RENDER_HANDLER_CAPI_H_ +#pragma once + +#ifdef __cplusplus +extern "C" { +#endif + +#include "include/capi/cef_base_capi.h" + + +/// +// Implement this structure to handle events when window rendering is disabled. +// The functions of this structure will be called on the UI thread. +/// +typedef struct _cef_render_handler_t { + /// + // Base structure. + /// + cef_base_t base; + + /// + // Called to retrieve the view rectangle which is relative to screen + // coordinates. Return true (1) if the rectangle was provided. + /// + int (CEF_CALLBACK *get_view_rect)(struct _cef_render_handler_t* self, + struct _cef_browser_t* browser, cef_rect_t* rect); + + /// + // Called to retrieve the simulated screen rectangle. Return true (1) if the + // rectangle was provided. + /// + int (CEF_CALLBACK *get_screen_rect)(struct _cef_render_handler_t* self, + struct _cef_browser_t* browser, cef_rect_t* rect); + + /// + // Called to retrieve the translation from view coordinates to actual screen + // coordinates. Return true (1) if the screen coordinates were provided. + /// + int (CEF_CALLBACK *get_screen_point)(struct _cef_render_handler_t* self, + struct _cef_browser_t* browser, int viewX, int viewY, int* screenX, + int* screenY); + + /// + // Called when the browser wants to show or hide the popup widget. The popup + // should be shown if |show| is true (1) and hidden if |show| is false (0). + /// + void (CEF_CALLBACK *on_popup_show)(struct _cef_render_handler_t* self, + struct _cef_browser_t* browser, int show); + + /// + // Called when the browser wants to move or resize the popup widget. |rect| + // contains the new location and size. + /// + void (CEF_CALLBACK *on_popup_size)(struct _cef_render_handler_t* self, + struct _cef_browser_t* browser, const cef_rect_t* rect); + + /// + // Called when an element should be painted. |type| indicates whether the + // element is the view or the popup widget. |buffer| contains the pixel data + // for the whole image. |dirtyRects| contains the set of rectangles that need + // to be repainted. On Windows |buffer| will be width*height*4 bytes in size + // and represents a BGRA image with an upper-left origin. + /// + void (CEF_CALLBACK *on_paint)(struct _cef_render_handler_t* self, + struct _cef_browser_t* browser, enum cef_paint_element_type_t type, + size_t dirtyRectsCount, cef_rect_t const* dirtyRects, + const void* buffer); + + /// + // Called when the browser window's cursor has changed. + /// + void (CEF_CALLBACK *on_cursor_change)(struct _cef_render_handler_t* self, + struct _cef_browser_t* browser, cef_cursor_handle_t cursor); +} cef_render_handler_t; + + +#ifdef __cplusplus +} +#endif + +#endif // CEF_INCLUDE_CAPI_CEF_RENDER_HANDLER_CAPI_H_ diff --git a/cef/include/capi/cef_request_capi.h b/cef/include/capi/cef_request_capi.h new file mode 100644 index 000000000..f4650f6ec --- /dev/null +++ b/cef/include/capi/cef_request_capi.h @@ -0,0 +1,261 @@ +// Copyright (c) 2012 Marshall A. Greenblatt. All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the name Chromium Embedded +// Framework nor the names of its contributors may be used to endorse +// or promote products derived from this software without specific prior +// written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +// --------------------------------------------------------------------------- +// +// This file was generated by the CEF translator tool and should not edited +// by hand. See the translator.README.txt file in the tools directory for +// more information. +// + +#ifndef CEF_INCLUDE_CAPI_CEF_REQUEST_CAPI_H_ +#define CEF_INCLUDE_CAPI_CEF_REQUEST_CAPI_H_ +#pragma once + +#ifdef __cplusplus +extern "C" { +#endif + +#include "include/capi/cef_base_capi.h" + + +/// +// Structure used to represent a web request. The functions of this structure +// may be called on any thread. +/// +typedef struct _cef_request_t { + /// + // Base structure. + /// + cef_base_t base; + + /// + // Get the fully qualified URL. + /// + // The resulting string must be freed by calling cef_string_userfree_free(). + cef_string_userfree_t (CEF_CALLBACK *get_url)(struct _cef_request_t* self); + + /// + // Set the fully qualified URL. + /// + void (CEF_CALLBACK *set_url)(struct _cef_request_t* self, + const cef_string_t* url); + + /// + // Get the request function type. The value will default to POST if post data + // is provided and GET otherwise. + /// + // The resulting string must be freed by calling cef_string_userfree_free(). + cef_string_userfree_t (CEF_CALLBACK *get_method)(struct _cef_request_t* self); + + /// + // Set the request function type. + /// + void (CEF_CALLBACK *set_method)(struct _cef_request_t* self, + const cef_string_t* method); + + /// + // Get the post data. + /// + struct _cef_post_data_t* (CEF_CALLBACK *get_post_data)( + struct _cef_request_t* self); + + /// + // Set the post data. + /// + void (CEF_CALLBACK *set_post_data)(struct _cef_request_t* self, + struct _cef_post_data_t* postData); + + /// + // Get the header values. + /// + void (CEF_CALLBACK *get_header_map)(struct _cef_request_t* self, + cef_string_multimap_t headerMap); + + /// + // Set the header values. + /// + void (CEF_CALLBACK *set_header_map)(struct _cef_request_t* self, + cef_string_multimap_t headerMap); + + /// + // Set all values at one time. + /// + void (CEF_CALLBACK *set)(struct _cef_request_t* self, const cef_string_t* url, + const cef_string_t* method, struct _cef_post_data_t* postData, + cef_string_multimap_t headerMap); + + /// + // Get the flags used in combination with cef_web_urlrequest_t. + /// + enum cef_weburlrequest_flags_t (CEF_CALLBACK *get_flags)( + struct _cef_request_t* self); + + /// + // Set the flags used in combination with cef_web_urlrequest_t. + /// + void (CEF_CALLBACK *set_flags)(struct _cef_request_t* self, + enum cef_weburlrequest_flags_t flags); + + /// + // Set the URL to the first party for cookies used in combination with + // cef_web_urlrequest_t. + /// + // The resulting string must be freed by calling cef_string_userfree_free(). + cef_string_userfree_t (CEF_CALLBACK *get_first_party_for_cookies)( + struct _cef_request_t* self); + + /// + // Get the URL to the first party for cookies used in combination with + // cef_web_urlrequest_t. + /// + void (CEF_CALLBACK *set_first_party_for_cookies)(struct _cef_request_t* self, + const cef_string_t* url); +} cef_request_t; + + +/// +// Create a new cef_request_t object. +/// +CEF_EXPORT cef_request_t* cef_request_create(); + + +/// +// Structure used to represent post data for a web request. The functions of +// this structure may be called on any thread. +/// +typedef struct _cef_post_data_t { + /// + // Base structure. + /// + cef_base_t base; + + /// + // Returns the number of existing post data elements. + /// + size_t (CEF_CALLBACK *get_element_count)(struct _cef_post_data_t* self); + + /// + // Retrieve the post data elements. + /// + void (CEF_CALLBACK *get_elements)(struct _cef_post_data_t* self, + size_t* elementsCount, struct _cef_post_data_element_t** elements); + + /// + // Remove the specified post data element. Returns true (1) if the removal + // succeeds. + /// + int (CEF_CALLBACK *remove_element)(struct _cef_post_data_t* self, + struct _cef_post_data_element_t* element); + + /// + // Add the specified post data element. Returns true (1) if the add succeeds. + /// + int (CEF_CALLBACK *add_element)(struct _cef_post_data_t* self, + struct _cef_post_data_element_t* element); + + /// + // Remove all existing post data elements. + /// + void (CEF_CALLBACK *remove_elements)(struct _cef_post_data_t* self); +} cef_post_data_t; + + +/// +// Create a new cef_post_data_t object. +/// +CEF_EXPORT cef_post_data_t* cef_post_data_create(); + + +/// +// Structure used to represent a single element in the request post data. The +// functions of this structure may be called on any thread. +/// +typedef struct _cef_post_data_element_t { + /// + // Base structure. + /// + cef_base_t base; + + /// + // Remove all contents from the post data element. + /// + void (CEF_CALLBACK *set_to_empty)(struct _cef_post_data_element_t* self); + + /// + // The post data element will represent a file. + /// + void (CEF_CALLBACK *set_to_file)(struct _cef_post_data_element_t* self, + const cef_string_t* fileName); + + /// + // The post data element will represent bytes. The bytes passed in will be + // copied. + /// + void (CEF_CALLBACK *set_to_bytes)(struct _cef_post_data_element_t* self, + size_t size, const void* bytes); + + /// + // Return the type of this post data element. + /// + enum cef_postdataelement_type_t (CEF_CALLBACK *get_type)( + struct _cef_post_data_element_t* self); + + /// + // Return the file name. + /// + // The resulting string must be freed by calling cef_string_userfree_free(). + cef_string_userfree_t (CEF_CALLBACK *get_file)( + struct _cef_post_data_element_t* self); + + /// + // Return the number of bytes. + /// + size_t (CEF_CALLBACK *get_bytes_count)(struct _cef_post_data_element_t* self); + + /// + // Read up to |size| bytes into |bytes| and return the number of bytes + // actually read. + /// + size_t (CEF_CALLBACK *get_bytes)(struct _cef_post_data_element_t* self, + size_t size, void* bytes); +} cef_post_data_element_t; + + +/// +// Create a new cef_post_data_element_t object. +/// +CEF_EXPORT cef_post_data_element_t* cef_post_data_element_create(); + + +#ifdef __cplusplus +} +#endif + +#endif // CEF_INCLUDE_CAPI_CEF_REQUEST_CAPI_H_ diff --git a/cef/include/capi/cef_request_handler_capi.h b/cef/include/capi/cef_request_handler_capi.h new file mode 100644 index 000000000..3414001b9 --- /dev/null +++ b/cef/include/capi/cef_request_handler_capi.h @@ -0,0 +1,159 @@ +// Copyright (c) 2012 Marshall A. Greenblatt. All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the name Chromium Embedded +// Framework nor the names of its contributors may be used to endorse +// or promote products derived from this software without specific prior +// written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +// --------------------------------------------------------------------------- +// +// This file was generated by the CEF translator tool and should not edited +// by hand. See the translator.README.txt file in the tools directory for +// more information. +// + +#ifndef CEF_INCLUDE_CAPI_CEF_REQUEST_HANDLER_CAPI_H_ +#define CEF_INCLUDE_CAPI_CEF_REQUEST_HANDLER_CAPI_H_ +#pragma once + +#ifdef __cplusplus +extern "C" { +#endif + +#include "include/capi/cef_base_capi.h" + + +/// +// Implement this structure to handle events related to browser requests. The +// functions of this structure will be called on the thread indicated. +/// +typedef struct _cef_request_handler_t { + /// + // Base structure. + /// + cef_base_t base; + + /// + // Called on the UI thread before browser navigation. Return true (1) to + // cancel the navigation or false (0) to allow the navigation to proceed. + /// + int (CEF_CALLBACK *on_before_browse)(struct _cef_request_handler_t* self, + struct _cef_browser_t* browser, struct _cef_frame_t* frame, + struct _cef_request_t* request, enum cef_handler_navtype_t navType, + int isRedirect); + + /// + // Called on the IO thread before a resource is loaded. To allow the resource + // to load normally return false (0). To redirect the resource to a new url + // populate the |redirectUrl| value and return false (0). To specify data for + // the resource return a CefStream object in |resourceStream|, use the + // |response| object to set mime type, HTTP status code and optional header + // values, and return false (0). To cancel loading of the resource return true + // (1). Any modifications to |request| will be observed. If the URL in + // |request| is changed and |redirectUrl| is also set, the URL in |request| + // will be used. + /// + int (CEF_CALLBACK *on_before_resource_load)( + struct _cef_request_handler_t* self, struct _cef_browser_t* browser, + struct _cef_request_t* request, cef_string_t* redirectUrl, + struct _cef_stream_reader_t** resourceStream, + struct _cef_response_t* response, int loadFlags); + + /// + // Called on the IO thread when a resource load is redirected. The |old_url| + // parameter will contain the old URL. The |new_url| parameter will contain + // the new URL and can be changed if desired. + /// + void (CEF_CALLBACK *on_resource_redirect)(struct _cef_request_handler_t* self, + struct _cef_browser_t* browser, const cef_string_t* old_url, + cef_string_t* new_url); + + /// + // Called on the UI thread after a response to the resource request is + // received. Set |filter| if response content needs to be monitored and/or + // modified as it arrives. + /// + void (CEF_CALLBACK *on_resource_response)(struct _cef_request_handler_t* self, + struct _cef_browser_t* browser, const cef_string_t* url, + struct _cef_response_t* response, + struct _cef_content_filter_t** filter); + + /// + // Called on the IO thread to handle requests for URLs with an unknown + // protocol component. Return true (1) to indicate that the request should + // succeed because it was handled externally. Set |allowOSExecution| to true + // (1) and return false (0) to attempt execution via the registered OS + // protocol handler, if any. If false (0) is returned and either + // |allow_os_execution| is false (0) or OS protocol handler execution fails + // then the request will fail with an error condition. SECURITY WARNING: YOU + // SHOULD USE THIS METHOD TO ENFORCE RESTRICTIONS BASED ON SCHEME, HOST OR + // OTHER URL ANALYSIS BEFORE ALLOWING OS EXECUTION. + /// + int (CEF_CALLBACK *on_protocol_execution)(struct _cef_request_handler_t* self, + struct _cef_browser_t* browser, const cef_string_t* url, + int* allowOSExecution); + + /// + // Called on the UI thread when a server indicates via the 'Content- + // Disposition' header that a response represents a file to download. + // |mimeType| is the mime type for the download, |fileName| is the suggested + // target file name and |contentLength| is either the value of the 'Content- + // Size' header or -1 if no size was provided. Set |handler| to the + // cef_download_handler_t instance that will recieve the file contents. Return + // true (1) to download the file or false (0) to cancel the file download. + /// + int (CEF_CALLBACK *get_download_handler)(struct _cef_request_handler_t* self, + struct _cef_browser_t* browser, const cef_string_t* mimeType, + const cef_string_t* fileName, int64 contentLength, + struct _cef_download_handler_t** handler); + + /// + // Called on the IO thread when the browser needs credentials from the user. + // |isProxy| indicates whether the host is a proxy server. |host| contains the + // hostname and port number. Set |username| and |password| and return true (1) + // to handle the request. Return false (0) to cancel the request. + /// + int (CEF_CALLBACK *get_auth_credentials)(struct _cef_request_handler_t* self, + struct _cef_browser_t* browser, int isProxy, const cef_string_t* host, + int port, const cef_string_t* realm, const cef_string_t* scheme, + cef_string_t* username, cef_string_t* password); + + /// + // Called on the IO thread to retrieve the cookie manager. |main_url| is the + // URL of the top-level frame. Cookies managers can be unique per browser or + // shared across multiple browsers. The global cookie manager will be used if + // this function returns NULL. + /// + struct _cef_cookie_manager_t* (CEF_CALLBACK *get_cookie_manager)( + struct _cef_request_handler_t* self, struct _cef_browser_t* browser, + const cef_string_t* main_url); +} cef_request_handler_t; + + +#ifdef __cplusplus +} +#endif + +#endif // CEF_INCLUDE_CAPI_CEF_REQUEST_HANDLER_CAPI_H_ diff --git a/cef/include/capi/cef_resource_bundle_handler_capi.h b/cef/include/capi/cef_resource_bundle_handler_capi.h new file mode 100644 index 000000000..2111fa7e2 --- /dev/null +++ b/cef/include/capi/cef_resource_bundle_handler_capi.h @@ -0,0 +1,95 @@ +// Copyright (c) 2012 Marshall A. Greenblatt. All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the name Chromium Embedded +// Framework nor the names of its contributors may be used to endorse +// or promote products derived from this software without specific prior +// written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +// --------------------------------------------------------------------------- +// +// This file was generated by the CEF translator tool and should not edited +// by hand. See the translator.README.txt file in the tools directory for +// more information. +// + +#ifndef CEF_INCLUDE_CAPI_CEF_RESOURCE_BUNDLE_HANDLER_CAPI_H_ +#define CEF_INCLUDE_CAPI_CEF_RESOURCE_BUNDLE_HANDLER_CAPI_H_ +#pragma once + +#ifdef __cplusplus +extern "C" { +#endif + +#include "include/capi/cef_base_capi.h" + + +/// +// Structure used to implement a custom resource bundle structure. The functions +// of this structure may be called on multiple threads. +/// +typedef struct _cef_resource_bundle_handler_t { + /// + // Base structure. + /// + cef_base_t base; + + /// + // Called to retrieve a localized translation for the string specified by + // |message_id|. To provide the translation set |string| to the translation + // string and return true (1). To use the default translation return false + // (0). + // + // WARNING: Be cautious when implementing this function. ID values are auto- + // generated when CEF is built and may change between versions. Existing ID + // values can be discovered by searching for *_strings.h in the + // "obj/global_intermediate" build output directory. + /// + int (CEF_CALLBACK *get_localized_string)( + struct _cef_resource_bundle_handler_t* self, int message_id, + cef_string_t* string); + + /// + // Called to retrieve data for the resource specified by |resource_id|. To + // provide the resource data set |data| and |data_size| to the data pointer + // and size respectively and return true (1). To use the default resource data + // return false (0). The resource data will not be copied and must remain + // resident in memory. + // + // WARNING: Be cautious when implementing this function. ID values are auto- + // generated when CEF is built and may change between versions. Existing ID + // values can be discovered by searching for *_resources.h in the + // "obj/global_intermediate" build output directory. + /// + int (CEF_CALLBACK *get_data_resource)( + struct _cef_resource_bundle_handler_t* self, int resource_id, void** data, + size_t* data_size); +} cef_resource_bundle_handler_t; + + +#ifdef __cplusplus +} +#endif + +#endif // CEF_INCLUDE_CAPI_CEF_RESOURCE_BUNDLE_HANDLER_CAPI_H_ diff --git a/cef/include/capi/cef_response_capi.h b/cef/include/capi/cef_response_capi.h new file mode 100644 index 000000000..e58180711 --- /dev/null +++ b/cef/include/capi/cef_response_capi.h @@ -0,0 +1,119 @@ +// Copyright (c) 2012 Marshall A. Greenblatt. All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the name Chromium Embedded +// Framework nor the names of its contributors may be used to endorse +// or promote products derived from this software without specific prior +// written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +// --------------------------------------------------------------------------- +// +// This file was generated by the CEF translator tool and should not edited +// by hand. See the translator.README.txt file in the tools directory for +// more information. +// + +#ifndef CEF_INCLUDE_CAPI_CEF_RESPONSE_CAPI_H_ +#define CEF_INCLUDE_CAPI_CEF_RESPONSE_CAPI_H_ +#pragma once + +#ifdef __cplusplus +extern "C" { +#endif + +#include "include/capi/cef_base_capi.h" + + +/// +// Structure used to represent a web response. The functions of this structure +// may be called on any thread. +/// +typedef struct _cef_response_t { + /// + // Base structure. + /// + cef_base_t base; + + /// + // Get the response status code. + /// + int (CEF_CALLBACK *get_status)(struct _cef_response_t* self); + + /// + // Set the response status code. + /// + void (CEF_CALLBACK *set_status)(struct _cef_response_t* self, int status); + + /// + // Get the response status text. + /// + // The resulting string must be freed by calling cef_string_userfree_free(). + cef_string_userfree_t (CEF_CALLBACK *get_status_text)( + struct _cef_response_t* self); + + /// + // Set the response status text. + /// + void (CEF_CALLBACK *set_status_text)(struct _cef_response_t* self, + const cef_string_t* statusText); + + /// + // Get the response mime type. + /// + // The resulting string must be freed by calling cef_string_userfree_free(). + cef_string_userfree_t (CEF_CALLBACK *get_mime_type)( + struct _cef_response_t* self); + + /// + // Set the response mime type. + /// + void (CEF_CALLBACK *set_mime_type)(struct _cef_response_t* self, + const cef_string_t* mimeType); + + /// + // Get the value for the specified response header field. + /// + // The resulting string must be freed by calling cef_string_userfree_free(). + cef_string_userfree_t (CEF_CALLBACK *get_header)(struct _cef_response_t* self, + const cef_string_t* name); + + /// + // Get all response header fields. + /// + void (CEF_CALLBACK *get_header_map)(struct _cef_response_t* self, + cef_string_multimap_t headerMap); + + /// + // Set all response header fields. + /// + void (CEF_CALLBACK *set_header_map)(struct _cef_response_t* self, + cef_string_multimap_t headerMap); +} cef_response_t; + + +#ifdef __cplusplus +} +#endif + +#endif // CEF_INCLUDE_CAPI_CEF_RESPONSE_CAPI_H_ diff --git a/cef/include/capi/cef_scheme_capi.h b/cef/include/capi/cef_scheme_capi.h new file mode 100644 index 000000000..b3806580b --- /dev/null +++ b/cef/include/capi/cef_scheme_capi.h @@ -0,0 +1,226 @@ +// Copyright (c) 2012 Marshall A. Greenblatt. All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the name Chromium Embedded +// Framework nor the names of its contributors may be used to endorse +// or promote products derived from this software without specific prior +// written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +// --------------------------------------------------------------------------- +// +// This file was generated by the CEF translator tool and should not edited +// by hand. See the translator.README.txt file in the tools directory for +// more information. +// + +#ifndef CEF_INCLUDE_CAPI_CEF_SCHEME_CAPI_H_ +#define CEF_INCLUDE_CAPI_CEF_SCHEME_CAPI_H_ +#pragma once + +#ifdef __cplusplus +extern "C" { +#endif + +#include "include/capi/cef_base_capi.h" + + +/// +// Register a custom scheme. This function should not be called for the built-in +// HTTP, HTTPS, FILE, FTP, ABOUT and DATA schemes. +// +// If |is_standard| is true (1) the scheme will be treated as a standard scheme. +// Standard schemes are subject to URL canonicalization and parsing rules as +// defined in the Common Internet Scheme Syntax RFC 1738 Section 3.1 available +// at http://www.ietf.org/rfc/rfc1738.txt +// +// In particular, the syntax for standard scheme URLs must be of the form: 
+//  [scheme]://[username]:[password]@[host]:[port]/[url-path]
+//
Standard scheme URLs must have a host component that is a fully +// qualified domain name as defined in Section 3.5 of RFC 1034 [13] and Section +// 2.1 of RFC 1123. These URLs will be canonicalized to "scheme://host/path" in +// the simplest case and "scheme://username:password@host:port/path" in the most +// explicit case. For example, "scheme:host/path" and "scheme:///host/path" will +// both be canonicalized to "scheme://host/path". The origin of a standard +// scheme URL is the combination of scheme, host and port (i.e., +// "scheme://host:port" in the most explicit case). +// +// For non-standard scheme URLs only the "scheme:" component is parsed and +// canonicalized. The remainder of the URL will be passed to the handler as-is. +// For example, "scheme:///some%20text" will remain the same. Non-standard +// scheme URLs cannot be used as a target for form submission. +// +// If |is_local| is true (1) the scheme will be treated as local (i.e., with the +// same security rules as those applied to "file" URLs). Normal pages cannot +// link to or access local URLs. Also, by default, local URLs can only perform +// XMLHttpRequest calls to the same URL (origin + path) that originated the +// request. To allow XMLHttpRequest calls from a local URL to other URLs with +// the same origin set the CefSettings.file_access_from_file_urls_allowed value +// to true (1). To allow XMLHttpRequest calls from a local URL to all origins +// set the CefSettings.universal_access_from_file_urls_allowed value to true +// (1). +// +// If |is_display_isolated| is true (1) the scheme will be treated as display- +// isolated. This means that pages cannot display these URLs unless they are +// from the same scheme. For example, pages in another origin cannot create +// iframes or hyperlinks to URLs with this scheme. +// +// This function may be called on any thread. It should only be called once per +// unique |scheme_name| value. If |scheme_name| is already registered or if an +// error occurs this function will return false (0). +/// +CEF_EXPORT int cef_register_custom_scheme(const cef_string_t* scheme_name, + int is_standard, int is_local, int is_display_isolated); + +/// +// Register a scheme handler factory for the specified |scheme_name| and +// optional |domain_name|. An NULL |domain_name| value for a standard scheme +// will cause the factory to match all domain names. The |domain_name| value +// will be ignored for non-standard schemes. If |scheme_name| is a built-in +// scheme and no handler is returned by |factory| then the built-in scheme +// handler factory will be called. If |scheme_name| is a custom scheme the +// cef_register_custom_scheme() function should be called for that scheme. This +// function may be called multiple times to change or remove the factory that +// matches the specified |scheme_name| and optional |domain_name|. Returns false +// (0) if an error occurs. This function may be called on any thread. +/// +CEF_EXPORT int cef_register_scheme_handler_factory( + const cef_string_t* scheme_name, const cef_string_t* domain_name, + struct _cef_scheme_handler_factory_t* factory); + +/// +// Clear all registered scheme handler factories. Returns false (0) on error. +// This function may be called on any thread. +/// +CEF_EXPORT int cef_clear_scheme_handler_factories(); + +/// +// Structure that creates cef_scheme_handler_t instances. The functions of this +// structure will always be called on the IO thread. +/// +typedef struct _cef_scheme_handler_factory_t { + /// + // Base structure. + /// + cef_base_t base; + + /// + // Return a new scheme handler instance to handle the request. |browser| will + // be the browser window that initiated the request. If the request was + // initiated using the cef_web_urlrequest_t API |browser| will be NULL. The + // |request| object passed to this function will not contain cookie data. + /// + struct _cef_scheme_handler_t* (CEF_CALLBACK *create)( + struct _cef_scheme_handler_factory_t* self, + struct _cef_browser_t* browser, const cef_string_t* scheme_name, + struct _cef_request_t* request); +} cef_scheme_handler_factory_t; + + +/// +// Structure used to facilitate asynchronous responses to custom scheme handler +// requests. The functions of this structure may be called on any thread. +/// +typedef struct _cef_scheme_handler_callback_t { + /// + // Base structure. + /// + cef_base_t base; + + /// + // Notify that header information is now available for retrieval. + /// + void (CEF_CALLBACK *headers_available)( + struct _cef_scheme_handler_callback_t* self); + + /// + // Notify that response data is now available for reading. + /// + void (CEF_CALLBACK *bytes_available)( + struct _cef_scheme_handler_callback_t* self); + + /// + // Cancel processing of the request. + /// + void (CEF_CALLBACK *cancel)(struct _cef_scheme_handler_callback_t* self); +} cef_scheme_handler_callback_t; + + +/// +// Structure used to implement a custom scheme handler structure. The functions +// of this structure will always be called on the IO thread. +/// +typedef struct _cef_scheme_handler_t { + /// + // Base structure. + /// + cef_base_t base; + + /// + // Begin processing the request. To handle the request return true (1) and + // call headers_available() once the response header information is available + // (headers_available() can also be called from inside this function if header + // information is available immediately). To cancel the request return false + // (0). + /// + int (CEF_CALLBACK *process_request)(struct _cef_scheme_handler_t* self, + struct _cef_request_t* request, + struct _cef_scheme_handler_callback_t* callback); + + /// + // Retrieve response header information. If the response length is not known + // set |response_length| to -1 and read_response() will be called until it + // returns false (0). If the response length is known set |response_length| to + // a positive value and read_response() will be called until it returns false + // (0) or the specified number of bytes have been read. Use the |response| + // object to set the mime type, http status code and other optional header + // values. To redirect the request to a new URL set |redirectUrl| to the new + // URL. + /// + void (CEF_CALLBACK *get_response_headers)(struct _cef_scheme_handler_t* self, + struct _cef_response_t* response, int64* response_length, + cef_string_t* redirectUrl); + + /// + // Read response data. If data is available immediately copy up to + // |bytes_to_read| bytes into |data_out|, set |bytes_read| to the number of + // bytes copied, and return true (1). To read the data at a later time set + // |bytes_read| to 0, return true (1) and call bytes_available() when the data + // is available. To indicate response completion return false (0). + /// + int (CEF_CALLBACK *read_response)(struct _cef_scheme_handler_t* self, + void* data_out, int bytes_to_read, int* bytes_read, + struct _cef_scheme_handler_callback_t* callback); + + /// + // Request processing has been canceled. + /// + void (CEF_CALLBACK *cancel)(struct _cef_scheme_handler_t* self); +} cef_scheme_handler_t; + + +#ifdef __cplusplus +} +#endif + +#endif // CEF_INCLUDE_CAPI_CEF_SCHEME_CAPI_H_ diff --git a/cef/include/capi/cef_storage_capi.h b/cef/include/capi/cef_storage_capi.h new file mode 100644 index 000000000..d04a6684b --- /dev/null +++ b/cef/include/capi/cef_storage_capi.h @@ -0,0 +1,116 @@ +// Copyright (c) 2012 Marshall A. Greenblatt. All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the name Chromium Embedded +// Framework nor the names of its contributors may be used to endorse +// or promote products derived from this software without specific prior +// written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +// --------------------------------------------------------------------------- +// +// This file was generated by the CEF translator tool and should not edited +// by hand. See the translator.README.txt file in the tools directory for +// more information. +// + +#ifndef CEF_INCLUDE_CAPI_CEF_STORAGE_CAPI_H_ +#define CEF_INCLUDE_CAPI_CEF_STORAGE_CAPI_H_ +#pragma once + +#ifdef __cplusplus +extern "C" { +#endif + +#include "include/capi/cef_base_capi.h" + + +/// +// Visit storage of the specified type. If |origin| is non-NULL only data +// matching that origin will be visited. If |key| is non-NULL only data matching +// that key will be visited. Otherwise, all data for the storage type will be +// visited. Origin should be of the form scheme://domain. If no origin is +// specified only data currently in memory will be returned. Returns false (0) +// if the storage cannot be accessed. +/// +CEF_EXPORT int cef_visit_storage(enum cef_storage_type_t type, + const cef_string_t* origin, const cef_string_t* key, + struct _cef_storage_visitor_t* visitor); + +/// +// Sets storage of the specified type, origin, key and value. Returns false (0) +// if storage cannot be accessed. This function must be called on the UI thread. +/// +CEF_EXPORT int cef_set_storage(enum cef_storage_type_t type, + const cef_string_t* origin, const cef_string_t* key, + const cef_string_t* value); + +/// +// Deletes all storage of the specified type. If |origin| is non-NULL only data +// matching that origin will be cleared. If |key| is non-NULL only data matching +// that key will be cleared. Otherwise, all data for the storage type will be +// cleared. Returns false (0) if storage cannot be accessed. This function must +// be called on the UI thread. +/// +CEF_EXPORT int cef_delete_storage(enum cef_storage_type_t type, + const cef_string_t* origin, const cef_string_t* key); + +/// +// Sets the directory path that will be used for storing data of the specified +// type. Currently only the ST_LOCALSTORAGE type is supported by this function. +// If |path| is NULL data will be stored in memory only. By default the storage +// path is the same as the cache path. Returns false (0) if the storage cannot +// be accessed. +/// +CEF_EXPORT int cef_set_storage_path(enum cef_storage_type_t type, + const cef_string_t* path); + +/// +// Structure to implement for visiting storage. The functions of this structure +// will always be called on the UI thread. +/// +typedef struct _cef_storage_visitor_t { + /// + // Base structure. + /// + cef_base_t base; + + /// + // Method that will be called once for each key/value data pair in storage. + // |count| is the 0-based index for the current pair. |total| is the total + // number of pairs. Set |deleteData| to true (1) to delete the pair currently + // being visited. Return false (0) to stop visiting pairs. This function may + // never be called if no data is found. + /// + int (CEF_CALLBACK *visit)(struct _cef_storage_visitor_t* self, + enum cef_storage_type_t type, const cef_string_t* origin, + const cef_string_t* key, const cef_string_t* value, int count, int total, + int* deleteData); +} cef_storage_visitor_t; + + +#ifdef __cplusplus +} +#endif + +#endif // CEF_INCLUDE_CAPI_CEF_STORAGE_CAPI_H_ diff --git a/cef/include/capi/cef_stream_capi.h b/cef/include/capi/cef_stream_capi.h new file mode 100644 index 000000000..f73fa39c3 --- /dev/null +++ b/cef/include/capi/cef_stream_capi.h @@ -0,0 +1,224 @@ +// Copyright (c) 2012 Marshall A. Greenblatt. All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the name Chromium Embedded +// Framework nor the names of its contributors may be used to endorse +// or promote products derived from this software without specific prior +// written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +// --------------------------------------------------------------------------- +// +// This file was generated by the CEF translator tool and should not edited +// by hand. See the translator.README.txt file in the tools directory for +// more information. +// + +#ifndef CEF_INCLUDE_CAPI_CEF_STREAM_CAPI_H_ +#define CEF_INCLUDE_CAPI_CEF_STREAM_CAPI_H_ +#pragma once + +#ifdef __cplusplus +extern "C" { +#endif + +#include "include/capi/cef_base_capi.h" + + +/// +// Structure the client can implement to provide a custom stream reader. The +// functions of this structure may be called on any thread. +/// +typedef struct _cef_read_handler_t { + /// + // Base structure. + /// + cef_base_t base; + + /// + // Read raw binary data. + /// + size_t (CEF_CALLBACK *read)(struct _cef_read_handler_t* self, void* ptr, + size_t size, size_t n); + + /// + // Seek to the specified offset position. |whence| may be any one of SEEK_CUR, + // SEEK_END or SEEK_SET. Return zero on success and non-zero on failure. + /// + int (CEF_CALLBACK *seek)(struct _cef_read_handler_t* self, int64 offset, + int whence); + + /// + // Return the current offset position. + /// + int64 (CEF_CALLBACK *tell)(struct _cef_read_handler_t* self); + + /// + // Return non-zero if at end of file. + /// + int (CEF_CALLBACK *eof)(struct _cef_read_handler_t* self); +} cef_read_handler_t; + + +/// +// Structure used to read data from a stream. The functions of this structure +// may be called on any thread. +/// +typedef struct _cef_stream_reader_t { + /// + // Base structure. + /// + cef_base_t base; + + /// + // Read raw binary data. + /// + size_t (CEF_CALLBACK *read)(struct _cef_stream_reader_t* self, void* ptr, + size_t size, size_t n); + + /// + // Seek to the specified offset position. |whence| may be any one of SEEK_CUR, + // SEEK_END or SEEK_SET. Returns zero on success and non-zero on failure. + /// + int (CEF_CALLBACK *seek)(struct _cef_stream_reader_t* self, int64 offset, + int whence); + + /// + // Return the current offset position. + /// + int64 (CEF_CALLBACK *tell)(struct _cef_stream_reader_t* self); + + /// + // Return non-zero if at end of file. + /// + int (CEF_CALLBACK *eof)(struct _cef_stream_reader_t* self); +} cef_stream_reader_t; + + +/// +// Create a new cef_stream_reader_t object from a file. +/// +CEF_EXPORT cef_stream_reader_t* cef_stream_reader_create_for_file( + const cef_string_t* fileName); + +/// +// Create a new cef_stream_reader_t object from data. +/// +CEF_EXPORT cef_stream_reader_t* cef_stream_reader_create_for_data(void* data, + size_t size); + +/// +// Create a new cef_stream_reader_t object from a custom handler. +/// +CEF_EXPORT cef_stream_reader_t* cef_stream_reader_create_for_handler( + cef_read_handler_t* handler); + + +/// +// Structure the client can implement to provide a custom stream writer. The +// functions of this structure may be called on any thread. +/// +typedef struct _cef_write_handler_t { + /// + // Base structure. + /// + cef_base_t base; + + /// + // Write raw binary data. + /// + size_t (CEF_CALLBACK *write)(struct _cef_write_handler_t* self, + const void* ptr, size_t size, size_t n); + + /// + // Seek to the specified offset position. |whence| may be any one of SEEK_CUR, + // SEEK_END or SEEK_SET. Return zero on success and non-zero on failure. + /// + int (CEF_CALLBACK *seek)(struct _cef_write_handler_t* self, int64 offset, + int whence); + + /// + // Return the current offset position. + /// + int64 (CEF_CALLBACK *tell)(struct _cef_write_handler_t* self); + + /// + // Flush the stream. + /// + int (CEF_CALLBACK *flush)(struct _cef_write_handler_t* self); +} cef_write_handler_t; + + +/// +// Structure used to write data to a stream. The functions of this structure may +// be called on any thread. +/// +typedef struct _cef_stream_writer_t { + /// + // Base structure. + /// + cef_base_t base; + + /// + // Write raw binary data. + /// + size_t (CEF_CALLBACK *write)(struct _cef_stream_writer_t* self, + const void* ptr, size_t size, size_t n); + + /// + // Seek to the specified offset position. |whence| may be any one of SEEK_CUR, + // SEEK_END or SEEK_SET. Returns zero on success and non-zero on failure. + /// + int (CEF_CALLBACK *seek)(struct _cef_stream_writer_t* self, int64 offset, + int whence); + + /// + // Return the current offset position. + /// + int64 (CEF_CALLBACK *tell)(struct _cef_stream_writer_t* self); + + /// + // Flush the stream. + /// + int (CEF_CALLBACK *flush)(struct _cef_stream_writer_t* self); +} cef_stream_writer_t; + + +/// +// Create a new cef_stream_writer_t object for a file. +/// +CEF_EXPORT cef_stream_writer_t* cef_stream_writer_create_for_file( + const cef_string_t* fileName); + +/// +// Create a new cef_stream_writer_t object for a custom handler. +/// +CEF_EXPORT cef_stream_writer_t* cef_stream_writer_create_for_handler( + cef_write_handler_t* handler); + + +#ifdef __cplusplus +} +#endif + +#endif // CEF_INCLUDE_CAPI_CEF_STREAM_CAPI_H_ diff --git a/cef/include/capi/cef_task_capi.h b/cef/include/capi/cef_task_capi.h new file mode 100644 index 000000000..cca4fbd9c --- /dev/null +++ b/cef/include/capi/cef_task_capi.h @@ -0,0 +1,96 @@ +// Copyright (c) 2012 Marshall A. Greenblatt. All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the name Chromium Embedded +// Framework nor the names of its contributors may be used to endorse +// or promote products derived from this software without specific prior +// written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +// --------------------------------------------------------------------------- +// +// This file was generated by the CEF translator tool and should not edited +// by hand. See the translator.README.txt file in the tools directory for +// more information. +// + +#ifndef CEF_INCLUDE_CAPI_CEF_TASK_CAPI_H_ +#define CEF_INCLUDE_CAPI_CEF_TASK_CAPI_H_ +#pragma once + +#ifdef __cplusplus +extern "C" { +#endif + +#include "include/capi/cef_base_capi.h" + + +/// +// CEF maintains multiple internal threads that are used for handling different +// types of tasks. The UI thread creates the browser window and is used for all +// interaction with the WebKit rendering engine and V8 JavaScript engine (The UI +// thread will be the same as the main application thread if cef_initialize() is +// called with a CefSettings.multi_threaded_message_loop value of false (0).) +// The IO thread is used for handling schema and network requests. The FILE +// thread is used for the application cache and other miscellaneous activities. +// This function will return true (1) if called on the specified thread. +/// +CEF_EXPORT int cef_currently_on(cef_thread_id_t threadId); + +/// +// Post a task for execution on the specified thread. This function may be +// called on any thread. +/// +CEF_EXPORT int cef_post_task(cef_thread_id_t threadId, + struct _cef_task_t* task); + +/// +// Post a task for delayed execution on the specified thread. This function may +// be called on any thread. +/// +CEF_EXPORT int cef_post_delayed_task(cef_thread_id_t threadId, + struct _cef_task_t* task, int64 delay_ms); + +/// +// Implement this structure for task execution. The functions of this structure +// may be called on any thread. +/// +typedef struct _cef_task_t { + /// + // Base structure. + /// + cef_base_t base; + + /// + // Method that will be executed. |threadId| is the thread executing the call. + /// + void (CEF_CALLBACK *execute)(struct _cef_task_t* self, + cef_thread_id_t threadId); +} cef_task_t; + + +#ifdef __cplusplus +} +#endif + +#endif // CEF_INCLUDE_CAPI_CEF_TASK_CAPI_H_ diff --git a/cef/include/capi/cef_url_capi.h b/cef/include/capi/cef_url_capi.h new file mode 100644 index 000000000..757875b39 --- /dev/null +++ b/cef/include/capi/cef_url_capi.h @@ -0,0 +1,67 @@ +// Copyright (c) 2012 Marshall A. Greenblatt. All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the name Chromium Embedded +// Framework nor the names of its contributors may be used to endorse +// or promote products derived from this software without specific prior +// written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +// --------------------------------------------------------------------------- +// +// This file was generated by the CEF translator tool and should not edited +// by hand. See the translator.README.txt file in the tools directory for +// more information. +// + +#ifndef CEF_INCLUDE_CAPI_CEF_URL_CAPI_H_ +#define CEF_INCLUDE_CAPI_CEF_URL_CAPI_H_ +#pragma once + +#ifdef __cplusplus +extern "C" { +#endif + +#include "include/capi/cef_base_capi.h" + + +/// +// Parse the specified |url| into its component parts. Returns false (0) if the +// URL is NULL or invalid. +/// +CEF_EXPORT int cef_parse_url(const cef_string_t* url, + struct _cef_urlparts_t* parts); + +/// +// Creates a URL from the specified |parts|, which must contain a non-NULL spec +// or a non-NULL host and path (at a minimum), but not both. Returns false (0) +// if |parts| isn't initialized as described. +/// +CEF_EXPORT int cef_create_url(const struct _cef_urlparts_t* parts, + cef_string_t* url); + +#ifdef __cplusplus +} +#endif + +#endif // CEF_INCLUDE_CAPI_CEF_URL_CAPI_H_ diff --git a/cef/include/capi/cef_v8_capi.h b/cef/include/capi/cef_v8_capi.h new file mode 100644 index 000000000..f0113dbf9 --- /dev/null +++ b/cef/include/capi/cef_v8_capi.h @@ -0,0 +1,615 @@ +// Copyright (c) 2012 Marshall A. Greenblatt. All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the name Chromium Embedded +// Framework nor the names of its contributors may be used to endorse +// or promote products derived from this software without specific prior +// written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +// --------------------------------------------------------------------------- +// +// This file was generated by the CEF translator tool and should not edited +// by hand. See the translator.README.txt file in the tools directory for +// more information. +// + +#ifndef CEF_INCLUDE_CAPI_CEF_V8_CAPI_H_ +#define CEF_INCLUDE_CAPI_CEF_V8_CAPI_H_ +#pragma once + +#ifdef __cplusplus +extern "C" { +#endif + +#include "include/capi/cef_base_capi.h" + + +/// +// Register a new V8 extension with the specified JavaScript extension code and +// handler. Functions implemented by the handler are prototyped using the +// keyword 'native'. The calling of a native function is restricted to the scope +// in which the prototype of the native function is defined. This function may +// be called on any thread. +// +// Example JavaScript extension code: 
+//   // create the 'example' global object if it doesn't already exist.
+//   if (!example)
+//     example = {};
+//   // create the 'example.test' global object if it doesn't already exist.
+//   if (!example.test)
+//     example.test = {};
+//   (function() {
+//     // Define the function 'example.test.myfunction'.
+//     example.test.myfunction = function() {
+//       // Call CefV8Handler::Execute() with the function name 'MyFunction'
+//       // and no arguments.
+//       native function MyFunction();
+//       return MyFunction();
+//     };
+//     // Define the getter function for parameter 'example.test.myparam'.
+//     example.test.__defineGetter__('myparam', function() {
+//       // Call CefV8Handler::Execute() with the function name 'GetMyParam'
+//       // and no arguments.
+//       native function GetMyParam();
+//       return GetMyParam();
+//     });
+//     // Define the setter function for parameter 'example.test.myparam'.
+//     example.test.__defineSetter__('myparam', function(b) {
+//       // Call CefV8Handler::Execute() with the function name 'SetMyParam'
+//       // and a single argument.
+//       native function SetMyParam();
+//       if(b) SetMyParam(b);
+//     });
+//
+//     // Extension definitions can also contain normal JavaScript variables
+//     // and functions.
+//     var myint = 0;
+//     example.test.increment = function() {
+//       myint += 1;
+//       return myint;
+//     };
+//   })();
+//
Example usage in the page: 
+//   // Call the function.
+//   example.test.myfunction();
+//   // Set the parameter.
+//   example.test.myparam = value;
+//   // Get the parameter.
+//   value = example.test.myparam;
+//   // Call another function.
+//   example.test.increment();
+//
+/// +CEF_EXPORT int cef_register_extension(const cef_string_t* extension_name, + const cef_string_t* javascript_code, struct _cef_v8handler_t* handler); + +/// +// Structure that encapsulates a V8 context handle. +/// +typedef struct _cef_v8context_t { + /// + // Base structure. + /// + cef_base_t base; + + /// + // Returns the browser for this context. + /// + struct _cef_browser_t* (CEF_CALLBACK *get_browser)( + struct _cef_v8context_t* self); + + /// + // Returns the frame for this context. + /// + struct _cef_frame_t* (CEF_CALLBACK *get_frame)(struct _cef_v8context_t* self); + + /// + // Returns the global object for this context. + /// + struct _cef_v8value_t* (CEF_CALLBACK *get_global)( + struct _cef_v8context_t* self); + + /// + // Enter this context. A context must be explicitly entered before creating a + // V8 Object, Array or Function asynchronously. exit() must be called the same + // number of times as enter() before releasing this context. V8 objects belong + // to the context in which they are created. Returns true (1) if the scope was + // entered successfully. + /// + int (CEF_CALLBACK *enter)(struct _cef_v8context_t* self); + + /// + // Exit this context. Call this function only after calling enter(). Returns + // true (1) if the scope was exited successfully. + /// + int (CEF_CALLBACK *exit)(struct _cef_v8context_t* self); + + /// + // Returns true (1) if this object is pointing to the same handle as |that| + // object. + /// + int (CEF_CALLBACK *is_same)(struct _cef_v8context_t* self, + struct _cef_v8context_t* that); +} cef_v8context_t; + + +/// +// Returns the current (top) context object in the V8 context stack. +/// +CEF_EXPORT cef_v8context_t* cef_v8context_get_current_context(); + +/// +// Returns the entered (bottom) context object in the V8 context stack. +/// +CEF_EXPORT cef_v8context_t* cef_v8context_get_entered_context(); + +/// +// Returns true (1) if V8 is currently inside a context. +/// +CEF_EXPORT int cef_v8context_in_context(); + + +/// +// Structure that should be implemented to handle V8 function calls. The +// functions of this structure will always be called on the UI thread. +/// +typedef struct _cef_v8handler_t { + /// + // Base structure. + /// + cef_base_t base; + + /// + // Handle execution of the function identified by |name|. |object| is the + // receiver ('this' object) of the function. |arguments| is the list of + // arguments passed to the function. If execution succeeds set |retval| to the + // function return value. If execution fails set |exception| to the exception + // that will be thrown. Return true (1) if execution was handled. + /// + int (CEF_CALLBACK *execute)(struct _cef_v8handler_t* self, + const cef_string_t* name, struct _cef_v8value_t* object, + size_t argumentsCount, struct _cef_v8value_t* const* arguments, + struct _cef_v8value_t** retval, cef_string_t* exception); +} cef_v8handler_t; + + +/// +// Structure that should be implemented to handle V8 accessor calls. Accessor +// identifiers are registered by calling cef_v8value_t::set_value_byaccessor(). +// The functions of this structure will always be called on the UI thread. +/// +typedef struct _cef_v8accessor_t { + /// + // Base structure. + /// + cef_base_t base; + + /// + // Handle retrieval the accessor value identified by |name|. |object| is the + // receiver ('this' object) of the accessor. If retrieval succeeds set + // |retval| to the return value. If retrieval fails set |exception| to the + // exception that will be thrown. Return true (1) if accessor retrieval was + // handled. + /// + int (CEF_CALLBACK *get)(struct _cef_v8accessor_t* self, + const cef_string_t* name, struct _cef_v8value_t* object, + struct _cef_v8value_t** retval, cef_string_t* exception); + + /// + // Handle assignment of the accessor value identified by |name|. |object| is + // the receiver ('this' object) of the accessor. |value| is the new value + // being assigned to the accessor. If assignment fails set |exception| to the + // exception that will be thrown. Return true (1) if accessor assignment was + // handled. + /// + int (CEF_CALLBACK *set)(struct _cef_v8accessor_t* self, + const cef_string_t* name, struct _cef_v8value_t* object, + struct _cef_v8value_t* value, cef_string_t* exception); +} cef_v8accessor_t; + + +/// +// Structure representing a V8 exception. +/// +typedef struct _cef_v8exception_t { + /// + // Base structure. + /// + cef_base_t base; + + /// + // Returns the exception message. + /// + // The resulting string must be freed by calling cef_string_userfree_free(). + cef_string_userfree_t (CEF_CALLBACK *get_message)( + struct _cef_v8exception_t* self); + + /// + // Returns the line of source code that the exception occurred within. + /// + // The resulting string must be freed by calling cef_string_userfree_free(). + cef_string_userfree_t (CEF_CALLBACK *get_source_line)( + struct _cef_v8exception_t* self); + + /// + // Returns the resource name for the script from where the function causing + // the error originates. + /// + // The resulting string must be freed by calling cef_string_userfree_free(). + cef_string_userfree_t (CEF_CALLBACK *get_script_resource_name)( + struct _cef_v8exception_t* self); + + /// + // Returns the 1-based number of the line where the error occurred or 0 if the + // line number is unknown. + /// + int (CEF_CALLBACK *get_line_number)(struct _cef_v8exception_t* self); + + /// + // Returns the index within the script of the first character where the error + // occurred. + /// + int (CEF_CALLBACK *get_start_position)(struct _cef_v8exception_t* self); + + /// + // Returns the index within the script of the last character where the error + // occurred. + /// + int (CEF_CALLBACK *get_end_position)(struct _cef_v8exception_t* self); + + /// + // Returns the index within the line of the first character where the error + // occurred. + /// + int (CEF_CALLBACK *get_start_column)(struct _cef_v8exception_t* self); + + /// + // Returns the index within the line of the last character where the error + // occurred. + /// + int (CEF_CALLBACK *get_end_column)(struct _cef_v8exception_t* self); +} cef_v8exception_t; + + +/// +// Structure representing a V8 value. The functions of this structure should +// only be called on the UI thread. +/// +typedef struct _cef_v8value_t { + /// + // Base structure. + /// + cef_base_t base; + + /// + // True if the value type is undefined. + /// + int (CEF_CALLBACK *is_undefined)(struct _cef_v8value_t* self); + + /// + // True if the value type is null. + /// + int (CEF_CALLBACK *is_null)(struct _cef_v8value_t* self); + + /// + // True if the value type is bool. + /// + int (CEF_CALLBACK *is_bool)(struct _cef_v8value_t* self); + + /// + // True if the value type is int. + /// + int (CEF_CALLBACK *is_int)(struct _cef_v8value_t* self); + + /// + // True if the value type is double. + /// + int (CEF_CALLBACK *is_double)(struct _cef_v8value_t* self); + + /// + // True if the value type is Date. + /// + int (CEF_CALLBACK *is_date)(struct _cef_v8value_t* self); + + /// + // True if the value type is string. + /// + int (CEF_CALLBACK *is_string)(struct _cef_v8value_t* self); + + /// + // True if the value type is object. + /// + int (CEF_CALLBACK *is_object)(struct _cef_v8value_t* self); + + /// + // True if the value type is array. + /// + int (CEF_CALLBACK *is_array)(struct _cef_v8value_t* self); + + /// + // True if the value type is function. + /// + int (CEF_CALLBACK *is_function)(struct _cef_v8value_t* self); + + /// + // Returns true (1) if this object is pointing to the same handle as |that| + // object. + /// + int (CEF_CALLBACK *is_same)(struct _cef_v8value_t* self, + struct _cef_v8value_t* that); + + /// + // Return a bool value. The underlying data will be converted to if + // necessary. + /// + int (CEF_CALLBACK *get_bool_value)(struct _cef_v8value_t* self); + + /// + // Return an int value. The underlying data will be converted to if + // necessary. + /// + int (CEF_CALLBACK *get_int_value)(struct _cef_v8value_t* self); + + /// + // Return a double value. The underlying data will be converted to if + // necessary. + /// + double (CEF_CALLBACK *get_double_value)(struct _cef_v8value_t* self); + + /// + // Return a Date value. The underlying data will be converted to if + // necessary. + /// + cef_time_t (CEF_CALLBACK *get_date_value)(struct _cef_v8value_t* self); + + /// + // Return a string value. The underlying data will be converted to if + // necessary. + /// + // The resulting string must be freed by calling cef_string_userfree_free(). + cef_string_userfree_t (CEF_CALLBACK *get_string_value)( + struct _cef_v8value_t* self); + + + // OBJECT METHODS - These functions are only available on objects. Arrays and + // functions are also objects. String- and integer-based keys can be used + // interchangably with the framework converting between them as necessary. + + /// + // Returns true (1) if the object has a value with the specified identifier. + /// + int (CEF_CALLBACK *has_value_bykey)(struct _cef_v8value_t* self, + const cef_string_t* key); + + /// + // Returns true (1) if the object has a value with the specified identifier. + /// + int (CEF_CALLBACK *has_value_byindex)(struct _cef_v8value_t* self, int index); + + /// + // Delete the value with the specified identifier. + /// + int (CEF_CALLBACK *delete_value_bykey)(struct _cef_v8value_t* self, + const cef_string_t* key); + + /// + // Delete the value with the specified identifier. + /// + int (CEF_CALLBACK *delete_value_byindex)(struct _cef_v8value_t* self, + int index); + + /// + // Returns the value with the specified identifier. + /// + struct _cef_v8value_t* (CEF_CALLBACK *get_value_bykey)( + struct _cef_v8value_t* self, const cef_string_t* key); + + /// + // Returns the value with the specified identifier. + /// + struct _cef_v8value_t* (CEF_CALLBACK *get_value_byindex)( + struct _cef_v8value_t* self, int index); + + /// + // Associate a value with the specified identifier. + /// + int (CEF_CALLBACK *set_value_bykey)(struct _cef_v8value_t* self, + const cef_string_t* key, struct _cef_v8value_t* value, + enum cef_v8_propertyattribute_t attribute); + + /// + // Associate a value with the specified identifier. + /// + int (CEF_CALLBACK *set_value_byindex)(struct _cef_v8value_t* self, int index, + struct _cef_v8value_t* value); + + /// + // Register an identifier whose access will be forwarded to the + // cef_v8accessor_t instance passed to + // cef_v8value_t::cef_v8value_create_object_with_accessor(). + /// + int (CEF_CALLBACK *set_value_byaccessor)(struct _cef_v8value_t* self, + const cef_string_t* key, enum cef_v8_accesscontrol_t settings, + enum cef_v8_propertyattribute_t attribute); + + /// + // Read the keys for the object's values into the specified vector. Integer- + // based keys will also be returned as strings. + /// + int (CEF_CALLBACK *get_keys)(struct _cef_v8value_t* self, + cef_string_list_t keys); + + /// + // Returns the user data, if any, specified when the object was created. + /// + struct _cef_base_t* (CEF_CALLBACK *get_user_data)( + struct _cef_v8value_t* self); + + /// + // Returns the amount of externally allocated memory registered for the + // object. + /// + int (CEF_CALLBACK *get_externally_allocated_memory)( + struct _cef_v8value_t* self); + + /// + // Adjusts the amount of registered external memory for the object. Used to + // give V8 an indication of the amount of externally allocated memory that is + // kept alive by JavaScript objects. V8 uses this information to decide when + // to perform global garbage collection. Each cef_v8value_t tracks the amount + // of external memory associated with it and automatically decreases the + // global total by the appropriate amount on its destruction. + // |change_in_bytes| specifies the number of bytes to adjust by. This function + // returns the number of bytes associated with the object after the + // adjustment. + /// + int (CEF_CALLBACK *adjust_externally_allocated_memory)( + struct _cef_v8value_t* self, int change_in_bytes); + + + // ARRAY METHODS - These functions are only available on arrays. + + /// + // Returns the number of elements in the array. + /// + int (CEF_CALLBACK *get_array_length)(struct _cef_v8value_t* self); + + + // FUNCTION METHODS - These functions are only available on functions. + + /// + // Returns the function name. + /// + // The resulting string must be freed by calling cef_string_userfree_free(). + cef_string_userfree_t (CEF_CALLBACK *get_function_name)( + struct _cef_v8value_t* self); + + /// + // Returns the function handler or NULL if not a CEF-created function. + /// + struct _cef_v8handler_t* (CEF_CALLBACK *get_function_handler)( + struct _cef_v8value_t* self); + + /// + // Execute the function using the current V8 context. This function should + // only be called from within the scope of a cef_v8handler_t or + // cef_v8accessor_t callback, or in combination with calling enter() and + // exit() on a stored cef_v8context_t reference. |object| is the receiver + // ('this' object) of the function. |arguments| is the list of arguments that + // will be passed to the function. If execution succeeds |retval| will be set + // to the function return value. If execution fails |exception| will be set to + // the exception that was thrown. If |rethrow_exception| is true (1) any + // exception will also be re- thrown. This function returns false (0) if + // called incorrectly. + /// + int (CEF_CALLBACK *execute_function)(struct _cef_v8value_t* self, + struct _cef_v8value_t* object, size_t argumentsCount, + struct _cef_v8value_t* const* arguments, struct _cef_v8value_t** retval, + struct _cef_v8exception_t** exception, int rethrow_exception); + + /// + // Execute the function using the specified V8 context. |object| is the + // receiver ('this' object) of the function. |arguments| is the list of + // arguments that will be passed to the function. If execution succeeds + // |retval| will be set to the function return value. If execution fails + // |exception| will be set to the exception that was thrown. If + // |rethrow_exception| is true (1) any exception will also be re-thrown. This + // function returns false (0) if called incorrectly. + /// + int (CEF_CALLBACK *execute_function_with_context)(struct _cef_v8value_t* self, + struct _cef_v8context_t* context, struct _cef_v8value_t* object, + size_t argumentsCount, struct _cef_v8value_t* const* arguments, + struct _cef_v8value_t** retval, struct _cef_v8exception_t** exception, + int rethrow_exception); +} cef_v8value_t; + + +/// +// Create a new cef_v8value_t object of type undefined. +/// +CEF_EXPORT cef_v8value_t* cef_v8value_create_undefined(); + +/// +// Create a new cef_v8value_t object of type null. +/// +CEF_EXPORT cef_v8value_t* cef_v8value_create_null(); + +/// +// Create a new cef_v8value_t object of type bool. +/// +CEF_EXPORT cef_v8value_t* cef_v8value_create_bool(int value); + +/// +// Create a new cef_v8value_t object of type int. +/// +CEF_EXPORT cef_v8value_t* cef_v8value_create_int(int value); + +/// +// Create a new cef_v8value_t object of type double. +/// +CEF_EXPORT cef_v8value_t* cef_v8value_create_double(double value); + +/// +// Create a new cef_v8value_t object of type Date. +/// +CEF_EXPORT cef_v8value_t* cef_v8value_create_date(const cef_time_t* date); + +/// +// Create a new cef_v8value_t object of type string. +/// +CEF_EXPORT cef_v8value_t* cef_v8value_create_string(const cef_string_t* value); + +/// +// Create a new cef_v8value_t object of type object with optional user data and +// accessor. This function should only be called from within the scope of a +// cef_v8context_tHandler, cef_v8handler_t or cef_v8accessor_t callback, or in +// combination with calling enter() and exit() on a stored cef_v8context_t +// reference. +/// +CEF_EXPORT cef_v8value_t* cef_v8value_create_object_with_accessor( + cef_base_t* user_data, cef_v8accessor_t* accessor); + +/// +// Create a new cef_v8value_t object of type array. This function should only be +// called from within the scope of a cef_v8context_tHandler, cef_v8handler_t or +// cef_v8accessor_t callback, or in combination with calling enter() and exit() +// on a stored cef_v8context_t reference. +/// +CEF_EXPORT cef_v8value_t* cef_v8value_create_array(); + +/// +// Create a new cef_v8value_t object of type function. This function should only +// be called from within the scope of a cef_v8context_tHandler, cef_v8handler_t +// or cef_v8accessor_t callback, or in combination with calling enter() and +// exit() on a stored cef_v8context_t reference. +/// +CEF_EXPORT cef_v8value_t* cef_v8value_create_function(const cef_string_t* name, + cef_v8handler_t* handler); + + +#ifdef __cplusplus +} +#endif + +#endif // CEF_INCLUDE_CAPI_CEF_V8_CAPI_H_ diff --git a/cef/include/capi/cef_v8context_handler_capi.h b/cef/include/capi/cef_v8context_handler_capi.h new file mode 100644 index 000000000..fa00e419b --- /dev/null +++ b/cef/include/capi/cef_v8context_handler_capi.h @@ -0,0 +1,81 @@ +// Copyright (c) 2012 Marshall A. Greenblatt. All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the name Chromium Embedded +// Framework nor the names of its contributors may be used to endorse +// or promote products derived from this software without specific prior +// written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +// --------------------------------------------------------------------------- +// +// This file was generated by the CEF translator tool and should not edited +// by hand. See the translator.README.txt file in the tools directory for +// more information. +// + +#ifndef CEF_INCLUDE_CAPI_CEF_V8CONTEXT_HANDLER_CAPI_H_ +#define CEF_INCLUDE_CAPI_CEF_V8CONTEXT_HANDLER_CAPI_H_ +#pragma once + +#ifdef __cplusplus +extern "C" { +#endif + +#include "include/capi/cef_base_capi.h" + + +/// +// Implement this structure to handle V8 context events. The functions of this +// structure will be called on the UI thread. +/// +typedef struct _cef_v8context_handler_t { + /// + // Base structure. + /// + cef_base_t base; + + /// + // Called immediately after the V8 context for a frame has been created. To + // retrieve the JavaScript 'window' object use the + // cef_v8context_t::get_global() function. + /// + void (CEF_CALLBACK *on_context_created)(struct _cef_v8context_handler_t* self, + struct _cef_browser_t* browser, struct _cef_frame_t* frame, + struct _cef_v8context_t* context); + + /// + // Called immediately before the V8 context for a frame is released. No + // references to the context should be kept after this function is called. + /// + void (CEF_CALLBACK *on_context_released)( + struct _cef_v8context_handler_t* self, struct _cef_browser_t* browser, + struct _cef_frame_t* frame, struct _cef_v8context_t* context); +} cef_v8context_handler_t; + + +#ifdef __cplusplus +} +#endif + +#endif // CEF_INCLUDE_CAPI_CEF_V8CONTEXT_HANDLER_CAPI_H_ diff --git a/cef/include/capi/cef_web_plugin_capi.h b/cef/include/capi/cef_web_plugin_capi.h new file mode 100644 index 000000000..d5aab64bd --- /dev/null +++ b/cef/include/capi/cef_web_plugin_capi.h @@ -0,0 +1,110 @@ +// Copyright (c) 2012 Marshall A. Greenblatt. All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the name Chromium Embedded +// Framework nor the names of its contributors may be used to endorse +// or promote products derived from this software without specific prior +// written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +// --------------------------------------------------------------------------- +// +// This file was generated by the CEF translator tool and should not edited +// by hand. See the translator.README.txt file in the tools directory for +// more information. +// + +#ifndef CEF_INCLUDE_CAPI_CEF_WEB_PLUGIN_CAPI_H_ +#define CEF_INCLUDE_CAPI_CEF_WEB_PLUGIN_CAPI_H_ +#pragma once + +#ifdef __cplusplus +extern "C" { +#endif + +#include "include/capi/cef_base_capi.h" + + +/// +// Returns the number of installed web plugins. This function must be called on +// the UI thread. +/// +CEF_EXPORT size_t cef_get_web_plugin_count(); + +/// +// Returns information for web plugin at the specified zero-based index. This +// function must be called on the UI thread. +/// +CEF_EXPORT struct _cef_web_plugin_info_t* cef_get_web_plugin_info(int index); + +/// +// Returns information for web plugin with the specified name. This function +// must be called on the UI thread. +/// +CEF_EXPORT struct _cef_web_plugin_info_t* cef_get_web_plugin_info_byname( + const cef_string_t* name); + +/// +// Information about a specific web plugin. +/// +typedef struct _cef_web_plugin_info_t { + /// + // Base structure. + /// + cef_base_t base; + + /// + // Returns the plugin name (i.e. Flash). + /// + // The resulting string must be freed by calling cef_string_userfree_free(). + cef_string_userfree_t (CEF_CALLBACK *get_name)( + struct _cef_web_plugin_info_t* self); + + /// + // Returns the plugin file path (DLL/bundle/library). + /// + // The resulting string must be freed by calling cef_string_userfree_free(). + cef_string_userfree_t (CEF_CALLBACK *get_path)( + struct _cef_web_plugin_info_t* self); + + /// + // Returns the version of the plugin (may be OS-specific). + /// + // The resulting string must be freed by calling cef_string_userfree_free(). + cef_string_userfree_t (CEF_CALLBACK *get_version)( + struct _cef_web_plugin_info_t* self); + + /// + // Returns a description of the plugin from the version information. + /// + // The resulting string must be freed by calling cef_string_userfree_free(). + cef_string_userfree_t (CEF_CALLBACK *get_description)( + struct _cef_web_plugin_info_t* self); +} cef_web_plugin_info_t; + + +#ifdef __cplusplus +} +#endif + +#endif // CEF_INCLUDE_CAPI_CEF_WEB_PLUGIN_CAPI_H_ diff --git a/cef/include/capi/cef_web_urlrequest_capi.h b/cef/include/capi/cef_web_urlrequest_capi.h new file mode 100644 index 000000000..3e2cbb12d --- /dev/null +++ b/cef/include/capi/cef_web_urlrequest_capi.h @@ -0,0 +1,143 @@ +// Copyright (c) 2012 Marshall A. Greenblatt. All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the name Chromium Embedded +// Framework nor the names of its contributors may be used to endorse +// or promote products derived from this software without specific prior +// written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +// --------------------------------------------------------------------------- +// +// This file was generated by the CEF translator tool and should not edited +// by hand. See the translator.README.txt file in the tools directory for +// more information. +// + +#ifndef CEF_INCLUDE_CAPI_CEF_WEB_URLREQUEST_CAPI_H_ +#define CEF_INCLUDE_CAPI_CEF_WEB_URLREQUEST_CAPI_H_ +#pragma once + +#ifdef __cplusplus +extern "C" { +#endif + +#include "include/capi/cef_base_capi.h" + + +/// +// Structure used to make a Web URL request. Web URL requests are not associated +// with a browser instance so no cef_client_t callbacks will be executed. The +// functions of this structure may be called on any thread. +/// +typedef struct _cef_web_urlrequest_t { + /// + // Base structure. + /// + cef_base_t base; + + /// + // Cancels the request. + /// + void (CEF_CALLBACK *cancel)(struct _cef_web_urlrequest_t* self); + + /// + // Returns the current ready state of the request. + /// + enum cef_weburlrequest_state_t (CEF_CALLBACK *get_state)( + struct _cef_web_urlrequest_t* self); +} cef_web_urlrequest_t; + + +/// +// Create a new CefWebUrlRequest object. +/// +CEF_EXPORT cef_web_urlrequest_t* cef_web_urlrequest_create( + struct _cef_request_t* request, + struct _cef_web_urlrequest_client_t* client); + + +/// +// Structure that should be implemented by the cef_web_urlrequest_t client. The +// functions of this structure will always be called on the UI thread. +/// +typedef struct _cef_web_urlrequest_client_t { + /// + // Base structure. + /// + cef_base_t base; + + /// + // Notifies the client that the request state has changed. State change + // notifications will always be sent before the below notification functions + // are called. + /// + void (CEF_CALLBACK *on_state_change)( + struct _cef_web_urlrequest_client_t* self, + struct _cef_web_urlrequest_t* requester, + enum cef_weburlrequest_state_t state); + + /// + // Notifies the client that the request has been redirected and provides a + // chance to change the request parameters. + /// + void (CEF_CALLBACK *on_redirect)(struct _cef_web_urlrequest_client_t* self, + struct _cef_web_urlrequest_t* requester, struct _cef_request_t* request, + struct _cef_response_t* response); + + /// + // Notifies the client of the response data. + /// + void (CEF_CALLBACK *on_headers_received)( + struct _cef_web_urlrequest_client_t* self, + struct _cef_web_urlrequest_t* requester, + struct _cef_response_t* response); + + /// + // Notifies the client of the upload progress. + /// + void (CEF_CALLBACK *on_progress)(struct _cef_web_urlrequest_client_t* self, + struct _cef_web_urlrequest_t* requester, uint64 bytesSent, + uint64 totalBytesToBeSent); + + /// + // Notifies the client that content has been received. + /// + void (CEF_CALLBACK *on_data)(struct _cef_web_urlrequest_client_t* self, + struct _cef_web_urlrequest_t* requester, const void* data, + int dataLength); + + /// + // Notifies the client that the request ended with an error. + /// + void (CEF_CALLBACK *on_error)(struct _cef_web_urlrequest_client_t* self, + struct _cef_web_urlrequest_t* requester, + enum cef_handler_errorcode_t errorCode); +} cef_web_urlrequest_client_t; + + +#ifdef __cplusplus +} +#endif + +#endif // CEF_INCLUDE_CAPI_CEF_WEB_URLREQUEST_CAPI_H_ diff --git a/cef/include/capi/cef_xml_reader_capi.h b/cef/include/capi/cef_xml_reader_capi.h new file mode 100644 index 000000000..c8585a53e --- /dev/null +++ b/cef/include/capi/cef_xml_reader_capi.h @@ -0,0 +1,278 @@ +// Copyright (c) 2012 Marshall A. Greenblatt. All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the name Chromium Embedded +// Framework nor the names of its contributors may be used to endorse +// or promote products derived from this software without specific prior +// written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +// --------------------------------------------------------------------------- +// +// This file was generated by the CEF translator tool and should not edited +// by hand. See the translator.README.txt file in the tools directory for +// more information. +// + +#ifndef CEF_INCLUDE_CAPI_CEF_XML_READER_CAPI_H_ +#define CEF_INCLUDE_CAPI_CEF_XML_READER_CAPI_H_ +#pragma once + +#ifdef __cplusplus +extern "C" { +#endif + +#include "include/capi/cef_base_capi.h" + + +/// +// Structure that supports the reading of XML data via the libxml streaming API. +// The functions of this structure should only be called on the thread that +// creates the object. +/// +typedef struct _cef_xml_reader_t { + /// + // Base structure. + /// + cef_base_t base; + + /// + // Moves the cursor to the next node in the document. This function must be + // called at least once to set the current cursor position. Returns true (1) + // if the cursor position was set successfully. + /// + int (CEF_CALLBACK *move_to_next_node)(struct _cef_xml_reader_t* self); + + /// + // Close the document. This should be called directly to ensure that cleanup + // occurs on the correct thread. + /// + int (CEF_CALLBACK *close)(struct _cef_xml_reader_t* self); + + /// + // Returns true (1) if an error has been reported by the XML parser. + /// + int (CEF_CALLBACK *has_error)(struct _cef_xml_reader_t* self); + + /// + // Returns the error string. + /// + // The resulting string must be freed by calling cef_string_userfree_free(). + cef_string_userfree_t (CEF_CALLBACK *get_error)( + struct _cef_xml_reader_t* self); + + + // The below functions retrieve data for the node at the current cursor + // position. + + /// + // Returns the node type. + /// + enum cef_xml_node_type_t (CEF_CALLBACK *get_type)( + struct _cef_xml_reader_t* self); + + /// + // Returns the node depth. Depth starts at 0 for the root node. + /// + int (CEF_CALLBACK *get_depth)(struct _cef_xml_reader_t* self); + + /// + // Returns the local name. See http://www.w3.org/TR/REC-xml-names/#NT- + // LocalPart for additional details. + /// + // The resulting string must be freed by calling cef_string_userfree_free(). + cef_string_userfree_t (CEF_CALLBACK *get_local_name)( + struct _cef_xml_reader_t* self); + + /// + // Returns the namespace prefix. See http://www.w3.org/TR/REC-xml-names/ for + // additional details. + /// + // The resulting string must be freed by calling cef_string_userfree_free(). + cef_string_userfree_t (CEF_CALLBACK *get_prefix)( + struct _cef_xml_reader_t* self); + + /// + // Returns the qualified name, equal to (Prefix:)LocalName. See + // http://www.w3.org/TR/REC-xml-names/#ns-qualnames for additional details. + /// + // The resulting string must be freed by calling cef_string_userfree_free(). + cef_string_userfree_t (CEF_CALLBACK *get_qualified_name)( + struct _cef_xml_reader_t* self); + + /// + // Returns the URI defining the namespace associated with the node. See + // http://www.w3.org/TR/REC-xml-names/ for additional details. + /// + // The resulting string must be freed by calling cef_string_userfree_free(). + cef_string_userfree_t (CEF_CALLBACK *get_namespace_uri)( + struct _cef_xml_reader_t* self); + + /// + // Returns the base URI of the node. See http://www.w3.org/TR/xmlbase/ for + // additional details. + /// + // The resulting string must be freed by calling cef_string_userfree_free(). + cef_string_userfree_t (CEF_CALLBACK *get_base_uri)( + struct _cef_xml_reader_t* self); + + /// + // Returns the xml:lang scope within which the node resides. See + // http://www.w3.org/TR/REC-xml/#sec-lang-tag for additional details. + /// + // The resulting string must be freed by calling cef_string_userfree_free(). + cef_string_userfree_t (CEF_CALLBACK *get_xml_lang)( + struct _cef_xml_reader_t* self); + + /// + // Returns true (1) if the node represents an NULL element. is considered + // NULL but is not. + /// + int (CEF_CALLBACK *is_empty_element)(struct _cef_xml_reader_t* self); + + /// + // Returns true (1) if the node has a text value. + /// + int (CEF_CALLBACK *has_value)(struct _cef_xml_reader_t* self); + + /// + // Returns the text value. + /// + // The resulting string must be freed by calling cef_string_userfree_free(). + cef_string_userfree_t (CEF_CALLBACK *get_value)( + struct _cef_xml_reader_t* self); + + /// + // Returns true (1) if the node has attributes. + /// + int (CEF_CALLBACK *has_attributes)(struct _cef_xml_reader_t* self); + + /// + // Returns the number of attributes. + /// + size_t (CEF_CALLBACK *get_attribute_count)(struct _cef_xml_reader_t* self); + + /// + // Returns the value of the attribute at the specified 0-based index. + /// + // The resulting string must be freed by calling cef_string_userfree_free(). + cef_string_userfree_t (CEF_CALLBACK *get_attribute_byindex)( + struct _cef_xml_reader_t* self, int index); + + /// + // Returns the value of the attribute with the specified qualified name. + /// + // The resulting string must be freed by calling cef_string_userfree_free(). + cef_string_userfree_t (CEF_CALLBACK *get_attribute_byqname)( + struct _cef_xml_reader_t* self, const cef_string_t* qualifiedName); + + /// + // Returns the value of the attribute with the specified local name and + // namespace URI. + /// + // The resulting string must be freed by calling cef_string_userfree_free(). + cef_string_userfree_t (CEF_CALLBACK *get_attribute_bylname)( + struct _cef_xml_reader_t* self, const cef_string_t* localName, + const cef_string_t* namespaceURI); + + /// + // Returns an XML representation of the current node's children. + /// + // The resulting string must be freed by calling cef_string_userfree_free(). + cef_string_userfree_t (CEF_CALLBACK *get_inner_xml)( + struct _cef_xml_reader_t* self); + + /// + // Returns an XML representation of the current node including its children. + /// + // The resulting string must be freed by calling cef_string_userfree_free(). + cef_string_userfree_t (CEF_CALLBACK *get_outer_xml)( + struct _cef_xml_reader_t* self); + + /// + // Returns the line number for the current node. + /// + int (CEF_CALLBACK *get_line_number)(struct _cef_xml_reader_t* self); + + + // Attribute nodes are not traversed by default. The below functions can be + // used to move the cursor to an attribute node. move_to_carrying_element() + // can be called afterwards to return the cursor to the carrying element. The + // depth of an attribute node will be 1 + the depth of the carrying element. + + /// + // Moves the cursor to the attribute at the specified 0-based index. Returns + // true (1) if the cursor position was set successfully. + /// + int (CEF_CALLBACK *move_to_attribute_byindex)(struct _cef_xml_reader_t* self, + int index); + + /// + // Moves the cursor to the attribute with the specified qualified name. + // Returns true (1) if the cursor position was set successfully. + /// + int (CEF_CALLBACK *move_to_attribute_byqname)(struct _cef_xml_reader_t* self, + const cef_string_t* qualifiedName); + + /// + // Moves the cursor to the attribute with the specified local name and + // namespace URI. Returns true (1) if the cursor position was set + // successfully. + /// + int (CEF_CALLBACK *move_to_attribute_bylname)(struct _cef_xml_reader_t* self, + const cef_string_t* localName, const cef_string_t* namespaceURI); + + /// + // Moves the cursor to the first attribute in the current element. Returns + // true (1) if the cursor position was set successfully. + /// + int (CEF_CALLBACK *move_to_first_attribute)(struct _cef_xml_reader_t* self); + + /// + // Moves the cursor to the next attribute in the current element. Returns true + // (1) if the cursor position was set successfully. + /// + int (CEF_CALLBACK *move_to_next_attribute)(struct _cef_xml_reader_t* self); + + /// + // Moves the cursor back to the carrying element. Returns true (1) if the + // cursor position was set successfully. + /// + int (CEF_CALLBACK *move_to_carrying_element)(struct _cef_xml_reader_t* self); +} cef_xml_reader_t; + + +/// +// Create a new cef_xml_reader_t object. The returned object's functions can +// only be called from the thread that created the object. +/// +CEF_EXPORT cef_xml_reader_t* cef_xml_reader_create( + struct _cef_stream_reader_t* stream, + enum cef_xml_encoding_type_t encodingType, const cef_string_t* URI); + + +#ifdef __cplusplus +} +#endif + +#endif // CEF_INCLUDE_CAPI_CEF_XML_READER_CAPI_H_ diff --git a/cef/include/capi/cef_zip_reader_capi.h b/cef/include/capi/cef_zip_reader_capi.h new file mode 100644 index 000000000..d7988afcb --- /dev/null +++ b/cef/include/capi/cef_zip_reader_capi.h @@ -0,0 +1,148 @@ +// Copyright (c) 2012 Marshall A. Greenblatt. All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the name Chromium Embedded +// Framework nor the names of its contributors may be used to endorse +// or promote products derived from this software without specific prior +// written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +// --------------------------------------------------------------------------- +// +// This file was generated by the CEF translator tool and should not edited +// by hand. See the translator.README.txt file in the tools directory for +// more information. +// + +#ifndef CEF_INCLUDE_CAPI_CEF_ZIP_READER_CAPI_H_ +#define CEF_INCLUDE_CAPI_CEF_ZIP_READER_CAPI_H_ +#pragma once + +#ifdef __cplusplus +extern "C" { +#endif + +#include "include/capi/cef_base_capi.h" + + +/// +// Structure that supports the reading of zip archives via the zlib unzip API. +// The functions of this structure should only be called on the thread that +// creates the object. +/// +typedef struct _cef_zip_reader_t { + /// + // Base structure. + /// + cef_base_t base; + + /// + // Moves the cursor to the first file in the archive. Returns true (1) if the + // cursor position was set successfully. + /// + int (CEF_CALLBACK *move_to_first_file)(struct _cef_zip_reader_t* self); + + /// + // Moves the cursor to the next file in the archive. Returns true (1) if the + // cursor position was set successfully. + /// + int (CEF_CALLBACK *move_to_next_file)(struct _cef_zip_reader_t* self); + + /// + // Moves the cursor to the specified file in the archive. If |caseSensitive| + // is true (1) then the search will be case sensitive. Returns true (1) if the + // cursor position was set successfully. + /// + int (CEF_CALLBACK *move_to_file)(struct _cef_zip_reader_t* self, + const cef_string_t* fileName, int caseSensitive); + + /// + // Closes the archive. This should be called directly to ensure that cleanup + // occurs on the correct thread. + /// + int (CEF_CALLBACK *close)(struct _cef_zip_reader_t* self); + + + // The below functions act on the file at the current cursor position. + + /// + // Returns the name of the file. + /// + // The resulting string must be freed by calling cef_string_userfree_free(). + cef_string_userfree_t (CEF_CALLBACK *get_file_name)( + struct _cef_zip_reader_t* self); + + /// + // Returns the uncompressed size of the file. + /// + int64 (CEF_CALLBACK *get_file_size)(struct _cef_zip_reader_t* self); + + /// + // Returns the last modified timestamp for the file. + /// + time_t (CEF_CALLBACK *get_file_last_modified)(struct _cef_zip_reader_t* self); + + /// + // Opens the file for reading of uncompressed data. A read password may + // optionally be specified. + /// + int (CEF_CALLBACK *open_file)(struct _cef_zip_reader_t* self, + const cef_string_t* password); + + /// + // Closes the file. + /// + int (CEF_CALLBACK *close_file)(struct _cef_zip_reader_t* self); + + /// + // Read uncompressed file contents into the specified buffer. Returns < 0 if + // an error occurred, 0 if at the end of file, or the number of bytes read. + /// + int (CEF_CALLBACK *read_file)(struct _cef_zip_reader_t* self, void* buffer, + size_t bufferSize); + + /// + // Returns the current offset in the uncompressed file contents. + /// + int64 (CEF_CALLBACK *tell)(struct _cef_zip_reader_t* self); + + /// + // Returns true (1) if at end of the file contents. + /// + int (CEF_CALLBACK *eof)(struct _cef_zip_reader_t* self); +} cef_zip_reader_t; + + +/// +// Create a new cef_zip_reader_t object. The returned object's functions can +// only be called from the thread that created the object. +/// +CEF_EXPORT cef_zip_reader_t* cef_zip_reader_create( + struct _cef_stream_reader_t* stream); + + +#ifdef __cplusplus +} +#endif + +#endif // CEF_INCLUDE_CAPI_CEF_ZIP_READER_CAPI_H_ diff --git a/cef/include/cef_app.h b/cef/include/cef_app.h new file mode 100644 index 000000000..028bd71d1 --- /dev/null +++ b/cef/include/cef_app.h @@ -0,0 +1,123 @@ +// Copyright (c) 2011 Marshall A. Greenblatt. All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the name Chromium Embedded +// Framework nor the names of its contributors may be used to endorse +// or promote products derived from this software without specific prior +// written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +// --------------------------------------------------------------------------- +// +// The contents of this file must follow a specific format in order to +// support the CEF translator tool. See the translator.README.txt file in the +// tools directory for more information. +// + + +#ifndef CEF_INCLUDE_CEF_APP_H_ +#define CEF_INCLUDE_CEF_APP_H_ +#pragma once + +#include "include/cef_base.h" +#include "include/cef_proxy_handler.h" +#include "include/cef_resource_bundle_handler.h" + +class CefApp; + +/// +// This function should be called on the main application thread to initialize +// CEF when the application is started. The |application| parameter may be +// empty. A return value of true indicates that it succeeded and false indicates +// that it failed. +/// +/*--cef(revision_check,optional_param=application)--*/ +bool CefInitialize(const CefSettings& settings, CefRefPtr application); + +/// +// This function should be called on the main application thread to shut down +// CEF before the application exits. +/// +/*--cef()--*/ +void CefShutdown(); + +/// +// Perform a single iteration of CEF message loop processing. This function is +// used to integrate the CEF message loop into an existing application message +// loop. Care must be taken to balance performance against excessive CPU usage. +// This function should only be called on the main application thread and only +// if CefInitialize() is called with a CefSettings.multi_threaded_message_loop +// value of false. This function will not block. +/// +/*--cef()--*/ +void CefDoMessageLoopWork(); + +/// +// Run the CEF message loop. Use this function instead of an application- +// provided message loop to get the best balance between performance and CPU +// usage. This function should only be called on the main application thread and +// only if CefInitialize() is called with a +// CefSettings.multi_threaded_message_loop value of false. This function will +// block until a quit message is received by the system. +/// +/*--cef()--*/ +void CefRunMessageLoop(); + +/// +// Quit the CEF message loop that was started by calling CefRunMessageLoop(). +// This function should only be called on the main application thread and only +// if CefRunMessageLoop() was used. +/// +/*--cef()--*/ +void CefQuitMessageLoop(); + + +/// +// Implement this interface to provide handler implementations. Methods will be +// called on the thread indicated. +/// +/*--cef(source=client,no_debugct_check)--*/ +class CefApp : public virtual CefBase { + public: + /// + // Return the handler for resource bundle events. If + // CefSettings.pack_loading_disabled is true a handler must be returned. If no + // handler is returned resources will be loaded from pack files. This method + // is called on multiple threads. + /// + /*--cef()--*/ + virtual CefRefPtr GetResourceBundleHandler() { + return NULL; + } + + /// + // Return the handler for proxy events. If not handler is returned the default + // system handler will be used. This method is called on the IO thread. + /// + /*--cef()--*/ + virtual CefRefPtr GetProxyHandler() { + return NULL; + } +}; + +#endif // CEF_INCLUDE_CEF_APP_H_ diff --git a/cef/include/cef_base.h b/cef/include/cef_base.h new file mode 100644 index 000000000..5fc964fa3 --- /dev/null +++ b/cef/include/cef_base.h @@ -0,0 +1,154 @@ +// Copyright (c) 2011 Marshall A. Greenblatt. All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the name Chromium Embedded +// Framework nor the names of its contributors may be used to endorse +// or promote products derived from this software without specific prior +// written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +// --------------------------------------------------------------------------- +// +// The contents of this file must follow a specific format in order to +// support the CEF translator tool. See the translator.README.txt file in the +// tools directory for more information. +// + + +#ifndef CEF_INCLUDE_CEF_BASE_H_ +#define CEF_INCLUDE_CEF_BASE_H_ +#pragma once + +#include "include/internal/cef_build.h" +#include "include/internal/cef_ptr.h" +#include "include/internal/cef_types_wrappers.h" + +// Bring in platform-specific definitions. +#if defined(OS_WIN) +#include "include/internal/cef_win.h" +#elif defined(OS_MACOSX) +#include "include/internal/cef_mac.h" +#elif defined(OS_LINUX) +#include "include/internal/cef_linux.h" +#endif + +/// +// Interface defining the reference count implementation methods. All framework +// classes must extend the CefBase class. +/// +class CefBase { + public: + /// + // The AddRef method increments the reference count for the object. It should + // be called for every new copy of a pointer to a given object. The resulting + // reference count value is returned and should be used for diagnostic/testing + // purposes only. + /// + virtual int AddRef() =0; + + /// + // The Release method decrements the reference count for the object. If the + // reference count on the object falls to 0, then the object should free + // itself from memory. The resulting reference count value is returned and + // should be used for diagnostic/testing purposes only. + /// + virtual int Release() =0; + + /// + // Return the current number of references. + /// + virtual int GetRefCt() =0; + + protected: + virtual ~CefBase() {} +}; + + +/// +// Class that implements atomic reference counting. +/// +class CefRefCount { + public: + CefRefCount() : refct_(0) {} + + /// + // Atomic reference increment. + /// + int AddRef() { + return CefAtomicIncrement(&refct_); + } + + /// + // Atomic reference decrement. Delete the object when no references remain. + /// + int Release() { + return CefAtomicDecrement(&refct_); + } + + /// + // Return the current number of references. + /// + int GetRefCt() { return refct_; } + + private: + long refct_; // NOLINT(runtime/int) +}; + +/// +// Macro that provides a reference counting implementation for classes extending +// CefBase. +/// +#define IMPLEMENT_REFCOUNTING(ClassName) \ + public: \ + int AddRef() { return refct_.AddRef(); } \ + int Release() { \ + int retval = refct_.Release(); \ + if (retval == 0) \ + delete this; \ + return retval; \ + } \ + int GetRefCt() { return refct_.GetRefCt(); } \ + private: \ + CefRefCount refct_; + +/// +// Macro that provides a locking implementation. Use the Lock() and Unlock() +// methods to protect a section of code from simultaneous access by multiple +// threads. The AutoLock class is a helper that will hold the lock while in +// scope. +/// +#define IMPLEMENT_LOCKING(ClassName) \ + public: \ + class AutoLock { \ + public: \ + explicit AutoLock(ClassName* base) : base_(base) { base_->Lock(); } \ + ~AutoLock() { base_->Unlock(); } \ + private: \ + ClassName* base_; \ + }; \ + void Lock() { critsec_.Lock(); } \ + void Unlock() { critsec_.Unlock(); } \ + private: \ + CefCriticalSection critsec_; + +#endif // CEF_INCLUDE_CEF_BASE_H_ diff --git a/cef/include/cef_browser.h b/cef/include/cef_browser.h new file mode 100644 index 000000000..540e4b9c6 --- /dev/null +++ b/cef/include/cef_browser.h @@ -0,0 +1,335 @@ +// Copyright (c) 2011 Marshall A. Greenblatt. All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the name Chromium Embedded +// Framework nor the names of its contributors may be used to endorse +// or promote products derived from this software without specific prior +// written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +// --------------------------------------------------------------------------- +// +// The contents of this file must follow a specific format in order to +// support the CEF translator tool. See the translator.README.txt file in the +// tools directory for more information. +// + +#ifndef CEF_INCLUDE_CEF_BROWSER_H_ +#define CEF_INCLUDE_CEF_BROWSER_H_ +#pragma once + +#include "include/cef_base.h" +#include "include/cef_frame.h" +#include + +class CefClient; + +/// +// Class used to represent a browser window. The methods of this class may be +// called on any thread unless otherwise indicated in the comments. +/// +/*--cef(source=library)--*/ +class CefBrowser : public virtual CefBase { + public: + typedef cef_key_type_t KeyType; + typedef cef_mouse_button_type_t MouseButtonType; + typedef cef_paint_element_type_t PaintElementType; + + /// + // Create a new browser window using the window parameters specified by + // |windowInfo|. All values will be copied internally and the actual window + // will be created on the UI thread. This method call will not block. + /// + /*--cef(optional_param=url)--*/ + static bool CreateBrowser(CefWindowInfo& windowInfo, + CefRefPtr client, + const CefString& url, + const CefBrowserSettings& settings); + + /// + // Create a new browser window using the window parameters specified by + // |windowInfo|. This method should only be called on the UI thread. + /// + /*--cef(optional_param=url)--*/ + static CefRefPtr CreateBrowserSync(CefWindowInfo& windowInfo, + CefRefPtr client, + const CefString& url, + const CefBrowserSettings& settings); + + /// + // Call this method before destroying a contained browser window. This method + // performs any internal cleanup that may be needed before the browser window + // is destroyed. + /// + /*--cef()--*/ + virtual void ParentWindowWillClose() =0; + + /// + // Closes this browser window. + /// + /*--cef()--*/ + virtual void CloseBrowser() =0; + + /// + // Returns true if the browser can navigate backwards. + /// + /*--cef()--*/ + virtual bool CanGoBack() =0; + /// + // Navigate backwards. + /// + /*--cef()--*/ + virtual void GoBack() =0; + /// + // Returns true if the browser can navigate forwards. + /// + /*--cef()--*/ + virtual bool CanGoForward() =0; + /// + // Navigate forwards. + /// + /*--cef()--*/ + virtual void GoForward() =0; + /// + // Reload the current page. + /// + /*--cef()--*/ + virtual void Reload() =0; + /// + // Reload the current page ignoring any cached data. + /// + /*--cef()--*/ + virtual void ReloadIgnoreCache() =0; + /// + // Stop loading the page. + /// + /*--cef()--*/ + virtual void StopLoad() =0; + + /// + // Set focus for the browser window. If |enable| is true focus will be set to + // the window. Otherwise, focus will be removed. + /// + /*--cef()--*/ + virtual void SetFocus(bool enable) =0; + + /// + // Retrieve the window handle for this browser. + /// + /*--cef()--*/ + virtual CefWindowHandle GetWindowHandle() =0; + + /// + // Retrieve the window handle of the browser that opened this browser. Will + // return NULL for non-popup windows. This method can be used in combination + // with custom handling of modal windows. + /// + /*--cef()--*/ + virtual CefWindowHandle GetOpenerWindowHandle() =0; + + /// + // Returns true if the window is a popup window. + /// + /*--cef()--*/ + virtual bool IsPopup() =0; + + // Returns true if a document has been loaded in the browser. + /*--cef()--*/ + virtual bool HasDocument() =0; + + /// + // Returns the client for this browser. + /// + /*--cef()--*/ + virtual CefRefPtr GetClient() =0; + + /// + // Returns the main (top-level) frame for the browser window. + /// + /*--cef()--*/ + virtual CefRefPtr GetMainFrame() =0; + + /// + // Returns the focused frame for the browser window. This method should only + // be called on the UI thread. + /// + /*--cef()--*/ + virtual CefRefPtr GetFocusedFrame() =0; + + /// + // Returns the frame with the specified name, or NULL if not found. This + // method should only be called on the UI thread. + /// + /*--cef()--*/ + virtual CefRefPtr GetFrame(const CefString& name) =0; + + /// + // Returns the names of all existing frames. This method should only be called + // on the UI thread. + /// + /*--cef()--*/ + virtual void GetFrameNames(std::vector& names) =0; + + /// + // Search for |searchText|. |identifier| can be used to have multiple searches + // running simultaniously. |forward| indicates whether to search forward or + // backward within the page. |matchCase| indicates whether the search should + // be case-sensitive. |findNext| indicates whether this is the first request + // or a follow-up. + /// + /*--cef()--*/ + virtual void Find(int identifier, const CefString& searchText, + bool forward, bool matchCase, bool findNext) =0; + + /// + // Cancel all searches that are currently going on. + /// + /*--cef()--*/ + virtual void StopFinding(bool clearSelection) =0; + + /// + // Get the zoom level. + /// + /*--cef()--*/ + virtual double GetZoomLevel() =0; + + /// + // Change the zoom level to the specified value. + /// + /*--cef()--*/ + virtual void SetZoomLevel(double zoomLevel) =0; + + /// + // Clear the back/forward browsing history. + /// + /*--cef()--*/ + virtual void ClearHistory() =0; + + /// + // Open developer tools in its own window. + /// + /*--cef()--*/ + virtual void ShowDevTools() =0; + + /// + // Explicitly close the developer tools window if one exists for this browser + // instance. + /// + /*--cef()--*/ + virtual void CloseDevTools() =0; + + /// + // Returns true if window rendering is disabled. + /// + /*--cef()--*/ + virtual bool IsWindowRenderingDisabled() =0; + + /// + // Get the size of the specified element. This method should only be called on + // the UI thread. + /// + /*--cef()--*/ + virtual bool GetSize(PaintElementType type, int& width, int& height) =0; + + /// + // Set the size of the specified element. This method is only used when window + // rendering is disabled. + /// + /*--cef()--*/ + virtual void SetSize(PaintElementType type, int width, int height) =0; + + /// + // Returns true if a popup is currently visible. This method should only be + // called on the UI thread. + /// + /*--cef()--*/ + virtual bool IsPopupVisible() =0; + + /// + // Hide the currently visible popup, if any. + /// + /*--cef()--*/ + virtual void HidePopup() =0; + + /// + // Invalidate the |dirtyRect| region of the view. This method is only used + // when window rendering is disabled and will result in a call to + // HandlePaint(). + /// + /*--cef()--*/ + virtual void Invalidate(const CefRect& dirtyRect) =0; + + /// + // Get the raw image data contained in the specified element without + // performing validation. The specified |width| and |height| dimensions must + // match the current element size. On Windows |buffer| must be width*height*4 + // bytes in size and represents a BGRA image with an upper-left origin. This + // method should only be called on the UI thread. + /// + /*--cef()--*/ + virtual bool GetImage(PaintElementType type, int width, int height, + void* buffer) =0; + + /// + // Send a key event to the browser. + /// + /*--cef()--*/ + virtual void SendKeyEvent(KeyType type, int key, int modifiers, bool sysChar, + bool imeChar) =0; + + /// + // Send a mouse click event to the browser. The |x| and |y| coordinates are + // relative to the upper-left corner of the view. + /// + /*--cef()--*/ + virtual void SendMouseClickEvent(int x, int y, MouseButtonType type, + bool mouseUp, int clickCount) =0; + + /// + // Send a mouse move event to the browser. The |x| and |y| coordinates are + // relative to the upper-left corner of the view. + /// + /*--cef()--*/ + virtual void SendMouseMoveEvent(int x, int y, bool mouseLeave) =0; + + /// + // Send a mouse wheel event to the browser. The |x| and |y| coordinates are + // relative to the upper-left corner of the view. + /// + /*--cef()--*/ + virtual void SendMouseWheelEvent(int x, int y, int delta) =0; + + /// + // Send a focus event to the browser. + /// + /*--cef()--*/ + virtual void SendFocusEvent(bool setFocus) =0; + + /// + // Send a capture lost event to the browser. + /// + /*--cef()--*/ + virtual void SendCaptureLostEvent() =0; +}; + +#endif // CEF_INCLUDE_CEF_BROWSER_H_ diff --git a/cef/include/cef_client.h b/cef/include/cef_client.h new file mode 100644 index 000000000..5e10971b8 --- /dev/null +++ b/cef/include/cef_client.h @@ -0,0 +1,176 @@ +// Copyright (c) 2011 Marshall A. Greenblatt. All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the name Chromium Embedded +// Framework nor the names of its contributors may be used to endorse +// or promote products derived from this software without specific prior +// written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +// --------------------------------------------------------------------------- +// +// The contents of this file must follow a specific format in order to +// support the CEF translator tool. See the translator.README.txt file in the +// tools directory for more information. +// + +#ifndef CEF_INCLUDE_CEF_CLIENT_H_ +#define CEF_INCLUDE_CEF_CLIENT_H_ +#pragma once + +#include "include/cef_base.h" +#include "include/cef_display_handler.h" +#include "include/cef_drag_handler.h" +#include "include/cef_find_handler.h" +#include "include/cef_focus_handler.h" +#include "include/cef_jsdialog_handler.h" +#include "include/cef_keyboard_handler.h" +#include "include/cef_life_span_handler.h" +#include "include/cef_load_handler.h" +#include "include/cef_menu_handler.h" +#include "include/cef_permission_handler.h" +#include "include/cef_print_handler.h" +#include "include/cef_render_handler.h" +#include "include/cef_request_handler.h" +#include "include/cef_v8context_handler.h" + +/// +// Implement this interface to provide handler implementations. +/// +/*--cef(source=client,no_debugct_check)--*/ +class CefClient : public virtual CefBase { + public: + /// + // Return the handler for browser life span events. + /// + /*--cef()--*/ + virtual CefRefPtr GetLifeSpanHandler() { + return NULL; + } + + /// + // Return the handler for browser load status events. + /// + /*--cef()--*/ + virtual CefRefPtr GetLoadHandler() { + return NULL; + } + + /// + // Return the handler for browser request events. + /// + /*--cef()--*/ + virtual CefRefPtr GetRequestHandler() { + return NULL; + } + + /// + // Return the handler for browser display state events. + /// + /*--cef()--*/ + virtual CefRefPtr GetDisplayHandler() { + return NULL; + } + + /// + // Return the handler for focus events. + /// + /*--cef()--*/ + virtual CefRefPtr GetFocusHandler() { + return NULL; + } + + /// + // Return the handler for keyboard events. + /// + /*--cef()--*/ + virtual CefRefPtr GetKeyboardHandler() { + return NULL; + } + + /// + // Return the handler for context menu events. + /// + /*--cef()--*/ + virtual CefRefPtr GetMenuHandler() { + return NULL; + } + + /// + // Return the handler for browser permission events. + /// + /*--cef()--*/ + virtual CefRefPtr GetPermissionHandler() { + return NULL; + } + + /// + // Return the handler for printing events. + /// + /*--cef()--*/ + virtual CefRefPtr GetPrintHandler() { + return NULL; + } + + /// + // Return the handler for find result events. + /// + /*--cef()--*/ + virtual CefRefPtr GetFindHandler() { + return NULL; + } + + /// + // Return the handler for JavaScript dialog events. + /// + /*--cef()--*/ + virtual CefRefPtr GetJSDialogHandler() { + return NULL; + } + + /// + // Return the handler for V8 context events. + /// + /*--cef()--*/ + virtual CefRefPtr GetV8ContextHandler() { + return NULL; + } + + /// + // Return the handler for off-screen rendering events. + /// + /*--cef()--*/ + virtual CefRefPtr GetRenderHandler() { + return NULL; + } + + /// + // Return the handler for drag events. + /// + /*--cef()--*/ + virtual CefRefPtr GetDragHandler() { + return NULL; + } +}; + +#endif // CEF_INCLUDE_CEF_CLIENT_H_ diff --git a/cef/include/cef_command_line.h b/cef/include/cef_command_line.h new file mode 100644 index 000000000..a698187ee --- /dev/null +++ b/cef/include/cef_command_line.h @@ -0,0 +1,160 @@ +// Copyright (c) 2011 Marshall A. Greenblatt. All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the name Chromium Embedded +// Framework nor the names of its contributors may be used to endorse +// or promote products derived from this software without specific prior +// written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +// --------------------------------------------------------------------------- +// +// The contents of this file must follow a specific format in order to +// support the CEF translator tool. See the translator.README.txt file in the +// tools directory for more information. +// + +#ifndef CEF_INCLUDE_CEF_COMMAND_LINE_H_ +#define CEF_INCLUDE_CEF_COMMAND_LINE_H_ +#pragma once + +#include "include/cef_base.h" +#include +#include + +/// +// Class used to create and/or parse command line arguments. Arguments with +// '--', '-' and, on Windows, '/' prefixes are considered switches. Switches +// will always precede any arguments without switch prefixes. Switches can +// optionally have a value specified using the '=' delimiter (e.g. +// "-switch=value"). An argument of "--" will terminate switch parsing with all +// subsequent tokens, regardless of prefix, being interpreted as non-switch +// arguments. Switch names are considered case-insensitive. This class can be +// used before CefInitialize() is called. +/// +/*--cef(source=library,no_debugct_check)--*/ +class CefCommandLine : public virtual CefBase { + public: + typedef std::vector ArgumentList; + typedef std::map SwitchMap; + + /// + // Create a new CefCommandLine instance. + /// + /*--cef(revision_check)--*/ + static CefRefPtr CreateCommandLine(); + + /// + // Initialize the command line with the specified |argc| and |argv| values. + // The first argument must be the name of the program. This method is only + // supported on non-Windows platforms. + /// + /*--cef()--*/ + virtual void InitFromArgv(int argc, const char* const* argv) =0; + + /// + // Initialize the command line with the string returned by calling + // GetCommandLineW(). This method is only supported on Windows. + /// + /*--cef()--*/ + virtual void InitFromString(const CefString& command_line) =0; + + /// + // Constructs and returns the represented command line string. Use this method + // cautiously because quoting behavior is unclear. + /// + /*--cef()--*/ + virtual CefString GetCommandLineString() =0; + + /// + // Get the program part of the command line string (the first item). + /// + /*--cef()--*/ + virtual CefString GetProgram() =0; + + /// + // Set the program part of the command line string (the first item). + /// + /*--cef()--*/ + virtual void SetProgram(const CefString& program) =0; + + /// + // Returns true if the command line has switches. + /// + /*--cef()--*/ + virtual bool HasSwitches() =0; + + /// + // Returns true if the command line contains the given switch. + /// + /*--cef()--*/ + virtual bool HasSwitch(const CefString& name) =0; + + /// + // Returns the value associated with the given switch. If the switch has no + // value or isn't present this method returns the empty string. + /// + /*--cef()--*/ + virtual CefString GetSwitchValue(const CefString& name) =0; + + /// + // Returns the map of switch names and values. If a switch has no value an + // empty string is returned. + /// + /*--cef()--*/ + virtual void GetSwitches(SwitchMap& switches) =0; + + /// + // Add a switch to the end of the command line. If the switch has no value + // pass an empty value string. + /// + /*--cef()--*/ + virtual void AppendSwitch(const CefString& name) =0; + + /// + // Add a switch with the specified value to the end of the command line. + /// + /*--cef()--*/ + virtual void AppendSwitchWithValue(const CefString& name, + const CefString& value) =0; + + /// + // True if there are remaining command line arguments. + /// + /*--cef()--*/ + virtual bool HasArguments() =0; + + /// + // Get the remaining command line arguments. + /// + /*--cef()--*/ + virtual void GetArguments(ArgumentList& arguments) =0; + + /// + // Add an argument to the end of the command line. + /// + /*--cef()--*/ + virtual void AppendArgument(const CefString& argument) =0; +}; + +#endif // CEF_INCLUDE_CEF_COMMAND_LINE_H_ diff --git a/cef/include/cef_content_filter.h b/cef/include/cef_content_filter.h new file mode 100644 index 000000000..af5cf1755 --- /dev/null +++ b/cef/include/cef_content_filter.h @@ -0,0 +1,68 @@ +// Copyright (c) 2011 Marshall A. Greenblatt. All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the name Chromium Embedded +// Framework nor the names of its contributors may be used to endorse +// or promote products derived from this software without specific prior +// written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +// --------------------------------------------------------------------------- +// +// The contents of this file must follow a specific format in order to +// support the CEF translator tool. See the translator.README.txt file in the +// tools directory for more information. +// + +#ifndef CEF_INCLUDE_CEF_CONTENT_FILTER_H_ +#define CEF_INCLUDE_CEF_CONTENT_FILTER_H_ +#pragma once + +#include "include/cef_base.h" +#include "include/cef_stream.h" + +/// +// Interface to implement for filtering response content. The methods of this +// class will always be called on the UI thread. +/// +/*--cef(source=client)--*/ +class CefContentFilter : public virtual CefBase { + public: + /// + // Set |substitute_data| to the replacement for the data in |data| if data + // should be modified. + /// + /*--cef()--*/ + virtual void ProcessData(const void* data, int data_size, + CefRefPtr& substitute_data) {} + + /// + // Called when there is no more data to be processed. It is expected that + // whatever data was retained in the last ProcessData() call, it should be + // returned now by setting |remainder| if appropriate. + /// + /*--cef()--*/ + virtual void Drain(CefRefPtr& remainder) {} +}; + +#endif // CEF_INCLUDE_CEF_CONTENT_FILTER_H_ diff --git a/cef/include/cef_cookie.h b/cef/include/cef_cookie.h new file mode 100644 index 000000000..d24325c39 --- /dev/null +++ b/cef/include/cef_cookie.h @@ -0,0 +1,147 @@ +// Copyright (c) 2012 Marshall A. Greenblatt. All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the name Chromium Embedded +// Framework nor the names of its contributors may be used to endorse +// or promote products derived from this software without specific prior +// written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +// --------------------------------------------------------------------------- +// +// The contents of this file must follow a specific format in order to +// support the CEF translator tool. See the translator.README.txt file in the +// tools directory for more information. +// + +#ifndef CEF_INCLUDE_CEF_COOKIE_H_ +#define CEF_INCLUDE_CEF_COOKIE_H_ +#pragma once + +#include "include/cef_base.h" +#include + +class CefCookieVisitor; + + +/// +// Class used for managing cookies. The methods of this class may be called on +// any thread unless otherwise indicated. +/// +/*--cef(source=library)--*/ +class CefCookieManager : public virtual CefBase { + public: + /// + // Returns the global cookie manager. By default data will be stored at + // CefSettings.cache_path if specified or in memory otherwise. + /// + /*--cef()--*/ + static CefRefPtr GetGlobalManager(); + + /// + // Creates a new cookie manager. If |path| is empty data will be stored in + // memory only. Returns NULL if creation fails. + /// + /*--cef(optional_param=path)--*/ + static CefRefPtr CreateManager(const CefString& path); + + /// + // Set the schemes supported by this manager. By default only "http" and + // "https" schemes are supported. Must be called before any cookies are + // accessed. + /// + /*--cef()--*/ + virtual void SetSupportedSchemes(const std::vector& schemes) =0; + + /// + // Visit all cookies. The returned cookies are ordered by longest path, then + // by earliest creation date. Returns false if cookies cannot be accessed. + /// + /*--cef()--*/ + virtual bool VisitAllCookies(CefRefPtr visitor) =0; + + /// + // Visit a subset of cookies. The results are filtered by the given url + // scheme, host, domain and path. If |includeHttpOnly| is true HTTP-only + // cookies will also be included in the results. The returned cookies are + // ordered by longest path, then by earliest creation date. Returns false if + // cookies cannot be accessed. + /// + /*--cef()--*/ + virtual bool VisitUrlCookies(const CefString& url, bool includeHttpOnly, + CefRefPtr visitor) =0; + + /// + // Sets a cookie given a valid URL and explicit user-provided cookie + // attributes. This function expects each attribute to be well-formed. It will + // check for disallowed characters (e.g. the ';' character is disallowed + // within the cookie value attribute) and will return false without setting + // the cookie if such characters are found. This method must be called on the + // IO thread. + /// + /*--cef()--*/ + virtual bool SetCookie(const CefString& url, const CefCookie& cookie) =0; + + /// + // Delete all cookies that match the specified parameters. If both |url| and + // values |cookie_name| are specified all host and domain cookies matching + // both will be deleted. If only |url| is specified all host cookies (but not + // domain cookies) irrespective of path will be deleted. If |url| is empty all + // cookies for all hosts and domains will be deleted. Returns false if a non- + // empty invalid URL is specified or if cookies cannot be accessed. This + // method must be called on the IO thread. + /// + /*--cef(optional_param=url,optional_param=cookie_name)--*/ + virtual bool DeleteCookies(const CefString& url, + const CefString& cookie_name) =0; + + /// + // Sets the directory path that will be used for storing cookie data. If + // |path| is empty data will be stored in memory only. Returns false if + // cookies cannot be accessed. + /// + /*--cef(optional_param=path)--*/ + virtual bool SetStoragePath(const CefString& path) =0; +}; + + +/// +// Interface to implement for visiting cookie values. The methods of this class +// will always be called on the IO thread. +/// +/*--cef(source=client)--*/ +class CefCookieVisitor : public virtual CefBase { + public: + /// + // Method that will be called once for each cookie. |count| is the 0-based + // index for the current cookie. |total| is the total number of cookies. + // Set |deleteCookie| to true to delete the cookie currently being visited. + // Return false to stop visiting cookies. This method may never be called if + // no cookies are found. + /// + /*--cef()--*/ + virtual bool Visit(const CefCookie& cookie, int count, int total, + bool& deleteCookie) =0; +}; + +#endif // CEF_INCLUDE_CEF_COOKIE_H_ diff --git a/cef/include/cef_display_handler.h b/cef/include/cef_display_handler.h new file mode 100644 index 000000000..2c55445d8 --- /dev/null +++ b/cef/include/cef_display_handler.h @@ -0,0 +1,117 @@ +// Copyright (c) 2011 Marshall A. Greenblatt. All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the name Chromium Embedded +// Framework nor the names of its contributors may be used to endorse +// or promote products derived from this software without specific prior +// written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +// --------------------------------------------------------------------------- +// +// The contents of this file must follow a specific format in order to +// support the CEF translator tool. See the translator.README.txt file in the +// tools directory for more information. +// + +#ifndef CEF_INCLUDE_CEF_DISPLAY_HANDLER_H_ +#define CEF_INCLUDE_CEF_DISPLAY_HANDLER_H_ +#pragma once + +#include "include/cef_base.h" +#include "include/cef_browser.h" +#include "include/cef_frame.h" + +/// +// Implement this interface to handle events related to browser display state. +// The methods of this class will be called on the UI thread. +/// +/*--cef(source=client)--*/ +class CefDisplayHandler : public virtual CefBase { + public: + typedef cef_handler_statustype_t StatusType; + + /// + // Called when the navigation state has changed. + /// + /*--cef()--*/ + virtual void OnNavStateChange(CefRefPtr browser, + bool canGoBack, + bool canGoForward) {} + + /// + // Called when a frame's address has changed. + /// + /*--cef()--*/ + virtual void OnAddressChange(CefRefPtr browser, + CefRefPtr frame, + const CefString& url) {} + + /// + // Called when the size of the content area has changed. + /// + /*--cef()--*/ + virtual void OnContentsSizeChange(CefRefPtr browser, + CefRefPtr frame, + int width, + int height) {} + + /// + // Called when the page title changes. + /// + /*--cef(optional_param=title)--*/ + virtual void OnTitleChange(CefRefPtr browser, + const CefString& title) {} + + /// + // Called when the browser is about to display a tooltip. |text| contains the + // text that will be displayed in the tooltip. To handle the display of the + // tooltip yourself return true. Otherwise, you can optionally modify |text| + // and then return false to allow the browser to display the tooltip. + /// + /*--cef(optional_param=text)--*/ + virtual bool OnTooltip(CefRefPtr browser, + CefString& text) { return false; } + + /// + // Called when the browser receives a status message. |text| contains the text + // that will be displayed in the status message and |type| indicates the + // status message type. + /// + /*--cef(optional_param=value)--*/ + virtual void OnStatusMessage(CefRefPtr browser, + const CefString& value, + StatusType type) {} + + /// + // Called to display a console message. Return true to stop the message from + // being output to the console. + /// + /*--cef(optional_param=message,optional_param=source)--*/ + virtual bool OnConsoleMessage(CefRefPtr browser, + const CefString& message, + const CefString& source, + int line) { return false; } +}; + +#endif // CEF_INCLUDE_CEF_DISPLAY_HANDLER_H_ diff --git a/cef/include/cef_dom.h b/cef/include/cef_dom.h new file mode 100644 index 000000000..b56050d87 --- /dev/null +++ b/cef/include/cef_dom.h @@ -0,0 +1,429 @@ +// Copyright (c) 2011 Marshall A. Greenblatt. All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the name Chromium Embedded +// Framework nor the names of its contributors may be used to endorse +// or promote products derived from this software without specific prior +// written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +// --------------------------------------------------------------------------- +// +// The contents of this file must follow a specific format in order to +// support the CEF translator tool. See the translator.README.txt file in the +// tools directory for more information. +// + +#ifndef CEF_INCLUDE_CEF_DOM_H_ +#define CEF_INCLUDE_CEF_DOM_H_ +#pragma once + +#include "include/cef_base.h" +#include + +class CefDOMDocument; +class CefDOMEventListener; +class CefDOMNode; + +/// +// Interface to implement for visiting the DOM. The methods of this class will +// be called on the UI thread. +/// +/*--cef(source=client)--*/ +class CefDOMVisitor : public virtual CefBase { + public: + /// + // Method executed for visiting the DOM. The document object passed to this + // method represents a snapshot of the DOM at the time this method is + // executed. DOM objects are only valid for the scope of this method. Do not + // keep references to or attempt to access any DOM objects outside the scope + // of this method. + /// + /*--cef()--*/ + virtual void Visit(CefRefPtr document) =0; +}; + + +/// +// Class used to represent a DOM document. The methods of this class should only +// be called on the UI thread. +/// +/*--cef(source=library)--*/ +class CefDOMDocument : public virtual CefBase { + public: + typedef cef_dom_document_type_t Type; + + /// + // Returns the document type. + /// + /*--cef(default_retval=DOM_DOCUMENT_TYPE_UNKNOWN)--*/ + virtual Type GetType() =0; + + /// + // Returns the root document node. + /// + /*--cef()--*/ + virtual CefRefPtr GetDocument() =0; + + /// + // Returns the BODY node of an HTML document. + /// + /*--cef()--*/ + virtual CefRefPtr GetBody() =0; + + /// + // Returns the HEAD node of an HTML document. + /// + /*--cef()--*/ + virtual CefRefPtr GetHead() =0; + + /// + // Returns the title of an HTML document. + /// + /*--cef()--*/ + virtual CefString GetTitle() =0; + + /// + // Returns the document element with the specified ID value. + /// + /*--cef()--*/ + virtual CefRefPtr GetElementById(const CefString& id) =0; + + /// + // Returns the node that currently has keyboard focus. + /// + /*--cef()--*/ + virtual CefRefPtr GetFocusedNode() =0; + + /// + // Returns true if a portion of the document is selected. + /// + /*--cef()--*/ + virtual bool HasSelection() =0; + + /// + // Returns the selection start node. + /// + /*--cef()--*/ + virtual CefRefPtr GetSelectionStartNode() =0; + + /// + // Returns the selection offset within the start node. + /// + /*--cef()--*/ + virtual int GetSelectionStartOffset() =0; + + /// + // Returns the selection end node. + /// + /*--cef()--*/ + virtual CefRefPtr GetSelectionEndNode() =0; + + /// + // Returns the selection offset within the end node. + /// + /*--cef()--*/ + virtual int GetSelectionEndOffset() =0; + + /// + // Returns the contents of this selection as markup. + /// + /*--cef()--*/ + virtual CefString GetSelectionAsMarkup() =0; + + /// + // Returns the contents of this selection as text. + /// + /*--cef()--*/ + virtual CefString GetSelectionAsText() =0; + + /// + // Returns the base URL for the document. + /// + /*--cef()--*/ + virtual CefString GetBaseURL() =0; + + /// + // Returns a complete URL based on the document base URL and the specified + // partial URL. + /// + /*--cef()--*/ + virtual CefString GetCompleteURL(const CefString& partialURL) =0; +}; + + +/// +// Class used to represent a DOM node. The methods of this class should only be +// called on the UI thread. +/// +/*--cef(source=library)--*/ +class CefDOMNode : public virtual CefBase { + public: + typedef std::map AttributeMap; + typedef cef_dom_node_type_t Type; + + /// + // Returns the type for this node. + /// + /*--cef(default_retval=DOM_NODE_TYPE_UNSUPPORTED)--*/ + virtual Type GetType() =0; + + /// + // Returns true if this is a text node. + /// + /*--cef()--*/ + virtual bool IsText() =0; + + /// + // Returns true if this is an element node. + /// + /*--cef()--*/ + virtual bool IsElement() =0; + + /// + // Returns true if this is a form control element node. + /// + /*--cef()--*/ + virtual bool IsFormControlElement() =0; + + /// + // Returns the type of this form control element node. + /// + /*--cef()--*/ + virtual CefString GetFormControlElementType() =0; + + /// + // Returns true if this object is pointing to the same handle as |that| + // object. + /// + /*--cef()--*/ + virtual bool IsSame(CefRefPtr that) =0; + + /// + // Returns the name of this node. + /// + /*--cef()--*/ + virtual CefString GetName() =0; + + /// + // Returns the value of this node. + /// + /*--cef()--*/ + virtual CefString GetValue() =0; + + /// + // Set the value of this node. Returns true on success. + /// + /*--cef()--*/ + virtual bool SetValue(const CefString& value) =0; + + /// + // Returns the contents of this node as markup. + /// + /*--cef()--*/ + virtual CefString GetAsMarkup() =0; + + /// + // Returns the document associated with this node. + /// + /*--cef()--*/ + virtual CefRefPtr GetDocument() =0; + + /// + // Returns the parent node. + /// + /*--cef()--*/ + virtual CefRefPtr GetParent() =0; + + /// + // Returns the previous sibling node. + /// + /*--cef()--*/ + virtual CefRefPtr GetPreviousSibling() =0; + + /// + // Returns the next sibling node. + /// + /*--cef()--*/ + virtual CefRefPtr GetNextSibling() =0; + + /// + // Returns true if this node has child nodes. + /// + /*--cef()--*/ + virtual bool HasChildren() =0; + + /// + // Return the first child node. + /// + /*--cef()--*/ + virtual CefRefPtr GetFirstChild() =0; + + /// + // Returns the last child node. + /// + /*--cef()--*/ + virtual CefRefPtr GetLastChild() =0; + + /// + // Add an event listener to this node for the specified event type. If + // |useCapture| is true then this listener will be considered a capturing + // listener. Capturing listeners will recieve all events of the specified + // type before the events are dispatched to any other event targets beneath + // the current node in the tree. Events which are bubbling upwards through + // the tree will not trigger a capturing listener. Separate calls to this + // method can be used to register the same listener with and without capture. + // See WebCore/dom/EventNames.h for the list of supported event types. + /// + /*--cef()--*/ + virtual void AddEventListener(const CefString& eventType, + CefRefPtr listener, + bool useCapture) =0; + + + // The following methods are valid only for element nodes. + + /// + // Returns the tag name of this element. + /// + /*--cef()--*/ + virtual CefString GetElementTagName() =0; + + /// + // Returns true if this element has attributes. + /// + /*--cef()--*/ + virtual bool HasElementAttributes() =0; + + /// + // Returns true if this element has an attribute named |attrName|. + /// + /*--cef()--*/ + virtual bool HasElementAttribute(const CefString& attrName) =0; + + /// + // Returns the element attribute named |attrName|. + /// + /*--cef()--*/ + virtual CefString GetElementAttribute(const CefString& attrName) =0; + + /// + // Returns a map of all element attributes. + /// + /*--cef()--*/ + virtual void GetElementAttributes(AttributeMap& attrMap) =0; + + /// + // Set the value for the element attribute named |attrName|. Returns true on + // success. + /// + /*--cef()--*/ + virtual bool SetElementAttribute(const CefString& attrName, + const CefString& value) =0; + + /// + // Returns the inner text of the element. + /// + /*--cef()--*/ + virtual CefString GetElementInnerText() =0; +}; + + +/// +// Class used to represent a DOM event. The methods of this class should only +// be called on the UI thread. +/// +/*--cef(source=library)--*/ +class CefDOMEvent : public virtual CefBase { + public: + typedef cef_dom_event_category_t Category; + typedef cef_dom_event_phase_t Phase; + + /// + // Returns the event type. + /// + /*--cef()--*/ + virtual CefString GetType() =0; + + /// + // Returns the event category. + /// + /*--cef(default_retval=DOM_EVENT_CATEGORY_UNKNOWN)--*/ + virtual Category GetCategory() =0; + + /// + // Returns the event processing phase. + /// + /*--cef(default_retval=DOM_EVENT_PHASE_UNKNOWN)--*/ + virtual Phase GetPhase() =0; + + /// + // Returns true if the event can bubble up the tree. + /// + /*--cef()--*/ + virtual bool CanBubble() =0; + + /// + // Returns true if the event can be canceled. + /// + /*--cef()--*/ + virtual bool CanCancel() =0; + + /// + // Returns the document associated with this event. + /// + /*--cef()--*/ + virtual CefRefPtr GetDocument() =0; + + /// + // Returns the target of the event. + /// + /*--cef()--*/ + virtual CefRefPtr GetTarget() =0; + + /// + // Returns the current target of the event. + /// + /*--cef()--*/ + virtual CefRefPtr GetCurrentTarget() =0; +}; + + +/// +// Interface to implement for handling DOM events. The methods of this class +// will be called on the UI thread. +/// +/*--cef(source=client)--*/ +class CefDOMEventListener : public virtual CefBase { + public: + /// + // Called when an event is received. The event object passed to this method + // contains a snapshot of the DOM at the time this method is executed. DOM + // objects are only valid for the scope of this method. Do not keep references + // to or attempt to access any DOM objects outside the scope of this method. + /// + /*--cef()--*/ + virtual void HandleEvent(CefRefPtr event) =0; +}; + +#endif // CEF_INCLUDE_CEF_DOM_H_ diff --git a/cef/include/cef_download_handler.h b/cef/include/cef_download_handler.h new file mode 100644 index 000000000..8fd209447 --- /dev/null +++ b/cef/include/cef_download_handler.h @@ -0,0 +1,65 @@ +// Copyright (c) 2011 Marshall A. Greenblatt. All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the name Chromium Embedded +// Framework nor the names of its contributors may be used to endorse +// or promote products derived from this software without specific prior +// written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +// --------------------------------------------------------------------------- +// +// The contents of this file must follow a specific format in order to +// support the CEF translator tool. See the translator.README.txt file in the +// tools directory for more information. +// + +#ifndef CEF_INCLUDE_CEF_DOWNLOAD_HANDLER_H_ +#define CEF_INCLUDE_CEF_DOWNLOAD_HANDLER_H_ +#pragma once + +#include "include/cef_base.h" + +/// +// Class used to handle file downloads. The methods of this class will always be +// called on the UI thread. +/// +/*--cef(source=client)--*/ +class CefDownloadHandler : public virtual CefBase { + public: + /// + // A portion of the file contents have been received. This method will be + // called multiple times until the download is complete. Return |true| to + // continue receiving data and |false| to cancel. + /// + /*--cef()--*/ + virtual bool ReceivedData(void* data, int data_size) =0; + + /// + // The download is complete. + /// + /*--cef()--*/ + virtual void Complete() =0; +}; + +#endif // CEF_INCLUDE_CEF_DOWNLOAD_HANDLER_H_ diff --git a/cef/include/cef_drag_data.h b/cef/include/cef_drag_data.h new file mode 100644 index 000000000..99487b3ae --- /dev/null +++ b/cef/include/cef_drag_data.h @@ -0,0 +1,126 @@ +// Copyright (c) 2011 Marshall A. Greenblatt. All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the name Chromium Embedded +// Framework nor the names of its contributors may be used to endorse +// or promote products derived from this software without specific prior +// written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +// --------------------------------------------------------------------------- +// +// The contents of this file must follow a specific format in order to +// support the CEF translator tool. See the translator.README.txt file in the +// tools directory for more information. +// + +#ifndef CEF_INCLUDE_CEF_DRAG_DATA_H_ +#define CEF_INCLUDE_CEF_DRAG_DATA_H_ +#pragma once + +#include "include/cef_base.h" +#include + +/// +// Class used to represent drag data. The methods of this class may be called +// on any thread. +/// +/*--cef(source=library)--*/ +class CefDragData : public virtual CefBase { + public: + /// + // Returns true if the drag data is a link. + /// + /*--cef()--*/ + virtual bool IsLink() =0; + + /// + // Returns true if the drag data is a text or html fragment. + /// + /*--cef()--*/ + virtual bool IsFragment() =0; + + /// + // Returns true if the drag data is a file. + /// + /*--cef()--*/ + virtual bool IsFile() =0; + + /// + // Return the link URL that is being dragged. + /// + /*--cef()--*/ + virtual CefString GetLinkURL() =0; + + /// + // Return the title associated with the link being dragged. + /// + /*--cef()--*/ + virtual CefString GetLinkTitle() =0; + + /// + // Return the metadata, if any, associated with the link being dragged. + /// + /*--cef()--*/ + virtual CefString GetLinkMetadata() =0; + + /// + // Return the plain text fragment that is being dragged. + /// + /*--cef()--*/ + virtual CefString GetFragmentText() =0; + + /// + // Return the text/html fragment that is being dragged. + /// + /*--cef()--*/ + virtual CefString GetFragmentHtml() =0; + + /// + // Return the base URL that the fragment came from. This value is used for + // resolving relative URLs and may be empty. + /// + /*--cef()--*/ + virtual CefString GetFragmentBaseURL() =0; + + /// + // Return the extension of the file being dragged out of the browser window. + /// + /*--cef()--*/ + virtual CefString GetFileExtension() =0; + + /// + // Return the name of the file being dragged out of the browser window. + /// + /*--cef()--*/ + virtual CefString GetFileName() =0; + + /// + // Retrieve the list of file names that are being dragged into the browser + // window. + /// + /*--cef()--*/ + virtual bool GetFileNames(std::vector& names) =0; +}; + +#endif // CEF_INCLUDE_CEF_DRAG_DATA_H_ diff --git a/cef/include/cef_drag_handler.h b/cef/include/cef_drag_handler.h new file mode 100644 index 000000000..79d90e57e --- /dev/null +++ b/cef/include/cef_drag_handler.h @@ -0,0 +1,77 @@ +// Copyright (c) 2011 Marshall A. Greenblatt. All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the name Chromium Embedded +// Framework nor the names of its contributors may be used to endorse +// or promote products derived from this software without specific prior +// written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +// --------------------------------------------------------------------------- +// +// The contents of this file must follow a specific format in order to +// support the CEF translator tool. See the translator.README.txt file in the +// tools directory for more information. +// + +#ifndef CEF_INCLUDE_CEF_DRAG_HANDLER_H_ +#define CEF_INCLUDE_CEF_DRAG_HANDLER_H_ +#pragma once + +#include "include/cef_base.h" +#include "include/cef_drag_data.h" +#include "include/cef_browser.h" + +/// +// Implement this interface to handle events related to dragging. The methods of +// this class will be called on the UI thread. +/// +/*--cef(source=client)--*/ +class CefDragHandler : public virtual CefBase { + public: + typedef cef_drag_operations_mask_t DragOperationsMask; + + /// + // Called when the browser window initiates a drag event. |dragData| + // contains the drag event data and |mask| represents the type of drag + // operation. Return false for default drag handling behavior or true to + // cancel the drag event. + /// + /*--cef()--*/ + virtual bool OnDragStart(CefRefPtr browser, + CefRefPtr dragData, + DragOperationsMask mask) { return false; } + + /// + // Called when an external drag event enters the browser window. |dragData| + // contains the drag event data and |mask| represents the type of drag + // operation. Return false for default drag handling behavior or true to + // cancel the drag event. + /// + /*--cef()--*/ + virtual bool OnDragEnter(CefRefPtr browser, + CefRefPtr dragData, + DragOperationsMask mask) { return false; } +}; + +#endif // CEF_INCLUDE_CEF_DRAG_HANDLER_H_ diff --git a/cef/include/cef_find_handler.h b/cef/include/cef_find_handler.h new file mode 100644 index 000000000..bead6feeb --- /dev/null +++ b/cef/include/cef_find_handler.h @@ -0,0 +1,68 @@ +// Copyright (c) 2011 Marshall A. Greenblatt. All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the name Chromium Embedded +// Framework nor the names of its contributors may be used to endorse +// or promote products derived from this software without specific prior +// written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +// --------------------------------------------------------------------------- +// +// The contents of this file must follow a specific format in order to +// support the CEF translator tool. See the translator.README.txt file in the +// tools directory for more information. +// + +#ifndef CEF_INCLUDE_CEF_FIND_HANDLER_H_ +#define CEF_INCLUDE_CEF_FIND_HANDLER_H_ +#pragma once + +#include "include/cef_base.h" +#include "include/cef_browser.h" + +/// +// Implement this interface to handle events related to find results. The +// methods of this class will be called on the UI thread. +/// +/*--cef(source=client)--*/ +class CefFindHandler : public virtual CefBase { + public: + /// + // Called to report find results returned by CefBrowser::Find(). |identifer| + // is the identifier passed to CefBrowser::Find(), |count| is the number of + // matches currently identified, |selectionRect| is the location of where the + // match was found (in window coordinates), |activeMatchOrdinal| is the + // current position in the search results, and |finalUpdate| is true if this + // is the last find notification. + /// + /*--cef()--*/ + virtual void OnFindResult(CefRefPtr browser, + int identifier, + int count, + const CefRect& selectionRect, + int activeMatchOrdinal, + bool finalUpdate) {} +}; + +#endif // CEF_INCLUDE_CEF_FIND_HANDLER_H_ diff --git a/cef/include/cef_focus_handler.h b/cef/include/cef_focus_handler.h new file mode 100644 index 000000000..a45b6f52e --- /dev/null +++ b/cef/include/cef_focus_handler.h @@ -0,0 +1,88 @@ +// Copyright (c) 2011 Marshall A. Greenblatt. All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the name Chromium Embedded +// Framework nor the names of its contributors may be used to endorse +// or promote products derived from this software without specific prior +// written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +// --------------------------------------------------------------------------- +// +// The contents of this file must follow a specific format in order to +// support the CEF translator tool. See the translator.README.txt file in the +// tools directory for more information. +// + +#ifndef CEF_INCLUDE_CEF_FOCUS_HANDLER_H_ +#define CEF_INCLUDE_CEF_FOCUS_HANDLER_H_ +#pragma once + +#include "include/cef_base.h" +#include "include/cef_browser.h" +#include "include/cef_dom.h" +#include "include/cef_frame.h" + +/// +// Implement this interface to handle events related to focus. The methods of +// this class will be called on the UI thread. +/// +/*--cef(source=client)--*/ +class CefFocusHandler : public virtual CefBase { + public: + typedef cef_handler_focus_source_t FocusSource; + + /// + // Called when the browser component is about to loose focus. For instance, if + // focus was on the last HTML element and the user pressed the TAB key. |next| + // will be true if the browser is giving focus to the next component and false + // if the browser is giving focus to the previous component. + /// + /*--cef()--*/ + virtual void OnTakeFocus(CefRefPtr browser, + bool next) {} + + /// + // Called when the browser component is requesting focus. |source| indicates + // where the focus request is originating from. Return false to allow the + // focus to be set or true to cancel setting the focus. + /// + /*--cef()--*/ + virtual bool OnSetFocus(CefRefPtr browser, + FocusSource source) { return false; } + + /// + // Called when a new node in the the browser gets focus. The |node| value may + // be empty if no specific node has gained focus. The node object passed to + // this method represents a snapshot of the DOM at the time this method is + // executed. DOM objects are only valid for the scope of this method. Do not + // keep references to or attempt to access any DOM objects outside the scope + // of this method. + /// + /*--cef(optional_param=frame,optional_param=node)--*/ + virtual void OnFocusedNodeChanged(CefRefPtr browser, + CefRefPtr frame, + CefRefPtr node) {} +}; + +#endif // CEF_INCLUDE_CEF_FOCUS_HANDLER_H_ diff --git a/cef/include/cef_frame.h b/cef/include/cef_frame.h new file mode 100644 index 000000000..f0ac6ef7a --- /dev/null +++ b/cef/include/cef_frame.h @@ -0,0 +1,220 @@ +// Copyright (c) 2011 Marshall A. Greenblatt. All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the name Chromium Embedded +// Framework nor the names of its contributors may be used to endorse +// or promote products derived from this software without specific prior +// written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +// --------------------------------------------------------------------------- +// +// The contents of this file must follow a specific format in order to +// support the CEF translator tool. See the translator.README.txt file in the +// tools directory for more information. +// + +#ifndef CEF_INCLUDE_CEF_FRAME_H_ +#define CEF_INCLUDE_CEF_FRAME_H_ +#pragma once + +#include "include/cef_base.h" +#include "include/cef_dom.h" +#include "include/cef_request.h" +#include "include/cef_stream.h" + +class CefBrowser; +class CefV8Context; + +/// +// Class used to represent a frame in the browser window. The methods of this +// class may be called on any thread unless otherwise indicated in the comments. +/// +/*--cef(source=library)--*/ +class CefFrame : public virtual CefBase { + public: + /// + // Execute undo in this frame. + /// + /*--cef()--*/ + virtual void Undo() =0; + /// + // Execute redo in this frame. + /// + /*--cef()--*/ + virtual void Redo() =0; + /// + // Execute cut in this frame. + /// + /*--cef()--*/ + virtual void Cut() =0; + /// + // Execute copy in this frame. + /// + /*--cef()--*/ + virtual void Copy() =0; + /// + // Execute paste in this frame. + /// + /*--cef()--*/ + virtual void Paste() =0; + /// + // Execute delete in this frame. + /// + /*--cef(capi_name=del)--*/ + virtual void Delete() =0; + /// + // Execute select all in this frame. + /// + /*--cef()--*/ + virtual void SelectAll() =0; + + /// + // Execute printing in the this frame. The user will be prompted with the + // print dialog appropriate to the operating system. + /// + /*--cef()--*/ + virtual void Print() =0; + + /// + // Save this frame's HTML source to a temporary file and open it in the + // default text viewing application. + /// + /*--cef()--*/ + virtual void ViewSource() =0; + + /// + // Returns this frame's HTML source as a string. This method should only be + // called on the UI thread. + /// + /*--cef()--*/ + virtual CefString GetSource() =0; + + /// + // Returns this frame's display text as a string. This method should only be + // called on the UI thread. + /// + /*--cef()--*/ + virtual CefString GetText() =0; + + /// + // Load the request represented by the |request| object. + /// + /*--cef()--*/ + virtual void LoadRequest(CefRefPtr request) =0; + + /// + // Load the specified |url|. + /// + /*--cef()--*/ + virtual void LoadURL(const CefString& url) =0; + + /// + // Load the contents of |string_val| with the optional dummy target |url|. + /// + /*--cef()--*/ + virtual void LoadString(const CefString& string_val, + const CefString& url) =0; + + /// + // Load the contents of |stream| with the optional dummy target |url|. + /// + /*--cef()--*/ + virtual void LoadStream(CefRefPtr stream, + const CefString& url) =0; + + /// + // Execute a string of JavaScript code in this frame. The |script_url| + // parameter is the URL where the script in question can be found, if any. + // The renderer may request this URL to show the developer the source of the + // error. The |start_line| parameter is the base line number to use for error + // reporting. + /// + /*--cef(optional_param=scriptUrl)--*/ + virtual void ExecuteJavaScript(const CefString& jsCode, + const CefString& scriptUrl, + int startLine) =0; + + /// + // Returns true if this is the main (top-level) frame. + /// + /*--cef()--*/ + virtual bool IsMain() =0; + + /// + // Returns true if this is the focused frame. This method should only be + // called on the UI thread. + /// + /*--cef()--*/ + virtual bool IsFocused() =0; + + /// + // Returns the name for this frame. If the frame has an assigned name (for + // example, set via the iframe "name" attribute) then that value will be + // returned. Otherwise a unique name will be constructed based on the frame + // parent hierarchy. The main (top-level) frame will always have an empty name + // value. + /// + /*--cef()--*/ + virtual CefString GetName() =0; + + /// + // Returns the globally unique identifier for this frame. + /// + /*--cef()--*/ + virtual int64 GetIdentifier() =0; + + /// + // Returns the parent of this frame or NULL if this is the main (top-level) + // frame. This method should only be called on the UI thread. + /// + /*--cef()--*/ + virtual CefRefPtr GetParent() =0; + + /// + // Returns the URL currently loaded in this frame. + /// + /*--cef()--*/ + virtual CefString GetURL() =0; + + /// + // Returns the browser that this frame belongs to. + /// + /*--cef()--*/ + virtual CefRefPtr GetBrowser() =0; + + /// + // Visit the DOM document. + /// + /*--cef()--*/ + virtual void VisitDOM(CefRefPtr visitor) =0; + + /// + // Get the V8 context associated with the frame. This method should only be + // called on the UI thread. + /// + /*--cef()--*/ + virtual CefRefPtr GetV8Context() =0; +}; + +#endif // CEF_INCLUDE_CEF_FRAME_H_ diff --git a/cef/include/cef_jsdialog_handler.h b/cef/include/cef_jsdialog_handler.h new file mode 100644 index 000000000..b34261241 --- /dev/null +++ b/cef/include/cef_jsdialog_handler.h @@ -0,0 +1,87 @@ +// Copyright (c) 2011 Marshall A. Greenblatt. All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the name Chromium Embedded +// Framework nor the names of its contributors may be used to endorse +// or promote products derived from this software without specific prior +// written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +// --------------------------------------------------------------------------- +// +// The contents of this file must follow a specific format in order to +// support the CEF translator tool. See the translator.README.txt file in the +// tools directory for more information. +// + +#ifndef CEF_INCLUDE_CEF_JSDIALOG_HANDLER_H_ +#define CEF_INCLUDE_CEF_JSDIALOG_HANDLER_H_ +#pragma once + +#include "include/cef_base.h" +#include "include/cef_browser.h" +#include "include/cef_frame.h" + +/// +// Implement this interface to handle events related to JavaScript dialogs. The +// methods of this class will be called on the UI thread. +/// +/*--cef(source=client)--*/ +class CefJSDialogHandler : public virtual CefBase { + public: + /// + // Called to run a JavaScript alert message. Return false to display the + // default alert or true if you displayed a custom alert. + /// + /*--cef()--*/ + virtual bool OnJSAlert(CefRefPtr browser, + CefRefPtr frame, + const CefString& message) { return false; } + + /// + // Called to run a JavaScript confirm request. Return false to display the + // default alert or true if you displayed a custom alert. If you handled the + // alert set |retval| to true if the user accepted the confirmation. + /// + /*--cef()--*/ + virtual bool OnJSConfirm(CefRefPtr browser, + CefRefPtr frame, + const CefString& message, + bool& retval) { return false; } + + /// + // Called to run a JavaScript prompt request. Return false to display the + // default prompt or true if you displayed a custom prompt. If you handled + // the prompt set |retval| to true if the user accepted the prompt and request + // and |result| to the resulting value. + /// + /*--cef()--*/ + virtual bool OnJSPrompt(CefRefPtr browser, + CefRefPtr frame, + const CefString& message, + const CefString& defaultValue, + bool& retval, + CefString& result) { return false; } +}; + +#endif // CEF_INCLUDE_CEF_JSDIALOG_HANDLER_H_ diff --git a/cef/include/cef_keyboard_handler.h b/cef/include/cef_keyboard_handler.h new file mode 100644 index 000000000..a8133e91f --- /dev/null +++ b/cef/include/cef_keyboard_handler.h @@ -0,0 +1,76 @@ +// Copyright (c) 2011 Marshall A. Greenblatt. All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the name Chromium Embedded +// Framework nor the names of its contributors may be used to endorse +// or promote products derived from this software without specific prior +// written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +// --------------------------------------------------------------------------- +// +// The contents of this file must follow a specific format in order to +// support the CEF translator tool. See the translator.README.txt file in the +// tools directory for more information. +// + +#ifndef CEF_INCLUDE_CEF_KEYBOARD_HANDLER_H_ +#define CEF_INCLUDE_CEF_KEYBOARD_HANDLER_H_ +#pragma once + +#include "include/cef_base.h" +#include "include/cef_browser.h" + +/// +// Implement this interface to handle events related to keyboard input. The +// methods of this class will be called on the UI thread. +/// +/*--cef(source=client)--*/ +class CefKeyboardHandler : public virtual CefBase { + public: + typedef cef_handler_keyevent_type_t KeyEventType; + + /// + // Called when the browser component receives a keyboard event. This method + // is called both before the event is passed to the renderer and after + // JavaScript in the page has had a chance to handle the event. |type| is the + // type of keyboard event, |code| is the windows scan-code for the event, + // |modifiers| is a set of bit- flags describing any pressed modifier keys and + // |isSystemKey| is true if Windows considers this a 'system key' message (see + // http://msdn.microsoft.com/en-us/library/ms646286(VS.85).aspx). If + // |isAfterJavaScript| is true then JavaScript in the page has had a chance + // to handle the event and has chosen not to. Only RAWKEYDOWN, KEYDOWN and + // CHAR events will be sent with |isAfterJavaScript| set to true. Return + // true if the keyboard event was handled or false to allow continued handling + // of the event by the renderer. + /// + /*--cef()--*/ + virtual bool OnKeyEvent(CefRefPtr browser, + KeyEventType type, + int code, + int modifiers, + bool isSystemKey, + bool isAfterJavaScript) { return false; } +}; + +#endif // CEF_INCLUDE_CEF_KEYBOARD_HANDLER_H_ diff --git a/cef/include/cef_life_span_handler.h b/cef/include/cef_life_span_handler.h new file mode 100644 index 000000000..907d755a8 --- /dev/null +++ b/cef/include/cef_life_span_handler.h @@ -0,0 +1,105 @@ +// Copyright (c) 2011 Marshall A. Greenblatt. All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the name Chromium Embedded +// Framework nor the names of its contributors may be used to endorse +// or promote products derived from this software without specific prior +// written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +// --------------------------------------------------------------------------- +// +// The contents of this file must follow a specific format in order to +// support the CEF translator tool. See the translator.README.txt file in the +// tools directory for more information. +// + +#ifndef CEF_INCLUDE_CEF_LIFE_SPAN_HANDLER_H_ +#define CEF_INCLUDE_CEF_LIFE_SPAN_HANDLER_H_ +#pragma once + +#include "include/cef_base.h" +#include "include/cef_browser.h" + +class CefClient; + +/// +// Implement this interface to handle events related to browser life span. The +// methods of this class will be called on the UI thread. +/// +/*--cef(source=client)--*/ +class CefLifeSpanHandler : public virtual CefBase { + public: + /// + // Called before a new popup window is created. The |parentBrowser| parameter + // will point to the parent browser window. The |popupFeatures| parameter will + // contain information about the style of popup window requested. Return false + // to have the framework create the new popup window based on the parameters + // in |windowInfo|. Return true to cancel creation of the popup window. By + // default, a newly created popup window will have the same client and + // settings as the parent window. To change the client for the new window + // modify the object that |client| points to. To change the settings for the + // new window modify the |settings| structure. + /// + /*--cef(optional_param=url)--*/ + virtual bool OnBeforePopup(CefRefPtr parentBrowser, + const CefPopupFeatures& popupFeatures, + CefWindowInfo& windowInfo, + const CefString& url, + CefRefPtr& client, + CefBrowserSettings& settings) { return false; } + + /// + // Called after a new window is created. + /// + /*--cef()--*/ + virtual void OnAfterCreated(CefRefPtr browser) {} + + /// + // Called when a modal window is about to display and the modal loop should + // begin running. Return false to use the default modal loop implementation or + // true to use a custom implementation. + /// + /*--cef()--*/ + virtual bool RunModal(CefRefPtr browser) { return false; } + + /// + // Called when a window has recieved a request to close. Return false to + // proceed with the window close or true to cancel the window close. If this + // is a modal window and a custom modal loop implementation was provided in + // RunModal() this callback should be used to restore the opener window to a + // usable state. + /// + /*--cef()--*/ + virtual bool DoClose(CefRefPtr browser) { return false; } + + /// + // Called just before a window is closed. If this is a modal window and a + // custom modal loop implementation was provided in RunModal() this callback + // should be used to exit the custom modal loop. + /// + /*--cef()--*/ + virtual void OnBeforeClose(CefRefPtr browser) {} +}; + +#endif // CEF_INCLUDE_CEF_LIFE_SPAN_HANDLER_H_ diff --git a/cef/include/cef_load_handler.h b/cef/include/cef_load_handler.h new file mode 100644 index 000000000..bfa01df25 --- /dev/null +++ b/cef/include/cef_load_handler.h @@ -0,0 +1,94 @@ +// Copyright (c) 2011 Marshall A. Greenblatt. All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the name Chromium Embedded +// Framework nor the names of its contributors may be used to endorse +// or promote products derived from this software without specific prior +// written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +// --------------------------------------------------------------------------- +// +// The contents of this file must follow a specific format in order to +// support the CEF translator tool. See the translator.README.txt file in the +// tools directory for more information. +// + +#ifndef CEF_INCLUDE_CEF_LOAD_HANDLER_H_ +#define CEF_INCLUDE_CEF_LOAD_HANDLER_H_ +#pragma once + +#include "include/cef_base.h" +#include "include/cef_browser.h" +#include "include/cef_frame.h" + +/// +// Implement this interface to handle events related to browser load status. The +// methods of this class will be called on the UI thread. +/// +/*--cef(source=client)--*/ +class CefLoadHandler : public virtual CefBase { + public: + typedef cef_handler_errorcode_t ErrorCode; + + /// + // Called when the browser begins loading a frame. The |frame| value will + // never be empty -- call the IsMain() method to check if this frame is the + // main frame. Multiple frames may be loading at the same time. Sub-frames may + // start or continue loading after the main frame load has ended. This method + // may not be called for a particular frame if the load request for that frame + // fails. + /// + /*--cef()--*/ + virtual void OnLoadStart(CefRefPtr browser, + CefRefPtr frame) {} + + /// + // Called when the browser is done loading a frame. The |frame| value will + // never be empty -- call the IsMain() method to check if this frame is the + // main frame. Multiple frames may be loading at the same time. Sub-frames may + // start or continue loading after the main frame load has ended. This method + // will always be called for all frames irrespective of whether the request + // completes successfully. + /// + /*--cef()--*/ + virtual void OnLoadEnd(CefRefPtr browser, + CefRefPtr frame, + int httpStatusCode) {} + + /// + // Called when the browser fails to load a resource. |errorCode| is the error + // code number and |failedUrl| is the URL that failed to load. To provide + // custom error text assign the text to |errorText| and return true. + // Otherwise, return false for the default error text. See + // net\base\net_error_list.h for complete descriptions of the error codes. + /// + /*--cef()--*/ + virtual bool OnLoadError(CefRefPtr browser, + CefRefPtr frame, + ErrorCode errorCode, + const CefString& failedUrl, + CefString& errorText) { return false; } +}; + +#endif // CEF_INCLUDE_CEF_LOAD_HANDLER_H_ diff --git a/cef/include/cef_menu_handler.h b/cef/include/cef_menu_handler.h new file mode 100644 index 000000000..81fe115b1 --- /dev/null +++ b/cef/include/cef_menu_handler.h @@ -0,0 +1,80 @@ +// Copyright (c) 2011 Marshall A. Greenblatt. All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the name Chromium Embedded +// Framework nor the names of its contributors may be used to endorse +// or promote products derived from this software without specific prior +// written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +// --------------------------------------------------------------------------- +// +// The contents of this file must follow a specific format in order to +// support the CEF translator tool. See the translator.README.txt file in the +// tools directory for more information. +// + +#ifndef CEF_INCLUDE_CEF_MENU_HANDLER_H_ +#define CEF_INCLUDE_CEF_MENU_HANDLER_H_ +#pragma once + +#include "include/cef_base.h" +#include "include/cef_browser.h" + +/// +// Implement this interface to handle events related to browser context menus. +// The methods of this class will be called on the UI thread. +/// +/*--cef(source=client)--*/ +class CefMenuHandler : public virtual CefBase { + public: + typedef cef_menu_id_t MenuId; + + /// + // Called before a context menu is displayed. Return false to display the + // default context menu or true to cancel the display. + /// + /*--cef()--*/ + virtual bool OnBeforeMenu(CefRefPtr browser, + const CefMenuInfo& menuInfo) { return false; } + + /// + // Called to optionally override the default text for a context menu item. + // |label| contains the default text and may be modified to substitute + // alternate text. + /// + /*--cef()--*/ + virtual void GetMenuLabel(CefRefPtr browser, + MenuId menuId, + CefString& label) {} + + /// + // Called when an option is selected from the default context menu. Return + // false to execute the default action or true to cancel the action. + /// + /*--cef()--*/ + virtual bool OnMenuAction(CefRefPtr browser, + MenuId menuId) { return false; } +}; + +#endif // CEF_INCLUDE_CEF_MENU_HANDLER_H_ diff --git a/cef/include/cef_origin_whitelist.h b/cef/include/cef_origin_whitelist.h new file mode 100644 index 000000000..fce2e805e --- /dev/null +++ b/cef/include/cef_origin_whitelist.h @@ -0,0 +1,99 @@ +// Copyright (c) 2011 Marshall A. Greenblatt. All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the name Chromium Embedded +// Framework nor the names of its contributors may be used to endorse +// or promote products derived from this software without specific prior +// written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +// --------------------------------------------------------------------------- +// +// The contents of this file must follow a specific format in order to +// support the CEF translator tool. See the translator.README.txt file in the +// tools directory for more information. +// + +#ifndef CEF_INCLUDE_CEF_ORIGIN_WHITELIST_H_ +#define CEF_INCLUDE_CEF_ORIGIN_WHITELIST_H_ +#pragma once + +#include "include/cef_base.h" + + +/// +// Add an entry to the cross-origin access whitelist. +// +// The same-origin policy restricts how scripts hosted from different origins +// (scheme + domain + port) can communicate. By default, scripts can only access +// resources with the same origin. Scripts hosted on the HTTP and HTTPS schemes +// (but no other schemes) can use the "Access-Control-Allow-Origin" header to +// allow cross-origin requests. For example, https://source.example.com can make +// XMLHttpRequest requests on http://target.example.com if the +// http://target.example.com request returns an "Access-Control-Allow-Origin: +// https://source.example.com" response header. +// +// Scripts in separate frames or iframes and hosted from the same protocol and +// domain suffix can execute cross-origin JavaScript if both pages set the +// document.domain value to the same domain suffix. For example, +// scheme://foo.example.com and scheme://bar.example.com can communicate using +// JavaScript if both domains set document.domain="example.com". +// +// This method is used to allow access to origins that would otherwise violate +// the same-origin policy. Scripts hosted underneath the fully qualified +// |source_origin| URL (like http://www.example.com) will be allowed access to +// all resources hosted on the specified |target_protocol| and |target_domain|. +// If |allow_target_subdomains| is true access will also be allowed to all +// subdomains of the target domain. +// +// This method cannot be used to bypass the restrictions on local or display +// isolated schemes. See the comments on CefRegisterCustomScheme for more +// information. +// +// This function may be called on any thread. Returns false if |source_origin| +// is invalid or the whitelist cannot be accessed. +/// +/*--cef()--*/ +bool CefAddCrossOriginWhitelistEntry(const CefString& source_origin, + const CefString& target_protocol, + const CefString& target_domain, + bool allow_target_subdomains); + +/// +// Remove an entry from the cross-origin access whitelist. Returns false if +// |source_origin| is invalid or the whitelist cannot be accessed. +/// +/*--cef()--*/ +bool CefRemoveCrossOriginWhitelistEntry(const CefString& source_origin, + const CefString& target_protocol, + const CefString& target_domain, + bool allow_target_subdomains); + +/// +// Remove all entries from the cross-origin access whitelist. Returns false if +// the whitelist cannot be accessed. +/// +/*--cef()--*/ +bool CefClearCrossOriginWhitelist(); + +#endif // CEF_INCLUDE_CEF_ORIGIN_WHITELIST_H_ diff --git a/cef/include/cef_permission_handler.h b/cef/include/cef_permission_handler.h new file mode 100644 index 000000000..aea8e46bb --- /dev/null +++ b/cef/include/cef_permission_handler.h @@ -0,0 +1,64 @@ +// Copyright (c) 2012 Marshall A. Greenblatt. All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the name Chromium Embedded +// Framework nor the names of its contributors may be used to endorse +// or promote products derived from this software without specific prior +// written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +// --------------------------------------------------------------------------- +// +// The contents of this file must follow a specific format in order to +// support the CEF translator tool. See the translator.README.txt file in the +// tools directory for more information. +// + +#ifndef CEF_INCLUDE_CEF_PERMISSION_HANDLER_H_ +#define CEF_INCLUDE_CEF_PERMISSION_HANDLER_H_ +#pragma once + +#include "include/cef_base.h" +#include "include/cef_browser.h" +#include "include/cef_frame.h" + +/// +// Implement this interface to handle events related to browser permissions. +// The methods of this class will be called on the UI thread. +/// +/*--cef(source=client)--*/ +class CefPermissionHandler : public virtual CefBase { + public: + /// + // Called on the UI thread before a script extension is loaded. + // Return false to let the extension load normally. + /// + /*--cef()--*/ + virtual bool OnBeforeScriptExtensionLoad(CefRefPtr browser, + CefRefPtr frame, + const CefString& extensionName) { + return false; + } +}; + +#endif // CEF_INCLUDE_CEF_PERMISSION_HANDLER_H_ diff --git a/cef/include/cef_print_handler.h b/cef/include/cef_print_handler.h new file mode 100644 index 000000000..d47fbf632 --- /dev/null +++ b/cef/include/cef_print_handler.h @@ -0,0 +1,91 @@ +// Copyright (c) 2011 Marshall A. Greenblatt. All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the name Chromium Embedded +// Framework nor the names of its contributors may be used to endorse +// or promote products derived from this software without specific prior +// written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +// --------------------------------------------------------------------------- +// +// The contents of this file must follow a specific format in order to +// support the CEF translator tool. See the translator.README.txt file in the +// tools directory for more information. +// + +#ifndef CEF_INCLUDE_CEF_PRINT_HANDLER_H_ +#define CEF_INCLUDE_CEF_PRINT_HANDLER_H_ +#pragma once + +#include "include/cef_base.h" +#include "include/cef_browser.h" +#include "include/cef_frame.h" + +/// +// Implement this interface to handle events related to printing. The methods of +// this class will be called on the UI thread. +/// +/*--cef(source=client)--*/ +class CefPrintHandler : public virtual CefBase { + public: + /// + // Called to allow customization of standard print options before the print + // dialog is displayed. |printOptions| allows specification of paper size, + // orientation and margins. Note that the specified margins may be adjusted if + // they are outside the range supported by the printer. All units are in + // inches. Return false to display the default print options or true to + // display the modified |printOptions|. + /// + /*--cef()--*/ + virtual bool GetPrintOptions(CefRefPtr browser, + CefPrintOptions& printOptions) { return false; } + + /// + // Called to format print headers and footers. |printInfo| contains platform- + // specific information about the printer context. |url| is the URL if the + // currently printing page, |title| is the title of the currently printing + // page, |currentPage| is the current page number and |maxPages| is the total + // number of pages. Six default header locations are provided by the + // implementation: top left, top center, top right, bottom left, bottom center + // and bottom right. To use one of these default locations just assign a + // string to the appropriate variable. To draw the header and footer yourself + // return true. Otherwise, populate the approprate variables and return false. + /// + /*--cef()--*/ + virtual bool GetPrintHeaderFooter(CefRefPtr browser, + CefRefPtr frame, + const CefPrintInfo& printInfo, + const CefString& url, + const CefString& title, + int currentPage, + int maxPages, + CefString& topLeft, + CefString& topCenter, + CefString& topRight, + CefString& bottomLeft, + CefString& bottomCenter, + CefString& bottomRight) { return false; } +}; + +#endif // CEF_INCLUDE_CEF_PRINT_HANDLER_H_ diff --git a/cef/include/cef_proxy_handler.h b/cef/include/cef_proxy_handler.h new file mode 100644 index 000000000..d40c67d7c --- /dev/null +++ b/cef/include/cef_proxy_handler.h @@ -0,0 +1,57 @@ +// Copyright (c) 2011 Marshall A. Greenblatt. All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the name Chromium Embedded +// Framework nor the names of its contributors may be used to endorse +// or promote products derived from this software without specific prior +// written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +// --------------------------------------------------------------------------- +// +// The contents of this file must follow a specific format in order to +// support the CEF translator tool. See the translator.README.txt file in the +// tools directory for more information. +// + +#ifndef CEF_INCLUDE_CEF_PROXY_HANDLER_H_ +#define CEF_INCLUDE_CEF_PROXY_HANDLER_H_ +#pragma once + +#include "include/cef_base.h" + +/// +// Implement this interface to handle proxy resolution events. +/// +/*--cef(source=client)--*/ +class CefProxyHandler : public virtual CefBase { + public: + /// + // Called to retrieve proxy information for the specified |url|. + /// + /*--cef()--*/ + virtual void GetProxyForUrl(const CefString& url, + CefProxyInfo& proxy_info) {} +}; + +#endif // CEF_INCLUDE_CEF_PROXY_HANDLER_H_ diff --git a/cef/include/cef_render_handler.h b/cef/include/cef_render_handler.h new file mode 100644 index 000000000..9bb9f68af --- /dev/null +++ b/cef/include/cef_render_handler.h @@ -0,0 +1,119 @@ +// Copyright (c) 2011 Marshall A. Greenblatt. All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the name Chromium Embedded +// Framework nor the names of its contributors may be used to endorse +// or promote products derived from this software without specific prior +// written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +// --------------------------------------------------------------------------- +// +// The contents of this file must follow a specific format in order to +// support the CEF translator tool. See the translator.README.txt file in the +// tools directory for more information. +// + +#ifndef CEF_INCLUDE_CEF_RENDER_HANDLER_H_ +#define CEF_INCLUDE_CEF_RENDER_HANDLER_H_ +#pragma once + +#include "include/cef_base.h" +#include "include/cef_browser.h" +#include + +/// +// Implement this interface to handle events when window rendering is disabled. +// The methods of this class will be called on the UI thread. +/// +/*--cef(source=client)--*/ +class CefRenderHandler : public virtual CefBase { + public: + typedef cef_paint_element_type_t PaintElementType; + typedef std::vector RectList; + + /// + // Called to retrieve the view rectangle which is relative to screen + // coordinates. Return true if the rectangle was provided. + /// + /*--cef()--*/ + virtual bool GetViewRect(CefRefPtr browser, + CefRect& rect) { return false; } + + /// + // Called to retrieve the simulated screen rectangle. Return true if the + // rectangle was provided. + /// + /*--cef()--*/ + virtual bool GetScreenRect(CefRefPtr browser, + CefRect& rect) { return false; } + + /// + // Called to retrieve the translation from view coordinates to actual screen + // coordinates. Return true if the screen coordinates were provided. + /// + /*--cef()--*/ + virtual bool GetScreenPoint(CefRefPtr browser, + int viewX, + int viewY, + int& screenX, + int& screenY) { return false; } + + /// + // Called when the browser wants to show or hide the popup widget. The popup + // should be shown if |show| is true and hidden if |show| is false. + /// + /*--cef()--*/ + virtual void OnPopupShow(CefRefPtr browser, + bool show) {} + + /// + // Called when the browser wants to move or resize the popup widget. |rect| + // contains the new location and size. + /// + /*--cef()--*/ + virtual void OnPopupSize(CefRefPtr browser, + const CefRect& rect) {} + + /// + // Called when an element should be painted. |type| indicates whether the + // element is the view or the popup widget. |buffer| contains the pixel data + // for the whole image. |dirtyRects| contains the set of rectangles that need + // to be repainted. On Windows |buffer| will be width*height*4 bytes in size + // and represents a BGRA image with an upper-left origin. + /// + /*--cef()--*/ + virtual void OnPaint(CefRefPtr browser, + PaintElementType type, + const RectList& dirtyRects, + const void* buffer) {} + + /// + // Called when the browser window's cursor has changed. + /// + /*--cef()--*/ + virtual void OnCursorChange(CefRefPtr browser, + CefCursorHandle cursor) {} +}; + +#endif // CEF_INCLUDE_CEF_RENDER_HANDLER_H_ diff --git a/cef/include/cef_request.h b/cef/include/cef_request.h new file mode 100644 index 000000000..95ade79b1 --- /dev/null +++ b/cef/include/cef_request.h @@ -0,0 +1,255 @@ +// Copyright (c) 2011 Marshall A. Greenblatt. All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the name Chromium Embedded +// Framework nor the names of its contributors may be used to endorse +// or promote products derived from this software without specific prior +// written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +// --------------------------------------------------------------------------- +// +// The contents of this file must follow a specific format in order to +// support the CEF translator tool. See the translator.README.txt file in the +// tools directory for more information. +// + +#ifndef CEF_INCLUDE_CEF_REQUEST_H_ +#define CEF_INCLUDE_CEF_REQUEST_H_ +#pragma once + +#include "include/cef_base.h" +#include +#include + +class CefPostData; +class CefPostDataElement; + +/// +// Class used to represent a web request. The methods of this class may be +// called on any thread. +/// +/*--cef(source=library)--*/ +class CefRequest : public virtual CefBase { + public: + typedef std::multimap HeaderMap; + typedef cef_weburlrequest_flags_t RequestFlags; + + /// + // Create a new CefRequest object. + /// + /*--cef()--*/ + static CefRefPtr CreateRequest(); + + /// + // Get the fully qualified URL. + /// + /*--cef()--*/ + virtual CefString GetURL() =0; + /// + // Set the fully qualified URL. + /// + /*--cef()--*/ + virtual void SetURL(const CefString& url) =0; + + /// + // Get the request method type. The value will default to POST if post data + // is provided and GET otherwise. + /// + /*--cef()--*/ + virtual CefString GetMethod() =0; + /// + // Set the request method type. + /// + /*--cef()--*/ + virtual void SetMethod(const CefString& method) =0; + + /// + // Get the post data. + /// + /*--cef()--*/ + virtual CefRefPtr GetPostData() =0; + /// + // Set the post data. + /// + /*--cef()--*/ + virtual void SetPostData(CefRefPtr postData) =0; + + /// + // Get the header values. + /// + /*--cef()--*/ + virtual void GetHeaderMap(HeaderMap& headerMap) =0; + /// + // Set the header values. + /// + /*--cef()--*/ + virtual void SetHeaderMap(const HeaderMap& headerMap) =0; + + /// + // Set all values at one time. + /// + /*--cef(optional_param=postData)--*/ + virtual void Set(const CefString& url, + const CefString& method, + CefRefPtr postData, + const HeaderMap& headerMap) =0; + + /// + // Get the flags used in combination with CefWebURLRequest. + /// + /*--cef(default_retval=WUR_FLAG_NONE)--*/ + virtual RequestFlags GetFlags() =0; + /// + // Set the flags used in combination with CefWebURLRequest. + /// + /*--cef()--*/ + virtual void SetFlags(RequestFlags flags) =0; + + /// + // Set the URL to the first party for cookies used in combination with + // CefWebURLRequest. + /// + /*--cef()--*/ + virtual CefString GetFirstPartyForCookies() =0; + /// + // Get the URL to the first party for cookies used in combination with + // CefWebURLRequest. + /// + /*--cef()--*/ + virtual void SetFirstPartyForCookies(const CefString& url) =0; +}; + + +/// +// Class used to represent post data for a web request. The methods of this +// class may be called on any thread. +/// +/*--cef(source=library)--*/ +class CefPostData : public virtual CefBase { + public: + typedef std::vector > ElementVector; + + /// + // Create a new CefPostData object. + /// + /*--cef()--*/ + static CefRefPtr CreatePostData(); + + /// + // Returns the number of existing post data elements. + /// + /*--cef()--*/ + virtual size_t GetElementCount() =0; + + /// + // Retrieve the post data elements. + /// + /*--cef(count_func=elements:GetElementCount)--*/ + virtual void GetElements(ElementVector& elements) =0; + + /// + // Remove the specified post data element. Returns true if the removal + // succeeds. + /// + /*--cef()--*/ + virtual bool RemoveElement(CefRefPtr element) =0; + + /// + // Add the specified post data element. Returns true if the add succeeds. + /// + /*--cef()--*/ + virtual bool AddElement(CefRefPtr element) =0; + + /// + // Remove all existing post data elements. + /// + /*--cef()--*/ + virtual void RemoveElements() =0; +}; + + +/// +// Class used to represent a single element in the request post data. The +// methods of this class may be called on any thread. +/// +/*--cef(source=library)--*/ +class CefPostDataElement : public virtual CefBase { + public: + /// + // Post data elements may represent either bytes or files. + /// + typedef cef_postdataelement_type_t Type; + + /// + // Create a new CefPostDataElement object. + /// + /*--cef()--*/ + static CefRefPtr CreatePostDataElement(); + + /// + // Remove all contents from the post data element. + /// + /*--cef()--*/ + virtual void SetToEmpty() =0; + + /// + // The post data element will represent a file. + /// + /*--cef()--*/ + virtual void SetToFile(const CefString& fileName) =0; + + /// + // The post data element will represent bytes. The bytes passed + // in will be copied. + /// + /*--cef()--*/ + virtual void SetToBytes(size_t size, const void* bytes) =0; + + /// + // Return the type of this post data element. + /// + /*--cef(default_retval=PDE_TYPE_EMPTY)--*/ + virtual Type GetType() =0; + + /// + // Return the file name. + /// + /*--cef()--*/ + virtual CefString GetFile() =0; + + /// + // Return the number of bytes. + /// + /*--cef()--*/ + virtual size_t GetBytesCount() =0; + + /// + // Read up to |size| bytes into |bytes| and return the number of bytes + // actually read. + /// + /*--cef()--*/ + virtual size_t GetBytes(size_t size, void* bytes) =0; +}; + +#endif // CEF_INCLUDE_CEF_REQUEST_H_ diff --git a/cef/include/cef_request_handler.h b/cef/include/cef_request_handler.h new file mode 100644 index 000000000..0ee758f07 --- /dev/null +++ b/cef/include/cef_request_handler.h @@ -0,0 +1,171 @@ +// Copyright (c) 2011 Marshall A. Greenblatt. All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the name Chromium Embedded +// Framework nor the names of its contributors may be used to endorse +// or promote products derived from this software without specific prior +// written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +// --------------------------------------------------------------------------- +// +// The contents of this file must follow a specific format in order to +// support the CEF translator tool. See the translator.README.txt file in the +// tools directory for more information. +// + +#ifndef CEF_INCLUDE_CEF_REQUEST_HANDLER_H_ +#define CEF_INCLUDE_CEF_REQUEST_HANDLER_H_ +#pragma once + +#include "include/cef_base.h" +#include "include/cef_browser.h" +#include "include/cef_cookie.h" +#include "include/cef_download_handler.h" +#include "include/cef_frame.h" +#include "include/cef_content_filter.h" +#include "include/cef_response.h" +#include "include/cef_request.h" +#include "include/cef_stream.h" + +/// +// Implement this interface to handle events related to browser requests. The +// methods of this class will be called on the thread indicated. +/// +/*--cef(source=client)--*/ +class CefRequestHandler : public virtual CefBase { + public: + typedef cef_handler_navtype_t NavType; + + /// + // Called on the UI thread before browser navigation. Return true to cancel + // the navigation or false to allow the navigation to proceed. + /// + /*--cef()--*/ + virtual bool OnBeforeBrowse(CefRefPtr browser, + CefRefPtr frame, + CefRefPtr request, + NavType navType, + bool isRedirect) { return false; } + + /// + // Called on the IO thread before a resource is loaded. To allow the resource + // to load normally return false. To redirect the resource to a new url + // populate the |redirectUrl| value and return false. To specify data for the + // resource return a CefStream object in |resourceStream|, use the |response| + // object to set mime type, HTTP status code and optional header values, and + // return false. To cancel loading of the resource return true. Any + // modifications to |request| will be observed. If the URL in |request| is + // changed and |redirectUrl| is also set, the URL in |request| will be used. + /// + /*--cef()--*/ + virtual bool OnBeforeResourceLoad(CefRefPtr browser, + CefRefPtr request, + CefString& redirectUrl, + CefRefPtr& resourceStream, + CefRefPtr response, + int loadFlags) { return false; } + + /// + // Called on the IO thread when a resource load is redirected. The |old_url| + // parameter will contain the old URL. The |new_url| parameter will contain + // the new URL and can be changed if desired. + /// + /*--cef()--*/ + virtual void OnResourceRedirect(CefRefPtr browser, + const CefString& old_url, + CefString& new_url) {} + + /// + // Called on the UI thread after a response to the resource request is + // received. Set |filter| if response content needs to be monitored and/or + // modified as it arrives. + /// + /*--cef()--*/ + virtual void OnResourceResponse(CefRefPtr browser, + const CefString& url, + CefRefPtr response, + CefRefPtr& filter) {} + + /// + // Called on the IO thread to handle requests for URLs with an unknown + // protocol component. Return true to indicate that the request should + // succeed because it was handled externally. Set |allowOSExecution| to true + // and return false to attempt execution via the registered OS protocol + // handler, if any. If false is returned and either |allow_os_execution| + // is false or OS protocol handler execution fails then the request will fail + // with an error condition. + // SECURITY WARNING: YOU SHOULD USE THIS METHOD TO ENFORCE RESTRICTIONS BASED + // ON SCHEME, HOST OR OTHER URL ANALYSIS BEFORE ALLOWING OS EXECUTION. + /// + /*--cef()--*/ + virtual bool OnProtocolExecution(CefRefPtr browser, + const CefString& url, + bool& allowOSExecution) { return false; } + + /// + // Called on the UI thread when a server indicates via the + // 'Content-Disposition' header that a response represents a file to download. + // |mimeType| is the mime type for the download, |fileName| is the suggested + // target file name and |contentLength| is either the value of the + // 'Content-Size' header or -1 if no size was provided. Set |handler| to the + // CefDownloadHandler instance that will recieve the file contents. Return + // true to download the file or false to cancel the file download. + /// + /*--cef()--*/ + virtual bool GetDownloadHandler(CefRefPtr browser, + const CefString& mimeType, + const CefString& fileName, + int64 contentLength, + CefRefPtr& handler) + { return false; } + + /// + // Called on the IO thread when the browser needs credentials from the user. + // |isProxy| indicates whether the host is a proxy server. |host| contains the + // hostname and port number. Set |username| and |password| and return + // true to handle the request. Return false to cancel the request. + /// + /*--cef(optional_param=realm)--*/ + virtual bool GetAuthCredentials(CefRefPtr browser, + bool isProxy, + const CefString& host, + int port, + const CefString& realm, + const CefString& scheme, + CefString& username, + CefString& password) { return false; } + + /// + // Called on the IO thread to retrieve the cookie manager. |main_url| is the + // URL of the top-level frame. Cookies managers can be unique per browser or + // shared across multiple browsers. The global cookie manager will be used if + // this method returns NULL. + /// + /*--cef()--*/ + virtual CefRefPtr GetCookieManager( + CefRefPtr browser, + const CefString& main_url) { return NULL; } +}; + +#endif // CEF_INCLUDE_CEF_REQUEST_HANDLER_H_ diff --git a/cef/include/cef_resource_bundle_handler.h b/cef/include/cef_resource_bundle_handler.h new file mode 100644 index 000000000..e7a37d1b5 --- /dev/null +++ b/cef/include/cef_resource_bundle_handler.h @@ -0,0 +1,82 @@ +// Copyright (c) 2012 Marshall A. Greenblatt. All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the name Chromium Embedded +// Framework nor the names of its contributors may be used to endorse +// or promote products derived from this software without specific prior +// written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +// --------------------------------------------------------------------------- +// +// The contents of this file must follow a specific format in order to +// support the CEF translator tool. See the translator.README.txt file in the +// tools directory for more information. +// + +#ifndef CEF_INCLUDE_CEF_RESOURCE_BUNDLE_HANDLER_H_ +#define CEF_INCLUDE_CEF_RESOURCE_BUNDLE_HANDLER_H_ +#pragma once + +#include "include/cef_base.h" + +/// +// Class used to implement a custom resource bundle interface. The methods of +// this class may be called on multiple threads. +/// +/*--cef(source=client)--*/ +class CefResourceBundleHandler : public virtual CefBase { + public: + /// + // Called to retrieve a localized translation for the string specified by + // |message_id|. To provide the translation set |string| to the translation + // string and return true. To use the default translation return false. + // + // WARNING: Be cautious when implementing this method. ID values are auto- + // generated when CEF is built and may change between versions. Existing ID + // values can be discovered by searching for *_strings.h in the + // "obj/global_intermediate" build output directory. + /// + /*--cef()--*/ + virtual bool GetLocalizedString(int message_id, + CefString& string) =0; + + /// + // Called to retrieve data for the resource specified by |resource_id|. To + // provide the resource data set |data| and |data_size| to the data pointer + // and size respectively and return true. To use the default resource data + // return false. The resource data will not be copied and must remain resident + // in memory. + // + // WARNING: Be cautious when implementing this method. ID values are auto- + // generated when CEF is built and may change between versions. Existing ID + // values can be discovered by searching for *_resources.h in the + // "obj/global_intermediate" build output directory. + /// + /*--cef()--*/ + virtual bool GetDataResource(int resource_id, + void*& data, + size_t& data_size) =0; +}; + +#endif // CEF_INCLUDE_CEF_RESOURCE_BUNDLE_HANDLER_H_ diff --git a/cef/include/cef_response.h b/cef/include/cef_response.h new file mode 100644 index 000000000..5448cd71c --- /dev/null +++ b/cef/include/cef_response.h @@ -0,0 +1,104 @@ +// Copyright (c) 2011 Marshall A. Greenblatt. All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the name Chromium Embedded +// Framework nor the names of its contributors may be used to endorse +// or promote products derived from this software without specific prior +// written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +// --------------------------------------------------------------------------- +// +// The contents of this file must follow a specific format in order to +// support the CEF translator tool. See the translator.README.txt file in the +// tools directory for more information. +// + +#ifndef CEF_INCLUDE_CEF_RESPONSE_H_ +#define CEF_INCLUDE_CEF_RESPONSE_H_ +#pragma once + +#include "include/cef_base.h" +#include + +/// +// Class used to represent a web response. The methods of this class may be +// called on any thread. +/// +/*--cef(source=library)--*/ +class CefResponse : public virtual CefBase { + public: + typedef std::multimap HeaderMap; + + /// + // Get the response status code. + /// + /*--cef()--*/ + virtual int GetStatus() =0; + /// + // Set the response status code. + /// + /*--cef()--*/ + virtual void SetStatus(int status) = 0; + + /// + // Get the response status text. + /// + /*--cef()--*/ + virtual CefString GetStatusText() =0; + /// + // Set the response status text. + /// + /*--cef()--*/ + virtual void SetStatusText(const CefString& statusText) = 0; + + /// + // Get the response mime type. + /// + /*--cef()--*/ + virtual CefString GetMimeType() = 0; + /// + // Set the response mime type. + /// + /*--cef()--*/ + virtual void SetMimeType(const CefString& mimeType) = 0; + + /// + // Get the value for the specified response header field. + /// + /*--cef()--*/ + virtual CefString GetHeader(const CefString& name) =0; + + /// + // Get all response header fields. + /// + /*--cef()--*/ + virtual void GetHeaderMap(HeaderMap& headerMap) =0; + /// + // Set all response header fields. + /// + /*--cef()--*/ + virtual void SetHeaderMap(const HeaderMap& headerMap) =0; +}; + +#endif // CEF_INCLUDE_CEF_RESPONSE_H_ diff --git a/cef/include/cef_scheme.h b/cef/include/cef_scheme.h new file mode 100644 index 000000000..1bd9a39b2 --- /dev/null +++ b/cef/include/cef_scheme.h @@ -0,0 +1,222 @@ +// Copyright (c) 2011 Marshall A. Greenblatt. All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the name Chromium Embedded +// Framework nor the names of its contributors may be used to endorse +// or promote products derived from this software without specific prior +// written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +// --------------------------------------------------------------------------- +// +// The contents of this file must follow a specific format in order to +// support the CEF translator tool. See the translator.README.txt file in the +// tools directory for more information. +// + +#ifndef CEF_INCLUDE_CEF_SCHEME_H_ +#define CEF_INCLUDE_CEF_SCHEME_H_ +#pragma once + +#include "include/cef_base.h" +#include "include/cef_browser.h" +#include "include/cef_response.h" +#include "include/cef_request.h" + +class CefSchemeHandler; +class CefSchemeHandlerFactory; + +/// +// Register a custom scheme. This method should not be called for the built-in +// HTTP, HTTPS, FILE, FTP, ABOUT and DATA schemes. +// +// If |is_standard| is true the scheme will be treated as a standard scheme. +// Standard schemes are subject to URL canonicalization and parsing rules as +// defined in the Common Internet Scheme Syntax RFC 1738 Section 3.1 available +// at http://www.ietf.org/rfc/rfc1738.txt +// +// In particular, the syntax for standard scheme URLs must be of the form: +// 
+//  [scheme]://[username]:[password]@[host]:[port]/[url-path]
+//
+// Standard scheme URLs must have a host component that is a fully qualified +// domain name as defined in Section 3.5 of RFC 1034 [13] and Section 2.1 of RFC +// 1123. These URLs will be canonicalized to "scheme://host/path" in the +// simplest case and "scheme://username:password@host:port/path" in the most +// explicit case. For example, "scheme:host/path" and "scheme:///host/path" will +// both be canonicalized to "scheme://host/path". The origin of a standard +// scheme URL is the combination of scheme, host and port (i.e., +// "scheme://host:port" in the most explicit case). +// +// For non-standard scheme URLs only the "scheme:" component is parsed and +// canonicalized. The remainder of the URL will be passed to the handler as-is. +// For example, "scheme:///some%20text" will remain the same. Non-standard +// scheme URLs cannot be used as a target for form submission. +// +// If |is_local| is true the scheme will be treated as local (i.e., with the +// same security rules as those applied to "file" URLs). Normal pages cannot +// link to or access local URLs. Also, by default, local URLs can only perform +// XMLHttpRequest calls to the same URL (origin + path) that originated the +// request. To allow XMLHttpRequest calls from a local URL to other URLs with +// the same origin set the CefSettings.file_access_from_file_urls_allowed value +// to true. To allow XMLHttpRequest calls from a local URL to all origins set +// the CefSettings.universal_access_from_file_urls_allowed value to true. +// +// If |is_display_isolated| is true the scheme will be treated as display- +// isolated. This means that pages cannot display these URLs unless they are +// from the same scheme. For example, pages in another origin cannot create +// iframes or hyperlinks to URLs with this scheme. +// +// This function may be called on any thread. It should only be called once +// per unique |scheme_name| value. If |scheme_name| is already registered or if +// an error occurs this method will return false. +/// +/*--cef()--*/ +bool CefRegisterCustomScheme(const CefString& scheme_name, + bool is_standard, + bool is_local, + bool is_display_isolated); + +/// +// Register a scheme handler factory for the specified |scheme_name| and +// optional |domain_name|. An empty |domain_name| value for a standard scheme +// will cause the factory to match all domain names. The |domain_name| value +// will be ignored for non-standard schemes. If |scheme_name| is a built-in +// scheme and no handler is returned by |factory| then the built-in scheme +// handler factory will be called. If |scheme_name| is a custom scheme the +// CefRegisterCustomScheme() function should be called for that scheme. +// This function may be called multiple times to change or remove the factory +// that matches the specified |scheme_name| and optional |domain_name|. +// Returns false if an error occurs. This function may be called on any thread. +/// +/*--cef(optional_param=domain_name,optional_param=factory)--*/ +bool CefRegisterSchemeHandlerFactory(const CefString& scheme_name, + const CefString& domain_name, + CefRefPtr factory); + +/// +// Clear all registered scheme handler factories. Returns false on error. This +// function may be called on any thread. +/// +/*--cef()--*/ +bool CefClearSchemeHandlerFactories(); + + +/// +// Class that creates CefSchemeHandler instances. The methods of this class will +// always be called on the IO thread. +/// +/*--cef(source=client)--*/ +class CefSchemeHandlerFactory : public virtual CefBase { + public: + /// + // Return a new scheme handler instance to handle the request. |browser| will + // be the browser window that initiated the request. If the request was + // initiated using the CefWebURLRequest API |browser| will be NULL. The + // |request| object passed to this method will not contain cookie data. + /// + /*--cef()--*/ + virtual CefRefPtr Create(CefRefPtr browser, + const CefString& scheme_name, + CefRefPtr request) =0; +}; + +/// +// Class used to facilitate asynchronous responses to custom scheme handler +// requests. The methods of this class may be called on any thread. +/// +/*--cef(source=library)--*/ +class CefSchemeHandlerCallback : public virtual CefBase { + public: + /// + // Notify that header information is now available for retrieval. + /// + /*--cef()--*/ + virtual void HeadersAvailable() =0; + + /// + // Notify that response data is now available for reading. + /// + /*--cef()--*/ + virtual void BytesAvailable() =0; + + /// + // Cancel processing of the request. + /// + /*--cef()--*/ + virtual void Cancel() =0; +}; + +/// +// Class used to implement a custom scheme handler interface. The methods of +// this class will always be called on the IO thread. +/// +/*--cef(source=client)--*/ +class CefSchemeHandler : public virtual CefBase { + public: + /// + // Begin processing the request. To handle the request return true and call + // HeadersAvailable() once the response header information is available + // (HeadersAvailable() can also be called from inside this method if header + // information is available immediately). To cancel the request return false. + /// + /*--cef()--*/ + virtual bool ProcessRequest(CefRefPtr request, + CefRefPtr callback) =0; + + /// + // Retrieve response header information. If the response length is not known + // set |response_length| to -1 and ReadResponse() will be called until it + // returns false. If the response length is known set |response_length| + // to a positive value and ReadResponse() will be called until it returns + // false or the specified number of bytes have been read. Use the |response| + // object to set the mime type, http status code and other optional header + // values. To redirect the request to a new URL set |redirectUrl| to the new + // URL. + /// + /*--cef()--*/ + virtual void GetResponseHeaders(CefRefPtr response, + int64& response_length, + CefString& redirectUrl) =0; + + /// + // Read response data. If data is available immediately copy up to + // |bytes_to_read| bytes into |data_out|, set |bytes_read| to the number of + // bytes copied, and return true. To read the data at a later time set + // |bytes_read| to 0, return true and call BytesAvailable() when the data is + // available. To indicate response completion return false. + /// + /*--cef()--*/ + virtual bool ReadResponse(void* data_out, + int bytes_to_read, + int& bytes_read, + CefRefPtr callback) =0; + + /// + // Request processing has been canceled. + /// + /*--cef()--*/ + virtual void Cancel() =0; +}; + +#endif // CEF_INCLUDE_CEF_SCHEME_H_ diff --git a/cef/include/cef_storage.h b/cef/include/cef_storage.h new file mode 100644 index 000000000..869595159 --- /dev/null +++ b/cef/include/cef_storage.h @@ -0,0 +1,110 @@ +// Copyright (c) 2011 Marshall A. Greenblatt. All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the name Chromium Embedded +// Framework nor the names of its contributors may be used to endorse +// or promote products derived from this software without specific prior +// written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +// --------------------------------------------------------------------------- +// +// The contents of this file must follow a specific format in order to +// support the CEF translator tool. See the translator.README.txt file in the +// tools directory for more information. +// + +#ifndef CEF_INCLUDE_CEF_STORAGE_H_ +#define CEF_INCLUDE_CEF_STORAGE_H_ +#pragma once + +#include "include/cef_base.h" + +class CefStorageVisitor; + +typedef cef_storage_type_t CefStorageType; + +/// +// Visit storage of the specified type. If |origin| is non-empty only data +// matching that origin will be visited. If |key| is non-empty only data +// matching that key will be visited. Otherwise, all data for the storage +// type will be visited. Origin should be of the form scheme://domain. If no +// origin is specified only data currently in memory will be returned. Returns +// false if the storage cannot be accessed. +/// +/*--cef(optional_param=origin,optional_param=key)--*/ +bool CefVisitStorage(CefStorageType type, const CefString& origin, + const CefString& key, + CefRefPtr visitor); + +/// +// Sets storage of the specified type, origin, key and value. Returns false if +// storage cannot be accessed. This method must be called on the UI thread. +/// +/*--cef()--*/ +bool CefSetStorage(CefStorageType type, const CefString& origin, + const CefString& key, const CefString& value); + +/// +// Deletes all storage of the specified type. If |origin| is non-empty only data +// matching that origin will be cleared. If |key| is non-empty only data +// matching that key will be cleared. Otherwise, all data for the storage type +// will be cleared. Returns false if storage cannot be accessed. This method +// must be called on the UI thread. +/// +/*--cef(optional_param=origin,optional_param=key)--*/ +bool CefDeleteStorage(CefStorageType type, const CefString& origin, + const CefString& key); + +/// +// Sets the directory path that will be used for storing data of the specified +// type. Currently only the ST_LOCALSTORAGE type is supported by this method. +// If |path| is empty data will be stored in memory only. By default the storage +// path is the same as the cache path. Returns false if the storage cannot be +// accessed. +/// +/*--cef(optional_param=path)--*/ +bool CefSetStoragePath(CefStorageType type, const CefString& path); + + +/// +// Interface to implement for visiting storage. The methods of this class will +// always be called on the UI thread. +/// +/*--cef(source=client)--*/ +class CefStorageVisitor : public virtual CefBase { + public: + /// + // Method that will be called once for each key/value data pair in storage. + // |count| is the 0-based index for the current pair. |total| is the total + // number of pairs. Set |deleteData| to true to delete the pair currently + // being visited. Return false to stop visiting pairs. This method may never + // be called if no data is found. + /// + /*--cef()--*/ + virtual bool Visit(CefStorageType type, const CefString& origin, + const CefString& key, const CefString& value, int count, + int total, bool& deleteData) =0; +}; + +#endif // CEF_INCLUDE_CEF_STORAGE_H_ diff --git a/cef/include/cef_stream.h b/cef/include/cef_stream.h new file mode 100644 index 000000000..8daae1708 --- /dev/null +++ b/cef/include/cef_stream.h @@ -0,0 +1,210 @@ +// Copyright (c) 2011 Marshall A. Greenblatt. All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the name Chromium Embedded +// Framework nor the names of its contributors may be used to endorse +// or promote products derived from this software without specific prior +// written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +// --------------------------------------------------------------------------- +// +// The contents of this file must follow a specific format in order to +// support the CEF translator tool. See the translator.README.txt file in the +// tools directory for more information. +// + +#ifndef CEF_INCLUDE_CEF_STREAM_H_ +#define CEF_INCLUDE_CEF_STREAM_H_ + +#include "include/cef_base.h" + +/// +// Interface the client can implement to provide a custom stream reader. The +// methods of this class may be called on any thread. +/// +/*--cef(source=client)--*/ +class CefReadHandler : public virtual CefBase { + public: + /// + // Read raw binary data. + /// + /*--cef()--*/ + virtual size_t Read(void* ptr, size_t size, size_t n) =0; + + /// + // Seek to the specified offset position. |whence| may be any one of + // SEEK_CUR, SEEK_END or SEEK_SET. Return zero on success and non-zero on + // failure. + /// + /*--cef()--*/ + virtual int Seek(int64 offset, int whence) =0; + + /// + // Return the current offset position. + /// + /*--cef()--*/ + virtual int64 Tell() =0; + + /// + // Return non-zero if at end of file. + /// + /*--cef()--*/ + virtual int Eof() =0; +}; + + +/// +// Class used to read data from a stream. The methods of this class may be +// called on any thread. +/// +/*--cef(source=library)--*/ +class CefStreamReader : public virtual CefBase { + public: + /// + // Create a new CefStreamReader object from a file. + /// + /*--cef()--*/ + static CefRefPtr CreateForFile(const CefString& fileName); + /// + // Create a new CefStreamReader object from data. + /// + /*--cef()--*/ + static CefRefPtr CreateForData(void* data, size_t size); + /// + // Create a new CefStreamReader object from a custom handler. + /// + /*--cef()--*/ + static CefRefPtr CreateForHandler( + CefRefPtr handler); + + /// + // Read raw binary data. + /// + /*--cef()--*/ + virtual size_t Read(void* ptr, size_t size, size_t n) =0; + + /// + // Seek to the specified offset position. |whence| may be any one of + // SEEK_CUR, SEEK_END or SEEK_SET. Returns zero on success and non-zero on + // failure. + /// + /*--cef()--*/ + virtual int Seek(int64 offset, int whence) =0; + + /// + // Return the current offset position. + /// + /*--cef()--*/ + virtual int64 Tell() =0; + + /// + // Return non-zero if at end of file. + /// + /*--cef()--*/ + virtual int Eof() =0; +}; + + +/// +// Interface the client can implement to provide a custom stream writer. The +// methods of this class may be called on any thread. +/// +/*--cef(source=client)--*/ +class CefWriteHandler : public virtual CefBase { + public: + /// + // Write raw binary data. + /// + /*--cef()--*/ + virtual size_t Write(const void* ptr, size_t size, size_t n) =0; + + /// + // Seek to the specified offset position. |whence| may be any one of + // SEEK_CUR, SEEK_END or SEEK_SET. Return zero on success and non-zero on + // failure. + /// + /*--cef()--*/ + virtual int Seek(int64 offset, int whence) =0; + + /// + // Return the current offset position. + /// + /*--cef()--*/ + virtual int64 Tell() =0; + + /// + // Flush the stream. + /// + /*--cef()--*/ + virtual int Flush() =0; +}; + + +/// +// Class used to write data to a stream. The methods of this class may be called +// on any thread. +/// +/*--cef(source=library)--*/ +class CefStreamWriter : public virtual CefBase { + public: + /// + // Create a new CefStreamWriter object for a file. + /// + /*--cef()--*/ + static CefRefPtr CreateForFile(const CefString& fileName); + /// + // Create a new CefStreamWriter object for a custom handler. + /// + /*--cef()--*/ + static CefRefPtr CreateForHandler( + CefRefPtr handler); + + /// + // Write raw binary data. + /// + /*--cef()--*/ + virtual size_t Write(const void* ptr, size_t size, size_t n) =0; + + /// + // Seek to the specified offset position. |whence| may be any one of + // SEEK_CUR, SEEK_END or SEEK_SET. Returns zero on success and non-zero on + // failure. + /// + /*--cef()--*/ + virtual int Seek(int64 offset, int whence) =0; + + /// + // Return the current offset position. + /// + /*--cef()--*/ + virtual int64 Tell() =0; + + /// + // Flush the stream. + /// + /*--cef()--*/ + virtual int Flush() =0; +}; + +#endif // CEF_INCLUDE_CEF_STREAM_H_ diff --git a/cef/include/cef_task.h b/cef/include/cef_task.h new file mode 100644 index 000000000..86550f6a0 --- /dev/null +++ b/cef/include/cef_task.h @@ -0,0 +1,89 @@ +// Copyright (c) 2011 Marshall A. Greenblatt. All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the name Chromium Embedded +// Framework nor the names of its contributors may be used to endorse +// or promote products derived from this software without specific prior +// written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +// --------------------------------------------------------------------------- +// +// The contents of this file must follow a specific format in order to +// support the CEF translator tool. See the translator.README.txt file in the +// tools directory for more information. +// + +#ifndef CEF_INCLUDE_CEF_TASK_H_ +#define CEF_INCLUDE_CEF_TASK_H_ + +#include "include/cef_base.h" + +class CefTask; + +typedef cef_thread_id_t CefThreadId; + +/// +// CEF maintains multiple internal threads that are used for handling different +// types of tasks. The UI thread creates the browser window and is used for all +// interaction with the WebKit rendering engine and V8 JavaScript engine (The +// UI thread will be the same as the main application thread if CefInitialize() +// is called with a CefSettings.multi_threaded_message_loop value of false.) The +// IO thread is used for handling schema and network requests. The FILE thread +// is used for the application cache and other miscellaneous activities. This +// function will return true if called on the specified thread. +/// +/*--cef()--*/ +bool CefCurrentlyOn(CefThreadId threadId); + +/// +// Post a task for execution on the specified thread. This function may be +// called on any thread. +/// +/*--cef()--*/ +bool CefPostTask(CefThreadId threadId, CefRefPtr task); + +/// +// Post a task for delayed execution on the specified thread. This function may +// be called on any thread. +/// +/*--cef()--*/ +bool CefPostDelayedTask(CefThreadId threadId, CefRefPtr task, + int64 delay_ms); + + +/// +// Implement this interface for task execution. The methods of this class may +// be called on any thread. +/// +/*--cef(source=client)--*/ +class CefTask : public virtual CefBase { + public: + /// + // Method that will be executed. |threadId| is the thread executing the call. + /// + /*--cef()--*/ + virtual void Execute(CefThreadId threadId) =0; +}; + +#endif // CEF_INCLUDE_CEF_TASK_H_ diff --git a/cef/include/cef_url.h b/cef/include/cef_url.h new file mode 100644 index 000000000..6caa1e229 --- /dev/null +++ b/cef/include/cef_url.h @@ -0,0 +1,60 @@ +// Copyright (c) 2011 Marshall A. Greenblatt. All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the name Chromium Embedded +// Framework nor the names of its contributors may be used to endorse +// or promote products derived from this software without specific prior +// written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +// --------------------------------------------------------------------------- +// +// The contents of this file must follow a specific format in order to +// support the CEF translator tool. See the translator.README.txt file in the +// tools directory for more information. +// + +#ifndef CEF_INCLUDE_CEF_URL_H_ +#define CEF_INCLUDE_CEF_URL_H_ +#pragma once + +#include "include/cef_base.h" + +/// +// Parse the specified |url| into its component parts. +// Returns false if the URL is empty or invalid. +/// +/*--cef()--*/ +bool CefParseURL(const CefString& url, + CefURLParts& parts); + +/// +// Creates a URL from the specified |parts|, which must contain a non-empty +// spec or a non-empty host and path (at a minimum), but not both. +// Returns false if |parts| isn't initialized as described. +/// +/*--cef()--*/ +bool CefCreateURL(const CefURLParts& parts, + CefString& url); + +#endif // CEF_INCLUDE_CEF_URL_H_ diff --git a/cef/include/cef_v8.h b/cef/include/cef_v8.h new file mode 100644 index 000000000..6024ce4a9 --- /dev/null +++ b/cef/include/cef_v8.h @@ -0,0 +1,618 @@ +// Copyright (c) 2011 Marshall A. Greenblatt. All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the name Chromium Embedded +// Framework nor the names of its contributors may be used to endorse +// or promote products derived from this software without specific prior +// written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +// --------------------------------------------------------------------------- +// +// The contents of this file must follow a specific format in order to +// support the CEF translator tool. See the translator.README.txt file in the +// tools directory for more information. +// + + +#ifndef CEF_INCLUDE_CEF_V8_H_ +#define CEF_INCLUDE_CEF_V8_H_ +#pragma once + +#include "include/cef_base.h" +#include "include/cef_browser.h" +#include "include/cef_frame.h" +#include + +class CefV8Handler; +class CefV8Value; + + +/// +// Register a new V8 extension with the specified JavaScript extension code and +// handler. Functions implemented by the handler are prototyped using the +// keyword 'native'. The calling of a native function is restricted to the scope +// in which the prototype of the native function is defined. This function may +// be called on any thread. +// +// Example JavaScript extension code: +// 
+//   // create the 'example' global object if it doesn't already exist.
+//   if (!example)
+//     example = {};
+//   // create the 'example.test' global object if it doesn't already exist.
+//   if (!example.test)
+//     example.test = {};
+//   (function() {
+//     // Define the function 'example.test.myfunction'.
+//     example.test.myfunction = function() {
+//       // Call CefV8Handler::Execute() with the function name 'MyFunction'
+//       // and no arguments.
+//       native function MyFunction();
+//       return MyFunction();
+//     };
+//     // Define the getter function for parameter 'example.test.myparam'.
+//     example.test.__defineGetter__('myparam', function() {
+//       // Call CefV8Handler::Execute() with the function name 'GetMyParam'
+//       // and no arguments.
+//       native function GetMyParam();
+//       return GetMyParam();
+//     });
+//     // Define the setter function for parameter 'example.test.myparam'.
+//     example.test.__defineSetter__('myparam', function(b) {
+//       // Call CefV8Handler::Execute() with the function name 'SetMyParam'
+//       // and a single argument.
+//       native function SetMyParam();
+//       if(b) SetMyParam(b);
+//     });
+//
+//     // Extension definitions can also contain normal JavaScript variables
+//     // and functions.
+//     var myint = 0;
+//     example.test.increment = function() {
+//       myint += 1;
+//       return myint;
+//     };
+//   })();
+//
+// Example usage in the page: +// 
+//   // Call the function.
+//   example.test.myfunction();
+//   // Set the parameter.
+//   example.test.myparam = value;
+//   // Get the parameter.
+//   value = example.test.myparam;
+//   // Call another function.
+//   example.test.increment();
+//
+/// +/*--cef(optional_param=handler)--*/ +bool CefRegisterExtension(const CefString& extension_name, + const CefString& javascript_code, + CefRefPtr handler); + + +/// +// Class that encapsulates a V8 context handle. +/// +/*--cef(source=library)--*/ +class CefV8Context : public virtual CefBase { + public: + /// + // Returns the current (top) context object in the V8 context stack. + /// + /*--cef()--*/ + static CefRefPtr GetCurrentContext(); + + /// + // Returns the entered (bottom) context object in the V8 context stack. + /// + /*--cef()--*/ + static CefRefPtr GetEnteredContext(); + + /// + // Returns true if V8 is currently inside a context. + /// + /*--cef()--*/ + static bool InContext(); + + /// + // Returns the browser for this context. + /// + /*--cef()--*/ + virtual CefRefPtr GetBrowser() =0; + + /// + // Returns the frame for this context. + /// + /*--cef()--*/ + virtual CefRefPtr GetFrame() =0; + + /// + // Returns the global object for this context. + /// + /*--cef()--*/ + virtual CefRefPtr GetGlobal() =0; + + /// + // Enter this context. A context must be explicitly entered before creating a + // V8 Object, Array or Function asynchronously. Exit() must be called the same + // number of times as Enter() before releasing this context. V8 objects belong + // to the context in which they are created. Returns true if the scope was + // entered successfully. + /// + /*--cef()--*/ + virtual bool Enter() =0; + + /// + // Exit this context. Call this method only after calling Enter(). Returns + // true if the scope was exited successfully. + /// + /*--cef()--*/ + virtual bool Exit() =0; + + /// + // Returns true if this object is pointing to the same handle as |that| + // object. + /// + /*--cef()--*/ + virtual bool IsSame(CefRefPtr that) =0; +}; + + +typedef std::vector > CefV8ValueList; + +/// +// Interface that should be implemented to handle V8 function calls. The methods +// of this class will always be called on the UI thread. +/// +/*--cef(source=client)--*/ +class CefV8Handler : public virtual CefBase { + public: + /// + // Handle execution of the function identified by |name|. |object| is the + // receiver ('this' object) of the function. |arguments| is the list of + // arguments passed to the function. If execution succeeds set |retval| to the + // function return value. If execution fails set |exception| to the exception + // that will be thrown. Return true if execution was handled. + /// + /*--cef()--*/ + virtual bool Execute(const CefString& name, + CefRefPtr object, + const CefV8ValueList& arguments, + CefRefPtr& retval, + CefString& exception) =0; +}; + +/// +// Interface that should be implemented to handle V8 accessor calls. Accessor +// identifiers are registered by calling CefV8Value::SetValue(). The methods +// of this class will always be called on the UI thread. +/// +/*--cef(source=client)--*/ +class CefV8Accessor : public virtual CefBase { + public: + /// + // Handle retrieval the accessor value identified by |name|. |object| is the + // receiver ('this' object) of the accessor. If retrieval succeeds set + // |retval| to the return value. If retrieval fails set |exception| to the + // exception that will be thrown. Return true if accessor retrieval was + // handled. + /// + /*--cef()--*/ + virtual bool Get(const CefString& name, + const CefRefPtr object, + CefRefPtr& retval, + CefString& exception) =0; + + /// + // Handle assignment of the accessor value identified by |name|. |object| is + // the receiver ('this' object) of the accessor. |value| is the new value + // being assigned to the accessor. If assignment fails set |exception| to the + // exception that will be thrown. Return true if accessor assignment was + // handled. + /// + /*--cef()--*/ + virtual bool Set(const CefString& name, + const CefRefPtr object, + const CefRefPtr value, + CefString& exception) =0; +}; + +/// +// Class representing a V8 exception. +/// +/*--cef(source=library)--*/ +class CefV8Exception : public virtual CefBase { + public: + /// + // Returns the exception message. + /// + /*--cef()--*/ + virtual CefString GetMessage() =0; + + /// + // Returns the line of source code that the exception occurred within. + /// + /*--cef()--*/ + virtual CefString GetSourceLine() =0; + + /// + // Returns the resource name for the script from where the function causing + // the error originates. + /// + /*--cef()--*/ + virtual CefString GetScriptResourceName() =0; + + /// + // Returns the 1-based number of the line where the error occurred or 0 if the + // line number is unknown. + /// + /*--cef()--*/ + virtual int GetLineNumber() =0; + + /// + // Returns the index within the script of the first character where the error + // occurred. + /// + /*--cef()--*/ + virtual int GetStartPosition() =0; + + /// + // Returns the index within the script of the last character where the error + // occurred. + /// + /*--cef()--*/ + virtual int GetEndPosition() =0; + + /// + // Returns the index within the line of the first character where the error + // occurred. + /// + /*--cef()--*/ + virtual int GetStartColumn() =0; + + /// + // Returns the index within the line of the last character where the error + // occurred. + /// + /*--cef()--*/ + virtual int GetEndColumn() =0; +}; + +/// +// Class representing a V8 value. The methods of this class should only be +// called on the UI thread. +/// +/*--cef(source=library)--*/ +class CefV8Value : public virtual CefBase { + public: + typedef cef_v8_accesscontrol_t AccessControl; + typedef cef_v8_propertyattribute_t PropertyAttribute; + + /// + // Create a new CefV8Value object of type undefined. + /// + /*--cef()--*/ + static CefRefPtr CreateUndefined(); + /// + // Create a new CefV8Value object of type null. + /// + /*--cef()--*/ + static CefRefPtr CreateNull(); + /// + // Create a new CefV8Value object of type bool. + /// + /*--cef()--*/ + static CefRefPtr CreateBool(bool value); + /// + // Create a new CefV8Value object of type int. + /// + /*--cef()--*/ + static CefRefPtr CreateInt(int value); + /// + // Create a new CefV8Value object of type double. + /// + /*--cef()--*/ + static CefRefPtr CreateDouble(double value); + /// + // Create a new CefV8Value object of type Date. + /// + /*--cef()--*/ + static CefRefPtr CreateDate(const CefTime& date); + /// + // Create a new CefV8Value object of type string. + /// + /*--cef(optional_param=value)--*/ + static CefRefPtr CreateString(const CefString& value); + /// + // Create a new CefV8Value object of type object with optional user data and + // accessor. This method should only be called from within the scope of a + // CefV8ContextHandler, CefV8Handler or CefV8Accessor callback, or in + // combination with calling Enter() and Exit() on a stored CefV8Context + // reference. + /// + /*--cef(capi_name=cef_v8value_create_object_with_accessor, + optional_param=user_data,optional_param=accessor)--*/ + static CefRefPtr CreateObject(CefRefPtr user_data, + CefRefPtr accessor); + /// + // Create a new CefV8Value object of type array. This method should only be + // called from within the scope of a CefV8ContextHandler, CefV8Handler or + // CefV8Accessor callback, or in combination with calling Enter() and Exit() + // on a stored CefV8Context reference. + /// + /*--cef()--*/ + static CefRefPtr CreateArray(); + /// + // Create a new CefV8Value object of type function. This method should only be + // called from within the scope of a CefV8ContextHandler, CefV8Handler or + // CefV8Accessor callback, or in combination with calling Enter() and Exit() + // on a stored CefV8Context reference. + /// + /*--cef()--*/ + static CefRefPtr CreateFunction(const CefString& name, + CefRefPtr handler); + + /// + // True if the value type is undefined. + /// + /*--cef()--*/ + virtual bool IsUndefined() =0; + /// + // True if the value type is null. + /// + /*--cef()--*/ + virtual bool IsNull() =0; + /// + // True if the value type is bool. + /// + /*--cef()--*/ + virtual bool IsBool() =0; + /// + // True if the value type is int. + /// + /*--cef()--*/ + virtual bool IsInt() =0; + /// + // True if the value type is double. + /// + /*--cef()--*/ + virtual bool IsDouble() =0; + /// + // True if the value type is Date. + /// + /*--cef()--*/ + virtual bool IsDate() =0; + /// + // True if the value type is string. + /// + /*--cef()--*/ + virtual bool IsString() =0; + /// + // True if the value type is object. + /// + /*--cef()--*/ + virtual bool IsObject() =0; + /// + // True if the value type is array. + /// + /*--cef()--*/ + virtual bool IsArray() =0; + /// + // True if the value type is function. + /// + /*--cef()--*/ + virtual bool IsFunction() =0; + + /// + // Returns true if this object is pointing to the same handle as |that| + // object. + /// + /*--cef()--*/ + virtual bool IsSame(CefRefPtr that) =0; + + /// + // Return a bool value. The underlying data will be converted to if + // necessary. + /// + /*--cef()--*/ + virtual bool GetBoolValue() =0; + /// + // Return an int value. The underlying data will be converted to if + // necessary. + /// + /*--cef()--*/ + virtual int GetIntValue() =0; + /// + // Return a double value. The underlying data will be converted to if + // necessary. + /// + /*--cef()--*/ + virtual double GetDoubleValue() =0; + /// + // Return a Date value. The underlying data will be converted to if + // necessary. + /// + /*--cef()--*/ + virtual CefTime GetDateValue() =0; + /// + // Return a string value. The underlying data will be converted to if + // necessary. + /// + /*--cef()--*/ + virtual CefString GetStringValue() =0; + + + // OBJECT METHODS - These methods are only available on objects. Arrays and + // functions are also objects. String- and integer-based keys can be used + // interchangably with the framework converting between them as necessary. + + /// + // Returns true if the object has a value with the specified identifier. + /// + /*--cef(capi_name=has_value_bykey)--*/ + virtual bool HasValue(const CefString& key) =0; + /// + // Returns true if the object has a value with the specified identifier. + /// + /*--cef(capi_name=has_value_byindex,index_param=index)--*/ + virtual bool HasValue(int index) =0; + + /// + // Delete the value with the specified identifier. + /// + /*--cef(capi_name=delete_value_bykey)--*/ + virtual bool DeleteValue(const CefString& key) =0; + /// + // Delete the value with the specified identifier. + /// + /*--cef(capi_name=delete_value_byindex,index_param=index)--*/ + virtual bool DeleteValue(int index) =0; + + /// + // Returns the value with the specified identifier. + /// + /*--cef(capi_name=get_value_bykey)--*/ + virtual CefRefPtr GetValue(const CefString& key) =0; + /// + // Returns the value with the specified identifier. + /// + /*--cef(capi_name=get_value_byindex,index_param=index)--*/ + virtual CefRefPtr GetValue(int index) =0; + + /// + // Associate a value with the specified identifier. + /// + /*--cef(capi_name=set_value_bykey)--*/ + virtual bool SetValue(const CefString& key, CefRefPtr value, + PropertyAttribute attribute) =0; + /// + // Associate a value with the specified identifier. + /// + /*--cef(capi_name=set_value_byindex,index_param=index)--*/ + virtual bool SetValue(int index, CefRefPtr value) =0; + + /// + // Register an identifier whose access will be forwarded to the CefV8Accessor + // instance passed to CefV8Value::CreateObject(). + /// + /*--cef(capi_name=set_value_byaccessor)--*/ + virtual bool SetValue(const CefString& key, AccessControl settings, + PropertyAttribute attribute) =0; + + /// + // Read the keys for the object's values into the specified vector. Integer- + // based keys will also be returned as strings. + /// + /*--cef()--*/ + virtual bool GetKeys(std::vector& keys) =0; + + /// + // Returns the user data, if any, specified when the object was created. + /// + /*--cef()--*/ + virtual CefRefPtr GetUserData() =0; + + /// + // Returns the amount of externally allocated memory registered for the + // object. + /// + /*--cef()--*/ + virtual int GetExternallyAllocatedMemory() =0; + + /// + // Adjusts the amount of registered external memory for the object. Used to + // give V8 an indication of the amount of externally allocated memory that is + // kept alive by JavaScript objects. V8 uses this information to decide when + // to perform global garbage collection. Each CefV8Value tracks the amount of + // external memory associated with it and automatically decreases the global + // total by the appropriate amount on its destruction. |change_in_bytes| + // specifies the number of bytes to adjust by. This method returns the number + // of bytes associated with the object after the adjustment. + /// + /*--cef()--*/ + virtual int AdjustExternallyAllocatedMemory(int change_in_bytes) =0; + + + // ARRAY METHODS - These methods are only available on arrays. + + /// + // Returns the number of elements in the array. + /// + /*--cef()--*/ + virtual int GetArrayLength() =0; + + + // FUNCTION METHODS - These methods are only available on functions. + + /// + // Returns the function name. + /// + /*--cef()--*/ + virtual CefString GetFunctionName() =0; + + /// + // Returns the function handler or NULL if not a CEF-created function. + /// + /*--cef()--*/ + virtual CefRefPtr GetFunctionHandler() =0; + + /// + // Execute the function using the current V8 context. This method should only + // be called from within the scope of a CefV8Handler or CefV8Accessor + // callback, or in combination with calling Enter() and Exit() on a stored + // CefV8Context reference. |object| is the receiver ('this' object) of the + // function. |arguments| is the list of arguments that will be passed to the + // function. If execution succeeds |retval| will be set to the function return + // value. If execution fails |exception| will be set to the exception that was + // thrown. If |rethrow_exception| is true any exception will also be re- + // thrown. This method returns false if called incorrectly. + /// + /*--cef(optional_param=object)--*/ + virtual bool ExecuteFunction(CefRefPtr object, + const CefV8ValueList& arguments, + CefRefPtr& retval, + CefRefPtr& exception, + bool rethrow_exception) =0; + + /// + // Execute the function using the specified V8 context. |object| is the + // receiver ('this' object) of the function. |arguments| is the list of + // arguments that will be passed to the function. If execution succeeds + // |retval| will be set to the function return value. If execution fails + // |exception| will be set to the exception that was thrown. If + // |rethrow_exception| is true any exception will also be re-thrown. This + // method returns false if called incorrectly. + /// + /*--cef(optional_param=object)--*/ + virtual bool ExecuteFunctionWithContext(CefRefPtr context, + CefRefPtr object, + const CefV8ValueList& arguments, + CefRefPtr& retval, + CefRefPtr& exception, + bool rethrow_exception) =0; +}; + +#endif // CEF_INCLUDE_CEF_V8_H_ diff --git a/cef/include/cef_v8context_handler.h b/cef/include/cef_v8context_handler.h new file mode 100644 index 000000000..5fd82da03 --- /dev/null +++ b/cef/include/cef_v8context_handler.h @@ -0,0 +1,73 @@ +// Copyright (c) 2011 Marshall A. Greenblatt. All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the name Chromium Embedded +// Framework nor the names of its contributors may be used to endorse +// or promote products derived from this software without specific prior +// written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +// --------------------------------------------------------------------------- +// +// The contents of this file must follow a specific format in order to +// support the CEF translator tool. See the translator.README.txt file in the +// tools directory for more information. +// + +#ifndef CEF_INCLUDE_CEF_V8CONTEXT_HANDLER_H_ +#define CEF_INCLUDE_CEF_V8CONTEXT_HANDLER_H_ +#pragma once + +#include "include/cef_base.h" +#include "include/cef_browser.h" +#include "include/cef_frame.h" +#include "include/cef_v8.h" + +/// +// Implement this interface to handle V8 context events. The methods of this +// class will be called on the UI thread. +/// +/*--cef(source=client)--*/ +class CefV8ContextHandler : public virtual CefBase { + public: + /// + // Called immediately after the V8 context for a frame has been created. To + // retrieve the JavaScript 'window' object use the CefV8Context::GetGlobal() + // method. + /// + /*--cef()--*/ + virtual void OnContextCreated(CefRefPtr browser, + CefRefPtr frame, + CefRefPtr context) {} + + /// + // Called immediately before the V8 context for a frame is released. No + // references to the context should be kept after this method is called. + /// + /*--cef()--*/ + virtual void OnContextReleased(CefRefPtr browser, + CefRefPtr frame, + CefRefPtr context) {} +}; + +#endif // CEF_INCLUDE_CEF_V8CONTEXT_HANDLER_H_ diff --git a/cef/include/cef_web_plugin.h b/cef/include/cef_web_plugin.h new file mode 100644 index 000000000..e00b2349b --- /dev/null +++ b/cef/include/cef_web_plugin.h @@ -0,0 +1,97 @@ +// Copyright (c) 2012 Marshall A. Greenblatt. All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the name Chromium Embedded +// Framework nor the names of its contributors may be used to endorse +// or promote products derived from this software without specific prior +// written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +// --------------------------------------------------------------------------- +// +// The contents of this file must follow a specific format in order to +// support the CEF translator tool. See the translator.README.txt file in the +// tools directory for more information. +// + +#ifndef CEF_INCLUDE_CEF_WEB_PLUGIN_H_ +#define CEF_INCLUDE_CEF_WEB_PLUGIN_H_ + +#include "include/cef_base.h" + +class CefWebPluginInfo; + +/// +// Returns the number of installed web plugins. This method must be called on +// the UI thread. +/// +/*--cef()--*/ +size_t CefGetWebPluginCount(); + +/// +// Returns information for web plugin at the specified zero-based index. This +// method must be called on the UI thread. +/// +/*--cef()--*/ +CefRefPtr CefGetWebPluginInfo(int index); + +/// +// Returns information for web plugin with the specified name. This method must +// be called on the UI thread. +/// +/*--cef(capi_name=cef_get_web_plugin_info_byname)--*/ +CefRefPtr CefGetWebPluginInfo(const CefString& name); + + +/// +// Information about a specific web plugin. +/// +/*--cef(source=library)--*/ +class CefWebPluginInfo : public virtual CefBase { + public: + /// + // Returns the plugin name (i.e. Flash). + /// + /*--cef()--*/ + virtual CefString GetName() =0; + + /// + // Returns the plugin file path (DLL/bundle/library). + /// + /*--cef()--*/ + virtual CefString GetPath() =0; + + /// + // Returns the version of the plugin (may be OS-specific). + /// + /*--cef()--*/ + virtual CefString GetVersion() =0; + + /// + // Returns a description of the plugin from the version information. + /// + /*--cef()--*/ + virtual CefString GetDescription() =0; +}; + +#endif // CEF_INCLUDE_CEF_WEB_PLUGIN_H_ diff --git a/cef/include/cef_web_urlrequest.h b/cef/include/cef_web_urlrequest.h new file mode 100644 index 000000000..c5f471f9a --- /dev/null +++ b/cef/include/cef_web_urlrequest.h @@ -0,0 +1,135 @@ +// Copyright (c) 2011 Marshall A. Greenblatt. All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the name Chromium Embedded +// Framework nor the names of its contributors may be used to endorse +// or promote products derived from this software without specific prior +// written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +// --------------------------------------------------------------------------- +// +// The contents of this file must follow a specific format in order to +// support the CEF translator tool. See the translator.README.txt file in the +// tools directory for more information. +// + +#ifndef CEF_INCLUDE_CEF_WEB_URLREQUEST_H_ +#define CEF_INCLUDE_CEF_WEB_URLREQUEST_H_ +#pragma once + +#include "include/cef_base.h" +#include "include/cef_request.h" +#include "include/cef_response.h" + +class CefWebURLRequestClient; + +/// +// Class used to make a Web URL request. Web URL requests are not associated +// with a browser instance so no CefClient callbacks will be executed. The +// methods of this class may be called on any thread. +/// +/*--cef(source=library)--*/ +class CefWebURLRequest : public virtual CefBase { + public: + typedef cef_weburlrequest_state_t RequestState; + + /// + // Create a new CefWebUrlRequest object. + /// + /*--cef()--*/ + static CefRefPtr CreateWebURLRequest( + CefRefPtr request, + CefRefPtr client); + + /// + // Cancels the request. + /// + /*--cef()--*/ + virtual void Cancel() =0; + + /// + // Returns the current ready state of the request. + /// + /*--cef(default_retval=WUR_STATE_UNSENT)--*/ + virtual RequestState GetState() =0; +}; + +/// +// Interface that should be implemented by the CefWebURLRequest client. The +// methods of this class will always be called on the UI thread. +/// +/*--cef(source=client)--*/ +class CefWebURLRequestClient : public virtual CefBase { + public: + typedef cef_weburlrequest_state_t RequestState; + typedef cef_handler_errorcode_t ErrorCode; + + /// + // Notifies the client that the request state has changed. State change + // notifications will always be sent before the below notification methods + // are called. + /// + /*--cef()--*/ + virtual void OnStateChange(CefRefPtr requester, + RequestState state) =0; + + /// + // Notifies the client that the request has been redirected and provides a + // chance to change the request parameters. + /// + /*--cef()--*/ + virtual void OnRedirect(CefRefPtr requester, + CefRefPtr request, + CefRefPtr response) =0; + + /// + // Notifies the client of the response data. + /// + /*--cef()--*/ + virtual void OnHeadersReceived(CefRefPtr requester, + CefRefPtr response) =0; + + /// + // Notifies the client of the upload progress. + /// + /*--cef()--*/ + virtual void OnProgress(CefRefPtr requester, + uint64 bytesSent, uint64 totalBytesToBeSent) =0; + + /// + // Notifies the client that content has been received. + /// + /*--cef()--*/ + virtual void OnData(CefRefPtr requester, + const void* data, int dataLength) =0; + + /// + // Notifies the client that the request ended with an error. + /// + /*--cef()--*/ + virtual void OnError(CefRefPtr requester, + ErrorCode errorCode) =0; +}; + +#endif // CEF_INCLUDE_CEF_WEB_URLREQUEST_H_ diff --git a/cef/include/cef_xml_reader.h b/cef/include/cef_xml_reader.h new file mode 100644 index 000000000..e457e0d8d --- /dev/null +++ b/cef/include/cef_xml_reader.h @@ -0,0 +1,268 @@ +// Copyright (c) 2011 Marshall A. Greenblatt. All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the name Chromium Embedded +// Framework nor the names of its contributors may be used to endorse +// or promote products derived from this software without specific prior +// written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +// --------------------------------------------------------------------------- +// +// The contents of this file must follow a specific format in order to +// support the CEF translator tool. See the translator.README.txt file in the +// tools directory for more information. +// + +#ifndef CEF_INCLUDE_CEF_XML_READER_H_ +#define CEF_INCLUDE_CEF_XML_READER_H_ +#pragma once + +#include "include/cef_base.h" +#include "include/cef_stream.h" + +/// +// Class that supports the reading of XML data via the libxml streaming API. +// The methods of this class should only be called on the thread that creates +// the object. +/// +/*--cef(source=library)--*/ +class CefXmlReader : public virtual CefBase { + public: + typedef cef_xml_encoding_type_t EncodingType; + typedef cef_xml_node_type_t NodeType; + + /// + // Create a new CefXmlReader object. The returned object's methods can only + // be called from the thread that created the object. + /// + /*--cef()--*/ + static CefRefPtr Create(CefRefPtr stream, + EncodingType encodingType, + const CefString& URI); + + /// + // Moves the cursor to the next node in the document. This method must be + // called at least once to set the current cursor position. Returns true if + // the cursor position was set successfully. + /// + /*--cef()--*/ + virtual bool MoveToNextNode() =0; + + /// + // Close the document. This should be called directly to ensure that cleanup + // occurs on the correct thread. + /// + /*--cef()--*/ + virtual bool Close() =0; + + /// + // Returns true if an error has been reported by the XML parser. + /// + /*--cef()--*/ + virtual bool HasError() =0; + + /// + // Returns the error string. + /// + /*--cef()--*/ + virtual CefString GetError() =0; + + + // The below methods retrieve data for the node at the current cursor + // position. + + /// + // Returns the node type. + /// + /*--cef(default_retval=XML_NODE_UNSUPPORTED)--*/ + virtual NodeType GetType() =0; + + /// + // Returns the node depth. Depth starts at 0 for the root node. + /// + /*--cef()--*/ + virtual int GetDepth() =0; + + /// + // Returns the local name. See + // http://www.w3.org/TR/REC-xml-names/#NT-LocalPart for additional details. + /// + /*--cef()--*/ + virtual CefString GetLocalName() =0; + + /// + // Returns the namespace prefix. See http://www.w3.org/TR/REC-xml-names/ for + // additional details. + /// + /*--cef()--*/ + virtual CefString GetPrefix() =0; + + /// + // Returns the qualified name, equal to (Prefix:)LocalName. See + // http://www.w3.org/TR/REC-xml-names/#ns-qualnames for additional details. + /// + /*--cef()--*/ + virtual CefString GetQualifiedName() =0; + + /// + // Returns the URI defining the namespace associated with the node. See + // http://www.w3.org/TR/REC-xml-names/ for additional details. + /// + /*--cef()--*/ + virtual CefString GetNamespaceURI() =0; + + /// + // Returns the base URI of the node. See http://www.w3.org/TR/xmlbase/ for + // additional details. + /// + /*--cef()--*/ + virtual CefString GetBaseURI() =0; + + /// + // Returns the xml:lang scope within which the node resides. See + // http://www.w3.org/TR/REC-xml/#sec-lang-tag for additional details. + /// + /*--cef()--*/ + virtual CefString GetXmlLang() =0; + + /// + // Returns true if the node represents an empty element. is considered + // empty but is not. + /// + /*--cef()--*/ + virtual bool IsEmptyElement() =0; + + /// + // Returns true if the node has a text value. + /// + /*--cef()--*/ + virtual bool HasValue() =0; + + /// + // Returns the text value. + /// + /*--cef()--*/ + virtual CefString GetValue() =0; + + /// + // Returns true if the node has attributes. + /// + /*--cef()--*/ + virtual bool HasAttributes() =0; + + /// + // Returns the number of attributes. + /// + /*--cef()--*/ + virtual size_t GetAttributeCount() =0; + + /// + // Returns the value of the attribute at the specified 0-based index. + /// + /*--cef(capi_name=get_attribute_byindex,index_param=index)--*/ + virtual CefString GetAttribute(int index) =0; + + /// + // Returns the value of the attribute with the specified qualified name. + /// + /*--cef(capi_name=get_attribute_byqname)--*/ + virtual CefString GetAttribute(const CefString& qualifiedName) =0; + + /// + // Returns the value of the attribute with the specified local name and + // namespace URI. + /// + /*--cef(capi_name=get_attribute_bylname)--*/ + virtual CefString GetAttribute(const CefString& localName, + const CefString& namespaceURI) =0; + + /// + // Returns an XML representation of the current node's children. + /// + /*--cef()--*/ + virtual CefString GetInnerXml() =0; + + /// + // Returns an XML representation of the current node including its children. + /// + /*--cef()--*/ + virtual CefString GetOuterXml() =0; + + /// + // Returns the line number for the current node. + /// + /*--cef()--*/ + virtual int GetLineNumber() =0; + + + // Attribute nodes are not traversed by default. The below methods can be + // used to move the cursor to an attribute node. MoveToCarryingElement() can + // be called afterwards to return the cursor to the carrying element. The + // depth of an attribute node will be 1 + the depth of the carrying element. + + /// + // Moves the cursor to the attribute at the specified 0-based index. Returns + // true if the cursor position was set successfully. + /// + /*--cef(capi_name=move_to_attribute_byindex,index_param=index)--*/ + virtual bool MoveToAttribute(int index) =0; + + /// + // Moves the cursor to the attribute with the specified qualified name. + // Returns true if the cursor position was set successfully. + /// + /*--cef(capi_name=move_to_attribute_byqname)--*/ + virtual bool MoveToAttribute(const CefString& qualifiedName) =0; + + /// + // Moves the cursor to the attribute with the specified local name and + // namespace URI. Returns true if the cursor position was set successfully. + /// + /*--cef(capi_name=move_to_attribute_bylname)--*/ + virtual bool MoveToAttribute(const CefString& localName, + const CefString& namespaceURI) =0; + + /// + // Moves the cursor to the first attribute in the current element. Returns + // true if the cursor position was set successfully. + /// + /*--cef()--*/ + virtual bool MoveToFirstAttribute() =0; + + /// + // Moves the cursor to the next attribute in the current element. Returns + // true if the cursor position was set successfully. + /// + /*--cef()--*/ + virtual bool MoveToNextAttribute() =0; + + /// + // Moves the cursor back to the carrying element. Returns true if the cursor + // position was set successfully. + /// + /*--cef()--*/ + virtual bool MoveToCarryingElement() =0; +}; + +#endif // CEF_INCLUDE_CEF_XML_READER_H_ diff --git a/cef/include/cef_zip_reader.h b/cef/include/cef_zip_reader.h new file mode 100644 index 000000000..9498f06ed --- /dev/null +++ b/cef/include/cef_zip_reader.h @@ -0,0 +1,141 @@ +// Copyright (c) 2011 Marshall A. Greenblatt. All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the name Chromium Embedded +// Framework nor the names of its contributors may be used to endorse +// or promote products derived from this software without specific prior +// written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +// --------------------------------------------------------------------------- +// +// The contents of this file must follow a specific format in order to +// support the CEF translator tool. See the translator.README.txt file in the +// tools directory for more information. +// + +#ifndef CEF_INCLUDE_CEF_ZIP_READER_H_ +#define CEF_INCLUDE_CEF_ZIP_READER_H_ + +#include "include/cef_base.h" +#include "include/cef_stream.h" + +/// +// Class that supports the reading of zip archives via the zlib unzip API. +// The methods of this class should only be called on the thread that creates +// the object. +/// +/*--cef(source=library)--*/ +class CefZipReader : public virtual CefBase { + public: + /// + // Create a new CefZipReader object. The returned object's methods can only + // be called from the thread that created the object. + /// + /*--cef()--*/ + static CefRefPtr Create(CefRefPtr stream); + + /// + // Moves the cursor to the first file in the archive. Returns true if the + // cursor position was set successfully. + /// + /*--cef()--*/ + virtual bool MoveToFirstFile() =0; + + /// + // Moves the cursor to the next file in the archive. Returns true if the + // cursor position was set successfully. + /// + /*--cef()--*/ + virtual bool MoveToNextFile() =0; + + /// + // Moves the cursor to the specified file in the archive. If |caseSensitive| + // is true then the search will be case sensitive. Returns true if the cursor + // position was set successfully. + /// + /*--cef()--*/ + virtual bool MoveToFile(const CefString& fileName, bool caseSensitive) =0; + + /// + // Closes the archive. This should be called directly to ensure that cleanup + // occurs on the correct thread. + /// + /*--cef()--*/ + virtual bool Close() =0; + + + // The below methods act on the file at the current cursor position. + + /// + // Returns the name of the file. + /// + /*--cef()--*/ + virtual CefString GetFileName() =0; + + /// + // Returns the uncompressed size of the file. + /// + /*--cef()--*/ + virtual int64 GetFileSize() =0; + + /// + // Returns the last modified timestamp for the file. + /// + /*--cef()--*/ + virtual time_t GetFileLastModified() =0; + + /// + // Opens the file for reading of uncompressed data. A read password may + // optionally be specified. + /// + /*--cef(optional_param=password)--*/ + virtual bool OpenFile(const CefString& password) =0; + + /// + // Closes the file. + /// + /*--cef()--*/ + virtual bool CloseFile() =0; + + /// + // Read uncompressed file contents into the specified buffer. Returns < 0 if + // an error occurred, 0 if at the end of file, or the number of bytes read. + /// + /*--cef()--*/ + virtual int ReadFile(void* buffer, size_t bufferSize) =0; + + /// + // Returns the current offset in the uncompressed file contents. + /// + /*--cef()--*/ + virtual int64 Tell() =0; + + /// + // Returns true if at end of the file contents. + /// + /*--cef()--*/ + virtual bool Eof() =0; +}; + +#endif // CEF_INCLUDE_CEF_ZIP_READER_H_ diff --git a/cef/include/wrapper/cef_byte_read_handler.h b/cef/include/wrapper/cef_byte_read_handler.h new file mode 100644 index 000000000..f7ca7a15a --- /dev/null +++ b/cef/include/wrapper/cef_byte_read_handler.h @@ -0,0 +1,88 @@ +// Copyright (c) 2011 Marshall A. Greenblatt. All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the name Chromium Embedded +// Framework nor the names of its contributors may be used to endorse +// or promote products derived from this software without specific prior +// written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +// --------------------------------------------------------------------------- +// +// The contents of this file are only available to applications that link +// against the libcef_dll_wrapper target. +// + +#ifndef CEF_INCLUDE_WRAPPER_CEF_BYTE_READ_HANDLER_H_ +#define CEF_INCLUDE_WRAPPER_CEF_BYTE_READ_HANDLER_H_ +#pragma once + +#include "include/cef_base.h" +#include "include/cef_stream.h" + +/// +// Thread safe implementation of the CefReadHandler class for reading an +// in-memory array of bytes. +/// +class CefByteReadHandler : public CefReadHandler { + public: + /// + // Create a new object for reading an array of bytes. An optional |source| + // reference can be kept to keep the underlying data source from being + // released while the reader exists. + /// + CefByteReadHandler(const unsigned char* bytes, size_t size, + CefRefPtr source); + + /// + // Read raw binary data. + /// + virtual size_t Read(void* ptr, size_t size, size_t n); + + /// + // Seek to the specified offset position. |whence| may be any one of + // SEEK_CUR, SEEK_END or SEEK_SET. + /// + virtual int Seek(int64 offset, int whence); + + /// + // Return the current offset position. + /// + virtual int64 Tell(); + + /// + // Return non-zero if at end of file. + /// + virtual int Eof(); + + private: + const unsigned char* bytes_; + int64 size_; + int64 offset_; + CefRefPtr source_; + + IMPLEMENT_REFCOUNTING(CefByteReadHandler); + IMPLEMENT_LOCKING(CefByteReadHandler); +}; + +#endif // CEF_INCLUDE_WRAPPER_CEF_BYTE_READ_HANDLER_H_ diff --git a/cef/include/wrapper/cef_xml_object.h b/cef/include/wrapper/cef_xml_object.h new file mode 100644 index 000000000..d9f706fde --- /dev/null +++ b/cef/include/wrapper/cef_xml_object.h @@ -0,0 +1,188 @@ +// Copyright (c) 2011 Marshall A. Greenblatt. All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the name Chromium Embedded +// Framework nor the names of its contributors may be used to endorse +// or promote products derived from this software without specific prior +// written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +// --------------------------------------------------------------------------- +// +// The contents of this file are only available to applications that link +// against the libcef_dll_wrapper target. +// + +#ifndef CEF_INCLUDE_WRAPPER_CEF_XML_OBJECT_H_ +#define CEF_INCLUDE_WRAPPER_CEF_XML_OBJECT_H_ +#pragma once + +#include "include/cef_base.h" +#include "include/cef_xml_reader.h" +#include +#include + +class CefStreamReader; + +/// +// Thread safe class for representing XML data as a structured object. This +// class should not be used with large XML documents because all data will be +// resident in memory at the same time. This implementation supports a +// restricted set of XML features: +// 
+// (1) Processing instructions, whitespace and comments are ignored.
+// (2) Elements and attributes must always be referenced using the fully
+//     qualified name (ie, namespace:localname).
+// (3) Empty elements () and elements with zero-length values ()
+//     are considered the same.
+// (4) Element nodes are considered part of a value if:
+//     (a) The element node follows a non-element node at the same depth
+//         (see 5), or
+//     (b) The element node does not have a namespace and the parent node does.
+// (5) Mixed node types at the same depth are combined into a single element
+//     value as follows:
+//     (a) All node values are concatenated to form a single string value.
+//     (b) Entity reference nodes are resolved to the corresponding entity
+//         value.
+//     (c) Element nodes are represented by their outer XML string.
+//
+/// +class CefXmlObject : public CefBase { + public: + typedef std::vector > ObjectVector; + typedef std::map AttributeMap; + + /// + // Create a new object with the specified name. An object name must always be + // at least one character long. + /// + explicit CefXmlObject(const CefString& name); + virtual ~CefXmlObject(); + + /// + // Load the contents of the specified XML stream into this object. The + // existing children and attributes, if any, will first be cleared. + /// + bool Load(CefRefPtr stream, + CefXmlReader::EncodingType encodingType, + const CefString& URI, CefString* loadError); + + /// + // Set the name, children and attributes of this object to a duplicate of the + // specified object's contents. The existing children and attributes, if any, + // will first be cleared. + /// + void Set(CefRefPtr object); + + /// + // Append a duplicate of the children and attributes of the specified object + // to this object. If |overwriteAttributes| is true then any attributes in + // this object that also exist in the specified object will be overwritten + // with the new values. The name of this object is not changed. + /// + void Append(CefRefPtr object, bool overwriteAttributes); + + /// + // Return a new object with the same name, children and attributes as this + // object. The parent of the new object will be NULL. + /// + CefRefPtr Duplicate(); + + /// + // Clears this object's children and attributes. The name and parenting of + // this object are not changed. + /// + void Clear(); + + /// + // Access the object's name. An object name must always be at least one + // character long. + /// + CefString GetName(); + bool SetName(const CefString& name); + + /// + // Access the object's parent. The parent can be NULL if this object has not + // been added as the child on another object. + /// + bool HasParent(); + CefRefPtr GetParent(); + + /// + // Access the object's value. An object cannot have a value if it also has + // children. Attempting to set the value while children exist will fail. + /// + bool HasValue(); + CefString GetValue(); + bool SetValue(const CefString& value); + + /// + // Access the object's attributes. Attributes must have unique names. + /// + bool HasAttributes(); + size_t GetAttributeCount(); + bool HasAttribute(const CefString& name); + CefString GetAttributeValue(const CefString& name); + bool SetAttributeValue(const CefString& name, const CefString& value); + size_t GetAttributes(AttributeMap& attributes); + void ClearAttributes(); + + /// + // Access the object's children. Each object can only have one parent so + // attempting to add an object that already has a parent will fail. Removing a + // child will set the child's parent to NULL. Adding a child will set the + // child's parent to this object. This object's value, if any, will be cleared + // if a child is added. + /// + bool HasChildren(); + size_t GetChildCount(); + bool HasChild(CefRefPtr child); + bool AddChild(CefRefPtr child); + bool RemoveChild(CefRefPtr child); + size_t GetChildren(ObjectVector& children); + void ClearChildren(); + + /// + // Find the first child with the specified name. + /// + CefRefPtr FindChild(const CefString& name); + + /// + // Find all children with the specified name. + /// + size_t FindChildren(const CefString& name, ObjectVector& children); + + private: + void SetParent(CefXmlObject* parent); + + CefString name_; + CefXmlObject* parent_; + CefString value_; + AttributeMap attributes_; + ObjectVector children_; + + IMPLEMENT_REFCOUNTING(CefXmlObject); + IMPLEMENT_LOCKING(CefXmlObject); +}; + +#endif // CEF_INCLUDE_WRAPPER_CEF_XML_OBJECT_H_ diff --git a/cef/include/wrapper/cef_zip_archive.h b/cef/include/wrapper/cef_zip_archive.h new file mode 100644 index 000000000..b58dbca01 --- /dev/null +++ b/cef/include/wrapper/cef_zip_archive.h @@ -0,0 +1,132 @@ +// Copyright (c) 2011 Marshall A. Greenblatt. All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the name Chromium Embedded +// Framework nor the names of its contributors may be used to endorse +// or promote products derived from this software without specific prior +// written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +// --------------------------------------------------------------------------- +// +// The contents of this file are only available to applications that link +// against the libcef_dll_wrapper target. +// + +#ifndef CEF_INCLUDE_WRAPPER_CEF_ZIP_ARCHIVE_H_ +#define CEF_INCLUDE_WRAPPER_CEF_ZIP_ARCHIVE_H_ +#pragma once + +#include "include/cef_base.h" +#include + +class CefStreamReader; + +/// +// Thread-safe class for accessing zip archive file contents. This class should +// not be used with large archive files because all data will be resident in +// memory at the same time. This implementation supports a restricted set of zip +// archive features: +// (1) Password-protected files are not supported. +// (2) All file names are stored and compared in lower case. +// (3) File ordering from the original zip archive is not maintained. This +// means that files from the same folder may not be located together in the +// file content map. +/// +class CefZipArchive : public CefBase { + public: + /// + // Class representing a file in the archive. Accessing the file data from + // multiple threads is safe provided a reference to the File object is kept. + /// + class File : public CefBase { + public: + /// + // Returns the read-only data contained in the file. + /// + virtual const unsigned char* GetData() =0; + + /// + // Returns the size of the data in the file. + /// + virtual size_t GetDataSize() =0; + + /// + // Returns a CefStreamReader object for streaming the contents of the file. + /// + virtual CefRefPtr GetStreamReader() =0; + }; + typedef std::map > FileMap; + + /// + // Create a new object. + /// + CefZipArchive(); + virtual ~CefZipArchive(); + + /// + // Load the contents of the specified zip archive stream into this object. + // If |overwriteExisting| is true then any files in this object that also + // exist in the specified archive will be replaced with the new files. + // Returns the number of files successfully loaded. + /// + size_t Load(CefRefPtr stream, bool overwriteExisting); + + /// + // Clears the contents of this object. + /// + void Clear(); + + /// + // Returns the number of files in the archive. + /// + size_t GetFileCount(); + + /// + // Returns true if the specified file exists and has contents. + /// + bool HasFile(const CefString& fileName); + + /// + // Returns the specified file. + /// + CefRefPtr GetFile(const CefString& fileName); + + /// + // Removes the specified file. + /// + bool RemoveFile(const CefString& fileName); + + /// + // Returns the map of all files. + /// + size_t GetFiles(FileMap& map); + + private: + FileMap contents_; + + IMPLEMENT_REFCOUNTING(CefZipArchive); + IMPLEMENT_LOCKING(CefZipArchive); +}; + +#endif // CEF_INCLUDE_WRAPPER_CEF_ZIP_ARCHIVE_H_ diff --git a/cef/libcef_dll/cpptoc/permission_handler_cpptoc.cc b/cef/libcef_dll/cpptoc/permission_handler_cpptoc.cc new file mode 100644 index 000000000..5558de8eb --- /dev/null +++ b/cef/libcef_dll/cpptoc/permission_handler_cpptoc.cc @@ -0,0 +1,67 @@ +// Copyright (c) 2012 The Chromium Embedded Framework Authors. All rights +// reserved. Use of this source code is governed by a BSD-style license that +// can be found in the LICENSE file. +// +// --------------------------------------------------------------------------- +// +// This file was generated by the CEF translator tool. If making changes by +// hand only do so within the body of existing method and function +// implementations. See the translator.README.txt file in the tools directory +// for more information. +// + +#include "libcef_dll/cpptoc/permission_handler_cpptoc.h" +#include "libcef_dll/ctocpp/browser_ctocpp.h" +#include "libcef_dll/ctocpp/frame_ctocpp.h" + + +// MEMBER FUNCTIONS - Body may be edited by hand. + +int CEF_CALLBACK permission_handler_on_before_script_extension_load( + struct _cef_permission_handler_t* self, cef_browser_t* browser, + cef_frame_t* frame, const cef_string_t* extensionName) { + // AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING + + DCHECK(self); + if (!self) + return 0; + // Verify param: browser; type: refptr_diff + DCHECK(browser); + if (!browser) + return 0; + // Verify param: frame; type: refptr_diff + DCHECK(frame); + if (!frame) + return 0; + // Verify param: extensionName; type: string_byref_const + DCHECK(extensionName); + if (!extensionName) + return 0; + + // Execute + bool _retval = CefPermissionHandlerCppToC::Get( + self)->OnBeforeScriptExtensionLoad( + CefBrowserCToCpp::Wrap(browser), + CefFrameCToCpp::Wrap(frame), + CefString(extensionName)); + + // Return type: bool + return _retval; +} + + +// CONSTRUCTOR - Do not edit by hand. + +CefPermissionHandlerCppToC::CefPermissionHandlerCppToC( + CefPermissionHandler* cls) + : CefCppToC(cls) { + struct_.struct_.on_before_script_extension_load = + permission_handler_on_before_script_extension_load; +} + +#ifndef NDEBUG +template<> long CefCppToC::DebugObjCt = 0; +#endif + diff --git a/cef/libcef_dll/cpptoc/permission_handler_cpptoc.h b/cef/libcef_dll/cpptoc/permission_handler_cpptoc.h new file mode 100644 index 000000000..a7e2f44af --- /dev/null +++ b/cef/libcef_dll/cpptoc/permission_handler_cpptoc.h @@ -0,0 +1,37 @@ +// Copyright (c) 2012 The Chromium Embedded Framework Authors. All rights +// reserved. Use of this source code is governed by a BSD-style license that +// can be found in the LICENSE file. +// +// --------------------------------------------------------------------------- +// +// This file was generated by the CEF translator tool. If making changes by +// hand only do so within the body of existing method and function +// implementations. See the translator.README.txt file in the tools directory +// for more information. +// + +#ifndef CEF_LIBCEF_DLL_CPPTOC_PERMISSION_HANDLER_CPPTOC_H_ +#define CEF_LIBCEF_DLL_CPPTOC_PERMISSION_HANDLER_CPPTOC_H_ +#pragma once + +#ifndef USING_CEF_SHARED +#pragma message("Warning: "__FILE__" may be accessed wrapper-side only") +#else // USING_CEF_SHARED + +#include "include/cef_permission_handler.h" +#include "include/capi/cef_permission_handler_capi.h" +#include "libcef_dll/cpptoc/cpptoc.h" + +// Wrap a C++ class with a C structure. +// This class may be instantiated and accessed wrapper-side only. +class CefPermissionHandlerCppToC + : public CefCppToC { + public: + explicit CefPermissionHandlerCppToC(CefPermissionHandler* cls); + virtual ~CefPermissionHandlerCppToC() {} +}; + +#endif // USING_CEF_SHARED +#endif // CEF_LIBCEF_DLL_CPPTOC_PERMISSION_HANDLER_CPPTOC_H_ + diff --git a/cef/libcef_dll/cpptoc/resource_bundle_handler_cpptoc.cc b/cef/libcef_dll/cpptoc/resource_bundle_handler_cpptoc.cc new file mode 100644 index 000000000..23dd259b3 --- /dev/null +++ b/cef/libcef_dll/cpptoc/resource_bundle_handler_cpptoc.cc @@ -0,0 +1,98 @@ +// Copyright (c) 2012 The Chromium Embedded Framework Authors. All rights +// reserved. Use of this source code is governed by a BSD-style license that +// can be found in the LICENSE file. +// +// --------------------------------------------------------------------------- +// +// This file was generated by the CEF translator tool. If making changes by +// hand only do so within the body of existing method and function +// implementations. See the translator.README.txt file in the tools directory +// for more information. +// + +#include "libcef_dll/cpptoc/resource_bundle_handler_cpptoc.h" + + +// MEMBER FUNCTIONS - Body may be edited by hand. + +int CEF_CALLBACK resource_bundle_handler_get_localized_string( + struct _cef_resource_bundle_handler_t* self, int message_id, + cef_string_t* string) { + // AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING + + DCHECK(self); + if (!self) + return 0; + // Verify param: string; type: string_byref + DCHECK(string); + if (!string) + return 0; + + // Translate param: string; type: string_byref + CefString stringStr(string); + + // Execute + bool _retval = CefResourceBundleHandlerCppToC::Get(self)->GetLocalizedString( + message_id, + stringStr); + + // Return type: bool + return _retval; +} + +int CEF_CALLBACK resource_bundle_handler_get_data_resource( + struct _cef_resource_bundle_handler_t* self, int resource_id, void** data, + size_t* data_size) { + // AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING + + DCHECK(self); + if (!self) + return 0; + // Verify param: data; type: simple_byref + DCHECK(data); + if (!data) + return 0; + // Verify param: data_size; type: simple_byref + DCHECK(data_size); + if (!data_size) + return 0; + + // Translate param: data; type: simple_byref + void* dataVal = data?*data:NULL; + // Translate param: data_size; type: simple_byref + size_t data_sizeVal = data_size?*data_size:0; + + // Execute + bool _retval = CefResourceBundleHandlerCppToC::Get(self)->GetDataResource( + resource_id, + dataVal, + data_sizeVal); + + // Restore param: data; type: simple_byref + if (data) + *data = dataVal; + // Restore param: data_size; type: simple_byref + if (data_size) + *data_size = data_sizeVal; + + // Return type: bool + return _retval; +} + + +// CONSTRUCTOR - Do not edit by hand. + +CefResourceBundleHandlerCppToC::CefResourceBundleHandlerCppToC( + CefResourceBundleHandler* cls) + : CefCppToC(cls) { + struct_.struct_.get_localized_string = + resource_bundle_handler_get_localized_string; + struct_.struct_.get_data_resource = resource_bundle_handler_get_data_resource; +} + +#ifndef NDEBUG +template<> long CefCppToC::DebugObjCt = 0; +#endif + diff --git a/cef/libcef_dll/cpptoc/resource_bundle_handler_cpptoc.h b/cef/libcef_dll/cpptoc/resource_bundle_handler_cpptoc.h new file mode 100644 index 000000000..3b11fb62c --- /dev/null +++ b/cef/libcef_dll/cpptoc/resource_bundle_handler_cpptoc.h @@ -0,0 +1,37 @@ +// Copyright (c) 2012 The Chromium Embedded Framework Authors. All rights +// reserved. Use of this source code is governed by a BSD-style license that +// can be found in the LICENSE file. +// +// --------------------------------------------------------------------------- +// +// This file was generated by the CEF translator tool. If making changes by +// hand only do so within the body of existing method and function +// implementations. See the translator.README.txt file in the tools directory +// for more information. +// + +#ifndef CEF_LIBCEF_DLL_CPPTOC_RESOURCE_BUNDLE_HANDLER_CPPTOC_H_ +#define CEF_LIBCEF_DLL_CPPTOC_RESOURCE_BUNDLE_HANDLER_CPPTOC_H_ +#pragma once + +#ifndef USING_CEF_SHARED +#pragma message("Warning: "__FILE__" may be accessed wrapper-side only") +#else // USING_CEF_SHARED + +#include "include/cef_resource_bundle_handler.h" +#include "include/capi/cef_resource_bundle_handler_capi.h" +#include "libcef_dll/cpptoc/cpptoc.h" + +// Wrap a C++ class with a C structure. +// This class may be instantiated and accessed wrapper-side only. +class CefResourceBundleHandlerCppToC + : public CefCppToC { + public: + explicit CefResourceBundleHandlerCppToC(CefResourceBundleHandler* cls); + virtual ~CefResourceBundleHandlerCppToC() {} +}; + +#endif // USING_CEF_SHARED +#endif // CEF_LIBCEF_DLL_CPPTOC_RESOURCE_BUNDLE_HANDLER_CPPTOC_H_ + diff --git a/cef/libcef_dll/ctocpp/cookie_manager_ctocpp.cc b/cef/libcef_dll/ctocpp/cookie_manager_ctocpp.cc new file mode 100644 index 000000000..f33ef0d7d --- /dev/null +++ b/cef/libcef_dll/ctocpp/cookie_manager_ctocpp.cc @@ -0,0 +1,175 @@ +// Copyright (c) 2012 The Chromium Embedded Framework Authors. All rights +// reserved. Use of this source code is governed by a BSD-style license that +// can be found in the LICENSE file. +// +// --------------------------------------------------------------------------- +// +// This file was generated by the CEF translator tool. If making changes by +// hand only do so within the body of existing method and function +// implementations. See the translator.README.txt file in the tools directory +// for more information. +// + +#include "libcef_dll/cpptoc/cookie_visitor_cpptoc.h" +#include "libcef_dll/ctocpp/cookie_manager_ctocpp.h" +#include "libcef_dll/transfer_util.h" + + +// STATIC METHODS - Body may be edited by hand. + +CefRefPtr CefCookieManager::GetGlobalManager() { + // AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING + + // Execute + cef_cookie_manager_t* _retval = cef_cookie_manager_get_global_manager(); + + // Return type: refptr_same + return CefCookieManagerCToCpp::Wrap(_retval); +} + +CefRefPtr CefCookieManager::CreateManager( + const CefString& path) { + // AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING + + // Unverified params: path + + // Execute + cef_cookie_manager_t* _retval = cef_cookie_manager_create_manager( + path.GetStruct()); + + // Return type: refptr_same + return CefCookieManagerCToCpp::Wrap(_retval); +} + + +// VIRTUAL METHODS - Body may be edited by hand. + +void CefCookieManagerCToCpp::SetSupportedSchemes( + const std::vector& schemes) { + if (CEF_MEMBER_MISSING(struct_, set_supported_schemes)) + return; + + // AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING + + // Translate param: schemes; type: string_vec_byref_const + cef_string_list_t schemesList = cef_string_list_alloc(); + DCHECK(schemesList); + if (schemesList) + transfer_string_list_contents(schemes, schemesList); + + // Execute + struct_->set_supported_schemes(struct_, + schemesList); + + // Restore param:schemes; type: string_vec_byref_const + if (schemesList) + cef_string_list_free(schemesList); +} + +bool CefCookieManagerCToCpp::VisitAllCookies( + CefRefPtr visitor) { + if (CEF_MEMBER_MISSING(struct_, visit_all_cookies)) + return false; + + // AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING + + // Verify param: visitor; type: refptr_diff + DCHECK(visitor.get()); + if (!visitor.get()) + return false; + + // Execute + int _retval = struct_->visit_all_cookies(struct_, + CefCookieVisitorCppToC::Wrap(visitor)); + + // Return type: bool + return _retval?true:false; +} + +bool CefCookieManagerCToCpp::VisitUrlCookies(const CefString& url, + bool includeHttpOnly, CefRefPtr visitor) { + if (CEF_MEMBER_MISSING(struct_, visit_url_cookies)) + return false; + + // AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING + + // Verify param: url; type: string_byref_const + DCHECK(!url.empty()); + if (url.empty()) + return false; + // Verify param: visitor; type: refptr_diff + DCHECK(visitor.get()); + if (!visitor.get()) + return false; + + // Execute + int _retval = struct_->visit_url_cookies(struct_, + url.GetStruct(), + includeHttpOnly, + CefCookieVisitorCppToC::Wrap(visitor)); + + // Return type: bool + return _retval?true:false; +} + +bool CefCookieManagerCToCpp::SetCookie(const CefString& url, + const CefCookie& cookie) { + if (CEF_MEMBER_MISSING(struct_, set_cookie)) + return false; + + // AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING + + // Verify param: url; type: string_byref_const + DCHECK(!url.empty()); + if (url.empty()) + return false; + + // Execute + int _retval = struct_->set_cookie(struct_, + url.GetStruct(), + &cookie); + + // Return type: bool + return _retval?true:false; +} + +bool CefCookieManagerCToCpp::DeleteCookies(const CefString& url, + const CefString& cookie_name) { + if (CEF_MEMBER_MISSING(struct_, delete_cookies)) + return false; + + // AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING + + // Unverified params: url, cookie_name + + // Execute + int _retval = struct_->delete_cookies(struct_, + url.GetStruct(), + cookie_name.GetStruct()); + + // Return type: bool + return _retval?true:false; +} + +bool CefCookieManagerCToCpp::SetStoragePath(const CefString& path) { + if (CEF_MEMBER_MISSING(struct_, set_storage_path)) + return false; + + // AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING + + // Unverified params: path + + // Execute + int _retval = struct_->set_storage_path(struct_, + path.GetStruct()); + + // Return type: bool + return _retval?true:false; +} + + +#ifndef NDEBUG +template<> long CefCToCpp::DebugObjCt = 0; +#endif + diff --git a/cef/libcef_dll/ctocpp/cookie_manager_ctocpp.h b/cef/libcef_dll/ctocpp/cookie_manager_ctocpp.h new file mode 100644 index 000000000..78cd1f460 --- /dev/null +++ b/cef/libcef_dll/ctocpp/cookie_manager_ctocpp.h @@ -0,0 +1,52 @@ +// Copyright (c) 2012 The Chromium Embedded Framework Authors. All rights +// reserved. Use of this source code is governed by a BSD-style license that +// can be found in the LICENSE file. +// +// --------------------------------------------------------------------------- +// +// This file was generated by the CEF translator tool. If making changes by +// hand only do so within the body of existing method and function +// implementations. See the translator.README.txt file in the tools directory +// for more information. +// + +#ifndef CEF_LIBCEF_DLL_CTOCPP_COOKIE_MANAGER_CTOCPP_H_ +#define CEF_LIBCEF_DLL_CTOCPP_COOKIE_MANAGER_CTOCPP_H_ +#pragma once + +#ifndef USING_CEF_SHARED +#pragma message("Warning: "__FILE__" may be accessed wrapper-side only") +#else // USING_CEF_SHARED + +#include +#include "include/cef_cookie.h" +#include "include/capi/cef_cookie_capi.h" +#include "libcef_dll/ctocpp/ctocpp.h" + +// Wrap a C structure with a C++ class. +// This class may be instantiated and accessed wrapper-side only. +class CefCookieManagerCToCpp + : public CefCToCpp { + public: + explicit CefCookieManagerCToCpp(cef_cookie_manager_t* str) + : CefCToCpp(str) {} + virtual ~CefCookieManagerCToCpp() {} + + // CefCookieManager methods + virtual void SetSupportedSchemes( + const std::vector& schemes) OVERRIDE; + virtual bool VisitAllCookies(CefRefPtr visitor) OVERRIDE; + virtual bool VisitUrlCookies(const CefString& url, bool includeHttpOnly, + CefRefPtr visitor) OVERRIDE; + virtual bool SetCookie(const CefString& url, + const CefCookie& cookie) OVERRIDE; + virtual bool DeleteCookies(const CefString& url, + const CefString& cookie_name) OVERRIDE; + virtual bool SetStoragePath(const CefString& path) OVERRIDE; +}; + +#endif // USING_CEF_SHARED +#endif // CEF_LIBCEF_DLL_CTOCPP_COOKIE_MANAGER_CTOCPP_H_ + diff --git a/cef/libcef_dll/ctocpp/web_plugin_info_ctocpp.cc b/cef/libcef_dll/ctocpp/web_plugin_info_ctocpp.cc new file mode 100644 index 000000000..4c814e969 --- /dev/null +++ b/cef/libcef_dll/ctocpp/web_plugin_info_ctocpp.cc @@ -0,0 +1,83 @@ +// Copyright (c) 2012 The Chromium Embedded Framework Authors. All rights +// reserved. Use of this source code is governed by a BSD-style license that +// can be found in the LICENSE file. +// +// --------------------------------------------------------------------------- +// +// This file was generated by the CEF translator tool. If making changes by +// hand only do so within the body of existing method and function +// implementations. See the translator.README.txt file in the tools directory +// for more information. +// + +#include "libcef_dll/ctocpp/web_plugin_info_ctocpp.h" + + +// VIRTUAL METHODS - Body may be edited by hand. + +CefString CefWebPluginInfoCToCpp::GetName() { + if (CEF_MEMBER_MISSING(struct_, get_name)) + return CefString(); + + // AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING + + // Execute + cef_string_userfree_t _retval = struct_->get_name(struct_); + + // Return type: string + CefString _retvalStr; + _retvalStr.AttachToUserFree(_retval); + return _retvalStr; +} + +CefString CefWebPluginInfoCToCpp::GetPath() { + if (CEF_MEMBER_MISSING(struct_, get_path)) + return CefString(); + + // AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING + + // Execute + cef_string_userfree_t _retval = struct_->get_path(struct_); + + // Return type: string + CefString _retvalStr; + _retvalStr.AttachToUserFree(_retval); + return _retvalStr; +} + +CefString CefWebPluginInfoCToCpp::GetVersion() { + if (CEF_MEMBER_MISSING(struct_, get_version)) + return CefString(); + + // AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING + + // Execute + cef_string_userfree_t _retval = struct_->get_version(struct_); + + // Return type: string + CefString _retvalStr; + _retvalStr.AttachToUserFree(_retval); + return _retvalStr; +} + +CefString CefWebPluginInfoCToCpp::GetDescription() { + if (CEF_MEMBER_MISSING(struct_, get_description)) + return CefString(); + + // AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING + + // Execute + cef_string_userfree_t _retval = struct_->get_description(struct_); + + // Return type: string + CefString _retvalStr; + _retvalStr.AttachToUserFree(_retval); + return _retvalStr; +} + + +#ifndef NDEBUG +template<> long CefCToCpp::DebugObjCt = 0; +#endif + diff --git a/cef/libcef_dll/ctocpp/web_plugin_info_ctocpp.h b/cef/libcef_dll/ctocpp/web_plugin_info_ctocpp.h new file mode 100644 index 000000000..b8bd1cbf0 --- /dev/null +++ b/cef/libcef_dll/ctocpp/web_plugin_info_ctocpp.h @@ -0,0 +1,45 @@ +// Copyright (c) 2012 The Chromium Embedded Framework Authors. All rights +// reserved. Use of this source code is governed by a BSD-style license that +// can be found in the LICENSE file. +// +// --------------------------------------------------------------------------- +// +// This file was generated by the CEF translator tool. If making changes by +// hand only do so within the body of existing method and function +// implementations. See the translator.README.txt file in the tools directory +// for more information. +// + +#ifndef CEF_LIBCEF_DLL_CTOCPP_WEB_PLUGIN_INFO_CTOCPP_H_ +#define CEF_LIBCEF_DLL_CTOCPP_WEB_PLUGIN_INFO_CTOCPP_H_ +#pragma once + +#ifndef USING_CEF_SHARED +#pragma message("Warning: "__FILE__" may be accessed wrapper-side only") +#else // USING_CEF_SHARED + +#include "include/cef_web_plugin.h" +#include "include/capi/cef_web_plugin_capi.h" +#include "libcef_dll/ctocpp/ctocpp.h" + +// Wrap a C structure with a C++ class. +// This class may be instantiated and accessed wrapper-side only. +class CefWebPluginInfoCToCpp + : public CefCToCpp { + public: + explicit CefWebPluginInfoCToCpp(cef_web_plugin_info_t* str) + : CefCToCpp(str) {} + virtual ~CefWebPluginInfoCToCpp() {} + + // CefWebPluginInfo methods + virtual CefString GetName() OVERRIDE; + virtual CefString GetPath() OVERRIDE; + virtual CefString GetVersion() OVERRIDE; + virtual CefString GetDescription() OVERRIDE; +}; + +#endif // USING_CEF_SHARED +#endif // CEF_LIBCEF_DLL_CTOCPP_WEB_PLUGIN_INFO_CTOCPP_H_ +