Revert "Initial port to Gtk3"

This reverts commit 996d542fd7d2d464edd572b165e80f9cb2c20ec7.

14 files changed, 328 insertions, 347 deletions

diff --git a/epubadapter.py b/epubadapter.py
index 4583b94..8def465 100644
--- a/epubadapter.py
+++ b/epubadapter.py
@@ -1,4 +1,4 @@
-from gi.repository import GObject
+import gobject
 import logging
 
 import epubview
@@ -19,7 +19,7 @@ class EpubViewer(epubview.EpubView):
         self.connect('selection-changed',
                             activity._view_selection_changed_cb)
 
-        activity._hbox.pack_start(self, True, True, 0)
+        activity._hbox.pack_start(self, expand=True, fill=True)
         self.show_all()
         # text to speech initialization
         self.current_word = 0
@@ -122,7 +122,7 @@ class EpubViewer(epubview.EpubView):
         if self._ready:
             self._load_page(n)
         else:
-            GObject.timeout_add(200, self._try_load_page, n)
+            gobject.timeout_add(200, self._try_load_page, n)
 
     def get_current_page(self):
         return int(self._loaded_page - 1)
diff --git a/epubview/__init__.py b/epubview/__init__.py
index adff032..5051bdf 100644
--- a/epubview/__init__.py
+++ b/epubview/__init__.py
@@ -15,9 +15,9 @@
 # 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
+import gobject
 
-GObject.threads_init()
+gobject.threads_init()
 
 from epub import _Epub as Epub
 from epubview import _View as EpubView
diff --git a/epubview/epubview.py b/epubview/epubview.py
index 56334f6..c4b3df0 100644
--- a/epubview/epubview.py
+++ b/epubview/epubview.py
@@ -15,9 +15,8 @@
 # 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 Gtk
-from gi.repository import GObject
-from gi.repository import Gdk
+import gtk
+import gobject
 import widgets
 
 import os.path
@@ -35,23 +34,23 @@ LOADING_HTML = '''
 '''
 
 
-class _View(Gtk.HBox):
+class _View(gtk.HBox):
 
     __gproperties__ = {
-        'scale': (GObject.TYPE_FLOAT, 'the zoom level',
+        'scale': (gobject.TYPE_FLOAT, 'the zoom level',
                    'the zoom level of the widget',
-                   0.5, 4.0, 1.0, GObject.PARAM_READWRITE),
+                   0.5, 4.0, 1.0, gobject.PARAM_READWRITE),
     }
     __gsignals__ = {
-        'page-changed': (GObject.SignalFlags.RUN_FIRST, GObject.TYPE_NONE,
+        'page-changed': (gobject.SIGNAL_RUN_FIRST, gobject.TYPE_NONE,
                 ([int, int])),
-        'selection-changed': (GObject.SignalFlags.RUN_FIRST, GObject.TYPE_NONE,
+        'selection-changed': (gobject.SIGNAL_RUN_FIRST, gobject.TYPE_NONE,
                               ([])),
     }
 
     def __init__(self):
-        GObject.threads_init()
-        Gtk.HBox.__init__(self)
+        gobject.threads_init()
+        gtk.HBox.__init__(self)
 
         self.connect("destroy", self._destroy_cb)
 
@@ -71,7 +70,7 @@ class _View(Gtk.HBox):
         self.__in_search = False
         self.__search_fwd = True
 
-        self._sw = Gtk.ScrolledWindow()
+        self._sw = gtk.ScrolledWindow()
         self._view = widgets._WebView()
         self._view.load_string(LOADING_HTML, 'text/html', 'utf-8', '/')
         settings = self._view.get_settings()
@@ -89,29 +88,27 @@ class _View(Gtk.HBox):
                 self._view_populate_popup_cb)
 
         self._sw.add(self._view)
-        self._sw.set_policy(Gtk.PolicyType.AUTOMATIC, Gtk.PolicyType.NEVER)
+        self._sw.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_NEVER)
         self._v_vscrollbar = self._sw.get_vscrollbar()
         self._v_scrollbar_value_changed_cb_id = \
                 self._v_vscrollbar.connect('value-changed', \
                 self._v_scrollbar_value_changed_cb)
-        self._scrollbar = Gtk.VScrollbar()
-        # TODO
-        # self._scrollbar.set_update_policy(Gtk.UPDATE_DISCONTINUOUS)
+        self._scrollbar = gtk.VScrollbar()
+        self._scrollbar.set_update_policy(gtk.UPDATE_DISCONTINUOUS)
         self._scrollbar_change_value_cb_id = \
                 self._scrollbar.connect('change-value', \
                 self._scrollbar_change_value_cb)
-        self.pack_start(self._sw, True, True, 0)
-        self.pack_start(self._scrollbar, False, False, 0)
+        self.pack_start(self._sw, expand=True, fill=True)
+        self.pack_start(self._scrollbar, expand=False, fill=False)
 
-        self._view.set_can_default(True)
-        self._view.set_can_focus(True)
+        self._view.set_flags(gtk.CAN_DEFAULT | gtk.CAN_FOCUS)
 
     def set_document(self, epubdocumentinstance):
         '''
         Sets document (should be a Epub instance)
         '''
         self._epub = epubdocumentinstance
-        GObject.idle_add(self._paginate)
+        gobject.idle_add(self._paginate)
 
     def do_get_property(self, property):
         if property.name == 'has-selection':
@@ -251,36 +248,36 @@ class _View(Gtk.HBox):
         Scrolls through the pages.
         Scrolling is horizontal if horizontal is set to True
         Valid scrolltypes are:
