Merge branch 'master' of git.sugarlabs.org:browse/mainline

6 files changed, 139 insertions, 135 deletions

diff --git a/browser.py b/browser.py
index 2fafc5b..5d5dc98 100644
--- a/browser.py
+++ b/browser.py
@@ -31,8 +31,9 @@ from sugar3.activity import activity
 from sugar3.graphics import style
 from sugar3.graphics.icon import Icon
 
+import sessionstore
+
 # FIXME
-# import sessionstore
 # from palettes import ContentInvoker
 # from sessionhistory import HistoryListener
 # from progresslistener import ProgressListener
@@ -181,8 +182,9 @@ class TabbedView(BrowserNotebook):
         self._update_tab_sizes()
 
     def __page_removed_cb(self, notebook, child, pagenum):
-        self._update_closing_buttons()
-        self._update_tab_sizes()
+        if self.get_n_pages():
+            self._update_closing_buttons()
+            self._update_tab_sizes()
 
     def __new_tab_cb(self, browser, url):
         new_browser = self.add_tab(next_to_current=True)
@@ -263,9 +265,7 @@ class TabbedView(BrowserNotebook):
         """Prevent closing the last tab."""
         first_page = self.get_nth_page(0)
         first_label = self.get_tab_label(first_page)
-        if self.get_n_pages() == 0:
-            return
-        elif self.get_n_pages() == 1:
+        if self.get_n_pages() == 1:
             first_label.hide_close_button()
         else:
             first_label.show_close_button()
@@ -278,10 +278,13 @@ class TabbedView(BrowserNotebook):
         else:
             default_page = os.path.join(activity.get_bundle_path(),
                                         "data/index.html")
-            browser.load_uri(default_page)
+            browser.load_uri('file://' + default_page)
 
     def _get_current_browser(self):
-        return self.get_nth_page(self.get_current_page()).get_child()
+        if self.get_n_pages():
+            return self.get_nth_page(self.get_current_page()).get_child()
+        else:
+            return None
 
     current_browser = GObject.property(type=object,
                                        getter=_get_current_browser)
@@ -289,7 +292,8 @@ class TabbedView(BrowserNotebook):
     def get_session(self):
         tab_sessions = []
         for index in xrange(0, self.get_n_pages()):
-            browser = self.get_nth_page(index)
+            scrolled_window = self.get_nth_page(index)
+            browser = scrolled_window.get_child()
             tab_sessions.append(sessionstore.get_session(browser))
         return tab_sessions
 
@@ -444,29 +448,11 @@ class Browser(WebKit.WebView):
         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
-
     def get_history_index(self):
-        return self.web_navigation.sessionHistory.index
+        return sessionstore.get_history_index(self)
 
     def set_history_index(self, index):
-        if index == -1:
-            return
-        self.web_navigation.gotoIndex(index)
+        return sessionstore.set_history_index(self, index)
 
     def open_new_tab(self, url):
         self.emit('new-tab', url)
diff --git a/edittoolbar.py b/edittoolbar.py
index ac54245..5c70546 100644
--- a/edittoolbar.py
+++ b/edittoolbar.py
@@ -15,6 +15,7 @@
 # along with this program; if not, write to the Free Software
 # Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 
+from gi.repository import GObject
 from gi.repository import Gtk
 from gi.repository import Gdk
 from gettext import gettext as _
@@ -30,36 +31,13 @@ class EditToolbar(activity.EditToolbar):
         activity.EditToolbar.__init__(self)
 
         self._activity = act
+        self._browser = None
 
         self.undo.connect('clicked', self.__undo_cb)
         self.redo.connect('clicked', self.__redo_cb)
         self.copy.connect('clicked', self.__copy_cb)
         self.paste.connect('clicked', self.__paste_cb)
 
