Ticket #3772: cairo_gtk3__almost-ported.diff

activity/activity.info

@@ -1 +1 @@
 [Activity]
-name = Typing Turtle
-activity_version = 29
+name = Gtk3 Typing Turtle
+activity_version = 31
 host_version = 1
-bundle_id = org.laptop.community.TypingTurtle
+bundle_id = gtk3.TypingTurtle
 icon = Activity-typingturtle
 exec = sugar-activity typingturtle.TypingTurtle

balloongame.py

@@ -14 +14 @@
 # You should have received a copy of the GNU General Public License
 # along with Typing Turtle.  If not, see <http://www.gnu.org/licenses/>.
 
+import math
 import random, datetime
+
 from gettext import gettext as _
 
-import gobject, pygtk, gtk, pango
+from gi.repository import Gtk
+from gi.repository import Gdk
+from gi.repository import GObject
+from gi.repository import Pango
+from gi.repository import PangoCairo
 
 import medalscreen
 
@@ -38 +44 @@
         self.size = max(100, 50 + len(word) * 20) 
         self.color = random.choice(BALLOON_COLORS)
 
-class BalloonGame(gtk.VBox):
+class BalloonGame(Gtk.VBox):
     def __init__(self, lesson, activity):
-        gtk.VBox.__init__(self)
+        GObject.GObject.__init__(self)
         
         self.lesson = lesson
         self.activity = activity
         
         # Build title bar.
-        title = gtk.Label()
+        title = Gtk.Label()
         title.set_markup("<span size='20000'><b>" + lesson['name'] + "</b></span>")
         title.set_alignment(1.0, 0.0)
         
-        stoplabel = gtk.Label(_('Go Back'))
-        stopbtn =  gtk.Button()
+        stoplabel = Gtk.Label(label=_('Go Back'))
+        stopbtn =  Gtk.Button()
         stopbtn.add(stoplabel)
         stopbtn.connect('clicked', self.stop_cb)
         
-        hbox = gtk.HBox()
+        hbox = Gtk.HBox()
         hbox.pack_start(stopbtn, False, False, 10)
         hbox.pack_end(title, False, False, 10)
         
         # Build the game drawing area.
-        self.area = gtk.DrawingArea()
-        self.area.connect("expose-event", self.expose_cb)
+        self.area = Gtk.DrawingArea()
+        self.draw_cb_id = self.area.connect("draw", self.draw_cb)
 
         # Connect keyboard grabbing and releasing callbacks.        
         self.area.connect('realize', self.realize_cb)
         self.area.connect('unrealize', self.unrealize_cb)
 
         self.pack_start(hbox, False, False, 10)
-        self.pack_start(self.area, True, True)
+        self.pack_start(self.area, True, True, 0)
         
         self.show_all()
         
@@ -85 +91 @@
         self.finished = False
 
         # Start the animation loop running.        
-        self.update_timer = gobject.timeout_add(20, self.tick, priority=gobject.PRIORITY_HIGH_IDLE+30)
+        self.update_timer = GObject.timeout_add(20, self.tick, priority=GObject.PRIORITY_HIGH_IDLE+30)
     
     def realize_cb(self, widget):
-        self.activity.add_events(gtk.gdk.KEY_PRESS_MASK)
+        self.activity.add_events(Gdk.EventMask.KEY_PRESS_MASK)
         self.key_press_cb_id = self.activity.connect('key-press-event', self.key_cb)
 
         # Clear the mouse cursor. 
-        #pixmap = gtk.gdk.Pixmap(widget.window, 10, 10)
-        #color = gtk.gdk.Color()
-        #cursor = gtk.gdk.Cursor(pixmap, pixmap, color, color, 5, 5)
+        #pixmap = Gdk.Pixmap(widget.window, 10, 10)
+        #color = Gdk.Color()
+        #cursor = Gdk.Cursor.new(pixmap, pixmap, color, color, 5, 5)
         #widget.window.set_cursor(cursor)
         
     def unrealize_cb(self, widget):
@@ -103 +109 @@
     def stop_cb(self, widget):
         # Stop the animation loop.
         if self.update_timer:
-            gobject.source_remove(self.update_timer)
+            GObject.source_remove(self.update_timer)
         
         self.activity.pop_screen()
 
     def key_cb(self, widget, event):
         # Ignore hotkeys.
-        if event.state & (gtk.gdk.CONTROL_MASK | gtk.gdk.MOD1_MASK):
+        if event.get_state() & (Gdk.ModifierType.CONTROL_MASK | Gdk.ModifierType.MOD1_MASK):
             return False
 
         # Extract information about the key pressed.
-        key = gtk.gdk.keyval_to_unicode(event.keyval)
+        key = Gdk.keyval_to_unicode(event.keyval)
         if key != 0: key = unichr(key)
 
         if self.finished:
-            key_name = gtk.gdk.keyval_name(event.keyval)
+            key_name = Gdk.keyval_name(event.keyval)
             if key_name == 'Return':
                 self.activity.pop_screen()
 
@@ -156 +162 @@
     
     def tick(self):
         if self.finished:
-            return
+            return False
 
         self.bounds = self.area.get_allocation()
             
@@ -192 +198 @@
  
         return True
 
-    def draw_results(self, gc):
+    def draw_results(self, cr):
         # Draw background.
         w = self.bounds.width - 400
         h = self.bounds.height - 200
         x = self.bounds.width/2 - w/2
         y = self.bounds.height/2 - h/2
 
-        gc.foreground = self.area.get_colormap().alloc_color(50000,50000,50000)
-        self.area.window.draw_rectangle(gc, True, x, y, w, h)
-        gc.foreground = self.area.get_colormap().alloc_color(0,0,0)
-        self.area.window.draw_rectangle(gc, False, x, y, w, h)
+        cr.set_source_rgb(0.762, 0.762, 0.762)
+        cr.rectangle(x, y, w, h)
+        cr.fill()
 
-        # Draw text
-        gc.foreground = self.area.get_colormap().alloc_color(0,0,0)
+        cr.set_source_rgb(0, 0, 0)
+        cr.rectangle(x, y, w, h)
+        cr.stroke()
 
+        # Draw text
         title = _('You finished!') + '\n'
-        layout = self.area.create_pango_layout(title)
-        layout.set_font_description(pango.FontDescription('Serif Bold 16'))    
-        size = layout.get_size()
-        tx = x+w/2-(size[0]/pango.SCALE)/2
+
+        cr.set_source_rgb(0, 0, 0)
+        pango_layout = PangoCairo.create_layout(cr)
+        fd = Pango.FontDescription('Serif Bold')
+        fd.set_size(16 * Pango.SCALE)
+        pango_layout.set_font_description(fd)
+        pango_layout.set_text(title.encode('utf-8'),
+                              len(title.encode('utf-8')))
+        size = pango_layout.get_size()
+        tx = x + (w / 2) - (size[0] / Pango.SCALE) / 2
         ty = y + 100
-        self.area.window.draw_layout(gc, tx, ty, layout)
+        cr.move_to(tx, ty)
+        PangoCairo.update_layout(cr, pango_layout)
+        PangoCairo.show_layout(cr, pango_layout)
 
         report = ''
         report += _('Your score was %(score)d.') % { 'score': self.score } + '\n'
@@ -222 +237 @@
         report += '\n'
         report += _('Press the ENTER key to continue.')
     
-        layout = self.area.create_pango_layout(report)
-        layout.set_font_description(pango.FontDescription('Times 12'))    
-        size = layout.get_size()
-        tx = x+w/2-(size[0]/pango.SCALE)/2
-        ty = y + 200
-        self.area.window.draw_layout(gc, tx, ty, layout)
+        cr.set_source_rgb(0, 0, 0)
+        pango_layout = PangoCairo.create_layout(cr)
+        fd = Pango.FontDescription('Times')
+        fd.set_size(12 * Pango.SCALE)
+        pango_layout.set_font_description(fd)
+        pango_layout.set_text(report, len(report))
+        size = pango_layout.get_size()
+        sx = x + w / 2 - (size[0] / Pango.SCALE) / 2
+        sy = y + 200
+        cr.move_to(sx, sy)
+        PangoCairo.update_layout(cr, pango_layout)
+        PangoCairo.show_layout(cr, pango_layout)
 
     def finish_game(self):
         self.finished = True
@@ -290 +311 @@
         h = int(b.size*1.5 + 10)
         self.area.queue_draw_area(x, y, w, h)
 
-    def draw_balloon(self, gc, b):
+    def draw_balloon(self, cr, b):
         x = int(b.x)
         y = int(b.y)
-        
+
         # Draw the string.
-        gc.foreground = self.area.get_colormap().alloc_color(0,0,0)
-        self.area.window.draw_line(gc, 
-            int(b.x), int(b.y+b.size/2), 
-            int(b.x), int(b.y+b.size))
-        
+        cr.set_source_rgb(0, 0, 0)
+        cr.move_to(int(b.x), int(b.y + b.size / 2))
+        cr.line_to(int(b.x), int(b.y + b.size))
+        cr.stroke()
+
         # Draw the balloon.
-        gc.foreground = self.area.get_colormap().alloc_color(b.color[0],b.color[1],b.color[2])
-        self.area.window.draw_arc(gc, True, x-b.size/2, y-b.size/2, b.size, b.size, 0, 360*64)
-    
-        # Draw the text.
-        gc.foreground = self.area.get_colormap().alloc_color(0,0,0)
-        layout = self.area.create_pango_layout(b.word)
-        layout.set_font_description(pango.FontDescription('Sans 12'))    
-        size = layout.get_size()
-        tx = x-(size[0]/pango.SCALE)/2
-        ty = y-(size[1]/pango.SCALE)/2
-        self.area.window.draw_layout(gc, tx, ty, layout)
-    
+        cr.save()
+        cr.set_source_rgb(b.color[0], b.color[1], b.color[2])
+        cr.arc(b.x, b.y, b.size / 2, 0, 2 * math.pi)
+        cr.fill()
+        cr.restore()
+
+        cr.set_source_rgb(0, 0, 0)
+
+        pango_layout = PangoCairo.create_layout(cr)
+        fd = Pango.FontDescription('Sans')
+        fd.set_size(12 * Pango.SCALE)
+        pango_layout.set_font_description(fd)
+        pango_layout.set_text(b.word, len(b.word))
+        size = pango_layout.get_size()
+        x = x - (size[0] / Pango.SCALE) / 2
+        y = y - (size[1] / Pango.SCALE) / 2
+        cr.move_to(x, y)
+        PangoCairo.update_layout(cr, pango_layout)
+        PangoCairo.show_layout(cr, pango_layout)
+
     def add_score(self, num):
         self.score += num
         self.queue_draw_score()
 
     def queue_draw_score(self):
         layout = self.area.create_pango_layout(_('SCORE: %d') % self.score)
-        layout.set_font_description(pango.FontDescription('Times 14'))    
+        layout.set_font_description(Pango.FontDescription('Times 14'))
         size = layout.get_size()
-        x = self.bounds.width-20-size[0]/pango.SCALE
+        x = self.bounds.width-20-size[0]/Pango.SCALE
         y = 20
         self.queue_draw_area(x, y, x+size[0], y+size[1])
 
-    def draw_score(self, gc):
-        layout = self.area.create_pango_layout(_('SCORE: %d') % self.score)
-        layout.set_font_description(pango.FontDescription('Times 14'))    
-        size = layout.get_size()
-        x = self.bounds.width-20-size[0]/pango.SCALE
+    def draw_score(self, cr):
+        cr.set_source_rgb(0, 0, 0)
+        pango_layout = PangoCairo.create_layout(cr)
+        fd = Pango.FontDescription('Times')
+        fd.set_size(14 * Pango.SCALE)
+        pango_layout.set_font_description(fd)
+        text = _('SCORE: %d') % self.score
+        pango_layout.set_text(text, len(text))
+
+        size = pango_layout.get_size()
+        x = self.bounds.width - 20 - size[0] / Pango.SCALE
         y = 20
-        self.area.window.draw_layout(gc, x, y, layout)
+        cr.move_to(x, y)
+        PangoCairo.update_layout(cr, pango_layout)
+        PangoCairo.show_layout(cr, pango_layout)
 
-    def draw_instructions(self, gc):
+    def draw_instructions(self, cr):
         # Draw instructions.
-        gc.foreground = self.area.get_colormap().alloc_color(0,0,0)
-
-        layout = self.area.create_pango_layout(_('Type the words to pop the balloons!'))
-        layout.set_font_description(pango.FontDescription('Times 14'))    
-        size = layout.get_size()
-        x = (self.bounds.width - size[0]/pango.SCALE)/2
-        y = self.bounds.height-20 - size[1]/pango.SCALE 
-        self.area.window.draw_layout(gc, x, y, layout)
-
-    def draw(self):
+        cr.set_source_rgb(0, 0, 0)
+        pango_layout = PangoCairo.create_layout(cr)
+        pango_layout.set_font_description(Pango.FontDescription('Times 14'))
+        text = _('Type the words to pop the balloons!')
+        pango_layout.set_text(text, len(text))
+        size = pango_layout.get_size()
+        x = (self.bounds.width - size[0] / Pango.SCALE) / 2
+        y = self.bounds.height - 20 - size[1] / Pango.SCALE
+        cr.move_to(x, y)
+        PangoCairo.update_layout(cr, pango_layout)
+        PangoCairo.show_layout(cr, pango_layout)
+
+    def draw(self, cr):
         self.bounds = self.area.get_allocation()
 
-        gc = self.area.window.new_gc()
-        
         # Draw background.
-        gc.foreground = self.area.get_colormap().alloc_color(60000,60000,65535)
-        self.area.window.draw_rectangle(gc, True, 0, 0, self.bounds.width, self.bounds.height)
+        cr.set_source_rgb(0.915, 0.915, 1)
+        cr.rectangle(0, 0, self.bounds.width, self.bounds.height)
+        cr.fill()
 
         # Draw the balloons.
         for b in self.balloons:
