class Browser(WebView):
    def __init__(self):
        WebView.__init__(self)

        self.progress = ProgressListener()

    def do_setup(self):
        WebView.do_setup(self)
        self.progress.setup(self)

    def zoom_in(self):
        contentViewer = self.doc_shell.queryInterface( \
                interfaces.nsIDocShell).contentViewer
        if contentViewer is not None:
            markupDocumentViewer = contentViewer.queryInterface( \
                    interfaces.nsIMarkupDocumentViewer)
            markupDocumentViewer.fullZoom += _ZOOM_AMOUNT

    def zoom_out(self):
        contentViewer = self.doc_shell.queryInterface( \
                interfaces.nsIDocShell).contentViewer
        if contentViewer is not None:
            markupDocumentViewer = contentViewer.queryInterface( \
                    interfaces.nsIMarkupDocumentViewer)
            markupDocumentViewer.fullZoom -= _ZOOM_AMOUNT
Example #2
0
    def __init__(self, application, appdir):
        WebView.__init__(self)
        self.platform = 'hulahop'
        self.progress = ProgressListener()
        self.application = application
        self.appdir = appdir
        self.already_initialised = False

        io_service_class = components.classes[ \
        "@mozilla.org/network/io-service;1"]
        io_service = io_service_class.getService(interfaces.nsIIOService)

        # Use xpcom to turn off "offline mode" detection, which disables
        # access to localhost for no good reason.  (Trac #6250.)
        io_service2 = io_service_class.getService(interfaces.nsIIOService2)
        io_service2.manageOfflineStatus = False

        self.progress.connect('loading-stop', self._loaded)
        self.progress.connect('loading-progress', self._loading)
Example #3
0
 def _create_browser(self):
     if hulahop_ok:
         self.web_view = WebView()
         self.pack_start(self.web_view, True, True)
         self.progress_listener = ProgressListener()
         self.progress_listener.setup(self.web_view)
         self.progress_listener.connect('location-changed', self._location_changed_cb)
         
         self.web_view.load_uri(self.last_uri)
         self.web_view.show()
     else:
         self.web_view = gtk.Button()
         self.web_view.load_uri = self.web_view.set_label
         self.web_view.load_uri(self.last_uri)
         self.add(self.web_view)
         self.web_view.show()
Example #4
0
File: hula.py Project: Afey/pyjs
    def __init__(self, application, appdir):
        WebView.__init__(self)
        self.platform = 'hulahop'
        self.progress = ProgressListener()
        self.application = application
        self.appdir = appdir
        self.already_initialised = False

        io_service_class = components.classes[ \
        "@mozilla.org/network/io-service;1"]
        io_service = io_service_class.getService(interfaces.nsIIOService)

        # Use xpcom to turn off "offline mode" detection, which disables
        # access to localhost for no good reason.  (Trac #6250.)
        io_service2 = io_service_class.getService(interfaces.nsIIOService2)
        io_service2.manageOfflineStatus = False

        self.progress.connect('loading-stop', self._loaded)
        self.progress.connect('loading-progress', self._loading)
Example #5
0
    def __init__(self):
        WebView.__init__(self)
        
        self.history = HistoryListener()
        self.progress = ProgressListener()
        self.userscript = ScriptListener()

        cls = components.classes["@mozilla.org/typeaheadfind;1"]
        self.typeahead = cls.createInstance(interfaces.nsITypeAheadFind)

        self._jobject = None

        io_service_class = components.classes[ \
                "@mozilla.org/network/io-service;1"]
        io_service = io_service_class.getService(interfaces.nsIIOService)

        # Use xpcom to turn off "offline mode" detection, which disables
        # access to localhost for no good reason.  (Trac #6250.)
        io_service2 = io_service_class.getService(interfaces.nsIIOService2)
        io_service2.manageOfflineStatus = False

        cls = components.classes['@mozilla.org/content/style-sheet-service;1']
        self.style_sheet_service = cls.getService(
                                            interfaces.nsIStyleSheetService)

        if os.path.exists(Browser.AGENT_SHEET):
            agent_sheet_uri = io_service.newURI('file:///' + 
                                                Browser.AGENT_SHEET,
                                                None, None)
            self.style_sheet_service.loadAndRegisterSheet(agent_sheet_uri,
                    interfaces.nsIStyleSheetService.AGENT_SHEET)

        if os.path.exists(Browser.USER_SHEET):
            self.user_sheet_uri = io_service.newURI('file:///' + 
                                               Browser.USER_SHEET,
                                               None, None)
            self.style_sheet_service.loadAndRegisterSheet(self.user_sheet_uri,
                    interfaces.nsIStyleSheetService.USER_SHEET)
