From 395170f5da81e0f8589009827d5ece7fa0e51451 Mon Sep 17 00:00:00 2001 From: James Cameron Date: Sun, 21 Jan 2018 05:39:03 +1100 Subject: [PATCH] Fix "non responsive buttons" issue on the XO (#44) Gtk+ events were not being handled in the application event loop, so we add a callback to check for and handle the events. Also ported to Sugargame v1.2 which solves some other problems. Tested on OLPC XO-4 with OLPC OS 13.2.9. --- PyCutActivity.py | 59 +++++++--------- game/__init__.py | 5 +- sugargame/__init__.py | 2 +- sugargame/canvas.py | 80 +++++++++++++-------- sugargame/event.py | 160 +++++++++++++++++++++++------------------- 5 files changed, 170 insertions(+), 136 deletions(-) diff --git a/PyCutActivity.py b/PyCutActivity.py index b55f6a3..97dca99 100644 --- a/PyCutActivity.py +++ b/PyCutActivity.py @@ -1,10 +1,14 @@ from gettext import gettext as _ import sys + +import gi +gi.require_version('Gtk', '3.0') + from gi.repository import Gtk import pygame -import sugar3.activity.activity +from sugar3.activity.activity import Activity from sugar3.graphics.toolbarbox import ToolbarBox from sugar3.activity.widgets import ActivityToolbarButton from sugar3.graphics.toolbutton import ToolButton @@ -14,29 +18,34 @@ import sugargame.canvas import game -class PyCutActivity(sugar3.activity.activity.Activity): +class PyCutActivity(Activity): def __init__(self, handle): - super(PyCutActivity, self).__init__(handle) + Activity.__init__(self, handle) - self.paused = False + self.max_participants = 1 # Create the game instance. - self.game = game.PyCutGame() + self.game = game.PyCutGame(poll_cb=self._poll_cb) # Build the activity toolbar. self.build_toolbar() # Build the Pygame canvas. - self._pygamecanvas = sugargame.canvas.PygameCanvas(self) + # Start the game running (self.game.run is called when the + # activity constructor returns). + self.game.canvas = sugargame.canvas.PygameCanvas(self, + main=self.game.run, modules=[pygame.display, pygame.font]) # Note that set_canvas implicitly calls read_file when # resuming from the Journal. - self.set_canvas(self._pygamecanvas) - self._pygamecanvas.grab_focus() + self.set_canvas(self.game.canvas) + self.game.canvas.grab_focus() - # Start the game running (self.game.run is called when the - # activity constructor returns). - self._pygamecanvas.run_pygame(self.game.run) + def _poll_cb(self): + while Gtk.events_pending(): + Gtk.main_iteration() + if self.game.quit_attempt: + Gtk.main_quit() def build_toolbar(self): toolbar_box = ToolbarBox() @@ -47,16 +56,6 @@ def build_toolbar(self): toolbar_box.toolbar.insert(activity_button, -1) activity_button.show() - # Pause/Play button: - - stop_play = ToolButton('media-playback-stop') - stop_play.set_tooltip(_("Stop")) - stop_play.set_accelerator(_('space')) - stop_play.connect('clicked', self._stop_play_cb) - stop_play.show() - - toolbar_box.toolbar.insert(stop_play, -1) - # Blank space (separator) and Stop button at the end: separator = Gtk.SeparatorToolItem() @@ -68,22 +67,16 @@ def build_toolbar(self): stop_button = StopButton(self) toolbar_box.toolbar.insert(stop_button, -1) stop_button.show() + stop_button.connect('clicked', self._stop_cb) - def _stop_play_cb(self, button): - # Pause or unpause the game. - self.paused = not self.paused - self.game.set_paused(self.paused) - - # Update the button to show the next action. - if self.paused: - button.set_icon('media-playback-start') - button.set_tooltip(_("Start")) - else: - button.set_icon('media-playback-stop') - button.set_tooltip(_("Stop")) + def _stop_cb(self, button): + self.game.running = False def read_file(self, file_path): self.game.read_file(file_path) def write_file(self, file_path): self.game.write_file(file_path) + + def get_preview(self): + return self.game.canvas.get_preview() diff --git a/game/__init__.py b/game/__init__.py index 4b847e2..1969b84 100644 --- a/game/__init__.py +++ b/game/__init__.py @@ -6,7 +6,7 @@ class PyCutGame(): """docstring for PyCutGame""" - def __init__(self): + def __init__(self, poll_cb=None): self.dev = True self.data = None self.basePath = os.path.dirname(__file__) @@ -23,6 +23,7 @@ def __init__(self): self.quit_attempt = False self.level = 1 self.total_good_pizza = 0 + self.poll_cb = poll_cb def load_assets(self): self.game_icon = self.load_image("PyCut_icon.png") @@ -68,6 +69,8 @@ def game_loop(self): self.active_scene = self.starting_scene(self) while self.active_scene != None: + if self.poll_cb: + self.poll_cb() pressed_keys = pygame.key.get_pressed() # Event filtering filtered_events = [] diff --git a/sugargame/__init__.py b/sugargame/__init__.py index 439eb0c..64477cf 100644 --- a/sugargame/__init__.py +++ b/sugargame/__init__.py @@ -1 +1 @@ -__version__ = '1.1' +__version__ = '1.2' diff --git a/sugargame/canvas.py b/sugargame/canvas.py index 3e4de75..2299f4d 100644 --- a/sugargame/canvas.py +++ b/sugargame/canvas.py @@ -1,17 +1,17 @@ import os from gi.repository import Gtk from gi.repository import GObject +from gi.repository import GLib +from sugar3.activity.activity import PREVIEW_SIZE import pygame import event CANVAS = None + class PygameCanvas(Gtk.EventBox): - - ''' - mainwindow is the activity intself. - ''' - def __init__(self, mainwindow, pointer_hint = True): + def __init__(self, activity, pointer_hint=True, + main=None, modules=[pygame]): GObject.GObject.__init__(self) global CANVAS @@ -19,44 +19,68 @@ def __init__(self, mainwindow, pointer_hint = True): CANVAS = self # Initialize Events translator before widget gets "realized". - self.translator = event.Translator(mainwindow, self) - - self._mainwindow = mainwindow + self.translator = event.Translator(activity, self) + + self._activity = activity + self._main = main + self._modules = modules self.set_can_focus(True) - + self._socket = Gtk.Socket() + self._socket.connect('realize', self._realize_cb) self.add(self._socket) + 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 - # constructor never returns and the activity freezes. - GObject.idle_add(self._run_pygame_cb, main_fn) + def _realize_cb(self, widget): - def _run_pygame_cb(self, main_fn): - assert pygame.display.get_surface() is None, "PygameCanvas.run_pygame can only be called once." - # 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()) - pygame.init() - + os.environ['SDL_WINDOWID'] = str(widget.get_id()) + for module in self._modules: + module.init() + # Restore the default cursor. - self._socket.props.window.set_cursor(None) + widget.props.window.set_cursor(None) - # Initialize the Pygame window. + # Confine the Pygame surface to the canvas size r = self.get_allocation() - pygame.display.set_mode((r.width, r.height), pygame.RESIZABLE) + self._screen = pygame.display.set_mode((r.width, r.height), + pygame.RESIZABLE) # Hook certain Pygame functions with GTK equivalents. self.translator.hook_pygame() - # Run the Pygame main loop. - main_fn() - return False + # Call the caller's main loop as an idle source + if self._main: + GLib.idle_add(self._main) def get_pygame_widget(self): return self._socket + + def get_preview(self): + """ + Return preview of main surface + How to use in activity: + def get_preview(self): + return self.game_canvas.get_preview() + """ + + if not hasattr(self, '_screen'): + return None + + _tmp_dir = os.path.join(self._activity.get_activity_root(), + 'tmp') + _file_path = os.path.join(_tmp_dir, 'preview.png') + + width = PREVIEW_SIZE[0] + height = PREVIEW_SIZE[1] + _surface = pygame.transform.scale(self._screen, (width, height)) + pygame.image.save(_surface, _file_path) + + f = open(_file_path, 'r') + preview = f.read() + f.close() + os.remove(_file_path) + + return preview diff --git a/sugargame/event.py b/sugargame/event.py index a6975e1..dee8d78 100644 --- a/sugargame/event.py +++ b/sugargame/event.py @@ -1,14 +1,15 @@ -from gi.repository import Gtk +import logging from gi.repository import Gdk from gi.repository import GObject import pygame import pygame.event -import logging + class _MockEvent(object): def __init__(self, keyval): self.keyval = keyval + class Translator(object): key_trans = { 'Alt_L': pygame.K_LALT, @@ -19,17 +20,17 @@ class Translator(object): 'Shift_R': pygame.K_RSHIFT, 'Super_L': pygame.K_LSUPER, 'Super_R': pygame.K_RSUPER, - 'KP_Page_Up' : pygame.K_KP9, - 'KP_Page_Down' : pygame.K_KP3, - 'KP_End' : pygame.K_KP1, - 'KP_Home' : pygame.K_KP7, - 'KP_Up' : pygame.K_KP8, - 'KP_Down' : pygame.K_KP2, - 'KP_Left' : pygame.K_KP4, - 'KP_Right' : pygame.K_KP6, + 'KP_Page_Up': pygame.K_KP9, + 'KP_Page_Down': pygame.K_KP3, + 'KP_End': pygame.K_KP1, + 'KP_Home': pygame.K_KP7, + 'KP_Up': pygame.K_KP8, + 'KP_Down': pygame.K_KP2, + 'KP_Left': pygame.K_KP4, + 'KP_Right': pygame.K_KP6, } - + mod_map = { pygame.K_LALT: pygame.KMOD_LALT, pygame.K_RALT: pygame.KMOD_RALT, @@ -38,45 +39,46 @@ 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 + + def __init__(self, activity, inner_evb): + """Initialise the Translator with the windows to which to listen""" + self._activity = activity self._inner_evb = inner_evb # Enable events # (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 \ + self._activity.add_events( + Gdk.EventMask.KEY_PRESS_MASK | + Gdk.EventMask.KEY_RELEASE_MASK | + Gdk.EventMask.VISIBILITY_NOTIFY_MASK ) - + self._inner_evb.set_events( - 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 + 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_can_focus(True) + self._activity.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._activity.connect('unrealize', self._quit_cb) + self._activity.connect('visibility_notify_event', self._visibility_cb) + self._activity.connect('configure-event', self._resize_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('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 - self.__button_state = [0,0,0] - self.__mouse_pos = (0,0) + self.__button_state = [0, 0, 0] + self.__mouse_pos = (0, 0) self.__repeat = (None, None) self.__held = set() self.__held_time_left = {} @@ -88,22 +90,29 @@ def hook_pygame(self): pygame.key.set_repeat = self._set_repeat pygame.mouse.get_pressed = self._get_mouse_pressed pygame.mouse.get_pos = self._get_mouse_pos - - def _draw_cb(self, widget, event): + + def update_display(self): if pygame.display.get_init(): pygame.event.post(pygame.event.Event(pygame.VIDEOEXPOSE)) - return True def _resize_cb(self, widget, event): - evt = pygame.event.Event(pygame.VIDEORESIZE, - size=(event.width,event.height), width=event.width, height=event.height) - pygame.event.post(evt) - return False # continue processing + if pygame.display.get_init(): + evt = pygame.event.Event(pygame.VIDEORESIZE, + size=(event.width,event.height), + width=event.width, height=event.height) + pygame.event.post(evt) + return False # continue processing + + def _screen_changed_cb(self, widget, previous_screen): + 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): + self.update_display() + return False + def _keydown_cb(self, widget, event): key = event.keyval if key in self.__held: @@ -113,45 +122,46 @@ def _keydown_cb(self, widget, event): 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: if key in self.__held: - # This is possibly false if set_repeat() is called with a key held + # This is possibly false if set_repeat() + # is called with a key held del self.__held_time_left[key] del self.__held_last_time[key] 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 = Gdk.keyval_name(event.keyval) if key is None: # No idea what this key is. - return False - + return False + keycode = None if key in self.key_trans: keycode = self.key_trans[key] - elif hasattr(pygame, 'K_'+key.upper()): - keycode = getattr(pygame, 'K_'+key.upper()) - elif hasattr(pygame, 'K_'+key.lower()): - keycode = getattr(pygame, 'K_'+key.lower()) + elif hasattr(pygame, 'K_' + key.upper()): + keycode = getattr(pygame, 'K_' + key.upper()) + elif hasattr(pygame, 'K_' + key.lower()): + keycode = getattr(pygame, 'K_' + key.lower()) elif key == 'XF86Start': # view source request, specially handled... - self._mainwindow.view_source() + self._activity.view_source() else: - print 'Key %s unrecognized' % key - + logging.error('Key %s unrecognized' % key) + if keycode is not None: if type == pygame.KEYDOWN: mod = self._keymods() @@ -163,7 +173,7 @@ def _keyevent(self, widget, event, type): ukey = '' evt = pygame.event.Event(type, key=keycode, unicode=ukey, mod=mod) self._post(evt) - + return True def _get_pressed(self): @@ -173,21 +183,22 @@ def _get_mouse_pressed(self): return self.__button_state def _mousedown_cb(self, widget, event): - self.__button_state[event.button-1] = 1 + self.__button_state[event.button - 1] = 1 return self._mouseevent(widget, event, pygame.MOUSEBUTTONDOWN) def _mouseup_cb(self, widget, event): - self.__button_state[event.button-1] = 0 + 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)) + 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 + # if this is a hint, then let's get all the necessary # information, if not it's all we need. if event.is_hint: win, x, y, state = event.window.get_device_position(event.device) @@ -198,38 +209,39 @@ def _mousemove_cb(self, widget, event): rel = (x - self.__mouse_pos[0], y - self.__mouse_pos[1]) self.__mouse_pos = (x, y) - + self.__button_state = [ 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) + 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] + 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) elif delay is None and self.__repeat[0] is not None: GObject.source_remove(self.__tick_id) self.__repeat = (delay, interval) - + def _get_mouse_pos(self): return self.__mouse_pos @@ -237,8 +249,10 @@ def _post(self, evt): try: pygame.event.post(evt) except pygame.error, e: - if str(e) == 'Event queue full': - print "Event queue full!" + if str(e) == 'video system not initialized': + pass + elif str(e) == 'Event queue full': + logging.error("Event queue full!") pass else: raise e