-            self.draw_balloon(gc, b)
+            self.draw_balloon(cr, b)
 
         if self.finished:
-            self.draw_results(gc)
-
+            self.draw_results(cr)
         else:
-            self.draw_instructions(gc)
+            self.draw_instructions(cr)
 
-            self.draw_score(gc)
+            self.draw_score(cr)
 
-    def expose_cb(self, area, event):
-        self.draw()
+    def draw_cb(self, area, cr):
+        self.draw(cr)

editlessonlistscreen.py

@@ -22 +22 @@
 from port import json
 from port import chooser
 
-# Import PyGTK.
-import gobject, pygtk, gtk, pango
+from gi.repository import Gtk
+from gi.repository import GObject
 
 # Import Sugar UI modules.
-import sugar.activity.activity
-import sugar.graphics.style
-import sugar.graphics.alert
-import sugar.mime
-import sugar.datastore.datastore
+import sugar3.activity.activity
+import sugar3.graphics.style
+import sugar3.graphics.alert
+import sugar3.mime
+import sugar3.datastore.datastore
 
 # Import activity modules.
 import editlessonscreen
 
-class EditLessonListScreen(gtk.VBox):
+class EditLessonListScreen(Gtk.VBox):
     def __init__(self, activity, lessons):
-        gtk.VBox.__init__(self)
+        GObject.GObject.__init__(self)
 
         self.activity = activity
         self.lessons = lessons
 
         # Add the header.
-        title = gtk.Label()
+        title = Gtk.Label()
         title.set_markup("<span size='20000'><b>" + _("Edit Lessons") + "</b></span>")
         title.set_alignment(1.0, 0.0)
         
-        stoplabel = gtk.Label(_('Go Back'))
-        stopbtn = gtk.Button()
+        stoplabel = Gtk.Label(label=_('Go Back'))
+        stopbtn = Gtk.Button()
         stopbtn.add(stoplabel)
         stopbtn.connect('clicked', self.stop_clicked_cb)
        
-        titlebox = gtk.HBox()
+        titlebox = Gtk.HBox()
         titlebox.pack_start(stopbtn, False, False, 10)
         titlebox.pack_end(title, False, False, 10)
 
         # Add the lesson list.
-        self.treeview = gtk.TreeView()
+        self.treeview = Gtk.TreeView()
         self.treeview.set_rules_hint(True)
         self.treeview.set_enable_search(False)
 
@@ -66 +66 @@
 
         # Note that the only thing we store in our liststore is the lesson id.
         # All the actual data is in the lessons list.
-        self.liststore = gtk.ListStore(gobject.TYPE_INT)
+        self.liststore = Gtk.ListStore(GObject.TYPE_INT)
         self.treeview.set_model(self.liststore)
 
         # Construct the columns.
-        renderer = gtk.CellRendererText()
-        col = gtk.TreeViewColumn(_('Name'), renderer)
+        renderer = Gtk.CellRendererText()
+        col = Gtk.TreeViewColumn(_('Name'), renderer)
         col.set_cell_data_func(renderer, self.name_render_cb) 
         self.treeview.append_column(col)
 
-        renderer = gtk.CellRendererText()
-        col = gtk.TreeViewColumn(_('Description'), renderer)
+        renderer = Gtk.CellRendererText()
+        col = Gtk.TreeViewColumn(_('Description'), renderer)
         col.set_cell_data_func(renderer, self.description_render_cb) 
         col.set_expand(True)
         self.treeview.append_column(col)
 
-        renderer = gtk.CellRendererText()
-        col = gtk.TreeViewColumn(_('Type'), renderer)
+        renderer = Gtk.CellRendererText()
+        col = Gtk.TreeViewColumn(_('Type'), renderer)
         col.set_cell_data_func(renderer, self.type_render_cb) 
         col.set_expand(False)
         self.treeview.append_column(col)
 
-        scroll = gtk.ScrolledWindow()
-        scroll.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
+        scroll = Gtk.ScrolledWindow()
+        scroll.set_policy(Gtk.PolicyType.AUTOMATIC, Gtk.PolicyType.AUTOMATIC)
         scroll.add(self.treeview)
 
-        importlabel = gtk.Label(_('Import Lessons from Journal'))
-        self.importbtn = gtk.Button()
+        importlabel = Gtk.Label(label=_('Import Lessons from Journal'))
+        self.importbtn = Gtk.Button()
         self.importbtn.add(importlabel)
         self.importbtn.connect('clicked', self.import_clicked_cb)
         
-        exportlabel = gtk.Label(_('Export Lessons to Journal'))
-        self.exportbtn = gtk.Button()
+        exportlabel = Gtk.Label(label=_('Export Lessons to Journal'))
+        self.exportbtn = Gtk.Button()
         self.exportbtn.add(exportlabel)
         self.exportbtn.connect('clicked', self.export_clicked_cb)
         
-        exportlabel = gtk.Label(_('Save Lessons to Activity'))
-        self.defaultsbtn = gtk.Button()
+        exportlabel = Gtk.Label(label=_('Save Lessons to Activity'))
+        self.defaultsbtn = Gtk.Button()
         self.defaultsbtn.add(exportlabel)
         self.defaultsbtn.connect('clicked', self.set_default_clicked_cb)
         
-        self.addbtn = gtk.Button()
-        self.addbtn.add(sugar.graphics.icon.Icon(icon_name='list-add'))
+        self.addbtn = Gtk.Button()
+        self.addbtn.add(sugar3.graphics.icon.Icon(icon_name='list-add'))
         self.addbtn.connect('clicked', self.add_lesson_clicked_cb)
-        self.delbtn = gtk.Button()
-        self.delbtn.add(sugar.graphics.icon.Icon(icon_name='list-remove'))
+        self.delbtn = Gtk.Button()
+        self.delbtn.add(sugar3.graphics.icon.Icon(icon_name='list-remove'))
         self.delbtn.connect('clicked', self.del_lesson_clicked_cb)
         self.delbtn.set_sensitive(False)
-        self.moveupbtn = gtk.Button()
-        self.moveupbtn.add(sugar.graphics.icon.Icon(icon_name='go-up'))
+        self.moveupbtn = Gtk.Button()
+        self.moveupbtn.add(sugar3.graphics.icon.Icon(icon_name='go-up'))
         self.moveupbtn.connect('clicked', self.move_lesson_up_clicked_cb)
         self.moveupbtn.set_sensitive(False)
-        self.movedownbtn = gtk.Button()
-        self.movedownbtn.add(sugar.graphics.icon.Icon(icon_name='go-down'))
+        self.movedownbtn = Gtk.Button()
+        self.movedownbtn.add(sugar3.graphics.icon.Icon(icon_name='go-down'))
         self.movedownbtn.connect('clicked', self.move_lesson_down_clicked_cb)
         self.movedownbtn.set_sensitive(False)
 
-        btnbox = gtk.HBox()
+        btnbox = Gtk.HBox()
         btnbox.pack_start(self.importbtn, False, False, 10)
-        btnbox.pack_start(self.exportbtn, False, False)
+        btnbox.pack_start(self.exportbtn, False, False, 0)
         btnbox.pack_start(self.defaultsbtn, False, False, 10)
-        btnbox.pack_end(self.addbtn, False, False)
-        btnbox.pack_end(self.delbtn, False, False)
-        btnbox.pack_end(self.moveupbtn, False, False)
-        btnbox.pack_end(self.movedownbtn, False, False)
+        btnbox.pack_end(self.addbtn, False, False, 0)
+        btnbox.pack_end(self.delbtn, False, False, 0)
+        btnbox.pack_end(self.moveupbtn, False, False, 0)
+        btnbox.pack_end(self.movedownbtn, False, False, 0)
 
         self.pack_start(titlebox, False, False, 10)
-        self.pack_start(gtk.HSeparator(), False, False, 0)
+        self.pack_start(Gtk.Separator(orientation=Gtk.Orientation.HORIZONTAL), False, False, 0)
         self.pack_start(scroll, True, True, 10)
         self.pack_start(btnbox, False, False, 10)
 
@@ -197 +197 @@
         if len(self.lessons) > 1:
             path = self.treeview.get_cursor()[0]
             if path:
-                msg = sugar.graphics.alert.ConfirmationAlert()
+                msg = sugar3.graphics.alert.ConfirmationAlert()
                 msg.props.title = _('Delete Lesson?')
                 msg.props.msg = _('Deleting the lesson will erase the lesson content.')
         
                 def alert_response_cb(alert, response_id, self, id):
                     self.activity.remove_alert(alert)
-                    if response_id is gtk.RESPONSE_OK:
+                    if response_id is Gtk.ResponseType.OK:
                         self.lessons.pop(id)
                         del self.liststore[id]
                         self.treeview.get_selection().select_path(id)
@@ -294 +294 @@
     
     def export_clicked_cb(self, btn):
         # Create the new journal entry
-        fileObject = sugar.datastore.datastore.create()
+        fileObject = sugar3.datastore.datastore.create()
 
         meta = self.activity.metadata
         fileObject.metadata['title'] = meta['title'] + _(' (Exported Lessons)')
@@ -312 +312 @@
         finally:
             fd.close()
         
-        sugar.datastore.datastore.write(fileObject, transfer_ownership=True)
+        sugar3.datastore.datastore.write(fileObject, transfer_ownership=True)
         fileObject.destroy()
         del fileObject
 
     def set_default_clicked_cb(self, btn):
         code = locale.getdefaultlocale()[0] or 'en_US'
-        path = sugar.activity.activity.get_bundle_path() + '/lessons/%s.lessons' % code
+        path = sugar3.activity.activity.get_bundle_path() + '/lessons/%s.lessons' % code
         
         fd = open(path, 'w')
         
@@ -328 +328 @@
             
         finally:
             fd.close()
-            
- No newline at end of file
+            

editlessonscreen.py

@@ -20 +20 @@
 import logging, os, math, time, copy, locale, datetime, random, re
 from gettext import gettext as _
 
-# Import PyGTK.
-import gobject, pygtk, gtk, pango
+from gi.repository import Gtk
+from gi.repository import GObject
+from gi.repository import Pango
 
 # Import Sugar UI modules.
-import sugar.activity.activity
-import sugar.graphics.style
-import sugar.graphics.icon
+import sugar3.activity.activity
+import sugar3.graphics.style
+import sugar3.graphics.icon
 
 # Import lessonbuilder functions.
 import lessonbuilder
 
-class EditLessonScreen(gtk.VBox):
+class EditLessonScreen(Gtk.VBox):
     def __init__(self, activity, lesson):
-        gtk.VBox.__init__(self)
+        GObject.GObject.__init__(self)
         self.set_border_width(10)
 
         self.activity = activity
@@ -42 +43 @@
         self.in_build = False
         
         # Add the header.
-        title = gtk.Label()
+        title = Gtk.Label()
         title.set_markup("<span size='20000'><b>" + _("Edit a Lesson") + "</b></span>")
         title.set_alignment(1.0, 0.0)
         
-        stoplabel = gtk.Label(_('Go Back'))
-        stopbtn = gtk.Button()
+        stoplabel = Gtk.Label(label=_('Go Back'))
+        stopbtn = Gtk.Button()
         stopbtn.add(stoplabel)
         stopbtn.connect('clicked', self.stop_clicked_cb)
                
-        titlebox = gtk.HBox()
+        titlebox = Gtk.HBox()
         titlebox.pack_start(stopbtn, False, False, 10)
         titlebox.pack_end(title, False, False, 10)
 
-        self.vp = gtk.Viewport()
+        self.vp = Gtk.Viewport()
 
-        self.scroll = gtk.ScrolledWindow()
-        self.scroll.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
+        self.scroll = Gtk.ScrolledWindow()
+        self.scroll.set_policy(Gtk.PolicyType.AUTOMATIC, Gtk.PolicyType.AUTOMATIC)
         self.scroll.add(self.vp)
 
         self.pack_start(titlebox, False, False, 10)
-        self.pack_start(gtk.HSeparator(), False, False, 0)
+        self.pack_start(Gtk.Separator(orientation=Gtk.Orientation.HORIZONTAL), False, False, 0)
         self.pack_start(self.scroll, True, True, 0)
 
         self.build()
@@ -70 +71 @@
         self.show_all()
 
     def build_generate(self):
-        generatebox = gtk.VBox()
+        generatebox = Gtk.VBox()
         generatebox.set_spacing(5)
 
-        newlabel = gtk.Label(_('New keys'))       
-        knownlabel = gtk.Label(_('Known keys'))
-        lengthlabel = gtk.Label(_('Length'))       
+        newlabel = Gtk.Label(label=_('New keys'))
+        knownlabel = Gtk.Label(label=_('Known keys'))
+        lengthlabel = Gtk.Label(label=_('Length'))
         
-        generatebox.newkeysent = gtk.Entry()
+        generatebox.newkeysent = Gtk.Entry()
         generatebox.newkeysent.set_width_chars(8)
-        generatebox.knownkeysent = gtk.Entry()
+        generatebox.knownkeysent = Gtk.Entry()
         generatebox.knownkeysent.set_width_chars(15)
-        generatebox.lengthent = gtk.Entry()
+        generatebox.lengthent = Gtk.Entry()
         generatebox.lengthent.set_width_chars(5)
         generatebox.lengthent.set_text('60')
         
-        oklabel = gtk.Label()
+        oklabel = Gtk.Label()
         oklabel.set_markup(_('Generate!'))
-        okbtn = gtk.Button()
+        okbtn = Gtk.Button()
         okbtn.add(oklabel)
         okbtn.connect('clicked', self.generate_ok_clicked_cb, generatebox)
         okbtn.set_alignment(0.5, 0.5)
 
-        box = gtk.HBox()
+        box = Gtk.HBox()
         box.set_spacing(10)
