modified: Making_Activities_Using_PyGame_gtk3/DemoiselleActivity.py

modified:   Making_Activities_Using_PyGame_gtk3/activity/activity.info
modified:   Making_Activities_Using_PyGame_gtk3/demoiselle2.py
modified:   Making_Activities_Using_PyGame_gtk3/sugargame/__init__.py
modified:   Making_Activities_Using_PyGame_gtk3/sugargame/canvas.py
modified:   Making_Activities_Using_PyGame_gtk3/sugargame/event.py
Update the Demoiselle Activity to sugar 3 and GTK 3.

6 files changed, 137 insertions, 90 deletions

diff --git a/Making_Activities_Using_PyGame_gtk3/DemoiselleActivity.py b/Making_Activities_Using_PyGame_gtk3/DemoiselleActivity.py
index 2c6c99f..f675b68 100644
--- a/Making_Activities_Using_PyGame_gtk3/DemoiselleActivity.py
+++ b/Making_Activities_Using_PyGame_gtk3/DemoiselleActivity.py
@@ -1,6 +1,6 @@
 # DemoiselleActivity.py 
 
-# Copyright (C) 2010  James D. Simmons
+# Copyright (C) 2014  James D. Simmons
 #
 # This program is free software; you can redistribute it and/or modify
 # it under the terms of the GNU General Public License as published by
@@ -19,11 +19,15 @@
 
 from gettext import gettext as _
 
-import gtk
+from gi.repository import Gtk
 import pygame
-from sugar.activity import activity
-from sugar.graphics.toolbutton import ToolButton
-import gobject
+from sugar3.activity import activity
+from sugar3.graphics.toolbutton import ToolButton
+from sugar3.graphics.toolbarbox import ToolbarButton
+from sugar3.graphics.toolbarbox import ToolbarBox
+from sugar3.activity.widgets import StopButton
+from sugar3.activity.widgets import ActivityToolbar
+from gi.repository import GObject
 import sugargame.canvas
 import demoiselle2
 
@@ -47,20 +51,32 @@ class DemoiselleActivity(activity.Activity):
         self._pygamecanvas.run_pygame(self.game.run)
         
     def build_toolbar(self):