-        Gtk.ScrollType.PAGE_BACKWARD, Gtk.ScrollType.PAGE_FORWARD,
-        Gtk.ScrollType.STEP_BACKWARD, Gtk.ScrollType.STEP_FORWARD
-        Gtk.ScrollType.STEP_START and Gtk.ScrollType.STEP_STOP
+        gtk.SCROLL_PAGE_BACKWARD, gtk.SCROLL_PAGE_FORWARD,
+        gtk.SCROLL_STEP_BACKWARD, gtk.SCROLL_STEP_FORWARD
+        gtk.SCROLL_STEP_START and gtk.SCROLL_STEP_STOP
         '''
-        if scrolltype == Gtk.ScrollType.PAGE_BACKWARD:
+        if scrolltype == gtk.SCROLL_PAGE_BACKWARD:
             self.__going_back = True
             self.__going_fwd = False
             if not self._do_page_transition():
-                self._view.move_cursor(Gtk.MovementStep.PAGES, -1)
-        elif scrolltype == Gtk.ScrollType.PAGE_FORWARD:
+                self._view.move_cursor(gtk.MOVEMENT_PAGES, -1)
+        elif scrolltype == gtk.SCROLL_PAGE_FORWARD:
             self.__going_back = False
             self.__going_fwd = True
             if not self._do_page_transition():
-                self._view.move_cursor(Gtk.MovementStep.PAGES, 1)
-        elif scrolltype == Gtk.ScrollType.STEP_BACKWARD:
+                self._view.move_cursor(gtk.MOVEMENT_PAGES, 1)
+        elif scrolltype == gtk.SCROLL_STEP_BACKWARD:
             self.__going_fwd = False
             self.__going_back = True
             if not self._do_page_transition():
-                self._view.move_cursor(Gtk.MovementStep.DISPLAY_LINES, -1)
-        elif scrolltype == Gtk.ScrollType.STEP_FORWARD:
+                self._view.move_cursor(gtk.MOVEMENT_DISPLAY_LINES, -1)
+        elif scrolltype == gtk.SCROLL_STEP_FORWARD:
             self.__going_fwd = True
             self.__going_back = False
             if not self._do_page_transition():
-                self._view.move_cursor(Gtk.MovementStep.DISPLAY_LINES, 1)
-        elif scrolltype == Gtk.ScrollType.START:
+                self._view.move_cursor(gtk.MOVEMENT_DISPLAY_LINES, 1)
+        elif scrolltype == gtk.SCROLL_START:
             self.__going_back = True
             self.__going_fwd = False
             if not self._do_page_transition():
                 self.set_current_page(1)
-        elif scrolltype == Gtk.ScrollType.END:
+        elif scrolltype == gtk.SCROLL_END:
             self.__going_back = False
             self.__going_fwd = True
             if not self._do_page_transition():
@@ -363,7 +360,7 @@ class _View(Gtk.HBox):
                                  | view.can_cut_clipboard())
 
     def _view_keypress_event_cb(self, view, event):
-        name = Gdk.keyval_name(event.keyval)
+        name = gtk.gdk.keyval_name(event.keyval)
         if name == 'Page_Down' or name == 'Down':
             self.__going_back = False
             self.__going_fwd = True
@@ -374,10 +371,10 @@ class _View(Gtk.HBox):
         self._do_page_transition()
 
     def _view_scroll_event_cb(self, view, event):
-        if event.direction == Gdk.ScrollDirection.DOWN:
+        if event.direction == gtk.gdk.SCROLL_DOWN:
             self.__going_back = False
             self.__going_fwd = True
-        elif event.direction == Gdk.ScrollDirection.UP:
+        elif event.direction == gtk.gdk.SCROLL_UP:
             self.__going_back = True
             self.__going_fwd = False
 
@@ -401,7 +398,7 @@ class _View(Gtk.HBox):
     def _view_load_finished_cb(self, v, frame):
         # Normally the line below would not be required - ugly workaround for
         # possible Webkit bug. See : https://bugs.launchpad.net/bugs/483231
-        self._sw.set_policy(Gtk.PolicyType.AUTOMATIC, Gtk.PolicyType.NEVER)
+        self._sw.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_NEVER)
 
         filename = self._view.props.uri.replace('file://', '')
         if os.path.exists(filename.replace('xhtml', 'xml')):
@@ -629,19 +626,19 @@ class _View(Gtk.HBox):
         self._load_page(pageno)
 
     def _scrollbar_change_value_cb(self, range, scrolltype, value):
-        if scrolltype == Gtk.ScrollType.STEP_FORWARD:
+        if scrolltype == gtk.SCROLL_STEP_FORWARD:
             self.__going_fwd = True
             self.__going_back = False
             if not self._do_page_transition():
-                self._view.move_cursor(Gtk.MovementStep.DISPLAY_LINES, 1)
-        elif scrolltype == Gtk.ScrollType.STEP_BACKWARD:
+                self._view.move_cursor(gtk.MOVEMENT_DISPLAY_LINES, 1)
+        elif scrolltype == gtk.SCROLL_STEP_BACKWARD:
             self.__going_fwd = False
             self.__going_back = True
             if not self._do_page_transition():
-                self._view.move_cursor(Gtk.MovementStep.DISPLAY_LINES, -1)
-        elif scrolltype == Gtk.ScrollType.JUMP or \
-            scrolltype == Gtk.ScrollType.PAGE_FORWARD or \
-                scrolltype == Gtk.ScrollType.PAGE_BACKWARD:
+                self._view.move_cursor(gtk.MOVEMENT_DISPLAY_LINES, -1)
+        elif scrolltype == gtk.SCROLL_JUMP or \
+            scrolltype == gtk.SCROLL_PAGE_FORWARD or \
+                scrolltype == gtk.SCROLL_PAGE_BACKWARD:
             if value > self._scrollbar.props.adjustment.props.upper:
                 self._load_page(self._pagecount)
             else:
diff --git a/epubview/jobs.py b/epubview/jobs.py
index ba28396..a0b6771 100644
--- a/epubview/jobs.py
+++ b/epubview/jobs.py
@@ -16,9 +16,8 @@
 # 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
+import gobject
+import gtk
 import widgets
 import cairo
 
@@ -61,10 +60,10 @@ class SearchThread(threading.Thread):
                 self.obj._matchfilelist.append(entry)
             f.close()
 
-        Gdk.threads_enter()
+        gtk.gdk.threads_enter()
         self.obj._finished = True
         self.obj.emit('updated')
-        Gdk.threads_leave()
+        gtk.gdk.threads_leave()
 
         return False
 
@@ -86,14 +85,14 @@ class SearchThread(threading.Thread):
         self.stopthread.set()
 
 
-class _JobPaginator(GObject.GObject):
+class _JobPaginator(gobject.GObject):
 
     __gsignals__ = {
-        'paginated': (GObject.SignalFlags.RUN_FIRST, GObject.TYPE_NONE, ([])),
+        'paginated': (gobject.SIGNAL_RUN_FIRST, gobject.TYPE_NONE, ([])),
     }
 
     def __init__(self, filelist):
-        GObject.GObject.__init__(self)
+        gobject.GObject.__init__(self)
 
         self._filelist = filelist
         self._filedict = {}
@@ -103,9 +102,7 @@ class _JobPaginator(GObject.GObject):
         self._count = 0
         self._pagecount = 0
 
-        #TODO
-        """
-        self._screen = Gdk.Screen.get_default()
+        self._screen = gtk.gdk.screen_get_default()
         self._old_fontoptions = self._screen.get_font_options()
         options = cairo.FontOptions()
         options.set_hint_style(cairo.HINT_STYLE_MEDIUM)
@@ -113,9 +110,8 @@ class _JobPaginator(GObject.GObject):
         options.set_subpixel_order(cairo.SUBPIXEL_ORDER_DEFAULT)
         options.set_hint_metrics(cairo.HINT_METRICS_DEFAULT)
         self._screen.set_font_options(options)
-        """
 
-        self._temp_win = Gtk.Window()
+        self._temp_win = gtk.Window()
         self._temp_view = widgets._WebView()
 
         settings = self._temp_view.get_settings()
@@ -131,8 +127,8 @@ class _JobPaginator(GObject.GObject):
         settings.props.default_monospace_font_size = 10
         settings.props.default_encoding = 'utf-8'
 
-        sw = Gtk.ScrolledWindow()
-        sw.set_policy(Gtk.PolicyType.NEVER, Gtk.PolicyType.NEVER)
+        sw = gtk.ScrolledWindow()
+        sw.set_policy(gtk.POLICY_NEVER, gtk.POLICY_NEVER)
         self._dpi = 96
         sw.set_size_request(_mm_to_pixel(PAGE_WIDTH, self._dpi),
                 _mm_to_pixel(PAGE_HEIGHT, self._dpi))
@@ -168,8 +164,7 @@ class _JobPaginator(GObject.GObject):
 
         if self._count + 1 >= len(self._filelist):
             self._temp_win.destroy()
-            # TODO
-            #self._screen.set_font_options(self._old_fontoptions)
+            self._screen.set_font_options(self._old_fontoptions)
             self.emit('paginated')
         else:
             self._count += 1
@@ -229,15 +224,15 @@ class _JobPaginator(GObject.GObject):
         return self._bookheight
 
 
-class _JobFind(GObject.GObject):
+class _JobFind(gobject.GObject):
     __gsignals__ = {
-        'updated': (GObject.SignalFlags.RUN_FIRST, GObject.TYPE_NONE, ([])),
+        'updated': (gobject.SIGNAL_RUN_FIRST, gobject.TYPE_NONE, ([])),
     }
 
     def __init__(self, document, start_page, n_pages, text,
             case_sensitive=False):
-        GObject.GObject.__init__(self)
-        Gdk.threads_init()
+        gobject.GObject.__init__(self)
+        gtk.gdk.threads_init()
 
         self._finished = False
         self._document = document
diff --git a/epubview/navmap.py b/epubview/navmap.py
index fa3713b..612f2d1 100644
--- a/epubview/navmap.py
+++ b/epubview/navmap.py
@@ -1,6 +1,5 @@
 from lxml import etree
-from gi.repository import Gtk
-import logging
+import gtk
 
 
 class NavPoint(object):
@@ -26,7 +25,7 @@ class NavMap(object):
         self._opffile = opffile
         self._tree = etree.parse(ncxfile)
         self._root = self._tree.getroot()
-        self._gtktreestore = Gtk.TreeStore(str, str)
+        self._gtktreestore = gtk.TreeStore(str, str)
         self._flattoc = []
 
         self._populate_flattoc()
@@ -63,11 +62,8 @@ class NavMap(object):
 
     def _getcontent(self, navpoint):
         text = navpoint.find(
-                './{http://www.daisy.org/z3986/2005/ncx/}content')
-        if text  is not None:
-            return self._basepath + text.get('src')
-        else:
-            return ""
+                './{http://www.daisy.org/z3986/2005/ncx/}content/')
+        return self._basepath + text.get('src')
 
     def _process_navpoint(self, navpoint, parent=None):
         title = self._gettitle(navpoint)
diff --git a/epubview/widgets.py b/epubview/widgets.py
index 39c52ce..a603c34 100644
--- a/epubview/widgets.py
+++ b/epubview/widgets.py
@@ -1,9 +1,10 @@
-from gi.repository import WebKit
+import webkit
+import gtk
 
 
-class _WebView(WebKit.WebView):
+class _WebView(webkit.WebView):
     def __init__(self):
-        WebKit.WebView.__init__(self)
+        webkit.WebView.__init__(self)
 
     def get_page_height(self):
         '''
diff --git a/evinceadapter.py b/evinceadapter.py
index 3e2d647..632ff96 100644
--- a/evinceadapter.py
+++ b/evinceadapter.py
@@ -1,9 +1,8 @@
-from gi.repository import GObject
-from gi.repository import Gtk
+import gobject
 import logging
+import gtk
 
-from gi.repository import EvinceDocument
-from gi.repository import EvinceView
+import evince
 
 _logger = logging.getLogger('read-activity')
 
@@ -12,50 +11,42 @@ class EvinceViewer():
 
     def __init__(self):
         self._view_notify_zoom_handler = None
-        EvinceDocument.init()
-        self._view = EvinceView.View()
+        self._view = evince.View()
 
     def setup(self, activity):
         self._activity = activity
         self._view.connect('selection-changed',
                             activity._view_selection_changed_cb)
 