-        box.pack_start(newlabel, expand=False)
-        box.pack_start(generatebox.newkeysent, expand=False)
-        box.pack_start(knownlabel, expand=False)
-        box.pack_start(generatebox.knownkeysent, expand=False)
-        box.pack_start(lengthlabel, expand=False)
-        box.pack_start(generatebox.lengthent, expand=False)
-        box.pack_end(okbtn, expand=False)
+        box.pack_start(newlabel, False, True, 0)
+        box.pack_start(generatebox.newkeysent, False, True, 0)
+        box.pack_start(knownlabel, False, True, 0)
+        box.pack_start(generatebox.knownkeysent, False, True, 0)
+        box.pack_start(lengthlabel, False, True, 0)
+        box.pack_start(generatebox.lengthent, False, True, 0)
+        box.pack_end(okbtn, False, True, 0)
         box.show_all()
         
-        wordslabel = gtk.Label()
+        wordslabel = Gtk.Label()
         wordslabel.set_markup(_('Edit Word List'))
-        wordsbtn = gtk.Button()
+        wordsbtn = Gtk.Button()
         wordsbtn.add(wordslabel)
         wordsbtn.connect('clicked', self.generate_words_clicked_cb)
         wordsbtn.set_alignment(0.5, 0.5)
 
-        generatebox.pack_start(box)
-        generatebox.pack_start(wordsbtn, expand=False, fill=False)               
+        generatebox.pack_start(box, True, True, 0)
+        generatebox.pack_start(wordsbtn, expand=False, fill=False, padding=0)
         
         return generatebox
 
     def build_step(self, step, idx):
-        stepbox = gtk.VBox()
+        stepbox = Gtk.VBox()
         stepbox.set_spacing(5)
 
-        steplabel = gtk.Label()
+        steplabel = Gtk.Label()
         steplabel.set_markup("<span size='x-large' weight='bold'>" + (_('Step #%d') % (idx+1)) + "</span>")
         steplabel.set_alignment(0.0, 0.5)
         steplabel.set_padding(10, 0)
 
         # Build the step type combo box.
-        stepbox.typecombo = gtk.combo_box_new_text()
+        stepbox.typecombo = Gtk.ComboBoxText()
         stepbox.typecombo.append_text(_('Keys'))
         stepbox.typecombo.append_text(_('Words'))
 
@@ -136 +137 @@
             stepbox.typecombo.set_active(1)
         
         # Build the tool buttons.
-        delstepbtn = gtk.Button()
-        delstepbtn.add(sugar.graphics.icon.Icon(icon_name='list-remove'))
+        delstepbtn = Gtk.Button()
+        delstepbtn.add(sugar3.graphics.icon.Icon(icon_name='list-remove'))
         delstepbtn.connect('clicked', self.del_step_clicked_cb, idx)
-        addstepbtn = gtk.Button()
-        addstepbtn.add(sugar.graphics.icon.Icon(icon_name='list-add'))
+        addstepbtn = Gtk.Button()
+        addstepbtn.add(sugar3.graphics.icon.Icon(icon_name='list-add'))
         addstepbtn.connect('clicked', self.add_step_clicked_cb, idx)
-        moveupbtn = gtk.Button()
-        moveupbtn.add(sugar.graphics.icon.Icon(icon_name='go-up'))
+        moveupbtn = Gtk.Button()
+        moveupbtn.add(sugar3.graphics.icon.Icon(icon_name='go-up'))
         moveupbtn.connect('clicked', self.move_step_up_clicked_cb, idx)
-        movedownbtn = gtk.Button()
-        movedownbtn.add(sugar.graphics.icon.Icon(icon_name='go-down'))
+        movedownbtn = Gtk.Button()
+        movedownbtn.add(sugar3.graphics.icon.Icon(icon_name='go-down'))
         movedownbtn.connect('clicked', self.move_step_down_clicked_cb, idx)
 
         if idx == 0:
@@ -154 +155 @@
         if idx == len(self.lesson['steps']) - 1:
             movedownbtn.set_sensitive(False)
 
-        btnbox = gtk.HBox()
-        btnbox.pack_start(steplabel, False, False)
+        btnbox = Gtk.HBox()
+        btnbox.pack_start(steplabel, False, False, 0)
         btnbox.pack_start(stepbox.typecombo, expand=False, padding=10)
-        btnbox.pack_end(addstepbtn, False, False)
-        btnbox.pack_end(delstepbtn, False, False)
-        btnbox.pack_end(moveupbtn, False, False)
-        btnbox.pack_end(movedownbtn, False, False)
+        btnbox.pack_end(addstepbtn, False, False, 0)
+        btnbox.pack_end(delstepbtn, False, False, 0)
+        btnbox.pack_end(moveupbtn, False, False, 0)
+        btnbox.pack_end(movedownbtn, False, False, 0)
 
         # Build the instructions entry.
-        instlabel = gtk.Label()
+        instlabel = Gtk.Label()
         instlabel.set_markup("<span size='large' weight='bold'>" + _('Instructions') + "</span>")
         instlabel.set_alignment(0.0, 0.5)
         instlabel.set_padding(20, 0)
 
         self.labelsizegroup.add_widget(instlabel)
 
-        stepbox.insttext = gtk.TextView(gtk.TextBuffer())
-        stepbox.insttext.props.wrap_mode = gtk.WRAP_WORD
-        stepbox.insttext.modify_font(pango.FontDescription('Monospace'))
-        instscroll = gtk.ScrolledWindow()
-        instscroll.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
+        stepbox.insttext = Gtk.TextView(Gtk.TextBuffer())
+        stepbox.insttext.props.wrap_mode = Gtk.WrapMode.WORD
+        stepbox.insttext.modify_font(Pango.FontDescription('Monospace'))
+        instscroll = Gtk.ScrolledWindow()
+        instscroll.set_policy(Gtk.PolicyType.AUTOMATIC, Gtk.PolicyType.AUTOMATIC)
         instscroll.add(stepbox.insttext)
         instscroll.set_size_request(-1, 75)
         stepbox.insttext.get_buffer().set_text(step['instructions'])
 
-        instbox = gtk.HBox()
-        instbox.pack_start(instlabel, False, False)
-        instbox.pack_start(instscroll, True, True)
+        instbox = Gtk.HBox()
+        instbox.pack_start(instlabel, False, False, 0)
+        instbox.pack_start(instscroll, True, True, 0)
 
         # Build the text entry.
-        textlabel = gtk.Label()
+        textlabel = Gtk.Label()
         textlabel.set_markup("<span size='large' weight='bold'>" + _('Text') + "</span>")
         textlabel.set_alignment(0.0, 0.5)
         textlabel.set_padding(20, 0)
 
         self.labelsizegroup.add_widget(textlabel)
 
-        stepbox.texttext = gtk.TextView(gtk.TextBuffer())
-        stepbox.texttext.props.wrap_mode = gtk.WRAP_WORD
-        stepbox.texttext.modify_font(pango.FontDescription('monospace'))
-        textscroll = gtk.ScrolledWindow()
-        textscroll.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
+        stepbox.texttext = Gtk.TextView(Gtk.TextBuffer())
+        stepbox.texttext.props.wrap_mode = Gtk.WrapMode.WORD
+        stepbox.texttext.modify_font(Pango.FontDescription('monospace'))
+        textscroll = Gtk.ScrolledWindow()
+        textscroll.set_policy(Gtk.PolicyType.AUTOMATIC, Gtk.PolicyType.AUTOMATIC)
         textscroll.add(stepbox.texttext)
         textscroll.set_size_request(-1, 100)
         stepbox.texttext.get_buffer().set_text(step['text'])
 
-        textbox = gtk.HBox()
-        textbox.pack_start(textlabel, expand=False)
-        textbox.pack_start(textscroll)
+        textbox = Gtk.HBox()
+        textbox.pack_start(textlabel, False, True, 0)
+        textbox.pack_start(textscroll, True, True, 0)
 
-        sizegroup = gtk.SizeGroup(gtk.SIZE_GROUP_HORIZONTAL)   
+        sizegroup = Gtk.SizeGroup(Gtk.SizeGroupMode.HORIZONTAL)
         sizegroup.add_widget(instlabel)
         sizegroup.add_widget(textlabel)    
 
-        stepbox.pack_start(btnbox, expand=False)
-        stepbox.pack_start(instbox, expand=False)
-        stepbox.pack_start(textbox, expand=False)
+        stepbox.pack_start(btnbox, False, True, 0)
+        stepbox.pack_start(instbox, False, True, 0)
+        stepbox.pack_start(textbox, False, True, 0)
         
         return stepbox
 
     def build_medal(self, medal, name):
-        box = gtk.HBox()
+        box = Gtk.HBox()
 
-        label = gtk.Label()
+        label = Gtk.Label()
         label.set_markup("<span size='large' weight='bold'>" + name + "</span>")
         label.set_alignment(0.0, 0.5)
         label.set_padding(20, 0)
 
         self.labelsizegroup.add_widget(label)
         
-        box.pack_start(label, False, False)
+        box.pack_start(label, False, False, 0)
 
         if self.lesson['type'] == 'normal':
-            acclabel = gtk.Label(_('Accuracy'))       
-            wpmlabel = gtk.Label(_('WPM'))
+            acclabel = Gtk.Label(label=_('Accuracy'))
+            wpmlabel = Gtk.Label(label=_('WPM'))
             
-            box.accent = gtk.Entry()
-            box.wpment = gtk.Entry()
+            box.accent = Gtk.Entry()
+            box.wpment = Gtk.Entry()
 
             box.accent.set_text(str(medal['accuracy']))
             box.wpment.set_text(str(medal['wpm']))
         
             box.pack_start(acclabel, False, False, 10)
-            box.pack_start(box.accent, False, False)
+            box.pack_start(box.accent, False, False, 0)
             box.pack_start(wpmlabel, False, False, 10)
-            box.pack_start(box.wpment, False, False)
+            box.pack_start(box.wpment, False, False, 0)
         
         elif self.lesson['type'] == 'balloon':
-            scorelabel = gtk.Label(_('Score'))
+            scorelabel = Gtk.Label(label=_('Score'))
             
-            box.scoreent = gtk.Entry()
+            box.scoreent = Gtk.Entry()
             box.scoreent.set_text(str(medal['score']))
         
             box.pack_start(scorelabel, False, False, 10)
-            box.pack_start(box.scoreent, False, False)
+            box.pack_start(box.scoreent, False, False, 0)
             
         return box
       
     def build(self):
         self.in_build = True
         
-        self.vbox = gtk.VBox()
+        self.vbox = Gtk.VBox()
         self.vbox.set_border_width(20)
         self.vbox.set_spacing(5)
         
-        self.labelsizegroup = gtk.SizeGroup(gtk.SIZE_GROUP_HORIZONTAL)   
+        self.labelsizegroup = Gtk.SizeGroup(Gtk.SizeGroupMode.HORIZONTAL)
 
         # Lesson details widgets.
-        detailslabel = gtk.Label()
+        detailslabel = Gtk.Label()
         detailslabel.set_markup("<span size='x-large'><b>" + _('Lesson Details') + "</b></span>")
         detailslabel.set_alignment(0.0, 0.5)
         detailslabel.set_padding(10, 0)
 
-        namelabel = gtk.Label()
+        namelabel = Gtk.Label()
         namelabel.set_markup("<span size='large' weight='bold'>" + _('Name') + "</span>")
         namelabel.set_alignment(0.0, 0.5)
         namelabel.set_padding(20, 0)
 
-        self.nameent = gtk.Entry()
+        self.nameent = Gtk.Entry()
         self.nameent.set_text(self.lesson['name'])
 
-        namebox = gtk.HBox()
-        namebox.pack_start(namelabel, expand=False)
-        namebox.pack_start(self.nameent)
+        namebox = Gtk.HBox()
+        namebox.pack_start(namelabel, False, True, 0)
+        namebox.pack_start(self.nameent, True, True, 0)
         
-        typelabel = gtk.Label()
+        typelabel = Gtk.Label()
         typelabel.set_markup("<span size='large' weight='bold'>" + _('Type') + "</span>")
         typelabel.set_alignment(0.0, 0.5)
         typelabel.set_padding(20, 0)
 
-        self.textradio = gtk.RadioButton(None, _('Normal Lesson'))
+        self.textradio = Gtk.RadioButton(None, _('Normal Lesson'))
         self.textradio.connect('toggled', self.type_toggled_cb)
         
-        self.balloonradio = gtk.RadioButton(self.textradio, _('Balloon Game'))
+        self.balloonradio = Gtk.RadioButton(self.textradio, _('Balloon Game'))
         self.balloonradio.connect('toggled', self.type_toggled_cb)
         
         self.textradio.set_active(self.lesson['type'] == 'normal')
         self.balloonradio.set_active(self.lesson['type'] == 'balloon')        
 
-        typebox = gtk.HBox()
-        typebox.pack_start(typelabel, expand=False)
-        typebox.pack_start(self.textradio, expand=False)
-        typebox.pack_start(self.balloonradio, expand=False)
+        typebox = Gtk.HBox()
+        typebox.pack_start(typelabel, False, True, 0)
+        typebox.pack_start(self.textradio, False, True, 0)
+        typebox.pack_start(self.balloonradio, False, True, 0)
         
-        desclabel = gtk.Label()
+        desclabel = Gtk.Label()
         desclabel.set_markup("<span size='large' weight='bold'>" + _('Description') + "</span>")
         desclabel.set_alignment(0.0, 0.5)
         desclabel.set_padding(20, 0)
 
-        self.desctext = gtk.TextView(gtk.TextBuffer())
-        self.desctext.props.wrap_mode = gtk.WRAP_WORD
-        descscroll = gtk.ScrolledWindow()
-        descscroll.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
+        self.desctext = Gtk.TextView(Gtk.TextBuffer())
+        self.desctext.props.wrap_mode = Gtk.WrapMode.WORD
+        descscroll = Gtk.ScrolledWindow()
+        descscroll.set_policy(Gtk.PolicyType.AUTOMATIC, Gtk.PolicyType.AUTOMATIC)
         descscroll.add(self.desctext)
         descscroll.set_size_request(-1, 75)
         self.desctext.get_buffer().set_text(self.lesson['description'])
 