Example #6
0
File: hula.py Project: Afey/pyjs
class Browser(WebView):
    def __init__(self, application, appdir):
        WebView.__init__(self)
        self.platform = 'hulahop'
        self.progress = ProgressListener()
        self.application = application
        self.appdir = appdir
        self.already_initialised = False

        io_service_class = components.classes[ \
        "@mozilla.org/network/io-service;1"]
        io_service = io_service_class.getService(interfaces.nsIIOService)

        # Use xpcom to turn off "offline mode" detection, which disables
        # access to localhost for no good reason.  (Trac #6250.)
        io_service2 = io_service_class.getService(interfaces.nsIIOService2)
        io_service2.manageOfflineStatus = False

        self.progress.connect('loading-stop', self._loaded)
        self.progress.connect('loading-progress', self._loading)

    def _alert(self, txt):
        print "_alert", txt
        #self.get_prompt_svc().alert(None, "Alert", txt)

        def close(w):
            dialog.destroy()
        dialog = gtk.Dialog("Alert", None, gtk.DIALOG_DESTROY_WITH_PARENT)
        label = gtk.Label(txt)
        dialog.vbox.add(label)
        label.show()
        button = gtk.Button("OK")
        dialog.action_area.pack_start (button, True, True, 0)
        button.connect("clicked", close)
        button.show()
        dialog.run ()

    def get_prompt_svc(self):

        prompt_svc_cls = components.classes[ \
            "@mozilla.org/embedcomp/prompt-service;1"]
        return prompt_svc_cls.createInstance(interfaces.nsIPromptService)

    def load_app(self):

        uri = self.application
        if uri.find(":") == -1:
            # assume file
            uri = 'file://'+os.path.abspath(uri)

        self.application = uri
        self.load_uri(uri)

    def do_setup(self):
        WebView.do_setup(self)
        self.progress.setup(self)

    def _addXMLHttpRequestEventListener(self, node, event_name, event_fn):

        listener = xpcom.server.WrapObject(ContentInvoker(node, event_fn),
                                            interfaces.nsIDOMEventListener)
        node.addEventListener(event_name, listener, False)
        return listener

    def addEventListener(self, node, event_name, event_fn):

        listener = xpcom.server.WrapObject(ContentInvoker(node, event_fn),
                                            interfaces.nsIDOMEventListener)
        node.addEventListener(event_name, listener, True)
        return listener

    def mash_attrib(self, attrib_name):
        return attrib_name

    def _addWindowEventListener(self, event_name, event_fn, win=None):

        if win is None:
            win = self.window_root
        listener = xpcom.server.WrapObject(ContentInvoker(win, event_fn),
                                            interfaces.nsIDOMEventListener)
        win.addEventListener(event_name, listener, True)
        return listener

    def getDOMParser(self):
        xml_svc_cls = components.classes[ \
            "@mozilla.org/xmlextras/domparser;1"]
        return xml_svc_cls.createInstance(interfaces.nsIDOMParser)

    def getXmlHttpRequest(self):
        xml_svc_cls = components.classes[ \
            "@mozilla.org/xmlextras/xmlhttprequest;1"]
        return xml_svc_cls.createInstance(interfaces.nsIXMLHttpRequest)

    def getUri(self):
        return self.application

    def getDomWindow(self):
        return self.get_dom_window()

    def getDomDocument(self):
        return self.get_dom_window().document

    def _loaded(self, progress_listener):

        print "loaded"

        if self.already_initialised:
            return
        self.already_initialised = True

        dw = self.get_dom_window()
        doc = dw.document

        from __pyjamas__ import pygwt_processMetas, set_main_frame
        from __pyjamas__ import set_gtk_module
        set_main_frame(self)
        set_gtk_module(gtk)

        (pth, app) = os.path.split(self.application)
        if self.appdir:
            pth = os.path.abspath(self.appdir)
        sys.path.append(pth)

        #for m in pygwt_processMetas():
        #    minst = module_load(m)
        #    if hasattr(minst, "onModuleLoad"):
        #        minst.onModuleLoad()

    def _loading(self, progress_listener, progress):
        pass
        #print "loading", progress, self.getDomWindow().location.href

    def _trigger_fake_button(self):
        doc = self.getDomDocument()
        wnd = self.getDomWindow()
        element = self._hack_timer_workaround_bug_button
        evt = doc.createEvent('MouseEvents')
        evt.initMouseEvent("click", True, True, wnd, 1, 0, 0, 0, 0, False,
                                    False, False, False, 0, element)
        element.dispatchEvent(evt)

    def _timer_callback_workaround(self, *args):

        global timer_q
        while timer_q:
            fn = timer_q.pop()
            fn()

    def nsITimer(self, func, delayMillis, repeating=False):

        '''For implementation of Timer() we use xpcom interfaces
        nsITimer and nsITimerCallback.

        This method returns a nsITimer which has been initialized with
        func as the callback (wrapped in an instance of
        nsITimerCallback).
        '''

        # create the xpcom nsITimer instance
        timer = components.classes['@mozilla.org/timer;1'].createInstance()
        timer.QueryInterface(interfaces.nsITimer)

        # what kind of timer are we?
        timertype = (interfaces.nsITimer.TYPE_REPEATING_SLACK
                     if repeating
                     else interfaces.nsITimer.TYPE_ONE_SHOT)

        # create the callback object (nsITimerCallback)
        cb = xpcom.server.WrapObject(nsITimerCallback(func),
                                     interfaces.nsITimerCallback)

        # initialize and return the timer
        timer.initWithCallback(cb, delayMillis, timertype)
        return timer
