PyGI changes

12 files changed, 244 insertions, 244 deletions

diff --git a/JokeMachineActivity.py b/JokeMachineActivity.py
index e9b716f..bd33fa4 100644
--- a/JokeMachineActivity.py
+++ b/JokeMachineActivity.py
@@ -31,7 +31,7 @@ from gettext import gettext as _
 import gettext
 import locale
 
-import hippo
+from gi.repository import Hippo
 from sugar3.activity import activity
 
 from globals import Globals
@@ -92,7 +92,7 @@ class JokeMachineActivity(activity.Activity):
     if os.path.exists(Gtkrc):
       logging.debug("Loading resources from %s" % Gtkrc)
       Gtk.rc_add_default_file(Gtkrc)
-      settings = Gtk.settings_get_default()
+      settings = Gtk.Settings.get_default()
       #Gtk.rc_reset_styles(settings)
       Gtk.rc_reparse_all_for_settings(settings, True)
       logging.debug("Loading resources DONE")
@@ -108,7 +108,7 @@ class JokeMachineActivity(activity.Activity):
     # main activity frame
     self.__activity_frame = Frame()
     vbox = Gtk.VBox()
-    vbox.pack_start(self.__activity_frame)
+    vbox.pack_start(self.__activity_frame, True, True, 0)
     vbox.show()
     self.set_canvas(vbox)
     self.show_all()
diff --git a/gui/canvaslistbox.py b/gui/canvaslistbox.py
index 5058ec8..503f708 100644
--- a/gui/canvaslistbox.py
+++ b/gui/canvaslistbox.py
@@ -19,7 +19,7 @@
 #
 import gi
 from gi.repository import Gtk
-import hippo
+from gi.repository import Hippo
 
 from sugar3.graphics import style
 
@@ -28,36 +28,36 @@ from gui import page
 
 
 # TODO- height seems bust
-class CanvasListBox(hippo.CanvasWidget):
+class CanvasListBox(Hippo.CanvasWidget):
   def __init__(self):
-    self._entries_div = hippo.CanvasBox() 
+    self._entries_div = Hippo.CanvasBox() 
 
     # props not set properly in constructor
     self._entries_div.props.background_color=theme.COLOR_PAGE.get_int() 
     self._entries_div.props.spacing=style.DEFAULT_SPACING    
     self._entries_div.props.padding=10
-    self._entries_div.props.orientation=hippo.ORIENTATION_VERTICAL    
+    self._entries_div.props.orientation=Hippo.Orientation.VERTICAL    
 
     # Munge it all up into something we can stick into a Gtk.ScrolledWindow
-    canvas = hippo.Canvas() 
+    canvas = Hippo.Canvas() 
     canvas.set_root(self._entries_div)
     canvas.show()
     
     hbox = Gtk.HBox()
     hbox.set_flags(Gtk.HAS_FOCUS | Gtk.CAN_FOCUS)
-    hbox.pack_start(canvas)
+    hbox.pack_start(canvas, True, True, 0)
     hbox.show()
 
     scroller = Gtk.ScrolledWindow()
-    scroller.set_policy(Gtk.POLICY_NEVER, Gtk.POLICY_AUTOMATIC)
+    scroller.set_policy(Gtk.PolicyType.NEVER, Gtk.PolicyType.AUTOMATIC)
     viewport = Gtk.Viewport()
-    viewport.set_shadow_type(Gtk.SHADOW_NONE) 
+    viewport.set_shadow_type(Gtk.ShadowType.NONE) 
     viewport.add(hbox)
     viewport.show()
     scroller.add(viewport)
     scroller.show()
 
