Ticket #3715: With-Help-Unscaled.diff

File With-Help-Unscaled.diff, 46.0 KB (added by humitos, 12 years ago)

Working with Help dialogue working (but unscaled board on it)

  • activity/activity.info 

    diff --git a/activity/activity.info b/activity/activity.info
index cbe5757..97896cb 100644
    a b  
    11[Activity]
    2 name = Implode
     2name = Implode Gtk3
    33activity_version = 12
    4 bundle_id = com.jotaro.ImplodeActivity
     4bundle_id = git.ImplodeActivity
    55icon = activity-implode
    66exec = sugar-activity implodeactivity.ImplodeActivity
    77license = GPLv2+

  • anim.py 

    diff --git a/anim.py b/anim.py
index 2c19a15..f34406e 100644
    a b  
    1616# along with this program; if not, write to the Free Software
    1717# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
    1818
    19 import gobject
     19from gi.repository import GObject
    2020
    2121# Animation timer interval (in msec)
    2222_TIMER_INTERVAL = 20
    … … class Anim(object): 
    3434    def start(self):
    3535        self._animating = True
    3636        self._update_func()
    37         gobject.timeout_add(_TIMER_INTERVAL, self._timer)
     37        GObject.timeout_add(_TIMER_INTERVAL, self._timer)
    3838
    3939    def stop(self):
    4040        if self._animating:

  • gridwidget.py 

    diff --git a/gridwidget.py b/gridwidget.py
index 8ee3aad..c3b6596 100644
    a b import logging 
    2020_logger = logging.getLogger('implode-activity.gridwidget')
    2121
    2222import cairo
    23 import gobject
    24 import gtk
     23from gi.repository import GObject
     24from gi.repository import Gtk
     25from gi.repository import Gdk
    2526import math
    2627import random
    2728import time
    … … _ANIM_SCALE = 0.04 
    9394def _log_errors(func):
    9495    return func
    9596
    96 class GridWidget(gtk.DrawingArea):
     97class GridWidget(Gtk.DrawingArea):
    9798    """Gtk widget for rendering the game board."""
    9899
    99100    __gsignals__ = {
    100         'piece-selected'  : (gobject.SIGNAL_RUN_LAST, None, (int, int)),
    101         'undo-key-pressed': (gobject.SIGNAL_RUN_LAST, None, (int,)),
    102         'redo-key-pressed': (gobject.SIGNAL_RUN_LAST, None, (int,)),
    103         'new-key-pressed' : (gobject.SIGNAL_RUN_LAST, None, (int,)),
    104         'button-press-event': 'override',
    105         'key-press-event': 'override',
    106         'expose-event': 'override',
    107         'size-allocate': 'override',
    108         'motion-notify-event': 'override',
     101        'piece-selected': (GObject.SignalFlags.RUN_LAST, None, (int, int)),
     102        'undo-key-pressed': (GObject.SignalFlags.RUN_LAST, None, (int,)),
     103        'redo-key-pressed': (GObject.SignalFlags.RUN_LAST, None, (int,)),
     104        'new-key-pressed': (GObject.SignalFlags.RUN_LAST, None, (int,)),
    109105    }
    110106
    111107    def __init__(self, *args, **kwargs):
    112108        super(GridWidget, self).__init__(*args, **kwargs)
    113         self.set_events(gtk.gdk.BUTTON_PRESS_MASK
    114                         | gtk.gdk.POINTER_MOTION_MASK
    115                         | gtk.gdk.KEY_PRESS_MASK)
    116         self.set_flags(gtk.CAN_FOCUS)
     109        self.set_events(Gdk.EventMask.BUTTON_PRESS_MASK
     110                        | Gdk.EventMask.POINTER_MOTION_MASK
     111                        | Gdk.EventMask.KEY_PRESS_MASK)
     112        self.set_can_focus(True)
    117113
    118114        self._board_drawer = BoardDrawer(self._get_size, self._invalidate_rect)
    119115        self._win_drawer = WinDrawer(self._get_size, self._invalidate_rect)
    120116        self._removal_drawer = RemovalDrawer(self._get_size, self._invalidate_rect)
    121117        self._set_current_drawer(self._board_drawer)
    122118
     119        self.connect('draw', self._draw_event_cb)
     120        self.connect('configure-event', self._configure_event_cb)
     121        self.connect('button-press-event', self._button_press_event_cb)
     122
    123123    def _get_size(self):
    124         return (self.allocation.width, self.allocation.height)
     124        return (self.get_allocated_width(), self.get_allocated_height())
    125125
    126126    def _invalidate_rect(self, rect):
    127         if self.window:
    128             self.window.invalidate_rect(rect, True)
     127        if self.get_window():
     128            self.get_window().invalidate_rect(rect, True)
    129129
    130130    def set_board(self, board):
    131131        self._board_drawer.set_board(board)
    … … class GridWidget(gtk.DrawingArea): 
    141141
    142142    def _invalidate_board(self):
    143143        (width, height) = self._get_size()
    144         self._invalidate_rect(gtk.gdk.Rectangle(0, 0, width, height))
     144        rect = Gdk.Rectangle()
     145        rect.x, rect.y, rect.width, rect.height = (0, 0, width, height)
     146        self._invalidate_rect(rect)
    145147
    146148    def get_win_draw_flag(self):
    147149        return (self._current_drawer is self._win_drawer)
    … … class GridWidget(gtk.DrawingArea): 
    160162        self._board_drawer.select_center_cell()
    161163
    162164    @_log_errors
    163     def do_button_press_event(self, event):
     165    def _button_press_event_cb(self, widget, event):
    164166        # Ignore mouse clicks while animating.
    165167        if self._is_animating():
    166168            return True
    167169        # Ignore double- and triple-clicks.
    168         if event.type != gtk.gdk.BUTTON_PRESS:
     170        if event.type != Gdk.EventType.BUTTON_PRESS:
    169171            return True
    170172        self.grab_focus()
    171173        self._board_drawer.set_mouse_selection(event.x, event.y)
    … … class GridWidget(gtk.DrawingArea): 
    219221        else:
    220222            x = event.x
    221223            y = event.y
    222             state = event.state
     224            state = event.get_state()
    223225        self._board_drawer.set_mouse_selection(x, y)
    224226
    225     @_log_errors
    226     def do_expose_event(self, event):
    227         cr = self.window.cairo_create()
    228         cr.rectangle(event.area.x,
    229                      event.area.y,
    230                      event.area.width,
    231                      event.area.height)
    232         cr.clip()
    233         (width, height) = self.window.get_size()
    234         self._current_drawer.draw(cr, width, height)
     227    def _draw_event_cb(self, widget, cr):
     228        alloc = self.get_allocation()
     229        self._current_drawer.draw(cr, alloc.width, alloc.height)
    235230
    236231    @_log_errors
    237     def do_size_allocate(self, allocation):
    238         super(GridWidget, self).do_size_allocate(self, allocation)
    239         self._current_drawer.resize(allocation.width, allocation.height)
     232    def _configure_event_cb(self, widget, event):
     233        self._current_drawer.resize(event.width, event.height)
    240234
    241235    def _set_current_drawer(self, drawer):
    242236        self._current_drawer = drawer
    … … class BoardDrawer(object): 
    382376
    383377    def _invalidate_board(self):
    384378        (width, height) = self._get_size_func()
    385         rect = gtk.gdk.Rectangle(0, 0, width, height)
     379        rect = Gdk.Rectangle()
     380        rect.x, rect.y, rect.width, rect.height = (0, 0, width, height)
    386381        self._invalidate_rect_func(rect)
    387382
    388383    def _invalidate_selection(self, selection_coord):
    … … class BoardDrawer(object): 
    407402        max_x2 = math.ceil( max(pt1[0], pt2[0])) + 1
    408403        min_y2 = math.floor(min(pt1[1], pt2[1])) - 1
    409404        max_y2 = math.ceil( max(pt1[1], pt2[1])) + 1
    410         rect = gtk.gdk.Rectangle(int(min_x2),
    411                                  int(min_y2),
    412                                  int(max_x2 - min_x2),
    413                                 int(max_y2 - min_y2))
     405        rect = Gdk.Rectangle()
     406        rect.x, rect.y, rect.width, rect.height = (
     407            int(min_x2), int(min_y2),
     408            int(max_x2 - min_x2), int(max_y2 - min_y2))
    414409        self._invalidate_rect_func(rect)
    415410
    416411    def _display_to_cell(self, x, y):
    … … class BoardDrawer(object): 
    426421            self._board_transform = _BoardTransform()
    427422        else:
    428423            self._board_transform = _BoardTransform()
    429             self._board_transform.setup(width,
    430                                        height,
    431                                        self._board_width,
    432                                        self._board_height)
     424            self._board_transform.setup(width, height, self._board_width,
     425                                        self._board_height)
    433426
    434427    def draw(self, cr, width, height):
    435428        # Draws the widget.
    … … class RemovalDrawer(object): 
    564557
    565558    def _invalidate_board(self):
    566559        (width, height) = self._get_size_func()
    567         rect = gtk.gdk.Rectangle(0, 0, width, height)
     560        rect = Gdk.Rectangle()
     561        rect.x, rect.y, rect.width, rect.height = (0, 0, width, height)
    568562        self._invalidate_rect_func(rect)
    569563
    570564    def _recalc_game_anim_frames(self):
    … … class WinDrawer(object): 
    810804
    811805    def _invalidate_board(self):
    812806        (width, height) = self._get_size_func()
    813         rect = gtk.gdk.Rectangle(0, 0, width, height)
     807        rect = Gdk.Rectangle()
     808        rect.x, rect.y, rect.width, rect.height = (0, 0, width, height)
    814809        self._invalidate_rect_func(rect)
    815810
    816811    def _get_win_tiles(self):

  • helpwidget.py 

    diff --git a/helpwidget.py b/helpwidget.py
