# 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(),\

global g_messageLoopTimer

Debug("DestroyMessageLoopTimer")

if g_messageLoopTimer:

g_messageLoopTimer.Stop()

g_messageLoopTimer = None

else:

# There was no browser created during session.

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, "Arrow Left.png"),

wx.BITMAP_TYPE_PNG), style=wx.BORDER_NONE)

self.forwardBtn = buttons.GenBitmapButton(self, -1,

wx.Bitmap(os.path.join(self.bitmapDir, "Arrow Right.png"),

wx.BITMAP_TYPE_PNG), style=wx.BORDER_NONE)

self.reloadBtn = buttons.GenBitmapButton(self, -1,

wx.Bitmap(os.path.join(self.bitmapDir, "Button Load.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):

"""

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)

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.

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

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

"""Initializes CEF, We should do it before initializing wx

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.

settings["release_dcheck_enabled"] = True

g_settings = settings