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

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

def __init__(self):

# noinspection PyArgumentList

super(MainWindow, self).__init__(None)

# Avoids crash when shutting down CEF (issue #360)

if PYSIDE:

self.setAttribute(Qt.WA_DeleteOnClose, True)

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.

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 <PyCObject object at 0x02FD8788>

# | 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.OnSize(self.getHandle(), 0, 0, 0)

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.OnSize(self.getHandle(), 0, 0, 0)

elif LINUX:

self.browser.SetBounds(self.x, self.y,

size.width(), size.height())

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):

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)

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)")

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())