def __init__(self):
# NOTE socket 创建
self.s = socket.socket()
self.s.setblocking(0)
self.host = socket.gethostname()
self.port = int(sys.argv[1])
self.s.bind((self.host, self.port))
self.s.listen(5)
# NOTE Initialize CEF
cef.Initialize({
"context_menu": {
"enabled": False,
"navigation": True, # Back, Forward, Reload
"print": False,
"view_source": False,
"external_browser": False, # Open in external browser
"devtools": False, # Developer Tools
}
})
self.browser_settings = {
"universal_access_from_file_urls_allowed": True,
"file_access_from_file_urls_allowed": True,
}
# NOTE 循环变量初始化
self.browser_dict = {}
self.callback_dict = {
# NOTE 确保加载完成再触发 模型加载 命令
'loadAsset':
lambda collections, data: collections.load_handler.dispatcher.
connectEventList(lambda: collections.browser.ExecuteFunction(
"loadAsset", data)) if collections.browser else None,
'loadUrl':
lambda collections, url: collections.browser.LoadUrl(url)
if collections.browser and collections.browser.GetUrl(
) != url else None,
'getUrl':
lambda collections: collections.browser.GetUrl()
if collections.browser else None,
'goBack':
lambda collections: collections.browser.GoBack()
if collections.browser and collections.browser.CanGoBack(
) else None,
'goForward':
lambda collections: collections.browser.GoForward()
if collections.browser and collections.browser.CanGoForward(
) else None,
'reload':
lambda collections: collections.browser.Reload()
if collections.browser else None,
'focusOut':
lambda collections: collections.browser.SetFocus(False)
if collections.browser else None,
'focusIn':
self.focusIn,
'resize':
self.resize,
}
def main():
check_versions()
sys.excepthook = cef.ExceptHook # To shutdown all CEF processes on error
# To change user agent use either "product_version"
# or "user_agent" options. Explained in Tutorial in
# "Change user agent string" section.
settings = {
# "product_version": "MyProduct/10.00",
# "user_agent": "MyAgent/20.00 MyProduct/10.00",
}
cef.Initialize(settings=settings)
#set_global_handler()
#browser = cef.CreateBrowserSync(url=html_to_data_uri(HTML_code),
# window_title="Tutorial")
#browser = cef.CreateBrowserSync(url="http://www.zhaopin.com")
browser = cef.CreateBrowserSync(url="http://www.baidu.com")
js_binding(browser)
bs4_visitor = Bs4Visitor()
browser.SetClientHandler(LoadHandler(bs4_visitor))
# browser.SetClientHandler(ResourceHandler())
browser.SetClientHandler(RequestHandler())
cef.MessageLoop()
cef.Shutdown()
def CefThread():
script_dir = os.path.dirname(os.path.realpath(__file__))
url= 'file://%s/gui/index.html'%script_dir
check_versions()
sys.excepthook = cef.ExceptHook # To shutdown all CEF processes on error
#p = Thread(target=TkSaveSubProc,args=(FILE_QUEUE,))
#p.start()
cef.Initialize()
#set up a browser
window_info = cef.WindowInfo()
window_info.SetAsChild(0, [0,0,1280,720])
browser = cef.CreateBrowserSync(
window_title="PushBroom Planner",
url=url, window_info=window_info)
frame = browser.GetMainFrame()
#set up the browser's javascript bindings
external = External()
bindings = cef.JavascriptBindings()
bindings.SetObject("external",external)
browser.SetJavascriptBindings(bindings)
#enter main loop
cef.MessageLoop()
cef.Shutdown()
FILE_QUEUE.put((None,None))
def main():
check_versions()
#sys.excepthook = cef.ExceptHook # To shutdown all CEF processes on error
# To change user agent use either "product_version"
# or "user_agent" options. Explained in Tutorial in
# "Change user agent string" section.
settings = {
# "product_version": "MyProduct/10.00",
# "user_agent": "MyAgent/20.00 MyProduct/10.00",
"auto_zooming": "0.0"
}
if WINDOWS:
# noinspection PyUnresolvedReferences, PyArgumentList
#cef.DpiAware.EnableHighDpiSupport()
cef.DpiAware.SetProcessDpiAware() # Alternative is to embed manifest
cef.Initialize(settings=settings)
set_global_handler()
#path = os.path.normpath(os.path.join(os.path.dirname(sys.argv[0]), os.pardir, os.pardir))
#htmlfile = os.path.join(path, 'html', 'index.html')
#browser = cef.CreateBrowserSync(url=htmlfile,
#browser = cef.CreateBrowserSync(url="file:///d:/ib/t1/dist/index.html",
browser = cef.CreateBrowserSync(url="http://localhost:8080/#/",
window_title="IB Trader")
set_client_handlers(browser)
set_javascript_bindings(browser)
cef.MessageLoop()
cef.Shutdown()
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 (Issue #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 main():
print("main")
check_versions()
parser.loadConfig()
wd = parser.getWD()
if (not _DEBUG): sys.excepthook = cef.ExceptHook
settings = {
"context_menu": {
"enabled": _DEBUG,
"navigation": False,
"print": False,
"view_source": False,
"external_browser": False,
"devtools": True,
},
# "product_version": "MyProduct/10.00",
# "user_agent": "MyAgent/20.00 MyProduct/10.00",
}
cef.Initialize(settings=settings)
browser = cef.CreateBrowserSync(url=html_to_data_uri(_make_html()),
window_title=APP_NAME)
set_client_handlers(browser)
set_javascript_bindings(browser)
cef.MessageLoop()
cef.Shutdown()
def __init__(self,
start_url,
window_title="CEFApp",
jinja_env=None,
cef_temp_dir=None):
"""Initialize a new base CEF app
:param start_url: Load url on browser startup
:type start_url: str
:param window_title: Top CEF browser title, defaults to "CEFApp"
:type window_title: str, optional
"""
sys.excepthook = cef.ExceptHook
cef.Initialize()
self.jinja_env = jinja_env
if cef_temp_dir is None:
self.cef_temp_dir = os.path.join(os.path.dirname(__file__),
".cef_temp")
else:
self.cef_temp_dir = cef_temp_dir
self.browser = cef.CreateBrowserSync(url=start_url,
window_title=window_title)
self.bindings = cef.JavascriptBindings(bindToFrames=False,
bindToPopups=False)
#Ajout des clients handler
self.set_client_handlers()
def init_browser(server_port):
sys.excepthook = cef.ExceptHook # To shutdown all CEF processes on error
cef.Initialize()
cef.CreateBrowserSync(url="http://localhost:{0}?user=admin&pwd=admin".format(str(server_port)),window_title="OmniDB")
cef.MessageLoop()
cef.Shutdown()
cherrypy.engine.exit()
def loadMap(dataUrl):
sys.excepthook = cef.ExceptHook # To shutdown all CEF processes on error
cef.Initialize()
cef.CreateBrowserSync(url=dataUrl,window_title="Chord Map Application")
cef.MessageLoop()
cef.Shutdown()
# lat -16.328546 lng -48.953403
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__ >= "55.3", "CEF Python v55.3+ required to run this"
sys.excepthook = cef.ExceptHook # To shutdown all CEF processes on error
root = tk.Tk()
app = MainFrame(root)
#app.get_browser().load_url(r"C:\Users\mani\AppData\Local\Temp\tmp9yiyyzeq.html")
#app.browser = cef.CreateBrowserSync(cef.WindowInfo(),
# url=self.html_text)
#print(type(app))
#app.set_url(r"C:\Users\mani\AppData\Local\Temp\tmp9yiyyzeq.html")
#app.LoadUrl()
# Tk must be initialized before CEF otherwise fatal error (Issue #306)
cef.Initialize()
#app.get_browser()LoadUrl(r"C:\Users\mani\AppData\Local\Temp\tmp9yiyyzeq.html")
app.mainloop()
cef.Shutdown()
def test_osr(self):
sys.excepthook = cef.ExceptHook
cef.Initialize(settings={"windowless_rendering_enabled": True})
parent_window_handle = 0
window_info = cef.WindowInfo()
window_info.SetAsOffscreen(parent_window_handle)
browser = cef.CreateBrowserSync(window_info=window_info, url=g_datauri)
client_handlers = [
LoadHandler(self),
DisplayHandler(self),
RenderHandler(self),
DragHandler(self)
]
for handler in client_handlers:
browser.SetClientHandler(handler)
browser.SendFocusEvent(True)
browser.WasResized()
# Test setting DragData.
self.subtest_dragdata()
cef_waiting(200)
# Automatic check of asserts in handlers
automatic_check_handlers(self, [] + client_handlers)
browser.CloseBrowser(True)
del browser
cef.Shutdown()
def initialize():
check_versions()
sys.excepthook = cef.ExceptHook
settings = {
"debug": False,
"log_severity": cef.LOGSEVERITY_DISABLE, # cef.LOGSEVERITY_INFO,
"locales_dir_path": cef.GetModuleDirectory() + "/locales",
"resources_dir_path": cef.GetModuleDirectory(),
"browser_subprocess_path": cef.GetModuleDirectory() + "/subprocess",
"downloads_enabled": True,
"remote_debugging_port": -1,
"context_menu": {
"enabled": True,
"navigation": True,
"print": True,
"view_source": True,
"external_browser": True,
"devtools": True,
},
"ignore_certificate_errors": True,
}
switches = {
# "disable-gpu": "1",
"no-proxy-server": "1",
"disable-web-security": "1",
}
cef.Initialize(settings, switches=switches)
def run_cef(self, in_path: str, out_path: str) -> None:
# Setup CEF
sys.excepthook = customExceptHook # to shutdown all CEF processes on error
settings: Dict[str, bool] = {
'windowless_rendering_enabled': True, # offscreen-rendering
}
switches: Dict[str, str] = {
# 'headless': '',
'disable-gpu': '',
'disable-gpu-compositing': '',
'enable-begin-frame-scheduling': '',
'disable-surfaces': '',
'disable-smooth-scrolling': '',
}
browser_settings: Dict[str, int] = {
'windowless_frame_rate': 30,
}
cef.Initialize(settings=settings, switches=switches)
print()
browser = self.create_browser(browser_settings, in_path, out_path)
bindings = cef.JavascriptBindings()
bindings.SetFunction("save_data", save_data_txt)
browser.SetJavascriptBindings(bindings)
# Enter loop
cef.MessageLoop()
# Cleanup
browser.CloseBrowser()
cef.Shutdown()
print('\nDone!')
def create_form(request_url, request_method='get', request_param=None,
external_data=None, session=None):
sys.excepthook = cef.ExceptHook
settings = {
"product_version": "utilities/2.0.0",
"user_agent": "utilities/2.0.0",
'unique_request_context_per_browser': True,
'persist_session_cookies': False,
'cache_path': os.path.expanduser("~") + "/Kam1n0/client-web-cache/"
}
browser_settings = {
# enable cross-site scripting. since our request sent from local
# but the cookie is from remote (different origin)
"web_security_disabled": True
}
cef.Initialize(settings=settings)
set_global_handler()
browser = cef.CreateBrowserSync(
settings=browser_settings,
url="file://" + get_application_path("resources/operations.html"),
window_title="Kam1n0")
set_client_handlers(browser, request_url, session)
set_javascript_bindings(browser, request_url, request_method,
request_param, external_data)
cef.MessageLoop()
cef.Shutdown()
os._exit(1)
def __init__(self, start_page_name: str, js_bindings: dict):
storage.browser = self # adding to global object
builtins.browser = self
self.thread_id = threading.get_ident()
self._check_versions()
sys.excepthook = cef.ExceptHook # To shutdown all CEF processes on error
settings = {
# "product_version": "MyProduct/10.00",
# "user_agent": "MyAgent/20.00 MyProduct/10.00",
"debug": False,
#"log_severity": cef.LOGSEVERITY_INFO,
}
cef.Initialize(settings=settings)
start_page = self._html_to_data_uri(
self.read(f'./cache/{start_page_name}.html'))
self.browser = cef.CreateBrowserSync(window_title="Versus X",
url=start_page)
self.browser.SetClientHandler(LifespanHandler())
self._bind_to_js(js_bindings)
cef.MessageLoop()
cef.Shutdown()
def __init__(self):
Backend.__init__(self)
sys.excepthook = ExceptHook # TODO: ??????????????
# Application settings
settings = {
# "cache_path": "webcache/", # Disk cache
# "debug": True, # cefpython debug messages in console and in log_file # TODO
"log_severity":
cefpython.LOGSEVERITY_INFO, # LOGSEVERITY_VERBOSE
"log_file":
GetApplicationPath("debug.log"), # Set to "" to disable.
"release_dcheck_enabled":
True, # Enable only when debugging.
# This directories must be set on Linux
"locales_dir_path":
cefpython.GetModuleDirectory() + "/locales",
"resources_dir_path":
cefpython.GetModuleDirectory(),
"browser_subprocess_path":
"%s/%s" % (cefpython.GetModuleDirectory(), "subprocess")
}
# Command line switches set programmatically
switches = {
# "proxy-server": "socks5://127.0.0.1:8888",
# "enable-media-stream": "",
# "--invalid-switch": "" -> Invalid switch name
}
cefpython.Initialize(settings, switches)
def main():
script_dir = os.path.dirname(os.path.realpath(__file__))
url = 'file://%s/index.html' % script_dir
print(url)
check_versions()
sys.excepthook = cef.ExceptHook # To shutdown all CEF processes on error
cef.Initialize()
#set up a browser
window_info = cef.WindowInfo()
window_info.SetAsChild(0, [0, 0, 1000, 650])
browser = cef.CreateBrowserSync(window_title="Hello World!",
url=url,
window_info=window_info)
frame = browser.GetMainFrame()
#set up the browser's javascript bindings
external = External()
bindings = cef.JavascriptBindings()
bindings.SetFunction("echo", external.echo)
bindings.SetObject("external", external)
bindings.SetProperty("KEY_CODES", External.KEY_CODES)
browser.SetJavascriptBindings(bindings)
#enter main loop
cef.MessageLoop()
cef.Shutdown()
def create_window(uid, title, url, width, height, resizable, fullscreen,
min_size, confirm_quit, background_color, debug, js_api,
webview_ready):
# app = QApplication.instance() or QApplication([])
app = CefApplication(sys.argv)
settings = {'context_menu': {'enabled': False}}
cef.Initialize(settings)
def _create():
browser = BrowserView(uid, title, url, width, height, resizable,
fullscreen, min_size, confirm_quit,
background_color, debug, js_api, webview_ready)
browser.show()
if uid == 'master':
_create()
app.exec_()
app.stopTimer()
# del browser # Just to be safe, similarly to "del app"
del app # Must destroy app object before calling Shutdown
cef.Shutdown()
else:
i = list(BrowserView.instances.values())[0] # arbitary instance
i.create_window_trigger.emit(_create)
def run_cef_gui(url_target, title):
check_versions()
sys.excepthook = cef.ExceptHook # To shutdown all CEF processes on error
cef.Initialize()
cef.CreateBrowserSync(url=url_target, window_title=title)
cef.MessageLoop()
cef.Shutdown()
def __init__(self, width=1920, height=1080, headless=False):
self.width = width
self.height = height
self.headless = headless
# pointer to reusable CEF objects
self.console = []
self.browser = None
self.source = None
self.domArray = None
self.windowParams = None
self.ready = True
self._getSourceLock = threading.Condition()
self._getDOMLock = threading.Condition()
self._getReadyLock = threading.Condition()
self._handler = fakechromehandlers(self)
settings = {
'user_agent':'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_12_6) ' \
'AppleWebKit/537.36 (KHTML, like Gecko) ' \
'Chrome/64.0.3282.140 Safari/537.36'
}
if self.headless:
settings['windowless_rendering_enabled'] = True
cef.Initialize(settings=settings)
def main(display):
sys.excepthook = cef.ExceptHook
cef.Initialize(settings={})
dbus_loop = DBusGMainLoop(set_as_default=True)
bus = dbus.SystemBus(mainloop=dbus_loop)
manager_path = f'/{GEOCLUE.replace(".", "/")}/Manager'
manager_proxy = bus.get_object(GEOCLUE, manager_path)
manager_iface = dbus.Interface(manager_proxy, f'{GEOCLUE}.Manager')
client_path = manager_iface.CreateClient()
client_proxy = bus.get_object(GEOCLUE, client_path)
client_iface = dbus.Interface(client_proxy, f'{GEOCLUE}.Client')
client_props_iface = dbus.Interface(client_iface, DBUS_PROPERTIES)
client_props = client_props_iface.GetAll(f'{GEOCLUE}.Client')
client_props_iface.Set(f'{GEOCLUE}.Client', 'DesktopId',
'geolocation.desktop')
client_props_iface.Set(f'{GEOCLUE}.Client', 'RequestedAccuracyLevel',
GCLUE_ACCURACY_LEVEL_EXACT)
map = Map(display, bus)
client_iface.Start()
client_iface.connect_to_signal('LocationUpdated', map.location_updated)
loop = GLib.MainLoop()
GLib.timeout_add(10000, loop.quit)
loop.run()
client_iface.Stop()
def search(query, root_url):
global i
print('query:', query, i)
url = root_url
if url.find('?') > -1:
url += '&query=' + query
else:
url += '?query=' + query
check_versions()
sys.excepthook = cef.ExceptHook # To shutdown all CEF processes on error
cef.Initialize()
window_info = create_window_info('win' + str(i))
i += 1
browser = cef.CreateBrowserSync(window_info=window_info, url=url,
window_title="词典")
browser.SetClientHandler(LifespanHandler())
# browser.LoadUrl('http://www.baidu.com')
cef.MessageLoop()
cef.Shutdown() # 清除所有资源
def browser(cef, url):
""" Starts a cef browser in the middle of the screen with url
"""
# Keeps the splash from displaying on short tasks
log.debug('Delaying splash for 2 seconds')
time.sleep(2)
log.info('Starting splash screen for long-running task')
settings = {
'background_color': 0xff000000,
'cache_path': '',
'context_menu': {
'enabled': False
},
'debug': False,
'command_line_args_disabled': False,
}
switches = {
'disable-gpu': '',
'disable-gpu-compositing': '',
}
sys.excepthook = cef.ExceptHook
cef.Initialize(settings, switches)
win_info = cef.WindowInfo()
win_info.SetAsChild(0, coordinates(600, 360))
cef.CreateBrowser(url=url, window_info=win_info, window_title='splash')
cef.MessageLoop()
cef.Shutdown()
def open_cef():
sys.excepthook = cef.ExceptHook
cef.Initialize()
cef.CreateBrowserSync(url='http://127.0.0.1:8000',
window_title='Welcome to RxPoint')
cef.MessageLoop()
def open_url_demo(url, title):
# To shutdown all CEF processes on error
sys.excepthook = cef.ExceptHook
cef.Initialize()
cef.CreateBrowserSync(url=url, window_title=title)
cef.MessageLoop()
cef.Shutdown()
def main():
print("[devtools.py] url={0}".format(DEVTOOLS_URL))
sys.excepthook = cef.ExceptHook # To shutdown all CEF processes on error
cef.Initialize()
cef.CreateBrowserSync(url=DEVTOOLS_URL, window_title="DevTools")
cef.MessageLoop()
cef.Shutdown()
def browser_login(self):
from cefpython3 import cefpython as cef
br_WindowInfo = cef.WindowInfo()
if sys.platform == 'win32':
parent = self.create_window()
br_WindowInfo.SetAsChild(parent, [0, 0, 500, 500])
else:
br_WindowInfo.SetAsChild(0, [0, 0, 500, 500])
settings = {
"debug": True,
"log_severity": cef.LOGSEVERITY_INFO,
"log_file": os.path.join(os.path.dirname(__file__),
"deez_debug.log"),
}
cef.Initialize(settings=settings)
browser = cef.CreateBrowserSync(br_WindowInfo,
url="https://www.deezer.com/",
window_title="Deezer Login")
browser.SetClientHandler(LoadHandler())
cef.MessageLoop()
print("Shutdown Complete")
# del browser
print("cookies =", cookies)
#pause()
cef.Shutdown()
def Initialize(settings=None):
"""Initializes CEF, We should do it before initializing wx
If no settings passed a default is used
"""
sys.excepthook = ExceptHook
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()
if not "browser_subprocess_path" in settings:
settings["browser_subprocess_path"] = \
"%s/%s" % (cefpython.GetModuleDirectory(), "subprocess")
# DEBUGGING options:
# ------------------
# cefpython.g_debug = True
# cefpython.g_debugFile = "debug.log"
# settings["log_severity"] = cefpython.LOGSEVERITY_VERBOSE
# settings["log_file"] = "debug.log" # Set to "" to disable.
# settings["release_dcheck_enabled"] = True
cefpython.Initialize(settings)
def init(window):
global _initialized
if not _initialized:
if sys.platform == 'win32':
_set_dpi_mode(True)
default_settings = {
'multi_threaded_message_loop': True,
'context_menu': {
'enabled': _debug
}
}
if not _debug:
default_settings['remote_debugging_port'] = -1
try: # set paths under Pyinstaller's one file mode
default_settings.update({
'resources_dir_path':
sys._MEIPASS,
'locales_dir_path':
os.path.join(sys._MEIPASS, 'locales'),
'browser_subprocess_path':
os.path.join(sys._MEIPASS, 'subprocess.exe'),
})
except Exception:
pass
all_settings = dict(default_settings, **settings)
cef.Initialize(settings=all_settings)
cef.DpiAware.EnableHighDpiSupport()
_initialized = True
def main():
# Use paths relative to this python file
pythonFileFolder = os.path.dirname(os.path.realpath(__file__))
os.chdir(pythonFileFolder)
_, innerFolder = os.path.split(pythonFileFolder)
check_versions()
sys.excepthook = cef.ExceptHook # To shutdown all CEF processes on error
settings = {
"remote_debugging_port": 49155,
}
cef.SetGlobalClientCallback("OnAfterCreated", on_after_create)
cef.Initialize(settings=settings)
browser = cef.CreateBrowserSync(url='file:///index.html',
window_title=innerFolder)
clientHandler = ClientHandler()
browser.SetClientHandler(clientHandler)
bindings = cef.JavascriptBindings()
testObject = TestObject()
bindings.SetObject("testObject", testObject)
browser.SetJavascriptBindings(bindings)
cef.MessageLoop()
cef.Shutdown()