-        activity._scrolled = Gtk.ScrolledWindow()
-        activity._scrolled.set_policy(Gtk.PolicyType.AUTOMATIC,
-                Gtk.PolicyType.AUTOMATIC)
-        activity._scrolled.props.shadow_type = Gtk.ShadowType.NONE
+        activity._scrolled = gtk.ScrolledWindow()
+        activity._scrolled.set_policy(gtk.POLICY_AUTOMATIC,
+                gtk.POLICY_AUTOMATIC)
+        activity._scrolled.props.shadow_type = gtk.SHADOW_NONE
 
         activity._scrolled.add(self._view)
         self._view.show()
 
-        activity._hbox.pack_start(activity._scrolled, True, True, 0)
+        activity._hbox.pack_start(activity._scrolled, expand=True, fill=True)
         activity._scrolled.show()
 
         self.dpi = activity.dpi
 
     def load_document(self, file_path):
         try:
-            self._document = \
-                    EvinceDocument.Document.factory_get_document(file_path)
-        except GObject.GError, e:
+            self._document = evince.document_factory_get_document(file_path)
+        except gobject.GError, e:
             _logger.error('Can not load document: %s', e)
             return
         else:
-            self._model = EvinceView.DocumentModel()
+            self._model = evince.DocumentModel()
             self._model.set_document(self._document)
             self._view.set_model(self._model)
 
             # set dpi
-            # TODO why we need set this?
-            """
             min_scale = self._model.get_min_scale()
             max_scale = self._model.get_max_scale()
-            logging.error("min scale %s max_scale %s", min_scale, max_scale)
-            logging.error("setting min scale %s", min_scale * self.dpi / 72.0)
-            logging.error("setting max scale %s", max_scale * self.dpi / 72.0)
             self._model.set_min_scale(min_scale * self.dpi / 72.0)
             self._model.set_max_scale(max_scale * self.dpi / 72.0)
-            """
 
     def get_current_page(self):
         return self._model.props.page
@@ -85,15 +76,16 @@ class EvinceViewer():
         sizing_mode = self.metadata.get('Read_sizing_mode', 'fit-width')
         _logger.debug('Found sizing mode: %s', sizing_mode)
         if sizing_mode == "best-fit":
-            self._model.set_sizing_mode(EvinceView.SizingMode.BEST_FIT)
+            self._model.props.sizing_mode = evince.SIZING_BEST_FIT
             if hasattr(self._view, 'update_view_size'):
                 self._view.update_view_size(self._scrolled)
         elif sizing_mode == "free":
-            self._model.set_sizing_mode(EvinceView.SizingMode.FREE)
-            self._model.set_scale(float(self.metadata.get('Read_zoom', '1.0')))
+            self._model.props.sizing_mode = evince.SIZING_FREE
+            self._model.props.scale = \
+                    float(self.metadata.get('Read_zoom', '1.0'))
             _logger.debug('Set zoom to %f', self._model.props.scale)
         elif sizing_mode == "fit-width":
-            self._model.set_sizing_mode(EvinceView.SizingMode.FIT_WIDTH)
+            self._model.props.sizing_mode = evince.SIZING_FIT_WIDTH
             if hasattr(self._view, 'update_view_size'):
                 self._view.update_view_size(self._scrolled)
         else:
@@ -101,21 +93,21 @@ class EvinceViewer():
             # 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._model.set_scale(float(self.metadata['Read_zoom']))
+                self._model.props.scale = float(self.metadata['Read_zoom'])
 
     def update_metadata(self, activity):
         self.metadata = activity.metadata
         self.metadata['Read_zoom'] = str(self._model.props.scale)
 
-        if self._model.get_sizing_mode() == EvinceView.SizingMode.BEST_FIT:
+        if self._model.props.sizing_mode == evince.SIZING_BEST_FIT:
             self.metadata['Read_sizing_mode'] = "best-fit"
-        elif self._model.get_sizing_mode() == EvinceView.SizingMode.FREE:
+        elif self._model.props.sizing_mode == evince.SIZING_FREE:
             self.metadata['Read_sizing_mode'] = "free"
-        elif self._model.get_sizing_mode() == EvinceView.SizingMode.FIT_WIDTH:
+        elif self._model.props.sizing_mode == evince.SIZING_FIT_WIDTH:
             self.metadata['Read_sizing_mode'] = "fit-width"
         else:
             _logger.error("Don't know how to save sizing_mode state '%s'" %
-                          self._model.get_sizing_mode())
+                          self._model.props.sizing_mode)
         self.metadata['Read_sizing_mode'] = "fit-width"
 
     def can_highlight(self):
@@ -134,7 +126,7 @@ class EvinceViewer():
         '''
         Sets the current zoom level
         '''
-        self._model.props.sizing_mode = EvinceView.SizingMode.FREE
+        self._model.props.sizing_mode = evince.SIZING_FREE
 
         if not self._view_notify_zoom_handler:
             return
@@ -150,18 +142,18 @@ class EvinceViewer():
         '''
         Zooms in (increases zoom level by 0.1)
         '''
-        self._model.props.sizing_mode = EvinceView.SizingMode.FREE
+        self._model.props.sizing_mode = evince.SIZING_FREE
         self._view.zoom_in()
 
     def zoom_out(self):
         '''
         Zooms out (decreases zoom level by 0.1)
         '''
-        self._model.props.sizing_mode = EvinceView.SizingMode.FREE
+        self._model.props.sizing_mode = evince.SIZING_FREE
         self._view.zoom_out()
 
     def zoom_to_width(self):
-        self._model.props.sizing_mode = EvinceView.SizingMode.FIT_WIDTH
+        self._model.props.sizing_mode = evince.SIZING_FIT_WIDTH
 
     def can_zoom_in(self):
         '''
@@ -179,10 +171,10 @@ class EvinceViewer():
         return True
 
     def zoom_to_best_fit(self):
-        self._model.props.sizing_mode = EvinceView.SizingMode.BEST_FIT
+        self._model.props.sizing_mode = evince.SIZING_BEST_FIT
 
     def zoom_to_actual_size(self):
-        self._model.props.sizing_mode = EvinceView.SizingMode.FREE
+        self._model.props.sizing_mode = evince.SIZING_FREE
         self._model.props.scale = 1.0
 
     def connect_zoom_handler(self, handler):
@@ -230,23 +222,23 @@ class EvinceViewer():
         Scrolls through the pages.
         Scrolling is horizontal if horizontal is set to True
         Valid scrolltypes are:
-        Gtk.ScrollType.PAGE_BACKWARD, Gtk.ScrollType.PAGE_FORWARD,
-        Gtk.ScrollType.STEP_BACKWARD, Gtk.ScrollType.STEP_FORWARD,
-        Gtk.ScrollType.START and Gtk.ScrollType.END
+        gtk.SCROLL_PAGE_BACKWARD, gtk.SCROLL_PAGE_FORWARD,
+        gtk.SCROLL_STEP_BACKWARD, gtk.SCROLL_STEP_FORWARD,
+        gtk.SCROLL_START and gtk.SCROLL_END
         '''
         _logger.error('scroll: %s', scrolltype)
 
-        if scrolltype == Gtk.ScrollType.PAGE_BACKWARD:
-            self._view.scroll(Gtk.ScrollType.PAGE_BACKWARD, horizontal)
-        elif scrolltype == Gtk.ScrollType.PAGE_FORWARD:
-            self._view.scroll(Gtk.ScrollType.PAGE_FORWARD, horizontal)
-        elif scrolltype == Gtk.ScrollType.STEP_BACKWARD:
+        if scrolltype == gtk.SCROLL_PAGE_BACKWARD:
+            self._view.scroll(gtk.SCROLL_PAGE_BACKWARD, horizontal)
+        elif scrolltype == gtk.SCROLL_PAGE_FORWARD:
+            self._view.scroll(gtk.SCROLL_PAGE_FORWARD, horizontal)
+        elif scrolltype == gtk.SCROLL_STEP_BACKWARD:
             self._scroll_step(False, horizontal)
-        elif scrolltype == Gtk.ScrollType.STEP_FORWARD:
+        elif scrolltype == gtk.SCROLL_STEP_FORWARD:
             self._scroll_step(True, horizontal)
-        elif scrolltype == Gtk.ScrollType.START:
+        elif scrolltype == gtk.SCROLL_START:
             self.set_current_page(0)
-        elif scrolltype == Gtk.ScrollType.END:
+        elif scrolltype == gtk.SCROLL_END:
             self.set_current_page(self._document.get_n_pages())
         else:
             print ('Got unsupported scrolltype %s' % str(scrolltype))
diff --git a/readactivity.py b/readactivity.py
index 577aab0..cea5e36 100644
--- a/readactivity.py
+++ b/readactivity.py
@@ -25,25 +25,25 @@ import re
 import md5
 
 import dbus
-from gi.repository import GObject
-from gi.repository import Gtk
-from gi.repository import Gdk
+import gobject
+import gtk
+import pango
 import telepathy
 