Example #7
0
class Browser(WebView):
    def __init__(self, application, appdir):
        WebView.__init__(self)
        self.platform = 'hulahop'
        self.progress = ProgressListener()
        self.application = application
        self.appdir = appdir
        self.already_initialised = False

        io_service_class = components.classes[ \
        "@mozilla.org/network/io-service;1"]
        io_service = io_service_class.getService(interfaces.nsIIOService)

        # Use xpcom to turn off "offline mode" detection, which disables
        # access to localhost for no good reason.  (Trac #6250.)
        io_service2 = io_service_class.getService(interfaces.nsIIOService2)
        io_service2.manageOfflineStatus = False

        self.progress.connect('loading-stop', self._loaded)
        self.progress.connect('loading-progress', self._loading)

    def _alert(self, txt):
        print "_alert", txt

        #self.get_prompt_svc().alert(None, "Alert", txt)

        def close(w):
            dialog.destroy()

        dialog = gtk.Dialog("Alert", None, gtk.DIALOG_DESTROY_WITH_PARENT)
        label = gtk.Label(txt)
        dialog.vbox.add(label)
        label.show()
        button = gtk.Button("OK")
        dialog.action_area.pack_start(button, True, True, 0)
        button.connect("clicked", close)
        button.show()
        dialog.run()

    def get_prompt_svc(self):

        prompt_svc_cls = components.classes[ \
            "@mozilla.org/embedcomp/prompt-service;1"]
        return prompt_svc_cls.createInstance(interfaces.nsIPromptService)

    def load_app(self):

        uri = self.application
        if uri.find(":") == -1:
            # assume file
            uri = 'file://' + os.path.abspath(uri)

        self.application = uri
        self.load_uri(uri)

    def do_setup(self):
        WebView.do_setup(self)
        self.progress.setup(self)

    def _addXMLHttpRequestEventListener(self, node, event_name, event_fn):

        listener = xpcom.server.WrapObject(ContentInvoker(node, event_fn),
                                           interfaces.nsIDOMEventListener)
        print event_name, listener
        node.addEventListener(event_name, listener, False)
        return listener

    def addEventListener(self, node, event_name, event_fn):

        listener = xpcom.server.WrapObject(ContentInvoker(node, event_fn),
                                           interfaces.nsIDOMEventListener)
        node.addEventListener(event_name, listener, True)
        return listener

    def mash_attrib(self, attrib_name):
        return attrib_name

    def _addWindowEventListener(self, event_name, event_fn, win=None):

        if win is None:
            win = self.window_root
        listener = xpcom.server.WrapObject(ContentInvoker(win, event_fn),
                                           interfaces.nsIDOMEventListener)
        win.addEventListener(event_name, listener, True)
        return listener

    def getDOMParser(self):
        xml_svc_cls = components.classes[ \
            "@mozilla.org/xmlextras/domparser;1"]
        return xml_svc_cls.createInstance(interfaces.nsIDOMParser)

    def getXmlHttpRequest(self):
        xml_svc_cls = components.classes[ \
            "@mozilla.org/xmlextras/xmlhttprequest;1"]
        return xml_svc_cls.createInstance(interfaces.nsIXMLHttpRequest)

    def getUri(self):
        return self.application

    def getDomWindow(self):
        return self.get_dom_window()

    def getDomDocument(self):
        return self.get_dom_window().document

    def _loaded(self, progress_listener):

        print "loaded"

        if self.already_initialised:
            return
        self.already_initialised = True

        dw = self.get_dom_window()
        doc = dw.document

        from __pyjamas__ import pygwt_processMetas, set_main_frame
        from __pyjamas__ import set_gtk_module
        set_main_frame(self)
        set_gtk_module(gtk)

        (pth, app) = os.path.split(self.application)
        if self.appdir:
            pth = os.path.abspath(self.appdir)
        sys.path.append(pth)

        #for m in pygwt_processMetas():
        #    minst = module_load(m)
        #    if hasattr(minst, "onModuleLoad"):
        #        minst.onModuleLoad()

    def _loading(self, progress_listener, progress):
        pass
        #print "loading", progress, self.getDomWindow().location.href

    def _trigger_fake_button(self):
        doc = self.getDomDocument()
        wnd = self.getDomWindow()
        element = self._hack_timer_workaround_bug_button
        evt = doc.createEvent('MouseEvents')
        evt.initMouseEvent("click", True, True, wnd, 1, 0, 0, 0, 0, False,
                           False, False, False, 0, element)
        element.dispatchEvent(evt)

    def _timer_callback_workaround(self, *args):

        global timer_q
        while timer_q:
            fn = timer_q.pop()
            fn()

    def nsITimer(self, func, delayMillis, repeating=False):
        '''For implementation of Timer() we use xpcom interfaces
        nsITimer and nsITimerCallback.

        This method returns a nsITimer which has been initialized with
        func as the callback (wrapped in an instance of
        nsITimerCallback).
        '''

        # create the xpcom nsITimer instance
        timer = components.classes['@mozilla.org/timer;1'].createInstance()
        timer.QueryInterface(interfaces.nsITimer)

        # what kind of timer are we?
        timertype = (interfaces.nsITimer.TYPE_REPEATING_SLACK
                     if repeating else interfaces.nsITimer.TYPE_ONE_SHOT)

        # create the callback object (nsITimerCallback)
        cb = xpcom.server.WrapObject(nsITimerCallback(func),
                                     interfaces.nsITimerCallback)

        # initialize and return the timer
        timer.initWithCallback(cb, delayMillis, timertype)
        return timer
    def __init__(self):
        WebView.__init__(self)

        self.progress = ProgressListener()