-        descbox = gtk.HBox()
-        descbox.pack_start(desclabel, expand=False)
-        descbox.pack_start(descscroll)
+        descbox = Gtk.HBox()
+        descbox.pack_start(desclabel, False, True, 0)
+        descbox.pack_start(descscroll, True, True, 0)
 
         # Build the options.
-        optslabel = gtk.Label()
+        optslabel = Gtk.Label()
         optslabel.set_markup("<span size='large' weight='bold'>" + _('Options') + "</span>")
         optslabel.set_alignment(0.0, 0.5)
         optslabel.set_padding(20, 0)
 
-        self.mistakescheck = gtk.CheckButton(_('Allow Mistakes'))
+        self.mistakescheck = Gtk.CheckButton(_('Allow Mistakes'))
         self.mistakescheck.set_active(self.lesson.get('options', {}).get('mistakes', True))
-        self.backspacecheck = gtk.CheckButton(_('Allow Backspace'))
+        self.backspacecheck = Gtk.CheckButton(_('Allow Backspace'))
         self.backspacecheck.set_active(self.lesson.get('options', {}).get('backspace', True))
 
-        optsbox = gtk.HBox()
-        optsbox.pack_start(optslabel, expand=False)
-        optsbox.pack_start(self.backspacecheck, expand=False)
-        optsbox.pack_start(self.mistakescheck, expand=False)
+        optsbox = Gtk.HBox()
+        optsbox.pack_start(optslabel, False, True, 0)
+        optsbox.pack_start(self.backspacecheck, False, True, 0)
+        optsbox.pack_start(self.mistakescheck, False, True, 0)
             
         self.labelsizegroup.add_widget(namelabel)
         self.labelsizegroup.add_widget(typelabel)    
         self.labelsizegroup.add_widget(desclabel)    
         self.labelsizegroup.add_widget(optslabel)    
   
-        self.vbox.pack_start(detailslabel, expand=False)        
-        self.vbox.pack_start(namebox, expand=False)
-        self.vbox.pack_start(typebox, expand=False)
-        self.vbox.pack_start(descbox, expand=False)
-        self.vbox.pack_start(optsbox, expand=False)
+        self.vbox.pack_start(detailslabel, False, True, 0)
+        self.vbox.pack_start(namebox, False, True, 0)
+        self.vbox.pack_start(typebox, False, True, 0)
+        self.vbox.pack_start(descbox, False, True, 0)
+        self.vbox.pack_start(optsbox, False, True, 0)
 
         # Build the generator.
-        generatelabel = gtk.Label()
+        generatelabel = Gtk.Label()
         generatelabel.set_markup("<span size='x-large'><b>" + _('Automatic Lesson Generator') + "</b></span>")
         generatelabel.set_alignment(0.0, 0.5)
         generatelabel.set_padding(10, 0)
 
         generatebox = self.build_generate()
         self.vbox.pack_start(generatelabel, expand=False, padding=10)      
-        self.vbox.pack_start(generatebox, expand=False)       
+        self.vbox.pack_start(generatebox, False, True, 0)       
         
         self.has_normal_widgets = False
         self.has_balloon_widgets = False
@@ -369 +370 @@
                 stepbox = self.build_step(step, len(self.stepboxes))
                 self.stepboxes.append(stepbox)
                 
-                self.vbox.pack_start(stepbox, expand=False)
+                self.vbox.pack_start(stepbox, False, True, 0)
                 
         if self.lesson['type'] == 'balloon':
             self.has_balloon_widgets = True
@@ -377 +378 @@
             if not self.lesson.has_key('words') or len(self.lesson['words']) == 0:
                 self.lesson['words'] = []
             
-            textlabel = gtk.Label()
+            textlabel = Gtk.Label()
             textlabel.set_markup("<span size='large' weight='bold'>" + _('Words') + "</span>")
             textlabel.set_alignment(0.0, 0.5)
             textlabel.set_padding(20, 0)
 
             self.labelsizegroup.add_widget(textlabel)
 
-            self.wordstext = gtk.TextView(gtk.TextBuffer())
-            self.wordstext.props.wrap_mode = gtk.WRAP_WORD
-            self.wordstext.modify_font(pango.FontDescription('Monospace'))
-            textscroll = gtk.ScrolledWindow()
-            textscroll.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
+            self.wordstext = Gtk.TextView(Gtk.TextBuffer())
+            self.wordstext.props.wrap_mode = Gtk.WrapMode.WORD
+            self.wordstext.modify_font(Pango.FontDescription('Monospace'))
+            textscroll = Gtk.ScrolledWindow()
+            textscroll.set_policy(Gtk.PolicyType.AUTOMATIC, Gtk.PolicyType.AUTOMATIC)
             textscroll.add(self.wordstext)
             textscroll.set_size_request(-1, 200)
             self.wordstext.get_buffer().set_text(' '.join(self.lesson['words']))
     
-            textbox = gtk.HBox()
-            textbox.pack_start(textlabel, expand=False)
-            textbox.pack_start(textscroll)
+            textbox = Gtk.HBox()
+            textbox.pack_start(textlabel, False, True, 0)
+            textbox.pack_start(textscroll, True, True, 0)
             
-            self.vbox.pack_start(textbox, expand=False)
+            self.vbox.pack_start(textbox, False, True, 0)
 
         # Medal requirements widgets.
-        medalslabel = gtk.Label()
+        medalslabel = Gtk.Label()
         medalslabel.set_markup("<span size='x-large'><b>" + _('Medal Requirements') + "</b></span>")
         medalslabel.set_alignment(0.0, 0.5)
         medalslabel.set_padding(10, 0)
@@ -412 +413 @@
         self.medalboxes.append(self.build_medal(self.lesson['medals'][1], _('Silver')))
         self.medalboxes.append(self.build_medal(self.lesson['medals'][2], _('Gold')))
         
-        self.vbox.pack_start(self.medalboxes[0], expand=False)
-        self.vbox.pack_start(self.medalboxes[1], expand=False)
-        self.vbox.pack_start(self.medalboxes[2], expand=False)
+        self.vbox.pack_start(self.medalboxes[0], False, True, 0)
+        self.vbox.pack_start(self.medalboxes[1], False, True, 0)
+        self.vbox.pack_start(self.medalboxes[2], False, True, 0)
 
         self.vbox.show_all()
         
@@ -555 +556 @@
     def generate_words_clicked_cb(self, btn):
         self.activity.push_screen(WordListScreen(self.activity))
 
-class WordListScreen(gtk.VBox):
+class WordListScreen(Gtk.VBox):
     def __init__(self, activity):
-        gtk.VBox.__init__(self)
+        GObject.GObject.__init__(self)
         self.set_border_width(10)
 
         self.activity = activity
         
         # Add the header.
-        title = gtk.Label()
+        title = Gtk.Label()
         title.set_markup("<span size='20000'><b>" + _("Edit Word List") + "</b></span>")
         title.set_alignment(1.0, 0.0)
         
-        stoplabel = gtk.Label(_('Go Back'))
-        stopbtn = gtk.Button()
+        stoplabel = Gtk.Label(label=_('Go Back'))
+        stopbtn = Gtk.Button()
         stopbtn.add(stoplabel)
         stopbtn.connect('clicked', self.stop_clicked_cb)
        
-        titlebox = gtk.HBox()
+        titlebox = Gtk.HBox()
         titlebox.pack_start(stopbtn, False, False, 10)
         titlebox.pack_end(title, False, False, 10)
 
-        subtitle = gtk.Label()
+        subtitle = Gtk.Label()
         subtitle.set_markup("<span size='10000'>" + _("Type or paste words here, for the Automatic Lesson Generator.  If empty, the dictionary will be used.") + "</span>")
         subtitle.set_alignment(1.0, 0.0)
 
-        self.wordlisttext = gtk.TextView(gtk.TextBuffer())
-        self.wordlisttext.props.wrap_mode = gtk.WRAP_WORD
-        wordlistscroll = gtk.ScrolledWindow()
-        wordlistscroll.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
+        self.wordlisttext = Gtk.TextView(Gtk.TextBuffer())
+        self.wordlisttext.props.wrap_mode = Gtk.WrapMode.WORD
+        wordlistscroll = Gtk.ScrolledWindow()
+        wordlistscroll.set_policy(Gtk.PolicyType.AUTOMATIC, Gtk.PolicyType.AUTOMATIC)
         wordlistscroll.add(self.wordlisttext)
         wordlistscroll.set_size_request(-1, 75)
         self.wordlisttext.get_buffer().set_text(' '.join(self.activity.wordlist))
 
-        self.pack_start(titlebox, expand=False)
-        self.pack_start(subtitle, expand=False)
-        self.pack_start(gtk.HSeparator(), expand=False)
-        self.pack_start(wordlistscroll)
+        self.pack_start(titlebox, False, True, 0)
+        self.pack_start(subtitle, False, True, 0)
+        self.pack_start(Gtk.Separator(orientation=Gtk.Orientation.HORIZONTAL), expand=False, padding=0)
+        self.pack_start(wordlistscroll, True, True, 0)
         
         self.show_all()
 

keyboard.py

@@ -16 +16 @@
 #!/usr/bin/env python
 # vi:sw=4 et 
 
-import pygtk
-pygtk.require('2.0')
-import gtk
-import rsvg
+import cairo
+import copy
 import os, glob, re
-import pango
+
+from gi.repository import Gtk
+from gi.repository import Pango
+from gi.repository import PangoCairo
+from gi.repository import Gdk
+from gi.repository import GObject
+from gi.repository import GdkPixbuf
+from gi.repository import Rsvg
+
+import StringIO
 from port import json
 import subprocess
 from layouts.olpc import OLPC_LAYOUT
@@ -125 +132 @@
 
         # This is for not changing all the numbers of olpcm layout,
         # that was made based on the original olpc layout.
+
+        # FIXME FIXME
         scale_width = self.width
         if _is_olpcm_model():
             scale_width = int(scale_width * 1.1625)
 
         for filename in glob.iglob('images/OLPC*.svg'):
-            image = gtk.gdk.pixbuf_new_from_file_at_scale(filename, scale_width,
-                                                          self.height, False)
+            image = Rsvg.Handle.new_from_file(filename)
             name = os.path.basename(filename)
             self.images[name] = image
 
@@ -144 +152 @@
         self.letter_map = {}
         
         # Access the current GTK keymap.
-        self.keymap = gtk.gdk.keymap_get_default()
+        self.keymap = Gdk.Keymap.get_default()
 
     def set_layout(self, layout): 
         self._build_key_list(layout)
@@ -234 +242 @@
 
     def format_key_sig(self, scan, state, group):
         sig = 'scan%d' % scan
-        if state & gtk.gdk.SHIFT_MASK:
+        if state & Gdk.ModifierType.SHIFT_MASK:
             sig += ' shift'
-        if state & gtk.gdk.MOD5_MASK:
+        if state & Gdk.ModifierType.MOD5_MASK:
             sig += ' altgr'
         if group != 0:
             sig += ' group%d' % group
@@ -249 +257 @@
 
         state = 0
         if m.group('shift'):
-            state |= gtk.gdk.SHIFT_MASK
+            state |= Gdk.ModifierType.SHIFT_MASK
         if m.group('altgr'):
-            state |= gtk.gdk.MOD5_MASK
+            state |= Gdk.ModifierType.MOD5_MASK
 
         scan = int(m.group('scan'))
 
@@ -277 +285 @@
         best_result = None
         
         for sig, l in self.letter_map.items():
-            if unicode(l) == unicode(letter):
+            if l == letter:
                 scan, state, group = self.parse_key_sig(sig)
                 
                 # Choose the key with the fewest modifiers.
                 score = 0
-                if state & gtk.gdk.SHIFT_MASK: score += 1
-                if state & gtk.gdk.MOD5_MASK: score += 1
+                if state & Gdk.ModifierType.SHIFT_MASK: score += 1
+                if state & Gdk.ModifierType.MOD5_MASK: score += 1
                 if score < best_score:
                     best_score = score
                     best_result = scan, state, group
@@ -294 +302 @@
                     return k, best_result[1], best_result[2]
 
         # Try the GDK keymap.
-        keyval = gtk.gdk.unicode_to_keyval(ord(letter))
-        entries = self.keymap.get_entries_for_keyval(keyval)
+        keyval = Gdk.unicode_to_keyval(ord(letter))
+        valid, entries = self.keymap.get_entries_for_keyval(keyval)
         for e in entries:
             for k in self.keys:
-                if k['key-scan'] == e[0]:
+                if k['key-scan'] == e.keycode:
                     # TODO: Level -> state calculations are hardcoded to what the XO keyboard does.
                     # They were discovered through experimentation.
                     state = 0
-                    if e[2] & 1: 
-                        state |= gtk.gdk.SHIFT_MASK
-                    if e[2] & 2: 
-                        state |= gtk.gdk.MOD5_MASK
-                    return k, state, e[1]
+                    if e.level & 1:
+                        state |= Gdk.ModifierType.SHIFT_MASK
+                    if e.level & 2:
+                        state |= Gdk.ModifierType.MOD5_MASK
+                    return k, state, e.group
 
         # Fail!
         return None, None, None
@@ -316 +324 @@
         if self.letter_map.has_key(sig):
             return self.letter_map[sig]
         else:
-            t = self.keymap.translate_keyboard_state(key['key-scan'], self.active_state, self.active_group)
-            if t:
-                return unichr(gtk.gdk.keyval_to_unicode(t[0]))
+            success, keyval, effective_group, level, consumed_modifiers = \
+                self.keymap.translate_keyboard_state(
+                    key['key-scan'], self.active_state, self.active_group)
+            if success:
+                return unichr(Gdk.keyval_to_unicode(keyval)).encode('utf-8')
 
         return ''
 
