Attachments you submit will be routed for moderation. If you have an account, please log in first.

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

File 0001-Port-to-Gtk3-SL-3760.patch, 25.3 KB (added by humitos, 10 months 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) 
    … …  
    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 
    … …  
    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 
    … …  
    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() 
    … …  
    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  
    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 
    … …  
    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 
    … …  
    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. 
    … …  
    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 
    … …  
    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 
    … …  
    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]: 
    … …  
    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) 
    … …  
    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. 
    … …  
    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 
    … …  
    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 
    … …  
    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: 
    … …  
    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): 
    … …  
    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') 
    … …  
    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 
    … …  
    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() 
    … …  
    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: 
    … …  
    856839 
    857840 
    858841if __name__ == '__main__': 
    859     window = gtk.Window() 
     842    window = Gtk.Window() 
    860843 
    861844    view = VideoWidget() 
    862845 
    … …  
    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) 
    … …  
    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 
    … …  
    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)