-        toolbox = activity.ActivityToolbox(self)
-        activity_toolbar = toolbox.get_activity_toolbar()
-        activity_toolbar.keep.props.visible = False
-        activity_toolbar.share.props.visible = False
-        
-        self.view_toolbar = ViewToolbar()
-        toolbox.add_toolbar(_('View'), self.view_toolbar)
-        self.view_toolbar.connect('go-fullscreen',
+        toolbar_box = ToolbarBox()
+
+        view_toolbar = ViewToolbar()
+        view_toolbar.connect('go-fullscreen',
                 self.view_toolbar_go_fullscreen_cb)
-        self.view_toolbar.show()
+        view_toolbar.show()
+        view_toolbar_button = ToolbarButton(
+            page=view_toolbar,
+            icon_name='toolbar-view')
+        toolbar_box.toolbar.insert(view_toolbar_button, -1)
+        view_toolbar_button.show()
 
-        toolbox.show()
-        self.set_toolbox(toolbox)
+        separator = Gtk.SeparatorToolItem()
+        separator.props.draw = False
+        separator.set_expand(True)
+        toolbar_box.toolbar.insert(separator, -1)
+        separator.show()
 
+        stop_button = StopButton(self)
+        stop_button.props.accelerator = '<Ctrl><Shift>Q'
+        toolbar_box.toolbar.insert(stop_button, -1)
+        stop_button.show()
+
+        self.set_toolbar_box(toolbar_box)
+        toolbar_box.show()
+        
     def view_toolbar_go_fullscreen_cb(self, view_toolbar):
         self.fullscreen()
 
@@ -79,20 +95,20 @@ class DemoiselleActivity(activity.Activity):
         finally:
             f.close
 
-class ViewToolbar(gtk.Toolbar):
+class ViewToolbar(Gtk.Toolbar):
     __gtype_name__ = 'ViewToolbar'
 
     __gsignals__ = {
-        'needs-update-size': (gobject.SIGNAL_RUN_FIRST,
-                              gobject.TYPE_NONE,
+        'needs-update-size': (GObject.SIGNAL_RUN_FIRST,
+                              GObject.TYPE_NONE,
                               ([])),
-        'go-fullscreen': (gobject.SIGNAL_RUN_FIRST,
-                          gobject.TYPE_NONE,
+        'go-fullscreen': (GObject.SIGNAL_RUN_FIRST,
+                          GObject.TYPE_NONE,
                           ([]))
     }
 
     def __init__(self):
-        gtk.Toolbar.__init__(self)
+        Gtk.Toolbar.__init__(self)
         self.fullscreen = ToolButton('view-fullscreen')
         self.fullscreen.set_tooltip(_('Fullscreen'))
         self.fullscreen.connect('clicked', self.fullscreen_cb)
diff --git a/Making_Activities_Using_PyGame_gtk3/activity/activity.info b/Making_Activities_Using_PyGame_gtk3/activity/activity.info
index 2767e12..4cefa95 100644
--- a/Making_Activities_Using_PyGame_gtk3/activity/activity.info
+++ b/Making_Activities_Using_PyGame_gtk3/activity/activity.info
@@ -1,6 +1,6 @@
 [Activity]
 name = Demoiselle
-service_name = net.flossmanuals.Demoiselle
+bundle_id = net.flossmanuals.Demoiselle
 icon = read-etexts
 exec = sugar-activity DemoiselleActivity.DemoiselleActivity
 show_launcher = yes
diff --git a/Making_Activities_Using_PyGame_gtk3/demoiselle2.py b/Making_Activities_Using_PyGame_gtk3/demoiselle2.py
index 46656ca..d927c6d 100755
--- a/Making_Activities_Using_PyGame_gtk3/demoiselle2.py
+++ b/Making_Activities_Using_PyGame_gtk3/demoiselle2.py
@@ -25,7 +25,7 @@
 #
 
 import pygame
-import gtk
+from gi.repository import Gtk
 import math
 import sys
 
@@ -66,8 +66,8 @@ class Demoiselle:
             self.clock.tick(30)
 
             # Pump GTK messages.
-            while gtk.events_pending():
-                gtk.main_iteration()
+            while Gtk.events_pending():
+                Gtk.main_iteration()
  
             # Pump PyGame messages.
             for event in pygame.event.get():
diff --git a/Making_Activities_Using_PyGame_gtk3/sugargame/__init__.py b/Making_Activities_Using_PyGame_gtk3/sugargame/__init__.py
index 7e49527..439eb0c 100644
--- a/Making_Activities_Using_PyGame_gtk3/sugargame/__init__.py
+++ b/Making_Activities_Using_PyGame_gtk3/sugargame/__init__.py
@@ -1 +1 @@
-__version__ = '1.0'
+__version__ = '1.1'
diff --git a/Making_Activities_Using_PyGame_gtk3/sugargame/canvas.py b/Making_Activities_Using_PyGame_gtk3/sugargame/canvas.py
index cf99a13..f5f5b56 100644
--- a/Making_Activities_Using_PyGame_gtk3/sugargame/canvas.py
+++ b/Making_Activities_Using_PyGame_gtk3/sugargame/canvas.py
@@ -1,55 +1,69 @@
 import os
-import gtk
-import gobject
+from gi.repository import Gtk
+from gi.repository import GObject
 import pygame
 import event
 
 CANVAS = None
 
-class PygameCanvas(gtk.EventBox):
-    def __init__(self, mainwindow):
-        gtk.EventBox.__init__(self)
+class PygameCanvas(Gtk.EventBox):
+
+    """
+    mainwindow is the activity intself.
+    """
+    def __init__(self, mainwindow, pointer_hint = True):
+        GObject.GObject.__init__(self)
 
         global CANVAS
         assert CANVAS == None, "Only one PygameCanvas can be created, ever."
         CANVAS = self
 
+        # Initialize Events translator before widget gets "realized".
+        self.translator = event.Translator(mainwindow, self)
+
         self._mainwindow = mainwindow
 
-        self.set_flags(gtk.CAN_FOCUS)
-        
-        self._socket = gtk.Socket()
+        self.set_can_focus(True)
+
+        self._socket = Gtk.Socket()
         self.add(self._socket)
+
+        self._initialized = False
+
         self.show_all()
 
     def run_pygame(self, main_fn):
         # Run the main loop after a short delay.  The reason for the delay is that the
         # Sugar activity is not properly created until after its constructor returns.
-        # If the Pygame main loop is called from the activity constructor, the 
+        # If the Pygame main loop is called from the activity constructor, the
         # constructor never returns and the activity freezes.
-        gobject.idle_add(self._run_pygame_cb, main_fn)
+        GObject.idle_add(self._run_pygame_cb, main_fn)
 
     def _run_pygame_cb(self, main_fn):
-        assert pygame.display.get_surface() is None, "PygameCanvas.run_pygame can only be called once."
-        
+        # PygameCanvas.run_pygame can only be called once
+        if self._initialized:
+            return
+
         # Preinitialize Pygame with the X window ID.
-        assert pygame.display.get_init() == False, "Pygame must not be initialized before calling PygameCanvas.run_pygame."
         os.environ['SDL_WINDOWID'] = str(self._socket.get_id())
+        if pygame.display.get_surface() is not None:
+            pygame.display.quit()
         pygame.init()
-        
+
         # Restore the default cursor.
-        self._socket.get_window().set_cursor(None)
+        self._socket.props.window.set_cursor(None)
 
         # Initialize the Pygame window.
         r = self.get_allocation()
         pygame.display.set_mode((r.width, r.height), pygame.RESIZABLE)
 
         # Hook certain Pygame functions with GTK equivalents.
-        translator = event.Translator(self._mainwindow, self)
-        translator.hook_pygame()
+        self.translator.hook_pygame()
 
         # Run the Pygame main loop.
         main_fn()
+
+        self._initialized = True
         return False
 
     def get_pygame_widget(self):
diff --git a/Making_Activities_Using_PyGame_gtk3/sugargame/event.py b/Making_Activities_Using_PyGame_gtk3/sugargame/event.py
index 52ca4ab..f6a69b9 100644
--- a/Making_Activities_Using_PyGame_gtk3/sugargame/event.py
+++ b/Making_Activities_Using_PyGame_gtk3/sugargame/event.py
@@ -1,8 +1,8 @@
-import gtk
-import gobject
+from gi.repository import Gtk
+from gi.repository import Gdk
+from gi.repository import GObject
 import pygame
 import pygame.event
-import logging 
 
 class _MockEvent(object):
     def __init__(self, keyval):
@@ -28,7 +28,7 @@ class Translator(object):
         'KP_Right' : pygame.K_KP6,
 
     }
-    
+
     mod_map = {
         pygame.K_LALT: pygame.KMOD_LALT,
         pygame.K_RALT: pygame.KMOD_RALT,
@@ -37,39 +37,43 @@ class Translator(object):
         pygame.K_LSHIFT: pygame.KMOD_LSHIFT,
         pygame.K_RSHIFT: pygame.KMOD_RSHIFT,
     }
-    
+
     def __init__(self, mainwindow, inner_evb):
         """Initialise the Translator with the windows to which to listen"""
         self._mainwindow = mainwindow
         self._inner_evb = inner_evb
 
         # Enable events
-        self._mainwindow.set_events(
-            gtk.gdk.KEY_PRESS_MASK | \
-            gtk.gdk.KEY_RELEASE_MASK \
+        # (add instead of set here because the main window is already realized)
+        self._mainwindow.add_events(
+            Gdk.EventMask.KEY_PRESS_MASK | \
+            Gdk.EventMask.KEY_RELEASE_MASK | \
+            Gdk.EventMask.VISIBILITY_NOTIFY_MASK
         )
-        
+
         self._inner_evb.set_events(
-            gtk.gdk.POINTER_MOTION_MASK | \
-            gtk.gdk.POINTER_MOTION_HINT_MASK | \
-            gtk.gdk.BUTTON_MOTION_MASK | \
-            gtk.gdk.BUTTON_PRESS_MASK | \
-            gtk.gdk.BUTTON_RELEASE_MASK 
+            Gdk.EventMask.POINTER_MOTION_MASK | \
+            Gdk.EventMask.POINTER_MOTION_HINT_MASK | \
+            Gdk.EventMask.BUTTON_MOTION_MASK | \
+            Gdk.EventMask.BUTTON_PRESS_MASK | \
+            Gdk.EventMask.BUTTON_RELEASE_MASK
         )
 
-        self._mainwindow.set_flags(gtk.CAN_FOCUS)
-        self._inner_evb.set_flags(gtk.CAN_FOCUS)
-        
+        self._mainwindow.set_can_focus(True)
+        self._inner_evb.set_can_focus(True)
+
         # Callback functions to link the event systems
         self._mainwindow.connect('unrealize', self._quit_cb)
+        self._mainwindow.connect('visibility_notify_event', self._visibility_cb)
         self._inner_evb.connect('key_press_event', self._keydown_cb)
         self._inner_evb.connect('key_release_event', self._keyup_cb)
         self._inner_evb.connect('button_press_event', self._mousedown_cb)
         self._inner_evb.connect('button_release_event', self._mouseup_cb)
         self._inner_evb.connect('motion-notify-event', self._mousemove_cb)
-        self._inner_evb.connect('expose-event', self._expose_cb)
+        self._inner_evb.connect('draw', self._draw_cb)
         self._inner_evb.connect('configure-event', self._resize_cb)
-        
+        self._inner_evb.connect('screen-changed', self._screen_changed_cb)
+
         # Internal data
         self.__stopped = False
         self.__keystate = [0] * 323
@@ -86,9 +90,13 @@ class Translator(object):
         pygame.key.set_repeat = self._set_repeat
         pygame.mouse.get_pressed = self._get_mouse_pressed
         pygame.mouse.get_pos = self._get_mouse_pos
-        
-    def _expose_cb(self, event, widget):
+
+    def update_display(self):
         pygame.event.post(pygame.event.Event(pygame.VIDEOEXPOSE))
+
+    def _draw_cb(self, widget, event):
+        if pygame.display.get_init():
+            pygame.event.post(pygame.event.Event(pygame.VIDEOEXPOSE))
         return True
 
     def _resize_cb(self, widget, event):
@@ -97,10 +105,19 @@ class Translator(object):
         pygame.event.post(evt)
         return False # continue processing
 
+    def _screen_changed_cb(self, widget, previous_screen):
+        if pygame.display.get_init():
+            self.update_display()
+
     def _quit_cb(self, data=None):
         self.__stopped = True
         pygame.event.post(pygame.event.Event(pygame.QUIT))
 
+    def _visibility_cb(self, widget, event):
+        if pygame.display.get_init():
+            self.update_display()
+        return False
+
     def _keydown_cb(self, widget, event):
         key = event.keyval
         if key in self.__held:
@@ -110,9 +127,9 @@ class Translator(object):
                 self.__held_last_time[key] = pygame.time.get_ticks()
                 self.__held_time_left[key] = self.__repeat[0]
             self.__held.add(key)
-            
+
         return self._keyevent(widget, event, pygame.KEYDOWN)
-        
+
     def _keyup_cb(self, widget, event):
         key = event.keyval
         if self.__repeat[0] is not None:
@@ -123,19 +140,19 @@ class Translator(object):
         self.__held.discard(key)
 
         return self._keyevent(widget, event, pygame.KEYUP)
-        
+
     def _keymods(self):
         mod = 0
         for key_val, mod_val in self.mod_map.iteritems():
             mod |= self.__keystate[key_val] and mod_val
         return mod
-        
+
     def _keyevent(self, widget, event, type):
-        key = gtk.gdk.keyval_name(event.keyval)
+        key = Gdk.keyval_name(event.keyval)
         if key is None:
             # No idea what this key is.
             return False 
-        
+
         keycode = None
         if key in self.key_trans:
             keycode = self.key_trans[key]
@@ -148,19 +165,19 @@ class Translator(object):
             self._mainwindow.view_source()
         else:
             print 'Key %s unrecognized' % key
-            
+
         if keycode is not None:
             if type == pygame.KEYDOWN:
                 mod = self._keymods()
             self.__keystate[keycode] = type == pygame.KEYDOWN
             if type == pygame.KEYUP:
                 mod = self._keymods()
-            ukey = unichr(gtk.gdk.keyval_to_unicode(event.keyval))
+            ukey = unichr(Gdk.keyval_to_unicode(event.keyval))
             if ukey == '\000':
                 ukey = ''
             evt = pygame.event.Event(type, key=keycode, unicode=ukey, mod=mod)
             self._post(evt)
-            
+
         return True
 
     def _get_pressed(self):
@@ -176,57 +193,57 @@ class Translator(object):
     def _mouseup_cb(self, widget, event):
         self.__button_state[event.button-1] = 0
         return self._mouseevent(widget, event, pygame.MOUSEBUTTONUP)
-        
+
     def _mouseevent(self, widget, event, type):
         evt = pygame.event.Event(type, button=event.button, pos=(event.x, event.y))
         self._post(evt)
         return True
-        
+
     def _mousemove_cb(self, widget, event):
         # From http://www.learningpython.com/2006/07/25/writing-a-custom-widget-using-pygtk/
         # if this is a hint, then let's get all the necessary 
         # information, if not it's all we need.
         if event.is_hint:
-            x, y, state = event.window.get_pointer()
+            win, x, y, state = event.window.get_device_position(event.device)
         else:
             x = event.x
             y = event.y
-            state = event.state
+            state = event.get_state()
 
         rel = (x - self.__mouse_pos[0], y - self.__mouse_pos[1])
         self.__mouse_pos = (x, y)
-        
+
         self.__button_state = [
-            state & gtk.gdk.BUTTON1_MASK and 1 or 0,
-            state & gtk.gdk.BUTTON2_MASK and 1 or 0,
-            state & gtk.gdk.BUTTON3_MASK and 1 or 0,
+            state & Gdk.ModifierType.BUTTON1_MASK and 1 or 0,
+            state & Gdk.ModifierType.BUTTON2_MASK and 1 or 0,
+            state & Gdk.ModifierType.BUTTON3_MASK and 1 or 0,
         ]
-        
+
         evt = pygame.event.Event(pygame.MOUSEMOTION,
                                  pos=self.__mouse_pos, rel=rel, buttons=self.__button_state)
         self._post(evt)
         return True
-        
+
     def _tick_cb(self):
         cur_time = pygame.time.get_ticks()
         for key in self.__held:
             delta = cur_time - self.__held_last_time[key] 
             self.__held_last_time[key] = cur_time
-            
+
             self.__held_time_left[key] -= delta
             if self.__held_time_left[key] <= 0:
                 self.__held_time_left[key] = self.__repeat[1]
                 self._keyevent(None, _MockEvent(key), pygame.KEYDOWN)
-                
+
         return True
-        
+
     def _set_repeat(self, delay=None, interval=None):
         if delay is not None and self.__repeat[0] is None:
-            self.__tick_id = gobject.timeout_add(10, self._tick_cb)
+            self.__tick_id = GObject.timeout_add(10, self._tick_cb)
         elif delay is None and self.__repeat[0] is not None:
-            gobject.source_remove(self.__tick_id)
+            GObject.source_remove(self.__tick_id)
         self.__repeat = (delay, interval)
-        
+
     def _get_mouse_pos(self):
         return self.__mouse_pos