-class KeyboardWidget(KeyboardData, gtk.DrawingArea):
+class KeyboardWidget(KeyboardData, Gtk.DrawingArea):
     """A GTK widget which implements an interactive visual keyboard, with support
        for custom data driven layouts."""
 
     def __init__(self, image, root_window, poll_keys=False):
         KeyboardData.__init__(self)
-        gtk.DrawingArea.__init__(self)
+        GObject.GObject.__init__(self)
         
         self.image = image
         self.root_window = root_window
@@ -336 +346 @@
         # Match the image cache in dimensions.
         self.set_size_request(image.width, image.height)
 
-        self.connect("expose-event", self._expose_cb)
+        self.connect("draw", self._draw_cb)
         
-        #self.modify_font(pango.FontDescription('Monospace 10'))
+        #self.modify_font(Pango.FontDescription('Monospace 10'))
         
         # Active language group and modifier state.
         # See http://www.pygtk.org/docs/pygtk/class-gdkkeymap.html for more
@@ -353 +363 @@
         
         self.draw_hands = False
         
-        self.modify_bg(gtk.STATE_NORMAL, self.get_colormap().alloc_color('#d0d0d0'))
+        self.modify_bg(Gtk.StateType.NORMAL, Gdk.Color.parse('#d0d0d0')[1])
 
         # Connect keyboard grabbing and releasing callbacks.        
         if poll_keys:
@@ -362 +372 @@
 
     def _realize_cb(self, widget):
         # Setup keyboard event snooping in the root window.
-        self.root_window.add_events(gtk.gdk.KEY_PRESS_MASK | gtk.gdk.KEY_RELEASE_MASK)
+        self.root_window.add_events(Gdk.EventMask.KEY_PRESS_MASK | Gdk.EventMask.KEY_RELEASE_MASK)
         self.key_press_cb_id = self.root_window.connect('key-press-event', self.key_press_release_cb)
         self.key_release_cb_id = self.root_window.connect('key-release-event', self.key_press_release_cb)
 
@@ -383 +393 @@
             k['key-width'] = int(k['key-width'] * width_scale)
             k['key-height'] = int(k['key-height'] * height_scale)
 
-        self._make_all_key_images()
-
-    def _make_key_images(self, key):
-        key['key-images'] = {}
-        for group in [0, 1]:
-            for state in [0, gtk.gdk.SHIFT_MASK, gtk.gdk.MOD5_MASK, gtk.gdk.SHIFT_MASK|gtk.gdk.MOD5_MASK]:
-                key['key-images'][(state, group)] = self.get_key_image(key, state, group)
+    def _draw_key(self, k, cr):
+        bounds = self.get_allocation()
 
-    def _make_all_key_images(self):
-        for key in self.keys:
-            self._make_key_images(key)
+        # HACK: this is a hack used when the widget is not shown yet,
+        # in that case bounds will be gtk.gdk.Rectangle(-1, -1, 1, 1)
+        # and the key will be outside the canvas. This is used only
+        # for the first key that appears below the instructions
+        if bounds.x == -1:
+            screen_x = screen_y = 0
+        else:
+            screen_x = int(bounds.width - self.image.width) / 2
+            screen_y = int(bounds.height - self.image.height) / 2
 
-    def _draw_key(self, k, draw, gc, for_pixmap, w=0, h=0):
-        x1 = 0 
-        y1 = 0
-        x2 = w
-        y2 = h
+        x1 = k['key-x'] + screen_x
+        y1 = k['key-y'] + screen_y
+        x2 = x1 + k['key-width']
+        y2 = y1 + k['key-height']
 
-        # Outline rounded box.
-        gc.foreground = self.get_colormap().alloc_color(int(0.4*65536),int(0.7*65536),int(0.4*65536))
-        
         corner = 5
         points = [
-            (x1 + corner, y1), 
+            (x1 + corner, y1),
             (x2 - corner, y1),
             (x2, y1 + corner),
             (x2, y2 - corner),
@@ -414 +421 @@
             (x1 + corner, y2),
             (x1, y2 - corner),
             (x1, y1 + corner)
-        ]
-        draw.draw_polygon(gc, True, points)
-        
-        # Inner text.
-        gc.foreground = self.get_colormap().alloc_color(int(1.0*65536),int(1.0*65536),int(1.0*65536))
+            ]
+
+        cr.new_path()
+        cr.set_source_rgb(0.396, 0.698, 0.392)
+        cr.set_line_width(2)
+        for point in points:
+            cr.line_to(*point)
+        cr.close_path()
+        cr.fill_preserve()
+        cr.stroke()
 
         text = ''
         if k['key-label']:
             text = k['key-label']
         else:
-            text = self.get_letter_for_key_state_group(k, self.active_state, self.active_group)
-        
-        try:
-            layout = self.create_pango_layout(unicode(text))
-            layout.set_font_description(pango.FontDescription('Monospace'))
-            draw.draw_layout(gc, x1+8, y2-23, layout)
-        except:
-            pass
-
-    def _expose_hands(self, gc):
+            text = self.get_letter_for_key_state_group(
+                k, self.active_state, self.active_group)
+
+        cr.set_source_rgb(0, 0, 0)
+        pango_layout = PangoCairo.create_layout(cr)
+        fd = Pango.FontDescription('Monospace')
+        fd.set_size(10 * Pango.SCALE)
+        pango_layout.set_font_description(fd)
+        pango_layout.set_text(text, len(text))
+
+        cr.move_to(x1 + 8, y2 - 23)
+        PangoCairo.update_layout(cr, pango_layout)
+        PangoCairo.show_layout(cr, pango_layout)
+
+    def _expose_hands(self, cr):
         lhand_image = self.image.images['OLPC_Lhand_HOMEROW.svg']
         rhand_image = self.image.images['OLPC_Rhand_HOMEROW.svg']
 
@@ -451 +468 @@
                         rhand_image = handle
 
                 # Put the other hand on the SHIFT key if needed.
-                if state & gtk.gdk.SHIFT_MASK:
+                if state & Gdk.ModifierType.SHIFT_MASK:
                     if finger[0] == 'L':
                         rhand_image = self.image.images['OLPC_Rhand_SHIFT.svg']
                     else:
@@ -460 +477 @@
                 # TODO: Do something about ALTGR.
 
         bounds = self.get_allocation()
-        screen_x = int(bounds.width-self.image.width)/2
-        screen_y = int(bounds.height-self.image.height)/2
-
-        self.window.draw_pixbuf(gc, lhand_image, 0, 0, screen_x, screen_y + HAND_YOFFSET)
-        self.window.draw_pixbuf(gc, rhand_image, 0, 0, screen_x, screen_y + HAND_YOFFSET)
-
-    def _expose_cb(self, area, event):
-        gc = self.window.new_gc()
-        
-        bounds = self.get_allocation()
-        screen_x = int(bounds.width-self.image.width)/2
-        screen_y = int(bounds.height-self.image.height)/2
 
+        cr.save()
+        xx = bounds.width / float(lhand_image.props.width)
+        yy = bounds.height / float(lhand_image.props.height)
+        # matrix = cairo.Matrix(xx=xx, yy=yy)
+        cr.scale(xx, yy)
+        lhand_image.set_dpi(250)
+        lhand_image.render_cairo(cr)
+
+        cr.restore()
+        xx = bounds.width / float(rhand_image.props.width)
+        yy = bounds.height / float(rhand_image.props.height)
+        # matrix = cairo.Matrix(xx=xx, yy=yy)
+        # cr.transform(matrix)
+        cr.scale(xx, yy)
+        rhand_image.render_cairo(cr)
+
+    def _draw_cb(self, area, cr):
         # Draw the keys.
         for k in self.keys:
-            x1 = k['key-x'] + screen_x
-            y1 = k['key-y'] + screen_y
-            x2 = x1 + k['key-width']
-            y2 = y1 + k['key-height']
-
-            # Index cached key images by state and group.
-            state = self.active_state & (gtk.gdk.SHIFT_MASK|gtk.gdk.MOD5_MASK)
-            index = (state, self.active_group)
-            image = k['key-images'].get(index)
-
-            if image:
-                self.window.draw_image(gc, image, 0, 0, x1, y1, x2-x1, y2-y1) 
-        
+            self._draw_key(k, cr)
+
         # Draw overlay images.
         if self.draw_hands:
-            self._expose_hands(gc)
-        
+            self._expose_hands(cr)
         return True
 
     def key_press_release_cb(self, widget, event):
         key = self.key_scan_map.get(event.hardware_keycode)
         if key:
-            key['key-pressed'] = event.type == gtk.gdk.KEY_PRESS
+            key['key-pressed'] = event.type == Gdk.EventType.KEY_PRESS
 
         # Hack to get the current modifier state - which will not be represented by the event.
-        state = gtk.gdk.device_get_core_pointer().get_state(self.window)[1]
+        # state = Gdk.device_get_core_pointer().get_state(self.get_window())[1]
 
-        if self.active_group != event.group or self.active_state != state:
+        if self.active_group != event.group or self.active_state != event.state:
             self.active_group = event.group
-            self.active_state = state
+            self.active_state = event.state
 
             self.queue_draw()
 
@@ -512 +522 @@
             sig = self.format_key_sig(event.hardware_keycode, event.state, event.group)
             if not self.letter_map.has_key(sig):
                 self.letter_map[sig] = event.string
-                self._make_key_images(key)
                 self.queue_draw()
 
         return False
 
-    def _keys_changed_cb(self, keymap):
-        self._make_key_images()
-
     def clear_hilite(self):
         self.hilite_letter = None
         self.queue_draw()
@@ -535 +541 @@
     def get_key_pixbuf(self, key, state=0, group=0, scale=1):
         w = int(key['key-width'] * scale)
         h = int(key['key-height'] * scale)
-        
+
         old_state, old_group = self.active_state, self.active_group
         self.active_state, self.active_group = state, group
-        
-        pixmap = gtk.gdk.Pixmap(self.root_window.window, w, h)
-        gc = pixmap.new_gc()
-        
-        gc.foreground = self.get_colormap().alloc_color('#d0d0d0')
-        pixmap.draw_rectangle(gc, True, 0, 0, w, h)
 
-        self._draw_key(key, pixmap, gc, True, w, h)
-        
-        pb = gtk.gdk.Pixbuf(gtk.gdk.COLORSPACE_RGB, False, 8, w, h)
-        pb.get_from_drawable(pixmap, self.root_window.window.get_colormap(), 0, 0, 0, 0,w, h)
-        
-        self.active_state, self.active_group = old_state, old_group
+        surface = cairo.ImageSurface(cairo.FORMAT_RGB24, w, h)
+        cr = cairo.Context(surface)
+        cr.set_source_rgb(1, 1, 1)
+        cr.rectangle(0, 0, w, h)
+        cr.fill()
 
-        return pb
+        # Duplicate the Key to be able to change its position values
+        key = copy.deepcopy(key)
+        key['key-x'] = 0
+        key['key-y'] = 0
 
-    def get_key_image(self, key, state=0, group=0, scale=1):
-        w = int(key['key-width'] * scale)
-        h = int(key['key-height'] * scale)
-        
-        old_state, old_group = self.active_state, self.active_group
-        self.active_state, self.active_group = state, group
-        
-        pixmap = gtk.gdk.Pixmap(self.root_window.window, w, h)
-        gc = pixmap.new_gc()
-        
-        gc.foreground = self.get_colormap().alloc_color('#d0d0d0')
-        pixmap.draw_rectangle(gc, True, 0, 0, w, h)
+        self._draw_key(key, cr)
+
+        # Convert cairo.Surface to Pixbuf
+        pixbuf_data = StringIO.StringIO()
+        surface.write_to_png(pixbuf_data)
+        pxb_loader = GdkPixbuf.PixbufLoader.new_with_type('png')
+        pxb_loader.write(pixbuf_data.getvalue())
+        temp_pix = pxb_loader.get_pixbuf()
+        pxb_loader.close()
 
-        self._draw_key(key, pixmap, gc, True, w, h)
-        
-        image = pixmap.get_image(0, 0, w, h)
-        
         self.active_state, self.active_group = old_state, old_group
 
-        return image
-    
+        return temp_pix

keybuilder.py

@@ -19 +19 @@
 import sys
 import keyboard
 
-import gtk
+from gi.repository import Gtk
 
-window = gtk.Window(gtk.WINDOW_TOPLEVEL)
+window = Gtk.Window(Gtk.WindowType.TOPLEVEL)
 window.set_title("keyboard widget")
-window.connect("destroy", lambda w: gtk.main_quit())
+window.connect("destroy", lambda w: Gtk.main_quit())
 window.show_all()
 window.realize()
 
@@ -37 +37 @@
     pass
 k.set_layout(keyboard.get_layout())
 
-savebtn = gtk.Button()
-savebtn.add(gtk.Label('Save Keys'))
+savebtn = Gtk.Button()
+savebtn.add(Gtk.Label(label='Save Keys'))
 savebtn.connect('clicked', lambda w: k.save_letter_map(sys.argv[1]))
 
-quitbtn = gtk.Button()
-quitbtn.add(gtk.Label('Quit'))
-quitbtn.connect('clicked', lambda w: gtk.main_quit())
+quitbtn = Gtk.Button()
+quitbtn.add(Gtk.Label(label='Quit'))
+quitbtn.connect('clicked', lambda w: Gtk.main_quit())
 
-hbox = gtk.HBox()
-hbox.pack_start(savebtn)
-hbox.pack_start(quitbtn)
+hbox = Gtk.HBox()
+hbox.pack_start(savebtn, True, True, 0)
+hbox.pack_start(quitbtn, True, True, 0)
 
-vbox = gtk.VBox()
-vbox.pack_start(k)
-vbox.pack_start(hbox)
+vbox = Gtk.VBox()
+vbox.pack_start(k, True, True, 0)
+vbox.pack_start(hbox, True, True, 0)
 
 window.add(vbox)
 window.show_all()
 
-gtk.main()
+Gtk.main()
 

lessonbuilder.py

@@ -21 +21 @@
 from port import json
 
 # For modifier constants.
