Full port to libevview 2.30. The only missing feature is set_screen_dpi. Not tested extensively, collaboration not tested at all.

3 files changed, 51 insertions, 129 deletions

diff --git a/readactivity.py b/readactivity.py
index 0b52df0..ac2aaf4 100644
--- a/readactivity.py
+++ b/readactivity.py
@@ -57,9 +57,6 @@ try:
 except:
     _EPUB_SUPPORT = False
 
-# Handle libevview 2.80's new API trac#1900
-_EVINCE_2_80 = hasattr(evince, 'document_factory_get_document')
-
 _HARDWARE_MANAGER_INTERFACE = 'org.laptop.HardwareManager'
 _HARDWARE_MANAGER_SERVICE = 'org.laptop.HardwareManager'
 _HARDWARE_MANAGER_OBJECT_PATH = '/org/laptop/HardwareManager'
@@ -174,8 +171,6 @@ class ReadActivity(activity.Activity):
         edit_toolbar_button.show()
 
         self._view_toolbar = ViewToolbar()
-        self._view_toolbar.connect('needs-update-size',
-                self.__view_toolbar_needs_update_size_cb)
         self._view_toolbar.connect('go-fullscreen',
                 self.__view_toolbar_go_fullscreen_cb)
         view_toolbar_button = ToolbarButton(
@@ -412,7 +407,7 @@ class ReadActivity(activity.Activity):
         elif page < 0:
             page = 0
 
-        self._document.get_page_cache().set_current_page(page)
+        self._model.props.page = page
         entry.props.text = str(page + 1)
     
     def __go_back_cb(self, button):
@@ -428,42 +423,41 @@ class ReadActivity(activity.Activity):
         self._view.next_page()
 
     def __prev_bookmark_activate_cb(self, menuitem):
-        page = self._document.get_page_cache().get_current_page()
+        page = self._model.props.page
         bookmarkmanager = self._sidebar.get_bookmarkmanager()
         
         prev_bookmark = bookmarkmanager.get_prev_bookmark_for_page(page)
         if prev_bookmark is not None:
-            self._document.get_page_cache().set_current_page(prev_bookmark.page_no)
+            self._model.props.page = prev_bookmark.page_no
 
     def __next_bookmark_activate_cb(self, menuitem):
-        page = self._document.get_page_cache().get_current_page()
+        page = self._model.props.page
         bookmarkmanager = self._sidebar.get_bookmarkmanager()
         
         next_bookmark = bookmarkmanager.get_next_bookmark_for_page(page)
         if next_bookmark is not None:
-            self._document.get_page_cache().set_current_page(next_bookmark.page_no)
+            self._model.props.page = next_bookmark.page_no
 
     def __bookmarker_toggled_cb(self, button):
-        page = self._document.get_page_cache().get_current_page()
         if self._bookmarker.props.active:
-            self._sidebar.add_bookmark(page)
+            self._sidebar.add_bookmark(self._model.props.page)
         else:
-            self._sidebar.del_bookmark(page)    
+            self._sidebar.del_bookmark(self._model.props.page)    
 
-    def __page_changed_cb(self, page, proxy = None):
+    def __page_changed_cb(self, previous, next, user_data):
         self._update_nav_buttons()
         if hasattr(self._document, 'has_document_links'):
             if self._document.has_document_links():
                 self._toc_select_active_page()
                 
-        self._sidebar.update_for_page(self._document.get_page_cache().get_current_page())
+        self._sidebar.update_for_page(self._model.props.page)
 
         self._bookmarker.handler_block(self._bookmarker_toggle_handler_id)
         self._bookmarker.props.active = self._sidebar.is_showing_local_bookmark()
         self._bookmarker.handler_unblock(self._bookmarker_toggle_handler_id)
         
     def _update_nav_buttons(self):
-        current_page = self._document.get_page_cache().get_current_page()
+        current_page = self._model.props.page
         self._back_button.props.sensitive = current_page > 0
         self._forward_button.props.sensitive = \
             current_page < self._document.get_n_pages() - 1
@@ -514,7 +508,7 @@ class ReadActivity(activity.Activity):
         iter = self._navigator.get_active_iter()
         
         current_link = self._toc_model.get(iter, 1)[0]
-        current_page = self._document.get_page_cache().get_current_page()
+        current_page = self._model.props.page
 
 
         if not hasattr(current_link, 'get_page'):
@@ -596,10 +590,6 @@ class ReadActivity(activity.Activity):
         self._tempfile = tempfile
         self._load_document('file://' + self._tempfile)
 
-        # FIXME: This should obviously be fixed properly
-        gobject.timeout_add_seconds(1, self.__view_toolbar_needs_update_size_cb,
-            None)
-
     def write_file(self, file_path):
         """Write into datastore for Keep.
         
@@ -616,7 +606,7 @@ class ReadActivity(activity.Activity):
 
         try:
             self.metadata['Read_current_page'] = \
-                        str(self._document.get_page_cache().get_current_page())
+                        str(self._model.props.page)
 
             self.metadata['Read_zoom'] = str(self._view.props.zoom)
 
@@ -769,9 +759,9 @@ class ReadActivity(activity.Activity):
 
     def _setup_evince_viewer(self):
         self._view = evince.View()
-        #self._view.set_screen_dpi(_get_screen_dpi())
-        self._view.connect('notify::has-selection',
-                            self._view_notify_has_selection_cb)
+        #self._view.set_screen_dpi(_get_screen_dpi()) #disabled trac#1900
+        #self._view.connect('notify::has-selection',
+        #                    self._view_notify_has_selection_cb)
 
         self._scrolled = gtk.ScrolledWindow()
         self._scrolled.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
@@ -800,27 +790,19 @@ class ReadActivity(activity.Activity):
         else:
             self._setup_evince_viewer()
             try:
-                if _EVINCE_2_80:
-                    self._document = evince.document_factory_get_document(
-                                        filepath)
-                else:
-                    self._document = evince.factory_get_document(filepath)
+                self._document = evince.document_factory_get_document(
+                                    filepath)
             except GError, e:
                 _logger.error('Can not load document: %s', e)
                 return
 
         self._want_document = False
 
-        if _EVINCE_2_80:
-            self._model = evince.DocumentModel()
-            self._model.set_document(self._document)
-            self._view.set_model(self._model)
+        self._model = evince.DocumentModel()
+        self._model.set_document(self._document)
+        self._view.set_model(self._model)
 
-            self._view_toolbar.set_model(self._model)
-        else:
-            self._view.set_document(self._document)
-
-        self._view_toolbar.set_view(self._view)
+        self._view_toolbar.set_view(self._view, self._model)
         self._edit_toolbar.set_view(self._view)
 
         self._edit_toolbar.set_document(self._document)
@@ -832,8 +814,7 @@ class ReadActivity(activity.Activity):
         self._update_nav_buttons()
         self._update_toc()
     
-        page_cache = self._document.get_page_cache()
-        page_cache.connect('page-changed', self.__page_changed_cb)
+        self._model.connect('page-changed', self.__page_changed_cb)
 
         if not self.metadata['title_set_by_user'] == '1':
             info = self._document.get_info()
@@ -844,23 +825,20 @@ class ReadActivity(activity.Activity):
             sizing_mode = self.metadata.get('Read_sizing_mode', 'fit-width')
             _logger.debug('Found sizing mode: %s', sizing_mode)
             if sizing_mode == "best-fit":
-                self._view.props.sizing_mode = evince.SIZING_BEST_FIT
-                if hasattr(self._view, 'update_view_size'):
-                    self._view.update_view_size(self._scrolled)
+                self._model.props.sizing_mode = evince.SIZING_BEST_FIT
             elif sizing_mode == "free":
-                self._view.props.sizing_mode = evince.SIZING_FREE
-                self._view.props.zoom = float(self.metadata.get('Read_zoom', '1.0'))
-                _logger.debug('Set zoom to %f', self._view.props.zoom)
+                self._model.props.sizing_mode = evince.SIZING_FREE
+                self._scale.props.zoom = float(self.metadata.get('Read_zoom',
+                                                                 '1.0'))
+                _logger.debug('Set zoom to %f', self._model.props.scale)
             elif sizing_mode == "fit-width":
-                self._view.props.sizing_mode = evince.SIZING_FIT_WIDTH
-                if hasattr(self._view, 'update_view_size'):
-                    self._view.update_view_size(self._scrolled)
+                self._model.props.sizing_mode = evince.SIZING_FIT_WIDTH
             else:
                 # this may happen when we get a document from a buddy with a later
                 # version of Read, for example.
                 _logger.warning("Unknown sizing_mode state '%s'", sizing_mode)
                 if self.metadata.get('Read_zoom', None) is not None:
-                    self._view.props.zoom = float(self.metadata['Read_zoom'])
+                    self._model.props.scale = float(self.metadata['Read_zoom'])
 
         self._view_toolbar._update_zoom_buttons()
 
@@ -869,7 +847,7 @@ class ReadActivity(activity.Activity):
 
         current_page = int(self.metadata.get('Read_current_page', '0'))
         _logger.debug('Setting page to: %d', current_page)
-        self._document.get_page_cache().set_current_page(current_page)
+        self._model.props.page = current_page
 
         # We've got the document, so if we're a shared activity, offer it
         try:
@@ -976,11 +954,5 @@ class ReadActivity(activity.Activity):
         else:
             self._topbar.hide()
 
-    def __view_toolbar_needs_update_size_cb(self, view_toolbar):
-        if hasattr(self._view, 'update_view_size'):
-            self._view.update_view_size(self._scrolled)
-        else:
-            return False # No need to run this again and again
-
     def __view_toolbar_go_fullscreen_cb(self, view_toolbar):
         self.fullscreen()
diff --git a/readtoolbar.py b/readtoolbar.py
index 2785ed8..a51eff6 100644
--- a/readtoolbar.py
+++ b/readtoolbar.py
@@ -31,9 +31,6 @@ from sugar.graphics.menuitem import MenuItem
 from sugar.graphics import iconentry
 from sugar.activity import activity
 
-# Handle libevview 2.80's new API trac#1900
-_EVINCE_2_80 = hasattr(evince, 'document_factory_get_document')
-
 
 class EditToolbar(activity.EditToolbar):
     __gtype_name__ = 'EditToolbar'
@@ -248,67 +245,39 @@ class ViewToolbar(gtk.Toolbar):
         self._fullscreen.show()
 
         self._view_notify_zoom_handler = None
-        self._view_notify_scale_handler = None
 
-    def set_view(self, view):
+    def set_view(self, view, model):
+        self._evince_model = model
         self._evince_view = view
 
-        if _EVINCE_2_80:
-            self._zoom_spin.props.value = self._evince_model.props.scale * 100
-            self._view_notify_scale_handler = self._evince_model.connect(
-                'notify::scale', self._view_notify_scale_cb)
-        else:
-            self._zoom_spin.props.value = self._evince_view.props.zoom * 100
-            self._view_notify_zoom_handler = self._evince_view.connect(
-                'notify::zoom', self._view_notify_zoom_cb)
+        self._zoom_spin.props.value = self._evince_model.props.scale * 100
+        self._view_notify_zoom_handler = self._evince_model.connect(
+            'notify::scale', self._view_notify_zoom_cb)
 
         self._update_zoom_buttons() 
 
-    def set_model(self, model):
-        self._evince_model = model
-
     def _zoom_spin_notify_value_cb(self, zoom_spin, pspec):
         if not self._view_notify_zoom_handler:
             return
 
-        if _EVINCE_2_80:
-            self._evince_model.disconnect(self._view_notify_scale_handler)
-        else:
-            self._evince_view.disconnect(self._view_notify_zoom_handler)
-
+        self._evince_model.disconnect(self._view_notify_zoom_handler)
         try:
-            if hasattr(self._evince_view.props, 'sizing_mode'):
-                self._evince_view.props.sizing_mode = evince.SIZING_FREE
-            if _EVINCE_2_80:
-                self._evince_model.props.scale = zoom_spin.props.value / 100.0
-            else:
-                self._evince_view.props.zoom = zoom_spin.props.value / 100.0
+            self._evince_model.props.scale = zoom_spin.props.value / 100.0
         finally:
-            self._view_notify_zoom_handler = self._evince_view.connect(
-                    'notify::zoom', self._view_notify_zoom_cb)
+            self._view_notify_zoom_handler = self._evince_model.connect(
+                'notify::scale', self._view_notify_zoom_cb)
 
-    def _view_notify_zoom_cb(self, evince_view, pspec):
-        self._zoom_spin.disconnect(self._zoom_spin_notify_value_handler)
-        try:
-            self._zoom_spin.props.value = round(evince_view.props.zoom * 100.0)
-        finally:
-            self._zoom_spin_notify_value_handler = self._zoom_spin.connect(
-                    'notify::value', self._zoom_spin_notify_value_cb)
-
-    def _view_notify_scale_cb(self, evince_model, pspec):
+    def _view_notify_zoom_cb(self, evince_model, pspec):
         self._zoom_spin.disconnect(self._zoom_spin_notify_value_handler)
         try:
             self._zoom_spin.props.value = round(evince_model.props.scale *
                                                 100.0)
         finally:
             self._zoom_spin_notify_value_handler = self._zoom_spin.connect(
-                    'notify::value', self._zoom_spin_notify_value_cb)            
+                    'notify::value', self._zoom_spin_notify_value_cb)
 
     def zoom_in(self):
-        if hasattr(self._evince_view.props, 'sizing_mode'):
-            self._evince_view.props.sizing_mode = evince.SIZING_FREE
-        if hasattr(self._evince_model.props, 'sizing-mode'):
-            self._evince_model.set_property('sizing-mode', evince.SIZING_FREE)
+        self._evince_model.props.sizing_mode = evince.SIZING_FREE
         self._evince_view.zoom_in()
         self._update_zoom_buttons()
 
@@ -316,10 +285,7 @@ class ViewToolbar(gtk.Toolbar):
         self.zoom_in()
 
     def zoom_out(self):
-        if hasattr(self._evince_view.props, 'sizing_mode'):
-            self._evince_view.props.sizing_mode = evince.SIZING_FREE
-        if hasattr(self._evince_model.props, 'sizing-mode'):
-            self._evince_model.set_property('sizing-mode', evince.SIZING_FREE)
+        self._evince_model.props.sizing_mode = evince.SIZING_FREE
         self._evince_view.zoom_out()
         self._update_zoom_buttons()
         
@@ -327,11 +293,7 @@ class ViewToolbar(gtk.Toolbar):
         self.zoom_out()
 
     def zoom_to_width(self):
-        if hasattr(self._evince_view.props, 'sizing_mode'):
-            self._evince_view.props.sizing_mode = evince.SIZING_FIT_WIDTH
-        if hasattr(self._evince_model.props, 'sizing-mode'):
-            self._evince_model.set_property('sizing-mode',
-                                            evince.SIZING_FIT_WIDTH)
+        self._evince_model.props.sizing_mode = evince.SIZING_FIT_WIDTH
         self.emit('needs-update-size')
         self._update_zoom_buttons()
 
@@ -343,23 +305,13 @@ class ViewToolbar(gtk.Toolbar):
         self._zoom_out.props.sensitive = self._evince_view.can_zoom_out()
 
     def _zoom_to_fit_menu_item_activate_cb(self, menu_item):
-        if hasattr(self._evince_view.props, 'sizing_mode'): #XXX
-            self._evince_view.props.sizing_mode = evince.SIZING_BEST_FIT
-        if hasattr(self._evince_model.props, 'sizing-mode'):
-            self._evince_model.set_property('sizing-mode',
-                                            evince.SIZING_BEST_FIT)
+        self._evince_model.props.sizing_mode = evince.SIZING_BEST_FIT
         self.emit('needs-update-size')
         self._update_zoom_buttons()
 
     def _actual_size_menu_item_activate_cb(self, menu_item):
-        if hasattr(self._evince_view.props, 'sizing_mode'):
-            self._evince_view.props.sizing_mode = evince.SIZING_FREE
-        if hasattr(self._evince_model.props, 'sizing-mode'):
-            self._evince_model.set_property('sizing-mode', evince.SIZING_FREE)
-        if _EVINCE_2_80:
-            self._evince_model.props.scale = 1.0
-        else:
-            self._evince_view.props.zoom = 1.0
+        self._evince_model.props.sizing_mode = evince.SIZING_FREE
+        self._evince_model.props.scale = 1.0
         self._update_zoom_buttons()
 
     def _fullscreen_cb(self, button):
diff --git a/readtopbar.py b/readtopbar.py
index 48aeabd..1815a66 100644
--- a/readtopbar.py
+++ b/readtopbar.py
@@ -27,9 +27,6 @@ from sugar.graphics.icon import Icon, get_icon_state
 
 from gettext import gettext as _
 
-# Handle libevview 2.80's new API trac#1900
-_EVINCE_2_80 = hasattr(evince, 'document_factory_get_document')
-
 _LEVEL_PROP = 'battery.charge_level.percentage'
 _CHARGING_PROP = 'battery.rechargeable.is_charging'
 _DISCHARGING_PROP = 'battery.rechargeable.is_discharging'
@@ -199,11 +196,12 @@ class TopBar(_TopBar):
     def set_document(self, document):
         self._document = document
 
-        page_cache = evince.PageCache(self._document)
-        page_cache.connect('page-changed', self._page_changed_cb)
+        model = evince.DocumentModel()
+        model.props.document = self._document
+        model.connect('page-changed', self._page_changed_cb)
 
     def _page_changed_cb(self, page, proxy = None):
-        current_page = evince.DocumentModel(self._document).props.page
+        current_page = self._document.props.page
         n_pages = self._document.get_n_pages()
 
         self.set_completion_level(current_page * 100/n_pages)