Port to Gtk3

Signed-off-by: Daniel Francis <francis@sugarlabs.org>

16 files changed, 568 insertions, 325 deletions

diff --git a/alerts.py b/alerts.py
index 7f90efb..a83460a 100644
--- a/alerts.py
+++ b/alerts.py
@@ -1,4 +1,4 @@
-# Copyright (C) 2012 S. Daniel Francis <francis@sugarlabs.org>
+# Copyright (C) 2012-2013 S. Daniel Francis <francis@sugarlabs.org>
 #
 # This program is free software; you can redistribute it and/or modify
 # it under the terms of the GNU General Public License as published by
@@ -15,29 +15,29 @@
 # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
 # MA 02110-1301, USA.
 
-import gtk
+from gi.repository import Gtk
 
-import pynotify
+from gi.repository import Notify
 import info
-pynotify.init(info.name)
+Notify.init(info.name)
 
 
-class Alert(gtk.MessageDialog):
+class Alert(Gtk.MessageDialog):
     def __init__(self, parent, title, content, mtype):
-        gtk.MessageDialog.__init__(self, parent, gtk.DIALOG_MODAL,
+        GObject.GObject.__init__(self, parent, Gtk.DialogFlags.MODAL,
                                    type=mtype,
-                                   buttons=gtk.BUTTONS_OK)
+                                   buttons=Gtk.ButtonsType.OK)
         self.set_markup('<b>%s</b>' % title)
         self.format_secondary_markup(content)
 
     def run(self):
-        gtk.MessageDialog.run(self)
-        gtk.MessageDialog.destroy(self)
+        Gtk.MessageDialog.run(self)
+        Gtk.MessageDialog.destroy(self)
 
 
-class NotifyAlert(pynotify.Notification):
+class NotifyAlert(Notify.Notification):
     def __init__(self, parent, title, content, icon, timeout):
-        pynotify.Notification.__init__(self, title, message=content, icon=icon)
+        Notify.Notification.__init__(self, title, message=content, icon=icon)
         self.set_timeout(timeout)
 
     def run(self):
diff --git a/basic_options.py b/basic_options.py
index 83636e1..fd6a238 100644
--- a/basic_options.py
+++ b/basic_options.py
@@ -2,7 +2,7 @@
 This module provides a "File" menu at desktops and an ActivityToolbar at Sugar.
 See class BasicOptions.
 """
-# Copyright (C) 2012 S. Daniel Francis <francis@sugarlabs.org>
+# Copyright (C) 2012-2013 S. Daniel Francis <francis@sugarlabs.org>
 #
 # This program is free software; you can redistribute it and/or modify
 # it under the terms of the GNU General Public License as published by
@@ -20,7 +20,7 @@ See class BasicOptions.
 # MA 02110-1301, USA.
 
 from gettext import gettext as _
-import gtk
+from gi.repository import Gtk
 
 import stock
 from item import Item
@@ -42,17 +42,17 @@ class BasicOptions(ItemGroup):
         ItemGroup.__init__(self, box, _('_File'), None)
 
         if activity.save_type != CONFIG:
-            new = Item(gtk.STOCK_NEW, True)
+            new = Item(Gtk.STOCK_NEW, True)
             new.connect('activate', lambda w: activity.new())
             self.append_item(new)
-            _open = Item(gtk.STOCK_OPEN, True)
+            _open = Item(Gtk.STOCK_OPEN, True)
             _open.connect('activate', lambda w: activity.open())
             self.append_item(_open)
             self.append_separator()
-            save_option = Item(gtk.STOCK_SAVE, True)
+            save_option = Item(Gtk.STOCK_SAVE, True)
             save_option.connect('activate', lambda w: activity.save())
             self.append_item(save_option)
-            save_as_option = Item(gtk.STOCK_SAVE_AS)
+            save_as_option = Item(Gtk.STOCK_SAVE_AS)
             save_as_option.connect('activate', lambda w: activity.save_as())
             self.append_item(save_as_option)
         if export_formats != None:
@@ -66,6 +66,6 @@ class BasicOptions(ItemGroup):
                                export_formats[0])
                 self.append_item(export)
             self.append_separator()
-        _quit = Item(gtk.STOCK_QUIT)
+        _quit = Item(Gtk.STOCK_QUIT)
         _quit.connect('activate', lambda w: activity.stop())
         self.append_item(_quit)
diff --git a/coloritem.py b/coloritem.py
index 03d0955..97be241 100644
--- a/coloritem.py
+++ b/coloritem.py
@@ -19,8 +19,9 @@
 import logging
 logger = logging.getLogger('option')
 
-import gobject
-import gtk
+from gi.repository import GObject
+from gi.repository import Gtk
+from gi.repository import Gdk
 
 from colors import color2string
 from item import Item
@@ -31,10 +32,10 @@ class ColorItem(Item):
     """Color Selecting interface.
     In Sugar it creates a sugar.graphics.colorbutton.ColorToolButton.
     In other desktops it's a sweetener.item.Item connected to a
-    gtk.ColorSelectionDialog.
+    Gtk.ColorSelectionDialog.
     """
-    __gsignals__ = {'updated': (gobject.SIGNAL_RUN_LAST, gobject.TYPE_NONE,
-                                (gobject.TYPE_STRING,))}
+    __gsignals__ = {'updated': (GObject.SignalFlags.RUN_LAST, None,
+                                (GObject.TYPE_STRING,))}
 
     def __init__(self, parent=None, important=False):
         """Constructor.
@@ -42,7 +43,7 @@ class ColorItem(Item):
         important -- bool , if it's True, in desktops a ToolItem will be
         appended to the Toolbar.
         """
-        Item.__init__(self, gtk.STOCK_SELECT_COLOR, important)
+        Item.__init__(self, Gtk.STOCK_SELECT_COLOR, important)
         self.parent = parent
         self.color = '#FFFFFF'
 
@@ -60,13 +61,13 @@ class ColorItem(Item):
             title = self.tooltip
         else:
             title = stock.get_title(self.stock_id)
-        dialog = gtk.ColorSelectionDialog(title)
+        dialog = Gtk.ColorSelectionDialog(title)
         dialog.set_transient_for(self.parent)
         color_selection = dialog.get_color_selection()
         color_selection.connect('color-changed', self._color_changed_cb)
-        color_selection.set_current_color(gtk.gdk.color_parse(self.color))
+        color_selection.set_current_color(Gdk.color_parse(self.color))
         dialog.props.cancel_button.hide()
-        #dialog.add_button(gtk.STOCK_OK, gtk.RESPONSE_ACCEPT)
+        #dialog.add_button(Gtk.STOCK_OK, Gtk.ResponseType.ACCEPT)
         dialog.run()
         dialog.destroy()
         self.emit('updated', self.color)
diff --git a/colors.py b/colors.py
index cff7ca1..c646bae 100644
--- a/colors.py
+++ b/colors.py
@@ -5,7 +5,7 @@ Utilities for handle color data and conversions.
 #     Copyright (C) 2006-2007 Red Hat, Inc.
 #
 # Adaptation and more:
-#     Copyright (C) 2012 Daniel Francis
+#     Copyright (C) 2012-2013 Daniel Francis
 #
 # This program is free software; you can redistribute it and/or modify
 # it under the terms of the GNU General Public License as published by
@@ -77,7 +77,7 @@ class XoColor:
 # Added in Sweetener
 def color2string(color):
     """Converts a GdkColor to a RGB string