-        """
-        Notifications are not working right now:
-        https://bugzilla.mozilla.org/show_bug.cgi?id=207339
-
-        command_manager = self._get_command_manager()
-        self.undo.set_sensitive(
-                command_manager.isCommandEnabled('cmd_undo', None))
-        self.redo.set_sensitive(
-                command_manager.isCommandEnabled('cmd_redo', None))
-        self.copy.set_sensitive(
-                command_manager.isCommandEnabled('cmd_copy', None))
-        self.paste.set_sensitive(
-                command_manager.isCommandEnabled('cmd_paste', None))
-
-        self._observer = xpcom.server.WrapObject(self, interfaces.nsIObserver)
-        command_manager.addCommandObserver(self._observer, 'cmd_undo')
-        command_manager.addCommandObserver(self._observer, 'cmd_redo')
-        command_manager.addCommandObserver(self._observer, 'cmd_copy')
-        command_manager.addCommandObserver(self._observer, 'cmd_paste')
-
-    def observe(self, subject, topic, data):
-        logging.debug('observe: %r %r %r' % (subject, topic, data))
-        """
-
         separator = Gtk.SeparatorToolItem()
         separator.set_draw(False)
         separator.set_expand(True)
@@ -97,38 +75,64 @@ class EditToolbar(activity.EditToolbar):
         self.insert(self._next, -1)
         self._next.show()
 
+        tabbed_view = self._activity.get_canvas()
+
+        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._browser is not None:
+            self._browser.disconnect(self._selection_changed_hid)
+
+        self._browser = browser
+
+        self._update_undoredo_buttons()
+        self._update_copypaste_buttons()
+
+        self._selection_changed_hid = self._browser.connect(
+                'selection-changed', self._selection_changed_cb)
+
+    def _selection_changed_cb(self, widget):
+        self._update_undoredo_buttons()
+        self._update_copypaste_buttons()
+
+    def _update_undoredo_buttons(self):
+        self.undo.set_sensitive(self._browser.can_undo())
+        self.redo.set_sensitive(self._browser.can_redo())
+
+    def _update_copypaste_buttons(self):
+        self.copy.set_sensitive(self._browser.can_copy_clipboard())
+        self.paste.set_sensitive(self._browser.can_paste_clipboard())
+
     def __undo_cb(self, button):
-        command_manager = self._get_command_manager()
-        command_manager.doCommand('cmd_undo', None, None)
+        self._browser.undo()
+        self._update_undoredo_buttons()
 
     def __redo_cb(self, button):
-        command_manager = self._get_command_manager()
-        command_manager.doCommand('cmd_redo', None, None)
+        self._browser.redo()
+        self._update_undoredo_buttons()
 
     def __copy_cb(self, button):
-        command_manager = self._get_command_manager()
-        command_manager.doCommand('cmd_copy', None, None)
+        self._browser.copy_clipboard()
 
     def __paste_cb(self, button):
-        command_manager = self._get_command_manager()
-        command_manager.doCommand('cmd_paste', None, None)
-
-    def _get_command_manager(self):
-        tabbed_view = self._activity.get_canvas()
-        web_browser = tabbed_view.props.current_browser.browser
-        interface_id = interfaces.nsIInterfaceRequestor
-        requestor = web_browser.queryInterface(interface_id)
-        return requestor.getInterface(interfaces.nsICommandManager)
+        self._browser.paste_clipboard()
 
     def __search_entry_activate_cb(self, entry):
-        tabbed_view = self._activity.get_canvas()
-        tabbed_view.props.current_browser.typeahead.findAgain(False, False)
+        search_text = entry.get_text()
+        self._browser.search_text(search_text, case_sensitive=False,
+                                  forward=True, wrap=True)
 
     def __search_entry_changed_cb(self, entry):
-        tabbed_view = self._activity.get_canvas()
-        found = tabbed_view.props.current_browser.typeahead.find( \
-            entry.props.text, False)
-        if found == interfaces.nsITypeAheadFind.FIND_NOTFOUND:
+        search_text = entry.get_text()
+        found = self._browser.search_text(search_text, case_sensitive=False,
+                                          forward=True, wrap=True)
+        if not found:
             self._prev.props.sensitive = False
             self._next.props.sensitive = False
             entry.modify_text(Gtk.StateType.NORMAL,
@@ -140,9 +144,11 @@ class EditToolbar(activity.EditToolbar):
                               style.COLOR_BLACK.get_gdk_color())
 
     def __find_previous_cb(self, button):
-        tabbed_view = self._activity.get_canvas()
-        tabbed_view.props.current_browser.typeahead.findAgain(True, False)
+        search_text = self.search_entry.get_text()
+        self._browser.search_text(search_text, case_sensitive=False,
+                                  forward=False, wrap=True)
 
     def __find_next_cb(self, button):
