Maximum CD 2012 January/maximum-cd-2012-01.iso/DiscContents/digsby_setup.exe/lib/gui/browser/webkit/webkitwindow.pyo

Python Compiled Bytecode | 2011-10-05 | 8.0 KB | 203 lines

# Source Generated with Decompyle++
# File: in.pyo (Python 2.6)

from __future__ import with_statement
import wx
from collections import defaultdict
from logging import getLogger
log = getLogger('webkitwindow')
from util import traceguard
from util.primitives.funcs import Delegate

try:
    import webview
    WebView = webview.WebView
except ImportError:
    from traceback import print_exc
    print_exc()

    class WebKitWindow(wx.Panel):
        pass


MinimumTextSizeMultiplier = 0.5
MaximumTextSizeMultiplier = 3
TextSizeMultiplierRatio = 1.2

class WebKitWindow(WebView):

    def __init__(self, parent, initialContents = '', contentPath = 'file:///c:/', url = None, simple_events = False, external_links = True, **opts):
        super(WebKitWindow, self).__init__(parent, size = wx.Size(200, 200), **opts)
        self._jsqueue_enabled = True
        self.jsqueue = []
        self.js_to_stderr = False
        self.ExternalLinks = external_links
        Bind = self.Bind
        Bind(wx.EVT_CONTEXT_MENU, self._WebKitWindow__OnContextMenu)
        Bind(webview.EVT_WEBVIEW_LOAD, self.OnStateChanged)
        Bind(webview.EVT_WEBVIEW_BEFORE_LOAD, self.OnBeforeLoad)
        setup_webview_logging = setup_webview_logging
        import gui.browser.webkit
        setup_webview_logging(self, 'webview')
        self.urltriggers = defaultdict(list)
        if initialContents and url is not None:
            raise ValueError('please specify initialContents or url, but not both')
        url is not None
        self.OnNav = Delegate()
        self.OnDoc = Delegate()
        self.LoadUrl = self.LoadURL
        if url is not None:
            self.LoadURL(url)
        else:
            self.SetPageSource(initialContents, 'file:///')
        self.BlockWebKitMenu = True


    def set_jsqueue_enabled(self, enabled):
        self._jsqueue_enabled = enabled


    def set_window_open_redirects_to_browser(self, url_callback = None):
        add_window_open_redirect(self, url_callback)


    def __OnContextMenu(self, e):
        if not self.BlockWebKitMenu:
            e.Skip()



    def SetPageSource(self, source, baseUrl):
        if self._jsqueue_enabled:
            del self.jsqueue[:]
            self._js_paused = True

        WebView.SetPageSource(self, source, baseUrl)


    def SetPage(self, source, baseUrl = None):
        if baseUrl is None:
            baseUrl = 'file:///'

        return self.SetPageSource(source, baseUrl)


    def RunScript(self, s, cb = None, immediate = False):
        pass


    def AppendToPage(self, content):
        escaped = content.replace('\n', '\\\n').replace('"', '\\"')
        self.RunScript('appendMessage("%s");' % escaped)


    def ScrollToBottom(self):
        self.RunScript('window.scroll(0, 10000000);')


    def OnStateChanged(self, e):
        e.Skip()
        state = e.GetState()
        if state == webview.WEBVIEW_LOAD_NEGOTIATING:
            self._pause_javascript()
        elif state == webview.WEBVIEW_LOAD_DOC_COMPLETED:
            self._execute_delayed_javascript()
            self.OnDoc(e.URL)

        if state == webview.WEBVIEW_LOAD_DL_COMPLETED:
            self.OnNav(e.URL)



    def _pause_javascript(self):
        self._js_paused = True


    def _execute_delayed_javascript(self):
        self._js_paused = False
        for script, cb in enumerate(self.jsqueue):
            val = self._runscript(script)
            if val != 'undefined':
                log.debug('result %d: %r' % (n, val))

            if cb is not None:
                cb(val)
                continue

        del self.jsqueue[:]


    def _runscript(self, s):
        return WebView.RunScript(self, s)


    def OnBeforeLoad(self, e):
        type = e.GetNavigationType()
        e.Skip()
        if e.IsCancelled():
            return None
        url = e.GetURL()
        if type == webview.WEBVIEW_NAV_LINK_CLICKED:
            callback = self.urltriggers.get(url, None)
            if self.ExternalLinks and not url.startswith('javascript'):
                wx.LaunchDefaultBrowser(url)
                e.Cancel()




    def OnURL(self, url, callback):
        if not hasattr(callback, '__call__'):
            raise TypeError('OnURL takes a callable')
        hasattr(callback, '__call__')
        self.urltriggers[url].append(callback)


    def SetHTML(self, contents, baseUrl = 'file:///'):
        self.SetPageSource(contents, baseUrl)

    HTML = property(webview.WebView.GetPageSource, SetHTML)
    Title = property(webview.WebView.GetPageTitle, webview.WebView.SetPageTitle)

    def EditSource(self):
        EditSource = EditSource
        import gui.browser.webkit.webkiteditsource
        return EditSource(self)



def add_window_open_redirect(self, url_callback = None, blank_opens_browser = False):
    if url_callback is None:
        url_callback = wx.LaunchDefaultBrowser


    class WindowOpenRedirector((wx.webview.WebView,)):

        def __init__(self):
            self.frame = wx.Frame(None)
            wx.webview.WebView.__init__(self, self.frame)
            self.Bind(wx.webview.EVT_WEBVIEW_BEFORE_LOAD, self._WindowOpenRedirector__onbeforeload)


        def __onbeforeload(self, e):
            print '*** caught window.open(%r)' % e.URL
            url_callback(e.URL)
            e.Cancel()
            wx.CallAfter(self.Destroy)



    def _on_new_window(e):
        print '_on_new_window', e, e.URL
        if not e.URL:
            e.WebView = WindowOpenRedirector()
            e.Skip(False)
        elif blank_opens_browser:
            url_callback(e.URL)
            e.Skip(False)
        else:
            e.Skip()

    self.Bind(wx.webview.EVT_WEBVIEW_NEW_WINDOW, _on_new_window)