-    color -- gtk.gdk.Color
+    color -- Gdk.Color
     """
     color_string = ["#"]
     color_string.append("%02x" % (color.red / 256))
diff --git a/help.py b/help.py
index b5ae931..1759c7c 100644
--- a/help.py
+++ b/help.py
@@ -17,7 +17,7 @@
 # MA 02110-1301, USA.
 
 from gettext import gettext as _
-import gtk
+from gi.repository import Gtk
 
 import stock
 from item import Item
@@ -27,11 +27,11 @@ import info
 
 class AboutItem(Item):
     def __init__(self, parent):
-        Item.__init__(self, gtk.STOCK_ABOUT)
+        Item.__init__(self, Gtk.STOCK_ABOUT)
         self.parent = parent
 
     def do_activate(self):
-        dialog = gtk.AboutDialog()
+        dialog = Gtk.AboutDialog()
         dialog.set_name(info.name)
         dialog.set_version(info.version)
         dialog.set_transient_for(self.parent)
@@ -54,14 +54,14 @@ class Help(ItemGroup):
         """Constructor.
         box -- sweetener.ItemBox where append it
         """
-        title = stock.get_label(gtk.STOCK_HELP, False)
+        title = stock.get_label(Gtk.STOCK_HELP, False)
         ItemGroup.__init__(self, box, title, 'toolbar-help')
         stock.register('sweetener-help-contents', title,
                        'F1', 'gtk-help')
         contents = Item('sweetener-help-contents')
-        contents.connect('activate', lambda w: gtk.show_uri(None,
+        contents.connect('activate', lambda w: Gtk.show_uri(None,
                                                          info.documentation,
-                                                gtk.get_current_event_time()))
+                                                Gtk.get_current_event_time()))
         self.append_item(contents)
         about = AboutItem(box._parent)
         self.append_item(about)
diff --git a/icon.py b/icon.py
index 3eb0515..b4d31b3 100644
--- a/icon.py
+++ b/icon.py
@@ -25,8 +25,11 @@ import re
 import math
 import logging
 
-import gobject
-import gtk
+from gi.repository import GObject
+from gi.repository import Gtk
+from gi.repository import Gdk
+from gi.repository import GdkPixbuf
+from gi.repository import Rsvg
 import cairo
 
 from colors import XoColor
@@ -125,7 +128,6 @@ class LRU:
     def keys(self):
         return self.d.keys()
 
-
 _BADGE_SIZE = 0.45
 
 
@@ -153,9 +155,7 @@ class _SVGLoader(object):
                 logging.error(
                     'Icon %s, entity %s is invalid.', file_name, entity)
 
-        # XXX this is very slow!  why?
-        import rsvg
-        return rsvg.Handle(data=icon)
+        return Rsvg.Handle.new_from_data(icon)
 
 
 class _IconInfo(object):
@@ -213,11 +213,11 @@ class _IconBuffer(object):
         return self._loader.load(file_name, entities, self.cache)
 
     def _get_attach_points(self, info, size_request):
-        attach_points = info.get_attach_points()
+        has_attach_points_, attach_points = info.get_attach_points()
 
         if attach_points:
-            attach_x = float(attach_points[0][0]) / size_request
-            attach_y = float(attach_points[0][1]) / size_request
+            attach_x = float(attach_points[0].x) / size_request
+            attach_y = float(attach_points[0].y) / size_request
         else:
             attach_x = attach_y = 0
 
@@ -229,7 +229,7 @@ class _IconBuffer(object):
         if self.file_name:
             icon_info.file_name = self.file_name
         elif self.icon_name:
-            theme = gtk.icon_theme_get_default()
+            theme = Gtk.IconTheme.get_default()
 
             size = 50
             if self.width != None:
@@ -251,20 +251,19 @@ class _IconBuffer(object):
         return icon_info
 
     def _draw_badge(self, context, size, sensitive, widget):
-        theme = gtk.icon_theme_get_default()
+        theme = Gtk.IconTheme.get_default()
         badge_info = theme.lookup_icon(self.badge_name, int(size), 0)
         if badge_info:
             badge_file_name = badge_info.get_filename()
             if badge_file_name.endswith('.svg'):
                 handle = self._loader.load(badge_file_name, {}, self.cache)
 
-                dimensions = handle.get_dimension_data()
-                icon_width = int(dimensions[0])
-                icon_height = int(dimensions[1])
+                icon_width = handle.props.width
+                icon_height = handle.props.height
 
                 pixbuf = handle.get_pixbuf()
             else:
-                pixbuf = gtk.gdk.pixbuf_new_from_file(badge_file_name)
+                pixbuf = GdkPixbuf.Pixbuf.new_from_file(badge_file_name)
 
                 icon_width = pixbuf.get_width()
                 icon_height = pixbuf.get_height()
@@ -274,9 +273,8 @@ class _IconBuffer(object):
 
             if not sensitive:
                 pixbuf = self._get_insensitive_pixbuf(pixbuf, widget)
-            gdkcontext = gtk.gdk.CairoContext(context)
-            gdkcontext.set_source_pixbuf(pixbuf, 0, 0)
-            gdkcontext.paint()
+            Gdk.cairo_set_source_pixbuf(context, pixbuf, 0, 0)
+            context.paint()
 
     def _get_size(self, icon_width, icon_height, padding):
         if self.width is not None and self.height is not None:
@@ -322,20 +320,21 @@ class _IconBuffer(object):
             self.fill_color = None
 
     def _get_insensitive_pixbuf(self, pixbuf, widget):
-        if not (widget and widget.style):
+        if not (widget and widget.get_style()):
             return pixbuf
 
-        icon_source = gtk.IconSource()
+        icon_source = Gtk.IconSource()
         # Special size meaning "don't touch"
         icon_source.set_size(-1)
         icon_source.set_pixbuf(pixbuf)
-        icon_source.set_state(gtk.STATE_INSENSITIVE)
+        icon_source.set_state(Gtk.StateType.INSENSITIVE)
         icon_source.set_direction_wildcarded(False)
         icon_source.set_size_wildcarded(False)
 
-        pixbuf = widget.style.render_icon(icon_source, widget.get_direction(),
-                                          gtk.STATE_INSENSITIVE, -1, widget,
-                                          'sugar-icon')
+        style = widget.get_style()
+        pixbuf = style.render_icon(icon_source, widget.get_direction(),
+                                   Gtk.StateType.INSENSITIVE, -1, widget,
+                                   'sugar-icon')
 
         return pixbuf
 
@@ -352,11 +351,10 @@ class _IconBuffer(object):
 
         if is_svg:
             handle = self._load_svg(icon_info.file_name)
-            dimensions = handle.get_dimension_data()
-            icon_width = int(dimensions[0])
-            icon_height = int(dimensions[1])
+            icon_width = handle.props.width
+            icon_height = handle.props.height
         else:
-            pixbuf = gtk.gdk.pixbuf_new_from_file(icon_info.file_name)
+            pixbuf = GdkPixbuf.Pixbuf.new_from_file(icon_info.file_name)
             icon_width = pixbuf.get_width()
             icon_height = pixbuf.get_height()
 
@@ -372,9 +370,7 @@ class _IconBuffer(object):
             surface = cairo.ImageSurface(cairo.FORMAT_RGB24, int(width),
                                          int(height))
             context = cairo.Context(surface)
-            context.set_source_rgb(self.background_color.red,
-                                   self.background_color.blue,
-                                   self.background_color.green)
+            context.set_source_color(self.background_color)
             context.paint()
 
         context.scale(float(width) / (icon_width + padding * 2),
@@ -388,15 +384,14 @@ class _IconBuffer(object):
             else:
                 pixbuf = handle.get_pixbuf()
                 pixbuf = self._get_insensitive_pixbuf(pixbuf, widget)
-                gdkcontext = gtk.gdk.CairoContext(context)
-                gdkcontext.set_source_pixbuf(pixbuf, 0, 0)
-                gdkcontext.paint()
+
+                Gdk.cairo_set_source_pixbuf(context, pixbuf, 0, 0)
+                context.paint()
         else:
             if not sensitive:
                 pixbuf = self._get_insensitive_pixbuf(pixbuf, widget)
-            gdkcontext = gtk.gdk.CairoContext(context)
-            gdkcontext.set_source_pixbuf(pixbuf, 0, 0)
-            gdkcontext.paint()
+            Gdk.cairo_set_source_pixbuf(context, pixbuf, 0, 0)
+            context.paint()
 
         if self.badge_name:
             context.restore()
@@ -410,20 +405,20 @@ class _IconBuffer(object):
     xo_color = property(_get_xo_color, _set_xo_color)
 
 
-class Icon(gtk.Image):
+class Icon(Gtk.Image):
 
     __gtype_name__ = 'SugarIcon'
 
     def __init__(self, **kwargs):
         self._buffer = _IconBuffer()
         # HACK: need to keep a reference to the path so it doesn't get garbage
-        # collected while it's still used if it's a sugar.util.TempFilePath.
+        # collected while it's still used if it's a sugar3.util.TempFilePath.
         # See #1175
         self._file = None
         self._alpha = 1.0
         self._scale = 1.0
 
-        gobject.GObject.__init__(self, **kwargs)
+        GObject.GObject.__init__(self, **kwargs)
 
     def get_file(self):
         return self._file
@@ -432,7 +427,7 @@ class Icon(gtk.Image):
         self._file = file_name
         self._buffer.file_name = file_name
 
-    file = gobject.property(type=object, setter=set_file, getter=get_file)
+    file = GObject.property(type=object, setter=set_file, getter=get_file)
 
     def _sync_image_properties(self):
         if self._buffer.icon_name != self.props.icon_name:
@@ -442,7 +437,7 @@ class Icon(gtk.Image):
             self._buffer.file_name = self.props.file
 
         if self.props.pixel_size == -1:
-            width, height = gtk.icon_size_lookup(self.props.icon_size)
+            valid_, width, height = Gtk.icon_size_lookup(self.props.icon_size)
         else:
             width = height = self.props.pixel_size
         if self._buffer.width != width or self._buffer.height != height:
@@ -458,41 +453,31 @@ class Icon(gtk.Image):
     def _file_changed_cb(self, image, pspec):
         self._buffer.file_name = self.props.file
 
-    def do_size_request(self, requisition):
-        """
-        Parameters
-        ----------
-        requisition :
-
-        Returns
-        -------
-        None
-
-        """
+    def do_get_preferred_height(self):
         self._sync_image_properties()
         surface = self._buffer.get_surface()
         if surface:
-            requisition[0] = surface.get_width()
-            requisition[1] = surface.get_height()
-        elif self._buffer.width and self._buffer.height:
-            requisition[0] = self._buffer.width
-            requisition[1] = self._buffer.width
+            height = surface.get_height()
+        elif self._buffer.height:
+            height = self._buffer.height
         else:
-            requisition[0] = requisition[1] = 0
-
-    def do_expose_event(self, event):
-        """
-        Parameters
-        ----------
-        event :
+            height = 0
+        return (height, height)
 