index af205e6..a7b8930 100644
    a b from __future__ import with_statement 
    2121from gettext import gettext as _
    2222
    2323import cairo
    24 import gobject
    25 import gtk
     24import logging
     25
     26from gi.repository import GObject
     27from gi.repository import Gtk
     28from gi.repository import Gdk
     29from gi.repository import Rsvg
     30
    2631import math
    2732import os
    28 import rsvg
    2933import time
    3034
    3135import board
    … … from anim import Anim 
    3337from gridwidget import BoardDrawer, RemovalDrawer, WinDrawer
    3438
    3539if 'SUGAR_BUNDLE_PATH' in os.environ:
    36     from sugar.graphics import style
     40    from sugar3.graphics import style
    3741    _DEFAULT_SPACING = style.DEFAULT_SPACING
    3842    _DEFAULT_PADDING = style.DEFAULT_PADDING
    3943    _BG_COLOR = tuple(style.COLOR_SELECTION_GREY.get_rgba()[:3])
    … … _CLICK_SPEED = 0.2 
    7579# Speed of the mouse, in units (4x3 per screen) per second.
    7680_MOUSE_SPEED = 0.5
    7781
    78 class HelpWidget(gtk.EventBox):
     82class HelpWidget(Gtk.EventBox):
    7983    def __init__(self, icon_file_func, *args, **kwargs):
    8084        super(HelpWidget, self).__init__(*args, **kwargs)
    8185
    82         vbox = gtk.VBox()
     86        vbox = Gtk.Box(orientation=Gtk.Orientation.VERTICAL)
    8387        self.add(vbox)
    8488
    8589        self._stages = [
    … … class HelpWidget(gtk.EventBox): 
    9094            _HelpStage5(icon_file_func),
    9195        ]
    9296        self._stage_index = 0
    93         self._notebook = gtk.Notebook()
     97        self._notebook = Gtk.Notebook()
    9498        self._notebook.set_show_tabs(False)
    9599        for stage in self._stages:
    96             self._notebook.append_page(stage)
    97         vbox.pack_start(self._notebook)
     100            self._notebook.append_page(stage, None)
     101        vbox.pack_start(self._notebook, True, True, 0)
    98102
    99103        self._reset_current_stage()
    100104
    … … class HelpWidget(gtk.EventBox): 
    128132        self._stages[self._stage_index].reset()
    129133
    130134
    131 class _HelpStage(gtk.EventBox):
     135class _HelpStage(Gtk.EventBox):
    132136    # An abstract parent class for objects that represent an animated help
    133137    # screen widget with a description.
    134138    def __init__(self, icon_file_func, *args, **kwargs):
    135139        super(_HelpStage, self).__init__(*args, **kwargs)
    136140
    137         hbox = gtk.HBox()
     141        hbox = Gtk.Box(orientation=Gtk.Orientation.HORIZONTAL)
    138142        self.add(hbox)
    139143
    140         vbox = gtk.VBox()
    141         hbox.pack_start(vbox, expand=True, padding=_DEFAULT_SPACING)
     144        vbox = Gtk.Box(orientation=Gtk.Orientation.VERTICAL)
     145        hbox.pack_start(vbox, expand=True, fill=False,
     146                        padding=_DEFAULT_SPACING)
    142147
    143148        self.preview = _PreviewWidget(icon_file_func)
    144         vbox.pack_start(self.preview, expand=True, padding=_DEFAULT_PADDING)
     149        vbox.pack_start(self.preview, expand=True, fill=False,
     150                        padding=_DEFAULT_PADDING)
    145151
    146         label = gtk.Label(self.get_message())
     152        label = Gtk.Label(label=self.get_message())
    147153        label.set_line_wrap(True)
    148         vbox.pack_start(label, expand=False, padding=_DEFAULT_PADDING)
     154        vbox.pack_start(label, expand=False, fill=False,
     155                        padding=_DEFAULT_PADDING)
    149156
    150157        self.board = None
    151158        self.undo_stack = []
    … … def _undo(): 
    552559        stage.next_action()
    553560    return action
    554561
    555 class _PreviewWidget(gtk.DrawingArea):
    556     __gsignals__ = {
    557         'expose-event': 'override',
    558         'size-allocate': 'override',
    559     }
    560 
     562class _PreviewWidget(Gtk.DrawingArea):
    561563    def __init__(self, icon_file_func, *args, **kwargs):
    562564        super(_PreviewWidget, self).__init__(*args, **kwargs)
    563565
    … … class _PreviewWidget(gtk.DrawingArea): 
    573575
    574576        self._icon_file_func = icon_file_func
    575577
    576         self._preview_rect = gtk.gdk.Rectangle(0, 0, 0, 0)
    577         self._toolbar_rect = gtk.gdk.Rectangle(0, 0, 0, 0)
    578         self._drawer_rect = gtk.gdk.Rectangle(0, 0, 0, 0)
     578        self._preview_rect = Gdk.Rectangle()
     579        self._preview_rect.x = self._preview_rect.y = \
     580            self._preview_rect.width = self._preview_rect.height = 0
     581
     582        self._toolbar_rect = Gdk.Rectangle()
     583        self._toolbar_rect.x = self._toolbar_rect.y = \
     584            self._toolbar_rect.width = self._toolbar_rect.height = 0
     585
     586        self._drawer_rect = Gdk.Rectangle()
     587        self._drawer_rect.x = self._drawer_rect.y = \
     588            self._drawer_rect.width = self._drawer_rect.height = 0
    579589
    580590        self._drawer = self.board_drawer
    581591
    … … class _PreviewWidget(gtk.DrawingArea): 
    589599        self._click_visible = False
    590600        self._cursor_visible = False
    591601
     602        self.connect('draw', self._draw_event_cb)
     603        self.connect('configure-event', self._configure_event_cb)
     604        # self.connect('size-allocate', self._configure_event_cb)
     605
    592606    def _get_drawer_size(self):
     607        logging.debug('FUNC: _get_drawer_size() -> %s, %s',
     608                      self._drawer_rect.width, self._drawer_rect.height)
    593609        return (self._drawer_rect.width, self._drawer_rect.height)
    594610
    595611    def _invalidate_drawer_rect(self, rect):
    596         if self.window:
     612        if self.get_window():
    597613            (x, y) = (self._drawer_rect.x, self._drawer_rect.y)
    598             offset_rect = gtk.gdk.Rectangle(rect.x + x,
    599                                             rect.y + y,
    600                                             rect.width,
    601                                             rect.height)
    602             self.window.invalidate_rect(offset_rect, True)
     614            rect = Gdk.Rectangle()
     615            rect.x, rect.y, rect.width, rect.height = (
     616                rect.x + x, rect.y + y, rect.width, rect.height)
     617            self.get_window().invalidate_rect(rect, True)
    603618
    604619    def set_drawer(self, drawer):
    605620        self._drawer = drawer
    … … class _PreviewWidget(gtk.DrawingArea): 
    667682        self._invalidate_client_rect(pixel_x - r, pixel_y - r, r2, r2)
    668683
    669684    def _invalidate_client_rect(self, x, y, width, height):
    670         if self.window:
    671             rect = gtk.gdk.Rectangle(
     685        if self.get_window():
     686            rect = Gdk.Rectangle()
     687            rect.x, rect.y, rect.width, rect.height = (
    672688                int(math.floor(x)) + self._preview_rect.x,
    673689                int(math.floor(y)) + self._preview_rect.y,
    674690                int(math.ceil(width)) + 1,
    675691                int(math.ceil(height)) + 1)
    676             self.window.invalidate_rect(rect, True)
     692            self.get_window().invalidate_rect(rect, True)
    677693
    678694    def _update_mouse_position(self):
    679695        (pixel_x, pixel_y) = self._get_cursor_pixel_coords()
    680696        (x, y) = (pixel_x, pixel_y - self._toolbar_rect.height)
    681697        self.board_drawer.set_mouse_selection(x, y)
    682698
    683     def do_expose_event(self, event):
    684         cr = self.window.cairo_create()
    685         cr.rectangle(event.area.x,
    686                      event.area.y,
    687                      event.area.width,
    688                      event.area.height)
    689         cr.clip()
    690         (width, height) = self.window.get_size()
    691         self._draw(cr, width, height)
     699    def _size_allocate_cb(self, widget, rect):
     700        self.width = rect.width
     701        self.height = rect.height
     702
     703    def _draw_event_cb(self, widget, cr):
     704        alloc = self.get_allocation()
     705        cr.rectangle(0, 0, alloc.width, alloc.height)
     706        self._draw(cr, alloc.width, alloc.height)
    692707
    693708    def _draw(self, cr, width, height):
    694709        cr.set_source_rgb(*_BG_COLOR)
    … … class _PreviewWidget(gtk.DrawingArea): 
    712727        cr.restore()
    713728
    714729    def _draw_toolbar(self, cr):
     730        logging.debug('FUNC: _draw_toolbar()')
    715731        cr.set_source_rgb(*_TOOLBAR_COLOR)
    716732        cr.rectangle(self._toolbar_rect.x,
    717733                     self._toolbar_rect.y,
    … … class _PreviewWidget(gtk.DrawingArea): 
    730746            cr.save()
    731747            cr.translate(self._toolbar_rect.x + i * icon_height,
    732748                         self._toolbar_rect.y)
     749            logging.debug('SCALE: %s', scale)
    733750            cr.scale(scale, scale)
    734751            handle.render_cairo(cr)
    735752            cr.restore()
    … … class _PreviewWidget(gtk.DrawingArea): 
    803820
    804821        cr.restore()
    805822
    806     def do_size_allocate(self, allocation):
    807         super(_PreviewWidget, self).do_size_allocate(self, allocation)
    808         (width, height) = (allocation.width, allocation.height)
     823    def _configure_event_cb(self, widget, event):
     824        logging.debug('FUNC: _configure_event_cb()')
     825        (width, height) = (event.width, event.height)
    809826
    810827        avail_width = width - _DEFAULT_SPACING * 2
    811828        other_height = avail_width * 3 / 4
    … … class _PreviewWidget(gtk.DrawingArea): 
    829846        old_width = self._preview_rect.width
    830847        old_height = self._preview_rect.height
    831848
    832         self._preview_rect = gtk.gdk.Rectangle(x_offset,
    833                                                y_offset,
    834                                                actual_width,
    835                                                actual_height)
    836         self._toolbar_rect = gtk.gdk.Rectangle(x_offset,
    837                                                y_offset,
    838                                                actual_width,
    839                                                icon_height)
    840         self._drawer_rect = gtk.gdk.Rectangle(x_offset,
    841                                               y_offset + icon_height,
    842                                               actual_width,
    843                                               board_height)
     849        self._preview_rect = Gdk.Rectangle()
     850        self._preview_rect.x = x_offset
     851        self._preview_rect.y = y_offset
     852        self._preview_rect.width = actual_width
     853        self._preview_rect.height = actual_height
     854
     855        self._toolbar_rect = Gdk.Rectangle()
     856        self._toolbar_rect.x = x_offset
     857        self._toolbar_rect.y = y_offset
     858        self._toolbar_rect.width = actual_width
     859        self._toolbar_rect.height = icon_height
     860
     861        self._drawer_rect = Gdk.Rectangle()
     862        self._drawer_rect.x = x_offset
     863        self._drawer_rect.y = y_offset + icon_height
     864        self._drawer_rect.width = actual_width
     865        self._drawer_rect.height = board_height
     866
    844867        self.board_drawer.resize(actual_width, board_height)
    845868        self.removal_drawer.resize(actual_width, board_height)
    846869        self.win_drawer.resize(actual_width, board_height)
    … … def _get_icon_handle(file_path): 
    886909    if file_path not in _icon_handles:
    887910        with open(file_path, 'r') as f:
    888911            data = f.read()
    889         _icon_handles[file_path] = rsvg.Handle(data=data)
     912        _icon_handles[file_path] = Rsvg.Handle.new_from_data(data)
    890913
    891914    return _icon_handles[file_path]

  • implodeactivity.py 

    diff --git a/implodeactivity.py b/implodeactivity.py
index 3e4cb2f..c03d7fe 100644
    a b _logger = logging.getLogger('implode-activity') 
    2121
    2222from gettext import gettext as _
    2323
    24 from sugar.activity.activity import Activity, get_bundle_path
    25 from sugar.graphics import style
    26 from sugar.graphics.icon import Icon
    27 from sugar.graphics.radiotoolbutton import RadioToolButton
    28 from sugar.graphics.toolbutton import ToolButton
    29 
    30 try:
    31     # 0.86+ toolbar widgets
    32     from sugar.activity.widgets import ActivityToolbarButton, StopButton
    33     from sugar.graphics.toolbarbox import ToolbarBox, ToolbarButton
    34     _USE_OLD_TOOLBARS = False
    35 except ImportError:
    36     # Pre-0.86 toolbar widgets
    37     from sugar.activity.activity import ActivityToolbox
    38     _USE_OLD_TOOLBARS = True
     24from sugar3.activity.activity import Activity, get_bundle_path
     25from sugar3.graphics import style
     26from sugar3.graphics.icon import Icon
     27from sugar3.graphics.radiotoolbutton import RadioToolButton
     28from sugar3.graphics.toolbutton import ToolButton
     29
     30from sugar3.activity.widgets import ActivityToolbarButton, StopButton
     31from sugar3.graphics.toolbarbox import ToolbarBox, ToolbarButton
    3932
    4033from implodegame import ImplodeGame
    4134from helpwidget import HelpWidget
    4235
    4336import os
    4437
    45 try:
    46     import json
    47     json.dumps
    48 except (ImportError, AttributeError):
    49     import simplejson as json
     38import json
    5039from StringIO import StringIO
    51 import gtk
    52 import gobject
     40from gi.repository import Gtk
     41from gi.repository import GObject
     42from gi.repository import Gdk
    5343
    5444from keymap import KEY_MAP
    5545
    … … class ImplodeActivity(Activity): 
    6353
    6454        self._game = ImplodeGame()
    6555
    66         game_box = gtk.VBox()
    67         game_box.pack_start(self._game)
     56        game_box = Gtk.Box(orientation=Gtk.Orientation.VERTICAL)
     57        game_box.pack_start(self._game, True, True, 0)
    6858        self._stuck_strip = _StuckStrip()
    6959
    7060        self._configure_toolbars()
    … … class ImplodeActivity(Activity): 
    7363
    7464        # Show everything except the stuck strip.
    7565        self.show_all()
    76         game_box.pack_end(self._stuck_strip, expand=False)
     66        game_box.pack_end(self._stuck_strip, expand=False, fill=False, padding=0)
    7767
    7868        self._game.connect('show-stuck', self._show_stuck_cb)
    7969        self._stuck_strip.connect('undo-clicked', self._stuck_undo_cb)
    … … class ImplodeActivity(Activity): 
    9686        file_data = json.load(io)
    9787        f.close()
    9888
    99         print file_data
    100         _logger.debug(file_data)
     89        # print file_data
     90        # _logger.debug(file_data)
    10191        (file_type, version, game_data) = file_data
    10292        if file_type == 'Implode save game' and version <= [1, 0]:
    10393            self._game.set_game_state(game_data)
    … … class ImplodeActivity(Activity): 
    121111        if data:
    122112            self._stuck_strip.show_all()
    123113        else:
    124             if self._stuck_strip.focus_child:
     114            if self._stuck_strip.get_focus_child():
    125115                self._game.grab_focus()
    126116            self._stuck_strip.hide()
    127117
    … … class ImplodeActivity(Activity): 
    133123        action = KEY_MAP.get(event.keyval, None)
    134124        if action is None:
    135125            return False
    136         if not self._stuck_strip.flags() & gtk.VISIBLE:
     126        if not self._stuck_strip.get_state_flags() & Gtk.AccelFlags.VISIBLE:
    137127            return True
    138         if self._game.focus_child:
     128        if self._game.get_focus_child():
    139129            if action == 'down':
    140130                self._stuck_strip.button.grab_focus()
    141131            return True
    142         elif self._stuck_strip.focus_child:
     132        elif self._stuck_strip.get_focus_child():
    143133            if action == 'up':
    144134                self._game.grab_focus()
    145135            elif action == 'select':
    … … class ImplodeActivity(Activity): 
    152142        controls, difficulty selector, help button, and stop button. All
    153143        callbacks are locally defined."""
    154144
    155         if _USE_OLD_TOOLBARS:
    156             toolbox = ActivityToolbox(self)
    157             toolbar = gtk.Toolbar()
    158         else:
    159             toolbar_box = ToolbarBox()
    160             toolbar = toolbar_box.toolbar
     145        toolbar_box = ToolbarBox()
     146        toolbar = toolbar_box.toolbar
    161147
    162             activity_button = ActivityToolbarButton(self)
    163             toolbar_box.toolbar.insert(activity_button, 0)
    164             activity_button.show()
     148        activity_button = ActivityToolbarButton(self)
     149        toolbar_box.toolbar.insert(activity_button, 0)
     150        activity_button.show()
    165151
    166             toolbar.add(gtk.SeparatorToolItem())
     152        toolbar.add(Gtk.SeparatorToolItem())
    167153
    168154        def add_button(icon_name, tooltip, func):
    169155            def callback(source):
    … … class ImplodeActivity(Activity): 
    176162        add_button('new-game'   , _("New")   , self._game.new_game)
    177163        add_button('replay-game', _("Replay"), self._game.replay_game)
    178164
    179         toolbar.add(gtk.SeparatorToolItem())
     165        toolbar.add(Gtk.SeparatorToolItem())
    180166
    181167        add_button('edit-undo'  , _("Undo")  , self._game.undo)
    182168        add_button('edit-redo'  , _("Redo")  , self._game.redo)
    183169
    184         toolbar.add(gtk.SeparatorToolItem())
     170        toolbar.add(Gtk.SeparatorToolItem())
    185171
    186172        self._levels_buttons = []
    187173        def add_level_button(icon_name, tooltip, numeric_level):
    … … class ImplodeActivity(Activity): 
    217203        # right now, however.
    218204        add_button('help-icon', _("Help"), _help_clicked_cb)
    219205
    220         if _USE_OLD_TOOLBARS:
    221             toolbox.add_toolbar(_("Game"), toolbar)
    222             toolbox.set_current_toolbar(1)
     206        stop_button = StopButton(self)
     207        stop_button.props.accelerator = '<Ctrl><Shift>Q'
     208        toolbar_box.toolbar.insert(stop_button, -1)
     209        stop_button.show()
    223210
    224             self.set_toolbox(toolbox)
    225             toolbox.show()
    226         else:
    227             stop_button = StopButton(self)
    228             stop_button.props.accelerator = '<Ctrl><Shift>Q'
    229             toolbar_box.toolbar.insert(stop_button, -1)
    230             stop_button.show()
    231 
    232             self.set_toolbar_box(toolbar_box)
    233             toolbar_box.show()
     211        self.set_toolbar_box(toolbar_box)
     212        toolbar_box.show()
    234213
    235214    def _add_expander(self, toolbar, expand=True):
    236215        """Insert a toolbar item which will expand to fill the available
    237216        space."""
    238         separator = gtk.SeparatorToolItem()
     217        separator = Gtk.SeparatorToolItem()
    239218        separator.props.draw = False
    240219        separator.set_expand(expand)
    241220        toolbar.insert(separator, -1)
    242221        separator.show()
    243222
    244223
    245 class _DialogWindow(gtk.Window):
     224class _DialogWindow(Gtk.Window):
    246225    # A base class for a modal dialog window.
    247226    def __init__(self, icon_name, title):
    248227        super(_DialogWindow, self).__init__()
    249228
    250229        self.set_border_width(style.LINE_WIDTH)
    251230        offset = style.GRID_CELL_SIZE
    252         width = gtk.gdk.screen_width() / 2
    253         height = gtk.gdk.screen_height() / 2
     231        width = Gdk.Screen.width() / 2
     232        height = Gdk.Screen.height() / 2
    254233        self.set_size_request(width, height)
    255         self.set_position(gtk.WIN_POS_CENTER_ALWAYS)
     234        self.set_position(Gtk.WindowPosition.CENTER_ALWAYS)
    256235        self.set_decorated(False)
    257236        self.set_resizable(False)
    258237        self.set_modal(True)
    259238
    260         vbox = gtk.VBox()
     239        vbox = Gtk.Box(orientation=Gtk.Orientation.VERTICAL)
    261240        self.add(vbox)
    262241
    263242        toolbar = _DialogToolbar(icon_name, title)
    264243        toolbar.connect('stop-clicked', self._stop_clicked_cb)
    265         vbox.pack_start(toolbar, False)
     244        vbox.pack_start(toolbar, expand=False, fill=False, padding=0)
    266245
    267         self.content_vbox = gtk.VBox()
     246        self.content_vbox = Gtk.Box(orientation=Gtk.Orientation.VERTICAL)
    268247        self.content_vbox.set_border_width(style.DEFAULT_SPACING)
    269248        vbox.add(self.content_vbox)
    270249
    … … class _DialogWindow(gtk.Window): 
    274253        self.destroy()
    275254
    276255    def _realize_cb(self, source):
    277         self.window.set_type_hint(gtk.gdk.WINDOW_TYPE_HINT_DIALOG)
    278         self.window.set_accept_focus(True)
     256        self.set_type_hint(Gdk.WindowTypeHint.DIALOG)
     257        self.get_window().set_accept_focus(True)
    279258
    280259
    281260class _HelpWindow(_DialogWindow):
    … … class _HelpWindow(_DialogWindow): 
    284263        super(_HelpWindow, self).__init__('help-icon', _("Help"))
    285264
    286265        offset = style.GRID_CELL_SIZE
    287         width = gtk.gdk.screen_width() - offset * 2
    288         height = gtk.gdk.screen_height() - offset * 2
     266        width = Gdk.Screen.width() - offset * 2
     267        height = Gdk.Screen.height() - offset * 2
    289268        self.set_size_request(width, height)
    290269
    291270        self._help_widget = HelpWidget(self._icon_file)
    292         self.content_vbox.pack_start(self._help_widget)
     271        self.content_vbox.pack_start(self._help_widget, True, True, 0)
    293272
    294273        self._help_nav_bar = _HelpNavBar()
    295         self.content_vbox.pack_end(self._help_nav_bar,
    296                                    expand=False,
    297                                    padding=style.DEFAULT_SPACING)
     274        self.content_vbox.pack_end(self._help_nav_bar, expand=False,
     275                                   fill=False, padding=style.DEFAULT_SPACING)
    298276
    299277        for (signal_name, callback) in [
    300278                ('forward-clicked', self._forward_clicked_cb),
    … … class _HelpWindow(_DialogWindow): 
    316294        self._help_widget.replay_stage()
    317295
    318296    def _icon_file(self, icon_name):
    319         theme = gtk.icon_theme_get_default()
     297        theme = Gtk.IconTheme.get_default()
    320298        info = theme.lookup_icon(icon_name, 0, 0)
    321299        return info.get_filename()
    322300
    … … class _HelpWindow(_DialogWindow): 
    326304        self._help_nav_bar.set_can_next_stage(hw.can_next_stage())
    327305
    328306
    329 class _DialogToolbar(gtk.Toolbar):
     307class _DialogToolbar(Gtk.Toolbar):
    330308    # Displays a dialog window's toolbar, with title, icon, and close box.
    331309    __gsignals__ = {
    332         'stop-clicked'       : (gobject.SIGNAL_RUN_LAST, None, ()),
     310        'stop-clicked'       : (GObject.SignalFlags.RUN_LAST, None, ()),
    333311    }
    334312    def __init__(self, icon_name, title):
    335313        super(_DialogToolbar, self).__init__()
    336314
    337315        icon = Icon()
    338         icon.set_from_icon_name(icon_name, gtk.ICON_SIZE_LARGE_TOOLBAR)
     316        icon.set_from_icon_name(icon_name, Gtk.IconSize.LARGE_TOOLBAR)
    339317        self._add_widget(icon)
    340318
    341319        self._add_separator()
    342320
    343         label = gtk.Label(title)
     321        label = Gtk.Label(label=title)
    344322        self._add_widget(label)
    345323
    346324        self._add_separator(expand=True)
    … … class _DialogToolbar(gtk.Toolbar): 
    351329        self.add(stop)
    352330
    353331    def _add_separator(self, expand=False):
    354         separator = gtk.SeparatorToolItem()
     332        separator = Gtk.SeparatorToolItem()
    355333        separator.set_expand(expand)
    356334        separator.set_draw(False)
    357335        self.add(separator)
    358336
    359337    def _add_widget(self, widget):
    360         tool_item = gtk.ToolItem()
     338        tool_item = Gtk.ToolItem()
    361339        tool_item.add(widget)
    362340        self.add(tool_item)
    363341
    … … class _DialogToolbar(gtk.Toolbar): 
    365343        self.emit('stop-clicked')
    366344
    367345
    368 class _HelpNavBar(gtk.HButtonBox):
     346class _HelpNavBar(Gtk.HButtonBox):
    369347    # A widget to display the navigation controls at the bottom of the help
    370348    # dialog.
    371349    __gsignals__ = {
    372         'forward-clicked' : (gobject.SIGNAL_RUN_LAST, None, ()),
    373         'back-clicked'    : (gobject.SIGNAL_RUN_LAST, None, ()),
    374         'reload-clicked'  : (gobject.SIGNAL_RUN_LAST, None, ()),
     350        'forward-clicked' : (GObject.SignalFlags.RUN_LAST, None, ()),
     351        'back-clicked'    : (GObject.SignalFlags.RUN_LAST, None, ()),
     352        'reload-clicked'  : (GObject.SignalFlags.RUN_LAST, None, ()),
    375353    }
    376354
    377355    def __init__(self):
    378356        super(_HelpNavBar, self).__init__()
    379357
    380         self.set_layout(gtk.BUTTONBOX_SPREAD)
     358        self.set_layout(Gtk.ButtonBoxStyle.SPREAD)
    381359
    382360        def add_button(icon_name, tooltip, signal_name):
    383361            icon = Icon()
    384             icon.set_from_icon_name(icon_name, gtk.ICON_SIZE_LARGE_TOOLBAR)
    385             button = gtk.Button()
     362            icon.set_from_icon_name(icon_name, Gtk.IconSize.LARGE_TOOLBAR)
     363            button = Gtk.Button()
    386364            button.set_image(icon)
    387365            button.set_tooltip_text(tooltip)
    388366            self.add(button)
    … … class _HelpNavBar(gtk.HButtonBox): 
    404382        self._forward_button.set_sensitive(can_next_stage)
    405383
    406384
    407 class _StuckStrip(gtk.HBox):
     385class _StuckStrip(Gtk.Box):
    408386    __gsignals__ = {
    409         'undo-clicked' : (gobject.SIGNAL_RUN_LAST, None, ()),
     387        'undo-clicked' : (GObject.SignalFlags.RUN_LAST, None, ()),
    410388    }
    411389    def __init__(self, *args, **kwargs):
    412390        super(_StuckStrip, self).__init__(*args, **kwargs)
    413391
    414         spacer1 = gtk.Label('')
    415         self.pack_start(spacer1, expand=True)
     392        self.orientation = Gtk.Orientation.HORIZONTAL
     393
     394        spacer1 = Gtk.Label(label='')
     395        self.pack_start(spacer1, True, True, 0)
    416396
    417         spacer2 = gtk.Label('')
    418         self.pack_end(spacer2, expand=True)
     397        spacer2 = Gtk.Label(label='')
     398        self.pack_end(spacer2, expand=True, fill=False, padding=0)
    419399
    420400        self.set_spacing(10)
    421401
    422402        self.set_border_width(10)
    423403
    424         label = gtk.Label(_("Stuck?  You can still solve the puzzle."))
    425         self.pack_start(label, expand=False)
     404        label = Gtk.Label(label=_("Stuck?  You can still solve the puzzle."))
     405        self.pack_start(label, False, True, 0)
    426406
    427407        icon = Icon()
    428         icon.set_from_icon_name('edit-undo', gtk.ICON_SIZE_LARGE_TOOLBAR)
    429         self.button = gtk.Button(stock=gtk.STOCK_UNDO)
     408        icon.set_from_icon_name('edit-undo', Gtk.IconSize.LARGE_TOOLBAR)
     409        self.button = Gtk.Button(stock=Gtk.STOCK_UNDO)
    430410        self.button.set_image(icon)
    431411        self.button.set_label(_("Undo some moves"))
    432         self.pack_end(self.button, expand=False)
     412        self.pack_end(self.button, expand=False, fill=False, padding=0)
    433413
    434414        def callback(source):
    435415            self.emit('undo-clicked')

  • implodegame.py 

    diff --git a/implodegame.py b/implodegame.py
index 60c507c..7841d69 100644
    a b _logger = logging.getLogger('implode-activity.implodegame') 
    2121
    2222from gettext import gettext as _
    2323
    24 import gtk
    25 import gobject
     24from gi.repository import Gtk
     25from gi.repository import GObject
    2626import random
    2727import time
    2828
    … … _STUCK_DELAY = 0.5 
    3939# state after the player gets stuck, in seconds.
    4040_UNDO_DELAY = 0.3
    4141
    42 class ImplodeGame(gtk.EventBox):
     42class ImplodeGame(Gtk.EventBox):
    4343    """Gtk widget for playing the implode game."""
    4444
    4545    __gsignals__ = {
    46         'show-stuck': (gobject.SIGNAL_RUN_LAST, None, (int,)),
     46        'show-stuck': (GObject.SignalFlags.RUN_LAST, None, (int,)),
    4747    }
    4848
    4949    def __init__(self, *args, **kwargs):

  • keymap.py 

    diff --git a/keymap.py b/keymap.py
index b420ace..0322b22 100644
    a b  
    1616# along with this program; if not, write to the Free Software
    1717# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
    1818
    19 import gtk
     19from gi.repository import Gdk
    2020
    2121KEY_MAP = {
    22     gtk.keysyms.KP_Up        : 'up',
    23     gtk.keysyms.KP_Down      : 'down',
    24     gtk.keysyms.KP_Left      : 'left',
    25     gtk.keysyms.KP_Right     : 'right',
    26 
    27     gtk.keysyms.w            : 'up',
    28     gtk.keysyms.s            : 'down',
    29     gtk.keysyms.a            : 'left',
    30     gtk.keysyms.d            : 'right',
    31 
    32     gtk.keysyms.KP_8         : 'up',
    33     gtk.keysyms.KP_2         : 'down',
    34     gtk.keysyms.KP_4         : 'left',
    35     gtk.keysyms.KP_6         : 'right',
    36 
    37     gtk.keysyms.Up           : 'up',
    38     gtk.keysyms.Down         : 'down',
    39     gtk.keysyms.Left         : 'left',
    40     gtk.keysyms.Right        : 'right',
    41 
    42     gtk.keysyms.uparrow      : 'up',
    43     gtk.keysyms.downarrow    : 'down',
    44     gtk.keysyms.leftarrow    : 'left',
    45     gtk.keysyms.rightarrow   : 'right',
    46 
    47     gtk.keysyms.Return       : 'select',
    48     gtk.keysyms.KP_Space     : 'select',
    49     gtk.keysyms.KP_Enter     : 'select',
    50     gtk.keysyms.space        : 'select',
    51     gtk.keysyms.End          : 'select',
    52     gtk.keysyms.KP_End       : 'select',
    53     gtk.keysyms.KP_1         : 'select',
    54     gtk.keysyms.q            : 'select',
    55 
    56     gtk.keysyms.Home         : 'new',
    57     gtk.keysyms.KP_Home      : 'new',
    58     gtk.keysyms.Page_Down    : 'redo',
    59     gtk.keysyms.KP_Page_Down : 'redo',
    60     gtk.keysyms.Page_Up      : 'undo',
    61     gtk.keysyms.KP_Page_Up   : 'undo',
     22    Gdk.KEY_KP_Up        : 'up',
     23    Gdk.KEY_KP_Down      : 'down',
     24    Gdk.KEY_KP_Left      : 'left',
     25    Gdk.KEY_KP_Right     : 'right',
     26
     27    Gdk.KEY_w            : 'up',
     28    Gdk.KEY_s            : 'down',
     29    Gdk.KEY_a            : 'left',
     30    Gdk.KEY_d            : 'right',
     31
     32    Gdk.KEY_KP_8         : 'up',
     33    Gdk.KEY_KP_2         : 'down',
     34    Gdk.KEY_KP_4         : 'left',
     35    Gdk.KEY_KP_6         : 'right',
     36
     37    Gdk.KEY_Up           : 'up',
     38    Gdk.KEY_Down         : 'down',
     39    Gdk.KEY_Left         : 'left',
     40    Gdk.KEY_Right        : 'right',
     41
     42    Gdk.KEY_uparrow      : 'up',
     43    Gdk.KEY_downarrow    : 'down',
     44    Gdk.KEY_leftarrow    : 'left',
     45    Gdk.KEY_rightarrow   : 'right',
     46
     47    Gdk.KEY_Return       : 'select',
     48    Gdk.KEY_KP_Space     : 'select',
     49    Gdk.KEY_KP_Enter     : 'select',
     50    Gdk.KEY_space        : 'select',
     51    Gdk.KEY_End          : 'select',
     52    Gdk.KEY_KP_End       : 'select',
     53    Gdk.KEY_KP_1         : 'select',
     54    Gdk.KEY_q            : 'select',
     55
     56    Gdk.KEY_Home         : 'new',
     57    Gdk.KEY_KP_Home      : 'new',
     58    Gdk.KEY_Page_Down    : 'redo',
     59    Gdk.KEY_KP_Page_Down : 'redo',
     60    Gdk.KEY_Page_Up      : 'undo',
     61    Gdk.KEY_KP_Page_Up   : 'undo',
    6262}

  • setup.py 

    diff --git a/setup.py b/setup.py
index 211f104..cbdf097 100644
    a b  
    11#!/usr/bin/env python
    22
    3 from sugar.activity import bundlebuilder
     3from sugar3.activity import bundlebuilder
    44if __name__ == "__main__":
    55    bundlebuilder.start()

  • sugarless.py 

    diff --git a/sugarless.py b/sugarless.py
index 6a9f3ea..cc6a4a5 100644
    a b  
    1919# A stub file for running the application on a sugarless GTK, when the Activity
    2020# framework is not available.
    2121
    22 import pygtk
    23 pygtk.require('2.0')
    24 import gtk
    25 import gobject
     22from gi.repository import Gtk
     23from gi.repository import Gdk
     24from gi.repository import GObject
    2625
    2726import os
    2827
    … … from keymap import KEY_MAP 
    3231
    3332_DEFAULT_SPACING = 15
    3433
    35 class ImplodeWindow(gtk.Window):
     34import logging
     35LOG_FILENAME = '/tmp/logging_example.out'
     36logging.basicConfig(filename=LOG_FILENAME, level=logging.DEBUG)
     37
     38logging.debug('This message should go to the log file')
     39
     40
     41class ImplodeWindow(Gtk.Window):
    3642    def __init__(self):
    37         super(ImplodeWindow, self).__init__(gtk.WINDOW_TOPLEVEL)
    38         self.set_geometry_hints(None, min_width=640, min_height=480)
     43        super(ImplodeWindow, self).__init__(Gtk.WindowType.TOPLEVEL)
     44
     45        geometry = Gdk.Geometry()
     46        geometry.min_width = 640
     47        geometry.min_height = 480
     48
     49        self.set_geometry_hints(None, geometry, Gdk.WindowHints.MIN_SIZE)
    3950        self.set_title("Implode")
    4051
    4152        self.connect("delete_event", self._delete_event_cb)
    4253
    43         toolbar = gtk.Toolbar()
     54        toolbar = Gtk.Toolbar()
    4455        self.game = implodegame.ImplodeGame()
    4556
    4657        def add_button(id, func):
    47             button = gtk.ToolButton(id)
     58            button = Gtk.ToolButton(id)
    4859            toolbar.add(button)
    4960
    5061            def callback(source):
    … … class ImplodeWindow(gtk.Window): 
    5364
    5465            return button
    5566
    56         add_button(gtk.STOCK_NEW, self.game.new_game)
    57         add_button(gtk.STOCK_MEDIA_PREVIOUS, self.game.replay_game)
    58         add_button(gtk.STOCK_UNDO, self.game.undo)
    59         add_button(gtk.STOCK_REDO, self.game.redo)
     67        add_button(Gtk.STOCK_NEW, self.game.new_game)
     68        add_button(Gtk.STOCK_MEDIA_PREVIOUS, self.game.replay_game)
     69        add_button(Gtk.STOCK_UNDO, self.game.undo)
     70        add_button(Gtk.STOCK_REDO, self.game.redo)
    6071
    61         toolbar.add(gtk.SeparatorToolItem())
     72        toolbar.add(Gtk.SeparatorToolItem())
    6273
    6374        radio_buttons = []
    6475        def add_radio_button(label, func):
    65             button = gtk.RadioToolButton()
     76            button = Gtk.RadioToolButton()
    6677            button.set_label(label)
    6778            toolbar.add(button)
    6879            radio_buttons.append(button)
    … … class ImplodeWindow(gtk.Window): 
    7788        add_radio_button('easy', self._easy_clicked)
    7889        add_radio_button('medium', self._medium_clicked)
    7990        add_radio_button('hard', self._hard_clicked)
    80         for button in radio_buttons[1:]:
    81             button.set_group(radio_buttons[0])
     91        # FIXME:
     92        # for button in radio_buttons[1:]:
     93        #     button.set_group(radio_buttons[0])
    8294
    83         separator = gtk.SeparatorToolItem()
     95        separator = Gtk.SeparatorToolItem()
    8496        separator.set_expand(True)
    8597        separator.set_draw(False)
    8698        toolbar.add(separator)
    8799
    88         add_button(gtk.STOCK_HELP, self._help_clicked)
     100        add_button(Gtk.STOCK_HELP, self._help_clicked)
    89101
    90102        self._stuck_strip = _StuckStrip()
    91103
    92         game_box = gtk.VBox()
    93         game_box.pack_start(self.game)
    94         game_box.pack_end(self._stuck_strip, expand=False)
     104        game_box = Gtk.Box(orientation=Gtk.Orientation.VERTICAL)
     105        game_box.pack_start(self.game, True, True, 0)
     106        game_box.pack_end(self._stuck_strip, expand=False,
     107                          fill=False, padding=0)
    95108
    96         main_box = gtk.VBox()
    97         main_box.pack_start(toolbar, expand=False)
    98         main_box.pack_end(game_box)
     109        main_box = Gtk.Box(orientation=Gtk.Orientation.VERTICAL)
     110        main_box.pack_start(toolbar, False, True, 0)
     111        main_box.pack_end(game_box, expand=False, fill=False, padding=0)
    99112        self.add(main_box)
    100113
    101114        # Show everything except the stuck strip.
    … … class ImplodeWindow(gtk.Window): 
    111124        self.show()
    112125
    113126    def _delete_event_cb(self, window, event):
    114         gtk.main_quit()
     127        Gtk.main_quit()
    115128        return False
    116129
    117130    def _easy_clicked(self):
    … … class ImplodeWindow(gtk.Window): 
    132145        if data:
    133146            self._stuck_strip.show_all()
    134147        else:
    135             if self._stuck_strip.focus_child:
     148            if self._stuck_strip.get_focus_child():
    136149                self.game.grab_focus()
    137150            self._stuck_strip.hide()
    138151
    … … class ImplodeWindow(gtk.Window): 
    144157        action = KEY_MAP.get(event.keyval, None)
    145158        if action is None:
    146159            return False
    147         if not self._stuck_strip.flags() & gtk.VISIBLE:
     160        if not self._stuck_strip.get_state_flags() & Gtk.AccelFlags.VISIBLE:
    148161            return True
    149         if self.game.focus_child:
     162        if self.game.get_focus_child():
    150163            if action == 'down':
    151164                self._stuck_strip.button.grab_focus()
    152165            return True
    153         elif self._stuck_strip.focus_child:
     166        elif self._stuck_strip.get_focus_child():
    154167            if action == 'up':
    155168                self.game.grab_focus()
    156169            elif action == 'select':
    … … class ImplodeWindow(gtk.Window): 
    158171            return True
    159172        return True
    160173
    161 class _HelpWindow(gtk.Window):
     174class _HelpWindow(Gtk.Window):
    162175    def __init__(self):
    163176        super(_HelpWindow, self).__init__()
    164177
    165178        self.set_size_request(640, 480)
    166         self.set_position(gtk.WIN_POS_CENTER_ON_PARENT)
     179        self.set_position(Gtk.WindowPosition.CENTER_ON_PARENT)
    167180        self.set_modal(True)
    168181
    169         vbox = gtk.VBox()
     182        vbox = Gtk.Box(orientation=Gtk.Orientation.VERTICAL)
    170183        self.add(vbox)
    171184
    172185        self._help_widget = HelpWidget(self._icon_file)
    173         vbox.pack_start(self._help_widget)
     186        vbox.pack_start(self._help_widget, True, True, 0)
    174187
    175188        self._help_nav_bar = _HelpNavBar()
    176189        vbox.pack_end(self._help_nav_bar,
    177                       expand=False)
     190                      expand=False, fill=False,
     191                      padding=0)
    178192
    179193        for (signal_name, callback) in [
    180194                ('forward-clicked', self._forward_clicked_cb),
    … … class _HelpWindow(gtk.Window): 
    207221        self._help_nav_bar.set_can_next_stage(hw.can_next_stage())
    208222
    209223
    210 class _HelpNavBar(gtk.HButtonBox):
     224class _HelpNavBar(Gtk.HButtonBox):
    211225    __gsignals__ = {
    212         'forward-clicked' : (gobject.SIGNAL_RUN_LAST, None, ()),
    213         'back-clicked'    : (gobject.SIGNAL_RUN_LAST, None, ()),
    214         'reload-clicked'  : (gobject.SIGNAL_RUN_LAST, None, ()),
     226        'forward-clicked' : (GObject.SignalFlags.RUN_LAST, None, ()),
     227        'back-clicked'    : (GObject.SignalFlags.RUN_LAST, None, ()),
     228        'reload-clicked'  : (GObject.SignalFlags.RUN_LAST, None, ()),
    215229    }
    216230
    217231    def __init__(self):
    218232        super(_HelpNavBar, self).__init__()
    219233
    220         self.set_layout(gtk.BUTTONBOX_SPREAD)
     234        self.set_layout(Gtk.ButtonBoxStyle.SPREAD)
    221235
    222236        def add_button(id, signal_name):
    223             button = gtk.Button(stock=id)
     237            button = Gtk.Button(stock=id)
    224238            self.add(button)
    225239
    226240            def callback(source):
    … … class _HelpNavBar(gtk.HButtonBox): 
    229243
    230244            return button
    231245
    232         self._back_button = add_button(gtk.STOCK_GO_BACK, 'back-clicked')
    233         add_button(gtk.STOCK_MEDIA_PLAY, 'reload-clicked')
    234         self._forward_button = add_button(gtk.STOCK_GO_FORWARD, 'forward-clicked')
     246        self._back_button = add_button(Gtk.STOCK_GO_BACK, 'back-clicked')
     247        add_button(Gtk.STOCK_MEDIA_PLAY, 'reload-clicked')
     248        self._forward_button = add_button(Gtk.STOCK_GO_FORWARD, 'forward-clicked')
    235249
    236250    def set_can_prev_stage(self, can_prev_stage):
    237251        self._back_button.set_sensitive(can_prev_stage)
    … … class _HelpNavBar(gtk.HButtonBox): 
    240254        self._forward_button.set_sensitive(can_next_stage)
    241255
    242256
    243 class _StuckStrip(gtk.HBox):
     257class _StuckStrip(Gtk.Box):
    244258    __gsignals__ = {
    245         'undo-clicked' : (gobject.SIGNAL_RUN_LAST, None, ()),
     259        'undo-clicked' : (GObject.SignalFlags.RUN_LAST, None, ()),
    246260    }
    247261    def __init__(self, *args, **kwargs):
    248262        super(_StuckStrip, self).__init__(*args, **kwargs)
    249263
    250         spacer1 = gtk.Label('')
    251         self.pack_start(spacer1, expand=True)
     264        self.orientation = Gtk.Orientation.HORIZONTAL
     265
     266        spacer1 = Gtk.Label(label='')
     267        self.pack_start(spacer1, True, True, 0)
    252268
    253         spacer2 = gtk.Label('')
    254         self.pack_end(spacer2, expand=True)
     269        spacer2 = Gtk.Label(label='')
     270        self.pack_end(spacer2, expand=True, fill=False, padding=0)
    255271
    256272        self.set_spacing(10)
    257273
    258274        self.set_border_width(10)
    259275
    260         label = gtk.Label("Stuck?  You can still solve the puzzle.")
    261         self.pack_start(label, expand=False)
     276        label = Gtk.Label(label="Stuck?  You can still solve the puzzle.")
     277        self.pack_start(label, False, True, 0)
    262278
    263         self.button = gtk.Button(stock=gtk.STOCK_UNDO)
     279        self.button = Gtk.Button(stock=Gtk.STOCK_UNDO)
    264280        self.button.set_label("Undo some moves")
    265         self.pack_end(self.button, expand=False)
     281        self.pack_end(self.button, expand=False, fill=False, padding=0)
    266282
    267283        def callback(source):
    268284            self.emit('undo-clicked')
    … … class _StuckStrip(gtk.HBox): 
    271287
    272288def main():
    273289    w = ImplodeWindow()
    274     gtk.main()
     290    Gtk.main()
    275291
    276292if __name__ == "__main__":
    277293    main()