Ticket #3715: 0001-Port-to-Gtk3-SL-3715.patch

File 0001-Port-to-Gtk3-SL-3715.patch, 37.2 KB (added by humitos, 12 years ago)

  • anim.py 

    From 6bd1ccef661420a352e0b0127d6ff6c3415ca2b9 Mon Sep 17 00:00:00 2001
From: Manuel Kaufmann <humitos@gmail.com>
Date: Mon, 6 Aug 2012 17:26:11 -0300
Subject: [PATCH Implode] Port to Gtk3 SL #3715

This commit ports the Implode Activity to its Gtk3 version.

The sugarless.py version is not ported on this commit.

Signed-off-by: Manuel Kaufmann <humitos@gmail.com>
---
 anim.py            |   4 +-
 gridwidget.py      |  89 +++++++++++++--------------
 helpwidget.py      | 155 ++++++++++++++++++++++++-----------------------
 implodeactivity.py | 174 ++++++++++++++++++++++++-----------------------------
 implodegame.py     |   8 +--
 keymap.py          |  82 ++++++++++++-------------
 setup.py           |   2 +-
 7 files changed, 248 insertions(+), 266 deletions(-)

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..3d89908 100644
    a b from __future__ import with_statement 
    2121from gettext import gettext as _
    2222
    2323import cairo
    24 import gobject
    25 import gtk
     24
     25from gi.repository import Gtk
     26from gi.repository import Gdk
     27from gi.repository import Rsvg
     28
    2629import math
    2730import os
    28 import rsvg
    2931import time
    3032
    3133import board
    … … from anim import Anim 
    3335from gridwidget import BoardDrawer, RemovalDrawer, WinDrawer
    3436
    3537if 'SUGAR_BUNDLE_PATH' in os.environ:
    36     from sugar.graphics import style
     38    from sugar3.graphics import style
    3739    _DEFAULT_SPACING = style.DEFAULT_SPACING
    3840    _DEFAULT_PADDING = style.DEFAULT_PADDING
    3941    _BG_COLOR = tuple(style.COLOR_SELECTION_GREY.get_rgba()[:3])
    … … _CLICK_SPEED = 0.2 
    7577# Speed of the mouse, in units (4x3 per screen) per second.
    7678_MOUSE_SPEED = 0.5
    7779
    78 class HelpWidget(gtk.EventBox):
     80class HelpWidget(Gtk.EventBox):
    7981    def __init__(self, icon_file_func, *args, **kwargs):
    8082        super(HelpWidget, self).__init__(*args, **kwargs)
    8183
    82         vbox = gtk.VBox()
     84        vbox = Gtk.Box(orientation=Gtk.Orientation.VERTICAL)
    8385        self.add(vbox)
    8486
    8587        self._stages = [
    … … class HelpWidget(gtk.EventBox): 
    9092            _HelpStage5(icon_file_func),
    9193        ]
    9294        self._stage_index = 0
    93         self._notebook = gtk.Notebook()
     95        self._notebook = Gtk.Notebook()
    9496        self._notebook.set_show_tabs(False)
    9597        for stage in self._stages:
    96             self._notebook.append_page(stage)
    97         vbox.pack_start(self._notebook)
     98            self._notebook.append_page(stage, None)
     99        vbox.pack_start(self._notebook, True, True, 0)
    98100
    99101        self._reset_current_stage()
    100102
    … … class HelpWidget(gtk.EventBox): 
    128130        self._stages[self._stage_index].reset()
    129131
    130132
    131 class _HelpStage(gtk.EventBox):
     133class _HelpStage(Gtk.EventBox):
    132134    # An abstract parent class for objects that represent an animated help
    133135    # screen widget with a description.
    134136    def __init__(self, icon_file_func, *args, **kwargs):
    135137        super(_HelpStage, self).__init__(*args, **kwargs)
    136138
    137         hbox = gtk.HBox()
     139        hbox = Gtk.Box(orientation=Gtk.Orientation.HORIZONTAL)
    138140        self.add(hbox)
    139141
    140         vbox = gtk.VBox()
    141         hbox.pack_start(vbox, expand=True, padding=_DEFAULT_SPACING)
     142        vbox = Gtk.Box(orientation=Gtk.Orientation.VERTICAL)
     143        hbox.pack_start(vbox, expand=True, fill=True,
     144                        padding=_DEFAULT_SPACING)
    142145
    143146        self.preview = _PreviewWidget(icon_file_func)
    144         vbox.pack_start(self.preview, expand=True, padding=_DEFAULT_PADDING)
     147        vbox.pack_start(self.preview, expand=True, fill=False,
     148                        padding=_DEFAULT_PADDING)
    145149
    146         label = gtk.Label(self.get_message())
     150        label = Gtk.Label(label=self.get_message())
    147151        label.set_line_wrap(True)
    148         vbox.pack_start(label, expand=False, padding=_DEFAULT_PADDING)
     152        vbox.pack_start(label, expand=False, fill=False,
     153                        padding=_DEFAULT_PADDING)
    149154
    150155        self.board = None
    151156        self.undo_stack = []
    … … def _undo(): 
    552557        stage.next_action()
    553558    return action
    554559
    555 class _PreviewWidget(gtk.DrawingArea):
    556     __gsignals__ = {
    557         'expose-event': 'override',
    558         'size-allocate': 'override',
    559     }
    560 
     560class _PreviewWidget(Gtk.DrawingArea):
    561561    def __init__(self, icon_file_func, *args, **kwargs):
    562562        super(_PreviewWidget, self).__init__(*args, **kwargs)
    563563
    … … class _PreviewWidget(gtk.DrawingArea): 
    573573
    574574        self._icon_file_func = icon_file_func
    575575
    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)
     576        self._preview_rect = Gdk.Rectangle()
     577        self._preview_rect.x = self._preview_rect.y = \
     578            self._preview_rect.width = self._preview_rect.height = 0
     579
     580        self._toolbar_rect = Gdk.Rectangle()
     581        self._toolbar_rect.x = self._toolbar_rect.y = \
     582            self._toolbar_rect.width = self._toolbar_rect.height = 0
     583
     584        self._drawer_rect = Gdk.Rectangle()
     585        self._drawer_rect.x = self._drawer_rect.y = \
     586            self._drawer_rect.width = self._drawer_rect.height = 0
    579587
    580588        self._drawer = self.board_drawer
    581589
    … … class _PreviewWidget(gtk.DrawingArea): 
    589597        self._click_visible = False
    590598        self._cursor_visible = False
    591599
     600        self.connect('draw', self._draw_event_cb)
     601        self.connect('configure-event', self._configure_event_cb)
     602        # self.connect('size-allocate', self._configure_event_cb)
     603
    592604    def _get_drawer_size(self):
    593605        return (self._drawer_rect.width, self._drawer_rect.height)
    594606
    595607    def _invalidate_drawer_rect(self, rect):
    596         if self.window:
     608        if self.get_window():
    597609            (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)
     610            offset_rect = Gdk.Rectangle()
     611            offset_rect.x, offset_rect.y, = (rect.x + x, rect.y + y)
     612            offset_rect.width, offset_rect.height = (rect.width, rect.height)
     613            self.get_window().invalidate_rect(offset_rect, True)
    603614
    604615    def set_drawer(self, drawer):
    605616        self._drawer = drawer
    … … class _PreviewWidget(gtk.DrawingArea): 
    667678        self._invalidate_client_rect(pixel_x - r, pixel_y - r, r2, r2)
    668679
    669680    def _invalidate_client_rect(self, x, y, width, height):
    670         if self.window:
    671             rect = gtk.gdk.Rectangle(
     681        if self.get_window():
     682            rect = Gdk.Rectangle()
     683            rect.x, rect.y, rect.width, rect.height = (
    672684                int(math.floor(x)) + self._preview_rect.x,
    673685                int(math.floor(y)) + self._preview_rect.y,
    674686                int(math.ceil(width)) + 1,
    675687                int(math.ceil(height)) + 1)
    676             self.window.invalidate_rect(rect, True)
     688
     689            self.get_window().invalidate_rect(rect, True)
    677690
    678691    def _update_mouse_position(self):
    679692        (pixel_x, pixel_y) = self._get_cursor_pixel_coords()
    680693        (x, y) = (pixel_x, pixel_y - self._toolbar_rect.height)
    681694        self.board_drawer.set_mouse_selection(x, y)
    682695
    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)
     696    def _size_allocate_cb(self, widget, rect):
     697        self.width = rect.width
     698        self.height = rect.height
     699
     700    def _draw_event_cb(self, widget, cr):
     701        alloc = self.get_allocation()
     702        cr.rectangle(0, 0, alloc.width, alloc.height)
     703        self._draw(cr, alloc.width, alloc.height)
    692704
    693705    def _draw(self, cr, width, height):
    694706        cr.set_source_rgb(*_BG_COLOR)
    … … class _PreviewWidget(gtk.DrawingArea): 
    737749    def _draw_grid(self, cr):
    738750        cr.save()
    739751        cr.translate(self._drawer_rect.x, self._drawer_rect.y)
    740         self._drawer.draw(cr, self._drawer_rect.width, self._drawer_rect.height)
     752        self._drawer.draw(cr, self._drawer_rect.width,
     753                          self._drawer_rect.height)
    741754        cr.restore()
    742755
    743756    def _draw_click(self, cr):
    … … class _PreviewWidget(gtk.DrawingArea): 
    803816
    804817        cr.restore()
    805818
    806     def do_size_allocate(self, allocation):
    807         super(_PreviewWidget, self).do_size_allocate(self, allocation)
    808         (width, height) = (allocation.width, allocation.height)
     819    def _configure_event_cb(self, widget, event):
     820        (width, height) = (event.width, event.height)
    809821
    810         avail_width = width - _DEFAULT_SPACING * 2
    811         other_height = avail_width * 3 / 4
     822        actual_width = width - style.GRID_CELL_SIZE * 4
     823        actual_height = actual_width * 3 / 4
    812824
    813         avail_height = height - _DEFAULT_SPACING * 2
    814         other_width = avail_height * 4 / 3
    815 
    816         if other_height < avail_height:
    817             actual_width = avail_width
    818             actual_height = other_height
    819         else:
    820             actual_width = other_width
    821             actual_height = avail_height
     825        self.set_size_request(actual_width, actual_height)
    822826
    823827        icon_height = int(math.ceil(actual_height * _ICON_HEIGHT))
    824828        board_height = actual_height - icon_height
    … … class _PreviewWidget(gtk.DrawingArea): 
    826830        x_offset = (width - actual_width) / 2
    827831        y_offset = (height - actual_height) / 2
    828832
    829         old_width = self._preview_rect.width
    830         old_height = self._preview_rect.height
    831 
    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)
     833        self._preview_rect = Gdk.Rectangle()
     834        self._preview_rect.x = x_offset
     835        self._preview_rect.y = y_offset
     836        self._preview_rect.width = actual_width
     837        self._preview_rect.height = actual_height
     838
     839        self._toolbar_rect = Gdk.Rectangle()
     840        self._toolbar_rect.x = x_offset
     841        self._toolbar_rect.y = y_offset
     842        self._toolbar_rect.width = actual_width
     843        self._toolbar_rect.height = icon_height
     844
     845        self._drawer_rect = Gdk.Rectangle()
     846        self._drawer_rect.x = x_offset
     847        self._drawer_rect.y = y_offset + icon_height
     848        self._drawer_rect.width = actual_width
     849        self._drawer_rect.height = board_height
     850
    844851        self.board_drawer.resize(actual_width, board_height)
    845852        self.removal_drawer.resize(actual_width, board_height)
    846853        self.win_drawer.resize(actual_width, board_height)
    … … def _get_icon_handle(file_path): 
    886893    if file_path not in _icon_handles:
    887894        with open(file_path, 'r') as f:
    888895            data = f.read()
    889         _icon_handles[file_path] = rsvg.Handle(data=data)
     896        _icon_handles[file_path] = Rsvg.Handle.new_from_data(data)
    890897
    891898    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()