-        Returns:
-        --------
-        None
+    def do_get_preferred_width(self):
+        self._sync_image_properties()
+        surface = self._buffer.get_surface()
+        if surface:
+            width = surface.get_width()
+        elif self._buffer.width:
+            width = self._buffer.width
+        else:
+            width = 0
+        return (width, width)
 
-        """
+    def do_draw(self, cr):
         self._sync_image_properties()
-        sensitive = (self.state != gtk.STATE_INSENSITIVE)
+        sensitive = (self.is_sensitive())
         surface = self._buffer.get_surface(sensitive, self)
         if surface is None:
             return
@@ -500,16 +485,14 @@ class Icon(gtk.Image):
         xpad, ypad = self.get_padding()
         xalign, yalign = self.get_alignment()
         requisition = self.get_child_requisition()
-        if self.get_direction() != gtk.TEXT_DIR_LTR:
+        if self.get_direction() != Gtk.TextDirection.LTR:
             xalign = 1.0 - xalign
 
         allocation = self.get_allocation()
-        x = math.floor(allocation.x + xpad +
-            (allocation.width - requisition[0]) * xalign)
-        y = math.floor(allocation.y + ypad +
-            (allocation.height - requisition[1]) * yalign)
-
-        cr = self.window.cairo_create()
+        x = math.floor(xpad +
+            (allocation.width - requisition.width) * xalign)
+        y = math.floor(ypad +
+            (allocation.height - requisition.height) * yalign)
 
         if self._scale != 1.0:
             cr.scale(self._scale, self._scale)
@@ -528,96 +511,36 @@ class Icon(gtk.Image):
             cr.paint_with_alpha(self._alpha)
 
     def set_xo_color(self, value):
-        """
-        Parameters
-        ----------
-        value :
-
-        Returns
-        -------
-        None
-
-        """
         if self._buffer.xo_color != value:
             self._buffer.xo_color = value
             self.queue_draw()
 
-    xo_color = gobject.property(
+    xo_color = GObject.property(
         type=object, getter=None, setter=set_xo_color)
 
     def set_fill_color(self, value):
-        """
-        Parameters
-        ----------
-        value :
-
-        Returns
-        -------
-        None
-
-        """
         if self._buffer.fill_color != value:
             self._buffer.fill_color = value
             self.queue_draw()
 
     def get_fill_color(self):
-        """
-        Parameters
-        ----------
-        None
-
-        Returns
-        -------
-        fill_color :
-
-        """
         return self._buffer.fill_color
 
-    fill_color = gobject.property(
+    fill_color = GObject.property(
         type=object, getter=get_fill_color, setter=set_fill_color)
 
     def set_stroke_color(self, value):
-        """
-        Parameters
-        ----------
-        value :
-
-        Returns
-        -------
-        None
-
-        """
         if self._buffer.stroke_color != value:
             self._buffer.stroke_color = value
             self.queue_draw()
 
     def get_stroke_color(self):
-        """
-        Parameters
-        ----------
-        None
-
-        Returns
-        -------
-        stroke_color :
-
-        """
         return self._buffer.stroke_color
 
-    stroke_color = gobject.property(
+    stroke_color = GObject.property(
         type=object, getter=get_stroke_color, setter=set_stroke_color)
 
     def set_badge_name(self, value):
-        """
-        Parameters
-        ----------
-        value:
-
-        Returns
-        -------
-        None
-
-        """
         if self._buffer.badge_name != value:
             self._buffer.badge_name = value
             self.queue_resize()
@@ -625,7 +548,7 @@ class Icon(gtk.Image):
     def get_badge_name(self):
         return self._buffer.badge_name
 
-    badge_name = gobject.property(
+    badge_name = GObject.property(
         type=str, getter=get_badge_name, setter=set_badge_name)
 
     def set_alpha(self, value):
@@ -633,7 +556,7 @@ class Icon(gtk.Image):
             self._alpha = value
             self.queue_draw()
 
-    alpha = gobject.property(
+    alpha = GObject.property(
         type=float, setter=set_alpha)
 
     def set_scale(self, value):
@@ -641,19 +564,285 @@ class Icon(gtk.Image):
             self._scale = value
             self.queue_draw()
 
-    scale = gobject.property(
+    scale = GObject.property(
         type=float, setter=set_scale)
 
 
-class CellRendererIcon(gtk.GenericCellRenderer):
+class EventIcon(Gtk.EventBox):
+    """
+    An Icon class that provides access to mouse events and that can act as a
+    cursor-positioned palette invoker.
+    """
+
+    __gtype_name__ = 'SugarEventIcon'
+
+    def __init__(self, **kwargs):
+        self._buffer = _IconBuffer()
+        self._alpha = 1.0
+
+        Gtk.EventBox.__init__(self)
+        self.set_visible_window(False)
+        self.set_above_child(True)
+        self.add_events(Gdk.EventMask.BUTTON_PRESS_MASK |
+                        Gdk.EventMask.TOUCH_MASK |
+                        Gdk.EventMask.BUTTON_RELEASE_MASK)
+        for key, value in kwargs.iteritems():
+            self.set_property(key, value)
+
+        from sugar3.graphics.palette import CursorInvoker
+        self._palette_invoker = CursorInvoker()
+        self._palette_invoker.attach(self)
+        self.connect('destroy', self.__destroy_cb)
+
+    def do_draw(self, cr):
+        surface = self._buffer.get_surface()
+        if surface:
+            allocation = self.get_allocation()
+
+            x = (allocation.width - surface.get_width()) / 2
+            y = (allocation.height - surface.get_height()) / 2
+
+            cr.set_source_surface(surface, x, y)
+            if self._alpha == 1.0:
+                cr.paint()
+            else:
+                cr.paint_with_alpha(self._alpha)
+
+    def do_get_preferred_height(self):
+        surface = self._buffer.get_surface()
+        if surface:
+            height = surface.get_height()
+        elif self._buffer.height:
+            height = self._buffer.height
+        else:
+            height = 0
+        return (height, height)
+
+    def do_get_preferred_width(self):
+        surface = self._buffer.get_surface()
+        if surface:
+            width = surface.get_width()
+        elif self._buffer.width:
+            width = self._buffer.width
+        else:
+            width = 0
+        return (width, width)
+
+    def __destroy_cb(self, icon):
+        if self._palette_invoker is not None:
+            self._palette_invoker.detach()
+
+    def set_file_name(self, value):
+        if self._buffer.file_name != value:
+            self._buffer.file_name = value
+            self.queue_draw()
+
+    def get_file_name(self):
+        return self._buffer.file_name
+
+    file_name = GObject.property(
+        type=object, getter=get_file_name, setter=set_file_name)
+
+    def set_icon_name(self, value):
+        if self._buffer.icon_name != value:
+            self._buffer.icon_name = value
+            self.queue_draw()
+
+    def get_icon_name(self):
+        return self._buffer.icon_name
+
+    icon_name = GObject.property(
+        type=object, getter=get_icon_name, setter=set_icon_name)
+
+    def set_xo_color(self, value):
+        if self._buffer.xo_color != value:
+            self._buffer.xo_color = value
+            self.queue_draw()
+
+    xo_color = GObject.property(
+        type=object, getter=None, setter=set_xo_color)
+
+    def set_fill_color(self, value):
+        if self._buffer.fill_color != value:
+            self._buffer.fill_color = value
+            self.queue_draw()
+
+    def get_fill_color(self):
+        return self._buffer.fill_color
+
+    fill_color = GObject.property(
+        type=object, getter=get_fill_color, setter=set_fill_color)
+
+    def set_stroke_color(self, value):
+        if self._buffer.stroke_color != value:
+            self._buffer.stroke_color = value
+            self.queue_draw()
+
+    def get_stroke_color(self):
+        return self._buffer.stroke_color
+
+    stroke_color = GObject.property(
+        type=object, getter=get_stroke_color, setter=set_stroke_color)
+
+    def set_background_color(self, value):
+        if self._buffer.background_color != value:
+            self._buffer.background_color = value
+            self.queue_draw()
+
+    def get_background_color(self):
+        return self._buffer.background_color
+
+    background_color = GObject.property(
+        type=object, getter=get_background_color, setter=set_background_color)
+
+    def set_size(self, value):
+        if self._buffer.width != value:
+            self._buffer.width = value
+            self._buffer.height = value
+            self.queue_resize()
+
+    def get_size(self):
+        return self._buffer.width
+
+    pixel_size = GObject.property(
+        type=object, getter=get_size, setter=set_size)
+
+    def set_scale(self, value):
+        if self._buffer.scale != value:
+            self._buffer.scale = value
+            self.queue_resize()
+
+    def get_scale(self):
+        return self._buffer.scale
+
+    scale = GObject.property(
+        type=float, getter=get_scale, setter=set_scale)
+
+    def set_alpha(self, alpha):
+        if self._alpha != alpha:
+            self._alpha = alpha
+            self.queue_draw()
+
+    alpha = GObject.property(
+        type=float, setter=set_alpha)
+
+    def set_cache(self, value):
+        self._buffer.cache = value
+
+    def get_cache(self):
+        return self._buffer.cache
+
+    cache = GObject.property(
+        type=bool, default=False, getter=get_cache, setter=set_cache)
+
+    def set_badge_name(self, value):
+        if self._buffer.badge_name != value:
+            self._buffer.badge_name = value
+            self.queue_draw()
+
+    def get_badge_name(self):
+        return self._buffer.badge_name
+
+    badge_name = GObject.property(
+        type=object, getter=get_badge_name, setter=set_badge_name)
+
+    def create_palette(self):
+        return None
+
+    def get_palette(self):
+        return self._palette_invoker.palette
+
+    def set_palette(self, palette):
+        self._palette_invoker.palette = palette
+
+    palette = GObject.property(
+        type=object, setter=set_palette, getter=get_palette)
+
+    def get_palette_invoker(self):
+        return self._palette_invoker
+
+    def set_palette_invoker(self, palette_invoker):
+        self._palette_invoker.detach()
+        self._palette_invoker = palette_invoker
+
+    palette_invoker = GObject.property(
+        type=object, setter=set_palette_invoker, getter=get_palette_invoker)
+
+    def set_tooltip(self, text):
+        from sugar3.graphics.palette import Palette
+
+        self.set_palette(Palette(text))
+
+
+class CanvasIcon(EventIcon):
+    """
+    An EventIcon with active and prelight states, and a styleable
+    background.
+
+    If the icon pops up a palette, the prelight state is set until the
+    palette pops down.
+
+    """
+
+    __gtype_name__ = 'SugarCanvasIcon'
+
+    def __init__(self, **kwargs):
+        EventIcon.__init__(self, **kwargs)
+
+        self.connect('enter-notify-event', self.__enter_notify_event_cb)
+        self.connect('leave-notify-event', self.__leave_notify_event_cb)
+        self.connect('button-press-event', self.__button_press_event_cb)
+        self.connect('button-release-event', self.__button_release_event_cb)
+
+    def connect_to_palette_pop_events(self, palette):
+        palette.connect('popup', self.__palette_popup_cb)
+        palette.connect('popdown', self.__palette_popdown_cb)
+
+    def do_draw(self, cr):
+        """Render a background that fits the allocated space."""
+        allocation = self.get_allocation()
+        context = self.get_style_context()
+        Gtk.render_background(context, cr, 0, 0,
+                              allocation.width,
+                              allocation.height)
+
+        EventIcon.do_draw(self, cr)
+
+    def __enter_notify_event_cb(self, icon, event):
+        self.set_state_flags(self.get_state_flags() | Gtk.StateFlags.PRELIGHT,
+                             clear=True)
+
+    def __leave_notify_event_cb(self, icon, event):
+        if self.palette and self.palette.is_up():
+            return
+
+        self.unset_state_flags(Gtk.StateFlags.PRELIGHT)
+
+    def __button_press_event_cb(self, icon, event):
+        if self.palette and not self.palette.is_up():
+            self.set_state_flags(self.get_state_flags() | Gtk.StateFlags.ACTIVE,
+                                 clear=True)
+
+    def __button_release_event_cb(self, icon, event):
+        self.unset_state_flags(Gtk.StateFlags.ACTIVE)
+
+    def __palette_popup_cb(self, palette):
+        self.set_state_flags(Gtk.StateFlags.PRELIGHT, clear=True)
+
+    def __palette_popdown_cb(self, palette):
+        self.unset_state_flags(Gtk.StateFlags.PRELIGHT)
+
+
+class CellRendererIcon(Gtk.CellRenderer):
 
     __gtype_name__ = 'SugarCellRendererIcon'
 
     __gsignals__ = {
-        'clicked': (gobject.SIGNAL_RUN_FIRST, gobject.TYPE_NONE, [object]),
+        'clicked': (GObject.SignalFlags.RUN_FIRST, None, [object]),
     }
 
     def __init__(self, tree_view):
+        #from sugar3.graphics.palette import CellRendererInvoker
 
         self._buffer = _IconBuffer()
         self._buffer.cache = True
@@ -662,20 +851,47 @@ class CellRendererIcon(gtk.GenericCellRenderer):
         self._stroke_color = None
         self._prelit_fill_color = None
         self._prelit_stroke_color = None
+        self._active_state = False
+        #self._palette_invoker = CellRendererInvoker()
+
+        Gtk.CellRenderer.__init__(self)
+
+        tree_view.connect('button-press-event',
+                          self.__button_press_event_cb)
+        tree_view.connect('button-release-event',
+                          self.__button_release_event_cb)
+
+        #self._palette_invoker.attach_cell_renderer(tree_view, self)
+
+    def __del__(self):
+        self._palette_invoker.detach()
+
+    def __button_press_event_cb(self, widget, event):
+        if self._point_in_cell_renderer(widget, event.x, event.y):
+            self._active_state = True
+
+    def __button_release_event_cb(self, widget, event):
+        self._active_state = False
+
+    def create_palette(self):
+        return None
 
-        gobject.GObject.__init__(self)
+    def get_palette_invoker(self):
+        return self._palette_invoker
+
+    palette_invoker = GObject.property(type=object, getter=get_palette_invoker)
 
     def set_file_name(self, value):
         if self._buffer.file_name != value:
             self._buffer.file_name = value
 
-    file_name = gobject.property(type=str, setter=set_file_name)
+    file_name = GObject.property(type=str, setter=set_file_name)
 
     def set_icon_name(self, value):
         if self._buffer.icon_name != value:
             self._buffer.icon_name = value
 
-    icon_name = gobject.property(type=str, setter=set_icon_name)
+    icon_name = GObject.property(type=str, setter=set_icon_name)
 
     def get_xo_color(self):
         return self._xo_color
@@ -683,40 +899,40 @@ class CellRendererIcon(gtk.GenericCellRenderer):
     def set_xo_color(self, value):
         self._xo_color = value
 
-    xo_color = gobject.property(type=object,
+    xo_color = GObject.property(type=object,
             getter=get_xo_color, setter=set_xo_color)
 
     def set_fill_color(self, value):
         if self._fill_color != value:
             self._fill_color = value
 
-    fill_color = gobject.property(type=object, setter=set_fill_color)
+    fill_color = GObject.property(type=object, setter=set_fill_color)
 
     def set_stroke_color(self, value):
         if self._stroke_color != value:
             self._stroke_color = value
 
-    stroke_color = gobject.property(type=object, setter=set_stroke_color)
+    stroke_color = GObject.property(type=object, setter=set_stroke_color)
 
     def set_prelit_fill_color(self, value):
         if self._prelit_fill_color != value:
             self._prelit_fill_color = value
 
-    prelit_fill_color = gobject.property(type=object,
+    prelit_fill_color = GObject.property(type=object,
                                          setter=set_prelit_fill_color)
 
     def set_prelit_stroke_color(self, value):
         if self._prelit_stroke_color != value:
             self._prelit_stroke_color = value
 
-    prelit_stroke_color = gobject.property(type=object,
+    prelit_stroke_color = GObject.property(type=object,
                                            setter=set_prelit_stroke_color)
 
     def set_background_color(self, value):
         if self._buffer.background_color != value:
             self._buffer.background_color = value
 
-    background_color = gobject.property(type=object,
+    background_color = GObject.property(type=object,
                                         setter=set_background_color)
 
     def set_size(self, value):
@@ -724,9 +940,10 @@ class CellRendererIcon(gtk.GenericCellRenderer):
             self._buffer.width = value
             self._buffer.height = value
 
-    size = gobject.property(type=object, setter=set_size)
+    size = GObject.property(type=object, setter=set_size)
 
-    def on_get_size(self, widget, cell_area):
+    def do_get_size(self, widget, cell_area, x_offset=None, y_offset=None,
+                    width=None, height=None):
         width = self._buffer.width + self.props.xpad * 2
         height = self._buffer.height + self.props.ypad * 2
         xoffset = 0
@@ -734,7 +951,7 @@ class CellRendererIcon(gtk.GenericCellRenderer):
 
         if width > 0 and height > 0 and cell_area is not None:
 
-            if widget.get_direction() == gtk.TEXT_DIR_RTL:
+            if widget.get_direction() == Gtk.TextDirection.RTL:
                 xoffset = 1.0 - self.props.xalign
             else:
                 xoffset = self.props.xalign
@@ -744,24 +961,31 @@ class CellRendererIcon(gtk.GenericCellRenderer):
 
         return xoffset, yoffset, width, height
 
-    def on_activate(self, event, widget, path, background_area, cell_area,
+    def do_activate(self, event, widget, path, background_area, cell_area,
                     flags):
         pass
 
-    def on_start_editing(self, event, widget, path, background_area, cell_area,
+    def do_start_editing(self, event, widget, path, background_area, cell_area,
                          flags):
         pass
 
-    def _is_prelit(self, tree_view):
-        x, y = tree_view.get_pointer()
-        x, y = tree_view.convert_widget_to_bin_window_coords(x, y)
-        pos = tree_view.get_path_at_pos(x, y)
+    def _point_in_cell_renderer(self, tree_view, x=None, y=None):
+        """Check if the point with coordinates x, y is inside this icon.
+
+        If the x, y coordinates are not given, they are taken from the
+        pointer current position.
+
+        """
+        if x is None and y is None:
+            x, y = tree_view.get_pointer()
+            x, y = tree_view.convert_widget_to_bin_window_coords(x, y)
+        pos = tree_view.get_path_at_pos(int(x), int(y))
         if pos is None:
             return False
 
-        path_, column, x, y = pos
+        path_, column, x, y_ = pos
 
-        for cell_renderer in column.get_cell_renderers():
+        for cell_renderer in column.get_cells():
             if cell_renderer == self:
                 cell_x, cell_width = column.cell_get_position(cell_renderer)
                 if x > cell_x and x < (cell_x + cell_width):
@@ -770,8 +994,30 @@ class CellRendererIcon(gtk.GenericCellRenderer):
 
         return False
 
-    def on_render(self, window, widget, background_area, cell_area,
-            expose_area, flags):
+    def do_render(self, cr, widget, background_area, cell_area, flags):
+        context = widget.get_style_context()
+        context.save()
+        context.add_class("sugar-icon-cell")
+
+        pointer_inside = self._point_in_cell_renderer(widget)
+
+        # The context will have prelight state if the mouse pointer is
+        # in the entire row, but we want that state if the pointer is
+        # in this cell only:
+        if flags & Gtk.CellRendererState.PRELIT:
+            if pointer_inside:
+                if self._active_state:
+                    context.set_state(Gtk.StateFlags.ACTIVE)
+            else:
+                context.set_state(Gtk.StateFlags.NORMAL)
+
+
+        Gtk.render_background(context, cr, background_area.x, background_area.y,
+                              background_area.width, background_area.height)
+
+        Gtk.render_frame(context, cr, background_area.x, background_area.y,
+                         background_area.width, background_area.height)
+
         if self._xo_color is not None:
             stroke_color = self._xo_color.get_stroke_color()
             fill_color = self._xo_color.get_fill_color()
@@ -786,8 +1032,8 @@ class CellRendererIcon(gtk.GenericCellRenderer):
         has_prelit_colors = None not in [prelit_fill_color,
                                          prelit_stroke_color]
 
-        if flags & gtk.CELL_RENDERER_PRELIT and has_prelit_colors and \
-                self._is_prelit(widget):
+        if flags & Gtk.CellRendererState.PRELIT and has_prelit_colors and \
+                pointer_inside:
 
             self._buffer.fill_color = prelit_fill_color
             self._buffer.stroke_color = prelit_stroke_color
@@ -799,20 +1045,21 @@ class CellRendererIcon(gtk.GenericCellRenderer):
         if surface is None:
             return
 
-        xoffset, yoffset, width_, height_ = self.on_get_size(widget, cell_area)
+        xoffset, yoffset, width_, height_ = self.do_get_size(widget, cell_area)
 
         x = cell_area.x + xoffset
         y = cell_area.y + yoffset
 
-        cr = window.cairo_create()
         cr.set_source_surface(surface, math.floor(x), math.floor(y))
-        cr.rectangle(expose_area)
+        cr.rectangle(cell_area.x, cell_area.y, cell_area.width,
+                     cell_area.height)
+        cr.clip()
         cr.paint()
 
 
 def get_icon_state(base_name, perc, step=5):
     strength = round(perc / step) * step
-    icon_theme = gtk.icon_theme_get_default()
+    icon_theme = Gtk.IconTheme.get_default()
 
     while strength <= 100 and strength >= 0:
         icon_name = '%s-%03d' % (base_name, strength)
@@ -823,8 +1070,8 @@ def get_icon_state(base_name, perc, step=5):
 
 
 def get_icon_file_name(icon_name):
-    icon_theme = gtk.icon_theme_get_default()
-    info = icon_theme.lookup_icon(icon_name, gtk.ICON_SIZE_LARGE_TOOLBAR, 0)
+    icon_theme = Gtk.IconTheme.get_default()
+    info = icon_theme.lookup_icon(icon_name, Gtk.IconSize.LARGE_TOOLBAR, 0)
     if not info:
         return None
     filename = info.get_filename()
diff --git a/item.py b/item.py
index 9291e2d..f4f9676 100644
--- a/item.py
+++ b/item.py
@@ -18,21 +18,21 @@
 import logging
 logger = logging.getLogger('option')
 
-import gobject
-import gtk
+from gi.repository import GObject
+from gi.repository import Gtk
 
 import stock
 
 
-class Item(gobject.GObject):
-    __gsignals__ = {'activate': (gobject.SIGNAL_RUN_LAST,
-                                 gobject.TYPE_NONE,
+class Item(GObject.GObject):
+    __gsignals__ = {'activate': (GObject.SignalFlags.RUN_LAST,
+                                 None,
                                  tuple())}
     menuitem = None
     toolitem = None
 
     def __init__(self, stock_id=None, important=False):
-        gobject.GObject.__init__(self)
+        GObject.GObject.__init__(self)
         self._stock_id = stock_id
         self.accel_group = None
         self.important = important
@@ -51,7 +51,7 @@ class Item(gobject.GObject):
     def get_menu_item(self):
         sensitive = self.sensitive
         if stock.stock_items[self.stock_id]['has_icon'] is not None:
-            self.menuitem = gtk.ImageMenuItem()
+            self.menuitem = Gtk.ImageMenuItem()
             self.menuitem.set_label(stock.get_label(self.stock_id, False))
             self.menuitem.set_use_underline(True)
             self.menuitem.set_sensitive(sensitive)
@@ -59,7 +59,7 @@ class Item(gobject.GObject):
             self.setup_accelerator()
             self.setup_menu_icon()
         else:
-            self.menuitem = gtk.MenuItem(stock.get_label(self.stock_id, False))
+            self.menuitem = Gtk.MenuItem(stock.get_label(self.stock_id, False))
             self.menuitem.set_use_underline(True)
             self.menuitem.set_sensitive(sensitive)
             self.menuitem.connect('activate', self.activate_cb)
@@ -74,11 +74,11 @@ class Item(gobject.GObject):
         logger.debug(str(accelerator))
         if accelerator[1] > 0:
             self.menuitem.add_accelerator('activate',
-                            self.accel_group, accelerator[1], accelerator[0],
-                            gtk.ACCEL_VISIBLE)
+                            self.accel_group, accelerator[0], accelerator[1],
+                            Gtk.AccelFlags.VISIBLE)
 
     def get_tool_item(self):
-        self.toolitem = gtk.ToolButton()
+        self.toolitem = Gtk.ToolButton()
         self.setup_tool_icon()
         self.toolitem.connect('clicked', self.activate_cb)
         self.toolitem.set_sensitive(self.sensitive)
@@ -90,24 +90,27 @@ class Item(gobject.GObject):
         iconset = stock.stock_items[self.stock_id]['has_icon']
         if iconset is not None:
             try:
-                pixbuf = iconset.render_icon(mstyle, gtk.TEXT_DIR_NONE,
-                                             gtk.STATE_NORMAL,
-                                             gtk.ICON_SIZE_MENU)
-                image = gtk.image_new_from_pixbuf(pixbuf)
+                pixbuf = iconset.render_icon(mstyle, Gtk.TextDirection.NONE,
+                                             Gtk.StateType.NORMAL,
+                                             Gtk.IconSize.MENU,
+                                             self.menuitem,
+                                             None)
+                image = Gtk.Image.new_from_pixbuf(pixbuf)
                 self.menuitem.set_image(image)
             except Exception, err:
                 logger.debug(self.stock_id)
                 logger.error(err)
 
     def setup_tool_icon(self):
-        mstyle = self.menuitem.get_style()
+        mstyle = self.toolitem.get_style()
         iconset = stock.stock_items[self.stock_id]['has_icon']
         if iconset is not None:
             try:
-                pixbuf = iconset.render_icon(mstyle, gtk.TEXT_DIR_NONE,
-                                             gtk.STATE_NORMAL,
-                                             gtk.ICON_SIZE_LARGE_TOOLBAR)
-                image = gtk.image_new_from_pixbuf(pixbuf)
+                pixbuf = iconset.render_icon(mstyle, Gtk.TextDirection.NONE,
+                                             Gtk.StateType.NORMAL,
+                                             Gtk.IconSize.LARGE_TOOLBAR,
+                                             self.toolitem, None)
+                image = Gtk.Image.new_from_pixbuf(pixbuf)
                 image.show()
                 self.toolitem.set_icon_widget(image)
             except Exception, err:
diff --git a/itembox.py b/itembox.py
index b7ff60d..40133a3 100644
--- a/itembox.py
+++ b/itembox.py
@@ -1,7 +1,4 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-#
-# Copyright (C) 2012 S. Daniel Francis <francis@sugarlabs.org>
+# Copyright (C) 2012-2013 S. Daniel Francis <francis@sugarlabs.org>
 #
 # This program is free software; you can redistribute it and/or modify
 # it under the terms of the GNU General Public License as published by
@@ -18,15 +15,16 @@
 # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
 # MA 02110-1301, USA.
 
-import gtk
+from gi.repository import GObject
+from gi.repository import Gtk
 
 
-class ItemBox(gtk.VBox):
+class ItemBox(Gtk.VBox):
     def __init__(self, activity):
-        gtk.VBox.__init__(self)
+        GObject.GObject.__init__(self)
         self._parent = activity
-        self.menubar = gtk.MenuBar()
-        self.toolbar = gtk.Toolbar()
+        self.menubar = Gtk.MenuBar()
+        self.toolbar = Gtk.Toolbar()
         self.pack_start(self.menubar, False, True, 0)
         self.pack_start(self.toolbar, False, True, 0)
         self.menubar.show()
diff --git a/itemgroup.py b/itemgroup.py
index 3e4780e..a6d5608 100644
--- a/itemgroup.py
+++ b/itemgroup.py
@@ -1,7 +1,4 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-#
-# Copyright (C) 2012 S. Daniel Francis <francis@sugarlabs.org>
+# Copyright (C) 2012-2013 S. Daniel Francis <francis@sugarlabs.org>
 #
 # This program is free software; you can redistribute it and/or modify
 # it under the terms of the GNU General Public License as published by
@@ -18,18 +15,18 @@
 # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
 # MA 02110-1301, USA.
 
-import gobject
-import gtk
+from gi.repository import GObject
+from gi.repository import Gtk
 
 
-class ItemGroup(gobject.GObject):
+class ItemGroup(GObject.GObject):
     def __init__(self, box, name=None, icon=None):
-        gobject.GObject.__init__(self)
+        GObject.GObject.__init__(self)
         self.items = []
         self.first_important = True
-        self.item = gtk.MenuItem(name)
+        self.item = Gtk.MenuItem.new_with_mnemonic(name)
         box.menubar.append(self.item)
-        self.menu = gtk.Menu()
+        self.menu = Gtk.Menu()
         self.item.set_submenu(self.menu)
         self.menu.show()
         self.item.show()
@@ -44,7 +41,7 @@ class ItemGroup(gobject.GObject):
         self.menu.append(menuitem)
         if item.important:
             if self.first_important and len(self.toolbar):
-                separator = gtk.SeparatorToolItem()
+                separator = Gtk.SeparatorToolItem()
                 separator.show()
                 self.toolbar.insert(separator, -1)
             self.first_important = False
@@ -54,11 +51,11 @@ class ItemGroup(gobject.GObject):
         self.items.append(item)
 
     def append_separator(self, important=False):
-        menuitem = gtk.SeparatorMenuItem()
+        menuitem = Gtk.SeparatorMenuItem()
         menuitem.show()
         self.menu.append(menuitem)
         if important:
-            toolitem = gtk.SeparatorToolItem()
+            toolitem = Gtk.SeparatorToolItem()
             toolitem.show()
             self.toolbar.insert(toolitem, -1)
             return toolitem
@@ -72,11 +69,11 @@ class GhostGroup(ItemGroup):
 
 class SubGroup(ItemGroup):
     def __init__(self, group, name=None):
-        gobject.GObject.__init__(self)
+        GObject.GObject.__init__(self)
         self.items = []
-        self.item = gtk.MenuItem(name)
+        self.item = Gtk.MenuItem.new_with_mnemonic(name)
         group.menu.append(self.item)
-        self.menu = gtk.Menu()
+        self.menu = Gtk.Menu()
         self.item.set_submenu(self.menu)
         self.menu.show()
         self.item.show()
diff --git a/profile.py b/profile.py
index 2be2e4a..a5f51f8 100644
--- a/profile.py
+++ b/profile.py
@@ -1,7 +1,4 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-#
-# Copyright (C) 2012 S. Daniel Francis <francis@sugarlabs.org>
+# Copyright (C) 2012-2013 S. Daniel Francis <francis@sugarlabs.org>
 #
 # This program is free software; you can redistribute it and/or modify
 # it under the terms of the GNU General Public License as published by
@@ -21,13 +18,14 @@
 import os
 import pwd
 name = pwd.getpwuid(os.getuid()).pw_gecos
-import gtk
+from gi.repository import Gdk
 
 
-def get_fill_color(widget):
-    color = widget.get_style().mid[gtk.STATE_SELECTED]
-    return color
+def get_fill_color(widget=None):
+    #FIXME: Need to use StyleContext
+    # context.get_background_color(Gtk.StateFlags.SELECTED)
+    return Gdk.color_parse('green')
 
 
-def get_stroke_color(widget):
-    return widget.get_style().dark[gtk.STATE_SELECTED]
+def get_stroke_color(widget=None):
+    return Gdk.color_parse('blue')
diff --git a/radioitem.py b/radioitem.py
index 87b0e7e..61106e0 100644
--- a/radioitem.py
+++ b/radioitem.py
@@ -17,7 +17,7 @@
 
 import logging
 logger = logging.getLogger('toggleoption')
-import gtk
+from gi.repository import Gtk
 from toggleitem import ToggleItem
 
 import stock
@@ -30,17 +30,20 @@ class RadioItem(ToggleItem):
         self.group = group
 
     def get_menu_item(self):
-        self.menuitem = gtk.RadioMenuItem(self.group.menuitem if self.group !=
-                                              None else None,
-                                          stock.get_label(self.stock_id,
-                                                          False))
+        if not self.group:
+            self.menuitem = Gtk.RadioMenuItem.new([])
+        else:
+            self.menuitem = Gtk.RadioMenuItem.new_from_widget(self.group.menuitem)
+        self.menuitem.set_label(
+            stock.get_label(self.stock_id, False))
+        self.menuitem.set_use_underline(True)
         self.menuitem.set_active(self.default_value)
         self.menuitem.connect('toggled', self.toggled_cb)
         self.setup_accelerator()
         return self.menuitem
 
     def get_tool_item(self):
-        self.toolitem = gtk.RadioToolButton(self.group.toolitem
+        self.toolitem = Gtk.RadioToolButton(self.group.toolitem
                                             if self.group != None else None)
         self.setup_tool_icon()
         self.toolitem.set_active(self.default_value)
diff --git a/settingsitem.py b/settingsitem.py
index f4016ac..746c264 100644
--- a/settingsitem.py
+++ b/settingsitem.py
@@ -18,19 +18,19 @@
 import logging
 logger = logging.getLogger('option')
 
-import gobject
-import gtk
+from gi.repository import GObject
+from gi.repository import Gtk
 
 from item import Item
 
 
 class SettingsItem(Item):
-    __gsignals__ = {'closed': (gobject.SIGNAL_RUN_LAST, gobject.TYPE_NONE,
+    __gsignals__ = {'closed': (GObject.SignalFlags.RUN_LAST, None,
                                 tuple())}
 
     def __init__(self, parent=None, stock_id=None, important=False):
         Item.__init__(self, stock_id, important)
-        self.content = gtk.EventBox()
+        self.content = Gtk.EventBox()
         self.parent = parent
         # For toggleoptions
         self.active = True
@@ -41,10 +41,10 @@ class SettingsItem(Item):
                 title = self.tooltip
             else:
                 title = stock.get_title(self.stock_id)
-            dialog = gtk.Dialog(title, self.parent)
-            dialog.vbox.pack_start(self.content, True, True)
+            dialog = Gtk.Dialog(title, self.parent)
+            dialog.vbox.pack_start(self.content, True, True, 0)
             self.content.show()
-            dialog.add_button(gtk.STOCK_OK, gtk.RESPONSE_ACCEPT)
+            dialog.add_button(Gtk.STOCK_OK, Gtk.ResponseType.ACCEPT)
             dialog.run()
             dialog.vbox.remove(self.content)
             dialog.destroy()
diff --git a/settingsradioitem.py b/settingsradioitem.py
index b8c8a9f..26a3b65 100644
--- a/settingsradioitem.py
+++ b/settingsradioitem.py
@@ -1,7 +1,4 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-#
-# Copyright (C) 2012 S. Daniel Francis <francis@sugarlabs.org>
+# Copyright (C) 2012-2013 S. Daniel Francis <francis@sugarlabs.org>
 #
 # This program is free software; you can redistribute it and/or modify
 # it under the terms of the GNU General Public License as published by
@@ -21,14 +18,14 @@
 import logging
 logger = logging.getLogger('option')
 
-import gobject
+from gi.repository import GObject
 from radioitem import RadioItem
 from settingsitem import SettingsItem
 
 
 class SettingsRadioItem(SettingsItem, RadioItem):
-    __gsignals__ = {'toggled': (gobject.SIGNAL_RUN_LAST, gobject.TYPE_NONE,
-                                (gobject.TYPE_BOOLEAN,))}
+    __gsignals__ = {'toggled': (GObject.SignalFlags.RUN_LAST, None,
+                                (GObject.TYPE_BOOLEAN,))}
 
     def __init__(self, group, default_value=True, parent=None,
                  stock_id=None, important=False):
diff --git a/shortcontentitem.py b/shortcontentitem.py
index 1c757c7..7197b14 100644
--- a/shortcontentitem.py
+++ b/shortcontentitem.py
@@ -18,8 +18,8 @@
 import logging
 logger = logging.getLogger('option')
 
-import gobject
-import gtk
+from gi.repository import GObject
+from gi.repository import Gtk
 
 from item import Item
 import stock
@@ -29,12 +29,12 @@ class ShortContentItem(Item):
 
     def __init__(self, parent=None, stock_id=None, important=False):
         Item.__init__(self, stock_id, important)
-        self.content = gtk.EventBox()
+        self.content = Gtk.EventBox()
         self.parent = parent
         self.separator = None
 
     def get_tool_item(self):
-        self.toolitem = gtk.ToolItem()
+        self.toolitem = Gtk.ToolItem()
         self.toolitem.add(self.content)
         self.setup_tooltip()
         return self.toolitem
@@ -44,16 +44,15 @@ class ShortContentItem(Item):
             title = self.tooltip
         else:
             title = stock.get_label(self.stock_id)
-        window = gtk.Dialog(title, self.parent)
+        window = Gtk.Dialog(title, self.parent)
         window.set_modal(False)
         window.set_decorated(True)
-        window.set_has_separator(False)
         window.set_border_width(10)
         if self.toolitem:
             self.toolitem.remove(self.content)
             if self.separator:
                 self.separator.hide()
-        window.vbox.pack_start(self.content)
+        window.vbox.pack_start(self.content, True, True, 0)
         self.content.show()
         window.connect('delete-event', self.destroy_window)
         window.show()
diff --git a/stock.py b/stock.py
index 8e281c9..7b243fb 100644
--- a/stock.py
+++ b/stock.py
@@ -17,50 +17,49 @@
 
 import logging
 logger = logging.getLogger('stock')
-import gtk
-
-icon_factory = gtk.IconFactory()
+from gi.repository import Gtk
+from gi.repository import Gdk
 
+icon_factory = Gtk.IconFactory()
 stock_items = {}
 
 
 def register(name, label, accelerator, icon_name):
     if icon_name:
-        icon_source = gtk.IconSource()
+        icon_source = Gtk.IconSource()
         icon_source.set_icon_name(icon_name)
-        icon = gtk.IconSet()
+        icon = Gtk.IconSet()
         icon.add_source(icon_source)
         icon_factory.add(name, icon)
         icon_factory.add_default()
 
-    iconset = gtk.icon_factory_lookup_default(name)
-
+    iconset = Gtk.IconFactory.lookup_default(name)
     stock_items[name] = {'label': label,
                          'accelerator': accelerator,
                          'has_icon': iconset or None}
 
 
 def overwrite_stock(stock_id, new_accelerator):
-    info = list(gtk.stock_lookup(stock_id))
-    keyval, mask = gtk.accelerator_parse(new_accelerator)
-    info[2] = mask
-    info[3] = keyval
+    info = Gtk.stock_lookup(stock_id)
+    keyval, mask = Gtk.accelerator_parse(new_accelerator)
+    info.modifier = mask
+    info.keyval = keyval
     logger.debug(str(info))
-    gtk.stock_add([(info[0], info[1], info[2], info[3], info[4])])
+    Gtk.stock_add([info])
 
 # Here we overwrite the key accelerators for some stock ids.
 # Feel free to add here any other stock id if you need it at your activity,
 # and send us a patch.
 
-overwrite_stock(gtk.STOCK_SAVE_AS, '<Shift><Ctrl>S')
-overwrite_stock(gtk.STOCK_ZOOM_IN, '<Ctrl>plus')
-overwrite_stock(gtk.STOCK_ZOOM_OUT, '<Ctrl>minus')
-overwrite_stock(gtk.STOCK_ZOOM_100, '<Ctrl>0')
+overwrite_stock(Gtk.STOCK_SAVE_AS, '<Shift><Ctrl>S')
+overwrite_stock(Gtk.STOCK_ZOOM_IN, '<Ctrl>plus')
+overwrite_stock(Gtk.STOCK_ZOOM_OUT, '<Ctrl>minus')
+overwrite_stock(Gtk.STOCK_ZOOM_100, '<Ctrl>0')
 # Key accelerator will be F11 on desktops and <Alt>return on Sugar.
-overwrite_stock(gtk.STOCK_FULLSCREEN, 'F11')
-overwrite_stock(gtk.STOCK_ADD, '<Ctrl>A')
-overwrite_stock(gtk.STOCK_REMOVE, '<Shift>Delete')
-overwrite_stock(gtk.STOCK_SELECT_COLOR, '<Ctrl>L')
+overwrite_stock(Gtk.STOCK_FULLSCREEN, 'F11')
+overwrite_stock(Gtk.STOCK_ADD, '<Ctrl>A')
+overwrite_stock(Gtk.STOCK_REMOVE, '<Shift>Delete')
+overwrite_stock(Gtk.STOCK_SELECT_COLOR, '<Ctrl>L')
 
 
 def get_label(stock, underline=True):
@@ -72,16 +71,17 @@ def get_label(stock, underline=True):
 
 def get_accelerator(stock):
     accelerator = stock_items[stock]['accelerator']
-    return gtk.accelerator_parse(accelerator) if accelerator is not None \
-        else (0, 0)
+    return Gtk.accelerator_parse(accelerator) if accelerator is not None \
+        else (0, Gdk.ModifierType(0))
 
 
-for i in gtk.stock_list_ids():
+for i in Gtk.stock_list_ids():
     # I am very noisy
     # logger.debug(i)
-    info = gtk.stock_lookup(i)
-    iconset = gtk.icon_factory_lookup_default(i)
+    info = Gtk.stock_lookup(i)
+    iconset = Gtk.IconFactory.lookup_default(i)
     if info is not None:
-        stock_items[i] = {'label': info[1],
-                      'accelerator': gtk.accelerator_name(info[3], info[2]),
+        stock_items[i] = {'label': info.label,
+                      'accelerator': Gtk.accelerator_name(info.keyval,
+                                                          info.modifier),
                       'has_icon': iconset or None}
diff --git a/toggleitem.py b/toggleitem.py
index 80c6096..3e63d03 100644
--- a/toggleitem.py
+++ b/toggleitem.py
@@ -17,16 +17,16 @@
 
 import logging
 logger = logging.getLogger('toggleoption')
-import gobject
-import gtk
+from gi.repository import GObject
+from gi.repository import Gtk
 
 from item import Item
 import stock
 
 
 class ToggleItem(Item):
-    __gsignals__ = {'toggled': (gobject.SIGNAL_RUN_LAST, gobject.TYPE_NONE,
-                                (gobject.TYPE_BOOLEAN,))}
+    __gsignals__ = {'toggled': (GObject.SignalFlags.RUN_LAST, None,
+                                (GObject.TYPE_BOOLEAN,))}
 
     def __init__(self, default_value=True, stock_id=None, important=False):
         Item.__init__(self, stock_id, important)
@@ -34,7 +34,7 @@ class ToggleItem(Item):
         self.active = default_value
 
     def get_menu_item(self):
-        self.menuitem = gtk.CheckMenuItem(stock.get_label(self.stock_id,
+        self.menuitem = Gtk.CheckMenuItem.new_with_mnemonic(stock.get_label(self.stock_id,
                                                           False))
         self.menuitem.set_active(self.default_value)
         self.menuitem.connect('toggled', self.toggled_cb)
@@ -51,7 +51,7 @@ class ToggleItem(Item):
         self.emit('toggled', active)
 
     def get_tool_item(self):
-        self.toolitem = gtk.ToggleToolButton()
+        self.toolitem = Gtk.ToggleToolButton()
         self.setup_tool_icon()
         self.toolitem.set_active(self.default_value)
         self.toolitem.connect('toggled', self.toggled_cb)