fixes for sugar activity

7 files changed, 27 insertions, 325 deletions

diff --git a/src/Main.py b/src/Main.py
index 51d45b3..c069b64 100755
--- a/src/Main.py
+++ b/src/Main.py
@@ -7,15 +7,21 @@ from game.MenuState import CMenuState
 import api.Game

 from api.Game import CGame

 

-def main():

+class EdSexualGame():

     

-    g = CGame()

+    def __init__(self):

+        pass

     

-    ms = CMenuState()

-    g.setState(ms)

-    

-    g.gameLoop()

-    g.destroy()

+    def main(self):

+        

+        g = CGame()

+

+        ms = CMenuState()

+        g.setState(ms)

+        

+        g.gameLoop()

+        g.destroy()

         

 if __name__ == "__main__":

-    main()
\ No newline at end of file
+    j = EdSexualGame()

+    j.main()
\ No newline at end of file
diff --git a/src/api/Button.py b/src/api/Button.py
index c16855f..2bf33a5 100755
--- a/src/api/Button.py
+++ b/src/api/Button.py
@@ -38,7 +38,7 @@ class CButton(CLabel):
         #check for mouse input

         

         self.mclicked = False

-        

+

         if CMouse().firstPress():

             if self.rect.collidepoint(CMouse().getPos()):

                 print("first press in button")

diff --git a/src/api/Game.py b/src/api/Game.py
index 071edb7..d3f181c 100755
--- a/src/api/Game.py
+++ b/src/api/Game.py
@@ -73,17 +73,19 @@ class CGame(object):
     def init(self):

         print "init pygame..."

         pygame.init()

+        #pygame.display.init()

         #pygame.font.init()

-         

         #screen = pygame.display.set_mode((1200, 900), FULLSCREEN)

-        self.mScreen = pygame.display.set_mode((1200, 900))

+        self.mScreen = pygame.display.get_surface()

+        if not(self.mScreen):

+            self.mScreen = pygame.display.set_mode((1200, 900))

         pygame.display.set_caption(_('Game'))

         

         self.mBackground = pygame.Surface(self.mScreen.get_size())

         self.mBackground.fill((255, 0, 0))

 

         # Sound system initialization.

-        pygame.mixer.init()

+        #pygame.mixer.init()

         

         #self.mAllSprites = pygame.sprite.Group()

         Sprites = []

@@ -103,9 +105,6 @@ class CGame(object):
         print "start game loop here"

         while not self.mQuit:

 

-            self.mClock.tick(30)

-            #print ("FPS: %.0f" % self.mClock.get_fps())

-        

             while gtk.events_pending():

                 gtk.main_iteration()

         

@@ -120,7 +119,7 @@ class CGame(object):
         

             self.mMouse.update()

             self.mMousePointerSprite.setXY(self.mMouse.getX(), self.mMouse.getY())

-            

+        

             #self.mState.preUpdate()

             self.mState.update()

             

@@ -136,6 +135,8 @@ class CGame(object):
             #self.mState.postUpdate()

             

             pygame.display.flip()

+            self.mClock.tick(30)