-        tabbed_view = self._activity.get_canvas()
-        tabbed_view.props.current_browser.typeahead.findAgain(False, False)
+        search_text = self.search_entry.get_text()
+        self._browser.search_text(search_text, case_sensitive=False,
+                                  forward=True, wrap=True)
diff --git a/sessionstore.py b/sessionstore.py
index 73edb24..589b44d 100644
--- a/sessionstore.py
+++ b/sessionstore.py
@@ -14,61 +14,76 @@
 # along with this program; if not, write to the Free Software
 # Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 
-# Based on
-# http://lxr.mozilla.org/seamonkey/source/browser/components/sessionstore
-
 import logging
 
-from xpcom import components
-from xpcom.components import interfaces
+from gi.repository import WebKit
 
 
 def get_session(browser):
-    session_history = browser.web_navigation.sessionHistory
-
-    if session_history.count == 0:
+    session_history = browser.get_back_forward_list()
+    if session_history.get_back_length() == 0:
         return ''
     return _get_history(session_history)
 
 
 def set_session(browser, data):
-    _set_history(browser.web_navigation.sessionHistory, data)
-
-    if data:
-        browser.web_navigation.gotoIndex(len(data) - 1)
-    else:
-        browser.load_uri('about:blank')
+    session_history = browser.get_back_forward_list()
+    _set_history(session_history, data)
 
 
 def _get_history(history):
-    logging.debug('%r', history.count)
+    items_list = _items_history_as_list(history)
+    logging.debug('history count: %r', len(items_list))
     entries_dest = []
-    for i in range(0, history.count):
-        entry_orig = history.getEntryAtIndex(i, False)
-        entry_dest = {'url':    entry_orig.URI.spec,
-                      'title':  entry_orig.title}
-
+    for item in items_list:
+        entry_dest = {'url': item.get_uri(),
+                      'title': item.get_title()}
         entries_dest.append(entry_dest)
 
     return entries_dest
 
 
 def _set_history(history, history_data):
-    history_internal = history.queryInterface(interfaces.nsISHistoryInternal)
-
-    if history_internal.count > 0:
-        history_internal.purgeHistory(history_internal.count)
-
-    for entry_dict in history_data:
-        logging.debug('entry_dict: %r', entry_dict)
-        entry_class = components.classes[ \
-                "@mozilla.org/browser/session-history-entry;1"]
-        entry = entry_class.createInstance(interfaces.nsISHEntry)
-
-        io_service_class = components.classes[ \
-                "@mozilla.org/network/io-service;1"]
-        io_service = io_service_class.getService(interfaces.nsIIOService)
-        entry.setURI(io_service.newURI(entry_dict['url'], None, None))
-        entry.setTitle(entry_dict['title'])
-
-        history_internal.addEntry(entry, True)
+    history.clear()
+    for entry in history_data:
+        uri, title = entry['url'], entry['title']
+        history_item = WebKit.WebHistoryItem.new_with_data(uri, title)
+        history.add_item(history_item)
+
+
+def get_history_index(browser):
+    """Return the index of the current item in the history."""
+    history = browser.get_back_forward_list()
+    history_list = _items_history_as_list(history)
+    current_item = history.get_current_item()
+    return history_list.index(current_item)
+
+
+def set_history_index(browser, index):
+    """Go to the item in the history specified by the index."""
+    history = browser.get_back_forward_list()
+    history_list = _items_history_as_list(history)
+    last_index = len(history_list) - 1
+    for i in range(last_index - index):
+        browser.go_back()
+    if index == last_index:
+        browser.go_back()
+        browser.go_forward()
+
+
+def _items_history_as_list(history):
+    """Return a list with the items of a WebKit.WebBackForwardList."""
+    back_items = []
+    for n in reversed(range(1, history.get_back_length() + 1)):
+        item = history.get_nth_item(n * -1)
+        back_items.append(item)
+
+    current_item = [history.get_current_item()]
+
+    forward_items = []
+    for n in range(1, history.get_forward_length() + 1):
+        item = history.get_nth_item(n)
+        forward_items.append(item)
+
+    all_items = back_items + current_item + forward_items
+    return all_items
diff --git a/webactivity.py b/webactivity.py
index 0e03fb2..9ccbe4c 100644
--- a/webactivity.py
+++ b/webactivity.py
@@ -401,7 +401,8 @@ class WebActivity(activity.Activity):
             logging.debug('########## reading %s', data)
             self._tabbed_view.set_session(self.model.data['history'])
             for number, tab in enumerate(self.model.data['currents']):
