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

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

  • ControlToolbar.py 

    From 7a4eb9bc2b1a1d47ef30386a983ce13ca552de73 Mon Sep 17 00:00:00 2001
From: Manuel Kaufmann <humitos@gmail.com>
Date: Mon, 16 Jul 2012 08:21:42 -0300
Subject: [PATCH Jukebox] Port to Gtk3 SL #3760

This commit ports completely the Jukebox Activity to Gtk3.

Signed-off-by: Manuel Kaufmann <humitos@gmail.com>
---
 ControlToolbar.py  |   58 +++++++------
 jukeboxactivity.py |  243 ++++++++++++++++++++++++----------------------------
 setup.py           |    2 +-
 widgets.py         |   43 +++++-----
 4 files changed, 169 insertions(+), 177 deletions(-)

diff --git a/ControlToolbar.py b/ControlToolbar.py
index 87a9b50..2205bde 100644
    a b  
    1515# along with this program; if not, write to the Free Software
    1616# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
    1717
     18import logging
     19
    1820from gettext import gettext as _
    1921
    20 import gobject
    21 import gtk
     22from gi.repository import GObject
     23from gi.repository import Gtk
    2224
    23 from sugar.graphics.toolbutton import ToolButton
    24 from sugar.graphics.toggletoolbutton import ToggleToolButton
     25from sugar3.graphics.toolbutton import ToolButton
     26from sugar3.graphics.toggletoolbutton import ToggleToolButton
    2527
    2628
    27 class ViewToolbar(gtk.Toolbar):
     29class ViewToolbar(Gtk.Toolbar):
    2830    __gtype_name__ = 'ViewToolbar'
    2931
    3032    __gsignals__ = {
    31         'go-fullscreen': (gobject.SIGNAL_RUN_FIRST,
    32                           gobject.TYPE_NONE,
     33        'go-fullscreen': (GObject.SignalFlags.RUN_FIRST,
     34                          None,
    3335                         ([])),
    34         'toggle-playlist': (gobject.SIGNAL_RUN_FIRST,
    35                             gobject.TYPE_NONE,
     36        'toggle-playlist': (GObject.SignalFlags.RUN_FIRST,
     37                            None,
    3638                            ([]))
    3739    }
    3840
    3941    def __init__(self):
    40         gtk.Toolbar.__init__(self)
     42        GObject.GObject.__init__(self)
    4143
    4244        self._show_playlist = ToggleToolButton('view-list')
    4345        self._show_playlist.set_active(True)
    … … class ViewToolbar(gtk.Toolbar): 
    5961        self.emit('toggle-playlist')
    6062
    6163
    62 class Control(gobject.GObject):
     64class Control(GObject.GObject):
    6365    """Class to create the Control (play) toolbar"""
    6466
    6567    def __init__(self, toolbar, jukebox):
    66         gobject.GObject.__init__(self)
     68        GObject.GObject.__init__(self)
    6769
    6870        self.toolbar = toolbar
    6971        self.jukebox = jukebox
    … … class Control(gobject.GObject): 
    8082                 jukebox._erase_playlist_entry_clicked_cb)
    8183        self.toolbar.insert(erase_playlist_entry_btn, -1)
    8284
    83         spacer = gtk.SeparatorToolItem()
     85        spacer = Gtk.SeparatorToolItem()
    8486        self.toolbar.insert(spacer, -1)
    8587        spacer.show()
    8688
    … … class Control(gobject.GObject): 
    9092        self.prev_button.connect('clicked', self.prev_button_clicked_cb)
    9193        self.toolbar.insert(self.prev_button, -1)
    9294
    93         self.pause_image = gtk.image_new_from_stock(gtk.STOCK_MEDIA_PAUSE,
    94                                                     gtk.ICON_SIZE_BUTTON)
     95        self.pause_image = Gtk.Image.new_from_stock(Gtk.STOCK_MEDIA_PAUSE,
     96                                                    Gtk.IconSize.BUTTON)
    9597        self.pause_image.show()
    96         self.play_image = gtk.image_new_from_stock(gtk.STOCK_MEDIA_PLAY,
    97                                                    gtk.ICON_SIZE_BUTTON)
     98        self.play_image = Gtk.Image.new_from_stock(Gtk.STOCK_MEDIA_PLAY,
     99                                                   Gtk.IconSize.BUTTON)
    98100        self.play_image.show()
    99101
    100         self.button = gtk.ToolButton()
     102        self.button = Gtk.ToolButton()
    101103        self.button.set_icon_widget(self.play_image)
    102104        self.button.set_property('can-default', True)
    103105        self.button.show()
    … … class Control(gobject.GObject): 
    111113        self.next_button.connect('clicked', self.next_button_clicked_cb)
    112114        self.toolbar.insert(self.next_button, -1)
    113115
    114         current_time = gtk.ToolItem()
    115         self.current_time_label = gtk.Label('')
     116        current_time = Gtk.ToolItem()
     117        self.current_time_label = Gtk.Label(label='')
    116118        current_time.add(self.current_time_label)
    117119        current_time.show()
    118120        toolbar.insert(current_time, -1)
    119121
    120         self.adjustment = gtk.Adjustment(0.0, 0.00, 100.0, 0.1, 1.0, 1.0)
    121         self.hscale = gtk.HScale(self.adjustment)
     122        self.adjustment = Gtk.Adjustment(0.0, 0.00, 100.0, 0.1, 1.0, 1.0)
     123        self.hscale = Gtk.Scale(orientation=Gtk.Orientation.HORIZONTAL,
     124                                adjustment=self.adjustment)
    122125        self.hscale.set_draw_value(False)
    123         self.hscale.set_update_policy(gtk.UPDATE_CONTINUOUS)
     126        # FIXME: this seems to be deprecated
     127        # self.hscale.set_update_policy(Gtk.UPDATE_CONTINUOUS)
     128        logging.debug("FIXME: AttributeError: 'Scale' object has no "
     129                      "attribute 'set_update_policy'")
    124130        self.hscale.connect('button-press-event',
    125131                jukebox.scale_button_press_cb)
    126132        self.hscale.connect('button-release-event',
    127133                jukebox.scale_button_release_cb)
    128134
    129         self.scale_item = gtk.ToolItem()
     135        self.scale_item = Gtk.ToolItem()
    130136        self.scale_item.set_expand(True)
    131137        self.scale_item.add(self.hscale)
    132138        self.toolbar.insert(self.scale_item, -1)
    133139
    134         total_time = gtk.ToolItem()
    135         self.total_time_label = gtk.Label('')
     140        total_time = Gtk.ToolItem()
     141        self.total_time_label = Gtk.Label(label='')
    136142        total_time.add(self.total_time_label)
    137143        total_time.show()
    138144        toolbar.insert(total_time, -1)

  • jukeboxactivity.py 

    diff --git a/jukeboxactivity.py b/jukeboxactivity.py
index 8ad59d6..7062fc3 100644
    a b import tempfile 
    2727from gettext import gettext as _
    2828import os
    2929
    30 from sugar.activity import activity
    31 from sugar.graphics.objectchooser import ObjectChooser
    32 from sugar import mime
    33 from sugar.datastore import datastore
     30from sugar3.activity import activity
     31from sugar3.graphics.objectchooser import ObjectChooser
     32from sugar3 import mime
     33from sugar3.datastore import datastore
    3434
    35 OLD_TOOLBAR = False
    36 try:
    37     from sugar.graphics.toolbarbox import ToolbarBox
    38     from sugar.graphics.toolbarbox import ToolbarButton
    39     from sugar.activity.widgets import StopButton
    40     from sugar.activity.widgets import ActivityToolbarButton
     35from sugar3.graphics.toolbarbox import ToolbarBox
     36from sugar3.graphics.toolbarbox import ToolbarButton
     37from sugar3.activity.widgets import StopButton
     38from sugar3.activity.widgets import ActivityToolbarButton
    4139
    42 except ImportError:
    43     OLD_TOOLBAR = True
     40import gi
     41gi.require_version('Gtk', '3.0')
    4442
    45 import pygtk
    46 pygtk.require('2.0')
    47 
    48 import gobject
     43from gi.repository import GObject
     44from gi.repository import Gdk
    4945
    5046import pygst
    5147pygst.require('0.10')
    5248import gst
    5349import gst.interfaces
    54 import gtk
     50from gi.repository import Gtk
    5551
    5652import urllib
    5753from ControlToolbar import Control, ViewToolbar
    … … class JukeboxActivity(activity.Activity): 
    7470        self.max_participants = 1
    7571        self._playlist_jobject = None
    7672
    77         if OLD_TOOLBAR:
    78             toolbox = activity.ActivityToolbox(self)
    79             self.set_toolbox(toolbox)
    80             toolbar = gtk.Toolbar()
    81             self.control = Control(toolbar, self)
    82             toolbox.add_toolbar(_('Play'), toolbar)
    83 
    84             toolbar.show()
    85 
    86             _view_toolbar = ViewToolbar()
    87             _view_toolbar.connect('go-fullscreen',
    88                     self.__go_fullscreen_cb)
    89             _view_toolbar.connect('toggle-playlist',
    90                     self.__toggle_playlist_cb)
    91             toolbox.add_toolbar(_('View'), _view_toolbar)
    92             _view_toolbar.show()
    93 
    94             toolbox.show()
    95 
    96             toolbar.grab_focus()
    97             #self.connect("shared", self._shared_cb)
    98             activity_toolbar = toolbox.get_activity_toolbar()
    99             activity_toolbar.remove(activity_toolbar.share)
    100             activity_toolbar.share = None
    101             activity_toolbar.remove(activity_toolbar.keep)
    102             activity_toolbar.keep = None
    103             self.title_entry = activity_toolbar.title
     73        toolbar_box = ToolbarBox()
     74        activity_button = ActivityToolbarButton(self)
     75        activity_toolbar = activity_button.page
     76        toolbar_box.toolbar.insert(activity_button, 0)
     77        self.title_entry = activity_toolbar.title
     78
     79        # FIXME: I don't know what is the mission of this line
     80        # activity_toolbar.stop.hide()
     81
     82        _view_toolbar = ViewToolbar()
     83        _view_toolbar.connect('go-fullscreen',
     84                              self.__go_fullscreen_cb)
     85        _view_toolbar.connect('toggle-playlist',
     86                              self.__toggle_playlist_cb)
     87        view_toolbar_button = ToolbarButton(
     88            page=_view_toolbar,
     89            icon_name='toolbar-view')
     90        _view_toolbar.show()
     91        toolbar_box.toolbar.insert(view_toolbar_button, -1)
     92        view_toolbar_button.show()
     93
     94        self.control = Control(toolbar_box.toolbar, self)
     95
     96        toolbar_box.toolbar.insert(StopButton(self), -1)
     97
     98        self.set_toolbar_box(toolbar_box)
     99        toolbar_box.show_all()
    104100
    105         else:
    106             toolbar_box = ToolbarBox()
    107             activity_button = ActivityToolbarButton(self)
    108             activity_toolbar = activity_button.page
    109             toolbar_box.toolbar.insert(activity_button, 0)
    110             self.title_entry = activity_toolbar.title
    111             activity_toolbar.stop.hide()
    112 
    113             _view_toolbar = ViewToolbar()
    114             _view_toolbar.connect('go-fullscreen',
    115                     self.__go_fullscreen_cb)
    116             _view_toolbar.connect('toggle-playlist',
    117                     self.__toggle_playlist_cb)
    118             view_toolbar_button = ToolbarButton(
    119                     page=_view_toolbar,
    120                     icon_name='toolbar-view')
    121             _view_toolbar.show()
    122             toolbar_box.toolbar.insert(view_toolbar_button, -1)
    123             view_toolbar_button.show()
    124 
    125             self.control = Control(toolbar_box.toolbar, self)
    126 
    127             toolbar_box.toolbar.insert(StopButton(self), -1)
    128 
    129             self.set_toolbar_box(toolbar_box)
    130             toolbar_box.show_all()
    131101        self.connect("key_press_event", self._key_press_event_cb)
    132102
    133         if handle.uri:
    134             pass
    135         elif self._shared_activity:
    136             if self.get_shared():
    137                 pass
    138             else:
    139                 # Wait for a successful join before trying to get the document
    140                 self.connect("joined", self._joined_cb)
     103        # FIXME: this is related with shared activity and it doesn't work
     104        # if handle.uri:
     105        #     pass
     106        # elif self._shared_activity:
     107        #     if self.get_shared():
     108        #         pass
     109        #     else:
     110        #         # Wait for a successful join before trying to get the document
     111        #         self.connect("joined", self._joined_cb)
    141112
    142113        self.update_id = -1
    143114        self.changed_id = -1
    … … class JukeboxActivity(activity.Activity): 
    162133        self.p_position = gst.CLOCK_TIME_NONE
    163134        self.p_duration = gst.CLOCK_TIME_NONE
    164135
    165         self.bin = gtk.HBox()
    166         self.bin.show()
     136        # README: I changed this because I was getting an error when I
     137        # tried to modify self.bin with something different than
     138        # Gtk.Bin
     139
     140        # self.bin = Gtk.HBox()
     141        # self.bin.show()
     142
     143        self.canvas = Gtk.Box(orientation=Gtk.Orientation.HORIZONTAL)
     144
    167145        self.playlist_widget = PlayListWidget(self.play)
    168146        self.playlist_widget.update(self.playlist)
    169147        self.playlist_widget.show()
    170         self.bin.pack_start(self.playlist_widget, expand=False)
    171         self._empty_widget = gtk.Label("")
     148        self.canvas.pack_start(self.playlist_widget, False, True, 0)
     149        self._empty_widget = Gtk.Label(label="")
    172150        self._empty_widget.show()
    173151        self.videowidget = VideoWidget()
    174152        self._switch_canvas(show_video=False)
    175         self.set_canvas(self.bin)
     153        self.set_canvas(self.canvas)
    176154        self.show_all()
    177         self.bin.connect('size-allocate', self.__size_allocate_cb)
     155        self.canvas.connect('size-allocate', self.__size_allocate_cb)
    178156
    179157        #From ImageViewer Activity
    180158        self._want_document = True
    181159        if self._object_id is None:
    182             self._show_object_picker = gobject.timeout_add(1000, \
     160            self._show_object_picker = GObject.timeout_add(1000, \
    183161            self._show_picker_cb)
    184162
    185163        if handle.uri:
    186164            self.uri = handle.uri
    187             gobject.idle_add(self._start, self.uri, handle.title)
     165            GObject.idle_add(self._start, self.uri, handle.title)
    188166
    189167    def _switch_canvas(self, show_video):
    190168        """Show or hide the video visualization in the canvas.
    … … class JukeboxActivity(activity.Activity): 
    194172
    195173        """
    196174        if show_video:
    197             self.bin.remove(self._empty_widget)
    198             self.bin.pack_end(self.videowidget)
     175            self.canvas.remove(self._empty_widget)
     176            self.canvas.pack_end(self.videowidget, True, True, 0)
    199177        else:
    200             self.bin.pack_end(self._empty_widget)
    201             self.bin.remove(self.videowidget)
    202         self.bin.queue_draw()
     178            self.canvas.pack_end(self._empty_widget, True, True, 0)
     179            self.canvas.remove(self.videowidget)
     180        self.canvas.queue_draw()
    203181
    204182    def __get_tags_cb(self, tags_reader, order, tags):
    205183        self.playlist[order]['title'] = tags['title']
    206184        self.playlist_widget.update(self.playlist)
    207185
    208186    def __size_allocate_cb(self, widget, allocation):
    209         canvas_size = self.bin.get_allocation()
     187        canvas_size = self.canvas.get_allocation()
    210188        playlist_width = int(canvas_size.width * PLAYLIST_WIDTH_PROP)
    211189        self.playlist_widget.set_size_request(playlist_width, 0)
    212190
    … … class JukeboxActivity(activity.Activity): 
    219197        #self.currentplaying = None
    220198        #self.playflag = False
    221199        self._want_document = True
    222         self._show_object_picker = gobject.timeout_add(1, self._show_picker_cb)
     200        self._show_object_picker = GObject.timeout_add(1, self._show_picker_cb)
    223201
    224202    def _key_press_event_cb(self, widget, event):
    225         keyname = gtk.gdk.keyval_name(event.keyval)
     203        keyname = Gdk.keyval_name(event.keyval)
    226204        logging.info("Keyname Press: %s, time: %s", keyname, event.time)
    227205        if self.title_entry.has_focus():
    228206            return False
    … … class JukeboxActivity(activity.Activity): 
    289267        self.player.stop()
    290268        self.player.set_uri(None)
    291269        self.control.set_disabled()
    292         self.bin.remove(self.videowidget)
    293         text = gtk.Label("Error: %s - %s" % (message, detail))
     270        self.canvas.remove(self.videowidget)
     271        text = Gtk.Label("Error: %s - %s" % (message, detail))
    294272        text.show_all()
    295         self.bin.add(text)
     273        self.canvas.add(text)
    296274
    297275    def _player_new_tag_cb(self, widget, tag, value):
    298276        if not tag in [gst.TAG_TITLE, gst.TAG_ARTIST, gst.TAG_ALBUM]:
    … … class JukeboxActivity(activity.Activity): 
    342320        if not self._want_document:
    343321            return
    344322
    345         chooser = ObjectChooser(_('Choose document'), self,
    346             gtk.DIALOG_MODAL |
    347             gtk.DIALOG_DESTROY_WITH_PARENT,
    348             what_filter=mime.GENERIC_TYPE_AUDIO)
     323        # README: some arguments are deprecated so I avoid them
     324
     325        # chooser = ObjectChooser(_('Choose document'), self,
     326        #     Gtk.DialogFlags.MODAL |
     327        #     Gtk.DialogFlags.DESTROY_WITH_PARENT,
     328        #     what_filter=mime.GENERIC_TYPE_AUDIO)
     329
     330        chooser = ObjectChooser(self, what_filter=mime.GENERIC_TYPE_AUDIO)
    349331
    350332        try:
    351333            result = chooser.run()
    352             if result == gtk.RESPONSE_ACCEPT:
     334            if result == Gtk.ResponseType.ACCEPT:
    353335                jobject = chooser.get_selected_object()
    354336                if jobject and jobject.file_path:
    355337                    logging.error('Adding %s', jobject.file_path)
    … … class JukeboxActivity(activity.Activity): 
    376358        if mimetype == 'audio/x-mpegurl':
    377359            # is a M3U playlist:
    378360            for uri in self._read_m3u_playlist(file_path):
    379                 gobject.idle_add(self._start, uri['url'], uri['title'],
     361                GObject.idle_add(self._start, uri['url'], uri['title'],
    380362                        uri['object_id'])
    381363        else:
    382364            # is another media file:
    383             gobject.idle_add(self._start, self.uri, title, object_id)
     365            GObject.idle_add(self._start, self.uri, title, object_id)
    384366
    385367    def _create_playlist_jobject(self):
    386368        """Create an object in the Journal to store the playlist.
    … … class JukeboxActivity(activity.Activity): 
    536518            else:
    537519                self.player.play()
    538520                if self.update_id == -1:
    539                     self.update_id = gobject.timeout_add(self.UPDATE_INTERVAL,
     521                    self.update_id = GObject.timeout_add(self.UPDATE_INTERVAL,
    540522                                                         self.update_scale_cb)
    541523                self.control.set_button_pause()
    542524
    … … class JukeboxActivity(activity.Activity): 
    552534
    553535        # don't timeout-update position during seek
    554536        if self.update_id != -1:
    555             gobject.source_remove(self.update_id)
     537            GObject.source_remove(self.update_id)
    556538            self.update_id = -1
    557539
    558540        # make sure we get changed notifies
    … … class JukeboxActivity(activity.Activity): 
    574556
    575557        self.control.button.set_sensitive(True)
    576558        if self.seek_timeout_id != -1:
    577             gobject.source_remove(self.seek_timeout_id)
     559            GObject.source_remove(self.seek_timeout_id)
    578560            self.seek_timeout_id = -1
    579561        else:
    580562            if self.was_playing:
    … … class JukeboxActivity(activity.Activity): 
    583565        if self.update_id != -1:
    584566            self.error('Had a previous update timeout id')
    585567        else:
    586             self.update_id = gobject.timeout_add(self.UPDATE_INTERVAL,
     568            self.update_id = GObject.timeout_add(self.UPDATE_INTERVAL,
    587569                self.update_scale_cb)
    588570
    589571    def update_scale_cb(self):
    … … class JukeboxActivity(activity.Activity): 
    617599            self.playlist_widget.hide()
    618600        else:
    619601            self.playlist_widget.show_all()
    620         self.bin.queue_draw()
     602        self.canvas.queue_draw()
    621603
    622604
    623 class TagReader(gobject.GObject):
     605class TagReader(GObject.GObject):
    624606
    625607    __gsignals__ = {
    626         'get-tags': (gobject.SIGNAL_RUN_FIRST, None, [int, object]),
     608        'get-tags': (GObject.SignalFlags.RUN_FIRST, None, [int, object]),
    627609    }
    628610
    629611    def __init__(self):
    630         gobject.GObject.__init__(self)
     612        GObject.GObject.__init__(self)
    631613        #make a playbin to parse the audio file
    632614        self.pbin = gst.element_factory_make('playbin', 'player')
    633615        fakesink = gst.element_factory_make('fakesink', 'fakesink')
    … … class TagReader(gobject.GObject): 
    661643        self.pbin.set_state(gst.STATE_PAUSED)
    662644
    663645
    664 class GstPlayer(gobject.GObject):
     646class GstPlayer(GObject.GObject):
    665647
    666648    __gsignals__ = {
    667         'error': (gobject.SIGNAL_RUN_FIRST, None, [str, str]),
    668         'eos': (gobject.SIGNAL_RUN_FIRST, None, []),
    669         'tag': (gobject.SIGNAL_RUN_FIRST, None, [str, str]),
    670         'stream-info': (gobject.SIGNAL_RUN_FIRST, None, [object])
     649        'error': (GObject.SignalFlags.RUN_FIRST, None, [str, str]),
     650        'eos': (GObject.SignalFlags.RUN_FIRST, None, []),
     651        'tag': (GObject.SignalFlags.RUN_FIRST, None, [str, str]),
     652        'stream-info': (GObject.SignalFlags.RUN_FIRST, None, [object])
    671653    }
    672654
    673655    def __init__(self, videowidget):
    674         gobject.GObject.__init__(self)
     656        GObject.GObject.__init__(self)
    675657
    676658        self.playing = False
    677659        self.error = False
    … … class GstPlayer(gobject.GObject): 
    689671        self.overlay = None
    690672        videowidget.realize()
    691673        self.videowidget = videowidget
    692         self.videowidget_xid = videowidget.window.xid
     674        self.videowidget_xid = videowidget.get_window().get_xid()
    693675        self._init_video_sink()
    694676
    695677        bus = self.player.get_bus()
    … … class GstPlayer(gobject.GObject): 
    831813        return self.playing
    832814
    833815
    834 class VideoWidget(gtk.DrawingArea):
     816class VideoWidget(Gtk.DrawingArea):
    835817    def __init__(self):
    836         gtk.DrawingArea.__init__(self)
    837         self.set_events(gtk.gdk.POINTER_MOTION_MASK |
    838         gtk.gdk.POINTER_MOTION_HINT_MASK |
    839         gtk.gdk.EXPOSURE_MASK |
    840         gtk.gdk.KEY_PRESS_MASK |
    841         gtk.gdk.KEY_RELEASE_MASK)
     818        GObject.GObject.__init__(self)
     819        self.set_events(Gdk.EventMask.POINTER_MOTION_MASK |
     820        Gdk.EventMask.POINTER_MOTION_HINT_MASK |
     821        Gdk.EventMask.EXPOSURE_MASK |
     822        Gdk.EventMask.KEY_PRESS_MASK |
     823        Gdk.EventMask.KEY_RELEASE_MASK)
    842824        self.imagesink = None
    843         self.unset_flags(gtk.DOUBLE_BUFFERED)
    844         self.set_flags(gtk.APP_PAINTABLE)
     825
     826        self.set_app_paintable(True)
     827        self.set_double_buffered(False)
    845828
    846829    def do_expose_event(self, event):
    847830        if self.imagesink:
    … … class VideoWidget(gtk.DrawingArea): 
    856839
    857840
    858841if __name__ == '__main__':
    859     window = gtk.Window()
     842    window = Gtk.Window()
    860843
    861844    view = VideoWidget()
    862845
    … … if __name__ == '__main__': 
    873856    player.set_uri('http://78.46.73.237:8000/prog')
    874857    player.play()
    875858    window.show_all()
    876     gtk.main()
     859    Gtk.main()

  • setup.py 

    diff --git a/setup.py b/setup.py
index d3ab3a3..2f2c143 100755
    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 from sugar.activity import bundlebuilder
     19from sugar3.activity import bundlebuilder
    2020
    2121bundlebuilder.start()

  • widgets.py 

    diff --git a/widgets.py b/widgets.py
index bd09a73..2dd5742 100644
    a b  
    1616import logging
    1717from gettext import gettext as _
    1818
    19 import pygtk
    20 pygtk.require('2.0')
     19import gi
     20gi.require_version('Gtk', '3.0')
    2121
    22 import gobject
    23 import gtk
    24 import pango
     22from gi.repository import GObject
     23from gi.repository import Gtk
     24from gi.repository import Pango
    2525
    2626
    2727COLUMNS_NAME = ('index', 'media')
    2828COLUMNS = dict((name, i) for i, name in enumerate(COLUMNS_NAME))
    2929
    3030
    31 class PlayListWidget(gtk.ScrolledWindow):
     31class PlayListWidget(Gtk.ScrolledWindow):
    3232    def __init__(self, play_callback):
    3333        self._playlist = None
    3434        self._play_callback = play_callback
    3535
    36         gtk.ScrolledWindow.__init__(self, hadjustment=None,
     36        GObject.GObject.__init__(self, hadjustment=None,
    3737                                    vadjustment=None)
    38         self.set_policy(gtk.POLICY_NEVER, gtk.POLICY_AUTOMATIC)
    39         self.listview = gtk.TreeView()
    40         self.treemodel = gtk.ListStore(int, object)
     38        self.set_policy(Gtk.PolicyType.NEVER, Gtk.PolicyType.AUTOMATIC)
     39        self.listview = Gtk.TreeView()
     40        self.treemodel = Gtk.ListStore(int, object)
    4141        self.listview.set_model(self.treemodel)
    4242        selection = self.listview.get_selection()
    43         selection.set_mode(gtk.SELECTION_SINGLE)
     43        selection.set_mode(Gtk.SelectionMode.SINGLE)
    4444
    45         renderer_idx = gtk.CellRendererText()
    46         treecol_idx = gtk.TreeViewColumn(_('No.'))
     45        renderer_idx = Gtk.CellRendererText()
     46        treecol_idx = Gtk.TreeViewColumn(_('No.'))
    4747        treecol_idx.pack_start(renderer_idx, True)
    4848        treecol_idx.set_cell_data_func(renderer_idx, self._set_number)
    4949        self.listview.append_column(treecol_idx)
    5050
    51         renderer_title = gtk.CellRendererText()
    52         renderer_title.set_property('ellipsize', pango.ELLIPSIZE_END)
    53         treecol_title = gtk.TreeViewColumn(_('Play List'))
     51        renderer_title = Gtk.CellRendererText()
     52        renderer_title.set_property('ellipsize', Pango.EllipsizeMode.END)
     53        treecol_title = Gtk.TreeViewColumn(_('Play List'))
    5454        treecol_title.pack_start(renderer_title, True)
    5555        treecol_title.set_cell_data_func(renderer_title, self._set_title)
    5656        self.listview.append_column(treecol_title)
    … … class PlayListWidget(gtk.ScrolledWindow): 
    6464
    6565    def __on_row_activated(self, treeview, path, col):
    6666        model = treeview.get_model()
    67         media_idx = path[COLUMNS['index']]
     67
     68        treeiter = model.get_iter(path)
     69        media_idx = model.get_value(treeiter, COLUMNS['index'])
    6870        self._play_callback(media_idx)
    6971
    70     def _set_number(self, column, cell, model, it):
     72    def _set_number(self, column, cell, model, it, data):
    7173        idx = model.get_value(it, COLUMNS['index'])
    7274        cell.set_property('text', idx + 1)
    7375
    74     def _set_title(self, column, cell, model, it):
     76    def _set_title(self, column, cell, model, it, data):
    7577        playlist_item = model.get_value(it, COLUMNS['media'])
    7678        cell.set_property('text', playlist_item['title'])
    7779
    … … class PlayListWidget(gtk.ScrolledWindow): 
    9092        selection = self.listview.get_selection()
    9193        sel_model, sel_rows = self.listview.get_selection().get_selected_rows()
    9294        for row in sel_rows:
    93             self._playlist.pop(row[0])
     95            index = sel_model.get_value(sel_model.get_iter(row), 0)
     96            self._playlist.pop(index)
    9497            self.treemodel.remove(self.treemodel.get_iter(row))
    9598        self.update(self._playlist)