-import gtk
+from gi.repository import Gtk
 
 # Set up remote debugging.
 #import dbgp.client
@@ -338 +338 @@
 #        except:
 #            error("The '%s' letter (scan code %x) does not have a finger assigned." % (letter, key['key-scan']))
 #
-#        if state == gtk.gdk.SHIFT_MASK:
+#        if state == Gdk.ModifierType.SHIFT_MASK:
 #            # Choose the finger to press the SHIFT key with.
 #            if key['key-finger'][0] == 'R':
 #                shift_finger = FINGERS['LP']
@@ -348 +348 @@
 #            instructions = _('Press and hold the SHIFT key with your %(finger)s finger, ') % { 'finger': shift_finger }
 #            instructions += _('then press the %(letter)s key with your %(finger)s finger.') % { 'letter': letter, 'finger': finger }
 #
-#        elif state == gtk.gdk.MOD5_MASK:
+#        elif state == Gdk.ModifierType.MOD5_MASK:
 #            instructions = _('Press and hold the ALTGR key, ') 
 #            instructions += _('then press the %(letter)s key with your %(finger)s finger.') % { 'letter': letter, 'finger': finger }
 #
-#        elif state == gtk.gdk.SHIFT_MASK | gtk.gdk.MOD5_MASK:
+#        elif state == Gdk.ModifierType.SHIFT_MASK | Gdk.ModifierType.MOD5_MASK:
 #            instructions = _('Press and hold the ALTGR and SHIFT keys, ')
 #            instructions += _('then press the %(letter)s key with your %(finger)s finger.') % { 'letter': letter, 'finger': finger }
 #

lessonscreen.py

@@ -19 +19 @@
 import logging, os, math, time, copy, locale, datetime, random, re
 from gettext import gettext as _
 
-# Import PyGTK.
-import gobject, pygtk, gtk, pango
+from gi.repository import Gtk
+from gi.repository import Gdk
+from gi.repository import GObject
 
 # Import Sugar UI modules.
-import sugar.activity.activity
-from sugar.graphics import *
+import sugar3.activity.activity
+from sugar3.graphics import *
 
 # Import activity modules.
 import keyboard, medalscreen
@@ -48 +49 @@
     'RT': _('right thumb'),
 }
 
-class LessonScreen(gtk.VBox):
+class LessonScreen(Gtk.VBox):
     def __init__(self, lesson, keyboard_images, activity):
-        gtk.VBox.__init__(self)
+        GObject.GObject.__init__(self)
         
         self.lesson = lesson
         self.keyboard_images = keyboard_images
         self.activity = activity
         
         # Build the user interface.
-        title = gtk.Label()
+        title = Gtk.Label()
         title.set_markup("<span size='x-large' weight='bold'>" + lesson['name'] + "</span>")
         title.set_alignment(1.0, 0.0)
         
-        stoplabel = gtk.Label(_('Go Back'))
-        stopbtn =  gtk.Button()
+        stoplabel = Gtk.Label(label=_('Go Back'))
+        stopbtn =  Gtk.Button()
         stopbtn.add(stoplabel)
         stopbtn.connect('clicked', self.stop_cb)
         
-        # TODO- These will be replaced by graphical displays using gtk.DrawingArea.
+        # TODO- These will be replaced by graphical displays using Gtk.DrawingArea.
         self.wpm = 0
         self.accuracy = 0
         
-        self.wpmlabel = gtk.Label()
-        self.accuracylabel = gtk.Label()
+        self.wpmlabel = Gtk.Label()
+        self.accuracylabel = Gtk.Label()
         
-        #self.wpmarea = gtk.DrawingArea()
+        #self.wpmarea = Gtk.DrawingArea()
         #self.wpmarea.connect('expose-event', self.wpm_expose_cb)
-        #self.accuracyarea = gtk.DrawingArea()
+        #self.accuracyarea = Gtk.DrawingArea()
         #self.accuracyarea.connect('expose-event', self.accuracy_expose_cb)
         
-        hbox = gtk.HBox()
+        hbox = Gtk.HBox()
         hbox.pack_start(stopbtn, False, False, 10)
         hbox.pack_start(self.wpmlabel, True, False, 10)
         hbox.pack_start(self.accuracylabel, True, False, 10)
         hbox.pack_end(title, False, False, 10)
         
         # Set up font styles.
-        self.tagtable = gtk.TextTagTable()
-        instructions_tag = gtk.TextTag('instructions')
-        instructions_tag.props.justification = gtk.JUSTIFY_CENTER
+        self.tagtable = Gtk.TextTagTable()
+        instructions_tag = Gtk.TextTag.new('instructions')
+        instructions_tag.props.justification = Gtk.Justification.CENTER
         self.tagtable.add(instructions_tag)
 
-        text_tag = gtk.TextTag('text')
+        text_tag = Gtk.TextTag.new('text')
         text_tag.props.family = 'Monospace'
         self.tagtable.add(text_tag)
         
-        spacer_tag = gtk.TextTag('spacer')
+        spacer_tag = Gtk.TextTag.new('spacer')
         spacer_tag.props.size = 3000
         self.tagtable.add(spacer_tag)
         
-        image_tag = gtk.TextTag('image')
-        image_tag.props.justification = gtk.JUSTIFY_CENTER
+        image_tag = Gtk.TextTag.new('image')
+        image_tag.props.justification = Gtk.Justification.CENTER
         self.tagtable.add(image_tag)
         
-        correct_copy_tag = gtk.TextTag('correct-copy')
+        correct_copy_tag = Gtk.TextTag.new('correct-copy')
         correct_copy_tag.props.family = 'Monospace'
         correct_copy_tag.props.foreground = '#0000ff'
         self.tagtable.add(correct_copy_tag)
         
-        incorrect_copy_tag = gtk.TextTag('incorrect-copy')
+        incorrect_copy_tag = Gtk.TextTag.new('incorrect-copy')
         incorrect_copy_tag.props.family = 'Monospace'
         incorrect_copy_tag.props.foreground = '#ff0000'
         self.tagtable.add(incorrect_copy_tag)
         
         # Set up the scrolling lesson text view.
-        self.lessonbuffer = gtk.TextBuffer(self.tagtable)
-        self.lessontext = gtk.TextView(self.lessonbuffer)
+        self.lessonbuffer = Gtk.TextBuffer.new(self.tagtable)
+        self.lessontext = Gtk.TextView.new_with_buffer(self.lessonbuffer)
         self.lessontext.set_editable(False)
         self.lessontext.set_left_margin(20)
         self.lessontext.set_right_margin(20)
-        self.lessontext.set_wrap_mode(gtk.WRAP_WORD)
-        self.lessontext.modify_base(gtk.STATE_NORMAL, self.get_colormap().alloc_color('#ffffcc'))
+        self.lessontext.set_wrap_mode(Gtk.WrapMode.WORD)
+        self.lessontext.modify_base(Gtk.StateType.NORMAL, Gdk.Color.parse('#ffffcc')[1])
         
-        self.lessonscroll = gtk.ScrolledWindow()
-        self.lessonscroll.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_ALWAYS)
+        self.lessonscroll = Gtk.ScrolledWindow()
+        self.lessonscroll.set_policy(Gtk.PolicyType.AUTOMATIC, Gtk.PolicyType.ALWAYS)
         self.lessonscroll.add(self.lessontext)
         
-        frame = gtk.Frame()
+        frame = Gtk.Frame()
         frame.add(self.lessonscroll)
         
         self.keyboard = keyboard.KeyboardWidget(self.keyboard_images, self.activity)
@@ -140 +141 @@
         self.keyboard.set_layout(keyboard.get_layout())
 
         self.pack_start(hbox, False, False, 10)
-        self.pack_start(frame, True, True)
-        self.pack_start(self.keyboard, False)
+        self.pack_start(frame, True, True, 0)
+        self.pack_start(self.keyboard, False, True, 0)
         
         # Connect keyboard grabbing and releasing callbacks.        
         self.connect('realize', self.realize_cb)
@@ -154 +155 @@
         self.begin_lesson()
         
     def realize_cb(self, widget):
-        self.activity.add_events(gtk.gdk.KEY_PRESS_MASK|gtk.gdk.KEY_RELEASE_MASK)
+        self.activity.add_events(Gdk.EventMask.KEY_PRESS_MASK|Gdk.EventMask.KEY_RELEASE_MASK)
         self.key_press_cb_id = self.activity.connect('key-press-event', self.key_cb)
         self.key_release_cb_id = self.activity.connect('key-release-event', self.key_cb)
         
@@ -164 +165 @@
 
     def start_timer(self):
         self.start_time = time.time()
-        self.timer_id = gobject.timeout_add(1000, self.timer_cb)
+        self.timer_id = GObject.timeout_add(1000, self.timer_cb)
 
     def stop_timer(self):
         if self.timer_id:
-            gobject.source_remove(self.timer_id)
+            GObject.source_remove(self.timer_id)
         self.start_time = None
         self.timer_id = None
 
@@ -349 +350 @@
 
         # Extract information about the key pressed.
         key = event.string
-        key_name = gtk.gdk.keyval_name(event.keyval)
+        key_name = Gdk.keyval_name(event.keyval)
         
         # Ignore events which don't produce a character, except backspace.
         if not (key_name == 'BackSpace' or key):
             return True
 
         # Ignore either press or release events, depending on mode.
-        if self.mode == 'key' and event.type == gtk.gdk.KEY_PRESS:
+        if self.mode == 'key' and event.type == Gdk.EventType.KEY_PRESS:
             return True 
-        if self.mode != 'key' and event.type == gtk.gdk.KEY_RELEASE:
+        if self.mode != 'key' and event.type == Gdk.EventType.KEY_RELEASE:
             return True
         
         # Ignore hotkeys.
-        if event.state & (gtk.gdk.CONTROL_MASK | gtk.gdk.MOD1_MASK):
+        if event.get_state() & (Gdk.ModifierType.CONTROL_MASK | Gdk.ModifierType.MOD1_MASK):
             return True
         
         # Convert Return keys to paragraph symbols.
@@ -474 +475 @@
             self.lessontext.grab_focus()
             
             # Scroll the TextView so the cursor is on screen.
-            self.lessontext.scroll_to_mark(self.lessonbuffer.get_insert(), 0)
+            self.lessontext.scroll_to_mark(self.lessonbuffer.get_insert(), 0,
+                                           use_align=False, xalign=0.5, yalign=0.5)
 
         # In Key mode, display the finger hint and the key image.
         if self.mode == 'key':
@@ -499 +501 @@
                 except:
                     finger = ''
         
-                if state == gtk.gdk.SHIFT_MASK:
+                if state == Gdk.ModifierType.SHIFT_MASK:
                     # Choose the finger to press the SHIFT key with.
                     if key['key-finger'][0] == 'R':
                         shift_finger = FINGERS['LP']
@@ -509 +511 @@
                     instructions = _('Press and hold the shift key with your %(finger)s, ') % { 'finger': shift_finger }
                     instructions += _('then press the %(letter)s key with your %(finger)s.') % { 'letter': letter, 'finger': finger }
         
-                elif state == gtk.gdk.MOD5_MASK:
+                elif state == Gdk.ModifierType.MOD5_MASK:
                     instructions = _('Press and hold the altgr key, ') 
                     instructions += _('then press the %(letter)s key with your %(finger)s.') % { 'letter': letter, 'finger': finger }
         
-                elif state == gtk.gdk.SHIFT_MASK | gtk.gdk.MOD5_MASK:
+                elif state == Gdk.ModifierType.SHIFT_MASK | Gdk.ModifierType.MOD5_MASK:
                     instructions = _('Press and hold the altgr and shift keys, ')
                     instructions += _('then press the %(letter)s key with your %(finger)s.') % { 'letter': letter, 'finger': finger }
         
@@ -522 +524 @@
 
                 self.lessonbuffer.insert(self.lessonbuffer.get_end_iter(), instructions + '\n\n')
 
-                if state & gtk.gdk.SHIFT_MASK:
+                if state & Gdk.ModifierType.SHIFT_MASK:
                     shift_key = self.keyboard.find_key_by_label('shift')
                     pixbuf = self.keyboard.get_key_pixbuf(shift_key, scale=1)
                     self.lessonbuffer.insert_pixbuf(self.lessonbuffer.get_end_iter(), pixbuf)
                     self.lessonbuffer.insert(self.lessonbuffer.get_end_iter(), ' ')
                 
-                if state & gtk.gdk.MOD5_MASK:
+                if state & Gdk.ModifierType.MOD5_MASK:
                     altgr_key = self.keyboard.find_key_by_label('altgr')
                     pixbuf = self.keyboard.get_key_pixbuf(altgr_key, scale=1)
                     self.lessonbuffer.insert_pixbuf(self.lessonbuffer.get_end_iter(), pixbuf)

mainscreen.py

@@ -19 +19 @@
 from gettext import gettext as _
 from port import json
 
-# Import PyGTK.
-import gobject, pygtk, gtk, pango
+from gi.repository import Gtk
+from gi.repository import Gdk
+from gi.repository import GdkPixbuf
+from gi.repository import GObject
 
 # Import Sugar UI modules.
-import sugar.activity.activity
-from sugar.graphics import *
+import sugar3.activity.activity
+from sugar3.graphics import *
 
 # Import activity modules.
 import lessonscreen, medalscreen
@@ -38 +40 @@
 # http://commons.wikimedia.org/wiki/File:Silver_medal_world_centered.svg
 # http://commons.wikimedia.org/wiki/File:Bronze_medal_world_centered.svg
 
-class MainScreen(gtk.VBox):
+class MainScreen(Gtk.VBox):
     def __init__(self, activity):
-        gtk.VBox.__init__(self)
+        GObject.GObject.__init__(self)
         
         self.activity = activity
         
@@ -48 +50 @@
         self.titlescene = titlescene.TitleScene()
         
         # Build lessons list.
-        self.lessonbox = gtk.HBox()
+        self.lessonbox = Gtk.HBox()
         