Example #9
0
class ContentWindow(gtk.HBox):
    
    def __init__(self, toolbar=None):
        gtk.HBox.__init__(self, False)
        
        self._create_treeview()
        sw = gtk.ScrolledWindow()
        sw.add(self.treeview)
        self.pack_start(sw, False)
        self.treeview.set_size_request(300, -1)
        
        self.web_view = None
        self.last_uri = HOME_PAGE
        
        self.connect("expose-event", self._exposed)
        self.show_all()

        self.library_type = "advanced"
        
        # Could be loaded on expose, but the set_url function won't work
        self._load_treeview()
    
    def switch(self, toolbutton, library_type):
        self.library_type = library_type
        self._load_treeview()
    
    def _create_browser(self):
        if hulahop_ok:
            self.web_view = WebView()
            self.pack_start(self.web_view, True, True)
            self.progress_listener = ProgressListener()
            self.progress_listener.setup(self.web_view)
            self.progress_listener.connect('location-changed', self._location_changed_cb)
            
            self.web_view.load_uri(self.last_uri)
            self.web_view.show()
        else:
            self.web_view = gtk.Button()
            self.web_view.load_uri = self.web_view.set_label
            self.web_view.load_uri(self.last_uri)
            self.add(self.web_view)
            self.web_view.show()
    
    def _create_treeview(self):
        # Provided by Poteland:
        # create a TreeStore with one string column to use as the model
        self.treestore = gtk.TreeStore(str, str)
        
        # create the TreeView using treestore
        self.treeview = gtk.TreeView(self.treestore)
        
        # create the TreeViewColumn to display the data
        tvcolumn = gtk.TreeViewColumn("")
        cell = gtk.CellRendererText()
        tvcolumn.pack_start(cell, True)
        self.treeview.append_column(tvcolumn)
        
        # set the cell "text" attribute to column 0 - retrieve text
        tvcolumn.add_attribute(cell, 'text', 0)
        
        # make it searchable
        self.treeview.set_search_column(0)
        
        self.treeview_loaded = False
        self.treeview.connect("cursor-changed", self.cursor_changed_cb)
        
    def _exposed(self, widget, event):
        if not self.treeview_loaded:
            self.path_iter = {}
            self.treeview_loaded = True
            self._load_treeview()
            
        if not self.web_view:
            # First exposes the widget and then (when idle) creates the browser, so the screen shows up faster
            self.web_view = True # temporary so the conditions doesn't meet
            gobject.idle_add(self._create_browser)
            
    def ditch(self):
        """ Called when we need to ditch the browsing window and hide the whole window """
        if self.web_view:
            self.remove(self.web_view)
            self.web_view = None
            self.progress_listener = None
    
    def _load_treeview(self):
        self.treeview_loaded = True
        self.path_iter = {}
        self.treestore.clear()
        self._load_treeview_recursive(ROOT_PATH, None)
    
    def _load_treeview_recursive(self, directory, parent_iter):
        dirList = listdir(directory)
        for node in sorted(dirList):
            load = self.check_type(node)
            if load:
                nodepath = os.path.join(directory, node)
                if isfile(nodepath):
                    if node.endswith(".html") and not node in ignore_list:
                        display_name = self.get_display_name(node)
                        _iter = self.treestore.append(parent_iter, (display_name, nodepath.encode("utf-8")))
                        self.path_iter[nodepath] = _iter
                else:
                    if not node in ignore_list:
                        display_name = self.get_display_name(node)
                        path = self.check_default_file(nodepath)
                        _iter = self.treestore.append(parent_iter, (display_name, path.encode("utf-8")))
                        self.path_iter[path] = _iter
                        self._load_treeview_recursive(nodepath, _iter)
    
    def check_type(self, node):
        if self.library_type == "advanced" and "-simple" in node:
            return False
        elif self.library_type == "basic" and "-avanzado" in node:
            return False
        else:
            return True
    
    def check_default_file(self, nodepath):
        aux = os.path.join(nodepath, "default-avanzado.html")
        if exists(aux):
            return aux
            
        aux = os.path.join(nodepath, "default-simple.html")
        if exists(aux):
            return aux
            
        aux = os.path.join(nodepath, "default.html")
        if exists(aux):
            return aux
        
        return nodepath

    def get_display_name(self, file_name):
        display_name = file_name.replace(".html", "")
        display_name = display_name.replace("-avanzado", "")
        display_name = display_name.replace("-simple", "")
        display_name = display_name.split("-", 1)[-1]
        return display_name
    
    def cursor_changed_cb(self, treeview):
        tree_path, column = self.treeview.get_cursor()
        
        it = self.treestore.get_iter(tree_path)
        path = self.treestore.get_value(it, 1)
        
        if path.endswith(".html") and self.web_view:
            uri = u"file://" + unicode(path, "utf-8")
            if not self.last_uri.startswith(uri):           # avoids reloading a page when the cursor is changed by the program
                self.last_uri = uri
                self.web_view.load_uri(self.last_uri)

    def _location_changed_cb(self, progress_listener, uri):
        if uri:
            path = utilities.unquote(uri.path.encode("utf-8"))
            uri = u"file://" + path
            if self.last_uri <> uri:
                self.last_uri = uri
                onlypath = path.split("#")[0]
                self.position_in_filename(onlypath)
        
    def position_in_filename(self, filepath):
        if filepath in self.path_iter:
            _iter = self.path_iter[filepath]
            if self.treeview.get_selection().get_selected()[1] <> _iter:   # avoids falling in a loop with location_changed
                treepath = self.treestore.get_path(_iter)
                self.treeview.expand_to_path(treepath)
                self.treeview.set_cursor(treepath)
        
    def set_url(self, link, anchor=None):
        # First fix the link in advanced or simple:
        if self.library_type == "basic":
            link = link.replace("-avanzado", "-simple")
        
        # Then add the base path and position in the tree
        link = os.path.join(ROOT_PATH, link)
        self.position_in_filename(link)
        
        # Last add the protocol and the anchor
        if anchor:
            self.last_uri = u"file://" + link + u"#" + unicode(anchor)
        else:
            self.last_uri = u"file://" + link
        
        if self.web_view:
            self.web_view.load_uri( self.last_uri )
        
    def get_toolbar(self):
        toolbar = gtk.Toolbar()
        
        radio_adv = RadioToolButton()
        radio_adv.set_active(True)
        radio_adv.set_label("Avanzada")
        radio_adv.set_tooltip("Mostrar biblioteca avanzada")
        radio_adv.connect("clicked", self.switch, "advanced")
        toolbar.insert(radio_adv, -1)
        radio_adv.show()
        
        radio_bas = RadioToolButton(group=radio_adv)
        radio_bas.set_label("Simple")
        radio_bas.set_tooltip("Mostrar biblioteca sencilla")
        radio_bas.connect("clicked", self.switch, "basic")
        toolbar.insert(radio_bas, -1)
        
        toolbar.show_all()
        
        return toolbar