-from sugar3.activity import activity
-from sugar3.graphics.toolbutton import ToolButton
-from sugar3.graphics.toolbarbox import ToolbarBox
-from sugar3.graphics.toolbarbox import ToolbarButton
-from sugar3.graphics.toolcombobox import ToolComboBox
-from sugar3.graphics.toggletoolbutton import ToggleToolButton
-from sugar3.graphics.menuitem import MenuItem
-from sugar3.activity.widgets import ActivityToolbarButton
-from sugar3.activity.widgets import StopButton
-from sugar3 import network
-from sugar3 import mime
-
-from sugar3.datastore import datastore
-from sugar3.graphics.objectchooser import ObjectChooser
+from sugar.activity import activity
+from sugar.graphics.toolbutton import ToolButton
+from sugar.graphics.toolbarbox import ToolbarBox
+from sugar.graphics.toolbarbox import ToolbarButton
+from sugar.graphics.toolcombobox import ToolComboBox
+from sugar.graphics.toggletoolbutton import ToggleToolButton
+from sugar.graphics.menuitem import MenuItem
+from sugar.activity.widgets import ActivityToolbarButton
+from sugar.activity.widgets import StopButton
+from sugar import network
+from sugar import mime
+
+from sugar.datastore import datastore
+from sugar.graphics.objectchooser import ObjectChooser
 
 from readtoolbar import EditToolbar
 from readtoolbar import ViewToolbar
@@ -66,7 +66,7 @@ _logger = logging.getLogger('read-activity')
 
 
 def _get_screen_dpi():
-    xft_dpi = Gtk.Settings.get_default().get_property('gtk-xft-dpi')
+    xft_dpi = gtk.settings_get_default().get_property('gtk-xft-dpi')
     _logger.debug('Setting dpi to %f', float(xft_dpi / 1024))
     return float(xft_dpi / 1024)
 
@@ -190,26 +190,26 @@ class ReadActivity(activity.Activity):
         toolbar_box.toolbar.insert(self._forward_button, -1)
         self._forward_button.show()
 
-        num_page_item = Gtk.ToolItem()
+        num_page_item = gtk.ToolItem()
         self._num_page_entry = self._create_search()
         num_page_item.add(self._num_page_entry)
         self._num_page_entry.show()
         toolbar_box.toolbar.insert(num_page_item, -1)
         num_page_item.show()
 
-        total_page_item = Gtk.ToolItem()
-        self._total_page_label = Gtk.Label()
+        total_page_item = gtk.ToolItem()
+        self._total_page_label = self._create_total_page_label()
         total_page_item.add(self._total_page_label)
         self._total_page_label.show()
         toolbar_box.toolbar.insert(total_page_item, -1)
         total_page_item.show()
 
-        spacer = Gtk.SeparatorToolItem()
+        spacer = gtk.SeparatorToolItem()
         spacer.props.draw = False
         toolbar_box.toolbar.insert(spacer, -1)
         spacer.show()
 
-        navigator_toolbar = Gtk.Toolbar()
+        navigator_toolbar = gtk.Toolbar()
         self._navigator = self._create_navigator()
         combotool = ToolComboBox(self._navigator)
         navigator_toolbar.insert(combotool, -1)
@@ -220,12 +220,12 @@ class ReadActivity(activity.Activity):
         navigator_toolbar.show()
         toolbar_box.toolbar.insert(self._navigator_toolbar_button, -1)
 
-        spacer = Gtk.SeparatorToolItem()
+        spacer = gtk.SeparatorToolItem()
         spacer.props.draw = False
         toolbar_box.toolbar.insert(spacer, -1)
         spacer.show()
 
-        bookmark_item = Gtk.ToolItem()
+        bookmark_item = gtk.ToolItem()
         self._bookmarker = self._create_bookmarker()
         self._bookmarker_toggle_handler_id = self._bookmarker.connect( \
                 'toggled', self.__bookmarker_toggled_cb)
@@ -234,7 +234,7 @@ class ReadActivity(activity.Activity):
         toolbar_box.toolbar.insert(bookmark_item, -1)
         bookmark_item.show()
 
-        self._highlight_item = Gtk.ToolItem()
+        self._highlight_item = gtk.ToolItem()
         self._highlight = ToggleToolButton('format-text-underline')
         self._highlight.set_tooltip(_('Highlight'))
         self._highlight.props.sensitive = False
@@ -249,7 +249,7 @@ class ReadActivity(activity.Activity):
                     icon_name='speak')
         toolbar_box.toolbar.insert(self.speech_toolbar_button, -1)
 
-        separator = Gtk.SeparatorToolItem()
+        separator = gtk.SeparatorToolItem()
         separator.props.draw = False
         separator.set_expand(True)
         toolbar_box.toolbar.insert(separator, -1)
@@ -262,17 +262,17 @@ class ReadActivity(activity.Activity):
         self.set_toolbar_box(toolbar_box)
         toolbar_box.show()
 
-        self._vbox = Gtk.VBox()
+        self._vbox = gtk.VBox()
         self._vbox.show()
 
         self._topbar = TopBar()
-        self._vbox.pack_start(self._topbar, False, False, 0)
+        self._vbox.pack_start(self._topbar, expand=False, fill=False)
 
-        self._hbox = Gtk.HBox()
+        self._hbox = gtk.HBox()
         self._hbox.show()
-        self._hbox.pack_start(self._sidebar, False, False, 0)
+        self._hbox.pack_start(self._sidebar, expand=False, fill=False)
 
-        self._vbox.pack_start(self._hbox, True, True, 0)
+        self._vbox.pack_start(self._hbox, expand=True, fill=True)
         self.set_canvas(self._vbox)
 
         # Set up for idle suspend
@@ -291,7 +291,6 @@ class ReadActivity(activity.Activity):
         self._close_requested = False
 
         fname = os.path.join('/etc', 'inhibit-ebook-sleep')
-
         if not os.path.exists(fname):
             try:
                 bus = dbus.SystemBus()
@@ -378,7 +377,7 @@ class ReadActivity(activity.Activity):
         return forward
 
     def _create_search(self):