-        #nexticon = sugar.graphics.icon.Icon(icon_name='go-next')
+        #nexticon = sugar3.graphics.icon.Icon(icon_name='go-next')
         #self.nextlessonbtn.add(nexticon)
-        nextlabel = gtk.Label()
+        nextlabel = Gtk.Label()
         nextlabel.set_markup("<span size='large'>" + _('Next') + "</span>")
 
-        self.nextlessonbtn = gtk.Button()
+        self.nextlessonbtn = Gtk.Button()
         self.nextlessonbtn.add(nextlabel)
         self.nextlessonbtn.connect('clicked', self.next_lesson_clicked_cb)
         
-        #previcon = sugar.graphics.icon.Icon(icon_name='go-previous')
+        #previcon = sugar3.graphics.icon.Icon(icon_name='go-previous')
         #self.prevlessonbtn.add(previcon)
-        prevlabel = gtk.Label()
+        prevlabel = Gtk.Label()
         prevlabel.set_markup("<span size='large'>" + _('Previous') + "</span>")
 
-        self.prevlessonbtn = gtk.Button()
+        self.prevlessonbtn = Gtk.Button()
         self.prevlessonbtn.add(prevlabel)
         self.prevlessonbtn.connect('clicked', self.prev_lesson_clicked_cb)
         
-        lessonlabel = gtk.Label()
+        lessonlabel = Gtk.Label()
         lessonlabel.set_markup("<span size='x-large' weight='bold'>" + _('Start Lesson') + "</span>")
         
-        lessonbtn = gtk.Button()
+        lessonbtn = Gtk.Button()
         lessonbtn.add(lessonlabel)
         lessonbtn.connect('clicked', self.lesson_clicked_cb)
-        lessonbtn.modify_bg(gtk.STATE_NORMAL, self.get_colormap().alloc_color('#60b060'))
+        lessonbtn.modify_bg(Gtk.StateType.NORMAL, Gdk.Color.parse('#60b060')[1])
         
         # Load lessons for this language.
         code = locale.getdefaultlocale()[0] or 'en_US'
-        lessons_path = os.path.join(sugar.activity.activity.get_bundle_path(), 'lessons')
+        lessons_path = os.path.join(sugar3.activity.activity.get_bundle_path(), 'lessons')
         lessons_file = os.path.join(lessons_path, code + '.lessons')
         if os.path.isfile(lessons_file):
             self.load_lessons(lessons_file)
@@ -99 +101 @@
         self.lessons.sort(lambda x, y: x.get('order', 0) - y.get('order', 0))
 
         # Load all the keyboard images.
-        width = int(gtk.gdk.screen_width())
-        height = int(gtk.gdk.screen_height()*0.3)
+        width = int(Gdk.Screen.width())
+        height = int(Gdk.Screen.height()*0.3)
         self.keyboard_images = keyboard.KeyboardImages(width, height)
         self.keyboard_images.load_images()
         
-        navbox = gtk.HBox()
+        navbox = Gtk.HBox()
         navbox.set_spacing(10)
-        navbox.pack_start(self.prevlessonbtn, True)
-        navbox.pack_start(lessonbtn, True)
-        navbox.pack_start(self.nextlessonbtn, True)
+        navbox.pack_start(self.prevlessonbtn, True, True, 0)
+        navbox.pack_start(lessonbtn, True, True, 0)
+        navbox.pack_start(self.nextlessonbtn, True, True, 0)
         
-        lessonbox = gtk.VBox()
+        lessonbox = Gtk.VBox()
         lessonbox.set_spacing(10)
-        lessonbox.pack_start(navbox, False)
-        lessonbox.pack_start(self.lessonbox)
+        lessonbox.pack_start(navbox, False, True, 0)
+        lessonbox.pack_start(self.lessonbox, True, True, 0)
         
         self.pack_start(self.titlescene, False, True, 10)
-        self.pack_start(lessonbox, True)
+        self.pack_start(lessonbox, True, True, 0)
         
         self.show_next_lesson()
 
@@ -165 +167 @@
             medal_type = self.activity.data['medals'][lesson['name']]['type']
         
         # Create the lesson button.
-        namelabel = gtk.Label()
+        namelabel = Gtk.Label()
         namelabel.set_alignment(0.5, 0.5)
         namelabel.set_markup("<span size='x-large' weight='bold'>" + lesson['name'] + "</span>")
-        desclabel = gtk.Label()
+        desclabel = Gtk.Label()
         desclabel.set_alignment(0.5, 0.5)
         desclabel.set_markup("<span size='large' color='#606060'>" + lesson['description'] + "</span>")
         
@@ -177 +179 @@
         else:
             hint = ''
                 
-        #hintlabel = gtk.Label()
+        #hintlabel = Gtk.Label()
         #hintlabel.set_alignment(0.0, 0.8)
         #hintlabel.set_markup("<span size='8000' color='#606020'>" + hint + "</span>")
         
-        labelbox = gtk.VBox()
+        labelbox = Gtk.VBox()
         labelbox.set_spacing(10)
         labelbox.set_border_width(20)
-        labelbox.pack_start(namelabel, False)
-        labelbox.pack_start(desclabel, False)
-        #labelbox.pack_start(hintlabel)
+        labelbox.pack_start(namelabel, False, True, 0)
+        labelbox.pack_start(desclabel, False, True, 0)
+        #labelbox.pack_start(hintlabel, True, True, 0)
 
         # Create the medal image.
         images = {
@@ -196 +198 @@
             'gold':   'images/gold-medal.svg'
         }
 
-        medal_size = int(2.0 * sugar.graphics.style.GRID_CELL_SIZE)
-        medalpixbuf = gtk.gdk.pixbuf_new_from_file(images[medal_type])
-        medalpixbuf = medalpixbuf.scale_simple(medal_size, medal_size, gtk.gdk.INTERP_BILINEAR)
+        medal_size = int(2.0 * sugar3.graphics.style.GRID_CELL_SIZE)
+        medalpixbuf = GdkPixbuf.Pixbuf.new_from_file(images[medal_type])
+        medalpixbuf = medalpixbuf.scale_simple(medal_size, medal_size, GdkPixbuf.InterpType.BILINEAR)
         
-        medalimage = gtk.Image()
+        medalimage = Gtk.Image()
         medalimage.set_from_pixbuf(medalpixbuf)
         
         names = {
@@ -209 +211 @@
             'silver': _('Silver Medal'),
             'gold':   _('Gold Medal'),
         }
-        medallabel = gtk.Label(names[medal_type])
+        medallabel = Gtk.Label(label=names[medal_type])
         
-        medalbox = gtk.VBox()
-        medalbox.pack_start(medalimage)
-        medalbox.pack_start(medallabel)
+        medalbox = Gtk.VBox()
+        medalbox.pack_start(medalimage, True, True, 0)
+        medalbox.pack_start(medallabel, True, True, 0)
         
-        medalbtn = gtk.Button()
+        medalbtn = Gtk.Button()
         medalbtn.add(medalbox)
         medalbtn.connect('clicked', self.medal_clicked_cb)
         
         # Hilite the button in the direction of the first unmedaled lesson.
         next_index = self.get_next_lesson()
         if next_index > self.lesson_index and index < len(self.lessons)-1:
-            self.nextlessonbtn.modify_bg(gtk.STATE_NORMAL, self.get_colormap().alloc_color('#ff8080'))
+            self.nextlessonbtn.modify_bg(Gtk.StateType.NORMAL, Gdk.Color.parse('#ff8080')[1])
         else:
-            self.nextlessonbtn.modify_bg(gtk.STATE_NORMAL, self.get_colormap().alloc_color('#40a040'))
+            self.nextlessonbtn.modify_bg(Gtk.StateType.NORMAL, Gdk.Color.parse('#40a040')[1])
         if next_index < self.lesson_index and index > 0:
-            self.prevlessonbtn.modify_bg(gtk.STATE_NORMAL, self.get_colormap().alloc_color('#ff8080'))
+            self.prevlessonbtn.modify_bg(Gtk.StateType.NORMAL, Gdk.Color.parse('#ff8080')[1])
         else:
-            self.prevlessonbtn.modify_bg(gtk.STATE_NORMAL, self.get_colormap().alloc_color('#40a040'))
+            self.prevlessonbtn.modify_bg(Gtk.StateType.NORMAL, Gdk.Color.parse('#40a040')[1])
         
-        self.lessonbox.pack_start(labelbox, True)
+        self.lessonbox.pack_start(labelbox, True, True, 0)
         if medal_type != 'none':
-            self.lessonbox.pack_start(medalbtn, False)
+            self.lessonbox.pack_start(medalbtn, False, True, 0)
 
         self.lessonbox.show_all()
     

medalscreen.py

@@ -18 +18 @@
 import logging, os, math, time, copy, locale, datetime, random, re
 from gettext import gettext as _
 
-# Import PyGTK.
-import gobject, pygtk, gtk, pango
+from gi.repository import Gtk
+from gi.repository import Gdk
+from gi.repository import GdkPixbuf
+from gi.repository import GObject
 
 # Import Sugar UI modules.
-import sugar.activity.activity
-import sugar.graphics.style
+import sugar3.activity.activity
+import sugar3.graphics.style
 
-class MedalScreen(gtk.EventBox):
-    MEDAL_SIZE = int(4.5 * sugar.graphics.style.GRID_CELL_SIZE)
+class MedalScreen(Gtk.EventBox):
+    MEDAL_SIZE = int(4.5 * sugar3.graphics.style.GRID_CELL_SIZE)
 
     def __init__(self, medal, activity):
-        gtk.EventBox.__init__(self)
+        GObject.GObject.__init__(self)
         
-        self.modify_bg(gtk.STATE_NORMAL, self.get_colormap().alloc_color('#ffffff'))
+        self.modify_bg(Gtk.StateType.NORMAL, Gdk.Color.parse('#ffffff')[1])
         
         self.medal = medal
         self.activity = activity
@@ -43 +45 @@
             'silver': 'images/silver-medal.svg',
             'gold':   'images/gold-medal.svg'
         }
-        medalpixbuf = gtk.gdk.pixbuf_new_from_file(images[medal_type])
-        medalpixbuf = medalpixbuf.scale_simple(MedalScreen.MEDAL_SIZE, MedalScreen.MEDAL_SIZE, gtk.gdk.INTERP_BILINEAR)
+        medalpixbuf = GdkPixbuf.Pixbuf.new_from_file(images[medal_type])
+        medalpixbuf = medalpixbuf.scale_simple(MedalScreen.MEDAL_SIZE, MedalScreen.MEDAL_SIZE, GdkPixbuf.InterpType.BILINEAR)
         
-        medalimage = gtk.Image()
+        medalimage = Gtk.Image()
         medalimage.set_from_pixbuf(medalpixbuf)
 
         # Certifications section.
-        title = gtk.Label()
+        title = Gtk.Label()
         title.set_markup(_("<span font_desc='Serif Bold Italic 28'>Certificate of Achievement</span>"))
         
-        text0 = gtk.Label()
+        text0 = Gtk.Label()
         text0.set_markup(_("<span font_desc='Sans 16'>This certifies that</span>"))
 
-        text1 = gtk.Label()
+        text1 = Gtk.Label()
         text1.set_markup(_("<span font_desc='Sans 16'><b><u><i>%(nick)s</i></u></b></span>") % medal)
 
-        text2 = gtk.Label()
+        text2 = Gtk.Label()
         text2.set_markup(_("<span font_desc='Sans 16'>earned a %(type)s medal in </span>") % medal)
 
-        text3 = gtk.Label()
+        text3 = Gtk.Label()
         text3.set_markup(_("<span font_desc='Sans 16'>in <b><u><i>%(lesson)s</i></u></b></span>") % medal)
 
-        text4 = gtk.Label()
+        text4 = Gtk.Label()
         text4.set_markup(_("<span font_desc='Sans 16'>on <b><u><i>%(date)s</i></u></b>.</span>") % medal)
 
-        textbox = gtk.VBox()
-        textbox.pack_start(text0)
-        textbox.pack_start(text1)
-        textbox.pack_start(text2)
-        textbox.pack_start(text3)
-        textbox.pack_start(text4)
+        textbox = Gtk.VBox()
+        textbox.pack_start(text0, True, True, 0)
+        textbox.pack_start(text1, True, True, 0)
+        textbox.pack_start(text2, True, True, 0)
+        textbox.pack_start(text3, True, True, 0)
+        textbox.pack_start(text4, True, True, 0)
 
-        medalbox = gtk.HBox()
-        medalbox.pack_start(textbox)
-        medalbox.pack_end(medalimage)
+        medalbox = Gtk.HBox()
+        medalbox.pack_start(textbox, True, True, 0)
+        medalbox.pack_end(medalimage, True, True, 0)
 
         # Stats section.
-        statbox = gtk.HBox()
+        statbox = Gtk.HBox()
         if medal.has_key('wpm'):
-            stat1 = gtk.Label()
+            stat1 = Gtk.Label()
             stat1.set_markup("<span size='18000'>" + (_('<b>Words Per Minute:</b> %(wpm)d') % medal) + "</span>" )
-            statbox.pack_start(stat1, True)
+            statbox.pack_start(stat1, True, True, 0)
         
-            stat2 = gtk.Label()
+            stat2 = Gtk.Label()
             stat2.set_markup("<span size='18000'>" + (_('<b>Accuracy:</b> %(accuracy)d%%') % medal) + "</span>" )
-            statbox.pack_start(stat2, True)
+            statbox.pack_start(stat2, True, True, 0)
 
         elif medal.has_key('score'):
-            stat1 = gtk.Label()
+            stat1 = Gtk.Label()
             stat1.set_markup("<span size='18000'>" + (_('<b>SCORE:</b> %(score)d') % medal) + "</span>" )
-            statbox.pack_start(stat1, True)
+            statbox.pack_start(stat1, True, True, 0)
         
