pax_global_header00006660000000000000000000000064133410326630014513gustar00rootroot0000000000000052 comment=90deb4fc37528394e8cecb95317a5c4cb81fcac4 cefpython-49.0/000077500000000000000000000000001334103266300134465ustar00rootroot00000000000000cefpython-49.0/.github/000077500000000000000000000000001334103266300150065ustar00rootroot00000000000000cefpython-49.0/.github/CONTRIBUTING.md000066400000000000000000000003511334103266300172360ustar00rootroot00000000000000Please do not create Issues. Issues must first be discussed and confirmed on the Forum. Report issues on the Forum here: https://goo.gl/xz4cEF Please do not ask questions in existing issues. Ask questions on the Forum, link above. cefpython-49.0/.github/ISSUE_TEMPLATE.md000066400000000000000000000003711334103266300175140ustar00rootroot00000000000000Please do not create Issues using this form. Issues must first be discussed and confirmed on the Forum. Report issues on the Forum here: https://goo.gl/xz4cEF Please do not ask questions in existing issues. Ask questions on the Forum, link above. cefpython-49.0/.gitignore000066400000000000000000000002121334103266300154310ustar00rootroot00000000000000.idea/ build/ *.log __pycache__/ *.pyc cefclient webcache/ examples/screenshot.png examples/pyinstaller/build/ examples/pyinstaller/dist/ cefpython-49.0/Authors000066400000000000000000000007531334103266300150230ustar00rootroot00000000000000Core developers: Czarek Tomczak Contributors: 老农 cjjer Richard Rodriguez Roman Plášil Rokas Stupuras Greg Kacy Thomas Dähling Dominique Burnand Greg Farrell Finn Hughes Marcelo Fernandez Simon Hatt <9hatt2@@gmail.com> cefpython-49.0/License000066400000000000000000000035231334103266300147560ustar00rootroot00000000000000Copyright (c) 2012 The CEF Python authors - see the Authors file. All rights reserved. Licensed under the BSD 3-clause license. See project website: https://github.com/cztomczak/cefpython This product includes the following third party libraries: * Chromium Embedded Framework licensed under the BSD 3-clause license. Website: https://bitbucket.org/chromiumembedded/cef 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 name of CEF Python 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. cefpython-49.0/README.md000066400000000000000000001063651334103266300147400ustar00rootroot00000000000000## About 'cefpython49-winxp' branch This is a special branch of Chromium v49 for Windows only with Windows XP and Vista support. This is the latest version of Chromium that supports Windows XP. This cefpython branch was forked from cefpython57 branch. # CEF Python Table of contents: * [About 'cefpython49-winxp' branch](#about-cefpython49-winxp-branch) * [Introduction](#introduction) * [Thanks to Fivestars for the v49 release](#thanks-to-fivestars-for-the-v49-release) * [Install](#install) * [Tutorial](#tutorial) * [Examples](#examples) * [Support](#support) * [Releases](#releases) * [Support development](#support-development) * [Thanks](#thanks) * [Quick links](#quick-links) ## Introduction CEF Python is a BSD-licensed open source project founded by [Czarek Tomczak](http://www.linkedin.com/in/czarektomczak) in 2012 and is based on Google Chromium and the [CEF Framework](https://bitbucket.org/chromiumembedded/cef) projects. The Chromium project focuses mainly on Google Chrome application development, while CEF focuses on facilitating embedded browser use cases in third-party applications. Lots of applications use CEF control, there are more than [100 million CEF instances](http://en.wikipedia.org/wiki/Chromium_Embedded_Framework#Applications_using_CEF) installed around the world. [Examples of embedding](examples/Examples-README.md) Chrome browser are available for many popular GUI toolkits including: wxPython, PyGTK, PyQt, PySide, Kivy, Panda3D and PyGame/PyOpenGL. There are many use cases for CEF. You can embed a web browser control based on Chromium with great HTML 5 support. You can use it to create a HTML 5 based GUI in an application, this can act as a replacement for standard GUI toolkits such as wxWidgets, Qt or GTK. In such case to communicate between Python<>Javascript use [javascript bindings](docs/Tutorial.md#javascript-integration) or embed an internal web server and talk using http requests. You can render web content off-screen in applications that use custom drawing frameworks. You can use it for automated testing of existing applications. You can use it for web scraping or as a web crawler, or other kind of internet bots. ## Thanks to Fivestars for the v49 release Thanks to Fivestars Loyalty, Inc. for sponsoring the [v49 release](../../releases) of CEF Python. Please visit its website: https://www.fivestars.com/ . [![fivestars360](https://raw.githubusercontent.com/wiki/cztomczak/cefpython/images/fivestars360.png)](https://www.fivestars.com/) ## Install You can install [pypi/cefpython3](https://pypi.python.org/pypi/cefpython3) package using pip tool. You can also download packages for offline installation available on the [GitHub Releases](../../releases) pages. Command to install with pip: ``` pip --no-cache-dir install cefpython3==49.0 ``` Please note that if you were previously installing cefpython3 package it is required to use the `--no-cache-dir` flag, otherwise pip will end up with error message `No matching distribution found for cefpython3==49.0`. This happens because 49.0 release occured after 57.0 and 66.0 releases. ## Tutorial See the [Tutorial.md](docs/Tutorial.md) file. ## Examples See the [Examples-README.md](examples/Examples-README.md) file. ## Support - Ask questions, report problems and issues on the [Forum](https://groups.google.com/group/cefpython) - Supported examples are listed in the [Examples-README.md](examples/Examples-README.md) file - Documentation is in the [docs/](docs) directory: - [Build instructions](docs/Build-instructions.md) - [Knowledge Base](docs/Knowledge-Base.md) - [Migration guide](docs/Migration-guide.md) - [Tutorial](docs/Tutorial.md) - API reference is in the [api/](api) directory: - [API categories](api/API-categories.md#api-categories) - [API index](api/API-index.md#api-index) - Additional documentation is available in [Issues labelled Knowledge Base](../../issues?q=is%3Aissue+is%3Aopen+label%3A%22Knowledge+Base%22) - To search documentation use GitHub "This repository" search at the top. To narrow results to documentation only select "Markdown" in the right pane. - Wiki pages are deprecated and for v31 only ## Releases Information on supported platforms, python versions, architectures and requirements. If you want to support old operating systems then choose the v31 release. **v49 release** OS | Py2 | Py3 | 32bit | 64bit | Requirements --- | --- | --- | --- | --- | --- Windows | 2.7 | 3.4 | Yes | Yes | Windows XP+ - Install with command: `pip --no-cache-dir install cefpython3==49.0`. - Please note that if you were previously installing cefpython3 package it is required to use the `--no-cache-dir` flag, otherwise pip will end up with error message `No matching distribution found for cefpython3==49.0`. This happens because 49.0 release occured after 57.0 and 66.0 releases. - Downloads are available on GitHub Releases tagged [v49.0](../../releases/tag/v49.0). - See [Migration guide](docs/Migration-guide.md) document for changes in this release - Documentation is available in the [docs/](../../tree/cefpython49-winxp/docs) directory - API reference is available in the [api/](../../tree/cefpython49-winxp/api) directory **v31 release** OS | Py2 | Py3 | 32bit | 64bit | Requirements --- | --- | --- | --- | --- | --- Windows | 2.7 | No | Yes | Yes | Windows XP+ Linux | 2.7 | No | Yes | Yes | Debian 7+ / Ubuntu 12.04+ Mac | 2.7 | No | Yes | Yes | MacOS 10.7+ Additional information for v31.2 release: - On Windows/Mac you can install with command: `pip install cefpython3==31.2` - Downloads are available on [wiki pages](../../wiki#downloads) and on GitHub Releases tagged [v31.2](../../releases/tag/v31.2). - Documentation is on [wiki pages](../../wiki) - API reference is available in revision [169a1b2](../../tree/169a1b20d3cd09879070d41aab28cfa195d2a7d5/docs/api) ## Support development If you would like to support general CEF Python development efforts by making a donation please click the Paypal Donate button:

If you would like to see some feature implemented you can make a comment about that when making a donation. It will give it a higher priority. If you are interested in sponsorship opportunities please contact Czarek directly. ### Thanks * Thanks to [FiveStars Loyalty, Inc.](https://www.fivestars.com/) for sponsoring the v49 release for Windows with WinXP support * Many thanks to [ClearChat Inc.](https://clearchat.com) for sponsoring the v55/v56 releases for all platforms * Thanks to JetBrains for providing an Open Source license for [PyCharm](https://www.jetbrains.com/pycharm/) * Thanks to those who have made a Paypal donation: [Rentouch GmbH](http://www.rentouch.ch/), Walter Purvis, Rokas Stupuras, Alex Rattray, Greg Kacy, Paul Korzhyk * Lots of thanks goes to [Cyan Inc.](http://www.blueplanet.com/) for sponsoring this project for a long time, making CEF Python 3 mature * Thanks to those who have donated their time through code contributions, they are listed in the [Authors](Authors) file * Thanks to Adam Duston for donating a Macbook to aid the development of Mac port * Thanks to [Rentouch GmbH](http://www.rentouch.ch/) for sponsoring the development of the off-screen rendering support * Thanks to Thomas Wusatiuk for sponsoring the development of the web response reading features ## Quick links ### Docs - [Build instructions](docs/Build-instructions.md) - [Knowledge Base](docs/Knowledge-Base.md) - [Migration guide](docs/Migration-guide.md) - [Tutorial](docs/Tutorial.md) ### API categories #### Modules * [cefpython](api/cefpython.md#cefpython) module #### Settings * [ApplicationSettings](api/ApplicationSettings.md#application-settings) dictionary * [BrowserSettings](api/BrowserSettings.md#browser-settings) dictionary * [CommandLineSwitches](api/CommandLineSwitches.md#command-line-switches) dictionary #### Classes and objects * [Browser](api/Browser.md#browser-object) object * [Callback](api/Callback.md#callback-object) object * [Cookie](api/Cookie.md#cookie-class) class * [CookieManager](api/CookieManager.md#cookiemanager-class) class * [DpiAware](api/DpiAware.md#dpiaware-class) class (Win) * [DragData](api/DragData.md#dragdata-object) object * [Frame](api/Frame.md#frame-object) object * [Image](api/Image.md#image-object) object * [JavascriptBindings](api/JavascriptBindings.md#javascriptbindings-class) class * [JavascriptCallback](api/JavascriptCallback.md#javascriptcallback-object) object * [PaintBuffer](api/PaintBuffer.md#paintbuffer-object) object * [Request](api/Request.md#request-class) class * [Response](api/Response.md#response-object) object * [WebPluginInfo](api/WebPluginInfo.md#webplugininfo-object) object * [WebRequest](api/WebRequest.md#webrequest-class) class * [WindowInfo](api/WindowInfo.md#windowinfo-class) class * [WindowUtils](api/WindowUtils.md#windowutils-class) class #### Client handlers (interfaces) * [DisplayHandler](api/DisplayHandler.md#displayhandler-interface) * [DownloadHandler](api/DownloadHandler.md#downloadhandler) * [FocusHandler](api/FocusHandler.md#focushandler-interface) * [JavascriptDialogHandler](api/JavascriptDialogHandler.md#javascriptdialoghandler-interface) * [KeyboardHandler](api/KeyboardHandler.md#keyboardhandler-interface) * [LifespanHandler](api/LifespanHandler.md#lifespanhandler-interface) * [LoadHandler](api/LoadHandler.md#loadhandler-interface) * [RenderHandler](api/RenderHandler.md#renderhandler-interface) * [RequestHandler](api/RequestHandler.md#requesthandler-interface) * [ResourceHandler](api/ResourceHandler.md#resourcehandler-interface) * [V8ContextHandler](api/V8ContextHandler.md#v8contexthandler-interface) #### Other interfaces * [CookieVisitor](api/CookieVisitor.md#cookievisitor-interface) interface * [StringVisitor](api/StringVisitor.md#stringvisitor-interface) interface * [WebRequestClient](api/WebRequestClient.md#webrequestclient-interface) interface ### API index * [Application settings](api/ApplicationSettings.md#application-settings) * [accept_language_list](api/ApplicationSettings.md#accept_language_list) * [app_user_model_id](api/ApplicationSettings.md#app_user_model_id) * [auto_zooming](api/ApplicationSettings.md#auto_zooming) * [background_color](api/ApplicationSettings.md#background_color) * [browser_subprocess_path](api/ApplicationSettings.md#browser_subprocess_path) * [cache_path](api/ApplicationSettings.md#cache_path) * [command_line_args_disabled](api/ApplicationSettings.md#command_line_args_disabled) * [context_menu](api/ApplicationSettings.md#context_menu) * [downloads_enabled](api/ApplicationSettings.md#downloads_enabled) * [ignore_certificate_errors](api/ApplicationSettings.md#ignore_certificate_errors) * [javascript_flags](api/ApplicationSettings.md#javascript_flags) * [locale](api/ApplicationSettings.md#locale) * [locales_dir_path](api/ApplicationSettings.md#locales_dir_path) * [debug](api/ApplicationSettings.md#debug) * [log_file](api/ApplicationSettings.md#log_file) * [log_severity](api/ApplicationSettings.md#log_severity) * [multi_threaded_message_loop](api/ApplicationSettings.md#multi_threaded_message_loop) * [pack_loading_disabled](api/ApplicationSettings.md#pack_loading_disabled) * [persist_session_cookies](api/ApplicationSettings.md#persist_session_cookies) * [persist_user_preferences](api/ApplicationSettings.md#persist_user_preferences) * [product_version](api/ApplicationSettings.md#product_version) * [remote_debugging_port](api/ApplicationSettings.md#remote_debugging_port) * [resources_dir_path](api/ApplicationSettings.md#resources_dir_path) * [single_process](api/ApplicationSettings.md#single_process) * [string_encoding](api/ApplicationSettings.md#string_encoding) * [uncaught_exception_stack_size](api/ApplicationSettings.md#uncaught_exception_stack_size) * [unique_request_context_per_browser](api/ApplicationSettings.md#unique_request_context_per_browser) * [user_agent](api/ApplicationSettings.md#user_agent) * [user_data_path](api/ApplicationSettings.md#user_data_path) * [windowless_rendering_enabled](api/ApplicationSettings.md#windowless_rendering_enabled) * [Browser (object)](api/Browser.md#browser-object) * [AddWordToDictionary](api/Browser.md#addwordtodictionary) * [CanGoBack](api/Browser.md#cangoback) * [CanGoForward](api/Browser.md#cangoforward) * [CloseBrowser](api/Browser.md#closebrowser) * [CloseDevTools](api/Browser.md#closedevtools) * [DragTargetDragEnter](api/Browser.md#dragtargetdragenter) * [DragTargetDragOver](api/Browser.md#dragtargetdragover) * [DragTargetDragLeave](api/Browser.md#dragtargetdragleave) * [DragTargetDrop](api/Browser.md#dragtargetdrop) * [DragSourceEndedAt](api/Browser.md#dragsourceendedat) * [DragSourceSystemDragEnded](api/Browser.md#dragsourcesystemdragended) * [ExecuteFunction](api/Browser.md#executefunction) * [ExecuteJavascript](api/Browser.md#executejavascript) * [Find](api/Browser.md#find) * [GetClientCallback](api/Browser.md#getclientcallback) * [GetClientCallbacksDict](api/Browser.md#getclientcallbacksdict) * [GetFocusedFrame](api/Browser.md#getfocusedframe) * [GetFrame](api/Browser.md#getframe) * [GetFrameByIdentifier](api/Browser.md#getframebyidentifier) * [GetFrames](api/Browser.md#getframes) * [GetFrameCount](api/Browser.md#getframecount) * [GetFrameIdentifiers](api/Browser.md#getframeidentifiers) * [GetFrameNames](api/Browser.md#getframenames) * [GetJavascriptBindings](api/Browser.md#getjavascriptbindings) * [GetMainFrame](api/Browser.md#getmainframe) * [GetNSTextInputContext](api/Browser.md#getnstextinputcontext) * [GetOpenerWindowHandle](api/Browser.md#getopenerwindowhandle) * [GetOuterWindowHandle](api/Browser.md#getouterwindowhandle) * [GetUrl](api/Browser.md#geturl) * [GetUserData](api/Browser.md#getuserdata) * [GetWindowHandle](api/Browser.md#getwindowhandle) * [GetIdentifier](api/Browser.md#getidentifier) * [GetZoomLevel](api/Browser.md#getzoomlevel) * [GoBack](api/Browser.md#goback) * [GoForward](api/Browser.md#goforward) * [HandleKeyEventAfterTextInputClient](api/Browser.md#handlekeyeventaftertextinputclient) * [HandleKeyEventBeforeTextInputClient](api/Browser.md#handlekeyeventbeforetextinputclient) * [HasDocument](api/Browser.md#hasdocument) * [IsFullscreen](api/Browser.md#isfullscreen) * [IsLoading](api/Browser.md#isloading) * [IsMouseCursorChangeDisabled](api/Browser.md#ismousecursorchangedisabled) * [IsPopup](api/Browser.md#ispopup) * [IsWindowRenderingDisabled](api/Browser.md#iswindowrenderingdisabled) * [LoadUrl](api/Browser.md#loadurl) * [Navigate](api/Browser.md#navigate) * [NotifyMoveOrResizeStarted](api/Browser.md#notifymoveorresizestarted) * [NotifyScreenInfoChanged](api/Browser.md#notifyscreeninfochanged) * [ParentWindowWillClose](api/Browser.md#parentwindowwillclose) * [Reload](api/Browser.md#reload) * [ReloadIgnoreCache](api/Browser.md#reloadignorecache) * [ReplaceMisspelling](api/Browser.md#replacemisspelling) * [SetBounds](api/Browser.md#setbounds) * [SendKeyEvent](api/Browser.md#sendkeyevent) * [SendMouseClickEvent](api/Browser.md#sendmouseclickevent) * [SendMouseMoveEvent](api/Browser.md#sendmousemoveevent) * [SendMouseWheelEvent](api/Browser.md#sendmousewheelevent) * [SendFocusEvent](api/Browser.md#sendfocusevent) * [SendCaptureLostEvent](api/Browser.md#sendcapturelostevent) * [SetClientCallback](api/Browser.md#setclientcallback) * [SetClientHandler](api/Browser.md#setclienthandler) * [SetFocus](api/Browser.md#setfocus) * [SetMouseCursorChangeDisabled](api/Browser.md#setmousecursorchangedisabled) * [SetJavascriptBindings](api/Browser.md#setjavascriptbindings) * [SetUserData](api/Browser.md#setuserdata) * [SetZoomLevel](api/Browser.md#setzoomlevel) * [ShowDevTools](api/Browser.md#showdevtools) * [StartDownload](api/Browser.md#startdownload) * [StopLoad](api/Browser.md#stopload) * [StopFinding](api/Browser.md#stopfinding) * [ToggleFullscreen](api/Browser.md#togglefullscreen) * [WasResized](api/Browser.md#wasresized) * [WasHidden](api/Browser.md#washidden) * [Browser settings](api/BrowserSettings.md#browser-settings) * [Font settings](api/BrowserSettings.md#font-settings) * [accept_language_list](api/BrowserSettings.md#accept_language_list) * [application_cache_disabled](api/BrowserSettings.md#application_cache_disabled) * [background_color](api/BrowserSettings.md#background_color) * [databases_disabled](api/BrowserSettings.md#databases_disabled) * [default_encoding](api/BrowserSettings.md#default_encoding) * [dom_paste_disabled](api/BrowserSettings.md#dom_paste_disabled) * [file_access_from_file_urls_allowed](api/BrowserSettings.md#file_access_from_file_urls_allowed) * [image_load_disabled](api/BrowserSettings.md#image_load_disabled) * [javascript_disabled](api/BrowserSettings.md#javascript_disabled) * [javascript_open_windows_disallowed](api/BrowserSettings.md#javascript_open_windows_disallowed) * [javascript_close_windows_disallowed](api/BrowserSettings.md#javascript_close_windows_disallowed) * [javascript_access_clipboard_disallowed](api/BrowserSettings.md#javascript_access_clipboard_disallowed) * [local_storage_disabled](api/BrowserSettings.md#local_storage_disabled) * [plugins_disabled](api/BrowserSettings.md#plugins_disabled) * [remote_fonts](api/BrowserSettings.md#remote_fonts) * [shrink_standalone_images_to_fit](api/BrowserSettings.md#shrink_standalone_images_to_fit) * [tab_to_links_disabled](api/BrowserSettings.md#tab_to_links_disabled) * [text_area_resize_disabled](api/BrowserSettings.md#text_area_resize_disabled) * [universal_access_from_file_urls_allowed](api/BrowserSettings.md#universal_access_from_file_urls_allowed) * [web_security_disabled](api/BrowserSettings.md#web_security_disabled) * [webgl_disabled](api/BrowserSettings.md#webgl_disabled) * [windowless_frame_rate](api/BrowserSettings.md#windowless_frame_rate) * [Callback (object)](api/Callback.md#callback-object) * [Continue](api/Callback.md#continue) * [Cancel](api/Callback.md#cancel) * [cefpython](api/cefpython.md#cefpython) * [CreateBrowser](api/cefpython.md#createbrowser) * [CreateBrowserSync](api/cefpython.md#createbrowsersync) * [ExceptHook](api/cefpython.md#excepthook) * [GetAppSetting](api/cefpython.md#getappsetting) * [GetAppPath](api/cefpython.md#getapppath) * [GetBrowserByWindowHandle](api/cefpython.md#getbrowserbywindowhandle) * [GetCommandLineSwitch](api/cefpython.md#getcommandlineswitch) * [GetGlobalClientCallback](api/cefpython.md#getglobalclientcallback) * [GetModuleDirectory](api/cefpython.md#getmoduledirectory) * [GetVersion](api/cefpython.md#getversion) * [Initialize](api/cefpython.md#initialize) * [IsThread](api/cefpython.md#isthread) * [MessageLoop](api/cefpython.md#messageloop) * [MessageLoopWork](api/cefpython.md#messageloopwork) * [PostTask](api/cefpython.md#posttask) * [PostDelayedTask](api/cefpython.md#postdelayedtask) * [QuitMessageLoop](api/cefpython.md#quitmessageloop) * [SetGlobalClientCallback](api/cefpython.md#setglobalclientcallback) * [SetOsModalLoop](api/cefpython.md#setosmodalloop) * [Shutdown](api/cefpython.md#shutdown) * [Command line switches](api/CommandLineSwitches.md#command-line-switches) * [enable-media-stream](api/CommandLineSwitches.md#enable-media-stream) * [proxy-server](api/CommandLineSwitches.md#proxy-server) * [no-proxy-server](api/CommandLineSwitches.md#no-proxy-server) * [disable-gpu](api/CommandLineSwitches.md#disable-gpu) * [Cookie (class)](api/Cookie.md#cookie-class) * [Set](api/Cookie.md#set) * [Get](api/Cookie.md#get) * [SetName](api/Cookie.md#setname) * [GetName](api/Cookie.md#getname) * [SetValue](api/Cookie.md#setvalue) * [GetValue](api/Cookie.md#getvalue) * [SetDomain](api/Cookie.md#setdomain) * [GetDomain](api/Cookie.md#getdomain) * [SetPath](api/Cookie.md#setpath) * [GetPath](api/Cookie.md#getpath) * [SetSecure](api/Cookie.md#setsecure) * [GetSecure](api/Cookie.md#getsecure) * [SetHttpOnly](api/Cookie.md#sethttponly) * [GetHttpOnly](api/Cookie.md#gethttponly) * [SetCreation](api/Cookie.md#setcreation) * [GetCreation](api/Cookie.md#getcreation) * [SetLastAccess](api/Cookie.md#setlastaccess) * [GetLastAccess](api/Cookie.md#getlastaccess) * [SetHasExpires](api/Cookie.md#sethasexpires) * [GetHasExpires](api/Cookie.md#gethasexpires) * [SetExpires](api/Cookie.md#setexpires) * [GetExpires](api/Cookie.md#getexpires) * [CookieManager (class)](api/CookieManager.md#cookiemanager-class) * [GetGlobalManager](api/CookieManager.md#getglobalmanager) * [CreateManager](api/CookieManager.md#createmanager) * [SetSupportedSchemes](api/CookieManager.md#setsupportedschemes) * [VisitAllCookies](api/CookieManager.md#visitallcookies) * [VisitUrlCookies](api/CookieManager.md#visiturlcookies) * [SetCookie](api/CookieManager.md#setcookie) * [DeleteCookies](api/CookieManager.md#deletecookies) * [SetStoragePath](api/CookieManager.md#setstoragepath) * [FlushStore](api/CookieManager.md#flushstore) * [CookieVisitor (interface)](api/CookieVisitor.md#cookievisitor-interface) * [Visit](api/CookieVisitor.md#visit) * [DisplayHandler (interface)](api/DisplayHandler.md#displayhandler-interface) * [OnAddressChange](api/DisplayHandler.md#onaddresschange) * [OnTitleChange](api/DisplayHandler.md#ontitlechange) * [OnTooltip](api/DisplayHandler.md#ontooltip) * [OnStatusMessage](api/DisplayHandler.md#onstatusmessage) * [OnConsoleMessage](api/DisplayHandler.md#onconsolemessage) * [DownloadHandler](api/DownloadHandler.md#downloadhandler) * [DpiAware (class)](api/DpiAware.md#dpiaware-class) * [CalculateWindowSize](api/DpiAware.md#calculatewindowsize) * [EnableHighDpiSupport](api/DpiAware.md#enablehighdpisupport) * [GetSystemDpi](api/DpiAware.md#getsystemdpi) * [IsProcessDpiAware](api/DpiAware.md#isprocessdpiaware) * [SetProcessDpiAware](api/DpiAware.md#setprocessdpiaware) * [DragData (object)](api/DragData.md#dragdata-object) * [IsLink](api/DragData.md#islink) * [IsFragment](api/DragData.md#isfragment) * [GetLinkUrl](api/DragData.md#getlinkurl) * [GetLinkTitle](api/DragData.md#getlinktitle) * [GetFragmentText](api/DragData.md#getfragmenttext) * [GetFragmentHtml](api/DragData.md#getfragmenthtml) * [GetImage](api/DragData.md#getimage) * [HasImage](api/DragData.md#hasimage) * [FocusHandler (interface)](api/FocusHandler.md#focushandler-interface) * [OnTakeFocus](api/FocusHandler.md#ontakefocus) * [OnSetFocus](api/FocusHandler.md#onsetfocus) * [OnGotFocus](api/FocusHandler.md#ongotfocus) * [Frame (object)](api/Frame.md#frame-object) * [Copy](api/Frame.md#copy) * [Cut](api/Frame.md#cut) * [Delete](api/Frame.md#delete) * [ExecuteFunction](api/Frame.md#executefunction) * [ExecuteJavascript](api/Frame.md#executejavascript) * [GetBrowser](api/Frame.md#getbrowser) * [GetParent](api/Frame.md#getparent) * [GetIdentifier](api/Frame.md#getidentifier) * [GetBrowserIdentifier](api/Frame.md#getbrowseridentifier) * [GetName](api/Frame.md#getname) * [GetParent](api/Frame.md#getparent) * [GetProperty](api/Frame.md#getproperty) * [GetSource](api/Frame.md#getsource) * [GetText](api/Frame.md#gettext) * [GetUrl](api/Frame.md#geturl) * [IsFocused](api/Frame.md#isfocused) * [IsMain](api/Frame.md#ismain) * [IsValid](api/Frame.md#isvalid) * [LoadString](api/Frame.md#loadstring) * [LoadUrl](api/Frame.md#loadurl) * [Paste](api/Frame.md#paste) * [Redo](api/Frame.md#redo) * [SelectAll](api/Frame.md#selectall) * [SetProperty](api/Frame.md#setproperty) * [Undo](api/Frame.md#undo) * [ViewSource](api/Frame.md#viewsource) * [Image (object)](api/Image.md#image-object) * [GetAsBitmap](api/Image.md#getasbitmap) * [GetAsPng](api/Image.md#getaspng) * [GetHeight](api/Image.md#getheight) * [GetWidth](api/Image.md#getwidth) * [JavascriptBindings (class)](api/JavascriptBindings.md#javascriptbindings-class) * [\_\_init\_\_](api/JavascriptBindings.md#__init__) * [IsValueAllowed](api/JavascriptBindings.md#isvalueallowed) * [Rebind](api/JavascriptBindings.md#rebind) * [SetFunction](api/JavascriptBindings.md#setfunction) * [SetObject](api/JavascriptBindings.md#setobject) * [SetProperty](api/JavascriptBindings.md#setproperty) * [JavascriptCallback (object)](api/JavascriptCallback.md#javascriptcallback-object) * [Call](api/JavascriptCallback.md#call) * [GetFrame](api/JavascriptCallback.md#getframe) * [GetId](api/JavascriptCallback.md#getid) * [GetFunctionName](api/JavascriptCallback.md#getfunctionname) * [JavascriptDialogHandler (interface)](api/JavascriptDialogHandler.md#javascriptdialoghandler-interface) * [Continue](api/JavascriptDialogHandler.md#continue) * [OnJavascriptDialog](api/JavascriptDialogHandler.md#onjavascriptdialog) * [OnBeforeUnloadJavascriptDialog](api/JavascriptDialogHandler.md#onbeforeunloadjavascriptdialog) * [OnResetJavascriptDialogState](api/JavascriptDialogHandler.md#onresetjavascriptdialogstate) * [OnJavascriptDialogClosed](api/JavascriptDialogHandler.md#onjavascriptdialogclosed) * [KeyboardHandler (interface)](api/KeyboardHandler.md#keyboardhandler-interface) * [OnPreKeyEvent](api/KeyboardHandler.md#onprekeyevent) * [OnKeyEvent](api/KeyboardHandler.md#onkeyevent) * [LifespanHandler (interface)](api/LifespanHandler.md#lifespanhandler-interface) * [OnBeforePopup](api/LifespanHandler.md#onbeforepopup) * [_OnAfterCreated](api/LifespanHandler.md#_onaftercreated) * [DoClose](api/LifespanHandler.md#doclose) * [OnBeforeClose](api/LifespanHandler.md#onbeforeclose) * [RunModal](api/LifespanHandler.md#runmodal) * [LoadHandler (interface)](api/LoadHandler.md#loadhandler-interface) * [OnLoadingStateChange](api/LoadHandler.md#onloadingstatechange) * [OnLoadStart](api/LoadHandler.md#onloadstart) * [OnDomReady](api/LoadHandler.md#ondomready) * [OnLoadEnd](api/LoadHandler.md#onloadend) * [OnLoadError](api/LoadHandler.md#onloaderror) * [Network error](api/NetworkError.md#network-error) * [ERR_NONE](api/NetworkError.md#err_none) * [ERR_ABORTED](api/NetworkError.md#err_aborted) * [ERR_ACCESS_DENIED](api/NetworkError.md#err_access_denied) * [ERR_ADDRESS_INVALID](api/NetworkError.md#err_address_invalid) * [ERR_ADDRESS_UNREACHABLE](api/NetworkError.md#err_address_unreachable) * [ERR_CACHE_MISS](api/NetworkError.md#err_cache_miss) * [ERR_CERT_AUTHORITY_INVALID](api/NetworkError.md#err_cert_authority_invalid) * [ERR_CERT_COMMON_NAME_INVALID](api/NetworkError.md#err_cert_common_name_invalid) * [ERR_CERT_CONTAINS_ERRORS](api/NetworkError.md#err_cert_contains_errors) * [ERR_CERT_DATE_INVALID](api/NetworkError.md#err_cert_date_invalid) * [ERR_CERT_END](api/NetworkError.md#err_cert_end) * [ERR_CERT_INVALID](api/NetworkError.md#err_cert_invalid) * [ERR_CERT_NO_REVOCATION_MECHANISM](api/NetworkError.md#err_cert_no_revocation_mechanism) * [ERR_CERT_REVOKED](api/NetworkError.md#err_cert_revoked) * [ERR_CERT_UNABLE_TO_CHECK_REVOCATION](api/NetworkError.md#err_cert_unable_to_check_revocation) * [ERR_CONNECTION_ABORTED](api/NetworkError.md#err_connection_aborted) * [ERR_CONNECTION_CLOSED](api/NetworkError.md#err_connection_closed) * [ERR_CONNECTION_FAILED](api/NetworkError.md#err_connection_failed) * [ERR_CONNECTION_REFUSED](api/NetworkError.md#err_connection_refused) * [ERR_CONNECTION_RESET](api/NetworkError.md#err_connection_reset) * [ERR_DISALLOWED_URL_SCHEME](api/NetworkError.md#err_disallowed_url_scheme) * [ERR_EMPTY_RESPONSE](api/NetworkError.md#err_empty_response) * [ERR_FAILED](api/NetworkError.md#err_failed) * [ERR_FILE_NOT_FOUND](api/NetworkError.md#err_file_not_found) * [ERR_FILE_TOO_BIG](api/NetworkError.md#err_file_too_big) * [ERR_INSECURE_RESPONSE](api/NetworkError.md#err_insecure_response) * [ERR_INTERNET_DISCONNECTED](api/NetworkError.md#err_internet_disconnected) * [ERR_INVALID_ARGUMENT](api/NetworkError.md#err_invalid_argument) * [ERR_INVALID_CHUNKED_ENCODING](api/NetworkError.md#err_invalid_chunked_encoding) * [ERR_INVALID_HANDLE](api/NetworkError.md#err_invalid_handle) * [ERR_INVALID_RESPONSE](api/NetworkError.md#err_invalid_response) * [ERR_INVALID_URL](api/NetworkError.md#err_invalid_url) * [ERR_METHOD_NOT_SUPPORTED](api/NetworkError.md#err_method_not_supported) * [ERR_NAME_NOT_RESOLVED](api/NetworkError.md#err_name_not_resolved) * [ERR_NO_SSL_VERSIONS_ENABLED](api/NetworkError.md#err_no_ssl_versions_enabled) * [ERR_NOT_IMPLEMENTED](api/NetworkError.md#err_not_implemented) * [ERR_RESPONSE_HEADERS_TOO_BIG](api/NetworkError.md#err_response_headers_too_big) * [ERR_SSL_CLIENT_AUTH_CERT_NEEDED](api/NetworkError.md#err_ssl_client_auth_cert_needed) * [ERR_SSL_PROTOCOL_ERROR](api/NetworkError.md#err_ssl_protocol_error) * [ERR_SSL_RENEGOTIATION_REQUESTED](api/NetworkError.md#err_ssl_renegotiation_requested) * [ERR_SSL_VERSION_OR_CIPHER_MISMATCH](api/NetworkError.md#err_ssl_version_or_cipher_mismatch) * [ERR_TIMED_OUT](api/NetworkError.md#err_timed_out) * [ERR_TOO_MANY_REDIRECTS](api/NetworkError.md#err_too_many_redirects) * [ERR_TUNNEL_CONNECTION_FAILED](api/NetworkError.md#err_tunnel_connection_failed) * [ERR_UNEXPECTED](api/NetworkError.md#err_unexpected) * [ERR_UNEXPECTED_PROXY_AUTH](api/NetworkError.md#err_unexpected_proxy_auth) * [ERR_UNKNOWN_URL_SCHEME](api/NetworkError.md#err_unknown_url_scheme) * [ERR_UNSAFE_PORT](api/NetworkError.md#err_unsafe_port) * [ERR_UNSAFE_REDIRECT](api/NetworkError.md#err_unsafe_redirect) * [PaintBuffer (object)](api/PaintBuffer.md#paintbuffer-object) * [GetIntPointer](api/PaintBuffer.md#getintpointer) * [GetString](api/PaintBuffer.md#getstring) * [RenderHandler (interface)](api/RenderHandler.md#renderhandler-interface) * [GetRootScreenRect](api/RenderHandler.md#getrootscreenrect) * [GetViewRect](api/RenderHandler.md#getviewrect) * [GetScreenRect](api/RenderHandler.md#getscreenrect) * [GetScreenPoint](api/RenderHandler.md#getscreenpoint) * [OnPopupShow](api/RenderHandler.md#onpopupshow) * [OnPopupSize](api/RenderHandler.md#onpopupsize) * [OnPaint](api/RenderHandler.md#onpaint) * [OnCursorChange](api/RenderHandler.md#oncursorchange) * [OnScrollOffsetChanged](api/RenderHandler.md#onscrolloffsetchanged) * [StartDragging](api/RenderHandler.md#startdragging) * [UpdateDragCursor](api/RenderHandler.md#updatedragcursor) * [Request (class)](api/Request.md#request-class) * [CreateRequest](api/Request.md#createrequest) * [IsReadOnly](api/Request.md#isreadonly) * [GetUrl](api/Request.md#geturl) * [SetUrl](api/Request.md#seturl) * [GetMethod](api/Request.md#getmethod) * [SetMethod](api/Request.md#setmethod) * [GetPostData](api/Request.md#getpostdata) * [SetPostData](api/Request.md#setpostdata) * [GetHeaderMap](api/Request.md#getheadermap) * [GetHeaderMultimap](api/Request.md#getheadermultimap) * [SetHeaderMap](api/Request.md#setheadermap) * [SetHeaderMultimap](api/Request.md#setheadermultimap) * [GetFlags](api/Request.md#getflags) * [SetFlags](api/Request.md#setflags) * [GetFirstPartyForCookies](api/Request.md#getfirstpartyforcookies) * [SetFirstPartyForCookies](api/Request.md#setfirstpartyforcookies) * [GetResourceType](api/Request.md#getresourcetype) * [GetTransitionType](api/Request.md#gettransitiontype) * [RequestHandler (interface)](api/RequestHandler.md#requesthandler-interface) * [OnBeforeBrowse](api/RequestHandler.md#onbeforebrowse) * [OnBeforeResourceLoad](api/RequestHandler.md#onbeforeresourceload) * [GetResourceHandler](api/RequestHandler.md#getresourcehandler) * [OnResourceRedirect](api/RequestHandler.md#onresourceredirect) * [OnResourceResponse](api/RequestHandler.md#onresourceresponse) * [GetAuthCredentials](api/RequestHandler.md#getauthcredentials) * [OnQuotaRequest](api/RequestHandler.md#onquotarequest) * [GetCookieManager](api/RequestHandler.md#getcookiemanager) * [OnProtocolExecution](api/RequestHandler.md#onprotocolexecution) * [_OnBeforePluginLoad](api/RequestHandler.md#_onbeforepluginload) * [_OnCertificateError](api/RequestHandler.md#_oncertificateerror) * [OnRendererProcessTerminated](api/RequestHandler.md#onrendererprocessterminated) * [OnPluginCrashed](api/RequestHandler.md#onplugincrashed) * [ResourceHandler (interface)](api/ResourceHandler.md#resourcehandler-interface) * [ProcessRequest](api/ResourceHandler.md#processrequest) * [GetResponseHeaders](api/ResourceHandler.md#getresponseheaders) * [ReadResponse](api/ResourceHandler.md#readresponse) * [CanGetCookie](api/ResourceHandler.md#cangetcookie) * [CanSetCookie](api/ResourceHandler.md#cansetcookie) * [Cancel](api/ResourceHandler.md#cancel) * [Response (object)](api/Response.md#response-object) * [IsReadOnly](api/Response.md#isreadonly) * [GetStatus](api/Response.md#getstatus) * [SetStatus](api/Response.md#setstatus) * [GetStatusText](api/Response.md#getstatustext) * [SetStatusText](api/Response.md#setstatustext) * [GetMimeType](api/Response.md#getmimetype) * [SetMimeType](api/Response.md#setmimetype) * [GetHeader](api/Response.md#getheader) * [GetHeaderMap](api/Response.md#getheadermap) * [GetHeaderMultimap](api/Response.md#getheadermultimap) * [SetHeaderMap](api/Response.md#setheadermap) * [SetHeaderMultimap](api/Response.md#setheadermultimap) * [StringVisitor (interface)](api/StringVisitor.md#stringvisitor-interface) * [Visit](api/StringVisitor.md#visit) * [V8ContextHandler (interface)](api/V8ContextHandler.md#v8contexthandler-interface) * [OnContextCreated](api/V8ContextHandler.md#oncontextcreated) * [OnContextReleased](api/V8ContextHandler.md#oncontextreleased) * [Virtual Key codes](api/VirtualKey.md#virtual-key-codes) * [WebPluginInfo (object)](api/WebPluginInfo.md#webplugininfo-object) * [GetName](api/WebPluginInfo.md#getname) * [GetPath](api/WebPluginInfo.md#getpath) * [GetVersion](api/WebPluginInfo.md#getversion) * [GetDescription](api/WebPluginInfo.md#getdescription) * [WebRequest (class)](api/WebRequest.md#webrequest-class) * [Create](api/WebRequest.md#create) * [GetRequest](api/WebRequest.md#getrequest) * [GetRequestStatus](api/WebRequest.md#getrequeststatus) * [GetRequestError](api/WebRequest.md#getrequesterror) * [GetResponse](api/WebRequest.md#getresponse) * [Cancel](api/WebRequest.md#cancel) * [WebRequestClient (interface)](api/WebRequestClient.md#webrequestclient-interface) * [OnUploadProgress](api/WebRequestClient.md#onuploadprogress) * [OnDownloadProgress](api/WebRequestClient.md#ondownloadprogress) * [OnDownloadData](api/WebRequestClient.md#ondownloaddata) * [OnRequestComplete](api/WebRequestClient.md#onrequestcomplete) * [WindowInfo (class)](api/WindowInfo.md#windowinfo-class) * [SetAsChild](api/WindowInfo.md#setaschild) * [SetAsPopup](api/WindowInfo.md#setaspopup) * [SetAsOffscreen](api/WindowInfo.md#setasoffscreen) * [SetTransparentPainting](api/WindowInfo.md#settransparentpainting) * [WindowUtils (class)](api/WindowUtils.md#windowutils-class) * [OnSetFocus ](api/WindowUtils.md#onsetfocus-win) * [OnSize ](api/WindowUtils.md#onsize-win) * [OnEraseBackground ](api/WindowUtils.md#onerasebackground-win) * [SetTitle ](api/WindowUtils.md#settitle-win) * [SetIcon ](api/WindowUtils.md#seticon-win) * [UpdateBrowserSize ](api/WindowUtils.md#updatebrowsersize-win) * [GetParentHandle](api/WindowUtils.md#getparenthandle) * [IsWindowHandle](api/WindowUtils.md#iswindowhandle) * [gtk_plug_new ](api/WindowUtils.md#gtk_plug_new-linux) * [gtk_widget_show ](api/WindowUtils.md#gtk_widget_show-linux) * [InstallX11ErrorHandlers ](api/WindowUtils.md#installx11errorhandlers-linux) cefpython-49.0/api/000077500000000000000000000000001334103266300142175ustar00rootroot00000000000000cefpython-49.0/api/API-categories.md000066400000000000000000000044601334103266300173010ustar00rootroot00000000000000[API categories](API-categories.md) | [API index](API-index.md) # API categories ### Modules * [cefpython](cefpython.md#cefpython) module ### Settings * [ApplicationSettings](ApplicationSettings.md#application-settings) dictionary * [BrowserSettings](BrowserSettings.md#browser-settings) dictionary * [CommandLineSwitches](CommandLineSwitches.md#command-line-switches) dictionary ### Classes and objects * [Browser](Browser.md#browser-object) object * [Callback](Callback.md#callback-object) object * [Cookie](Cookie.md#cookie-class) class * [CookieManager](CookieManager.md#cookiemanager-class) class * [DpiAware](DpiAware.md#dpiaware-class) class (Win) * [DragData](DragData.md#dragdata-object) object * [Frame](Frame.md#frame-object) object * [Image](Image.md#image-object) object * [JavascriptBindings](JavascriptBindings.md#javascriptbindings-class) class * [JavascriptCallback](JavascriptCallback.md#javascriptcallback-object) object * [PaintBuffer](PaintBuffer.md#paintbuffer-object) object * [Request](Request.md#request-class) class * [Response](Response.md#response-object) object * [WebPluginInfo](WebPluginInfo.md#webplugininfo-object) object * [WebRequest](WebRequest.md#webrequest-class) class * [WindowInfo](WindowInfo.md#windowinfo-class) class * [WindowUtils](WindowUtils.md#windowutils-class) class ### Client handlers (interfaces) * [DisplayHandler](DisplayHandler.md#displayhandler-interface) * [DownloadHandler](DownloadHandler.md#downloadhandler) * [FocusHandler](FocusHandler.md#focushandler-interface) * [JavascriptDialogHandler](JavascriptDialogHandler.md#javascriptdialoghandler-interface) * [KeyboardHandler](KeyboardHandler.md#keyboardhandler-interface) * [LifespanHandler](LifespanHandler.md#lifespanhandler-interface) * [LoadHandler](LoadHandler.md#loadhandler-interface) * [RenderHandler](RenderHandler.md#renderhandler-interface) * [RequestHandler](RequestHandler.md#requesthandler-interface) * [ResourceHandler](ResourceHandler.md#resourcehandler-interface) * [V8ContextHandler](V8ContextHandler.md#v8contexthandler-interface) ### Other interfaces * [CookieVisitor](CookieVisitor.md#cookievisitor-interface) interface * [StringVisitor](StringVisitor.md#stringvisitor-interface) interface * [WebRequestClient](WebRequestClient.md#webrequestclient-interface) interface cefpython-49.0/api/API-index.md000066400000000000000000000571611334103266300162710ustar00rootroot00000000000000[API categories](API-categories.md#api-categories) | [API index](API-index.md#api-index) # API index * [Application settings](ApplicationSettings.md#application-settings) * [accept_language_list](ApplicationSettings.md#accept_language_list) * [app_user_model_id](ApplicationSettings.md#app_user_model_id) * [auto_zooming](ApplicationSettings.md#auto_zooming) * [background_color](ApplicationSettings.md#background_color) * [browser_subprocess_path](ApplicationSettings.md#browser_subprocess_path) * [cache_path](ApplicationSettings.md#cache_path) * [command_line_args_disabled](ApplicationSettings.md#command_line_args_disabled) * [context_menu](ApplicationSettings.md#context_menu) * [downloads_enabled](ApplicationSettings.md#downloads_enabled) * [ignore_certificate_errors](ApplicationSettings.md#ignore_certificate_errors) * [javascript_flags](ApplicationSettings.md#javascript_flags) * [locale](ApplicationSettings.md#locale) * [locales_dir_path](ApplicationSettings.md#locales_dir_path) * [debug](ApplicationSettings.md#debug) * [log_file](ApplicationSettings.md#log_file) * [log_severity](ApplicationSettings.md#log_severity) * [multi_threaded_message_loop](ApplicationSettings.md#multi_threaded_message_loop) * [pack_loading_disabled](ApplicationSettings.md#pack_loading_disabled) * [persist_session_cookies](ApplicationSettings.md#persist_session_cookies) * [persist_user_preferences](ApplicationSettings.md#persist_user_preferences) * [product_version](ApplicationSettings.md#product_version) * [remote_debugging_port](ApplicationSettings.md#remote_debugging_port) * [resources_dir_path](ApplicationSettings.md#resources_dir_path) * [single_process](ApplicationSettings.md#single_process) * [string_encoding](ApplicationSettings.md#string_encoding) * [uncaught_exception_stack_size](ApplicationSettings.md#uncaught_exception_stack_size) * [unique_request_context_per_browser](ApplicationSettings.md#unique_request_context_per_browser) * [user_agent](ApplicationSettings.md#user_agent) * [user_data_path](ApplicationSettings.md#user_data_path) * [windowless_rendering_enabled](ApplicationSettings.md#windowless_rendering_enabled) * [Browser (object)](Browser.md#browser-object) * [AddWordToDictionary](Browser.md#addwordtodictionary) * [CanGoBack](Browser.md#cangoback) * [CanGoForward](Browser.md#cangoforward) * [CloseBrowser](Browser.md#closebrowser) * [CloseDevTools](Browser.md#closedevtools) * [DragTargetDragEnter](Browser.md#dragtargetdragenter) * [DragTargetDragOver](Browser.md#dragtargetdragover) * [DragTargetDragLeave](Browser.md#dragtargetdragleave) * [DragTargetDrop](Browser.md#dragtargetdrop) * [DragSourceEndedAt](Browser.md#dragsourceendedat) * [DragSourceSystemDragEnded](Browser.md#dragsourcesystemdragended) * [ExecuteFunction](Browser.md#executefunction) * [ExecuteJavascript](Browser.md#executejavascript) * [Find](Browser.md#find) * [GetClientCallback](Browser.md#getclientcallback) * [GetClientCallbacksDict](Browser.md#getclientcallbacksdict) * [GetFocusedFrame](Browser.md#getfocusedframe) * [GetFrame](Browser.md#getframe) * [GetFrameByIdentifier](Browser.md#getframebyidentifier) * [GetFrames](Browser.md#getframes) * [GetFrameCount](Browser.md#getframecount) * [GetFrameIdentifiers](Browser.md#getframeidentifiers) * [GetFrameNames](Browser.md#getframenames) * [GetJavascriptBindings](Browser.md#getjavascriptbindings) * [GetMainFrame](Browser.md#getmainframe) * [GetNSTextInputContext](Browser.md#getnstextinputcontext) * [GetOpenerWindowHandle](Browser.md#getopenerwindowhandle) * [GetOuterWindowHandle](Browser.md#getouterwindowhandle) * [GetUrl](Browser.md#geturl) * [GetUserData](Browser.md#getuserdata) * [GetWindowHandle](Browser.md#getwindowhandle) * [GetIdentifier](Browser.md#getidentifier) * [GetZoomLevel](Browser.md#getzoomlevel) * [GoBack](Browser.md#goback) * [GoForward](Browser.md#goforward) * [HandleKeyEventAfterTextInputClient](Browser.md#handlekeyeventaftertextinputclient) * [HandleKeyEventBeforeTextInputClient](Browser.md#handlekeyeventbeforetextinputclient) * [HasDocument](Browser.md#hasdocument) * [IsFullscreen](Browser.md#isfullscreen) * [IsLoading](Browser.md#isloading) * [IsMouseCursorChangeDisabled](Browser.md#ismousecursorchangedisabled) * [IsPopup](Browser.md#ispopup) * [IsWindowRenderingDisabled](Browser.md#iswindowrenderingdisabled) * [LoadUrl](Browser.md#loadurl) * [Navigate](Browser.md#navigate) * [NotifyMoveOrResizeStarted](Browser.md#notifymoveorresizestarted) * [NotifyScreenInfoChanged](Browser.md#notifyscreeninfochanged) * [ParentWindowWillClose](Browser.md#parentwindowwillclose) * [Reload](Browser.md#reload) * [ReloadIgnoreCache](Browser.md#reloadignorecache) * [ReplaceMisspelling](Browser.md#replacemisspelling) * [SetBounds](Browser.md#setbounds) * [SendKeyEvent](Browser.md#sendkeyevent) * [SendMouseClickEvent](Browser.md#sendmouseclickevent) * [SendMouseMoveEvent](Browser.md#sendmousemoveevent) * [SendMouseWheelEvent](Browser.md#sendmousewheelevent) * [SendFocusEvent](Browser.md#sendfocusevent) * [SendCaptureLostEvent](Browser.md#sendcapturelostevent) * [SetClientCallback](Browser.md#setclientcallback) * [SetClientHandler](Browser.md#setclienthandler) * [SetFocus](Browser.md#setfocus) * [SetMouseCursorChangeDisabled](Browser.md#setmousecursorchangedisabled) * [SetJavascriptBindings](Browser.md#setjavascriptbindings) * [SetUserData](Browser.md#setuserdata) * [SetZoomLevel](Browser.md#setzoomlevel) * [ShowDevTools](Browser.md#showdevtools) * [StartDownload](Browser.md#startdownload) * [StopLoad](Browser.md#stopload) * [StopFinding](Browser.md#stopfinding) * [ToggleFullscreen](Browser.md#togglefullscreen) * [WasResized](Browser.md#wasresized) * [WasHidden](Browser.md#washidden) * [Browser settings](BrowserSettings.md#browser-settings) * [Font settings](BrowserSettings.md#font-settings) * [accept_language_list](BrowserSettings.md#accept_language_list) * [application_cache_disabled](BrowserSettings.md#application_cache_disabled) * [background_color](BrowserSettings.md#background_color) * [databases_disabled](BrowserSettings.md#databases_disabled) * [default_encoding](BrowserSettings.md#default_encoding) * [dom_paste_disabled](BrowserSettings.md#dom_paste_disabled) * [file_access_from_file_urls_allowed](BrowserSettings.md#file_access_from_file_urls_allowed) * [image_load_disabled](BrowserSettings.md#image_load_disabled) * [javascript_disabled](BrowserSettings.md#javascript_disabled) * [javascript_open_windows_disallowed](BrowserSettings.md#javascript_open_windows_disallowed) * [javascript_close_windows_disallowed](BrowserSettings.md#javascript_close_windows_disallowed) * [javascript_access_clipboard_disallowed](BrowserSettings.md#javascript_access_clipboard_disallowed) * [local_storage_disabled](BrowserSettings.md#local_storage_disabled) * [plugins_disabled](BrowserSettings.md#plugins_disabled) * [remote_fonts](BrowserSettings.md#remote_fonts) * [shrink_standalone_images_to_fit](BrowserSettings.md#shrink_standalone_images_to_fit) * [tab_to_links_disabled](BrowserSettings.md#tab_to_links_disabled) * [text_area_resize_disabled](BrowserSettings.md#text_area_resize_disabled) * [universal_access_from_file_urls_allowed](BrowserSettings.md#universal_access_from_file_urls_allowed) * [web_security_disabled](BrowserSettings.md#web_security_disabled) * [webgl_disabled](BrowserSettings.md#webgl_disabled) * [windowless_frame_rate](BrowserSettings.md#windowless_frame_rate) * [Callback (object)](Callback.md#callback-object) * [Continue](Callback.md#continue) * [Cancel](Callback.md#cancel) * [cefpython](cefpython.md#cefpython) * [CreateBrowser](cefpython.md#createbrowser) * [CreateBrowserSync](cefpython.md#createbrowsersync) * [ExceptHook](cefpython.md#excepthook) * [GetAppSetting](cefpython.md#getappsetting) * [GetAppPath](cefpython.md#getapppath) * [GetBrowserByWindowHandle](cefpython.md#getbrowserbywindowhandle) * [GetCommandLineSwitch](cefpython.md#getcommandlineswitch) * [GetGlobalClientCallback](cefpython.md#getglobalclientcallback) * [GetModuleDirectory](cefpython.md#getmoduledirectory) * [GetVersion](cefpython.md#getversion) * [Initialize](cefpython.md#initialize) * [IsThread](cefpython.md#isthread) * [MessageLoop](cefpython.md#messageloop) * [MessageLoopWork](cefpython.md#messageloopwork) * [PostTask](cefpython.md#posttask) * [PostDelayedTask](cefpython.md#postdelayedtask) * [QuitMessageLoop](cefpython.md#quitmessageloop) * [SetGlobalClientCallback](cefpython.md#setglobalclientcallback) * [SetOsModalLoop](cefpython.md#setosmodalloop) * [Shutdown](cefpython.md#shutdown) * [Command line switches](CommandLineSwitches.md#command-line-switches) * [enable-media-stream](CommandLineSwitches.md#enable-media-stream) * [proxy-server](CommandLineSwitches.md#proxy-server) * [no-proxy-server](CommandLineSwitches.md#no-proxy-server) * [disable-gpu](CommandLineSwitches.md#disable-gpu) * [Cookie (class)](Cookie.md#cookie-class) * [Set](Cookie.md#set) * [Get](Cookie.md#get) * [SetName](Cookie.md#setname) * [GetName](Cookie.md#getname) * [SetValue](Cookie.md#setvalue) * [GetValue](Cookie.md#getvalue) * [SetDomain](Cookie.md#setdomain) * [GetDomain](Cookie.md#getdomain) * [SetPath](Cookie.md#setpath) * [GetPath](Cookie.md#getpath) * [SetSecure](Cookie.md#setsecure) * [GetSecure](Cookie.md#getsecure) * [SetHttpOnly](Cookie.md#sethttponly) * [GetHttpOnly](Cookie.md#gethttponly) * [SetCreation](Cookie.md#setcreation) * [GetCreation](Cookie.md#getcreation) * [SetLastAccess](Cookie.md#setlastaccess) * [GetLastAccess](Cookie.md#getlastaccess) * [SetHasExpires](Cookie.md#sethasexpires) * [GetHasExpires](Cookie.md#gethasexpires) * [SetExpires](Cookie.md#setexpires) * [GetExpires](Cookie.md#getexpires) * [CookieManager (class)](CookieManager.md#cookiemanager-class) * [GetGlobalManager](CookieManager.md#getglobalmanager) * [CreateManager](CookieManager.md#createmanager) * [SetSupportedSchemes](CookieManager.md#setsupportedschemes) * [VisitAllCookies](CookieManager.md#visitallcookies) * [VisitUrlCookies](CookieManager.md#visiturlcookies) * [SetCookie](CookieManager.md#setcookie) * [DeleteCookies](CookieManager.md#deletecookies) * [SetStoragePath](CookieManager.md#setstoragepath) * [FlushStore](CookieManager.md#flushstore) * [CookieVisitor (interface)](CookieVisitor.md#cookievisitor-interface) * [Visit](CookieVisitor.md#visit) * [DisplayHandler (interface)](DisplayHandler.md#displayhandler-interface) * [OnAddressChange](DisplayHandler.md#onaddresschange) * [OnTitleChange](DisplayHandler.md#ontitlechange) * [OnTooltip](DisplayHandler.md#ontooltip) * [OnStatusMessage](DisplayHandler.md#onstatusmessage) * [OnConsoleMessage](DisplayHandler.md#onconsolemessage) * [DownloadHandler](DownloadHandler.md#downloadhandler) * [DpiAware (class)](DpiAware.md#dpiaware-class) * [CalculateWindowSize](DpiAware.md#calculatewindowsize) * [EnableHighDpiSupport](DpiAware.md#enablehighdpisupport) * [GetSystemDpi](DpiAware.md#getsystemdpi) * [IsProcessDpiAware](DpiAware.md#isprocessdpiaware) * [SetProcessDpiAware](DpiAware.md#setprocessdpiaware) * [DragData (object)](DragData.md#dragdata-object) * [IsLink](DragData.md#islink) * [IsFragment](DragData.md#isfragment) * [GetLinkUrl](DragData.md#getlinkurl) * [GetLinkTitle](DragData.md#getlinktitle) * [GetFragmentText](DragData.md#getfragmenttext) * [GetFragmentHtml](DragData.md#getfragmenthtml) * [GetImage](DragData.md#getimage) * [HasImage](DragData.md#hasimage) * [FocusHandler (interface)](FocusHandler.md#focushandler-interface) * [OnTakeFocus](FocusHandler.md#ontakefocus) * [OnSetFocus](FocusHandler.md#onsetfocus) * [OnGotFocus](FocusHandler.md#ongotfocus) * [Frame (object)](Frame.md#frame-object) * [Copy](Frame.md#copy) * [Cut](Frame.md#cut) * [Delete](Frame.md#delete) * [ExecuteFunction](Frame.md#executefunction) * [ExecuteJavascript](Frame.md#executejavascript) * [GetBrowser](Frame.md#getbrowser) * [GetParent](Frame.md#getparent) * [GetIdentifier](Frame.md#getidentifier) * [GetBrowserIdentifier](Frame.md#getbrowseridentifier) * [GetName](Frame.md#getname) * [GetParent](Frame.md#getparent) * [GetProperty](Frame.md#getproperty) * [GetSource](Frame.md#getsource) * [GetText](Frame.md#gettext) * [GetUrl](Frame.md#geturl) * [IsFocused](Frame.md#isfocused) * [IsMain](Frame.md#ismain) * [IsValid](Frame.md#isvalid) * [LoadString](Frame.md#loadstring) * [LoadUrl](Frame.md#loadurl) * [Paste](Frame.md#paste) * [Redo](Frame.md#redo) * [SelectAll](Frame.md#selectall) * [SetProperty](Frame.md#setproperty) * [Undo](Frame.md#undo) * [ViewSource](Frame.md#viewsource) * [Image (object)](Image.md#image-object) * [GetAsBitmap](Image.md#getasbitmap) * [GetAsPng](Image.md#getaspng) * [GetHeight](Image.md#getheight) * [GetWidth](Image.md#getwidth) * [JavascriptBindings (class)](JavascriptBindings.md#javascriptbindings-class) * [\_\_init\_\_](JavascriptBindings.md#__init__) * [IsValueAllowed](JavascriptBindings.md#isvalueallowed) * [Rebind](JavascriptBindings.md#rebind) * [SetFunction](JavascriptBindings.md#setfunction) * [SetObject](JavascriptBindings.md#setobject) * [SetProperty](JavascriptBindings.md#setproperty) * [JavascriptCallback (object)](JavascriptCallback.md#javascriptcallback-object) * [Call](JavascriptCallback.md#call) * [GetFrame](JavascriptCallback.md#getframe) * [GetId](JavascriptCallback.md#getid) * [GetFunctionName](JavascriptCallback.md#getfunctionname) * [JavascriptDialogHandler (interface)](JavascriptDialogHandler.md#javascriptdialoghandler-interface) * [Continue](JavascriptDialogHandler.md#continue) * [OnJavascriptDialog](JavascriptDialogHandler.md#onjavascriptdialog) * [OnBeforeUnloadJavascriptDialog](JavascriptDialogHandler.md#onbeforeunloadjavascriptdialog) * [OnResetJavascriptDialogState](JavascriptDialogHandler.md#onresetjavascriptdialogstate) * [OnJavascriptDialogClosed](JavascriptDialogHandler.md#onjavascriptdialogclosed) * [KeyboardHandler (interface)](KeyboardHandler.md#keyboardhandler-interface) * [OnPreKeyEvent](KeyboardHandler.md#onprekeyevent) * [OnKeyEvent](KeyboardHandler.md#onkeyevent) * [LifespanHandler (interface)](LifespanHandler.md#lifespanhandler-interface) * [OnBeforePopup](LifespanHandler.md#onbeforepopup) * [_OnAfterCreated](LifespanHandler.md#_onaftercreated) * [DoClose](LifespanHandler.md#doclose) * [OnBeforeClose](LifespanHandler.md#onbeforeclose) * [RunModal](LifespanHandler.md#runmodal) * [LoadHandler (interface)](LoadHandler.md#loadhandler-interface) * [OnLoadingStateChange](LoadHandler.md#onloadingstatechange) * [OnLoadStart](LoadHandler.md#onloadstart) * [OnDomReady](LoadHandler.md#ondomready) * [OnLoadEnd](LoadHandler.md#onloadend) * [OnLoadError](LoadHandler.md#onloaderror) * [Network error](NetworkError.md#network-error) * [ERR_NONE](NetworkError.md#err_none) * [ERR_ABORTED](NetworkError.md#err_aborted) * [ERR_ACCESS_DENIED](NetworkError.md#err_access_denied) * [ERR_ADDRESS_INVALID](NetworkError.md#err_address_invalid) * [ERR_ADDRESS_UNREACHABLE](NetworkError.md#err_address_unreachable) * [ERR_CACHE_MISS](NetworkError.md#err_cache_miss) * [ERR_CERT_AUTHORITY_INVALID](NetworkError.md#err_cert_authority_invalid) * [ERR_CERT_COMMON_NAME_INVALID](NetworkError.md#err_cert_common_name_invalid) * [ERR_CERT_CONTAINS_ERRORS](NetworkError.md#err_cert_contains_errors) * [ERR_CERT_DATE_INVALID](NetworkError.md#err_cert_date_invalid) * [ERR_CERT_END](NetworkError.md#err_cert_end) * [ERR_CERT_INVALID](NetworkError.md#err_cert_invalid) * [ERR_CERT_NO_REVOCATION_MECHANISM](NetworkError.md#err_cert_no_revocation_mechanism) * [ERR_CERT_REVOKED](NetworkError.md#err_cert_revoked) * [ERR_CERT_UNABLE_TO_CHECK_REVOCATION](NetworkError.md#err_cert_unable_to_check_revocation) * [ERR_CONNECTION_ABORTED](NetworkError.md#err_connection_aborted) * [ERR_CONNECTION_CLOSED](NetworkError.md#err_connection_closed) * [ERR_CONNECTION_FAILED](NetworkError.md#err_connection_failed) * [ERR_CONNECTION_REFUSED](NetworkError.md#err_connection_refused) * [ERR_CONNECTION_RESET](NetworkError.md#err_connection_reset) * [ERR_DISALLOWED_URL_SCHEME](NetworkError.md#err_disallowed_url_scheme) * [ERR_EMPTY_RESPONSE](NetworkError.md#err_empty_response) * [ERR_FAILED](NetworkError.md#err_failed) * [ERR_FILE_NOT_FOUND](NetworkError.md#err_file_not_found) * [ERR_FILE_TOO_BIG](NetworkError.md#err_file_too_big) * [ERR_INSECURE_RESPONSE](NetworkError.md#err_insecure_response) * [ERR_INTERNET_DISCONNECTED](NetworkError.md#err_internet_disconnected) * [ERR_INVALID_ARGUMENT](NetworkError.md#err_invalid_argument) * [ERR_INVALID_CHUNKED_ENCODING](NetworkError.md#err_invalid_chunked_encoding) * [ERR_INVALID_HANDLE](NetworkError.md#err_invalid_handle) * [ERR_INVALID_RESPONSE](NetworkError.md#err_invalid_response) * [ERR_INVALID_URL](NetworkError.md#err_invalid_url) * [ERR_METHOD_NOT_SUPPORTED](NetworkError.md#err_method_not_supported) * [ERR_NAME_NOT_RESOLVED](NetworkError.md#err_name_not_resolved) * [ERR_NO_SSL_VERSIONS_ENABLED](NetworkError.md#err_no_ssl_versions_enabled) * [ERR_NOT_IMPLEMENTED](NetworkError.md#err_not_implemented) * [ERR_RESPONSE_HEADERS_TOO_BIG](NetworkError.md#err_response_headers_too_big) * [ERR_SSL_CLIENT_AUTH_CERT_NEEDED](NetworkError.md#err_ssl_client_auth_cert_needed) * [ERR_SSL_PROTOCOL_ERROR](NetworkError.md#err_ssl_protocol_error) * [ERR_SSL_RENEGOTIATION_REQUESTED](NetworkError.md#err_ssl_renegotiation_requested) * [ERR_SSL_VERSION_OR_CIPHER_MISMATCH](NetworkError.md#err_ssl_version_or_cipher_mismatch) * [ERR_TIMED_OUT](NetworkError.md#err_timed_out) * [ERR_TOO_MANY_REDIRECTS](NetworkError.md#err_too_many_redirects) * [ERR_TUNNEL_CONNECTION_FAILED](NetworkError.md#err_tunnel_connection_failed) * [ERR_UNEXPECTED](NetworkError.md#err_unexpected) * [ERR_UNEXPECTED_PROXY_AUTH](NetworkError.md#err_unexpected_proxy_auth) * [ERR_UNKNOWN_URL_SCHEME](NetworkError.md#err_unknown_url_scheme) * [ERR_UNSAFE_PORT](NetworkError.md#err_unsafe_port) * [ERR_UNSAFE_REDIRECT](NetworkError.md#err_unsafe_redirect) * [PaintBuffer (object)](PaintBuffer.md#paintbuffer-object) * [GetIntPointer](PaintBuffer.md#getintpointer) * [GetString](PaintBuffer.md#getstring) * [RenderHandler (interface)](RenderHandler.md#renderhandler-interface) * [GetRootScreenRect](RenderHandler.md#getrootscreenrect) * [GetViewRect](RenderHandler.md#getviewrect) * [GetScreenRect](RenderHandler.md#getscreenrect) * [GetScreenPoint](RenderHandler.md#getscreenpoint) * [OnPopupShow](RenderHandler.md#onpopupshow) * [OnPopupSize](RenderHandler.md#onpopupsize) * [OnPaint](RenderHandler.md#onpaint) * [OnCursorChange](RenderHandler.md#oncursorchange) * [OnScrollOffsetChanged](RenderHandler.md#onscrolloffsetchanged) * [StartDragging](RenderHandler.md#startdragging) * [UpdateDragCursor](RenderHandler.md#updatedragcursor) * [Request (class)](Request.md#request-class) * [CreateRequest](Request.md#createrequest) * [IsReadOnly](Request.md#isreadonly) * [GetUrl](Request.md#geturl) * [SetUrl](Request.md#seturl) * [GetMethod](Request.md#getmethod) * [SetMethod](Request.md#setmethod) * [GetPostData](Request.md#getpostdata) * [SetPostData](Request.md#setpostdata) * [GetHeaderMap](Request.md#getheadermap) * [GetHeaderMultimap](Request.md#getheadermultimap) * [SetHeaderMap](Request.md#setheadermap) * [SetHeaderMultimap](Request.md#setheadermultimap) * [GetFlags](Request.md#getflags) * [SetFlags](Request.md#setflags) * [GetFirstPartyForCookies](Request.md#getfirstpartyforcookies) * [SetFirstPartyForCookies](Request.md#setfirstpartyforcookies) * [GetResourceType](Request.md#getresourcetype) * [GetTransitionType](Request.md#gettransitiontype) * [RequestHandler (interface)](RequestHandler.md#requesthandler-interface) * [OnBeforeBrowse](RequestHandler.md#onbeforebrowse) * [OnBeforeResourceLoad](RequestHandler.md#onbeforeresourceload) * [GetResourceHandler](RequestHandler.md#getresourcehandler) * [OnResourceRedirect](RequestHandler.md#onresourceredirect) * [OnResourceResponse](RequestHandler.md#onresourceresponse) * [GetAuthCredentials](RequestHandler.md#getauthcredentials) * [OnQuotaRequest](RequestHandler.md#onquotarequest) * [GetCookieManager](RequestHandler.md#getcookiemanager) * [OnProtocolExecution](RequestHandler.md#onprotocolexecution) * [_OnBeforePluginLoad](RequestHandler.md#_onbeforepluginload) * [_OnCertificateError](RequestHandler.md#_oncertificateerror) * [OnRendererProcessTerminated](RequestHandler.md#onrendererprocessterminated) * [OnPluginCrashed](RequestHandler.md#onplugincrashed) * [ResourceHandler (interface)](ResourceHandler.md#resourcehandler-interface) * [ProcessRequest](ResourceHandler.md#processrequest) * [GetResponseHeaders](ResourceHandler.md#getresponseheaders) * [ReadResponse](ResourceHandler.md#readresponse) * [CanGetCookie](ResourceHandler.md#cangetcookie) * [CanSetCookie](ResourceHandler.md#cansetcookie) * [Cancel](ResourceHandler.md#cancel) * [Response (object)](Response.md#response-object) * [IsReadOnly](Response.md#isreadonly) * [GetStatus](Response.md#getstatus) * [SetStatus](Response.md#setstatus) * [GetStatusText](Response.md#getstatustext) * [SetStatusText](Response.md#setstatustext) * [GetMimeType](Response.md#getmimetype) * [SetMimeType](Response.md#setmimetype) * [GetHeader](Response.md#getheader) * [GetHeaderMap](Response.md#getheadermap) * [GetHeaderMultimap](Response.md#getheadermultimap) * [SetHeaderMap](Response.md#setheadermap) * [SetHeaderMultimap](Response.md#setheadermultimap) * [StringVisitor (interface)](StringVisitor.md#stringvisitor-interface) * [Visit](StringVisitor.md#visit) * [V8ContextHandler (interface)](V8ContextHandler.md#v8contexthandler-interface) * [OnContextCreated](V8ContextHandler.md#oncontextcreated) * [OnContextReleased](V8ContextHandler.md#oncontextreleased) * [Virtual Key codes](VirtualKey.md#virtual-key-codes) * [WebPluginInfo (object)](WebPluginInfo.md#webplugininfo-object) * [GetName](WebPluginInfo.md#getname) * [GetPath](WebPluginInfo.md#getpath) * [GetVersion](WebPluginInfo.md#getversion) * [GetDescription](WebPluginInfo.md#getdescription) * [WebRequest (class)](WebRequest.md#webrequest-class) * [Create](WebRequest.md#create) * [GetRequest](WebRequest.md#getrequest) * [GetRequestStatus](WebRequest.md#getrequeststatus) * [GetRequestError](WebRequest.md#getrequesterror) * [GetResponse](WebRequest.md#getresponse) * [Cancel](WebRequest.md#cancel) * [WebRequestClient (interface)](WebRequestClient.md#webrequestclient-interface) * [OnUploadProgress](WebRequestClient.md#onuploadprogress) * [OnDownloadProgress](WebRequestClient.md#ondownloadprogress) * [OnDownloadData](WebRequestClient.md#ondownloaddata) * [OnRequestComplete](WebRequestClient.md#onrequestcomplete) * [WindowInfo (class)](WindowInfo.md#windowinfo-class) * [SetAsChild](WindowInfo.md#setaschild) * [SetAsPopup](WindowInfo.md#setaspopup) * [SetAsOffscreen](WindowInfo.md#setasoffscreen) * [SetTransparentPainting](WindowInfo.md#settransparentpainting) * [WindowUtils (class)](WindowUtils.md#windowutils-class) * [OnSetFocus ](WindowUtils.md#onsetfocus-win) * [OnSize ](WindowUtils.md#onsize-win) * [OnEraseBackground ](WindowUtils.md#onerasebackground-win) * [SetTitle ](WindowUtils.md#settitle-win) * [SetIcon ](WindowUtils.md#seticon-win) * [UpdateBrowserSize ](WindowUtils.md#updatebrowsersize-win) * [GetParentHandle](WindowUtils.md#getparenthandle) * [IsWindowHandle](WindowUtils.md#iswindowhandle) * [gtk_plug_new ](WindowUtils.md#gtk_plug_new-linux) * [gtk_widget_show ](WindowUtils.md#gtk_widget_show-linux) * [InstallX11ErrorHandlers ](WindowUtils.md#installx11errorhandlers-linux) cefpython-49.0/api/ApplicationSettings.md000066400000000000000000000402561334103266300205340ustar00rootroot00000000000000[API categories](API-categories.md) | [API index](API-index.md) # Application settings Table of contents: * [Introduction](#introduction) * [Settings](#settings) * [accept_language_list](#accept_language_list) * [app_user_model_id](#app_user_model_id) * [auto_zooming](#auto_zooming) * [background_color](#background_color) * [browser_subprocess_path](#browser_subprocess_path) * [cache_path](#cache_path) * [command_line_args_disabled](#command_line_args_disabled) * [context_menu](#context_menu) * [downloads_enabled](#downloads_enabled) * [ignore_certificate_errors](#ignore_certificate_errors) * [javascript_flags](#javascript_flags) * [locale](#locale) * [locales_dir_path](#locales_dir_path) * [debug](#debug) * [log_file](#log_file) * [log_severity](#log_severity) * [multi_threaded_message_loop](#multi_threaded_message_loop) * [pack_loading_disabled](#pack_loading_disabled) * [persist_session_cookies](#persist_session_cookies) * [persist_user_preferences](#persist_user_preferences) * [product_version](#product_version) * [remote_debugging_port](#remote_debugging_port) * [resources_dir_path](#resources_dir_path) * [single_process](#single_process) * [string_encoding](#string_encoding) * [uncaught_exception_stack_size](#uncaught_exception_stack_size) * [unique_request_context_per_browser](#unique_request_context_per_browser) * [user_agent](#user_agent) * [user_data_path](#user_data_path) * [windowless_rendering_enabled](#windowless_rendering_enabled) ## Introduction These settings can be passed when calling [cefpython](cefpython.md).Initialize() . The default values of options that are suggested in descriptions may not always be correct, it may be best to set them explicitily. There are hundreds of options that can be set through CEF/Chromium command line switches. These switches can be set programmatically by passing a dictionary with switches as second argument to [cefpython](cefpython.md).Initialize(). See the [CommandLineSwitches](CommandLineSwitches.md) wiki page for more information. Issue #244 is to add even more configurable settings by exposing API to Chromium Preferences. ## Settings ### accept_language_list (string) Comma delimited ordered list of language codes without any whitespace that will be used in the "Accept-Language" HTTP header. May be overridden on a per-browser basis using the CefBrowserSettings.accept_language_list value. If both values are empty then "en-US,en" will be used. Can be overridden for individual CefRequestContext instances via the CefRequestContextSettings.accept_language_list value. ### app_user_model_id This is setting is applied only on Windows. It sets [AppUserModelID](https://msdn.microsoft.com/en-us/library/windows/desktop/dd378459(v=vs.85).aspx) (also known as AppID) for all processes (Browser, Renderer, GPU, etc.). Setting this is required on Windows 10 to workaround issues related to pinning app to Taskbar. More details can be found in [Issue #395](https://github.com/cztomczak/cefpython/issues/395). Internally this setting will append "--app-user-model-id" switch to all processes. ### auto_zooming (string) Windows only. Perform automatic zooming of browser contents. Example values for auto_zooming (numeric value means a zoom level): * "" - default is empty string * "0.0" (96 DPI) * "1.0" (120 DPI) * "2.0" (144 DPI) * "-1.0" (72 DPI) * "system_dpi" - Deprecated. Use system DPI settings. This value is deprecated, as it is no more required to set auto_zooming to this value after High DPI support was enabled. Example values that can be set in Win7 DPI settings (Control Panel Appearance and Personalization Display): * Smaller 100% (Default) = 96 DPI = 0.0 zoom level * Medium 125% = 120 DPI = 1.0 zoom level * Larger 150% = 144 DPI = 2.0 zoom level * Custom 75% = 72 DPI = -1.0 zoom level ### background_color (int) Opaque background color used for accelerated content. By default the background color will be white. Only the RGB compontents of the specified value will be used. The alpha component must greater than 0 to enable use of the background color but will be otherwise ignored. 32-bit ARGB color value, not premultiplied. The color components are always in a known order. Equivalent to the `SkColor` type. ### browser_subprocess_path (string) The path to a separate executable that will be launched for sub-processes. If this value is empty on Windows or Linux then the main process executable will be used. If this value is empty on macOS then a helper executable must exist at "Contents/Frameworks/ Helper.app/Contents/MacOS/ Helper" in the top-level app bundle. See the comments on CefExecuteProcess() for details. Also configurable using the "browser-subprocess-path" command-line switch. ### cache_path (string) The location where cache data will be stored on disk. If empty then browsers will be created in "incognito mode" where in-memory caches are used for storage and no data is persisted to disk. HTML5 databases such as localStorage will only persist across sessions if a cache path is specified. Can be overridden for individual CefRequestContext instances via the CefRequestContextSettings.cache_path value. CEF flushes cookies or other cache data to disk every 30 seconds, or immediately when [cefpython](cefpython.md).Shutdown() is called. When this option is not set (empty string), a unique cache directory will be created in the user's temp directory for each run of the application. ### command_line_args_disabled (bool) Set to true (1) to disable configuration of browser process features using standard CEF and Chromium [command-line arguments](CommandLineSwitches.md). Configuration can still be specified using CEF data structures or via the `CefApp::OnBeforeCommandLineProcessing()` method. ### context_menu (dict) Configure mouse context menu. All dict values are of type bool and are True by default. * `enabled` - whether to enable mouse context menu * `navigation` - show the "Back", "Forward" and "Reload" items. The "Reload" option calls [Browser](Browser.md).`ReloadIgnoreCache`. * `print` - show the "Print..." item * `view_source` - show the "View source" item * `external_browser` - show the "Open in external browser" and "Open frame in external browser" options. On Linux the external browser is not focused when opening url. * `devtools` - show the "Developer Tools" option. See also ApplicationSettings.`remote_debugging_port`. ### downloads_enabled (bool) Default: True Downloads are handled automatically. A default `SaveAs` file dialog provided by OS is displayed. See also the [DownloadHandler](DownloadHandler.md) wiki page. ### ignore_certificate_errors (bool) Set to true (1) to ignore errors related to invalid SSL certificates. Enabling this setting can lead to potential security vulnerabilities like "man in the middle" attacks. Applications that load content from the internet should not enable this setting. Also configurable using the "ignore-certificate-errors" [command-line switch](CommandLineSwitches.md). Can be overridden for individual CefRequestContext instances via the CefRequestContextSettings.ignore_certificate_errors value. __IMPORTANT__: This option not only ignores all certificate errors, but it also enables caching of content due to custom patch being applied (read more in "NOTE ON CACHING" further down). If you don't want this caching feature of insecure content then alternatively you can ignore certificate errors using the RequestHandler.[_OnCertificateError()](#_oncertificateerror) callback. Note that disk caching is enabled only when the "cache_path" option is set. __NOTE ON CACHING__: the official CEF Python binary releases incorporate a patch that changes the caching behavior on sites with SSL certificate errors when used with this setting. Chromium by default disallows caching of content when there is certificate error. CEF Python applies a patch to Chromium sources to allow for caching even when there is certificate error, but only when the "ignore_certificate_errors" option is set to True. When it's set to False then the Chromium's caching behavior does not change. Enabling caching with certificate errors is useful on local private networks that use self-signed SSL certificates. See the referenced CEF topic in [Issue #125](../issues/125) for more details. ### javascript_flags (string) Custom flags that will be used when initializing the V8 Javascript engine. The consequences of using custom flags may not be well tested. Also configurable using the --js-flags switch. To enable WebAssembly support set the `--expose-wasm` flag. ### locale (string) The locale string that will be passed to Webkit. If empty the default locale of "en-US" will be used. This value is ignored on Linux where locale is determined using environment variable parsing with the precedence order: LANGUAGE, LC_ALL, LC_MESSAGES and LANG. Also configurable using the "lang" [command-line switch](CommandLineSwitches.md). ### locales_dir_path (string) The fully qualified path for the locales directory. If this value is empty the locales directory must be located in the module directory. This value is ignored on Mac OS X where pack files are always loaded from the app bundle Resources directory. Also configurable using the "locales-dir-path" [command-line switch](CommandLineSwitches.md). ### debug (bool) Whether cefpython should display debug messages in console and write them to "log_file" (see the next option). In previous versions of cefpython, this option was set by overwriting module's g_debug global variable, this way of setting is now deprecated. ### log_file (string) The directory and file name to use for the debug log. If empty a default log file name and location will be used. On Windows and Linux a "debug.log" file will be written in the main executable directory. On Mac OS X a "~/Library/Logs/_debug.log" file will be written where is the name of the main app executable. Also configurable using the "log-file" command-line switch. ### log_severity (int) The log severity. Only messages of this severity level or higher will be logged. Also configurable using the --log-severity switch with a value of "verbose", "info", "warning", "error", "error-report" or "disable". Accepted values - constants available in the cefpython module: * LOGSEVERITY_VERBOSE * LOGSEVERITY_INFO * LOGSEVERITY_WARNING * LOGSEVERITY_ERROR (default) * LOGSEVERITY_ERROR_REPORT * LOGSEVERITY_DISABLE ### multi_threaded_message_loop (bool) Set to true (1) to have the browser process message loop run in a separate thread. If false (0) than the [cefpython](cefpython.md).MessageLoopWork() function must be called from your application message loop. This option is only supported on Windows. This option is not and cannot be supported on OS-X for architectural reasons. ### pack_loading_disabled (bool) Set to true (1) to disable loading of pack files for resources and locales. A resource bundle handler must be provided for the browser and render processes via `CefApp::GetResourceBundleHandler()` if loading of pack files is disabled. Also configurable using the --disable-pack-loading switch. ### persist_session_cookies (bool) To persist session cookies (cookies without an expiry date or validity interval) by default when using the global cookie manager set this value to true. Session cookies are generally intended to be transient and most Web browsers do not persist them. A |cache_path| value must also be specified to enable this feature. Also configurable using the "persist-session-cookies" [command-line switch](CommandLineSwitches.md). ### persist_user_preferences (bool) To persist user preferences as a JSON file in the cache path directory set this value to true (1). A |cache_path| value must also be specified to enable this feature. Also configurable using the "persist-user-preferences" command-line switch. Can be overridden for individual CefRequestContext instances via the CefRequestContextSettings.persist_user_preferences value. ### product_version (string) Value that will be inserted as the product portion of the default User-Agent string. If empty the Chromium product version will be used. If |userAgent| is specified this value will be ignored. Also configurable using the --product-version switch. ### remote_debugging_port (int) Set to a value between 1024 and 65535 to enable remote debugging on the specified port. For example, if 8080 is specified the remote debugging URL will be http://127.0.0.1:8080. CEF can be remotely debugged from CEF or Chrome browser window. Also configurable using the "remote-debugging-port" [command-line switch](CommandLineSwitches.md). A default value of 0 will generate a random port between 49152–65535. A value of -1 will disable remote debugging. NOTE: Do not use the --remote-debugging-port command line switch, as it collides with this option. ### resources_dir_path (string) The fully qualified path for the resources directory. If this value is empty the cef.pak and/or devtools_resources.pak files must be located in the module directory on Windows/Linux or the app bundle Resources directory on Mac OS X. Also configurable using the --resources-dir-path switch. ### single_process (bool) Set to true (1) to use a single process for the browser and renderer. This run mode is not officially supported by Chromium and is less stable than the multi-process default. Also configurable using the "single-process" [command-line switch](CommandLineSwitches.md). ### string_encoding (string) What kind of encoding should we use when converting unicode string to bytes string. This conversion is done when you pass a unicode string to javascript. This encoding is also used when converting bytes to unicode, this includes the post data in the [Request](Request.md) object. The default is "utf-8". The behavior for encode/decode errors is to replace the unknown character with "?", this can be changed in the "string_utils.pyx" file through UNICODE_ENCODE_ERRORS/BYTES_DECODE_ERRORS constants. ### uncaught_exception_stack_size (int) The number of stack trace frames to capture for uncaught exceptions. Specify a positive value to enable the [V8ContextHandler](V8ContextHandler.md).OnUncaughtException() callback. Specify 0 (default value) and OnUncaughtException() will not be called. Also configurable using the "uncaught-exception-stack-size" [command-line switch](CommandLineSwitches.md). ### unique_request_context_per_browser (bool) A request context provides request handling for a set of related browser objects. Browser objects with different request contexts will never be hosted in the same render process. Browser objects with the same request context may or may not be hosted in the same render process depending on the process model. Browser objects created indirectly via the JavaScript window.open function or targeted links will share the same render process and the same request context as the source browser. To successfully implement separate cookie manager per browser session with the use of the RequestHandler.`GetCookieManager` callback, you have to set `unique_request_context_per_browser` to True. In upstream CEF each request context may have separate settings like cache_path, persist_session_cookies, persist_user_preferences, ignore_certificate_errors, accept_language_list. Such functionality wasn't yet exposed in CEF Python. ### user_agent (string) Value that will be returned as the User-Agent HTTP header. If empty the default User-Agent string will be used. Also configurable using the "user-agent" [command-line switch](CommandLineSwitches.md). ### user_data_path (string) The location where user data such as spell checking dictionary files will be stored on disk. If empty then the default platform-specific user data directory will be used (`"~/.cef_user_data"` directory on Linux, `"~/Library/Application Support/CEF/User Data"` directory on Mac OS X, `"Local Settings\Application Data\CEF\User Data"` directory under the user profile directory on Windows). ### windowless_rendering_enabled (bool) Set to true (1) to enable windowless (off-screen) rendering support. Do not enable this value if the application does not use windowless rendering as it may reduce rendering performance on some systems. cefpython-49.0/api/Browser.md000066400000000000000000000540631334103266300161740ustar00rootroot00000000000000[API categories](API-categories.md) | [API index](API-index.md) # Browser (object) Remember to free all browser references when closing app for the browser to shut down cleanly. Otherwise data such as cookies or other storage might not be flushed to disk when closing app, and other issues might occur as well. To free a reference just assign a None value to a browser variable. To compare browser objects always use [GetIdentifier()](#getidentifier) method. Do not compare two Browser objects variables directly. Table of contents: * [Notes](#notes) * [Methods](#methods) * [AddWordToDictionary](#addwordtodictionary) * [CanGoBack](#cangoback) * [CanGoForward](#cangoforward) * [CloseBrowser](#closebrowser) * [CloseDevTools](#closedevtools) * [DragTargetDragEnter](#dragtargetdragenter) * [DragTargetDragOver](#dragtargetdragover) * [DragTargetDragLeave](#dragtargetdragleave) * [DragTargetDrop](#dragtargetdrop) * [DragSourceEndedAt](#dragsourceendedat) * [DragSourceSystemDragEnded](#dragsourcesystemdragended) * [ExecuteFunction](#executefunction) * [ExecuteJavascript](#executejavascript) * [Find](#find) * [GetClientCallback](#getclientcallback) * [GetClientCallbacksDict](#getclientcallbacksdict) * [GetFocusedFrame](#getfocusedframe) * [GetFrame](#getframe) * [GetFrameByIdentifier](#getframebyidentifier) * [GetFrames](#getframes) * [GetFrameCount](#getframecount) * [GetFrameIdentifiers](#getframeidentifiers) * [GetFrameNames](#getframenames) * [GetJavascriptBindings](#getjavascriptbindings) * [GetMainFrame](#getmainframe) * [GetNSTextInputContext](#getnstextinputcontext) * [GetOpenerWindowHandle](#getopenerwindowhandle) * [GetOuterWindowHandle](#getouterwindowhandle) * [GetUrl](#geturl) * [GetUserData](#getuserdata) * [GetWindowHandle](#getwindowhandle) * [GetIdentifier](#getidentifier) * [GetZoomLevel](#getzoomlevel) * [GoBack](#goback) * [GoForward](#goforward) * [HandleKeyEventAfterTextInputClient](#handlekeyeventaftertextinputclient) * [HandleKeyEventBeforeTextInputClient](#handlekeyeventbeforetextinputclient) * [HasDocument](#hasdocument) * [IsFullscreen](#isfullscreen) * [IsLoading](#isloading) * [IsMouseCursorChangeDisabled](#ismousecursorchangedisabled) * [IsPopup](#ispopup) * [IsWindowRenderingDisabled](#iswindowrenderingdisabled) * [LoadUrl](#loadurl) * [Navigate](#navigate) * [NotifyMoveOrResizeStarted](#notifymoveorresizestarted) * [NotifyScreenInfoChanged](#notifyscreeninfochanged) * [ParentWindowWillClose](#parentwindowwillclose) * [Reload](#reload) * [ReloadIgnoreCache](#reloadignorecache) * [ReplaceMisspelling](#replacemisspelling) * [SetBounds](#setbounds) * [SendKeyEvent](#sendkeyevent) * [SendMouseClickEvent](#sendmouseclickevent) * [SendMouseMoveEvent](#sendmousemoveevent) * [SendMouseWheelEvent](#sendmousewheelevent) * [SendFocusEvent](#sendfocusevent) * [SendCaptureLostEvent](#sendcapturelostevent) * [SetClientCallback](#setclientcallback) * [SetClientHandler](#setclienthandler) * [SetFocus](#setfocus) * [SetMouseCursorChangeDisabled](#setmousecursorchangedisabled) * [SetJavascriptBindings](#setjavascriptbindings) * [SetUserData](#setuserdata) * [SetZoomLevel](#setzoomlevel) * [ShowDevTools](#showdevtools) * [StartDownload](#startdownload) * [StopLoad](#stopload) * [StopFinding](#stopfinding) * [ToggleFullscreen](#togglefullscreen) * [WasResized](#wasresized) * [WasHidden](#washidden) ## Notes There are some edge cases when after the OnBeforeClose event browser objects are no more globally referenced thus a new instance is created that wraps upstream CefBrowser object. Browser objects that were globally unreferenced do not have properties of the original Browser object, for example they do not have client callbacks, javascript bindings or user data set. ## Methods ### AddWordToDictionary | Parameter | Type | | --- | --- | | word | string | | __Return__ | void | Add the specified |word| to the spelling dictionary. ### CanGoBack | | | | --- | --- | | __Return__ | bool | Returns true if the browser can navigate backwards. ### CanGoForward | | | | --- | --- | | __Return__ | bool | Returns true if the browser can navigate forwards. ### CloseBrowser | Parameter | Type | | --- | --- | | forceClose | bool | | __Return__ | void | Closes the browser. If the window was created explicitily by you (not a popup) you still need to post WM_DESTROY message to the window. Request that the browser close. The Javascript 'onbeforeunload' event will be fired. If |force_close| is false the event handler, if any, will be allowed to prompt the user and the user can optionally cancel the close. If |force_close| is true the prompt will not be displayed and the close will proceed. Results in a call to LifespanHandler::DoClose() if the event handler allows the close or if |force_close| is true. See LifespanHandler::DoClose() documentation for additional usage information. ### CloseDevTools | | | | --- | --- | | __Return__ | bool | Explicitly close the associated DevTools browser, if any. ### DragTargetDragEnter | Parameter | Type | | --- | --- | | drag_data | [DragData](DragData.md) | | x | int | | y | int | | allowed_ops | int | | __Return__ | void | Description from upstream CEF: > Call this method when the user drags the mouse into the web view (before > calling DragTargetDragOver/DragTargetLeave/DragTargetDrop). > |drag_data| should not contain file contents as this type of data is not > allowed to be dragged into the web view. File contents can be removed using > CefDragData::ResetFileContents (for example, if |drag_data| comes from > CefRenderHandler::StartDragging). > This method is only used when window rendering is disabled. ### DragTargetDragOver | Parameter | Type | | --- | --- | | x | int | | y | int | | allowed_ops | int | | __Return__ | void | Description from upstream CEF: > Call this method each time the mouse is moved across the web view during > a drag operation (after calling DragTargetDragEnter and before calling > DragTargetDragLeave/DragTargetDrop). > This method is only used when window rendering is disabled. ### DragTargetDragLeave | | | | --- | --- | | __Return__ | void | Description from upstream CEF: > Call this method when the user drags the mouse out of the web view (after > calling DragTargetDragEnter). > This method is only used when window rendering is disabled. ### DragTargetDrop | Parameter | Type | | --- | --- | | x | int | | y | int | | __Return__ | void | Description from upstream CEF: > Call this method when the user completes the drag operation by dropping > the object onto the web view (after calling DragTargetDragEnter). > The object being dropped is |drag_data|, given as an argument to > the previous DragTargetDragEnter call. > This method is only used when window rendering is disabled. ### DragSourceEndedAt | Parameter | Type | | --- | --- | | x | int | | y | int | | operation | int | | __Return__ | void | Description from upstream CEF: > Call this method when the drag operation started by a > CefRenderHandler::StartDragging call has ended either in a drop or > by being cancelled. |x| and |y| are mouse coordinates relative to the > upper-left corner of the view. If the web view is both the drag source > and the drag target then all DragTarget* methods should be called before > DragSource* mthods. > This method is only used when window rendering is disabled. Operation enum from upstream CEF - these constants are declared in the `cefpython` module: > DRAG_OPERATION_NONE = 0, > DRAG_OPERATION_COPY = 1, > DRAG_OPERATION_LINK = 2, > DRAG_OPERATION_GENERIC = 4, > DRAG_OPERATION_PRIVATE = 8, > DRAG_OPERATION_MOVE = 16, > DRAG_OPERATION_DELETE = 32, > DRAG_OPERATION_EVERY = UINT_MAX ### DragSourceSystemDragEnded | | | | --- | --- | | __Return__ | void | Description from upstream CEF: > Call this method when the drag operation started by a > CefRenderHandler::StartDragging call has completed. This method may be > called immediately without first calling DragSourceEndedAt to cancel a > drag operation. If the web view is both the drag source and the drag > target then all DragTarget* methods should be called before DragSource* > mthods. > This method is only used when window rendering is disabled. ### ExecuteFunction | Parameter | Type | | --- | --- | | funcName | string | | [params..] | mixed | | __Return__ | void | Call javascript function asynchronously. This can also call object's methods, just pass "object.method" as `funcName`. Any valid javascript syntax is allowed as `funcName`, you could even pass an anonymous function here. For a list of allowed types for `mixed` see [JavascriptBindings](JavascriptBindings.md).IsValueAllowed() (except function, method and instance). Passing a python function here is not allowed, it is only possible through [JavascriptCallback](JavascriptCallback.md) object. ### ExecuteJavascript | Parameter | Type | | --- | --- | | jsCode | string | | scriptUrl="" | string | | startLine=1 | int | | __Return__ | void | Execute a string of JavaScript code in this frame. The `sciptURL` 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 `startLine` parameter is the base line number to use for error reporting. This function executes asynchronously so there is no way to get the returned value. Calling javascript from native code synchronously is not possible in CEF 3. It is also not possible doing it synchronously the other way around ie. js->native. ### Find | Parameter | Type | | --- | --- | | searchID | int | | searchText | string | | forward | bool | | matchCase | bool | | findNext | bool | | __Return__ | void | Search for |searchText|. |searchID| can be custom, it is so that you can have multiple searches running simultaneously. |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. The CefFindHandler instance, if any, returned via CefClient::GetFindHandler will be called to report find results. ### GetClientCallback | Parameter | Type | | --- | --- | | name | string | | __Return__ | func | Get client callback by name. ### GetClientCallbacksDict | | | | --- | --- | | __Return__ | dict | Get client callbacks as a dictionary. ### GetFocusedFrame | | | | --- | --- | | __Return__ | Frame | Returns the focused [Frame](Frame.md) for the browser window. ### GetFrame | Parameter | Type | | --- | --- | | name | string | | __Return__ | Frame | Returns the [Frame](Frame.md) with the specified name, or NULL if not found. ### GetFrameByIdentifier | Parameter | Type | | --- | --- | | identifier | long | | __Return__ | Frame | Available only in CEF 3. Returns the [Frame](Frame.md) with the specified identifier, or None if not found. ### GetFrames | | | | --- | --- | | __Return__ | list | Get all frames. This is an internal CEF Python implementation that uses GetFrameNames() and GetFrame() methods to list through all frames. The main frame is not included in that list. ### GetFrameCount | | | | --- | --- | | __Return__ | int | Available only in CEF 3. Not yet implemented. Returns the number of frames that currently exist. ### GetFrameIdentifiers | | | | --- | --- | | __Return__ | void | Available only in CEF 3. Not yet implemented. Returns the identifiers of all existing frames. ### GetFrameNames | | | | --- | --- | | __Return__ | string[] | Returns the names of all existing frames. This list does not include the main frame. ### GetJavascriptBindings | | | | --- | --- | | __Return__ | [JavascriptBindings](JavascriptBindings.md) | Returns the [JavascriptBindings](JavascriptBindings.md) object that was passed to [cefpython](cefpython.md).CreateBrowserSync(). ### GetMainFrame | | | | --- | --- | | __Return__ | Frame | Returns the main (top-level) [Frame](Frame.md) for the browser window. ### GetNSTextInputContext | | | | --- | --- | | __Return__ | TextInputContext | Not yet ported. Available only in CEF 3. Get the NSTextInputContext implementation for enabling IME on Mac when window rendering is disabled. ### GetOpenerWindowHandle | | | | --- | --- | | __Return__ | windowHandle | Retrieve the CEF-internal (inner or outer) window handle of the browser that opened this browser. Will return None for non-popup windows. See GetWindowHandle() for an explanation of inner/outer window handles. ### GetOuterWindowHandle | | | | --- | --- | | __Return__ | windowHandle | Get the most outer window handle. ### GetUrl | | | | --- | --- | | __Return__ | string | Get url of the main frame. ### GetUserData | Parameter | Type | | --- | --- | | key | mixed | | __Return__ | mixed | Get user data. See also SetUserData(). ### GetWindowHandle | | | | --- | --- | | __Return__ | windowHandle | Returns an inner or outer window handle for the browser. If the browser was created using CreateBrowserSync() then this will return an inner CEF-internal window handle. If this is a popup browser created from javascript using `window.open()` and its [WindowInfo](WindowInfo.md) has not been set in LifespanHandler.OnAfterCreated(), then it returns CEF-internal window handle which is the most outer window handle in this case. ### GetIdentifier | | | | --- | --- | | __Return__ | int | Returns the globally unique identifier for this browser. ### GetZoomLevel | | | | --- | --- | | __Return__ | float | Get the current zoom level. The default zoom level is 0.0. ### GoBack | | | | --- | --- | | __Return__ | void | Navigate backwards. ### GoForward | | | | --- | --- | | __Return__ | void | Navigate forwards. ### HandleKeyEventAfterTextInputClient | Parameter | Type | | --- | --- | | keyEvent | eventHandle | | __Return__ | void | Available only in CEF 3. Not yet implemented. Performs any additional actions after NSTextInputClient handles the event. ### HandleKeyEventBeforeTextInputClient | | | | --- | --- | | __Return__ | void | Available only in CEF 3. Not yet implemented. Handles a keyDown event prior to passing it through the NSTextInputClient machinery. ### HasDocument | | | | --- | --- | | __Return__ | bool | Returns true if a document has been loaded in the browser. ### IsFullscreen | | | | --- | --- | | __Return__ | void | Whether in fullscreen mode, see ToggleFullscreen(). This function is Windows-only. ### IsLoading | | | | --- | --- | | __Return__ | bool | Available only in CEF 3. Not yet implemented. Returns true if the browser is currently loading. ### IsMouseCursorChangeDisabled | | | | --- | --- | | __Return__ | bool | Available only in CEF 3. Returns true if mouse cursor change is disabled. ### IsPopup | | | | --- | --- | | __Return__ | bool | Returns true if the window is a popup window. ### IsWindowRenderingDisabled | | | | --- | --- | | __Return__ | bool | Returns true if window rendering is disabled. ### LoadUrl | Parameter | Type | | --- | --- | | url | string | | __Return__ | void | Load url in the main frame. ### Navigate | Parameter | Type | | --- | --- | | url | string | | __Return__ | void | This is an alias for the `LoadUrl` method. ### NotifyMoveOrResizeStarted | | | | --- | --- | | __Return__ | void | Notify the browser of move or resize events so that popup widgets (e.g. `` element). You can see a call to [SetUserData](../api/Browser.md#setuserdata) which is a helper method for storing custom data associated with browser. This data is stored for later use when page completes loading. During loading of a page there are many calls to OnPaint callback and it is not yet known which call is the last when loading completes and thus image buffer is stored for later use. The screenshot example also implements another handler named [LoadHanadler](../api/LoadHandler.md#loadhandler-interface) and two of its callbacks: [OnLoadingStateChange](../api/LoadHandler.md#onloadingstatechange) and [OnLoadError](../api/LoadHandler.md#onloaderror). The OnLoadingStateChange callbacks notifies when web page loading completes and OnLoadError callback notifies if loading of page failed. When loading succeeds a function save_screenshot() is called which retrieves image buffer that was earlier stored in the browser object and then uses Pillow image library to save it as a PNG image. At the end, it is worth noting that there is yet an another option for off-screen rendering named [windowless_frame_rate](../api/BrowserSettings.md#windowless_frame_rate) (can be passed to [CreateBrowserSync](../api/cefpython.md#createbrowsersync)), but is not used by this example. It sets the maximum rate in frames per second (fps) that OnPaint callback will be called Currently CEF requires a window manager on Linux even in off-screen rendering mode. On systems without screen or any input you can use something like [Xvfb](https://en.wikipedia.org/wiki/Xvfb) which performs all graphical operations in memory without showing any screen output. Pure headless mode is currently not supported in CEF, but that may change in the future. CEF currently depends on X11 window manager, but there are plans to support alternative window managers by adding Ozone support - [upstream issue #1989](https://bitbucket.org/chromiumembedded/cef/issues/1989/linux-add-ozone-support-as-an-alternative). The screenshot.py example is just a basic showcase of off-screen rendering features. That screenshot feature should also be possible to implement using windowed rendering using a normal GUI window, but a hidden one with height set to some very big value that it wouldn't fit on screen. You could then render contents of this window to an image. For example in Qt you can do this by using QImage/QPainter classes along with a call to QWidget.render(). ## Build executable There are no official examples for building executable using python packaging tools, however some resources and tips are available, see these issues in the tracker: * Pyinstaller - see [Issue #135](../../../issues/135) * py2exe - see [Issue #35](../../../issues/35) * py2app - see [Issue #337](../../../issues/337) * cx_Freeze - see [Issue #338](../../../issues/338) If you have any problems building executable ask on the [Forum](https://groups.google.com/group/cefpython). **Files in the cefpython3 package** The cefpython3 package has the following components: 1. The CEF Python modules (cefpython_pyxx.pyd on Windows, cefpython_pyxx.so on Linux/Mac) 2. The CEF dynamic library (libcef.dll on Windows, libcef.so on Linux, “Chromium Embedded Framework.framework” on OS X). 3. Other dynamic libraries CEF depends on (libEGL, libGLES, d3dcompiler, etc.) and some optional (widevinecdmadapter, etc.) 4. Support files (*.pak, *.dat, *.bin, etc). See README.txt in the cefpython3 package which provides extended details about all CEF binary files. ## Support and documentation For support and documentation see the [Support](../README.md#support) section in README. cefpython-49.0/examples/000077500000000000000000000000001334103266300152645ustar00rootroot00000000000000cefpython-49.0/examples/Examples-README.md000066400000000000000000000110451334103266300203200ustar00rootroot00000000000000# Examples README Table of contents: * [Hello World!](#hello-world) * [Supported examples](#supported-examples) * [Featured](#featured) * [Snippets](#snippets) * [GUI frameworks](#gui-frameworks) * [Unit tests](#unit-tests) * [More examples](#more-examples) ## Hello World! Instructions to install the cefpython3 package, clone the repository and run the hello_world.py example: ``` pip --no-cache-dir install cefpython3==49.0 git clone https://github.com/cztomczak/cefpython.git cd cefpython/examples/ python hello_world.py ``` Please note that if you were previously installing cefpython3 package it is required to use the `--no-cache-dir` flag, otherwise pip will end up with error message `No matching distribution found for cefpython3==49.0`. This happens because 49.0 release occured after 57.0 and 66.0 releases. ## Supported examples Examples provided in the examples/ root directory are actively maintained. If there are any issues in examples read top comments in sources to see whether this is a known issue with available workarounds. ### Featured - [hello_world.py](hello_world.py) - Basic example, doesn't require any third party GUI framework to run - [tutorial.py](tutorial.py) - Example from [Tutorial](../docs/Tutorial.md) - [screenshot.py](screenshot.py) - Example of off-screen rendering mode to create a screenshot of a web page. The code from this example is discussed in great details in Tutorial in the [Off-screen rendering](../docs/Tutorial.md#off-screen-rendering) section. ### Snippets See small code snippets that show various CEF features in the [examples/snippets/](snippets/) directory: - [javascript_bindings.py](snippets/javascript_bindings.py) - Communicate between Python and Javascript asynchronously using inter-process messaging with the use of Javascript Bindings. - [javascript_errors.py](snippets/javascript_errors.py) - Two ways for intercepting Javascript errors. - [network_cookies.py](snippets/network_cookies.py) - Implement interfaces to block or allow cookies over network requests. - [onbeforeclose.py](snippets/onbeforeclose.py) - Implement interface to execute custom code before browser window closes. - [ondomready.py](snippets/ondomready.py) - Execute custom Python code on a web page as soon as DOM is ready. - [onpagecomplete.py](snippets/onpagecomplete.py) - Execute custom Python code on a web page when page loading is complete. - [window_size.py](snippets/window_size.py) - Set initial window size without use of any third party GUI framework. ### GUI frameworks Examples of embedding using various GUI frameworks: - [gtk2.py](gtk2.py): example for [PyGTK](http://www.pygtk.org/) library (GTK 2) - [gtk3.py](gtk3.py): example for [PyGObject/PyGI](https://wiki.gnome.org/Projects/PyGObject) library (GTK 3). Currently broken on Linux/Mac, see top comments in sources. - [qt.py](qt.py): example for [PyQt4](https://wiki.python.org/moin/PyQt4), [PyQt5](https://pypi.python.org/pypi/PyQt5) and [PySide](https://wiki.qt.io/PySide) libraries - [tkinter_.py](tkinter_.py): example for [Tkinter](https://wiki.python.org/moin/TkInter). Currently broken on Mac. - [wxpython.py](wxpython.py): example for [wxPython](https://wxpython.org/) toolkit ### Unit tests There are also available unit tests and its usage of the API can be of some use. See: - [main_test.py](../unittests/main_test.py) - windowed rendering general tests - [osr_test.py](../unittests/osr_test.py) - off-screen rendering tests ## More examples There are even more examples available, some of them are externally maintained. - Kivy framework: see [Kivy](https://github.com/cztomczak/cefpython/wiki/Kivy) wiki page. - Panda3D game engine: see [Panda3D](https://github.com/cztomczak/cefpython/wiki/Panda3D) wiki page. - PyGame/PyOpenGL: see [gist by AnishN](https://gist.github.com/AnishN/aa3bb27fc9d69319955ed9a8973cd40f) - Example of implementing [ResourceHandler](../api/ResourceHandler.md) with the use of [WebRequest](../api/WebRequest.md) object and [WebRequestClient](../api/WebRequestClient.md) interface to allow for reading/modifying web requests: see the [wxpython-response.py](https://github.com/cztomczak/cefpython/blob/cefpython31/cefpython/cef3/linux/binaries_64bit/wxpython-response.py) example in the cefpython31 branch. - Old PyWin32 example: see [pywin32.py](https://github.com/cztomczak/cefpython/blob/cefpython31/cefpython/cef3/windows/binaries_32bit/pywin32.py) in the cefpython31 branch There are ongoing efforts to add these examples to the official examples/ directory, see issues in the tracker. cefpython-49.0/examples/gtk2.py000066400000000000000000000155151334103266300165140ustar00rootroot00000000000000# Example of embedding CEF browser using PyGTK library (GTK 2). # Tested configurations: # - GTK 2.24 on Windows/Linux/Mac # - CEF Python v49.0+ from cefpython3 import cefpython as cef import pygtk import gtk import gobject import os import platform import sys # Fix for PyCharm hints warnings when using static methods WindowUtils = cef.WindowUtils() # Platforms WINDOWS = (platform.system() == "Windows") LINUX = (platform.system() == "Linux") MAC = (platform.system() == "Darwin") # In CEF you can run message loop in two ways (see API ref for more details): # 1. By calling cef.MessageLoopWork() in a timer - each call performs # a single iteration of CEF message loop processing. # 2. By calling cef.MessageLoop() instead of an application-provided # message loop to get the best balance between performance and CPU # usage. This function will block until a quit message is received by # the system. This seem to work only on Linux in GTK example. # NOTE: On Mac message loop timer doesn't work, so using CEF message # loop by default. MESSAGE_LOOP_TIMER = 1 MESSAGE_LOOP_CEF = 2 # Pass --message-loop-cef flag to script on Linux g_message_loop = None def main(): check_versions() sys.excepthook = cef.ExceptHook # To shutdown all CEF processes on error configure_message_loop() cef.Initialize() gobject.threads_init() Gtk2Example() if g_message_loop == MESSAGE_LOOP_CEF: cef.MessageLoop() else: gtk.main() cef.Shutdown() def check_versions(): print("[gtk2.py] CEF Python {ver}".format(ver=cef.__version__)) print("[gtk2.py] Python {ver} {arch}".format( ver=platform.python_version(), arch=platform.architecture()[0])) print("[gtk2.py] GTK {ver}".format(ver='.'.join( map(str, list(gtk.gtk_version))))) assert cef.__version__ >= "49.0", "CEF Python v49.0+ required to run this" pygtk.require('2.0') def configure_message_loop(): global g_message_loop if MAC and "--message-loop-cef" not in sys.argv: print("[gtk2.py] Force --message-loop-cef flag on Mac") sys.argv.append("--message-loop-cef") if "--message-loop-cef" in sys.argv: print("[gtk2.py] Message loop mode: CEF (best performance)") g_message_loop = MESSAGE_LOOP_CEF sys.argv.remove("--message-loop-cef") else: print("[gtk2.py] Message loop mode: TIMER") g_message_loop = MESSAGE_LOOP_TIMER class Gtk2Example: def __init__(self): self.browser = None self.menubar_height = 0 self.exiting = False self.main_window = gtk.Window(gtk.WINDOW_TOPLEVEL) self.main_window.connect('focus-in-event', self.on_focus_in) self.main_window.connect('configure-event', self.on_configure) self.main_window.connect('destroy', self.on_exit) self.main_window.set_size_request(width=800, height=600) self.main_window.set_title('GTK 2 example (PyGTK)') icon = os.path.join(os.path.dirname(__file__), "resources", "gtk.png") if os.path.exists(icon): self.main_window.set_icon_from_file(icon) self.main_window.realize() self.vbox = gtk.VBox(False, 0) self.vbox.connect('size-allocate', self.on_vbox_size_allocate) self.menubar = self.create_menu() self.menubar.connect('size-allocate', self.on_menubar_size_allocate) self.vbox.pack_start(self.menubar, False, False, 0) self.main_window.add(self.vbox) # On Linux must show window first before embedding browser # (Issue #347). self.vbox.show() self.main_window.show() self.embed_browser() self.vbox.get_window().focus() self.main_window.get_window().focus() if g_message_loop == MESSAGE_LOOP_TIMER: gobject.timeout_add(10, self.on_timer) def embed_browser(self): windowInfo = cef.WindowInfo() size = self.main_window.get_size() rect = [0, 0, size[0], size[1]] windowInfo.SetAsChild(self.get_window_handle(), rect) self.browser = cef.CreateBrowserSync(windowInfo, settings={}, url="https://www.google.com/") self.browser.SetClientHandler(LoadHandler()) def get_window_handle(self): if WINDOWS: return self.main_window.window.handle elif LINUX: return self.main_window.window.xid elif MAC: return self.main_window.window.nsview def create_menu(self): item1 = gtk.MenuItem('MenuBar') item1.show() item1_0 = gtk.Menu() item1_1 = gtk.MenuItem('Just a menu') item1_0.append(item1_1) item1_1.show() item1.set_submenu(item1_0) menubar = gtk.MenuBar() menubar.append(item1) menubar.show() return menubar def on_timer(self): if self.exiting: return False cef.MessageLoopWork() return True def on_focus_in(self, *_): if self.browser: self.browser.SetFocus(True) return True return False def on_configure(self, *_): if self.browser: self.browser.NotifyMoveOrResizeStarted() return False def on_vbox_size_allocate(self, _, data): if self.browser: x = data.x y = data.y + self.menubar_height width = data.width height = data.height - self.menubar_height if WINDOWS: WindowUtils.UpdateBrowserSize(self.get_window_handle(), self.browser) elif LINUX: self.browser.SetBounds(x, y, width, height) def on_menubar_size_allocate(self, _, data): self.menubar_height = data.height def on_exit(self, *_): if self.exiting: print("[gtk2.py] on_exit() called, but already exiting") return self.exiting = True self.browser.CloseBrowser(True) self.clear_browser_references() if g_message_loop == MESSAGE_LOOP_CEF: cef.QuitMessageLoop() else: gtk.main_quit() def clear_browser_references(self): # Clear browser references that you keep anywhere in your # code. All references must be cleared for CEF to shutdown cleanly. self.browser = None class LoadHandler(object): def __init__(self): self.initial_app_loading = True def OnLoadStart(self, browser, **_): if self.initial_app_loading: # Temporary fix for focus issue during initial loading # on Linux (Issue #284). if LINUX: print("[gtk2.py] LoadHandler.OnLoadStart:" " keyboard focus fix (Issue #284)") browser.SetFocus(True) self.initial_app_loading = False if __name__ == '__main__': main() cefpython-49.0/examples/gtk3.py000066400000000000000000000133061334103266300165110ustar00rootroot00000000000000# Example of embedding CEF Python browser using PyGObject/PyGI (GTK 3). # # Tested configurations: # - GTK 3.18 on Windows (cefpython v53.1+) # - GTK 3.10 on Linux (works with cefpython v53.1 and v57.0+) # # Mac crash: This example crashes on Mac with error message: # > _createMenuRef called with existing principal MenuRef.. # Reported as Issue #310. from cefpython3 import cefpython as cef import ctypes import gi import os import platform import sys gi.require_version("Gtk", "3.0") # noinspection PyUnresolvedReferences from gi.repository import Gtk, GObject, Gdk, GdkPixbuf # noqa # Fix for PyCharm hints warnings when using static methods WindowUtils = cef.WindowUtils() # Platforms WINDOWS = (platform.system() == "Windows") LINUX = (platform.system() == "Linux") MAC = (platform.system() == "Darwin") # Linux imports if LINUX: # noinspection PyUnresolvedReferences from gi.repository import GdkX11 def main(): print("[gkt3.py] CEF Python {ver}".format(ver=cef.__version__)) print("[gkt3.py] Python {ver} {arch}".format( ver=platform.python_version(), arch=platform.architecture()[0])) print("[gkt3.py] GTK {major}.{minor}".format( major=Gtk.get_major_version(), minor=Gtk.get_minor_version())) assert cef.__version__ >= "49.0", "CEF Python v49.0+ required to run this" if not MAC: # On Mac exception hook doesn't work and is causing a strange error: # > Python[57738:d07] _createMenuRef called with existing principal # > MenuRef already associated with menu sys.excepthook = cef.ExceptHook # To shutdown CEF processes on error cef.Initialize() app = Gtk3Example() SystemExit(app.run(sys.argv)) class Gtk3Example(Gtk.Application): def __init__(self): super(Gtk3Example, self).__init__(application_id='cefpython.gtk3') self.browser = None self.window = None self.win32_handle = None def run(self, argv): GObject.threads_init() GObject.timeout_add(10, self.on_timer) self.connect("startup", self.on_startup) self.connect("activate", self.on_activate) self.connect("shutdown", self.on_shutdown) return super(Gtk3Example, self).run(argv) def get_handle(self): if WINDOWS: Gdk.threads_enter() ctypes.pythonapi.PyCapsule_GetPointer.restype = ctypes.c_void_p ctypes.pythonapi.PyCapsule_GetPointer.argtypes = \ [ctypes.py_object] gpointer = ctypes.pythonapi.PyCapsule_GetPointer( self.window.get_property("window").__gpointer__, None) libgdk = ctypes.CDLL("libgdk-3-0.dll") self.win32_handle = libgdk.gdk_win32_window_get_handle(gpointer) Gdk.threads_leave() return self.win32_handle elif LINUX: return self.window.get_property("window").get_xid() elif MAC: # TODO: Must call libgdk.gdk_quartz_window_get_nsview(gpointer) # similarly as on Windows. print("[gtk3.py] WARNING: get_handle not implemented on Mac") return 0 def on_timer(self): cef.MessageLoopWork() return True def on_startup(self, *_): self.window = Gtk.ApplicationWindow.new(self) self.window.set_title("GTK 3 example (PyGObject)") self.window.set_default_size(800, 600) self.window.connect("configure-event", self.on_configure) self.window.connect("size-allocate", self.on_size_allocate) self.window.connect("focus-in-event", self.on_focus_in) self.window.connect("delete-event", self.on_window_close) self.add_window(self.window) self.setup_icon() def on_activate(self, *_): self.window.realize() self.embed_browser() self.window.show_all() # Must set size of the window again after it was shown, # otherwise browser occupies only part of the window area. self.window.resize(*self.window.get_default_size()) def embed_browser(self): window_info = cef.WindowInfo() # TODO: on Mac pass rect[x, y, width, height] to SetAsChild window_info.SetAsChild(self.get_handle()) self.browser = cef.CreateBrowserSync(window_info, url="https://www.google.com/") def on_configure(self, *_): if self.browser: self.browser.NotifyMoveOrResizeStarted() return False def on_size_allocate(self, _, data): if self.browser: if WINDOWS: WindowUtils.UpdateBrowserSize(self.win32_handle, self.browser) elif LINUX: self.browser.SetBounds(data.x, data.y, data.width, data.height) def on_focus_in(self, *_): if self.browser: self.browser.SetFocus(True) return True return False def on_window_close(self, *_): if self.browser: self.browser.CloseBrowser(True) self.clear_browser_references() def clear_browser_references(self): # Clear browser references that you keep anywhere in your # code. All references must be cleared for CEF to shutdown cleanly. self.browser = None def on_shutdown(self, *_): cef.Shutdown() def setup_icon(self): icon = os.path.join(os.path.dirname(__file__), "resources", "gtk.png") if not os.path.exists(icon): return pixbuf = GdkPixbuf.Pixbuf.new_from_file(icon) transparent = pixbuf.add_alpha(True, 0xff, 0xff, 0xff) Gtk.Window.set_default_icon_list([transparent]) if __name__ == '__main__': main() cefpython-49.0/examples/hello_world.py000066400000000000000000000014511334103266300201510ustar00rootroot00000000000000# Hello world example. Doesn't depend on any third party GUI framework. # Tested with CEF Python v49.0+. from cefpython3 import cefpython as cef import platform import sys def main(): check_versions() sys.excepthook = cef.ExceptHook # To shutdown all CEF processes on error cef.Initialize() cef.CreateBrowserSync(url="https://www.google.com/", window_title="Hello World!") cef.MessageLoop() cef.Shutdown() def check_versions(): print("[hello_world.py] CEF Python {ver}".format(ver=cef.__version__)) print("[hello_world.py] Python {ver} {arch}".format( ver=platform.python_version(), arch=platform.architecture()[0])) assert cef.__version__ >= "49.0", "CEF Python v49.0 required to run this" if __name__ == '__main__': main() cefpython-49.0/examples/qt.py000066400000000000000000000324651334103266300162740ustar00rootroot00000000000000# Example of embedding CEF browser using PyQt4, PyQt5 and # PySide libraries. This example has two widgets: a navigation # bar and a browser. # # Tested configurations: # - PyQt 5.8.2 on Windows/Linux/Mac # - PyQt 4.11 (qt 4.8) on Windows/Linux # - PySide 1.2 (qt 4.8) on Windows/Linux/Mac # - CEF Python v49.0+ # # Issues with PySide 1.2 on Mac: # - Keyboard focus issues when switching between controls (Issue #284) # - Mouse cursor never changes when hovering over links (Issue #311) # - Sometimes process hangs when quitting app from cefpython3 import cefpython as cef import ctypes import os import platform import sys # GLOBALS PYQT4 = False PYQT5 = False PYSIDE = False if "pyqt4" in sys.argv: PYQT4 = True # noinspection PyUnresolvedReferences from PyQt4.QtGui import * # noinspection PyUnresolvedReferences from PyQt4.QtCore import * elif "pyqt5" in sys.argv: PYQT5 = True # noinspection PyUnresolvedReferences from PyQt5.QtGui import * # noinspection PyUnresolvedReferences from PyQt5.QtCore import * # noinspection PyUnresolvedReferences from PyQt5.QtWidgets import * elif "pyside" in sys.argv: PYSIDE = True # noinspection PyUnresolvedReferences import PySide # noinspection PyUnresolvedReferences from PySide import QtCore # noinspection PyUnresolvedReferences from PySide.QtGui import * # noinspection PyUnresolvedReferences from PySide.QtCore import * else: print("USAGE:") print(" qt.py pyqt4") print(" qt.py pyqt5") print(" qt.py pyside") sys.exit(1) # Fix for PyCharm hints warnings when using static methods WindowUtils = cef.WindowUtils() # Platforms WINDOWS = (platform.system() == "Windows") LINUX = (platform.system() == "Linux") MAC = (platform.system() == "Darwin") # Configuration WIDTH = 800 HEIGHT = 600 # OS differences CefWidgetParent = QWidget if LINUX and (PYQT4 or PYSIDE): # noinspection PyUnresolvedReferences CefWidgetParent = QX11EmbedContainer def main(): check_versions() sys.excepthook = cef.ExceptHook # To shutdown all CEF processes on error cef.Initialize() app = CefApplication(sys.argv) main_window = MainWindow() main_window.show() main_window.activateWindow() main_window.raise_() app.exec_() app.stopTimer() del main_window # Just to be safe, similarly to "del app" del app # Must destroy app object before calling Shutdown cef.Shutdown() def check_versions(): print("[qt.py] CEF Python {ver}".format(ver=cef.__version__)) print("[qt.py] Python {ver} {arch}".format( ver=platform.python_version(), arch=platform.architecture()[0])) if PYQT4 or PYQT5: print("[qt.py] PyQt {v1} (qt {v2})".format( v1=PYQT_VERSION_STR, v2=qVersion())) elif PYSIDE: print("[qt.py] PySide {v1} (qt {v2})".format( v1=PySide.__version__, v2=QtCore.__version__)) # CEF Python version requirement assert cef.__version__ >= "49.0", "CEF Python v49.0+ required to run this" class MainWindow(QMainWindow): def __init__(self): # noinspection PyArgumentList super(MainWindow, self).__init__(None) self.cef_widget = None self.navigation_bar = None if PYQT4: self.setWindowTitle("PyQt4 example") elif PYQT5: self.setWindowTitle("PyQt5 example") elif PYSIDE: self.setWindowTitle("PySide example") self.setFocusPolicy(Qt.StrongFocus) self.setupLayout() def setupLayout(self): self.resize(WIDTH, HEIGHT) self.cef_widget = CefWidget(self) self.navigation_bar = NavigationBar(self.cef_widget) layout = QGridLayout() # noinspection PyArgumentList layout.addWidget(self.navigation_bar, 0, 0) # noinspection PyArgumentList layout.addWidget(self.cef_widget, 1, 0) layout.setContentsMargins(0, 0, 0, 0) layout.setSpacing(0) layout.setRowStretch(0, 0) layout.setRowStretch(1, 1) # noinspection PyArgumentList frame = QFrame() frame.setLayout(layout) self.setCentralWidget(frame) if PYQT5 and WINDOWS: # On Windows with PyQt5 main window must be shown first # before CEF browser is embedded, otherwise window is # not resized and application hangs during resize. self.show() # Browser can be embedded only after layout was set up self.cef_widget.embedBrowser() if PYQT5 and LINUX: # On Linux with PyQt5 the QX11EmbedContainer widget is # no more available. An equivalent in Qt5 is to create # a hidden window, embed CEF browser in it and then # create a container for that hidden window and replace # cef widget in the layout with the container. # noinspection PyUnresolvedReferences, PyArgumentList self.container = QWidget.createWindowContainer( self.cef_widget.hidden_window, parent=self) # noinspection PyArgumentList layout.addWidget(self.container, 1, 0) def closeEvent(self, event): # Close browser (force=True) and free CEF reference if self.cef_widget.browser: self.cef_widget.browser.CloseBrowser(True) self.clear_browser_references() def clear_browser_references(self): # Clear browser references that you keep anywhere in your # code. All references must be cleared for CEF to shutdown cleanly. self.cef_widget.browser = None class CefWidget(CefWidgetParent): def __init__(self, parent=None): # noinspection PyArgumentList super(CefWidget, self).__init__(parent) self.parent = parent self.browser = None self.hidden_window = None # Required for PyQt5 on Linux self.show() def focusInEvent(self, event): # This event seems to never get called on Linux, as CEF is # stealing all focus due to Issue #284. if self.browser: if WINDOWS: WindowUtils.OnSetFocus(self.getHandle(), 0, 0, 0) self.browser.SetFocus(True) def focusOutEvent(self, event): # This event seems to never get called on Linux, as CEF is # stealing all focus due to Issue #284. if self.browser: self.browser.SetFocus(False) def embedBrowser(self): if PYQT5 and LINUX: # noinspection PyUnresolvedReferences self.hidden_window = QWindow() window_info = cef.WindowInfo() rect = [0, 0, self.width(), self.height()] window_info.SetAsChild(self.getHandle(), rect) self.browser = cef.CreateBrowserSync(window_info, url="https://www.google.com/") self.browser.SetClientHandler(LoadHandler(self.parent.navigation_bar)) self.browser.SetClientHandler(FocusHandler(self)) def getHandle(self): if self.hidden_window: # PyQt5 on Linux return int(self.hidden_window.winId()) try: # PyQt4 and PyQt5 return int(self.winId()) except: # PySide: # | QWidget.winId() returns # | Converting it to int using ctypes. if sys.version_info[0] == 2: # Python 2 ctypes.pythonapi.PyCObject_AsVoidPtr.restype = ( ctypes.c_void_p) ctypes.pythonapi.PyCObject_AsVoidPtr.argtypes = ( [ctypes.py_object]) return ctypes.pythonapi.PyCObject_AsVoidPtr(self.winId()) else: # Python 3 ctypes.pythonapi.PyCapsule_GetPointer.restype = ( ctypes.c_void_p) ctypes.pythonapi.PyCapsule_GetPointer.argtypes = ( [ctypes.py_object]) return ctypes.pythonapi.PyCapsule_GetPointer( self.winId(), None) def moveEvent(self, _): self.x = 0 self.y = 0 if self.browser: if WINDOWS: WindowUtils.UpdateBrowserSize(self.getHandle(), self.browser) elif LINUX: self.browser.SetBounds(self.x, self.y, self.width(), self.height()) self.browser.NotifyMoveOrResizeStarted() def resizeEvent(self, event): size = event.size() if self.browser: if WINDOWS: WindowUtils.UpdateBrowserSize(self.getHandle(), self.browser) elif LINUX: self.browser.SetBounds(self.x, self.y, size.width(), size.height()) self.browser.NotifyMoveOrResizeStarted() class CefApplication(QApplication): def __init__(self, args): super(CefApplication, self).__init__(args) self.timer = self.createTimer() self.setupIcon() def createTimer(self): timer = QTimer() # noinspection PyUnresolvedReferences timer.timeout.connect(self.onTimer) timer.start(10) return timer def onTimer(self): cef.MessageLoopWork() def stopTimer(self): # Stop the timer after Qt's message loop has ended self.timer.stop() def setupIcon(self): icon_file = os.path.join(os.path.abspath(os.path.dirname(__file__)), "resources", "{0}.png".format(sys.argv[1])) if os.path.exists(icon_file): self.setWindowIcon(QIcon(icon_file)) class LoadHandler(object): def __init__(self, navigation_bar): self.initial_app_loading = True self.navigation_bar = navigation_bar def OnLoadingStateChange(self, **_): self.navigation_bar.updateState() def OnLoadStart(self, browser, **_): self.navigation_bar.url.setText(browser.GetUrl()) if self.initial_app_loading: self.navigation_bar.cef_widget.setFocus() # Temporary fix no. 2 for focus issue on Linux (Issue #284) if LINUX: print("[qt.py] LoadHandler.OnLoadStart:" " keyboard focus fix no. 2 (Issue #284)") browser.SetFocus(True) self.initial_app_loading = False class FocusHandler(object): def __init__(self, cef_widget): self.cef_widget = cef_widget def OnSetFocus(self, **_): pass def OnGotFocus(self, browser, **_): # Temporary fix no. 1 for focus issues on Linux (Issue #284) if LINUX: print("[qt.py] FocusHandler.OnGotFocus:" " keyboard focus fix no. 1 (Issue #284)") browser.SetFocus(True) class NavigationBar(QFrame): def __init__(self, cef_widget): # noinspection PyArgumentList super(NavigationBar, self).__init__() self.cef_widget = cef_widget # Init layout layout = QGridLayout() layout.setContentsMargins(0, 0, 0, 0) layout.setSpacing(0) # Back button self.back = self.createButton("back") # noinspection PyUnresolvedReferences self.back.clicked.connect(self.onBack) # noinspection PyArgumentList layout.addWidget(self.back, 0, 0) # Forward button self.forward = self.createButton("forward") # noinspection PyUnresolvedReferences self.forward.clicked.connect(self.onForward) # noinspection PyArgumentList layout.addWidget(self.forward, 0, 1) # Reload button self.reload = self.createButton("reload") # noinspection PyUnresolvedReferences self.reload.clicked.connect(self.onReload) # noinspection PyArgumentList layout.addWidget(self.reload, 0, 2) # Url input self.url = QLineEdit("") # noinspection PyUnresolvedReferences self.url.returnPressed.connect(self.onGoUrl) # noinspection PyArgumentList layout.addWidget(self.url, 0, 3) # Layout self.setLayout(layout) self.updateState() def onBack(self): if self.cef_widget.browser: self.cef_widget.browser.GoBack() def onForward(self): if self.cef_widget.browser: self.cef_widget.browser.GoForward() def onReload(self): if self.cef_widget.browser: self.cef_widget.browser.Reload() def onGoUrl(self): if self.cef_widget.browser: self.cef_widget.browser.LoadUrl(self.url.text()) def updateState(self): browser = self.cef_widget.browser if not browser: self.back.setEnabled(False) self.forward.setEnabled(False) self.reload.setEnabled(False) self.url.setEnabled(False) return self.back.setEnabled(browser.CanGoBack()) self.forward.setEnabled(browser.CanGoForward()) self.reload.setEnabled(True) self.url.setEnabled(True) self.url.setText(browser.GetUrl()) def createButton(self, name): resources = os.path.join(os.path.abspath(os.path.dirname(__file__)), "resources") pixmap = QPixmap(os.path.join(resources, "{0}.png".format(name))) icon = QIcon(pixmap) button = QPushButton() button.setIcon(icon) button.setIconSize(pixmap.rect().size()) return button if __name__ == '__main__': main() cefpython-49.0/examples/resources/000077500000000000000000000000001334103266300172765ustar00rootroot00000000000000cefpython-49.0/examples/resources/back.gif000066400000000000000000000021711334103266300206660ustar00rootroot00000000000000GIF89a3e6f2f4g4g4g2f2g2g2g2h2h3h4h4i2h2i=p2i2i2j2i2j5k4k5l4l2k3l2l2o8qw>w6y7z9z9~:;<Ar@uJzN~FzFzH{;<=WzMMV]FAC@BFEHIHRZP^_]^^ambaksssttum`ef|vz}p~悦抪勬玭匬烩葯蛶嚵睷甲꒱퓳홵꛷죻駾꠻!,] H$(`Aƒ ZPb8p @D "ԉQeࠄkaLLĀHP5 5z7 }@OBRS!JD(KB#VÖϛ>aGϛDVڣ3Mp@JBgS\\<9L1'WIy,AU a*c %8鳞8&|Ǐ.bwo!>|p`"D|J >!bdDr,fy+SW/uP+YCq!^)~^0A @EiƂR€  8$F8 4 B\;cefpython-49.0/examples/resources/back.png000066400000000000000000000025041334103266300207050ustar00rootroot00000000000000PNG  IHDRĴl;bKGD pHYs ,tIME 4ٸIDATxڍۋ\U{Oթ[Wv3t0J 3 C-,B<"/ DP$q=L NtWwUr.{IO4`}ǷYk)~JG $")@]6]wa'A(L;#M`^Ò{R? .y9NMx|szͲjFSFoT*;A:OdٷCx$opTN吓!__'M{ÓwΏ|z>sqt}JhDeNõLVj*˾o깲3 >6yw[1榓|tζ-Q$[ ٔQa fsp{rەK* |O=R$i݈\DU8{KԈ9=H!-=mU,@Y =WuA9)t"2!͞el?hvő= K}(@'|eɺwa%*~ieԝ 5;|rv_~1x_\+PI4r ll|.!lo8p}X\ 1 $i[ƶk<59R]xΆs߃7#cmQd6FILҍԭr^nvnUߏK 򗱴g,2\Zxl[XeK2`,B^Hڄծ8Yw-?$*']r!i?I&i/$mh&U!7o?٧>~9jU~Uz(;;*P$0 bk#v|MF' #$\Arym֙‰\BϔL.3ݏf)֬]PoGxsƁV-Wg&sNj`Rěj*ʩF]fεNjtt#]\ Db=Nl2_8qZT*/ȑ#G4>_GkUCۚr2^t44zA+3*qj%Hr^ns@T*{/{hRhIENDB`cefpython-49.0/examples/resources/forward.gif000066400000000000000000000021651334103266300214350ustar00rootroot00000000000000GIF89a3e6f2f4g4g4g2f2g2g2g2h2h3h4h4i2h2i=p2i2i2j2i2j5k4k5l4l2k3l2l2o8qw>w6y7z9z9~:;<Ar@uJzN~FzFzH{;<=>WzMMV]F@C@BBBFHIKRRZP]^_]^ambaksssttu`md|z悦惦抪剫玭匬烩葯蛶嚵睷甲ꓳ홵꛷솮頻렻쥾!,e H$(`Aƒ ZP8o,@D "04O|hPB 5@5՟P3r!F ph\ 9hCE$8B $;cefpython-49.0/examples/resources/forward.png000066400000000000000000000024371334103266300214560ustar00rootroot00000000000000PNG  IHDRĴl;bKGD pHYs ,tIME 'VnIDATxڍk\E?4IhMZ[FRPQUA "*U" W b5X4mif{􇶶/3g>s93l^MlkSvnVt<~E<0"Ltd?GO/j$[CW_|fGxw*"A+A&wݞ;ٶa]Dv|\H](2^PA<=:Vd ¶6$Rpo1?-ӡr\_un@ў!Tw擃%)hJ:ܻ1ɑ5rkFKsn&웉7̄*6rψ,DZHgV:woH%%CZOGG55$Z˲s"$]ޝ|vloRkŭ5Q,j!9AeH'$J),RagAMA a cHRMz&u0`:pQ<bKGDIDATxyx[?9%[Nl'N8YlJBuZ@hNo[yxӰ n -Ci)ô;P Y YH8;lkǫ#Kɛdo$IGo=G06Xwo1!DOwH06\p (fˁɿgŀzi?SsDr@jVDu<$D2.S5s@r-ŝZU~|Hih q|";KLLK";Ů?+NF,3(^,C-r`E}@PĠ#B]sږBtc˹nT~Q6\:SZRox8 DKO`H3`ʬL(E9v)Db |(g.kRBgPX"m$$4Y8˚rNp"f礔>0* fKy(m%2멫7$pƶu-A4Č:P-P`VN6Y5eLiՀ(9$]J-t uPZhsApԠ#J]K B $j @$h;Mu5,V͢9QX <lRe f2._|$3{kԶ(!c$̺$PD;䧡5e3.r !%(𬔲UP0H.͗i+Q?u$ +o's&IY[<| xx]J)$ifLeݒ~|8_ gZ1B1)n SZ;^#G;X[SNbl\B~<&RemM9N4!J><\JB}X jbpӬ/CEt39_.oh "iM"N9?+斲rDJ6,,>* CJ]Beӵ磲qif164)$h S1IYtU,RYQ)a &@rѭŭ+ow' 9YsaiGۢSN7hpe;kkʩ*sibcVgRu#s&@/ɿg&ޕjMHQ[mr5DG(F$6z`a»|:`%Y9@9D24$*hQEӬWR]4 3c9 :FY,LYb8z5e\6Ëêۀ_?RI ѕj]*hqC0Z4Rֱe Ե[a`]M3l~<-lTkwҺb{Tn=1"t/iƈj0Ai,dRZdQ5&AoP ܖ< @h-*h-=TІ*a)YX8M~ |0@ E8ffh%K˸Y" OB9&5Q | XjGz஽ TK nOa]M9n= ɡZ?i~授3p9B_NGB"apJ&y t~Oߨ8ߞ=(YɅ}YuӉ?0mDw)$\^1. #M8ovG[D6I`5`Ɇ:‘?/~O+Iл$qIv7j9zÔ7Y(gqf֠ д.$?qGIqI1G;xZ^{s: jpK@qoDAvt. WKHA@`~)s3pJ?F8ں(@`R0%ᦛ2%a$$D ޳<o4 4*Z_f?~\I–-00´NNt&-㚗Le?"C[¶|yJNp{Mo05<D" fO0CEutw* 4,(Ix>{yXNϞ$m Ɖ#T;j8,T5͜ eE6 q#ȅIl+ @M?"!LӑmD<7O7h h :y 2Dbx]VfOV>k5}@ fq&6]]xğ'M$WKB0Mv E6L0{e.{Hǩ6!DIu)zWÖ `a#@o\E{ 4q:n %H` 4t85/HTw\2aŢQPUb$E6=yggc*KQKDvĢkѻ!h 00/!bA}{l]:De0qOvh} C. ,#% /1" FwSEc䯞vy_P@W,@FTIIJ**R, yIRϧ燩=(67FZ#ToZIY̩(YϕܢCÊCK %Zz3_Q# InfRχ+Jtašy a4H46b&*sQu\y<4,ps2$[¶lY^%AYު27N)bBz;\-p.zw( "@0 tIزE%FP2Ӌkk̑.=w V"%$;p:GIďկ;p͛цIzs5CK-,SDߦ6;#va3kC'j ۇ ?t!ܖ+<̞N$G9y5/z>PEH#NZ302Z${|^/pS1ۮgXScхe lг]#C2ot#*?v,gIIgMvsI"{yD I=8b稴.!&CHhsg>!(F1P + e! QzNs7%n[yPyLwH4@J@4_sK[ò3!=K _z%`Bt = GwHtػ, bŔR8a.l"5ᣇ, dgdv͛1@dH$vp$@Fkӧ3b" qz="dcT!BڡfMF/pho؜$ /]A t78`!2A]UFK $I1ndr%pROc> =UZНF;!}OȆC Q鶥TVRi]G.l$/$K̅k 12CƄ/ 6\D&Y`m-5؄1v}џ!noSi]ʎ\0>H1G(ӮlC>i˩ʶ}:A?PC}ڍz"ync3L^9 f 1zFx 6R}6UTYW0պ6 =?RCS08TGm;}+{bo)v3qH@-tL>)˨dmeXH\>uj&hAT_bX﹋[f]Sݓ%- vQ8 !L[{S- )֧-^ˁEw{92+]u=}]_fP9aٞWk g!&%!gnA8kM oļae.nař^'h 6$| 7r6.uX]*KxV􈇋 ^nm$a[ڵX.thi!Do'ccHbiS3&Ј0Cq.gyngsL.uZ-Lۍ Uʴ_q %SD|=g"#Pkصծ[{?fO燝 igMWb[h%%H؁}hi{7Thgg3k<_Һ?LtoCBL& p8ЦLt2k`;VFJdvoEY3Fw﫬p]_FVvгeǐ[\BLdsIhs`[5XWD<b;F'G d9俟wX﹋Ҷ7s.~dlBLdCHG …֬f .C$ڈGpVeڏ%adq fx4 Ǹ}+ r)oHC.8'2"nJl+Wb[WϜ Q[K{7ƙ3@Pbq;7}u'Gu);[uCBpau|@4hXW5X.E8 ;xP-hnX,PbwC;:,u~iE'#odn ]r!hի~{6l2>f#q<ەs'Ɖ$::F7P?ȋYoЀ }eG![m4sܷSi]3pQ=Ɖ}7ѝ;?pC HNEw;*,s 7lc{Q#";s3|"w>m^U}Z?dPbv;/tA0'dNȆpq~;݇V^6G¿9W8zjǵX8 ]ؓD=1'̉ h6oS1B$/un᥎{Wy^' rzMHf942ȾyNEv%n>Z5 ʻH <lScX,5s0;b;yL3GYلKa r1u$A)pP8[^~y٘@##JK8wq!Y`@gJ@GS!I+)ٶ ۪U^cfAM~~+Im%7leo 7 +. Ё9$l+VP?|_1 FDO+2\taŖ@%׀X/[qlX ]:c CF9o})nnc"չc$؅XͣGqp%,Dp%~u /wދ]s}'Nmy~*0@ Ce@3f}\7ъs4 G/%aSKzѣ{ W'o}TzBxv|1/3Y0~ W3ɲ AOF&Tieezwxw#k1Cx-ƾ9 S^3G }6?HJ܅EڊlAs~9,aN8[(ѫc@}#l J~ hl87?pxvhFimMko8%y`/O.-IM%K8Mj|k e+qldm5n [$STEOe Yl%oFt}7FCÈ]BESWj|U,p\dKuzs@ aђ$*zG\oތq^B%TږPmK(֧vwx8DrXw ob؃$ JbMp^"w>yG2 *SmHmI_Nd$I`V1qՈmhvbĩNdK5ՎkgLPɴQ\1bi$ (Vy)y o]#u:#.+v\Ǭ *ʩ#M@Gie+(ٶ; k#yJCN<ǩv\dKMONk9ubiYC0ºp!%[~睄_zi d:uoͩ;09u"/4좋-Qck.D]KmioNLݰ9u"o4GUgGQEg)Ctw8f*J9ywrE^k**OyrJb߲ ݩhets3u'A.WXC%1|Jb(rlZ2q8riA:u"*QZI{U%JbS7z95өVN](赒OxP갡Sg[Oc#%84o>k_ ƩE6*n7;.Υ:wtrE2*CW9Sʘi[tĭ*.W$JK _PE}m@tnٯoרQ劂%dTDW%qӟV$NbYV:/Ӭv\%٩3˯eN](h@F%g(s*\p:iߴInՎL.N](x@ (ٶoAI6fRʩ2}NTL%;j5 @ć+`ǜSN\ǨI_?4NݘJJKvCkVGߑD )eRRJ!GYqI`5;"RʃRJ)WH)k1ʑFR%w[R,R>FyRW!)oR'D7%tEXtdate:create2014-01-24T10:17:03+08:006j%tEXtdate:modify2014-01-24T10:17:03+08:00k?IENDB`cefpython-49.0/examples/resources/pyqt4.png000066400000000000000000000504551334103266300210760ustar00rootroot00000000000000PNG  IHDRxsBIT|d pHYsW3tEXtSoftwarewww.inkscape.org< IDATxw|>g[ElK6 A`cq P8%@R.%B.$_ ! %$4M1ƽWYھ?lcd[hygv}1c4ywޢe2T """9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9Gu~K~b~^=-wM\ihtƕJgt׭ |E>qPun"le2Z(EV2?~\o\E0 [Kt$< 6jk4OFDL,q؛|_ p## 2?T1̇%>xݢoBA7'",YJ`_G+}QŒ!Gԍ>, _`!>x k=^ b^m.m7uF|nk_"r$k'5d#wiy8iZ.[4GF;S*`3Z}m,ŁG qʌ<, הV1PטT(,6Ł7p`bh)X6?R [b12(kg%:,a")ɾUI؎Mπo2$ohX6 ~v 6PVsqS{ypŲ`g/^أ49 hnp8Κ1t1P h>Bp|,S=zI~HDbPL(efҰb(L2v$ߡ?AC]^XkG'ۥ31*hH0pw?$"@0Ìy._Z3nG -aX8&q?[g`hQlGƄ`D$ ɴک8?֔iJP;K6|lD`> Ԭ{u3ͺ9G  aDe0"hp`_Y91Ku;"ûsD~Hd-,&kPa=GpeП,c765v+MEP,Iuϐ߅]TY$ QTDY@2~b=W^Y^.JSe N{i֌ g6ǐH ] !I5~/Də?jkL FdE,hw{^'N5Dv0w?X$kp[Crp?ѰlGV~HN`0vuL}sJ/1Rc0V_ 7yϪr?23oID~@Z}m9fGk+Ä $dЛ Ft,,kf޳ҏϜODC/Y A|{`^pyeODvI9Y_R?=UZzo|x~b8`6ͼY q<3oIDj`b`oC]#_I_eC~Hk8D3[;.,1Dd`+<`}/_Z;-[C~: oh]H_Kmzè,VNg_".v?oKD4\c~uoV ] LOH@7STq2.#щw?#`l)?QV)pe8b~=,> ph'w? %OFD ` zästk p๕4 K3DDvv65USͥ:M7(͟H̡/m.\ʱS|ODd3p,}<>'"2d#DDr* >JF|^"""cE%utY%""裦w}y8@DD`Ї#DDdk|GG7"""kT "" q9 9 9 9 9 9 9 9 9 9 9 9 9Gulٗ`,X"xÿi$d2\1cʐA^0<QGaEBx]nDS%>k,5?G8 sԜDL,D#ӟD{O t$ޛDGOX<.-.JLcg`AՉ>xLcF[d#~h X HP4Ǝ1lkĶ}QERún\iLK]skx]~T֢2CA{dǶm1%@4 ͝qlkb۾(ǐ> ܘ?i".WxFTbP*; 5؄m=oa{ջԠD$ Q>UޓuEKq˒%&4ި, ʏ#IbOzl~ [D@,DGK⭍Xm0>5,6q-8s2 !v$D@He;?q-yn[}Ih$<\=1`(y%$!:>^:&sq Aqp(D @INXȖ^[kr^<%"phA`"苈vikÝ] GD 'Og/,Geo߿?o^35aDd,u+=:ΪH YN:ԱYQS]Nܻ54kBn\{~jljz3j1qi>Sgf$DXrҀDj $zGϣe%8q،Z 9&qﺯm`!y8mv5.vjC26lJB>['6Ru˜J45',EϧkpS%Q!7~ - K`l'@Oq-1̦AÒϘzOh, Ia CS귖AB5ֶ?ݽk .bq1^@S>yv1d1rML;SB"}X2Vo( dSD*gwZ'ت5뿑hΨƴKYSY:X 6_wl^qgO5_o@SO5e_x2.ѪQ\Ht Y݃'v7 dh ^k)Z~J r[!Hx,5hW.ݦbTĉ' C YšmSǖiҘ]w!ǡEݿ%tG:%$2ssg಩KHB )9*|'+!vƎM眚F) '7 SOz]̎*=XHG&{3vP9*ey%@ʭ.>RM5s3*)^'? P]8rn W7a,D#@J5wƅwkOTB{N&vVgm9r /]$! ȰRk/ zpI&C2Ǻf8iZ|́" |HJd9e}L\>S"Q,L:!^Κ9 ^Yf*~~}3S[O3|ZQkxb e?JHc5mϪQ= ci%. 'fgoh"2;ėy=.q i̕$Kžzz/1<9 i5Dx\b Mo@l/bzrb[ZѾHL#EԬ^u0и7`=ٱ_e?H%[%h1zjv|2yLn[Û_In3RSOŖI 7'TVc0هHo@Áu㔉' g&2 )Y|/ud`gﻪ#|~\o[YL4Ŷ24o.?t ]=߻ۂ;ߍt;81pر_nЃ&?x*&1>$sal_rㆷ$%2N[q3 ~ny(+l6{9vOM[nE"_ y/'!gϱDFw ξugO3~M ;TGRWld*?;峒R@J;&0 c0w_{*#wL?\6?;QaH>N"VctEc&4lvy-TL֝@$*iK@8މXʺ{O-^/=bp}y?(,d`3 NFGdǔp!' QU:e<-ˎ:p\GjoxW@d,dN%n(Kl*,T2X4]`f#=qm!3S2X4]}I=F'VϑF  wm|M)|&32MX2yIԈ"QDG5DicG@d ,d=^挝+!pEyt[l N8Ku"K` PVHnwcJrT RLwi NNGKѳ Ma> iW]Z:r,dN ^EէHHFKuaV@02{ ҋL'^J CL&hR]<M N"1TG RLN _SQX !>.Bn/6lx'MD,d5cJ%$Q#6G* IB=> .ʠ?">0d4j &Ws״P AeQHu "XHgQe0i%r _c1+XH:=0bIԉp@OOTe Wñta}`FL3h9z `,LF|'f9Au"XH:=#~ ҨLh HHc竎@Tv,&Kѱ$?&h9e.1oD;ёXH*=ҐȕF ;>?D<Ȁ$rk j0.^B욚bM378(!|@N@R $$Qi6:0ɃL,$Ȯh_utׄ<CTQ ?]uD*=#)@RPʑDT^oS %#ɞ D"XH*=By :wlɁ@d b i c`TNvq>_>|HŹEgQ#.ѤV9 I?DTھs.}#q[34z.ˮY8Qr*Fo(ˮY<Hg#GȩXHGŹٵ1K]z$39T,$MZC #z(ɮ}'I@46bvֹ ^s8@@Ҥx'Q+oF8_ms/QF@P,$MJ^e#6~wVh ƗBrԓ4錾gpl=@@FܚGu"ӱ4ug׋OԽ F@@Y4|8I{z4Dc iL`GNp4Ft;2;?нP^ 'b ik;$@ 'b i<iav^ARx^f 'ʾW[ }G2#@߉v[GDjKg GGcۭpd߫-YG8`%m#DjKd1v^H@N@yHet!la콲A@#D@YAgչ]Nti@N@Yӟҳt?m?sf,@ϗyS=6Hu1XHzVXwKDGr"F@VySvs2@@ZfG5`u8@N@pcc?3 9 Ik@;5zx^ó@N@<wDkɴ/"2 Ig@&dyg N@84z6٧ݗN8ON@w8rNKɡXH=@456b.F|nI9 I28Zv> @ ;@N@ttD-;]"c i:G:; N'`U,T,$ߧo+]l&C4zG#='Q~#"c iȶ3~$#> S4~>xӻ5Hfk b i lp@uHd},$x=%Q1@@RE$$QsTz&G]4|$X3D;:nWp'@"c l4IHNГ:nzw#D:".J@$ @ (gΓD@R' dYڷDWDXDJTyA0M"ʞv~.[苳3Ty:F2`WN ixrYxA_,&.JO N Og`2d:9  I#sIԲD@=#$r;{IԲ<=#$r?9 IpåV(}6> r2JӀ\+Zz;%QǮKg9 Ig/p$F@9r9 Ig/pXBu : (T !}qr.ND:Ȏ ?D 'c <GCoEA}Թ pInIr2._GH2ӽ[B5h/zGJJ N"G<5Xr@u "eXHQ}w;'QǎD~'c uM NTUDHN@ywԲMB5XT68\@N@'> m$jqM A= r:2Eq q{;g7@m7C(`r:2ym=3og; '!HN@г `SkL:=T8LQ/I)Y菤)γdG> c S] nFS:pR %XI UH)2E(B'㶹e4j g MP[^-!Zv@ @|`W{$jǪ0lz>ʩ'Sg)`G$jF1,]} 1 N"Gvc ӌ./zJH]&v%z4L)@k#D,d%=YcyziIIgRhdIDzYo+eb\:~Vn_e|ES#1ţ$$1^^#DنLuk(1`-ҨaG`|=v: XTcJl*!v p0u@Mx i@t jtxH`ggvڶ#+UN18-\@L6Z<);&=yz]nv/̠)=K [oKHG[ 3$1V[da1,Lvi(/3p4jX}%x\|2Ӟ޵#Y N~Z6o g`tQ$ӷNu"` Y ?ĺKHcqyTG8l^/;~@ ՏDq3q )[,@4%|Z˞$qso( rܺznkҘ*ߚwu]WW$~DEa %& _z>d2X# iOx55\ i W,8F1@46?#!&SaH{bTW!KOd1,Ą]aȝZ2`0oB4 ;٣:RVy#XH WR/o~OBiP]8WuiN _t@ϖM#2F?ԁp,;vrc=c3?fpmz]u嬾5$Sp kb eGH-o&: )ҀJymɞܬ2 )xRy)X#t읓XsGH,Դ ǚ:jwv<ӵ<)+ gHHc tjG%r0}?XH,Ԫ |Yw[ iwݢ5`^p֌9) n׻4+Yq@Pu R0u|P~KB=\t ;/aGSYs f@@͜#|M[OOm|RB22_Q|YqXZ{4F`m#.~`\0%LgrFQ+IHc¹U^KW[uo ig5z-#>~d*xҚ ؆QWjcuϭ[T: ?Ƌ\G6\'|͔1ŸlkuS|WF(eTS¹#f[OBH LC$K^drRV9Q$󯖔d)cK}W&,'!gN^)[lzƣ7FJ=~Ϣ|J-͆f ,⇖тv$!| >^UHcgsT|zLahҙVJ?(h/*l,d9S't*;OXN I/6 x.Tl|yٗ !Ӻ-;3^f>DhptQnqքń#>t܅=WH0F{@w,r{vYMً,iNM˯ DsFyD#t`q* W@}o3m| Ҿg$Da Ky44M|7_G{>4y ;_W 9; KlNƦ$!2 Y)3r ]3M?pQ?aLa_ӟl:ΜuETY Ö7(nqebuo@hX:@|?|%v[~qMQ6t 3![÷V\go$R$KS5FlT:6!) ȱ͙#5*):n;.! ކiG_dx4 8cF-Vn'+dʽM HJC4r,diPYkwokHKI7#7 {bvm: N _  L)9LףaDI:h()ȰUWP;.(tMtmܚ +?/.xK}s?r4TPwDq[x+Ocq&6ֳ;DJlH>;KBYd gXmMH^e!/b.:j|ī vޞh bJLKlB[[CYm=NٵkEcI%9GJ 8q<njB OřSU >K^Ycfg՛&?\֊D)ʯ$!ҏlcB n)v4|#Z) G"-g"=X6|^ 6 9zʞl_x^s A O)fw[>-@RUǩ3?AK؜b$G,ÛtFLV1{أ߽Ј )83 ӟ忾VR"2ÓnGO:;wR!s( S2 sW. َۥaŞankT$m), :J蚦~ a [*+&{mD$Kwn-u' `Wk:bֵ󑇕m-cBDb):Db_"'at_ş}Pb*u7o[ <71mi.=Eb6~ Kw tl/ T\.SG H SJLfh2Uŝ^߭[B"=mI5WUg ܚF* }]:ʰ>;+N/5)t_w7JN&G:Ξǫ.?vmk50nLWƕgoC<9Ok| KMHv:^RCجI!.t 8 ֶ3?GUG"k%vdXu$ }dq1|av ˽T:s|4|+=UUC ~|Jm/E-x~~\\hn(-7!;ul| ;zE*=sX(kL ✅xLepoq_IOܮߪ1b.06'~~cX"^^\O?(=RVۀ} ӷ[2ى0K}þf O鷘?dX^s^s5<=b{S;dMZfk+4u1ԧֶ0^#%/_o ֞+-}T&Ɠ;-Obށ?@w8H,H4X<}ԟيQA8i2N]S8c ǡ4nVd@OfDmFOX2tkC]UP#N߅^BzoHoo9W Hd:6;Wb7`n͇HDbi CgiŚbMqk(P[`.(((X(k͙υ^D25XWـ_|ן-[e&øbo:Q,rnㆁ$bvEڥ}(M gd7};~HLl77kn?B,+2W*7t/Z$q%I߭]wa pϋ+1ۧa}}vh ^En3_ODrc.>m.Y\ w?[;Wg/Db춦'rCEbK*#nWXˏ#FCNم?:凈[D?"'b G*_/ǒ?Aw6ZGtwⱭǶUXȱ\.`ɜ||I%fOpk@Sg_8G7fx*vߍ}5k2HDt/?ǍO♷zgi/NOgg߆*a-*֧0#>IDAT";` :؇Ϝ[{[=gTO>/=߻{z7'E$/NDd,DG2.Al;7c[SG DS/=+gf^`N`Rm{o<ցN,DCpiRDOl{[?xI7+WaVu9_ \s&%+ ۟B$ѫ: 'GaU%Ř4&qV3_Kp}m` JCU "ph. ӫC^B"7E)OWW(׋&a\Dƨʟݽ龜AD#@׭a& ‘-zp :kF 3JAD#@d0KCyon(!<ʖ@4RqTb 2 |ͮ^t tHH#Gihs&A4@$y 5HH#I/Vh$:UPHb>^O{ABy攝PDzgM" 4 _!> j i4Dzq10{$gJ?Cu "=8@D30^4r7|cȋ_׿,!\5櫪cmkL $!^ڸ'(=Vh` j^m5H}ȷ38i 1"*Fy1X^yHB3h8wMԌ"_: ѱW@5"_z~l,!9&.~&~ejqI6sb^@4p۳wHJd;/ ~?SFT"Ru<eυi!6 tݣo_]A6͛ywt`>[nG@7y(-FYnQW{~)K%:j,D&W#\z{ҹWJJNqN sJ0SurUPL0|}IHCx`,D&3pho` 2͜9p '3 D\ irnԎ _JHCX@dSwڇ6>.! #q "M@U1JHCH;nS"-_ |͚{KHC(m8v W1yL@o>ɀD#t_C]cBu` R`5WBJ"V@@e3'o`<"!Q{qV@ȹ'!';FI?H߅ _Ѹi V??a5,D M 6J3#IJEuPc%@ eߨ`E,Dݸ|Y .u*~Re55:Y@UZ$tM&|w-HJEd{q_VªX,b&Hvvnhkܮ:UYȲS#tMw83nzvKJEdKGu+c M. ]-߽ZIJFd;lkSX,FpB1WРA+֞#ܭ:ձY9Q״+Dz]{ߺKb2"BC]cZuc ٓrpӊ ͂‘$q/F`tD@C]˪C ݸ|i .;N^3}{2rCYFU.Xlbڄ nZQ59Іg8'˰z*ư v@d#A Ս.s:@:~NXr2<=H&%2Mb'H\Ag-9زwlǶ(2O2xi^W\_\T֘\@ CCC]C؍9+}V_[YŽ[^>&ObAk=qy5L*G],; , !z &mFw=іsO xofX]Ǿ_m SHcqTnЍI*@uq5j˦`bDL(jF4ՏLKIf_?"y4PW$[pYY :HY*u|f?8 aUDUv,DDdJC].ATY 165ViX,q/ u{q4"" _+ރֻ-iJCC`!ڏ/$%{`nC\ċIJZ|c)鴪,@p(8mk~ ̖iUl=a! 髒~˶$ꡟ)rrЀI"餤'bGU"+- {{"Փ4EVnY O'yzL{+iVC?]d0h a;'%=ov%ͩzOYa9 ڎ0_NO^A9ۆ#Q{Z"Hꡟ*05FoJJ{6ꡟ,*`,8;{v{`A*}~{*@-EE?>SC[?\*-!'iύiSц,zOYh7^Cw?~d<F,/u-BTpDI:!QIK6$=~/CusCXp$O'_p?k?5@#ɽv]~`&cO%yzlN#Gww+ !Xo G!D B"@"D!D B"@"D!D B"@"DIENDB`cefpython-49.0/examples/resources/pyqt5.png000066400000000000000000000504551334103266300210770ustar00rootroot00000000000000PNG  IHDRxsBIT|d pHYsW3tEXtSoftwarewww.inkscape.org< IDATxw|>g[ElK6 A`cq P8%@R.%B.$_ ! %$4M1ƽWYھ?lcd[hygv}1c4ywޢe2T """9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9Gu~K~b~^=-wM\ihtƕJgt׭ |E>qPun"le2Z(EV2?~\o\E0 [Kt$< 6jk4OFDL,q؛|_ p## 2?T1̇%>xݢoBA7'",YJ`_G+}QŒ!Gԍ>, _`!>x k=^ b^m.m7uF|nk_"r$k'5d#wiy8iZ.[4GF;S*`3Z}m,ŁG qʌ<, הV1PטT(,6Ł7p`bh)X6?R [b12(kg%:,a")ɾUI؎Mπo2$ohX6 ~v 6PVsqS{ypŲ`g/^أ49 hnp8Κ1t1P h>Bp|,S=zI~HDbPL(efҰb(L2v$ߡ?AC]^XkG'ۥ31*hH0pw?$"@0Ìy._Z3nG -aX8&q?[g`hQlGƄ`D$ ɴک8?֔iJP;K6|lD`> Ԭ{u3ͺ9G  aDe0"hp`_Y91Ku;"ûsD~Hd-,&kPa=GpeП,c765v+MEP,Iuϐ߅]TY$ QTDY@2~b=W^Y^.JSe N{i֌ g6ǐH ] !I5~/Də?jkL FdE,hw{^'N5Dv0w?X$kp[Crp?ѰlGV~HN`0vuL}sJ/1Rc0V_ 7yϪr?23oID~@Z}m9fGk+Ä $dЛ Ft,,kf޳ҏϜODC/Y A|{`^pyeODvI9Y_R?=UZzo|x~b8`6ͼY q<3oIDj`b`oC]#_I_eC~Hk8D3[;.,1Dd`+<`}/_Z;-[C~: oh]H_Kmzè,VNg_".v?oKD4\c~uoV ] LOH@7STq2.#щw?#`l)?QV)pe8b~=,> ph'w? %OFD ` zästk p๕4 K3DDvv65USͥ:M7(͟H̡/m.\ʱS|ODd3p,}<>'"2d#DDr* >JF|^"""cE%utY%""裦w}y8@DD`Ї#DDdk|GG7"""kT "" q9 9 9 9 9 9 9 9 9 9 9 9 9Gulٗ`,X"xÿi$d2\1cʐA^0<QGaEBx]nDS%>k,5?G8 sԜDL,D#ӟD{O t$ޛDGOX<.-.JLcg`AՉ>xLcF[d#~h X HP4Ǝ1lkĶ}QERún\iLK]skx]~T֢2CA{dǶm1%@4 ͝qlkb۾(ǐ> ܘ?i".WxFTbP*; 5؄m=oa{ջԠD$ Q>UޓuEKq˒%&4ި, ʏ#IbOzl~ [D@,DGK⭍Xm0>5,6q-8s2 !v$D@He;?q-yn[}Ih$<\=1`(y%$!:>^:&sq Aqp(D @INXȖ^[kr^<%"phA`"苈vikÝ] GD 'Og/,Geo߿?o^35aDd,u+=:ΪH YN:ԱYQS]Nܻ54kBn\{~jljz3j1qi>Sgf$DXrҀDj $zGϣe%8q،Z 9&qﺯm`!y8mv5.vjC26lJB>['6Ru˜J45',EϧkpS%Q!7~ - K`l'@Oq-1̦AÒϘzOh, Ia CS귖AB5ֶ?ݽk .bq1^@S>yv1d1rML;SB"}X2Vo( dSD*gwZ'ت5뿑hΨƴKYSY:X 6_wl^qgO5_o@SO5e_x2.ѪQ\Ht Y݃'v7 dh ^k)Z~J r[!Hx,5hW.ݦbTĉ' C YšmSǖiҘ]w!ǡEݿ%tG:%$2ssg಩KHB )9*|'+!vƎM眚F) '7 SOz]̎*=XHG&{3vP9*ey%@ʭ.>RM5s3*)^'? P]8rn W7a,D#@J5wƅwkOTB{N&vVgm9r /]$! ȰRk/ zpI&C2Ǻf8iZ|́" |HJd9e}L\>S"Q,L:!^Κ9 ^Yf*~~}3S[O3|ZQkxb e?JHc5mϪQ= ci%. 'fgoh"2;ėy=.q i̕$Kžzz/1<9 i5Dx\b Mo@l/bzrb[ZѾHL#EԬ^u0и7`=ٱ_e?H%[%h1zjv|2yLn[Û_In3RSOŖI 7'TVc0هHo@Áu㔉' g&2 )Y|/ud`gﻪ#|~\o[YL4Ŷ24o.?t ]=߻ۂ;ߍt;81pر_nЃ&?x*&1>$sal_rㆷ$%2N[q3 ~ny(+l6{9vOM[nE"_ y/'!gϱDFw ξugO3~M ;TGRWld*?;峒R@J;&0 c0w_{*#wL?\6?;QaH>N"VctEc&4lvy-TL֝@$*iK@8މXʺ{O-^/=bp}y?(,d`3 NFGdǔp!' QU:e<-ˎ:p\GjoxW@d,dN%n(Kl*,T2X4]`f#=qm!3S2X4]}I=F'VϑF  wm|M)|&32MX2yIԈ"QDG5DicG@d ,d=^挝+!pEyt[l N8Ku"K` PVHnwcJrT RLwi NNGKѳ Ma> iW]Z:r,dN ^EէHHFKuaV@02{ ҋL'^J CL&hR]<M N"1TG RLN _SQX !>.Bn/6lx'MD,d5cJ%$Q#6G* IB=> .ʠ?">0d4j &Ws״P AeQHu "XHgQe0i%r _c1+XH:=0bIԉp@OOTe Wñta}`FL3h9z `,LF|'f9Au"XH:=#~ ҨLh HHc竎@Tv,&Kѱ$?&h9e.1oD;ёXH*=ҐȕF ;>?D<Ȁ$rk j0.^B욚bM378(!|@N@R $$Qi6:0ɃL,$Ȯh_utׄ<CTQ ?]uD*=#)@RPʑDT^oS %#ɞ D"XH*=By :wlɁ@d b i c`TNvq>_>|HŹEgQ#.ѤV9 I?DTھs.}#q[34z.ˮY8Qr*Fo(ˮY<Hg#GȩXHGŹٵ1K]z$39T,$MZC #z(ɮ}'I@46bvֹ ^s8@@Ҥx'Q+oF8_ms/QF@P,$MJ^e#6~wVh ƗBrԓ4錾gpl=@@FܚGu"ӱ4ug׋OԽ F@@Y4|8I{z4Dc iL`GNp4Ft;2;?нP^ 'b ik;$@ 'b i<iav^ARx^f 'ʾW[ }G2#@߉v[GDjKg GGcۭpd߫-YG8`%m#DjKd1v^H@N@yHet!la콲A@#D@YAgչ]Nti@N@Yӟҳt?m?sf,@ϗyS=6Hu1XHzVXwKDGr"F@VySvs2@@ZfG5`u8@N@pcc?3 9 Ik@;5zx^ó@N@<wDkɴ/"2 Ig@&dyg N@84z6٧ݗN8ON@w8rNKɡXH=@456b.F|nI9 I28Zv> @ ;@N@ttD-;]"c i:G:; N'`U,T,$ߧo+]l&C4zG#='Q~#"c iȶ3~$#> S4~>xӻ5Hfk b i lp@uHd},$x=%Q1@@RE$$QsTz&G]4|$X3D;:nWp'@"c l4IHNГ:nzw#D:".J@$ @ (gΓD@R' dYڷDWDXDJTyA0M"ʞv~.[苳3Ty:F2`WN ixrYxA_,&.JO N Og`2d:9  I#sIԲD@=#$r;{IԲ<=#$r?9 IpåV(}6> r2JӀ\+Zz;%QǮKg9 Ig/p$F@9r9 Ig/pXBu : (T !}qr.ND:Ȏ ?D 'c <GCoEA}Թ pInIr2._GH2ӽ[B5h/zGJJ N"G<5Xr@u "eXHQ}w;'QǎD~'c uM NTUDHN@ywԲMB5XT68\@N@'> m$jqM A= r:2Eq q{;g7@m7C(`r:2ym=3og; '!HN@г `SkL:=T8LQ/I)Y菤)γdG> c S] nFS:pR %XI UH)2E(B'㶹e4j g MP[^-!Zv@ @|`W{$jǪ0lz>ʩ'Sg)`G$jF1,]} 1 N"Gvc ӌ./zJH]&v%z4L)@k#D,d%=YcyziIIgRhdIDzYo+eb\:~Vn_e|ES#1ţ$$1^^#DنLuk(1`-ҨaG`|=v: XTcJl*!v p0u@Mx i@t jtxH`ggvڶ#+UN18-\@L6Z<);&=yz]nv/̠)=K [oKHG[ 3$1V[da1,Lvi(/3p4jX}%x\|2Ӟ޵#Y N~Z6o g`tQ$ӷNu"` Y ?ĺKHcqyTG8l^/;~@ ՏDq3q )[,@4%|Z˞$qso( rܺznkҘ*ߚwu]WW$~DEa %& _z>d2X# iOx55\ i W,8F1@46?#!&SaH{bTW!KOd1,Ą]aȝZ2`0oB4 ;٣:RVy#XH WR/o~OBiP]8WuiN _t@ϖM#2F?ԁp,;vrc=c3?fpmz]u嬾5$Sp kb eGH-o&: )ҀJymɞܬ2 )xRy)X#t읓XsGH,Դ ǚ:jwv<ӵ<)+ gHHc tjG%r0}?XH,Ԫ |Yw[ iwݢ5`^p֌9) n׻4+Yq@Pu R0u|P~KB=\t ;/aGSYs f@@͜#|M[OOm|RB22_Q|YqXZ{4F`m#.~`\0%LgrFQ+IHc¹U^KW[uo ig5z-#>~d*xҚ ؆QWjcuϭ[T: ?Ƌ\G6\'|͔1ŸlkuS|WF(eTS¹#f[OBH LC$K^drRV9Q$󯖔d)cK}W&,'!gN^)[lzƣ7FJ=~Ϣ|J-͆f ,⇖тv$!| >^UHcgsT|zLahҙVJ?(h/*l,d9S't*;OXN I/6 x.Tl|yٗ !Ӻ-;3^f>DhptQnqքń#>t܅=WH0F{@w,r{vYMً,iNM˯ DsFyD#t`q* W@}o3m| Ҿg$Da Ky44M|7_G{>4y ;_W 9; KlNƦ$!2 Y)3r ]3M?pQ?aLa_ӟl:ΜuETY Ö7(nqebuo@hX:@|?|%v[~qMQ6t 3![÷V\go$R$KS5FlT:6!) ȱ͙#5*):n;.! ކiG_dx4 8cF-Vn'+dʽM HJC4r,diPYkwokHKI7#7 {bvm: N _  L)9LףaDI:h()ȰUWP;.(tMtmܚ +?/.xK}s?r4TPwDq[x+Ocq&6ֳ;DJlH>;KBYd gXmMH^e!/b.:j|ī vޞh bJLKlB[[CYm=NٵkEcI%9GJ 8q<njB OřSU >K^Ycfg՛&?\֊D)ʯ$!ҏlcB n)v4|#Z) G"-g"=X6|^ 6 9zʞl_x^s A O)fw[>-@RUǩ3?AK؜b$G,ÛtFLV1{أ߽Ј )83 ӟ忾VR"2ÓnGO:;wR!s( S2 sW. َۥaŞankT$m), :J蚦~ a [*+&{mD$Kwn-u' `Wk:bֵ󑇕m-cBDb):Db_"'at_ş}Pb*u7o[ <71mi.=Eb6~ Kw tl/ T\.SG H SJLfh2Uŝ^߭[B"=mI5WUg ܚF* }]:ʰ>;+N/5)t_w7JN&G:Ξǫ.?vmk50nLWƕgoC<9Ok| KMHv:^RCجI!.t 8 ֶ3?GUG"k%vdXu$ }dq1|av ˽T:s|4|+=UUC ~|Jm/E-x~~\\hn(-7!;ul| ;zE*=sX(kL ✅xLepoq_IOܮߪ1b.06'~~cX"^^\O?(=RVۀ} ӷ[2ى0K}þf O鷘?dX^s^s5<=b{S;dMZfk+4u1ԧֶ0^#%/_o ֞+-}T&Ɠ;-Obށ?@w8H,H4X<}ԟيQA8i2N]S8c ǡ4nVd@OfDmFOX2tkC]UP#N߅^BzoHoo9W Hd:6;Wb7`n͇HDbi CgiŚbMqk(P[`.(((X(k͙υ^D25XWـ_|ן-[e&øbo:Q,rnㆁ$bvEڥ}(M gd7};~HLl77kn?B,+2W*7t/Z$q%I߭]wa pϋ+1ۧa}}vh ^En3_ODrc.>m.Y\ w?[;Wg/Db춦'rCEbK*#nWXˏ#FCNم?:凈[D?"'b G*_/ǒ?Aw6ZGtwⱭǶUXȱ\.`ɜ||I%fOpk@Sg_8G7fx*vߍ}5k2HDt/?ǍO♷zgi/NOgg߆*a-*֧0#>IDAT";` :؇Ϝ[{[=gTO>/=߻{z7'E$/NDd,DG2.Al;7c[SG DS/=+gf^`N`Rm{o<ցN,DCpiRDOl{[?xI7+WaVu9_ \s&%+ ۟B$ѫ: 'GaU%Ř4&qV3_Kp}m` JCU "ph. ӫC^B"7E)OWW(׋&a\Dƨʟݽ龜AD#@׭a& ‘-zp :kF 3JAD#@d0KCyon(!<ʖ@4RqTb 2 |ͮ^t tHH#Gihs&A4@$y 5HH#I/Vh$:UPHb>^O{ABy攝PDzgM" 4 _!> j i4Dzq10{$gJ?Cu "=8@D30^4r7|cȋ_׿,!\5櫪cmkL $!^ڸ'(=Vh` j^m5H}ȷ38i 1"*Fy1X^yHB3h8wMԌ"_: ѱW@5"_z~l,!9&.~&~ejqI6sb^@4p۳wHJd;/ ~?SFT"Ru<eυi!6 tݣo_]A6͛ywt`>[nG@7y(-FYnQW{~)K%:j,D&W#\z{ҹWJJNqN sJ0SurUPL0|}IHCx`,D&3pho` 2͜9p '3 D\ irnԎ _JHCX@dSwڇ6>.! #q "M@U1JHCH;nS"-_ |͚{KHC(m8v W1yL@o>ɀD#t_C]cBu` R`5WBJ"V@@e3'o`<"!Q{qV@ȹ'!';FI?H߅ _Ѹi V??a5,D M 6J3#IJEuPc%@ eߨ`E,Dݸ|Y .u*~Re55:Y@UZ$tM&|w-HJEd{q_VªX,b&Hvvnhkܮ:UYȲS#tMw83nzvKJEdKGu+c M. ]-߽ZIJFd;lkSX,FpB1WРA+֞#ܭ:ձY9Q״+Dz]{ߺKb2"BC]cZuc ٓrpӊ ͂‘$q/F`tD@C]˪C ݸ|i .;N^3}{2rCYFU.Xlbڄ nZQ59Іg8'˰z*ư v@d#A Ս.s:@:~NXr2<=H&%2Mb'H\Ag-9زwlǶ(2O2xi^W\_\T֘\@ CCC]C؍9+}V_[YŽ[^>&ObAk=qy5L*G],; , !z &mFw=іsO xofX]Ǿ_m SHcqTnЍI*@uq5j˦`bDL(jF4ՏLKIf_?"y4PW$[pYY :HY*u|f?8 aUDUv,DDdJC].ATY 165ViX,q/ u{q4"" _+ރֻ-iJCC`!ڏ/$%{`nC\ċIJZ|c)鴪,@p(8mk~ ̖iUl=a! 髒~˶$ꡟ)rrЀI"餤'bGU"+- {{"Փ4EVnY O'yzL{+iVC?]d0h a;'%=ov%ͩzOYa9 ڎ0_NO^A9ۆ#Q{Z"Hꡟ*05FoJJ{6ꡟ,*`,8;{v{`A*}~{*@-EE?>SC[?\*-!'iύiSц,zOYh7^Cw?~d<F,/u-BTpDI:!QIK6$=~/CusCXp$O'_p?k?5@#ɽv]~`&cO%yzlN#Gww+ !Xo G!D B"@"D!D B"@"D!D B"@"DIENDB`cefpython-49.0/examples/resources/pyside.png000066400000000000000000000654621334103266300213160ustar00rootroot00000000000000PNG  IHDRbKGDC pHYs B(xtIME &:A IDATxy\]ϹWŲvv;^ԲNBv8C6 `a q"CI C^0<ɐgX$vV{-/M}Q%YdTU]Ϋ#J9_ݺ{s Gqf|ڎwl6% D-tb4m.z80aˀ Զel/j0Ay_V+E eN10p8jж_t;ضA""P#=n{-v/ms `b}c}nRHQp{#ܠhL t>rO&;} p_]@DD.j"ur;| AgǗnsmz"" ep Br?3 LHxS ?`< v{xHQ(=/e00 ^%7`?rowߑK; i DD.?r'6={}K4o6;qcceg?4Hw{>|IPS8CɄpzۦK^>7$"0w=vfUGnr.^PDDf i\K UtG;݃,/btzm/WBsJ|sQԀCA~\#&" {{ܟ>rY*'" /۵/Km4NnaY)Hy wUV~nޏ[WDD^[=5l2!70ؗ-& dL'/yl U=׽=_~S%9r`8Z|ohEUn s;+N[hS ;Q>/uIw;4p+Uj'T#ĚI ZL.'"_˩4s|Y(#arC? vM^d[8 _q;sú@:5 < <}$"3z7]ߢGDeܣ{\|PHSaSvo|gˢ_wSw(Ю̨qx(a`wGMm(P?ѻe@J+Rs,e[?uh_M*(Qv":$mYm " 'DnÎ;nz/}]#UNdzrsP9E/< G ȶy@̒@>5pJ)"o!Cnl`>$^;x+,~{[UO@oGHifɭvxcۺ.ZG=WDzm/HXSZQD*%r_& `0J$RPщ."R?d!CpoIr+!>w١w*ԨWǀvd ָnɆ_~[7?%=XF~[YXS^ MFzwu(|"2e=8Fn߄36oM%/ҪA8 < < p,/ 0pnȬq*`?GSN`97y a[2K;;{BL34l""Yr%4iܣ;<9F~nn\j 緀UDD6Rs]`ʇ;G0Nz%Px-s+6XDDj%7N9@C_2Ͽ?+ ""s4E{ G}'/{x\ =u;T&@v W %0'u?xLe`mnTDD FO[*ytp&vߟ_|ܦk7Ujv}nWU؟8W{}b*2GmtnH(0 ݗ_dWl z 895m|/t^wً_Gn77= 7ẗH@(yjF=?4v[hgp5~""`󝂗 7qȁ}s lV9FxijX/JЬ+iG"""9 << pwfq&'% fj=3)SV>~_s-Wr$|W34r @֩EDDd .@DDDz06H%H&2/""`H((((((((((((((((((\R $,k?w/̅sEDDj"o܅kmRo-.L] 1\'kBkeųYR$$lש`@ADD*}o%]#nxbZ i/)ICH[ 2^!FSg>424Y?Mƛ&OR8[g36K]̫[rhi.|.nw>-,nXɟ$Q&Ld>&sf$ 8!\B(|+#uucS})"n):¾E~h g904F.d}0 " ˽G,TOcֶmbuB Ƹ VU[~ ) =g:xz0c\ -Y?MOZֵofI5t-'j T]8.nc Lȳ~ӓ9BNDa@DdVcş56sNtկd} 'OSg*3V" rDC̫[ڶܸCDJ&r粟e?]>_f8yRg@Dx~ ~潇κ儝 SMױ:c %wq:}Ou} ]=W QWw5hXǢu,Y  V9Q*iXv uI\r3Wp3Gg>1CDbwo[8C(3`iӵ,mi =#e$uJ." 1*>f+%*F hƮx_g4< r2~ܶ\?=*H 2aӢs˂{x߰89Փ" "űXܪq7'mEd"2J oΒS|lM/;ߥrwyøNXEQ@puGZغ}WGBNDC" 2y~>XҸAn^x7?}3j Ԩ"%)~fWa4 ^muD} ku:ODcۗ %3>iGMY NNc0qHŲz>kD "|x[CGAv/)oO2:}בd$Y! Yd|T0">s3^mȚ//oiӢ#ۤI(3y2w"t&Get&]6OgIf'He'HfǙ:a<=dz0!&2CL'M0htY@f pMG[eRխ7|?ˌN!̫[QMCwuQ8>mƳ |?խ7 gm/-*kB|tVnYQ TAeE@攬g6 WRqy_]T1*0KQ!D@U0*]9Vܨ+=P!D@ޘo}ֶws󂏨Rӏu[),RQ79QXX'ճRU!'ʇWN`0t&r"*(&~v2#bz^}/|=V6 URy{*̘">}7 ;,V)w 1~ ! rUpMǝ*Doh2 qTQGKl>wWŐZ,4T+~gYt ! rׄ!9݋?Ɇ;xl5(HMlY7ܩKd}t6Wj;>(Rn^m"l.ܬB >+qC5)/ɇW^HL,cҟVH*(k~%?=$čbM&k0NaaBZ yGT df'rtENLe(yp~P`CstmE'a א7Si:ou<eɧ?]m]}ರa ! Ag0$B*Femg`Nd y1c̛Neǘ{cϳpKkl,ik:{hW fMQ1^/-v-$ PܭBg\6^g3*u6uͷWqT+I~t[؋cBXuҷq v}WbUͼ{/RiՇw{ OCKՁ!=_R!п|g83yׄgd$ׄIyS>xg8<>h'. 7!uIFtKaq:D3|gq:Jfֳ$Ms2~ c6vKKAȫ#O/&xwSc]}4ò&uD "Ktrr??0:S+9 Ms} bAC:!Xi/ɖ%?Rvz/gGk gL U E ,hX*F~ԙWz'a,=_[$c W4U7vh6 |rV]jtv?{̌ T 1zm?Ps6u,hX/(USխEX6뗔u I{~6 ʆܓ?" i#ͱ.;O_;95qMcБo y{D4nZ`*DL{9v3> ?uc睴Ǘfq z,_VB֧%6ZP$&F{ 1/10u$VJ`lmR@iz}F(<2ԉԡ99a`l ~:,nXu~ K9:wO_醩pt%v@~Q[1KSB}E hpϙ tqs;XeMK- A7quM*D^|}Or"s ~ncmۭszmz,kV@H,=D(gx_~J{c@~=KfD_Z_nQ-7q*D =@2x3]'GC:7F;X׾e>i!Ҫ/(o==_p|:}Ai}{wv 痜xӤ$o"</ĺp3MNRN6h~[`7)FOsjUg1 喅?Pܵ?xz(S'LeZq0c U$'U^ cc O \W3l44c2=Df㩳̌0f23ht~PHL,U! *DA /ngY7Y߱ǎ SwP#P#{.A}Qi96_(diqye@UhC-[PG ֿӓ (T DȲ6@GvkT1_r' g nv[XJE3#[CON&IyS$)/tv>''@M 9~Z  _&%IiNLo}9WCE(ۢnҾA9BNMzݟ5[y 3BdAM*X'oO+ 3{VfA*A-_2`8)o*p|U;5Q@WJ& tf0XRN eI@(Ԙ=eA *zg5y@v5_EEjDM_Bhhp2~S7+@" R5H(@ʛ rec/7G QyKsmESLGT4F۩ QyXt Q?E2;B\c5mA P4{H2U!$`HyL5$RVY-Z/ˉWޗ6mc" 3˷>eڱg^{7bje`@9x0;8t/ׂ@" 37nP! ɣ,oǷY" 3Z%U" OPL2~dv"DfJCxI(uķYgޗ5nD;J(?\'b|mY1 f9:K8h5 H1 QVihXZb i5d0_ Ksl,pGj2(0Ļ`Cg|' 9a]*DPf>]+U"Lj]fHϫ[D@%b]uWEvtV~wVzH,W!̌D]`FS+Yκe*Dch`e:Ӂ}7F<ܠp) R!Үي$]@`~b%z:D@*OGb QioBEP"D@Q[T!*x__Q_i-R! R L]uD@h+óYޔ QcVZ \-j)}NX ~7BT 0$ 8qhv0+brۻ&&qnXh[ܯP=Q7Aȉ uDIQ|*xz0sS yLfƊzݡ]E ^'e؉_Df>Ց72[Eul:LdW΄ys1q&gLf $p# EwR*Dxj01ځVmu\L}״7Dz(?R9 Acq@oOiqPa=w_a&ͦ_s3+l~_v8Q7N؉vcD8'z'N؍v L *:VI<ԨP&g[N̓/CNfu@D5ů"o=R$$㯥xq |nN/3kN4ќb$-Ş~a*3eȉy 6D>%T> 8DFg+yd}XAD@*XdcHT"VS$?P=sD@*(:xSW:XLP!(H@)RT a'(Hl %t*I| R Bs+Dh{s)w01^(!ӁAc# ˆT`1Mj BCS@2xirK vh_ᎀ" rOCM(AOPL#TkX!H(H@E()$c٠i@'XK"ԬB MkUpQb"?|@ caQ ai$A߫:'x~&u `E(H(VO *0P(Hﰬ(AnyZjt/~M) p)@TgK)ZbػR?@j@}Y@bpQPhD@\`RZ <C  թ%hfzugD@+&Tujg@n(HZSJ P- " R?q*D 2~JU | zRG (Hh\r":D@(55Pp(H.(zh`j!!D@QQ[ԻR]Yw1Qr,aJ}ZC(H W@U_" RXE useWv3h@t_OЇ ר RF!TJIU *Q@IĻҬVkP@̧V+51j@Qr^Q(-PK@ِ e;*BiAJe0 xYR $7 06F:Q2W@[t( RxQ@Jo)2Vb多NP'EYPkoD@|^Q(d}–ºN*$TA\VwUDtW*:舗+VJ+U TlGE@hK'RNu ӱT,*! R+ŎM=UN|f+EIԭ)iE[|_TR+l(N*(/jP.HՎ!Q2VP`V* =:UNWjUU[C ei UKD@|N(: RSkFěRWZ + R?x W4 ٬Qӄ҅O`4 9U;LBфHQ2v<qUT : v`j@kӀ R;+:%_q@ s0P@(Hyeia'5{}=( R>C*;B Dq R3!)tܢKnX,Y?A|JW$KOaHQ250*DI Zo6)/M,*M؉:  ] $@gZi\){07BLTEPz)`B(Nx( 7 RB` QLh2Q#-dfDsT08Ph^ERng,5Aw-j*mGZr@Ǘ(HQHp#h֊]g<}VQ  c3*DBMT.kK(`T yEp@/@Y_ Ub@;]< %ʌ@Ba yD(Ќ&iUx$K-$/ RbӓEբE|AZ Q p-Xhg~S(HUcX|ͱyVHG;q: UY>Vw,M<(H0>B-k˧1wH{I4T )@l@;8;uXJP@QX\/Ƣiwa=]" *A|Rg^bu9(HUH4Q- vbDCuQ]MSx6B5:G&j5@w0A *AOPB %n h N0)zH 3)(PEQ<@Z*q96 QL 'ʩ.܄3NQpxl QHg@>gM" 3NU!qc$*Dƥ!7o-g''oL1d'T@xH<ԥ!},S  FrT uHUP`;SQFR L=B 7e44~&O?(IK*Dv}C*(̼S1@j^!>`Y\@QYiZЖX uez̯_ ' @ /PR\ ̯[~|e?" !:-LCU!(x,_~xt:H" `8=uz*F5W,4sKC"P+ pzU- :ܪBO4;샸ND̝0ZI@ RޔQHzCҎ1@pQhnp zrG@D23` QxX Qݸtpc) &c LQ! aP]KW}g_/MXsle=^ecRGP= Wy;4C|{AԯָnhZ((țs0NP(ڶMZ-cE=? WPJ''2S1 L+ߦe߄gm-~]xj@ȉj5% w`BgYu{ɣ %at8!B@2WU! a-npSRӧIC5Ďh(y QbT7ЙXF]9p{k6m DeTBrV>Bgb q7}dvfW-u0i/ɡ]*D|\v\ִm 7WԴa7/ZӶ ][m75}giPm >S@ añ*f~jQ .i6/Txj5o[aW*UPk@-gU,jX~leFS=6w1߰Rw)H sg*`X|-S IDATvS$Ϧ.}K,YnՒƍ 3d jMd㰾c2ȍ.m&p{*3j~?c g ((H>@˛>:,jXGk|Q#7!h>~΢Pq'&2:B#k?[XquᦚZ&Yz a7P㆒83uP(ЦlѷbyS7TvrV0 ^1n ~ M 9Q5oX5 &Xk4Q'u|?+[nR1 q Wsrbov)>[,{ϷpgAroM >}LeFf($gi:KYӶumYڴ1KujkB:odmZ(]Wk-,jX{*3gfυ8 t>KdU=%Xt ~o!Ytrߨ[ΚMz$0D‰񽜙=ddpXt{8ƭ|Zc QX-w|g6kۺkv7t''N=R(kB\?}.07gq@~ۏRг8 &皶ϯ&vc%_g8&ļ,%װa-IQ`21^8 :PA } ɣsz~;, A>K؉Ͳ,tvXjЊ N~9$ aw?:V A`Xv[Ժ*$4[K|gjv_rinyo:,o.Ӱ喅喅~^zSZǸ8N!F[let-c~YQ{铴Xrk7@aɉZ|$CƟƳYBNP*DUc,=˃E_#n]w-l`Of>}A߀넉 +vn[46ƱX7_5=\/l>pƷ-:o*Fn^p7ͱ9Dr"տŎ99#c/0$!}AE@ uПEq>kdgk ю~vq>}d`)N PbZgrovҟeQ~FwqxYH{I) RE>W[k֢潟u[fPgh~<П~óYNOԊ eS LV!9؍ˇWMNfۖ/?٩Csb- cO5!˃GB)? n5[,u#Ǽsg~HT,`81G}~߅cݥ/(HqBN Qgm/!'Zw֧5_|۟ g/)Du_)0<žGU,kOml[ons}=͹ ^\╡k(H6S8b4^Om/,jX['a%~orW0g?3/:}E@|SZVdVL ş.gy{9\ |{{OB_UZSU[/ 막iKo36mԇ[G5s0yQ}RUxSօ Wcu<{_зzi\2{6gܼnn]Q\S݄kxf9Ld94Kǀ %$9'Bѿd<=b\x[owquǿoU$Kޱ8CH@&$$8vٸ3@.0} lsfaa’3@Bd@l[U"[Vkߥ޻նeIU-9bUSoWpwS`cxxx&@Q`&]G<|K5Ӊ Lku7KWt3h@L<aK˯3M{rCu:th=L X,1d!\ef/fkr\;fx?灙ec,n#%%W/ r;م Ts887_Nn$2C$Q:c Vk?I4O:$`0#0-bab.< %*4PfɟAJx|o r=u>t&:'hfn%\;K>C]/<_]+̡zQ}WTݼPM"+hHd*(3A~U!T=U~ @W܄?iXTwo䠖 k2:t\]Q3R<_/ܸ!9Մ?#y1! r<}CrP_WV1y&31~Ӥ܄ r* N*`w9W1dҥ?"n]$ml#7Xytϫmw;W͹UIba&t]j,*;KY0 /K\=Gf_K f^ȟw_ G>v˿1` "B^N{Vx?艉3=Fi԰k=Z~M* ` y2=fkCխ.e+ra.oj fT/oUoe[4=rd&mEy[|Ejyy֕\-Cy1<:W|)ר p };(֡':V0Ǫ\r=w^CΫD;TT?!,/ZAELvmo_;vH9)H?]Jy C΋T&ODWA's(h:TÏ~{ w]`^cz:Ki?NM`@^, 2ұ+gcvy"TMMWI|E"G˞y 0hѴeq=K=2>y_O(Ă3ՏEůWAHf<}p wYƦ-Rw*>ĝ[.z\=Lh#pVVD'?2) UA|ۡ Ϳ`w\9&],dꞗ]tX^@zX $Ł9*4p@&@,=zKWųo&hbиxin*uqg T? `uc - #`I_cvENK<=ȯ>m:QO9`m{>…,'W~f^ÂWR4 W)7@D'vbMtDhk#`XVU\ȓFP OV~{*LH,5?:j9Ŀ~&LʎR:( Ph3"u#W̾fY;W.ݱĎ#ZGghj If^ƿ7odO&C[…*;ē_` ٩>;g"!П蠱/\,cx1.c^%,O=@ AU"%I R8`]OOG0`C֘ }L v0.~R~ _Șj{l?ӟh|EOuǎk8_P>o5|]+Ȕ]&~MnTQ$+OtE>* V TWL'~=[T7#}Edx~y`5Ks=:SȔd#/M4 ?!3{X'e0x'Ti 7 To^פ.aѬ%x(Md7t$q7 " ']цUsnճ" 66Gw}̸| DD@16} .evB DD@l,ZqL^סz@D$8Գ%pz@D$_VWϽ@1FDD@"*EFM" !k:yc-."'3 2me4G}v@DN:E*ȴz:X▋2HDK(4%}%^?.H/ 9v~L*4fO}%f,`;8;?j@Dn̺`[41 2Y&WU`.ˮLLw 2Vΰ ue51H_ѣ Ӛ0eZV\A FRQDO3> _2 1uaSH~ <:("SX3q 6 P_Go1KgE3+?L[m/pk=12g !2y' y3 PݽBdCas9oBg :TC<=HKx7laelXm!"4 y)o'KM8M baU'^"%"&q4/xXVU@]D]eSww~hFD.N(R9Գk*Y*)Okͅ" TM= yÁ$2QCD-U|%8URH>I8p䵠UDi*cHt{!"7 "@݉H^\X "uFߣBto>xz]j<y y2;^$T1Dd:I LS)DdDFXT>GO!"^E@d dmFDdqR'vD`0y!"I "~Zdsw)K@&qT"2MX9 " O|Tgu(\f ;_R7-x e O"2y+Px? r`l*ڞ+֨bT5 T+]lhoBDAd ;]/"2 "g hbhQ1Dd*rBO+!x[܄!"SyWP9 {3BDekD*K'!",H 2W=RbHj_>V- +K<0T!D$ VJOk' 5ϫ"k2v 2XtFOtc*Oombͫ)/__EZۅe`Y@4Gjz󣽟V1Dd2ǹ{m) roc<m*L u "mtxrhاȅq'8VDΐ/?O "r>qBjgrP rVw~][T9>PYH@\`wyh{^!|y3g}0s]FIp#" x)_4|N rcIE.c-ŁXFo?9$y'nYWPA -b[\`)Ksocn%y^ ";N(8A]LI<^7rri}Xƞ6xzX#F:c tǚ鍷aP; +H^Uo uӸdb zX2f`[A&1qep4x`X:Z'֌yX`0&LV`=׍_#"93.` 6AZ4͸ŋy]ѥ,(yE0"f^Č=%2">~">R= $:Ht2"g `d&m𖱱dG:D4(X1`dG XlĶ0Rf,`NE,O]Œ,%}1$eH b!A!] &;OtOzi2d}(9~EDΝ$ƻYZt"8pn< V7z*٭9{1ա8KfO' ""2'mf'7rG7kXDDdio=."~Ц̨f]8wt׫޳ؗET\ lvo@ c^{RÛ(🫏gN0ۿ1>gq<L!V?`AêP"9U+F'ͪ(6]ٯ@%PeaU >o" "" ؃>^ {a" ܈(LoV?i&WW٭8ʉgꫜPa"cu "mg@աIs&^ͻSz٫r`# wjW_DDrJQa(:^Lk \Qm ~=XNh]|cݘ/ ""%@$[lغ25+Sv/W^1ODDrKź&ఁաpz坼~f''8_DDdvE ~5u>b;UQD@DrH H f6` j-p# "n@ 76,+]C" "j] ?$ &:TA7Q?ߧ(מn ٭W/=+XEDd_n#@_姁g?voG4r{5-`(/WxprTs_U{Py/ "#4!G{ VZ?ُͩ(I??l0<2`NhwED@$6C]#wX~dzgED@$T}@cN~ZFDDrٯ6MD&YϼfpIo"" "_~/N(|h~z൯W@v@DD@$M F?f7񚿈ȅwlh?RœtARDD@dj:|<>*pt>ekU9Q"`76gP82Hnߐwl% M£g1HnK>pc=G+Xlj" o _3|)pG6ɕ> $ץ l 6p?Nh4fg雲!8 9(j¿o+P1ux^ & z~" ܈L>? l6;;<%7r#i-]wegsBFwGEDD@r-{5^W 'N6,+|"" [@,El T SgEDD@&׎&CញT_DDdr6aэ}@ju(jx^DDd$0?t_ 89p&2߽Z'iJ[XD|""^54 1t嬺EDD&?^7?i`NtdQ\*o }u4>r݈'"" SKٻMƲvz^{j{|j""[M^W{m2{V^=iξ;=nDDD Āa[5@ ̷ ΗN_DDD`l0WJ;Fۏ5ɕvމz]`VJ'ro/"" ؙmm@WP)p'76gMN('fu?q"<lXQǟ9/aV^qUdNoIENDB`cefpython-49.0/examples/resources/reload.gif000066400000000000000000000022311334103266300212310ustar00rootroot00000000000000GIF89a3e6f2f4g4g4g2f2g2g2g2h2h3h4h4i2h2i=p2i2i2j2i2j5k4k5l4l2k3l2l2o8qw>w6y7z9z9~:;<Ar@uJzN~FzFzH{;<=?WzMMV]FCBJHIVRZP]^_XZXZambackssttuafhmd`l||z|wzׁ悥悦惦愧抪厭匬烩萮䒯摯蔰柷㛶噵皵睷琰땳蔲ꓳ푲잹졸㡹根颻飻駾蠻좼줾!, H$(`Aƒ ZPH?{aAD "X a|hPB8)uK1 `9P8p(Qhњ`bʔ3mEcժTX4 |OG] H( B:m#J 1jGKJCfH3T6p_h6s{e3r#zXsy"w֮uu>p!tc5'~6/tj#w K-b]-2"@; )ëic.@b0*2"  aaQt U!Lj$Q D$@8FvD@,@ -4`{7yP@;cefpython-49.0/examples/resources/reload.png000066400000000000000000000026141334103266300212550ustar00rootroot00000000000000PNG  IHDRĴl;bKGDC pHYs ,tIME 9'JIDATx}Ml\|8=ؐ n(i( 6jK VccSu_bbJiZ)H(Ăi%$D6:`;=3y>]L:ʕ_>o4Y̓l5nl,o'Og1g`!!&a:"LAO:u+ ^A |`g}Srj Viڽ 0iky4aw 8}x壇#%T'J RmVa:??Q|[rOȧ=&K ! S(PJ"858{mhuxҞ(t6|t⹒\%J4p X͑h^(V2P~PW;_]t8yh]՝&&7[ qbKZ&?vXk&s[zʬ|]- R*CA2[3MsRD)ɕ%bՍi0 *+r"[0צ密tR^bVB>;urnB3( }Q9,B֦J 6dLGIÔw>jFw슬J,sdH֓&4}q@YWs<2SȻ ]9xn4cxwx=,0UvxZܾmB䄡tХ޳<=|Z J%G' fB69 0`Q,Ւމ]1Uv¡>R䞫ST!~06$lbzodEY:]~Fs`F7z+!#!)ݴVU̅,W7S {۟&lW<`5q8_N  ^>I|DuQZFBPpF ;~VVV[?[#lz6PΤXri=KhR֛ o|t}V_sa-b8Yh3_N;ʌ^ ķVoGs_6"oFflg.\Ǭ6b8e OvBRSnekz?JJyɒJ\G*|ngzl6O_[Vwpa[Re>*%sQeTrHjZϿKka?S_x6$KKK/%P\desc,ddscm|mmod (cprt4-XYZ Vh/ XYZ {o XYZ $GXYZ Rsf32 B&lcurvcurvcurvvcgt ; P[O/f!w "#[$%'*(f)*+-..]/0124516K7d8~9:;<=? @ A3BICaDwEFGHIJLMN7ONPeQuRSTUVWXYZ\]^$_2`CaTbacldse{fghijklmnopqst uvw'x-y3z;{D|L}O~W[]ckuĒēpaSB-؟àhM2ɩ}_C' ӱeH,߹v^H5! ļţƌxhZK9ͿΈNњYԑL ׉Cٳo+ܚP޿r&C[ j|+=af52k!     "##$$#&'''()*(+,,,../00/22334354758899:;;;=>>=?@@@A@CCDDEFFFGGHIIIJIKKLNNNOOPOQQQRRSSTSUVVVWVXXXYZZ[[[\\]^^^__``aabbcdddeeffgghiiijjkkllmmnmoopqqqrssstuuuvuwwxwzz{{|{}}~~ *6GMPSVY\`cgmt~-BNbs  /9N]kx !"$% &''(-)5*=+F,M-O.V/Y0[1_2c3i4o5n6k7k8m9m:l;oj?b@aA\BJCCDrE*EFGIGHIaJJKL7LMN^OOPvQ-QRSJSTUmV!VWXAXYZ_[[\]3]^_S``arb%bcdBdefegghi9ijk[l lmvn,nopqrstu|vwsxqy_zT{L|E};~2(ׅȆvcTB/ ԓxbO;&ҠyeRD7)ޮկ̰wsvurpopqtyƒÕġũƵ *EdωЯ+d֢!`ۤQ߳~R ndin6RV'P T9J=J=n $/<JYi|!?^~:c S3p5} YMS  o 4  m H , wy /Q{M1xn w!,!"#K$$%&A&'()I**+,u-E../01n2G3!345678w9^:D;*<=>>?@ABCDEFGHIKLMINmOPQSTMUVWY,Zh[\^C_`b'cdf'ghjEkm npoqGrtuvxky{W|~A5# 3ڙtUNJCZccuҵ+^bŬZ̾)чjDݟLM3.h %7MYe  5ax+d_4YFpGt-\R d  G 2 & d !$/C]yXI[ }!7!"#o$0$%&~'F(()*y+J,,-./y0U13223d34567q8\9I:8;(<=>>?@ABCDEFnFGJ KL!M0N@ORPfQ{STUVXY?Za[]^`%aRbcdfgGh|jl'mdnoq"restv6wx{c|~UV eŠ!GP+ jեQϩΫQԯi )MwA{ʺ[ϣԛEٟNޱdAv6|Be !2E[t>g%\GU6+4M  | S 4   'DmwQ. !"#$&'+(K)l*+,./N0134D568'9u:<=y>@5ABDpEGPHIJKMN0OKP[QRSTVW=XkYZ[]7^u_`b)ctdegEhik5lmo;pqsMtvwxxzA{}~mڄH:)$)"/?ÜDƟZ٢o28ðQ޳j(˜ ũȎˁcCҴ!Ճ7ْHݣEM ,Jd|ze<ij\desc Color LCDmluc enUS(frFRB:Color LCDcran cristaux lisquides couleurmmod+MrtextCopyright Apple Computer, Inc., 2005,<7m H*\ȰÇ#JHŋ3jȱǏ CZ45ϥXDF5dž !V9*Jr b /ljM`!r7W}"|$0U+\'nM=iCCPICC ProfileXígTϲ{Yr9,$QDXrΒ.eaɂd JRAE$"Q$A@yzx9}W53=]5]SР|@A2P:@ S56 K瘟^ck> 5(ČY.!~{ጆ8bQ) 8.(w=} YX.EP `4 pг42-uH[,MX#XǶcg`CnRL0J5fOOwep~zzT|zzR|W> \ M9NJMH {LHژfΖ~шEÍ's-_ɹUaA7"b Udeɣ/D*\W4tpJ*tVHӪCȀP$YyEeϕQy6vp{>G)'3q߳wO?fwo(021;D T,Lbz5+Q1X︠7o%%WԤݪݐ֜ޕѕِUz'n=l\<|PdagQ̓R2ՊwUrU;>F>!٨P4Yts/~5~nh~2%աM]oyξ7)oC{<) &gx?5;bh8IgSO"Lϒ̶M^@./V..S.|Za_X*uj-ҷ?ܶdIw_Ep(u}\srt{z |>s,Y~A!aAQQQqq II ))iiiYy .****)++]VQQQUA"5455utttu LLLMM,,--XZYYMZ;888::99;hbqAAAA!!!WG_ 7oLJJNNIIuvZZ:mzzFFffV֝;w޻Ú_Pp~aaQă%%eeWTTV>zT%\UU]'55uuO>{V_yC /_liimmkkoή7o޾y```pphaᑑFFG','&&'?~izznffv繹y%/++_}fccsǏ흝?www~:<<::>>94 bDjĆ$.dyuT4ktpz:!=7[( LbzNA,m>9J~:(ĄdD4E Č-%%m;J=er0 >KJ>^]TUtpKug,-#:κLzFFMLM6n䵜bjkіѶ.^~ա̉ԩreVCֺxy*xnz=c[Jspw"CBGh\S抡?qF}Bib>BɨT[9W2F3_eUC'Il\<|x˅#EKJ\WW =b"ګxXMm3t=ˮ@Āv$% 'A)h` F]9"aE.W:(<? &#!"%FELElM\A|Hb@RLr@jFZKFC%&!ϥS`(>RjS6QRR3Pߤ!9 ݣ M@ƐX$l¼Zf=<g(n_V7^Q3wuW-./#L'<-R!$!,""uWJKWTfACB>BEuEK\J0 *jo=ݚ=Zt:tE3fs8WEm/ anܦUzTUFfNk6$4`krL_ K _jWF֛6Rl{{?g\]A (,(`, Kuv h DpGx F(ChME8@EIX8xDĎ$dԔt ADG&ТhBSSR?ᣩmC ӗo0DCP4jz}#S󀫂ۖqWwLY,$ιBa"[boŋ$$-KKKHdd/)\(x]Z|tʆ*rUƺ־.>IYyżeg#GNM]P597zw->o1v 52p3X.$*]8*i$<"242Yk$䘔[Z3mˣ,YU4_2Vfprʤzfvŋ&.C%#[y[ ?͡/'omo5D?=v#R@؂@諯`S2 o## 臓µ ^BB U"9x b(IwDAJnFB251u M*-m>szu) #!c)S 8+!WOZx#xΌ];gi&)a(xK&.{Sn₀BKJa*N4>kk?];V%mMMszͷ,Y(Yy[gۼ=wruZsB[\kx\I,b0 f ^w#2%$;}-b$T[iB3dݕטs93_MMbliYT9mE#t֚>kmn%Cuv-Gϭ^ҾȑQޱIS3%sI  $4.]ވLޥ}_<G^Ǥǹ''~7^#HG_{|ơt0zz|-4zV`p!M(Hsejx@Q @(dt=:܃tH uߟH @ pmj+$/ P^W tʼn"t|Q)IIY/s%8e? pHYs+ IDAThCoƟ;@9cP@ .^RTQ4UH(Q6T""M)%0&|XkyFI661Ưifo]#fύv[^~fTƵaZtu4aϦ:D>5sm?XGҀ܊Wv5nz#lE_'}J#2U}0A!?<҂-/{ le簋&Xr 4wup}=}7ctS\V8!N2*W*eKˆ5qaLLL`'oG,Uѡip+ӭ+-!`W.;Bh===,YlE' x5?1alh/RabG)UOƢqo@&y2r!Wgb~p00QʵyFJ*OmƺdA"SF"[ž`oӷoݳ197 "k@U@M!_iQ_.erH>b1xl6{wyd?^]UslX"<8lۖ'?dO Xg:ݷ|8YTVe^rم'_̦ ?ZO6MA,L m[EhV!|x>S;{4jK|\Z7tSsm_Mss[ʭՋ0ǃX٬RxSŔ#)uG VDioa6cI2xDT%eU4 (* K5Rܠy Շ]v!V?[6,^}6|1AUx9 r%ڎxB)mT/őFUu,JV^ɋCw" σOppAnKZg DSH7$8Kg#QUIT6kc; Lb"n.œD1ZaKaY:ǏGGGǜ %Nf,%L~I&+R*ĝ fT p"P>a:\N+`19'qoxu wX·wwѣعs#K<,K (𺫉8P_xA4YRx 2狒8HLfvRlN XغyraT1- ~ښ¢Ug|8"MC*LGUŝ^ԕa(qDEؓ?}M>>|X_@go橻șRE\ӕI,*;LP}bת!OaN{zfi&X8jx'q<9r[nE8h͞\o o6gWçxb>*"$׫u(U4*n* KEeRXy rX7 oPٳMMM Eԏ~Deʄt5<2,c=1c "Ak*K{uacW`GF庻wFkkj|l6~jRBg$Xnn̉LPB ’V&͗*RYx4Ƽ~-sؾ}j"lق.}El&'֙!l-8|l𻙘1ۆaLg J}QVT5 9q?"̤ о;vPmmmD"uftkLEquLJp@fMq?kUl!/MBua HUѶEOQrÆ hd&5bmA1|r|ʥU"xͣ5ditjá 1ac#6#TM)- y1 ~|wk(wx1). ߐ*SyC袻8p۶mSjJ߻$6oOIS㶾56 ĩۅAT*`>Ρ {TZTs67ܜBW- :2YS2HXO0׍m* ~Kj7qma]O.o,19sܻ~Atvv`߾}*677/[Z,Fƹ =كmncuK͛7+ו4 aK\Ĉ wGCGGGU,֒e϶\FnlvnoWDPn+YVW"WlMBg)zæMlsO {+P% +sGJ}afTp^R$U_Ê=r1o1kϕh*\,\ VD\*XxBmΤZ,QVv[^ b IENDB`cefpython-49.0/examples/resources/wxpython.png000066400000000000000000000264101334103266300217070ustar00rootroot00000000000000PNG  IHDR>asRGBgAMA a pHYsod,IDATx^] tem3B@d&Ȱ !a (CepmqFؒFE#LeE@IXwoUiҡw|snUu6,2,2,2,2,2,2,2,2,2,2,2,?+f́u>fdI0kVŐ'"=}5Mgbp5kv^\dKU{V>ph,Pefb|мy9sCgf2JOW͘JK30}z(5U=JJR%&6M=4u`Bk[';L j{Oϲke"b[f_eG-r~p܂̟ȼy̝Ȝ9̞ȬYdd(2stEfP$-MIMU$%EdEILTd4S*Ȕ)+2y"&)2q"qqL`Iv?t- ^-׭Xŋnvd"U…*^STB TB TB TATATATATATA !BP!'W$6(2n"c*Xθ8+ݖ-&.^vvK}sߎɻ~'[lq;wny-ny [^}-▗^rny<-HEEDٻWdnMq:EEdNErrDEnH xG _|@8ሼ@8rN;Dd(EF$?+kx ^e5ZYYο|+,N:A9pRwQRw(%}6-[D.%7 _}U 7oD AD ?Y䩧(BPFPdpǣG *k˗kS,|>lO?r@ϧp׆'AAJ:tCE|"=] i?{#yǓ/k"C曗'Mc?ȃ OPt~2dB1bor, Բ;>b;7o$s_"'N|矋|H/f~/x3_ < ??'̰a{⼗cYV3?>~ѢgPE9zT+Ksޟ_ {EGd͚ hv@AKcYo!=.K"N?.7FSdg{|_{-8w_)wME.7߬M79z/Dz@m}22l ]{8+}FB#ܳ!U}y$~ݺ_zȪU"'x;@cY;cr:5.YY.gGgg}>{{$į\)b@P(}EPi[(7vttr]/vKQ73%J"ge,Y"h wo;*m))$]%z~'~|gT`gG'>/Z$`ȸqҳPK6 )I9=m]23]cOg+BF~V$Zz|Eg_w)r'~|sEƌ)X͝NH˼y.xvN0 ggkhe_^U5gf?{ȬY"FJnvU,T22rcNUNqs]%zqlj 9at`oxy78Ϫ$~Ҳ=~3Ef1Ptfȍ2E9=y]22\cdCV,W %~rtzzF"""Ӧ"2lXtl@WNOhtcsc_V\/6<;)Id$ DƏg'2v"Ɛo? Ct*m&)'LKZ yD/9?8aOϿϧNc[W>ʐ/2|С" Jt]ڴQm[Kظ8vIMuɦM%zqEJf `& )@2$Ӏ@0ŋx`20 +nUۦiqNM0!oQQB^/ы;yuʟP_f|ϐH׏yB"٫@t&n~w<M;tnp6ߞ ?n@#4]'(pϕ7]P+Kr<'=%n=pF8Q zӻv=@꥜у\KŽ3}`=B'٦sÆ$~_?dȥoIo_,eD7=Krі 2IHn@|Il`+KIG~jW'yyO66BKAHGizoo ׳r+k$%D'󡇌!,EaߟxNRS|(o@ڙ Ϛ.).vђOGkB?}GP n<P7 {w[Ѕ< 33E#@'9?x$W"?ʅ '$|~ ƹ00ڵ~}M:F]I% q,\='udfT?̛wR;9'ٳO*f9󤒞~R1㤒f 5rRIN>Lv}t*rw$Ɤ?fǰOp< ve iDPyO o?`*K @ċ =jR!ܲ}mڪU}YYo( lёwގkGҵ#Qjudd.iGf1CiibG\E))bG?ݞ(v莩SqwIn* %qq%$c{~{_PK|n"]p_|73]'N,`  W"U=7+'Xd6ZT f>`D}/^}rDEētxBյw\0ojɻ\)yHy𞼥K%YCCoA@yPN9~Sڣ ĖK,˿;`xNA|LA~jpCg"qfGXͣo_QOB^#jAMz) vZ5x~ߖS&gѓI1ݻ/v: 1H1bw1ܷ-[|1*7ސo&woҾ=׹@l>aaL85}sC Y6;mQ@@@H0/ {~~Vě=;3gǰE/ K`7νO8|U &{$1L MNgF[Lٸ?QV.9w+Pr\ DxN/ @  [b!x .\F<LdH!gm֏r_ix@1$hd! Ap! wժ(FE/+V]&<,'>Yq+tff; \uzq>5Hp?C\列K W"刿֭EE!5i@*,n0G>{7E?S|̋?s񇩁- C?+C|Mjx `[ʞ`!O ^,$0<$^$H&A= .8 `Ϛ5jfn}qH>Faw^_g7/)9`OA|Ӧ"4lRp'AS!_YzNcapl9(UAŋ…RR2KgӁTw;R A 873? wY$@!ʟៅIY՗E3\\7ow"( FT{dsu?o>052ȯ_:]$@ =`Oߟxwe(r9{6]N&'ON~〱1h6ZN+?<^n7 h_qΙБ jH A.`gVh%| 2]iܡﴍKg~7$GFGDw;nh<@exg[Ǿ;\s~E/J=… s&^ۀp`0Tl>޾93_AlՐ<$3Ǔxoh` Ʂ/LěrW1Og&a4iQj~ !_6ԓx{v.P3ȯ]=S_LH";Gdϩ>@/ϝ o B M3=0R,>":t.|%$b$`ij 0 ,ڭϦ|û˛H;QcRP9@m := ۃz@d{o= < = =RG= #5kzzﾔ͛A 8~C<P 5꟡-aqw9g!/BO? '~p 0%Q@s[8@ZZ$ZZxH"Gp$C#qr/}\w_VI|Jnj- : "5k Su DDh @xb5UKj@j4 3pTIh.\7unH$;x do I|Y}ϪLdH#_ nƿxǦ@JJ2mhH=g`~C3YٛijW k){w_\}|^ |U:FHdD3HD]ED(:Mj) @ 7PnjUU( _ڊh  l9g H!??[? #^d<9sf,-.O_ ~@W hcJ ))_:UdHVI<X#Kwf'|Ǐ':pÖ/?%^a7#}[Sz0е;!-i_-i]g#j+5kG/EXX)TQ BC fӎDFn-|Գǰ}7?l)3S \ceool/%} QOyWGb@c(䆎|eѐ<$c[V$uOgUO㺾ė}ke=c̜'͑333?ʉr.͖51… ?ĕUF :!@BB2yhHv@95?^'sš'$?cEE;H%U 'l.,`,)|eo9;>~H O; hO!86()SEKHC7;yBX3GfEg8;>.l>_s ~v,*@P;v mv;6 䱕cgY;.q@`geol/՟; oa3P>O7 BqW LL Z|xX1$,?,/[so֤` /\ nr#jt(ڦ͇@_.ʟI({9 #`.=~Kx1C9c].@g ñn% C2޹O> @n`gjk %ۗ߹+@(W/QDi\{x/f 7078E~^̶ @z")D{z}0: V8@]#ĉ &+ A!mwo( @lSE빑^J  =DmBfDk,HVubqqSߐB YgԉIxq!p9;퀶86@=SI xH(;[;N W2Oho~3Cy߷f>D[7QJ&5mDFv$C#+8^,'#Ϗ{}=n絆8q bcswlH<;naC%޿3oc'+#jӦ4ndt:FvF@k ێ l|kOg8 jX \#F4Ro"4!,8#4cg9^y}9w S'QJF5nDt:rc U`'6C+ { x(OK h ız0ڿ2hh :+\``,1G<=~>"@п w|A6<^ `07v`2؁F~` {/YUx9 `_QIWjdcϕ?+:6e_R nmz}ׅtw۶6l(JdhQ!V:B\og!8Ŀl5)> X!">POhnT1ݻ@ p=l(V'qk>MxsCMQJA@'nd{`n0A@C\ㆍuo4#!o5 ի@Mp=Y1 FgOZ؏/ޝ VDJݺիj۷w8m[[yｶRX87x0Ŀ+`-HcoN/%)PJ gׅPkxzپ=cE ]={( Чt !@M)z/Q27w{[^=Q""D ߱m[;}\}w{pyw{7+jVVpthmd]p {O↎zGnk9>X&T>𯓏vu^JL@LL7pqs?N[nm\F |F ѪWPlޭ[.l[ʑ#] 'bZxx>cرnR*f:w.຺a8g6{8䑣ag}N ě*7w _^] im{nݶnr 9||- D(Crrr۶F(<"^u^j5^Ta^\Tx 5<~VxBGxv0&&T@ B%,83q2U{UAOqw%Gy#;ARhUznǎ瞻m۸/z^p-˱ugZ17P cr7 3;3Ǜ{mF{11۷ߩR@WY1p-b\?lzy3_#縎2WcWh6[ % ZTUFwD{g ' DujT|P~ @rrlN{7~3ڦ#$ߎ|]``~,^Apoqw7/(>CCEdWH:\Sc=p *.[)J.G].r`(N[#MF؂m6Ni 7XAӳY4!UJ|9!^@aaywrR,tFG ȱC ,s;s< <z _累&gxo Dr>x/ŲڞGT)-I4k,}6s|O|^xwl6x%Xv5[jZTc f=Uˮ!6haOdd^}FxԩVv)j|V^aajR>.gw קZf@F2,2,2,2,2,2,2,2,2,2,2,7l6n=IENDB`cefpython-49.0/examples/screenshot.py000066400000000000000000000206721334103266300200220ustar00rootroot00000000000000""" Example of using CEF browser in off-screen rendering mode (windowless) to create a screenshot of a web page. This example doesn't depend on any third party GUI framework. This example is discussed in Tutorial in the Off-screen rendering section. Before running this script you have to install Pillow image library (PIL module): pip install Pillow With optionl arguments to this script you can resize viewport so that screenshot includes whole page with height like 5000px which would be an equivalent of scrolling down multiple pages. By default when no arguments are provided will load cefpython project page on Github with 5000px height. Usage: python screenshot.py python screenshot.py https://github.com/cztomczak/cefpython 1024 5000 python screenshot.py https://www.google.com/ncr 1024 768 Tested configurations: - CEF Python v49.0+ - Pillow 2.3.0 / 4.1.0 """ from cefpython3 import cefpython as cef import os import platform import subprocess import sys try: from PIL import Image, PILLOW_VERSION except: print("[screenshot.py] Error: PIL module not available. To install" " type: pip install Pillow") sys.exit(1) # Config URL = "https://github.com/cztomczak/cefpython" VIEWPORT_SIZE = (1024, 5000) SCREENSHOT_PATH = os.path.join(os.path.abspath(os.path.dirname(__file__)), "screenshot.png") def main(): check_versions() sys.excepthook = cef.ExceptHook # To shutdown all CEF processes on error if os.path.exists(SCREENSHOT_PATH): print("[screenshot.py] Remove old screenshot") os.remove(SCREENSHOT_PATH) command_line_arguments() # Off-screen-rendering requires setting "windowless_rendering_enabled" # option. settings = { "windowless_rendering_enabled": True, } switches = { # GPU acceleration is not supported in OSR mode, so must disable # it using these Chromium switches (Issues #240 and #463) "disable-gpu": "", "disable-gpu-compositing": "", # Tweaking OSR performance by setting the same Chromium flags # as in upstream cefclient (Issue #240). "enable-begin-frame-scheduling": "", "disable-surfaces": "", # This is required for PDF ext to work } browser_settings = { # Tweaking OSR performance (Issue #240) "windowless_frame_rate": 30, # Default frame rate in CEF is 30 } cef.Initialize(settings=settings, switches=switches) create_browser(browser_settings) cef.MessageLoop() cef.Shutdown() print("[screenshot.py] Opening screenshot with default application") open_with_default_application(SCREENSHOT_PATH) def check_versions(): print("[screenshot.py] CEF Python {ver}".format(ver=cef.__version__)) print("[screenshot.py] Python {ver} {arch}".format( ver=platform.python_version(), arch=platform.architecture()[0])) print("[screenshot.py] Pillow {ver}".format(ver=PILLOW_VERSION)) assert cef.__version__ >= "49.0", "CEF Python v49.0+ required to run this" def command_line_arguments(): if len(sys.argv) == 4: url = sys.argv[1] width = int(sys.argv[2]) height = int(sys.argv[3]) if url.startswith("http://") or url.startswith("https://"): global URL URL = url else: print("[screenshot.py] Error: Invalid url argument") sys.exit(1) if width > 0 and height > 0: global VIEWPORT_SIZE VIEWPORT_SIZE = (width, height) else: print("[screenshot.py] Error: Invalid width and height") sys.exit(1) elif len(sys.argv) > 1: print("[screenshot.py] Error: Expected arguments: url width height") sys.exit(1) def create_browser(settings): # Create browser in off-screen-rendering mode (windowless mode) # by calling SetAsOffscreen method. In such mode parent window # handle can be NULL (0). parent_window_handle = 0 window_info = cef.WindowInfo() window_info.SetAsOffscreen(parent_window_handle) print("[screenshot.py] Viewport size: {size}" .format(size=str(VIEWPORT_SIZE))) print("[screenshot.py] Loading url: {url}" .format(url=URL)) browser = cef.CreateBrowserSync(window_info=window_info, settings=settings, url=URL) browser.SetClientHandler(LoadHandler()) browser.SetClientHandler(RenderHandler()) browser.SendFocusEvent(True) # You must call WasResized at least once to let know CEF that # viewport size is available and that OnPaint may be called. browser.WasResized() def save_screenshot(browser): # Browser object provides GetUserData/SetUserData methods # for storing custom data associated with browser. The # "OnPaint.buffer_string" data is set in RenderHandler.OnPaint. buffer_string = browser.GetUserData("OnPaint.buffer_string") if not buffer_string: raise Exception("buffer_string is empty, OnPaint never called?") image = Image.frombytes("RGBA", VIEWPORT_SIZE, buffer_string, "raw", "RGBA", 0, 1) image.save(SCREENSHOT_PATH, "PNG") print("[screenshot.py] Saved image: {path}".format(path=SCREENSHOT_PATH)) def open_with_default_application(path): if sys.platform.startswith("darwin"): subprocess.call(("open", path)) elif os.name == "nt": # noinspection PyUnresolvedReferences os.startfile(path) elif os.name == "posix": subprocess.call(("xdg-open", path)) def exit_app(browser): # Important note: # Do not close browser nor exit app from OnLoadingStateChange # OnLoadError or OnPaint events. Closing browser during these # events may result in unexpected behavior. Use cef.PostTask # function to call exit_app from these events. print("[screenshot.py] Close browser and exit app") browser.CloseBrowser() cef.QuitMessageLoop() class LoadHandler(object): def OnLoadingStateChange(self, browser, is_loading, **_): """Called when the loading state has changed.""" if not is_loading: # Loading is complete sys.stdout.write(os.linesep) print("[screenshot.py] Web page loading is complete") save_screenshot(browser) # See comments in exit_app() why PostTask must be used cef.PostTask(cef.TID_UI, exit_app, browser) def OnLoadError(self, browser, frame, error_code, failed_url, **_): """Called when the resource load for a navigation fails or is canceled.""" if not frame.IsMain(): # We are interested only in loading main url. # Ignore any errors during loading of other frames. return print("[screenshot.py] ERROR: Failed to load url: {url}" .format(url=failed_url)) print("[screenshot.py] Error code: {code}" .format(code=error_code)) # See comments in exit_app() why PostTask must be used cef.PostTask(cef.TID_UI, exit_app, browser) class RenderHandler(object): def __init__(self): self.OnPaint_called = False def GetViewRect(self, rect_out, **_): """Called to retrieve the view rectangle which is relative to screen coordinates. Return True if the rectangle was provided.""" # rect_out --> [x, y, width, height] rect_out.extend([0, 0, VIEWPORT_SIZE[0], VIEWPORT_SIZE[1]]) return True def OnPaint(self, browser, element_type, paint_buffer, **_): """Called when an element should be painted.""" if self.OnPaint_called: sys.stdout.write(".") sys.stdout.flush() else: sys.stdout.write("[screenshot.py] OnPaint") self.OnPaint_called = True if element_type == cef.PET_VIEW: # Buffer string is a huge string, so for performance # reasons it would be better not to copy this string. # I think that Python makes a copy of that string when # passing it to SetUserData. buffer_string = paint_buffer.GetString(mode="rgba", origin="top-left") # Browser object provides GetUserData/SetUserData methods # for storing custom data associated with browser. browser.SetUserData("OnPaint.buffer_string", buffer_string) else: raise Exception("Unsupported element_type in OnPaint") if __name__ == '__main__': main() cefpython-49.0/examples/snippets/000077500000000000000000000000001334103266300171315ustar00rootroot00000000000000cefpython-49.0/examples/snippets/javascript_bindings.py000066400000000000000000000033261334103266300235320ustar00rootroot00000000000000""" Communicate between Python and Javascript asynchronously using inter-process messaging with the use of Javascript Bindings. """ from cefpython3 import cefpython as cef g_htmlcode = """

Javascript Bindings

""" def main(): cef.Initialize() browser = cef.CreateBrowserSync(url=cef.GetDataUrl(g_htmlcode), window_title="Javascript Bindings") browser.SetClientHandler(LifespanHandler()) bindings = cef.JavascriptBindings() bindings.SetFunction("py_function", py_function) bindings.SetFunction("py_callback", py_callback) browser.SetJavascriptBindings(bindings) cef.MessageLoop() del browser cef.Shutdown() def py_function(value, js_callback): print("Value sent from Javascript: "+value) js_callback.Call("I am a Python string #2", py_callback) def py_callback(value): print("Value sent from Javascript: "+value) class LifespanHandler(object): def OnLoadEnd(self, browser, **_): browser.ExecuteFunction("js_function", "I am a Python string #1") if __name__ == '__main__': main() cefpython-49.0/examples/snippets/javascript_errors.py000066400000000000000000000030451334103266300232470ustar00rootroot00000000000000""" Two ways for intercepting Javascript errors: 1. window.onerror event in Javascript 2. DisplayHandler.OnConsoleMessage in Python """ from cefpython3 import cefpython as cef g_htmlcode = """

Javascript Errors

""" def main(): cef.Initialize() browser = cef.CreateBrowserSync(url=cef.GetDataUrl(g_htmlcode), window_title="Javascript Errors") browser.SetClientHandler(DisplayHandler()) cef.MessageLoop() cef.Shutdown() class DisplayHandler(object): def OnConsoleMessage(self, browser, message, line, **_): if "error" in message.lower() or "uncaught" in message.lower(): logmsg = "[Py:OnConsoleMessage] {message} (line {line})" \ .format(message=message, line=line) print(logmsg) browser.ExecuteFunction("print", logmsg) if __name__ == '__main__': main() cefpython-49.0/examples/snippets/onbeforeclose.py000066400000000000000000000012041334103266300223250ustar00rootroot00000000000000""" Implement LifespanHandler.OnBeforeClose to execute custom code before browser window closes. """ from cefpython3 import cefpython as cef def main(): cef.Initialize() browser = cef.CreateBrowserSync(url="https://www.google.com/", window_title="OnBeforeClose") browser.SetClientHandler(LifespanHandler()) cef.MessageLoop() del browser cef.Shutdown() class LifespanHandler(object): def OnBeforeClose(self, browser): print("Browser ID: {}".format(browser.GetIdentifier())) print("Browser will close and app will exit") if __name__ == '__main__': main() cefpython-49.0/examples/snippets/ondomready.py000066400000000000000000000026511334103266300216500ustar00rootroot00000000000000""" Execute custom Python code on a web page as soon as DOM is ready. Implements a custom "_OnDomReady" event in the LoadHandler object. """ from cefpython3 import cefpython as cef def main(): cef.Initialize() browser = cef.CreateBrowserSync(url="https://www.google.com/", window_title="_OnDomReady event") load_handler = LoadHandler(browser) browser.SetClientHandler(load_handler) bindings = cef.JavascriptBindings() bindings.SetFunction("LoadHandler_OnDomReady", load_handler["_OnDomReady"]) browser.SetJavascriptBindings(bindings) cef.MessageLoop() del load_handler del browser cef.Shutdown() class LoadHandler(object): def __init__(self, browser): self.browser = browser def __getitem__(self, key): return getattr(self, key) def OnLoadStart(self, browser, **_): browser.ExecuteJavascript(""" if (document.readyState === "complete") { LoadHandler_OnDomReady(); } else { document.addEventListener("DOMContentLoaded", function() { LoadHandler_OnDomReady(); }); } """) def _OnDomReady(self): print("DOM is ready!") self.browser.ExecuteFunction("alert", "Message from Python: DOM is ready!") if __name__ == '__main__': main() cefpython-49.0/examples/snippets/onpagecomplete.py000066400000000000000000000022011334103266300225000ustar00rootroot00000000000000""" Execute custom Python code on a web page when page loading is complete. Implements a custom "_OnPageComplete" event in the LoadHandler object. """ from cefpython3 import cefpython as cef def main(): cef.Initialize() browser = cef.CreateBrowserSync(url="https://www.google.com/", window_title="_OnPageComplete event") browser.SetClientHandler(LoadHandler()) cef.MessageLoop() del browser cef.Shutdown() class LoadHandler(object): def OnLoadingStateChange(self, browser, is_loading, **_): """For detecting if page loading has ended it is recommended to use OnLoadingStateChange which is most reliable. The OnLoadEnd callback also available in LoadHandler can sometimes fail in some cases e.g. when image loading hangs.""" if not is_loading: self._OnPageComplete(browser) def _OnPageComplete(self, browser): print("Page loading is complete!") browser.ExecuteFunction("alert", "Message from Python: Page loading" " is complete!") if __name__ == '__main__': main() cefpython-49.0/examples/snippets/setcookie.py000066400000000000000000000016651334103266300215000ustar00rootroot00000000000000""" Shows how to set a cookie. """ from cefpython3 import cefpython as cef import datetime def main(): cef.Initialize() cef.CreateBrowserSync( url="http://www.html-kit.com/tools/cookietester/", window_title="Set a cookie") manager = cef.CookieManager.GetGlobalManager() cookie = cef.Cookie() cookie.Set({ "name": "my_cookie", "value": "my_value", # Make sure domain is a valid value otherwise it crashes # app (Issue #459) "domain": "www.html-kit.com", "path": "/", "secure": False, "httpOnly": False, "creation": datetime.datetime(2018, 8, 22), "lastAccess": datetime.datetime(2018, 8, 22), "hasExpires": True, "expires": datetime.datetime(2028, 12, 31, 23, 59, 59), }) manager.SetCookie("http://www.html-kit.com/", cookie) cef.MessageLoop() cef.Shutdown() if __name__ == '__main__': main() cefpython-49.0/examples/snippets/window_size.py000066400000000000000000000024351334103266300220500ustar00rootroot00000000000000""" Set initial window size to 900/640px without use of any third party GUI framework. On Linux/Mac you can set window size by calling WindowInfo.SetAsChild. On Windows you can accomplish this by calling Windows native functions using the ctypes module. """ from cefpython3 import cefpython as cef import ctypes import platform def main(): cef.Initialize() window_info = cef.WindowInfo() parent_handle = 0 # This call has effect only on Mac and Linux. # All rect coordinates are applied including X and Y parameters. window_info.SetAsChild(parent_handle, [0, 0, 900, 640]) browser = cef.CreateBrowserSync(url="https://www.google.com/", window_info=window_info, window_title="Window size") if platform.system() == "Windows": window_handle = browser.GetOuterWindowHandle() insert_after_handle = 0 # X and Y parameters are ignored by setting the SWP_NOMOVE flag SWP_NOMOVE = 0x0002 # noinspection PyUnresolvedReferences ctypes.windll.user32.SetWindowPos(window_handle, insert_after_handle, 0, 0, 900, 640, SWP_NOMOVE) cef.MessageLoop() del browser cef.Shutdown() if __name__ == '__main__': main() cefpython-49.0/examples/tkinter_.py000066400000000000000000000321471334103266300174640ustar00rootroot00000000000000# Example of embedding CEF Python browser using Tkinter toolkit. # This example has two widgets: a navigation bar and a browser. # # NOTE: This example often crashes on Mac (Python 2.7, Tk 8.5/8.6) # during initial app loading with such message: # "Segmentation fault: 11". Reported as Issue #309. # # Tested configurations: # - Tk 8.5 on Windows/Mac # - Tk 8.6 on Linux # - CEF Python v49.0+ # # Known issue on Linux: When typing url, mouse must be over url # entry widget otherwise keyboard focus is lost (Issue #255 # and Issue #284). from cefpython3 import cefpython as cef try: import tkinter as tk except ImportError: import Tkinter as tk import sys import os import platform import logging as _logging # Fix for PyCharm hints warnings WindowUtils = cef.WindowUtils() # Platforms WINDOWS = (platform.system() == "Windows") LINUX = (platform.system() == "Linux") MAC = (platform.system() == "Darwin") # Globals logger = _logging.getLogger("tkinter_.py") # Constants # Tk 8.5 doesn't support png images IMAGE_EXT = ".png" if tk.TkVersion > 8.5 else ".gif" def main(): logger.setLevel(_logging.INFO) stream_handler = _logging.StreamHandler() formatter = _logging.Formatter("[%(filename)s] %(message)s") stream_handler.setFormatter(formatter) logger.addHandler(stream_handler) logger.info("CEF Python {ver}".format(ver=cef.__version__)) logger.info("Python {ver} {arch}".format( ver=platform.python_version(), arch=platform.architecture()[0])) logger.info("Tk {ver}".format(ver=tk.Tcl().eval('info patchlevel'))) assert cef.__version__ >= "49.0", "CEF Python v49.0+ required to run this" sys.excepthook = cef.ExceptHook # To shutdown all CEF processes on error root = tk.Tk() app = MainFrame(root) # Tk must be initialized before CEF otherwise fatal error (Issue #306) cef.Initialize() app.mainloop() cef.Shutdown() class MainFrame(tk.Frame): def __init__(self, root): self.browser_frame = None self.navigation_bar = None # Root root.geometry("800x600") tk.Grid.rowconfigure(root, 0, weight=1) tk.Grid.columnconfigure(root, 0, weight=1) # MainFrame tk.Frame.__init__(self, root) self.master.title("Tkinter example") self.master.protocol("WM_DELETE_WINDOW", self.on_close) self.master.bind("", self.on_root_configure) self.setup_icon() self.bind("", self.on_configure) self.bind("", self.on_focus_in) self.bind("", self.on_focus_out) # NavigationBar self.navigation_bar = NavigationBar(self) self.navigation_bar.grid(row=0, column=0, sticky=(tk.N + tk.S + tk.E + tk.W)) tk.Grid.rowconfigure(self, 0, weight=0) tk.Grid.columnconfigure(self, 0, weight=0) # BrowserFrame self.browser_frame = BrowserFrame(self, self.navigation_bar) self.browser_frame.grid(row=1, column=0, sticky=(tk.N + tk.S + tk.E + tk.W)) tk.Grid.rowconfigure(self, 1, weight=1) tk.Grid.columnconfigure(self, 0, weight=1) # Pack MainFrame self.pack(fill=tk.BOTH, expand=tk.YES) def on_root_configure(self, _): logger.debug("MainFrame.on_root_configure") if self.browser_frame: self.browser_frame.on_root_configure() def on_configure(self, event): logger.debug("MainFrame.on_configure") if self.browser_frame: width = event.width height = event.height if self.navigation_bar: height = height - self.navigation_bar.winfo_height() self.browser_frame.on_mainframe_configure(width, height) def on_focus_in(self, _): logger.debug("MainFrame.on_focus_in") def on_focus_out(self, _): logger.debug("MainFrame.on_focus_out") def on_close(self): if self.browser_frame: self.browser_frame.on_root_close() self.master.destroy() def get_browser(self): if self.browser_frame: return self.browser_frame.browser return None def get_browser_frame(self): if self.browser_frame: return self.browser_frame return None def setup_icon(self): resources = os.path.join(os.path.dirname(__file__), "resources") icon_path = os.path.join(resources, "tkinter"+IMAGE_EXT) if os.path.exists(icon_path): self.icon = tk.PhotoImage(file=icon_path) # noinspection PyProtectedMember self.master.call("wm", "iconphoto", self.master._w, self.icon) class BrowserFrame(tk.Frame): def __init__(self, master, navigation_bar=None): self.navigation_bar = navigation_bar self.closing = False self.browser = None tk.Frame.__init__(self, master) self.bind("", self.on_focus_in) self.bind("", self.on_focus_out) self.bind("", self.on_configure) self.focus_set() def embed_browser(self): window_info = cef.WindowInfo() rect = [0, 0, self.winfo_width(), self.winfo_height()] window_info.SetAsChild(self.get_window_handle(), rect) self.browser = cef.CreateBrowserSync(window_info, url="https://www.google.com/") assert self.browser self.browser.SetClientHandler(LoadHandler(self)) self.browser.SetClientHandler(FocusHandler(self)) self.message_loop_work() def get_window_handle(self): if self.winfo_id() > 0: return self.winfo_id() elif MAC: # On Mac window id is an invalid negative value (Issue #308). # This is kind of a dirty hack to get window handle using # PyObjC package. If you change structure of windows then you # need to do modifications here as well. # noinspection PyUnresolvedReferences from AppKit import NSApp # noinspection PyUnresolvedReferences import objc # Sometimes there is more than one window, when application # didn't close cleanly last time Python displays an NSAlert # window asking whether to Reopen that window. # noinspection PyUnresolvedReferences return objc.pyobjc_id(NSApp.windows()[-1].contentView()) else: raise Exception("Couldn't obtain window handle") def message_loop_work(self): cef.MessageLoopWork() self.after(10, self.message_loop_work) def on_configure(self, _): if not self.browser: self.embed_browser() def on_root_configure(self): # Root event will be called when top window is moved if self.browser: self.browser.NotifyMoveOrResizeStarted() def on_mainframe_configure(self, width, height): if self.browser: if WINDOWS: WindowUtils.UpdateBrowserSize(self.get_window_handle(), self.browser) elif LINUX: self.browser.SetBounds(0, 0, width, height) self.browser.NotifyMoveOrResizeStarted() def on_focus_in(self, _): logger.debug("BrowserFrame.on_focus_in") if self.browser: self.browser.SetFocus(True) def on_focus_out(self, _): logger.debug("BrowserFrame.on_focus_out") if self.browser: self.browser.SetFocus(False) def on_root_close(self): if self.browser: self.browser.CloseBrowser(True) self.clear_browser_references() self.destroy() def clear_browser_references(self): # Clear browser references that you keep anywhere in your # code. All references must be cleared for CEF to shutdown cleanly. self.browser = None class LoadHandler(object): def __init__(self, browser_frame): self.browser_frame = browser_frame def OnLoadStart(self, browser, **_): if self.browser_frame.master.navigation_bar: self.browser_frame.master.navigation_bar.set_url(browser.GetUrl()) class FocusHandler(object): def __init__(self, browser_frame): self.browser_frame = browser_frame def OnTakeFocus(self, next_component, **_): logger.debug("FocusHandler.OnTakeFocus, next={next}" .format(next=next_component)) def OnSetFocus(self, source, **_): logger.debug("FocusHandler.OnSetFocus, source={source}" .format(source=source)) return False def OnGotFocus(self, **_): """Fix CEF focus issues (#255). Call browser frame's focus_set to get rid of type cursor in url entry widget.""" logger.debug("FocusHandler.OnGotFocus") self.browser_frame.focus_set() class NavigationBar(tk.Frame): def __init__(self, master): self.back_state = tk.NONE self.forward_state = tk.NONE self.back_image = None self.forward_image = None self.reload_image = None tk.Frame.__init__(self, master) resources = os.path.join(os.path.dirname(__file__), "resources") # Back button back_png = os.path.join(resources, "back"+IMAGE_EXT) if os.path.exists(back_png): self.back_image = tk.PhotoImage(file=back_png) self.back_button = tk.Button(self, image=self.back_image, command=self.go_back) self.back_button.grid(row=0, column=0) # Forward button forward_png = os.path.join(resources, "forward"+IMAGE_EXT) if os.path.exists(forward_png): self.forward_image = tk.PhotoImage(file=forward_png) self.forward_button = tk.Button(self, image=self.forward_image, command=self.go_forward) self.forward_button.grid(row=0, column=1) # Reload button reload_png = os.path.join(resources, "reload"+IMAGE_EXT) if os.path.exists(reload_png): self.reload_image = tk.PhotoImage(file=reload_png) self.reload_button = tk.Button(self, image=self.reload_image, command=self.reload) self.reload_button.grid(row=0, column=2) # Url entry self.url_entry = tk.Entry(self) self.url_entry.bind("", self.on_url_focus_in) self.url_entry.bind("", self.on_url_focus_out) self.url_entry.bind("", self.on_load_url) self.url_entry.bind("", self.on_button1) self.url_entry.grid(row=0, column=3, sticky=(tk.N + tk.S + tk.E + tk.W)) tk.Grid.rowconfigure(self, 0, weight=100) tk.Grid.columnconfigure(self, 3, weight=100) # Update state of buttons self.update_state() def go_back(self): if self.master.get_browser(): self.master.get_browser().GoBack() def go_forward(self): if self.master.get_browser(): self.master.get_browser().GoForward() def reload(self): if self.master.get_browser(): self.master.get_browser().Reload() def set_url(self, url): self.url_entry.delete(0, tk.END) self.url_entry.insert(0, url) def on_url_focus_in(self, _): logger.debug("NavigationBar.on_url_focus_in") def on_url_focus_out(self, _): logger.debug("NavigationBar.on_url_focus_out") def on_load_url(self, _): if self.master.get_browser(): self.master.get_browser().StopLoad() self.master.get_browser().LoadUrl(self.url_entry.get()) def on_button1(self, _): """Fix CEF focus issues (#255). See also FocusHandler.OnGotFocus.""" logger.debug("NavigationBar.on_button1") self.master.master.focus_force() def update_state(self): browser = self.master.get_browser() if not browser: if self.back_state != tk.DISABLED: self.back_button.config(state=tk.DISABLED) self.back_state = tk.DISABLED if self.forward_state != tk.DISABLED: self.forward_button.config(state=tk.DISABLED) self.forward_state = tk.DISABLED self.after(100, self.update_state) return if browser.CanGoBack(): if self.back_state != tk.NORMAL: self.back_button.config(state=tk.NORMAL) self.back_state = tk.NORMAL else: if self.back_state != tk.DISABLED: self.back_button.config(state=tk.DISABLED) self.back_state = tk.DISABLED if browser.CanGoForward(): if self.forward_state != tk.NORMAL: self.forward_button.config(state=tk.NORMAL) self.forward_state = tk.NORMAL else: if self.forward_state != tk.DISABLED: self.forward_button.config(state=tk.DISABLED) self.forward_state = tk.DISABLED self.after(100, self.update_state) class Tabs(tk.Frame): def __init__(self): tk.Frame.__init__(self) # TODO: implement tabs if __name__ == '__main__': main() cefpython-49.0/examples/tutorial.py000066400000000000000000000155541334103266300175130ustar00rootroot00000000000000# Tutorial example. Doesn't depend on any third party GUI framework. # Tested with CEF Python v49.0+ from cefpython3 import cefpython as cef import base64 import platform import sys import threading # HTML code. Browser will navigate to a Data uri created # from this html code. HTML_code = """

Tutorial example

""" def main(): check_versions() sys.excepthook = cef.ExceptHook # To shutdown all CEF processes on error cef.Initialize() set_global_handler() browser = cef.CreateBrowserSync(url=html_to_data_uri(HTML_code), window_title="Tutorial") set_client_handlers(browser) set_javascript_bindings(browser) cef.MessageLoop() cef.Shutdown() def check_versions(): print("[tutorial.py] CEF Python {ver}".format(ver=cef.__version__)) print("[tutorial.py] Python {ver} {arch}".format( ver=platform.python_version(), arch=platform.architecture()[0])) assert cef.__version__ >= "49.0", "CEF Python v49.0+ required to run this" def html_to_data_uri(html, js_callback=None): # This function is called in two ways: # 1. From Python: in this case value is returned # 2. From Javascript: in this case value cannot be returned because # inter-process messaging is asynchronous, so must return value # by calling js_callback. html = html.encode("utf-8", "replace") b64 = base64.b64encode(html).decode("utf-8", "replace") ret = "data:text/html;base64,{data}".format(data=b64) if js_callback: js_print(js_callback.GetFrame().GetBrowser(), "Python", "html_to_data_uri", "Called from Javascript. Will call Javascript callback now.") js_callback.Call(ret) else: return ret def set_global_handler(): # A global handler is a special handler for callbacks that # must be set before Browser is created using # SetGlobalClientCallback() method. global_handler = GlobalHandler() cef.SetGlobalClientCallback("OnAfterCreated", global_handler.OnAfterCreated) def set_client_handlers(browser): client_handlers = [LoadHandler(), DisplayHandler()] for handler in client_handlers: browser.SetClientHandler(handler) def set_javascript_bindings(browser): external = External(browser) bindings = cef.JavascriptBindings( bindToFrames=False, bindToPopups=False) bindings.SetProperty("python_property", "This property was set in Python") bindings.SetProperty("cefpython_version", cef.GetVersion()) bindings.SetFunction("html_to_data_uri", html_to_data_uri) bindings.SetObject("external", external) browser.SetJavascriptBindings(bindings) def js_print(browser, lang, event, msg): # Execute Javascript function "js_print" browser.ExecuteFunction("js_print", lang, event, msg) class GlobalHandler(object): def OnAfterCreated(self, browser, **_): """Called after a new browser is created.""" # DOM is not yet loaded. Using js_print at this moment will # throw an error: "Uncaught ReferenceError: js_print is not defined". # We make this error on purpose. This error will be intercepted # in DisplayHandler.OnConsoleMessage. js_print(browser, "Python", "OnAfterCreated", "This will probably never display as DOM is not yet loaded") # Delay print by 0.5 sec, because js_print is not available yet args = [browser, "Python", "OnAfterCreated", "(Delayed) Browser id="+str(browser.GetIdentifier())] threading.Timer(0.5, js_print, args).start() class LoadHandler(object): def OnLoadingStateChange(self, browser, is_loading, **_): """Called when the loading state has changed.""" if not is_loading: # Loading is complete. DOM is ready. js_print(browser, "Python", "OnLoadingStateChange", "Loading is complete") class DisplayHandler(object): def OnConsoleMessage(self, browser, message, **_): """Called to display a console message.""" # This will intercept js errors, see comments in OnAfterCreated if "error" in message.lower() or "uncaught" in message.lower(): # Prevent infinite recurrence in case something went wrong if "js_print is not defined" in message.lower(): if hasattr(self, "js_print_is_not_defined"): print("Python: OnConsoleMessage: " "Intercepted Javascript error: "+message) return else: self.js_print_is_not_defined = True # Delay print by 0.5 sec, because js_print may not be # available yet due to DOM not ready. args = [browser, "Python", "OnConsoleMessage", "(Delayed) Intercepted Javascript error: {error}" .format(error=message)] threading.Timer(0.5, js_print, args).start() class External(object): def __init__(self, browser): self.browser = browser def test_multiple_callbacks(self, js_callback): """Test both javascript and python callbacks.""" js_print(self.browser, "Python", "test_multiple_callbacks", "Called from Javascript. Will call Javascript callback now.") def py_callback(msg_from_js): js_print(self.browser, "Python", "py_callback", msg_from_js) js_callback.Call("String sent from Python", py_callback) if __name__ == '__main__': main() cefpython-49.0/examples/wxpython.py000066400000000000000000000176241334103266300175500ustar00rootroot00000000000000# Example of embedding CEF Python browser using wxPython library. # This example has a top menu and a browser widget without navigation bar. # Tested configurations: # - wxPython 4.0 on Windows/Mac/Linux # - wxPython 3.0 on Windows/Mac # - wxPython 2.8 on Linux # - CEF Python v49.0+ import wx from cefpython3 import cefpython as cef import platform import sys import os # Fix for PyCharm hints warnings when using static methods WindowUtils = cef.WindowUtils() # Platforms WINDOWS = (platform.system() == "Windows") LINUX = (platform.system() == "Linux") MAC = (platform.system() == "Darwin") # Configuration WIDTH = 800 HEIGHT = 600 # Globals g_count_windows = 0 def main(): check_versions() sys.excepthook = cef.ExceptHook # To shutdown all CEF processes on error settings = {} # To enable High DPI support embed a DPI awareness manifest in # both the main process and the subprocess.exe executable. Calling # cef.DpiAware.SetProcessDpiAware sets DPI awareness only for # the main process and thus is not recommended. Also you have to # set ApplicationSettings.auto_zooming to "system_dpi". cef.Initialize(settings=settings) app = CefApp(False) app.MainLoop() del app # Must destroy before calling Shutdown if not MAC: # On Mac shutdown is called in OnClose cef.Shutdown() def check_versions(): print("[wxpython.py] CEF Python {ver}".format(ver=cef.__version__)) print("[wxpython.py] Python {ver} {arch}".format( ver=platform.python_version(), arch=platform.architecture()[0])) print("[wxpython.py] wxPython {ver}".format(ver=wx.version())) # CEF Python version requirement assert cef.__version__ >= "49.0", "CEF Python v49.0+ required to run this" class MainFrame(wx.Frame): def __init__(self): wx.Frame.__init__(self, parent=None, id=wx.ID_ANY, title='wxPython example', size=(WIDTH, HEIGHT)) self.browser = None # Must ignore X11 errors like 'BadWindow' and others by # installing X11 error handlers. This must be done after # wx was intialized. if LINUX: WindowUtils.InstallX11ErrorHandlers() global g_count_windows g_count_windows += 1 self.setup_icon() self.create_menu() self.Bind(wx.EVT_CLOSE, self.OnClose) # Set wx.WANTS_CHARS style for the keyboard to work. # This style also needs to be set for all parent controls. self.browser_panel = wx.Panel(self, style=wx.WANTS_CHARS) self.browser_panel.Bind(wx.EVT_SET_FOCUS, self.OnSetFocus) self.browser_panel.Bind(wx.EVT_SIZE, self.OnSize) # On Linux must show before embedding browser, so that handle # is available (Issue #347). if LINUX: self.Show() # In wxPython 3.0 and wxPython 4.0 handle is still # not yet available, must delay embedding browser # (Issue #349). if wx.version().startswith("3.") or wx.version().startswith("4."): wx.CallLater(20, self.embed_browser) else: # This works fine in wxPython 2.8 self.embed_browser() else: self.embed_browser() self.Show() def setup_icon(self): icon_file = os.path.join(os.path.abspath(os.path.dirname(__file__)), "resources", "wxpython.png") # wx.IconFromBitmap is not available on Linux in wxPython 3.0/4.0 if os.path.exists(icon_file) and hasattr(wx, "IconFromBitmap"): icon = wx.IconFromBitmap(wx.Bitmap(icon_file, wx.BITMAP_TYPE_PNG)) self.SetIcon(icon) def create_menu(self): filemenu = wx.Menu() filemenu.Append(1, "Some option") filemenu.Append(2, "Another option") menubar = wx.MenuBar() menubar.Append(filemenu, "&File") self.SetMenuBar(menubar) def embed_browser(self): window_info = cef.WindowInfo() (width, height) = self.browser_panel.GetClientSize().Get() window_info.SetAsChild(self.browser_panel.GetHandle(), [0, 0, width, height]) self.browser = cef.CreateBrowserSync(window_info, url="https://www.google.com/") self.browser.SetClientHandler(FocusHandler()) def OnSetFocus(self, _): if not self.browser: return if WINDOWS: WindowUtils.OnSetFocus(self.browser_panel.GetHandle(), 0, 0, 0) self.browser.SetFocus(True) def OnSize(self, _): if not self.browser: return if WINDOWS: WindowUtils.UpdateBrowserSize(self.browser_panel.GetHandle(), self.browser) elif LINUX: (x, y) = (0, 0) (width, height) = self.browser_panel.GetSize().Get() self.browser.SetBounds(x, y, width, height) self.browser.NotifyMoveOrResizeStarted() def OnClose(self, event): print("[wxpython.py] OnClose called") if not self.browser: # May already be closing, may be called multiple times on Mac return if MAC: # On Mac things work differently, other steps are required self.browser.CloseBrowser() self.clear_browser_references() self.Destroy() global g_count_windows g_count_windows -= 1 if g_count_windows == 0: cef.Shutdown() wx.GetApp().ExitMainLoop() # Call _exit otherwise app exits with code 255 (Issue #162). # noinspection PyProtectedMember os._exit(0) else: # Calling browser.CloseBrowser() and/or self.Destroy() # in OnClose may cause app crash on some paltforms in # some use cases, details in Issue #107. self.browser.ParentWindowWillClose() event.Skip() self.clear_browser_references() def clear_browser_references(self): # Clear browser references that you keep anywhere in your # code. All references must be cleared for CEF to shutdown cleanly. self.browser = None class FocusHandler(object): def OnGotFocus(self, browser, **_): # Temporary fix for focus issues on Linux (Issue #284). if LINUX: print("[wxpython.py] FocusHandler.OnGotFocus:" " keyboard focus fix (Issue #284)") browser.SetFocus(True) class CefApp(wx.App): def __init__(self, redirect): self.timer = None self.timer_id = 1 self.is_initialized = False super(CefApp, self).__init__(redirect=redirect) def OnPreInit(self): super(CefApp, self).OnPreInit() # On Mac with wxPython 4.0 the OnInit() event never gets # called. Doing wx window creation in OnPreInit() seems to # resolve the problem (Issue #350). if MAC and wx.version().startswith("4."): print("[wxpython.py] OnPreInit: initialize here" " (wxPython 4.0 fix)") self.initialize() def OnInit(self): self.initialize() return True def initialize(self): if self.is_initialized: return self.is_initialized = True self.create_timer() frame = MainFrame() self.SetTopWindow(frame) frame.Show() def create_timer(self): # See also "Making a render loop": # http://wiki.wxwidgets.org/Making_a_render_loop # Another way would be to use EVT_IDLE in MainFrame. self.timer = wx.Timer(self, self.timer_id) self.Bind(wx.EVT_TIMER, self.on_timer, self.timer) self.timer.Start(10) # 10ms timer def on_timer(self, _): cef.MessageLoopWork() def OnExit(self): self.timer.Stop() return 0 if __name__ == '__main__': main() cefpython-49.0/patches/000077500000000000000000000000001334103266300150755ustar00rootroot00000000000000cefpython-49.0/patches/include.gypi000066400000000000000000000000661334103266300174140ustar00rootroot00000000000000{ 'variables': { 'use_allocator': 'none', }, }cefpython-49.0/patches/issue125.patch000066400000000000000000000014221334103266300174750ustar00rootroot00000000000000diff --git http_cache_transaction.cc http_cache_transaction.cc index 24002d75215d..2a44a6368558 100644 --- http_cache_transaction.cc +++ http_cache_transaction.cc @@ -2601,7 +2601,8 @@ int HttpCache::Transaction::WriteResponseInfoToEntry(bool truncated) { // blocking page is shown. An alternative would be to reverse-map the cert // status to a net error and replay the net error. if ((response_.headers->HasHeaderValue("cache-control", "no-store")) || - IsCertStatusError(response_.ssl_info.cert_status)) { + (!cache_->GetSession()->params().ignore_certificate_errors && + IsCertStatusError(response_.ssl_info.cert_status))) { DoneWritingToEntry(false); if (net_log_.IsCapturing()) net_log_.EndEvent(NetLogEventType::HTTP_CACHE_WRITE_INFO); cefpython-49.0/patches/issue218_linux.patch000066400000000000000000000051401334103266300207200ustar00rootroot00000000000000Index: libcef/browser/browser_host_impl_gtk.cc =================================================================== --- browser_host_impl_gtk.cc (revision 1639) +++ browser_host_impl_gtk.cc (working copy) @@ -273,8 +273,43 @@ // Parent the TabContents to the browser window. window_info_.widget = web_contents_->GetView()->GetNativeView(); - gtk_container_add(GTK_CONTAINER(window_info_.parent_widget), - window_info_.widget); + if (GTK_IS_BOX(window_info_.parent_widget)) { + gtk_box_pack_start(GTK_BOX(window_info_.parent_widget), + window_info_.widget, TRUE, TRUE, 0); + } else { + // Parent view shouldn't contain any children, but in wxWidgets library + // there will be GtkPizza widget for Panel or any other control. + GList *children, *iter; + children = gtk_container_get_children(GTK_CONTAINER( + window_info_.parent_widget)); + GtkWidget* child = NULL; + GtkWidget* vbox = gtk_vbox_new(FALSE, 0); + for (iter = children; iter != NULL; iter = g_list_next(iter)) { + child = GTK_WIDGET(iter->data); + // We will have to keep a reference to that child that we remove, + // otherwise we will get lots of warnings like "invalid unclassed + // pointer in cast to `GtkPizza'". First we increase a reference, + // we need to do this for a moment before we add this child to the + // vbox, then we will decrease that reference. + g_object_ref(G_OBJECT(child)); + gtk_container_remove(GTK_CONTAINER(window_info_.parent_widget), child); + } + g_list_free(children); + gtk_box_pack_start(GTK_BOX(vbox), window_info_.widget, TRUE, TRUE, 0); + if (child != NULL) { + // This child is packed to the box only so that its reference lives, + // as it might be referenced from other code thus resulting in errors. + gtk_box_pack_end(GTK_BOX(vbox), child, FALSE, FALSE, 0); + gtk_widget_hide(GTK_WIDGET(child)); + g_object_unref(G_OBJECT(child)); + } + gtk_widget_show(GTK_WIDGET(vbox)); + if (GTK_IS_SCROLLED_WINDOW(window_info_.parent_widget)) + gtk_scrolled_window_add_with_viewport( + GTK_SCROLLED_WINDOW(window_info_.parent_widget), vbox); + else + gtk_container_add(GTK_CONTAINER(window_info_.parent_widget), vbox); + } g_signal_connect(G_OBJECT(window_info_.widget), "destroy", G_CALLBACK(browser_destroy), this); @@ -293,6 +328,8 @@ prefs->inactive_selection_bg_color = SkColorSetRGB(200, 200, 200); prefs->inactive_selection_fg_color = SkColorSetRGB(50, 50, 50); + gtk_widget_show_all(GTK_WIDGET(window_info_.widget)); + return true; }cefpython-49.0/patches/issue231.patch000066400000000000000000000107101334103266300174730ustar00rootroot00000000000000diff --git include/capi/cef_path_util_capi.h include/capi/cef_path_util_capi.h index de99ebd8..dd2f21c5 100644 --- include/capi/cef_path_util_capi.h +++ include/capi/cef_path_util_capi.h @@ -51,6 +51,16 @@ extern "C" { /// CEF_EXPORT int cef_get_path(cef_path_key_t key, cef_string_t* path); +/// +// Override the path associated with the specified |key|. This cannot be used to +// change the value of PK_DIR_CURRENT, but that should be obvious. Also, if the +// path specifies a directory that does not exist, the directory will be created +// by this function. This function returns true (1) if successful. WARNING: +// Consumers of CefGetPath may expect paths to be constant over the lifetime of +// the app, so this function should be used with caution. +/// +CEF_EXPORT int cef_override_path(cef_path_key_t key, const cef_string_t* path); + #ifdef __cplusplus } #endif diff --git include/cef_path_util.h include/cef_path_util.h index 552f4ba5..95af66ef 100644 --- include/cef_path_util.h +++ include/cef_path_util.h @@ -49,4 +49,15 @@ typedef cef_path_key_t PathKey; /*--cef()--*/ bool CefGetPath(PathKey key, CefString& path); +/// +// Override the path associated with the specified |key|. This cannot +// be used to change the value of PK_DIR_CURRENT, but that should be obvious. +// Also, if the path specifies a directory that does not exist, the directory +// will be created by this method. This method returns true if successful. +// WARNING: Consumers of CefGetPath may expect paths to be constant +// over the lifetime of the app, so this method should be used with caution. +/// +/*--cef()--*/ +bool CefOverridePath(PathKey key, const CefString& path); + #endif // CEF_INCLUDE_CEF_PATH_UTIL_H_ diff --git libcef/browser/path_util_impl.cc libcef/browser/path_util_impl.cc index 6a759309..ad620d7f 100644 --- libcef/browser/path_util_impl.cc +++ libcef/browser/path_util_impl.cc @@ -51,3 +51,38 @@ bool CefGetPath(PathKey key, CefString& path) { return false; } + +bool CefOverridePath(PathKey key, const CefString& path) { + int pref_key = base::PATH_START; + switch(key) { + case PK_DIR_EXE: + pref_key = base::DIR_EXE; + break; + case PK_DIR_MODULE: + pref_key = base::DIR_MODULE; + break; + case PK_DIR_TEMP: + pref_key = base::DIR_TEMP; + break; + case PK_FILE_EXE: + pref_key = base::FILE_EXE; + break; + case PK_FILE_MODULE: + pref_key = base::FILE_MODULE; + break; +#if defined(OS_WIN) + case PK_LOCAL_APP_DATA: + pref_key = base::DIR_LOCAL_APP_DATA; + break; +#endif + case PK_USER_DATA: + pref_key = chrome::DIR_USER_DATA; + break; + default: + NOTREACHED() << "invalid argument"; + return false; + } + + base::FilePath file_path = base::FilePath(path); + return PathService::Override(pref_key, file_path); +} diff --git libcef_dll/libcef_dll.cc libcef_dll/libcef_dll.cc index 096eede2..05ecf9bd 100644 --- libcef_dll/libcef_dll.cc +++ libcef_dll/libcef_dll.cc @@ -959,6 +959,23 @@ CEF_EXPORT int cef_get_path(cef_path_key_t key, cef_string_t* path) { return _retval; } +CEF_EXPORT int cef_override_path(cef_path_key_t key, const cef_string_t* path) { + // AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING + + // Verify param: path; type: string_byref_const + DCHECK(path); + if (!path) + return 0; + + // Execute + bool _retval = CefOverridePath( + key, + CefString(path)); + + // Return type: bool + return _retval; +} + CEF_EXPORT int cef_launch_process(struct _cef_command_line_t* command_line) { // AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING diff --git libcef_dll/wrapper/libcef_dll_wrapper.cc libcef_dll/wrapper/libcef_dll_wrapper.cc index 15026ab5..a3d21052 100644 --- libcef_dll/wrapper/libcef_dll_wrapper.cc +++ libcef_dll/wrapper/libcef_dll_wrapper.cc @@ -880,6 +880,23 @@ CEF_GLOBAL bool CefGetPath(PathKey key, CefString& path) { return _retval?true:false; } +CEF_GLOBAL bool CefOverridePath(PathKey key, const CefString& path) { + // AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING + + // Verify param: path; type: string_byref_const + DCHECK(!path.empty()); + if (path.empty()) + return false; + + // Execute + int _retval = cef_override_path( + key, + path.GetStruct()); + + // Return type: bool + return _retval?true:false; +} + CEF_GLOBAL bool CefLaunchProcess(CefRefPtr command_line) { // AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING cefpython-49.0/patches/issue251.patch000066400000000000000000000240731334103266300175040ustar00rootroot00000000000000diff --git include/capi/cef_drag_data_capi.h include/capi/cef_drag_data_capi.h index e1fcfd8c..fc388247 100644 --- include/capi/cef_drag_data_capi.h +++ include/capi/cef_drag_data_capi.h @@ -39,6 +39,7 @@ #pragma once #include "include/capi/cef_base_capi.h" +#include "include/capi/cef_image_capi.h" #include "include/capi/cef_stream_capi.h" #ifdef __cplusplus @@ -195,6 +196,22 @@ typedef struct _cef_drag_data_t { /// void (CEF_CALLBACK *add_file)(struct _cef_drag_data_t* self, const cef_string_t* path, const cef_string_t* display_name); + + /// + // Set image representation of drag data. + /// + void (CEF_CALLBACK *set_image)(struct _cef_drag_data_t* self, + struct _cef_image_t* image); + + /// + // Get image representation of drag data (may be NULL). + /// + struct _cef_image_t* (CEF_CALLBACK *get_image)(struct _cef_drag_data_t* self); + + /// + // Whether image representation of drag data is available. + /// + int (CEF_CALLBACK *has_image)(struct _cef_drag_data_t* self); } cef_drag_data_t; diff --git include/cef_drag_data.h include/cef_drag_data.h index 29b85e84..e3c9c2df 100644 --- include/cef_drag_data.h +++ include/cef_drag_data.h @@ -39,6 +39,7 @@ #pragma once #include "include/cef_base.h" +#include "include/cef_image.h" #include "include/cef_stream.h" #include @@ -193,6 +194,24 @@ class CefDragData : public virtual CefBaseRefCounted { /// /*--cef(optional_param=display_name)--*/ virtual void AddFile(const CefString& path, const CefString& display_name) =0; + + /// + // Set image representation of drag data. + /// + /*--cef()--*/ + virtual void SetImage(CefRefPtr image) =0; + + /// + // Get image representation of drag data (may be NULL). + /// + /*--cef()--*/ + virtual CefRefPtr GetImage() =0; + + /// + // Whether image representation of drag data is available. + /// + /*--cef()--*/ + virtual bool HasImage() =0; }; #endif // CEF_INCLUDE_CEF_DRAG_DATA_H_ diff --git libcef/browser/osr/browser_platform_delegate_osr.cc libcef/browser/osr/browser_platform_delegate_osr.cc index 2cf44f6d..2e6b8c32 100644 --- libcef/browser/osr/browser_platform_delegate_osr.cc +++ libcef/browser/osr/browser_platform_delegate_osr.cc @@ -7,6 +7,7 @@ #include #include "libcef/browser/browser_host_impl.h" +#include "libcef/browser/image_impl.h" #include "libcef/browser/osr/render_widget_host_view_osr.h" #include "libcef/browser/osr/web_contents_view_osr.h" #include "libcef/common/drag_data_impl.h" @@ -393,7 +394,9 @@ void CefBrowserPlatformDelegateOsr::StartDragging( CefRefPtr handler = browser_->GetClient()->GetRenderHandler(); if (handler.get()) { - CefRefPtr drag_data(new CefDragDataImpl(drop_data)); + CefRefPtr cef_image(new CefImageImpl(image)); + CefRefPtr drag_data(new CefDragDataImpl(drop_data, + cef_image)); drag_data->SetReadOnly(true); base::MessageLoop::ScopedNestableTaskAllower allow( base::MessageLoop::current()); diff --git libcef/common/drag_data_impl.cc libcef/common/drag_data_impl.cc index 6b632ab2..2f12b928 100644 --- libcef/common/drag_data_impl.cc +++ libcef/common/drag_data_impl.cc @@ -20,6 +20,13 @@ CefDragDataImpl::CefDragDataImpl(const content::DropData& data) read_only_(false) { } +CefDragDataImpl::CefDragDataImpl(const content::DropData& data, + CefRefPtr image) + : data_(data), + image_(image), + read_only_(false) { +} + CefDragDataImpl::CefDragDataImpl() : read_only_(false) { } @@ -32,7 +39,7 @@ CefRefPtr CefDragDataImpl::Clone() { CefDragDataImpl* drag_data = NULL; { base::AutoLock lock_scope(lock_); - drag_data = new CefDragDataImpl(data_); + drag_data = new CefDragDataImpl(data_, image_); } return drag_data; } @@ -191,3 +198,20 @@ void CefDragDataImpl::SetReadOnly(bool read_only) { read_only_ = read_only; } + +void CefDragDataImpl::SetImage(CefRefPtr image) { + base::AutoLock lock_scope(lock_); + CHECK_READONLY_RETURN_VOID(); + image_ = image; +} + +CefRefPtr CefDragDataImpl::GetImage() { + base::AutoLock lock_scope(lock_); + return image_; +} + +bool CefDragDataImpl::HasImage() { + base::AutoLock lock_scope(lock_); + if (image_) return true; + else return false; +} diff --git libcef/common/drag_data_impl.h libcef/common/drag_data_impl.h index 64f29ed3..98707262 100644 --- libcef/common/drag_data_impl.h +++ libcef/common/drag_data_impl.h @@ -7,6 +7,7 @@ #pragma once #include "include/cef_drag_data.h" +#include "include/cef_image.h" #include @@ -18,6 +19,8 @@ class CefDragDataImpl : public CefDragData { public: CefDragDataImpl(); explicit CefDragDataImpl(const content::DropData& data); + explicit CefDragDataImpl(const content::DropData& data, + CefRefPtr image); CefRefPtr Clone() override; bool IsReadOnly() override; @@ -41,6 +44,9 @@ class CefDragDataImpl : public CefDragData { void SetFragmentBaseURL(const CefString& fragment) override; void ResetFileContents() override; void AddFile(const CefString& path, const CefString& display_name) override; + void SetImage(CefRefPtr image) override; + CefRefPtr GetImage() override; + bool HasImage() override; // This method is not safe. Use Lock/Unlock to get mutually exclusive access. content::DropData* drop_data() { @@ -53,6 +59,7 @@ class CefDragDataImpl : public CefDragData { private: content::DropData data_; + CefRefPtr image_; // True if this object is read-only. bool read_only_; diff --git libcef_dll/cpptoc/drag_data_cpptoc.cc libcef_dll/cpptoc/drag_data_cpptoc.cc index 381b88b9..6f4925a0 100644 --- libcef_dll/cpptoc/drag_data_cpptoc.cc +++ libcef_dll/cpptoc/drag_data_cpptoc.cc @@ -11,6 +11,7 @@ // #include "libcef_dll/cpptoc/drag_data_cpptoc.h" +#include "libcef_dll/cpptoc/image_cpptoc.h" #include "libcef_dll/cpptoc/stream_writer_cpptoc.h" #include "libcef_dll/transfer_util.h" @@ -367,6 +368,52 @@ void CEF_CALLBACK drag_data_add_file(struct _cef_drag_data_t* self, CefString(display_name)); } +void CEF_CALLBACK drag_data_set_image(struct _cef_drag_data_t* self, + struct _cef_image_t* image) { + // AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING + + DCHECK(self); + if (!self) + return; + // Verify param: image; type: refptr_same + DCHECK(image); + if (!image) + return; + + // Execute + CefDragDataCppToC::Get(self)->SetImage( + CefImageCppToC::Unwrap(image)); +} + +struct _cef_image_t* CEF_CALLBACK drag_data_get_image( + struct _cef_drag_data_t* self) { + // AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING + + DCHECK(self); + if (!self) + return NULL; + + // Execute + CefRefPtr _retval = CefDragDataCppToC::Get(self)->GetImage(); + + // Return type: refptr_same + return CefImageCppToC::Wrap(_retval); +} + +int CEF_CALLBACK drag_data_has_image(struct _cef_drag_data_t* self) { + // AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING + + DCHECK(self); + if (!self) + return 0; + + // Execute + bool _retval = CefDragDataCppToC::Get(self)->HasImage(); + + // Return type: bool + return _retval; +} + } // namespace @@ -395,6 +442,9 @@ CefDragDataCppToC::CefDragDataCppToC() { GetStruct()->set_fragment_base_url = drag_data_set_fragment_base_url; GetStruct()->reset_file_contents = drag_data_reset_file_contents; GetStruct()->add_file = drag_data_add_file; + GetStruct()->set_image = drag_data_set_image; + GetStruct()->get_image = drag_data_get_image; + GetStruct()->has_image = drag_data_has_image; } template<> CefRefPtr CefCppToCRefCounted image) { + cef_drag_data_t* _struct = GetStruct(); + if (CEF_MEMBER_MISSING(_struct, set_image)) + return; + + // AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING + + // Verify param: image; type: refptr_same + DCHECK(image.get()); + if (!image.get()) + return; + + // Execute + _struct->set_image(_struct, + CefImageCToCpp::Unwrap(image)); +} + +CefRefPtr CefDragDataCToCpp::GetImage() { + cef_drag_data_t* _struct = GetStruct(); + if (CEF_MEMBER_MISSING(_struct, get_image)) + return NULL; + + // AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING + + // Execute + cef_image_t* _retval = _struct->get_image(_struct); + + // Return type: refptr_same + return CefImageCToCpp::Wrap(_retval); +} + +bool CefDragDataCToCpp::HasImage() { + cef_drag_data_t* _struct = GetStruct(); + if (CEF_MEMBER_MISSING(_struct, has_image)) + return false; + + // AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING + + // Execute + int _retval = _struct->has_image(_struct); + + // Return type: bool + return _retval?true:false; +} + // CONSTRUCTOR - Do not edit by hand. diff --git libcef_dll/ctocpp/drag_data_ctocpp.h libcef_dll/ctocpp/drag_data_ctocpp.h index 5b202710..a2e3774f 100644 --- libcef_dll/ctocpp/drag_data_ctocpp.h +++ libcef_dll/ctocpp/drag_data_ctocpp.h @@ -54,6 +54,9 @@ class CefDragDataCToCpp void SetFragmentBaseURL(const CefString& base_url) OVERRIDE; void ResetFileContents() OVERRIDE; void AddFile(const CefString& path, const CefString& display_name) OVERRIDE; + void SetImage(CefRefPtr image) OVERRIDE; + CefRefPtr GetImage() OVERRIDE; + bool HasImage() OVERRIDE; }; #endif // CEF_LIBCEF_DLL_CTOCPP_DRAG_DATA_CTOCPP_H_ cefpython-49.0/patches/issue73_linux000066400000000000000000000003401334103266300175360ustar00rootroot00000000000000Patch to CEF. Fixes tcmalloc issue on Linux: https://github.com/cztomczak/cefpython/issues/73 Copy the "include.gypi" file to the ~/.gyp/ directory. The automate.py script applies this patch by setting GYP_DEFINES env var. cefpython-49.0/patches/patch.py000066400000000000000000000020311334103266300165420ustar00rootroot00000000000000# CEF Python patches to Chromium and CEF. # See upstream cef/patch/patch.cfg for how patching works in CEF. # Current working directory is cef_build_dir/chromium/cef/ . # See also docs/Build-instructions.md and tools/automate.py . import platform OS_POSTFIX = ("win" if platform.system() == "Windows" else "linux" if platform.system() == "Linux" else "mac" if platform.system() == "Darwin" else "unknown") # ALL PLATFORMS # noinspection PyUnresolvedReferences patches.extend([ { # Fixes HTTPS cache problems with private certificates 'name': 'issue125', 'path': '../net/http/' }, ]) # LINUX if OS_POSTFIX == "linux": # noinspection PyUnresolvedReferences patches.extend([ { # Discovery of the "icudtl.dat" file fails on Linux. 'name': 'issue231', 'path': './' }, { # Adds drag-image representation during drag & drop in OSR mode. 'name': 'issue251', 'path': './' }, ]) cefpython-49.0/src/000077500000000000000000000000001334103266300142355ustar00rootroot00000000000000cefpython-49.0/src/.gitignore000066400000000000000000000001621334103266300162240ustar00rootroot00000000000000# If you want to ignore an already commited directory run: # git rm --cached -r .idea compile_time_constants.pxi cefpython-49.0/src/app.pyx000066400000000000000000000011551334103266300155610ustar00rootroot00000000000000# Copyright (c) 2014 CEF Python, see the Authors file. # All rights reserved. Licensed under BSD 3-clause license. # Project website: https://github.com/cztomczak/cefpython include "cefpython.pyx" cdef public void App_OnBeforeCommandLineProcessing_BrowserProcess( CefRefPtr[CefCommandLine] cefCommandLine ) except * with gil: try: AppendSwitchesToCommandLine(cefCommandLine, g_commandLineSwitches) Debug("App_OnBeforeCommandLineProcessing_BrowserProcess()") except: (exc_type, exc_value, exc_trace) = sys.exc_info() sys.excepthook(exc_type, exc_value, exc_trace) cefpython-49.0/src/browser.pyx000066400000000000000000000720341334103266300164700ustar00rootroot00000000000000# Copyright (c) 2012 CEF Python, see the Authors file. # All rights reserved. Licensed under BSD 3-clause license. # Project website: https://github.com/cztomczak/cefpython include "cefpython.pyx" cimport cef_types IF UNAME_SYSNAME == "Linux": cimport x11 # cef_mouse_button_type_t, SendMouseClickEvent(). MOUSEBUTTON_LEFT = cef_types.MBT_LEFT MOUSEBUTTON_MIDDLE = cef_types.MBT_MIDDLE MOUSEBUTTON_RIGHT = cef_types.MBT_RIGHT # If you try to keep PyBrowser() objects inside cpp_vector you will # get segmentation faults, as they will be garbage collected. cdef dict g_pyBrowsers = {} # See also g_browser_settings defined in cefpython.pyx # Unreferenced browsers are added to this list in OnBeforeClose(). # Must keep a list of unreferenced browsers so that a new reference # is not created in GetPyBrowser() when browser was closed. cdef list g_unreferenced_browsers = [] # [int identifier, ..] # Browsers that are about to be closed are added to this list in # CloseBrowser(). cdef list g_closed_browsers = [] # [int identifier, ..] cdef PyBrowser GetPyBrowserById(int browserId): """May return None value so always check returned value.""" if browserId in g_pyBrowsers: return g_pyBrowsers[browserId] return None cdef PyBrowser GetPyBrowser(CefRefPtr[CefBrowser] cefBrowser, callerIdStr="GetPyBrowser"): """The second argument 'callerIdStr' is so that a debug message can be displayed informing which CEF handler callback is being called to which an incomplete PyBrowser instance is provided.""" global g_pyBrowsers if cefBrowser == NULL or not cefBrowser.get(): raise Exception("{caller}: CefBrowser reference is NULL" .format(caller=callerIdStr)) cdef PyBrowser pyBrowser cdef int browserId browserId = cefBrowser.get().GetIdentifier() if browserId in g_pyBrowsers: return g_pyBrowsers[browserId] # This code probably ain't needed. # ---- cdef list toRemove = [] cdef int identifier for identifier, pyBrowser in g_pyBrowsers.items(): if not pyBrowser.cefBrowser.get(): toRemove.append(identifier) for identifier in toRemove: Debug("GetPyBrowser(): removing an empty CefBrowser reference," " browserId=%s" % identifier) RemovePyBrowser(identifier) # ---- pyBrowser = PyBrowser() pyBrowser.cefBrowser = cefBrowser cdef WindowHandle openerHandle cdef dict clientCallbacks cdef JavascriptBindings javascriptBindings cdef PyBrowser tempPyBrowser if browserId in g_unreferenced_browsers: # This browser was already unreferenced due to OnBeforeClose # was already called. An incomplete new instance of Browser # object is created. This instance doesn't have the client # callbacks, javascript bindings or user data that was already # available in the original Browser object. Debug("{caller}: Browser was already globally unreferenced" ", a new incomplete instance is created, browser id={id}" .format(caller=callerIdStr, id=str(browserId))) else: # This is first creation of browser. Store a reference globally # and inherit client callbacks and javascript bindings from # parent browsers. Debug("GetPyBrowser(): create new PyBrowser, browserId=%s" % browserId) g_pyBrowsers[browserId] = pyBrowser # Inherit client callbacks and javascript bindings # from parent browser. # - Checking __outerWindowHandle as we should not inherit # client callbacks and javascript bindings if the browser # was created explicitily by calling CreateBrowserSync(). # - Popups inherit client callbacks by default. # - Popups inherit javascript bindings only when "bindToPopups" # constructor param was set to True. if pyBrowser.IsPopup()\ and not pyBrowser.GetUserData("__outerWindowHandle"): openerHandle = pyBrowser.GetOpenerWindowHandle() for identifier, tempPyBrowser in g_pyBrowsers.items(): if tempPyBrowser.GetWindowHandle() == openerHandle: # tempPyBrowser is a parent browser if tempPyBrowser.GetSetting("inherit_client_handlers_for_popups"): if pyBrowser.GetIdentifier() not in g_browser_settings: g_browser_settings[pyBrowser.GetIdentifier()] = {} g_browser_settings[pyBrowser.GetIdentifier()]["inherit_client_handlers_for_popups"] =\ tempPyBrowser.GetSetting("inherit_client_handlers_for_popups") clientCallbacks = tempPyBrowser.GetClientCallbacksDict() if clientCallbacks: pyBrowser.SetClientCallbacksDict(clientCallbacks) javascriptBindings = tempPyBrowser.GetJavascriptBindings() if javascriptBindings: if javascriptBindings.GetBindToPopups(): pyBrowser.SetJavascriptBindings(javascriptBindings) return pyBrowser cdef void RemovePyBrowser(int browserId) except *: # Called from LifespanHandler_OnBeforeClose(). global g_pyBrowsers, g_unreferenced_browsers if browserId in g_pyBrowsers: # noinspection PyUnresolvedReferences Debug("del g_pyBrowsers[%s]" % browserId) del g_pyBrowsers[browserId] g_unreferenced_browsers.append(browserId) else: # noinspection PyUnresolvedReferences Debug("RemovePyBrowser() FAILED: browser not found, id = %s" \ % browserId) cpdef PyBrowser GetBrowserByWindowHandle(WindowHandle windowHandle): cdef PyBrowser pyBrowser for browserId in g_pyBrowsers: pyBrowser = g_pyBrowsers[browserId] if (pyBrowser.GetWindowHandle() == windowHandle or pyBrowser.GetUserData("__outerWindowHandle") == windowHandle): return pyBrowser return None cpdef PyBrowser GetBrowserByIdentifier(int identifier): cdef PyBrowser pyBrowser for browserId in g_pyBrowsers: pyBrowser = g_pyBrowsers[browserId] if pyBrowser.GetIdentifier() == identifier: return pyBrowser return None cdef public void PyBrowser_ShowDevTools(CefRefPtr[CefBrowser] cefBrowser ) except * with gil: # Called from ClientHandler::OnContextMenuCommand cdef PyBrowser pyBrowser try: pyBrowser = GetPyBrowser(cefBrowser, "ShowDevTools") pyBrowser.ShowDevTools() except: (exc_type, exc_value, exc_trace) = sys.exc_info() sys.excepthook(exc_type, exc_value, exc_trace) # ----------------------------------------------------------------------------- cdef class PyBrowser: cdef CefRefPtr[CefBrowser] cefBrowser cdef public dict clientCallbacks cdef public list allowedClientCallbacks cdef public JavascriptBindings javascriptBindings cdef public dict userData # Properties used by ToggleFullscreen(). cdef public int isFullscreen cdef public int maximized cdef public int gwlStyle cdef public int gwlExStyle cdef public tuple windowRect # C-level attributes are initialized to 0 automatically. cdef void* imageBuffer cdef CefRefPtr[CefBrowser] GetCefBrowser(self) except *: if self.cefBrowser != NULL and self.cefBrowser.get(): return self.cefBrowser raise Exception("PyBrowser.GetCefBrowser() failed: CefBrowser " "was destroyed") cdef CefRefPtr[CefBrowserHost] GetCefBrowserHost(self) except *: cdef CefRefPtr[CefBrowserHost] cefBrowserHost = ( self.GetCefBrowser().get().GetHost()) if cefBrowserHost != NULL and cefBrowserHost.get(): return cefBrowserHost raise Exception("PyBrowser.GetCefBrowserHost() failed: this " "method can only be called in the browser " "process.") def __init__(self): self.clientCallbacks = {} self.allowedClientCallbacks = [] self.userData = {} def __dealloc__(self): if self.imageBuffer: free(self.imageBuffer) cpdef py_void SetClientCallback(self, py_string name, object callback): if not self.allowedClientCallbacks: # DisplayHandler self.allowedClientCallbacks += [ "OnAddressChange", "OnTitleChange", "OnTooltip", "OnStatusMessage", "OnConsoleMessage"] # KeyboardHandler self.allowedClientCallbacks += ["OnPreKeyEvent", "OnKeyEvent"] # RequestHandler # NOTE: OnCertificateError and OnBeforePluginLoad are not # included as they must be set using # cefpython.SetGlobalClientCallback(). self.allowedClientCallbacks += ["OnBeforeResourceLoad", "OnResourceRedirect", "GetAuthCredentials", "OnQuotaRequest", "OnProtocolExecution", "GetResourceHandler", "OnBeforeBrowse", "OnRendererProcessTerminated", "OnPluginCrashed"] # RequestContextHandler self.allowedClientCallbacks += ["GetCookieManager"] # LoadHandler self.allowedClientCallbacks += ["OnLoadingStateChange", "OnLoadStart", "OnLoadEnd", "OnLoadError"] # LifespanHandler # NOTE: OnAfterCreated not included as it must be set using # cefpython.SetGlobalClientCallback(). self.allowedClientCallbacks += ["OnBeforePopup", "RunModal", "DoClose", "OnBeforeClose"] # RenderHandler self.allowedClientCallbacks += ["GetRootScreenRect", "GetViewRect", "GetScreenPoint", "GetScreenInfo", "GetScreenRect", "OnPopupShow", "OnPopupSize", "OnPaint", "OnCursorChange", "OnScrollOffsetChanged", "StartDragging", "UpdateDragCursor"] # JavascriptDialogHandler self.allowedClientCallbacks += ["OnJavascriptDialog", "OnBeforeUnloadJavascriptDialog", "OnResetJavascriptDialogState", "OnJavascriptDialogClosed"] # FocusHandler self.allowedClientCallbacks += ["OnTakeFocus", "OnSetFocus", "OnGotFocus"] if name not in self.allowedClientCallbacks: raise Exception("Browser.SetClientCallback() failed: unknown " "callback: %s" % name) self.clientCallbacks[name] = callback cpdef py_void SetClientHandler(self, object clientHandler): if not hasattr(clientHandler, "__class__"): raise Exception("Browser.SetClientHandler() failed: __class__ " "attribute missing") cdef dict methods = {} cdef py_string key cdef object method cdef tuple value for value in inspect.getmembers(clientHandler, predicate=inspect.ismethod): key = value[0] method = value[1] if key and key[0] != '_': self.SetClientCallback(key, method) cpdef object GetClientCallback(self, py_string name): if name in self.clientCallbacks: return self.clientCallbacks[name] cpdef py_void SetClientCallbacksDict(self, dict clientCallbacks): self.clientCallbacks = clientCallbacks cpdef dict GetClientCallbacksDict(self): return self.clientCallbacks cpdef py_void SetJavascriptBindings(self, JavascriptBindings bindings): self.javascriptBindings = bindings self.javascriptBindings.Rebind() cpdef JavascriptBindings GetJavascriptBindings(self): return self.javascriptBindings cpdef object GetSetting(self, py_string key): cdef int browser_id = self.GetIdentifier() if browser_id in g_browser_settings: if key in g_browser_settings[browser_id]: return g_browser_settings[browser_id][key] return None # -------------- # CEF API. # -------------- cpdef py_void AddWordToDictionary(self, py_string word): cdef CefString cef_word PyToCefString(word, cef_word) self.GetCefBrowserHost().get().AddWordToDictionary(cef_word) cpdef py_bool CanGoBack(self): return self.GetCefBrowser().get().CanGoBack() cpdef py_bool CanGoForward(self): return self.GetCefBrowser().get().CanGoForward() cpdef py_void ParentWindowWillClose(self): # Method removed in upstream CEF, keeping for BC pass cpdef py_void CloseBrowser(self, py_bool forceClose=False): Debug("CefBrowser::CloseBrowser(%s)" % forceClose) cdef int browserId = self.GetCefBrowser().get().GetIdentifier() self.GetCefBrowserHost().get().CloseBrowser(bool(forceClose)) global g_closed_browsers g_closed_browsers.append(browserId) cpdef py_void CloseDevTools(self): self.GetCefBrowserHost().get().CloseDevTools() def ExecuteFunction(self, *args): self.GetMainFrame().ExecuteFunction(*args) cpdef py_void ExecuteJavascript(self, py_string jsCode, py_string scriptUrl="", int startLine=1): self.GetMainFrame().ExecuteJavascript(jsCode, scriptUrl, startLine) cpdef py_void Find(self, int searchId, py_string searchText, py_bool forward, py_bool matchCase, py_bool findNext): cdef CefString cefSearchText PyToCefString(searchText, cefSearchText) self.GetCefBrowserHost().get().Find(searchId, cefSearchText, bool(forward), bool(matchCase), bool(findNext)) cpdef PyFrame GetFocusedFrame(self): assert IsThread(TID_UI), ( "Browser.GetFocusedFrame() may only be called on UI thread") return GetPyFrame(self.GetCefBrowser().get().GetFocusedFrame()) cpdef PyFrame GetFrame(self, py_string name): assert IsThread(TID_UI), ( "Browser.GetFrame() may only be called on the UI thread") cdef CefString cefName PyToCefString(name, cefName) return GetPyFrame(self.GetCefBrowser().get().GetFrame(cefName)) cpdef object GetFrameByIdentifier(self, object identifier): return GetPyFrame(self.GetCefBrowser().get().GetFrame( identifier)) cpdef list GetFrameNames(self): assert IsThread(TID_UI), ( "Browser.GetFrameNames() may only be called on the UI thread") cdef cpp_vector[CefString] cefNames self.GetCefBrowser().get().GetFrameNames(cefNames) cdef list names = [] cdef cpp_vector[CefString].iterator iterator = cefNames.begin() cdef CefString cefString while iterator != cefNames.end(): cefString = deref(iterator) names.append(CefToPyString(cefString)) preinc(iterator) return names cpdef list GetFrames(self): cdef list names = self.GetFrameNames() cdef PyFrame frame cdef list frames = [] for name in names: frame = self.GetFrame(name) frames.append(frame) return frames cpdef int GetIdentifier(self) except *: return self.GetCefBrowser().get().GetIdentifier() cpdef PyFrame GetMainFrame(self): return GetPyFrame(self.GetCefBrowser().get().GetMainFrame()) cpdef WindowHandle GetOpenerWindowHandle(self) except *: cdef WindowHandle hwnd hwnd = \ self.GetCefBrowserHost().get().GetOpenerWindowHandle() return hwnd cpdef WindowHandle GetOuterWindowHandle(self) except *: if self.GetUserData("__outerWindowHandle"): return self.GetUserData("__outerWindowHandle") else: return self.GetWindowHandle() cpdef py_string GetUrl(self): return self.GetMainFrame().GetUrl() cpdef object GetUserData(self, object key): if key in self.userData: return self.userData[key] return None cpdef WindowHandle GetWindowHandle(self) except *: cdef WindowHandle hwnd hwnd = self.GetCefBrowserHost().get().GetWindowHandle() return hwnd cpdef double GetZoomLevel(self) except *: cdef double zoomLevel zoomLevel = self.GetCefBrowserHost().get().GetZoomLevel() return zoomLevel cpdef py_void GoBack(self): self.GetCefBrowser().get().GoBack() cpdef py_void GoForward(self): self.GetCefBrowser().get().GoForward() cpdef py_bool HasDocument(self): return self.GetCefBrowser().get().HasDocument() cpdef py_bool IsFullscreen(self): return bool(self.isFullscreen) cpdef py_bool IsPopup(self): return self.GetCefBrowser().get().IsPopup() cpdef py_bool IsWindowRenderingDisabled(self): return self.GetCefBrowserHost().get().IsWindowRenderingDisabled() cpdef py_string LoadUrl(self, py_string url): self.GetMainFrame().LoadUrl(url) cpdef py_void Navigate(self, py_string url): self.LoadUrl(url) cpdef py_void NotifyMoveOrResizeStarted(self): self.GetCefBrowserHost().get().NotifyMoveOrResizeStarted() cpdef py_void Print(self): self.GetCefBrowserHost().get().Print() cpdef py_void Reload(self): self.GetCefBrowser().get().Reload() cpdef py_void ReloadIgnoreCache(self): self.GetCefBrowser().get().ReloadIgnoreCache() cpdef py_void ReplaceMisspelling(self, py_string word): cdef CefString cef_word PyToCefString(word, cef_word) self.GetCefBrowserHost().get().ReplaceMisspelling(cef_word) cpdef py_void SetBounds(self, int x, int y, int width, int height): IF UNAME_SYSNAME == "Linux": x11.SetX11WindowBounds(self.GetCefBrowser(), x, y, width, height) ELSE: NonCriticalError("SetBounds() not implemented on this platform") cpdef py_void SetFocus(self, enable): self.GetCefBrowserHost().get().SetFocus(bool(enable)) cpdef py_void SetUserData(self, object key, object value): self.userData[key] = value cpdef py_void SetZoomLevel(self, double zoomLevel): self.GetCefBrowserHost().get().SetZoomLevel(zoomLevel) cpdef py_void ShowDevTools(self): cdef CefWindowInfo window_info IF UNAME_SYSNAME == "Windows": # On Windows with empty window_info structure the devtools # window doesn't appear. window_info.SetAsPopup( self.GetWindowHandle(), PyToCefStringValue("DevTools")) cdef CefBrowserSettings settings cdef CefPoint inspect_element_at self.GetCefBrowserHost().get().ShowDevTools( window_info, new DevToolsClientHandler(), settings, inspect_element_at) cpdef py_void StopLoad(self): self.GetCefBrowser().get().StopLoad() cpdef py_void StopFinding(self, py_bool clearSelection): self.GetCefBrowserHost().get().StopFinding(bool(clearSelection)) cpdef py_void ToggleFullscreen(self): IF UNAME_SYSNAME == "Windows": self.ToggleFullscreen_Windows() IF UNAME_SYSNAME == "Windows": cpdef py_void ToggleFullscreen_Windows(self): cdef WindowHandle windowHandle if self.GetUserData("__outerWindowHandle"): windowHandle = \ self.GetUserData("__outerWindowHandle") else: windowHandle = self.GetWindowHandle() # Offscreen browser will have an empty window handle. assert windowHandle, ( "Browser.ToggleFullscreen() failed: no window handle " "found") cdef HWND hwnd = windowHandle cdef RECT rect cdef HMONITOR monitor cdef MONITORINFO monitorInfo monitorInfo.cbSize = sizeof(monitorInfo) # Logic copied from chromium > fullscreen_handler.cc > # FullscreenHandler::SetFullscreenImpl: # http://src.chromium.org/viewvc/chrome/trunk/src/ui/views/win/ # fullscreen_handler.cc cdef py_bool for_metro = False if not self.isFullscreen: self.maximized = IsZoomed(hwnd) if self.maximized: SendMessage(hwnd, WM_SYSCOMMAND, SC_RESTORE, 0) self.gwlStyle = GetWindowLong(hwnd, GWL_STYLE) self.gwlExStyle = GetWindowLong(hwnd, GWL_EXSTYLE) GetWindowRect(hwnd, &rect) self.windowRect = (rect.left, rect.top, rect.right, rect.bottom) cdef int removeStyle, removeExStyle cdef int left, top, right, bottom if not self.isFullscreen: removeStyle = WS_CAPTION | WS_THICKFRAME removeExStyle = (WS_EX_DLGMODALFRAME | WS_EX_WINDOWEDGE | WS_EX_CLIENTEDGE | WS_EX_STATICEDGE) SetWindowLong(hwnd, GWL_STYLE, self.gwlStyle & ~removeStyle) SetWindowLong(hwnd, GWL_EXSTYLE, self.gwlExStyle & ~removeExStyle) if not for_metro: # MONITOR_DEFAULTTONULL, MONITOR_DEFAULTTOPRIMARY, # MONITOR_DEFAULTTONEAREST monitor = MonitorFromWindow(hwnd, MONITOR_DEFAULTTONEAREST) GetMonitorInfo(monitor, &monitorInfo) left = monitorInfo.rcMonitor.left top = monitorInfo.rcMonitor.top right = monitorInfo.rcMonitor.right bottom = monitorInfo.rcMonitor.bottom # noinspection PyUnresolvedReferences SetWindowPos(hwnd, NULL, left, top, right-left, bottom-top, SWP_NOZORDER | SWP_NOACTIVATE | SWP_FRAMECHANGED) else: SetWindowLong(hwnd, GWL_STYLE, int(self.gwlStyle)) SetWindowLong(hwnd, GWL_EXSTYLE, int(self.gwlExStyle)) if not for_metro: (left, top, right, bottom) = self.windowRect # noinspection PyUnresolvedReferences SetWindowPos(hwnd, NULL, int(left), int(top), int(right-left), int(bottom-top), SWP_NOZORDER | SWP_NOACTIVATE | SWP_FRAMECHANGED) if self.maximized: SendMessage(hwnd, WM_SYSCOMMAND, SC_MAXIMIZE, 0) self.isFullscreen = int(not bool(self.isFullscreen)) cpdef py_void SendKeyEvent(self, dict pyEvent): cdef CefKeyEvent cefEvent if "type" in pyEvent: cefEvent.type = int(pyEvent["type"]) if "modifiers" in pyEvent: cefEvent.modifiers = pyEvent["modifiers"] # Always set CefKeyEvent.windows_key_code in SendKeyEvent, even on # Linux. When sending key event for 'backspace' on Linux and setting # "native_key_code", "character", "unmodified_character" it doesn't # work. It starts working after "windows_key_code" is also sent. if "windows_key_code" in pyEvent: cefEvent.windows_key_code = int(pyEvent["windows_key_code"]) if "native_key_code" in pyEvent: cefEvent.native_key_code = int(pyEvent["native_key_code"]) if "is_system_key" in pyEvent: cefEvent.is_system_key = int(bool(pyEvent["is_system_key"])) if "character" in pyEvent: cefEvent.character = int(pyEvent["character"]) if "unmodified_character" in pyEvent: cefEvent.unmodified_character = \ int(pyEvent["unmodified_character"]) if "focus_on_editable_field" in pyEvent: cefEvent.focus_on_editable_field = \ int(bool(pyEvent["focus_on_editable_field"])) self.GetCefBrowserHost().get().SendKeyEvent(cefEvent) cpdef py_void SendMouseClickEvent(self, int x, int y, cef_types.cef_mouse_button_type_t mouseButtonType, py_bool mouseUp, int clickCount, int modifiers=0): cdef CefMouseEvent mouseEvent mouseEvent.x = x mouseEvent.y = y mouseEvent.modifiers = modifiers self.GetCefBrowserHost().get().SendMouseClickEvent(mouseEvent, mouseButtonType, bool(mouseUp), clickCount) cpdef py_void SendMouseMoveEvent(self, int x, int y, py_bool mouseLeave, int modifiers=0): cdef CefMouseEvent mouseEvent mouseEvent.x = x mouseEvent.y = y mouseEvent.modifiers = modifiers self.GetCefBrowserHost().get().SendMouseMoveEvent(mouseEvent, bool(mouseLeave)) cpdef py_void SendMouseWheelEvent(self, int x, int y, int deltaX, int deltaY, int modifiers=0): cdef CefMouseEvent mouseEvent mouseEvent.x = x mouseEvent.y = y mouseEvent.modifiers = modifiers self.GetCefBrowserHost().get().SendMouseWheelEvent(mouseEvent, deltaX, deltaY) cpdef py_void SendFocusEvent(self, py_bool setFocus): self.GetCefBrowserHost().get().SendFocusEvent(bool(setFocus)) cpdef py_void SendCaptureLostEvent(self): self.GetCefBrowserHost().get().SendCaptureLostEvent() cpdef py_void StartDownload(self, py_string url): self.GetCefBrowserHost().get().StartDownload(PyToCefStringValue( url)) cpdef py_void SetMouseCursorChangeDisabled(self, py_bool disabled): self.GetCefBrowserHost().get().SetMouseCursorChangeDisabled( bool(disabled)) cpdef py_bool IsMouseCursorChangeDisabled(self): return self.GetCefBrowserHost().get().IsMouseCursorChangeDisabled() cpdef py_bool TryCloseBrowser(self): """For forward compatibility.""" self.CloseBrowser() return True cpdef py_void WasResized(self): self.GetCefBrowserHost().get().WasResized() cpdef py_void WasHidden(self, py_bool hidden): self.GetCefBrowserHost().get().WasHidden(bool(hidden)) cpdef py_void NotifyScreenInfoChanged(self): self.GetCefBrowserHost().get().NotifyScreenInfoChanged() cdef void SendProcessMessage(self, cef_process_id_t targetProcess, object frameId, py_string messageName, list pyArguments ) except *: cdef CefRefPtr[CefProcessMessage] message = \ CefProcessMessage_Create(PyToCefStringValue(messageName)) # This does not work, no idea why, the CEF implementation # seems not to allow it, both Assign() and swap() do not work: # | message.get().GetArgumentList().Assign(arguments.get()) # | message.get().GetArgumentList().swap(arguments) cdef CefRefPtr[CefListValue] messageArguments = \ message.get().GetArgumentList() PyListToExistingCefListValue(self.GetIdentifier(), frameId, pyArguments, messageArguments) Debug("SendProcessMessage(): message=%s, arguments size=%d" % ( messageName, message.get().GetArgumentList().get().GetSize())) cdef cpp_bool success = \ self.GetCefBrowser().get().SendProcessMessage( targetProcess, message) if not success: raise Exception("Browser.SendProcessMessage() failed: "\ "messageName=%s" % messageName) # ------------------------------------------------------------------------- # OSR drag & drop # ------------------------------------------------------------------------- cpdef py_void DragTargetDragEnter(self, DragData drag_data, int x, int y, uint32 allowed_ops): cdef CefMouseEvent mouse_event mouse_event.x = x mouse_event.y = y self.GetCefBrowserHost().get().DragTargetDragEnter( drag_data.cef_drag_data, mouse_event, allowed_ops) cpdef py_void DragTargetDragOver(self, int x, int y, uint32 allowed_ops): cdef CefMouseEvent mouse_event mouse_event.x = x mouse_event.y = y self.GetCefBrowserHost().get().DragTargetDragOver( mouse_event, allowed_ops) cpdef py_void DragTargetDragLeave(self): self.GetCefBrowserHost().get().DragTargetDragLeave() cpdef py_void DragTargetDrop(self, int x, int y): cdef CefMouseEvent mouse_event mouse_event.x = x mouse_event.y = y self.GetCefBrowserHost().get().DragTargetDrop(mouse_event) cpdef py_void DragSourceEndedAt(self, int x, int y, uint32 operation): self.GetCefBrowserHost().get().DragSourceEndedAt( x, y, operation) cpdef py_void DragSourceSystemDragEnded(self): self.GetCefBrowserHost().get().DragSourceSystemDragEnded() cefpython-49.0/src/callback.pyx000066400000000000000000000011451334103266300165340ustar00rootroot00000000000000# Copyright (c) 2013 CEF Python, see the Authors file. # All rights reserved. Licensed under BSD 3-clause license. # Project website: https://github.com/cztomczak/cefpython include "cefpython.pyx" cdef PyCallback CreatePyCallback( CefRefPtr[CefCallback] cefCallback): cdef PyCallback pyCallback = PyCallback() pyCallback.cefCallback = cefCallback return pyCallback cdef class PyCallback: cdef CefRefPtr[CefCallback] cefCallback cpdef py_void Continue(self): self.cefCallback.get().Continue() cpdef py_void Cancel(self): self.cefCallback.get().Cancel() cefpython-49.0/src/cefpython.pyx000066400000000000000000001210011334103266300167710ustar00rootroot00000000000000# Copyright (c) 2012 CEF Python, see the Authors file. # All rights reserved. Licensed under BSD 3-clause license. # Project website: https://github.com/cztomczak/cefpython """ CHANGES in CEF since v31..v51. Below are listed new or modified functions/classes, but not all of them. ------------------------------------------------------------------------------- CefEnableHighDPISupport() CefRequestContext NEW BROWSER SETTINGS that can be get/set using request context: * GetAllPreferences - all preferences for browser's request context * SetPreference * many more methods has/get/canset... _cef_request_context_settings_t: cache_path persist_session_cookies persist_user_preferences ignore_certificate_errors PurgePluginListCache GetDefaultCookieManager GetCachePath IsSharingWith - possible to create new context that shares storage with another context more methods... CefRequestContextHandler OnBeforePluginLoad CefBrowserSettings windowless_frame_rate - **OSR** CefBrowserHost GetNavigationEntries PrintToPDF ParentWindowWillClose() - REMOVED, update .py examples SetWindowVisibility() ShowDevTools(WindowInfo, CefClient, BrowserSettings, inspect_element_at) CloseDevTools [DONE] ReplaceMisspelling AddWordToDictionary Invalidate NotifyMoveOrResizeStarted() - call in WM_MOVE, WM_MOVING, WM_SIZING on Win GetWindowlessFrameRate - **OSR** SetWindowlessFrameRate - **OSR** DragTargetDragEnter DragTargetDragOver DragTargetDragLeave DragTargetDrop DragSourceEndedAt DragSourceSystemDragEnded HasDevTools DownloadImage HasView CefRequestHandler OnOpenURLFromTab OnBeforeResourceLoad - new arg CefRequestCallback OnResourceResponse GetResourceResponseFilter - easy way to alter response, no need for the complicated wxpython-response.py example (Issue #229) OnResourceLoadComplete OnCertificateError - new args: browser and ssl_info. No more need to set it using cefpython.SetGlobalClientCallback() OnRenderViewReady Support for handling onbeforeunload in LifespanHandler::DoClose with the use of Browser.TryCloseBrowser() or Browser.CloseBrowser. CefRequest SetReferrer GetReferrerURL GetReferrerPolicy GetIdentifier CefResponse GetError SetError CEF exposes Views/Aura framework as an alternative API for client applications. This can be a replacement for WinAPI/GTK/X11/Cocoa UI frameworks. See for more info: https://bitbucket.org/chromiumembedded/cef/issues/1749 CefPrintHandler - Linux only CefPrintSettings CefDisplayHandler OnFaviconURLChange OnFullscreenModeChange CefRenderHandler OnCursorChange - new args: type and custom_cursor_info StartDragging UpdateDragCursor OnScrollOffsetChanged - new args: x,y In upstream cefclient: 1. g_signal_connect(G_OBJECT(window_), "configure-event", G_CALLBACK(&RootWindowGtk::WindowConfigure), this); browser->GetHost()->NotifyMoveOrResizeStarted(); 2. g_signal_connect(G_OBJECT(window_), "focus-in-event", G_CALLBACK(&RootWindowGtk::WindowFocusIn), this); self->browser_window_->SetFocus(true); When window is minimized set browser size to 0x0 to reduce resource usage. See cefclient: - on Windows see https://github.com/cztomczak/phpdesktop/issues/179 - on Linux see root_window_gtk.cc > WindowState CefContextMenuHandler RunContextMenu CefContextMenuParams GetMisspelledWord GetDictionarySuggestions IsSpellCheckEnabled IsCustomMenu IsPepperMenu CefCompletionCallback - added to many cookie functions to run asynchronously on the IO thread include/cef_parser.h - url/css/json/etc parsers CefResourceBundle CefResponseFilter CefValue cef_get_current_platform_thread_id() cef_get_current_platform_thread_handle() cef_get_xdisplay(); include/cef_ssl_info.h include/wrapper/cef_helpers.h - CefDeleteOnThread() free object on the specified thread include/wrapper/cef_resource_manager.h CefPostData HasExcludedElements ------------------------------------------------------------------------------- END OF: CHANGES in CEF since v31..v47. """ # IMPORTANT notes: # # - cdef/cpdef functions returning something other than a Python object # should have in its declaration "except *", otherwise exceptions are # ignored. Those cdef/cpdef that return "object" have "except *" by # default. The setup/compile.py script will check for functions missing # "except *" and will display an error message about that, but it's # not perfect and won't detect all cases. # # - TODO: add checking for "except * with gil" in functions with the # "public" keyword # # - about acquiring/releasing GIL lock, see discussion here: # https://groups.google.com/forum/?fromgroups=#!topic/cython-users/jcvjpSOZPp0 # # - new ClientHandler() # <...?> means to throw an error if the cast is not allowed # # - in client handler callbacks (or others that are called from C++ and # use "except * with gil") must embrace all code in try..except otherwise # the error will be ignored, only printed to the output console, this is the # default behavior of Cython, to remedy this you are supposed to add "except *" # in function declaration, unfortunately it does not work, some conflict with # CEF threading, see topic at cython-users for more details: # https://groups.google.com/d/msg/cython-users/CRxWoX57dnM/aufW3gXMhOUJ. # # - Note that acquiring the GIL is a blocking thread-synchronising operation, # and therefore potentially costly. It might not be worth releasing the GIL # for minor calculations. Usually, I/O operations and substantial # computations in parallel code will benefit from it. # # - In regards to GIL locks see Issue #102 "Remove GIL to avoid deadlocks when # calling CEF functions". # # - CTags requires all functions/methods imported in .pxd files to be preceded with "cdef", # otherwise they are not indexed. # # - __del__ method does not exist in Extension Types (cdef class), # you have to use __dealloc__ instead, try to remember that as # defining __del__ will not raise any warning and could lead to # memory leaks. # # - CefString.c_str() is safe to use only on Windows, on Ubuntu 64bit # for a "Pers" string it returns: "P\x00e\x00r\x00s\x00", which is # most probably not what you expected. # # - You can rename methods when importing in pxd files: # | cdef cppclass _Object "Object": # # - Supporting operators that are not yet supported: # | RetValue& Assign "operator="(T* p) # | object.Assign(T*) # In the same way you can import function with a different name, this one # imports a static method Create() while adding a prefix "CefSome_": # | cdef extern from "..": # | static CefRefPtr[CefSome] CefSome_Create "CefSome::Create"() # # - Declaring C++ classes in Cython. Storing python callbacks # in a C++ class using Py_INCREF, Py_DECREF. Calling from # C++ using PyObject_CallMethod. # | http://stackoverflow.com/a/17070382/623622 # Disadvantage: when calling python callback from the C++ class # declared in Cython there is no easy way to propagate the python # exceptions when they occur during execution of the callback. # # - | cdef char* other_c_string = py_string # This is a very fast operation after which other_c_string points # to the byte string buffer of the Python string itself. It is # tied to the life time of the Python string. When the Python # string is garbage collected, the pointer becomes invalid. # # - When defining cpdef functions returning "cpp_bool": # | cpdef cpp_bool myfunc() except *: # Always do an additional cast when returning value, even when # variable is defined as py_bool: # | cdef py_bool returnValue # | return bool(returnValue) # Otherwise compiler warnings appear: # | cefpython.cpp(26533) : warning C4800: 'int' : forcing value # | to bool 'true' or 'false' (performance warning) # Lots of these warnings results in ignoring them, but sometimes # they are shown for a good reason. For example when you forget # to return a value in a function. # # - Always import bool from libcpp as cpp_bool, if you import it as # "bool" in a pxd file, then Cython will complain about bool casts # like "bool(1)" being invalid, in pyx files. # # - malloc example code: # from libc.stdlib cimport malloc, free # cdef RECT* rect = malloc(sizeof(RECT)) # free(rect) # # All .pyx files need to be included in this file. # Includes being made in other .pyx files are allowed to help # IDE completion, but will be removed during cython compilation. include "compile_time_constants.pxi" # ----------------------------------------------------------------------------- # IMPORTS # noinspection PyUnresolvedReferences import os import sys # noinspection PyUnresolvedReferences import cython # noinspection PyUnresolvedReferences import platform # noinspection PyUnresolvedReferences import traceback # noinspection PyUnresolvedReferences import time # noinspection PyUnresolvedReferences import types # noinspection PyUnresolvedReferences import re # noinspection PyUnresolvedReferences import copy # noinspection PyUnresolvedReferences import inspect # used by JavascriptBindings.__SetObjectMethods() # noinspection PyUnresolvedReferences import urllib # noinspection PyUnresolvedReferences import json # noinspection PyUnresolvedReferences import datetime # noinspection PyUnresolvedReferences import random # noinspection PyUnresolvedReferences import base64 if sys.version_info.major == 2: # noinspection PyUnresolvedReferences import urlparse else: # noinspection PyUnresolvedReferences, PyProtectedMember from urllib import parse as urlparse if sys.version_info.major == 2: # noinspection PyUnresolvedReferences from urllib import pathname2url as urllib_pathname2url else: # noinspection PyUnresolvedReferences from urllib.request import pathname2url as urllib_pathname2url # noinspection PyUnresolvedReferences from cpython.version cimport PY_MAJOR_VERSION # noinspection PyUnresolvedReferences import weakref # We should allow multiple string types: str, unicode, bytes. # PyToCefString() can handle them all. # Important: # If you set it to basestring, Cython will accept exactly(!) # str/unicode in Py2 and str in Py3. This won't work in Py3 # as we might want to pass bytes as well. Also it will # reject string subtypes, so using it in publi API functions # would be a bad idea. ctypedef object py_string # You can't use "void" along with cpdef function returning None, it is # planned to be added to Cython in the future, creating this virtual # type temporarily. If you change it later to "void" then don't forget # to add "except *". ctypedef object py_void # noinspection PyUnresolvedReferences from cpython cimport PyLong_FromVoidPtr # noinspection PyUnresolvedReferences from cpython cimport bool as py_bool # noinspection PyUnresolvedReferences from libcpp cimport bool as cpp_bool # noinspection PyUnresolvedReferences from libcpp.map cimport map as cpp_map # noinspection PyUnresolvedReferences from multimap cimport multimap as cpp_multimap # noinspection PyUnresolvedReferences from libcpp.pair cimport pair as cpp_pair # noinspection PyUnresolvedReferences from libcpp.vector cimport vector as cpp_vector # noinspection PyUnresolvedReferences from libcpp.string cimport string as cpp_string # noinspection PyUnresolvedReferences from wstring cimport wstring as cpp_wstring # noinspection PyUnresolvedReferences from libc.string cimport strlen # noinspection PyUnresolvedReferences from libc.string cimport memcpy # preincrement and dereference must be "as" otherwise not seen. # noinspection PyUnresolvedReferences from cython.operator cimport preincrement as preinc, dereference as deref # noinspection PyUnresolvedReferences # from cython.operator cimport address as addr # Address of an c++ object? # noinspection PyUnresolvedReferences from libc.stdlib cimport calloc, malloc, free # noinspection PyUnresolvedReferences from libc.stdlib cimport atoi # When pyx file cimports * from a pxd file and that pxd cimports * from another pxd # then these names will be visible in pyx file. # Circular imports are allowed in form "cimport ...", but won't work if you do # "from ... cimport *", this is important to know in pxd files. # noinspection PyUnresolvedReferences from libc.stdint cimport uint64_t # noinspection PyUnresolvedReferences from libc.stdint cimport uintptr_t # noinspection PyUnresolvedReferences ctypedef uintptr_t WindowHandle # noinspection PyUnresolvedReferences cimport ctime IF UNAME_SYSNAME == "Windows": from windows cimport * from dpi_aware_win cimport * ELIF UNAME_SYSNAME == "Linux": from linux cimport * ELIF UNAME_SYSNAME == "Darwin": from mac cimport * from cpp_utils cimport * from task cimport * IF UNAME_SYSNAME == "Linux": # noinspection PyUnresolvedReferences cimport x11 from cef_string cimport * cdef extern from *: # noinspection PyUnresolvedReferences ctypedef CefString ConstCefString "const CefString" # cannot cimport *, that would cause name conflicts with constants # noinspection PyUnresolvedReferences from cef_types cimport ( CefSettings, CefBrowserSettings, CefRect, CefSize, CefPoint, CefKeyEvent, CefMouseEvent, CefScreenInfo, PathKey, PK_DIR_EXE, PK_DIR_MODULE, int32, uint32, int64, uint64, ) # noinspection PyUnresolvedReferences from cef_ptr cimport CefRefPtr # noinspection PyUnresolvedReferences from cef_scoped_ptr cimport scoped_ptr from cef_task cimport * from cef_platform cimport * from cef_app cimport * from cef_browser cimport * # noinspection PyUnresolvedReferences cimport cef_browser_static from cef_client cimport * from client_handler cimport * from cef_frame cimport * from cef_time cimport * from cef_values cimport * from cefpython_app cimport * from cef_process_message cimport * from cef_web_plugin cimport * from cef_request_handler cimport * from cef_request cimport * from cef_cookie cimport * from cef_string_visitor cimport * # noinspection PyUnresolvedReferences cimport cef_cookie_manager_namespace from cookie_visitor cimport * from string_visitor cimport * from cef_callback cimport * from cef_response cimport * from cef_resource_handler cimport * from resource_handler cimport * from cef_urlrequest cimport * from web_request_client cimport * from cef_command_line cimport * from cef_request_context cimport * from cef_request_context_handler cimport * from request_context_handler cimport * from cef_jsdialog_handler cimport * from cef_path_util cimport * from cef_drag_data cimport * # noinspection PyUnresolvedReferences from cef_views cimport * from cef_log cimport * # ----------------------------------------------------------------------------- # GLOBAL VARIABLES g_debug = False # When put None here and assigned a local dictionary in Initialize(), later # while running app this global variable was garbage collected, see topic: # https://groups.google.com/d/topic/cython-users/0dw3UASh7HY/discussion # The string_encoding key must be set early here and also in Initialize. g_applicationSettings = {"string_encoding": "utf-8"} g_commandLineSwitches = {} g_browser_settings = {} # If ApplicationSettings.unique_request_context_per_browser is False # then a shared request context is used for all browsers. Otherwise # a unique one is created for each call to CreateBrowserSync. # noinspection PyUnresolvedReferences cdef CefRefPtr[CefRequestContext] g_shared_request_context cdef py_bool g_MessageLoop_called = False cdef py_bool g_MessageLoopWork_called = False cdef py_bool g_cef_initialized = False cdef dict g_globalClientCallbacks = {} # ----------------------------------------------------------------------------- include "utils.pyx" include "string_utils.pyx" IF UNAME_SYSNAME == "Windows": include "string_utils_win.pyx" include "time_utils.pyx" include "browser.pyx" include "frame.pyx" include "settings.pyx" IF UNAME_SYSNAME == "Windows": include "window_utils_win.pyx" include "dpi_aware_win.pyx" ELIF UNAME_SYSNAME == "Linux": include "window_utils_linux.pyx" ELIF UNAME_SYSNAME == "Darwin": include "window_utils_mac.pyx" include "task.pyx" include "javascript_bindings.pyx" include "virtual_keys.pyx" include "window_info.pyx" include "process_message_utils.pyx" include "javascript_callback.pyx" include "python_callback.pyx" include "web_plugin_info.pyx" include "request.pyx" include "cookie.pyx" include "string_visitor.pyx" include "network_error.pyx" include "paint_buffer.pyx" include "callback.pyx" include "response.pyx" include "web_request.pyx" include "command_line.pyx" include "app.pyx" include "drag_data.pyx" include "helpers.pyx" # Handlers include "handlers/browser_process_handler.pyx" include "handlers/display_handler.pyx" include "handlers/focus_handler.pyx" include "handlers/javascript_dialog_handler.pyx" include "handlers/keyboard_handler.pyx" include "handlers/lifespan_handler.pyx" include "handlers/load_handler.pyx" include "handlers/render_handler.pyx" include "handlers/resource_handler.pyx" include "handlers/request_handler.pyx" include "handlers/v8context_handler.pyx" include "handlers/v8function_handler.pyx" # ----------------------------------------------------------------------------- # Utility functions to provide settings to the C++ browser process code. cdef public void cefpython_GetDebugOptions( cpp_bool* debug ) except * with gil: # Called from subprocess/cefpython_app.cpp -> CefPythonApp constructor. try: debug[0] = bool(g_debug) except: (exc_type, exc_value, exc_trace) = sys.exc_info() sys.excepthook(exc_type, exc_value, exc_trace) cdef public cpp_bool ApplicationSettings_GetBool(const char* key ) except * with gil: # Called from client_handler/client_handler.cpp for example cdef py_string pyKey = CharToPyString(key) if pyKey in g_applicationSettings: return bool(g_applicationSettings[pyKey]) return False cdef public cpp_bool ApplicationSettings_GetBoolFromDict(const char* key1, const char* key2) except * with gil: cdef py_string pyKey1 = CharToPyString(key1) cdef py_string pyKey2 = CharToPyString(key2) cdef object dictValue # Yet to be checked whether it is `dict` if pyKey1 in g_applicationSettings: dictValue = g_applicationSettings[pyKey1] if type(dictValue) != dict: return False if pyKey2 in dictValue: return bool(dictValue[pyKey2]) return False cdef public cpp_string ApplicationSettings_GetString(const char* key ) except * with gil: cdef py_string pyKey = CharToPyString(key) cdef cpp_string cppString if pyKey in g_applicationSettings: cppString = PyStringToChar(AnyToPyString(g_applicationSettings[pyKey])) return cppString cdef public int CommandLineSwitches_GetInt(const char* key) except * with gil: cdef py_string pyKey = CharToPyString(key) if pyKey in g_commandLineSwitches: return int(g_commandLineSwitches[pyKey]) return 0 # ----------------------------------------------------------------------------- # If you've built custom binaries with tcmalloc hook enabled on # Linux, then do not to run any of the CEF code until Initialize() # is called. See Issue #73 in the CEF Python Issue Tracker. def Initialize(applicationSettings=None, commandLineSwitches=None, **kwargs): # applicationSettings and commandLineSwitches argument # names are kept for backward compatibility. application_settings = applicationSettings command_line_switches = commandLineSwitches # Alternative names for existing parameters if "settings" in kwargs: assert not applicationSettings, "Bad arguments" application_settings = kwargs["settings"] del kwargs["settings"] if "switches" in kwargs: assert not command_line_switches, "Bad arguments" command_line_switches = kwargs["switches"] del kwargs["switches"] for kwarg in kwargs: raise Exception("Invalid argument: "+kwarg) if command_line_switches: # Make a copy as commandLineSwitches is a reference only # that might get destroyed later. global g_commandLineSwitches for key in command_line_switches: g_commandLineSwitches[key] = copy.deepcopy( command_line_switches[key]) # Use g_commandLineSwitches if you need to modify or access # command line switches inside this function. del command_line_switches del commandLineSwitches IF UNAME_SYSNAME == "Linux": # Fix Issue #231 - Discovery of the "icudtl.dat" file fails on Linux. cdef str py_module_dir = GetModuleDirectory() cdef CefString cef_module_dir PyToCefString(py_module_dir, cef_module_dir) CefOverridePath(PK_DIR_EXE, cef_module_dir)\ or Debug("ERROR: CefOverridePath failed") CefOverridePath(PK_DIR_MODULE, cef_module_dir)\ or Debug("ERROR: CefOverridePath failed") # END IF UNAME_SYSNAME == "Linux": if not application_settings: application_settings = {} # Debug settings need to be set before Debug() is called # and before the CefPythonApp class is instantiated. global g_debug if "--debug" in sys.argv: application_settings["debug"] = True application_settings["log_file"] = os.path.join(os.getcwd(), "debug.log") application_settings["log_severity"] = LOGSEVERITY_INFO sys.argv.remove("--debug") if "debug" in application_settings: g_debug = bool(application_settings["debug"]) if "log_severity" in application_settings: if application_settings["log_severity"] <= LOGSEVERITY_INFO: g_debug = True Debug("Initialize() called") # Mac initialization. Need to call NSApplication.sharedApplication() # and do NSApplication methods swizzling to implement # CrAppControlProtocol. See Issue 156. IF UNAME_SYSNAME == "Darwin": MacInitialize() # ------------------------------------------------------------------------ # CEF Python only options # ------------------------------------------------------------------------ if "debug" not in application_settings: application_settings["debug"] = False if "log_severity" not in application_settings: # By default show only errors. Don't show on Linux X server non-fatal # errors like "WARNING:x11_util.cc(1409)] X error received". application_settings["log_severity"] = LOGSEVERITY_ERROR if "string_encoding" not in application_settings: application_settings["string_encoding"] = "utf-8" if "unique_request_context_per_browser" not in application_settings: application_settings["unique_request_context_per_browser"] = False if "downloads_enabled" not in application_settings: application_settings["downloads_enabled"] = True if "remote_debugging_port" not in application_settings: application_settings["remote_debugging_port"] = 0 if "app_user_model_id" in application_settings: g_commandLineSwitches["app-user-model-id"] =\ application_settings["app_user_model_id"] # ------------------------------------------------------------------------ # Paths # ------------------------------------------------------------------------ cdef str module_dir = GetModuleDirectory() if "locales_dir_path" not in application_settings: if platform.system() != "Darwin": application_settings["locales_dir_path"] = os.path.join( module_dir, "locales") if "resources_dir_path" not in application_settings: application_settings["resources_dir_path"] = module_dir if "browser_subprocess_path" not in application_settings: application_settings["browser_subprocess_path"] = os.path.join( module_dir, "subprocess") # ------------------------------------------------------------------------ # Mouse context menu # ------------------------------------------------------------------------ if "context_menu" not in application_settings: application_settings["context_menu"] = {} menuItems = ["enabled", "navigation", "print", "view_source", "external_browser", "devtools"] for item in menuItems: if item not in application_settings["context_menu"]: application_settings["context_menu"][item] = True # ------------------------------------------------------------------------ # Remote debugging port. # ------------------------------------------------------------------------ # If value is 0 we will generate a random port. To disable # remote debugging set value to -1. if application_settings["remote_debugging_port"] == 0: # Generate a random port. application_settings["remote_debugging_port"] =\ random.randint(49152, 65535) elif application_settings["remote_debugging_port"] == -1: # Disable remote debugging application_settings["remote_debugging_port"] = 0 # ------------------------------------------------------------------------ # CEF options - default values # ------------------------------------------------------------------------ if not "multi_threaded_message_loop" in application_settings: application_settings["multi_threaded_message_loop"] = False if not "single_process" in application_settings: application_settings["single_process"] = False # ------------------------------------------------------------------------ cdef CefRefPtr[CefApp] cefApp = new CefPythonApp() IF UNAME_SYSNAME == "Windows": cdef HINSTANCE hInstance = GetModuleHandle(NULL) cdef CefMainArgs cefMainArgs = CefMainArgs(hInstance) ELIF UNAME_SYSNAME == "Linux": # TODO: use the CefMainArgs(int argc, char** argv) constructor. cdef CefMainArgs cefMainArgs ELIF UNAME_SYSNAME == "Darwin": # TODO: use the CefMainArgs(int argc, char** argv) constructor. cdef CefMainArgs cefMainArgs cdef int exitCode = 1 # NOTE: CefExecuteProcess shall not be called here. It should # be called only in the subprocess main.cpp. # Make a copy as applicationSettings is a reference only # that might get destroyed later. global g_applicationSettings for key in application_settings: g_applicationSettings[key] = copy.deepcopy(application_settings[key]) cdef CefSettings cefApplicationSettings # No sandboxing for the subprocesses cefApplicationSettings.no_sandbox = 1 SetApplicationSettings(application_settings, &cefApplicationSettings) Debug("CefInitialize()") cdef cpp_bool ret with nogil: ret = CefInitialize(cefMainArgs, cefApplicationSettings, cefApp, NULL) global g_cef_initialized g_cef_initialized = True if not ret: Debug("CefInitialize() failed") IF UNAME_SYSNAME == "Linux": # Install by default. WindowUtils.InstallX11ErrorHandlers() return ret def CreateBrowser(**kwargs): """Create browser asynchronously. TODO. """ CreateBrowserSync(**kwargs) def CreateBrowserSync(windowInfo=None, browserSettings=None, navigateUrl="", window_title="", **kwargs): # Alternative names for existing parameters if "window_info" in kwargs: windowInfo = kwargs["window_info"] del kwargs["window_info"] if "settings" in kwargs: browserSettings = kwargs["settings"] del kwargs["settings"] if "url" in kwargs: navigateUrl = kwargs["url"] del kwargs["url"] for kwarg in kwargs: raise Exception("Invalid argument: "+kwarg) Debug("CreateBrowserSync() called") assert IsThread(TID_UI), ( "cefpython.CreateBrowserSync() may only be called on the UI thread") """ # CEF views # noinspection PyUnresolvedReferences cdef CefRefPtr[CefWindow] cef_window # noinspection PyUnresolvedReferences cdef CefRefPtr[CefBoxLayout] cef_box_layout cdef CefBoxLayoutSettings cef_box_layout_settings cdef CefRefPtr[CefPanel] cef_panel if not windowInfo and browserSettings \ and "window_title" in browserSettings: # noinspection PyUnresolvedReferences cef_window = CefWindow.CreateTopLevelWindow( NULL) Debug("CefWindow.GetChildViewCount = " +str(cef_window.get().GetChildViewCount())) cef_window.get().CenterWindow(CefSize(800, 600)) cef_window.get().SetBounds(CefRect(0, 0, 800, 600)) # noinspection PyUnresolvedReferences #cef_box_layout = cef_window.get().SetToBoxLayout( # cef_box_layout_settings) #cef_box_layout.get().SetFlexForView(cef_window, 1) cef_window.get().SetToFillLayout() # noinspection PyUnresolvedReferences cef_panel = CefPanel.CreatePanel(NULL) cef_window.get().AddChildView(cef_panel) cef_window.get().Layout() cef_window.get().SetVisible(True) cef_window.get().Show() cef_window.get().RequestFocus() windowInfo = WindowInfo() windowInfo.SetAsChild(cef_window.get().GetWindowHandle()) Debug("CefWindow handle = " +str(cef_window.get().GetWindowHandle())) """ # Only title was set in hello_world.py example if windowInfo and not windowInfo.windowType: windowInfo.SetAsChild(0) # No window info provided if not windowInfo: windowInfo = WindowInfo() windowInfo.SetAsChild(0) elif not isinstance(windowInfo, WindowInfo): raise Exception("CreateBrowserSync() failed: windowInfo: invalid object") if window_title and windowInfo.parentWindowHandle == 0: windowInfo.windowName = window_title if not browserSettings: browserSettings = {} # CEF Python only settings if "inherit_client_handlers_for_popups" not in browserSettings: browserSettings["inherit_client_handlers_for_popups"] = True cdef CefBrowserSettings cefBrowserSettings SetBrowserSettings(browserSettings, &cefBrowserSettings) cdef CefWindowInfo cefWindowInfo SetCefWindowInfo(cefWindowInfo, windowInfo) navigateUrl = GetNavigateUrl(navigateUrl) Debug("navigateUrl: %s" % navigateUrl) cdef CefString cefNavigateUrl PyToCefString(navigateUrl, cefNavigateUrl) Debug("CefBrowser::CreateBrowserSync()") cdef CefRefPtr[ClientHandler] clientHandler =\ new ClientHandler() cdef CefRefPtr[CefBrowser] cefBrowser # Request context - part 1/2. createSharedRequestContext = bool(not g_shared_request_context.get()) cdef CefRefPtr[CefRequestContext] cefRequestContext cdef CefRefPtr[RequestContextHandler] requestContextHandler =\ new RequestContextHandler( cefBrowser) if g_applicationSettings["unique_request_context_per_browser"]: cefRequestContext = CefRequestContext.CreateContext( CefRequestContext.GetGlobalContext(), requestContextHandler) elif createSharedRequestContext: cefRequestContext = CefRequestContext.CreateContext( CefRequestContext.GetGlobalContext(), requestContextHandler) g_shared_request_context.Assign(cefRequestContext.get()) else: cefRequestContext.Assign(g_shared_request_context.get()) # CEF browser creation. with nogil: cefBrowser = cef_browser_static.CreateBrowserSync( cefWindowInfo, clientHandler, cefNavigateUrl, cefBrowserSettings, cefRequestContext) if cefBrowser == NULL or not cefBrowser.get(): Debug("CefBrowser::CreateBrowserSync() failed") return None else: Debug("CefBrowser::CreateBrowserSync() succeeded") Debug("CefBrowser window handle = " +str(cefBrowser.get().GetHost().get().GetWindowHandle())) # Request context - part 2/2. if g_applicationSettings["unique_request_context_per_browser"]: requestContextHandler.get().SetBrowser(cefBrowser) else: if createSharedRequestContext: requestContextHandler.get().SetBrowser(cefBrowser) cdef PyBrowser pyBrowser = GetPyBrowser(cefBrowser) pyBrowser.SetUserData("__outerWindowHandle", int(windowInfo.parentWindowHandle)) """ if cef_window.get(): cef_window.get().ReorderChildView(cef_panel, -1) cef_window.get().Layout() cef_window.get().Show() cef_window.get().RequestFocus() """ if windowInfo.parentWindowHandle == 0\ and windowInfo.windowType == "child"\ and windowInfo.windowName: # Set window title in hello_world.py example IF UNAME_SYSNAME == "Linux": x11.SetX11WindowTitle(cefBrowser, PyStringToChar(windowInfo.windowName)) ELIF UNAME_SYSNAME == "Darwin": MacSetWindowTitle(cefBrowser, PyStringToChar(windowInfo.windowName)) return pyBrowser def MessageLoop(): Debug("MessageLoop()") if not g_MessageLoop_called: global g_MessageLoop_called g_MessageLoop_called = True with nogil: CefRunMessageLoop() def MessageLoopWork(): # 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. # Anything that can block for a significant amount of time # and is thread-safe should release the GIL: # https://groups.google.com/d/msg/cython-users/jcvjpSOZPp0/KHpUEX8IhnAJ # GIL must be released here otherwise we will get dead lock # when calling from c++ to python. if not g_MessageLoopWork_called: global g_MessageLoopWork_called g_MessageLoopWork_called = True with nogil: CefDoMessageLoopWork() def SingleMessageLoop(): # @deprecated, use MessageLoopWork() instead MessageLoopWork() def QuitMessageLoop(): Debug("QuitMessageLoop()") with nogil: CefQuitMessageLoop() def Shutdown(): Debug("Shutdown()") # Release shared request context. This is sometimes causing # segmentation fault, so disabling it for now. See Issue #333: # https://github.com/cztomczak/cefpython/issues/333 # OFF: g_shared_request_context.Assign(NULL) # Run some message loop work, force closing browsers and then run # some message loop work again for the browsers to close cleanly. # # UPDATE: This code needs to be rechecked. There were enhancements # to unrferencing globally stored Browser objects in # g_pyBrowsers. See Issue #330 and its commits. # # CASE 1: # There might be a case when python error occured after creating # browser, but before any message loop was run. In such case # the renderer process won't be terminated unless we run some # message loop work here first, close browser and free # reference, and then run some message loop work again. # # CASE 2: # Application closes browser and then calls CEF shutdown. We need # to run some message loop work so that browser can close cleanly. # Looks like running message loop work is also required when # application runs MessageLoop() (Issue #282 and the hello_world.py # example). # # CASE 3: # Run some message loop work to fix possible errors on shutdown. # See this post: # >> https://magpcss.org/ceforum/viewtopic.php?p=30858#p30858 # May be fixed by host owned message loop, see Issue 1805: # >> https://bitbucket.org/chromiumembedded/cef/issues/1805/ # This 0.2 sec message loop work should close browsers and clean # CEF references. Even when CloseBrowser(True) wasn't called # in client app, then this code below should close it cleanly. # Looks like CEF detects that parent window was destroyed # and closes browser automatically if you give it some time. # If the time was not enough, then there is an emergency plan, # the code block further down that checks len(g_pyBrowsers). for _ in range(20): for __ in range(10): with nogil: CefDoMessageLoopWork() time.sleep(0.01) # Emergency plan in case the code above didn't close browsers, # and neither browsers were closed in client app. This code # will force closing browsers by calling CloseBrowser(True) # and then free global g_pyBrowsers list that keeps CEF # references alive. if len(g_pyBrowsers): browsers_list = [] for browserId in g_pyBrowsers: # Cannot close browser here otherwise error: # > dictionary changed size during iteration browsers_list.append(browserId) browser_close_forced = False for browserId in browsers_list: browser = GetPyBrowserById(browserId) if browser and browserId not in g_closed_browsers: Debug("WARNING: Browser was not closed with CloseBrowser call." " Will close it safely now, but this will delay CEF" " shutdown by 0.2 sec.") browser.CloseBrowser(True) browser_close_forced = True browser = None # free reference RemovePyBrowser(browserId) if browser_close_forced: for _ in range(20): for __ in range(10): with nogil: CefDoMessageLoopWork() time.sleep(0.01) # Message loop work was run, so handlers callbacks might got called # and browsers might still be in g_pyBrowsers. for browserId in browsers_list: if browserId in g_pyBrowsers: RemovePyBrowser(browserId) # If the the two code blocks above, that tried to close browsers # and free CEF references, failed, then display an error about it! if len(g_pyBrowsers): NonCriticalError("Shutdown called, but there are still browser" " references alive") Debug("CefShutdown()") with nogil: CefShutdown() def SetOsModalLoop(py_bool modalLoop): cdef cpp_bool cefModalLoop = bool(modalLoop) with nogil: CefSetOSModalLoop(cefModalLoop) cpdef py_void SetGlobalClientCallback(py_string name, object callback): global g_globalClientCallbacks # Global callbacks are prefixed with "_" in documentation. # Accept both with and without a prefix. if name.startswith("_"): name = name[1:] if name in ["OnCertificateError", "OnBeforePluginLoad", "OnAfterCreated"]: g_globalClientCallbacks[name] = callback else: raise Exception("SetGlobalClientCallback() failed: "\ "invalid callback name = %s" % name) cpdef py_void SetGlobalClientHandler(object clientHandler): if not hasattr(clientHandler, "__class__"): raise Exception("SetGlobalClientHandler() failed: __class__ " "attribute missing") cdef dict methods = {} cdef py_string key cdef object method cdef tuple value for value in inspect.getmembers(clientHandler, predicate=inspect.ismethod): key = value[0] method = value[1] if key and key[0:2] != '__': SetGlobalClientCallback(key, method) cpdef object GetGlobalClientCallback(py_string name): global g_globalClientCallbacks if name in g_globalClientCallbacks: return g_globalClientCallbacks[name] else: return None cpdef object GetAppSetting(py_string key): global g_applicationSettings if key in g_applicationSettings: return g_applicationSettings[key] return None cpdef dict GetVersion(): # These variable are set when building the module. # noinspection PyUnresolvedReferences return dict( version=__version__, chrome_version=__chrome_version__, cef_version=__cef_version__, cef_api_hash_platform=__cef_api_hash_platform__, cef_api_hash_universal=__cef_api_hash_universal__, cef_commit_hash=__cef_commit_hash__, cef_commit_number=__cef_commit_number__, ) cpdef GetDataUrl(data, mediatype="html"): html = data.encode("utf-8", "replace") b64 = base64.b64encode(html).decode("utf-8", "replace") ret = "data:text/html;base64,{data}".format(data=b64) return ret cefpython-49.0/src/cefpython3.wx/000077500000000000000000000000001334103266300167545ustar00rootroot00000000000000cefpython-49.0/src/cefpython3.wx/README.txt000066400000000000000000000002661334103266300204560ustar00rootroot00000000000000This is a wxPython subpackage for the cefpython3 package that provides an easy to use API for the wxPython GUI library. Author: Greg Kacy License: BSD 3-clause cefpython-49.0/src/cefpython3.wx/__init__.py000066400000000000000000000001751334103266300210700ustar00rootroot00000000000000# This dummy file is overwritten by "__init__.py.template", see: # cefpython/windows/installer/ # cefpython/linux/installer/ cefpython-49.0/src/cefpython3.wx/chromectrl.py000066400000000000000000000363051334103266300214770ustar00rootroot00000000000000# Additional and wx specific layer of abstraction for the cefpython # __author__ = "Greg Kacy " #------------------------------------------------------------------------------- from cefpython3 import cefpython import os, sys, platform import wx import wx.lib.buttons as buttons #------------------------------------------------------------------------------- # CEF Python application settings g_settings = None def Debug(msg): if g_settings and "debug" in g_settings and g_settings["debug"]: print("[chromectrl.py] "+msg) #------------------------------------------------------------------------------- # Default timer interval when timer used to service CEF message loop DEFAULT_TIMER_MILLIS = 10 # A global timer for CEF message loop processing. g_messageLoopTimer = None def CreateMessageLoopTimer(timerMillis): # This function gets called multiple times for each ChromeWindow # instance. global g_messageLoopTimer Debug("CreateMesageLoopTimer") if g_messageLoopTimer: return g_messageLoopTimer = wx.Timer() g_messageLoopTimer.Start(timerMillis) Debug("g_messageLoopTimer.GetId() = "\ +str(g_messageLoopTimer.GetId())) wx.EVT_TIMER(g_messageLoopTimer, g_messageLoopTimer.GetId(),\ MessageLoopTimer) def MessageLoopTimer(event): cefpython.MessageLoopWork() def DestroyMessageLoopTimer(): global g_messageLoopTimer Debug("DestroyMessageLoopTimer") if g_messageLoopTimer: g_messageLoopTimer.Stop() g_messageLoopTimer = None else: # There was no browser created during session. Debug("DestroyMessageLoopTimer: timer not started") #------------------------------------------------------------------------------- class NavigationBar(wx.Panel): def __init__(self, parent, *args, **kwargs): wx.Panel.__init__(self, parent, *args, **kwargs) self.bitmapDir = os.path.join(os.path.dirname( os.path.abspath(__file__)), "images") self._InitComponents() self._LayoutComponents() self._InitEventHandlers() def _InitComponents(self): self.backBtn = buttons.GenBitmapButton(self, -1, wx.Bitmap(os.path.join(self.bitmapDir, "back.png"), wx.BITMAP_TYPE_PNG), style=wx.BORDER_NONE) self.forwardBtn = buttons.GenBitmapButton(self, -1, wx.Bitmap(os.path.join(self.bitmapDir, "forward.png"), wx.BITMAP_TYPE_PNG), style=wx.BORDER_NONE) self.reloadBtn = buttons.GenBitmapButton(self, -1, wx.Bitmap(os.path.join(self.bitmapDir, "reload_page.png"), wx.BITMAP_TYPE_PNG), style=wx.BORDER_NONE) self.url = wx.TextCtrl(self, id=-1, style=0) self.historyPopup = wx.Menu() def _LayoutComponents(self): sizer = wx.BoxSizer(wx.HORIZONTAL) sizer.Add(self.backBtn, 0, wx.ALIGN_LEFT|wx.ALIGN_CENTER_VERTICAL| wx.ALL, 0) sizer.Add(self.forwardBtn, 0, wx.ALIGN_LEFT|wx.ALIGN_CENTER_VERTICAL| wx.ALL, 0) sizer.Add(self.reloadBtn, 0, wx.ALIGN_LEFT|wx.ALIGN_CENTER_VERTICAL| wx.ALL, 0) sizer.Add(self.url, 1, wx.EXPAND|wx.ALIGN_CENTER_VERTICAL|wx.ALL, 12) self.SetSizer(sizer) self.Fit() def _InitEventHandlers(self): self.backBtn.Bind(wx.EVT_CONTEXT_MENU, self.OnButtonContext) def __del__(self): self.historyPopup.Destroy() def GetBackButton(self): return self.backBtn def GetForwardButton(self): return self.forwardBtn def GetReloadButton(self): return self.reloadBtn def GetUrlCtrl(self): return self.url def InitHistoryPopup(self): self.historyPopup = wx.Menu() def AddToHistory(self, url): self.historyPopup.Append(-1, url) def OnButtonContext(self, event): self.PopupMenu(self.historyPopup) class ChromeWindow(wx.Window): """ Standalone CEF component. The class provides facilites for interacting with wx message loop """ def __init__(self, parent, url="", useTimer=True, timerMillis=DEFAULT_TIMER_MILLIS, browserSettings=None, size=(-1, -1), *args, **kwargs): wx.Window.__init__(self, parent, id=wx.ID_ANY, size=size, *args, **kwargs) # This timer is not used anymore, but creating it for backwards # compatibility. In one of external projects ChromeWindow.timer.Stop() # is being called during browser destruction. self.timer = wx.Timer() # On Linux absolute file urls need to start with "file://" # otherwise a path of "/home/some" is converted to "http://home/some". if platform.system() in ["Linux", "Darwin"]: if url.startswith("/"): url = "file://" + url self.url = url windowInfo = cefpython.WindowInfo() if platform.system() == "Windows": windowInfo.SetAsChild(self.GetHandle()) elif platform.system() == "Linux": windowInfo.SetAsChild(self.GetGtkWidget()) elif platform.system() == "Darwin": (width, height) = self.GetClientSizeTuple() windowInfo.SetAsChild(self.GetHandle(), [0, 0, width, height]) else: raise Exception("Unsupported OS") if not browserSettings: browserSettings = {} # Disable plugins: # | browserSettings["plugins_disabled"] = True self.browser = cefpython.CreateBrowserSync(windowInfo, browserSettings=browserSettings, navigateUrl=url) if platform.system() == "Windows": self.Bind(wx.EVT_SET_FOCUS, self.OnSetFocus) self.Bind(wx.EVT_SIZE, self.OnSize) self._useTimer = useTimer if useTimer: CreateMessageLoopTimer(timerMillis) else: # Currently multiple EVT_IDLE events might be registered # when creating multiple ChromeWindow instances. This will # result in calling CEF message loop work multiple times # simultaneously causing performance penalties and possibly # some unwanted behavior (CEF Python Issue 129). Debug("WARNING: Using EVT_IDLE for CEF message loop processing"\ " is not recommended") self.Bind(wx.EVT_IDLE, self.OnIdle) self.Bind(wx.EVT_CLOSE, self.OnClose) def OnClose(self, event): if not self._useTimer: try: self.Unbind(wx.EVT_IDLE) except: # Calling Unbind() may cause problems on Windows 8: # https://groups.google.com/d/topic/cefpython/iXE7e1ekArI/discussion # (it was causing problems in __del__, this might not # be true anymore in OnClose, but still let's make sure) pass self.browser.ParentWindowWillClose() def OnIdle(self, event): """Service CEF message loop when useTimer is False""" cefpython.MessageLoopWork() event.Skip() def OnSetFocus(self, event): """OS_WIN only.""" cefpython.WindowUtils.OnSetFocus(self.GetHandle(), 0, 0, 0) event.Skip() def OnSize(self, event): """OS_WIN only. Handle the the size event""" cefpython.WindowUtils.OnSize(self.GetHandle(), 0, 0, 0) event.Skip() def GetBrowser(self): """Returns the CEF's browser object""" return self.browser def LoadUrl(self, url, onLoadStart=None, onLoadEnd=None): if onLoadStart or onLoadEnd: self.GetBrowser().SetClientHandler( CallbackClientHandler(onLoadStart, onLoadEnd)) browser = self.GetBrowser() if cefpython.g_debug: Debug("LoadUrl() self: %s" % self) Debug("browser: %s" % browser) Debug("browser id: %s" % browser.GetIdentifier()) Debug("mainframe: %s" % browser.GetMainFrame()) Debug("mainframe id: %s" % \ browser.GetMainFrame().GetIdentifier()) self.GetBrowser().GetMainFrame().LoadUrl(url) #wx.CallLater(100, browser.ReloadIgnoreCache) #wx.CallLater(200, browser.GetMainFrame().LoadUrl, url) class ChromeCtrl(wx.Panel): def __init__(self, parent, url="", useTimer=True, timerMillis=DEFAULT_TIMER_MILLIS, browserSettings=None, hasNavBar=True, *args, **kwargs): # You also have to set the wx.WANTS_CHARS style for # all parent panels/controls, if it's deeply embedded. wx.Panel.__init__(self, parent, style=wx.WANTS_CHARS, *args, **kwargs) self.chromeWindow = ChromeWindow(self, url=str(url), useTimer=useTimer, browserSettings=browserSettings) sizer = wx.BoxSizer(wx.VERTICAL) self.navigationBar = None if hasNavBar: self.navigationBar = self.CreateNavigationBar() sizer.Add(self.navigationBar, 0, wx.EXPAND|wx.ALL, 0) self._InitEventHandlers() sizer.Add(self.chromeWindow, 1, wx.EXPAND, 0) self.SetSizer(sizer) self.Fit() ch = DefaultClientHandler(self) self.SetClientHandler(ch) if self.navigationBar: self.UpdateButtonsState() def _InitEventHandlers(self): self.navigationBar.backBtn.Bind(wx.EVT_BUTTON, self.OnLeft) self.navigationBar.forwardBtn.Bind(wx.EVT_BUTTON, self.OnRight) self.navigationBar.reloadBtn.Bind(wx.EVT_BUTTON, self.OnReload) def GetNavigationBar(self): return self.navigationBar def SetNavigationBar(self, navigationBar): sizer = self.GetSizer() if self.navigationBar: # remove previous one sizer.Replace(self.navigationBar, navigationBar) self.navigationBar.Hide() del self.navigationBar else: sizer.Insert(0, navigationBar, 0, wx.EXPAND) self.navigationBar = navigationBar sizer.Fit(self) def CreateNavigationBar(self): np = NavigationBar(self) return np def SetClientHandler(self, handler): self.chromeWindow.GetBrowser().SetClientHandler(handler) def OnLeft(self, event): if self.chromeWindow.GetBrowser().CanGoBack(): self.chromeWindow.GetBrowser().GoBack() self.UpdateButtonsState() self.chromeWindow.GetBrowser().SetFocus(True) def OnRight(self, event): if self.chromeWindow.GetBrowser().CanGoForward(): self.chromeWindow.GetBrowser().GoForward() self.UpdateButtonsState() self.chromeWindow.GetBrowser().SetFocus(True) def OnReload(self, event): self.chromeWindow.GetBrowser().Reload() self.UpdateButtonsState() self.chromeWindow.GetBrowser().SetFocus(True) def UpdateButtonsState(self): self.navigationBar.backBtn.Enable( self.chromeWindow.GetBrowser().CanGoBack()) self.navigationBar.forwardBtn.Enable( self.chromeWindow.GetBrowser().CanGoForward()) def OnLoadStart(self, browser, frame): if self.navigationBar: self.UpdateButtonsState() self.navigationBar.GetUrlCtrl().SetValue( browser.GetMainFrame().GetUrl()) self.navigationBar.AddToHistory(browser.GetMainFrame().GetUrl()) def OnLoadEnd(self, browser, frame, httpStatusCode): if self.navigationBar: # In CEF 3 the CanGoBack() and CanGoForward() methods # sometimes do work, sometimes do not, when called from # the OnLoadStart event. That's why we're calling it again # here. This is still not perfect as OnLoadEnd() is not # guaranteed to get called for all types of pages. See the # cefpython documentation: # https://code.google.com/p/cefpython/wiki/LoadHandler # OnDomReady() would be perfect, but is still not implemented. # Another option is to implement our own browser state # using the OnLoadStart and OnLoadEnd callbacks. self.UpdateButtonsState() class DefaultClientHandler(object): def __init__(self, parentCtrl): self.parentCtrl = parentCtrl def OnLoadStart(self, browser, frame): self.parentCtrl.OnLoadStart(browser, frame) def OnLoadEnd(self, browser, frame, httpStatusCode): self.parentCtrl.OnLoadEnd(browser, frame, httpStatusCode) def OnLoadError(self, browser, frame, errorCode, errorText, failedUrl): # TODO Debug("ERROR LOADING URL : %s" % failedUrl) class CallbackClientHandler(object): def __init__(self, onLoadStart=None, onLoadEnd=None): self._onLoadStart = onLoadStart self._onLoadEnd = onLoadEnd def OnLoadStart(self, browser, frame): if self._onLoadStart and frame.GetUrl() != "about:blank": self._onLoadStart(browser, frame) def OnLoadEnd(self, browser, frame, httpStatusCode): if self._onLoadEnd and frame.GetUrl() != "about:blank": self._onLoadEnd(browser, frame, httpStatusCode) def OnLoadError(self, browser, frame, errorCode, errorText, failedUrl): # TODO Debug("ERROR LOADING URL : %s, %s" % (failedUrl, frame.GetUrl())) #------------------------------------------------------------------------------- def Initialize(settings=None, debug=False): """Initializes CEF, We should do it before initializing wx If no settings passed a default is used """ switches = {} global g_settings if not settings: settings = {} if not "log_severity" in settings: settings["log_severity"] = cefpython.LOGSEVERITY_INFO if not "log_file" in settings: settings["log_file"] = "" if platform.system() == "Linux": # On Linux we need to set locales and resources directories. if not "locales_dir_path" in settings: settings["locales_dir_path"] = \ cefpython.GetModuleDirectory() + "/locales" if not "resources_dir_path" in settings: settings["resources_dir_path"] = cefpython.GetModuleDirectory() elif platform.system() == "Darwin": # On Mac we need to set the resoures dir and the locale_pak switch if not "resources_dir_path" in settings: settings["resources_dir_path"] = (cefpython.GetModuleDirectory() + "/Resources") locale_pak = (cefpython.GetModuleDirectory() + "/Resources/en.lproj/locale.pak") if "locale_pak" in settings: locale_pak = settings["locale_pak"] del settings["locale_pak"] switches["locale_pak"] = locale_pak if not "browser_subprocess_path" in settings: settings["browser_subprocess_path"] = \ "%s/%s" % (cefpython.GetModuleDirectory(), "subprocess") # DEBUGGING options: # ------------------ if debug: settings["debug"] = True # cefpython messages in console and log_file settings["log_severity"] = cefpython.LOGSEVERITY_VERBOSE settings["log_file"] = "debug.log" # Set to "" to disable. g_settings = settings cefpython.Initialize(settings, switches) def Shutdown(): """Shuts down CEF, should be called by app exiting code""" DestroyMessageLoopTimer() cefpython.Shutdown() cefpython-49.0/src/cefpython3.wx/examples/000077500000000000000000000000001334103266300205725ustar00rootroot00000000000000cefpython-49.0/src/cefpython3.wx/examples/back.png000066400000000000000000000025041334103266300222010ustar00rootroot00000000000000PNG  IHDRĴl;bKGD pHYs ,tIME 4ٸIDATxڍۋ\U{Oթ[Wv3t0J 3 C-,B<"/ DP$q=L NtWwUr.{IO4`}ǷYk)~JG $")@]6]wa'A(L;#M`^Ò{R? .y9NMx|szͲjFSFoT*;A:OdٷCx$opTN吓!__'M{ÓwΏ|z>sqt}JhDeNõLVj*˾o깲3 >6yw[1榓|tζ-Q$[ ٔQa fsp{rەK* |O=R$i݈\DU8{KԈ9=H!-=mU,@Y =WuA9)t"2!͞el?hvő= K}(@'|eɺwa%*~ieԝ 5;|rv_~1x_\+PI4r ll|.!lo8p}X\ 1 $i[ƶk<59R]xΆs߃7#cmQd6FILҍԭr^nvnUߏK 򗱴g,2\Zxl[XeK2`,B^Hڄծ8Yw-?$*']r!i?I&i/$mh&U!7o?٧>~9jU~Uz(;;*P$0 bk#v|MF' #$\Arym֙‰\BϔL.3ݏf)֬]PoGxsƁV-Wg&sNj`Rěj*ʩF]fεNjtt#]\ Db=Nl2_8qZT*/ȑ#G4>_GkUCۚr2^t44zA+3*qj%Hr^ns@T*{/{hRhIENDB`cefpython-49.0/src/cefpython3.wx/examples/forward.png000066400000000000000000000024371334103266300227520ustar00rootroot00000000000000PNG  IHDRĴl;bKGD pHYs ,tIME 'VnIDATxڍk\E?4IhMZ[FRPQUA "*U" W b5X4mif{􇶶/3g>s93l^MlkSvnVt<~E<0"Ltd?GO/j$[CW_|fGxw*"A+A&wݞ;ٶa]Dv|\H](2^PA<=:Vd ¶6$Rpo1?-ӡr\_un@ў!Tw擃%)hJ:ܻ1ɑ5rkFKsn&웉7̄*6rψ,DZHgV:woH%%CZOGG55$Z˲s"$]ޝ|vloRkŭ5Q,j!9AeH'$J),R]L:ʕ_>o4Y̓l5nl,o'Og1g`!!&a:"LAO:u+ ^A |`g}Srj Viڽ 0iky4aw 8}x壇#%T'J RmVa:??Q|[rOȧ=&K ! S(PJ"858{mhuxҞ(t6|t⹒\%J4p X͑h^(V2P~PW;_]t8yh]՝&&7[ qbKZ&?vXk&s[zʬ|]- R*CA2[3MsRD)ɕ%bՍi0 *+r"[0צ密tR^bVB>;urnB3( }Q9,B֦J 6dLGIÔw>jFw슬J,sdH֓&4}q@YWs<2SȻ ]9xn4cxwx=,0UvxZܾmB䄡tХ޳<=|Z J%G' fB69 0`Q,Ւމ]1Uv¡>R䞫ST!~06$lbzodEY:]~Fs`F7z+!#!)ݴVU̅,W7S {۟&lW<`5q8_N  ^>I|DuQZFBPpF ;~VVV[?[#lz6PΤXri=KhR֛ o|t}V_sa-b8Yh3_N;ʌ^ ķVoGs_6"oFflg.\Ǭ6b8e OvBRSnekz?JJyɒJ\G*|ngzl6O_[Vwpa[Re>*%sQeTrHjZϿKka?S_x6$KKK/%P\ sample 1 sample1.py - wxPython example for the CEF Python framework

Google Search

http://www.google.com/

User agent

Popup

window.open('sample1.html')
































cefpython-49.0/src/cefpython3.wx/examples/sample1.py000066400000000000000000000035611334103266300225130ustar00rootroot00000000000000# Simple sample ilustrating the usage of CEFWindow class. # On Mac the cefpython library must be imported the very first, # before any other libraries (Issue 155). import cefpython3.wx.chromectrl as chrome import os import wx import platform class MainFrame(wx.Frame): def __init__(self): wx.Frame.__init__(self, parent=None, id=wx.ID_ANY, title='cefwx example1', size=(800,600)) self.cefWindow = chrome.ChromeWindow(self, url=os.path.join(os.path.dirname(os.path.abspath(__file__)), "sample1.html")) sizer = wx.BoxSizer() sizer.Add(self.cefWindow, 1, wx.EXPAND, 0) self.SetSizer(sizer) self.Bind(wx.EVT_CLOSE, self.OnClose) def OnClose(self, event): # Remember to destroy all CEF browser references before calling # Destroy(), so that browser closes cleanly. In this specific # example there are no references kept, but keep this in mind # for the future. self.Destroy() # On Mac the code after app.MainLoop() never executes, so # need to call CEF shutdown here. if platform.system() == "Darwin": chrome.Shutdown() wx.GetApp().Exit() class MyApp(wx.App): def OnInit(self): frame = MainFrame() self.SetTopWindow(frame) frame.Show() return True if __name__ == '__main__': chrome.Initialize({ "debug": True, "log_file": "debug.log", "log_severity": chrome.cefpython.LOGSEVERITY_INFO, # "cache_path": "webcache/", }) print('[sample1.py] wx.version=%s' % wx.version()) app = MyApp(False) app.MainLoop() # Important: do the wx cleanup before calling Shutdown del app # On Mac Shutdown is called in OnClose if platform.system() in ["Linux", "Windows"]: chrome.Shutdown() cefpython-49.0/src/cefpython3.wx/examples/sample2.py000066400000000000000000000102561334103266300225130ustar00rootroot00000000000000# Slightly more advanced sample illustrating the usage of CEFWindow class. # On Mac the cefpython library must be imported the very first, # before any other libraries (Issue 155). import cefpython3.wx.chromectrl as chrome # TODO: There is something wrong happening on Linux. CPU usage # for the python process is 100% all the time. This problem # does not occur on Windows, nor in sample1.py/sample3.py. # It must have something to do with invalid usage of the wx # controls in this example. import wx import wx.lib.agw.flatnotebook as fnb import platform import sys ROOT_NAME = "My Locations" URLS = ["http://gmail.com", "http://maps.google.com", "http://youtube.com", "http://yahoo.com", "http://wikipedia.com", "http://cyaninc.com", "http://tavmjong.free.fr/INKSCAPE/MANUAL/web/svg_tests.php" ] class MainFrame(wx.Frame): def __init__(self): wx.Frame.__init__(self, parent=None, id=wx.ID_ANY, title='cefwx example2', size=(800, 600)) self.initComponents() self.layoutComponents() self.initEventHandlers() if len(sys.argv) == 2 and sys.argv[1] == "test-launch": wx.CallLater(500, self.testLaunch) def testLaunch(self): # This hash is checked by /tests/test-launch.sh script # to detect whether CEF initialized successfully. print("b8ba7d9945c22425328df2e21fbb64cd") self.Close() def initComponents(self): self.tree = wx.TreeCtrl(self, id=-1, size=(200, -1)) self.root = self.tree.AddRoot(ROOT_NAME) for url in URLS: self.tree.AppendItem(self.root, url) self.tree.Expand(self.root) self.tabs = fnb.FlatNotebook(self, wx.ID_ANY, agwStyle=fnb.FNB_NODRAG | fnb.FNB_X_ON_TAB) # You also have to set the wx.WANTS_CHARS style for # all parent panels/controls, if it's deeply embedded. self.tabs.SetWindowStyleFlag(wx.WANTS_CHARS) def layoutComponents(self): sizer = wx.BoxSizer(wx.HORIZONTAL) sizer.Add(self.tree, 0, wx.EXPAND) sizer.Add(self.tabs, 1, wx.EXPAND) self.SetSizer(sizer) def initEventHandlers(self): self.Bind(wx.EVT_TREE_SEL_CHANGED, self.OnSelChanged, self.tree) self.Bind(fnb.EVT_FLATNOTEBOOK_PAGE_CLOSING, self.OnPageClosing) self.Bind(wx.EVT_CLOSE, self.OnClose) def OnSelChanged(self, event): self.item = event.GetItem() url = self.tree.GetItemText(self.item) if url and url != ROOT_NAME: cefPanel = chrome.ChromeCtrl(self.tabs, useTimer=True, url=str(url)) self.tabs.AddPage(cefPanel, url) self.tabs.SetSelection(self.tabs.GetPageCount()-1) event.Skip() def OnPageClosing(self, event): print("sample2.py: One could place some extra closing stuff here") event.Skip() def OnClose(self, event): # Remember to destroy all CEF browser references before calling # Destroy(), so that browser closes cleanly. In this specific # example there are no references kept, but keep this in mind # for the future. self.Destroy() # On Mac the code after app.MainLoop() never executes, so # need to call CEF shutdown here. if platform.system() == "Darwin": chrome.Shutdown() wx.GetApp().Exit() class MyApp(wx.App): def OnInit(self): frame = MainFrame() self.SetTopWindow(frame) frame.Show() return True if __name__ == '__main__': chrome.Initialize() if platform.system() == "Linux": # CEF initialization fails intermittently on Linux during # launch of a subprocess (Issue 131). The solution is # to offload cpu for half a second after Initialize # has returned (it still runs some stuff in its thread). import time time.sleep(0.5) print('sample2.py: wx.version=%s' % wx.version()) app = MyApp(False) app.MainLoop() # Important: do the wx cleanup before calling Shutdown del app # On Mac Shutdown is called in OnClose if platform.system() in ["Linux", "Windows"]: chrome.Shutdown() cefpython-49.0/src/cefpython3.wx/examples/sample3.py000066400000000000000000000075541334103266300225230ustar00rootroot00000000000000# Slightly more advanced sample illustrating the usage of CEFWindow class. # On Mac the cefpython library must be imported the very first, # before any other libraries (Issue 155). import cefpython3.wx.chromectrl as chrome import os import wx import wx.lib.agw.flatnotebook as fnb import platform class MainFrame(wx.Frame): def __init__(self): wx.Frame.__init__(self, parent=None, id=wx.ID_ANY, title='cefwx example3', size=(800,600)) self._InitComponents() self._LayoutComponents() self._InitEventHandlers() def _InitComponents(self): self.tabs = fnb.FlatNotebook(self, wx.ID_ANY, agwStyle=fnb.FNB_NODRAG|fnb.FNB_X_ON_TAB) # You also have to set the wx.WANTS_CHARS style for # all parent panels/controls, if it's deeply embedded. self.tabs.SetWindowStyleFlag(wx.WANTS_CHARS) ctrl1 = chrome.ChromeCtrl(self.tabs, useTimer=True, url="wikipedia.org") ctrl1.GetNavigationBar().GetUrlCtrl().SetEditable(False) ctrl1.GetNavigationBar().GetBackButton().SetBitmapLabel( wx.Bitmap(os.path.join(os.path.dirname(os.path.abspath(__file__)), "back.png"), wx.BITMAP_TYPE_PNG)) ctrl1.GetNavigationBar().GetForwardButton().SetBitmapLabel( wx.Bitmap(os.path.join(os.path.dirname(os.path.abspath(__file__)), "forward.png"), wx.BITMAP_TYPE_PNG)) ctrl1.GetNavigationBar().GetReloadButton().SetBitmapLabel( wx.Bitmap(os.path.join(os.path.dirname(os.path.abspath(__file__)), "reload_page.png"), wx.BITMAP_TYPE_PNG)) self.tabs.AddPage(ctrl1, "Wikipedia") ctrl2 = chrome.ChromeCtrl(self.tabs, useTimer=True, url="google.com", hasNavBar=False) self.tabs.AddPage(ctrl2, "Google") ctrl3 = chrome.ChromeCtrl(self.tabs, useTimer=True, url="greenpeace.org") ctrl3.SetNavigationBar(CustomNavigationBar(ctrl3)) self.tabs.AddPage(ctrl3, "Greenpeace") def _LayoutComponents(self): sizer = wx.BoxSizer(wx.HORIZONTAL) sizer.Add(self.tabs, 1, wx.EXPAND) self.SetSizer(sizer) def _InitEventHandlers(self): self.Bind(wx.EVT_CLOSE, self.OnClose) def OnClose(self, event): # Remember to destroy all CEF browser references before calling # Destroy(), so that browser closes cleanly. In this specific # example there are no references kept, but keep this in mind # for the future. self.Destroy() # On Mac the code after app.MainLoop() never executes, so # need to call CEF shutdown here. if platform.system() == "Darwin": chrome.Shutdown() wx.GetApp().Exit() class CustomNavigationBar(chrome.NavigationBar): def _LayoutComponents(self): sizer = wx.BoxSizer(wx.HORIZONTAL) sizer.Add(self.url, 1, wx.EXPAND|wx.ALIGN_CENTER_VERTICAL|wx.ALL, 12) sizer.Add(self.GetBackButton(), 0, wx.ALIGN_LEFT|wx.ALIGN_CENTER_VERTICAL| wx.ALL, 0) sizer.Add(self.GetForwardButton(), 0, wx.ALIGN_LEFT|wx.ALIGN_CENTER_VERTICAL| wx.ALL, 0) # in this example we dont want reload button self.GetReloadButton().Hide() self.SetSizer(sizer) self.Fit() class MyApp(wx.App): def OnInit(self): frame = MainFrame() self.SetTopWindow(frame) frame.Show() return True if __name__ == '__main__': chrome.Initialize() print('sample3.py: wx.version=%s' % wx.version()) app = MyApp() app.MainLoop() # Important: do the wx cleanup before calling Shutdown del app # On Mac Shutdown is called in OnClose if platform.system() in ["Linux", "Windows"]: chrome.Shutdown() cefpython-49.0/src/cefpython3.wx/images/000077500000000000000000000000001334103266300202215ustar00rootroot00000000000000cefpython-49.0/src/cefpython3.wx/images/back.png000066400000000000000000000025041334103266300216300ustar00rootroot00000000000000PNG  IHDRĴl;bKGD pHYs ,tIME 4ٸIDATxڍۋ\U{Oթ[Wv3t0J 3 C-,B<"/ DP$q=L NtWwUr.{IO4`}ǷYk)~JG $")@]6]wa'A(L;#M`^Ò{R? .y9NMx|szͲjFSFoT*;A:OdٷCx$opTN吓!__'M{ÓwΏ|z>sqt}JhDeNõLVj*˾o깲3 >6yw[1榓|tζ-Q$[ ٔQa fsp{rەK* |O=R$i݈\DU8{KԈ9=H!-=mU,@Y =WuA9)t"2!͞el?hvő= K}(@'|eɺwa%*~ieԝ 5;|rv_~1x_\+PI4r ll|.!lo8p}X\ 1 $i[ƶk<59R]xΆs߃7#cmQd6FILҍԭr^nvnUߏK 򗱴g,2\Zxl[XeK2`,B^Hڄծ8Yw-?$*']r!i?I&i/$mh&U!7o?٧>~9jU~Uz(;;*P$0 bk#v|MF' #$\Arym֙‰\BϔL.3ݏf)֬]PoGxsƁV-Wg&sNj`Rěj*ʩF]fεNjtt#]\ Db=Nl2_8qZT*/ȑ#G4>_GkUCۚr2^t44zA+3*qj%Hr^ns@T*{/{hRhIENDB`cefpython-49.0/src/cefpython3.wx/images/forward.png000066400000000000000000000024371334103266300224010ustar00rootroot00000000000000PNG  IHDRĴl;bKGD pHYs ,tIME 'VnIDATxڍk\E?4IhMZ[FRPQUA "*U" W b5X4mif{􇶶/3g>s93l^MlkSvnVt<~E<0"Ltd?GO/j$[CW_|fGxw*"A+A&wݞ;ٶa]Dv|\H](2^PA<=:Vd ¶6$Rpo1?-ӡr\_un@ў!Tw擃%)hJ:ܻ1ɑ5rkFKsn&웉7̄*6rψ,DZHgV:woH%%CZOGG55$Z˲s"$]ޝ|vloRkŭ5Q,j!9AeH'$J),R]L:ʕ_>o4Y̓l5nl,o'Og1g`!!&a:"LAO:u+ ^A |`g}Srj Viڽ 0iky4aw 8}x壇#%T'J RmVa:??Q|[rOȧ=&K ! S(PJ"858{mhuxҞ(t6|t⹒\%J4p X͑h^(V2P~PW;_]t8yh]՝&&7[ qbKZ&?vXk&s[zʬ|]- R*CA2[3MsRD)ɕ%bՍi0 *+r"[0צ密tR^bVB>;urnB3( }Q9,B֦J 6dLGIÔw>jFw슬J,sdH֓&4}q@YWs<2SȻ ]9xn4cxwx=,0UvxZܾmB䄡tХ޳<=|Z J%G' fB69 0`Q,Ւމ]1Uv¡>R䞫ST!~06$lbzodEY:]~Fs`F7z+!#!)ݴVU̅,W7S {۟&lW<`5q8_N  ^>I|DuQZFBPpF ;~VVV[?[#lz6PΤXri=KhR֛ o|t}V_sa-b8Yh3_N;ʌ^ ķVoGs_6"oFflg.\Ǭ6b8e OvBRSnekz?JJyɒJ\G*|ngzl6O_[Vwpa[Re>*%sQeTrHjZϿKka?S_x6$KKK/%P\ #pragma comment(lib, "Shell32.lib") #include "dpi_aware.h" #elif defined(OS_LINUX) #include #include #endif // OS_WIN // ---------------------------------------------------------------------------- // CefClient // ---------------------------------------------------------------------------- bool ClientHandler::OnProcessMessageReceived( CefRefPtr browser, CefProcessId source_process, CefRefPtr message) { if (source_process != PID_RENDERER) { return false; } std::string messageName = message->GetName().ToString(); std::string logMessage = "[Browser process] OnProcessMessageReceived(): "; logMessage.append(messageName.c_str()); LOG(INFO) << logMessage.c_str(); if (messageName == "OnContextCreated") { CefRefPtr arguments = message->GetArgumentList(); if (arguments->GetSize() == 1 && arguments->GetType(0) == VTYPE_INT) { int64 frameId = arguments->GetInt(0); CefRefPtr frame = browser->GetFrame(frameId); V8ContextHandler_OnContextCreated(browser, frame); return true; } else { LOG(ERROR) << "[Browser process] OnProcessMessageReceived():" " invalid arguments, messageName=OnContextCreated"; return false; } } else if (messageName == "OnContextReleased") { CefRefPtr arguments = message->GetArgumentList(); if (arguments->GetSize() == 2 \ && arguments->GetType(0) == VTYPE_INT \ && arguments->GetType(1) == VTYPE_INT) { int browserId = arguments->GetInt(0); int64 frameId = arguments->GetInt(1); V8ContextHandler_OnContextReleased(browserId, frameId); return true; } else { LOG(ERROR) << "[Browser process] OnProcessMessageReceived():" " invalid arguments, messageName=OnContextReleased"; return false; } } else if (messageName == "V8FunctionHandler::Execute") { CefRefPtr arguments = message->GetArgumentList(); if (arguments->GetSize() == 3 // frameId && arguments->GetType(0) == VTYPE_INT // functionName && arguments->GetType(1) == VTYPE_STRING // functionArguments && arguments->GetType(2) == VTYPE_LIST) { int64 frameId = arguments->GetInt(0); CefString functionName = arguments->GetString(1); CefRefPtr functionArguments = arguments->GetList(2); CefRefPtr frame = browser->GetFrame(frameId); V8FunctionHandler_Execute(browser, frame, functionName, functionArguments); return true; } else { LOG(ERROR) << "[Browser process] OnProcessMessageReceived():" " invalid arguments," " messageName=V8FunctionHandler::Execute"; return false; } } else if (messageName == "ExecutePythonCallback") { CefRefPtr arguments = message->GetArgumentList(); if (arguments->GetSize() == 2 && arguments->GetType(0) == VTYPE_INT // callbackId && arguments->GetType(1) == VTYPE_LIST) { // functionArguments int callbackId = arguments->GetInt(0); CefRefPtr functionArguments = arguments->GetList(1); ExecutePythonCallback(browser, callbackId, functionArguments); return true; } else { LOG(ERROR) << "[Browser process] OnProcessMessageReceived():" " invalid arguments," " messageName=ExecutePythonCallback"; return false; } } else if (messageName == "RemovePythonCallbacksForFrame") { CefRefPtr arguments = message->GetArgumentList(); if (arguments->GetSize() == 1 && arguments->GetType(0) == VTYPE_INT) { int frameId = arguments->GetInt(0); RemovePythonCallbacksForFrame(frameId); return true; } else { LOG(ERROR) << "[Browser process] OnProcessMessageReceived():" " invalid arguments," " messageName=ExecutePythonCallback"; return false; } } return false; } cefpython-49.0/src/client_handler/client_handler.h000066400000000000000000000053041334103266300223360ustar00rootroot00000000000000// Copyright (c) 2012 CEF Python, see the Authors file. // All rights reserved. Licensed under BSD 3-clause license. // Project website: https://github.com/cztomczak/cefpython // ClientHandler code is running only in the Browser process. #pragma once #if defined(_WIN32) #include #endif #include "context_menu_handler.h" #include "dialog_handler.h" #include "display_handler.h" #include "download_handler.h" #include "focus_handler.h" #include "js_dialog_handler.h" #include "keyboard_handler.h" #include "lifespan_handler.h" #include "load_handler.h" #include "render_handler.h" #include "request_handler.h" class DevToolsClientHandler : public CefClient { public: DevToolsClientHandler(){} virtual ~DevToolsClientHandler(){} private: IMPLEMENT_REFCOUNTING(DevToolsClientHandler); }; class ClientHandler : public CefClient, public ContextMenuHandler, public DialogHandler, public DisplayHandler, public DownloadHandler, public FocusHandler, public JSDialogHandler, public KeyboardHandler, public LifespanHandler, public LoadHandler, public RenderHandler, public RequestHandler { public: ClientHandler(){} virtual ~ClientHandler(){} CefRefPtr GetContextMenuHandler() override { return this; } #if defined(OS_LINUX) CefRefPtr GetDialogHandler() override { return this; } #endif CefRefPtr GetDisplayHandler() override { return this; } CefRefPtr GetDownloadHandler() override { return this; } CefRefPtr GetFocusHandler() override { return this; } CefRefPtr GetJSDialogHandler() override { return this; } CefRefPtr GetKeyboardHandler() override { return this; } CefRefPtr GetLifeSpanHandler() override { return this; } CefRefPtr GetLoadHandler() override { return this; } CefRefPtr GetRenderHandler() override { return this; } CefRefPtr GetRequestHandler() override { return this; } bool OnProcessMessageReceived(CefRefPtr browser, CefProcessId source_process, CefRefPtr message ) override; private: IMPLEMENT_REFCOUNTING(ClientHandler); }; cefpython-49.0/src/client_handler/context_menu_handler.cpp000066400000000000000000000130621334103266300241230ustar00rootroot00000000000000// Copyright (c) 2016 CEF Python, see the Authors file. // All rights reserved. Licensed under BSD 3-clause license. // Project website: https://github.com/cztomczak/cefpython #include "context_menu_handler.h" #include "include/base/cef_logging.h" #define _MENU_ID_DEVTOOLS MENU_ID_USER_FIRST + 1 #define _MENU_ID_RELOAD_PAGE MENU_ID_USER_FIRST + 2 #define _MENU_ID_OPEN_PAGE_IN_EXTERNAL_BROWSER MENU_ID_USER_FIRST + 3 #define _MENU_ID_OPEN_FRAME_IN_EXTERNAL_BROWSER MENU_ID_USER_FIRST + 4 // Forward declarations void OpenInExternalBrowser(const std::string& url); void ContextMenuHandler::OnBeforeContextMenu( CefRefPtr browser, CefRefPtr frame, CefRefPtr params, CefRefPtr model) { bool enabled = ApplicationSettings_GetBoolFromDict( "context_menu", "enabled"); bool navigation = ApplicationSettings_GetBoolFromDict( "context_menu", "navigation"); bool print = ApplicationSettings_GetBoolFromDict( "context_menu", "print"); bool view_source = ApplicationSettings_GetBoolFromDict( "context_menu", "view_source"); bool external_browser = ApplicationSettings_GetBoolFromDict( "context_menu", "external_browser"); bool devtools = ApplicationSettings_GetBoolFromDict( "context_menu", "devtools"); if (!enabled) { model->Clear(); return; } if (!navigation && model->IsVisible(MENU_ID_BACK) && model->IsVisible(MENU_ID_FORWARD)) { model->Remove(MENU_ID_BACK); model->Remove(MENU_ID_FORWARD); // Remove separator if (model->GetTypeAt(0) == MENUITEMTYPE_SEPARATOR) { model->RemoveAt(0); } } if (!print) { model->Remove(MENU_ID_PRINT); } if (!view_source) { model->Remove(MENU_ID_VIEW_SOURCE); } if (!params->IsEditable() && params->GetSelectionText().empty() && (params->GetPageUrl().length() || params->GetFrameUrl().length())) { if (external_browser) { model->AddItem(_MENU_ID_OPEN_PAGE_IN_EXTERNAL_BROWSER, "Open in external browser"); if (params->GetFrameUrl().length() && params->GetPageUrl() != params->GetFrameUrl()) { model->AddItem(_MENU_ID_OPEN_FRAME_IN_EXTERNAL_BROWSER, "Open frame in external browser"); } } if (navigation) { model->InsertItemAt(2, _MENU_ID_RELOAD_PAGE, "Reload"); } if (devtools) { model->AddSeparator(); model->AddItem(_MENU_ID_DEVTOOLS, "Developer Tools"); } } } bool ContextMenuHandler::OnContextMenuCommand( CefRefPtr browser, CefRefPtr frame, CefRefPtr params, int command_id, EventFlags event_flags) { if (command_id == _MENU_ID_OPEN_PAGE_IN_EXTERNAL_BROWSER) { #if defined(OS_WIN) ShellExecuteA(0, "open", params->GetPageUrl().ToString().c_str(), 0, 0, SW_SHOWNORMAL); #elif defined(OS_LINUX) OpenInExternalBrowser(params->GetPageUrl().ToString()); #endif // OS_WIN return true; } else if (command_id == _MENU_ID_OPEN_FRAME_IN_EXTERNAL_BROWSER) { #if defined(OS_WIN) ShellExecuteA(0, "open", params->GetFrameUrl().ToString().c_str(), 0, 0, SW_SHOWNORMAL); #elif defined(OS_LINUX) OpenInExternalBrowser(params->GetFrameUrl().ToString()); #endif // OS_WIN return true; } else if (command_id == _MENU_ID_RELOAD_PAGE) { browser->ReloadIgnoreCache(); return true; } else if (command_id == _MENU_ID_DEVTOOLS) { PyBrowser_ShowDevTools(browser); return true; } return false; } void ContextMenuHandler::OnContextMenuDismissed(CefRefPtr browser, CefRefPtr frame) { // PASS } // ---------------------------------------------------------------------------- // Context menu utility functions // ---------------------------------------------------------------------------- #if defined(OS_LINUX) void OpenInExternalBrowser(const std::string& url) { // Linux equivalent of ShellExecute if (url.empty()) { LOG(ERROR) << "[Browser process] OpenInExternalBrowser():" " url is empty"; return; } std::string msg = "[Browser process] OpenInExternalBrowser(): url="; msg.append(url.c_str()); LOG(INFO) << msg.c_str(); // xdg-open is a desktop-independent tool for running // default applications. Installed by default on Ubuntu. // xdg-open process is running in the backround until // cefpython app closes. std::string prog = "xdg-open"; // Using system() opens up for bugs and exploits, not // recommended. // Fork yourself and run in parallel, do not block the // current proces. char *args[3]; args[0] = (char*) prog.c_str(); args[1] = (char*) url.c_str(); args[2] = 0; pid_t pid = fork(); if (!pid) { execvp(prog.c_str(), args); } } #endif cefpython-49.0/src/client_handler/context_menu_handler.h000066400000000000000000000022601334103266300235660ustar00rootroot00000000000000// Copyright (c) 2016 CEF Python, see the Authors file. // All rights reserved. Licensed under BSD 3-clause license. // Project website: https://github.com/cztomczak/cefpython #pragma once #include "common/cefpython_public_api.h" #include "include/cef_context_menu_handler.h" class ContextMenuHandler : public CefContextMenuHandler { public: ContextMenuHandler(){} virtual ~ContextMenuHandler(){} typedef cef_event_flags_t EventFlags; void OnBeforeContextMenu(CefRefPtr browser, CefRefPtr frame, CefRefPtr params, CefRefPtr model) override; bool OnContextMenuCommand(CefRefPtr browser, CefRefPtr frame, CefRefPtr params, int command_id, EventFlags event_flags) override; void OnContextMenuDismissed(CefRefPtr browser, CefRefPtr frame) override; private: IMPLEMENT_REFCOUNTING(ContextMenuHandler); }; cefpython-49.0/src/client_handler/cookie_visitor.cpp000066400000000000000000000007501334103266300227460ustar00rootroot00000000000000// Copyright (c) 2014 CEF Python, see the Authors file. // All rights reserved. Licensed under BSD 3-clause license. // Project website: https://github.com/cztomczak/cefpython #include "cookie_visitor.h" #include bool CookieVisitor::Visit( const CefCookie& cookie, int count, int total, bool& deleteCookie ) { REQUIRE_IO_THREAD(); return CookieVisitor_Visit(cookieVisitorId_, cookie, count, total, deleteCookie); } cefpython-49.0/src/client_handler/cookie_visitor.h000066400000000000000000000012601334103266300224100ustar00rootroot00000000000000// Copyright (c) 2014 CEF Python, see the Authors file. // All rights reserved. Licensed under BSD 3-clause license. // Project website: https://github.com/cztomczak/cefpython #pragma once #if defined(_WIN32) #include #endif #include "common/cefpython_public_api.h" class CookieVisitor : public CefCookieVisitor { public: int cookieVisitorId_; public: CookieVisitor(int cookieVisitorId) : cookieVisitorId_(cookieVisitorId) { } virtual bool Visit( const CefCookie& cookie, int count, int total, bool& deleteCookie ) OVERRIDE; protected: IMPLEMENT_REFCOUNTING(CookieVisitor); }; cefpython-49.0/src/client_handler/deprecated/000077500000000000000000000000001334103266300213105ustar00rootroot00000000000000cefpython-49.0/src/client_handler/deprecated/deprecated_client_handler_py27_64bit.vcproj000066400000000000000000000112351334103266300315630ustar00rootroot00000000000000 cefpython-49.0/src/client_handler/deprecated/deprecated_client_handler_py27_win32.vcproj000066400000000000000000000112721334103266300315760ustar00rootroot00000000000000 cefpython-49.0/src/client_handler/deprecated/deprecated_client_handler_py34_32bit.vcproj000066400000000000000000000073371334103266300315640ustar00rootroot00000000000000 cefpython-49.0/src/client_handler/dialog_handler.cpp000066400000000000000000000024131334103266300226500ustar00rootroot00000000000000// Copyright (c) 2017 CEF Python, see the Authors file. // All rights reserved. Licensed under BSD 3-clause license. // Project website: https://github.com/cztomczak/cefpython #include "dialog_handler.h" DialogHandler::DialogHandler() { #if defined(OS_LINUX) // Provide the GTK-based default dialog implementation on Linux. dialog_handler_ = new ClientDialogHandlerGtk(); #endif } bool DialogHandler::OnFileDialog(CefRefPtr browser, FileDialogMode mode, const CefString& title, const CefString& default_file_path, const std::vector& accept_filters, int selected_accept_filter, CefRefPtr callback) { #if defined(OS_LINUX) return dialog_handler_->OnFileDialog(browser, mode, title, default_file_path, accept_filters, selected_accept_filter, callback); #else return false; #endif } cefpython-49.0/src/client_handler/dialog_handler.h000066400000000000000000000020341334103266300223140ustar00rootroot00000000000000// Copyright (c) 2017 CEF Python, see the Authors file. // All rights reserved. Licensed under BSD 3-clause license. // Project website: https://github.com/cztomczak/cefpython #pragma once #include "common/cefpython_public_api.h" #include "include/cef_dialog_handler.h" #if defined(OS_LINUX) #include "dialog_handler_gtk.h" #endif class DialogHandler : public CefDialogHandler { public: DialogHandler(); virtual ~DialogHandler(){} bool OnFileDialog(CefRefPtr browser, FileDialogMode mode, const CefString& title, const CefString& default_file_path, const std::vector& accept_filters, int selected_accept_filter, CefRefPtr callback) override; public: #if defined(OS_LINUX) // Default dialog handler impl for GTK. CefRefPtr dialog_handler_; #endif private: IMPLEMENT_REFCOUNTING(DialogHandler); }; cefpython-49.0/src/client_handler/dialog_handler_gtk.cpp000066400000000000000000000344041334103266300235220ustar00rootroot00000000000000// Default dialog handler implementation on Linux. // Copied from upstream cefclient with changes: // - Rewrote GetWindow() func // - Removed "client" namespace // - Changed titles of JS alerts, removed URL and "Javascript" word // Copyright (c) 2015 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. #include #include #include #include #include #include "include/cef_browser.h" #include "include/cef_parser.h" #include "include/wrapper/cef_helpers.h" #include "include/base/cef_logging.h" #include "dialog_handler_gtk.h" #include "x11.h" namespace { const char kPromptTextId[] = "cef_prompt_text"; // If there's a text entry in the dialog, get the text from the first one and // return it. std::string GetPromptText(GtkDialog* dialog) { GtkWidget* widget = static_cast( g_object_get_data(G_OBJECT(dialog), kPromptTextId)); if (widget) return gtk_entry_get_text(GTK_ENTRY(widget)); return std::string(); } std::string GetDescriptionFromMimeType(const std::string& mime_type) { // Check for wild card mime types and return an appropriate description. static const struct { const char* mime_type; const char* label; } kWildCardMimeTypes[] = { { "audio", "Audio Files" }, { "image", "Image Files" }, { "text", "Text Files" }, { "video", "Video Files" }, }; for (size_t i = 0; i < sizeof(kWildCardMimeTypes) / sizeof(kWildCardMimeTypes[0]); ++i) { if (mime_type == std::string(kWildCardMimeTypes[i].mime_type) + "/*") return std::string(kWildCardMimeTypes[i].label); } return std::string(); } void AddFilters(GtkFileChooser* chooser, const std::vector& accept_filters, bool include_all_files, std::vector* filters) { bool has_filter = false; for (size_t i = 0; i < accept_filters.size(); ++i) { const std::string& filter = accept_filters[i]; if (filter.empty()) continue; std::vector extensions; std::string description; size_t sep_index = filter.find('|'); if (sep_index != std::string::npos) { // Treat as a filter of the form "Filter Name|.ext1;.ext2;.ext3". description = filter.substr(0, sep_index); const std::string& exts = filter.substr(sep_index + 1); size_t last = 0; size_t size = exts.size(); for (size_t i = 0; i <= size; ++i) { if (i == size || exts[i] == ';') { std::string ext(exts, last, i - last); if (!ext.empty() && ext[0] == '.') extensions.push_back(ext); last = i + 1; } } } else if (filter[0] == '.') { // Treat as an extension beginning with the '.' character. extensions.push_back(filter); } else { // Otherwise convert mime type to one or more extensions. description = GetDescriptionFromMimeType(filter); std::vector ext; CefGetExtensionsForMimeType(filter, ext); for (size_t x = 0; x < ext.size(); ++x) extensions.push_back("." + ext[x].ToString()); } if (extensions.empty()) continue; GtkFileFilter* gtk_filter = gtk_file_filter_new(); std::string ext_str; for (size_t x = 0; x < extensions.size(); ++x) { const std::string& pattern = "*" + extensions[x]; if (x != 0) ext_str += ";"; ext_str += pattern; gtk_file_filter_add_pattern(gtk_filter, pattern.c_str()); } if (description.empty()) description = ext_str; else description += " (" + ext_str + ")"; gtk_file_filter_set_name(gtk_filter, description.c_str()); gtk_file_chooser_add_filter(chooser, gtk_filter); if (!has_filter) has_filter = true; filters->push_back(gtk_filter); } // Add the *.* filter, but only if we have added other filters (otherwise it // is implied). if (include_all_files && has_filter) { GtkFileFilter* filter = gtk_file_filter_new(); gtk_file_filter_add_pattern(filter, "*"); gtk_file_filter_set_name(filter, "All Files (*)"); gtk_file_chooser_add_filter(chooser, filter); } } GtkWindow* GetWindow(CefRefPtr browser) { // -- REWRITTEN FOR CEF PYTHON USE CASE -- // X11 window handle ::Window xwindow = browser->GetHost()->GetWindowHandle(); // X11 display ::Display* xdisplay = cef_get_xdisplay(); // GDK display GdkDisplay* gdk_display = NULL; if (xdisplay) { // See if we can find GDK display using X11 display gdk_display = gdk_x11_lookup_xdisplay(xdisplay); } if (!gdk_display) { // If not then get the default display gdk_display = gdk_display_get_default(); } if (!gdk_display) { // The tkinter_.py and hello_world.py examples do not use GTK // internally, so GTK wasn't yet initialized and must do it // now, so that display is available. Also must install X11 // error handlers to avoid 'BadWindow' errors. LOG(INFO) << "[Browser process] Initialize GTK"; gtk_init(0, NULL); InstallX11ErrorHandlers(); // Now the display is available gdk_display = gdk_display_get_default(); } // In kivy_.py example getting error message: // > Can't create GtkPlug as child of non-GtkSocket // However dialog handler works just fine. GtkWidget* widget = gtk_plug_new_for_display(gdk_display, xwindow); // Getting top level widget doesn't seem to be required. // OFF: GtkWidget* toplevel = gtk_widget_get_toplevel(widget); GtkWindow* window = GTK_WINDOW(widget); if (!window) { LOG(ERROR) << "No GtkWindow for browser"; } return window; } } // namespace ClientDialogHandlerGtk::ClientDialogHandlerGtk() : gtk_dialog_(NULL) { } bool ClientDialogHandlerGtk::OnFileDialog( CefRefPtr browser, FileDialogMode mode, const CefString& title, const CefString& default_file_path, const std::vector& accept_filters, int selected_accept_filter, CefRefPtr callback) { std::vector files; GtkFileChooserAction action; const gchar* accept_button; // Remove any modifier flags. FileDialogMode mode_type = static_cast(mode & FILE_DIALOG_TYPE_MASK); if (mode_type == FILE_DIALOG_OPEN || mode_type == FILE_DIALOG_OPEN_MULTIPLE) { action = GTK_FILE_CHOOSER_ACTION_OPEN; accept_button = GTK_STOCK_OPEN; } else if (mode_type == FILE_DIALOG_OPEN_FOLDER) { action = GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER; accept_button = GTK_STOCK_OPEN; } else if (mode_type == FILE_DIALOG_SAVE) { action = GTK_FILE_CHOOSER_ACTION_SAVE; accept_button = GTK_STOCK_SAVE; } else { NOTREACHED(); return false; } std::string title_str; if (!title.empty()) { title_str = title; } else { switch (mode_type) { case FILE_DIALOG_OPEN: title_str = "Open File"; break; case FILE_DIALOG_OPEN_MULTIPLE: title_str = "Open Files"; break; case FILE_DIALOG_OPEN_FOLDER: title_str = "Open Folder"; break; case FILE_DIALOG_SAVE: title_str = "Save File"; break; default: break; } } GtkWindow* window = GetWindow(browser); if (!window) return false; GtkWidget* dialog = gtk_file_chooser_dialog_new( title_str.c_str(), GTK_WINDOW(window), action, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, accept_button, GTK_RESPONSE_ACCEPT, NULL); if (mode_type == FILE_DIALOG_OPEN_MULTIPLE) gtk_file_chooser_set_select_multiple(GTK_FILE_CHOOSER(dialog), TRUE); if (mode_type == FILE_DIALOG_SAVE) { gtk_file_chooser_set_do_overwrite_confirmation( GTK_FILE_CHOOSER(dialog), !!(mode & FILE_DIALOG_OVERWRITEPROMPT_FLAG)); } gtk_file_chooser_set_show_hidden(GTK_FILE_CHOOSER(dialog), !(mode & FILE_DIALOG_HIDEREADONLY_FLAG)); if (!default_file_path.empty() && mode_type == FILE_DIALOG_SAVE) { const std::string& file_path = default_file_path; bool exists = false; struct stat sb; if (stat(file_path.c_str(), &sb) == 0 && S_ISREG(sb.st_mode)) { // Use the directory and name of the existing file. gtk_file_chooser_set_filename(GTK_FILE_CHOOSER(dialog), file_path.data()); exists = true; } if (!exists) { // Set the current file name but let the user choose the directory. std::string file_name_str = file_path; const char* file_name = basename(const_cast(file_name_str.data())); gtk_file_chooser_set_current_name(GTK_FILE_CHOOSER(dialog), file_name); } } std::vector filters; AddFilters(GTK_FILE_CHOOSER(dialog), accept_filters, true, &filters); if (selected_accept_filter < static_cast(filters.size())) { gtk_file_chooser_set_filter(GTK_FILE_CHOOSER(dialog), filters[selected_accept_filter]); } bool success = false; if (gtk_dialog_run(GTK_DIALOG(dialog)) == GTK_RESPONSE_ACCEPT) { if (mode_type == FILE_DIALOG_OPEN || mode_type == FILE_DIALOG_OPEN_FOLDER || mode_type == FILE_DIALOG_SAVE) { char* filename = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(dialog)); files.push_back(std::string(filename)); success = true; } else if (mode_type == FILE_DIALOG_OPEN_MULTIPLE) { GSList* filenames = gtk_file_chooser_get_filenames(GTK_FILE_CHOOSER(dialog)); if (filenames) { for (GSList* iter = filenames; iter != NULL; iter = g_slist_next(iter)) { std::string path(static_cast(iter->data)); g_free(iter->data); files.push_back(path); } g_slist_free(filenames); success = true; } } } int filter_index = selected_accept_filter; if (success) { GtkFileFilter* selected_filter = gtk_file_chooser_get_filter(GTK_FILE_CHOOSER(dialog)); if (selected_filter != NULL) { for (size_t x = 0; x < filters.size(); ++x) { if (filters[x] == selected_filter) { filter_index = x; break; } } } } gtk_widget_destroy(dialog); if (success) callback->Continue(filter_index, files); else callback->Cancel(); return true; } bool ClientDialogHandlerGtk::OnJSDialog( CefRefPtr browser, const CefString& origin_url, JSDialogType dialog_type, const CefString& message_text, const CefString& default_prompt_text, CefRefPtr callback, bool& suppress_message) { CEF_REQUIRE_UI_THREAD(); GtkButtonsType buttons = GTK_BUTTONS_NONE; GtkMessageType gtk_message_type = GTK_MESSAGE_OTHER; std::string title; switch (dialog_type) { case JSDIALOGTYPE_ALERT: buttons = GTK_BUTTONS_NONE; gtk_message_type = GTK_MESSAGE_WARNING; title = "Alert"; break; case JSDIALOGTYPE_CONFIRM: buttons = GTK_BUTTONS_CANCEL; gtk_message_type = GTK_MESSAGE_QUESTION; title = "Confirm"; break; case JSDIALOGTYPE_PROMPT: buttons = GTK_BUTTONS_CANCEL; gtk_message_type = GTK_MESSAGE_QUESTION; title = "Prompt"; break; } js_dialog_callback_ = callback; if (!origin_url.empty()) { // title += " - "; // title += CefFormatUrlForSecurityDisplay(origin_url).ToString(); } GtkWindow* window = GetWindow(browser); if (!window) return false; gtk_dialog_ = gtk_message_dialog_new(GTK_WINDOW(window), GTK_DIALOG_MODAL, gtk_message_type, buttons, "%s", message_text.ToString().c_str()); g_signal_connect(gtk_dialog_, "delete-event", G_CALLBACK(gtk_widget_hide_on_delete), NULL); gtk_window_set_title(GTK_WINDOW(gtk_dialog_), title.c_str()); GtkWidget* ok_button = gtk_dialog_add_button(GTK_DIALOG(gtk_dialog_), GTK_STOCK_OK, GTK_RESPONSE_OK); if (dialog_type != JSDIALOGTYPE_PROMPT) gtk_widget_grab_focus(ok_button); if (dialog_type == JSDIALOGTYPE_PROMPT) { GtkWidget* content_area = gtk_dialog_get_content_area(GTK_DIALOG(gtk_dialog_)); GtkWidget* text_box = gtk_entry_new(); gtk_entry_set_text(GTK_ENTRY(text_box), default_prompt_text.ToString().c_str()); gtk_box_pack_start(GTK_BOX(content_area), text_box, TRUE, TRUE, 0); g_object_set_data(G_OBJECT(gtk_dialog_), kPromptTextId, text_box); gtk_entry_set_activates_default(GTK_ENTRY(text_box), TRUE); } gtk_dialog_set_default_response(GTK_DIALOG(gtk_dialog_), GTK_RESPONSE_OK); g_signal_connect(gtk_dialog_, "response", G_CALLBACK(OnDialogResponse), this); gtk_widget_show_all(GTK_WIDGET(gtk_dialog_)); return true; } bool ClientDialogHandlerGtk::OnBeforeUnloadDialog( CefRefPtr browser, const CefString& message_text, bool is_reload, CefRefPtr callback) { CEF_REQUIRE_UI_THREAD(); const std::string& new_message_text = message_text.ToString() + "\n\nIs it OK to leave/reload this page?"; bool suppress_message = false; return OnJSDialog(browser, CefString(), JSDIALOGTYPE_CONFIRM, new_message_text, CefString(), callback, suppress_message); } void ClientDialogHandlerGtk::OnResetDialogState(CefRefPtr browser) { CEF_REQUIRE_UI_THREAD(); if (!gtk_dialog_) return; gtk_widget_destroy(gtk_dialog_); gtk_dialog_ = NULL; js_dialog_callback_ = NULL; } // static void ClientDialogHandlerGtk::OnDialogResponse(GtkDialog* dialog, gint response_id, ClientDialogHandlerGtk* handler) { CEF_REQUIRE_UI_THREAD(); DCHECK_EQ(dialog, GTK_DIALOG(handler->gtk_dialog_)); switch (response_id) { case GTK_RESPONSE_OK: handler->js_dialog_callback_->Continue(true, GetPromptText(dialog)); break; case GTK_RESPONSE_CANCEL: case GTK_RESPONSE_DELETE_EVENT: handler->js_dialog_callback_->Continue(false, CefString()); break; default: NOTREACHED(); } handler->OnResetDialogState(NULL); } cefpython-49.0/src/client_handler/dialog_handler_gtk.h000066400000000000000000000042051334103266300231630ustar00rootroot00000000000000// Default dialog handler implementation on Linux. // Copied from upstream cefclient with changes: // - Removed "client" namespace // Copyright (c) 2015 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. #ifndef CEF_TESTS_CEFCLIENT_BROWSER_DIALOG_HANDLER_GTK_H_ #define CEF_TESTS_CEFCLIENT_BROWSER_DIALOG_HANDLER_GTK_H_ #pragma once #include #include "include/cef_dialog_handler.h" #include "include/cef_jsdialog_handler.h" class ClientDialogHandlerGtk : public CefDialogHandler, public CefJSDialogHandler { public: ClientDialogHandlerGtk(); // CefDialogHandler methods. bool OnFileDialog(CefRefPtr browser, FileDialogMode mode, const CefString& title, const CefString& default_file_path, const std::vector& accept_filters, int selected_accept_filter, CefRefPtr callback) OVERRIDE; // CefJSDialogHandler methods. bool OnJSDialog(CefRefPtr browser, const CefString& origin_url, JSDialogType dialog_type, const CefString& message_text, const CefString& default_prompt_text, CefRefPtr callback, bool& suppress_message) OVERRIDE; bool OnBeforeUnloadDialog( CefRefPtr browser, const CefString& message_text, bool is_reload, CefRefPtr callback) OVERRIDE; void OnResetDialogState(CefRefPtr browser) OVERRIDE; private: static void OnDialogResponse(GtkDialog *dialog, gint response_id, ClientDialogHandlerGtk* handler); GtkWidget* gtk_dialog_; CefRefPtr js_dialog_callback_; IMPLEMENT_REFCOUNTING(ClientDialogHandlerGtk); DISALLOW_COPY_AND_ASSIGN(ClientDialogHandlerGtk); }; #endif // CEF_TESTS_CEFCLIENT_BROWSER_DIALOG_HANDLER_GTK_H_ cefpython-49.0/src/client_handler/display_handler.cpp000066400000000000000000000026371334103266300230660ustar00rootroot00000000000000// Copyright (c) 2012 CEF Python, see the Authors file. // All rights reserved. Licensed under BSD 3-clause license. // Project website: https://github.com/cztomczak/cefpython #include "display_handler.h" void DisplayHandler::OnAddressChange(CefRefPtr browser, CefRefPtr frame, const CefString& url) { REQUIRE_UI_THREAD(); DisplayHandler_OnAddressChange(browser, frame, url); } void DisplayHandler::OnTitleChange(CefRefPtr browser, const CefString& title) { REQUIRE_UI_THREAD(); DisplayHandler_OnTitleChange(browser, title); } bool DisplayHandler::OnTooltip(CefRefPtr browser, CefString& text) { REQUIRE_UI_THREAD(); return DisplayHandler_OnTooltip(browser, text); } void DisplayHandler::OnStatusMessage(CefRefPtr browser, const CefString& value) { REQUIRE_UI_THREAD(); DisplayHandler_OnStatusMessage(browser, value); } bool DisplayHandler::OnConsoleMessage(CefRefPtr browser, const CefString& message, const CefString& source, int line) { REQUIRE_UI_THREAD(); return DisplayHandler_OnConsoleMessage(browser, message, source, line); } cefpython-49.0/src/client_handler/display_handler.h000066400000000000000000000021661334103266300225300ustar00rootroot00000000000000// Copyright (c) 2012 CEF Python, see the Authors file. // All rights reserved. Licensed under BSD 3-clause license. // Project website: https://github.com/cztomczak/cefpython #pragma once #include "common/cefpython_public_api.h" #include "include/cef_display_handler.h" class DisplayHandler : public CefDisplayHandler { public: DisplayHandler(){} virtual ~DisplayHandler(){} void OnAddressChange(CefRefPtr browser, CefRefPtr frame, const CefString& url) override; void OnTitleChange(CefRefPtr browser, const CefString& title) override; bool OnTooltip(CefRefPtr browser, CefString& text) override; void OnStatusMessage(CefRefPtr browser, const CefString& value) override; bool OnConsoleMessage(CefRefPtr browser, const CefString& message, const CefString& source, int line) override; private: IMPLEMENT_REFCOUNTING(DisplayHandler); }; cefpython-49.0/src/client_handler/download_handler.cpp000066400000000000000000000031731334103266300232240ustar00rootroot00000000000000// Copyright (c) 2014 CEF Python, see the Authors file. // All rights reserved. Licensed under BSD 3-clause license. // Project website: https://github.com/cztomczak/cefpython #include "download_handler.h" #include "include/base/cef_logging.h" void DownloadHandler::OnBeforeDownload( CefRefPtr browser, CefRefPtr download_item, const CefString& suggested_name, CefRefPtr callback) { REQUIRE_UI_THREAD(); bool downloads_enabled = ApplicationSettings_GetBool("downloads_enabled"); if (downloads_enabled) { std::string msg = "[Browser process] About to download file: "; msg.append(suggested_name.ToString().c_str()); LOG(INFO) << msg.c_str(); callback->Continue(suggested_name, true); } else { LOG(INFO) << "[Browser process] Tried to download file," " but downloads are disabled"; } } void DownloadHandler::OnDownloadUpdated( CefRefPtr browser, CefRefPtr download_item, CefRefPtr callback) { REQUIRE_UI_THREAD(); if (download_item->IsComplete()) { std::string msg = "[Browser process] Download completed, saved to: "; msg.append(download_item->GetFullPath().ToString().c_str()); LOG(INFO) << msg.c_str(); } else if (download_item->IsCanceled()) { LOG(INFO) << "[Browser process] Download was cancelled"; } } cefpython-49.0/src/client_handler/download_handler.h000066400000000000000000000017111334103266300226650ustar00rootroot00000000000000// Copyright (c) 2014 CEF Python, see the Authors file. // All rights reserved. Licensed under BSD 3-clause license. // Project website: https://github.com/cztomczak/cefpython #include "common/cefpython_public_api.h" #include "include/cef_download_handler.h" class DownloadHandler : public CefDownloadHandler { public: DownloadHandler(){} virtual ~DownloadHandler(){} void OnBeforeDownload(CefRefPtr browser, CefRefPtr download_item, const CefString& suggested_name, CefRefPtr callback ) override; void OnDownloadUpdated(CefRefPtr browser, CefRefPtr download_item, CefRefPtr callback ) override; private: IMPLEMENT_REFCOUNTING(DownloadHandler); }; cefpython-49.0/src/client_handler/dpi_aware.cpp000066400000000000000000000222021334103266300216450ustar00rootroot00000000000000// Copyright (c) 2014 CEF Python, see the Authors file. // All rights reserved. Licensed under BSD 3-clause license. // Project website: https://github.com/cztomczak/cefpython // Windows only #pragma comment(lib, "Gdi32.lib") #include #include "dpi_aware.h" #include "include/wrapper/cef_closure_task.h" #include "include/base/cef_bind.h" #include "include/base/cef_logging.h" const int DEFAULT_DPIX = 96; bool IsProcessDpiAware() { typedef BOOL(WINAPI *IsProcessDPIAwarePtr)(VOID); IsProcessDPIAwarePtr is_process_dpi_aware_func = reinterpret_cast( GetProcAddress(GetModuleHandleA("user32.dll"), "IsProcessDPIAware")); BOOL is_aware = FALSE; if (is_process_dpi_aware_func) { is_aware = is_process_dpi_aware_func(); if (is_aware == TRUE) { return true; } } // GetProcessDpiAwareness is available only on Win8. So it // should be called only as a back-up plan after IsProcessDPIAware // was called. Also if IsProcessDPIAware returned false, // then GetProcessDpiAwareness is called as well. if (GetProcessDpiAwareness() != PROCESS_DPI_UNAWARE) { return true; } return false; } PROCESS_DPI_AWARENESS GetProcessDpiAwareness() { // Win8.1 supports monitor-specific DPI scaling, so it is // recommended to use GetProcessDPIAwareness instead of the // deprecated IsProcessDPIAware. typedef HRESULT(WINAPI *GetProcessDpiAwarenessPtr) (HANDLE,PROCESS_DPI_AWARENESS*); GetProcessDpiAwarenessPtr get_process_dpi_awareness_func = reinterpret_cast( GetProcAddress(GetModuleHandleA("user32.dll"), "GetProcessDpiAwarenessInternal")); if (get_process_dpi_awareness_func) { HANDLE hProcess = OpenProcess(PROCESS_ALL_ACCESS, false, GetCurrentProcessId()); PROCESS_DPI_AWARENESS result; HRESULT hr = get_process_dpi_awareness_func(hProcess, &result); if (SUCCEEDED(hr)) { return result; } // Possible failures include E_INVALIDARG or E_ACCESSDENIED. LOG(INFO) << "[Browser process] GetProcessDpiAwareness():" " hr=" << hr; } return PROCESS_DPI_UNAWARE; } void SetProcessDpiAware() { // Win8.1 supports monitor-specific DPI scaling, so it is // recommended to use SetProcessDPIAwareness instead of the // deprecated SetProcessDPIAware. SetProcessDpiAwareness is // only available on Win8. So as a back-up plan SetProcessDPIAware // is called. // If DPI aware manifest was embedded in executable, or // "Disable display scaling on high DPI settings" was checked // on the executable properties (Compatibility tab), then // DPI awareness is already set. /* What if GetProcessDpiAwareness returned PROCESS_PER_MONITOR_DPI_AWARE? The code below sets awareness to PROCESS_SYSTEM_DPI_AWARE, so it should be called either way. --OFF: if (IsProcessDpiAware()) { return; } */ typedef BOOL(WINAPI *SetProcessDpiAwarenessPtr)(PROCESS_DPI_AWARENESS); SetProcessDpiAwarenessPtr set_process_dpi_awareness_func = reinterpret_cast( GetProcAddress(GetModuleHandleA("user32.dll"), "SetProcessDpiAwarenessInternal")); if (set_process_dpi_awareness_func) { LOG(INFO) << "[Browser process] SetProcessDpiAware():" " calling user32.dll SetProcessDpiAwareness"; HRESULT hr = set_process_dpi_awareness_func(PROCESS_SYSTEM_DPI_AWARE); if (SUCCEEDED(hr)) { LOG(INFO) << "[Browser process]: SetBrowserDpiAware():" " SetProcessDpiAwareness succeeded"; return; } else if (hr == E_ACCESSDENIED) { LOG(ERROR) << "[Browser process] SetBrowserDpiAware():" " SetProcessDpiAwareness failed:" " The DPI awareness is already set, either by calling" " this API previously or through the application" " (.exe) manifest."; // Do not return here, let's try to call SetProcessDPIAware. } else { LOG(ERROR) << "[Browser process] SetBrowserDpiAware():" " SetProcessDpiAwareness failed"; // Do not return here, let's try to call SetProcessDPIAware. } } // SetProcessDpiAwareness not found in user32.dll or the call failed. typedef BOOL(WINAPI *SetProcessDPIAwarePtr)(VOID); SetProcessDPIAwarePtr set_process_dpi_aware_func = reinterpret_cast( GetProcAddress(GetModuleHandleA("user32.dll"), "SetProcessDPIAware")); if (set_process_dpi_aware_func) { // If cefpython.Initialize() wasn't yet called, then // this log message won't be written, as g_debug is // is set during CEF initialization. LOG(INFO) << "[Browser process] SetProcessDpiAware():" " calling user32.dll SetProcessDPIAware"; set_process_dpi_aware_func(); } } void GetSystemDpi(int* dpix, int* dpiy) { // Win7 DPI (Control Panel > Appearance and Personalization > Display): // text size Larger 150% => dpix/dpiy 144 // text size Medium 125% => dpix/dpiy 120 // text size Smaller 100% => dpix/dpiy 96 // // DPI settings should not be cached. When SetProcessDpiAware // is not yet called, then OS returns 96 DPI, even though it // is set to 144 DPI. After DPI Awareness is enabled for the // running process it will return the correct 144 DPI. HDC hdc = GetDC(HWND_DESKTOP); *dpix = GetDeviceCaps(hdc, LOGPIXELSX); *dpiy = GetDeviceCaps(hdc, LOGPIXELSY); ReleaseDC(HWND_DESKTOP, hdc); } void GetDpiAwareWindowSize(int* width, int* height) { int dpix = 0; int dpiy = 0; GetSystemDpi(&dpix, &dpiy); double newZoomLevel = 0.0; // 1. Using only "dpix" value to calculate zoom level. All // modern displays have equal horizontal and vertical resolution. // 2. Calculation for DPI < 96 is not yet supported (newZoomLevel<0.0). newZoomLevel = (dpix - DEFAULT_DPIX) / 24; if (newZoomLevel > 0.0) { *width = *width + (int)ceil(newZoomLevel * 0.25 * (*width)); *height = *height + (int)ceil(newZoomLevel * 0.25 * (*height)); LOG(INFO) << "[Browser process] GetDpiAwareWindowSize():" " enlarged by " << ceil(newZoomLevel * 0.25 * 100) << "%" " new size = " << *width << "/" << *height; } } void SetBrowserDpiSettings(CefRefPtr cefBrowser, CefString autoZooming) { // Setting zoom level immediately after browser was created // won't work. We need to wait a moment before we can set it. REQUIRE_UI_THREAD(); double oldZoomLevel = cefBrowser->GetHost()->GetZoomLevel(); double newZoomLevel = 0.0; int dpix = 0; int dpiy = 0; GetSystemDpi(&dpix, &dpiy); if (autoZooming.ToString() == "system_dpi") { // Using only "dpix" value to calculate zoom level. All // modern displays have equal horizontal/vertical resolution. // Examples: // dpix=96 zoom=0.0 // dpix=120 zoom=1.0 // dpix=144 zoom=2.0 // dpix=72 zoom=-1.0 newZoomLevel = (dpix - DEFAULT_DPIX) / 24; } else { // When atof() fails converting string to double, then // 0.0 is returned. newZoomLevel = atof(autoZooming.ToString().c_str()); } if (oldZoomLevel != newZoomLevel) { cefBrowser->GetHost()->SetZoomLevel(newZoomLevel); if (cefBrowser->GetHost()->GetZoomLevel() != oldZoomLevel) { // OK succes. LOG(INFO) << "[Browser process] SetBrowserDpiSettings():" " DPI=" << dpix << "" " zoom=" << cefBrowser->GetHost()->GetZoomLevel(); } } else { // This code block running can also be a result of executing // SetZoomLevel(), as GetZoomLevel() didn't return the new // value that was set. Documentation says that if SetZoomLevel // is called on the UI thread, then GetZoomLevel should // immediately return the same value that was set. Unfortunately // this seems not to be true. static bool already_logged = false; if (!already_logged) { already_logged = true; // OK success. LOG(INFO) << "[Browser process] SetBrowserDpiSettings():" " DPI=" << dpix << "" " zoom=" << cefBrowser->GetHost()->GetZoomLevel(); } } // We need to check zooming constantly, during loading of pages. // If we set zooming to 2.0 for localhost/ and then it navigates // to google.com, then the zomming is back at 0.0 and needs to // be set again. CefPostDelayedTask( TID_UI, CefCreateClosureTask( base::Bind(&SetBrowserDpiSettings, cefBrowser, autoZooming) ), 50 ); } cefpython-49.0/src/client_handler/dpi_aware.h000066400000000000000000000014121334103266300213120ustar00rootroot00000000000000// Copyright (c) 2014 CEF Python, see the Authors file. // All rights reserved. Licensed under BSD 3-clause license. // Project website: https://github.com/cztomczak/cefpython // Windows only #pragma once #include #include "include/cef_app.h" #include "util.h" // Duplicated from Win8.1 SDK ShellScalingApi.h typedef enum PROCESS_DPI_AWARENESS { PROCESS_DPI_UNAWARE = 0, PROCESS_SYSTEM_DPI_AWARE = 1, PROCESS_PER_MONITOR_DPI_AWARE = 2 } PROCESS_DPI_AWARENESS; bool IsProcessDpiAware(); PROCESS_DPI_AWARENESS GetProcessDpiAwareness(); void SetProcessDpiAware(); void GetSystemDpi(int* outx, int* outy); void GetDpiAwareWindowSize(int* width, int* height); void SetBrowserDpiSettings(CefRefPtr cefBrowser, CefString autoZooming); cefpython-49.0/src/client_handler/focus_handler.cpp000066400000000000000000000013141334103266300225270ustar00rootroot00000000000000// Copyright (c) 2016 CEF Python, see the Authors file. // All rights reserved. Licensed under BSD 3-clause license. // Project website: https://github.com/cztomczak/cefpython #include "focus_handler.h" void FocusHandler::OnTakeFocus(CefRefPtr browser, bool next) { REQUIRE_UI_THREAD(); FocusHandler_OnTakeFocus(browser, next); } bool FocusHandler::OnSetFocus(CefRefPtr browser, cef_focus_source_t source) { REQUIRE_UI_THREAD(); return FocusHandler_OnSetFocus(browser, source); } void FocusHandler::OnGotFocus(CefRefPtr browser) { REQUIRE_UI_THREAD(); FocusHandler_OnGotFocus(browser); } cefpython-49.0/src/client_handler/focus_handler.h000066400000000000000000000012541334103266300221770ustar00rootroot00000000000000// Copyright (c) 2016 CEF Python, see the Authors file. // All rights reserved. Licensed under BSD 3-clause license. // Project website: https://github.com/cztomczak/cefpython #include "common/cefpython_public_api.h" #include "include/cef_focus_handler.h" class FocusHandler : public CefFocusHandler { public: FocusHandler(){} virtual ~FocusHandler(){} void OnTakeFocus(CefRefPtr browser, bool next) override; bool OnSetFocus(CefRefPtr browser, cef_focus_source_t source) override; void OnGotFocus(CefRefPtr browser) override; private: IMPLEMENT_REFCOUNTING(FocusHandler); }; cefpython-49.0/src/client_handler/js_dialog_handler.cpp000066400000000000000000000055071334103266300233530ustar00rootroot00000000000000// Copyright (c) 2016 CEF Python, see the Authors file. // All rights reserved. Licensed under BSD 3-clause license. // Project website: https://github.com/cztomczak/cefpython #include "js_dialog_handler.h" JSDialogHandler::JSDialogHandler() { #if defined(OS_LINUX) // Provide the GTK-based default dialog implementation on Linux. dialog_handler_ = new ClientDialogHandlerGtk(); #endif } bool JSDialogHandler::OnJSDialog(CefRefPtr browser, const CefString& origin_url, const CefString& accept_lang, JSDialogType dialog_type, const CefString& message_text, const CefString& default_prompt_text, CefRefPtr callback, bool& suppress_message) { REQUIRE_UI_THREAD(); bool ret = JavascriptDialogHandler_OnJavascriptDialog( browser, origin_url, accept_lang, dialog_type, message_text, default_prompt_text, callback, suppress_message); #if defined(OS_LINUX) if (!ret) { // Default implementation return dialog_handler_->OnJSDialog(browser, origin_url, dialog_type, message_text, default_prompt_text, callback, suppress_message); } #endif return ret; } bool JSDialogHandler::OnBeforeUnloadDialog( CefRefPtr browser, const CefString& message_text, bool is_reload, CefRefPtr callback) { REQUIRE_UI_THREAD(); bool ret = JavascriptDialogHandler_OnBeforeUnloadJavascriptDialog( browser, message_text, is_reload, callback); #if defined(OS_LINUX) if (!ret) { // Default implementation return dialog_handler_->OnBeforeUnloadDialog(browser, message_text, is_reload, callback); } #endif return ret; } void JSDialogHandler::OnResetDialogState(CefRefPtr browser) { REQUIRE_UI_THREAD(); #if defined(OS_LINUX) // Default implementation dialog_handler_->OnResetDialogState(browser); #endif // User implementation JavascriptDialogHandler_OnResetJavascriptDialogState(browser); } void JSDialogHandler::OnDialogClosed(CefRefPtr browser) { REQUIRE_UI_THREAD(); JavascriptDialogHandler_OnJavascriptDialogClosed(browser); } cefpython-49.0/src/client_handler/js_dialog_handler.h000066400000000000000000000027561334103266300230230ustar00rootroot00000000000000// Copyright (c) 2016 CEF Python, see the Authors file. // All rights reserved. Licensed under BSD 3-clause license. // Project website: https://github.com/cztomczak/cefpython #include "common/cefpython_public_api.h" #include "include/cef_jsdialog_handler.h" #if defined(OS_LINUX) #include "dialog_handler_gtk.h" #endif class JSDialogHandler : public CefJSDialogHandler { public: JSDialogHandler(); virtual ~JSDialogHandler(){} typedef cef_jsdialog_type_t JSDialogType; bool OnJSDialog(CefRefPtr browser, const CefString& origin_url, const CefString& accept_lang, JSDialogType dialog_type, const CefString& message_text, const CefString& default_prompt_text, CefRefPtr callback, bool& suppress_message) override; bool OnBeforeUnloadDialog(CefRefPtr browser, const CefString& message_text, bool is_reload, CefRefPtr callback ) override; void OnResetDialogState(CefRefPtr browser) override; void OnDialogClosed(CefRefPtr browser) override; public: #if defined(OS_LINUX) // Default dialog handler impl for GTK. CefRefPtr dialog_handler_; #endif private: IMPLEMENT_REFCOUNTING(JSDialogHandler); }; cefpython-49.0/src/client_handler/keyboard_handler.cpp000066400000000000000000000016071334103266300232150ustar00rootroot00000000000000// Copyright (c) 2012 CEF Python, see the Authors file. // All rights reserved. Licensed under BSD 3-clause license. // Project website: https://github.com/cztomczak/cefpython #include "keyboard_handler.h" bool KeyboardHandler::OnPreKeyEvent(CefRefPtr browser, const CefKeyEvent& event, CefEventHandle os_event, bool* is_keyboard_shortcut) { REQUIRE_UI_THREAD(); return KeyboardHandler_OnPreKeyEvent(browser, event, os_event, is_keyboard_shortcut); } bool KeyboardHandler:: OnKeyEvent(CefRefPtr browser, const CefKeyEvent& event, CefEventHandle os_event) { REQUIRE_UI_THREAD(); return KeyboardHandler_OnKeyEvent(browser, event, os_event); } cefpython-49.0/src/client_handler/keyboard_handler.h000066400000000000000000000014421334103266300226570ustar00rootroot00000000000000// Copyright (c) 2012 CEF Python, see the Authors file. // All rights reserved. Licensed under BSD 3-clause license. // Project website: https://github.com/cztomczak/cefpython #include "common/cefpython_public_api.h" #include "include/cef_keyboard_handler.h" class KeyboardHandler : public CefKeyboardHandler { public: KeyboardHandler(){} virtual ~KeyboardHandler(){} bool OnPreKeyEvent(CefRefPtr browser, const CefKeyEvent& event, CefEventHandle os_event, bool* is_keyboard_shortcut) override; bool OnKeyEvent(CefRefPtr browser, const CefKeyEvent& event, CefEventHandle os_event) override; private: IMPLEMENT_REFCOUNTING(KeyboardHandler); }; cefpython-49.0/src/client_handler/lifespan_handler.cpp000066400000000000000000000044531334103266300232200ustar00rootroot00000000000000// Copyright (c) 2012 CEF Python, see the Authors file. // All rights reserved. Licensed under BSD 3-clause license. // Project website: https://github.com/cztomczak/cefpython #include "lifespan_handler.h" #if defined(OS_WIN) #include "dpi_aware.h" #endif #include "include/base/cef_logging.h" bool LifespanHandler::OnBeforePopup(CefRefPtr browser, CefRefPtr frame, const CefString& target_url, const CefString& target_frame_name, WindowOpenDisposition target_disposition, bool user_gesture, const CefPopupFeatures& popupFeatures, CefWindowInfo& windowInfo, CefRefPtr& client, CefBrowserSettings& settings, bool* no_javascript_access) { REQUIRE_IO_THREAD(); // Note: passing popupFeatures is not yet supported. const int popupFeaturesNotImpl = 0; return LifespanHandler_OnBeforePopup(browser, frame, target_url, target_frame_name, target_disposition, user_gesture, popupFeaturesNotImpl, windowInfo, client, settings, no_javascript_access); } void LifespanHandler::OnAfterCreated(CefRefPtr browser) { REQUIRE_UI_THREAD(); #if defined(OS_WIN) // High DPI support. CefString auto_zooming = ApplicationSettings_GetString("auto_zooming"); if (!auto_zooming.empty()) { LOG(INFO) << "[Browser process] OnAfterCreated(): auto_zooming = " << auto_zooming.ToString(); SetBrowserDpiSettings(browser, auto_zooming); } #endif // OS_WIN LifespanHandler_OnAfterCreated(browser); } bool LifespanHandler::DoClose(CefRefPtr browser) { REQUIRE_UI_THREAD(); return LifespanHandler_DoClose(browser); } void LifespanHandler::OnBeforeClose(CefRefPtr browser) { REQUIRE_UI_THREAD(); LifespanHandler_OnBeforeClose(browser); } bool LifespanHandler::RunModal(CefRefPtr browser) { REQUIRE_UI_THREAD(); return LifespanHandler_RunModal(browser); } cefpython-49.0/src/client_handler/lifespan_handler.h000066400000000000000000000025071334103266300226630ustar00rootroot00000000000000// Copyright (c) 2012 CEF Python, see the Authors file. // All rights reserved. Licensed under BSD 3-clause license. // Project website: https://github.com/cztomczak/cefpython #include "common/cefpython_public_api.h" #include "include/cef_life_span_handler.h" class LifespanHandler : public CefLifeSpanHandler { public: LifespanHandler(){} virtual ~LifespanHandler(){} typedef cef_window_open_disposition_t WindowOpenDisposition; bool OnBeforePopup(CefRefPtr browser, CefRefPtr frame, const CefString& target_url, const CefString& target_frame_name, WindowOpenDisposition target_disposition, bool user_gesture, const CefPopupFeatures& popupFeatures, CefWindowInfo& windowInfo, CefRefPtr& client, CefBrowserSettings& settings, bool* no_javascript_access) override; void OnAfterCreated(CefRefPtr browser) override; bool DoClose(CefRefPtr browser) override; void OnBeforeClose(CefRefPtr browser) override; bool RunModal(CefRefPtr browser) override; private: IMPLEMENT_REFCOUNTING(LifespanHandler); }; cefpython-49.0/src/client_handler/load_handler.cpp000066400000000000000000000026361334103266300223370ustar00rootroot00000000000000// Copyright (c) 2012 CEF Python, see the Authors file. // All rights reserved. Licensed under BSD 3-clause license. // Project website: https://github.com/cztomczak/cefpython #include "load_handler.h" void LoadHandler::OnLoadingStateChange(CefRefPtr browser, bool isLoading, bool canGoBack, bool canGoForward) { REQUIRE_UI_THREAD(); LoadHandler_OnLoadingStateChange(browser, isLoading, canGoBack, canGoForward); } void LoadHandler::OnLoadStart(CefRefPtr browser, CefRefPtr frame) { REQUIRE_UI_THREAD(); LoadHandler_OnLoadStart(browser, frame); } void LoadHandler::OnLoadEnd(CefRefPtr browser, CefRefPtr frame, int httpStatusCode) { REQUIRE_UI_THREAD(); LoadHandler_OnLoadEnd(browser, frame, httpStatusCode); } void LoadHandler::OnLoadError(CefRefPtr browser, CefRefPtr frame, cef_errorcode_t errorCode, const CefString& errorText, const CefString& failedUrl) { REQUIRE_UI_THREAD(); LoadHandler_OnLoadError(browser, frame, errorCode, errorText, failedUrl); } cefpython-49.0/src/client_handler/load_handler.h000066400000000000000000000021631334103266300217770ustar00rootroot00000000000000// Copyright (c) 2012 CEF Python, see the Authors file. // All rights reserved. Licensed under BSD 3-clause license. // Project website: https://github.com/cztomczak/cefpython #include "common/cefpython_public_api.h" #include "include/cef_load_handler.h" class LoadHandler : public CefLoadHandler { public: LoadHandler(){} virtual ~LoadHandler(){} void OnLoadingStateChange(CefRefPtr browser, bool isLoading, bool canGoBack, bool canGoForward) override; void OnLoadStart(CefRefPtr browser, CefRefPtr frame) override; void OnLoadEnd(CefRefPtr browser, CefRefPtr frame, int httpStatusCode) override; void OnLoadError(CefRefPtr browser, CefRefPtr frame, cef_errorcode_t errorCode, const CefString& errorText, const CefString& failedUrl) override; private: IMPLEMENT_REFCOUNTING(LoadHandler); }; cefpython-49.0/src/client_handler/render_handler.cpp000066400000000000000000000063161334103266300226760ustar00rootroot00000000000000// Copyright (c) 2013 CEF Python, see the Authors file. // All rights reserved. Licensed under BSD 3-clause license. // Project website: https://github.com/cztomczak/cefpython #include "render_handler.h" bool RenderHandler::GetRootScreenRect(CefRefPtr browser, CefRect& rect) { REQUIRE_UI_THREAD(); return RenderHandler_GetRootScreenRect(browser, rect); } bool RenderHandler::GetViewRect(CefRefPtr browser, CefRect& rect) { REQUIRE_UI_THREAD(); return RenderHandler_GetViewRect(browser, rect); } bool RenderHandler::GetScreenPoint(CefRefPtr browser, int viewX, int viewY, int& screenX, int& screenY) { REQUIRE_UI_THREAD(); return RenderHandler_GetScreenPoint(browser, viewX, viewY, screenX, screenY); } bool RenderHandler::GetScreenInfo(CefRefPtr browser, CefScreenInfo& screen_info) { REQUIRE_UI_THREAD(); return RenderHandler_GetScreenInfo(browser, screen_info); } void RenderHandler::OnPopupShow(CefRefPtr browser, bool show) { REQUIRE_UI_THREAD(); RenderHandler_OnPopupShow(browser, show); } void RenderHandler::OnPopupSize(CefRefPtr browser, const CefRect& rect) { REQUIRE_UI_THREAD(); RenderHandler_OnPopupSize(browser, rect); } void RenderHandler::OnPaint(CefRefPtr browser, PaintElementType type, const RectList& dirtyRects, const void* buffer, int width, int height) { REQUIRE_UI_THREAD(); RenderHandler_OnPaint(browser, type, const_cast(dirtyRects), buffer, width, height); } void RenderHandler::OnCursorChange(CefRefPtr browser, CefCursorHandle cursor, CursorType type, const CefCursorInfo& custom_cursor_info) { REQUIRE_UI_THREAD(); RenderHandler_OnCursorChange(browser, cursor); } void RenderHandler::OnScrollOffsetChanged(CefRefPtr browser, double x, double y) { REQUIRE_UI_THREAD(); RenderHandler_OnScrollOffsetChanged(browser); } bool RenderHandler::StartDragging(CefRefPtr browser, CefRefPtr drag_data, DragOperationsMask allowed_ops, int x, int y) { REQUIRE_UI_THREAD(); return RenderHandler_StartDragging(browser, drag_data, allowed_ops, x, y); } void RenderHandler::UpdateDragCursor(CefRefPtr browser, DragOperation operation) { REQUIRE_UI_THREAD(); RenderHandler_UpdateDragCursor(browser, operation); } cefpython-49.0/src/client_handler/render_handler.h000066400000000000000000000041311334103266300223340ustar00rootroot00000000000000// Copyright (c) 2013 CEF Python, see the Authors file. // All rights reserved. Licensed under BSD 3-clause license. // Project website: https://github.com/cztomczak/cefpython #include "common/cefpython_public_api.h" #include "include/cef_render_handler.h" class RenderHandler : public CefRenderHandler { public: RenderHandler(){} virtual ~RenderHandler(){} bool GetRootScreenRect(CefRefPtr browser, CefRect& rect) override; bool GetViewRect(CefRefPtr browser, CefRect& rect) override; bool GetScreenPoint(CefRefPtr browser, int viewX, int viewY, int& screenX, int& screenY) override; bool GetScreenInfo(CefRefPtr browser, CefScreenInfo& screen_info) override; void OnPopupShow(CefRefPtr browser, bool show) override; void OnPopupSize(CefRefPtr browser, const CefRect& rect) override; void OnPaint(CefRefPtr browser, PaintElementType type, const RectList& dirtyRects, const void* buffer, int width, int height) override; void OnCursorChange(CefRefPtr browser, CefCursorHandle cursor, CursorType type, const CefCursorInfo& custom_cursor_info ) override; void OnScrollOffsetChanged(CefRefPtr browser, double x, double y) override; bool StartDragging(CefRefPtr browser, CefRefPtr drag_data, cef_drag_operations_mask_t allowed_ops, int x, int y) override; void UpdateDragCursor(CefRefPtr browser, cef_drag_operations_mask_t operation) override; private: IMPLEMENT_REFCOUNTING(RenderHandler); }; cefpython-49.0/src/client_handler/request_context_handler.cpp000066400000000000000000000027751334103266300246600ustar00rootroot00000000000000// Copyright (c) 2013 CEF Python, see the Authors file. // All rights reserved. Licensed under BSD 3-clause license. // Project website: https://github.com/cztomczak/cefpython #include "request_context_handler.h" #include "common/cefpython_public_api.h" // -------------------------------------------------------------------------- // CefRequestContextHandler // -------------------------------------------------------------------------- CefRefPtr RequestContextHandler::GetCookieManager() { REQUIRE_IO_THREAD(); if (browser_.get()) { return RequestHandler_GetCookieManager(browser_, browser_->GetMainFrame()->GetURL()); } else { CefString mainUrl; return RequestHandler_GetCookieManager(browser_, mainUrl); } // Default: return NULL. } bool RequestContextHandler::OnBeforePluginLoad( const CefString& mime_type, const CefString& plugin_url, const CefString& top_origin_url, CefRefPtr plugin_info, PluginPolicy* plugin_policy) { // Called on multiple threads return RequestHandler_OnBeforePluginLoad(browser_, mime_type, plugin_url, top_origin_url, plugin_info, plugin_policy); } cefpython-49.0/src/client_handler/request_context_handler.h000066400000000000000000000024701334103266300243150ustar00rootroot00000000000000// Copyright (c) 2013 CEF Python, see the Authors file. // All rights reserved. Licensed under BSD 3-clause license. // Project website: https://github.com/cztomczak/cefpython #pragma once #if defined(_WIN32) #include #endif #include "common/cefpython_public_api.h" class RequestContextHandler : public CefRequestContextHandler { private: CefRefPtr browser_; typedef cef_plugin_policy_t PluginPolicy; public: // Browser may be NULL when instantiated from cefpython.CreateBrowserSync. // In such case SetBrowser will be called after browser creation. // GetCookieManager must handle a case when browser is NULL. explicit RequestContextHandler(CefRefPtr browser) : browser_(browser) { } void SetBrowser(CefRefPtr browser) { browser_ = browser; } virtual CefRefPtr GetCookieManager() OVERRIDE; virtual bool OnBeforePluginLoad(const CefString& mime_type, const CefString& plugin_url, const CefString& top_origin_url, CefRefPtr plugin_info, PluginPolicy* plugin_policy) OVERRIDE; private: IMPLEMENT_REFCOUNTING(RequestContextHandler); }; cefpython-49.0/src/client_handler/request_handler.cpp000066400000000000000000000106151334103266300231040ustar00rootroot00000000000000// Copyright (c) 2012 CEF Python, see the Authors file. // All rights reserved. Licensed under BSD 3-clause license. // Project website: https://github.com/cztomczak/cefpython #include "request_handler.h" #include "include/base/cef_logging.h" bool RequestHandler::OnBeforeBrowse(CefRefPtr browser, CefRefPtr frame, CefRefPtr request, bool is_redirect) { REQUIRE_UI_THREAD(); return RequestHandler_OnBeforeBrowse(browser, frame, request, is_redirect); } ReturnValue RequestHandler::OnBeforeResourceLoad( CefRefPtr browser, CefRefPtr frame, CefRefPtr request, CefRefPtr callback) { REQUIRE_IO_THREAD(); bool retval = RequestHandler_OnBeforeResourceLoad(browser, frame, request); if (retval) { return RV_CANCEL; } else { return RV_CONTINUE; } } CefRefPtr RequestHandler::GetResourceHandler( CefRefPtr browser, CefRefPtr frame, CefRefPtr request) { REQUIRE_IO_THREAD(); return RequestHandler_GetResourceHandler(browser, frame, request); } void RequestHandler::OnResourceRedirect(CefRefPtr browser, CefRefPtr frame, CefRefPtr request, CefString& new_url) { REQUIRE_IO_THREAD(); RequestHandler_OnResourceRedirect(browser, frame, request->GetURL(), new_url, request); } bool RequestHandler::GetAuthCredentials(CefRefPtr browser, CefRefPtr frame, bool isProxy, const CefString& host, int port, const CefString& realm, const CefString& scheme, CefRefPtr callback) { REQUIRE_IO_THREAD(); return RequestHandler_GetAuthCredentials(browser, frame, isProxy, host, port, realm, scheme, callback); } bool RequestHandler::OnQuotaRequest(CefRefPtr browser, const CefString& origin_url, int64 new_size, CefRefPtr callback) { REQUIRE_IO_THREAD(); return RequestHandler_OnQuotaRequest(browser, origin_url, new_size, callback); } void RequestHandler::OnProtocolExecution(CefRefPtr browser, const CefString& url, bool& allow_os_execution) { REQUIRE_UI_THREAD(); RequestHandler_OnProtocolExecution(browser, url, allow_os_execution); } bool RequestHandler::OnCertificateError( CefRefPtr browser, // not used cef_errorcode_t cert_error, const CefString& request_url, CefRefPtr ssl_info, // not used CefRefPtr callback) { REQUIRE_UI_THREAD(); return RequestHandler_OnCertificateError(cert_error, request_url, callback); } void RequestHandler::OnRenderProcessTerminated(CefRefPtr browser, cef_termination_status_t status) { REQUIRE_UI_THREAD(); LOG(ERROR) << "[Browser process] OnRenderProcessTerminated()"; RequestHandler_OnRendererProcessTerminated(browser, status); } void RequestHandler::OnPluginCrashed(CefRefPtr browser, const CefString& plugin_path) { REQUIRE_UI_THREAD(); RequestHandler_OnPluginCrashed(browser, plugin_path); } cefpython-49.0/src/client_handler/request_handler.h000066400000000000000000000055441334103266300225560ustar00rootroot00000000000000// Copyright (c) 2012 CEF Python, see the Authors file. // All rights reserved. Licensed under BSD 3-clause license. // Project website: https://github.com/cztomczak/cefpython #include "common/cefpython_public_api.h" #include "include/cef_request_handler.h" typedef cef_return_value_t ReturnValue; class RequestHandler : public CefRequestHandler { public: RequestHandler(){} virtual ~RequestHandler(){} bool OnBeforeBrowse(CefRefPtr browser, CefRefPtr frame, CefRefPtr request, bool is_redirect) override; ReturnValue OnBeforeResourceLoad(CefRefPtr browser, CefRefPtr frame, CefRefPtr request, CefRefPtr callback ) override; CefRefPtr GetResourceHandler( CefRefPtr browser, CefRefPtr frame, CefRefPtr request) override; void OnResourceRedirect(CefRefPtr browser, CefRefPtr frame, CefRefPtr request, CefString& new_url) override; bool GetAuthCredentials(CefRefPtr browser, CefRefPtr frame, bool isProxy, const CefString& host, int port, const CefString& realm, const CefString& scheme, CefRefPtr callback) override; bool OnQuotaRequest(CefRefPtr browser, const CefString& origin_url, int64 new_size, CefRefPtr callback) override; void OnProtocolExecution(CefRefPtr browser, const CefString& url, bool& allow_os_execution) override; bool OnCertificateError(CefRefPtr browser, cef_errorcode_t cert_error, const CefString& request_url, CefRefPtr ssl_info, CefRefPtr callback) override; void OnRenderProcessTerminated(CefRefPtr browser, cef_termination_status_t status) override; void OnPluginCrashed(CefRefPtr browser, const CefString& plugin_path) override; private: IMPLEMENT_REFCOUNTING(RequestHandler); }; cefpython-49.0/src/client_handler/resource_handler.cpp000066400000000000000000000030261334103266300232410ustar00rootroot00000000000000// Copyright (c) 2013 CEF Python, see the Authors file. // All rights reserved. Licensed under BSD 3-clause license. // Project website: https://github.com/cztomczak/cefpython #include "resource_handler.h" bool ResourceHandler::ProcessRequest(CefRefPtr request, CefRefPtr callback) { REQUIRE_IO_THREAD(); return ResourceHandler_ProcessRequest(resourceHandlerId_, request, callback); } void ResourceHandler::GetResponseHeaders(CefRefPtr response, int64& response_length, CefString& redirectUrl) { REQUIRE_IO_THREAD(); ResourceHandler_GetResponseHeaders(resourceHandlerId_, response, response_length, redirectUrl); } bool ResourceHandler::ReadResponse(void* data_out, int bytes_to_read, int& bytes_read, CefRefPtr callback) { REQUIRE_IO_THREAD(); return ResourceHandler_ReadResponse(resourceHandlerId_, data_out, bytes_to_read, bytes_read, callback); } bool ResourceHandler::CanGetCookie(const CefCookie& cookie) { REQUIRE_IO_THREAD(); return ResourceHandler_CanGetCookie(resourceHandlerId_, cookie); } bool ResourceHandler::CanSetCookie(const CefCookie& cookie) { REQUIRE_IO_THREAD(); return ResourceHandler_CanSetCookie(resourceHandlerId_, cookie); } void ResourceHandler::Cancel() { REQUIRE_IO_THREAD(); return ResourceHandler_Cancel(resourceHandlerId_); } cefpython-49.0/src/client_handler/resource_handler.h000066400000000000000000000023271334103266300227110ustar00rootroot00000000000000// Copyright (c) 2013 CEF Python, see the Authors file. // All rights reserved. Licensed under BSD 3-clause license. // Project website: https://github.com/cztomczak/cefpython #pragma once #if defined(_WIN32) #include #endif #include "common/cefpython_public_api.h" class ResourceHandler : public CefResourceHandler { public: int resourceHandlerId_; public: ResourceHandler(int resourceHandlerId) : resourceHandlerId_(resourceHandlerId) { } virtual bool ProcessRequest(CefRefPtr request, CefRefPtr callback) override; virtual void GetResponseHeaders(CefRefPtr response, int64& response_length, CefString& redirectUrl) override; virtual bool ReadResponse(void* data_out, int bytes_to_read, int& bytes_read, CefRefPtr callback) override; virtual bool CanGetCookie(const CefCookie& cookie) override; virtual bool CanSetCookie(const CefCookie& cookie) override; virtual void Cancel() OVERRIDE; private: IMPLEMENT_REFCOUNTING(ResourceHandler); }; cefpython-49.0/src/client_handler/string_visitor.cpp000066400000000000000000000005351334103266300230040ustar00rootroot00000000000000// Copyright (c) 2013 CEF Python, see the Authors file. // All rights reserved. Licensed under BSD 3-clause license. // Project website: https://github.com/cztomczak/cefpython #include "string_visitor.h" #include void StringVisitor::Visit( const CefString& string ) { StringVisitor_Visit(stringVisitorId_, string); } cefpython-49.0/src/client_handler/string_visitor.h000066400000000000000000000011361334103266300224470ustar00rootroot00000000000000// Copyright (c) 2013 CEF Python, see the Authors file. // All rights reserved. Licensed under BSD 3-clause license. // Project website: https://github.com/cztomczak/cefpython #pragma once #if defined(_WIN32) #include #endif #include "common/cefpython_public_api.h" class StringVisitor : public CefStringVisitor { public: int stringVisitorId_; public: StringVisitor(int stringVisitorId) : stringVisitorId_(stringVisitorId) { } virtual void Visit( const CefString& string ) OVERRIDE; protected: IMPLEMENT_REFCOUNTING(StringVisitor); }; cefpython-49.0/src/client_handler/task.cpp000066400000000000000000000030541334103266300206600ustar00rootroot00000000000000// Copyright (c) 2014 CEF Python, see the Authors file. // All rights reserved. Licensed under BSD 3-clause license. // Project website: https://github.com/cztomczak/cefpython #include "task.h" #include "include/wrapper/cef_closure_task.h" #include "include/base/cef_bind.h" void PostTaskWrapper(int threadId, int taskId) { CefPostTask( static_cast(threadId), CefCreateClosureTask(base::Bind( &PyTaskRunnable, taskId )) ); } void PostDelayedTaskWrapper(int threadId, int64 delay_ms, int taskId) { CefPostDelayedTask( static_cast(threadId), CefCreateClosureTask(base::Bind( &PyTaskRunnable, taskId )), delay_ms ); } CefRefPtr CreateTask_SetCookie( CefCookieManager* obj, const CefString& url, const CefCookie& cookie, CefRefPtr callback) { return CefCreateClosureTask(base::Bind( base::IgnoreResult(&CefCookieManager::SetCookie), obj, url, cookie, callback )); } CefRefPtr CreateTask_DeleteCookies( CefCookieManager* obj, const CefString& url, const CefString& cookie_name, CefRefPtr callback) { return CefCreateClosureTask(base::Bind( base::IgnoreResult(&CefCookieManager::DeleteCookies), obj, url, cookie_name, callback )); } cefpython-49.0/src/client_handler/task.h000066400000000000000000000014411334103266300203230ustar00rootroot00000000000000// Copyright (c) 2014 CEF Python, see the Authors file. // All rights reserved. Licensed under BSD 3-clause license. // Project website: https://github.com/cztomczak/cefpython #pragma once #include "common/cefpython_public_api.h" #include "include/cef_cookie.h" #include "include/cef_task.h" void PostTaskWrapper(int threadId, int taskId); void PostDelayedTaskWrapper(int threadId, int64 delay_ms, int taskId); CefRefPtr CreateTask_SetCookie( CefCookieManager* obj, const CefString& url, const CefCookie& cookie, CefRefPtr callback); CefRefPtr CreateTask_DeleteCookies( CefCookieManager* obj, const CefString& url, const CefString& cookie_name, CefRefPtr callback); cefpython-49.0/src/client_handler/util_mac.h000066400000000000000000000007451334103266300211640ustar00rootroot00000000000000// Copyright (c) 2013 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. #ifndef CEFPYTHON_UTIL_MAC_H_ #define CEFPYTHON_UTIL_MAC_H_ #include #include "include/cef_base.h" #include "include/cef_app.h" #include "include/cef_browser.h" void MacInitialize(); void MacSetWindowTitle(CefRefPtr browser, char* title); #endif // CEFPYTHON_UTIL_MAC_H_ cefpython-49.0/src/client_handler/util_mac.mm000066400000000000000000000041601334103266300213410ustar00rootroot00000000000000// Copyright (c) 2013 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. #import "util_mac.h" #import #include #include "include/cef_app.h" #include "include/cef_application_mac.h" #include "include/cef_browser.h" namespace { BOOL g_handling_send_event = false; } // namespace // Add the necessary CrAppControlProtocol // functionality to NSApplication using categories and swizzling. @interface NSApplication (CEFPythonApplication) - (BOOL)isHandlingSendEvent; - (void)setHandlingSendEvent:(BOOL)handlingSendEvent; - (void)_swizzled_sendEvent:(NSEvent*)event; - (void)_swizzled_terminate:(id)sender; @end @implementation NSApplication (CEFPythonApplication) // This selector is called very early during the application initialization. + (void)load { // Swap NSApplication::sendEvent with _swizzled_sendEvent. Method original = class_getInstanceMethod(self, @selector(sendEvent)); Method swizzled = class_getInstanceMethod(self, @selector(_swizzled_sendEvent)); method_exchangeImplementations(original, swizzled); Method originalTerm = class_getInstanceMethod(self, @selector(terminate:)); Method swizzledTerm = class_getInstanceMethod(self, @selector(_swizzled_terminate:)); method_exchangeImplementations(originalTerm, swizzledTerm); } - (BOOL)isHandlingSendEvent { return g_handling_send_event; } - (void)setHandlingSendEvent:(BOOL)handlingSendEvent { g_handling_send_event = handlingSendEvent; } - (void)_swizzled_sendEvent:(NSEvent*)event { CefScopedSendingEvent sendingEventScoper; // Calls NSApplication::sendEvent due to the swizzling. [self _swizzled_sendEvent:event]; } - (void)_swizzled_terminate:(id)sender { [self _swizzled_terminate:sender]; } @end void MacInitialize() { [NSApplication sharedApplication]; } void MacSetWindowTitle(CefRefPtr browser, char* title) { NSView* view = browser->GetHost()->GetWindowHandle(); NSString* nstitle = [NSString stringWithFormat:@"%s" , title]; view.window.title = nstitle; } cefpython-49.0/src/client_handler/web_request_client.cpp000066400000000000000000000027221334103266300236020ustar00rootroot00000000000000// Copyright (c) 2013 CEF Python, see the Authors file. // All rights reserved. Licensed under BSD 3-clause license. // Project website: https://github.com/cztomczak/cefpython #include "web_request_client.h" void WebRequestClient::OnRequestComplete(CefRefPtr request) { WebRequestClient_OnRequestComplete(webRequestId_, request); } void WebRequestClient::OnUploadProgress(CefRefPtr request, int64 current, int64 total) { WebRequestClient_OnUploadProgress(webRequestId_, request, current, total); } void WebRequestClient::OnDownloadProgress(CefRefPtr request, int64 current, int64 total) { WebRequestClient_OnDownloadProgress(webRequestId_, request, current, total); } void WebRequestClient::OnDownloadData(CefRefPtr request, const void* data, size_t data_length) { WebRequestClient_OnDownloadData(webRequestId_, request, data, data_length); } bool WebRequestClient::GetAuthCredentials(bool isProxy, const CefString& host, int port, const CefString& realm, const CefString& scheme, CefRefPtr callback) { // Not yet implemented. return false; } cefpython-49.0/src/client_handler/web_request_client.h000066400000000000000000000027501334103266300232500ustar00rootroot00000000000000// Copyright (c) 2013 CEF Python, see the Authors file. // All rights reserved. Licensed under BSD 3-clause license. // Project website: https://github.com/cztomczak/cefpython #pragma once #if defined(_WIN32) #include #endif #include "common/cefpython_public_api.h" class WebRequestClient : public CefURLRequestClient { public: int webRequestId_; public: WebRequestClient(int webRequestId) : webRequestId_(webRequestId) { } virtual ~WebRequestClient(){} virtual void OnRequestComplete(CefRefPtr request) OVERRIDE; virtual void OnUploadProgress(CefRefPtr request, int64 current, int64 total) OVERRIDE; virtual void OnDownloadProgress(CefRefPtr request, int64 current, int64 total) OVERRIDE; virtual void OnDownloadData(CefRefPtr request, const void* data, size_t data_length) OVERRIDE; virtual bool GetAuthCredentials(bool isProxy, const CefString& host, int port, const CefString& realm, const CefString& scheme, CefRefPtr callback) OVERRIDE; protected: IMPLEMENT_REFCOUNTING(WebRequestClient); }; cefpython-49.0/src/client_handler/x11.cpp000066400000000000000000000033471334103266300203340ustar00rootroot00000000000000// Copyright (c) 2016 CEF Python, see the Authors file. // All rights reserved. Licensed under BSD 3-clause license. // Project website: https://github.com/cztomczak/cefpython #include "x11.h" #include "include/base/cef_logging.h" int XErrorHandlerImpl(Display *display, XErrorEvent *event) { LOG(INFO) << "[Browser process] " << "X error received: " << "type " << event->type << ", " << "serial " << event->serial << ", " << "error_code " << static_cast(event->error_code) << ", " << "request_code " << static_cast(event->request_code) << ", " << "minor_code " << static_cast(event->minor_code); return 0; } int XIOErrorHandlerImpl(Display *display) { return 0; } void InstallX11ErrorHandlers() { // Copied from upstream cefclient. // Install xlib error handlers so that the application won't be terminated // on non-fatal errors. Must be done after initializing GTK. XSetErrorHandler(XErrorHandlerImpl); XSetIOErrorHandler(XIOErrorHandlerImpl); } void SetX11WindowBounds(CefRefPtr browser, int x, int y, int width, int height) { ::Window xwindow = browser->GetHost()->GetWindowHandle(); ::Display* xdisplay = cef_get_xdisplay(); XWindowChanges changes = {0}; changes.x = x; changes.y = y; changes.width = static_cast(width); changes.height = static_cast(height); XConfigureWindow(xdisplay, xwindow, CWX | CWY | CWHeight | CWWidth, &changes); } void SetX11WindowTitle(CefRefPtr browser, char* title) { ::Window xwindow = browser->GetHost()->GetWindowHandle(); ::Display* xdisplay = cef_get_xdisplay(); XStoreName(xdisplay, xwindow, title); } cefpython-49.0/src/client_handler/x11.h000066400000000000000000000007201334103266300177710ustar00rootroot00000000000000// Copyright (c) 2016 CEF Python, see the Authors file. // All rights reserved. Licensed under BSD 3-clause license. // Project website: https://github.com/cztomczak/cefpython #pragma once #include #include "include/cef_browser.h" void InstallX11ErrorHandlers(); void SetX11WindowBounds(CefRefPtr browser, int x, int y, int width, int height); void SetX11WindowTitle(CefRefPtr browser, char* title); cefpython-49.0/src/command_line.pyx000066400000000000000000000052131334103266300174250ustar00rootroot00000000000000# Copyright (c) 2014 CEF Python, see the Authors file. # All rights reserved. Licensed under BSD 3-clause license. # Project website: https://github.com/cztomczak/cefpython include "cefpython.pyx" cdef void AppendSwitchesToCommandLine( CefRefPtr[CefCommandLine] cefCommandLine, dict switches ) except * with gil: # Called from: # 1. App_OnBeforeCommandLineProcessing_BrowserProcess() # 2. BrowserProcessHandler_OnRenderProcessThreadCreated() cdef PyCommandLine pyCommandLine = CreatePyCommandLine(cefCommandLine) cdef py_string switch cdef py_string value for switch, value in switches.iteritems(): if not isinstance(switch, basestring) or switch[0] == '-': Debug("Invalid command line switch: %s" % switch) continue if value: if pyCommandLine.HasSwitch(switch)\ and value == pyCommandLine.GetSwitchValue(switch): Debug("Switch already set, ignoring: %s" % switch) else: pyCommandLine.AppendSwitchWithValue(switch, value) else: if pyCommandLine.HasSwitch(switch): Debug("Switch already set, ignoring: %s" % switch) else: pyCommandLine.AppendSwitch(switch) cdef PyCommandLine CreatePyCommandLine( CefRefPtr[CefCommandLine] cefCommandLine): cdef PyCommandLine pyCommandLine = PyCommandLine() pyCommandLine.cefCommandLine = cefCommandLine return pyCommandLine cdef class PyCommandLine: cdef CefRefPtr[CefCommandLine] cefCommandLine cdef py_void AppendSwitch(self, py_string switch): cdef CefString cefSwitch cefSwitch = PyToCefStringValue(switch) self.cefCommandLine.get().AppendSwitch(cefSwitch) cdef py_void AppendSwitchWithValue(self, py_string switch, py_string value): cdef CefString cefSwitch cdef CefString cefValue cefSwitch = PyToCefStringValue(switch) cefValue = PyToCefStringValue(value) self.cefCommandLine.get().AppendSwitchWithValue(cefSwitch, cefValue) cdef py_string GetCommandLineString(self): return CefToPyString(self.cefCommandLine.get().GetCommandLineString()) cdef py_bool HasSwitch(self, py_string switch): cdef CefString cefSwitch cefSwitch = PyToCefStringValue(switch) return self.cefCommandLine.get().HasSwitch(cefSwitch) cdef py_string GetSwitchValue(self, py_string switch): cdef CefString cefValue cdef CefString cefSwitch cefSwitch = PyToCefStringValue(switch) cefValue = self.cefCommandLine.get().GetSwitchValue(cefSwitch) return CefToPyString(cefValue) cefpython-49.0/src/common/000077500000000000000000000000001334103266300155255ustar00rootroot00000000000000cefpython-49.0/src/common/cefpython_public_api.h000066400000000000000000000025551334103266300220730ustar00rootroot00000000000000// Copyright (c) 2012 CEF Python, see the Authors file. // All rights reserved. Licensed under BSD 3-clause license. // Project website: https://github.com/cztomczak/cefpython /* This is a wrapper around including cefpython_fixed.h that is generated by Cython. Functions marked with the 'public' keyword are exposed to C through that header file. */ #ifndef CEFPYTHON_PUBLIC_API_H #define CEFPYTHON_PUBLIC_API_H #if defined(OS_WIN) #pragma warning(disable:4190) // cefpython API extern C-linkage warnings #endif // Python.h must be included first otherwise error on Linux: // >> error: "_POSIX_C_SOURCE" redefined #include "Python.h" // Includes required by "cefpython_fixed.h". #include "include/cef_client.h" #include "include/cef_urlrequest.h" #include "include/cef_command_line.h" #include "util.h" // cefpython_fixed.h declares public functions using DL_IMPORT and these // macros are not available in Python 3. #ifndef DL_IMPORT #define DL_IMPORT(RTYPE) RTYPE #endif #ifndef DL_EXPORT #define DL_EXPORT(RTYPE) RTYPE #endif #if PY_MAJOR_VERSION == 2 #if PY_MINOR_VERSION == 7 #include "../../build/build_cefpython/cefpython_py27_fixed.h" #endif // PY_MINOR_VERSION #elif PY_MAJOR_VERSION == 3 #if PY_MINOR_VERSION == 4 #include "../../build/build_cefpython/cefpython_py34_fixed.h" #endif // PY_MINOR_VERSION #endif // PY_MAJOR_VERSION #endif // CEFPYTHON_PUBLIC_API_H cefpython-49.0/src/common/util.h000066400000000000000000000016741334103266300166630ustar00rootroot00000000000000// Copyright (c) 2011 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. #ifndef CEF_TESTS_CEFCLIENT_UTIL_H_ #define CEF_TESTS_CEFCLIENT_UTIL_H_ #pragma once #include "include/cef_task.h" #if defined(OS_WIN) #include // NOLINT(build/include_order) #ifndef NDEBUG #define ASSERT(condition) if (!(condition)) { DebugBreak(); } #else #define ASSERT(condition) ((void)0) #endif #else // !OS_WIN #include // NOLINT(build/include_order) #ifndef NDEBUG #define ASSERT(condition) if (!(condition)) { assert(false); } #else #define ASSERT(condition) ((void)0) #endif #endif // !OS_WIN #define REQUIRE_UI_THREAD() ASSERT(CefCurrentlyOn(TID_UI)); #define REQUIRE_IO_THREAD() ASSERT(CefCurrentlyOn(TID_IO)); #define REQUIRE_FILE_THREAD() ASSERT(CefCurrentlyOn(TID_FILE)); #endif // CEF_TESTS_CEFCLIENT_UTIL_H_ cefpython-49.0/src/compile_time_constants.pxi000066400000000000000000000001351334103266300215200ustar00rootroot00000000000000# This file was generated by setup.py DEF UNAME_SYSNAME = "Windows" DEF PY_MAJOR_VERSION = 3 cefpython-49.0/src/cookie.pyx000066400000000000000000000320351334103266300162530ustar00rootroot00000000000000# Copyright (c) 2013 CEF Python, see the Authors file. # All rights reserved. Licensed under BSD 3-clause license. # Project website: https://github.com/cztomczak/cefpython include "cefpython.pyx" from task cimport * # ------------------------------------------------------------------------------ # Tests # ------------------------------------------------------------------------------ #cdef Cookie cookie = Cookie() #cookie.SetName("asd1") #print("cookie.cefCookie: %s" % cookie.cefCookie) #print("cookie.GetName(): %s" % cookie.GetName()) #print("cookie.GetCreation(): %s" % cookie.GetCreation()) #cookie.SetCreation(datetime.datetime(2013,5,23)) #print("cookie.GetCreation(): %s" % cookie.GetCreation()) #print("cookie: %s" % cookie.Get()) # ------------------------------------------------------------------------------ # Globals # ------------------------------------------------------------------------------ # noinspection PyUnresolvedReferences cdef PyCookieManager g_globalCookieManager = None # See StoreUserCookieVisitor(). import weakref cdef object g_userCookieVisitors = weakref.WeakValueDictionary() cdef int g_userCookieVisitorMaxId = 0 # ------------------------------------------------------------------------------ # Cookie # ------------------------------------------------------------------------------ # noinspection PyUnresolvedReferences ctypedef Cookie PyCookie cdef PyCookie CreatePyCookie(CefCookie cefCookie): cdef PyCookie pyCookie = Cookie() pyCookie.cefCookie = cefCookie return pyCookie cdef class Cookie: cdef CefCookie cefCookie cpdef py_void Set(self, dict cookie): for key in cookie: if key == "name": self.SetName(cookie[key]) elif key == "value": self.SetValue(cookie[key]) elif key == "domain": self.SetDomain(cookie[key]) elif key == "path": self.SetPath(cookie[key]) elif key == "secure": self.SetSecure(cookie[key]) elif key == "httpOnly": self.SetHttpOnly(cookie[key]) elif key == "creation": self.SetCreation(cookie[key]) elif key == "lastAccess": self.SetLastAccess(cookie[key]) elif key == "hasExpires": self.SetHasExpires(cookie[key]) elif key == "expires": self.SetExpires(cookie[key]) else: raise Exception("Invalid key: %s" % key) cpdef dict Get(self): return { "name": self.GetName(), "value": self.GetValue(), "domain": self.GetDomain(), "path": self.GetPath(), "secure": self.GetSecure(), "httpOnly": self.GetHttpOnly(), "creation": self.GetCreation(), "lastAccess": self.GetLastAccess(), "hasExpires": self.GetHasExpires(), "expires": self.GetExpires(), } cpdef py_void SetName(self, py_string name): # This works: # | CefString(&self.cefCookie.name).FromString(name) # This does not work: # | cdef CefString cefString = CefString(&self.cefCookie.name) # | PyToCefString(name, cefString) # Because it's a Copy Constructor, it does not reference the # same underlying cef_string_t, instead it copies the value. # "T a(b)" - direct initialization (not supported by cython) # "T a = b" - copy initialization # But this works: # | cdef CefString* cefString = new CefString(&self.cefCookie.name) # | PyToCefStringPointer(name, cefString) # | del cefString # Solution: use Attach() method to pass reference to cef_string_t. cdef CefString cefString cefString.Attach(&self.cefCookie.name, False) PyToCefString(name, cefString) cpdef str GetName(self): cdef CefString cefString cefString.Attach(&self.cefCookie.name, False) return CefToPyString(cefString) cpdef py_void SetValue(self, py_string value): cdef CefString cefString cefString.Attach(&self.cefCookie.value, False) PyToCefString(value, cefString) cpdef str GetValue(self): cdef CefString cefString cefString.Attach(&self.cefCookie.value, False) return CefToPyString(cefString) cpdef py_void SetDomain(self, py_string domain): cdef CefString cefString cefString.Attach(&self.cefCookie.domain, False) PyToCefString(domain, cefString) cpdef str GetDomain(self): cdef CefString cefString cefString.Attach(&self.cefCookie.domain, False) return CefToPyString(cefString) cpdef py_void SetPath(self, py_string path): cdef CefString cefString cefString.Attach(&self.cefCookie.path, False) PyToCefString(path, cefString) cpdef str GetPath(self): cdef CefString cefString cefString.Attach(&self.cefCookie.path, False) return CefToPyString(cefString) cpdef py_void SetSecure(self, py_bool secure): # Need to wrap it with bool() to get rid of the C++ compiler # warnings: "cefpython.cpp(24740) : warning C4800: 'int' : # forcing value to bool 'true' or 'false' (performance warning)". self.cefCookie.secure = bool(secure) cpdef py_bool GetSecure(self): return self.cefCookie.secure cpdef py_void SetHttpOnly(self, py_bool httpOnly): self.cefCookie.httponly = bool(httpOnly) cpdef py_bool GetHttpOnly(self): return self.cefCookie.httponly cpdef py_void SetCreation(self, object creation): DatetimeToCefTimeT(creation, self.cefCookie.creation) cpdef object GetCreation(self): return CefTimeTToDatetime(self.cefCookie.creation) cpdef py_void SetLastAccess(self, object lastAccess): DatetimeToCefTimeT(lastAccess, self.cefCookie.last_access) cpdef object GetLastAccess(self): return CefTimeTToDatetime(self.cefCookie.last_access) cpdef py_void SetHasExpires(self, py_bool hasExpires): self.cefCookie.has_expires = bool(hasExpires) cpdef py_bool GetHasExpires(self): return self.cefCookie.has_expires cpdef py_void SetExpires(self, object expires): DatetimeToCefTimeT(expires, self.cefCookie.expires) cpdef object GetExpires(self): return CefTimeTToDatetime(self.cefCookie.expires) # ------------------------------------------------------------------------------ # CookieManager # ------------------------------------------------------------------------------ class CookieManager: @staticmethod def GetGlobalManager(): global g_globalCookieManager cdef CefRefPtr[CefCookieManager] cefCookieManager if not g_globalCookieManager: cefCookieManager = CefCookieManager_GetGlobalManager( NULL) g_globalCookieManager = CreatePyCookieManager(cefCookieManager) return g_globalCookieManager @staticmethod def CreateManager(py_string path, py_bool persistSessionCookies=False): cdef CefRefPtr[CefCookieManager] cefCookieManager cefCookieManager = CefCookieManager_CreateManager( PyToCefStringValue(path), bool(persistSessionCookies), NULL) if cefCookieManager != NULL and cefCookieManager.get(): return CreatePyCookieManager(cefCookieManager) return None # ------------------------------------------------------------------------------ # PyCookieManager # ------------------------------------------------------------------------------ cdef PyCookieManager CreatePyCookieManager( CefRefPtr[CefCookieManager] cefCookieManager): cdef PyCookieManager pyCookieManager = PyCookieManager() pyCookieManager.cefCookieManager = cefCookieManager return pyCookieManager cdef class PyCookieManager: cdef CefRefPtr[CefCookieManager] cefCookieManager cpdef py_void SetSupportedSchemes(self, list schemes): cdef cpp_vector[CefString] schemesVector for scheme in schemes: schemesVector.push_back(PyToCefStringValue(scheme)) self.cefCookieManager.get().SetSupportedSchemes(schemesVector, NULL) cdef py_void ValidateUserCookieVisitor(self, object userCookieVisitor): if userCookieVisitor and hasattr(userCookieVisitor, "Visit") and ( callable(getattr(userCookieVisitor, "Visit"))): # OK. return raise Exception("CookieVisitor object is missing Visit() method") cpdef py_bool VisitAllCookies(self, object userCookieVisitor): self.ValidateUserCookieVisitor(userCookieVisitor) cdef int cookieVisitorId = StoreUserCookieVisitor(userCookieVisitor) cdef CefRefPtr[CefCookieVisitor] cefCookieVisitor = ( new CookieVisitor( cookieVisitorId)) return self.cefCookieManager.get().VisitAllCookies( cefCookieVisitor) cpdef py_bool VisitUrlCookies(self, py_string url, py_bool includeHttpOnly, object userCookieVisitor): self.ValidateUserCookieVisitor(userCookieVisitor) cdef int cookieVisitorId = StoreUserCookieVisitor(userCookieVisitor) cdef CefRefPtr[CefCookieVisitor] cefCookieVisitor = ( new CookieVisitor( cookieVisitorId)) return self.cefCookieManager.get().VisitUrlCookies( PyToCefStringValue(url), bool(includeHttpOnly), cefCookieVisitor) cpdef py_void SetCookie(self, py_string url, PyCookie cookie): assert isinstance(cookie, Cookie), "cookie object is invalid" CefPostTask(TID_IO, CreateTask_SetCookie( self.cefCookieManager.get(), PyToCefStringValue(url), cookie.cefCookie, NULL)) cpdef py_void DeleteCookies(self, py_string url, py_string cookie_name): CefPostTask(TID_IO, CreateTask_DeleteCookies( self.cefCookieManager.get(), PyToCefStringValue(url), PyToCefStringValue(cookie_name), NULL)) cpdef py_bool SetStoragePath(self, py_string path, py_bool persistSessionCookies=False): return self.cefCookieManager.get().SetStoragePath( PyToCefStringValue(path), bool(persistSessionCookies), NULL) # ------------------------------------------------------------------------------ # PyCookieVisitor # ------------------------------------------------------------------------------ cdef int StoreUserCookieVisitor(object userCookieVisitor) except *: global g_userCookieVisitorMaxId global g_userCookieVisitors g_userCookieVisitorMaxId += 1 g_userCookieVisitors[g_userCookieVisitorMaxId] = userCookieVisitor return g_userCookieVisitorMaxId cdef PyCookieVisitor GetPyCookieVisitor(int cookieVisitorId): global g_userCookieVisitors cdef object userCookieVisitor cdef PyCookieVisitor pyCookieVisitor if cookieVisitorId in g_userCookieVisitors: userCookieVisitor = g_userCookieVisitors[cookieVisitorId] pyCookieVisitor = PyCookieVisitor(userCookieVisitor) return pyCookieVisitor cdef class PyCookieVisitor: cdef object userCookieVisitor def __init__(self, object userCookieVisitor): self.userCookieVisitor = userCookieVisitor cdef object GetCallback(self, str funcName): if self.userCookieVisitor and ( hasattr(self.userCookieVisitor, funcName) and ( callable(getattr(self.userCookieVisitor, funcName)))): return getattr(self.userCookieVisitor, funcName) # ------------------------------------------------------------------------------ # C++ CookieVisitor # ------------------------------------------------------------------------------ cdef public cpp_bool CookieVisitor_Visit( int cookieVisitorId, const CefCookie& cookie, int count, int total, cpp_bool& deleteCookie ) except * with gil: cdef PyCookieVisitor pyCookieVisitor cdef object callback cdef py_bool ret cdef PyCookie pyCookie cdef list pyDeleteCookie = [False] try: assert IsThread(TID_IO), "Must be called on the IO thread" pyCookieVisitor = GetPyCookieVisitor(cookieVisitorId) pyCookie = CreatePyCookie(cookie) if pyCookieVisitor: callback = pyCookieVisitor.GetCallback("Visit") if callback: ret = callback( cookie=pyCookie, count=count, total=total, delete_cookie_out=pyDeleteCookie) (&deleteCookie)[0] = bool(pyDeleteCookie[0]) return bool(ret) return False except: (exc_type, exc_value, exc_trace) = sys.exc_info() sys.excepthook(exc_type, exc_value, exc_trace) cefpython-49.0/src/cpp_utils/000077500000000000000000000000001334103266300162375ustar00rootroot00000000000000cefpython-49.0/src/cpp_utils/.gitignore000066400000000000000000000000071334103266300202240ustar00rootroot00000000000000*.o *.acefpython-49.0/src/cpp_utils/Makefile000066400000000000000000000012131334103266300176740ustar00rootroot00000000000000CCFLAGS = -fPIC $(CEF_CCFLAGS) SRC = PaintBuffer.cpp OBJ = $(SRC:.cpp=.o) OUT = libcpp_utils.a INC = -I./../ -I/usr/include/gtk-2.0 \ -I/usr/include/glib-2.0 -I/usr/lib/i386-linux-gnu/gtk-2.0/include \ -I/usr/lib/i386-linux-gnu/glib-2.0/include -I/usr/include/cairo \ -I/usr/include/pango-1.0 -I/usr/include/gdk-pixbuf-2.0 \ -I/usr/include/atk-1.0 -I/usr/lib/x86_64-linux-gnu/glib-2.0/include \ -I/usr/lib/x86_64-linux-gnu/gtk-2.0/include \ -I/usr/lib64/glib-2.0/include -I/usr/lib64/gtk-2.0/include \ -I/usr/lib/glib-2.0/include -I/usr/lib/gtk-2.0/include .cpp.o: $(CXX) $(INC) $(CCFLAGS) -c $< -o $@ $(OUT): $(OBJ) ar rcs $(OUT) $(OBJ) cefpython-49.0/src/cpp_utils/PaintBuffer.cpp000066400000000000000000000003121334103266300211440ustar00rootroot00000000000000// Copyright (c) 2013 CEF Python, see the Authors file. // All rights reserved. Licensed under BSD 3-clause license. // Project website: https://github.com/cztomczak/cefpython #include "PaintBuffer.h" cefpython-49.0/src/cpp_utils/PaintBuffer.h000066400000000000000000000026101334103266300206140ustar00rootroot00000000000000// Copyright (c) 2013 CEF Python, see the Authors file. // All rights reserved. Licensed under BSD 3-clause license. // Project website: https://github.com/cztomczak/cefpython #pragma once // OS_WIN is not defined on Windows when CEF is not included. // _WIN32 is defined on both 32bit and 64bit. #if defined(_WIN32) #include "windows.h" #include #else #include #endif #include void FlipBufferUpsideDown(void* _dest, const void* _src, int width, int height \ ) { // In CEF the buffer passed to Browser.GetImage() & RenderHandler.OnPaint() // has upper-left origin, but some libraries like Panda3D require // bottom-left origin. int32_t* dest = (int32_t*)_dest; int32_t* src = (int32_t*)_src; unsigned int tb; int length = width*height; for (int y = 0; y < height; y++) { tb = length - ((y+1)*width); memcpy(&dest[tb], &src[y*width], width*4); } } void SwapBufferFromBgraToRgba(void* _dest, const void* _src, int width, \ int height) { int32_t* dest = (int32_t*)_dest; int32_t* src = (int32_t*)_src; int32_t rgba; int32_t bgra; int length = width*height; for (int i = 0; i < length; i++) { bgra = src[i]; // BGRA in hex = 0xAARRGGBB. rgba = (bgra & 0x00ff0000) >> 16 // Red >> Blue. | (bgra & 0xff00ff00) // Green Alpha. | (bgra & 0x000000ff) << 16; // Blue >> Red. dest[i] = rgba; } } cefpython-49.0/src/cpp_utils/cpp_utils_win32.vcproj000066400000000000000000000051141334103266300225110ustar00rootroot00000000000000 cefpython-49.0/src/cpp_utils/deprecated_cpp_utils_64bit.vcproj000066400000000000000000000042251334103266300246610ustar00rootroot00000000000000 cefpython-49.0/src/dpi_aware_win.pyx000066400000000000000000000026401334103266300176110ustar00rootroot00000000000000# Copyright (c) 2014 CEF Python, see the Authors file. # All rights reserved. Licensed under BSD 3-clause license. # Project website: https://github.com/cztomczak/cefpython include "cefpython.pyx" class DpiAware: @staticmethod def GetSystemDpi(): # Win7 DPI (Control Panel > Appearance and Personalization > Display): # text size Larger 150% => dpix/dpiy 144 # text size Medium 125% => dpix/dpiy 120 # text size Smaller 100% => dpix/dpiy 96 # # dpix=96 zoomlevel=0.0 # dpix=120 zoomlevel=1.0 # dpix=144 zoomlevel=2.0 # dpix=72 zoomlevel=-1.0 # # If DPI awareness wasn't yet enabled, then GetSystemDpi # will always return a default 96 DPI. cdef int dpix = 0 cdef int dpiy = 0 GetSystemDpi(&dpix, &dpiy) return dpix, dpiy @staticmethod def CalculateWindowSize(int width, int height): # Calculation for DPI < 96 is not yet supported. GetDpiAwareWindowSize(&width, &height) return width, height @staticmethod def IsProcessDpiAware(): return IsProcessDpiAware() @staticmethod def SetProcessDpiAware(): SetProcessDpiAware() @staticmethod def EnableHighDpiSupport(): # This CEF function sets process to be DPI aware. This # CEF func is also called in subprocesses. Only for Win7+. CefEnableHighDPISupport() cefpython-49.0/src/drag_data.pyx000066400000000000000000000034221334103266300167060ustar00rootroot00000000000000# Copyright (c) 2016 CEF Python, see the Authors file. # All rights reserved. Licensed under BSD 3-clause license. # Project website: https://github.com/cztomczak/cefpython include "cefpython.pyx" cdef DragData_Init(CefRefPtr[CefDragData] cef_drag_data): cdef DragData drag_data = DragData() drag_data.cef_drag_data = cef_drag_data return drag_data cdef class DragData: cdef CefRefPtr[CefDragData] cef_drag_data def __init__(self): self.cef_drag_data = CefDragData_Create() self.cef_drag_data.get().SetFragmentText(PyToCefStringValue("none")) self.cef_drag_data.get().SetFragmentHtml(PyToCefStringValue("none")) self.cef_drag_data.get().SetFragmentBaseURL(PyToCefStringValue("")) cpdef py_bool IsLink(self): return self.cef_drag_data.get().IsLink() cpdef py_bool IsFragment(self): return self.cef_drag_data.get().IsFragment() cpdef py_string GetLinkUrl(self): return CefToPyString(self.cef_drag_data.get().GetLinkURL()) cpdef py_string GetLinkTitle(self): return CefToPyString(self.cef_drag_data.get().GetLinkTitle()) cpdef py_string GetFragmentText(self): return CefToPyString(self.cef_drag_data.get().GetFragmentText()) cpdef py_string GetFragmentHtml(self): return CefToPyString(self.cef_drag_data.get().GetFragmentHtml()) IF UNAME_SYSNAME == "Linux": cpdef PyImage GetImage(self): cdef CefRefPtr[CefImage] cef_image =\ self.cef_drag_data.get().GetImage() if not cef_image.get(): raise Exception("Image is not available") return PyImage_Init(cef_image) cpdef py_bool HasImage(self): return self.cef_drag_data.get().HasImage() # END IF UNAME_SYSNAME == "Linux": cefpython-49.0/src/extern/000077500000000000000000000000001334103266300155425ustar00rootroot00000000000000cefpython-49.0/src/extern/cef/000077500000000000000000000000001334103266300162775ustar00rootroot00000000000000cefpython-49.0/src/extern/cef/cef_app.pxd000066400000000000000000000025611334103266300204150ustar00rootroot00000000000000# Copyright (c) 2012 CEF Python, see the Authors file. # All rights reserved. Licensed under BSD 3-clause license. # Project website: https://github.com/cztomczak/cefpython # Circular imports are allowed in form "cimport ...", # but won't work if you do "from ... cimport *". include "compile_time_constants.pxi" from cef_types cimport CefSettings from cef_ptr cimport CefRefPtr from libcpp cimport bool as cpp_bool IF UNAME_SYSNAME == "Windows": from cef_win cimport CefMainArgs ELIF UNAME_SYSNAME == "Linux": from cef_linux cimport CefMainArgs ELIF UNAME_SYSNAME == "Darwin": from cef_mac cimport CefMainArgs cdef extern from "include/cef_app.h": cdef cppclass CefApp: pass cdef void CefEnableHighDPISupport() nogil cdef int CefExecuteProcess(CefMainArgs& args, CefRefPtr[CefApp] application, void* windows_sandbox_info ) nogil cdef cpp_bool CefInitialize(CefMainArgs&, CefSettings&, CefRefPtr[CefApp], void* windows_sandbox_info ) nogil cdef void CefRunMessageLoop() nogil cdef void CefDoMessageLoopWork() nogil cdef void CefQuitMessageLoop() nogil cdef void CefShutdown() nogil cdef void CefSetOSModalLoop(cpp_bool osModalLoop) nogil cefpython-49.0/src/extern/cef/cef_browser.pxd000066400000000000000000000100421334103266300213110ustar00rootroot00000000000000# Copyright (c) 2012 CEF Python, see the Authors file. # All rights reserved. Licensed under BSD 3-clause license. # Project website: https://github.com/cztomczak/cefpython include "compile_time_constants.pxi" from cef_ptr cimport CefRefPtr from cef_string cimport CefString from cef_client cimport CefClient from libcpp cimport bool as cpp_bool from libcpp.vector cimport vector as cpp_vector from cef_frame cimport CefFrame cimport cef_types from cef_types cimport int64 from cef_types cimport CefBrowserSettings, CefPoint from cef_drag_data cimport CefDragData from cef_types cimport CefMouseEvent from cef_process_message cimport CefProcessMessage, CefProcessId IF UNAME_SYSNAME == "Windows": from cef_win cimport CefWindowHandle, CefWindowInfo ELIF UNAME_SYSNAME == "Linux": from cef_linux cimport CefWindowHandle, CefWindowInfo ELIF UNAME_SYSNAME == "Darwin": from cef_mac cimport CefWindowHandle, CefWindowInfo cdef extern from "include/cef_browser.h": cdef cppclass CefBrowserHost: void CloseBrowser(cpp_bool force_close) CefRefPtr[CefBrowser] GetBrowser() void SetFocus(cpp_bool enable) CefWindowHandle GetWindowHandle() CefWindowHandle GetOpenerWindowHandle() double GetZoomLevel() void SetZoomLevel(double zoomLevel) void StartDownload(const CefString& url) void SetMouseCursorChangeDisabled(cpp_bool disabled) cpp_bool IsMouseCursorChangeDisabled() cpp_bool IsWindowRenderingDisabled() void WasResized() void WasHidden(cpp_bool hidden) void NotifyScreenInfoChanged() void NotifyMoveOrResizeStarted() void SendKeyEvent(cef_types.CefKeyEvent) void SendMouseClickEvent(cef_types.CefMouseEvent, cef_types.cef_mouse_button_type_t mbtype, cpp_bool mouseUp, int clickCount) void SendMouseMoveEvent(cef_types.CefMouseEvent, cpp_bool mouseLeave) void SendMouseWheelEvent(cef_types.CefMouseEvent, int deltaX, int deltaY) void SendFocusEvent(cpp_bool setFocus) void SendCaptureLostEvent() void ShowDevTools(const CefWindowInfo& windowInfo, CefRefPtr[CefClient] client, const CefBrowserSettings& settings, const CefPoint& inspect_element_at) void CloseDevTools() void Find(int identifier, const CefString& searchText, cpp_bool forward, cpp_bool matchCase, cpp_bool findNext) void StopFinding(cpp_bool clearSelection) void Print() # Drag & drop OSR void DragTargetDragEnter(CefRefPtr[CefDragData] drag_data, const CefMouseEvent& event, cef_types.cef_drag_operations_mask_t allowed_ops) void DragTargetDragOver(const CefMouseEvent& event, cef_types.cef_drag_operations_mask_t allowed_ops) void DragTargetDragLeave() void DragTargetDrop(const CefMouseEvent& event) void DragSourceEndedAt(int x, int y, cef_types.cef_drag_operations_mask_t op) void DragSourceSystemDragEnded() # Spell checking void ReplaceMisspelling(const CefString& word) void AddWordToDictionary(const CefString& word) cdef cppclass CefBrowser: CefRefPtr[CefBrowserHost] GetHost() cpp_bool CanGoBack() cpp_bool CanGoForward() CefRefPtr[CefFrame] GetFocusedFrame() CefRefPtr[CefFrame] GetFrame(CefString& name) CefRefPtr[CefFrame] GetFrame(int64 identifier) void GetFrameNames(cpp_vector[CefString]& names) CefRefPtr[CefFrame] GetMainFrame() void GoBack() void GoForward() cpp_bool HasDocument() cpp_bool IsPopup() void Reload() void ReloadIgnoreCache() void StopLoad() cpp_bool IsLoading() int GetIdentifier() cpp_bool SendProcessMessage(CefProcessId target_process, CefRefPtr[CefProcessMessage] message) cefpython-49.0/src/extern/cef/cef_browser_static.pxd000066400000000000000000000021041334103266300226600ustar00rootroot00000000000000# Copyright (c) 2012 CEF Python, see the Authors file. # All rights reserved. Licensed under BSD 3-clause license. # Project website: https://github.com/cztomczak/cefpython include "compile_time_constants.pxi" from cef_ptr cimport CefRefPtr IF UNAME_SYSNAME == "Windows": from cef_win cimport CefWindowInfo ELIF UNAME_SYSNAME == "Linux": from cef_linux cimport CefWindowInfo ELIF UNAME_SYSNAME == "Darwin": from cef_mac cimport CefWindowInfo # noinspection PyUnresolvedReferences from cef_client cimport CefClient from cef_types cimport CefBrowserSettings # noinspection PyUnresolvedReferences from cef_request_context cimport CefRequestContext # noinspection PyUnresolvedReferences from cef_browser cimport CefBrowser from cef_string cimport CefString # Specifying namespace allows to import a static method. cdef extern from "include/cef_browser.h" namespace "CefBrowserHost": cdef CefRefPtr[CefBrowser] CreateBrowserSync( CefWindowInfo&, CefRefPtr[CefClient], CefString&, CefBrowserSettings&, CefRefPtr[CefRequestContext]) nogil cefpython-49.0/src/extern/cef/cef_callback.pxd000066400000000000000000000005531334103266300213700ustar00rootroot00000000000000# Copyright (c) 2013 CEF Python, see the Authors file. # All rights reserved. Licensed under BSD 3-clause license. # Project website: https://github.com/cztomczak/cefpython cdef extern from "include/cef_callback.h": cdef cppclass CefCallback: void Continue() void Cancel() cdef cppclass CefCompletionCallback: void OnComplete() cefpython-49.0/src/extern/cef/cef_client.pxd000066400000000000000000000004021334103266300211030ustar00rootroot00000000000000# Copyright (c) 2012 CEF Python, see the Authors file. # All rights reserved. Licensed under BSD 3-clause license. # Project website: https://github.com/cztomczak/cefpython cdef extern from "include/cef_client.h": cdef cppclass CefClient: pass cefpython-49.0/src/extern/cef/cef_command_line.pxd000066400000000000000000000013311334103266300222540ustar00rootroot00000000000000# Copyright (c) 2014 CEF Python, see the Authors file. # All rights reserved. Licensed under BSD 3-clause license. # Project website: https://github.com/cztomczak/cefpython # Circular imports are allowed in form "cimport ...", # but won't work if you do "from ... cimport *". include "compile_time_constants.pxi" from cef_string cimport CefString from libcpp cimport bool as cpp_bool cdef extern from "include/cef_command_line.h": cdef cppclass CefCommandLine: void AppendSwitch(CefString& name) void AppendSwitchWithValue(CefString& name, CefString& value) CefString GetCommandLineString() cpp_bool HasSwitch(const CefString& name) CefString GetSwitchValue(const CefString& name) cefpython-49.0/src/extern/cef/cef_cookie.pxd000066400000000000000000000046531334103266300211120ustar00rootroot00000000000000# Copyright (c) 2013 CEF Python, see the Authors file. # All rights reserved. Licensed under BSD 3-clause license. # Project website: https://github.com/cztomczak/cefpython from cef_string cimport cef_string_t from libcpp cimport bool as cpp_bool from cef_time cimport cef_time_t from libcpp.vector cimport vector as cpp_vector from cef_string cimport CefString from cef_ptr cimport CefRefPtr # noinspection PyUnresolvedReferences from cef_callback cimport CefCompletionCallback cdef extern from "include/cef_cookie.h": ctypedef struct CefCookie: cef_string_t name cef_string_t value cef_string_t domain cef_string_t path cpp_bool secure cpp_bool httponly cef_time_t creation cef_time_t last_access cpp_bool has_expires cef_time_t expires cdef CefRefPtr[CefCookieManager] CefCookieManager_GetGlobalManager \ "CefCookieManager::GetGlobalManager"( CefRefPtr[CefCompletionCallback] callback) cdef CefRefPtr[CefCookieManager] CefCookieManager_CreateManager \ "CefCookieManager::CreateManager"( const CefString& path, cpp_bool persist_session_cookies, CefRefPtr[CefCompletionCallback] callback) cdef cppclass CefCookieManager: void SetSupportedSchemes(const cpp_vector[CefString]& schemes, CefRefPtr[CefCompletionCallback] callback) cpp_bool VisitAllCookies(CefRefPtr[CefCookieVisitor] visitor) cpp_bool VisitUrlCookies(const CefString& url, cpp_bool includeHttpOnly, CefRefPtr[CefCookieVisitor] visitor) cpp_bool SetCookie(const CefString& url, const CefCookie& cookie, CefRefPtr[CefSetCookieCallback] callback) cpp_bool DeleteCookies(const CefString& url, const CefString& cookie_name, CefRefPtr[CefDeleteCookiesCallback] callback) cpp_bool SetStoragePath(const CefString& path, cpp_bool persist_session_cookies, CefRefPtr[CefCompletionCallback] callback) # cpp_bool FlushStore(CefRefPtr[CefCompletionCallback] handler) cdef cppclass CefCookieVisitor: pass cdef cppclass CefSetCookieCallback: pass cdef cppclass CefDeleteCookiesCallback: pass cefpython-49.0/src/extern/cef/cef_cookie_manager_namespace.pxd000066400000000000000000000023201334103266300246050ustar00rootroot00000000000000# Copyright (c) 2013 CEF Python, see the Authors file. # All rights reserved. Licensed under BSD 3-clause license. # Project website: https://github.com/cztomczak/cefpython include "compile_time_constants.pxi" from libcpp cimport bool as cpp_bool from cef_string cimport CefString from cef_cookie cimport CefCookie # noinspection PyUnresolvedReferences from cef_cookie cimport CefSetCookieCallback, CefDeleteCookiesCallback from cef_ptr cimport CefRefPtr # We need to pass C++ class methods by reference to a function, # it is not possible with such syntax: # | &CefCookieManager.SetCookie # We had to create this addional pxd file so we can pass it like this: # | &cef_cookie_manager_namespace.SetCookie # In cookie.pyx > PyCookieManager.SetCookie(). # See this topic: # https://groups.google.com/d/topic/cython-users/G-vEdIkmNNY/discussion cdef extern from "include/cef_cookie.h" namespace "CefCookieManager": cpp_bool SetCookie(const CefString& url, const CefCookie& cookie, CefRefPtr[CefSetCookieCallback] callback) cpp_bool DeleteCookies(const CefString& url, const CefString& cookie_name, CefRefPtr[CefDeleteCookiesCallback] callback) cefpython-49.0/src/extern/cef/cef_drag_data.pxd000066400000000000000000000014201334103266300215340ustar00rootroot00000000000000# Copyright (c) 2016 CEF Python, see the Authors file. # All rights reserved. Licensed under BSD 3-clause license. # Project website: https://github.com/cztomczak/cefpython from libcpp cimport bool as cpp_bool from cef_string cimport CefString from cef_ptr cimport CefRefPtr cdef extern from "include/cef_drag_data.h": cdef cppclass CefDragData: cpp_bool IsLink() cpp_bool IsFragment() CefString GetLinkURL() CefString GetLinkTitle() CefString GetFragmentText() CefString GetFragmentHtml() void SetFragmentText(const CefString& text) void SetFragmentHtml(const CefString& html) void SetFragmentBaseURL(const CefString& base_url) cdef CefRefPtr[CefDragData] CefDragData_Create "CefDragData::Create"() cefpython-49.0/src/extern/cef/cef_frame.pxd000066400000000000000000000022361334103266300207260ustar00rootroot00000000000000# Copyright (c) 2012 CEF Python, see the Authors file. # All rights reserved. Licensed under BSD 3-clause license. # Project website: https://github.com/cztomczak/cefpython include "compile_time_constants.pxi" from cef_types cimport int64 from cef_string cimport CefString from libcpp cimport bool as cpp_bool from cef_ptr cimport CefRefPtr from cef_browser cimport CefBrowser from cef_string_visitor cimport CefStringVisitor cdef extern from "include/cef_frame.h": cdef cppclass CefFrame: cpp_bool IsValid() void ExecuteJavaScript(CefString& jsCode, CefString& scriptUrl, int startLine) CefString GetURL() int64 GetIdentifier() cpp_bool IsMain() void LoadURL(CefString& url) void Undo() void Redo() void Cut() void Copy() void Paste() void Delete() void SelectAll() void ViewSource() void GetSource(CefRefPtr[CefStringVisitor] visitor) void GetText(CefRefPtr[CefStringVisitor] visitor) void LoadString(CefString& string_val, CefString& url) cpp_bool IsFocused() CefString GetName() CefRefPtr[CefFrame] GetParent() CefRefPtr[CefBrowser] GetBrowser() cefpython-49.0/src/extern/cef/cef_image.pxd000066400000000000000000000020501334103266300207100ustar00rootroot00000000000000# Copyright (c) 2016 CEF Python, see the Authors file. # All rights reserved. Licensed under BSD 3-clause license. # Project website: https://github.com/cztomczak/cefpython from cef_ptr cimport CefRefPtr from libcpp cimport bool as cpp_bool from cef_values cimport CefBinaryValue from cef_types cimport cef_color_type_t, cef_alpha_type_t cdef extern from "include/cef_image.h": cdef cppclass CefImage: size_t GetWidth() size_t GetHeight() CefRefPtr[CefBinaryValue] GetAsBitmap(float scale_factor, cef_color_type_t color_type, cef_alpha_type_t alpha_type, int& pixel_width, int& pixel_height) CefRefPtr[CefBinaryValue] GetAsPNG(float scale_factor, cpp_bool with_transparency, int& pixel_width, int& pixel_height) cefpython-49.0/src/extern/cef/cef_jsdialog_handler.pxd000066400000000000000000000006541334103266300231270ustar00rootroot00000000000000# Copyright (c) 2016 CEF Python, see the Authors file. # All rights reserved. Licensed under BSD 3-clause license. # Project website: https://github.com/cztomczak/cefpython from cef_string cimport CefString from libcpp cimport bool as cpp_bool cdef extern from "include/cef_jsdialog_handler.h": cdef cppclass CefJSDialogCallback: void Continue(cpp_bool success, const CefString& user_input) cefpython-49.0/src/extern/cef/cef_linux.pxd000066400000000000000000000013671334103266300207770ustar00rootroot00000000000000# Copyright (c) 2012 CEF Python, see the Authors file. # All rights reserved. Licensed under BSD 3-clause license. # Project website: https://github.com/cztomczak/cefpython include "compile_time_constants.pxi" from libcpp cimport bool as cpp_bool from cef_types cimport CefRect cdef extern from "include/internal/cef_linux.h": ctypedef unsigned long CefWindowHandle ctypedef unsigned long CefCursorHandle cdef cppclass CefWindowInfo: void SetAsChild(CefWindowHandle parent, const CefRect& windowRect) void SetAsWindowless(CefWindowHandle parent, cpp_bool transparent) cdef cppclass CefMainArgs: CefMainArgs() CefMainArgs(int argc_arg, char** argv_arg) cefpython-49.0/src/extern/cef/cef_mac.pxd000066400000000000000000000013201334103266300203650ustar00rootroot00000000000000# Copyright (c) 2015 CEF Python, see the Authors file. # All rights reserved. Licensed under BSD 3-clause license. # Project website: https://github.com/cztomczak/cefpython include "compile_time_constants.pxi" from libcpp cimport bool as cpp_bool cdef extern from "include/internal/cef_mac.h": ctypedef void* CefWindowHandle ctypedef void* CefCursorHandle cdef cppclass CefWindowInfo: void SetAsChild(CefWindowHandle parent, int x, int y, int width, int height) void SetAsWindowless(CefWindowHandle parent, cpp_bool transparent) cdef cppclass CefMainArgs: CefMainArgs() CefMainArgs(int argc_arg, char** argv_arg) cefpython-49.0/src/extern/cef/cef_path_util.pxd000066400000000000000000000006761334103266300216330ustar00rootroot00000000000000# Copyright (c) 2016 CEF Python, see the Authors file. # All rights reserved. Licensed under BSD 3-clause license. # Project website: https://github.com/cztomczak/cefpython from cef_types cimport PathKey from cef_string cimport CefString from libcpp cimport bool as cpp_bool cdef extern from "include/cef_path_util.h" nogil: cpp_bool CefGetPath(PathKey key, CefString& path) cpp_bool CefOverridePath(PathKey key, const CefString& path) cefpython-49.0/src/extern/cef/cef_platform.pxd000066400000000000000000000006571334103266300214650ustar00rootroot00000000000000# Copyright (c) 2012 CEF Python, see the Authors file. # All rights reserved. Licensed under BSD 3-clause license. # Project website: https://github.com/cztomczak/cefpython include "compile_time_constants.pxi" IF UNAME_SYSNAME == "Windows": # noinspection PyUnresolvedReferences from cef_win cimport * ELIF UNAME_SYSNAME == "Darwin": from cef_mac cimport * ELIF UNAME_SYSNAME == "Linux": from cef_linux cimport * cefpython-49.0/src/extern/cef/cef_process_message.pxd000066400000000000000000000015471334103266300230220ustar00rootroot00000000000000# Copyright (c) 2013 CEF Python, see the Authors file. # All rights reserved. Licensed under BSD 3-clause license. # Project website: https://github.com/cztomczak/cefpython # noinspection PyUnresolvedReferences from cef_types cimport cef_process_id_t from cef_ptr cimport CefRefPtr from cef_string cimport CefString from libcpp cimport bool as cpp_bool from cef_values cimport CefListValue cdef extern from "include/cef_process_message.h": cdef CefRefPtr[CefProcessMessage] CefProcessMessage_Create \ "CefProcessMessage::Create"(const CefString& name) cdef cppclass CefProcessMessage: cpp_bool IsValid() cpp_bool IsReadOnly() CefRefPtr[CefProcessMessage] Copy() CefString GetName() CefRefPtr[CefListValue] GetArgumentList() # noinspection PyUnresolvedReferences ctypedef cef_process_id_t CefProcessId cefpython-49.0/src/extern/cef/cef_ptr.pxd000066400000000000000000000012331334103266300204350ustar00rootroot00000000000000# Copyright (c) 2012 CEF Python, see the Authors file. # All rights reserved. Licensed under BSD 3-clause license. # Project website: https://github.com/cztomczak/cefpython cdef extern from "include/internal/cef_ptr.h": cdef cppclass CefRefPtr[T]: CefRefPtr() # noinspection PyUnresolvedReferences CefRefPtr(T* p) # noinspection PyUnresolvedReferences CefRefPtr(const CefRefPtr[T]& r) # noinspection PyUnresolvedReferences T* get() # noinspection PyUnresolvedReferences void swap(CefRefPtr[T]& r) # noinspection PyUnresolvedReferences CefRefPtr[T]& Assign "operator="(T* p) cefpython-49.0/src/extern/cef/cef_request.pxd000066400000000000000000000050311334103266300213200ustar00rootroot00000000000000# Copyright (c) 2013 CEF Python, see the Authors file. # All rights reserved. Licensed under BSD 3-clause license. # Project website: https://github.com/cztomczak/cefpython from cef_ptr cimport CefRefPtr from cef_string cimport CefString # noinspection PyUnresolvedReferences from cef_types cimport cef_urlrequest_flags_t, cef_postdataelement_type_t # noinspection PyUnresolvedReferences from libcpp.vector cimport vector as cpp_vector from libcpp cimport bool as cpp_bool # noinspection PyUnresolvedReferences from multimap cimport multimap as cpp_multimap cdef extern from "include/cef_request.h": # This types won't be visible in pyx files! ctypedef cpp_multimap[CefString, CefString] HeaderMap # ctypedef cef_urlrequest_flags_t CefRequestFlags cdef CefRefPtr[CefRequest] CefRequest_Create "CefRequest::Create"() cdef cppclass CefRequest: cpp_bool IsReadOnly() CefString GetURL() void SetURL(CefString& url) CefString GetMethod() void SetMethod(CefString& method) CefRefPtr[CefPostData] GetPostData() void SetPostData(CefRefPtr[CefPostData] postData) void GetHeaderMap(HeaderMap& headerMap) void SetHeaderMap(HeaderMap& headerMap) void Set(CefString& url, CefString& method, CefRefPtr[CefPostData] postData, HeaderMap& headerMap) int GetFlags() void SetFlags(int flags) CefString GetFirstPartyForCookies() void SetFirstPartyForCookies(CefString& url) # noinspection PyUnresolvedReferences ctypedef cpp_vector[CefRefPtr[CefPostDataElement]] ElementVector cdef CefRefPtr[CefPostData] CefPostData_Create \ "CefPostData::Create"() cdef cppclass CefPostData: cpp_bool IsReadOnly() size_t GetElementCount() void GetElements(ElementVector& elements) cpp_bool RemoveElement(CefRefPtr[CefPostDataElement] element) cpp_bool AddElement(CefRefPtr[CefPostDataElement] element) void RemoveElements() # noinspection PyUnresolvedReferences ctypedef cef_postdataelement_type_t ElementType cdef CefRefPtr[CefPostDataElement] CefPostDataElement_Create \ "CefPostDataElement::Create"() cdef cppclass CefPostDataElement: cpp_bool IsReadOnly() void SetToEmpty() void SetToFile(CefString& fileName) void SetToBytes(size_t size, void* bytes_) ElementType GetType() CefString GetFile() size_t GetBytesCount() size_t GetBytes(size_t size, void* bytes_) cefpython-49.0/src/extern/cef/cef_request_context.pxd000066400000000000000000000012261334103266300230660ustar00rootroot00000000000000# Copyright (c) 2013 CEF Python, see the Authors file. # All rights reserved. Licensed under BSD 3-clause license. # Project website: https://github.com/cztomczak/cefpython from cef_ptr cimport CefRefPtr # noinspection PyUnresolvedReferences from cef_request_context_handler cimport CefRequestContextHandler cdef extern from "include/cef_request_context.h": cdef cppclass CefRequestContext: @staticmethod CefRefPtr[CefRequestContext] GetGlobalContext() @staticmethod CefRefPtr[CefRequestContext] CreateContext( CefRefPtr[CefRequestContext] other, CefRefPtr[CefRequestContextHandler] handler) cefpython-49.0/src/extern/cef/cef_request_context_handler.pxd000066400000000000000000000004411334103266300245610ustar00rootroot00000000000000# Copyright (c) 2013 CEF Python, see the Authors file. # All rights reserved. Licensed under BSD 3-clause license. # Project website: https://github.com/cztomczak/cefpython cdef extern from "include/cef_request_context_handler.h": cdef cppclass CefRequestContextHandler: pass cefpython-49.0/src/extern/cef/cef_request_handler.pxd000066400000000000000000000011261334103266300230160ustar00rootroot00000000000000# Copyright (c) 2012 CEF Python, see the Authors file. # All rights reserved. Licensed under BSD 3-clause license. # Project website: https://github.com/cztomczak/cefpython from cef_string cimport CefString from libcpp cimport bool as cpp_bool cdef extern from "include/cef_auth_callback.h": cdef cppclass CefAuthCallback: void Continue(const CefString& username, const CefString& password) void Cancel() cdef extern from "include/cef_request_handler.h": cdef cppclass CefRequestCallback: void Continue(cpp_bool allow) void Cancel() cefpython-49.0/src/extern/cef/cef_resource_handler.pxd000066400000000000000000000004241334103266300231550ustar00rootroot00000000000000# Copyright (c) 2013 CEF Python, see the Authors file. # All rights reserved. Licensed under BSD 3-clause license. # Project website: https://github.com/cztomczak/cefpython cdef extern from "include/cef_resource_handler.h": cdef cppclass CefResourceHandler: pass cefpython-49.0/src/extern/cef/cef_response.pxd000066400000000000000000000017441334103266300214750ustar00rootroot00000000000000# Copyright (c) 2013 CEF Python, see the Authors file. # All rights reserved. Licensed under BSD 3-clause license. # Project website: https://github.com/cztomczak/cefpython from cef_string cimport CefString # noinspection PyUnresolvedReferences from multimap cimport multimap as cpp_multimap from libcpp cimport bool as cpp_bool from cef_ptr cimport CefRefPtr cdef extern from "include/cef_response.h": ctypedef cpp_multimap[CefString, CefString] CefResponseHeaderMap cdef CefRefPtr[CefResponse] CefResponse_Create "CefResponse::Create"() cdef cppclass CefResponse: cpp_bool IsReadOnly() int GetStatus() void SetStatus(int status) CefString GetStatusText() void SetStatusText(CefString& statusText) CefString GetMimeType() void SetMimeType(CefString& mimeType) CefString GetHeader(CefString& name) void GetHeaderMap(CefResponseHeaderMap& headerMap) void SetHeaderMap(CefResponseHeaderMap& headerMap) cefpython-49.0/src/extern/cef/cef_scoped_ptr.pxd000066400000000000000000000010461334103266300217740ustar00rootroot00000000000000# Copyright (c) 2016 CEF Python, see the Authors file. # All rights reserved. Licensed under BSD 3-clause license. # Project website: https://github.com/cztomczak/cefpython cdef extern from "include/base/cef_scoped_ptr.h": cdef cppclass scoped_ptr[T]: scoped_ptr() # noinspection PyUnresolvedReferences scoped_ptr(T* p) # noinspection PyUnresolvedReferences void reset() # noinspection PyUnresolvedReferences void reset(T* p) # noinspection PyUnresolvedReferences T* get() cefpython-49.0/src/extern/cef/cef_string.pxd000066400000000000000000000015651334103266300211460ustar00rootroot00000000000000# Copyright (c) 2012 CEF Python, see the Authors file. # All rights reserved. Licensed under BSD 3-clause license. # Project website: https://github.com/cztomczak/cefpython from libcpp cimport bool as cpp_bool from libc.stddef cimport wchar_t from libcpp.string cimport string as cpp_string from wstring cimport wstring as cpp_wstring cdef extern from "include/internal/cef_string.h": ctypedef struct cef_string_t: pass cdef cppclass CefString: CefString() CefString(cef_string_t*) void Attach(cef_string_t* str, cpp_bool owner) cpp_bool empty() cpp_bool FromASCII(char*) # noinspection PyUnresolvedReferences cpp_bool FromString(wchar_t*, size_t, cpp_bool) cpp_bool FromString(cpp_string& str) cpp_string ToString() cpp_wstring ToWString() char* c_str() size_t length() cefpython-49.0/src/extern/cef/cef_string_visitor.pxd000066400000000000000000000004201334103266300227120ustar00rootroot00000000000000# Copyright (c) 2013 CEF Python, see the Authors file. # All rights reserved. Licensed under BSD 3-clause license. # Project website: https://github.com/cztomczak/cefpython cdef extern from "include/cef_string_visitor.h": cdef cppclass CefStringVisitor: pass cefpython-49.0/src/extern/cef/cef_task.pxd000066400000000000000000000014711334103266300205760ustar00rootroot00000000000000# Copyright (c) 2014 CEF Python, see the Authors file. # All rights reserved. Licensed under BSD 3-clause license. # Project website: https://github.com/cztomczak/cefpython from libcpp cimport bool as cpp_bool # noinspection PyUnresolvedReferences cimport cef_types from cef_types cimport int64 from cef_ptr cimport CefRefPtr cdef extern from "include/cef_task.h": ctypedef int CefThreadId ctypedef cef_types.cef_thread_id_t CefThreadId cdef cpp_bool CefCurrentlyOn(CefThreadId) cdef cpp_bool CefPostTask(CefThreadId threadId, CefRefPtr[CefTask] task) cdef cpp_bool CefPostDelayedTask(CefThreadId threadId, CefRefPtr[CefTask] task, int64 delay_ms) cdef cppclass CefTask: pass cefpython-49.0/src/extern/cef/cef_time.pxd000066400000000000000000000011621334103266300205670ustar00rootroot00000000000000# Copyright (c) 2013 CEF Python, see the Authors file. # All rights reserved. Licensed under BSD 3-clause license. # Project website: https://github.com/cztomczak/cefpython from ctime cimport time_t cdef extern from "include/internal/cef_time.h": ctypedef struct cef_time_t: int year int month int day_of_week int day_of_month int hour int minute int second int millisecond cdef extern from "include/internal/cef_types.h": cdef cppclass CefTime: CefTime() CefTime(cef_time_t&) void SetTimeT(time_t r) time_t GetTimeT() cefpython-49.0/src/extern/cef/cef_types.pxd000066400000000000000000000265651334103266300210130ustar00rootroot00000000000000# Copyright (c) 2012 CEF Python, see the Authors file. # All rights reserved. Licensed under BSD 3-clause license. # Project website: https://github.com/cztomczak/cefpython include "compile_time_constants.pxi" from libcpp cimport bool as cpp_bool # noinspection PyUnresolvedReferences from libc.stddef cimport wchar_t # noinspection PyUnresolvedReferences from libc.stdint cimport int32_t, uint32_t, int64_t, uint64_t from cef_string cimport cef_string_t # noinspection PyUnresolvedReferences from libc.limits cimport UINT_MAX cdef extern from "include/internal/cef_types.h": # noinspection PyUnresolvedReferences ctypedef int32_t int32 # noinspection PyUnresolvedReferences ctypedef uint32_t uint32 # noinspection PyUnresolvedReferences ctypedef int64_t int64 # noinspection PyUnresolvedReferences ctypedef uint64_t uint64 IF UNAME_SYSNAME == "Windows": # noinspection PyUnresolvedReferences ctypedef wchar_t char16 ELSE: ctypedef unsigned short char16 ctypedef uint32 cef_color_t ctypedef struct CefSettings: cef_string_t accept_language_list int single_process cef_string_t browser_subprocess_path int command_line_args_disabled cef_string_t cache_path int persist_session_cookies cef_string_t user_agent cef_string_t product_version cef_string_t locale cef_string_t log_file int log_severity int multi_threaded_message_loop cef_string_t javascript_flags cef_string_t resources_dir_path cef_string_t locales_dir_path int pack_loading_disabled int remote_debugging_port int uncaught_exception_stack_size int context_safety_implementation # Not exposed. int ignore_certificate_errors cef_color_t background_color int persist_user_preferences cef_string_t user_data_path int windowless_rendering_enabled int no_sandbox ctypedef struct CefBrowserSettings: cef_string_t accept_language_list cef_color_t background_color cef_string_t standard_font_family cef_string_t fixed_font_family cef_string_t serif_font_family cef_string_t sans_serif_font_family cef_string_t cursive_font_family cef_string_t fantasy_font_family int default_font_size int default_fixed_font_size int minimum_font_size int minimum_logical_font_size cef_string_t default_encoding cef_state_t remote_fonts cef_state_t javascript cef_state_t javascript_open_windows cef_state_t javascript_close_windows cef_state_t javascript_access_clipboard cef_state_t javascript_dom_paste cef_state_t plugins cef_state_t universal_access_from_file_urls cef_state_t file_access_from_file_urls cef_state_t web_security cef_state_t image_loading cef_state_t image_shrink_standalone_to_fit cef_state_t text_area_resize cef_state_t tab_to_links cef_state_t local_storage cef_state_t databases cef_state_t application_cache cef_state_t webgl int windowless_frame_rate cdef cppclass CefRect: int x, y, width, height CefRect() CefRect(int x, int y, int width, int height) cdef cppclass CefSize: int width, height CefSize() CefSize(int width, int height) cdef cppclass CefPoint: pass ctypedef struct CefRequestContextSettings: pass ctypedef enum cef_log_severity_t: LOGSEVERITY_DEFAULT, LOGSEVERITY_VERBOSE, LOGSEVERITY_INFO, LOGSEVERITY_WARNING, LOGSEVERITY_ERROR, LOGSEVERITY_DISABLE = 99, ctypedef enum cef_thread_id_t: TID_UI, TID_DB, TID_FILE, TID_FILE_USER_BLOCKING, TID_PROCESS_LAUNCHER, TID_CACHE, TID_IO, TID_RENDERER ctypedef enum cef_v8_propertyattribute_t: V8_PROPERTY_ATTRIBUTE_NONE = 0, # Writeable, Enumerable, # Configurable V8_PROPERTY_ATTRIBUTE_READONLY = 1 << 0, # Not writeable V8_PROPERTY_ATTRIBUTE_DONTENUM = 1 << 1, # Not enumerable V8_PROPERTY_ATTRIBUTE_DONTDELETE = 1 << 2 # Not configurable ctypedef enum cef_navigation_type_t: NAVIGATION_LINK_CLICKED = 0, NAVIGATION_FORM_SUBMITTED, NAVIGATION_BACK_FORWARD, NAVIGATION_RELOAD, NAVIGATION_FORM_RESUBMITTED, NAVIGATION_OTHER, ctypedef enum cef_process_id_t: PID_BROWSER, PID_RENDERER, ctypedef enum cef_state_t: STATE_DEFAULT = 0, STATE_ENABLED, STATE_DISABLED, ctypedef enum cef_postdataelement_type_t: PDE_TYPE_EMPTY = 0, PDE_TYPE_BYTES, PDE_TYPE_FILE, # WebRequest ctypedef enum cef_urlrequest_flags_t: UR_FLAG_NONE = 0, UR_FLAG_SKIP_CACHE = 1 << 0, UR_FLAG_ALLOW_CACHED_CREDENTIALS = 1 << 1, UR_FLAG_REPORT_UPLOAD_PROGRESS = 1 << 3, UR_FLAG_NO_DOWNLOAD_DATA = 1 << 6, UR_FLAG_NO_RETRY_ON_5XX = 1 << 7, # CefListValue, CefDictionaryValue - types. ctypedef enum cef_value_type_t: VTYPE_INVALID = 0, VTYPE_NULL, VTYPE_BOOL, VTYPE_INT, VTYPE_DOUBLE, VTYPE_STRING, VTYPE_BINARY, VTYPE_DICTIONARY, VTYPE_LIST, # KeyboardHandler ctypedef void* CefEventHandle ctypedef enum cef_key_event_type_t: KEYEVENT_RAWKEYDOWN = 0, KEYEVENT_KEYDOWN, KEYEVENT_KEYUP, KEYEVENT_CHAR ctypedef struct _cef_key_event_t: cef_key_event_type_t type uint32 modifiers int windows_key_code int native_key_code int is_system_key char16 character char16 unmodified_character cpp_bool focus_on_editable_field ctypedef _cef_key_event_t CefKeyEvent ctypedef enum cef_event_flags_t: EVENTFLAG_NONE = 0, EVENTFLAG_CAPS_LOCK_ON = 1 << 0, EVENTFLAG_SHIFT_DOWN = 1 << 1, EVENTFLAG_CONTROL_DOWN = 1 << 2, EVENTFLAG_ALT_DOWN = 1 << 3, EVENTFLAG_LEFT_MOUSE_BUTTON = 1 << 4, EVENTFLAG_MIDDLE_MOUSE_BUTTON = 1 << 5, EVENTFLAG_RIGHT_MOUSE_BUTTON = 1 << 6, # Mac OS-X command key. EVENTFLAG_COMMAND_DOWN = 1 << 7, EVENTFLAG_NUM_LOCK_ON = 1 << 8, EVENTFLAG_IS_KEY_PAD = 1 << 9, EVENTFLAG_IS_LEFT = 1 << 10, EVENTFLAG_IS_RIGHT = 1 << 11, # LoadHandler ctypedef enum cef_termination_status_t: TS_ABNORMAL_TERMINATION, TS_PROCESS_WAS_KILLED, TS_PROCESS_CRASHED, ctypedef enum cef_errorcode_t: ERR_NONE = 0, ERR_FAILED = -2, ERR_ABORTED = -3, ERR_INVALID_ARGUMENT = -4, ERR_INVALID_HANDLE = -5, ERR_FILE_NOT_FOUND = -6, ERR_TIMED_OUT = -7, ERR_FILE_TOO_BIG = -8, ERR_UNEXPECTED = -9, ERR_ACCESS_DENIED = -10, ERR_NOT_IMPLEMENTED = -11, ERR_CONNECTION_CLOSED = -100, ERR_CONNECTION_RESET = -101, ERR_CONNECTION_REFUSED = -102, ERR_CONNECTION_ABORTED = -103, ERR_CONNECTION_FAILED = -104, ERR_NAME_NOT_RESOLVED = -105, ERR_INTERNET_DISCONNECTED = -106, ERR_SSL_PROTOCOL_ERROR = -107, ERR_ADDRESS_INVALID = -108, ERR_ADDRESS_UNREACHABLE = -109, ERR_SSL_CLIENT_AUTH_CERT_NEEDED = -110, ERR_TUNNEL_CONNECTION_FAILED = -111, ERR_NO_SSL_VERSIONS_ENABLED = -112, ERR_SSL_VERSION_OR_CIPHER_MISMATCH = -113, ERR_SSL_RENEGOTIATION_REQUESTED = -114, ERR_CERT_COMMON_NAME_INVALID = -200, ERR_CERT_DATE_INVALID = -201, ERR_CERT_AUTHORITY_INVALID = -202, ERR_CERT_CONTAINS_ERRORS = -203, ERR_CERT_NO_REVOCATION_MECHANISM = -204, ERR_CERT_UNABLE_TO_CHECK_REVOCATION = -205, ERR_CERT_REVOKED = -206, ERR_CERT_INVALID = -207, ERR_CERT_END = -208, ERR_INVALID_URL = -300, ERR_DISALLOWED_URL_SCHEME = -301, ERR_UNKNOWN_URL_SCHEME = -302, ERR_TOO_MANY_REDIRECTS = -310, ERR_UNSAFE_REDIRECT = -311, ERR_UNSAFE_PORT = -312, ERR_INVALID_RESPONSE = -320, ERR_INVALID_CHUNKED_ENCODING = -321, ERR_METHOD_NOT_SUPPORTED = -322, ERR_UNEXPECTED_PROXY_AUTH = -323, ERR_EMPTY_RESPONSE = -324, ERR_RESPONSE_HEADERS_TOO_BIG = -325, ERR_CACHE_MISS = -400, ERR_INSECURE_RESPONSE = -501, # Browser > GetImage(), RenderHandler > OnPaint(). ctypedef enum cef_paint_element_type_t: PET_VIEW = 0, PET_POPUP, ctypedef cef_paint_element_type_t PaintElementType # Browser > SendMouseClickEvent(). ctypedef enum cef_mouse_button_type_t: MBT_LEFT = 0, MBT_MIDDLE, MBT_RIGHT, ctypedef struct cef_mouse_event_t: int x int y uint32 modifiers ctypedef cef_mouse_event_t CefMouseEvent # RenderHandler > GetScreenInfo(): ctypedef struct cef_rect_t: int x int y int width int height ctypedef struct cef_screen_info_t: float device_scale_factor int depth int depth_per_component cpp_bool is_monochrome cef_rect_t rect cef_rect_t available_rect ctypedef cef_screen_info_t CefScreenInfo # CefURLRequest.GetStatus() ctypedef enum cef_urlrequest_status_t: UR_UNKNOWN = 0 UR_SUCCESS UR_IO_PENDING UR_CANCELED UR_FAILED # CefJSDialogHandler.OnJSDialog() ctypedef enum cef_jsdialog_type_t: JSDIALOGTYPE_ALERT = 0, JSDIALOGTYPE_CONFIRM, JSDIALOGTYPE_PROMPT, ctypedef cef_jsdialog_type_t JSDIalogType # LifespanHandler and RequestHandler ctypedef enum cef_window_open_disposition_t: WOD_UNKNOWN, WOD_CURRENT_TAB, WOD_SINGLETON_TAB, WOD_NEW_FOREGROUND_TAB, WOD_NEW_BACKGROUND_TAB, WOD_NEW_POPUP, WOD_NEW_WINDOW, WOD_SAVE_TO_DISK, WOD_OFF_THE_RECORD, WOD_IGNORE_ACTION ctypedef cef_window_open_disposition_t WindowOpenDisposition ctypedef enum cef_path_key_t: PK_DIR_CURRENT, PK_DIR_EXE, PK_DIR_MODULE, PK_DIR_TEMP, PK_FILE_EXE, PK_FILE_MODULE, PK_LOCAL_APP_DATA, PK_USER_DATA, ctypedef cef_path_key_t PathKey ctypedef enum cef_plugin_policy_t: PLUGIN_POLICY_ALLOW, PLUGIN_POLICY_DETECT_IMPORTANT, PLUGIN_POLICY_BLOCK, PLUGIN_POLICY_DISABLE, # Drag & drop ctypedef enum cef_drag_operations_mask_t: DRAG_OPERATION_NONE = 0 DRAG_OPERATION_COPY = 1 DRAG_OPERATION_LINK = 2 DRAG_OPERATION_GENERIC = 4 DRAG_OPERATION_PRIVATE = 8 DRAG_OPERATION_MOVE = 16 DRAG_OPERATION_DELETE = 32 DRAG_OPERATION_EVERY = UINT_MAX ctypedef enum cef_color_type_t: CEF_COLOR_TYPE_RGBA_8888, CEF_COLOR_TYPE_BGRA_8888, ctypedef enum cef_alpha_type_t: CEF_ALPHA_TYPE_OPAQUE, CEF_ALPHA_TYPE_PREMULTIPLIED, CEF_ALPHA_TYPE_POSTMULTIPLIED, ctypedef enum cef_focus_source_t: FOCUS_SOURCE_NAVIGATION, FOCUS_SOURCE_SYSTEM, cefpython-49.0/src/extern/cef/cef_urlrequest.pxd000066400000000000000000000020271334103266300220450ustar00rootroot00000000000000# Copyright (c) 2013 CEF Python, see the Authors file. # All rights reserved. Licensed under BSD 3-clause license. # Project website: https://github.com/cztomczak/cefpython from cef_ptr cimport CefRefPtr cimport cef_types from cef_request cimport CefRequest from cef_response cimport CefResponse # noinspection PyUnresolvedReferences from cef_request_context cimport CefRequestContext cdef extern from "include/cef_urlrequest.h": cdef CefRefPtr[CefURLRequest] CefURLRequest_Create \ "CefURLRequest::Create"( CefRefPtr[CefRequest] request, CefRefPtr[CefURLRequestClient] client, CefRefPtr[CefRequestContext]) cdef cppclass CefURLRequest: CefRefPtr[CefRequest] GetRequest() CefRefPtr[CefURLRequestClient] GetClient() cef_types.cef_urlrequest_status_t GetRequestStatus() cef_types.cef_errorcode_t GetRequestError() CefRefPtr[CefResponse] GetResponse() void Cancel() cdef cppclass CefURLRequestClient: pass cefpython-49.0/src/extern/cef/cef_values.pxd000066400000000000000000000065471334103266300211440ustar00rootroot00000000000000# Copyright (c) 2013 CEF Python, see the Authors file. # All rights reserved. Licensed under BSD 3-clause license. # Project website: https://github.com/cztomczak/cefpython from cef_ptr cimport CefRefPtr from libcpp cimport bool as cpp_bool from cef_string cimport CefString from libcpp.vector cimport vector from cef_types cimport cef_value_type_t cdef extern from "include/cef_values.h": cdef CefRefPtr[CefBinaryValue] CefBinaryValue_Create \ "CefBinaryValue::Create"(const void* data, size_t data_size) cdef cppclass CefBinaryValue: cpp_bool IsValid() cpp_bool IsOwned() CefRefPtr[CefBinaryValue] Copy() size_t GetSize() size_t GetData(void* buffer_, size_t buffer_size, size_t data_offset) cdef CefRefPtr[CefDictionaryValue] CefDictionaryValue_Create \ "CefDictionaryValue::Create"() cdef cppclass CefDictionaryValue: cpp_bool IsValid() cpp_bool IsOwned() cpp_bool IsReadOnly() CefRefPtr[CefDictionaryValue] Copy(cpp_bool exclude_empty_children) size_t GetSize() cpp_bool Clear() cpp_bool HasKey(const CefString& key) cpp_bool GetKeys(vector[CefString]& keys) cpp_bool Remove(const CefString& key) cef_value_type_t GetType(const CefString& key) cpp_bool GetBool(const CefString& key) int GetInt(const CefString& key) double GetDouble(const CefString& key) CefString GetString(const CefString& key) CefRefPtr[CefBinaryValue] GetBinary(const CefString& key) CefRefPtr[CefDictionaryValue] GetDictionary(const CefString& key) CefRefPtr[CefListValue] GetList(const CefString& key) cpp_bool SetNull(const CefString& key) cpp_bool SetBool(const CefString& key, cpp_bool value) cpp_bool SetInt(const CefString& key, int value) cpp_bool SetDouble(const CefString& key, double value) cpp_bool SetString(const CefString& key, const CefString& value) cpp_bool SetBinary(const CefString& key, CefRefPtr[CefBinaryValue] value) cpp_bool SetDictionary(const CefString& key, CefRefPtr[CefDictionaryValue] value) cpp_bool SetList(const CefString& key, CefRefPtr[CefListValue] value) cdef CefRefPtr[CefListValue] CefListValue_Create "CefListValue::Create"() cdef cppclass CefListValue: cpp_bool IsValid() cpp_bool IsOwned() cpp_bool IsReadOnly() CefRefPtr[CefListValue] Copy() cpp_bool SetSize(size_t size) size_t GetSize() cpp_bool Clear() cpp_bool Remove(int index) cef_value_type_t GetType(int index) cpp_bool GetBool(int index) int GetInt(int index) double GetDouble(int index) CefString GetString(int index) CefRefPtr[CefBinaryValue] GetBinary(int index) CefRefPtr[CefDictionaryValue] GetDictionary(int index) CefRefPtr[CefListValue] GetList(int index) cpp_bool SetNull(int index) cpp_bool SetBool(int index, cpp_bool value) cpp_bool SetInt(int index, int value) cpp_bool SetDouble(int index, double value) cpp_bool SetString(int index, const CefString& value) cpp_bool SetBinary(int index, CefRefPtr[CefBinaryValue] value) cpp_bool SetDictionary(int index, CefRefPtr[CefDictionaryValue] value) cpp_bool SetList(int index, CefRefPtr[CefListValue] value) cefpython-49.0/src/extern/cef/cef_views.pxd000066400000000000000000000053571334103266300210000ustar00rootroot00000000000000# Copyright (c) 2017 CEF Python, see the Authors file. # All rights reserved. Licensed under BSD 3-clause license. # Project website: https://github.com/cztomczak/cefpython from cef_ptr cimport CefRefPtr from cef_browser cimport CefWindowHandle from cef_types cimport CefRect, CefSize from libcpp cimport bool as cpp_bool cdef extern from "include/internal/cef_types.h": ctypedef struct cef_insets_t: int top; int left; int bottom; int right; ctypedef enum cef_main_axis_alignment_t: CEF_MAIN_AXIS_ALIGNMENT_START, CEF_MAIN_AXIS_ALIGNMENT_CENTER, CEF_MAIN_AXIS_ALIGNMENT_END, ctypedef enum cef_cross_axis_alignment_t: CEF_CROSS_AXIS_ALIGNMENT_STRETCH, CEF_CROSS_AXIS_ALIGNMENT_START, CEF_CROSS_AXIS_ALIGNMENT_CENTER, CEF_CROSS_AXIS_ALIGNMENT_END, ctypedef struct CefBoxLayoutSettings: int horizontal; int inside_border_horizontal_spacing; int inside_border_vertical_spacing; cef_insets_t inside_border_insets; int between_child_spacing; cef_main_axis_alignment_t main_axis_alignment; cef_cross_axis_alignment_t cross_axis_alignment; int minimum_cross_axis_size; int default_flex; """ # CEF Views cdef extern from "include/views/cef_box_layout.h": cdef cppclass CefBoxLayout: void SetFlexForView(CefRefPtr[CefWindow] view, int flex) cdef extern from "include/views/cef_window_delegate.h": cdef cppclass CefWindowDelegate: pass cdef extern from "include/views/cef_view.h": cdef cppclass CefView: pass cdef extern from "include/views/cef_panel_delegate.h": cdef cppclass CefPanelDelegate: pass cdef extern from "include/views/cef_panel.h": cdef cppclass CefPanel: @staticmethod CefRefPtr[CefPanel] CreatePanel(CefRefPtr[CefPanelDelegate] delegate) cdef extern from "include/views/cef_fill_layout.h": cdef cppclass CefFillLayout: pass cdef extern from "include/views/cef_window.h": cdef cppclass CefWindow: @staticmethod CefRefPtr[CefWindow] CreateTopLevelWindow( CefRefPtr[CefWindowDelegate] delegate) void Show() CefWindowHandle GetWindowHandle() void SetBounds(const CefRect& bounds) void CenterWindow(const CefSize& size) void SetVisible(cpp_bool visible) void Layout() CefRefPtr[CefFillLayout] SetToFillLayout() CefRefPtr[CefBoxLayout] SetToBoxLayout( const CefBoxLayoutSettings& settings) void RequestFocus() void RemoveAllChildViews() size_t GetChildViewCount() void AddChildView(CefRefPtr[CefPanel] view) void ReorderChildView(CefRefPtr[CefPanel] view, int index) """ cefpython-49.0/src/extern/cef/cef_web_plugin.pxd000066400000000000000000000006531334103266300217700ustar00rootroot00000000000000# Copyright (c) 2013 CEF Python, see the Authors file. # All rights reserved. Licensed under BSD 3-clause license. # Project website: https://github.com/cztomczak/cefpython from cef_string cimport CefString # CEF 3 only. cdef extern from "include/cef_web_plugin.h": cdef cppclass CefWebPluginInfo: CefString GetName() CefString GetPath() CefString GetVersion() CefString GetDescription() cefpython-49.0/src/extern/cef/cef_win.pxd000066400000000000000000000017431334103266300204330ustar00rootroot00000000000000# Copyright (c) 2012 CEF Python, see the Authors file. # All rights reserved. Licensed under BSD 3-clause license. # Project website: https://github.com/cztomczak/cefpython include "compile_time_constants.pxi" # noinspection PyUnresolvedReferences from windows cimport HWND, RECT, HINSTANCE, HCURSOR from cef_string cimport CefString from libcpp cimport bool as cpp_bool cdef extern from "include/internal/cef_win.h": # noinspection PyUnresolvedReferences ctypedef HWND CefWindowHandle # noinspection PyUnresolvedReferences ctypedef HCURSOR CefCursorHandle cdef cppclass CefWindowInfo: void SetAsChild(CefWindowHandle parent, RECT windowRect) void SetAsPopup(CefWindowHandle parent, const CefString& windowName) void SetAsWindowless(CefWindowHandle parent, cpp_bool transparent) cdef cppclass CefMainArgs: CefMainArgs() CefMainArgs(HINSTANCE hInstance) cefpython-49.0/src/extern/cef_log.pxd000066400000000000000000000005021334103266300176520ustar00rootroot00000000000000# Copyright (c) 2017 CEF Python, see the Authors file. # All rights reserved. Licensed under BSD 3-clause license. # Project website: https://github.com/cztomczak/cefpython cdef extern from "client_handler/cef_log.h": void cef_log_info(char* msg) void cef_log_warning(char* msg) void cef_log_error(char* msg) cefpython-49.0/src/extern/cefpython_app.pxd000066400000000000000000000004121334103266300211130ustar00rootroot00000000000000# Copyright (c) 2012 CEF Python, see the Authors file. # All rights reserved. Licensed under BSD 3-clause license. # Project website: https://github.com/cztomczak/cefpython cdef extern from "subprocess/cefpython_app.h": cdef cppclass CefPythonApp: pass cefpython-49.0/src/extern/client_handler.pxd000066400000000000000000000005101334103266300212260ustar00rootroot00000000000000# Copyright (c) 2012 CEF Python, see the Authors file. # All rights reserved. Licensed under BSD 3-clause license. # Project website: https://github.com/cztomczak/cefpython cdef extern from "client_handler/client_handler.h": cdef cppclass ClientHandler: pass cdef cppclass DevToolsClientHandler: pass cefpython-49.0/src/extern/cookie_visitor.pxd000066400000000000000000000004571334103266300213150ustar00rootroot00000000000000# Copyright (c) 2014 CEF Python, see the Authors file. # All rights reserved. Licensed under BSD 3-clause license. # Project website: https://github.com/cztomczak/cefpython cdef extern from "client_handler/cookie_visitor.h": cdef cppclass CookieVisitor: CookieVisitor(int cookieVisitorId) cefpython-49.0/src/extern/cpp_utils.pxd000066400000000000000000000006341334103266300202640ustar00rootroot00000000000000# Copyright (c) 2013 CEF Python, see the Authors file. # All rights reserved. Licensed under BSD 3-clause license. # Project website: https://github.com/cztomczak/cefpython cdef extern from "cpp_utils/PaintBuffer.h": cdef void FlipBufferUpsideDown( void* dest, void* src, int width, int height) cdef void SwapBufferFromBgraToRgba( void* dest, void* src, int width, int height) cefpython-49.0/src/extern/ctime.pxd000066400000000000000000000011561334103266300173630ustar00rootroot00000000000000# Copyright (c) 2013 CEF Python, see the Authors file. # All rights reserved. Licensed under BSD 3-clause license. # Project website: https://github.com/cztomczak/cefpython cdef extern from "time.h": ctypedef struct time_t: pass ctypedef struct tm: int tm_sec int tm_min int tm_hour int tm_mday int tm_mon int tm_year int tm_wday int tm_yday int tm_isdst size_t strftime (char* ptr, size_t maxsize, const char* format_, const tm* timeptr ) tm* localtime (const time_t* timer) time_t mktime (tm* timeptr)cefpython-49.0/src/extern/dpi_aware_win.pxd000066400000000000000000000006731334103266300210750ustar00rootroot00000000000000# Copyright (c) 2014 CEF Python, see the Authors file. # All rights reserved. Licensed under BSD 3-clause license. # Project website: https://github.com/cztomczak/cefpython from libcpp cimport bool as cpp_bool cdef extern from "client_handler/dpi_aware.h": cdef void GetSystemDpi(int* dpix, int* dpiy) cdef void GetDpiAwareWindowSize(int* width, int* height) cdef void SetProcessDpiAware() cdef cpp_bool IsProcessDpiAware() cefpython-49.0/src/extern/linux.pxd000066400000000000000000000005771334103266300174270ustar00rootroot00000000000000# Copyright (c) 2013 CEF Python, see the Authors file. # All rights reserved. Licensed under BSD 3-clause license. # Project website: https://github.com/cztomczak/cefpython cdef extern from "gtk/gtk.h" nogil: ctypedef void* GdkNativeWindow ctypedef void* GtkWidget cdef GtkWidget* gtk_plug_new(GdkNativeWindow socket_id) cdef void gtk_widget_show(GtkWidget* widget) cefpython-49.0/src/extern/mac.pxd000066400000000000000000000006001334103266300170130ustar00rootroot00000000000000# Copyright (c) 2015 CEF Python, see the Authors file. # All rights reserved. Licensed under BSD 3-clause license. # Project website: https://github.com/cztomczak/cefpython from cef_ptr cimport CefRefPtr from cef_browser cimport CefBrowser cdef extern from "client_handler/util_mac.h": void MacInitialize() void MacSetWindowTitle(CefRefPtr[CefBrowser] browser, char* title) cefpython-49.0/src/extern/multimap.pxd000066400000000000000000000020651334103266300201120ustar00rootroot00000000000000# Copyright (c) 2012 CEF Python, see the Authors file. # All rights reserved. Licensed under BSD 3-clause license. # Project website: https://github.com/cztomczak/cefpython from libcpp.utility cimport pair # Copied from: Cython/Includes/libcpp/map.pxd cdef extern from "" namespace "std": cdef cppclass multimap[T, U]: cppclass iterator: # noinspection PyUnresolvedReferences pair[T, U]& operator*() nogil iterator operator++() nogil iterator operator--() nogil bint operator==(iterator) nogil bint operator!=(iterator) nogil multimap() nogil except + # noinspection PyUnresolvedReferences U& operator[](T&) nogil # noinspection PyUnresolvedReferences iterator begin() nogil # noinspection PyUnresolvedReferences iterator end() nogil # noinspection PyUnresolvedReferences pair[iterator, bint] insert(pair[T, U]) nogil # XXX pair[T,U]& # noinspection PyUnresolvedReferences iterator find(T&) nogil cefpython-49.0/src/extern/request_context_handler.pxd000066400000000000000000000007141334103266300232120ustar00rootroot00000000000000# Copyright (c) 2013 CEF Python, see the Authors file. # All rights reserved. Licensed under BSD 3-clause license. # Project website: https://github.com/cztomczak/cefpython from cef_ptr cimport CefRefPtr from cef_browser cimport CefBrowser cdef extern from "client_handler/request_context_handler.h": cdef cppclass RequestContextHandler: RequestContextHandler(CefRefPtr[CefBrowser] browser) void SetBrowser(CefRefPtr[CefBrowser] browser) cefpython-49.0/src/extern/resource_handler.pxd000066400000000000000000000004671334103266300216120ustar00rootroot00000000000000# Copyright (c) 2013 CEF Python, see the Authors file. # All rights reserved. Licensed under BSD 3-clause license. # Project website: https://github.com/cztomczak/cefpython cdef extern from "client_handler/resource_handler.h": cdef cppclass ResourceHandler: ResourceHandler(int resourceHandlerId) cefpython-49.0/src/extern/string_visitor.pxd000066400000000000000000000004571334103266300213520ustar00rootroot00000000000000# Copyright (c) 2013 CEF Python, see the Authors file. # All rights reserved. Licensed under BSD 3-clause license. # Project website: https://github.com/cztomczak/cefpython cdef extern from "client_handler/string_visitor.h": cdef cppclass StringVisitor: StringVisitor(int stringVisitorId) cefpython-49.0/src/extern/task.pxd000066400000000000000000000022451334103266300172240ustar00rootroot00000000000000# Copyright (c) 2014 CEF Python, see the Authors file. # All rights reserved. Licensed under BSD 3-clause license. # Project website: https://github.com/cztomczak/cefpython from cef_ptr cimport CefRefPtr # noinspection PyUnresolvedReferences from cef_task cimport CefTask from cef_string cimport CefString from cef_cookie cimport CefCookie, CefCookieManager # noinspection PyUnresolvedReferences from cef_cookie cimport CefSetCookieCallback, CefDeleteCookiesCallback # noinspection PyUnresolvedReferences from libcpp cimport bool as cpp_bool from cef_types cimport int64 cdef extern from "client_handler/task.h": void PostTaskWrapper(int threadId, int taskId) nogil void PostDelayedTaskWrapper(int threadId, int64 delay_ms, int taskId) nogil cdef CefRefPtr[CefTask] CreateTask_SetCookie( CefCookieManager* obj, const CefString& url, const CefCookie& cookie, CefRefPtr[CefSetCookieCallback] callback) cdef CefRefPtr[CefTask] CreateTask_DeleteCookies( CefCookieManager* obj, const CefString& url, const CefString& cookie_name, CefRefPtr[CefDeleteCookiesCallback] callback) cefpython-49.0/src/extern/web_request_client.pxd000066400000000000000000000004661334103266300221500ustar00rootroot00000000000000# Copyright (c) 2013 CEF Python, see the Authors file. # All rights reserved. Licensed under BSD 3-clause license. # Project website: https://github.com/cztomczak/cefpython cdef extern from "client_handler/web_request_client.h": cdef cppclass WebRequestClient: WebRequestClient(int webRequestId) cefpython-49.0/src/extern/windows.pxd000066400000000000000000000100521334103266300177470ustar00rootroot00000000000000# Copyright (c) 2012 CEF Python, see the Authors file. # All rights reserved. Licensed under BSD 3-clause license. # Project website: https://github.com/cztomczak/cefpython from libc.stddef cimport wchar_t cdef extern from *: ctypedef char const_char "const char" # noinspection PyUnresolvedReferences ctypedef wchar_t const_wchar_t "const wchar_t" cdef extern from "stdio.h" nogil: cdef int printf(const_char* TEMPLATE, ...) cdef int wprintf(const_wchar_t* TEMPLATE, ...) cdef extern from "Windows.h" nogil: ctypedef void* HANDLE ctypedef HANDLE HWND ctypedef HANDLE HINSTANCE ctypedef HANDLE HICON ctypedef HANDLE HDC ctypedef HANDLE HBITMAP ctypedef HICON HCURSOR ctypedef unsigned int UINT # noinspection PyUnresolvedReferences ctypedef wchar_t* LPCTSTR # noinspection PyUnresolvedReferences ctypedef wchar_t* LPTSTR ctypedef int BOOL ctypedef unsigned long DWORD ctypedef unsigned short WORD cdef HINSTANCE GetModuleHandle(LPCTSTR lpModuleName) ctypedef struct RECT: long left long top long right long bottom ctypedef RECT* LPRECT cdef UINT CP_UTF8 cdef UINT CP_ACP cdef DWORD WC_COMPOSITECHECK cdef int WideCharToMultiByte(int, int, wchar_t*, int, char*, int, char*, int*) cdef DWORD MB_COMPOSITE cdef int MultiByteToWideChar(int, int, char*, int, wchar_t*, int) cdef size_t mbstowcs(wchar_t *wcstr, const_char *mbstr, size_t count) ctypedef void* HDWP cdef int SWP_NOZORDER cdef int SWP_NOREDRAW cdef HDWP BeginDeferWindowPos(int nNumWindows) cdef HDWP DeferWindowPos( HDWP hWinPosInfo, HWND hWnd, HWND hWndInsertAfter, int x, int y, int cx, int cy, UINT uFlags) cdef BOOL EndDeferWindowPos(HDWP hWinPosInfo) cdef BOOL GetClientRect(HWND hWnd, LPRECT lpRect) ctypedef unsigned int WPARAM ctypedef unsigned int LPARAM cdef UINT WM_SETFOCUS cdef BOOL PostMessage( HWND hWnd, UINT Msg, WPARAM wParam, LPARAM lParam) ctypedef unsigned int UINT_PTR ctypedef unsigned int UINT ctypedef struct TIMERPROC: pass cdef UINT_PTR SetTimer( HWND hwnd, UINT_PTR nIDEvent, UINT uElapse, TIMERPROC lpTimerFunc) cdef int USER_TIMER_MINIMUM # Detecting 64bit platform in an IF condition not required, see: # https://groups.google.com/d/msg/cython-users/qb6VAR4OUms/HcLGwKwkwCgJ ctypedef long LONG_PTR ctypedef LONG_PTR LRESULT ctypedef long LONG cdef BOOL IsZoomed(HWND hWnd) cdef LRESULT SendMessage( HWND hWnd, UINT Msg, WPARAM wParam, LPARAM lParam) cdef UINT WM_SYSCOMMAND cdef UINT SC_RESTORE cdef UINT SC_MAXIMIZE cdef int GWL_STYLE cdef int GWL_EXSTYLE cdef LONG GetWindowLong(HWND hWnd, int nIndex) cdef LONG SetWindowLong(HWND hWnd, int nIndex, LONG dwNewLong) cdef BOOL GetWindowRect(HWND hWnd, LPRECT lpRect) cdef int WS_CAPTION cdef int WS_THICKFRAME cdef int WS_EX_DLGMODALFRAME cdef int WS_EX_WINDOWEDGE cdef int WS_EX_CLIENTEDGE cdef int WS_EX_STATICEDGE cdef int MONITOR_DEFAULTTONEAREST ctypedef HANDLE HMONITOR ctypedef struct MONITORINFO: DWORD cbSize RECT rcMonitor RECT rcWork DWORD dwFlags ctypedef MONITORINFO* LPMONITORINFO cdef HMONITOR MonitorFromWindow(HWND hwnd, DWORD dwFlags) cdef BOOL GetMonitorInfo(HMONITOR hMonitor, LPMONITORINFO lpmi) cdef BOOL SetWindowPos( HWND hWnd, HWND hWndInsertAfter, int X, int Y, int cx, int cy, UINT uFlags) cdef int SWP_NOZORDER cdef int SWP_NOACTIVATE cdef int SWP_FRAMECHANGED cdef DWORD GetLastError() cdef BOOL IsWindow(HWND hWnd) cdef LRESULT DefWindowProc( HWND hWnd, UINT Msg, WPARAM wParam, LPARAM lParam) cdef int GetWindowTextW(HWND hWnd, wchar_t* lpString, int nMaxCount) cdef BOOL SetWindowTextW(HWND hWnd, wchar_t* lpString) cdef UINT WM_GETICON cdef UINT WM_SETICON cdef int ICON_BIG cdef int ICON_SMALL cdef HWND GetParent(HWND hwnd) cefpython-49.0/src/extern/wstring.pxd000066400000000000000000000101631334103266300177550ustar00rootroot00000000000000# Copyright (c) Cython from libc.stddef cimport wchar_t from libcpp.string cimport string cdef extern from *: # noinspection PyUnresolvedReferences ctypedef wchar_t const_wchar_t "const wchar_t" cdef extern from "" namespace "std": size_t npos = -1 cdef cppclass wstring: wstring() nogil except + wstring(wchar_t *) nogil except + wstring(wchar_t *, size_t) nogil except + wstring(string&) nogil except + # as a string formed by a repetition of character c, n times. wstring(size_t, char) nogil except + const_wchar_t* c_str() nogil const_wchar_t* data() nogil size_t size() nogil size_t max_size() nogil size_t length() nogil void resize(size_t) nogil void resize(size_t, char c) nogil size_t capacity() nogil void reserve(size_t) nogil void clear() nogil bint empty() nogil #char& at(size_t) nogil #char& operator[](size_t) nogil #int compare(string&) nogil #string& append(string&) nogil #string& append(string&, size_t, size_t) nogil #string& append(char *) nogil #string& append(char *, size_t) nogil #string& append(size_t, char) nogil #void push_back(char c) nogil #string& assign (string&) nogil #string& assign (string&, size_t, size_t) nogil #string& assign (char *, size_t) nogil #string& assign (char *) nogil #string& assign (size_t n, char c) nogil #string& insert(size_t, string&) nogil #string& insert(size_t, string&, size_t, size_t) nogil #string& insert(size_t, char* s, size_t) nogil #string& insert(size_t, char* s) nogil #string& insert(size_t, size_t, char c) nogil #size_t copy(char *, size_t, size_t) nogil #size_t find(string&) nogil #size_t find(string&, size_t) nogil #size_t find(char*, size_t pos, size_t) nogil #size_t find(char*, size_t pos) nogil #size_t find(char, size_t pos) nogil #size_t rfind(string&, size_t) nogil #size_t rfind(char* s, size_t, size_t) nogil #size_t rfind(char*, size_t pos) nogil #size_t rfind(char c, size_t) nogil #size_t rfind(char c) nogil #size_t find_first_of(string&, size_t) nogil #size_t find_first_of(char* s, size_t, size_t) nogil #size_t find_first_of(char*, size_t pos) nogil #size_t find_first_of(char c, size_t) nogil #size_t find_first_of(char c) nogil #size_t find_first_not_of(string&, size_t) nogil #size_t find_first_not_of(char* s, size_t, size_t) nogil #size_t find_first_not_of(char*, size_t pos) nogil #size_t find_first_not_of(char c, size_t) nogil #size_t find_first_not_of(char c) nogil #size_t find_last_of(string&, size_t) nogil #size_t find_last_of(char* s, size_t, size_t) nogil #size_t find_last_of(char*, size_t pos) nogil #size_t find_last_of(char c, size_t) nogil #size_t find_last_of(char c) nogil #size_t find_last_not_of(string&, size_t) nogil #size_t find_last_not_of(char* s, size_t, size_t) nogil #size_t find_last_not_of(char*, size_t pos) nogil #string substr(size_t, size_t) nogil #string substr() nogil #string substr(size_t) nogil #size_t find_last_not_of(char c, size_t) nogil #size_t find_last_not_of(char c) nogil #string& operator= (string&) #string& operator= (char*) #string& operator= (char) #string operator+ (string& rhs) nogil #string operator+ (char* rhs) nogil #bint operator==(string&) nogil #bint operator==(char*) nogil #bint operator!= (string& rhs ) nogil #bint operator!= (char* ) nogil #bint operator< (string&) nogil #bint operator< (char*) nogil #bint operator> (string&) nogil #bint operator> (char*) nogil #bint operator<= (string&) nogil #bint operator<= (char*) nogil #bint operator>= (string&) nogil #bint operator>= (char*) nogil cefpython-49.0/src/extern/x11.pxd000066400000000000000000000010551334103266300166710ustar00rootroot00000000000000# Copyright (c) 2016 CEF Python, see the Authors file. # All rights reserved. Licensed under BSD 3-clause license. # Project website: https://github.com/cztomczak/cefpython from cef_ptr cimport CefRefPtr # noinspection PyUnresolvedReferences from cef_browser cimport CefBrowser cdef extern from "client_handler/x11.h" nogil: void InstallX11ErrorHandlers() void SetX11WindowBounds(CefRefPtr[CefBrowser] browser, int x, int y, int width, int height) void SetX11WindowTitle(CefRefPtr[CefBrowser] browser, char* title) cefpython-49.0/src/frame.pyx000066400000000000000000000164241334103266300161000ustar00rootroot00000000000000# Copyright (c) 2012 CEF Python, see the Authors file. # All rights reserved. Licensed under BSD 3-clause license. # Project website: https://github.com/cztomczak/cefpython include "cefpython.pyx" include "browser.pyx" cdef dict g_pyFrames = {} cdef object GetUniqueFrameId(int browserId, object frameId): return str(browserId) +"#"+ str(frameId) cdef PyFrame GetPyFrameById(int browserId, object frameId): cdef object uniqueFrameId = GetUniqueFrameId(browserId, frameId) if uniqueFrameId in g_pyFrames: return g_pyFrames[uniqueFrameId] return None cdef PyFrame GetPyFrame(CefRefPtr[CefFrame] cefFrame): global g_pyFrames if cefFrame == NULL or not cefFrame.get(): raise Exception("GetPyFrame(): CefFrame reference is NULL") cdef PyFrame pyFrame cdef object frameId = cefFrame.get().GetIdentifier() # int64 cdef int browserId = cefFrame.get().GetBrowser().get().GetIdentifier() assert (frameId and browserId), "frameId or browserId empty" cdef object uniqueFrameId = GetUniqueFrameId(browserId, frameId) if uniqueFrameId in g_pyFrames: return g_pyFrames[uniqueFrameId] # This code probably ain't needed. # ---- cdef list toRemove = [] for uFid, pyFrame in g_pyFrames.items(): if not pyFrame.cefFrame.get(): toRemove.append(uFid) for uFid in toRemove: Debug("GetPyFrame(): removing an empty CefFrame reference, " "uniqueFrameId = %s" % uniqueFrameId) del g_pyFrames[uFid] # ---- pyFrame = PyFrame(browserId, frameId) pyFrame.cefFrame = cefFrame if browserId in g_unreferenced_browsers: # Browser was already globally unreferenced in OnBeforeClose, # thus all frames are globally unreferenced too. Create a new # incomplete instance of PyFrame object. Read comments in # browser.pyx > GetPyBrowser and in Browser.md for what # "incomplete" means. pass else: # Keep a global reference to this frame only if the browser # wasn't destroyed in OnBeforeClose. Otherwise we would leave # dead frames references living forever. # SIDE EFFECT: two calls to GetPyFrame for the same frame object # may return two different PyFrame objects. Compare # frame objects always using GetIdentifier(). # Debug("GetPyFrame(): create new PyFrame, frameId=%s" % frameId) g_pyFrames[uniqueFrameId] = pyFrame return pyFrame cdef void RemovePyFrame(int browserId, object frameId) except *: # Called from V8ContextHandler_OnContextReleased(). global g_pyFrames cdef object uniqueFrameId = GetUniqueFrameId(browserId, frameId) if uniqueFrameId in g_pyFrames: Debug("del g_pyFrames[%s]" % uniqueFrameId) del g_pyFrames[uniqueFrameId] else: Debug("RemovePyFrame() FAILED: uniqueFrameId = %s" % uniqueFrameId) cdef void RemovePyFramesForBrowser(int browserId) except *: # Called from LifespanHandler_BeforeClose(). cdef list toRemove = [] cdef object uniqueFrameId cdef PyFrame pyFrame global g_pyFrames for uniqueFrameId, pyFrame in g_pyFrames.iteritems(): if pyFrame.GetBrowserIdentifier() == browserId: toRemove.append(uniqueFrameId) for uniqueFrameId in toRemove: Debug("del g_pyFrames[%s]" % uniqueFrameId) del g_pyFrames[uniqueFrameId] cdef class PyFrame: cdef CefRefPtr[CefFrame] cefFrame cdef int browserId cdef object frameId cdef CefRefPtr[CefFrame] GetCefFrame(self) except *: # Do not call IsValid() here, if the frame does not exist # then no big deal, no reason to crash the application. # The CEF calls will fail, but they also won't cause crash. if self.cefFrame != NULL and self.cefFrame.get(): return self.cefFrame raise Exception("PyFrame.GetCefFrame() failed: CefFrame was destroyed") def __init__(self, int browserId, int frameId): self.browserId = browserId self.frameId = frameId cpdef py_bool IsValid(self): if self.cefFrame != NULL and self.cefFrame.get() \ and self.cefFrame.get().IsValid(): return True return False def CallFunction(self, *args): # DEPRECATED - keep for backwards compatibility. self.ExecuteFunction(*args) cpdef py_void Copy(self): self.GetCefFrame().get().Copy() cpdef py_void Cut(self): self.GetCefFrame().get().Cut() cpdef py_void Delete(self): self.GetCefFrame().get().Delete() def ExecuteFunction(self, funcName, *args): # No need to enter V8 context as we're calling javascript # asynchronously using ExecuteJavascript() function. code = funcName+"(" for i in range(0, len(args)): if i != 0: code += ", " code += json.dumps(args[i]) code += ")" self.ExecuteJavascript(code) cpdef py_void ExecuteJavascript(self, py_string jsCode, py_string scriptUrl="", int startLine=1): self.GetCefFrame().get().ExecuteJavaScript(PyToCefStringValue(jsCode), PyToCefStringValue(scriptUrl), startLine) cpdef object GetIdentifier(self): # It is better to save browser and frame identifiers during # browser instantiation. When freeing PyBrowser and PyFrame # we need these identifiers. CefFrame and CefBrowser may already # be freed and calling methods on these objects may fail, this # may or may not include GetIdentifier() method, but let's be sure. return self.frameId cpdef PyFrame GetParent(self): return GetPyFrame(self.GetCefFrame().get().GetParent()) cpdef PyBrowser GetBrowser(self): return GetPyBrowser(self.GetCefFrame().get().GetBrowser()) cpdef int GetBrowserIdentifier(self) except *: return self.browserId cpdef str GetName(self): return CefToPyString(self.GetCefFrame().get().GetName()) cpdef py_void GetSource(self, object visitor): self.GetCefFrame().get().GetSource(CreateStringVisitor(visitor)) cpdef py_void GetText(self, object visitor): self.GetCefFrame().get().GetText(CreateStringVisitor(visitor)) cpdef str GetUrl(self): return CefToPyString(self.GetCefFrame().get().GetURL()) cpdef py_bool IsFocused(self): return self.GetCefFrame().get().IsFocused() cpdef py_bool IsMain(self): return self.GetCefFrame().get().IsMain() cpdef py_void LoadString(self, py_string value, py_string url): cdef CefString cefValue cdef CefString cefUrl PyToCefString(value, cefValue) PyToCefString(url, cefUrl) self.GetCefFrame().get().LoadString(cefValue, cefUrl) cpdef py_void LoadUrl(self, py_string url): url = GetNavigateUrl(url) cdef CefString cefUrl PyToCefString(url, cefUrl) self.GetCefFrame().get().LoadURL(cefUrl) cpdef py_void Paste(self): self.GetCefFrame().get().Paste() cpdef py_void Redo(self): self.GetCefFrame().get().Redo() cpdef py_void SelectAll(self): self.GetCefFrame().get().SelectAll() cpdef py_void Undo(self): self.GetCefFrame().get().Undo() cpdef py_void ViewSource(self): self.GetCefFrame().get().ViewSource() cefpython-49.0/src/handlers/000077500000000000000000000000001334103266300160355ustar00rootroot00000000000000cefpython-49.0/src/handlers/browser_process_handler.pyx000066400000000000000000000015151334103266300235170ustar00rootroot00000000000000# Copyright (c) 2012 CEF Python, see the Authors file. # All rights reserved. Licensed under BSD 3-clause license. # Project website: https://github.com/cztomczak/cefpython include "../cefpython.pyx" cdef public void BrowserProcessHandler_OnRenderProcessThreadCreated( CefRefPtr[CefListValue] extra_info ) except * with gil: try: pass except: (exc_type, exc_value, exc_trace) = sys.exc_info() sys.excepthook(exc_type, exc_value, exc_trace) cdef public void BrowserProcessHandler_OnBeforeChildProcessLaunch( CefRefPtr[CefCommandLine] cefCommandLine ) except * with gil: try: AppendSwitchesToCommandLine(cefCommandLine, g_commandLineSwitches) except: (exc_type, exc_value, exc_trace) = sys.exc_info() sys.excepthook(exc_type, exc_value, exc_trace) cefpython-49.0/src/handlers/display_handler.pyx000066400000000000000000000076041334103266300217500ustar00rootroot00000000000000# Copyright (c) 2012 CEF Python, see the Authors file. # All rights reserved. Licensed under BSD 3-clause license. # Project website: https://github.com/cztomczak/cefpython include "../cefpython.pyx" include "../browser.pyx" cdef public void DisplayHandler_OnAddressChange( CefRefPtr[CefBrowser] cefBrowser, CefRefPtr[CefFrame] cefFrame, const CefString& cefUrl ) except * with gil: cdef PyBrowser pyBrowser cdef PyFrame pyFrame cdef py_string pyUrl cdef object callback try: pyBrowser = GetPyBrowser(cefBrowser, "OnAddressChange") pyFrame = GetPyFrame(cefFrame) pyUrl = CefToPyString(cefUrl) callback = pyBrowser.GetClientCallback("OnAddressChange") if callback: callback(browser=pyBrowser, frame=pyFrame, url=pyUrl) except: (exc_type, exc_value, exc_trace) = sys.exc_info() sys.excepthook(exc_type, exc_value, exc_trace) cdef public void DisplayHandler_OnTitleChange( CefRefPtr[CefBrowser] cefBrowser, const CefString& cefTitle ) except * with gil: cdef PyBrowser pyBrowser cdef py_string pyTitle cdef object callback try: pyBrowser = GetPyBrowser(cefBrowser, "OnTitleChange") pyTitle = CefToPyString(cefTitle) callback = pyBrowser.GetClientCallback("OnTitleChange") if callback: callback(browser=pyBrowser, title=pyTitle) except: (exc_type, exc_value, exc_trace) = sys.exc_info() sys.excepthook(exc_type, exc_value, exc_trace) cdef public cpp_bool DisplayHandler_OnTooltip( CefRefPtr[CefBrowser] cefBrowser, CefString& cefText ) except * with gil: cdef PyBrowser pyBrowser cdef py_string pyText cdef list pyTextOut cdef object callback cdef py_bool returnValue try: pyBrowser = GetPyBrowser(cefBrowser, "OnTooltip") pyText = CefToPyString(cefText) pyTextOut = [pyText] callback = pyBrowser.GetClientCallback("OnTooltip") if callback: returnValue = callback(browser=pyBrowser, text_out=pyTextOut) # pyText and pyTextOut[0] are not the same strings! PyToCefString(pyTextOut[0], cefText) return bool(returnValue) return False except: (exc_type, exc_value, exc_trace) = sys.exc_info() sys.excepthook(exc_type, exc_value, exc_trace) cdef public void DisplayHandler_OnStatusMessage( CefRefPtr[CefBrowser] cefBrowser, const CefString& cefValue ) except * with gil: cdef PyBrowser pyBrowser cdef py_string pyValue cdef object callback try: pyBrowser = GetPyBrowser(cefBrowser, "OnStatusMessage") pyValue = CefToPyString(cefValue) callback = pyBrowser.GetClientCallback("OnStatusMessage") if callback: callback(browser=pyBrowser, value=pyValue) except: (exc_type, exc_value, exc_trace) = sys.exc_info() sys.excepthook(exc_type, exc_value, exc_trace) cdef public cpp_bool DisplayHandler_OnConsoleMessage( CefRefPtr[CefBrowser] cefBrowser, const CefString& cefMessage, const CefString& cefSource, int line ) except * with gil: cdef PyBrowser pyBrowser cdef py_string pyMessage cdef py_string pySource cdef py_bool returnValue cdef object callback try: pyBrowser = GetPyBrowser(cefBrowser, "OnConsoleMessage") pyMessage = CefToPyString(cefMessage) pySource = CefToPyString(cefSource) callback = pyBrowser.GetClientCallback("OnConsoleMessage") if callback: returnValue = callback(browser=pyBrowser, message=pyMessage, source=pySource, line=line) return bool(returnValue) return False except: (exc_type, exc_value, exc_trace) = sys.exc_info() sys.excepthook(exc_type, exc_value, exc_trace) cefpython-49.0/src/handlers/focus_handler.pyx000066400000000000000000000041371334103266300214200ustar00rootroot00000000000000# Copyright (c) 2016 CEF Python, see the Authors file. # All rights reserved. Licensed under BSD 3-clause license. # Project website: https://github.com/cztomczak/cefpython include "../cefpython.pyx" include "../browser.pyx" cimport cef_types from cef_types cimport TID_UI FOCUS_SOURCE_NAVIGATION = cef_types.FOCUS_SOURCE_NAVIGATION FOCUS_SOURCE_SYSTEM = cef_types.FOCUS_SOURCE_SYSTEM cdef public void FocusHandler_OnTakeFocus( CefRefPtr[CefBrowser] cef_browser, cpp_bool next_ ) except * with gil: cdef PyBrowser browser try: assert IsThread(TID_UI), "Must be called on the UI thread" browser = GetPyBrowser(cef_browser, "OnTakeFocus") callback = browser.GetClientCallback("OnTakeFocus") if callback: callback(browser=browser, next=next_) except: (exc_type, exc_value, exc_trace) = sys.exc_info() sys.excepthook(exc_type, exc_value, exc_trace) cdef public cpp_bool FocusHandler_OnSetFocus( CefRefPtr[CefBrowser] cef_browser, cef_types.cef_focus_source_t source ) except * with gil: cdef PyBrowser browser cdef py_bool ret try: assert IsThread(TID_UI), "Must be called on the UI thread" browser = GetPyBrowser(cef_browser, "OnSetFocus") callback = browser.GetClientCallback("OnSetFocus") if callback: ret = callback(browser=browser, source=source) return bool(ret) else: return False except: (exc_type, exc_value, exc_trace) = sys.exc_info() sys.excepthook(exc_type, exc_value, exc_trace) cdef public void FocusHandler_OnGotFocus( CefRefPtr[CefBrowser] cef_browser ) except * with gil: cdef PyBrowser browser try: assert IsThread(TID_UI), "Must be called on the UI thread" browser = GetPyBrowser(cef_browser, "OnGotFocus") callback = browser.GetClientCallback("OnGotFocus") if callback: callback(browser=browser) except: (exc_type, exc_value, exc_trace) = sys.exc_info() sys.excepthook(exc_type, exc_value, exc_trace) cefpython-49.0/src/handlers/javascript_dialog_handler.pyx000066400000000000000000000130761334103266300237700ustar00rootroot00000000000000# Copyright (c) 2016 CEF Python, see the Authors file. # All rights reserved. Licensed under BSD 3-clause license. # Project website: https://github.com/cztomczak/cefpython include "../cefpython.pyx" include "../browser.pyx" # enum cef_jsdialog_type_t cimport cef_types JSDIALOGTYPE_ALERT = cef_types.JSDIALOGTYPE_ALERT JSDIALOGTYPE_CONFIRM = cef_types.JSDIALOGTYPE_CONFIRM JSDIALOGTYPE_PROMPT = cef_types.JSDIALOGTYPE_PROMPT # ----------------------------------------------------------------------------- # PyJavascriptDialogCallback # ----------------------------------------------------------------------------- cdef PyJavascriptDialogCallback CreatePyJavascriptDialogCallback( CefRefPtr[CefJSDialogCallback] cefCallback): cdef PyJavascriptDialogCallback pyCallback = PyJavascriptDialogCallback() pyCallback.cefCallback = cefCallback return pyCallback cdef class PyJavascriptDialogCallback: cdef CefRefPtr[CefJSDialogCallback] cefCallback cpdef py_void Continue(self, py_bool allow, py_string user_input): self.cefCallback.get().Continue(bool(allow), PyToCefStringValue(user_input)) # ----------------------------------------------------------------------------- # JavascriptDialogHandler # ----------------------------------------------------------------------------- cdef public cpp_bool JavascriptDialogHandler_OnJavascriptDialog( CefRefPtr[CefBrowser] cefBrowser, const CefString& origin_url, const CefString& accept_lang, cef_types.cef_jsdialog_type_t dialog_type, const CefString& message_text, const CefString& default_prompt_text, CefRefPtr[CefJSDialogCallback] callback, cpp_bool& suppress_message ) except * with gil: cdef PyBrowser pyBrowser cdef py_string pyOriginUrl cdef py_string pyAcceptLang cdef py_string pyMessageText cdef py_string pyDefaultPromptText cdef PyJavascriptDialogCallback pyCallback cdef list pySuppressMessage = [] cdef object clientCallback cdef py_bool returnValue try: pyBrowser = GetPyBrowser(cefBrowser, "OnJavascriptDialog") pyOriginUrl = CefToPyString(origin_url) pyAcceptLang = CefToPyString(accept_lang) pyMessageText = CefToPyString(message_text) pyDefaultPromptText = CefToPyString(default_prompt_text) pyCallback = CreatePyJavascriptDialogCallback(callback) pySuppressMessage = [bool(suppress_message)] clientCallback = pyBrowser.GetClientCallback("OnJavascriptDialog") if clientCallback: returnValue = clientCallback( browser=pyBrowser, origin_url=pyOriginUrl, accept_lang=pyAcceptLang, dialog_type=dialog_type, message_text=pyMessageText, default_prompt_text=pyDefaultPromptText, callback=pyCallback, suppress_message_out=pySuppressMessage) (&suppress_message)[0] = bool(pySuppressMessage[0]) return bool(returnValue) return False except: (exc_type, exc_value, exc_trace) = sys.exc_info() sys.excepthook(exc_type, exc_value, exc_trace) cdef public cpp_bool JavascriptDialogHandler_OnBeforeUnloadJavascriptDialog( CefRefPtr[CefBrowser] cefBrowser, const CefString& message_text, cpp_bool is_reload, CefRefPtr[CefJSDialogCallback] callback ) except * with gil: cdef PyBrowser pyBrowser cdef py_string pyMessageText cdef py_bool pyIsReload cdef PyJavascriptDialogCallback pyCallback cdef object clientCallback cdef py_bool returnValue try: pyBrowser = GetPyBrowser(cefBrowser, "OnBeforeUnloadJavascriptDialog") pyMessageText = CefToPyString(message_text) pyIsReload = bool(is_reload) pyCallback = CreatePyJavascriptDialogCallback(callback) clientCallback = pyBrowser.GetClientCallback( "OnBeforeUnloadJavascriptDialog") if clientCallback: returnValue = clientCallback( browser=pyBrowser, message_text=pyMessageText, is_reload=pyIsReload, callback=pyCallback) return bool(returnValue) return False except: (exc_type, exc_value, exc_trace) = sys.exc_info() sys.excepthook(exc_type, exc_value, exc_trace) cdef public void JavascriptDialogHandler_OnResetJavascriptDialogState( CefRefPtr[CefBrowser] cefBrowser ) except * with gil: cdef PyBrowser pyBrowser try: pyBrowser = GetPyBrowser(cefBrowser, "OnResetJavascriptDialogState") callback = pyBrowser.GetClientCallback( "OnResetJavascriptDialogState") if callback: callback(browser=pyBrowser) except: (exc_type, exc_value, exc_trace) = sys.exc_info() sys.excepthook(exc_type, exc_value, exc_trace) cdef public void JavascriptDialogHandler_OnJavascriptDialogClosed( CefRefPtr[CefBrowser] cefBrowser, ) except * with gil: cdef PyBrowser pyBrowser try: pyBrowser = GetPyBrowser(cefBrowser, "OnJavascriptDialogClosed") callback = pyBrowser.GetClientCallback("OnJavascriptDialogClosed") if callback: callback(browser=pyBrowser) except: (exc_type, exc_value, exc_trace) = sys.exc_info() sys.excepthook(exc_type, exc_value, exc_trace) cefpython-49.0/src/handlers/keyboard_handler.pyx000066400000000000000000000105761334103266300221050ustar00rootroot00000000000000# Copyright (c) 2012 CEF Python, see the Authors file. # All rights reserved. Licensed under BSD 3-clause license. # Project website: https://github.com/cztomczak/cefpython include "../cefpython.pyx" # noinspection PyUnresolvedReferences cimport cef_types # cef_key_event_type_t KEYEVENT_RAWKEYDOWN = cef_types.KEYEVENT_RAWKEYDOWN KEYEVENT_KEYDOWN = cef_types.KEYEVENT_KEYDOWN KEYEVENT_KEYUP = cef_types.KEYEVENT_KEYUP KEYEVENT_CHAR = cef_types.KEYEVENT_CHAR # cef_event_flags_t EVENTFLAG_NONE = cef_types.EVENTFLAG_NONE EVENTFLAG_CAPS_LOCK_ON = cef_types.EVENTFLAG_CAPS_LOCK_ON EVENTFLAG_SHIFT_DOWN = cef_types.EVENTFLAG_SHIFT_DOWN EVENTFLAG_CONTROL_DOWN = cef_types.EVENTFLAG_CONTROL_DOWN EVENTFLAG_ALT_DOWN = cef_types.EVENTFLAG_ALT_DOWN EVENTFLAG_LEFT_MOUSE_BUTTON = cef_types.EVENTFLAG_LEFT_MOUSE_BUTTON EVENTFLAG_MIDDLE_MOUSE_BUTTON = cef_types.EVENTFLAG_MIDDLE_MOUSE_BUTTON EVENTFLAG_RIGHT_MOUSE_BUTTON = cef_types.EVENTFLAG_RIGHT_MOUSE_BUTTON # Mac OS-X command key. EVENTFLAG_COMMAND_DOWN = cef_types.EVENTFLAG_COMMAND_DOWN EVENTFLAG_NUM_LOCK_ON = cef_types.EVENTFLAG_NUM_LOCK_ON EVENTFLAG_IS_KEY_PAD = cef_types.EVENTFLAG_IS_KEY_PAD EVENTFLAG_IS_LEFT = cef_types.EVENTFLAG_IS_LEFT EVENTFLAG_IS_RIGHT = cef_types.EVENTFLAG_IS_RIGHT cdef dict CefToPyKeyEvent(const cef_types.CefKeyEvent& cefKeyEvent): pyKeyEvent = { "type": cefKeyEvent.type, "modifiers": cefKeyEvent.modifiers, "windows_key_code": cefKeyEvent.windows_key_code, "native_key_code": cefKeyEvent.native_key_code, "is_system_key": bool(cefKeyEvent.is_system_key), "character": cefKeyEvent.character, "unmodified_character": cefKeyEvent.unmodified_character, "focus_on_editable_field": bool(cefKeyEvent.focus_on_editable_field) } return pyKeyEvent cdef public cpp_bool KeyboardHandler_OnPreKeyEvent( CefRefPtr[CefBrowser] cefBrowser, const cef_types.CefKeyEvent& cefEvent, cef_types.CefEventHandle cefEventHandle, cpp_bool* cefIsKeyboardShortcut ) except * with gil: cdef PyBrowser pyBrowser cdef dict pyEvent cdef list pyIsKeyboardShortcutOut cdef py_bool returnValue cdef object callback try: pyBrowser = GetPyBrowser(cefBrowser, "OnPreKeyEvent") pyEvent = CefToPyKeyEvent(cefEvent) pyIsKeyboardShortcutOut = [cefIsKeyboardShortcut[0]] callback = pyBrowser.GetClientCallback("OnPreKeyEvent") if callback: returnValue = callback( browser=pyBrowser, event=pyEvent, event_handle=PyLong_FromVoidPtr(cefEventHandle), is_keyboard_shortcut_out=pyIsKeyboardShortcutOut) cefIsKeyboardShortcut[0] = \ bool(pyIsKeyboardShortcutOut[0]) return bool(returnValue) return False except: (exc_type, exc_value, exc_trace) = sys.exc_info() sys.excepthook(exc_type, exc_value, exc_trace) cdef public cpp_bool KeyboardHandler_OnKeyEvent( CefRefPtr[CefBrowser] cefBrowser, const cef_types.CefKeyEvent& cefEvent, cef_types.CefEventHandle cefEventHandle ) except * with gil: cdef PyBrowser pyBrowser cdef dict pyEvent cdef py_bool returnValue cdef object callback try: pyBrowser = GetPyBrowser(cefBrowser, "OnKeyEvent") pyEvent = CefToPyKeyEvent(cefEvent) callback = pyBrowser.GetClientCallback("OnKeyEvent") if callback: returnValue = callback( browser=pyBrowser, event=pyEvent, event_handle=PyLong_FromVoidPtr(cefEventHandle)) # If returnValue is False then handle copy/paste on Mac if returnValue: return bool(returnValue) if platform.system() == "Darwin": # Handle copy: command + c if pyEvent["modifiers"] == 128 \ and pyEvent["native_key_code"] == 8: pyBrowser.GetFocusedFrame().Copy() return True # Handle paste: command + v elif pyEvent["modifiers"] == 128 \ and pyEvent["native_key_code"] == 9: pyBrowser.GetFocusedFrame().Paste() return True return False except: (exc_type, exc_value, exc_trace) = sys.exc_info() sys.excepthook(exc_type, exc_value, exc_trace) cefpython-49.0/src/handlers/lifespan_handler.pyx000066400000000000000000000137211334103266300221010ustar00rootroot00000000000000# Copyright (c) 2012 CEF Python, see the Authors file. # All rights reserved. Licensed under BSD 3-clause license. # Project website: https://github.com/cztomczak/cefpython include "../cefpython.pyx" include "../browser.pyx" # noinspection PyUnresolvedReferences from cef_types cimport WindowOpenDisposition # noinspection PyUnresolvedReferences cimport cef_types # WindowOpenDisposition WOD_UNKNOWN = cef_types.WOD_UNKNOWN WOD_CURRENT_TAB = cef_types.WOD_CURRENT_TAB WOD_SINGLETON_TAB = cef_types.WOD_SINGLETON_TAB WOD_NEW_FOREGROUND_TAB = cef_types.WOD_NEW_FOREGROUND_TAB WOD_NEW_BACKGROUND_TAB = cef_types.WOD_NEW_BACKGROUND_TAB WOD_NEW_POPUP = cef_types.WOD_NEW_POPUP WOD_NEW_WINDOW = cef_types.WOD_NEW_WINDOW WOD_SAVE_TO_DISK = cef_types.WOD_SAVE_TO_DISK WOD_OFF_THE_RECORD = cef_types.WOD_OFF_THE_RECORD WOD_IGNORE_ACTION = cef_types.WOD_IGNORE_ACTION cdef public cpp_bool LifespanHandler_OnBeforePopup( CefRefPtr[CefBrowser] cefBrowser, CefRefPtr[CefFrame] cefFrame, const CefString& targetUrl, const CefString& targetFrameName, cef_types.cef_window_open_disposition_t targetDisposition, cpp_bool userGesture, const int popupFeaturesNotImpl, CefWindowInfo& windowInfo, CefRefPtr[CefClient]& client, CefBrowserSettings& settings, cpp_bool* noJavascriptAccess ) except * with gil: # Empty place-holders: popupFeatures, client. cdef PyBrowser pyBrowser cdef PyFrame pyFrame, cdef py_string pyTargetUrl cdef py_string pyTargetFrameName cdef list pyNoJavascriptAccess # out bool pyNoJavascriptAccess[0] cdef list pyWindowInfo cdef list pyBrowserSettings cdef object callback cdef py_bool returnValue try: pyBrowser = GetPyBrowser(cefBrowser, "OnBeforePopup") pyFrame = GetPyFrame(cefFrame) pyTargetUrl = CefToPyString(targetUrl) pyTargetFrameName = CefToPyString(targetFrameName) pyNoJavascriptAccess = [noJavascriptAccess[0]] pyWindowInfo = [] pyBrowserSettings = [] callback = pyBrowser.GetClientCallback("OnBeforePopup") if callback: returnValue = bool(callback( browser=pyBrowser, frame=pyFrame, target_url=pyTargetUrl, target_frame_name=pyTargetFrameName, target_disposition=targetDisposition, user_gesture=userGesture, popup_features=None, window_info_out=pyWindowInfo, client=None, browser_settings_out=pyBrowserSettings, no_javascript_access_out=pyNoJavascriptAccess)) noJavascriptAccess[0] = bool(pyNoJavascriptAccess[0]) if len(pyBrowserSettings): SetBrowserSettings(pyBrowserSettings[0], &settings) if len(pyWindowInfo): SetCefWindowInfo(windowInfo, pyWindowInfo[0]) return bool(returnValue) return False except: (exc_type, exc_value, exc_trace) = sys.exc_info() sys.excepthook(exc_type, exc_value, exc_trace) cdef public void LifespanHandler_OnAfterCreated( CefRefPtr[CefBrowser] cefBrowser ) except * with gil: cdef PyBrowser pyBrowser try: pyBrowser = GetPyBrowser(cefBrowser, "OnAfterCreated") callback = GetGlobalClientCallback("OnAfterCreated") if callback: callback(browser=pyBrowser) except: (exc_type, exc_value, exc_trace) = sys.exc_info() sys.excepthook(exc_type, exc_value, exc_trace) cdef public cpp_bool LifespanHandler_DoClose( CefRefPtr[CefBrowser] cefBrowser ) except * with gil: cdef PyBrowser pyBrowser try: pyBrowser = GetPyBrowser(cefBrowser, "DoClose") callback = pyBrowser.GetClientCallback("DoClose") if callback: return bool(callback(browser=pyBrowser)) return False except: (exc_type, exc_value, exc_trace) = sys.exc_info() sys.excepthook(exc_type, exc_value, exc_trace) cdef public void LifespanHandler_OnBeforeClose( CefRefPtr[CefBrowser] cefBrowser ) except * with gil: cdef PyBrowser pyBrowser cdef object callback try: Debug("LifespanHandler_OnBeforeClose") # NOTE: browser_id may not necessarily be in g_pyBrowsers currently. # I haven't yet debugged it but the logic in Shutdown that # tries to force close browsers and removes references might # have something to do with it. Such scenario is reproducible # with the following steps: # 1. Run wxpython.py example # 2. Google "js alert" and open w3schools # 3. Open demo popup # 4. Close main window (not popup) pyBrowser = GetPyBrowser(cefBrowser, "OnBeforeClose") callback = pyBrowser.GetClientCallback("OnBeforeClose") if callback: callback(browser=pyBrowser) RemovePythonCallbacksForBrowser(pyBrowser.GetIdentifier()) RemovePyFramesForBrowser(pyBrowser.GetIdentifier()) RemovePyBrowser(pyBrowser.GetIdentifier()) if g_MessageLoop_called and not len(g_pyBrowsers): # Automatically quit message loop when last browser was closed. # This is required for hello_world.py example to work. QuitMessageLoop() except: (exc_type, exc_value, exc_trace) = sys.exc_info() sys.excepthook(exc_type, exc_value, exc_trace) cdef public cpp_bool LifespanHandler_RunModal( CefRefPtr[CefBrowser] cefBrowser ) except * with gil: cdef PyBrowser pyBrowser try: pyBrowser = GetPyBrowser(cefBrowser) callback = pyBrowser.GetClientCallback("RunModal") if callback: return bool(callback(pyBrowser)) return False except: (exc_type, exc_value, exc_trace) = sys.exc_info() sys.excepthook(exc_type, exc_value, exc_trace) cefpython-49.0/src/handlers/load_handler.pyx000066400000000000000000000072321334103266300212170ustar00rootroot00000000000000# Copyright (c) 2012 CEF Python, see the Authors file. # All rights reserved. Licensed under BSD 3-clause license. # Project website: https://github.com/cztomczak/cefpython include "../cefpython.pyx" include "../browser.pyx" cdef public void LoadHandler_OnLoadingStateChange( CefRefPtr[CefBrowser] cefBrowser, cpp_bool isLoading, cpp_bool canGoBack, cpp_bool canGoForward ) except * with gil: cdef PyBrowser pyBrowser cdef object callback try: pyBrowser = GetPyBrowser(cefBrowser, "OnLoadingStateChange") callback = pyBrowser.GetClientCallback("OnLoadingStateChange") if callback: callback(browser=pyBrowser, is_loading=isLoading, can_go_back=canGoBack, can_go_forward=canGoForward) except: (exc_type, exc_value, exc_trace) = sys.exc_info() sys.excepthook(exc_type, exc_value, exc_trace) cdef public void LoadHandler_OnLoadStart( CefRefPtr[CefBrowser] cefBrowser, CefRefPtr[CefFrame] cefFrame ) except * with gil: cdef PyBrowser pyBrowser cdef PyFrame pyFrame cdef object clientCallback try: pyBrowser = GetPyBrowser(cefBrowser, "OnLoadStart") pyFrame = GetPyFrame(cefFrame) clientCallback = pyBrowser.GetClientCallback("OnLoadStart") if clientCallback: clientCallback(browser=pyBrowser, frame=pyFrame) except: (exc_type, exc_value, exc_trace) = sys.exc_info() sys.excepthook(exc_type, exc_value, exc_trace) cdef public void LoadHandler_OnLoadEnd( CefRefPtr[CefBrowser] cefBrowser, CefRefPtr[CefFrame] cefFrame, int httpStatusCode ) except * with gil: cdef PyBrowser pyBrowser cdef PyFrame pyFrame cdef object clientCallback try: pyBrowser = GetPyBrowser(cefBrowser, "OnLoadEnd") pyFrame = GetPyFrame(cefFrame) clientCallback = pyBrowser.GetClientCallback("OnLoadEnd") if clientCallback: clientCallback(browser=pyBrowser, frame=pyFrame, http_code=httpStatusCode) except: (exc_type, exc_value, exc_trace) = sys.exc_info() sys.excepthook(exc_type, exc_value, exc_trace) cdef public void LoadHandler_OnLoadError( CefRefPtr[CefBrowser] cefBrowser, CefRefPtr[CefFrame] cefFrame, cef_types.cef_errorcode_t cefErrorCode, const CefString& cefErrorText, const CefString& cefFailedUrl ) except * with gil: cdef PyBrowser pyBrowser cdef PyFrame pyFrame cdef list errorTextOut cdef object clientCallback try: # If webpage loading or file download is aborted by user # the error code will be ERR_ABORTED. In such cases calls # to OnLoadError should be ignored and not handled by user # scripts. The wxpython example implements such behavior. pyBrowser = GetPyBrowser(cefBrowser, "OnLoadError") pyFrame = GetPyFrame(cefFrame) errorTextOut = [CefToPyString(cefErrorText)] clientCallback = pyBrowser.GetClientCallback("OnLoadError") if clientCallback: clientCallback( browser=pyBrowser, frame=pyFrame, error_code=cefErrorCode, error_text_out=errorTextOut, failed_url=CefToPyString(cefFailedUrl)) # Providing custom error messsage not yet supported in CEF 3. # | PyToCefString(errorTextOut[0], cefErrorText) except: (exc_type, exc_value, exc_trace) = sys.exc_info() sys.excepthook(exc_type, exc_value, exc_trace) cefpython-49.0/src/handlers/render_handler.pyx000066400000000000000000000242251334103266300215600ustar00rootroot00000000000000# Copyright (c) 2013 CEF Python, see the Authors file. # All rights reserved. Licensed under BSD 3-clause license. # Project website: https://github.com/cztomczak/cefpython include "../cefpython.pyx" include "../browser.pyx" cimport cef_types # cef_paint_element_type_t, PaintElementType PET_VIEW = cef_types.PET_VIEW PET_POPUP = cef_types.PET_POPUP # cef_drag_operations_mask_t, DragOperation, DragOperationsMask DRAG_OPERATION_NONE = cef_types.DRAG_OPERATION_NONE DRAG_OPERATION_COPY = cef_types.DRAG_OPERATION_COPY DRAG_OPERATION_LINK = cef_types.DRAG_OPERATION_LINK DRAG_OPERATION_GENERIC = cef_types.DRAG_OPERATION_GENERIC DRAG_OPERATION_PRIVATE = cef_types.DRAG_OPERATION_PRIVATE DRAG_OPERATION_MOVE = cef_types.DRAG_OPERATION_MOVE DRAG_OPERATION_DELETE = cef_types.DRAG_OPERATION_DELETE DRAG_OPERATION_EVERY = cef_types.DRAG_OPERATION_EVERY cdef public cpp_bool RenderHandler_GetRootScreenRect( CefRefPtr[CefBrowser] cefBrowser, CefRect& cefRect ) except * with gil: cdef PyBrowser pyBrowser cdef list pyRect = [] cdef py_bool ret try: pyBrowser = GetPyBrowser(cefBrowser, "GetRootScreenRect") callback = pyBrowser.GetClientCallback("GetRootScreenRect") if callback: ret = callback(browser=pyBrowser, rect_out=pyRect) if ret: assert (pyRect and len(pyRect) == 4), "rectangle not provided" cefRect.x = pyRect[0] cefRect.y = pyRect[1] cefRect.width = pyRect[2] cefRect.height = pyRect[3] return True else: return False else: return False except: (exc_type, exc_value, exc_trace) = sys.exc_info() sys.excepthook(exc_type, exc_value, exc_trace) cdef public cpp_bool RenderHandler_GetViewRect( CefRefPtr[CefBrowser] cefBrowser, CefRect& cefRect ) except * with gil: cdef PyBrowser pyBrowser cdef list pyRect = [] cdef py_bool ret try: pyBrowser = GetPyBrowser(cefBrowser, "GetViewRect") callback = pyBrowser.GetClientCallback("GetViewRect") if callback: ret = callback(browser=pyBrowser, rect_out=pyRect) if ret: assert (pyRect and len(pyRect) == 4), "rectangle not provided" cefRect.x = pyRect[0] cefRect.y = pyRect[1] cefRect.width = pyRect[2] cefRect.height = pyRect[3] return True else: return False else: return False except: (exc_type, exc_value, exc_trace) = sys.exc_info() sys.excepthook(exc_type, exc_value, exc_trace) cdef public cpp_bool RenderHandler_GetScreenRect( CefRefPtr[CefBrowser] cefBrowser, CefRect& cefRect ) except * with gil: cdef PyBrowser pyBrowser cdef list pyRect = [] cdef py_bool ret try: pyBrowser = GetPyBrowser(cefBrowser, "GetScreenRect") callback = pyBrowser.GetClientCallback("GetScreenRect") if callback: ret = callback(browser=pyBrowser, rect_out=pyRect) if ret: assert (pyRect and len(pyRect) == 4), ( "rectangle not provided or invalid") cefRect.x = pyRect[0] cefRect.y = pyRect[1] cefRect.width = pyRect[2] cefRect.height = pyRect[3] return True else: return False else: return False except: (exc_type, exc_value, exc_trace) = sys.exc_info() sys.excepthook(exc_type, exc_value, exc_trace) cdef public cpp_bool RenderHandler_GetScreenPoint( CefRefPtr[CefBrowser] cefBrowser, int viewX, int viewY, int& screenX, int& screenY ) except * with gil: cdef PyBrowser pyBrowser cdef list screenCoordinates = [] cdef py_bool ret try: pyBrowser = GetPyBrowser(cefBrowser, "GetScreenPoint") callback = pyBrowser.GetClientCallback("GetScreenPoint") if callback: ret = callback(browser=pyBrowser, view_x=viewX, view_y=viewY, screen_coordinates_out=screenCoordinates) if ret: assert (screenCoordinates and len(screenCoordinates) == 2), ( "screenCoordinates not provided or invalid") (&screenX)[0] = int(screenCoordinates[0]) (&screenY)[0] = int(screenCoordinates[1]) return True else: return False else: return False except: (exc_type, exc_value, exc_trace) = sys.exc_info() sys.excepthook(exc_type, exc_value, exc_trace) cdef public cpp_bool RenderHandler_GetScreenInfo( CefRefPtr[CefBrowser] cefBrowser, CefScreenInfo& cefScreenInfo ) except * with gil: # Not yet implemented. return False cdef public void RenderHandler_OnPopupShow( CefRefPtr[CefBrowser] cefBrowser, cpp_bool show ) except * with gil: cdef PyBrowser pyBrowser try: pyBrowser = GetPyBrowser(cefBrowser, "OnPopupShow") callback = pyBrowser.GetClientCallback("OnPopupShow") if callback: callback(browser=pyBrowser, show=show) except: (exc_type, exc_value, exc_trace) = sys.exc_info() sys.excepthook(exc_type, exc_value, exc_trace) cdef public void RenderHandler_OnPopupSize( CefRefPtr[CefBrowser] cefBrowser, const CefRect& cefRect ) except * with gil: cdef PyBrowser pyBrowser cdef list pyRect try: pyBrowser = GetPyBrowser(cefBrowser, "OnPopupSize") callback = pyBrowser.GetClientCallback("OnPopupSize") if callback: pyRect = [cefRect.x, cefRect.y, cefRect.width, cefRect.height] callback(browser=pyBrowser, rect_out=pyRect) except: (exc_type, exc_value, exc_trace) = sys.exc_info() sys.excepthook(exc_type, exc_value, exc_trace) cdef public void RenderHandler_OnPaint( CefRefPtr[CefBrowser] cefBrowser, cef_types.cef_paint_element_type_t paintElementType, cpp_vector[CefRect]& cefDirtyRects, const void* cefBuffer, int width, int height ) except * with gil: cdef PyBrowser pyBrowser cdef list pyDirtyRects = [] cdef list pyRect # TODO: cefDirtyRects should be const, but const_iterator is # not yet implemented in libcpp.vector. cdef cpp_vector[CefRect].iterator iterator cdef CefRect cefRect cdef PaintBuffer paintBuffer try: pyBrowser = GetPyBrowser(cefBrowser, "OnPaint") iterator = cefDirtyRects.begin() while iterator != cefDirtyRects.end(): cefRect = deref(iterator) pyRect = [cefRect.x, cefRect.y, cefRect.width, cefRect.height] pyDirtyRects.append(pyRect) preinc(iterator) # In CEF 1 width and height were fetched using GetSize(), # but in CEF 3 they are passed as arguments to OnPaint(). # OFF: | (width, height) = pyBrowser.GetSize(paintElementType) paintBuffer = CreatePaintBuffer(cefBuffer, width, height) callback = pyBrowser.GetClientCallback("OnPaint") if callback: callback( browser=pyBrowser, element_type=paintElementType, dirty_rects=pyDirtyRects, paint_buffer=paintBuffer, width=width, height=height) else: return except: (exc_type, exc_value, exc_trace) = sys.exc_info() sys.excepthook(exc_type, exc_value, exc_trace) cdef public void RenderHandler_OnCursorChange( CefRefPtr[CefBrowser] cefBrowser, CefCursorHandle cursor ) except * with gil: cdef PyBrowser pyBrowser try: pyBrowser = GetPyBrowser(cefBrowser, "OnCursorChange") callback = pyBrowser.GetClientCallback("OnCursorChange") if callback: callback(browser=pyBrowser, cursor=cursor) except: (exc_type, exc_value, exc_trace) = sys.exc_info() sys.excepthook(exc_type, exc_value, exc_trace) cdef public void RenderHandler_OnScrollOffsetChanged( CefRefPtr[CefBrowser] cefBrowser ) except * with gil: cdef PyBrowser pyBrowser try: pyBrowser = GetPyBrowser(cefBrowser, "OnScrollOffsetChanged") callback = pyBrowser.GetClientCallback("OnScrollOffsetChanged") if callback: callback(browser=pyBrowser) except: (exc_type, exc_value, exc_trace) = sys.exc_info() sys.excepthook(exc_type, exc_value, exc_trace) cdef public cpp_bool RenderHandler_StartDragging( CefRefPtr[CefBrowser] cef_browser, CefRefPtr[CefDragData] cef_drag_data, uint32 allowed_ops, int x, int y ) except * with gil: cdef PyBrowser browser cdef DragData drag_data cdef py_bool ret try: browser = GetPyBrowser(cef_browser, "StartDragging") drag_data = DragData_Init(cef_drag_data) callback = browser.GetClientCallback("StartDragging") if callback: ret = callback( browser=browser, drag_data=drag_data, allowed_ops=allowed_ops, x=x, y=y) if ret: return True else: return False else: return False except: (exc_type, exc_value, exc_trace) = sys.exc_info() sys.excepthook(exc_type, exc_value, exc_trace) cdef public void RenderHandler_UpdateDragCursor( CefRefPtr[CefBrowser] cef_browser, uint32 operation, ) except * with gil: cdef PyBrowser browser try: browser = GetPyBrowser(cef_browser, "UpdateDragCursor") callback = browser.GetClientCallback("UpdateDragCursor") if callback: callback(browser=browser, operation=operation) except: (exc_type, exc_value, exc_trace) = sys.exc_info() sys.excepthook(exc_type, exc_value, exc_trace) cefpython-49.0/src/handlers/request_handler.pyx000066400000000000000000000413601334103266300217700ustar00rootroot00000000000000# Copyright (c) 2013 CEF Python, see the Authors file. # All rights reserved. Licensed under BSD 3-clause license. # Project website: https://github.com/cztomczak/cefpython include "../cefpython.pyx" include "../browser.pyx" # cef_termination_status_t cimport cef_types TS_ABNORMAL_TERMINATION = cef_types.TS_ABNORMAL_TERMINATION TS_PROCESS_WAS_KILLED = cef_types.TS_PROCESS_WAS_KILLED TS_PROCESS_CRASHED = cef_types.TS_PROCESS_CRASHED # ----------------------------------------------------------------------------- # PyAuthCallback # ----------------------------------------------------------------------------- cdef PyAuthCallback CreatePyAuthCallback( CefRefPtr[CefAuthCallback] cefCallback): cdef PyAuthCallback pyCallback = PyAuthCallback() pyCallback.cefCallback = cefCallback return pyCallback cdef class PyAuthCallback: cdef CefRefPtr[CefAuthCallback] cefCallback cpdef py_void Continue(self, py_string username, py_string password): self.cefCallback.get().Continue( PyToCefStringValue(username), PyToCefStringValue(password)) cpdef py_void Cancel(self): self.cefCallback.get().Cancel() # ----------------------------------------------------------------------------- # PyRequestCallback # ----------------------------------------------------------------------------- cdef PyRequestCallback CreatePyRequestCallback( CefRefPtr[CefRequestCallback] cefCallback): cdef PyRequestCallback pyCallback = PyRequestCallback() pyCallback.cefCallback = cefCallback return pyCallback cdef class PyRequestCallback: cdef CefRefPtr[CefRequestCallback] cefCallback cpdef py_void Continue(self, py_bool allow): self.cefCallback.get().Continue(bool(allow)) cpdef py_void Cancel(self): self.cefCallback.get().Cancel() # ----------------------------------------------------------------------------- # RequestHandler # ----------------------------------------------------------------------------- cdef public cpp_bool RequestHandler_OnBeforeBrowse( CefRefPtr[CefBrowser] cefBrowser, CefRefPtr[CefFrame] cefFrame, CefRefPtr[CefRequest] cefRequest, cpp_bool cefIsRedirect ) except * with gil: cdef PyBrowser pyBrowser cdef PyFrame pyFrame cdef PyRequest pyRequest cdef py_bool pyIsRedirect cdef object clientCallback cdef py_bool returnValue try: pyBrowser = GetPyBrowser(cefBrowser, "OnBeforeBrowse") pyFrame = GetPyFrame(cefFrame) pyRequest = CreatePyRequest(cefRequest) pyIsRedirect = bool(cefIsRedirect) clientCallback = pyBrowser.GetClientCallback("OnBeforeBrowse") if clientCallback: returnValue = clientCallback( browser=pyBrowser, frame=pyFrame, request=pyRequest, is_redirect=pyIsRedirect) return bool(returnValue) else: return False except: (exc_type, exc_value, exc_trace) = sys.exc_info() sys.excepthook(exc_type, exc_value, exc_trace) cdef public cpp_bool RequestHandler_OnBeforeResourceLoad( CefRefPtr[CefBrowser] cefBrowser, CefRefPtr[CefFrame] cefFrame, CefRefPtr[CefRequest] cefRequest ) except * with gil: cdef PyBrowser pyBrowser cdef PyFrame pyFrame cdef PyRequest pyRequest cdef object clientCallback cdef py_bool returnValue try: pyBrowser = GetPyBrowser(cefBrowser, "OnBeforeResourceLoad") pyFrame = GetPyFrame(cefFrame) pyRequest = CreatePyRequest(cefRequest) clientCallback = pyBrowser.GetClientCallback("OnBeforeResourceLoad") if clientCallback: returnValue = clientCallback( browser=pyBrowser, frame=pyFrame, request=pyRequest) return bool(returnValue) else: return False except: (exc_type, exc_value, exc_trace) = sys.exc_info() sys.excepthook(exc_type, exc_value, exc_trace) cdef public CefRefPtr[CefResourceHandler] RequestHandler_GetResourceHandler( CefRefPtr[CefBrowser] cefBrowser, CefRefPtr[CefFrame] cefFrame, CefRefPtr[CefRequest] cefRequest ) except * with gil: cdef PyBrowser pyBrowser cdef PyFrame pyFrame cdef PyRequest pyRequest cdef object clientCallback cdef object returnValue try: pyBrowser = GetPyBrowser(cefBrowser, "GetResourceHandler") pyFrame = GetPyFrame(cefFrame) pyRequest = CreatePyRequest(cefRequest) clientCallback = pyBrowser.GetClientCallback("GetResourceHandler") if clientCallback: returnValue = clientCallback( browser=pyBrowser, frame=pyFrame, request=pyRequest) if returnValue: return CreateResourceHandler(returnValue) else: return NULL else: return NULL except: (exc_type, exc_value, exc_trace) = sys.exc_info() sys.excepthook(exc_type, exc_value, exc_trace) cdef public void RequestHandler_OnResourceRedirect( CefRefPtr[CefBrowser] cefBrowser, CefRefPtr[CefFrame] cefFrame, const CefString& cefOldUrl, CefString& cefNewUrl, CefRefPtr[CefRequest] cefRequest ) except * with gil: cdef PyBrowser pyBrowser cdef PyFrame pyFrame cdef str pyOldUrl cdef list pyNewUrlOut cdef PyRequest pyRequest cdef object clientCallback try: pyBrowser = GetPyBrowser(cefBrowser, "OnResourceRedirect") pyFrame = GetPyFrame(cefFrame) pyOldUrl = CefToPyString(cefOldUrl) pyNewUrlOut = [CefToPyString(cefNewUrl)] pyRequest = CreatePyRequest(cefRequest) clientCallback = pyBrowser.GetClientCallback("OnResourceRedirect") if clientCallback: clientCallback( browser=pyBrowser, frame=pyFrame, old_url=pyOldUrl, new_url_out=pyNewUrlOut, request=pyRequest) if pyNewUrlOut[0]: PyToCefString(pyNewUrlOut[0], cefNewUrl) except: (exc_type, exc_value, exc_trace) = sys.exc_info() sys.excepthook(exc_type, exc_value, exc_trace) cdef public cpp_bool RequestHandler_GetAuthCredentials( CefRefPtr[CefBrowser] cefBrowser, CefRefPtr[CefFrame] cefFrame, cpp_bool cefIsProxy, const CefString& cefHost, int cefPort, const CefString& cefRealm, const CefString& cefScheme, CefRefPtr[CefAuthCallback] cefAuthCallback ) except * with gil: cdef PyBrowser pyBrowser cdef PyFrame pyFrame cdef py_bool pyIsProxy cdef str pyHost cdef int pyPort cdef str pyRealm cdef str pyScheme cdef PyAuthCallback pyAuthCallback cdef py_bool returnValue cdef list pyUsernameOut cdef list pyPasswordOut cdef object clientCallback try: pyBrowser = GetPyBrowser(cefBrowser, "GetAuthCredentials") pyFrame = GetPyFrame(cefFrame) pyIsProxy = bool(cefIsProxy) pyHost = CefToPyString(cefHost) pyPort = int(cefPort) pyRealm = CefToPyString(cefRealm) pyScheme = CefToPyString(cefScheme) pyAuthCallback = CreatePyAuthCallback(cefAuthCallback) pyUsernameOut = [""] pyPasswordOut = [""] clientCallback = pyBrowser.GetClientCallback("GetAuthCredentials") if clientCallback: returnValue = clientCallback( browser=pyBrowser, frame=pyFrame, is_proxy=pyIsProxy, host=pyHost, port=pyPort, realm=pyRealm, scheme=pyScheme, callback=pyAuthCallback) return bool(returnValue) else: # TODO: port it from CEF 1, copy the cef1/http_authentication/. # -- # Default implementation for Windows. # IF UNAME_SYSNAME == "Windows": # returnValue = HttpAuthenticationDialog( # pyBrowser, # pyIsProxy, pyHost, pyPort, pyRealm, pyScheme, # pyUsernameOut, pyPasswordOut) # if returnValue: # pyAuthCallback.Continue(pyUsernameOut[0], pyPasswordOut[0]) # return True # return False # ELSE: # return False return False except: (exc_type, exc_value, exc_trace) = sys.exc_info() sys.excepthook(exc_type, exc_value, exc_trace) cdef public cpp_bool RequestHandler_OnQuotaRequest( CefRefPtr[CefBrowser] cefBrowser, const CefString& cefOriginUrl, int64 newSize, CefRefPtr[CefRequestCallback] cefRequestCallback ) except * with gil: cdef PyBrowser pyBrowser cdef py_string pyOriginUrl cdef py_bool returnValue cdef object clientCallback try: pyBrowser = GetPyBrowser(cefBrowser, "OnQuotaRequest") pyOriginUrl = CefToPyString(cefOriginUrl) clientCallback = pyBrowser.GetClientCallback("OnQuotaRequest") if clientCallback: returnValue = clientCallback( browser=pyBrowser, origin_url=pyOriginUrl, new_size=newSize, callback=CreatePyRequestCallback(cefRequestCallback)) return bool(returnValue) else: return False except: (exc_type, exc_value, exc_trace) = sys.exc_info() sys.excepthook(exc_type, exc_value, exc_trace) cdef public CefRefPtr[CefCookieManager] RequestHandler_GetCookieManager( CefRefPtr[CefBrowser] cefBrowser, const CefString& cefMainUrl ) except * with gil: # In CEF the GetCookieManager callback belongs to # CefRequestContextHandler. # In an exceptional case the browser parameter may be None # due to limitation in CEF API. No workaround as of now. cdef PyBrowser pyBrowser cdef str pyMainUrl cdef object clientCallback cdef PyCookieManager returnValue try: pyBrowser = GetPyBrowser(cefBrowser, "GetCookieManager") pyMainUrl = CefToPyString(cefMainUrl) if pyBrowser: # Browser may be empty. clientCallback = pyBrowser.GetClientCallback("GetCookieManager") if clientCallback: returnValue = clientCallback( browser=pyBrowser, main_url=pyMainUrl) if returnValue: if isinstance(returnValue, PyCookieManager): return returnValue.cefCookieManager else: raise Exception("Expected a CookieManager object") return NULL else: return NULL except: (exc_type, exc_value, exc_trace) = sys.exc_info() sys.excepthook(exc_type, exc_value, exc_trace) cdef public void RequestHandler_OnProtocolExecution( CefRefPtr[CefBrowser] cefBrowser, const CefString& cefUrl, cpp_bool& cefAllowOSExecution ) except * with gil: cdef PyBrowser pyBrowser cdef str pyUrl cdef list pyAllowOSExecutionOut cdef object clientCallback try: pyBrowser = GetPyBrowser(cefBrowser, "OnProtocolExecution") pyUrl = CefToPyString(cefUrl) pyAllowOSExecutionOut = [bool(cefAllowOSExecution)] clientCallback = pyBrowser.GetClientCallback("OnProtocolExecution") if clientCallback: clientCallback( browser=pyBrowser, url=pyUrl, allow_execution_out=pyAllowOSExecutionOut) # Since Cython 0.17.4 assigning a value to an argument # passed by reference will throw an error, the fix is to # to use "(&arg)[0] =" instead of "arg =", see this topic: # https://groups.google.com/forum/#!msg/cython-users/j58Sp3QMrD4/y9vJy9YBi_kJ # For CefRefPtr you should use swap() method instead. (&cefAllowOSExecution)[0] = 1 #(&cefAllowOSExecution)[0] = bool(pyAllowOSExecutionOut[0]) except: (exc_type, exc_value, exc_trace) = sys.exc_info() sys.excepthook(exc_type, exc_value, exc_trace) cdef public cpp_bool RequestHandler_OnBeforePluginLoad( CefRefPtr[CefBrowser] browser, const CefString& mime_type, const CefString& plugin_url, const CefString& top_origin_url, CefRefPtr[CefWebPluginInfo] plugin_info, cef_types.cef_plugin_policy_t* plugin_policy ) except * with gil: cdef PyBrowser pyBrowser cdef PyWebPluginInfo pyInfo cdef py_bool returnValue cdef object clientCallback try: # OnBeforePluginLoad is called from RequestContexthandler. # The Browser object might not be available, because it is # being set synchronously during CreateBrowserSync, after # Browser is created. From testing it always works, however # better be safe. if not browser.get(): Debug("WARNING: RequestHandler_OnBeforePluginLoad() failed," " Browser object is not available") return False py_browser = GetPyBrowser(browser, "OnBeforePluginLoad") py_plugin_info = CreatePyWebPluginInfo(plugin_info) clientCallback = GetGlobalClientCallback("OnBeforePluginLoad") if clientCallback: returnValue = clientCallback( browser=py_browser, mime_type=CefToPyString(mime_type), plugin_url=CefToPyString(plugin_url), top_origin_url=CefToPyString(top_origin_url), plugin_info=py_plugin_info) if returnValue: plugin_policy[0] = cef_types.PLUGIN_POLICY_DISABLE return bool(returnValue) else: return False except: (exc_type, exc_value, exc_trace) = sys.exc_info() sys.excepthook(exc_type, exc_value, exc_trace) cdef public cpp_bool RequestHandler_OnCertificateError( int certError, const CefString& cefRequestUrl, CefRefPtr[CefRequestCallback] cefCertCallback ) except * with gil: cdef py_bool returnValue cdef object clientCallback try: clientCallback = GetGlobalClientCallback("OnCertificateError") if clientCallback: returnValue = clientCallback( cert_error=certError, request_url=CefToPyString(cefRequestUrl), callback=CreatePyRequestCallback(cefCertCallback)) return bool(returnValue) else: return False except: (exc_type, exc_value, exc_trace) = sys.exc_info() sys.excepthook(exc_type, exc_value, exc_trace) cdef public void RequestHandler_OnRendererProcessTerminated( CefRefPtr[CefBrowser] cefBrowser, cef_types.cef_termination_status_t cefStatus ) except * with gil: # TODO: proccess may crash during browser creation. Let this callback # to be set either through cefpython.SetGlobalClientCallback() # or PyBrowser.SetClientCallback(). Modify the # PyBrowser.GetClientCallback() implementation to return a global # callback first if set. cdef PyBrowser pyBrowser cdef object clientCallback try: pyBrowser = GetPyBrowser(cefBrowser, "OnRendererProcessTerminated") clientCallback = pyBrowser.GetClientCallback( "OnRendererProcessTerminated") if clientCallback: clientCallback(browser=pyBrowser, status=cefStatus) except: (exc_type, exc_value, exc_trace) = sys.exc_info() sys.excepthook(exc_type, exc_value, exc_trace) cdef public void RequestHandler_OnPluginCrashed( CefRefPtr[CefBrowser] cefBrowser, const CefString& cefPluginPath ) except * with gil: # TODO: plugin may crash during browser creation. Let this callback # to be set either through cefpython.SetGlobalClientCallback() # or PyBrowser.SetClientCallback(). Modify the # PyBrowser.GetClientCallback() implementation to return a global # callback first if set. cdef PyBrowser pyBrowser cdef object clientCallback try: pyBrowser = GetPyBrowser(cefBrowser, "OnPluginCrashed") clientCallback = pyBrowser.GetClientCallback("OnPluginCrashed") if clientCallback: clientCallback( browser=pyBrowser, plugin_path=CefToPyString(cefPluginPath)) except: (exc_type, exc_value, exc_trace) = sys.exc_info() sys.excepthook(exc_type, exc_value, exc_trace) cefpython-49.0/src/handlers/resource_handler.pyx000066400000000000000000000231131334103266300221230ustar00rootroot00000000000000# Copyright (c) 2013 CEF Python, see the Authors file. # All rights reserved. Licensed under BSD 3-clause license. # Project website: https://github.com/cztomczak/cefpython include "../cefpython.pyx" import weakref # ----------------------------------------------------------------------------- # Globals # ----------------------------------------------------------------------------- # See StoreUserCookieVisitor(). cdef object g_userResourceHandler = weakref.WeakValueDictionary() cdef int g_userResourceHandlerMaxId = 0 # ----------------------------------------------------------------------------- # ResourceHandler # ----------------------------------------------------------------------------- cdef py_void ValidateUserResourceHandler(object userResourceHandler): cdef list methods = ["ProcessRequest", "GetResponseHeaders", "ReadResponse", "CanGetCookie", "CanSetCookie", "Cancel"] for method in methods: if userResourceHandler and hasattr(userResourceHandler, method)\ and callable(getattr(userResourceHandler, method)): # Okay. continue else: raise Exception("ResourceHandler object is missing method: %s"\ % method) cdef CefRefPtr[CefResourceHandler] CreateResourceHandler( object userResourceHandler) except *: ValidateUserResourceHandler(userResourceHandler) cdef int resourceHandlerId = StoreUserResourceHandler(userResourceHandler) cdef CefRefPtr[CefResourceHandler] resourceHandler =\ new ResourceHandler( resourceHandlerId) return resourceHandler cdef int StoreUserResourceHandler(object userResourceHandler) except *: global g_userResourceHandlerMaxId global g_userResourceHandler g_userResourceHandlerMaxId += 1 g_userResourceHandler[g_userResourceHandlerMaxId] = userResourceHandler return g_userResourceHandlerMaxId cdef PyResourceHandler GetPyResourceHandler(int resourceHandlerId): global g_userResourceHandler cdef object userResourceHandler cdef PyResourceHandler pyResourceHandler if resourceHandlerId in g_userResourceHandler: userResourceHandler = g_userResourceHandler[resourceHandlerId] pyResourceHandler = PyResourceHandler(userResourceHandler) return pyResourceHandler cdef class PyResourceHandler: cdef object userResourceHandler def __init__(self, object userResourceHandler): self.userResourceHandler = userResourceHandler cdef object GetCallback(self, str funcName): if self.userResourceHandler and ( hasattr(self.userResourceHandler, funcName) and ( callable(getattr(self.userResourceHandler, funcName)))): return getattr(self.userResourceHandler, funcName) # ------------------------------------------------------------------------------ # ResourceHandler callbacks # ------------------------------------------------------------------------------ cdef public cpp_bool ResourceHandler_ProcessRequest( int resourceHandlerId, CefRefPtr[CefRequest] cefRequest, CefRefPtr[CefCallback] cefCallback ) except * with gil: cdef PyResourceHandler pyResourceHandler cdef object userCallback cdef py_bool returnValue cdef PyRequest pyRequest cdef PyCallback pyCallback try: assert IsThread(TID_IO), "Must be called on the IO thread" pyResourceHandler = GetPyResourceHandler(resourceHandlerId) pyRequest = CreatePyRequest(cefRequest) pyCallback = CreatePyCallback(cefCallback) if pyResourceHandler: userCallback = pyResourceHandler.GetCallback("ProcessRequest") if userCallback: returnValue = userCallback( request=pyRequest, callback=pyCallback) return bool(returnValue) return False except: (exc_type, exc_value, exc_trace) = sys.exc_info() sys.excepthook(exc_type, exc_value, exc_trace) cdef public void ResourceHandler_GetResponseHeaders( int resourceHandlerId, CefRefPtr[CefResponse] cefResponse, int64& cefResponseLength, CefString& cefRedirectUrl ) except * with gil: cdef PyResourceHandler pyResourceHandler cdef object userCallback cdef py_bool returnValue cdef PyResponse pyResponse cdef list responseLengthOut cdef list redirectUrlOut try: assert IsThread(TID_IO), "Must be called on the IO thread" pyResourceHandler = GetPyResourceHandler(resourceHandlerId) pyResponse = CreatePyResponse(cefResponse) responseLengthOut = [cefResponseLength] redirectUrlOut = [CefToPyString(cefRedirectUrl)] if pyResourceHandler: userCallback = pyResourceHandler.GetCallback("GetResponseHeaders") if userCallback: returnValue = userCallback(pyResponse, responseLengthOut, redirectUrlOut) (&cefResponseLength)[0] = responseLengthOut[0] if redirectUrlOut[0]: PyToCefString(redirectUrlOut[0], cefRedirectUrl) return return except: (exc_type, exc_value, exc_trace) = sys.exc_info() sys.excepthook(exc_type, exc_value, exc_trace) cdef public cpp_bool ResourceHandler_ReadResponse( int resourceHandlerId, void* cefDataOut, int bytesToRead, int& cefBytesRead, CefRefPtr[CefCallback] cefCallback ) except * with gil: cdef PyResourceHandler pyResourceHandler cdef object userCallback cdef py_bool returnValue cdef list dataOut cdef list bytesReadOut cdef PyCallback pyCallback cdef char* tempData cdef int tempDataLength cdef int pyBytesRead try: assert IsThread(TID_IO), "Must be called on the IO thread" pyResourceHandler = GetPyResourceHandler(resourceHandlerId) dataOut = [""] bytesReadOut = [0] pyCallback = CreatePyCallback(cefCallback) if pyResourceHandler: userCallback = pyResourceHandler.GetCallback("ReadResponse") if userCallback: returnValue = userCallback( data_out=dataOut, bytes_to_read=bytesToRead, bytes_read_out=bytesReadOut, callback=pyCallback) pyBytesRead = int(bytesReadOut[0]) if dataOut[0] and IsString(dataOut[0]): # The tempData pointer is tied to the lifetime # of dataOut[0] string. tempData = dataOut[0] memcpy(cefDataOut, tempData, len(dataOut[0])) assert pyBytesRead >= 0, "bytesReadOut < 0" (&cefBytesRead)[0] = pyBytesRead # True should be returned now. else: (&cefBytesRead)[0] = 0 # Either: # 1. True should be returned and callback.Continue() # called at a later time. # 2. False returned to indicate response completion. return bool(returnValue) return False except: (exc_type, exc_value, exc_trace) = sys.exc_info() sys.excepthook(exc_type, exc_value, exc_trace) cdef public cpp_bool ResourceHandler_CanGetCookie( int resourceHandlerId, const CefCookie& cefCookie ) except * with gil: cdef PyResourceHandler pyResourceHandler cdef object userCallback cdef py_bool returnValue cdef PyCookie pyCookie try: assert IsThread(TID_IO), "Must be called on the IO thread" pyResourceHandler = GetPyResourceHandler(resourceHandlerId) pyCookie = CreatePyCookie(cefCookie) if pyResourceHandler: userCallback = pyResourceHandler.GetCallback("CanGetCookie") if userCallback: returnValue = userCallback(cookie=pyCookie) return bool(returnValue) return False except: (exc_type, exc_value, exc_trace) = sys.exc_info() sys.excepthook(exc_type, exc_value, exc_trace) cdef public cpp_bool ResourceHandler_CanSetCookie( int resourceHandlerId, const CefCookie& cefCookie ) except * with gil: cdef PyResourceHandler pyResourceHandler cdef object userCallback cdef py_bool returnValue cdef PyCookie pyCookie try: assert IsThread(TID_IO), "Must be called on the IO thread" pyResourceHandler = GetPyResourceHandler(resourceHandlerId) pyCookie = CreatePyCookie(cefCookie) if pyResourceHandler: userCallback = pyResourceHandler.GetCallback("CanSetCookie") if userCallback: returnValue = userCallback(cookie=pyCookie) return bool(returnValue) return False except: (exc_type, exc_value, exc_trace) = sys.exc_info() sys.excepthook(exc_type, exc_value, exc_trace) cdef public void ResourceHandler_Cancel( int resourceHandlerId ) except * with gil: cdef PyResourceHandler pyResourceHandler cdef object userCallback try: assert IsThread(TID_IO), "Must be called on the IO thread" pyResourceHandler = GetPyResourceHandler(resourceHandlerId) if pyResourceHandler: userCallback = pyResourceHandler.GetCallback("Cancel") if userCallback: userCallback() return return except: (exc_type, exc_value, exc_trace) = sys.exc_info() sys.excepthook(exc_type, exc_value, exc_trace)cefpython-49.0/src/handlers/v8context_handler.pyx000066400000000000000000000061071334103266300222420ustar00rootroot00000000000000# Copyright (c) 2012 CEF Python, see the Authors file. # All rights reserved. Licensed under BSD 3-clause license. # Project website: https://github.com/cztomczak/cefpython # In CEF 3 there is no V8ContextHandler, the methods OnContextCreated(), # OnContextReleased(), OnUncaughtException() are in CefRenderProcessHandler # and are called in the Renderer process, we use process messaging to # recreate these events in the Browser process, but the timing will be # a bit delayed due to asynchronous way this is being done. include "../cefpython.pyx" include "../browser.pyx" cdef public void V8ContextHandler_OnContextCreated( CefRefPtr[CefBrowser] cefBrowser, CefRefPtr[CefFrame] cefFrame ) except * with gil: cdef PyBrowser pyBrowser cdef PyFrame pyFrame cdef object clientCallback try: Debug("V8ContextHandler_OnContextCreated()") pyBrowser = GetPyBrowser(cefBrowser, "OnContextCreated") pyBrowser.SetUserData("__v8ContextCreated", True) pyFrame = GetPyFrame(cefFrame) # User defined callback. clientCallback = pyBrowser.GetClientCallback("OnContextCreated") if clientCallback: clientCallback(browser=pyBrowser, frame=pyFrame) except: (exc_type, exc_value, exc_trace) = sys.exc_info() sys.excepthook(exc_type, exc_value, exc_trace) cdef public void V8ContextHandler_OnContextReleased( int browserId, int64 frameId ) except * with gil: cdef PyBrowser pyBrowser cdef PyFrame pyFrame cdef object clientCallback try: # Due to multi-process architecture in CEF 3, this function won't # get called for the main frame in main browser. To send a message # from the renderer process a parent browser is used. If this was # a main frame then this would mean that the browser is being # destroyed, thus we can't send a process message using this browser. # There is no guarantee that this will get called for frames in the # main browser, if the browser is destroyed shortly after the frames # were released. Debug("V8ContextHandler_OnContextReleased()") pyBrowser = GetPyBrowserById(browserId) if not pyBrowser: Debug("OnContextReleased: Browser doesn't exist anymore, id={id}" .format(id=str(browserId))) return pyFrame = GetPyFrameById(browserId, frameId) if pyBrowser and pyFrame: clientCallback = pyBrowser.GetClientCallback("OnContextReleased") if clientCallback: clientCallback(browser=pyBrowser, frame=pyFrame) else: if not pyBrowser: Debug("V8ContextHandler_OnContextReleased() WARNING: " "PyBrowser not found") if not pyFrame: Debug("V8ContextHandler_OnContextReleased() WARNING: " "PyFrame not found") RemovePyFrame(browserId, frameId) except: (exc_type, exc_value, exc_trace) = sys.exc_info() sys.excepthook(exc_type, exc_value, exc_trace) cefpython-49.0/src/handlers/v8function_handler.pyx000066400000000000000000000043451334103266300224050ustar00rootroot00000000000000# Copyright (c) 2012 CEF Python, see the Authors file. # All rights reserved. Licensed under BSD 3-clause license. # Project website: https://github.com/cztomczak/cefpython include "../cefpython.pyx" include "../browser.pyx" cdef public void V8FunctionHandler_Execute( CefRefPtr[CefBrowser] cefBrowser, CefRefPtr[CefFrame] cefFrame, CefString& cefFunctionName, CefRefPtr[CefListValue] cefFunctionArguments ) except * with gil: cdef PyBrowser pyBrowser cdef PyFrame pyFrame cdef py_string functionName cdef object function cdef list functionArguments cdef object returnValue cdef py_string jsErrorMessage try: pyBrowser = GetPyBrowser(cefBrowser, "V8FunctionHandler_Execute") pyFrame = GetPyFrame(cefFrame) functionName = CefToPyString(cefFunctionName) Debug("V8FunctionHandler_Execute(): functionName=%s" % functionName) jsBindings = pyBrowser.GetJavascriptBindings() function = jsBindings.GetFunctionOrMethod(functionName) if not function: # The Renderer process already checks whether function # name is valid before calling V8FunctionHandler_Execute(), # but it is possible for the javascript bindings to change # during execution, so it's possible for the Browser/Renderer # bindings to be out of sync due to delay in process messaging. jsErrorMessage = "V8FunctionHandler_Execute() FAILED: " \ "python function not found: %s" % functionName Debug(jsErrorMessage) # Raise a javascript exception in that frame. pyFrame.ExecuteJavascript("throw '%s';" % jsErrorMessage) return functionArguments = CefListValueToPyList(cefBrowser, cefFunctionArguments) returnValue = function(*functionArguments) if returnValue is not None: Debug("V8FunctionHandler_Execute() WARNING: function returned" \ "value, but returning values to javascript is not " \ "supported, functionName=%s" % functionName) except: (exc_type, exc_value, exc_trace) = sys.exc_info() sys.excepthook(exc_type, exc_value, exc_trace) cefpython-49.0/src/helpers.pyx000066400000000000000000000067041334103266300164500ustar00rootroot00000000000000# Copyright (c) 2012 CEF Python, see the Authors file. # All rights reserved. Licensed under BSD 3-clause license. # Project website: https://github.com/cztomczak/cefpython include "cefpython.pyx" import os import platform import re import traceback import time import codecs def ExceptHook(exc_type, exc_value, exc_trace): """Global except hook to exit app cleanly on error. This hook does the following: in case of exception write it to the "error.log" file, display it to the console, shutdown CEF and exit application immediately by ignoring "finally" (_exit()). """ print("[CEF Python] ExceptHook: catched exception, will shutdown CEF") QuitMessageLoop() Shutdown() msg = "".join(traceback.format_exception(exc_type, exc_value, exc_trace)) error_file = GetAppPath("error.log") encoding = GetAppSetting("string_encoding") or "utf-8" if type(msg) == bytes: msg = msg.decode(encoding=encoding, errors="replace") try: with codecs.open(error_file, mode="a", encoding=encoding) as fp: fp.write("\n[%s] %s\n" % ( time.strftime("%Y-%m-%d %H:%M:%S"), msg)) except: print("[CEF Python] WARNING: failed writing to error file: %s" % ( error_file)) # Convert error message to ascii before printing, otherwise # you may get error like this: # | UnicodeEncodeError: 'charmap' codec can't encode characters msg = msg.encode("ascii", errors="replace") msg = msg.decode("ascii", errors="replace") print("\n"+msg) # noinspection PyProtectedMember os._exit(1) cpdef str GetModuleDirectory(): """Get path to the cefpython module (so/pyd).""" if platform.system() == "Linux" and os.getenv("CEFPYTHON3_PATH"): # cefpython3 package __init__.py sets CEFPYTHON3_PATH. # When cefpython3 is installed as debian package, this # env variable is the only way of getting valid path. return os.getenv("CEFPYTHON3_PATH") if hasattr(sys, "frozen"): path = os.path.dirname(sys.executable) elif "__file__" in globals(): path = os.path.dirname(os.path.realpath(__file__)) else: path = os.getcwd() if platform.system() == "Windows": path = re.sub(r"[/\\]+", re.escape(os.sep), path) path = re.sub(r"[/\\]+$", "", path) return os.path.abspath(path) g_GetAppPath_dir = None cpdef str GetAppPath(file_=None): """Get application path.""" # On Windows after downloading file and calling Browser.GoForward(), # current working directory is set to %UserProfile%. # Calling os.path.dirname(os.path.realpath(__file__)) # returns for eg. "C:\Users\user\Downloads". A solution # is to cache path on first call. if not g_GetAppPath_dir: if hasattr(sys, "frozen"): adir = os.path.dirname(sys.executable) else: adir = os.getcwd() global g_GetAppPath_dir g_GetAppPath_dir = adir # If file is None return current directory without trailing slash. if file_ is None: file_ = "" # Only when relative path. if not file_.startswith("/") and not file_.startswith("\\") and ( not re.search(r"^[\w-]+:", file_)): path = g_GetAppPath_dir + os.sep + file_ if platform.system() == "Windows": path = re.sub(r"[/\\]+", re.escape(os.sep), path) path = re.sub(r"[/\\]+$", "", path) return path return str(file_) cefpython-49.0/src/image.pyx000066400000000000000000000053221334103266300160630ustar00rootroot00000000000000# Copyright (c) 2016 CEF Python, see the Authors file. # All rights reserved. Licensed under BSD 3-clause license. # Project website: https://github.com/cztomczak/cefpython include "cefpython.pyx" # noinspection PyUnresolvedReferences cimport cef_types # cef_color_type_t CEF_COLOR_TYPE_RGBA_8888 = cef_types.CEF_COLOR_TYPE_RGBA_8888 CEF_COLOR_TYPE_BGRA_8888 = cef_types.CEF_COLOR_TYPE_BGRA_8888 # cef_alpha_type_t CEF_ALPHA_TYPE_OPAQUE = cef_types.CEF_ALPHA_TYPE_OPAQUE CEF_ALPHA_TYPE_PREMULTIPLIED = cef_types.CEF_ALPHA_TYPE_PREMULTIPLIED CEF_ALPHA_TYPE_POSTMULTIPLIED = cef_types.CEF_ALPHA_TYPE_POSTMULTIPLIED cdef PyImage PyImage_Init(CefRefPtr[CefImage] cef_image): cdef PyImage image = PyImage() image.cef_image = cef_image return image cdef class PyImage: cdef CefRefPtr[CefImage] cef_image cpdef bytes GetAsBitmap(self, float scale_factor, cef_types.cef_color_type_t color_type, cef_types.cef_alpha_type_t alpha_type): cdef int pixel_width = 0 cdef int pixel_height = 0 if not self.cef_image.get(): raise Exception("cef_image is NULL") cdef CefRefPtr[CefBinaryValue] binary_value =\ self.cef_image.get().GetAsBitmap(scale_factor, color_type, alpha_type, pixel_width, pixel_height) cdef size_t size = binary_value.get().GetSize() cdef void* abuffer = malloc(size) binary_value.get().GetData(abuffer, size, 0) cdef bytes ret = (abuffer)[:size] free(abuffer) return ret cpdef bytes GetAsPng(self, float scale_factor, py_bool with_transparency): cdef int pixel_width = 0 cdef int pixel_height = 0 if not self.cef_image.get(): raise Exception("cef_image is NULL") cdef CefRefPtr[CefBinaryValue] binary_value =\ self.cef_image.get().GetAsPNG(scale_factor, bool(with_transparency), pixel_width, pixel_height) cdef size_t size = binary_value.get().GetSize() cdef void* abuffer = malloc(size) binary_value.get().GetData(abuffer, size, 0) cdef bytes ret = (abuffer)[:size] free(abuffer) return ret cpdef size_t GetHeight(self): if not self.cef_image.get(): raise Exception("cef_image is NULL") return self.cef_image.get().GetHeight() cpdef size_t GetWidth(self): if not self.cef_image.get(): raise Exception("cef_image is NULL") return self.cef_image.get().GetWidth() cefpython-49.0/src/include/000077500000000000000000000000001334103266300156605ustar00rootroot00000000000000cefpython-49.0/src/include/base/000077500000000000000000000000001334103266300165725ustar00rootroot00000000000000cefpython-49.0/src/include/base/cef_atomic_ref_count.h000066400000000000000000000123561334103266300231070ustar00rootroot00000000000000// Copyright (c) 2014 Marshall A. Greenblatt. Portions copyright (c) 2011 // Google Inc. 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 is a low level implementation of atomic semantics for reference // counting. Please use cef_ref_counted.h directly instead. // // The Chromium implementation includes annotations to avoid some false // positives when using data race detection tools. Annotations are not // currently supported by the CEF implementation. #ifndef CEF_INCLUDE_BASE_CEF_ATOMIC_REF_COUNT_H_ #define CEF_INCLUDE_BASE_CEF_ATOMIC_REF_COUNT_H_ #pragma once #if defined(BASE_ATOMIC_REF_COUNT_H_) // Do nothing if the Chromium header has already been included. // This can happen in cases where Chromium code is used directly by the // client application. When using Chromium code directly always include // the Chromium header first to avoid type conflicts. #elif defined(BUILDING_CEF_SHARED) // When building CEF include the Chromium header directly. #include "base/atomic_ref_count.h" #else // !BUILDING_CEF_SHARED // The following is substantially similar to the Chromium implementation. // If the Chromium implementation diverges the below implementation should be // updated to match. #include "include/base/cef_atomicops.h" // Annotations are not currently supported. #define ANNOTATE_HAPPENS_BEFORE(obj) /* empty */ #define ANNOTATE_HAPPENS_AFTER(obj) /* empty */ namespace base { typedef subtle::Atomic32 AtomicRefCount; // Increment a reference count by "increment", which must exceed 0. inline void AtomicRefCountIncN(volatile AtomicRefCount *ptr, AtomicRefCount increment) { subtle::NoBarrier_AtomicIncrement(ptr, increment); } // Decrement a reference count by "decrement", which must exceed 0, // and return whether the result is non-zero. // Insert barriers to ensure that state written before the reference count // became zero will be visible to a thread that has just made the count zero. inline bool AtomicRefCountDecN(volatile AtomicRefCount *ptr, AtomicRefCount decrement) { ANNOTATE_HAPPENS_BEFORE(ptr); bool res = (subtle::Barrier_AtomicIncrement(ptr, -decrement) != 0); if (!res) { ANNOTATE_HAPPENS_AFTER(ptr); } return res; } // Increment a reference count by 1. inline void AtomicRefCountInc(volatile AtomicRefCount *ptr) { base::AtomicRefCountIncN(ptr, 1); } // Decrement a reference count by 1 and return whether the result is non-zero. // Insert barriers to ensure that state written before the reference count // became zero will be visible to a thread that has just made the count zero. inline bool AtomicRefCountDec(volatile AtomicRefCount *ptr) { return base::AtomicRefCountDecN(ptr, 1); } // Return whether the reference count is one. If the reference count is used // in the conventional way, a refrerence count of 1 implies that the current // thread owns the reference and no other thread shares it. This call performs // the test for a reference count of one, and performs the memory barrier // needed for the owning thread to act on the object, knowing that it has // exclusive access to the object. inline bool AtomicRefCountIsOne(volatile AtomicRefCount *ptr) { bool res = (subtle::Acquire_Load(ptr) == 1); if (res) { ANNOTATE_HAPPENS_AFTER(ptr); } return res; } // Return whether the reference count is zero. With conventional object // referencing counting, the object will be destroyed, so the reference count // should never be zero. Hence this is generally used for a debug check. inline bool AtomicRefCountIsZero(volatile AtomicRefCount *ptr) { bool res = (subtle::Acquire_Load(ptr) == 0); if (res) { ANNOTATE_HAPPENS_AFTER(ptr); } return res; } } // namespace base #endif // !BUILDING_CEF_SHARED #endif // CEF_INCLUDE_BASE_CEF_ATOMIC_REF_COUNT_H_ cefpython-49.0/src/include/base/cef_atomicops.h000066400000000000000000000214131334103266300215570ustar00rootroot00000000000000// Copyright (c) 2014 Marshall A. Greenblatt. Portions copyright (c) 2012 // Google Inc. 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. // For atomic operations on reference counts, see cef_atomic_ref_count.h. // The routines exported by this module are subtle. If you use them, even if // you get the code right, it will depend on careful reasoning about atomicity // and memory ordering; it will be less readable, and harder to maintain. If // you plan to use these routines, you should have a good reason, such as solid // evidence that performance would otherwise suffer, or there being no // alternative. You should assume only properties explicitly guaranteed by the // specifications in this file. You are almost certainly _not_ writing code // just for the x86; if you assume x86 semantics, x86 hardware bugs and // implementations on other archtectures will cause your code to break. If you // do not know what you are doing, avoid these routines, and use a Mutex. // // It is incorrect to make direct assignments to/from an atomic variable. // You should use one of the Load or Store routines. The NoBarrier // versions are provided when no barriers are needed: // NoBarrier_Store() // NoBarrier_Load() // Although there are currently no compiler enforcement, you are encouraged // to use these. // #ifndef CEF_INCLUDE_BASE_CEF_ATOMICOPS_H_ #define CEF_INCLUDE_BASE_CEF_ATOMICOPS_H_ #pragma once #if defined(BASE_ATOMICOPS_H_) // Do nothing if the Chromium header has already been included. // This can happen in cases where Chromium code is used directly by the // client application. When using Chromium code directly always include // the Chromium header first to avoid type conflicts. #elif defined(BUILDING_CEF_SHARED) // When building CEF include the Chromium header directly. #include "base/atomicops.h" #else // !BUILDING_CEF_SHARED // The following is substantially similar to the Chromium implementation. // If the Chromium implementation diverges the below implementation should be // updated to match. #include #include "include/base/cef_build.h" #if defined(OS_WIN) && defined(ARCH_CPU_64_BITS) // windows.h #defines this (only on x64). This causes problems because the // public API also uses MemoryBarrier at the public name for this fence. So, on // X64, undef it, and call its documented // (http://msdn.microsoft.com/en-us/library/windows/desktop/ms684208.aspx) // implementation directly. #undef MemoryBarrier #endif namespace base { namespace subtle { typedef int32_t Atomic32; #ifdef ARCH_CPU_64_BITS // We need to be able to go between Atomic64 and AtomicWord implicitly. This // means Atomic64 and AtomicWord should be the same type on 64-bit. #if defined(__ILP32__) || defined(OS_NACL) // NaCl's intptr_t is not actually 64-bits on 64-bit! // http://code.google.com/p/nativeclient/issues/detail?id=1162 typedef int64_t Atomic64; #else typedef intptr_t Atomic64; #endif #endif // Use AtomicWord for a machine-sized pointer. It will use the Atomic32 or // Atomic64 routines below, depending on your architecture. typedef intptr_t AtomicWord; // Atomically execute: // result = *ptr; // if (*ptr == old_value) // *ptr = new_value; // return result; // // I.e., replace "*ptr" with "new_value" if "*ptr" used to be "old_value". // Always return the old value of "*ptr" // // This routine implies no memory barriers. Atomic32 NoBarrier_CompareAndSwap(volatile Atomic32* ptr, Atomic32 old_value, Atomic32 new_value); // Atomically store new_value into *ptr, returning the previous value held in // *ptr. This routine implies no memory barriers. Atomic32 NoBarrier_AtomicExchange(volatile Atomic32* ptr, Atomic32 new_value); // Atomically increment *ptr by "increment". Returns the new value of // *ptr with the increment applied. This routine implies no memory barriers. Atomic32 NoBarrier_AtomicIncrement(volatile Atomic32* ptr, Atomic32 increment); Atomic32 Barrier_AtomicIncrement(volatile Atomic32* ptr, Atomic32 increment); // These following lower-level operations are typically useful only to people // implementing higher-level synchronization operations like spinlocks, // mutexes, and condition-variables. They combine CompareAndSwap(), a load, or // a store with appropriate memory-ordering instructions. "Acquire" operations // ensure that no later memory access can be reordered ahead of the operation. // "Release" operations ensure that no previous memory access can be reordered // after the operation. "Barrier" operations have both "Acquire" and "Release" // semantics. A MemoryBarrier() has "Barrier" semantics, but does no memory // access. Atomic32 Acquire_CompareAndSwap(volatile Atomic32* ptr, Atomic32 old_value, Atomic32 new_value); Atomic32 Release_CompareAndSwap(volatile Atomic32* ptr, Atomic32 old_value, Atomic32 new_value); void MemoryBarrier(); void NoBarrier_Store(volatile Atomic32* ptr, Atomic32 value); void Acquire_Store(volatile Atomic32* ptr, Atomic32 value); void Release_Store(volatile Atomic32* ptr, Atomic32 value); Atomic32 NoBarrier_Load(volatile const Atomic32* ptr); Atomic32 Acquire_Load(volatile const Atomic32* ptr); Atomic32 Release_Load(volatile const Atomic32* ptr); // 64-bit atomic operations (only available on 64-bit processors). #ifdef ARCH_CPU_64_BITS Atomic64 NoBarrier_CompareAndSwap(volatile Atomic64* ptr, Atomic64 old_value, Atomic64 new_value); Atomic64 NoBarrier_AtomicExchange(volatile Atomic64* ptr, Atomic64 new_value); Atomic64 NoBarrier_AtomicIncrement(volatile Atomic64* ptr, Atomic64 increment); Atomic64 Barrier_AtomicIncrement(volatile Atomic64* ptr, Atomic64 increment); Atomic64 Acquire_CompareAndSwap(volatile Atomic64* ptr, Atomic64 old_value, Atomic64 new_value); Atomic64 Release_CompareAndSwap(volatile Atomic64* ptr, Atomic64 old_value, Atomic64 new_value); void NoBarrier_Store(volatile Atomic64* ptr, Atomic64 value); void Acquire_Store(volatile Atomic64* ptr, Atomic64 value); void Release_Store(volatile Atomic64* ptr, Atomic64 value); Atomic64 NoBarrier_Load(volatile const Atomic64* ptr); Atomic64 Acquire_Load(volatile const Atomic64* ptr); Atomic64 Release_Load(volatile const Atomic64* ptr); #endif // ARCH_CPU_64_BITS } // namespace subtle } // namespace base // Include our platform specific implementation. #if defined(OS_WIN) && defined(COMPILER_MSVC) && defined(ARCH_CPU_X86_FAMILY) #include "include/base/internal/cef_atomicops_x86_msvc.h" #elif defined(OS_MACOSX) #include "include/base/internal/cef_atomicops_mac.h" #elif defined(COMPILER_GCC) && defined(ARCH_CPU_X86_FAMILY) #include "include/base/internal/cef_atomicops_x86_gcc.h" #else #error "Atomic operations are not supported on your platform" #endif // On some platforms we need additional declarations to make // AtomicWord compatible with our other Atomic* types. #if defined(OS_MACOSX) || defined(OS_OPENBSD) #include "include/base/internal/cef_atomicops_atomicword_compat.h" #endif #endif // !BUILDING_CEF_SHARED #endif // CEF_INCLUDE_BASE_CEF_ATOMICOPS_H_ cefpython-49.0/src/include/base/cef_basictypes.h000066400000000000000000000061251334103266300217320ustar00rootroot00000000000000// Copyright (c) 2014 Marshall A. Greenblatt. Portions copyright (c) 2012 // Google Inc. 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_BASE_CEF_BASICTYPES_H_ #define CEF_INCLUDE_BASE_CEF_BASICTYPES_H_ #pragma once #include // For UINT_MAX #include // For size_t #include "include/base/cef_build.h" // The NSPR system headers define 64-bit as |long| when possible, except on // Mac OS X. In order to not have typedef mismatches, we do the same on LP64. // // On Mac OS X, |long long| is used for 64-bit types for compatibility with // format macros even in the LP64 model. #if defined(__LP64__) && !defined(OS_MACOSX) && !defined(OS_OPENBSD) typedef long int64; // NOLINT(runtime/int) typedef unsigned long uint64; // NOLINT(runtime/int) #else typedef long long int64; // NOLINT(runtime/int) typedef unsigned long long uint64; // NOLINT(runtime/int) #endif // TODO: Remove these type guards. These are to avoid conflicts with // obsolete/protypes.h in the Gecko SDK. #ifndef _INT32 #define _INT32 typedef int int32; #endif // TODO: Remove these type guards. These are to avoid conflicts with // obsolete/protypes.h in the Gecko SDK. #ifndef _UINT32 #define _UINT32 typedef unsigned int uint32; #endif // UTF-16 character type. // This should be kept synchronized with base/strings/string16.h #ifndef char16 #if defined(WCHAR_T_IS_UTF16) typedef wchar_t char16; #elif defined(WCHAR_T_IS_UTF32) typedef unsigned short char16; #endif #endif #endif // CEF_INCLUDE_BASE_CEF_BASICTYPES_H_ cefpython-49.0/src/include/base/cef_bind.h000066400000000000000000000703561334103266300205070ustar00rootroot00000000000000// Copyright (c) 2014 Marshall A. Greenblatt. Portions copyright (c) 2011 // Google Inc. 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_BASE_CEF_BIND_H_ #define CEF_INCLUDE_BASE_CEF_BIND_H_ #pragma once #if defined(BASE_BIND_H_) // Do nothing if the Chromium header has already been included. // This can happen in cases where Chromium code is used directly by the // client application. When using Chromium code directly always include // the Chromium header first to avoid type conflicts. #elif defined(BUILDING_CEF_SHARED) // When building CEF include the Chromium header directly. #include "base/bind.h" #else // !BUILDING_CEF_SHARED // The following is substantially similar to the Chromium implementation. // If the Chromium implementation diverges the below implementation should be // updated to match. #include "include/base/internal/cef_bind_internal.h" #include "include/base/internal/cef_callback_internal.h" // ----------------------------------------------------------------------------- // Usage documentation // ----------------------------------------------------------------------------- // // See base/cef_callback.h for documentation. // // // ----------------------------------------------------------------------------- // Implementation notes // ----------------------------------------------------------------------------- // // If you're reading the implementation, before proceeding further, you should // read the top comment of base/bind_internal.h for a definition of common // terms and concepts. // // RETURN TYPES // // Though Bind()'s result is meant to be stored in a Callback<> type, it // cannot actually return the exact type without requiring a large amount // of extra template specializations. The problem is that in order to // discern the correct specialization of Callback<>, Bind would need to // unwrap the function signature to determine the signature's arity, and // whether or not it is a method. // // Each unique combination of (arity, function_type, num_prebound) where // function_type is one of {function, method, const_method} would require // one specialization. We eventually have to do a similar number of // specializations anyways in the implementation (see the Invoker<>, // classes). However, it is avoidable in Bind if we return the result // via an indirection like we do below. // // TODO(ajwong): We might be able to avoid this now, but need to test. // // It is possible to move most of the COMPILE_ASSERT asserts into BindState<>, // but it feels a little nicer to have the asserts here so people do not // need to crack open bind_internal.h. On the other hand, it makes Bind() // harder to read. namespace base { template base::Callback< typename cef_internal::BindState< typename cef_internal::FunctorTraits::RunnableType, typename cef_internal::FunctorTraits::RunType, void()> ::UnboundRunType> Bind(Functor functor) { // Typedefs for how to store and run the functor. typedef typename cef_internal::FunctorTraits::RunnableType RunnableType; typedef typename cef_internal::FunctorTraits::RunType RunType; typedef cef_internal::BindState BindState; return Callback( new BindState(cef_internal::MakeRunnable(functor))); } template base::Callback< typename cef_internal::BindState< typename cef_internal::FunctorTraits::RunnableType, typename cef_internal::FunctorTraits::RunType, void(typename cef_internal::CallbackParamTraits::StorageType)> ::UnboundRunType> Bind(Functor functor, const P1& p1) { // Typedefs for how to store and run the functor. typedef typename cef_internal::FunctorTraits::RunnableType RunnableType; typedef typename cef_internal::FunctorTraits::RunType RunType; // Use RunnableType::RunType instead of RunType above because our // checks should below for bound references need to know what the actual // functor is going to interpret the argument as. typedef cef_internal::FunctionTraits BoundFunctorTraits; // Do not allow binding a non-const reference parameter. Non-const reference // parameters are disallowed by the Google style guide. Also, binding a // non-const reference parameter can make for subtle bugs because the // invoked function will receive a reference to the stored copy of the // argument and not the original. COMPILE_ASSERT( !(is_non_const_reference::value ), do_not_bind_functions_with_nonconst_ref); // For methods, we need to be careful for parameter 1. We do not require // a scoped_refptr because BindState<> itself takes care of AddRef() for // methods. We also disallow binding of an array as the method's target // object. COMPILE_ASSERT( cef_internal::HasIsMethodTag::value || !cef_internal::NeedsScopedRefptrButGetsRawPtr::value, p1_is_refcounted_type_and_needs_scoped_refptr); COMPILE_ASSERT(!cef_internal::HasIsMethodTag::value || !is_array::value, first_bound_argument_to_method_cannot_be_array); typedef cef_internal::BindState::StorageType)> BindState; return Callback( new BindState(cef_internal::MakeRunnable(functor), p1)); } template base::Callback< typename cef_internal::BindState< typename cef_internal::FunctorTraits::RunnableType, typename cef_internal::FunctorTraits::RunType, void(typename cef_internal::CallbackParamTraits::StorageType, typename cef_internal::CallbackParamTraits::StorageType)> ::UnboundRunType> Bind(Functor functor, const P1& p1, const P2& p2) { // Typedefs for how to store and run the functor. typedef typename cef_internal::FunctorTraits::RunnableType RunnableType; typedef typename cef_internal::FunctorTraits::RunType RunType; // Use RunnableType::RunType instead of RunType above because our // checks should below for bound references need to know what the actual // functor is going to interpret the argument as. typedef cef_internal::FunctionTraits BoundFunctorTraits; // Do not allow binding a non-const reference parameter. Non-const reference // parameters are disallowed by the Google style guide. Also, binding a // non-const reference parameter can make for subtle bugs because the // invoked function will receive a reference to the stored copy of the // argument and not the original. COMPILE_ASSERT( !(is_non_const_reference::value || is_non_const_reference::value ), do_not_bind_functions_with_nonconst_ref); // For methods, we need to be careful for parameter 1. We do not require // a scoped_refptr because BindState<> itself takes care of AddRef() for // methods. We also disallow binding of an array as the method's target // object. COMPILE_ASSERT( cef_internal::HasIsMethodTag::value || !cef_internal::NeedsScopedRefptrButGetsRawPtr::value, p1_is_refcounted_type_and_needs_scoped_refptr); COMPILE_ASSERT(!cef_internal::HasIsMethodTag::value || !is_array::value, first_bound_argument_to_method_cannot_be_array); COMPILE_ASSERT(!cef_internal::NeedsScopedRefptrButGetsRawPtr::value, p2_is_refcounted_type_and_needs_scoped_refptr); typedef cef_internal::BindState::StorageType, typename cef_internal::CallbackParamTraits::StorageType)> BindState; return Callback( new BindState(cef_internal::MakeRunnable(functor), p1, p2)); } template base::Callback< typename cef_internal::BindState< typename cef_internal::FunctorTraits::RunnableType, typename cef_internal::FunctorTraits::RunType, void(typename cef_internal::CallbackParamTraits::StorageType, typename cef_internal::CallbackParamTraits::StorageType, typename cef_internal::CallbackParamTraits::StorageType)> ::UnboundRunType> Bind(Functor functor, const P1& p1, const P2& p2, const P3& p3) { // Typedefs for how to store and run the functor. typedef typename cef_internal::FunctorTraits::RunnableType RunnableType; typedef typename cef_internal::FunctorTraits::RunType RunType; // Use RunnableType::RunType instead of RunType above because our // checks should below for bound references need to know what the actual // functor is going to interpret the argument as. typedef cef_internal::FunctionTraits BoundFunctorTraits; // Do not allow binding a non-const reference parameter. Non-const reference // parameters are disallowed by the Google style guide. Also, binding a // non-const reference parameter can make for subtle bugs because the // invoked function will receive a reference to the stored copy of the // argument and not the original. COMPILE_ASSERT( !(is_non_const_reference::value || is_non_const_reference::value || is_non_const_reference::value ), do_not_bind_functions_with_nonconst_ref); // For methods, we need to be careful for parameter 1. We do not require // a scoped_refptr because BindState<> itself takes care of AddRef() for // methods. We also disallow binding of an array as the method's target // object. COMPILE_ASSERT( cef_internal::HasIsMethodTag::value || !cef_internal::NeedsScopedRefptrButGetsRawPtr::value, p1_is_refcounted_type_and_needs_scoped_refptr); COMPILE_ASSERT(!cef_internal::HasIsMethodTag::value || !is_array::value, first_bound_argument_to_method_cannot_be_array); COMPILE_ASSERT(!cef_internal::NeedsScopedRefptrButGetsRawPtr::value, p2_is_refcounted_type_and_needs_scoped_refptr); COMPILE_ASSERT(!cef_internal::NeedsScopedRefptrButGetsRawPtr::value, p3_is_refcounted_type_and_needs_scoped_refptr); typedef cef_internal::BindState::StorageType, typename cef_internal::CallbackParamTraits::StorageType, typename cef_internal::CallbackParamTraits::StorageType)> BindState; return Callback( new BindState(cef_internal::MakeRunnable(functor), p1, p2, p3)); } template base::Callback< typename cef_internal::BindState< typename cef_internal::FunctorTraits::RunnableType, typename cef_internal::FunctorTraits::RunType, void(typename cef_internal::CallbackParamTraits::StorageType, typename cef_internal::CallbackParamTraits::StorageType, typename cef_internal::CallbackParamTraits::StorageType, typename cef_internal::CallbackParamTraits::StorageType)> ::UnboundRunType> Bind(Functor functor, const P1& p1, const P2& p2, const P3& p3, const P4& p4) { // Typedefs for how to store and run the functor. typedef typename cef_internal::FunctorTraits::RunnableType RunnableType; typedef typename cef_internal::FunctorTraits::RunType RunType; // Use RunnableType::RunType instead of RunType above because our // checks should below for bound references need to know what the actual // functor is going to interpret the argument as. typedef cef_internal::FunctionTraits BoundFunctorTraits; // Do not allow binding a non-const reference parameter. Non-const reference // parameters are disallowed by the Google style guide. Also, binding a // non-const reference parameter can make for subtle bugs because the // invoked function will receive a reference to the stored copy of the // argument and not the original. COMPILE_ASSERT( !(is_non_const_reference::value || is_non_const_reference::value || is_non_const_reference::value || is_non_const_reference::value ), do_not_bind_functions_with_nonconst_ref); // For methods, we need to be careful for parameter 1. We do not require // a scoped_refptr because BindState<> itself takes care of AddRef() for // methods. We also disallow binding of an array as the method's target // object. COMPILE_ASSERT( cef_internal::HasIsMethodTag::value || !cef_internal::NeedsScopedRefptrButGetsRawPtr::value, p1_is_refcounted_type_and_needs_scoped_refptr); COMPILE_ASSERT(!cef_internal::HasIsMethodTag::value || !is_array::value, first_bound_argument_to_method_cannot_be_array); COMPILE_ASSERT(!cef_internal::NeedsScopedRefptrButGetsRawPtr::value, p2_is_refcounted_type_and_needs_scoped_refptr); COMPILE_ASSERT(!cef_internal::NeedsScopedRefptrButGetsRawPtr::value, p3_is_refcounted_type_and_needs_scoped_refptr); COMPILE_ASSERT(!cef_internal::NeedsScopedRefptrButGetsRawPtr::value, p4_is_refcounted_type_and_needs_scoped_refptr); typedef cef_internal::BindState::StorageType, typename cef_internal::CallbackParamTraits::StorageType, typename cef_internal::CallbackParamTraits::StorageType, typename cef_internal::CallbackParamTraits::StorageType)> BindState; return Callback( new BindState(cef_internal::MakeRunnable(functor), p1, p2, p3, p4)); } template base::Callback< typename cef_internal::BindState< typename cef_internal::FunctorTraits::RunnableType, typename cef_internal::FunctorTraits::RunType, void(typename cef_internal::CallbackParamTraits::StorageType, typename cef_internal::CallbackParamTraits::StorageType, typename cef_internal::CallbackParamTraits::StorageType, typename cef_internal::CallbackParamTraits::StorageType, typename cef_internal::CallbackParamTraits::StorageType)> ::UnboundRunType> Bind(Functor functor, const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5) { // Typedefs for how to store and run the functor. typedef typename cef_internal::FunctorTraits::RunnableType RunnableType; typedef typename cef_internal::FunctorTraits::RunType RunType; // Use RunnableType::RunType instead of RunType above because our // checks should below for bound references need to know what the actual // functor is going to interpret the argument as. typedef cef_internal::FunctionTraits BoundFunctorTraits; // Do not allow binding a non-const reference parameter. Non-const reference // parameters are disallowed by the Google style guide. Also, binding a // non-const reference parameter can make for subtle bugs because the // invoked function will receive a reference to the stored copy of the // argument and not the original. COMPILE_ASSERT( !(is_non_const_reference::value || is_non_const_reference::value || is_non_const_reference::value || is_non_const_reference::value || is_non_const_reference::value ), do_not_bind_functions_with_nonconst_ref); // For methods, we need to be careful for parameter 1. We do not require // a scoped_refptr because BindState<> itself takes care of AddRef() for // methods. We also disallow binding of an array as the method's target // object. COMPILE_ASSERT( cef_internal::HasIsMethodTag::value || !cef_internal::NeedsScopedRefptrButGetsRawPtr::value, p1_is_refcounted_type_and_needs_scoped_refptr); COMPILE_ASSERT(!cef_internal::HasIsMethodTag::value || !is_array::value, first_bound_argument_to_method_cannot_be_array); COMPILE_ASSERT(!cef_internal::NeedsScopedRefptrButGetsRawPtr::value, p2_is_refcounted_type_and_needs_scoped_refptr); COMPILE_ASSERT(!cef_internal::NeedsScopedRefptrButGetsRawPtr::value, p3_is_refcounted_type_and_needs_scoped_refptr); COMPILE_ASSERT(!cef_internal::NeedsScopedRefptrButGetsRawPtr::value, p4_is_refcounted_type_and_needs_scoped_refptr); COMPILE_ASSERT(!cef_internal::NeedsScopedRefptrButGetsRawPtr::value, p5_is_refcounted_type_and_needs_scoped_refptr); typedef cef_internal::BindState::StorageType, typename cef_internal::CallbackParamTraits::StorageType, typename cef_internal::CallbackParamTraits::StorageType, typename cef_internal::CallbackParamTraits::StorageType, typename cef_internal::CallbackParamTraits::StorageType)> BindState; return Callback( new BindState(cef_internal::MakeRunnable(functor), p1, p2, p3, p4, p5)); } template base::Callback< typename cef_internal::BindState< typename cef_internal::FunctorTraits::RunnableType, typename cef_internal::FunctorTraits::RunType, void(typename cef_internal::CallbackParamTraits::StorageType, typename cef_internal::CallbackParamTraits::StorageType, typename cef_internal::CallbackParamTraits::StorageType, typename cef_internal::CallbackParamTraits::StorageType, typename cef_internal::CallbackParamTraits::StorageType, typename cef_internal::CallbackParamTraits::StorageType)> ::UnboundRunType> Bind(Functor functor, const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5, const P6& p6) { // Typedefs for how to store and run the functor. typedef typename cef_internal::FunctorTraits::RunnableType RunnableType; typedef typename cef_internal::FunctorTraits::RunType RunType; // Use RunnableType::RunType instead of RunType above because our // checks should below for bound references need to know what the actual // functor is going to interpret the argument as. typedef cef_internal::FunctionTraits BoundFunctorTraits; // Do not allow binding a non-const reference parameter. Non-const reference // parameters are disallowed by the Google style guide. Also, binding a // non-const reference parameter can make for subtle bugs because the // invoked function will receive a reference to the stored copy of the // argument and not the original. COMPILE_ASSERT( !(is_non_const_reference::value || is_non_const_reference::value || is_non_const_reference::value || is_non_const_reference::value || is_non_const_reference::value || is_non_const_reference::value ), do_not_bind_functions_with_nonconst_ref); // For methods, we need to be careful for parameter 1. We do not require // a scoped_refptr because BindState<> itself takes care of AddRef() for // methods. We also disallow binding of an array as the method's target // object. COMPILE_ASSERT( cef_internal::HasIsMethodTag::value || !cef_internal::NeedsScopedRefptrButGetsRawPtr::value, p1_is_refcounted_type_and_needs_scoped_refptr); COMPILE_ASSERT(!cef_internal::HasIsMethodTag::value || !is_array::value, first_bound_argument_to_method_cannot_be_array); COMPILE_ASSERT(!cef_internal::NeedsScopedRefptrButGetsRawPtr::value, p2_is_refcounted_type_and_needs_scoped_refptr); COMPILE_ASSERT(!cef_internal::NeedsScopedRefptrButGetsRawPtr::value, p3_is_refcounted_type_and_needs_scoped_refptr); COMPILE_ASSERT(!cef_internal::NeedsScopedRefptrButGetsRawPtr::value, p4_is_refcounted_type_and_needs_scoped_refptr); COMPILE_ASSERT(!cef_internal::NeedsScopedRefptrButGetsRawPtr::value, p5_is_refcounted_type_and_needs_scoped_refptr); COMPILE_ASSERT(!cef_internal::NeedsScopedRefptrButGetsRawPtr::value, p6_is_refcounted_type_and_needs_scoped_refptr); typedef cef_internal::BindState::StorageType, typename cef_internal::CallbackParamTraits::StorageType, typename cef_internal::CallbackParamTraits::StorageType, typename cef_internal::CallbackParamTraits::StorageType, typename cef_internal::CallbackParamTraits::StorageType, typename cef_internal::CallbackParamTraits::StorageType)> BindState; return Callback( new BindState(cef_internal::MakeRunnable(functor), p1, p2, p3, p4, p5, p6)); } template base::Callback< typename cef_internal::BindState< typename cef_internal::FunctorTraits::RunnableType, typename cef_internal::FunctorTraits::RunType, void(typename cef_internal::CallbackParamTraits::StorageType, typename cef_internal::CallbackParamTraits::StorageType, typename cef_internal::CallbackParamTraits::StorageType, typename cef_internal::CallbackParamTraits::StorageType, typename cef_internal::CallbackParamTraits::StorageType, typename cef_internal::CallbackParamTraits::StorageType, typename cef_internal::CallbackParamTraits::StorageType)> ::UnboundRunType> Bind(Functor functor, const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5, const P6& p6, const P7& p7) { // Typedefs for how to store and run the functor. typedef typename cef_internal::FunctorTraits::RunnableType RunnableType; typedef typename cef_internal::FunctorTraits::RunType RunType; // Use RunnableType::RunType instead of RunType above because our // checks should below for bound references need to know what the actual // functor is going to interpret the argument as. typedef cef_internal::FunctionTraits BoundFunctorTraits; // Do not allow binding a non-const reference parameter. Non-const reference // parameters are disallowed by the Google style guide. Also, binding a // non-const reference parameter can make for subtle bugs because the // invoked function will receive a reference to the stored copy of the // argument and not the original. COMPILE_ASSERT( !(is_non_const_reference::value || is_non_const_reference::value || is_non_const_reference::value || is_non_const_reference::value || is_non_const_reference::value || is_non_const_reference::value || is_non_const_reference::value ), do_not_bind_functions_with_nonconst_ref); // For methods, we need to be careful for parameter 1. We do not require // a scoped_refptr because BindState<> itself takes care of AddRef() for // methods. We also disallow binding of an array as the method's target // object. COMPILE_ASSERT( cef_internal::HasIsMethodTag::value || !cef_internal::NeedsScopedRefptrButGetsRawPtr::value, p1_is_refcounted_type_and_needs_scoped_refptr); COMPILE_ASSERT(!cef_internal::HasIsMethodTag::value || !is_array::value, first_bound_argument_to_method_cannot_be_array); COMPILE_ASSERT(!cef_internal::NeedsScopedRefptrButGetsRawPtr::value, p2_is_refcounted_type_and_needs_scoped_refptr); COMPILE_ASSERT(!cef_internal::NeedsScopedRefptrButGetsRawPtr::value, p3_is_refcounted_type_and_needs_scoped_refptr); COMPILE_ASSERT(!cef_internal::NeedsScopedRefptrButGetsRawPtr::value, p4_is_refcounted_type_and_needs_scoped_refptr); COMPILE_ASSERT(!cef_internal::NeedsScopedRefptrButGetsRawPtr::value, p5_is_refcounted_type_and_needs_scoped_refptr); COMPILE_ASSERT(!cef_internal::NeedsScopedRefptrButGetsRawPtr::value, p6_is_refcounted_type_and_needs_scoped_refptr); COMPILE_ASSERT(!cef_internal::NeedsScopedRefptrButGetsRawPtr::value, p7_is_refcounted_type_and_needs_scoped_refptr); typedef cef_internal::BindState::StorageType, typename cef_internal::CallbackParamTraits::StorageType, typename cef_internal::CallbackParamTraits::StorageType, typename cef_internal::CallbackParamTraits::StorageType, typename cef_internal::CallbackParamTraits::StorageType, typename cef_internal::CallbackParamTraits::StorageType, typename cef_internal::CallbackParamTraits::StorageType)> BindState; return Callback( new BindState(cef_internal::MakeRunnable(functor), p1, p2, p3, p4, p5, p6, p7)); } } // namespace base #endif // !BUILDING_CEF_SHARED #endif // CEF_INCLUDE_BASE_CEF_BIND_H_ cefpython-49.0/src/include/base/cef_bind_helpers.h000066400000000000000000000464561334103266300222350ustar00rootroot00000000000000// Copyright (c) 2014 Marshall A. Greenblatt. Portions copyright (c) 2011 // Google Inc. 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 defines a set of argument wrappers and related factory methods that // can be used specify the refcounting and reference semantics of arguments // that are bound by the Bind() function in base/bind.h. // // It also defines a set of simple functions and utilities that people want // when using Callback<> and Bind(). // // // ARGUMENT BINDING WRAPPERS // // The wrapper functions are base::Unretained(), base::Owned(), base::Passed(), // base::ConstRef(), and base::IgnoreResult(). // // Unretained() allows Bind() to bind a non-refcounted class, and to disable // refcounting on arguments that are refcounted objects. // // Owned() transfers ownership of an object to the Callback resulting from // bind; the object will be deleted when the Callback is deleted. // // Passed() is for transferring movable-but-not-copyable types (eg. scoped_ptr) // through a Callback. Logically, this signifies a destructive transfer of // the state of the argument into the target function. Invoking // Callback::Run() twice on a Callback that was created with a Passed() // argument will CHECK() because the first invocation would have already // transferred ownership to the target function. // // ConstRef() allows binding a constant reference to an argument rather // than a copy. // // IgnoreResult() is used to adapt a function or Callback with a return type to // one with a void return. This is most useful if you have a function with, // say, a pesky ignorable bool return that you want to use with PostTask or // something else that expect a Callback with a void return. // // EXAMPLE OF Unretained(): // // class Foo { // public: // void func() { cout << "Foo:f" << endl; } // }; // // // In some function somewhere. // Foo foo; // Closure foo_callback = // Bind(&Foo::func, Unretained(&foo)); // foo_callback.Run(); // Prints "Foo:f". // // Without the Unretained() wrapper on |&foo|, the above call would fail // to compile because Foo does not support the AddRef() and Release() methods. // // // EXAMPLE OF Owned(): // // void foo(int* arg) { cout << *arg << endl } // // int* pn = new int(1); // Closure foo_callback = Bind(&foo, Owned(pn)); // // foo_callback.Run(); // Prints "1" // foo_callback.Run(); // Prints "1" // *n = 2; // foo_callback.Run(); // Prints "2" // // foo_callback.Reset(); // |pn| is deleted. Also will happen when // // |foo_callback| goes out of scope. // // Without Owned(), someone would have to know to delete |pn| when the last // reference to the Callback is deleted. // // // EXAMPLE OF ConstRef(): // // void foo(int arg) { cout << arg << endl } // // int n = 1; // Closure no_ref = Bind(&foo, n); // Closure has_ref = Bind(&foo, ConstRef(n)); // // no_ref.Run(); // Prints "1" // has_ref.Run(); // Prints "1" // // n = 2; // no_ref.Run(); // Prints "1" // has_ref.Run(); // Prints "2" // // Note that because ConstRef() takes a reference on |n|, |n| must outlive all // its bound callbacks. // // // EXAMPLE OF IgnoreResult(): // // int DoSomething(int arg) { cout << arg << endl; } // // // Assign to a Callback with a void return type. // Callback cb = Bind(IgnoreResult(&DoSomething)); // cb->Run(1); // Prints "1". // // // Prints "1" on |ml|. // ml->PostTask(FROM_HERE, Bind(IgnoreResult(&DoSomething), 1); // // // EXAMPLE OF Passed(): // // void TakesOwnership(scoped_ptr arg) { } // scoped_ptr CreateFoo() { return scoped_ptr(new Foo()); } // // scoped_ptr f(new Foo()); // // // |cb| is given ownership of Foo(). |f| is now NULL. // // You can use f.Pass() in place of &f, but it's more verbose. // Closure cb = Bind(&TakesOwnership, Passed(&f)); // // // Run was never called so |cb| still owns Foo() and deletes // // it on Reset(). // cb.Reset(); // // // |cb| is given a new Foo created by CreateFoo(). // cb = Bind(&TakesOwnership, Passed(CreateFoo())); // // // |arg| in TakesOwnership() is given ownership of Foo(). |cb| // // no longer owns Foo() and, if reset, would not delete Foo(). // cb.Run(); // Foo() is now transferred to |arg| and deleted. // cb.Run(); // This CHECK()s since Foo() already been used once. // // Passed() is particularly useful with PostTask() when you are transferring // ownership of an argument into a task, but don't necessarily know if the // task will always be executed. This can happen if the task is cancellable // or if it is posted to a MessageLoopProxy. // // // SIMPLE FUNCTIONS AND UTILITIES. // // DoNothing() - Useful for creating a Closure that does nothing when called. // DeletePointer() - Useful for creating a Closure that will delete a // pointer when invoked. Only use this when necessary. // In most cases MessageLoop::DeleteSoon() is a better // fit. #ifndef CEF_INCLUDE_BASE_CEF_BIND_HELPERS_H_ #define CEF_INCLUDE_BASE_CEF_BIND_HELPERS_H_ #pragma once #if defined(BASE_BIND_HELPERS_H_) // Do nothing if the Chromium header has already been included. // This can happen in cases where Chromium code is used directly by the // client application. When using Chromium code directly always include // the Chromium header first to avoid type conflicts. #elif defined(BUILDING_CEF_SHARED) // When building CEF include the Chromium header directly. #include "base/bind_helpers.h" #else // !BUILDING_CEF_SHARED // The following is substantially similar to the Chromium implementation. // If the Chromium implementation diverges the below implementation should be // updated to match. #include "include/base/cef_basictypes.h" #include "include/base/cef_callback.h" #include "include/base/cef_template_util.h" #include "include/base/cef_weak_ptr.h" namespace base { namespace cef_internal { // Use the Substitution Failure Is Not An Error (SFINAE) trick to inspect T // for the existence of AddRef() and Release() functions of the correct // signature. // // http://en.wikipedia.org/wiki/Substitution_failure_is_not_an_error // http://stackoverflow.com/questions/257288/is-it-possible-to-write-a-c-template-to-check-for-a-functions-existence // http://stackoverflow.com/questions/4358584/sfinae-approach-comparison // http://stackoverflow.com/questions/1966362/sfinae-to-check-for-inherited-member-functions // // The last link in particular show the method used below. // // For SFINAE to work with inherited methods, we need to pull some extra tricks // with multiple inheritance. In the more standard formulation, the overloads // of Check would be: // // template // Yes NotTheCheckWeWant(Helper<&C::TargetFunc>*); // // template // No NotTheCheckWeWant(...); // // static const bool value = sizeof(NotTheCheckWeWant(0)) == sizeof(Yes); // // The problem here is that template resolution will not match // C::TargetFunc if TargetFunc does not exist directly in C. That is, if // TargetFunc in inherited from an ancestor, &C::TargetFunc will not match, // |value| will be false. This formulation only checks for whether or // not TargetFunc exist directly in the class being introspected. // // To get around this, we play a dirty trick with multiple inheritance. // First, We create a class BaseMixin that declares each function that we // want to probe for. Then we create a class Base that inherits from both T // (the class we wish to probe) and BaseMixin. Note that the function // signature in BaseMixin does not need to match the signature of the function // we are probing for; thus it's easiest to just use void(void). // // Now, if TargetFunc exists somewhere in T, then &Base::TargetFunc has an // ambiguous resolution between BaseMixin and T. This lets us write the // following: // // template // No GoodCheck(Helper<&C::TargetFunc>*); // // template // Yes GoodCheck(...); // // static const bool value = sizeof(GoodCheck(0)) == sizeof(Yes); // // Notice here that the variadic version of GoodCheck() returns Yes here // instead of No like the previous one. Also notice that we calculate |value| // by specializing GoodCheck() on Base instead of T. // // We've reversed the roles of the variadic, and Helper overloads. // GoodCheck(Helper<&C::TargetFunc>*), when C = Base, fails to be a valid // substitution if T::TargetFunc exists. Thus GoodCheck(0) will resolve // to the variadic version if T has TargetFunc. If T::TargetFunc does not // exist, then &C::TargetFunc is not ambiguous, and the overload resolution // will prefer GoodCheck(Helper<&C::TargetFunc>*). // // This method of SFINAE will correctly probe for inherited names, but it cannot // typecheck those names. It's still a good enough sanity check though. // // Works on gcc-4.2, gcc-4.4, and Visual Studio 2008. // // TODO(ajwong): Move to ref_counted.h or template_util.h when we've vetted // this works well. // // TODO(ajwong): Make this check for Release() as well. // See http://crbug.com/82038. template class SupportsAddRefAndRelease { typedef char Yes[1]; typedef char No[2]; struct BaseMixin { void AddRef(); }; // MSVC warns when you try to use Base if T has a private destructor, the // common pattern for refcounted types. It does this even though no attempt to // instantiate Base is made. We disable the warning for this definition. #if defined(OS_WIN) #pragma warning(push) #pragma warning(disable:4624) #endif struct Base : public T, public BaseMixin { }; #if defined(OS_WIN) #pragma warning(pop) #endif template struct Helper {}; template static No& Check(Helper<&C::AddRef>*); template static Yes& Check(...); public: static const bool value = sizeof(Check(0)) == sizeof(Yes); }; // Helpers to assert that arguments of a recounted type are bound with a // scoped_refptr. template struct UnsafeBindtoRefCountedArgHelper : false_type { }; template struct UnsafeBindtoRefCountedArgHelper : integral_constant::value> { }; template struct UnsafeBindtoRefCountedArg : false_type { }; template struct UnsafeBindtoRefCountedArg : UnsafeBindtoRefCountedArgHelper::value, T> { }; template class HasIsMethodTag { typedef char Yes[1]; typedef char No[2]; template static Yes& Check(typename U::IsMethod*); template static No& Check(...); public: static const bool value = sizeof(Check(0)) == sizeof(Yes); }; template class UnretainedWrapper { public: explicit UnretainedWrapper(T* o) : ptr_(o) {} T* get() const { return ptr_; } private: T* ptr_; }; template class ConstRefWrapper { public: explicit ConstRefWrapper(const T& o) : ptr_(&o) {} const T& get() const { return *ptr_; } private: const T* ptr_; }; template struct IgnoreResultHelper { explicit IgnoreResultHelper(T functor) : functor_(functor) {} T functor_; }; template struct IgnoreResultHelper > { explicit IgnoreResultHelper(const Callback& functor) : functor_(functor) {} const Callback& functor_; }; // An alternate implementation is to avoid the destructive copy, and instead // specialize ParamTraits<> for OwnedWrapper<> to change the StorageType to // a class that is essentially a scoped_ptr<>. // // The current implementation has the benefit though of leaving ParamTraits<> // fully in callback_internal.h as well as avoiding type conversions during // storage. template class OwnedWrapper { public: explicit OwnedWrapper(T* o) : ptr_(o) {} ~OwnedWrapper() { delete ptr_; } T* get() const { return ptr_; } OwnedWrapper(const OwnedWrapper& other) { ptr_ = other.ptr_; other.ptr_ = NULL; } private: mutable T* ptr_; }; // PassedWrapper is a copyable adapter for a scoper that ignores const. // // It is needed to get around the fact that Bind() takes a const reference to // all its arguments. Because Bind() takes a const reference to avoid // unnecessary copies, it is incompatible with movable-but-not-copyable // types; doing a destructive "move" of the type into Bind() would violate // the const correctness. // // This conundrum cannot be solved without either C++11 rvalue references or // a O(2^n) blowup of Bind() templates to handle each combination of regular // types and movable-but-not-copyable types. Thus we introduce a wrapper type // that is copyable to transmit the correct type information down into // BindState<>. Ignoring const in this type makes sense because it is only // created when we are explicitly trying to do a destructive move. // // Two notes: // 1) PassedWrapper supports any type that has a "Pass()" function. // This is intentional. The whitelisting of which specific types we // support is maintained by CallbackParamTraits<>. // 2) is_valid_ is distinct from NULL because it is valid to bind a "NULL" // scoper to a Callback and allow the Callback to execute once. template class PassedWrapper { public: explicit PassedWrapper(T scoper) : is_valid_(true), scoper_(scoper.Pass()) {} PassedWrapper(const PassedWrapper& other) : is_valid_(other.is_valid_), scoper_(other.scoper_.Pass()) { } T Pass() const { CHECK(is_valid_); is_valid_ = false; return scoper_.Pass(); } private: mutable bool is_valid_; mutable T scoper_; }; // Unwrap the stored parameters for the wrappers above. template struct UnwrapTraits { typedef const T& ForwardType; static ForwardType Unwrap(const T& o) { return o; } }; template struct UnwrapTraits > { typedef T* ForwardType; static ForwardType Unwrap(UnretainedWrapper unretained) { return unretained.get(); } }; template struct UnwrapTraits > { typedef const T& ForwardType; static ForwardType Unwrap(ConstRefWrapper const_ref) { return const_ref.get(); } }; template struct UnwrapTraits > { typedef T* ForwardType; static ForwardType Unwrap(const scoped_refptr& o) { return o.get(); } }; template struct UnwrapTraits > { typedef const WeakPtr& ForwardType; static ForwardType Unwrap(const WeakPtr& o) { return o; } }; template struct UnwrapTraits > { typedef T* ForwardType; static ForwardType Unwrap(const OwnedWrapper& o) { return o.get(); } }; template struct UnwrapTraits > { typedef T ForwardType; static T Unwrap(PassedWrapper& o) { return o.Pass(); } }; // Utility for handling different refcounting semantics in the Bind() // function. template struct MaybeRefcount; template struct MaybeRefcount { static void AddRef(const T&) {} static void Release(const T&) {} }; template struct MaybeRefcount { static void AddRef(const T*) {} static void Release(const T*) {} }; template struct MaybeRefcount { static void AddRef(const T&) {} static void Release(const T&) {} }; template struct MaybeRefcount { static void AddRef(T* o) { o->AddRef(); } static void Release(T* o) { o->Release(); } }; // No need to additionally AddRef() and Release() since we are storing a // scoped_refptr<> inside the storage object already. template struct MaybeRefcount > { static void AddRef(const scoped_refptr& o) {} static void Release(const scoped_refptr& o) {} }; template struct MaybeRefcount { static void AddRef(const T* o) { o->AddRef(); } static void Release(const T* o) { o->Release(); } }; // IsWeakMethod is a helper that determine if we are binding a WeakPtr<> to a // method. It is used internally by Bind() to select the correct // InvokeHelper that will no-op itself in the event the WeakPtr<> for // the target object is invalidated. // // P1 should be the type of the object that will be received of the method. template struct IsWeakMethod : public false_type {}; template struct IsWeakMethod > : public true_type {}; template struct IsWeakMethod > > : public true_type {}; } // namespace cef_internal template static inline cef_internal::UnretainedWrapper Unretained(T* o) { return cef_internal::UnretainedWrapper(o); } template static inline cef_internal::ConstRefWrapper ConstRef(const T& o) { return cef_internal::ConstRefWrapper(o); } template static inline cef_internal::OwnedWrapper Owned(T* o) { return cef_internal::OwnedWrapper(o); } // We offer 2 syntaxes for calling Passed(). The first takes a temporary and // is best suited for use with the return value of a function. The second // takes a pointer to the scoper and is just syntactic sugar to avoid having // to write Passed(scoper.Pass()). template static inline cef_internal::PassedWrapper Passed(T scoper) { return cef_internal::PassedWrapper(scoper.Pass()); } template static inline cef_internal::PassedWrapper Passed(T* scoper) { return cef_internal::PassedWrapper(scoper->Pass()); } template static inline cef_internal::IgnoreResultHelper IgnoreResult(T data) { return cef_internal::IgnoreResultHelper(data); } template static inline cef_internal::IgnoreResultHelper > IgnoreResult(const Callback& data) { return cef_internal::IgnoreResultHelper >(data); } void DoNothing(); template void DeletePointer(T* obj) { delete obj; } } // namespace base #endif // !BUILDING_CEF_SHARED #endif // CEF_INCLUDE_BASE_CEF_BIND_HELPERS_H_ cefpython-49.0/src/include/base/cef_build.h000066400000000000000000000146051334103266300206650ustar00rootroot00000000000000// 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_BASE_CEF_BUILD_H_ #define CEF_INCLUDE_BASE_CEF_BUILD_H_ #pragma once #if defined(BUILDING_CEF_SHARED) // When building CEF include the Chromium header directly. #include "base/compiler_specific.h" #else // !BUILDING_CEF_SHARED // The following is substantially similar to the Chromium implementation. // If the Chromium implementation diverges the below implementation should be // updated to match. #if defined(_WIN32) #ifndef OS_WIN #define OS_WIN 1 #endif #elif defined(__APPLE__) #ifndef OS_MACOSX #define OS_MACOSX 1 #endif #elif defined(__linux__) #ifndef OS_LINUX #define OS_LINUX 1 #endif #else #error Please add support for your platform in cef_build.h #endif // For access to standard POSIXish features, use OS_POSIX instead of a // more specific macro. #if defined(OS_MACOSX) || defined(OS_LINUX) #ifndef OS_POSIX #define OS_POSIX 1 #endif #endif // Compiler detection. #if defined(__GNUC__) #ifndef COMPILER_GCC #define COMPILER_GCC 1 #endif #elif defined(_MSC_VER) #ifndef COMPILER_MSVC #define COMPILER_MSVC 1 #endif #else #error Please add support for your compiler in cef_build.h #endif // Processor architecture detection. For more info on what's defined, see: // http://msdn.microsoft.com/en-us/library/b0084kay.aspx // http://www.agner.org/optimize/calling_conventions.pdf // or with gcc, run: "echo | gcc -E -dM -" #if defined(_M_X64) || defined(__x86_64__) #define ARCH_CPU_X86_FAMILY 1 #define ARCH_CPU_X86_64 1 #define ARCH_CPU_64_BITS 1 #define ARCH_CPU_LITTLE_ENDIAN 1 #elif defined(_M_IX86) || defined(__i386__) #define ARCH_CPU_X86_FAMILY 1 #define ARCH_CPU_X86 1 #define ARCH_CPU_32_BITS 1 #define ARCH_CPU_LITTLE_ENDIAN 1 #elif defined(__ARMEL__) #define ARCH_CPU_ARM_FAMILY 1 #define ARCH_CPU_ARMEL 1 #define ARCH_CPU_32_BITS 1 #define ARCH_CPU_LITTLE_ENDIAN 1 #elif defined(__aarch64__) #define ARCH_CPU_ARM_FAMILY 1 #define ARCH_CPU_ARM64 1 #define ARCH_CPU_64_BITS 1 #define ARCH_CPU_LITTLE_ENDIAN 1 #elif defined(__pnacl__) #define ARCH_CPU_32_BITS 1 #define ARCH_CPU_LITTLE_ENDIAN 1 #elif defined(__MIPSEL__) #define ARCH_CPU_MIPS_FAMILY 1 #define ARCH_CPU_MIPSEL 1 #define ARCH_CPU_32_BITS 1 #define ARCH_CPU_LITTLE_ENDIAN 1 #else #error Please add support for your architecture in cef_build.h #endif // Type detection for wchar_t. #if defined(OS_WIN) #define WCHAR_T_IS_UTF16 #elif defined(OS_POSIX) && defined(COMPILER_GCC) && \ defined(__WCHAR_MAX__) && \ (__WCHAR_MAX__ == 0x7fffffff || __WCHAR_MAX__ == 0xffffffff) #define WCHAR_T_IS_UTF32 #elif defined(OS_POSIX) && defined(COMPILER_GCC) && \ defined(__WCHAR_MAX__) && \ (__WCHAR_MAX__ == 0x7fff || __WCHAR_MAX__ == 0xffff) // On Posix, we'll detect short wchar_t, but projects aren't guaranteed to // compile in this mode (in particular, Chrome doesn't). This is intended for // other projects using base who manage their own dependencies and make sure // short wchar works for them. #define WCHAR_T_IS_UTF16 #else #error Please add support for your compiler in cef_build.h #endif // Annotate a function indicating the caller must examine the return value. // Use like: // int foo() WARN_UNUSED_RESULT; // To explicitly ignore a result, see |ignore_result()| in . #ifndef WARN_UNUSED_RESULT #if defined(COMPILER_GCC) #define WARN_UNUSED_RESULT __attribute__((warn_unused_result)) #else #define WARN_UNUSED_RESULT #endif #endif // WARN_UNUSED_RESULT // Annotate a typedef or function indicating it's ok if it's not used. // Use like: // typedef Foo Bar ALLOW_UNUSED_TYPE; #ifndef ALLOW_UNUSED_TYPE #if defined(COMPILER_GCC) #define ALLOW_UNUSED_TYPE __attribute__((unused)) #else #define ALLOW_UNUSED_TYPE #endif #endif // ALLOW_UNUSED_TYPE // Annotate a variable indicating it's ok if the variable is not used. // (Typically used to silence a compiler warning when the assignment // is important for some other reason.) // Use like: // int x = ...; // ALLOW_UNUSED_LOCAL(x); #ifndef ALLOW_UNUSED_LOCAL #define ALLOW_UNUSED_LOCAL(x) false ? (void)x : (void)0 #endif #endif // !BUILDING_CEF_SHARED // Annotate a virtual method indicating it must be overriding a virtual method // in the parent class. // Use like: // void foo() OVERRIDE; // NOTE: This define should only be used in classes exposed to the client since // C++11 support may not be enabled in client applications. CEF internal classes // should use the `override` keyword directly. #ifndef OVERRIDE #if defined(__clang__) #define OVERRIDE override #elif defined(COMPILER_MSVC) && _MSC_VER >= 1600 // Visual Studio 2010 and later support override. #define OVERRIDE override #elif defined(COMPILER_GCC) && __cplusplus >= 201103 && \ (__GNUC__ * 10000 + __GNUC_MINOR__ * 100) >= 40700 // GCC 4.7 supports explicit virtual overrides when C++11 support is enabled. #define OVERRIDE override #else #define OVERRIDE #endif #endif // OVERRIDE #endif // CEF_INCLUDE_BASE_CEF_BUILD_H_ cefpython-49.0/src/include/base/cef_callback.h000066400000000000000000001010741334103266300213170ustar00rootroot00000000000000// Copyright (c) 2014 Marshall A. Greenblatt. Portions copyright (c) 2012 // Google Inc. 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_BASE_CEF_CALLBACK_H_ #define CEF_INCLUDE_BASE_CEF_CALLBACK_H_ #pragma once #if defined(BASE_CALLBACK_H_) // Do nothing if the Chromium header has already been included. // This can happen in cases where Chromium code is used directly by the // client application. When using Chromium code directly always include // the Chromium header first to avoid type conflicts. #elif defined(BUILDING_CEF_SHARED) // When building CEF include the Chromium header directly. #include "base/callback.h" #else // !BUILDING_CEF_SHARED // The following is substantially similar to the Chromium implementation. // If the Chromium implementation diverges the below implementation should be // updated to match. #include "include/base/internal/cef_callback_internal.h" #include "include/base/cef_callback_forward.h" #include "include/base/cef_template_util.h" // NOTE: Header files that do not require the full definition of Callback or // Closure should #include "base/cef_callback_forward.h" instead of this file. // ----------------------------------------------------------------------------- // Introduction // ----------------------------------------------------------------------------- // // The templated Callback class is a generalized function object. Together // with the Bind() function in bind.h, they provide a type-safe method for // performing partial application of functions. // // Partial application (or "currying") is the process of binding a subset of // a function's arguments to produce another function that takes fewer // arguments. This can be used to pass around a unit of delayed execution, // much like lexical closures are used in other languages. For example, it // is used in Chromium code to schedule tasks on different MessageLoops. // // A callback with no unbound input parameters (base::Callback) // is called a base::Closure. Note that this is NOT the same as what other // languages refer to as a closure -- it does not retain a reference to its // enclosing environment. // // MEMORY MANAGEMENT AND PASSING // // The Callback objects themselves should be passed by const-reference, and // stored by copy. They internally store their state via a refcounted class // and thus do not need to be deleted. // // The reason to pass via a const-reference is to avoid unnecessary // AddRef/Release pairs to the internal state. // // // ----------------------------------------------------------------------------- // Quick reference for basic stuff // ----------------------------------------------------------------------------- // // BINDING A BARE FUNCTION // // int Return5() { return 5; } // base::Callback func_cb = base::Bind(&Return5); // LOG(INFO) << func_cb.Run(); // Prints 5. // // BINDING A CLASS METHOD // // The first argument to bind is the member function to call, the second is // the object on which to call it. // // class Ref : public base::RefCountedThreadSafe { // public: // int Foo() { return 3; } // void PrintBye() { LOG(INFO) << "bye."; } // }; // scoped_refptr ref = new Ref(); // base::Callback ref_cb = base::Bind(&Ref::Foo, ref); // LOG(INFO) << ref_cb.Run(); // Prints out 3. // // By default the object must support RefCounted or you will get a compiler // error. If you're passing between threads, be sure it's // RefCountedThreadSafe! See "Advanced binding of member functions" below if // you don't want to use reference counting. // // RUNNING A CALLBACK // // Callbacks can be run with their "Run" method, which has the same // signature as the template argument to the callback. // // void DoSomething(const base::Callback& callback) { // callback.Run(5, "hello"); // } // // Callbacks can be run more than once (they don't get deleted or marked when // run). However, this precludes using base::Passed (see below). // // void DoSomething(const base::Callback& callback) { // double myresult = callback.Run(3.14159); // myresult += callback.Run(2.71828); // } // // PASSING UNBOUND INPUT PARAMETERS // // Unbound parameters are specified at the time a callback is Run(). They are // specified in the Callback template type: // // void MyFunc(int i, const std::string& str) {} // base::Callback cb = base::Bind(&MyFunc); // cb.Run(23, "hello, world"); // // PASSING BOUND INPUT PARAMETERS // // Bound parameters are specified when you create thee callback as arguments // to Bind(). They will be passed to the function and the Run()ner of the // callback doesn't see those values or even know that the function it's // calling. // // void MyFunc(int i, const std::string& str) {} // base::Callback cb = base::Bind(&MyFunc, 23, "hello world"); // cb.Run(); // // A callback with no unbound input parameters (base::Callback) // is called a base::Closure. So we could have also written: // // base::Closure cb = base::Bind(&MyFunc, 23, "hello world"); // // When calling member functions, bound parameters just go after the object // pointer. // // base::Closure cb = base::Bind(&MyClass::MyFunc, this, 23, "hello world"); // // PARTIAL BINDING OF PARAMETERS // // You can specify some parameters when you create the callback, and specify // the rest when you execute the callback. // // void MyFunc(int i, const std::string& str) {} // base::Callback cb = base::Bind(&MyFunc, 23); // cb.Run("hello world"); // // When calling a function bound parameters are first, followed by unbound // parameters. // // // ----------------------------------------------------------------------------- // Quick reference for advanced binding // ----------------------------------------------------------------------------- // // BINDING A CLASS METHOD WITH WEAK POINTERS // // base::Bind(&MyClass::Foo, GetWeakPtr()); // // The callback will not be run if the object has already been destroyed. // DANGER: weak pointers are not threadsafe, so don't use this // when passing between threads! // // BINDING A CLASS METHOD WITH MANUAL LIFETIME MANAGEMENT // // base::Bind(&MyClass::Foo, base::Unretained(this)); // // This disables all lifetime management on the object. You're responsible // for making sure the object is alive at the time of the call. You break it, // you own it! // // BINDING A CLASS METHOD AND HAVING THE CALLBACK OWN THE CLASS // // MyClass* myclass = new MyClass; // base::Bind(&MyClass::Foo, base::Owned(myclass)); // // The object will be deleted when the callback is destroyed, even if it's // not run (like if you post a task during shutdown). Potentially useful for // "fire and forget" cases. // // IGNORING RETURN VALUES // // Sometimes you want to call a function that returns a value in a callback // that doesn't expect a return value. // // int DoSomething(int arg) { cout << arg << endl; } // base::Callback) cb = // base::Bind(base::IgnoreResult(&DoSomething)); // // // ----------------------------------------------------------------------------- // Quick reference for binding parameters to Bind() // ----------------------------------------------------------------------------- // // Bound parameters are specified as arguments to Bind() and are passed to the // function. A callback with no parameters or no unbound parameters is called a // Closure (base::Callback and base::Closure are the same thing). // // PASSING PARAMETERS OWNED BY THE CALLBACK // // void Foo(int* arg) { cout << *arg << endl; } // int* pn = new int(1); // base::Closure foo_callback = base::Bind(&foo, base::Owned(pn)); // // The parameter will be deleted when the callback is destroyed, even if it's // not run (like if you post a task during shutdown). // // PASSING PARAMETERS AS A scoped_ptr // // void TakesOwnership(scoped_ptr arg) {} // scoped_ptr f(new Foo); // // f becomes null during the following call. // base::Closure cb = base::Bind(&TakesOwnership, base::Passed(&f)); // // Ownership of the parameter will be with the callback until the it is run, // when ownership is passed to the callback function. This means the callback // can only be run once. If the callback is never run, it will delete the // object when it's destroyed. // // PASSING PARAMETERS AS A scoped_refptr // // void TakesOneRef(scoped_refptr arg) {} // scoped_refptr f(new Foo) // base::Closure cb = base::Bind(&TakesOneRef, f); // // This should "just work." The closure will take a reference as long as it // is alive, and another reference will be taken for the called function. // // PASSING PARAMETERS BY REFERENCE // // Const references are *copied* unless ConstRef is used. Example: // // void foo(const int& arg) { printf("%d %p\n", arg, &arg); } // int n = 1; // base::Closure has_copy = base::Bind(&foo, n); // base::Closure has_ref = base::Bind(&foo, base::ConstRef(n)); // n = 2; // foo(n); // Prints "2 0xaaaaaaaaaaaa" // has_copy.Run(); // Prints "1 0xbbbbbbbbbbbb" // has_ref.Run(); // Prints "2 0xaaaaaaaaaaaa" // // Normally parameters are copied in the closure. DANGER: ConstRef stores a // const reference instead, referencing the original parameter. This means // that you must ensure the object outlives the callback! // // // ----------------------------------------------------------------------------- // Implementation notes // ----------------------------------------------------------------------------- // // WHERE IS THIS DESIGN FROM: // // The design Callback and Bind is heavily influenced by C++'s // tr1::function/tr1::bind, and by the "Google Callback" system used inside // Google. // // // HOW THE IMPLEMENTATION WORKS: // // There are three main components to the system: // 1) The Callback classes. // 2) The Bind() functions. // 3) The arguments wrappers (e.g., Unretained() and ConstRef()). // // The Callback classes represent a generic function pointer. Internally, // it stores a refcounted piece of state that represents the target function // and all its bound parameters. Each Callback specialization has a templated // constructor that takes an BindState<>*. In the context of the constructor, // the static type of this BindState<> pointer uniquely identifies the // function it is representing, all its bound parameters, and a Run() method // that is capable of invoking the target. // // Callback's constructor takes the BindState<>* that has the full static type // and erases the target function type as well as the types of the bound // parameters. It does this by storing a pointer to the specific Run() // function, and upcasting the state of BindState<>* to a // BindStateBase*. This is safe as long as this BindStateBase pointer // is only used with the stored Run() pointer. // // To BindState<> objects are created inside the Bind() functions. // These functions, along with a set of internal templates, are responsible for // // - Unwrapping the function signature into return type, and parameters // - Determining the number of parameters that are bound // - Creating the BindState storing the bound parameters // - Performing compile-time asserts to avoid error-prone behavior // - Returning an Callback<> with an arity matching the number of unbound // parameters and that knows the correct refcounting semantics for the // target object if we are binding a method. // // The Bind functions do the above using type-inference, and template // specializations. // // By default Bind() will store copies of all bound parameters, and attempt // to refcount a target object if the function being bound is a class method. // These copies are created even if the function takes parameters as const // references. (Binding to non-const references is forbidden, see bind.h.) // // To change this behavior, we introduce a set of argument wrappers // (e.g., Unretained(), and ConstRef()). These are simple container templates // that are passed by value, and wrap a pointer to argument. See the // file-level comment in base/bind_helpers.h for more info. // // These types are passed to the Unwrap() functions, and the MaybeRefcount() // functions respectively to modify the behavior of Bind(). The Unwrap() // and MaybeRefcount() functions change behavior by doing partial // specialization based on whether or not a parameter is a wrapper type. // // ConstRef() is similar to tr1::cref. Unretained() is specific to Chromium. // // // WHY NOT TR1 FUNCTION/BIND? // // Direct use of tr1::function and tr1::bind was considered, but ultimately // rejected because of the number of copy constructors invocations involved // in the binding of arguments during construction, and the forwarding of // arguments during invocation. These copies will no longer be an issue in // C++0x because C++0x will support rvalue reference allowing for the compiler // to avoid these copies. However, waiting for C++0x is not an option. // // Measured with valgrind on gcc version 4.4.3 (Ubuntu 4.4.3-4ubuntu5), the // tr1::bind call itself will invoke a non-trivial copy constructor three times // for each bound parameter. Also, each when passing a tr1::function, each // bound argument will be copied again. // // In addition to the copies taken at binding and invocation, copying a // tr1::function causes a copy to be made of all the bound parameters and // state. // // Furthermore, in Chromium, it is desirable for the Callback to take a // reference on a target object when representing a class method call. This // is not supported by tr1. // // Lastly, tr1::function and tr1::bind has a more general and flexible API. // This includes things like argument reordering by use of // tr1::bind::placeholder, support for non-const reference parameters, and some // limited amount of subtyping of the tr1::function object (e.g., // tr1::function is convertible to tr1::function). // // These are not features that are required in Chromium. Some of them, such as // allowing for reference parameters, and subtyping of functions, may actually // become a source of errors. Removing support for these features actually // allows for a simpler implementation, and a terser Currying API. // // // WHY NOT GOOGLE CALLBACKS? // // The Google callback system also does not support refcounting. Furthermore, // its implementation has a number of strange edge cases with respect to type // conversion of its arguments. In particular, the argument's constness must // at times match exactly the function signature, or the type-inference might // break. Given the above, writing a custom solution was easier. // // // MISSING FUNCTIONALITY // - Invoking the return of Bind. Bind(&foo).Run() does not work; // - Binding arrays to functions that take a non-const pointer. // Example: // void Foo(const char* ptr); // void Bar(char* ptr); // Bind(&Foo, "test"); // Bind(&Bar, "test"); // This fails because ptr is not const. namespace base { // First, we forward declare the Callback class template. This informs the // compiler that the template only has 1 type parameter which is the function // signature that the Callback is representing. // // After this, create template specializations for 0-7 parameters. Note that // even though the template typelist grows, the specialization still // only has one type: the function signature. // // If you are thinking of forward declaring Callback in your own header file, // please include "base/callback_forward.h" instead. template class Callback; namespace cef_internal { template struct BindState; } // namespace cef_internal template class Callback : public cef_internal::CallbackBase { public: typedef R(RunType)(); Callback() : CallbackBase(NULL) { } // Note that this constructor CANNOT be explicit, and that Bind() CANNOT // return the exact Callback<> type. See base/bind.h for details. template Callback(cef_internal::BindState* bind_state) : CallbackBase(bind_state) { // Force the assignment to a local variable of PolymorphicInvoke // so the compiler will typecheck that the passed in Run() method has // the correct type. PolymorphicInvoke invoke_func = &cef_internal::BindState ::InvokerType::Run; polymorphic_invoke_ = reinterpret_cast(invoke_func); } bool Equals(const Callback& other) const { return CallbackBase::Equals(other); } R Run() const { PolymorphicInvoke f = reinterpret_cast(polymorphic_invoke_); return f(bind_state_.get()); } private: typedef R(*PolymorphicInvoke)( cef_internal::BindStateBase*); }; template class Callback : public cef_internal::CallbackBase { public: typedef R(RunType)(A1); Callback() : CallbackBase(NULL) { } // Note that this constructor CANNOT be explicit, and that Bind() CANNOT // return the exact Callback<> type. See base/bind.h for details. template Callback(cef_internal::BindState* bind_state) : CallbackBase(bind_state) { // Force the assignment to a local variable of PolymorphicInvoke // so the compiler will typecheck that the passed in Run() method has // the correct type. PolymorphicInvoke invoke_func = &cef_internal::BindState ::InvokerType::Run; polymorphic_invoke_ = reinterpret_cast(invoke_func); } bool Equals(const Callback& other) const { return CallbackBase::Equals(other); } R Run(typename cef_internal::CallbackParamTraits::ForwardType a1) const { PolymorphicInvoke f = reinterpret_cast(polymorphic_invoke_); return f(bind_state_.get(), cef_internal::CallbackForward(a1)); } private: typedef R(*PolymorphicInvoke)( cef_internal::BindStateBase*, typename cef_internal::CallbackParamTraits::ForwardType); }; template class Callback : public cef_internal::CallbackBase { public: typedef R(RunType)(A1, A2); Callback() : CallbackBase(NULL) { } // Note that this constructor CANNOT be explicit, and that Bind() CANNOT // return the exact Callback<> type. See base/bind.h for details. template Callback(cef_internal::BindState* bind_state) : CallbackBase(bind_state) { // Force the assignment to a local variable of PolymorphicInvoke // so the compiler will typecheck that the passed in Run() method has // the correct type. PolymorphicInvoke invoke_func = &cef_internal::BindState ::InvokerType::Run; polymorphic_invoke_ = reinterpret_cast(invoke_func); } bool Equals(const Callback& other) const { return CallbackBase::Equals(other); } R Run(typename cef_internal::CallbackParamTraits::ForwardType a1, typename cef_internal::CallbackParamTraits::ForwardType a2) const { PolymorphicInvoke f = reinterpret_cast(polymorphic_invoke_); return f(bind_state_.get(), cef_internal::CallbackForward(a1), cef_internal::CallbackForward(a2)); } private: typedef R(*PolymorphicInvoke)( cef_internal::BindStateBase*, typename cef_internal::CallbackParamTraits::ForwardType, typename cef_internal::CallbackParamTraits::ForwardType); }; template class Callback : public cef_internal::CallbackBase { public: typedef R(RunType)(A1, A2, A3); Callback() : CallbackBase(NULL) { } // Note that this constructor CANNOT be explicit, and that Bind() CANNOT // return the exact Callback<> type. See base/bind.h for details. template Callback(cef_internal::BindState* bind_state) : CallbackBase(bind_state) { // Force the assignment to a local variable of PolymorphicInvoke // so the compiler will typecheck that the passed in Run() method has // the correct type. PolymorphicInvoke invoke_func = &cef_internal::BindState ::InvokerType::Run; polymorphic_invoke_ = reinterpret_cast(invoke_func); } bool Equals(const Callback& other) const { return CallbackBase::Equals(other); } R Run(typename cef_internal::CallbackParamTraits::ForwardType a1, typename cef_internal::CallbackParamTraits::ForwardType a2, typename cef_internal::CallbackParamTraits::ForwardType a3) const { PolymorphicInvoke f = reinterpret_cast(polymorphic_invoke_); return f(bind_state_.get(), cef_internal::CallbackForward(a1), cef_internal::CallbackForward(a2), cef_internal::CallbackForward(a3)); } private: typedef R(*PolymorphicInvoke)( cef_internal::BindStateBase*, typename cef_internal::CallbackParamTraits::ForwardType, typename cef_internal::CallbackParamTraits::ForwardType, typename cef_internal::CallbackParamTraits::ForwardType); }; template class Callback : public cef_internal::CallbackBase { public: typedef R(RunType)(A1, A2, A3, A4); Callback() : CallbackBase(NULL) { } // Note that this constructor CANNOT be explicit, and that Bind() CANNOT // return the exact Callback<> type. See base/bind.h for details. template Callback(cef_internal::BindState* bind_state) : CallbackBase(bind_state) { // Force the assignment to a local variable of PolymorphicInvoke // so the compiler will typecheck that the passed in Run() method has // the correct type. PolymorphicInvoke invoke_func = &cef_internal::BindState ::InvokerType::Run; polymorphic_invoke_ = reinterpret_cast(invoke_func); } bool Equals(const Callback& other) const { return CallbackBase::Equals(other); } R Run(typename cef_internal::CallbackParamTraits::ForwardType a1, typename cef_internal::CallbackParamTraits::ForwardType a2, typename cef_internal::CallbackParamTraits::ForwardType a3, typename cef_internal::CallbackParamTraits::ForwardType a4) const { PolymorphicInvoke f = reinterpret_cast(polymorphic_invoke_); return f(bind_state_.get(), cef_internal::CallbackForward(a1), cef_internal::CallbackForward(a2), cef_internal::CallbackForward(a3), cef_internal::CallbackForward(a4)); } private: typedef R(*PolymorphicInvoke)( cef_internal::BindStateBase*, typename cef_internal::CallbackParamTraits::ForwardType, typename cef_internal::CallbackParamTraits::ForwardType, typename cef_internal::CallbackParamTraits::ForwardType, typename cef_internal::CallbackParamTraits::ForwardType); }; template class Callback : public cef_internal::CallbackBase { public: typedef R(RunType)(A1, A2, A3, A4, A5); Callback() : CallbackBase(NULL) { } // Note that this constructor CANNOT be explicit, and that Bind() CANNOT // return the exact Callback<> type. See base/bind.h for details. template Callback(cef_internal::BindState* bind_state) : CallbackBase(bind_state) { // Force the assignment to a local variable of PolymorphicInvoke // so the compiler will typecheck that the passed in Run() method has // the correct type. PolymorphicInvoke invoke_func = &cef_internal::BindState ::InvokerType::Run; polymorphic_invoke_ = reinterpret_cast(invoke_func); } bool Equals(const Callback& other) const { return CallbackBase::Equals(other); } R Run(typename cef_internal::CallbackParamTraits::ForwardType a1, typename cef_internal::CallbackParamTraits::ForwardType a2, typename cef_internal::CallbackParamTraits::ForwardType a3, typename cef_internal::CallbackParamTraits::ForwardType a4, typename cef_internal::CallbackParamTraits::ForwardType a5) const { PolymorphicInvoke f = reinterpret_cast(polymorphic_invoke_); return f(bind_state_.get(), cef_internal::CallbackForward(a1), cef_internal::CallbackForward(a2), cef_internal::CallbackForward(a3), cef_internal::CallbackForward(a4), cef_internal::CallbackForward(a5)); } private: typedef R(*PolymorphicInvoke)( cef_internal::BindStateBase*, typename cef_internal::CallbackParamTraits::ForwardType, typename cef_internal::CallbackParamTraits::ForwardType, typename cef_internal::CallbackParamTraits::ForwardType, typename cef_internal::CallbackParamTraits::ForwardType, typename cef_internal::CallbackParamTraits::ForwardType); }; template class Callback : public cef_internal::CallbackBase { public: typedef R(RunType)(A1, A2, A3, A4, A5, A6); Callback() : CallbackBase(NULL) { } // Note that this constructor CANNOT be explicit, and that Bind() CANNOT // return the exact Callback<> type. See base/bind.h for details. template Callback(cef_internal::BindState* bind_state) : CallbackBase(bind_state) { // Force the assignment to a local variable of PolymorphicInvoke // so the compiler will typecheck that the passed in Run() method has // the correct type. PolymorphicInvoke invoke_func = &cef_internal::BindState ::InvokerType::Run; polymorphic_invoke_ = reinterpret_cast(invoke_func); } bool Equals(const Callback& other) const { return CallbackBase::Equals(other); } R Run(typename cef_internal::CallbackParamTraits::ForwardType a1, typename cef_internal::CallbackParamTraits::ForwardType a2, typename cef_internal::CallbackParamTraits::ForwardType a3, typename cef_internal::CallbackParamTraits::ForwardType a4, typename cef_internal::CallbackParamTraits::ForwardType a5, typename cef_internal::CallbackParamTraits::ForwardType a6) const { PolymorphicInvoke f = reinterpret_cast(polymorphic_invoke_); return f(bind_state_.get(), cef_internal::CallbackForward(a1), cef_internal::CallbackForward(a2), cef_internal::CallbackForward(a3), cef_internal::CallbackForward(a4), cef_internal::CallbackForward(a5), cef_internal::CallbackForward(a6)); } private: typedef R(*PolymorphicInvoke)( cef_internal::BindStateBase*, typename cef_internal::CallbackParamTraits::ForwardType, typename cef_internal::CallbackParamTraits::ForwardType, typename cef_internal::CallbackParamTraits::ForwardType, typename cef_internal::CallbackParamTraits::ForwardType, typename cef_internal::CallbackParamTraits::ForwardType, typename cef_internal::CallbackParamTraits::ForwardType); }; template class Callback : public cef_internal::CallbackBase { public: typedef R(RunType)(A1, A2, A3, A4, A5, A6, A7); Callback() : CallbackBase(NULL) { } // Note that this constructor CANNOT be explicit, and that Bind() CANNOT // return the exact Callback<> type. See base/bind.h for details. template Callback(cef_internal::BindState* bind_state) : CallbackBase(bind_state) { // Force the assignment to a local variable of PolymorphicInvoke // so the compiler will typecheck that the passed in Run() method has // the correct type. PolymorphicInvoke invoke_func = &cef_internal::BindState ::InvokerType::Run; polymorphic_invoke_ = reinterpret_cast(invoke_func); } bool Equals(const Callback& other) const { return CallbackBase::Equals(other); } R Run(typename cef_internal::CallbackParamTraits::ForwardType a1, typename cef_internal::CallbackParamTraits::ForwardType a2, typename cef_internal::CallbackParamTraits::ForwardType a3, typename cef_internal::CallbackParamTraits::ForwardType a4, typename cef_internal::CallbackParamTraits::ForwardType a5, typename cef_internal::CallbackParamTraits::ForwardType a6, typename cef_internal::CallbackParamTraits::ForwardType a7) const { PolymorphicInvoke f = reinterpret_cast(polymorphic_invoke_); return f(bind_state_.get(), cef_internal::CallbackForward(a1), cef_internal::CallbackForward(a2), cef_internal::CallbackForward(a3), cef_internal::CallbackForward(a4), cef_internal::CallbackForward(a5), cef_internal::CallbackForward(a6), cef_internal::CallbackForward(a7)); } private: typedef R(*PolymorphicInvoke)( cef_internal::BindStateBase*, typename cef_internal::CallbackParamTraits::ForwardType, typename cef_internal::CallbackParamTraits::ForwardType, typename cef_internal::CallbackParamTraits::ForwardType, typename cef_internal::CallbackParamTraits::ForwardType, typename cef_internal::CallbackParamTraits::ForwardType, typename cef_internal::CallbackParamTraits::ForwardType, typename cef_internal::CallbackParamTraits::ForwardType); }; // Syntactic sugar to make Callbacks easier to declare since it // will be used in a lot of APIs with delayed execution. typedef Callback Closure; } // namespace base #endif // !BUILDING_CEF_SHARED #endif // CEF_INCLUDE_BASE_CEF_CALLBACK_H_ cefpython-49.0/src/include/base/cef_callback_forward.h000066400000000000000000000050411334103266300230400ustar00rootroot00000000000000// Copyright (c) 2014 Marshall A. Greenblatt. Portions copyright (c) 2011 // Google Inc. 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 INCLUDE_BASE_CEF_CALLBACK_FORWARD_H_ #define INCLUDE_BASE_CEF_CALLBACK_FORWARD_H_ #pragma once #if defined(BASE_CALLBACK_FORWARD_H_) // Do nothing if the Chromium header has already been included. // This can happen in cases where Chromium code is used directly by the // client application. When using Chromium code directly always include // the Chromium header first to avoid type conflicts. #elif defined(BUILDING_CEF_SHARED) // When building CEF include the Chromium header directly. #include "base/callback_forward.h" #else // !BUILDING_CEF_SHARED // The following is substantially similar to the Chromium implementation. // If the Chromium implementation diverges the below implementation should be // updated to match. namespace base { template class Callback; typedef Callback Closure; } // namespace base #endif // !!BUILDING_CEF_SHARED #endif // INCLUDE_BASE_CEF_CALLBACK_FORWARD_H_ cefpython-49.0/src/include/base/cef_callback_helpers.h000066400000000000000000000073351334103266300230460ustar00rootroot00000000000000// Copyright (c) 2014 Marshall A. Greenblatt. Portions copyright (c) 2012 // Google Inc. 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 defines helpful methods for dealing with Callbacks. Because Callbacks // are implemented using templates, with a class per callback signature, adding // methods to Callback<> itself is unattractive (lots of extra code gets // generated). Instead, consider adding methods here. // // ResetAndReturn(&cb) is like cb.Reset() but allows executing a callback (via a // copy) after the original callback is Reset(). This can be handy if Run() // reads/writes the variable holding the Callback. #ifndef CEF_INCLUDE_BASE_CEF_CALLBACK_HELPERS_H_ #define CEF_INCLUDE_BASE_CEF_CALLBACK_HELPERS_H_ #pragma once #if defined(BASE_CALLBACK_HELPERS_H_) // Do nothing if the Chromium header has already been included. // This can happen in cases where Chromium code is used directly by the // client application. When using Chromium code directly always include // the Chromium header first to avoid type conflicts. #elif defined(BUILDING_CEF_SHARED) // When building CEF include the Chromium header directly. #include "base/callback_helpers.h" #else // !BUILDING_CEF_SHARED // The following is substantially similar to the Chromium implementation. // If the Chromium implementation diverges the below implementation should be // updated to match. #include "include/base/cef_basictypes.h" #include "include/base/cef_build.h" #include "include/base/cef_callback.h" #include "include/base/cef_macros.h" namespace base { template base::Callback ResetAndReturn(base::Callback* cb) { base::Callback ret(*cb); cb->Reset(); return ret; } // ScopedClosureRunner is akin to scoped_ptr for Closures. It ensures that the // Closure is executed and deleted no matter how the current scope exits. class ScopedClosureRunner { public: ScopedClosureRunner(); explicit ScopedClosureRunner(const Closure& closure); ~ScopedClosureRunner(); void Reset(); void Reset(const Closure& closure); Closure Release() WARN_UNUSED_RESULT; private: Closure closure_; DISALLOW_COPY_AND_ASSIGN(ScopedClosureRunner); }; } // namespace base #endif // !BUILDING_CEF_SHARED #endif // CEF_INCLUDE_BASE_CEF_CALLBACK_HELPERS_H_ cefpython-49.0/src/include/base/cef_callback_list.h000066400000000000000000000334671334103266300223640ustar00rootroot00000000000000// Copyright (c) 2014 Marshall A. Greenblatt. Portions copyright (c) 2013 // Google Inc. 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_BASE_CEF_CALLBACK_LIST_H_ #define CEF_INCLUDE_BASE_CEF_CALLBACK_LIST_H_ #pragma once #if defined(BASE_CALLBACK_LIST_H_) // Do nothing if the Chromium header has already been included. // This can happen in cases where Chromium code is used directly by the // client application. When using Chromium code directly always include // the Chromium header first to avoid type conflicts. #elif defined(BUILDING_CEF_SHARED) // When building CEF include the Chromium header directly. #include "base/callback_list.h" #else // !BUILDING_CEF_SHARED // The following is substantially similar to the Chromium implementation. // If the Chromium implementation diverges the below implementation should be // updated to match. #include #include "include/base/cef_basictypes.h" #include "include/base/cef_callback.h" #include "include/base/internal/cef_callback_internal.h" #include "include/base/cef_build.h" #include "include/base/cef_logging.h" #include "include/base/cef_macros.h" #include "include/base/cef_scoped_ptr.h" // OVERVIEW: // // A container for a list of callbacks. Unlike a normal STL vector or list, // this container can be modified during iteration without invalidating the // iterator. It safely handles the case of a callback removing itself // or another callback from the list while callbacks are being run. // // TYPICAL USAGE: // // class MyWidget { // public: // ... // // typedef base::Callback OnFooCallback; // // scoped_ptr::Subscription> // RegisterCallback(const OnFooCallback& cb) { // return callback_list_.Add(cb); // } // // private: // void NotifyFoo(const Foo& foo) { // callback_list_.Notify(foo); // } // // base::CallbackList callback_list_; // // DISALLOW_COPY_AND_ASSIGN(MyWidget); // }; // // // class MyWidgetListener { // public: // MyWidgetListener::MyWidgetListener() { // foo_subscription_ = MyWidget::GetCurrent()->RegisterCallback( // base::Bind(&MyWidgetListener::OnFoo, this))); // } // // MyWidgetListener::~MyWidgetListener() { // // Subscription gets deleted automatically and will deregister // // the callback in the process. // } // // private: // void OnFoo(const Foo& foo) { // // Do something. // } // // scoped_ptr::Subscription> // foo_subscription_; // // DISALLOW_COPY_AND_ASSIGN(MyWidgetListener); // }; namespace base { namespace cef_internal { template class CallbackListBase { public: class Subscription { public: Subscription(CallbackListBase* list, typename std::list::iterator iter) : list_(list), iter_(iter) { } ~Subscription() { if (list_->active_iterator_count_) { iter_->Reset(); } else { list_->callbacks_.erase(iter_); if (!list_->removal_callback_.is_null()) list_->removal_callback_.Run(); } } private: CallbackListBase* list_; typename std::list::iterator iter_; DISALLOW_COPY_AND_ASSIGN(Subscription); }; // Add a callback to the list. The callback will remain registered until the // returned Subscription is destroyed, which must occur before the // CallbackList is destroyed. scoped_ptr Add(const CallbackType& cb) WARN_UNUSED_RESULT { DCHECK(!cb.is_null()); return scoped_ptr( new Subscription(this, callbacks_.insert(callbacks_.end(), cb))); } // Sets a callback which will be run when a subscription list is changed. void set_removal_callback(const Closure& callback) { removal_callback_ = callback; } // Returns true if there are no subscriptions. This is only valid to call when // not looping through the list. bool empty() { DCHECK_EQ(0, active_iterator_count_); return callbacks_.empty(); } protected: // An iterator class that can be used to access the list of callbacks. class Iterator { public: explicit Iterator(CallbackListBase* list) : list_(list), list_iter_(list_->callbacks_.begin()) { ++list_->active_iterator_count_; } Iterator(const Iterator& iter) : list_(iter.list_), list_iter_(iter.list_iter_) { ++list_->active_iterator_count_; } ~Iterator() { if (list_ && --list_->active_iterator_count_ == 0) { list_->Compact(); } } CallbackType* GetNext() { while ((list_iter_ != list_->callbacks_.end()) && list_iter_->is_null()) ++list_iter_; CallbackType* cb = NULL; if (list_iter_ != list_->callbacks_.end()) { cb = &(*list_iter_); ++list_iter_; } return cb; } private: CallbackListBase* list_; typename std::list::iterator list_iter_; }; CallbackListBase() : active_iterator_count_(0) {} ~CallbackListBase() { DCHECK_EQ(0, active_iterator_count_); DCHECK_EQ(0U, callbacks_.size()); } // Returns an instance of a CallbackListBase::Iterator which can be used // to run callbacks. Iterator GetIterator() { return Iterator(this); } // Compact the list: remove any entries which were NULLed out during // iteration. void Compact() { typename std::list::iterator it = callbacks_.begin(); bool updated = false; while (it != callbacks_.end()) { if ((*it).is_null()) { updated = true; it = callbacks_.erase(it); } else { ++it; } if (updated && !removal_callback_.is_null()) removal_callback_.Run(); } } private: std::list callbacks_; int active_iterator_count_; Closure removal_callback_; DISALLOW_COPY_AND_ASSIGN(CallbackListBase); }; } // namespace cef_internal template class CallbackList; template <> class CallbackList : public cef_internal::CallbackListBase > { public: typedef Callback CallbackType; CallbackList() {} void Notify() { cef_internal::CallbackListBase::Iterator it = this->GetIterator(); CallbackType* cb; while ((cb = it.GetNext()) != NULL) { cb->Run(); } } private: DISALLOW_COPY_AND_ASSIGN(CallbackList); }; template class CallbackList : public cef_internal::CallbackListBase > { public: typedef Callback CallbackType; CallbackList() {} void Notify(typename cef_internal::CallbackParamTraits::ForwardType a1) { typename cef_internal::CallbackListBase::Iterator it = this->GetIterator(); CallbackType* cb; while ((cb = it.GetNext()) != NULL) { cb->Run(a1); } } private: DISALLOW_COPY_AND_ASSIGN(CallbackList); }; template class CallbackList : public cef_internal::CallbackListBase > { public: typedef Callback CallbackType; CallbackList() {} void Notify(typename cef_internal::CallbackParamTraits::ForwardType a1, typename cef_internal::CallbackParamTraits::ForwardType a2) { typename cef_internal::CallbackListBase::Iterator it = this->GetIterator(); CallbackType* cb; while ((cb = it.GetNext()) != NULL) { cb->Run(a1, a2); } } private: DISALLOW_COPY_AND_ASSIGN(CallbackList); }; template class CallbackList : public cef_internal::CallbackListBase > { public: typedef Callback CallbackType; CallbackList() {} void Notify(typename cef_internal::CallbackParamTraits::ForwardType a1, typename cef_internal::CallbackParamTraits::ForwardType a2, typename cef_internal::CallbackParamTraits::ForwardType a3) { typename cef_internal::CallbackListBase::Iterator it = this->GetIterator(); CallbackType* cb; while ((cb = it.GetNext()) != NULL) { cb->Run(a1, a2, a3); } } private: DISALLOW_COPY_AND_ASSIGN(CallbackList); }; template class CallbackList : public cef_internal::CallbackListBase > { public: typedef Callback CallbackType; CallbackList() {} void Notify(typename cef_internal::CallbackParamTraits::ForwardType a1, typename cef_internal::CallbackParamTraits::ForwardType a2, typename cef_internal::CallbackParamTraits::ForwardType a3, typename cef_internal::CallbackParamTraits::ForwardType a4) { typename cef_internal::CallbackListBase::Iterator it = this->GetIterator(); CallbackType* cb; while ((cb = it.GetNext()) != NULL) { cb->Run(a1, a2, a3, a4); } } private: DISALLOW_COPY_AND_ASSIGN(CallbackList); }; template class CallbackList : public cef_internal::CallbackListBase > { public: typedef Callback CallbackType; CallbackList() {} void Notify(typename cef_internal::CallbackParamTraits::ForwardType a1, typename cef_internal::CallbackParamTraits::ForwardType a2, typename cef_internal::CallbackParamTraits::ForwardType a3, typename cef_internal::CallbackParamTraits::ForwardType a4, typename cef_internal::CallbackParamTraits::ForwardType a5) { typename cef_internal::CallbackListBase::Iterator it = this->GetIterator(); CallbackType* cb; while ((cb = it.GetNext()) != NULL) { cb->Run(a1, a2, a3, a4, a5); } } private: DISALLOW_COPY_AND_ASSIGN(CallbackList); }; template class CallbackList : public cef_internal::CallbackListBase > { public: typedef Callback CallbackType; CallbackList() {} void Notify(typename cef_internal::CallbackParamTraits::ForwardType a1, typename cef_internal::CallbackParamTraits::ForwardType a2, typename cef_internal::CallbackParamTraits::ForwardType a3, typename cef_internal::CallbackParamTraits::ForwardType a4, typename cef_internal::CallbackParamTraits::ForwardType a5, typename cef_internal::CallbackParamTraits::ForwardType a6) { typename cef_internal::CallbackListBase::Iterator it = this->GetIterator(); CallbackType* cb; while ((cb = it.GetNext()) != NULL) { cb->Run(a1, a2, a3, a4, a5, a6); } } private: DISALLOW_COPY_AND_ASSIGN(CallbackList); }; template class CallbackList : public cef_internal::CallbackListBase > { public: typedef Callback CallbackType; CallbackList() {} void Notify(typename cef_internal::CallbackParamTraits::ForwardType a1, typename cef_internal::CallbackParamTraits::ForwardType a2, typename cef_internal::CallbackParamTraits::ForwardType a3, typename cef_internal::CallbackParamTraits::ForwardType a4, typename cef_internal::CallbackParamTraits::ForwardType a5, typename cef_internal::CallbackParamTraits::ForwardType a6, typename cef_internal::CallbackParamTraits::ForwardType a7) { typename cef_internal::CallbackListBase::Iterator it = this->GetIterator(); CallbackType* cb; while ((cb = it.GetNext()) != NULL) { cb->Run(a1, a2, a3, a4, a5, a6, a7); } } private: DISALLOW_COPY_AND_ASSIGN(CallbackList); }; } // namespace base #endif // !BUILDING_CEF_SHARED #endif // CEF_INCLUDE_BASE_CEF_CALLBACK_LIST_H_ cefpython-49.0/src/include/base/cef_cancelable_callback.h000066400000000000000000000237331334103266300234550ustar00rootroot00000000000000// Copyright (c) 2014 Marshall A. Greenblatt. Portions copyright (c) 2011 // Google Inc. 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. // // CancelableCallback is a wrapper around base::Callback that allows // cancellation of a callback. CancelableCallback takes a reference on the // wrapped callback until this object is destroyed or Reset()/Cancel() are // called. // // NOTE: // // Calling CancelableCallback::Cancel() brings the object back to its natural, // default-constructed state, i.e., CancelableCallback::callback() will return // a null callback. // // THREAD-SAFETY: // // CancelableCallback objects must be created on, posted to, cancelled on, and // destroyed on the same thread. // // // EXAMPLE USAGE: // // In the following example, the test is verifying that RunIntensiveTest() // Quit()s the message loop within 4 seconds. The cancelable callback is posted // to the message loop, the intensive test runs, the message loop is run, // then the callback is cancelled. // // void TimeoutCallback(const std::string& timeout_message) { // FAIL() << timeout_message; // MessageLoop::current()->QuitWhenIdle(); // } // // CancelableClosure timeout(base::Bind(&TimeoutCallback, "Test timed out.")); // MessageLoop::current()->PostDelayedTask(FROM_HERE, timeout.callback(), // 4000) // 4 seconds to run. // RunIntensiveTest(); // MessageLoop::current()->Run(); // timeout.Cancel(); // Hopefully this is hit before the timeout callback runs. // #ifndef CEF_INCLUDE_BASE_CEF_CANCELABLE_CALLBACK_H_ #define CEF_INCLUDE_BASE_CEF_CANCELABLE_CALLBACK_H_ #pragma once #if defined(BASE_CANCELABLE_CALLBACK_H_) // Do nothing if the Chromium header has already been included. // This can happen in cases where Chromium code is used directly by the // client application. When using Chromium code directly always include // the Chromium header first to avoid type conflicts. #elif defined(BUILDING_CEF_SHARED) // When building CEF include the Chromium header directly. #include "base/cancelable_callback.h" #else // !BUILDING_CEF_SHARED // The following is substantially similar to the Chromium implementation. // If the Chromium implementation diverges the below implementation should be // updated to match. #include "include/base/cef_bind.h" #include "include/base/cef_callback.h" #include "include/base/cef_build.h" #include "include/base/cef_logging.h" #include "include/base/cef_macros.h" #include "include/base/cef_weak_ptr.h" #include "include/base/internal/cef_callback_internal.h" namespace base { template class CancelableCallback; template <> class CancelableCallback { public: CancelableCallback() : weak_factory_(this) {} // |callback| must not be null. explicit CancelableCallback(const base::Callback& callback) : weak_factory_(this), callback_(callback) { DCHECK(!callback.is_null()); InitializeForwarder(); } ~CancelableCallback() {} // Cancels and drops the reference to the wrapped callback. void Cancel() { weak_factory_.InvalidateWeakPtrs(); forwarder_.Reset(); callback_.Reset(); } // Returns true if the wrapped callback has been cancelled. bool IsCancelled() const { return callback_.is_null(); } // Sets |callback| as the closure that may be cancelled. |callback| may not // be null. Outstanding and any previously wrapped callbacks are cancelled. void Reset(const base::Callback& callback) { DCHECK(!callback.is_null()); // Outstanding tasks (e.g., posted to a message loop) must not be called. Cancel(); // |forwarder_| is no longer valid after Cancel(), so re-bind. InitializeForwarder(); callback_ = callback; } // Returns a callback that can be disabled by calling Cancel(). const base::Callback& callback() const { return forwarder_; } private: void Forward() { callback_.Run(); } // Helper method to bind |forwarder_| using a weak pointer from // |weak_factory_|. void InitializeForwarder() { forwarder_ = base::Bind(&CancelableCallback::Forward, weak_factory_.GetWeakPtr()); } // Used to ensure Forward() is not run when this object is destroyed. base::WeakPtrFactory > weak_factory_; // The wrapper closure. base::Callback forwarder_; // The stored closure that may be cancelled. base::Callback callback_; DISALLOW_COPY_AND_ASSIGN(CancelableCallback); }; template class CancelableCallback { public: CancelableCallback() : weak_factory_(this) {} // |callback| must not be null. explicit CancelableCallback(const base::Callback& callback) : weak_factory_(this), callback_(callback) { DCHECK(!callback.is_null()); InitializeForwarder(); } ~CancelableCallback() {} // Cancels and drops the reference to the wrapped callback. void Cancel() { weak_factory_.InvalidateWeakPtrs(); forwarder_.Reset(); callback_.Reset(); } // Returns true if the wrapped callback has been cancelled. bool IsCancelled() const { return callback_.is_null(); } // Sets |callback| as the closure that may be cancelled. |callback| may not // be null. Outstanding and any previously wrapped callbacks are cancelled. void Reset(const base::Callback& callback) { DCHECK(!callback.is_null()); // Outstanding tasks (e.g., posted to a message loop) must not be called. Cancel(); // |forwarder_| is no longer valid after Cancel(), so re-bind. InitializeForwarder(); callback_ = callback; } // Returns a callback that can be disabled by calling Cancel(). const base::Callback& callback() const { return forwarder_; } private: void Forward(A1 a1) const { callback_.Run(a1); } // Helper method to bind |forwarder_| using a weak pointer from // |weak_factory_|. void InitializeForwarder() { forwarder_ = base::Bind(&CancelableCallback::Forward, weak_factory_.GetWeakPtr()); } // Used to ensure Forward() is not run when this object is destroyed. base::WeakPtrFactory > weak_factory_; // The wrapper closure. base::Callback forwarder_; // The stored closure that may be cancelled. base::Callback callback_; DISALLOW_COPY_AND_ASSIGN(CancelableCallback); }; template class CancelableCallback { public: CancelableCallback() : weak_factory_(this) {} // |callback| must not be null. explicit CancelableCallback(const base::Callback& callback) : weak_factory_(this), callback_(callback) { DCHECK(!callback.is_null()); InitializeForwarder(); } ~CancelableCallback() {} // Cancels and drops the reference to the wrapped callback. void Cancel() { weak_factory_.InvalidateWeakPtrs(); forwarder_.Reset(); callback_.Reset(); } // Returns true if the wrapped callback has been cancelled. bool IsCancelled() const { return callback_.is_null(); } // Sets |callback| as the closure that may be cancelled. |callback| may not // be null. Outstanding and any previously wrapped callbacks are cancelled. void Reset(const base::Callback& callback) { DCHECK(!callback.is_null()); // Outstanding tasks (e.g., posted to a message loop) must not be called. Cancel(); // |forwarder_| is no longer valid after Cancel(), so re-bind. InitializeForwarder(); callback_ = callback; } // Returns a callback that can be disabled by calling Cancel(). const base::Callback& callback() const { return forwarder_; } private: void Forward(A1 a1, A2 a2) const { callback_.Run(a1, a2); } // Helper method to bind |forwarder_| using a weak pointer from // |weak_factory_|. void InitializeForwarder() { forwarder_ = base::Bind(&CancelableCallback::Forward, weak_factory_.GetWeakPtr()); } // Used to ensure Forward() is not run when this object is destroyed. base::WeakPtrFactory > weak_factory_; // The wrapper closure. base::Callback forwarder_; // The stored closure that may be cancelled. base::Callback callback_; DISALLOW_COPY_AND_ASSIGN(CancelableCallback); }; typedef CancelableCallback CancelableClosure; } // namespace base #endif // !BUILDING_CEF_SHARED #endif // CEF_INCLUDE_BASE_CEF_CANCELABLE_CALLBACK_H_ cefpython-49.0/src/include/base/cef_lock.h000066400000000000000000000126151334103266300205150ustar00rootroot00000000000000// Copyright (c) 2014 Marshall A. Greenblatt. Portions copyright (c) 2011 // Google Inc. 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_BASE_CEF_LOCK_H_ #define CEF_INCLUDE_BASE_CEF_LOCK_H_ #pragma once #if defined(BASE_SYNCHRONIZATION_LOCK_H_) // Do nothing if the Chromium header has already been included. // This can happen in cases where Chromium code is used directly by the // client application. When using Chromium code directly always include // the Chromium header first to avoid type conflicts. #elif defined(BUILDING_CEF_SHARED) // When building CEF include the Chromium header directly. #include "base/synchronization/lock.h" #else // !BUILDING_CEF_SHARED // The following is substantially similar to the Chromium implementation. // If the Chromium implementation diverges the below implementation should be // updated to match. #include "include/base/cef_macros.h" #include "include/base/cef_platform_thread.h" #include "include/base/internal/cef_lock_impl.h" namespace base { // A convenient wrapper for an OS specific critical section. The only real // intelligence in this class is in debug mode for the support for the // AssertAcquired() method. class Lock { public: #if defined(NDEBUG) // Optimized wrapper implementation Lock() : lock_() {} ~Lock() {} void Acquire() { lock_.Lock(); } void Release() { lock_.Unlock(); } // If the lock is not held, take it and return true. If the lock is already // held by another thread, immediately return false. This must not be called // by a thread already holding the lock (what happens is undefined and an // assertion may fail). bool Try() { return lock_.Try(); } // Null implementation if not debug. void AssertAcquired() const {} #else Lock(); ~Lock(); // NOTE: Although windows critical sections support recursive locks, we do not // allow this, and we will commonly fire a DCHECK() if a thread attempts to // acquire the lock a second time (while already holding it). void Acquire() { lock_.Lock(); CheckUnheldAndMark(); } void Release() { CheckHeldAndUnmark(); lock_.Unlock(); } bool Try() { bool rv = lock_.Try(); if (rv) { CheckUnheldAndMark(); } return rv; } void AssertAcquired() const; #endif // NDEBUG private: #if !defined(NDEBUG) // Members and routines taking care of locks assertions. // Note that this checks for recursive locks and allows them // if the variable is set. This is allowed by the underlying implementation // on windows but not on Posix, so we're doing unneeded checks on Posix. // It's worth it to share the code. void CheckHeldAndUnmark(); void CheckUnheldAndMark(); // All private data is implicitly protected by lock_. // Be VERY careful to only access members under that lock. base::PlatformThreadRef owning_thread_ref_; #endif // NDEBUG // Platform specific underlying lock implementation. cef_internal::LockImpl lock_; DISALLOW_COPY_AND_ASSIGN(Lock); }; // A helper class that acquires the given Lock while the AutoLock is in scope. class AutoLock { public: struct AlreadyAcquired {}; explicit AutoLock(Lock& lock) : lock_(lock) { lock_.Acquire(); } AutoLock(Lock& lock, const AlreadyAcquired&) : lock_(lock) { lock_.AssertAcquired(); } ~AutoLock() { lock_.AssertAcquired(); lock_.Release(); } private: Lock& lock_; DISALLOW_COPY_AND_ASSIGN(AutoLock); }; // AutoUnlock is a helper that will Release() the |lock| argument in the // constructor, and re-Acquire() it in the destructor. class AutoUnlock { public: explicit AutoUnlock(Lock& lock) : lock_(lock) { // We require our caller to have the lock. lock_.AssertAcquired(); lock_.Release(); } ~AutoUnlock() { lock_.Acquire(); } private: Lock& lock_; DISALLOW_COPY_AND_ASSIGN(AutoUnlock); }; } // namespace base #endif // !BUILDING_CEF_SHARED #endif // CEF_INCLUDE_BASE_CEF_LOCK_H_ cefpython-49.0/src/include/base/cef_logging.h000066400000000000000000000677351334103266300212300ustar00rootroot00000000000000// Copyright (c) 2014 Marshall A. Greenblatt. Portions copyright (c) 2012 // Google Inc. 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. // // WARNING: Logging macros should not be used in the main/browser process before // calling CefInitialize or in sub-processes before calling CefExecuteProcess. // // Instructions // ------------ // // Make a bunch of macros for logging. The way to log things is to stream // things to LOG(). E.g., // // LOG(INFO) << "Found " << num_cookies << " cookies"; // // You can also do conditional logging: // // LOG_IF(INFO, num_cookies > 10) << "Got lots of cookies"; // // The CHECK(condition) macro is active in both debug and release builds and // effectively performs a LOG(FATAL) which terminates the process and // generates a crashdump unless a debugger is attached. // // There are also "debug mode" logging macros like the ones above: // // DLOG(INFO) << "Found cookies"; // // DLOG_IF(INFO, num_cookies > 10) << "Got lots of cookies"; // // All "debug mode" logging is compiled away to nothing for non-debug mode // compiles. LOG_IF and development flags also work well together // because the code can be compiled away sometimes. // // We also have // // LOG_ASSERT(assertion); // DLOG_ASSERT(assertion); // // which is syntactic sugar for {,D}LOG_IF(FATAL, assert fails) << assertion; // // There are "verbose level" logging macros. They look like // // VLOG(1) << "I'm printed when you run the program with --v=1 or more"; // VLOG(2) << "I'm printed when you run the program with --v=2 or more"; // // These always log at the INFO log level (when they log at all). // The verbose logging can also be turned on module-by-module. For instance, // --vmodule=profile=2,icon_loader=1,browser_*=3,*/chromeos/*=4 --v=0 // will cause: // a. VLOG(2) and lower messages to be printed from profile.{h,cc} // b. VLOG(1) and lower messages to be printed from icon_loader.{h,cc} // c. VLOG(3) and lower messages to be printed from files prefixed with // "browser" // d. VLOG(4) and lower messages to be printed from files under a // "chromeos" directory. // e. VLOG(0) and lower messages to be printed from elsewhere // // The wildcarding functionality shown by (c) supports both '*' (match // 0 or more characters) and '?' (match any single character) // wildcards. Any pattern containing a forward or backward slash will // be tested against the whole pathname and not just the module. // E.g., "*/foo/bar/*=2" would change the logging level for all code // in source files under a "foo/bar" directory. // // There's also VLOG_IS_ON(n) "verbose level" condition macro. To be used as // // if (VLOG_IS_ON(2)) { // // do some logging preparation and logging // // that can't be accomplished with just VLOG(2) << ...; // } // // There is also a VLOG_IF "verbose level" condition macro for sample // cases, when some extra computation and preparation for logs is not // needed. // // VLOG_IF(1, (size > 1024)) // << "I'm printed when size is more than 1024 and when you run the " // "program with --v=1 or more"; // // We also override the standard 'assert' to use 'DLOG_ASSERT'. // // Lastly, there is: // // PLOG(ERROR) << "Couldn't do foo"; // DPLOG(ERROR) << "Couldn't do foo"; // PLOG_IF(ERROR, cond) << "Couldn't do foo"; // DPLOG_IF(ERROR, cond) << "Couldn't do foo"; // PCHECK(condition) << "Couldn't do foo"; // DPCHECK(condition) << "Couldn't do foo"; // // which append the last system error to the message in string form (taken from // GetLastError() on Windows and errno on POSIX). // // The supported severity levels for macros that allow you to specify one // are (in increasing order of severity) INFO, WARNING, ERROR, and FATAL. // // Very important: logging a message at the FATAL severity level causes // the program to terminate (after the message is logged). // // There is the special severity of DFATAL, which logs FATAL in debug mode, // ERROR in normal mode. // #ifndef CEF_INCLUDE_BASE_CEF_LOGGING_H_ #define CEF_INCLUDE_BASE_CEF_LOGGING_H_ #pragma once #if defined(DCHECK) // Do nothing if the macros provided by this header already exist. // This can happen in cases where Chromium code is used directly by the // client application. When using Chromium code directly always include // the Chromium header first to avoid type conflicts. // Always define the DCHECK_IS_ON macro which is used from other CEF headers. #if defined(NDEBUG) && !defined(DCHECK_ALWAYS_ON) #define DCHECK_IS_ON() 0 #else #define DCHECK_IS_ON() 1 #endif #elif defined(BUILDING_CEF_SHARED) // When building CEF include the Chromium header directly. #include "base/logging.h" #else // !BUILDING_CEF_SHARED // The following is substantially similar to the Chromium implementation. // If the Chromium implementation diverges the below implementation should be // updated to match. #include #include #include #include #include "include/base/cef_build.h" #include "include/base/cef_macros.h" #include "include/internal/cef_logging_internal.h" namespace cef { namespace logging { // Gets the current log level. inline int GetMinLogLevel() { return cef_get_min_log_level(); } // Gets the current vlog level for the given file (usually taken from // __FILE__). Note that |N| is the size *with* the null terminator. template int GetVlogLevel(const char (&file)[N]) { return cef_get_vlog_level(file, N); } typedef int LogSeverity; const LogSeverity LOG_VERBOSE = -1; // This is level 1 verbosity // Note: the log severities are used to index into the array of names, // see log_severity_names. const LogSeverity LOG_INFO = 0; const LogSeverity LOG_WARNING = 1; const LogSeverity LOG_ERROR = 2; const LogSeverity LOG_FATAL = 3; const LogSeverity LOG_NUM_SEVERITIES = 4; // LOG_DFATAL is LOG_FATAL in debug mode, ERROR in normal mode #ifdef NDEBUG const LogSeverity LOG_DFATAL = LOG_ERROR; #else const LogSeverity LOG_DFATAL = LOG_FATAL; #endif // A few definitions of macros that don't generate much code. These are used // by LOG() and LOG_IF, etc. Since these are used all over our code, it's // better to have compact code for these operations. #define COMPACT_GOOGLE_LOG_EX_INFO(ClassName, ...) \ cef::logging::ClassName(__FILE__, __LINE__, cef::logging::LOG_INFO , \ ##__VA_ARGS__) #define COMPACT_GOOGLE_LOG_EX_WARNING(ClassName, ...) \ cef::logging::ClassName(__FILE__, __LINE__, cef::logging::LOG_WARNING , \ ##__VA_ARGS__) #define COMPACT_GOOGLE_LOG_EX_ERROR(ClassName, ...) \ cef::logging::ClassName(__FILE__, __LINE__, cef::logging::LOG_ERROR , \ ##__VA_ARGS__) #define COMPACT_GOOGLE_LOG_EX_FATAL(ClassName, ...) \ cef::logging::ClassName(__FILE__, __LINE__, cef::logging::LOG_FATAL , \ ##__VA_ARGS__) #define COMPACT_GOOGLE_LOG_EX_DFATAL(ClassName, ...) \ cef::logging::ClassName(__FILE__, __LINE__, cef::logging::LOG_DFATAL , \ ##__VA_ARGS__) #define COMPACT_GOOGLE_LOG_INFO \ COMPACT_GOOGLE_LOG_EX_INFO(LogMessage) #define COMPACT_GOOGLE_LOG_WARNING \ COMPACT_GOOGLE_LOG_EX_WARNING(LogMessage) #define COMPACT_GOOGLE_LOG_ERROR \ COMPACT_GOOGLE_LOG_EX_ERROR(LogMessage) #define COMPACT_GOOGLE_LOG_FATAL \ COMPACT_GOOGLE_LOG_EX_FATAL(LogMessage) #define COMPACT_GOOGLE_LOG_DFATAL \ COMPACT_GOOGLE_LOG_EX_DFATAL(LogMessage) #if defined(OS_WIN) // wingdi.h defines ERROR to be 0. When we call LOG(ERROR), it gets // substituted with 0, and it expands to COMPACT_GOOGLE_LOG_0. To allow us // to keep using this syntax, we define this macro to do the same thing // as COMPACT_GOOGLE_LOG_ERROR, and also define ERROR the same way that // the Windows SDK does for consistency. #define ERROR 0 #define COMPACT_GOOGLE_LOG_EX_0(ClassName, ...) \ COMPACT_GOOGLE_LOG_EX_ERROR(ClassName , ##__VA_ARGS__) #define COMPACT_GOOGLE_LOG_0 COMPACT_GOOGLE_LOG_ERROR // Needed for LOG_IS_ON(ERROR). const LogSeverity LOG_0 = LOG_ERROR; #endif // As special cases, we can assume that LOG_IS_ON(FATAL) always holds. Also, // LOG_IS_ON(DFATAL) always holds in debug mode. In particular, CHECK()s will // always fire if they fail. #define LOG_IS_ON(severity) \ ((::cef::logging::LOG_ ## severity) >= ::cef::logging::GetMinLogLevel()) // We can't do any caching tricks with VLOG_IS_ON() like the // google-glog version since it requires GCC extensions. This means // that using the v-logging functions in conjunction with --vmodule // may be slow. #define VLOG_IS_ON(verboselevel) \ ((verboselevel) <= ::cef::logging::GetVlogLevel(__FILE__)) // Helper macro which avoids evaluating the arguments to a stream if // the condition doesn't hold. #define LAZY_STREAM(stream, condition) \ !(condition) ? (void) 0 : ::cef::logging::LogMessageVoidify() & (stream) // We use the preprocessor's merging operator, "##", so that, e.g., // LOG(INFO) becomes the token COMPACT_GOOGLE_LOG_INFO. There's some funny // subtle difference between ostream member streaming functions (e.g., // ostream::operator<<(int) and ostream non-member streaming functions // (e.g., ::operator<<(ostream&, string&): it turns out that it's // impossible to stream something like a string directly to an unnamed // ostream. We employ a neat hack by calling the stream() member // function of LogMessage which seems to avoid the problem. #define LOG_STREAM(severity) COMPACT_GOOGLE_LOG_ ## severity.stream() #define LOG(severity) LAZY_STREAM(LOG_STREAM(severity), LOG_IS_ON(severity)) #define LOG_IF(severity, condition) \ LAZY_STREAM(LOG_STREAM(severity), LOG_IS_ON(severity) && (condition)) #define SYSLOG(severity) LOG(severity) #define SYSLOG_IF(severity, condition) LOG_IF(severity, condition) // The VLOG macros log with negative verbosities. #define VLOG_STREAM(verbose_level) \ cef::logging::LogMessage(__FILE__, __LINE__, -verbose_level).stream() #define VLOG(verbose_level) \ LAZY_STREAM(VLOG_STREAM(verbose_level), VLOG_IS_ON(verbose_level)) #define VLOG_IF(verbose_level, condition) \ LAZY_STREAM(VLOG_STREAM(verbose_level), \ VLOG_IS_ON(verbose_level) && (condition)) #if defined (OS_WIN) #define VPLOG_STREAM(verbose_level) \ cef::logging::Win32ErrorLogMessage(__FILE__, __LINE__, -verbose_level, \ ::cef::logging::GetLastSystemErrorCode()).stream() #elif defined(OS_POSIX) #define VPLOG_STREAM(verbose_level) \ cef::logging::ErrnoLogMessage(__FILE__, __LINE__, -verbose_level, \ ::cef::logging::GetLastSystemErrorCode()).stream() #endif #define VPLOG(verbose_level) \ LAZY_STREAM(VPLOG_STREAM(verbose_level), VLOG_IS_ON(verbose_level)) #define VPLOG_IF(verbose_level, condition) \ LAZY_STREAM(VPLOG_STREAM(verbose_level), \ VLOG_IS_ON(verbose_level) && (condition)) // TODO(akalin): Add more VLOG variants, e.g. VPLOG. #define LOG_ASSERT(condition) \ LOG_IF(FATAL, !(condition)) << "Assert failed: " #condition ". " #define SYSLOG_ASSERT(condition) \ SYSLOG_IF(FATAL, !(condition)) << "Assert failed: " #condition ". " #if defined(OS_WIN) #define PLOG_STREAM(severity) \ COMPACT_GOOGLE_LOG_EX_ ## severity(Win32ErrorLogMessage, \ ::cef::logging::GetLastSystemErrorCode()).stream() #elif defined(OS_POSIX) #define PLOG_STREAM(severity) \ COMPACT_GOOGLE_LOG_EX_ ## severity(ErrnoLogMessage, \ ::cef::logging::GetLastSystemErrorCode()).stream() #endif #define PLOG(severity) \ LAZY_STREAM(PLOG_STREAM(severity), LOG_IS_ON(severity)) #define PLOG_IF(severity, condition) \ LAZY_STREAM(PLOG_STREAM(severity), LOG_IS_ON(severity) && (condition)) // The actual stream used isn't important. #define EAT_STREAM_PARAMETERS \ true ? (void) 0 : ::cef::logging::LogMessageVoidify() & LOG_STREAM(FATAL) // CHECK dies with a fatal error if condition is not true. It is *not* // controlled by NDEBUG, so the check will be executed regardless of // compilation mode. // // We make sure CHECK et al. always evaluates their arguments, as // doing CHECK(FunctionWithSideEffect()) is a common idiom. #define CHECK(condition) \ LAZY_STREAM(LOG_STREAM(FATAL), !(condition)) \ << "Check failed: " #condition ". " #define PCHECK(condition) \ LAZY_STREAM(PLOG_STREAM(FATAL), !(condition)) \ << "Check failed: " #condition ". " // Helper macro for binary operators. // Don't use this macro directly in your code, use CHECK_EQ et al below. // // TODO(akalin): Rewrite this so that constructs like if (...) // CHECK_EQ(...) else { ... } work properly. #define CHECK_OP(name, op, val1, val2) \ if (std::string* _result = \ cef::logging::Check##name##Impl((val1), (val2), \ #val1 " " #op " " #val2)) \ cef::logging::LogMessage(__FILE__, __LINE__, _result).stream() // Build the error message string. This is separate from the "Impl" // function template because it is not performance critical and so can // be out of line, while the "Impl" code should be inline. Caller // takes ownership of the returned string. template std::string* MakeCheckOpString(const t1& v1, const t2& v2, const char* names) { std::ostringstream ss; ss << names << " (" << v1 << " vs. " << v2 << ")"; std::string* msg = new std::string(ss.str()); return msg; } // MSVC doesn't like complex extern templates and DLLs. #if !defined(COMPILER_MSVC) // Commonly used instantiations of MakeCheckOpString<>. Explicitly instantiated // in logging.cc. extern template std::string* MakeCheckOpString( const int&, const int&, const char* names); extern template std::string* MakeCheckOpString( const unsigned long&, const unsigned long&, const char* names); extern template std::string* MakeCheckOpString( const unsigned long&, const unsigned int&, const char* names); extern template std::string* MakeCheckOpString( const unsigned int&, const unsigned long&, const char* names); extern template std::string* MakeCheckOpString( const std::string&, const std::string&, const char* name); #endif // Helper functions for CHECK_OP macro. // The (int, int) specialization works around the issue that the compiler // will not instantiate the template version of the function on values of // unnamed enum type - see comment below. #define DEFINE_CHECK_OP_IMPL(name, op) \ template \ inline std::string* Check##name##Impl(const t1& v1, const t2& v2, \ const char* names) { \ if (v1 op v2) return NULL; \ else return MakeCheckOpString(v1, v2, names); \ } \ inline std::string* Check##name##Impl(int v1, int v2, const char* names) { \ if (v1 op v2) return NULL; \ else return MakeCheckOpString(v1, v2, names); \ } DEFINE_CHECK_OP_IMPL(EQ, ==) DEFINE_CHECK_OP_IMPL(NE, !=) DEFINE_CHECK_OP_IMPL(LE, <=) DEFINE_CHECK_OP_IMPL(LT, < ) DEFINE_CHECK_OP_IMPL(GE, >=) DEFINE_CHECK_OP_IMPL(GT, > ) #undef DEFINE_CHECK_OP_IMPL #define CHECK_EQ(val1, val2) CHECK_OP(EQ, ==, val1, val2) #define CHECK_NE(val1, val2) CHECK_OP(NE, !=, val1, val2) #define CHECK_LE(val1, val2) CHECK_OP(LE, <=, val1, val2) #define CHECK_LT(val1, val2) CHECK_OP(LT, < , val1, val2) #define CHECK_GE(val1, val2) CHECK_OP(GE, >=, val1, val2) #define CHECK_GT(val1, val2) CHECK_OP(GT, > , val1, val2) #if defined(NDEBUG) #define ENABLE_DLOG 0 #else #define ENABLE_DLOG 1 #endif #if defined(NDEBUG) && !defined(DCHECK_ALWAYS_ON) #define DCHECK_IS_ON() 0 #else #define DCHECK_IS_ON() 1 #endif // Definitions for DLOG et al. #if ENABLE_DLOG #define DLOG_IS_ON(severity) LOG_IS_ON(severity) #define DLOG_IF(severity, condition) LOG_IF(severity, condition) #define DLOG_ASSERT(condition) LOG_ASSERT(condition) #define DPLOG_IF(severity, condition) PLOG_IF(severity, condition) #define DVLOG_IF(verboselevel, condition) VLOG_IF(verboselevel, condition) #define DVPLOG_IF(verboselevel, condition) VPLOG_IF(verboselevel, condition) #else // ENABLE_DLOG // If ENABLE_DLOG is off, we want to avoid emitting any references to // |condition| (which may reference a variable defined only if NDEBUG // is not defined). Contrast this with DCHECK et al., which has // different behavior. #define DLOG_IS_ON(severity) false #define DLOG_IF(severity, condition) EAT_STREAM_PARAMETERS #define DLOG_ASSERT(condition) EAT_STREAM_PARAMETERS #define DPLOG_IF(severity, condition) EAT_STREAM_PARAMETERS #define DVLOG_IF(verboselevel, condition) EAT_STREAM_PARAMETERS #define DVPLOG_IF(verboselevel, condition) EAT_STREAM_PARAMETERS #endif // ENABLE_DLOG // DEBUG_MODE is for uses like // if (DEBUG_MODE) foo.CheckThatFoo(); // instead of // #ifndef NDEBUG // foo.CheckThatFoo(); // #endif // // We tie its state to ENABLE_DLOG. enum { DEBUG_MODE = ENABLE_DLOG }; #undef ENABLE_DLOG #define DLOG(severity) \ LAZY_STREAM(LOG_STREAM(severity), DLOG_IS_ON(severity)) #define DPLOG(severity) \ LAZY_STREAM(PLOG_STREAM(severity), DLOG_IS_ON(severity)) #define DVLOG(verboselevel) DVLOG_IF(verboselevel, VLOG_IS_ON(verboselevel)) #define DVPLOG(verboselevel) DVPLOG_IF(verboselevel, VLOG_IS_ON(verboselevel)) // Definitions for DCHECK et al. #if DCHECK_IS_ON() #define COMPACT_GOOGLE_LOG_EX_DCHECK(ClassName, ...) \ COMPACT_GOOGLE_LOG_EX_FATAL(ClassName , ##__VA_ARGS__) #define COMPACT_GOOGLE_LOG_DCHECK COMPACT_GOOGLE_LOG_FATAL const LogSeverity LOG_DCHECK = LOG_FATAL; #else // DCHECK_IS_ON() // These are just dummy values. #define COMPACT_GOOGLE_LOG_EX_DCHECK(ClassName, ...) \ COMPACT_GOOGLE_LOG_EX_INFO(ClassName , ##__VA_ARGS__) #define COMPACT_GOOGLE_LOG_DCHECK COMPACT_GOOGLE_LOG_INFO const LogSeverity LOG_DCHECK = LOG_INFO; #endif // DCHECK_IS_ON() // DCHECK et al. make sure to reference |condition| regardless of // whether DCHECKs are enabled; this is so that we don't get unused // variable warnings if the only use of a variable is in a DCHECK. // This behavior is different from DLOG_IF et al. #define DCHECK(condition) \ LAZY_STREAM(LOG_STREAM(DCHECK), DCHECK_IS_ON() && !(condition)) \ << "Check failed: " #condition ". " #define DPCHECK(condition) \ LAZY_STREAM(PLOG_STREAM(DCHECK), DCHECK_IS_ON() && !(condition)) \ << "Check failed: " #condition ". " // Helper macro for binary operators. // Don't use this macro directly in your code, use DCHECK_EQ et al below. #define DCHECK_OP(name, op, val1, val2) \ if (DCHECK_IS_ON()) \ if (std::string* _result = cef::logging::Check##name##Impl( \ (val1), (val2), #val1 " " #op " " #val2)) \ cef::logging::LogMessage(__FILE__, __LINE__, \ ::cef::logging::LOG_DCHECK, _result).stream() // Equality/Inequality checks - compare two values, and log a // LOG_DCHECK message including the two values when the result is not // as expected. The values must have operator<<(ostream, ...) // defined. // // You may append to the error message like so: // DCHECK_NE(1, 2) << ": The world must be ending!"; // // We are very careful to ensure that each argument is evaluated exactly // once, and that anything which is legal to pass as a function argument is // legal here. In particular, the arguments may be temporary expressions // which will end up being destroyed at the end of the apparent statement, // for example: // DCHECK_EQ(string("abc")[1], 'b'); // // WARNING: These may not compile correctly if one of the arguments is a pointer // and the other is NULL. To work around this, simply static_cast NULL to the // type of the desired pointer. #define DCHECK_EQ(val1, val2) DCHECK_OP(EQ, ==, val1, val2) #define DCHECK_NE(val1, val2) DCHECK_OP(NE, !=, val1, val2) #define DCHECK_LE(val1, val2) DCHECK_OP(LE, <=, val1, val2) #define DCHECK_LT(val1, val2) DCHECK_OP(LT, < , val1, val2) #define DCHECK_GE(val1, val2) DCHECK_OP(GE, >=, val1, val2) #define DCHECK_GT(val1, val2) DCHECK_OP(GT, > , val1, val2) #if defined(NDEBUG) && defined(OS_CHROMEOS) #define NOTREACHED() LOG(ERROR) << "NOTREACHED() hit in " << \ __FUNCTION__ << ". " #else #define NOTREACHED() DCHECK(false) #endif // Redefine the standard assert to use our nice log files #undef assert #define assert(x) DLOG_ASSERT(x) // This class more or less represents a particular log message. You // create an instance of LogMessage and then stream stuff to it. // When you finish streaming to it, ~LogMessage is called and the // full message gets streamed to the appropriate destination. // // You shouldn't actually use LogMessage's constructor to log things, // though. You should use the LOG() macro (and variants thereof) // above. class LogMessage { public: // Used for LOG(severity). LogMessage(const char* file, int line, LogSeverity severity); // Used for CHECK_EQ(), etc. Takes ownership of the given string. // Implied severity = LOG_FATAL. LogMessage(const char* file, int line, std::string* result); // Used for DCHECK_EQ(), etc. Takes ownership of the given string. LogMessage(const char* file, int line, LogSeverity severity, std::string* result); ~LogMessage(); std::ostream& stream() { return stream_; } private: LogSeverity severity_; std::ostringstream stream_; // The file and line information passed in to the constructor. const char* file_; const int line_; #if defined(OS_WIN) // Stores the current value of GetLastError in the constructor and restores // it in the destructor by calling SetLastError. // This is useful since the LogMessage class uses a lot of Win32 calls // that will lose the value of GLE and the code that called the log function // will have lost the thread error value when the log call returns. class SaveLastError { public: SaveLastError(); ~SaveLastError(); unsigned long get_error() const { return last_error_; } protected: unsigned long last_error_; }; SaveLastError last_error_; #endif DISALLOW_COPY_AND_ASSIGN(LogMessage); }; // A non-macro interface to the log facility; (useful // when the logging level is not a compile-time constant). inline void LogAtLevel(int const log_level, std::string const &msg) { LogMessage(__FILE__, __LINE__, log_level).stream() << msg; } // This class is used to explicitly ignore values in the conditional // logging macros. This avoids compiler warnings like "value computed // is not used" and "statement has no effect". class LogMessageVoidify { public: LogMessageVoidify() { } // This has to be an operator with a precedence lower than << but // higher than ?: void operator&(std::ostream&) { } }; #if defined(OS_WIN) typedef unsigned long SystemErrorCode; #elif defined(OS_POSIX) typedef int SystemErrorCode; #endif // Alias for ::GetLastError() on Windows and errno on POSIX. Avoids having to // pull in windows.h just for GetLastError() and DWORD. SystemErrorCode GetLastSystemErrorCode(); std::string SystemErrorCodeToString(SystemErrorCode error_code); #if defined(OS_WIN) // Appends a formatted system message of the GetLastError() type. class Win32ErrorLogMessage { public: Win32ErrorLogMessage(const char* file, int line, LogSeverity severity, SystemErrorCode err); // Appends the error message before destructing the encapsulated class. ~Win32ErrorLogMessage(); std::ostream& stream() { return log_message_.stream(); } private: SystemErrorCode err_; LogMessage log_message_; DISALLOW_COPY_AND_ASSIGN(Win32ErrorLogMessage); }; #elif defined(OS_POSIX) // Appends a formatted system message of the errno type class ErrnoLogMessage { public: ErrnoLogMessage(const char* file, int line, LogSeverity severity, SystemErrorCode err); // Appends the error message before destructing the encapsulated class. ~ErrnoLogMessage(); std::ostream& stream() { return log_message_.stream(); } private: SystemErrorCode err_; LogMessage log_message_; DISALLOW_COPY_AND_ASSIGN(ErrnoLogMessage); }; #endif // OS_WIN } // namespace logging } // namespace cef // These functions are provided as a convenience for logging, which is where we // use streams (it is against Google style to use streams in other places). It // is designed to allow you to emit non-ASCII Unicode strings to the log file, // which is normally ASCII. It is relatively slow, so try not to use it for // common cases. Non-ASCII characters will be converted to UTF-8 by these // operators. std::ostream& operator<<(std::ostream& out, const wchar_t* wstr); inline std::ostream& operator<<(std::ostream& out, const std::wstring& wstr) { return out << wstr.c_str(); } // The NOTIMPLEMENTED() macro annotates codepaths which have // not been implemented yet. // // The implementation of this macro is controlled by NOTIMPLEMENTED_POLICY: // 0 -- Do nothing (stripped by compiler) // 1 -- Warn at compile time // 2 -- Fail at compile time // 3 -- Fail at runtime (DCHECK) // 4 -- [default] LOG(ERROR) at runtime // 5 -- LOG(ERROR) at runtime, only once per call-site #ifndef NOTIMPLEMENTED_POLICY #if defined(OS_ANDROID) && defined(OFFICIAL_BUILD) #define NOTIMPLEMENTED_POLICY 0 #else // Select default policy: LOG(ERROR) #define NOTIMPLEMENTED_POLICY 4 #endif #endif #if defined(COMPILER_GCC) // On Linux, with GCC, we can use __PRETTY_FUNCTION__ to get the demangled name // of the current function in the NOTIMPLEMENTED message. #define NOTIMPLEMENTED_MSG "Not implemented reached in " << __PRETTY_FUNCTION__ #else #define NOTIMPLEMENTED_MSG "NOT IMPLEMENTED" #endif #if NOTIMPLEMENTED_POLICY == 0 #define NOTIMPLEMENTED() EAT_STREAM_PARAMETERS #elif NOTIMPLEMENTED_POLICY == 1 // TODO, figure out how to generate a warning #define NOTIMPLEMENTED() COMPILE_ASSERT(false, NOT_IMPLEMENTED) #elif NOTIMPLEMENTED_POLICY == 2 #define NOTIMPLEMENTED() COMPILE_ASSERT(false, NOT_IMPLEMENTED) #elif NOTIMPLEMENTED_POLICY == 3 #define NOTIMPLEMENTED() NOTREACHED() #elif NOTIMPLEMENTED_POLICY == 4 #define NOTIMPLEMENTED() LOG(ERROR) << NOTIMPLEMENTED_MSG #elif NOTIMPLEMENTED_POLICY == 5 #define NOTIMPLEMENTED() do {\ static bool logged_once = false;\ LOG_IF(ERROR, !logged_once) << NOTIMPLEMENTED_MSG;\ logged_once = true;\ } while(0);\ EAT_STREAM_PARAMETERS #endif #endif // !BUILDING_CEF_SHARED #endif // CEF_INCLUDE_BASE_CEF_LOGGING_H_ cefpython-49.0/src/include/base/cef_macros.h000066400000000000000000000202641334103266300210500ustar00rootroot00000000000000// Copyright (c) 2014 Marshall A. Greenblatt. Portions copyright (c) 2012 // Google Inc. 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_BASE_CEF_MACROS_H_ #define CEF_INCLUDE_BASE_CEF_MACROS_H_ #pragma once #if defined(BUILDING_CEF_SHARED) // When building CEF include the Chromium header directly. #include "base/macros.h" #else // !BUILDING_CEF_SHARED // The following is substantially similar to the Chromium implementation. // If the Chromium implementation diverges the below implementation should be // updated to match. #include // For size_t. #include "include/base/cef_build.h" // For COMPILER_MSVC #if !defined(ALLOW_THIS_IN_INITIALIZER_LIST) #if defined(COMPILER_MSVC) // MSVC_PUSH_DISABLE_WARNING pushes |n| onto a stack of warnings to be disabled. // The warning remains disabled until popped by MSVC_POP_WARNING. #define MSVC_PUSH_DISABLE_WARNING(n) __pragma(warning(push)) \ __pragma(warning(disable:n)) // MSVC_PUSH_WARNING_LEVEL pushes |n| as the global warning level. The level // remains in effect until popped by MSVC_POP_WARNING(). Use 0 to disable all // warnings. #define MSVC_PUSH_WARNING_LEVEL(n) __pragma(warning(push, n)) // Pop effects of innermost MSVC_PUSH_* macro. #define MSVC_POP_WARNING() __pragma(warning(pop)) // Allows |this| to be passed as an argument in constructor initializer lists. // This uses push/pop instead of the seemingly simpler suppress feature to avoid // having the warning be disabled for more than just |code|. // // Example usage: // Foo::Foo() : x(NULL), ALLOW_THIS_IN_INITIALIZER_LIST(y(this)), z(3) {} // // Compiler warning C4355: 'this': used in base member initializer list: // http://msdn.microsoft.com/en-us/library/3c594ae3(VS.80).aspx #define ALLOW_THIS_IN_INITIALIZER_LIST(code) MSVC_PUSH_DISABLE_WARNING(4355) \ code \ MSVC_POP_WARNING() #else // !COMPILER_MSVC #define ALLOW_THIS_IN_INITIALIZER_LIST(code) code #endif // !COMPILER_MSVC #endif // !ALLOW_THIS_IN_INITIALIZER_LIST #if !defined(arraysize) // The arraysize(arr) macro returns the # of elements in an array arr. // The expression is a compile-time constant, and therefore can be // used in defining new arrays, for example. If you use arraysize on // a pointer by mistake, you will get a compile-time error. // // One caveat is that arraysize() doesn't accept any array of an // anonymous type or a type defined inside a function. In these rare // cases, you have to use the unsafe ARRAYSIZE_UNSAFE() macro below. This is // due to a limitation in C++'s template system. The limitation might // eventually be removed, but it hasn't happened yet. // This template function declaration is used in defining arraysize. // Note that the function doesn't need an implementation, as we only // use its type. template char (&ArraySizeHelper(T (&array)[N]))[N]; // That gcc wants both of these prototypes seems mysterious. VC, for // its part, can't decide which to use (another mystery). Matching of // template overloads: the final frontier. #ifndef _MSC_VER template char (&ArraySizeHelper(const T (&array)[N]))[N]; #endif #define arraysize(array) (sizeof(ArraySizeHelper(array))) #endif // !arraysize #if !defined(DISALLOW_COPY_AND_ASSIGN) // A macro to disallow the copy constructor and operator= functions // This should be used in the private: declarations for a class #define DISALLOW_COPY_AND_ASSIGN(TypeName) \ TypeName(const TypeName&); \ void operator=(const TypeName&) #endif // !DISALLOW_COPY_AND_ASSIGN #if !defined(DISALLOW_IMPLICIT_CONSTRUCTORS) // A macro to disallow all the implicit constructors, namely the // default constructor, copy constructor and operator= functions. // // This should be used in the private: declarations for a class // that wants to prevent anyone from instantiating it. This is // especially useful for classes containing only static methods. #define DISALLOW_IMPLICIT_CONSTRUCTORS(TypeName) \ TypeName(); \ DISALLOW_COPY_AND_ASSIGN(TypeName) #endif // !DISALLOW_IMPLICIT_CONSTRUCTORS #if !defined(COMPILE_ASSERT) // The COMPILE_ASSERT macro can be used to verify that a compile time // expression is true. For example, you could use it to verify the // size of a static array: // // COMPILE_ASSERT(ARRAYSIZE_UNSAFE(content_type_names) == CONTENT_NUM_TYPES, // content_type_names_incorrect_size); // // or to make sure a struct is smaller than a certain size: // // COMPILE_ASSERT(sizeof(foo) < 128, foo_too_large); // // The second argument to the macro is the name of the variable. If // the expression is false, most compilers will issue a warning/error // containing the name of the variable. #if __cplusplus >= 201103L // Under C++11, just use static_assert. #define COMPILE_ASSERT(expr, msg) static_assert(expr, #msg) #else namespace cef { template struct CompileAssert { }; } // namespace cef #define COMPILE_ASSERT(expr, msg) \ typedef cef::CompileAssert<(bool(expr))> msg[bool(expr) ? 1 : -1] \ ALLOW_UNUSED_TYPE // Implementation details of COMPILE_ASSERT: // // - COMPILE_ASSERT works by defining an array type that has -1 // elements (and thus is invalid) when the expression is false. // // - The simpler definition // // #define COMPILE_ASSERT(expr, msg) typedef char msg[(expr) ? 1 : -1] // // does not work, as gcc supports variable-length arrays whose sizes // are determined at run-time (this is gcc's extension and not part // of the C++ standard). As a result, gcc fails to reject the // following code with the simple definition: // // int foo; // COMPILE_ASSERT(foo, msg); // not supposed to compile as foo is // // not a compile-time constant. // // - By using the type CompileAssert<(bool(expr))>, we ensures that // expr is a compile-time constant. (Template arguments must be // determined at compile-time.) // // - The outer parentheses in CompileAssert<(bool(expr))> are necessary // to work around a bug in gcc 3.4.4 and 4.0.1. If we had written // // CompileAssert // // instead, these compilers will refuse to compile // // COMPILE_ASSERT(5 > 0, some_message); // // (They seem to think the ">" in "5 > 0" marks the end of the // template argument list.) // // - The array size is (bool(expr) ? 1 : -1), instead of simply // // ((expr) ? 1 : -1). // // This is to avoid running into a bug in MS VC 7.1, which // causes ((0.0) ? 1 : -1) to incorrectly evaluate to 1. #endif // !(__cplusplus >= 201103L) #endif // !defined(COMPILE_ASSERT) #endif // !BUILDING_CEF_SHARED #endif // CEF_INCLUDE_BASE_CEF_MACROS_H_ cefpython-49.0/src/include/base/cef_move.h000066400000000000000000000251501334103266300205310ustar00rootroot00000000000000// Copyright (c) 2014 Marshall A. Greenblatt. Portions copyright (c) 2012 // Google Inc. 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_BASE_CEF_MOVE_H_ #define CEF_INCLUDE_BASE_CEF_MOVE_H_ #if defined(MOVE_ONLY_TYPE_FOR_CPP_03) // Do nothing if the macro in this header has already been defined. // This can happen in cases where Chromium code is used directly by the // client application. When using Chromium code directly always include // the Chromium header first to avoid type conflicts. #elif defined(BUILDING_CEF_SHARED) // When building CEF include the Chromium header directly. #include "base/move.h" #else // !BUILDING_CEF_SHARED // The following is substantially similar to the Chromium implementation. // If the Chromium implementation diverges the below implementation should be // updated to match. // Macro with the boilerplate that makes a type move-only in C++03. // // USAGE // // This macro should be used instead of DISALLOW_COPY_AND_ASSIGN to create // a "move-only" type. Unlike DISALLOW_COPY_AND_ASSIGN, this macro should be // the first line in a class declaration. // // A class using this macro must call .Pass() (or somehow be an r-value already) // before it can be: // // * Passed as a function argument // * Used as the right-hand side of an assignment // * Returned from a function // // Each class will still need to define their own "move constructor" and "move // operator=" to make this useful. Here's an example of the macro, the move // constructor, and the move operator= from the scoped_ptr class: // // template // class scoped_ptr { // MOVE_ONLY_TYPE_FOR_CPP_03(scoped_ptr, RValue) // public: // scoped_ptr(RValue& other) : ptr_(other.release()) { } // scoped_ptr& operator=(RValue& other) { // swap(other); // return *this; // } // }; // // Note that the constructor must NOT be marked explicit. // // For consistency, the second parameter to the macro should always be RValue // unless you have a strong reason to do otherwise. It is only exposed as a // macro parameter so that the move constructor and move operator= don't look // like they're using a phantom type. // // // HOW THIS WORKS // // For a thorough explanation of this technique, see: // // http://en.wikibooks.org/wiki/More_C%2B%2B_Idioms/Move_Constructor // // The summary is that we take advantage of 2 properties: // // 1) non-const references will not bind to r-values. // 2) C++ can apply one user-defined conversion when initializing a // variable. // // The first lets us disable the copy constructor and assignment operator // by declaring private version of them with a non-const reference parameter. // // For l-values, direct initialization still fails like in // DISALLOW_COPY_AND_ASSIGN because the copy constructor and assignment // operators are private. // // For r-values, the situation is different. The copy constructor and // assignment operator are not viable due to (1), so we are trying to call // a non-existent constructor and non-existing operator= rather than a private // one. Since we have not committed an error quite yet, we can provide an // alternate conversion sequence and a constructor. We add // // * a private struct named "RValue" // * a user-defined conversion "operator RValue()" // * a "move constructor" and "move operator=" that take the RValue& as // their sole parameter. // // Only r-values will trigger this sequence and execute our "move constructor" // or "move operator=." L-values will match the private copy constructor and // operator= first giving a "private in this context" error. This combination // gives us a move-only type. // // For signaling a destructive transfer of data from an l-value, we provide a // method named Pass() which creates an r-value for the current instance // triggering the move constructor or move operator=. // // Other ways to get r-values is to use the result of an expression like a // function call. // // Here's an example with comments explaining what gets triggered where: // // class Foo { // MOVE_ONLY_TYPE_FOR_CPP_03(Foo, RValue); // // public: // ... API ... // Foo(RValue other); // Move constructor. // Foo& operator=(RValue rhs); // Move operator= // }; // // Foo MakeFoo(); // Function that returns a Foo. // // Foo f; // Foo f_copy(f); // ERROR: Foo(Foo&) is private in this context. // Foo f_assign; // f_assign = f; // ERROR: operator=(Foo&) is private in this context. // // // Foo f(MakeFoo()); // R-value so alternate conversion executed. // Foo f_copy(f.Pass()); // R-value so alternate conversion executed. // f = f_copy.Pass(); // R-value so alternate conversion executed. // // // IMPLEMENTATION SUBTLETIES WITH RValue // // The RValue struct is just a container for a pointer back to the original // object. It should only ever be created as a temporary, and no external // class should ever declare it or use it in a parameter. // // It is tempting to want to use the RValue type in function parameters, but // excluding the limited usage here for the move constructor and move // operator=, doing so would mean that the function could take both r-values // and l-values equially which is unexpected. See COMPARED To Boost.Move for // more details. // // An alternate, and incorrect, implementation of the RValue class used by // Boost.Move makes RValue a fieldless child of the move-only type. RValue& // is then used in place of RValue in the various operators. The RValue& is // "created" by doing *reinterpret_cast(this). This has the appeal // of never creating a temporary RValue struct even with optimizations // disabled. Also, by virtue of inheritance you can treat the RValue // reference as if it were the move-only type itself. Unfortunately, // using the result of this reinterpret_cast<> is actually undefined behavior // due to C++98 5.2.10.7. In certain compilers (e.g., NaCl) the optimizer // will generate non-working code. // // In optimized builds, both implementations generate the same assembly so we // choose the one that adheres to the standard. // // // WHY HAVE typedef void MoveOnlyTypeForCPP03 // // Callback<>/Bind() needs to understand movable-but-not-copyable semantics // to call .Pass() appropriately when it is expected to transfer the value. // The cryptic typedef MoveOnlyTypeForCPP03 is added to make this check // easy and automatic in helper templates for Callback<>/Bind(). // See IsMoveOnlyType template and its usage in base/callback_internal.h // for more details. // // // COMPARED TO C++11 // // In C++11, you would implement this functionality using an r-value reference // and our .Pass() method would be replaced with a call to std::move(). // // This emulation also has a deficiency where it uses up the single // user-defined conversion allowed by C++ during initialization. This can // cause problems in some API edge cases. For instance, in scoped_ptr, it is // impossible to make a function "void Foo(scoped_ptr p)" accept a // value of type scoped_ptr even if you add a constructor to // scoped_ptr<> that would make it look like it should work. C++11 does not // have this deficiency. // // // COMPARED TO Boost.Move // // Our implementation similar to Boost.Move, but we keep the RValue struct // private to the move-only type, and we don't use the reinterpret_cast<> hack. // // In Boost.Move, RValue is the boost::rv<> template. This type can be used // when writing APIs like: // // void MyFunc(boost::rv& f) // // that can take advantage of rv<> to avoid extra copies of a type. However you // would still be able to call this version of MyFunc with an l-value: // // Foo f; // MyFunc(f); // Uh oh, we probably just destroyed |f| w/o calling Pass(). // // unless someone is very careful to also declare a parallel override like: // // void MyFunc(const Foo& f) // // that would catch the l-values first. This was declared unsafe in C++11 and // a C++11 compiler will explicitly fail MyFunc(f). Unfortunately, we cannot // ensure this in C++03. // // Since we have no need for writing such APIs yet, our implementation keeps // RValue private and uses a .Pass() method to do the conversion instead of // trying to write a version of "std::move()." Writing an API like std::move() // would require the RValue struct to be public. // // // CAVEATS // // If you include a move-only type as a field inside a class that does not // explicitly declare a copy constructor, the containing class's implicit // copy constructor will change from Containing(const Containing&) to // Containing(Containing&). This can cause some unexpected errors. // // http://llvm.org/bugs/show_bug.cgi?id=11528 // // The workaround is to explicitly declare your copy constructor. // #define MOVE_ONLY_TYPE_FOR_CPP_03(type, rvalue_type) \ private: \ struct rvalue_type { \ explicit rvalue_type(type* object) : object(object) {} \ type* object; \ }; \ type(type&); \ void operator=(type&); \ public: \ operator rvalue_type() { return rvalue_type(this); } \ type Pass() { return type(rvalue_type(this)); } \ typedef void MoveOnlyTypeForCPP03; \ private: #endif // !BUILDING_CEF_SHARED #endif // CEF_INCLUDE_BASE_CEF_MOVE_H_ cefpython-49.0/src/include/base/cef_platform_thread.h000066400000000000000000000105541334103266300227400ustar00rootroot00000000000000// Copyright (c) 2014 Marshall A. Greenblatt. Portions copyright (c) 2011 // Google Inc. 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. // WARNING: You should *NOT* be using this class directly. PlatformThread is // the low-level platform-specific abstraction to the OS's threading interface. // You should instead be using a message-loop driven Thread, see thread.h. #ifndef CEF_INCLUDE_BASE_PLATFORM_THREAD_H_ #define CEF_INCLUDE_BASE_PLATFORM_THREAD_H_ #if defined(BASE_THREADING_PLATFORM_THREAD_H_) // Do nothing if the Chromium header has already been included. // This can happen in cases where Chromium code is used directly by the // client application. When using Chromium code directly always include // the Chromium header first to avoid type conflicts. #elif defined(BUILDING_CEF_SHARED) // When building CEF include the Chromium header directly. #include "base/threading/platform_thread.h" #else // !BUILDING_CEF_SHARED // The following is substantially similar to the Chromium implementation. // If the Chromium implementation diverges the below implementation should be // updated to match. #include "include/base/cef_basictypes.h" #include "include/base/cef_build.h" #include "include/internal/cef_thread_internal.h" namespace base { // Used for logging. Always an integer value. typedef cef_platform_thread_id_t PlatformThreadId; // Used for thread checking and debugging. // Meant to be as fast as possible. // These are produced by PlatformThread::CurrentRef(), and used to later // check if we are on the same thread or not by using ==. These are safe // to copy between threads, but can't be copied to another process as they // have no meaning there. Also, the internal identifier can be re-used // after a thread dies, so a PlatformThreadRef cannot be reliably used // to distinguish a new thread from an old, dead thread. class PlatformThreadRef { public: typedef cef_platform_thread_handle_t RefType; PlatformThreadRef() : id_(0) { } explicit PlatformThreadRef(RefType id) : id_(id) { } bool operator==(PlatformThreadRef other) const { return id_ == other.id_; } bool is_null() const { return id_ == 0; } private: RefType id_; }; // A namespace for low-level thread functions. // Chromium uses a class with static methods but CEF uses an actual namespace // to avoid linker problems with the sandbox libaries on Windows. namespace PlatformThread { // Gets the current thread id, which may be useful for logging purposes. inline PlatformThreadId CurrentId() { return cef_get_current_platform_thread_id(); } // Gets the current thread reference, which can be used to check if // we're on the right thread quickly. inline PlatformThreadRef CurrentRef() { return PlatformThreadRef(cef_get_current_platform_thread_handle()); } } // namespace PlatformThread } // namespace base #endif // !BUILDING_CEF_SHARED #endif // CEF_INCLUDE_BASE_PLATFORM_THREAD_H_ cefpython-49.0/src/include/base/cef_ref_counted.h000066400000000000000000000241011334103266300220530ustar00rootroot00000000000000// Copyright (c) 2014 Marshall A. Greenblatt. Portions copyright (c) 2012 // Google Inc. 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_BASE_CEF_REF_COUNTED_H_ #define CEF_INCLUDE_BASE_CEF_REF_COUNTED_H_ #pragma once #if defined(BASE_MEMORY_REF_COUNTED_H_) // Do nothing if the Chromium header has already been included. // This can happen in cases where Chromium code is used directly by the // client application. When using Chromium code directly always include // the Chromium header first to avoid type conflicts. #elif defined(BUILDING_CEF_SHARED) // When building CEF include the Chromium header directly. #include "base/memory/ref_counted.h" #else // !BUILDING_CEF_SHARED // The following is substantially similar to the Chromium implementation. // If the Chromium implementation diverges the below implementation should be // updated to match. #include #include "include/base/cef_atomic_ref_count.h" #include "include/base/cef_build.h" #ifndef NDEBUG #include "include/base/cef_logging.h" #endif #include "include/base/cef_thread_collision_warner.h" namespace base { namespace cef_subtle { class RefCountedBase { public: bool HasOneRef() const { return ref_count_ == 1; } protected: RefCountedBase() : ref_count_(0) #ifndef NDEBUG , in_dtor_(false) #endif { } ~RefCountedBase() { #ifndef NDEBUG DCHECK(in_dtor_) << "RefCounted object deleted without calling Release()"; #endif } void AddRef() const { // TODO(maruel): Add back once it doesn't assert 500 times/sec. // Current thread books the critical section "AddRelease" // without release it. // DFAKE_SCOPED_LOCK_THREAD_LOCKED(add_release_); #ifndef NDEBUG DCHECK(!in_dtor_); #endif ++ref_count_; } // Returns true if the object should self-delete. bool Release() const { // TODO(maruel): Add back once it doesn't assert 500 times/sec. // Current thread books the critical section "AddRelease" // without release it. // DFAKE_SCOPED_LOCK_THREAD_LOCKED(add_release_); #ifndef NDEBUG DCHECK(!in_dtor_); #endif if (--ref_count_ == 0) { #ifndef NDEBUG in_dtor_ = true; #endif return true; } return false; } private: mutable int ref_count_; #ifndef NDEBUG mutable bool in_dtor_; #endif DFAKE_MUTEX(add_release_); DISALLOW_COPY_AND_ASSIGN(RefCountedBase); }; class RefCountedThreadSafeBase { public: bool HasOneRef() const; protected: RefCountedThreadSafeBase(); ~RefCountedThreadSafeBase(); void AddRef() const; // Returns true if the object should self-delete. bool Release() const; private: mutable AtomicRefCount ref_count_; #ifndef NDEBUG mutable bool in_dtor_; #endif DISALLOW_COPY_AND_ASSIGN(RefCountedThreadSafeBase); }; } // namespace cef_subtle // // A base class for reference counted classes. Otherwise, known as a cheap // knock-off of WebKit's RefCounted class. To use this guy just extend your // class from it like so: // // class MyFoo : public base::RefCounted { // ... // private: // friend class base::RefCounted; // ~MyFoo(); // }; // // You should always make your destructor private, to avoid any code deleting // the object accidently while there are references to it. template class RefCounted : public cef_subtle::RefCountedBase { public: RefCounted() {} void AddRef() const { cef_subtle::RefCountedBase::AddRef(); } void Release() const { if (cef_subtle::RefCountedBase::Release()) { delete static_cast(this); } } protected: ~RefCounted() {} private: DISALLOW_COPY_AND_ASSIGN(RefCounted); }; // Forward declaration. template class RefCountedThreadSafe; // Default traits for RefCountedThreadSafe. Deletes the object when its ref // count reaches 0. Overload to delete it on a different thread etc. template struct DefaultRefCountedThreadSafeTraits { static void Destruct(const T* x) { // Delete through RefCountedThreadSafe to make child classes only need to be // friend with RefCountedThreadSafe instead of this struct, which is an // implementation detail. RefCountedThreadSafe::DeleteInternal(x); } }; // // A thread-safe variant of RefCounted // // class MyFoo : public base::RefCountedThreadSafe { // ... // }; // // If you're using the default trait, then you should add compile time // asserts that no one else is deleting your object. i.e. // private: // friend class base::RefCountedThreadSafe; // ~MyFoo(); template > class RefCountedThreadSafe : public cef_subtle::RefCountedThreadSafeBase { public: RefCountedThreadSafe() {} void AddRef() const { cef_subtle::RefCountedThreadSafeBase::AddRef(); } void Release() const { if (cef_subtle::RefCountedThreadSafeBase::Release()) { Traits::Destruct(static_cast(this)); } } protected: ~RefCountedThreadSafe() {} private: friend struct DefaultRefCountedThreadSafeTraits; static void DeleteInternal(const T* x) { delete x; } DISALLOW_COPY_AND_ASSIGN(RefCountedThreadSafe); }; // // A thread-safe wrapper for some piece of data so we can place other // things in scoped_refptrs<>. // template class RefCountedData : public base::RefCountedThreadSafe< base::RefCountedData > { public: RefCountedData() : data() {} RefCountedData(const T& in_value) : data(in_value) {} T data; private: friend class base::RefCountedThreadSafe >; ~RefCountedData() {} }; } // namespace base // // A smart pointer class for reference counted objects. Use this class instead // of calling AddRef and Release manually on a reference counted object to // avoid common memory leaks caused by forgetting to Release an object // reference. Sample usage: // // class MyFoo : public RefCounted { // ... // }; // // void some_function() { // scoped_refptr foo = new MyFoo(); // foo->Method(param); // // |foo| is released when this function returns // } // // void some_other_function() { // scoped_refptr foo = new MyFoo(); // ... // foo = NULL; // explicitly releases |foo| // ... // if (foo) // foo->Method(param); // } // // The above examples show how scoped_refptr acts like a pointer to T. // Given two scoped_refptr classes, it is also possible to exchange // references between the two objects, like so: // // { // scoped_refptr a = new MyFoo(); // scoped_refptr b; // // b.swap(a); // // now, |b| references the MyFoo object, and |a| references NULL. // } // // To make both |a| and |b| in the above example reference the same MyFoo // object, simply use the assignment operator: // // { // scoped_refptr a = new MyFoo(); // scoped_refptr b; // // b = a; // // now, |a| and |b| each own a reference to the same MyFoo object. // } // template class scoped_refptr { public: typedef T element_type; scoped_refptr() : ptr_(NULL) { } scoped_refptr(T* p) : ptr_(p) { if (ptr_) ptr_->AddRef(); } scoped_refptr(const scoped_refptr& r) : ptr_(r.ptr_) { if (ptr_) ptr_->AddRef(); } template scoped_refptr(const scoped_refptr& r) : ptr_(r.get()) { if (ptr_) ptr_->AddRef(); } ~scoped_refptr() { if (ptr_) ptr_->Release(); } T* get() const { return ptr_; } // Allow scoped_refptr to be used in boolean expression // and comparison operations. operator T*() const { return ptr_; } T* operator->() const { assert(ptr_ != NULL); return ptr_; } scoped_refptr& operator=(T* p) { // AddRef first so that self assignment should work if (p) p->AddRef(); T* old_ptr = ptr_; ptr_ = p; if (old_ptr) old_ptr->Release(); return *this; } scoped_refptr& operator=(const scoped_refptr& r) { return *this = r.ptr_; } template scoped_refptr& operator=(const scoped_refptr& r) { return *this = r.get(); } void swap(T** pp) { T* p = ptr_; ptr_ = *pp; *pp = p; } void swap(scoped_refptr& r) { swap(&r.ptr_); } protected: T* ptr_; }; // Handy utility for creating a scoped_refptr out of a T* explicitly without // having to retype all the template arguments template scoped_refptr make_scoped_refptr(T* t) { return scoped_refptr(t); } #endif // !BUILDING_CEF_SHARED #endif // CEF_INCLUDE_BASE_CEF_REF_COUNTED_H_ cefpython-49.0/src/include/base/cef_scoped_ptr.h000066400000000000000000000603331334103266300217270ustar00rootroot00000000000000// Copyright (c) 2014 Marshall A. Greenblatt. Portions copyright (c) 2012 // Google Inc. 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. // Scopers help you manage ownership of a pointer, helping you easily manage a // pointer within a scope, and automatically destroying the pointer at the end // of a scope. There are two main classes you will use, which correspond to the // operators new/delete and new[]/delete[]. // // Example usage (scoped_ptr): // { // scoped_ptr foo(new Foo("wee")); // } // foo goes out of scope, releasing the pointer with it. // // { // scoped_ptr foo; // No pointer managed. // foo.reset(new Foo("wee")); // Now a pointer is managed. // foo.reset(new Foo("wee2")); // Foo("wee") was destroyed. // foo.reset(new Foo("wee3")); // Foo("wee2") was destroyed. // foo->Method(); // Foo::Method() called. // foo.get()->Method(); // Foo::Method() called. // SomeFunc(foo.release()); // SomeFunc takes ownership, foo no longer // // manages a pointer. // foo.reset(new Foo("wee4")); // foo manages a pointer again. // foo.reset(); // Foo("wee4") destroyed, foo no longer // // manages a pointer. // } // foo wasn't managing a pointer, so nothing was destroyed. // // Example usage (scoped_ptr): // { // scoped_ptr foo(new Foo[100]); // foo.get()->Method(); // Foo::Method on the 0th element. // foo[10].Method(); // Foo::Method on the 10th element. // } // // These scopers also implement part of the functionality of C++11 unique_ptr // in that they are "movable but not copyable." You can use the scopers in // the parameter and return types of functions to signify ownership transfer // in to and out of a function. When calling a function that has a scoper // as the argument type, it must be called with the result of an analogous // scoper's Pass() function or another function that generates a temporary; // passing by copy will NOT work. Here is an example using scoped_ptr: // // void TakesOwnership(scoped_ptr arg) { // // Do something with arg // } // scoped_ptr CreateFoo() { // // No need for calling Pass() because we are constructing a temporary // // for the return value. // return scoped_ptr(new Foo("new")); // } // scoped_ptr PassThru(scoped_ptr arg) { // return arg.Pass(); // } // // { // scoped_ptr ptr(new Foo("yay")); // ptr manages Foo("yay"). // TakesOwnership(ptr.Pass()); // ptr no longer owns Foo("yay"). // scoped_ptr ptr2 = CreateFoo(); // ptr2 owns the return Foo. // scoped_ptr ptr3 = // ptr3 now owns what was in ptr2. // PassThru(ptr2.Pass()); // ptr2 is correspondingly NULL. // } // // Notice that if you do not call Pass() when returning from PassThru(), or // when invoking TakesOwnership(), the code will not compile because scopers // are not copyable; they only implement move semantics which require calling // the Pass() function to signify a destructive transfer of state. CreateFoo() // is different though because we are constructing a temporary on the return // line and thus can avoid needing to call Pass(). // // Pass() properly handles upcast in initialization, i.e. you can use a // scoped_ptr to initialize a scoped_ptr: // // scoped_ptr foo(new Foo()); // scoped_ptr parent(foo.Pass()); // // PassAs<>() should be used to upcast return value in return statement: // // scoped_ptr CreateFoo() { // scoped_ptr result(new FooChild()); // return result.PassAs(); // } // // Note that PassAs<>() is implemented only for scoped_ptr, but not for // scoped_ptr. This is because casting array pointers may not be safe. #ifndef CEF_INCLUDE_BASE_CEF_MEMORY_SCOPED_PTR_H_ #define CEF_INCLUDE_BASE_CEF_MEMORY_SCOPED_PTR_H_ #pragma once #if defined(BASE_MEMORY_SCOPED_PTR_H_) // Do nothing if the Chromium header has already been included. // This can happen in cases where Chromium code is used directly by the // client application. When using Chromium code directly always include // the Chromium header first to avoid type conflicts. #elif defined(BUILDING_CEF_SHARED) // When building CEF include the Chromium header directly. #include "base/memory/scoped_ptr.h" #else // !BUILDING_CEF_SHARED // The following is substantially similar to the Chromium implementation. // If the Chromium implementation diverges the below implementation should be // updated to match. // This is an implementation designed to match the anticipated future TR2 // implementation of the scoped_ptr class. #include #include #include #include // For std::swap(). #include "include/base/cef_basictypes.h" #include "include/base/cef_build.h" #include "include/base/cef_macros.h" #include "include/base/cef_move.h" #include "include/base/cef_template_util.h" namespace base { namespace subtle { class RefCountedBase; class RefCountedThreadSafeBase; } // namespace subtle // Function object which deletes its parameter, which must be a pointer. // If C is an array type, invokes 'delete[]' on the parameter; otherwise, // invokes 'delete'. The default deleter for scoped_ptr. template struct DefaultDeleter { DefaultDeleter() {} template DefaultDeleter(const DefaultDeleter& other) { // IMPLEMENTATION NOTE: C++11 20.7.1.1.2p2 only provides this constructor // if U* is implicitly convertible to T* and U is not an array type. // // Correct implementation should use SFINAE to disable this // constructor. However, since there are no other 1-argument constructors, // using a COMPILE_ASSERT() based on is_convertible<> and requiring // complete types is simpler and will cause compile failures for equivalent // misuses. // // Note, the is_convertible check also ensures that U is not an // array. T is guaranteed to be a non-array, so any U* where U is an array // cannot convert to T*. enum { T_must_be_complete = sizeof(T) }; enum { U_must_be_complete = sizeof(U) }; COMPILE_ASSERT((base::is_convertible::value), U_ptr_must_implicitly_convert_to_T_ptr); } inline void operator()(T* ptr) const { enum { type_must_be_complete = sizeof(T) }; delete ptr; } }; // Specialization of DefaultDeleter for array types. template struct DefaultDeleter { inline void operator()(T* ptr) const { enum { type_must_be_complete = sizeof(T) }; delete[] ptr; } private: // Disable this operator for any U != T because it is undefined to execute // an array delete when the static type of the array mismatches the dynamic // type. // // References: // C++98 [expr.delete]p3 // http://cplusplus.github.com/LWG/lwg-defects.html#938 template void operator()(U* array) const; }; template struct DefaultDeleter { // Never allow someone to declare something like scoped_ptr. COMPILE_ASSERT(sizeof(T) == -1, do_not_use_array_with_size_as_type); }; // Function object which invokes 'free' on its parameter, which must be // a pointer. Can be used to store malloc-allocated pointers in scoped_ptr: // // scoped_ptr foo_ptr( // static_cast(malloc(sizeof(int)))); struct FreeDeleter { inline void operator()(void* ptr) const { free(ptr); } }; namespace cef_internal { template struct IsNotRefCounted { enum { value = !base::is_convertible::value && !base::is_convertible:: value }; }; // Minimal implementation of the core logic of scoped_ptr, suitable for // reuse in both scoped_ptr and its specializations. template class scoped_ptr_impl { public: explicit scoped_ptr_impl(T* p) : data_(p) { } // Initializer for deleters that have data parameters. scoped_ptr_impl(T* p, const D& d) : data_(p, d) {} // Templated constructor that destructively takes the value from another // scoped_ptr_impl. template scoped_ptr_impl(scoped_ptr_impl* other) : data_(other->release(), other->get_deleter()) { // We do not support move-only deleters. We could modify our move // emulation to have base::subtle::move() and base::subtle::forward() // functions that are imperfect emulations of their C++11 equivalents, // but until there's a requirement, just assume deleters are copyable. } template void TakeState(scoped_ptr_impl* other) { // See comment in templated constructor above regarding lack of support // for move-only deleters. reset(other->release()); get_deleter() = other->get_deleter(); } ~scoped_ptr_impl() { if (data_.ptr != NULL) { // Not using get_deleter() saves one function call in non-optimized // builds. static_cast(data_)(data_.ptr); } } void reset(T* p) { // This is a self-reset, which is no longer allowed: http://crbug.com/162971 if (p != NULL && p == data_.ptr) abort(); // Note that running data_.ptr = p can lead to undefined behavior if // get_deleter()(get()) deletes this. In order to prevent this, reset() // should update the stored pointer before deleting its old value. // // However, changing reset() to use that behavior may cause current code to // break in unexpected ways. If the destruction of the owned object // dereferences the scoped_ptr when it is destroyed by a call to reset(), // then it will incorrectly dispatch calls to |p| rather than the original // value of |data_.ptr|. // // During the transition period, set the stored pointer to NULL while // deleting the object. Eventually, this safety check will be removed to // prevent the scenario initially described from occuring and // http://crbug.com/176091 can be closed. T* old = data_.ptr; data_.ptr = NULL; if (old != NULL) static_cast(data_)(old); data_.ptr = p; } T* get() const { return data_.ptr; } D& get_deleter() { return data_; } const D& get_deleter() const { return data_; } void swap(scoped_ptr_impl& p2) { // Standard swap idiom: 'using std::swap' ensures that std::swap is // present in the overload set, but we call swap unqualified so that // any more-specific overloads can be used, if available. using std::swap; swap(static_cast(data_), static_cast(p2.data_)); swap(data_.ptr, p2.data_.ptr); } T* release() { T* old_ptr = data_.ptr; data_.ptr = NULL; return old_ptr; } private: // Needed to allow type-converting constructor. template friend class scoped_ptr_impl; // Use the empty base class optimization to allow us to have a D // member, while avoiding any space overhead for it when D is an // empty class. See e.g. http://www.cantrip.org/emptyopt.html for a good // discussion of this technique. struct Data : public D { explicit Data(T* ptr_in) : ptr(ptr_in) {} Data(T* ptr_in, const D& other) : D(other), ptr(ptr_in) {} T* ptr; }; Data data_; DISALLOW_COPY_AND_ASSIGN(scoped_ptr_impl); }; } // namespace cef_internal } // namespace base // A scoped_ptr is like a T*, except that the destructor of scoped_ptr // automatically deletes the pointer it holds (if any). // That is, scoped_ptr owns the T object that it points to. // Like a T*, a scoped_ptr may hold either NULL or a pointer to a T object. // Also like T*, scoped_ptr is thread-compatible, and once you // dereference it, you get the thread safety guarantees of T. // // The size of scoped_ptr is small. On most compilers, when using the // DefaultDeleter, sizeof(scoped_ptr) == sizeof(T*). Custom deleters will // increase the size proportional to whatever state they need to have. See // comments inside scoped_ptr_impl<> for details. // // Current implementation targets having a strict subset of C++11's // unique_ptr<> features. Known deficiencies include not supporting move-only // deleteres, function pointers as deleters, and deleters with reference // types. template > class scoped_ptr { MOVE_ONLY_TYPE_FOR_CPP_03(scoped_ptr, RValue) COMPILE_ASSERT(base::cef_internal::IsNotRefCounted::value, T_is_refcounted_type_and_needs_scoped_refptr); public: // The element and deleter types. typedef T element_type; typedef D deleter_type; // Constructor. Defaults to initializing with NULL. scoped_ptr() : impl_(NULL) { } // Constructor. Takes ownership of p. explicit scoped_ptr(element_type* p) : impl_(p) { } // Constructor. Allows initialization of a stateful deleter. scoped_ptr(element_type* p, const D& d) : impl_(p, d) { } // Constructor. Allows construction from a scoped_ptr rvalue for a // convertible type and deleter. // // IMPLEMENTATION NOTE: C++11 unique_ptr<> keeps this constructor distinct // from the normal move constructor. By C++11 20.7.1.2.1.21, this constructor // has different post-conditions if D is a reference type. Since this // implementation does not support deleters with reference type, // we do not need a separate move constructor allowing us to avoid one // use of SFINAE. You only need to care about this if you modify the // implementation of scoped_ptr. template scoped_ptr(scoped_ptr other) : impl_(&other.impl_) { COMPILE_ASSERT(!base::is_array::value, U_cannot_be_an_array); } // Constructor. Move constructor for C++03 move emulation of this type. scoped_ptr(RValue rvalue) : impl_(&rvalue.object->impl_) { } // operator=. Allows assignment from a scoped_ptr rvalue for a convertible // type and deleter. // // IMPLEMENTATION NOTE: C++11 unique_ptr<> keeps this operator= distinct from // the normal move assignment operator. By C++11 20.7.1.2.3.4, this templated // form has different requirements on for move-only Deleters. Since this // implementation does not support move-only Deleters, we do not need a // separate move assignment operator allowing us to avoid one use of SFINAE. // You only need to care about this if you modify the implementation of // scoped_ptr. template scoped_ptr& operator=(scoped_ptr rhs) { COMPILE_ASSERT(!base::is_array::value, U_cannot_be_an_array); impl_.TakeState(&rhs.impl_); return *this; } // Reset. Deletes the currently owned object, if any. // Then takes ownership of a new object, if given. void reset(element_type* p = NULL) { impl_.reset(p); } // Accessors to get the owned object. // operator* and operator-> will assert() if there is no current object. element_type& operator*() const { assert(impl_.get() != NULL); return *impl_.get(); } element_type* operator->() const { assert(impl_.get() != NULL); return impl_.get(); } element_type* get() const { return impl_.get(); } // Access to the deleter. deleter_type& get_deleter() { return impl_.get_deleter(); } const deleter_type& get_deleter() const { return impl_.get_deleter(); } // Allow scoped_ptr to be used in boolean expressions, but not // implicitly convertible to a real bool (which is dangerous). // // Note that this trick is only safe when the == and != operators // are declared explicitly, as otherwise "scoped_ptr1 == // scoped_ptr2" will compile but do the wrong thing (i.e., convert // to Testable and then do the comparison). private: typedef base::cef_internal::scoped_ptr_impl scoped_ptr::*Testable; public: operator Testable() const { return impl_.get() ? &scoped_ptr::impl_ : NULL; } // Comparison operators. // These return whether two scoped_ptr refer to the same object, not just to // two different but equal objects. bool operator==(const element_type* p) const { return impl_.get() == p; } bool operator!=(const element_type* p) const { return impl_.get() != p; } // Swap two scoped pointers. void swap(scoped_ptr& p2) { impl_.swap(p2.impl_); } // Release a pointer. // The return value is the current pointer held by this object. // If this object holds a NULL pointer, the return value is NULL. // After this operation, this object will hold a NULL pointer, // and will not own the object any more. element_type* release() WARN_UNUSED_RESULT { return impl_.release(); } // C++98 doesn't support functions templates with default parameters which // makes it hard to write a PassAs() that understands converting the deleter // while preserving simple calling semantics. // // Until there is a use case for PassAs() with custom deleters, just ignore // the custom deleter. template scoped_ptr PassAs() { return scoped_ptr(Pass()); } private: // Needed to reach into |impl_| in the constructor. template friend class scoped_ptr; base::cef_internal::scoped_ptr_impl impl_; // Forbidden for API compatibility with std::unique_ptr. explicit scoped_ptr(int disallow_construction_from_null); // Forbid comparison of scoped_ptr types. If U != T, it totally // doesn't make sense, and if U == T, it still doesn't make sense // because you should never have the same object owned by two different // scoped_ptrs. template bool operator==(scoped_ptr const& p2) const; template bool operator!=(scoped_ptr const& p2) const; }; template class scoped_ptr { MOVE_ONLY_TYPE_FOR_CPP_03(scoped_ptr, RValue) public: // The element and deleter types. typedef T element_type; typedef D deleter_type; // Constructor. Defaults to initializing with NULL. scoped_ptr() : impl_(NULL) { } // Constructor. Stores the given array. Note that the argument's type // must exactly match T*. In particular: // - it cannot be a pointer to a type derived from T, because it is // inherently unsafe in the general case to access an array through a // pointer whose dynamic type does not match its static type (eg., if // T and the derived types had different sizes access would be // incorrectly calculated). Deletion is also always undefined // (C++98 [expr.delete]p3). If you're doing this, fix your code. // - it cannot be NULL, because NULL is an integral expression, not a // pointer to T. Use the no-argument version instead of explicitly // passing NULL. // - it cannot be const-qualified differently from T per unique_ptr spec // (http://cplusplus.github.com/LWG/lwg-active.html#2118). Users wanting // to work around this may use implicit_cast(). // However, because of the first bullet in this comment, users MUST // NOT use implicit_cast() to upcast the static type of the array. explicit scoped_ptr(element_type* array) : impl_(array) { } // Constructor. Move constructor for C++03 move emulation of this type. scoped_ptr(RValue rvalue) : impl_(&rvalue.object->impl_) { } // operator=. Move operator= for C++03 move emulation of this type. scoped_ptr& operator=(RValue rhs) { impl_.TakeState(&rhs.object->impl_); return *this; } // Reset. Deletes the currently owned array, if any. // Then takes ownership of a new object, if given. void reset(element_type* array = NULL) { impl_.reset(array); } // Accessors to get the owned array. element_type& operator[](size_t i) const { assert(impl_.get() != NULL); return impl_.get()[i]; } element_type* get() const { return impl_.get(); } // Access to the deleter. deleter_type& get_deleter() { return impl_.get_deleter(); } const deleter_type& get_deleter() const { return impl_.get_deleter(); } // Allow scoped_ptr to be used in boolean expressions, but not // implicitly convertible to a real bool (which is dangerous). private: typedef base::cef_internal::scoped_ptr_impl scoped_ptr::*Testable; public: operator Testable() const { return impl_.get() ? &scoped_ptr::impl_ : NULL; } // Comparison operators. // These return whether two scoped_ptr refer to the same object, not just to // two different but equal objects. bool operator==(element_type* array) const { return impl_.get() == array; } bool operator!=(element_type* array) const { return impl_.get() != array; } // Swap two scoped pointers. void swap(scoped_ptr& p2) { impl_.swap(p2.impl_); } // Release a pointer. // The return value is the current pointer held by this object. // If this object holds a NULL pointer, the return value is NULL. // After this operation, this object will hold a NULL pointer, // and will not own the object any more. element_type* release() WARN_UNUSED_RESULT { return impl_.release(); } private: // Force element_type to be a complete type. enum { type_must_be_complete = sizeof(element_type) }; // Actually hold the data. base::cef_internal::scoped_ptr_impl impl_; // Disable initialization from any type other than element_type*, by // providing a constructor that matches such an initialization, but is // private and has no definition. This is disabled because it is not safe to // call delete[] on an array whose static type does not match its dynamic // type. template explicit scoped_ptr(U* array); explicit scoped_ptr(int disallow_construction_from_null); // Disable reset() from any type other than element_type*, for the same // reasons as the constructor above. template void reset(U* array); void reset(int disallow_reset_from_null); // Forbid comparison of scoped_ptr types. If U != T, it totally // doesn't make sense, and if U == T, it still doesn't make sense // because you should never have the same object owned by two different // scoped_ptrs. template bool operator==(scoped_ptr const& p2) const; template bool operator!=(scoped_ptr const& p2) const; }; // Free functions template void swap(scoped_ptr& p1, scoped_ptr& p2) { p1.swap(p2); } template bool operator==(T* p1, const scoped_ptr& p2) { return p1 == p2.get(); } template bool operator!=(T* p1, const scoped_ptr& p2) { return p1 != p2.get(); } // A function to convert T* into scoped_ptr // Doing e.g. make_scoped_ptr(new FooBarBaz(arg)) is a shorter notation // for scoped_ptr >(new FooBarBaz(arg)) template scoped_ptr make_scoped_ptr(T* ptr) { return scoped_ptr(ptr); } #endif // !BUILDING_CEF_SHARED #endif // CEF_INCLUDE_BASE_CEF_MEMORY_SCOPED_PTR_H_ cefpython-49.0/src/include/base/cef_string16.h000066400000000000000000000212431334103266300212370ustar00rootroot00000000000000// Copyright (c) 2014 Marshall A. Greenblatt. Portions copyright (c) 2013 // Google Inc. 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_BASE_CEF_STRING16_H_ #define CEF_INCLUDE_BASE_CEF_STRING16_H_ #pragma once #if defined(BASE_STRINGS_STRING16_H_) // Do nothing if the Chromium header has already been included. // This can happen in cases where Chromium code is used directly by the // client application. When using Chromium code directly always include // the Chromium header first to avoid type conflicts. #elif defined(BUILDING_CEF_SHARED) // When building CEF include the Chromium header directly. #include "base/strings/string16.h" #else // !BUILDING_CEF_SHARED // The following is substantially similar to the Chromium implementation. // If the Chromium implementation diverges the below implementation should be // updated to match. // WHAT: // A version of std::basic_string that provides 2-byte characters even when // wchar_t is not implemented as a 2-byte type. You can access this class as // string16. We also define char16, which string16 is based upon. // // WHY: // On Windows, wchar_t is 2 bytes, and it can conveniently handle UTF-16/UCS-2 // data. Plenty of existing code operates on strings encoded as UTF-16. // // On many other platforms, sizeof(wchar_t) is 4 bytes by default. We can make // it 2 bytes by using the GCC flag -fshort-wchar. But then std::wstring fails // at run time, because it calls some functions (like wcslen) that come from // the system's native C library -- which was built with a 4-byte wchar_t! // It's wasteful to use 4-byte wchar_t strings to carry UTF-16 data, and it's // entirely improper on those systems where the encoding of wchar_t is defined // as UTF-32. // // Here, we define string16, which is similar to std::wstring but replaces all // libc functions with custom, 2-byte-char compatible routines. It is capable // of carrying UTF-16-encoded data. #include #include #include "include/base/cef_basictypes.h" #if defined(WCHAR_T_IS_UTF16) namespace base { typedef wchar_t char16; typedef std::wstring string16; typedef std::char_traits string16_char_traits; } // namespace base #elif defined(WCHAR_T_IS_UTF32) #include // For uint16_t #include "include/base/cef_macros.h" namespace base { typedef uint16_t char16; // char16 versions of the functions required by string16_char_traits; these // are based on the wide character functions of similar names ("w" or "wcs" // instead of "c16"). int c16memcmp(const char16* s1, const char16* s2, size_t n); size_t c16len(const char16* s); const char16* c16memchr(const char16* s, char16 c, size_t n); char16* c16memmove(char16* s1, const char16* s2, size_t n); char16* c16memcpy(char16* s1, const char16* s2, size_t n); char16* c16memset(char16* s, char16 c, size_t n); struct string16_char_traits { typedef char16 char_type; typedef int int_type; // int_type needs to be able to hold each possible value of char_type, and in // addition, the distinct value of eof(). COMPILE_ASSERT(sizeof(int_type) > sizeof(char_type), unexpected_type_width); typedef std::streamoff off_type; typedef mbstate_t state_type; typedef std::fpos pos_type; static void assign(char_type& c1, const char_type& c2) { c1 = c2; } static bool eq(const char_type& c1, const char_type& c2) { return c1 == c2; } static bool lt(const char_type& c1, const char_type& c2) { return c1 < c2; } static int compare(const char_type* s1, const char_type* s2, size_t n) { return c16memcmp(s1, s2, n); } static size_t length(const char_type* s) { return c16len(s); } static const char_type* find(const char_type* s, size_t n, const char_type& a) { return c16memchr(s, a, n); } static char_type* move(char_type* s1, const char_type* s2, int_type n) { return c16memmove(s1, s2, n); } static char_type* copy(char_type* s1, const char_type* s2, size_t n) { return c16memcpy(s1, s2, n); } static char_type* assign(char_type* s, size_t n, char_type a) { return c16memset(s, a, n); } static int_type not_eof(const int_type& c) { return eq_int_type(c, eof()) ? 0 : c; } static char_type to_char_type(const int_type& c) { return char_type(c); } static int_type to_int_type(const char_type& c) { return int_type(c); } static bool eq_int_type(const int_type& c1, const int_type& c2) { return c1 == c2; } static int_type eof() { return static_cast(EOF); } }; typedef std::basic_string string16; extern std::ostream& operator<<(std::ostream& out, const string16& str); // This is required by googletest to print a readable output on test failures. extern void PrintTo(const string16& str, std::ostream* out); } // namespace base // The string class will be explicitly instantiated only once, in string16.cc. // // std::basic_string<> in GNU libstdc++ contains a static data member, // _S_empty_rep_storage, to represent empty strings. When an operation such // as assignment or destruction is performed on a string, causing its existing // data member to be invalidated, it must not be freed if this static data // member is being used. Otherwise, it counts as an attempt to free static // (and not allocated) data, which is a memory error. // // Generally, due to C++ template magic, _S_empty_rep_storage will be marked // as a coalesced symbol, meaning that the linker will combine multiple // instances into a single one when generating output. // // If a string class is used by multiple shared libraries, a problem occurs. // Each library will get its own copy of _S_empty_rep_storage. When strings // are passed across a library boundary for alteration or destruction, memory // errors will result. GNU libstdc++ contains a configuration option, // --enable-fully-dynamic-string (_GLIBCXX_FULLY_DYNAMIC_STRING), which // disables the static data member optimization, but it's a good optimization // and non-STL code is generally at the mercy of the system's STL // configuration. Fully-dynamic strings are not the default for GNU libstdc++ // libstdc++ itself or for the libstdc++ installations on the systems we care // about, such as Mac OS X and relevant flavors of Linux. // // See also http://gcc.gnu.org/bugzilla/show_bug.cgi?id=24196 . // // To avoid problems, string classes need to be explicitly instantiated only // once, in exactly one library. All other string users see it via an "extern" // declaration. This is precisely how GNU libstdc++ handles // std::basic_string (string) and std::basic_string (wstring). // // This also works around a Mac OS X linker bug in ld64-85.2.1 (Xcode 3.1.2), // in which the linker does not fully coalesce symbols when dead code // stripping is enabled. This bug causes the memory errors described above // to occur even when a std::basic_string<> does not cross shared library // boundaries, such as in statically-linked executables. // // TODO(mark): File this bug with Apple and update this note with a bug number. extern template class std::basic_string; #endif // WCHAR_T_IS_UTF32 #endif // !BUILDING_CEF_SHARED #endif // CEF_INCLUDE_BASE_CEF_STRING16_H_ cefpython-49.0/src/include/base/cef_template_util.h000066400000000000000000000162621334103266300224370ustar00rootroot00000000000000// Copyright (c) 2014 Marshall A. Greenblatt. Portions copyright (c) 2011 // Google Inc. 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_BASE_CEF_TEMPLATE_UTIL_H_ #define CEF_INCLUDE_BASE_CEF_TEMPLATE_UTIL_H_ #pragma once #if defined(BASE_TEMPLATE_UTIL_H_) // Do nothing if the Chromium header has already been included. // This can happen in cases where Chromium code is used directly by the // client application. When using Chromium code directly always include // the Chromium header first to avoid type conflicts. #elif defined(BUILDING_CEF_SHARED) // When building CEF include the Chromium header directly. #include "base/template_util.h" #else // !BUILDING_CEF_SHARED // The following is substantially similar to the Chromium implementation. // If the Chromium implementation diverges the below implementation should be // updated to match. #include // For size_t. #include "include/base/cef_build.h" namespace base { // template definitions from tr1 template struct integral_constant { static const T value = v; typedef T value_type; typedef integral_constant type; }; template const T integral_constant::value; typedef integral_constant true_type; typedef integral_constant false_type; template struct is_pointer : false_type {}; template struct is_pointer : true_type {}; // Member function pointer detection up to four params. Add more as needed // below. This is built-in to C++ 11, and we can remove this when we switch. template struct is_member_function_pointer : false_type {}; template struct is_member_function_pointer : true_type {}; template struct is_member_function_pointer : true_type {}; template struct is_member_function_pointer : true_type {}; template struct is_member_function_pointer : true_type {}; template struct is_member_function_pointer : true_type {}; template struct is_member_function_pointer : true_type {}; template struct is_member_function_pointer : true_type {}; template struct is_member_function_pointer : true_type {}; template struct is_member_function_pointer : true_type {}; template struct is_member_function_pointer : true_type {}; template struct is_same : public false_type {}; template struct is_same : true_type {}; template struct is_array : public false_type {}; template struct is_array : public true_type {}; template struct is_array : public true_type {}; template struct is_non_const_reference : false_type {}; template struct is_non_const_reference : true_type {}; template struct is_non_const_reference : false_type {}; template struct is_const : false_type {}; template struct is_const : true_type {}; template struct is_void : false_type {}; template <> struct is_void : true_type {}; namespace cef_internal { // Types YesType and NoType are guaranteed such that sizeof(YesType) < // sizeof(NoType). typedef char YesType; struct NoType { YesType dummy[2]; }; // This class is an implementation detail for is_convertible, and you // don't need to know how it works to use is_convertible. For those // who care: we declare two different functions, one whose argument is // of type To and one with a variadic argument list. We give them // return types of different size, so we can use sizeof to trick the // compiler into telling us which function it would have chosen if we // had called it with an argument of type From. See Alexandrescu's // _Modern C++ Design_ for more details on this sort of trick. struct ConvertHelper { template static YesType Test(To); template static NoType Test(...); template static From& Create(); }; // Used to determine if a type is a struct/union/class. Inspired by Boost's // is_class type_trait implementation. struct IsClassHelper { template static YesType Test(void(C::*)(void)); template static NoType Test(...); }; } // namespace cef_internal // Inherits from true_type if From is convertible to To, false_type otherwise. // // Note that if the type is convertible, this will be a true_type REGARDLESS // of whether or not the conversion would emit a warning. template struct is_convertible : integral_constant( cef_internal::ConvertHelper::Create())) == sizeof(cef_internal::YesType)> { }; template struct is_class : integral_constant(0)) == sizeof(cef_internal::YesType)> { }; template struct enable_if {}; template struct enable_if { typedef T type; }; } // namespace base #endif // !BUILDING_CEF_SHARED #endif // CEF_INCLUDE_BASE_CEF_TEMPLATE_UTIL_H_ cefpython-49.0/src/include/base/cef_thread_checker.h000066400000000000000000000113101334103266300225070ustar00rootroot00000000000000// Copyright (c) 2014 Marshall A. Greenblatt. Portions copyright (c) 2012 // Google Inc. 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_BASE_THREAD_CHECKER_H_ #define CEF_INCLUDE_BASE_THREAD_CHECKER_H_ #pragma once #if defined(BASE_THREADING_THREAD_CHECKER_H_) // Do nothing if the Chromium header has already been included. // This can happen in cases where Chromium code is used directly by the // client application. When using Chromium code directly always include // the Chromium header first to avoid type conflicts. #elif defined(BUILDING_CEF_SHARED) // When building CEF include the Chromium header directly. #include "base/threading/thread_checker.h" #else // !BUILDING_CEF_SHARED // The following is substantially similar to the Chromium implementation. // If the Chromium implementation diverges the below implementation should be // updated to match. #include "include/base/cef_logging.h" #include "include/base/internal/cef_thread_checker_impl.h" // Apart from debug builds, we also enable the thread checker in // builds with DCHECK_ALWAYS_ON so that trybots and waterfall bots // with this define will get the same level of thread checking as // debug bots. #if DCHECK_IS_ON() #define ENABLE_THREAD_CHECKER 1 #else #define ENABLE_THREAD_CHECKER 0 #endif namespace base { namespace cef_internal { // Do nothing implementation, for use in release mode. // // Note: You should almost always use the ThreadChecker class to get the // right version for your build configuration. class ThreadCheckerDoNothing { public: bool CalledOnValidThread() const { return true; } void DetachFromThread() {} }; } // namespace cef_internal // ThreadChecker is a helper class used to help verify that some methods of a // class are called from the same thread. It provides identical functionality to // base::NonThreadSafe, but it is meant to be held as a member variable, rather // than inherited from base::NonThreadSafe. // // While inheriting from base::NonThreadSafe may give a clear indication about // the thread-safety of a class, it may also lead to violations of the style // guide with regard to multiple inheritance. The choice between having a // ThreadChecker member and inheriting from base::NonThreadSafe should be based // on whether: // - Derived classes need to know the thread they belong to, as opposed to // having that functionality fully encapsulated in the base class. // - Derived classes should be able to reassign the base class to another // thread, via DetachFromThread. // // If neither of these are true, then having a ThreadChecker member and calling // CalledOnValidThread is the preferable solution. // // Example: // class MyClass { // public: // void Foo() { // DCHECK(thread_checker_.CalledOnValidThread()); // ... (do stuff) ... // } // // private: // ThreadChecker thread_checker_; // } // // In Release mode, CalledOnValidThread will always return true. #if ENABLE_THREAD_CHECKER class ThreadChecker : public cef_internal::ThreadCheckerImpl { }; #else class ThreadChecker : public cef_internal::ThreadCheckerDoNothing { }; #endif // ENABLE_THREAD_CHECKER #undef ENABLE_THREAD_CHECKER } // namespace base #endif // !BUILDING_CEF_SHARED #endif // CEF_INCLUDE_BASE_THREAD_CHECKER_H_ cefpython-49.0/src/include/base/cef_thread_collision_warner.h000066400000000000000000000227001334103266300244610ustar00rootroot00000000000000// Copyright (c) 2014 Marshall A. Greenblatt. Portions copyright (c) 2012 // Google Inc. 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_BASE_CEF_THREAD_COLLISION_WARNER_H_ #define CEF_INCLUDE_BASE_CEF_THREAD_COLLISION_WARNER_H_ #pragma once #if defined(BASE_THREADING_THREAD_COLLISION_WARNER_H_) // Do nothing if the Chromium header has already been included. // This can happen in cases where Chromium code is used directly by the // client application. When using Chromium code directly always include // the Chromium header first to avoid type conflicts. #elif defined(BUILDING_CEF_SHARED) // When building CEF include the Chromium header directly. #include "base/threading/thread_collision_warner.h" #else // !BUILDING_CEF_SHARED // The following is substantially similar to the Chromium implementation. // If the Chromium implementation diverges the below implementation should be // updated to match. #include #include "include/base/cef_atomicops.h" #include "include/base/cef_basictypes.h" #include "include/base/cef_build.h" #include "include/base/cef_macros.h" // A helper class alongside macros to be used to verify assumptions about thread // safety of a class. // // Example: Queue implementation non thread-safe but still usable if clients // are synchronized somehow. // // In this case the macro DFAKE_SCOPED_LOCK has to be // used, it checks that if a thread is inside the push/pop then // noone else is still inside the pop/push // // class NonThreadSafeQueue { // public: // ... // void push(int) { DFAKE_SCOPED_LOCK(push_pop_); ... } // int pop() { DFAKE_SCOPED_LOCK(push_pop_); ... } // ... // private: // DFAKE_MUTEX(push_pop_); // }; // // // Example: Queue implementation non thread-safe but still usable if clients // are synchronized somehow, it calls a method to "protect" from // a "protected" method // // In this case the macro DFAKE_SCOPED_RECURSIVE_LOCK // has to be used, it checks that if a thread is inside the push/pop // then noone else is still inside the pop/push // // class NonThreadSafeQueue { // public: // void push(int) { // DFAKE_SCOPED_LOCK(push_pop_); // ... // } // int pop() { // DFAKE_SCOPED_RECURSIVE_LOCK(push_pop_); // bar(); // ... // } // void bar() { DFAKE_SCOPED_RECURSIVE_LOCK(push_pop_); ... } // ... // private: // DFAKE_MUTEX(push_pop_); // }; // // // Example: Queue implementation not usable even if clients are synchronized, // so only one thread in the class life cycle can use the two members // push/pop. // // In this case the macro DFAKE_SCOPED_LOCK_THREAD_LOCKED pins the // specified // critical section the first time a thread enters push or pop, from // that time on only that thread is allowed to execute push or pop. // // class NonThreadSafeQueue { // public: // ... // void push(int) { DFAKE_SCOPED_LOCK_THREAD_LOCKED(push_pop_); ... } // int pop() { DFAKE_SCOPED_LOCK_THREAD_LOCKED(push_pop_); ... } // ... // private: // DFAKE_MUTEX(push_pop_); // }; // // // Example: Class that has to be contructed/destroyed on same thread, it has // a "shareable" method (with external synchronization) and a not // shareable method (even with external synchronization). // // In this case 3 Critical sections have to be defined // // class ExoticClass { // public: // ExoticClass() { DFAKE_SCOPED_LOCK_THREAD_LOCKED(ctor_dtor_); ... } // ~ExoticClass() { DFAKE_SCOPED_LOCK_THREAD_LOCKED(ctor_dtor_); ... } // // void Shareable() { DFAKE_SCOPED_LOCK(shareable_section_); ... } // void NotShareable() { DFAKE_SCOPED_LOCK_THREAD_LOCKED(ctor_dtor_); ... } // ... // private: // DFAKE_MUTEX(ctor_dtor_); // DFAKE_MUTEX(shareable_section_); // }; #if !defined(NDEBUG) // Defines a class member that acts like a mutex. It is used only as a // verification tool. #define DFAKE_MUTEX(obj) \ mutable base::ThreadCollisionWarner obj // Asserts the call is never called simultaneously in two threads. Used at // member function scope. #define DFAKE_SCOPED_LOCK(obj) \ base::ThreadCollisionWarner::ScopedCheck s_check_##obj(&obj) // Asserts the call is never called simultaneously in two threads. Used at // member function scope. Same as DFAKE_SCOPED_LOCK but allows recursive locks. #define DFAKE_SCOPED_RECURSIVE_LOCK(obj) \ base::ThreadCollisionWarner::ScopedRecursiveCheck sr_check_##obj(&obj) // Asserts the code is always executed in the same thread. #define DFAKE_SCOPED_LOCK_THREAD_LOCKED(obj) \ base::ThreadCollisionWarner::Check check_##obj(&obj) #else #define DFAKE_MUTEX(obj) typedef void InternalFakeMutexType##obj #define DFAKE_SCOPED_LOCK(obj) ((void)0) #define DFAKE_SCOPED_RECURSIVE_LOCK(obj) ((void)0) #define DFAKE_SCOPED_LOCK_THREAD_LOCKED(obj) ((void)0) #endif namespace base { // The class ThreadCollisionWarner uses an Asserter to notify the collision // AsserterBase is the interfaces and DCheckAsserter is the default asserter // used. During the unit tests is used another class that doesn't "DCHECK" // in case of collision (check thread_collision_warner_unittests.cc) struct AsserterBase { virtual ~AsserterBase() {} virtual void warn() = 0; }; struct DCheckAsserter : public AsserterBase { virtual ~DCheckAsserter() {} virtual void warn() OVERRIDE; }; class ThreadCollisionWarner { public: // The parameter asserter is there only for test purpose explicit ThreadCollisionWarner(AsserterBase* asserter = new DCheckAsserter()) : valid_thread_id_(0), counter_(0), asserter_(asserter) {} ~ThreadCollisionWarner() { delete asserter_; } // This class is meant to be used through the macro // DFAKE_SCOPED_LOCK_THREAD_LOCKED // it doesn't leave the critical section, as opposed to ScopedCheck, // because the critical section being pinned is allowed to be used only // from one thread class Check { public: explicit Check(ThreadCollisionWarner* warner) : warner_(warner) { warner_->EnterSelf(); } ~Check() {} private: ThreadCollisionWarner* warner_; DISALLOW_COPY_AND_ASSIGN(Check); }; // This class is meant to be used through the macro // DFAKE_SCOPED_LOCK class ScopedCheck { public: explicit ScopedCheck(ThreadCollisionWarner* warner) : warner_(warner) { warner_->Enter(); } ~ScopedCheck() { warner_->Leave(); } private: ThreadCollisionWarner* warner_; DISALLOW_COPY_AND_ASSIGN(ScopedCheck); }; // This class is meant to be used through the macro // DFAKE_SCOPED_RECURSIVE_LOCK class ScopedRecursiveCheck { public: explicit ScopedRecursiveCheck(ThreadCollisionWarner* warner) : warner_(warner) { warner_->EnterSelf(); } ~ScopedRecursiveCheck() { warner_->Leave(); } private: ThreadCollisionWarner* warner_; DISALLOW_COPY_AND_ASSIGN(ScopedRecursiveCheck); }; private: // This method stores the current thread identifier and does a DCHECK // if a another thread has already done it, it is safe if same thread // calls this multiple time (recursion allowed). void EnterSelf(); // Same as EnterSelf but recursion is not allowed. void Enter(); // Removes the thread_id stored in order to allow other threads to // call EnterSelf or Enter. void Leave(); // This stores the thread id that is inside the critical section, if the // value is 0 then no thread is inside. volatile subtle::Atomic32 valid_thread_id_; // Counter to trace how many time a critical section was "pinned" // (when allowed) in order to unpin it when counter_ reaches 0. volatile subtle::Atomic32 counter_; // Here only for class unit tests purpose, during the test I need to not // DCHECK but notify the collision with something else. AsserterBase* asserter_; DISALLOW_COPY_AND_ASSIGN(ThreadCollisionWarner); }; } // namespace base #endif // !BUILDING_CEF_SHARED #endif // CEF_INCLUDE_BASE_CEF_THREAD_COLLISION_WARNER_H_ cefpython-49.0/src/include/base/cef_trace_event.h000066400000000000000000000506671334103266300220750ustar00rootroot00000000000000// Copyright (c) 2014 Marshall A. Greenblatt. Portions copyright (c) 2012 // Google Inc. 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. /// // Trace events are for tracking application performance and resource usage. // Macros are provided to track: // Begin and end of function calls // Counters // // Events are issued against categories. Whereas LOG's categories are statically // defined, TRACE categories are created implicitly with a string. For example: // TRACE_EVENT_INSTANT0("MY_SUBSYSTEM", "SomeImportantEvent") // // Events can be INSTANT, or can be pairs of BEGIN and END in the same scope: // TRACE_EVENT_BEGIN0("MY_SUBSYSTEM", "SomethingCostly") // doSomethingCostly() // TRACE_EVENT_END0("MY_SUBSYSTEM", "SomethingCostly") // Note: Our tools can't always determine the correct BEGIN/END pairs unless // these are used in the same scope. Use ASYNC_BEGIN/ASYNC_END macros if you // need them to be in separate scopes. // // A common use case is to trace entire function scopes. This issues a trace // BEGIN and END automatically: // void doSomethingCostly() { // TRACE_EVENT0("MY_SUBSYSTEM", "doSomethingCostly"); // ... // } // // Additional parameters can be associated with an event: // void doSomethingCostly2(int howMuch) { // TRACE_EVENT1("MY_SUBSYSTEM", "doSomethingCostly", // "howMuch", howMuch); // ... // } // // The trace system will automatically add to this information the current // process id, thread id, and a timestamp in microseconds. // // To trace an asynchronous procedure such as an IPC send/receive, use // ASYNC_BEGIN and ASYNC_END: // [single threaded sender code] // static int send_count = 0; // ++send_count; // TRACE_EVENT_ASYNC_BEGIN0("ipc", "message", send_count); // Send(new MyMessage(send_count)); // [receive code] // void OnMyMessage(send_count) { // TRACE_EVENT_ASYNC_END0("ipc", "message", send_count); // } // The third parameter is a unique ID to match ASYNC_BEGIN/ASYNC_END pairs. // ASYNC_BEGIN and ASYNC_END can occur on any thread of any traced process. // Pointers can be used for the ID parameter, and they will be mangled // internally so that the same pointer on two different processes will not // match. For example: // class MyTracedClass { // public: // MyTracedClass() { // TRACE_EVENT_ASYNC_BEGIN0("category", "MyTracedClass", this); // } // ~MyTracedClass() { // TRACE_EVENT_ASYNC_END0("category", "MyTracedClass", this); // } // } // // The trace event also supports counters, which is a way to track a quantity // as it varies over time. Counters are created with the following macro: // TRACE_COUNTER1("MY_SUBSYSTEM", "myCounter", g_myCounterValue); // // Counters are process-specific. The macro itself can be issued from any // thread, however. // // Sometimes, you want to track two counters at once. You can do this with two // counter macros: // TRACE_COUNTER1("MY_SUBSYSTEM", "myCounter0", g_myCounterValue[0]); // TRACE_COUNTER1("MY_SUBSYSTEM", "myCounter1", g_myCounterValue[1]); // Or you can do it with a combined macro: // TRACE_COUNTER2("MY_SUBSYSTEM", "myCounter", // "bytesPinned", g_myCounterValue[0], // "bytesAllocated", g_myCounterValue[1]); // This indicates to the tracing UI that these counters should be displayed // in a single graph, as a summed area chart. // // Since counters are in a global namespace, you may want to disembiguate with a // unique ID, by using the TRACE_COUNTER_ID* variations. // // By default, trace collection is compiled in, but turned off at runtime. // Collecting trace data is the responsibility of the embedding application. In // CEF's case, calling BeginTracing will turn on tracing on all active // processes. // // // Memory scoping note: // Tracing copies the pointers, not the string content, of the strings passed // in for category, name, and arg_names. Thus, the following code will cause // problems: // char* str = strdup("impprtantName"); // TRACE_EVENT_INSTANT0("SUBSYSTEM", str); // BAD! // free(str); // Trace system now has dangling pointer // // To avoid this issue with the |name| and |arg_name| parameters, use the // TRACE_EVENT_COPY_XXX overloads of the macros at additional runtime // overhead. // Notes: The category must always be in a long-lived char* (i.e. static const). // The |arg_values|, when used, are always deep copied with the _COPY // macros. // // // Thread Safety: // All macros are thread safe and can be used from any process. /// #ifndef CEF_INCLUDE_BASE_CEF_TRACE_EVENT_H_ #define CEF_INCLUDE_BASE_CEF_TRACE_EVENT_H_ #pragma once #if defined(TRACE_EVENT0) // Do nothing if the macros provided by this header already exist. // This can happen in cases where Chromium code is used directly by the // client application. When using Chromium code directly always include // the Chromium header first to avoid type conflicts. #elif defined(BUILDING_CEF_SHARED) // When building CEF include the Chromium header directly. #include "base/debug/trace_event.h" #else // !BUILDING_CEF_SHARED // The following is substantially similar to the Chromium implementation. // If the Chromium implementation diverges the below implementation should be // updated to match. #include "include/internal/cef_trace_event_internal.h" // Records a pair of begin and end events called "name" for the current // scope, with 0, 1 or 2 associated arguments. If the category is not // enabled, then this does nothing. // - category and name strings must have application lifetime (statics or // literals). They may not include " chars. #define TRACE_EVENT0(category, name) \ cef_trace_event_begin(category, name, NULL, 0, NULL, 0, false); \ CEF_INTERNAL_TRACE_END_ON_SCOPE_CLOSE(category, name) #define TRACE_EVENT1(category, name, arg1_name, arg1_val) \ cef_trace_event_begin(category, name, arg1_name, arg1_val, NULL, 0, false); \ CEF_INTERNAL_TRACE_END_ON_SCOPE_CLOSE(category, name) #define TRACE_EVENT2(category, name, arg1_name, arg1_val, arg2_name, \ arg2_val) \ cef_trace_event_begin(category, name, arg1_name, arg1_val, \ arg2_name, arg2_val, false); \ CEF_INTERNAL_TRACE_END_ON_SCOPE_CLOSE(category, name) // Implementation detail: trace event macros create temporary variable names. // These macros give each temporary variable a unique name based on the line // number to prevent name collisions. #define CEF_INTERNAL_TRACE_EVENT_UID3(a,b) \ cef_trace_event_unique_##a##b #define CEF_INTERNAL_TRACE_EVENT_UID2(a,b) \ CEF_INTERNAL_TRACE_EVENT_UID3(a,b) #define CEF_INTERNAL_TRACE_EVENT_UID(name_prefix) \ CEF_INTERNAL_TRACE_EVENT_UID2(name_prefix, __LINE__) // Implementation detail: internal macro to end end event when the scope ends. #define CEF_INTERNAL_TRACE_END_ON_SCOPE_CLOSE(category, name) \ cef_trace_event::CefTraceEndOnScopeClose \ CEF_INTERNAL_TRACE_EVENT_UID(profileScope)(category, name) // Records a single event called "name" immediately, with 0, 1 or 2 // associated arguments. If the category is not enabled, then this // does nothing. // - category and name strings must have application lifetime (statics or // literals). They may not include " chars. #define TRACE_EVENT_INSTANT0(category, name) \ cef_trace_event_instant(category, name, NULL, 0, NULL, 0, false) #define TRACE_EVENT_INSTANT1(category, name, arg1_name, arg1_val) \ cef_trace_event_instant(category, name, arg1_name, arg1_val, NULL, 0, false) #define TRACE_EVENT_INSTANT2(category, name, arg1_name, arg1_val, \ arg2_name, arg2_val) \ cef_trace_event_instant(category, name, arg1_name, arg1_val, arg2_name, \ arg2_val, false) #define TRACE_EVENT_COPY_INSTANT0(category, name) \ cef_trace_event_instant(category, name, NULL, 0, NULL, 0, true) #define TRACE_EVENT_COPY_INSTANT1(category, name, arg1_name, arg1_val) \ cef_trace_event_instant(category, name, arg1_name, arg1_val, NULL, 0, true) #define TRACE_EVENT_COPY_INSTANT2(category, name, arg1_name, arg1_val, \ arg2_name, arg2_val) \ cef_trace_event_instant(category, name, arg1_name, arg1_val, arg2_name, \ arg2_val, true) // Records a single BEGIN event called "name" immediately, with 0, 1 or 2 // associated arguments. If the category is not enabled, then this // does nothing. // - category and name strings must have application lifetime (statics or // literals). They may not include " chars. #define TRACE_EVENT_BEGIN0(category, name) \ cef_trace_event_begin(category, name, NULL, 0, NULL, 0, false) #define TRACE_EVENT_BEGIN1(category, name, arg1_name, arg1_val) \ cef_trace_event_begin(category, name, arg1_name, arg1_val, NULL, 0, false) #define TRACE_EVENT_BEGIN2(category, name, arg1_name, arg1_val, \ arg2_name, arg2_val) \ cef_trace_event_begin(category, name, arg1_name, arg1_val, arg2_name, \ arg2_val, false) #define TRACE_EVENT_COPY_BEGIN0(category, name) \ cef_trace_event_begin(category, name, NULL, 0, NULL, 0, true) #define TRACE_EVENT_COPY_BEGIN1(category, name, arg1_name, arg1_val) \ cef_trace_event_begin(category, name, arg1_name, arg1_val, NULL, 0, true) #define TRACE_EVENT_COPY_BEGIN2(category, name, arg1_name, arg1_val, \ arg2_name, arg2_val) \ cef_trace_event_begin(category, name, arg1_name, arg1_val, arg2_name, \ arg2_val, true) // Records a single END event for "name" immediately. If the category // is not enabled, then this does nothing. // - category and name strings must have application lifetime (statics or // literals). They may not include " chars. #define TRACE_EVENT_END0(category, name) \ cef_trace_event_end(category, name, NULL, 0, NULL, 0, false) #define TRACE_EVENT_END1(category, name, arg1_name, arg1_val) \ cef_trace_event_end(category, name, arg1_name, arg1_val, NULL, 0, false) #define TRACE_EVENT_END2(category, name, arg1_name, arg1_val, \ arg2_name, arg2_val) \ cef_trace_event_end(category, name, arg1_name, arg1_val, arg2_name, \ arg2_val, false) #define TRACE_EVENT_COPY_END0(category, name) \ cef_trace_event_end(category, name, NULL, 0, NULL, 0, true) #define TRACE_EVENT_COPY_END1(category, name, arg1_name, arg1_val) \ cef_trace_event_end(category, name, arg1_name, arg1_val, NULL, 0, true) #define TRACE_EVENT_COPY_END2(category, name, arg1_name, arg1_val, \ arg2_name, arg2_val) \ cef_trace_event_end(category, name, arg1_name, arg1_val, arg2_name, \ arg2_val, true) // Records the value of a counter called "name" immediately. Value // must be representable as a 32 bit integer. // - category and name strings must have application lifetime (statics or // literals). They may not include " chars. #define TRACE_COUNTER1(category, name, value) \ cef_trace_counter(category, name, NULL, value, NULL, 0, false) #define TRACE_COPY_COUNTER1(category, name, value) \ cef_trace_counter(category, name, NULL, value, NULL, 0, true) // Records the values of a multi-parted counter called "name" immediately. // The UI will treat value1 and value2 as parts of a whole, displaying their // values as a stacked-bar chart. // - category and name strings must have application lifetime (statics or // literals). They may not include " chars. #define TRACE_COUNTER2(category, name, value1_name, value1_val, \ value2_name, value2_val) \ cef_trace_counter(category, name, value1_name, value1_val, value2_name, \ value2_val, false) #define TRACE_COPY_COUNTER2(category, name, value1_name, value1_val, \ value2_name, value2_val) \ cef_trace_counter(category, name, value1_name, value1_val, value2_name, \ value2_val, true) // Records the value of a counter called "name" immediately. Value // must be representable as a 32 bit integer. // - category and name strings must have application lifetime (statics or // literals). They may not include " chars. // - |id| is used to disambiguate counters with the same name. It must either // be a pointer or an integer value up to 64 bits. If it's a pointer, the // bits will be xored with a hash of the process ID so that the same pointer // on two different processes will not collide. #define TRACE_COUNTER_ID1(category, name, id, value) \ cef_trace_counter_id(category, name, id, NULL, value, NULL, 0, false) #define TRACE_COPY_COUNTER_ID1(category, name, id, value) \ cef_trace_counter_id(category, name, id, NULL, value, NULL, 0, true) // Records the values of a multi-parted counter called "name" immediately. // The UI will treat value1 and value2 as parts of a whole, displaying their // values as a stacked-bar chart. // - category and name strings must have application lifetime (statics or // literals). They may not include " chars. // - |id| is used to disambiguate counters with the same name. It must either // be a pointer or an integer value up to 64 bits. If it's a pointer, the // bits will be xored with a hash of the process ID so that the same pointer // on two different processes will not collide. #define TRACE_COUNTER_ID2(category, name, id, value1_name, value1_val, \ value2_name, value2_val) \ cef_trace_counter_id(category, name, id, value1_name, value1_val, \ value2_name, value2_val, false) #define TRACE_COPY_COUNTER_ID2(category, name, id, value1_name, \ value1_val, value2_name, value2_val) \ cef_trace_counter_id(category, name, id, value1_name, value1_val, \ value2_name, value2_val, true) // Records a single ASYNC_BEGIN event called "name" immediately, with 0, 1 or 2 // associated arguments. If the category is not enabled, then this // does nothing. // - category and name strings must have application lifetime (statics or // literals). They may not include " chars. // - |id| is used to match the ASYNC_BEGIN event with the ASYNC_END event. // ASYNC events are considered to match if their category, name and id values // all match. |id| must either be a pointer or an integer value up to 64 // bits. If it's a pointer, the bits will be xored with a hash of the process // ID sothat the same pointer on two different processes will not collide. // An asynchronous operation can consist of multiple phases. The first phase is // defined by the ASYNC_BEGIN calls. Additional phases can be defined using the // ASYNC_STEP_BEGIN macros. When the operation completes, call ASYNC_END. // An async operation can span threads and processes, but all events in that // operation must use the same |name| and |id|. Each event can have its own // args. #define TRACE_EVENT_ASYNC_BEGIN0(category, name, id) \ cef_trace_event_async_begin(category, name, id, NULL, 0, NULL, 0, false) #define TRACE_EVENT_ASYNC_BEGIN1(category, name, id, arg1_name, arg1_val) \ cef_trace_event_async_begin(category, name, id, arg1_name, arg1_val, NULL, \ 0, false) #define TRACE_EVENT_ASYNC_BEGIN2(category, name, id, arg1_name, arg1_val, \ arg2_name, arg2_val) \ cef_trace_event_async_begin(category, name, id, arg1_name, arg1_val, \ arg2_name, arg2_val, false) #define TRACE_EVENT_COPY_ASYNC_BEGIN0(category, name, id) \ cef_trace_event_async_begin(category, name, id, NULL, 0, NULL, 0, true) #define TRACE_EVENT_COPY_ASYNC_BEGIN1(category, name, id, arg1_name, \ arg1_val) \ cef_trace_event_async_begin(category, name, id, arg1_name, arg1_val, NULL, \ 0, true) #define TRACE_EVENT_COPY_ASYNC_BEGIN2(category, name, id, arg1_name, \ arg1_val, arg2_name, arg2_val) \ cef_trace_event_async_begin(category, name, id, arg1_name, arg1_val, \ arg2_name, arg2_val, true) // Records a single ASYNC_STEP_INTO event for |step| immediately. If the // category is not enabled, then this does nothing. The |name| and |id| must // match the ASYNC_BEGIN event above. The |step| param identifies this step // within the async event. This should be called at the beginning of the next // phase of an asynchronous operation. The ASYNC_BEGIN event must not have any // ASYNC_STEP_PAST events. #define TRACE_EVENT_ASYNC_STEP_INTO0(category, name, id, step) \ cef_trace_event_async_step_into(category, name, id, step, NULL, 0, false) #define TRACE_EVENT_ASYNC_STEP_INTO1(category, name, id, step, \ arg1_name, arg1_val) \ cef_trace_event_async_step_into(category, name, id, step, arg1_name, \ arg1_val, false) #define TRACE_EVENT_COPY_ASYNC_STEP_INTO0(category, name, id, step) \ cef_trace_event_async_step_into(category, name, id, step, NULL, 0, true) #define TRACE_EVENT_COPY_ASYNC_STEP_INTO1(category, name, id, step, \ arg1_name, arg1_val) \ cef_trace_event_async_step_into(category, name, id, step, arg1_name, \ arg1_val, true) // Records a single ASYNC_STEP_PAST event for |step| immediately. If the // category is not enabled, then this does nothing. The |name| and |id| must // match the ASYNC_BEGIN event above. The |step| param identifies this step // within the async event. This should be called at the beginning of the next // phase of an asynchronous operation. The ASYNC_BEGIN event must not have any // ASYNC_STEP_INTO events. #define TRACE_EVENT_ASYNC_STEP_PAST0(category, name, id, step) \ cef_trace_event_async_step_past(category, name, id, step, NULL, 0, false) #define TRACE_EVENT_ASYNC_STEP_PAST1(category, name, id, step, \ arg1_name, arg1_val) \ cef_trace_event_async_step_past(category, name, id, step, arg1_name, \ arg1_val, false) #define TRACE_EVENT_COPY_ASYNC_STEP_PAST0(category, name, id, step) \ cef_trace_event_async_step_past(category, name, id, step, NULL, 0, true) #define TRACE_EVENT_COPY_ASYNC_STEP_PAST1(category, name, id, step, \ arg1_name, arg1_val) \ cef_trace_event_async_step_past(category, name, id, step, arg1_name, \ arg1_val, true) // Records a single ASYNC_END event for "name" immediately. If the category // is not enabled, then this does nothing. #define TRACE_EVENT_ASYNC_END0(category, name, id) \ cef_trace_event_async_end(category, name, id, NULL, 0, NULL, 0, false) #define TRACE_EVENT_ASYNC_END1(category, name, id, arg1_name, arg1_val) \ cef_trace_event_async_end(category, name, id, arg1_name, arg1_val, NULL, 0, \ false) #define TRACE_EVENT_ASYNC_END2(category, name, id, arg1_name, arg1_val, \ arg2_name, arg2_val) \ cef_trace_event_async_end(category, name, id, arg1_name, arg1_val, \ arg2_name, arg2_val, false) #define TRACE_EVENT_COPY_ASYNC_END0(category, name, id) \ cef_trace_event_async_end(category, name, id, NULL, 0, NULL, 0, true) #define TRACE_EVENT_COPY_ASYNC_END1(category, name, id, arg1_name, \ arg1_val) \ cef_trace_event_async_end(category, name, id, arg1_name, arg1_val, NULL, 0, \ true) #define TRACE_EVENT_COPY_ASYNC_END2(category, name, id, arg1_name, \ arg1_val, arg2_name, arg2_val) \ cef_trace_event_async_end(category, name, id, arg1_name, arg1_val, \ arg2_name, arg2_val, true) namespace cef_trace_event { // Used by TRACE_EVENTx macro. Do not use directly. class CefTraceEndOnScopeClose { public: CefTraceEndOnScopeClose(const char* category, const char* name) : category_(category), name_(name) { } ~CefTraceEndOnScopeClose() { cef_trace_event_end(category_, name_, NULL, 0, NULL, 0, false); } private: const char* category_; const char* name_; }; } // cef_trace_event #endif // !BUILDING_CEF_SHARED #endif // CEF_INCLUDE_BASE_CEF_TRACE_EVENT_H_ cefpython-49.0/src/include/base/cef_tuple.h000066400000000000000000001556121334103266300207230ustar00rootroot00000000000000// Copyright (c) 2014 Marshall A. Greenblatt. Portions copyright (c) 2011 // Google Inc. 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. // A Tuple is a generic templatized container, similar in concept to std::pair. // There are classes Tuple0 to Tuple6, cooresponding to the number of elements // it contains. The convenient MakeTuple() function takes 0 to 6 arguments, // and will construct and return the appropriate Tuple object. The functions // DispatchToMethod and DispatchToFunction take a function pointer or instance // and method pointer, and unpack a tuple into arguments to the call. // // Tuple elements are copied by value, and stored in the tuple. See the unit // tests for more details of how/when the values are copied. // // Example usage: // // These two methods of creating a Tuple are identical. // Tuple2 tuple_a(1, "wee"); // Tuple2 tuple_b = MakeTuple(1, "wee"); // // void SomeFunc(int a, const char* b) { } // DispatchToFunction(&SomeFunc, tuple_a); // SomeFunc(1, "wee") // DispatchToFunction( // &SomeFunc, MakeTuple(10, "foo")); // SomeFunc(10, "foo") // // struct { void SomeMeth(int a, int b, int c) { } } foo; // DispatchToMethod(&foo, &Foo::SomeMeth, MakeTuple(1, 2, 3)); // // foo->SomeMeth(1, 2, 3); #ifndef CEF_INCLUDE_BASE_CEF_TUPLE_H_ #define CEF_INCLUDE_BASE_CEF_TUPLE_H_ #pragma once #if defined(BASE_TUPLE_H_) // The Chromium header has already been included. // This can happen in cases where Chromium code is used directly by the // client application. When using Chromium code directly always include // the Chromium header first to avoid type conflicts. // For legacy compatibility, we name the first 8 tuple elements "a", "b", ... // TODO(cef): Remove this code when cef_runnable.h is deleted. namespace base { #define DEFINE_TUPLE_LEAF(N, x) \ template \ struct TupleLeaf { \ TupleLeaf() {} \ explicit TupleLeaf(typename TupleTraits::ParamType x) : x(x) {} \ \ T& get() { return x; } \ const T& get() const { return x; } \ \ T x; \ } DEFINE_TUPLE_LEAF(0, a); DEFINE_TUPLE_LEAF(1, b); DEFINE_TUPLE_LEAF(2, c); DEFINE_TUPLE_LEAF(3, d); DEFINE_TUPLE_LEAF(4, e); DEFINE_TUPLE_LEAF(5, f); DEFINE_TUPLE_LEAF(6, g); DEFINE_TUPLE_LEAF(7, h); #undef DEFINE_TUPLE_LEAF // Deprecated compat aliases // TODO(cef): Remove this code when cef_runnable.h is deleted. using Tuple0 = Tuple<>; template using Tuple1 = Tuple; template using Tuple2 = Tuple; template using Tuple3 = Tuple; template using Tuple4 = Tuple; template using Tuple5 = Tuple; template using Tuple6 = Tuple; template using Tuple7 = Tuple; template using Tuple8 = Tuple; } // namespace base #elif defined(BUILDING_CEF_SHARED) // When building CEF include the Chromium header directly. #include "base/tuple.h" #else // !BUILDING_CEF_SHARED // The following is substantially similar to the Chromium implementation. // If the Chromium implementation diverges the below implementation should be // updated to match. #include "include/base/cef_bind_helpers.h" namespace base { // Traits ---------------------------------------------------------------------- // // A simple traits class for tuple arguments. // // ValueType: the bare, nonref version of a type (same as the type for nonrefs). // RefType: the ref version of a type (same as the type for refs). // ParamType: what type to pass to functions (refs should not be constified). template struct TupleTraits { typedef P ValueType; typedef P& RefType; typedef const P& ParamType; }; template struct TupleTraits { typedef P ValueType; typedef P& RefType; typedef P& ParamType; }; template struct TupleTypes { }; // Tuple ----------------------------------------------------------------------- // // This set of classes is useful for bundling 0 or more heterogeneous data types // into a single variable. The advantage of this is that it greatly simplifies // function objects that need to take an arbitrary number of parameters; see // RunnableMethod and IPC::MessageWithTuple. // // Tuple0 is supplied to act as a 'void' type. It can be used, for example, // when dispatching to a function that accepts no arguments (see the // Dispatchers below). // Tuple1 is rarely useful. One such use is when A is non-const ref that you // want filled by the dispatchee, and the tuple is merely a container for that // output (a "tier"). See MakeRefTuple and its usages. struct Tuple0 { typedef Tuple0 ValueTuple; typedef Tuple0 RefTuple; typedef Tuple0 ParamTuple; }; template struct Tuple1 { public: typedef A TypeA; Tuple1() {} explicit Tuple1(typename TupleTraits::ParamType a) : a(a) {} A a; }; template struct Tuple2 { public: typedef A TypeA; typedef B TypeB; Tuple2() {} Tuple2(typename TupleTraits::ParamType a, typename TupleTraits::ParamType b) : a(a), b(b) { } A a; B b; }; template struct Tuple3 { public: typedef A TypeA; typedef B TypeB; typedef C TypeC; Tuple3() {} Tuple3(typename TupleTraits::ParamType a, typename TupleTraits::ParamType b, typename TupleTraits::ParamType c) : a(a), b(b), c(c){ } A a; B b; C c; }; template struct Tuple4 { public: typedef A TypeA; typedef B TypeB; typedef C TypeC; typedef D TypeD; Tuple4() {} Tuple4(typename TupleTraits::ParamType a, typename TupleTraits::ParamType b, typename TupleTraits::ParamType c, typename TupleTraits::ParamType d) : a(a), b(b), c(c), d(d) { } A a; B b; C c; D d; }; template struct Tuple5 { public: typedef A TypeA; typedef B TypeB; typedef C TypeC; typedef D TypeD; typedef E TypeE; Tuple5() {} Tuple5(typename TupleTraits::ParamType a, typename TupleTraits::ParamType b, typename TupleTraits::ParamType c, typename TupleTraits::ParamType d, typename TupleTraits::ParamType e) : a(a), b(b), c(c), d(d), e(e) { } A a; B b; C c; D d; E e; }; template struct Tuple6 { public: typedef A TypeA; typedef B TypeB; typedef C TypeC; typedef D TypeD; typedef E TypeE; typedef F TypeF; Tuple6() {} Tuple6(typename TupleTraits::ParamType a, typename TupleTraits::ParamType b, typename TupleTraits::ParamType c, typename TupleTraits::ParamType d, typename TupleTraits::ParamType e, typename TupleTraits::ParamType f) : a(a), b(b), c(c), d(d), e(e), f(f) { } A a; B b; C c; D d; E e; F f; }; template struct Tuple7 { public: typedef A TypeA; typedef B TypeB; typedef C TypeC; typedef D TypeD; typedef E TypeE; typedef F TypeF; typedef G TypeG; Tuple7() {} Tuple7(typename TupleTraits::ParamType a, typename TupleTraits::ParamType b, typename TupleTraits::ParamType c, typename TupleTraits::ParamType d, typename TupleTraits::ParamType e, typename TupleTraits::ParamType f, typename TupleTraits::ParamType g) : a(a), b(b), c(c), d(d), e(e), f(f), g(g) { } A a; B b; C c; D d; E e; F f; G g; }; template struct Tuple8 { public: typedef A TypeA; typedef B TypeB; typedef C TypeC; typedef D TypeD; typedef E TypeE; typedef F TypeF; typedef G TypeG; typedef H TypeH; Tuple8() {} Tuple8(typename TupleTraits::ParamType a, typename TupleTraits::ParamType b, typename TupleTraits::ParamType c, typename TupleTraits::ParamType d, typename TupleTraits::ParamType e, typename TupleTraits::ParamType f, typename TupleTraits::ParamType g, typename TupleTraits::ParamType h) : a(a), b(b), c(c), d(d), e(e), f(f), g(g), h(h) { } A a; B b; C c; D d; E e; F f; G g; H h; }; // Tuple types ---------------------------------------------------------------- // // Allows for selection of ValueTuple/RefTuple/ParamTuple without needing the // definitions of class types the tuple takes as parameters. template <> struct TupleTypes< Tuple0 > { typedef Tuple0 ValueTuple; typedef Tuple0 RefTuple; typedef Tuple0 ParamTuple; }; template struct TupleTypes< Tuple1 > { typedef Tuple1::ValueType> ValueTuple; typedef Tuple1::RefType> RefTuple; typedef Tuple1::ParamType> ParamTuple; }; template struct TupleTypes< Tuple2 > { typedef Tuple2::ValueType, typename TupleTraits::ValueType> ValueTuple; typedef Tuple2::RefType, typename TupleTraits::RefType> RefTuple; typedef Tuple2::ParamType, typename TupleTraits::ParamType> ParamTuple; }; template struct TupleTypes< Tuple3 > { typedef Tuple3::ValueType, typename TupleTraits::ValueType, typename TupleTraits::ValueType> ValueTuple; typedef Tuple3::RefType, typename TupleTraits::RefType, typename TupleTraits::RefType> RefTuple; typedef Tuple3::ParamType, typename TupleTraits::ParamType, typename TupleTraits::ParamType> ParamTuple; }; template struct TupleTypes< Tuple4 > { typedef Tuple4::ValueType, typename TupleTraits::ValueType, typename TupleTraits::ValueType, typename TupleTraits::ValueType> ValueTuple; typedef Tuple4::RefType, typename TupleTraits::RefType, typename TupleTraits::RefType, typename TupleTraits::RefType> RefTuple; typedef Tuple4::ParamType, typename TupleTraits::ParamType, typename TupleTraits::ParamType, typename TupleTraits::ParamType> ParamTuple; }; template struct TupleTypes< Tuple5 > { typedef Tuple5::ValueType, typename TupleTraits::ValueType, typename TupleTraits::ValueType, typename TupleTraits::ValueType, typename TupleTraits::ValueType> ValueTuple; typedef Tuple5::RefType, typename TupleTraits::RefType, typename TupleTraits::RefType, typename TupleTraits::RefType, typename TupleTraits::RefType> RefTuple; typedef Tuple5::ParamType, typename TupleTraits::ParamType, typename TupleTraits::ParamType, typename TupleTraits::ParamType, typename TupleTraits::ParamType> ParamTuple; }; template struct TupleTypes< Tuple6 > { typedef Tuple6::ValueType, typename TupleTraits::ValueType, typename TupleTraits::ValueType, typename TupleTraits::ValueType, typename TupleTraits::ValueType, typename TupleTraits::ValueType> ValueTuple; typedef Tuple6::RefType, typename TupleTraits::RefType, typename TupleTraits::RefType, typename TupleTraits::RefType, typename TupleTraits::RefType, typename TupleTraits::RefType> RefTuple; typedef Tuple6::ParamType, typename TupleTraits::ParamType, typename TupleTraits::ParamType, typename TupleTraits::ParamType, typename TupleTraits::ParamType, typename TupleTraits::ParamType> ParamTuple; }; template struct TupleTypes< Tuple7 > { typedef Tuple7::ValueType, typename TupleTraits::ValueType, typename TupleTraits::ValueType, typename TupleTraits::ValueType, typename TupleTraits::ValueType, typename TupleTraits::ValueType, typename TupleTraits::ValueType> ValueTuple; typedef Tuple7::RefType, typename TupleTraits::RefType, typename TupleTraits::RefType, typename TupleTraits::RefType, typename TupleTraits::RefType, typename TupleTraits::RefType, typename TupleTraits::RefType> RefTuple; typedef Tuple7::ParamType, typename TupleTraits::ParamType, typename TupleTraits::ParamType, typename TupleTraits::ParamType, typename TupleTraits::ParamType, typename TupleTraits::ParamType, typename TupleTraits::ParamType> ParamTuple; }; template struct TupleTypes< Tuple8 > { typedef Tuple8::ValueType, typename TupleTraits::ValueType, typename TupleTraits::ValueType, typename TupleTraits::ValueType, typename TupleTraits::ValueType, typename TupleTraits::ValueType, typename TupleTraits::ValueType, typename TupleTraits::ValueType> ValueTuple; typedef Tuple8::RefType, typename TupleTraits::RefType, typename TupleTraits::RefType, typename TupleTraits::RefType, typename TupleTraits::RefType, typename TupleTraits::RefType, typename TupleTraits::RefType, typename TupleTraits::RefType> RefTuple; typedef Tuple8::ParamType, typename TupleTraits::ParamType, typename TupleTraits::ParamType, typename TupleTraits::ParamType, typename TupleTraits::ParamType, typename TupleTraits::ParamType, typename TupleTraits::ParamType, typename TupleTraits::ParamType> ParamTuple; }; // Tuple creators ------------------------------------------------------------- // // Helper functions for constructing tuples while inferring the template // argument types. inline Tuple0 MakeTuple() { return Tuple0(); } template inline Tuple1 MakeTuple(const A& a) { return Tuple1(a); } template inline Tuple2 MakeTuple(const A& a, const B& b) { return Tuple2(a, b); } template inline Tuple3 MakeTuple(const A& a, const B& b, const C& c) { return Tuple3(a, b, c); } template inline Tuple4 MakeTuple(const A& a, const B& b, const C& c, const D& d) { return Tuple4(a, b, c, d); } template inline Tuple5 MakeTuple(const A& a, const B& b, const C& c, const D& d, const E& e) { return Tuple5(a, b, c, d, e); } template inline Tuple6 MakeTuple(const A& a, const B& b, const C& c, const D& d, const E& e, const F& f) { return Tuple6(a, b, c, d, e, f); } template inline Tuple7 MakeTuple(const A& a, const B& b, const C& c, const D& d, const E& e, const F& f, const G& g) { return Tuple7(a, b, c, d, e, f, g); } template inline Tuple8 MakeTuple(const A& a, const B& b, const C& c, const D& d, const E& e, const F& f, const G& g, const H& h) { return Tuple8(a, b, c, d, e, f, g, h); } // The following set of helpers make what Boost refers to as "Tiers" - a tuple // of references. template inline Tuple1 MakeRefTuple(A& a) { return Tuple1(a); } template inline Tuple2 MakeRefTuple(A& a, B& b) { return Tuple2(a, b); } template inline Tuple3 MakeRefTuple(A& a, B& b, C& c) { return Tuple3(a, b, c); } template inline Tuple4 MakeRefTuple(A& a, B& b, C& c, D& d) { return Tuple4(a, b, c, d); } template inline Tuple5 MakeRefTuple(A& a, B& b, C& c, D& d, E& e) { return Tuple5(a, b, c, d, e); } template inline Tuple6 MakeRefTuple(A& a, B& b, C& c, D& d, E& e, F& f) { return Tuple6(a, b, c, d, e, f); } template inline Tuple7 MakeRefTuple(A& a, B& b, C& c, D& d, E& e, F& f, G& g) { return Tuple7(a, b, c, d, e, f, g); } template inline Tuple8 MakeRefTuple(A& a, B& b, C& c, D& d, E& e, F& f, G& g, H& h) { return Tuple8(a, b, c, d, e, f, g, h); } // Dispatchers ---------------------------------------------------------------- // // Helper functions that call the given method on an object, with the unpacked // tuple arguments. Notice that they all have the same number of arguments, // so you need only write: // DispatchToMethod(object, &Object::method, args); // This is very useful for templated dispatchers, since they don't need to know // what type |args| is. // Non-Static Dispatchers with no out params. template inline void DispatchToMethod(ObjT* obj, Method method, const Tuple0& arg) { (obj->*method)(); } template inline void DispatchToMethod(ObjT* obj, Method method, const A& arg) { (obj->*method)(base::cef_internal::UnwrapTraits::Unwrap(arg)); } template inline void DispatchToMethod(ObjT* obj, Method method, const Tuple1& arg) { (obj->*method)(base::cef_internal::UnwrapTraits::Unwrap(arg.a)); } template inline void DispatchToMethod(ObjT* obj, Method method, const Tuple2& arg) { (obj->*method)(base::cef_internal::UnwrapTraits::Unwrap(arg.a), base::cef_internal::UnwrapTraits::Unwrap(arg.b)); } template inline void DispatchToMethod(ObjT* obj, Method method, const Tuple3& arg) { (obj->*method)(base::cef_internal::UnwrapTraits::Unwrap(arg.a), base::cef_internal::UnwrapTraits::Unwrap(arg.b), base::cef_internal::UnwrapTraits::Unwrap(arg.c)); } template inline void DispatchToMethod(ObjT* obj, Method method, const Tuple4& arg) { (obj->*method)(base::cef_internal::UnwrapTraits::Unwrap(arg.a), base::cef_internal::UnwrapTraits::Unwrap(arg.b), base::cef_internal::UnwrapTraits::Unwrap(arg.c), base::cef_internal::UnwrapTraits::Unwrap(arg.d)); } template inline void DispatchToMethod(ObjT* obj, Method method, const Tuple5& arg) { (obj->*method)(base::cef_internal::UnwrapTraits::Unwrap(arg.a), base::cef_internal::UnwrapTraits::Unwrap(arg.b), base::cef_internal::UnwrapTraits::Unwrap(arg.c), base::cef_internal::UnwrapTraits::Unwrap(arg.d), base::cef_internal::UnwrapTraits::Unwrap(arg.e)); } template inline void DispatchToMethod(ObjT* obj, Method method, const Tuple6& arg) { (obj->*method)(base::cef_internal::UnwrapTraits::Unwrap(arg.a), base::cef_internal::UnwrapTraits::Unwrap(arg.b), base::cef_internal::UnwrapTraits::Unwrap(arg.c), base::cef_internal::UnwrapTraits::Unwrap(arg.d), base::cef_internal::UnwrapTraits::Unwrap(arg.e), base::cef_internal::UnwrapTraits::Unwrap(arg.f)); } template inline void DispatchToMethod(ObjT* obj, Method method, const Tuple7& arg) { (obj->*method)(base::cef_internal::UnwrapTraits::Unwrap(arg.a), base::cef_internal::UnwrapTraits::Unwrap(arg.b), base::cef_internal::UnwrapTraits::Unwrap(arg.c), base::cef_internal::UnwrapTraits::Unwrap(arg.d), base::cef_internal::UnwrapTraits::Unwrap(arg.e), base::cef_internal::UnwrapTraits::Unwrap(arg.f), base::cef_internal::UnwrapTraits::Unwrap(arg.g)); } template inline void DispatchToMethod(ObjT* obj, Method method, const Tuple8& arg) { (obj->*method)(base::cef_internal::UnwrapTraits::Unwrap(arg.a), base::cef_internal::UnwrapTraits::Unwrap(arg.b), base::cef_internal::UnwrapTraits::Unwrap(arg.c), base::cef_internal::UnwrapTraits::Unwrap(arg.d), base::cef_internal::UnwrapTraits::Unwrap(arg.e), base::cef_internal::UnwrapTraits::Unwrap(arg.f), base::cef_internal::UnwrapTraits::Unwrap(arg.g), base::cef_internal::UnwrapTraits::Unwrap(arg.h)); } // Static Dispatchers with no out params. template inline void DispatchToFunction(Function function, const Tuple0& arg) { (*function)(); } template inline void DispatchToFunction(Function function, const A& arg) { (*function)(arg); } template inline void DispatchToFunction(Function function, const Tuple1& arg) { (*function)(base::cef_internal::UnwrapTraits::Unwrap(arg.a)); } template inline void DispatchToFunction(Function function, const Tuple2& arg) { (*function)(base::cef_internal::UnwrapTraits::Unwrap(arg.a), base::cef_internal::UnwrapTraits::Unwrap(arg.b)); } template inline void DispatchToFunction(Function function, const Tuple3& arg) { (*function)(base::cef_internal::UnwrapTraits::Unwrap(arg.a), base::cef_internal::UnwrapTraits::Unwrap(arg.b), base::cef_internal::UnwrapTraits::Unwrap(arg.c)); } template inline void DispatchToFunction(Function function, const Tuple4& arg) { (*function)(base::cef_internal::UnwrapTraits::Unwrap(arg.a), base::cef_internal::UnwrapTraits::Unwrap(arg.b), base::cef_internal::UnwrapTraits::Unwrap(arg.c), base::cef_internal::UnwrapTraits::Unwrap(arg.d)); } template inline void DispatchToFunction(Function function, const Tuple5& arg) { (*function)(base::cef_internal::UnwrapTraits::Unwrap(arg.a), base::cef_internal::UnwrapTraits::Unwrap(arg.b), base::cef_internal::UnwrapTraits::Unwrap(arg.c), base::cef_internal::UnwrapTraits::Unwrap(arg.d), base::cef_internal::UnwrapTraits::Unwrap(arg.e)); } template inline void DispatchToFunction(Function function, const Tuple6& arg) { (*function)(base::cef_internal::UnwrapTraits::Unwrap(arg.a), base::cef_internal::UnwrapTraits::Unwrap(arg.b), base::cef_internal::UnwrapTraits::Unwrap(arg.c), base::cef_internal::UnwrapTraits::Unwrap(arg.d), base::cef_internal::UnwrapTraits::Unwrap(arg.e), base::cef_internal::UnwrapTraits::Unwrap(arg.f)); } template inline void DispatchToFunction(Function function, const Tuple7& arg) { (*function)(base::cef_internal::UnwrapTraits::Unwrap(arg.a), base::cef_internal::UnwrapTraits::Unwrap(arg.b), base::cef_internal::UnwrapTraits::Unwrap(arg.c), base::cef_internal::UnwrapTraits::Unwrap(arg.d), base::cef_internal::UnwrapTraits::Unwrap(arg.e), base::cef_internal::UnwrapTraits::Unwrap(arg.f), base::cef_internal::UnwrapTraits::Unwrap(arg.g)); } template inline void DispatchToFunction(Function function, const Tuple8& arg) { (*function)(base::cef_internal::UnwrapTraits::Unwrap(arg.a), base::cef_internal::UnwrapTraits::Unwrap(arg.b), base::cef_internal::UnwrapTraits::Unwrap(arg.c), base::cef_internal::UnwrapTraits::Unwrap(arg.d), base::cef_internal::UnwrapTraits::Unwrap(arg.e), base::cef_internal::UnwrapTraits::Unwrap(arg.f), base::cef_internal::UnwrapTraits::Unwrap(arg.g), base::cef_internal::UnwrapTraits::Unwrap(arg.h)); } // Dispatchers with 0 out param (as a Tuple0). template inline void DispatchToMethod(ObjT* obj, Method method, const Tuple0& arg, Tuple0*) { (obj->*method)(); } template inline void DispatchToMethod(ObjT* obj, Method method, const A& arg, Tuple0*) { (obj->*method)(base::cef_internal::UnwrapTraits::Unwrap(arg)); } template inline void DispatchToMethod(ObjT* obj, Method method, const Tuple1& arg, Tuple0*) { (obj->*method)(base::cef_internal::UnwrapTraits::Unwrap(arg.a)); } template inline void DispatchToMethod(ObjT* obj, Method method, const Tuple2& arg, Tuple0*) { (obj->*method)(base::cef_internal::UnwrapTraits::Unwrap(arg.a), base::cef_internal::UnwrapTraits::Unwrap(arg.b)); } template inline void DispatchToMethod(ObjT* obj, Method method, const Tuple3& arg, Tuple0*) { (obj->*method)(base::cef_internal::UnwrapTraits::Unwrap(arg.a), base::cef_internal::UnwrapTraits::Unwrap(arg.b), base::cef_internal::UnwrapTraits::Unwrap(arg.c)); } template inline void DispatchToMethod(ObjT* obj, Method method, const Tuple4& arg, Tuple0*) { (obj->*method)(base::cef_internal::UnwrapTraits::Unwrap(arg.a), base::cef_internal::UnwrapTraits::Unwrap(arg.b), base::cef_internal::UnwrapTraits::Unwrap(arg.c), base::cef_internal::UnwrapTraits::Unwrap(arg.d)); } template inline void DispatchToMethod(ObjT* obj, Method method, const Tuple5& arg, Tuple0*) { (obj->*method)(base::cef_internal::UnwrapTraits::Unwrap(arg.a), base::cef_internal::UnwrapTraits::Unwrap(arg.b), base::cef_internal::UnwrapTraits::Unwrap(arg.c), base::cef_internal::UnwrapTraits::Unwrap(arg.d), base::cef_internal::UnwrapTraits::Unwrap(arg.e)); } template inline void DispatchToMethod(ObjT* obj, Method method, const Tuple6& arg, Tuple0*) { (obj->*method)(base::cef_internal::UnwrapTraits::Unwrap(arg.a), base::cef_internal::UnwrapTraits::Unwrap(arg.b), base::cef_internal::UnwrapTraits::Unwrap(arg.c), base::cef_internal::UnwrapTraits::Unwrap(arg.d), base::cef_internal::UnwrapTraits::Unwrap(arg.e), base::cef_internal::UnwrapTraits::Unwrap(arg.f)); } // Dispatchers with 1 out param. template inline void DispatchToMethod(ObjT* obj, Method method, const Tuple0& in, Tuple1* out) { (obj->*method)(&out->a); } template inline void DispatchToMethod(ObjT* obj, Method method, const InA& in, Tuple1* out) { (obj->*method)(in, &out->a); } template inline void DispatchToMethod(ObjT* obj, Method method, const Tuple1& in, Tuple1* out) { (obj->*method)(base::cef_internal::UnwrapTraits::Unwrap(in.a), &out->a); } template inline void DispatchToMethod(ObjT* obj, Method method, const Tuple2& in, Tuple1* out) { (obj->*method)(base::cef_internal::UnwrapTraits::Unwrap(in.a), base::cef_internal::UnwrapTraits::Unwrap(in.b), &out->a); } template inline void DispatchToMethod(ObjT* obj, Method method, const Tuple3& in, Tuple1* out) { (obj->*method)(base::cef_internal::UnwrapTraits::Unwrap(in.a), base::cef_internal::UnwrapTraits::Unwrap(in.b), base::cef_internal::UnwrapTraits::Unwrap(in.c), &out->a); } template inline void DispatchToMethod(ObjT* obj, Method method, const Tuple4& in, Tuple1* out) { (obj->*method)(base::cef_internal::UnwrapTraits::Unwrap(in.a), base::cef_internal::UnwrapTraits::Unwrap(in.b), base::cef_internal::UnwrapTraits::Unwrap(in.c), base::cef_internal::UnwrapTraits::Unwrap(in.d), &out->a); } template inline void DispatchToMethod(ObjT* obj, Method method, const Tuple5& in, Tuple1* out) { (obj->*method)(base::cef_internal::UnwrapTraits::Unwrap(in.a), base::cef_internal::UnwrapTraits::Unwrap(in.b), base::cef_internal::UnwrapTraits::Unwrap(in.c), base::cef_internal::UnwrapTraits::Unwrap(in.d), base::cef_internal::UnwrapTraits::Unwrap(in.e), &out->a); } template inline void DispatchToMethod(ObjT* obj, Method method, const Tuple6& in, Tuple1* out) { (obj->*method)(base::cef_internal::UnwrapTraits::Unwrap(in.a), base::cef_internal::UnwrapTraits::Unwrap(in.b), base::cef_internal::UnwrapTraits::Unwrap(in.c), base::cef_internal::UnwrapTraits::Unwrap(in.d), base::cef_internal::UnwrapTraits::Unwrap(in.e), base::cef_internal::UnwrapTraits::Unwrap(in.f), &out->a); } // Dispatchers with 2 out params. template inline void DispatchToMethod(ObjT* obj, Method method, const Tuple0& in, Tuple2* out) { (obj->*method)(&out->a, &out->b); } template inline void DispatchToMethod(ObjT* obj, Method method, const InA& in, Tuple2* out) { (obj->*method)(in, &out->a, &out->b); } template inline void DispatchToMethod(ObjT* obj, Method method, const Tuple1& in, Tuple2* out) { (obj->*method)( base::cef_internal::UnwrapTraits::Unwrap(in.a), &out->a, &out->b); } template inline void DispatchToMethod(ObjT* obj, Method method, const Tuple2& in, Tuple2* out) { (obj->*method)(base::cef_internal::UnwrapTraits::Unwrap(in.a), base::cef_internal::UnwrapTraits::Unwrap(in.b), &out->a, &out->b); } template inline void DispatchToMethod(ObjT* obj, Method method, const Tuple3& in, Tuple2* out) { (obj->*method)(base::cef_internal::UnwrapTraits::Unwrap(in.a), base::cef_internal::UnwrapTraits::Unwrap(in.b), base::cef_internal::UnwrapTraits::Unwrap(in.c), &out->a, &out->b); } template inline void DispatchToMethod(ObjT* obj, Method method, const Tuple4& in, Tuple2* out) { (obj->*method)(base::cef_internal::UnwrapTraits::Unwrap(in.a), base::cef_internal::UnwrapTraits::Unwrap(in.b), base::cef_internal::UnwrapTraits::Unwrap(in.c), base::cef_internal::UnwrapTraits::Unwrap(in.d), &out->a, &out->b); } template inline void DispatchToMethod(ObjT* obj, Method method, const Tuple5& in, Tuple2* out) { (obj->*method)(base::cef_internal::UnwrapTraits::Unwrap(in.a), base::cef_internal::UnwrapTraits::Unwrap(in.b), base::cef_internal::UnwrapTraits::Unwrap(in.c), base::cef_internal::UnwrapTraits::Unwrap(in.d), base::cef_internal::UnwrapTraits::Unwrap(in.e), &out->a, &out->b); } template inline void DispatchToMethod(ObjT* obj, Method method, const Tuple6& in, Tuple2* out) { (obj->*method)(base::cef_internal::UnwrapTraits::Unwrap(in.a), base::cef_internal::UnwrapTraits::Unwrap(in.b), base::cef_internal::UnwrapTraits::Unwrap(in.c), base::cef_internal::UnwrapTraits::Unwrap(in.d), base::cef_internal::UnwrapTraits::Unwrap(in.e), base::cef_internal::UnwrapTraits::Unwrap(in.f), &out->a, &out->b); } // Dispatchers with 3 out params. template inline void DispatchToMethod(ObjT* obj, Method method, const Tuple0& in, Tuple3* out) { (obj->*method)(&out->a, &out->b, &out->c); } template inline void DispatchToMethod(ObjT* obj, Method method, const InA& in, Tuple3* out) { (obj->*method)(in, &out->a, &out->b, &out->c); } template inline void DispatchToMethod(ObjT* obj, Method method, const Tuple1& in, Tuple3* out) { (obj->*method)(base::cef_internal::UnwrapTraits::Unwrap(in.a), &out->a, &out->b, &out->c); } template inline void DispatchToMethod(ObjT* obj, Method method, const Tuple2& in, Tuple3* out) { (obj->*method)(base::cef_internal::UnwrapTraits::Unwrap(in.a), base::cef_internal::UnwrapTraits::Unwrap(in.b), &out->a, &out->b, &out->c); } template inline void DispatchToMethod(ObjT* obj, Method method, const Tuple3& in, Tuple3* out) { (obj->*method)(base::cef_internal::UnwrapTraits::Unwrap(in.a), base::cef_internal::UnwrapTraits::Unwrap(in.b), base::cef_internal::UnwrapTraits::Unwrap(in.c), &out->a, &out->b, &out->c); } template inline void DispatchToMethod(ObjT* obj, Method method, const Tuple4& in, Tuple3* out) { (obj->*method)(base::cef_internal::UnwrapTraits::Unwrap(in.a), base::cef_internal::UnwrapTraits::Unwrap(in.b), base::cef_internal::UnwrapTraits::Unwrap(in.c), base::cef_internal::UnwrapTraits::Unwrap(in.d), &out->a, &out->b, &out->c); } template inline void DispatchToMethod(ObjT* obj, Method method, const Tuple5& in, Tuple3* out) { (obj->*method)(base::cef_internal::UnwrapTraits::Unwrap(in.a), base::cef_internal::UnwrapTraits::Unwrap(in.b), base::cef_internal::UnwrapTraits::Unwrap(in.c), base::cef_internal::UnwrapTraits::Unwrap(in.d), base::cef_internal::UnwrapTraits::Unwrap(in.e), &out->a, &out->b, &out->c); } template inline void DispatchToMethod(ObjT* obj, Method method, const Tuple6& in, Tuple3* out) { (obj->*method)(base::cef_internal::UnwrapTraits::Unwrap(in.a), base::cef_internal::UnwrapTraits::Unwrap(in.b), base::cef_internal::UnwrapTraits::Unwrap(in.c), base::cef_internal::UnwrapTraits::Unwrap(in.d), base::cef_internal::UnwrapTraits::Unwrap(in.e), base::cef_internal::UnwrapTraits::Unwrap(in.f), &out->a, &out->b, &out->c); } // Dispatchers with 4 out params. template inline void DispatchToMethod(ObjT* obj, Method method, const Tuple0& in, Tuple4* out) { (obj->*method)(&out->a, &out->b, &out->c, &out->d); } template inline void DispatchToMethod(ObjT* obj, Method method, const InA& in, Tuple4* out) { (obj->*method)(base::cef_internal::UnwrapTraits::Unwrap(in), &out->a, &out->b, &out->c, &out->d); } template inline void DispatchToMethod(ObjT* obj, Method method, const Tuple1& in, Tuple4* out) { (obj->*method)(base::cef_internal::UnwrapTraits::Unwrap(in.a), &out->a, &out->b, &out->c, &out->d); } template inline void DispatchToMethod(ObjT* obj, Method method, const Tuple2& in, Tuple4* out) { (obj->*method)(base::cef_internal::UnwrapTraits::Unwrap(in.a), base::cef_internal::UnwrapTraits::Unwrap(in.b), &out->a, &out->b, &out->c, &out->d); } template inline void DispatchToMethod(ObjT* obj, Method method, const Tuple3& in, Tuple4* out) { (obj->*method)(base::cef_internal::UnwrapTraits::Unwrap(in.a), base::cef_internal::UnwrapTraits::Unwrap(in.b), base::cef_internal::UnwrapTraits::Unwrap(in.c), &out->a, &out->b, &out->c, &out->d); } template inline void DispatchToMethod(ObjT* obj, Method method, const Tuple4& in, Tuple4* out) { (obj->*method)(base::cef_internal::UnwrapTraits::Unwrap(in.a), base::cef_internal::UnwrapTraits::Unwrap(in.b), base::cef_internal::UnwrapTraits::Unwrap(in.c), base::cef_internal::UnwrapTraits::Unwrap(in.d), &out->a, &out->b, &out->c, &out->d); } template inline void DispatchToMethod(ObjT* obj, Method method, const Tuple5& in, Tuple4* out) { (obj->*method)(base::cef_internal::UnwrapTraits::Unwrap(in.a), base::cef_internal::UnwrapTraits::Unwrap(in.b), base::cef_internal::UnwrapTraits::Unwrap(in.c), base::cef_internal::UnwrapTraits::Unwrap(in.d), base::cef_internal::UnwrapTraits::Unwrap(in.e), &out->a, &out->b, &out->c, &out->d); } template inline void DispatchToMethod(ObjT* obj, Method method, const Tuple6& in, Tuple4* out) { (obj->*method)(base::cef_internal::UnwrapTraits::Unwrap(in.a), base::cef_internal::UnwrapTraits::Unwrap(in.b), base::cef_internal::UnwrapTraits::Unwrap(in.c), base::cef_internal::UnwrapTraits::Unwrap(in.d), base::cef_internal::UnwrapTraits::Unwrap(in.e), base::cef_internal::UnwrapTraits::Unwrap(in.f), &out->a, &out->b, &out->c, &out->d); } // Dispatchers with 5 out params. template inline void DispatchToMethod(ObjT* obj, Method method, const Tuple0& in, Tuple5* out) { (obj->*method)(&out->a, &out->b, &out->c, &out->d, &out->e); } template inline void DispatchToMethod(ObjT* obj, Method method, const InA& in, Tuple5* out) { (obj->*method)(base::cef_internal::UnwrapTraits::Unwrap(in), &out->a, &out->b, &out->c, &out->d, &out->e); } template inline void DispatchToMethod(ObjT* obj, Method method, const Tuple1& in, Tuple5* out) { (obj->*method)(base::cef_internal::UnwrapTraits::Unwrap(in.a), &out->a, &out->b, &out->c, &out->d, &out->e); } template inline void DispatchToMethod(ObjT* obj, Method method, const Tuple2& in, Tuple5* out) { (obj->*method)(base::cef_internal::UnwrapTraits::Unwrap(in.a), base::cef_internal::UnwrapTraits::Unwrap(in.b), &out->a, &out->b, &out->c, &out->d, &out->e); } template inline void DispatchToMethod(ObjT* obj, Method method, const Tuple3& in, Tuple5* out) { (obj->*method)(base::cef_internal::UnwrapTraits::Unwrap(in.a), base::cef_internal::UnwrapTraits::Unwrap(in.b), base::cef_internal::UnwrapTraits::Unwrap(in.c), &out->a, &out->b, &out->c, &out->d, &out->e); } template inline void DispatchToMethod(ObjT* obj, Method method, const Tuple4& in, Tuple5* out) { (obj->*method)(base::cef_internal::UnwrapTraits::Unwrap(in.a), base::cef_internal::UnwrapTraits::Unwrap(in.b), base::cef_internal::UnwrapTraits::Unwrap(in.c), base::cef_internal::UnwrapTraits::Unwrap(in.d), &out->a, &out->b, &out->c, &out->d, &out->e); } template inline void DispatchToMethod(ObjT* obj, Method method, const Tuple5& in, Tuple5* out) { (obj->*method)(base::cef_internal::UnwrapTraits::Unwrap(in.a), base::cef_internal::UnwrapTraits::Unwrap(in.b), base::cef_internal::UnwrapTraits::Unwrap(in.c), base::cef_internal::UnwrapTraits::Unwrap(in.d), base::cef_internal::UnwrapTraits::Unwrap(in.e), &out->a, &out->b, &out->c, &out->d, &out->e); } template inline void DispatchToMethod(ObjT* obj, Method method, const Tuple6& in, Tuple5* out) { (obj->*method)(base::cef_internal::UnwrapTraits::Unwrap(in.a), base::cef_internal::UnwrapTraits::Unwrap(in.b), base::cef_internal::UnwrapTraits::Unwrap(in.c), base::cef_internal::UnwrapTraits::Unwrap(in.d), base::cef_internal::UnwrapTraits::Unwrap(in.e), base::cef_internal::UnwrapTraits::Unwrap(in.f), &out->a, &out->b, &out->c, &out->d, &out->e); } } // namespace base #endif // !BUILDING_CEF_SHARED #endif // CEF_INCLUDE_BASE_CEF_TUPLE_H_ cefpython-49.0/src/include/base/cef_weak_ptr.h000066400000000000000000000322601334103266300213770ustar00rootroot00000000000000// Copyright (c) 2014 Marshall A. Greenblatt. Portions copyright (c) 2012 // Google Inc. 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. // Weak pointers are pointers to an object that do not affect its lifetime, // and which may be invalidated (i.e. reset to NULL) by the object, or its // owner, at any time, most commonly when the object is about to be deleted. // Weak pointers are useful when an object needs to be accessed safely by one // or more objects other than its owner, and those callers can cope with the // object vanishing and e.g. tasks posted to it being silently dropped. // Reference-counting such an object would complicate the ownership graph and // make it harder to reason about the object's lifetime. // EXAMPLE: // // class Controller { // public: // Controller() : weak_factory_(this) {} // void SpawnWorker() { Worker::StartNew(weak_factory_.GetWeakPtr()); } // void WorkComplete(const Result& result) { ... } // private: // // Member variables should appear before the WeakPtrFactory, to ensure // // that any WeakPtrs to Controller are invalidated before its members // // variable's destructors are executed, rendering them invalid. // WeakPtrFactory weak_factory_; // }; // // class Worker { // public: // static void StartNew(const WeakPtr& controller) { // Worker* worker = new Worker(controller); // // Kick off asynchronous processing... // } // private: // Worker(const WeakPtr& controller) // : controller_(controller) {} // void DidCompleteAsynchronousProcessing(const Result& result) { // if (controller_) // controller_->WorkComplete(result); // } // WeakPtr controller_; // }; // // With this implementation a caller may use SpawnWorker() to dispatch multiple // Workers and subsequently delete the Controller, without waiting for all // Workers to have completed. // ------------------------- IMPORTANT: Thread-safety ------------------------- // Weak pointers may be passed safely between threads, but must always be // dereferenced and invalidated on the same thread otherwise checking the // pointer would be racey. // // To ensure correct use, the first time a WeakPtr issued by a WeakPtrFactory // is dereferenced, the factory and its WeakPtrs become bound to the calling // thread, and cannot be dereferenced or invalidated on any other thread. Bound // WeakPtrs can still be handed off to other threads, e.g. to use to post tasks // back to object on the bound thread. // // If all WeakPtr objects are destroyed or invalidated then the factory is // unbound from the SequencedTaskRunner/Thread. The WeakPtrFactory may then be // destroyed, or new WeakPtr objects may be used, from a different sequence. // // Thus, at least one WeakPtr object must exist and have been dereferenced on // the correct thread to enforce that other WeakPtr objects will enforce they // are used on the desired thread. #ifndef CEF_INCLUDE_BASE_CEF_WEAK_PTR_H_ #define CEF_INCLUDE_BASE_CEF_WEAK_PTR_H_ #pragma once #if defined(BASE_MEMORY_WEAK_PTR_H_) // Do nothing if the Chromium header has already been included. // This can happen in cases where Chromium code is used directly by the // client application. When using Chromium code directly always include // the Chromium header first to avoid type conflicts. #elif defined(BUILDING_CEF_SHARED) // When building CEF include the Chromium header directly. #include "base/memory/weak_ptr.h" #else // !BUILDING_CEF_SHARED // The following is substantially similar to the Chromium implementation. // If the Chromium implementation diverges the below implementation should be // updated to match. #include "include/base/cef_basictypes.h" #include "include/base/cef_logging.h" #include "include/base/cef_ref_counted.h" #include "include/base/cef_template_util.h" #include "include/base/cef_thread_checker.h" namespace base { template class SupportsWeakPtr; template class WeakPtr; namespace cef_internal { // These classes are part of the WeakPtr implementation. // DO NOT USE THESE CLASSES DIRECTLY YOURSELF. class WeakReference { public: // Although Flag is bound to a specific thread, it may be deleted from another // via base::WeakPtr::~WeakPtr(). class Flag : public RefCountedThreadSafe { public: Flag(); void Invalidate(); bool IsValid() const; private: friend class base::RefCountedThreadSafe; ~Flag(); // The current Chromium implementation uses SequenceChecker instead of // ThreadChecker to support SequencedWorkerPools. CEF does not yet expose // the concept of SequencedWorkerPools. ThreadChecker thread_checker_; bool is_valid_; }; WeakReference(); explicit WeakReference(const Flag* flag); ~WeakReference(); bool is_valid() const; private: scoped_refptr flag_; }; class WeakReferenceOwner { public: WeakReferenceOwner(); ~WeakReferenceOwner(); WeakReference GetRef() const; bool HasRefs() const { return flag_.get() && !flag_->HasOneRef(); } void Invalidate(); private: mutable scoped_refptr flag_; }; // This class simplifies the implementation of WeakPtr's type conversion // constructor by avoiding the need for a public accessor for ref_. A // WeakPtr cannot access the private members of WeakPtr, so this // base class gives us a way to access ref_ in a protected fashion. class WeakPtrBase { public: WeakPtrBase(); ~WeakPtrBase(); protected: explicit WeakPtrBase(const WeakReference& ref); WeakReference ref_; }; // This class provides a common implementation of common functions that would // otherwise get instantiated separately for each distinct instantiation of // SupportsWeakPtr<>. class SupportsWeakPtrBase { public: // A safe static downcast of a WeakPtr to WeakPtr. This // conversion will only compile if there is exists a Base which inherits // from SupportsWeakPtr. See base::AsWeakPtr() below for a helper // function that makes calling this easier. template static WeakPtr StaticAsWeakPtr(Derived* t) { typedef is_convertible convertible; COMPILE_ASSERT(convertible::value, AsWeakPtr_argument_inherits_from_SupportsWeakPtr); return AsWeakPtrImpl(t, *t); } private: // This template function uses type inference to find a Base of Derived // which is an instance of SupportsWeakPtr. We can then safely // static_cast the Base* to a Derived*. template static WeakPtr AsWeakPtrImpl( Derived* t, const SupportsWeakPtr&) { WeakPtr ptr = t->Base::AsWeakPtr(); return WeakPtr(ptr.ref_, static_cast(ptr.ptr_)); } }; } // namespace cef_internal template class WeakPtrFactory; // The WeakPtr class holds a weak reference to |T*|. // // This class is designed to be used like a normal pointer. You should always // null-test an object of this class before using it or invoking a method that // may result in the underlying object being destroyed. // // EXAMPLE: // // class Foo { ... }; // WeakPtr foo; // if (foo) // foo->method(); // template class WeakPtr : public cef_internal::WeakPtrBase { public: WeakPtr() : ptr_(NULL) { } // Allow conversion from U to T provided U "is a" T. Note that this // is separate from the (implicit) copy constructor. template WeakPtr(const WeakPtr& other) : WeakPtrBase(other), ptr_(other.ptr_) { } T* get() const { return ref_.is_valid() ? ptr_ : NULL; } T& operator*() const { DCHECK(get() != NULL); return *get(); } T* operator->() const { DCHECK(get() != NULL); return get(); } // Allow WeakPtr to be used in boolean expressions, but not // implicitly convertible to a real bool (which is dangerous). // // Note that this trick is only safe when the == and != operators // are declared explicitly, as otherwise "weak_ptr1 == weak_ptr2" // will compile but do the wrong thing (i.e., convert to Testable // and then do the comparison). private: typedef T* WeakPtr::*Testable; public: operator Testable() const { return get() ? &WeakPtr::ptr_ : NULL; } void reset() { ref_ = cef_internal::WeakReference(); ptr_ = NULL; } private: // Explicitly declare comparison operators as required by the bool // trick, but keep them private. template bool operator==(WeakPtr const&) const; template bool operator!=(WeakPtr const&) const; friend class cef_internal::SupportsWeakPtrBase; template friend class WeakPtr; friend class SupportsWeakPtr; friend class WeakPtrFactory; WeakPtr(const cef_internal::WeakReference& ref, T* ptr) : WeakPtrBase(ref), ptr_(ptr) { } // This pointer is only valid when ref_.is_valid() is true. Otherwise, its // value is undefined (as opposed to NULL). T* ptr_; }; // A class may be composed of a WeakPtrFactory and thereby // control how it exposes weak pointers to itself. This is helpful if you only // need weak pointers within the implementation of a class. This class is also // useful when working with primitive types. For example, you could have a // WeakPtrFactory that is used to pass around a weak reference to a bool. template class WeakPtrFactory { public: explicit WeakPtrFactory(T* ptr) : ptr_(ptr) { } ~WeakPtrFactory() { ptr_ = NULL; } WeakPtr GetWeakPtr() { DCHECK(ptr_); return WeakPtr(weak_reference_owner_.GetRef(), ptr_); } // Call this method to invalidate all existing weak pointers. void InvalidateWeakPtrs() { DCHECK(ptr_); weak_reference_owner_.Invalidate(); } // Call this method to determine if any weak pointers exist. bool HasWeakPtrs() const { DCHECK(ptr_); return weak_reference_owner_.HasRefs(); } private: cef_internal::WeakReferenceOwner weak_reference_owner_; T* ptr_; DISALLOW_IMPLICIT_CONSTRUCTORS(WeakPtrFactory); }; // A class may extend from SupportsWeakPtr to let others take weak pointers to // it. This avoids the class itself implementing boilerplate to dispense weak // pointers. However, since SupportsWeakPtr's destructor won't invalidate // weak pointers to the class until after the derived class' members have been // destroyed, its use can lead to subtle use-after-destroy issues. template class SupportsWeakPtr : public cef_internal::SupportsWeakPtrBase { public: SupportsWeakPtr() {} WeakPtr AsWeakPtr() { return WeakPtr(weak_reference_owner_.GetRef(), static_cast(this)); } protected: ~SupportsWeakPtr() {} private: cef_internal::WeakReferenceOwner weak_reference_owner_; DISALLOW_COPY_AND_ASSIGN(SupportsWeakPtr); }; // Helper function that uses type deduction to safely return a WeakPtr // when Derived doesn't directly extend SupportsWeakPtr, instead it // extends a Base that extends SupportsWeakPtr. // // EXAMPLE: // class Base : public base::SupportsWeakPtr {}; // class Derived : public Base {}; // // Derived derived; // base::WeakPtr ptr = base::AsWeakPtr(&derived); // // Note that the following doesn't work (invalid type conversion) since // Derived::AsWeakPtr() is WeakPtr SupportsWeakPtr::AsWeakPtr(), // and there's no way to safely cast WeakPtr to WeakPtr at // the caller. // // base::WeakPtr ptr = derived.AsWeakPtr(); // Fails. template WeakPtr AsWeakPtr(Derived* t) { return cef_internal::SupportsWeakPtrBase::StaticAsWeakPtr(t); } } // namespace base #endif // !BUILDING_CEF_SHARED #endif // CEF_INCLUDE_BASE_CEF_WEAK_PTR_H_ cefpython-49.0/src/include/base/internal/000077500000000000000000000000001334103266300204065ustar00rootroot00000000000000cefpython-49.0/src/include/base/internal/cef_atomicops_atomicword_compat.h000066400000000000000000000121001334103266300271570ustar00rootroot00000000000000// Copyright (c) 2011 Google Inc. 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. // Do not include this header file directly. Use base/cef_atomicops.h // instead. #ifndef CEF_INCLUDE_BASE_INTERNAL_CEF_ATOMICOPS_ATOMICWORD_COMPAT_H_ #define CEF_INCLUDE_BASE_INTERNAL_CEF_ATOMICOPS_ATOMICWORD_COMPAT_H_ // AtomicWord is a synonym for intptr_t, and Atomic32 is a synonym for int32, // which in turn means int. On some LP32 platforms, intptr_t is an int, but // on others, it's a long. When AtomicWord and Atomic32 are based on different // fundamental types, their pointers are incompatible. // // This file defines function overloads to allow both AtomicWord and Atomic32 // data to be used with this interface. // // On LP64 platforms, AtomicWord and Atomic64 are both always long, // so this problem doesn't occur. #if !defined(ARCH_CPU_64_BITS) namespace base { namespace subtle { inline AtomicWord NoBarrier_CompareAndSwap(volatile AtomicWord* ptr, AtomicWord old_value, AtomicWord new_value) { return NoBarrier_CompareAndSwap( reinterpret_cast(ptr), old_value, new_value); } inline AtomicWord NoBarrier_AtomicExchange(volatile AtomicWord* ptr, AtomicWord new_value) { return NoBarrier_AtomicExchange( reinterpret_cast(ptr), new_value); } inline AtomicWord NoBarrier_AtomicIncrement(volatile AtomicWord* ptr, AtomicWord increment) { return NoBarrier_AtomicIncrement( reinterpret_cast(ptr), increment); } inline AtomicWord Barrier_AtomicIncrement(volatile AtomicWord* ptr, AtomicWord increment) { return Barrier_AtomicIncrement( reinterpret_cast(ptr), increment); } inline AtomicWord Acquire_CompareAndSwap(volatile AtomicWord* ptr, AtomicWord old_value, AtomicWord new_value) { return base::subtle::Acquire_CompareAndSwap( reinterpret_cast(ptr), old_value, new_value); } inline AtomicWord Release_CompareAndSwap(volatile AtomicWord* ptr, AtomicWord old_value, AtomicWord new_value) { return base::subtle::Release_CompareAndSwap( reinterpret_cast(ptr), old_value, new_value); } inline void NoBarrier_Store(volatile AtomicWord *ptr, AtomicWord value) { NoBarrier_Store( reinterpret_cast(ptr), value); } inline void Acquire_Store(volatile AtomicWord* ptr, AtomicWord value) { return base::subtle::Acquire_Store( reinterpret_cast(ptr), value); } inline void Release_Store(volatile AtomicWord* ptr, AtomicWord value) { return base::subtle::Release_Store( reinterpret_cast(ptr), value); } inline AtomicWord NoBarrier_Load(volatile const AtomicWord *ptr) { return NoBarrier_Load( reinterpret_cast(ptr)); } inline AtomicWord Acquire_Load(volatile const AtomicWord* ptr) { return base::subtle::Acquire_Load( reinterpret_cast(ptr)); } inline AtomicWord Release_Load(volatile const AtomicWord* ptr) { return base::subtle::Release_Load( reinterpret_cast(ptr)); } } // namespace base::subtle } // namespace base #endif // !defined(ARCH_CPU_64_BITS) #endif // CEF_INCLUDE_BASE_INTERNAL_CEF_ATOMICOPS_ATOMICWORD_COMPAT_H_ cefpython-49.0/src/include/base/internal/cef_atomicops_mac.h000066400000000000000000000161541334103266300242210ustar00rootroot00000000000000// Copyright (c) 2012 Google Inc. 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. // Do not include this header file directly. Use base/cef_atomicops.h // instead. #ifndef CEF_INCLUDE_BASE_INTERNAL_CEF_ATOMICOPS_MAC_H_ #define CEF_INCLUDE_BASE_INTERNAL_CEF_ATOMICOPS_MAC_H_ #include namespace base { namespace subtle { inline Atomic32 NoBarrier_CompareAndSwap(volatile Atomic32* ptr, Atomic32 old_value, Atomic32 new_value) { Atomic32 prev_value; do { if (OSAtomicCompareAndSwap32(old_value, new_value, const_cast(ptr))) { return old_value; } prev_value = *ptr; } while (prev_value == old_value); return prev_value; } inline Atomic32 NoBarrier_AtomicExchange(volatile Atomic32* ptr, Atomic32 new_value) { Atomic32 old_value; do { old_value = *ptr; } while (!OSAtomicCompareAndSwap32(old_value, new_value, const_cast(ptr))); return old_value; } inline Atomic32 NoBarrier_AtomicIncrement(volatile Atomic32* ptr, Atomic32 increment) { return OSAtomicAdd32(increment, const_cast(ptr)); } inline Atomic32 Barrier_AtomicIncrement(volatile Atomic32* ptr, Atomic32 increment) { return OSAtomicAdd32Barrier(increment, const_cast(ptr)); } inline void MemoryBarrier() { OSMemoryBarrier(); } inline Atomic32 Acquire_CompareAndSwap(volatile Atomic32* ptr, Atomic32 old_value, Atomic32 new_value) { Atomic32 prev_value; do { if (OSAtomicCompareAndSwap32Barrier(old_value, new_value, const_cast(ptr))) { return old_value; } prev_value = *ptr; } while (prev_value == old_value); return prev_value; } inline Atomic32 Release_CompareAndSwap(volatile Atomic32* ptr, Atomic32 old_value, Atomic32 new_value) { return Acquire_CompareAndSwap(ptr, old_value, new_value); } inline void NoBarrier_Store(volatile Atomic32* ptr, Atomic32 value) { *ptr = value; } inline void Acquire_Store(volatile Atomic32* ptr, Atomic32 value) { *ptr = value; MemoryBarrier(); } inline void Release_Store(volatile Atomic32* ptr, Atomic32 value) { MemoryBarrier(); *ptr = value; } inline Atomic32 NoBarrier_Load(volatile const Atomic32* ptr) { return *ptr; } inline Atomic32 Acquire_Load(volatile const Atomic32* ptr) { Atomic32 value = *ptr; MemoryBarrier(); return value; } inline Atomic32 Release_Load(volatile const Atomic32* ptr) { MemoryBarrier(); return *ptr; } #ifdef __LP64__ // 64-bit implementation on 64-bit platform inline Atomic64 NoBarrier_CompareAndSwap(volatile Atomic64* ptr, Atomic64 old_value, Atomic64 new_value) { Atomic64 prev_value; do { if (OSAtomicCompareAndSwap64(old_value, new_value, reinterpret_cast(ptr))) { return old_value; } prev_value = *ptr; } while (prev_value == old_value); return prev_value; } inline Atomic64 NoBarrier_AtomicExchange(volatile Atomic64* ptr, Atomic64 new_value) { Atomic64 old_value; do { old_value = *ptr; } while (!OSAtomicCompareAndSwap64(old_value, new_value, reinterpret_cast(ptr))); return old_value; } inline Atomic64 NoBarrier_AtomicIncrement(volatile Atomic64* ptr, Atomic64 increment) { return OSAtomicAdd64(increment, reinterpret_cast(ptr)); } inline Atomic64 Barrier_AtomicIncrement(volatile Atomic64* ptr, Atomic64 increment) { return OSAtomicAdd64Barrier(increment, reinterpret_cast(ptr)); } inline Atomic64 Acquire_CompareAndSwap(volatile Atomic64* ptr, Atomic64 old_value, Atomic64 new_value) { Atomic64 prev_value; do { if (OSAtomicCompareAndSwap64Barrier( old_value, new_value, reinterpret_cast(ptr))) { return old_value; } prev_value = *ptr; } while (prev_value == old_value); return prev_value; } inline Atomic64 Release_CompareAndSwap(volatile Atomic64* ptr, Atomic64 old_value, Atomic64 new_value) { // The lib kern interface does not distinguish between // Acquire and Release memory barriers; they are equivalent. return Acquire_CompareAndSwap(ptr, old_value, new_value); } inline void NoBarrier_Store(volatile Atomic64* ptr, Atomic64 value) { *ptr = value; } inline void Acquire_Store(volatile Atomic64* ptr, Atomic64 value) { *ptr = value; MemoryBarrier(); } inline void Release_Store(volatile Atomic64* ptr, Atomic64 value) { MemoryBarrier(); *ptr = value; } inline Atomic64 NoBarrier_Load(volatile const Atomic64* ptr) { return *ptr; } inline Atomic64 Acquire_Load(volatile const Atomic64* ptr) { Atomic64 value = *ptr; MemoryBarrier(); return value; } inline Atomic64 Release_Load(volatile const Atomic64* ptr) { MemoryBarrier(); return *ptr; } #endif // defined(__LP64__) } // namespace base::subtle } // namespace base #endif // CEF_INCLUDE_BASE_INTERNAL_CEF_ATOMICOPS_MAC_H_ cefpython-49.0/src/include/base/internal/cef_atomicops_x86_gcc.h000066400000000000000000000231401334103266300247130ustar00rootroot00000000000000// Copyright (c) 2011 Google Inc. 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. // Do not include this header file directly. Use base/cef_atomicops.h // instead. #ifndef CEF_INCLUDE_BASE_INTERNAL_CEF_ATOMICOPS_X86_GCC_H_ #define CEF_INCLUDE_BASE_INTERNAL_CEF_ATOMICOPS_X86_GCC_H_ // This struct is not part of the public API of this module; clients may not // use it. // Features of this x86. Values may not be correct before main() is run, // but are set conservatively. struct AtomicOps_x86CPUFeatureStruct { bool has_amd_lock_mb_bug; // Processor has AMD memory-barrier bug; do lfence // after acquire compare-and-swap. }; extern struct AtomicOps_x86CPUFeatureStruct AtomicOps_Internalx86CPUFeatures; #define ATOMICOPS_COMPILER_BARRIER() __asm__ __volatile__("" : : : "memory") namespace base { namespace subtle { // 32-bit low-level operations on any platform. inline Atomic32 NoBarrier_CompareAndSwap(volatile Atomic32* ptr, Atomic32 old_value, Atomic32 new_value) { Atomic32 prev; __asm__ __volatile__("lock; cmpxchgl %1,%2" : "=a" (prev) : "q" (new_value), "m" (*ptr), "0" (old_value) : "memory"); return prev; } inline Atomic32 NoBarrier_AtomicExchange(volatile Atomic32* ptr, Atomic32 new_value) { __asm__ __volatile__("xchgl %1,%0" // The lock prefix is implicit for xchg. : "=r" (new_value) : "m" (*ptr), "0" (new_value) : "memory"); return new_value; // Now it's the previous value. } inline Atomic32 NoBarrier_AtomicIncrement(volatile Atomic32* ptr, Atomic32 increment) { Atomic32 temp = increment; __asm__ __volatile__("lock; xaddl %0,%1" : "+r" (temp), "+m" (*ptr) : : "memory"); // temp now holds the old value of *ptr return temp + increment; } inline Atomic32 Barrier_AtomicIncrement(volatile Atomic32* ptr, Atomic32 increment) { Atomic32 temp = increment; __asm__ __volatile__("lock; xaddl %0,%1" : "+r" (temp), "+m" (*ptr) : : "memory"); // temp now holds the old value of *ptr if (AtomicOps_Internalx86CPUFeatures.has_amd_lock_mb_bug) { __asm__ __volatile__("lfence" : : : "memory"); } return temp + increment; } inline Atomic32 Acquire_CompareAndSwap(volatile Atomic32* ptr, Atomic32 old_value, Atomic32 new_value) { Atomic32 x = NoBarrier_CompareAndSwap(ptr, old_value, new_value); if (AtomicOps_Internalx86CPUFeatures.has_amd_lock_mb_bug) { __asm__ __volatile__("lfence" : : : "memory"); } return x; } inline Atomic32 Release_CompareAndSwap(volatile Atomic32* ptr, Atomic32 old_value, Atomic32 new_value) { return NoBarrier_CompareAndSwap(ptr, old_value, new_value); } inline void NoBarrier_Store(volatile Atomic32* ptr, Atomic32 value) { *ptr = value; } inline void MemoryBarrier() { __asm__ __volatile__("mfence" : : : "memory"); } inline void Acquire_Store(volatile Atomic32* ptr, Atomic32 value) { *ptr = value; MemoryBarrier(); } inline void Release_Store(volatile Atomic32* ptr, Atomic32 value) { ATOMICOPS_COMPILER_BARRIER(); *ptr = value; // An x86 store acts as a release barrier. // See comments in Atomic64 version of Release_Store(), below. } inline Atomic32 NoBarrier_Load(volatile const Atomic32* ptr) { return *ptr; } inline Atomic32 Acquire_Load(volatile const Atomic32* ptr) { Atomic32 value = *ptr; // An x86 load acts as a acquire barrier. // See comments in Atomic64 version of Release_Store(), below. ATOMICOPS_COMPILER_BARRIER(); return value; } inline Atomic32 Release_Load(volatile const Atomic32* ptr) { MemoryBarrier(); return *ptr; } #if defined(__x86_64__) // 64-bit low-level operations on 64-bit platform. inline Atomic64 NoBarrier_CompareAndSwap(volatile Atomic64* ptr, Atomic64 old_value, Atomic64 new_value) { Atomic64 prev; __asm__ __volatile__("lock; cmpxchgq %1,%2" : "=a" (prev) : "q" (new_value), "m" (*ptr), "0" (old_value) : "memory"); return prev; } inline Atomic64 NoBarrier_AtomicExchange(volatile Atomic64* ptr, Atomic64 new_value) { __asm__ __volatile__("xchgq %1,%0" // The lock prefix is implicit for xchg. : "=r" (new_value) : "m" (*ptr), "0" (new_value) : "memory"); return new_value; // Now it's the previous value. } inline Atomic64 NoBarrier_AtomicIncrement(volatile Atomic64* ptr, Atomic64 increment) { Atomic64 temp = increment; __asm__ __volatile__("lock; xaddq %0,%1" : "+r" (temp), "+m" (*ptr) : : "memory"); // temp now contains the previous value of *ptr return temp + increment; } inline Atomic64 Barrier_AtomicIncrement(volatile Atomic64* ptr, Atomic64 increment) { Atomic64 temp = increment; __asm__ __volatile__("lock; xaddq %0,%1" : "+r" (temp), "+m" (*ptr) : : "memory"); // temp now contains the previous value of *ptr if (AtomicOps_Internalx86CPUFeatures.has_amd_lock_mb_bug) { __asm__ __volatile__("lfence" : : : "memory"); } return temp + increment; } inline void NoBarrier_Store(volatile Atomic64* ptr, Atomic64 value) { *ptr = value; } inline void Acquire_Store(volatile Atomic64* ptr, Atomic64 value) { *ptr = value; MemoryBarrier(); } inline void Release_Store(volatile Atomic64* ptr, Atomic64 value) { ATOMICOPS_COMPILER_BARRIER(); *ptr = value; // An x86 store acts as a release barrier // for current AMD/Intel chips as of Jan 2008. // See also Acquire_Load(), below. // When new chips come out, check: // IA-32 Intel Architecture Software Developer's Manual, Volume 3: // System Programming Guide, Chatper 7: Multiple-processor management, // Section 7.2, Memory Ordering. // Last seen at: // http://developer.intel.com/design/pentium4/manuals/index_new.htm // // x86 stores/loads fail to act as barriers for a few instructions (clflush // maskmovdqu maskmovq movntdq movnti movntpd movntps movntq) but these are // not generated by the compiler, and are rare. Users of these instructions // need to know about cache behaviour in any case since all of these involve // either flushing cache lines or non-temporal cache hints. } inline Atomic64 NoBarrier_Load(volatile const Atomic64* ptr) { return *ptr; } inline Atomic64 Acquire_Load(volatile const Atomic64* ptr) { Atomic64 value = *ptr; // An x86 load acts as a acquire barrier, // for current AMD/Intel chips as of Jan 2008. // See also Release_Store(), above. ATOMICOPS_COMPILER_BARRIER(); return value; } inline Atomic64 Release_Load(volatile const Atomic64* ptr) { MemoryBarrier(); return *ptr; } inline Atomic64 Acquire_CompareAndSwap(volatile Atomic64* ptr, Atomic64 old_value, Atomic64 new_value) { Atomic64 x = NoBarrier_CompareAndSwap(ptr, old_value, new_value); if (AtomicOps_Internalx86CPUFeatures.has_amd_lock_mb_bug) { __asm__ __volatile__("lfence" : : : "memory"); } return x; } inline Atomic64 Release_CompareAndSwap(volatile Atomic64* ptr, Atomic64 old_value, Atomic64 new_value) { return NoBarrier_CompareAndSwap(ptr, old_value, new_value); } #endif // defined(__x86_64__) } // namespace base::subtle } // namespace base #undef ATOMICOPS_COMPILER_BARRIER #endif // CEF_INCLUDE_BASE_INTERNAL_CEF_ATOMICOPS_X86_GCC_H_ cefpython-49.0/src/include/base/internal/cef_atomicops_x86_msvc.h000066400000000000000000000173601334103266300251360ustar00rootroot00000000000000// Copyright (c) 2008 Google Inc. 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. // Do not include this header file directly. Use base/cef_atomicops.h // instead. #ifndef CEF_INCLUDE_BASE_INTERNAL_CEF_ATOMICOPS_X86_MSVC_H_ #define CEF_INCLUDE_BASE_INTERNAL_CEF_ATOMICOPS_X86_MSVC_H_ #include #include #include "include/base/cef_macros.h" #if defined(ARCH_CPU_64_BITS) // windows.h #defines this (only on x64). This causes problems because the // public API also uses MemoryBarrier at the public name for this fence. So, on // X64, undef it, and call its documented // (http://msdn.microsoft.com/en-us/library/windows/desktop/ms684208.aspx) // implementation directly. #undef MemoryBarrier #endif namespace base { namespace subtle { inline Atomic32 NoBarrier_CompareAndSwap(volatile Atomic32* ptr, Atomic32 old_value, Atomic32 new_value) { LONG result = _InterlockedCompareExchange( reinterpret_cast(ptr), static_cast(new_value), static_cast(old_value)); return static_cast(result); } inline Atomic32 NoBarrier_AtomicExchange(volatile Atomic32* ptr, Atomic32 new_value) { LONG result = _InterlockedExchange( reinterpret_cast(ptr), static_cast(new_value)); return static_cast(result); } inline Atomic32 Barrier_AtomicIncrement(volatile Atomic32* ptr, Atomic32 increment) { return _InterlockedExchangeAdd( reinterpret_cast(ptr), static_cast(increment)) + increment; } inline Atomic32 NoBarrier_AtomicIncrement(volatile Atomic32* ptr, Atomic32 increment) { return Barrier_AtomicIncrement(ptr, increment); } #if !(defined(_MSC_VER) && _MSC_VER >= 1400) #error "We require at least vs2005 for MemoryBarrier" #endif inline void MemoryBarrier() { #if defined(ARCH_CPU_64_BITS) // See #undef and note at the top of this file. __faststorefence(); #else // We use MemoryBarrier from WinNT.h ::MemoryBarrier(); #endif } inline Atomic32 Acquire_CompareAndSwap(volatile Atomic32* ptr, Atomic32 old_value, Atomic32 new_value) { return NoBarrier_CompareAndSwap(ptr, old_value, new_value); } inline Atomic32 Release_CompareAndSwap(volatile Atomic32* ptr, Atomic32 old_value, Atomic32 new_value) { return NoBarrier_CompareAndSwap(ptr, old_value, new_value); } inline void NoBarrier_Store(volatile Atomic32* ptr, Atomic32 value) { *ptr = value; } inline void Acquire_Store(volatile Atomic32* ptr, Atomic32 value) { NoBarrier_AtomicExchange(ptr, value); // acts as a barrier in this implementation } inline void Release_Store(volatile Atomic32* ptr, Atomic32 value) { *ptr = value; // works w/o barrier for current Intel chips as of June 2005 // See comments in Atomic64 version of Release_Store() below. } inline Atomic32 NoBarrier_Load(volatile const Atomic32* ptr) { return *ptr; } inline Atomic32 Acquire_Load(volatile const Atomic32* ptr) { Atomic32 value = *ptr; return value; } inline Atomic32 Release_Load(volatile const Atomic32* ptr) { MemoryBarrier(); return *ptr; } #if defined(_WIN64) // 64-bit low-level operations on 64-bit platform. COMPILE_ASSERT(sizeof(Atomic64) == sizeof(PVOID), atomic_word_is_atomic); inline Atomic64 NoBarrier_CompareAndSwap(volatile Atomic64* ptr, Atomic64 old_value, Atomic64 new_value) { PVOID result = InterlockedCompareExchangePointer( reinterpret_cast(ptr), reinterpret_cast(new_value), reinterpret_cast(old_value)); return reinterpret_cast(result); } inline Atomic64 NoBarrier_AtomicExchange(volatile Atomic64* ptr, Atomic64 new_value) { PVOID result = InterlockedExchangePointer( reinterpret_cast(ptr), reinterpret_cast(new_value)); return reinterpret_cast(result); } inline Atomic64 Barrier_AtomicIncrement(volatile Atomic64* ptr, Atomic64 increment) { return InterlockedExchangeAdd64( reinterpret_cast(ptr), static_cast(increment)) + increment; } inline Atomic64 NoBarrier_AtomicIncrement(volatile Atomic64* ptr, Atomic64 increment) { return Barrier_AtomicIncrement(ptr, increment); } inline void NoBarrier_Store(volatile Atomic64* ptr, Atomic64 value) { *ptr = value; } inline void Acquire_Store(volatile Atomic64* ptr, Atomic64 value) { NoBarrier_AtomicExchange(ptr, value); // acts as a barrier in this implementation } inline void Release_Store(volatile Atomic64* ptr, Atomic64 value) { *ptr = value; // works w/o barrier for current Intel chips as of June 2005 // When new chips come out, check: // IA-32 Intel Architecture Software Developer's Manual, Volume 3: // System Programming Guide, Chatper 7: Multiple-processor management, // Section 7.2, Memory Ordering. // Last seen at: // http://developer.intel.com/design/pentium4/manuals/index_new.htm } inline Atomic64 NoBarrier_Load(volatile const Atomic64* ptr) { return *ptr; } inline Atomic64 Acquire_Load(volatile const Atomic64* ptr) { Atomic64 value = *ptr; return value; } inline Atomic64 Release_Load(volatile const Atomic64* ptr) { MemoryBarrier(); return *ptr; } inline Atomic64 Acquire_CompareAndSwap(volatile Atomic64* ptr, Atomic64 old_value, Atomic64 new_value) { return NoBarrier_CompareAndSwap(ptr, old_value, new_value); } inline Atomic64 Release_CompareAndSwap(volatile Atomic64* ptr, Atomic64 old_value, Atomic64 new_value) { return NoBarrier_CompareAndSwap(ptr, old_value, new_value); } #endif // defined(_WIN64) } // namespace base::subtle } // namespace base #endif // CEF_INCLUDE_BASE_INTERNAL_CEF_ATOMICOPS_X86_MSVC_H_ cefpython-49.0/src/include/base/internal/cef_bind_internal.h000066400000000000000000003306771334103266300242240ustar00rootroot00000000000000// Copyright (c) 2011 Google Inc. 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. // Do not include this header file directly. Use base/cef_bind.h instead. #ifndef CEF_INCLUDE_BASE_INTERNAL_CEF_BIND_INTERNAL_H_ #define CEF_INCLUDE_BASE_INTERNAL_CEF_BIND_INTERNAL_H_ #include "include/base/cef_bind_helpers.h" #include "include/base/cef_build.h" #include "include/base/cef_template_util.h" #include "include/base/cef_weak_ptr.h" #include "include/base/internal/cef_callback_internal.h" #include "include/base/internal/cef_raw_scoped_refptr_mismatch_checker.h" #if defined(OS_WIN) #include "include/base/internal/cef_bind_internal_win.h" #endif namespace base { namespace cef_internal { // See base/callback.h for user documentation. // // // CONCEPTS: // Runnable -- A type (really a type class) that has a single Run() method // and a RunType typedef that corresponds to the type of Run(). // A Runnable can declare that it should treated like a method // call by including a typedef named IsMethod. The value of // this typedef is NOT inspected, only the existence. When a // Runnable declares itself a method, Bind() will enforce special // refcounting + WeakPtr handling semantics for the first // parameter which is expected to be an object. // Functor -- A copyable type representing something that should be called. // All function pointers, Callback<>, and Runnables are functors // even if the invocation syntax differs. // RunType -- A function type (as opposed to function _pointer_ type) for // a Run() function. Usually just a convenience typedef. // (Bound)ArgsType -- A function type that is being (ab)used to store the // types of set of arguments. The "return" type is always // void here. We use this hack so that we do not need // a new type name for each arity of type. (eg., // BindState1, BindState2). This makes forward // declarations and friending much much easier. // // Types: // RunnableAdapter<> -- Wraps the various "function" pointer types into an // object that adheres to the Runnable interface. // There are |3*ARITY| RunnableAdapter types. // FunctionTraits<> -- Type traits that unwrap a function signature into a // a set of easier to use typedefs. Used mainly for // compile time asserts. // There are |ARITY| FunctionTraits types. // ForceVoidReturn<> -- Helper class for translating function signatures to // equivalent forms with a "void" return type. // There are |ARITY| ForceVoidReturn types. // FunctorTraits<> -- Type traits used determine the correct RunType and // RunnableType for a Functor. This is where function // signature adapters are applied. // There are |ARITY| ForceVoidReturn types. // MakeRunnable<> -- Takes a Functor and returns an object in the Runnable // type class that represents the underlying Functor. // There are |O(1)| MakeRunnable types. // InvokeHelper<> -- Take a Runnable + arguments and actully invokes it. // Handle the differing syntaxes needed for WeakPtr<> support, // and for ignoring return values. This is separate from // Invoker to avoid creating multiple version of Invoker<> // which grows at O(n^2) with the arity. // There are |k*ARITY| InvokeHelper types. // Invoker<> -- Unwraps the curried parameters and executes the Runnable. // There are |(ARITY^2 + ARITY)/2| Invoketypes. // BindState<> -- Stores the curried parameters, and is the main entry point // into the Bind() system, doing most of the type resolution. // There are ARITY BindState types. // RunnableAdapter<> // // The RunnableAdapter<> templates provide a uniform interface for invoking // a function pointer, method pointer, or const method pointer. The adapter // exposes a Run() method with an appropriate signature. Using this wrapper // allows for writing code that supports all three pointer types without // undue repetition. Without it, a lot of code would need to be repeated 3 // times. // // For method pointers and const method pointers the first argument to Run() // is considered to be the received of the method. This is similar to STL's // mem_fun(). // // This class also exposes a RunType typedef that is the function type of the // Run() function. // // If and only if the wrapper contains a method or const method pointer, an // IsMethod typedef is exposed. The existence of this typedef (NOT the value) // marks that the wrapper should be considered a method wrapper. template class RunnableAdapter; // Function: Arity 0. template class RunnableAdapter { public: typedef R (RunType)(); explicit RunnableAdapter(R(*function)()) : function_(function) { } R Run() { return function_(); } private: R (*function_)(); }; // Method: Arity 0. template class RunnableAdapter { public: typedef R (RunType)(T*); typedef true_type IsMethod; explicit RunnableAdapter(R(T::*method)()) : method_(method) { } R Run(T* object) { return (object->*method_)(); } private: R (T::*method_)(); }; // Const Method: Arity 0. template class RunnableAdapter { public: typedef R (RunType)(const T*); typedef true_type IsMethod; explicit RunnableAdapter(R(T::*method)() const) : method_(method) { } R Run(const T* object) { return (object->*method_)(); } private: R (T::*method_)() const; }; // Function: Arity 1. template class RunnableAdapter { public: typedef R (RunType)(A1); explicit RunnableAdapter(R(*function)(A1)) : function_(function) { } R Run(typename CallbackParamTraits::ForwardType a1) { return function_(CallbackForward(a1)); } private: R (*function_)(A1); }; // Method: Arity 1. template class RunnableAdapter { public: typedef R (RunType)(T*, A1); typedef true_type IsMethod; explicit RunnableAdapter(R(T::*method)(A1)) : method_(method) { } R Run(T* object, typename CallbackParamTraits::ForwardType a1) { return (object->*method_)(CallbackForward(a1)); } private: R (T::*method_)(A1); }; // Const Method: Arity 1. template class RunnableAdapter { public: typedef R (RunType)(const T*, A1); typedef true_type IsMethod; explicit RunnableAdapter(R(T::*method)(A1) const) : method_(method) { } R Run(const T* object, typename CallbackParamTraits::ForwardType a1) { return (object->*method_)(CallbackForward(a1)); } private: R (T::*method_)(A1) const; }; // Function: Arity 2. template class RunnableAdapter { public: typedef R (RunType)(A1, A2); explicit RunnableAdapter(R(*function)(A1, A2)) : function_(function) { } R Run(typename CallbackParamTraits::ForwardType a1, typename CallbackParamTraits::ForwardType a2) { return function_(CallbackForward(a1), CallbackForward(a2)); } private: R (*function_)(A1, A2); }; // Method: Arity 2. template class RunnableAdapter { public: typedef R (RunType)(T*, A1, A2); typedef true_type IsMethod; explicit RunnableAdapter(R(T::*method)(A1, A2)) : method_(method) { } R Run(T* object, typename CallbackParamTraits::ForwardType a1, typename CallbackParamTraits::ForwardType a2) { return (object->*method_)(CallbackForward(a1), CallbackForward(a2)); } private: R (T::*method_)(A1, A2); }; // Const Method: Arity 2. template class RunnableAdapter { public: typedef R (RunType)(const T*, A1, A2); typedef true_type IsMethod; explicit RunnableAdapter(R(T::*method)(A1, A2) const) : method_(method) { } R Run(const T* object, typename CallbackParamTraits::ForwardType a1, typename CallbackParamTraits::ForwardType a2) { return (object->*method_)(CallbackForward(a1), CallbackForward(a2)); } private: R (T::*method_)(A1, A2) const; }; // Function: Arity 3. template class RunnableAdapter { public: typedef R (RunType)(A1, A2, A3); explicit RunnableAdapter(R(*function)(A1, A2, A3)) : function_(function) { } R Run(typename CallbackParamTraits::ForwardType a1, typename CallbackParamTraits::ForwardType a2, typename CallbackParamTraits::ForwardType a3) { return function_(CallbackForward(a1), CallbackForward(a2), CallbackForward(a3)); } private: R (*function_)(A1, A2, A3); }; // Method: Arity 3. template class RunnableAdapter { public: typedef R (RunType)(T*, A1, A2, A3); typedef true_type IsMethod; explicit RunnableAdapter(R(T::*method)(A1, A2, A3)) : method_(method) { } R Run(T* object, typename CallbackParamTraits::ForwardType a1, typename CallbackParamTraits::ForwardType a2, typename CallbackParamTraits::ForwardType a3) { return (object->*method_)(CallbackForward(a1), CallbackForward(a2), CallbackForward(a3)); } private: R (T::*method_)(A1, A2, A3); }; // Const Method: Arity 3. template class RunnableAdapter { public: typedef R (RunType)(const T*, A1, A2, A3); typedef true_type IsMethod; explicit RunnableAdapter(R(T::*method)(A1, A2, A3) const) : method_(method) { } R Run(const T* object, typename CallbackParamTraits::ForwardType a1, typename CallbackParamTraits::ForwardType a2, typename CallbackParamTraits::ForwardType a3) { return (object->*method_)(CallbackForward(a1), CallbackForward(a2), CallbackForward(a3)); } private: R (T::*method_)(A1, A2, A3) const; }; // Function: Arity 4. template class RunnableAdapter { public: typedef R (RunType)(A1, A2, A3, A4); explicit RunnableAdapter(R(*function)(A1, A2, A3, A4)) : function_(function) { } R Run(typename CallbackParamTraits::ForwardType a1, typename CallbackParamTraits::ForwardType a2, typename CallbackParamTraits::ForwardType a3, typename CallbackParamTraits::ForwardType a4) { return function_(CallbackForward(a1), CallbackForward(a2), CallbackForward(a3), CallbackForward(a4)); } private: R (*function_)(A1, A2, A3, A4); }; // Method: Arity 4. template class RunnableAdapter { public: typedef R (RunType)(T*, A1, A2, A3, A4); typedef true_type IsMethod; explicit RunnableAdapter(R(T::*method)(A1, A2, A3, A4)) : method_(method) { } R Run(T* object, typename CallbackParamTraits::ForwardType a1, typename CallbackParamTraits::ForwardType a2, typename CallbackParamTraits::ForwardType a3, typename CallbackParamTraits::ForwardType a4) { return (object->*method_)(CallbackForward(a1), CallbackForward(a2), CallbackForward(a3), CallbackForward(a4)); } private: R (T::*method_)(A1, A2, A3, A4); }; // Const Method: Arity 4. template class RunnableAdapter { public: typedef R (RunType)(const T*, A1, A2, A3, A4); typedef true_type IsMethod; explicit RunnableAdapter(R(T::*method)(A1, A2, A3, A4) const) : method_(method) { } R Run(const T* object, typename CallbackParamTraits::ForwardType a1, typename CallbackParamTraits::ForwardType a2, typename CallbackParamTraits::ForwardType a3, typename CallbackParamTraits::ForwardType a4) { return (object->*method_)(CallbackForward(a1), CallbackForward(a2), CallbackForward(a3), CallbackForward(a4)); } private: R (T::*method_)(A1, A2, A3, A4) const; }; // Function: Arity 5. template class RunnableAdapter { public: typedef R (RunType)(A1, A2, A3, A4, A5); explicit RunnableAdapter(R(*function)(A1, A2, A3, A4, A5)) : function_(function) { } R Run(typename CallbackParamTraits::ForwardType a1, typename CallbackParamTraits::ForwardType a2, typename CallbackParamTraits::ForwardType a3, typename CallbackParamTraits::ForwardType a4, typename CallbackParamTraits::ForwardType a5) { return function_(CallbackForward(a1), CallbackForward(a2), CallbackForward(a3), CallbackForward(a4), CallbackForward(a5)); } private: R (*function_)(A1, A2, A3, A4, A5); }; // Method: Arity 5. template class RunnableAdapter { public: typedef R (RunType)(T*, A1, A2, A3, A4, A5); typedef true_type IsMethod; explicit RunnableAdapter(R(T::*method)(A1, A2, A3, A4, A5)) : method_(method) { } R Run(T* object, typename CallbackParamTraits::ForwardType a1, typename CallbackParamTraits::ForwardType a2, typename CallbackParamTraits::ForwardType a3, typename CallbackParamTraits::ForwardType a4, typename CallbackParamTraits::ForwardType a5) { return (object->*method_)(CallbackForward(a1), CallbackForward(a2), CallbackForward(a3), CallbackForward(a4), CallbackForward(a5)); } private: R (T::*method_)(A1, A2, A3, A4, A5); }; // Const Method: Arity 5. template class RunnableAdapter { public: typedef R (RunType)(const T*, A1, A2, A3, A4, A5); typedef true_type IsMethod; explicit RunnableAdapter(R(T::*method)(A1, A2, A3, A4, A5) const) : method_(method) { } R Run(const T* object, typename CallbackParamTraits::ForwardType a1, typename CallbackParamTraits::ForwardType a2, typename CallbackParamTraits::ForwardType a3, typename CallbackParamTraits::ForwardType a4, typename CallbackParamTraits::ForwardType a5) { return (object->*method_)(CallbackForward(a1), CallbackForward(a2), CallbackForward(a3), CallbackForward(a4), CallbackForward(a5)); } private: R (T::*method_)(A1, A2, A3, A4, A5) const; }; // Function: Arity 6. template class RunnableAdapter { public: typedef R (RunType)(A1, A2, A3, A4, A5, A6); explicit RunnableAdapter(R(*function)(A1, A2, A3, A4, A5, A6)) : function_(function) { } R Run(typename CallbackParamTraits::ForwardType a1, typename CallbackParamTraits::ForwardType a2, typename CallbackParamTraits::ForwardType a3, typename CallbackParamTraits::ForwardType a4, typename CallbackParamTraits::ForwardType a5, typename CallbackParamTraits::ForwardType a6) { return function_(CallbackForward(a1), CallbackForward(a2), CallbackForward(a3), CallbackForward(a4), CallbackForward(a5), CallbackForward(a6)); } private: R (*function_)(A1, A2, A3, A4, A5, A6); }; // Method: Arity 6. template class RunnableAdapter { public: typedef R (RunType)(T*, A1, A2, A3, A4, A5, A6); typedef true_type IsMethod; explicit RunnableAdapter(R(T::*method)(A1, A2, A3, A4, A5, A6)) : method_(method) { } R Run(T* object, typename CallbackParamTraits::ForwardType a1, typename CallbackParamTraits::ForwardType a2, typename CallbackParamTraits::ForwardType a3, typename CallbackParamTraits::ForwardType a4, typename CallbackParamTraits::ForwardType a5, typename CallbackParamTraits::ForwardType a6) { return (object->*method_)(CallbackForward(a1), CallbackForward(a2), CallbackForward(a3), CallbackForward(a4), CallbackForward(a5), CallbackForward(a6)); } private: R (T::*method_)(A1, A2, A3, A4, A5, A6); }; // Const Method: Arity 6. template class RunnableAdapter { public: typedef R (RunType)(const T*, A1, A2, A3, A4, A5, A6); typedef true_type IsMethod; explicit RunnableAdapter(R(T::*method)(A1, A2, A3, A4, A5, A6) const) : method_(method) { } R Run(const T* object, typename CallbackParamTraits::ForwardType a1, typename CallbackParamTraits::ForwardType a2, typename CallbackParamTraits::ForwardType a3, typename CallbackParamTraits::ForwardType a4, typename CallbackParamTraits::ForwardType a5, typename CallbackParamTraits::ForwardType a6) { return (object->*method_)(CallbackForward(a1), CallbackForward(a2), CallbackForward(a3), CallbackForward(a4), CallbackForward(a5), CallbackForward(a6)); } private: R (T::*method_)(A1, A2, A3, A4, A5, A6) const; }; // Function: Arity 7. template class RunnableAdapter { public: typedef R (RunType)(A1, A2, A3, A4, A5, A6, A7); explicit RunnableAdapter(R(*function)(A1, A2, A3, A4, A5, A6, A7)) : function_(function) { } R Run(typename CallbackParamTraits::ForwardType a1, typename CallbackParamTraits::ForwardType a2, typename CallbackParamTraits::ForwardType a3, typename CallbackParamTraits::ForwardType a4, typename CallbackParamTraits::ForwardType a5, typename CallbackParamTraits::ForwardType a6, typename CallbackParamTraits::ForwardType a7) { return function_(CallbackForward(a1), CallbackForward(a2), CallbackForward(a3), CallbackForward(a4), CallbackForward(a5), CallbackForward(a6), CallbackForward(a7)); } private: R (*function_)(A1, A2, A3, A4, A5, A6, A7); }; // Method: Arity 7. template class RunnableAdapter { public: typedef R (RunType)(T*, A1, A2, A3, A4, A5, A6, A7); typedef true_type IsMethod; explicit RunnableAdapter(R(T::*method)(A1, A2, A3, A4, A5, A6, A7)) : method_(method) { } R Run(T* object, typename CallbackParamTraits::ForwardType a1, typename CallbackParamTraits::ForwardType a2, typename CallbackParamTraits::ForwardType a3, typename CallbackParamTraits::ForwardType a4, typename CallbackParamTraits::ForwardType a5, typename CallbackParamTraits::ForwardType a6, typename CallbackParamTraits::ForwardType a7) { return (object->*method_)(CallbackForward(a1), CallbackForward(a2), CallbackForward(a3), CallbackForward(a4), CallbackForward(a5), CallbackForward(a6), CallbackForward(a7)); } private: R (T::*method_)(A1, A2, A3, A4, A5, A6, A7); }; // Const Method: Arity 7. template class RunnableAdapter { public: typedef R (RunType)(const T*, A1, A2, A3, A4, A5, A6, A7); typedef true_type IsMethod; explicit RunnableAdapter(R(T::*method)(A1, A2, A3, A4, A5, A6, A7) const) : method_(method) { } R Run(const T* object, typename CallbackParamTraits::ForwardType a1, typename CallbackParamTraits::ForwardType a2, typename CallbackParamTraits::ForwardType a3, typename CallbackParamTraits::ForwardType a4, typename CallbackParamTraits::ForwardType a5, typename CallbackParamTraits::ForwardType a6, typename CallbackParamTraits::ForwardType a7) { return (object->*method_)(CallbackForward(a1), CallbackForward(a2), CallbackForward(a3), CallbackForward(a4), CallbackForward(a5), CallbackForward(a6), CallbackForward(a7)); } private: R (T::*method_)(A1, A2, A3, A4, A5, A6, A7) const; }; // FunctionTraits<> // // Breaks a function signature apart into typedefs for easier introspection. template struct FunctionTraits; template struct FunctionTraits { typedef R ReturnType; }; template struct FunctionTraits { typedef R ReturnType; typedef A1 A1Type; }; template struct FunctionTraits { typedef R ReturnType; typedef A1 A1Type; typedef A2 A2Type; }; template struct FunctionTraits { typedef R ReturnType; typedef A1 A1Type; typedef A2 A2Type; typedef A3 A3Type; }; template struct FunctionTraits { typedef R ReturnType; typedef A1 A1Type; typedef A2 A2Type; typedef A3 A3Type; typedef A4 A4Type; }; template struct FunctionTraits { typedef R ReturnType; typedef A1 A1Type; typedef A2 A2Type; typedef A3 A3Type; typedef A4 A4Type; typedef A5 A5Type; }; template struct FunctionTraits { typedef R ReturnType; typedef A1 A1Type; typedef A2 A2Type; typedef A3 A3Type; typedef A4 A4Type; typedef A5 A5Type; typedef A6 A6Type; }; template struct FunctionTraits { typedef R ReturnType; typedef A1 A1Type; typedef A2 A2Type; typedef A3 A3Type; typedef A4 A4Type; typedef A5 A5Type; typedef A6 A6Type; typedef A7 A7Type; }; // ForceVoidReturn<> // // Set of templates that support forcing the function return type to void. template struct ForceVoidReturn; template struct ForceVoidReturn { typedef void(RunType)(); }; template struct ForceVoidReturn { typedef void(RunType)(A1); }; template struct ForceVoidReturn { typedef void(RunType)(A1, A2); }; template struct ForceVoidReturn { typedef void(RunType)(A1, A2, A3); }; template struct ForceVoidReturn { typedef void(RunType)(A1, A2, A3, A4); }; template struct ForceVoidReturn { typedef void(RunType)(A1, A2, A3, A4, A5); }; template struct ForceVoidReturn { typedef void(RunType)(A1, A2, A3, A4, A5, A6); }; template struct ForceVoidReturn { typedef void(RunType)(A1, A2, A3, A4, A5, A6, A7); }; // FunctorTraits<> // // See description at top of file. template struct FunctorTraits { typedef RunnableAdapter RunnableType; typedef typename RunnableType::RunType RunType; }; template struct FunctorTraits > { typedef typename FunctorTraits::RunnableType RunnableType; typedef typename ForceVoidReturn< typename RunnableType::RunType>::RunType RunType; }; template struct FunctorTraits > { typedef Callback RunnableType; typedef typename Callback::RunType RunType; }; // MakeRunnable<> // // Converts a passed in functor to a RunnableType using type inference. template typename FunctorTraits::RunnableType MakeRunnable(const T& t) { return RunnableAdapter(t); } template typename FunctorTraits::RunnableType MakeRunnable(const IgnoreResultHelper& t) { return MakeRunnable(t.functor_); } template const typename FunctorTraits >::RunnableType& MakeRunnable(const Callback& t) { DCHECK(!t.is_null()); return t; } // InvokeHelper<> // // There are 3 logical InvokeHelper<> specializations: normal, void-return, // WeakCalls. // // The normal type just calls the underlying runnable. // // We need a InvokeHelper to handle void return types in order to support // IgnoreResult(). Normally, if the Runnable's RunType had a void return, // the template system would just accept "return functor.Run()" ignoring // the fact that a void function is being used with return. This piece of // sugar breaks though when the Runnable's RunType is not void. Thus, we // need a partial specialization to change the syntax to drop the "return" // from the invocation call. // // WeakCalls similarly need special syntax that is applied to the first // argument to check if they should no-op themselves. template struct InvokeHelper; template struct InvokeHelper { static ReturnType MakeItSo(Runnable runnable) { return runnable.Run(); } }; template struct InvokeHelper { static void MakeItSo(Runnable runnable) { runnable.Run(); } }; template struct InvokeHelper { static ReturnType MakeItSo(Runnable runnable, A1 a1) { return runnable.Run(CallbackForward(a1)); } }; template struct InvokeHelper { static void MakeItSo(Runnable runnable, A1 a1) { runnable.Run(CallbackForward(a1)); } }; template struct InvokeHelper { static void MakeItSo(Runnable runnable, BoundWeakPtr weak_ptr) { if (!weak_ptr.get()) { return; } runnable.Run(weak_ptr.get()); } }; template struct InvokeHelper { static ReturnType MakeItSo(Runnable runnable, A1 a1, A2 a2) { return runnable.Run(CallbackForward(a1), CallbackForward(a2)); } }; template struct InvokeHelper { static void MakeItSo(Runnable runnable, A1 a1, A2 a2) { runnable.Run(CallbackForward(a1), CallbackForward(a2)); } }; template struct InvokeHelper { static void MakeItSo(Runnable runnable, BoundWeakPtr weak_ptr, A2 a2) { if (!weak_ptr.get()) { return; } runnable.Run(weak_ptr.get(), CallbackForward(a2)); } }; template struct InvokeHelper { static ReturnType MakeItSo(Runnable runnable, A1 a1, A2 a2, A3 a3) { return runnable.Run(CallbackForward(a1), CallbackForward(a2), CallbackForward(a3)); } }; template struct InvokeHelper { static void MakeItSo(Runnable runnable, A1 a1, A2 a2, A3 a3) { runnable.Run(CallbackForward(a1), CallbackForward(a2), CallbackForward(a3)); } }; template struct InvokeHelper { static void MakeItSo(Runnable runnable, BoundWeakPtr weak_ptr, A2 a2, A3 a3) { if (!weak_ptr.get()) { return; } runnable.Run(weak_ptr.get(), CallbackForward(a2), CallbackForward(a3)); } }; template struct InvokeHelper { static ReturnType MakeItSo(Runnable runnable, A1 a1, A2 a2, A3 a3, A4 a4) { return runnable.Run(CallbackForward(a1), CallbackForward(a2), CallbackForward(a3), CallbackForward(a4)); } }; template struct InvokeHelper { static void MakeItSo(Runnable runnable, A1 a1, A2 a2, A3 a3, A4 a4) { runnable.Run(CallbackForward(a1), CallbackForward(a2), CallbackForward(a3), CallbackForward(a4)); } }; template struct InvokeHelper { static void MakeItSo(Runnable runnable, BoundWeakPtr weak_ptr, A2 a2, A3 a3, A4 a4) { if (!weak_ptr.get()) { return; } runnable.Run(weak_ptr.get(), CallbackForward(a2), CallbackForward(a3), CallbackForward(a4)); } }; template struct InvokeHelper { static ReturnType MakeItSo(Runnable runnable, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) { return runnable.Run(CallbackForward(a1), CallbackForward(a2), CallbackForward(a3), CallbackForward(a4), CallbackForward(a5)); } }; template struct InvokeHelper { static void MakeItSo(Runnable runnable, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) { runnable.Run(CallbackForward(a1), CallbackForward(a2), CallbackForward(a3), CallbackForward(a4), CallbackForward(a5)); } }; template struct InvokeHelper { static void MakeItSo(Runnable runnable, BoundWeakPtr weak_ptr, A2 a2, A3 a3, A4 a4, A5 a5) { if (!weak_ptr.get()) { return; } runnable.Run(weak_ptr.get(), CallbackForward(a2), CallbackForward(a3), CallbackForward(a4), CallbackForward(a5)); } }; template struct InvokeHelper { static ReturnType MakeItSo(Runnable runnable, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) { return runnable.Run(CallbackForward(a1), CallbackForward(a2), CallbackForward(a3), CallbackForward(a4), CallbackForward(a5), CallbackForward(a6)); } }; template struct InvokeHelper { static void MakeItSo(Runnable runnable, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) { runnable.Run(CallbackForward(a1), CallbackForward(a2), CallbackForward(a3), CallbackForward(a4), CallbackForward(a5), CallbackForward(a6)); } }; template struct InvokeHelper { static void MakeItSo(Runnable runnable, BoundWeakPtr weak_ptr, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) { if (!weak_ptr.get()) { return; } runnable.Run(weak_ptr.get(), CallbackForward(a2), CallbackForward(a3), CallbackForward(a4), CallbackForward(a5), CallbackForward(a6)); } }; template struct InvokeHelper { static ReturnType MakeItSo(Runnable runnable, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) { return runnable.Run(CallbackForward(a1), CallbackForward(a2), CallbackForward(a3), CallbackForward(a4), CallbackForward(a5), CallbackForward(a6), CallbackForward(a7)); } }; template struct InvokeHelper { static void MakeItSo(Runnable runnable, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) { runnable.Run(CallbackForward(a1), CallbackForward(a2), CallbackForward(a3), CallbackForward(a4), CallbackForward(a5), CallbackForward(a6), CallbackForward(a7)); } }; template struct InvokeHelper { static void MakeItSo(Runnable runnable, BoundWeakPtr weak_ptr, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) { if (!weak_ptr.get()) { return; } runnable.Run(weak_ptr.get(), CallbackForward(a2), CallbackForward(a3), CallbackForward(a4), CallbackForward(a5), CallbackForward(a6), CallbackForward(a7)); } }; #if !defined(_MSC_VER) template struct InvokeHelper { // WeakCalls are only supported for functions with a void return type. // Otherwise, the function result would be undefined if the the WeakPtr<> // is invalidated. COMPILE_ASSERT(is_void::value, weak_ptrs_can_only_bind_to_methods_without_return_values); }; #endif // Invoker<> // // See description at the top of the file. template struct Invoker; // Arity 0 -> 0. template struct Invoker<0, StorageType, R()> { typedef R(RunType)(BindStateBase*); typedef R(UnboundRunType)(); static R Run(BindStateBase* base) { StorageType* storage = static_cast(base); // Local references to make debugger stepping easier. If in a debugger, // you really want to warp ahead and step through the // InvokeHelper<>::MakeItSo() call below. return InvokeHelper ::MakeItSo(storage->runnable_); } }; // Arity 1 -> 1. template struct Invoker<0, StorageType, R(X1)> { typedef R(RunType)(BindStateBase*, typename CallbackParamTraits::ForwardType); typedef R(UnboundRunType)(X1); static R Run(BindStateBase* base, typename CallbackParamTraits::ForwardType x1) { StorageType* storage = static_cast(base); // Local references to make debugger stepping easier. If in a debugger, // you really want to warp ahead and step through the // InvokeHelper<>::MakeItSo() call below. return InvokeHelper::ForwardType x1)> ::MakeItSo(storage->runnable_, CallbackForward(x1)); } }; // Arity 1 -> 0. template struct Invoker<1, StorageType, R(X1)> { typedef R(RunType)(BindStateBase*); typedef R(UnboundRunType)(); static R Run(BindStateBase* base) { StorageType* storage = static_cast(base); // Local references to make debugger stepping easier. If in a debugger, // you really want to warp ahead and step through the // InvokeHelper<>::MakeItSo() call below. typedef typename StorageType::Bound1UnwrapTraits Bound1UnwrapTraits; typename Bound1UnwrapTraits::ForwardType x1 = Bound1UnwrapTraits::Unwrap(storage->p1_); return InvokeHelper ::MakeItSo(storage->runnable_, CallbackForward(x1)); } }; // Arity 2 -> 2. template struct Invoker<0, StorageType, R(X1, X2)> { typedef R(RunType)(BindStateBase*, typename CallbackParamTraits::ForwardType, typename CallbackParamTraits::ForwardType); typedef R(UnboundRunType)(X1, X2); static R Run(BindStateBase* base, typename CallbackParamTraits::ForwardType x1, typename CallbackParamTraits::ForwardType x2) { StorageType* storage = static_cast(base); // Local references to make debugger stepping easier. If in a debugger, // you really want to warp ahead and step through the // InvokeHelper<>::MakeItSo() call below. return InvokeHelper::ForwardType x1, typename CallbackParamTraits::ForwardType x2)> ::MakeItSo(storage->runnable_, CallbackForward(x1), CallbackForward(x2)); } }; // Arity 2 -> 1. template struct Invoker<1, StorageType, R(X1, X2)> { typedef R(RunType)(BindStateBase*, typename CallbackParamTraits::ForwardType); typedef R(UnboundRunType)(X2); static R Run(BindStateBase* base, typename CallbackParamTraits::ForwardType x2) { StorageType* storage = static_cast(base); // Local references to make debugger stepping easier. If in a debugger, // you really want to warp ahead and step through the // InvokeHelper<>::MakeItSo() call below. typedef typename StorageType::Bound1UnwrapTraits Bound1UnwrapTraits; typename Bound1UnwrapTraits::ForwardType x1 = Bound1UnwrapTraits::Unwrap(storage->p1_); return InvokeHelper::ForwardType x2)> ::MakeItSo(storage->runnable_, CallbackForward(x1), CallbackForward(x2)); } }; // Arity 2 -> 0. template struct Invoker<2, StorageType, R(X1, X2)> { typedef R(RunType)(BindStateBase*); typedef R(UnboundRunType)(); static R Run(BindStateBase* base) { StorageType* storage = static_cast(base); // Local references to make debugger stepping easier. If in a debugger, // you really want to warp ahead and step through the // InvokeHelper<>::MakeItSo() call below. typedef typename StorageType::Bound1UnwrapTraits Bound1UnwrapTraits; typedef typename StorageType::Bound2UnwrapTraits Bound2UnwrapTraits; typename Bound1UnwrapTraits::ForwardType x1 = Bound1UnwrapTraits::Unwrap(storage->p1_); typename Bound2UnwrapTraits::ForwardType x2 = Bound2UnwrapTraits::Unwrap(storage->p2_); return InvokeHelper ::MakeItSo(storage->runnable_, CallbackForward(x1), CallbackForward(x2)); } }; // Arity 3 -> 3. template struct Invoker<0, StorageType, R(X1, X2, X3)> { typedef R(RunType)(BindStateBase*, typename CallbackParamTraits::ForwardType, typename CallbackParamTraits::ForwardType, typename CallbackParamTraits::ForwardType); typedef R(UnboundRunType)(X1, X2, X3); static R Run(BindStateBase* base, typename CallbackParamTraits::ForwardType x1, typename CallbackParamTraits::ForwardType x2, typename CallbackParamTraits::ForwardType x3) { StorageType* storage = static_cast(base); // Local references to make debugger stepping easier. If in a debugger, // you really want to warp ahead and step through the // InvokeHelper<>::MakeItSo() call below. return InvokeHelper::ForwardType x1, typename CallbackParamTraits::ForwardType x2, typename CallbackParamTraits::ForwardType x3)> ::MakeItSo(storage->runnable_, CallbackForward(x1), CallbackForward(x2), CallbackForward(x3)); } }; // Arity 3 -> 2. template struct Invoker<1, StorageType, R(X1, X2, X3)> { typedef R(RunType)(BindStateBase*, typename CallbackParamTraits::ForwardType, typename CallbackParamTraits::ForwardType); typedef R(UnboundRunType)(X2, X3); static R Run(BindStateBase* base, typename CallbackParamTraits::ForwardType x2, typename CallbackParamTraits::ForwardType x3) { StorageType* storage = static_cast(base); // Local references to make debugger stepping easier. If in a debugger, // you really want to warp ahead and step through the // InvokeHelper<>::MakeItSo() call below. typedef typename StorageType::Bound1UnwrapTraits Bound1UnwrapTraits; typename Bound1UnwrapTraits::ForwardType x1 = Bound1UnwrapTraits::Unwrap(storage->p1_); return InvokeHelper::ForwardType x2, typename CallbackParamTraits::ForwardType x3)> ::MakeItSo(storage->runnable_, CallbackForward(x1), CallbackForward(x2), CallbackForward(x3)); } }; // Arity 3 -> 1. template struct Invoker<2, StorageType, R(X1, X2, X3)> { typedef R(RunType)(BindStateBase*, typename CallbackParamTraits::ForwardType); typedef R(UnboundRunType)(X3); static R Run(BindStateBase* base, typename CallbackParamTraits::ForwardType x3) { StorageType* storage = static_cast(base); // Local references to make debugger stepping easier. If in a debugger, // you really want to warp ahead and step through the // InvokeHelper<>::MakeItSo() call below. typedef typename StorageType::Bound1UnwrapTraits Bound1UnwrapTraits; typedef typename StorageType::Bound2UnwrapTraits Bound2UnwrapTraits; typename Bound1UnwrapTraits::ForwardType x1 = Bound1UnwrapTraits::Unwrap(storage->p1_); typename Bound2UnwrapTraits::ForwardType x2 = Bound2UnwrapTraits::Unwrap(storage->p2_); return InvokeHelper::ForwardType x3)> ::MakeItSo(storage->runnable_, CallbackForward(x1), CallbackForward(x2), CallbackForward(x3)); } }; // Arity 3 -> 0. template struct Invoker<3, StorageType, R(X1, X2, X3)> { typedef R(RunType)(BindStateBase*); typedef R(UnboundRunType)(); static R Run(BindStateBase* base) { StorageType* storage = static_cast(base); // Local references to make debugger stepping easier. If in a debugger, // you really want to warp ahead and step through the // InvokeHelper<>::MakeItSo() call below. typedef typename StorageType::Bound1UnwrapTraits Bound1UnwrapTraits; typedef typename StorageType::Bound2UnwrapTraits Bound2UnwrapTraits; typedef typename StorageType::Bound3UnwrapTraits Bound3UnwrapTraits; typename Bound1UnwrapTraits::ForwardType x1 = Bound1UnwrapTraits::Unwrap(storage->p1_); typename Bound2UnwrapTraits::ForwardType x2 = Bound2UnwrapTraits::Unwrap(storage->p2_); typename Bound3UnwrapTraits::ForwardType x3 = Bound3UnwrapTraits::Unwrap(storage->p3_); return InvokeHelper ::MakeItSo(storage->runnable_, CallbackForward(x1), CallbackForward(x2), CallbackForward(x3)); } }; // Arity 4 -> 4. template struct Invoker<0, StorageType, R(X1, X2, X3, X4)> { typedef R(RunType)(BindStateBase*, typename CallbackParamTraits::ForwardType, typename CallbackParamTraits::ForwardType, typename CallbackParamTraits::ForwardType, typename CallbackParamTraits::ForwardType); typedef R(UnboundRunType)(X1, X2, X3, X4); static R Run(BindStateBase* base, typename CallbackParamTraits::ForwardType x1, typename CallbackParamTraits::ForwardType x2, typename CallbackParamTraits::ForwardType x3, typename CallbackParamTraits::ForwardType x4) { StorageType* storage = static_cast(base); // Local references to make debugger stepping easier. If in a debugger, // you really want to warp ahead and step through the // InvokeHelper<>::MakeItSo() call below. return InvokeHelper::ForwardType x1, typename CallbackParamTraits::ForwardType x2, typename CallbackParamTraits::ForwardType x3, typename CallbackParamTraits::ForwardType x4)> ::MakeItSo(storage->runnable_, CallbackForward(x1), CallbackForward(x2), CallbackForward(x3), CallbackForward(x4)); } }; // Arity 4 -> 3. template struct Invoker<1, StorageType, R(X1, X2, X3, X4)> { typedef R(RunType)(BindStateBase*, typename CallbackParamTraits::ForwardType, typename CallbackParamTraits::ForwardType, typename CallbackParamTraits::ForwardType); typedef R(UnboundRunType)(X2, X3, X4); static R Run(BindStateBase* base, typename CallbackParamTraits::ForwardType x2, typename CallbackParamTraits::ForwardType x3, typename CallbackParamTraits::ForwardType x4) { StorageType* storage = static_cast(base); // Local references to make debugger stepping easier. If in a debugger, // you really want to warp ahead and step through the // InvokeHelper<>::MakeItSo() call below. typedef typename StorageType::Bound1UnwrapTraits Bound1UnwrapTraits; typename Bound1UnwrapTraits::ForwardType x1 = Bound1UnwrapTraits::Unwrap(storage->p1_); return InvokeHelper::ForwardType x2, typename CallbackParamTraits::ForwardType x3, typename CallbackParamTraits::ForwardType x4)> ::MakeItSo(storage->runnable_, CallbackForward(x1), CallbackForward(x2), CallbackForward(x3), CallbackForward(x4)); } }; // Arity 4 -> 2. template struct Invoker<2, StorageType, R(X1, X2, X3, X4)> { typedef R(RunType)(BindStateBase*, typename CallbackParamTraits::ForwardType, typename CallbackParamTraits::ForwardType); typedef R(UnboundRunType)(X3, X4); static R Run(BindStateBase* base, typename CallbackParamTraits::ForwardType x3, typename CallbackParamTraits::ForwardType x4) { StorageType* storage = static_cast(base); // Local references to make debugger stepping easier. If in a debugger, // you really want to warp ahead and step through the // InvokeHelper<>::MakeItSo() call below. typedef typename StorageType::Bound1UnwrapTraits Bound1UnwrapTraits; typedef typename StorageType::Bound2UnwrapTraits Bound2UnwrapTraits; typename Bound1UnwrapTraits::ForwardType x1 = Bound1UnwrapTraits::Unwrap(storage->p1_); typename Bound2UnwrapTraits::ForwardType x2 = Bound2UnwrapTraits::Unwrap(storage->p2_); return InvokeHelper::ForwardType x3, typename CallbackParamTraits::ForwardType x4)> ::MakeItSo(storage->runnable_, CallbackForward(x1), CallbackForward(x2), CallbackForward(x3), CallbackForward(x4)); } }; // Arity 4 -> 1. template struct Invoker<3, StorageType, R(X1, X2, X3, X4)> { typedef R(RunType)(BindStateBase*, typename CallbackParamTraits::ForwardType); typedef R(UnboundRunType)(X4); static R Run(BindStateBase* base, typename CallbackParamTraits::ForwardType x4) { StorageType* storage = static_cast(base); // Local references to make debugger stepping easier. If in a debugger, // you really want to warp ahead and step through the // InvokeHelper<>::MakeItSo() call below. typedef typename StorageType::Bound1UnwrapTraits Bound1UnwrapTraits; typedef typename StorageType::Bound2UnwrapTraits Bound2UnwrapTraits; typedef typename StorageType::Bound3UnwrapTraits Bound3UnwrapTraits; typename Bound1UnwrapTraits::ForwardType x1 = Bound1UnwrapTraits::Unwrap(storage->p1_); typename Bound2UnwrapTraits::ForwardType x2 = Bound2UnwrapTraits::Unwrap(storage->p2_); typename Bound3UnwrapTraits::ForwardType x3 = Bound3UnwrapTraits::Unwrap(storage->p3_); return InvokeHelper::ForwardType x4)> ::MakeItSo(storage->runnable_, CallbackForward(x1), CallbackForward(x2), CallbackForward(x3), CallbackForward(x4)); } }; // Arity 4 -> 0. template struct Invoker<4, StorageType, R(X1, X2, X3, X4)> { typedef R(RunType)(BindStateBase*); typedef R(UnboundRunType)(); static R Run(BindStateBase* base) { StorageType* storage = static_cast(base); // Local references to make debugger stepping easier. If in a debugger, // you really want to warp ahead and step through the // InvokeHelper<>::MakeItSo() call below. typedef typename StorageType::Bound1UnwrapTraits Bound1UnwrapTraits; typedef typename StorageType::Bound2UnwrapTraits Bound2UnwrapTraits; typedef typename StorageType::Bound3UnwrapTraits Bound3UnwrapTraits; typedef typename StorageType::Bound4UnwrapTraits Bound4UnwrapTraits; typename Bound1UnwrapTraits::ForwardType x1 = Bound1UnwrapTraits::Unwrap(storage->p1_); typename Bound2UnwrapTraits::ForwardType x2 = Bound2UnwrapTraits::Unwrap(storage->p2_); typename Bound3UnwrapTraits::ForwardType x3 = Bound3UnwrapTraits::Unwrap(storage->p3_); typename Bound4UnwrapTraits::ForwardType x4 = Bound4UnwrapTraits::Unwrap(storage->p4_); return InvokeHelper ::MakeItSo(storage->runnable_, CallbackForward(x1), CallbackForward(x2), CallbackForward(x3), CallbackForward(x4)); } }; // Arity 5 -> 5. template struct Invoker<0, StorageType, R(X1, X2, X3, X4, X5)> { typedef R(RunType)(BindStateBase*, typename CallbackParamTraits::ForwardType, typename CallbackParamTraits::ForwardType, typename CallbackParamTraits::ForwardType, typename CallbackParamTraits::ForwardType, typename CallbackParamTraits::ForwardType); typedef R(UnboundRunType)(X1, X2, X3, X4, X5); static R Run(BindStateBase* base, typename CallbackParamTraits::ForwardType x1, typename CallbackParamTraits::ForwardType x2, typename CallbackParamTraits::ForwardType x3, typename CallbackParamTraits::ForwardType x4, typename CallbackParamTraits::ForwardType x5) { StorageType* storage = static_cast(base); // Local references to make debugger stepping easier. If in a debugger, // you really want to warp ahead and step through the // InvokeHelper<>::MakeItSo() call below. return InvokeHelper::ForwardType x1, typename CallbackParamTraits::ForwardType x2, typename CallbackParamTraits::ForwardType x3, typename CallbackParamTraits::ForwardType x4, typename CallbackParamTraits::ForwardType x5)> ::MakeItSo(storage->runnable_, CallbackForward(x1), CallbackForward(x2), CallbackForward(x3), CallbackForward(x4), CallbackForward(x5)); } }; // Arity 5 -> 4. template struct Invoker<1, StorageType, R(X1, X2, X3, X4, X5)> { typedef R(RunType)(BindStateBase*, typename CallbackParamTraits::ForwardType, typename CallbackParamTraits::ForwardType, typename CallbackParamTraits::ForwardType, typename CallbackParamTraits::ForwardType); typedef R(UnboundRunType)(X2, X3, X4, X5); static R Run(BindStateBase* base, typename CallbackParamTraits::ForwardType x2, typename CallbackParamTraits::ForwardType x3, typename CallbackParamTraits::ForwardType x4, typename CallbackParamTraits::ForwardType x5) { StorageType* storage = static_cast(base); // Local references to make debugger stepping easier. If in a debugger, // you really want to warp ahead and step through the // InvokeHelper<>::MakeItSo() call below. typedef typename StorageType::Bound1UnwrapTraits Bound1UnwrapTraits; typename Bound1UnwrapTraits::ForwardType x1 = Bound1UnwrapTraits::Unwrap(storage->p1_); return InvokeHelper::ForwardType x2, typename CallbackParamTraits::ForwardType x3, typename CallbackParamTraits::ForwardType x4, typename CallbackParamTraits::ForwardType x5)> ::MakeItSo(storage->runnable_, CallbackForward(x1), CallbackForward(x2), CallbackForward(x3), CallbackForward(x4), CallbackForward(x5)); } }; // Arity 5 -> 3. template struct Invoker<2, StorageType, R(X1, X2, X3, X4, X5)> { typedef R(RunType)(BindStateBase*, typename CallbackParamTraits::ForwardType, typename CallbackParamTraits::ForwardType, typename CallbackParamTraits::ForwardType); typedef R(UnboundRunType)(X3, X4, X5); static R Run(BindStateBase* base, typename CallbackParamTraits::ForwardType x3, typename CallbackParamTraits::ForwardType x4, typename CallbackParamTraits::ForwardType x5) { StorageType* storage = static_cast(base); // Local references to make debugger stepping easier. If in a debugger, // you really want to warp ahead and step through the // InvokeHelper<>::MakeItSo() call below. typedef typename StorageType::Bound1UnwrapTraits Bound1UnwrapTraits; typedef typename StorageType::Bound2UnwrapTraits Bound2UnwrapTraits; typename Bound1UnwrapTraits::ForwardType x1 = Bound1UnwrapTraits::Unwrap(storage->p1_); typename Bound2UnwrapTraits::ForwardType x2 = Bound2UnwrapTraits::Unwrap(storage->p2_); return InvokeHelper::ForwardType x3, typename CallbackParamTraits::ForwardType x4, typename CallbackParamTraits::ForwardType x5)> ::MakeItSo(storage->runnable_, CallbackForward(x1), CallbackForward(x2), CallbackForward(x3), CallbackForward(x4), CallbackForward(x5)); } }; // Arity 5 -> 2. template struct Invoker<3, StorageType, R(X1, X2, X3, X4, X5)> { typedef R(RunType)(BindStateBase*, typename CallbackParamTraits::ForwardType, typename CallbackParamTraits::ForwardType); typedef R(UnboundRunType)(X4, X5); static R Run(BindStateBase* base, typename CallbackParamTraits::ForwardType x4, typename CallbackParamTraits::ForwardType x5) { StorageType* storage = static_cast(base); // Local references to make debugger stepping easier. If in a debugger, // you really want to warp ahead and step through the // InvokeHelper<>::MakeItSo() call below. typedef typename StorageType::Bound1UnwrapTraits Bound1UnwrapTraits; typedef typename StorageType::Bound2UnwrapTraits Bound2UnwrapTraits; typedef typename StorageType::Bound3UnwrapTraits Bound3UnwrapTraits; typename Bound1UnwrapTraits::ForwardType x1 = Bound1UnwrapTraits::Unwrap(storage->p1_); typename Bound2UnwrapTraits::ForwardType x2 = Bound2UnwrapTraits::Unwrap(storage->p2_); typename Bound3UnwrapTraits::ForwardType x3 = Bound3UnwrapTraits::Unwrap(storage->p3_); return InvokeHelper::ForwardType x4, typename CallbackParamTraits::ForwardType x5)> ::MakeItSo(storage->runnable_, CallbackForward(x1), CallbackForward(x2), CallbackForward(x3), CallbackForward(x4), CallbackForward(x5)); } }; // Arity 5 -> 1. template struct Invoker<4, StorageType, R(X1, X2, X3, X4, X5)> { typedef R(RunType)(BindStateBase*, typename CallbackParamTraits::ForwardType); typedef R(UnboundRunType)(X5); static R Run(BindStateBase* base, typename CallbackParamTraits::ForwardType x5) { StorageType* storage = static_cast(base); // Local references to make debugger stepping easier. If in a debugger, // you really want to warp ahead and step through the // InvokeHelper<>::MakeItSo() call below. typedef typename StorageType::Bound1UnwrapTraits Bound1UnwrapTraits; typedef typename StorageType::Bound2UnwrapTraits Bound2UnwrapTraits; typedef typename StorageType::Bound3UnwrapTraits Bound3UnwrapTraits; typedef typename StorageType::Bound4UnwrapTraits Bound4UnwrapTraits; typename Bound1UnwrapTraits::ForwardType x1 = Bound1UnwrapTraits::Unwrap(storage->p1_); typename Bound2UnwrapTraits::ForwardType x2 = Bound2UnwrapTraits::Unwrap(storage->p2_); typename Bound3UnwrapTraits::ForwardType x3 = Bound3UnwrapTraits::Unwrap(storage->p3_); typename Bound4UnwrapTraits::ForwardType x4 = Bound4UnwrapTraits::Unwrap(storage->p4_); return InvokeHelper::ForwardType x5)> ::MakeItSo(storage->runnable_, CallbackForward(x1), CallbackForward(x2), CallbackForward(x3), CallbackForward(x4), CallbackForward(x5)); } }; // Arity 5 -> 0. template struct Invoker<5, StorageType, R(X1, X2, X3, X4, X5)> { typedef R(RunType)(BindStateBase*); typedef R(UnboundRunType)(); static R Run(BindStateBase* base) { StorageType* storage = static_cast(base); // Local references to make debugger stepping easier. If in a debugger, // you really want to warp ahead and step through the // InvokeHelper<>::MakeItSo() call below. typedef typename StorageType::Bound1UnwrapTraits Bound1UnwrapTraits; typedef typename StorageType::Bound2UnwrapTraits Bound2UnwrapTraits; typedef typename StorageType::Bound3UnwrapTraits Bound3UnwrapTraits; typedef typename StorageType::Bound4UnwrapTraits Bound4UnwrapTraits; typedef typename StorageType::Bound5UnwrapTraits Bound5UnwrapTraits; typename Bound1UnwrapTraits::ForwardType x1 = Bound1UnwrapTraits::Unwrap(storage->p1_); typename Bound2UnwrapTraits::ForwardType x2 = Bound2UnwrapTraits::Unwrap(storage->p2_); typename Bound3UnwrapTraits::ForwardType x3 = Bound3UnwrapTraits::Unwrap(storage->p3_); typename Bound4UnwrapTraits::ForwardType x4 = Bound4UnwrapTraits::Unwrap(storage->p4_); typename Bound5UnwrapTraits::ForwardType x5 = Bound5UnwrapTraits::Unwrap(storage->p5_); return InvokeHelper ::MakeItSo(storage->runnable_, CallbackForward(x1), CallbackForward(x2), CallbackForward(x3), CallbackForward(x4), CallbackForward(x5)); } }; // Arity 6 -> 6. template struct Invoker<0, StorageType, R(X1, X2, X3, X4, X5, X6)> { typedef R(RunType)(BindStateBase*, typename CallbackParamTraits::ForwardType, typename CallbackParamTraits::ForwardType, typename CallbackParamTraits::ForwardType, typename CallbackParamTraits::ForwardType, typename CallbackParamTraits::ForwardType, typename CallbackParamTraits::ForwardType); typedef R(UnboundRunType)(X1, X2, X3, X4, X5, X6); static R Run(BindStateBase* base, typename CallbackParamTraits::ForwardType x1, typename CallbackParamTraits::ForwardType x2, typename CallbackParamTraits::ForwardType x3, typename CallbackParamTraits::ForwardType x4, typename CallbackParamTraits::ForwardType x5, typename CallbackParamTraits::ForwardType x6) { StorageType* storage = static_cast(base); // Local references to make debugger stepping easier. If in a debugger, // you really want to warp ahead and step through the // InvokeHelper<>::MakeItSo() call below. return InvokeHelper::ForwardType x1, typename CallbackParamTraits::ForwardType x2, typename CallbackParamTraits::ForwardType x3, typename CallbackParamTraits::ForwardType x4, typename CallbackParamTraits::ForwardType x5, typename CallbackParamTraits::ForwardType x6)> ::MakeItSo(storage->runnable_, CallbackForward(x1), CallbackForward(x2), CallbackForward(x3), CallbackForward(x4), CallbackForward(x5), CallbackForward(x6)); } }; // Arity 6 -> 5. template struct Invoker<1, StorageType, R(X1, X2, X3, X4, X5, X6)> { typedef R(RunType)(BindStateBase*, typename CallbackParamTraits::ForwardType, typename CallbackParamTraits::ForwardType, typename CallbackParamTraits::ForwardType, typename CallbackParamTraits::ForwardType, typename CallbackParamTraits::ForwardType); typedef R(UnboundRunType)(X2, X3, X4, X5, X6); static R Run(BindStateBase* base, typename CallbackParamTraits::ForwardType x2, typename CallbackParamTraits::ForwardType x3, typename CallbackParamTraits::ForwardType x4, typename CallbackParamTraits::ForwardType x5, typename CallbackParamTraits::ForwardType x6) { StorageType* storage = static_cast(base); // Local references to make debugger stepping easier. If in a debugger, // you really want to warp ahead and step through the // InvokeHelper<>::MakeItSo() call below. typedef typename StorageType::Bound1UnwrapTraits Bound1UnwrapTraits; typename Bound1UnwrapTraits::ForwardType x1 = Bound1UnwrapTraits::Unwrap(storage->p1_); return InvokeHelper::ForwardType x2, typename CallbackParamTraits::ForwardType x3, typename CallbackParamTraits::ForwardType x4, typename CallbackParamTraits::ForwardType x5, typename CallbackParamTraits::ForwardType x6)> ::MakeItSo(storage->runnable_, CallbackForward(x1), CallbackForward(x2), CallbackForward(x3), CallbackForward(x4), CallbackForward(x5), CallbackForward(x6)); } }; // Arity 6 -> 4. template struct Invoker<2, StorageType, R(X1, X2, X3, X4, X5, X6)> { typedef R(RunType)(BindStateBase*, typename CallbackParamTraits::ForwardType, typename CallbackParamTraits::ForwardType, typename CallbackParamTraits::ForwardType, typename CallbackParamTraits::ForwardType); typedef R(UnboundRunType)(X3, X4, X5, X6); static R Run(BindStateBase* base, typename CallbackParamTraits::ForwardType x3, typename CallbackParamTraits::ForwardType x4, typename CallbackParamTraits::ForwardType x5, typename CallbackParamTraits::ForwardType x6) { StorageType* storage = static_cast(base); // Local references to make debugger stepping easier. If in a debugger, // you really want to warp ahead and step through the // InvokeHelper<>::MakeItSo() call below. typedef typename StorageType::Bound1UnwrapTraits Bound1UnwrapTraits; typedef typename StorageType::Bound2UnwrapTraits Bound2UnwrapTraits; typename Bound1UnwrapTraits::ForwardType x1 = Bound1UnwrapTraits::Unwrap(storage->p1_); typename Bound2UnwrapTraits::ForwardType x2 = Bound2UnwrapTraits::Unwrap(storage->p2_); return InvokeHelper::ForwardType x3, typename CallbackParamTraits::ForwardType x4, typename CallbackParamTraits::ForwardType x5, typename CallbackParamTraits::ForwardType x6)> ::MakeItSo(storage->runnable_, CallbackForward(x1), CallbackForward(x2), CallbackForward(x3), CallbackForward(x4), CallbackForward(x5), CallbackForward(x6)); } }; // Arity 6 -> 3. template struct Invoker<3, StorageType, R(X1, X2, X3, X4, X5, X6)> { typedef R(RunType)(BindStateBase*, typename CallbackParamTraits::ForwardType, typename CallbackParamTraits::ForwardType, typename CallbackParamTraits::ForwardType); typedef R(UnboundRunType)(X4, X5, X6); static R Run(BindStateBase* base, typename CallbackParamTraits::ForwardType x4, typename CallbackParamTraits::ForwardType x5, typename CallbackParamTraits::ForwardType x6) { StorageType* storage = static_cast(base); // Local references to make debugger stepping easier. If in a debugger, // you really want to warp ahead and step through the // InvokeHelper<>::MakeItSo() call below. typedef typename StorageType::Bound1UnwrapTraits Bound1UnwrapTraits; typedef typename StorageType::Bound2UnwrapTraits Bound2UnwrapTraits; typedef typename StorageType::Bound3UnwrapTraits Bound3UnwrapTraits; typename Bound1UnwrapTraits::ForwardType x1 = Bound1UnwrapTraits::Unwrap(storage->p1_); typename Bound2UnwrapTraits::ForwardType x2 = Bound2UnwrapTraits::Unwrap(storage->p2_); typename Bound3UnwrapTraits::ForwardType x3 = Bound3UnwrapTraits::Unwrap(storage->p3_); return InvokeHelper::ForwardType x4, typename CallbackParamTraits::ForwardType x5, typename CallbackParamTraits::ForwardType x6)> ::MakeItSo(storage->runnable_, CallbackForward(x1), CallbackForward(x2), CallbackForward(x3), CallbackForward(x4), CallbackForward(x5), CallbackForward(x6)); } }; // Arity 6 -> 2. template struct Invoker<4, StorageType, R(X1, X2, X3, X4, X5, X6)> { typedef R(RunType)(BindStateBase*, typename CallbackParamTraits::ForwardType, typename CallbackParamTraits::ForwardType); typedef R(UnboundRunType)(X5, X6); static R Run(BindStateBase* base, typename CallbackParamTraits::ForwardType x5, typename CallbackParamTraits::ForwardType x6) { StorageType* storage = static_cast(base); // Local references to make debugger stepping easier. If in a debugger, // you really want to warp ahead and step through the // InvokeHelper<>::MakeItSo() call below. typedef typename StorageType::Bound1UnwrapTraits Bound1UnwrapTraits; typedef typename StorageType::Bound2UnwrapTraits Bound2UnwrapTraits; typedef typename StorageType::Bound3UnwrapTraits Bound3UnwrapTraits; typedef typename StorageType::Bound4UnwrapTraits Bound4UnwrapTraits; typename Bound1UnwrapTraits::ForwardType x1 = Bound1UnwrapTraits::Unwrap(storage->p1_); typename Bound2UnwrapTraits::ForwardType x2 = Bound2UnwrapTraits::Unwrap(storage->p2_); typename Bound3UnwrapTraits::ForwardType x3 = Bound3UnwrapTraits::Unwrap(storage->p3_); typename Bound4UnwrapTraits::ForwardType x4 = Bound4UnwrapTraits::Unwrap(storage->p4_); return InvokeHelper::ForwardType x5, typename CallbackParamTraits::ForwardType x6)> ::MakeItSo(storage->runnable_, CallbackForward(x1), CallbackForward(x2), CallbackForward(x3), CallbackForward(x4), CallbackForward(x5), CallbackForward(x6)); } }; // Arity 6 -> 1. template struct Invoker<5, StorageType, R(X1, X2, X3, X4, X5, X6)> { typedef R(RunType)(BindStateBase*, typename CallbackParamTraits::ForwardType); typedef R(UnboundRunType)(X6); static R Run(BindStateBase* base, typename CallbackParamTraits::ForwardType x6) { StorageType* storage = static_cast(base); // Local references to make debugger stepping easier. If in a debugger, // you really want to warp ahead and step through the // InvokeHelper<>::MakeItSo() call below. typedef typename StorageType::Bound1UnwrapTraits Bound1UnwrapTraits; typedef typename StorageType::Bound2UnwrapTraits Bound2UnwrapTraits; typedef typename StorageType::Bound3UnwrapTraits Bound3UnwrapTraits; typedef typename StorageType::Bound4UnwrapTraits Bound4UnwrapTraits; typedef typename StorageType::Bound5UnwrapTraits Bound5UnwrapTraits; typename Bound1UnwrapTraits::ForwardType x1 = Bound1UnwrapTraits::Unwrap(storage->p1_); typename Bound2UnwrapTraits::ForwardType x2 = Bound2UnwrapTraits::Unwrap(storage->p2_); typename Bound3UnwrapTraits::ForwardType x3 = Bound3UnwrapTraits::Unwrap(storage->p3_); typename Bound4UnwrapTraits::ForwardType x4 = Bound4UnwrapTraits::Unwrap(storage->p4_); typename Bound5UnwrapTraits::ForwardType x5 = Bound5UnwrapTraits::Unwrap(storage->p5_); return InvokeHelper::ForwardType x6)> ::MakeItSo(storage->runnable_, CallbackForward(x1), CallbackForward(x2), CallbackForward(x3), CallbackForward(x4), CallbackForward(x5), CallbackForward(x6)); } }; // Arity 6 -> 0. template struct Invoker<6, StorageType, R(X1, X2, X3, X4, X5, X6)> { typedef R(RunType)(BindStateBase*); typedef R(UnboundRunType)(); static R Run(BindStateBase* base) { StorageType* storage = static_cast(base); // Local references to make debugger stepping easier. If in a debugger, // you really want to warp ahead and step through the // InvokeHelper<>::MakeItSo() call below. typedef typename StorageType::Bound1UnwrapTraits Bound1UnwrapTraits; typedef typename StorageType::Bound2UnwrapTraits Bound2UnwrapTraits; typedef typename StorageType::Bound3UnwrapTraits Bound3UnwrapTraits; typedef typename StorageType::Bound4UnwrapTraits Bound4UnwrapTraits; typedef typename StorageType::Bound5UnwrapTraits Bound5UnwrapTraits; typedef typename StorageType::Bound6UnwrapTraits Bound6UnwrapTraits; typename Bound1UnwrapTraits::ForwardType x1 = Bound1UnwrapTraits::Unwrap(storage->p1_); typename Bound2UnwrapTraits::ForwardType x2 = Bound2UnwrapTraits::Unwrap(storage->p2_); typename Bound3UnwrapTraits::ForwardType x3 = Bound3UnwrapTraits::Unwrap(storage->p3_); typename Bound4UnwrapTraits::ForwardType x4 = Bound4UnwrapTraits::Unwrap(storage->p4_); typename Bound5UnwrapTraits::ForwardType x5 = Bound5UnwrapTraits::Unwrap(storage->p5_); typename Bound6UnwrapTraits::ForwardType x6 = Bound6UnwrapTraits::Unwrap(storage->p6_); return InvokeHelper ::MakeItSo(storage->runnable_, CallbackForward(x1), CallbackForward(x2), CallbackForward(x3), CallbackForward(x4), CallbackForward(x5), CallbackForward(x6)); } }; // Arity 7 -> 7. template struct Invoker<0, StorageType, R(X1, X2, X3, X4, X5, X6, X7)> { typedef R(RunType)(BindStateBase*, typename CallbackParamTraits::ForwardType, typename CallbackParamTraits::ForwardType, typename CallbackParamTraits::ForwardType, typename CallbackParamTraits::ForwardType, typename CallbackParamTraits::ForwardType, typename CallbackParamTraits::ForwardType, typename CallbackParamTraits::ForwardType); typedef R(UnboundRunType)(X1, X2, X3, X4, X5, X6, X7); static R Run(BindStateBase* base, typename CallbackParamTraits::ForwardType x1, typename CallbackParamTraits::ForwardType x2, typename CallbackParamTraits::ForwardType x3, typename CallbackParamTraits::ForwardType x4, typename CallbackParamTraits::ForwardType x5, typename CallbackParamTraits::ForwardType x6, typename CallbackParamTraits::ForwardType x7) { StorageType* storage = static_cast(base); // Local references to make debugger stepping easier. If in a debugger, // you really want to warp ahead and step through the // InvokeHelper<>::MakeItSo() call below. return InvokeHelper::ForwardType x1, typename CallbackParamTraits::ForwardType x2, typename CallbackParamTraits::ForwardType x3, typename CallbackParamTraits::ForwardType x4, typename CallbackParamTraits::ForwardType x5, typename CallbackParamTraits::ForwardType x6, typename CallbackParamTraits::ForwardType x7)> ::MakeItSo(storage->runnable_, CallbackForward(x1), CallbackForward(x2), CallbackForward(x3), CallbackForward(x4), CallbackForward(x5), CallbackForward(x6), CallbackForward(x7)); } }; // Arity 7 -> 6. template struct Invoker<1, StorageType, R(X1, X2, X3, X4, X5, X6, X7)> { typedef R(RunType)(BindStateBase*, typename CallbackParamTraits::ForwardType, typename CallbackParamTraits::ForwardType, typename CallbackParamTraits::ForwardType, typename CallbackParamTraits::ForwardType, typename CallbackParamTraits::ForwardType, typename CallbackParamTraits::ForwardType); typedef R(UnboundRunType)(X2, X3, X4, X5, X6, X7); static R Run(BindStateBase* base, typename CallbackParamTraits::ForwardType x2, typename CallbackParamTraits::ForwardType x3, typename CallbackParamTraits::ForwardType x4, typename CallbackParamTraits::ForwardType x5, typename CallbackParamTraits::ForwardType x6, typename CallbackParamTraits::ForwardType x7) { StorageType* storage = static_cast(base); // Local references to make debugger stepping easier. If in a debugger, // you really want to warp ahead and step through the // InvokeHelper<>::MakeItSo() call below. typedef typename StorageType::Bound1UnwrapTraits Bound1UnwrapTraits; typename Bound1UnwrapTraits::ForwardType x1 = Bound1UnwrapTraits::Unwrap(storage->p1_); return InvokeHelper::ForwardType x2, typename CallbackParamTraits::ForwardType x3, typename CallbackParamTraits::ForwardType x4, typename CallbackParamTraits::ForwardType x5, typename CallbackParamTraits::ForwardType x6, typename CallbackParamTraits::ForwardType x7)> ::MakeItSo(storage->runnable_, CallbackForward(x1), CallbackForward(x2), CallbackForward(x3), CallbackForward(x4), CallbackForward(x5), CallbackForward(x6), CallbackForward(x7)); } }; // Arity 7 -> 5. template struct Invoker<2, StorageType, R(X1, X2, X3, X4, X5, X6, X7)> { typedef R(RunType)(BindStateBase*, typename CallbackParamTraits::ForwardType, typename CallbackParamTraits::ForwardType, typename CallbackParamTraits::ForwardType, typename CallbackParamTraits::ForwardType, typename CallbackParamTraits::ForwardType); typedef R(UnboundRunType)(X3, X4, X5, X6, X7); static R Run(BindStateBase* base, typename CallbackParamTraits::ForwardType x3, typename CallbackParamTraits::ForwardType x4, typename CallbackParamTraits::ForwardType x5, typename CallbackParamTraits::ForwardType x6, typename CallbackParamTraits::ForwardType x7) { StorageType* storage = static_cast(base); // Local references to make debugger stepping easier. If in a debugger, // you really want to warp ahead and step through the // InvokeHelper<>::MakeItSo() call below. typedef typename StorageType::Bound1UnwrapTraits Bound1UnwrapTraits; typedef typename StorageType::Bound2UnwrapTraits Bound2UnwrapTraits; typename Bound1UnwrapTraits::ForwardType x1 = Bound1UnwrapTraits::Unwrap(storage->p1_); typename Bound2UnwrapTraits::ForwardType x2 = Bound2UnwrapTraits::Unwrap(storage->p2_); return InvokeHelper::ForwardType x3, typename CallbackParamTraits::ForwardType x4, typename CallbackParamTraits::ForwardType x5, typename CallbackParamTraits::ForwardType x6, typename CallbackParamTraits::ForwardType x7)> ::MakeItSo(storage->runnable_, CallbackForward(x1), CallbackForward(x2), CallbackForward(x3), CallbackForward(x4), CallbackForward(x5), CallbackForward(x6), CallbackForward(x7)); } }; // Arity 7 -> 4. template struct Invoker<3, StorageType, R(X1, X2, X3, X4, X5, X6, X7)> { typedef R(RunType)(BindStateBase*, typename CallbackParamTraits::ForwardType, typename CallbackParamTraits::ForwardType, typename CallbackParamTraits::ForwardType, typename CallbackParamTraits::ForwardType); typedef R(UnboundRunType)(X4, X5, X6, X7); static R Run(BindStateBase* base, typename CallbackParamTraits::ForwardType x4, typename CallbackParamTraits::ForwardType x5, typename CallbackParamTraits::ForwardType x6, typename CallbackParamTraits::ForwardType x7) { StorageType* storage = static_cast(base); // Local references to make debugger stepping easier. If in a debugger, // you really want to warp ahead and step through the // InvokeHelper<>::MakeItSo() call below. typedef typename StorageType::Bound1UnwrapTraits Bound1UnwrapTraits; typedef typename StorageType::Bound2UnwrapTraits Bound2UnwrapTraits; typedef typename StorageType::Bound3UnwrapTraits Bound3UnwrapTraits; typename Bound1UnwrapTraits::ForwardType x1 = Bound1UnwrapTraits::Unwrap(storage->p1_); typename Bound2UnwrapTraits::ForwardType x2 = Bound2UnwrapTraits::Unwrap(storage->p2_); typename Bound3UnwrapTraits::ForwardType x3 = Bound3UnwrapTraits::Unwrap(storage->p3_); return InvokeHelper::ForwardType x4, typename CallbackParamTraits::ForwardType x5, typename CallbackParamTraits::ForwardType x6, typename CallbackParamTraits::ForwardType x7)> ::MakeItSo(storage->runnable_, CallbackForward(x1), CallbackForward(x2), CallbackForward(x3), CallbackForward(x4), CallbackForward(x5), CallbackForward(x6), CallbackForward(x7)); } }; // Arity 7 -> 3. template struct Invoker<4, StorageType, R(X1, X2, X3, X4, X5, X6, X7)> { typedef R(RunType)(BindStateBase*, typename CallbackParamTraits::ForwardType, typename CallbackParamTraits::ForwardType, typename CallbackParamTraits::ForwardType); typedef R(UnboundRunType)(X5, X6, X7); static R Run(BindStateBase* base, typename CallbackParamTraits::ForwardType x5, typename CallbackParamTraits::ForwardType x6, typename CallbackParamTraits::ForwardType x7) { StorageType* storage = static_cast(base); // Local references to make debugger stepping easier. If in a debugger, // you really want to warp ahead and step through the // InvokeHelper<>::MakeItSo() call below. typedef typename StorageType::Bound1UnwrapTraits Bound1UnwrapTraits; typedef typename StorageType::Bound2UnwrapTraits Bound2UnwrapTraits; typedef typename StorageType::Bound3UnwrapTraits Bound3UnwrapTraits; typedef typename StorageType::Bound4UnwrapTraits Bound4UnwrapTraits; typename Bound1UnwrapTraits::ForwardType x1 = Bound1UnwrapTraits::Unwrap(storage->p1_); typename Bound2UnwrapTraits::ForwardType x2 = Bound2UnwrapTraits::Unwrap(storage->p2_); typename Bound3UnwrapTraits::ForwardType x3 = Bound3UnwrapTraits::Unwrap(storage->p3_); typename Bound4UnwrapTraits::ForwardType x4 = Bound4UnwrapTraits::Unwrap(storage->p4_); return InvokeHelper::ForwardType x5, typename CallbackParamTraits::ForwardType x6, typename CallbackParamTraits::ForwardType x7)> ::MakeItSo(storage->runnable_, CallbackForward(x1), CallbackForward(x2), CallbackForward(x3), CallbackForward(x4), CallbackForward(x5), CallbackForward(x6), CallbackForward(x7)); } }; // Arity 7 -> 2. template struct Invoker<5, StorageType, R(X1, X2, X3, X4, X5, X6, X7)> { typedef R(RunType)(BindStateBase*, typename CallbackParamTraits::ForwardType, typename CallbackParamTraits::ForwardType); typedef R(UnboundRunType)(X6, X7); static R Run(BindStateBase* base, typename CallbackParamTraits::ForwardType x6, typename CallbackParamTraits::ForwardType x7) { StorageType* storage = static_cast(base); // Local references to make debugger stepping easier. If in a debugger, // you really want to warp ahead and step through the // InvokeHelper<>::MakeItSo() call below. typedef typename StorageType::Bound1UnwrapTraits Bound1UnwrapTraits; typedef typename StorageType::Bound2UnwrapTraits Bound2UnwrapTraits; typedef typename StorageType::Bound3UnwrapTraits Bound3UnwrapTraits; typedef typename StorageType::Bound4UnwrapTraits Bound4UnwrapTraits; typedef typename StorageType::Bound5UnwrapTraits Bound5UnwrapTraits; typename Bound1UnwrapTraits::ForwardType x1 = Bound1UnwrapTraits::Unwrap(storage->p1_); typename Bound2UnwrapTraits::ForwardType x2 = Bound2UnwrapTraits::Unwrap(storage->p2_); typename Bound3UnwrapTraits::ForwardType x3 = Bound3UnwrapTraits::Unwrap(storage->p3_); typename Bound4UnwrapTraits::ForwardType x4 = Bound4UnwrapTraits::Unwrap(storage->p4_); typename Bound5UnwrapTraits::ForwardType x5 = Bound5UnwrapTraits::Unwrap(storage->p5_); return InvokeHelper::ForwardType x6, typename CallbackParamTraits::ForwardType x7)> ::MakeItSo(storage->runnable_, CallbackForward(x1), CallbackForward(x2), CallbackForward(x3), CallbackForward(x4), CallbackForward(x5), CallbackForward(x6), CallbackForward(x7)); } }; // Arity 7 -> 1. template struct Invoker<6, StorageType, R(X1, X2, X3, X4, X5, X6, X7)> { typedef R(RunType)(BindStateBase*, typename CallbackParamTraits::ForwardType); typedef R(UnboundRunType)(X7); static R Run(BindStateBase* base, typename CallbackParamTraits::ForwardType x7) { StorageType* storage = static_cast(base); // Local references to make debugger stepping easier. If in a debugger, // you really want to warp ahead and step through the // InvokeHelper<>::MakeItSo() call below. typedef typename StorageType::Bound1UnwrapTraits Bound1UnwrapTraits; typedef typename StorageType::Bound2UnwrapTraits Bound2UnwrapTraits; typedef typename StorageType::Bound3UnwrapTraits Bound3UnwrapTraits; typedef typename StorageType::Bound4UnwrapTraits Bound4UnwrapTraits; typedef typename StorageType::Bound5UnwrapTraits Bound5UnwrapTraits; typedef typename StorageType::Bound6UnwrapTraits Bound6UnwrapTraits; typename Bound1UnwrapTraits::ForwardType x1 = Bound1UnwrapTraits::Unwrap(storage->p1_); typename Bound2UnwrapTraits::ForwardType x2 = Bound2UnwrapTraits::Unwrap(storage->p2_); typename Bound3UnwrapTraits::ForwardType x3 = Bound3UnwrapTraits::Unwrap(storage->p3_); typename Bound4UnwrapTraits::ForwardType x4 = Bound4UnwrapTraits::Unwrap(storage->p4_); typename Bound5UnwrapTraits::ForwardType x5 = Bound5UnwrapTraits::Unwrap(storage->p5_); typename Bound6UnwrapTraits::ForwardType x6 = Bound6UnwrapTraits::Unwrap(storage->p6_); return InvokeHelper::ForwardType x7)> ::MakeItSo(storage->runnable_, CallbackForward(x1), CallbackForward(x2), CallbackForward(x3), CallbackForward(x4), CallbackForward(x5), CallbackForward(x6), CallbackForward(x7)); } }; // Arity 7 -> 0. template struct Invoker<7, StorageType, R(X1, X2, X3, X4, X5, X6, X7)> { typedef R(RunType)(BindStateBase*); typedef R(UnboundRunType)(); static R Run(BindStateBase* base) { StorageType* storage = static_cast(base); // Local references to make debugger stepping easier. If in a debugger, // you really want to warp ahead and step through the // InvokeHelper<>::MakeItSo() call below. typedef typename StorageType::Bound1UnwrapTraits Bound1UnwrapTraits; typedef typename StorageType::Bound2UnwrapTraits Bound2UnwrapTraits; typedef typename StorageType::Bound3UnwrapTraits Bound3UnwrapTraits; typedef typename StorageType::Bound4UnwrapTraits Bound4UnwrapTraits; typedef typename StorageType::Bound5UnwrapTraits Bound5UnwrapTraits; typedef typename StorageType::Bound6UnwrapTraits Bound6UnwrapTraits; typedef typename StorageType::Bound7UnwrapTraits Bound7UnwrapTraits; typename Bound1UnwrapTraits::ForwardType x1 = Bound1UnwrapTraits::Unwrap(storage->p1_); typename Bound2UnwrapTraits::ForwardType x2 = Bound2UnwrapTraits::Unwrap(storage->p2_); typename Bound3UnwrapTraits::ForwardType x3 = Bound3UnwrapTraits::Unwrap(storage->p3_); typename Bound4UnwrapTraits::ForwardType x4 = Bound4UnwrapTraits::Unwrap(storage->p4_); typename Bound5UnwrapTraits::ForwardType x5 = Bound5UnwrapTraits::Unwrap(storage->p5_); typename Bound6UnwrapTraits::ForwardType x6 = Bound6UnwrapTraits::Unwrap(storage->p6_); typename Bound7UnwrapTraits::ForwardType x7 = Bound7UnwrapTraits::Unwrap(storage->p7_); return InvokeHelper ::MakeItSo(storage->runnable_, CallbackForward(x1), CallbackForward(x2), CallbackForward(x3), CallbackForward(x4), CallbackForward(x5), CallbackForward(x6), CallbackForward(x7)); } }; // BindState<> // // This stores all the state passed into Bind() and is also where most // of the template resolution magic occurs. // // Runnable is the functor we are binding arguments to. // RunType is type of the Run() function that the Invoker<> should use. // Normally, this is the same as the RunType of the Runnable, but it can // be different if an adapter like IgnoreResult() has been used. // // BoundArgsType contains the storage type for all the bound arguments by // (ab)using a function type. template struct BindState; template struct BindState : public BindStateBase { typedef Runnable RunnableType; typedef false_type IsWeakCall; typedef Invoker<0, BindState, RunType> InvokerType; typedef typename InvokerType::UnboundRunType UnboundRunType; explicit BindState(const Runnable& runnable) : BindStateBase(&Destroy), runnable_(runnable) { } ~BindState() { } static void Destroy(BindStateBase* self) { delete static_cast(self); } RunnableType runnable_; }; template struct BindState : public BindStateBase { typedef Runnable RunnableType; typedef IsWeakMethod::value, P1> IsWeakCall; typedef Invoker<1, BindState, RunType> InvokerType; typedef typename InvokerType::UnboundRunType UnboundRunType; // Convenience typedefs for bound argument types. typedef UnwrapTraits Bound1UnwrapTraits; BindState(const Runnable& runnable, const P1& p1) : BindStateBase(&Destroy), runnable_(runnable), p1_(p1) { MaybeRefcount::value, P1>::AddRef(p1_); } ~BindState() { MaybeRefcount::value, P1>::Release(p1_); } static void Destroy(BindStateBase* self) { delete static_cast(self); } RunnableType runnable_; P1 p1_; }; template struct BindState : public BindStateBase { typedef Runnable RunnableType; typedef IsWeakMethod::value, P1> IsWeakCall; typedef Invoker<2, BindState, RunType> InvokerType; typedef typename InvokerType::UnboundRunType UnboundRunType; // Convenience typedefs for bound argument types. typedef UnwrapTraits Bound1UnwrapTraits; typedef UnwrapTraits Bound2UnwrapTraits; BindState(const Runnable& runnable, const P1& p1, const P2& p2) : BindStateBase(&Destroy), runnable_(runnable), p1_(p1), p2_(p2) { MaybeRefcount::value, P1>::AddRef(p1_); } ~BindState() { MaybeRefcount::value, P1>::Release(p1_); } static void Destroy(BindStateBase* self) { delete static_cast(self); } RunnableType runnable_; P1 p1_; P2 p2_; }; template struct BindState : public BindStateBase { typedef Runnable RunnableType; typedef IsWeakMethod::value, P1> IsWeakCall; typedef Invoker<3, BindState, RunType> InvokerType; typedef typename InvokerType::UnboundRunType UnboundRunType; // Convenience typedefs for bound argument types. typedef UnwrapTraits Bound1UnwrapTraits; typedef UnwrapTraits Bound2UnwrapTraits; typedef UnwrapTraits Bound3UnwrapTraits; BindState(const Runnable& runnable, const P1& p1, const P2& p2, const P3& p3) : BindStateBase(&Destroy), runnable_(runnable), p1_(p1), p2_(p2), p3_(p3) { MaybeRefcount::value, P1>::AddRef(p1_); } ~BindState() { MaybeRefcount::value, P1>::Release(p1_); } static void Destroy(BindStateBase* self) { delete static_cast(self); } RunnableType runnable_; P1 p1_; P2 p2_; P3 p3_; }; template struct BindState : public BindStateBase { typedef Runnable RunnableType; typedef IsWeakMethod::value, P1> IsWeakCall; typedef Invoker<4, BindState, RunType> InvokerType; typedef typename InvokerType::UnboundRunType UnboundRunType; // Convenience typedefs for bound argument types. typedef UnwrapTraits Bound1UnwrapTraits; typedef UnwrapTraits Bound2UnwrapTraits; typedef UnwrapTraits Bound3UnwrapTraits; typedef UnwrapTraits Bound4UnwrapTraits; BindState(const Runnable& runnable, const P1& p1, const P2& p2, const P3& p3, const P4& p4) : BindStateBase(&Destroy), runnable_(runnable), p1_(p1), p2_(p2), p3_(p3), p4_(p4) { MaybeRefcount::value, P1>::AddRef(p1_); } ~BindState() { MaybeRefcount::value, P1>::Release(p1_); } static void Destroy(BindStateBase* self) { delete static_cast(self); } RunnableType runnable_; P1 p1_; P2 p2_; P3 p3_; P4 p4_; }; template struct BindState : public BindStateBase { typedef Runnable RunnableType; typedef IsWeakMethod::value, P1> IsWeakCall; typedef Invoker<5, BindState, RunType> InvokerType; typedef typename InvokerType::UnboundRunType UnboundRunType; // Convenience typedefs for bound argument types. typedef UnwrapTraits Bound1UnwrapTraits; typedef UnwrapTraits Bound2UnwrapTraits; typedef UnwrapTraits Bound3UnwrapTraits; typedef UnwrapTraits Bound4UnwrapTraits; typedef UnwrapTraits Bound5UnwrapTraits; BindState(const Runnable& runnable, const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5) : BindStateBase(&Destroy), runnable_(runnable), p1_(p1), p2_(p2), p3_(p3), p4_(p4), p5_(p5) { MaybeRefcount::value, P1>::AddRef(p1_); } ~BindState() { MaybeRefcount::value, P1>::Release(p1_); } static void Destroy(BindStateBase* self) { delete static_cast(self); } RunnableType runnable_; P1 p1_; P2 p2_; P3 p3_; P4 p4_; P5 p5_; }; template struct BindState : public BindStateBase { typedef Runnable RunnableType; typedef IsWeakMethod::value, P1> IsWeakCall; typedef Invoker<6, BindState, RunType> InvokerType; typedef typename InvokerType::UnboundRunType UnboundRunType; // Convenience typedefs for bound argument types. typedef UnwrapTraits Bound1UnwrapTraits; typedef UnwrapTraits Bound2UnwrapTraits; typedef UnwrapTraits Bound3UnwrapTraits; typedef UnwrapTraits Bound4UnwrapTraits; typedef UnwrapTraits Bound5UnwrapTraits; typedef UnwrapTraits Bound6UnwrapTraits; BindState(const Runnable& runnable, const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5, const P6& p6) : BindStateBase(&Destroy), runnable_(runnable), p1_(p1), p2_(p2), p3_(p3), p4_(p4), p5_(p5), p6_(p6) { MaybeRefcount::value, P1>::AddRef(p1_); } ~BindState() { MaybeRefcount::value, P1>::Release(p1_); } static void Destroy(BindStateBase* self) { delete static_cast(self); } RunnableType runnable_; P1 p1_; P2 p2_; P3 p3_; P4 p4_; P5 p5_; P6 p6_; }; template struct BindState : public BindStateBase { typedef Runnable RunnableType; typedef IsWeakMethod::value, P1> IsWeakCall; typedef Invoker<7, BindState, RunType> InvokerType; typedef typename InvokerType::UnboundRunType UnboundRunType; // Convenience typedefs for bound argument types. typedef UnwrapTraits Bound1UnwrapTraits; typedef UnwrapTraits Bound2UnwrapTraits; typedef UnwrapTraits Bound3UnwrapTraits; typedef UnwrapTraits Bound4UnwrapTraits; typedef UnwrapTraits Bound5UnwrapTraits; typedef UnwrapTraits Bound6UnwrapTraits; typedef UnwrapTraits Bound7UnwrapTraits; BindState(const Runnable& runnable, const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5, const P6& p6, const P7& p7) : BindStateBase(&Destroy), runnable_(runnable), p1_(p1), p2_(p2), p3_(p3), p4_(p4), p5_(p5), p6_(p6), p7_(p7) { MaybeRefcount::value, P1>::AddRef(p1_); } ~BindState() { MaybeRefcount::value, P1>::Release(p1_); } static void Destroy(BindStateBase* self) { delete static_cast(self); } RunnableType runnable_; P1 p1_; P2 p2_; P3 p3_; P4 p4_; P5 p5_; P6 p6_; P7 p7_; }; } // namespace cef_internal } // namespace base #endif // CEF_INCLUDE_BASE_INTERNAL_CEF_BIND_INTERNAL_H_ cefpython-49.0/src/include/base/internal/cef_bind_internal_win.h000066400000000000000000000273761334103266300251000ustar00rootroot00000000000000// Copyright (c) 2011 Google Inc. 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. // Do not include this header file directly. Use base/cef_bind.h instead. // Specializations of RunnableAdapter<> for Windows specific calling // conventions. Please see base/bind_internal.h for more info. #ifndef CEF_INCLUDE_BASE_INTERNAL_CEF_BIND_INTERNAL_WIN_H_ #define CEF_INCLUDE_BASE_INTERNAL_CEF_BIND_INTERNAL_WIN_H_ // In the x64 architecture in Windows, __fastcall, __stdcall, etc, are all // the same as __cdecl which would turn the following specializations into // multiple definitions. #if !defined(ARCH_CPU_X86_64) namespace base { namespace cef_internal { template class RunnableAdapter; // __stdcall Function: Arity 0. template class RunnableAdapter { public: typedef R (RunType)(); explicit RunnableAdapter(R(__stdcall *function)()) : function_(function) { } R Run() { return function_(); } private: R (__stdcall *function_)(); }; // __fastcall Function: Arity 0. template class RunnableAdapter { public: typedef R (RunType)(); explicit RunnableAdapter(R(__fastcall *function)()) : function_(function) { } R Run() { return function_(); } private: R (__fastcall *function_)(); }; // __stdcall Function: Arity 1. template class RunnableAdapter { public: typedef R (RunType)(A1); explicit RunnableAdapter(R(__stdcall *function)(A1)) : function_(function) { } R Run(typename CallbackParamTraits::ForwardType a1) { return function_(a1); } private: R (__stdcall *function_)(A1); }; // __fastcall Function: Arity 1. template class RunnableAdapter { public: typedef R (RunType)(A1); explicit RunnableAdapter(R(__fastcall *function)(A1)) : function_(function) { } R Run(typename CallbackParamTraits::ForwardType a1) { return function_(a1); } private: R (__fastcall *function_)(A1); }; // __stdcall Function: Arity 2. template class RunnableAdapter { public: typedef R (RunType)(A1, A2); explicit RunnableAdapter(R(__stdcall *function)(A1, A2)) : function_(function) { } R Run(typename CallbackParamTraits::ForwardType a1, typename CallbackParamTraits::ForwardType a2) { return function_(a1, a2); } private: R (__stdcall *function_)(A1, A2); }; // __fastcall Function: Arity 2. template class RunnableAdapter { public: typedef R (RunType)(A1, A2); explicit RunnableAdapter(R(__fastcall *function)(A1, A2)) : function_(function) { } R Run(typename CallbackParamTraits::ForwardType a1, typename CallbackParamTraits::ForwardType a2) { return function_(a1, a2); } private: R (__fastcall *function_)(A1, A2); }; // __stdcall Function: Arity 3. template class RunnableAdapter { public: typedef R (RunType)(A1, A2, A3); explicit RunnableAdapter(R(__stdcall *function)(A1, A2, A3)) : function_(function) { } R Run(typename CallbackParamTraits::ForwardType a1, typename CallbackParamTraits::ForwardType a2, typename CallbackParamTraits::ForwardType a3) { return function_(a1, a2, a3); } private: R (__stdcall *function_)(A1, A2, A3); }; // __fastcall Function: Arity 3. template class RunnableAdapter { public: typedef R (RunType)(A1, A2, A3); explicit RunnableAdapter(R(__fastcall *function)(A1, A2, A3)) : function_(function) { } R Run(typename CallbackParamTraits::ForwardType a1, typename CallbackParamTraits::ForwardType a2, typename CallbackParamTraits::ForwardType a3) { return function_(a1, a2, a3); } private: R (__fastcall *function_)(A1, A2, A3); }; // __stdcall Function: Arity 4. template class RunnableAdapter { public: typedef R (RunType)(A1, A2, A3, A4); explicit RunnableAdapter(R(__stdcall *function)(A1, A2, A3, A4)) : function_(function) { } R Run(typename CallbackParamTraits::ForwardType a1, typename CallbackParamTraits::ForwardType a2, typename CallbackParamTraits::ForwardType a3, typename CallbackParamTraits::ForwardType a4) { return function_(a1, a2, a3, a4); } private: R (__stdcall *function_)(A1, A2, A3, A4); }; // __fastcall Function: Arity 4. template class RunnableAdapter { public: typedef R (RunType)(A1, A2, A3, A4); explicit RunnableAdapter(R(__fastcall *function)(A1, A2, A3, A4)) : function_(function) { } R Run(typename CallbackParamTraits::ForwardType a1, typename CallbackParamTraits::ForwardType a2, typename CallbackParamTraits::ForwardType a3, typename CallbackParamTraits::ForwardType a4) { return function_(a1, a2, a3, a4); } private: R (__fastcall *function_)(A1, A2, A3, A4); }; // __stdcall Function: Arity 5. template class RunnableAdapter { public: typedef R (RunType)(A1, A2, A3, A4, A5); explicit RunnableAdapter(R(__stdcall *function)(A1, A2, A3, A4, A5)) : function_(function) { } R Run(typename CallbackParamTraits::ForwardType a1, typename CallbackParamTraits::ForwardType a2, typename CallbackParamTraits::ForwardType a3, typename CallbackParamTraits::ForwardType a4, typename CallbackParamTraits::ForwardType a5) { return function_(a1, a2, a3, a4, a5); } private: R (__stdcall *function_)(A1, A2, A3, A4, A5); }; // __fastcall Function: Arity 5. template class RunnableAdapter { public: typedef R (RunType)(A1, A2, A3, A4, A5); explicit RunnableAdapter(R(__fastcall *function)(A1, A2, A3, A4, A5)) : function_(function) { } R Run(typename CallbackParamTraits::ForwardType a1, typename CallbackParamTraits::ForwardType a2, typename CallbackParamTraits::ForwardType a3, typename CallbackParamTraits::ForwardType a4, typename CallbackParamTraits::ForwardType a5) { return function_(a1, a2, a3, a4, a5); } private: R (__fastcall *function_)(A1, A2, A3, A4, A5); }; // __stdcall Function: Arity 6. template class RunnableAdapter { public: typedef R (RunType)(A1, A2, A3, A4, A5, A6); explicit RunnableAdapter(R(__stdcall *function)(A1, A2, A3, A4, A5, A6)) : function_(function) { } R Run(typename CallbackParamTraits::ForwardType a1, typename CallbackParamTraits::ForwardType a2, typename CallbackParamTraits::ForwardType a3, typename CallbackParamTraits::ForwardType a4, typename CallbackParamTraits::ForwardType a5, typename CallbackParamTraits::ForwardType a6) { return function_(a1, a2, a3, a4, a5, a6); } private: R (__stdcall *function_)(A1, A2, A3, A4, A5, A6); }; // __fastcall Function: Arity 6. template class RunnableAdapter { public: typedef R (RunType)(A1, A2, A3, A4, A5, A6); explicit RunnableAdapter(R(__fastcall *function)(A1, A2, A3, A4, A5, A6)) : function_(function) { } R Run(typename CallbackParamTraits::ForwardType a1, typename CallbackParamTraits::ForwardType a2, typename CallbackParamTraits::ForwardType a3, typename CallbackParamTraits::ForwardType a4, typename CallbackParamTraits::ForwardType a5, typename CallbackParamTraits::ForwardType a6) { return function_(a1, a2, a3, a4, a5, a6); } private: R (__fastcall *function_)(A1, A2, A3, A4, A5, A6); }; // __stdcall Function: Arity 7. template class RunnableAdapter { public: typedef R (RunType)(A1, A2, A3, A4, A5, A6, A7); explicit RunnableAdapter(R(__stdcall *function)(A1, A2, A3, A4, A5, A6, A7)) : function_(function) { } R Run(typename CallbackParamTraits::ForwardType a1, typename CallbackParamTraits::ForwardType a2, typename CallbackParamTraits::ForwardType a3, typename CallbackParamTraits::ForwardType a4, typename CallbackParamTraits::ForwardType a5, typename CallbackParamTraits::ForwardType a6, typename CallbackParamTraits::ForwardType a7) { return function_(a1, a2, a3, a4, a5, a6, a7); } private: R (__stdcall *function_)(A1, A2, A3, A4, A5, A6, A7); }; // __fastcall Function: Arity 7. template class RunnableAdapter { public: typedef R (RunType)(A1, A2, A3, A4, A5, A6, A7); explicit RunnableAdapter(R(__fastcall *function)(A1, A2, A3, A4, A5, A6, A7)) : function_(function) { } R Run(typename CallbackParamTraits::ForwardType a1, typename CallbackParamTraits::ForwardType a2, typename CallbackParamTraits::ForwardType a3, typename CallbackParamTraits::ForwardType a4, typename CallbackParamTraits::ForwardType a5, typename CallbackParamTraits::ForwardType a6, typename CallbackParamTraits::ForwardType a7) { return function_(a1, a2, a3, a4, a5, a6, a7); } private: R (__fastcall *function_)(A1, A2, A3, A4, A5, A6, A7); }; } // namespace cef_internal } // namespace base #endif // !defined(ARCH_CPU_X86_64) #endif // CEF_INCLUDE_BASE_INTERNAL_CEF_BIND_INTERNAL_WIN_H_ cefpython-49.0/src/include/base/internal/cef_callback_internal.h000066400000000000000000000213771334103266300250360ustar00rootroot00000000000000// Copyright (c) 2012 Google Inc. 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. // Do not include this header file directly. Use base/cef_bind.h or // base/cef_callback.h instead. // This file contains utility functions and classes that help the // implementation, and management of the Callback objects. #ifndef CEF_INCLUDE_BASE_INTERNAL_CEF_CALLBACK_INTERNAL_H_ #define CEF_INCLUDE_BASE_INTERNAL_CEF_CALLBACK_INTERNAL_H_ #include #include "include/base/cef_atomic_ref_count.h" #include "include/base/cef_macros.h" #include "include/base/cef_ref_counted.h" #include "include/base/cef_scoped_ptr.h" #include "include/base/cef_template_util.h" template class ScopedVector; namespace base { namespace cef_internal { class CallbackBase; // At the base level, the only task is to add reference counting data. Don't use // RefCountedThreadSafe since it requires the destructor to be a virtual method. // Creating a vtable for every BindState template instantiation results in a lot // of bloat. Its only task is to call the destructor which can be done with a // function pointer. class BindStateBase { protected: explicit BindStateBase(void (*destructor)(BindStateBase*)) : ref_count_(0), destructor_(destructor) {} ~BindStateBase() {} private: friend class scoped_refptr; friend class CallbackBase; void AddRef(); void Release(); AtomicRefCount ref_count_; // Pointer to a function that will properly destroy |this|. void (*destructor_)(BindStateBase*); DISALLOW_COPY_AND_ASSIGN(BindStateBase); }; // Holds the Callback methods that don't require specialization to reduce // template bloat. class CallbackBase { public: // Returns true if Callback is null (doesn't refer to anything). bool is_null() const { return bind_state_.get() == NULL; } // Returns the Callback into an uninitialized state. void Reset(); protected: // In C++, it is safe to cast function pointers to function pointers of // another type. It is not okay to use void*. We create a InvokeFuncStorage // that that can store our function pointer, and then cast it back to // the original type on usage. typedef void(*InvokeFuncStorage)(void); // Returns true if this callback equals |other|. |other| may be null. bool Equals(const CallbackBase& other) const; // Allow initializing of |bind_state_| via the constructor to avoid default // initialization of the scoped_refptr. We do not also initialize // |polymorphic_invoke_| here because doing a normal assignment in the // derived Callback templates makes for much nicer compiler errors. explicit CallbackBase(BindStateBase* bind_state); // Force the destructor to be instantiated inside this translation unit so // that our subclasses will not get inlined versions. Avoids more template // bloat. ~CallbackBase(); scoped_refptr bind_state_; InvokeFuncStorage polymorphic_invoke_; }; // A helper template to determine if given type is non-const move-only-type, // i.e. if a value of the given type should be passed via .Pass() in a // destructive way. template struct IsMoveOnlyType { template static YesType Test(const typename U::MoveOnlyTypeForCPP03*); template static NoType Test(...); static const bool value = sizeof(Test(0)) == sizeof(YesType) && !is_const::value; }; // This is a typetraits object that's used to take an argument type, and // extract a suitable type for storing and forwarding arguments. // // In particular, it strips off references, and converts arrays to // pointers for storage; and it avoids accidentally trying to create a // "reference of a reference" if the argument is a reference type. // // This array type becomes an issue for storage because we are passing bound // parameters by const reference. In this case, we end up passing an actual // array type in the initializer list which C++ does not allow. This will // break passing of C-string literals. template ::value> struct CallbackParamTraits { typedef const T& ForwardType; typedef T StorageType; }; // The Storage should almost be impossible to trigger unless someone manually // specifies type of the bind parameters. However, in case they do, // this will guard against us accidentally storing a reference parameter. // // The ForwardType should only be used for unbound arguments. template struct CallbackParamTraits { typedef T& ForwardType; typedef T StorageType; }; // Note that for array types, we implicitly add a const in the conversion. This // means that it is not possible to bind array arguments to functions that take // a non-const pointer. Trying to specialize the template based on a "const // T[n]" does not seem to match correctly, so we are stuck with this // restriction. template struct CallbackParamTraits { typedef const T* ForwardType; typedef const T* StorageType; }; // See comment for CallbackParamTraits. template struct CallbackParamTraits { typedef const T* ForwardType; typedef const T* StorageType; }; // Parameter traits for movable-but-not-copyable scopers. // // Callback<>/Bind() understands movable-but-not-copyable semantics where // the type cannot be copied but can still have its state destructively // transferred (aka. moved) to another instance of the same type by calling a // helper function. When used with Bind(), this signifies transferal of the // object's state to the target function. // // For these types, the ForwardType must not be a const reference, or a // reference. A const reference is inappropriate, and would break const // correctness, because we are implementing a destructive move. A non-const // reference cannot be used with temporaries which means the result of a // function or a cast would not be usable with Callback<> or Bind(). template struct CallbackParamTraits { typedef T ForwardType; typedef T StorageType; }; // CallbackForward() is a very limited simulation of C++11's std::forward() // used by the Callback/Bind system for a set of movable-but-not-copyable // types. It is needed because forwarding a movable-but-not-copyable // argument to another function requires us to invoke the proper move // operator to create a rvalue version of the type. The supported types are // whitelisted below as overloads of the CallbackForward() function. The // default template compiles out to be a no-op. // // In C++11, std::forward would replace all uses of this function. However, it // is impossible to implement a general std::forward with C++11 due to a lack // of rvalue references. // // In addition to Callback/Bind, this is used by PostTaskAndReplyWithResult to // simulate std::forward() and forward the result of one Callback as a // parameter to another callback. This is to support Callbacks that return // the movable-but-not-copyable types whitelisted above. template typename enable_if::value, T>::type& CallbackForward(T& t) { return t; } template typename enable_if::value, T>::type CallbackForward(T& t) { return t.Pass(); } } // namespace cef_internal } // namespace base #endif // CEF_INCLUDE_BASE_INTERNAL_CEF_CALLBACK_INTERNAL_H_ cefpython-49.0/src/include/base/internal/cef_lock_impl.h000066400000000000000000000060561334103266300233540ustar00rootroot00000000000000// Copyright (c) 2011 Google Inc. 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. // Do not include this header file directly. Use base/cef_lock.h instead. #ifndef CEF_INCLUDE_BASE_INTERNAL_CEF_LOCK_IMPL_H_ #define CEF_INCLUDE_BASE_INTERNAL_CEF_LOCK_IMPL_H_ #include "include/base/cef_build.h" #if defined(OS_WIN) #include #elif defined(OS_POSIX) #include #endif #include "include/base/cef_macros.h" namespace base { namespace cef_internal { // This class implements the underlying platform-specific spin-lock mechanism // used for the Lock class. Most users should not use LockImpl directly, but // should instead use Lock. class LockImpl { public: #if defined(OS_WIN) typedef CRITICAL_SECTION NativeHandle; #elif defined(OS_POSIX) typedef pthread_mutex_t NativeHandle; #endif LockImpl(); ~LockImpl(); // If the lock is not held, take it and return true. If the lock is already // held by something else, immediately return false. bool Try(); // Take the lock, blocking until it is available if necessary. void Lock(); // Release the lock. This must only be called by the lock's holder: after // a successful call to Try, or a call to Lock. void Unlock(); // Return the native underlying lock. // TODO(awalker): refactor lock and condition variables so that this is // unnecessary. NativeHandle* native_handle() { return &native_handle_; } private: NativeHandle native_handle_; DISALLOW_COPY_AND_ASSIGN(LockImpl); }; } // namespace cef_internal } // namespace base #endif // CEF_INCLUDE_BASE_INTERNAL_CEF_LOCK_IMPL_H_ cefpython-49.0/src/include/base/internal/cef_raw_scoped_refptr_mismatch_checker.h000066400000000000000000000147121334103266300304620ustar00rootroot00000000000000// Copyright (c) 2011 Google Inc. 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. // Do not include this header file directly. Use base/cef_callback.h instead. #ifndef CEF_INCLUDE_BASE_INTERNAL_CEF_RAW_SCOPED_REFPTR_MISMATCH_CHECKER_H_ #define CEF_INCLUDE_BASE_INTERNAL_CEF_RAW_SCOPED_REFPTR_MISMATCH_CHECKER_H_ #include "include/base/cef_build.h" #include "include/base/cef_ref_counted.h" #include "include/base/cef_template_util.h" #include "include/base/cef_tuple.h" // It is dangerous to post a task with a T* argument where T is a subtype of // RefCounted(Base|ThreadSafeBase), since by the time the parameter is used, the // object may already have been deleted since it was not held with a // scoped_refptr. Example: http://crbug.com/27191 // The following set of traits are designed to generate a compile error // whenever this antipattern is attempted. namespace base { namespace cef_internal { template struct NeedsScopedRefptrButGetsRawPtr { #if defined(OS_WIN) enum { value = base::false_type::value }; #else enum { // Human readable translation: you needed to be a scoped_refptr if you are a // raw pointer type and are convertible to a RefCounted(Base|ThreadSafeBase) // type. value = (is_pointer::value && (is_convertible::value || is_convertible::value)) }; #endif }; template struct ParamsUseScopedRefptrCorrectly { enum { value = 0 }; }; template <> struct ParamsUseScopedRefptrCorrectly { enum { value = 1 }; }; template struct ParamsUseScopedRefptrCorrectly > { enum { value = !NeedsScopedRefptrButGetsRawPtr::value }; }; template struct ParamsUseScopedRefptrCorrectly > { enum { value = !(NeedsScopedRefptrButGetsRawPtr::value || NeedsScopedRefptrButGetsRawPtr::value) }; }; template struct ParamsUseScopedRefptrCorrectly > { enum { value = !(NeedsScopedRefptrButGetsRawPtr::value || NeedsScopedRefptrButGetsRawPtr::value || NeedsScopedRefptrButGetsRawPtr::value) }; }; template struct ParamsUseScopedRefptrCorrectly > { enum { value = !(NeedsScopedRefptrButGetsRawPtr::value || NeedsScopedRefptrButGetsRawPtr::value || NeedsScopedRefptrButGetsRawPtr::value || NeedsScopedRefptrButGetsRawPtr::value) }; }; template struct ParamsUseScopedRefptrCorrectly > { enum { value = !(NeedsScopedRefptrButGetsRawPtr::value || NeedsScopedRefptrButGetsRawPtr::value || NeedsScopedRefptrButGetsRawPtr::value || NeedsScopedRefptrButGetsRawPtr::value || NeedsScopedRefptrButGetsRawPtr::value) }; }; template struct ParamsUseScopedRefptrCorrectly > { enum { value = !(NeedsScopedRefptrButGetsRawPtr::value || NeedsScopedRefptrButGetsRawPtr::value || NeedsScopedRefptrButGetsRawPtr::value || NeedsScopedRefptrButGetsRawPtr::value || NeedsScopedRefptrButGetsRawPtr::value || NeedsScopedRefptrButGetsRawPtr::value) }; }; template struct ParamsUseScopedRefptrCorrectly > { enum { value = !(NeedsScopedRefptrButGetsRawPtr::value || NeedsScopedRefptrButGetsRawPtr::value || NeedsScopedRefptrButGetsRawPtr::value || NeedsScopedRefptrButGetsRawPtr::value || NeedsScopedRefptrButGetsRawPtr::value || NeedsScopedRefptrButGetsRawPtr::value || NeedsScopedRefptrButGetsRawPtr::value) }; }; template struct ParamsUseScopedRefptrCorrectly > { enum { value = !(NeedsScopedRefptrButGetsRawPtr::value || NeedsScopedRefptrButGetsRawPtr::value || NeedsScopedRefptrButGetsRawPtr::value || NeedsScopedRefptrButGetsRawPtr::value || NeedsScopedRefptrButGetsRawPtr::value || NeedsScopedRefptrButGetsRawPtr::value || NeedsScopedRefptrButGetsRawPtr::value || NeedsScopedRefptrButGetsRawPtr::value) }; }; } // namespace cef_internal } // namespace base #endif // CEF_INCLUDE_BASE_INTERNAL_CEF_RAW_SCOPED_REFPTR_MISMATCH_CHECKER_H_ cefpython-49.0/src/include/base/internal/cef_thread_checker_impl.h000066400000000000000000000055011334103266300253510ustar00rootroot00000000000000// Copyright (c) 2011 Google Inc. 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. // Do not include this header file directly. Use base/cef_thread_checker.h // instead. #ifndef CEF_INCLUDE_BASE_INTERNAL_THREAD_CHECKER_IMPL_H_ #define CEF_INCLUDE_BASE_INTERNAL_THREAD_CHECKER_IMPL_H_ #include "include/base/cef_lock.h" #include "include/base/cef_platform_thread.h" namespace base { namespace cef_internal { // Real implementation of ThreadChecker, for use in debug mode, or // for temporary use in release mode (e.g. to CHECK on a threading issue // seen only in the wild). // // Note: You should almost always use the ThreadChecker class to get the // right version for your build configuration. class ThreadCheckerImpl { public: ThreadCheckerImpl(); ~ThreadCheckerImpl(); bool CalledOnValidThread() const; // Changes the thread that is checked for in CalledOnValidThread. This may // be useful when an object may be created on one thread and then used // exclusively on another thread. void DetachFromThread(); private: void EnsureThreadIdAssigned() const; mutable base::Lock lock_; // This is mutable so that CalledOnValidThread can set it. // It's guarded by |lock_|. mutable PlatformThreadRef valid_thread_id_; }; } // namespace cef_internal } // namespace base #endif // CEF_INCLUDE_BASE_INTERNAL_THREAD_CHECKER_IMPL_H_ cefpython-49.0/src/include/cef_app.h000066400000000000000000000200311334103266300174220ustar00rootroot00000000000000// 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_APP_H_ #define CEF_INCLUDE_CEF_APP_H_ #pragma once #include "include/cef_base.h" #include "include/cef_browser_process_handler.h" #include "include/cef_command_line.h" #include "include/cef_render_process_handler.h" #include "include/cef_resource_bundle_handler.h" #include "include/cef_scheme.h" class CefApp; /// // This function should be called from the application entry point function to // execute a secondary process. It can be used to run secondary processes from // the browser client executable (default behavior) or from a separate // executable specified by the CefSettings.browser_subprocess_path value. If // called for the browser process (identified by no "type" command-line value) // it will return immediately with a value of -1. If called for a recognized // secondary process it will block until the process should exit and then return // the process exit code. The |application| parameter may be empty. The // |windows_sandbox_info| parameter is only used on Windows and may be NULL (see // cef_sandbox_win.h for details). /// /*--cef(api_hash_check,optional_param=application, optional_param=windows_sandbox_info)--*/ int CefExecuteProcess(const CefMainArgs& args, CefRefPtr application, void* windows_sandbox_info); /// // This function should be called on the main application thread to initialize // the CEF browser process. The |application| parameter may be empty. A return // value of true indicates that it succeeded and false indicates that it failed. // The |windows_sandbox_info| parameter is only used on Windows and may be NULL // (see cef_sandbox_win.h for details). /// /*--cef(api_hash_check,optional_param=application, optional_param=windows_sandbox_info)--*/ bool CefInitialize(const CefMainArgs& args, const CefSettings& settings, CefRefPtr application, void* windows_sandbox_info); /// // This function should be called on the main application thread to shut down // the CEF browser process 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(); /// // Set to true before calling Windows APIs like TrackPopupMenu that enter a // modal message loop. Set to false after exiting the modal message loop. /// /*--cef()--*/ void CefSetOSModalLoop(bool osModalLoop); /// // Call during process startup to enable High-DPI support on Windows 7 or newer. // Older versions of Windows should be left DPI-unaware because they do not // support DirectWrite and GDI fonts are kerned very badly. /// /*--cef(capi_name=cef_enable_highdpi_support)--*/ void CefEnableHighDPISupport(); /// // Implement this interface to provide handler implementations. Methods will be // called by the process and/or thread indicated. /// /*--cef(source=client,no_debugct_check)--*/ class CefApp : public virtual CefBase { public: /// // Provides an opportunity to view and/or modify command-line arguments before // processing by CEF and Chromium. The |process_type| value will be empty for // the browser process. Do not keep a reference to the CefCommandLine object // passed to this method. The CefSettings.command_line_args_disabled value // can be used to start with an empty command-line object. Any values // specified in CefSettings that equate to command-line arguments will be set // before this method is called. Be cautious when using this method to modify // command-line arguments for non-browser processes as this may result in // undefined behavior including crashes. /// /*--cef(optional_param=process_type)--*/ virtual void OnBeforeCommandLineProcessing( const CefString& process_type, CefRefPtr command_line) { } /// // Provides an opportunity to register custom schemes. Do not keep a reference // to the |registrar| object. This method is called on the main thread for // each process and the registered schemes should be the same across all // processes. /// /*--cef()--*/ virtual void OnRegisterCustomSchemes( CefRefPtr registrar) { } /// // 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 by the browser and render processes on multiple threads. /// /*--cef()--*/ virtual CefRefPtr GetResourceBundleHandler() { return NULL; } /// // Return the handler for functionality specific to the browser process. This // method is called on multiple threads in the browser process. /// /*--cef()--*/ virtual CefRefPtr GetBrowserProcessHandler() { return NULL; } /// // Return the handler for functionality specific to the render process. This // method is called on the render process main thread. /// /*--cef()--*/ virtual CefRefPtr GetRenderProcessHandler() { return NULL; } }; #endif // CEF_INCLUDE_CEF_APP_H_ cefpython-49.0/src/include/cef_application_mac.h000066400000000000000000000154111334103266300217730ustar00rootroot00000000000000// 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_CEF_APPLICATION_MAC_H_ #define CEF_INCLUDE_CEF_APPLICATION_MAC_H_ #pragma once #include "include/cef_base.h" #if defined(OS_MACOSX) && defined(__OBJC__) #ifdef BUILDING_CEF_SHARED // Use the existing CrAppControlProtocol definition. #import "base/mac/scoped_sending_event.h" // Use the existing CrAppProtocol definition. #import "base/message_loop/message_pump_mac.h" // Use the existing UnderlayableSurface definition. #import "ui/base/cocoa/underlay_opengl_hosting_window.h" // Use the existing empty protocol definitions. #import "base/mac/cocoa_protocols.h" // Use the existing empty protocol definitions. #import "base/mac/sdk_forward_declarations.h" #else // BUILDING_CEF_SHARED #import #import // Copy of definition from base/message_loop/message_pump_mac.h. @protocol CrAppProtocol // Must return true if -[NSApplication sendEvent:] is currently on the stack. - (BOOL)isHandlingSendEvent; @end // Copy of definition from base/mac/scoped_sending_event.h. @protocol CrAppControlProtocol - (void)setHandlingSendEvent:(BOOL)handlingSendEvent; @end // Copy of definition from ui/base/cocoa/underlay_opengl_hosting_window.h. // Common base class for windows that host a OpenGL surface that renders under // the window. Contains methods relating to hole punching so that the OpenGL // surface is visible through the window. @interface UnderlayOpenGLHostingWindow : NSWindow @end // Copy of definitions from base/mac/sdk_forward_declarations.h. // Forward declarations for APIs that are part of the 10.7 SDK. This will allow // using them when building with the 10.6 SDK. #if !defined(MAC_OS_X_VERSION_10_7) || \ MAC_OS_X_VERSION_MAX_ALLOWED < MAC_OS_X_VERSION_10_7 enum { NSEventPhaseNone = 0, // event not associated with a phase. NSEventPhaseBegan = 0x1 << 0, NSEventPhaseStationary = 0x1 << 1, NSEventPhaseChanged = 0x1 << 2, NSEventPhaseEnded = 0x1 << 3, NSEventPhaseCancelled = 0x1 << 4, }; typedef NSUInteger NSEventPhase; @interface NSEvent (LionSDK) + (BOOL)isSwipeTrackingFromScrollEventsEnabled; - (NSEventPhase)phase; - (CGFloat)scrollingDeltaX; - (CGFloat)scrollingDeltaY; - (BOOL)isDirectionInvertedFromDevice; @end @interface NSScreen (LionSDK) - (CGFloat)backingScaleFactor; - (NSRect)convertRectToBacking:(NSRect)aRect; @end @interface NSWindow (LionSDK) - (CGFloat)backingScaleFactor; @end #endif // MAC_OS_X_VERSION_10_7 // The Mac OS X 10.6 SDK introduced new protocols used for delegates. These // protocol defintions were not present in earlier releases of the Mac OS X // SDK. In order to support building against the new SDK, which requires // delegates to conform to these protocols, and earlier SDKs, which do not // define these protocols at all, this file will provide empty protocol // definitions when used with earlier SDK versions. #if !defined(MAC_OS_X_VERSION_10_6) || \ MAC_OS_X_VERSION_MAX_ALLOWED < MAC_OS_X_VERSION_10_6 #define DEFINE_EMPTY_PROTOCOL(p) \ @protocol p \ @end DEFINE_EMPTY_PROTOCOL(NSAlertDelegate) DEFINE_EMPTY_PROTOCOL(NSApplicationDelegate) DEFINE_EMPTY_PROTOCOL(NSControlTextEditingDelegate) DEFINE_EMPTY_PROTOCOL(NSMatrixDelegate) DEFINE_EMPTY_PROTOCOL(NSMenuDelegate) DEFINE_EMPTY_PROTOCOL(NSOpenSavePanelDelegate) DEFINE_EMPTY_PROTOCOL(NSOutlineViewDataSource) DEFINE_EMPTY_PROTOCOL(NSOutlineViewDelegate) DEFINE_EMPTY_PROTOCOL(NSSpeechSynthesizerDelegate) DEFINE_EMPTY_PROTOCOL(NSSplitViewDelegate) DEFINE_EMPTY_PROTOCOL(NSTableViewDataSource) DEFINE_EMPTY_PROTOCOL(NSTableViewDelegate) DEFINE_EMPTY_PROTOCOL(NSTextFieldDelegate) DEFINE_EMPTY_PROTOCOL(NSTextViewDelegate) DEFINE_EMPTY_PROTOCOL(NSWindowDelegate) #undef DEFINE_EMPTY_PROTOCOL #endif #endif // BUILDING_CEF_SHARED // Forward declarations for APIs that are part of the 10.7 SDK. This will allow // using them when building with the 10.6 SDK. #if !defined(MAC_OS_X_VERSION_10_7) || \ MAC_OS_X_VERSION_MAX_ALLOWED < MAC_OS_X_VERSION_10_7 @interface NSView (NSOpenGLSurfaceResolutionLionAPI) - (void)setWantsBestResolutionOpenGLSurface:(BOOL)flag; @end @interface NSView (LionAPI) - (NSSize)convertSizeToBacking:(NSSize)aSize; - (NSRect)convertRectToBacking:(NSRect)aRect; - (NSRect)convertRectFromBacking:(NSRect)aRect; @end static NSString* const NSWindowDidChangeBackingPropertiesNotification = @"NSWindowDidChangeBackingPropertiesNotification"; static NSString* const NSBackingPropertyOldScaleFactorKey = @"NSBackingPropertyOldScaleFactorKey"; #endif // MAC_OS_X_VERSION_10_7 // All CEF client applications must subclass NSApplication and implement this // protocol. @protocol CefAppProtocol @end // Controls the state of |isHandlingSendEvent| in the event loop so that it is // reset properly. class CefScopedSendingEvent { public: CefScopedSendingEvent() : app_(static_cast*>( [NSApplication sharedApplication])), handling_([app_ isHandlingSendEvent]) { [app_ setHandlingSendEvent:YES]; } ~CefScopedSendingEvent() { [app_ setHandlingSendEvent:handling_]; } private: NSApplication* app_; BOOL handling_; }; #endif // defined(OS_MACOSX) && defined(__OBJC__) #endif // CEF_INCLUDE_CEF_APPLICATION_MAC_H_ cefpython-49.0/src/include/cef_auth_callback.h000066400000000000000000000047441334103266300214340ustar00rootroot00000000000000// Copyright (c) 2013 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_AUTH_CALLBACK_H_ #define CEF_INCLUDE_CEF_AUTH_CALLBACK_H_ #pragma once #include "include/cef_base.h" /// // Callback interface used for asynchronous continuation of authentication // requests. /// /*--cef(source=library)--*/ class CefAuthCallback : public virtual CefBase { public: /// // Continue the authentication request. /// /*--cef(capi_name=cont)--*/ virtual void Continue(const CefString& username, const CefString& password) =0; /// // Cancel the authentication request. /// /*--cef()--*/ virtual void Cancel() =0; }; #endif // CEF_INCLUDE_CEF_AUTH_CALLBACK_H_ cefpython-49.0/src/include/cef_base.h000066400000000000000000000146361334103266300175720ustar00rootroot00000000000000// 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. #ifndef CEF_INCLUDE_CEF_BASE_H_ #define CEF_INCLUDE_CEF_BASE_H_ #pragma once #include "include/base/cef_atomic_ref_count.h" #include "include/base/cef_build.h" #include "include/base/cef_macros.h" // Bring in common C++ type definitions used by CEF consumers. #include "include/internal/cef_ptr.h" #include "include/internal/cef_types_wrappers.h" #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: /// // Called to increment the reference count for the object. Should be called // for every new copy of a pointer to a given object. /// virtual void AddRef() const =0; /// // Called to decrement the reference count for the object. Returns true if // the reference count is 0, in which case the object should self-delete. /// virtual bool Release() const =0; /// // Returns true if the reference count is 1. /// virtual bool HasOneRef() const =0; protected: virtual ~CefBase() {} }; /// // Class that implements atomic reference counting. /// class CefRefCount { public: CefRefCount() : ref_count_(0) {} /// // Increment the reference count. /// void AddRef() const { base::AtomicRefCountInc(&ref_count_); } /// // Decrement the reference count. Returns true if the reference count is 0. /// bool Release() const { return !base::AtomicRefCountDec(&ref_count_); } /// // Returns true if the reference count is 1. /// bool HasOneRef() const { return base::AtomicRefCountIsOne(&ref_count_); } private: mutable base::AtomicRefCount ref_count_; DISALLOW_COPY_AND_ASSIGN(CefRefCount); }; /// // Macro that provides a reference counting implementation for classes extending // CefBase. /// #define IMPLEMENT_REFCOUNTING(ClassName) \ public: \ void AddRef() const OVERRIDE { \ ref_count_.AddRef(); \ } \ bool Release() const OVERRIDE { \ if (ref_count_.Release()) { \ delete static_cast(this); \ return true; \ } \ return false; \ } \ bool HasOneRef() const OVERRIDE { \ return ref_count_.HasOneRef(); \ } \ private: \ CefRefCount ref_count_; /// // 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. // // THIS MACRO IS DEPRECATED. Use an explicit base::Lock member variable and // base::AutoLock instead. For example: // // #include "include/base/cef_lock.h" // // // Class declaration. // class MyClass : public CefBase { // public: // MyClass() : value_(0) {} // // Method that may be called on multiple threads. // void IncrementValue(); // private: // // Value that may be accessed on multiple theads. // int value_; // // Lock used to protect access to |value_|. // base::Lock lock_; // IMPLEMENT_REFCOUNTING(MyClass); // }; // // // Class implementation. // void MyClass::IncrementValue() { // // Acquire the lock for the scope of this method. // base::AutoLock lock_scope(lock_); // // |value_| can now be modified safely. // value_++; // } /// #define IMPLEMENT_LOCKING(ClassName) \ public: \ class AutoLock { \ public: \ explicit AutoLock(ClassName* base) : base_(base) { base_->Lock(); } \ ~AutoLock() { base_->Unlock(); } \ private: \ ClassName* base_; \ DISALLOW_COPY_AND_ASSIGN(AutoLock); \ }; \ void Lock() { lock_.Acquire(); } \ void Unlock() { lock_.Release(); } \ private: \ base::Lock lock_; #endif // CEF_INCLUDE_CEF_BASE_H_ cefpython-49.0/src/include/cef_browser.h000066400000000000000000000572171334103266300203450ustar00rootroot00000000000000// 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_BROWSER_H_ #define CEF_INCLUDE_CEF_BROWSER_H_ #pragma once #include "include/cef_base.h" #include "include/cef_drag_data.h" #include "include/cef_frame.h" #include "include/cef_navigation_entry.h" #include "include/cef_process_message.h" #include "include/cef_request_context.h" #include class CefBrowserHost; class CefClient; /// // Class used to represent a browser window. When used in the browser process // the methods of this class may be called on any thread unless otherwise // indicated in the comments. When used in the render process the methods of // this class may only be called on the main thread. /// /*--cef(source=library)--*/ class CefBrowser : public virtual CefBase { public: /// // Returns the browser host object. This method can only be called in the // browser process. /// /*--cef()--*/ virtual CefRefPtr GetHost() =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; /// // Returns true if the browser is currently loading. /// /*--cef()--*/ virtual bool IsLoading() =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; /// // Returns the globally unique identifier for this browser. /// /*--cef()--*/ virtual int GetIdentifier() =0; /// // Returns true if this object is pointing to the same handle as |that| // object. /// /*--cef()--*/ virtual bool IsSame(CefRefPtr that) =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 main (top-level) frame for the browser window. /// /*--cef()--*/ virtual CefRefPtr GetMainFrame() =0; /// // Returns the focused frame for the browser window. /// /*--cef()--*/ virtual CefRefPtr GetFocusedFrame() =0; /// // Returns the frame with the specified identifier, or NULL if not found. /// /*--cef(capi_name=get_frame_byident)--*/ virtual CefRefPtr GetFrame(int64 identifier) =0; /// // Returns the frame with the specified name, or NULL if not found. /// /*--cef(optional_param=name)--*/ virtual CefRefPtr GetFrame(const CefString& name) =0; /// // Returns the number of frames that currently exist. /// /*--cef()--*/ virtual size_t GetFrameCount() =0; /// // Returns the identifiers of all existing frames. /// /*--cef(count_func=identifiers:GetFrameCount)--*/ virtual void GetFrameIdentifiers(std::vector& identifiers) =0; /// // Returns the names of all existing frames. /// /*--cef()--*/ virtual void GetFrameNames(std::vector& names) =0; /// // Send a message to the specified |target_process|. Returns true if the // message was sent successfully. /// /*--cef()--*/ virtual bool SendProcessMessage(CefProcessId target_process, CefRefPtr message) =0; }; /// // Callback interface for CefBrowserHost::RunFileDialog. The methods of this // class will be called on the browser process UI thread. /// /*--cef(source=client)--*/ class CefRunFileDialogCallback : public virtual CefBase { public: /// // Called asynchronously after the file dialog is dismissed. // |selected_accept_filter| is the 0-based index of the value selected from // the accept filters array passed to CefBrowserHost::RunFileDialog. // |file_paths| will be a single value or a list of values depending on the // dialog mode. If the selection was cancelled |file_paths| will be empty. /// /*--cef(index_param=selected_accept_filter,optional_param=file_paths)--*/ virtual void OnFileDialogDismissed( int selected_accept_filter, const std::vector& file_paths) =0; }; /// // Callback interface for CefBrowserHost::GetNavigationEntries. The methods of // this class will be called on the browser process UI thread. /// /*--cef(source=client)--*/ class CefNavigationEntryVisitor : public virtual CefBase { public: /// // Method that will be executed. Do not keep a reference to |entry| outside of // this callback. Return true to continue visiting entries or false to stop. // |current| is true if this entry is the currently loaded navigation entry. // |index| is the 0-based index of this entry and |total| is the total number // of entries. /// /*--cef()--*/ virtual bool Visit(CefRefPtr entry, bool current, int index, int total) =0; }; /// // Callback interface for CefBrowserHost::PrintToPDF. The methods of this class // will be called on the browser process UI thread. /// /*--cef(source=client)--*/ class CefPdfPrintCallback : public virtual CefBase { public: /// // Method that will be executed when the PDF printing has completed. |path| // is the output path. |ok| will be true if the printing completed // successfully or false otherwise. /// /*--cef()--*/ virtual void OnPdfPrintFinished(const CefString& path, bool ok) =0; }; /// // Class used to represent the browser process aspects of a browser window. The // methods of this class can only be called in the browser process. They may be // called on any thread in that process unless otherwise indicated in the // comments. /// /*--cef(source=library)--*/ class CefBrowserHost : public virtual CefBase { public: typedef cef_drag_operations_mask_t DragOperationsMask; typedef cef_file_dialog_mode_t FileDialogMode; 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. If |request_context| is empty the // global request context will be used. This method can be called on any // browser process thread and will not block. /// /*--cef(optional_param=client,optional_param=url, optional_param=request_context)--*/ static bool CreateBrowser(const CefWindowInfo& windowInfo, CefRefPtr client, const CefString& url, const CefBrowserSettings& settings, CefRefPtr request_context); /// // Create a new browser window using the window parameters specified by // |windowInfo|. If |request_context| is empty the global request context // will be used. This method can only be called on the browser process UI // thread. /// /*--cef(optional_param=client,optional_param=url, optional_param=request_context)--*/ static CefRefPtr CreateBrowserSync( const CefWindowInfo& windowInfo, CefRefPtr client, const CefString& url, const CefBrowserSettings& settings, CefRefPtr request_context); /// // Returns the hosted browser object. /// /*--cef()--*/ virtual CefRefPtr GetBrowser() =0; /// // Request that the browser close. The JavaScript 'onbeforeunload' event will // be fired. If |force_close| is false the event handler, if any, will be // allowed to prompt the user and the user can optionally cancel the close. // If |force_close| is true the prompt will not be displayed and the close // will proceed. Results in a call to CefLifeSpanHandler::DoClose() if the // event handler allows the close or if |force_close| is true. See // CefLifeSpanHandler::DoClose() documentation for additional usage // information. /// /*--cef()--*/ virtual void CloseBrowser(bool force_close) =0; /// // Set whether the browser is focused. /// /*--cef()--*/ virtual void SetFocus(bool focus) =0; /// // Set whether the window containing the browser is visible // (minimized/unminimized, app hidden/unhidden, etc). Only used on Mac OS X. /// /*--cef()--*/ virtual void SetWindowVisibility(bool visible) =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 the client for this browser. /// /*--cef()--*/ virtual CefRefPtr GetClient() =0; /// // Returns the request context for this browser. /// /*--cef()--*/ virtual CefRefPtr GetRequestContext() =0; /// // Get the current zoom level. The default zoom level is 0.0. This method can // only be called on the UI thread. /// /*--cef()--*/ virtual double GetZoomLevel() =0; /// // Change the zoom level to the specified value. Specify 0.0 to reset the // zoom level. If called on the UI thread the change will be applied // immediately. Otherwise, the change will be applied asynchronously on the // UI thread. /// /*--cef()--*/ virtual void SetZoomLevel(double zoomLevel) =0; /// // Call to run a file chooser dialog. Only a single file chooser dialog may be // pending at any given time. |mode| represents the type of dialog to display. // |title| to the title to be used for the dialog and may be empty to show the // default title ("Open" or "Save" depending on the mode). |default_file_path| // is the path with optional directory and/or file name component that will be // initially selected in the dialog. |accept_filters| are used to restrict the // selectable file types and may any combination of (a) valid lower-cased MIME // types (e.g. "text/*" or "image/*"), (b) individual file extensions (e.g. // ".txt" or ".png"), or (c) combined description and file extension delimited // using "|" and ";" (e.g. "Image Types|.png;.gif;.jpg"). // |selected_accept_filter| is the 0-based index of the filter that will be // selected by default. |callback| will be executed after the dialog is // dismissed or immediately if another dialog is already pending. The dialog // will be initiated asynchronously on the UI thread. /// /*--cef(optional_param=title,optional_param=default_file_path, optional_param=accept_filters,index_param=selected_accept_filter)--*/ virtual void RunFileDialog(FileDialogMode mode, const CefString& title, const CefString& default_file_path, const std::vector& accept_filters, int selected_accept_filter, CefRefPtr callback) =0; /// // Download the file at |url| using CefDownloadHandler. /// /*--cef()--*/ virtual void StartDownload(const CefString& url) =0; /// // Print the current browser contents. /// /*--cef()--*/ virtual void Print() =0; /// // Print the current browser contents to the PDF file specified by |path| and // execute |callback| on completion. The caller is responsible for deleting // |path| when done. For PDF printing to work on Linux you must implement the // CefPrintHandler::GetPdfPaperSize method. /// /*--cef(optional_param=callback)--*/ virtual void PrintToPDF(const CefString& path, const CefPdfPrintSettings& settings, CefRefPtr callback) =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. The CefFindHandler instance, if any, returned via // CefClient::GetFindHandler will be called to report find results. /// /*--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; /// // Open developer tools in its own window. If |inspect_element_at| is non- // empty the element at the specified (x,y) location will be inspected. /// /*--cef(optional_param=inspect_element_at)--*/ virtual void ShowDevTools(const CefWindowInfo& windowInfo, CefRefPtr client, const CefBrowserSettings& settings, const CefPoint& inspect_element_at) =0; /// // Explicitly close the developer tools window if one exists for this browser // instance. /// /*--cef()--*/ virtual void CloseDevTools() =0; /// // Retrieve a snapshot of current navigation entries as values sent to the // specified visitor. If |current_only| is true only the current navigation // entry will be sent, otherwise all navigation entries will be sent. /// /*--cef()--*/ virtual void GetNavigationEntries( CefRefPtr visitor, bool current_only) =0; /// // Set whether mouse cursor change is disabled. /// /*--cef()--*/ virtual void SetMouseCursorChangeDisabled(bool disabled) =0; /// // Returns true if mouse cursor change is disabled. /// /*--cef()--*/ virtual bool IsMouseCursorChangeDisabled() =0; /// // If a misspelled word is currently selected in an editable node calling // this method will replace it with the specified |word|. /// /*--cef()--*/ virtual void ReplaceMisspelling(const CefString& word) =0; /// // Add the specified |word| to the spelling dictionary. /// /*--cef()--*/ virtual void AddWordToDictionary(const CefString& word) =0; /// // Returns true if window rendering is disabled. /// /*--cef()--*/ virtual bool IsWindowRenderingDisabled() =0; /// // Notify the browser that the widget has been resized. The browser will first // call CefRenderHandler::GetViewRect to get the new size and then call // CefRenderHandler::OnPaint asynchronously with the updated regions. This // method is only used when window rendering is disabled. /// /*--cef()--*/ virtual void WasResized() =0; /// // Notify the browser that it has been hidden or shown. Layouting and // CefRenderHandler::OnPaint notification will stop when the browser is // hidden. This method is only used when window rendering is disabled. /// /*--cef()--*/ virtual void WasHidden(bool hidden) =0; /// // Send a notification to the browser that the screen info has changed. The // browser will then call CefRenderHandler::GetScreenInfo to update the // screen information with the new values. This simulates moving the webview // window from one display to another, or changing the properties of the // current display. This method is only used when window rendering is // disabled. /// /*--cef()--*/ virtual void NotifyScreenInfoChanged() =0; /// // Invalidate the view. The browser will call CefRenderHandler::OnPaint // asynchronously. This method is only used when window rendering is // disabled. /// /*--cef()--*/ virtual void Invalidate(PaintElementType type) =0; /// // Send a key event to the browser. /// /*--cef()--*/ virtual void SendKeyEvent(const CefKeyEvent& event) =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(const CefMouseEvent& event, 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(const CefMouseEvent& event, 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. The |deltaX| and |deltaY| // values represent the movement delta in the X and Y directions respectively. // In order to scroll inside select popups with window rendering disabled // CefRenderHandler::GetScreenPoint should be implemented properly. /// /*--cef()--*/ virtual void SendMouseWheelEvent(const CefMouseEvent& event, int deltaX, int deltaY) =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; /// // Notify the browser that the window hosting it is about to be moved or // resized. This method is only used on Windows and Linux. /// /*--cef()--*/ virtual void NotifyMoveOrResizeStarted() =0; /// // Returns the maximum rate in frames per second (fps) that CefRenderHandler:: // OnPaint will be called for a windowless browser. The actual fps may be // lower if the browser cannot generate frames at the requested rate. The // minimum value is 1 and the maximum value is 60 (default 30). This method // can only be called on the UI thread. /// /*--cef()--*/ virtual int GetWindowlessFrameRate() =0; /// // Set the maximum rate in frames per second (fps) that CefRenderHandler:: // OnPaint will be called for a windowless browser. The actual fps may be // lower if the browser cannot generate frames at the requested rate. The // minimum value is 1 and the maximum value is 60 (default 30). Can also be // set at browser creation via CefBrowserSettings.windowless_frame_rate. /// /*--cef()--*/ virtual void SetWindowlessFrameRate(int frame_rate) =0; /// // Get the NSTextInputContext implementation for enabling IME on Mac when // window rendering is disabled. /// /*--cef(default_retval=NULL)--*/ virtual CefTextInputContext GetNSTextInputContext() =0; /// // Handles a keyDown event prior to passing it through the NSTextInputClient // machinery. /// /*--cef()--*/ virtual void HandleKeyEventBeforeTextInputClient(CefEventHandle keyEvent) =0; /// // Performs any additional actions after NSTextInputClient handles the event. /// /*--cef()--*/ virtual void HandleKeyEventAfterTextInputClient(CefEventHandle keyEvent) =0; /// // Call this method when the user drags the mouse into the web view (before // calling DragTargetDragOver/DragTargetLeave/DragTargetDrop). // |drag_data| should not contain file contents as this type of data is not // allowed to be dragged into the web view. File contents can be removed using // CefDragData::ResetFileContents (for example, if |drag_data| comes from // CefRenderHandler::StartDragging). // This method is only used when window rendering is disabled. /// /*--cef()--*/ virtual void DragTargetDragEnter(CefRefPtr drag_data, const CefMouseEvent& event, DragOperationsMask allowed_ops) =0; /// // Call this method each time the mouse is moved across the web view during // a drag operation (after calling DragTargetDragEnter and before calling // DragTargetDragLeave/DragTargetDrop). // This method is only used when window rendering is disabled. /// /*--cef()--*/ virtual void DragTargetDragOver(const CefMouseEvent& event, DragOperationsMask allowed_ops) =0; /// // Call this method when the user drags the mouse out of the web view (after // calling DragTargetDragEnter). // This method is only used when window rendering is disabled. /// /*--cef()--*/ virtual void DragTargetDragLeave() =0; /// // Call this method when the user completes the drag operation by dropping // the object onto the web view (after calling DragTargetDragEnter). // The object being dropped is |drag_data|, given as an argument to // the previous DragTargetDragEnter call. // This method is only used when window rendering is disabled. /// /*--cef()--*/ virtual void DragTargetDrop(const CefMouseEvent& event) =0; /// // Call this method when the drag operation started by a // CefRenderHandler::StartDragging call has ended either in a drop or // by being cancelled. |x| and |y| are mouse coordinates relative to the // upper-left corner of the view. If the web view is both the drag source // and the drag target then all DragTarget* methods should be called before // DragSource* mthods. // This method is only used when window rendering is disabled. /// /*--cef()--*/ virtual void DragSourceEndedAt(int x, int y, DragOperationsMask op) =0; /// // Call this method when the drag operation started by a // CefRenderHandler::StartDragging call has completed. This method may be // called immediately without first calling DragSourceEndedAt to cancel a // drag operation. If the web view is both the drag source and the drag // target then all DragTarget* methods should be called before DragSource* // mthods. // This method is only used when window rendering is disabled. /// /*--cef()--*/ virtual void DragSourceSystemDragEnded() =0; }; #endif // CEF_INCLUDE_CEF_BROWSER_H_ cefpython-49.0/src/include/cef_browser_process_handler.h000066400000000000000000000073701334103266300235730ustar00rootroot00000000000000// 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_BROWSER_PROCESS_HANDLER_H_ #define CEF_INCLUDE_CEF_BROWSER_PROCESS_HANDLER_H_ #pragma once #include "include/cef_base.h" #include "include/cef_command_line.h" #include "include/cef_print_handler.h" #include "include/cef_values.h" /// // Class used to implement browser process callbacks. The methods of this class // will be called on the browser process main thread unless otherwise indicated. /// /*--cef(source=client)--*/ class CefBrowserProcessHandler : public virtual CefBase { public: /// // Called on the browser process UI thread immediately after the CEF context // has been initialized. /// /*--cef()--*/ virtual void OnContextInitialized() {} /// // Called before a child process is launched. Will be called on the browser // process UI thread when launching a render process and on the browser // process IO thread when launching a GPU or plugin process. Provides an // opportunity to modify the child process command line. Do not keep a // reference to |command_line| outside of this method. /// /*--cef()--*/ virtual void OnBeforeChildProcessLaunch( CefRefPtr command_line) {} /// // Called on the browser process IO thread after the main thread has been // created for a new render process. Provides an opportunity to specify extra // information that will be passed to // CefRenderProcessHandler::OnRenderThreadCreated() in the render process. Do // not keep a reference to |extra_info| outside of this method. /// /*--cef()--*/ virtual void OnRenderProcessThreadCreated( CefRefPtr extra_info) {} /// // Return the handler for printing on Linux. If a print handler is not // provided then printing will not be supported on the Linux platform. /// /*--cef()--*/ virtual CefRefPtr GetPrintHandler() { return NULL; } }; #endif // CEF_INCLUDE_CEF_BROWSER_PROCESS_HANDLER_H_ cefpython-49.0/src/include/cef_callback.h000066400000000000000000000051551334103266300204100ustar00rootroot00000000000000// 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_CALLBACK_H_ #define CEF_INCLUDE_CEF_CALLBACK_H_ #pragma once #include "include/cef_base.h" /// // Generic callback interface used for asynchronous continuation. /// /*--cef(source=library)--*/ class CefCallback : public virtual CefBase { public: /// // Continue processing. /// /*--cef(capi_name=cont)--*/ virtual void Continue() =0; /// // Cancel processing. /// /*--cef()--*/ virtual void Cancel() =0; }; /// // Generic callback interface used for asynchronous completion. /// /*--cef(source=client)--*/ class CefCompletionCallback : public virtual CefBase { public: /// // Method that will be called once the task is complete. /// /*--cef()--*/ virtual void OnComplete() =0; }; #endif // CEF_INCLUDE_CEF_CALLBACK_H_ cefpython-49.0/src/include/cef_client.h000066400000000000000000000134331334103266300201300ustar00rootroot00000000000000// 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_CLIENT_H_ #define CEF_INCLUDE_CEF_CLIENT_H_ #pragma once #include "include/cef_base.h" #include "include/cef_context_menu_handler.h" #include "include/cef_dialog_handler.h" #include "include/cef_display_handler.h" #include "include/cef_download_handler.h" #include "include/cef_drag_handler.h" #include "include/cef_find_handler.h" #include "include/cef_focus_handler.h" #include "include/cef_geolocation_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_process_message.h" #include "include/cef_render_handler.h" #include "include/cef_request_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 context menus. If no handler is provided the default // implementation will be used. /// /*--cef()--*/ virtual CefRefPtr GetContextMenuHandler() { return NULL; } /// // Return the handler for dialogs. If no handler is provided the default // implementation will be used. /// /*--cef()--*/ virtual CefRefPtr GetDialogHandler() { return NULL; } /// // Return the handler for browser display state events. /// /*--cef()--*/ virtual CefRefPtr GetDisplayHandler() { return NULL; } /// // Return the handler for download events. If no handler is returned downloads // will not be allowed. /// /*--cef()--*/ virtual CefRefPtr GetDownloadHandler() { return NULL; } /// // Return the handler for drag events. /// /*--cef()--*/ virtual CefRefPtr GetDragHandler() { return NULL; } /// // Return the handler for find result events. /// /*--cef()--*/ virtual CefRefPtr GetFindHandler() { return NULL; } /// // Return the handler for focus events. /// /*--cef()--*/ virtual CefRefPtr GetFocusHandler() { return NULL; } /// // Return the handler for geolocation permissions requests. If no handler is // provided geolocation access will be denied by default. /// /*--cef()--*/ virtual CefRefPtr GetGeolocationHandler() { return NULL; } /// // Return the handler for JavaScript dialogs. If no handler is provided the // default implementation will be used. /// /*--cef()--*/ virtual CefRefPtr GetJSDialogHandler() { return NULL; } /// // Return the handler for keyboard events. /// /*--cef()--*/ virtual CefRefPtr GetKeyboardHandler() { return NULL; } /// // 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 off-screen rendering events. /// /*--cef()--*/ virtual CefRefPtr GetRenderHandler() { return NULL; } /// // Return the handler for browser request events. /// /*--cef()--*/ virtual CefRefPtr GetRequestHandler() { return NULL; } /// // Called when a new message is received from a different process. Return true // if the message was handled or false otherwise. Do not keep a reference to // or attempt to access the message outside of this callback. /// /*--cef()--*/ virtual bool OnProcessMessageReceived(CefRefPtr browser, CefProcessId source_process, CefRefPtr message) { return false; } }; #endif // CEF_INCLUDE_CEF_CLIENT_H_ cefpython-49.0/src/include/cef_command_line.h000066400000000000000000000152101334103266300212720ustar00rootroot00000000000000// 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_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(api_hash_check)--*/ static CefRefPtr CreateCommandLine(); /// // Returns the singleton global CefCommandLine object. The returned object // will be read-only. /// /*--cef(api_hash_check)--*/ static CefRefPtr GetGlobalCommandLine(); /// // Returns true if this object is valid. Do not call any other methods if this // function returns false. /// /*--cef()--*/ virtual bool IsValid() =0; /// // Returns true if the values of this object are read-only. Some APIs may // expose read-only objects. /// /*--cef()--*/ virtual bool IsReadOnly() =0; /// // Returns a writable copy of this object. /// /*--cef()--*/ virtual CefRefPtr Copy() =0; /// // 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; /// // Reset the command-line switches and arguments but leave the program // component unchanged. /// /*--cef()--*/ virtual void Reset() =0; /// // Retrieve the original command line string as a vector of strings. // The argv array: { program, [(--|-|/)switch[=value]]*, [--], [argument]* } /// /*--cef()--*/ virtual void GetArgv(std::vector& argv) =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; /// // Insert a command before the current command. // Common for debuggers, like "valgrind" or "gdb --args". /// /*--cef()--*/ virtual void PrependWrapper(const CefString& wrapper) =0; }; #endif // CEF_INCLUDE_CEF_COMMAND_LINE_H_ cefpython-49.0/src/include/cef_context_menu_handler.h000066400000000000000000000231131334103266300230530ustar00rootroot00000000000000// 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_CONTEXT_MENU_HANDLER_H_ #define CEF_INCLUDE_CEF_CONTEXT_MENU_HANDLER_H_ #pragma once #include "include/cef_base.h" #include "include/cef_browser.h" #include "include/cef_frame.h" #include "include/cef_menu_model.h" class CefContextMenuParams; /// // Callback interface used for continuation of custom context menu display. /// /*--cef(source=library)--*/ class CefRunContextMenuCallback : public virtual CefBase { public: typedef cef_event_flags_t EventFlags; /// // Complete context menu display by selecting the specified |command_id| and // |event_flags|. /// /*--cef(capi_name=cont)--*/ virtual void Continue(int command_id, EventFlags event_flags) =0; /// // Cancel context menu display. /// /*--cef()--*/ virtual void Cancel() =0; }; /// // Implement this interface to handle context menu events. The methods of this // class will be called on the UI thread. /// /*--cef(source=client)--*/ class CefContextMenuHandler : public virtual CefBase { public: typedef cef_event_flags_t EventFlags; /// // Called before a context menu is displayed. |params| provides information // about the context menu state. |model| initially contains the default // context menu. The |model| can be cleared to show no context menu or // modified to show a custom menu. Do not keep references to |params| or // |model| outside of this callback. /// /*--cef()--*/ virtual void OnBeforeContextMenu(CefRefPtr browser, CefRefPtr frame, CefRefPtr params, CefRefPtr model) {} /// // Called to allow custom display of the context menu. |params| provides // information about the context menu state. |model| contains the context menu // model resulting from OnBeforeContextMenu. For custom display return true // and execute |callback| either synchronously or asynchronously with the // selected command ID. For default display return false. Do not keep // references to |params| or |model| outside of this callback. /// /*--cef()--*/ virtual bool RunContextMenu(CefRefPtr browser, CefRefPtr frame, CefRefPtr params, CefRefPtr model, CefRefPtr callback) { return false; } /// // Called to execute a command selected from the context menu. Return true if // the command was handled or false for the default implementation. See // cef_menu_id_t for the command ids that have default implementations. All // user-defined command ids should be between MENU_ID_USER_FIRST and // MENU_ID_USER_LAST. |params| will have the same values as what was passed to // OnBeforeContextMenu(). Do not keep a reference to |params| outside of this // callback. /// /*--cef()--*/ virtual bool OnContextMenuCommand(CefRefPtr browser, CefRefPtr frame, CefRefPtr params, int command_id, EventFlags event_flags) { return false; } /// // Called when the context menu is dismissed irregardless of whether the menu // was empty or a command was selected. /// /*--cef()--*/ virtual void OnContextMenuDismissed(CefRefPtr browser, CefRefPtr frame) {} }; /// // Provides information about the context menu state. The ethods of this class // can only be accessed on browser process the UI thread. /// /*--cef(source=library)--*/ class CefContextMenuParams : public virtual CefBase { public: typedef cef_context_menu_type_flags_t TypeFlags; typedef cef_context_menu_media_type_t MediaType; typedef cef_context_menu_media_state_flags_t MediaStateFlags; typedef cef_context_menu_edit_state_flags_t EditStateFlags; /// // Returns the X coordinate of the mouse where the context menu was invoked. // Coords are relative to the associated RenderView's origin. /// /*--cef()--*/ virtual int GetXCoord() =0; /// // Returns the Y coordinate of the mouse where the context menu was invoked. // Coords are relative to the associated RenderView's origin. /// /*--cef()--*/ virtual int GetYCoord() =0; /// // Returns flags representing the type of node that the context menu was // invoked on. /// /*--cef(default_retval=CM_TYPEFLAG_NONE)--*/ virtual TypeFlags GetTypeFlags() =0; /// // Returns the URL of the link, if any, that encloses the node that the // context menu was invoked on. /// /*--cef()--*/ virtual CefString GetLinkUrl() =0; /// // Returns the link URL, if any, to be used ONLY for "copy link address". We // don't validate this field in the frontend process. /// /*--cef()--*/ virtual CefString GetUnfilteredLinkUrl() =0; /// // Returns the source URL, if any, for the element that the context menu was // invoked on. Example of elements with source URLs are img, audio, and video. /// /*--cef()--*/ virtual CefString GetSourceUrl() =0; /// // Returns true if the context menu was invoked on an image which has // non-empty contents. /// /*--cef()--*/ virtual bool HasImageContents() =0; /// // Returns the URL of the top level page that the context menu was invoked on. /// /*--cef()--*/ virtual CefString GetPageUrl() =0; /// // Returns the URL of the subframe that the context menu was invoked on. /// /*--cef()--*/ virtual CefString GetFrameUrl() =0; /// // Returns the character encoding of the subframe that the context menu was // invoked on. /// /*--cef()--*/ virtual CefString GetFrameCharset() =0; /// // Returns the type of context node that the context menu was invoked on. /// /*--cef(default_retval=CM_MEDIATYPE_NONE)--*/ virtual MediaType GetMediaType() =0; /// // Returns flags representing the actions supported by the media element, if // any, that the context menu was invoked on. /// /*--cef(default_retval=CM_MEDIAFLAG_NONE)--*/ virtual MediaStateFlags GetMediaStateFlags() =0; /// // Returns the text of the selection, if any, that the context menu was // invoked on. /// /*--cef()--*/ virtual CefString GetSelectionText() =0; /// // Returns the text of the misspelled word, if any, that the context menu was // invoked on. /// /*--cef()--*/ virtual CefString GetMisspelledWord() =0; /// // Returns true if suggestions exist, false otherwise. Fills in |suggestions| // from the spell check service for the misspelled word if there is one. /// /*--cef()--*/ virtual bool GetDictionarySuggestions(std::vector& suggestions) =0; /// // Returns true if the context menu was invoked on an editable node. /// /*--cef()--*/ virtual bool IsEditable() =0; /// // Returns true if the context menu was invoked on an editable node where // spell-check is enabled. /// /*--cef()--*/ virtual bool IsSpellCheckEnabled() =0; /// // Returns flags representing the actions supported by the editable node, if // any, that the context menu was invoked on. /// /*--cef(default_retval=CM_EDITFLAG_NONE)--*/ virtual EditStateFlags GetEditStateFlags() =0; /// // Returns true if the context menu contains items specified by the renderer // process (for example, plugin placeholder or pepper plugin menu items). /// /*--cef()--*/ virtual bool IsCustomMenu() =0; /// // Returns true if the context menu was invoked from a pepper plugin. /// /*--cef()--*/ virtual bool IsPepperMenu() =0; }; #endif // CEF_INCLUDE_CEF_CONTEXT_MENU_HANDLER_H_ cefpython-49.0/src/include/cef_cookie.h000066400000000000000000000224271334103266300201260ustar00rootroot00000000000000// 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 "include/cef_callback.h" #include class CefCookieVisitor; class CefSetCookieCallback; class CefDeleteCookiesCallback; /// // Class used for managing cookies. The methods of this class may be called on // any thread unless otherwise indicated. /// /*--cef(source=library,no_debugct_check)--*/ 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. If |callback| // is non-NULL it will be executed asnychronously on the IO thread after the // manager's storage has been initialized. Using this method is equivalent to // calling CefRequestContext::GetGlobalContext()->GetDefaultCookieManager(). /// /*--cef(optional_param=callback)--*/ static CefRefPtr GetGlobalManager( CefRefPtr callback); /// // Creates a new cookie manager. If |path| is empty data will be stored in // memory only. Otherwise, data will be stored at the specified |path|. To // persist session cookies (cookies without an expiry date or validity // interval) set |persist_session_cookies| to true. Session cookies are // generally intended to be transient and most Web browsers do not persist // them. If |callback| is non-NULL it will be executed asnychronously on the // IO thread after the manager's storage has been initialized. /// /*--cef(optional_param=path,optional_param=callback)--*/ static CefRefPtr CreateManager( const CefString& path, bool persist_session_cookies, CefRefPtr callback); /// // Set the schemes supported by this manager. The default schemes ("http", // "https", "ws" and "wss") will always be supported. If |callback| is non- // NULL it will be executed asnychronously on the IO thread after the change // has been applied. Must be called before any cookies are accessed. /// /*--cef(optional_param=callback)--*/ virtual void SetSupportedSchemes( const std::vector& schemes, CefRefPtr callback) =0; /// // Visit all cookies on the IO thread. 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 on the IO thread. 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 fail without setting the cookie if // such characters are found. If |callback| is non-NULL it will be executed // asnychronously on the IO thread after the cookie has been set. Returns // false if an invalid URL is specified or if cookies cannot be accessed. /// /*--cef(optional_param=callback)--*/ virtual bool SetCookie(const CefString& url, const CefCookie& cookie, CefRefPtr callback) =0; /// // Delete all cookies that match the specified parameters. If both |url| and // |cookie_name| values 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. If |callback| is // non-NULL it will be executed asnychronously on the IO thread after the // cookies have been deleted. Returns false if a non-empty invalid URL is // specified or if cookies cannot be accessed. Cookies can alternately be // deleted using the Visit*Cookies() methods. /// /*--cef(optional_param=url,optional_param=cookie_name, optional_param=callback)--*/ virtual bool DeleteCookies(const CefString& url, const CefString& cookie_name, CefRefPtr callback) =0; /// // Sets the directory path that will be used for storing cookie data. If // |path| is empty data will be stored in memory only. Otherwise, data will be // stored at the specified |path|. To persist session cookies (cookies without // an expiry date or validity interval) set |persist_session_cookies| to true. // Session cookies are generally intended to be transient and most Web // browsers do not persist them. If |callback| is non-NULL it will be executed // asnychronously on the IO thread after the manager's storage has been // initialized. Returns false if cookies cannot be accessed. /// /*--cef(optional_param=path,optional_param=callback)--*/ virtual bool SetStoragePath(const CefString& path, bool persist_session_cookies, CefRefPtr callback) =0; /// // Flush the backing store (if any) to disk. If |callback| is non-NULL it will // be executed asnychronously on the IO thread after the flush is complete. // Returns false if cookies cannot be accessed. /// /*--cef(optional_param=callback)--*/ virtual bool FlushStore(CefRefPtr callback) =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; }; /// // Interface to implement to be notified of asynchronous completion via // CefCookieManager::SetCookie(). /// /*--cef(source=client)--*/ class CefSetCookieCallback : public virtual CefBase { public: /// // Method that will be called upon completion. |success| will be true if the // cookie was set successfully. /// /*--cef()--*/ virtual void OnComplete(bool success) =0; }; /// // Interface to implement to be notified of asynchronous completion via // CefCookieManager::DeleteCookies(). /// /*--cef(source=client)--*/ class CefDeleteCookiesCallback : public virtual CefBase { public: /// // Method that will be called upon completion. |num_deleted| will be the // number of cookies that were deleted or -1 if unknown. /// /*--cef()--*/ virtual void OnComplete(int num_deleted) =0; }; #endif // CEF_INCLUDE_CEF_COOKIE_H_ cefpython-49.0/src/include/cef_dialog_handler.h000066400000000000000000000113221334103266300216010ustar00rootroot00000000000000// 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_DIALOG_HANDLER_H_ #define CEF_INCLUDE_CEF_DIALOG_HANDLER_H_ #pragma once #include "include/cef_base.h" #include "include/cef_browser.h" /// // Callback interface for asynchronous continuation of file dialog requests. /// /*--cef(source=library)--*/ class CefFileDialogCallback : public virtual CefBase { public: /// // Continue the file selection. |selected_accept_filter| should be the 0-based // index of the value selected from the accept filters array passed to // CefDialogHandler::OnFileDialog. |file_paths| should be a single value or a // list of values depending on the dialog mode. An empty |file_paths| value is // treated the same as calling Cancel(). /// /*--cef(capi_name=cont,index_param=selected_accept_filter, optional_param=file_paths)--*/ virtual void Continue(int selected_accept_filter, const std::vector& file_paths) =0; /// // Cancel the file selection. /// /*--cef()--*/ virtual void Cancel() =0; }; /// // Implement this interface to handle dialog events. The methods of this class // will be called on the browser process UI thread. /// /*--cef(source=client)--*/ class CefDialogHandler : public virtual CefBase { public: typedef cef_file_dialog_mode_t FileDialogMode; /// // Called to run a file chooser dialog. |mode| represents the type of dialog // to display. |title| to the title to be used for the dialog and may be empty // to show the default title ("Open" or "Save" depending on the mode). // |default_file_path| is the path with optional directory and/or file name // component that should be initially selected in the dialog. |accept_filters| // are used to restrict the selectable file types and may any combination of // (a) valid lower-cased MIME types (e.g. "text/*" or "image/*"), // (b) individual file extensions (e.g. ".txt" or ".png"), or (c) combined // description and file extension delimited using "|" and ";" (e.g. // "Image Types|.png;.gif;.jpg"). |selected_accept_filter| is the 0-based // index of the filter that should be selected by default. To display a custom // dialog return true and execute |callback| either inline or at a later time. // To display the default dialog return false. /// /*--cef(optional_param=title,optional_param=default_file_path, optional_param=accept_filters,index_param=selected_accept_filter)--*/ virtual bool OnFileDialog(CefRefPtr browser, FileDialogMode mode, const CefString& title, const CefString& default_file_path, const std::vector& accept_filters, int selected_accept_filter, CefRefPtr callback) { return false; } }; #endif // CEF_INCLUDE_CEF_DIALOG_HANDLER_H_ cefpython-49.0/src/include/cef_display_handler.h000066400000000000000000000114401334103266300220100ustar00rootroot00000000000000// 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_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: /// // Called when a frame's address has changed. /// /*--cef()--*/ virtual void OnAddressChange(CefRefPtr browser, CefRefPtr frame, const CefString& url) {} /// // Called when the page title changes. /// /*--cef(optional_param=title)--*/ virtual void OnTitleChange(CefRefPtr browser, const CefString& title) {} /// // Called when the page icon changes. /// /*--cef(optional_param=icon_urls)--*/ virtual void OnFaviconURLChange(CefRefPtr browser, const std::vector& icon_urls) {} /// // Called when web content in the page has toggled fullscreen mode. If // |fullscreen| is true the content will automatically be sized to fill the // browser content area. If |fullscreen| is false the content will // automatically return to its original size and position. The client is // responsible for resizing the browser if desired. /// /*--cef()--*/ virtual void OnFullscreenModeChange(CefRefPtr browser, bool fullscreen) {} /// // 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. // When window rendering is disabled the application is responsible for // drawing tooltips and the return value is ignored. /// /*--cef(optional_param=text)--*/ virtual bool OnTooltip(CefRefPtr browser, CefString& text) { return false; } /// // Called when the browser receives a status message. |value| contains the // text that will be displayed in the status message. /// /*--cef(optional_param=value)--*/ virtual void OnStatusMessage(CefRefPtr browser, const CefString& value) {} /// // 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_ cefpython-49.0/src/include/cef_dom.h000066400000000000000000000203661334103266300174340ustar00rootroot00000000000000// 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_DOM_H_ #define CEF_INCLUDE_CEF_DOM_H_ #pragma once #include "include/cef_base.h" #include class CefDOMDocument; class CefDOMNode; /// // Interface to implement for visiting the DOM. The methods of this class will // be called on the render process main 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 render process main thread 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 offset within the start node. /// /*--cef()--*/ virtual int GetSelectionStartOffset() =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 render process main 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 an editable node. /// /*--cef()--*/ virtual bool IsEditable() =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; // 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; }; #endif // CEF_INCLUDE_CEF_DOM_H_ cefpython-49.0/src/include/cef_download_handler.h000066400000000000000000000106331334103266300221550ustar00rootroot00000000000000// 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_DOWNLOAD_HANDLER_H_ #define CEF_INCLUDE_CEF_DOWNLOAD_HANDLER_H_ #pragma once #include "include/cef_base.h" #include "include/cef_browser.h" #include "include/cef_download_item.h" /// // Callback interface used to asynchronously continue a download. /// /*--cef(source=library)--*/ class CefBeforeDownloadCallback : public virtual CefBase { public: /// // Call to continue the download. Set |download_path| to the full file path // for the download including the file name or leave blank to use the // suggested name and the default temp directory. Set |show_dialog| to true // if you do wish to show the default "Save As" dialog. /// /*--cef(capi_name=cont,optional_param=download_path)--*/ virtual void Continue(const CefString& download_path, bool show_dialog) =0; }; /// // Callback interface used to asynchronously cancel a download. /// /*--cef(source=library)--*/ class CefDownloadItemCallback : public virtual CefBase { public: /// // Call to cancel the download. /// /*--cef()--*/ virtual void Cancel() =0; /// // Call to pause the download. /// /*--cef()--*/ virtual void Pause() =0; /// // Call to resume the download. /// /*--cef()--*/ virtual void Resume() =0; }; /// // Class used to handle file downloads. The methods of this class will called // on the browser process UI thread. /// /*--cef(source=client)--*/ class CefDownloadHandler : public virtual CefBase { public: /// // Called before a download begins. |suggested_name| is the suggested name for // the download file. By default the download will be canceled. Execute // |callback| either asynchronously or in this method to continue the download // if desired. Do not keep a reference to |download_item| outside of this // method. /// /*--cef()--*/ virtual void OnBeforeDownload( CefRefPtr browser, CefRefPtr download_item, const CefString& suggested_name, CefRefPtr callback) =0; /// // Called when a download's status or progress information has been updated. // This may be called multiple times before and after OnBeforeDownload(). // Execute |callback| either asynchronously or in this method to cancel the // download if desired. Do not keep a reference to |download_item| outside of // this method. /// /*--cef()--*/ virtual void OnDownloadUpdated( CefRefPtr browser, CefRefPtr download_item, CefRefPtr callback) {} }; #endif // CEF_INCLUDE_CEF_DOWNLOAD_HANDLER_H_ cefpython-49.0/src/include/cef_download_item.h000066400000000000000000000101631334103266300214740ustar00rootroot00000000000000// 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_DOWNLOAD_ITEM_H_ #define CEF_INCLUDE_CEF_DOWNLOAD_ITEM_H_ #pragma once #include "include/cef_base.h" /// // Class used to represent a download item. /// /*--cef(source=library)--*/ class CefDownloadItem : public virtual CefBase { public: /// // Returns true if this object is valid. Do not call any other methods if this // function returns false. /// /*--cef()--*/ virtual bool IsValid() =0; /// // Returns true if the download is in progress. /// /*--cef()--*/ virtual bool IsInProgress() =0; /// // Returns true if the download is complete. /// /*--cef()--*/ virtual bool IsComplete() =0; /// // Returns true if the download has been canceled or interrupted. /// /*--cef()--*/ virtual bool IsCanceled() =0; /// // Returns a simple speed estimate in bytes/s. /// /*--cef()--*/ virtual int64 GetCurrentSpeed() =0; /// // Returns the rough percent complete or -1 if the receive total size is // unknown. /// /*--cef()--*/ virtual int GetPercentComplete() =0; /// // Returns the total number of bytes. /// /*--cef()--*/ virtual int64 GetTotalBytes() =0; /// // Returns the number of received bytes. /// /*--cef()--*/ virtual int64 GetReceivedBytes() =0; /// // Returns the time that the download started. /// /*--cef()--*/ virtual CefTime GetStartTime() =0; /// // Returns the time that the download ended. /// /*--cef()--*/ virtual CefTime GetEndTime() =0; /// // Returns the full path to the downloaded or downloading file. /// /*--cef()--*/ virtual CefString GetFullPath() =0; /// // Returns the unique identifier for this download. /// /*--cef()--*/ virtual uint32 GetId() =0; /// // Returns the URL. /// /*--cef()--*/ virtual CefString GetURL() =0; /// // Returns the original URL before any redirections. /// /*--cef()--*/ virtual CefString GetOriginalUrl() =0; /// // Returns the suggested file name. /// /*--cef()--*/ virtual CefString GetSuggestedFileName() =0; /// // Returns the content disposition. /// /*--cef()--*/ virtual CefString GetContentDisposition() =0; /// // Returns the mime type. /// /*--cef()--*/ virtual CefString GetMimeType() =0; }; #endif // CEF_INCLUDE_CEF_DOWNLOAD_ITEM_H_ cefpython-49.0/src/include/cef_drag_data.h000066400000000000000000000134521334103266300205610ustar00rootroot00000000000000// Copyright (c) 2013 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 "include/cef_stream.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: /// // Create a new CefDragData object. /// /*--cef()--*/ static CefRefPtr Create(); /// // Returns a copy of the current object. /// /*--cef()--*/ virtual CefRefPtr Clone() =0; /// // Returns true if this object is read-only. /// /*--cef()--*/ virtual bool IsReadOnly() =0; /// // 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 name of the file being dragged out of the browser window. /// /*--cef()--*/ virtual CefString GetFileName() =0; /// // Write the contents of the file being dragged out of the web view into // |writer|. Returns the number of bytes sent to |writer|. If |writer| is // NULL this method will return the size of the file contents in bytes. // Call GetFileName() to get a suggested name for the file. /// /*--cef(optional_param=writer)--*/ virtual size_t GetFileContents(CefRefPtr writer) =0; /// // Retrieve the list of file names that are being dragged into the browser // window. /// /*--cef()--*/ virtual bool GetFileNames(std::vector& names) =0; /// // Set the link URL that is being dragged. /// /*--cef(optional_param=url)--*/ virtual void SetLinkURL(const CefString& url) =0; /// // Set the title associated with the link being dragged. /// /*--cef(optional_param=title)--*/ virtual void SetLinkTitle(const CefString& title) =0; /// // Set the metadata associated with the link being dragged. /// /*--cef(optional_param=data)--*/ virtual void SetLinkMetadata(const CefString& data) =0; /// // Set the plain text fragment that is being dragged. /// /*--cef(optional_param=text)--*/ virtual void SetFragmentText(const CefString& text) =0; /// // Set the text/html fragment that is being dragged. /// /*--cef(optional_param=html)--*/ virtual void SetFragmentHtml(const CefString& html) =0; /// // Set the base URL that the fragment came from. /// /*--cef(optional_param=base_url)--*/ virtual void SetFragmentBaseURL(const CefString& base_url) =0; /// // Reset the file contents. You should do this before calling // CefBrowserHost::DragTargetDragEnter as the web view does not allow us to // drag in this kind of data. /// /*--cef()--*/ virtual void ResetFileContents() =0; /// // Add a file that is being dragged into the webview. /// /*--cef(optional_param=display_name)--*/ virtual void AddFile(const CefString& path, const CefString& display_name) =0; }; #endif // CEF_INCLUDE_CEF_DRAG_DATA_H_ cefpython-49.0/src/include/cef_drag_handler.h000066400000000000000000000065221334103266300212650ustar00rootroot00000000000000// Copyright (c) 2013 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 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; } /// // Called whenever draggable regions for the browser window change. These can // be specified using the '-webkit-app-region: drag/no-drag' CSS-property. If // draggable regions are never defined in a document this method will also // never be called. If the last draggable region is removed from a document // this method will be called with an empty vector. /// /*--cef()--*/ virtual void OnDraggableRegionsChanged( CefRefPtr browser, const std::vector& regions) {} }; #endif // CEF_INCLUDE_CEF_DRAG_HANDLER_H_ cefpython-49.0/src/include/cef_find_handler.h000066400000000000000000000057701334103266300212740ustar00rootroot00000000000000// Copyright (c) 2015 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 CefBrowserHost::Find(). // |identifer| is the identifier passed to 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_ cefpython-49.0/src/include/cef_focus_handler.h000066400000000000000000000064411334103266300214670ustar00rootroot00000000000000// 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_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_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 the browser component has received focus. /// /*--cef()--*/ virtual void OnGotFocus(CefRefPtr browser) {} }; #endif // CEF_INCLUDE_CEF_FOCUS_HANDLER_H_ cefpython-49.0/src/include/cef_frame.h000066400000000000000000000150711334103266300177440ustar00rootroot00000000000000// 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_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" #include "include/cef_string_visitor.h" class CefBrowser; class CefV8Context; /// // Class used to represent a frame in the browser window. When used in the // browser process the methods of this class may be called on any thread unless // otherwise indicated in the comments. When used in the render process the // methods of this class may only be called on the main thread. /// /*--cef(source=library)--*/ class CefFrame : public virtual CefBase { public: /// // True if this object is currently attached to a valid frame. /// /*--cef()--*/ virtual bool IsValid() =0; /// // 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; /// // Save this frame's HTML source to a temporary file and open it in the // default text viewing application. This method can only be called from the // browser process. /// /*--cef()--*/ virtual void ViewSource() =0; /// // Retrieve this frame's HTML source as a string sent to the specified // visitor. /// /*--cef()--*/ virtual void GetSource(CefRefPtr visitor) =0; /// // Retrieve this frame's display text as a string sent to the specified // visitor. /// /*--cef()--*/ virtual void GetText(CefRefPtr visitor) =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 specified dummy |url|. |url| // should have a standard scheme (for example, http scheme) or behaviors like // link clicks and web security restrictions may not behave as expected. /// /*--cef()--*/ virtual void LoadString(const CefString& string_val, 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=script_url)--*/ virtual void ExecuteJavaScript(const CefString& code, const CefString& script_url, int start_line) =0; /// // Returns true if this is the main (top-level) frame. /// /*--cef()--*/ virtual bool IsMain() =0; /// // Returns true if this is the focused frame. /// /*--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 or < 0 if the // underlying frame does not yet exist. /// /*--cef()--*/ virtual int64 GetIdentifier() =0; /// // Returns the parent of this frame or NULL if this is the main (top-level) // frame. /// /*--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; /// // Get the V8 context associated with the frame. This method can only be // called from the render process. /// /*--cef()--*/ virtual CefRefPtr GetV8Context() =0; /// // Visit the DOM document. This method can only be called from the render // process. /// /*--cef()--*/ virtual void VisitDOM(CefRefPtr visitor) =0; }; #endif // CEF_INCLUDE_CEF_FRAME_H_ cefpython-49.0/src/include/cef_geolocation.h000066400000000000000000000053441334103266300211570ustar00rootroot00000000000000// 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_GEOLOCATION_H_ #define CEF_INCLUDE_CEF_GEOLOCATION_H_ #pragma once #include "include/cef_base.h" /// // Implement this interface to receive geolocation updates. The methods of this // class will be called on the browser process UI thread. /// /*--cef(source=client)--*/ class CefGetGeolocationCallback : public virtual CefBase { public: /// // Called with the 'best available' location information or, if the location // update failed, with error information. /// /*--cef()--*/ virtual void OnLocationUpdate(const CefGeoposition& position) =0; }; /// // Request a one-time geolocation update. This function bypasses any user // permission checks so should only be used by code that is allowed to access // location information. /// /*--cef()--*/ bool CefGetGeolocation(CefRefPtr callback); #endif // CEF_INCLUDE_CEF_GEOLOCATION_H_ cefpython-49.0/src/include/cef_geolocation_handler.h000066400000000000000000000070431334103266300226520ustar00rootroot00000000000000// 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_GEOLOCATION_HANDLER_H_ #define CEF_INCLUDE_CEF_GEOLOCATION_HANDLER_H_ #pragma once #include "include/cef_base.h" #include "include/cef_browser.h" /// // Callback interface used for asynchronous continuation of geolocation // permission requests. /// /*--cef(source=library)--*/ class CefGeolocationCallback : public virtual CefBase { public: /// // Call to allow or deny geolocation access. /// /*--cef(capi_name=cont)--*/ virtual void Continue(bool allow) =0; }; /// // Implement this interface to handle events related to geolocation permission // requests. The methods of this class will be called on the browser process UI // thread. /// /*--cef(source=client)--*/ class CefGeolocationHandler : public virtual CefBase { public: /// // Called when a page requests permission to access geolocation information. // |requesting_url| is the URL requesting permission and |request_id| is the // unique ID for the permission request. Return true and call // CefGeolocationCallback::Continue() either in this method or at a later // time to continue or cancel the request. Return false to cancel the request // immediately. /// /*--cef()--*/ virtual bool OnRequestGeolocationPermission( CefRefPtr browser, const CefString& requesting_url, int request_id, CefRefPtr callback) { return false; } /// // Called when a geolocation access request is canceled. |request_id| is the // unique ID for the permission request. /// /*--cef()--*/ virtual void OnCancelGeolocationPermission( CefRefPtr browser, int request_id) { } }; #endif // CEF_INCLUDE_CEF_GEOLOCATION_HANDLER_H_ cefpython-49.0/src/include/cef_jsdialog_handler.h000066400000000000000000000133131334103266300221400ustar00rootroot00000000000000// 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_JSDIALOG_HANDLER_H_ #define CEF_INCLUDE_CEF_JSDIALOG_HANDLER_H_ #pragma once #include "include/cef_base.h" #include "include/cef_browser.h" /// // Callback interface used for asynchronous continuation of JavaScript dialog // requests. /// /*--cef(source=library)--*/ class CefJSDialogCallback : public virtual CefBase { public: /// // Continue the JS dialog request. Set |success| to true if the OK button was // pressed. The |user_input| value should be specified for prompt dialogs. /// /*--cef(capi_name=cont,optional_param=user_input)--*/ virtual void Continue(bool success, const CefString& user_input) =0; }; /// // 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: typedef cef_jsdialog_type_t JSDialogType; /// // Called to run a JavaScript dialog. If |origin_url| and |accept_lang| are // non-empty they can be passed to the CefFormatUrlForSecurityDisplay function // to retrieve a secure and user-friendly display string. The // |default_prompt_text| value will be specified for prompt dialogs only. Set // |suppress_message| to true and return false to suppress the message // (suppressing messages is preferable to immediately executing the callback // as this is used to detect presumably malicious behavior like spamming alert // messages in onbeforeunload). Set |suppress_message| to false and return // false to use the default implementation (the default implementation will // show one modal dialog at a time and suppress any additional dialog requests // until the displayed dialog is dismissed). Return true if the application // will use a custom dialog or if the callback has been executed immediately. // Custom dialogs may be either modal or modeless. If a custom dialog is used // the application must execute |callback| once the custom dialog is // dismissed. /// /*--cef(optional_param=origin_url,optional_param=accept_lang, optional_param=message_text,optional_param=default_prompt_text)--*/ virtual bool OnJSDialog(CefRefPtr browser, const CefString& origin_url, const CefString& accept_lang, JSDialogType dialog_type, const CefString& message_text, const CefString& default_prompt_text, CefRefPtr callback, bool& suppress_message) { return false; } /// // Called to run a dialog asking the user if they want to leave a page. Return // false to use the default dialog implementation. Return true if the // application will use a custom dialog or if the callback has been executed // immediately. Custom dialogs may be either modal or modeless. If a custom // dialog is used the application must execute |callback| once the custom // dialog is dismissed. /// /*--cef(optional_param=message_text)--*/ virtual bool OnBeforeUnloadDialog(CefRefPtr browser, const CefString& message_text, bool is_reload, CefRefPtr callback) { return false; } /// // Called to cancel any pending dialogs and reset any saved dialog state. Will // be called due to events like page navigation irregardless of whether any // dialogs are currently pending. /// /*--cef()--*/ virtual void OnResetDialogState(CefRefPtr browser) {} /// // Called when the default implementation dialog is closed. /// /*--cef()--*/ virtual void OnDialogClosed(CefRefPtr browser) {} }; #endif // CEF_INCLUDE_CEF_JSDIALOG_HANDLER_H_ cefpython-49.0/src/include/cef_keyboard_handler.h000066400000000000000000000066241334103266300221530ustar00rootroot00000000000000// 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_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: /// // Called before a keyboard event is sent to the renderer. |event| contains // information about the keyboard event. |os_event| is the operating system // event message, if any. Return true if the event was handled or false // otherwise. If the event will be handled in OnKeyEvent() as a keyboard // shortcut set |is_keyboard_shortcut| to true and return false. /// /*--cef()--*/ virtual bool OnPreKeyEvent(CefRefPtr browser, const CefKeyEvent& event, CefEventHandle os_event, bool* is_keyboard_shortcut) { return false; } /// // Called after the renderer and JavaScript in the page has had a chance to // handle the event. |event| contains information about the keyboard event. // |os_event| is the operating system event message, if any. Return true if // the keyboard event was handled or false otherwise. /// /*--cef()--*/ virtual bool OnKeyEvent(CefRefPtr browser, const CefKeyEvent& event, CefEventHandle os_event) { return false; } }; #endif // CEF_INCLUDE_CEF_KEYBOARD_HANDLER_H_ cefpython-49.0/src/include/cef_life_span_handler.h000066400000000000000000000210321334103266300223010ustar00rootroot00000000000000// 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_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 unless otherwise // indicated. /// /*--cef(source=client)--*/ class CefLifeSpanHandler : public virtual CefBase { public: typedef cef_window_open_disposition_t WindowOpenDisposition; /// // Called on the IO thread before a new popup browser is created. The // |browser| and |frame| values represent the source of the popup request. The // |target_url| and |target_frame_name| values indicate where the popup // browser should navigate and may be empty if not specified with the request. // The |target_disposition| value indicates where the user intended to open // the popup (e.g. current tab, new tab, etc). The |user_gesture| value will // be true if the popup was opened via explicit user gesture (e.g. clicking a // link) or false if the popup opened automatically (e.g. via the // DomContentLoaded event). The |popupFeatures| structure contains additional // information about the requested popup window. To allow creation of the // popup browser optionally modify |windowInfo|, |client|, |settings| and // |no_javascript_access| and return false. To cancel creation of the popup // browser return true. The |client| and |settings| values will default to the // source browser's values. If the |no_javascript_access| value is set to // false the new browser will not be scriptable and may not be hosted in the // same renderer process as the source browser. /// /*--cef(optional_param=target_url,optional_param=target_frame_name)--*/ virtual bool OnBeforePopup(CefRefPtr browser, CefRefPtr frame, const CefString& target_url, const CefString& target_frame_name, WindowOpenDisposition target_disposition, bool user_gesture, const CefPopupFeatures& popupFeatures, CefWindowInfo& windowInfo, CefRefPtr& client, CefBrowserSettings& settings, bool* no_javascript_access) { return false; } /// // Called after a new browser 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 browser has recieved a request to close. This may result // directly from a call to CefBrowserHost::CloseBrowser() or indirectly if the // browser is a top-level OS window created by CEF and the user attempts to // close the window. This method will be called after the JavaScript // 'onunload' event has been fired. It will not be called for browsers after // the associated OS window has been destroyed (for those browsers it is no // longer possible to cancel the close). // // If CEF created an OS window for the browser returning false will send an OS // close notification to the browser window's top-level owner (e.g. WM_CLOSE // on Windows, performClose: on OS-X and "delete_event" on Linux). If no OS // window exists (window rendering disabled) returning false will cause the // browser object to be destroyed immediately. Return true if the browser is // parented to another window and that other window needs to receive close // notification via some non-standard technique. // // If an application provides its own top-level window it should handle OS // close notifications by calling CefBrowserHost::CloseBrowser(false) instead // of immediately closing (see the example below). This gives CEF an // opportunity to process the 'onbeforeunload' event and optionally cancel the // close before DoClose() is called. // // The CefLifeSpanHandler::OnBeforeClose() method will be called immediately // before the browser object is destroyed. The application should only exit // after OnBeforeClose() has been called for all existing browsers. // // If the browser represents a modal window and a custom modal loop // implementation was provided in CefLifeSpanHandler::RunModal() this callback // should be used to restore the opener window to a usable state. // // By way of example consider what should happen during window close when the // browser is parented to an application-provided top-level OS window. // 1. User clicks the window close button which sends an OS close // notification (e.g. WM_CLOSE on Windows, performClose: on OS-X and // "delete_event" on Linux). // 2. Application's top-level window receives the close notification and: // A. Calls CefBrowserHost::CloseBrowser(false). // B. Cancels the window close. // 3. JavaScript 'onbeforeunload' handler executes and shows the close // confirmation dialog (which can be overridden via // CefJSDialogHandler::OnBeforeUnloadDialog()). // 4. User approves the close. // 5. JavaScript 'onunload' handler executes. // 6. Application's DoClose() handler is called. Application will: // A. Set a flag to indicate that the next close attempt will be allowed. // B. Return false. // 7. CEF sends an OS close notification. // 8. Application's top-level window receives the OS close notification and // allows the window to close based on the flag from #6B. // 9. Browser OS window is destroyed. // 10. Application's CefLifeSpanHandler::OnBeforeClose() handler is called and // the browser object is destroyed. // 11. Application exits by calling CefQuitMessageLoop() if no other browsers // exist. /// /*--cef()--*/ virtual bool DoClose(CefRefPtr browser) { return false; } /// // Called just before a browser is destroyed. Release all references to the // browser object and do not attempt to execute any methods on the browser // object after this callback returns. 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. See DoClose() documentation for // additional usage information. /// /*--cef()--*/ virtual void OnBeforeClose(CefRefPtr browser) {} }; #endif // CEF_INCLUDE_CEF_LIFE_SPAN_HANDLER_H_ cefpython-49.0/src/include/cef_load_handler.h000066400000000000000000000116521334103266300212670ustar00rootroot00000000000000// 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_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 browser process UI thread or // render process main thread (TID_RENDERER). /// /*--cef(source=client)--*/ class CefLoadHandler : public virtual CefBase { public: typedef cef_errorcode_t ErrorCode; /// // Called when the loading state has changed. This callback will be executed // twice -- once when loading is initiated either programmatically or by user // action, and once when loading is terminated due to completion, cancellation // of failure. It will be called before any calls to OnLoadStart and after all // calls to OnLoadError and/or OnLoadEnd. /// /*--cef()--*/ virtual void OnLoadingStateChange(CefRefPtr browser, bool isLoading, bool canGoBack, bool canGoForward) {} /// // 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 // will always be called for all frames irrespective of whether the request // completes successfully. For notification of overall browser load status use // OnLoadingStateChange instead. /// /*--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. For notification of overall browser load status use // OnLoadingStateChange instead. /// /*--cef()--*/ virtual void OnLoadEnd(CefRefPtr browser, CefRefPtr frame, int httpStatusCode) {} /// // Called when the resource load for a navigation fails or is canceled. // |errorCode| is the error code number, |errorText| is the error text and // |failedUrl| is the URL that failed to load. See net\base\net_error_list.h // for complete descriptions of the error codes. /// /*--cef(optional_param=errorText)--*/ virtual void OnLoadError(CefRefPtr browser, CefRefPtr frame, ErrorCode errorCode, const CefString& errorText, const CefString& failedUrl) {} }; #endif // CEF_INCLUDE_CEF_LOAD_HANDLER_H_ cefpython-49.0/src/include/cef_menu_model.h000066400000000000000000000277041334103266300210040ustar00rootroot00000000000000// 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_MENU_MODEL_H_ #define CEF_INCLUDE_CEF_MENU_MODEL_H_ #pragma once #include "include/cef_base.h" /// // Supports creation and modification of menus. See cef_menu_id_t for the // command ids that have default implementations. All user-defined command ids // should be between MENU_ID_USER_FIRST and MENU_ID_USER_LAST. The methods of // this class can only be accessed on the browser process the UI thread. /// /*--cef(source=library)--*/ class CefMenuModel : public virtual CefBase { public: typedef cef_menu_item_type_t MenuItemType; /// // Clears the menu. Returns true on success. /// /*--cef()--*/ virtual bool Clear() =0; /// // Returns the number of items in this menu. /// /*--cef()--*/ virtual int GetCount() =0; /// // Add a separator to the menu. Returns true on success. /// /*--cef()--*/ virtual bool AddSeparator() =0; /// // Add an item to the menu. Returns true on success. /// /*--cef()--*/ virtual bool AddItem(int command_id, const CefString& label) =0; /// // Add a check item to the menu. Returns true on success. /// /*--cef()--*/ virtual bool AddCheckItem(int command_id, const CefString& label) =0; /// // Add a radio item to the menu. Only a single item with the specified // |group_id| can be checked at a time. Returns true on success. /// /*--cef()--*/ virtual bool AddRadioItem(int command_id, const CefString& label, int group_id) =0; /// // Add a sub-menu to the menu. The new sub-menu is returned. /// /*--cef()--*/ virtual CefRefPtr AddSubMenu(int command_id, const CefString& label) =0; /// // Insert a separator in the menu at the specified |index|. Returns true on // success. /// /*--cef()--*/ virtual bool InsertSeparatorAt(int index) =0; /// // Insert an item in the menu at the specified |index|. Returns true on // success. /// /*--cef()--*/ virtual bool InsertItemAt(int index, int command_id, const CefString& label) =0; /// // Insert a check item in the menu at the specified |index|. Returns true on // success. /// /*--cef()--*/ virtual bool InsertCheckItemAt(int index, int command_id, const CefString& label) =0; /// // Insert a radio item in the menu at the specified |index|. Only a single // item with the specified |group_id| can be checked at a time. Returns true // on success. /// /*--cef()--*/ virtual bool InsertRadioItemAt(int index, int command_id, const CefString& label, int group_id) =0; /// // Insert a sub-menu in the menu at the specified |index|. The new sub-menu // is returned. /// /*--cef()--*/ virtual CefRefPtr InsertSubMenuAt(int index, int command_id, const CefString& label) =0; /// // Removes the item with the specified |command_id|. Returns true on success. /// /*--cef()--*/ virtual bool Remove(int command_id) =0; /// // Removes the item at the specified |index|. Returns true on success. /// /*--cef()--*/ virtual bool RemoveAt(int index) =0; /// // Returns the index associated with the specified |command_id| or -1 if not // found due to the command id not existing in the menu. /// /*--cef()--*/ virtual int GetIndexOf(int command_id) =0; /// // Returns the command id at the specified |index| or -1 if not found due to // invalid range or the index being a separator. /// /*--cef()--*/ virtual int GetCommandIdAt(int index) =0; /// // Sets the command id at the specified |index|. Returns true on success. /// /*--cef()--*/ virtual bool SetCommandIdAt(int index, int command_id) =0; /// // Returns the label for the specified |command_id| or empty if not found. /// /*--cef()--*/ virtual CefString GetLabel(int command_id) =0; /// // Returns the label at the specified |index| or empty if not found due to // invalid range or the index being a separator. /// /*--cef()--*/ virtual CefString GetLabelAt(int index) =0; /// // Sets the label for the specified |command_id|. Returns true on success. /// /*--cef()--*/ virtual bool SetLabel(int command_id, const CefString& label) =0; /// // Set the label at the specified |index|. Returns true on success. /// /*--cef()--*/ virtual bool SetLabelAt(int index, const CefString& label) =0; /// // Returns the item type for the specified |command_id|. /// /*--cef(default_retval=MENUITEMTYPE_NONE)--*/ virtual MenuItemType GetType(int command_id) =0; /// // Returns the item type at the specified |index|. /// /*--cef(default_retval=MENUITEMTYPE_NONE)--*/ virtual MenuItemType GetTypeAt(int index) =0; /// // Returns the group id for the specified |command_id| or -1 if invalid. /// /*--cef()--*/ virtual int GetGroupId(int command_id) =0; /// // Returns the group id at the specified |index| or -1 if invalid. /// /*--cef()--*/ virtual int GetGroupIdAt(int index) =0; /// // Sets the group id for the specified |command_id|. Returns true on success. /// /*--cef()--*/ virtual bool SetGroupId(int command_id, int group_id) =0; /// // Sets the group id at the specified |index|. Returns true on success. /// /*--cef()--*/ virtual bool SetGroupIdAt(int index, int group_id) =0; /// // Returns the submenu for the specified |command_id| or empty if invalid. /// /*--cef()--*/ virtual CefRefPtr GetSubMenu(int command_id) =0; /// // Returns the submenu at the specified |index| or empty if invalid. /// /*--cef()--*/ virtual CefRefPtr GetSubMenuAt(int index) =0; /// // Returns true if the specified |command_id| is visible. /// /*--cef()--*/ virtual bool IsVisible(int command_id) =0; /// // Returns true if the specified |index| is visible. /// /*--cef()--*/ virtual bool IsVisibleAt(int index) =0; /// // Change the visibility of the specified |command_id|. Returns true on // success. /// /*--cef()--*/ virtual bool SetVisible(int command_id, bool visible) =0; /// // Change the visibility at the specified |index|. Returns true on success. /// /*--cef()--*/ virtual bool SetVisibleAt(int index, bool visible) =0; /// // Returns true if the specified |command_id| is enabled. /// /*--cef()--*/ virtual bool IsEnabled(int command_id) =0; /// // Returns true if the specified |index| is enabled. /// /*--cef()--*/ virtual bool IsEnabledAt(int index) =0; /// // Change the enabled status of the specified |command_id|. Returns true on // success. /// /*--cef()--*/ virtual bool SetEnabled(int command_id, bool enabled) =0; /// // Change the enabled status at the specified |index|. Returns true on // success. /// /*--cef()--*/ virtual bool SetEnabledAt(int index, bool enabled) =0; /// // Returns true if the specified |command_id| is checked. Only applies to // check and radio items. /// /*--cef()--*/ virtual bool IsChecked(int command_id) =0; /// // Returns true if the specified |index| is checked. Only applies to check // and radio items. /// /*--cef()--*/ virtual bool IsCheckedAt(int index) =0; /// // Check the specified |command_id|. Only applies to check and radio items. // Returns true on success. /// /*--cef()--*/ virtual bool SetChecked(int command_id, bool checked) =0; /// // Check the specified |index|. Only applies to check and radio items. Returns // true on success. /// /*--cef()--*/ virtual bool SetCheckedAt(int index, bool checked) =0; /// // Returns true if the specified |command_id| has a keyboard accelerator // assigned. /// /*--cef()--*/ virtual bool HasAccelerator(int command_id) =0; /// // Returns true if the specified |index| has a keyboard accelerator assigned. /// /*--cef()--*/ virtual bool HasAcceleratorAt(int index) =0; /// // Set the keyboard accelerator for the specified |command_id|. |key_code| can // be any virtual key or character value. Returns true on success. /// /*--cef()--*/ virtual bool SetAccelerator(int command_id, int key_code, bool shift_pressed, bool ctrl_pressed, bool alt_pressed) =0; /// // Set the keyboard accelerator at the specified |index|. |key_code| can be // any virtual key or character value. Returns true on success. /// /*--cef()--*/ virtual bool SetAcceleratorAt(int index, int key_code, bool shift_pressed, bool ctrl_pressed, bool alt_pressed) =0; /// // Remove the keyboard accelerator for the specified |command_id|. Returns // true on success. /// /*--cef()--*/ virtual bool RemoveAccelerator(int command_id) =0; /// // Remove the keyboard accelerator at the specified |index|. Returns true on // success. /// /*--cef()--*/ virtual bool RemoveAcceleratorAt(int index) =0; /// // Retrieves the keyboard accelerator for the specified |command_id|. Returns // true on success. /// /*--cef()--*/ virtual bool GetAccelerator(int command_id, int& key_code, bool& shift_pressed, bool& ctrl_pressed, bool& alt_pressed) =0; /// // Retrieves the keyboard accelerator for the specified |index|. Returns true // on success. /// /*--cef()--*/ virtual bool GetAcceleratorAt(int index, int& key_code, bool& shift_pressed, bool& ctrl_pressed, bool& alt_pressed) =0; }; #endif // CEF_INCLUDE_CEF_MENU_MODEL_H_ cefpython-49.0/src/include/cef_navigation_entry.h000066400000000000000000000075351334103266300222400ustar00rootroot00000000000000// Copyright (c) 2014 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_NAVIGATION_ENTRY_H_ #define CEF_INCLUDE_CEF_NAVIGATION_ENTRY_H_ #pragma once #include "include/cef_base.h" /// // Class used to represent an entry in navigation history. /// /*--cef(source=library)--*/ class CefNavigationEntry : public virtual CefBase { public: typedef cef_transition_type_t TransitionType; /// // Returns true if this object is valid. Do not call any other methods if this // function returns false. /// /*--cef()--*/ virtual bool IsValid() =0; /// // Returns the actual URL of the page. For some pages this may be data: URL or // similar. Use GetDisplayURL() to return a display-friendly version. /// /*--cef()--*/ virtual CefString GetURL() =0; /// // Returns a display-friendly version of the URL. /// /*--cef()--*/ virtual CefString GetDisplayURL() =0; /// // Returns the original URL that was entered by the user before any redirects. /// /*--cef()--*/ virtual CefString GetOriginalURL() =0; /// // Returns the title set by the page. This value may be empty. /// /*--cef()--*/ virtual CefString GetTitle() =0; /// // Returns the transition type which indicates what the user did to move to // this page from the previous page. /// /*--cef(default_retval=TT_EXPLICIT)--*/ virtual TransitionType GetTransitionType() =0; /// // Returns true if this navigation includes post data. /// /*--cef()--*/ virtual bool HasPostData() =0; /// // Returns the time for the last known successful navigation completion. A // navigation may be completed more than once if the page is reloaded. May be // 0 if the navigation has not yet completed. /// /*--cef()--*/ virtual CefTime GetCompletionTime() =0; /// // Returns the HTTP status code for the last known successful navigation // response. May be 0 if the response has not yet been received or if the // navigation has not yet completed. /// /*--cef()--*/ virtual int GetHttpStatusCode() =0; }; #endif // CEF_INCLUDE_CEF_NAVIGATION_ENTRY_H_ cefpython-49.0/src/include/cef_origin_whitelist.h000066400000000000000000000117301334103266300222330ustar00rootroot00000000000000// 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_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 |target_domain| is non-empty and |allow_target_subdomains| if false only // exact domain matches will be allowed. If |target_domain| contains a top- // level domain component (like "example.com") and |allow_target_subdomains| is // true sub-domain matches will be allowed. If |target_domain| is empty and // |allow_target_subdomains| if true all domains and IP addresses will be // allowed. // // 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(optional_param=target_domain)--*/ 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(optional_param=target_domain)--*/ 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_ cefpython-49.0/src/include/cef_parser.h000066400000000000000000000155651334103266300201560ustar00rootroot00000000000000// 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_PARSER_H_ #define CEF_INCLUDE_CEF_PARSER_H_ #pragma once #include #include "include/cef_base.h" #include "include/cef_values.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); /// // This is a convenience function for formatting a URL in a concise and human- // friendly way to help users make security-related decisions (or in other // circumstances when people need to distinguish sites, origins, or otherwise- // simplified URLs from each other). Internationalized domain names (IDN) may be // presented in Unicode if |languages| accepts the Unicode representation. The // returned value will (a) omit the path for standard schemes, excepting file // and filesystem, and (b) omit the port if it is the default for the scheme. Do // not use this for URLs which will be parsed or sent to other applications. /// /*--cef(optional_param=languages)--*/ CefString CefFormatUrlForSecurityDisplay(const CefString& origin_url, const CefString& languages); /// // Returns the mime type for the specified file extension or an empty string if // unknown. /// /*--cef()--*/ CefString CefGetMimeType(const CefString& extension); /// // Get the extensions associated with the given mime type. This should be passed // in lower case. There could be multiple extensions for a given mime type, like // "html,htm" for "text/html", or "txt,text,html,..." for "text/*". Any existing // elements in the provided vector will not be erased. /// /*--cef()--*/ void CefGetExtensionsForMimeType(const CefString& mime_type, std::vector& extensions); /// // Encodes |data| as a base64 string. /// /*--cef()--*/ CefString CefBase64Encode(const void* data, size_t data_size); /// // Decodes the base64 encoded string |data|. The returned value will be NULL if // the decoding fails. /// /*--cef()--*/ CefRefPtr CefBase64Decode(const CefString& data); /// // Escapes characters in |text| which are unsuitable for use as a query // parameter value. Everything except alphanumerics and -_.!~*'() will be // converted to "%XX". If |use_plus| is true spaces will change to "+". The // result is basically the same as encodeURIComponent in Javacript. /// /*--cef()--*/ CefString CefURIEncode(const CefString& text, bool use_plus); /// // Unescapes |text| and returns the result. Unescaping consists of looking for // the exact pattern "%XX" where each X is a hex digit and converting to the // character with the numerical value of those digits (e.g. "i%20=%203%3b" // unescapes to "i = 3;"). If |convert_to_utf8| is true this function will // attempt to interpret the initial decoded result as UTF-8. If the result is // convertable into UTF-8 it will be returned as converted. Otherwise the // initial decoded result will be returned. The |unescape_rule| parameter // supports further customization the decoding process. /// /*--cef()--*/ CefString CefURIDecode(const CefString& text, bool convert_to_utf8, cef_uri_unescape_rule_t unescape_rule); /// // Parses |string| which represents a CSS color value. If |strict| is true // strict parsing rules will be applied. Returns true on success or false on // error. If parsing succeeds |color| will be set to the color value otherwise // |color| will remain unchanged. /// /*--cef()--*/ bool CefParseCSSColor(const CefString& string, bool strict, cef_color_t& color); /// // Parses the specified |json_string| and returns a dictionary or list // representation. If JSON parsing fails this method returns NULL. /// /*--cef()--*/ CefRefPtr CefParseJSON(const CefString& json_string, cef_json_parser_options_t options); /// // Parses the specified |json_string| and returns a dictionary or list // representation. If JSON parsing fails this method returns NULL and populates // |error_code_out| and |error_msg_out| with an error code and a formatted error // message respectively. /// /*--cef()--*/ CefRefPtr CefParseJSONAndReturnError( const CefString& json_string, cef_json_parser_options_t options, cef_json_parser_error_t& error_code_out, CefString& error_msg_out); /// // Generates a JSON string from the specified root |node| which should be a // dictionary or list value. Returns an empty string on failure. This method // requires exclusive access to |node| including any underlying data. /// /*--cef()--*/ CefString CefWriteJSON(CefRefPtr node, cef_json_writer_options_t options); #endif // CEF_INCLUDE_CEF_PARSER_H_ cefpython-49.0/src/include/cef_path_util.h000066400000000000000000000043601334103266300206420ustar00rootroot00000000000000// 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_PATH_UTIL_H_ #define CEF_INCLUDE_CEF_PATH_UTIL_H_ #pragma once #include "include/cef_base.h" typedef cef_path_key_t PathKey; /// // Retrieve the path associated with the specified |key|. Returns true on // success. Can be called on any thread in the browser process. /// /*--cef()--*/ bool CefGetPath(PathKey key, CefString& path); #endif // CEF_INCLUDE_CEF_PATH_UTIL_H_ cefpython-49.0/src/include/cef_print_handler.h000066400000000000000000000114031334103266300214760ustar00rootroot00000000000000// Copyright (c) 2014 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_print_settings.h" /// // Callback interface for asynchronous continuation of print dialog requests. /// /*--cef(source=library)--*/ class CefPrintDialogCallback : public virtual CefBase { public: /// // Continue printing with the specified |settings|. /// /*--cef(capi_name=cont)--*/ virtual void Continue(CefRefPtr settings) =0; /// // Cancel the printing. /// /*--cef()--*/ virtual void Cancel() =0; }; /// // Callback interface for asynchronous continuation of print job requests. /// /*--cef(source=library)--*/ class CefPrintJobCallback : public virtual CefBase { public: /// // Indicate completion of the print job. /// /*--cef(capi_name=cont)--*/ virtual void Continue() =0; }; /// // Implement this interface to handle printing on Linux. The methods of this // class will be called on the browser process UI thread. /// /*--cef(source=client)--*/ class CefPrintHandler : public virtual CefBase { public: /// // Called when printing has started for the specified |browser|. This method // will be called before the other OnPrint*() methods and irrespective of how // printing was initiated (e.g. CefBrowserHost::Print(), JavaScript // window.print() or PDF extension print button). /// /*--cef()--*/ virtual void OnPrintStart(CefRefPtr browser) =0; /// // Synchronize |settings| with client state. If |get_defaults| is true then // populate |settings| with the default print settings. Do not keep a // reference to |settings| outside of this callback. /// /*--cef()--*/ virtual void OnPrintSettings(CefRefPtr settings, bool get_defaults) =0; /// // Show the print dialog. Execute |callback| once the dialog is dismissed. // Return true if the dialog will be displayed or false to cancel the // printing immediately. /// /*--cef()--*/ virtual bool OnPrintDialog(bool has_selection, CefRefPtr callback) =0; /// // Send the print job to the printer. Execute |callback| once the job is // completed. Return true if the job will proceed or false to cancel the job // immediately. /// /*--cef()--*/ virtual bool OnPrintJob(const CefString& document_name, const CefString& pdf_file_path, CefRefPtr callback) =0; /// // Reset client state related to printing. /// /*--cef()--*/ virtual void OnPrintReset() =0; /// // Return the PDF paper size in device units. Used in combination with // CefBrowserHost::PrintToPDF(). /// /*--cef()--*/ virtual CefSize GetPdfPaperSize(int device_units_per_inch) { return CefSize(); } }; #endif // CEF_INCLUDE_CEF_PRINT_HANDLER_H_ cefpython-49.0/src/include/cef_print_settings.h000066400000000000000000000126001334103266300217210ustar00rootroot00000000000000// Copyright (c) 2014 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_SETTINGS_H_ #define CEF_INCLUDE_CEF_PRINT_SETTINGS_H_ #pragma once #include #include "include/cef_base.h" /// // Class representing print settings. /// /*--cef(source=library)--*/ class CefPrintSettings : public virtual CefBase { public: typedef cef_color_model_t ColorModel; typedef cef_duplex_mode_t DuplexMode; typedef std::vector PageRangeList; /// // Create a new CefPrintSettings object. /// /*--cef()--*/ static CefRefPtr Create(); /// // Returns true if this object is valid. Do not call any other methods if this // function returns false. /// /*--cef()--*/ virtual bool IsValid() =0; /// // Returns true if the values of this object are read-only. Some APIs may // expose read-only objects. /// /*--cef()--*/ virtual bool IsReadOnly() =0; /// // Returns a writable copy of this object. /// /*--cef()--*/ virtual CefRefPtr Copy() =0; /// // Set the page orientation. /// /*--cef()--*/ virtual void SetOrientation(bool landscape) =0; /// // Returns true if the orientation is landscape. /// /*--cef()--*/ virtual bool IsLandscape() =0; /// // Set the printer printable area in device units. // Some platforms already provide flipped area. Set |landscape_needs_flip| // to false on those platforms to avoid double flipping. /// /*--cef()--*/ virtual void SetPrinterPrintableArea( const CefSize& physical_size_device_units, const CefRect& printable_area_device_units, bool landscape_needs_flip) =0; /// // Set the device name. /// /*--cef(optional_param=name)--*/ virtual void SetDeviceName(const CefString& name) =0; /// // Get the device name. /// /*--cef()--*/ virtual CefString GetDeviceName() =0; /// // Set the DPI (dots per inch). /// /*--cef()--*/ virtual void SetDPI(int dpi) =0; /// // Get the DPI (dots per inch). /// /*--cef()--*/ virtual int GetDPI() =0; /// // Set the page ranges. /// /*--cef()--*/ virtual void SetPageRanges(const PageRangeList& ranges) =0; /// // Returns the number of page ranges that currently exist. /// /*--cef()--*/ virtual size_t GetPageRangesCount() =0; /// // Retrieve the page ranges. /// /*--cef(count_func=ranges:GetPageRangesCount)--*/ virtual void GetPageRanges(PageRangeList& ranges) =0; /// // Set whether only the selection will be printed. /// /*--cef()--*/ virtual void SetSelectionOnly(bool selection_only) =0; /// // Returns true if only the selection will be printed. /// /*--cef()--*/ virtual bool IsSelectionOnly() =0; /// // Set whether pages will be collated. /// /*--cef()--*/ virtual void SetCollate(bool collate) =0; /// // Returns true if pages will be collated. /// /*--cef()--*/ virtual bool WillCollate() =0; /// // Set the color model. /// /*--cef()--*/ virtual void SetColorModel(ColorModel model) =0; /// // Get the color model. /// /*--cef(default_retval=COLOR_MODEL_UNKNOWN)--*/ virtual ColorModel GetColorModel() =0; /// // Set the number of copies. /// /*--cef()--*/ virtual void SetCopies(int copies) =0; /// // Get the number of copies. /// /*--cef()--*/ virtual int GetCopies() =0; /// // Set the duplex mode. /// /*--cef()--*/ virtual void SetDuplexMode(DuplexMode mode) =0; /// // Get the duplex mode. /// /*--cef(default_retval=DUPLEX_MODE_UNKNOWN)--*/ virtual DuplexMode GetDuplexMode() =0; }; #endif // CEF_INCLUDE_CEF_PRINT_SETTINGS_H_ cefpython-49.0/src/include/cef_process_message.h000066400000000000000000000060651334103266300220370ustar00rootroot00000000000000// 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_MESSAGE_H_ #define CEF_INCLUDE_CEF_MESSAGE_H_ #pragma once #include "include/cef_base.h" #include "include/cef_values.h" typedef cef_process_id_t CefProcessId; /// // Class representing a message. Can be used on any process and thread. /// /*--cef(source=library)--*/ class CefProcessMessage : public virtual CefBase { public: /// // Create a new CefProcessMessage object with the specified name. /// /*--cef()--*/ static CefRefPtr Create(const CefString& name); /// // Returns true if this object is valid. Do not call any other methods if this // function returns false. /// /*--cef()--*/ virtual bool IsValid() =0; /// // Returns true if the values of this object are read-only. Some APIs may // expose read-only objects. /// /*--cef()--*/ virtual bool IsReadOnly() =0; /// // Returns a writable copy of this object. /// /*--cef()--*/ virtual CefRefPtr Copy() =0; /// // Returns the message name. /// /*--cef()--*/ virtual CefString GetName() =0; /// // Returns the list of arguments. /// /*--cef()--*/ virtual CefRefPtr GetArgumentList() =0; }; #endif // CEF_INCLUDE_CEF_MESSAGE_H_ cefpython-49.0/src/include/cef_process_util.h000066400000000000000000000050611334103266300213630ustar00rootroot00000000000000// 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_PROCESS_UTIL_H_ #define CEF_INCLUDE_CEF_PROCESS_UTIL_H_ #pragma once #include "include/cef_base.h" #include "include/cef_command_line.h" /// // Launches the process specified via |command_line|. Returns true upon // success. Must be called on the browser process TID_PROCESS_LAUNCHER thread. // // Unix-specific notes: // - All file descriptors open in the parent process will be closed in the // child process except for stdin, stdout, and stderr. // - If the first argument on the command line does not contain a slash, // PATH will be searched. (See man execvp.) /// /*--cef()--*/ bool CefLaunchProcess(CefRefPtr command_line); #endif // CEF_INCLUDE_CEF_PROCESS_UTIL_H_ cefpython-49.0/src/include/cef_render_handler.h000066400000000000000000000164051334103266300216300ustar00rootroot00000000000000// 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_RENDER_HANDLER_H_ #define CEF_INCLUDE_CEF_RENDER_HANDLER_H_ #pragma once #include "include/cef_base.h" #include "include/cef_browser.h" #include "include/cef_drag_data.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_cursor_type_t CursorType; typedef cef_drag_operations_mask_t DragOperation; typedef cef_drag_operations_mask_t DragOperationsMask; typedef cef_paint_element_type_t PaintElementType; typedef std::vector RectList; /// // Called to retrieve the root window rectangle in screen coordinates. Return // true if the rectangle was provided. /// /*--cef()--*/ virtual bool GetRootScreenRect(CefRefPtr browser, CefRect& rect) { return false; } /// // 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) =0; /// // 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 to allow the client to fill in the CefScreenInfo object with // appropriate values. Return true if the |screen_info| structure has been // modified. // // If the screen info rectangle is left empty the rectangle from GetViewRect // will be used. If the rectangle is still empty or invalid popups may not be // drawn correctly. /// /*--cef()--*/ virtual bool GetScreenInfo(CefRefPtr browser, CefScreenInfo& screen_info) { 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 in view coordinates. /// /*--cef()--*/ virtual void OnPopupSize(CefRefPtr browser, const CefRect& rect) {} /// // Called when an element should be painted. Pixel values passed to this // method are scaled relative to view coordinates based on the value of // CefScreenInfo.device_scale_factor returned from GetScreenInfo. |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 in pixel coordinates that need to be repainted. |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, int width, int height) =0; /// // Called when the browser's cursor has changed. If |type| is CT_CUSTOM then // |custom_cursor_info| will be populated with the custom cursor information. /// /*--cef()--*/ virtual void OnCursorChange(CefRefPtr browser, CefCursorHandle cursor, CursorType type, const CefCursorInfo& custom_cursor_info) {} /// // Called when the user starts dragging content in the web view. Contextual // information about the dragged content is supplied by |drag_data|. // (|x|, |y|) is the drag start location in screen coordinates. // OS APIs that run a system message loop may be used within the // StartDragging call. // // Return false to abort the drag operation. Don't call any of // CefBrowserHost::DragSource*Ended* methods after returning false. // // Return true to handle the drag operation. Call // CefBrowserHost::DragSourceEndedAt and DragSourceSystemDragEnded either // synchronously or asynchronously to inform the web view that the drag // operation has ended. /// /*--cef()--*/ virtual bool StartDragging(CefRefPtr browser, CefRefPtr drag_data, DragOperationsMask allowed_ops, int x, int y) { return false; } /// // Called when the web view wants to update the mouse cursor during a // drag & drop operation. |operation| describes the allowed operation // (none, move, copy, link). /// /*--cef()--*/ virtual void UpdateDragCursor(CefRefPtr browser, DragOperation operation) {} /// // Called when the scroll offset has changed. /// /*--cef()--*/ virtual void OnScrollOffsetChanged(CefRefPtr browser, double x, double y) {} }; #endif // CEF_INCLUDE_CEF_RENDER_HANDLER_H_ cefpython-49.0/src/include/cef_render_process_handler.h000066400000000000000000000154231334103266300233650ustar00rootroot00000000000000// Copyright (c) 2013 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_PROCESS_HANDLER_H_ #define CEF_INCLUDE_CEF_RENDER_PROCESS_HANDLER_H_ #pragma once #include "include/cef_base.h" #include "include/cef_browser.h" #include "include/cef_dom.h" #include "include/cef_frame.h" #include "include/cef_load_handler.h" #include "include/cef_process_message.h" #include "include/cef_v8.h" #include "include/cef_values.h" /// // Class used to implement render process callbacks. The methods of this class // will be called on the render process main thread (TID_RENDERER) unless // otherwise indicated. /// /*--cef(source=client)--*/ class CefRenderProcessHandler : public virtual CefBase { public: typedef cef_navigation_type_t NavigationType; /// // Called after the render process main thread has been created. |extra_info| // is a read-only value originating from // CefBrowserProcessHandler::OnRenderProcessThreadCreated(). Do not keep a // reference to |extra_info| outside of this method. /// /*--cef()--*/ virtual void OnRenderThreadCreated(CefRefPtr extra_info) {} /// // Called after WebKit has been initialized. /// /*--cef()--*/ virtual void OnWebKitInitialized() {} /// // Called after a browser has been created. When browsing cross-origin a new // browser will be created before the old browser with the same identifier is // destroyed. /// /*--cef()--*/ virtual void OnBrowserCreated(CefRefPtr browser) {} /// // Called before a browser is destroyed. /// /*--cef()--*/ virtual void OnBrowserDestroyed(CefRefPtr browser) {} /// // Return the handler for browser load status events. /// /*--cef()--*/ virtual CefRefPtr GetLoadHandler() { return NULL; } /// // Called before browser navigation. Return true to cancel the navigation or // false to allow the navigation to proceed. The |request| object cannot be // modified in this callback. /// /*--cef()--*/ virtual bool OnBeforeNavigation(CefRefPtr browser, CefRefPtr frame, CefRefPtr request, NavigationType navigation_type, bool is_redirect) { return false; } /// // Called immediately after the V8 context for a frame has been created. To // retrieve the JavaScript 'window' object use the CefV8Context::GetGlobal() // method. V8 handles can only be accessed from the thread on which they are // created. A task runner for posting tasks on the associated thread can be // retrieved via the CefV8Context::GetTaskRunner() 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) {} /// // Called for global uncaught exceptions in a frame. Execution of this // callback is disabled by default. To enable set // CefSettings.uncaught_exception_stack_size > 0. /// /*--cef()--*/ virtual void OnUncaughtException(CefRefPtr browser, CefRefPtr frame, CefRefPtr context, CefRefPtr exception, CefRefPtr stackTrace) {} /// // 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) {} /// // Called when a new message is received from a different process. Return true // if the message was handled or false otherwise. Do not keep a reference to // or attempt to access the message outside of this callback. /// /*--cef()--*/ virtual bool OnProcessMessageReceived(CefRefPtr browser, CefProcessId source_process, CefRefPtr message) { return false; } }; #endif // CEF_INCLUDE_CEF_RENDER_PROCESS_HANDLER_H_ cefpython-49.0/src/include/cef_request.h000066400000000000000000000221261334103266300203410ustar00rootroot00000000000000// 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_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,no_debugct_check)--*/ class CefRequest : public virtual CefBase { public: typedef std::multimap HeaderMap; typedef cef_referrer_policy_t ReferrerPolicy; typedef cef_resource_type_t ResourceType; typedef cef_transition_type_t TransitionType; /// // Create a new CefRequest object. /// /*--cef()--*/ static CefRefPtr Create(); /// // Returns true if this object is read-only. /// /*--cef()--*/ virtual bool IsReadOnly() =0; /// // 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; /// // Set the referrer URL and policy. If non-empty the referrer URL must be // fully qualified with an HTTP or HTTPS scheme component. Any username, // password or ref component will be removed. /// /*--cef()--*/ virtual void SetReferrer(const CefString& referrer_url, ReferrerPolicy policy) =0; /// // Get the referrer URL. /// /*--cef()--*/ virtual CefString GetReferrerURL() =0; /// // Get the referrer policy. /// /*--cef(default_retval=REFERRER_POLICY_DEFAULT)--*/ virtual ReferrerPolicy GetReferrerPolicy() =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. Will not include the Referer value if any. /// /*--cef()--*/ virtual void GetHeaderMap(HeaderMap& headerMap) =0; /// // Set the header values. If a Referer value exists in the header map it will // be removed and ignored. /// /*--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 CefURLRequest. See // cef_urlrequest_flags_t for supported values. /// /*--cef(default_retval=UR_FLAG_NONE)--*/ virtual int GetFlags() =0; /// // Set the flags used in combination with CefURLRequest. See // cef_urlrequest_flags_t for supported values. /// /*--cef()--*/ virtual void SetFlags(int flags) =0; /// // Set the URL to the first party for cookies used in combination with // CefURLRequest. /// /*--cef()--*/ virtual CefString GetFirstPartyForCookies() =0; /// // Get the URL to the first party for cookies used in combination with // CefURLRequest. /// /*--cef()--*/ virtual void SetFirstPartyForCookies(const CefString& url) =0; /// // Get the resource type for this request. Only available in the browser // process. /// /*--cef(default_retval=RT_SUB_RESOURCE)--*/ virtual ResourceType GetResourceType() =0; /// // Get the transition type for this request. Only available in the browser // process and only applies to requests that represent a main frame or // sub-frame navigation. /// /*--cef(default_retval=TT_EXPLICIT)--*/ virtual TransitionType GetTransitionType() =0; /// // Returns the globally unique identifier for this request or 0 if not // specified. Can be used by CefRequestHandler implementations in the browser // process to track a single request across multiple callbacks. /// /*--cef()--*/ virtual uint64 GetIdentifier() =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,no_debugct_check)--*/ class CefPostData : public virtual CefBase { public: typedef std::vector > ElementVector; /// // Create a new CefPostData object. /// /*--cef()--*/ static CefRefPtr Create(); /// // Returns true if this object is read-only. /// /*--cef()--*/ virtual bool IsReadOnly() =0; /// // Returns true if the underlying POST data includes elements that are not // represented by this CefPostData object (for example, multi-part file upload // data). Modifying CefPostData objects with excluded elements may result in // the request failing. /// /*--cef()--*/ virtual bool HasExcludedElements() = 0; /// // 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,no_debugct_check)--*/ 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 Create(); /// // Returns true if this object is read-only. /// /*--cef()--*/ virtual bool IsReadOnly() =0; /// // 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_ cefpython-49.0/src/include/cef_request_context.h000066400000000000000000000267271334103266300221200ustar00rootroot00000000000000// Copyright (c) 2013 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_CONTEXT_H_ #define CEF_INCLUDE_CEF_REQUEST_CONTEXT_H_ #pragma once #include #include "include/cef_callback.h" #include "include/cef_cookie.h" #include "include/cef_request_context_handler.h" #include "include/cef_values.h" class CefSchemeHandlerFactory; /// // Callback interface for CefRequestContext::ResolveHost. /// /*--cef(source=client)--*/ class CefResolveCallback : public virtual CefBase { public: /// // Called after the ResolveHost request has completed. |result| will be the // result code. |resolved_ips| will be the list of resolved IP addresses or // empty if the resolution failed. /// /*--cef(optional_param=resolved_ips)--*/ virtual void OnResolveCompleted( cef_errorcode_t result, const std::vector& resolved_ips) =0; }; /// // A request context provides request handling for a set of related browser // or URL request objects. A request context can be specified when creating a // new browser via the CefBrowserHost static factory methods or when creating a // new URL request via the CefURLRequest static factory methods. Browser objects // with different request contexts will never be hosted in the same render // process. Browser objects with the same request context may or may not be // hosted in the same render process depending on the process model. Browser // objects created indirectly via the JavaScript window.open function or // targeted links will share the same render process and the same request // context as the source browser. When running in single-process mode there is // only a single render process (the main process) and so all browsers created // in single-process mode will share the same request context. This will be the // first request context passed into a CefBrowserHost static factory method and // all other request context objects will be ignored. /// /*--cef(source=library,no_debugct_check)--*/ class CefRequestContext : public virtual CefBase { public: /// // Returns the global context object. /// /*--cef()--*/ static CefRefPtr GetGlobalContext(); /// // Creates a new context object with the specified |settings| and optional // |handler|. /// /*--cef(optional_param=handler)--*/ static CefRefPtr CreateContext( const CefRequestContextSettings& settings, CefRefPtr handler); /// // Creates a new context object that shares storage with |other| and uses an // optional |handler|. /// /*--cef(capi_name=create_context_shared,optional_param=handler)--*/ static CefRefPtr CreateContext( CefRefPtr other, CefRefPtr handler); /// // Returns true if this object is pointing to the same context as |that| // object. /// /*--cef()--*/ virtual bool IsSame(CefRefPtr other) =0; /// // Returns true if this object is sharing the same storage as |that| object. /// /*--cef()--*/ virtual bool IsSharingWith(CefRefPtr other) =0; /// // Returns true if this object is the global context. The global context is // used by default when creating a browser or URL request with a NULL context // argument. /// /*--cef()--*/ virtual bool IsGlobal() =0; /// // Returns the handler for this context if any. /// /*--cef()--*/ virtual CefRefPtr GetHandler() =0; /// // Returns the cache path for this object. If empty an "incognito mode" // in-memory cache is being used. /// /*--cef()--*/ virtual CefString GetCachePath() =0; /// // Returns the default cookie manager for this object. This will be the global // cookie manager if this object is the global request context. Otherwise, // this will be the default cookie manager used when this request context does // not receive a value via CefRequestContextHandler::GetCookieManager(). If // |callback| is non-NULL it will be executed asnychronously on the IO thread // after the manager's storage has been initialized. /// /*--cef(optional_param=callback)--*/ virtual CefRefPtr GetDefaultCookieManager( CefRefPtr callback) =0; /// // 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 then // you must also implement the CefApp::OnRegisterCustomSchemes() method in all // processes. 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 in the browser process. /// /*--cef(optional_param=domain_name,optional_param=factory)--*/ virtual bool RegisterSchemeHandlerFactory( const CefString& scheme_name, const CefString& domain_name, CefRefPtr factory) =0; /// // Clear all registered scheme handler factories. Returns false on error. This // function may be called on any thread in the browser process. /// /*--cef()--*/ virtual bool ClearSchemeHandlerFactories() =0; /// // Tells all renderer processes associated with this context to throw away // their plugin list cache. If |reload_pages| is true they will also reload // all pages with plugins. CefRequestContextHandler::OnBeforePluginLoad may // be called to rebuild the plugin list cache. /// /*--cef()--*/ virtual void PurgePluginListCache(bool reload_pages) =0; /// // Returns true if a preference with the specified |name| exists. This method // must be called on the browser process UI thread. /// /*--cef()--*/ virtual bool HasPreference(const CefString& name) =0; /// // Returns the value for the preference with the specified |name|. Returns // NULL if the preference does not exist. The returned object contains a copy // of the underlying preference value and modifications to the returned object // will not modify the underlying preference value. This method must be called // on the browser process UI thread. /// /*--cef()--*/ virtual CefRefPtr GetPreference(const CefString& name) =0; /// // Returns all preferences as a dictionary. If |include_defaults| is true then // preferences currently at their default value will be included. The returned // object contains a copy of the underlying preference values and // modifications to the returned object will not modify the underlying // preference values. This method must be called on the browser process UI // thread. /// /*--cef()--*/ virtual CefRefPtr GetAllPreferences( bool include_defaults) =0; /// // Returns true if the preference with the specified |name| can be modified // using SetPreference. As one example preferences set via the command-line // usually cannot be modified. This method must be called on the browser // process UI thread. /// /*--cef()--*/ virtual bool CanSetPreference(const CefString& name) =0; /// // Set the |value| associated with preference |name|. Returns true if the // value is set successfully and false otherwise. If |value| is NULL the // preference will be restored to its default value. If setting the preference // fails then |error| will be populated with a detailed description of the // problem. This method must be called on the browser process UI thread. /// /*--cef(optional_param=value)--*/ virtual bool SetPreference(const CefString& name, CefRefPtr value, CefString& error) =0; /// // Clears all certificate exceptions that were added as part of handling // CefRequestHandler::OnCertificateError(). If you call this it is // recommended that you also call CloseAllConnections() or you risk not // being prompted again for server certificates if you reconnect quickly. // If |callback| is non-NULL it will be executed on the UI thread after // completion. /// /*--cef(optional_param=callback)--*/ virtual void ClearCertificateExceptions( CefRefPtr callback) =0; /// // Clears all active and idle connections that Chromium currently has. // This is only recommended if you have released all other CEF objects but // don't yet want to call CefShutdown(). If |callback| is non-NULL it will be // executed on the UI thread after completion. /// /*--cef(optional_param=callback)--*/ virtual void CloseAllConnections( CefRefPtr callback) =0; /// // Attempts to resolve |origin| to a list of associated IP addresses. // |callback| will be executed on the UI thread after completion. /// /*--cef()--*/ virtual void ResolveHost( const CefString& origin, CefRefPtr callback) =0; /// // Attempts to resolve |origin| to a list of associated IP addresses using // cached data. |resolved_ips| will be populated with the list of resolved IP // addresses or empty if no cached data is available. Returns ERR_NONE on // success. This method must be called on the browser process IO thread. /// /*--cef(default_retval=ERR_FAILED)--*/ virtual cef_errorcode_t ResolveHostCached( const CefString& origin, std::vector& resolved_ips) =0; }; #endif // CEF_INCLUDE_CEF_REQUEST_CONTEXT_H_ cefpython-49.0/src/include/cef_request_context_handler.h000066400000000000000000000104341334103266300236010ustar00rootroot00000000000000// Copyright (c) 2013 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_CONTEXT_HANDLER_H_ #define CEF_INCLUDE_CEF_REQUEST_CONTEXT_HANDLER_H_ #pragma once #include "include/cef_base.h" #include "include/cef_cookie.h" #include "include/cef_web_plugin.h" /// // Implement this interface to provide handler implementations. The handler // instance will not be released until all objects related to the context have // been destroyed. /// /*--cef(source=client,no_debugct_check)--*/ class CefRequestContextHandler : public virtual CefBase { public: typedef cef_plugin_policy_t PluginPolicy; /// // Called on the browser process IO thread to retrieve the cookie manager. If // this method returns NULL the default cookie manager retrievable via // CefRequestContext::GetDefaultCookieManager() will be used. /// /*--cef()--*/ virtual CefRefPtr GetCookieManager() { return NULL; } /// // Called on multiple browser process threads before a plugin instance is // loaded. |mime_type| is the mime type of the plugin that will be loaded. // |plugin_url| is the content URL that the plugin will load and may be empty. // |top_origin_url| is the URL for the top-level frame that contains the // plugin when loading a specific plugin instance or empty when building the // initial list of enabled plugins for 'navigator.plugins' JavaScript state. // |plugin_info| includes additional information about the plugin that will be // loaded. |plugin_policy| is the recommended policy. Modify |plugin_policy| // and return true to change the policy. Return false to use the recommended // policy. The default plugin policy can be set at runtime using the // `--plugin-policy=[allow|detect|block]` command-line flag. Decisions to mark // a plugin as disabled by setting |plugin_policy| to PLUGIN_POLICY_DISABLED // may be cached when |top_origin_url| is empty. To purge the plugin list // cache and potentially trigger new calls to this method call // CefRequestContext::PurgePluginListCache. /// /*--cef(optional_param=plugin_url,optional_param=top_origin_url)--*/ virtual bool OnBeforePluginLoad(const CefString& mime_type, const CefString& plugin_url, const CefString& top_origin_url, CefRefPtr plugin_info, PluginPolicy* plugin_policy) { return false; } }; #endif // CEF_INCLUDE_CEF_REQUEST_CONTEXT_HANDLER_H_ cefpython-49.0/src/include/cef_request_handler.h000066400000000000000000000314301334103266300220340ustar00rootroot00000000000000// 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_auth_callback.h" #include "include/cef_base.h" #include "include/cef_browser.h" #include "include/cef_frame.h" #include "include/cef_resource_handler.h" #include "include/cef_response.h" #include "include/cef_response_filter.h" #include "include/cef_request.h" #include "include/cef_ssl_info.h" /// // Callback interface used for asynchronous continuation of url requests. /// /*--cef(source=library)--*/ class CefRequestCallback : public virtual CefBase { public: /// // Continue the url request. If |allow| is true the request will be continued. // Otherwise, the request will be canceled. /// /*--cef(capi_name=cont)--*/ virtual void Continue(bool allow) =0; /// // Cancel the url request. /// /*--cef()--*/ virtual void Cancel() =0; }; /// // 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_return_value_t ReturnValue; typedef cef_termination_status_t TerminationStatus; typedef cef_urlrequest_status_t URLRequestStatus; typedef cef_window_open_disposition_t WindowOpenDisposition; /// // Called on the UI thread before browser navigation. Return true to cancel // the navigation or false to allow the navigation to proceed. The |request| // object cannot be modified in this callback. // CefLoadHandler::OnLoadingStateChange will be called twice in all cases. // If the navigation is allowed CefLoadHandler::OnLoadStart and // CefLoadHandler::OnLoadEnd will be called. If the navigation is canceled // CefLoadHandler::OnLoadError will be called with an |errorCode| value of // ERR_ABORTED. /// /*--cef()--*/ virtual bool OnBeforeBrowse(CefRefPtr browser, CefRefPtr frame, CefRefPtr request, bool is_redirect) { return false; } /// // Called on the UI thread before OnBeforeBrowse in certain limited cases // where navigating a new or different browser might be desirable. This // includes user-initiated navigation that might open in a special way (e.g. // links clicked via middle-click or ctrl + left-click) and certain types of // cross-origin navigation initiated from the renderer process (e.g. // navigating the top-level frame to/from a file URL). The |browser| and // |frame| values represent the source of the navigation. The // |target_disposition| value indicates where the user intended to navigate // the browser based on standard Chromium behaviors (e.g. current tab, // new tab, etc). The |user_gesture| value will be true if the browser // navigated via explicit user gesture (e.g. clicking a link) or false if it // navigated automatically (e.g. via the DomContentLoaded event). Return true // to cancel the navigation or false to allow the navigation to proceed in the // source browser's top-level frame. /// /*--cef()--*/ virtual bool OnOpenURLFromTab(CefRefPtr browser, CefRefPtr frame, const CefString& target_url, WindowOpenDisposition target_disposition, bool user_gesture) { return false; } /// // Called on the IO thread before a resource request is loaded. The |request| // object may be modified. Return RV_CONTINUE to continue the request // immediately. Return RV_CONTINUE_ASYNC and call CefRequestCallback:: // Continue() at a later time to continue or cancel the request // asynchronously. Return RV_CANCEL to cancel the request immediately. // /// /*--cef(default_retval=RV_CONTINUE)--*/ virtual ReturnValue OnBeforeResourceLoad( CefRefPtr browser, CefRefPtr frame, CefRefPtr request, CefRefPtr callback) { return RV_CONTINUE; } /// // Called on the IO thread before a resource is loaded. To allow the resource // to load normally return NULL. To specify a handler for the resource return // a CefResourceHandler object. The |request| object should not be modified in // this callback. /// /*--cef()--*/ virtual CefRefPtr GetResourceHandler( CefRefPtr browser, CefRefPtr frame, CefRefPtr request) { return NULL; } /// // Called on the IO thread when a resource load is redirected. The |request| // parameter will contain the old URL and other request-related information. // The |new_url| parameter will contain the new URL and can be changed if // desired. The |request| object cannot be modified in this callback. /// /*--cef()--*/ virtual void OnResourceRedirect(CefRefPtr browser, CefRefPtr frame, CefRefPtr request, CefString& new_url) {} /// // Called on the IO thread when a resource response is received. To allow the // resource to load normally return false. To redirect or retry the resource // modify |request| (url, headers or post body) and return true. The // |response| object cannot be modified in this callback. /// /*--cef()--*/ virtual bool OnResourceResponse(CefRefPtr browser, CefRefPtr frame, CefRefPtr request, CefRefPtr response) { return false; } /// // Called on the IO thread to optionally filter resource response content. // |request| and |response| represent the request and response respectively // and cannot be modified in this callback. /// /*--cef()--*/ virtual CefRefPtr GetResourceResponseFilter( CefRefPtr browser, CefRefPtr frame, CefRefPtr request, CefRefPtr response) { return NULL; } /// // Called on the IO thread when a resource load has completed. |request| and // |response| represent the request and response respectively and cannot be // modified in this callback. |status| indicates the load completion status. // |received_content_length| is the number of response bytes actually read. /// /*--cef()--*/ virtual void OnResourceLoadComplete(CefRefPtr browser, CefRefPtr frame, CefRefPtr request, CefRefPtr response, URLRequestStatus status, int64 received_content_length) {} /// // 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| contains the port number. |realm| is the realm of the // challenge and may be empty. |scheme| is the authentication scheme used, // such as "basic" or "digest", and will be empty if the source of the request // is an FTP server. Return true to continue the request and call // CefAuthCallback::Continue() either in this method or at a later time when // the authentication information is available. Return false to cancel the // request immediately. /// /*--cef(optional_param=realm,optional_param=scheme)--*/ virtual bool GetAuthCredentials(CefRefPtr browser, CefRefPtr frame, bool isProxy, const CefString& host, int port, const CefString& realm, const CefString& scheme, CefRefPtr callback) { return false; } /// // Called on the IO thread when JavaScript requests a specific storage quota // size via the webkitStorageInfo.requestQuota function. |origin_url| is the // origin of the page making the request. |new_size| is the requested quota // size in bytes. Return true to continue the request and call // CefRequestCallback::Continue() either in this method or at a later time to // grant or deny the request. Return false to cancel the request immediately. /// /*--cef()--*/ virtual bool OnQuotaRequest(CefRefPtr browser, const CefString& origin_url, int64 new_size, CefRefPtr callback) { return false; } /// // Called on the UI thread to handle requests for URLs with an unknown // protocol component. Set |allow_os_execution| to true to attempt execution // via the registered OS protocol handler, if any. // SECURITY WARNING: YOU SHOULD USE THIS METHOD TO ENFORCE RESTRICTIONS BASED // ON SCHEME, HOST OR OTHER URL ANALYSIS BEFORE ALLOWING OS EXECUTION. /// /*--cef()--*/ virtual void OnProtocolExecution(CefRefPtr browser, const CefString& url, bool& allow_os_execution) {} /// // Called on the UI thread to handle requests for URLs with an invalid // SSL certificate. Return true and call CefRequestCallback::Continue() either // in this method or at a later time to continue or cancel the request. Return // false to cancel the request immediately. If // CefSettings.ignore_certificate_errors is set all invalid certificates will // be accepted without calling this method. /// /*--cef()--*/ virtual bool OnCertificateError( CefRefPtr browser, cef_errorcode_t cert_error, const CefString& request_url, CefRefPtr ssl_info, CefRefPtr callback) { return false; } /// // Called on the browser process UI thread when a plugin has crashed. // |plugin_path| is the path of the plugin that crashed. /// /*--cef()--*/ virtual void OnPluginCrashed(CefRefPtr browser, const CefString& plugin_path) {} /// // Called on the browser process UI thread when the render view associated // with |browser| is ready to receive/handle IPC messages in the render // process. /// /*--cef()--*/ virtual void OnRenderViewReady(CefRefPtr browser) {} /// // Called on the browser process UI thread when the render process // terminates unexpectedly. |status| indicates how the process // terminated. /// /*--cef()--*/ virtual void OnRenderProcessTerminated(CefRefPtr browser, TerminationStatus status) {} }; #endif // CEF_INCLUDE_CEF_REQUEST_HANDLER_H_ cefpython-49.0/src/include/cef_resource_bundle.h000066400000000000000000000105031334103266300220250ustar00rootroot00000000000000// Copyright (c) 2015 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_H_ #define CEF_INCLUDE_CEF_RESOURCE_BUNDLE_H_ #pragma once #include "include/cef_base.h" /// // Class used for retrieving resources from the resource bundle (*.pak) files // loaded by CEF during startup or via the CefResourceBundleHandler returned // from CefApp::GetResourceBundleHandler. See CefSettings for additional options // related to resource bundle loading. The methods of this class may be called // on any thread unless otherwise indicated. /// /*--cef(source=library,no_debugct_check)--*/ class CefResourceBundle : public virtual CefBase { public: typedef cef_scale_factor_t ScaleFactor; /// // Returns the global resource bundle instance. /// /*--cef()--*/ static CefRefPtr GetGlobal(); /// // Returns the localized string for the specified |string_id| or an empty // string if the value is not found. Include cef_pack_strings.h for a listing // of valid string ID values. /// /*--cef()--*/ virtual CefString GetLocalizedString(int string_id) =0; /// // Retrieves the contents of the specified scale independent |resource_id|. // If the value is found then |data| and |data_size| will be populated and // this method will return true. If the value is not found then this method // will return false. The returned |data| pointer will remain resident in // memory and should not be freed. Include cef_pack_resources.h for a listing // of valid resource ID values. /// /*--cef()--*/ virtual bool GetDataResource(int resource_id, void*& data, size_t& data_size) =0; /// // Retrieves the contents of the specified |resource_id| nearest the scale // factor |scale_factor|. Use a |scale_factor| value of SCALE_FACTOR_NONE for // scale independent resources or call GetDataResource instead. If the value // is found then |data| and |data_size| will be populated and this method will // return true. If the value is not found then this method will return false. // The returned |data| pointer will remain resident in memory and should not // be freed. Include cef_pack_resources.h for a listing of valid resource ID // values. /// /*--cef()--*/ virtual bool GetDataResourceForScale(int resource_id, ScaleFactor scale_factor, void*& data, size_t& data_size) =0; }; #endif // CEF_INCLUDE_CEF_RESOURCE_BUNDLE_H_ cefpython-49.0/src/include/cef_resource_bundle_handler.h000066400000000000000000000100701334103266300235210ustar00rootroot00000000000000// 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. See CefSettings // for additional options related to resource bundle loading. The methods of // this class may be called on multiple threads. /// /*--cef(source=client)--*/ class CefResourceBundleHandler : public virtual CefBase { public: typedef cef_scale_factor_t ScaleFactor; /// // Called to retrieve a localized translation for the specified |string_id|. // To provide the translation set |string| to the translation string and // return true. To use the default translation return false. Include // cef_pack_strings.h for a listing of valid string ID values. /// /*--cef()--*/ virtual bool GetLocalizedString(int string_id, CefString& string) =0; /// // Called to retrieve data for the specified scale independent |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. Include cef_pack_resources.h for a listing of valid resource ID // values. /// /*--cef()--*/ virtual bool GetDataResource(int resource_id, void*& data, size_t& data_size) =0; /// // Called to retrieve data for the specified |resource_id| nearest the scale // factor |scale_factor|. 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. Include cef_pack_resources.h for // a listing of valid resource ID values. /// /*--cef()--*/ virtual bool GetDataResourceForScale(int resource_id, ScaleFactor scale_factor, void*& data, size_t& data_size) =0; }; #endif // CEF_INCLUDE_CEF_RESOURCE_BUNDLE_HANDLER_H_ cefpython-49.0/src/include/cef_resource_handler.h000066400000000000000000000114401334103266300221720ustar00rootroot00000000000000// 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_HANDLER_H_ #define CEF_INCLUDE_CEF_RESOURCE_HANDLER_H_ #pragma once #include "include/cef_base.h" #include "include/cef_browser.h" #include "include/cef_callback.h" #include "include/cef_cookie.h" #include "include/cef_request.h" #include "include/cef_response.h" /// // Class used to implement a custom request handler interface. The methods of // this class will always be called on the IO thread. /// /*--cef(source=client)--*/ class CefResourceHandler : public virtual CefBase { public: /// // Begin processing the request. To handle the request return true and call // CefCallback::Continue() once the response header information is available // (CefCallback::Continue() 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 CefCallback::Continue() 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; /// // Return true if the specified cookie can be sent with the request or false // otherwise. If false is returned for any cookie then no cookies will be sent // with the request. /// /*--cef()--*/ virtual bool CanGetCookie(const CefCookie& cookie) { return true; } /// // Return true if the specified cookie returned with the response can be set // or false otherwise. /// /*--cef()--*/ virtual bool CanSetCookie(const CefCookie& cookie) { return true; } /// // Request processing has been canceled. /// /*--cef()--*/ virtual void Cancel() =0; }; #endif // CEF_INCLUDE_CEF_RESOURCE_HANDLER_H_ cefpython-49.0/src/include/cef_response.h000066400000000000000000000070061334103266300205070ustar00rootroot00000000000000// 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_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,no_debugct_check)--*/ class CefResponse : public virtual CefBase { public: typedef std::multimap HeaderMap; /// // Create a new CefResponse object. /// /*--cef()--*/ static CefRefPtr Create(); /// // Returns true if this object is read-only. /// /*--cef()--*/ virtual bool IsReadOnly() =0; /// // 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_ cefpython-49.0/src/include/cef_response_filter.h000066400000000000000000000101161334103266300220500ustar00rootroot00000000000000// Copyright (c) 2015 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_FILTER_H_ #define CEF_INCLUDE_CEF_RESPONSE_FILTER_H_ #pragma once #include "include/cef_base.h" /// // Implement this interface to filter resource response content. The methods of // this class will be called on the browser process IO thread. /// /*--cef(source=client)--*/ class CefResponseFilter : public virtual CefBase { public: typedef cef_response_filter_status_t FilterStatus; /// // Initialize the response filter. Will only be called a single time. The // filter will not be installed if this method returns false. /// /*--cef()--*/ virtual bool InitFilter() =0; /// // Called to filter a chunk of data. |data_in| is the input buffer containing // |data_in_size| bytes of pre-filter data (|data_in| will be NULL if // |data_in_size| is zero). |data_out| is the output buffer that can accept up // to |data_out_size| bytes of filtered output data. Set |data_in_read| to the // number of bytes that were read from |data_in|. Set |data_out_written| to // the number of bytes that were written into |data_out|. If some or all of // the pre-filter data was read successfully but more data is needed in order // to continue filtering (filtered output is pending) return // RESPONSE_FILTER_NEED_MORE_DATA. If some or all of the pre-filter data was // read successfully and all available filtered output has been written return // RESPONSE_FILTER_DONE. If an error occurs during filtering return // RESPONSE_FILTER_ERROR. This method will be called repeatedly until there is // no more data to filter (resource response is complete), |data_in_read| // matches |data_in_size| (all available pre-filter bytes have been read), and // the method returns RESPONSE_FILTER_DONE or RESPONSE_FILTER_ERROR. Do not // keep a reference to the buffers passed to this method. /// /*--cef(optional_param=data_in,default_retval=RESPONSE_FILTER_ERROR)--*/ virtual FilterStatus Filter(void* data_in, size_t data_in_size, size_t& data_in_read, void* data_out, size_t data_out_size, size_t& data_out_written) =0; }; #endif // CEF_INCLUDE_CEF_RESPONSE_FILTER_H_ cefpython-49.0/src/include/cef_runnable.h000066400000000000000000000325761334103266300204710ustar00rootroot00000000000000// Copyright (c) 2013 Marshall A. Greenblatt. Portions Copyright (c) // 2006-2011 Google Inc. 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 a modified extract of base/task.h #ifndef CEF_INCLUDE_CEF_RUNNABLE_H_ #define CEF_INCLUDE_CEF_RUNNABLE_H_ #pragma once #if defined(BUILDING_CEF_SHARED) // The implementation of cef_runnable.h depends on an obsolete version of // base/tuple.h that is implemented by cef_tuple.h for client applications but // is not compatible with the version used when building Chromium/CEF. #error This header cannot be used when building Chromium/CEF. #endif #include "include/base/cef_tuple.h" #include "include/cef_base.h" #include "include/cef_task.h" // CefRunnableMethodTraits ----------------------------------------------------- // // This traits-class is used by CefRunnableMethod to manage the lifetime of the // callee object. By default, it is assumed that the callee supports AddRef // and Release methods. A particular class can specialize this template to // define other lifetime management. For example, if the callee is known to // live longer than the CefRunnableMethod object, then a CefRunnableMethodTraits // struct could be defined with empty RetainCallee and ReleaseCallee methods. // // The DISABLE_RUNNABLE_METHOD_REFCOUNT macro is provided as a convenient way // for declaring a CefRunnableMethodTraits that disables refcounting. template struct CefRunnableMethodTraits { CefRunnableMethodTraits() { } ~CefRunnableMethodTraits() { } void RetainCallee(T* obj) { #ifndef NDEBUG // Catch NewCefRunnableMethod being called in an object's constructor. // This isn't safe since the method can be invoked before the constructor // completes, causing the object to be deleted. obj->AddRef(); obj->Release(); #endif obj->AddRef(); } void ReleaseCallee(T* obj) { obj->Release(); } }; // Convenience macro for declaring a CefRunnableMethodTraits that disables // refcounting of a class. This is useful if you know that the callee // will outlive the CefRunnableMethod object and thus do not need the ref // counts. // // The invocation of DISABLE_RUNNABLE_METHOD_REFCOUNT should be done at the // global namespace scope. Example: // // namespace foo { // class Bar { // ... // }; // } // namespace foo // // DISABLE_RUNNABLE_METHOD_REFCOUNT(foo::Bar); // // This is different from DISALLOW_COPY_AND_ASSIGN which is declared inside the // class. #define DISABLE_RUNNABLE_METHOD_REFCOUNT(TypeName) \ template <> \ struct CefRunnableMethodTraits { \ void RetainCallee(TypeName* manager) {} \ void ReleaseCallee(TypeName* manager) {} \ } // CefRunnableMethod and CefRunnableFunction ---------------------------------- // // CefRunnable methods are a type of task that call a function on an object // when they are run. We implement both an object and a set of // NewCefRunnableMethod and NewCefRunnableFunction functions for convenience. // These functions are overloaded and will infer the template types, // simplifying calling code. // // The template definitions all use the following names: // T - the class type of the object you're supplying // this is not needed for the Static version of the call // Method/Function - the signature of a pointer to the method or function you // want to call // Param - the parameter(s) to the method, possibly packed as a Tuple // A - the first parameter (if any) to the method // B - the second parameter (if any) to the method // // Put these all together and you get an object that can call a method whose // signature is: // R T::MyFunction([A[, B]]) // // Usage: // CefPostTask(TID_UI, NewCefRunnableMethod(object, &Object::method[, a[, b]]) // CefPostTask(TID_UI, NewCefRunnableFunction(&function[, a[, b]]) // CefRunnableMethod and NewCefRunnableMethod implementation ------------------ template class CefRunnableMethod : public CefTask { public: CefRunnableMethod(T* obj, Method meth, const Params& params) : obj_(obj), meth_(meth), params_(params) { traits_.RetainCallee(obj_); } ~CefRunnableMethod() { T* obj = obj_; obj_ = NULL; if (obj) traits_.ReleaseCallee(obj); } void Execute() OVERRIDE { if (obj_) DispatchToMethod(obj_, meth_, params_); } private: T* obj_; Method meth_; Params params_; CefRunnableMethodTraits traits_; IMPLEMENT_REFCOUNTING(CefRunnableMethod); }; template inline CefRefPtr NewCefRunnableMethod(T* object, Method method) { return new CefRunnableMethod( object, method, base::MakeTuple()); } template inline CefRefPtr NewCefRunnableMethod(T* object, Method method, const A& a) { return new CefRunnableMethod >( object, method, base::MakeTuple(a)); } template inline CefRefPtr NewCefRunnableMethod(T* object, Method method, const A& a, const B& b) { return new CefRunnableMethod >( object, method, base::MakeTuple(a, b)); } template inline CefRefPtr NewCefRunnableMethod(T* object, Method method, const A& a, const B& b, const C& c) { return new CefRunnableMethod >( object, method, base::MakeTuple(a, b, c)); } template inline CefRefPtr NewCefRunnableMethod(T* object, Method method, const A& a, const B& b, const C& c, const D& d) { return new CefRunnableMethod >( object, method, base::MakeTuple(a, b, c, d)); } template inline CefRefPtr NewCefRunnableMethod(T* object, Method method, const A& a, const B& b, const C& c, const D& d, const E& e) { return new CefRunnableMethod >( object, method, base::MakeTuple(a, b, c, d, e)); } template inline CefRefPtr NewCefRunnableMethod(T* object, Method method, const A& a, const B& b, const C& c, const D& d, const E& e, const F& f) { return new CefRunnableMethod >( object, method, base::MakeTuple(a, b, c, d, e, f)); } template inline CefRefPtr NewCefRunnableMethod(T* object, Method method, const A& a, const B& b, const C& c, const D& d, const E& e, const F& f, const G& g) { return new CefRunnableMethod >( object, method, base::MakeTuple(a, b, c, d, e, f, g)); } // CefRunnableFunction and NewCefRunnableFunction implementation -------------- template class CefRunnableFunction : public CefTask { public: CefRunnableFunction(Function function, const Params& params) : function_(function), params_(params) { } ~CefRunnableFunction() { } void Execute() OVERRIDE { if (function_) DispatchToFunction(function_, params_); } private: Function function_; Params params_; IMPLEMENT_REFCOUNTING(CefRunnableFunction); }; template inline CefRefPtr NewCefRunnableFunction(Function function) { return new CefRunnableFunction( function, base::MakeTuple()); } template inline CefRefPtr NewCefRunnableFunction(Function function, const A& a) { return new CefRunnableFunction >( function, base::MakeTuple(a)); } template inline CefRefPtr NewCefRunnableFunction(Function function, const A& a, const B& b) { return new CefRunnableFunction >( function, base::MakeTuple(a, b)); } template inline CefRefPtr NewCefRunnableFunction(Function function, const A& a, const B& b, const C& c) { return new CefRunnableFunction >( function, base::MakeTuple(a, b, c)); } template inline CefRefPtr NewCefRunnableFunction(Function function, const A& a, const B& b, const C& c, const D& d) { return new CefRunnableFunction >( function, base::MakeTuple(a, b, c, d)); } template inline CefRefPtr NewCefRunnableFunction(Function function, const A& a, const B& b, const C& c, const D& d, const E& e) { return new CefRunnableFunction >( function, base::MakeTuple(a, b, c, d, e)); } template inline CefRefPtr NewCefRunnableFunction(Function function, const A& a, const B& b, const C& c, const D& d, const E& e, const F& f) { return new CefRunnableFunction >( function, base::MakeTuple(a, b, c, d, e, f)); } template inline CefRefPtr NewCefRunnableFunction(Function function, const A& a, const B& b, const C& c, const D& d, const E& e, const F& f, const G& g) { return new CefRunnableFunction >( function, base::MakeTuple(a, b, c, d, e, f, g)); } template inline CefRefPtr NewCefRunnableFunction(Function function, const A& a, const B& b, const C& c, const D& d, const E& e, const F& f, const G& g, const H& h) { return new CefRunnableFunction >( function, base::MakeTuple(a, b, c, d, e, f, g, h)); } #endif // CEF_INCLUDE_CEF_RUNNABLE_H_ cefpython-49.0/src/include/cef_sandbox_win.h000066400000000000000000000065351334103266300211720ustar00rootroot00000000000000// Copyright (c) 2013 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_CEF_SANDBOX_WIN_H_ #define CEF_INCLUDE_CEF_SANDBOX_WIN_H_ #pragma once #include "include/cef_base.h" #if defined(OS_WIN) #ifdef __cplusplus extern "C" { #endif // The sandbox is used to restrict sub-processes (renderer, plugin, GPU, etc) // from directly accessing system resources. This helps to protect the user // from untrusted and potentially malicious Web content. // See http://www.chromium.org/developers/design-documents/sandbox for // complete details. // // To enable the sandbox on Windows the following requirements must be met: // 1. Use the same executable for the browser process and all sub-processes. // 2. Link the executable with the cef_sandbox static library. // 3. Call the cef_sandbox_info_create() function from within the executable // (not from a separate DLL) and pass the resulting pointer into both the // CefExecutProcess() and CefInitialize() functions via the // |windows_sandbox_info| parameter. /// // Create the sandbox information object for this process. It is safe to create // multiple of this object and to destroy the object immediately after passing // into the CefExecutProcess() and/or CefInitialize() functions. /// void* cef_sandbox_info_create(); /// // Destroy the specified sandbox information object. /// void cef_sandbox_info_destroy(void* sandbox_info); #ifdef __cplusplus } /// // Manages the life span of a sandbox information object. /// class CefScopedSandboxInfo { public: CefScopedSandboxInfo() { sandbox_info_ = cef_sandbox_info_create(); } ~CefScopedSandboxInfo() { cef_sandbox_info_destroy(sandbox_info_); } void* sandbox_info() const { return sandbox_info_; } private: void* sandbox_info_; }; #endif // __cplusplus #endif // defined(OS_WIN) #endif // CEF_INCLUDE_CEF_SANDBOX_WIN_H_ cefpython-49.0/src/include/cef_scheme.h000066400000000000000000000170701334103266300201170ustar00rootroot00000000000000// 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_SCHEME_H_ #define CEF_INCLUDE_CEF_SCHEME_H_ #pragma once #include "include/cef_base.h" #include "include/cef_browser.h" #include "include/cef_frame.h" #include "include/cef_request.h" #include "include/cef_response.h" #include "include/cef_resource_handler.h" class CefSchemeHandlerFactory; /// // Register a scheme handler factory with the global request context. 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 then you must also implement the // CefApp::OnRegisterCustomSchemes() method in all processes. 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 in the browser process. // Using this function is equivalent to calling // CefRequestContext::GetGlobalContext()->RegisterSchemeHandlerFactory(). /// /*--cef(optional_param=domain_name,optional_param=factory)--*/ bool CefRegisterSchemeHandlerFactory( const CefString& scheme_name, const CefString& domain_name, CefRefPtr factory); /// // Clear all scheme handler factories registered with the global request // context. Returns false on error. This function may be called on any thread in // the browser process. Using this function is equivalent to calling // CefRequestContext::GetGlobalContext()->ClearSchemeHandlerFactories(). /// /*--cef()--*/ bool CefClearSchemeHandlerFactories(); /// // Class that manages custom scheme registrations. /// /*--cef(source=library)--*/ class CefSchemeRegistrar : public virtual CefBase { public: /// // 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()--*/ virtual bool AddCustomScheme(const CefString& scheme_name, bool is_standard, bool is_local, bool is_display_isolated) =0; }; /// // Class that creates CefResourceHandler instances for handling scheme requests. // 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 resource handler instance to handle the request or an empty // reference to allow default handling of the request. |browser| and |frame| // will be the browser window and frame respectively that originated the // request or NULL if the request did not originate from a browser window // (for example, if the request came from CefURLRequest). The |request| object // passed to this method will not contain cookie data. /// /*--cef(optional_param=browser,optional_param=frame)--*/ virtual CefRefPtr Create( CefRefPtr browser, CefRefPtr frame, const CefString& scheme_name, CefRefPtr request) =0; }; #endif // CEF_INCLUDE_CEF_SCHEME_H_ cefpython-49.0/src/include/cef_ssl_info.h000066400000000000000000000144051334103266300204660ustar00rootroot00000000000000// Copyright (c) 2015 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_SSL_INFO_H_ #define CEF_INCLUDE_CEF_SSL_INFO_H_ #pragma once #include #include "include/cef_base.h" #include "include/cef_values.h" /// // Class representing the issuer or subject field of an X.509 certificate. /// /*--cef(source=library)--*/ class CefSSLCertPrincipal : public virtual CefBase { public: /// // Returns a name that can be used to represent the issuer. It tries in this // order: CN, O and OU and returns the first non-empty one found. /// /*--cef()--*/ virtual CefString GetDisplayName() =0; /// // Returns the common name. /// /*--cef()--*/ virtual CefString GetCommonName() =0; /// // Returns the locality name. /// /*--cef()--*/ virtual CefString GetLocalityName() =0; /// // Returns the state or province name. /// /*--cef()--*/ virtual CefString GetStateOrProvinceName() =0; /// // Returns the country name. /// /*--cef()--*/ virtual CefString GetCountryName() =0; /// // Retrieve the list of street addresses. /// /*--cef()--*/ virtual void GetStreetAddresses(std::vector& addresses) =0; /// // Retrieve the list of organization names. /// /*--cef()--*/ virtual void GetOrganizationNames(std::vector& names) =0; /// // Retrieve the list of organization unit names. /// /*--cef()--*/ virtual void GetOrganizationUnitNames(std::vector& names) =0; /// // Retrieve the list of domain components. /// /*--cef()--*/ virtual void GetDomainComponents(std::vector& components) =0; }; /// // Class representing SSL information. /// /*--cef(source=library)--*/ class CefSSLInfo : public virtual CefBase { public: typedef std::vector > IssuerChainBinaryList; /// // Returns a bitmask containing any and all problems verifying the server // certificate. /// /*--cef(default_retval=CERT_STATUS_NONE)--*/ virtual cef_cert_status_t GetCertStatus() =0; /// // Returns true if the certificate status has any error, major or minor. /// /*--cef()--*/ virtual bool IsCertStatusError() =0; /// // Returns true if the certificate status represents only minor errors // (e.g. failure to verify certificate revocation). /// /*--cef()--*/ virtual bool IsCertStatusMinorError() =0; /// // Returns the subject of the X.509 certificate. For HTTPS server // certificates this represents the web server. The common name of the // subject should match the host name of the web server. /// /*--cef()--*/ virtual CefRefPtr GetSubject() =0; /// // Returns the issuer of the X.509 certificate. /// /*--cef()--*/ virtual CefRefPtr GetIssuer() =0; /// // Returns the DER encoded serial number for the X.509 certificate. The value // possibly includes a leading 00 byte. /// /*--cef()--*/ virtual CefRefPtr GetSerialNumber() =0; /// // Returns the date before which the X.509 certificate is invalid. // CefTime.GetTimeT() will return 0 if no date was specified. /// /*--cef()--*/ virtual CefTime GetValidStart() =0; /// // Returns the date after which the X.509 certificate is invalid. // CefTime.GetTimeT() will return 0 if no date was specified. /// /*--cef()--*/ virtual CefTime GetValidExpiry() =0; /// // Returns the DER encoded data for the X.509 certificate. /// /*--cef()--*/ virtual CefRefPtr GetDEREncoded() =0; /// // Returns the PEM encoded data for the X.509 certificate. /// /*--cef()--*/ virtual CefRefPtr GetPEMEncoded() =0; /// // Returns the number of certificates in the issuer chain. // If 0, the certificate is self-signed. /// /*--cef()--*/ virtual size_t GetIssuerChainSize() =0; /// // Returns the DER encoded data for the certificate issuer chain. // If we failed to encode a certificate in the chain it is still // present in the array but is an empty string. /// /*--cef(count_func=chain:GetIssuerChainSize)--*/ virtual void GetDEREncodedIssuerChain(IssuerChainBinaryList& chain) =0; /// // Returns the PEM encoded data for the certificate issuer chain. // If we failed to encode a certificate in the chain it is still // present in the array but is an empty string. /// /*--cef(count_func=chain:GetIssuerChainSize)--*/ virtual void GetPEMEncodedIssuerChain(IssuerChainBinaryList& chain) =0; }; #endif // CEF_INCLUDE_CEF_SSL_INFO_H_ cefpython-49.0/src/include/cef_stream.h000066400000000000000000000152551334103266300201510ustar00rootroot00000000000000// 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_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; /// // Return true if this handler performs work like accessing the file system // which may block. Used as a hint for determining the thread to access the // handler from. /// /*--cef()--*/ virtual bool MayBlock() =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; /// // Returns true if this reader performs work like accessing the file system // which may block. Used as a hint for determining the thread to access the // reader from. /// /*--cef()--*/ virtual bool MayBlock() =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; /// // Return true if this handler performs work like accessing the file system // which may block. Used as a hint for determining the thread to access the // handler from. /// /*--cef()--*/ virtual bool MayBlock() =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; /// // Returns true if this writer performs work like accessing the file system // which may block. Used as a hint for determining the thread to access the // writer from. /// /*--cef()--*/ virtual bool MayBlock() =0; }; #endif // CEF_INCLUDE_CEF_STREAM_H_ cefpython-49.0/src/include/cef_string_visitor.h000066400000000000000000000044561334103266300217440ustar00rootroot00000000000000// 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_STRING_VISITOR_H_ #define CEF_INCLUDE_CEF_STRING_VISITOR_H_ #include "include/cef_base.h" /// // Implement this interface to receive string values asynchronously. /// /*--cef(source=client)--*/ class CefStringVisitor : public virtual CefBase { public: /// // Method that will be executed. /// /*--cef(optional_param=string)--*/ virtual void Visit(const CefString& string) =0; }; #endif // CEF_INCLUDE_CEF_STRING_VISITOR_H_ cefpython-49.0/src/include/cef_task.h000066400000000000000000000124311334103266300176110ustar00rootroot00000000000000// Copyright (c) 2013 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" typedef cef_thread_id_t CefThreadId; /// // Implement this interface for asynchronous task execution. If the task is // posted successfully and if the associated message loop is still running then // the Execute() method will be called on the target thread. If the task fails // to post then the task object may be destroyed on the source thread instead of // the target thread. For this reason be cautious when performing work in the // task object destructor. /// /*--cef(source=client)--*/ class CefTask : public virtual CefBase { public: /// // Method that will be executed on the target thread. /// /*--cef()--*/ virtual void Execute() =0; }; /// // Class that asynchronously executes tasks on the associated thread. It is safe // to call the methods of this class on any thread. // // CEF maintains multiple internal threads that are used for handling different // types of tasks in different processes. The cef_thread_id_t definitions in // cef_types.h list the common CEF threads. Task runners are also available for // other CEF threads as appropriate (for example, V8 WebWorker threads). /// /*--cef(source=library)--*/ class CefTaskRunner : public virtual CefBase { public: /// // Returns the task runner for the current thread. Only CEF threads will have // task runners. An empty reference will be returned if this method is called // on an invalid thread. /// /*--cef()--*/ static CefRefPtr GetForCurrentThread(); /// // Returns the task runner for the specified CEF thread. /// /*--cef()--*/ static CefRefPtr GetForThread(CefThreadId threadId); /// // Returns true if this object is pointing to the same task runner as |that| // object. /// /*--cef()--*/ virtual bool IsSame(CefRefPtr that) =0; /// // Returns true if this task runner belongs to the current thread. /// /*--cef()--*/ virtual bool BelongsToCurrentThread() =0; /// // Returns true if this task runner is for the specified CEF thread. /// /*--cef()--*/ virtual bool BelongsToThread(CefThreadId threadId) =0; /// // Post a task for execution on the thread associated with this task runner. // Execution will occur asynchronously. /// /*--cef()--*/ virtual bool PostTask(CefRefPtr task) =0; /// // Post a task for delayed execution on the thread associated with this task // runner. Execution will occur asynchronously. Delayed tasks are not // supported on V8 WebWorker threads and will be executed without the // specified delay. /// /*--cef()--*/ virtual bool PostDelayedTask(CefRefPtr task, int64 delay_ms) =0; }; /// // Returns true if called on the specified thread. Equivalent to using // CefTaskRunner::GetForThread(threadId)->BelongsToCurrentThread(). /// /*--cef()--*/ bool CefCurrentlyOn(CefThreadId threadId); /// // Post a task for execution on the specified thread. Equivalent to // using CefTaskRunner::GetForThread(threadId)->PostTask(task). /// /*--cef()--*/ bool CefPostTask(CefThreadId threadId, CefRefPtr task); /// // Post a task for delayed execution on the specified thread. Equivalent to // using CefTaskRunner::GetForThread(threadId)->PostDelayedTask(task, delay_ms). /// /*--cef()--*/ bool CefPostDelayedTask(CefThreadId threadId, CefRefPtr task, int64 delay_ms); #endif // CEF_INCLUDE_CEF_TASK_H_ cefpython-49.0/src/include/cef_trace.h000066400000000000000000000110331334103266300177420ustar00rootroot00000000000000// Copyright (c) 2012 Marshall A. Greenblatt. Portons copyright (c) 2012 // Google Inc. 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. // // See cef_trace_event.h for trace macros and additonal documentation. #ifndef CEF_INCLUDE_CEF_TRACE_H_ #define CEF_INCLUDE_CEF_TRACE_H_ #pragma once #include "include/cef_base.h" #include "include/cef_callback.h" /// // Implement this interface to receive notification when tracing has completed. // The methods of this class will be called on the browser process UI thread. /// /*--cef(source=client)--*/ class CefEndTracingCallback : public virtual CefBase { public: /// // Called after all processes have sent their trace data. |tracing_file| is // the path at which tracing data was written. The client is responsible for // deleting |tracing_file|. /// /*--cef()--*/ virtual void OnEndTracingComplete(const CefString& tracing_file) =0; }; /// // Start tracing events on all processes. Tracing is initialized asynchronously // and |callback| will be executed on the UI thread after initialization is // complete. // // If CefBeginTracing was called previously, or if a CefEndTracingAsync call is // pending, CefBeginTracing will fail and return false. // // |categories| is a comma-delimited list of category wildcards. A category can // have an optional '-' prefix to make it an excluded category. Having both // included and excluded categories in the same list is not supported. // // Example: "test_MyTest*" // Example: "test_MyTest*,test_OtherStuff" // Example: "-excluded_category1,-excluded_category2" // // This function must be called on the browser process UI thread. /// /*--cef(optional_param=categories,optional_param=callback)--*/ bool CefBeginTracing(const CefString& categories, CefRefPtr callback); /// // Stop tracing events on all processes. // // This function will fail and return false if a previous call to // CefEndTracingAsync is already pending or if CefBeginTracing was not called. // // |tracing_file| is the path at which tracing data will be written and // |callback| is the callback that will be executed once all processes have // sent their trace data. If |tracing_file| is empty a new temporary file path // will be used. If |callback| is empty no trace data will be written. // // This function must be called on the browser process UI thread. /// /*--cef(optional_param=tracing_file,optional_param=callback)--*/ bool CefEndTracing(const CefString& tracing_file, CefRefPtr callback); /// // Returns the current system trace time or, if none is defined, the current // high-res time. Can be used by clients to synchronize with the time // information in trace events. /// /*--cef()--*/ int64 CefNowFromSystemTraceTime(); #endif // CEF_INCLUDE_CEF_TRACE_H_ cefpython-49.0/src/include/cef_urlrequest.h000066400000000000000000000170251334103266300210660ustar00rootroot00000000000000// 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_URLREQUEST_H_ #define CEF_INCLUDE_CEF_URLREQUEST_H_ #pragma once #include "include/cef_auth_callback.h" #include "include/cef_base.h" #include "include/cef_request.h" #include "include/cef_request_context.h" #include "include/cef_response.h" class CefURLRequestClient; /// // Class used to make a URL request. URL requests are not associated with a // browser instance so no CefClient callbacks will be executed. URL requests // can be created on any valid CEF thread in either the browser or render // process. Once created the methods of the URL request object must be accessed // on the same thread that created it. /// /*--cef(source=library)--*/ class CefURLRequest : public virtual CefBase { public: typedef cef_urlrequest_status_t Status; typedef cef_errorcode_t ErrorCode; /// // Create a new URL request. Only GET, POST, HEAD, DELETE and PUT request // methods are supported. Multiple post data elements are not supported and // elements of type PDE_TYPE_FILE are only supported for requests originating // from the browser process. Requests originating from the render process will // receive the same handling as requests originating from Web content -- if // the response contains Content-Disposition or Mime-Type header values that // would not normally be rendered then the response may receive special // handling inside the browser (for example, via the file download code path // instead of the URL request code path). The |request| object will be marked // as read-only after calling this method. In the browser process if // |request_context| is empty the global request context will be used. In the // render process |request_context| must be empty and the context associated // with the current renderer process' browser will be used. /// /*--cef(optional_param=request_context)--*/ static CefRefPtr Create( CefRefPtr request, CefRefPtr client, CefRefPtr request_context); /// // Returns the request object used to create this URL request. The returned // object is read-only and should not be modified. /// /*--cef()--*/ virtual CefRefPtr GetRequest() =0; /// // Returns the client. /// /*--cef()--*/ virtual CefRefPtr GetClient() =0; /// // Returns the request status. /// /*--cef(default_retval=UR_UNKNOWN)--*/ virtual Status GetRequestStatus() =0; /// // Returns the request error if status is UR_CANCELED or UR_FAILED, or 0 // otherwise. /// /*--cef(default_retval=ERR_NONE)--*/ virtual ErrorCode GetRequestError() =0; /// // Returns the response, or NULL if no response information is available. // Response information will only be available after the upload has completed. // The returned object is read-only and should not be modified. /// /*--cef()--*/ virtual CefRefPtr GetResponse() =0; /// // Cancel the request. /// /*--cef()--*/ virtual void Cancel() =0; }; /// // Interface that should be implemented by the CefURLRequest client. The // methods of this class will be called on the same thread that created the // request unless otherwise documented. /// /*--cef(source=client)--*/ class CefURLRequestClient : public virtual CefBase { public: /// // Notifies the client that the request has completed. Use the // CefURLRequest::GetRequestStatus method to determine if the request was // successful or not. /// /*--cef()--*/ virtual void OnRequestComplete(CefRefPtr request) =0; /// // Notifies the client of upload progress. |current| denotes the number of // bytes sent so far and |total| is the total size of uploading data (or -1 if // chunked upload is enabled). This method will only be called if the // UR_FLAG_REPORT_UPLOAD_PROGRESS flag is set on the request. /// /*--cef()--*/ virtual void OnUploadProgress(CefRefPtr request, int64 current, int64 total) =0; /// // Notifies the client of download progress. |current| denotes the number of // bytes received up to the call and |total| is the expected total size of the // response (or -1 if not determined). /// /*--cef()--*/ virtual void OnDownloadProgress(CefRefPtr request, int64 current, int64 total) =0; /// // Called when some part of the response is read. |data| contains the current // bytes received since the last call. This method will not be called if the // UR_FLAG_NO_DOWNLOAD_DATA flag is set on the request. /// /*--cef()--*/ virtual void OnDownloadData(CefRefPtr request, const void* data, size_t data_length) =0; /// // 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| contains the port number. Return true to continue the // request and call CefAuthCallback::Continue() when the authentication // information is available. Return false to cancel the request. This method // will only be called for requests initiated from the browser process. /// /*--cef(optional_param=realm)--*/ virtual bool GetAuthCredentials(bool isProxy, const CefString& host, int port, const CefString& realm, const CefString& scheme, CefRefPtr callback) =0; }; #endif // CEF_INCLUDE_CEF_URLREQUEST_H_ cefpython-49.0/src/include/cef_v8.h000066400000000000000000000675301334103266300172160ustar00rootroot00000000000000// Copyright (c) 2013 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 "include/cef_task.h" #include class CefV8Exception; class CefV8Handler; class CefV8StackFrame; 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 // only be called on the render process main 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 representing a V8 context handle. V8 handles can only be accessed from // the thread on which they are created. Valid threads for creating a V8 handle // include the render process main thread (TID_RENDERER) and WebWorker threads. // A task runner for posting tasks on the associated thread can be retrieved via // the CefV8Context::GetTaskRunner() method. /// /*--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 task runner associated with this context. V8 handles can only // be accessed from the thread on which they are created. This method can be // called on any render process thread. /// /*--cef()--*/ virtual CefRefPtr GetTaskRunner() =0; /// // Returns true if the underlying handle is valid and it can be accessed on // the current thread. Do not call any other methods if this method returns // false. /// /*--cef()--*/ virtual bool IsValid() =0; /// // Returns the browser for this context. This method will return an empty // reference for WebWorker contexts. /// /*--cef()--*/ virtual CefRefPtr GetBrowser() =0; /// // Returns the frame for this context. This method will return an empty // reference for WebWorker contexts. /// /*--cef()--*/ virtual CefRefPtr GetFrame() =0; /// // Returns the global object for this context. The context must be entered // before calling this method. /// /*--cef()--*/ virtual CefRefPtr GetGlobal() =0; /// // Enter this context. A context must be explicitly entered before creating a // V8 Object, Array, Function or Date 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; /// // Evaluates the specified JavaScript code using this context's global object. // On success |retval| will be set to the return value, if any, and the // function will return true. On failure |exception| will be set to the // exception, if any, and the function will return false. /// /*--cef()--*/ virtual bool Eval(const CefString& code, CefRefPtr& retval, CefRefPtr& exception) =0; }; typedef std::vector > CefV8ValueList; /// // Interface that should be implemented to handle V8 function calls. The methods // of this class will be called on the thread associated with the V8 function. /// /*--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 be called on the thread associated with the V8 accessor. /// /*--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. The methods of this class may be called on // any render process thread. /// /*--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 handle. V8 handles can only be accessed from // the thread on which they are created. Valid threads for creating a V8 handle // include the render process main thread (TID_RENDERER) and WebWorker threads. // A task runner for posting tasks on the associated thread can be retrieved via // the CefV8Context::GetTaskRunner() method. /// /*--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(int32 value); /// // Create a new CefV8Value object of type unsigned int. /// /*--cef()--*/ static CefRefPtr CreateUInt(uint32 value); /// // Create a new CefV8Value object of type double. /// /*--cef()--*/ static CefRefPtr CreateDouble(double value); /// // Create a new CefV8Value object of type Date. This method should only be // called from within the scope of a CefRenderProcessHandler, CefV8Handler or // CefV8Accessor callback, or in combination with calling Enter() and Exit() // on a stored CefV8Context reference. /// /*--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 accessor. This // method should only be called from within the scope of a // CefRenderProcessHandler, CefV8Handler or CefV8Accessor callback, or in // combination with calling Enter() and Exit() on a stored CefV8Context // reference. /// /*--cef(optional_param=accessor)--*/ static CefRefPtr CreateObject(CefRefPtr accessor); /// // Create a new CefV8Value object of type array with the specified |length|. // If |length| is negative the returned array will have length 0. This method // should only be called from within the scope of a CefRenderProcessHandler, // CefV8Handler or CefV8Accessor callback, or in combination with calling // Enter() and Exit() on a stored CefV8Context reference. /// /*--cef()--*/ static CefRefPtr CreateArray(int length); /// // Create a new CefV8Value object of type function. This method should only be // called from within the scope of a CefRenderProcessHandler, 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); /// // Returns true if the underlying handle is valid and it can be accessed on // the current thread. Do not call any other methods if this method returns // false. /// /*--cef()--*/ virtual bool IsValid() =0; /// // 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 unsigned int. /// /*--cef()--*/ virtual bool IsUInt() =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 int32 GetIntValue() =0; /// // Return an unisgned int value. The underlying data will be converted to if // necessary. /// /*--cef()--*/ virtual uint32 GetUIntValue() =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 this is a user created object. /// /*--cef()--*/ virtual bool IsUserCreated() =0; /// // Returns true if the last method call resulted in an exception. This // attribute exists only in the scope of the current CEF value object. /// /*--cef()--*/ virtual bool HasException() =0; /// // Returns the exception resulting from the last method call. This attribute // exists only in the scope of the current CEF value object. /// /*--cef()--*/ virtual CefRefPtr GetException() =0; /// // Clears the last exception and returns true on success. /// /*--cef()--*/ virtual bool ClearException() =0; /// // Returns true if this object will re-throw future exceptions. This attribute // exists only in the scope of the current CEF value object. /// /*--cef()--*/ virtual bool WillRethrowExceptions() =0; /// // Set whether this object will re-throw future exceptions. By default // exceptions are not re-thrown. If a exception is re-thrown the current // context should not be accessed again until after the exception has been // caught and not re-thrown. Returns true on success. This attribute exists // only in the scope of the current CEF value object. /// /*--cef()--*/ virtual bool SetRethrowExceptions(bool rethrow) =0; /// // Returns true if the object has a value with the specified identifier. /// /*--cef(capi_name=has_value_bykey,optional_param=key)--*/ 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; /// // Deletes the value with the specified identifier and returns true on // success. Returns false if this method is called incorrectly or an exception // is thrown. For read-only and don't-delete values this method will return // true even though deletion failed. /// /*--cef(capi_name=delete_value_bykey,optional_param=key)--*/ virtual bool DeleteValue(const CefString& key) =0; /// // Deletes the value with the specified identifier and returns true on // success. Returns false if this method is called incorrectly, deletion fails // or an exception is thrown. For read-only and don't-delete values this // method will return true even though deletion failed. /// /*--cef(capi_name=delete_value_byindex,index_param=index)--*/ virtual bool DeleteValue(int index) =0; /// // Returns the value with the specified identifier on success. Returns NULL // if this method is called incorrectly or an exception is thrown. /// /*--cef(capi_name=get_value_bykey,optional_param=key)--*/ virtual CefRefPtr GetValue(const CefString& key) =0; /// // Returns the value with the specified identifier on success. Returns NULL // if this method is called incorrectly or an exception is thrown. /// /*--cef(capi_name=get_value_byindex,index_param=index)--*/ virtual CefRefPtr GetValue(int index) =0; /// // Associates a value with the specified identifier and returns true on // success. Returns false if this method is called incorrectly or an exception // is thrown. For read-only values this method will return true even though // assignment failed. /// /*--cef(capi_name=set_value_bykey,optional_param=key)--*/ virtual bool SetValue(const CefString& key, CefRefPtr value, PropertyAttribute attribute) =0; /// // Associates a value with the specified identifier and returns true on // success. Returns false if this method is called incorrectly or an exception // is thrown. For read-only values this method will return true even though // assignment failed. /// /*--cef(capi_name=set_value_byindex,index_param=index)--*/ virtual bool SetValue(int index, CefRefPtr value) =0; /// // Registers an identifier and returns true on success. Access to the // identifier will be forwarded to the CefV8Accessor instance passed to // CefV8Value::CreateObject(). Returns false if this method is called // incorrectly or an exception is thrown. For read-only values this method // will return true even though assignment failed. /// /*--cef(capi_name=set_value_byaccessor,optional_param=key)--*/ 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; /// // Sets the user data for this object and returns true on success. Returns // false if this method is called incorrectly. This method can only be called // on user created objects. /// /*--cef(optional_param=user_data)--*/ virtual bool SetUserData(CefRefPtr user_data) =0; /// // Returns the user data, if any, assigned to this object. /// /*--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. This method can // only be called on user created objects. /// /*--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. If |object| is empty the current context's global object will be // used. |arguments| is the list of arguments that will be passed to the // function. Returns the function return value on success. Returns NULL if // this method is called incorrectly or an exception is thrown. /// /*--cef(optional_param=object)--*/ virtual CefRefPtr ExecuteFunction( CefRefPtr object, const CefV8ValueList& arguments) =0; /// // Execute the function using the specified V8 context. |object| is the // receiver ('this' object) of the function. If |object| is empty the // specified context's global object will be used. |arguments| is the list of // arguments that will be passed to the function. Returns the function return // value on success. Returns NULL if this method is called incorrectly or an // exception is thrown. /// /*--cef(optional_param=object)--*/ virtual CefRefPtr ExecuteFunctionWithContext( CefRefPtr context, CefRefPtr object, const CefV8ValueList& arguments) =0; }; /// // Class representing a V8 stack trace handle. V8 handles can only be accessed // from the thread on which they are created. Valid threads for creating a V8 // handle include the render process main thread (TID_RENDERER) and WebWorker // threads. A task runner for posting tasks on the associated thread can be // retrieved via the CefV8Context::GetTaskRunner() method. /// /*--cef(source=library)--*/ class CefV8StackTrace : public virtual CefBase { public: /// // Returns the stack trace for the currently active context. |frame_limit| is // the maximum number of frames that will be captured. /// /*--cef()--*/ static CefRefPtr GetCurrent(int frame_limit); /// // Returns true if the underlying handle is valid and it can be accessed on // the current thread. Do not call any other methods if this method returns // false. /// /*--cef()--*/ virtual bool IsValid() =0; /// // Returns the number of stack frames. /// /*--cef()--*/ virtual int GetFrameCount() =0; /// // Returns the stack frame at the specified 0-based index. /// /*--cef()--*/ virtual CefRefPtr GetFrame(int index) =0; }; /// // Class representing a V8 stack frame handle. V8 handles can only be accessed // from the thread on which they are created. Valid threads for creating a V8 // handle include the render process main thread (TID_RENDERER) and WebWorker // threads. A task runner for posting tasks on the associated thread can be // retrieved via the CefV8Context::GetTaskRunner() method. /// /*--cef(source=library)--*/ class CefV8StackFrame : public virtual CefBase { public: /// // Returns true if the underlying handle is valid and it can be accessed on // the current thread. Do not call any other methods if this method returns // false. /// /*--cef()--*/ virtual bool IsValid() =0; /// // Returns the name of the resource script that contains the function. /// /*--cef()--*/ virtual CefString GetScriptName() =0; /// // Returns the name of the resource script that contains the function or the // sourceURL value if the script name is undefined and its source ends with // a "//@ sourceURL=..." string. /// /*--cef()--*/ virtual CefString GetScriptNameOrSourceURL() =0; /// // Returns the name of the function. /// /*--cef()--*/ virtual CefString GetFunctionName() =0; /// // Returns the 1-based line number for the function call or 0 if unknown. /// /*--cef()--*/ virtual int GetLineNumber() =0; /// // Returns the 1-based column offset on the line for the function call or 0 if // unknown. /// /*--cef()--*/ virtual int GetColumn() =0; /// // Returns true if the function was compiled using eval(). /// /*--cef()--*/ virtual bool IsEval() =0; /// // Returns true if the function was called as a constructor via "new". /// /*--cef()--*/ virtual bool IsConstructor() =0; }; #endif // CEF_INCLUDE_CEF_V8_H_ cefpython-49.0/src/include/cef_values.h000066400000000000000000000566051334103266300201610ustar00rootroot00000000000000// 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_VALUES_H_ #define CEF_INCLUDE_CEF_VALUES_H_ #pragma once #include #include "include/cef_base.h" class CefBinaryValue; class CefDictionaryValue; class CefListValue; typedef cef_value_type_t CefValueType; /// // Class that wraps other data value types. Complex types (binary, dictionary // and list) will be referenced but not owned by this object. Can be used on any // process and thread. /// /*--cef(source=library)--*/ class CefValue : public virtual CefBase { public: /// // Creates a new object. /// /*--cef()--*/ static CefRefPtr Create(); /// // Returns true if the underlying data is valid. This will always be true for // simple types. For complex types (binary, dictionary and list) the // underlying data may become invalid if owned by another object (e.g. list or // dictionary) and that other object is then modified or destroyed. This value // object can be re-used by calling Set*() even if the underlying data is // invalid. /// /*--cef()--*/ virtual bool IsValid() =0; /// // Returns true if the underlying data is owned by another object. /// /*--cef()--*/ virtual bool IsOwned() =0; /// // Returns true if the underlying data is read-only. Some APIs may expose // read-only objects. /// /*--cef()--*/ virtual bool IsReadOnly() =0; /// // Returns true if this object and |that| object have the same underlying // data. If true modifications to this object will also affect |that| object // and vice-versa. /// /*--cef()--*/ virtual bool IsSame(CefRefPtr that) =0; /// // Returns true if this object and |that| object have an equivalent underlying // value but are not necessarily the same object. /// /*--cef()--*/ virtual bool IsEqual(CefRefPtr that) =0; /// // Returns a copy of this object. The underlying data will also be copied. /// /*--cef()--*/ virtual CefRefPtr Copy() =0; /// // Returns the underlying value type. /// /*--cef(default_retval=VTYPE_INVALID)--*/ virtual CefValueType GetType() =0; /// // Returns the underlying value as type bool. /// /*--cef()--*/ virtual bool GetBool() =0; /// // Returns the underlying value as type int. /// /*--cef()--*/ virtual int GetInt() =0; /// // Returns the underlying value as type double. /// /*--cef()--*/ virtual double GetDouble() =0; /// // Returns the underlying value as type string. /// /*--cef()--*/ virtual CefString GetString() =0; /// // Returns the underlying value as type binary. The returned reference may // become invalid if the value is owned by another object or if ownership is // transferred to another object in the future. To maintain a reference to // the value after assigning ownership to a dictionary or list pass this // object to the SetValue() method instead of passing the returned reference // to SetBinary(). /// /*--cef()--*/ virtual CefRefPtr GetBinary() =0; /// // Returns the underlying value as type dictionary. The returned reference may // become invalid if the value is owned by another object or if ownership is // transferred to another object in the future. To maintain a reference to // the value after assigning ownership to a dictionary or list pass this // object to the SetValue() method instead of passing the returned reference // to SetDictionary(). /// /*--cef()--*/ virtual CefRefPtr GetDictionary() =0; /// // Returns the underlying value as type list. The returned reference may // become invalid if the value is owned by another object or if ownership is // transferred to another object in the future. To maintain a reference to // the value after assigning ownership to a dictionary or list pass this // object to the SetValue() method instead of passing the returned reference // to SetList(). /// /*--cef()--*/ virtual CefRefPtr GetList() =0; /// // Sets the underlying value as type null. Returns true if the value was set // successfully. /// /*--cef()--*/ virtual bool SetNull() =0; /// // Sets the underlying value as type bool. Returns true if the value was set // successfully. /// /*--cef()--*/ virtual bool SetBool(bool value) =0; /// // Sets the underlying value as type int. Returns true if the value was set // successfully. /// /*--cef()--*/ virtual bool SetInt(int value) =0; /// // Sets the underlying value as type double. Returns true if the value was set // successfully. /// /*--cef()--*/ virtual bool SetDouble(double value) =0; /// // Sets the underlying value as type string. Returns true if the value was set // successfully. /// /*--cef(optional_param=value)--*/ virtual bool SetString(const CefString& value) =0; /// // Sets the underlying value as type binary. Returns true if the value was set // successfully. This object keeps a reference to |value| and ownership of the // underlying data remains unchanged. /// /*--cef()--*/ virtual bool SetBinary(CefRefPtr value) =0; /// // Sets the underlying value as type dict. Returns true if the value was set // successfully. This object keeps a reference to |value| and ownership of the // underlying data remains unchanged. /// /*--cef()--*/ virtual bool SetDictionary(CefRefPtr value) =0; /// // Sets the underlying value as type list. Returns true if the value was set // successfully. This object keeps a reference to |value| and ownership of the // underlying data remains unchanged. /// /*--cef()--*/ virtual bool SetList(CefRefPtr value) =0; }; /// // Class representing a binary value. Can be used on any process and thread. /// /*--cef(source=library)--*/ class CefBinaryValue : public virtual CefBase { public: /// // Creates a new object that is not owned by any other object. The specified // |data| will be copied. /// /*--cef()--*/ static CefRefPtr Create(const void* data, size_t data_size); /// // Returns true if this object is valid. This object may become invalid if // the underlying data is owned by another object (e.g. list or dictionary) // and that other object is then modified or destroyed. Do not call any other // methods if this method returns false. /// /*--cef()--*/ virtual bool IsValid() =0; /// // Returns true if this object is currently owned by another object. /// /*--cef()--*/ virtual bool IsOwned() =0; /// // Returns true if this object and |that| object have the same underlying // data. /// /*--cef()--*/ virtual bool IsSame(CefRefPtr that) =0; /// // Returns true if this object and |that| object have an equivalent underlying // value but are not necessarily the same object. /// /*--cef()--*/ virtual bool IsEqual(CefRefPtr that) =0; /// // Returns a copy of this object. The data in this object will also be copied. /// /*--cef()--*/ virtual CefRefPtr Copy() =0; /// // Returns the data size. /// /*--cef()--*/ virtual size_t GetSize() =0; /// // Read up to |buffer_size| number of bytes into |buffer|. Reading begins at // the specified byte |data_offset|. Returns the number of bytes read. /// /*--cef()--*/ virtual size_t GetData(void* buffer, size_t buffer_size, size_t data_offset) =0; }; /// // Class representing a dictionary value. Can be used on any process and thread. /// /*--cef(source=library)--*/ class CefDictionaryValue : public virtual CefBase { public: typedef std::vector KeyList; /// // Creates a new object that is not owned by any other object. /// /*--cef()--*/ static CefRefPtr Create(); /// // Returns true if this object is valid. This object may become invalid if // the underlying data is owned by another object (e.g. list or dictionary) // and that other object is then modified or destroyed. Do not call any other // methods if this method returns false. /// /*--cef()--*/ virtual bool IsValid() =0; /// // Returns true if this object is currently owned by another object. /// /*--cef()--*/ virtual bool IsOwned() =0; /// // Returns true if the values of this object are read-only. Some APIs may // expose read-only objects. /// /*--cef()--*/ virtual bool IsReadOnly() =0; /// // Returns true if this object and |that| object have the same underlying // data. If true modifications to this object will also affect |that| object // and vice-versa. /// /*--cef()--*/ virtual bool IsSame(CefRefPtr that) =0; /// // Returns true if this object and |that| object have an equivalent underlying // value but are not necessarily the same object. /// /*--cef()--*/ virtual bool IsEqual(CefRefPtr that) =0; /// // Returns a writable copy of this object. If |exclude_empty_children| is true // any empty dictionaries or lists will be excluded from the copy. /// /*--cef()--*/ virtual CefRefPtr Copy(bool exclude_empty_children) =0; /// // Returns the number of values. /// /*--cef()--*/ virtual size_t GetSize() =0; /// // Removes all values. Returns true on success. /// /*--cef()--*/ virtual bool Clear() =0; /// // Returns true if the current dictionary has a value for the given key. /// /*--cef()--*/ virtual bool HasKey(const CefString& key) =0; /// // Reads all keys for this dictionary into the specified vector. /// /*--cef()--*/ virtual bool GetKeys(KeyList& keys) =0; /// // Removes the value at the specified key. Returns true is the value was // removed successfully. /// /*--cef()--*/ virtual bool Remove(const CefString& key) =0; /// // Returns the value type for the specified key. /// /*--cef(default_retval=VTYPE_INVALID)--*/ virtual CefValueType GetType(const CefString& key) =0; /// // Returns the value at the specified key. For simple types the returned // value will copy existing data and modifications to the value will not // modify this object. For complex types (binary, dictionary and list) the // returned value will reference existing data and modifications to the value // will modify this object. /// /*--cef()--*/ virtual CefRefPtr GetValue(const CefString& key) =0; /// // Returns the value at the specified key as type bool. /// /*--cef()--*/ virtual bool GetBool(const CefString& key) =0; /// // Returns the value at the specified key as type int. /// /*--cef()--*/ virtual int GetInt(const CefString& key) =0; /// // Returns the value at the specified key as type double. /// /*--cef()--*/ virtual double GetDouble(const CefString& key) =0; /// // Returns the value at the specified key as type string. /// /*--cef()--*/ virtual CefString GetString(const CefString& key) =0; /// // Returns the value at the specified key as type binary. The returned // value will reference existing data. /// /*--cef()--*/ virtual CefRefPtr GetBinary(const CefString& key) =0; /// // Returns the value at the specified key as type dictionary. The returned // value will reference existing data and modifications to the value will // modify this object. /// /*--cef()--*/ virtual CefRefPtr GetDictionary(const CefString& key) =0; /// // Returns the value at the specified key as type list. The returned value // will reference existing data and modifications to the value will modify // this object. /// /*--cef()--*/ virtual CefRefPtr GetList(const CefString& key) =0; /// // Sets the value at the specified key. Returns true if the value was set // successfully. If |value| represents simple data then the underlying data // will be copied and modifications to |value| will not modify this object. If // |value| represents complex data (binary, dictionary or list) then the // underlying data will be referenced and modifications to |value| will modify // this object. /// /*--cef()--*/ virtual bool SetValue(const CefString& key, CefRefPtr value) =0; /// // Sets the value at the specified key as type null. Returns true if the // value was set successfully. /// /*--cef()--*/ virtual bool SetNull(const CefString& key) =0; /// // Sets the value at the specified key as type bool. Returns true if the // value was set successfully. /// /*--cef()--*/ virtual bool SetBool(const CefString& key, bool value) =0; /// // Sets the value at the specified key as type int. Returns true if the // value was set successfully. /// /*--cef()--*/ virtual bool SetInt(const CefString& key, int value) =0; /// // Sets the value at the specified key as type double. Returns true if the // value was set successfully. /// /*--cef()--*/ virtual bool SetDouble(const CefString& key, double value) =0; /// // Sets the value at the specified key as type string. Returns true if the // value was set successfully. /// /*--cef(optional_param=value)--*/ virtual bool SetString(const CefString& key, const CefString& value) =0; /// // Sets the value at the specified key as type binary. Returns true if the // value was set successfully. If |value| is currently owned by another object // then the value will be copied and the |value| reference will not change. // Otherwise, ownership will be transferred to this object and the |value| // reference will be invalidated. /// /*--cef()--*/ virtual bool SetBinary(const CefString& key, CefRefPtr value) =0; /// // Sets the value at the specified key as type dict. Returns true if the // value was set successfully. If |value| is currently owned by another object // then the value will be copied and the |value| reference will not change. // Otherwise, ownership will be transferred to this object and the |value| // reference will be invalidated. /// /*--cef()--*/ virtual bool SetDictionary(const CefString& key, CefRefPtr value) =0; /// // Sets the value at the specified key as type list. Returns true if the // value was set successfully. If |value| is currently owned by another object // then the value will be copied and the |value| reference will not change. // Otherwise, ownership will be transferred to this object and the |value| // reference will be invalidated. /// /*--cef()--*/ virtual bool SetList(const CefString& key, CefRefPtr value) =0; }; /// // Class representing a list value. Can be used on any process and thread. /// /*--cef(source=library)--*/ class CefListValue : public virtual CefBase { public: /// // Creates a new object that is not owned by any other object. /// /*--cef()--*/ static CefRefPtr Create(); /// // Returns true if this object is valid. This object may become invalid if // the underlying data is owned by another object (e.g. list or dictionary) // and that other object is then modified or destroyed. Do not call any other // methods if this method returns false. /// /*--cef()--*/ virtual bool IsValid() =0; /// // Returns true if this object is currently owned by another object. /// /*--cef()--*/ virtual bool IsOwned() =0; /// // Returns true if the values of this object are read-only. Some APIs may // expose read-only objects. /// /*--cef()--*/ virtual bool IsReadOnly() =0; /// // Returns true if this object and |that| object have the same underlying // data. If true modifications to this object will also affect |that| object // and vice-versa. /// /*--cef()--*/ virtual bool IsSame(CefRefPtr that) =0; /// // Returns true if this object and |that| object have an equivalent underlying // value but are not necessarily the same object. /// /*--cef()--*/ virtual bool IsEqual(CefRefPtr that) =0; /// // Returns a writable copy of this object. /// /*--cef()--*/ virtual CefRefPtr Copy() =0; /// // Sets the number of values. If the number of values is expanded all // new value slots will default to type null. Returns true on success. /// /*--cef()--*/ virtual bool SetSize(size_t size) =0; /// // Returns the number of values. /// /*--cef()--*/ virtual size_t GetSize() =0; /// // Removes all values. Returns true on success. /// /*--cef()--*/ virtual bool Clear() =0; /// // Removes the value at the specified index. /// /*--cef(index_param=index)--*/ virtual bool Remove(int index) =0; /// // Returns the value type at the specified index. /// /*--cef(default_retval=VTYPE_INVALID,index_param=index)--*/ virtual CefValueType GetType(int index) =0; /// // Returns the value at the specified index. For simple types the returned // value will copy existing data and modifications to the value will not // modify this object. For complex types (binary, dictionary and list) the // returned value will reference existing data and modifications to the value // will modify this object. /// /*--cef(index_param=index)--*/ virtual CefRefPtr GetValue(int index) =0; /// // Returns the value at the specified index as type bool. /// /*--cef(index_param=index)--*/ virtual bool GetBool(int index) =0; /// // Returns the value at the specified index as type int. /// /*--cef(index_param=index)--*/ virtual int GetInt(int index) =0; /// // Returns the value at the specified index as type double. /// /*--cef(index_param=index)--*/ virtual double GetDouble(int index) =0; /// // Returns the value at the specified index as type string. /// /*--cef(index_param=index)--*/ virtual CefString GetString(int index) =0; /// // Returns the value at the specified index as type binary. The returned // value will reference existing data. /// /*--cef(index_param=index)--*/ virtual CefRefPtr GetBinary(int index) =0; /// // Returns the value at the specified index as type dictionary. The returned // value will reference existing data and modifications to the value will // modify this object. /// /*--cef(index_param=index)--*/ virtual CefRefPtr GetDictionary(int index) =0; /// // Returns the value at the specified index as type list. The returned // value will reference existing data and modifications to the value will // modify this object. /// /*--cef(index_param=index)--*/ virtual CefRefPtr GetList(int index) =0; /// // Sets the value at the specified index. Returns true if the value was set // successfully. If |value| represents simple data then the underlying data // will be copied and modifications to |value| will not modify this object. If // |value| represents complex data (binary, dictionary or list) then the // underlying data will be referenced and modifications to |value| will modify // this object. /// /*--cef(index_param=index)--*/ virtual bool SetValue(int index, CefRefPtr value) =0; /// // Sets the value at the specified index as type null. Returns true if the // value was set successfully. /// /*--cef(index_param=index)--*/ virtual bool SetNull(int index) =0; /// // Sets the value at the specified index as type bool. Returns true if the // value was set successfully. /// /*--cef(index_param=index)--*/ virtual bool SetBool(int index, bool value) =0; /// // Sets the value at the specified index as type int. Returns true if the // value was set successfully. /// /*--cef(index_param=index)--*/ virtual bool SetInt(int index, int value) =0; /// // Sets the value at the specified index as type double. Returns true if the // value was set successfully. /// /*--cef(index_param=index)--*/ virtual bool SetDouble(int index, double value) =0; /// // Sets the value at the specified index as type string. Returns true if the // value was set successfully. /// /*--cef(optional_param=value,index_param=index)--*/ virtual bool SetString(int index, const CefString& value) =0; /// // Sets the value at the specified index as type binary. Returns true if the // value was set successfully. If |value| is currently owned by another object // then the value will be copied and the |value| reference will not change. // Otherwise, ownership will be transferred to this object and the |value| // reference will be invalidated. /// /*--cef(index_param=index)--*/ virtual bool SetBinary(int index, CefRefPtr value) =0; /// // Sets the value at the specified index as type dict. Returns true if the // value was set successfully. If |value| is currently owned by another object // then the value will be copied and the |value| reference will not change. // Otherwise, ownership will be transferred to this object and the |value| // reference will be invalidated. /// /*--cef(index_param=index)--*/ virtual bool SetDictionary(int index, CefRefPtr value) =0; /// // Sets the value at the specified index as type list. Returns true if the // value was set successfully. If |value| is currently owned by another object // then the value will be copied and the |value| reference will not change. // Otherwise, ownership will be transferred to this object and the |value| // reference will be invalidated. /// /*--cef(index_param=index)--*/ virtual bool SetList(int index, CefRefPtr value) =0; }; #endif // CEF_INCLUDE_CEF_VALUES_H_ cefpython-49.0/src/include/cef_web_plugin.h000066400000000000000000000134031334103266300210020ustar00rootroot00000000000000// 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 CefBrowser; /// // 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; }; /// // Interface to implement for visiting web plugin information. The methods of // this class will be called on the browser process UI thread. /// /*--cef(source=client)--*/ class CefWebPluginInfoVisitor : public virtual CefBase { public: /// // Method that will be called once for each plugin. |count| is the 0-based // index for the current plugin. |total| is the total number of plugins. // Return false to stop visiting plugins. This method may never be called if // no plugins are found. /// /*--cef()--*/ virtual bool Visit(CefRefPtr info, int count, int total) =0; }; /// // Visit web plugin information. Can be called on any thread in the browser // process. /// /*--cef()--*/ void CefVisitWebPluginInfo(CefRefPtr visitor); /// // Cause the plugin list to refresh the next time it is accessed regardless // of whether it has already been loaded. Can be called on any thread in the // browser process. /// /*--cef()--*/ void CefRefreshWebPlugins(); /// // Add a plugin path (directory + file). This change may not take affect until // after CefRefreshWebPlugins() is called. Can be called on any thread in the // browser process. /// /*--cef()--*/ void CefAddWebPluginPath(const CefString& path); /// // Add a plugin directory. This change may not take affect until after // CefRefreshWebPlugins() is called. Can be called on any thread in the browser // process. /// /*--cef()--*/ void CefAddWebPluginDirectory(const CefString& dir); /// // Remove a plugin path (directory + file). This change may not take affect // until after CefRefreshWebPlugins() is called. Can be called on any thread in // the browser process. /// /*--cef()--*/ void CefRemoveWebPluginPath(const CefString& path); /// // Unregister an internal plugin. This may be undone the next time // CefRefreshWebPlugins() is called. Can be called on any thread in the browser // process. /// /*--cef()--*/ void CefUnregisterInternalWebPlugin(const CefString& path); /// // Force a plugin to shutdown. Can be called on any thread in the browser // process but will be executed on the IO thread. /// /*--cef()--*/ void CefForceWebPluginShutdown(const CefString& path); /// // Register a plugin crash. Can be called on any thread in the browser process // but will be executed on the IO thread. /// /*--cef()--*/ void CefRegisterWebPluginCrash(const CefString& path); /// // Interface to implement for receiving unstable plugin information. The methods // of this class will be called on the browser process IO thread. /// /*--cef(source=client)--*/ class CefWebPluginUnstableCallback : public virtual CefBase { public: /// // Method that will be called for the requested plugin. |unstable| will be // true if the plugin has reached the crash count threshold of 3 times in 120 // seconds. /// /*--cef()--*/ virtual void IsUnstable(const CefString& path, bool unstable) =0; }; /// // Query if a plugin is unstable. Can be called on any thread in the browser // process. /// /*--cef()--*/ void CefIsWebPluginUnstable(const CefString& path, CefRefPtr callback); #endif // CEF_INCLUDE_CEF_WEB_PLUGIN_H_ cefpython-49.0/src/include/cef_xml_reader.h000066400000000000000000000203061334103266300207710ustar00rootroot00000000000000// 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_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_ cefpython-49.0/src/include/cef_zip_reader.h000066400000000000000000000107551334103266300210020ustar00rootroot00000000000000// 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_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 CefTime 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_ cefpython-49.0/src/include/internal/000077500000000000000000000000001334103266300174745ustar00rootroot00000000000000cefpython-49.0/src/include/internal/cef_export.h000066400000000000000000000041741334103266300220110ustar00rootroot00000000000000// Copyright (c) 2009 The Chromium Embedded Framework Authors. 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_INTERNAL_CEF_EXPORT_H_ #define CEF_INCLUDE_INTERNAL_CEF_EXPORT_H_ #pragma once #include "include/base/cef_build.h" #if defined(COMPILER_MSVC) #ifdef BUILDING_CEF_SHARED #define CEF_EXPORT __declspec(dllexport) #elif USING_CEF_SHARED #define CEF_EXPORT __declspec(dllimport) #else #define CEF_EXPORT #endif #define CEF_CALLBACK __stdcall #elif defined(COMPILER_GCC) #define CEF_EXPORT __attribute__ ((visibility("default"))) #define CEF_CALLBACK #endif // COMPILER_GCC #endif // CEF_INCLUDE_INTERNAL_CEF_EXPORT_H_ cefpython-49.0/src/include/internal/cef_linux.h000066400000000000000000000116021334103266300216210ustar00rootroot00000000000000// Copyright (c) 2010 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_INTERNAL_CEF_LINUX_H_ #define CEF_INCLUDE_INTERNAL_CEF_LINUX_H_ #pragma once #include "include/internal/cef_types_linux.h" #include "include/internal/cef_types_wrappers.h" // Handle types. #define CefCursorHandle cef_cursor_handle_t #define CefEventHandle cef_event_handle_t #define CefWindowHandle cef_window_handle_t #define CefTextInputContext cef_text_input_context_t struct CefMainArgsTraits { typedef cef_main_args_t struct_type; static inline void init(struct_type* s) {} static inline void clear(struct_type* s) {} static inline void set(const struct_type* src, struct_type* target, bool copy) { target->argc = src->argc; target->argv = src->argv; } }; // Class representing CefExecuteProcess arguments. class CefMainArgs : public CefStructBase { public: typedef CefStructBase parent; CefMainArgs() : parent() {} explicit CefMainArgs(const cef_main_args_t& r) : parent(r) {} explicit CefMainArgs(const CefMainArgs& r) : parent(r) {} CefMainArgs(int argc_arg, char** argv_arg) : parent() { argc = argc_arg; argv = argv_arg; } }; struct CefWindowInfoTraits { typedef cef_window_info_t struct_type; static inline void init(struct_type* s) {} static inline void clear(struct_type* s) {} static inline void set(const struct_type* src, struct_type* target, bool copy) { target->x = src->x; target->y = src->y; target->width = src->width; target->height = src->height; target->parent_window = src->parent_window; target->windowless_rendering_enabled = src->windowless_rendering_enabled; target->transparent_painting_enabled = src->transparent_painting_enabled; target->window = src->window; } }; // Class representing window information. class CefWindowInfo : public CefStructBase { public: typedef CefStructBase parent; CefWindowInfo() : parent() {} explicit CefWindowInfo(const cef_window_info_t& r) : parent(r) {} explicit CefWindowInfo(const CefWindowInfo& r) : parent(r) {} /// // Create the browser as a child window. /// void SetAsChild(CefWindowHandle parent, const CefRect& windowRect) { parent_window = parent; x = windowRect.x; y = windowRect.y; width = windowRect.width; height = windowRect.height; } /// // Create the browser using windowless (off-screen) rendering. No window // will be created for the browser and all rendering will occur via the // CefRenderHandler interface. The |parent| value will be used to identify // monitor info and to act as the parent window for dialogs, context menus, // etc. If |parent| is not provided then the main screen monitor will be used // and some functionality that requires a parent window may not function // correctly. If |transparent| is true a transparent background color will be // used (RGBA=0x00000000). If |transparent| is false the background will be // white and opaque. In order to create windowless browsers the // CefSettings.windowless_rendering_enabled value must be set to true. /// void SetAsWindowless(CefWindowHandle parent, bool transparent) { windowless_rendering_enabled = true; parent_window = parent; transparent_painting_enabled = transparent; } }; #endif // CEF_INCLUDE_INTERNAL_CEF_LINUX_H_ cefpython-49.0/src/include/internal/cef_logging_internal.h000066400000000000000000000047421334103266300240130ustar00rootroot00000000000000// Copyright (c) 2014 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_INTERNAL_CEF_LOGGING_INTERNAL_H_ #define CEF_INCLUDE_INTERNAL_CEF_LOGGING_INTERNAL_H_ #pragma once #include "include/internal/cef_export.h" #ifdef __cplusplus extern "C" { #endif // See include/base/cef_logging.h for macros and intended usage. /// // Gets the current log level. /// CEF_EXPORT int cef_get_min_log_level(); /// // Gets the current vlog level for the given file (usually taken from // __FILE__). Note that |N| is the size *with* the null terminator. /// CEF_EXPORT int cef_get_vlog_level(const char* file_start, size_t N); /// // Add a log message. See the LogSeverity defines for supported |severity| // values. /// CEF_EXPORT void cef_log(const char* file, int line, int severity, const char* message); #ifdef __cplusplus } #endif // __cplusplus #endif // CEF_INCLUDE_INTERNAL_CEF_LOGGING_INTERNAL_H_ cefpython-49.0/src/include/internal/cef_mac.h000066400000000000000000000120401334103266300212170ustar00rootroot00000000000000// Copyright (c) 2010 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_INTERNAL_CEF_MAC_H_ #define CEF_INCLUDE_INTERNAL_CEF_MAC_H_ #pragma once #include "include/internal/cef_types_mac.h" #include "include/internal/cef_types_wrappers.h" // Handle types. #define CefCursorHandle cef_cursor_handle_t #define CefEventHandle cef_event_handle_t #define CefWindowHandle cef_window_handle_t #define CefTextInputContext cef_text_input_context_t struct CefMainArgsTraits { typedef cef_main_args_t struct_type; static inline void init(struct_type* s) {} static inline void clear(struct_type* s) {} static inline void set(const struct_type* src, struct_type* target, bool copy) { target->argc = src->argc; target->argv = src->argv; } }; // Class representing CefExecuteProcess arguments. class CefMainArgs : public CefStructBase { public: typedef CefStructBase parent; CefMainArgs() : parent() {} explicit CefMainArgs(const cef_main_args_t& r) : parent(r) {} explicit CefMainArgs(const CefMainArgs& r) : parent(r) {} CefMainArgs(int argc, char** argv) : parent() { this->argc = argc; this->argv = argv; } }; struct CefWindowInfoTraits { typedef cef_window_info_t struct_type; static inline void init(struct_type* s) {} static inline void clear(struct_type* s) { cef_string_clear(&s->window_name); } static inline void set(const struct_type* src, struct_type* target, bool copy) { cef_string_set(src->window_name.str, src->window_name.length, &target->window_name, copy); target->x = src->x; target->y = src->y; target->width = src->width; target->height = src->height; target->hidden = src->hidden; target->parent_view = src->parent_view; target->windowless_rendering_enabled = src->windowless_rendering_enabled; target->transparent_painting_enabled = src->transparent_painting_enabled; target->view = src->view; } }; // Class representing window information. class CefWindowInfo : public CefStructBase { public: typedef CefStructBase parent; CefWindowInfo() : parent() {} explicit CefWindowInfo(const cef_window_info_t& r) : parent(r) {} explicit CefWindowInfo(const CefWindowInfo& r) : parent(r) {} /// // Create the browser as a child view. /// void SetAsChild(CefWindowHandle parent, int x, int y, int width, int height) { parent_view = parent; this->x = x; this->y = y; this->width = width; this->height = height; hidden = false; } /// // Create the browser using windowless (off-screen) rendering. No view // will be created for the browser and all rendering will occur via the // CefRenderHandler interface. The |parent| value will be used to identify // monitor info and to act as the parent view for dialogs, context menus, // etc. If |parent| is not provided then the main screen monitor will be used // and some functionality that requires a parent view may not function // correctly. If |transparent| is true a transparent background color will be // used (RGBA=0x00000000). If |transparent| is false the background will be // white and opaque. In order to create windowless browsers the // CefSettings.windowless_rendering_enabled value must be set to true. /// void SetAsWindowless(CefWindowHandle parent, bool transparent) { windowless_rendering_enabled = true; parent_view = parent; transparent_painting_enabled = transparent; } }; #endif // CEF_INCLUDE_INTERNAL_CEF_MAC_H_ cefpython-49.0/src/include/internal/cef_ptr.h000066400000000000000000000132271334103266300212740ustar00rootroot00000000000000// Copyright (c) 2014 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_INTERNAL_CEF_PTR_H_ #define CEF_INCLUDE_INTERNAL_CEF_PTR_H_ #pragma once #include "include/base/cef_ref_counted.h" /// // Smart pointer implementation that is an alias of scoped_refptr from // include/base/cef_ref_counted.h. //

// A smart pointer class for reference counted objects. Use this class instead // of calling AddRef and Release manually on a reference counted object to // avoid common memory leaks caused by forgetting to Release an object // reference. Sample usage: // 

//   class MyFoo : public CefBase {
//    ...
//   };
//
//   void some_function() {
//     // The MyFoo object that |foo| represents starts with a single
//     // reference.
//     CefRefPtr<MyFoo> foo = new MyFoo();
//     foo->Method(param);
//     // |foo| is released when this function returns
//   }
//
//   void some_other_function() {
//     CefRefPtr<MyFoo> foo = new MyFoo();
//     ...
//     foo = NULL;  // explicitly releases |foo|
//     ...
//     if (foo)
//       foo->Method(param);
//   }
//
// The above examples show how CefRefPtr<T> acts like a pointer to T. // Given two CefRefPtr<T> classes, it is also possible to exchange // references between the two objects, like so: // 
//   {
//     CefRefPtr<MyFoo> a = new MyFoo();
//     CefRefPtr<MyFoo> b;
//
//     b.swap(a);
//     // now, |b| references the MyFoo object, and |a| references NULL.
//   }
//
// To make both |a| and |b| in the above example reference the same MyFoo // object, simply use the assignment operator: // 
//   {
//     CefRefPtr<MyFoo> a = new MyFoo();
//     CefRefPtr<MyFoo> b;
//
//     b = a;
//     // now, |a| and |b| each own a reference to the same MyFoo object.
//     // the reference count of the underlying MyFoo object will be 2.
//   }
//
// Reference counted objects can also be passed as function parameters and // used as function return values: // 
//   void some_func_with_param(CefRefPtr<MyFoo> param) {
//     // A reference is added to the MyFoo object that |param| represents
//     // during the scope of some_func_with_param() and released when
//     // some_func_with_param() goes out of scope.
//   }
//
//   CefRefPtr<MyFoo> some_func_with_retval() {
//     // The MyFoo object that |foox| represents starts with a single
//     // reference.
//     CefRefPtr<MyFoo> foox = new MyFoo();
//
//     // Creating the return value adds an additional reference.
//     return foox;
//
//     // When some_func_with_retval() goes out of scope the original |foox|
//     // reference is released.
//   }
//
//   void and_another_function() {
//     CefRefPtr<MyFoo> foo = new MyFoo();
//
//     // pass |foo| as a parameter.
//     some_function(foo);
//
//     CefRefPtr<MyFoo> foo2 = some_func_with_retval();
//     // Now, since we kept a reference to the some_func_with_retval() return
//     // value, |foo2| is the only class pointing to the MyFoo object created
//     in some_func_with_retval(), and it has a reference count of 1.
//
//     some_func_with_retval();
//     // Now, since we didn't keep a reference to the some_func_with_retval()
//     // return value, the MyFoo object created in some_func_with_retval()
//     // will automatically be released.
//   }
//
// And in standard containers: // 
//   {
//      // Create a vector that holds MyFoo objects.
//      std::vector<CefRefPtr<MyFoo> > MyFooVec;
//
//     // The MyFoo object that |foo| represents starts with a single
//     // reference.
//     CefRefPtr<MyFoo> foo = new MyFoo();
//
//     // When the MyFoo object is added to |MyFooVec| the reference count
//     // is increased to 2.
//     MyFooVec.push_back(foo);
//   }
//
//

/// template class CefRefPtr : public scoped_refptr { public: typedef scoped_refptr parent; CefRefPtr() : parent() {} CefRefPtr(T* p) : parent(p) {} CefRefPtr(const scoped_refptr& r) : parent(r) {} template CefRefPtr(const scoped_refptr& r) : parent(r) {} }; #endif // CEF_INCLUDE_INTERNAL_CEF_PTR_H_ cefpython-49.0/src/include/internal/cef_string.h000066400000000000000000000116061334103266300217740ustar00rootroot00000000000000// Copyright (c) 2010 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_INTERNAL_CEF_STRING_H_ #define CEF_INCLUDE_INTERNAL_CEF_STRING_H_ #pragma once // The CEF interface is built with one string type as the default. Comment out // all but one of the CEF_STRING_TYPE_* defines below to specify the default. // If you change the default you MUST recompile all of CEF. // Build with the UTF8 string type as default. // #define CEF_STRING_TYPE_UTF8 1 // Build with the UTF16 string type as default. #define CEF_STRING_TYPE_UTF16 1 // Build with the wide string type as default. // #define CEF_STRING_TYPE_WIDE 1 #include "include/internal/cef_string_types.h" #ifdef __cplusplus #include "include/internal/cef_string_wrappers.h" #if defined(CEF_STRING_TYPE_UTF16) typedef CefStringUTF16 CefString; #elif defined(CEF_STRING_TYPE_UTF8) typedef CefStringUTF8 CefString; #elif defined(CEF_STRING_TYPE_WIDE) typedef CefStringWide CefString; #endif #endif // __cplusplus #if defined(CEF_STRING_TYPE_UTF8) typedef char cef_char_t; typedef cef_string_utf8_t cef_string_t; typedef cef_string_userfree_utf8_t cef_string_userfree_t; #define cef_string_set cef_string_utf8_set #define cef_string_copy cef_string_utf8_copy #define cef_string_clear cef_string_utf8_clear #define cef_string_userfree_alloc cef_string_userfree_utf8_alloc #define cef_string_userfree_free cef_string_userfree_utf8_free #define cef_string_from_ascii cef_string_utf8_copy #define cef_string_to_utf8 cef_string_utf8_copy #define cef_string_from_utf8 cef_string_utf8_copy #define cef_string_to_utf16 cef_string_utf8_to_utf16 #define cef_string_from_utf16 cef_string_utf16_to_utf8 #define cef_string_to_wide cef_string_utf8_to_wide #define cef_string_from_wide cef_string_wide_to_utf8 #elif defined(CEF_STRING_TYPE_UTF16) typedef char16 cef_char_t; typedef cef_string_userfree_utf16_t cef_string_userfree_t; typedef cef_string_utf16_t cef_string_t; #define cef_string_set cef_string_utf16_set #define cef_string_copy cef_string_utf16_copy #define cef_string_clear cef_string_utf16_clear #define cef_string_userfree_alloc cef_string_userfree_utf16_alloc #define cef_string_userfree_free cef_string_userfree_utf16_free #define cef_string_from_ascii cef_string_ascii_to_utf16 #define cef_string_to_utf8 cef_string_utf16_to_utf8 #define cef_string_from_utf8 cef_string_utf8_to_utf16 #define cef_string_to_utf16 cef_string_utf16_copy #define cef_string_from_utf16 cef_string_utf16_copy #define cef_string_to_wide cef_string_utf16_to_wide #define cef_string_from_wide cef_string_wide_to_utf16 #elif defined(CEF_STRING_TYPE_WIDE) typedef wchar_t cef_char_t; typedef cef_string_wide_t cef_string_t; typedef cef_string_userfree_wide_t cef_string_userfree_t; #define cef_string_set cef_string_wide_set #define cef_string_copy cef_string_wide_copy #define cef_string_clear cef_string_wide_clear #define cef_string_userfree_alloc cef_string_userfree_wide_alloc #define cef_string_userfree_free cef_string_userfree_wide_free #define cef_string_from_ascii cef_string_ascii_to_wide #define cef_string_to_utf8 cef_string_wide_to_utf8 #define cef_string_from_utf8 cef_string_utf8_to_wide #define cef_string_to_utf16 cef_string_wide_to_utf16 #define cef_string_from_utf16 cef_string_utf16_to_wide #define cef_string_to_wide cef_string_wide_copy #define cef_string_from_wide cef_string_wide_copy #else #error Please choose a string type. #endif #endif // CEF_INCLUDE_INTERNAL_CEF_STRING_H_ cefpython-49.0/src/include/internal/cef_string_list.h000066400000000000000000000057171334103266300230350ustar00rootroot00000000000000// Copyright (c) 2009 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_INTERNAL_CEF_STRING_LIST_H_ #define CEF_INCLUDE_INTERNAL_CEF_STRING_LIST_H_ #pragma once #include "include/internal/cef_export.h" #include "include/internal/cef_string.h" #ifdef __cplusplus extern "C" { #endif /// // CEF string maps are a set of key/value string pairs. /// typedef void* cef_string_list_t; /// // Allocate a new string map. /// CEF_EXPORT cef_string_list_t cef_string_list_alloc(); /// // Return the number of elements in the string list. /// CEF_EXPORT int cef_string_list_size(cef_string_list_t list); /// // Retrieve the value at the specified zero-based string list index. Returns // true (1) if the value was successfully retrieved. /// CEF_EXPORT int cef_string_list_value(cef_string_list_t list, int index, cef_string_t* value); /// // Append a new value at the end of the string list. /// CEF_EXPORT void cef_string_list_append(cef_string_list_t list, const cef_string_t* value); /// // Clear the string list. /// CEF_EXPORT void cef_string_list_clear(cef_string_list_t list); /// // Free the string list. /// CEF_EXPORT void cef_string_list_free(cef_string_list_t list); /// // Creates a copy of an existing string list. /// CEF_EXPORT cef_string_list_t cef_string_list_copy(cef_string_list_t list); #ifdef __cplusplus } #endif #endif // CEF_INCLUDE_INTERNAL_CEF_STRING_LIST_H_ cefpython-49.0/src/include/internal/cef_string_map.h000066400000000000000000000063441334103266300226340ustar00rootroot00000000000000// Copyright (c) 2009 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_INTERNAL_CEF_STRING_MAP_H_ #define CEF_INCLUDE_INTERNAL_CEF_STRING_MAP_H_ #pragma once #include "include/internal/cef_export.h" #include "include/internal/cef_string.h" #ifdef __cplusplus extern "C" { #endif /// // CEF string maps are a set of key/value string pairs. /// typedef void* cef_string_map_t; /// // Allocate a new string map. /// CEF_EXPORT cef_string_map_t cef_string_map_alloc(); /// // Return the number of elements in the string map. /// CEF_EXPORT int cef_string_map_size(cef_string_map_t map); /// // Return the value assigned to the specified key. /// CEF_EXPORT int cef_string_map_find(cef_string_map_t map, const cef_string_t* key, cef_string_t* value); /// // Return the key at the specified zero-based string map index. /// CEF_EXPORT int cef_string_map_key(cef_string_map_t map, int index, cef_string_t* key); /// // Return the value at the specified zero-based string map index. /// CEF_EXPORT int cef_string_map_value(cef_string_map_t map, int index, cef_string_t* value); /// // Append a new key/value pair at the end of the string map. /// CEF_EXPORT int cef_string_map_append(cef_string_map_t map, const cef_string_t* key, const cef_string_t* value); /// // Clear the string map. /// CEF_EXPORT void cef_string_map_clear(cef_string_map_t map); /// // Free the string map. /// CEF_EXPORT void cef_string_map_free(cef_string_map_t map); #ifdef __cplusplus } #endif #endif // CEF_INCLUDE_INTERNAL_CEF_STRING_MAP_H_ cefpython-49.0/src/include/internal/cef_string_multimap.h000066400000000000000000000073541334103266300237110ustar00rootroot00000000000000// 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_INTERNAL_CEF_STRING_MULTIMAP_H_ #define CEF_INCLUDE_INTERNAL_CEF_STRING_MULTIMAP_H_ #pragma once #include "include/internal/cef_export.h" #include "include/internal/cef_string.h" #ifdef __cplusplus extern "C" { #endif /// // CEF string multimaps are a set of key/value string pairs. // More than one value can be assigned to a single key. /// typedef void* cef_string_multimap_t; /// // Allocate a new string multimap. /// CEF_EXPORT cef_string_multimap_t cef_string_multimap_alloc(); /// // Return the number of elements in the string multimap. /// CEF_EXPORT int cef_string_multimap_size(cef_string_multimap_t map); /// // Return the number of values with the specified key. /// CEF_EXPORT int cef_string_multimap_find_count(cef_string_multimap_t map, const cef_string_t* key); /// // Return the value_index-th value with the specified key. /// CEF_EXPORT int cef_string_multimap_enumerate(cef_string_multimap_t map, const cef_string_t* key, int value_index, cef_string_t* value); /// // Return the key at the specified zero-based string multimap index. /// CEF_EXPORT int cef_string_multimap_key(cef_string_multimap_t map, int index, cef_string_t* key); /// // Return the value at the specified zero-based string multimap index. /// CEF_EXPORT int cef_string_multimap_value(cef_string_multimap_t map, int index, cef_string_t* value); /// // Append a new key/value pair at the end of the string multimap. /// CEF_EXPORT int cef_string_multimap_append(cef_string_multimap_t map, const cef_string_t* key, const cef_string_t* value); /// // Clear the string multimap. /// CEF_EXPORT void cef_string_multimap_clear(cef_string_multimap_t map); /// // Free the string multimap. /// CEF_EXPORT void cef_string_multimap_free(cef_string_multimap_t map); #ifdef __cplusplus } #endif #endif // CEF_INCLUDE_INTERNAL_CEF_STRING_MULTIMAP_H_ cefpython-49.0/src/include/internal/cef_string_types.h000066400000000000000000000165631334103266300232270ustar00rootroot00000000000000// Copyright (c) 2010 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_INTERNAL_CEF_STRING_TYPES_H_ #define CEF_INCLUDE_INTERNAL_CEF_STRING_TYPES_H_ #pragma once // CEF provides functions for converting between UTF-8, -16 and -32 strings. // CEF string types are safe for reading from multiple threads but not for // modification. It is the user's responsibility to provide synchronization if // modifying CEF strings from multiple threads. #include #include "include/base/cef_basictypes.h" #include "include/internal/cef_export.h" #ifdef __cplusplus extern "C" { #endif // CEF string type definitions. Whomever allocates |str| is responsible for // providing an appropriate |dtor| implementation that will free the string in // the same memory space. When reusing an existing string structure make sure // to call |dtor| for the old value before assigning new |str| and |dtor| // values. Static strings will have a NULL |dtor| value. Using the below // functions if you want this managed for you. typedef struct _cef_string_wide_t { wchar_t* str; size_t length; void (*dtor)(wchar_t* str); } cef_string_wide_t; typedef struct _cef_string_utf8_t { char* str; size_t length; void (*dtor)(char* str); } cef_string_utf8_t; typedef struct _cef_string_utf16_t { char16* str; size_t length; void (*dtor)(char16* str); } cef_string_utf16_t; /// // These functions set string values. If |copy| is true (1) the value will be // copied instead of referenced. It is up to the user to properly manage // the lifespan of references. /// CEF_EXPORT int cef_string_wide_set(const wchar_t* src, size_t src_len, cef_string_wide_t* output, int copy); CEF_EXPORT int cef_string_utf8_set(const char* src, size_t src_len, cef_string_utf8_t* output, int copy); CEF_EXPORT int cef_string_utf16_set(const char16* src, size_t src_len, cef_string_utf16_t* output, int copy); /// // Convenience macros for copying values. /// #define cef_string_wide_copy(src, src_len, output) \ cef_string_wide_set(src, src_len, output, true) #define cef_string_utf8_copy(src, src_len, output) \ cef_string_utf8_set(src, src_len, output, true) #define cef_string_utf16_copy(src, src_len, output) \ cef_string_utf16_set(src, src_len, output, true) /// // These functions clear string values. The structure itself is not freed. /// CEF_EXPORT void cef_string_wide_clear(cef_string_wide_t* str); CEF_EXPORT void cef_string_utf8_clear(cef_string_utf8_t* str); CEF_EXPORT void cef_string_utf16_clear(cef_string_utf16_t* str); /// // These functions compare two string values with the same results as strcmp(). /// CEF_EXPORT int cef_string_wide_cmp(const cef_string_wide_t* str1, const cef_string_wide_t* str2); CEF_EXPORT int cef_string_utf8_cmp(const cef_string_utf8_t* str1, const cef_string_utf8_t* str2); CEF_EXPORT int cef_string_utf16_cmp(const cef_string_utf16_t* str1, const cef_string_utf16_t* str2); /// // These functions convert between UTF-8, -16, and -32 strings. They are // potentially slow so unnecessary conversions should be avoided. The best // possible result will always be written to |output| with the boolean return // value indicating whether the conversion is 100% valid. /// CEF_EXPORT int cef_string_wide_to_utf8(const wchar_t* src, size_t src_len, cef_string_utf8_t* output); CEF_EXPORT int cef_string_utf8_to_wide(const char* src, size_t src_len, cef_string_wide_t* output); CEF_EXPORT int cef_string_wide_to_utf16(const wchar_t* src, size_t src_len, cef_string_utf16_t* output); CEF_EXPORT int cef_string_utf16_to_wide(const char16* src, size_t src_len, cef_string_wide_t* output); CEF_EXPORT int cef_string_utf8_to_utf16(const char* src, size_t src_len, cef_string_utf16_t* output); CEF_EXPORT int cef_string_utf16_to_utf8(const char16* src, size_t src_len, cef_string_utf8_t* output); /// // These functions convert an ASCII string, typically a hardcoded constant, to a // Wide/UTF16 string. Use instead of the UTF8 conversion routines if you know // the string is ASCII. /// CEF_EXPORT int cef_string_ascii_to_wide(const char* src, size_t src_len, cef_string_wide_t* output); CEF_EXPORT int cef_string_ascii_to_utf16(const char* src, size_t src_len, cef_string_utf16_t* output); /// // It is sometimes necessary for the system to allocate string structures with // the expectation that the user will free them. The userfree types act as a // hint that the user is responsible for freeing the structure. /// typedef cef_string_wide_t* cef_string_userfree_wide_t; typedef cef_string_utf8_t* cef_string_userfree_utf8_t; typedef cef_string_utf16_t* cef_string_userfree_utf16_t; /// // These functions allocate a new string structure. They must be freed by // calling the associated free function. /// CEF_EXPORT cef_string_userfree_wide_t cef_string_userfree_wide_alloc(); CEF_EXPORT cef_string_userfree_utf8_t cef_string_userfree_utf8_alloc(); CEF_EXPORT cef_string_userfree_utf16_t cef_string_userfree_utf16_alloc(); /// // These functions free the string structure allocated by the associated // alloc function. Any string contents will first be cleared. /// CEF_EXPORT void cef_string_userfree_wide_free(cef_string_userfree_wide_t str); CEF_EXPORT void cef_string_userfree_utf8_free(cef_string_userfree_utf8_t str); CEF_EXPORT void cef_string_userfree_utf16_free(cef_string_userfree_utf16_t str); #ifdef __cplusplus } #endif #endif // CEF_INCLUDE_INTERNAL_CEF_STRING_TYPES_H_ cefpython-49.0/src/include/internal/cef_string_wrappers.h000066400000000000000000000545561334103266300237320ustar00rootroot00000000000000// Copyright (c) 2010 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_INTERNAL_CEF_STRING_WRAPPERS_H_ #define CEF_INCLUDE_INTERNAL_CEF_STRING_WRAPPERS_H_ #pragma once #include #include #include "include/base/cef_string16.h" #include "include/internal/cef_string_types.h" #if defined(BUILDING_CEF_SHARED) #include "base/files/file_path.h" #endif /// // Traits implementation for wide character strings. /// struct CefStringTraitsWide { typedef wchar_t char_type; typedef cef_string_wide_t struct_type; typedef cef_string_userfree_wide_t userfree_struct_type; static inline void clear(struct_type *s) { cef_string_wide_clear(s); } static inline int set(const char_type* src, size_t src_size, struct_type* output, int copy) { return cef_string_wide_set(src, src_size, output, copy); } static inline int compare(const struct_type* s1, const struct_type* s2) { return cef_string_wide_cmp(s1, s2); } static inline userfree_struct_type userfree_alloc() { return cef_string_userfree_wide_alloc(); } static inline void userfree_free(userfree_struct_type ufs) { return cef_string_userfree_wide_free(ufs); } // Conversion methods. static inline bool from_ascii(const char* str, size_t len, struct_type *s) { return cef_string_ascii_to_wide(str, len, s) ? true : false; } static inline std::string to_string(const struct_type *s) { cef_string_utf8_t cstr; memset(&cstr, 0, sizeof(cstr)); cef_string_wide_to_utf8(s->str, s->length, &cstr); std::string str; if (cstr.length > 0) str = std::string(cstr.str, cstr.length); cef_string_utf8_clear(&cstr); return str; } static inline bool from_string(const std::string& str, struct_type *s) { return cef_string_utf8_to_wide(str.c_str(), str.length(), s) ? true : false; } static inline std::wstring to_wstring(const struct_type *s) { return std::wstring(s->str, s->length); } static inline bool from_wstring(const std::wstring& str, struct_type *s) { return cef_string_wide_set(str.c_str(), str.length(), s, true) ? true : false; } #if defined(WCHAR_T_IS_UTF32) static inline base::string16 to_string16(const struct_type *s) { cef_string_utf16_t cstr; memset(&cstr, 0, sizeof(cstr)); cef_string_wide_to_utf16(s->str, s->length, &cstr); base::string16 str; if (cstr.length > 0) str = base::string16(cstr.str, cstr.length); cef_string_utf16_clear(&cstr); return str; } static inline bool from_string16(const base::string16& str, struct_type *s) { return cef_string_utf16_to_wide(str.c_str(), str.length(), s) ? true : false; } #else // WCHAR_T_IS_UTF32 static inline base::string16 to_string16(const struct_type *s) { return base::string16(s->str, s->length); } static inline bool from_string16(const base::string16& str, struct_type *s) { return cef_string_wide_set(str.c_str(), str.length(), s, true) ? true : false; } #endif // WCHAR_T_IS_UTF32 }; /// // Traits implementation for utf8 character strings. /// struct CefStringTraitsUTF8 { typedef char char_type; typedef cef_string_utf8_t struct_type; typedef cef_string_userfree_utf8_t userfree_struct_type; static inline void clear(struct_type *s) { cef_string_utf8_clear(s); } static inline int set(const char_type* src, size_t src_size, struct_type* output, int copy) { return cef_string_utf8_set(src, src_size, output, copy); } static inline int compare(const struct_type* s1, const struct_type* s2) { return cef_string_utf8_cmp(s1, s2); } static inline userfree_struct_type userfree_alloc() { return cef_string_userfree_utf8_alloc(); } static inline void userfree_free(userfree_struct_type ufs) { return cef_string_userfree_utf8_free(ufs); } // Conversion methods. static inline bool from_ascii(const char* str, size_t len, struct_type* s) { return cef_string_utf8_copy(str, len, s) ? true : false; } static inline std::string to_string(const struct_type* s) { return std::string(s->str, s->length); } static inline bool from_string(const std::string& str, struct_type* s) { return cef_string_utf8_copy(str.c_str(), str.length(), s) ? true : false; } static inline std::wstring to_wstring(const struct_type* s) { cef_string_wide_t cstr; memset(&cstr, 0, sizeof(cstr)); cef_string_utf8_to_wide(s->str, s->length, &cstr); std::wstring str; if (cstr.length > 0) str = std::wstring(cstr.str, cstr.length); cef_string_wide_clear(&cstr); return str; } static inline bool from_wstring(const std::wstring& str, struct_type* s) { return cef_string_wide_to_utf8(str.c_str(), str.length(), s) ? true : false; } static inline base::string16 to_string16(const struct_type* s) { cef_string_utf16_t cstr; memset(&cstr, 0, sizeof(cstr)); cef_string_utf8_to_utf16(s->str, s->length, &cstr); base::string16 str; if (cstr.length > 0) str = base::string16(cstr.str, cstr.length); cef_string_utf16_clear(&cstr); return str; } static inline bool from_string16(const base::string16& str, struct_type* s) { return cef_string_utf16_to_utf8(str.c_str(), str.length(), s) ? true : false; } }; /// // Traits implementation for utf16 character strings. /// struct CefStringTraitsUTF16 { typedef char16 char_type; typedef cef_string_utf16_t struct_type; typedef cef_string_userfree_utf16_t userfree_struct_type; static inline void clear(struct_type *s) { cef_string_utf16_clear(s); } static inline int set(const char_type* src, size_t src_size, struct_type* output, int copy) { return cef_string_utf16_set(src, src_size, output, copy); } static inline int compare(const struct_type* s1, const struct_type* s2) { return cef_string_utf16_cmp(s1, s2); } static inline userfree_struct_type userfree_alloc() { return cef_string_userfree_utf16_alloc(); } static inline void userfree_free(userfree_struct_type ufs) { return cef_string_userfree_utf16_free(ufs); } // Conversion methods. static inline bool from_ascii(const char* str, size_t len, struct_type* s) { return cef_string_ascii_to_utf16(str, len, s) ? true : false; } static inline std::string to_string(const struct_type* s) { cef_string_utf8_t cstr; memset(&cstr, 0, sizeof(cstr)); cef_string_utf16_to_utf8(s->str, s->length, &cstr); std::string str; if (cstr.length > 0) str = std::string(cstr.str, cstr.length); cef_string_utf8_clear(&cstr); return str; } static inline bool from_string(const std::string& str, struct_type* s) { return cef_string_utf8_to_utf16(str.c_str(), str.length(), s) ? true : false; } #if defined(WCHAR_T_IS_UTF32) static inline std::wstring to_wstring(const struct_type* s) { cef_string_wide_t cstr; memset(&cstr, 0, sizeof(cstr)); cef_string_utf16_to_wide(s->str, s->length, &cstr); std::wstring str; if (cstr.length > 0) str = std::wstring(cstr.str, cstr.length); cef_string_wide_clear(&cstr); return str; } static inline bool from_wstring(const std::wstring& str, struct_type* s) { return cef_string_wide_to_utf16(str.c_str(), str.length(), s) ? true : false; } #else // WCHAR_T_IS_UTF32 static inline std::wstring to_wstring(const struct_type* s) { return std::wstring(s->str, s->length); } static inline bool from_wstring(const std::wstring& str, struct_type* s) { return cef_string_utf16_set(str.c_str(), str.length(), s, true) ? true : false; } #endif // WCHAR_T_IS_UTF32 static inline base::string16 to_string16(const struct_type* s) { return base::string16(s->str, s->length); } static inline bool from_string16(const base::string16& str, struct_type* s) { return cef_string_utf16_set(str.c_str(), str.length(), s, true) ? true : false; } }; /// // CEF string classes can convert between all supported string types. For // example, the CefStringWide class uses wchar_t as the underlying character // type and provides two approaches for converting data to/from a UTF8 string // (std::string). //

// 1. Implicit conversion using the assignment operator overload. // 

//   CefStringWide aCefString;
//   std::string aUTF8String;
//   aCefString = aUTF8String; // Assign std::string to CefStringWide
//   aUTF8String = aCefString; // Assign CefStringWide to std::string
//
// 2. Explicit conversion using the FromString/ToString methods. // 
//   CefStringWide aCefString;
//   std::string aUTF8String;
//   aCefString.FromString(aUTF8String); // Assign std::string to CefStringWide
//   aUTF8String = aCefString.ToString(); // Assign CefStringWide to std::string
//
// Conversion will only occur if the assigned value is a different string type. // Assigning a std::string to a CefStringUTF8, for example, will copy the data // without performing a conversion. //

// CEF string classes are safe for reading from multiple threads but not for // modification. It is the user's responsibility to provide synchronization if // modifying CEF strings from multiple threads. /// template class CefStringBase { public: typedef typename traits::char_type char_type; typedef typename traits::struct_type struct_type; typedef typename traits::userfree_struct_type userfree_struct_type; /// // Default constructor. /// CefStringBase() : string_(NULL), owner_(false) {} /// // Create a new string from an existing string. Data will always be copied. /// CefStringBase(const CefStringBase& str) : string_(NULL), owner_(false) { FromString(str.c_str(), str.length(), true); } /// // Create a new string from an existing std::string. Data will be always // copied. Translation will occur if necessary based on the underlying string // type. /// CefStringBase(const std::string& src) // NOLINT(runtime/explicit) : string_(NULL), owner_(false) { FromString(src); } CefStringBase(const char* src) // NOLINT(runtime/explicit) : string_(NULL), owner_(false) { if (src) FromString(std::string(src)); } /// // Create a new string from an existing std::wstring. Data will be always // copied. Translation will occur if necessary based on the underlying string // type. /// CefStringBase(const std::wstring& src) // NOLINT(runtime/explicit) : string_(NULL), owner_(false) { FromWString(src); } CefStringBase(const wchar_t* src) // NOLINT(runtime/explicit) : string_(NULL), owner_(false) { if (src) FromWString(std::wstring(src)); } #if defined(WCHAR_T_IS_UTF32) /// // Create a new string from an existing string16. Data will be always // copied. Translation will occur if necessary based on the underlying string // type. /// CefStringBase(const base::string16& src) // NOLINT(runtime/explicit) : string_(NULL), owner_(false) { FromString16(src); } CefStringBase(const char16* src) // NOLINT(runtime/explicit) : string_(NULL), owner_(false) { if (src) FromString16(base::string16(src)); } #endif // WCHAR_T_IS_UTF32 /// // Create a new string from an existing character array. If |copy| is true // this class will copy the data. Otherwise, this class will reference the // existing data. Referenced data must exist for the lifetime of this class // and will not be freed by this class. /// CefStringBase(const char_type* src, size_t src_len, bool copy) : string_(NULL), owner_(false) { if (src && src_len > 0) FromString(src, src_len, copy); } /// // Create a new string referencing an existing string structure without taking // ownership. Referenced structures must exist for the lifetime of this class // and will not be freed by this class. /// CefStringBase(const struct_type* src) // NOLINT(runtime/explicit) : string_(NULL), owner_(false) { if (!src) return; // Reference the existing structure without taking ownership. Attach(const_cast(src), false); } virtual ~CefStringBase() { ClearAndFree(); } // The following methods are named for compatibility with the standard library // string template types. /// // Return a read-only pointer to the string data. /// const char_type* c_str() const { return (string_ ? string_->str : NULL); } /// // Return the length of the string data. /// size_t length() const { return (string_ ? string_->length : 0); } /// // Return the length of the string data. /// inline size_t size() const { return length(); } /// // Returns true if the string is empty. /// bool empty() const { return (string_ == NULL || string_->length == 0); } /// // Compare this string to the specified string. /// int compare(const CefStringBase& str) const { if (empty() && str.empty()) return 0; if (empty()) return -1; if (str.empty()) return 1; return traits::compare(string_, str.GetStruct()); } /// // Clear the string data. /// void clear() { if (string_) traits::clear(string_); } /// // Swap this string's contents with the specified string. /// void swap(CefStringBase& str) { struct_type* tmp_string = string_; bool tmp_owner = owner_; string_ = str.string_; owner_ = str.owner_; str.string_ = tmp_string; str.owner_ = tmp_owner; } // The following methods are unique to CEF string template types. /// // Returns true if this class owns the underlying string structure. /// bool IsOwner() const { return owner_; } /// // Returns a read-only pointer to the underlying string structure. May return // NULL if no structure is currently allocated. /// const struct_type* GetStruct() const { return string_; } /// // Returns a writable pointer to the underlying string structure. Will never // return NULL. /// struct_type* GetWritableStruct() { AllocIfNeeded(); return string_; } /// // Clear the state of this class. The underlying string structure and data // will be freed if this class owns the structure. /// void ClearAndFree() { if (!string_) return; if (owner_) { clear(); delete string_; } string_ = NULL; owner_ = false; } /// // Attach to the specified string structure. If |owner| is true this class // will take ownership of the structure. /// void Attach(struct_type* str, bool owner) { // Free the previous structure and data, if any. ClearAndFree(); string_ = str; owner_ = owner; } /// // Take ownership of the specified userfree structure's string data. The // userfree structure itself will be freed. Only use this method with userfree // structures. /// void AttachToUserFree(userfree_struct_type str) { // Free the previous structure and data, if any. ClearAndFree(); if (!str) return; AllocIfNeeded(); owner_ = true; memcpy(string_, str, sizeof(struct_type)); // Free the |str| structure but not the data. memset(str, 0, sizeof(struct_type)); traits::userfree_free(str); } /// // Detach from the underlying string structure. To avoid memory leaks only use // this method if you already hold a pointer to the underlying string // structure. /// void Detach() { string_ = NULL; owner_ = false; } /// // Create a userfree structure and give it ownership of this class' string // data. This class will be disassociated from the data. May return NULL if // this string class currently contains no data. /// userfree_struct_type DetachToUserFree() { if (empty()) return NULL; userfree_struct_type str = traits::userfree_alloc(); memcpy(str, string_, sizeof(struct_type)); // Free this class' structure but not the data. memset(string_, 0, sizeof(struct_type)); ClearAndFree(); return str; } /// // Set this string's data to the specified character array. If |copy| is true // this class will copy the data. Otherwise, this class will reference the // existing data. Referenced data must exist for the lifetime of this class // and will not be freed by this class. /// bool FromString(const char_type* src, size_t src_len, bool copy) { if (src == NULL || src_len == 0) { clear(); return true; } AllocIfNeeded(); return traits::set(src, src_len, string_, copy) ? true : false; } /// // Set this string's data from an existing ASCII string. Data will be always // copied. Translation will occur if necessary based on the underlying string // type. /// bool FromASCII(const char* str) { size_t len = str ? strlen(str) : 0; if (len == 0) { clear(); return true; } AllocIfNeeded(); return traits::from_ascii(str, len, string_); } /// // Return this string's data as a std::string. Translation will occur if // necessary based on the underlying string type. /// std::string ToString() const { if (empty()) return std::string(); return traits::to_string(string_); } /// // Set this string's data from an existing std::string. Data will be always // copied. Translation will occur if necessary based on the underlying string // type. /// bool FromString(const std::string& str) { if (str.empty()) { clear(); return true; } AllocIfNeeded(); return traits::from_string(str, string_); } /// // Return this string's data as a std::wstring. Translation will occur if // necessary based on the underlying string type. /// std::wstring ToWString() const { if (empty()) return std::wstring(); return traits::to_wstring(string_); } /// // Set this string's data from an existing std::wstring. Data will be always // copied. Translation will occur if necessary based on the underlying string // type. /// bool FromWString(const std::wstring& str) { if (str.empty()) { clear(); return true; } AllocIfNeeded(); return traits::from_wstring(str, string_); } /// // Return this string's data as a string16. Translation will occur if // necessary based on the underlying string type. /// base::string16 ToString16() const { if (empty()) return base::string16(); return traits::to_string16(string_); } /// // Set this string's data from an existing string16. Data will be always // copied. Translation will occur if necessary based on the underlying string // type. /// bool FromString16(const base::string16& str) { if (str.empty()) { clear(); return true; } AllocIfNeeded(); return traits::from_string16(str, string_); } /// // Comparison operator overloads. /// bool operator<(const CefStringBase& str) const { return (compare(str) < 0); } bool operator<=(const CefStringBase& str) const { return (compare(str) <= 0); } bool operator>(const CefStringBase& str) const { return (compare(str) > 0); } bool operator>=(const CefStringBase& str) const { return (compare(str) >= 0); } bool operator==(const CefStringBase& str) const { return (compare(str) == 0); } bool operator!=(const CefStringBase& str) const { return (compare(str) != 0); } /// // Assignment operator overloads. /// CefStringBase& operator=(const CefStringBase& str) { FromString(str.c_str(), str.length(), true); return *this; } operator std::string() const { return ToString(); } CefStringBase& operator=(const std::string& str) { FromString(str); return *this; } CefStringBase& operator=(const char* str) { FromString(std::string(str)); return *this; } operator std::wstring() const { return ToWString(); } CefStringBase& operator=(const std::wstring& str) { FromWString(str); return *this; } CefStringBase& operator=(const wchar_t* str) { FromWString(std::wstring(str)); return *this; } #if defined(WCHAR_T_IS_UTF32) operator base::string16() const { return ToString16(); } CefStringBase& operator=(const base::string16& str) { FromString16(str); return *this; } CefStringBase& operator=(const char16* str) { FromString16(base::string16(str)); return *this; } #endif // WCHAR_T_IS_UTF32 #if defined(BUILDING_CEF_SHARED) // The base::FilePath constructor is marked as explicit so provide the // conversion here for convenience. operator base::FilePath() const { #if defined(OS_WIN) return base::FilePath(ToWString()); #else return base::FilePath(ToString()); #endif } #endif // BUILDING_CEF_SHARED private: // Allocate the string structure if it doesn't already exist. void AllocIfNeeded() { if (string_ == NULL) { string_ = new struct_type; memset(string_, 0, sizeof(struct_type)); owner_ = true; } } struct_type* string_; bool owner_; }; typedef CefStringBase CefStringWide; typedef CefStringBase CefStringUTF8; typedef CefStringBase CefStringUTF16; #endif // CEF_INCLUDE_INTERNAL_CEF_STRING_WRAPPERS_H_ cefpython-49.0/src/include/internal/cef_thread_internal.h000066400000000000000000000050101334103266300236210ustar00rootroot00000000000000// Copyright (c) 2014 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_INTERNAL_CEF_THREAD_INTERNAL_H_ #define CEF_INCLUDE_INTERNAL_CEF_THREAD_INTERNAL_H_ #pragma once #if defined(OS_WIN) #include #elif defined(OS_POSIX) #include #include #endif #include "include/internal/cef_export.h" #ifdef __cplusplus extern "C" { #endif #if defined(OS_WIN) typedef DWORD cef_platform_thread_id_t; #elif defined(OS_POSIX) typedef pid_t cef_platform_thread_id_t; #endif /// // Returns the current platform thread ID. /// CEF_EXPORT cef_platform_thread_id_t cef_get_current_platform_thread_id(); #if defined(OS_WIN) typedef DWORD cef_platform_thread_handle_t; #elif defined(OS_POSIX) typedef pthread_t cef_platform_thread_handle_t; #endif /// // Returns the current platform thread handle. /// CEF_EXPORT cef_platform_thread_handle_t cef_get_current_platform_thread_handle(); #ifdef __cplusplus } #endif // __cplusplus #endif // CEF_INCLUDE_INTERNAL_CEF_THREAD_INTERNAL_H_ cefpython-49.0/src/include/internal/cef_time.h000066400000000000000000000067071334103266300214320ustar00rootroot00000000000000// 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_INTERNAL_CEF_TIME_H_ #define CEF_INCLUDE_INTERNAL_CEF_TIME_H_ #pragma once #ifdef __cplusplus extern "C" { #endif #include "include/internal/cef_export.h" #include /// // Time information. Values should always be in UTC. /// typedef struct _cef_time_t { int year; // Four digit year "2007" int month; // 1-based month (values 1 = January, etc.) int day_of_week; // 0-based day of week (0 = Sunday, etc.) int day_of_month; // 1-based day of month (1-31) int hour; // Hour within the current day (0-23) int minute; // Minute within the current hour (0-59) int second; // Second within the current minute (0-59 plus leap // seconds which may take it up to 60). int millisecond; // Milliseconds within the current second (0-999) } cef_time_t; /// // Converts cef_time_t to/from time_t. Returns true (1) on success and false (0) // on failure. /// CEF_EXPORT int cef_time_to_timet(const cef_time_t* cef_time, time_t* time); CEF_EXPORT int cef_time_from_timet(time_t time, cef_time_t* cef_time); /// // Converts cef_time_t to/from a double which is the number of seconds since // epoch (Jan 1, 1970). Webkit uses this format to represent time. A value of 0 // means "not initialized". Returns true (1) on success and false (0) on // failure. /// CEF_EXPORT int cef_time_to_doublet(const cef_time_t* cef_time, double* time); CEF_EXPORT int cef_time_from_doublet(double time, cef_time_t* cef_time); /// // Retrieve the current system time. // CEF_EXPORT int cef_time_now(cef_time_t* cef_time); /// // Retrieve the delta in milliseconds between two time values. // CEF_EXPORT int cef_time_delta(const cef_time_t* cef_time1, const cef_time_t* cef_time2, long long* delta); #ifdef __cplusplus } #endif #endif // CEF_INCLUDE_INTERNAL_CEF_TIME_H_ cefpython-49.0/src/include/internal/cef_trace_event_internal.h000066400000000000000000000144741334103266300246670ustar00rootroot00000000000000// Copyright (c) 2014 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_INTERNAL_CEF_TRACE_EVENT_INTERNAL_H_ #define CEF_INCLUDE_INTERNAL_CEF_TRACE_EVENT_INTERNAL_H_ #pragma once #include "include/internal/cef_export.h" #include "include/internal/cef_types.h" #ifdef __cplusplus extern "C" { #endif // See include/base/cef_trace_event.h for macros and intended usage. // Functions for tracing counters and functions; called from macros. // - |category| string must have application lifetime (static or literal). They // may not include "(quotes) chars. // - |argX_name|, |argX_val|, |valueX_name|, |valeX_val| are optional parameters // and represent pairs of name and values of arguments // - |copy| is used to avoid memory scoping issues with the |name| and // |arg_name| parameters by copying them // - |id| is used to disambiguate counters with the same name, or match async // trace events CEF_EXPORT void cef_trace_event_instant(const char* category, const char* name, const char* arg1_name, uint64 arg1_val, const char* arg2_name, uint64 arg2_val, int copy); CEF_EXPORT void cef_trace_event_begin(const char* category, const char* name, const char* arg1_name, uint64 arg1_val, const char* arg2_name, uint64 arg2_val, int copy); CEF_EXPORT void cef_trace_event_end(const char* category, const char* name, const char* arg1_name, uint64 arg1_val, const char* arg2_name, uint64 arg2_val, int copy); CEF_EXPORT void cef_trace_counter(const char* category, const char* name, const char* value1_name, uint64 value1_val, const char* value2_name, uint64 value2_val, int copy); CEF_EXPORT void cef_trace_counter_id(const char* category, const char* name, uint64 id, const char* value1_name, uint64 value1_val, const char* value2_name, uint64 value2_val, int copy); CEF_EXPORT void cef_trace_event_async_begin(const char* category, const char* name, uint64 id, const char* arg1_name, uint64 arg1_val, const char* arg2_name, uint64 arg2_val, int copy); CEF_EXPORT void cef_trace_event_async_step_into(const char* category, const char* name, uint64 id, uint64 step, const char* arg1_name, uint64 arg1_val, int copy); CEF_EXPORT void cef_trace_event_async_step_past(const char* category, const char* name, uint64 id, uint64 step, const char* arg1_name, uint64 arg1_val, int copy); CEF_EXPORT void cef_trace_event_async_end(const char* category, const char* name, uint64 id, const char* arg1_name, uint64 arg1_val, const char* arg2_name, uint64 arg2_val, int copy); #ifdef __cplusplus } #endif // __cplusplus #endif // CEF_INCLUDE_INTERNAL_CEF_TRACE_EVENT_INTERNAL_H_ cefpython-49.0/src/include/internal/cef_types.h000066400000000000000000002003341334103266300216300ustar00rootroot00000000000000// Copyright (c) 2014 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_INTERNAL_CEF_TYPES_H_ #define CEF_INCLUDE_INTERNAL_CEF_TYPES_H_ #pragma once #include "include/base/cef_basictypes.h" #include "include/internal/cef_string.h" #include "include/internal/cef_string_list.h" #include "include/internal/cef_time.h" // Bring in platform-specific definitions. #if defined(OS_WIN) #include "include/internal/cef_types_win.h" #elif defined(OS_MACOSX) #include "include/internal/cef_types_mac.h" #elif defined(OS_LINUX) #include "include/internal/cef_types_linux.h" #endif // 32-bit ARGB color value, not premultiplied. The color components are always // in a known order. Equivalent to the SkColor type. typedef uint32 cef_color_t; // Return the alpha byte from a cef_color_t value. #define CefColorGetA(color) (((color) >> 24) & 0xFF) // Return the red byte from a cef_color_t value. #define CefColorGetR(color) (((color) >> 16) & 0xFF) // Return the green byte from a cef_color_t value. #define CefColorGetG(color) (((color) >> 8) & 0xFF) // Return the blue byte from a cef_color_t value. #define CefColorGetB(color) (((color) >> 0) & 0xFF) // Return an cef_color_t value with the specified byte component values. #define CefColorSetARGB(a, r, g, b) \ static_cast( \ (static_cast(a) << 24) | \ (static_cast(r) << 16) | \ (static_cast(g) << 8) | \ (static_cast(b) << 0)) // Return an int64 value with the specified low and high int32 component values. #define CefInt64Set(int32_low, int32_high) \ static_cast((static_cast(int32_low)) | \ (static_cast(static_cast(int32_high))) << 32) // Return the low int32 value from an int64 value. #define CefInt64GetLow(int64_val) static_cast(int64_val) // Return the high int32 value from an int64 value. #define CefInt64GetHigh(int64_val) \ static_cast((static_cast(int64_val) >> 32) & 0xFFFFFFFFL) #ifdef __cplusplus extern "C" { #endif /// // Log severity levels. /// typedef enum { /// // Default logging (currently INFO logging). /// LOGSEVERITY_DEFAULT, /// // Verbose logging. /// LOGSEVERITY_VERBOSE, /// // INFO logging. /// LOGSEVERITY_INFO, /// // WARNING logging. /// LOGSEVERITY_WARNING, /// // ERROR logging. /// LOGSEVERITY_ERROR, /// // Completely disable logging. /// LOGSEVERITY_DISABLE = 99 } cef_log_severity_t; /// // Represents the state of a setting. /// typedef enum { /// // Use the default state for the setting. /// STATE_DEFAULT = 0, /// // Enable or allow the setting. /// STATE_ENABLED, /// // Disable or disallow the setting. /// STATE_DISABLED, } cef_state_t; /// // Initialization settings. Specify NULL or 0 to get the recommended default // values. Many of these and other settings can also configured using command- // line switches. /// typedef struct _cef_settings_t { /// // Size of this structure. /// size_t size; /// // Set to true (1) to use a single process for the browser and renderer. This // run mode is not officially supported by Chromium and is less stable than // the multi-process default. Also configurable using the "single-process" // command-line switch. /// int single_process; /// // Set to true (1) to disable the sandbox for sub-processes. See // cef_sandbox_win.h for requirements to enable the sandbox on Windows. Also // configurable using the "no-sandbox" command-line switch. /// int no_sandbox; /// // The path to a separate executable that will be launched for sub-processes. // By default the browser process executable is used. See the comments on // CefExecuteProcess() for details. Also configurable using the // "browser-subprocess-path" command-line switch. /// cef_string_t browser_subprocess_path; /// // Set to true (1) to have the browser process message loop run in a separate // thread. If false (0) than the CefDoMessageLoopWork() function must be // called from your application message loop. This option is only supported on // Windows. /// int multi_threaded_message_loop; /// // Set to true (1) to enable windowless (off-screen) rendering support. Do not // enable this value if the application does not use windowless rendering as // it may reduce rendering performance on some systems. /// int windowless_rendering_enabled; /// // Set to true (1) to disable configuration of browser process features using // standard CEF and Chromium command-line arguments. Configuration can still // be specified using CEF data structures or via the // CefApp::OnBeforeCommandLineProcessing() method. /// int command_line_args_disabled; /// // The location where cache data will be stored on disk. If empty then // browsers will be created in "incognito mode" where in-memory caches are // used for storage and no data is persisted to disk. HTML5 databases such as // localStorage will only persist across sessions if a cache path is // specified. Can be overridden for individual CefRequestContext instances via // the CefRequestContextSettings.cache_path value. /// cef_string_t cache_path; /// // The location where user data such as spell checking dictionary files will // be stored on disk. If empty then the default platform-specific user data // directory will be used ("~/.cef_user_data" directory on Linux, // "~/Library/Application Support/CEF/User Data" directory on Mac OS X, // "Local Settings\Application Data\CEF\User Data" directory under the user // profile directory on Windows). /// cef_string_t user_data_path; /// // To persist session cookies (cookies without an expiry date or validity // interval) by default when using the global cookie manager set this value to // true (1). Session cookies are generally intended to be transient and most // Web browsers do not persist them. A |cache_path| value must also be // specified to enable this feature. Also configurable using the // "persist-session-cookies" command-line switch. Can be overridden for // individual CefRequestContext instances via the // CefRequestContextSettings.persist_session_cookies value. /// int persist_session_cookies; /// // To persist user preferences as a JSON file in the cache path directory set // this value to true (1). A |cache_path| value must also be specified // to enable this feature. Also configurable using the // "persist-user-preferences" command-line switch. Can be overridden for // individual CefRequestContext instances via the // CefRequestContextSettings.persist_user_preferences value. /// int persist_user_preferences; /// // Value that will be returned as the User-Agent HTTP header. If empty the // default User-Agent string will be used. Also configurable using the // "user-agent" command-line switch. /// cef_string_t user_agent; /// // Value that will be inserted as the product portion of the default // User-Agent string. If empty the Chromium product version will be used. If // |userAgent| is specified this value will be ignored. Also configurable // using the "product-version" command-line switch. /// cef_string_t product_version; /// // The locale string that will be passed to WebKit. If empty the default // locale of "en-US" will be used. This value is ignored on Linux where locale // is determined using environment variable parsing with the precedence order: // LANGUAGE, LC_ALL, LC_MESSAGES and LANG. Also configurable using the "lang" // command-line switch. /// cef_string_t locale; /// // The directory and file name to use for the debug log. If empty a default // log file name and location will be used. On Windows and Linux a "debug.log" // file will be written in the main executable directory. On Mac OS X a // "~/Library/Logs/_debug.log" file will be written where // is the name of the main app executable. Also configurable using the // "log-file" command-line switch. /// cef_string_t log_file; /// // The log severity. Only messages of this severity level or higher will be // logged. Also configurable using the "log-severity" command-line switch with // a value of "verbose", "info", "warning", "error", "error-report" or // "disable". /// cef_log_severity_t log_severity; /// // Custom flags that will be used when initializing the V8 JavaScript engine. // The consequences of using custom flags may not be well tested. Also // configurable using the "js-flags" command-line switch. /// cef_string_t javascript_flags; /// // The fully qualified path for the resources directory. If this value is // empty the cef.pak and/or devtools_resources.pak files must be located in // the module directory on Windows/Linux or the app bundle Resources directory // on Mac OS X. Also configurable using the "resources-dir-path" command-line // switch. /// cef_string_t resources_dir_path; /// // The fully qualified path for the locales directory. If this value is empty // the locales directory must be located in the module directory. This value // is ignored on Mac OS X where pack files are always loaded from the app // bundle Resources directory. Also configurable using the "locales-dir-path" // command-line switch. /// cef_string_t locales_dir_path; /// // Set to true (1) to disable loading of pack files for resources and locales. // A resource bundle handler must be provided for the browser and render // processes via CefApp::GetResourceBundleHandler() if loading of pack files // is disabled. Also configurable using the "disable-pack-loading" command- // line switch. /// int pack_loading_disabled; /// // Set to a value between 1024 and 65535 to enable remote debugging on the // specified port. For example, if 8080 is specified the remote debugging URL // will be http://localhost:8080. CEF can be remotely debugged from any CEF or // Chrome browser window. Also configurable using the "remote-debugging-port" // command-line switch. /// int remote_debugging_port; /// // The number of stack trace frames to capture for uncaught exceptions. // Specify a positive value to enable the CefRenderProcessHandler:: // OnUncaughtException() callback. Specify 0 (default value) and // OnUncaughtException() will not be called. Also configurable using the // "uncaught-exception-stack-size" command-line switch. /// int uncaught_exception_stack_size; /// // By default CEF V8 references will be invalidated (the IsValid() method will // return false) after the owning context has been released. This reduces the // need for external record keeping and avoids crashes due to the use of V8 // references after the associated context has been released. // // CEF currently offers two context safety implementations with different // performance characteristics. The default implementation (value of 0) uses a // map of hash values and should provide better performance in situations with // a small number contexts. The alternate implementation (value of 1) uses a // hidden value attached to each context and should provide better performance // in situations with a large number of contexts. // // If you need better performance in the creation of V8 references and you // plan to manually track context lifespan you can disable context safety by // specifying a value of -1. // // Also configurable using the "context-safety-implementation" command-line // switch. /// int context_safety_implementation; /// // Set to true (1) to ignore errors related to invalid SSL certificates. // Enabling this setting can lead to potential security vulnerabilities like // "man in the middle" attacks. Applications that load content from the // internet should not enable this setting. Also configurable using the // "ignore-certificate-errors" command-line switch. Can be overridden for // individual CefRequestContext instances via the // CefRequestContextSettings.ignore_certificate_errors value. /// int ignore_certificate_errors; /// // Opaque background color used for accelerated content. By default the // background color will be white. Only the RGB compontents of the specified // value will be used. The alpha component must greater than 0 to enable use // of the background color but will be otherwise ignored. /// cef_color_t background_color; /// // Comma delimited ordered list of language codes without any whitespace that // will be used in the "Accept-Language" HTTP header. May be overridden on a // per-browser basis using the CefBrowserSettings.accept_language_list value. // If both values are empty then "en-US,en" will be used. Can be overridden // for individual CefRequestContext instances via the // CefRequestContextSettings.accept_language_list value. /// cef_string_t accept_language_list; } cef_settings_t; /// // Request context initialization settings. Specify NULL or 0 to get the // recommended default values. /// typedef struct _cef_request_context_settings_t { /// // Size of this structure. /// size_t size; /// // The location where cache data will be stored on disk. If empty then // browsers will be created in "incognito mode" where in-memory caches are // used for storage and no data is persisted to disk. HTML5 databases such as // localStorage will only persist across sessions if a cache path is // specified. To share the global browser cache and related configuration set // this value to match the CefSettings.cache_path value. /// cef_string_t cache_path; /// // To persist session cookies (cookies without an expiry date or validity // interval) by default when using the global cookie manager set this value to // true (1). Session cookies are generally intended to be transient and most // Web browsers do not persist them. Can be set globally using the // CefSettings.persist_session_cookies value. This value will be ignored if // |cache_path| is empty or if it matches the CefSettings.cache_path value. /// int persist_session_cookies; /// // To persist user preferences as a JSON file in the cache path directory set // this value to true (1). Can be set globally using the // CefSettings.persist_user_preferences value. This value will be ignored if // |cache_path| is empty or if it matches the CefSettings.cache_path value. /// int persist_user_preferences; /// // Set to true (1) to ignore errors related to invalid SSL certificates. // Enabling this setting can lead to potential security vulnerabilities like // "man in the middle" attacks. Applications that load content from the // internet should not enable this setting. Can be set globally using the // CefSettings.ignore_certificate_errors value. This value will be ignored if // |cache_path| matches the CefSettings.cache_path value. /// int ignore_certificate_errors; /// // Comma delimited ordered list of language codes without any whitespace that // will be used in the "Accept-Language" HTTP header. Can be set globally // using the CefSettings.accept_language_list value or overridden on a per- // browser basis using the CefBrowserSettings.accept_language_list value. If // all values are empty then "en-US,en" will be used. This value will be // ignored if |cache_path| matches the CefSettings.cache_path value. /// cef_string_t accept_language_list; } cef_request_context_settings_t; /// // Browser initialization settings. Specify NULL or 0 to get the recommended // default values. The consequences of using custom values may not be well // tested. Many of these and other settings can also configured using command- // line switches. /// typedef struct _cef_browser_settings_t { /// // Size of this structure. /// size_t size; /// // The maximum rate in frames per second (fps) that CefRenderHandler::OnPaint // will be called for a windowless browser. The actual fps may be lower if // the browser cannot generate frames at the requested rate. The minimum // value is 1 and the maximum value is 60 (default 30). This value can also be // changed dynamically via CefBrowserHost::SetWindowlessFrameRate. /// int windowless_frame_rate; // The below values map to WebPreferences settings. /// // Font settings. /// cef_string_t standard_font_family; cef_string_t fixed_font_family; cef_string_t serif_font_family; cef_string_t sans_serif_font_family; cef_string_t cursive_font_family; cef_string_t fantasy_font_family; int default_font_size; int default_fixed_font_size; int minimum_font_size; int minimum_logical_font_size; /// // Default encoding for Web content. If empty "ISO-8859-1" will be used. Also // configurable using the "default-encoding" command-line switch. /// cef_string_t default_encoding; /// // Controls the loading of fonts from remote sources. Also configurable using // the "disable-remote-fonts" command-line switch. /// cef_state_t remote_fonts; /// // Controls whether JavaScript can be executed. Also configurable using the // "disable-javascript" command-line switch. /// cef_state_t javascript; /// // Controls whether JavaScript can be used for opening windows. Also // configurable using the "disable-javascript-open-windows" command-line // switch. /// cef_state_t javascript_open_windows; /// // Controls whether JavaScript can be used to close windows that were not // opened via JavaScript. JavaScript can still be used to close windows that // were opened via JavaScript or that have no back/forward history. Also // configurable using the "disable-javascript-close-windows" command-line // switch. /// cef_state_t javascript_close_windows; /// // Controls whether JavaScript can access the clipboard. Also configurable // using the "disable-javascript-access-clipboard" command-line switch. /// cef_state_t javascript_access_clipboard; /// // Controls whether DOM pasting is supported in the editor via // execCommand("paste"). The |javascript_access_clipboard| setting must also // be enabled. Also configurable using the "disable-javascript-dom-paste" // command-line switch. /// cef_state_t javascript_dom_paste; /// // Controls whether the caret position will be drawn. Also configurable using // the "enable-caret-browsing" command-line switch. /// cef_state_t caret_browsing; /// // Controls whether any plugins will be loaded. Also configurable using the // "disable-plugins" command-line switch. /// cef_state_t plugins; /// // Controls whether file URLs will have access to all URLs. Also configurable // using the "allow-universal-access-from-files" command-line switch. /// cef_state_t universal_access_from_file_urls; /// // Controls whether file URLs will have access to other file URLs. Also // configurable using the "allow-access-from-files" command-line switch. /// cef_state_t file_access_from_file_urls; /// // Controls whether web security restrictions (same-origin policy) will be // enforced. Disabling this setting is not recommend as it will allow risky // security behavior such as cross-site scripting (XSS). Also configurable // using the "disable-web-security" command-line switch. /// cef_state_t web_security; /// // Controls whether image URLs will be loaded from the network. A cached image // will still be rendered if requested. Also configurable using the // "disable-image-loading" command-line switch. /// cef_state_t image_loading; /// // Controls whether standalone images will be shrunk to fit the page. Also // configurable using the "image-shrink-standalone-to-fit" command-line // switch. /// cef_state_t image_shrink_standalone_to_fit; /// // Controls whether text areas can be resized. Also configurable using the // "disable-text-area-resize" command-line switch. /// cef_state_t text_area_resize; /// // Controls whether the tab key can advance focus to links. Also configurable // using the "disable-tab-to-links" command-line switch. /// cef_state_t tab_to_links; /// // Controls whether local storage can be used. Also configurable using the // "disable-local-storage" command-line switch. /// cef_state_t local_storage; /// // Controls whether databases can be used. Also configurable using the // "disable-databases" command-line switch. /// cef_state_t databases; /// // Controls whether the application cache can be used. Also configurable using // the "disable-application-cache" command-line switch. /// cef_state_t application_cache; /// // Controls whether WebGL can be used. Note that WebGL requires hardware // support and may not work on all systems even when enabled. Also // configurable using the "disable-webgl" command-line switch. /// cef_state_t webgl; /// // Opaque background color used for the browser before a document is loaded // and when no document color is specified. By default the background color // will be the same as CefSettings.background_color. Only the RGB compontents // of the specified value will be used. The alpha component must greater than // 0 to enable use of the background color but will be otherwise ignored. /// cef_color_t background_color; /// // Comma delimited ordered list of language codes without any whitespace that // will be used in the "Accept-Language" HTTP header. May be set globally // using the CefBrowserSettings.accept_language_list value. If both values are // empty then "en-US,en" will be used. /// cef_string_t accept_language_list; } cef_browser_settings_t; /// // Return value types. /// typedef enum { /// // Cancel immediately. /// RV_CANCEL = 0, /// // Continue immediately. /// RV_CONTINUE, /// // Continue asynchronously (usually via a callback). /// RV_CONTINUE_ASYNC, } cef_return_value_t; /// // URL component parts. /// typedef struct _cef_urlparts_t { /// // The complete URL specification. /// cef_string_t spec; /// // Scheme component not including the colon (e.g., "http"). /// cef_string_t scheme; /// // User name component. /// cef_string_t username; /// // Password component. /// cef_string_t password; /// // Host component. This may be a hostname, an IPv4 address or an IPv6 literal // surrounded by square brackets (e.g., "[2001:db8::1]"). /// cef_string_t host; /// // Port number component. /// cef_string_t port; /// // Origin contains just the scheme, host, and port from a URL. Equivalent to // clearing any username and password, replacing the path with a slash, and // clearing everything after that. This value will be empty for non-standard // URLs. /// cef_string_t origin; /// // Path component including the first slash following the host. /// cef_string_t path; /// // Query string component (i.e., everything following the '?'). /// cef_string_t query; } cef_urlparts_t; /// // Cookie information. /// typedef struct _cef_cookie_t { /// // The cookie name. /// cef_string_t name; /// // The cookie value. /// cef_string_t value; /// // If |domain| is empty a host cookie will be created instead of a domain // cookie. Domain cookies are stored with a leading "." and are visible to // sub-domains whereas host cookies are not. /// cef_string_t domain; /// // If |path| is non-empty only URLs at or below the path will get the cookie // value. /// cef_string_t path; /// // If |secure| is true the cookie will only be sent for HTTPS requests. /// int secure; /// // If |httponly| is true the cookie will only be sent for HTTP requests. /// int httponly; /// // The cookie creation date. This is automatically populated by the system on // cookie creation. /// cef_time_t creation; /// // The cookie last access date. This is automatically populated by the system // on access. /// cef_time_t last_access; /// // The cookie expiration date is only valid if |has_expires| is true. /// int has_expires; cef_time_t expires; } cef_cookie_t; /// // Process termination status values. /// typedef enum { /// // Non-zero exit status. /// TS_ABNORMAL_TERMINATION, /// // SIGKILL or task manager kill. /// TS_PROCESS_WAS_KILLED, /// // Segmentation fault. /// TS_PROCESS_CRASHED, } cef_termination_status_t; /// // Path key values. /// typedef enum { /// // Current directory. /// PK_DIR_CURRENT, /// // Directory containing PK_FILE_EXE. /// PK_DIR_EXE, /// // Directory containing PK_FILE_MODULE. /// PK_DIR_MODULE, /// // Temporary directory. /// PK_DIR_TEMP, /// // Path and filename of the current executable. /// PK_FILE_EXE, /// // Path and filename of the module containing the CEF code (usually the libcef // module). /// PK_FILE_MODULE, /// // "Local Settings\Application Data" directory under the user profile // directory on Windows. /// PK_LOCAL_APP_DATA, /// // "Application Data" directory under the user profile directory on Windows // and "~/Library/Application Support" directory on Mac OS X. /// PK_USER_DATA, } cef_path_key_t; /// // Storage types. /// typedef enum { ST_LOCALSTORAGE = 0, ST_SESSIONSTORAGE, } cef_storage_type_t; /// // Supported error code values. See net\base\net_error_list.h for complete // descriptions of the error codes. /// typedef enum { ERR_NONE = 0, ERR_FAILED = -2, ERR_ABORTED = -3, ERR_INVALID_ARGUMENT = -4, ERR_INVALID_HANDLE = -5, ERR_FILE_NOT_FOUND = -6, ERR_TIMED_OUT = -7, ERR_FILE_TOO_BIG = -8, ERR_UNEXPECTED = -9, ERR_ACCESS_DENIED = -10, ERR_NOT_IMPLEMENTED = -11, ERR_CONNECTION_CLOSED = -100, ERR_CONNECTION_RESET = -101, ERR_CONNECTION_REFUSED = -102, ERR_CONNECTION_ABORTED = -103, ERR_CONNECTION_FAILED = -104, ERR_NAME_NOT_RESOLVED = -105, ERR_INTERNET_DISCONNECTED = -106, ERR_SSL_PROTOCOL_ERROR = -107, ERR_ADDRESS_INVALID = -108, ERR_ADDRESS_UNREACHABLE = -109, ERR_SSL_CLIENT_AUTH_CERT_NEEDED = -110, ERR_TUNNEL_CONNECTION_FAILED = -111, ERR_NO_SSL_VERSIONS_ENABLED = -112, ERR_SSL_VERSION_OR_CIPHER_MISMATCH = -113, ERR_SSL_RENEGOTIATION_REQUESTED = -114, ERR_CERT_COMMON_NAME_INVALID = -200, ERR_CERT_BEGIN = ERR_CERT_COMMON_NAME_INVALID, ERR_CERT_DATE_INVALID = -201, ERR_CERT_AUTHORITY_INVALID = -202, ERR_CERT_CONTAINS_ERRORS = -203, ERR_CERT_NO_REVOCATION_MECHANISM = -204, ERR_CERT_UNABLE_TO_CHECK_REVOCATION = -205, ERR_CERT_REVOKED = -206, ERR_CERT_INVALID = -207, ERR_CERT_WEAK_SIGNATURE_ALGORITHM = -208, // -209 is available: was ERR_CERT_NOT_IN_DNS. ERR_CERT_NON_UNIQUE_NAME = -210, ERR_CERT_WEAK_KEY = -211, ERR_CERT_NAME_CONSTRAINT_VIOLATION = -212, ERR_CERT_VALIDITY_TOO_LONG = -213, ERR_CERT_END = ERR_CERT_VALIDITY_TOO_LONG, ERR_INVALID_URL = -300, ERR_DISALLOWED_URL_SCHEME = -301, ERR_UNKNOWN_URL_SCHEME = -302, ERR_TOO_MANY_REDIRECTS = -310, ERR_UNSAFE_REDIRECT = -311, ERR_UNSAFE_PORT = -312, ERR_INVALID_RESPONSE = -320, ERR_INVALID_CHUNKED_ENCODING = -321, ERR_METHOD_NOT_SUPPORTED = -322, ERR_UNEXPECTED_PROXY_AUTH = -323, ERR_EMPTY_RESPONSE = -324, ERR_RESPONSE_HEADERS_TOO_BIG = -325, ERR_CACHE_MISS = -400, ERR_INSECURE_RESPONSE = -501, } cef_errorcode_t; /// // Supported certificate status code values. See net\cert\cert_status_flags.h // for more information. CERT_STATUS_NONE is new in CEF because we use an // enum while cert_status_flags.h uses a typedef and static const variables. /// typedef enum { CERT_STATUS_NONE = 0, CERT_STATUS_COMMON_NAME_INVALID = 1 << 0, CERT_STATUS_DATE_INVALID = 1 << 1, CERT_STATUS_AUTHORITY_INVALID = 1 << 2, // 1 << 3 is reserved for ERR_CERT_CONTAINS_ERRORS (not useful with WinHTTP). CERT_STATUS_NO_REVOCATION_MECHANISM = 1 << 4, CERT_STATUS_UNABLE_TO_CHECK_REVOCATION = 1 << 5, CERT_STATUS_REVOKED = 1 << 6, CERT_STATUS_INVALID = 1 << 7, CERT_STATUS_WEAK_SIGNATURE_ALGORITHM = 1 << 8, // 1 << 9 was used for CERT_STATUS_NOT_IN_DNS CERT_STATUS_NON_UNIQUE_NAME = 1 << 10, CERT_STATUS_WEAK_KEY = 1 << 11, // 1 << 12 was used for CERT_STATUS_WEAK_DH_KEY CERT_STATUS_PINNED_KEY_MISSING = 1 << 13, CERT_STATUS_NAME_CONSTRAINT_VIOLATION = 1 << 14, CERT_STATUS_VALIDITY_TOO_LONG = 1 << 15, // Bits 16 to 31 are for non-error statuses. CERT_STATUS_IS_EV = 1 << 16, CERT_STATUS_REV_CHECKING_ENABLED = 1 << 17, // Bit 18 was CERT_STATUS_IS_DNSSEC CERT_STATUS_SHA1_SIGNATURE_PRESENT = 1 << 19, CERT_STATUS_CT_COMPLIANCE_FAILED = 1 << 20, } cef_cert_status_t; /// // The manner in which a link click should be opened. /// typedef enum { WOD_UNKNOWN, WOD_SUPPRESS_OPEN, WOD_CURRENT_TAB, WOD_SINGLETON_TAB, WOD_NEW_FOREGROUND_TAB, WOD_NEW_BACKGROUND_TAB, WOD_NEW_POPUP, WOD_NEW_WINDOW, WOD_SAVE_TO_DISK, WOD_OFF_THE_RECORD, WOD_IGNORE_ACTION } cef_window_open_disposition_t; /// // "Verb" of a drag-and-drop operation as negotiated between the source and // destination. These constants match their equivalents in WebCore's // DragActions.h and should not be renumbered. /// typedef enum { DRAG_OPERATION_NONE = 0, DRAG_OPERATION_COPY = 1, DRAG_OPERATION_LINK = 2, DRAG_OPERATION_GENERIC = 4, DRAG_OPERATION_PRIVATE = 8, DRAG_OPERATION_MOVE = 16, DRAG_OPERATION_DELETE = 32, DRAG_OPERATION_EVERY = UINT_MAX } cef_drag_operations_mask_t; /// // V8 access control values. /// typedef enum { V8_ACCESS_CONTROL_DEFAULT = 0, V8_ACCESS_CONTROL_ALL_CAN_READ = 1, V8_ACCESS_CONTROL_ALL_CAN_WRITE = 1 << 1, V8_ACCESS_CONTROL_PROHIBITS_OVERWRITING = 1 << 2 } cef_v8_accesscontrol_t; /// // V8 property attribute values. /// typedef enum { V8_PROPERTY_ATTRIBUTE_NONE = 0, // Writeable, Enumerable, // Configurable V8_PROPERTY_ATTRIBUTE_READONLY = 1 << 0, // Not writeable V8_PROPERTY_ATTRIBUTE_DONTENUM = 1 << 1, // Not enumerable V8_PROPERTY_ATTRIBUTE_DONTDELETE = 1 << 2 // Not configurable } cef_v8_propertyattribute_t; /// // Post data elements may represent either bytes or files. /// typedef enum { PDE_TYPE_EMPTY = 0, PDE_TYPE_BYTES, PDE_TYPE_FILE, } cef_postdataelement_type_t; /// // Resource type for a request. /// typedef enum { /// // Top level page. /// RT_MAIN_FRAME = 0, /// // Frame or iframe. /// RT_SUB_FRAME, /// // CSS stylesheet. /// RT_STYLESHEET, /// // External script. /// RT_SCRIPT, /// // Image (jpg/gif/png/etc). /// RT_IMAGE, /// // Font. /// RT_FONT_RESOURCE, /// // Some other subresource. This is the default type if the actual type is // unknown. /// RT_SUB_RESOURCE, /// // Object (or embed) tag for a plugin, or a resource that a plugin requested. /// RT_OBJECT, /// // Media resource. /// RT_MEDIA, /// // Main resource of a dedicated worker. /// RT_WORKER, /// // Main resource of a shared worker. /// RT_SHARED_WORKER, /// // Explicitly requested prefetch. /// RT_PREFETCH, /// // Favicon. /// RT_FAVICON, /// // XMLHttpRequest. /// RT_XHR, /// // A request for a /// RT_PING, /// // Main resource of a service worker. /// RT_SERVICE_WORKER, /// // A report of Content Security Policy violations. /// RT_CSP_REPORT, /// // A resource that a plugin requested. /// RT_PLUGIN_RESOURCE, } cef_resource_type_t; /// // Transition type for a request. Made up of one source value and 0 or more // qualifiers. /// typedef enum { /// // Source is a link click or the JavaScript window.open function. This is // also the default value for requests like sub-resource loads that are not // navigations. /// TT_LINK = 0, /// // Source is some other "explicit" navigation action such as creating a new // browser or using the LoadURL function. This is also the default value // for navigations where the actual type is unknown. /// TT_EXPLICIT = 1, /// // Source is a subframe navigation. This is any content that is automatically // loaded in a non-toplevel frame. For example, if a page consists of several // frames containing ads, those ad URLs will have this transition type. // The user may not even realize the content in these pages is a separate // frame, so may not care about the URL. /// TT_AUTO_SUBFRAME = 3, /// // Source is a subframe navigation explicitly requested by the user that will // generate new navigation entries in the back/forward list. These are // probably more important than frames that were automatically loaded in // the background because the user probably cares about the fact that this // link was loaded. /// TT_MANUAL_SUBFRAME = 4, /// // Source is a form submission by the user. NOTE: In some situations // submitting a form does not result in this transition type. This can happen // if the form uses a script to submit the contents. /// TT_FORM_SUBMIT = 7, /// // Source is a "reload" of the page via the Reload function or by re-visiting // the same URL. NOTE: This is distinct from the concept of whether a // particular load uses "reload semantics" (i.e. bypasses cached data). /// TT_RELOAD = 8, /// // General mask defining the bits used for the source values. /// TT_SOURCE_MASK = 0xFF, // Qualifiers. // Any of the core values above can be augmented by one or more qualifiers. // These qualifiers further define the transition. /// // Attempted to visit a URL but was blocked. /// TT_BLOCKED_FLAG = 0x00800000, /// // Used the Forward or Back function to navigate among browsing history. /// TT_FORWARD_BACK_FLAG = 0x01000000, /// // The beginning of a navigation chain. /// TT_CHAIN_START_FLAG = 0x10000000, /// // The last transition in a redirect chain. /// TT_CHAIN_END_FLAG = 0x20000000, /// // Redirects caused by JavaScript or a meta refresh tag on the page. /// TT_CLIENT_REDIRECT_FLAG = 0x40000000, /// // Redirects sent from the server by HTTP headers. /// TT_SERVER_REDIRECT_FLAG = 0x80000000, /// // Used to test whether a transition involves a redirect. /// TT_IS_REDIRECT_MASK = 0xC0000000, /// // General mask defining the bits used for the qualifiers. /// TT_QUALIFIER_MASK = 0xFFFFFF00, } cef_transition_type_t; /// // Flags used to customize the behavior of CefURLRequest. /// typedef enum { /// // Default behavior. /// UR_FLAG_NONE = 0, /// // If set the cache will be skipped when handling the request. /// UR_FLAG_SKIP_CACHE = 1 << 0, /// // If set user name, password, and cookies may be sent with the request, and // cookies may be saved from the response. /// UR_FLAG_ALLOW_CACHED_CREDENTIALS = 1 << 1, /// // If set upload progress events will be generated when a request has a body. /// UR_FLAG_REPORT_UPLOAD_PROGRESS = 1 << 3, /// // If set the CefURLRequestClient::OnDownloadData method will not be called. /// UR_FLAG_NO_DOWNLOAD_DATA = 1 << 6, /// // If set 5XX redirect errors will be propagated to the observer instead of // automatically re-tried. This currently only applies for requests // originated in the browser process. /// UR_FLAG_NO_RETRY_ON_5XX = 1 << 7, } cef_urlrequest_flags_t; /// // Flags that represent CefURLRequest status. /// typedef enum { /// // Unknown status. /// UR_UNKNOWN = 0, /// // Request succeeded. /// UR_SUCCESS, /// // An IO request is pending, and the caller will be informed when it is // completed. /// UR_IO_PENDING, /// // Request was canceled programatically. /// UR_CANCELED, /// // Request failed for some reason. /// UR_FAILED, } cef_urlrequest_status_t; /// // Structure representing a point. /// typedef struct _cef_point_t { int x; int y; } cef_point_t; /// // Structure representing a rectangle. /// typedef struct _cef_rect_t { int x; int y; int width; int height; } cef_rect_t; /// // Structure representing a size. /// typedef struct _cef_size_t { int width; int height; } cef_size_t; /// // Structure representing a draggable region. /// typedef struct _cef_draggable_region_t { /// // Bounds of the region. /// cef_rect_t bounds; /// // True (1) this this region is draggable and false (0) otherwise. /// int draggable; } cef_draggable_region_t; /// // Existing process IDs. /// typedef enum { /// // Browser process. /// PID_BROWSER, /// // Renderer process. /// PID_RENDERER, } cef_process_id_t; /// // Existing thread IDs. /// typedef enum { // BROWSER PROCESS THREADS -- Only available in the browser process. /// // The main thread in the browser. This will be the same as the main // application thread if CefInitialize() is called with a // CefSettings.multi_threaded_message_loop value of false. /// TID_UI, /// // Used to interact with the database. /// TID_DB, /// // Used to interact with the file system. /// TID_FILE, /// // Used for file system operations that block user interactions. // Responsiveness of this thread affects users. /// TID_FILE_USER_BLOCKING, /// // Used to launch and terminate browser processes. /// TID_PROCESS_LAUNCHER, /// // Used to handle slow HTTP cache operations. /// TID_CACHE, /// // Used to process IPC and network messages. /// TID_IO, // RENDER PROCESS THREADS -- Only available in the render process. /// // The main thread in the renderer. Used for all WebKit and V8 interaction. /// TID_RENDERER, } cef_thread_id_t; /// // Supported value types. /// typedef enum { VTYPE_INVALID = 0, VTYPE_NULL, VTYPE_BOOL, VTYPE_INT, VTYPE_DOUBLE, VTYPE_STRING, VTYPE_BINARY, VTYPE_DICTIONARY, VTYPE_LIST, } cef_value_type_t; /// // Supported JavaScript dialog types. /// typedef enum { JSDIALOGTYPE_ALERT = 0, JSDIALOGTYPE_CONFIRM, JSDIALOGTYPE_PROMPT, } cef_jsdialog_type_t; /// // Screen information used when window rendering is disabled. This structure is // passed as a parameter to CefRenderHandler::GetScreenInfo and should be filled // in by the client. /// typedef struct _cef_screen_info_t { /// // Device scale factor. Specifies the ratio between physical and logical // pixels. /// float device_scale_factor; /// // The screen depth in bits per pixel. /// int depth; /// // The bits per color component. This assumes that the colors are balanced // equally. /// int depth_per_component; /// // This can be true for black and white printers. /// int is_monochrome; /// // This is set from the rcMonitor member of MONITORINFOEX, to whit: // "A RECT structure that specifies the display monitor rectangle, // expressed in virtual-screen coordinates. Note that if the monitor // is not the primary display monitor, some of the rectangle's // coordinates may be negative values." // // The |rect| and |available_rect| properties are used to determine the // available surface for rendering popup views. /// cef_rect_t rect; /// // This is set from the rcWork member of MONITORINFOEX, to whit: // "A RECT structure that specifies the work area rectangle of the // display monitor that can be used by applications, expressed in // virtual-screen coordinates. Windows uses this rectangle to // maximize an application on the monitor. The rest of the area in // rcMonitor contains system windows such as the task bar and side // bars. Note that if the monitor is not the primary display monitor, // some of the rectangle's coordinates may be negative values". // // The |rect| and |available_rect| properties are used to determine the // available surface for rendering popup views. /// cef_rect_t available_rect; } cef_screen_info_t; /// // Supported menu IDs. Non-English translations can be provided for the // IDS_MENU_* strings in CefResourceBundleHandler::GetLocalizedString(). /// typedef enum { // Navigation. MENU_ID_BACK = 100, MENU_ID_FORWARD = 101, MENU_ID_RELOAD = 102, MENU_ID_RELOAD_NOCACHE = 103, MENU_ID_STOPLOAD = 104, // Editing. MENU_ID_UNDO = 110, MENU_ID_REDO = 111, MENU_ID_CUT = 112, MENU_ID_COPY = 113, MENU_ID_PASTE = 114, MENU_ID_DELETE = 115, MENU_ID_SELECT_ALL = 116, // Miscellaneous. MENU_ID_FIND = 130, MENU_ID_PRINT = 131, MENU_ID_VIEW_SOURCE = 132, // Spell checking word correction suggestions. MENU_ID_SPELLCHECK_SUGGESTION_0 = 200, MENU_ID_SPELLCHECK_SUGGESTION_1 = 201, MENU_ID_SPELLCHECK_SUGGESTION_2 = 202, MENU_ID_SPELLCHECK_SUGGESTION_3 = 203, MENU_ID_SPELLCHECK_SUGGESTION_4 = 204, MENU_ID_SPELLCHECK_SUGGESTION_LAST = 204, MENU_ID_NO_SPELLING_SUGGESTIONS = 205, MENU_ID_ADD_TO_DICTIONARY = 206, // Custom menu items originating from the renderer process. For example, // plugin placeholder menu items or Flash menu items. MENU_ID_CUSTOM_FIRST = 220, MENU_ID_CUSTOM_LAST = 250, // All user-defined menu IDs should come between MENU_ID_USER_FIRST and // MENU_ID_USER_LAST to avoid overlapping the Chromium and CEF ID ranges // defined in the tools/gritsettings/resource_ids file. MENU_ID_USER_FIRST = 26500, MENU_ID_USER_LAST = 28500, } cef_menu_id_t; /// // Mouse button types. /// typedef enum { MBT_LEFT = 0, MBT_MIDDLE, MBT_RIGHT, } cef_mouse_button_type_t; /// // Structure representing mouse event information. /// typedef struct _cef_mouse_event_t { /// // X coordinate relative to the left side of the view. /// int x; /// // Y coordinate relative to the top side of the view. /// int y; /// // Bit flags describing any pressed modifier keys. See // cef_event_flags_t for values. /// uint32 modifiers; } cef_mouse_event_t; /// // Paint element types. /// typedef enum { PET_VIEW = 0, PET_POPUP, } cef_paint_element_type_t; /// // Supported event bit flags. /// typedef enum { EVENTFLAG_NONE = 0, EVENTFLAG_CAPS_LOCK_ON = 1 << 0, EVENTFLAG_SHIFT_DOWN = 1 << 1, EVENTFLAG_CONTROL_DOWN = 1 << 2, EVENTFLAG_ALT_DOWN = 1 << 3, EVENTFLAG_LEFT_MOUSE_BUTTON = 1 << 4, EVENTFLAG_MIDDLE_MOUSE_BUTTON = 1 << 5, EVENTFLAG_RIGHT_MOUSE_BUTTON = 1 << 6, // Mac OS-X command key. EVENTFLAG_COMMAND_DOWN = 1 << 7, EVENTFLAG_NUM_LOCK_ON = 1 << 8, EVENTFLAG_IS_KEY_PAD = 1 << 9, EVENTFLAG_IS_LEFT = 1 << 10, EVENTFLAG_IS_RIGHT = 1 << 11, } cef_event_flags_t; /// // Supported menu item types. /// typedef enum { MENUITEMTYPE_NONE, MENUITEMTYPE_COMMAND, MENUITEMTYPE_CHECK, MENUITEMTYPE_RADIO, MENUITEMTYPE_SEPARATOR, MENUITEMTYPE_SUBMENU, } cef_menu_item_type_t; /// // Supported context menu type flags. /// typedef enum { /// // No node is selected. /// CM_TYPEFLAG_NONE = 0, /// // The top page is selected. /// CM_TYPEFLAG_PAGE = 1 << 0, /// // A subframe page is selected. /// CM_TYPEFLAG_FRAME = 1 << 1, /// // A link is selected. /// CM_TYPEFLAG_LINK = 1 << 2, /// // A media node is selected. /// CM_TYPEFLAG_MEDIA = 1 << 3, /// // There is a textual or mixed selection that is selected. /// CM_TYPEFLAG_SELECTION = 1 << 4, /// // An editable element is selected. /// CM_TYPEFLAG_EDITABLE = 1 << 5, } cef_context_menu_type_flags_t; /// // Supported context menu media types. /// typedef enum { /// // No special node is in context. /// CM_MEDIATYPE_NONE, /// // An image node is selected. /// CM_MEDIATYPE_IMAGE, /// // A video node is selected. /// CM_MEDIATYPE_VIDEO, /// // An audio node is selected. /// CM_MEDIATYPE_AUDIO, /// // A file node is selected. /// CM_MEDIATYPE_FILE, /// // A plugin node is selected. /// CM_MEDIATYPE_PLUGIN, } cef_context_menu_media_type_t; /// // Supported context menu media state bit flags. /// typedef enum { CM_MEDIAFLAG_NONE = 0, CM_MEDIAFLAG_ERROR = 1 << 0, CM_MEDIAFLAG_PAUSED = 1 << 1, CM_MEDIAFLAG_MUTED = 1 << 2, CM_MEDIAFLAG_LOOP = 1 << 3, CM_MEDIAFLAG_CAN_SAVE = 1 << 4, CM_MEDIAFLAG_HAS_AUDIO = 1 << 5, CM_MEDIAFLAG_HAS_VIDEO = 1 << 6, CM_MEDIAFLAG_CONTROL_ROOT_ELEMENT = 1 << 7, CM_MEDIAFLAG_CAN_PRINT = 1 << 8, CM_MEDIAFLAG_CAN_ROTATE = 1 << 9, } cef_context_menu_media_state_flags_t; /// // Supported context menu edit state bit flags. /// typedef enum { CM_EDITFLAG_NONE = 0, CM_EDITFLAG_CAN_UNDO = 1 << 0, CM_EDITFLAG_CAN_REDO = 1 << 1, CM_EDITFLAG_CAN_CUT = 1 << 2, CM_EDITFLAG_CAN_COPY = 1 << 3, CM_EDITFLAG_CAN_PASTE = 1 << 4, CM_EDITFLAG_CAN_DELETE = 1 << 5, CM_EDITFLAG_CAN_SELECT_ALL = 1 << 6, CM_EDITFLAG_CAN_TRANSLATE = 1 << 7, } cef_context_menu_edit_state_flags_t; /// // Key event types. /// typedef enum { /// // Notification that a key transitioned from "up" to "down". /// KEYEVENT_RAWKEYDOWN = 0, /// // Notification that a key was pressed. This does not necessarily correspond // to a character depending on the key and language. Use KEYEVENT_CHAR for // character input. /// KEYEVENT_KEYDOWN, /// // Notification that a key was released. /// KEYEVENT_KEYUP, /// // Notification that a character was typed. Use this for text input. Key // down events may generate 0, 1, or more than one character event depending // on the key, locale, and operating system. /// KEYEVENT_CHAR } cef_key_event_type_t; /// // Structure representing keyboard event information. /// typedef struct _cef_key_event_t { /// // The type of keyboard event. /// cef_key_event_type_t type; /// // Bit flags describing any pressed modifier keys. See // cef_event_flags_t for values. /// uint32 modifiers; /// // The Windows key code for the key event. This value is used by the DOM // specification. Sometimes it comes directly from the event (i.e. on // Windows) and sometimes it's determined using a mapping function. See // WebCore/platform/chromium/KeyboardCodes.h for the list of values. /// int windows_key_code; /// // The actual key code genenerated by the platform. /// int native_key_code; /// // Indicates whether the event is considered a "system key" event (see // http://msdn.microsoft.com/en-us/library/ms646286(VS.85).aspx for details). // This value will always be false on non-Windows platforms. /// int is_system_key; /// // The character generated by the keystroke. /// char16 character; /// // Same as |character| but unmodified by any concurrently-held modifiers // (except shift). This is useful for working out shortcut keys. /// char16 unmodified_character; /// // True if the focus is currently on an editable field on the page. This is // useful for determining if standard key events should be intercepted. /// int focus_on_editable_field; } cef_key_event_t; /// // Focus sources. /// typedef enum { /// // The source is explicit navigation via the API (LoadURL(), etc). /// FOCUS_SOURCE_NAVIGATION = 0, /// // The source is a system-generated focus event. /// FOCUS_SOURCE_SYSTEM, } cef_focus_source_t; /// // Navigation types. /// typedef enum { NAVIGATION_LINK_CLICKED = 0, NAVIGATION_FORM_SUBMITTED, NAVIGATION_BACK_FORWARD, NAVIGATION_RELOAD, NAVIGATION_FORM_RESUBMITTED, NAVIGATION_OTHER, } cef_navigation_type_t; /// // Supported XML encoding types. The parser supports ASCII, ISO-8859-1, and // UTF16 (LE and BE) by default. All other types must be translated to UTF8 // before being passed to the parser. If a BOM is detected and the correct // decoder is available then that decoder will be used automatically. /// typedef enum { XML_ENCODING_NONE = 0, XML_ENCODING_UTF8, XML_ENCODING_UTF16LE, XML_ENCODING_UTF16BE, XML_ENCODING_ASCII, } cef_xml_encoding_type_t; /// // XML node types. /// typedef enum { XML_NODE_UNSUPPORTED = 0, XML_NODE_PROCESSING_INSTRUCTION, XML_NODE_DOCUMENT_TYPE, XML_NODE_ELEMENT_START, XML_NODE_ELEMENT_END, XML_NODE_ATTRIBUTE, XML_NODE_TEXT, XML_NODE_CDATA, XML_NODE_ENTITY_REFERENCE, XML_NODE_WHITESPACE, XML_NODE_COMMENT, } cef_xml_node_type_t; /// // Popup window features. /// typedef struct _cef_popup_features_t { int x; int xSet; int y; int ySet; int width; int widthSet; int height; int heightSet; int menuBarVisible; int statusBarVisible; int toolBarVisible; int locationBarVisible; int scrollbarsVisible; int resizable; int fullscreen; int dialog; cef_string_list_t additionalFeatures; } cef_popup_features_t; /// // DOM document types. /// typedef enum { DOM_DOCUMENT_TYPE_UNKNOWN = 0, DOM_DOCUMENT_TYPE_HTML, DOM_DOCUMENT_TYPE_XHTML, DOM_DOCUMENT_TYPE_PLUGIN, } cef_dom_document_type_t; /// // DOM event category flags. /// typedef enum { DOM_EVENT_CATEGORY_UNKNOWN = 0x0, DOM_EVENT_CATEGORY_UI = 0x1, DOM_EVENT_CATEGORY_MOUSE = 0x2, DOM_EVENT_CATEGORY_MUTATION = 0x4, DOM_EVENT_CATEGORY_KEYBOARD = 0x8, DOM_EVENT_CATEGORY_TEXT = 0x10, DOM_EVENT_CATEGORY_COMPOSITION = 0x20, DOM_EVENT_CATEGORY_DRAG = 0x40, DOM_EVENT_CATEGORY_CLIPBOARD = 0x80, DOM_EVENT_CATEGORY_MESSAGE = 0x100, DOM_EVENT_CATEGORY_WHEEL = 0x200, DOM_EVENT_CATEGORY_BEFORE_TEXT_INSERTED = 0x400, DOM_EVENT_CATEGORY_OVERFLOW = 0x800, DOM_EVENT_CATEGORY_PAGE_TRANSITION = 0x1000, DOM_EVENT_CATEGORY_POPSTATE = 0x2000, DOM_EVENT_CATEGORY_PROGRESS = 0x4000, DOM_EVENT_CATEGORY_XMLHTTPREQUEST_PROGRESS = 0x8000, } cef_dom_event_category_t; /// // DOM event processing phases. /// typedef enum { DOM_EVENT_PHASE_UNKNOWN = 0, DOM_EVENT_PHASE_CAPTURING, DOM_EVENT_PHASE_AT_TARGET, DOM_EVENT_PHASE_BUBBLING, } cef_dom_event_phase_t; /// // DOM node types. /// typedef enum { DOM_NODE_TYPE_UNSUPPORTED = 0, DOM_NODE_TYPE_ELEMENT, DOM_NODE_TYPE_ATTRIBUTE, DOM_NODE_TYPE_TEXT, DOM_NODE_TYPE_CDATA_SECTION, DOM_NODE_TYPE_PROCESSING_INSTRUCTIONS, DOM_NODE_TYPE_COMMENT, DOM_NODE_TYPE_DOCUMENT, DOM_NODE_TYPE_DOCUMENT_TYPE, DOM_NODE_TYPE_DOCUMENT_FRAGMENT, } cef_dom_node_type_t; /// // Supported file dialog modes. /// typedef enum { /// // Requires that the file exists before allowing the user to pick it. /// FILE_DIALOG_OPEN = 0, /// // Like Open, but allows picking multiple files to open. /// FILE_DIALOG_OPEN_MULTIPLE, /// // Like Open, but selects a folder to open. /// FILE_DIALOG_OPEN_FOLDER, /// // Allows picking a nonexistent file, and prompts to overwrite if the file // already exists. /// FILE_DIALOG_SAVE, /// // General mask defining the bits used for the type values. /// FILE_DIALOG_TYPE_MASK = 0xFF, // Qualifiers. // Any of the type values above can be augmented by one or more qualifiers. // These qualifiers further define the dialog behavior. /// // Prompt to overwrite if the user selects an existing file with the Save // dialog. /// FILE_DIALOG_OVERWRITEPROMPT_FLAG = 0x01000000, /// // Do not display read-only files. /// FILE_DIALOG_HIDEREADONLY_FLAG = 0x02000000, } cef_file_dialog_mode_t; /// // Geoposition error codes. /// typedef enum { GEOPOSITON_ERROR_NONE = 0, GEOPOSITON_ERROR_PERMISSION_DENIED, GEOPOSITON_ERROR_POSITION_UNAVAILABLE, GEOPOSITON_ERROR_TIMEOUT, } cef_geoposition_error_code_t; /// // Structure representing geoposition information. The properties of this // structure correspond to those of the JavaScript Position object although // their types may differ. /// typedef struct _cef_geoposition_t { /// // Latitude in decimal degrees north (WGS84 coordinate frame). /// double latitude; /// // Longitude in decimal degrees west (WGS84 coordinate frame). /// double longitude; /// // Altitude in meters (above WGS84 datum). /// double altitude; /// // Accuracy of horizontal position in meters. /// double accuracy; /// // Accuracy of altitude in meters. /// double altitude_accuracy; /// // Heading in decimal degrees clockwise from true north. /// double heading; /// // Horizontal component of device velocity in meters per second. /// double speed; /// // Time of position measurement in milliseconds since Epoch in UTC time. This // is taken from the host computer's system clock. /// cef_time_t timestamp; /// // Error code, see enum above. /// cef_geoposition_error_code_t error_code; /// // Human-readable error message. /// cef_string_t error_message; } cef_geoposition_t; /// // Print job color mode values. /// typedef enum { COLOR_MODEL_UNKNOWN, COLOR_MODEL_GRAY, COLOR_MODEL_COLOR, COLOR_MODEL_CMYK, COLOR_MODEL_CMY, COLOR_MODEL_KCMY, COLOR_MODEL_CMY_K, // CMY_K represents CMY+K. COLOR_MODEL_BLACK, COLOR_MODEL_GRAYSCALE, COLOR_MODEL_RGB, COLOR_MODEL_RGB16, COLOR_MODEL_RGBA, COLOR_MODEL_COLORMODE_COLOR, // Used in samsung printer ppds. COLOR_MODEL_COLORMODE_MONOCHROME, // Used in samsung printer ppds. COLOR_MODEL_HP_COLOR_COLOR, // Used in HP color printer ppds. COLOR_MODEL_HP_COLOR_BLACK, // Used in HP color printer ppds. COLOR_MODEL_PRINTOUTMODE_NORMAL, // Used in foomatic ppds. COLOR_MODEL_PRINTOUTMODE_NORMAL_GRAY, // Used in foomatic ppds. COLOR_MODEL_PROCESSCOLORMODEL_CMYK, // Used in canon printer ppds. COLOR_MODEL_PROCESSCOLORMODEL_GREYSCALE, // Used in canon printer ppds. COLOR_MODEL_PROCESSCOLORMODEL_RGB, // Used in canon printer ppds } cef_color_model_t; /// // Print job duplex mode values. /// typedef enum { DUPLEX_MODE_UNKNOWN = -1, DUPLEX_MODE_SIMPLEX, DUPLEX_MODE_LONG_EDGE, DUPLEX_MODE_SHORT_EDGE, } cef_duplex_mode_t; /// // Structure representing a print job page range. /// typedef struct _cef_page_range_t { int from; int to; } cef_page_range_t; /// // Cursor type values. /// typedef enum { CT_POINTER = 0, CT_CROSS, CT_HAND, CT_IBEAM, CT_WAIT, CT_HELP, CT_EASTRESIZE, CT_NORTHRESIZE, CT_NORTHEASTRESIZE, CT_NORTHWESTRESIZE, CT_SOUTHRESIZE, CT_SOUTHEASTRESIZE, CT_SOUTHWESTRESIZE, CT_WESTRESIZE, CT_NORTHSOUTHRESIZE, CT_EASTWESTRESIZE, CT_NORTHEASTSOUTHWESTRESIZE, CT_NORTHWESTSOUTHEASTRESIZE, CT_COLUMNRESIZE, CT_ROWRESIZE, CT_MIDDLEPANNING, CT_EASTPANNING, CT_NORTHPANNING, CT_NORTHEASTPANNING, CT_NORTHWESTPANNING, CT_SOUTHPANNING, CT_SOUTHEASTPANNING, CT_SOUTHWESTPANNING, CT_WESTPANNING, CT_MOVE, CT_VERTICALTEXT, CT_CELL, CT_CONTEXTMENU, CT_ALIAS, CT_PROGRESS, CT_NODROP, CT_COPY, CT_NONE, CT_NOTALLOWED, CT_ZOOMIN, CT_ZOOMOUT, CT_GRAB, CT_GRABBING, CT_CUSTOM, } cef_cursor_type_t; /// // Structure representing cursor information. |buffer| will be // |size.width|*|size.height|*4 bytes in size and represents a BGRA image with // an upper-left origin. /// typedef struct _cef_cursor_info_t { cef_point_t hotspot; float image_scale_factor; void* buffer; cef_size_t size; } cef_cursor_info_t; /// // URI unescape rules passed to CefURIDecode(). /// typedef enum { /// // Don't unescape anything at all. /// UU_NONE = 0, /// // Don't unescape anything special, but all normal unescaping will happen. // This is a placeholder and can't be combined with other flags (since it's // just the absence of them). All other unescape rules imply "normal" in // addition to their special meaning. Things like escaped letters, digits, // and most symbols will get unescaped with this mode. /// UU_NORMAL = 1, /// // Convert %20 to spaces. In some places where we're showing URLs, we may // want this. In places where the URL may be copied and pasted out, then // you wouldn't want this since it might not be interpreted in one piece // by other applications. /// UU_SPACES = 2, /// // Unescapes various characters that will change the meaning of URLs, // including '%', '+', '&', '/', '#'. If we unescaped these characters, the // resulting URL won't be the same as the source one. This flag is used when // generating final output like filenames for URLs where we won't be // interpreting as a URL and want to do as much unescaping as possible. /// UU_URL_SPECIAL_CHARS = 4, /// // Unescapes control characters such as %01. This INCLUDES NULLs. This is // used for rare cases such as data: URL decoding where the result is binary // data. This flag also unescapes BiDi control characters. // // DO NOT use CONTROL_CHARS if the URL is going to be displayed in the UI // for security reasons. /// UU_CONTROL_CHARS = 8, /// // URL queries use "+" for space. This flag controls that replacement. /// UU_REPLACE_PLUS_WITH_SPACE = 16, } cef_uri_unescape_rule_t; /// // Options that can be passed to CefParseJSON. /// typedef enum { /// // Parses the input strictly according to RFC 4627. See comments in Chromium's // base/json/json_reader.h file for known limitations/deviations from the RFC. /// JSON_PARSER_RFC = 0, /// // Allows commas to exist after the last element in structures. /// JSON_PARSER_ALLOW_TRAILING_COMMAS = 1 << 0, } cef_json_parser_options_t; /// // Error codes that can be returned from CefParseJSONAndReturnError. /// typedef enum { JSON_NO_ERROR = 0, JSON_INVALID_ESCAPE, JSON_SYNTAX_ERROR, JSON_UNEXPECTED_TOKEN, JSON_TRAILING_COMMA, JSON_TOO_MUCH_NESTING, JSON_UNEXPECTED_DATA_AFTER_ROOT, JSON_UNSUPPORTED_ENCODING, JSON_UNQUOTED_DICTIONARY_KEY, JSON_PARSE_ERROR_COUNT } cef_json_parser_error_t; /// // Options that can be passed to CefWriteJSON. /// typedef enum { /// // Default behavior. /// JSON_WRITER_DEFAULT = 0, /// // This option instructs the writer that if a Binary value is encountered, // the value (and key if within a dictionary) will be omitted from the // output, and success will be returned. Otherwise, if a binary value is // encountered, failure will be returned. /// JSON_WRITER_OMIT_BINARY_VALUES = 1 << 0, /// // This option instructs the writer to write doubles that have no fractional // part as a normal integer (i.e., without using exponential notation // or appending a '.0') as long as the value is within the range of a // 64-bit int. /// JSON_WRITER_OMIT_DOUBLE_TYPE_PRESERVATION = 1 << 1, /// // Return a slightly nicer formatted json string (pads with whitespace to // help with readability). /// JSON_WRITER_PRETTY_PRINT = 1 << 2, } cef_json_writer_options_t; /// // Margin type for PDF printing. /// typedef enum { /// // Default margins. /// PDF_PRINT_MARGIN_DEFAULT, /// // No margins. /// PDF_PRINT_MARGIN_NONE, /// // Minimum margins. /// PDF_PRINT_MARGIN_MINIMUM, /// // Custom margins using the |margin_*| values from cef_pdf_print_settings_t. /// PDF_PRINT_MARGIN_CUSTOM, } cef_pdf_print_margin_type_t; /// // Structure representing PDF print settings. /// typedef struct _cef_pdf_print_settings_t { /// // Page title to display in the header. Only used if |header_footer_enabled| // is set to true (1). /// cef_string_t header_footer_title; /// // URL to display in the footer. Only used if |header_footer_enabled| is set // to true (1). /// cef_string_t header_footer_url; /// // Output page size in microns. If either of these values is less than or // equal to zero then the default paper size (A4) will be used. /// int page_width; int page_height; /// // Margins in millimeters. Only used if |margin_type| is set to // PDF_PRINT_MARGIN_CUSTOM. /// double margin_top; double margin_right; double margin_bottom; double margin_left; /// // Margin type. /// cef_pdf_print_margin_type_t margin_type; /// // Set to true (1) to print headers and footers or false (0) to not print // headers and footers. /// int header_footer_enabled; /// // Set to true (1) to print the selection only or false (0) to print all. /// int selection_only; /// // Set to true (1) for landscape mode or false (0) for portrait mode. /// int landscape; /// // Set to true (1) to print background graphics or false (0) to not print // background graphics. /// int backgrounds_enabled; } cef_pdf_print_settings_t; /// // Supported UI scale factors for the platform. SCALE_FACTOR_NONE is used for // density independent resources such as string, html/js files or an image that // can be used for any scale factors (such as wallpapers). /// typedef enum { SCALE_FACTOR_NONE = 0, SCALE_FACTOR_100P, SCALE_FACTOR_125P, SCALE_FACTOR_133P, SCALE_FACTOR_140P, SCALE_FACTOR_150P, SCALE_FACTOR_180P, SCALE_FACTOR_200P, SCALE_FACTOR_250P, SCALE_FACTOR_300P, } cef_scale_factor_t; /// // Plugin policies supported by CefRequestContextHandler::OnBeforePluginLoad. /// typedef enum { /// // Allow the content. /// PLUGIN_POLICY_ALLOW, /// // Allow important content and block unimportant content based on heuristics. // The user can manually load blocked content. /// PLUGIN_POLICY_DETECT_IMPORTANT, /// // Block the content. The user can manually load blocked content. /// PLUGIN_POLICY_BLOCK, /// // Disable the content. The user cannot load disabled content. /// PLUGIN_POLICY_DISABLE, } cef_plugin_policy_t; /// // Policy for how the Referrer HTTP header value will be sent during navigation. // If the `--no-referrers` command-line flag is specified then the policy value // will be ignored and the Referrer value will never be sent. /// typedef enum { /// // Always send the complete Referrer value. /// REFERRER_POLICY_ALWAYS, /// // Use the default policy. This is REFERRER_POLICY_ORIGIN_WHEN_CROSS_ORIGIN // when the `--reduced-referrer-granularity` command-line flag is specified // and REFERRER_POLICY_NO_REFERRER_WHEN_DOWNGRADE otherwise. // /// REFERRER_POLICY_DEFAULT, /// // When navigating from HTTPS to HTTP do not send the Referrer value. // Otherwise, send the complete Referrer value. /// REFERRER_POLICY_NO_REFERRER_WHEN_DOWNGRADE, /// // Never send the Referrer value. /// REFERRER_POLICY_NEVER, /// // Only send the origin component of the Referrer value. /// REFERRER_POLICY_ORIGIN, /// // When navigating cross-origin only send the origin component of the Referrer // value. Otherwise, send the complete Referrer value. /// REFERRER_POLICY_ORIGIN_WHEN_CROSS_ORIGIN, } cef_referrer_policy_t; /// // Return values for CefResponseFilter::Filter(). /// typedef enum { /// // Some or all of the pre-filter data was read successfully but more data is // needed in order to continue filtering (filtered output is pending). /// RESPONSE_FILTER_NEED_MORE_DATA, /// // Some or all of the pre-filter data was read successfully and all available // filtered output has been written. /// RESPONSE_FILTER_DONE, /// // An error occurred during filtering. /// RESPONSE_FILTER_ERROR } cef_response_filter_status_t; #ifdef __cplusplus } #endif #endif // CEF_INCLUDE_INTERNAL_CEF_TYPES_H_ cefpython-49.0/src/include/internal/cef_types_linux.h000066400000000000000000000077321334103266300230560ustar00rootroot00000000000000// Copyright (c) 2014 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_INTERNAL_CEF_TYPES_LINUX_H_ #define CEF_INCLUDE_INTERNAL_CEF_TYPES_LINUX_H_ #pragma once #include "include/base/cef_build.h" #if defined(OS_LINUX) typedef union _XEvent XEvent; typedef struct _XDisplay XDisplay; #include "include/internal/cef_export.h" #include "include/internal/cef_string.h" // Handle types. #define cef_cursor_handle_t unsigned long #define cef_event_handle_t XEvent* #define cef_window_handle_t unsigned long #define kNullCursorHandle 0 #define kNullEventHandle NULL #define kNullWindowHandle 0 #ifdef __cplusplus extern "C" { #endif /// // Return the singleton X11 display shared with Chromium. The display is not // thread-safe and must only be accessed on the browser process UI thread. /// CEF_EXPORT XDisplay* cef_get_xdisplay(); #define cef_text_input_context_t void* /// // Structure representing CefExecuteProcess arguments. /// typedef struct _cef_main_args_t { int argc; char** argv; } cef_main_args_t; /// // Class representing window information. /// typedef struct _cef_window_info_t { unsigned int x; unsigned int y; unsigned int width; unsigned int height; /// // Pointer for the parent window. /// cef_window_handle_t parent_window; /// // Set to true (1) to create the browser using windowless (off-screen) // rendering. No window will be created for the browser and all rendering will // occur via the CefRenderHandler interface. The |parent_window| value will be // used to identify monitor info and to act as the parent window for dialogs, // context menus, etc. If |parent_window| is not provided then the main screen // monitor will be used and some functionality that requires a parent window // may not function correctly. In order to create windowless browsers the // CefSettings.windowless_rendering_enabled value must be set to true. /// int windowless_rendering_enabled; /// // Set to true (1) to enable transparent painting in combination with // windowless rendering. When this value is true a transparent background // color will be used (RGBA=0x00000000). When this value is false the // background will be white and opaque. /// int transparent_painting_enabled; /// // Pointer for the new browser window. Only used with windowed rendering. /// cef_window_handle_t window; } cef_window_info_t; #ifdef __cplusplus } #endif #endif // OS_LINUX #endif // CEF_INCLUDE_INTERNAL_CEF_TYPES_LINUX_H_ cefpython-49.0/src/include/internal/cef_types_mac.h000066400000000000000000000101201334103266300224400ustar00rootroot00000000000000// Copyright (c) 2014 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_INTERNAL_CEF_TYPES_MAC_H_ #define CEF_INCLUDE_INTERNAL_CEF_TYPES_MAC_H_ #pragma once #include "include/base/cef_build.h" #if defined(OS_MACOSX) #include "include/internal/cef_string.h" // Handle types. #ifdef __cplusplus #ifdef __OBJC__ @class NSCursor; @class NSEvent; @class NSView; @class NSTextInputContext; #else class NSCursor; class NSEvent; struct NSView; class NSTextInputContext; #endif #define cef_cursor_handle_t NSCursor* #define cef_event_handle_t NSEvent* #define cef_window_handle_t NSView* #define cef_text_input_context_t NSTextInputContext* #else #define cef_cursor_handle_t void* #define cef_event_handle_t void* #define cef_window_handle_t void* #define cef_text_input_context_t void* #endif #define kNullCursorHandle NULL #define kNullEventHandle NULL #define kNullWindowHandle NULL #ifdef __cplusplus extern "C" { #endif /// // Structure representing CefExecuteProcess arguments. /// typedef struct _cef_main_args_t { int argc; char** argv; } cef_main_args_t; /// // Class representing window information. /// typedef struct _cef_window_info_t { cef_string_t window_name; int x; int y; int width; int height; /// // Set to true (1) to create the view initially hidden. /// int hidden; /// // NSView pointer for the parent view. /// cef_window_handle_t parent_view; /// // Set to true (1) to create the browser using windowless (off-screen) // rendering. No view will be created for the browser and all rendering will // occur via the CefRenderHandler interface. The |parent_view| value will be // used to identify monitor info and to act as the parent view for dialogs, // context menus, etc. If |parent_view| is not provided then the main screen // monitor will be used and some functionality that requires a parent view // may not function correctly. In order to create windowless browsers the // CefSettings.windowless_rendering_enabled value must be set to true. /// int windowless_rendering_enabled; /// // Set to true (1) to enable transparent painting in combination with // windowless rendering. When this value is true a transparent background // color will be used (RGBA=0x00000000). When this value is false the // background will be white and opaque. /// int transparent_painting_enabled; /// // NSView pointer for the new browser view. Only used with windowed rendering. /// cef_window_handle_t view; } cef_window_info_t; #ifdef __cplusplus } #endif #endif // OS_MACOSX #endif // CEF_INCLUDE_INTERNAL_CEF_TYPES_MAC_H_ cefpython-49.0/src/include/internal/cef_types_win.h000066400000000000000000000073151334103266300225110ustar00rootroot00000000000000// Copyright (c) 2009 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_INTERNAL_CEF_TYPES_WIN_H_ #define CEF_INCLUDE_INTERNAL_CEF_TYPES_WIN_H_ #pragma once #include "include/base/cef_build.h" #if defined(OS_WIN) #include #include "include/internal/cef_string.h" // Handle types. #define cef_cursor_handle_t HCURSOR #define cef_event_handle_t MSG* #define cef_window_handle_t HWND #define cef_text_input_context_t void* #define kNullCursorHandle NULL #define kNullEventHandle NULL #define kNullWindowHandle NULL #ifdef __cplusplus extern "C" { #endif /// // Structure representing CefExecuteProcess arguments. /// typedef struct _cef_main_args_t { HINSTANCE instance; } cef_main_args_t; /// // Structure representing window information. /// typedef struct _cef_window_info_t { // Standard parameters required by CreateWindowEx() DWORD ex_style; cef_string_t window_name; DWORD style; int x; int y; int width; int height; cef_window_handle_t parent_window; HMENU menu; /// // Set to true (1) to create the browser using windowless (off-screen) // rendering. No window will be created for the browser and all rendering will // occur via the CefRenderHandler interface. The |parent_window| value will be // used to identify monitor info and to act as the parent window for dialogs, // context menus, etc. If |parent_window| is not provided then the main screen // monitor will be used and some functionality that requires a parent window // may not function correctly. In order to create windowless browsers the // CefSettings.windowless_rendering_enabled value must be set to true. /// int windowless_rendering_enabled; /// // Set to true (1) to enable transparent painting in combination with // windowless rendering. When this value is true a transparent background // color will be used (RGBA=0x00000000). When this value is false the // background will be white and opaque. /// int transparent_painting_enabled; /// // Handle for the new browser window. Only used with windowed rendering. /// cef_window_handle_t window; } cef_window_info_t; #ifdef __cplusplus } #endif #endif // OS_WIN #endif // CEF_INCLUDE_INTERNAL_CEF_TYPES_WIN_H_ cefpython-49.0/src/include/internal/cef_types_wrappers.h000066400000000000000000000670401334103266300235600ustar00rootroot00000000000000// Copyright (c) 2013 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_INTERNAL_CEF_TYPES_WRAPPERS_H_ #define CEF_INCLUDE_INTERNAL_CEF_TYPES_WRAPPERS_H_ #pragma once #include "include/internal/cef_string.h" #include "include/internal/cef_string_list.h" #include "include/internal/cef_types.h" /// // Template class that provides common functionality for CEF structure wrapping. /// template class CefStructBase : public traits::struct_type { public: typedef typename traits::struct_type struct_type; CefStructBase() : attached_to_(NULL) { Init(); } virtual ~CefStructBase() { // Only clear this object's data if it isn't currently attached to a // structure. if (!attached_to_) Clear(this); } CefStructBase(const CefStructBase& r) { Init(); *this = r; } CefStructBase(const struct_type& r) { // NOLINT(runtime/explicit) Init(); *this = r; } /// // Clear this object's values. /// void Reset() { Clear(this); Init(); } /// // Attach to the source structure's existing values. DetachTo() can be called // to insert the values back into the existing structure. /// void AttachTo(struct_type& source) { // Only clear this object's data if it isn't currently attached to a // structure. if (!attached_to_) Clear(this); // This object is now attached to the new structure. attached_to_ = &source; // Transfer ownership of the values from the source structure. memcpy(static_cast(this), &source, sizeof(struct_type)); } /// // Relinquish ownership of values to the target structure. /// void DetachTo(struct_type& target) { if (attached_to_ != &target) { // Clear the target structure's values only if we are not currently // attached to that structure. Clear(&target); } // Transfer ownership of the values to the target structure. memcpy(&target, static_cast(this), sizeof(struct_type)); // Remove the references from this object. Init(); } /// // Set this object's values. If |copy| is true the source structure's values // will be copied instead of referenced. /// void Set(const struct_type& source, bool copy) { traits::set(&source, this, copy); } CefStructBase& operator=(const CefStructBase& s) { return operator=(static_cast(s)); } CefStructBase& operator=(const struct_type& s) { Set(s, true); return *this; } protected: void Init() { memset(static_cast(this), 0, sizeof(struct_type)); attached_to_ = NULL; traits::init(this); } static void Clear(struct_type* s) { traits::clear(s); } struct_type* attached_to_; }; struct CefPointTraits { typedef cef_point_t struct_type; static inline void init(struct_type* s) {} static inline void clear(struct_type* s) {} static inline void set(const struct_type* src, struct_type* target, bool copy) { *target = *src; } }; /// // Class representing a point. /// class CefPoint : public CefStructBase { public: typedef CefStructBase parent; CefPoint() : parent() {} CefPoint(const cef_point_t& r) : parent(r) {} // NOLINT(runtime/explicit) CefPoint(const CefPoint& r) : parent(r) {} // NOLINT(runtime/explicit) CefPoint(int x, int y) : parent() { Set(x, y); } bool IsEmpty() const { return x <= 0 && y <= 0; } void Set(int x_val, int y_val) { x = x_val, y = y_val; } }; inline bool operator==(const CefPoint& a, const CefPoint& b) { return a.x == b.x && a.y == b.y; } inline bool operator!=(const CefPoint& a, const CefPoint& b) { return !(a == b); } struct CefRectTraits { typedef cef_rect_t struct_type; static inline void init(struct_type* s) {} static inline void clear(struct_type* s) {} static inline void set(const struct_type* src, struct_type* target, bool copy) { *target = *src; } }; /// // Class representing a rectangle. /// class CefRect : public CefStructBase { public: typedef CefStructBase parent; CefRect() : parent() {} CefRect(const cef_rect_t& r) : parent(r) {} // NOLINT(runtime/explicit) CefRect(const CefRect& r) : parent(r) {} // NOLINT(runtime/explicit) CefRect(int x, int y, int width, int height) : parent() { Set(x, y, width, height); } bool IsEmpty() const { return width <= 0 || height <= 0; } void Set(int x_val, int y_val, int width_val, int height_val) { x = x_val, y = y_val, width = width_val, height = height_val; } }; inline bool operator==(const CefRect& a, const CefRect& b) { return a.x == b.x && a.y == b.y && a.width == b.width && a.height == b.height; } inline bool operator!=(const CefRect& a, const CefRect& b) { return !(a == b); } struct CefSizeTraits { typedef cef_size_t struct_type; static inline void init(struct_type* s) {} static inline void clear(struct_type* s) {} static inline void set(const struct_type* src, struct_type* target, bool copy) { *target = *src; } }; /// // Class representing a size. /// class CefSize : public CefStructBase { public: typedef CefStructBase parent; CefSize() : parent() {} CefSize(const cef_size_t& r) : parent(r) {} // NOLINT(runtime/explicit) CefSize(const CefSize& r) : parent(r) {} // NOLINT(runtime/explicit) CefSize(int width, int height) : parent() { Set(width, height); } bool IsEmpty() const { return width <= 0 || height <= 0; } void Set(int width_val, int height_val) { width = width_val, height = height_val; } }; inline bool operator==(const CefSize& a, const CefSize& b) { return a.width == b.width && a.height == b.height; } inline bool operator!=(const CefSize& a, const CefSize& b) { return !(a == b); } struct CefDraggableRegionTraits { typedef cef_draggable_region_t struct_type; static inline void init(struct_type* s) {} static inline void clear(struct_type* s) {} static inline void set(const struct_type* src, struct_type* target, bool copy) { *target = *src; } }; /// // Class representing a draggable region. /// class CefDraggableRegion : public CefStructBase { public: typedef CefStructBase parent; CefDraggableRegion() : parent() {} CefDraggableRegion(const cef_draggable_region_t& r) // NOLINT(runtime/explicit) : parent(r) {} CefDraggableRegion(const CefDraggableRegion& r) // NOLINT(runtime/explicit) : parent(r) {} CefDraggableRegion(const CefRect& bounds, bool draggable) : parent() { Set(bounds, draggable); } void Set(const CefRect& bounds_val, bool draggable_val) { bounds = bounds_val, draggable = draggable_val; } }; inline bool operator==(const CefDraggableRegion& a, const CefDraggableRegion& b) { return a.bounds == b.bounds && a.draggable == b.draggable; } inline bool operator!=(const CefDraggableRegion& a, const CefDraggableRegion& b) { return !(a == b); } struct CefScreenInfoTraits { typedef cef_screen_info_t struct_type; static inline void init(struct_type* s) {} static inline void clear(struct_type* s) {} static inline void set(const struct_type* src, struct_type* target, bool copy) { target->device_scale_factor = src->device_scale_factor; target->depth = src->depth; target->depth_per_component = src->depth_per_component; target->is_monochrome = src->is_monochrome; target->rect = src->rect; target->available_rect = src->available_rect; } }; /// // Class representing the virtual screen information for use when window // rendering is disabled. /// class CefScreenInfo : public CefStructBase { public: typedef CefStructBase parent; CefScreenInfo() : parent() {} CefScreenInfo(const cef_screen_info_t& r) : parent(r) {} // NOLINT(runtime/explicit) CefScreenInfo(const CefScreenInfo& r) : parent(r) {} // NOLINT(runtime/explicit) CefScreenInfo(float device_scale_factor, int depth, int depth_per_component, bool is_monochrome, const CefRect& rect, const CefRect& available_rect) : parent() { Set(device_scale_factor, depth, depth_per_component, is_monochrome, rect, available_rect); } void Set(float device_scale_factor_val, int depth_val, int depth_per_component_val, bool is_monochrome_val, const CefRect& rect_val, const CefRect& available_rect_val) { device_scale_factor = device_scale_factor_val; depth = depth_val; depth_per_component = depth_per_component_val; is_monochrome = is_monochrome_val; rect = rect_val; available_rect = available_rect_val; } }; struct CefKeyEventTraits { typedef cef_key_event_t struct_type; static inline void init(struct_type* s) {} static inline void clear(struct_type* s) {} static inline void set(const struct_type* src, struct_type* target, bool copy) { target->type = src->type; target->modifiers = src->modifiers; target->windows_key_code = src->windows_key_code; target->native_key_code = src->native_key_code; target->is_system_key = src->is_system_key; target->character = src->character; target->unmodified_character = src->unmodified_character; target->focus_on_editable_field = src->focus_on_editable_field; } }; /// // Class representing a a keyboard event. /// typedef CefStructBase CefKeyEvent; struct CefMouseEventTraits { typedef cef_mouse_event_t struct_type; static inline void init(struct_type* s) {} static inline void clear(struct_type* s) {} static inline void set(const struct_type* src, struct_type* target, bool copy) { target->x = src->x; target->y = src->y; target->modifiers = src->modifiers; } }; /// // Class representing a mouse event. /// typedef CefStructBase CefMouseEvent; struct CefPopupFeaturesTraits { typedef cef_popup_features_t struct_type; static inline void init(struct_type* s) { s->menuBarVisible = true; s->statusBarVisible = true; s->toolBarVisible = true; s->locationBarVisible = true; s->scrollbarsVisible = true; s->resizable = true; } static inline void clear(struct_type* s) { if (s->additionalFeatures) cef_string_list_free(s->additionalFeatures); } static inline void set(const struct_type* src, struct_type* target, bool copy) { if (target->additionalFeatures) cef_string_list_free(target->additionalFeatures); target->additionalFeatures = src->additionalFeatures ? cef_string_list_copy(src->additionalFeatures) : NULL; target->x = src->x; target->xSet = src->xSet; target->y = src->y; target->ySet = src->ySet; target->width = src->width; target->widthSet = src->widthSet; target->height = src->height; target->heightSet = src->heightSet; target->menuBarVisible = src->menuBarVisible; target->statusBarVisible = src->statusBarVisible; target->toolBarVisible = src->toolBarVisible; target->locationBarVisible = src->locationBarVisible; target->scrollbarsVisible = src->scrollbarsVisible; target->resizable = src->resizable; target->fullscreen = src->fullscreen; target->dialog = src->dialog; } }; /// // Class representing popup window features. /// typedef CefStructBase CefPopupFeatures; struct CefSettingsTraits { typedef cef_settings_t struct_type; static inline void init(struct_type* s) { s->size = sizeof(struct_type); } static inline void clear(struct_type* s) { cef_string_clear(&s->browser_subprocess_path); cef_string_clear(&s->cache_path); cef_string_clear(&s->user_data_path); cef_string_clear(&s->user_agent); cef_string_clear(&s->product_version); cef_string_clear(&s->locale); cef_string_clear(&s->log_file); cef_string_clear(&s->javascript_flags); cef_string_clear(&s->resources_dir_path); cef_string_clear(&s->locales_dir_path); cef_string_clear(&s->accept_language_list); } static inline void set(const struct_type* src, struct_type* target, bool copy) { target->single_process = src->single_process; target->no_sandbox = src->no_sandbox; cef_string_set(src->browser_subprocess_path.str, src->browser_subprocess_path.length, &target->browser_subprocess_path, copy); target->multi_threaded_message_loop = src->multi_threaded_message_loop; target->windowless_rendering_enabled = src->windowless_rendering_enabled; target->command_line_args_disabled = src->command_line_args_disabled; cef_string_set(src->cache_path.str, src->cache_path.length, &target->cache_path, copy); cef_string_set(src->user_data_path.str, src->user_data_path.length, &target->user_data_path, copy); target->persist_session_cookies = src->persist_session_cookies; target->persist_user_preferences = src->persist_user_preferences; cef_string_set(src->user_agent.str, src->user_agent.length, &target->user_agent, copy); cef_string_set(src->product_version.str, src->product_version.length, &target->product_version, copy); cef_string_set(src->locale.str, src->locale.length, &target->locale, copy); cef_string_set(src->log_file.str, src->log_file.length, &target->log_file, copy); target->log_severity = src->log_severity; cef_string_set(src->javascript_flags.str, src->javascript_flags.length, &target->javascript_flags, copy); cef_string_set(src->resources_dir_path.str, src->resources_dir_path.length, &target->resources_dir_path, copy); cef_string_set(src->locales_dir_path.str, src->locales_dir_path.length, &target->locales_dir_path, copy); target->pack_loading_disabled = src->pack_loading_disabled; target->remote_debugging_port = src->remote_debugging_port; target->uncaught_exception_stack_size = src->uncaught_exception_stack_size; target->context_safety_implementation = src->context_safety_implementation; target->ignore_certificate_errors = src->ignore_certificate_errors; target->background_color = src->background_color; cef_string_set(src->accept_language_list.str, src->accept_language_list.length, &target->accept_language_list, copy); } }; /// // Class representing initialization settings. /// typedef CefStructBase CefSettings; struct CefRequestContextSettingsTraits { typedef cef_request_context_settings_t struct_type; static inline void init(struct_type* s) { s->size = sizeof(struct_type); } static inline void clear(struct_type* s) { cef_string_clear(&s->cache_path); cef_string_clear(&s->accept_language_list); } static inline void set(const struct_type* src, struct_type* target, bool copy) { cef_string_set(src->cache_path.str, src->cache_path.length, &target->cache_path, copy); target->persist_session_cookies = src->persist_session_cookies; target->persist_user_preferences = src->persist_user_preferences; target->ignore_certificate_errors = src->ignore_certificate_errors; cef_string_set(src->accept_language_list.str, src->accept_language_list.length, &target->accept_language_list, copy); } }; /// // Class representing request context initialization settings. /// typedef CefStructBase CefRequestContextSettings; struct CefBrowserSettingsTraits { typedef cef_browser_settings_t struct_type; static inline void init(struct_type* s) { s->size = sizeof(struct_type); } static inline void clear(struct_type* s) { cef_string_clear(&s->standard_font_family); cef_string_clear(&s->fixed_font_family); cef_string_clear(&s->serif_font_family); cef_string_clear(&s->sans_serif_font_family); cef_string_clear(&s->cursive_font_family); cef_string_clear(&s->fantasy_font_family); cef_string_clear(&s->default_encoding); cef_string_clear(&s->accept_language_list); } static inline void set(const struct_type* src, struct_type* target, bool copy) { target->windowless_frame_rate = src->windowless_frame_rate; cef_string_set(src->standard_font_family.str, src->standard_font_family.length, &target->standard_font_family, copy); cef_string_set(src->fixed_font_family.str, src->fixed_font_family.length, &target->fixed_font_family, copy); cef_string_set(src->serif_font_family.str, src->serif_font_family.length, &target->serif_font_family, copy); cef_string_set(src->sans_serif_font_family.str, src->sans_serif_font_family.length, &target->sans_serif_font_family, copy); cef_string_set(src->cursive_font_family.str, src->cursive_font_family.length, &target->cursive_font_family, copy); cef_string_set(src->fantasy_font_family.str, src->fantasy_font_family.length, &target->fantasy_font_family, copy); target->default_font_size = src->default_font_size; target->default_fixed_font_size = src->default_fixed_font_size; target->minimum_font_size = src->minimum_font_size; target->minimum_logical_font_size = src->minimum_logical_font_size; cef_string_set(src->default_encoding.str, src->default_encoding.length, &target->default_encoding, copy); target->remote_fonts = src->remote_fonts; target->javascript = src->javascript; target->javascript_open_windows = src->javascript_open_windows; target->javascript_close_windows = src->javascript_close_windows; target->javascript_access_clipboard = src->javascript_access_clipboard; target->javascript_dom_paste = src->javascript_dom_paste; target->caret_browsing = src->caret_browsing; target->plugins = src->plugins; target->universal_access_from_file_urls = src->universal_access_from_file_urls; target->file_access_from_file_urls = src->file_access_from_file_urls; target->web_security = src->web_security; target->image_loading = src->image_loading; target->image_shrink_standalone_to_fit = src->image_shrink_standalone_to_fit; target->text_area_resize = src->text_area_resize; target->tab_to_links = src->tab_to_links; target->local_storage = src->local_storage; target->databases= src->databases; target->application_cache = src->application_cache; target->webgl = src->webgl; target->background_color = src->background_color; cef_string_set(src->accept_language_list.str, src->accept_language_list.length, &target->accept_language_list, copy); } }; /// // Class representing browser initialization settings. /// typedef CefStructBase CefBrowserSettings; struct CefURLPartsTraits { typedef cef_urlparts_t struct_type; static inline void init(struct_type* s) {} static inline void clear(struct_type* s) { cef_string_clear(&s->spec); cef_string_clear(&s->scheme); cef_string_clear(&s->username); cef_string_clear(&s->password); cef_string_clear(&s->host); cef_string_clear(&s->port); cef_string_clear(&s->origin); cef_string_clear(&s->path); cef_string_clear(&s->query); } static inline void set(const struct_type* src, struct_type* target, bool copy) { cef_string_set(src->spec.str, src->spec.length, &target->spec, copy); cef_string_set(src->scheme.str, src->scheme.length, &target->scheme, copy); cef_string_set(src->username.str, src->username.length, &target->username, copy); cef_string_set(src->password.str, src->password.length, &target->password, copy); cef_string_set(src->host.str, src->host.length, &target->host, copy); cef_string_set(src->port.str, src->port.length, &target->port, copy); cef_string_set(src->origin.str, src->origin.length, &target->origin, copy); cef_string_set(src->path.str, src->path.length, &target->path, copy); cef_string_set(src->query.str, src->query.length, &target->query, copy); } }; /// // Class representing a URL's component parts. /// typedef CefStructBase CefURLParts; struct CefTimeTraits { typedef cef_time_t struct_type; static inline void init(struct_type* s) {} static inline void clear(struct_type* s) {} static inline void set(const struct_type* src, struct_type* target, bool copy) { *target = *src; } }; /// // Class representing a time. /// class CefTime : public CefStructBase { public: typedef CefStructBase parent; CefTime() : parent() {} CefTime(const cef_time_t& r) : parent(r) {} // NOLINT(runtime/explicit) CefTime(const CefTime& r) : parent(r) {} // NOLINT(runtime/explicit) explicit CefTime(time_t r) : parent() { SetTimeT(r); } explicit CefTime(double r) : parent() { SetDoubleT(r); } // Converts to/from time_t. void SetTimeT(time_t r) { cef_time_from_timet(r, this); } time_t GetTimeT() const { time_t time = 0; cef_time_to_timet(this, &time); return time; } // Converts to/from a double which is the number of seconds since epoch // (Jan 1, 1970). Webkit uses this format to represent time. A value of 0 // means "not initialized". void SetDoubleT(double r) { cef_time_from_doublet(r, this); } double GetDoubleT() const { double time = 0; cef_time_to_doublet(this, &time); return time; } // Set this object to now. void Now() { cef_time_now(this); } // Return the delta between this object and |other| in milliseconds. long long Delta(const CefTime& other) { long long delta = 0; cef_time_delta(this, &other, &delta); return delta; } }; struct CefCookieTraits { typedef cef_cookie_t struct_type; static inline void init(struct_type* s) {} static inline void clear(struct_type* s) { cef_string_clear(&s->name); cef_string_clear(&s->value); cef_string_clear(&s->domain); cef_string_clear(&s->path); } static inline void set(const struct_type* src, struct_type* target, bool copy) { cef_string_set(src->name.str, src->name.length, &target->name, copy); cef_string_set(src->value.str, src->value.length, &target->value, copy); cef_string_set(src->domain.str, src->domain.length, &target->domain, copy); cef_string_set(src->path.str, src->path.length, &target->path, copy); target->secure = src->secure; target->httponly = src->httponly; target->creation = src->creation; target->last_access = src->last_access; target->has_expires = src->has_expires; target->expires = src->expires; } }; /// // Class representing a cookie. /// typedef CefStructBase CefCookie; struct CefGeopositionTraits { typedef cef_geoposition_t struct_type; static inline void init(struct_type* s) {} static inline void clear(struct_type* s) { cef_string_clear(&s->error_message); } static inline void set(const struct_type* src, struct_type* target, bool copy) { target->latitude = src->latitude; target->longitude = src->longitude; target->altitude = src->altitude; target->accuracy = src->accuracy; target->altitude_accuracy = src->altitude_accuracy; target->heading = src->heading; target->speed = src->speed; target->timestamp = src->timestamp; target->error_code = src->error_code; cef_string_set(src->error_message.str, src->error_message.length, &target->error_message, copy); } }; /// // Class representing a geoposition. /// typedef CefStructBase CefGeoposition; struct CefPageRangeTraits { typedef cef_page_range_t struct_type; static inline void init(struct_type* s) {} static inline void clear(struct_type* s) {} static inline void set(const struct_type* src, struct_type* target, bool copy) { *target = *src; } }; /// // Class representing a print job page range. /// class CefPageRange : public CefStructBase { public: typedef CefStructBase parent; CefPageRange() : parent() {} CefPageRange(const cef_page_range_t& r) // NOLINT(runtime/explicit) : parent(r) {} CefPageRange(const CefPageRange& r) // NOLINT(runtime/explicit) : parent(r) {} CefPageRange(int from, int to) : parent() { Set(from, to); } void Set(int from_val, int to_val) { from = from_val, to = to_val; } }; inline bool operator==(const CefPageRange& a, const CefPageRange& b) { return a.from == b.from && a.to == b.to; } inline bool operator!=(const CefPageRange& a, const CefPageRange& b) { return !(a == b); } struct CefCursorInfoTraits { typedef cef_cursor_info_t struct_type; static inline void init(struct_type* s) {} static inline void clear(struct_type* s) {} static inline void set(const struct_type* src, struct_type* target, bool copy) { target->hotspot = src->hotspot; target->image_scale_factor = src->image_scale_factor; target->buffer = src->buffer; target->size = src->size; } }; /// // Class representing cursor information. /// typedef CefStructBase CefCursorInfo; struct CefPdfPrintSettingsTraits { typedef cef_pdf_print_settings_t struct_type; static inline void init(struct_type* s) {} static inline void clear(struct_type* s) { cef_string_clear(&s->header_footer_title); cef_string_clear(&s->header_footer_url); } static inline void set(const struct_type* src, struct_type* target, bool copy) { cef_string_set(src->header_footer_title.str, src->header_footer_title.length, &target->header_footer_title, copy); cef_string_set(src->header_footer_url.str, src->header_footer_url.length, &target->header_footer_url, copy); target->page_width = src->page_width; target->page_height = src->page_height; target->margin_top = src->margin_top; target->margin_right = src->margin_right; target->margin_bottom = src->margin_bottom; target->margin_left = src->margin_left; target->margin_type = src->margin_type; target->header_footer_enabled = src->header_footer_enabled; target->selection_only = src->selection_only; target->landscape = src->landscape; target->backgrounds_enabled = src->backgrounds_enabled; } }; /// // Class representing PDF print settings /// typedef CefStructBase CefPdfPrintSettings; #endif // CEF_INCLUDE_INTERNAL_CEF_TYPES_WRAPPERS_H_ cefpython-49.0/src/include/internal/cef_win.h000066400000000000000000000131661334103266300212660ustar00rootroot00000000000000// Copyright (c) 2008 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_INTERNAL_CEF_WIN_H_ #define CEF_INCLUDE_INTERNAL_CEF_WIN_H_ #pragma once #include "include/internal/cef_types_win.h" #include "include/internal/cef_types_wrappers.h" /// // Handle types. /// #define CefCursorHandle cef_cursor_handle_t #define CefEventHandle cef_event_handle_t #define CefWindowHandle cef_window_handle_t #define CefTextInputContext cef_text_input_context_t struct CefMainArgsTraits { typedef cef_main_args_t struct_type; static inline void init(struct_type* s) {} static inline void clear(struct_type* s) {} static inline void set(const struct_type* src, struct_type* target, bool copy) { target->instance = src->instance; } }; // Class representing CefExecuteProcess arguments. class CefMainArgs : public CefStructBase { public: typedef CefStructBase parent; CefMainArgs() : parent() {} explicit CefMainArgs(const cef_main_args_t& r) : parent(r) {} explicit CefMainArgs(const CefMainArgs& r) : parent(r) {} explicit CefMainArgs(HINSTANCE hInstance) : parent() { instance = hInstance; } }; struct CefWindowInfoTraits { typedef cef_window_info_t struct_type; static inline void init(struct_type* s) {} static inline void clear(struct_type* s) { cef_string_clear(&s->window_name); } static inline void set(const struct_type* src, struct_type* target, bool copy) { target->ex_style = src->ex_style; cef_string_set(src->window_name.str, src->window_name.length, &target->window_name, copy); target->style = src->style; target->x = src->x; target->y = src->y; target->width = src->width; target->height = src->height; target->parent_window = src->parent_window; target->menu = src->menu; target->transparent_painting_enabled = src->transparent_painting_enabled; target->windowless_rendering_enabled = src->windowless_rendering_enabled; target->window = src->window; } }; /// // Class representing window information. /// class CefWindowInfo : public CefStructBase { public: typedef CefStructBase parent; CefWindowInfo() : parent() {} explicit CefWindowInfo(const cef_window_info_t& r) : parent(r) {} explicit CefWindowInfo(const CefWindowInfo& r) : parent(r) {} /// // Create the browser as a child window. /// void SetAsChild(CefWindowHandle parent, RECT windowRect) { style = WS_CHILD | WS_CLIPCHILDREN | WS_CLIPSIBLINGS | WS_TABSTOP | WS_VISIBLE; parent_window = parent; x = windowRect.left; y = windowRect.top; width = windowRect.right - windowRect.left; height = windowRect.bottom - windowRect.top; } /// // Create the browser as a popup window. /// void SetAsPopup(CefWindowHandle parent, const CefString& windowName) { style = WS_OVERLAPPEDWINDOW | WS_CLIPCHILDREN | WS_CLIPSIBLINGS | WS_VISIBLE; parent_window = parent; x = CW_USEDEFAULT; y = CW_USEDEFAULT; width = CW_USEDEFAULT; height = CW_USEDEFAULT; cef_string_copy(windowName.c_str(), windowName.length(), &window_name); } /// // Create the browser using windowless (off-screen) rendering. No window // will be created for the browser and all rendering will occur via the // CefRenderHandler interface. The |parent| value will be used to identify // monitor info and to act as the parent window for dialogs, context menus, // etc. If |parent| is not provided then the main screen monitor will be used // and some functionality that requires a parent window may not function // correctly. If |transparent| is true a transparent background color will be // used (RGBA=0x00000000). If |transparent| is false the background will be // white and opaque. In order to create windowless browsers the // CefSettings.windowless_rendering_enabled value must be set to true. /// void SetAsWindowless(CefWindowHandle parent, bool transparent) { windowless_rendering_enabled = TRUE; parent_window = parent; transparent_painting_enabled = transparent; } }; #endif // CEF_INCLUDE_INTERNAL_CEF_WIN_H_ cefpython-49.0/src/include/test/000077500000000000000000000000001334103266300166375ustar00rootroot00000000000000cefpython-49.0/src/include/test/cef_translator_test.h000066400000000000000000000315271334103266300230650ustar00rootroot00000000000000// Copyright (c) 2015 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. // // THIS FILE IS FOR TESTING PURPOSES ONLY. // // The APIs defined in this file are for testing purposes only. They will not be // exposed via the binary distribution. All classes in this file must include // the 'no_debugct_check' attribute to avoid problems when building the binary // distribution. // #ifndef CEF_INCLUDE_TEST_CEF_TEST_H_ #define CEF_INCLUDE_TEST_CEF_TEST_H_ #pragma once #include #include #include "include/cef_base.h" class CefTranslatorTestHandler; class CefTranslatorTestHandlerChild; class CefTranslatorTestObject; class CefTranslatorTestObjectChild; // Test values. #define TEST_INT_VAL 5 #define TEST_INT_VAL2 60 #define TEST_BOOL_VAL true #define TEST_DOUBLE_VAL 4.543 #define TEST_LONG_VAL -65 #define TEST_SIZET_VAL 3U #define TEST_STRING_VAL "My test string" #define TEST_STRING_VAL2 "My 2nd test string" #define TEST_STRING_VAL3 "My 3rd test string" #define TEST_STRING_KEY "key0" #define TEST_STRING_KEY2 "key1" #define TEST_STRING_KEY3 "key2" #define TEST_X_VAL 44 #define TEST_Y_VAL 754 #define TEST_X_VAL2 900 #define TEST_Y_VAL2 300 /// // Class for testing all of the possible data transfer types. /// /*--cef(source=library,no_debugct_check)--*/ class CefTranslatorTest : public CefBase { public: /// // Create the test object. /// /*--cef()--*/ static CefRefPtr Create(); // PRIMITIVE VALUES /// // Return a void value. /// /*--cef()--*/ virtual void GetVoid() =0; /// // Return a bool value. /// /*--cef()--*/ virtual bool GetBool() =0; /// // Return an int value. /// /*--cef()--*/ virtual int GetInt() =0; /// // Return a double value. /// /*--cef()--*/ virtual double GetDouble() =0; /// // Return a long value. /// /*--cef()--*/ virtual long GetLong() =0; /// // Return a size_t value. /// /*--cef()--*/ virtual size_t GetSizet() =0; /// // Set a void value. /// /*--cef()--*/ virtual bool SetVoid() =0; /// // Set a bool value. /// /*--cef()--*/ virtual bool SetBool(bool val) =0; /// // Set an int value. /// /*--cef()--*/ virtual bool SetInt(int val) =0; /// // Set a double value. /// /*--cef()--*/ virtual bool SetDouble(double val) =0; /// // Set a long value. /// /*--cef()--*/ virtual bool SetLong(long val) =0; /// // Set a size_t value. /// /*--cef()--*/ virtual bool SetSizet(size_t val) =0; // PRIMITIVE LIST VALUES // Test both with and without a typedef. typedef std::vector IntList; /// // Set a int list value. /// /*--cef()--*/ virtual bool SetIntList(const std::vector& val) =0; /// // Return an int list value by out-param. /// /*--cef(count_func=val:GetIntListSize)--*/ virtual bool GetIntListByRef(IntList& val) =0; /// // Return the number of points that will be output above. /// /*--cef()--*/ virtual size_t GetIntListSize() = 0; // STRING VALUES /// // Return a string value. /// /*--cef()--*/ virtual CefString GetString() =0; /// // Set a string value. /// /*--cef()--*/ virtual bool SetString(const CefString& val) =0; /// // Return a string value by out-param. /// /*--cef()--*/ virtual void GetStringByRef(CefString& val) =0; // STRING LIST VALUES // Test both with and without a typedef. typedef std::vector StringList; /// // Set a string list value. /// /*--cef()--*/ virtual bool SetStringList(const std::vector& val) =0; /// // Return a string list value by out-param. /// /*--cef()--*/ virtual bool GetStringListByRef(StringList& val) =0; // STRING MAP VALUES // Test both with and without a typedef. typedef std::map StringMap; /// // Set a string map value. /// /*--cef()--*/ virtual bool SetStringMap(const StringMap& val) =0; /// // Return a string map value by out-param. /// /*--cef()--*/ virtual bool GetStringMapByRef(std::map& val) =0; // STRING MULTIMAP VALUES // Test both with and without a typedef. typedef std::multimap StringMultimap; /// // Set a string multimap value. /// /*--cef()--*/ virtual bool SetStringMultimap( const std::multimap& val) =0; /// // Return a string multimap value by out-param. /// /*--cef()--*/ virtual bool GetStringMultimapByRef(StringMultimap& val) =0; // STRUCT VALUES /// // Return a point value. /// /*--cef()--*/ virtual CefPoint GetPoint() =0; /// // Set a point value. /// /*--cef()--*/ virtual bool SetPoint(const CefPoint& val) =0; /// // Return a point value by out-param. /// /*--cef()--*/ virtual void GetPointByRef(CefPoint& val) =0; // STRUCT LIST VALUES // Test both with and without a typedef. typedef std::vector PointList; /// // Set a point list vlaue. /// /*--cef()--*/ virtual bool SetPointList(const std::vector& val) =0; /// // Return a point list value by out-param. /// /*--cef(count_func=val:GetPointListSize)--*/ virtual bool GetPointListByRef(PointList& val) =0; /// // Return the number of points that will be output above. /// /*--cef()--*/ virtual size_t GetPointListSize() = 0; // LIBRARY-SIDE OBJECT VALUES /// // Return an new library-side object. /// /*--cef()--*/ virtual CefRefPtr GetObject(int val) =0; /// // Set an object. Returns the value from CefTranslatorTestObject::GetValue(). // This tests input and execution of a library-side object type. /// /*--cef()--*/ virtual int SetObject(CefRefPtr val) =0; /// // Set an object. Returns the object passed in. This tests input and output // of a library-side object type. /// /*--cef()--*/ virtual CefRefPtr SetObjectAndReturn( CefRefPtr val) =0; /// // Set a child object. Returns the value from // CefTranslatorTestObject::GetValue(). This tests input of a library-side // child object type and execution as the parent type. /// /*--cef()--*/ virtual int SetChildObject(CefRefPtr val) =0; /// // Set a child object. Returns the object as the parent type. This tests input // of a library-side child object type and return as the parent type. /// /*--cef()--*/ virtual CefRefPtr SetChildObjectAndReturnParent( CefRefPtr val) =0; // LIBRARY-SIDE OBJECT LIST VALUES // Test both with and without a typedef. typedef std::vector > ObjectList; /// // Set an object list vlaue. /// /*--cef()--*/ virtual bool SetObjectList( const std::vector >& val, int val1, int val2) =0; /// // Return an object list value by out-param. /// /*--cef(count_func=val:GetObjectListSize)--*/ virtual bool GetObjectListByRef(ObjectList& val, int val1, int val2) =0; /// // Return the number of object that will be output above. /// /*--cef()--*/ virtual size_t GetObjectListSize() = 0; // CLIENT-SIDE OBJECT VALUES /// // Set an object. Returns the value from CefTranslatorTestHandler::GetValue(). // This tests input and execution of a client-side object type. /// /*--cef()--*/ virtual int SetHandler(CefRefPtr val) =0; /// // Set an object. Returns the handler passed in. This tests input and output // of a client-side object type. /// /*--cef()--*/ virtual CefRefPtr SetHandlerAndReturn( CefRefPtr val) =0; /// // Set a child object. Returns the value from // CefTranslatorTestHandler::GetValue(). This tests input of a client-side // child object type and execution as the parent type. /// /*--cef()--*/ virtual int SetChildHandler(CefRefPtr val) =0; /// // Set a child object. Returns the object as the parent type. This tests // input of a client-side child object type and return as the parent type. /// /*--cef()--*/ virtual CefRefPtr SetChildHandlerAndReturnParent( CefRefPtr val) =0; // CLIENT-SIDE OBJECT LIST VALUES // Test both with and without a typedef. typedef std::vector > HandlerList; /// // Set an object list vlaue. /// /*--cef()--*/ virtual bool SetHandlerList( const std::vector >& val, int val1, int val2) =0; /// // Return an object list value by out-param. /// /*--cef(count_func=val:GetObjectListSize)--*/ virtual bool GetHandlerListByRef( HandlerList& val, CefRefPtr val1, CefRefPtr val2) =0; /// // Return the number of object that will be output above. /// /*--cef()--*/ virtual size_t GetHandlerListSize() = 0; }; /// // Library-side test object. /// /*--cef(source=library,no_debugct_check)--*/ class CefTranslatorTestObject : public CefBase { public: /// // Create the test object. /// /*--cef()--*/ static CefRefPtr Create(int value); /// // Return a value. /// /*--cef()--*/ virtual int GetValue() =0; /// // Set a value. /// /*--cef()--*/ virtual void SetValue(int value) =0; }; /// // Library-side child test object. /// /*--cef(source=library,no_debugct_check)--*/ class CefTranslatorTestObjectChild : public CefTranslatorTestObject { public: /// // Create the test object. /// /*--cef()--*/ static CefRefPtr Create(int value, int other_value); /// // Return a value. /// /*--cef()--*/ virtual int GetOtherValue() =0; /// // Set a value. /// /*--cef()--*/ virtual void SetOtherValue(int value) =0; }; /// // Another library-side child test object. /// /*--cef(source=library,no_debugct_check)--*/ class CefTranslatorTestObjectChildChild : public CefTranslatorTestObjectChild { public: /// // Create the test object. /// /*--cef()--*/ static CefRefPtr Create( int value, int other_value, int other_other_value); /// // Return a value. /// /*--cef()--*/ virtual int GetOtherOtherValue() =0; /// // Set a value. /// /*--cef()--*/ virtual void SetOtherOtherValue(int value) =0; }; /// // Client-side test object. /// /*--cef(source=client,no_debugct_check)--*/ class CefTranslatorTestHandler : public virtual CefBase { public: /// // Return a value. /// /*--cef()--*/ virtual int GetValue() =0; }; /// // Client-side child test object. /// /*--cef(source=client,no_debugct_check)--*/ class CefTranslatorTestHandlerChild : public CefTranslatorTestHandler { public: /// // Return a value. /// /*--cef()--*/ virtual int GetOtherValue() =0; }; #endif // CEF_INCLUDE_TEST_CEF_TEST_H_ cefpython-49.0/src/include/wrapper/000077500000000000000000000000001334103266300173405ustar00rootroot00000000000000cefpython-49.0/src/include/wrapper/cef_byte_read_handler.h000066400000000000000000000060561334103266300237700ustar00rootroot00000000000000// 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 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/base/cef_lock.h" #include "include/base/cef_macros.h" #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); // CefReadHandler methods. virtual size_t Read(void* ptr, size_t size, size_t n) OVERRIDE; virtual int Seek(int64 offset, int whence) OVERRIDE; virtual int64 Tell() OVERRIDE; virtual int Eof() OVERRIDE; virtual bool MayBlock() OVERRIDE { return false; } private: const unsigned char* bytes_; int64 size_; int64 offset_; CefRefPtr source_; base::Lock lock_; IMPLEMENT_REFCOUNTING(CefByteReadHandler); DISALLOW_COPY_AND_ASSIGN(CefByteReadHandler); }; #endif // CEF_INCLUDE_WRAPPER_CEF_BYTE_READ_HANDLER_H_ cefpython-49.0/src/include/wrapper/cef_closure_task.h000066400000000000000000000075311334103266300230320ustar00rootroot00000000000000// Copyright (c) 2014 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_CLOSURE_TASK_H_ #define CEF_INCLUDE_WRAPPER_CEF_CLOSURE_TASK_H_ #pragma once #include "include/base/cef_callback_forward.h" #include "include/base/cef_macros.h" #include "include/cef_task.h" /// // Helpers for asynchronously executing a base::Closure (bound function or // method) on a CEF thread. Creation of base::Closures can be facilitated using // base::Bind. See include/base/cef_callback.h for complete usage instructions. // // TO use these helpers you should include this header and the header that // defines base::Bind. // // #include "include/base/cef_bind.h" // #include "include/wrapper/cef_closure_task.h" // // Example of executing a bound function: // // // Define a function. // void MyFunc(int arg) { /* do something with |arg| on the UI thread */ } // // // Post a task that will execute MyFunc on the UI thread and pass an |arg| // // value of 5. // CefPostTask(TID_UI, base::Bind(&MyFunc, 5)); // // Example of executing a bound method: // // // Define a class. // class MyClass : public CefBase { // public: // MyClass() {} // void MyMethod(int arg) { /* do something with |arg| on the UI thread */ } // private: // IMPLEMENT_REFCOUNTING(MyClass); // }; // // // Create an instance of MyClass. // CefRefPtr instance = new MyClass(); // // // Post a task that will execute MyClass::MyMethod on the UI thread and pass // // an |arg| value of 5. |instance| will be kept alive until after the task // // completes. // CefPostTask(TID_UI, base::Bind(&MyClass::MyMethod, instance, 5)); /// /// // Create a CefTask that wraps a base::Closure. Can be used in combination with // CefTaskRunner. /// CefRefPtr CefCreateClosureTask(const base::Closure& closure); /// // Post a Closure for execution on the specified thread. /// bool CefPostTask(CefThreadId threadId, const base::Closure& closure); /// // Post a Closure for delayed execution on the specified thread. /// bool CefPostDelayedTask(CefThreadId threadId, const base::Closure& closure, int64 delay_ms); #endif // CEF_INCLUDE_WRAPPER_CEF_CLOSURE_TASK_H_ cefpython-49.0/src/include/wrapper/cef_helpers.h000066400000000000000000000104761334103266300220000ustar00rootroot00000000000000// Copyright (c) 2014 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_HELPERS_H_ #define CEF_INCLUDE_WRAPPER_CEF_HELPERS_H_ #pragma once #include #include #include #include "include/base/cef_bind.h" #include "include/base/cef_logging.h" #include "include/base/cef_macros.h" #include "include/cef_task.h" #define CEF_REQUIRE_UI_THREAD() DCHECK(CefCurrentlyOn(TID_UI)); #define CEF_REQUIRE_IO_THREAD() DCHECK(CefCurrentlyOn(TID_IO)); #define CEF_REQUIRE_FILE_THREAD() DCHECK(CefCurrentlyOn(TID_FILE)); #define CEF_REQUIRE_RENDERER_THREAD() DCHECK(CefCurrentlyOn(TID_RENDERER)); // Use this struct in conjuction with refcounted types to ensure that an // object is deleted on the specified thread. For example: // // class Foo : public base::RefCountedThreadSafe { // public: // Foo(); // void DoSomething(); // // private: // // Allow deletion via scoped_refptr only. // friend struct CefDeleteOnThread; // friend class base::RefCountedThreadSafe; // // virtual ~Foo() {} // }; // // base::scoped_refptr foo = new Foo(); // foo->DoSomething(); // foo = NULL; // Deletion of |foo| will occur on the UI thread. // template struct CefDeleteOnThread { template static void Destruct(const T* x) { if (CefCurrentlyOn(thread)) { delete x; } else { CefPostTask(thread, base::Bind(&CefDeleteOnThread::Destruct, x)); } } }; struct CefDeleteOnUIThread : public CefDeleteOnThread { }; struct CefDeleteOnIOThread : public CefDeleteOnThread { }; struct CefDeleteOnFileThread : public CefDeleteOnThread { }; struct CefDeleteOnRendererThread : public CefDeleteOnThread { }; /// // Helper class to manage a scoped copy of |argv|. /// class CefScopedArgArray { public: CefScopedArgArray(int argc, char* argv[]) { // argv should have (argc + 1) elements, the last one always being NULL. array_ = new char*[argc + 1]; for (int i = 0; i < argc; ++i) { values_.push_back(argv[i]); array_[i] = const_cast(values_[i].c_str()); } array_[argc] = NULL; } ~CefScopedArgArray() { delete [] array_; } char** array() const { return array_; } private: char** array_; // Keep values in a vector separate from |array_| because various users may // modify |array_| and we still want to clean up memory properly. std::vector values_; DISALLOW_COPY_AND_ASSIGN(CefScopedArgArray); }; #endif // CEF_INCLUDE_WRAPPER_CEF_HELPERS_H_ cefpython-49.0/src/include/wrapper/cef_message_router.h000066400000000000000000000444611334103266300233630ustar00rootroot00000000000000// Copyright (c) 2014 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_MESSAGE_ROUTER_H_ #define CEF_INCLUDE_WRAPPER_CEF_MESSAGE_ROUTER_H_ #pragma once #include "include/base/cef_ref_counted.h" #include "include/cef_base.h" #include "include/cef_browser.h" #include "include/cef_process_message.h" #include "include/cef_v8.h" // The below classes implement support for routing aynchronous messages between // JavaScript running in the renderer process and C++ running in the browser // process. An application interacts with the router by passing it data from // standard CEF C++ callbacks (OnBeforeBrowse, OnProcessMessageRecieved, // OnContextCreated, etc). The renderer-side router supports generic JavaScript // callback registration and execution while the browser-side router supports // application-specific logic via one or more application-provided Handler // instances. // // The renderer-side router implementation exposes a query function and a cancel // function via the JavaScript 'window' object: // // // Create and send a new query. // var request_id = window.cefQuery({ // request: 'my_request', // persistent: false, // onSuccess: function(response) {}, // onFailure: function(error_code, error_message) {} // }); // // // Optionally cancel the query. // window.cefQueryCancel(request_id); // // When |window.cefQuery| is executed the request is sent asynchronously to one // or more C++ Handler objects registered in the browser process. Each C++ // Handler can choose to either handle or ignore the query in the // Handler::OnQuery callback. If a Handler chooses to handle the query then it // should execute Callback::Success when a response is available or // Callback::Failure if an error occurs. This will result in asynchronous // execution of the associated JavaScript callback in the renderer process. Any // queries unhandled by C++ code in the browser process will be automatically // canceled and the associated JavaScript onFailure callback will be executed // with an error code of -1. // // Queries can be either persistent or non-persistent. If the query is // persistent than the callbacks will remain registered until one of the // following conditions are met: // // A. The query is canceled in JavaScript using the |window.cefQueryCancel| // function. // B. The query is canceled in C++ code using the Callback::Failure function. // C. The context associated with the query is released due to browser // destruction, navigation or renderer process termination. // // If the query is non-persistent then the registration will be removed after // the JavaScript callback is executed a single time. If a query is canceled for // a reason other than Callback::Failure being executed then the associated // Handler's OnQueryCanceled method will be called. // // Some possible usage patterns include: // // One-time Request. Use a non-persistent query to send a JavaScript request. // The Handler evaluates the request and returns the response. The query is // then discarded. // // Broadcast. Use a persistent query to register as a JavaScript broadcast // receiver. The Handler keeps track of all registered Callbacks and executes // them sequentially to deliver the broadcast message. // // Subscription. Use a persistent query to register as a JavaScript subscription // receiver. The Handler initiates the subscription feed on the first request // and delivers responses to all registered subscribers as they become // available. The Handler cancels the subscription feed when there are no // longer any registered JavaScript receivers. // // Message routing occurs on a per-browser and per-context basis. Consequently, // additional application logic can be applied by restricting which browser or // context instances are passed into the router. If you choose to use this // approach do so cautiously. In order for the router to function correctly any // browser or context instance passed into a single router callback must then // be passed into all router callbacks. // // There is generally no need to have multiple renderer-side routers unless you // wish to have multiple bindings with different JavaScript function names. It // can be useful to have multiple browser-side routers with different client- // provided Handler instances when implementing different behaviors on a per- // browser basis. // // This implementation places no formatting restrictions on payload content. // An application may choose to exchange anything from simple formatted // strings to serialized XML or JSON data. // // // EXAMPLE USAGE // // 1. Define the router configuration. You can optionally specify settings // like the JavaScript function names. The configuration must be the same in // both the browser and renderer processes. If using multiple routers in the // same application make sure to specify unique function names for each // router configuration. // // // Example config object showing the default values. // CefMessageRouterConfig config; // config.js_query_function = "cefQuery"; // config.js_cancel_function = "cefQueryCancel"; // // 2. Create an instance of CefMessageRouterBrowserSide in the browser process. // You might choose to make it a member of your CefClient implementation, // for example. // // browser_side_router_ = CefMessageRouterBrowserSide::Create(config); // // 3. Register one or more Handlers. The Handler instances must either outlive // the router or be removed from the router before they're deleted. // // browser_side_router_->AddHandler(my_handler); // // 4. Call all required CefMessageRouterBrowserSide methods from other callbacks // in your CefClient implementation (OnBeforeClose, etc). See the // CefMessageRouterBrowserSide class documentation for the complete list of // methods. // // 5. Create an instance of CefMessageRouterRendererSide in the renderer process. // You might choose to make it a member of your CefApp implementation, for // example. // // renderer_side_router_ = CefMessageRouterRendererSide::Create(config); // // 6. Call all required CefMessageRouterRendererSide methods from other // callbacks in your CefRenderProcessHandler implementation // (OnContextCreated, etc). See the CefMessageRouterRendererSide class // documentation for the complete list of methods. // // 7. Execute the query function from JavaScript code. // // window.cefQuery({request: 'my_request', // persistent: false, // onSuccess: function(response) { print(response); }, // onFailure: function(error_code, error_message) {} }); // // 8. Handle the query in your Handler::OnQuery implementation and execute the // appropriate callback either immediately or asynchronously. // // void MyHandler::OnQuery(int64 query_id, // CefRefPtr browser, // CefRefPtr frame, // const CefString& request, // bool persistent, // CefRefPtr callback) { // if (request == "my_request") { // callback->Continue("my_response"); // return true; // } // return false; // Not handled. // } // // 9. Notice that the onSuccess callback is executed in JavaScript. /// // Used to configure the query router. The same values must be passed to both // CefMessageRouterBrowserSide and CefMessageRouterRendererSide. If using multiple // router pairs make sure to choose values that do not conflict. /// struct CefMessageRouterConfig { CefMessageRouterConfig(); // Name of the JavaScript function that will be added to the 'window' object // for sending a query. The default value is "cefQuery". CefString js_query_function; // Name of the JavaScript function that will be added to the 'window' object // for canceling a pending query. The default value is "cefQueryCancel". CefString js_cancel_function; }; /// // Implements the browser side of query routing. The methods of this class may // be called on any browser process thread unless otherwise indicated. /// class CefMessageRouterBrowserSide : public base::RefCountedThreadSafe { public: /// // Callback associated with a single pending asynchronous query. Execute the // Success or Failure method to send an asynchronous response to the // associated JavaScript handler. It is a runtime error to destroy a Callback // object associated with an uncanceled query without first executing one of // the callback methods. The methods of this class may be called on any // browser process thread. /// class Callback : public CefBase { public: /// // Notify the associated JavaScript onSuccess callback that the query has // completed successfully with the specified |response|. /// virtual void Success(const CefString& response) =0; /// // Notify the associated JavaScript onFailure callback that the query has // failed with the specified |error_code| and |error_message|. /// virtual void Failure(int error_code, const CefString& error_message) =0; }; /// // Implement this interface to handle queries. All methods will be executed on // the browser process UI thread. /// class Handler { public: typedef CefMessageRouterBrowserSide::Callback Callback; /// // Executed when a new query is received. |query_id| uniquely identifies the // query for the life span of the router. Return true to handle the query // or false to propagate the query to other registered handlers, if any. If // no handlers return true from this method then the query will be // automatically canceled with an error code of -1 delivered to the // JavaScript onFailure callback. If this method returns true then a // Callback method must be executed either in this method or asynchronously // to complete the query. /// virtual bool OnQuery(CefRefPtr browser, CefRefPtr frame, int64 query_id, const CefString& request, bool persistent, CefRefPtr callback) { return false; } /// // Executed when a query has been canceled either explicitly using the // JavaScript cancel function or implicitly due to browser destruction, // navigation or renderer process termination. It will only be called for // the single handler that returned true from OnQuery for the same // |query_id|. No references to the associated Callback object should be // kept after this method is called, nor should any Callback methods be // executed. /// virtual void OnQueryCanceled(CefRefPtr browser, CefRefPtr frame, int64 query_id) {} virtual ~Handler() {} }; /// // Create a new router with the specified configuration. /// static CefRefPtr Create( const CefMessageRouterConfig& config); /// // Add a new query handler. If |first| is true it will be added as the first // handler, otherwise it will be added as the last handler. Returns true if // the handler is added successfully or false if the handler has already been // added. Must be called on the browser process UI thread. The Handler object // must either outlive the router or be removed before deletion. /// virtual bool AddHandler(Handler* handler, bool first) =0; /// // Remove an existing query handler. Any pending queries associated with the // handler will be canceled. Handler::OnQueryCanceled will be called and the // associated JavaScript onFailure callback will be executed with an error // code of -1. Returns true if the handler is removed successfully or false // if the handler is not found. Must be called on the browser process UI // thread. /// virtual bool RemoveHandler(Handler* handler) =0; /// // Cancel all pending queries associated with either |browser| or |handler|. // If both |browser| and |handler| are NULL all pending queries will be // canceled. Handler::OnQueryCanceled will be called and the associated // JavaScript onFailure callback will be executed in all cases with an error // code of -1. /// virtual void CancelPending(CefRefPtr browser, Handler* handler) =0; /// // Returns the number of queries currently pending for the specified |browser| // and/or |handler|. Either or both values may be empty. Must be called on the // browser process UI thread. /// virtual int GetPendingCount(CefRefPtr browser, Handler* handler) =0; // The below methods should be called from other CEF handlers. They must be // called exactly as documented for the router to function correctly. /// // Call from CefLifeSpanHandler::OnBeforeClose. Any pending queries associated // with |browser| will be canceled and Handler::OnQueryCanceled will be called. // No JavaScript callbacks will be executed since this indicates destruction // of the browser. /// virtual void OnBeforeClose(CefRefPtr browser) =0; /// // Call from CefRequestHandler::OnRenderProcessTerminated. Any pending queries // associated with |browser| will be canceled and Handler::OnQueryCanceled // will be called. No JavaScript callbacks will be executed since this // indicates destruction of the context. /// virtual void OnRenderProcessTerminated(CefRefPtr browser) =0; /// // Call from CefRequestHandler::OnBeforeBrowse only if the navigation is // allowed to proceed. If |frame| is the main frame then any pending queries // associated with |browser| will be canceled and Handler::OnQueryCanceled // will be called. No JavaScript callbacks will be executed since this // indicates destruction of the context. /// virtual void OnBeforeBrowse(CefRefPtr browser, CefRefPtr frame) =0; /// // Call from CefClient::OnProcessMessageReceived. Returns true if the message // is handled by this router or false otherwise. /// virtual bool OnProcessMessageReceived( CefRefPtr browser, CefProcessId source_process, CefRefPtr message) =0; protected: // Protect against accidental deletion of this object. friend class base::RefCountedThreadSafe; virtual ~CefMessageRouterBrowserSide() {} }; /// // Implements the renderer side of query routing. The methods of this class must // be called on the render process main thread. /// class CefMessageRouterRendererSide : public base::RefCountedThreadSafe { public: /// // Create a new router with the specified configuration. /// static CefRefPtr Create( const CefMessageRouterConfig& config); /// // Returns the number of queries currently pending for the specified |browser| // and/or |context|. Either or both values may be empty. /// virtual int GetPendingCount(CefRefPtr browser, CefRefPtr context) =0; // The below methods should be called from other CEF handlers. They must be // called exactly as documented for the router to function correctly. /// // Call from CefRenderProcessHandler::OnContextCreated. Registers the // JavaScripts functions with the new context. /// virtual void OnContextCreated(CefRefPtr browser, CefRefPtr frame, CefRefPtr context) =0; /// // Call from CefRenderProcessHandler::OnContextReleased. Any pending queries // associated with the released context will be canceled and // Handler::OnQueryCanceled will be called in the browser process. /// virtual void OnContextReleased(CefRefPtr browser, CefRefPtr frame, CefRefPtr context) =0; /// // Call from CefRenderProcessHandler::OnProcessMessageReceived. Returns true // if the message is handled by this router or false otherwise. /// virtual bool OnProcessMessageReceived( CefRefPtr browser, CefProcessId source_process, CefRefPtr message) =0; protected: // Protect against accidental deletion of this object. friend class base::RefCountedThreadSafe; virtual ~CefMessageRouterRendererSide() {} }; #endif // CEF_INCLUDE_WRAPPER_CEF_MESSAGE_ROUTER_H_ cefpython-49.0/src/include/wrapper/cef_resource_manager.h000066400000000000000000000337671334103266300236670ustar00rootroot00000000000000// Copyright (c) 2015 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_RESOURCE_MANAGER_H_ #define CEF_INCLUDE_WRAPPER_CEF_RESOURCE_MANAGER_H_ #pragma once #include #include "include/base/cef_macros.h" #include "include/base/cef_ref_counted.h" #include "include/base/cef_weak_ptr.h" #include "include/cef_request_handler.h" #include "include/wrapper/cef_closure_task.h" #include "include/wrapper/cef_helpers.h" /// // Class for managing multiple resource providers. For each resource request // providers will be called in order and have the option to (a) handle the // request by returning a CefResourceHandler, (b) pass the request to the next // provider in order, or (c) stop handling the request. See comments on the // Request object for additional usage information. The methods of this class // may be called on any browser process thread unless otherwise indicated. /// class CefResourceManager : public base::RefCountedThreadSafe { public: /// // Provides an opportunity to modify |url| before it is passed to a provider. // For example, the implementation could rewrite |url| to include a default // file extension. |url| will be fully qualified and may contain query or // fragment components. /// typedef base::Callback UrlFilter; /// // Used to resolve mime types for URLs, usually based on the file extension. // |url| will be fully qualified and may contain query or fragment components. /// typedef base::Callback MimeTypeResolver; private: // Values that stay with a request as it moves between providers. struct RequestParams { std::string url_; CefRefPtr browser_; CefRefPtr frame_; CefRefPtr request_; UrlFilter url_filter_; MimeTypeResolver mime_type_resolver_; }; // Values that are associated with the pending request only. struct RequestState; public: /// // Object representing a request. Each request object is used for a single // call to Provider::OnRequest and will become detached (meaning the callbacks // will no longer trigger) after Request::Continue or Request::Stop is called. // A request passed to Provider::OnRequestCanceled will already have been // detached. The methods of this class may be called on any browser process // thread. /// class Request : public base::RefCountedThreadSafe { public: /// // Returns the URL associated with this request. The returned value will be // fully qualified but will not contain query or fragment components. It // will already have been passed through the URL filter. /// std::string url() const { return params_.url_; } /// // Returns the CefBrowser associated with this request. /// CefRefPtr browser() const { return params_.browser_; } /// // Returns the CefFrame associated with this request. /// CefRefPtr frame() const { return params_.frame_; } /// // Returns the CefRequest associated with this request. /// CefRefPtr request() const { return params_.request_; } /// // Returns the current URL filter. /// const CefResourceManager::UrlFilter& url_filter() const { return params_.url_filter_; } /// // Returns the current mime type resolver. /// const CefResourceManager::MimeTypeResolver& mime_type_resolver() const { return params_.mime_type_resolver_; } /// // Continue handling the request. If |handler| is non-NULL then no // additional providers will be called and the |handler| value will be // returned via CefResourceManager::GetResourceHandler. If |handler| is NULL // then the next provider in order, if any, will be called. If there are no // additional providers then NULL will be returned via CefResourceManager:: // GetResourceHandler. /// void Continue(CefRefPtr handler); /// // Stop handling the request. No additional providers will be called and // NULL will be returned via CefResourceManager::GetResourceHandler. /// void Stop(); private: // Only allow deletion via scoped_refptr. friend class base::RefCountedThreadSafe; friend class CefResourceManager; // The below methods are called on the browser process IO thread. explicit Request(scoped_ptr state); scoped_ptr SendRequest(); bool HasState(); static void ContinueOnIOThread(scoped_ptr state, CefRefPtr handler); static void StopOnIOThread(scoped_ptr state); // Will be non-NULL while the request is pending. Only accessed on the // browser process IO thread. scoped_ptr state_; // Params that stay with this request object. Safe to access on any thread. RequestParams params_; DISALLOW_COPY_AND_ASSIGN(Request); }; typedef std::list > RequestList; /// // Interface implemented by resource providers. A provider may be created on // any thread but the methods will be called on, and the object will be // destroyed on, the browser process IO thread. /// class Provider { public: /// // Called to handle a request. If the provider knows immediately that it // will not handle the request return false. Otherwise, return true and call // Request::Continue or Request::Stop either in this method or // asynchronously to indicate completion. See comments on Request for // additional usage information. /// virtual bool OnRequest(scoped_refptr request) =0; /// // Called when a request has been canceled. It is still safe to dereference // |request| but any calls to Request::Continue or Request::Stop will be // ignored. /// virtual void OnRequestCanceled(scoped_refptr request) {} virtual ~Provider() {} }; CefResourceManager(); /// // Add a provider that maps requests for |url| to |content|. |url| should be // fully qualified but not include a query or fragment component. If // |mime_type| is empty the MimeTypeResolver will be used. See comments on // AddProvider for usage of the |order| and |identifier| parameters. /// void AddContentProvider(const std::string& url, const std::string& content, const std::string& mime_type, int order, const std::string& identifier); /// // Add a provider that maps requests that start with |url_path| to files under // |directory_path|. |url_path| should include an origin and optional path // component only. Files will be loaded when a matching URL is requested. // See comments on AddProvider for usage of the |order| and |identifier| // parameters. /// void AddDirectoryProvider(const std::string& url_path, const std::string& directory_path, int order, const std::string& identifier); /// // Add a provider that maps requests that start with |url_path| to files // stored in the archive file at |archive_path|. |url_path| should include an // origin and optional path component only. The archive file will be loaded // when a matching URL is requested for the first time. See comments on // AddProvider for usage of the |order| and |identifier| parameters. /// void AddArchiveProvider(const std::string& url_path, const std::string& archive_path, const std::string& password, int order, const std::string& identifier); /// // Add a provider. This object takes ownership of |provider|. Providers will // be called in ascending order based on the |order| value. Multiple providers // sharing the same |order| value will be called in the order that they were // added. The |identifier| value, which does not need to be unique, can be // used to remove the provider at a later time. /// void AddProvider(Provider* provider, int order, const std::string& identifier); /// // Remove all providers with the specified |identifier| value. If any removed // providers have pending requests the Provider::OnRequestCancel method will // be called. The removed providers may be deleted immediately or at a later // time. /// void RemoveProviders(const std::string& identifier); /// // Remove all providers. If any removed providers have pending requests the // Provider::OnRequestCancel method will be called. The removed providers may // be deleted immediately or at a later time. /// void RemoveAllProviders(); /// // Set the url filter. If not set the default no-op filter will be used. // Changes to this value will not affect currently pending requests. /// void SetUrlFilter(const UrlFilter& filter); /// // Set the mime type resolver. If not set the default resolver will be used. // Changes to this value will not affect currently pending requests. /// void SetMimeTypeResolver(const MimeTypeResolver& resolver); // The below methods should be called from other CEF handlers. They must be // called exactly as documented for the manager to function correctly. /// // Called from CefRequestHandler::OnBeforeResourceLoad on the browser process // IO thread. /// cef_return_value_t OnBeforeResourceLoad( CefRefPtr browser, CefRefPtr frame, CefRefPtr request, CefRefPtr callback); /// // Called from CefRequestHandler::GetResourceHandler on the browser process // IO thread. /// CefRefPtr GetResourceHandler( CefRefPtr browser, CefRefPtr frame, CefRefPtr request); private: // Only allow deletion via scoped_refptr. friend struct CefDeleteOnThread; friend class base::RefCountedThreadSafe; ~CefResourceManager(); // Provider and associated information. struct ProviderEntry; typedef std::list ProviderEntryList; // Values associated with the pending request only. Ownership will be passed // between requests and the resource manager as request handling proceeds. struct RequestState { ~RequestState(); base::WeakPtr manager_; // Callback to execute once request handling is complete. CefRefPtr callback_; // Position of the currently associated ProviderEntry in the |providers_| // list. ProviderEntryList::iterator current_entry_pos_; // Position of this request object in the currently associated // ProviderEntry's |pending_requests_| list. RequestList::iterator current_request_pos_; // Params that will be copied to each request object. RequestParams params_; }; // Methods that manage request state between requests. Called on the browser // process IO thread. bool SendRequest(scoped_ptr state); void ContinueRequest(scoped_ptr state, CefRefPtr handler); void StopRequest(scoped_ptr state); bool IncrementProvider(RequestState* state); void DetachRequestFromProvider(RequestState* state); void GetNextValidProvider(ProviderEntryList::iterator& iterator); void DeleteProvider(ProviderEntryList::iterator& iterator, bool stop); // The below members are only accessed on the browser process IO thread. // List of providers including additional associated information. ProviderEntryList providers_; // Map of response ID to pending CefResourceHandler object. typedef std::map > PendingHandlersMap; PendingHandlersMap pending_handlers_; UrlFilter url_filter_; MimeTypeResolver mime_type_resolver_; // Must be the last member. Created and accessed on the IO thread. scoped_ptr > weak_ptr_factory_; DISALLOW_COPY_AND_ASSIGN(CefResourceManager); }; #endif // CEF_INCLUDE_WRAPPER_CEF_RESOURCE_MANAGER_H_ cefpython-49.0/src/include/wrapper/cef_stream_resource_handler.h000066400000000000000000000101501334103266300252220ustar00rootroot00000000000000// 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 are only available to applications that link // against the libcef_dll_wrapper target. // #ifndef CEF_INCLUDE_WRAPPER_CEF_STREAM_RESOURCE_HANDLER_H_ #define CEF_INCLUDE_WRAPPER_CEF_STREAM_RESOURCE_HANDLER_H_ #pragma once #include "include/base/cef_macros.h" #include "include/base/cef_scoped_ptr.h" #include "include/cef_base.h" #include "include/cef_resource_handler.h" #include "include/cef_response.h" class CefStreamReader; /// // Implementation of the CefResourceHandler class for reading from a CefStream. /// class CefStreamResourceHandler : public CefResourceHandler { public: /// // Create a new object with default response values. /// CefStreamResourceHandler(const CefString& mime_type, CefRefPtr stream); /// // Create a new object with explicit response values. /// CefStreamResourceHandler(int status_code, const CefString& status_text, const CefString& mime_type, CefResponse::HeaderMap header_map, CefRefPtr stream); virtual ~CefStreamResourceHandler(); // CefResourceHandler methods. virtual bool ProcessRequest(CefRefPtr request, CefRefPtr callback) OVERRIDE; virtual void GetResponseHeaders(CefRefPtr response, int64& response_length, CefString& redirectUrl) OVERRIDE; virtual bool ReadResponse(void* data_out, int bytes_to_read, int& bytes_read, CefRefPtr callback) OVERRIDE; virtual void Cancel() OVERRIDE; private: void ReadOnFileThread(int bytes_to_read, CefRefPtr callback); const int status_code_; const CefString status_text_; const CefString mime_type_; const CefResponse::HeaderMap header_map_; const CefRefPtr stream_; bool read_on_file_thread_; class Buffer; scoped_ptr buffer_; #ifndef NDEBUG // Used in debug builds to verify that |buffer_| isn't being accessed on // multiple threads at the same time. bool buffer_owned_by_file_thread_; #endif IMPLEMENT_REFCOUNTING(CefStreamResourceHandler); DISALLOW_COPY_AND_ASSIGN(CefStreamResourceHandler); }; #endif // CEF_INCLUDE_WRAPPER_CEF_STREAM_RESOURCE_HANDLER_H_ cefpython-49.0/src/include/wrapper/cef_xml_object.h000066400000000000000000000161261334103266300224620ustar00rootroot00000000000000// 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 #include "include/base/cef_lock.h" #include "include/base/cef_macros.h" #include "include/base/cef_ref_counted.h" #include "include/cef_base.h" #include "include/cef_xml_reader.h" 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 base::RefCountedThreadSafe { 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); /// // 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: // Protect against accidental deletion of this object. friend class base::RefCountedThreadSafe; ~CefXmlObject(); void SetParent(CefXmlObject* parent); CefString name_; CefXmlObject* parent_; CefString value_; AttributeMap attributes_; ObjectVector children_; base::Lock lock_; DISALLOW_COPY_AND_ASSIGN(CefXmlObject); }; #endif // CEF_INCLUDE_WRAPPER_CEF_XML_OBJECT_H_ cefpython-49.0/src/include/wrapper/cef_zip_archive.h000066400000000000000000000112731334103266300226350ustar00rootroot00000000000000// 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 "include/base/cef_lock.h" #include "include/base/cef_macros.h" #include "include/base/cef_ref_counted.h" #include "include/cef_base.h" 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) All file names are stored and compared in lower case. // (2) 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 base::RefCountedThreadSafe { 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() const =0; /// // Returns the size of the data in the file. /// virtual size_t GetDataSize() const =0; /// // Returns a CefStreamReader object for streaming the contents of the file. /// virtual CefRefPtr GetStreamReader() const =0; }; typedef std::map > FileMap; /// // Create a new object. /// CefZipArchive(); /// // Load the contents of the specified zip archive stream into this object. // If the zip archive requires a password then provide it via |password|. // 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, const CefString& password, bool overwriteExisting); /// // Clears the contents of this object. /// void Clear(); /// // Returns the number of files in the archive. /// size_t GetFileCount() const; /// // Returns true if the specified file exists and has contents. /// bool HasFile(const CefString& fileName) const; /// // Returns the specified file. /// CefRefPtr GetFile(const CefString& fileName) const; /// // Removes the specified file. /// bool RemoveFile(const CefString& fileName); /// // Returns the map of all files. /// size_t GetFiles(FileMap& map) const; private: // Protect against accidental deletion of this object. friend class base::RefCountedThreadSafe; ~CefZipArchive(); FileMap contents_; mutable base::Lock lock_; DISALLOW_COPY_AND_ASSIGN(CefZipArchive); }; #endif // CEF_INCLUDE_WRAPPER_CEF_ZIP_ARCHIVE_H_ cefpython-49.0/src/javascript_bindings.pyx000066400000000000000000000137141334103266300210300ustar00rootroot00000000000000# Copyright (c) 2012 CEF Python, see the Authors file. # All rights reserved. Licensed under BSD 3-clause license. # Project website: https://github.com/cztomczak/cefpython include "cefpython.pyx" cdef class JavascriptBindings: # By default binding only to top frame. cdef public py_bool bindToFrames cdef public py_bool bindToPopups cdef public dict functions cdef public dict properties cdef public dict objects def __init__(self, bindToFrames=False, bindToPopups=False): self.functions = {} self.properties = {} self.objects = {} self.bindToFrames = bool(bindToFrames) self.bindToPopups = bool(bindToPopups) cpdef py_bool GetBindToFrames(self): return bool(self.bindToFrames) cpdef py_bool GetBindToPopups(self): return bool(self.bindToPopups) cpdef py_void SetFunction(self, py_string name, object func): self.SetProperty(name, func) cpdef py_void SetObject(self, py_string name, object obj): if not hasattr(obj, "__class__"): raise Exception("JavascriptBindings.SetObject() failed: name=%s, " "__class__ attribute missing, this is not an object" % name) cdef dict methods = {} cdef py_string key cdef object method cdef object predicate = inspect.ismethod if isinstance(obj, (PyBrowser, PyFrame)): predicate = inspect.isbuiltin for value in inspect.getmembers(obj, predicate=predicate): key = value[0] method = value[1] methods[key] = method self.objects[name] = methods cpdef object GetFunction(self, py_string name): if name in self.functions: return self.functions[name] cpdef dict GetFunctions(self): return self.functions cpdef dict GetObjects(self): return self.objects cpdef object GetObjectMethod(self, py_string objectName, py_string methodName): if objectName in self.objects: if methodName in self.objects[objectName]: return self.objects[objectName][methodName] cpdef object GetFunctionOrMethod(self, py_string name): # Name can be "someFunc" or "object.someMethod". cdef list words if "." in name: words = name.split(".") return self.GetObjectMethod(words[0], words[1]) else: return self.GetFunction(name) cpdef py_void SetProperty(self, py_string name, object value): cdef object allowed = self.IsValueAllowedRecursively(value) # returns True or string. if allowed is not True: raise Exception("JavascriptBindings.SetProperty() failed: name=%s, " "not allowed type: %s (this may be a type of a nested value)" % (name, allowed)) cdef object valueType = type(value) if IsFunctionOrMethod(valueType): self.functions[name] = value else: self.properties[name] = value cpdef py_void Rebind(self): # Rebind() is called for both first-time binding and rebinding. cdef PyBrowser pyBrowser cdef dict functions cdef dict properties cdef dict objects cdef dict methods for browserId, pyBrowser in g_pyBrowsers.iteritems(): if pyBrowser.GetJavascriptBindings() != self: continue # Send to the Renderer process: functions, properties, # objects and its methods, bindToFrames. functions = {} for funcName in self.functions: functions[funcName] = None properties = self.properties objects = {} for objectName in self.objects: methods = {} for methodName in self.objects[objectName]: methods[methodName] = None objects[objectName] = methods pyBrowser.SendProcessMessage(cef_types.PID_RENDERER, 0, "DoJavascriptBindings", [{ "functions": functions, "properties": properties, "objects": objects, "bindToFrames": self.bindToFrames }]) cpdef dict GetProperties(self): return self.properties @staticmethod def IsValueAllowed(object value): return JavascriptBindings.IsValueAllowedRecursively(value) is True @staticmethod def IsValueAllowedRecursively(object value, py_bool recursion=False): # When making changes here modify also Frame.SetProperty() as it # checks for FunctionType, MethodType. cdef object valueType = type(value) cdef object valueType2 cdef object key if valueType == list: for val in value: valueType2 = JavascriptBindings.IsValueAllowedRecursively(val, True) if valueType2 is not True: return valueType2.__name__ return True elif valueType == bool: return True elif valueType == float: return True elif valueType == int: return True elif valueType == type(None): return True elif IsFunctionOrMethod(valueType): if recursion: return valueType.__name__ else: return True elif valueType == dict: for key in value: valueType2 = JavascriptBindings.IsValueAllowedRecursively(value[key], True) if valueType2 is not True: return valueType2.__name__ return True elif valueType == str or valueType == bytes: return True elif PY_MAJOR_VERSION < 3 and valueType == unicode: # The unicode type is not defined in Python 3. return True elif valueType == tuple: return True else: return valueType.__name__ cefpython-49.0/src/javascript_callback.pyx000066400000000000000000000042301334103266300207600ustar00rootroot00000000000000# Copyright (c) 2013 CEF Python, see the Authors file. # All rights reserved. Licensed under BSD 3-clause license. # Project website: https://github.com/cztomczak/cefpython include "cefpython.pyx" include "browser.pyx" cdef JavascriptCallback CreateJavascriptCallback(int callbackId, CefRefPtr[CefBrowser] cefBrowser, object frameId, py_string functionName): # frameId is int64 cdef JavascriptCallback jsCallback = JavascriptCallback() jsCallback.callbackId = callbackId cdef PyBrowser browser = GetPyBrowser(cefBrowser) jsCallback.frame = browser.GetFrameByIdentifier(frameId) jsCallback.functionName = functionName Debug("Created javascript callback, callbackId=%s, functionName=%s" % \ (callbackId, functionName)) return jsCallback cdef class JavascriptCallback: """A javascript callback object may still live while browser/frame are destroyed. Always check frame/browser for None value.""" cdef int callbackId cdef PyFrame frame cdef py_string functionName def Call(self, *args): # Send process message "ExecuteJavascriptCallback". if self.frame: browser = self.frame.GetBrowser() if browser: browser.SendProcessMessage( cef_types.PID_RENDERER, self.frame.GetIdentifier(), "ExecuteJavascriptCallback", [self.callbackId] + list(args)) else: # This code probably ain't needed raise Exception("JavascriptCallback.Call() FAILED: browser" " not found, callbackId = %s" % self.callbackId) else: # This code probably ain't needed raise Exception("JavascriptCallback.Call() FAILED: frame not found" ", callbackId = %s" % self.callbackId) def GetFunctionName(self): return self.functionName def GetName(self): """@deprecated.""" return self.GetFunctionName() def GetId(self): return self.callbackId def GetFrame(self): return self.frame cefpython-49.0/src/linux/000077500000000000000000000000001334103266300153745ustar00rootroot00000000000000cefpython-49.0/src/linux/binaries_64bit/000077500000000000000000000000001334103266300202005ustar00rootroot00000000000000cefpython-49.0/src/linux/binaries_64bit/kivy-select-boxes/000077500000000000000000000000001334103266300235555ustar00rootroot00000000000000cefpython-49.0/src/linux/binaries_64bit/kivy-select-boxes/kivy-selectBox.css000066400000000000000000000121201334103266300271730ustar00rootroot00000000000000/* IMPORTANT: 1. DO NOT USE DOUBLE QUOTES HERE! This file contents is included on page using document.write: | (DQ = double quote) | document.write(DQDQ); 2. Each attribute must end with a semicolon, as newlines are removed from this file. */ /* Dropdown control */ .__kivy__selectBox-dropdown { min-width: 150px; position: relative; border: solid 1px #BBB; line-height: 1.5; text-decoration: none; text-align: left; color: #000; outline: none; vertical-align: middle; background: #F2F2F2; background: -moz-linear-gradient(top, #F8F8F8 1%, #E1E1E1 100%); background: -webkit-gradient(linear, left top, left bottom, color-stop(1%, #F8F8F8), color-stop(100%, #E1E1E1)); filter: progid:DXImageTransform.Microsoft.gradient(startColorstr='#F8F8F8', endColorstr='#E1E1E1', GradientType=0); -moz-box-shadow: 0 1px 0 rgba(255, 255, 255, .75); -webkit-box-shadow: 0 1px 0 rgba(255, 255, 255, .75); box-shadow: 0 1px 0 rgba(255, 255, 255, .75); -webkit-border-radius: 4px; -moz-border-radius: 4px; border-radius: 4px; display: inline-block; cursor: default; } .__kivy__selectBox-dropdown:focus, .__kivy__selectBox-dropdown:focus .__kivy__selectBox-arrow { border-color: #666; } .__kivy__selectBox-dropdown.__kivy__selectBox-menuShowing-bottom { -moz-border-radius-bottomleft: 0; -moz-border-radius-bottomright: 0; -webkit-border-bottom-left-radius: 0; -webkit-border-bottom-right-radius: 0; border-bottom-left-radius: 0; border-bottom-right-radius: 0; } .__kivy__selectBox-dropdown.__kivy__selectBox-menuShowing-top { -moz-border-radius-topleft: 0; -moz-border-radius-topright: 0; -webkit-border-top-left-radius: 0; -webkit-border-top-right-radius: 0; border-top-left-radius: 0; border-top-right-radius: 0; } .__kivy__selectBox-dropdown .__kivy__selectBox-label { padding: 2px 8px; display: inline-block; white-space: nowrap; overflow: hidden; } .__kivy__selectBox-dropdown .__kivy__selectBox-arrow { position: absolute; top: 0; right: 0; width: 23px; height: 100%; background: url(data:image/gif;base64,R0lGODlhCQAOAIABAAAAAP///yH5BAEAAAEALAAAAAAJAA4AAAIXjAOnwIrcDJxvQoez3tUmn0jUEjmhUQAAOw==) 50% center no-repeat; border-left: solid 1px #BBB; } /* Dropdown menu */ .__kivy__selectBox-dropdown-menu { position: absolute; z-index: 99999; max-height: 200px; min-height: 1em; border: solid 1px #BBB; /* should be the same border width as .__kivy__selectBox-dropdown */ background: #FFF; -moz-box-shadow: 0 2px 6px rgba(0, 0, 0, .2); -webkit-box-shadow: 0 2px 6px rgba(0, 0, 0, .2); box-shadow: 0 2px 6px rgba(0, 0, 0, .2); overflow: auto; -webkit-overflow-scrolling: touch; } /* Inline control */ .__kivy__selectBox-inline { min-width: 150px; outline: none; border: solid 1px #BBB; background: #FFF; display: inline-block; -webkit-border-radius: 4px; -moz-border-radius: 4px; border-radius: 4px; overflow: auto; } .__kivy__selectBox-inline:focus { border-color: #666; } /* Options */ .__kivy__selectBox-options, .__kivy__selectBox-options LI, .__kivy__selectBox-options LI A { list-style: none; display: block; cursor: default; padding: 0; margin: 0; } .__kivy__selectBox-options.__kivy__selectBox-options-top{ border-bottom:none; margin-top:1px; -moz-border-radius-topleft: 5px; -moz-border-radius-topright: 5px; -webkit-border-top-left-radius: 5px; -webkit-border-top-right-radius: 5px; border-top-left-radius: 5px; border-top-right-radius: 5px; } .__kivy__selectBox-options.__kivy__selectBox-options-bottom{ border-top:none; -moz-border-radius-bottomleft: 5px; -moz-border-radius-bottomright: 5px; -webkit-border-bottom-left-radius: 5px; -webkit-border-bottom-right-radius: 5px; border-bottom-left-radius: 5px; border-bottom-right-radius: 5px; } .__kivy__selectBox-options LI A { line-height: 1.5; padding: 0 .5em; white-space: nowrap; overflow: hidden; background: 6px center no-repeat; } .__kivy__selectBox-options LI.__kivy__selectBox-hover A { background-color: #EEE; } .__kivy__selectBox-options LI.__kivy__selectBox-disabled A { color: #888; background-color: transparent; } .__kivy__selectBox-options LI.__kivy__selectBox-selected A { background-color: #C8DEF4; } .__kivy__selectBox-options .__kivy__selectBox-optgroup { color: #666; background: #EEE; font-weight: bold; line-height: 1.5; padding: 0 .3em; white-space: nowrap; } /* Disabled state */ .__kivy__selectBox.__kivy__selectBox-disabled { color: #888 !important; } .__kivy__selectBox-dropdown.__kivy__selectBox-disabled .__kivy__selectBox-arrow { opacity: .5; filter: alpha(opacity=50); border-color: #666; } .__kivy__selectBox-inline.__kivy__selectBox-disabled { color: #888 !important; } .__kivy__selectBox-inline.__kivy__selectBox-disabled .__kivy__selectBox-options A { background-color: transparent !important; } cefpython-49.0/src/linux/binaries_64bit/kivy-select-boxes/kivy-selectBox.js000066400000000000000000013017661334103266300270410ustar00rootroot00000000000000/*! * __kivy__jQuery JavaScript Library v1.7.1 * http://jquery.com/ * * Copyright 2011, John Resig * Dual licensed under the MIT or GPL Version 2 licenses. * http://jquery.org/license * * Includes Sizzle.js * http://sizzlejs.com/ * Copyright 2011, The Dojo Foundation * Released under the MIT, BSD, and GPL Licenses. * * Date: Mon Nov 21 21:11:03 2011 -0500 */ (function( window, undefined ) { // Use the correct document accordingly with window argument (sandbox) var document = window.document, navigator = window.navigator, location = window.location; var __kivy__jQuery = (function() { // Define a local copy of __kivy__jQuery var __kivy__jQuery = function( selector, context ) { // The __kivy__jQuery object is actually just the init constructor 'enhanced' return new __kivy__jQuery.fn.init( selector, context, root__kivy__jQuery ); }, // Map over __kivy__jQuery in case of overwrite ___kivy__jQuery = window.__kivy__jQuery, // Map over the $ in case of overwrite __kivy___$ = window.__kivy__$, // A central reference to the root __kivy__jQuery(document) root__kivy__jQuery, // A simple way to check for HTML strings or ID strings // Prioritize #id over to avoid XSS via location.hash (#9521) quickExpr = /^(?:[^#<]*(<[\w\W]+>)[^>]*$|#([\w\-]*)$)/, // Check if a string has a non-whitespace character in it rnotwhite = /\S/, // Used for trimming whitespace trimLeft = /^\s+/, trimRight = /\s+$/, // Match a standalone tag rsingleTag = /^<(\w+)\s*\/?>(?:<\/\1>)?$/, // JSON RegExp rvalidchars = /^[\],:{}\s]*$/, rvalidescape = /\\(?:["\\\/bfnrt]|u[0-9a-fA-F]{4})/g, rvalidtokens = /"[^"\\\n\r]*"|true|false|null|-?\d+(?:\.\d*)?(?:[eE][+\-]?\d+)?/g, rvalidbraces = /(?:^|:|,)(?:\s*\[)+/g, // Useragent RegExp rwebkit = /(webkit)[ \/]([\w.]+)/, ropera = /(opera)(?:.*version)?[ \/]([\w.]+)/, rmsie = /(msie) ([\w.]+)/, rmozilla = /(mozilla)(?:.*? rv:([\w.]+))?/, // Matches dashed string for camelizing rdashAlpha = /-([a-z]|[0-9])/ig, rmsPrefix = /^-ms-/, // Used by __kivy__jQuery.camelCase as callback to replace() fcamelCase = function( all, letter ) { return ( letter + "" ).toUpperCase(); }, // Keep a UserAgent string for use with __kivy__jQuery.browser userAgent = navigator.userAgent, // For matching the engine and version of the browser browserMatch, // The deferred used on DOM ready readyList, // The ready event handler DOMContentLoaded, // Save a reference to some core methods toString = Object.prototype.toString, hasOwn = Object.prototype.hasOwnProperty, push = Array.prototype.push, slice = Array.prototype.slice, trim = String.prototype.trim, indexOf = Array.prototype.indexOf, // [[Class]] -> type pairs class2type = {}; __kivy__jQuery.fn = __kivy__jQuery.prototype = { constructor: __kivy__jQuery, init: function( selector, context, root__kivy__jQuery ) { var match, elem, ret, doc; // Handle $(""), $(null), or $(undefined) if ( !selector ) { return this; } // Handle $(DOMElement) if ( selector.nodeType ) { this.context = this[0] = selector; this.length = 1; return this; } // The body element only exists once, optimize finding it if ( selector === "body" && !context && document.body ) { this.context = document; this[0] = document.body; this.selector = selector; this.length = 1; return this; } // Handle HTML strings if ( typeof selector === "string" ) { // Are we dealing with HTML string or an ID? if ( selector.charAt(0) === "<" && selector.charAt( selector.length - 1 ) === ">" && selector.length >= 3 ) { // Assume that strings that start and end with <> are HTML and skip the regex check match = [ null, selector, null ]; } else { match = quickExpr.exec( selector ); } // Verify a match, and that no context was specified for #id if ( match && (match[1] || !context) ) { // HANDLE: $(html) -> $(array) if ( match[1] ) { context = context instanceof __kivy__jQuery ? context[0] : context; doc = ( context ? context.ownerDocument || context : document ); // If a single string is passed in and it's a single tag // just do a createElement and skip the rest ret = rsingleTag.exec( selector ); if ( ret ) { if ( __kivy__jQuery.isPlainObject( context ) ) { selector = [ document.createElement( ret[1] ) ]; __kivy__jQuery.fn.attr.call( selector, context, true ); } else { selector = [ doc.createElement( ret[1] ) ]; } } else { ret = __kivy__jQuery.buildFragment( [ match[1] ], [ doc ] ); selector = ( ret.cacheable ? __kivy__jQuery.clone(ret.fragment) : ret.fragment ).childNodes; } return __kivy__jQuery.merge( this, selector ); // HANDLE: $("#id") } else { elem = document.getElementById( match[2] ); // Check parentNode to catch when Blackberry 4.6 returns // nodes that are no longer in the document #6963 if ( elem && elem.parentNode ) { // Handle the case where IE and Opera return items // by name instead of ID if ( elem.id !== match[2] ) { return root__kivy__jQuery.find( selector ); } // Otherwise, we inject the element directly into the __kivy__jQuery object this.length = 1; this[0] = elem; } this.context = document; this.selector = selector; return this; } // HANDLE: $(expr, $(...)) } else if ( !context || context.__kivy__jquery ) { return ( context || root__kivy__jQuery ).find( selector ); // HANDLE: $(expr, context) // (which is just equivalent to: $(context).find(expr) } else { return this.constructor( context ).find( selector ); } // HANDLE: $(function) // Shortcut for document ready } else if ( __kivy__jQuery.isFunction( selector ) ) { return root__kivy__jQuery.ready( selector ); } if ( selector.selector !== undefined ) { this.selector = selector.selector; this.context = selector.context; } return __kivy__jQuery.makeArray( selector, this ); }, // Start with an empty selector selector: "", // The current version of __kivy__jQuery being used __kivy__jquery: "1.7.1", // The default length of a __kivy__jQuery object is 0 length: 0, // The number of elements contained in the matched element set size: function() { return this.length; }, toArray: function() { return slice.call( this, 0 ); }, // Get the Nth element in the matched element set OR // Get the whole matched element set as a clean array get: function( num ) { return num == null ? // Return a 'clean' array this.toArray() : // Return just the object ( num < 0 ? this[ this.length + num ] : this[ num ] ); }, // Take an array of elements and push it onto the stack // (returning the new matched element set) pushStack: function( elems, name, selector ) { // Build a new __kivy__jQuery matched element set var ret = this.constructor(); if ( __kivy__jQuery.isArray( elems ) ) { push.apply( ret, elems ); } else { __kivy__jQuery.merge( ret, elems ); } // Add the old object onto the stack (as a reference) ret.prevObject = this; ret.context = this.context; if ( name === "find" ) { ret.selector = this.selector + ( this.selector ? " " : "" ) + selector; } else if ( name ) { ret.selector = this.selector + "." + name + "(" + selector + ")"; } // Return the newly-formed element set return ret; }, // Execute a callback for every element in the matched set. // (You can seed the arguments with an array of args, but this is // only used internally.) each: function( callback, args ) { return __kivy__jQuery.each( this, callback, args ); }, ready: function( fn ) { // Attach the listeners __kivy__jQuery.bindReady(); // Add the callback readyList.add( fn ); return this; }, eq: function( i ) { i = +i; return i === -1 ? this.slice( i ) : this.slice( i, i + 1 ); }, first: function() { return this.eq( 0 ); }, last: function() { return this.eq( -1 ); }, slice: function() { return this.pushStack( slice.apply( this, arguments ), "slice", slice.call(arguments).join(",") ); }, map: function( callback ) { return this.pushStack( __kivy__jQuery.map(this, function( elem, i ) { return callback.call( elem, i, elem ); })); }, end: function() { return this.prevObject || this.constructor(null); }, // For internal use only. // Behaves like an Array's method, not like a __kivy__jQuery method. push: push, sort: [].sort, splice: [].splice }; // Give the init function the __kivy__jQuery prototype for later instantiation __kivy__jQuery.fn.init.prototype = __kivy__jQuery.fn; __kivy__jQuery.extend = __kivy__jQuery.fn.extend = function() { var options, name, src, copy, copyIsArray, clone, target = arguments[0] || {}, i = 1, length = arguments.length, deep = false; // Handle a deep copy situation if ( typeof target === "boolean" ) { deep = target; target = arguments[1] || {}; // skip the boolean and the target i = 2; } // Handle case when target is a string or something (possible in deep copy) if ( typeof target !== "object" && !__kivy__jQuery.isFunction(target) ) { target = {}; } // extend __kivy__jQuery itself if only one argument is passed if ( length === i ) { target = this; --i; } for ( ; i < length; i++ ) { // Only deal with non-null/undefined values if ( (options = arguments[ i ]) != null ) { // Extend the base object for ( name in options ) { src = target[ name ]; copy = options[ name ]; // Prevent never-ending loop if ( target === copy ) { continue; } // Recurse if we're merging plain objects or arrays if ( deep && copy && ( __kivy__jQuery.isPlainObject(copy) || (copyIsArray = __kivy__jQuery.isArray(copy)) ) ) { if ( copyIsArray ) { copyIsArray = false; clone = src && __kivy__jQuery.isArray(src) ? src : []; } else { clone = src && __kivy__jQuery.isPlainObject(src) ? src : {}; } // Never move original objects, clone them target[ name ] = __kivy__jQuery.extend( deep, clone, copy ); // Don't bring in undefined values } else if ( copy !== undefined ) { target[ name ] = copy; } } } } // Return the modified object return target; }; __kivy__jQuery.extend({ noConflict: function( deep ) { if ( window.__kivy__$ === __kivy__jQuery ) { window.__kivy__$ = __kivy___$; } if ( deep && window.__kivy__jQuery === __kivy__jQuery ) { window.__kivy__jQuery = ___kivy__jQuery; } return __kivy__jQuery; }, // Is the DOM ready to be used? Set to true once it occurs. isReady: false, // A counter to track how many items to wait for before // the ready event fires. See #6781 readyWait: 1, // Hold (or release) the ready event holdReady: function( hold ) { if ( hold ) { __kivy__jQuery.readyWait++; } else { __kivy__jQuery.ready( true ); } }, // Handle when the DOM is ready ready: function( wait ) { // Either a released hold or an DOMready/load event and not yet ready if ( (wait === true && !--__kivy__jQuery.readyWait) || (wait !== true && !__kivy__jQuery.isReady) ) { // Make sure body exists, at least, in case IE gets a little overzealous (ticket #5443). if ( !document.body ) { return setTimeout( __kivy__jQuery.ready, 1 ); } // Remember that the DOM is ready __kivy__jQuery.isReady = true; // If a normal DOM Ready event fired, decrement, and wait if need be if ( wait !== true && --__kivy__jQuery.readyWait > 0 ) { return; } // If there are functions bound, to execute readyList.fireWith( document, [ __kivy__jQuery ] ); // Trigger any bound ready events if ( __kivy__jQuery.fn.trigger ) { __kivy__jQuery( document ).trigger( "ready" ).off( "ready" ); } } }, bindReady: function() { if ( readyList ) { return; } readyList = __kivy__jQuery.Callbacks( "once memory" ); // Catch cases where $(document).ready() is called after the // browser event has already occurred. if ( document.readyState === "complete" ) { // Handle it asynchronously to allow scripts the opportunity to delay ready return setTimeout( __kivy__jQuery.ready, 1 ); } // Mozilla, Opera and webkit nightlies currently support this event if ( document.addEventListener ) { // Use the handy event callback document.addEventListener( "DOMContentLoaded", DOMContentLoaded, false ); // A fallback to window.onload, that will always work window.addEventListener( "load", __kivy__jQuery.ready, false ); // If IE event model is used } else if ( document.attachEvent ) { // ensure firing before onload, // maybe late but safe also for iframes document.attachEvent( "onreadystatechange", DOMContentLoaded ); // A fallback to window.onload, that will always work window.attachEvent( "onload", __kivy__jQuery.ready ); // If IE and not a frame // continually check to see if the document is ready var toplevel = false; try { toplevel = window.frameElement == null; } catch(e) {} if ( document.documentElement.doScroll && toplevel ) { doScrollCheck(); } } }, // See test/unit/core.js for details concerning isFunction. // Since version 1.3, DOM methods and functions like alert // aren't supported. They return false on IE (#2968). isFunction: function( obj ) { return __kivy__jQuery.type(obj) === "function"; }, isArray: Array.isArray || function( obj ) { return __kivy__jQuery.type(obj) === "array"; }, // A crude way of determining if an object is a window isWindow: function( obj ) { return obj && typeof obj === "object" && "setInterval" in obj; }, isNumeric: function( obj ) { return !isNaN( parseFloat(obj) ) && isFinite( obj ); }, type: function( obj ) { return obj == null ? String( obj ) : class2type[ toString.call(obj) ] || "object"; }, isPlainObject: function( obj ) { // Must be an Object. // Because of IE, we also have to check the presence of the constructor property. // Make sure that DOM nodes and window objects don't pass through, as well if ( !obj || __kivy__jQuery.type(obj) !== "object" || obj.nodeType || __kivy__jQuery.isWindow( obj ) ) { return false; } try { // Not own constructor property must be Object if ( obj.constructor && !hasOwn.call(obj, "constructor") && !hasOwn.call(obj.constructor.prototype, "isPrototypeOf") ) { return false; } } catch ( e ) { // IE8,9 Will throw exceptions on certain host objects #9897 return false; } // Own properties are enumerated firstly, so to speed up, // if last one is own, then all properties are own. var key; for ( key in obj ) {} return key === undefined || hasOwn.call( obj, key ); }, isEmptyObject: function( obj ) { for ( var name in obj ) { return false; } return true; }, error: function( msg ) { throw new Error( msg ); }, parseJSON: function( data ) { if ( typeof data !== "string" || !data ) { return null; } // Make sure leading/trailing whitespace is removed (IE can't handle it) data = __kivy__jQuery.trim( data ); // Attempt to parse using the native JSON parser first if ( window.JSON && window.JSON.parse ) { return window.JSON.parse( data ); } // Make sure the incoming data is actual JSON // Logic borrowed from http://json.org/json2.js if ( rvalidchars.test( data.replace( rvalidescape, "@" ) .replace( rvalidtokens, "]" ) .replace( rvalidbraces, "")) ) { return ( new Function( "return " + data ) )(); } __kivy__jQuery.error( "Invalid JSON: " + data ); }, // Cross-browser xml parsing parseXML: function( data ) { var xml, tmp; try { if ( window.DOMParser ) { // Standard tmp = new DOMParser(); xml = tmp.parseFromString( data , "text/xml" ); } else { // IE xml = new ActiveXObject( "Microsoft.XMLDOM" ); xml.async = "false"; xml.loadXML( data ); } } catch( e ) { xml = undefined; } if ( !xml || !xml.documentElement || xml.getElementsByTagName( "parsererror" ).length ) { __kivy__jQuery.error( "Invalid XML: " + data ); } return xml; }, noop: function() {}, // Evaluates a script in a global context // Workarounds based on findings by Jim Driscoll // http://weblogs.java.net/blog/driscoll/archive/2009/09/08/eval-javascript-global-context globalEval: function( data ) { if ( data && rnotwhite.test( data ) ) { // We use execScript on Internet Explorer // We use an anonymous function so that context is window // rather than __kivy__jQuery in Firefox ( window.execScript || function( data ) { window[ "eval" ].call( window, data ); } )( data ); } }, // Convert dashed to camelCase; used by the css and data modules // Microsoft forgot to hump their vendor prefix (#9572) camelCase: function( string ) { return string.replace( rmsPrefix, "ms-" ).replace( rdashAlpha, fcamelCase ); }, nodeName: function( elem, name ) { return elem.nodeName && elem.nodeName.toUpperCase() === name.toUpperCase(); }, // args is for internal usage only each: function( object, callback, args ) { var name, i = 0, length = object.length, isObj = length === undefined || __kivy__jQuery.isFunction( object ); if ( args ) { if ( isObj ) { for ( name in object ) { if ( callback.apply( object[ name ], args ) === false ) { break; } } } else { for ( ; i < length; ) { if ( callback.apply( object[ i++ ], args ) === false ) { break; } } } // A special, fast, case for the most common use of each } else { if ( isObj ) { for ( name in object ) { if ( callback.call( object[ name ], name, object[ name ] ) === false ) { break; } } } else { for ( ; i < length; ) { if ( callback.call( object[ i ], i, object[ i++ ] ) === false ) { break; } } } } return object; }, // Use native String.trim function wherever possible trim: trim ? function( text ) { return text == null ? "" : trim.call( text ); } : // Otherwise use our own trimming functionality function( text ) { return text == null ? "" : text.toString().replace( trimLeft, "" ).replace( trimRight, "" ); }, // results is for internal usage only makeArray: function( array, results ) { var ret = results || []; if ( array != null ) { // The window, strings (and functions) also have 'length' // Tweaked logic slightly to handle Blackberry 4.7 RegExp issues #6930 var type = __kivy__jQuery.type( array ); if ( array.length == null || type === "string" || type === "function" || type === "regexp" || __kivy__jQuery.isWindow( array ) ) { push.call( ret, array ); } else { __kivy__jQuery.merge( ret, array ); } } return ret; }, inArray: function( elem, array, i ) { var len; if ( array ) { if ( indexOf ) { return indexOf.call( array, elem, i ); } len = array.length; i = i ? i < 0 ? Math.max( 0, len + i ) : i : 0; for ( ; i < len; i++ ) { // Skip accessing in sparse arrays if ( i in array && array[ i ] === elem ) { return i; } } } return -1; }, merge: function( first, second ) { var i = first.length, j = 0; if ( typeof second.length === "number" ) { for ( var l = second.length; j < l; j++ ) { first[ i++ ] = second[ j ]; } } else { while ( second[j] !== undefined ) { first[ i++ ] = second[ j++ ]; } } first.length = i; return first; }, grep: function( elems, callback, inv ) { var ret = [], retVal; inv = !!inv; // Go through the array, only saving the items // that pass the validator function for ( var i = 0, length = elems.length; i < length; i++ ) { retVal = !!callback( elems[ i ], i ); if ( inv !== retVal ) { ret.push( elems[ i ] ); } } return ret; }, // arg is for internal usage only map: function( elems, callback, arg ) { var value, key, ret = [], i = 0, length = elems.length, // jquery objects are treated as arrays isArray = elems instanceof __kivy__jQuery || length !== undefined && typeof length === "number" && ( ( length > 0 && elems[ 0 ] && elems[ length -1 ] ) || length === 0 || __kivy__jQuery.isArray( elems ) ) ; // Go through the array, translating each of the items to their if ( isArray ) { for ( ; i < length; i++ ) { value = callback( elems[ i ], i, arg ); if ( value != null ) { ret[ ret.length ] = value; } } // Go through every key on the object, } else { for ( key in elems ) { value = callback( elems[ key ], key, arg ); if ( value != null ) { ret[ ret.length ] = value; } } } // Flatten any nested arrays return ret.concat.apply( [], ret ); }, // A global GUID counter for objects guid: 1, // Bind a function to a context, optionally partially applying any // arguments. proxy: function( fn, context ) { if ( typeof context === "string" ) { var tmp = fn[ context ]; context = fn; fn = tmp; } // Quick check to determine if target is callable, in the spec // this throws a TypeError, but we will just return undefined. if ( !__kivy__jQuery.isFunction( fn ) ) { return undefined; } // Simulated bind var args = slice.call( arguments, 2 ), proxy = function() { return fn.apply( context, args.concat( slice.call( arguments ) ) ); }; // Set the guid of unique handler to the same of original handler, so it can be removed proxy.guid = fn.guid = fn.guid || proxy.guid || __kivy__jQuery.guid++; return proxy; }, // Mutifunctional method to get and set values to a collection // The value/s can optionally be executed if it's a function access: function( elems, key, value, exec, fn, pass ) { var length = elems.length; // Setting many attributes if ( typeof key === "object" ) { for ( var k in key ) { __kivy__jQuery.access( elems, k, key[k], exec, fn, value ); } return elems; } // Setting one attribute if ( value !== undefined ) { // Optionally, function values get executed if exec is true exec = !pass && exec && __kivy__jQuery.isFunction(value); for ( var i = 0; i < length; i++ ) { fn( elems[i], key, exec ? value.call( elems[i], i, fn( elems[i], key ) ) : value, pass ); } return elems; } // Getting an attribute return length ? fn( elems[0], key ) : undefined; }, now: function() { return ( new Date() ).getTime(); }, // Use of __kivy__jQuery.browser is frowned upon. // More details: http://docs.jquery.com/Utilities/__kivy__jQuery.browser uaMatch: function( ua ) { ua = ua.toLowerCase(); var match = rwebkit.exec( ua ) || ropera.exec( ua ) || rmsie.exec( ua ) || ua.indexOf("compatible") < 0 && rmozilla.exec( ua ) || []; return { browser: match[1] || "", version: match[2] || "0" }; }, sub: function() { function __kivy__jQuerySub( selector, context ) { return new __kivy__jQuerySub.fn.init( selector, context ); } __kivy__jQuery.extend( true, __kivy__jQuerySub, this ); __kivy__jQuerySub.superclass = this; __kivy__jQuerySub.fn = __kivy__jQuerySub.prototype = this(); __kivy__jQuerySub.fn.constructor = __kivy__jQuerySub; __kivy__jQuerySub.sub = this.sub; __kivy__jQuerySub.fn.init = function init( selector, context ) { if ( context && context instanceof __kivy__jQuery && !(context instanceof __kivy__jQuerySub) ) { context = __kivy__jQuerySub( context ); } return __kivy__jQuery.fn.init.call( this, selector, context, root__kivy__jQuerySub ); }; __kivy__jQuerySub.fn.init.prototype = __kivy__jQuerySub.fn; var root__kivy__jQuerySub = __kivy__jQuerySub(document); return __kivy__jQuerySub; }, browser: {} }); // Populate the class2type map __kivy__jQuery.each("Boolean Number String Function Array Date RegExp Object".split(" "), function(i, name) { class2type[ "[object " + name + "]" ] = name.toLowerCase(); }); browserMatch = __kivy__jQuery.uaMatch( userAgent ); if ( browserMatch.browser ) { __kivy__jQuery.browser[ browserMatch.browser ] = true; __kivy__jQuery.browser.version = browserMatch.version; } // Deprecated, use __kivy__jQuery.browser.webkit instead if ( __kivy__jQuery.browser.webkit ) { __kivy__jQuery.browser.safari = true; } // IE doesn't match non-breaking spaces with \s if ( rnotwhite.test( "\xA0" ) ) { trimLeft = /^[\s\xA0]+/; trimRight = /[\s\xA0]+$/; } // All __kivy__jQuery objects should point back to these root__kivy__jQuery = __kivy__jQuery(document); // Cleanup functions for the document ready method if ( document.addEventListener ) { DOMContentLoaded = function() { document.removeEventListener( "DOMContentLoaded", DOMContentLoaded, false ); __kivy__jQuery.ready(); }; } else if ( document.attachEvent ) { DOMContentLoaded = function() { // Make sure body exists, at least, in case IE gets a little overzealous (ticket #5443). if ( document.readyState === "complete" ) { document.detachEvent( "onreadystatechange", DOMContentLoaded ); __kivy__jQuery.ready(); } }; } // The DOM ready check for Internet Explorer function doScrollCheck() { if ( __kivy__jQuery.isReady ) { return; } try { // If IE is used, use the trick by Diego Perini // http://javascript.nwbox.com/IEContentLoaded/ document.documentElement.doScroll("left"); } catch(e) { setTimeout( doScrollCheck, 1 ); return; } // and execute any waiting functions __kivy__jQuery.ready(); } return __kivy__jQuery; })(); // String to Object flags format cache var flagsCache = {}; // Convert String-formatted flags into Object-formatted ones and store in cache function createFlags( flags ) { var object = flagsCache[ flags ] = {}, i, length; flags = flags.split( /\s+/ ); for ( i = 0, length = flags.length; i < length; i++ ) { object[ flags[i] ] = true; } return object; } /* * Create a callback list using the following parameters: * * flags: an optional list of space-separated flags that will change how * the callback list behaves * * By default a callback list will act like an event callback list and can be * "fired" multiple times. * * Possible flags: * * once: will ensure the callback list can only be fired once (like a Deferred) * * memory: will keep track of previous values and will call any callback added * after the list has been fired right away with the latest "memorized" * values (like a Deferred) * * unique: will ensure a callback can only be added once (no duplicate in the list) * * stopOnFalse: interrupt callings when a callback returns false * */ __kivy__jQuery.Callbacks = function( flags ) { // Convert flags from String-formatted to Object-formatted // (we check in cache first) flags = flags ? ( flagsCache[ flags ] || createFlags( flags ) ) : {}; var // Actual callback list list = [], // Stack of fire calls for repeatable lists stack = [], // Last fire value (for non-forgettable lists) memory, // Flag to know if list is currently firing firing, // First callback to fire (used internally by add and fireWith) firingStart, // End of the loop when firing firingLength, // Index of currently firing callback (modified by remove if needed) firingIndex, // Add one or several callbacks to the list add = function( args ) { var i, length, elem, type, actual; for ( i = 0, length = args.length; i < length; i++ ) { elem = args[ i ]; type = __kivy__jQuery.type( elem ); if ( type === "array" ) { // Inspect recursively add( elem ); } else if ( type === "function" ) { // Add if not in unique mode and callback is not in if ( !flags.unique || !self.has( elem ) ) { list.push( elem ); } } } }, // Fire callbacks fire = function( context, args ) { args = args || []; memory = !flags.memory || [ context, args ]; firing = true; firingIndex = firingStart || 0; firingStart = 0; firingLength = list.length; for ( ; list && firingIndex < firingLength; firingIndex++ ) { if ( list[ firingIndex ].apply( context, args ) === false && flags.stopOnFalse ) { memory = true; // Mark as halted break; } } firing = false; if ( list ) { if ( !flags.once ) { if ( stack && stack.length ) { memory = stack.shift(); self.fireWith( memory[ 0 ], memory[ 1 ] ); } } else if ( memory === true ) { self.disable(); } else { list = []; } } }, // Actual Callbacks object self = { // Add a callback or a collection of callbacks to the list add: function() { if ( list ) { var length = list.length; add( arguments ); // Do we need to add the callbacks to the // current firing batch? if ( firing ) { firingLength = list.length; // With memory, if we're not firing then // we should call right away, unless previous // firing was halted (stopOnFalse) } else if ( memory && memory !== true ) { firingStart = length; fire( memory[ 0 ], memory[ 1 ] ); } } return this; }, // Remove a callback from the list remove: function() { if ( list ) { var args = arguments, argIndex = 0, argLength = args.length; for ( ; argIndex < argLength ; argIndex++ ) { for ( var i = 0; i < list.length; i++ ) { if ( args[ argIndex ] === list[ i ] ) { // Handle firingIndex and firingLength if ( firing ) { if ( i <= firingLength ) { firingLength--; if ( i <= firingIndex ) { firingIndex--; } } } // Remove the element list.splice( i--, 1 ); // If we have some unicity property then // we only need to do this once if ( flags.unique ) { break; } } } } } return this; }, // Control if a given callback is in the list has: function( fn ) { if ( list ) { var i = 0, length = list.length; for ( ; i < length; i++ ) { if ( fn === list[ i ] ) { return true; } } } return false; }, // Remove all callbacks from the list empty: function() { list = []; return this; }, // Have the list do nothing anymore disable: function() { list = stack = memory = undefined; return this; }, // Is it disabled? disabled: function() { return !list; }, // Lock the list in its current state lock: function() { stack = undefined; if ( !memory || memory === true ) { self.disable(); } return this; }, // Is it locked? locked: function() { return !stack; }, // Call all callbacks with the given context and arguments fireWith: function( context, args ) { if ( stack ) { if ( firing ) { if ( !flags.once ) { stack.push( [ context, args ] ); } } else if ( !( flags.once && memory ) ) { fire( context, args ); } } return this; }, // Call all the callbacks with the given arguments fire: function() { self.fireWith( this, arguments ); return this; }, // To know if the callbacks have already been called at least once fired: function() { return !!memory; } }; return self; }; var // Static reference to slice sliceDeferred = [].slice; __kivy__jQuery.extend({ Deferred: function( func ) { var doneList = __kivy__jQuery.Callbacks( "once memory" ), failList = __kivy__jQuery.Callbacks( "once memory" ), progressList = __kivy__jQuery.Callbacks( "memory" ), state = "pending", lists = { resolve: doneList, reject: failList, notify: progressList }, promise = { done: doneList.add, fail: failList.add, progress: progressList.add, state: function() { return state; }, // Deprecated isResolved: doneList.fired, isRejected: failList.fired, then: function( doneCallbacks, failCallbacks, progressCallbacks ) { deferred.done( doneCallbacks ).fail( failCallbacks ).progress( progressCallbacks ); return this; }, always: function() { deferred.done.apply( deferred, arguments ).fail.apply( deferred, arguments ); return this; }, pipe: function( fnDone, fnFail, fnProgress ) { return __kivy__jQuery.Deferred(function( newDefer ) { __kivy__jQuery.each( { done: [ fnDone, "resolve" ], fail: [ fnFail, "reject" ], progress: [ fnProgress, "notify" ] }, function( handler, data ) { var fn = data[ 0 ], action = data[ 1 ], returned; if ( __kivy__jQuery.isFunction( fn ) ) { deferred[ handler ](function() { returned = fn.apply( this, arguments ); if ( returned && __kivy__jQuery.isFunction( returned.promise ) ) { returned.promise().then( newDefer.resolve, newDefer.reject, newDefer.notify ); } else { newDefer[ action + "With" ]( this === deferred ? newDefer : this, [ returned ] ); } }); } else { deferred[ handler ]( newDefer[ action ] ); } }); }).promise(); }, // Get a promise for this deferred // If obj is provided, the promise aspect is added to the object promise: function( obj ) { if ( obj == null ) { obj = promise; } else { for ( var key in promise ) { obj[ key ] = promise[ key ]; } } return obj; } }, deferred = promise.promise({}), key; for ( key in lists ) { deferred[ key ] = lists[ key ].fire; deferred[ key + "With" ] = lists[ key ].fireWith; } // Handle state deferred.done( function() { state = "resolved"; }, failList.disable, progressList.lock ).fail( function() { state = "rejected"; }, doneList.disable, progressList.lock ); // Call given func if any if ( func ) { func.call( deferred, deferred ); } // All done! return deferred; }, // Deferred helper when: function( firstParam ) { var args = sliceDeferred.call( arguments, 0 ), i = 0, length = args.length, pValues = new Array( length ), count = length, pCount = length, deferred = length <= 1 && firstParam && __kivy__jQuery.isFunction( firstParam.promise ) ? firstParam : __kivy__jQuery.Deferred(), promise = deferred.promise(); function resolveFunc( i ) { return function( value ) { args[ i ] = arguments.length > 1 ? sliceDeferred.call( arguments, 0 ) : value; if ( !( --count ) ) { deferred.resolveWith( deferred, args ); } }; } function progressFunc( i ) { return function( value ) { pValues[ i ] = arguments.length > 1 ? sliceDeferred.call( arguments, 0 ) : value; deferred.notifyWith( promise, pValues ); }; } if ( length > 1 ) { for ( ; i < length; i++ ) { if ( args[ i ] && args[ i ].promise && __kivy__jQuery.isFunction( args[ i ].promise ) ) { args[ i ].promise().then( resolveFunc(i), deferred.reject, progressFunc(i) ); } else { --count; } } if ( !count ) { deferred.resolveWith( deferred, args ); } } else if ( deferred !== firstParam ) { deferred.resolveWith( deferred, length ? [ firstParam ] : [] ); } return promise; } }); __kivy__jQuery.support = (function() { var support, all, a, select, opt, input, marginDiv, fragment, tds, events, eventName, i, isSupported, div = document.createElement( "div" ), documentElement = document.documentElement; // Preliminary tests div.setAttribute("className", "t"); div.innerHTML = "
a"; all = div.getElementsByTagName( "*" ); a = div.getElementsByTagName( "a" )[ 0 ]; // Can't get basic test support if ( !all || !all.length || !a ) { return {}; } // First batch of supports tests select = document.createElement( "select" ); opt = select.appendChild( document.createElement("option") ); input = div.getElementsByTagName( "input" )[ 0 ]; support = { // IE strips leading whitespace when .innerHTML is used leadingWhitespace: ( div.firstChild.nodeType === 3 ), // Make sure that tbody elements aren't automatically inserted // IE will insert them into empty tables tbody: !div.getElementsByTagName("tbody").length, // Make sure that link elements get serialized correctly by innerHTML // This requires a wrapper element in IE htmlSerialize: !!div.getElementsByTagName("link").length, // Get the style information from getAttribute // (IE uses .cssText instead) style: /top/.test( a.getAttribute("style") ), // Make sure that URLs aren't manipulated // (IE normalizes it by default) hrefNormalized: ( a.getAttribute("href") === "/a" ), // Make sure that element opacity exists // (IE uses filter instead) // Use a regex to work around a WebKit issue. See #5145 opacity: /^0.55/.test( a.style.opacity ), // Verify style float existence // (IE uses styleFloat instead of cssFloat) cssFloat: !!a.style.cssFloat, // Make sure that if no value is specified for a checkbox // that it defaults to "on". // (WebKit defaults to "" instead) checkOn: ( input.value === "on" ), // Make sure that a selected-by-default option has a working selected property. // (WebKit defaults to false instead of true, IE too, if it's in an optgroup) optSelected: opt.selected, // Test setAttribute on camelCase class. If it works, we need attrFixes when doing get/setAttribute (ie6/7) getSetAttribute: div.className !== "t", // Tests for enctype support on a form(#6743) enctype: !!document.createElement("form").enctype, // Makes sure cloning an html5 element does not cause problems // Where outerHTML is undefined, this still works html5Clone: document.createElement("nav").cloneNode( true ).outerHTML !== "<:nav>", // Will be defined later submitBubbles: true, changeBubbles: true, focusinBubbles: false, deleteExpando: true, noCloneEvent: true, inlineBlockNeedsLayout: false, shrinkWrapBlocks: false, reliableMarginRight: true }; // Make sure checked status is properly cloned input.checked = true; support.noCloneChecked = input.cloneNode( true ).checked; // Make sure that the options inside disabled selects aren't marked as disabled // (WebKit marks them as disabled) select.disabled = true; support.optDisabled = !opt.disabled; // Test to see if it's possible to delete an expando from an element // Fails in Internet Explorer try { delete div.test; } catch( e ) { support.deleteExpando = false; } if ( !div.addEventListener && div.attachEvent && div.fireEvent ) { div.attachEvent( "onclick", function() { // Cloning a node shouldn't copy over any // bound event handlers (IE does this) support.noCloneEvent = false; }); div.cloneNode( true ).fireEvent( "onclick" ); } // Check if a radio maintains its value // after being appended to the DOM input = document.createElement("input"); input.value = "t"; input.setAttribute("type", "radio"); support.radioValue = input.value === "t"; input.setAttribute("checked", "checked"); div.appendChild( input ); fragment = document.createDocumentFragment(); fragment.appendChild( div.lastChild ); // WebKit doesn't clone checked state correctly in fragments support.checkClone = fragment.cloneNode( true ).cloneNode( true ).lastChild.checked; // Check if a disconnected checkbox will retain its checked // value of true after appended to the DOM (IE6/7) support.appendChecked = input.checked; fragment.removeChild( input ); fragment.appendChild( div ); div.innerHTML = ""; // Check if div with explicit width and no margin-right incorrectly // gets computed margin-right based on width of container. For more // info see bug #3333 // Fails in WebKit before Feb 2011 nightlies // WebKit Bug 13343 - getComputedStyle returns wrong value for margin-right if ( window.getComputedStyle ) { marginDiv = document.createElement( "div" ); marginDiv.style.width = "0"; marginDiv.style.marginRight = "0"; div.style.width = "2px"; div.appendChild( marginDiv ); support.reliableMarginRight = ( parseInt( ( window.getComputedStyle( marginDiv, null ) || { marginRight: 0 } ).marginRight, 10 ) || 0 ) === 0; } // Technique from Juriy Zaytsev // http://perfectionkills.com/detecting-event-support-without-browser-sniffing/ // We only care about the case where non-standard event systems // are used, namely in IE. Short-circuiting here helps us to // avoid an eval call (in setAttribute) which can cause CSP // to go haywire. See: https://developer.mozilla.org/en/Security/CSP if ( div.attachEvent ) { for( i in { submit: 1, change: 1, focusin: 1 }) { eventName = "on" + i; isSupported = ( eventName in div ); if ( !isSupported ) { div.setAttribute( eventName, "return;" ); isSupported = ( typeof div[ eventName ] === "function" ); } support[ i + "Bubbles" ] = isSupported; } } fragment.removeChild( div ); // Null elements to avoid leaks in IE fragment = select = opt = marginDiv = div = input = null; // Run tests that need a body at doc ready __kivy__jQuery(function() { var container, outer, inner, table, td, offsetSupport, conMarginTop, ptlm, vb, style, html, body = document.getElementsByTagName("body")[0]; if ( !body ) { // Return for frameset docs that don't have a body return; } conMarginTop = 1; ptlm = "position:absolute;top:0;left:0;width:1px;height:1px;margin:0;"; vb = "visibility:hidden;border:0;"; style = "style='" + ptlm + "border:5px solid #000;padding:0;'"; html = "
" + "" + "
"; container = document.createElement("div"); container.style.cssText = vb + "width:0;height:0;position:static;top:0;margin-top:" + conMarginTop + "px"; body.insertBefore( container, body.firstChild ); // Construct the test element div = document.createElement("div"); container.appendChild( div ); // Check if table cells still have offsetWidth/Height when they are set // to display:none and there are still other visible table cells in a // table row; if so, offsetWidth/Height are not reliable for use when // determining if an element has been hidden directly using // display:none (it is still safe to use offsets if a parent element is // hidden; don safety goggles and see bug #4512 for more information). // (only IE 8 fails this test) div.innerHTML = "
t
"; tds = div.getElementsByTagName( "td" ); isSupported = ( tds[ 0 ].offsetHeight === 0 ); tds[ 0 ].style.display = ""; tds[ 1 ].style.display = "none"; // Check if empty table cells still have offsetWidth/Height // (IE <= 8 fail this test) support.reliableHiddenOffsets = isSupported && ( tds[ 0 ].offsetHeight === 0 ); // Figure out if the W3C box model works as expected div.innerHTML = ""; div.style.width = div.style.paddingLeft = "1px"; __kivy__jQuery.boxModel = support.boxModel = div.offsetWidth === 2; if ( typeof div.style.zoom !== "undefined" ) { // Check if natively block-level elements act like inline-block // elements when setting their display to 'inline' and giving // them layout // (IE < 8 does this) div.style.display = "inline"; div.style.zoom = 1; support.inlineBlockNeedsLayout = ( div.offsetWidth === 2 ); // Check if elements with layout shrink-wrap their children // (IE 6 does this) div.style.display = ""; div.innerHTML = "
"; support.shrinkWrapBlocks = ( div.offsetWidth !== 2 ); } div.style.cssText = ptlm + vb; div.innerHTML = html; outer = div.firstChild; inner = outer.firstChild; td = outer.nextSibling.firstChild.firstChild; offsetSupport = { doesNotAddBorder: ( inner.offsetTop !== 5 ), doesAddBorderForTableAndCells: ( td.offsetTop === 5 ) }; inner.style.position = "fixed"; inner.style.top = "20px"; // safari subtracts parent border width here which is 5px offsetSupport.fixedPosition = ( inner.offsetTop === 20 || inner.offsetTop === 15 ); inner.style.position = inner.style.top = ""; outer.style.overflow = "hidden"; outer.style.position = "relative"; offsetSupport.subtractsBorderForOverflowNotVisible = ( inner.offsetTop === -5 ); offsetSupport.doesNotIncludeMarginInBodyOffset = ( body.offsetTop !== conMarginTop ); body.removeChild( container ); div = container = null; __kivy__jQuery.extend( support, offsetSupport ); }); return support; })(); var rbrace = /^(?:\{.*\}|\[.*\])$/, rmultiDash = /([A-Z])/g; __kivy__jQuery.extend({ cache: {}, // Please use with caution uuid: 0, // Unique for each copy of __kivy__jQuery on the page // Non-digits removed to match rinline__kivy__jQuery expando: "__kivy__jQuery" + ( __kivy__jQuery.fn.__kivy__jquery + Math.random() ).replace( /\D/g, "" ), // The following elements throw uncatchable exceptions if you // attempt to add expando properties to them. noData: { "embed": true, // Ban all objects except for Flash (which handle expandos) "object": "clsid:D27CDB6E-AE6D-11cf-96B8-444553540000", "applet": true }, hasData: function( elem ) { elem = elem.nodeType ? __kivy__jQuery.cache[ elem[__kivy__jQuery.expando] ] : elem[ __kivy__jQuery.expando ]; return !!elem && !isEmptyDataObject( elem ); }, data: function( elem, name, data, pvt /* Internal Use Only */ ) { if ( !__kivy__jQuery.acceptData( elem ) ) { return; } var privateCache, thisCache, ret, internalKey = __kivy__jQuery.expando, getByName = typeof name === "string", // We have to handle DOM nodes and JS objects differently because IE6-7 // can't GC object references properly across the DOM-JS boundary isNode = elem.nodeType, // Only DOM nodes need the global __kivy__jQuery cache; JS object data is // attached directly to the object so GC can occur automatically cache = isNode ? __kivy__jQuery.cache : elem, // Only defining an ID for JS objects if its cache already exists allows // the code to shortcut on the same path as a DOM node with no cache id = isNode ? elem[ internalKey ] : elem[ internalKey ] && internalKey, isEvents = name === "events"; // Avoid doing any more work than we need to when trying to get data on an // object that has no data at all if ( (!id || !cache[id] || (!isEvents && !pvt && !cache[id].data)) && getByName && data === undefined ) { return; } if ( !id ) { // Only DOM nodes need a new unique ID for each element since their data // ends up in the global cache if ( isNode ) { elem[ internalKey ] = id = ++__kivy__jQuery.uuid; } else { id = internalKey; } } if ( !cache[ id ] ) { cache[ id ] = {}; // Avoids exposing __kivy__jQuery metadata on plain JS objects when the object // is serialized using JSON.stringify if ( !isNode ) { cache[ id ].toJSON = __kivy__jQuery.noop; } } // An object can be passed to __kivy__jQuery.data instead of a key/value pair; this gets // shallow copied over onto the existing cache if ( typeof name === "object" || typeof name === "function" ) { if ( pvt ) { cache[ id ] = __kivy__jQuery.extend( cache[ id ], name ); } else { cache[ id ].data = __kivy__jQuery.extend( cache[ id ].data, name ); } } privateCache = thisCache = cache[ id ]; // __kivy__jQuery data() is stored in a separate object inside the object's internal data // cache in order to avoid key collisions between internal data and user-defined // data. if ( !pvt ) { if ( !thisCache.data ) { thisCache.data = {}; } thisCache = thisCache.data; } if ( data !== undefined ) { thisCache[ __kivy__jQuery.camelCase( name ) ] = data; } // Users should not attempt to inspect the internal events object using __kivy__jQuery.data, // it is undocumented and subject to change. But does anyone listen? No. if ( isEvents && !thisCache[ name ] ) { return privateCache.events; } // Check for both converted-to-camel and non-converted data property names // If a data property was specified if ( getByName ) { // First Try to find as-is property data ret = thisCache[ name ]; // Test for null|undefined property data if ( ret == null ) { // Try to find the camelCased property ret = thisCache[ __kivy__jQuery.camelCase( name ) ]; } } else { ret = thisCache; } return ret; }, removeData: function( elem, name, pvt /* Internal Use Only */ ) { if ( !__kivy__jQuery.acceptData( elem ) ) { return; } var thisCache, i, l, // Reference to internal data cache key internalKey = __kivy__jQuery.expando, isNode = elem.nodeType, // See __kivy__jQuery.data for more information cache = isNode ? __kivy__jQuery.cache : elem, // See __kivy__jQuery.data for more information id = isNode ? elem[ internalKey ] : internalKey; // If there is already no cache entry for this object, there is no // purpose in continuing if ( !cache[ id ] ) { return; } if ( name ) { thisCache = pvt ? cache[ id ] : cache[ id ].data; if ( thisCache ) { // Support array or space separated string names for data keys if ( !__kivy__jQuery.isArray( name ) ) { // try the string as a key before any manipulation if ( name in thisCache ) { name = [ name ]; } else { // split the camel cased version by spaces unless a key with the spaces exists name = __kivy__jQuery.camelCase( name ); if ( name in thisCache ) { name = [ name ]; } else { name = name.split( " " ); } } } for ( i = 0, l = name.length; i < l; i++ ) { delete thisCache[ name[i] ]; } // If there is no data left in the cache, we want to continue // and let the cache object itself get destroyed if ( !( pvt ? isEmptyDataObject : __kivy__jQuery.isEmptyObject )( thisCache ) ) { return; } } } // See __kivy__jQuery.data for more information if ( !pvt ) { delete cache[ id ].data; // Don't destroy the parent cache unless the internal data object // had been the only thing left in it if ( !isEmptyDataObject(cache[ id ]) ) { return; } } // Browsers that fail expando deletion also refuse to delete expandos on // the window, but it will allow it on all other JS objects; other browsers // don't care // Ensure that `cache` is not a window object #10080 if ( __kivy__jQuery.support.deleteExpando || !cache.setInterval ) { delete cache[ id ]; } else { cache[ id ] = null; } // We destroyed the cache and need to eliminate the expando on the node to avoid // false lookups in the cache for entries that no longer exist if ( isNode ) { // IE does not allow us to delete expando properties from nodes, // nor does it have a removeAttribute function on Document nodes; // we must handle all of these cases if ( __kivy__jQuery.support.deleteExpando ) { delete elem[ internalKey ]; } else if ( elem.removeAttribute ) { elem.removeAttribute( internalKey ); } else { elem[ internalKey ] = null; } } }, // For internal use only. _data: function( elem, name, data ) { return __kivy__jQuery.data( elem, name, data, true ); }, // A method for determining if a DOM node can handle the data expando acceptData: function( elem ) { if ( elem.nodeName ) { var match = __kivy__jQuery.noData[ elem.nodeName.toLowerCase() ]; if ( match ) { return !(match === true || elem.getAttribute("classid") !== match); } } return true; } }); __kivy__jQuery.fn.extend({ data: function( key, value ) { var parts, attr, name, data = null; if ( typeof key === "undefined" ) { if ( this.length ) { data = __kivy__jQuery.data( this[0] ); if ( this[0].nodeType === 1 && !__kivy__jQuery._data( this[0], "parsedAttrs" ) ) { attr = this[0].attributes; for ( var i = 0, l = attr.length; i < l; i++ ) { name = attr[i].name; if ( name.indexOf( "data-" ) === 0 ) { name = __kivy__jQuery.camelCase( name.substring(5) ); dataAttr( this[0], name, data[ name ] ); } } __kivy__jQuery._data( this[0], "parsedAttrs", true ); } } return data; } else if ( typeof key === "object" ) { return this.each(function() { __kivy__jQuery.data( this, key ); }); } parts = key.split("."); parts[1] = parts[1] ? "." + parts[1] : ""; if ( value === undefined ) { data = this.triggerHandler("getData" + parts[1] + "!", [parts[0]]); // Try to fetch any internally stored data first if ( data === undefined && this.length ) { data = __kivy__jQuery.data( this[0], key ); data = dataAttr( this[0], key, data ); } return data === undefined && parts[1] ? this.data( parts[0] ) : data; } else { return this.each(function() { var self = __kivy__jQuery( this ), args = [ parts[0], value ]; self.triggerHandler( "setData" + parts[1] + "!", args ); __kivy__jQuery.data( this, key, value ); self.triggerHandler( "changeData" + parts[1] + "!", args ); }); } }, removeData: function( key ) { return this.each(function() { __kivy__jQuery.removeData( this, key ); }); } }); function dataAttr( elem, key, data ) { // If nothing was found internally, try to fetch any // data from the HTML5 data-* attribute if ( data === undefined && elem.nodeType === 1 ) { var name = "data-" + key.replace( rmultiDash, "-$1" ).toLowerCase(); data = elem.getAttribute( name ); if ( typeof data === "string" ) { try { data = data === "true" ? true : data === "false" ? false : data === "null" ? null : __kivy__jQuery.isNumeric( data ) ? parseFloat( data ) : rbrace.test( data ) ? __kivy__jQuery.parseJSON( data ) : data; } catch( e ) {} // Make sure we set the data so it isn't changed later __kivy__jQuery.data( elem, key, data ); } else { data = undefined; } } return data; } // checks a cache object for emptiness function isEmptyDataObject( obj ) { for ( var name in obj ) { // if the public data object is empty, the private is still empty if ( name === "data" && __kivy__jQuery.isEmptyObject( obj[name] ) ) { continue; } if ( name !== "toJSON" ) { return false; } } return true; } function handleQueueMarkDefer( elem, type, src ) { var deferDataKey = type + "defer", queueDataKey = type + "queue", markDataKey = type + "mark", defer = __kivy__jQuery._data( elem, deferDataKey ); if ( defer && ( src === "queue" || !__kivy__jQuery._data(elem, queueDataKey) ) && ( src === "mark" || !__kivy__jQuery._data(elem, markDataKey) ) ) { // Give room for hard-coded callbacks to fire first // and eventually mark/queue something else on the element setTimeout( function() { if ( !__kivy__jQuery._data( elem, queueDataKey ) && !__kivy__jQuery._data( elem, markDataKey ) ) { __kivy__jQuery.removeData( elem, deferDataKey, true ); defer.fire(); } }, 0 ); } } __kivy__jQuery.extend({ _mark: function( elem, type ) { if ( elem ) { type = ( type || "fx" ) + "mark"; __kivy__jQuery._data( elem, type, (__kivy__jQuery._data( elem, type ) || 0) + 1 ); } }, _unmark: function( force, elem, type ) { if ( force !== true ) { type = elem; elem = force; force = false; } if ( elem ) { type = type || "fx"; var key = type + "mark", count = force ? 0 : ( (__kivy__jQuery._data( elem, key ) || 1) - 1 ); if ( count ) { __kivy__jQuery._data( elem, key, count ); } else { __kivy__jQuery.removeData( elem, key, true ); handleQueueMarkDefer( elem, type, "mark" ); } } }, queue: function( elem, type, data ) { var q; if ( elem ) { type = ( type || "fx" ) + "queue"; q = __kivy__jQuery._data( elem, type ); // Speed up dequeue by getting out quickly if this is just a lookup if ( data ) { if ( !q || __kivy__jQuery.isArray(data) ) { q = __kivy__jQuery._data( elem, type, __kivy__jQuery.makeArray(data) ); } else { q.push( data ); } } return q || []; } }, dequeue: function( elem, type ) { type = type || "fx"; var queue = __kivy__jQuery.queue( elem, type ), fn = queue.shift(), hooks = {}; // If the fx queue is dequeued, always remove the progress sentinel if ( fn === "inprogress" ) { fn = queue.shift(); } if ( fn ) { // Add a progress sentinel to prevent the fx queue from being // automatically dequeued if ( type === "fx" ) { queue.unshift( "inprogress" ); } __kivy__jQuery._data( elem, type + ".run", hooks ); fn.call( elem, function() { __kivy__jQuery.dequeue( elem, type ); }, hooks ); } if ( !queue.length ) { __kivy__jQuery.removeData( elem, type + "queue " + type + ".run", true ); handleQueueMarkDefer( elem, type, "queue" ); } } }); __kivy__jQuery.fn.extend({ queue: function( type, data ) { if ( typeof type !== "string" ) { data = type; type = "fx"; } if ( data === undefined ) { return __kivy__jQuery.queue( this[0], type ); } return this.each(function() { var queue = __kivy__jQuery.queue( this, type, data ); if ( type === "fx" && queue[0] !== "inprogress" ) { __kivy__jQuery.dequeue( this, type ); } }); }, dequeue: function( type ) { return this.each(function() { __kivy__jQuery.dequeue( this, type ); }); }, // Based off of the plugin by Clint Helfers, with permission. // http://blindsignals.com/index.php/2009/07/jquery-delay/ delay: function( time, type ) { time = __kivy__jQuery.fx ? __kivy__jQuery.fx.speeds[ time ] || time : time; type = type || "fx"; return this.queue( type, function( next, hooks ) { var timeout = setTimeout( next, time ); hooks.stop = function() { clearTimeout( timeout ); }; }); }, clearQueue: function( type ) { return this.queue( type || "fx", [] ); }, // Get a promise resolved when queues of a certain type // are emptied (fx is the type by default) promise: function( type, object ) { if ( typeof type !== "string" ) { object = type; type = undefined; } type = type || "fx"; var defer = __kivy__jQuery.Deferred(), elements = this, i = elements.length, count = 1, deferDataKey = type + "defer", queueDataKey = type + "queue", markDataKey = type + "mark", tmp; function resolve() { if ( !( --count ) ) { defer.resolveWith( elements, [ elements ] ); } } while( i-- ) { if (( tmp = __kivy__jQuery.data( elements[ i ], deferDataKey, undefined, true ) || ( __kivy__jQuery.data( elements[ i ], queueDataKey, undefined, true ) || __kivy__jQuery.data( elements[ i ], markDataKey, undefined, true ) ) && __kivy__jQuery.data( elements[ i ], deferDataKey, __kivy__jQuery.Callbacks( "once memory" ), true ) )) { count++; tmp.add( resolve ); } } resolve(); return defer.promise(); } }); var rclass = /[\n\t\r]/g, rspace = /\s+/, rreturn = /\r/g, rtype = /^(?:button|input)$/i, rfocusable = /^(?:button|input|object|select|textarea)$/i, rclickable = /^a(?:rea)?$/i, rboolean = /^(?:autofocus|autoplay|async|checked|controls|defer|disabled|hidden|loop|multiple|open|readonly|required|scoped|selected)$/i, getSetAttribute = __kivy__jQuery.support.getSetAttribute, nodeHook, boolHook, fixSpecified; __kivy__jQuery.fn.extend({ attr: function( name, value ) { return __kivy__jQuery.access( this, name, value, true, __kivy__jQuery.attr ); }, removeAttr: function( name ) { return this.each(function() { __kivy__jQuery.removeAttr( this, name ); }); }, prop: function( name, value ) { return __kivy__jQuery.access( this, name, value, true, __kivy__jQuery.prop ); }, removeProp: function( name ) { name = __kivy__jQuery.propFix[ name ] || name; return this.each(function() { // try/catch handles cases where IE balks (such as removing a property on window) try { this[ name ] = undefined; delete this[ name ]; } catch( e ) {} }); }, addClass: function( value ) { var classNames, i, l, elem, setClass, c, cl; if ( __kivy__jQuery.isFunction( value ) ) { return this.each(function( j ) { __kivy__jQuery( this ).addClass( value.call(this, j, this.className) ); }); } if ( value && typeof value === "string" ) { classNames = value.split( rspace ); for ( i = 0, l = this.length; i < l; i++ ) { elem = this[ i ]; if ( elem.nodeType === 1 ) { if ( !elem.className && classNames.length === 1 ) { elem.className = value; } else { setClass = " " + elem.className + " "; for ( c = 0, cl = classNames.length; c < cl; c++ ) { if ( !~setClass.indexOf( " " + classNames[ c ] + " " ) ) { setClass += classNames[ c ] + " "; } } elem.className = __kivy__jQuery.trim( setClass ); } } } } return this; }, removeClass: function( value ) { var classNames, i, l, elem, className, c, cl; if ( __kivy__jQuery.isFunction( value ) ) { return this.each(function( j ) { __kivy__jQuery( this ).removeClass( value.call(this, j, this.className) ); }); } if ( (value && typeof value === "string") || value === undefined ) { classNames = ( value || "" ).split( rspace ); for ( i = 0, l = this.length; i < l; i++ ) { elem = this[ i ]; if ( elem.nodeType === 1 && elem.className ) { if ( value ) { className = (" " + elem.className + " ").replace( rclass, " " ); for ( c = 0, cl = classNames.length; c < cl; c++ ) { className = className.replace(" " + classNames[ c ] + " ", " "); } elem.className = __kivy__jQuery.trim( className ); } else { elem.className = ""; } } } } return this; }, toggleClass: function( value, stateVal ) { var type = typeof value, isBool = typeof stateVal === "boolean"; if ( __kivy__jQuery.isFunction( value ) ) { return this.each(function( i ) { __kivy__jQuery( this ).toggleClass( value.call(this, i, this.className, stateVal), stateVal ); }); } return this.each(function() { if ( type === "string" ) { // toggle individual class names var className, i = 0, self = __kivy__jQuery( this ), state = stateVal, classNames = value.split( rspace ); while ( (className = classNames[ i++ ]) ) { // check each className given, space seperated list state = isBool ? state : !self.hasClass( className ); self[ state ? "addClass" : "removeClass" ]( className ); } } else if ( type === "undefined" || type === "boolean" ) { if ( this.className ) { // store className if set __kivy__jQuery._data( this, "__className__", this.className ); } // toggle whole className this.className = this.className || value === false ? "" : __kivy__jQuery._data( this, "__className__" ) || ""; } }); }, hasClass: function( selector ) { var className = " " + selector + " ", i = 0, l = this.length; for ( ; i < l; i++ ) { if ( this[i].nodeType === 1 && (" " + this[i].className + " ").replace(rclass, " ").indexOf( className ) > -1 ) { return true; } } return false; }, val: function( value ) { var hooks, ret, isFunction, elem = this[0]; if ( !arguments.length ) { if ( elem ) { hooks = __kivy__jQuery.valHooks[ elem.nodeName.toLowerCase() ] || __kivy__jQuery.valHooks[ elem.type ]; if ( hooks && "get" in hooks && (ret = hooks.get( elem, "value" )) !== undefined ) { return ret; } ret = elem.value; return typeof ret === "string" ? // handle most common string cases ret.replace(rreturn, "") : // handle cases where value is null/undef or number ret == null ? "" : ret; } return; } isFunction = __kivy__jQuery.isFunction( value ); return this.each(function( i ) { var self = __kivy__jQuery(this), val; if ( this.nodeType !== 1 ) { return; } if ( isFunction ) { val = value.call( this, i, self.val() ); } else { val = value; } // Treat null/undefined as ""; convert numbers to string if ( val == null ) { val = ""; } else if ( typeof val === "number" ) { val += ""; } else if ( __kivy__jQuery.isArray( val ) ) { val = __kivy__jQuery.map(val, function ( value ) { return value == null ? "" : value + ""; }); } hooks = __kivy__jQuery.valHooks[ this.nodeName.toLowerCase() ] || __kivy__jQuery.valHooks[ this.type ]; // If set returns undefined, fall back to normal setting if ( !hooks || !("set" in hooks) || hooks.set( this, val, "value" ) === undefined ) { this.value = val; } }); } }); __kivy__jQuery.extend({ valHooks: { option: { get: function( elem ) { // attributes.value is undefined in Blackberry 4.7 but // uses .value. See #6932 var val = elem.attributes.value; return !val || val.specified ? elem.value : elem.text; } }, select: { get: function( elem ) { var value, i, max, option, index = elem.selectedIndex, values = [], options = elem.options, one = elem.type === "select-one"; // Nothing was selected if ( index < 0 ) { return null; } // Loop through all the selected options i = one ? index : 0; max = one ? index + 1 : options.length; for ( ; i < max; i++ ) { option = options[ i ]; // Don't return options that are disabled or in a disabled optgroup if ( option.selected && (__kivy__jQuery.support.optDisabled ? !option.disabled : option.getAttribute("disabled") === null) && (!option.parentNode.disabled || !__kivy__jQuery.nodeName( option.parentNode, "optgroup" )) ) { // Get the specific value for the option value = __kivy__jQuery( option ).val(); // We don't need an array for one selects if ( one ) { return value; } // Multi-Selects return an array values.push( value ); } } // Fixes Bug #2551 -- select.val() broken in IE after form.reset() if ( one && !values.length && options.length ) { return __kivy__jQuery( options[ index ] ).val(); } return values; }, set: function( elem, value ) { var values = __kivy__jQuery.makeArray( value ); __kivy__jQuery(elem).find("option").each(function() { this.selected = __kivy__jQuery.inArray( __kivy__jQuery(this).val(), values ) >= 0; }); if ( !values.length ) { elem.selectedIndex = -1; } return values; } } }, attrFn: { val: true, css: true, html: true, text: true, data: true, width: true, height: true, offset: true }, attr: function( elem, name, value, pass ) { var ret, hooks, notxml, nType = elem.nodeType; // don't get/set attributes on text, comment and attribute nodes if ( !elem || nType === 3 || nType === 8 || nType === 2 ) { return; } if ( pass && name in __kivy__jQuery.attrFn ) { return __kivy__jQuery( elem )[ name ]( value ); } // Fallback to prop when attributes are not supported if ( typeof elem.getAttribute === "undefined" ) { return __kivy__jQuery.prop( elem, name, value ); } notxml = nType !== 1 || !__kivy__jQuery.isXMLDoc( elem ); // All attributes are lowercase // Grab necessary hook if one is defined if ( notxml ) { name = name.toLowerCase(); hooks = __kivy__jQuery.attrHooks[ name ] || ( rboolean.test( name ) ? boolHook : nodeHook ); } if ( value !== undefined ) { if ( value === null ) { __kivy__jQuery.removeAttr( elem, name ); return; } else if ( hooks && "set" in hooks && notxml && (ret = hooks.set( elem, value, name )) !== undefined ) { return ret; } else { elem.setAttribute( name, "" + value ); return value; } } else if ( hooks && "get" in hooks && notxml && (ret = hooks.get( elem, name )) !== null ) { return ret; } else { ret = elem.getAttribute( name ); // Non-existent attributes return null, we normalize to undefined return ret === null ? undefined : ret; } }, removeAttr: function( elem, value ) { var propName, attrNames, name, l, i = 0; if ( value && elem.nodeType === 1 ) { attrNames = value.toLowerCase().split( rspace ); l = attrNames.length; for ( ; i < l; i++ ) { name = attrNames[ i ]; if ( name ) { propName = __kivy__jQuery.propFix[ name ] || name; // See #9699 for explanation of this approach (setting first, then removal) __kivy__jQuery.attr( elem, name, "" ); elem.removeAttribute( getSetAttribute ? name : propName ); // Set corresponding property to false for boolean attributes if ( rboolean.test( name ) && propName in elem ) { elem[ propName ] = false; } } } } }, attrHooks: { type: { set: function( elem, value ) { // We can't allow the type property to be changed (since it causes problems in IE) if ( rtype.test( elem.nodeName ) && elem.parentNode ) { __kivy__jQuery.error( "type property can't be changed" ); } else if ( !__kivy__jQuery.support.radioValue && value === "radio" && __kivy__jQuery.nodeName(elem, "input") ) { // Setting the type on a radio button after the value resets the value in IE6-9 // Reset value to it's default in case type is set after value // This is for element creation var val = elem.value; elem.setAttribute( "type", value ); if ( val ) { elem.value = val; } return value; } } }, // Use the value property for back compat // Use the nodeHook for button elements in IE6/7 (#1954) value: { get: function( elem, name ) { if ( nodeHook && __kivy__jQuery.nodeName( elem, "button" ) ) { return nodeHook.get( elem, name ); } return name in elem ? elem.value : null; }, set: function( elem, value, name ) { if ( nodeHook && __kivy__jQuery.nodeName( elem, "button" ) ) { return nodeHook.set( elem, value, name ); } // Does not return so that setAttribute is also used elem.value = value; } } }, propFix: { tabindex: "tabIndex", readonly: "readOnly", "for": "htmlFor", "class": "className", maxlength: "maxLength", cellspacing: "cellSpacing", cellpadding: "cellPadding", rowspan: "rowSpan", colspan: "colSpan", usemap: "useMap", frameborder: "frameBorder", contenteditable: "contentEditable" }, prop: function( elem, name, value ) { var ret, hooks, notxml, nType = elem.nodeType; // don't get/set properties on text, comment and attribute nodes if ( !elem || nType === 3 || nType === 8 || nType === 2 ) { return; } notxml = nType !== 1 || !__kivy__jQuery.isXMLDoc( elem ); if ( notxml ) { // Fix name and attach hooks name = __kivy__jQuery.propFix[ name ] || name; hooks = __kivy__jQuery.propHooks[ name ]; } if ( value !== undefined ) { if ( hooks && "set" in hooks && (ret = hooks.set( elem, value, name )) !== undefined ) { return ret; } else { return ( elem[ name ] = value ); } } else { if ( hooks && "get" in hooks && (ret = hooks.get( elem, name )) !== null ) { return ret; } else { return elem[ name ]; } } }, propHooks: { tabIndex: { get: function( elem ) { // elem.tabIndex doesn't always return the correct value when it hasn't been explicitly set // http://fluidproject.org/blog/2008/01/09/getting-setting-and-removing-tabindex-values-with-javascript/ var attributeNode = elem.getAttributeNode("tabindex"); return attributeNode && attributeNode.specified ? parseInt( attributeNode.value, 10 ) : rfocusable.test( elem.nodeName ) || rclickable.test( elem.nodeName ) && elem.href ? 0 : undefined; } } } }); // Add the tabIndex propHook to attrHooks for back-compat (different case is intentional) __kivy__jQuery.attrHooks.tabindex = __kivy__jQuery.propHooks.tabIndex; // Hook for boolean attributes boolHook = { get: function( elem, name ) { // Align boolean attributes with corresponding properties // Fall back to attribute presence where some booleans are not supported var attrNode, property = __kivy__jQuery.prop( elem, name ); return property === true || typeof property !== "boolean" && ( attrNode = elem.getAttributeNode(name) ) && attrNode.nodeValue !== false ? name.toLowerCase() : undefined; }, set: function( elem, value, name ) { var propName; if ( value === false ) { // Remove boolean attributes when set to false __kivy__jQuery.removeAttr( elem, name ); } else { // value is true since we know at this point it's type boolean and not false // Set boolean attributes to the same name and set the DOM property propName = __kivy__jQuery.propFix[ name ] || name; if ( propName in elem ) { // Only set the IDL specifically if it already exists on the element elem[ propName ] = true; } elem.setAttribute( name, name.toLowerCase() ); } return name; } }; // IE6/7 do not support getting/setting some attributes with get/setAttribute if ( !getSetAttribute ) { fixSpecified = { name: true, id: true }; // Use this for any attribute in IE6/7 // This fixes almost every IE6/7 issue nodeHook = __kivy__jQuery.valHooks.button = { get: function( elem, name ) { var ret; ret = elem.getAttributeNode( name ); return ret && ( fixSpecified[ name ] ? ret.nodeValue !== "" : ret.specified ) ? ret.nodeValue : undefined; }, set: function( elem, value, name ) { // Set the existing or create a new attribute node var ret = elem.getAttributeNode( name ); if ( !ret ) { ret = document.createAttribute( name ); elem.setAttributeNode( ret ); } return ( ret.nodeValue = value + "" ); } }; // Apply the nodeHook to tabindex __kivy__jQuery.attrHooks.tabindex.set = nodeHook.set; // Set width and height to auto instead of 0 on empty string( Bug #8150 ) // This is for removals __kivy__jQuery.each([ "width", "height" ], function( i, name ) { __kivy__jQuery.attrHooks[ name ] = __kivy__jQuery.extend( __kivy__jQuery.attrHooks[ name ], { set: function( elem, value ) { if ( value === "" ) { elem.setAttribute( name, "auto" ); return value; } } }); }); // Set contenteditable to false on removals(#10429) // Setting to empty string throws an error as an invalid value __kivy__jQuery.attrHooks.contenteditable = { get: nodeHook.get, set: function( elem, value, name ) { if ( value === "" ) { value = "false"; } nodeHook.set( elem, value, name ); } }; } // Some attributes require a special call on IE if ( !__kivy__jQuery.support.hrefNormalized ) { __kivy__jQuery.each([ "href", "src", "width", "height" ], function( i, name ) { __kivy__jQuery.attrHooks[ name ] = __kivy__jQuery.extend( __kivy__jQuery.attrHooks[ name ], { get: function( elem ) { var ret = elem.getAttribute( name, 2 ); return ret === null ? undefined : ret; } }); }); } if ( !__kivy__jQuery.support.style ) { __kivy__jQuery.attrHooks.style = { get: function( elem ) { // Return undefined in the case of empty string // Normalize to lowercase since IE uppercases css property names return elem.style.cssText.toLowerCase() || undefined; }, set: function( elem, value ) { return ( elem.style.cssText = "" + value ); } }; } // Safari mis-reports the default selected property of an option // Accessing the parent's selectedIndex property fixes it if ( !__kivy__jQuery.support.optSelected ) { __kivy__jQuery.propHooks.selected = __kivy__jQuery.extend( __kivy__jQuery.propHooks.selected, { get: function( elem ) { var parent = elem.parentNode; if ( parent ) { parent.selectedIndex; // Make sure that it also works with optgroups, see #5701 if ( parent.parentNode ) { parent.parentNode.selectedIndex; } } return null; } }); } // IE6/7 call enctype encoding if ( !__kivy__jQuery.support.enctype ) { __kivy__jQuery.propFix.enctype = "encoding"; } // Radios and checkboxes getter/setter if ( !__kivy__jQuery.support.checkOn ) { __kivy__jQuery.each([ "radio", "checkbox" ], function() { __kivy__jQuery.valHooks[ this ] = { get: function( elem ) { // Handle the case where in Webkit "" is returned instead of "on" if a value isn't specified return elem.getAttribute("value") === null ? "on" : elem.value; } }; }); } __kivy__jQuery.each([ "radio", "checkbox" ], function() { __kivy__jQuery.valHooks[ this ] = __kivy__jQuery.extend( __kivy__jQuery.valHooks[ this ], { set: function( elem, value ) { if ( __kivy__jQuery.isArray( value ) ) { return ( elem.checked = __kivy__jQuery.inArray( __kivy__jQuery(elem).val(), value ) >= 0 ); } } }); }); var rformElems = /^(?:textarea|input|select)$/i, rtypenamespace = /^([^\.]*)?(?:\.(.+))?$/, rhoverHack = /\bhover(\.\S+)?\b/, rkeyEvent = /^key/, rmouseEvent = /^(?:mouse|contextmenu)|click/, rfocusMorph = /^(?:focusinfocus|focusoutblur)$/, rquickIs = /^(\w*)(?:#([\w\-]+))?(?:\.([\w\-]+))?$/, quickParse = function( selector ) { var quick = rquickIs.exec( selector ); if ( quick ) { // 0 1 2 3 // [ _, tag, id, class ] quick[1] = ( quick[1] || "" ).toLowerCase(); quick[3] = quick[3] && new RegExp( "(?:^|\\s)" + quick[3] + "(?:\\s|$)" ); } return quick; }, quickIs = function( elem, m ) { var attrs = elem.attributes || {}; return ( (!m[1] || elem.nodeName.toLowerCase() === m[1]) && (!m[2] || (attrs.id || {}).value === m[2]) && (!m[3] || m[3].test( (attrs[ "class" ] || {}).value )) ); }, hoverHack = function( events ) { return __kivy__jQuery.event.special.hover ? events : events.replace( rhoverHack, "mouseenter$1 mouseleave$1" ); }; /* * Helper functions for managing events -- not part of the public interface. * Props to Dean Edwards' addEvent library for many of the ideas. */ __kivy__jQuery.event = { add: function( elem, types, handler, data, selector ) { var elemData, eventHandle, events, t, tns, type, namespaces, handleObj, handleObjIn, quick, handlers, special; // Don't attach events to noData or text/comment nodes (allow plain objects tho) if ( elem.nodeType === 3 || elem.nodeType === 8 || !types || !handler || !(elemData = __kivy__jQuery._data( elem )) ) { return; } // Caller can pass in an object of custom data in lieu of the handler if ( handler.handler ) { handleObjIn = handler; handler = handleObjIn.handler; } // Make sure that the handler has a unique ID, used to find/remove it later if ( !handler.guid ) { handler.guid = __kivy__jQuery.guid++; } // Init the element's event structure and main handler, if this is the first events = elemData.events; if ( !events ) { elemData.events = events = {}; } eventHandle = elemData.handle; if ( !eventHandle ) { elemData.handle = eventHandle = function( e ) { // Discard the second event of a __kivy__jQuery.event.trigger() and // when an event is called after a page has unloaded return typeof __kivy__jQuery !== "undefined" && (!e || __kivy__jQuery.event.triggered !== e.type) ? __kivy__jQuery.event.dispatch.apply( eventHandle.elem, arguments ) : undefined; }; // Add elem as a property of the handle fn to prevent a memory leak with IE non-native events eventHandle.elem = elem; } // Handle multiple events separated by a space // __kivy__jQuery(...).bind("mouseover mouseout", fn); types = __kivy__jQuery.trim( hoverHack(types) ).split( " " ); for ( t = 0; t < types.length; t++ ) { tns = rtypenamespace.exec( types[t] ) || []; type = tns[1]; namespaces = ( tns[2] || "" ).split( "." ).sort(); // If event changes its type, use the special event handlers for the changed type special = __kivy__jQuery.event.special[ type ] || {}; // If selector defined, determine special event api type, otherwise given type type = ( selector ? special.delegateType : special.bindType ) || type; // Update special based on newly reset type special = __kivy__jQuery.event.special[ type ] || {}; // handleObj is passed to all event handlers handleObj = __kivy__jQuery.extend({ type: type, origType: tns[1], data: data, handler: handler, guid: handler.guid, selector: selector, quick: quickParse( selector ), namespace: namespaces.join(".") }, handleObjIn ); // Init the event handler queue if we're the first handlers = events[ type ]; if ( !handlers ) { handlers = events[ type ] = []; handlers.delegateCount = 0; // Only use addEventListener/attachEvent if the special events handler returns false if ( !special.setup || special.setup.call( elem, data, namespaces, eventHandle ) === false ) { // Bind the global event handler to the element if ( elem.addEventListener ) { elem.addEventListener( type, eventHandle, false ); } else if ( elem.attachEvent ) { elem.attachEvent( "on" + type, eventHandle ); } } } if ( special.add ) { special.add.call( elem, handleObj ); if ( !handleObj.handler.guid ) { handleObj.handler.guid = handler.guid; } } // Add to the element's handler list, delegates in front if ( selector ) { handlers.splice( handlers.delegateCount++, 0, handleObj ); } else { handlers.push( handleObj ); } // Keep track of which events have ever been used, for event optimization __kivy__jQuery.event.global[ type ] = true; } // Nullify elem to prevent memory leaks in IE elem = null; }, global: {}, // Detach an event or set of events from an element remove: function( elem, types, handler, selector, mappedTypes ) { var elemData = __kivy__jQuery.hasData( elem ) && __kivy__jQuery._data( elem ), t, tns, type, origType, namespaces, origCount, j, events, special, handle, eventType, handleObj; if ( !elemData || !(events = elemData.events) ) { return; } // Once for each type.namespace in types; type may be omitted types = __kivy__jQuery.trim( hoverHack( types || "" ) ).split(" "); for ( t = 0; t < types.length; t++ ) { tns = rtypenamespace.exec( types[t] ) || []; type = origType = tns[1]; namespaces = tns[2]; // Unbind all events (on this namespace, if provided) for the element if ( !type ) { for ( type in events ) { __kivy__jQuery.event.remove( elem, type + types[ t ], handler, selector, true ); } continue; } special = __kivy__jQuery.event.special[ type ] || {}; type = ( selector? special.delegateType : special.bindType ) || type; eventType = events[ type ] || []; origCount = eventType.length; namespaces = namespaces ? new RegExp("(^|\\.)" + namespaces.split(".").sort().join("\\.(?:.*\\.)?") + "(\\.|$)") : null; // Remove matching events for ( j = 0; j < eventType.length; j++ ) { handleObj = eventType[ j ]; if ( ( mappedTypes || origType === handleObj.origType ) && ( !handler || handler.guid === handleObj.guid ) && ( !namespaces || namespaces.test( handleObj.namespace ) ) && ( !selector || selector === handleObj.selector || selector === "**" && handleObj.selector ) ) { eventType.splice( j--, 1 ); if ( handleObj.selector ) { eventType.delegateCount--; } if ( special.remove ) { special.remove.call( elem, handleObj ); } } } // Remove generic event handler if we removed something and no more handlers exist // (avoids potential for endless recursion during removal of special event handlers) if ( eventType.length === 0 && origCount !== eventType.length ) { if ( !special.teardown || special.teardown.call( elem, namespaces ) === false ) { __kivy__jQuery.removeEvent( elem, type, elemData.handle ); } delete events[ type ]; } } // Remove the expando if it's no longer used if ( __kivy__jQuery.isEmptyObject( events ) ) { handle = elemData.handle; if ( handle ) { handle.elem = null; } // removeData also checks for emptiness and clears the expando if empty // so use it instead of delete __kivy__jQuery.removeData( elem, [ "events", "handle" ], true ); } }, // Events that are safe to short-circuit if no handlers are attached. // Native DOM events should not be added, they may have inline handlers. customEvent: { "getData": true, "setData": true, "changeData": true }, trigger: function( event, data, elem, onlyHandlers ) { // Don't do events on text and comment nodes if ( elem && (elem.nodeType === 3 || elem.nodeType === 8) ) { return; } // Event object or event type var type = event.type || event, namespaces = [], cache, exclusive, i, cur, old, ontype, special, handle, eventPath, bubbleType; // focus/blur morphs to focusin/out; ensure we're not firing them right now if ( rfocusMorph.test( type + __kivy__jQuery.event.triggered ) ) { return; } if ( type.indexOf( "!" ) >= 0 ) { // Exclusive events trigger only for the exact event (no namespaces) type = type.slice(0, -1); exclusive = true; } if ( type.indexOf( "." ) >= 0 ) { // Namespaced trigger; create a regexp to match event type in handle() namespaces = type.split("."); type = namespaces.shift(); namespaces.sort(); } if ( (!elem || __kivy__jQuery.event.customEvent[ type ]) && !__kivy__jQuery.event.global[ type ] ) { // No __kivy__jQuery handlers for this event type, and it can't have inline handlers return; } // Caller can pass in an Event, Object, or just an event type string event = typeof event === "object" ? // __kivy__jQuery.Event object event[ __kivy__jQuery.expando ] ? event : // Object literal new __kivy__jQuery.Event( type, event ) : // Just the event type (string) new __kivy__jQuery.Event( type ); event.type = type; event.isTrigger = true; event.exclusive = exclusive; event.namespace = namespaces.join( "." ); event.namespace_re = event.namespace? new RegExp("(^|\\.)" + namespaces.join("\\.(?:.*\\.)?") + "(\\.|$)") : null; ontype = type.indexOf( ":" ) < 0 ? "on" + type : ""; // Handle a global trigger if ( !elem ) { // TODO: Stop taunting the data cache; remove global events and always attach to document cache = __kivy__jQuery.cache; for ( i in cache ) { if ( cache[ i ].events && cache[ i ].events[ type ] ) { __kivy__jQuery.event.trigger( event, data, cache[ i ].handle.elem, true ); } } return; } // Clean up the event in case it is being reused event.result = undefined; if ( !event.target ) { event.target = elem; } // Clone any incoming data and prepend the event, creating the handler arg list data = data != null ? __kivy__jQuery.makeArray( data ) : []; data.unshift( event ); // Allow special events to draw outside the lines special = __kivy__jQuery.event.special[ type ] || {}; if ( special.trigger && special.trigger.apply( elem, data ) === false ) { return; } // Determine event propagation path in advance, per W3C events spec (#9951) // Bubble up to document, then to window; watch for a global ownerDocument var (#9724) eventPath = [[ elem, special.bindType || type ]]; if ( !onlyHandlers && !special.noBubble && !__kivy__jQuery.isWindow( elem ) ) { bubbleType = special.delegateType || type; cur = rfocusMorph.test( bubbleType + type ) ? elem : elem.parentNode; old = null; for ( ; cur; cur = cur.parentNode ) { eventPath.push([ cur, bubbleType ]); old = cur; } // Only add window if we got to document (e.g., not plain obj or detached DOM) if ( old && old === elem.ownerDocument ) { eventPath.push([ old.defaultView || old.parentWindow || window, bubbleType ]); } } // Fire handlers on the event path for ( i = 0; i < eventPath.length && !event.isPropagationStopped(); i++ ) { cur = eventPath[i][0]; event.type = eventPath[i][1]; handle = ( __kivy__jQuery._data( cur, "events" ) || {} )[ event.type ] && __kivy__jQuery._data( cur, "handle" ); if ( handle ) { handle.apply( cur, data ); } // Note that this is a bare JS function and not a __kivy__jQuery handler handle = ontype && cur[ ontype ]; if ( handle && __kivy__jQuery.acceptData( cur ) && handle.apply( cur, data ) === false ) { event.preventDefault(); } } event.type = type; // If nobody prevented the default action, do it now if ( !onlyHandlers && !event.isDefaultPrevented() ) { if ( (!special._default || special._default.apply( elem.ownerDocument, data ) === false) && !(type === "click" && __kivy__jQuery.nodeName( elem, "a" )) && __kivy__jQuery.acceptData( elem ) ) { // Call a native DOM method on the target with the same name name as the event. // Can't use an .isFunction() check here because IE6/7 fails that test. // Don't do default actions on window, that's where global variables be (#6170) // IE<9 dies on focus/blur to hidden element (#1486) if ( ontype && elem[ type ] && ((type !== "focus" && type !== "blur") || event.target.offsetWidth !== 0) && !__kivy__jQuery.isWindow( elem ) ) { // Don't re-trigger an onFOO event when we call its FOO() method old = elem[ ontype ]; if ( old ) { elem[ ontype ] = null; } // Prevent re-triggering of the same event, since we already bubbled it above __kivy__jQuery.event.triggered = type; elem[ type ](); __kivy__jQuery.event.triggered = undefined; if ( old ) { elem[ ontype ] = old; } } } } return event.result; }, dispatch: function( event ) { // Make a writable __kivy__jQuery.Event from the native event object event = __kivy__jQuery.event.fix( event || window.event ); var handlers = ( (__kivy__jQuery._data( this, "events" ) || {} )[ event.type ] || []), delegateCount = handlers.delegateCount, args = [].slice.call( arguments, 0 ), run_all = !event.exclusive && !event.namespace, handlerQueue = [], i, j, cur, jqcur, ret, selMatch, matched, matches, handleObj, sel, related; // Use the fix-ed __kivy__jQuery.Event rather than the (read-only) native event args[0] = event; event.delegateTarget = this; // Determine handlers that should run if there are delegated events // Avoid disabled elements in IE (#6911) and non-left-click bubbling in Firefox (#3861) if ( delegateCount && !event.target.disabled && !(event.button && event.type === "click") ) { // Pregenerate a single __kivy__jQuery object for reuse with .is() jqcur = __kivy__jQuery(this); jqcur.context = this.ownerDocument || this; for ( cur = event.target; cur != this; cur = cur.parentNode || this ) { selMatch = {}; matches = []; jqcur[0] = cur; for ( i = 0; i < delegateCount; i++ ) { handleObj = handlers[ i ]; sel = handleObj.selector; if ( selMatch[ sel ] === undefined ) { selMatch[ sel ] = ( handleObj.quick ? quickIs( cur, handleObj.quick ) : jqcur.is( sel ) ); } if ( selMatch[ sel ] ) { matches.push( handleObj ); } } if ( matches.length ) { handlerQueue.push({ elem: cur, matches: matches }); } } } // Add the remaining (directly-bound) handlers if ( handlers.length > delegateCount ) { handlerQueue.push({ elem: this, matches: handlers.slice( delegateCount ) }); } // Run delegates first; they may want to stop propagation beneath us for ( i = 0; i < handlerQueue.length && !event.isPropagationStopped(); i++ ) { matched = handlerQueue[ i ]; event.currentTarget = matched.elem; for ( j = 0; j < matched.matches.length && !event.isImmediatePropagationStopped(); j++ ) { handleObj = matched.matches[ j ]; // Triggered event must either 1) be non-exclusive and have no namespace, or // 2) have namespace(s) a subset or equal to those in the bound event (both can have no namespace). if ( run_all || (!event.namespace && !handleObj.namespace) || event.namespace_re && event.namespace_re.test( handleObj.namespace ) ) { event.data = handleObj.data; event.handleObj = handleObj; ret = ( (__kivy__jQuery.event.special[ handleObj.origType ] || {}).handle || handleObj.handler ) .apply( matched.elem, args ); if ( ret !== undefined ) { event.result = ret; if ( ret === false ) { event.preventDefault(); event.stopPropagation(); } } } } } return event.result; }, // Includes some event props shared by KeyEvent and MouseEvent // *** attrChange attrName relatedNode srcElement are not normalized, non-W3C, deprecated, will be removed in 1.8 *** props: "attrChange attrName relatedNode srcElement altKey bubbles cancelable ctrlKey currentTarget eventPhase metaKey relatedTarget shiftKey target timeStamp view which".split(" "), fixHooks: {}, keyHooks: { props: "char charCode key keyCode".split(" "), filter: function( event, original ) { // Add which for key events if ( event.which == null ) { event.which = original.charCode != null ? original.charCode : original.keyCode; } return event; } }, mouseHooks: { props: "button buttons clientX clientY fromElement offsetX offsetY pageX pageY screenX screenY toElement".split(" "), filter: function( event, original ) { var eventDoc, doc, body, button = original.button, fromElement = original.fromElement; // Calculate pageX/Y if missing and clientX/Y available if ( event.pageX == null && original.clientX != null ) { eventDoc = event.target.ownerDocument || document; doc = eventDoc.documentElement; body = eventDoc.body; event.pageX = original.clientX + ( doc && doc.scrollLeft || body && body.scrollLeft || 0 ) - ( doc && doc.clientLeft || body && body.clientLeft || 0 ); event.pageY = original.clientY + ( doc && doc.scrollTop || body && body.scrollTop || 0 ) - ( doc && doc.clientTop || body && body.clientTop || 0 ); } // Add relatedTarget, if necessary if ( !event.relatedTarget && fromElement ) { event.relatedTarget = fromElement === event.target ? original.toElement : fromElement; } // Add which for click: 1 === left; 2 === middle; 3 === right // Note: button is not normalized, so don't use it if ( !event.which && button !== undefined ) { event.which = ( button & 1 ? 1 : ( button & 2 ? 3 : ( button & 4 ? 2 : 0 ) ) ); } return event; } }, fix: function( event ) { if ( event[ __kivy__jQuery.expando ] ) { return event; } // Create a writable copy of the event object and normalize some properties var i, prop, originalEvent = event, fixHook = __kivy__jQuery.event.fixHooks[ event.type ] || {}, copy = fixHook.props ? this.props.concat( fixHook.props ) : this.props; event = __kivy__jQuery.Event( originalEvent ); for ( i = copy.length; i; ) { prop = copy[ --i ]; event[ prop ] = originalEvent[ prop ]; } // Fix target property, if necessary (#1925, IE 6/7/8 & Safari2) if ( !event.target ) { event.target = originalEvent.srcElement || document; } // Target should not be a text node (#504, Safari) if ( event.target.nodeType === 3 ) { event.target = event.target.parentNode; } // For mouse/key events; add metaKey if it's not there (#3368, IE6/7/8) if ( event.metaKey === undefined ) { event.metaKey = event.ctrlKey; } return fixHook.filter? fixHook.filter( event, originalEvent ) : event; }, special: { ready: { // Make sure the ready event is setup setup: __kivy__jQuery.bindReady }, load: { // Prevent triggered image.load events from bubbling to window.load noBubble: true }, focus: { delegateType: "focusin" }, blur: { delegateType: "focusout" }, beforeunload: { setup: function( data, namespaces, eventHandle ) { // We only want to do this special case on windows if ( __kivy__jQuery.isWindow( this ) ) { this.onbeforeunload = eventHandle; } }, teardown: function( namespaces, eventHandle ) { if ( this.onbeforeunload === eventHandle ) { this.onbeforeunload = null; } } } }, simulate: function( type, elem, event, bubble ) { // Piggyback on a donor event to simulate a different one. // Fake originalEvent to avoid donor's stopPropagation, but if the // simulated event prevents default then we do the same on the donor. var e = __kivy__jQuery.extend( new __kivy__jQuery.Event(), event, { type: type, isSimulated: true, originalEvent: {} } ); if ( bubble ) { __kivy__jQuery.event.trigger( e, null, elem ); } else { __kivy__jQuery.event.dispatch.call( elem, e ); } if ( e.isDefaultPrevented() ) { event.preventDefault(); } } }; // Some plugins are using, but it's undocumented/deprecated and will be removed. // The 1.7 special event interface should provide all the hooks needed now. __kivy__jQuery.event.handle = __kivy__jQuery.event.dispatch; __kivy__jQuery.removeEvent = document.removeEventListener ? function( elem, type, handle ) { if ( elem.removeEventListener ) { elem.removeEventListener( type, handle, false ); } } : function( elem, type, handle ) { if ( elem.detachEvent ) { elem.detachEvent( "on" + type, handle ); } }; __kivy__jQuery.Event = function( src, props ) { // Allow instantiation without the 'new' keyword if ( !(this instanceof __kivy__jQuery.Event) ) { return new __kivy__jQuery.Event( src, props ); } // Event object if ( src && src.type ) { this.originalEvent = src; this.type = src.type; // Events bubbling up the document may have been marked as prevented // by a handler lower down the tree; reflect the correct value. this.isDefaultPrevented = ( src.defaultPrevented || src.returnValue === false || src.getPreventDefault && src.getPreventDefault() ) ? returnTrue : returnFalse; // Event type } else { this.type = src; } // Put explicitly provided properties onto the event object if ( props ) { __kivy__jQuery.extend( this, props ); } // Create a timestamp if incoming event doesn't have one this.timeStamp = src && src.timeStamp || __kivy__jQuery.now(); // Mark it as fixed this[ __kivy__jQuery.expando ] = true; }; function returnFalse() { return false; } function returnTrue() { return true; } // __kivy__jQuery.Event is based on DOM3 Events as specified by the ECMAScript Language Binding // http://www.w3.org/TR/2003/WD-DOM-Level-3-Events-20030331/ecma-script-binding.html __kivy__jQuery.Event.prototype = { preventDefault: function() { this.isDefaultPrevented = returnTrue; var e = this.originalEvent; if ( !e ) { return; } // if preventDefault exists run it on the original event if ( e.preventDefault ) { e.preventDefault(); // otherwise set the returnValue property of the original event to false (IE) } else { e.returnValue = false; } }, stopPropagation: function() { this.isPropagationStopped = returnTrue; var e = this.originalEvent; if ( !e ) { return; } // if stopPropagation exists run it on the original event if ( e.stopPropagation ) { e.stopPropagation(); } // otherwise set the cancelBubble property of the original event to true (IE) e.cancelBubble = true; }, stopImmediatePropagation: function() { this.isImmediatePropagationStopped = returnTrue; this.stopPropagation(); }, isDefaultPrevented: returnFalse, isPropagationStopped: returnFalse, isImmediatePropagationStopped: returnFalse }; // Create mouseenter/leave events using mouseover/out and event-time checks __kivy__jQuery.each({ mouseenter: "mouseover", mouseleave: "mouseout" }, function( orig, fix ) { __kivy__jQuery.event.special[ orig ] = { delegateType: fix, bindType: fix, handle: function( event ) { var target = this, related = event.relatedTarget, handleObj = event.handleObj, selector = handleObj.selector, ret; // For mousenter/leave call the handler if related is outside the target. // NB: No relatedTarget if the mouse left/entered the browser window if ( !related || (related !== target && !__kivy__jQuery.contains( target, related )) ) { event.type = handleObj.origType; ret = handleObj.handler.apply( this, arguments ); event.type = fix; } return ret; } }; }); // IE submit delegation if ( !__kivy__jQuery.support.submitBubbles ) { __kivy__jQuery.event.special.submit = { setup: function() { // Only need this for delegated form submit events if ( __kivy__jQuery.nodeName( this, "form" ) ) { return false; } // Lazy-add a submit handler when a descendant form may potentially be submitted __kivy__jQuery.event.add( this, "click._submit keypress._submit", function( e ) { // Node name check avoids a VML-related crash in IE (#9807) var elem = e.target, form = __kivy__jQuery.nodeName( elem, "input" ) || __kivy__jQuery.nodeName( elem, "button" ) ? elem.form : undefined; if ( form && !form._submit_attached ) { __kivy__jQuery.event.add( form, "submit._submit", function( event ) { // If form was submitted by the user, bubble the event up the tree if ( this.parentNode && !event.isTrigger ) { __kivy__jQuery.event.simulate( "submit", this.parentNode, event, true ); } }); form._submit_attached = true; } }); // return undefined since we don't need an event listener }, teardown: function() { // Only need this for delegated form submit events if ( __kivy__jQuery.nodeName( this, "form" ) ) { return false; } // Remove delegated handlers; cleanData eventually reaps submit handlers attached above __kivy__jQuery.event.remove( this, "._submit" ); } }; } // IE change delegation and checkbox/radio fix if ( !__kivy__jQuery.support.changeBubbles ) { __kivy__jQuery.event.special.change = { setup: function() { if ( rformElems.test( this.nodeName ) ) { // IE doesn't fire change on a check/radio until blur; trigger it on click // after a propertychange. Eat the blur-change in special.change.handle. // This still fires onchange a second time for check/radio after blur. if ( this.type === "checkbox" || this.type === "radio" ) { __kivy__jQuery.event.add( this, "propertychange._change", function( event ) { if ( event.originalEvent.propertyName === "checked" ) { this._just_changed = true; } }); __kivy__jQuery.event.add( this, "click._change", function( event ) { if ( this._just_changed && !event.isTrigger ) { this._just_changed = false; __kivy__jQuery.event.simulate( "change", this, event, true ); } }); } return false; } // Delegated event; lazy-add a change handler on descendant inputs __kivy__jQuery.event.add( this, "beforeactivate._change", function( e ) { var elem = e.target; if ( rformElems.test( elem.nodeName ) && !elem._change_attached ) { __kivy__jQuery.event.add( elem, "change._change", function( event ) { if ( this.parentNode && !event.isSimulated && !event.isTrigger ) { __kivy__jQuery.event.simulate( "change", this.parentNode, event, true ); } }); elem._change_attached = true; } }); }, handle: function( event ) { var elem = event.target; // Swallow native change events from checkbox/radio, we already triggered them above if ( this !== elem || event.isSimulated || event.isTrigger || (elem.type !== "radio" && elem.type !== "checkbox") ) { return event.handleObj.handler.apply( this, arguments ); } }, teardown: function() { __kivy__jQuery.event.remove( this, "._change" ); return rformElems.test( this.nodeName ); } }; } // Create "bubbling" focus and blur events if ( !__kivy__jQuery.support.focusinBubbles ) { __kivy__jQuery.each({ focus: "focusin", blur: "focusout" }, function( orig, fix ) { // Attach a single capturing handler while someone wants focusin/focusout var attaches = 0, handler = function( event ) { __kivy__jQuery.event.simulate( fix, event.target, __kivy__jQuery.event.fix( event ), true ); }; __kivy__jQuery.event.special[ fix ] = { setup: function() { if ( attaches++ === 0 ) { document.addEventListener( orig, handler, true ); } }, teardown: function() { if ( --attaches === 0 ) { document.removeEventListener( orig, handler, true ); } } }; }); } __kivy__jQuery.fn.extend({ on: function( types, selector, data, fn, /*INTERNAL*/ one ) { var origFn, type; // Types can be a map of types/handlers if ( typeof types === "object" ) { // ( types-Object, selector, data ) if ( typeof selector !== "string" ) { // ( types-Object, data ) data = selector; selector = undefined; } for ( type in types ) { this.on( type, selector, data, types[ type ], one ); } return this; } if ( data == null && fn == null ) { // ( types, fn ) fn = selector; data = selector = undefined; } else if ( fn == null ) { if ( typeof selector === "string" ) { // ( types, selector, fn ) fn = data; data = undefined; } else { // ( types, data, fn ) fn = data; data = selector; selector = undefined; } } if ( fn === false ) { fn = returnFalse; } else if ( !fn ) { return this; } if ( one === 1 ) { origFn = fn; fn = function( event ) { // Can use an empty set, since event contains the info __kivy__jQuery().off( event ); return origFn.apply( this, arguments ); }; // Use same guid so caller can remove using origFn fn.guid = origFn.guid || ( origFn.guid = __kivy__jQuery.guid++ ); } return this.each( function() { __kivy__jQuery.event.add( this, types, fn, data, selector ); }); }, one: function( types, selector, data, fn ) { return this.on.call( this, types, selector, data, fn, 1 ); }, off: function( types, selector, fn ) { if ( types && types.preventDefault && types.handleObj ) { // ( event ) dispatched __kivy__jQuery.Event var handleObj = types.handleObj; __kivy__jQuery( types.delegateTarget ).off( handleObj.namespace? handleObj.type + "." + handleObj.namespace : handleObj.type, handleObj.selector, handleObj.handler ); return this; } if ( typeof types === "object" ) { // ( types-object [, selector] ) for ( var type in types ) { this.off( type, selector, types[ type ] ); } return this; } if ( selector === false || typeof selector === "function" ) { // ( types [, fn] ) fn = selector; selector = undefined; } if ( fn === false ) { fn = returnFalse; } return this.each(function() { __kivy__jQuery.event.remove( this, types, fn, selector ); }); }, bind: function( types, data, fn ) { return this.on( types, null, data, fn ); }, unbind: function( types, fn ) { return this.off( types, null, fn ); }, live: function( types, data, fn ) { __kivy__jQuery( this.context ).on( types, this.selector, data, fn ); return this; }, die: function( types, fn ) { __kivy__jQuery( this.context ).off( types, this.selector || "**", fn ); return this; }, delegate: function( selector, types, data, fn ) { return this.on( types, selector, data, fn ); }, undelegate: function( selector, types, fn ) { // ( namespace ) or ( selector, types [, fn] ) return arguments.length == 1? this.off( selector, "**" ) : this.off( types, selector, fn ); }, trigger: function( type, data ) { return this.each(function() { __kivy__jQuery.event.trigger( type, data, this ); }); }, triggerHandler: function( type, data ) { if ( this[0] ) { return __kivy__jQuery.event.trigger( type, data, this[0], true ); } }, toggle: function( fn ) { // Save reference to arguments for access in closure var args = arguments, guid = fn.guid || __kivy__jQuery.guid++, i = 0, toggler = function( event ) { // Figure out which function to execute var lastToggle = ( __kivy__jQuery._data( this, "lastToggle" + fn.guid ) || 0 ) % i; __kivy__jQuery._data( this, "lastToggle" + fn.guid, lastToggle + 1 ); // Make sure that clicks stop event.preventDefault(); // and execute the function return args[ lastToggle ].apply( this, arguments ) || false; }; // link all the functions, so any of them can unbind this click handler toggler.guid = guid; while ( i < args.length ) { args[ i++ ].guid = guid; } return this.click( toggler ); }, hover: function( fnOver, fnOut ) { return this.mouseenter( fnOver ).mouseleave( fnOut || fnOver ); } }); __kivy__jQuery.each( ("blur focus focusin focusout load resize scroll unload click dblclick " + "mousedown mouseup mousemove mouseover mouseout mouseenter mouseleave " + "change select submit keydown keypress keyup error contextmenu").split(" "), function( i, name ) { // Handle event binding __kivy__jQuery.fn[ name ] = function( data, fn ) { if ( fn == null ) { fn = data; data = null; } return arguments.length > 0 ? this.on( name, null, data, fn ) : this.trigger( name ); }; if ( __kivy__jQuery.attrFn ) { __kivy__jQuery.attrFn[ name ] = true; } if ( rkeyEvent.test( name ) ) { __kivy__jQuery.event.fixHooks[ name ] = __kivy__jQuery.event.keyHooks; } if ( rmouseEvent.test( name ) ) { __kivy__jQuery.event.fixHooks[ name ] = __kivy__jQuery.event.mouseHooks; } }); /*! * Sizzle CSS Selector Engine * Copyright 2011, The Dojo Foundation * Released under the MIT, BSD, and GPL Licenses. * More information: http://sizzlejs.com/ */ (function(){ var chunker = /((?:\((?:\([^()]+\)|[^()]+)+\)|\[(?:\[[^\[\]]*\]|['"][^'"]*['"]|[^\[\]'"]+)+\]|\\.|[^ >+~,(\[\\]+)+|[>+~])(\s*,\s*)?((?:.|\r|\n)*)/g, expando = "sizcache" + (Math.random() + '').replace('.', ''), done = 0, toString = Object.prototype.toString, hasDuplicate = false, baseHasDuplicate = true, rBackslash = /\\/g, rReturn = /\r\n/g, rNonWord = /\W/; // Here we check if the JavaScript engine is using some sort of // optimization where it does not always call our comparision // function. If that is the case, discard the hasDuplicate value. // Thus far that includes Google Chrome. [0, 0].sort(function() { baseHasDuplicate = false; return 0; }); var Sizzle = function( selector, context, results, seed ) { results = results || []; context = context || document; var origContext = context; if ( context.nodeType !== 1 && context.nodeType !== 9 ) { return []; } if ( !selector || typeof selector !== "string" ) { return results; } var m, set, checkSet, extra, ret, cur, pop, i, prune = true, contextXML = Sizzle.isXML( context ), parts = [], soFar = selector; // Reset the position of the chunker regexp (start from head) do { chunker.exec( "" ); m = chunker.exec( soFar ); if ( m ) { soFar = m[3]; parts.push( m[1] ); if ( m[2] ) { extra = m[3]; break; } } } while ( m ); if ( parts.length > 1 && origPOS.exec( selector ) ) { if ( parts.length === 2 && Expr.relative[ parts[0] ] ) { set = posProcess( parts[0] + parts[1], context, seed ); } else { set = Expr.relative[ parts[0] ] ? [ context ] : Sizzle( parts.shift(), context ); while ( parts.length ) { selector = parts.shift(); if ( Expr.relative[ selector ] ) { selector += parts.shift(); } set = posProcess( selector, set, seed ); } } } else { // Take a shortcut and set the context if the root selector is an ID // (but not if it'll be faster if the inner selector is an ID) if ( !seed && parts.length > 1 && context.nodeType === 9 && !contextXML && Expr.match.ID.test(parts[0]) && !Expr.match.ID.test(parts[parts.length - 1]) ) { ret = Sizzle.find( parts.shift(), context, contextXML ); context = ret.expr ? Sizzle.filter( ret.expr, ret.set )[0] : ret.set[0]; } if ( context ) { ret = seed ? { expr: parts.pop(), set: makeArray(seed) } : Sizzle.find( parts.pop(), parts.length === 1 && (parts[0] === "~" || parts[0] === "+") && context.parentNode ? context.parentNode : context, contextXML ); set = ret.expr ? Sizzle.filter( ret.expr, ret.set ) : ret.set; if ( parts.length > 0 ) { checkSet = makeArray( set ); } else { prune = false; } while ( parts.length ) { cur = parts.pop(); pop = cur; if ( !Expr.relative[ cur ] ) { cur = ""; } else { pop = parts.pop(); } if ( pop == null ) { pop = context; } Expr.relative[ cur ]( checkSet, pop, contextXML ); } } else { checkSet = parts = []; } } if ( !checkSet ) { checkSet = set; } if ( !checkSet ) { Sizzle.error( cur || selector ); } if ( toString.call(checkSet) === "[object Array]" ) { if ( !prune ) { results.push.apply( results, checkSet ); } else if ( context && context.nodeType === 1 ) { for ( i = 0; checkSet[i] != null; i++ ) { if ( checkSet[i] && (checkSet[i] === true || checkSet[i].nodeType === 1 && Sizzle.contains(context, checkSet[i])) ) { results.push( set[i] ); } } } else { for ( i = 0; checkSet[i] != null; i++ ) { if ( checkSet[i] && checkSet[i].nodeType === 1 ) { results.push( set[i] ); } } } } else { makeArray( checkSet, results ); } if ( extra ) { Sizzle( extra, origContext, results, seed ); Sizzle.uniqueSort( results ); } return results; }; Sizzle.uniqueSort = function( results ) { if ( sortOrder ) { hasDuplicate = baseHasDuplicate; results.sort( sortOrder ); if ( hasDuplicate ) { for ( var i = 1; i < results.length; i++ ) { if ( results[i] === results[ i - 1 ] ) { results.splice( i--, 1 ); } } } } return results; }; Sizzle.matches = function( expr, set ) { return Sizzle( expr, null, null, set ); }; Sizzle.matchesSelector = function( node, expr ) { return Sizzle( expr, null, null, [node] ).length > 0; }; Sizzle.find = function( expr, context, isXML ) { var set, i, len, match, type, left; if ( !expr ) { return []; } for ( i = 0, len = Expr.order.length; i < len; i++ ) { type = Expr.order[i]; if ( (match = Expr.leftMatch[ type ].exec( expr )) ) { left = match[1]; match.splice( 1, 1 ); if ( left.substr( left.length - 1 ) !== "\\" ) { match[1] = (match[1] || "").replace( rBackslash, "" ); set = Expr.find[ type ]( match, context, isXML ); if ( set != null ) { expr = expr.replace( Expr.match[ type ], "" ); break; } } } } if ( !set ) { set = typeof context.getElementsByTagName !== "undefined" ? context.getElementsByTagName( "*" ) : []; } return { set: set, expr: expr }; }; Sizzle.filter = function( expr, set, inplace, not ) { var match, anyFound, type, found, item, filter, left, i, pass, old = expr, result = [], curLoop = set, isXMLFilter = set && set[0] && Sizzle.isXML( set[0] ); while ( expr && set.length ) { for ( type in Expr.filter ) { if ( (match = Expr.leftMatch[ type ].exec( expr )) != null && match[2] ) { filter = Expr.filter[ type ]; left = match[1]; anyFound = false; match.splice(1,1); if ( left.substr( left.length - 1 ) === "\\" ) { continue; } if ( curLoop === result ) { result = []; } if ( Expr.preFilter[ type ] ) { match = Expr.preFilter[ type ]( match, curLoop, inplace, result, not, isXMLFilter ); if ( !match ) { anyFound = found = true; } else if ( match === true ) { continue; } } if ( match ) { for ( i = 0; (item = curLoop[i]) != null; i++ ) { if ( item ) { found = filter( item, match, i, curLoop ); pass = not ^ found; if ( inplace && found != null ) { if ( pass ) { anyFound = true; } else { curLoop[i] = false; } } else if ( pass ) { result.push( item ); anyFound = true; } } } } if ( found !== undefined ) { if ( !inplace ) { curLoop = result; } expr = expr.replace( Expr.match[ type ], "" ); if ( !anyFound ) { return []; } break; } } } // Improper expression if ( expr === old ) { if ( anyFound == null ) { Sizzle.error( expr ); } else { break; } } old = expr; } return curLoop; }; Sizzle.error = function( msg ) { throw new Error( "Syntax error, unrecognized expression: " + msg ); }; /** * Utility function for retreiving the text value of an array of DOM nodes * @param {Array|Element} elem */ var getText = Sizzle.getText = function( elem ) { var i, node, nodeType = elem.nodeType, ret = ""; if ( nodeType ) { if ( nodeType === 1 || nodeType === 9 ) { // Use textContent || innerText for elements if ( typeof elem.textContent === 'string' ) { return elem.textContent; } else if ( typeof elem.innerText === 'string' ) { // Replace IE's carriage returns return elem.innerText.replace( rReturn, '' ); } else { // Traverse it's children for ( elem = elem.firstChild; elem; elem = elem.nextSibling) { ret += getText( elem ); } } } else if ( nodeType === 3 || nodeType === 4 ) { return elem.nodeValue; } } else { // If no nodeType, this is expected to be an array for ( i = 0; (node = elem[i]); i++ ) { // Do not traverse comment nodes if ( node.nodeType !== 8 ) { ret += getText( node ); } } } return ret; }; var Expr = Sizzle.selectors = { order: [ "ID", "NAME", "TAG" ], match: { ID: /#((?:[\w\u00c0-\uFFFF\-]|\\.)+)/, CLASS: /\.((?:[\w\u00c0-\uFFFF\-]|\\.)+)/, NAME: /\[name=['"]*((?:[\w\u00c0-\uFFFF\-]|\\.)+)['"]*\]/, ATTR: /\[\s*((?:[\w\u00c0-\uFFFF\-]|\\.)+)\s*(?:(\S?=)\s*(?:(['"])(.*?)\3|(#?(?:[\w\u00c0-\uFFFF\-]|\\.)*)|)|)\s*\]/, TAG: /^((?:[\w\u00c0-\uFFFF\*\-]|\\.)+)/, CHILD: /:(only|nth|last|first)-child(?:\(\s*(even|odd|(?:[+\-]?\d+|(?:[+\-]?\d*)?n\s*(?:[+\-]\s*\d+)?))\s*\))?/, POS: /:(nth|eq|gt|lt|first|last|even|odd)(?:\((\d*)\))?(?=[^\-]|$)/, PSEUDO: /:((?:[\w\u00c0-\uFFFF\-]|\\.)+)(?:\((['"]?)((?:\([^\)]+\)|[^\(\)]*)+)\2\))?/ }, leftMatch: {}, attrMap: { "class": "className", "for": "htmlFor" }, attrHandle: { href: function( elem ) { return elem.getAttribute( "href" ); }, type: function( elem ) { return elem.getAttribute( "type" ); } }, relative: { "+": function(checkSet, part){ var isPartStr = typeof part === "string", isTag = isPartStr && !rNonWord.test( part ), isPartStrNotTag = isPartStr && !isTag; if ( isTag ) { part = part.toLowerCase(); } for ( var i = 0, l = checkSet.length, elem; i < l; i++ ) { if ( (elem = checkSet[i]) ) { while ( (elem = elem.previousSibling) && elem.nodeType !== 1 ) {} checkSet[i] = isPartStrNotTag || elem && elem.nodeName.toLowerCase() === part ? elem || false : elem === part; } } if ( isPartStrNotTag ) { Sizzle.filter( part, checkSet, true ); } }, ">": function( checkSet, part ) { var elem, isPartStr = typeof part === "string", i = 0, l = checkSet.length; if ( isPartStr && !rNonWord.test( part ) ) { part = part.toLowerCase(); for ( ; i < l; i++ ) { elem = checkSet[i]; if ( elem ) { var parent = elem.parentNode; checkSet[i] = parent.nodeName.toLowerCase() === part ? parent : false; } } } else { for ( ; i < l; i++ ) { elem = checkSet[i]; if ( elem ) { checkSet[i] = isPartStr ? elem.parentNode : elem.parentNode === part; } } if ( isPartStr ) { Sizzle.filter( part, checkSet, true ); } } }, "": function(checkSet, part, isXML){ var nodeCheck, doneName = done++, checkFn = dirCheck; if ( typeof part === "string" && !rNonWord.test( part ) ) { part = part.toLowerCase(); nodeCheck = part; checkFn = dirNodeCheck; } checkFn( "parentNode", part, doneName, checkSet, nodeCheck, isXML ); }, "~": function( checkSet, part, isXML ) { var nodeCheck, doneName = done++, checkFn = dirCheck; if ( typeof part === "string" && !rNonWord.test( part ) ) { part = part.toLowerCase(); nodeCheck = part; checkFn = dirNodeCheck; } checkFn( "previousSibling", part, doneName, checkSet, nodeCheck, isXML ); } }, find: { ID: function( match, context, isXML ) { if ( typeof context.getElementById !== "undefined" && !isXML ) { var m = context.getElementById(match[1]); // Check parentNode to catch when Blackberry 4.6 returns // nodes that are no longer in the document #6963 return m && m.parentNode ? [m] : []; } }, NAME: function( match, context ) { if ( typeof context.getElementsByName !== "undefined" ) { var ret = [], results = context.getElementsByName( match[1] ); for ( var i = 0, l = results.length; i < l; i++ ) { if ( results[i].getAttribute("name") === match[1] ) { ret.push( results[i] ); } } return ret.length === 0 ? null : ret; } }, TAG: function( match, context ) { if ( typeof context.getElementsByTagName !== "undefined" ) { return context.getElementsByTagName( match[1] ); } } }, preFilter: { CLASS: function( match, curLoop, inplace, result, not, isXML ) { match = " " + match[1].replace( rBackslash, "" ) + " "; if ( isXML ) { return match; } for ( var i = 0, elem; (elem = curLoop[i]) != null; i++ ) { if ( elem ) { if ( not ^ (elem.className && (" " + elem.className + " ").replace(/[\t\n\r]/g, " ").indexOf(match) >= 0) ) { if ( !inplace ) { result.push( elem ); } } else if ( inplace ) { curLoop[i] = false; } } } return false; }, ID: function( match ) { return match[1].replace( rBackslash, "" ); }, TAG: function( match, curLoop ) { return match[1].replace( rBackslash, "" ).toLowerCase(); }, CHILD: function( match ) { if ( match[1] === "nth" ) { if ( !match[2] ) { Sizzle.error( match[0] ); } match[2] = match[2].replace(/^\+|\s*/g, ''); // parse equations like 'even', 'odd', '5', '2n', '3n+2', '4n-1', '-n+6' var test = /(-?)(\d*)(?:n([+\-]?\d*))?/.exec( match[2] === "even" && "2n" || match[2] === "odd" && "2n+1" || !/\D/.test( match[2] ) && "0n+" + match[2] || match[2]); // calculate the numbers (first)n+(last) including if they are negative match[2] = (test[1] + (test[2] || 1)) - 0; match[3] = test[3] - 0; } else if ( match[2] ) { Sizzle.error( match[0] ); } // TODO: Move to normal caching system match[0] = done++; return match; }, ATTR: function( match, curLoop, inplace, result, not, isXML ) { var name = match[1] = match[1].replace( rBackslash, "" ); if ( !isXML && Expr.attrMap[name] ) { match[1] = Expr.attrMap[name]; } // Handle if an un-quoted value was used match[4] = ( match[4] || match[5] || "" ).replace( rBackslash, "" ); if ( match[2] === "~=" ) { match[4] = " " + match[4] + " "; } return match; }, PSEUDO: function( match, curLoop, inplace, result, not ) { if ( match[1] === "not" ) { // If we're dealing with a complex expression, or a simple one if ( ( chunker.exec(match[3]) || "" ).length > 1 || /^\w/.test(match[3]) ) { match[3] = Sizzle(match[3], null, null, curLoop); } else { var ret = Sizzle.filter(match[3], curLoop, inplace, true ^ not); if ( !inplace ) { result.push.apply( result, ret ); } return false; } } else if ( Expr.match.POS.test( match[0] ) || Expr.match.CHILD.test( match[0] ) ) { return true; } return match; }, POS: function( match ) { match.unshift( true ); return match; } }, filters: { enabled: function( elem ) { return elem.disabled === false && elem.type !== "hidden"; }, disabled: function( elem ) { return elem.disabled === true; }, checked: function( elem ) { return elem.checked === true; }, selected: function( elem ) { // Accessing this property makes selected-by-default // options in Safari work properly if ( elem.parentNode ) { elem.parentNode.selectedIndex; } return elem.selected === true; }, parent: function( elem ) { return !!elem.firstChild; }, empty: function( elem ) { return !elem.firstChild; }, has: function( elem, i, match ) { return !!Sizzle( match[3], elem ).length; }, header: function( elem ) { return (/h\d/i).test( elem.nodeName ); }, text: function( elem ) { var attr = elem.getAttribute( "type" ), type = elem.type; // IE6 and 7 will map elem.type to 'text' for new HTML5 types (search, etc) // use getAttribute instead to test this case return elem.nodeName.toLowerCase() === "input" && "text" === type && ( attr === type || attr === null ); }, radio: function( elem ) { return elem.nodeName.toLowerCase() === "input" && "radio" === elem.type; }, checkbox: function( elem ) { return elem.nodeName.toLowerCase() === "input" && "checkbox" === elem.type; }, file: function( elem ) { return elem.nodeName.toLowerCase() === "input" && "file" === elem.type; }, password: function( elem ) { return elem.nodeName.toLowerCase() === "input" && "password" === elem.type; }, submit: function( elem ) { var name = elem.nodeName.toLowerCase(); return (name === "input" || name === "button") && "submit" === elem.type; }, image: function( elem ) { return elem.nodeName.toLowerCase() === "input" && "image" === elem.type; }, reset: function( elem ) { var name = elem.nodeName.toLowerCase(); return (name === "input" || name === "button") && "reset" === elem.type; }, button: function( elem ) { var name = elem.nodeName.toLowerCase(); return name === "input" && "button" === elem.type || name === "button"; }, input: function( elem ) { return (/input|select|textarea|button/i).test( elem.nodeName ); }, focus: function( elem ) { return elem === elem.ownerDocument.activeElement; } }, setFilters: { first: function( elem, i ) { return i === 0; }, last: function( elem, i, match, array ) { return i === array.length - 1; }, even: function( elem, i ) { return i % 2 === 0; }, odd: function( elem, i ) { return i % 2 === 1; }, lt: function( elem, i, match ) { return i < match[3] - 0; }, gt: function( elem, i, match ) { return i > match[3] - 0; }, nth: function( elem, i, match ) { return match[3] - 0 === i; }, eq: function( elem, i, match ) { return match[3] - 0 === i; } }, filter: { PSEUDO: function( elem, match, i, array ) { var name = match[1], filter = Expr.filters[ name ]; if ( filter ) { return filter( elem, i, match, array ); } else if ( name === "contains" ) { return (elem.textContent || elem.innerText || getText([ elem ]) || "").indexOf(match[3]) >= 0; } else if ( name === "not" ) { var not = match[3]; for ( var j = 0, l = not.length; j < l; j++ ) { if ( not[j] === elem ) { return false; } } return true; } else { Sizzle.error( name ); } }, CHILD: function( elem, match ) { var first, last, doneName, parent, cache, count, diff, type = match[1], node = elem; switch ( type ) { case "only": case "first": while ( (node = node.previousSibling) ) { if ( node.nodeType === 1 ) { return false; } } if ( type === "first" ) { return true; } node = elem; case "last": while ( (node = node.nextSibling) ) { if ( node.nodeType === 1 ) { return false; } } return true; case "nth": first = match[2]; last = match[3]; if ( first === 1 && last === 0 ) { return true; } doneName = match[0]; parent = elem.parentNode; if ( parent && (parent[ expando ] !== doneName || !elem.nodeIndex) ) { count = 0; for ( node = parent.firstChild; node; node = node.nextSibling ) { if ( node.nodeType === 1 ) { node.nodeIndex = ++count; } } parent[ expando ] = doneName; } diff = elem.nodeIndex - last; if ( first === 0 ) { return diff === 0; } else { return ( diff % first === 0 && diff / first >= 0 ); } } }, ID: function( elem, match ) { return elem.nodeType === 1 && elem.getAttribute("id") === match; }, TAG: function( elem, match ) { return (match === "*" && elem.nodeType === 1) || !!elem.nodeName && elem.nodeName.toLowerCase() === match; }, CLASS: function( elem, match ) { return (" " + (elem.className || elem.getAttribute("class")) + " ") .indexOf( match ) > -1; }, ATTR: function( elem, match ) { var name = match[1], result = Sizzle.attr ? Sizzle.attr( elem, name ) : Expr.attrHandle[ name ] ? Expr.attrHandle[ name ]( elem ) : elem[ name ] != null ? elem[ name ] : elem.getAttribute( name ), value = result + "", type = match[2], check = match[4]; return result == null ? type === "!=" : !type && Sizzle.attr ? result != null : type === "=" ? value === check : type === "*=" ? value.indexOf(check) >= 0 : type === "~=" ? (" " + value + " ").indexOf(check) >= 0 : !check ? value && result !== false : type === "!=" ? value !== check : type === "^=" ? value.indexOf(check) === 0 : type === "$=" ? value.substr(value.length - check.length) === check : type === "|=" ? value === check || value.substr(0, check.length + 1) === check + "-" : false; }, POS: function( elem, match, i, array ) { var name = match[2], filter = Expr.setFilters[ name ]; if ( filter ) { return filter( elem, i, match, array ); } } } }; var origPOS = Expr.match.POS, fescape = function(all, num){ return "\\" + (num - 0 + 1); }; for ( var type in Expr.match ) { Expr.match[ type ] = new RegExp( Expr.match[ type ].source + (/(?![^\[]*\])(?![^\(]*\))/.source) ); Expr.leftMatch[ type ] = new RegExp( /(^(?:.|\r|\n)*?)/.source + Expr.match[ type ].source.replace(/\\(\d+)/g, fescape) ); } var makeArray = function( array, results ) { array = Array.prototype.slice.call( array, 0 ); if ( results ) { results.push.apply( results, array ); return results; } return array; }; // Perform a simple check to determine if the browser is capable of // converting a NodeList to an array using builtin methods. // Also verifies that the returned array holds DOM nodes // (which is not the case in the Blackberry browser) try { Array.prototype.slice.call( document.documentElement.childNodes, 0 )[0].nodeType; // Provide a fallback method if it does not work } catch( e ) { makeArray = function( array, results ) { var i = 0, ret = results || []; if ( toString.call(array) === "[object Array]" ) { Array.prototype.push.apply( ret, array ); } else { if ( typeof array.length === "number" ) { for ( var l = array.length; i < l; i++ ) { ret.push( array[i] ); } } else { for ( ; array[i]; i++ ) { ret.push( array[i] ); } } } return ret; }; } var sortOrder, siblingCheck; if ( document.documentElement.compareDocumentPosition ) { sortOrder = function( a, b ) { if ( a === b ) { hasDuplicate = true; return 0; } if ( !a.compareDocumentPosition || !b.compareDocumentPosition ) { return a.compareDocumentPosition ? -1 : 1; } return a.compareDocumentPosition(b) & 4 ? -1 : 1; }; } else { sortOrder = function( a, b ) { // The nodes are identical, we can exit early if ( a === b ) { hasDuplicate = true; return 0; // Fallback to using sourceIndex (in IE) if it's available on both nodes } else if ( a.sourceIndex && b.sourceIndex ) { return a.sourceIndex - b.sourceIndex; } var al, bl, ap = [], bp = [], aup = a.parentNode, bup = b.parentNode, cur = aup; // If the nodes are siblings (or identical) we can do a quick check if ( aup === bup ) { return siblingCheck( a, b ); // If no parents were found then the nodes are disconnected } else if ( !aup ) { return -1; } else if ( !bup ) { return 1; } // Otherwise they're somewhere else in the tree so we need // to build up a full list of the parentNodes for comparison while ( cur ) { ap.unshift( cur ); cur = cur.parentNode; } cur = bup; while ( cur ) { bp.unshift( cur ); cur = cur.parentNode; } al = ap.length; bl = bp.length; // Start walking down the tree looking for a discrepancy for ( var i = 0; i < al && i < bl; i++ ) { if ( ap[i] !== bp[i] ) { return siblingCheck( ap[i], bp[i] ); } } // We ended someplace up the tree so do a sibling check return i === al ? siblingCheck( a, bp[i], -1 ) : siblingCheck( ap[i], b, 1 ); }; siblingCheck = function( a, b, ret ) { if ( a === b ) { return ret; } var cur = a.nextSibling; while ( cur ) { if ( cur === b ) { return -1; } cur = cur.nextSibling; } return 1; }; } // Check to see if the browser returns elements by name when // querying by getElementById (and provide a workaround) (function(){ // We're going to inject a fake input element with a specified name var form = document.createElement("div"), id = "script" + (new Date()).getTime(), root = document.documentElement; form.innerHTML = ""; // Inject it into the root element, check its status, and remove it quickly root.insertBefore( form, root.firstChild ); // The workaround has to do additional checks after a getElementById // Which slows things down for other browsers (hence the branching) if ( document.getElementById( id ) ) { Expr.find.ID = function( match, context, isXML ) { if ( typeof context.getElementById !== "undefined" && !isXML ) { var m = context.getElementById(match[1]); return m ? m.id === match[1] || typeof m.getAttributeNode !== "undefined" && m.getAttributeNode("id").nodeValue === match[1] ? [m] : undefined : []; } }; Expr.filter.ID = function( elem, match ) { var node = typeof elem.getAttributeNode !== "undefined" && elem.getAttributeNode("id"); return elem.nodeType === 1 && node && node.nodeValue === match; }; } root.removeChild( form ); // release memory in IE root = form = null; })(); (function(){ // Check to see if the browser returns only elements // when doing getElementsByTagName("*") // Create a fake element var div = document.createElement("div"); div.appendChild( document.createComment("") ); // Make sure no comments are found if ( div.getElementsByTagName("*").length > 0 ) { Expr.find.TAG = function( match, context ) { var results = context.getElementsByTagName( match[1] ); // Filter out possible comments if ( match[1] === "*" ) { var tmp = []; for ( var i = 0; results[i]; i++ ) { if ( results[i].nodeType === 1 ) { tmp.push( results[i] ); } } results = tmp; } return results; }; } // Check to see if an attribute returns normalized href attributes div.innerHTML = ""; if ( div.firstChild && typeof div.firstChild.getAttribute !== "undefined" && div.firstChild.getAttribute("href") !== "#" ) { Expr.attrHandle.href = function( elem ) { return elem.getAttribute( "href", 2 ); }; } // release memory in IE div = null; })(); if ( document.querySelectorAll ) { (function(){ var oldSizzle = Sizzle, div = document.createElement("div"), id = "__sizzle__"; div.innerHTML = "

"; // Safari can't handle uppercase or unicode characters when // in quirks mode. if ( div.querySelectorAll && div.querySelectorAll(".TEST").length === 0 ) { return; } Sizzle = function( query, context, extra, seed ) { context = context || document; // Only use querySelectorAll on non-XML documents // (ID selectors don't work in non-HTML documents) if ( !seed && !Sizzle.isXML(context) ) { // See if we find a selector to speed up var match = /^(\w+$)|^\.([\w\-]+$)|^#([\w\-]+$)/.exec( query ); if ( match && (context.nodeType === 1 || context.nodeType === 9) ) { // Speed-up: Sizzle("TAG") if ( match[1] ) { return makeArray( context.getElementsByTagName( query ), extra ); // Speed-up: Sizzle(".CLASS") } else if ( match[2] && Expr.find.CLASS && context.getElementsByClassName ) { return makeArray( context.getElementsByClassName( match[2] ), extra ); } } if ( context.nodeType === 9 ) { // Speed-up: Sizzle("body") // The body element only exists once, optimize finding it if ( query === "body" && context.body ) { return makeArray( [ context.body ], extra ); // Speed-up: Sizzle("#ID") } else if ( match && match[3] ) { var elem = context.getElementById( match[3] ); // Check parentNode to catch when Blackberry 4.6 returns // nodes that are no longer in the document #6963 if ( elem && elem.parentNode ) { // Handle the case where IE and Opera return items // by name instead of ID if ( elem.id === match[3] ) { return makeArray( [ elem ], extra ); } } else { return makeArray( [], extra ); } } try { return makeArray( context.querySelectorAll(query), extra ); } catch(qsaError) {} // qSA works strangely on Element-rooted queries // We can work around this by specifying an extra ID on the root // and working up from there (Thanks to Andrew Dupont for the technique) // IE 8 doesn't work on object elements } else if ( context.nodeType === 1 && context.nodeName.toLowerCase() !== "object" ) { var oldContext = context, old = context.getAttribute( "id" ), nid = old || id, hasParent = context.parentNode, relativeHierarchySelector = /^\s*[+~]/.test( query ); if ( !old ) { context.setAttribute( "id", nid ); } else { nid = nid.replace( /'/g, "\\$&" ); } if ( relativeHierarchySelector && hasParent ) { context = context.parentNode; } try { if ( !relativeHierarchySelector || hasParent ) { return makeArray( context.querySelectorAll( "[id='" + nid + "'] " + query ), extra ); } } catch(pseudoError) { } finally { if ( !old ) { oldContext.removeAttribute( "id" ); } } } } return oldSizzle(query, context, extra, seed); }; for ( var prop in oldSizzle ) { Sizzle[ prop ] = oldSizzle[ prop ]; } // release memory in IE div = null; })(); } (function(){ var html = document.documentElement, matches = html.matchesSelector || html.mozMatchesSelector || html.webkitMatchesSelector || html.msMatchesSelector; if ( matches ) { // Check to see if it's possible to do matchesSelector // on a disconnected node (IE 9 fails this) var disconnectedMatch = !matches.call( document.createElement( "div" ), "div" ), pseudoWorks = false; try { // This should fail with an exception // Gecko does not error, returns false instead matches.call( document.documentElement, "[test!='']:sizzle" ); } catch( pseudoError ) { pseudoWorks = true; } Sizzle.matchesSelector = function( node, expr ) { // Make sure that attribute selectors are quoted expr = expr.replace(/\=\s*([^'"\]]*)\s*\]/g, "='$1']"); if ( !Sizzle.isXML( node ) ) { try { if ( pseudoWorks || !Expr.match.PSEUDO.test( expr ) && !/!=/.test( expr ) ) { var ret = matches.call( node, expr ); // IE 9's matchesSelector returns false on disconnected nodes if ( ret || !disconnectedMatch || // As well, disconnected nodes are said to be in a document // fragment in IE 9, so check for that node.document && node.document.nodeType !== 11 ) { return ret; } } } catch(e) {} } return Sizzle(expr, null, null, [node]).length > 0; }; } })(); (function(){ var div = document.createElement("div"); div.innerHTML = "
"; // Opera can't find a second classname (in 9.6) // Also, make sure that getElementsByClassName actually exists if ( !div.getElementsByClassName || div.getElementsByClassName("e").length === 0 ) { return; } // Safari caches class attributes, doesn't catch changes (in 3.2) div.lastChild.className = "e"; if ( div.getElementsByClassName("e").length === 1 ) { return; } Expr.order.splice(1, 0, "CLASS"); Expr.find.CLASS = function( match, context, isXML ) { if ( typeof context.getElementsByClassName !== "undefined" && !isXML ) { return context.getElementsByClassName(match[1]); } }; // release memory in IE div = null; })(); function dirNodeCheck( dir, cur, doneName, checkSet, nodeCheck, isXML ) { for ( var i = 0, l = checkSet.length; i < l; i++ ) { var elem = checkSet[i]; if ( elem ) { var match = false; elem = elem[dir]; while ( elem ) { if ( elem[ expando ] === doneName ) { match = checkSet[elem.sizset]; break; } if ( elem.nodeType === 1 && !isXML ){ elem[ expando ] = doneName; elem.sizset = i; } if ( elem.nodeName.toLowerCase() === cur ) { match = elem; break; } elem = elem[dir]; } checkSet[i] = match; } } } function dirCheck( dir, cur, doneName, checkSet, nodeCheck, isXML ) { for ( var i = 0, l = checkSet.length; i < l; i++ ) { var elem = checkSet[i]; if ( elem ) { var match = false; elem = elem[dir]; while ( elem ) { if ( elem[ expando ] === doneName ) { match = checkSet[elem.sizset]; break; } if ( elem.nodeType === 1 ) { if ( !isXML ) { elem[ expando ] = doneName; elem.sizset = i; } if ( typeof cur !== "string" ) { if ( elem === cur ) { match = true; break; } } else if ( Sizzle.filter( cur, [elem] ).length > 0 ) { match = elem; break; } } elem = elem[dir]; } checkSet[i] = match; } } } if ( document.documentElement.contains ) { Sizzle.contains = function( a, b ) { return a !== b && (a.contains ? a.contains(b) : true); }; } else if ( document.documentElement.compareDocumentPosition ) { Sizzle.contains = function( a, b ) { return !!(a.compareDocumentPosition(b) & 16); }; } else { Sizzle.contains = function() { return false; }; } Sizzle.isXML = function( elem ) { // documentElement is verified for cases where it doesn't yet exist // (such as loading iframes in IE - #4833) var documentElement = (elem ? elem.ownerDocument || elem : 0).documentElement; return documentElement ? documentElement.nodeName !== "HTML" : false; }; var posProcess = function( selector, context, seed ) { var match, tmpSet = [], later = "", root = context.nodeType ? [context] : context; // Position selectors must be done after the filter // And so must :not(positional) so we move all PSEUDOs to the end while ( (match = Expr.match.PSEUDO.exec( selector )) ) { later += match[0]; selector = selector.replace( Expr.match.PSEUDO, "" ); } selector = Expr.relative[selector] ? selector + "*" : selector; for ( var i = 0, l = root.length; i < l; i++ ) { Sizzle( selector, root[i], tmpSet, seed ); } return Sizzle.filter( later, tmpSet ); }; // EXPOSE // Override sizzle attribute retrieval Sizzle.attr = __kivy__jQuery.attr; Sizzle.selectors.attrMap = {}; __kivy__jQuery.find = Sizzle; __kivy__jQuery.expr = Sizzle.selectors; __kivy__jQuery.expr[":"] = __kivy__jQuery.expr.filters; __kivy__jQuery.unique = Sizzle.uniqueSort; __kivy__jQuery.text = Sizzle.getText; __kivy__jQuery.isXMLDoc = Sizzle.isXML; __kivy__jQuery.contains = Sizzle.contains; })(); var runtil = /Until$/, rparentsprev = /^(?:parents|prevUntil|prevAll)/, // Note: This RegExp should be improved, or likely pulled from Sizzle rmultiselector = /,/, isSimple = /^.[^:#\[\.,]*$/, slice = Array.prototype.slice, POS = __kivy__jQuery.expr.match.POS, // methods guaranteed to produce a unique set when starting from a unique set guaranteedUnique = { children: true, contents: true, next: true, prev: true }; __kivy__jQuery.fn.extend({ find: function( selector ) { var self = this, i, l; if ( typeof selector !== "string" ) { return __kivy__jQuery( selector ).filter(function() { for ( i = 0, l = self.length; i < l; i++ ) { if ( __kivy__jQuery.contains( self[ i ], this ) ) { return true; } } }); } var ret = this.pushStack( "", "find", selector ), length, n, r; for ( i = 0, l = this.length; i < l; i++ ) { length = ret.length; __kivy__jQuery.find( selector, this[i], ret ); if ( i > 0 ) { // Make sure that the results are unique for ( n = length; n < ret.length; n++ ) { for ( r = 0; r < length; r++ ) { if ( ret[r] === ret[n] ) { ret.splice(n--, 1); break; } } } } } return ret; }, has: function( target ) { var targets = __kivy__jQuery( target ); return this.filter(function() { for ( var i = 0, l = targets.length; i < l; i++ ) { if ( __kivy__jQuery.contains( this, targets[i] ) ) { return true; } } }); }, not: function( selector ) { return this.pushStack( winnow(this, selector, false), "not", selector); }, filter: function( selector ) { return this.pushStack( winnow(this, selector, true), "filter", selector ); }, is: function( selector ) { return !!selector && ( typeof selector === "string" ? // If this is a positional selector, check membership in the returned set // so $("p:first").is("p:last") won't return true for a doc with two "p". POS.test( selector ) ? __kivy__jQuery( selector, this.context ).index( this[0] ) >= 0 : __kivy__jQuery.filter( selector, this ).length > 0 : this.filter( selector ).length > 0 ); }, closest: function( selectors, context ) { var ret = [], i, l, cur = this[0]; // Array (deprecated as of __kivy__jQuery 1.7) if ( __kivy__jQuery.isArray( selectors ) ) { var level = 1; while ( cur && cur.ownerDocument && cur !== context ) { for ( i = 0; i < selectors.length; i++ ) { if ( __kivy__jQuery( cur ).is( selectors[ i ] ) ) { ret.push({ selector: selectors[ i ], elem: cur, level: level }); } } cur = cur.parentNode; level++; } return ret; } // String var pos = POS.test( selectors ) || typeof selectors !== "string" ? __kivy__jQuery( selectors, context || this.context ) : 0; for ( i = 0, l = this.length; i < l; i++ ) { cur = this[i]; while ( cur ) { if ( pos ? pos.index(cur) > -1 : __kivy__jQuery.find.matchesSelector(cur, selectors) ) { ret.push( cur ); break; } else { cur = cur.parentNode; if ( !cur || !cur.ownerDocument || cur === context || cur.nodeType === 11 ) { break; } } } } ret = ret.length > 1 ? __kivy__jQuery.unique( ret ) : ret; return this.pushStack( ret, "closest", selectors ); }, // Determine the position of an element within // the matched set of elements index: function( elem ) { // No argument, return index in parent if ( !elem ) { return ( this[0] && this[0].parentNode ) ? this.prevAll().length : -1; } // index in selector if ( typeof elem === "string" ) { return __kivy__jQuery.inArray( this[0], __kivy__jQuery( elem ) ); } // Locate the position of the desired element return __kivy__jQuery.inArray( // If it receives a __kivy__jQuery object, the first element is used elem.__kivy__jquery ? elem[0] : elem, this ); }, add: function( selector, context ) { var set = typeof selector === "string" ? __kivy__jQuery( selector, context ) : __kivy__jQuery.makeArray( selector && selector.nodeType ? [ selector ] : selector ), all = __kivy__jQuery.merge( this.get(), set ); return this.pushStack( isDisconnected( set[0] ) || isDisconnected( all[0] ) ? all : __kivy__jQuery.unique( all ) ); }, andSelf: function() { return this.add( this.prevObject ); } }); // A painfully simple check to see if an element is disconnected // from a document (should be improved, where feasible). function isDisconnected( node ) { return !node || !node.parentNode || node.parentNode.nodeType === 11; } __kivy__jQuery.each({ parent: function( elem ) { var parent = elem.parentNode; return parent && parent.nodeType !== 11 ? parent : null; }, parents: function( elem ) { return __kivy__jQuery.dir( elem, "parentNode" ); }, parentsUntil: function( elem, i, until ) { return __kivy__jQuery.dir( elem, "parentNode", until ); }, next: function( elem ) { return __kivy__jQuery.nth( elem, 2, "nextSibling" ); }, prev: function( elem ) { return __kivy__jQuery.nth( elem, 2, "previousSibling" ); }, nextAll: function( elem ) { return __kivy__jQuery.dir( elem, "nextSibling" ); }, prevAll: function( elem ) { return __kivy__jQuery.dir( elem, "previousSibling" ); }, nextUntil: function( elem, i, until ) { return __kivy__jQuery.dir( elem, "nextSibling", until ); }, prevUntil: function( elem, i, until ) { return __kivy__jQuery.dir( elem, "previousSibling", until ); }, siblings: function( elem ) { return __kivy__jQuery.sibling( elem.parentNode.firstChild, elem ); }, children: function( elem ) { return __kivy__jQuery.sibling( elem.firstChild ); }, contents: function( elem ) { return __kivy__jQuery.nodeName( elem, "iframe" ) ? elem.contentDocument || elem.contentWindow.document : __kivy__jQuery.makeArray( elem.childNodes ); } }, function( name, fn ) { __kivy__jQuery.fn[ name ] = function( until, selector ) { var ret = __kivy__jQuery.map( this, fn, until ); if ( !runtil.test( name ) ) { selector = until; } if ( selector && typeof selector === "string" ) { ret = __kivy__jQuery.filter( selector, ret ); } ret = this.length > 1 && !guaranteedUnique[ name ] ? __kivy__jQuery.unique( ret ) : ret; if ( (this.length > 1 || rmultiselector.test( selector )) && rparentsprev.test( name ) ) { ret = ret.reverse(); } return this.pushStack( ret, name, slice.call( arguments ).join(",") ); }; }); __kivy__jQuery.extend({ filter: function( expr, elems, not ) { if ( not ) { expr = ":not(" + expr + ")"; } return elems.length === 1 ? __kivy__jQuery.find.matchesSelector(elems[0], expr) ? [ elems[0] ] : [] : __kivy__jQuery.find.matches(expr, elems); }, dir: function( elem, dir, until ) { var matched = [], cur = elem[ dir ]; while ( cur && cur.nodeType !== 9 && (until === undefined || cur.nodeType !== 1 || !__kivy__jQuery( cur ).is( until )) ) { if ( cur.nodeType === 1 ) { matched.push( cur ); } cur = cur[dir]; } return matched; }, nth: function( cur, result, dir, elem ) { result = result || 1; var num = 0; for ( ; cur; cur = cur[dir] ) { if ( cur.nodeType === 1 && ++num === result ) { break; } } return cur; }, sibling: function( n, elem ) { var r = []; for ( ; n; n = n.nextSibling ) { if ( n.nodeType === 1 && n !== elem ) { r.push( n ); } } return r; } }); // Implement the identical functionality for filter and not function winnow( elements, qualifier, keep ) { // Can't pass null or undefined to indexOf in Firefox 4 // Set to 0 to skip string check qualifier = qualifier || 0; if ( __kivy__jQuery.isFunction( qualifier ) ) { return __kivy__jQuery.grep(elements, function( elem, i ) { var retVal = !!qualifier.call( elem, i, elem ); return retVal === keep; }); } else if ( qualifier.nodeType ) { return __kivy__jQuery.grep(elements, function( elem, i ) { return ( elem === qualifier ) === keep; }); } else if ( typeof qualifier === "string" ) { var filtered = __kivy__jQuery.grep(elements, function( elem ) { return elem.nodeType === 1; }); if ( isSimple.test( qualifier ) ) { return __kivy__jQuery.filter(qualifier, filtered, !keep); } else { qualifier = __kivy__jQuery.filter( qualifier, filtered ); } } return __kivy__jQuery.grep(elements, function( elem, i ) { return ( __kivy__jQuery.inArray( elem, qualifier ) >= 0 ) === keep; }); } function createSafeFragment( document ) { var list = nodeNames.split( "|" ), safeFrag = document.createDocumentFragment(); if ( safeFrag.createElement ) { while ( list.length ) { safeFrag.createElement( list.pop() ); } } return safeFrag; } var nodeNames = "abbr|article|aside|audio|canvas|datalist|details|figcaption|figure|footer|" + "header|hgroup|mark|meter|nav|output|progress|section|summary|time|video", rinline__kivy__jQuery = / __kivy__jQuery\d+="(?:\d+|null)"/g, rleadingWhitespace = /^\s+/, rxhtmlTag = /<(?!area|br|col|embed|hr|img|input|link|meta|param)(([\w:]+)[^>]*)\/>/ig, rtagName = /<([\w:]+)/, rtbody = /", "" ], legend: [ 1, "
", "
" ], thead: [ 1, "", "
" ], tr: [ 2, "", "
" ], td: [ 3, "", "
" ], col: [ 2, "", "
" ], area: [ 1, "", "" ], _default: [ 0, "", "" ] }, safeFragment = createSafeFragment( document ); wrapMap.optgroup = wrapMap.option; wrapMap.tbody = wrapMap.tfoot = wrapMap.colgroup = wrapMap.caption = wrapMap.thead; wrapMap.th = wrapMap.td; // IE can't serialize and Some <select> element from JIRA:
(click submit to test the post data sent)

With Fixed as "selected":

Add new <select> element dynamically on a page:
(select boxes are checked every second on a page,
you should see a normal select element transforming
into js select box a moment after you click the button)



Test interaction with other webpages that already use some other
javascript boxes library.

These links need to be opened in the kivy_.py example:

Some libraries that are not well-designed will display
the select element twice, take a look at this for example:

http://adam.co/lab/jquery/customselect/ (open in kivy_.py example)

Although, it will still be functional, just with a display glitch.

The following code was added to the SelectBox library to transform <select> element into js box only if it's visible on a webpage:

    // This should fix interaction with other js boxes libraries,
    // so that the select element does not appear twice.
    if (!$(select).is(":visible")) {
        return;
    }
Also this code gives one second to other select box libraries
to do their stuff, before we start ours: 
    __kivy__jQuery(document).ready(function() {
    // Transform select elements only after a second,
    // this will give time other select boxes libraries
    // included on a webpage to their stuff first.
    window.setInterval(function(){
        __kivy__jQuery(document).ready(function() { 
            __kivy__jQuery("select").__kivy__selectBox(); 
        });
    }, 1000);
});
cefpython-49.0/src/linux/binaries_64bit/kivy-select-boxes/readme.md000066400000000000000000000131161334103266300253360ustar00rootroot00000000000000# jQuery selectBox: A styleable replacement for SELECT elements _Licensed under the MIT license: http://opensource.org/licenses/MIT_ ## Features * Supports OPTGROUPS * Supports standard dropdown controls * Supports multi-select controls (i.e. multiple="multiple") * Supports inline controls (i.e. size="5") * Fully accessible via keyboard * Shift + click (or shift + enter) to select a range of options in multi-select controls * Type to search when the control has focus * Auto-height based on the size attribute (to use, omit the height property in your CSS!) * Tested in IE7-IE9, Firefox 3-4, recent WebKit browsers, and Opera ## Usage Link to the JS file: ```html ``` Add the CSS file (or append contents to your own stylesheet): ```html ``` To initialize: ```javascript // default $('select').selectBox(); // or with custom settings $('select').selectBox({ mobile: true, menuSpeed: 'fast' }); ``` ## Settings | Key | Default | Values | Description | | ---------------|:-------------:|---------------------------:|-------------------------------------------------:| | mobile | `false` | Boolean | Disables the widget for mobile devices | | menuTransition | `default` | `default`, `slide`, `fade` | The show/hide transition for dropdown menus | | menuSpeed | `normal` | `slow`, `normal`, `fast` | The show/hide transition speed | | loopOptions | `false` | Boolean | Flag to allow arrow keys to loop through options | To specify settings after the init, use this syntax: ```javascript $('select').selectBox('settings', {settingName: value, ... }); ``` ## Methods To call a method use this syntax: ```javascript $('select').selectBox('methodName', [option]); ``` ### Available methods | Key | Description | | ---------------|-----------------------------------------------------------------------------------------------| | create | Creates the control (default) | | destroy | Destroys the selectBox control and reverts back to the original form control | | disable | Disables the control (i.e. disabled="disabled") | | enable | Enables the control | | value | If passed with a value, sets the control to that value; otherwise returns the current value | | options | If passed either a string of HTML or a JSON object, replaces the existing options; otherwise Returns the options container element as a jQuery object | | control | Returns the selectBox control element (an anchor tag) for working with directly | | refresh | Updates the selectBox control's options based on the original controls options | | instance | Returns the SelectBox instance, where you have more methods available (only in v1.2.0-dev | | available) as in the `SelectBox` class below. | ## API `SelectBox` You can instantiate the selectBox also through a classic OOP way: ```javascript var selectBox = new SelectBox($('#mySelectBox'), settings = {}); selectBox.showMenu(); ``` The public methods are: ```javascript refresh() destroy() disable() enable() getLabelClass() getLabelText() getSelectElement() getOptions(String type = 'inline'|'dropdown') hideMenus() showMenu() setLabel() setOptions(Object options) setValue(String value) removeHover(HTMLElement li) addHover(HTMLElement li) disableSelection(HTMLElement selector) generateOptions(jQuery self, jQuery options) handleKeyDown(event) handleKeyPress(event) init(options) keepOptionInView(jQuery li, Boolean center) refresh() removeHover(HTMLElement li) selectOption(HTMLElement li, event) ``` ## Events Events are fired on the original select element. You can bind events like this: ```javascript $('select').selectBox().change(function () { alert($(this).val()); }); ``` ### Available events | Key | Description | | ---------------|-----------------------------------------------------------------------------------------------| | focus | Fired when the control gains focus | | blur | Fired when the control loses focus | | change | Fired when the value of a control changes | | beforeopen | Fired before a dropdown menu opens (cancelable) | | open | Fired after a dropdown menu opens (not cancelable) | | beforeclose | Fired before a dropdown menu closes (cancelable) | | close | Fired after a dropdown menu closes (not cancelable) | ### Known Issues * The blur and focus callbacks are not very reliable in IE7. The change callback works fine. ## Credits Original plugin by Cory LaViska of A Beautiful Site, LLC. (http://www.abeautifulsite.net/)cefpython-49.0/src/linux/binaries_64bit/kivy_.py000066400000000000000000001052071334103266300217000ustar00rootroot00000000000000# An example of embedding CEF browser in the Kivy framework. # The browser is embedded using off-screen rendering mode. # Tested using Kivy 1.7.2 stable, only on Linux. # In this example kivy-lang is used to declare the layout which # contains two buttons (back, forward) and the browser view. from cefpython3 import cefpython as cef import pygtk import gtk import sys import os from kivy.app import App from kivy.uix.button import Button from kivy.uix.popup import Popup from kivy.uix.label import Label from kivy.uix.widget import Widget from kivy.graphics import Color, Rectangle from kivy.clock import Clock from kivy.graphics.texture import Texture from kivy.uix.boxlayout import BoxLayout from kivy.base import EventLoop # Global variables g_switches = None # PyGTK required pygtk.require('2.0') class BrowserLayout(BoxLayout): def __init__(self, **kwargs): super(BrowserLayout, self).__init__(**kwargs) self.orientation = "vertical" self.browser_widget = CefBrowser(id="browser") layout = BoxLayout() layout.size_hint_y = None layout.height = 40 layout.add_widget(Button(text="Back", on_press=self.browser_widget.go_back)) layout.add_widget(Button(text="Forward", on_press=self.browser_widget.go_forward)) layout.add_widget(Button(text="Reload", on_press=self.browser_widget.reload)) layout.add_widget(Button(text="Print", on_press=self.browser_widget.print_page)) layout.add_widget(Button(text="DevTools", on_press=self.browser_widget.devtools)) self.add_widget(layout) self.add_widget(self.browser_widget) class CefBrowser(Widget): """Represent a browser widget for kivy, which can be used like a normal widget.""" # Keyboard mode: "global" or "local". # 1. Global mode forwards keys to CEF all the time. # 2. Local mode forwards keys to CEF only when an editable # control is focused (input type=text|password or textarea). keyboard_mode = "global" def __init__(self, start_url='https://www.google.com/', **kwargs): super(CefBrowser, self).__init__(**kwargs) for arg in sys.argv: if arg.startswith("http://") or arg.startswith("https://"): start_url = arg self.start_url = start_url # Workaround for flexible size: # start browser when the height has changed (done by layout) # This has to be done like this because I wasn't able to change # the texture size # until runtime without core-dump. self.bind(size=self.size_changed) self.browser = None starting = True def size_changed(self, *_): """When the height of the cefbrowser widget got changed, create the browser.""" if self.starting: if self.height != 100: self.start_cef() self.starting = False else: # noinspection PyArgumentList self.texture = Texture.create( size=self.size, colorfmt='rgba', bufferfmt='ubyte') self.texture.flip_vertical() with self.canvas: Color(1, 1, 1) # This will cause segmentation fault: # | self.rect = Rectangle(size=self.size, texture=self.texture) # Update only the size: self.rect.size = self.size self.browser.WasResized() count = 0 def _message_loop_work(self, *_): """Get called every frame.""" self.count += 1 # print(self.count) cef.MessageLoopWork() self.on_mouse_move_emulate() # From Kivy docs: # Clock.schedule_once(my_callback, 0) # call after the next frame # Clock.schedule_once(my_callback, -1) # call before the next frame # When scheduling "after the next frame" Kivy calls _message_loop_work # in about 13ms intervals. We use a small trick to make this 6ms # interval by scheduling it alternately before and after the next # frame. This gives better User Experience when scrolling. # See Issue #240 for more details on OSR performance. if self.count % 2 == 0: Clock.schedule_once(self._message_loop_work, 0) else: Clock.schedule_once(self._message_loop_work, -1) def update_rect(self, *_): """Get called whenever the texture got updated. => we need to reset the texture for the rectangle """ self.rect.texture = self.texture def start_cef(self): """Starts CEF.""" # create texture & add it to canvas # noinspection PyArgumentList self.texture = Texture.create( size=self.size, colorfmt='rgba', bufferfmt='ubyte') self.texture.flip_vertical() with self.canvas: Color(1, 1, 1) self.rect = Rectangle(size=self.size, texture=self.texture) # Configure CEF settings = { # This directories must be set on Linux "locales_dir_path": cef.GetModuleDirectory()+"/locales", "resources_dir_path": cef.GetModuleDirectory(), "browser_subprocess_path": "%s/%s" % ( cef.GetModuleDirectory(), "subprocess"), "windowless_rendering_enabled": True, "context_menu": { # Disable context menu, popup widgets not supported "enabled": False, }, } switches = { # Tweaking OSR performance by setting the same Chromium flags # as in upstream cefclient (# Issue #240). "disable-surfaces": "", "disable-gpu": "", "disable-gpu-compositing": "", "enable-begin-frame-scheduling": "", } browserSettings = { # Tweaking OSR performance (Issue #240) "windowless_frame_rate": 60 } # Initialize CEF # noinspection PyArgumentList cef.WindowUtils.InstallX11ErrorHandlers() global g_switches g_switches = switches cef.Initialize(settings, switches) # Start idle - CEF message loop work. Clock.schedule_once(self._message_loop_work, 0) # TODO: For printing to work in off-screen-rendering mode # it is enough to call gtk_init(). It is not required # to provide window handle when calling SetAsOffscreen(). gtkwin = gtk.Window() gtkwin.realize() # WindowInfo offscreen flag windowInfo = cef.WindowInfo() windowInfo.SetAsOffscreen(gtkwin.window.xid) # Create Broswer and naviagte to empty page <= OnPaint won't get # called yet # The render handler callbacks are not yet set, thus an # error report will be thrown in the console (when release # DCHECKS are enabled), however don't worry, it is harmless. # This is happening because calling GetViewRect will return # false. That's why it is initially navigating to "about:blank". # Later, a real url will be loaded using the LoadUrl() method # and the GetViewRect will be called again. This time the render # handler callbacks will be available, it will work fine from # this point. # -- # Do not use "about:blank" as navigateUrl - this will cause # the GoBack() and GoForward() methods to not work. # self.browser = cef.CreateBrowserSync( windowInfo, browserSettings, navigateUrl=self.start_url) # Set focus self.browser.SendFocusEvent(True) self._client_handler = ClientHandler(self) self.browser.SetClientHandler(self._client_handler) self.set_js_bindings() # Call WasResized() => force cef to call GetViewRect() and OnPaint # afterwards self.browser.WasResized() # The browserWidget instance is required in OnLoadingStateChange(). self.browser.SetUserData("browserWidget", self) if self.keyboard_mode == "global": self.request_keyboard() # Clock.schedule_once(self.change_url, 5) _client_handler = None _js_bindings = None def set_js_bindings(self): if not self._js_bindings: self._js_bindings = cef.JavascriptBindings( bindToFrames=True, bindToPopups=True) self._js_bindings.SetFunction("__kivy__request_keyboard", self.request_keyboard) self._js_bindings.SetFunction("__kivy__release_keyboard", self.release_keyboard) self.browser.SetJavascriptBindings(self._js_bindings) def change_url(self, *_): # Doing a javascript redirect instead of Navigate() # solves the js bindings error. The url here need to # be preceded with "http://". Calling StopLoad() # might be a good idea before making the js navigation. self.browser.StopLoad() self.browser.GetMainFrame().ExecuteJavascript( "window.location='http://www.youtube.com/'") # Do not use Navigate() or GetMainFrame()->LoadURL(), # as it causes the js bindings to be removed. There is # a bug in CEF, that happens after a call to Navigate(). # The OnBrowserDestroyed() callback is fired and causes # the js bindings to be removed. See this topic for more # details: # http://www.magpcss.org/ceforum/viewtopic.php?f=6&t=11009 # OFF: # | self.browser.Navigate("http://www.youtube.com/") _keyboard = None def request_keyboard(self): print("request_keyboard()") self._keyboard = EventLoop.window.request_keyboard( self.release_keyboard, self) self._keyboard.bind(on_key_down=self.on_key_down) self._keyboard.bind(on_key_up=self.on_key_up) self.is_shift1 = False self.is_shift2 = False self.is_ctrl1 = False self.is_ctrl2 = False self.is_alt1 = False self.is_alt2 = False # Not sure if it is still required to send the focus # (some earlier bug), but it shouldn't hurt to call it. self.browser.SendFocusEvent(True) def release_keyboard(self): # When using local keyboard mode, do all the request # and releases of the keyboard through js bindings, # otherwise some focus problems arise. self.is_shift1 = False self.is_shift2 = False self.is_ctrl1 = False self.is_ctrl2 = False self.is_alt1 = False self.is_alt2 = False if not self._keyboard: return print("release_keyboard()") self._keyboard.unbind(on_key_down=self.on_key_down) self._keyboard.unbind(on_key_up=self.on_key_up) self._keyboard.release() # Kivy does not provide modifiers in on_key_up, but these # must be sent to CEF as well. is_shift1 = False is_shift2 = False is_ctrl1 = False is_ctrl2 = False is_alt1 = False is_alt2 = False def on_key_down(self, _, key, text, modifiers): # NOTE: Right alt modifier is not sent by Kivy through modifiers param. # print("---- on_key_down") # print("-- key="+str(key)) # print(text) - utf-8 char # print("-- modifiers="+str(modifiers)) if text: # print("-- ord(text)="+str(ord(text))) pass # CEF key event type: # KEYEVENT_RAWKEYDOWN = 0 # KEYEVENT_KEYDOWN = 1 # KEYEVENT_KEYUP = 2 # KEYEVENT_CHAR = 3 # Kivy code -1 is a special key eg. Change keyboard layout. # Sending it to CEF would crash it. if key[0] == -1: return # On escape release the keyboard, see the injected in OnLoadStart() if key[0] == 27: self.browser.GetFocusedFrame().ExecuteJavascript( "__kivy__on_escape()") return # CEF modifiers # When pressing ctrl also set modifiers for ctrl if key[0] in (306, 305): modifiers.append('ctrl') cef_modifiers = cef.EVENTFLAG_NONE if "shift" in modifiers: cef_modifiers |= cef.EVENTFLAG_SHIFT_DOWN if "ctrl" in modifiers: cef_modifiers |= cef.EVENTFLAG_CONTROL_DOWN if "alt" in modifiers: cef_modifiers |= cef.EVENTFLAG_ALT_DOWN if "capslock" in modifiers: cef_modifiers |= cef.EVENTFLAG_CAPS_LOCK_ON keycode = self.get_windows_key_code(key[0]) charcode = key[0] if text: charcode = ord(text) # Send key event to cef: RAWKEYDOWN keyEvent = { "type": cef.KEYEVENT_RAWKEYDOWN, "windows_key_code": keycode, "character": charcode, "unmodified_character": charcode, "modifiers": cef_modifiers, } # print("- SendKeyEvent: %s" % keyEvent) self.browser.SendKeyEvent(keyEvent) # Send key event to cef: CHAR if text: keyEvent = { "type": cef.KEYEVENT_CHAR, "windows_key_code": keycode, "character": charcode, "unmodified_character": charcode, "modifiers": cef_modifiers } # print("- SendKeyEvent: %s" % keyEvent) self.browser.SendKeyEvent(keyEvent) if key[0] == 304: self.is_shift1 = True elif key[0] == 303: self.is_shift2 = True elif key[0] == 306: self.is_ctrl1 = True elif key[0] == 305: self.is_ctrl2 = True elif key[0] == 308: self.is_alt1 = True elif key[0] == 313: self.is_alt2 = True def on_key_up(self, _, key): # print("---- on_key_up") # print("-- key="+str(key)) # Kivy code -1 is a special key eg. Change keyboard layout. # Sending it to CEF would crash it. if key[0] == -1: return # CEF modifiers cef_modifiers = cef.EVENTFLAG_NONE if self.is_shift1 or self.is_shift2: cef_modifiers |= cef.EVENTFLAG_SHIFT_DOWN if self.is_ctrl1 or self.is_ctrl2: cef_modifiers |= cef.EVENTFLAG_CONTROL_DOWN if self.is_alt1: cef_modifiers |= cef.EVENTFLAG_ALT_DOWN keycode = self.get_windows_key_code(key[0]) charcode = key[0] # Send key event to cef: KEYUP keyEvent = { "type": cef.KEYEVENT_KEYUP, "windows_key_code": keycode, "character": charcode, "unmodified_character": charcode, "modifiers": cef_modifiers } # print("- SendKeyEvent: %s" % keyEvent) self.browser.SendKeyEvent(keyEvent) if key[0] == 304: self.is_shift1 = False elif key[0] == 303: self.is_shift2 = False elif key[0] == 306: self.is_ctrl1 = False elif key[0] == 305: self.is_ctrl2 = False elif key[0] == 308: self.is_alt1 = False elif key[0] == 313: self.is_alt2 = False def get_windows_key_code(self, kivycode): cefcode = kivycode # NOTES: # - Map on all platforms to OnPreKeyEvent.event["windows_key_code"] # - Mapping all keys was not necessary on Linux, for example # 'comma' worked fine, while 'dot' did not, but mapping all keys # to make sure it will work correctly on all platforms. # - If some key mapping is missing launch wxpython.py and see # OnPreKeyEvent info for key events and replacate it here. # (key codes can also be found on MSDN Virtual-key codes page) # Must map basic letters, otherwise eg. ctrl+a to select all # text won't work. (97-122 kivy <> 65-90 cef) if 97 <= kivycode <= 122: cefcode = kivycode - 32 other_keys_map = { # Escape "27": 27, # F1-F12 "282": 112, "283": 113, "284": 114, "285": 115, "286": 116, "287": 117, "288": 118, "289": 119, "290": 120, "291": 121, "292": 122, "293": 123, # Tab "9": 9, # Left Shift, Right Shift "304": 16, "303": 16, # Left Ctrl, Right Ctrl "306": 17, "305": 17, # Left Alt, Right Alt # TODO: left alt is_system_key=True in CEF but only when RAWKEYDOWN "308": 18, "313": 225, # Backspace "8": 8, # Enter "13": 13, # PrScr, ScrLck, Pause "316": 42, "302": 145, "19": 19, # Insert, Delete, # Home, End, # Pgup, Pgdn "277": 45, "127": 46, "278": 36, "279": 35, "280": 33, "281": 34, # Arrows (left, up, right, down) "276": 37, "273": 38, "275": 39, "274": 40, # tilde "96": 192, # minus, plus "45": 189, "61": 187, # square brackets / curly brackets, backslash "91": 219, "93": 221, "92": 220, # windows key "311": 91, # colon / semicolon "59": 186, # single quote / double quote "39": 222, # comma, dot, slash "44": 188, "46": 190, "47": 91, # context menu key is 93, but disable as it crashes app after # context menu is shown. "319": 0, } if str(kivycode) in other_keys_map: cefcode = other_keys_map[str(kivycode)] return cefcode def go_forward(self, *_): """Going to forward in browser history.""" print "go forward" self.browser.GoForward() def go_back(self, *_): """Going back in browser history.""" print "go back" self.browser.GoBack() def reload(self, *_): self.browser.Reload() def print_page(self, *_): self.browser.Print() def devtools(self, *_): # ShowDevTools doesn't work with the 'enable-begin-frame-scheduling' # switch. This might be fixed by implementing native popup widgets, # see Issue #69. The solution for now is to remove that switch, # but this will impact performance. if "enable-begin-frame-scheduling" in g_switches: text = ("To enable DevTools you need to remove the\n" "'enable-begin-frame-scheduling' switch that\n" "is passed to cef.Initialize(). See also\n" "comment in CefBrowser.devtools().") popup = Popup(title='DevTools INFO', content=Label(text=text), size_hint=(None, None), size=(400, 400)) popup.open() else: self.browser.ShowDevTools() is_mouse_down = False is_drag = False is_drag_leave = False # Mouse leaves web view drag_data = None current_drag_operation = cef.DRAG_OPERATION_NONE def on_touch_down(self, touch, *kwargs): # Mouse scrolling if "button" in touch.profile: if touch.button in ["scrollup", "scrolldown"]: # Handled in on_touch_up() return if not self.collide_point(*touch.pos): return touch.grab(self) y = self.height-touch.pos[1] if touch.is_double_tap: # is_double_tap seems not to work in Kivy 1.7. # Context menu is currently disabled see # settings["context_menu"] in cef_start(). self.browser.SendMouseClickEvent( touch.x, y, cef.MOUSEBUTTON_RIGHT, mouseUp=False, clickCount=1 ) self.browser.SendMouseClickEvent( touch.x, y, cef.MOUSEBUTTON_RIGHT, mouseUp=True, clickCount=1 ) else: self.browser.SendMouseClickEvent(touch.x, y, cef.MOUSEBUTTON_LEFT, mouseUp=False, clickCount=1) self.is_mouse_down = True def on_touch_up(self, touch, *kwargs): # Mouse scrolling if "button" in touch.profile: if touch.button in ["scrollup", "scrolldown"]: x = touch.x y = self.height-touch.pos[1] deltaY = -40 if "scrollup" == touch.button else 40 self.browser.SendMouseWheelEvent(x, y, deltaX=0, deltaY=deltaY) return if touch.grab_current is not self: return y = self.height-touch.pos[1] self.browser.SendMouseClickEvent(touch.x, y, cef.MOUSEBUTTON_LEFT, mouseUp=True, clickCount=1) self.is_mouse_down = False if self.is_drag: # print("on_touch_up=%s/%s" % (touch.x,y)) if self.is_drag_leave or not self.is_inside_web_view(touch.x, y): # See comment in is_inside_web_view() - x/y at borders # should be treated as outside of web view. x = touch.x if x == 0: x = -1 if x == self.width-1: x = self.width if y == 0: y = -1 if y == self.height-1: y = self.height print("~~ DragSourceEndedAt") print("~~ current_drag_operation=%s" % self.current_drag_operation) self.browser.DragSourceEndedAt(x, y, self.current_drag_operation) self.drag_ended() else: print("~~ DragTargetDrop") print("~~ DragSourceEndedAt") print("~~ current_drag_operation=%s" % self.current_drag_operation) self.browser.DragTargetDrop(touch.x, y) self.browser.DragSourceEndedAt(touch.x, y, self.current_drag_operation) self.drag_ended() touch.ungrab(self) last_mouse_pos = None def on_mouse_move_emulate(self): if not hasattr(self.get_root_window(), "mouse_pos"): # Not all Kivy window providers have the "mouse_pos" attribute. # WindowPygame does have (kivy/kivy#325). return mouse_pos = self.get_root_window().mouse_pos if self.last_mouse_pos == mouse_pos: return self.last_mouse_pos = mouse_pos # Fix mouse pos: realy = 0, kivy y = 600 / realy = 600, kivy y = 0 x = mouse_pos[0] y = int(mouse_pos[1]-self.height) if x >= 0 >= y: y = abs(y) if not self.is_mouse_down and not self.is_drag: # When mouse is down on_touch_move will be called. Calling # mouse move event here caused issues with drag&drop. self.browser.SendMouseMoveEvent(x, y, mouseLeave=False) def on_touch_move(self, touch, *kwargs): if touch.grab_current is not self: return y = self.height-touch.pos[1] modifiers = cef.EVENTFLAG_LEFT_MOUSE_BUTTON self.browser.SendMouseMoveEvent(touch.x, y, mouseLeave=False, modifiers=modifiers) if self.is_drag: # print("on_touch_move=%s/%s" % (touch.x, y)) if self.is_inside_web_view(touch.x, y): if self.is_drag_leave: print("~~ DragTargetDragEnter") self.browser.DragTargetDragEnter( self.drag_data, touch.x, y, cef.DRAG_OPERATION_EVERY) self.is_drag_leave = False print("~~ DragTargetDragOver") self.browser.DragTargetDragOver( touch.x, y, cef.DRAG_OPERATION_EVERY) self.update_drag_icon(touch.x, y) else: if not self.is_drag_leave: self.is_drag_leave = True print("~~ DragTargetDragLeave") self.browser.DragTargetDragLeave() def is_inside_web_view(self, x, y): # When mouse is out of app window Kivy still generates move events # at the borders with x=0, x=width-1, y=0, y=height-1. if (0 < x < self.width-1) and (0 < y < self.height-1): return True return False def drag_ended(self): # Either success or cancelled. self.is_drag = False self.is_drag_leave = False del self.drag_data self.current_drag_operation = cef.DRAG_OPERATION_NONE self.update_drag_icon(None, None) print("~~ DragSourceSystemDragEnded") self.browser.DragSourceSystemDragEnded() drag_icon = None def update_drag_icon(self, x, y): if self.is_drag: if self.drag_icon: self.drag_icon.pos = self.flip_pos_vertical(x, y) else: image = self.drag_data.GetImage() width = image.GetWidth() height = image.GetHeight() abuffer = image.GetAsBitmap( 1.0, cef.CEF_COLOR_TYPE_BGRA_8888, cef.CEF_ALPHA_TYPE_PREMULTIPLIED) # noinspection PyArgumentList texture = Texture.create(size=(width, height)) texture.blit_buffer(abuffer, colorfmt='bgra', bufferfmt='ubyte') texture.flip_vertical() self.drag_icon = Rectangle(texture=texture, pos=self.flip_pos_vertical(x, y), size=(width, height)) self.canvas.add(self.drag_icon) elif self.drag_icon: self.canvas.remove(self.drag_icon) del self.drag_icon def flip_pos_vertical(self, x, y): half = self.height / 2 if y > half: y = half - (y-half) elif y < half: y = half + (half-y) # Additionally position drag icon to the center of mouse cursor y -= 20 x -= 20 return x, y class ClientHandler: def __init__(self, browserWidget): self.browserWidget = browserWidget def _fix_select_boxes(self, frame): # This is just a temporary fix, until proper Popup widgets # painting is implemented (PET_POPUP in OnPaint). Currently # there is no way to obtain a native window handle (GtkWindow # pointer) in Kivy, and this may cause things like context menus, # select boxes and plugins not to display correctly. Although, # this needs to be tested. The popup widget buffers are # available in a separate paint buffer, so they could positioned # freely so that it doesn't go out of the window. So the native # window handle might not necessarily be required to make it work # in most cases (99.9%). Though, this still needs testing to confirm. # -- # See this topic on the CEF Forum regarding the NULL window handle: # http://www.magpcss.org/ceforum/viewtopic.php?f=6&t=10851 # -- # See also a related topic on the Kivy-users group: # https://groups.google.com/d/topic/kivy-users/WdEQyHI5vTs/discussion # -- # The javascript select boxes library used: # http://marcj.github.io/jquery-selectBox/ # -- # Cannot use "file://" urls to load local resources, error: # | Not allowed to load local resource print("_fix_select_boxes()") resources_dir = os.path.join( os.path.dirname(os.path.abspath(__file__)), "kivy-select-boxes") if not os.path.exists(resources_dir): print("The kivy-select-boxes directory does not exist, " "select boxes fix won't be applied.") return js_file = os.path.join(resources_dir, "kivy-selectBox.js") js_content = "" with open(js_file, "r") as myfile: js_content = myfile.read() css_file = os.path.join(resources_dir, "kivy-selectBox.css") css_content = "" with open(css_file, "r") as myfile: css_content = myfile.read() css_content = css_content.replace("\r", "") css_content = css_content.replace("\n", "") jsCode = """ %(js_content)s var __kivy_temp_head = document.getElementsByTagName('head')[0]; var __kivy_temp_style = document.createElement('style'); __kivy_temp_style.type = 'text/css'; __kivy_temp_style.appendChild(document.createTextNode("%(css_content)s")); __kivy_temp_head.appendChild(__kivy_temp_style); """ % locals() frame.ExecuteJavascript( jsCode, "kivy_.py > ClientHandler > OnLoadStart > _fix_select_boxes()") def OnLoadStart(self, browser, frame, **_): self._fix_select_boxes(frame) browserWidget = browser.GetUserData("browserWidget") if browserWidget and browserWidget.keyboard_mode == "local": print("OnLoadStart(): injecting focus listeners for text controls") # The logic is similar to the one found in kivy-berkelium: # https://github.com/kivy/kivy-berkelium/blob/master/berkelium/__init__.py jsCode = """ var __kivy__keyboard_requested = false; function __kivy__keyboard_interval() { var element = document.activeElement; if (!element) { return; } var tag = element.tagName; var type = element.type; if (tag == "INPUT" && (type == "" || type == "text" || type == "password") || tag == "TEXTAREA") { if (!__kivy__keyboard_requested) { __kivy__request_keyboard(); __kivy__keyboard_requested = true; } return; } if (__kivy__keyboard_requested) { __kivy__release_keyboard(); __kivy__keyboard_requested = false; } } function __kivy__on_escape() { if (document.activeElement) { document.activeElement.blur(); } if (__kivy__keyboard_requested) { __kivy__release_keyboard(); __kivy__keyboard_requested = false; } } setInterval(__kivy__keyboard_interval, 100); """ frame.ExecuteJavascript( jsCode, "kivy_.py > ClientHandler > OnLoadStart") def OnLoadEnd(self, browser, **_): # Browser lost its focus after the LoadURL() and the # OnBrowserDestroyed() callback bug. When keyboard mode # is local the fix is in the request_keyboard() method. # Call it from OnLoadEnd only when keyboard mode is global. browserWidget = browser.GetUserData("browserWidget") if browserWidget and browserWidget.keyboard_mode == "global": browser.SendFocusEvent(True) def OnLoadingStateChange(self, is_loading, **_): print("OnLoadingStateChange(): isLoading = %s" % is_loading) # browserWidget = browser.GetUserData("browserWidget") def OnPaint(self, element_type, paint_buffer, **_): # print "OnPaint()" if element_type != cef.PET_VIEW: print "Popups aren't implemented yet" return # update buffer paint_buffer = paint_buffer.GetString(mode="bgra", origin="top-left") # update texture of canvas rectangle self.browserWidget.texture.blit_buffer( paint_buffer, colorfmt='bgra', bufferfmt='ubyte') self.browserWidget.update_rect() return True def GetViewRect(self, rect_out, **_): width, height = self.browserWidget.texture.size rect_out.append(0) rect_out.append(0) rect_out.append(width) rect_out.append(height) return True """ def GetRootScreenRect(self, rect_out, **_): width, height = self.browserWidget.texture.size rect_out.append(0) rect_out.append(0) rect_out.append(width) rect_out.append(height) return True def GetScreenRect(self, rect_out, **_): width, height = self.browserWidget.texture.size rect_out.append(0) rect_out.append(0) rect_out.append(width) rect_out.append(height) return True def GetScreenPoint(self, screen_coordinates_out, **kwargs): screen_coordinates_out.append(view_x) screen_coordinates_out.append(view_y) return True """ def OnJavascriptDialog(self, suppress_message_out, **_): suppress_message_out[0] = True return False def OnBeforeUnloadJavascriptDialog(self, callback, **_): callback.Continue(allow=True, userInput="") return True def StartDragging(self, drag_data, x, y, **_): print("~~ StartDragging") # Succession of d&d calls: # DragTargetDragEnter # DragTargetDragOver - in touch move event # DragTargetDragLeave - optional # DragSourceSystemDragEnded - optional, to cancel dragging # DragTargetDrop - on mouse up # DragSourceEndedAt - on mouse up # DragSourceSystemDragEnded - on mouse up print("~~ DragTargetDragEnter") self.browserWidget.browser.DragTargetDragEnter( drag_data, x, y, cef.DRAG_OPERATION_EVERY) self.browserWidget.is_drag = True self.browserWidget.is_drag_leave = False self.browserWidget.drag_data = drag_data self.browserWidget.current_drag_operation = \ cef.DRAG_OPERATION_NONE self.browserWidget.update_drag_icon(x, y) return True def UpdateDragCursor(self, **kwargs): # print("~~ UpdateDragCursor(): operation=%s" % operation) self.browserWidget.current_drag_operation = kwargs["operation"] class CefBrowserApp(App): def build(self): self.layout = BrowserLayout() return self.layout def on_stop(self): # This is required for a clean shutdown of CEF. self.layout.browser_widget.browser.CloseBrowser(True) del self.layout.browser_widget.browser if __name__ == '__main__': CefBrowserApp().run() cef.Shutdown() cefpython-49.0/src/linux/deb_pkg_deprecated/000077500000000000000000000000001334103266300211475ustar00rootroot00000000000000cefpython-49.0/src/linux/deb_pkg_deprecated/.gitignore000066400000000000000000000000451334103266300231360ustar00rootroot00000000000000/cefpython3-*/ /deb_archive/ *.tar.gzcefpython-49.0/src/linux/deb_pkg_deprecated/debian.postinst000066400000000000000000000020461334103266300242000ustar00rootroot00000000000000#!/bin/bash # Exit immediately if a command exits with a non-zero status set -e # Permissions for the executable files chmod 755 /usr/share/pyshared/cefpython3/cefclient chmod 755 /usr/share/pyshared/cefpython3/subprocess # Permissions for the examples - debug.log is created. # If you want to run the cefclient executable you may # also have to chmod 777 /usr/share/pyshared/cefpython3/. chmod 666 /usr/share/pyshared/cefpython3/debug.log chmod 666 /usr/share/pyshared/cefpython3/examples/debug.log chmod 666 /usr/share/pyshared/cefpython3/examples/wx/debug.log # This creates symbolic links in /usr/lib/pymodules/.../cefpython3/ # for all the files. This is no more required, as in make-deb.py # we're modify the deb archive and moving the /usr/lib/pyshared/.../ # .so files to the /usr/share/pyshared/.../ directory. Read the # comments in make-deb.py why it needs to be done so. # Let's keep the creation of symlinks for backwards compatibility. if which update-python-modules >/dev/null 2>&1; then update-python-modules python-cefpython3.public fi cefpython-49.0/src/linux/deb_pkg_deprecated/deps.txt000066400000000000000000000011621334103266300226430ustar00rootroot00000000000000gconf-service libasound2 (>= 1.0.23) libatk1.0-0 (>= 1.12.4) libc6 (>= 2.12) libcairo2 (>= 1.6.0) libcups2 (>= 1.4.0) libdbus-1-3 (>= 1.2.14) libexpat1 (>= 1.95.8) libfontconfig1 (>= 2.8.0) libfreetype6 (>= 2.3.9) libgcc1 (>= 1:4.1.1) libgconf-2-4 (>= 2.31.1) libgdk-pixbuf2.0-0 (>= 2.22.0) libglib2.0-0 (>= 2.26.0) libgtk2.0-0 (>= 2.24.0) libnspr4 (>= 1.8.0.10) libnss3 (>= 3.12.4) libpango1.0-0 (>= 1.14.0) libstdc++6 (>= 4.6) libx11-6 (>= 2:1.4.99.1) libxcomposite1 (>= 1:0.3-1) libxcursor1 (>> 1.1.2) libxdamage1 (>= 1:1.1) libxext6 libxfixes3 libxi6 (>= 2:1.2.99.4) libxrandr2 (>= 2:1.2.99.2) libxrender1 libxss1 libxtst6cefpython-49.0/src/linux/deb_pkg_deprecated/find-deps.py000066400000000000000000000157011334103266300233760ustar00rootroot00000000000000# Copyright (c) 2012-2014 The CEF Python authors. All rights reserved. # License: New BSD License. # Website: http://code.google.com/p/cefpython/ # This script finds dependencies. It fetches google chrome # debian package dependencies from src.chromium.org for # specific revision. Filters these dependencies with data # returned by ldd command. Saves results to deps.txt. import os import sys import re import platform import glob import subprocess def main(): branch = get_branch() revision = get_chromium_revision(branch) chrome_deps = get_chrome_deps(revision) cef_library_dependencies = get_cef_library_dependencies() cef_deps = get_cef_deps(cef_library_dependencies) final_deps = get_final_deps(chrome_deps, cef_deps) curdir = os.path.dirname(os.path.realpath(__file__)) with open(curdir+"/deps.txt", "w") as f: f.write("\n".join(final_deps)) log("Saved deps to deps.txt file") success = check_final_deps(final_deps) if not success: sys.exit(1) def log(msg): print("[dependencies.py] %s" % msg) def fetch_url(url): if sys.version_info[0] == 2: import urllib2 try: urlfile = urllib2.urlopen(url) except: # 404 for example return None return urlfile.read() else: import urllib.request try: urlfile = urllib.request.urlopen(url) except: # 404 for example return None return urlfile.read() def get_branch(): curdir = os.path.dirname(os.path.realpath(__file__)) with open(curdir+"/../../BUILD_COMPATIBILITY.txt") as f: m = re.search(r"\d+\.\d+\.(\d+)\.\d+", f.read()) branch = m.group(1) log("branch = %s" % branch) return branch def get_chromium_revision(branch): # TODO: revision not needed anymore, see new GIT link in get_chrome_deps() url = "http://src.chromium.org/viewvc" \ "/chrome/branches/%s/src/chrome/VERSION" % branch contents = fetch_url(url) if not contents: raise Exception("Failed fetching url: %s" % url) m = re.search(r"revision=(\d+)", contents) revision = m.group(1) log("chromium revision = %s" % revision) return revision def get_chrome_deps(revision): # TODO: new GIT link: https://chromium.googlesource.com/chromium .. # /src/+/51.0.2704.104/chrome/installer/linux/debian/expected_deps_x64 # Currently works only with SVN up to Chrome revision 293233. base_url = "http://src.chromium.org/svn/trunk/src" \ "/chrome/installer/linux/debian" url = base_url+"/expected_deps?p=%s" % revision contents = fetch_url(url) if not contents: url = base_url+"/expected_deps_x64?p=%s" % revision contents = fetch_url(url) if not contents: raise Exception("Failed fetching url: %s" % url) contents = contents.strip() deps = contents.splitlines() for i, dep in enumerate(deps): deps[i] = dep.strip() deps.sort(key = lambda s: s.lower()); log("Found %d Chrome deps" % len(deps)) print("-" * 80) print("\n".join(deps)) print("-" * 80) return deps def get_cef_library_dependencies(): # Chrome deps != library dependencies # deps = package dependencies (for apt-get install) # library dependencies -> a package with such name may not exist curdir = os.path.dirname(os.path.realpath(__file__)) bits = platform.architecture()[0] assert (bits == "32bit" or bits == "64bit") binaries_dir = curdir+"/../binaries_%s" % bits libraries = glob.glob(binaries_dir+"/*.so") assert(len(libraries)) log("Found %d CEF libraries" % (len(libraries))) all_dependencies = [] for library in libraries: library = os.path.abspath(library) dependencies = get_library_dependencies(library) all_dependencies = all_dependencies + dependencies all_dependencies = remove_duplicate_dependencies(all_dependencies) log("Found %d all CEF library dependencies combined" \ % len(all_dependencies)) return all_dependencies def remove_duplicate_dependencies(dependencies): unique = [] for dependency in dependencies: if dependency not in unique: unique.append(dependency) return unique def get_library_dependencies(library): contents = subprocess.check_output("ldd %s" % library, shell=True) contents = contents.strip() lines = contents.splitlines() dependencies = [] for line in lines: m = re.search(r"([^/\s=>]+).so[.\s]", line) dependencies.append(m.group(1)) dependencies.sort(key = lambda s: s.lower()); log("Found %d dependencies in %s:" % \ (len(dependencies), os.path.basename(library))) print("-" * 80) print("\n".join(dependencies)) print("-" * 80) return dependencies def get_cef_deps(dependencies): cef_deps = [] for dependency in dependencies: if package_exists(dependency): cef_deps.append(dependency) log("Found %d CEF deps for which package exists:" % len(cef_deps)) print("-" * 80) print("\n".join(cef_deps)) print("-" * 80) return cef_deps def package_exists(package): try: devnull = open('/dev/null', 'w') contents = subprocess.check_output("dpkg -s %s" % package, stderr=devnull, shell=True) devnull.close() except subprocess.CalledProcessError, e: return False if "install ok installed" in contents: return True print("**PROBABLY ERROR OCCURED** while calling: %s" % "dpkg -s "+package) return False def get_final_deps(chrome_deps, cef_deps): final_deps = chrome_deps chrome_deps_names = [] for chrome_dep in chrome_deps: chrome_dep_name = get_chrome_dep_name(chrome_dep) chrome_deps_names.append(chrome_dep_name) for cef_dep in cef_deps: if cef_dep not in chrome_deps_names: final_deps.append(cef_dep) log("Found %d CEF deps that were not listed in Chrome deps" % \ (len(final_deps)-len(chrome_deps)) ) log("Found %d final deps:" % len(final_deps)) print("-" * 80) print("\n".join(final_deps)) print("-" * 80) return final_deps def get_chrome_dep_name(dep): # Eg. libxcomposite1 (>= 1:0.3-1) ===> libxcomposite1 dep = re.sub(r"\([^\(]+\)", "", dep) dep = dep.strip() return dep def check_final_deps(deps): # Check if all deps packages are installed deps_not_installed = [] for dep in deps: dep_name = get_chrome_dep_name(dep) if not package_exists(dep_name): deps_not_installed.append(dep_name) if len(deps_not_installed) == 0: log("Everything is OK. All deps are found to be installed.") return True else: log("Found %d deps that are currently not installed:" % \ len(deps_not_installed)) print("-" * 80) print("\n".join(deps_not_installed)) print("-" * 80) log("ERROR") return False if __name__ == "__main__": main() cefpython-49.0/src/linux/deb_pkg_deprecated/make-deb.py000066400000000000000000000263661334103266300232030ustar00rootroot00000000000000# Copyright (c) 2012-2014 The CEF Python authors. All rights reserved. # License: New BSD License. # Website: http://code.google.com/p/cefpython/ """ Create a Debian Package. Required dependencies: sudo apt-get install python-support sudo apt-get install python-pip sudo pip install stdeb==0.6.0 """ import subprocess import os, sys import platform import argparse import re import shutil # ----------------------------------------------------------------------------- # Globals BITS = platform.architecture()[0] assert (BITS == "32bit" or BITS == "64bit") ARCHITECTURE = "i386" if (BITS == "32bit") else "amd64" if BITS == "32bit": LINUX_BITS = "linux32" else: LINUX_BITS = "linux64" PACKAGE_NAME = "cefpython3" PYTHON_NAME ="python2.7" # Directory name in deb archive HOMEPAGE = "https://code.google.com/p/cefpython/" MAINTAINER = "Czarek Tomczak " DESCRIPTION_EXTENDED = \ """ CEF Python 3 is a python library for embedding the Chromium browser. It uses the Chromium Embedded Framework (CEF) internally. Examples of embedding are available for many GUI toolkits, including wxPython, PyGTK, PyQt, PySide, Kivy and PyWin32. """ COPYRIGHT = \ """Format: http://www.debian.org/doc/packaging-manuals/copyright-format/1.0/ Name: cefpython3 Maintainer: %s Source: %s Copyright: 2012-2014 The CEF Python authors License: BSD 3-Clause Files: * Copyright: 2012-2014 The CEF Python authors License: BSD 3-Clause """ % (MAINTAINER, HOMEPAGE) PYTHON_VERSION_WITH_DOT = (str(sys.version_info.major) + "." + str(sys.version_info.minor)) VERSION = None # cefpython/linux/installer INSTALLER = os.path.dirname(os.path.abspath(__file__)) # installer/cefpython3-31.0-linux-64bit-setup/ DISTUTILS_SETUP = None # deb_dist/ DEB_DIST = None # deb_dist/cefpython3-31.0/ DEB_DIST_PACKAGE = None # deb_dist/cefpython3-31.0/debian/ DEBIAN = None # deb_dist/cefpython3-31.0/debian/python-cefpython3/ DEBIAN_PACKAGE = None # ----------------------------------------------------------------------------- def log(msg): print("[make-deb.py] %s" % msg) def replace_in_file(f_path, s_what, s_with): contents = "" with open(f_path, "r") as f: contents = f.read() assert contents, ("Failed reading file: %s" % f_path) contents = contents.replace(s_what, s_with) with open(f_path, "w") as f: f.write(contents) def remove_directories_from_previous_run(): if os.path.exists(DISTUTILS_SETUP): log("The Distutils setup directory already exists, removing..") shutil.rmtree(DISTUTILS_SETUP) if os.path.exists(INSTALLER+"/deb_dist/"): log("The deb_dist/ directory already exists, removing..") shutil.rmtree(INSTALLER+"/deb_dist/") if os.path.exists(INSTALLER+"/deb_archive/"): log("The deb_archive/ directory already exists, removing..") shutil.rmtree(INSTALLER+"/deb_archive/") def create_distutils_setup_package(): log("Creating Distutils setup package") subprocess.call("%s %s/make-setup.py -v %s" % \ (sys.executable, INSTALLER, VERSION), shell=True) assert os.path.exists(DISTUTILS_SETUP),\ "Distutils Setup directory not found" def modify_control_file(): log("Modyfing debian control file") control_file = DEBIAN+"/control" # Read contents with open(control_file, "r") as f: contents = f.read() # Set architecture to i386 or amd64 contents = contents.replace("Architecture: all", "Architecture: %s" % ARCHITECTURE) # Extend the Package section, remove the two ending new lines contents = re.sub("[\r\n]+$", "", contents) contents += "\n" # Extend description description = DESCRIPTION_EXTENDED description = re.sub("[\r\n]+", "\n", description) description = re.sub("\n$", "", description) contents += "%s\n" % description # Other fields contents += "Version: %s-1\n" % VERSION contents += "Maintainer: %s\n" % MAINTAINER contents += "Homepage: %s\n" % HOMEPAGE # Control file should end with two new lines contents += "\n" with open(control_file, "w") as f: f.write(contents) def create_copyright_file(): # The license is "Unknown" when opening deb package in # Ubuntu Software Center. It's a known bug: # https://bugs.launchpad.net/ubuntu/+source/software-center/+bug/435183 log("Creating debian copyright file") copyright = COPYRIGHT copyright = re.sub("[\r\n]", "\n", copyright) copyright += "\n" copyright += "License: BSD 3-clause\n" with open(INSTALLER+"/../../../License", "r") as f: license = f.readlines() for line in license: if not len(re.sub("\s+", "", line)): copyright += " .\n" else: copyright += " "+line.rstrip()+"\n" copyright += "\n" with open(DEBIAN+"/copyright", "w") as f: f.write(copyright) def copy_postinst_script(): # When creating .postinst file in the debian directory, # it will overwrite the default postinst script created # by dh_pysupport, its contents are: # ----------------------------------------------------- # if which update-python-modules >/dev/null 2>&1; then # update-python-modules python-cefpython3.public # fi # ----------------------------------------------------- # The command above creates symlinks for libraries and # executables, so that they appear to be in one directory. # CEF executable requires that libcef.so and the subprocess # executable are in the same directory. # This solution does not to work correctly in CEF3 branch # 1650, so we will have to put .so libraries along with # other files in a real single directory. log("Copying .postinst script") shutil.copy(INSTALLER+"/debian.postinst", DEBIAN+"/python-%s.postinst" % (PACKAGE_NAME)) def create_debian_source_package(): log("Creating Debian source package using stdeb") os.chdir(DISTUTILS_SETUP) shutil.copy("../stdeb.cfg.template", "stdeb.cfg") stdeb_cfg_add_deps("stdeb.cfg") subprocess.call("%s setup.py --command-packages=stdeb.command sdist_dsc"\ % (sys.executable,), shell=True) def stdeb_cfg_add_deps(stdeb_cfg): log("Adding deps to stdeb.cfg") with open(INSTALLER+"/deps.txt", "r") as f: deps = f.read() deps = deps.strip() deps = deps.splitlines() for i, dep in enumerate(deps): deps[i] = dep.strip() deps = ", ".join(deps) with open(stdeb_cfg, "a") as f: f.write("\nDepends: %s" % deps) def deb_dist_cleanup(): # Move the deb_dist/ directory and remove unnecessary files log("Preparing the deb_dist directory") os.system("mv %s %s"\ % (DISTUTILS_SETUP+"/deb_dist", INSTALLER+"/deb_dist")) os.system("rm -rf %s" % DISTUTILS_SETUP) # Paths global DEB_DIST, DEB_DIST_PACKAGE, DEBIAN, DEBIAN_PACKAGE DEB_DIST = INSTALLER+"/deb_dist" DEB_DIST_PACKAGE = DEB_DIST+"/"+PACKAGE_NAME+"-"+VERSION DEBIAN = DEB_DIST_PACKAGE+"/debian" DEBIAN_PACKAGE = DEBIAN+"/python-"+PACKAGE_NAME # Remove unnecessary files os.chdir(DEB_DIST) os.system("rm *.gz") os.system("rm *.dsc") def create_debian_binary_package(): os.chdir(DEB_DIST_PACKAGE) # Will create .deb .dsc .gz in the upper directory DEB_DIST subprocess.call("dpkg-buildpackage -rfakeroot -uc -us", shell=True) def modify_deb_archive(): # CEF branch 1650 doesn't work when the .so files do not reside # in the same directory as the subprocess executable. The symlinks # created in /usr/lib/pymodules/ do not help. After launching # CEF and webpage being displayed, the CEF renderer process # crashes after a moment. The solution is to modify the deb # archive, move the /usr/lib/pyshared/.../*.so libraries to # the /usr/share/pyshared/.../ directory. Also some files with # hardcoded paths to /usr/lub/pyshared/ need to be modified # (eg. DEBIAN/md5sums, python-support/python-cefpython3.public). log("Modifying the deb archive") # Paths deb_archive_name = "python-%s_%s-1_%s.deb" \ % (PACKAGE_NAME, VERSION, ARCHITECTURE) deb_archive_dir = INSTALLER+"/deb_archive" # Move the deb archive to the deb_archive/ directory log("Moving the deb archive") os.system("mkdir %s" % deb_archive_dir) os.system("mv %s %s" % (DEB_DIST+"/"+deb_archive_name,\ deb_archive_dir+"/"+deb_archive_name)) # Remove the deb_dist/ directory os.system("rm -rf %s" % DEB_DIST) # Extract the deb archive log("Extracting the deb archive") os.chdir(deb_archive_dir) # Extract the usr/ directory os.system("dpkg-deb -x %s ." % deb_archive_name) # Extract the DEBIAN/ directory os.system("dpkg-deb -e %s" % deb_archive_name) # Remove the deb archive that was extracted os.system("rm %s" % deb_archive_name) # Move the .so files from the ./usr/lib/pyshared/.../ directory # to the ./usr/share/pyshared/.../ directory. Also remove the # ./usr/lib/ directory. log("Moving the .so libraries") lib_pyshared = "./usr/lib/pyshared/%s/%s" \ % (PYTHON_NAME, PACKAGE_NAME) share_pyshared = "./usr/share/pyshared/%s" % PACKAGE_NAME os.system("mv %s/*.so %s/" % (lib_pyshared, share_pyshared)) os.system("rm -rf ./usr/lib/") # Modify also the paths in some text files. # The paths do not start with "/" on purpose. In the md5sums # file the paths are relative. In the python-cefpython3.public # file paths are absolute. log("Modifying paths in the text files") old_path = "usr/lib/pyshared/%s/%s/" % (PYTHON_NAME, PACKAGE_NAME) new_path = "usr/share/pyshared/%s/" % PACKAGE_NAME md5sums_file = "./DEBIAN/md5sums" cefpython3_public_file = "./usr/share/python-support/python-%s.public" \ % PACKAGE_NAME old_md5sum = subprocess.check_output("md5sum %s | cut -c 1-32" \ % cefpython3_public_file, shell=True).strip() # Modify paths in the text files replace_in_file(md5sums_file, old_path, new_path) replace_in_file(cefpython3_public_file, old_path, new_path) # Correct md5 sum for the python-cefpython3.public file new_md5sum = subprocess.check_output("md5sum %s | cut -c 1-32" \ % cefpython3_public_file, shell=True).strip() replace_in_file(md5sums_file, old_md5sum, new_md5sum) # Create deb archive from the modified ./DEBIAN/ and # ./usr/ directories. log("Creating deb archive from the modified files") os.system("fakeroot dpkg-deb -b . ./%s" % deb_archive_name) def main(): # Command line options parser = argparse.ArgumentParser(usage="%(prog)s [options]") parser.add_argument("-v", "--version", help="cefpython version", required=True) args = parser.parse_args() assert re.search(r"^\d+\.\d+$", args.version), ( "Invalid version string") # Version global VERSION VERSION = args.version # Paths global DISTUTILS_SETUP DISTUTILS_SETUP = INSTALLER+"/"+PACKAGE_NAME+"-"+args.version+"-"+\ LINUX_BITS+"-setup" remove_directories_from_previous_run() create_distutils_setup_package() create_debian_source_package() deb_dist_cleanup() modify_control_file() create_copyright_file() copy_postinst_script() create_debian_binary_package() modify_deb_archive() log("DONE") if __name__ == "__main__": main() cefpython-49.0/src/linux/deb_pkg_deprecated/stdeb.cfg.template000066400000000000000000000000401334103266300245350ustar00rootroot00000000000000[DEFAULT] XS-Python-Version: 2.7cefpython-49.0/src/mac/000077500000000000000000000000001334103266300147755ustar00rootroot00000000000000cefpython-49.0/src/mac/mac64.sh000066400000000000000000000002531334103266300162430ustar00rootroot00000000000000#!/bin/bash PATH=/usr/local/bin:$PATH export PATH CEF_CCFLAGS="-arch x86_64" export CEF_CCFLAGS ARCHFLAGS="-arch x86_64" export ARCHFLAGS export CC=gcc export CXX=g++ cefpython-49.0/src/network_error.pyx000066400000000000000000000057121334103266300177060ustar00rootroot00000000000000# Copyright (c) 2013 CEF Python, see the Authors file. # All rights reserved. Licensed under BSD 3-clause license. # Project website: https://github.com/cztomczak/cefpython # noinspection PyUnresolvedReferences cimport cef_types # Network error constants. ERR_NONE = cef_types.ERR_NONE ERR_FAILED = cef_types.ERR_FAILED ERR_ABORTED = cef_types.ERR_ABORTED ERR_INVALID_ARGUMENT = cef_types.ERR_INVALID_ARGUMENT ERR_INVALID_HANDLE = cef_types.ERR_INVALID_HANDLE ERR_FILE_NOT_FOUND = cef_types.ERR_FILE_NOT_FOUND ERR_TIMED_OUT = cef_types.ERR_TIMED_OUT ERR_FILE_TOO_BIG = cef_types.ERR_FILE_TOO_BIG ERR_UNEXPECTED = cef_types.ERR_UNEXPECTED ERR_ACCESS_DENIED = cef_types.ERR_ACCESS_DENIED ERR_NOT_IMPLEMENTED = cef_types.ERR_NOT_IMPLEMENTED ERR_CONNECTION_CLOSED = cef_types.ERR_CONNECTION_CLOSED ERR_CONNECTION_RESET = cef_types.ERR_CONNECTION_RESET ERR_CONNECTION_REFUSED = cef_types.ERR_CONNECTION_REFUSED ERR_CONNECTION_ABORTED = cef_types.ERR_CONNECTION_ABORTED ERR_CONNECTION_FAILED = cef_types.ERR_CONNECTION_FAILED ERR_NAME_NOT_RESOLVED = cef_types.ERR_NAME_NOT_RESOLVED ERR_INTERNET_DISCONNECTED = cef_types.ERR_INTERNET_DISCONNECTED ERR_SSL_PROTOCOL_ERROR = cef_types.ERR_SSL_PROTOCOL_ERROR ERR_ADDRESS_INVALID = cef_types.ERR_ADDRESS_INVALID ERR_ADDRESS_UNREACHABLE = cef_types.ERR_ADDRESS_UNREACHABLE ERR_SSL_CLIENT_AUTH_CERT_NEEDED = cef_types.ERR_SSL_CLIENT_AUTH_CERT_NEEDED ERR_TUNNEL_CONNECTION_FAILED = cef_types.ERR_TUNNEL_CONNECTION_FAILED ERR_NO_SSL_VERSIONS_ENABLED = cef_types.ERR_NO_SSL_VERSIONS_ENABLED ERR_SSL_VERSION_OR_CIPHER_MISMATCH = cef_types.ERR_SSL_VERSION_OR_CIPHER_MISMATCH ERR_SSL_RENEGOTIATION_REQUESTED = cef_types.ERR_SSL_RENEGOTIATION_REQUESTED ERR_CERT_COMMON_NAME_INVALID = cef_types.ERR_CERT_COMMON_NAME_INVALID ERR_CERT_DATE_INVALID = cef_types.ERR_CERT_DATE_INVALID ERR_CERT_AUTHORITY_INVALID = cef_types.ERR_CERT_AUTHORITY_INVALID ERR_CERT_CONTAINS_ERRORS = cef_types.ERR_CERT_CONTAINS_ERRORS ERR_CERT_NO_REVOCATION_MECHANISM = cef_types.ERR_CERT_NO_REVOCATION_MECHANISM ERR_CERT_UNABLE_TO_CHECK_REVOCATION = cef_types.ERR_CERT_UNABLE_TO_CHECK_REVOCATION ERR_CERT_REVOKED = cef_types.ERR_CERT_REVOKED ERR_CERT_INVALID = cef_types.ERR_CERT_INVALID ERR_CERT_END = cef_types.ERR_CERT_END ERR_INVALID_URL = cef_types.ERR_INVALID_URL ERR_DISALLOWED_URL_SCHEME = cef_types.ERR_DISALLOWED_URL_SCHEME ERR_UNKNOWN_URL_SCHEME = cef_types.ERR_UNKNOWN_URL_SCHEME ERR_TOO_MANY_REDIRECTS = cef_types.ERR_TOO_MANY_REDIRECTS ERR_UNSAFE_REDIRECT = cef_types.ERR_UNSAFE_REDIRECT ERR_UNSAFE_PORT = cef_types.ERR_UNSAFE_PORT ERR_INVALID_RESPONSE = cef_types.ERR_INVALID_RESPONSE ERR_INVALID_CHUNKED_ENCODING = cef_types.ERR_INVALID_CHUNKED_ENCODING ERR_METHOD_NOT_SUPPORTED = cef_types.ERR_METHOD_NOT_SUPPORTED ERR_UNEXPECTED_PROXY_AUTH = cef_types.ERR_UNEXPECTED_PROXY_AUTH ERR_EMPTY_RESPONSE = cef_types.ERR_EMPTY_RESPONSE ERR_RESPONSE_HEADERS_TOO_BIG = cef_types.ERR_RESPONSE_HEADERS_TOO_BIG ERR_CACHE_MISS = cef_types.ERR_CACHE_MISS ERR_INSECURE_RESPONSE = cef_types.ERR_INSECURE_RESPONSE cefpython-49.0/src/paint_buffer.pyx000066400000000000000000000071111334103266300174430ustar00rootroot00000000000000# Copyright (c) 2013 CEF Python, see the Authors file. # All rights reserved. Licensed under BSD 3-clause license. # Project website: https://github.com/cztomczak/cefpython include "cefpython.pyx" cdef PaintBuffer CreatePaintBuffer(const void* buffer_, int width, int height): cdef PaintBuffer paintBuffer = PaintBuffer() paintBuffer.buffer = buffer_ paintBuffer.width = width paintBuffer.height = height paintBuffer.length = width*height*4 return paintBuffer cdef class PaintBuffer: cdef const void* buffer cdef public int width cdef public int height cdef public Py_ssize_t length cpdef uintptr_t GetPointer(self) except *: # BEFORE MODIFYING CODE: # There is an exact copy of this method named "GetIntPointer" # (deprecated). return self.buffer cpdef object GetBytes(self, str mode="bgra", str origin="top-left"): # BEFORE MODIFYING CODE: # There is an exact copy of this method named "GetString" (deprecated). cdef void* dest cdef py_bool dest_alloced = False cdef object ret origin = origin.lower() mode = mode.lower() assert origin in ("top-left", "bottom-left"), "Invalid origin" assert mode in ("bgra", "rgba"), "Invalid mode" # To get rid of a Cython warning: # | '__pyx_v_dest' may be used uninitialized in this function dest = malloc(0) if mode == "rgba": if not dest_alloced: dest = malloc(self.length) dest_alloced = True SwapBufferFromBgraToRgba(dest, self.buffer, self.width, self.height) if origin == "bottom-left": if not dest_alloced: dest = malloc(self.length) dest_alloced = True FlipBufferUpsideDown(dest, self.buffer, self.width, self.height) if dest_alloced: ret = (dest)[:self.length] free(dest) return ret else: return (self.buffer)[:self.length] # ---- DEPRECATED --------------------------------------------------------- # TODO: remove deprecated methods from API reference during next release. # TODO: remove deprecated methods after users had time to update code. cpdef uintptr_t GetIntPointer(self) except *: """@deprecated.""" return self.buffer cpdef object GetString(self, str mode="bgra", str origin="top-left"): """@deprecated.""" cdef void* dest cdef py_bool dest_alloced = False cdef object ret origin = origin.lower() mode = mode.lower() assert origin in ("top-left", "bottom-left"), "Invalid origin" assert mode in ("bgra", "rgba"), "Invalid mode" # To get rid of a Cython warning: # | '__pyx_v_dest' may be used uninitialized in this function dest = malloc(0) if mode == "rgba": if not dest_alloced: dest = malloc(self.length) dest_alloced = True SwapBufferFromBgraToRgba(dest, self.buffer, self.width, self.height) if origin == "bottom-left": if not dest_alloced: dest = malloc(self.length) dest_alloced = True FlipBufferUpsideDown(dest, self.buffer, self.width, self.height) if dest_alloced: ret = (dest)[:self.length] free(dest) return ret else: return (self.buffer)[:self.length]cefpython-49.0/src/process_message_utils.pyx000066400000000000000000000367251334103266300214160ustar00rootroot00000000000000# Copyright (c) 2013 CEF Python, see the Authors file. # All rights reserved. Licensed under BSD 3-clause license. # Project website: https://github.com/cztomczak/cefpython # CefListValue->SetXxxx() functions need first param to be be cast # to (int) because GetSize() returns size_t and generates a warning # when compiling on VS2008 for x64 platform. Issue reported here: # https://github.com/cztomczak/cefpython/issues/165 # Here in pyx you also need to convert Py_ssize_t returned by # enumerate(), to an int. include "cefpython.pyx" # ----------------------------------------------------------------------------- # CEF values to Python values # ----------------------------------------------------------------------------- cdef object CheckForCefPythonMessageHash(CefRefPtr[CefBrowser] cefBrowser, py_string pyString): # A javascript callback from the Renderer process is sent as a string. # TODO: this could be sent using CefBinaryNamedString in the future, # see this topic "Sending custom data types using process messaging": # http://www.magpcss.org/ceforum/viewtopic.php?f=6&t=10881 cdef py_string cefPythonMessageHash = "####cefpython####" cdef JavascriptCallback jsCallback cdef py_string jsonData cdef object message if pyString.startswith(cefPythonMessageHash): jsonData = pyString[len(cefPythonMessageHash):] message = json.loads(jsonData) if message and type(message) == dict and ("what" in message) \ and message["what"] == "javascript-callback": jsCallback = CreateJavascriptCallback( message["callbackId"], cefBrowser, message["frameId"], message["functionName"]) return jsCallback return pyString cdef list CefListValueToPyList( CefRefPtr[CefBrowser] cefBrowser, CefRefPtr[CefListValue] cefListValue, int nestingLevel=0): assert cefListValue.get().IsValid(), "cefListValue is invalid" if nestingLevel > 8: raise Exception("CefListValueToPyList(): max nesting level (8)" " exceeded") cdef int index cdef int size = int(cefListValue.get().GetSize()) cdef cef_types.cef_value_type_t valueType cdef list ret = [] cdef CefRefPtr[CefBinaryValue] binaryValue cdef uint32 uint32_value cdef int64 int64_value cdef object originallyString for index in range(0, size): valueType = cefListValue.get().GetType(index) if valueType == cef_types.VTYPE_NULL: ret.append(None) elif valueType == cef_types.VTYPE_BOOL: ret.append(bool(cefListValue.get().GetBool(index))) elif valueType == cef_types.VTYPE_INT: ret.append(cefListValue.get().GetInt(index)) elif valueType == cef_types.VTYPE_DOUBLE: ret.append(cefListValue.get().GetDouble(index)) elif valueType == cef_types.VTYPE_STRING: originallyString = CefToPyString( cefListValue.get().GetString(index)) originallyString = CheckForCefPythonMessageHash(cefBrowser, originallyString) ret.append(originallyString) elif valueType == cef_types.VTYPE_DICTIONARY: ret.append(CefDictionaryValueToPyDict( cefBrowser, cefListValue.get().GetDictionary(index), nestingLevel + 1)) elif valueType == cef_types.VTYPE_LIST: ret.append(CefListValueToPyList( cefBrowser, cefListValue.get().GetList(index), nestingLevel + 1)) elif valueType == cef_types.VTYPE_BINARY: binaryValue = cefListValue.get().GetBinary(index) if binaryValue.get().GetSize() == sizeof(uint32_value): binaryValue.get().GetData( &uint32_value, sizeof(uint32_value), 0) ret.append(uint32_value) elif binaryValue.get().GetSize() == sizeof(int64_value): binaryValue.get().GetData( &int64_value, sizeof(int64_value), 0) ret.append(int64_value) else: raise Exception("Unknown binary value, size=%s" % \ binaryValue.get().GetSize()) else: raise Exception("Unknown value type=%s" % valueType) return ret cdef dict CefDictionaryValueToPyDict( CefRefPtr[CefBrowser] cefBrowser, CefRefPtr[CefDictionaryValue] cefDictionaryValue, int nestingLevel=0): assert cefDictionaryValue.get().IsValid(), "cefDictionaryValue is invalid" if nestingLevel > 8: raise Exception("CefDictionaryValueToPyDict(): max nesting level (8)" " exceeded") cdef cpp_vector[CefString] keyList cefDictionaryValue.get().GetKeys(keyList) cdef cef_types.cef_value_type_t valueType cdef dict ret = {} cdef cpp_vector[CefString].iterator iterator = keyList.begin() cdef CefString cefKey cdef py_string pyKey cdef CefRefPtr[CefBinaryValue] binaryValue cdef uint32 uint32_value cdef int64 int64_value cdef object originallyString while iterator != keyList.end(): cefKey = deref(iterator) pyKey = CefToPyString(cefKey) preinc(iterator) valueType = cefDictionaryValue.get().GetType(cefKey) if valueType == cef_types.VTYPE_NULL: ret[pyKey] = None elif valueType == cef_types.VTYPE_BOOL: ret[pyKey] = bool(cefDictionaryValue.get().GetBool(cefKey)) elif valueType == cef_types.VTYPE_INT: ret[pyKey] = cefDictionaryValue.get().GetInt(cefKey) elif valueType == cef_types.VTYPE_DOUBLE: ret[pyKey] = cefDictionaryValue.get().GetDouble(cefKey) elif valueType == cef_types.VTYPE_STRING: originallyString = CefToPyString( cefDictionaryValue.get().GetString(cefKey)) originallyString = CheckForCefPythonMessageHash(cefBrowser, originallyString) ret[pyKey] = originallyString elif valueType == cef_types.VTYPE_DICTIONARY: ret[pyKey] = CefDictionaryValueToPyDict( cefBrowser, cefDictionaryValue.get().GetDictionary(cefKey), nestingLevel + 1) elif valueType == cef_types.VTYPE_LIST: ret[pyKey] = CefListValueToPyList( cefBrowser, cefDictionaryValue.get().GetList(cefKey), nestingLevel + 1) elif valueType == cef_types.VTYPE_BINARY: binaryValue = cefDictionaryValue.get().GetBinary(cefKey) if binaryValue.get().GetSize() == sizeof(uint32_value): binaryValue.get().GetData( &uint32_value, sizeof(uint32_value), 0) ret[pyKey] = uint32_value elif binaryValue.get().GetSize() == sizeof(int64_value): binaryValue.get().GetData( &int64_value, sizeof(int64_value), 0) ret[pyKey] = int64_value else: raise Exception("Unknown binary value, size=%s" % \ binaryValue.get().GetSize()) else: raise Exception("Unknown value type = %s" % valueType) return ret # ----------------------------------------------------------------------------- # Python values to CEF values # ----------------------------------------------------------------------------- cdef CefRefPtr[CefListValue] PyListToCefListValue( int browserId, object frameId, list pyList, int nestingLevel=0) except *: if nestingLevel > 8: raise Exception("PyListToCefListValue(): max nesting level (8)" " exceeded") cdef type valueType cdef CefRefPtr[CefListValue] ret = CefListValue_Create() cdef CefRefPtr[CefBinaryValue] binaryValue cdef int index for index_size_t, value in enumerate(pyList): index = int(index_size_t) valueType = type(value) if valueType == type(None): ret.get().SetNull(index) elif valueType == bool: ret.get().SetBool(index, bool(value)) elif valueType == int: ret.get().SetInt(index, int(value)) elif valueType == long: # Int32 range is -2147483648..2147483647, we've increased the # minimum size by one as Cython was throwing a warning: # "unary minus operator applied to unsigned type, result still # unsigned". if -2147483647 <= value <= 2147483647: ret.get().SetInt(index, int(value)) else: # Long values become strings. ret.get().SetString(index, PyToCefStringValue(str(value))) elif valueType == float: ret.get().SetDouble(index, float(value)) elif valueType == bytes or valueType == str \ or (PY_MAJOR_VERSION < 3 and valueType == unicode): # The unicode type is not defined in Python 3. ret.get().SetString(index, PyToCefStringValue(str(value))) elif valueType == dict: ret.get().SetDictionary(index, PyDictToCefDictionaryValue( browserId, frameId, value, nestingLevel + 1)) elif valueType == list or valueType == tuple: if valueType == tuple: value = list(value) ret.get().SetList(index, PyListToCefListValue( browserId, frameId, value, nestingLevel + 1)) elif IsFunctionOrMethod(valueType): ret.get().SetBinary(index, PutPythonCallback( browserId, frameId, value)) else: # Raising an exception probably not a good idea, why # terminate application when we can cast it to string, # the data may contain some non-standard object that is # probably redundant, but casting to string will do no harm. # This will handle the "type" type. ret.get().SetString(index, PyToCefStringValue(str(value))) return ret cdef void PyListToExistingCefListValue( int browserId, object frameId, list pyList, CefRefPtr[CefListValue] cefListValue, int nestingLevel=0) except *: # When sending process messages you must use an existing # CefListValue, see browser.pyx > SendProcessMessage(). if nestingLevel > 8: raise Exception("PyListToCefListValue(): max nesting level (8)" " exceeded") cdef type valueType cdef CefRefPtr[CefListValue] newCefListValue cdef int index for index_size_t, value in enumerate(pyList): index = int(index_size_t) valueType = type(value) if valueType == type(None): cefListValue.get().SetNull(index) elif valueType == bool: cefListValue.get().SetBool(index, bool(value)) elif valueType == int: cefListValue.get().SetInt(index, int(value)) elif valueType == long: # Int32 range is -2147483648..2147483647, we've increased the # minimum size by one as Cython was throwing a warning: # "unary minus operator applied to unsigned type, result still # unsigned". if -2147483647 <= value <= 2147483647: cefListValue.get().SetInt(index, int(value)) else: # Long values become strings. cefListValue.get().SetString(index, PyToCefStringValue(str( value))) elif valueType == float: cefListValue.get().SetDouble(index, float(value)) elif valueType == bytes or valueType == str \ or (PY_MAJOR_VERSION < 3 and valueType == unicode): # The unicode type is not defined in Python 3. cefListValue.get().SetString(index, PyToCefStringValue(str(value))) elif valueType == dict: cefListValue.get().SetDictionary(index, PyDictToCefDictionaryValue( browserId, frameId, value, nestingLevel + 1)) elif valueType == list or valueType == tuple: if valueType == tuple: value = list(value) newCefListValue = CefListValue_Create() PyListToExistingCefListValue(browserId, frameId, value, newCefListValue, nestingLevel + 1) cefListValue.get().SetList(index, newCefListValue) elif IsFunctionOrMethod(valueType): cefListValue.get().SetBinary(index, PutPythonCallback( browserId, frameId, value)) else: # Raising an exception probably not a good idea, why # terminate application when we can cast it to string, # the data may contain some non-standard object that is # probably redundant, but casting to string will do no harm. # This will handle the "type" type. cefListValue.get().SetString(index, PyToCefStringValue(str(value))) cdef CefRefPtr[CefDictionaryValue] PyDictToCefDictionaryValue( int browserId, object frameId, dict pyDict, int nestingLevel=0) except *: if nestingLevel > 8: raise Exception("PyDictToCefDictionaryValue(): max nesting level (8)" " exceeded") cdef type valueType cdef CefRefPtr[CefDictionaryValue] ret = CefDictionaryValue_Create() cdef CefString cefKey cdef object value for pyKey in pyDict: value = pyDict[pyKey] valueType = type(value) PyToCefString(pyKey, cefKey) if valueType == type(None): ret.get().SetNull(cefKey) elif valueType == bool: ret.get().SetBool(cefKey, bool(value)) elif valueType == int: ret.get().SetInt(cefKey, int(value)) elif valueType == long: # Int32 range is -2147483648..2147483647, we've increased the # minimum size by one as Cython was throwing a warning: # "unary minus operator applied to unsigned type, result still # unsigned". if -2147483647 <= value <= 2147483647: ret.get().SetInt(cefKey, int(value)) else: # Long values become strings. ret.get().SetString(cefKey, PyToCefStringValue(str(value))) elif valueType == float: ret.get().SetDouble(cefKey, float(value)) elif valueType == bytes or valueType == str \ or (PY_MAJOR_VERSION < 3 and valueType == unicode): # The unicode type is not defined in Python 3. ret.get().SetString(cefKey, PyToCefStringValue(str(value))) elif valueType == dict: ret.get().SetDictionary(cefKey, PyDictToCefDictionaryValue( browserId, frameId, value, nestingLevel + 1)) elif valueType == list or valueType == tuple: if valueType == tuple: value = list(value) ret.get().SetList(cefKey, PyListToCefListValue( browserId, frameId, value, nestingLevel + 1)) elif IsFunctionOrMethod(valueType): ret.get().SetBinary(cefKey, PutPythonCallback( browserId, frameId, value)) else: # Raising an exception probably not a good idea, why # terminate application when we can cast it to string, # the data may contain some non-standard object that is # probably redundant, but casting to string will do no harm. # This will handle the "type" type. ret.get().SetString(cefKey, PyToCefStringValue(str(value))) return ret cefpython-49.0/src/python_callback.pyx000066400000000000000000000071771334103266300201500ustar00rootroot00000000000000# Copyright (c) 2013 CEF Python, see the Authors file. # All rights reserved. Licensed under BSD 3-clause license. # Project website: https://github.com/cztomczak/cefpython include "cefpython.pyx" cdef int g_pythonCallbackMaxId = 0 cdef dict g_pythonCallbacks = {} # TODO: send callbackId using CefBinaryNamedValue, see: # http://www.magpcss.org/ceforum/viewtopic.php?f=6&t=10881 cdef struct PythonCallback: int callbackId char uniqueCefBinaryValueSize[16] cdef CefRefPtr[CefBinaryValue] PutPythonCallback( object browserId, object frameId, object function ) except *: global g_pythonCallbacks global g_pythonCallbackMaxId if not browserId: raise Exception("PutPythonCallback() FAILED: browserId is empty") if not frameId: raise Exception("PutPythonCallback() FAILED: frameId is empty") cdef PythonCallback pyCallback g_pythonCallbackMaxId += 1 pyCallback.callbackId = g_pythonCallbackMaxId cdef CefRefPtr[CefBinaryValue] binaryValue = CefBinaryValue_Create( &pyCallback, sizeof(pyCallback)) # [0] browserId, [1] frameId, [2] function. g_pythonCallbacks[g_pythonCallbackMaxId] = (browserId, frameId, function) return binaryValue cdef public void RemovePythonCallbacksForFrame( int frameId ) except * with gil: # Cannot remove elements from g_pythonCallbacks (dict) while iterating. cdef list toRemove = [] try: global g_pythonCallbacks for callbackId, value in g_pythonCallbacks.iteritems(): if value[1] == frameId: toRemove.append(callbackId) for callbackId in toRemove: del g_pythonCallbacks[callbackId] Debug("RemovePythonCallbacksForFrame(): " \ "removed python callback, callbackId = %s" \ % callbackId) except: (exc_type, exc_value, exc_trace) = sys.exc_info() sys.excepthook(exc_type, exc_value, exc_trace) cdef void RemovePythonCallbacksForBrowser( int browserId) except *: cdef list toRemove = [] global g_pythonCallbacks for callbackId, value in g_pythonCallbacks.iteritems(): if value[0] == browserId: toRemove.append(callbackId) for callbackId in toRemove: del g_pythonCallbacks[callbackId] Debug("RemovePythonCallbacksForBrowser(): " \ "removed python callback, callbackId = %s" \ % callbackId) cdef public cpp_bool ExecutePythonCallback( CefRefPtr[CefBrowser] cefBrowser, int callbackId, CefRefPtr[CefListValue] cefFunctionArguments, ) except * with gil: cdef object function cdef list functionArguments cdef object returnValue try: global g_pythonCallbacks if callbackId in g_pythonCallbacks: # [0] browserId, [1] frameId, [2] function. function = g_pythonCallbacks[callbackId][2] functionArguments = CefListValueToPyList( cefBrowser, cefFunctionArguments) returnValue = function(*functionArguments) if returnValue is not None: Debug("ExecutePythonCallback() WARNING: function returned" \ "value, but returning values to javascript is not " \ "supported, function name = %s" % function.__name__) return True else: Debug("ExecutePythonCallback() FAILED: callback not found, " \ "callbackId = %s" % callbackId) return False except: (exc_type, exc_value, exc_trace) = sys.exc_info() sys.excepthook(exc_type, exc_value, exc_trace) cefpython-49.0/src/request.pyx000066400000000000000000000213621334103266300164730ustar00rootroot00000000000000# Copyright (c) 2013 CEF Python, see the Authors file. # All rights reserved. Licensed under BSD 3-clause license. # Project website: https://github.com/cztomczak/cefpython include "cefpython.pyx" class Request: Flags = { "None": cef_types.UR_FLAG_NONE, "SkipCache": cef_types.UR_FLAG_SKIP_CACHE, "AllowCachedCredentials": cef_types.UR_FLAG_ALLOW_CACHED_CREDENTIALS, "AllowCookies": 0, # keep for BC "ReportUploadProgress": cef_types.UR_FLAG_REPORT_UPLOAD_PROGRESS, "ReportLoadTiming": 0, # keep for BC "ReportRawHeaders": 0, # keep for BC "NoDownloadData": cef_types.UR_FLAG_NO_DOWNLOAD_DATA, "NoRetryOn5xx": cef_types.UR_FLAG_NO_RETRY_ON_5XX, } def __init__(self): # Request object is just a public API wrapper, # the real Request object is named PyRequest. raise Exception("Request object cannot be instantiated directly, " "use static method Request.CreateRequest()") @staticmethod def CreateRequest(): cdef CefRefPtr[CefRequest] cefRequest = CefRequest_Create() cdef PyRequest pyRequest = CreatePyRequest(cefRequest) return pyRequest cdef PyRequest CreatePyRequest(CefRefPtr[CefRequest] cefRequest): # This can't be named "GetPyRequest()" as CefRequest has # no unique identifier, so each time a different python object # must be returned. cdef PyRequest pyRequest = PyRequest() pyRequest.cefRequest = cefRequest return pyRequest cdef class PyRequest: cdef CefRefPtr[CefRequest] cefRequest cdef CefRefPtr[CefRequest] GetCefRequest(self) except *: if self.cefRequest != NULL and self.cefRequest.get(): return self.cefRequest raise Exception("PyRequest.GetCefRequest() failed: " "CefRequest was destroyed") cpdef str GetUrl(self): return CefToPyString(self.GetCefRequest().get().GetURL()) cpdef py_void SetUrl(self, py_string url): cdef CefString cefUrl PyToCefString(url, cefUrl) self.GetCefRequest().get().SetURL(cefUrl) cpdef str GetMethod(self): return CefToPyString(self.GetCefRequest().get().GetMethod()) cpdef py_void SetMethod(self, py_string method): cdef CefString cefMethod PyToCefString(method, cefMethod) self.GetCefRequest().get().SetMethod(cefMethod) cpdef object GetPostData(self): if self.GetMethod() != "POST": return {} cdef cpp_vector[CefRefPtr[CefPostDataElement]] elementVector cdef CefRefPtr[CefPostData] postData = ( self.GetCefRequest().get().GetPostData()) if postData.get() == NULL: return {} if postData.get().GetElementCount() == 0: return {} postData.get().GetElements(elementVector) cdef cpp_vector[CefRefPtr[CefPostDataElement]].iterator iterator = ( elementVector.begin()) cdef CefRefPtr[CefPostDataElement] postDataElement cdef list retMultipart = [] cdef dict retUrlEncoded = {} # pyData is really of type "str", but Cython will throw # an error if we use that type: "Cannot convert 'bytes' # object to str implicitly. This is not portable to Py3." cdef object pyData cdef size_t bytesCount cdef void* voidData cdef str pyFile while iterator != elementVector.end(): postDataElement = deref(iterator) if postDataElement.get().GetType() == cef_types.PDE_TYPE_EMPTY: # May return an empty dict - retUrlEncoded. pass elif postDataElement.get().GetType() == cef_types.PDE_TYPE_BYTES: bytesCount = postDataElement.get().GetBytesCount() voidData = malloc(bytesCount) postDataElement.get().GetBytes(bytesCount, voidData) pyData = VoidPtrToString(voidData, bytesCount) free(voidData) if pyData.startswith('--') or retMultipart: # Content-Type: multipart/form-data retMultipart.append(pyData) else: # Content-Type: application/x-www-form-urlencoded retUrlEncoded.update(urlparse.parse_qsl(qs=pyData, keep_blank_values=True)) elif postDataElement.get().GetType() == cef_types.PDE_TYPE_FILE: pyFile = CefToPyString(postDataElement.get().GetFile()) retMultipart.append("@"+pyFile) else: raise Exception("Invalid type of CefPostDataElement") preinc(iterator) if retMultipart: return retMultipart else: return retUrlEncoded cpdef py_void SetPostData(self, object pyPostData): cdef CefRefPtr[CefPostData] postData = CefPostData_Create() cdef CefRefPtr[CefPostDataElement] postDataElement cdef py_string pyElement cdef CefString sfile if type(pyPostData) == list: for pyElement in pyPostData: if pyElement.startswith('--'): postDataElement = CefPostDataElement_Create() postDataElement.get().SetToBytes(len(pyElement), pyElement) elif pyElement.startswith('@'): postDataElement = CefPostDataElement_Create() PyToCefString(pyElement[1:], sfile) postDataElement.get().SetToFile(sfile) elif not pyElement: postDataElement = CefPostDataElement_Create() postDataElement.get().SetToEmpty() else: raise Exception("Invalid element in postData: %s" % ( pyElement)) postData.get().AddElement(postDataElement) elif type(pyPostData) == dict: pyElement = urllib.urlencode(pyPostData) pyElement = str(pyElement) postDataElement = CefPostDataElement_Create() postDataElement.get().SetToBytes(len(pyElement), pyElement) postData.get().AddElement(postDataElement) else: raise Exception("Invalid type of postData, only dict|list allowed") cpdef dict GetHeaderMap(self): cdef list headerMultimap = self.GetHeaderMultimap() cdef dict headerMap = {} cdef tuple headerTuple for headerTuple in headerMultimap: key = headerTuple[0] value = headerTuple[1] headerMap[key] = value return headerMap cpdef list GetHeaderMultimap(self): cdef cpp_multimap[CefString, CefString] cefHeaderMap self.GetCefRequest().get().GetHeaderMap(cefHeaderMap) cdef list pyHeaderMultimap = [] cdef cpp_multimap[CefString, CefString].iterator iterator = ( cefHeaderMap.begin()) cdef CefString cefKey cdef CefString cefValue cdef str pyKey cdef str pyValue while iterator != cefHeaderMap.end(): cefKey = deref(iterator).first cefValue = deref(iterator).second pyKey = CefToPyString(cefKey) pyValue = CefToPyString(cefValue) pyHeaderMultimap.append((pyKey, pyValue)) preinc(iterator) return pyHeaderMultimap cpdef py_void SetHeaderMap(self, dict headerMap): assert len(headerMap) > 0, "headerMap param is empty" cpdef list headerMultimap = [] cdef object key for key in headerMap: headerMultimap.append((str(key), str(headerMap[key]))) self.SetHeaderMultimap(headerMultimap) cpdef py_void SetHeaderMultimap(self, list headerMultimap): assert len(headerMultimap) > 0, "headerMultimap param is empty" cdef cpp_multimap[CefString, CefString] cefHeaderMap cdef CefString cefKey cdef CefString cefValue cdef cpp_pair[CefString, CefString] pair cdef tuple headerTuple for headerTuple in headerMultimap: PyToCefString(str(headerTuple[0]), cefKey) PyToCefString(str(headerTuple[1]), cefValue) pair.first, pair.second = cefKey, cefValue cefHeaderMap.insert(pair) self.GetCefRequest().get().SetHeaderMap(cefHeaderMap) cpdef int GetFlags(self) except *: return self.GetCefRequest().get().GetFlags() cpdef py_void SetFlags(self, int flags): self.GetCefRequest().get().SetFlags(flags) cpdef str GetFirstPartyForCookies(self): return CefToPyString( self.GetCefRequest().get().GetFirstPartyForCookies()) cpdef py_void SetFirstPartyForCookies(self, py_string url): self.GetCefRequest().get().SetFirstPartyForCookies( PyToCefStringValue(url)) cefpython-49.0/src/response.pyx000066400000000000000000000104651334103266300166430ustar00rootroot00000000000000# Copyright (c) 2013 CEF Python, see the Authors file. # All rights reserved. Licensed under BSD 3-clause license. # Project website: https://github.com/cztomczak/cefpython include "cefpython.pyx" cdef PyResponse CreatePyResponse(CefRefPtr[CefResponse] cefResponse): cdef PyResponse pyResponse = PyResponse() pyResponse.cefResponse = cefResponse return pyResponse cdef class PyResponse: cdef CefRefPtr[CefResponse] cefResponse cdef CefRefPtr[CefResponse] GetCefResponse(self ) except *: if self.cefResponse != NULL and self.cefResponse.get(): return self.cefResponse raise Exception("CefResponse was destroyed, you cannot use this object anymore") cpdef py_bool IsReadOnly(self): return self.GetCefResponse().get().IsReadOnly() cpdef int GetStatus(self) except *: return self.GetCefResponse().get().GetStatus() cpdef py_void SetStatus(self, int status): assert type(status) == int, "Response.SetStatus() failed: status param is not an int" self.GetCefResponse().get().SetStatus(status) cpdef str GetStatusText(self): return CefToPyString(self.GetCefResponse().get().GetStatusText()) cpdef py_void SetStatusText(self, py_string statusText): assert type(statusText) in (str, unicode, bytes), ( "Response.SetStatusText() failed: statusText param is not a string") cdef CefString cefStatusText PyToCefString(statusText, cefStatusText) self.GetCefResponse().get().SetStatusText(cefStatusText) cpdef str GetMimeType(self): return CefToPyString(self.GetCefResponse().get().GetMimeType()) cpdef py_void SetMimeType(self, py_string mimeType): assert type(mimeType) in (str, unicode, bytes), ( "Response.SetMimeType() failed: mimeType param is not a string") cdef CefString cefMimeType PyToCefString(mimeType, cefMimeType) self.GetCefResponse().get().SetMimeType(cefMimeType) cpdef str GetHeader(self, py_string name): assert type(name) in (str, unicode, bytes), ( "Response.GetHeader() failed: name param is not a string") cdef CefString cefName PyToCefString(name, cefName) return CefToPyString(self.GetCefResponse().get().GetHeader(cefName)) cpdef dict GetHeaderMap(self): cdef list headerMultimap = self.GetHeaderMultimap() cdef dict headerMap = {} cdef tuple headerTuple for headerTuple in headerMultimap: key = headerTuple[0] value = headerTuple[1] headerMap[key] = value return headerMap cpdef list GetHeaderMultimap(self): cdef cpp_multimap[CefString, CefString] cefHeaderMap self.GetCefResponse().get().GetHeaderMap(cefHeaderMap) cdef list pyHeaderMultimap = [] cdef cpp_multimap[CefString, CefString].iterator iterator = ( cefHeaderMap.begin()) cdef CefString cefKey cdef CefString cefValue cdef str pyKey cdef str pyValue while iterator != cefHeaderMap.end(): cefKey = deref(iterator).first cefValue = deref(iterator).second pyKey = CefToPyString(cefKey) pyValue = CefToPyString(cefValue) pyHeaderMultimap.append((pyKey, pyValue)) preinc(iterator) return pyHeaderMultimap cpdef py_void SetHeaderMap(self, dict headerMap): assert len(headerMap) > 0, "headerMap param is empty" cpdef list headerMultimap = [] cdef object key for key in headerMap: headerMultimap.append((str(key), str(headerMap[key]))) self.SetHeaderMultimap(headerMultimap) cpdef py_void SetHeaderMultimap(self, list headerMultimap): assert len(headerMultimap) > 0, "headerMultimap param is empty" cdef cpp_multimap[CefString, CefString] cefHeaderMap cdef CefString cefKey cdef CefString cefValue cdef cpp_pair[CefString, CefString] pair cdef tuple headerTuple for headerTuple in headerMultimap: PyToCefString(str(headerTuple[0]), cefKey) PyToCefString(str(headerTuple[1]), cefValue) pair.first, pair.second = cefKey, cefValue cefHeaderMap.insert(pair) self.GetCefResponse().get().SetHeaderMap(cefHeaderMap) cefpython-49.0/src/settings.pyx000066400000000000000000000341451334103266300166460ustar00rootroot00000000000000# Copyright (c) 2012 CEF Python, see the Authors file. # All rights reserved. Licensed under BSD 3-clause license. # Project website: https://github.com/cztomczak/cefpython # More options/flags can be specified for Chromium through # CefApp::OnBeforeCommandLineProcessing(), see comment 10 by Marshall: # https://code.google.com/p/chromiumembedded/issues/detail?id=878#c10 include "cefpython.pyx" cimport cef_types LOGSEVERITY_DEFAULT = cef_types.LOGSEVERITY_DEFAULT LOGSEVERITY_VERBOSE = cef_types.LOGSEVERITY_VERBOSE LOGSEVERITY_INFO = cef_types.LOGSEVERITY_INFO LOGSEVERITY_WARNING = cef_types.LOGSEVERITY_WARNING LOGSEVERITY_ERROR = cef_types.LOGSEVERITY_ERROR # keep for BC LOGSEVERITY_ERROR_REPORT = cef_types.LOGSEVERITY_ERROR LOGSEVERITY_DISABLE = cef_types.LOGSEVERITY_DISABLE cdef void SetApplicationSettings( dict appSettings, CefSettings* cefAppSettings ) except *: cdef CefString* cefString for key in appSettings: # Setting string: CefString(&browserDefaults.default_encoding).FromASCII("UTF-8"); # cefString = CefString(&cefSettings.user_agent) # cefString.FromASCII(settings[key]) if key == "string_encoding"\ or key == "debug"\ or key == "unique_request_context_per_browser"\ or key == "downloads_enabled"\ or key == "context_menu" \ or key == "auto_zooming"\ or key == "app_user_model_id": # CEF Python only options. These are not to be found in CEF. continue elif key == "accept_language_list": cefString = new CefString(&cefAppSettings.accept_language_list) PyToCefStringPointer(appSettings[key], cefString) del cefString elif key == "cache_path": cefString = new CefString(&cefAppSettings.cache_path) PyToCefStringPointer(appSettings[key], cefString) del cefString elif key == "persist_session_cookies": cefAppSettings.persist_session_cookies = int(appSettings[key]) elif key == "user_agent": cefString = new CefString(&cefAppSettings.user_agent) PyToCefStringPointer(appSettings[key], cefString) del cefString elif key == "product_version": cefString = new CefString(&cefAppSettings.product_version) PyToCefStringPointer(appSettings[key], cefString) del cefString elif key == "log_file": cefString = new CefString(&cefAppSettings.log_file) PyToCefStringPointer(appSettings[key], cefString) del cefString elif key == "locale": cefString = new CefString(&cefAppSettings.locale) PyToCefStringPointer(appSettings[key], cefString) del cefString elif key == "log_severity": cefAppSettings.log_severity = int(appSettings[key]) elif key == "multi_threaded_message_loop": cefAppSettings.multi_threaded_message_loop = int(appSettings[key]) elif key == "release_dcheck_enabled": # Keep for BC, just log info - no error Debug("DEPRECATED: 'release_dcheck_enabled' setting") elif key == "javascript_flags": cefString = new CefString(&cefAppSettings.javascript_flags) PyToCefStringPointer(appSettings[key], cefString) del cefString elif key == "resources_dir_path": cefString = new CefString(&cefAppSettings.resources_dir_path) PyToCefStringPointer(appSettings[key], cefString) del cefString elif key == "locales_dir_path": cefString = new CefString(&cefAppSettings.locales_dir_path) PyToCefStringPointer(appSettings[key], cefString) del cefString elif key == "pack_loading_disabled": cefAppSettings.pack_loading_disabled = int(appSettings[key]) elif key == "uncaught_exception_stack_size": cefAppSettings.uncaught_exception_stack_size = int(appSettings[key]) elif key == "single_process": cefAppSettings.single_process = int(appSettings[key]) elif key == "browser_subprocess_path": cefString = new CefString(&cefAppSettings.browser_subprocess_path) PyToCefStringPointer(appSettings[key], cefString) del cefString elif key == "command_line_args_disabled": cefAppSettings.command_line_args_disabled = int(appSettings[key]) elif key == "remote_debugging_port": cefAppSettings.remote_debugging_port = int(appSettings[key]) elif key == "ignore_certificate_errors": cefAppSettings.ignore_certificate_errors = int(appSettings[key]) elif key == "background_color": cefAppSettings.background_color = \ int(appSettings[key]) elif key == "persist_user_preferences": cefAppSettings.persist_user_preferences = \ int(appSettings[key]) elif key == "user_data_path": cefString = new CefString(&cefAppSettings.user_data_path) PyToCefStringPointer(appSettings[key], cefString) del cefString elif key == "windowless_rendering_enabled": cefAppSettings.windowless_rendering_enabled = \ int(appSettings[key]) else: raise Exception("Invalid appSettings key: %s" % key) cdef void SetBrowserSettings( dict browserSettings, CefBrowserSettings* cefBrowserSettings ) except *: cdef CefString* cefString for key in browserSettings: if key == "inherit_client_handlers_for_popups": # CEF Python only options. These are not to be found in CEF. continue elif key == "accept_language_list": cefString = new CefString(&cefBrowserSettings.accept_language_list) PyToCefStringPointer(browserSettings[key], cefString) del cefString elif key == "background_color": cefBrowserSettings.background_color = \ int(browserSettings[key]) elif key == "standard_font_family": cefString = new CefString(&cefBrowserSettings.standard_font_family) PyToCefStringPointer(browserSettings[key], cefString) del cefString elif key == "fixed_font_family": cefString = new CefString(&cefBrowserSettings.fixed_font_family) PyToCefStringPointer(browserSettings[key], cefString) del cefString elif key == "serif_font_family": cefString = new CefString(&cefBrowserSettings.serif_font_family) PyToCefStringPointer(browserSettings[key], cefString) del cefString elif key == "sans_serif_font_family": cefString = new CefString(&cefBrowserSettings.sans_serif_font_family) PyToCefStringPointer(browserSettings[key], cefString) del cefString elif key == "cursive_font_family": cefString = new CefString(&cefBrowserSettings.cursive_font_family) PyToCefStringPointer(browserSettings[key], cefString) del cefString elif key == "fantasy_font_family": cefString = new CefString(&cefBrowserSettings.fantasy_font_family) PyToCefStringPointer(browserSettings[key], cefString) del cefString elif key == "default_font_size": cefBrowserSettings.default_font_size = int(browserSettings[key]) elif key == "default_fixed_font_size": cefBrowserSettings.default_fixed_font_size = int(browserSettings[key]) elif key == "minimum_font_size": cefBrowserSettings.minimum_font_size = int(browserSettings[key]) elif key == "minimum_logical_font_size": cefBrowserSettings.minimum_logical_font_size = int(browserSettings[key]) elif key == "default_encoding": cefString = new CefString(&cefBrowserSettings.default_encoding) PyToCefStringPointer(browserSettings[key], cefString) del cefString elif key == "user_style_sheet_location": # Keep for BC, just log info - no error Debug("DEPRECATED: 'user_style_sheet_location' setting") elif key == "remote_fonts_disabled": if browserSettings[key]: cefBrowserSettings.remote_fonts = cef_types.STATE_DISABLED else: cefBrowserSettings.remote_fonts = cef_types.STATE_ENABLED elif key == "javascript_disabled": if browserSettings[key]: cefBrowserSettings.javascript = cef_types.STATE_DISABLED else: cefBrowserSettings.javascript = cef_types.STATE_ENABLED elif key == "javascript_open_windows_disallowed": if browserSettings[key]: cefBrowserSettings.javascript_open_windows = ( cef_types.STATE_DISABLED) else: cefBrowserSettings.javascript_open_windows = ( cef_types.STATE_ENABLED) elif key == "javascript_close_windows_disallowed": if browserSettings[key]: cefBrowserSettings.javascript_close_windows = ( cef_types.STATE_DISABLED) else: cefBrowserSettings.javascript_close_windows = ( cef_types.STATE_ENABLED) elif key == "javascript_access_clipboard_disallowed": if browserSettings[key]: cefBrowserSettings.javascript_access_clipboard = ( cef_types.STATE_DISABLED) else: cefBrowserSettings.javascript_access_clipboard = ( cef_types.STATE_ENABLED) elif key == "dom_paste_disabled": if browserSettings[key]: cefBrowserSettings.javascript_dom_paste = ( cef_types.STATE_DISABLED) else: cefBrowserSettings.javascript_dom_paste = ( cef_types.STATE_ENABLED) elif key == "caret_browsing_enabled": # Keep the key for BC Debug("DEPRECATED: 'caret_browsing_enabled' setting") elif key == "java_disabled": # Keep the key for BC Debug("DEPRECATED: 'java_disabled' setting") elif key == "plugins_disabled": if browserSettings[key]: cefBrowserSettings.plugins = cef_types.STATE_DISABLED else: cefBrowserSettings.plugins = cef_types.STATE_ENABLED elif key == "universal_access_from_file_urls_allowed": if browserSettings[key]: cefBrowserSettings.universal_access_from_file_urls = ( cef_types.STATE_ENABLED) else: cefBrowserSettings.universal_access_from_file_urls = ( cef_types.STATE_DISABLED) elif key == "file_access_from_file_urls_allowed": if browserSettings[key]: cefBrowserSettings.file_access_from_file_urls = ( cef_types.STATE_ENABLED) else: cefBrowserSettings.file_access_from_file_urls = ( cef_types.STATE_DISABLED) elif key == "web_security_disabled": if browserSettings[key]: cefBrowserSettings.web_security = cef_types.STATE_DISABLED else: cefBrowserSettings.web_security = cef_types.STATE_ENABLED elif key == "image_load_disabled": if browserSettings[key]: cefBrowserSettings.image_loading = cef_types.STATE_DISABLED else: cefBrowserSettings.image_loading = cef_types.STATE_ENABLED elif key == "shrink_standalone_images_to_fit": if browserSettings[key]: cefBrowserSettings.image_shrink_standalone_to_fit = ( cef_types.STATE_ENABLED) else: cefBrowserSettings.image_shrink_standalone_to_fit = ( cef_types.STATE_DISABLED) elif key == "text_area_resize_disabled": if browserSettings[key]: cefBrowserSettings.text_area_resize = ( cef_types.STATE_DISABLED) else: cefBrowserSettings.text_area_resize = ( cef_types.STATE_ENABLED) elif key == "tab_to_links_disabled": if browserSettings[key]: cefBrowserSettings.tab_to_links = cef_types.STATE_DISABLED else: cefBrowserSettings.tab_to_links = cef_types.STATE_ENABLED elif key == "author_and_user_styles_disabled": Debug("DEPRECATED: 'author_and_user_styles_disabled' setting") elif key == "local_storage_disabled": if browserSettings[key]: cefBrowserSettings.local_storage = cef_types.STATE_DISABLED else: cefBrowserSettings.local_storage = cef_types.STATE_ENABLED elif key == "databases_disabled": if browserSettings[key]: cefBrowserSettings.databases = cef_types.STATE_DISABLED else: cefBrowserSettings.databases = cef_types.STATE_ENABLED elif key == "application_cache_disabled": if browserSettings[key]: cefBrowserSettings.application_cache = ( cef_types.STATE_DISABLED) else: cefBrowserSettings.application_cache = ( cef_types.STATE_ENABLED) elif key == "webgl_disabled": if browserSettings[key]: cefBrowserSettings.webgl = cef_types.STATE_DISABLED else: cefBrowserSettings.webgl = cef_types.STATE_ENABLED elif key == "accelerated_compositing_disabled": Debug("DEPRECATED: 'accelerated_compositing_disabled' setting") elif key == "windowless_frame_rate": cefBrowserSettings.windowless_frame_rate =\ int(browserSettings[key]) else: raise Exception("Invalid browserSettings key: %s" % key) cefpython-49.0/src/string_utils.pyx000066400000000000000000000122461334103266300175320ustar00rootroot00000000000000# Copyright (c) 2012 CEF Python, see the Authors file. # All rights reserved. Licensed under BSD 3-clause license. # Project website: https://github.com/cztomczak/cefpython # In Python 2 all cefpython strings are byte strings, but in Python 3 # all cefpython strings are unicode. Unicode issues were discussed # in Issue #60: https://github.com/cztomczak/cefpython/issues/60 # Unicode issues were discussed on cython-users, see posts by Stefan # Behnel: https://groups.google.com/d/topic/cython-users/VICzhVn-zPw/discussion # See the "basestring" comment in cefpython.pyx. # Note that bytes != str != unicode != basestring in Cython # Any bytes/unicode encoding and decoding in cefpython should # be performed only using functions from this file - let's # keep it in one place for future fixes - see Issue 60 ("Strings # should be unicode by default, if bytes is required make it # explicit"). include "cefpython.pyx" # TODO: make this configurable through ApplicationSettings. UNICODE_ENCODE_ERRORS = "replace" BYTES_DECODE_ERRORS = "replace" cdef py_string AnyToPyString(object value): cdef object valueType = type(value) if valueType == str or valueType == bytes: return value elif PY_MAJOR_VERSION < 3 and valueType == unicode: # The unicode type is not defined in Python 3 return value else: return "" cdef py_string CharToPyString( const char* charString): if PY_MAJOR_VERSION < 3: return charString else: return ((charString).decode( g_applicationSettings["string_encoding"], errors=BYTES_DECODE_ERRORS)) cdef bytes PyStringToChar(py_string pyString): if PY_MAJOR_VERSION < 3: return pyString else: # The unicode type is not defined in Python 3. if type(pyString) == str: pyString = (pyString.encode( g_applicationSettings["string_encoding"], errors=UNICODE_ENCODE_ERRORS)) return pyString # Not used anywhere so commented out. # --- # cdef py_string CppToPyString( # cpp_string cppString): # if PY_MAJOR_VERSION < 3: # return cppString # else: # return ((cppString).decode( # g_applicationSettings["string_encoding"], # errors=BYTES_DECODE_ERRORS)) # --- # No need for this function as you can do it in one line. # Stays here just for the info on how to do it. # --- # cdef cpp_string PyToCppString(py_string pyString) except *: # cdef cpp_string cppString = pyString # return cppString # --- cdef py_string CefToPyString( ConstCefString& cefString): cdef cpp_string cppString if cefString.empty(): return "" IF UNAME_SYSNAME == "Windows": cdef wchar_t* wcharstr = cefString.c_str() return WidecharToPyString(wcharstr) ELSE: cppString = cefString.ToString() if PY_MAJOR_VERSION < 3: return cppString else: return ((cppString).decode( g_applicationSettings["string_encoding"], errors=BYTES_DECODE_ERRORS)) cdef void PyToCefString( py_string pyString, CefString& cefString ) except *: if PY_MAJOR_VERSION < 3: if type(pyString) == unicode: pyString = (pyString.encode( g_applicationSettings["string_encoding"], errors=UNICODE_ENCODE_ERRORS)) else: # The unicode type is not defined in Python 3. if type(pyString) == str: pyString = (pyString.encode( g_applicationSettings["string_encoding"], errors=UNICODE_ENCODE_ERRORS)) cdef cpp_string cppString = pyString # Using cefString.FromASCII() will result in DCHECK failures # when a non-ascii character is encountered. cefString.FromString(cppString) cdef CefString PyToCefStringValue( py_string pyString ) except *: cdef CefString cefString PyToCefString(pyString, cefString) return cefString cdef void PyToCefStringPointer( py_string pyString, CefString* cefString ) except *: if PY_MAJOR_VERSION < 3: if type(pyString) == unicode: pyString = (pyString.encode( g_applicationSettings["string_encoding"], errors=UNICODE_ENCODE_ERRORS)) else: # The unicode type is not defined in Python 3. if type(pyString) == str: pyString = (pyString.encode( g_applicationSettings["string_encoding"], errors=UNICODE_ENCODE_ERRORS)) cdef cpp_string cppString = pyString # When used cefString.FromASCII(), a DCHECK failed # when passed a unicode string. cefString.FromString(cppString) cdef py_string VoidPtrToString(const void* data, size_t dataLength): if PY_MAJOR_VERSION < 3: return ((data)[:dataLength]) else: return (((data)[:dataLength]).decode( g_applicationSettings["string_encoding"], errors=BYTES_DECODE_ERRORS)) cefpython-49.0/src/string_utils_win.pyx000066400000000000000000000024161334103266300204050ustar00rootroot00000000000000# Copyright (c) 2012 CEF Python, see the Authors file. # All rights reserved. Licensed under BSD 3-clause license. # Project website: https://github.com/cztomczak/cefpython include "cefpython.pyx" cdef int wchar_t_size = 2 cdef void CharToWidechar(char* charString, wchar_t* wideString, int wideSize ) except *: cdef int copiedCharacters = MultiByteToWideChar( CP_UTF8, 0, charString, -1, wideString, wideSize) # MultiByteToWideChar does not include the NULL character # when 0 bytes are written. if wideSize > 0 and copiedCharacters == 0: wideString[0] = 0 cdef py_string WidecharToPyString( wchar_t* wcharString): cdef int charBytes = WideCharToMultiByte( CP_UTF8, 0, wcharString, -1, NULL, 0, NULL, NULL) assert charBytes > 0, "WideCharToMultiByte() returned 0" cdef char* charString = malloc(charBytes * sizeof(char)) cdef int copiedBytes = WideCharToMultiByte( CP_UTF8, 0, wcharString, -1, charString, charBytes, NULL, NULL) # WideCharToMultiByte does not include the NULL character # when 0 bytes are written. if copiedBytes == 0: charString[0] = 0 cdef py_string pyString = CharToPyString(charString) free(charString) return pyString cefpython-49.0/src/string_visitor.pyx000066400000000000000000000056131334103266300200710ustar00rootroot00000000000000# Copyright (c) 2013 CEF Python, see the Authors file. # All rights reserved. Licensed under BSD 3-clause license. # Project website: https://github.com/cztomczak/cefpython include "cefpython.pyx" import weakref # ----------------------------------------------------------------------------- # PyStringVisitor # ----------------------------------------------------------------------------- cdef object g_userStringVisitors = weakref.WeakValueDictionary() cdef int g_userStringVisitorMaxId = 0 cdef int StoreUserStringVisitor(object userStringVisitor) except *: global g_userStringVisitorMaxId global g_userStringVisitors g_userStringVisitorMaxId += 1 g_userStringVisitors[g_userStringVisitorMaxId] = userStringVisitor return g_userStringVisitorMaxId cdef PyStringVisitor GetUserStringVisitor(int stringVisitorId): global g_userStringVisitors cdef object userStringVisitor cdef PyStringVisitor pyStringVisitor if stringVisitorId in g_userStringVisitors: userStringVisitor = g_userStringVisitors[stringVisitorId] pyStringVisitor = PyStringVisitor(userStringVisitor) return pyStringVisitor cdef class PyStringVisitor: cdef object userStringVisitor def __init__(self, object userStringVisitor): self.userStringVisitor = userStringVisitor cdef object GetCallback(self, str funcName): if self.userStringVisitor and ( hasattr(self.userStringVisitor, funcName) and ( callable(getattr(self.userStringVisitor, funcName)))): return getattr(self.userStringVisitor, funcName) # ----------------------------------------------------------------------------- # C++ StringVisitor # ----------------------------------------------------------------------------- cdef CefRefPtr[CefStringVisitor] CreateStringVisitor( object userStringVisitor) except *: if not userStringVisitor: raise Exception("userStringVisitor object missing") if not hasattr(userStringVisitor, "Visit"): raise Exception("userStringVisitor object is missing Visit() method") cdef int stringVisitorId = StoreUserStringVisitor(userStringVisitor) cdef CefRefPtr[CefStringVisitor] cefStringVisitor = ( new StringVisitor(stringVisitorId)) return cefStringVisitor cdef public void StringVisitor_Visit( int stringVisitorId, const CefString& string ) except * with gil: cdef str pyString cdef PyStringVisitor userStringVisitor cdef object callback try: pyString = CefToPyString(string) userStringVisitor = GetUserStringVisitor(stringVisitorId) if userStringVisitor: callback = userStringVisitor.GetCallback("Visit") if callback: callback(value=pyString) except: (exc_type, exc_value, exc_trace) = sys.exc_info() sys.excepthook(exc_type, exc_value, exc_trace) cefpython-49.0/src/subprocess/000077500000000000000000000000001334103266300164255ustar00rootroot00000000000000cefpython-49.0/src/subprocess/.gitignore000066400000000000000000000000441334103266300204130ustar00rootroot00000000000000*.o *.a subprocess subprocess.dSYM/ cefpython-49.0/src/subprocess/Makefile000066400000000000000000000034161334103266300200710ustar00rootroot00000000000000# -g - extra debug information # -O1 - more precise backtraces # -fPIC - required when using -shared option, required for use with Cython # -Wall - show important warnings # -Werror - treat warnings as errors UNAME_S = $(shell uname -s) INC = -I./../ -I./../common/ -I$(PYTHON_INCLUDE) \ -I/usr/include/gtk-2.0 \ -I/usr/include/gtk-unix-print-2.0 \ -I/usr/include/glib-2.0 \ -I/usr/include/cairo \ -I/usr/include/pango-1.0 \ -I/usr/include/gdk-pixbuf-2.0 \ -I/usr/include/atk-1.0 \ -I/usr/lib/x86_64-linux-gnu/gtk-2.0/include \ -I/usr/lib/x86_64-linux-gnu/gtk-unix-print-2.0 \ -I/usr/lib/x86_64-linux-gnu/glib-2.0/include \ -I/usr/lib/i386-linux-gnu/gtk-2.0/include \ -I/usr/lib/i386-linux-gnu/gtk-unix-print-2.0 \ -I/usr/lib/i386-linux-gnu/glib-2.0/include \ -I/usr/lib64/gtk-2.0/include \ -I/usr/lib64/gtk-unix-print-2.0 \ -I/usr/lib64/glib-2.0/include \ -I/usr/lib/gtk-2.0/include \ -I/usr/lib/gtk-2.0/gtk-unix-print-2.0 \ -I/usr/lib/glib-2.0/include ifeq ($(UNAME_S), Linux) LIB_DIRS = -L$(CEF_BIN) \ -L$(CEF_LIB) else ifeq ($(UNAME_S), Darwin) LIB_DIRS = -F$(CEF_BIN) \ -L$(CEF_LIB) endif ifeq ($(UNAME_S), Linux) CPP_FILES = print_handler_gtk.cpp LIBS = -lcef -lgobject-2.0 -lglib-2.0 -lgtk-x11-2.0 else ifeq ($(UNAME_S), Darwin) CPP_FILES = # Include framework before libcef_dll_wrapper LIBS = -framework "Chromium Embedded Framework" endif CCFLAGS = -DRENDERER_PROCESS $(CEF_CCFLAGS) subprocess: # -fPIC is required only for libraries included by Cython. @echo [SUBPROCESS] Building the 'subprocess' executable $(CXX) $(CCFLAGS) $(INC) $(LIB_DIRS) main.cpp cefpython_app.cpp \ v8function_handler.cpp v8utils.cpp javascript_callback.cpp \ $(CPP_FILES) \ $(CEF_LINK_FLAGS) \ $(LIBS) -lcef_dll_wrapper \ -o subprocess -Wl,-rpath,@loader_path/ cefpython-49.0/src/subprocess/Makefile-libcefpythonapp000066400000000000000000000033161334103266300232550ustar00rootroot00000000000000# -g - extra debug information # -O1 - more precise backtraces # -fPIC - required when using -shared option, required for use with Cython # -Wall - show important warnings # -Werror - treat warnings as errors # Cython compiler options: # -fPIC -shared -Wl,-O1 -Wl,-Bsymbolic-functions -Wl,-Bsymbolic-functions \ # -Wl,-z,relro UNAME_S = $(shell uname -s) CCFLAGS = -fPIC -DBROWSER_PROCESS $(CEF_CCFLAGS) ifeq ($(UNAME_S), Linux) SRC_MORE = print_handler_gtk.cpp else ifeq ($(UNAME_S), Darwin) SRC_MORE = endif SRC = cefpython_app.cpp v8function_handler.cpp v8utils.cpp \ javascript_callback.cpp \ $(SRC_MORE) OBJ = $(filter %.o, $(SRC:.cpp=.o) $(SRC:.mm=.o)) .SUFFIXES: .cpp .mm .o OUT = libcefpythonapp.a INC = -I./../ -I./../common/ -I$(PYTHON_INCLUDE) \ -I/usr/include/gtk-2.0 \ -I/usr/include/gtk-unix-print-2.0 \ -I/usr/include/glib-2.0 \ -I/usr/include/cairo \ -I/usr/include/pango-1.0 \ -I/usr/include/gdk-pixbuf-2.0 \ -I/usr/include/atk-1.0 \ -I/usr/lib/x86_64-linux-gnu/gtk-2.0/include \ -I/usr/lib/x86_64-linux-gnu/gtk-unix-print-2.0 \ -I/usr/lib/x86_64-linux-gnu/glib-2.0/include \ -I/usr/lib/i386-linux-gnu/gtk-2.0/include \ -I/usr/lib/i386-linux-gnu/gtk-unix-print-2.0 \ -I/usr/lib/i386-linux-gnu/glib-2.0/include \ -I/usr/lib64/gtk-2.0/include \ -I/usr/lib64/gtk-unix-print-2.0 \ -I/usr/lib64/glib-2.0/include \ -I/usr/lib/gtk-2.0/include \ -I/usr/lib/gtk-2.0/gtk-unix-print-2.0 \ -I/usr/lib/glib-2.0/include $(OUT): $(OBJ) @echo [CEFPYTHONAPP] Creating library $(OUT) from $(OBJ)... ar rcs $(OUT) $(OBJ) .cpp.o: @echo [CEFPYTHONAPP] Building $@ from $<... $(CXX) $(CCFLAGS) $(INC) -c $< -o $@ .mm.o: @echo [CEFPYTHONAPP] Building $@ from $<... $(CXX) $(CCFLAGS) $(INC) -c $< -o $@ cefpython-49.0/src/subprocess/cefpython_app.cpp000066400000000000000000000702531334103266300217770ustar00rootroot00000000000000// Copyright (c) 2012 CEF Python, see the Authors file. // All rights reserved. Licensed under BSD 3-clause license. // Project website: https://github.com/cztomczak/cefpython // BROWSER_PROCESS macro is defined when compiling the libcefpythonapp library. // RENDERER_PROCESS macro is define when compiling the subprocess executable. #ifdef BROWSER_PROCESS #include "common/cefpython_public_api.h" #endif #if defined(OS_WIN) #include #pragma comment(lib, "Shell32.lib") #endif // OS_WIN #ifdef BROWSER_PROCESS #ifdef OS_WIN #include "client_handler/dpi_aware.h" #elif OS_LINUX // OS_WIN #include #include #include #include "print_handler_gtk.h" #endif // OS_LINUX #endif // BROWSER_PROCESS #include "cefpython_app.h" #include "util.h" #include "include/wrapper/cef_closure_task.h" #include "include/base/cef_bind.h" #include "include/base/cef_logging.h" #include #include #include "v8utils.h" #include "javascript_callback.h" #include "v8function_handler.h" // GLOBALS bool g_debug = false; CefPythonApp::CefPythonApp() { #ifdef BROWSER_PROCESS cefpython_GetDebugOptions(&g_debug); #endif } // ----------------------------------------------------------------------------- // CefApp // ----------------------------------------------------------------------------- void CefPythonApp::OnBeforeCommandLineProcessing( const CefString& process_type, CefRefPtr command_line) { // IMPORTANT NOTES // --------------- // NOTE 1: Currently CEF logging is limited and you cannot log // info messages during execution of this function. The // default log severity in Chromium is LOG_ERROR, thus // you can will only see log messages when using LOG(ERROR) // here. You won't see LOG(WARNING) nor LOG(INFO) messages // here. // NOTE 2: The "g_debug" variable is never set at this moment // due to IPC messaging delay. There is some code here // that depends on this variable, but it is currently // never executed. #ifdef BROWSER_PROCESS // This is included only in the Browser process, when building // the libcefpythonapp library. if (process_type.empty()) { // Empty proc type, so this must be the main browser process. App_OnBeforeCommandLineProcessing_BrowserProcess(command_line); } #endif // BROWSER_PROCESS // IMPORTANT: This code is currently dead due to g_debug and // LOG(INFO) issues described at the top of this // function. Command line string for subprocesses are // are currently logged in OnBeforeChildProcess(). // Command line string for the main browser process // is currently never logged. std::string process_name = process_type.ToString(); if (process_name.empty()) { process_name = "browser"; } #ifdef BROWSER_PROCESS std::string logMessage = "[Browser process] "; #else // BROWSER_PROCESS std::string logMessage = "[Non-browser process] "; #endif // BROWSER_PROCESS logMessage.append("Command line string for the "); logMessage.append(process_name); logMessage.append(" process: "); std::string clString = command_line->GetCommandLineString().ToString(); logMessage.append(clString.c_str()); if (g_debug) { // This code is currently never executed, see the "IMPORTANT" // comment above and comments at the top of this function. LOG(INFO) << logMessage.c_str(); } #ifdef OS_WIN // Set AppUserModelID (AppID) when "--app-user-model-id" switch // is provided. This fixes pinning to taskbar issues on Windows 10. // See Issue #395 for details. // // AppID here is set in all processes (Browser, Renderer, GPU, etc.). // // When compiling under Python 2.7 (VS2008) using Visual C++ for // Python, it seems you can't use WINSDK 7 header files even though // WINVER was specified in build_cpp_projects.py macros. Thus calling // using proc address. Specifying full path to Shell32.dll is not // required, in Chromium's source code full paths are not used. // // Note: // subprocess.exe is built with UNICODE defined, however the // cefpython_app library that is shared between subprocess and // python process does not define UNICODE macro. Thus it is required // to call LoadLibraryW explicitilly here. HINSTANCE shell32 = LoadLibraryW(L"shell32.dll"); CefString app_id = command_line->GetSwitchValue("app-user-model-id"); if (app_id.length()) { typedef HRESULT (WINAPI *SetAppUserModelID_Type)(PCWSTR); static SetAppUserModelID_Type SetAppUserModelID; SetAppUserModelID = (SetAppUserModelID_Type)GetProcAddress( shell32, "SetCurrentProcessExplicitAppUserModelID"); HRESULT hr = (*SetAppUserModelID)(app_id.ToWString().c_str()); if (hr == S_OK) { if (g_debug) { // This code is currently never executed, see comments // at the top of this function. LOG(INFO) << "SetCurrentProcessExplicitAppUserModelID ok"; } } else { LOG(ERROR) << "SetCurrentProcessExplicitAppUserModelID failed"; } } #endif // OS_WIN } void CefPythonApp::OnRegisterCustomSchemes( CefRefPtr registrar) { } CefRefPtr CefPythonApp::GetResourceBundleHandler() { return NULL; } CefRefPtr CefPythonApp::GetBrowserProcessHandler() { return this; } CefRefPtr CefPythonApp::GetRenderProcessHandler() { return this; } // ---------------------------------------------------------------------------- // CefBrowserProcessHandler // ---------------------------------------------------------------------------- void CefPythonApp::OnContextInitialized() { #ifdef BROWSER_PROCESS REQUIRE_UI_THREAD(); #if defined(OS_LINUX) print_handler_ = new ClientPrintHandlerGtk(); #endif // OS_LINUX #endif // BROWSER_PROCESS } void CefPythonApp::OnBeforeChildProcessLaunch( CefRefPtr command_line) { #ifdef BROWSER_PROCESS // This is included only in the Browser process, when building // the libcefpythonapp library. if (IsProcessDpiAware()) { // It is required to set DPI awareness in subprocesses // as well, see Issue #358. command_line->AppendSwitch("enable-high-dpi-support"); } BrowserProcessHandler_OnBeforeChildProcessLaunch(command_line); #endif // BROWSER_PROCESS #ifdef BROWSER_PROCESS std::string logMessage = "[Browser process] "; #else std::string logMessage = "[Non-browser process] "; #endif // BROWSER_PROCESS logMessage.append("OnBeforeChildProcessLaunch() command line: "); std::string clString = command_line->GetCommandLineString().ToString(); logMessage.append(clString.c_str()); LOG(INFO) << logMessage.c_str(); } void CefPythonApp::OnRenderProcessThreadCreated( CefRefPtr extra_info) { #ifdef BROWSER_PROCESS // If you have an existing CefListValue that you would like // to provide, do this: // | extra_info = mylist.get() // The equivalent in Cython is: // | extra_info.Assign(mylist.get()) REQUIRE_IO_THREAD(); // Eg.: // | extra_info->SetBool(0, false); // | extra_info->SetString(1, "test"); // This is included only in the Browser process, when building // the libcefpythonapp library. BrowserProcessHandler_OnRenderProcessThreadCreated(extra_info); #endif // BROWSER_PROCESS } CefRefPtr CefPythonApp::GetPrintHandler() { #ifdef BROWSER_PROCESS #if defined(OS_LINUX) // For print handler to work GTK must be initialized. This is // required for some of the examples. GdkDisplay* gdk_display = gdk_display_get_default(); if (!gdk_display) { LOG(INFO) << "[Browser process] Initialize GTK"; gtk_init(0, NULL); } #endif #endif return print_handler_; } // ----------------------------------------------------------------------------- // CefRenderProcessHandler // ----------------------------------------------------------------------------- void CefPythonApp::OnRenderThreadCreated(CefRefPtr extra_info) { } void CefPythonApp::OnWebKitInitialized() { } void CefPythonApp::OnBrowserCreated(CefRefPtr browser) { } void CefPythonApp::OnBrowserDestroyed(CefRefPtr browser) { LOG(INFO) << "[Renderer process] OnBrowserDestroyed()"; RemoveJavascriptBindings(browser); } bool CefPythonApp::OnBeforeNavigation(CefRefPtr browser, CefRefPtr frame, CefRefPtr request, cef_navigation_type_t navigation_type, bool is_redirect) { return false; } void CefPythonApp::OnContextCreated(CefRefPtr browser, CefRefPtr frame, CefRefPtr context) { LOG(INFO) << "[Renderer process] OnContextCreated()"; CefRefPtr message = CefProcessMessage::Create( "OnContextCreated"); CefRefPtr arguments = message->GetArgumentList(); /* Sending int64 type using process messaging would require converting it to a string or a binary, or you could send two ints, see this topic: http://www.magpcss.org/ceforum/viewtopic.php?f=6&t=10869 */ /* // Example of converting int64 to string. Still need an // example of converting it back from string. std::string logMessage = "[Renderer process] OnContextCreated(): frameId="; stringstream stream; int64 value = frame->GetIdentifier(); stream << value; logMessage.append(stream.str()); LOG(INFO) << logMessage.c_str(); */ // TODO: losing int64 precision, the solution is to convert // it to string and then in the Browser process back // from string to int64. But it is rather unlikely // that number of frames will exceed int range, so // casting it to int for now. arguments->SetInt(0, (int)(frame->GetIdentifier())); browser->SendProcessMessage(PID_BROWSER, message); CefRefPtr jsBindings = GetJavascriptBindings(browser); if (jsBindings.get()) { // Javascript bindings are most probably not yet set for // the main frame, they will be set a moment later due to // process messaging delay. The code seems to be executed // only for iframes. if (frame->IsMain()) { DoJavascriptBindingsForFrame(browser, frame, context); } else { if (jsBindings->HasKey("bindToFrames") && jsBindings->GetType("bindToFrames") == VTYPE_BOOL && jsBindings->GetBool("bindToFrames")) { DoJavascriptBindingsForFrame(browser, frame, context); } } } } void CefPythonApp::OnContextReleased(CefRefPtr browser, CefRefPtr frame, CefRefPtr context) { LOG(INFO) << "[Renderer process] OnContextReleased()"; CefRefPtr message; CefRefPtr arguments; // ------------------------------------------------------------------------ // 1. Send "OnContextReleased" message. // ------------------------------------------------------------------------ message = CefProcessMessage::Create("OnContextReleased"); arguments = message->GetArgumentList(); arguments->SetInt(0, browser->GetIdentifier()); // TODO: losing int64 precision, the solution is to convert // it to string and then in the Browser process back // from string to int64. But it is rather unlikely // that number of frames will exceed int range, so // casting it to int for now. arguments->SetInt(1, (int)(frame->GetIdentifier())); // Should we send the message using current "browser" // when this is not the main frame? It could fail, so // it is more reliable to always use the main browser. browser->SendProcessMessage(PID_BROWSER, message); // ------------------------------------------------------------------------ // 2. Remove python callbacks for a frame. // ------------------------------------------------------------------------ // If this is the main frame then the message won't arrive // to the browser process, as browser is being destroyed, // but it doesn't matter because in LifespanHandler_BeforeClose() // we're calling RemovePythonCallbacksForBrowser(). message = CefProcessMessage::Create("RemovePythonCallbacksForFrame"); arguments = message->GetArgumentList(); // TODO: int64 precision lost arguments->SetInt(0, (int)(frame->GetIdentifier())); browser->SendProcessMessage(PID_BROWSER, message); // ------------------------------------------------------------------------ // 3. Clear javascript callbacks. // ------------------------------------------------------------------------ RemoveJavascriptCallbacksForFrame(frame); } void CefPythonApp::OnUncaughtException(CefRefPtr browser, CefRefPtr frame, CefRefPtr context, CefRefPtr exception, CefRefPtr stackTrace) { } void CefPythonApp::OnFocusedNodeChanged(CefRefPtr browser, CefRefPtr frame, CefRefPtr node) { } bool CefPythonApp::OnProcessMessageReceived(CefRefPtr browser, CefProcessId source_process, CefRefPtr message) { std::string messageName = message->GetName().ToString(); std::string logMessage = "[Renderer process] OnProcessMessageReceived(): "; logMessage.append(messageName.c_str()); LOG(INFO) << logMessage.c_str(); CefRefPtr args = message->GetArgumentList(); if (messageName == "DoJavascriptBindings") { if (args->GetSize() == 1 && args->GetType(0) == VTYPE_DICTIONARY && args->GetDictionary(0)->IsValid()) { // Is it necessary to make a copy? It won't harm. SetJavascriptBindings(browser, args->GetDictionary(0)->Copy(false)); DoJavascriptBindingsForBrowser(browser); } else { LOG(ERROR) << "[Renderer process] OnProcessMessageReceived():" " invalid arguments," " messageName=DoJavascriptBindings"; return false; } } else if (messageName == "ExecuteJavascriptCallback") { if (args->GetType(0) == VTYPE_INT) { int jsCallbackId = args->GetInt(0); CefRefPtr jsArgs; if (args->IsReadOnly()) { jsArgs = args->Copy(); } else { jsArgs = args; } // Remove jsCallbackId. jsArgs->Remove(0); ExecuteJavascriptCallback(jsCallbackId, jsArgs); } else { LOG(ERROR) << "[Renderer process] OnProcessMessageReceived:" " invalid arguments, expected first argument to be" " a javascript callback (int)"; return false; } } return true; } void CefPythonApp::SetJavascriptBindings(CefRefPtr browser, CefRefPtr data) { javascriptBindings_[browser->GetIdentifier()] = data; } CefRefPtr CefPythonApp::GetJavascriptBindings( CefRefPtr browser) { int browserId = browser->GetIdentifier(); if (javascriptBindings_.find(browserId) != javascriptBindings_.end()) { return javascriptBindings_[browserId]; } return NULL; } void CefPythonApp::RemoveJavascriptBindings(CefRefPtr browser) { int browserId = browser->GetIdentifier(); if (javascriptBindings_.find(browserId) != javascriptBindings_.end()) { javascriptBindings_.erase(browserId); } } bool CefPythonApp::BindedFunctionExists(CefRefPtr browser, const CefString& functionName) { CefRefPtr jsBindings = GetJavascriptBindings(browser); if (!jsBindings.get()) { return false; } std::string strFunctionName = functionName.ToString(); size_t dotPosition = strFunctionName.find("."); if (std::string::npos != dotPosition) { // This is a method call, functionName == "object.method". CefString objectName(strFunctionName.substr(0, dotPosition)); CefString methodName(strFunctionName.substr(dotPosition + 1, std::string::npos)); if (!(jsBindings->HasKey("objects") && jsBindings->GetType("objects") == VTYPE_DICTIONARY)) { LOG(ERROR) << "[Renderer process] BindedFunctionExists():" " objects dictionary not found"; return false; } CefRefPtr objects = \ jsBindings->GetDictionary("objects"); if (objects->HasKey(objectName)) { if (!(objects->GetType(objectName) == VTYPE_DICTIONARY)) { LOG(ERROR) << "[Renderer process] BindedFunctionExists():" " objects dictionary has invalid type"; return false; } CefRefPtr methods = \ objects->GetDictionary(objectName); return methods->HasKey(methodName); } else { return false; } } else { // This is a function call. if (!(jsBindings->HasKey("functions") && jsBindings->GetType("functions") == VTYPE_DICTIONARY)) { LOG(ERROR) << "[Renderer process] BindedFunctionExists():" " functions dictionary not found"; return false; } CefRefPtr functions = \ jsBindings->GetDictionary("functions"); return functions->HasKey(functionName); } } void CefPythonApp::DoJavascriptBindingsForBrowser( CefRefPtr browser) { // get frame // get context // if bindToFrames is true loop through all frames, // otherwise just the main frame. // post task on a valid v8 thread CefRefPtr jsBindings = GetJavascriptBindings(browser); if (!jsBindings.get()) { // Bindings must be set before this function is called. LOG(ERROR) << "[Renderer process] DoJavascriptBindingsForBrowser():" " bindings not set"; return; } std::vector frameIds; std::vector frameNames; if (jsBindings->HasKey("bindToFrames") && jsBindings->GetType("bindToFrames") == VTYPE_BOOL && jsBindings->GetBool("bindToFrames")) { // GetFrameIdentifiers() is buggy, returns always a vector // filled with zeroes (as of revision 1448). Use GetFrameNames() // instead. browser->GetFrameNames(frameNames); for (std::vector::iterator it = frameNames.begin(); \ it != frameNames.end(); ++it) { CefRefPtr frame = browser->GetFrame(*it); if (frame.get()) { frameIds.push_back(frame->GetIdentifier()); // | printf("GetFrameNames(): frameId = %lu\n", // | frame->GetIdentifier()); } } } // BUG in CEF: // GetFrameNames() does not return the main frame (as of revision 1448). // Make it work for the future when this bug gets fixed. std::vector::iterator find_it = std::find( frameIds.begin(), frameIds.end(), browser->GetMainFrame()->GetIdentifier()); if (find_it == frameIds.end()) { // Main frame not found in frameIds vector, add it now. // | printf("Adding main frame to frameIds: %lu\n", // | browser->GetMainFrame()->GetIdentifier()); frameIds.push_back(browser->GetMainFrame()->GetIdentifier()); } if (!frameIds.size()) { LOG(ERROR) << "[Renderer process] DoJavascriptBindingsForBrowser():" " frameIds.size() == 0"; return; } for (std::vector::iterator it = frameIds.begin(); \ it != frameIds.end(); ++it) { if (*it <= 0) { // GetFrameIdentifiers() bug that returned a vector // filled with zeros. This problem was fixed by using' // GetFrameNames() so this block of code should not // be executed anymore. LOG(ERROR) << "[Renderer process] DoJavascriptBindingsForBrowser():" " frameId <= 0"; // printf("[CEF Python] Renderer: frameId = %lli\n", *it); continue; } CefRefPtr frame = browser->GetFrame(*it); if (!frame.get()) { LOG(ERROR) << "[Renderer process] DoJavascriptBindingsForBrowser():" " GetFrame() failed"; continue; } CefRefPtr context = frame->GetV8Context(); CefRefPtr taskRunner = context->GetTaskRunner(); taskRunner->PostTask(CefCreateClosureTask(base::Bind( &CefPythonApp::DoJavascriptBindingsForFrame, this, browser, frame, context ))); } } void CefPythonApp::DoJavascriptBindingsForFrame(CefRefPtr browser, CefRefPtr frame, CefRefPtr context) { CefRefPtr jsBindings = GetJavascriptBindings(browser); if (!jsBindings.get()) { // Bindings may not yet be set, it's okay. LOG(INFO) << "[Renderer process] DoJavascriptBindingsForFrame():" " bindings not set yet"; return; } LOG(INFO) << "[Renderer process] DoJavascriptBindingsForFrame():" " bindings are set"; if (!(jsBindings->HasKey("functions") && jsBindings->GetType("functions") == VTYPE_DICTIONARY && jsBindings->HasKey("properties") && jsBindings->GetType("properties") == VTYPE_DICTIONARY && jsBindings->HasKey("objects") && jsBindings->GetType("objects") == VTYPE_DICTIONARY && jsBindings->HasKey("bindToFrames") && jsBindings->GetType("bindToFrames") == VTYPE_BOOL)) { LOG(ERROR) << "[Renderer process] DoJavascriptBindingsForFrame():" " invalid data [1]"; return; } // A context must be explicitly entered before creating a // V8 Object, Array, Function or Date asynchronously. // NOTE: you cannot call CefV8Context::GetEnteredContext // or GetCurrentContext when CefV8Context::InContext // returns false, as it will result in crashes. bool didEnterContext = false; if (!CefV8Context::InContext()) { if (!context->IsValid()) { // BUG in CEF (Issue 130), the "context" provided by CEF may // not be valid. May be a timing issue. Or may be caused by // a redirect to a different origin and that creates a new // renderer process. // This message is logged in the tutorial.py example which // uses data uri created from html string. LOG(INFO) << "[Renderer process] DoJavascriptBindingsForFrame():" " V8 context provided by CEF is invalid"; return; } context->Enter(); didEnterContext = true; } CefRefPtr functions = \ jsBindings->GetDictionary("functions"); CefRefPtr properties = \ jsBindings->GetDictionary("properties"); CefRefPtr objects = \ jsBindings->GetDictionary("objects"); // Here in this function we bind only for the current frame. // | bool bindToFrames = jsBindings->GetBool("bindToFrames"); if (!(functions->IsValid() && properties->IsValid() && objects->IsValid())) { LOG(ERROR) << "[Renderer process] DoJavascriptBindingsForFrame():" " invalid data [2]"; if (didEnterContext) context->Exit(); return; } CefRefPtr v8Window = context->GetGlobal(); CefRefPtr v8Function; CefRefPtr v8FunctionHandler(new V8FunctionHandler(this, 0)); // FUNCTIONS. std::vector functionsVector; if (!functions->GetKeys(functionsVector)) { LOG(ERROR) << "[Renderer process] DoJavascriptBindingsForFrame():" " functions->GetKeys() failed"; if (didEnterContext) context->Exit(); return; } for (std::vector::iterator it = functionsVector.begin(); \ it != functionsVector.end(); ++it) { CefString functionName = *it; v8Function = CefV8Value::CreateFunction(functionName, v8FunctionHandler); v8Window->SetValue(functionName, v8Function, V8_PROPERTY_ATTRIBUTE_NONE); } // PROPERTIES. CefRefPtr v8Properties = CefDictionaryValueToV8Value( properties); std::vector v8Keys; if (!v8Properties->GetKeys(v8Keys)) { LOG(ERROR) << "[Renderer process] DoJavascriptBindingsForFrame():" " v8Properties->GetKeys() failed"; if (didEnterContext) context->Exit(); return; } for (std::vector::iterator it = v8Keys.begin(); \ it != v8Keys.end(); ++it) { CefString v8Key = *it; CefRefPtr v8Value = v8Properties->GetValue(v8Key); v8Window->SetValue(v8Key, v8Value, V8_PROPERTY_ATTRIBUTE_NONE); } // OBJECTS AND ITS METHODS. std::vector objectsVector; if (!objects->GetKeys(objectsVector)) { LOG(ERROR) << "[Renderer process] DoJavascriptBindingsForFrame():" " objects->GetKeys() failed"; if (didEnterContext) context->Exit(); return; } for (std::vector::iterator it = objectsVector.begin(); \ it != objectsVector.end(); ++it) { CefString objectName = *it; CefRefPtr v8Object = CefV8Value::CreateObject(NULL); v8Window->SetValue(objectName, v8Object, V8_PROPERTY_ATTRIBUTE_NONE); // METHODS. if (!(objects->GetType(objectName) == VTYPE_DICTIONARY)) { LOG(ERROR) << "[Renderer process] DoJavascriptBindingsForFrame():" " objects->GetType() != VTYPE_DICTIONARY"; if (didEnterContext) context->Exit(); return; } CefRefPtr methods = \ objects->GetDictionary(objectName); std::vector methodsVector; if (!(methods->IsValid() && methods->GetKeys(methodsVector))) { LOG(ERROR) << "[Renderer process] DoJavascriptBindingsForFrame():" " methods->GetKeys() failed"; if (didEnterContext) context->Exit(); return; } for (std::vector::iterator it = methodsVector.begin(); \ it != methodsVector.end(); ++it) { CefString methodName = *it; // fullMethodName = "object.method" std::string fullMethodName = objectName.ToString().append(".") \ .append(methodName.ToString()); v8Function = CefV8Value::CreateFunction(fullMethodName, v8FunctionHandler); v8Object->SetValue(methodName, v8Function, V8_PROPERTY_ATTRIBUTE_NONE); } } // END. if (didEnterContext) context->Exit(); } cefpython-49.0/src/subprocess/cefpython_app.h000066400000000000000000000112041334103266300214330ustar00rootroot00000000000000// Copyright (c) 2012 CEF Python, see the Authors file. // All rights reserved. Licensed under BSD 3-clause license. // Project website: https://github.com/cztomczak/cefpython #pragma once #include "include/cef_app.h" #include "include/cef_print_handler.h" #include // CefPythonApp class is instantiated in subprocess and in // cefpython.pyx for the browser process, so the code is shared. // Using printf() in CefRenderProcessHandler won't work on some // operating systems, use LOG(INFO) macro instead, it will write // the message to the "debug.log" file. class CefPythonApp : public CefApp, public CefBrowserProcessHandler, public CefRenderProcessHandler { protected: std::map > javascriptBindings_; CefRefPtr print_handler_; public: CefPythonApp(); void OnBeforeCommandLineProcessing( const CefString& process_type, CefRefPtr command_line) override; void OnRegisterCustomSchemes( CefRefPtr registrar) override; CefRefPtr GetResourceBundleHandler() override; CefRefPtr GetBrowserProcessHandler() override; CefRefPtr GetRenderProcessHandler() override; // --------------------------------------------------------------------------- // CefBrowserProcessHandler // --------------------------------------------------------------------------- void OnContextInitialized() override; void OnBeforeChildProcessLaunch( CefRefPtr command_line) override; void OnRenderProcessThreadCreated( CefRefPtr extra_info) override; CefRefPtr GetPrintHandler() override; // --------------------------------------------------------------------------- // CefRenderProcessHandler // --------------------------------------------------------------------------- void OnRenderThreadCreated(CefRefPtr extra_info) override; void OnWebKitInitialized() override; void OnBrowserCreated(CefRefPtr browser) override; void OnBrowserDestroyed(CefRefPtr browser) override; bool OnBeforeNavigation(CefRefPtr browser, CefRefPtr frame, CefRefPtr request, cef_navigation_type_t navigation_type, bool is_redirect) override; void OnContextCreated(CefRefPtr browser, CefRefPtr frame, CefRefPtr context) override; void OnContextReleased(CefRefPtr browser, CefRefPtr frame, CefRefPtr context) override; void OnUncaughtException(CefRefPtr browser, CefRefPtr frame, CefRefPtr context, CefRefPtr exception, CefRefPtr stackTrace) override; void OnFocusedNodeChanged(CefRefPtr browser, CefRefPtr frame, CefRefPtr node) override; bool OnProcessMessageReceived(CefRefPtr browser, CefProcessId source_process, CefRefPtr message) override; // --------------------------------------------------------------------------- // Javascript bindings // --------------------------------------------------------------------------- void SetJavascriptBindings(CefRefPtr browser, CefRefPtr data); CefRefPtr GetJavascriptBindings( CefRefPtr browser); void RemoveJavascriptBindings(CefRefPtr browser); bool BindedFunctionExists(CefRefPtr browser, const CefString& funcName); void DoJavascriptBindingsForBrowser(CefRefPtr browser); void DoJavascriptBindingsForFrame(CefRefPtr browser, CefRefPtr frame, CefRefPtr context); private: IMPLEMENT_REFCOUNTING(CefPythonApp); }; cefpython-49.0/src/subprocess/deprecated/000077500000000000000000000000001334103266300205255ustar00rootroot00000000000000cefpython-49.0/src/subprocess/deprecated/deprecated_libcefpythonapp_py27_64bit.vcproj000066400000000000000000000075311334103266300312200ustar00rootroot00000000000000 cefpython-49.0/src/subprocess/deprecated/deprecated_libcefpythonapp_py27_win32.vcproj000066400000000000000000000067001334103266300312270ustar00rootroot00000000000000 cefpython-49.0/src/subprocess/deprecated/deprecated_libcefpythonapp_py34_32bit.vcproj000066400000000000000000000074501334103266300312110ustar00rootroot00000000000000 cefpython-49.0/src/subprocess/deprecated/deprecated_subprocess_64bit.vcproj000066400000000000000000000064011334103266300273330ustar00rootroot00000000000000 cefpython-49.0/src/subprocess/deprecated/deprecated_subprocess_win32.vcproj000066400000000000000000000100521334103266300273420ustar00rootroot00000000000000 cefpython-49.0/src/subprocess/javascript_callback.cpp000066400000000000000000000076111334103266300231200ustar00rootroot00000000000000// Copyright (c) 2013 CEF Python, see the Authors file. // All rights reserved. Licensed under BSD 3-clause license. // Project website: https://github.com/cztomczak/cefpython #include "javascript_callback.h" #include #include #include "v8utils.h" #include "cefpython_app.h" #include "include/base/cef_logging.h" template inline std::string AnyToString(const T& value) { std::ostringstream oss; oss << value; return oss.str(); } typedef std::map, CefRefPtr > > JavascriptCallbackMap; JavascriptCallbackMap g_jsCallbackMap; int g_jsCallbackMaxId = 0; CefString PutJavascriptCallback( CefRefPtr frame, CefRefPtr jsCallback) { // Returns a "####cefpython####" string followed by json encoded data. // {"what":"javascript-callback","callbackId":123, // "frameId":123,"functionName":"xx"} int callbackId = ++g_jsCallbackMaxId; int64 frameId = frame->GetIdentifier(); CefString functionName = jsCallback->GetFunctionName(); std::string strCallbackId = "####cefpython####"; strCallbackId.append("{"); // JSON format allows only for double quotes. strCallbackId.append("\"what\":\"javascript-callback\""); strCallbackId.append(",\"callbackId\":").append(AnyToString(callbackId)); strCallbackId.append(",\"frameId\":").append(AnyToString(frameId)); strCallbackId.append(",\"functionName\":\"").append(functionName) \ .append("\""); strCallbackId.append("}"); g_jsCallbackMap.insert(std::make_pair( callbackId, std::make_pair(frame, jsCallback))); return strCallbackId; } bool ExecuteJavascriptCallback(int callbackId, CefRefPtr args) { if (g_jsCallbackMap.empty()) { LOG(ERROR) << "[Renderer process] ExecuteJavascriptCallback():" " callback map is empty"; return false; } JavascriptCallbackMap::const_iterator it = g_jsCallbackMap.find( callbackId); if (it == g_jsCallbackMap.end()) { std::string logMessage = "[Renderer process]" " ExecuteJavascriptCallback():" " callback not found, id="; logMessage.append(AnyToString(callbackId)); LOG(ERROR) << logMessage.c_str(); return false; } CefRefPtr frame = it->second.first; CefRefPtr callback = it->second.second; CefRefPtr context = frame->GetV8Context(); context->Enter(); CefV8ValueList v8Arguments = CefListValueToCefV8ValueList(args); CefRefPtr v8ReturnValue = callback->ExecuteFunction( NULL, v8Arguments); if (v8ReturnValue.get()) { context->Exit(); return true; } else { context->Exit(); LOG(ERROR) << "[Renderer process] ExecuteJavascriptCallback():" " callback->ExecuteFunction() failed"; return false; } } void RemoveJavascriptCallbacksForFrame(CefRefPtr frame) { if (g_jsCallbackMap.empty()) { return; } JavascriptCallbackMap::iterator it = g_jsCallbackMap.begin(); int64 frameId = frame->GetIdentifier(); while (it != g_jsCallbackMap.end()) { if (it->second.first->GetIdentifier() == frameId) { // Pass current iterator and increment it after passing // to the function, but before erase() is called, this // is important for it to work in a loop. You can't do this: // | if (..) erase(it); // | ++it; // This would cause an infinite loop. g_jsCallbackMap.erase(it++); LOG(INFO) << "[Renderer process]" " RemoveJavascriptCallbacksForFrame():" " removed js callback from the map"; } else { ++it; } } } cefpython-49.0/src/subprocess/javascript_callback.h000066400000000000000000000007251334103266300225640ustar00rootroot00000000000000// Copyright (c) 2013 CEF Python, see the Authors file. // All rights reserved. Licensed under BSD 3-clause license. // Project website: https://github.com/cztomczak/cefpython #pragma once #include "include/cef_v8.h" CefString PutJavascriptCallback( CefRefPtr frame, CefRefPtr jsCallback); bool ExecuteJavascriptCallback(int callbackId, CefRefPtr args); void RemoveJavascriptCallbacksForFrame(CefRefPtr frame); cefpython-49.0/src/subprocess/main.cpp000066400000000000000000000022541334103266300200600ustar00rootroot00000000000000// Copyright (c) 2013 CEF Python, see the Authors file. // All rights reserved. Licensed under BSD 3-clause license. // Project website: https://github.com/cztomczak/cefpython #include "cefpython_app.h" #if defined(OS_WIN) #include int APIENTRY wWinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPTSTR lpCmdLine, int nCmdShow) { UNREFERENCED_PARAMETER(hPrevInstance); UNREFERENCED_PARAMETER(lpCmdLine); // lpCmdLine does not include program name argument, must // use GetCommandLineW(). Cannot use CefCommandLine::GetGlobalCommandLine, // as CEF was not yet initialized. CefRefPtr command_line = \ CefCommandLine::CreateCommandLine(); command_line->InitFromString(GetCommandLineW()); if (command_line->HasSwitch("enable-high-dpi-support")) { CefEnableHighDPISupport(); } CefMainArgs mainArgs(hInstance); #else // defined(OS_WIN) int main(int argc, char **argv) { CefMainArgs mainArgs(argc, argv); #endif // Mac, Linux CefRefPtr app(new CefPythonApp); int exitCode = CefExecuteProcess(mainArgs, app.get(), NULL); return exitCode; } cefpython-49.0/src/subprocess/print_handler_gtk.cpp000066400000000000000000000423731334103266300226400ustar00rootroot00000000000000// COPIED from upstream cef/tests/cefclient/browser/ // with minor modifications. // Copyright (c) 2014 The Chromium Embedded Framework Authors. // Portions Copyright (c) 2012 The Chromium Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. #include "print_handler_gtk.h" #include #include "include/base/cef_logging.h" #include "include/base/cef_macros.h" #include "include/wrapper/cef_helpers.h" namespace { // CUPS Duplex attribute and values. const char kCUPSDuplex[] = "cups-Duplex"; const char kDuplexNone[] = "None"; const char kDuplexTumble[] = "DuplexTumble"; const char kDuplexNoTumble[] = "DuplexNoTumble"; // CUPS color mode attribute and values. const char kCUPSColorMode[] = "cups-ColorMode"; const char kCUPSColorModel[] = "cups-ColorModel"; const char kCUPSPrintoutMode[] = "cups-PrintoutMode"; const char kCUPSProcessColorModel[] = "cups-ProcessColorModel"; const char kBlack[] = "Black"; const char kCMYK[] = "CMYK"; const char kCMY_K[] = "CMY+K"; const char kCMY[] = "CMY"; const char kColor[] = "Color"; const char kGray[] = "Gray"; const char kGrayscale[] = "Grayscale"; const char kGreyscale[] = "Greyscale"; const char kMonochrome[] = "Monochrome"; const char kNormal[] = "Normal"; const char kNormalGray[] = "Normal.Gray"; const char kRGB[] = "RGB"; const char kRGBA[] = "RGBA"; const char kRGB16[] = "RGB16"; // Default margin settings. const double kTopMarginInInch = 0.25; const double kBottomMarginInInch = 0.56; const double kLeftMarginInInch = 0.25; const double kRightMarginInInch = 0.25; // Length of an inch in CSS's 1px unit. // http://dev.w3.org/csswg/css3-values/#the-px-unit const int kPixelsPerInch = 96; // LETTER: 8.5 x 11 inches const float kLetterWidthInch = 8.5f; const float kLetterHeightInch = 11.0f; class StickyPrintSettingGtk { public: StickyPrintSettingGtk() : last_used_settings_(gtk_print_settings_new()) { } ~StickyPrintSettingGtk() { NOTREACHED(); // The instance is intentionally leaked. } GtkPrintSettings* settings() { return last_used_settings_; } void SetLastUsedSettings(GtkPrintSettings* settings) { DCHECK(last_used_settings_); g_object_unref(last_used_settings_); last_used_settings_ = gtk_print_settings_copy(settings); } private: GtkPrintSettings* last_used_settings_; DISALLOW_COPY_AND_ASSIGN(StickyPrintSettingGtk); }; // Lazily initialize the singleton instance. StickyPrintSettingGtk* GetLastUsedSettings() { static StickyPrintSettingGtk* settings = NULL; if (!settings) settings = new StickyPrintSettingGtk(); return settings; } // Helper class to track GTK printers. class GtkPrinterList { public: GtkPrinterList() : default_printer_(NULL) { gtk_enumerate_printers(SetPrinter, this, NULL, TRUE); } ~GtkPrinterList() { for (std::vector::iterator it = printers_.begin(); it < printers_.end(); ++it) { g_object_unref(*it); } } // Can return NULL if there's no default printer. E.g. Printer on a laptop // is "home_printer", but the laptop is at work. GtkPrinter* default_printer() { return default_printer_; } // Can return NULL if the printer cannot be found due to: // - Printer list out of sync with printer dialog UI. // - Querying for non-existant printers like 'Print to PDF'. GtkPrinter* GetPrinterWithName(const std::string& name) { if (name.empty()) return NULL; for (std::vector::iterator it = printers_.begin(); it < printers_.end(); ++it) { if (gtk_printer_get_name(*it) == name) { return *it; } } return NULL; } private: // Callback function used by gtk_enumerate_printers() to get all printer. static gboolean SetPrinter(GtkPrinter* printer, gpointer data) { GtkPrinterList* printer_list = reinterpret_cast(data); if (gtk_printer_is_default(printer)) printer_list->default_printer_ = printer; g_object_ref(printer); printer_list->printers_.push_back(printer); return FALSE; } std::vector printers_; GtkPrinter* default_printer_; }; void GetColorModelForMode(CefPrintSettings::ColorModel color_mode, std::string* color_setting_name, std::string* color_value) { color_setting_name->assign(kCUPSColorModel); switch (color_mode) { case COLOR_MODEL_COLOR: color_value->assign(kColor); break; case COLOR_MODEL_CMYK: color_value->assign(kCMYK); break; case COLOR_MODEL_PRINTOUTMODE_NORMAL: color_value->assign(kNormal); color_setting_name->assign(kCUPSPrintoutMode); break; case COLOR_MODEL_PRINTOUTMODE_NORMAL_GRAY: color_value->assign(kNormalGray); color_setting_name->assign(kCUPSPrintoutMode); break; case COLOR_MODEL_RGB16: color_value->assign(kRGB16); break; case COLOR_MODEL_RGBA: color_value->assign(kRGBA); break; case COLOR_MODEL_RGB: color_value->assign(kRGB); break; case COLOR_MODEL_CMY: color_value->assign(kCMY); break; case COLOR_MODEL_CMY_K: color_value->assign(kCMY_K); break; case COLOR_MODEL_BLACK: color_value->assign(kBlack); break; case COLOR_MODEL_GRAY: color_value->assign(kGray); break; case COLOR_MODEL_COLORMODE_COLOR: color_setting_name->assign(kCUPSColorMode); color_value->assign(kColor); break; case COLOR_MODEL_COLORMODE_MONOCHROME: color_setting_name->assign(kCUPSColorMode); color_value->assign(kMonochrome); break; case COLOR_MODEL_HP_COLOR_COLOR: color_setting_name->assign(kColor); color_value->assign(kColor); break; case COLOR_MODEL_HP_COLOR_BLACK: color_setting_name->assign(kColor); color_value->assign(kBlack); break; case COLOR_MODEL_PROCESSCOLORMODEL_CMYK: color_setting_name->assign(kCUPSProcessColorModel); color_value->assign(kCMYK); break; case COLOR_MODEL_PROCESSCOLORMODEL_GREYSCALE: color_setting_name->assign(kCUPSProcessColorModel); color_value->assign(kGreyscale); break; case COLOR_MODEL_PROCESSCOLORMODEL_RGB: color_setting_name->assign(kCUPSProcessColorModel); color_value->assign(kRGB); break; default: color_value->assign(kGrayscale); break; } } void InitPrintSettings(GtkPrintSettings* settings, GtkPageSetup* page_setup, CefRefPtr print_settings) { DCHECK(settings); DCHECK(page_setup); std::string device_name; const gchar* name = gtk_print_settings_get_printer(settings); if (name) device_name = name; print_settings->SetDeviceName(device_name); CefSize physical_size_device_units; CefRect printable_area_device_units; int dpi = gtk_print_settings_get_resolution(settings); if (dpi) { // Initialize page_setup_device_units_. physical_size_device_units.Set( gtk_page_setup_get_paper_width(page_setup, GTK_UNIT_INCH) * dpi, gtk_page_setup_get_paper_height(page_setup, GTK_UNIT_INCH) * dpi); printable_area_device_units.Set( gtk_page_setup_get_left_margin(page_setup, GTK_UNIT_INCH) * dpi, gtk_page_setup_get_top_margin(page_setup, GTK_UNIT_INCH) * dpi, gtk_page_setup_get_page_width(page_setup, GTK_UNIT_INCH) * dpi, gtk_page_setup_get_page_height(page_setup, GTK_UNIT_INCH) * dpi); } else { // Use default values if we cannot get valid values from the print dialog. dpi = kPixelsPerInch; double page_width_in_pixel = kLetterWidthInch * dpi; double page_height_in_pixel = kLetterHeightInch * dpi; physical_size_device_units.Set( static_cast(page_width_in_pixel), static_cast(page_height_in_pixel)); printable_area_device_units.Set( static_cast(kLeftMarginInInch * dpi), static_cast(kTopMarginInInch * dpi), page_width_in_pixel - (kLeftMarginInInch + kRightMarginInInch) * dpi, page_height_in_pixel - (kTopMarginInInch + kBottomMarginInInch) * dpi); } print_settings->SetDPI(dpi); // Note: With the normal GTK print dialog, when the user selects the landscape // orientation, all that does is change the paper size. Which seems to be // enough to render the right output and send it to the printer. // The orientation value stays as portrait and does not actually affect // printing. // Thus this is only useful in print preview mode, where we manually set the // orientation and change the paper size ourselves. GtkPageOrientation orientation = gtk_print_settings_get_orientation(settings); // Set before SetPrinterPrintableArea to make it flip area if necessary. print_settings->SetOrientation(orientation == GTK_PAGE_ORIENTATION_LANDSCAPE); print_settings->SetPrinterPrintableArea(physical_size_device_units, printable_area_device_units, true); } } // namespace ClientPrintHandlerGtk::ClientPrintHandlerGtk() : dialog_(NULL), gtk_settings_(NULL), page_setup_(NULL), printer_(NULL) { } void ClientPrintHandlerGtk::OnPrintStart(CefRefPtr browser) { } void ClientPrintHandlerGtk::OnPrintSettings( CefRefPtr settings, bool get_defaults) { if (get_defaults) { DCHECK(!page_setup_); DCHECK(!printer_); // |gtk_settings_| is a new copy. gtk_settings_ = gtk_print_settings_copy(GetLastUsedSettings()->settings()); page_setup_ = gtk_page_setup_new(); } else { if (!gtk_settings_) { gtk_settings_ = gtk_print_settings_copy(GetLastUsedSettings()->settings()); } GtkPrinterList* printer_list = new GtkPrinterList; printer_ = printer_list->GetPrinterWithName(settings->GetDeviceName()); if (printer_) { g_object_ref(printer_); gtk_print_settings_set_printer(gtk_settings_, gtk_printer_get_name(printer_)); if (!page_setup_) { page_setup_ = gtk_printer_get_default_page_size(printer_); } } gtk_print_settings_set_n_copies(gtk_settings_, settings->GetCopies()); gtk_print_settings_set_collate(gtk_settings_, settings->WillCollate()); std::string color_value; std::string color_setting_name; GetColorModelForMode(settings->GetColorModel(), &color_setting_name, &color_value); gtk_print_settings_set(gtk_settings_, color_setting_name.c_str(), color_value.c_str()); if (settings->GetDuplexMode() != DUPLEX_MODE_UNKNOWN) { const char* cups_duplex_mode = NULL; switch (settings->GetDuplexMode()) { case DUPLEX_MODE_LONG_EDGE: cups_duplex_mode = kDuplexNoTumble; break; case DUPLEX_MODE_SHORT_EDGE: cups_duplex_mode = kDuplexTumble; break; case DUPLEX_MODE_SIMPLEX: cups_duplex_mode = kDuplexNone; break; default: // UNKNOWN_DUPLEX_MODE NOTREACHED(); break; } gtk_print_settings_set(gtk_settings_, kCUPSDuplex, cups_duplex_mode); } if (!page_setup_) page_setup_ = gtk_page_setup_new(); gtk_print_settings_set_orientation( gtk_settings_, settings->IsLandscape() ? GTK_PAGE_ORIENTATION_LANDSCAPE : GTK_PAGE_ORIENTATION_PORTRAIT); delete printer_list; } InitPrintSettings(gtk_settings_, page_setup_, settings); } bool ClientPrintHandlerGtk::OnPrintDialog( bool has_selection, CefRefPtr callback) { dialog_callback_ = callback; // TODO(cef): Identify the correct parent window. GtkWindow* parent = NULL; // TODO(estade): We need a window title here. dialog_ = gtk_print_unix_dialog_new(NULL, parent); g_signal_connect(dialog_, "delete-event", G_CALLBACK(gtk_widget_hide_on_delete), NULL); // Set modal so user cannot focus the same tab and press print again. gtk_window_set_modal(GTK_WINDOW(dialog_), TRUE); // Since we only generate PDF, only show printers that support PDF. // TODO(thestig) Add more capabilities to support? GtkPrintCapabilities cap = static_cast( GTK_PRINT_CAPABILITY_GENERATE_PDF | GTK_PRINT_CAPABILITY_PAGE_SET | GTK_PRINT_CAPABILITY_COPIES | GTK_PRINT_CAPABILITY_COLLATE | GTK_PRINT_CAPABILITY_REVERSE); gtk_print_unix_dialog_set_manual_capabilities(GTK_PRINT_UNIX_DIALOG(dialog_), cap); gtk_print_unix_dialog_set_embed_page_setup(GTK_PRINT_UNIX_DIALOG(dialog_), TRUE); gtk_print_unix_dialog_set_support_selection(GTK_PRINT_UNIX_DIALOG(dialog_), TRUE); gtk_print_unix_dialog_set_has_selection(GTK_PRINT_UNIX_DIALOG(dialog_), has_selection); gtk_print_unix_dialog_set_settings(GTK_PRINT_UNIX_DIALOG(dialog_), gtk_settings_); g_signal_connect(dialog_, "response", G_CALLBACK(OnDialogResponseThunk), this); gtk_widget_show(dialog_); return true; } bool ClientPrintHandlerGtk::OnPrintJob( const CefString& document_name, const CefString& pdf_file_path, CefRefPtr callback) { // If |printer_| is NULL then somehow the GTK printer list changed out under // us. In which case, just bail out. if (!printer_) return false; job_callback_ = callback; // Save the settings for next time. GetLastUsedSettings()->SetLastUsedSettings(gtk_settings_); GtkPrintJob* print_job = gtk_print_job_new( document_name.ToString().c_str(), printer_, gtk_settings_, page_setup_); gtk_print_job_set_source_file(print_job, pdf_file_path.ToString().c_str(), NULL); gtk_print_job_send(print_job, OnJobCompletedThunk, this, NULL); return true; } void ClientPrintHandlerGtk::OnPrintReset() { if (dialog_) { gtk_widget_destroy(dialog_); dialog_ = NULL; } if (gtk_settings_) { g_object_unref(gtk_settings_); gtk_settings_ = NULL; } if (page_setup_) { g_object_unref(page_setup_); page_setup_ = NULL; } if (printer_) { g_object_unref(printer_); printer_ = NULL; } } CefSize ClientPrintHandlerGtk::GetPdfPaperSize(int device_units_per_inch) { GtkPageSetup* page_setup = gtk_page_setup_new(); float width = gtk_page_setup_get_paper_width(page_setup, GTK_UNIT_INCH); float height = gtk_page_setup_get_paper_height(page_setup, GTK_UNIT_INCH); g_object_unref(page_setup); return CefSize(width * device_units_per_inch, height * device_units_per_inch); } void ClientPrintHandlerGtk::OnDialogResponse(GtkDialog *dialog, gint response_id) { int num_matched_handlers = g_signal_handlers_disconnect_by_func( dialog_, reinterpret_cast(&OnDialogResponseThunk), this); DCHECK_EQ(1, num_matched_handlers); gtk_widget_hide(dialog_); switch (response_id) { case GTK_RESPONSE_OK: { if (gtk_settings_) g_object_unref(gtk_settings_); gtk_settings_ = gtk_print_unix_dialog_get_settings( GTK_PRINT_UNIX_DIALOG(dialog_)); if (printer_) g_object_unref(printer_); printer_ = gtk_print_unix_dialog_get_selected_printer( GTK_PRINT_UNIX_DIALOG(dialog_)); g_object_ref(printer_); if (page_setup_) g_object_unref(page_setup_); page_setup_ = gtk_print_unix_dialog_get_page_setup( GTK_PRINT_UNIX_DIALOG(dialog_)); g_object_ref(page_setup_); // Handle page ranges. CefPrintSettings::PageRangeList ranges_vector; gint num_ranges; bool print_selection_only = false; switch (gtk_print_settings_get_print_pages(gtk_settings_)) { case GTK_PRINT_PAGES_RANGES: { GtkPageRange* gtk_range = gtk_print_settings_get_page_ranges(gtk_settings_, &num_ranges); if (gtk_range) { for (int i = 0; i < num_ranges; ++i) { ranges_vector.push_back( CefRange(gtk_range[i].start, gtk_range[i].end)); } g_free(gtk_range); } break; } case GTK_PRINT_PAGES_SELECTION: print_selection_only = true; break; case GTK_PRINT_PAGES_ALL: // Leave |ranges_vector| empty to indicate print all pages. break; case GTK_PRINT_PAGES_CURRENT: default: NOTREACHED(); break; } CefRefPtr settings = CefPrintSettings::Create(); settings->SetPageRanges(ranges_vector); settings->SetSelectionOnly(print_selection_only); InitPrintSettings(gtk_settings_, page_setup_, settings); dialog_callback_->Continue(settings); dialog_callback_ = NULL; return; } case GTK_RESPONSE_DELETE_EVENT: // Fall through. case GTK_RESPONSE_CANCEL: { dialog_callback_->Cancel(); dialog_callback_ = NULL; return; } case GTK_RESPONSE_APPLY: default: { NOTREACHED(); } } } void ClientPrintHandlerGtk::OnJobCompleted(GtkPrintJob* print_job, GError* error) { job_callback_->Continue(); job_callback_ = NULL; } cefpython-49.0/src/subprocess/print_handler_gtk.h000066400000000000000000000045101334103266300222740ustar00rootroot00000000000000// COPIED from upstream cef/tests/cefclient/browser/ // with minor modifications. // Copyright (c) 2014 The Chromium Embedded Framework Authors. // Portions Copyright (c) 2012 The Chromium Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. #ifndef CEF_TESTS_CEFCLIENT_BROWSER_PRINT_HANDLER_GTK_H_ #define CEF_TESTS_CEFCLIENT_BROWSER_PRINT_HANDLER_GTK_H_ #pragma once #include #include #include "include/cef_print_handler.h" class ClientPrintHandlerGtk : public CefPrintHandler { public: ClientPrintHandlerGtk(); // CefPrintHandler methods. void OnPrintStart(CefRefPtr browser) OVERRIDE; void OnPrintSettings(CefRefPtr settings, bool get_defaults) OVERRIDE; bool OnPrintDialog( bool has_selection, CefRefPtr callback) OVERRIDE; bool OnPrintJob(const CefString& document_name, const CefString& pdf_file_path, CefRefPtr callback) OVERRIDE; void OnPrintReset() OVERRIDE; CefSize GetPdfPaperSize(int device_units_per_inch) OVERRIDE; private: void OnDialogResponse(GtkDialog *dialog, gint response_id); void OnJobCompleted(GtkPrintJob* print_job, GError* error); static void OnDialogResponseThunk(GtkDialog *dialog, gint response_id, ClientPrintHandlerGtk* handler) { handler->OnDialogResponse(dialog, response_id); } static void OnJobCompletedThunk(GtkPrintJob* print_job, void* handler, GError* error) { static_cast(handler)-> OnJobCompleted(print_job, error); } // Print dialog settings. ClientPrintHandlerGtk owns |dialog_| and holds // references to the other objects. GtkWidget* dialog_; GtkPrintSettings* gtk_settings_; GtkPageSetup* page_setup_; GtkPrinter* printer_; CefRefPtr dialog_callback_; CefRefPtr job_callback_; IMPLEMENT_REFCOUNTING(ClientPrintHandlerGtk); DISALLOW_COPY_AND_ASSIGN(ClientPrintHandlerGtk); }; #endif // CEF_TESTS_CEFCLIENT_BROWSER_PRINT_HANDLER_GTK_H_ cefpython-49.0/src/subprocess/v8function_handler.cpp000066400000000000000000000060231334103266300227320ustar00rootroot00000000000000// Copyright (c) 2012 CEF Python, see the Authors file. // All rights reserved. Licensed under BSD 3-clause license. // Project website: https://github.com/cztomczak/cefpython #include "cefpython_app.h" #include "v8utils.h" #include "include/base/cef_logging.h" bool V8FunctionHandler::Execute(const CefString& functionName, CefRefPtr thisObject, const CefV8ValueList& v8Arguments, CefRefPtr& returnValue, CefString& exception) { if (!CefV8Context::InContext()) { // CefV8Context::GetCurrentContext may not be called when // not in a V8 context. LOG(ERROR) << "[Renderer process] V8FunctionHandler::Execute():" " not inside a V8 context"; return false; } CefRefPtr context = CefV8Context::GetCurrentContext(); CefRefPtr browser = context.get()->GetBrowser(); CefRefPtr frame = context.get()->GetFrame(); if (pythonCallbackId_) { LOG(INFO) << "[Renderer process] V8FunctionHandler::Execute():" " python callback"; CefRefPtr functionArguments = V8ValueListToCefListValue( v8Arguments); CefRefPtr processMessage = \ CefProcessMessage::Create("ExecutePythonCallback"); CefRefPtr messageArguments = \ processMessage->GetArgumentList(); messageArguments->SetInt(0, pythonCallbackId_); messageArguments->SetList(1, functionArguments); browser->SendProcessMessage(PID_BROWSER, processMessage); returnValue = CefV8Value::CreateNull(); return true; } else { LOG(INFO) << "[Renderer process] V8FunctionHandler::Execute():" " js binding"; if (!(cefPythonApp_.get() \ && cefPythonApp_->BindedFunctionExists( \ browser, functionName))) { exception = std::string("[CEF Python] " \ "V8FunctionHandler::Execute() FAILED: " \ "function does not exist: ").append(functionName) \ .append("()"); // Must return true for the exception to be thrown. return true; } CefRefPtr functionArguments = V8ValueListToCefListValue( v8Arguments); // TODO: losing int64 precision here. int frameId = (int)frame->GetIdentifier(); CefRefPtr processMessage = \ CefProcessMessage::Create("V8FunctionHandler::Execute"); CefRefPtr messageArguments = \ processMessage->GetArgumentList(); messageArguments->SetInt(0, frameId); messageArguments->SetString(1, functionName); messageArguments->SetList(2, functionArguments); browser->SendProcessMessage(PID_BROWSER, processMessage); returnValue = CefV8Value::CreateNull(); return true; } } cefpython-49.0/src/subprocess/v8function_handler.h000066400000000000000000000016471334103266300224060ustar00rootroot00000000000000// Copyright (c) 2012 CEF Python, see the Authors file. // All rights reserved. Licensed under BSD 3-clause license. // Project website: https://github.com/cztomczak/cefpython #pragma once #include "include/cef_v8.h" #include "util.h" class CefPythonApp; class V8FunctionHandler : public CefV8Handler { public: V8FunctionHandler(CefRefPtr cefPythonApp, int pythonCallbackId) : cefPythonApp_(cefPythonApp), pythonCallbackId_(pythonCallbackId) { } virtual bool Execute(const CefString& name, CefRefPtr object, const CefV8ValueList& arguments, CefRefPtr& retval, CefString& exception) OVERRIDE; protected: CefRefPtr cefPythonApp_; int pythonCallbackId_; private: IMPLEMENT_REFCOUNTING(V8FunctionHandler); }; cefpython-49.0/src/subprocess/v8utils.cpp000066400000000000000000000436711334103266300205620ustar00rootroot00000000000000// Copyright (c) 2013 CEF Python, see the Authors file. // All rights reserved. Licensed under BSD 3-clause license. // Project website: https://github.com/cztomczak/cefpython // CefListValue->SetXxxx() functions need first param to be be cast // to (int) because GetSize() returns size_t and generates a warning // when compiling on VS2008 for x64 platform. Issue reported here: // https://github.com/cztomczak/cefpython/issues/165 #include "v8utils.h" #include "javascript_callback.h" #include "include/base/cef_logging.h" #include "cefpython_app.h" #include // ---------------------------------------------------------------------------- // V8 values to CEF values. // ---------------------------------------------------------------------------- CefRefPtr V8ValueListToCefListValue( const CefV8ValueList& v8List) { // typedef std::vector > CefV8ValueList; CefRefPtr listValue = CefListValue::Create(); for (CefV8ValueList::const_iterator it = v8List.begin(); it != v8List.end(); \ ++it) { CefRefPtr v8Value = *it; V8ValueAppendToCefListValue(v8Value, listValue); } return listValue; } void V8ValueAppendToCefListValue(CefRefPtr v8Value, CefRefPtr listValue, int nestingLevel) { if (!v8Value->IsValid()) { LOG(ERROR) << "[Renderer process] V8ValueAppendToCefListValue():" " IsValid() failed"; return; } if (nestingLevel > 8) { LOG(ERROR) << "[Renderer process] V8ValueAppendToCefListValue():" " max nesting level (8) exceeded"; return; } if (v8Value->IsUndefined() || v8Value->IsNull()) { listValue->SetNull((int)listValue->GetSize()); } else if (v8Value->IsBool()) { listValue->SetBool((int)listValue->GetSize(), v8Value->GetBoolValue()); } else if (v8Value->IsInt()) { listValue->SetInt((int)listValue->GetSize(), v8Value->GetIntValue()); } else if (v8Value->IsUInt()) { uint32 uint32_value = v8Value->GetUIntValue(); CefRefPtr binaryValue = CefBinaryValue::Create( &uint32_value, sizeof(uint32_value)); listValue->SetBinary((int)listValue->GetSize(), binaryValue); } else if (v8Value->IsDouble()) { listValue->SetDouble((int)listValue->GetSize(), v8Value->GetDoubleValue()); } else if (v8Value->IsDate()) { // TODO: in time_utils.pyx there are already functions for // converting cef_time_t to python DateTime, we could easily // add a new function for converting the python DateTime to // string and then to CefString and expose the function using // the "public" keyword. But how do we get the cef_time_t // structure from the CefTime class? GetDateValue() returns // CefTime class. listValue->SetNull((int)listValue->GetSize()); } else if (v8Value->IsString()) { listValue->SetString((int)listValue->GetSize(), v8Value->GetStringValue()); } else if (v8Value->IsArray()) { // Check for IsArray() must happen before the IsObject() check. int length = v8Value->GetArrayLength(); CefRefPtr newListValue = CefListValue::Create(); for (int i = 0; i < length; ++i) { V8ValueAppendToCefListValue(v8Value->GetValue(i), newListValue, nestingLevel + 1); } listValue->SetList((int)listValue->GetSize(), newListValue); } else if (v8Value->IsFunction()) { // Check for IsFunction() must happen before the IsObject() check. if (CefV8Context::InContext()) { CefRefPtr context = \ CefV8Context::GetCurrentContext(); CefRefPtr frame = context->GetFrame(); std::string strCallbackId = PutJavascriptCallback(frame, v8Value); /* strCallbackId = '####cefpython####' \ '{"what"=>"javascript-callback", ..}' */ listValue->SetString((int)listValue->GetSize(), strCallbackId); } else { listValue->SetNull((int)listValue->GetSize()); LOG(ERROR) << "[Renderer process] V8ValueAppendToCefListValue():" " not in V8 context"; return; } } else if (v8Value->IsObject()) { // Check for IsObject() must happen after the IsArray() // and IsFunction() checks. listValue->SetDictionary((int)listValue->GetSize(), V8ObjectToCefDictionaryValue(v8Value, nestingLevel + 1)); } else { listValue->SetNull((int)listValue->GetSize()); LOG(ERROR) << "[Renderer process] V8ValueAppendToCefListValue():" " unknown V8 type"; } } CefRefPtr V8ObjectToCefDictionaryValue( CefRefPtr v8Object, int nestingLevel) { if (!v8Object->IsValid()) { LOG(ERROR) << "[Renderer process] V8ObjectToCefDictionaryValue():" " IsValid() failed"; return CefDictionaryValue::Create(); } if (nestingLevel > 8) { LOG(ERROR) << "[Renderer process] V8ObjectToCefDictionaryValue():" " max nesting level (8) exceeded"; return CefDictionaryValue::Create(); } if (!v8Object->IsObject()) { LOG(ERROR) << "[Renderer process] V8ObjectToCefDictionaryValue():" " IsObject() failed"; return CefDictionaryValue::Create(); } CefRefPtr ret = CefDictionaryValue::Create(); std::vector keys; if (!v8Object->GetKeys(keys)) { LOG(ERROR) << "[Renderer process] V8ObjectToCefDictionaryValue():" " GetKeys() failed"; return ret; } for (std::vector::iterator it = keys.begin(); \ it != keys.end(); ++it) { CefString key = *it; CefRefPtr v8Value = v8Object->GetValue(key); if (v8Value->IsUndefined() || v8Value->IsNull()) { ret->SetNull(key); } else if (v8Value->IsBool()) { ret->SetBool(key, v8Value->GetBoolValue()); } else if (v8Value->IsInt()) { ret->SetInt(key, v8Value->GetIntValue()); } else if (v8Value->IsUInt()) { uint32 uint32_value = v8Value->GetUIntValue(); CefRefPtr binaryValue = CefBinaryValue::Create( &uint32_value, sizeof(uint32_value)); ret->SetBinary(key, binaryValue); } else if (v8Value->IsDouble()) { ret->SetDouble(key, v8Value->GetDoubleValue()); } else if (v8Value->IsDate()) { // TODO: in time_utils.pyx there are already functions for // converting cef_time_t to python DateTime, we could easily // add a new function for converting the python DateTime to // string and then to CefString and expose the function using // the "public" keyword. But how do we get the cef_time_t // structure from the CefTime class? GetDateValue() returns // CefTime class. ret->SetNull(key); } else if (v8Value->IsString()) { ret->SetString(key, v8Value->GetStringValue()); } else if (v8Value->IsArray()) { // Check for IsArray() must happen before the IsObject() check. int length = v8Value->GetArrayLength(); CefRefPtr newListValue = CefListValue::Create(); for (int i = 0; i < length; ++i) { V8ValueAppendToCefListValue(v8Value->GetValue(i), newListValue, nestingLevel + 1); } ret->SetList(key, newListValue); } else if (v8Value->IsFunction()) { // Check for IsFunction() must happen before the IsObject() check. if (CefV8Context::InContext()) { CefRefPtr context = \ CefV8Context::GetCurrentContext(); CefRefPtr frame = context->GetFrame(); std::string strCallbackId = PutJavascriptCallback( frame, v8Value); /* strCallbackId = '####cefpython####' \ '{"what"=>"javascript-callback", ..}' */ ret->SetString(key, strCallbackId); } else { ret->SetNull(key); LOG(ERROR) << "[Renderer process]" " V8ObjectToCefDictionaryValue():" " not in V8 context"; } } else if (v8Value->IsObject()) { // Check for IsObject() must happen after the IsArray() // and IsFunction() checks. ret->SetDictionary(key, V8ObjectToCefDictionaryValue(v8Value, nestingLevel + 1)); } else { ret->SetNull(key); LOG(ERROR) << "[Renderer process] V8ObjectToCefDictionaryValue():" " unknown V8 type"; } } return ret; } // ---------------------------------------------------------------------------- // CEF values to V8 values. // ---------------------------------------------------------------------------- // TODO: send callbackId using CefBinaryNamedValue, see: // http://www.magpcss.org/ceforum/viewtopic.php?f=6&t=10881 struct PythonCallback { int callbackId; char uniqueCefBinaryValueSize[16]; }; template inline std::string AnyToString(const T& value) { std::ostringstream oss; oss << value; return oss.str(); } CefV8ValueList CefListValueToCefV8ValueList( CefRefPtr listValue) { // CefV8ValueList = typedef std::vector > CefV8ValueList v8ValueVector; CefRefPtr v8List = CefListValueToV8Value(listValue); int v8ListLength = v8List->GetArrayLength(); for (int i = 0; i < v8ListLength; ++i) { v8ValueVector.push_back(v8List->GetValue(i)); } return v8ValueVector; } CefRefPtr CefListValueToV8Value( CefRefPtr listValue, int nestingLevel) { if (!listValue->IsValid()) { LOG(ERROR) << "[Renderer process] CefListValueToV8Value():" " CefDictionaryValue is invalid"; return CefV8Value::CreateNull(); } if (nestingLevel > 8) { LOG(ERROR) << "[Renderer process] CefListValueToV8Value():" " max nesting level (8) exceeded"; return CefV8Value::CreateNull(); } int listSize = (int)listValue->GetSize(); CefRefPtr ret = CefV8Value::CreateArray(listSize); CefRefPtr binaryValue; PythonCallback pyCallback; CefRefPtr v8FunctionHandler; for (int key = 0; key < listSize; ++key) { cef_value_type_t valueType = listValue->GetType(key); bool success; std::string callbackName = "python_callback_"; if (valueType == VTYPE_NULL) { success = ret->SetValue(key, CefV8Value::CreateNull()); } else if (valueType == VTYPE_BOOL) { success = ret->SetValue(key, CefV8Value::CreateBool(listValue->GetBool(key))); } else if (valueType == VTYPE_INT) { success = ret->SetValue(key, CefV8Value::CreateInt(listValue->GetInt(key))); } else if (valueType == VTYPE_DOUBLE) { success = ret->SetValue(key, CefV8Value::CreateDouble(listValue->GetDouble(key))); } else if (valueType == VTYPE_STRING) { success = ret->SetValue(key, CefV8Value::CreateString(listValue->GetString(key))); } else if (valueType == VTYPE_BINARY) { binaryValue = listValue->GetBinary(key); if (binaryValue->GetSize() == sizeof(pyCallback)) { binaryValue->GetData(&pyCallback, sizeof(pyCallback), 0); v8FunctionHandler = new V8FunctionHandler( NULL, pyCallback.callbackId); // You must provide a function name to // CefV8Value::CreateFunction(), otherwise it fails. callbackName.append(AnyToString(pyCallback.callbackId)); success = ret->SetValue(key, CefV8Value::CreateFunction( callbackName, v8FunctionHandler)); } else { LOG(ERROR) << "[Renderer process] CefListValueToV8Value():" " unknown binary value, setting value to null"; success = ret->SetValue(key, CefV8Value::CreateNull()); } } else if (valueType == VTYPE_DICTIONARY) { success = ret->SetValue(key, CefDictionaryValueToV8Value( listValue->GetDictionary(key), nestingLevel + 1)); } else if (valueType == VTYPE_LIST) { success = ret->SetValue(key, CefListValueToV8Value( listValue->GetList(key), nestingLevel + 1)); } else { LOG(ERROR) << "[Renderer process] CefListValueToV8Value():" " unknown type, setting value to null"; success = ret->SetValue(key, CefV8Value::CreateNull()); } if (!success) { LOG(ERROR) << "[Renderer process] CefListValueToV8Value():" " ret->SetValue() failed"; } } return ret; } CefRefPtr CefDictionaryValueToV8Value( CefRefPtr dictValue, int nestingLevel) { if (!dictValue->IsValid()) { LOG(ERROR) << "[Renderer process] CefDictionaryValueToV8Value():" " CefDictionaryValue is invalid"; return CefV8Value::CreateNull(); } if (nestingLevel > 8) { LOG(ERROR) << "[Renderer process] CefDictionaryValueToV8Value():" " max nesting level (8) exceeded"; return CefV8Value::CreateNull(); } std::vector keys; if (!dictValue->GetKeys(keys)) { LOG(ERROR) << "[Renderer process] CefDictionaryValueToV8Value():" " dictValue->GetKeys() failed"; return CefV8Value::CreateNull(); } CefRefPtr ret = CefV8Value::CreateObject(NULL); CefRefPtr binaryValue; PythonCallback pyCallback; CefRefPtr v8FunctionHandler; for (std::vector::iterator it = keys.begin(); \ it != keys.end(); ++it) { CefString key = *it; cef_value_type_t valueType = dictValue->GetType(key); bool success; std::string callbackName = "python_callback_"; if (valueType == VTYPE_NULL) { success = ret->SetValue(key, CefV8Value::CreateNull(), V8_PROPERTY_ATTRIBUTE_NONE); } else if (valueType == VTYPE_BOOL) { success = ret->SetValue(key, CefV8Value::CreateBool(dictValue->GetBool(key)), V8_PROPERTY_ATTRIBUTE_NONE); } else if (valueType == VTYPE_INT) { success = ret->SetValue(key, CefV8Value::CreateInt(dictValue->GetInt(key)), V8_PROPERTY_ATTRIBUTE_NONE); } else if (valueType == VTYPE_DOUBLE) { success = ret->SetValue(key, CefV8Value::CreateDouble(dictValue->GetDouble(key)), V8_PROPERTY_ATTRIBUTE_NONE); } else if (valueType == VTYPE_STRING) { success = ret->SetValue(key, CefV8Value::CreateString(dictValue->GetString(key)), V8_PROPERTY_ATTRIBUTE_NONE); } else if (valueType == VTYPE_BINARY) { binaryValue = dictValue->GetBinary(key); if (binaryValue->GetSize() == sizeof(pyCallback)) { binaryValue->GetData(&pyCallback, sizeof(pyCallback), 0); v8FunctionHandler = new V8FunctionHandler( NULL, pyCallback.callbackId); // You must provide a function name to // CefV8Value::CreateFunction(), otherwise it fails. callbackName.append(AnyToString(pyCallback.callbackId)); success = ret->SetValue(key, CefV8Value::CreateFunction( callbackName, v8FunctionHandler), V8_PROPERTY_ATTRIBUTE_NONE); } else { LOG(ERROR) << "[Renderer process] CefListValueToV8Value():" " unknown binary value, setting value to null"; success = ret->SetValue(key, CefV8Value::CreateNull(), V8_PROPERTY_ATTRIBUTE_NONE); } } else if (valueType == VTYPE_DICTIONARY) { success = ret->SetValue(key, CefDictionaryValueToV8Value( dictValue->GetDictionary(key), nestingLevel + 1), V8_PROPERTY_ATTRIBUTE_NONE); } else if (valueType == VTYPE_LIST) { success = ret->SetValue(key, CefListValueToV8Value( dictValue->GetList(key), nestingLevel + 1), V8_PROPERTY_ATTRIBUTE_NONE); } else { LOG(ERROR) << "[Renderer process] CefDictionaryValueToV8Value():" " unknown type, setting value to null"; success = ret->SetValue(key, CefV8Value::CreateNull(), V8_PROPERTY_ATTRIBUTE_NONE); } if (!success) { LOG(ERROR) << "[Renderer process] CefDictionaryValueToV8Value():" " ret->SetValue() failed"; } } return ret; } cefpython-49.0/src/subprocess/v8utils.h000066400000000000000000000026671334103266300202270ustar00rootroot00000000000000// Copyright (c) 2013 CEF Python, see the Authors file. // All rights reserved. Licensed under BSD 3-clause license. // Project website: https://github.com/cztomczak/cefpython #pragma once #include "include/cef_v8.h" #include "include/cef_values.h" #include "v8function_handler.h" // ---------------------------------------------------------------------------- // V8 values to CEF values. // ---------------------------------------------------------------------------- CefRefPtr V8ValueListToCefListValue( const CefV8ValueList& v8List); void V8ValueAppendToCefListValue(const CefRefPtr v8Value, CefRefPtr listValue, int nestingLevel=0); CefRefPtr V8ObjectToCefDictionaryValue( const CefRefPtr v8Object, int nestingLevel=0); // ---------------------------------------------------------------------------- // CEF values to V8 values. // ---------------------------------------------------------------------------- CefV8ValueList CefListValueToCefV8ValueList( CefRefPtr listValue); CefRefPtr CefListValueToV8Value( CefRefPtr listValue, int nestingLevel=0); CefRefPtr CefDictionaryValueToV8Value( CefRefPtr dictValue, int nestingLevel=0); cefpython-49.0/src/task.pyx000066400000000000000000000046071334103266300157500ustar00rootroot00000000000000# Copyright (c) 2014 CEF Python, see the Authors file. # All rights reserved. Licensed under BSD 3-clause license. # Project website: https://github.com/cztomczak/cefpython include "cefpython.pyx" g_taskMaxId = 0 g_tasks = {} def PostTask(int thread, object func, *args): global g_tasks, g_taskMaxId # Validate threadId. if thread not in g_browserProcessThreads: raise Exception("PoastTask failed: requires a browser process thread") # Validate func. if not IsFunctionOrMethod(type(func)): raise Exception("PostTask failed: not a function nor method") # Params. cdef list params = list(args) # Keep func and params until PyTaskRunnable is called. g_taskMaxId += 1 g_tasks[str(g_taskMaxId)] = { "func": func, "params": params } # Call C++ wrapper. cdef int cTaskId = int(g_taskMaxId) with nogil: PostTaskWrapper(thread, cTaskId) def PostDelayedTask(int thread, int delay_ms, object func, *args): global g_tasks, g_taskMaxId # Validate threadId. if thread not in g_browserProcessThreads: raise Exception("PoastTask failed: requires a browser process thread") # Validate func. if not IsFunctionOrMethod(type(func)): raise Exception("PostTask failed: not a function nor method") # Params. cdef list params = list(args) # Keep func and params until PyTaskRunnable is called. g_taskMaxId += 1 g_tasks[str(g_taskMaxId)] = { "func": func, "params": params } # Call C++ wrapper. cdef int cTaskId = int(g_taskMaxId) with nogil: PostDelayedTaskWrapper(thread, delay_ms, cTaskId) cdef public void PyTaskRunnable(int taskId) except * with gil: cdef object func cdef list params cdef object task try: global g_tasks # Validate if task exist. if str(taskId) not in g_tasks: raise Exception("PyTaskRunnable failed: invalid taskId=%s" \ % taskId) # Fetch task: func and params. task = g_tasks[str(taskId)] func = task["func"] params = task["params"] del g_tasks[str(taskId)] # Execute user func. Debug("PyTaskRunnable: taskId=%s, func=%s" % (taskId, func.__name__)) func(*params) except: (exc_type, exc_value, exc_trace) = sys.exc_info() sys.excepthook(exc_type, exc_value, exc_trace) cefpython-49.0/src/time_utils.pyx000066400000000000000000000025711334103266300171620ustar00rootroot00000000000000# Copyright (c) 2013 CEF Python, see the Authors file. # All rights reserved. Licensed under BSD 3-clause license. # Project website: https://github.com/cztomczak/cefpython include "cefpython.pyx" cdef void DatetimeToCefTimeT(object pyDatetime, cef_time_t& timeT) except *: if not isinstance(pyDatetime, datetime.datetime): raise Exception("Expected object of type datetime.datetime") timeT.year = pyDatetime.year timeT.month = pyDatetime.month timeT.day_of_week = pyDatetime.weekday() timeT.day_of_month = pyDatetime.day timeT.hour = pyDatetime.hour timeT.minute = pyDatetime.minute timeT.second = pyDatetime.second # Milliseconds/microseconds are ignored. timeT.millisecond = 0 cdef object CefTimeTToDatetime(cef_time_t timeT): cdef int year = timeT.year if year < datetime.MINYEAR: year = datetime.MINYEAR if year > datetime.MAXYEAR: year = datetime.MAXYEAR cdef int month = timeT.month if month == 0: month = 1 cdef int day_of_month = timeT.day_of_month if day_of_month == 0: day_of_month = 1 cdef int second = timeT.second if second > 59: # Ignore leap seconds as datetime.datetime() allows 0-59 only. second = 59 # Milliseconds/microseconds are ignored. return datetime.datetime(year, month, day_of_month, timeT.hour, timeT.minute, second) cefpython-49.0/src/utils.pyx000066400000000000000000000111251334103266300161370ustar00rootroot00000000000000# Copyright (c) 2012 CEF Python, see the Authors file. # All rights reserved. Licensed under BSD 3-clause license. # Project website: https://github.com/cztomczak/cefpython include "cefpython.pyx" # noinspection PyUnresolvedReferences cimport cef_types TID_UI = cef_types.TID_UI TID_DB = cef_types.TID_DB TID_FILE = cef_types.TID_FILE TID_FILE_USER_BLOCKING = cef_types.TID_FILE_USER_BLOCKING TID_PROCESS_LAUNCHER = cef_types.TID_PROCESS_LAUNCHER TID_CACHE = cef_types.TID_CACHE TID_IO = cef_types.TID_IO TID_RENDERER = cef_types.TID_RENDERER g_browserProcessThreads = [ TID_UI, TID_DB, TID_FILE, TID_FILE_USER_BLOCKING, TID_CACHE, TID_IO, ] cpdef py_bool IsString(object maybeString): # In Python 2.7 string types are: 1) str/bytes 2) unicode. # In Python 3 string types are: 1) bytes 2) str if type(maybeString) == bytes or type(maybeString) == str \ or (PY_MAJOR_VERSION < 3 and type(maybeString) == unicode): return True return False cpdef py_bool IsThread(int threadID): return bool(CefCurrentlyOn(threadID)) # TODO: this function needs to accept unicode strings, use the # logic from wxpython.py/ExceptHook to handle printing # unicode strings and writing them to file (codecs.open). # This change is required to work with Cython 0.20. cpdef object Debug(py_string msg): """Print debug message. Will be shown only when settings.debug=True.""" # In Python 3 str or bytes may be passed if type(msg) != str and type(msg) == bytes: msg = msg.decode("utf-8", "replace") # Convert to str in case other kind of object was passed msg = str(msg) msg = "[Browser process] " + msg # CEF logging is initialized only after CEF was initialized. # Otherwise the default is LOGSEVERITY_INFO and log_file is # none. if g_cef_initialized or g_debug: cef_log_info(PyStringToChar(msg)) cdef void NonCriticalError(py_string msg) except *: """Notify about error gently. Does not terminate application.""" # In Python 3 str or bytes may be passed if type(msg) != str and type(msg) == bytes: msg = msg.decode("utf-8", "replace") # Convert to str in case other kind of object was passed msg = str(msg) msg = "[Browser process] " + msg cef_log_error(PyStringToChar(msg)) cpdef str GetSystemError(): IF UNAME_SYSNAME == "Windows": cdef DWORD errorCode = GetLastError() return "Error Code = %d" % errorCode ELSE: return "" cpdef str GetNavigateUrl(py_string url): # Encode local file paths so that CEF can load them correctly: # | some.html, some/some.html, D:\, /var, file:// if re.search(r"^file:", url, re.I) or \ re.search(r"^[a-zA-Z]:", url) or \ not re.search(r"^[\w-]+:", url): # Function pathname2url will complain if url starts with "file://". # CEF may also change local urls to "file:///C:/" - three slashes. is_file_protocol = False file_prefix = "" file_prefixes = ["file:///", "file://"] for file_prefix in file_prefixes: if url.startswith(file_prefix): is_file_protocol = True # Remove the file:// prefix url = url[len(file_prefix):] break # Need to encode chinese characters in local file paths, # otherwise CEF will try to encode them by itself. But it # will fail in doing so. CEF will return the following string: # >> %EF%BF%97%EF%BF%80%EF%BF%83%EF%BF%A6 # But it should be: # >> %E6%A1%8C%E9%9D%A2 url = urllib_pathname2url(url) if is_file_protocol: url = "%s%s" % (file_prefix, url) # If it is C:\ then colon was encoded. Decode it back. url = re.sub(r"^([a-zA-Z])%3A", r"\1:", url) # Allow hash when loading urls. The pathname2url function # replaced hashes with "%23" (Issue #114). url = url.replace("%23", "#") # Allow more special characters when loading urls. The pathname2url # function encoded them and need to decode them back here # Characters: ? & = (Issue #273). url = url.replace("%3F", "?") url = url.replace("%26", "&") url = url.replace("%3D", "=") return str(url) cpdef py_bool IsFunctionOrMethod(object valueType): if (valueType == types.FunctionType or valueType == types.MethodType or valueType == types.BuiltinFunctionType or valueType == types.BuiltinMethodType or valueType.__name__ == "cython_function_or_method"): return True return False cefpython-49.0/src/version/000077500000000000000000000000001334103266300157225ustar00rootroot00000000000000cefpython-49.0/src/version/cef_version_win.h000066400000000000000000000074451334103266300212640ustar00rootroot00000000000000// Copyright (c) 2016 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 is generated by the make_version_header.py tool. // #ifndef CEF_INCLUDE_CEF_VERSION_H_ #define CEF_INCLUDE_CEF_VERSION_H_ #define CEF_VERSION "3.2623.1401.gb90a3be" #define CEF_VERSION_MAJOR 3 #define CEF_COMMIT_NUMBER 1401 #define CEF_COMMIT_HASH "b90a3be1860b0647e8a62c218ff7c054390365b1" #define COPYRIGHT_YEAR 2016 #define CHROME_VERSION_MAJOR 49 #define CHROME_VERSION_MINOR 0 #define CHROME_VERSION_BUILD 2623 #define CHROME_VERSION_PATCH 110 #define DO_MAKE_STRING(p) #p #define MAKE_STRING(p) DO_MAKE_STRING(p) #ifndef APSTUDIO_HIDDEN_SYMBOLS #include "include/internal/cef_export.h" #ifdef __cplusplus extern "C" { #endif // The API hash is created by analyzing CEF header files for C API type // definitions. The hash value will change when header files are modified // in a way that may cause binary incompatibility with other builds. The // universal hash value will change if any platform is affected whereas the // platform hash values will change only if that particular platform is // affected. #define CEF_API_HASH_UNIVERSAL "32c1d3523da124f2dea7b80b92c53c4d4a463c65" #if defined(OS_WIN) #define CEF_API_HASH_PLATFORM "64b27477b82b44b51ce817522f744fca6768cbbb" #elif defined(OS_MACOSX) #define CEF_API_HASH_PLATFORM "e3b9c36454ae5ae4fb3509e17fb6a7d2877c847d" #elif defined(OS_LINUX) #define CEF_API_HASH_PLATFORM "87a195efc055fb9f39c84f5ce8199cc8766290e3" #endif // Returns CEF version information for the libcef library. The |entry| // parameter describes which version component will be returned: // 0 - CEF_VERSION_MAJOR // 1 - CEF_COMMIT_NUMBER // 2 - CHROME_VERSION_MAJOR // 3 - CHROME_VERSION_MINOR // 4 - CHROME_VERSION_BUILD // 5 - CHROME_VERSION_PATCH /// CEF_EXPORT int cef_version_info(int entry); /// // Returns CEF API hashes for the libcef library. The returned string is owned // by the library and should not be freed. The |entry| parameter describes which // hash value will be returned: // 0 - CEF_API_HASH_PLATFORM // 1 - CEF_API_HASH_UNIVERSAL // 2 - CEF_COMMIT_HASH /// CEF_EXPORT const char* cef_api_hash(int entry); #ifdef __cplusplus } #endif #endif // APSTUDIO_HIDDEN_SYMBOLS #endif // CEF_INCLUDE_CEF_VERSION_H_ cefpython-49.0/src/virtual_keys.pyx000066400000000000000000000100011334103266300175100ustar00rootroot00000000000000# Copyright (c) 2012 CEF Python, see the Authors file. # All rights reserved. Licensed under BSD 3-clause license. # Project website: https://github.com/cztomczak/cefpython # Regular expression to transform these constants to a form # that can be later pasted to wiki page: # (http://code.google.com/p/cefpython/wiki/VirtualKey) # # Find what: (VK_\w+) = \w+[ ]*([^\r\n]*) # Replace with: cefpython.`\1` \2
VK_0 = 0x30 VK_1 = 0x31 VK_2 = 0x32 VK_3 = 0x33 VK_4 = 0x34 VK_5 = 0x35 VK_6 = 0x36 VK_7 = 0x37 VK_8 = 0x38 VK_9 = 0x39 VK_A = 0x041 VK_B = 0x042 VK_C = 0x043 VK_D = 0x044 VK_E = 0x045 VK_F = 0x046 VK_G = 0x047 VK_H = 0x048 VK_I = 0x049 VK_J = 0x04A VK_K = 0x04B VK_L = 0x04C VK_M = 0x04D VK_N = 0x04E VK_O = 0x04F VK_P = 0x050 VK_Q = 0x051 VK_R = 0x052 VK_S = 0x053 VK_T = 0x054 VK_U = 0x055 VK_V = 0x056 VK_W = 0x057 VK_X = 0x058 VK_Y = 0x059 VK_Z = 0x05A VK_F1 = 0x70 VK_F2 = 0x71 VK_F3 = 0x72 VK_F4 = 0x73 VK_F5 = 0x74 VK_F6 = 0x75 VK_F7 = 0x76 VK_F8 = 0x77 VK_F9 = 0x78 VK_F10 = 0x79 VK_F11 = 0x7A VK_F12 = 0x7B VK_F13 = 0x7C VK_F14 = 0x7D VK_F15 = 0x7E VK_F16 = 0x7F VK_F17 = 0x80 VK_F18 = 0x81 VK_F19 = 0x82 VK_F20 = 0x83 VK_F21 = 0x84 VK_F22 = 0x85 VK_F23 = 0x86 VK_F24 = 0x87 VK_LEFT = 0x25 # Left arrow key VK_UP = 0x26 # Up arrow key VK_RIGHT = 0x27 # Right arrow key VK_DOWN = 0x28 # Down arrow key VK_LSHIFT = 0xA0 # Left shift VK_RSHIFT = 0xA1 # Right shift VK_LCONTROL = 0xA2 # Left Ctrl VK_RCONTROL = 0xA3 # Right Ctrl VK_LMENU = 0xA4 # Left Alt VK_RMENU = 0xA5 # Right Alt VK_LALT = VK_LMENU VK_RALT = VK_RMENU VK_BACK = 0x08 # Backspace key VK_RETURN = 0x0D # Enter key VK_TAB = 0x09 VK_SPACE = 0x20 # Space bar key VK_ESCAPE = 0x1B VK_SHIFT = 0x10 # Shift key VK_CONTROL = 0x11 # Ctrl key VK_MENU = 0x12 # Alt key VK_LWIN = 0x5B # Left Windows key VK_RWIN = 0x5C # Right Windows key VK_CAPITAL = 0x14 # Caps Lock key VK_CAPSLOCK = VK_CAPITAL VK_PRIOR = 0x21 # Page up VK_NEXT = 0x22 # Page down VK_PAGEUP = VK_PRIOR VK_PAGEDOWN = VK_NEXT VK_END = 0x23 VK_HOME = 0x24 VK_INSERT = 0x2D VK_DELETE = 0x2E VK_NUMLOCK = 0x90 VK_SCROLL = 0x91 # Scroll Lock key VK_SELECT = 0x29 VK_PRINT = 0x2A VK_EXECUTE = 0x2B VK_SNAPSHOT = 0x2C # Print Screen key VK_PRINTSCREEN = VK_SNAPSHOT VK_HELP = 0x2F VK_PAUSE = 0x13 VK_CLEAR = 0x0C VK_APPS = 0x5D # Applications key (Natural keyboard) VK_SLEEP = 0x5F # Computer Sleep key VK_NUMPAD0 = 0x60 # Numeric keypad 0 key VK_NUMPAD1 = 0x61 # Numeric keypad 1 key VK_NUMPAD2 = 0x62 # Numeric keypad 2 key VK_NUMPAD3 = 0x63 # Numeric keypad 3 key VK_NUMPAD4 = 0x64 # Numeric keypad 4 key VK_NUMPAD5 = 0x65 # Numeric keypad 5 key VK_NUMPAD6 = 0x66 # Numeric keypad 6 key VK_NUMPAD7 = 0x67 # Numeric keypad 7 key VK_NUMPAD8 = 0x68 # Numeric keypad 8 key VK_NUMPAD9 = 0x69 # Numeric keypad 9 key VK_BROWSER_BACK = 0xA6 VK_BROWSER_FORWARD = 0xA7 VK_BROWSER_REFRESH = 0xA8 VK_BROWSER_STOP = 0xA9 VK_BROWSER_SEARCH = 0xAA VK_BROWSER_FAVORITES = 0xAB VK_BROWSER_HOME = 0xAC VK_PLAY = 0xFA VK_ZOOM = 0xFB VK_VOLUME_MUTE = 0xAD VK_VOLUME_DOWN = 0xAE VK_VOLUME_UP = 0xAF VK_MEDIA_NEXT_TRACK = 0xB0 VK_MEDIA_PREV_TRACK = 0xB1 VK_MEDIA_STOP = 0xB2 VK_MEDIA_PLAY_PAUSE = 0xB3 VK_LAUNCH_MAIL = 0xB4 VK_LAUNCH_MEDIA_SELECT = 0xB5 VK_LAUNCH_APP1 = 0xB6 # Start Application 1 key VK_LAUNCH_APP2 = 0xB7 # Start Application 2 key VK_MULTIPLY = 0x6A VK_ADD = 0x6B VK_SEPARATOR = 0x6C VK_SUBTRACT = 0x6D VK_DECIMAL = 0x6E VK_DIVIDE = 0x6F VK_LBUTTON = 0x01 # Left mouse button VK_RBUTTON = 0x02 # Right mouse button VK_CANCEL = 0x03 # Control-break processing VK_MBUTTON = 0x04 # Middle mouse button (three-button mouse) VK_XBUTTON1 = 0x05 # X1 mouse button VK_XBUTTON2 = 0x06 # X2 mouse button VK_KANA = 0x15 # IME Kana mode VK_HANGUL = 0x15 # IME Hangul mode VK_JUNJA = 0x17 # IME Junja mode VK_FINAL = 0x18 # IME final mode VK_HANJA = 0x19 # IME Hanja mode VK_KANJI = 0x19 # IME Kanji mode VK_CONVERT = 0x1C # IME convert VK_NONCONVERT = 0x1D # IME nonconvert VK_ACCEPT = 0x1E # IME accept VK_MODECHANGE = 0x1F # IME mode change request VK_PROCESSKEY = 0xE5 VK_PACKET = 0xE7 VK_ICO_HELP = 0xE3 VK_ICO_00 = 0xE4 VK_ICO_CLEAR = 0xE6 cefpython-49.0/src/web_plugin_info.pyx000066400000000000000000000015641334103266300201530ustar00rootroot00000000000000# Copyright (c) 2013 CEF Python, see the Authors file. # All rights reserved. Licensed under BSD 3-clause license. # Project website: https://github.com/cztomczak/cefpython include "cefpython.pyx" cdef PyWebPluginInfo CreatePyWebPluginInfo( CefRefPtr[CefWebPluginInfo] cefPlugin): cdef PyWebPluginInfo pyPlugin = PyWebPluginInfo() pyPlugin.cefPlugin = cefPlugin return pyPlugin cdef class PyWebPluginInfo: cdef CefRefPtr[CefWebPluginInfo] cefPlugin cpdef py_string GetName(self): return CefToPyString(self.cefPlugin.get().GetName()) cpdef py_string GetPath(self): return CefToPyString(self.cefPlugin.get().GetPath()) cpdef py_string GetVersion(self): return CefToPyString(self.cefPlugin.get().GetVersion()) cpdef py_string GetDescription(self): return CefToPyString(self.cefPlugin.get().GetDescription()) cefpython-49.0/src/web_request.pyx000066400000000000000000000163241334103266300173320ustar00rootroot00000000000000# Copyright (c) 2013 CEF Python, see the Authors file. # All rights reserved. Licensed under BSD 3-clause license. # Project website: https://github.com/cztomczak/cefpython include "cefpython.pyx" import weakref cdef object g_pyWebRequests = weakref.WeakValueDictionary() cdef int g_webRequestMaxId = 0 # ----------------------------------------------------------------------------- # WebRequest # ----------------------------------------------------------------------------- # Static methods are not allowed in cdef classes, # that's why we need a wrapper for PyWebRequest. class WebRequest: Status = { "Unknown": cef_types.UR_UNKNOWN, "Success": cef_types.UR_SUCCESS, "Pending": cef_types.UR_IO_PENDING, "Canceled": cef_types.UR_CANCELED, "Failed": cef_types.UR_FAILED, } def __init__(self): raise Exception("You cannot instantiate WebRequest directly, " "use WebRequest.CreateWebRequest() static method") @staticmethod def ValidateClient(webRequestClient): cdef list methods = ["OnRequestComplete", "OnUploadProgress", "OnDownloadProgress", "OnDownloadData"] for method in methods: if webRequestClient and hasattr(webRequestClient, method) \ and callable(getattr(webRequestClient, method)): # Okay. continue else: raise Exception("WebRequestClient object is missing method: " \ "%s" % method) @staticmethod def Create(request, webRequestClient): if not isinstance(request, PyRequest): raise Exception("Invalid request object") WebRequest.ValidateClient(webRequestClient) return CreatePyWebRequest(request, webRequestClient) # ----------------------------------------------------------------------------- # PyWebRequest # ----------------------------------------------------------------------------- cdef PyWebRequest CreatePyWebRequest(PyRequest request, object webRequestClient): global g_pyWebRequests cdef PyWebRequest webRequest = PyWebRequest(request, webRequestClient) assert webRequest.webRequestId, "webRequest.webRequestId empty" g_pyWebRequests[webRequest.webRequestId] = webRequest return webRequest cdef PyWebRequest GetPyWebRequest(int webRequestId): global g_pyWebRequests if webRequestId in g_pyWebRequests: return g_pyWebRequests[webRequestId] return None cdef class PyWebRequest: cdef object __weakref__ # see g_pyWebRequests cdef int webRequestId cdef CefRefPtr[CefURLRequest] cefWebRequest cdef object pyWebRequestClient def __init__(self, PyRequest pyRequest, object pyWebRequestClient): global g_webRequestMaxId g_webRequestMaxId += 1 self.webRequestId = g_webRequestMaxId cdef CefRefPtr[WebRequestClient] cppWebRequestClient = ( new WebRequestClient( self.webRequestId)) self.pyWebRequestClient = pyWebRequestClient self.cefWebRequest = (CefURLRequest_Create( pyRequest.cefRequest, cppWebRequestClient, NULL)) cdef object GetCallback(self, str funcName): if hasattr(self.pyWebRequestClient, funcName) and ( callable(getattr(self.pyWebRequestClient, funcName))): return getattr(self.pyWebRequestClient, funcName) cpdef PyRequest GetRequest(self): cdef CefRefPtr[CefRequest] cefRequest = \ self.cefWebRequest.get().GetRequest() cdef PyRequest pyRequest = CreatePyRequest(cefRequest) return pyRequest cpdef int GetRequestStatus(self) except *: return self.cefWebRequest.get().GetRequestStatus() cpdef int GetRequestError(self) except *: return self.cefWebRequest.get().GetRequestError() cpdef PyResponse GetResponse(self): cdef CefRefPtr[CefResponse] cefResponse = \ self.cefWebRequest.get().GetResponse() cdef PyResponse pyResponse # CefResponse may be NULL. if cefResponse.get(): pyResponse = CreatePyResponse(cefResponse) return pyResponse return None cpdef py_void Cancel(self): self.cefWebRequest.get().Cancel() # ----------------------------------------------------------------------------- # WebRequestClient # ----------------------------------------------------------------------------- cdef public void WebRequestClient_OnUploadProgress( int webRequestId, CefRefPtr[CefURLRequest] cefWebRequest, int64 current, int64 total ) except * with gil: cdef PyWebRequest webRequest cdef object userCallback try: webRequest = GetPyWebRequest(webRequestId) if webRequest: userCallback = webRequest.GetCallback("OnUploadProgress") if userCallback: userCallback( web_request=webRequest, current=current, total=total) except: (exc_type, exc_value, exc_trace) = sys.exc_info() sys.excepthook(exc_type, exc_value, exc_trace) cdef public void WebRequestClient_OnDownloadProgress( int webRequestId, CefRefPtr[CefURLRequest] cefWebRequest, int64 current, int64 total ) except * with gil: cdef PyWebRequest webRequest cdef object userCallback try: webRequest = GetPyWebRequest(webRequestId) if webRequest: userCallback = webRequest.GetCallback("OnDownloadProgress") if userCallback: userCallback( web_request=webRequest, current=current, total=total) except: (exc_type, exc_value, exc_trace) = sys.exc_info() sys.excepthook(exc_type, exc_value, exc_trace) cdef public void WebRequestClient_OnDownloadData( int webRequestId, CefRefPtr[CefURLRequest] cefWebRequest, const void* data, size_t dataLength ) except * with gil: cdef PyWebRequest webRequest cdef object userCallback try: webRequest = GetPyWebRequest(webRequestId) if webRequest: userCallback = webRequest.GetCallback("OnDownloadData") if userCallback: userCallback( web_request=webRequest, data=VoidPtrToString(data, dataLength)) except: (exc_type, exc_value, exc_trace) = sys.exc_info() sys.excepthook(exc_type, exc_value, exc_trace) cdef public void WebRequestClient_OnRequestComplete( int webRequestId, CefRefPtr[CefURLRequest] cefWebRequest ) except * with gil: cdef PyWebRequest webRequest cdef object userCallback try: webRequest = GetPyWebRequest(webRequestId) if webRequest: userCallback = webRequest.GetCallback("OnRequestComplete") if userCallback: userCallback(web_request=webRequest) except: (exc_type, exc_value, exc_trace) = sys.exc_info() sys.excepthook(exc_type, exc_value, exc_trace) cefpython-49.0/src/window_info.pyx000066400000000000000000000135721334103266300173310ustar00rootroot00000000000000# Copyright (c) 2013 CEF Python, see the Authors file. # All rights reserved. Licensed under BSD 3-clause license. # Project website: https://github.com/cztomczak/cefpython include "cefpython.pyx" cdef void SetCefWindowInfo( CefWindowInfo& cefWindowInfo, WindowInfo windowInfo ) except *: if not windowInfo.windowType: raise Exception("WindowInfo: windowType is not set") # It is allowed to pass 0 as parentWindowHandle in OSR mode, but then # some things like context menus and plugins may not display correctly. if windowInfo.windowType != "offscreen": if not windowInfo.parentWindowHandle: # raise Exception("WindowInfo: parentWindowHandle is not set") pass IF UNAME_SYSNAME == "Windows": cdef RECT windowRect cdef CefString windowName ELIF UNAME_SYSNAME == "Linux": cdef CefRect windowRect # CHILD WINDOW if windowInfo.windowType == "child": IF UNAME_SYSNAME == "Windows": if windowInfo.windowRect: windowRect.left = int(windowInfo.windowRect[0]) windowRect.top = int(windowInfo.windowRect[1]) windowRect.right = int(windowInfo.windowRect[2]) windowRect.bottom = int(windowInfo.windowRect[3]) else: GetClientRect(windowInfo.parentWindowHandle, &windowRect) cefWindowInfo.SetAsChild( windowInfo.parentWindowHandle, windowRect) ELIF UNAME_SYSNAME == "Darwin": cefWindowInfo.SetAsChild( windowInfo.parentWindowHandle, int(windowInfo.windowRect[0]), int(windowInfo.windowRect[1]), int(windowInfo.windowRect[2]), int(windowInfo.windowRect[3])) ELIF UNAME_SYSNAME == "Linux": x = int(windowInfo.windowRect[0]) y = int(windowInfo.windowRect[1]) width = int(windowInfo.windowRect[2] - windowInfo.windowRect[0]) height = int(windowInfo.windowRect[3] - windowInfo.windowRect[1]) windowRect = CefRect(x, y, width, height) cefWindowInfo.SetAsChild( windowInfo.parentWindowHandle, windowRect) # POPUP WINDOW - Windows only IF UNAME_SYSNAME == "Windows": if windowInfo.windowType == "popup": PyToCefString(windowInfo.windowName, windowName) cefWindowInfo.SetAsPopup( windowInfo.parentWindowHandle, windowName) cdef cpp_bool transparent = bool(windowInfo.transparentPainting) if windowInfo.windowType == "offscreen": cefWindowInfo.SetAsWindowless( windowInfo.parentWindowHandle, transparent) cdef class WindowInfo: cdef public str windowType cdef public WindowHandle parentWindowHandle cdef public list windowRect # [left, top, right, bottom] cdef public py_string windowName cdef public py_bool transparentPainting def __init__(self, title=""): self.transparentPainting = False self.windowName = "" if title: self.windowName = title cpdef py_void SetAsChild(self, WindowHandle parentWindowHandle, list windowRect=None): # Allow parent window handle to be 0, in such case CEF will # create top window automatically as in hello_world.py example. IF UNAME_SYSNAME == "Windows": # On Windows when parent window handle is 0 then SetAsPopup() # must be called instead. if parentWindowHandle == 0: self.SetAsPopup(parentWindowHandle, "") return if parentWindowHandle != 0\ and not WindowUtils.IsWindowHandle(parentWindowHandle): raise Exception("Invalid parentWindowHandle: %s"\ % parentWindowHandle) self.windowType = "child" self.parentWindowHandle = parentWindowHandle IF UNAME_SYSNAME == "Darwin" or UNAME_SYSNAME == "Linux": if not windowRect: windowRect = [0,0,0,0] if windowRect: if type(windowRect) == list and len(windowRect) == 4: self.windowRect = [windowRect[0], windowRect[1], windowRect[2], windowRect[3]] else: raise Exception("WindowInfo.SetAsChild() failed: " "windowRect: invalid value") IF UNAME_SYSNAME == "Windows": cpdef py_void SetAsPopup(self, WindowHandle parentWindowHandle, py_string windowName): # Allow parent window handle to be 0, in such case CEF will # create top window automatically as in hello_world.py example. if parentWindowHandle != 0\ and not WindowUtils.IsWindowHandle(parentWindowHandle): raise Exception("Invalid parentWindowHandle: %s"\ % parentWindowHandle) self.parentWindowHandle = parentWindowHandle self.windowType = "popup" if windowName: self.windowName = str(windowName) cpdef py_void SetAsOffscreen(self, WindowHandle parentWindowHandle): # It is allowed to pass 0 as parentWindowHandle in OSR mode if parentWindowHandle and \ not WindowUtils.IsWindowHandle(parentWindowHandle): raise Exception("Invalid parentWindowHandle: %s" \ % parentWindowHandle) self.parentWindowHandle = parentWindowHandle self.windowType = "offscreen" cpdef py_void SetTransparentPainting(self, py_bool transparentPainting): self.transparentPainting = transparentPainting cefpython-49.0/src/window_utils_linux.pyx000066400000000000000000000035251334103266300207520ustar00rootroot00000000000000# Copyright (c) 2013 CEF Python, see the Authors file. # All rights reserved. Licensed under BSD 3-clause license. # Project website: https://github.com/cztomczak/cefpython include "cefpython.pyx" class WindowUtils: # You have to overwrite this class and provide implementations # for these methods. @staticmethod def OnSetFocus(WindowHandle windowHandle, long msg, long wparam, long lparam): # Available only on Windows, but have it available on other # platforms so that PyCharm doesn't warn about unresolved reference. pass @staticmethod def OnSize(WindowHandle windowHandle, long msg, long wparam, long lparam): # Available only on Windows, but have it available on other # platforms so that PyCharm doesn't warn about unresolved reference. pass @staticmethod def OnEraseBackground(WindowHandle windowHandle, long msg, long wparam, long lparam): # Available only on Windows, but have it available on other # platforms so that PyCharm doesn't warn about unresolved reference. pass @staticmethod def GetParentHandle(WindowHandle windowHandle): Debug("WindowUtils::GetParentHandle() not implemented (returns 0)") return 0 @staticmethod def IsWindowHandle(WindowHandle windowHandle): Debug("WindowUtils::IsWindowHandle() not implemented (always True)") return True @staticmethod def gtk_plug_new(WindowHandle gdkNativeWindow): return gtk_plug_new(gdkNativeWindow) @staticmethod def gtk_widget_show(WindowHandle gtkWidgetPtr): with nogil: gtk_widget_show(gtkWidgetPtr) @staticmethod def InstallX11ErrorHandlers(): with nogil: x11.InstallX11ErrorHandlers() cefpython-49.0/src/window_utils_mac.pyx000066400000000000000000000030001334103266300203370ustar00rootroot00000000000000# Copyright (c) 2015 CEF Python, see the Authors file. # All rights reserved. Licensed under BSD 3-clause license. # Project website: https://github.com/cztomczak/cefpython include "cefpython.pyx" class WindowUtils: # You have to overwrite this class and provide implementations # for these methods. @staticmethod def OnSetFocus(WindowHandle windowHandle, long msg, long wparam, long lparam): # Available only on Windows, but have it available on other # platforms so that PyCharm doesn't warn about unresolved reference. pass @staticmethod def OnSize(WindowHandle windowHandle, long msg, long wparam, long lparam): # Available only on Windows, but have it available on other # platforms so that PyCharm doesn't warn about unresolved reference. pass @staticmethod def OnEraseBackground(WindowHandle windowHandle, long msg, long wparam, long lparam): # Available only on Windows, but have it available on other # platforms so that PyCharm doesn't warn about unresolved reference. pass @staticmethod def GetParentHandle(WindowHandle windowHandle): Debug("WindowUtils::GetParentHandle() not implemented (returns 0)") return 0 @staticmethod def IsWindowHandle(WindowHandle windowHandle): Debug("WindowUtils::IsWindowHandle() not implemented (always True)") return True @staticmethod def InstallX11ErrorHandlers(): pass cefpython-49.0/src/window_utils_win.pyx000066400000000000000000000150131334103266300204030ustar00rootroot00000000000000# Copyright (c) 2012 CEF Python, see the Authors file. # All rights reserved. Licensed under BSD 3-clause license. # Project website: https://github.com/cztomczak/cefpython include "cefpython.pyx" class WindowUtils(object): @staticmethod def OnSetFocus(WindowHandle windowHandle, long msg, long wparam, long lparam): cdef PyBrowser pyBrowser = GetBrowserByWindowHandle(windowHandle) if not pyBrowser: return 0 pyBrowser.SetFocus(True) return 0 @staticmethod def OnSize(WindowHandle windowHandle, long msg, long wparam, long lparam): cdef PyBrowser pyBrowser = GetBrowserByWindowHandle(windowHandle) if not pyBrowser: return DefWindowProc(windowHandle, msg, wparam, lparam) cdef HWND innerHwnd = pyBrowser.GetWindowHandle() if not innerHwnd: return DefWindowProc(windowHandle, msg, wparam, lparam) cdef RECT rect2 cdef BOOL result = GetClientRect(windowHandle, &rect2) cdef HDWP hdwp if result != 0: hdwp = BeginDeferWindowPos(1) if hdwp: hdwp = DeferWindowPos(hdwp, innerHwnd, NULL, rect2.left, rect2.top, rect2.right - rect2.left, rect2.bottom - rect2.top, SWP_NOZORDER) if hdwp: EndDeferWindowPos(hdwp) return DefWindowProc(windowHandle, msg, wparam, lparam) @staticmethod def UpdateBrowserSize(WindowHandle parent_window_handle, PyBrowser browser, py_bool redraw=True): cdef HWND innerHwnd = browser.GetWindowHandle() if not innerHwnd: return cdef RECT rect2 cdef BOOL result = GetClientRect(parent_window_handle, &rect2) cdef UINT flags = SWP_NOZORDER if not redraw: flags = SWP_NOZORDER | SWP_NOREDRAW if result != 0: SetWindowPos(innerHwnd, NULL, rect2.left, rect2.top, rect2.right - rect2.left, rect2.bottom - rect2.top, flags) @staticmethod def OnEraseBackground(WindowHandle windowHandle, long msg, long wparam, long lparam): cdef PyBrowser pyBrowser = GetBrowserByWindowHandle(windowHandle) if not pyBrowser: return DefWindowProc(windowHandle, msg, wparam, lparam) # Dont erase the background if the browser window has been loaded, # this avoids flashing. if pyBrowser.GetWindowHandle(): return 0 return DefWindowProc(windowHandle, msg, wparam, lparam) @staticmethod def SetTitle(PyBrowser pyBrowser, str pyTitle): # Each browser window should have a title (Issue 3). # When popup is created, the window that sits in taskbar # has no title. if not pyTitle: return cdef WindowHandle windowHandle if pyBrowser.GetUserData("__outerWindowHandle"): windowHandle = \ pyBrowser.GetUserData("__outerWindowHandle") else: windowHandle = pyBrowser.GetWindowHandle() assert windowHandle, ( "WindowUtils.SetTitle() failed: windowHandle is empty") # Get window title. cdef int sizeOfTitle = 100 cdef wchar_t* widecharTitle = ( calloc(sizeOfTitle, wchar_t_size)) GetWindowTextW(windowHandle, widecharTitle, sizeOfTitle) cdef str currentTitle = WidecharToPyString(widecharTitle) free(widecharTitle) # Must keep alive while c_str() is passed. cdef CefString cefTitle PyToCefString(pyTitle, cefTitle) if pyBrowser.GetUserData("__outerWindowHandle"): if not currentTitle: SetWindowTextW(windowHandle, cefTitle.ToWString().c_str()) else: # For independent popups we always change title to what page # is displayed currently. SetWindowTextW(windowHandle, cefTitle.ToWString().c_str()) @staticmethod def SetIcon(PyBrowser pyBrowser, py_string icon="inherit"): # `icon` parameter is not implemented. # Popup window inherits icon from the main window. if pyBrowser.GetUserData("__outerWindowHandle"): return None windowHandle = pyBrowser.GetWindowHandle() assert windowHandle, ( "WindowUtils.SetIcon() failed: windowHandle is empty") iconBig = SendMessage( windowHandle, WM_GETICON, ICON_BIG, 0) iconSmall = SendMessage( windowHandle, WM_GETICON, ICON_SMALL, 0) cdef WindowHandle parentWindowHandle if not iconBig and not iconSmall: parentWindowHandle = pyBrowser.GetOpenerWindowHandle() parentIconBig = SendMessage( parentWindowHandle, WM_GETICON, ICON_BIG, 0) parentIconSmall = SendMessage( parentWindowHandle, WM_GETICON, ICON_SMALL, 0) # If parent is main application window, then # GetOpenerWindowHandle() returned innerWindowHandle # of the parent window, try again. if not parentIconBig and not parentIconSmall: parentWindowHandle = GetParent( parentWindowHandle) Debug("WindowUtils.SetIcon(): popup inherits icon from " "parent window: %s" % parentWindowHandle) parentIconBig = SendMessage( parentWindowHandle, WM_GETICON, ICON_BIG, 0) parentIconSmall = SendMessage( parentWindowHandle, WM_GETICON, ICON_SMALL, 0) if parentIconBig: SendMessage(windowHandle, WM_SETICON, ICON_BIG, parentIconBig) if parentIconSmall: SendMessage(windowHandle, WM_SETICON, ICON_SMALL, parentIconSmall) @staticmethod def GetParentHandle(WindowHandle windowHandle): return GetParent(windowHandle) @staticmethod def IsWindowHandle(WindowHandle windowHandle): IF UNAME_SYSNAME == "Windows": return bool(IsWindow(windowHandle)) ELSE: return False @staticmethod def InstallX11ErrorHandlers(): pass cefpython-49.0/src/windows/000077500000000000000000000000001334103266300157275ustar00rootroot00000000000000cefpython-49.0/src/windows/py27/000077500000000000000000000000001334103266300165305ustar00rootroot00000000000000cefpython-49.0/src/windows/py27/stdint.h000066400000000000000000000170601334103266300202120ustar00rootroot00000000000000// ISO C9x compliant stdint.h for Microsoft Visual Studio // Based on ISO/IEC 9899:TC2 Committee draft (May 6, 2005) WG14/N1124 // // Copyright (c) 2006-2008 Alexander Chemeris // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are met: // // 1. Redistributions of source code must retain the above copyright notice, // this list of conditions and the following disclaimer. // // 2. 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. // // 3. The name of the author may be used to endorse or promote products // derived from this software without specific prior written permission. // // THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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 _MSC_VER // [ #error "Use this header only with Microsoft Visual C++ compilers!" #endif // _MSC_VER ] #ifndef _MSC_STDINT_H_ // [ #define _MSC_STDINT_H_ #if _MSC_VER > 1000 #pragma once #endif #include // For Visual Studio 6 in C++ mode and for many Visual Studio versions when // compiling for ARM we should wrap include with 'extern "C++" {}' // or compiler give many errors like this: // error C2733: second C linkage of overloaded function 'wmemchr' not allowed #ifdef __cplusplus extern "C" { #endif # include #ifdef __cplusplus } #endif // Define _W64 macros to mark types changing their size, like intptr_t. #ifndef _W64 # if !defined(__midl) && (defined(_X86_) || defined(_M_IX86)) && _MSC_VER >= 1300 # define _W64 __w64 # else # define _W64 # endif #endif // 7.18.1 Integer types // 7.18.1.1 Exact-width integer types // Visual Studio 6 and Embedded Visual C++ 4 doesn't // realize that, e.g. char has the same size as __int8 // so we give up on __intX for them. #if (_MSC_VER < 1300) typedef signed char int8_t; typedef signed short int16_t; typedef signed int int32_t; typedef unsigned char uint8_t; typedef unsigned short uint16_t; typedef unsigned int uint32_t; #else typedef signed __int8 int8_t; typedef signed __int16 int16_t; typedef signed __int32 int32_t; typedef unsigned __int8 uint8_t; typedef unsigned __int16 uint16_t; typedef unsigned __int32 uint32_t; #endif typedef signed __int64 int64_t; typedef unsigned __int64 uint64_t; // 7.18.1.2 Minimum-width integer types typedef int8_t int_least8_t; typedef int16_t int_least16_t; typedef int32_t int_least32_t; typedef int64_t int_least64_t; typedef uint8_t uint_least8_t; typedef uint16_t uint_least16_t; typedef uint32_t uint_least32_t; typedef uint64_t uint_least64_t; // 7.18.1.3 Fastest minimum-width integer types typedef int8_t int_fast8_t; typedef int16_t int_fast16_t; typedef int32_t int_fast32_t; typedef int64_t int_fast64_t; typedef uint8_t uint_fast8_t; typedef uint16_t uint_fast16_t; typedef uint32_t uint_fast32_t; typedef uint64_t uint_fast64_t; // 7.18.1.4 Integer types capable of holding object pointers #ifdef _WIN64 // [ typedef signed __int64 intptr_t; typedef unsigned __int64 uintptr_t; #else // _WIN64 ][ typedef _W64 signed int intptr_t; typedef _W64 unsigned int uintptr_t; #endif // _WIN64 ] // 7.18.1.5 Greatest-width integer types typedef int64_t intmax_t; typedef uint64_t uintmax_t; // 7.18.2 Limits of specified-width integer types #if !defined(__cplusplus) || defined(__STDC_LIMIT_MACROS) // [ See footnote 220 at page 257 and footnote 221 at page 259 // 7.18.2.1 Limits of exact-width integer types #define INT8_MIN ((int8_t)_I8_MIN) #define INT8_MAX _I8_MAX #define INT16_MIN ((int16_t)_I16_MIN) #define INT16_MAX _I16_MAX #define INT32_MIN ((int32_t)_I32_MIN) #define INT32_MAX _I32_MAX #define INT64_MIN ((int64_t)_I64_MIN) #define INT64_MAX _I64_MAX #define UINT8_MAX _UI8_MAX #define UINT16_MAX _UI16_MAX #define UINT32_MAX _UI32_MAX #define UINT64_MAX _UI64_MAX // 7.18.2.2 Limits of minimum-width integer types #define INT_LEAST8_MIN INT8_MIN #define INT_LEAST8_MAX INT8_MAX #define INT_LEAST16_MIN INT16_MIN #define INT_LEAST16_MAX INT16_MAX #define INT_LEAST32_MIN INT32_MIN #define INT_LEAST32_MAX INT32_MAX #define INT_LEAST64_MIN INT64_MIN #define INT_LEAST64_MAX INT64_MAX #define UINT_LEAST8_MAX UINT8_MAX #define UINT_LEAST16_MAX UINT16_MAX #define UINT_LEAST32_MAX UINT32_MAX #define UINT_LEAST64_MAX UINT64_MAX // 7.18.2.3 Limits of fastest minimum-width integer types #define INT_FAST8_MIN INT8_MIN #define INT_FAST8_MAX INT8_MAX #define INT_FAST16_MIN INT16_MIN #define INT_FAST16_MAX INT16_MAX #define INT_FAST32_MIN INT32_MIN #define INT_FAST32_MAX INT32_MAX #define INT_FAST64_MIN INT64_MIN #define INT_FAST64_MAX INT64_MAX #define UINT_FAST8_MAX UINT8_MAX #define UINT_FAST16_MAX UINT16_MAX #define UINT_FAST32_MAX UINT32_MAX #define UINT_FAST64_MAX UINT64_MAX // 7.18.2.4 Limits of integer types capable of holding object pointers #ifdef _WIN64 // [ # define INTPTR_MIN INT64_MIN # define INTPTR_MAX INT64_MAX # define UINTPTR_MAX UINT64_MAX #else // _WIN64 ][ # define INTPTR_MIN INT32_MIN # define INTPTR_MAX INT32_MAX # define UINTPTR_MAX UINT32_MAX #endif // _WIN64 ] // 7.18.2.5 Limits of greatest-width integer types #define INTMAX_MIN INT64_MIN #define INTMAX_MAX INT64_MAX #define UINTMAX_MAX UINT64_MAX // 7.18.3 Limits of other integer types #ifdef _WIN64 // [ # define PTRDIFF_MIN _I64_MIN # define PTRDIFF_MAX _I64_MAX #else // _WIN64 ][ # define PTRDIFF_MIN _I32_MIN # define PTRDIFF_MAX _I32_MAX #endif // _WIN64 ] #define SIG_ATOMIC_MIN INT_MIN #define SIG_ATOMIC_MAX INT_MAX #ifndef SIZE_MAX // [ # ifdef _WIN64 // [ # define SIZE_MAX _UI64_MAX # else // _WIN64 ][ # define SIZE_MAX _UI32_MAX # endif // _WIN64 ] #endif // SIZE_MAX ] // WCHAR_MIN and WCHAR_MAX are also defined in #ifndef WCHAR_MIN // [ # define WCHAR_MIN 0 #endif // WCHAR_MIN ] #ifndef WCHAR_MAX // [ # define WCHAR_MAX _UI16_MAX #endif // WCHAR_MAX ] #define WINT_MIN 0 #define WINT_MAX _UI16_MAX #endif // __STDC_LIMIT_MACROS ] // 7.18.4 Limits of other integer types #if !defined(__cplusplus) || defined(__STDC_CONSTANT_MACROS) // [ See footnote 224 at page 260 // 7.18.4.1 Macros for minimum-width integer constants #define INT8_C(val) val##i8 #define INT16_C(val) val##i16 #define INT32_C(val) val##i32 #define INT64_C(val) val##i64 #define UINT8_C(val) val##ui8 #define UINT16_C(val) val##ui16 #define UINT32_C(val) val##ui32 #define UINT64_C(val) val##ui64 // 7.18.4.2 Macros for greatest-width integer constants #define INTMAX_C INT64_C #define UINTMAX_C UINT64_C #endif // __STDC_CONSTANT_MACROS ] #endif // _MSC_STDINT_H_ ] cefpython-49.0/tools/000077500000000000000000000000001334103266300146065ustar00rootroot00000000000000cefpython-49.0/tools/apidocs.py000066400000000000000000000144051334103266300166060ustar00rootroot00000000000000# Copyright (c) 2016 CEF Python, see the Authors file. # All rights reserved. Licensed under BSD 3-clause license. # Project website: https://github.com/cztomczak/cefpython """Generate API reference index in api/ directory and in root/README.md. TODO: - generate api/ docs from Cython sources - generate API-index.md, a list of all modules/functions/classes/methods and constants/global module variables - generate API-categories.md: objects, handlers, settings, types (eg. TerminationStatus, KeyEvent, KeyEventFlags) """ from common import * import glob import os import re import subprocess def main(): """Main entry point.""" # Call toc.py for docs/ and api/ directories and for README.md in root dir print("Running toc.py in {}/ dir".format(os.path.basename(API_DIR))) retcode = subprocess.call([sys.executable, os.path.join(TOOLS_DIR, "toc.py"), API_DIR]) assert retcode == 0, "Executing toc.py for API_DIR failed" print("Running toc.py in {}/ dir".format(os.path.basename(DOCS_DIR))) retcode = subprocess.call([sys.executable, os.path.join(TOOLS_DIR, "toc.py"), DOCS_DIR]) assert retcode == 0, "Executing toc.py for DOCS_DIR failed" print("Running toc.py for root/README.md") retcode = subprocess.call([sys.executable, os.path.join(TOOLS_DIR, "toc.py"), os.path.join(ROOT_DIR, "README.md")]) assert retcode == 0, "Executing toc.py for root/README.md failed" # Generate API reference in api/ dir and in root/README.md api_links = generate_api_links() update_api_index_file(api_links) update_readme_file(api_links) def update_api_index_file(api_links): """Create or update API-index.md file.""" contents = ("[API categories](API-categories.md#api-categories) | " + "[API index](API-index.md#api-index)\n\n" + "# API index\n\n") contents += api_links index_file = os.path.join(API_DIR, "API-index.md") with open(index_file, "rb") as fo: current_contents = fo.read().decode("utf-8") if contents == current_contents: print("No changes: %s/%s" % (os.path.basename(API_DIR), os.path.basename(index_file))) return with open(index_file, "wb") as fo: fo.write(contents.encode("utf-8")) print("Updated: %s/%s" % (os.path.basename(API_DIR), os.path.basename(index_file))) def update_readme_file(api_links): """Update root/README.md with API categories and index links. API categories are copied from API-categories.md which is generated manually. """ api_links = api_links.replace("](", "](api/") readme_file = os.path.join(ROOT_DIR, "README.md") with open(readme_file, "rb") as fo: readme_contents = fo.read().decode("utf-8") contents = readme_contents # Update API categories categories_file = os.path.join(API_DIR, "API-categories.md") with open(categories_file, "rb") as fo: categories_contents = fo.read().decode("utf-8") match = re.search(r"# API categories\s+(###[\s\S]+)", categories_contents) assert match and match.group(1), "Failed to parse API categories" categories_contents = match.group(1) categories_contents = categories_contents.replace("###", "####") categories_contents = categories_contents.replace("](", "](api/") re_find = r"### API categories[\s\S]+### API index" assert re.search(re_find, readme_contents), ("API categories not found" " in README") contents = re.sub(re_find, (u"### API categories\r\n\r\n{categories_contents}" u"\r\n### API index" .format(categories_contents=categories_contents)), contents) # Update API index re_find = (r"### API index\s+" r"(\s*\*[ ]\[[^\r\n\[\]]+\]\([^\r\n()]+\)\s+)*") assert re.search(re_find, readme_contents), ("API index not found" " in README") contents = re.sub(re_find, (u"### API index\r\n\r\n{api_links}" .format(api_links=api_links)), contents) if contents == readme_contents: print("No changes: /%s" % (os.path.basename(readme_file))) return with open(readme_file, "wb") as fo: fo.write(contents.encode("utf-8")) print("Updated: /%s" % (os.path.basename(readme_file))) def generate_api_links(): """Generate API index with all modules / classes / functions.""" contents = "" files = glob.glob(os.path.join(API_DIR, "*.md")) files = sorted(files, key=lambda s: s.lower()) for file_ in files: # Ignore API-index.md and API-categories.md files if "API-" in file_: continue with open(file_, "rb") as fo: md_contents = fo.read().decode("utf-8") md_contents = re.sub(u"```[\\s\\S]+?```", u"", md_contents) matches = re.findall(r"^(#|###)\s+(.*)", md_contents, re.MULTILINE) for match in matches: heading_level = match[0].strip() title = match[1].strip() title = title.strip() if heading_level == "#": indent = "" link = os.path.basename(file_) + "#" + get_heading_hash(title) elif heading_level == "###": indent = " " link = os.path.basename(file_) + "#" + get_heading_hash(title) # hash generation needs complete title. Now we can strip some. title = re.sub(r"\(.*", r"", title) else: assert False, "Heading level unsupported" contents += (indent + "* " + "[%s](%s)\n" % (title, link)) return contents def get_heading_hash(title): """Get a link hash for headings H1, H2, H3.""" hash_ = title.lower() hash_ = re.sub(r"[^a-z0-9_\- ]+", r"", hash_) hash_ = hash_.replace(" ", "-") hash_ = re.sub(r"[-]+", r"-", hash_) hash_ = re.sub(r"-$", r"", hash_) return hash_ if __name__ == "__main__": main() cefpython-49.0/tools/automate-git.py000066400000000000000000001250151334103266300175640ustar00rootroot00000000000000""" See automate.py. This script is for internal usage only, don't call it directly. This is a modified copy of automate-git.py from upstream CEF. Some modifications were applied for CEF Python specific use case. There is a patch file with the same name as this script that contains differences from the original file. ------------------------------------------------------------------------------- Usage: automate-git.py [options] This utility implements automation for the download, update, build and distribution of CEF. Options: -h, --help show this help message and exit --download-dir=DIR Download directory with no spaces [required]. --depot-tools-dir=DIR Download directory for depot_tools. --depot-tools-archive=DEPOTTOOLSARCHIVE Zip archive file that contains a single top-level depot_tools directory. --branch=BRANCH Branch of CEF to build (trunk, 1916, ...). This will be used to name the CEF download directory and to identify the correct URL if --url is not specified. The default value is trunk. --url=URL CEF download URL. If not specified the default URL will be used. --chromium-url=CHROMIUMURL Chromium download URL. If not specified the default URL will be used. --checkout=CHECKOUT Version of CEF to checkout. If not specified the most recent remote version of the branch will be used. --chromium-checkout=CHROMIUMCHECKOUT Version of Chromium to checkout (Git branch/hash/tag). This overrides the value specified by CEF in CHROMIUM_BUILD_COMPATIBILITY.txt. --force-config Force creation of a new gclient config file. --force-clean Force a clean checkout of Chromium and CEF. This will trigger a new update, build and distribution. --force-clean-deps Force a clean checkout of Chromium dependencies. Used in combination with --force-clean. --dry-run Output commands without executing them. --dry-run-platform=DRYRUNPLATFORM Simulate a dry run on the specified platform (windows, macosx, linux). Must be used in combination with the --dry-run flag. --force-update Force a Chromium and CEF update. This will trigger a new build and distribution. --no-update Do not update Chromium or CEF. Pass --force-build or --force-distrib if you desire a new build or distribution. --no-cef-update Do not update CEF. Pass --force-build or --force- distrib if you desire a new build or distribution. --no-chromium-update Do not update Chromium. --no-depot-tools-update Do not update depot_tools. --force-build Force CEF debug and release builds. This builds [build-target] on all platforms and chrome_sandbox on Linux. --no-build Do not build CEF. --build-target=BUILDTARGET Target name(s) to build (defaults to "cefclient"). --build-tests Also build the cef_unittests target. --no-debug-build Don't perform the CEF debug build. --no-release-build Don't perform the CEF release build. --verbose-build Show all command lines while building. --build-log-file Write build logs to file. The file will be named "build-[branch]-[debug|release].log" in the download directory. --x64-build Create a 64-bit build. --arm-build Create an ARM build. --force-distrib Force creation of a CEF binary distribution. --no-distrib Don't create a CEF binary distribution. --minimal-distrib Create a minimal CEF binary distribution. --minimal-distrib-only Create a minimal CEF binary distribution only. --client-distrib Create a client CEF binary distribution. --client-distrib-only Create a client CEF binary distribution only. --no-distrib-docs Don't create CEF documentation. --no-distrib-archive Don't create archives for output directories. --clean-artifacts Clean the artifacts output directory. --distrib-subdir=DISTRIBSUBDIR CEF distrib dir name, child of chromium/src/cef/binary_distrib """ # Copyright (c) 2014 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. from optparse import OptionParser import os import shlex import shutil import subprocess import sys import tempfile import urllib import zipfile ## # Default URLs. ## depot_tools_url = 'https://chromium.googlesource.com/chromium/tools/depot_tools.git' depot_tools_archive_url = 'https://storage.googleapis.com/chrome-infra/depot_tools.zip' cef_git_url = 'https://bitbucket.org/chromiumembedded/cef.git' ## # Global system variables. ## # Script directory. script_dir = os.path.dirname(__file__) ## # Helper functions. ## def msg(message): """ Output a message. """ sys.stdout.write('--> ' + message + "\n") def run(command_line, working_dir, depot_tools_dir=None, output_file=None): """ Runs the specified command. """ # add depot_tools to the path env = os.environ if not depot_tools_dir is None: env['PATH'] = depot_tools_dir+os.pathsep+env['PATH'] sys.stdout.write('-------- Running "'+command_line+'" in "'+\ working_dir+'"...'+"\n") if not options.dryrun: args = shlex.split(command_line.replace('\\', '\\\\')) if not output_file: return subprocess.check_call(args, cwd=working_dir, env=env, shell=(sys.platform == 'win32')) with open(output_file, "w") as f: return subprocess.check_call(args, cwd=working_dir, env=env, shell=(sys.platform == 'win32'), stderr=subprocess.STDOUT, stdout=f) def create_directory(path): """ Creates a directory if it doesn't already exist. """ if not os.path.exists(path): msg("Creating directory %s" % (path)); if not options.dryrun: os.makedirs(path) def delete_directory(path): """ Removes an existing directory. """ if os.path.exists(path): msg("Removing directory %s" % (path)); if not options.dryrun: shutil.rmtree(path, onerror=onerror) def copy_directory(source, target, allow_overwrite=False): """ Copies a directory from source to target. """ if not options.dryrun and os.path.exists(target): if not allow_overwrite: raise Exception("Directory %s already exists" % (target)) remove_directory(target) if os.path.exists(source): msg("Copying directory %s to %s" % (source, target)); if not options.dryrun: shutil.copytree(source, target) def move_directory(source, target, allow_overwrite=False): """ Copies a directory from source to target. """ if not options.dryrun and os.path.exists(target): if not allow_overwrite: raise Exception("Directory %s already exists" % (target)) remove_directory(target) if os.path.exists(source): msg("Moving directory %s to %s" % (source, target)); if not options.dryrun: shutil.move(source, target) def is_git_checkout(path): """ Returns true if the path represents a git checkout. """ return os.path.exists(os.path.join(path, '.git')) def exec_cmd(cmd, path): """ Execute the specified command and return the result. """ out = '' err = '' sys.stdout.write("-------- Running \"%s\" in \"%s\"...\n" % (cmd, path)) parts = cmd.split() try: process = subprocess.Popen(parts, cwd=path, stdout=subprocess.PIPE, stderr=subprocess.PIPE, shell=(sys.platform == 'win32')) out, err = process.communicate() except IOError, (errno, strerror): raise except: raise return {'out': out, 'err': err} def get_git_hash(path, branch): """ Returns the git hash for the specified branch/tag/hash. """ cmd = "%s rev-parse %s" % (git_exe, branch) result = exec_cmd(cmd, path) if result['out'] != '': return result['out'].strip() return 'Unknown' def get_git_url(path): """ Returns the origin url for the specified path. """ cmd = "%s config --get remote.origin.url" % (git_exe) result = exec_cmd(cmd, path) if result['out'] != '': return result['out'].strip() return 'Unknown' def download_and_extract(src, target): """ Extracts the contents of src, which may be a URL or local file, to the target directory. """ temporary = False if src[:4] == 'http': # Attempt to download a URL. opener = urllib.FancyURLopener({}) response = opener.open(src) temporary = True handle, archive_path = tempfile.mkstemp(suffix = '.zip') os.write(handle, response.read()) os.close(handle) elif os.path.exists(src): # Use a local file. archive_path = src else: raise Exception('Path type is unsupported or does not exist: ' + src) if not zipfile.is_zipfile(archive_path): raise Exception('Not a valid zip archive: ' + src) # Attempt to extract the archive file. try: os.makedirs(target) zf = zipfile.ZipFile(archive_path, 'r') zf.extractall(target) except: shutil.rmtree(target, onerror=onerror) raise zf.close() # Delete the archive file if temporary. if temporary and os.path.exists(archive_path): os.remove(archive_path) def read_file(path): """ Read a file. """ if os.path.exists(path): fp = open(path, 'r') data = fp.read() fp.close() return data else: raise Exception("Path does not exist: %s" % (path)) def read_config_file(path): """ Read a configuration file. """ # Parse the contents. return eval(read_file(path), {'__builtins__': None}, None) def write_config_file(path, contents): """ Write a configuration file. """ msg('Writing file: %s' % path) if not options.dryrun: fp = open(path, 'w') fp.write("{\n") for key in sorted(contents.keys()): fp.write(" '%s': '%s',\n" % (key, contents[key])) fp.write("}\n") fp.close() def read_branch_config_file(path): """ Read the CEF branch from the specified path. """ config_file = os.path.join(path, 'cef.branch') if os.path.isfile(config_file): contents = read_config_file(config_file) if 'branch' in contents: return contents['branch'] return '' def write_branch_config_file(path, branch): """ Write the CEF branch to the specified path. """ config_file = os.path.join(path, 'cef.branch') if not os.path.isfile(config_file): write_config_file(config_file, {'branch': branch}) def remove_deps_entry(path, entry): """ Remove an entry from the Chromium DEPS file at the specified path. """ msg('Updating DEPS file: %s' % path) if not options.dryrun: # Read the DEPS file. fp = open(path, 'r') lines = fp.readlines() fp.close() # Write the DEPS file. # Each entry takes 2 lines. Skip both lines if found. fp = open(path, 'w') skip_next = False for line in lines: if skip_next: skip_next = False continue elif line.find(entry) >= 0: skip_next = True continue fp.write(line) fp.close() def apply_deps_patch(): """ Patch the Chromium DEPS file if necessary. """ # Starting with 43.0.2357.126 the DEPS file is now 100% Git and the .DEPS.git # file is no longer created. Look for the older file first in case we're # building an older branch version. deps_file = '.DEPS.git' deps_path = os.path.join(chromium_src_dir, deps_file) if not os.path.isfile(deps_path): deps_file = 'DEPS' deps_path = os.path.join(chromium_src_dir, deps_file) if os.path.isfile(deps_path): msg("Chromium DEPS file: %s" % (deps_path)) patch_file = os.path.join(cef_dir, 'patch', 'patches', deps_file + '.patch') if os.path.exists(patch_file): # Attempt to apply the DEPS patch file that may exist with newer branches. patch_tool = os.path.join(cef_dir, 'tools', 'patcher.py') run('%s %s --patch-file "%s" --patch-dir "%s"' % (python_exe, patch_tool, patch_file, chromium_src_dir), chromium_src_dir, depot_tools_dir) elif cef_branch != 'trunk' and int(cef_branch) <= 1916: # Release branch DEPS files older than 37.0.2007.0 may include a 'src' # entry. This entry needs to be removed otherwise `gclient sync` will # fail. remove_deps_entry(deps_path, "'src'") else: raise Exception("Path does not exist: %s" % (deps_path)) def onerror(func, path, exc_info): """ Error handler for ``shutil.rmtree``. If the error is due to an access error (read only file) it attempts to add write permission and then retries. If the error is for another reason it re-raises the error. Usage : ``shutil.rmtree(path, onerror=onerror)`` """ import stat if not os.access(path, os.W_OK): # Is the error an access error ? os.chmod(path, stat.S_IWUSR) func(path) else: raise ## # Program entry point. ## # Cannot be loaded as a module. if __name__ != "__main__": sys.stderr.write('This file cannot be loaded as a module!') sys.exit() # Parse command-line options. disc = """ This utility implements automation for the download, update, build and distribution of CEF. """ parser = OptionParser(description=disc) # Setup options. parser.add_option('--download-dir', dest='downloaddir', metavar='DIR', help='Download directory with no spaces [required].') parser.add_option('--depot-tools-dir', dest='depottoolsdir', metavar='DIR', help='Download directory for depot_tools.', default='') parser.add_option('--depot-tools-archive', dest='depottoolsarchive', help='Zip archive file that contains a single top-level '+\ 'depot_tools directory.', default='') parser.add_option('--branch', dest='branch', help='Branch of CEF to build (trunk, 1916, ...). This '+\ 'will be used to name the CEF download directory and '+\ 'to identify the correct URL if --url is not '+\ 'specified. The default value is trunk.', default='trunk') parser.add_option('--url', dest='url', help='CEF download URL. If not specified the default URL '+\ 'will be used.', default='') parser.add_option('--chromium-url', dest='chromiumurl', help='Chromium download URL. If not specified the default '+\ 'URL will be used.', default='') parser.add_option('--checkout', dest='checkout', help='Version of CEF to checkout. If not specified the '+\ 'most recent remote version of the branch will be used.', default='') parser.add_option('--chromium-checkout', dest='chromiumcheckout', help='Version of Chromium to checkout (Git '+\ 'branch/hash/tag). This overrides the value specified '+\ 'by CEF in CHROMIUM_BUILD_COMPATIBILITY.txt.', default='') # Miscellaneous options. parser.add_option('--force-config', action='store_true', dest='forceconfig', default=False, help='Force creation of a new gclient config file.') parser.add_option('--force-clean', action='store_true', dest='forceclean', default=False, help='Force a clean checkout of Chromium and CEF. This will'+\ ' trigger a new update, build and distribution.') parser.add_option('--force-clean-deps', action='store_true', dest='forcecleandeps', default=False, help='Force a clean checkout of Chromium dependencies. Used'+\ ' in combination with --force-clean.') parser.add_option('--dry-run', action='store_true', dest='dryrun', default=False, help="Output commands without executing them.") parser.add_option('--dry-run-platform', dest='dryrunplatform', default=None, help='Simulate a dry run on the specified platform '+\ '(windows, macosx, linux). Must be used in combination'+\ ' with the --dry-run flag.') # Update-related options. parser.add_option('--force-update', action='store_true', dest='forceupdate', default=False, help='Force a Chromium and CEF update. This will trigger a '+\ 'new build and distribution.') parser.add_option('--no-update', action='store_true', dest='noupdate', default=False, help='Do not update Chromium or CEF. Pass --force-build or '+\ '--force-distrib if you desire a new build or '+\ 'distribution.') parser.add_option('--no-cef-update', action='store_true', dest='nocefupdate', default=False, help='Do not update CEF. Pass --force-build or '+\ '--force-distrib if you desire a new build or '+\ 'distribution.') parser.add_option('--no-chromium-update', action='store_true', dest='nochromiumupdate', default=False, help='Do not update Chromium.') parser.add_option('--no-depot-tools-update', action='store_true', dest='nodepottoolsupdate', default=False, help='Do not update depot_tools.') # Build-related options. parser.add_option('--force-build', action='store_true', dest='forcebuild', default=False, help='Force CEF debug and release builds. This builds '+\ '[build-target] on all platforms and chrome_sandbox '+\ 'on Linux.') parser.add_option('--no-build', action='store_true', dest='nobuild', default=False, help='Do not build CEF.') parser.add_option('--build-target', dest='buildtarget', default='cefclient', help='Target name(s) to build (defaults to "cefclient").') parser.add_option('--build-tests', action='store_true', dest='buildtests', default=False, help='Also build the cef_unittests target.') parser.add_option('--no-debug-build', action='store_true', dest='nodebugbuild', default=False, help="Don't perform the CEF debug build.") parser.add_option('--no-release-build', action='store_true', dest='noreleasebuild', default=False, help="Don't perform the CEF release build.") parser.add_option('--verbose-build', action='store_true', dest='verbosebuild', default=False, help='Show all command lines while building.') parser.add_option('--build-log-file', action='store_true', dest='buildlogfile', default=False, help='Write build logs to file. The file will be named '+\ '"build-[branch]-[debug|release].log" in the download '+\ 'directory.') parser.add_option('--x64-build', action='store_true', dest='x64build', default=False, help='Create a 64-bit build.') parser.add_option('--arm-build', action='store_true', dest='armbuild', default=False, help='Create an ARM build.') # Distribution-related options. parser.add_option('--force-distrib', action='store_true', dest='forcedistrib', default=False, help='Force creation of a CEF binary distribution.') parser.add_option('--no-distrib', action='store_true', dest='nodistrib', default=False, help="Don't create a CEF binary distribution.") parser.add_option('--minimal-distrib', action='store_true', dest='minimaldistrib', default=False, help='Create a minimal CEF binary distribution.') parser.add_option('--minimal-distrib-only', action='store_true', dest='minimaldistribonly', default=False, help='Create a minimal CEF binary distribution only.') parser.add_option('--client-distrib', action='store_true', dest='clientdistrib', default=False, help='Create a client CEF binary distribution.') parser.add_option('--client-distrib-only', action='store_true', dest='clientdistribonly', default=False, help='Create a client CEF binary distribution only.') parser.add_option('--no-distrib-docs', action='store_true', dest='nodistribdocs', default=False, help="Don't create CEF documentation.") parser.add_option('--no-distrib-archive', action='store_true', dest='nodistribarchive', default=False, help="Don't create archives for output directories.") parser.add_option('--clean-artifacts', action='store_true', dest='cleanartifacts', default=False, help='Clean the artifacts output directory.') parser.add_option('--distrib-subdir', dest='distribsubdir', help='CEF distrib dir name, child of '+\ 'chromium/src/cef/binary_distrib', default='') (options, args) = parser.parse_args() if options.downloaddir is None: print "The --download-dir option is required." parser.print_help(sys.stderr) sys.exit() # Opt into component-specific flags for later use. if options.noupdate: options.nocefupdate = True options.nochromiumupdate = True options.nodepottoolsupdate = True if (options.nochromiumupdate and options.forceupdate) or \ (options.nocefupdate and options.forceupdate) or \ (options.nobuild and options.forcebuild) or \ (options.nodistrib and options.forcedistrib): # -- CEF Python modification below if (options.nocefupdate and options.forceupdate): pass else: print "Invalid combination of options." parser.print_help(sys.stderr) sys.exit() # -- if (options.noreleasebuild and \ (options.minimaldistrib or options.minimaldistribonly or \ options.clientdistrib or options.clientdistribonly)) or \ (options.minimaldistribonly and options.clientdistribonly): print 'Invalid combination of options.' parser.print_help(sys.stderr) sys.exit() if options.x64build and options.armbuild: print 'Invalid combination of options.' parser.print_help(sys.stderr) sys.exit() # Operating system. if options.dryrun and options.dryrunplatform is not None: platform = options.dryrunplatform if not platform in ['windows', 'macosx', 'linux']: print 'Invalid dry-run-platform value: %s' % (platform) sys.exit() elif sys.platform == 'win32': platform = 'windows' elif sys.platform == 'darwin': platform = 'macosx' elif sys.platform.startswith('linux'): platform = 'linux' else: print 'Unknown operating system platform' sys.exit() # Script extension. if platform == 'windows': script_ext = '.bat' else: script_ext = '.sh' if options.clientdistrib or options.clientdistribonly: if platform == 'linux': client_app = 'cefsimple' else: client_app = 'cefclient' if options.buildtarget.find(client_app) == -1: print 'A client distribution cannot be generated if --build-target '+\ 'excludes %s.' % client_app parser.print_help(sys.stderr) sys.exit() # CEF branch. if options.branch != 'trunk' and not options.branch.isdigit(): print 'Invalid branch value: %s' % (options.branch) cef_branch = options.branch if cef_branch != 'trunk' and int(cef_branch) <= 1453: print 'The requested branch is too old to build using this tool' sys.exit() # True if the requested branch is 2272 or newer. branch_is_2272_or_newer = (cef_branch == 'trunk' or int(cef_branch) >= 2272) # True if the requested branch is 2357 or newer. branch_is_2357_or_newer = (cef_branch == 'trunk' or int(cef_branch) >= 2357) # True if the requested branch is 2743 or older. branch_is_2743_or_older = (cef_branch != 'trunk' and int(cef_branch) <= 2743) # True if the requested branch is newer than 2785. branch_is_newer_than_2785 = (cef_branch == 'trunk' or int(cef_branch) > 2785) # Enable GN by default for branches newer than 2785. if branch_is_newer_than_2785 and not 'CEF_USE_GN' in os.environ.keys(): os.environ['CEF_USE_GN'] = '1' # Whether to use GN or GYP. GYP is currently the default for older branches. use_gn = bool(int(os.environ.get('CEF_USE_GN', '0'))) if use_gn: if branch_is_2743_or_older: print 'GN is not supported with branch 2743 and older (set CEF_USE_GN=0).' sys.exit() if options.armbuild: if platform != 'linux': print 'The ARM build option is only supported on Linux.' sys.exit() if not branch_is_newer_than_2785: print 'The ARM build option is not supported with branch 2785 and older.' sys.exit() else: if options.armbuild: print 'The ARM build option is not supported by GYP.' sys.exit() if options.x64build and platform != 'windows' and platform != 'macosx': print 'The x64 build option is only used on Windows and Mac OS X.' sys.exit() if platform == 'windows' and not 'GYP_MSVS_VERSION' in os.environ.keys(): print 'You must set the GYP_MSVS_VERSION environment variable on Windows.' sys.exit() # True if GYP_DEFINES=target_arch=x64 must be set. gyp_needs_target_arch_x64 = options.x64build and \ (platform == 'windows' or \ (platform == 'macosx' and not branch_is_2272_or_newer)) # Starting with 43.0.2357.126 the DEPS file is now 100% Git and the .DEPS.git # file is no longer created. if branch_is_2357_or_newer: deps_file = 'DEPS' else: deps_file = '.DEPS.git' if platform == 'macosx' and not options.x64build and branch_is_2272_or_newer: print '32-bit Mac OS X builds are no longer supported with 2272 branch and '+\ 'newer. Add --x64-build flag to generate a 64-bit build.' sys.exit() # Options that force the sources to change. force_change = options.forceclean or options.forceupdate if platform == 'windows': # Avoid errors when the "vs_toolchain.py update" Chromium hook runs. os.environ['DEPOT_TOOLS_WIN_TOOLCHAIN'] = '0' ## # Manage the download directory. ## # Create the download directory if necessary. download_dir = os.path.abspath(options.downloaddir) create_directory(download_dir) msg("Download Directory: %s" % (download_dir)) ## # Manage the depot_tools directory. ## # Check if the depot_tools directory exists. if options.depottoolsdir != '': depot_tools_dir = os.path.abspath(options.depottoolsdir) else: depot_tools_dir = os.path.join(download_dir, 'depot_tools') msg("Depot Tools Directory: %s" % (depot_tools_dir)) if not os.path.exists(depot_tools_dir): if platform == 'windows' and options.depottoolsarchive == '': # On Windows download depot_tools as an archive file since we can't assume # that git is already installed. options.depottoolsarchive = depot_tools_archive_url if options.depottoolsarchive != '': # Extract depot_tools from an archive file. msg('Extracting %s to %s.' % \ (options.depottoolsarchive, depot_tools_dir)) if not options.dryrun: download_and_extract(options.depottoolsarchive, depot_tools_dir) else: # On Linux and OS X check out depot_tools using Git. run('git clone '+depot_tools_url+' '+depot_tools_dir, download_dir) if not options.nodepottoolsupdate: # Update depot_tools. # On Windows this will download required python and git binaries. msg('Updating depot_tools') if platform == 'windows': run('update_depot_tools.bat', depot_tools_dir, depot_tools_dir); else: run('update_depot_tools', depot_tools_dir, depot_tools_dir); # Determine the executables to use. if platform == 'windows': # Force use of the version bundled with depot_tools. git_exe = os.path.join(depot_tools_dir, 'git.bat') python_exe = os.path.join(depot_tools_dir, 'python.bat') if options.dryrun and not os.path.exists(git_exe): sys.stdout.write("WARNING: --dry-run assumes that depot_tools" \ " is already in your PATH. If it isn't\nplease" \ " specify a --depot-tools-dir value.\n") git_exe = 'git.bat' python_exe = 'python.bat' else: git_exe = 'git' python_exe = 'python' ## # Manage the cef directory. ## cef_dir = os.path.join(download_dir, 'cef') # Delete the existing CEF directory if requested. if options.forceclean and os.path.exists(cef_dir): delete_directory(cef_dir) # Determine the type of CEF checkout to use. if os.path.exists(cef_dir) and not is_git_checkout(cef_dir): raise Exception("Not a valid CEF Git checkout: %s" % (cef_dir)) # Determine the CEF download URL to use. if options.url == '': cef_url = cef_git_url else: cef_url = options.url # Verify that the requested CEF URL matches the existing checkout. if not options.nocefupdate and os.path.exists(cef_dir): cef_existing_url = get_git_url(cef_dir) if cef_url != cef_existing_url: raise Exception( 'Requested CEF checkout URL %s does not match existing URL %s' % (cef_url, cef_existing_url)) msg("CEF Branch: %s" % (cef_branch)) msg("CEF URL: %s" % (cef_url)) msg("CEF Source Directory: %s" % (cef_dir)) # Determine the CEF Git branch to use. if options.checkout == '': # Target the most recent branch commit from the remote repo. if cef_branch == 'trunk': cef_checkout = 'origin/master' else: cef_checkout = 'origin/' + cef_branch else: cef_checkout = options.checkout # Create the CEF checkout if necessary. if not options.nocefupdate and not os.path.exists(cef_dir): cef_checkout_new = True run('%s clone %s %s' % (git_exe, cef_url, cef_dir), download_dir, \ depot_tools_dir) else: cef_checkout_new = False # Update the CEF checkout if necessary. if not options.nocefupdate and os.path.exists(cef_dir): cef_current_hash = get_git_hash(cef_dir, 'HEAD') if not cef_checkout_new: # Fetch new sources. run('%s fetch' % (git_exe), cef_dir, depot_tools_dir) cef_desired_hash = get_git_hash(cef_dir, cef_checkout) cef_checkout_changed = cef_checkout_new or force_change or \ cef_current_hash != cef_desired_hash msg("CEF Current Checkout: %s" % (cef_current_hash)) msg("CEF Desired Checkout: %s (%s)" % (cef_desired_hash, cef_checkout)) if cef_checkout_changed: # Checkout the requested branch. run('%s checkout %s%s' % (git_exe, ('--force ' if options.forceclean else ''), cef_checkout), \ cef_dir, depot_tools_dir) else: cef_checkout_changed = False ## # Manage the out directory. ## out_dir = os.path.join(download_dir, 'out_' + cef_branch) # Delete the existing out directory if requested. if options.forceclean and os.path.exists(out_dir): delete_directory(out_dir) msg("CEF Output Directory: %s" % (out_dir)) ## # Manage the chromium directory. ## # Create the chromium directory if necessary. chromium_dir = os.path.join(download_dir, 'chromium') create_directory(chromium_dir) chromium_src_dir = os.path.join(chromium_dir, 'src') cef_src_dir = os.path.join(chromium_src_dir, 'cef') out_src_dir = os.path.join(chromium_src_dir, 'out') if options.chromiumurl != '': chromium_url = options.chromiumurl; else: chromium_url = 'https://chromium.googlesource.com/chromium/src.git' # Create gclient configuration file. gclient_file = os.path.join(chromium_dir, '.gclient') if not os.path.exists(gclient_file) or options.forceconfig: # Exclude unnecessary directories. Intentionally written without newlines. gclient_spec = \ "solutions = [{"+\ "u'managed': False,"+\ "u'name': u'src', "+\ "u'url': u'" + chromium_url + "', "+\ "u'custom_deps': {"+\ "u'build': None, "+\ "u'build/scripts/command_wrapper/bin': None, "+\ "u'build/scripts/gsd_generate_index': None, "+\ "u'build/scripts/private/data/reliability': None, "+\ "u'build/scripts/tools/deps2git': None, "+\ "u'build/third_party/lighttpd': None, "+\ "u'commit-queue': None, "+\ "u'depot_tools': None, "+\ "u'src/chrome_frame/tools/test/reference_build/chrome': None, "+\ "u'src/chrome/tools/test/reference_build/chrome_linux': None, "+\ "u'src/chrome/tools/test/reference_build/chrome_mac': None, "+\ "u'src/chrome/tools/test/reference_build/chrome_win': None, "+\ "}, "+\ "u'deps_file': u'" + deps_file + "', "+\ "u'safesync_url': u''"+\ "}]" msg('Writing file: %s' % gclient_file) if not options.dryrun: fp = open(gclient_file, 'w') fp.write(gclient_spec) fp.close() # Initial Chromium checkout. if not options.nochromiumupdate and not os.path.exists(chromium_src_dir): chromium_checkout_new = True run("gclient sync --nohooks --with_branch_heads --jobs 16", chromium_dir, \ depot_tools_dir) else: chromium_checkout_new = False # Verify the Chromium checkout. if not options.dryrun and not is_git_checkout(chromium_src_dir): raise Exception('Not a valid git checkout: %s' % (chromium_src_dir)) if os.path.exists(chromium_src_dir): msg("Chromium URL: %s" % (get_git_url(chromium_src_dir))) # Determine the Chromium checkout options required by CEF. if options.chromiumcheckout == '': # Read the build compatibility file to identify the checkout name. compat_path = os.path.join(cef_dir, 'CHROMIUM_BUILD_COMPATIBILITY.txt') config = read_config_file(compat_path) if 'chromium_checkout' in config: chromium_checkout = config['chromium_checkout'] else: raise Exception("Missing chromium_checkout value in %s" % (compat_path)) else: chromium_checkout = options.chromiumcheckout # Determine if the Chromium checkout needs to change. if not options.nochromiumupdate and os.path.exists(chromium_src_dir): chromium_current_hash = get_git_hash(chromium_src_dir, 'HEAD') chromium_desired_hash = get_git_hash(chromium_src_dir, chromium_checkout) chromium_checkout_changed = chromium_checkout_new or force_change or \ chromium_current_hash != chromium_desired_hash msg("Chromium Current Checkout: %s" % (chromium_current_hash)) msg("Chromium Desired Checkout: %s (%s)" % \ (chromium_desired_hash, chromium_checkout)) else: chromium_checkout_changed = options.dryrun # Delete the existing src/cef directory. It will be re-copied from the download # directory later. if cef_checkout_changed and os.path.exists(cef_src_dir): delete_directory(cef_src_dir) # Delete the existing src/out directory if requested. if options.forceclean and os.path.exists(out_src_dir): delete_directory(out_src_dir) # Move the existing src/out directory to the correct location in the download # directory. It will be moved back from the download directory later. if os.path.exists(out_src_dir): old_branch = read_branch_config_file(out_src_dir) if old_branch != '' and (chromium_checkout_changed or \ old_branch != cef_branch): old_out_dir = os.path.join(download_dir, 'out_' + old_branch) move_directory(out_src_dir, old_out_dir) # Update the Chromium checkout. if chromium_checkout_changed: if not chromium_checkout_new: if options.forceclean and options.forcecleandeps: # Remove all local changes including third-party git checkouts managed by # gclient. run("%s clean -dffx" % (git_exe), chromium_src_dir, depot_tools_dir) else: # Revert all changes in the Chromium checkout. run("gclient revert --nohooks", chromium_dir, depot_tools_dir) # Fetch new sources. run("%s fetch" % (git_exe), chromium_src_dir, depot_tools_dir) # Also fetch tags, which are required for release branch builds. run("%s fetch --tags" % (git_exe), chromium_src_dir, depot_tools_dir) # Checkout the requested branch. run("%s checkout %s%s" % \ (git_exe, ('--force ' if options.forceclean else ''), chromium_checkout), \ chromium_src_dir, depot_tools_dir) # Patch the Chromium DEPS file if necessary. apply_deps_patch() # Set the GYP_CHROMIUM_NO_ACTION value temporarily so that `gclient sync` does # not run gyp. os.environ['GYP_CHROMIUM_NO_ACTION'] = '1' # Update third-party dependencies including branch/tag information. run("gclient sync %s--with_branch_heads --jobs 16" % \ (('--reset ' if options.forceclean else '')), \ chromium_dir, depot_tools_dir) # Clear the GYP_CHROMIUM_NO_ACTION value. del os.environ['GYP_CHROMIUM_NO_ACTION'] # Delete the src/out directory created by `gclient sync`. delete_directory(out_src_dir) # Restore the src/cef directory. if os.path.exists(cef_dir) and not os.path.exists(cef_src_dir): copy_directory(cef_dir, cef_src_dir) # Restore the src/out directory. out_src_dir_exists = os.path.exists(out_src_dir) if os.path.exists(out_dir) and not out_src_dir_exists: move_directory(out_dir, out_src_dir) out_src_dir_exists = True elif not out_src_dir_exists: create_directory(out_src_dir) # Write the config file for identifying the branch. write_branch_config_file(out_src_dir, cef_branch) ## # Build CEF. ## if not options.nobuild and (chromium_checkout_changed or \ cef_checkout_changed or options.forcebuild or \ not out_src_dir_exists): # Building should also force a distribution. options.forcedistrib = True if use_gn: # Make sure the GN configuration exists. if not options.dryrun and \ not os.path.exists(os.path.join(cef_src_dir, 'BUILD.gn')): raise Exception('GN configuration does not exist; set CEF_USE_GN=0') else: # Make sure the GYP configuration exists. if not options.dryrun and \ not os.path.exists(os.path.join(cef_src_dir, 'cef.gyp')): raise Exception('GYP configuration does not exist; set CEF_USE_GN=1') # Set GYP environment variables. os.environ['GYP_GENERATORS'] = 'ninja' if gyp_needs_target_arch_x64: if 'GYP_DEFINES' in os.environ.keys(): os.environ['GYP_DEFINES'] = os.environ['GYP_DEFINES'] + ' ' + \ 'target_arch=x64' else: os.environ['GYP_DEFINES'] = 'target_arch=x64' # Print all build-related environment variables including any that were set # previously. for key in os.environ.keys(): if key.startswith('CEF_') or key.startswith('GN_') or \ key.startswith('GYP_') or key.startswith('DEPOT_TOOLS_'): msg('%s=%s' % (key, os.environ[key])) # Run the cef_create_projects script to generate project files. path = os.path.join(cef_src_dir, 'cef_create_projects'+script_ext) run(path, cef_src_dir, depot_tools_dir) # Build using Ninja. command = 'ninja -C ' if options.verbosebuild: command = 'ninja -v -C' # -- CEF Python modification below assert os.environ['CEFPYTHON_NINJA_JOBS'] command = 'ninja -v -j' + os.environ['CEFPYTHON_NINJA_JOBS'] + ' -C' # -- target = ' ' + options.buildtarget if options.buildtests: target = target + ' cef_unittests' if platform == 'linux': target = target + ' chrome_sandbox' build_dir_suffix = '' if use_gn: # CEF uses a consistent directory naming scheme for GN via # GetAllPlatformConfigs in tools/gn_args.py. if options.x64build: build_dir_suffix = '_GN_x64' elif options.armbuild: build_dir_suffix = '_GN_arm' else: build_dir_suffix = '_GN_x86' else: # GYP outputs both x86 and x64 builds to the same directory on Linux and # Mac OS X. On Windows it suffixes the directory name for x64 builds. if platform == 'windows' and options.x64build: build_dir_suffix = '_x64' if not options.nodebugbuild: build_path = os.path.join('out', 'Debug' + build_dir_suffix) if use_gn: args_path = os.path.join(chromium_src_dir, build_path, 'args.gn') if os.path.exists(args_path): msg(args_path + ' contents:\n' + read_file(args_path)) # Make a CEF Debug build. run(command + build_path + target, chromium_src_dir, depot_tools_dir, os.path.join(download_dir, 'build-%s-debug.log' % (cef_branch)) \ if options.buildlogfile else None) if not options.noreleasebuild: build_path = os.path.join('out', 'Release' + build_dir_suffix) if use_gn: args_path = os.path.join(chromium_src_dir, build_path, 'args.gn') if os.path.exists(args_path): msg(args_path + ' contents:\n' + read_file(args_path)) # Make a CEF Release build. run(command + build_path + target, chromium_src_dir, depot_tools_dir, os.path.join(download_dir, 'build-%s-release.log' % (cef_branch)) \ if options.buildlogfile else None) elif not options.nobuild: msg('Not building. The source hashes have not changed and ' + 'the output folder "%s" already exists' % (out_src_dir)) ## # Create the CEF binary distribution. ## if not options.nodistrib and (chromium_checkout_changed or \ cef_checkout_changed or options.forcedistrib): if not options.forceclean and options.cleanartifacts: # Clean the artifacts output directory. artifacts_path = os.path.join(cef_src_dir, 'binary_distrib') delete_directory(artifacts_path) # Determine the requested distribution types. distrib_types = [] if options.minimaldistribonly: distrib_types.append('minimal') elif options.clientdistribonly: distrib_types.append('client') else: distrib_types.append('standard') if options.minimaldistrib: distrib_types.append('minimal') if options.clientdistrib: distrib_types.append('client') cef_tools_dir = os.path.join(cef_src_dir, 'tools') # Create the requested distribution types. first_type = True for type in distrib_types: path = os.path.join(cef_tools_dir, 'make_distrib'+script_ext) if options.nodebugbuild or options.noreleasebuild or type != 'standard': path = path + ' --allow-partial' path = path + ' --ninja-build' if options.x64build: path = path + ' --x64-build' elif options.armbuild: path = path + ' --arm-build' if type == 'minimal': path = path + ' --minimal' elif type == 'client': path = path + ' --client' if first_type: if options.nodistribdocs: path = path + ' --no-docs' if options.nodistribarchive: path = path + ' --no-archive' first_type = False else: # Don't create the symbol archives or documentation more than once. path = path + ' --no-symbols --no-docs' # Override the subdirectory name of binary_distrib if the caller requested. if options.distribsubdir != '': path = path + ' --distrib-subdir=' + options.distribsubdir # Create the distribution. run(path, cef_tools_dir, depot_tools_dir) cefpython-49.0/tools/automate-git.py.patch000066400000000000000000000140751334103266300206650ustar00rootroot00000000000000diff --git automate-git.py automate-git.py index d5e75ae..9b3db23 100644 --- automate-git.py +++ automate-git.py @@ -1,3 +1,92 @@ +""" See automate.py. This script is for internal usage only, don't +call it directly. This is a modified copy of automate-git.py from +upstream CEF. + +Some modifications were applied for CEF Python specific use case. +There is a patch file with the same name as this script that contains +differences from the original file. + +------------------------------------------------------------------------------- + +Usage: automate-git.py [options] + + This utility implements automation for the download, update, build and +distribution of CEF. + +Options: + -h, --help show this help message and exit + --download-dir=DIR Download directory with no spaces [required]. + --depot-tools-dir=DIR + Download directory for depot_tools. + --depot-tools-archive=DEPOTTOOLSARCHIVE + Zip archive file that contains a single top-level + depot_tools directory. + --branch=BRANCH Branch of CEF to build (trunk, 1916, ...). This will + be used to name the CEF download directory and to + identify the correct URL if --url is not specified. + The default value is trunk. + --url=URL CEF download URL. If not specified the default URL + will be used. + --chromium-url=CHROMIUMURL + Chromium download URL. If not specified the default + URL will be used. + --checkout=CHECKOUT Version of CEF to checkout. If not specified the most + recent remote version of the branch will be used. + --chromium-checkout=CHROMIUMCHECKOUT + Version of Chromium to checkout (Git branch/hash/tag). + This overrides the value specified by CEF in + CHROMIUM_BUILD_COMPATIBILITY.txt. + --force-config Force creation of a new gclient config file. + --force-clean Force a clean checkout of Chromium and CEF. This will + trigger a new update, build and distribution. + --force-clean-deps Force a clean checkout of Chromium dependencies. Used + in combination with --force-clean. + --dry-run Output commands without executing them. + --dry-run-platform=DRYRUNPLATFORM + Simulate a dry run on the specified platform (windows, + macosx, linux). Must be used in combination with the + --dry-run flag. + --force-update Force a Chromium and CEF update. This will trigger a + new build and distribution. + --no-update Do not update Chromium or CEF. Pass --force-build or + --force-distrib if you desire a new build or + distribution. + --no-cef-update Do not update CEF. Pass --force-build or --force- + distrib if you desire a new build or distribution. + --no-chromium-update Do not update Chromium. + --no-depot-tools-update + Do not update depot_tools. + --force-build Force CEF debug and release builds. This builds + [build-target] on all platforms and chrome_sandbox on + Linux. + --no-build Do not build CEF. + --build-target=BUILDTARGET + Target name(s) to build (defaults to "cefclient"). + --build-tests Also build the cef_unittests target. + --no-debug-build Don't perform the CEF debug build. + --no-release-build Don't perform the CEF release build. + --verbose-build Show all command lines while building. + --build-log-file Write build logs to file. The file will be named + "build-[branch]-[debug|release].log" in the download + directory. + --x64-build Create a 64-bit build. + --arm-build Create an ARM build. + --force-distrib Force creation of a CEF binary distribution. + --no-distrib Don't create a CEF binary distribution. + --minimal-distrib Create a minimal CEF binary distribution. + --minimal-distrib-only + Create a minimal CEF binary distribution only. + --client-distrib Create a client CEF binary distribution. + --client-distrib-only + Create a client CEF binary distribution only. + --no-distrib-docs Don't create CEF documentation. + --no-distrib-archive Don't create archives for output directories. + --clean-artifacts Clean the artifacts output directory. + --distrib-subdir=DISTRIBSUBDIR + CEF distrib dir name, child of + chromium/src/cef/binary_distrib +""" + # Copyright (c) 2014 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. @@ -457,9 +546,14 @@ if (options.nochromiumupdate and options.forceupdate) or \ (options.nocefupdate and options.forceupdate) or \ (options.nobuild and options.forcebuild) or \ (options.nodistrib and options.forcedistrib): - print "Invalid combination of options." - parser.print_help(sys.stderr) - sys.exit() + # -- CEF Python modification below + if (options.nocefupdate and options.forceupdate): + pass + else: + print "Invalid combination of options." + parser.print_help(sys.stderr) + sys.exit() + # -- if (options.noreleasebuild and \ (options.minimaldistrib or options.minimaldistribonly or \ @@ -945,6 +1039,12 @@ if not options.nobuild and (chromium_checkout_changed or \ command = 'ninja -C ' if options.verbosebuild: command = 'ninja -v -C' + + # -- CEF Python modification below + assert os.environ['CEFPYTHON_NINJA_JOBS'] + command = 'ninja -v -j' + os.environ['CEFPYTHON_NINJA_JOBS'] + ' -C' + # -- + target = ' ' + options.buildtarget if options.buildtests: target = target + ' cef_unittests' cefpython-49.0/tools/automate.py000066400000000000000000001143531334103266300170060ustar00rootroot00000000000000# Copyright (c) 2016 CEF Python, see the Authors file. # All rights reserved. Licensed under BSD 3-clause license. # Project website: https://github.com/cztomczak/cefpython """ Prepares CEF binaries and libraries for work with the build.py tool. Option 1 is to build CEF from sources with the CEF Python patches applied using the --build-cef flag. Building CEF from sources is supported only on 64-bit systems. 32-bit is also built on 64-bit using cross-compiling. Note that building CEF from sources was last tested with v56 on Linux and with v50 on Windows, so if there are issues report them on the Forum. Option 2 is to use CEF binaries from Spotify Automated Builds using the --prebuilt-cef flag. In such case check the cefpython/src/version/ directory to know which version of CEF to download from Spotify: http://opensource.spotify.com/cefbuilds/index.html Download and extract it so that for example you have such a directory: cefpython/build/cef_binary_3.2883.1553.g80bd606_windows32/ . This tool generates CEF binaries and libraries that are ready for work with cefpython, with the build.py script. When automate.py tool completes job you should see a new subdirectory in the build/ directory, for example: cefpython/build/cef55_3.2883.1553.g80bd606_win32/ . Usage: automate.py (--prebuilt-cef | --build-cef) [--x86 X86] [--fast-build FAST_BUILD] [--force-chromium-update FORCE_CHROMIUM_UPDATE] [--no-cef-update NO_CEF_UPDATE] [--cef-branch BRANCH] [--cef-commit COMMIT] [--build-dir BUILD_DIR] [--cef-build-dir CEF_BUILD_DIR] [--ninja-jobs JOBS] [--gyp-generators GENERATORS] [--gyp-msvs-version MSVS] automate.py (-h | --help) [type -h to show full description for options] Options: -h --help Show this help message. --prebuilt-cef Whether to use prebuilt CEF binaries. Prebuilt binaries for Linux are built on Ubuntu. --build-cef Whether to build CEF from sources with the cefpython patches applied. --x86 Build 32-bit CEF on 64-bit system --fast-build Fast build with is_official_build=False --force-chromium-update Force Chromium update (gclient sync etc). --no-cef-update Do not update CEF sources (by default both cef/ directories are deleted on every run). --cef-branch= CEF branch. Defaults to CHROME_VERSION_BUILD from "src/version/cef_version_{platform}.h". --cef-commit= CEF revision. Defaults to CEF_COMMIT_HASH from "src/version/cef_version_{platform}.h". --build-dir= Build directory. --cef-build-dir= CEF build directory. By default same as --build-dir. --ninja-jobs= How many CEF jobs to run in parallel. To speed up building set it to number of cores in your CPU. By default set to cpu_count / 2. --gyp-generators= Set GYP_GENERATORS [default: ninja]. --gyp-msvs-version= Set GYP_MSVS_VERSION. """ from common import * import os import sys import shlex import subprocess import platform import docopt import stat import glob import shutil import multiprocessing from collections import OrderedDict from setuptools.msvc import msvc9_query_vcvarsall # Constants CEF_GIT_URL = "https://bitbucket.org/chromiumembedded/cef.git" RUNTIME_MT = "MT" RUNTIME_MD = "MD" class Options(object): """Options from command-line and internal options.""" # From command-line prebuilt_cef = False build_cef = False x86 = False fast_build = False force_chromium_update = False no_cef_update = False cef_branch = "" cef_commit = "" cef_version = "" build_dir = "" cef_build_dir = "" ninja_jobs = None gyp_generators = "ninja" # Even though CEF uses now GN, still some GYP gyp_msvs_version = "" # env variables are being used. # Internal options depot_tools_dir = "" tools_dir = "" cefpython_dir = "" binary_distrib = "" release_build = True build_type = "" # Will be set according to "release_build" value cef_binary = "" def main(): """Main entry point.""" if len(sys.argv) <= 1: print(__doc__) sys.exit(1) setup_options(docopt.docopt(__doc__)) if Options.build_cef: if not sys.version_info[:2] == (2, 7): print("ERROR: To build CEF from sources you need Python 2.7," " as upstream automate-git.py only works with that" " version of python.") sys.exit(1) build_cef() elif Options.prebuilt_cef: prebuilt_cef() def setup_options(docopt_args): """Setup options from cmd-line and internal options.""" # Populate Options using command line arguments for key in docopt_args: value = docopt_args[key] key2 = key.replace("--", "").replace("-", "_") if hasattr(Options, key2) and value is not None: setattr(Options, key2, value) Options.tools_dir = os.path.dirname(os.path.realpath(__file__)) Options.cefpython_dir = os.path.dirname(Options.tools_dir) # If --cef-branch is specified will use latest CEF commit from that # branch. Otherwise get cef branch/commit from src/version/. if not Options.cef_branch: # Use branch/commit from the src/version/cef_version_*.h file Options.cef_branch = get_cefpython_version()["CHROME_VERSION_BUILD"] Options.cef_commit = get_cefpython_version()["CEF_COMMIT_HASH"] Options.cef_version = get_cefpython_version()["CEF_VERSION"] # --gyp-msvs-version if not Options.gyp_msvs_version: if int(Options.cef_branch) >= 2704: Options.gyp_msvs_version = "2015" else: # Branch 2623 supports building with VS 2013, so you can # change it to 2013 below. Options.gyp_msvs_version = "2015" # --build-dir if Options.build_dir: Options.build_dir = os.path.realpath(Options.build_dir) else: Options.build_dir = os.path.join(Options.cefpython_dir, "build") if " " in Options.build_dir: print("[automate.py] ERROR: Build dir cannot contain spaces") print(">> " + Options.build_dir) sys.exit(1) if not os.path.exists(Options.build_dir): os.makedirs(Options.build_dir) # --cef-build-dir if Options.cef_build_dir: Options.cef_build_dir = os.path.realpath(Options.cef_build_dir) else: Options.cef_build_dir = Options.build_dir if " " in Options.cef_build_dir: print("[automate.py] ERROR: CEF build dir cannot contain spaces") print(">> " + Options.cef_build_dir) sys.exit(1) if not os.path.exists(Options.cef_build_dir): os.makedirs(Options.cef_build_dir) # --depot-tools-dir Options.depot_tools_dir = os.path.join(Options.cef_build_dir, "depot_tools") # binary_distrib Options.binary_distrib = os.path.join(Options.cef_build_dir, "chromium", "src", "cef", "binary_distrib") # build_type Options.build_type = "Release" if Options.release_build else "Debug" # ninja_jobs # cpu_count() returns number of CPU threads, not CPU cores. # On i5 with 2 cores and 4 cpu threads the default of 4 ninja # jobs slows down computer significantly. if not Options.ninja_jobs: Options.ninja_jobs = int(multiprocessing.cpu_count() / 2) if Options.ninja_jobs < 1: Options.ninja_jobs = 1 Options.ninja_jobs = str(Options.ninja_jobs) def build_cef(): """Build CEF from sources.""" if ARCH32: print("[automate.py] INFO: building CEF 32-bit from sources is" " supported only with cross-compiling on 64-bit OS.") sys.exit(1) # cef/ repo create_cef_directories() # Delete binary_distrib if os.path.exists(Options.binary_distrib): rmdir(Options.binary_distrib) # Run automate-git.py run_automate_git() print("[automate.py] Binary distrib created in %s" % Options.binary_distrib) if Options.x86: print("[automate.py] INFO: Build CEF projects and create prebuilt" " binaries on Linux 32-bit using eg. VirtualBox. Copy the binary" " distrib's cef_binary_*/ directory (path displayed above) to" " cefpython's build/ directory. Then run automate.py" " --prebuilt-cef on Linux 32-bit.") sys.exit(0) else: # Build cefclient, cefsimple, libcef_dll_wrapper build_cef_projects() create_prebuilt_binaries() def prebuilt_cef(): """Use prebuilt binaries.""" # TODO: Option to download CEF prebuilt binaries from GitHub Releases, # eg. tag 'upstream-cef47'. # Find cef_binary directory in the build directory postfix2 = CEF_POSTFIX2 if Options.x86: postfix2 = get_cef_postfix2_for_arch("32bit") if Options.cef_version: cef_binary = os.path.join(Options.build_dir, "cef_binary_{cef_version}_{os}{sep}" .format(cef_version=Options.cef_version, os=postfix2, sep=os.sep)) else: cef_binary = os.path.join(Options.build_dir, "cef_binary_3.{cef_branch}.*_{os}{sep}" .format(cef_branch=Options.cef_branch, os=postfix2, sep=os.sep)) dirs = glob.glob(cef_binary) if len(dirs) == 1: Options.cef_binary = dirs[0] else: print("ERROR: Could not find prebuilt binaries in the build dir:") print(" {cef_binary}".format(cef_binary=cef_binary)) sys.exit(1) build_cef_projects() create_prebuilt_binaries() def create_cef_directories(): """Create cef/ directories in cef_build_dir/ and in chromium/src/ .""" if Options.no_cef_update: return cef_dir = os.path.join(Options.cef_build_dir, "cef") src_dir = os.path.join(Options.cef_build_dir, "chromium", "src") cef_dir2 = os.path.join(src_dir, "cef") # Clone cef repo and checkout branch if os.path.exists(cef_dir): rmdir(cef_dir) run_git("clone -b %s %s cef" % (Options.cef_branch, CEF_GIT_URL), Options.cef_build_dir) if Options.cef_commit: run_git("checkout %s" % Options.cef_commit, cef_dir) # Update cef patches update_cef_patches() # Copy cef/ to chromium/src/ but only if chromium/src/ exists, # but don't copy it and delete if exists when --force-chromium-update # flag is passed, chromium throws error about unstaged changes. if os.path.exists(src_dir): if os.path.exists(cef_dir2): rmdir(cef_dir2) if not Options.force_chromium_update: shutil.copytree(cef_dir, cef_dir2) def update_cef_patches(): """Update cef/patch/ directory with CEF Python patches. Issue73 is applied in getenv() by setting appropriate env var. Note that this modifies only cef_build_dir/cef/ directory. If the build was run previously then there is a copy of the cef/ directory in the cef_build_dir/chromium/ directory which is not being updated. """ print("[automate.py] Updating CEF patches with CEF Python patches") cef_dir = os.path.join(Options.cef_build_dir, "cef") cef_patch_dir = os.path.join(cef_dir, "patch") cef_patches_dir = os.path.join(cef_patch_dir, "patches") # Copy src/patches/*.patch to cef/patch/patches/ cefpython_patches_dir = os.path.join(Options.cefpython_dir, "patches") cefpython_patches = glob.glob(os.path.join(cefpython_patches_dir, "*.patch")) for file_ in cefpython_patches: print("[automate.py] Copying %s to %s" % (os.path.basename(file_), cef_patches_dir)) shutil.copy(file_, cef_patches_dir) # Append cefpython/patches/patch.py to cef/patch/patch.cfg cef_patch_cfg = os.path.join(cef_patch_dir, "patch.cfg") print("[automate.py] Overwriting %s" % cef_patch_cfg) with open(cef_patch_cfg, "rb") as fp: cef_patch_cfg_contents = fp.read().decode("utf-8") cef_patch_cfg_contents += "\n" cefpython_patch_cfg = os.path.join(cefpython_patches_dir, "patch.py") with open(cefpython_patch_cfg, "rb") as fp: cefpython_patch_cfg_contents = fp.read().decode("utf-8") with open(cef_patch_cfg, "wb") as fp: cef_patch_cfg_contents = cef_patch_cfg_contents.replace("\r\n", "\n") cefpython_patch_cfg_contents = cefpython_patch_cfg_contents.replace( "\r\n", "\n") new_contents = cef_patch_cfg_contents + cefpython_patch_cfg_contents fp.write(new_contents.encode("utf-8")) def build_cef_projects(): """Build cefclient, cefsimple, libcef_dll_wrapper.""" print("[automate.py] Build cef projects...") if WINDOWS: # fix_cmake_variables_permanently_windows() pass # fix_cef_include_files() # Find cef_binary directory. # Might already be set if --prebuilt-cef flag was passed. if not Options.cef_binary: if platform.system() == "Windows": files = glob.glob(os.path.join(Options.binary_distrib, "cef_binary_*_symbols")) assert len(files) == 1, ("More than one dir with release" " symbols found") symbols = files[0] if Options.release_build: cef_binary = symbols.replace("_release_symbols", "") else: cef_binary = symbols.replace("_debug_symbols", "") assert "symbols" not in os.path.basename(cef_binary) else: postfix2 = CEF_POSTFIX2 if Options.x86: postfix2 = get_cef_postfix2_for_arch("32bit") files = glob.glob(os.path.join(Options.binary_distrib, "cef_binary_*_"+postfix2)) assert len(files) == 1, "Error finding binary distrib" cef_binary = files[0] assert os.path.exists(cef_binary) Options.cef_binary = cef_binary # Set build directory build_cefclient_dir = os.path.join(Options.cef_binary, "build_cefclient") cefclient_exe = os.path.join(build_cefclient_dir, "cefclient", "cefclient" + APP_EXT) # Check whether already built already_built = False if os.path.exists(cefclient_exe): already_built = True elif os.path.exists(build_cefclient_dir): # Last build failed, clean directory assert build_cefclient_dir shutil.rmtree(build_cefclient_dir) print("[automate.py] Create build_cefclient/ dir in cef_binary*/ dir") os.makedirs(build_cefclient_dir) else: print("[automate.py] Create build_cefclient/ dir in cef_binary*/ dir") os.makedirs(build_cefclient_dir) # Build cefclient, cefsimple if already_built: print("[automate.py] Already built: cefclient, cefsimple") else: print("[automate.py] Build cefclient, cefsimple") # Cmake command = prepare_build_command() command.extend(["cmake", "-G", "Ninja"]) command.append("-DCMAKE_BUILD_TYPE="+Options.build_type) if MAC: command.append("-DPROJECT_ARCH=x86_64") command.append("..") run_command(command, build_cefclient_dir) print("[automate.py] OK") # Ninja command = prepare_build_command() # On Mac cefclient fails with XCode 5: # > cefclient_mac.mm:22:29: error: property 'mainMenu' not found if MAC: # Build only cefsimple command.extend(["ninja", "-j", Options.ninja_jobs, "cefsimple"]) else: command.extend(["ninja", "-j", Options.ninja_jobs, "cefclient", "cefsimple"]) run_command(command, build_cefclient_dir) print("[automate.py] OK") assert os.path.exists(cefclient_exe) # Build libcef_dll_wrapper libs if WINDOWS: build_all_wrapper_libraries_windows() elif MAC: build_wrapper_library_mac() def build_all_wrapper_libraries_windows(): python_compilers = get_available_python_compilers() if not len(python_compilers): print("[automate.py] ERROR: Visual Studio compiler not found") sys.exit(1) for msvs in python_compilers: vcvars = python_compilers[msvs] print("[automate.py] Build libcef_dll_wrapper libraries for" " VS{msvs}".format(msvs=msvs)) build_wrapper_library_windows(runtime_library=RUNTIME_MT, msvs=msvs, vcvars=vcvars) build_wrapper_library_windows(runtime_library=RUNTIME_MD, msvs=msvs, vcvars=vcvars) def build_wrapper_library_windows(runtime_library, msvs, vcvars): # When building library cmake variables file is being modified # for the /MD build. If the build fails and variables aren't # restored then the next /MT build would be broken. Make sure # that original contents of cmake variables files is always # restored. fix_cmake_variables_for_MD_library(try_undo=True) # Command to build libcef_dll_wrapper cmake_wrapper = prepare_build_command(build_lib=True, vcvars=vcvars) cmake_wrapper.extend(["cmake", "-G", "Ninja", "-DCMAKE_BUILD_TYPE="+Options.build_type, ".."]) # Build directory and library path build_wrapper_dir = os.path.join( Options.cef_binary, "build_wrapper_{runtime_library}_VS{msvs}" .format(runtime_library=runtime_library, msvs=msvs)) wrapper_lib = os.path.join(build_wrapper_dir, "libcef_dll", "libcef_dll_wrapper{ext}".format(ext=LIB_EXT)) # Check whether library is already built mt_already_built = False if os.path.exists(wrapper_lib): mt_already_built = True elif os.path.exists(build_wrapper_dir): # Last build failed, clean directory assert build_wrapper_dir shutil.rmtree(build_wrapper_dir) os.makedirs(build_wrapper_dir) else: os.makedirs(build_wrapper_dir) # Build library if mt_already_built: print("[automate.py] Already built: libcef_dll_wrapper" " /{runtime_library} for VS{msvs}" .format(runtime_library=runtime_library, msvs=msvs)) else: print("[automate.py] Build libcef_dll_wrapper" " /{runtime_library} for VS{msvs}" .format(runtime_library=runtime_library, msvs=msvs)) # Run cmake old_gyp_msvs_version = Options.gyp_msvs_version Options.gyp_msvs_version = msvs if runtime_library == RUNTIME_MD: fix_cmake_variables_for_MD_library() env = getenv() if msvs == "2010": # When Using WinSDK 7.1 vcvarsall.bat doesn't work. Use # setuptools.msvc.msvc9_query_vcvarsall to query env vars. env.update(msvc9_query_vcvarsall(10.0, arch=VS_PLATFORM_ARG)) # On Python 2.7 env values returned by both distutils # and setuptools are unicode, but Python expects env # dict values as strings. for env_key in env: env_value = env[env_key] if type(env_value) != str: env[env_key] = env_value.encode("utf-8") run_command(cmake_wrapper, working_dir=build_wrapper_dir, env=env) Options.gyp_msvs_version = old_gyp_msvs_version if runtime_library == RUNTIME_MD: fix_cmake_variables_for_MD_library(undo=True) print("[automate.py] cmake OK") # Run ninja ninja_wrapper = prepare_build_command(build_lib=True, vcvars=vcvars) ninja_wrapper.extend(["ninja", "-j", Options.ninja_jobs, "libcef_dll_wrapper"]) run_command(ninja_wrapper, working_dir=build_wrapper_dir) print("[automate.py] ninja OK") assert os.path.exists(wrapper_lib) def fix_cmake_variables_permanently_windows(): """Changes to cef_variables.cmake are made permanently, there is no undo. """ # To get rid of these warnings: # > cl : Command line warning D9025 : overriding '/GR' with '/GR-' # > cl : Command line warning D9025 : overriding '/W3' with '/W4' # > cl : Command line warning D9025 : overriding '/MD' with '/MT' cmake_variables = os.path.join(Options.cef_binary, "cmake", "cef_variables.cmake") with open(cmake_variables, "rb") as fp: contents = fp.read().decode("utf-8") set1 = 'set(CMAKE_CXX_FLAGS_RELEASE "")' set2 = 'set(CMAKE_CXX_FLAGS "")' if "if(OS_WINDOWS)" not in contents: print("[automate.py] WARNING: failed to fix cmake variables" " permanently on Windows") return if set1 not in contents or set2 not in contents: contents = contents.replace("if(OS_WINDOWS)", "if(OS_WINDOWS)\n {set1}\n {set2}" .format(set1=set1, set2=set2)) else: return with open(cmake_variables, "wb") as fp: print("[automate.py] Fix permanently: {filename}" .format(filename=os.path.basename(cmake_variables))) fp.write(contents.encode("utf-8")) def fix_cmake_variables_for_MD_library(undo=False, try_undo=False): """Fix cmake variables or undo it. The try_undo param is for a case when want to be sure that the file wasn't modified, for example in case the last build failed.""" # Replace /MT with /MD /wd4275 in cef/cmake/cef_variables.cmake # Warnings are treated as errors so this needs to be ignored: # >> warning C4275: non dll-interface class 'stdext::exception' # >> used as base for dll-interface class 'std::bad_cast' # This warning occurs only in VS2008, in VS2013 not. # This replacements must be unique for the undo operation # to be reliable. mt_find = u'"/MT ' mt_replace = u'"/MD /wd4275 ' mtd_find = u'"/MTd ' mtd_replace = u'"/MDd /wd4275 ' cmake_variables = os.path.join(Options.cef_binary, "CMakeLists.txt") with open(cmake_variables, "rb") as fp: contents = fp.read().decode("utf-8") if try_undo: matches1 = re.findall(re.escape(mt_replace), contents) matches2 = re.findall(re.escape(mtd_replace), contents) if len(matches1) or len(matches2): undo = True else: return if undo: (contents, count) = re.subn(re.escape(mt_replace), mt_find, contents) assert count == 1 (contents, count) = re.subn(re.escape(mtd_replace), mtd_find, contents) assert count == 1 else: (contents, count) = re.subn(re.escape(mt_find), mt_replace, contents) assert count == 1 (contents, count) = re.subn(re.escape(mtd_find), mtd_replace, contents) assert count == 1 with open(cmake_variables, "wb") as fp: fp.write(contents.encode("utf-8")) def build_wrapper_library_mac(): # On Mac it is required to link libcef_dll_wrapper against # libc++ library, so must build this library separately # from cefclient. cmake_wrapper = prepare_build_command(build_lib=True) cmake_wrapper.extend(["cmake", "-G", "Ninja", "-DPROJECT_ARCH=x86_64", "-DCMAKE_CXX_FLAGS=-stdlib=libc++", "-DCMAKE_BUILD_TYPE=" + Options.build_type, ".."]) build_wrapper_dir = os.path.join(Options.cef_binary, "build_wrapper") wrapper_lib = os.path.join(build_wrapper_dir, "libcef_dll_wrapper", "libcef_dll_wrapper.a") # Check whether already built already_built = False if os.path.exists(wrapper_lib): already_built = True elif os.path.exists(build_wrapper_dir): # Last build failed, clean directory assert build_wrapper_dir shutil.rmtree(build_wrapper_dir) os.makedirs(build_wrapper_dir) else: os.makedirs(build_wrapper_dir) # Build libcef_dll_wrapper library if already_built: print("[automate.py] Already built: libcef_dll_wrapper") else: print("[automate.py] Build libcef_dll_wrapper") # Cmake run_command(cmake_wrapper, build_wrapper_dir) print("[automate.py] cmake OK") # Ninja ninja_wrapper = prepare_build_command(build_lib=True) ninja_wrapper.extend(["ninja", "-j", Options.ninja_jobs, "libcef_dll_wrapper"]) run_command(ninja_wrapper, build_wrapper_dir) print("[automate.py] ninja OK") assert os.path.exists(wrapper_lib) def prepare_build_command(build_lib=False, vcvars=None): """On Windows VS env variables must be set up by calling vcvarsall.bat""" command = list() if platform.system() == "Windows": if build_lib: if vcvars == VS2010_VCVARS: # When using WinSDK 7.1 vcvarsall.bat is broken. Instead # env variables are queried using setuptools.msvc. return command if vcvars: command.append(vcvars) else: command.append(get_vcvars_for_python()) command.append(VS_PLATFORM_ARG) else: if int(Options.cef_branch) >= 2704: command.append(VS2015_VCVARS) else: # Branch 2623 supports building with VS 2013, so you can # change it to 2013 below. command.append(VS2015_VCVARS) command.append(VS_PLATFORM_ARG) command.append("&&") return command def fix_cef_include_files(): """Fixes to CEF include header files for eg. VS2008 on Windows.""" # TODO: This was fixed in upstream CEF, remove this code during # next CEF update on Windows. if platform.system() == "Windows" and get_msvs_for_python() == "2008": print("[automate.py] Fixing CEF include/ files") # cef_types_wrappers.h cef_types_wrappers = os.path.join(Options.cef_binary, "include", "internal", "cef_types_wrappers.h") with open(cef_types_wrappers, "rb") as fp: contents = fp.read().decode("utf-8") # error C2059: syntax error : '{' contents = contents.replace("s->range = {0, 0};", "s->range.from = 0; s->range.to = 0;") with open(cef_types_wrappers, "wb") as fp: fp.write(contents.encode("utf-8")) def create_prebuilt_binaries(): """After building copy binaries/libs to build/cef_xxxx/. Not all projects may have been built on all platforms.""" # Directories src = Options.cef_binary version_header = os.path.join(src, "include", "cef_version.h") dst = get_prebuilt_name(version_header) dst = os.path.join(Options.build_dir, dst) rmdir(dst) os.makedirs(dst) bindir = os.path.join(dst, "bin") libdir = os.path.join(dst, "lib") os.makedirs(bindir) os.makedirs(libdir) # Copy Release/Debug and Resources cpdir(os.path.join(src, Options.build_type), bindir) if not MAC: cpdir(os.path.join(src, "Resources"), bindir) # Fix id in CEF framework on Mac (currently it expects Frameworks/ dir) if MAC: new_id = ("@rpath/Chromium Embedded Framework.framework" "/Chromium Embedded Framework") cef_framework_dir = os.path.join( bindir, "Chromium Embedded Framework.framework") cef_library = os.path.join( cef_framework_dir, "Chromium Embedded Framework") assert os.path.isdir(cef_framework_dir) run_command(["install_name_tool", "-id", new_id, cef_library], working_dir=cef_framework_dir) # Copy cefclient, cefsimple # cefclient cefclient = os.path.join( src, "build_cefclient", "cefclient", "cefclient" + APP_EXT) if LINUX and os.path.exists(cefclient): # On Windows resources/*.html files are embedded inside exe cefclient_files = os.path.join( src, "build_cefclient", "cefclient", "cefclient_files") cpdir(cefclient_files, os.path.join(bindir, "cefclient_files")) # cefsimple cefsimple = os.path.join( src, "build_cefclient", "cefsimple", "cefsimple" + APP_EXT) def copy_app(app): if os.path.exists(app): if os.path.isdir(app): # On Mac app is a directory shutil.copytree(app, os.path.join(bindir, os.path.basename(app))) else: shutil.copy(app, bindir) if not MAC: # Currently do not copy apps on Mac copy_app(cefclient) copy_app(cefsimple) # END: Copy cefclient, cefsimple # Copy libraries if platform.system() == "Windows": # libcef.lib and cef_sandbox.lib mvfiles(bindir, libdir, ".lib") python_compilers = get_available_python_compilers() for msvs in python_compilers: vs_subdir = os.path.join(libdir, "VS{msvs}".format(msvs=msvs)) os.makedirs(vs_subdir) # MT library libsrc = os.path.join( src, "build_wrapper_MT_VS{msvs}".format(msvs=msvs), "libcef_dll", "libcef_dll_wrapper.lib") libdst = os.path.join(vs_subdir, "libcef_dll_wrapper_MT.lib") shutil.copy(libsrc, libdst) # MD library libsrc = os.path.join( src, "build_wrapper_MD_VS{msvs}".format(msvs=msvs), "libcef_dll", "libcef_dll_wrapper.lib") libdst = os.path.join(vs_subdir, "libcef_dll_wrapper_MD.lib") shutil.copy(libsrc, libdst) elif platform.system() == "Darwin": shutil.copy(os.path.join(src, "build_wrapper", "libcef_dll_wrapper", "libcef_dll_wrapper.a"), libdir) else: # cefclient builds libcef_dll_wrapper by default and this version # is good for cefpython on Linux. On Windows and Mac # libcef_dll_wrapper is built seprately. shutil.copy(os.path.join(src, "build_cefclient", "libcef_dll_wrapper", "libcef_dll_wrapper.a"), libdir) # Remove .lib files from bin/ only after libraries were copied (Windows) libs = glob.glob(os.path.join(bindir, "*.lib")) for lib in libs: os.remove(lib) # Remove cef_sandbox.lib (huge file) cef_sandbox = os.path.join(libdir, "cef_sandbox.lib") if os.path.exists(cef_sandbox): os.remove(cef_sandbox) # Copy README.txt and LICENSE.txt shutil.copy(os.path.join(src, "README.txt"), dst) shutil.copy(os.path.join(src, "LICENSE.txt"), dst) # Copy cef_version_{os}.h cef_version_file = os.path.join(dst, "cef_version_{os_postfix}.h".format( os_postfix=OS_POSTFIX)) shutil.copy(os.path.join(src, "include", "cef_version.h"), cef_version_file) print("[automate.py] OK prebuilt binaries created in '%s/'" % dst) def get_available_python_compilers(): all_python_compilers = OrderedDict([ ("2008", VS2008_VCVARS), ("2010", VS2010_VCVARS), ]) ret_compilers = OrderedDict() for msvs in all_python_compilers: vcvars = all_python_compilers[msvs] if os.path.exists(vcvars): ret_compilers[msvs] = vcvars else: print("[automate.py] INFO: Visual Studio compiler not found:" " {vcvars}".format(vcvars=vcvars)) return ret_compilers def get_vcvars_for_python(): msvs = get_msvs_for_python() return globals()["VS"+msvs+"_VCVARS"] def getenv(): """Env variables passed to shell when running commands. See cef/AutomatedBuildSetup.md for reference.""" env = os.environ # PATH if Options.build_cef: if os.path.exists(Options.depot_tools_dir): env["PATH"] = Options.depot_tools_dir + os.pathsep + env["PATH"] # Generators: ninja, msvs env["GYP_GENERATORS"] = Options.gyp_generators # VS version if platform.system() == "Windows": env["GYP_MSVS_VERSION"] = Options.gyp_msvs_version # GN configuration env["CEF_USE_GN"] = "1" # Issue #73 patch applied here with "use_allocator=none" env["GN_DEFINES"] = "use_sysroot=true use_allocator=none symbol_level=1" # env["GN_DEFINES"] += " use_gtk3=false" # To perform an official build set GYP_DEFINES=buildtype=Official. # This will disable debugging code and enable additional link-time # optimizations in Release builds. if Options.release_build and not Options.fast_build: env["GN_DEFINES"] += " is_official_build=true" # GYP configuration is DEPRECATED, however it is still set in # upstream Linux configuration on AutomatedBuildSetup wiki page, # so setting it here as well. env["GYP_DEFINES"] = "disable_nacl=1 use_sysroot=1 use_allocator=none" if Options.x86: env["GYP_DEFINES"] += " host_arch=x86_64 target_arch=ia32" if Options.release_build and not Options.fast_build: env["GYP_DEFINES"] += " buildtype=Official" # Modifications to upstream automate-git.py introduced # CEFPYTHON_NINJA_JOBS env key. env["CEFPYTHON_NINJA_JOBS"] = str(Options.ninja_jobs) return env def run_command(command, working_dir, env=None): """Run command in a given directory with env variables set. On Linux multiple commands on one line with the use of && are not allowed. """ if isinstance(command, list): command_str = " ".join(command) else: command_str = command print("[automate.py] Running '"+command_str+"' in '" + working_dir+"'...") if isinstance(command, str): args = shlex.split(command.replace("\\", "\\\\")) else: args = command if not env: env = getenv() # When passing list of args shell cannot be True on eg. Linux, read # notes in build.py shell = (platform.system() == "Windows") return subprocess.check_call(args, cwd=working_dir, env=env, shell=shell) def run_git(command_line, working_dir): """Run git command using depot_tools.""" return run_command("git %s" % command_line, working_dir) def run_automate_git(): """Run CEF automate-git.py using Python 2.7.""" script = os.path.join(Options.cefpython_dir, "tools", "automate-git.py") """ Example automate-git.py command: C:\chromium>call python automate-git.py --download-dir=./test/ --branch=2526 --no-debug-build --verbose-build Run ninja build manually: cd chromium/src ninja -v -j2 -Cout\Release cefclient """ args = [] if ARCH64 and not Options.x86: args.append("--x64-build") args.append("--download-dir=" + Options.cef_build_dir) args.append("--branch=" + Options.cef_branch) if Options.release_build: args.append("--no-debug-build") args.append("--verbose-build") # --force-build sets --force-distrib by default # ninja will only recompile files that changed args.append("--force-build") # We clone cef repository ourselves and update cef patches with ours, # so don't fetch/update CEF repo. args.append("--no-cef-update") # Force Chromium update so that gclient sync is called. It may fail # sometimes with files missing and must re-run to fix. if Options.force_chromium_update: args.append("--force-update") args.append("--no-distrib-archive") if platform.system() == "Linux": # Building cefclient target isn't supported on Linux when # using sysroot (cef/#1916). However building cefclient # later in cef_binary/ with cmake/ninja do works fine. args.append("--build-target=cefsimple") # On Windows automate-git.py must be run using Python 2.7 # from depot_tools. depot_tools should already be added to PATH. python = "python" # *do not* replace with sys.executable! args = " ".join(args) command = script + " " + args working_dir = Options.cef_build_dir return run_command("%s %s" % (python, command), working_dir) def rmdir(path): """Delete directory recursively.""" if os.path.exists(path): print("[automate.py] Removing directory %s" % path) shutil.rmtree(path, onerror=onerror) def cpdir(src, dst): """An equivalent of linux 'cp -r src/* dst/'. """ names = os.listdir(src) if not os.path.exists(dst): os.makedirs(dst) for name in names: path = os.path.join(src, name) if os.path.isdir(path): dst_subdir = os.path.join(dst, name) shutil.copytree(path, dst_subdir) else: shutil.copy(path, dst) def mvfiles(src, dst, ext): """An equivalent of linux 'mv src/*.ext dst/'. """ names = os.listdir(src) if not os.path.exists(dst): os.makedirs(dst) for name in names: path = os.path.join(src, name) if os.path.isfile(path) and name.endswith(ext): shutil.copy(path, dst) def onerror(func, path, _): """Fix file permission on error and retry operation.""" if not os.access(path, os.W_OK): os.chmod(path, stat.S_IWUSR) func(path) else: raise Exception("Not a file permission error, dunno what to do") def get_prebuilt_name(header_file=""): if header_file: version = get_version_from_file(header_file) else: version = get_cefpython_version() postfix2 = OS_POSTFIX2 if Options.x86: postfix2 = get_os_postfix2_for_arch("32bit") name = "cef%s_%s_%s" % ( version["CHROME_VERSION_MAJOR"], version["CEF_VERSION"], postfix2 ) return name if __name__ == "__main__": main() cefpython-49.0/tools/build.py000066400000000000000000001012311334103266300162550ustar00rootroot00000000000000# Copyright (c) 2017 CEF Python, see the Authors file. # All rights reserved. Licensed under BSD 3-clause license. # Project website: https://github.com/cztomczak/cefpython """ Build the cefpython module, install package and run example. Before running you must first put cefpython ready CEF binaries and libraries in the cefpython/build/ directory (create if doesn't exist). You have two options for obtaining these binaries and libraries. Option 1: Download upstream CEF binaries and libraries from cefpython GitHub Releases page. These binaries are tagged eg. "v55-upstream". Extract the archive so that for example you have such a directory: cefpython/build/cef55_3.2883.1553.g80bd606_win32/ . Option 2: Use the automate.py tool. With this tool you can build CEF from sources or use ready binaries from Spotify Automated Builds. Usage: build.py VERSION [--rebuild-cpp] [--fast] [--clean] [--kivy] [--hello-world] Options: VERSION Version number eg. 50.0 --no-run-examples Do not run examples after build, only unit tests --fast Fast mode --clean Clean C++ projects build files on Linux/Mac --kivy Run only Kivy example --hello-world Run only Hello World example """ # --rebuild-cpp Force rebuild of .vcproj C++ projects (DISABLED) # NOTE: When passing string command to subprocess functions you must # always use shell=True, otherwise on Linux error is thrown: # "No such file or directory". Always pass string commands to # subprocess functions with shell=True. If you pass a list of # arguments instead, then on Linux a "Segmentation fault" error # message is not shown. When passing a list of args to subprocess # function then you can't pass shell=True on Linux. If you pass # then it will execute args[0] and ignore others args. # NOTE 2: When calling os.system() returned value may be 256 when eg. # when running unit tests fail. If you pass 256 to sys.exit # an undefined result will occur. In my case on Linux it caused # that other script that called it sys.exit(256) was interpreted # for the script execute successfully. So never pass to sys.exit # a value returned from os.system. Check the value and call # sys.exit(1). # How to debug on Linux (OLD unsupported). # 1. Install "python-dbg" package # 2. Install "python-wxgtk2.8-dbg" package # 3. Run "python compile.py debug" # 4. In cygdb type "cy run" # 5. To display debug backtrace type "cy bt" # 6. More commands: http://docs.cython.org/src/userguide/debugging.html from common import * import sys import os import glob import shutil import subprocess import re # raw_input() was renamed to input() in Python 3 try: # noinspection PyUnresolvedReferences # noinspection PyShadowingBuiltins input = raw_input except NameError: pass # Command line args variables VERSION = "" NO_RUN_EXAMPLES = False DEBUG_FLAG = False FAST_FLAG = False CLEAN_FLAG = False KIVY_FLAG = False HELLO_WORLD_FLAG = False REBUILD_CPP = False # First run FIRST_RUN = False def main(): command_line_args() print("[build.py] Python version: {ver} {arch}" .format(ver=platform.python_version(), arch=ARCH_STR)) print("[build.py] Python executable: %s" % sys.executable) print("[build.py] PYVERSION = %s" % PYVERSION) print("[build.py] OS_POSTFIX2 = %s" % OS_POSTFIX2) check_cython_version() check_directories() setup_environ() if os.path.exists(CEFPYTHON_API_HFILE): fix_cefpython_api_header_file() if WINDOWS: compile_cpp_projects_with_setuptools() elif MAC or LINUX: compile_cpp_projects_unix() else: print("[build.py] INFO: Looks like first run, as" " cefpython_py{pyver}.h is missing. Skip building" " C++ projects." .format(pyver=PYVERSION)) global FIRST_RUN FIRST_RUN = True clear_cache() copy_and_fix_pyx_files() build_cefpython_module() fix_cefpython_api_header_file() install_and_run() def command_line_args(): global DEBUG_FLAG, FAST_FLAG, CLEAN_FLAG, KIVY_FLAG, HELLO_WORLD_FLAG, \ REBUILD_CPP, VERSION, NO_RUN_EXAMPLES VERSION = get_version_from_command_line_args(__file__) if not VERSION: print(__doc__) sys.exit(1) print("[build.py] Parse command line arguments") # --no-run-examples if "--no-run-examples" in sys.argv: NO_RUN_EXAMPLES = True print("[build.py] Running examples disabled (--no-run-examples)") # -- debug if "--debug" in sys.argv: DEBUG_FLAG = True print("[build.py] DEBUG mode On") # --fast if "--fast" in sys.argv: # Fast mode doesn't delete C++ .o .a files. # Fast mode also disables optimization flags in setup/setup.py . FAST_FLAG = True print("[build.py] FAST mode On") # --clean if "--clean" in sys.argv: CLEAN_FLAG = True # --kivy if "--kivy" in sys.argv: KIVY_FLAG = True print("[build.py] KIVY example") # --kivy if "--hello-world" in sys.argv: HELLO_WORLD_FLAG = True print("[build.py] HELLO WORLD example") # --rebuild-cpp # Rebuild c++ projects if "--rebuild-cpp" in sys.argv: REBUILD_CPP = True print("[build.py] REBUILD_CPP mode enabled") print("[build.py] VERSION=%s" % VERSION) def check_cython_version(): print("[build.py] Check Cython version") with open(os.path.join(TOOLS_DIR, "requirements.txt"), "rb") as fileobj: contents = fileobj.read().decode("utf-8") match = re.search(r"cython\s*==\s*([\d.]+)", contents, flags=re.IGNORECASE) assert match, "cython package not found in requirements.txt" require_version = match.group(1) try: import Cython version = Cython.__version__ except ImportError: # noinspection PyUnusedLocal Cython = None print("[build.py] ERROR: Cython is not installed ({0} required)" .format(require_version)) sys.exit(1) if version != require_version: print("[build.py] ERROR: Wrong Cython version: {0}. Required: {1}" .format(version, require_version)) sys.exit(1) print("[build.py] Cython version: {0}".format(version)) def check_directories(): print("[build.py] Check directories") # Create directories if necessary if not os.path.exists(CEFPYTHON_BINARY): os.makedirs(CEFPYTHON_BINARY) if not os.path.exists(BUILD_CEFPYTHON): os.makedirs(BUILD_CEFPYTHON) # Info if directory missing if not os.path.exists(CEF_BINARIES_LIBRARIES): prebuilt_name = get_cef_binaries_libraries_basename(OS_POSTFIX2) print("[build.py] ERROR: Couldn't find CEF prebuilt binaries and" " libraries: 'build/{prebuilt_dir}/'. Download it" " from GitHub released tagged eg. 'v50-upstream` or download" " CEF binaries from Spotify Automated Builds and then run" "`automate.py --prebuilt-cef`." .format(prebuilt_dir=prebuilt_name)) sys.exit(1) # Check directories exist assert os.path.exists(BUILD_DIR) assert os.path.exists(BUILD_CEFPYTHON) assert os.path.exists(CEF_BINARIES_LIBRARIES) assert os.path.exists(CEFPYTHON_BINARY) def setup_environ(): """Set environment variables. Set PATH so that it contains only minimum set of directories,to avoid any possible issues. Set Python include path. Set Mac compiler options. Etc.""" print("[build.py] Setup environment variables") # PATH if WINDOWS: path = [ "C:\\Windows\\system32", "C:\\Windows", "C:\\Windows\\System32\\Wbem", get_python_path(), ] os.environ["PATH"] = os.pathsep.join(path) print("[build.py] environ PATH: {path}" .format(path=os.environ["PATH"])) # INCLUDE env for vcproj build if WINDOWS: if "INCLUDE" not in os.environ: os.environ["INCLUDE"] = "" os.environ["INCLUDE"] += os.pathsep + get_python_include_path() print("[build.py] environ INCLUDE: {include}" .format(include=os.environ["INCLUDE"])) # LIB env for vcproj build if WINDOWS: os.environ["AdditionalLibraryDirectories"] = os.path.join( CEF_BINARIES_LIBRARIES, "lib") print("[build.py] environ AdditionalLibraryDirectories: {lib}" .format(lib=os.environ["AdditionalLibraryDirectories"])) if LINUX or MAC: # Env variables for makefiles os.environ["PYTHON_INCLUDE"] = get_python_include_path() print("[build.py] PYTHON_INCLUDE: {python_include}" .format(python_include=os.environ["PYTHON_INCLUDE"])) os.environ["CEF_CCFLAGS"] = "-std=gnu++11 -DNDEBUG -Wall -Werror" if FAST_FLAG: os.environ["CEF_CCFLAGS"] += " -O0" else: os.environ["CEF_CCFLAGS"] += " -O3" os.environ["CEF_LINK_FLAGS"] = "" os.environ["CEF_BIN"] = os.path.join(CEF_BINARIES_LIBRARIES, "bin") os.environ["CEF_LIB"] = os.path.join(CEF_BINARIES_LIBRARIES, "lib") if LINUX: # TODO: Set CEF_CCFLAGS and CEF_LINK_FLAGS according to what is # in upstream cefclient, see cef/cmake/cef_variables.cmake. pass # Mac compiler options if MAC: os.environ["PATH"] = "/usr/local/bin:"+os.environ["PATH"] os.environ["CC"] = "c++" os.environ["CXX"] = "c++" if ARCH32: raise Exception("Python 32-bit is not supported on Mac") os.environ["ARCHFLAGS"] = "-arch x86_64" os.environ["CEF_CCFLAGS"] += " -arch x86_64" os.environ["CEF_LINK_FLAGS"] += " -mmacosx-version-min=10.9" # -Wno-return-type-c-linkage to ignore: # > warning: 'somefunc' has C-linkage specified, but returns # > user-defined type 'sometype' which is incompatible with C os.environ["CEF_CCFLAGS"] += " -Wno-return-type-c-linkage" # Compile against libc++ otherwise error "symbol not found" # with cef::logging::LogMessage symbol. Also include -lc++ # and -lc++abi libraries. os.environ["CEF_CCFLAGS"] += " -stdlib=libc++" # See compile/link flags in upstream cefclient os.environ["CEF_CCFLAGS"] += ( " -fno-strict-aliasing" " -fno-rtti" " -fno-threadsafe-statics" " -fobjc-call-cxx-cdtors" " -fvisibility=hidden" " -fvisibility-inlines-hidden" ) os.environ["CEF_LINK_FLAGS"] += ( " -lc++" " -lc++abi" " -Wl,-search_paths_first" " -Wl,-ObjC" " -Wl,-pie" " -Wl,-dead_strip" ) def fix_cefpython_api_header_file(): """This function does two things: 1) Disable warnings in cefpython API header file and 2) Make a copy named cefpython_pyXX_fixed.h, this copy will be used by C++ projects and its modification time won't change every time you run build.py script, thus C++ won't rebuild each time.""" # Fix cefpython_pyXX.h to disable this warning: # > warning: 'somefunc' has C-linkage specified, but returns # > user-defined type 'sometype' which is incompatible with C # On Mac this warning must be disabled using -Wno-return-type-c-linkage # flag in makefiles. print("[build.py] Fix cefpython API header file in the build_cefpython/" " directory") if not os.path.exists(CEFPYTHON_API_HFILE): assert not os.path.exists(CEFPYTHON_API_HFILE_FIXED) print("[build.py] cefpython API header file was not yet generated") return # Original contents with open(CEFPYTHON_API_HFILE, "rb") as fo: contents = fo.read().decode("utf-8") # Pragma fix on Windows if WINDOWS: pragma = "#pragma warning(disable:4190)" if pragma in contents: print("[build.py] cefpython API header file is already fixed") else: contents = ("%s\n\n" % pragma) + contents with open(CEFPYTHON_API_HFILE, "wb") as fo: fo.write(contents.encode("utf-8")) print("[build.py] Save {filename}" .format(filename=CEFPYTHON_API_HFILE)) # Make a copy with a "_fixed" postfix if os.path.exists(CEFPYTHON_API_HFILE_FIXED): with open(CEFPYTHON_API_HFILE_FIXED, "rb") as fo: contents_fixed = fo.read().decode("utf-8") else: contents_fixed = "" # Resave fixed copy only if contents changed. Other scripts # depend on "modified time" of the "_fixed" file. if contents != contents_fixed: print("[build.py] Save cefpython_fixed.h") with open(CEFPYTHON_API_HFILE_FIXED, "wb") as fo: fo.write(contents.encode("utf-8")) def compile_cpp_projects_with_setuptools(): """Use setuptools to build static libraries / executable.""" compile_cpp_projects = os.path.join(TOOLS_DIR, "build_cpp_projects.py") retcode = subprocess.call([sys.executable, compile_cpp_projects]) if retcode != 0: print("[build.py] ERROR: Failed to compile C++ projects") sys.exit(1) # Copy subprocess executable print("[build.py] Copy subprocess executable") shutil.copy(SUBPROCESS_EXE, CEFPYTHON_BINARY) def compile_cpp_projects_windows_DEPRECATED(): """DEPRECATED. Not used currently. Build C++ projects using .vcproj files.""" # TODO: Remove code after setuptools compilation was tested for some time print("[build.py] Compile C++ projects") print("[build.py] ~~ Build CLIENT_HANDLER vcproj") vcproj = ("client_handler_py{pyver}_{os}.vcproj" .format(pyver=PYVERSION, os=OS_POSTFIX2)) vcproj = os.path.join(SRC_DIR, "client_handler", vcproj) build_vcproj_DEPRECATED(vcproj) print("[build.py] ~~ Build LIBCEFPYTHONAPP vcproj") vcproj = ("libcefpythonapp_py{pyver}_{os}.vcproj" .format(pyver=PYVERSION, os=OS_POSTFIX2)) vcproj = os.path.join(SRC_DIR, "subprocess", vcproj) build_vcproj_DEPRECATED(vcproj) print("[build.py] ~~ Build SUBPROCESS vcproj") vcproj = ("subprocess_{os}.vcproj" .format(os=OS_POSTFIX2)) vcproj = os.path.join(SRC_DIR, "subprocess", vcproj) ret = build_vcproj_DEPRECATED(vcproj) # Copy subprocess executable subprocess_from = os.path.join( SUBPROCESS_DIR, "Release_{os}".format(os=OS_POSTFIX2), "subprocess_{os}.exe".format(os=OS_POSTFIX2)) subprocess_to = os.path.join(CEFPYTHON_BINARY, "subprocess.exe") if os.path.exists(subprocess_to): os.remove(subprocess_to) if ret == 0: print("[build.py] Copy subprocess executable") # shutil.copy() will also copy Permission bits shutil.copy(subprocess_from, subprocess_to) print("[build.py] ~~ Build CPP_UTILS vcproj") vcproj = ("cpp_utils_{os}.vcproj" .format(os=OS_POSTFIX2)) vcproj = os.path.join(SRC_DIR, "cpp_utils", vcproj) build_vcproj_DEPRECATED(vcproj) def build_vcproj_DEPRECATED(vcproj): """DEPRECATED. Not used currently.""" # TODO: Remove code after setuptools compilation was tested for some time # In VS2010 vcbuild.exe was replaced by msbuild.exe. # Ufortunately WinSDK 7.1 does not come with msbuild.exe, # so it would be required to install Visual Studio 2010, # and to support both 32-bit ad 64-bit compilations it # a non-express version would have to be installed, which # is not free. So to make it free open-source it was # required migrate to a new compilation system that uses # distutils/setuptools packages. # msbuild.exe flags: # /clp:disableconsolecolor # msbuild /p:BuildProjectReferences=false project.proj # MSBuild.exe MyProject.proj /t:build if PYVERSION == "27": args = list() args.append(VS2008_VCVARS) args.append(VS_PLATFORM_ARG) args.append("&&") args.append(VS2008_BUILD) args.append("/nocolor") args.append("/nologo") args.append("/nohtmllog") if REBUILD_CPP: args.append("/rebuild") args.append(vcproj) ret = subprocess.call(args, shell=True) if ret != 0: compile_ask_to_continue() return ret else: raise Exception("Only Python 2.7 32-bit is currently supported") def compile_ask_to_continue(): # noinspection PyUnboundLocalVariable what = input("[build.py] make failed, 'y' to continue, Enter to stop: ") if what != "y": sys.exit(1) def clean_cpp_projects_unix(): delete_files_by_pattern("{0}/*.o".format(CLIENT_HANDLER_DIR)) delete_files_by_pattern("{0}/*.a".format(CLIENT_HANDLER_DIR)) delete_files_by_pattern("{0}/*.o".format(SUBPROCESS_DIR)) delete_files_by_pattern("{0}/*.a".format(SUBPROCESS_DIR)) delete_files_by_pattern("{0}/subprocess".format(SUBPROCESS_DIR)) delete_files_by_pattern("{0}/*.o".format(CPP_UTILS_DIR)) delete_files_by_pattern("{0}/*.a".format(CPP_UTILS_DIR)) def compile_cpp_projects_unix(): print("[build.py] Compile C++ projects") if CLEAN_FLAG: print("[build.py] Clean C++ projects (--clean flag passed)") clean_cpp_projects_unix() # Need to allow continuing even when make fails, as it may # fail because the "public" function declaration is not yet # in cefpython API header file, but for it to be generated we need # to run cython compiling, so in this case you continue even when # make fails and then run the compile.py script again and this time # make should succeed. # -- CLIENT_HANDLER print("[build.py] ~~ Build CLIENT_HANDLER project") os.chdir(CLIENT_HANDLER_DIR) if not FAST_FLAG: subprocess.call("rm -f *.o *.a", shell=True) ret = subprocess.call("make -f Makefile", shell=True) if ret != 0: compile_ask_to_continue() # -- LIBCEFPYTHONAPP print("[build.py] ~~ Build LIBCEFPYTHONAPP project") os.chdir(SUBPROCESS_DIR) if not FAST_FLAG: subprocess.call("rm -f *.o *.a", shell=True) subprocess.call("rm -f subprocess", shell=True) ret = subprocess.call("make -f Makefile-libcefpythonapp", shell=True) if ret != 0: compile_ask_to_continue() # -- SUBPROCESS print("[build.py] ~~ Build SUBPROCESS project") ret = subprocess.call("make -f Makefile", shell=True) if ret != 0: compile_ask_to_continue() # Copy subprocess executable subprocess_from = os.path.join(SUBPROCESS_DIR, "subprocess") subprocess_to = os.path.join(CEFPYTHON_BINARY, "subprocess") if os.path.exists(subprocess_from): # shutil.copy() will also copy Permission bits shutil.copy(subprocess_from, subprocess_to) # -- CPP_UTILS print("[build.py] ~~ Build CPP_UTILS project") os.chdir(CPP_UTILS_DIR) if not FAST_FLAG: subprocess.call("rm -f *.o *.a", shell=True) ret = subprocess.call("make -f Makefile", shell=True) if ret != 0: compile_ask_to_continue() def clear_cache(): print("[build.py] Clean build cache") # Cache in CEFPYTHON_BINARY directory (eg. cefpython_linux64/) os.chdir(CEFPYTHON_BINARY) delete_files_by_pattern("./"+MODULE_NAME_TEMPLATE .format(pyversion=PYVERSION, ext=MODULE_EXT)) # Cache in build_cefpython/ directory os.chdir(BUILD_CEFPYTHON) delete_files_by_pattern("./"+MODULE_NAME_TEMPLATE .format(pyversion=PYVERSION, ext=MODULE_EXT)) delete_files_by_pattern("./*.pyx") try: if not FAST_FLAG: # Cython's internal build/ directory shutil.rmtree(os.path.join(BUILD_CEFPYTHON, "build")) except OSError: pass def copy_and_fix_pyx_files(): print("[build.py] Copy and fix pyx files") # First, it copies all .pyx files from upper directory to setup/. # Then, fixes repeating of "include" statements in pyx files. # Only the mainfile needs to have "include" statements, # but we're using PyCharm and to get rid of "unresolved references" # and other errors displayed in pycharm we are adding "include" # statements in all of the pyx files. # I'm not 100% sure how includes work in Cython, but I suspect that # a few includes of the same file will include the same content more # than once, it should work, but function and variable definitions are # duplicated, it is some kind of overhead and it could lead to some # problems in the future, better to fix it now. # It also checks cdef & cpdef functions whether they are not missing # "except *", it is required to add it when returning non-python type. os.chdir(BUILD_CEFPYTHON) print("\n") mainfile_original = "cefpython.pyx" mainfile_newname = "cefpython_py{pyver}.pyx".format(pyver=PYVERSION) pyxfiles = glob.glob("../../src/*.pyx") if not len(pyxfiles): print("[build.py] ERROR: no .pyx files found in root") sys.exit(1) pyxfiles = [f for f in pyxfiles if f.find(mainfile_original) == -1] # Now, pyxfiles contains all pyx files except mainfile_original # (cefpython.pyx), we do not fix includes in mainfile. pyxfiles2 = glob.glob("../../src/handlers/*.pyx") if not len(pyxfiles2): print("[build.py] ERROR: no .pyx files found in handlers/") sys.exit(1) pyxfiles = pyxfiles + pyxfiles2 # Remove old pyx files oldpyxfiles = glob.glob("./*.pyx") print("[build.py] Clean pyx files in build_cefpython/") for pyxfile in oldpyxfiles: if os.path.exists(pyxfile): os.remove(pyxfile) # Copying pyxfiles and reading its contents. print("[build.py] Copy pyx files to build_cefpython/") # Copy cefpython.pyx and fix includes in cefpython.pyx, eg.: # include "handlers/focus_handler.pyx" becomes include "focus_handler.pyx" shutil.copy("../../src/%s" % mainfile_original, "./%s" % mainfile_newname) with open("./%s" % mainfile_newname, "rb") as fo: content = fo.read().decode("utf-8") (content, subs) = re.subn(r"^include \"handlers/", "include \"", content, flags=re.MULTILINE) # Add __version__ variable in cefpython.pyx print("[build.py] Add __version__ variable to %s" % mainfile_newname) content = generate_cefpython_module_variables() + content with open("./%s" % mainfile_newname, "wb") as fo: fo.write(content.encode("utf-8")) print("[build.py] Fix %s includes in %s" % (subs, mainfile_newname)) # Copy the rest of the files print("[build.py] Fix includes in other .pyx files") for pyxfile in pyxfiles: newfile = "./%s" % os.path.basename(pyxfile) shutil.copy(pyxfile, newfile) pyxfile = newfile with open(pyxfile, "rb") as pyxfileopened: content = pyxfileopened.read().decode("utf-8") lineNumber = except_all_missing(content) if lineNumber: print("[build.py] WARNING: 'except *' missing" " in a cdef/cpdef function," " in file %s on line %d" % (os.path.basename(pyxfile), lineNumber)) sys.exit(1) # Do not remove the newline - so that line numbers # are exact with originals. (content, subs) = re.subn( r"^include[\t ]+[\"'][^\"'\n\r]+[\"'][\t ]*", "", content, flags=re.MULTILINE) if subs: # print("[build.py] %s includes removed in: %s" # % (subs, os.path.basename(pyxfile))) pass with open(pyxfile, "wb") as pyxfileopened: pyxfileopened.write(content.encode("utf-8")) print("\n") def generate_cefpython_module_variables(): """Global variables that will be appended to cefpython.pyx sources.""" ret = ('__version__ = "{0}"\n'.format(VERSION)) version = get_cefpython_version() chrome_version = "{0}.{1}.{2}.{3}".format( version["CHROME_VERSION_MAJOR"], version["CHROME_VERSION_MINOR"], version["CHROME_VERSION_BUILD"], version["CHROME_VERSION_PATCH"]) ret += ('__chrome_version__ = "{0}"\n'.format(chrome_version)) ret += ('__cef_version__ = "{0}"\n'.format(version["CEF_VERSION"])) ret += ('__cef_api_hash_platform__ = "{0}"\n' .format(version["CEF_API_HASH_PLATFORM"])) ret += ('__cef_api_hash_universal__ = "{0}"\n' .format(version["CEF_API_HASH_UNIVERSAL"])) ret += ('__cef_commit_hash__ = "{0}"\n' .format(version["CEF_COMMIT_HASH"])) ret += ('__cef_commit_number__ = "{0}"\n' .format(version["CEF_COMMIT_NUMBER"])) return ret def except_all_missing(content): # This is not perfect, won't detect C++ custom types, but will find # the built-in types, templates and pointers. patterns = list() patterns.append( r"\bcp?def\s+" "((int|short|long|double|char|unsigned|float|double|cpp_bool" "|cpp_string|cpp_wstring|uintptr_t|void" "|int32|uint32|int64|uint64" "|int32_t|uint32_t|int64_t|uint64_t" "|CefString)\s+)+" "\w+\([^)]*\)\s*(with\s+(gil|nogil))?\s*:") patterns.append( r"\bcp?def\s+" # A template ends with bracket: CefRefPtr[CefBrowser] # or a pointer ends with asterisk: CefBrowser* "[^\s]+[\]*]\s+" "\w+\([^)]*\)\s*(with\s+(gil|nogil))?\s*:") patterns.append( r"\bcp?def\s+" # A reference, eg. CefString& "[^\s]+&\s+" "\w+\([^)]*\)\s*(with\s+(gil|nogil))?\s*:") match = None for pattern in patterns: match = re.search(pattern, content) if match: break if match: lineNumber = (content.count("\n", 0, match.start()) + 1) return lineNumber def build_cefpython_module(): # if DEBUG_FLAG: # ret = subprocess.call("python-dbg setup.py build_ext --inplace" # " --cython-gdb", shell=True) print("[build.py] Execute cython_setup.py script") print("") os.chdir(BUILD_CEFPYTHON) command = ("\"{python}\" {tools_dir}/cython_setup.py build_ext" .format(python=sys.executable, tools_dir=TOOLS_DIR)) if FAST_FLAG: command += " --fast" ret = subprocess.call(command, shell=True) # if DEBUG_FLAG: # shutil.rmtree("./../binaries_%s/cython_debug/" % BITS, # ignore_errors=True) # shutil.copytree("./cython_debug/", # "./../binaries_%s/cython_debug/" % BITS) # Remove .pyx files oldpyxfiles = glob.glob("./*.pyx") print("") print("[build.py] Cleanup: remove pyx files in build_cefpython/") for pyxfile in oldpyxfiles: if os.path.exists(pyxfile): os.remove(pyxfile) # Check if built succeeded after pyx files were removed if ret != 0: if FIRST_RUN and os.path.exists(CEFPYTHON_API_HFILE): print("[build.py] INFO: looks like this was first run and" " building the cefpython module is expected to fail" " in such case due to cefpython API header file not" " being generated yet. Will re-run the build.py script" " programmatically now.") args = list() args.append("\"{python}\"".format(python=sys.executable)) args.append(os.path.join(TOOLS_DIR, os.path.basename(__file__))) assert __file__ in sys.argv[0] args.extend(sys.argv[1:]) command = " ".join(args) ret = subprocess.call(command, shell=True) # Always pass fixed value to sys.exit, read note at # the top of the script about os.system and sys.exit # issue. sys.exit(0 if ret == 0 else 1) else: print("[build.py] ERROR: failed to build the cefpython module") sys.exit(1) # Move the cefpython module module_pattern = MODULE_NAME_TEMPLATE.format(pyversion=PYVERSION+"*", ext=MODULE_EXT) module_pattern = "./build/lib*/" + module_pattern move_file_by_pattern(module_pattern, os.path.join(CEFPYTHON_BINARY, MODULE_NAME)) print("[build.py] DONE building the cefpython module") def move_file_by_pattern(pattern, move_to): assert len(pattern) > 2 print("[build.py] Move file: {pattern} to {move_to}" .format(pattern=pattern, move_to=move_to)) files = glob.glob(pattern) assert(len(files) == 1) os.rename(files[0], move_to) def delete_files_by_pattern(pattern): assert len(pattern) > 2 print("[build.py] Delete files by pattern: {pattern}" .format(pattern=pattern)) files = glob.glob(pattern) for f in files: os.remove(f) print("[build.py] Removed {0} files".format(len(files))) def delete_directories_by_pattern(pattern): assert len(pattern) > 2 print("[build.py] Delete directories by pattern: {pattern}" .format(pattern=pattern)) paths = glob.glob(pattern) for path in paths: if os.path.isdir(path): shutil.rmtree(path) def install_and_run(): # if DEBUG_FLAG: # os.chdir("./binaries_%s" % BITS) # subprocess.call("cygdb . --args python-dbg wxpython.py", shell=True) print("[build.py] Install and run...") os.chdir(BUILD_DIR) # Setup installer directory setup_basename = get_setup_installer_basename(VERSION, OS_POSTFIX2) setup_installer_dir = os.path.join(BUILD_DIR, setup_basename) # Delete setup installer directory if exists if os.path.exists(setup_installer_dir): delete_directory_reliably(setup_installer_dir) # Make setup installer print("[build.py] Make setup installer") make_tool = os.path.join(TOOLS_DIR, "make_installer.py") command = ("\"{python}\" {make_tool} --version {version}" .format(python=sys.executable, make_tool=make_tool, version=VERSION)) ret = os.system(command) if ret != 0: print("[build.py] ERROR while making installer package") sys.exit(1) # Install print("[build.py] Install the cefpython package") os.chdir(setup_installer_dir) command = ("\"{python}\" setup.py install" .format(python=sys.executable)) command = sudo_command(command, python=sys.executable) ret = os.system(command) if ret != 0: print("[build.py] ERROR while installing package") sys.exit(1) os.chdir(BUILD_DIR) # Delete setup installer directory after the package was installed delete_directory_reliably(setup_installer_dir) # Run unittests print("[build.py] Run unittests") test_runner = os.path.join(UNITTESTS_DIR, "_test_runner.py") command = ("\"{python}\" {test_runner}" .format(python=sys.executable, test_runner=test_runner)) ret = os.system(command) if ret != 0: print("[build.py] ERROR while running unit tests") sys.exit(1) # Run examples if not NO_RUN_EXAMPLES: print("[build.py] Run examples") os.chdir(EXAMPLES_DIR) flags = "" if KIVY_FLAG: flags += " --kivy" if HELLO_WORLD_FLAG: flags += " --hello-world" run_examples = os.path.join(TOOLS_DIR, "run_examples.py") command = ("\"{python}\" {run_examples} {flags}" .format(python=sys.executable, run_examples=run_examples, flags=flags)) ret = os.system(command) if ret != 0: print("[build.py] ERROR while running examples") sys.exit(1) print("[build.py] Everything OK") def delete_directory_reliably(adir): assert len(adir) > 2 assert os.path.isdir(adir) print("[build.py] Delete directory: {dir}" .format(dir=adir.replace(ROOT_DIR, ""))) if WINDOWS: # rmtree is vulnerable to race conditions. Sometimes # deleting directory fails with error: # >> OSError: [WinError 145] The directory is not empty: # >> 'C:\\github\\cefpython\\build\\cefpython3_56.2_win64\\build\\ # >> lib\\cefpython3' shutil.rmtree(adir, ignore_errors=True) else: # On Linux sudo might be required to delete directory, as this # might be a setup installer directory with package installed # using sudo and in such case files were created with sudo. command = "rm -rf {dir}".format(dir=adir) command = sudo_command(command, python=sys.executable) os.system(command) if __name__ == "__main__": main() cefpython-49.0/tools/build_cpp_projects.py000066400000000000000000000267721334103266300210500ustar00rootroot00000000000000# Copyright (c) 2017 CEF Python, see the Authors file. # All rights reserved. Licensed under BSD 3-clause license. # Project website: https://github.com/cztomczak/cefpython """Called by build.py internally. Builds C++ projects using distutils/setuptools compilers. This tool is executed by build.py on Windows only currently. Output directories are in build/build_cefpython/. Usage: build_cpp_projects.py [--force] TODO: Linux/Mac support, see makefiles, add include dirs using compiler.add_include_dir, compiler/linker flags, refactor macros. """ # import setuptools so that distutils msvc compiler is patched # noinspection PyUnresolvedReferences import setuptools from distutils.ccompiler import new_compiler from common import * import shutil from pprint import pprint # Macros MACROS = [ "WIN32", "_WIN32", "_WINDOWS", # Windows 7+ minimum supported ("NTDDI_VERSION", "0x06010000"), ("WINVER", "0x0601"), ("_WIN32_WINNT", "0x0601"), "NDEBUG", "_NDEBUG", "_CRT_SECURE_NO_WARNINGS", ] cefpython_app_MACROS = MACROS + [ "BROWSER_PROCESS", ] subprocess_MACROS = MACROS + [ "RENDERER_PROCESS", "UNICODE", "_UNICODE", "NOMINMAX", "WIN32_LEAN_AND_MEAN", ("_HAS_EXCEPTIONS", "0"), ] # Compiler args COMPILER_ARGS = [ "/EHsc", ] subprocess_COMPILER_ARGS = [ "/MT", ] # Linker args subprocess_LINKER_ARGS = [ "/MANIFEST:NO", "/LARGEADDRESSAWARE", ] # Command line args FORCE_FLAG = False def main(): command_line_args() clean_build_directories_if_forced() print_compiler_options() build_cefpython_app_library() build_library(lib_name="client_handler", macros=MACROS, sources_dir=CLIENT_HANDLER_DIR, output_dir=BUILD_CLIENT_HANDLER) build_library(lib_name="cpp_utils", macros=MACROS, sources_dir=CPP_UTILS_DIR, output_dir=BUILD_CPP_UTILS) build_subprocess_executable() print("[build_cpp_projects.py] Done building C++ projects") def command_line_args(): global FORCE_FLAG if "--force" in sys.argv: FORCE_FLAG = True def clean_build_directories_if_forced(): build_dirs = [BUILD_CEFPYTHON_APP, BUILD_CLIENT_HANDLER, BUILD_CPP_UTILS, BUILD_SUBPROCESS] if FORCE_FLAG: print("[build_cpp_projects.py] Clean C++ projects build directories") for bdir in build_dirs: if os.path.isdir(bdir): shutil.rmtree(bdir) def print_compiler_options(): compiler = get_compiler() print("[build_cpp.projects] Shared macros:") pprint(MACROS, indent=3, width=160) print("[build_cpp.projects] cefpython_app library macros:") pprint(cefpython_app_MACROS, indent=3, width=160) print("[build_cpp.projects] subprocess executable macros:") pprint(subprocess_MACROS, indent=3, width=160) print("[build_cpp.projects] Compiler options:") pprint(vars(compiler), indent=3, width=160) def get_compiler(static=False): # NOTES: # - VS2008 and VS2010 are both using distutils/msvc9compiler.py compiler = new_compiler() # Must initialize so that "compile_options" and others are available compiler.initialize() if static: compiler.compile_options.remove("/MD") # Overwrite function that adds /MANIFESTFILE, as for subprocess # manifest is disabled. Otherwise warning LNK4075 is generated. if hasattr(compiler, "manifest_setup_ldargs"): compiler.manifest_setup_ldargs = lambda *_: None return compiler def build_library(lib_name, macros, output_dir, sources=None, sources_dir=None): assert bool(sources_dir) ^ bool(sources) # xor print("[build_cpp_projects.py] Build library: {lib_name}" .format(lib_name=lib_name)) compiler = get_compiler() if not os.path.exists(output_dir): os.makedirs(output_dir) if sources_dir: assert not sources sources = get_sources(sources_dir) (changed, objects) = smart_compile(compiler, macros=macros, extra_args=COMPILER_ARGS, sources=sources, output_dir=output_dir) lib_path = os.path.join(output_dir, lib_name + LIB_EXT) if changed or not os.path.exists(lib_path): compiler.create_static_lib(objects, lib_name, output_dir=output_dir) print("[build_cpp_projects.py] Created library: {lib_name}" .format(lib_name=lib_name)) else: print("[build_cpp_projects.py] Library is up-to-date: {lib_name}" .format(lib_name=lib_name)) def build_cefpython_app_library(): sources = get_sources(SUBPROCESS_DIR, exclude_names=["main.cpp"]) build_library(lib_name="cefpython_app", macros=cefpython_app_MACROS, sources=sources, output_dir=BUILD_CEFPYTHON_APP) def build_subprocess_executable(): print("[buil_cpp_projects.py] Build executable: subprocess") compiler = get_compiler(static=True) sources = get_sources(SUBPROCESS_DIR, exclude_names=["print_handler_gtk.cpp"]) (changed, objects) = smart_compile(compiler, macros=subprocess_MACROS, extra_args=subprocess_COMPILER_ARGS, sources=sources, output_dir=BUILD_SUBPROCESS) executable_path = os.path.join(BUILD_SUBPROCESS, "subprocess" + EXECUTABLE_EXT) if changed or not os.path.exists(executable_path): lib_dir = os.path.join(CEF_BINARIES_LIBRARIES, "lib") lib_dir_vs = os.path.join(lib_dir, get_msvs_for_python(vs_prefix=True)) compiler.link_executable(objects, output_progname="subprocess", output_dir=BUILD_SUBPROCESS, libraries=["libcef", "libcef_dll_wrapper_MT"], library_dirs=[lib_dir, lib_dir_vs], # TODO linker flags for Linux/Mac extra_preargs=None, extra_postargs=subprocess_LINKER_ARGS) else: print("[build_cpp_projects.py] Executable is up-to-date: subprocess") def get_sources(sources_dir, exclude_names=None): if not exclude_names: exclude_names = list() sources = glob.glob(os.path.join(sources_dir, "*.cpp")) if MAC: sources.extend(glob.glob(os.path.join(sources_dir, "*.mm"))) ret = list() for source_file in sources: filename = os.path.basename(source_file) if "_win.cpp" in filename and not WINDOWS: continue if "_linux.cpp" in filename and not LINUX: continue if "x11" in filename and not LINUX: continue if "gtk" in filename and not LINUX: continue if "_mac.cpp" in filename and not MAC: continue exclude = False for name in exclude_names: if name in filename: exclude = True break if not exclude: ret.append(source_file) return ret def smart_compile(compiler, macros, extra_args, sources, output_dir): """Smart compile will only recompile files that need recompiling.""" if not os.path.exists(output_dir): os.makedirs(output_dir) any_changed = False objects = list() for source_file in sources: header_file = source_file.replace(".cpp", ".h") header_file = header_file.replace(".mm", ".h") assert header_file.endswith(".h") if not os.path.isfile(header_file): header_file = None obj_file = os.path.join(output_dir, os.path.basename(source_file)) obj_file = obj_file.replace(".cpp", OBJ_EXT) obj_file = obj_file.replace(".mm", OBJ_EXT) assert obj_file.endswith(OBJ_EXT) if os.path.exists(obj_file): # Recompile source file if its time is newer than obj file, # Also check its header file time. Also check times of any # possible includes: cefpython_fixed.h, src/common/ files. obj_time = os.path.getmtime(obj_file) source_time = os.path.getmtime(source_file) header_time = os.path.getmtime(header_file) if header_file else 0 cefpython_h_fixed_time = os.path.getmtime( CEFPYTHON_API_HFILE_FIXED) common_files_time = get_directory_mtime(os.path.join(SRC_DIR, "common")) changed = ((source_time > obj_time) or (header_time > obj_time) or (cefpython_h_fixed_time > obj_time) or (common_files_time > obj_time)) else: changed = True if changed: any_changed = True else: objects.append(obj_file) if any_changed: # If any has changed must recompile all given sources (for a library # or executable). This is because we don't know which sources include # which header files so must recompile everything. objects = list() # Compile each source file separately so that when compiling # source files from different directories, object files are # all put in the same output_directory. Otherwise distutils # will create lots of subdirs in output_directory. macros = macros_as_tuples(macros) common_dir = os.path.join(SRC_DIR, "common") original_dir = os.getcwd() for source_file in sources: source_dir = os.path.dirname(source_file) os.chdir(source_dir) source_basename = os.path.basename(source_file) oneobj = compiler.compile([source_basename], output_dir=output_dir, macros=macros, # TODO include dirs for Linux/Mac include_dirs=[SRC_DIR, common_dir, get_python_include_path()], # TODO compiler flags for Linux/Mac extra_preargs=None, extra_postargs=extra_args) assert len(oneobj) == 1 objects.append(os.path.join(source_dir, oneobj[0])) os.chdir(original_dir) assert len(objects) return any_changed, objects def macros_as_tuples(macros): """Return all macros as tuples. Required by distutils.ccompiler.""" ret_macros = list() for macro in macros: if isinstance(macro, str): ret_macros.append((macro, "")) else: assert isinstance(macro, tuple) ret_macros.append(macro) return ret_macros def get_directory_mtime(directory): # For example check src/common/ directory for newest modification time assert os.path.isdir(directory) files = glob.glob(os.path.join(directory, "*")) ret_mtime = 0 for header_file in files: mtime = os.path.getmtime(header_file) if mtime > ret_mtime: ret_mtime = mtime assert ret_mtime return ret_mtime if __name__ == "__main__": main() cefpython-49.0/tools/build_distrib.py000066400000000000000000000665331334103266300200140ustar00rootroot00000000000000# Copyright (c) 2017 CEF Python, see the Authors file. # All rights reserved. Licensed under BSD 3-clause license. # Project website: https://github.com/cztomczak/cefpython """ Build distribution packages for all architectures and all supported python versions. Usage: build_distrib.py VERSION [--no-run-examples] [--no-rebuild] Options: VERSION Version number eg. 50.0 --no-run-examples Do not run examples while building cefpython modules. Examples require interaction, closing window before proceeding. Only unit tests will be run in such case. --no-rebuild Do not rebuild cefpython modules. For internal use so that changes to packaging can be quickly tested. --no-automate Do not run automate.py --prebuilt-cef. This flag allows to use CEF prebuilt binaries and libraries downloaded from CEF Python's Github releases to build distribution pacakges. This script does the following: 1. Expects that all supported python versions are installed a) On Windows search for Pythons in the multiple default install locations b) On Linux use only Pythons from ~/.pyenv/versions/ directory c) On Mac use Pythons from ~/.pyenv/versions/ and /usr/local/bin/python For example will use Python 2.7.13 from /usr/local/bin/ only when 2.7 was not found in ~/.pyenv/versions/. 2. Expects that all python compilers for supported python versions are installed. See docs/Build-instructions.md > Requirements. 3. Expects cef_binary*/ directories from Spotify Automated Builds to be in the build/ directory. It does not rebuild cefclient nor libcef_dll_wrapper libraries in these directories. If you would like to rebuild everything from scratch then delete subdirs manually (build_cefclient/, build_wrapper*/). When building CEF from sources copy build/chromium/src/cef/binary_distrib /cef_binary_*/ to the build/ directory. 4. Install and/or upgrade tools/requirements.txt and uninstall cefpython3 packages for all python versions 5. Run automate.py --prebuilt-cef using both Python 32-bit and Python 64-bit 6. Pack the prebuilt biaries using zip on Win/Mac and .tar.gz on Linux and move to build/distrib/ 7. Reduce packages size (Issue #321). After packing prebuilt binaries, reduce its size so that packages will use the reduced prebuilt binaries. 8. Build cefpython modules for all supported Python versions on both 32-bit and 64-bit. Backup and restore subprocess executable on Windows built with Python 2.7 (Issue #342). 9. Make setup installers and pack them to zip (Win/Mac) or .tar.gz (Linux) 10. Make wheel packages 11. Move setup and wheel packages to the build/distrib/ directory 12. Test wheel packages installation and run unit tests using the installed wheel package. 13. Show summary """ from common import * import glob import os import pprint import re import shutil import subprocess # import tarfile # Currently using zip on all platforms import zipfile # Command line args VERSION = "" NO_RUN_EXAMPLES = False NO_REBUILD = False NO_AUTOMATE = False # Python versions SUPPORTED_PYTHON_VERSIONS = [(2, 7), (3, 4)] # Python search paths. It will use first Python found for specific version. # Supports replacement of one environment variable in path eg.: %ENV_KEY%. PYTHON_SEARCH_PATHS = dict( WINDOWS=[ "C:\\Python*\\", "%LOCALAPPDATA%\\Programs\\Python\\Python*\\", "C:\\Program Files\\Python*\\", "C:\\Program Files (x86)\\Python*\\", ], LINUX=[ "%PYENV_ROOT%/versions/*/bin", ], MAC=[ "%PYENV_ROOT%/versions/*/bin", "/usr/local/bin", ], ) def main(): command_line_args() supported = list() for version in SUPPORTED_PYTHON_VERSIONS: supported.append("{major}.{minor}".format(major=version[0], minor=version[1])) print("[build_distrib.py] Supported python versions: {supported}" .format(supported=" / ".join(supported))) clean_build_directories() if WINDOWS: pythons_32bit = search_for_pythons("32bit") pythons_64bit = search_for_pythons("64bit") elif LINUX: pythons_32bit = search_for_pythons("32bit") if ARCH32 else list() pythons_64bit = search_for_pythons("64bit") if ARCH64 else list() elif MAC: pythons_32bit = list() pythons_64bit = search_for_pythons("64bit") else: print("ERROR: Unsupported OS") sys.exit(1) check_pythons(pythons_32bit, pythons_64bit) install_upgrade_requirements(pythons_32bit + pythons_64bit) uninstall_cefpython3_packages(pythons_32bit + pythons_64bit) if not os.path.exists(DISTRIB_DIR): os.makedirs(DISTRIB_DIR) if pythons_32bit: if not NO_AUTOMATE: run_automate_prebuilt_cef(pythons_32bit[0]) pack_prebuilt_cef("32bit") if LINUX: reduce_package_size_issue_262("32bit") remove_unnecessary_package_files("32bit") if pythons_64bit: if not NO_AUTOMATE: run_automate_prebuilt_cef(pythons_64bit[0]) pack_prebuilt_cef("64bit") if LINUX: reduce_package_size_issue_262("64bit") remove_unnecessary_package_files("64bit") if not NO_REBUILD: build_cefpython_modules(pythons_32bit, "32bit") build_cefpython_modules(pythons_64bit, "64bit") if pythons_32bit: make_packages(pythons_32bit[0], "32bit", pythons_32bit) if pythons_64bit: make_packages(pythons_64bit[0], "64bit", pythons_64bit) test_wheel_packages(pythons_32bit + pythons_64bit) show_summary(pythons_32bit, pythons_64bit) def command_line_args(): global VERSION, NO_RUN_EXAMPLES, NO_REBUILD, NO_AUTOMATE version = get_version_from_command_line_args(__file__) if not version or "--help" in sys.argv: print(__doc__) sys.exit(1) VERSION = version if "--no-run-examples" in sys.argv: NO_RUN_EXAMPLES = True sys.argv.remove("--no-run-examples") if "--no-rebuild" in sys.argv: NO_REBUILD = True sys.argv.remove("--no-rebuild") if "--no-automate" in sys.argv: NO_AUTOMATE = True sys.argv.remove("--no-automate") args = sys.argv[1:] for arg in args: if arg == version: continue print("[build_distrib.py] Invalid argument: {arg}".format(arg=arg)) sys.exit(1) def clean_build_directories(): print("[build_distrib.py] Clean build directories") # Delete distrib dir if os.path.exists(DISTRIB_DIR): print("[build_distrib.py] Delete directory: {distrib_dir}/" .format(distrib_dir=os.path.basename(DISTRIB_DIR))) shutil.rmtree(DISTRIB_DIR) if not NO_REBUILD: # Delete build_cefpython/ dir if os.path.exists(BUILD_CEFPYTHON): print("[build_distirb.py] Delete directory: {dir}/" .format(dir=os.path.basename(BUILD_CEFPYTHON))) shutil.rmtree(BUILD_CEFPYTHON) # Delete cefpython_binary_*/ dirs delete_cefpython_binary_dir("32bit") delete_cefpython_binary_dir("64bit") # Delete cef binaries and libraries dirs if not NO_AUTOMATE: # Delete cef binlib dir only if cef_binary dir exists, # otherwise you will end up with cef binlib directory # deleted and script failing further when calling # automate.py --prebuilt-cef. version = get_cefpython_version() # 32-bit if not MAC: postfix2 = get_cef_postfix2_for_arch("32bit") cef_binary_dir = "cef_binary_{cef_version}_{postfix2}"\ .format(cef_version=version["CEF_VERSION"], postfix2=postfix2) if len(glob.glob(cef_binary_dir)) != 1: raise Exception("Directory not found: "+cef_binary_dir) # 64-bit postfix2 = get_cef_postfix2_for_arch("64bit") cef_binary_dir = "cef_binary_{cef_version}_windows64"\ .format(cef_version=version["CEF_VERSION"], postfix2=postfix2) if len(glob.glob(cef_binary_dir)) != 1: raise Exception("Directory not found: "+cef_binary_dir) # Delete delete_cef_binaries_libraries_dir("32bit") delete_cef_binaries_libraries_dir("64bit") def delete_cefpython_binary_dir(arch): cefpython_binary = get_cefpython_binary_basename( postfix2=get_os_postfix2_for_arch(arch)) assert cefpython_binary, cefpython_binary cefpython_binary = os.path.join(BUILD_DIR, cefpython_binary) if os.path.exists(cefpython_binary): print("[build_distrib.py] Delete directory: {dir}/" .format(dir=os.path.basename(cefpython_binary))) shutil.rmtree(cefpython_binary) def delete_cef_binaries_libraries_dir(arch): cef_binlib = get_cef_binaries_libraries_basename( postfix2=get_os_postfix2_for_arch(arch)) assert cef_binlib, cef_binlib cef_binlib = os.path.join(BUILD_DIR, cef_binlib) if os.path.exists(cef_binlib): print("[build_distrib.py] Delete directory: {dir}/" .format(dir=os.path.basename(cef_binlib))) shutil.rmtree(cef_binlib) def search_for_pythons(search_arch): """Returns pythons ordered by version from lowest to highest.""" pythons_found = list() for pattern in PYTHON_SEARCH_PATHS[SYSTEM]: # Replace env variable in path match = re.search(r"%(\w+)%", pattern) if match: env_key = match.group(1) if env_key in os.environ: pattern = pattern.replace(match.group(0), os.environ[env_key]) else: print("ERROR: Env variable not found: {env_key}" .format(env_key=env_key)) sys.exit(1) results = glob.glob(pattern) for path in results: if os.path.isdir(path): python = os.path.join(path, "python{ext}".format(ext=EXECUTABLE_EXT)) version_code = ("import sys;" "print(str(sys.version_info[:3]));") if not os.path.isfile(python): print("ERROR: Python executable not found: {executable}" .format(executable=python)) sys.exit(1) version_str = subprocess.check_output([python, "-c", version_code]) version_str = version_str.strip() match = re.search("^\((\d+), (\d+), (\d+)\)$", version_str) assert match, version_str major = match.group(1) minor = match.group(2) micro = match.group(3) version_tuple2 = (int(major), int(minor)) version_tuple3 = (int(major), int(minor), int(micro)) arch_code = ("import platform;" "print(str(platform.architecture()[0]));") arch = subprocess.check_output([python, "-c", arch_code]) arch = arch.strip() if version_tuple2 in SUPPORTED_PYTHON_VERSIONS \ and arch == search_arch: name = ("Python {major}.{minor}.{micro} {arch}" .format(major=major, minor=minor, micro=micro, arch=arch)) pythons_found.append(dict( version2=version_tuple2, version3=version_tuple3, arch=arch, executable=python, name=name)) ret_pythons = list() for version_tuple in SUPPORTED_PYTHON_VERSIONS: supported_python = None for python in pythons_found: if python["version2"] == version_tuple: supported_python = python break if supported_python: ret_pythons.append(supported_python) return ret_pythons def check_pythons(pythons_32bit, pythons_64bit): check_32bit = True check_64bit = True if MAC: check_32bit = False elif LINUX: if pythons_64bit: check_32bit = False elif pythons_32bit: check_64bit = False pp = pprint.PrettyPrinter(indent=4) if pythons_32bit: print("[build_distrib.py] Pythons 32-bit found:") pp.pprint(pythons_32bit) if check_32bit and len(pythons_32bit) != len(SUPPORTED_PYTHON_VERSIONS): print("[build_distrib.py] ERROR: Couldn't find all supported" " python 32-bit installations. Found: {found}." .format(found=len(pythons_32bit))) sys.exit(1) if pythons_64bit: print("[build_distrib.py] Pythons 64-bit found:") pp.pprint(pythons_64bit) if check_64bit and len(pythons_64bit) != len(SUPPORTED_PYTHON_VERSIONS): print("[build_distrib.py] ERROR: Couldn't find all supported" " python 64-bit installations. Found: {found}." .format(found=len(pythons_64bit))) sys.exit(1) def install_upgrade_requirements(pythons): for python in pythons: print("[build_distrib.py] pip install/upgrade requirements.txt" " for: {name}".format(name=python["name"])) # Upgrade pip command = ("\"{python}\" -m pip install --upgrade pip" .format(python=python["executable"])) command = sudo_command(command, python=python["executable"]) pcode = subprocess.call(command, shell=True) if pcode != 0: print("[build_distrib.py] ERROR while upgrading pip") sys.exit(1) # Install/upgrade requirements.txt requirements = os.path.join(TOOLS_DIR, "requirements.txt") command = ("\"{python}\" -m pip install --upgrade -r {requirements}" .format(python=python["executable"], requirements=requirements)) command = sudo_command(command, python=python["executable"]) pcode = subprocess.call(command, shell=True) if pcode != 0: print("[build_distrib.py] ERROR while running pip install/upgrade") sys.exit(1) def uninstall_cefpython3_packages(pythons): for python in pythons: print("[build_distrib.py] Uninstall cefpython3 package" " for: {name}".format(name=python["name"])) # Check if package is installed command = ("\"{python}\" -m pip show cefpython3" .format(python=python["executable"])) try: output = subprocess.check_output(command, shell=True) except subprocess.CalledProcessError, exc: # pip show returns error code when package is not installed output = exc.output if not len(output.strip()): # Package is not installed - info is an empty string print("[build_distrib.py] Not installed") continue # Uninstall package. Only uninstall if package is installed, # otherwise error code is returned. command = ("\"{python}\" -m pip uninstall -y cefpython3" .format(python=python["executable"])) command = sudo_command(command, python=python["executable"]) pcode = subprocess.call(command, shell=True) if pcode != 0: print("[build_distrib.py] ERROR while uninstall cefpython3" " package using pip") sys.exit(1) def run_automate_prebuilt_cef(python): print("[build_distrib.py] Run automate.py --prebuilt-cef for {arch}" .format(arch=python["arch"])) automate = os.path.join(TOOLS_DIR, "automate.py") command = ("\"{python}\" {automate} --prebuilt-cef" .format(python=python["executable"], automate=automate)) code = subprocess.call(command, shell=True) if code != 0: print("[build_distrib.py] ERROR while running automate.py") sys.exit(1) def pack_prebuilt_cef(arch): prebuilt_basename = get_cef_binaries_libraries_basename( get_os_postfix2_for_arch(arch)) print("[build_distrib.py] Pack directory: {dir}/ ..." .format(dir=prebuilt_basename)) prebuilt_dir = os.path.join(BUILD_DIR, prebuilt_basename) assert os.path.exists(prebuilt_dir), prebuilt_dir archive = pack_directory(prebuilt_dir, base_path=BUILD_DIR) shutil.move(archive, DISTRIB_DIR) print("[build_distrib.py] Created archive in distrib dir: {archive}" .format(archive=os.path.basename(archive))) def pack_directory(path, base_path): if path.endswith(os.path.sep): path = path[:-1] # ext = ".zip" if WINDOWS or MAC else ".tar.gz" ext = ".zip" archive = path + ext if os.path.exists(archive): os.remove(archive) if WINDOWS or MAC: zip_directory(path, base_path=base_path, archive=archive) else: zip_directory(path, base_path=base_path, archive=archive) # with tarfile.open(archive, "w:gz") as tar: # tar.add(path, arcname=os.path.basename(path)) assert os.path.isfile(archive), archive return archive def zip_directory(path, base_path, archive): original_dir = os.getcwd() os.chdir(base_path) path = path.replace(base_path, "") if path[0] == os.path.sep: path = path[1:] zipf = zipfile.ZipFile(archive, "w", zipfile.ZIP_DEFLATED) for root, dirs, files in os.walk(path): for file_ in files: zipf.write(os.path.join(root, file_)) zipf.close() os.chdir(original_dir) def reduce_package_size_issue_262(arch): """Linux only: libcef.so is huge (500 MB) in Chrome v54+. Issue #262.""" print("[build_distrib.py] Reduce package size for {arch} (Issue #262)" .format(arch=arch)) prebuilt_basename = get_cef_binaries_libraries_basename( get_os_postfix2_for_arch(arch)) bin_dir = os.path.join(prebuilt_basename, "bin") # Run `strip` command on `libcef.so` libcef_so = os.path.join(bin_dir, "libcef.so") print("[build_distrib.py] Strip {libcef_so}" .format(libcef_so=os.path.basename(libcef_so))) command = "strip {libcef_so}".format(libcef_so=libcef_so) pcode = subprocess.call(command, shell=True) assert pcode == 0, "strip command failed" def remove_unnecessary_package_files(arch): """Do not ship sample applications (cefclient etc) with the package. They increase size and also are an additional unnecessary factor when dealing with false-positives in Anti-Virus software.""" print("[build_distrib.py] Reduce package size for {arch} (Issue #321)" .format(arch=arch)) prebuilt_basename = get_cef_binaries_libraries_basename( get_os_postfix2_for_arch(arch)) bin_dir = os.path.join(prebuilt_basename, "bin") delete_cef_sample_apps(caller_script=__file__, bin_dir=bin_dir) def build_cefpython_modules(pythons, arch): for python in pythons: print("[build_distrib.py] Build cefpython module for {python_name}" .format(python_name=python["name"])) flags = "" if NO_RUN_EXAMPLES: flags += " --no-run-examples" # On Linux/Mac Makefiles are used and must pass --clean flag command = ("\"{python}\" {build_py} {version} --clean {flags}" .format(python=python["executable"], build_py=os.path.join(TOOLS_DIR, "build.py"), version=VERSION, flags=flags)) # build.py may require sudo if system python, so shell=True pcode = subprocess.call(command, shell=True) if pcode != 0: print("[build_distrib.py] ERROR: failed to build cefpython" " module for {python_name}" .format(python_name=python["name"])) sys.exit(1) print("[build_distrib.py] Built successfully cefpython module for" " {python_name}".format(python_name=python["name"])) # Issue #342 backup_subprocess_executable_issue342(python) # Issue #342 restore_subprocess_executable_issue342(arch) print("[build_distrib.py] Successfully built cefpython modules for {arch}" .format(arch=arch)) def backup_subprocess_executable_issue342(python): """Use subprocess executable build by Python 2.7 to avoid false-positives by AVs when building subprocess with Python 3. Windows-only issue.""" if not WINDOWS: return if python["version2"] == (2, 7): print("[build_distrib.py] Backup subprocess executable built" " with Python 2.7 (Issue #342)") cefpython_binary_basename = get_cefpython_binary_basename( get_os_postfix2_for_arch(python["arch"])) cefpython_binary = os.path.join(BUILD_DIR, cefpython_binary_basename) assert os.path.isdir(cefpython_binary) src = os.path.join(cefpython_binary, "subprocess.exe") dst = os.path.join(BUILD_CEFPYTHON, "subprocess_py27_{arch}_issue342.exe" .format(arch=python["arch"])) shutil.copy(src, dst) def restore_subprocess_executable_issue342(arch): """Use subprocess executable build by Python 2.7 to avoid false-positives by AVs when building subprocess with Python 3. Windows-only issue.""" if not WINDOWS: return print("[build_distrib.py] Restore subprocess executable built" " with Python 2.7 (Issue #342)") cefpython_binary_basename = get_cefpython_binary_basename( get_os_postfix2_for_arch(arch)) cefpython_binary = os.path.join(BUILD_DIR, cefpython_binary_basename) assert os.path.isdir(cefpython_binary) src = os.path.join(BUILD_CEFPYTHON, "subprocess_py27_{arch}_issue342.exe" .format(arch=arch)) assert os.path.isfile(src) dst = os.path.join(cefpython_binary, "subprocess.exe") shutil.copy(src, dst) def make_packages(python, arch, all_pythons): """Make setup and wheel packages.""" print("[build_distrib.py] Make setup package for {arch}..." .format(arch=arch)) # Call make_installer.py make_installer_py = os.path.join(TOOLS_DIR, "make_installer.py") installer_command = ("\"{python}\" {make_installer_py} {version}" .format(python=python["executable"], make_installer_py=make_installer_py, version=VERSION)) pcode = subprocess.call(installer_command, cwd=BUILD_DIR, shell=True) if pcode != 0: print("[build_distrib.py] ERROR: failed to make setup package for" " {arch}".format(arch=arch)) sys.exit(1) # Pack setup package and move to distrib dir print("[build_distrib.py] Pack setup package for {arch}..." .format(arch=arch)) setup_basename = get_setup_installer_basename( VERSION, get_os_postfix2_for_arch(arch)) setup_dir = os.path.join(BUILD_DIR, setup_basename) check_cpp_extension_dependencies_issue359(setup_dir, all_pythons) archive = pack_directory(setup_dir, BUILD_DIR) shutil.move(archive, DISTRIB_DIR) # Make wheel package print("[build_distrib.py] Make wheel package for {arch}..." .format(arch=arch)) wheel_args = "bdist_wheel --universal" wheel_command = ("\"{python}\" setup.py {wheel_args}" .format(python=python["executable"], wheel_args=wheel_args)) pcode = subprocess.call(wheel_command, cwd=setup_dir, shell=True) if pcode != 0: print("[build_distrib.py] ERROR: failed to make wheel package for" " {arch}".format(arch=arch)) sys.exit(1) # Move wheel package files = glob.glob(os.path.join(setup_dir, "dist", "*.whl")) assert len(files) == 1, ".whl file not found" shutil.move(files[0], DISTRIB_DIR) # Delete setup directory print("[build_distrib.py] Delete setup directory: {setup_dir}/" .format(setup_dir=os.path.basename(setup_dir))) shutil.rmtree(setup_dir) def check_cpp_extension_dependencies_issue359(setup_dir, all_pythons): """Windows only: check if msvcpXX.dll exist for all Python versions. Issue #359.""" if not WINDOWS: return checked_any = False for python in all_pythons: if python["version2"] == (3, 4): checked_any = True if not os.path.exists(os.path.join(setup_dir, "cefpython3", "msvcp100.dll")): raise Exception("C++ ext dependency missing: msvcp100.dll") elif python["version2"] == (2, 7): if not os.path.exists(os.path.join(setup_dir, "cefpython3", "msvcp90.dll")): raise Exception("C++ ext dependency missing: msvcp90.dll") checked_any = True assert checked_any def test_wheel_packages(pythons): """Test wheel packages installation and run unit tests.""" uninstall_cefpython3_packages(pythons) for python in pythons: print("[build_distrib.py] Test wheel package (install, unittests) for" " {python_name}".format(python_name=python["name"])) platform_tag = get_pypi_postfix2_for_arch(python["arch"]) whl_pattern = (r"*{platform_tag}.whl" .format(platform_tag=platform_tag)) wheels = glob.glob(os.path.join(DISTRIB_DIR, whl_pattern)) assert len(wheels) == 1, ("No wheels found in distrib dir for %s" % python["arch"]) # Install wheel command = ("\"{python}\" -m pip install {wheel}" .format(python=python["executable"], wheel=os.path.basename(wheels[0]))) command = sudo_command(command, python=python["executable"]) pcode = subprocess.call(command, cwd=DISTRIB_DIR, shell=True) if pcode != 0: print("[build_distrib.py] Wheel package installation failed for" " {python_name}".format(python_name=python["name"])) sys.exit(1) # Run unittests using the installed wheel package command = ("\"{python}\" {unittests}" .format(python=python["executable"], unittests=os.path.join(UNITTESTS_DIR, "main_test.py"))) pcode = subprocess.call(command, cwd=DISTRIB_DIR, shell=True) if pcode != 0: print("[build_distrib.py] ERROR: Unit tests failed for" " {python_name}".format(python_name=python["name"])) sys.exit(1) def show_summary(pythons_32bit, pythons_64bit): print("[build_distrib.py] SUMMARY:") print(" Pythons 32bit ({count})".format(count=len(pythons_32bit))) for python in pythons_32bit: print(" {python_name}".format(python_name=python["name"])) print(" Pythons 64bit ({count})".format(count=len(pythons_64bit))) for python in pythons_64bit: print(" {python_name}".format(python_name=python["name"])) files = glob.glob(os.path.join(DISTRIB_DIR, "*")) print(" Files in the build/{distrib_basename}/ directory ({count})" .format(distrib_basename=os.path.basename(DISTRIB_DIR), count=len(files))) for file_ in files: print(" {filename}".format(filename=os.path.basename(file_))) print("[build_distrib.py] Everything OK. Distribution packages created.") if __name__ == "__main__": main() cefpython-49.0/tools/common.py000066400000000000000000000376511334103266300164640ustar00rootroot00000000000000# Copyright (c) 2017 CEF Python, see the Authors file. # All rights reserved. Licensed under BSD 3-clause license. # Project website: https://github.com/cztomczak/cefpython # Common stuff for tools such as automate.py, build.py, etc. import glob import os import platform import re import shutil import struct import sys # These sample apps will be deleted when creating setup/wheel packages CEF_SAMPLE_APPS = ["cefclient", "cefsimple", "ceftests", "chrome-sandbox"] # Architecture and OS postfixes ARCH32 = (8 * struct.calcsize('P') == 32) ARCH64 = (8 * struct.calcsize('P') == 64) # Make sure platform.architecture()[0] shows correctly 32bit when # running Python 32bit on Windows 64bit. if ARCH32: assert platform.architecture()[0] == "32bit" if ARCH64: assert platform.architecture()[0] == "64bit" ARCH_STR = platform.architecture()[0] # Operating system architecture SYSTEM64 = platform.machine().endswith('64') SYSTEM32 = not SYSTEM64 # OS_POSTFIX is for directories/files names in cefpython sources # and doesn't include architecture type, just OS name. # OS_POSTFIX2 is for platform name in cefpython binaries # and includes architecture type (32bit/64bit). # CEF_POSTFIX2 is for platform name in upstream CEF binaries # and includes architecture type (32bit/64bit). OS_POSTFIX = ("win" if platform.system() == "Windows" else "linux" if platform.system() == "Linux" else "mac" if platform.system() == "Darwin" else "unknown") OS_POSTFIX2 = "unknown" CEF_POSTFIX2 = "unknown" # Upstream CEF binaries postfix if OS_POSTFIX == "win": OS_POSTFIX2 = "win32" if ARCH32 else "win64" CEF_POSTFIX2 = "windows32" if ARCH32 else "windows64" elif OS_POSTFIX == "mac": OS_POSTFIX2 = "mac32" if ARCH32 else "mac64" CEF_POSTFIX2 = "macosx32" if ARCH32 else "macosx64" elif OS_POSTFIX == "linux": OS_POSTFIX2 = "linux32" if ARCH32 else "linux64" CEF_POSTFIX2 = "linux32" if ARCH32 else "linux64" # Platforms SYSTEM = platform.system().upper() if SYSTEM == "DARWIN": SYSTEM = "MAC" WINDOWS = SYSTEM if SYSTEM == "WINDOWS" else False LINUX = SYSTEM if SYSTEM == "LINUX" else False MAC = SYSTEM if SYSTEM == "MAC" else False OS_POSTFIX2_ARCH = dict( WINDOWS={"32bit": "win32", "64bit": "win64"}, LINUX={"32bit": "linux32", "64bit": "linux64"}, MAC={"32bit": "mac32", "64bit": "mac64"}, ) CEF_POSTFIX2_ARCH = dict( WINDOWS={"32bit": "windows32", "64bit": "windows64"}, LINUX={"32bit": "linux32", "64bit": "linux64"}, MAC={"64bit": "macosx64"}, ) PYPI_POSTFIX2_ARCH = dict( WINDOWS={"32bit": "win32", "64bit": "win_amd64"}, LINUX={"32bit": "manylinux1_i686", "64bit": "manylinux1_x86_64"}, MAC={"64bit": "x86_64"}, ) # Python version eg. 27 PYVERSION = str(sys.version_info[0])+str(sys.version_info[1]) # Module extension if WINDOWS: MODULE_EXT = "pyd" else: MODULE_EXT = "so" # CEF Python module name MODULE_NAME_TEMPLATE = "cefpython_py{pyversion}.{ext}" MODULE_NAME_TEMPLATE_NOEXT = "cefpython_py{pyversion}" MODULE_NAME = MODULE_NAME_TEMPLATE.format(pyversion=PYVERSION, ext=MODULE_EXT) MODULE_NAME_NOEXT = MODULE_NAME_TEMPLATE_NOEXT.format(pyversion=PYVERSION) # App and Executable extensions if WINDOWS: APP_EXT = ".exe" EXECUTABLE_EXT = ".exe" elif MAC: APP_EXT = ".app" # cefclient, cefsimple, ceftests EXECUTABLE_EXT = "" # subprocess else: APP_EXT = "" EXECUTABLE_EXT = "" # Library extension if WINDOWS: LIB_EXT = ".lib" else: LIB_EXT = ".a" # Compiled object extension if WINDOWS: OBJ_EXT = ".obj" else: OBJ_EXT = ".o" # ---------------------------------------------------------------------------- # Directories # ---------------------------------------------------------------------------- assert __file__ ROOT_DIR = os.path.abspath(os.path.dirname(os.path.dirname(__file__))) # API reference API_DIR = os.path.join(ROOT_DIR, "api") DOCS_DIR = os.path.join(ROOT_DIR, "docs") # Build directories BUILD_DIR = os.path.join(ROOT_DIR, "build") BUILD_CEFPYTHON = os.path.join(BUILD_DIR, "build_cefpython") # May be auto-overwritten through detect_cef_binaries_libraries_dir() CEF_BINARIES_LIBRARIES = os.path.join(BUILD_DIR, "cef_"+OS_POSTFIX2) # Will be overwritten through detect_cefpython_binary_dir() CEFPYTHON_BINARY = "CEFPYTHON_BINARY_NOTSET" # Distrib directory DISTRIB_DIR = os.path.join(BUILD_DIR, "DISTRIB_NOTSET") # Build C++ projects directories BUILD_CEFPYTHON_APP = os.path.join(BUILD_CEFPYTHON, "cefpython_app_py{pyver}_{os}" .format(pyver=PYVERSION, os=OS_POSTFIX2)) BUILD_CLIENT_HANDLER = os.path.join(BUILD_CEFPYTHON, "client_handler_py{pyver}_{os}" .format(pyver=PYVERSION, os=OS_POSTFIX2)) BUILD_CPP_UTILS = os.path.join(BUILD_CEFPYTHON, "cpp_utils_py{pyver}_{os}" .format(pyver=PYVERSION, os=OS_POSTFIX2)) BUILD_SUBPROCESS = os.path.join(BUILD_CEFPYTHON, "subprocess_py{pyver}_{os}" .format(pyver=PYVERSION, os=OS_POSTFIX2)) # -- end build directories EXAMPLES_DIR = os.path.join(ROOT_DIR, "examples") SNIPPETS_DIR = os.path.join(EXAMPLES_DIR, "snippets") SRC_DIR = os.path.join(ROOT_DIR, "src") # Subdirectories in src/ CLIENT_HANDLER_DIR = os.path.join(SRC_DIR, "client_handler") CPP_UTILS_DIR = os.path.join(SRC_DIR, "cpp_utils") LINUX_DIR = os.path.join(SRC_DIR, "linux") MAC_DIR = os.path.join(SRC_DIR, "mac") SUBPROCESS_DIR = os.path.join(SRC_DIR, "subprocess") WINDOWS_DIR = os.path.abspath(os.path.join(SRC_DIR, "windows")) # -- end subdirectories in src/ TOOLS_DIR = os.path.join(ROOT_DIR, "tools") INSTALLER_DIR = os.path.join(TOOLS_DIR, "installer") UNITTESTS_DIR = os.path.abspath(os.path.join(ROOT_DIR, "unittests")) # ---------------------------------------------------------------------------- # cefpython API header file and a fixed copy of it CEFPYTHON_API_HFILE = os.path.join(BUILD_CEFPYTHON, "cefpython_py{pyver}.h" .format(pyver=PYVERSION)) CEFPYTHON_API_HFILE_FIXED = os.path.join(BUILD_CEFPYTHON, "cefpython_py{pyver}_fixed.h" .format(pyver=PYVERSION)) # Result libraries paths CEFPYTHON_APP_LIB = os.path.join(BUILD_CEFPYTHON_APP, "cefpython_app" + LIB_EXT) CLIENT_HANDLER_LIB = os.path.join(BUILD_CLIENT_HANDLER, "client_handler" + LIB_EXT) CPP_UTILS_LIB = os.path.join(BUILD_CPP_UTILS, "cpp_utils" + LIB_EXT) SUBPROCESS_EXE = os.path.join(BUILD_SUBPROCESS, "subprocess" + EXECUTABLE_EXT) # Visual Studio constants VS_PLATFORM_ARG = "x86" if ARCH32 else "amd64" VS2015_VCVARS = ("C:\\Program Files (x86)\\Microsoft Visual Studio 14.0" "\\VC\\vcvarsall.bat") # For CEF build VS2013_VCVARS = ("C:\\Program Files (x86)\\Microsoft Visual Studio 12.0" "\\VC\\vcvarsall.bat") # VS2010 vcvarsall not used, using detection with setuptools instead VS2010_VCVARS = ("C:\\Program Files (x86)\\Microsoft Visual Studio 10.0" "\\VC\\vcvarsall.bat") VS2008_VCVARS = ("%LocalAppData%\\Programs\\Common\\Microsoft" "\\Visual C++ for Python\\9.0\\vcvarsall.bat") VS2008_BUILD = ("%LocalAppData%\\Programs\\Common\\" "Microsoft\\Visual C++ for Python\\9.0\\" "VC\\bin\\amd64\\vcbuild.exe") if "LOCALAPPDATA" in os.environ: VS2008_VCVARS = VS2008_VCVARS.replace("%LocalAppData%", os.environ["LOCALAPPDATA"]) VS2008_BUILD = VS2008_BUILD.replace("%LocalAppData%", os.environ["LOCALAPPDATA"]) # ----------------------------------------------------------------------------- def get_os_postfix2_for_arch(arch): return OS_POSTFIX2_ARCH[SYSTEM][arch] def get_cef_postfix2_for_arch(arch): return CEF_POSTFIX2_ARCH[SYSTEM][arch] def get_pypi_postfix2_for_arch(arch): return PYPI_POSTFIX2_ARCH[SYSTEM][arch] def sudo_command(command, python): """Prepends command with sudo when installing python packages requires sudo.""" if python.startswith("/usr/"): command = "sudo " + command return command def get_python_path(): """Get Python path.""" return os.path.dirname(sys.executable) def get_python_include_path(): # 1) C:\Python27\include # 2) ~/.pyenv/versions/2.7.13/bin/python # ~/.pyenv/versions/2.7.13/include/python2.7 # 3) ~/.pyenv/versions/3.4.6/include/python2.7m # 4) /usr/include/python2.7 base_dir = os.path.dirname(sys.executable) try_dirs = ["{base_dir}/include", "{base_dir}/../include/python{ver}", "{base_dir}/../include/python{ver}*", ("{base_dir}/../Frameworks/Python.framework/Versions/{ver}" "/include/python{ver}*"), "/usr/include/python{ver}"] ver_tuple = sys.version_info[:2] ver = "{major}.{minor}".format(major=ver_tuple[0], minor=ver_tuple[1]) for pattern in try_dirs: pattern = pattern.format(base_dir=base_dir, ver=ver) if WINDOWS: pattern = pattern.replace("/", "\\") results = glob.glob(pattern) if len(results) == 1: python_h = os.path.join(results[0], "Python.h") if os.path.isfile(python_h): return results[0] return ".\\" if WINDOWS else "./" def delete_cef_sample_apps(caller_script, bin_dir): """Delete CEF sample apps to reduce package size.""" for sample_app_name in CEF_SAMPLE_APPS: sample_app = os.path.join(bin_dir, sample_app_name + APP_EXT) # Not on all platforms sample apps may be available if os.path.exists(sample_app): print("[{script}] Delete {sample_app}" .format(script=os.path.basename(caller_script), sample_app=os.path.basename(sample_app))) if os.path.isdir(sample_app): shutil.rmtree(sample_app) else: os.remove(sample_app) # Also delete subdirs eg. cefclient_files/, ceftests_files/ files_subdir = os.path.join(bin_dir, sample_app_name + "_files") if os.path.isdir(files_subdir): print("[build_distrib.py] Delete directory: {dir}/" .format(dir=os.path.basename(files_subdir))) shutil.rmtree(files_subdir) def _detect_cef_binaries_libraries_dir(): """Detect cef binary directory created by automate.py eg. build/cef55_3.2883.1553.g80bd606_win32/ and set CEF_BINARIES_LIBRARIES to it, otherwise it will point to eg. build/cef_win32/ .""" global CEF_BINARIES_LIBRARIES if not os.path.exists(CEF_BINARIES_LIBRARIES): dirs = glob.glob(os.path.join( BUILD_DIR, get_cef_binaries_libraries_basename(OS_POSTFIX2))) if len(dirs) == 1: CEF_BINARIES_LIBRARIES = os.path.normpath(dirs[0]) def get_cef_binaries_libraries_basename(postfix2): version = get_cefpython_version() return ("cef{major}_{cef_version}_{os}" .format(major=version["CHROME_VERSION_MAJOR"], cef_version=version["CEF_VERSION"], os=postfix2)) def get_cefpython_binary_basename(postfix2, ignore_error=False): cef_version = get_cefpython_version() cmdline_version = get_version_from_command_line_args( __file__, ignore_error=ignore_error) if not cmdline_version: if not ignore_error: raise Exception("Version arg not found in command line args") return # If cef_version is 56 then expect version from command line to # start with "56.". cef_major = cef_version["CHROME_VERSION_MAJOR"] if not cmdline_version.startswith("{major}.".format(major=cef_major)): if not ignore_error: raise Exception("cmd line arg major version != Chrome version") return dirname = "cefpython_binary_{version}_{os}".format( version=cmdline_version, os=postfix2) return dirname def get_setup_installer_basename(version, postfix2): setup_basename = ("cefpython3_{version}_{os}" .format(version=version, os=postfix2)) return setup_basename def _detect_cefpython_binary_dir(): """Detect cefpython binary directory where cefpython modules will be put. Eg. build/cefpython_56.0_win32/.""" # Check cef version from header file and check cefpython version # that was passed as command line argument to either build.py # or make-installer.py. The CEFPYTHON_BINARY constant should # only be used in those two scripts, so version number in sys.argv # is expected. If not found then keep the default # "CEFPYTHON_BINARY_NOTSET" value intact. dirname = get_cefpython_binary_basename(OS_POSTFIX2, ignore_error=True) if not dirname: return binary_dir = os.path.join(BUILD_DIR, dirname) global CEFPYTHON_BINARY CEFPYTHON_BINARY = binary_dir def _detect_distrib_dir(): global DISTRIB_DIR version = get_version_from_command_line_args(__file__, ignore_error=True) if version: # Will only be set when called from scripts that had version # number arg passed on command line: build.py, build_distrib.py, # make_installer.py, etc. if LINUX or MAC: # - On Linux buildig 32bit and 64bit separately, so don't # delete eg. 64bit distrib when building 32bit distrib. # Keep them in different directories. # - On Mac only 64bit is supported. dirname = ("distrib_{version}_{postfix2}" .format(version=version, postfix2=OS_POSTFIX2)) elif WINDOWS: # On Windows both 32bit and 64bit distribs are built at # the same time. dirname = ("distrib_{version}_{win32}_{win64}" .format(version=version, win32=OS_POSTFIX2_ARCH[WINDOWS]["32bit"], win64=OS_POSTFIX2_ARCH[WINDOWS]["64bit"])) else: dirname = ("distrib_{version}_{postfix}" .format(version=version, postfix=OS_POSTFIX)) DISTRIB_DIR = os.path.join(BUILD_DIR, dirname) def get_version_from_command_line_args(caller_script, ignore_error=False): args = " ".join(sys.argv) match = re.search(r"\b(\d+)\.\d+\b", args) if match: version = match.group(0) major = match.group(1) cef_version = get_cefpython_version() if major != cef_version["CHROME_VERSION_MAJOR"]: if ignore_error: return "" print("[{script}] ERROR: cmd arg major version != Chrome version" .format(script=os.path.basename(caller_script))) sys.exit(1) return version return def get_cefpython_version(): """Get CEF version from the 'src/version/' directory.""" header_file = os.path.join(SRC_DIR, "version", "cef_version_"+OS_POSTFIX+".h") return get_version_from_file(header_file) def get_version_from_file(header_file): with open(header_file, "rU") as fp: contents = fp.read() # no need to decode() as "rU" specified ret = dict() matches = re.findall(r'^#define (\w+) "?([^\s"]+)"?', contents, re.MULTILINE) for match in matches: ret[match[0]] = match[1] return ret def get_msvs_for_python(vs_prefix=False): """Get MSVS version (eg 2008) for current python running.""" if sys.version_info[:2] == (2, 7): return "VS2008" if vs_prefix else "2008" elif sys.version_info[:2] == (3, 4): return "VS2010" if vs_prefix else "2010" else: print("ERROR: This version of Python is not supported") sys.exit(1) _detect_cef_binaries_libraries_dir() _detect_cefpython_binary_dir() _detect_distrib_dir() cefpython-49.0/tools/cython_setup.py000066400000000000000000000344601334103266300177130ustar00rootroot00000000000000# Copyright (c) 2017 CEF Python, see the Authors file. # All rights reserved. Licensed under BSD 3-clause license. # Project website: https://github.com/cztomczak/cefpython """ cython_setup.py is for internal use only - called by build.py. This is Cython's setup for building the cefpython module """ # Use setuptools so that "Visual C++ compiler for Python 2.7" tools # can be used. Otherwise "Unable to find vcvarsall.bat" error occurs. try: from setuptools import setup from setuptools import Extension except ImportError: from distutils.core import setup from distutils.extension import Extension # Use "Extension" from Cython.Distutils so that "cython_directives" works from Cython.Distutils import build_ext, Extension from Cython.Compiler import Options # noinspection PyUnresolvedReferences from Cython.Compiler.ModuleNode import ModuleNode from common import * import sys import platform import Cython import os # Must monkey patch Cython's ModuleNode to inject custom C++ code # in the generated cefpython.cpp. This is a fix for an error on Mac: # > ImportError: dynamic module does not define init function # To get rid of CEF's undefined symbol error when importing module # it was required to pass "-fvisibility=hidden" and "-Wl,-dead_strip" # flags. However these flags cause the "initcefpython_py27" Python # Module Initialization function to be hidden as well. To workaround # this it is required to add default visibility attribute to the # signature of that init function. # # Original definition in Python 2.7: # | https://github.com/python/cpython/blob/2.7/Include/pyport.h # > define PyMODINIT_FUNC extern "C" __declspec(dllexport) void # # Original definition in Python 3.4 / 3.5 / 3.6: # > define PyMODINIT_FUNC extern "C" __declspec(dllexport) PyObject* if MAC: g_generate_extern_c_macro_definition_old = ( ModuleNode.generate_extern_c_macro_definition) def generate_extern_c_macro_definition(self, code): # This code is written by Cython to both cefpython API header file # and cefpython module cpp file. g_generate_extern_c_macro_definition_old(self, code) code.putln("// Added by: cefpython/tools/cython_setup.py") code.putln("#undef PyMODINIT_FUNC") if sys.version_info[:2] == (2, 7): code.putln("#define PyMODINIT_FUNC extern \"C\"" " __attribute__((visibility(\"default\"))) void") else: code.putln("#define PyMODINIT_FUNC extern \"C\"" " __attribute__((visibility(\"default\"))) PyObject*") # Overwrite Cython function ModuleNode.generate_extern_c_macro_definition = ( generate_extern_c_macro_definition) # Constants FAST_FLAG = False # Cython options. Stop on first error, otherwise hundreds # of errors appear in the console. Options.fast_fail = True def main(): print("[cython_setup.py] Python version: {ver} {arch}" .format(ver=platform.python_version(), arch=ARCH_STR)) print("[cython_setup.py] Python executable: %s" % sys.executable) print("[cython_setup.py] Cython version: %s" % Cython.__version__) global FAST_FLAG if len(sys.argv) > 1 and "--fast" in sys.argv: # Fast mode disables optimization flags print("[cython_setup.py] FAST mode enabled") FAST_FLAG = True sys.argv.remove("--fast") if len(sys.argv) <= 1: print(__doc__) sys.exit(1) compile_time_constants() options = dict() set_compiler_options(options) options["include_dirs"] = get_include_dirs() options["library_dirs"] = get_library_dirs() options["libraries"] = get_libraries() print("[cython_setup.py] Execute setup()") setup( name="cefpython_py{pyver}".format(pyver=PYVERSION), cmdclass={"build_ext": build_ext}, ext_modules=get_ext_modules(options) ) def get_winsdk_lib(): print("[cython_setup.py] Detect Windows SDK library directory") ret = "" if WINDOWS: if ARCH32: winsdk_libs = [ r"C:\\Program Files\\Microsoft SDKs\\Windows\\v7.1\\Lib", r"C:\\Program Files\\Microsoft SDKs\\Windows\\v7.0\\Lib", ] elif ARCH64: winsdk_libs = [ r"C:\\Program Files\\Microsoft SDKs\\Windows\\v7.1\\Lib\\x64", r"C:\\Program Files\\Microsoft SDKs\\Windows\\v7.0\\Lib\\x64", ] else: raise Exception("Unknown architecture") for lib in winsdk_libs: if os.path.exists(lib): ret = lib break if not ret: ret = winsdk_libs[0] if not os.path.exists(ret): raise Exception("Windows SDK Lib directory not found: %s" % ret) return ret def set_compiler_options(options): """Extends options and also sets environment variables.""" print("[cython_setup.py] Set compiler options") extra_compile_args = list() extra_link_args = list() if WINDOWS: # /EHsc - using STL string, multimap and others that use # C++ exceptions. # # /ignore:4217 - disable warnings such as this: # # client_handler_py27_32bit.lib(client_handler.obj): warning LNK4217: # locally defined symbol _RemovePythonCallbacksForFrame imported in # function "public: virtual bool __thiscall # ClientHandler::OnProcessMessageReceived # # The above warning LNK4217 is caused by the warning below which occurs # when building the client_handler.lib static library: extra_compile_args.extend(["/EHsc"]) extra_link_args.extend(["/ignore:4217"]) if LINUX or MAC: # Compiler flags if FAST_FLAG: extra_compile_args.append("-O0") else: extra_compile_args.append("-O3") extra_compile_args.extend([ "-DNDEBUG", "-std=gnu++11", ]) if LINUX: os.environ["CC"] = "g++" os.environ["CXX"] = "g++" extra_compile_args.extend(["-std=gnu++11"]) # Fix "ImportError ... undefined symbol ..." caused by CEF's # include/base/ headers by adding the -flto flag (Issue #230). # Unfortunately -flto prolongs compilation time significantly. # More on the other flags: https://stackoverflow.com/questions/ # 6687630/ . if FAST_FLAG: extra_compile_args.extend(["-flto"]) extra_link_args.extend(["-flto"]) else: extra_compile_args.extend(["-flto", "-fdata-sections", "-ffunction-sections"]) extra_link_args.extend(["-flto", "-Wl,--gc-sections"]) if MAC: # Compiler environment variables os.environ["CC"] = "c++" os.environ["CXX"] = "c++" # COMPILER ARGS # -Wno-return-type-c-linkage to ignore: # > warning: 'somefunc' has C-linkage specified, but returns # > user-defined type 'sometype' which is incompatible with C # # -Wno-constant-logical-operand to ignore: # > warning: use of logical '||' with constant operand extra_compile_args.extend([ # Compile against libc++ otherwise error "symbol not found" # with cef::logging::LogMessage symbol. Also include -lc++ # and -lc++abi libraries. "-stdlib=libc++", "-Wno-return-type-c-linkage", "-Wno-constant-logical-operand", ]) # From upstream CEF cefclient extra_compile_args.extend([ "-fno-strict-aliasing", "-fno-rtti", "-fno-threadsafe-statics", "-fobjc-call-cxx-cdtors", # Visibility of symbols: "-fvisibility=hidden", "-fvisibility-inlines-hidden", ]) # Visibility of symbols extra_compile_args.extend([ # "-flto", # "-fdata-sections", # "-ffunction-sections", ]) # LINKER ARGS extra_link_args.extend([ "-mmacosx-version-min=10.9", "-Wl,-search_paths_first", "-F"+os.path.join(CEF_BINARIES_LIBRARIES, "bin"), "-framework", "Chromium Embedded Framework", "-Wl,-rpath,@loader_path/", # ending slash is crucial! ]) if not FAST_FLAG: extra_link_args.extend([ # "-force_flat_namespace", # "-flto", "-Wl,-dead_strip", ]) options["extra_compile_args"] = extra_compile_args options["extra_link_args"] = extra_link_args def get_include_dirs(): print("[cython_setup.py] Prepare include directories") include_dirs = list() common_include_dirs = [ SRC_DIR, os.path.join(SRC_DIR, "common"), os.path.join(SRC_DIR, "extern"), os.path.join(SRC_DIR, "extern", "cef") ] if WINDOWS: include_dirs.extend([WINDOWS_DIR]) include_dirs.extend(common_include_dirs) elif MAC: include_dirs.extend([MAC_DIR]) include_dirs.extend(common_include_dirs) # TODO: Check these directories, are these really required on Mac? include_dirs.extend([ '/usr/include/gtk-2.0', '/usr/include/glib-2.0', '/usr/include/gtk-unix-print-2.0', '/usr/include/cairo', '/usr/include/pango-1.0', '/usr/include/gdk-pixbuf-2.0', '/usr/include/atk-1.0', # Fedora '/usr/lib64/gtk-2.0/include', '/usr/lib64/gtk-unix-print-2.0', '/usr/lib64/glib-2.0/include', '/usr/lib/gtk-2.0/include', '/usr/lib/gtk-2.0/gtk-unix-print-2.0', '/usr/lib/glib-2.0/include', ]) elif LINUX: include_dirs.extend([LINUX_DIR]) include_dirs.extend(common_include_dirs) include_dirs.extend([ '/usr/include/gtk-2.0', '/usr/include/glib-2.0', '/usr/include/gtk-unix-print-2.0', '/usr/include/cairo', '/usr/include/pango-1.0', '/usr/include/gdk-pixbuf-2.0', '/usr/include/atk-1.0', # Ubuntu '/usr/lib/x86_64-linux-gnu/gtk-2.0/include', '/usr/lib/x86_64-linux-gnu/gtk-unix-print-2.0', '/usr/lib/x86_64-linux-gnu/glib-2.0/include', '/usr/lib/i386-linux-gnu/gtk-2.0/include', '/usr/lib/i386-linux-gnu/gtk-unix-print-2.0', '/usr/lib/i386-linux-gnu/glib-2.0/include', # Fedora '/usr/lib64/gtk-2.0/include', '/usr/lib64/gtk-unix-print-2.0', '/usr/lib64/glib-2.0/include', '/usr/lib/gtk-2.0/include', '/usr/lib/gtk-2.0/gtk-unix-print-2.0', '/usr/lib/glib-2.0/include', ]) return include_dirs def get_library_dirs(): print("[cython_setup.py] Prepare library directories") library_dirs = [ os.path.join(CEF_BINARIES_LIBRARIES, "lib"), os.path.join(CEF_BINARIES_LIBRARIES, "lib", get_msvs_for_python(vs_prefix=True)), ] if WINDOWS: library_dirs.extend([ get_winsdk_lib(), BUILD_CEFPYTHON_APP, BUILD_CLIENT_HANDLER, BUILD_CPP_UTILS, ]) if MAC: library_dirs.append(os.path.join(CEF_BINARIES_LIBRARIES, "bin")) if MAC or LINUX: library_dirs.extend([ os.path.join(SRC_DIR, "client_handler"), os.path.join(SRC_DIR, "subprocess"), # libcefpythonapp os.path.join(SRC_DIR, "cpp_utils"), ]) return library_dirs def get_libraries(): print("[cython_setup.py] Prepare libraries") libraries = list() if WINDOWS: libraries.extend([ "libcef", "libcef_dll_wrapper_MD", "User32", "cefpython_app", "cpp_utils", "client_handler", ]) elif MAC: libraries.extend([ "c++", "c++abi", "cef_dll_wrapper", "cefpythonapp", "client_handler", "cpp_utils", ]) elif LINUX: libraries.extend([ "X11", "gobject-2.0", "glib-2.0", "gtk-x11-2.0", # CEF and CEF Python libraries "cef_dll_wrapper", "cefpythonapp", "client_handler", "cpp_utils", ]) return libraries def get_ext_modules(options): ext_modules = [Extension( name=MODULE_NAME_NOEXT, sources=["cefpython_py{pyver}.pyx".format(pyver=PYVERSION)], # Ignore the warning in the console: # > C:\Python27\lib\distutils\extension.py:133: UserWarning: # > Unknown Extension options: 'cython_directives' warnings.warn(msg) cython_directives={ # Any conversion to unicode must be explicit using .decode(). "c_string_type": "bytes", "c_string_encoding": "utf-8", }, language="c++", include_dirs=options["include_dirs"], library_dirs=options["library_dirs"], # Static libraries only. Order is important, if library A depends on B, # then B must be included before A. libraries=options["libraries"], # When you put "./" in here, loading of libcef.so will only work when # running scripts from the same directory that libcef.so resides in. # runtime_library_dirs=[ # './' # ], extra_compile_args=options["extra_compile_args"], extra_link_args=options["extra_link_args"], # Defining macros: # define_macros = [("UNICODE","1"), ("_UNICODE","1"), ] )] return ext_modules def compile_time_constants(): print("[cython_setup.py] Generate compile_time_constants.pxi") with open(os.path.join(SRC_DIR, "compile_time_constants.pxi"), "wb") as fo: contents = "# This file was generated by setup.py\n" # A way around Python 3.2 bug: UNAME_SYSNAME is not set contents += 'DEF UNAME_SYSNAME = "%s"\n' % platform.uname()[0] contents += 'DEF PY_MAJOR_VERSION = %s\n' % sys.version_info.major fo.write(contents.encode("utf-8")) if __name__ == "__main__": main() cefpython-49.0/tools/installer/000077500000000000000000000000001334103266300166035ustar00rootroot00000000000000cefpython-49.0/tools/installer/cefpython3.README.txt000066400000000000000000000004601334103266300223620ustar00rootroot000000000000001. To install CEF Python 3 package type: python setup.py install On Linux/Mac if using system Python then you need to add sudo: sudo python setup.py install 2. To run examples enter the examples/ directory, start with the hello_world.py example: cd examples/ python hello_world.py cefpython-49.0/tools/installer/cefpython3.__init__.py000066400000000000000000000040741334103266300230020ustar00rootroot00000000000000# Copyright (c) 2013 CEF Python, see the Authors file. # All rights reserved. Licensed under BSD 3-clause license. # Project website: https://github.com/cztomczak/cefpython # NOTE: Template variables like {{VERSION}} are replaced with actual # values when make_installer.py tool generates this package # installer. import os import sys import ctypes import platform __all__ = ["cefpython"] # Disabled: "wx" __version__ = "{{VERSION}}" __author__ = "The CEF Python authors" # If package was installed using PIP or setup.py then package # dir is here: # /usr/local/lib/python2.7/dist-packages/cefpython3/ # If this is a debian package then package_dir returns: # /usr/lib/pymodules/python2.7/cefpython3 # The above path consists of symbolic links to the real directory: # /usr/share/pyshared/cefpython3 package_dir = os.path.dirname(os.path.abspath(__file__)) # This loads the libcef.so library for the subprocess executable. # On Mac it works without setting library paths. os.environ["LD_LIBRARY_PATH"] = package_dir # This env variable will be returned by cefpython.GetModuleDirectory(). os.environ["CEFPYTHON3_PATH"] = package_dir # This loads the libcef library for the main python executable. # Loading library dynamically using ctypes.CDLL is required on Linux. # TODO: Check if on Linux libcef.so can be linked like on Mac. # On Mac the CEF framework dependency information is added to # the cefpython*.so module by linking to CEF framework. # The libffmpegsumo.so library does not need to be loaded here, # it may cause issues to load it here in the browser process. if platform.system() == "Linux": libcef = os.path.join(package_dir, "libcef.so") ctypes.CDLL(libcef, ctypes.RTLD_GLOBAL) # Load the cefpython module for proper Python version if sys.version_info[:2] == (2, 7): # noinspection PyUnresolvedReferences from . import cefpython_py27 as cefpython elif sys.version_info[:2] == (3, 4): # noinspection PyUnresolvedReferences from . import cefpython_py34 as cefpython else: raise Exception("Python version not supported: " + sys.version) cefpython-49.0/tools/installer/cefpython3.setup.py000066400000000000000000000232501334103266300224000ustar00rootroot00000000000000# Copyright (c) 2017 CEF Python, see the Authors file. # All rights reserved. Licensed under BSD 3-clause license. # Project website: https://github.com/cztomczak/cefpython """ cefpython3 package setup.py file. Usage: setup.py install setup.py bdist_wheel [--universal] Options: install Install package bdist_wheel Generate wheel package. Use the --universal flag when you have built cefpython modules for multiple Python versions. """ # NOTE: Template variables like {{VERSION}} are replaced with actual # values when make_installer.py tool generates this package # installer. import copy import os import platform import subprocess import sys import sysconfig # The setuptools package is not installed by default on a clean # Ubuntu. Might be also a case on Windows. Also Python Eggs # and Wheels can be created only with setuptools. try: from setuptools import setup from setuptools.command.install import install from setuptools.dist import Distribution print("[setup.py] Using setuptools") except ImportError: from distutils.core import setup from distutils.command.install import install from distutils.dist import Distribution print("[setup.py] Using distutils") if "bdist_wheel" in sys.argv: print("[setup.py] ERROR: You must install setuptools package using" " pip tool to be able to create a wheel package. Type" " 'pip install setuptools'.") sys.exit(1) # Need to know which files are executables to set appropriate execute # permissions during post_install_hook. On Windows .exe postfix will # be added to these automatically. EXECUTABLES_NOEXT = [ "cefclient", "cefsimple", "ceftests", "subprocess", ] class custom_install(install): def __init__(self, *args, **kwargs): install.__init__(self, *args, **kwargs) def run(self): install.run(self) post_install_hook() # Provide a custom install command print("[setup.py] Overload install command to enable execution of" " post install hook") cmdclass = {"install": custom_install} # Fix platform tag in wheel package if "bdist_wheel" in sys.argv: print("[setup.py] Overload bdist_wheel command to fix platform tag") from wheel.bdist_wheel import bdist_wheel class custom_bdist_wheel(bdist_wheel): def get_tag(self): tag = bdist_wheel.get_tag(self) platform_tag = sysconfig.get_platform() platform_tag = platform_tag.replace("-", "_") if platform.system() == "Linux": assert "linux" in platform_tag # "linux-x86_64" replace with "manylinux1_x86_64" platform_tag = platform_tag.replace("linux", "manylinux1") elif platform.system() == "Darwin": # For explanation of Mac platform tags, see: # http://lepture.com/en/2014/python-on-a-hard-wheel platform_tag = ("macosx_10_6_intel" ".macosx_10_9_intel.macosx_10_9_x86_64" ".macosx_10_10_intel.macosx_10_10_x86_64") tag = (tag[0], tag[1], platform_tag) return tag # Overwrite bdist_wheel command cmdclass["bdist_wheel"] = custom_bdist_wheel def main(): setup( distclass=Distribution, cmdclass=cmdclass, name="cefpython3", # No spaces here, so that it works with deb pkg version="{{VERSION}}", description="GUI toolkit for embedding a Chromium widget" " in desktop applications", long_description="CEF Python is an open source project founded" " by Czarek Tomczak in 2012 to provide python" " bindings for the Chromium Embedded Framework." " Examples of embedding CEF browser are available" " for many popular GUI toolkits including:" " wxPython, PyQt, PySide, Kivy, Panda3D, PyGTK," " PyGObject, PyGame/PyOpenGL and PyWin32.\n\n" "There are many use cases for CEF. You can embed" " a web browser control based on Chromium with" " great HTML 5 support. You can use it to create" " a HTML 5 based GUI in an application, this can" " act as a replacement for standard GUI toolkits" " like wxWidgets, Qt or GTK. You can render web" " content off-screen in application that use custom" " drawing frameworks. You can use it for automated" " testing of existing applications. You can use it" " for web scraping or as a web crawler, or other" " kind of internet bots.\n\n" "Project website:\n" "https://github.com/cztomczak/cefpython", license="BSD 3-clause", author="Czarek Tomczak", author_email="czarek.tomczak@gmail.com", url="https://github.com/cztomczak/cefpython", download_url="https://github.com/cztomczak/cefpython/releases", platforms=["{{SYSCONFIG_PLATFORM}}"], packages=["cefpython3"], # Disabled: "cefpython3.wx" package_data=get_package_data(), classifiers=[ "Development Status :: 6 - Mature", "Intended Audience :: Developers", "License :: OSI Approved :: BSD License", "Natural Language :: English", "Operating System :: MacOS :: MacOS X", "Operating System :: Microsoft :: Windows", "Operating System :: POSIX :: Linux", "Programming Language :: Python :: 2.7", "Programming Language :: Python :: 3.4", "Programming Language :: Python :: 3.5", "Programming Language :: Python :: 3.6", "Programming Language :: Python :: 3.7", "Topic :: Desktop Environment", "Topic :: Internet", "Topic :: Internet :: WWW/HTTP", "Topic :: Internet :: WWW/HTTP :: Browsers", "Topic :: Multimedia", "Topic :: Software Development :: User Interfaces", ], ) if "install" in sys.argv: print("[setup.py] OK installed") elif "bdist_wheel" in sys.argv: print("[setup.py] OK created wheel package in dist/ directory") else: print("[setup.py] Unknown command line arguments") def get_package_data(): package_data = {"cefpython3": get_package_files()} return package_data def get_package_files(relative_dir=".", recursive=False): """Finds files recursively in the cefpython3/ local directory. Includes only files and their paths are relative to the cefpython3/ local directory. Empty directories are not included.""" old_dir = None if not recursive: old_dir = os.getcwd() setup_dir = os.path.abspath(os.path.dirname(__file__)) local_pkg_dir = os.path.join(setup_dir, "cefpython3") os.chdir(local_pkg_dir) files = os.listdir(relative_dir) ret = list() for fpath in files: fpath = os.path.join(relative_dir, fpath) if os.path.isdir(fpath): ret.extend(get_package_files(relative_dir=fpath, recursive=True)) else: ret.append(fpath) if not recursive: os.chdir(old_dir) return ret def get_executables(): data = copy.copy(EXECUTABLES_NOEXT) if platform.system() == "Windows": for key, executable in enumerate(data): data[key] += ".exe" return data def post_install_hook(): """Post install hook to chmod files on Linux and Mac.""" # Nothing extra required to do on Windows if platform.system() == "Windows": print("[setup.py] post_install_hook is ignored on Windows") return # If this a wheel package generation then do not execute the hook if "bdist_wheel" in sys.argv: print("[setup.py] Ignoring post_install_hook as this is bdist_wheel") return print("[setup.py] Execute post_install_hook") # Find the installed package directory. Do not import from # the local cefpython3/ directory. print("[setup.py] Overload sys.path to facilitate finding correct" " directory for the installed package") del sys.path[0] sys.path.append("") import cefpython3 installed_package_dir = os.path.dirname(cefpython3.__file__) # Make sure that the imported package wasn't the local cefptyhon3/ # directory. print("[setup.py] Installed package directory: {dir}" .format(dir=installed_package_dir)) assert not installed_package_dir.startswith( os.path.dirname(os.path.abspath(__file__))) # Set permissions on executables print("[setup.py] Set execute permissions on executables") for executable in get_executables(): executable = os.path.join(installed_package_dir, executable) if not os.path.exists(executable): continue command = "chmod +x {executable}".format(executable=executable) print("[setup.py] {command}".format(command=command)) subprocess.call(command, shell=True) # Set write permissions on log files print("[setup.py] Set write permissions on log files") package_data = get_package_data() for pkgfile in package_data: if not pkgfile.endswith(".log"): continue logfile = os.path.join(installed_package_dir, pkgfile) command = "chmod 666 {logfile}".format(logfile=logfile) print("[setup.py] {command}".format(command=command)) subprocess.call(command, shell=True) if __name__ == "__main__": main() cefpython-49.0/tools/make_installer.py000066400000000000000000000363161334103266300201630ustar00rootroot00000000000000# Copyright (c) 2017 CEF Python, see the Authors file. # All rights reserved. Licensed under BSD 3-clause license. # Project website: https://github.com/cztomczak/cefpython """ Create setup.py package installer. Usage: make_installer.py VERSION [--wheel] [--python-tag xx] [--universal] Options: VERSION Version number eg. 50.0 --wheel Generate wheel package. Additional args for the wheel package: --python-tag xx (eg. cp27 - cpython 2.7) --universal (any python 2 or 3) """ from common import * import glob import os import re import shutil import subprocess import sys import sysconfig # Command line args VERSION = "" WHEEL = False WHEEL_ARGS = list() # Globals SETUP_DIR = "" PKG_DIR = "" # Config IGNORE_EXT = [".log", ".pyc", ".pdb", ] IGNORE_DIRS = ["__pycache__"] def main(): command_line_args() # Make sure pyinstaller build/dist directories do not exist, # otherwise they would be packed along with examples and thus # increase package size significantly. assert not os.path.exists(os.path.join(EXAMPLES_DIR, "pyinstaller", "build")) assert not os.path.exists(os.path.join(EXAMPLES_DIR, "pyinstaller", "dist")) # Setup and package directories global SETUP_DIR, PKG_DIR setup_dir_name = get_setup_installer_basename(VERSION, OS_POSTFIX2) SETUP_DIR = os.path.join(BUILD_DIR, setup_dir_name) PKG_DIR = os.path.join(SETUP_DIR, "cefpython3") # Print src and dest for file operations print("[make_installer.py] Src: {src}".format(src=ROOT_DIR)) print("[make_installer.py] Dst: {dst}".format(dst=SETUP_DIR)) # Make directories if os.path.exists(SETUP_DIR): print("[make_installer.py] Delete: {dir}" .format(dir=SETUP_DIR.replace(ROOT_DIR, ""))) shutil.rmtree(SETUP_DIR) os.makedirs(SETUP_DIR) os.makedirs(os.path.join(SETUP_DIR, "examples/")) os.makedirs(PKG_DIR) os.makedirs(os.path.join(PKG_DIR, "examples/")) # Copy files from tools/installer/ copy_tools_installer_files(SETUP_DIR, PKG_DIR) # Multiple copy operations using glob patterns copy_operations = [ (ROOT_DIR, "License"), (PKG_DIR,), (CEF_BINARIES_LIBRARIES, "*.txt"), (PKG_DIR,), (CEF_BINARIES_LIBRARIES, "bin/*"), (PKG_DIR,), (CEFPYTHON_BINARY, "*"), (PKG_DIR,), (EXAMPLES_DIR, "*"), (PKG_DIR, "examples/"), (EXAMPLES_DIR, "*"), (SETUP_DIR, "examples/"), ] perform_copy_operations(copy_operations) delete_cef_sample_apps(caller_script=__file__, bin_dir=PKG_DIR) # Linux only operations if LINUX: os.makedirs(os.path.join(SETUP_DIR, "examples", "kivy-select-boxes")) copy_operations_linux = [ (LINUX_DIR, "binaries_64bit/kivy_.py"), (SETUP_DIR, "examples/"), (LINUX_DIR, "binaries_64bit/kivy-select-boxes/*"), (SETUP_DIR, "examples/kivy-select-boxes/") ] perform_copy_operations(copy_operations_linux) # Create empty debug.log files so that package uninstalls cleanly # in case examples or CEF tests were launched. See Issue #149. create_empty_log_file(os.path.join(PKG_DIR, "debug.log")) create_empty_log_file(os.path.join(PKG_DIR, "examples/debug.log")) # Remove screenshot.png screenshot_png = os.path.join(PKG_DIR, "examples", "screenshot.png") if os.path.exists(screenshot_png): os.remove(screenshot_png) copy_cpp_extension_dependencies_issue359(PKG_DIR) print("[make_installer.py] Done. Installer package created: {setup_dir}" .format(setup_dir=SETUP_DIR)) # Optional generation of wheel package if WHEEL: print("[make_installer.py] Create Wheel package") if not len(WHEEL_ARGS): print("[make_installer.py] ERROR: you must specify flags" " eg. --python-tag cp27 or --universal") sys.exit(1) command = ("\"{python}\" setup.py bdist_wheel {wheel_args}" .format(python=sys.executable, wheel_args=" ".join(WHEEL_ARGS))) print("[make_installer.py] Run command: '{0}' in setup directory" .format(command)) subprocess.check_call(command, cwd=SETUP_DIR, shell=True) dist_dir = os.path.join(SETUP_DIR, "dist") files = glob.glob(os.path.join(dist_dir, "*.whl")) assert len(files) == 1 print("[make_installer.py] Done. Wheel package created: {0}" .format(files[0])) def command_line_args(): global VERSION, WHEEL, WHEEL_ARGS VERSION = get_version_from_command_line_args(__file__) if not VERSION: print(__doc__) sys.exit(1) for arg in sys.argv: if arg == VERSION: continue if arg == "--wheel": WHEEL = True continue if WHEEL: WHEEL_ARGS.append(arg) if WHEEL and not len(WHEEL_ARGS): print("ERROR: wheel requires additional args eg. --universal") sys.exit(1) def copy_tools_installer_files(setup_dir, pkg_dir): variables = dict() variables["VERSION"] = VERSION variables["SYSCONFIG_PLATFORM"] = sysconfig.get_platform() shutil.copy( os.path.join(INSTALLER_DIR, "cefpython3.README.txt"), os.path.join(setup_dir, "README.txt")) copy_template_file( os.path.join(INSTALLER_DIR, "cefpython3.setup.py"), os.path.join(setup_dir, "setup.py"), variables) copy_template_file( os.path.join(INSTALLER_DIR, "cefpython3.__init__.py"), os.path.join(pkg_dir, "__init__.py"), variables) def copy_template_file(src, dst, variables): """Copy file and replaces template variables in that file.""" print("[make_installer.py] Copy_t: {src} ==> {dst}" .format(src=short_src_path(src), dst=short_dst_path(dst))) with open(src, "rb") as fo: contents = fo.read().decode("utf-8") contents = replace_template_vars(contents, variables) with open(dst, "wb") as fo: fo.write(contents.encode("utf-8")) return contents def replace_template_vars(string, dictionary): """Replaces template variables like {{SOME}} in the string using the dictionary values.""" orig_string = string for key, value in dictionary.items(): string = string.replace("{{"+key+"}}", value) if string == orig_string: raise Exception("Nothing to format") if re.search(r"{{[a-zA-Z0-9_]+}}", string): raise Exception("Not all strings were formatted") return string def perform_copy_operations(operations): assert len(operations) % 2 == 0 count_ops = int(len(operations) / 2) for op_i in range(count_ops): # Refer to values by index pattern = operations[op_i*2] dst_dir = operations[op_i*2+1] # Convert tuples to lists pattern = list(pattern) dst_dir = list(dst_dir) # Join paths pattern = os.path.join(*pattern) dst_dir = os.path.join(*dst_dir) dst_dir = os.path.abspath(dst_dir) # Normalize unix slashes on Windows pattern = pattern.replace("/", os.path.sep) # dst_dir must be a directory if not os.path.isdir(dst_dir): raise Exception("Not a directory: {dst_dir}" .format(dst_dir=dst_dir)) # Is pattern a file or a directory if os.path.isfile(pattern): if is_ignored_path(pattern): raise Exception("Copy operation pattern is in ignore list:" " {pattern}".format(pattern=pattern)) print("[make_installer.py] Copy: {file} ==> {dir}" .format(file=short_src_path(pattern), dir=short_dst_path(dst_dir))) # Destination file must not exist assert not os.path.exists(os.path.join(dst_dir, os.path.basename(pattern))) shutil.copy(pattern, dst_dir) else: # pattern is a glob pattern base_dir = os.path.dirname(pattern) assert base_dir assert base_dir == os.path.abspath(base_dir) paths = glob.glob(pattern) if not len(paths): raise Exception("No paths found in: {pattern}" .format(pattern=pattern)) for path in paths: # "path" variable contains absolute path assert path == os.path.abspath(path) if os.path.isfile(path): if is_ignored_path(path): continue print("[make_installer.py] Copy: {file} ==> {dir}" .format(file=short_src_path(path), dir=short_dst_path(dst_dir))) # Destination file must not exist assert not os.path.exists( os.path.join(dst_dir, os.path.basename(path))) shutil.copy(path, dst_dir) elif os.path.isdir(path): if is_ignored_path(path): continue relative_dir = path.replace(base_dir, "") assert relative_dir[0] == os.path.sep relative_dir = relative_dir[1:] perform_copy_recursively(base_dir, relative_dir, dst_dir) else: raise Exception("Unknown path: {path}".format(path=path)) def perform_copy_recursively(base_dir, relative_dir, new_dir): real_dir = os.path.join(base_dir, relative_dir) assert os.path.exists(real_dir) and os.path.isdir(real_dir) assert os.path.exists(new_dir) and os.path.isdir(new_dir) # Create subdirectory new_subdir = os.path.join(new_dir, relative_dir) if not os.path.exists(new_subdir): print("[make_installer.py] Create: {dir}" .format(dir=short_dst_path(new_subdir))) os.makedirs(new_subdir) # List directory paths = os.listdir(real_dir) for path in paths: # "path" variable contains relative path real_path = os.path.join(real_dir, path) path = os.path.join(relative_dir, path) if os.path.isdir(real_path): if is_ignored_path(real_path): continue perform_copy_recursively(base_dir, path, new_dir) elif os.path.isfile(real_path): if is_ignored_path(real_path): continue new_file = os.path.join(new_dir, path) new_subdir = os.path.dirname(new_file) if os.path.exists(new_file): raise Exception("Path aready exists: {new_file}" .format(new_file=short_dst_path(new_file))) print("[make_installer.py] Copy: {file} ==> {dir}" .format(file=short_src_path(real_path), dir=short_dst_path(new_subdir))) shutil.copy(real_path, new_subdir) else: raise Exception("Unknown path: {path}".format(path=real_path)) def is_ignored_path(path): basename = os.path.basename(path) if basename in IGNORE_DIRS: print("[make_installer.py] Ignore: {dir}" .format(dir=short_src_path(path))) return True for ext in IGNORE_EXT: if path.endswith(ext): print("[make_installer.py] Ignore: {file}" .format(file=short_src_path(path))) return True return False def delete_files_by_pattern(pattern): assert len(pattern) > 2 # Normalize unix slashes on Windows pattern = pattern.replace("/", os.path.sep) print("[make_installer.py] Delete: {pattern}" .format(pattern=short_dst_path(pattern))) files = glob.glob(pattern) for f in files: os.remove(f) def create_empty_log_file(log_file): # Normalize unix slashes on Windows log_file = log_file.replace("/", os.path.sep) print("[make_installer.py] Create: {file}" .format(file=short_dst_path(log_file))) with open(log_file, "wb") as fo: fo.write("".encode("utf-8")) # On Linux and Mac chmod so that for cases when package is # installed using sudo. When wheel package is created it # will remember file permissions set. if LINUX or MAC: command = "chmod 666 {file}".format(file=log_file) print("[make_installer.py] {command}" .format(command=command.replace(SETUP_DIR, ""))) subprocess.check_call(command, shell=True) def copy_cpp_extension_dependencies_issue359(pkg_dir): """CEF Python module is written in Cython and is a Python C++ extension and depends on msvcpXX.dll. For Python 3.4 msvcp100.dll is required. See Issue #359. For Python 2.7 msvcp90.dll is required. Etc. These dependencies are not included with Python binaries from Python.org.""" if not WINDOWS: return windows_dir = os.environ["SYSTEMROOT"] if SYSTEM64: system32 = os.path.join(windows_dir, "SysWOW64") system64 = os.path.join(windows_dir, "System32") else: system32 = os.path.join(windows_dir, "") system64 = None if ARCH64: system = system64 else: system = system32 root_search_paths = [] # Need to check for .pyd files for all Python version, because # the builder/installer work in a way that previous cefpython # module builds for other Python versions are also included # in the package. Thus if included, msvcpxx.dll dependency is # required as well. # Python 3.4 if os.path.exists(os.path.join(pkg_dir, "cefpython_py34.pyd")): search_paths = [ # 10.00.40219.325 installs here on my system. os.path.join(system, "msvcp100.dll"), ] root_search_paths.append(search_paths) # Python 2.7 if os.path.exists(os.path.join(pkg_dir, "cefpython_py27.pyd")): if ARCH32: search_paths = [ # This runtime version is shipped with Python 2.7.15 r"c:\Windows\winsxs\x86_microsoft.vc90.crt_1fc8b3b9a1e18e3b" r"_9.0.30729.1_none_e163563597edeada\msvcp90.dll", ] else: search_paths = [ # This runtime version is shipped with Python 2.7.15 r"c:\Windows\winsxs\amd64_microsoft.vc90.crt_1fc8b3b9a1e18e3b" r"_9.0.30729.1_none_99b61f5e8371c1d4\msvcp90.dll", ] root_search_paths.append(search_paths) assert len(root_search_paths) for search_paths in root_search_paths: found = False for path in search_paths: if os.path.exists(path): shutil.copy(path, pkg_dir) found = True if not found: raise Exception("C++ extension dll dependency not found." " Search paths: {0}" .format(", ".join(search_paths))) def short_src_path(path): # Very long: \build\cef55_3.2883.1553.g80bd606_win32\ find = os.path.basename(CEF_BINARIES_LIBRARIES) if len(find) > 12: path = path.replace(find, find[:12] + "*") path = path.replace(ROOT_DIR, "") return path def short_dst_path(path): path = path.replace(SETUP_DIR, "") return path if __name__ == "__main__": main() cefpython-49.0/tools/requirements.py000066400000000000000000000010551334103266300177040ustar00rootroot00000000000000""" Installs Python dependencies using the pip tool. See the requirements.txt file. python -m pip install --upgrade -r ../tools/requirements.txt """ from common import * import subprocess def main(): args = [] if sys.executable.startswith("/usr/"): args.append("sudo") requirements = os.path.join(TOOLS_DIR, "requirements.txt") args.extend([sys.executable, "-m", "pip", "install", "--upgrade", "-r", requirements]) retcode = subprocess.call(args) sys.exit(retcode) if __name__ == "__main__": main() cefpython-49.0/tools/requirements.txt000066400000000000000000000000711334103266300200700ustar00rootroot00000000000000Cython == 0.25.2 docopt >= 0.6.2 setuptools wheel Pillow cefpython-49.0/tools/run_examples.py000066400000000000000000000152041334103266300176640ustar00rootroot00000000000000# Copyright (c) 2017 CEF Python, see the Authors file. # All rights reserved. Licensed under BSD 3-clause license. # Project website: https://github.com/cztomczak/cefpython """ Run all examples that can be run on current configuration and display a summary at the end. Note on GTK 2 / GTK 3 on Windows: Installing both PyGTK and PyGI on Windows will cause errors. You can install only one of these packages. """ from common import * import importlib import os import subprocess import sys def main(): os.chdir(EXAMPLES_DIR) # When importing Kivy package there can't be any flags unknown to Kivy, # use sys.argv.remove to remove them. kivy_flag = False if "--kivy" in sys.argv: sys.argv.remove("--kivy") kivy_flag = True hello_world_flag = False if "--hello-world" in sys.argv: sys.argv.remove("--hello-world") hello_world_flag = True packages = check_installed_packages() examples = list() examples.append("hello_world.py") examples.append("tutorial.py") examples.append("screenshot.py") succeeded = list() failed = list() passed = list() # wxpython if packages["wx"]: examples.append("wxpython.py") else: print("[run_examples.py] PASS: wxpython.py (wxPython not installed)") passed.append("wxpython.py") # gtk2 if packages["gtk"]: examples.append("gtk2.py") if LINUX: examples.append("gtk2.py --message-loop-cef") else: print("[run_examples.py] PASS: gtk2.py (Gtk 2 not installed") passed.append("gtk2.py") # gtk3 """ if LINUX: # Broken on Linux (Issue #261) print("[run_examples.py] PASS: gtk3.py (Issue #261)") passed.append("gtk3.py (Issue #261)") """ if MAC: # Crashes on Mac (Issue #310) print("[run_examples.py] PASS: gtk3.py (Issue #310)") passed.append("gtk3.py (Issue #310)") elif packages["gi"]: examples.append("gtk3.py") else: print("[run_examples.py] PASS: gtk3.py (Gtk 3 not installed)") passed.append("gtk3.py") # pyqt4 if LINUX: print("[run_examples.py] PASS: qt.py pyqt4 (Issue #452)") passed.append("qt.py pyqt4 (Issue #452)") elif packages["PyQt4"]: examples.append("qt.py pyqt4") else: print("[run_examples.py] PASS: qt.py pyqt4 (PyQt4 not installed)") passed.append("qt.py pyqt4") # pyqt5 if packages["PyQt5"]: examples.append("qt.py pyqt5") else: print("[run_examples.py] PASS: qt.py pyqt5 (PyQt5 not installed)") passed.append("qt.py pyqt5") # pyside if LINUX: print("[run_examples.py] PASS: qt.py pyside (Issue #452)") passed.append("qt.py pyside (Issue #452)") elif packages["PySide"]: examples.append("qt.py pyside") else: print("[run_examples.py] PASS: qt.py pyside (PySide not installed)") passed.append("qt.py pyside") # tkinter if MAC: # This example often crashes on Mac (Issue #309) print("[run_examples.py] PASS: tkinter_.py (Issue #309)") passed.append("tkinter_.py (Issue #309)") elif WINDOWS and sys.version_info.major == 2: print("[run_examples.py] PASS: tkinter_.py (Issue #441)") passed.append("tkinter_.py (Issue #441)") elif packages["tkinter"] or packages["Tkinter"]: examples.append("tkinter_.py") else: print(["run_examples.py] PASS: tkinter_.py (tkinter not installed)"]) passed.append("tkinter_.py") if LINUX and packages["kivy"] and packages["gtk"]: # When --kivy flag passed run only Kivy example if kivy_flag: examples = list() passed = list() examples.append("{linux_dir}/binaries_64bit/kivy_.py" .format(linux_dir=LINUX_DIR)) # When --hello-world flag is passed run only hello_world.py example if hello_world_flag: examples = list() passed = list() examples.append("hello_world.py") # Run all for example in examples: print("[run_examples.py] Running '{example}'..." .format(example=example)) command = "\"{python}\" {example}".format(python=sys.executable, example=example) ret = os.system(command) if ret == 0: succeeded.append(example) else: print("[run_examples.py] ERROR while running example: {example}" .format(example=example)) failed.append(example) # Summary summary = "" for example in succeeded: summary += " OK {example}{nl}"\ .format(example=example, nl=os.linesep) for example in failed: summary += " ERROR {example}{nl}"\ .format(example=example, nl=os.linesep) for example in passed: summary += " PASS {example}{nl}"\ .format(example=example, nl=os.linesep) summary = summary[:-(len(os.linesep))] print("[run_examples.py] SUMMARY:") print(summary.format()) # OK or error message passed_msg = "" if passed: passed_msg = ". Passed: {passed}.".format(passed=len(passed)) if len(failed): print("[run_examples.py] ERRORS({failed}) while running examples" "{passed_msg}" .format(failed=len(failed), passed_msg=passed_msg)) sys.exit(1) else: print("[run_examples.py] OK({succeeded}){passed_msg}" .format(succeeded=len(succeeded), passed_msg=passed_msg)) def check_installed_packages(): packages = { "gtk": False, "kivy": False, "PyQt4": False, "PyQt5": False, "PySide": False, "tkinter": False, "Tkinter": False, "wx": False, } for package in packages: try: if package == "PyQt5": # Strange issue on Mac, PyQt5 is an empty built-in module from PyQt5 import QtGui else: importlib.import_module(package) packages[package] = True except ImportError: packages[package] = False packages["gi"] = check_gi_installed() return packages def check_gi_installed(): # Cannot import both gtk and gi in the same script, thus # need another way of checking if gi package is installed. code = subprocess.call([sys.executable, "-c", "import gi"]) if code != 0: print("[run_examples.py] gi module not found (PyGI / GTK 3).") print(" Import error above can be safely ignored.") return True if code == 0 else False if __name__ == "__main__": main() cefpython-49.0/tools/run_snippets.py000066400000000000000000000032331334103266300177120ustar00rootroot00000000000000# Copyright (c) 2018 CEF Python, see the Authors file. # All rights reserved. Licensed under BSD 3-clause license. # Project website: https://github.com/cztomczak/cefpython """ Run all snippets from the examples/snippets/ directory and display a summary at the end. """ from common import * import glob import os import subprocess import sys def main(): # Iterate over all snippets snippets_iter = glob.glob(os.path.join(SNIPPETS_DIR, "*.py")) succeeded = [] failed = [] for snippet in snippets_iter: print("[run_snippets.py] Running '{snippet}'..." .format(snippet=os.path.basename(snippet))) retcode = subprocess.call([sys.executable, snippet]) if retcode == 0: succeeded.append(os.path.basename(snippet)) else: print("[run_snippets.py] ERROR while running snippet: {snippet}" .format(snippet=snippet)) failed.append(os.path.basename(snippet)) # Print summary summary = "" for snippet in succeeded: summary += " OK {snippet}{nl}"\ .format(snippet=snippet, nl=os.linesep) for snippet in failed: summary += " ERROR {snippet}{nl}"\ .format(snippet=snippet, nl=os.linesep) summary = summary[:-(len(os.linesep))] print("[run_snippets.py] SUMMARY:") print(summary.format()) if len(failed): print("[run_snippets.py] ERRORS ({failed}) while running snippets" .format(failed=len(failed))) sys.exit(1) else: print("[run_snippets.py] OK ({succeeded})" .format(succeeded=len(succeeded))) if __name__ == "__main__": main() cefpython-49.0/tools/toc.py000066400000000000000000000142041334103266300157460ustar00rootroot00000000000000# Copyright (c) 2016 CEF Python, see the Authors file. # All rights reserved. Licensed under BSD 3-clause license. # Project website: https://github.com/cztomczak/cefpython """Create Table of contents (TOC) for a single .md file or for a directory. Usage: toc.py FILE toc.py DIR To ignore file when generating TOC, put an empty line just before H1. """ import os import sys import re import glob API_DIR = os.path.join(os.path.dirname(__file__), "..", "api") def main(): """Main entry point.""" if len(sys.argv) == 1: sys.argv.append(API_DIR) if (len(sys.argv) == 1 or "-h" in sys.argv or "--help" in sys.argv or "/?" in sys.argv): print(__doc__.strip()) sys.exit(0) arg1 = sys.argv[1] if os.path.isdir(arg1): (modified, warnings) = toc_dir(arg1) if modified: print("Done") else: print("No changes to TOCs. Files not modified.") else: (modified, warnings) = toc_file(arg1) if modified: print("Done") else: print("No changes to TOC. File not modified.") if warnings: print("Warnings: "+str(warnings)) def toc_file(file_): """A single file was passed to doctoc. Return bool whether modified and the number of warnings.""" with open(file_, "rb") as fo: orig_contents = fo.read().decode("utf-8", "ignore") # Fix new lines just in case. Not using Python's "rU", # it is causing strange issues. orig_contents = re.sub(r"(\r\n|\r|\n)", os.linesep, orig_contents) (tocsize, contents, warnings) = create_toc(orig_contents, file_) if contents != orig_contents: with open(file_, "wb") as fo: fo.write(contents.encode("utf-8")) tocsize_str = ("TOC size: "+str(tocsize) if tocsize else "TOC removed") print("Modified: "+file_+" ("+tocsize_str+")") return True, warnings else: return False, warnings def toc_dir(dir_): """A directory was passed to doctoc. Return bool whether any file was modified and the number of warnings.""" files = glob.glob(os.path.join(dir_, "*.md")) modified_any = False warnings = 0 for file_ in files: if "API-categories.md" in file_ or "API-index.md" in file_: continue (modified, warnings) = toc_file(file_) if not modified_any: modified_any = True if modified else False return modified_any, warnings def create_toc(contents, file_): """Create or modify TOC for the document contents.""" match = re.search(r"Table of contents:%s(\s*\* \[[^\]]+\]\([^)]+\)%s){2,}" % (os.linesep, os.linesep), contents) oldtoc = match.group(0) if match else None (tocsize, toc, warnings) = parse_headings(contents, file_) if oldtoc: if not toc: # If toc removed need to remove an additional new lines # that was inserted after toc. contents = contents.replace(oldtoc+os.linesep, toc) else: contents = contents.replace(oldtoc, toc) elif tocsize: # Insert after H1, but if there is text directly after H1 # then insert after that text. first_line = False if not re.search(r"^#\s+", contents): print("WARNING: missing H1 on first line. Ignoring file: "+file_) return 0, contents, warnings+1 lines = contents.splitlines() contents = "" toc_inserted = False for line in lines: if not first_line: first_line = True else: if not toc_inserted and re.search(r"^(##|###)", line): contents = contents[0:-len(os.linesep)] contents += os.linesep + toc + os.linesep + os.linesep toc_inserted = True contents += line + os.linesep # Special case for README.md - remove Quick Links toc for subheadings re_find = (r" \* \[Docs\]\(#docs\)[\r\n]+" r" \* \[API categories\]\(#api-categories\)[\r\n]+" r" \* \[API index\]\(#api-index\)\r?\n?") contents = re.sub(re_find, "", contents) return tocsize, contents, warnings def parse_headings(raw_contents, file_): """Parse contents looking for headings. Return a tuple with number of TOC elements, the TOC fragment and the number of warnings.""" # Remove code blocks parsable_contents = re.sub(r"```[\s\S]+?```", "", raw_contents) # Parse H1,H2,H3 headings = re.findall(r"^(#|##|###)\s+(.*)", parsable_contents, re.MULTILINE) toc = "Table of contents:" + os.linesep tocsize = 0 warnings = 0 count_h1 = 0 count_h2 = 0 for heading in headings: level = heading[0] level = (1 if level == "#" else 2 if level == "##" else 3 if level == "###" else None) assert level is not None title = heading[1].strip() if level == 1: count_h1 += 1 if count_h1 > 1: warnings += 1 print("WARNING: found more than one H1 in "+file_) continue if level == 2: count_h2 += 1 hash_ = headinghash(title) indent = "" if level == 3: if count_h2: # If there was no H2 yet then H3 shouldn't have indent. indent = " " * 2 toc += indent + "* [%s](#%s)" % (title, hash_) + os.linesep tocsize += 1 if tocsize <= 1: # If there is only one H2/H3 heading do not create TOC. toc = "" tocsize = 0 return tocsize, toc, warnings def headinghash(title): """Get a link hash for a heading H1,H2,H3.""" hash_ = title.lower() hash_ = hash_.replace(" - ", "specialcase1") hash_ = hash_.replace(" / ", "specialcase2") hash_ = re.sub(r"[^a-z0-9_\- ]+", r"", hash_) hash_ = hash_.replace(" ", "-") hash_ = re.sub(r"[-]+", r"-", hash_) hash_ = re.sub(r"-$", r"", hash_) hash_ = hash_.replace("specialcase1", "---") hash_ = hash_.replace("specialcase2", "--") return hash_ if __name__ == "__main__": main() cefpython-49.0/unittests/000077500000000000000000000000001334103266300155105ustar00rootroot00000000000000cefpython-49.0/unittests/_common.py000066400000000000000000000222031334103266300175100ustar00rootroot00000000000000# Copyright (c) 2018 CEF Python, see the Authors file. # All rights reserved. Licensed under BSD 3-clause license. # Project website: https://github.com/cztomczak/cefpython from cefpython3 import cefpython as cef import base64 import os import platform import sys import time # Platforms SYSTEM = platform.system().upper() if SYSTEM == "DARWIN": SYSTEM = "MAC" WINDOWS = SYSTEM if SYSTEM == "WINDOWS" else False LINUX = SYSTEM if SYSTEM == "LINUX" else False MAC = SYSTEM if SYSTEM == "MAC" else False # To show the window for an extended period of time increase this number. MESSAGE_LOOP_RANGE = 200 # each iteration is 0.01 sec MAIN_BROWSER_ID = 1 POPUP_BROWSER_ID = 2 g_subtests_ran = 0 g_js_code_completed = False g_on_load_end_callbacks = [] def subtest_message(message): global g_subtests_ran g_subtests_ran += 1 print(str(g_subtests_ran) + ". " + message) sys.stdout.flush() def show_test_summary(pyfile): print("\nRan " + str(g_subtests_ran) + " sub-tests in " + os.path.basename(pyfile)) def run_message_loop(): # Run message loop for some time. # noinspection PyTypeChecker for i in range(MESSAGE_LOOP_RANGE): cef.MessageLoopWork() time.sleep(0.01) subtest_message("cef.MessageLoopWork() ok") def do_message_loop_work(work_loops): # noinspection PyTypeChecker for i in range(work_loops): cef.MessageLoopWork() time.sleep(0.01) def on_load_end(callback, *args): global g_on_load_end_callbacks g_on_load_end_callbacks.append([callback, args]) def js_code_completed(): """Sometimes window.onload can execute before javascript bindings are ready if the document loads very fast. When setting javascript bindings it can take some time, because these bindings are sent via IPC messaging to the Renderer process.""" global g_js_code_completed assert not g_js_code_completed g_js_code_completed = True subtest_message("js_code_completed() ok") def check_auto_asserts(test_case, objects): # Check if js code completed test_case.assertTrue(g_js_code_completed) # Automatic check of asserts in handlers and in external for obj in objects: test_for_True = False # Test whether asserts are working correctly for key, value in obj.__dict__.items(): if key == "test_for_True": test_for_True = True continue if "_True" in key: test_case.assertTrue(value, "Check assert: " + obj.__class__.__name__ + "." + key) subtest_message(obj.__class__.__name__ + "." + key.replace("_True", "") + " ok") elif "_False" in key: test_case.assertFalse(value, "Check assert: " + obj.__class__.__name__ + "." + key) subtest_message(obj.__class__.__name__ + "." + key.replace("_False", "") + " ok") test_case.assertTrue(test_for_True) class DisplayHandler(object): def __init__(self, test_case): self.test_case = test_case # Asserts for True/False will be checked just before shutdown self.test_for_True = True # Test whether asserts are working correctly self.javascript_errors_False = False self.OnConsoleMessage_True = False def OnConsoleMessage(self, message, **_): if "error" in message.lower() or "uncaught" in message.lower(): self.javascript_errors_False = True raise Exception("Javascript error: " + message) else: # Check whether messages from javascript are coming self.OnConsoleMessage_True = True subtest_message(message) def close_popup(global_handler, browser): browser.CloseBrowser() global_handler.PopupClosed_True = True # Test developer tools popup main_browser = cef.GetBrowserByIdentifier(MAIN_BROWSER_ID) main_browser.ShowDevTools() cef.PostDelayedTask(cef.TID_UI, 1500, close_devtools, global_handler) cef.PostDelayedTask(cef.TID_UI, 500, main_browser.SetFocus, True) def close_devtools(global_handler): main_browser = cef.GetBrowserByIdentifier(MAIN_BROWSER_ID) main_browser.CloseDevTools() subtest_message("DevTools popup ok") class GlobalHandler(object): def __init__(self, test_case): self.test_case = test_case # Asserts for True/False will be checked just before shutdown self.test_for_True = True # Test whether asserts are working correctly self.OnAfterCreatedMain_True = False if "main_test" in test_case.id(): self.OnAfterCreatedPopup_True = False self.PopupClosed_True = False def _OnAfterCreated(self, browser, **_): # For asserts that are checked automatically before shutdown its # values should be set first, so that when other asserts fail # (the ones called through the test_case member) they are reported # correctly. if not self.OnAfterCreatedMain_True: # First call for main browser. # browser.GetUrl() returns empty at this moment. self.OnAfterCreatedMain_True = True self.test_case.assertEqual(browser.GetIdentifier(), MAIN_BROWSER_ID) self.test_case.assertFalse(browser.IsPopup()) else: # Second call for implicit popup browser opened via js. # Should execute only for main test. # Should not execute for DevTools window. assert "main_test" in self.test_case.id() assert not self.OnAfterCreatedPopup_True self.OnAfterCreatedPopup_True = True self.test_case.assertEqual(browser.GetIdentifier(), POPUP_BROWSER_ID) # browser.GetUrl() returns empty at this moment. self.test_case.assertTrue(browser.IsPopup()) if WINDOWS: cef.WindowUtils.SetTitle(browser, "Popup test") # Close the popup browser after 250 ms cef.PostDelayedTask(cef.TID_UI, 250, close_popup, self, browser) class LoadHandler(object): def __init__(self, test_case, datauri): self.test_case = test_case self.datauri = datauri self.frame_source_visitor = None # Asserts for True/False will be checked just before shutdown self.test_for_True = True # Test whether asserts are working correctly self.OnLoadStart_True = False self.OnLoadEnd_True = False self.FrameSourceVisitor_True = False # self.OnLoadingStateChange_Start_True = False # FAILS self.OnLoadingStateChange_End_True = False def OnLoadStart(self, browser, frame, **_): self.test_case.assertFalse(self.OnLoadStart_True) self.OnLoadStart_True = True self.test_case.assertEqual(browser.GetUrl(), frame.GetUrl()) self.test_case.assertEqual(browser.GetUrl(), self.datauri) def OnLoadEnd(self, browser, frame, http_code, **_): # OnLoadEnd should be called only once self.test_case.assertFalse(self.OnLoadEnd_True) self.OnLoadEnd_True = True self.test_case.assertEqual(http_code, 200) self.frame_source_visitor = FrameSourceVisitor(self, self.test_case) frame.GetSource(self.frame_source_visitor) browser.ExecuteJavascript("print('LoadHandler.OnLoadEnd() ok')") subtest_message("Executing callbacks registered with on_load_end()") global g_on_load_end_callbacks for callback_data in g_on_load_end_callbacks: callback_data[0](*callback_data[1]) del g_on_load_end_callbacks def OnLoadingStateChange(self, browser, is_loading, can_go_back, can_go_forward, **_): if is_loading: # TODO: this test fails, looks like OnLoadingStaetChange with # is_loading=False is being called very fast, before # OnLoadStart and before client handler is set by calling # browser.SetClientHandler(). # SOLUTION: allow to set OnLoadingStateChange through # SetGlobalClientCallback similarly to _OnAfterCreated(). # self.test_case.assertFalse(self.OnLoadingStateChange_Start_True) # self.OnLoadingStateChange_Start_True = True pass else: self.test_case.assertFalse(self.OnLoadingStateChange_End_True) self.OnLoadingStateChange_End_True = True self.test_case.assertEqual(browser.CanGoBack(), can_go_back) self.test_case.assertEqual(browser.CanGoForward(), can_go_forward) class FrameSourceVisitor(object): """Visitor for Frame.GetSource().""" def __init__(self, load_handler, test_case): self.load_handler = load_handler self.test_case = test_case def Visit(self, value): self.test_case.assertFalse(self.load_handler.FrameSourceVisitor_True) self.load_handler.FrameSourceVisitor_True = True self.test_case.assertIn("747ef3e6011b6a61e6b3c6e54bdd2dee", value) cefpython-49.0/unittests/_test_runner.py000066400000000000000000000250251334103266300205750ustar00rootroot00000000000000# Copyright (c) 2016 CEF Python, see the Authors file. # All rights reserved. Licensed under BSD 3-clause license. # Project website: https://github.com/cztomczak/cefpython """Run unit tests. With no arguments all tests are run. Read notes below. Usage: _test_runner.py [--debug] [FILE | _TESTCASE] Options: --debug Enable debug info FILE Run tests from single file _TESTCASE Test cases matching pattern to run eg "file.TestCase". Calling with this argument is for internal use only. It has side effects, so don't use it. See comments. Notes: - Files starting with "_" are ignored - If test case name contains "IsolatedTest" word then this test case will be run using a new instance of Python interpreter. In such case instead of calling "unittest.main()" use this code: "import _runner; _runner.main(os.path.basename(__file__))". - Tested only with TestCase objects. TestSuite usage is untested. """ import unittest import os import platform import sys from os.path import dirname, realpath import re import subprocess # Command line args CUSTOM_CMDLINE_ARG = "" def main(file_arg=""): # type: (str) -> None """Main entry point.""" # Set working dir to script's current os.chdir(dirname(realpath(__file__))) # Script arguments testcase_arg = "" if len(sys.argv) > 1 and sys.argv[1].startswith("--"): # Will allow to pass custom args like --debug to isolated tests # (main_test.py for example). global CUSTOM_CMDLINE_ARG CUSTOM_CMDLINE_ARG = sys.argv[1] elif len(sys.argv) > 1: if ".py" in sys.argv[1]: file_arg = sys.argv[1] else: testcase_arg = sys.argv[1] # Run tests runner = TestRunner() if testcase_arg: runner.run_testcase(testcase_arg) elif file_arg: runner.run_file(file_arg) else: runner.run_all() class TestRunner(object): """Customized test runner.""" ran = 0 errors = 0 failures = 0 cefpython_version = "-unknown-" _suites = None # type: unittest.TestSuite _isolated_suites = None # type: unittest.TestSuite _import_errors = None # type: unittest.TestSuite def _reset_state(self): # type: () -> None """Reset TestRunner state before test discovery.""" self.ran = 0 self.errors = 0 self.failures = 0 self._suites = unittest.TestSuite() self._isolated_suites = unittest.TestSuite() self._import_errors = unittest.TestSuite() # ---- Public methods def run_testcase(self, testcase): # type: (str) -> None """Run single test case eg 'foo.BarTest'. This is needed to run single testcase that is marked as IsolatedTest.""" self._discover("[!_]*.py", testcase) assert not self._count_suites(self._isolated_suites) if not self._count_suites(self._suites): print("[_test_runner.py] ERROR: test case not found") sys.exit(1) # Import errors found during discovery are ignored self._run_suites(self._suites) self._exit() def run_file(self, filename): # type: (str) -> None """Run test cases from a specific file. This is needed so that you can use _runner.main() in isolated tests.""" self._discover(filename) self._run_discovered_suites() def run_all(self): # type: () -> None """Run all tests from current directory.""" self._discover("[!_]*.py") self._run_discovered_suites() # ---- Private methods def _run_discovered_suites(self): # type: () -> None """Run both normal and isolated suites.""" suites = self._merge_suites(self._import_errors, self._suites) self._run_suites(suites) self._run_suites_in_isolation(self._isolated_suites) self._print_summary() def _run_suites(self, suites): # type: (unittest.TestSuite) -> None """Run suites.""" if not self._count_suites(suites): return runner = unittest.TextTestRunner(verbosity=2, descriptions=True, buffer=False) # Update "ran" before running suites, because after ran # counting them doesn't work (Python 3 issue). self.ran += self._count_suites(suites) result = runner.run(suites) self.errors += len(result.errors) self.failures += len(result.failures) def _run_suites_in_isolation(self, suites): # type: (unittest.TestSuite) -> None """Run each suite using new instance of Python interpreter.""" if not self._count_suites(suites): return for suite in suites: # Find test case identifier testcase_id = "" for testcase in suite: testcase_id = testcase.id() break # Run test using new instance of Python interpreter try: output = subprocess.check_output( [sys.executable, "_test_runner.py", testcase_id, CUSTOM_CMDLINE_ARG], stderr=subprocess.STDOUT) exit_code = 0 except subprocess.CalledProcessError as exc: output = exc.output exit_code = exc.returncode if type(output) != str: output = output.decode("utf-8", errors="replace") # Fetch number of sub-tests ran from output match = re.search(r"^Ran (\d+) sub-tests in \w+", output, re.MULTILINE) if match: self.ran += int(match.group(1)) # Fetch CEF Python version from output match = re.search(r"^CEF Python (\d+\.\d+)", output, re.MULTILINE) if match: self.cefpython_version = match.group(1) # Write original output sys.stdout.write(output) # If tests failed parse output for errors/failures if exit_code: if output: lines = output.splitlines() lastline = lines[len(lines)-1] match = re.search(r"failures=(\d+)", lastline) if match: self.failures += int(match.group(1)) match = re.search(r"errors=(\d+)", lastline) if match: self.errors += int(match.group(1)) if not self.errors and not self.failures: self.errors += 1 elif output: # Test case still might have failed and unittest would not # detect this. For example when assertion fails # in ClientHandler in core_test.py . if "Traceback (most recent call last)" in output\ or "AssertionError" in output: self.errors += 1 # Update ran self.ran += self._count_suites(suites) def _count_suites(self, suites): # type: (unittest.TestSuite) -> int count = 0 for suite in suites: if isinstance(suite, unittest.TestSuite): for _ in suite: count += 1 return count def _merge_suites(self, suites1, suites2): # type: (unittest.TestSuite, unittest.TestSuite) -> unittest.TestSuite merged = unittest.TestSuite() for suite in suites1: merged.addTest(suite) for suite in suites2: merged.addTest(suite) return merged def _discover(self, pattern, testcase_name=""): # type: (str, str) -> None """Test discovery using glob pattern from arg or main().""" self._reset_state() loader = unittest.TestLoader() discovered_suite = loader.discover(start_dir=".", pattern=pattern) for level1_suite in discovered_suite: for level2_suite in level1_suite: if isinstance(level2_suite, unittest.TestSuite): for testcase_obj in level2_suite: if testcase_name: if re.match(re.escape(testcase_name), testcase_obj.id()): self._suites.addTest(level2_suite) break elif "IsolatedTest" in testcase_obj.id(): self._isolated_suites.addTest(level2_suite) break else: self._suites.addTest(level2_suite) break elif not testcase_name: # unittest.loader.ModuleImportFailure # Warning: If there is an import error in a file # containing a test case that is being run then there # won't be any error displayed about it when running # that single test case. However running a single test # case is for internal use only, to run test cases in # isolation with a new instance of Python interpreter. # Import errors will always be showed when running all # tests or tests from file. self._import_errors.addTest(level2_suite) def _print_summary(self): # type: () -> None """Print summary and exit.""" print("-"*70) print("[_test_runner.py] CEF Python {ver}" .format(ver=self.cefpython_version)) print("[_test_runner.py] Python {ver} {arch}" .format(ver=platform.python_version(), arch=platform.architecture()[0])) print("[_test_runner.py] Ran {ran} tests in total" .format(ran=self.ran)) if self.errors or self.failures: failed_str = "[_test_runner.py] FAILED (" if self.failures: failed_str += ("failures="+str(self.failures)) if self.errors: if self.failures: failed_str += ", " failed_str += ("errors="+str(self.errors)) failed_str += ")" print(failed_str) else: print("[_test_runner.py] OK all unit tests succeeded") self._exit() def _exit(self): # type: () -> None """Exit with appropriate exit code.""" if self.errors or self.failures: sys.exit(1) else: sys.exit(0) if __name__ == "__main__": main() cefpython-49.0/unittests/isolated_test.py000066400000000000000000000017351334103266300207330ustar00rootroot00000000000000# Copyright (c) 2016 CEF Python, see the Authors file. # All rights reserved. Licensed under BSD 3-clause license. # Project website: https://github.com/cztomczak/cefpython """ Test isolated test. Isolated tests are run each using a new instance of Python interpreter. They also implement some unique features for our use case. See main_test.py for some real tests. """ import unittest # noinspection PyUnresolvedReferences import _test_runner from os.path import basename # Globals g_count = 0 class IsolatedTest1(unittest.TestCase): def test_isolated1(self): global g_count g_count += 1 self.assertEqual(g_count, 1) def test_isolated2(self): global g_count g_count += 1 self.assertEqual(g_count, 2) class IsolatedTest2(unittest.TestCase): def test_isolated3(self): global g_count g_count += 1 self.assertEqual(g_count, 1) if __name__ == "__main__": _test_runner.main(basename(__file__)) cefpython-49.0/unittests/main_test.py000066400000000000000000000254071334103266300200550ustar00rootroot00000000000000# Copyright (c) 2016 CEF Python, see the Authors file. # All rights reserved. Licensed under BSD 3-clause license. # Project website: https://github.com/cztomczak/cefpython """General testing of CEF Python.""" import unittest # noinspection PyUnresolvedReferences import _test_runner from _common import * from cefpython3 import cefpython as cef import glob import os import sys g_datauri_data = """

Main test

""" g_datauri = cef.GetDataUrl(g_datauri_data) class MainTest_IsolatedTest(unittest.TestCase): def test_main(self): """Main entry point. All the code must run inside one single test, otherwise strange things happen.""" print("") print("CEF Python {ver}".format(ver=cef.__version__)) print("Python {ver}".format(ver=sys.version[:6])) # Test initialization of CEF settings = { "debug": False, "log_severity": cef.LOGSEVERITY_ERROR, "log_file": "", } if not LINUX: # On Linux you get a lot of "X error received" messages # from Chromium's "x11_util.cc", so do not show them. settings["log_severity"] = cef.LOGSEVERITY_WARNING if "--debug" in sys.argv: settings["debug"] = True settings["log_severity"] = cef.LOGSEVERITY_INFO if "--debug-warning" in sys.argv: settings["debug"] = True settings["log_severity"] = cef.LOGSEVERITY_WARNING cef.Initialize(settings) subtest_message("cef.Initialize() ok") # High DPI on Windows if WINDOWS: self.assertIsInstance(cef.DpiAware.GetSystemDpi(), tuple) window_size = cef.DpiAware.CalculateWindowSize(800, 600) self.assertIsInstance(window_size, tuple) self.assertGreater(window_size[0], 0) # It seems that in v49 Chromium sets process DPI awareness # by default, so IsProcessDpiAware returns True. # self.assertFalse(cef.DpiAware.IsProcessDpiAware()) subtest_message("cef.DpiAware ok") # Global handler global_handler = GlobalHandler(self) cef.SetGlobalClientCallback("OnAfterCreated", global_handler._OnAfterCreated) subtest_message("cef.SetGlobalClientCallback() ok") # Create browser browser_settings = { "inherit_client_handlers_for_popups": False, } browser = cef.CreateBrowserSync(url=g_datauri, settings=browser_settings) self.assertIsNotNone(browser, "Browser object") browser.SetFocus(True) subtest_message("cef.CreateBrowserSync() ok") # Client handlers client_handlers = [LoadHandler(self, g_datauri), DisplayHandler(self)] for handler in client_handlers: browser.SetClientHandler(handler) subtest_message("browser.SetClientHandler() ok") # Javascript bindings external = External(self) bindings = cef.JavascriptBindings( bindToFrames=False, bindToPopups=False) bindings.SetFunction("js_code_completed", js_code_completed) bindings.SetFunction("test_function", external.test_function) bindings.SetProperty("test_property1", external.test_property1) bindings.SetProperty("test_property2", external.test_property2) # Property with a function value can also be bound. CEF Python # supports passing functions as callbacks when called from # javascript, and as a side effect any value and in this case # a property can also be a function. bindings.SetProperty("test_property3_function", external.test_property3_function) bindings.SetProperty("cefpython_version", cef.GetVersion()) bindings.SetObject("external", external) browser.SetJavascriptBindings(bindings) subtest_message("browser.SetJavascriptBindings() ok") # Cookie manager self.assertIsInstance(cef.CookieManager.CreateManager(path=""), cef.PyCookieManager) self.assertIsInstance(cef.CookieManager.GetGlobalManager(), cef.PyCookieManager) subtest_message("cef.CookieManager ok") # Window Utils if WINDOWS: hwnd = 1 # When using 0 getting issues with OnautoResize self.assertFalse(cef.WindowUtils.IsWindowHandle(hwnd)) cef.WindowUtils.OnSetFocus(hwnd, 0, 0, 0) cef.WindowUtils.OnSize(hwnd, 0, 0, 0) cef.WindowUtils.OnEraseBackground(hwnd, 0, 0, 0) cef.WindowUtils.GetParentHandle(hwnd) cef.WindowUtils.SetTitle(browser, "Main test") subtest_message("cef.WindowUtils ok") elif LINUX: cef.WindowUtils.InstallX11ErrorHandlers() subtest_message("cef.WindowUtils ok") elif MAC: hwnd = 0 cef.WindowUtils.GetParentHandle(hwnd) cef.WindowUtils.IsWindowHandle(hwnd) subtest_message("cef.WindowUtils ok") # Run message loop run_message_loop() # Make sure popup browser was destroyed self.assertIsInstance(cef.GetBrowserByIdentifier(MAIN_BROWSER_ID), cef.PyBrowser) self.assertIsNone(cef.GetBrowserByIdentifier(POPUP_BROWSER_ID)) subtest_message("cef.GetBrowserByIdentifier() ok") # Close browser and clean reference browser.CloseBrowser(True) del browser subtest_message("browser.CloseBrowser() ok") # Give it some time to close before checking asserts # and calling shutdown. do_message_loop_work(25) # noinspection PyTypeChecker check_auto_asserts(self, [] + client_handlers + [global_handler, external]) # Test shutdown of CEF cef.Shutdown() subtest_message("cef.Shutdown() ok") # Display summary show_test_summary(__file__) sys.stdout.flush() class External(object): """Javascript 'window.external' object.""" def __init__(self, test_case): self.test_case = test_case # Test binding properties to the 'window' object. self.test_property1 = "Test binding property to the 'window' object" self.test_property2 = {"key1": self.test_property1, "key2": ["Inside list", 1, 2]} # Asserts for True/False will be checked just before shutdown self.test_for_True = True # Test whether asserts are working correctly self.test_function_True = False self.test_property3_function_True = False self.test_callbacks_True = False self.py_callback_True = False def test_function(self): """Test binding function to the 'window' object.""" self.test_function_True = True def test_property3_function(self): """Test binding function to the 'window' object.""" self.test_property3_function_True = True def test_callbacks(self, js_callback): """Test both javascript and python callbacks.""" def py_callback(msg_from_js): self.py_callback_True = True self.test_case.assertEqual(msg_from_js, "String sent from Javascript") self.test_callbacks_True = True js_callback.Call("String sent from Python", py_callback) if __name__ == "__main__": _test_runner.main(os.path.basename(__file__)) cefpython-49.0/unittests/main_test_old.py000066400000000000000000000310361334103266300207060ustar00rootroot00000000000000# Copyright (c) 2016 CEF Python, see the Authors file. # All rights reserved. Licensed under BSD 3-clause license. # Project website: https://github.com/cztomczak/cefpython """General testing of CEF Python.""" import unittest # noinspection PyUnresolvedReferences import _test_runner from os.path import basename from cefpython3 import cefpython as cef import time import base64 import sys # To show the window for an extended period of time increase this number. MESSAGE_LOOP_RANGE = 200 # each iteration is 0.01 sec g_datauri_data = """

Main test (old)

""" g_datauri = "data:text/html;base64,"+base64.b64encode(g_datauri_data.encode( "utf-8", "replace")).decode("utf-8", "replace") g_subtests_ran = 0 def subtest_message(message): global g_subtests_ran g_subtests_ran += 1 print(str(g_subtests_ran) + ". " + message) sys.stdout.flush() class MainTest_IsolatedTest(unittest.TestCase): def test_main(self): """Main entry point.""" # All this code must run inside one single test, otherwise strange # things happen. print("") print("CEF Python {ver}".format(ver=cef.__version__)) print("Python {ver}".format(ver=sys.version[:6])) # Test initialization of CEF settings = { "debug": False, "log_severity": cef.LOGSEVERITY_ERROR, "log_file": "", } if "--debug" in sys.argv: settings["debug"] = True settings["log_severity"] = cef.LOGSEVERITY_INFO cef.Initialize(settings) subtest_message("cef.Initialize() ok") # Test global handler global_handler = GlobalHandler(self) cef.SetGlobalClientCallback("OnAfterCreated", global_handler._OnAfterCreated) subtest_message("cef.SetGlobalClientCallback() ok") # Test creation of browser browser = cef.CreateBrowserSync(url=g_datauri) self.assertIsNotNone(browser, "Browser object") subtest_message("cef.CreateBrowserSync() ok") # Test other handlers: LoadHandler, DisplayHandler etc. client_handlers = [LoadHandler(self), DisplayHandler(self)] for handler in client_handlers: browser.SetClientHandler(handler) subtest_message("browser.SetClientHandler() ok") # Test javascript bindings external = External(self) bindings = cef.JavascriptBindings( bindToFrames=False, bindToPopups=False) bindings.SetFunction("test_function", external.test_function) bindings.SetProperty("test_property1", external.test_property1) bindings.SetProperty("test_property2", external.test_property2) bindings.SetProperty("cefpython_version", cef.GetVersion()) bindings.SetObject("external", external) browser.SetJavascriptBindings(bindings) subtest_message("browser.SetJavascriptBindings() ok") # Run message loop for some time. # noinspection PyTypeChecker for i in range(MESSAGE_LOOP_RANGE): cef.MessageLoopWork() time.sleep(0.01) subtest_message("cef.MessageLoopWork() ok") # Test browser closing. Remember to clean reference. browser.CloseBrowser(True) del browser subtest_message("browser.CloseBrowser() ok") # Give it some time to close before calling shutdown. # noinspection PyTypeChecker for i in range(25): cef.MessageLoopWork() time.sleep(0.01) # Automatic check of asserts in handlers and in external for obj in [] + client_handlers + [global_handler, external]: test_for_True = False # Test whether asserts are working correctly for key, value in obj.__dict__.items(): if key == "test_for_True": test_for_True = True continue if "_True" in key: self.assertTrue(value, "Check assert: " + obj.__class__.__name__ + "." + key) subtest_message(obj.__class__.__name__ + "." + key.replace("_True", "") + " ok") elif "_False" in key: self.assertFalse(value, "Check assert: " + obj.__class__.__name__ + "." + key) subtest_message(obj.__class__.__name__ + "." + key.replace("_False", "") + " ok") self.assertTrue(test_for_True) # Test shutdown of CEF cef.Shutdown() subtest_message("cef.Shutdown() ok") # Display real number of tests there were run print("\nRan " + str(g_subtests_ran) + " sub-tests in test_main") sys.stdout.flush() class GlobalHandler(object): def __init__(self, test_case): self.test_case = test_case # Asserts for True/False will be checked just before shutdown self.test_for_True = True # Test whether asserts are working correctly self.OnAfterCreated_True = False def _OnAfterCreated(self, browser, **_): # For asserts that are checked automatically before shutdown its # values should be set first, so that when other asserts fail # (the ones called through the test_case member) they are reported # correctly. self.test_case.assertFalse(self.OnAfterCreated_True) self.OnAfterCreated_True = True self.test_case.assertEqual(browser.GetIdentifier(), 1) class LoadHandler(object): def __init__(self, test_case): self.test_case = test_case self.frame_source_visitor = None # Asserts for True/False will be checked just before shutdown self.test_for_True = True # Test whether asserts are working correctly self.OnLoadStart_True = False self.OnLoadEnd_True = False self.FrameSourceVisitor_True = False # self.OnLoadingStateChange_Start_True = False # FAILS self.OnLoadingStateChange_End_True = False def OnLoadStart(self, browser, frame, **_): self.test_case.assertFalse(self.OnLoadStart_True) self.OnLoadStart_True = True self.test_case.assertEqual(browser.GetUrl(), frame.GetUrl()) self.test_case.assertEqual(browser.GetUrl(), g_datauri) def OnLoadEnd(self, browser, frame, http_code, **_): # OnLoadEnd should be called only once self.test_case.assertFalse(self.OnLoadEnd_True) self.OnLoadEnd_True = True self.test_case.assertEqual(http_code, 200) self.frame_source_visitor = FrameSourceVisitor(self, self.test_case) frame.GetSource(self.frame_source_visitor) browser.ExecuteJavascript("print('LoadHandler.OnLoadEnd() ok')") def OnLoadingStateChange(self, browser, is_loading, can_go_back, can_go_forward, **_): if is_loading: # TODO: this test fails, looks like OnLoadingStaetChange with # is_loading=False is being called very fast, before # OnLoadStart and before client handler is set by calling # browser.SetClientHandler(). # SOLUTION: allow to set OnLoadingStateChange through # SetGlobalClientCallback similarly to _OnAfterCreated(). # self.test_case.assertFalse(self.OnLoadingStateChange_Start_True) # self.OnLoadingStateChange_Start_True = True pass else: self.test_case.assertFalse(self.OnLoadingStateChange_End_True) self.OnLoadingStateChange_End_True = True self.test_case.assertEqual(browser.CanGoBack(), can_go_back) self.test_case.assertEqual(browser.CanGoForward(), can_go_forward) class DisplayHandler(object): def __init__(self, test_case): self.test_case = test_case # Asserts for True/False will be checked just before shutdown self.test_for_True = True # Test whether asserts are working correctly self.javascript_errors_False = False self.OnConsoleMessage_True = False def OnConsoleMessage(self, message, **_): if "error" in message.lower() or "uncaught" in message.lower(): self.javascript_errors_False = True raise Exception(message) else: # Check whether messages from javascript are coming self.OnConsoleMessage_True = True subtest_message(message) class FrameSourceVisitor(object): """Visitor for Frame.GetSource().""" def __init__(self, load_handler, test_case): self.load_handler = load_handler self.test_case = test_case def Visit(self, **_): self.test_case.assertFalse(self.load_handler.FrameSourceVisitor_True) self.load_handler.FrameSourceVisitor_True = True self.test_case.assertIn("747ef3e6011b6a61e6b3c6e54bdd2dee", g_datauri_data) class External(object): """Javascript 'window.external' object.""" def __init__(self, test_case): self.test_case = test_case # Test binding properties to the 'window' object. self.test_property1 = "Test binding property to the 'window' object" self.test_property2 = {"key1": self.test_property1, "key2": ["Inside list", 1, 2]} # Asserts for True/False will be checked just before shutdown self.test_for_True = True # Test whether asserts are working correctly self.test_function_True = False self.test_callbacks_True = False self.py_callback_True = False def test_function(self): """Test binding function to the 'window' object.""" self.test_function_True = True def test_callbacks(self, js_callback): """Test both javascript and python callbacks.""" def py_callback(msg_from_js): self.py_callback_True = True self.test_case.assertEqual(msg_from_js, "String sent from Javascript") self.test_callbacks_True = True js_callback.Call("String sent from Python", py_callback) if __name__ == "__main__": _test_runner.main(basename(__file__)) cefpython-49.0/unittests/osr_test.py000066400000000000000000000170051334103266300177270ustar00rootroot00000000000000# Copyright (c) 2018 CEF Python, see the Authors file. # All rights reserved. Licensed under BSD 3-clause license. # Project website: https://github.com/cztomczak/cefpython """Off-screen rendering tests.""" import unittest # noinspection PyUnresolvedReferences import _test_runner from _common import * from cefpython3 import cefpython as cef import sys g_datauri_data = """

Off-screen rendering test

Test selection.
""" g_datauri = cef.GetDataUrl(g_datauri_data) class OsrTest_IsolatedTest(unittest.TestCase): def test_osr(self): """Main entry point. All the code must run inside one single test, otherwise strange things happen.""" print("") print("CEF Python {ver}".format(ver=cef.__version__)) print("Python {ver}".format(ver=sys.version[:6])) # Application settings settings = { "debug": False, "log_severity": cef.LOGSEVERITY_ERROR, "log_file": "", "windowless_rendering_enabled": True } if not LINUX: # On Linux you get a lot of "X error received" messages # from Chromium's "x11_util.cc", so do not show them. settings["log_severity"] = cef.LOGSEVERITY_WARNING if "--debug" in sys.argv: settings["debug"] = True settings["log_severity"] = cef.LOGSEVERITY_INFO if "--debug-warning" in sys.argv: settings["debug"] = True settings["log_severity"] = cef.LOGSEVERITY_WARNING # All settings settings = { "windowless_rendering_enabled": True, } switches = { # GPU acceleration is not supported in OSR mode, so must disable # it using these Chromium switches (Issues #240 and #463) "disable-gpu": "", "disable-gpu-compositing": "", # Tweaking OSR performance by setting the same Chromium flags # as in upstream cefclient (Issue #240). "enable-begin-frame-scheduling": "", "disable-surfaces": "", # This is required for PDF ext to work } browser_settings = { # Tweaking OSR performance (Issue #240) "windowless_frame_rate": 30, # Default frame rate in CEF is 30 } # Initialize cef.Initialize(settings, switches=switches) subtest_message("cef.Initialize() ok") # Global handler global_handler = GlobalHandler(self) cef.SetGlobalClientCallback("OnAfterCreated", global_handler._OnAfterCreated) subtest_message("cef.SetGlobalClientCallback() ok") # Create browser window_info = cef.WindowInfo() window_info.SetAsOffscreen(0) browser = cef.CreateBrowserSync(window_info=window_info, settings=browser_settings, url=g_datauri) # Javascript bindings bindings = cef.JavascriptBindings( bindToFrames=False, bindToPopups=False) bindings.SetFunction("js_code_completed", js_code_completed) bindings.SetProperty("cefpython_version", cef.GetVersion()) browser.SetJavascriptBindings(bindings) subtest_message("browser.SetJavascriptBindings() ok") # Client handlers client_handlers = [LoadHandler(self, g_datauri), DisplayHandler(self), RenderHandler(self)] for handler in client_handlers: browser.SetClientHandler(handler) # Initiate OSR rendering browser.SendFocusEvent(True) browser.WasResized() # Test selection on_load_end(select_h1_text, browser) # Message loop run_message_loop() # Close browser and clean reference browser.CloseBrowser(True) del browser subtest_message("browser.CloseBrowser() ok") # Give it some time to close before checking asserts # and calling shutdown. do_message_loop_work(25) # Asserts before shutdown # noinspection PyTypeChecker check_auto_asserts(self, [] + client_handlers + [global_handler]) # Test shutdown of CEF cef.Shutdown() subtest_message("cef.Shutdown() ok") # Display summary show_test_summary(__file__) sys.stdout.flush() def select_h1_text(browser): browser.SendMouseClickEvent(0, 0, cef.MOUSEBUTTON_LEFT, mouseUp=False, clickCount=1) browser.SendMouseMoveEvent(400, 20, mouseLeave=False, modifiers=cef.EVENTFLAG_LEFT_MOUSE_BUTTON) browser.SendMouseClickEvent(400, 20, cef.MOUSEBUTTON_LEFT, mouseUp=True, clickCount=1) subtest_message("select_h1_text() ok") class RenderHandler(object): def __init__(self, test_case): self.test_case = test_case # Asserts for True/False will be checked just before shutdown. # Test whether asserts are working correctly. self.test_for_True = True self.GetViewRect_True = False self.OnPaint_True = False def GetViewRect(self, rect_out, **_): """Called to retrieve the view rectangle which is relative to screen coordinates. Return True if the rectangle was provided.""" # rect_out --> [x, y, width, height] self.GetViewRect_True = True rect_out.extend([0, 0, 800, 600]) return True def OnPaint(self, element_type, paint_buffer, **_): """Called when an element should be painted.""" if element_type == cef.PET_VIEW: self.test_case.assertEqual(paint_buffer.width, 800) self.test_case.assertEqual(paint_buffer.height, 600) if not self.OnPaint_True: self.OnPaint_True = True subtest_message("RenderHandler.OnPaint: viewport ok") else: raise Exception("Unsupported element_type in OnPaint") if __name__ == "__main__": _test_runner.main(os.path.basename(__file__)) cefpython-49.0/unittests/unittest_test.py000066400000000000000000000030671334103266300210060ustar00rootroot00000000000000# Copyright (c) 2016 CEF Python, see the Authors file. # All rights reserved. Licensed under BSD 3-clause license. # Project website: https://github.com/cztomczak/cefpython """Test the unittest itself.""" import unittest # Globals g_count = 0 g_setUpClass_count = 0 g_tearDownClass_count = 0 g_setUp_count = 0 g_tearDown_count = 0 class Test(unittest.TestCase): count = 0 @classmethod def setUpClass(cls): global g_setUpClass_count g_setUpClass_count += 1 @classmethod def tearDownClass(cls): global g_tearDownClass_count g_tearDownClass_count += 1 def setUp(self): global g_setUp_count g_setUp_count += 1 def tearDown(self): global g_tearDown_count g_tearDown_count += 1 def test_unittest1(self): global g_count g_count += 1 self.count += 1 self.assertEqual(g_count, 1) self.assertEqual(self.count, 1) self.assertEqual(g_setUpClass_count, 1) self.assertEqual(g_tearDownClass_count, 0) def test_unittest2(self): global g_count g_count += 1 self.count += 1 self.assertEqual(g_count, 2) self.assertEqual(self.count, 1) self.assertEqual(g_setUpClass_count, 1) self.assertEqual(g_tearDownClass_count, 0) def test_unittest3(self): self.assertEqual(g_setUp_count, 3) self.assertEqual(g_tearDown_count, 2) self.assertEqual(g_setUpClass_count, 1) self.assertEqual(g_tearDownClass_count, 0) if __name__ == "__main__": unittest.main()