-        num_page_entry = Gtk.Entry()
+        num_page_entry = gtk.Entry()
         num_page_entry.set_text('0')
         num_page_entry.set_alignment(1)
         num_page_entry.connect('insert-text',
@@ -388,15 +387,21 @@ class ReadActivity(activity.Activity):
         num_page_entry.set_width_chars(4)
         return num_page_entry
 
-    def _set_total_page_label(self, value):
-        self._total_page_label.set_use_markup(True)
-        self._total_page_label.set_markup(
-                '<span font_desc="14" foreground="#ffffff"> / %s</span>' %
-                value)
+    def _create_total_page_label(self):
+        total_page_label = gtk.Label()
+
+        label_attributes = pango.AttrList()
+        label_attributes.insert(pango.AttrSize(14000, 0, -1))
+        label_attributes.insert(pango.AttrForeground(65535, 65535,
+                                                     65535, 0, -1))
+        total_page_label.set_attributes(label_attributes)
+
+        total_page_label.set_text(' / 0')
+        return total_page_label
 
     def _create_navigator(self):
-        navigator = Gtk.ComboBox()
-        cell = Gtk.CellRendererText()
+        navigator = gtk.ComboBox()
+        cell = gtk.CellRendererText()
         navigator.pack_start(cell, True)
         navigator.add_attribute(cell, 'text', 0)
         navigator.props.visible = False
@@ -422,10 +427,10 @@ class ReadActivity(activity.Activity):
         entry.props.text = str(page + 1)
 
     def __go_back_cb(self, button):
-        self._view.scroll(Gtk.ScrollType.PAGE_BACKWARD, False)
+        self._view.scroll(gtk.SCROLL_PAGE_BACKWARD, False)
 
     def __go_forward_cb(self, button):
-        self._view.scroll(Gtk.ScrollType.PAGE_FORWARD, False)
+        self._view.scroll(gtk.SCROLL_PAGE_FORWARD, False)
 
     def __go_back_page_cb(self, button):
         self._view.previous_page()
@@ -506,7 +511,8 @@ class ReadActivity(activity.Activity):
             current_page < self._view.get_pagecount() - 1
 
         self._num_page_entry.props.text = str(current_page + 1)
-        self._set_total_page_label(self._view.get_pagecount())
+        self._total_page_label.props.label = \
+            ' / ' + str(self._view.get_pagecount())
 
     def _update_toc(self):
         if self._view.update_toc(self):
@@ -561,13 +567,13 @@ class ReadActivity(activity.Activity):
         """
         if not self._want_document:
             return
-        chooser = ObjectChooser(_('Choose document'), None,
-                                Gtk.DialogFlags.MODAL |
-                                Gtk.DialogFlags.DESTROY_WITH_PARENT,
+        chooser = ObjectChooser(_('Choose document'), self,
+                                gtk.DIALOG_MODAL |
+                                gtk.DIALOG_DESTROY_WITH_PARENT,
                                 what_filter=mime.GENERIC_TYPE_TEXT)
         try:
             result = chooser.run()
-            if result == Gtk.ResponseType.ACCEPT:
+            if result == gtk.RESPONSE_ACCEPT:
                 logging.debug('ObjectChooser: %r' %
                               chooser.get_selected_object())
                 jobject = chooser.get_selected_object()
@@ -581,8 +587,8 @@ class ReadActivity(activity.Activity):
         if self.props.active:
             # Now active, start initial suspend timeout
             if self._idle_timer > 0:
-                GObject.source_remove(self._idle_timer)
-            self._idle_timer = GObject.timeout_add_seconds(15,
+                gobject.source_remove(self._idle_timer)
+            self._idle_timer = gobject.timeout_add_seconds(15,
                     self._suspend_cb)
             self._sleep_inhibit = False
         else:
@@ -601,8 +607,8 @@ class ReadActivity(activity.Activity):
     def _user_action_cb(self, widget):
         """Set a timer for going back to ebook mode idle sleep."""
         if self._idle_timer > 0:
-            GObject.source_remove(self._idle_timer)
-        self._idle_timer = GObject.timeout_add_seconds(5, self._suspend_cb)
+            gobject.source_remove(self._idle_timer)
+        self._idle_timer = gobject.timeout_add_seconds(5, self._suspend_cb)
 
     def _suspend_cb(self):
         """Go into ebook mode idle sleep."""
@@ -623,7 +629,7 @@ class ReadActivity(activity.Activity):
         self._load_document('file://' + self._tempfile)
 
         # FIXME: This should obviously be fixed properly
-        GObject.timeout_add_seconds(1,
+        gobject.timeout_add_seconds(1,
                 self.__view_toolbar_needs_update_size_cb, None)
 
     def write_file(self, file_path):
@@ -709,7 +715,7 @@ class ReadActivity(activity.Activity):
         self._want_document = True
         self._download_content_length = 0
         self._download_content_type = None
-        GObject.idle_add(self._get_document)
+        gobject.idle_add(self._get_document)
 
     def _download_document(self, tube_id, path):
         # FIXME: should ideally have the CM listen on a Unix socket
@@ -761,7 +767,7 @@ class ReadActivity(activity.Activity):
 
         # Avoid trying to download the document multiple times at once
         self._want_document = False
-        GObject.idle_add(self._download_document, tube_id, path)
+        gobject.idle_add(self._download_document, tube_id, path)
         return False
 
     def _joined_cb(self, also_self):
@@ -770,7 +776,7 @@ class ReadActivity(activity.Activity):
         Get the shared document from another participant.
         """
         self.watch_for_tubes()
-        GObject.idle_add(self._get_document)
+        gobject.idle_add(self._get_document)
 
     def _load_document(self, filepath):
         """Load the specified document and set up the UI.
@@ -870,7 +876,7 @@ class ReadActivity(activity.Activity):
             self.unused_download_tubes.add(tube_id)
             # if no download is in progress, let's fetch the document
             if self._want_document:
-                GObject.idle_add(self._get_document)
+                gobject.idle_add(self._get_document)
 
     def _list_tubes_reply_cb(self, tubes):
         """Callback when new tubes are available."""
@@ -927,8 +933,8 @@ class ReadActivity(activity.Activity):
         self._view.copy()
 
     def _key_press_event_cb(self, widget, event):
-        keyname = Gdk.keyval_name(event.keyval)
-        if keyname == 'c' and event.state & Gdk.CONTROL_MASK:
+        keyname = gtk.gdk.keyval_name(event.keyval)
+        if keyname == 'c' and event.state & gtk.gdk.CONTROL_MASK:
             self._view.copy()
             return True
         elif keyname == 'KP_Home':
@@ -939,34 +945,34 @@ class ReadActivity(activity.Activity):
             self._view_toolbar.zoom_out()
             return True
         elif keyname == 'Home':
-            self._view.scroll(Gtk.ScrollType.START, False)
+            self._view.scroll(gtk.SCROLL_START, False)
             return True
         elif keyname == 'End':
-            self._view.scroll(Gtk.ScrollType.END, False)
+            self._view.scroll(gtk.SCROLL_END, False)
             return True
         elif keyname == 'Page_Up' or keyname == 'KP_Page_Up':
-            self._view.scroll(Gtk.ScrollType.PAGE_BACKWARD, False)
+            self._view.scroll(gtk.SCROLL_PAGE_BACKWARD, False)
             return True
         elif keyname == 'Page_Down' or keyname == 'KP_Page_Down':
-            self._view.scroll(Gtk.ScrollType.PAGE_FORWARD, False)
+            self._view.scroll(gtk.SCROLL_PAGE_FORWARD, False)
             return True
         elif keyname == 'Up' or keyname == 'KP_Up':
-            self._view.scroll(Gtk.ScrollType.STEP_BACKWARD, False)
+            self._view.scroll(gtk.SCROLL_STEP_BACKWARD, False)
             return True
         elif keyname == 'Down' or keyname == 'KP_Down':
-            self._view.scroll(Gtk.ScrollType.STEP_FORWARD, False)
+            self._view.scroll(gtk.SCROLL_STEP_FORWARD, False)
             return True
         elif keyname == 'Left' or keyname == 'KP_Left':
-            self._view.scroll(Gtk.ScrollType.STEP_BACKWARD, True)
+            self._view.scroll(gtk.SCROLL_STEP_BACKWARD, True)
             return True
         elif keyname == 'Right' or keyname == 'KP_Right':
-            self._view.scroll(Gtk.ScrollType.STEP_FORWARD, True)
+            self._view.scroll(gtk.SCROLL_STEP_FORWARD, True)
             return True
         else:
             return False
 
     def _key_release_event_cb(self, widget, event):
-        #keyname = Gdk.keyval_name(event.keyval)
+        #keyname = gtk.gdk.keyval_name(event.keyval)
         #_logger.debug("Keyname Release: %s, time: %s", keyname, event.time)
         return False
 
diff --git a/readdialog.py b/readdialog.py
index 4460fe4..bc8b822 100644
--- a/readdialog.py
+++ b/readdialog.py
@@ -2,48 +2,47 @@
 
 # Stolen from the PyGTK demo module by Maik Hertha <maik.hertha@berlin.de>
 
-from gi.repository import GObject
-from gi.repository import Gtk
-from gi.repository import Gdk
+import gtk
+import gobject
 
-from sugar3.graphics import style
-from sugar3.graphics.toolbutton import ToolButton
+from sugar.graphics import style
+from sugar.graphics.toolbutton import ToolButton
 
 from gettext import gettext as _
 import cjson
 
 
-class BaseReadDialog(Gtk.Window):
+class BaseReadDialog(gtk.Window):
 
     def __init__(self, parent_xid, dialog_title):
-        Gtk.Window.__init__(self)
+        gtk.Window.__init__(self)
 
         self.connect('realize', self.__realize_cb)
 
         self.set_decorated(False)
-        self.set_position(Gtk.WindowPosition.CENTER_ALWAYS)
+        self.set_position(gtk.WIN_POS_CENTER_ALWAYS)
         self.set_border_width(style.LINE_WIDTH)
 
-        width = Gdk.Screen.width() - style.GRID_CELL_SIZE * 4
-        height = Gdk.Screen.height() - style.GRID_CELL_SIZE * 4
+        width = gtk.gdk.screen_width() - style.GRID_CELL_SIZE * 4
+        height = gtk.gdk.screen_height() - style.GRID_CELL_SIZE * 4
         self.set_size_request(width, height)
 
         self._parent_window_xid = parent_xid
 
-        _vbox = Gtk.VBox(spacing=2)
+        _vbox = gtk.VBox(spacing=2)
         self.add(_vbox)
 
-        self.toolbar = Gtk.Toolbar()
-        label = Gtk.Label()
+        self.toolbar = gtk.Toolbar()
+        label = gtk.Label()
         label.set_markup('<b>  %s</b>' % dialog_title)
         label.set_alignment(0, 0.5)
-        tool_item = Gtk.ToolItem()
+        tool_item = gtk.ToolItem()
         tool_item.add(label)
         label.show()
         self.toolbar.insert(tool_item, -1)
         tool_item.show()
 
-        separator = Gtk.SeparatorToolItem()
+        separator = gtk.SeparatorToolItem()
         separator.props.draw = False
         separator.set_expand(True)
         self.toolbar.insert(separator, -1)
@@ -60,11 +59,11 @@ class BaseReadDialog(Gtk.Window):
         accept.show()
         self.toolbar.insert(accept, -1)
 
-        _vbox.pack_start(self.toolbar, False, True, 0)
+        _vbox.pack_start(self.toolbar, expand=False)
         self.toolbar.show()
 
-        self._event_box = Gtk.EventBox()
-        _vbox.pack_start(self._event_box, True, True, 0)
+        self._event_box = gtk.EventBox()
+        _vbox.pack_start(self._event_box, expand=True, fill=True)
         self._canvas = None
 
     def set_canvas(self, canvas):
@@ -74,21 +73,21 @@ class BaseReadDialog(Gtk.Window):
         self._canvas = canvas
 
     def __realize_cb(self, widget):
-        self.window.set_type_hint(Gdk.WindowType._HINT_DIALOG)
+        self.window.set_type_hint(gtk.gdk.WINDOW_TYPE_HINT_DIALOG)
         self.window.set_accept_focus(True)
 
-        parent = Gdk.window_foreign_new(self._parent_window_xid)
+        parent = gtk.gdk.window_foreign_new(self._parent_window_xid)
         self.window.set_transient_for(parent)
 
-        self.modify_bg(Gtk.StateType.NORMAL,
+        self.modify_bg(gtk.STATE_NORMAL,
                             style.COLOR_WHITE.get_gdk_color())
 
         if self._canvas is not None:
-            self._canvas.modify_bg(Gtk.StateType.NORMAL,
+            self._canvas.modify_bg(gtk.STATE_NORMAL,
                 style.COLOR_WHITE.get_gdk_color())
             self._canvas.grab_focus()
 
-        self._event_box.modify_bg(Gtk.StateType.NORMAL,
+        self._event_box.modify_bg(gtk.STATE_NORMAL,
                 style.COLOR_WHITE.get_gdk_color())
 
     def accept_clicked_cb(self, widget):
@@ -103,57 +102,57 @@ class BookmarkDialog(BaseReadDialog):
         self._sidebarinstance = sidebarinstance
         self._page = page
 
-        vbox = Gtk.VBox()
-        thbox = Gtk.HBox()
-        vbox.pack_start(thbox, False, False, 0)
+        vbox = gtk.VBox()
+        thbox = gtk.HBox()
+        vbox.pack_start(thbox, expand=False, fill=False)
         thbox.set_border_width(style.DEFAULT_SPACING * 2)
         thbox.set_spacing(style.DEFAULT_SPACING)
         thbox.show()
 
-        label_title = Gtk.Label(_('<b>Title</b>:'))
+        label_title = gtk.Label(_('<b>Title</b>:'))
         label_title.set_use_markup(True)
         label_title.set_alignment(1, 0.5)
-        label_title.modify_fg(Gtk.StateType.NORMAL,
+        label_title.modify_fg(gtk.STATE_NORMAL,
                             style.COLOR_SELECTION_GREY.get_gdk_color())
-        thbox.pack_start(label_title, False, False, 0)
+        thbox.pack_start(label_title, expand=False, fill=False)
         label_title.show()
 
-        self._title_entry = Gtk.Entry()
-        self._title_entry.modify_bg(Gtk.StateType.INSENSITIVE,
+        self._title_entry = gtk.Entry()
+        self._title_entry.modify_bg(gtk.STATE_INSENSITIVE,
                             style.COLOR_WHITE.get_gdk_color())
-        self._title_entry.modify_base(Gtk.StateType.INSENSITIVE,
+        self._title_entry.modify_base(gtk.STATE_INSENSITIVE,
                             style.COLOR_WHITE.get_gdk_color())
-        self._title_entry.set_size_request(int(Gdk.Screen.width() / 3), -1)
+        self._title_entry.set_size_request(int(gtk.gdk.screen_width() / 3), -1)
 
-        thbox.pack_start(self._title_entry, False, False, 0)
+        thbox.pack_start(self._title_entry, expand=False, fill=False)
         self._title_entry.show()
         if bookmark_title is not None:
             self._title_entry.set_text(bookmark_title)
 
-        cvbox = Gtk.VBox()
-        vbox.pack_start(cvbox, True, True, 0)
+        cvbox = gtk.VBox()
+        vbox.pack_start(cvbox, expand=True, fill=True)
         cvbox.set_border_width(style.DEFAULT_SPACING * 2)
         cvbox.set_spacing(style.DEFAULT_SPACING / 2)
         cvbox.show()
 
-        label_content = Gtk.Label(_('<b>Details</b>:'))
+        label_content = gtk.Label(_('<b>Details</b>:'))
         label_content.set_use_markup(True)
         label_content.set_alignment(0, 0)
-        label_content.modify_fg(Gtk.StateType.NORMAL,
+        label_content.modify_fg(gtk.STATE_NORMAL,
                             style.COLOR_SELECTION_GREY.get_gdk_color())
-        cvbox.pack_start(label_content, False, False, 0)
+        cvbox.pack_start(label_content, expand=False, fill=False)
         label_content.show()
 
-        sw = Gtk.ScrolledWindow()
-        sw.set_policy(Gtk.PolicyType.AUTOMATIC, Gtk.PolicyType.AUTOMATIC)
+        sw = gtk.ScrolledWindow()
+        sw.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
 
-        self._content_entry = Gtk.TextView()
-        self._content_entry.set_wrap_mode(Gtk.WrapMode.WORD)
+        self._content_entry = gtk.TextView()
+        self._content_entry.set_wrap_mode(gtk.WRAP_WORD)
 
         sw.add(self._content_entry)
-        sw.set_shadow_type(Gtk.ShadowType.ETCHED_IN)
+        sw.set_shadow_type(gtk.SHADOW_ETCHED_IN)
 
-        cvbox.pack_start(sw, True, True, 0)
+        cvbox.pack_start(sw, expand=True, fill=True)
         self._content_entry.show()
         if bookmark_content is not None:
             buffer = self._content_entry.get_buffer()
diff --git a/readsidebar.py b/readsidebar.py
index 5dee47f..b4db2bc 100644
--- a/readsidebar.py
+++ b/readsidebar.py
@@ -18,14 +18,12 @@
 import logging
 import time
 
-from gi.repository import Gtk
-from gi.repository import Gdk
+import gtk
 
-from sugar3.graphics.icon import Icon
-from sugar3.graphics.xocolor import XoColor
-from sugar3 import profile
-from sugar3.util import timestamp_to_elapsed_string
-from sugar3.graphics import style
+from sugar.graphics.icon import Icon
+from sugar.graphics.xocolor import XoColor
+from sugar import profile
+from sugar.util import timestamp_to_elapsed_string
 
 from readbookmark import Bookmark
 from readdb import BookmarkManager
@@ -40,16 +38,17 @@ _logger = logging.getLogger('read-activity')
 # (required when sharing)
 
 
-class Sidebar(Gtk.EventBox):
+class Sidebar(gtk.EventBox):
 
     def __init__(self):
-        Gtk.EventBox.__init__(self)
+        gtk.EventBox.__init__(self)
         self.set_size_request(20, -1)
         # Take care of the background first
-        self.modify_bg(Gtk.StateType.NORMAL, style.COLOR_WHITE.get_gdk_color())
+        white = gtk.gdk.color_parse("white")
+        self.modify_bg(gtk.STATE_NORMAL, white)
 
-        self._box = Gtk.VButtonBox()
-        self._box.set_layout(Gtk.ButtonBoxStyle.CENTER)
+        self._box = gtk.VButtonBox()
+        self._box.set_layout(gtk.BUTTONBOX_CENTER)
         self.add(self._box)
 
         self._box.show()
@@ -58,7 +57,8 @@ class Sidebar(Gtk.EventBox):
         self._bookmark_icon = None
         self._bookmark_manager = None
         self._is_showing_local_bookmark = False
-        self.add_events(Gdk.EventMask.BUTTON_PRESS_MASK)
+
+        self.add_events(gtk.gdk.BUTTON_PRESS_MASK)
 
     def _add_bookmark_icon(self, bookmark):
         xocolor = XoColor(bookmark.color)
@@ -73,7 +73,7 @@ class Sidebar(Gtk.EventBox):
         self.__event_cb_id = \
             self.connect('event', self.__event_cb, bookmark)
 
-        self._box.pack_start(self._bookmark_icon, False, False, 0)
+        self._box.pack_start(self._bookmark_icon, expand=False, fill=False)
         self._bookmark_icon.show_all()
 
         if bookmark.is_local():
@@ -89,30 +89,30 @@ class Sidebar(Gtk.EventBox):
                 % {'user': bookmark.nick,
                 'time': timestamp_to_elapsed_string(bookmark.timestamp)})
 
-        vbox = Gtk.VBox()
+        vbox = gtk.VBox()
 
-        l = Gtk.Label('<big>%s</big>' % tooltip_header)
+        l = gtk.Label('<big>%s</big>' % tooltip_header)
         l.set_use_markup(True)
         l.set_width_chars(40)
         l.set_line_wrap(True)
-        vbox.pack_start(l, False, False, 0)
+        vbox.pack_start(l, expand=False, fill=False)
         l.show()
 
-        l = Gtk.Label('%s' % tooltip_body)
+        l = gtk.Label('%s' % tooltip_body)
         l.set_use_markup(True)
         l.set_alignment(0, 0)
         l.set_padding(2, 6)
         l.set_width_chars(40)
         l.set_line_wrap(True)
-        l.set_justify(Gtk.JUSTIFY_FILL)
-        vbox.pack_start(l, True, True, 0)
+        l.set_justify(gtk.JUSTIFY_FILL)
+        vbox.pack_start(l, expand=True, fill=True)
         l.show()
 
-        l = Gtk.Label('<small><i>%s</i></small>' % tooltip_footer)
+        l = gtk.Label('<small><i>%s</i></small>' % tooltip_footer)
         l.set_use_markup(True)
         l.set_width_chars(40)
         l.set_line_wrap(True)
-        vbox.pack_start(l, False, False, 0)
+        vbox.pack_start(l, expand=False, fill=False)
         l.show()
 
         tip.set_custom(vbox)
@@ -120,7 +120,7 @@ class Sidebar(Gtk.EventBox):
         return True
 
     def __event_cb(self, widget, event, bookmark):
-        if event.type == Gdk.EventType.BUTTON_PRESS and \
+        if event.type == gtk.gdk.BUTTON_PRESS and \
                     self._bookmark_icon is not None:
 
             bookmark_title = bookmark.get_note_title()
diff --git a/readtoolbar.py b/readtoolbar.py
index b52d19c..043ac05 100644
--- a/readtoolbar.py
+++ b/readtoolbar.py
@@ -17,19 +17,18 @@
 from gettext import gettext as _
 import logging
 
-from gi.repository import GObject
-from gi.repository import Gtk
-from gi.repository import Gdk
+import gobject
+import gtk
 import os
 import simplejson
 
-from sugar3.graphics.combobox import ComboBox
-from sugar3.graphics.toolbutton import ToolButton
-from sugar3.graphics.toggletoolbutton import ToggleToolButton
-from sugar3.graphics.toolcombobox import ToolComboBox
-from sugar3.graphics.menuitem import MenuItem
-from sugar3.graphics import iconentry
-from sugar3.activity import activity
+from sugar.graphics.combobox import ComboBox
+from sugar.graphics.toolbutton import ToolButton
+from sugar.graphics.toggletoolbutton import ToggleToolButton
+from sugar.graphics.toolcombobox import ToolComboBox
+from sugar.graphics.menuitem import MenuItem
+from sugar.graphics import iconentry
+from sugar.activity import activity
 
 import speech
 
@@ -45,7 +44,7 @@ class EditToolbar(activity.EditToolbar):
 
         self._find_job = None
 
-        search_item = Gtk.ToolItem()
+        search_item = gtk.ToolItem()
 
         self._search_entry = iconentry.IconEntry()
         self._search_entry.set_icon_from_name(iconentry.ICON_ENTRY_PRIMARY,
@@ -55,7 +54,7 @@ class EditToolbar(activity.EditToolbar):
         self._search_entry.connect('changed', self._search_entry_changed_cb)
         self._search_entry_changed = True
 
-        width = int(Gdk.Screen.width() / 3)
+        width = int(gtk.gdk.screen_width() / 3)
         self._search_entry.set_size_request(width, -1)
 
         search_item.add(self._search_entry)
@@ -124,7 +123,7 @@ class EditToolbar(activity.EditToolbar):
         self._search_entry_changed = True
         self._update_find_buttons()
 
-    #    GObject.timeout_add(500, self._search_entry_timeout_cb)
+    #    gobject.timeout_add(500, self._search_entry_timeout_cb)
     #
     #def _search_entry_timeout_cb(self):
     #    self._clear_find_job()
@@ -166,16 +165,15 @@ class EditToolbar(activity.EditToolbar):
             self._next.set_tooltip(_('Find next'))
 
 
-class ViewToolbar(Gtk.Toolbar):
+class ViewToolbar(gtk.Toolbar):
     __gtype_name__ = 'ViewToolbar'
 
     __gsignals__ = {
-        'go-fullscreen': (GObject.SignalFlags.RUN_FIRST, GObject.TYPE_NONE,
-                ([])),
+        'go-fullscreen': (gobject.SIGNAL_RUN_FIRST, gobject.TYPE_NONE, ([])),
     }
 
     def __init__(self):
-        Gtk.Toolbar.__init__(self)
+        gtk.Toolbar.__init__(self)
 
         self._view = None
 
@@ -208,11 +206,11 @@ class ViewToolbar(Gtk.Toolbar):
         palette.menu.append(menu_item)
         menu_item.show()
 
-        tool_item = Gtk.ToolItem()
+        tool_item = gtk.ToolItem()
         self.insert(tool_item, -1)
         tool_item.show()
 
-        self._zoom_spin = Gtk.SpinButton()
+        self._zoom_spin = gtk.SpinButton()
         self._zoom_spin.set_range(5.409, 400)
         self._zoom_spin.set_increments(1, 10)
         self._zoom_spin_notify_value_handler = self._zoom_spin.connect(
@@ -220,14 +218,14 @@ class ViewToolbar(Gtk.Toolbar):
         tool_item.add(self._zoom_spin)
         self._zoom_spin.show()
 
-        zoom_perc_label = Gtk.Label(_("%"))
+        zoom_perc_label = gtk.Label(_("%"))
         zoom_perc_label.show()
-        tool_item_zoom_perc_label = Gtk.ToolItem()
+        tool_item_zoom_perc_label = gtk.ToolItem()
         tool_item_zoom_perc_label.add(zoom_perc_label)
         self.insert(tool_item_zoom_perc_label, -1)
         tool_item_zoom_perc_label.show()
 
-        spacer = Gtk.SeparatorToolItem()
+        spacer = gtk.SeparatorToolItem()
         spacer.props.draw = False
         self.insert(spacer, -1)
         spacer.show()
@@ -299,11 +297,11 @@ class ViewToolbar(Gtk.Toolbar):
         self.emit('go-fullscreen')
 
 
-class SpeechToolbar(Gtk.Toolbar):
+class SpeechToolbar(gtk.Toolbar):
 
     def __init__(self, activity):
-        Gtk.Toolbar.__init__(self)
-        voicebar = Gtk.Toolbar()
+        gtk.Toolbar.__init__(self)
+        voicebar = gtk.Toolbar()
         self._activity = activity
         if not speech.supported:
             return
@@ -335,25 +333,25 @@ class SpeechToolbar(Gtk.Toolbar):
         self.insert(combotool, -1)
         combotool.show()
 
-        self.pitchadj = Gtk.Adjustment(0, -100, 100, 1, 10, 0)
-        pitchbar = Gtk.HScale()
-        pitchbar.set_adjustment(self.pitchadj)
+        self.pitchadj = gtk.Adjustment(0, -100, 100, 1, 10, 0)
+        pitchbar = gtk.HScale(self.pitchadj)
         pitchbar.set_draw_value(False)
+        pitchbar.set_update_policy(gtk.UPDATE_DISCONTINUOUS)
         pitchbar.set_size_request(150, 15)
         self.pitchadj.set_value(speech.pitch)
-        pitchtool = Gtk.ToolItem()
+        pitchtool = gtk.ToolItem()
         pitchtool.add(pitchbar)
         pitchtool.show()
         self.insert(pitchtool, -1)
         pitchbar.show()
 
-        self.rateadj = Gtk.Adjustment(0, -100, 100, 1, 10, 0)
-        ratebar = Gtk.HScale()
-        ratebar.set_adjustment(self.rateadj)
+        self.rateadj = gtk.Adjustment(0, -100, 100, 1, 10, 0)
+        ratebar = gtk.HScale(self.rateadj)
         ratebar.set_draw_value(False)
+        ratebar.set_update_policy(gtk.UPDATE_DISCONTINUOUS)
         ratebar.set_size_request(150, 15)
         self.rateadj.set_value(speech.rate)
-        ratetool = Gtk.ToolItem()
+        ratetool = gtk.ToolItem()
         ratetool.add(ratebar)
         ratetool.show()
         self.insert(ratetool, -1)
diff --git a/readtopbar.py b/readtopbar.py
index 3190203..fc4a534 100644
--- a/readtopbar.py
+++ b/readtopbar.py
@@ -16,13 +16,13 @@
 # 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
+import gtk
+import gobject
 import dbus
 import logging
 
-from sugar3.graphics import style
-from sugar3.graphics.icon import Icon, get_icon_state
+from sugar.graphics import style
+from sugar.graphics.icon import Icon, get_icon_state
 
 from gettext import gettext as _
 
@@ -33,14 +33,14 @@ _UP_DEVICE_IFACE = 'org.freedesktop.UPower.Device'
 _UP_TYPE_BATTERY = 2
 
 
-class _TopBar(Gtk.HBox):
+class _TopBar(gtk.HBox):
     __gproperties__ = {
         'completion-level': (float, None, None, 0.0, 100.0, 0.0,
-                             GObject.ParamFlags.WRITABLE),
+                             gobject.PARAM_READWRITE),
     }
 
     def __init__(self):
-        Gtk.HBox.__init__(self)
+        gtk.HBox.__init__(self)
 
         self.set_border_width(int(style.DEFAULT_SPACING / 2.0))
         self.set_spacing(style.DEFAULT_SPACING * 4)
@@ -102,16 +102,17 @@ class _TopBar(Gtk.HBox):
             return 0
 
     def _setup(self):
-        self._progressbar = Gtk.ProgressBar()
+        self._progressbar = gtk.ProgressBar()
+        self._progressbar.props.discrete_blocks = 10
         self._progressbar.set_fraction(self._completion_level / 100.0)
-        self.pack_start(self._progressbar, True, True, 0)
+        self.pack_start(self._progressbar, expand=True, fill=True)
         if self._battery_props is None:
             return
 
         level = self._get_battery_level()
         icon_name = get_icon_state(_ICON_NAME, level, step=-5)
         self._icon = Icon(icon_name=icon_name)
-        self.pack_start(self._icon, False, False, 0)
+        self.pack_start(self._icon, expand=False, fill=False)
 
     def __battery_properties_changed_cb(self):
         level = self._get_battery_level()
diff --git a/speech_dispatcher.py b/speech_dispatcher.py
index 977a16d..4fad27f 100644
--- a/speech_dispatcher.py
+++ b/speech_dispatcher.py
@@ -14,7 +14,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 Gtk
+import gtk
 import time
 import threading
 import speechd
@@ -105,12 +105,12 @@ class EspeakThread(threading.Thread):
         if type == speechd.CallbackType.INDEX_MARK:
             mark = kargs['index_mark']
             word_count = int(mark)
-            Gtk.gdk.threads_enter()
+            gtk.gdk.threads_enter()
             speech.highlight_cb(word_count)
-            Gtk.gdk.threads_leave()
+            gtk.gdk.threads_leave()
         elif type == speechd.CallbackType.END:
-            Gtk.gdk.threads_enter()
+            gtk.gdk.threads_enter()
             speech.reset_cb()
-            Gtk.gdk.threads_leave()
+            gtk.gdk.threads_leave()
             global done
             done = True
diff --git a/textadapter.py b/textadapter.py
index f6dee23..526f6f1 100644
--- a/textadapter.py
+++ b/textadapter.py
@@ -1,45 +1,44 @@
 import os
 import zipfile
 import logging
-from gi.repository import Gtk
-from gi.repository import Pango
-from gi.repository import GObject
+import gtk
+import pango
+import gobject
 import threading
 
-from sugar3 import mime
-from sugar3.graphics import style
+from sugar import mime
+from sugar.graphics import style
 
 import speech
 
 PAGE_SIZE = 38
 
 
-class TextViewer(GObject.GObject):
+class TextViewer(gobject.GObject):
 
     __gsignals__ = {
-        'zoom-changed': (GObject.SignalFlags.RUN_FIRST, GObject.TYPE_NONE,
+        'zoom-changed': (gobject.SIGNAL_RUN_FIRST, gobject.TYPE_NONE,
                 ([int])),
-        'page-changed': (GObject.SignalFlags.RUN_FIRST, GObject.TYPE_NONE,
+        'page-changed': (gobject.SIGNAL_RUN_FIRST, gobject.TYPE_NONE,
                 ([int, int])),
-        'selection-changed': (GObject.SignalFlags.RUN_FIRST, GObject.TYPE_NONE,
+        'selection-changed': (gobject.SIGNAL_RUN_FIRST, gobject.TYPE_NONE,
                               ([])),
     }
 
     def setup(self, activity):
         self._activity = activity
-        activity._scrolled = Gtk.ScrolledWindow()
-        activity._scrolled.set_policy(Gtk.PolicyType.NEVER,
-                Gtk.PolicyType.AUTOMATIC)
-        activity._scrolled.props.shadow_type = Gtk.ShadowType.NONE
+        activity._scrolled = gtk.ScrolledWindow()
+        activity._scrolled.set_policy(gtk.POLICY_NEVER, gtk.POLICY_AUTOMATIC)
+        activity._scrolled.props.shadow_type = gtk.SHADOW_NONE
 
         self._scrolled = activity._scrolled
 
-        self.textview = Gtk.TextView()
+        self.textview = gtk.TextView()
         self.textview.set_editable(False)
         self.textview.set_cursor_visible(False)
         self.textview.set_left_margin(50)
         self.textview.set_right_margin(50)
-        self.textview.set_wrap_mode(Gtk.WrapMode.WORD)
+        self.textview.set_wrap_mode(gtk.WRAP_WORD)
         self.textview.connect('button-release-event', \
                 self._view_buttonrelease_event_cb)
         self.connect('selection-changed',
@@ -48,10 +47,10 @@ class TextViewer(GObject.GObject):
         activity._scrolled.add(self.textview)
         self.textview.show()
         activity._scrolled.show()
-        activity._hbox.pack_start(activity._scrolled, True, True, 0)
+        activity._hbox.pack_start(activity._scrolled, expand=True, fill=True)
 
         self._font_size = style.zoom(10)
-        self.font_desc = Pango.FontDescription("sans %d" % self._font_size)
+        self.font_desc = pango.FontDescription("sans %d" % self._font_size)
         self.textview.modify_font(self.font_desc)
         self._zoom = 100
         self.font_zoom_relation = self._zoom / self._font_size
@@ -66,9 +65,9 @@ class TextViewer(GObject.GObject):
         self.current_word = 0
         self.word_tuples = []
         self.spoken_word_tag = self.textview.get_buffer().create_tag()
-        self.spoken_word_tag.set_property('weight', Pango.Weight.BOLD)
+        self.spoken_word_tag.set_property('weight', pango.WEIGHT_BOLD)
         self.normal_tag = self.textview.get_buffer().create_tag()
-        self.normal_tag.set_property('weight',  Pango.Weight.NORMAL)
+        self.normal_tag.set_property('weight',  pango.WEIGHT_NORMAL)
 
     def load_document(self, file_path):
 
@@ -220,14 +219,12 @@ class TextViewer(GObject.GObject):
     def scroll(self, scrolltype, horizontal):
         v_adjustment = self._scrolled.get_vadjustment()
         v_value = v_adjustment.value
-        if scrolltype in (Gtk.ScrollType.PAGE_BACKWARD,
-                Gtk.ScrollType.PAGE_FORWARD):
+        if scrolltype in (gtk.SCROLL_PAGE_BACKWARD, gtk.SCROLL_PAGE_FORWARD):
             step = v_adjustment.page_increment
         else:
             step = v_adjustment.step_increment
 
-        if scrolltype in (Gtk.ScrollType.PAGE_BACKWARD,
-                Gtk.ScrollType.STEP_BACKWARD):
+        if scrolltype in (gtk.SCROLL_PAGE_BACKWARD, gtk.SCROLL_STEP_BACKWARD):
             if v_value <= v_adjustment.lower:
                 self.previous_page()
                 v_adjustment.value = v_adjustment.upper - \
@@ -238,8 +235,7 @@ class TextViewer(GObject.GObject):
                 if new_value < v_adjustment.lower:
                     new_value = v_adjustment.lower
                 v_adjustment.value = new_value
-        elif scrolltype in (Gtk.ScrollType.PAGE_FORWARD,
-                Gtk.ScrollType.STEP_FORWARD):
+        elif scrolltype in (gtk.SCROLL_PAGE_FORWARD, gtk.SCROLL_STEP_FORWARD):
             if v_value >= v_adjustment.upper - v_adjustment.page_size:
                 self.next_page()
                 return
@@ -248,9 +244,9 @@ class TextViewer(GObject.GObject):
                 if new_value > v_adjustment.upper - v_adjustment.page_size:
                     new_value = v_adjustment.upper - v_adjustment.page_size
                 v_adjustment.value = new_value
-        elif scrolltype == Gtk.ScrollType.START:
+        elif scrolltype == gtk.SCROLL_START:
             self.set_current_page(0)
-        elif scrolltype == Gtk.ScrollType.END:
+        elif scrolltype == gtk.SCROLL_END:
             self.set_current_page(self._pagecount - 1)
 
     def previous_page(self):
@@ -282,7 +278,7 @@ class TextViewer(GObject.GObject):
         pass
 
     def copy(self):
-        self.textview.get_buffer().copy_clipboard(Gtk.Clipboard())
+        self.textview.get_buffer().copy_clipboard(gtk.Clipboard())
 
     def update_view_size(self, _scrolled):
         pass
@@ -319,7 +315,7 @@ class TextViewer(GObject.GObject):
     def _show_found_text(self, founded_tuple):
         textbuffer = self.textview.get_buffer()
         tag = textbuffer.create_tag()
-        tag.set_property('weight', Pango.Weight.BOLD)
+        tag.set_property('weight', pango.WEIGHT_BOLD)
         tag.set_property('foreground', 'white')
         tag.set_property('background', 'black')
         iterStart = textbuffer.get_iter_at_offset(founded_tuple[1])
@@ -372,16 +368,16 @@ class TextViewer(GObject.GObject):
         return False
 
 
-class _JobFind(GObject.GObject):
+class _JobFind(gobject.GObject):
 
     __gsignals__ = {
-        'updated': (GObject.SignalFlags.RUN_FIRST, GObject.TYPE_NONE, ([])),
+        'updated': (gobject.SIGNAL_RUN_FIRST, gobject.TYPE_NONE, ([])),
     }
 
     def __init__(self, text_file, start_page, n_pages, text, \
                 case_sensitive=False):
-        GObject.GObject.__init__(self)
-        Gtk.gdk.threads_init()
+        gobject.GObject.__init__(self)
+        gtk.gdk.threads_init()
 
         self._finished = False
         self._text_file = text_file
@@ -471,10 +467,10 @@ class _SearchThread(threading.Thread):
                     self._found_records[self._current_found_item]
             self._page = self.current_found_tuple[0]
 
-        Gtk.gdk.threads_enter()
+        gtk.gdk.threads_enter()
         self.obj._finished = True
         self.obj.emit('updated')
-        Gtk.gdk.threads_leave()
+        gtk.gdk.threads_leave()
 
         return False