-        oklabel = gtk.Label()
+        oklabel = Gtk.Label()
         oklabel.set_markup("<span size='10000'>" + _('Press the ENTER key to continue.') + '</span>')
-        self.okbtn = gtk.Button()
+        self.okbtn = Gtk.Button()
         self.okbtn.add(oklabel)
         self.okbtn.connect('clicked', self.ok_cb)
 
-        btnbox = gtk.HBox()
+        btnbox = Gtk.HBox()
         btnbox.pack_start(self.okbtn, True, True, 100)
         
-        vbox = gtk.VBox()
+        vbox = Gtk.VBox()
         
         vbox.pack_start(title, False, False, 0)
         vbox.pack_start(medalbox, True, False, 0)
-        vbox.pack_start(gtk.HSeparator(), False, False, 20)
+        vbox.pack_start(Gtk.Separator(orientation=Gtk.Orientation.HORIZONTAL), False, False, 20)
         vbox.pack_start(statbox, False, False, 0)
         
-        frame = gtk.Frame()
+        frame = Gtk.Frame()
         frame.add(vbox)
         frame.set_border_width(10)
 
-        box = gtk.VBox() 
-        box.pack_start(frame, True, True)
+        box = Gtk.VBox()
+        box.pack_start(frame, True, True, 0)
         box.pack_start(btnbox, False, False, 40)
 
         self.add(box)
@@ -127 +129 @@
 
     def realize_cb(self, widget):
         # For some odd reason, if I do this in the constructor, nothing happens.
-        self.okbtn.set_flags(gtk.CAN_DEFAULT)
+        self.okbtn.set_can_default(True)
         self.okbtn.grab_default()
 
     def ok_cb(self, widget):

port/chooser.py

@@ -14 +14 @@
 
 """Object chooser method"""
 
-import gtk
+from gi.repository import Gtk
 import logging
 
-from sugar import mime
-from sugar.graphics.objectchooser import ObjectChooser
+from sugar3 import mime
+from sugar3.graphics.objectchooser import ObjectChooser
 
 TEXT  = hasattr(mime, 'GENERIC_TYPE_TEXT') and mime.GENERIC_TYPE_TEXT or None
 IMAGE = hasattr(mime, 'GENERIC_TYPE_IMAGE') and mime.GENERIC_TYPE_IMAGE or None
@@ -45 +45 @@
     out = None
 
     try:
-        if chooser.run() == gtk.RESPONSE_ACCEPT:
+        if chooser.run() == Gtk.ResponseType.ACCEPT:
             jobject = chooser.get_selected_object()
             logging.debug('ObjectChooser: %r' % jobject)
 

setup.py

@@ -1 +1 @@
 #!/usr/bin/env python
-from sugar.activity import bundlebuilder
+from sugar3.activity import bundlebuilder
 if __name__ == "__main__":
     bundlebuilder.start()

titlescene.py

@@ -18 +18 @@
 import random
 from gettext import gettext as _
 
-# Import PyGTK.
-import gobject, pygtk, gtk, pango
+from gi.repository import Gtk
+from gi.repository import Gdk
+from gi.repository import GObject
+from gi.repository import Pango
+from gi.repository import PangoCairo
+from gi.repository import GdkPixbuf
 
-class TitleScene(gtk.DrawingArea):
+
+class TitleScene(Gtk.DrawingArea):
     # Maximum portion of the screen the background can fill vertically.
     BACKGROUND_HEIGHT_RATIO = 0.6
 
     # Border from top right of screen to draw title at.
-    TITLE_OFFSET = (20, 30)
+    TITLE_OFFSET = (20, 50)
 
     # Font used to display the title.
     TITLE_FONT = 'Times 45'
 
     def __init__(self):
-        gtk.DrawingArea.__init__(self)
+        Gtk.DrawingArea.__init__(self)
 
-        pbuf = gtk.gdk.pixbuf_new_from_file('images/main-background.jpg')
+        pbuf = GdkPixbuf.Pixbuf.new_from_file('images/main-background.jpg')
 
-        width_ratio = float(gtk.gdk.screen_width()) / pbuf.get_width()
-        height_ratio = float(gtk.gdk.screen_height()*TitleScene.BACKGROUND_HEIGHT_RATIO) / pbuf.get_height()
+        width_ratio = float(Gdk.Screen.width()) / pbuf.get_width()
+        height_ratio = float(Gdk.Screen.height()*TitleScene.BACKGROUND_HEIGHT_RATIO) / pbuf.get_height()
 
         ratio = min(width_ratio, height_ratio)
-        self.backgroundpixbuf = pbuf.scale_simple(int(pbuf.get_width()*ratio), int(pbuf.get_height()*ratio), gtk.gdk.INTERP_BILINEAR)
+        self.backgroundpixbuf = pbuf.scale_simple(int(pbuf.get_width()*ratio), int(pbuf.get_height()*ratio), GdkPixbuf.InterpType.BILINEAR)
  
         self.set_size_request(self.backgroundpixbuf.get_width(), self.backgroundpixbuf.get_height())
         
-        self.connect("expose-event", self.expose_cb)
+        self.connect("draw", self.draw_cb)
         
         self.title_original = _('Typing Turtle')
         self.title_src = self.title_original
         self.title_text = ''
 
-    def expose_cb(self, area, event):
+    def draw_cb(self, area, cr):
         bounds = self.get_allocation()
-        
-        gc = self.get_style().fg_gc[gtk.STATE_NORMAL]
 
         # Background picture.
         x = (bounds.width - self.backgroundpixbuf.get_width())/2
-        self.window.draw_pixbuf(
-            gc, self.backgroundpixbuf, 0, 0, 
-            x, 0, self.backgroundpixbuf.get_width(), self.backgroundpixbuf.get_height())
-        pc = self.create_pango_context()
-        
-        self.layout = self.create_pango_layout('')
-        self.layout.set_font_description(pango.FontDescription(TitleScene.TITLE_FONT))
-        
-        self.layout.set_text(self.title_original)
-        original_size = self.layout.get_size()
-        self.x_text = (bounds.width-original_size[0]/pango.SCALE)-TitleScene.TITLE_OFFSET[0]
+
+        Gdk.cairo_set_source_pixbuf(cr, self.backgroundpixbuf, 0, 0)
+        cr.rectangle(x, 0, self.backgroundpixbuf.get_width(),
+                     self.backgroundpixbuf.get_height())
+        cr.paint()
+
+        cr.set_source_rgb(0, 0, 0)
+        self.pango_layout = PangoCairo.create_layout(cr)
+        self.pango_layout.set_font_description(
+            Pango.FontDescription(TitleScene.TITLE_FONT))
+        self.pango_layout.set_text(unicode(self.title_original),
+                                   len(self.title_original))
+
+        original_size = self.pango_layout.get_size()
+        self.x_text = (bounds.width - original_size[0] / Pango.SCALE) - \
+            TitleScene.TITLE_OFFSET[0]
         self.y_text = TitleScene.TITLE_OFFSET[1]
-        gobject.timeout_add(50, self.timer_cb)
+
+        GObject.timeout_add(50, self.timer_cb)
 
     def draw_text(self):
         # Animated Typing Turtle title.
-        gc = self.get_style().fg_gc[gtk.STATE_NORMAL]
-        self.layout.set_text(self.title_text)
-        self.window.draw_layout(gc, self.x_text, self.y_text, self.layout)
+        window = self.get_window()
+        if window is None:
+            return
+        cr = window.cairo_create()
+
+        cr.move_to(self.x_text, self.y_text)
+        self.pango_layout.set_text(unicode(self.title_text),
+                                   len(self.title_text))
+        PangoCairo.update_layout(cr, self.pango_layout)
+        PangoCairo.show_layout(cr, self.pango_layout)
 
     def timer_cb(self):
         if len(self.title_src) > 0:

typingturtle.py

@@ -25 +25 @@
 #dbgp.client.brkOnExcept(host='192.168.1.104', port=12900)
 
 # there is need to set up localization.
-# since sugar.activity.main already seted up gettext envronment
+# since sugar3.activity.main already seted up gettext envronment
 #locale.setlocale(locale.LC_ALL, '')
 
-# Import PyGTK.
-import gobject, pygtk, gtk, pango
+
+from gi.repository import Gtk
 
 # Import Sugar UI modules.
-import sugar.activity.activity
-from sugar.graphics import *
-from sugar.graphics import toolbutton
-from sugar import profile
-
-OLD_TOOLBAR = False
-try:
-    from sugar.graphics.toolbarbox import ToolbarBox
-    from sugar.activity.widgets import StopButton
-    from sugar.activity.widgets import ActivityToolbarButton
-except ImportError:
-    OLD_TOOLBAR = True
+import sugar3.activity.activity
+from sugar3.graphics import *
+from sugar3.graphics import toolbutton
+from sugar3 import profile
+
+from sugar3.graphics.toolbarbox import ToolbarBox
+from sugar3.activity.widgets import StopButton
+from sugar3.activity.widgets import ActivityToolbarButton
 
 # Initialize logging.
 log = logging.getLogger('Typing Turtle')
@@ -51 +47 @@
 logging.basicConfig()
 
 # Change to bundle directory.
-bundle_path = sugar.activity.activity.get_bundle_path() 
+bundle_path = sugar3.activity.activity.get_bundle_path() 
 os.chdir(bundle_path)
 
 # Import activity modules.
 import mainscreen, editlessonlistscreen
 
+from gi.repository import PangoCairo
+
+
+def _get_screen_dpi():
+    xft_dpi = Gtk.Settings.get_default().get_property('gtk-xft-dpi')
+    dpi = float(xft_dpi / 1024)
+    logging.debug('Setting dpi to: %f', dpi)
+    # HACK: if the DPI detected is 200.0 it seems we are on an XO, so
+    # we return 133 because the XO manage its resolution in a complex
+    # way. More information here:
+    #     http://wiki.laptop.org/go/Display
+    if 200 == int(dpi):
+        return 133
+    return dpi
+
+dpi = _get_screen_dpi()
+font_map_default = PangoCairo.font_map_get_default()
+font_map_default.set_resolution(dpi)
+
+from gi.repository import Rsvg
+Rsvg.set_default_dpi(200)
+ # This is the main Typing Turtle activity class.
+ # 
+ # It owns the main application window, and all the various toolbars and options.
+
+
+
 # This is the main Typing Turtle activity class.
 # 
 # It owns the main application window, and all the various toolbars and options.
 # Activity Screens are stored in a stack, with the currently active screen on top.
-class TypingTurtle(sugar.activity.activity.Activity):
+class TypingTurtle(sugar3.activity.activity.Activity):
     def __init__ (self, handle):
-        sugar.activity.activity.Activity.__init__(self, handle)
+        sugar3.activity.activity.Activity.__init__(self, handle)
         self.set_title(_("Typing Turtle"))
         self.max_participants = 1
         
         self.build_toolbox()
         
         self.screens = []
-        self.screenbox = gtk.VBox()
+        self.screenbox = Gtk.VBox()
         
         self.nick = profile.get_nick_name()
         
@@ -92 +115 @@
         
         self.show_all()
         
-        self.editorbtn = sugar.graphics.toolbutton.ToolButton('view-source')
+        self.editorbtn = sugar3.graphics.toolbutton.ToolButton('view-source')
         self.editorbtn.set_tooltip(_("Edit Lessons"))
         self.editorbtn.connect('clicked', self.editor_clicked_cb)
 
-        if OLD_TOOLBAR:
-            # Hide the sharing button from the activity toolbar since
-            # we don't support sharing.
-            activity_toolbar = self.tbox.get_activity_toolbar()
-            activity_toolbar.share.props.visible = False
-
-            share_idx = activity_toolbar.get_item_index(activity_toolbar.share)
-            activity_toolbar.insert(self.editorbtn, share_idx)
-        else:
-            activity_toolbar = self.toolbar_box.toolbar
-            activity_toolbar.insert(self.editorbtn, 1)
+        activity_toolbar = self.toolbar_box.toolbar
+        activity_toolbar.insert(self.editorbtn, 1)
 
         self.editorbtn.show_all()
 
     def build_toolbox(self):
-        if OLD_TOOLBAR:
-            self.tbox = sugar.activity.activity.ActivityToolbox(self)
-            self.tbox.show_all()
-            self.set_toolbox(self.tbox)
-        else:
-            self.toolbar_box = ToolbarBox()
+        self.toolbar_box = ToolbarBox()
 
-            activity_button = ActivityToolbarButton(self)
-            self.toolbar_box.toolbar.insert(activity_button, 0)
-            activity_button.show()
+        activity_button = ActivityToolbarButton(self)
+        self.toolbar_box.toolbar.insert(activity_button, 0)
+        activity_button.show()
 
-            separator = gtk.SeparatorToolItem()
-            separator.props.draw = False
-            separator.set_expand(True)
-            self.toolbar_box.toolbar.insert(separator, -1)
+        separator = Gtk.SeparatorToolItem()
+        separator.props.draw = False
+        separator.set_expand(True)
+        self.toolbar_box.toolbar.insert(separator, -1)
 
-            self.toolbar_box.toolbar.insert(StopButton(self), -1)
+        self.toolbar_box.toolbar.insert(StopButton(self), -1)
 
-            self.set_toolbar_box(self.toolbar_box)
-            self.toolbar_box.show_all()
+        self.set_toolbar_box(self.toolbar_box)
+        self.toolbar_box.show_all()
 
     def editor_clicked_cb(self, btn):
         self.push_screen(editlessonlistscreen.EditLessonListScreen(self, self.mainscreen.lessons))
@@ -146 +155 @@
             
             self.screenbox.remove(oldscreen)
         
-        self.screenbox.pack_start(screen, True, True)
+        self.screenbox.pack_start(screen, True, True, 0)
         self.screens.append(screen)
         
         try:
@@ -172 +181 @@
             except:
                 pass
             
-            self.screenbox.pack_start(screen)
+            self.screenbox.pack_start(screen, True, True, 0)
             
     def add_history(self, entry):
         self.data['history'].append(entry)