From fab5b0f0f321fbea2782a7af2734a03962225c38 Mon Sep 17 00:00:00 2001 From: Tomeu Vizoso Date: Wed, 08 Jul 2009 13:49:49 +0000 Subject: Open new windows in tabs --- diff --git a/browser.py b/browser.py index b0a7ae7..08ee1a5 100644 --- a/browser.py +++ b/browser.py @@ -1,5 +1,6 @@ # Copyright (C) 2006, Red Hat, Inc. # Copyright (C) 2007, One Laptop Per Child +# Copyright (C) 2009, Tomeu Vizoso # # This program is free software; you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by @@ -85,7 +86,10 @@ class CommandListener(object): cert_exception = cls.createInstance(interfaces.hulahopAddCertException) cert_exception.showDialog(self._window) -class Browser(WebView): +class TabbedView(gtk.Notebook): + __gtype_name__ = 'TabbedView' + + _com_interfaces_ = interfaces.nsIWindowCreator AGENT_SHEET = os.path.join(activity.get_bundle_path(), 'agent-stylesheet.css') @@ -93,15 +97,10 @@ class Browser(WebView): 'user-stylesheet.css') def __init__(self): - WebView.__init__(self) - - self.history = HistoryListener() - self.progress = ProgressListener() + gobject.GObject.__init__(self) - cls = components.classes["@mozilla.org/typeaheadfind;1"] - self.typeahead = cls.createInstance(interfaces.nsITypeAheadFind) - - self._jobject = None + self.props.show_border = False + self.props.scrollable = True io_service_class = components.classes[ \ "@mozilla.org/network/io-service;1"] @@ -115,19 +114,165 @@ class Browser(WebView): cls = components.classes['@mozilla.org/content/style-sheet-service;1'] style_sheet_service = cls.getService(interfaces.nsIStyleSheetService) - if os.path.exists(Browser.AGENT_SHEET): + if os.path.exists(TabbedView.AGENT_SHEET): agent_sheet_uri = io_service.newURI('file:///' + - Browser.AGENT_SHEET, + TabbedView.AGENT_SHEET, None, None) style_sheet_service.loadAndRegisterSheet(agent_sheet_uri, interfaces.nsIStyleSheetService.AGENT_SHEET) - if os.path.exists(Browser.USER_SHEET): - user_sheet_uri = io_service.newURI('file:///' + Browser.USER_SHEET, + if os.path.exists(TabbedView.USER_SHEET): + user_sheet_uri = io_service.newURI('file:///' + TabbedView.USER_SHEET, None, None) style_sheet_service.loadAndRegisterSheet(user_sheet_uri, interfaces.nsIStyleSheetService.USER_SHEET) + cls = components.classes['@mozilla.org/embedcomp/window-watcher;1'] + window_watcher = cls.getService(interfaces.nsIWindowWatcher) + window_creator = xpcom.server.WrapObject(self, + interfaces.nsIWindowCreator) + window_watcher.setWindowCreator(window_creator) + + browser = Browser() + self._append_tab(browser) + + def createChromeWindow(self, parent, flags): + if flags & interfaces.nsIWebBrowserChrome.CHROME_OPENAS_CHROME: + dialog = PopupDialog() + dialog.view.is_chrome = True + + parent_dom_window = parent.webBrowser.contentDOMWindow + parent_view = hulahop.get_view_for_window(parent_dom_window) + if parent_view: + dialog.set_transient_for(parent_view.get_toplevel()) + + browser = dialog.view.browser + + item = browser.queryInterface(interfaces.nsIDocShellTreeItem) + item.itemType = interfaces.nsIDocShellTreeItem.typeChromeWrapper + + return browser.containerWindow + else: + browser = Browser() + self._append_tab(browser) + + return browser.browser.containerWindow + + def _append_tab(self, browser): + label = TabLabel(browser) + label.connect('tab-close', self.__tab_close_cb) + + self.append_page(browser, label) + browser.show() + + self.set_current_page(-1) + self.props.show_tabs = self.get_n_pages() > 1 + + def __tab_close_cb(self, label, browser): + self.remove_page(self.page_num(browser)) + browser.destroy() + self.props.show_tabs = self.get_n_pages() > 1 + + def _get_current_browser(self): + return self.get_nth_page(self.get_current_page()) + + current_browser = gobject.property(type=object, getter=_get_current_browser) + + def get_session(self): + tab_sessions = [] + for index in xrange(-1, self.get_n_pages() - 1): + browser = self.get_nth_page(index) + tab_sessions.append(sessionstore.get_session(browser)) + return tab_sessions + + def set_session(self, tab_sessions): + if tab_sessions and isinstance(tab_sessions[0], dict): + # Old format, no tabs + tab_sessions = [tab_sessions] + + while self.get_n_pages(): + self.remove_page(self.get_n_pages() - 1) + + for tab_session in tab_sessions: + browser = Browser() + self._append_tab(browser) + sessionstore.set_session(browser, tab_session) + +gtk.rc_parse_string(''' + style "browse-tab-close" { + xthickness = 0 + ythickness = 0 + } + widget "*browse-tab-close" style "browse-tab-close"''') + +class TabLabel(gtk.HBox): + __gtype_name__ = 'TabLabel' + + __gsignals__ = { + 'tab-close': (gobject.SIGNAL_RUN_FIRST, + gobject.TYPE_NONE, + ([object])) + } + + def __init__(self, browser): + gobject.GObject.__init__(self) + + self._browser = browser + self._browser.connect('is-setup', self.__browser_is_setup_cb) + + self._label = gtk.Label('') + self.pack_start(self._label) + self._label.show() + + button = gtk.Button() + button.connect('clicked', self.__button_clicked_cb) + button.set_name('browse-tab-close') + button.props.relief = gtk.RELIEF_NONE + button.props.focus_on_click = False + self.pack_start(button) + button.show() + + close_image = gtk.image_new_from_stock(gtk.STOCK_CLOSE, + gtk.ICON_SIZE_MENU) + button.add(close_image) + close_image.show() + + def __button_clicked_cb(self, button): + self.emit('tab-close', self._browser) + + def __browser_is_setup_cb(self, browser): + browser.progress.connect('notify::location', self.__location_changed_cb) + browser.connect('notify::title', self.__title_changed_cb) + + def __location_changed_cb(self, progress_listener, pspec): + uri = progress_listener.location + cls = components.classes['@mozilla.org/intl/texttosuburi;1'] + texttosuburi = cls.getService(interfaces.nsITextToSubURI) + ui_uri = texttosuburi.unEscapeURIForUI(uri.originCharset, uri.spec) + + self._label.set_text(ui_uri) + + def __title_changed_cb(self, browser, pspec): + self._label.set_text(browser.props.title) + +class Browser(WebView): + __gtype_name__ = 'Browser' + + __gsignals__ = { + 'is-setup': (gobject.SIGNAL_RUN_FIRST, + gobject.TYPE_NONE, + ([])) + } + + def __init__(self): + WebView.__init__(self) + + self.history = HistoryListener() + self.progress = ProgressListener() + + cls = components.classes["@mozilla.org/typeaheadfind;1"] + self.typeahead = cls.createInstance(interfaces.nsITypeAheadFind) + def do_setup(self): WebView.do_setup(self) @@ -145,6 +290,8 @@ class Browser(WebView): self.typeahead.init(self.doc_shell) + self.emit('is-setup') + def get_session(self): return sessionstore.get_session(self) @@ -199,31 +346,12 @@ class PopupDialog(gtk.Window): gtk.gdk.screen_height() - border * 2) self.view = WebView() + self.view.connect('notify::visibility', self.__notify_visibility_cb) self.add(self.view) self.view.realize() -class WindowCreator: - _com_interfaces_ = interfaces.nsIWindowCreator - - def createChromeWindow(self, parent, flags): - dialog = PopupDialog() - - parent_dom_window = parent.webBrowser.contentDOMWindow - parent_view = hulahop.get_view_for_window(parent_dom_window) - if parent_view: - dialog.set_transient_for(parent_view.get_toplevel()) - - browser = dialog.view.browser - - if flags & interfaces.nsIWebBrowserChrome.CHROME_OPENAS_CHROME: - dialog.view.is_chrome = True - - item = browser.queryInterface(interfaces.nsIDocShellTreeItem) - item.itemType = interfaces.nsIDocShellTreeItem.typeChromeWrapper - - return browser.containerWindow + def __notify_visibility_cb(self, web_view, pspec): + if self.view.props.visibility: + self.view.show() + self.show() -window_creator = WindowCreator() -cls = components.classes['@mozilla.org/embedcomp/window-watcher;1'] -window_watcher = cls.getService(interfaces.nsIWindowWatcher) -window_watcher.setWindowCreator(window_creator) diff --git a/downloadmanager.py b/downloadmanager.py index 69d1c8a..44dc99f 100644 --- a/downloadmanager.py +++ b/downloadmanager.py @@ -1,4 +1,5 @@ # Copyright (C) 2007, One Laptop Per Child +# Copyright (C) 2009, Tomeu Vizoso # # This program is free software; you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by @@ -113,7 +114,7 @@ components.registrar.registerFactory('{64355793-988d-40a5-ba8e-fcde78cac631}', class Download: _com_interfaces_ = interfaces.nsITransfer - + def init(self, source, target, display_name, mime_info, start_time, temp_file, cancelable): self._source = source @@ -134,7 +135,7 @@ class Download: del _dest_to_window[self._target_file.path] view = hulahop.get_view_for_window(dom_window) - print dom_window + logging.debug('Download.init dom_window: %r' % dom_window) self._activity = view.get_toplevel() return NS_OK diff --git a/progresslistener.py b/progresslistener.py index 23d4966..5ac7d7a 100644 --- a/progresslistener.py +++ b/progresslistener.py @@ -1,5 +1,6 @@ # Copyright (C) 2006, Red Hat, Inc. # Copyright (C) 2007, One Laptop Per Child +# Copyright (C) 2009, Tomeu Vizoso # # This program is free software; you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by @@ -22,29 +23,19 @@ from xpcom.components import interfaces class ProgressListener(gobject.GObject): _com_interfaces_ = interfaces.nsIWebProgressListener - __gsignals__ = { - 'location-changed': (gobject.SIGNAL_RUN_FIRST, gobject.TYPE_NONE, - ([object])), - 'loading-start': (gobject.SIGNAL_RUN_FIRST, gobject.TYPE_NONE, - ([])), - 'loading-stop': (gobject.SIGNAL_RUN_FIRST, gobject.TYPE_NONE, - ([])), - 'loading-progress': (gobject.SIGNAL_RUN_FIRST, gobject.TYPE_NONE, - ([float])) - } - def __init__(self): gobject.GObject.__init__(self) - self.total_requests = 0 - self.completed_requests = 0 + self._location = None + self._loading = False + self._progress = 0.0 + self._total_requests = 0 + self._completed_requests = 0 self._wrapped_self = xpcom.server.WrapObject( \ self, interfaces.nsIWebProgressListener) weak_ref = xpcom.client.WeakReference(self._wrapped_self) - self._reset_requests_count() - def setup(self, browser): mask = interfaces.nsIWebProgress.NOTIFY_STATE_NETWORK | \ interfaces.nsIWebProgress.NOTIFY_STATE_REQUEST | \ @@ -53,12 +44,13 @@ class ProgressListener(gobject.GObject): browser.web_progress.addProgressListener(self._wrapped_self, mask) def _reset_requests_count(self): - self.total_requests = 0 - self.completed_requests = 0 + self._total_requests = 0 + self._completed_requests = 0 def onLocationChange(self, webProgress, request, location): - self.emit('location-changed', location) - + self._location = location + self.notify('location') + def onProgressChange(self, webProgress, request, curSelfProgress, maxSelfProgress, curTotalProgress, maxTotalProgress): pass @@ -69,24 +61,43 @@ class ProgressListener(gobject.GObject): def onStateChange(self, webProgress, request, stateFlags, status): if stateFlags & interfaces.nsIWebProgressListener.STATE_IS_REQUEST: if stateFlags & interfaces.nsIWebProgressListener.STATE_START: - self.total_requests += 1 + self._total_requests += 1 elif stateFlags & interfaces.nsIWebProgressListener.STATE_STOP: - self.completed_requests += 1 + self._completed_requests += 1 if stateFlags & interfaces.nsIWebProgressListener.STATE_IS_NETWORK: if stateFlags & interfaces.nsIWebProgressListener.STATE_START: - self.emit('loading-start') + self._loading = True self._reset_requests_count() + self.notify('loading') elif stateFlags & interfaces.nsIWebProgressListener.STATE_STOP: - self.emit('loading-stop') + self._loading = False + self.notify('loading') - if self.total_requests < self.completed_requests: - self.emit('loading-progress', 1.0) - elif self.total_requests > 0: - self.emit('loading-progress', float(self.completed_requests) / - float(self.total_requests)) + if self._total_requests < self._completed_requests: + self._progress = 1.0 + elif self._total_requests > 0: + self._progress = \ + self._completed_requests / float(self._total_requests) else: - self.emit('loading-progress', 0.0) + self._progress = 0.0 + self.notify('progress') def onStatusChange(self, webProgress, request, status, message): pass + + def _get_location(self): + return self._location + + location = gobject.property(type=object, getter=_get_location) + + def _get_loading(self): + return self._loading + + loading = gobject.property(type=bool, default=False, getter=_get_loading) + + def _get_progress(self): + return self._progress + + progress = gobject.property(type=float, getter=_get_progress) + diff --git a/viewtoolbar.py b/viewtoolbar.py index 2b08360..3564269 100644 --- a/viewtoolbar.py +++ b/viewtoolbar.py @@ -1,4 +1,5 @@ # Copyright (C) 2007, One Laptop Per Child +# Copyright (C) 2009, Tomeu Vizoso # # This program is free software; you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by @@ -27,8 +28,6 @@ class ViewToolbar(gtk.Toolbar): self._activity = activity self._activity.tray.connect('unmap', self.__unmap_cb) self._activity.tray.connect('map', self.__map_cb) - - self._browser = self._activity._browser self.zoomout = ToolButton('zoom-out') self.zoomout.set_tooltip(_('Zoom out')) @@ -60,11 +59,13 @@ class ViewToolbar(gtk.Toolbar): self.traybutton.show() def __zoomin_clicked_cb(self, button): - self._browser.zoom_in() - + tabbed_view = self._activity.get_canvas() + tabbed_view.props.current_browser.zoom_in() + def __zoomout_clicked_cb(self, button): - self._browser.zoom_out() - + tabbed_view = self._activity.get_canvas() + tabbed_view.props.current_browser.zoom_out() + def __fullscreen_clicked_cb(self, button): self._activity.fullscreen() diff --git a/webactivity.py b/webactivity.py index a7c55bb..f1e1313 100644 --- a/webactivity.py +++ b/webactivity.py @@ -1,5 +1,5 @@ # Copyright (C) 2006, Red Hat, Inc. -# Copyright (C) 2009 Martin Langhoff, Simon Schampijer, Daniel Drake +# Copyright (C) 2009 Martin Langhoff, Simon Schampijer, Daniel Drake, Tomeu Vizoso # # This program is free software; you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by @@ -152,7 +152,7 @@ def _set_accept_languages(): branch.setCharPref('intl.accept_languages', pref) logging.debug('LANG set') -from browser import Browser +from browser import TabbedView from edittoolbar import EditToolbar from webtoolbar import WebToolbar from viewtoolbar import ViewToolbar @@ -182,7 +182,7 @@ class WebActivity(activity.Activity): _logger.debug('Starting the web activity') - self._browser = Browser() + self._tabbed_view = TabbedView() _set_accept_languages() _seed_xs_cookie() @@ -195,11 +195,12 @@ class WebActivity(activity.Activity): toolbox = activity.ActivityToolbox(self) - self._edit_toolbar = EditToolbar(self._browser) + self._edit_toolbar = EditToolbar(self._tabbed_view) toolbox.add_toolbar(_('Edit'), self._edit_toolbar) self._edit_toolbar.show() - self._web_toolbar = WebToolbar(self._browser) + self._web_toolbar = WebToolbar(self._tabbed_view) + self._web_toolbar.connect('add-link', self._link_add_button_cb) toolbox.add_toolbar(_('Browse'), self._web_toolbar) self._web_toolbar.show() @@ -214,26 +215,18 @@ class WebActivity(activity.Activity): self.set_toolbox(toolbox) toolbox.show() - self.set_canvas(self._browser) - self._browser.show() - - self._browser.history.connect('session-link-changed', - self._session_history_changed_cb) - self._web_toolbar.connect('add-link', self._link_add_button_cb) - - self._browser.connect("notify::title", self._title_changed_cb) + self.set_canvas(self._tabbed_view) + self._tabbed_view.show() self.model = Model() self.model.connect('add_link', self._add_link_model_cb) - self.current = _('blank') - self.webtitle = _('blank') self.connect('key-press-event', self._key_press_cb) self.toolbox.set_current_toolbar(_TOOLBAR_BROWSE) if handle.uri: - self._browser.load_uri(handle.uri) + self._tabbed_view.current_browser.load_uri(handle.uri) elif not self._jobject.file_path: # TODO: we need this hack until we extend the activity API for # opening URIs and default docs. @@ -362,23 +355,14 @@ class WebActivity(activity.Activity): self.messenger = Messenger(self.tube_conn, self.initiating, self.model) - def _load_homepage(self): + browser = self._tabbed_view.current_browser if os.path.isfile(_LIBRARY_PATH): - self._browser.load_uri('file://' + _LIBRARY_PATH) + browser.load_uri('file://' + _LIBRARY_PATH) else: default_page = os.path.join(activity.get_bundle_path(), "data/index.html") - self._browser.load_uri(default_page) - - def _session_history_changed_cb(self, session_history, link): - _logger.debug('NewPage: %s.' %link) - self.current = link - - def _title_changed_cb(self, embed, pspec): - if embed.props.title is not '': - _logger.debug('Title changed=%s' % embed.props.title) - self.webtitle = embed.props.title + browser.load_uri(default_page) def _get_data_from_file_path(self, file_path): fd = open(file_path, 'r') @@ -401,43 +385,46 @@ class WebActivity(activity.Activity): base64.b64decode(link['thumb']), link['color'], link['title'], link['owner'], -1, link['hash']) - self._browser.set_session(self.model.data['history']) + logging.debug('########## reading %s' % data) + self._tabbed_view.set_session(self.model.data['history']) elif self.metadata['mime_type'] == 'text/uri-list': data = self._get_data_from_file_path(file_path) uris = mime.split_uri_list(data) if len(uris) == 1: - self._browser.load_uri(uris[0]) + self._tabbed_view.props.current_browser.load_uri(uris[0]) else: _logger.error('Open uri-list: Does not support' 'list of multiple uris by now.') else: - self._browser.load_uri(file_path) + self._tabbed_view.props.current_browser.load_uri(file_path) def write_file(self, file_path): if not self.metadata['mime_type']: self.metadata['mime_type'] = 'text/plain' - + if self.metadata['mime_type'] == 'text/plain': + + browser = self._tabbed_view.current_browser + if not self._jobject.metadata['title_set_by_user'] == '1': - if self._browser.props.title: - self.metadata['title'] = self._browser.props.title + if browser.props.title: + self.metadata['title'] = browser.props.title - self.model.data['history'] = self._browser.get_session() + self.model.data['history'] = self._tabbed_view.get_session() f = open(file_path, 'w') try: + logging.debug('########## writing %s' % self.model.serialize()) f.write(self.model.serialize()) finally: f.close() def _link_add_button_cb(self, button): - _logger.debug('button: Add link: %s.' % self.current) self._add_link() def _key_press_cb(self, widget, event): if event.state & gtk.gdk.CONTROL_MASK: if gtk.gdk.keyval_name(event.keyval) == "d": - _logger.debug('keyboard: Add link: %s.' % self.current) self._add_link() return True elif gtk.gdk.keyval_name(event.keyval) == "f": @@ -452,30 +439,37 @@ class WebActivity(activity.Activity): return True elif gtk.gdk.keyval_name(event.keyval) == "minus": _logger.debug('keyboard: Zoom out') - self._browser.zoom_out() + self._tabbed_view.props.current_browser.zoom_out() return True elif gtk.gdk.keyval_name(event.keyval) == "plus" \ or gtk.gdk.keyval_name(event.keyval) == "equal" : _logger.debug('keyboard: Zoom in') - self._browser.zoom_in() + self._tabbed_view.props.current_browser.zoom_in() return True return False def _add_link(self): ''' take screenshot and add link info to the model ''' + + browser = self._tabbed_view.props.current_browser + uri = browser.progress_listener.location + cls = components.classes['@mozilla.org/intl/texttosuburi;1'] + texttosuburi = cls.getService(interfaces.nsITextToSubURI) + ui_uri = texttosuburi.unEscapeURIForUI(uri.originCharset, uri.spec) + for link in self.model.data['shared_links']: - if link['hash'] == sha.new(self.current).hexdigest(): + if link['hash'] == sha.new(ui_uri).hexdigest(): _logger.debug('_add_link: link exist already a=%s b=%s' %( - link['hash'], sha.new(self.current).hexdigest())) + link['hash'], sha.new(ui_uri).hexdigest())) return buf = self._get_screenshot() timestamp = time.time() - self.model.add_link(self.current, self.webtitle, buf, + self.model.add_link(ui_uri, browser.props.title, buf, profile.get_nick_name(), profile.get_color().to_string(), timestamp) if self.messenger is not None: - self.messenger._add_link(self.current, self.webtitle, + self.messenger._add_link(ui_uri, browser.props.title, profile.get_color().to_string(), profile.get_nick_name(), base64.b64encode(buf), timestamp) @@ -507,7 +501,7 @@ class WebActivity(activity.Activity): def _link_clicked_cb(self, button, url): ''' an item of the link tray has been clicked ''' - self._browser.load_uri(url) + self._tabbed_view.props.current_browser.load_uri(url) def _pixbuf_save_cb(self, buf, data): data[0] += buf @@ -519,7 +513,7 @@ class WebActivity(activity.Activity): return str(data[0]) def _get_screenshot(self): - window = self._browser.window + window = self._tabbed_view.props.current_browser.window width, height = window.get_size() screenshot = gtk.gdk.Pixbuf(gtk.gdk.COLORSPACE_RGB, has_alpha=False, @@ -562,4 +556,6 @@ class WebActivity(activity.Activity): self.close(force=True) def get_document_path(self, async_cb, async_err_cb): - self._browser.get_source(async_cb, async_err_cb) + browser = self._tabbed_view.props.current_browser + browser.get_source(async_cb, async_err_cb) + diff --git a/webtoolbar.py b/webtoolbar.py index 428fd89..f942fa8 100644 --- a/webtoolbar.py +++ b/webtoolbar.py @@ -1,5 +1,6 @@ # Copyright (C) 2006, Red Hat, Inc. # Copyright (C) 2007, One Laptop Per Child +# Copyright (C) 2009, Tomeu Vizoso # # This program is free software; you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by @@ -220,10 +221,10 @@ class WebToolbar(gtk.Toolbar): ([])) } - def __init__(self, browser): + def __init__(self, tabbed_view): gtk.Toolbar.__init__(self) - self._browser = browser + self._tabbed_view = tabbed_view self._loading = False @@ -262,50 +263,92 @@ class WebToolbar(gtk.Toolbar): self._link_add.connect('clicked', self._link_add_clicked_cb) self.insert(self._link_add, -1) self._link_add.show() - - progress_listener = browser.progress - progress_listener.connect('location-changed', - self._location_changed_cb) - progress_listener.connect('loading-start', self._loading_start_cb) - progress_listener.connect('loading-stop', self._loading_stop_cb) - progress_listener.connect('loading-progress', - self._loading_progress_cb) - self._browser.history.connect('session-history-changed', - self._session_history_changed_cb) + self._progress_listener = None + self._history = None + self._browser = None + + self._location_changed_hid = None + self._loading_changed_hid = None + self._progress_changed_hid = None + self._session_history_changed_hid = None + self._title_changed_hid = None + + gobject.idle_add(lambda: + self._connect_to_browser(tabbed_view.props.current_browser)) + + tabbed_view.connect_after('switch-page', self.__switch_page_cb) + + def __switch_page_cb(self, tabbed_view, page, page_num): + self._connect_to_browser(tabbed_view.props.current_browser) + + def _connect_to_browser(self, browser): + if self._progress_listener is not None: + self._progress_listener.disconnect(self._location_changed_hid) + self._progress_listener.disconnect(self._loading_changed_hid) + self._progress_listener.disconnect(self._progress_changed_hid) + + self._progress_listener = browser.progress + self._set_progress(self._progress_listener.progress) + if self._progress_listener.location: + self._set_address(self._progress_listener.location) + else: + self._set_address(None) + self._set_loading(self._progress_listener.loading) + self._update_navigation_buttons() + + self._location_changed_hid = self._progress_listener.connect( + 'notify::location', self.__location_changed_cb) + self._loading_changed_hid = self._progress_listener.connect( + 'notify::loading', self.__loading_changed_cb) + self._progress_changed_hid = self._progress_listener.connect( + 'notify::progress', self.__progress_changed_cb) - self._browser.connect("notify::title", self._title_changed_cb) + if self._history is not None: + self._history.disconnect(self._session_history_changed_hid) + + self._history = browser.history + self._session_history_changed_hid = self._history.connect( + 'session-history-changed', self._session_history_changed_cb) + + if self._browser is not None: + self._browser.disconnect(self._title_changed_hid) + + self._browser = browser + self._set_title(self._browser.props.title) + + self._title_changed_hid = self._browser.connect( + 'notify::title', self._title_changed_cb) def _session_history_changed_cb(self, session_history, current_page_index): # We have to wait until the history info is updated. gobject.idle_add(self._reload_session_history, current_page_index) - def _location_changed_cb(self, progress_listener, uri): - cls = components.classes['@mozilla.org/intl/texttosuburi;1'] - texttosuburi = cls.getService(interfaces.nsITextToSubURI) - ui_uri = texttosuburi.unEscapeURIForUI(uri.originCharset, uri.spec) - - self._set_address(ui_uri) + def __location_changed_cb(self, progress_listener, pspec): + self._set_address(progress_listener.location) self._update_navigation_buttons() filepicker.cleanup_temp_files() - def _loading_start_cb(self, progress_listener): - self._set_title(None) - self._set_loading(True) + def __loading_changed_cb(self, progress_listener, pspec): + if progress_listener.loading: + self._set_title(None) + self._set_loading(progress_listener.loading) self._update_navigation_buttons() - def _loading_stop_cb(self, progress_listener): - self._set_loading(False) - self._update_navigation_buttons() - - def _loading_progress_cb(self, progress_listener, progress): - self._set_progress(progress) + def __progress_changed_cb(self, progress_listener, pspec): + self._set_progress(progress_listener.progress) def _set_progress(self, progress): self.entry.props.progress = progress - def _set_address(self, address): - self.entry.props.address = address + def _set_address(self, uri): + if uri is not None: + cls = components.classes['@mozilla.org/intl/texttosuburi;1'] + texttosuburi = cls.getService(interfaces.nsITextToSubURI) + ui_uri = texttosuburi.unEscapeURIForUI(uri.originCharset, uri.spec) + else: + ui_uri = None + self.entry.props.address = ui_uri def _set_title(self, title): self.entry.props.title = title @@ -317,32 +360,37 @@ class WebToolbar(gtk.Toolbar): self._stop_and_reload.set_icon('view-refresh') def _update_navigation_buttons(self): - can_go_back = self._browser.web_navigation.canGoBack + browser = self._tabbed_view.props.current_browser + + can_go_back = browser.web_navigation.canGoBack self._back.props.sensitive = can_go_back - can_go_forward = self._browser.web_navigation.canGoForward + can_go_forward = browser.web_navigation.canGoForward self._forward.props.sensitive = can_go_forward def _entry_activate_cb(self, entry): - self._browser.load_uri(entry.props.text) - self._browser.grab_focus() + browser = self._tabbed_view.props.current_browser + browser.load_uri(entry.props.text) + browser.grab_focus() def _go_back_cb(self, button): - self._browser.web_navigation.goBack() + browser = self._tabbed_view.props.current_browser + browser.web_navigation.goBack() def _go_forward_cb(self, button): - self._browser.web_navigation.goForward() + browser = self._tabbed_view.props.current_browser + browser.web_navigation.goForward() def _title_changed_cb(self, embed, spec): self._set_title(embed.props.title) def _stop_and_reload_cb(self, button): + browser = self._tabbed_view.props.current_browser if self._loading: - self._browser.web_navigation.stop( \ - interfaces.nsIWebNavigation.STOP_ALL) + browser.web_navigation.stop(interfaces.nsIWebNavigation.STOP_ALL) else: flags = interfaces.nsIWebNavigation.LOAD_FLAGS_NONE - self._browser.web_navigation.reload(flags) + browser.web_navigation.reload(flags) def _set_loading(self, loading): self._loading = loading @@ -355,7 +403,8 @@ class WebToolbar(gtk.Toolbar): self._stop_and_reload.set_tooltip(_('Reload')) def _reload_session_history(self, current_page_index=None): - session_history = self._browser.web_navigation.sessionHistory + browser = self._tabbed_view.props.current_browser + session_history = browser.web_navigation.sessionHistory if current_page_index is None: current_page_index = session_history.index @@ -391,7 +440,8 @@ class WebToolbar(gtk.Toolbar): menu_item.show() def _history_item_activated_cb(self, menu_item, index): - self._browser.web_navigation.gotoIndex(index) + browser = self._tabbed_view.props.current_browser + browser.web_navigation.gotoIndex(index) def _link_add_clicked_cb(self, button): self.emit('add-link') -- cgit v0.9.1