+            #print ("FPS: %.0f" % self.mClock.get_fps())

 

     def doEvents(self, event):

         """ overwrite this method to add your own events.

diff --git a/src/api/Mouse.py b/src/api/Mouse.py
index bf0e0c8..ba34eb6 100755
--- a/src/api/Mouse.py
+++ b/src/api/Mouse.py
@@ -43,10 +43,10 @@ class CMouse(object):
         return self.mPressed
     
     def firstPress(self):
-        return self.pressed() and not self.mPrevPressed
+        return (self.mPressed and not self.mPrevPressed)
 
     def release(self):
-        return not self.pressed() and self.mPrevPressed
+        return (not(self.mPressed) and self.mPrevPressed)
 
     def update(self):
         #print("mouse update")
@@ -54,7 +54,8 @@ class CMouse(object):
         #print("y=" + str(self.getY()))
         
         self.mPrevPressed = self.mPressed;
-        self.mPressed = (pygame.mouse.get_pressed() == (1, 0, 0))
+        pp = pygame.mouse.get_pressed()
+        self.mPressed = (pp[0] == 1 and pp[1] == 0 and pp[2] == 0)
         
     def destroy(self):
         self.mInstance = None
diff --git a/src/sugargame/__init__.py b/src/sugargame/__init__.py
deleted file mode 100755
index 439eb0c..0000000
--- a/src/sugargame/__init__.py
+++ /dev/null
@@ -1 +0,0 @@
-__version__ = '1.1'
diff --git a/src/sugargame/canvas.py b/src/sugargame/canvas.py
deleted file mode 100755
index 980cb73..0000000
--- a/src/sugargame/canvas.py
+++ /dev/null
@@ -1,62 +0,0 @@
-import os
-import gtk
-import gobject
-import pygame
-import event
-
-CANVAS = None
-
-class PygameCanvas(gtk.EventBox):
-    
-    """
-    mainwindow is the activity intself.
-    """
-    def __init__(self, mainwindow, pointer_hint = True):
-        gtk.EventBox.__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.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 _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()
-        
-        # Restore the default cursor.
-        self._socket.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.
-        self.translator.hook_pygame()
-
-        # Run the Pygame main loop.
-        main_fn()
-        return False
-
-    def get_pygame_widget(self):
-        return self._socket
diff --git a/src/sugargame/event.py b/src/sugargame/event.py
deleted file mode 100755
index 4cc3be8..0000000
--- a/src/sugargame/event.py
+++ /dev/null
@@ -1,243 +0,0 @@
-import gtk
-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,
-        'Alt_R': pygame.K_RALT,
-        'Control_L': pygame.K_LCTRL,
-        'Control_R': pygame.K_RCTRL,
-        'Shift_L': pygame.K_LSHIFT,
-        '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,
-
-    }
-    
-    mod_map = {
-        pygame.K_LALT: pygame.KMOD_LALT,
-        pygame.K_RALT: pygame.KMOD_RALT,
-        pygame.K_LCTRL: pygame.KMOD_LCTRL,
-        pygame.K_RCTRL: pygame.KMOD_RCTRL,
-        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
-        # (add instead of set here because the main window is already realized)
-        self._mainwindow.add_events(
-            gtk.gdk.KEY_PRESS_MASK | \
-            gtk.gdk.KEY_RELEASE_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 
-        )
-
-        self._mainwindow.set_flags(gtk.CAN_FOCUS)
-        self._inner_evb.set_flags(gtk.CAN_FOCUS)
-        
-        # Callback functions to link the event systems
-        self._mainwindow.connect('unrealize', self._quit_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('configure-event', self._resize_cb)
-        
-        # Internal data
-        self.__stopped = False
-        self.__keystate = [0] * 323
-        self.__button_state = [0,0,0]
-        self.__mouse_pos = (0,0)
-        self.__repeat = (None, None)
-        self.__held = set()
-        self.__held_time_left = {}
-        self.__held_last_time = {}
-        self.__tick_id = None
-
-    def hook_pygame(self):
-        pygame.key.get_pressed = self._get_pressed
-        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):
-        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
-
-    def _quit_cb(self, data=None):
-        self.__stopped = True
-        pygame.event.post(pygame.event.Event(pygame.QUIT))
-
-    def _keydown_cb(self, widget, event):
-        key = event.keyval
-        if key in self.__held:
-            return True
-        else:
-            if self.__repeat[0] is not None:
-                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
-                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 = gtk.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]
-        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()
-        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))
-            if ukey == '\000':
-                ukey = ''
-            evt = pygame.event.Event(type, key=keycode, unicode=ukey, mod=mod)
-            self._post(evt)
-            
-        return True
-
-    def _get_pressed(self):
-        return self.__keystate
-
-    def _get_mouse_pressed(self):
-        return self.__button_state
-
-    def _mousedown_cb(self, widget, event):
-        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
-        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()
-        else:
-            x = event.x
-            y = event.y
-            state = event.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,
-        ]
-        
-        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)
-        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
-
-    def _post(self, evt):
-        try:
-            pygame.event.post(evt)
-        except pygame.error, e:
-            if str(e) == 'Event queue full':
-                print "Event queue full!"
-                pass
-            else:
-                raise e