-    hippo.CanvasWidget.__init__(self, 
+    gobject.GObject.__init__(self, 
                                 widget=scroller, 
                                 padding=0, 
                                 spacing=0,
diff --git a/gui/frame.py b/gui/frame.py
index 365797a..d76429b 100644
--- a/gui/frame.py
+++ b/gui/frame.py
@@ -20,7 +20,7 @@
 import gi
 from gi.repository import GObject
 from gi.repository import Gtk
-import hippo
+from gi.repository import Hippo
 import logging
 
 from gettext import gettext as _
@@ -36,15 +36,15 @@ import pages.edit
 from persistence.jokebook import Jokebook
 from gui.lessonplanwidget import LessonPlanWidget
 
-class Frame(hippo.Canvas):
+class Frame(Hippo.Canvas):
   
   def __init__(self):
-    hippo.Canvas.__init__(self)
+    gobject.GObject.__init__(self)
     
     # Root Frame ###############################################################
     # Holds: Everything
-    self.__root = hippo.CanvasBox(
-      orientation=hippo.ORIENTATION_VERTICAL)
+    self.__root = Hippo.CanvasBox(
+      orientation=Hippo.Orientation.VERTICAL)
     self.set_root(self.__root)
     
     # Application Header #######################################################
@@ -54,7 +54,7 @@ class Frame(hippo.Canvas):
     
     # Page Container ###########################################################
     # Holds: The currently open UI page
-    self.__container = hippo.CanvasBox(border=theme.BORDER_WIDTH,
+    self.__container = Hippo.CanvasBox(border=theme.BORDER_WIDTH,
                                        border_color=theme.COLOR_FRAME.get_int(),
                                        background_color=theme.COLOR_BACKGROUND.get_int(),
                                        spacing=4,
@@ -62,16 +62,16 @@ class Frame(hippo.Canvas):
                                        padding_left=40, 
                                        padding_right=40,
                                        padding_bottom=20,
-                                       orientation=hippo.ORIENTATION_VERTICAL)
-    self.__root.append(self.__container, hippo.PACK_EXPAND)
+                                       orientation=Hippo.Orientation.VERTICAL)
+    self.__root.append(self.__container, Hippo.PackFlags.EXPAND)
     
-    self.__page = hippo.CanvasBox(background_color=theme.COLOR_PAGE.get_int(),
+    self.__page = Hippo.CanvasBox(background_color=theme.COLOR_PAGE.get_int(),
                                   border=4,
                                   border_color=theme.COLOR_PAGE_BORDER.get_int(), 
                                   spacing=8,      
                                   padding=20,
-                                  orientation=hippo.ORIENTATION_VERTICAL)
-    self.__container.append(self.__page, hippo.PACK_EXPAND)
+                                  orientation=Hippo.Orientation.VERTICAL)
+    self.__container.append(self.__page, Hippo.PackFlags.EXPAND)
     
     self.__page_class = None
     
@@ -83,16 +83,16 @@ class Frame(hippo.Canvas):
 
 
   def __make_header(self):
-    ret = hippo.CanvasBox(
-      orientation=hippo.ORIENTATION_HORIZONTAL)
+    ret = Hippo.CanvasBox(
+      orientation=Hippo.Orientation.HORIZONTAL)
     
     # logo
     logo = Gtk.Image()
     logo.set_from_file(Globals.logo)
-    ret.append(hippo.CanvasWidget(widget=logo))
+    ret.append(Hippo.CanvasWidget(widget=logo))
     
     # lesson plans
-    lesson_plans =  hippo.CanvasWidget(background_color=theme.COLOR_BACKGROUND.get_int(),
+    lesson_plans =  Hippo.CanvasWidget(background_color=theme.COLOR_BACKGROUND.get_int(),
                                       border_top=theme.BORDER_WIDTH,
                                       border_left=theme.BORDER_WIDTH, 
                                       border_right=theme.BORDER_WIDTH, 
@@ -101,33 +101,33 @@ class Frame(hippo.Canvas):
                                       padding_bottom=12,
                                       padding_left=30, 
                                       padding_right=30,
-                                      yalign=hippo.ALIGNMENT_CENTER,
-                                      orientation=hippo.ORIENTATION_VERTICAL)
+                                      yalign=Hippo.ALIGNMENT_CENTER,
+                                      orientation=Hippo.Orientation.VERTICAL)
     button = Gtk.Button(_('Lesson Plans'))
     button.set_size_request(200, -1)
     button.active = False
     button.connect('clicked', self.__do_clicked_lessonplans)
     lesson_plans.props.widget = theme.theme_widget(button)
-    ret.append(lesson_plans, hippo.PACK_EXPAND)
+    ret.append(lesson_plans, Hippo.PackFlags.EXPAND)
     
     return ret
   
   
   
   def __make_footer(self):
-    ret = hippo.CanvasBox(
+    ret = Hippo.CanvasBox(
       padding_right=8,
       padding_top=8,
       padding_bottom=0,
       spacing=8,
-      orientation=hippo.ORIENTATION_HORIZONTAL)
+      orientation=Hippo.Orientation.HORIZONTAL)
     button = Gtk.Button(_('Read Jokebooks'))
     button.connect('clicked', self.__do_clicked_read)
-    self.__button_read = hippo.CanvasWidget(widget=theme.theme_widget(button))
+    self.__button_read = Hippo.CanvasWidget(widget=theme.theme_widget(button))
     ret.append(self.__button_read)
     button = Gtk.Button(_('Make Jokebook'))
     button.connect('clicked', self.__do_clicked_make)
-    self.__button_make = hippo.CanvasWidget(widget=theme.theme_widget(button))
+    self.__button_make = Hippo.CanvasWidget(widget=theme.theme_widget(button))
     ret.append(self.__button_make)
     return ret
  
@@ -148,7 +148,7 @@ class Frame(hippo.Canvas):
     def set(self, value): 
       self.__page_class = type(value)
       self.__page.clear()
-      self.__page.append(value, hippo.PACK_EXPAND)
+      self.__page.append(value, Hippo.PackFlags.EXPAND)
 
       # some rules for the buttons in the footer
       if not Globals.JokeMachineActivity.is_initiator \
@@ -196,16 +196,16 @@ class Frame(hippo.Canvas):
     else:
       button.set_label(_('Close Lessons'))
       button.active = True
-      widget_box = hippo.CanvasBox(border=0,
+      widget_box = Hippo.CanvasBox(border=0,
                                    border_color=theme.COLOR_BLUE.get_int())
-      widget_box.append(hippo.CanvasText(text= _('Lesson Plans:'),
-                                         xalign=hippo.ALIGNMENT_START,
+      widget_box.append(Hippo.CanvasText(text= _('Lesson Plans:'),
+                                         xalign=Hippo.ALIGNMENT_START,
                                          padding=10))
       lesson_plans = LessonPlanWidget(Globals.pwd)
-      widget_box.append(hippo.CanvasWidget(widget=lesson_plans,
+      widget_box.append(Hippo.CanvasWidget(widget=lesson_plans,
                                            border=0,
                                            border_color=theme.COLOR_DARK_GREEN.get_int()),
-                                           hippo.PACK_EXPAND)
+                                           Hippo.PackFlags.EXPAND)
       self.page = widget_box
       self.__button_read.set_visible(False)
       self.__button_make.set_visible(False)            
diff --git a/gui/lessonplanwidget.py b/gui/lessonplanwidget.py
index 2b97a18..bebcdb6 100644
--- a/gui/lessonplanwidget.py
+++ b/gui/lessonplanwidget.py
@@ -68,6 +68,6 @@ class LessonPlanWidget(Gtk.Notebook):
     canvas.view_online_layout()
     canvas.zoom_width()
     canvas.set_show_margin(False)
-    self.append_page(canvas, Gtk.Label(name))
+    self.append_page(canvas, Gtk.Label(label=name))
     
     
diff --git a/gui/page.py b/gui/page.py
index 183a9af..bee9131 100644
--- a/gui/page.py
+++ b/gui/page.py
@@ -21,8 +21,8 @@ import gi
 import os
 from gi.repository import Gtk
 import cairo # for getting png for CanvasImage
-import pango
-import hippo
+from gi.repository import Pango
+from gi.repository import Hippo
 import logging
 import StringIO
 
@@ -51,20 +51,20 @@ from gui import theme
 from globals import Globals
 
 
-THUMB_SIZE = min(Gtk.gdk.screen_width(), Gtk.gdk.screen_height()) / 2
+THUMB_SIZE = min(Gdk.Screen.width(), Gdk.Screen.height()) / 2
 
 
-class Page(hippo.CanvasBox):
+class Page(Hippo.CanvasBox):
 
   def __init__(self, **kwargs):
-    hippo.CanvasBox.__init__(self, **kwargs)
+    gobject.GObject.__init__(self, **kwargs)
     
     self.__alternate_color_listrows = False
     self.__color_listrow = theme.COLOR_LIST_ROW_ALT.get_int()
     
   
   def append(self, item, *args, **kwargs):
-    hippo.CanvasBox.append(self, item, *args, **kwargs)
+    Hippo.CanvasBox.append(self, item, *args, **kwargs)
     
     
   @property
@@ -94,12 +94,12 @@ class Page(hippo.CanvasBox):
     image_file = os.path.join(Globals.pwd, theme.AUDIO_CHOOSE)
     if not os.path.exists(image_file):
       logging.debug('cannot find %s' % image_file)
-      return hippo.CanvasBox()
+      return Hippo.CanvasBox()
     
     surface = cairo.ImageSurface.create_from_png(image_file)
-    preview_sound = hippo.CanvasImage(image=surface,
-                                      xalign=hippo.ALIGNMENT_START,
-                                      yalign=hippo.ALIGNMENT_CENTER)
+    preview_sound = Hippo.CanvasImage(image=surface,
+                                      xalign=Hippo.ALIGNMENT_START,
+                                      yalign=Hippo.ALIGNMENT_CENTER)
     preview_sound.connect('button-press-event', self.__do_clicked_preview_sound, obj, property)
     
     if hasattr(obj, property) and getattr(obj, property) != None:
@@ -107,8 +107,8 @@ class Page(hippo.CanvasBox):
     else:
       sound_name = _('Click to choose a sound')
     
-    choose_sound = hippo.CanvasText(text=sound_name, 
-                                    xalign=hippo.ALIGNMENT_START)
+    choose_sound = Hippo.CanvasText(text=sound_name, 
+                                    xalign=Hippo.ALIGNMENT_START)
     choose_sound.connect('button-press-event', self.__do_clicked_choose_sound, obj, property)
     
     sound_box = RoundBox()
@@ -118,13 +118,13 @@ class Page(hippo.CanvasBox):
     sound_box.props.border=theme.BORDER_WIDTH_CONTROL / 2
     sound_box.props.border_color=theme.COLOR_DARK_GREEN.get_int()
     sound_box.props.background_color = theme.COLOR_WHITE.get_int()
-    sound_box.props.orientation=hippo.ORIENTATION_HORIZONTAL
-    sound_box.props.xalign=hippo.ALIGNMENT_START
+    sound_box.props.orientation=Hippo.Orientation.HORIZONTAL
+    sound_box.props.xalign=Hippo.ALIGNMENT_START
     sound_box.set_clickable(True)
     sound_box.append(preview_sound)
     sound_box.append(choose_sound)
     
-    deglitch_box = hippo.CanvasBox(xalign=hippo.ALIGNMENT_START, box_width=width)
+    deglitch_box = Hippo.CanvasBox(xalign=Hippo.ALIGNMENT_START, box_width=width)
     deglitch_box.append(sound_box)
     return deglitch_box
     
@@ -155,11 +155,11 @@ class Page(hippo.CanvasBox):
       border_width = theme.BORDER_WIDTH_IMAGE
       
     # the image itself
-    cover_image = hippo.CanvasImage(image=surface,
+    cover_image = Hippo.CanvasImage(image=surface,
                                     border=border_width,
                                     border_color=theme.COLOR_BLACK.get_int(),
-                                    xalign=hippo.ALIGNMENT_CENTER,
-                                    yalign=hippo.ALIGNMENT_CENTER,
+                                    xalign=Hippo.ALIGNMENT_CENTER,
+                                    yalign=Hippo.ALIGNMENT_CENTER,
                                     scale_width=width,
                                     scale_height=height)
     if editable:
@@ -176,14 +176,14 @@ class Page(hippo.CanvasBox):
       
     # Grrr... RoundedBoxes and CanvasImages expand their width to their parent
     # unless they're in a CanvasBox
-    deglitch_box = hippo.CanvasBox(xalign=hippo.ALIGNMENT_CENTER, padding=padding)
+    deglitch_box = Hippo.CanvasBox(xalign=Hippo.ALIGNMENT_CENTER, padding=padding)
     deglitch_box.append(image_box)
     return deglitch_box
   
 
-  def make_bodytext(self, text, width=-1, xalign = hippo.ALIGNMENT_START, text_color = theme.COLOR_BLACK):
-    return hippo.CanvasText(text=text,
-                            size_mode=hippo.CANVAS_SIZE_WRAP_WORD,
+  def make_bodytext(self, text, width=-1, xalign = Hippo.ALIGNMENT_START, text_color = theme.COLOR_BLACK):
+    return Hippo.CanvasText(text=text,
+                            size_mode=Hippo.CANVAS_SIZE_WRAP_WORD,
                             box_width=width,
                             xalign=xalign,
                             color=text_color.get_int())
@@ -198,12 +198,12 @@ class Page(hippo.CanvasBox):
  
   def make_field(self, label, label_width, obj, property, field_width, editable=True):
     value = self.__get_property_value(obj, property)
-    field_box = hippo.CanvasBox(orientation=hippo.ORIENTATION_HORIZONTAL,
-                                xalign=hippo.ALIGNMENT_START,
+    field_box = Hippo.CanvasBox(orientation=Hippo.Orientation.HORIZONTAL,
+                                xalign=Hippo.ALIGNMENT_START,
                                 spacing=10)
-    field_box.append(hippo.CanvasText(text=label,
+    field_box.append(Hippo.CanvasText(text=label,
                                       box_width=label_width,
-                                      xalign=hippo.ALIGNMENT_START,
+                                      xalign=Hippo.ALIGNMENT_START,
                                       color=theme.COLOR_DARK_GREEN.get_int()))
     #if editable:
     textfield = self.__textview(value, field_width, -1, editable, False) 
@@ -211,10 +211,10 @@ class Page(hippo.CanvasBox):
     field_box.append(textfield)
     #else: # TODO - move to __textview()
       #glitch_box = CanvasBox(box_width=field_width)
-      #glitch_box.append(hippo.CanvasText(text=value,
-                                        #size_mode=hippo.CANVAS_SIZE_WRAP_WORD,
+      #glitch_box.append(Hippo.CanvasText(text=value,
+                                        #size_mode=Hippo.CANVAS_SIZE_WRAP_WORD,
                                         #box_width=field_width,
-                                        #xalign=hippo.ALIGNMENT_START))
+                                        #xalign=Hippo.ALIGNMENT_START))
       #field_box.append(glitch_box)
     return field_box
 
@@ -227,21 +227,21 @@ class Page(hippo.CanvasBox):
     textview.get_buffer().set_text(text)
 
     # control props
-    textview.set_wrap_mode(Gtk.WRAP_WORD)
-    textview.modify_base(Gtk.STATE_NORMAL, theme.COLOR_TEXTBOX.get_gdk_color())
+    textview.set_wrap_mode(Gtk.WrapMode.WORD)
+    textview.modify_base(Gtk.StateType.NORMAL, theme.COLOR_TEXTBOX.get_gdk_color())
     textview.set_editable(editable)
     textview.set_cursor_visible(editable)
     if height == -1:
       context = textview.create_pango_context()
-      layout = pango.Layout(context)
+      layout = Pango.Layout(context)
       layout.set_text(text[ : text.find('\n')])
       (w, h) = layout.get_pixel_size()
       height = h #+ theme.BORDER_WIDTH_CONTROL / 2 # fudge factor - on the XO-1 hardware all known solutions evaporate
     textview.set_size_request(width, height)
-    textview.set_border_window_size(Gtk.TEXT_WINDOW_LEFT, 0)
-    textview.set_border_window_size(Gtk.TEXT_WINDOW_RIGHT, 0)
-    textview.set_border_window_size(Gtk.TEXT_WINDOW_TOP, 0)
-    textview.set_border_window_size(Gtk.TEXT_WINDOW_BOTTOM, 0)
+    textview.set_border_window_size(Gtk.TextWindowType.LEFT, 0)
+    textview.set_border_window_size(Gtk.TextWindowType.RIGHT, 0)
+    textview.set_border_window_size(Gtk.TextWindowType.TOP, 0)
+    textview.set_border_window_size(Gtk.TextWindowType.BOTTOM, 0)
     textview.show()
     
     if editable: # because rounded corners are well... pretty
@@ -252,18 +252,18 @@ class Page(hippo.CanvasBox):
       border_box.props.border=theme.BORDER_WIDTH_CONTROL / 2
       border_box.props.border_color=theme.COLOR_DARK_GREEN.get_int()
       border_box.props.background_color=theme.COLOR_TEXTBOX.get_int()
-      border_box.props.xalign=hippo.ALIGNMENT_START
+      border_box.props.xalign=Hippo.ALIGNMENT_START
       #border_box.props.box_width = width
       #border_box.props.box_height = height
       
       # TODO - File bug: RoundBox seriously messes with TextView's 
       #                  (and other things) width !!
-      deglitch_box = hippo.CanvasBox() 
-      deglitch_box.append(hippo.CanvasWidget(widget=textview))
+      deglitch_box = Hippo.CanvasBox() 
+      deglitch_box.append(Hippo.CanvasWidget(widget=textview))
       border_box.append(deglitch_box)
       return border_box
 
-    no_edit_box = hippo.CanvasWidget(widget=textview)
+    no_edit_box = Hippo.CanvasWidget(widget=textview)
     no_edit_box.control = textview
     return no_edit_box
 
@@ -301,11 +301,11 @@ class Page(hippo.CanvasBox):
     # Courtesy of Write.activity - toolbar.py
     chooser = ObjectChooser(title=_('Choose image'), 
                             parent=Globals.JokeMachineActivity, #._parent,
-                            flags=Gtk.DIALOG_MODAL | Gtk.DIALOG_DESTROY_WITH_PARENT,
+                            flags=Gtk.DialogFlags.MODAL | Gtk.DialogFlags.DESTROY_WITH_PARENT,
                             **filter)
     try:
       result = chooser.run()
-      if result == Gtk.RESPONSE_ACCEPT:
+      if result == Gtk.ResponseType.ACCEPT:
         logging.debug('ObjectChooser: %r' % chooser.get_selected_object())
         journal_object = chooser.get_selected_object()
         if hasattr(obj, 'image_blob') and journal_object and journal_object.file_path:
@@ -333,11 +333,11 @@ class Page(hippo.CanvasBox):
     logging.debug('choosing sound file') 
     chooser = ObjectChooser(title=_('Choose Sound'), 
                             parent=Globals.JokeMachineActivity, #._parent,
-                            flags=Gtk.DIALOG_MODAL | Gtk.DIALOG_DESTROY_WITH_PARENT,
+                            flags=Gtk.DialogFlags.MODAL | Gtk.DialogFlags.DESTROY_WITH_PARENT,
                             **filter)
     try:
       result = chooser.run()
-      if result == Gtk.RESPONSE_ACCEPT:
+      if result == Gtk.ResponseType.ACCEPT:
         logging.debug('ObjectChooser: %r' % chooser.get_selected_object())
         journal_object = chooser.get_selected_object()
         if hasattr(obj, 'sound_blob') and journal_object and journal_object.file_path:
@@ -367,7 +367,7 @@ class Page(hippo.CanvasBox):
     player.play()
 
 def _load_image(file_name):
-    pixbuf = Gtk.gdk.pixbuf_new_from_file_at_size(file_name,
+    pixbuf = GdkPixbuf.Pixbuf.new_from_file_at_size(file_name,
             THUMB_SIZE, THUMB_SIZE)
     if pixbuf is None:
         return None
diff --git a/gui/theme.py b/gui/theme.py
index fcf018c..b52aa46 100644
--- a/gui/theme.py
+++ b/gui/theme.py
@@ -47,32 +47,32 @@ COLOR_TEXT_FIELD_GREY = style.Color('#E5E5E5')
 
 
 COLOR_FG_BUTTONS = (
-  (Gtk.STATE_NORMAL,      style.Color('#CCFF99')),
-  (Gtk.STATE_ACTIVE,      style.Color('#CCFF99')),
-  (Gtk.STATE_PRELIGHT,    style.Color('#CCFF99')),
-  (Gtk.STATE_SELECTED,    style.Color('#CCFF99')),
-  (Gtk.STATE_INSENSITIVE, style.Color('#CCFF99')),
+  (Gtk.StateType.NORMAL,      style.Color('#CCFF99')),
+  (Gtk.StateType.ACTIVE,      style.Color('#CCFF99')),
+  (Gtk.StateType.PRELIGHT,    style.Color('#CCFF99')),
+  (Gtk.StateType.SELECTED,    style.Color('#CCFF99')),
+  (Gtk.StateType.INSENSITIVE, style.Color('#CCFF99')),
 )
 COLOR_BG_BUTTONS = (
-  (Gtk.STATE_NORMAL,      style.Color('#027F01')),
-  (Gtk.STATE_ACTIVE,      style.Color('#014D01')),
-  (Gtk.STATE_PRELIGHT,    style.Color('#016D01')),
-  (Gtk.STATE_SELECTED,    style.Color('#027F01')),
-  (Gtk.STATE_INSENSITIVE, style.Color('#027F01')),
+  (Gtk.StateType.NORMAL,      style.Color('#027F01')),
+  (Gtk.StateType.ACTIVE,      style.Color('#014D01')),
+  (Gtk.StateType.PRELIGHT,    style.Color('#016D01')),
+  (Gtk.StateType.SELECTED,    style.Color('#027F01')),
+  (Gtk.StateType.INSENSITIVE, style.Color('#027F01')),
 )
 COLOR_BG_RADIOBUTTONS = (
-  (Gtk.STATE_NORMAL,      COLOR_LIGHT_GRAY),
-  (Gtk.STATE_ACTIVE,      COLOR_LIGHT_GRAY),
-  (Gtk.STATE_PRELIGHT,    COLOR_LIGHT_GRAY),
-  (Gtk.STATE_SELECTED,    COLOR_LIGHT_GRAY),
-  (Gtk.STATE_INSENSITIVE, COLOR_LIGHT_GRAY),
+  (Gtk.StateType.NORMAL,      COLOR_LIGHT_GRAY),
+  (Gtk.StateType.ACTIVE,      COLOR_LIGHT_GRAY),
+  (Gtk.StateType.PRELIGHT,    COLOR_LIGHT_GRAY),
+  (Gtk.StateType.SELECTED,    COLOR_LIGHT_GRAY),
+  (Gtk.StateType.INSENSITIVE, COLOR_LIGHT_GRAY),
 )
 COLOR_FG_RADIOBUTTONS = (
-  (Gtk.STATE_NORMAL,      COLOR_DARK_GREEN),
-  (Gtk.STATE_ACTIVE,      COLOR_DARK_GREEN),
-  (Gtk.STATE_PRELIGHT,    COLOR_DARK_GREEN),
-  (Gtk.STATE_SELECTED,    COLOR_DARK_GREEN),
-  (Gtk.STATE_INSENSITIVE, COLOR_DARK_GREEN),
+  (Gtk.StateType.NORMAL,      COLOR_DARK_GREEN),
+  (Gtk.StateType.ACTIVE,      COLOR_DARK_GREEN),
+  (Gtk.StateType.PRELIGHT,    COLOR_DARK_GREEN),
+  (Gtk.StateType.SELECTED,    COLOR_DARK_GREEN),
+  (Gtk.StateType.INSENSITIVE, COLOR_DARK_GREEN),
 )
 
 
@@ -135,7 +135,7 @@ def theme_widget(widget, width=-1, height=-1, highlight=False):
 
   #for state, color in COLOR_BG_BUTTONS:
     #if highlight:
-      #widget.modify_bg(state, Gtk.gdk.color_parse("#CCFF99"))
+      #widget.modify_bg(state, Gdk.color_parse("#CCFF99"))
     #else:
       #widget.modify_bg(state, color.get_gdk_color())
 
diff --git a/pages/choose.py b/pages/choose.py
index 96120c5..e78953e 100644
--- a/pages/choose.py
+++ b/pages/choose.py
@@ -20,8 +20,8 @@
 import gi
 import os
 from gi.repository import Gtk
-import hippo
-import pango
+from gi.repository import Hippo
+from gi.repository import Pango
 import logging
 from gettext import gettext as _
 
@@ -43,8 +43,8 @@ class Choose(Page):
     Page.__init__(self)
 
     # page title
-    self.append(hippo.CanvasText(text= _('Choose a Jokebook to read:'),
-                                 xalign=hippo.ALIGNMENT_START,
+    self.append(Hippo.CanvasText(text= _('Choose a Jokebook to read:'),
+                                 xalign=Hippo.ALIGNMENT_START,
                                  padding=10))
     
     # list of Jokebooks 
@@ -52,7 +52,7 @@ class Choose(Page):
     jokebooks_div = CanvasListBox()
     for jokebook in Globals.JokeMachineState.jokebooks:
       jokebooks_div.append(self.__make_jokebook_div(jokebook, allow_edit))
-    self.append(jokebooks_div, hippo.PACK_EXPAND) 
+    self.append(jokebooks_div, Hippo.PackFlags.EXPAND) 
 
 
   def __do_clicked_title(self, control, event, jokebook):
@@ -69,15 +69,15 @@ class Choose(Page):
       message += '\'' + jokebook.title + '\' ' 
     message += _('jokebook ?')
     confirm = Gtk.MessageDialog(Globals.JokeMachineActivity, 
-                                Gtk.DIALOG_MODAL | Gtk.DIALOG_DESTROY_WITH_PARENT,
-                                Gtk.MESSAGE_QUESTION,
-                                Gtk.BUTTONS_YES_NO,
+                                Gtk.DialogFlags.MODAL | Gtk.DialogFlags.DESTROY_WITH_PARENT,
+                                Gtk.MessageType.QUESTION,
+                                Gtk.ButtonsType.YES_NO,
                                 message)
     response = confirm.run()
     confirm.hide()
     confirm.destroy()
     del confirm
-    if response == Gtk.RESPONSE_YES:
+    if response == Gtk.ResponseType.YES:
       logging.debug('Deleting jokebook: %s' % jokebook.title)
       Globals.JokeMachineState.jokebooks.remove(jokebook)
       Globals.JokeMachineActivity.set_page(pages.choose.Choose)
@@ -91,35 +91,35 @@ class Choose(Page):
     list_row.append(self.__make_column_div(100, thumbnail))
 
     # title
-    title = hippo.CanvasText(
+    title = Hippo.CanvasText(
             text = (jokebook.title or '')+ "\n" + (jokebook.owner or ''), 
                              padding_left = 20,                             
-                             xalign=hippo.ALIGNMENT_START,
+                             xalign=Hippo.ALIGNMENT_START,
                              color=theme.COLOR_LINK.get_int())
     title.set_clickable(True)
     title.connect('button-press-event', self.__do_clicked_title, jokebook)    
-    list_row.append(self.__make_column_div(-1, title), hippo.PACK_EXPAND) 
+    list_row.append(self.__make_column_div(-1, title), Hippo.PackFlags.EXPAND) 
     
-    list_row.append(hippo.CanvasBox(box_width=theme.SPACER_HORIZONTAL)) # TODO spacer    
+    list_row.append(Hippo.CanvasBox(box_width=theme.SPACER_HORIZONTAL)) # TODO spacer    
     
     # buttons
     if edit:
       button = Gtk.Button(_('Edit'))
       button.connect('clicked', self.__do_clicked_edit, jokebook)
-      list_row.append(self.__make_column_div(100, hippo.CanvasWidget(widget=theme.theme_widget(button))))
-      list_row.append(hippo.CanvasBox(box_width=theme.SPACER_HORIZONTAL)) # TODO spacer
+      list_row.append(self.__make_column_div(100, Hippo.CanvasWidget(widget=theme.theme_widget(button))))
+      list_row.append(Hippo.CanvasBox(box_width=theme.SPACER_HORIZONTAL)) # TODO spacer
       button = Gtk.Button(_('Delete'))
       button.connect('clicked', self.__do_clicked_delete, jokebook)
-      list_row.append(self.__make_column_div(100, hippo.CanvasWidget(widget=theme.theme_widget(button))))
-      list_row.append(hippo.CanvasBox(box_width=theme.SPACER_HORIZONTAL)) # TODO spacer    
+      list_row.append(self.__make_column_div(100, Hippo.CanvasWidget(widget=theme.theme_widget(button))))
+      list_row.append(Hippo.CanvasBox(box_width=theme.SPACER_HORIZONTAL)) # TODO spacer    
 
     return list_row
 
 
   def __make_column_div(self, width, content):
-    ret = hippo.CanvasBox(
+    ret = Hippo.CanvasBox(
       box_width=width,
-      yalign=hippo.ALIGNMENT_CENTER) 
+      yalign=Hippo.ALIGNMENT_CENTER) 
     ret.append(content)
     return ret
 
diff --git a/pages/cover.py b/pages/cover.py
index f74e7f9..c5e156b 100644
--- a/pages/cover.py
+++ b/pages/cover.py
@@ -20,8 +20,8 @@
 import gi
 import os
 from gi.repository import Gtk
-import hippo
-import pango
+from gi.repository import Hippo
+from gi.repository import Pango
 import logging
 from gettext import gettext as _
 
@@ -38,22 +38,22 @@ class Cover(Page):
     Page.__init__(self)
 
     # title
-    self.append(hippo.CanvasText(text='"' + (jokebook.title or '') + '" ' +
+    self.append(Hippo.CanvasText(text='"' + (jokebook.title or '') + '" ' +
         _('started by') + ' ' + (jokebook.owner or ''),
-                                 xalign=hippo.ALIGNMENT_CENTER,
+                                 xalign=Hippo.ALIGNMENT_CENTER,
                                  padding_top=10))
-    self.append(hippo.CanvasBox(box_height=theme.SPACER_VERTICAL))      
+    self.append(Hippo.CanvasBox(box_height=theme.SPACER_VERTICAL))      
 
     # cover picture 
     cover_picture = self.make_imagebox(jokebook, 'image', 480, 360, False)    
-    self.append(cover_picture, hippo.PACK_EXPAND)
-    self.append(hippo.CanvasBox(box_height=theme.SPACER_VERTICAL))
+    self.append(cover_picture, Hippo.PackFlags.EXPAND)
+    self.append(Hippo.CanvasBox(box_height=theme.SPACER_VERTICAL))
     
     # open button 
     button = Gtk.Button(_('Open'))
     button.connect('clicked', self.__do_clicked_open, jokebook)
     button.set_size_request(50, -1)
-    self.append(hippo.CanvasWidget(widget=theme.theme_widget(button),
+    self.append(Hippo.CanvasWidget(widget=theme.theme_widget(button),
                                    box_width=50))
 
   
diff --git a/pages/edit.py b/pages/edit.py
index 24bd781..b960c5d 100644
--- a/pages/edit.py
+++ b/pages/edit.py
@@ -21,8 +21,8 @@
 import gi
 import os
 from gi.repository import Gtk
-import hippo
-import pango
+from gi.repository import Hippo
+from gi.repository import Pango
 import logging
 from gettext import gettext as _
 
@@ -42,49 +42,49 @@ import persistence.joke
 
 
 
-class PageSelector(hippo.CanvasBox):
+class PageSelector(Hippo.CanvasBox):
   
   def __init__(self, parent, **kwargs):
-    hippo.CanvasBox.__init__(self, **kwargs)
+    gobject.GObject.__init__(self, **kwargs)
     self.__parent = parent
 
     self.props.border = 1
     self.props.border_color=theme.COLOR_TAB_ACTIVE.get_int()
     self.props.background_color=theme.COLOR_PAGE.get_int()
-    self.props.orientation=hippo.ORIENTATION_VERTICAL
+    self.props.orientation=Hippo.Orientation.VERTICAL
     
-    tab_box = hippo.CanvasBox(background_color=theme.COLOR_TAB_SEPERATOR.get_int(),
+    tab_box = Hippo.CanvasBox(background_color=theme.COLOR_TAB_SEPERATOR.get_int(),
                                  spacing=2,
-                                 orientation=hippo.ORIENTATION_HORIZONTAL)
-    self.__tab_1 = hippo.CanvasText(text=_('Edit Jokebook Cover'),
+                                 orientation=Hippo.Orientation.HORIZONTAL)
+    self.__tab_1 = Hippo.CanvasText(text=_('Edit Jokebook Cover'),
                                 padding=theme.PADDING_TAB,
-                                xalign=hippo.ALIGNMENT_START,
+                                xalign=Hippo.ALIGNMENT_START,
                                 background_color=theme.COLOR_TAB_ACTIVE.get_int(),
                                 color=theme.COLOR_TAB_TEXT.get_int())
     self.__tab_1.page = EditInfo
     self.__tab_1.connect('button-press-event', self.__do_clicked_tab)    
-    tab_box.append(self.__tab_1, hippo.PACK_EXPAND)
-    self.__tab_2 = hippo.CanvasText(text=_('Edit My Jokes'),
+    tab_box.append(self.__tab_1, Hippo.PackFlags.EXPAND)
+    self.__tab_2 = Hippo.CanvasText(text=_('Edit My Jokes'),
                                 padding=theme.PADDING_TAB,
-                                xalign=hippo.ALIGNMENT_START,
+                                xalign=Hippo.ALIGNMENT_START,
                                 background_color=theme.COLOR_TAB_INACTIVE.get_int(),
                                 color=theme.COLOR_TAB_TEXT.get_int())
     self.__tab_2.page = EditJokes
     self.__tab_2.connect('button-press-event', self.__do_clicked_tab)    
-    tab_box.append(self.__tab_2, hippo.PACK_EXPAND)
-    self.__tab_3 = hippo.CanvasText(text=_('Review Submitted Jokes'),
+    tab_box.append(self.__tab_2, Hippo.PackFlags.EXPAND)
+    self.__tab_3 = Hippo.CanvasText(text=_('Review Submitted Jokes'),
                                 padding=theme.PADDING_TAB,
-                                xalign=hippo.ALIGNMENT_START,
+                                xalign=Hippo.ALIGNMENT_START,
                                 background_color=theme.COLOR_TAB_INACTIVE.get_int(),
                                 color=theme.COLOR_TAB_TEXT.get_int())
     self.__tab_3.page = EditReview
     self.__tab_3.connect('button-press-event', self.__do_clicked_tab)    
-    tab_box.append(self.__tab_3, hippo.PACK_EXPAND)
+    tab_box.append(self.__tab_3, Hippo.PackFlags.EXPAND)
     self.append(tab_box)
     
-    self.__page = hippo.CanvasBox(background_color=theme.COLOR_PAGE.get_int(),
-                                orientation=hippo.ORIENTATION_VERTICAL)
-    self.append(self.__page, hippo.PACK_EXPAND)
+    self.__page = Hippo.CanvasBox(background_color=theme.COLOR_PAGE.get_int(),
+                                orientation=Hippo.Orientation.VERTICAL)
+    self.append(self.__page, Hippo.PackFlags.EXPAND)
     
     
   @Property
@@ -92,7 +92,7 @@ class PageSelector(hippo.CanvasBox):
     def get(self): return self.__page.the_page
     def set(self, value): 
       self.__page.clear()
-      self.__page.append(value, hippo.PACK_EXPAND)
+      self.__page.append(value, Hippo.PackFlags.EXPAND)
       self.__page.the_page = value
     
     
@@ -113,12 +113,12 @@ class Edit(Page):
     self.__jokebook = jokebook    
     
     self.__page_selector = PageSelector(self)
-    self.append(self.__page_selector, hippo.PACK_EXPAND)
+    self.append(self.__page_selector, Hippo.PackFlags.EXPAND)
     self.__page_selector.page = EditInfo(jokebook, self)
     
     button = Gtk.Button(_('Preview'))
     button.connect('clicked', self.__do_clicked_preview, jokebook)    
-    self.append(hippo.CanvasWidget(widget=theme.theme_widget(button), padding_top=theme.SPACER_VERTICAL))
+    self.append(Hippo.CanvasWidget(widget=theme.theme_widget(button), padding_top=theme.SPACER_VERTICAL))
 
 
   def __do_clicked_preview(self, button, jokebook):
@@ -133,8 +133,8 @@ class Edit(Page):
 
 class EditInfo(Page): # TODO -> gui.Page should follow this pattern rather
   def __init__(self, jokebook, parent):
-    Page.__init__(self, xalign=hippo.ALIGNMENT_CENTER,
-                        orientation=hippo.ORIENTATION_VERTICAL,
+    Page.__init__(self, xalign=Hippo.ALIGNMENT_CENTER,
+                        orientation=Hippo.Orientation.VERTICAL,
                         padding=20, 
                         spacing=20)
     
@@ -144,8 +144,8 @@ class EditInfo(Page): # TODO -> gui.Page should follow this pattern rather
     self.append(self.make_field(_('Title of Jokebook:'), 250, jokebook, 'title', 300, True))
     #field = self.make_field(_('Sound Effect:'), 250, None, '', 300, False)
     
-    sound_effect = hippo.CanvasBox(orientation=hippo.ORIENTATION_HORIZONTAL, spacing=10)
-    sound_effect.append(self.make_bodytext(_('Sound Effect:'), 250, hippo.ALIGNMENT_START, theme.COLOR_DARK_GREEN))
+    sound_effect = Hippo.CanvasBox(orientation=Hippo.Orientation.HORIZONTAL, spacing=10)
+    sound_effect.append(self.make_bodytext(_('Sound Effect:'), 250, Hippo.ALIGNMENT_START, theme.COLOR_DARK_GREEN))
     sound_effect.append(self.make_audiobox(jokebook, 'sound', 316))
     self.append(sound_effect)
     
@@ -172,33 +172,33 @@ class EditJokes(Page):
     for joke in jokebook.jokes:
       button = Gtk.Button(' ' + _('Delete') + ' ')
       button.connect('clicked', self.__do_clicked_delete, jokebook, joke)
-      list_row = self.make_listrow(JokeEditor(joke), hippo.PACK_EXPAND)
-      list_row.append(hippo.CanvasWidget(widget=theme.theme_widget(button),
+      list_row = self.make_listrow(JokeEditor(joke), Hippo.PackFlags.EXPAND)
+      list_row.append(Hippo.CanvasWidget(widget=theme.theme_widget(button),
                                          padding=5),
-                      hippo.PACK_END)
+                      Hippo.PackFlags.END)
       jokes_div.append(list_row)
-    self.append(jokes_div, hippo.PACK_EXPAND)
+    self.append(jokes_div, Hippo.PackFlags.EXPAND)
     
     # new joke button
-    buttons = hippo.CanvasBox(orientation=hippo.ORIENTATION_HORIZONTAL,
-                              xalign=hippo.ALIGNMENT_START)
+    buttons = Hippo.CanvasBox(orientation=Hippo.Orientation.HORIZONTAL,
+                              xalign=Hippo.ALIGNMENT_START)
     button = Gtk.Button(_('Add New Joke'))
     button.connect('clicked', self.do_clicked_add_joke, jokebook)    
-    buttons.append(hippo.CanvasWidget(widget=theme.theme_widget(button)))    
+    buttons.append(Hippo.CanvasWidget(widget=theme.theme_widget(button)))    
     jokes_div.append(buttons)
     
     
   def __do_clicked_delete(self, button, jokebook, joke):
     confirm = Gtk.MessageDialog(Globals.JokeMachineActivity, 
-                                Gtk.DIALOG_MODAL | Gtk.DIALOG_DESTROY_WITH_PARENT,
-                                Gtk.MESSAGE_QUESTION,
-                                Gtk.BUTTONS_YES_NO,
+                                Gtk.DialogFlags.MODAL | Gtk.DialogFlags.DESTROY_WITH_PARENT,
+                                Gtk.MessageType.QUESTION,
+                                Gtk.ButtonsType.YES_NO,
                                 _('Are you sure you want to delete this joke ?'))
     response = confirm.run()
     confirm.hide()
     confirm.destroy()
     del confirm
-    if response == Gtk.RESPONSE_YES:
+    if response == Gtk.ResponseType.YES:
       logging.debug('Deleting joke: %s' % joke.id)
       jokebook.jokes.remove(joke)
       self.__parent.do_tab_clicked(EditJokes)
@@ -227,49 +227,49 @@ class EditReview(Page):
     jokes_div.props.border=0
     for joke in jokebook.submissions:
       list_row = self.make_listrow(JokeViewer(joke, jokebook.title))
-      list_row.props.orientation=hippo.ORIENTATION_VERTICAL
+      list_row.props.orientation=Hippo.Orientation.VERTICAL
       
-      buttons = hippo.CanvasBox(orientation=hippo.ORIENTATION_HORIZONTAL,
-                                xalign=hippo.ALIGNMENT_END,
+      buttons = Hippo.CanvasBox(orientation=Hippo.Orientation.HORIZONTAL,
+                                xalign=Hippo.ALIGNMENT_END,
                                 spacing=10,
                                 padding=10)
       
       button = Gtk.Button(' ' + _('Reject') + ' ')
       button.connect('clicked', self.__do_clicked_reject, jokebook, joke)
-      buttons.append(hippo.CanvasWidget(widget=theme.theme_widget(button),
+      buttons.append(Hippo.CanvasWidget(widget=theme.theme_widget(button),
                                         border_color=theme.COLOR_RED.get_int(),
                                         border=0,
-                                        xalign=hippo.ALIGNMENT_CENTER))
+                                        xalign=Hippo.ALIGNMENT_CENTER))
 
       button = Gtk.Button(' ' + _('Accept') + ' ')
       button.connect('clicked', self.__do_clicked_accept, jokebook, joke)
-      buttons.append(hippo.CanvasWidget(widget=theme.theme_widget(button),
+      buttons.append(Hippo.CanvasWidget(widget=theme.theme_widget(button),
                                         border_color=theme.COLOR_RED.get_int(),
                                         border=0,
-                                        xalign=hippo.ALIGNMENT_CENTER))
+                                        xalign=Hippo.ALIGNMENT_CENTER))
  
       list_row.append(buttons)
       
-      #list_row.props.orientation=hippo.ORIENTATION_VERTICAL
-      #status_box = hippo.CanvasBox(orientation=hippo.ORIENTATION_HORIZONTAL,
+      #list_row.props.orientation=Hippo.Orientation.VERTICAL
+      #status_box = Hippo.CanvasBox(orientation=Hippo.Orientation.HORIZONTAL,
                                    #padding_top=4,
                                    #padding_left=4)
-      #status_box.append(hippo.CanvasText(text=_('Status:'),
+      #status_box.append(Hippo.CanvasText(text=_('Status:'),
                                   #color=theme.COLOR_DARK_GREEN.get_int(),
                                   #box_width=100,
-                                  #xalign=hippo.ALIGNMENT_START))
+                                  #xalign=Hippo.ALIGNMENT_START))
       ##button = None
       #button = Gtk.RadioButton()
       #button = Gtk.RadioButton(button, _('Approved'))
       #button.set_size_request(200, -1)
-      #status_box.append(hippo.CanvasWidget(widget = button))
+      #status_box.append(Hippo.CanvasWidget(widget = button))
       #button = Gtk.RadioButton(button, _('Rejected'))
       #button.set_size_request(200, -1)
-      #status_box.append(hippo.CanvasWidget(widget = button))
+      #status_box.append(Hippo.CanvasWidget(widget = button))
       #button = Gtk.RadioButton(button, _('Not Reviewed'))
       #button.set_size_request(200, -1)
       #button.set_active(True)
-      #status_box.append(hippo.CanvasWidget(widget = button))
+      #status_box.append(Hippo.CanvasWidget(widget = button))
       #list_row.append(status_box)
       
       jokes_div.append(list_row)
diff --git a/pages/joke.py b/pages/joke.py
index 269148e..f8bf8bc 100644
--- a/pages/joke.py
+++ b/pages/joke.py
@@ -21,8 +21,8 @@
 import gi
 import os
 from gi.repository import Gtk
-import hippo
-import pango
+from gi.repository import Hippo
+from gi.repository import Pango
 from gettext import gettext as _
 import logging
 
@@ -44,41 +44,41 @@ class JokeViewer(Page):
                   padding=4,
                   border_color=theme.COLOR_RED.get_int(),
                   border=0,
-                  xalign=hippo.ALIGNMENT_START,
-                  orientation=hippo.ORIENTATION_HORIZONTAL)
+                  xalign=Hippo.ALIGNMENT_START,
+                  orientation=Hippo.Orientation.HORIZONTAL)
 
     # left column 
-    self.left = hippo.CanvasBox(border=0,
+    self.left = Hippo.CanvasBox(border=0,
                                 border_color=theme.COLOR_RED.get_int(),
                                 box_width=450,
-                                xalign=hippo.ALIGNMENT_START,
-                                orientation=hippo.ORIENTATION_VERTICAL)
+                                xalign=Hippo.ALIGNMENT_START,
+                                orientation=Hippo.Orientation.VERTICAL)
     joke_image = self.make_imagebox(joke, 'image', 320, 240, False)
     self.left.append(joke_image)
-    self.left.append(hippo.CanvasText(text=jokebook_title,
-                                      xalign=hippo.ALIGNMENT_START,
+    self.left.append(Hippo.CanvasText(text=jokebook_title,
+                                      xalign=Hippo.ALIGNMENT_START,
                                       color=theme.COLOR_DARK_GREEN.get_int()))
-    self.left.append(hippo.CanvasText(text=_('Joke') + ' ' + str(joke.id),
-                                      xalign=hippo.ALIGNMENT_START))
-    self.left.append(hippo.CanvasText(text=_('By') + ' ' + str(joke.joker),
-                                      xalign=hippo.ALIGNMENT_START))
+    self.left.append(Hippo.CanvasText(text=_('Joke') + ' ' + str(joke.id),
+                                      xalign=Hippo.ALIGNMENT_START))
+    self.left.append(Hippo.CanvasText(text=_('By') + ' ' + str(joke.joker),
+                                      xalign=Hippo.ALIGNMENT_START))
 
     # right column 
-    self.right = hippo.CanvasBox(border=0,
+    self.right = Hippo.CanvasBox(border=0,
                                  border_color=theme.COLOR_RED.get_int(),
                                  box_width=350,
-                                 xalign=hippo.ALIGNMENT_START,
-                                 orientation=hippo.ORIENTATION_VERTICAL)
-    self.right.append(hippo.CanvasText(text=_('Question'),
-                                       xalign=hippo.ALIGNMENT_START,
+                                 xalign=Hippo.ALIGNMENT_START,
+                                 orientation=Hippo.Orientation.VERTICAL)
+    self.right.append(Hippo.CanvasText(text=_('Question'),
+                                       xalign=Hippo.ALIGNMENT_START,
                                        color=theme.COLOR_DARK_GREEN.get_int()))
     self.right.append(self.make_bodytext(joke.text))
 
-    self.right.append(hippo.CanvasBox(box_height=30)) # spacer
+    self.right.append(Hippo.CanvasBox(box_height=30)) # spacer
 
-    self.answer_box = hippo.CanvasBox()
-    self.answer_box.append(hippo.CanvasText(text=_('Answer'),
-                                       xalign=hippo.ALIGNMENT_START,
+    self.answer_box = Hippo.CanvasBox()
+    self.answer_box.append(Hippo.CanvasText(text=_('Answer'),
+                                       xalign=Hippo.ALIGNMENT_START,
                                        color=theme.COLOR_DARK_GREEN.get_int()))
     self.answer_box.append(self.make_bodytext(joke.answer))    
     self.right.append(self.answer_box)
@@ -99,12 +99,12 @@ class Joke(Page):
       if not Globals.JokeMachineActivity.is_initiator:
         button = Gtk.Button(_('Submit a Joke'))
         button.connect('clicked', self.__do_clicked_submit, jokebook, joke_id)        
-        self.append(hippo.CanvasWidget(widget=theme.theme_widget(button), 
+        self.append(Hippo.CanvasWidget(widget=theme.theme_widget(button), 
                                        padding_top=20))
       else:
         button = Gtk.Button(_('Add Jokes'))
         button.connect('clicked', self.__do_clicked_add, jokebook, joke_id)        
-        self.append(hippo.CanvasWidget(widget=theme.theme_widget(button), 
+        self.append(Hippo.CanvasWidget(widget=theme.theme_widget(button), 
                                        padding_top=20))
       return
       
@@ -114,16 +114,16 @@ class Joke(Page):
     self.joke_box.answer_box.set_visible(False)
 
     # the navigation box
-    self.navigation_box = hippo.CanvasBox(
+    self.navigation_box = Hippo.CanvasBox(
       padding_right=8,
       padding_top=8,
       spacing=18,
-      orientation=hippo.ORIENTATION_HORIZONTAL)
+      orientation=Hippo.Orientation.HORIZONTAL)
 
     # the answer button
     button = Gtk.Button(_('Answer'))
     button.connect('clicked', self.__do_clicked_answer, jokebook, joke_id)        
-    self.navigation_box.append(hippo.CanvasWidget(widget=theme.theme_widget(button), padding_top=20))
+    self.navigation_box.append(Hippo.CanvasWidget(widget=theme.theme_widget(button), padding_top=20))
     self.joke_box.right.append(self.navigation_box)
     self.append(self.joke_box)
 
@@ -153,13 +153,13 @@ class Joke(Page):
     if len(jokebook.jokes) > joke_id + 1:
       button = Gtk.Button(_('Next'))
       button.connect('clicked', self.__do_clicked_next, jokebook, joke_id + 1)        
-      self.navigation_box.append(hippo.CanvasWidget(widget=theme.theme_widget(button), padding_right=10, padding_top=20))
+      self.navigation_box.append(Hippo.CanvasWidget(widget=theme.theme_widget(button), padding_right=10, padding_top=20))
     
     # only allow submitting a joke if activity is shared and you are the one joining
     if not Globals.JokeMachineActivity.is_initiator:
       button = Gtk.Button(_('Submit a Joke'))
       button.connect('clicked', self.__do_clicked_submit, jokebook, joke_id)        
-      self.navigation_box.append(hippo.CanvasWidget(widget=theme.theme_widget(button), 
+      self.navigation_box.append(Hippo.CanvasWidget(widget=theme.theme_widget(button), 
                                                     padding_top=20))
       
     
diff --git a/pages/preview.py b/pages/preview.py
index e3e8508..d44f9c8 100644
--- a/pages/preview.py
+++ b/pages/preview.py
@@ -21,8 +21,8 @@
 import gi
 import os
 from gi.repository import Gtk
-import hippo
-import pango
+from gi.repository import Hippo
+from gi.repository import Pango
 import logging
 from gettext import gettext as _
 
@@ -39,34 +39,34 @@ import pages.edit
 class Preview(Page):
   
   def __init__(self, jokebook):
-    Page.__init__(self, xalign=hippo.ALIGNMENT_CENTER)
+    Page.__init__(self, xalign=Hippo.ALIGNMENT_CENTER)
     
     preview_box = CanvasListBox()
     
     # cover
     cover = self.make_listrow()
-    cover.props.orientation=hippo.ORIENTATION_VERTICAL
-    cover.append(hippo.CanvasText(text='"' + (jokebook.title or '')+ '" ' +
+    cover.props.orientation=Hippo.Orientation.VERTICAL
+    cover.append(Hippo.CanvasText(text='"' + (jokebook.title or '')+ '" ' +
         _('started by') + ' ' + (jokebook.owner or ''),
-                                 xalign=hippo.ALIGNMENT_CENTER,
+                                 xalign=Hippo.ALIGNMENT_CENTER,
                                  padding_top=10))
-    cover.append(hippo.CanvasBox(box_height=theme.SPACER_VERTICAL))      
+    cover.append(Hippo.CanvasBox(box_height=theme.SPACER_VERTICAL))      
     cover_picture = self.make_imagebox(jokebook, 'image', 480, 360, False)    
     cover.append(cover_picture)
-    cover.append(hippo.CanvasBox(box_height=theme.SPACER_VERTICAL))
+    cover.append(Hippo.CanvasBox(box_height=theme.SPACER_VERTICAL))
     preview_box.append(cover)
     
     # jokes
     for joke in jokebook.jokes:
       list_row = self.make_listrow(JokeViewer(joke, jokebook.title))
       preview_box.append(list_row)
-    self.append(preview_box, hippo.PACK_EXPAND)
+    self.append(preview_box, Hippo.PackFlags.EXPAND)
     
-    self.append(hippo.CanvasBox(box_height=theme.SPACER_VERTICAL))
+    self.append(Hippo.CanvasBox(box_height=theme.SPACER_VERTICAL))
     
     button = Gtk.Button(_('Edit'))
     button.connect('clicked', self.__do_clicked_edit, jokebook)    
-    self.append(hippo.CanvasWidget(widget=theme.theme_widget(button)))
+    self.append(Hippo.CanvasWidget(widget=theme.theme_widget(button)))
 
   
   def __do_clicked_edit(self, button, jokebook):
diff --git a/pages/submit.py b/pages/submit.py
index dfe7bd6..25fce61 100644
--- a/pages/submit.py
+++ b/pages/submit.py
@@ -21,8 +21,8 @@
 import gi
 import os
 from gi.repository import Gtk
-import hippo
-import pango
+from gi.repository import Hippo
+from gi.repository import Pango
 import logging
 from gettext import gettext as _
 
@@ -44,38 +44,38 @@ class JokeEditor(Page):
                   padding=4,
                   border_color=theme.COLOR_RED.get_int(),
                   border=0,
-                  orientation=hippo.ORIENTATION_HORIZONTAL)
+                  orientation=Hippo.Orientation.HORIZONTAL)
     
      # left column 
-    self.left = hippo.CanvasBox(border=0,
+    self.left = Hippo.CanvasBox(border=0,
                                 border_color=theme.COLOR_RED.get_int(),
-                                xalign=hippo.ALIGNMENT_START,
-                                orientation=hippo.ORIENTATION_VERTICAL,
+                                xalign=Hippo.ALIGNMENT_START,
+                                orientation=Hippo.Orientation.VERTICAL,
                                 padding=theme.BORDER_WIDTH_CONTROL/2)
     joke_image = self.make_imagebox(joke, 'image', 320, 240, True)
     self.left.append(joke_image)
     
     # right column 
-    self.right = hippo.CanvasBox(border=0,
+    self.right = Hippo.CanvasBox(border=0,
                                  border_color=theme.COLOR_RED.get_int(),
                                  padding=theme.SPACER_HORIZONTAL,
-                                 orientation=hippo.ORIENTATION_VERTICAL,
+                                 orientation=Hippo.Orientation.VERTICAL,
                                  padding_bottom=theme.BORDER_WIDTH_CONTROL/2,
                                  spacing=theme.BORDER_WIDTH_CONTROL/2)
-    self.right.append(hippo.CanvasText(text=_('Question'),
-                                  xalign=hippo.ALIGNMENT_START,
+    self.right.append(Hippo.CanvasText(text=_('Question'),
+                                  xalign=Hippo.ALIGNMENT_START,
                                   color=theme.COLOR_DARK_GREEN.get_int()))
     self.right.append(self.make_textbox(joke, 'text'))
 
-    self.right.append(hippo.CanvasBox(box_height=theme.SPACER_VERTICAL)) 
+    self.right.append(Hippo.CanvasBox(box_height=theme.SPACER_VERTICAL)) 
     
-    self.right.append(hippo.CanvasText(text=_('Answer'),
-                                  xalign=hippo.ALIGNMENT_START,
+    self.right.append(Hippo.CanvasText(text=_('Answer'),
+                                  xalign=Hippo.ALIGNMENT_START,
                                   color=theme.COLOR_DARK_GREEN.get_int()))
     self.right.append(self.make_textbox(joke, 'answer'))
     
     self.append(self.left)
-    self.append(self.right, hippo.PACK_EXPAND)
+    self.append(self.right, Hippo.PackFlags.EXPAND)
 
 
 class Submit(Page):
@@ -93,21 +93,21 @@ class Submit(Page):
     self.append(self.make_field(_('Submission For:'), 250, jokebook, 'title', 300, False))
     self.append(self.make_field(_('Your Name:'),  250, joke, 'joker', 300, True))
     
-    self.append(hippo.CanvasBox(box_height=theme.SPACER_VERTICAL)) # spacer
+    self.append(Hippo.CanvasBox(box_height=theme.SPACER_VERTICAL)) # spacer
 
     # joke editor
     jokebox = JokeEditor(joke)        
-    nav = hippo.CanvasBox(
+    nav = Hippo.CanvasBox(
       padding_right=8,
       padding_top=8,
       spacing=18,
-      orientation=hippo.ORIENTATION_HORIZONTAL)
+      orientation=Hippo.Orientation.HORIZONTAL)
     button = Gtk.Button(_('Submit'))
     button.connect('clicked', self.__do_clicked_submit, jokebook, joke)    
-    nav.append(hippo.CanvasWidget(widget=theme.theme_widget(button), padding_right=10, padding_top=20))
+    nav.append(Hippo.CanvasWidget(widget=theme.theme_widget(button), padding_right=10, padding_top=20))
     button = Gtk.Button(_('Back'))
     button.connect('clicked', self.__do_clicked_back, jokebook, last_joke)    
-    nav.append(hippo.CanvasWidget(widget=theme.theme_widget(button), padding_top=20))
+    nav.append(Hippo.CanvasWidget(widget=theme.theme_widget(button), padding_top=20))
     jokebox.right.append(nav)
     self.append(jokebox)