-                browser = self._tabbed_view.get_nth_page(number)
+                scrolled_window = self._tabbed_view.get_nth_page(number)
+                browser = scrolled_window.get_child()
                 browser.set_history_index(tab['history_index'])
 
             self._tabbed_view.set_current_page(self.model.data['current_tab'])
@@ -430,22 +431,18 @@ class WebActivity(activity.Activity):
                 else:
                     self.metadata['title'] = browser.props.title
 
-            # FIXME
-            # self.model.data['history'] = self._tabbed_view.get_session()
-            self.model.data['history'] = []
+            self.model.data['history'] = self._tabbed_view.get_session()
             current_tab = self._tabbed_view.get_current_page()
             self.model.data['current_tab'] = current_tab
 
             self.model.data['currents'] = []
             for n in range(0, self._tabbed_view.get_n_pages()):
-                # FIXME
-                continue
-                n_browser = self._tabbed_view.get_nth_page(n)
+                scrolled_window = self._tabbed_view.get_nth_page(n)
+                n_browser = scrolled_window.get_child()
                 if n_browser != None:
-                    nsiuri = n_browser.progress.location
-                    ui_uri = n_browser.get_url_from_nsiuri(nsiuri)
+                    uri = n_browser.get_uri()
                     history_index = n_browser.get_history_index()
-                    info = {'title': n_browser.props.title, 'url': ui_uri,
+                    info = {'title': n_browser.props.title, 'url': uri,
                             'history_index': history_index}
 
                     self.model.data['currents'].append(info)
diff --git a/webtoolbar.py b/webtoolbar.py
index a61d758..47ece72 100644
--- a/webtoolbar.py
+++ b/webtoolbar.py
@@ -296,13 +296,14 @@ class PrimaryToolbar(ToolbarBase):
         self._title_changed_hid = None
         self._uri_changed_hid = None
 
-        GObject.idle_add(lambda:
-                self._connect_to_browser(tabbed_view.props.current_browser))
+        if tabbed_view.get_n_pages():
+            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)
+        if tabbed_view.get_n_pages():
+            self._connect_to_browser(tabbed_view.props.current_browser)
 
     def _connect_to_browser(self, browser):
 
@@ -346,7 +347,7 @@ class PrimaryToolbar(ToolbarBase):
         status = widget.get_load_status()
         if status <= WebKit.LoadStatus.COMMITTED:
             self._set_title(None)
-        self._set_loading(status >= WebKit.LoadStatus.FINISHED)
+        self._set_loading(status < WebKit.LoadStatus.FINISHED)
         self._update_navigation_buttons()
 
     def __progress_changed_cb(self, widget, param):
@@ -409,10 +410,9 @@ class PrimaryToolbar(ToolbarBase):
     def _stop_and_reload_cb(self, entry, icon_pos, button):
         browser = self._tabbed_view.props.current_browser
         if self._loading:
-            browser.web_navigation.stop(interfaces.nsIWebNavigation.STOP_ALL)
+            browser.stop_loading()
         else:
-            flags = interfaces.nsIWebNavigation.LOAD_FLAGS_NONE
-            browser.web_navigation.reload(flags)
+            browser.reload()
 
     def _set_loading(self, loading):
         self._loading = loading
diff --git a/widgets.py b/widgets.py
index 608dbb6..3cfdf1e 100644
--- a/widgets.py
+++ b/widgets.py
@@ -69,11 +69,11 @@ class BrowserNotebook(Gtk.Notebook):
         empty_page.show()
 
     def on_add_tab(self, obj):
-        raise NotImplementedError, "implement this in the subclass"
+        raise NotImplementedError("implement this in the subclass")
 
     def __on_switch_page(self, notebook, page, page_num):
         """Don't switch to the extra tab at the end."""
-        if page_num == Gtk.Notebook.get_n_pages(self) - 1:
+        if page_num > 0 and page_num == Gtk.Notebook.get_n_pages(self) - 1:
             self.handler_block(self._switch_handler)
             self.set_current_page(-1)
             self.handler_unblock(self._switch_handler)