Example #10
0
class Browser(WebView):

    AGENT_SHEET = os.path.join(activity.get_bundle_path(), 
                               'agent-stylesheet.css')
    USER_SHEET = os.path.join(activity.get_activity_root(),
                              'data/style.user.css')

    def __init__(self):
        WebView.__init__(self)
        
        self.history = HistoryListener()
        self.progress = ProgressListener()
        self.userscript = ScriptListener()

        cls = components.classes["@mozilla.org/typeaheadfind;1"]
        self.typeahead = cls.createInstance(interfaces.nsITypeAheadFind)

        self._jobject = None

        io_service_class = components.classes[ \
                "@mozilla.org/network/io-service;1"]
        io_service = io_service_class.getService(interfaces.nsIIOService)

        # Use xpcom to turn off "offline mode" detection, which disables
        # access to localhost for no good reason.  (Trac #6250.)
        io_service2 = io_service_class.getService(interfaces.nsIIOService2)
        io_service2.manageOfflineStatus = False

        cls = components.classes['@mozilla.org/content/style-sheet-service;1']
        self.style_sheet_service = cls.getService(
                                            interfaces.nsIStyleSheetService)

        if os.path.exists(Browser.AGENT_SHEET):
            agent_sheet_uri = io_service.newURI('file:///' + 
                                                Browser.AGENT_SHEET,
                                                None, None)
            self.style_sheet_service.loadAndRegisterSheet(agent_sheet_uri,
                    interfaces.nsIStyleSheetService.AGENT_SHEET)

        if os.path.exists(Browser.USER_SHEET):
            self.user_sheet_uri = io_service.newURI('file:///' + 
                                               Browser.USER_SHEET,
                                               None, None)
            self.style_sheet_service.loadAndRegisterSheet(self.user_sheet_uri,
                    interfaces.nsIStyleSheetService.USER_SHEET)
                    
    def do_setup(self):
        WebView.do_setup(self)

        listener = xpcom.server.WrapObject(ContentInvoker(self),
                                           interfaces.nsIDOMEventListener)
        self.window_root.addEventListener('click', listener, False)

        listener = xpcom.server.WrapObject(CommandListener(self.dom_window),
                                           interfaces.nsIDOMEventListener)
        self.window_root.addEventListener('command', listener, False)

        self.progress.setup(self)

        self.history.setup(self.web_navigation)
        
        self.userscript.setup(self)

        self.typeahead.init(self.doc_shell)
        
    def get_session(self):
        return sessionstore.get_session(self)

    def set_session(self, data):
        return sessionstore.set_session(self, data)
        
    def update_userstyle(self):
        if self.style_sheet_service.sheetRegistered(self.user_sheet_uri,
                interfaces.nsIStyleSheetService.USER_SHEET):
            self.style_sheet_service.unregisterSheet(self.user_sheet_uri,
                    interfaces.nsIStyleSheetService.USER_SHEET)
    
        self.style_sheet_service.loadAndRegisterSheet(self.user_sheet_uri,
                interfaces.nsIStyleSheetService.USER_SHEET)

    def get_source(self, async_cb, async_err_cb):
        cls = components.classes[ \
                '@mozilla.org/embedding/browser/nsWebBrowserPersist;1']
        persist = cls.createInstance(interfaces.nsIWebBrowserPersist)
        # get the source from the cache
        persist.persistFlags = \
                interfaces.nsIWebBrowserPersist.PERSIST_FLAGS_FROM_CACHE

        temp_path = os.path.join(activity.get_activity_root(), 'instance')
        file_path = os.path.join(temp_path, '%i' % time.time())        
        cls = components.classes["@mozilla.org/file/local;1"]
        local_file = cls.createInstance(interfaces.nsILocalFile)
        local_file.initWithPath(file_path)

        progresslistener = GetSourceListener(file_path, async_cb, async_err_cb)
        persist.progressListener = xpcom.server.WrapObject(
            progresslistener, interfaces.nsIWebProgressListener)

        uri = self.web_navigation.currentURI            
        persist.saveURI(uri, self.doc_shell, None, None, None, local_file)

    def zoom_in(self):
        contentViewer = self.doc_shell.queryInterface( \
                interfaces.nsIDocShell).contentViewer
        if contentViewer is not None:
            markupDocumentViewer = contentViewer.queryInterface( \
                    interfaces.nsIMarkupDocumentViewer)
            markupDocumentViewer.fullZoom += _ZOOM_AMOUNT

    def zoom_out(self):
        contentViewer = self.doc_shell.queryInterface( \
                interfaces.nsIDocShell).contentViewer
        if contentViewer is not None:
            markupDocumentViewer = contentViewer.queryInterface( \
                    interfaces.nsIMarkupDocumentViewer)
            markupDocumentViewer.fullZoom -= _ZOOM_AMOUNT