Changeset 3b72c6f02dde3ec9451bd43e4fc86d3143cc6775 for samurai-x

Timestamp:

07/14/2008 09:17:36 AM (2 years ago)

Author:

dunkfordyce <dunkfordyce@…>

Children:

8a84fd16a7eb94842a748169309b8184a176666d

Parents:

42db8fb5f3a04acbc4b6bbeae932b5349d99e403

git-committer:

dunkfordyce <dunkfordyce@561c22c7-a851-0410-91f3-c76db74392ff> / 2008-07-14T08:17:36Z+0000

Message:

work from the weekend

git-svn-id:  https://samurai-x.googlecode.com/svn/trunk@5 561c22c7-a851-0410-91f3-c76db74392ff

Location:

samurai-x

Files:

• run.py (modified) (1 diff)
• samuraix/appl.py (moved) (moved from samurai-x/samuraix/app.py) (13 diffs)
• samuraix/cairo.py (added)
• samuraix/client.py (modified) (10 diffs)
• samuraix/desktop.py (modified) (2 diffs)
• samuraix/drawcontext.py (added)
• samuraix/focus.py (added)
• samuraix/keysymdef.py (moved) (moved from samurai-x/samuraix/keydefs.py)
• samuraix/main.py (modified) (5 diffs)
• samuraix/rules.py (added)
• samuraix/screen.py (modified) (7 diffs)
• samuraix/simple_window.py (added)
• samuraix/statusbar.py (added)
• samuraix/widget.py (added)
• samuraix/xatom.py (added)
• samuraix/xconstants.py (modified) (1 diff)
• samuraix/xhelpers.py (modified) (2 diffs)
• tools/makeatoms.py (added)
• tools/makekeydefs.py (added)

samurai-x/run.py

@@ +1 @@
+#!/usr/bin/env python
+
 import sys
 sys.path.append('.')
 
 from samuraix.main import run
-from samuraix.app import App
+from samuraix.appl import App
 
 run(App)

samurai-x/samuraix/appl.py

@@ -1 +1 @@
 import pyglet
+from pyglet.window.xlib import xlib 
+
+import signal
+
 import samuraix
-
-from pyglet.window.xlib import xlib 
-#from pyglet.window.xlib import cursorfont
-from ctypes import *
-
-import keydefs 
-
 from samuraix.xhelpers import get_window_state
+from samuraix.screen import Screen
 from samuraix.client import Client
-from samuraix.screen import Screen
+from samuraix.sxctypes import *
+from samuraix import xatom
 
 from samuraix.testfunc import testfunc
@@ -18 +17 @@
 log = logging.getLogger(__name__)
 
+
 class App(pyglet.event.EventDispatcher):
 
-    x_event_map = {
-        xlib.ButtonPress:       'on_button_press',
-        xlib.ConfigureRequest:  'on_configure_request',
-        xlib.ConfigureNotify:   'on_configure_notify',
-        xlib.DestroyNotify:     'on_destroy_notify',
-        xlib.EnterNotify:       'on_enter_notify', 
-        xlib.Expose:            'on_expose',
-        xlib.KeyPress:          'on_key_press',
-        xlib.MappingNotify:     'on_mapping_notify',
-        xlib.MapRequest:        'on_map_request',
-        xlib.PropertyNotify:    'on_property_notify',
-        xlib.UnmapNotify:       'on_unmap_notify',
-        xlib.ClientMessage:     'on_client_message',
-    }
-
-    client_class = Client
-
-    @classmethod
-    def register_x_event_handlers(cls):
-        for event in cls.x_event_map.itervalues():
-            cls.register_event_type(event)
 
     def __init__(self, config={}):
@@ -48 +27 @@
         ]
 
+        self.x_event_map = {
+            xlib.ButtonPress:       self.on_button_press,
+            xlib.ConfigureRequest:  self.on_configure_request,
+            xlib.ConfigureNotify:   self.on_configure_notify,
+            xlib.DestroyNotify:     self.on_destroy_notify,
+            xlib.EnterNotify:       self.on_enter_notify, 
+            xlib.Expose:            self.on_expose,
+            xlib.KeyPress:          self.on_key_press,
+            xlib.MappingNotify:     self.on_mapping_notify,
+            xlib.MapRequest:        self.on_map_request,
+            xlib.PropertyNotify:    self.on_property_notify,
+            xlib.UnmapNotify:       self.on_unmap_notify,
+            xlib.ClientMessage:     self.on_client_message,
+        }
+
+    def init(self):
+        log.info('app %s initialising...' % self)
+
+        log.info('registering signal handlers...')
+        signal.signal(signal.SIGINT, self.stop)
+        signal.signal(signal.SIGTERM, self.stop)
+        signal.signal(signal.SIGHUP, self.stop)
+
         self.create_screens()
 
-        self.clients = []
         self.scan()
 
@@ -56 +57 @@
 
     def run(self):
+        log.info('app %s now running...' % self)
+
         xlib.XSync(samuraix.display, False)
         self.running = True
 
-        try:
-            self._run()
-        finally:
+        ev = xlib.XEvent()
+
+        while self.running:
+            # for non blocking use this ..
+            #while xlib.XPending(samuraix.display):
+            xlib.XNextEvent(samuraix.display, byref(ev))
+            self.handle_event(ev)
             xlib.XSync(samuraix.display, False)
-            xlib.XCloseDisplay(samuraix.display)
-
-    def _run(self):
-        ev = xlib.XEvent()
-
-        while self.running:
-            while xlib.XPending(samuraix.display):
-                while xlib.XPending(samuraix.display):
-                    xlib.XNextEvent(samuraix.display, byref(ev))
-                    self.handle_event(ev)
-                xlib.XSync(samuraix.display, False)
+
+            for screen in self.screens:
+                for widget in screen.widgets:
+                    if widget.dirty:
+                        widget.draw()
+
+        for screen in self.screens:
+            screen.remove()
+
+    def stop(self, *args, **kwargs):
+        log.info(' app %s stop' % self)
+        self.running = False
 
     def handle_event(self, ev):
         try:
-            evname = self.x_event_map[ev.type]
+            func = self.x_event_map[ev.type]
         except KeyError:
             log.debug('cant map event %s' % ev.type)
-            return 
-        self.dispatch_event(evname, ev)
+        else:
+            func(ev)
         xlib.XSync(samuraix.display, False)
 
     def create_screens(self):
+        log.info('creating screens...')
         num_screens = xlib.XScreenCount(samuraix.display)
 
@@ -93 +102 @@
             self.screens.append(scr)
         
-        wa = xlib.XSetWindowAttributes()
-        wa.event_mask = ( xlib.SubstructureRedirectMask |      
-                          xlib.SubstructureNotifyMask | 
-                          xlib.EnterWindowMask | 
-                          xlib.LeaveWindowMask | 
-                          xlib.StructureNotifyMask )
-        wa.cursor = samuraix.cursors['normal']
-
+    def scan(self):
+        log.info('scanning screens for existing windows...')
         for screen in self.screens:
-            root = screen.root_window
-
-            xlib.XChangeWindowAttributes(samuraix.display, 
-                root, 
-                xlib.CWEventMask | xlib.CWCursor,
-                byref(wa))
-
-            xlib.XSelectInput(samuraix.display,
-                root, 
-                wa.event_mask)
-
-            screen.grab_buttons()
-            screen.grab_keys()
-
-    def scan(self):
-        wa = xlib.XWindowAttributes()
-
-        wins = xlib.Window_p()
-        wins.contains = None
-        d1 = xlib.Window()
-        d2 = xlib.Window()
-        num = c_uint()
-
-        for screen in self.screens:
-            root = xlib.XRootWindow(samuraix.display, screen.num)
-            log.debug('root is %s' % root)
-            if xlib.XQueryTree(samuraix.display, root, byref(d1), byref(d2), byref(wins), byref(num)):
-                log.debug('found %s window' % num)
-                for i in range(num.value):
-                    log.debug('found window %s' % wins[i])
-                    if (xlib.XGetWindowAttributes(samuraix.display, wins[i], byref(wa)) and 
-                            not wa.override_redirect and 
-                            (wa.map_state == xlib.IsViewable or 
-                             get_window_state(wins[i]) == xlib.IconicState)):
-                        self.manage(wins[i], wa, screen)
-            if wins:
-                xlib.XFree(wins)
-
-
-    def manage(self, window, wa, screen):
-        log.debug('managing %s %s %s' % (window, wa, screen))
-        client = self.client_class(screen, window, wa)
-        self.clients.append(client)
-
-    def get_client_by_window(self, win):
-        for client in self.clients:
-            if client.window == win:
-                return client
-        return None
+            screen.scan()
 
     def on_button_press(self, e):
@@ -161 +116 @@
         y = c_int()
 
-        client = self.get_client_by_window(ev.window)
+        client = Client.get_by_window(ev.window)
         if client is not None:
+            client.focus()
             if CLEANMASK(ev.state) == xlib.NoSymbol and ev.button == xlib.Button1:
                 xlib.XAllowEvents(samuraix.display, xlib.ReplayPointer, xlib.CurrentTime)
@@ -178 +134 @@
         ev = e.xconfigurerequest
 
-        client = self.get_client_by_window(ev.window)
+        client = Client.get_by_window(ev.window)
         if client is not None:
             geom = client.geom.copy()
@@ -214 +170 @@
     def on_destroy_notify(self, e):
         ev = e.xdestroywindow
-        client = self.get_client_by_window(ev.window)
+        client = Client.get_by_window(ev.window)
         if client is not None:
             client.remove()
@@ -220 +176 @@
     def on_enter_notify(self, e):
         ev = e.xcrossing
-        client = self.get_client_by_window(ev.window)
+        client = Client.get_by_window(ev.window)
         if client:
             client.dispatch_event('on_enter')
@@ -229 +185 @@
                     return 
 
-    def on_expose(self, ev):
-        pass
+    def on_expose(self, e):
+        log.debug('expose')
+        ev = e.xexpose
+        if not ev.count:
+            for screen in self.screens:
+                for widget in screen.widgets:
+                    if widget.test_window(ev.window):
+                        widget.refresh()
+                        return
 
     def on_key_press(self, e):
@@ -244 +207 @@
                 scr.dispatch_event('on_key_press', e.xkey)
                 return 
-        log.warn('got a key press for a screen we dnt know!')
-
-    def on_mapping_notify(self, ev):
-        pass
+        log.warn('got a key press for a screen we dont know!')
+
+    def on_mapping_notify(self, e):
+        ev = e.xmapping
+        xlib.XRefreshKeyboardMapping(ev)
+        if ev.request == xlib.MappingKeyboard:
+            for screen in self.screens:
+                screen.grab_keys()
 
     def on_map_request(self, e):
         ev = e.xmaprequest
         wa = xlib.XWindowAttributes()
-        
+
         if not xlib.XGetWindowAttributes(e.xany.display, ev.window, byref(wa)):
+            log.debug('couldnt get XGetWindowAttributes')
             return 
 
@@ -259 +227 @@
             return 
 
-        client = self.get_client_by_window(ev.window)
+        client = Client.get_by_window(ev.window)
         if client is None:
-            screen = self.screens[0]
-            for s in self.screens:
-                if wa.screen == s.num:
-                    screen = s
-                    break
-            
-            self.manage(ev.window, wa, screens)
-
-    def on_property_notify(self, ev):
-        pass
+            for screen in self.screens:
+                if (addressof(wa.screen.contents) == 
+                        addressof(xlib.XScreenOfDisplay(e.xany.display, screen.num).contents)):
+                    screen.manage(ev.window, wa)
+                    return 
+            assert screen is not None, "looking for screen %s(%s) failed" %(wa.screen, type(wa.screen))
+
+    def on_property_notify(self, e):
+        ev = e.xproperty
+        if ev.state == xlib.PropertyDelete:
+            return
+        client = Client.get_by_window(ev.window)
+        if client:
+            log.debug('prop change for client %s' % client)
+            if ev.atom == xatom.XA_WM_TRANSIENT_FOR:
+                trans = xlib.Window()
+                xlib.XGetTransientForHint(e.xany.display, client.window, byref(trans))
+                # needs rearrange
+            elif ev.atom == xatom.XA_WM_NORMAL_HINTS:
+                client.update_size_hints()
+            elif ev.atom == xatom.XA_WM_HINTS:
+                client.update_wm_hints()
+            elif ev.atom == xatom.XA_WM_NAME or ev.atom == samuraix.atoms['_NET_WM_NAME']:
+                client.update_title()
 
     def on_unmap_notify(self, e):
         ev = e.xunmap
-        client = self.get_client_by_window(ev.window)
+        client = Client.get_by_window(ev.window)
         if (client is not None and 
             ev.event == xlib.XRootWindow(e.xany.display, client.screen.num) and 
@@ -281 +263 @@
             client.remove()
 
-    def on_client_message(self, ev):
-        pass
-
-
-
+    def on_client_message(self, e):
+        ev = e.xclient
+        self.process_ewmh_message(ev)
+
+    def process_ewmh_message(self, ev):
+        if ev.message_type == samuraix.atoms['_NET_CURRENT_DESKTOP']:
+            pass
+            # change the desktop
+        elif ev.message_type == samuraix.atoms['_NET_CLOSE_WINDOW']:
+            client = Client.get_by_window(ev.window)
+            if client:
+                client.kill()
+        elif ev.message_type == samuraix.atoms['_NET_WM_STATE']:
+            client = Client.get_by_window(ev.window)
+            if client:
+                client.process_ewmh_state_atom(ev.data.l[1], ev.data.l[0])
+                if ev.data.l[2]:
+                    client.process_ewmh_state_atom(ev.data.l[2], ev.data.l[0])
+                    
+            
+                
+
+

samurai-x/samuraix/client.py

@@ -1 +1 @@
 import pyglet
 from pyglet.window.xlib import xlib 
+
+import weakref
 
 from samuraix.sxctypes import *
@@ -13 +15 @@
 
 class Client(pyglet.event.EventDispatcher):
+
+    all_clients = []
+    window_2_client_map = weakref.WeakValueDictionary()
+
+    @classmethod 
+    def get_by_window(cls, window):
+        return cls.window_2_client_map.get(window)
+
     def __init__(self, screen, window, wa):
         self.screen = screen
@@ -20 +30 @@
         self.maxed_geom = self.geom.copy()
         self.old_border = wa.border_width
+        self.desktop = screen.active_desktop
 
         self.configure_window()
         self.update_title()
         self.update_size_hints()
+        self.update_wm_hints()
+        self.check_ewmh()
 
         xlib.XSelectInput(samuraix.display, window, 
@@ -30 +43 @@
                 xlib.EnterWindowMask)
 
-        log.debug("new client with %s %s" % (self.window, self.geom))
+        log.info("new client with %s %s" % (self.window, self.geom))
 
         self.buttons = [
@@ -36 +49 @@
             (3, xlib.Mod4Mask, self.mouseresize),
         ]
+
+        self.all_clients.append(self)
+        self.window_2_client_map[self.window] = self
+
 
     def __str__(self):
@@ -56 +73 @@
                 xlib.StructureNotifyMask, cast(byref(ce), POINTER(xlib.XEvent)))
 
+    def check_ewmh(self):
+        format = c_int()
+        real = xlib.Atom()
+        data = c_uchar_p()
+        n = c_ulong()
+        extra = c_ulong()
+
+        #if (xlib.XGetWindowProperty(samuraix.display, self.window, samuraix.atoms['_NET_WM_STATE'],
+        #    0, LONG_NAN, False, xatom.XA_ATOM, byref(real), byref(format), byref(n),
+        #    byref(extra), byref(data)) == xlib.Success):
+        #    state = cast(data, xlib.Atom_p)       
+
     def update_title(self):
         self.title = xhelpers.get_text_property(self.window, samuraix.atoms['_NET_WM_NAME'])
         if not self.title:
             self.title = xhelpers.get_text_property(self.window, samuraix.atoms['WM_NAME'])
-        log.debug("title is now %s" % self.title)
+        log.debug("title of %s is now %s" % (self, self.title))
     
     def update_size_hints(self):
-        print "TODO update_size_hints"
+        msize = c_long()
+        size = xlib.XSizeHints()
+
+        if not xlib.XGetWMNormalHints(samuraix.display, self.window, byref(size), byref(msize)):
+            return 0
+
+        if size.flags & xlib.PBaseSize:
+            self.base_width = size.base_width
+            self.base_height = size.base_height
+        elif size.flags & xlib.PMinSize:
+            self.base_width = size.min_width
+            self.base_height = size.min_height
+        else:
+            self.base_width = 0 
+            self.base_height = 0 
+
+        if size.flags & xlib.PResizeInc:
+            self.inc_width = size.width_inc
+            self.inc_height = size.height_inc
+        else:
+            self.inc_width = 0
+            self.inc_height = 0 
+
+        if size.flags & xlib.PMaxSize:
+            self.max_width = size.max_width
+            self.max_height = size.max_height
+        else:
+            self.max_width = 0 
+            self.max_height = 0
+
+        if size.flags & xlib.PMinSize:
+            self.min_width = size.min_width
+            self.min_height = size.min_height
+        elif size.flags & xlib.PBaseSize:
+            self.min_width = size.base_width
+            self.min_height = size.base_height
+        else:
+            self.min_width = 0 
+            self.min_height = 0
+
+        if size.flags & xlib.PAspect:
+            self.min_aspect_x = size.min_aspect.x
+            self.min_aspect_y = size.min_aspect.y
+            self.max_aspect_x = size.max_aspect.x
+            self.max_aspect_y = size.max_aspect.y
+        else:
+            self.min_aspect_x = 0
+            self.min_aspect_y = 0
+            self.max_aspect_x = 0
+            self.max_aspect_y = 0
+
+        return size.flags
+
+    def update_wm_hints(self):
+        wmhp = xlib.XGetWMHints(samuraix.display, self.window)
+        wmh = wmhp[0]
+        if wmh:
+            self.urgent = wmh.flags & xlib.XUrgencyHint
+            if self.urgent: # and its not the focused window...
+                pass
+                # meant to invalidate that cache and draw titlebar
+            if wmh.flags & xlib.StateHint and wmh.initial_state == xlib.WithdrawnState:
+                self.border_width = 0
+                self.skip = True
+            xlib.XFree(wmhp)
+        
+    def process_ewmh_state_atom(self, client, state, set):
+        if state == samuraix.atoms['_NET_WM_STATE_STICKY']:
+            pass
 
     def resize(self, geometry, hints=False):
@@ -88 +185 @@
 
     def focus(self):
-        pass
+        log.debug('focusing %s' % self)
+        xlib.XSetInputFocus(samuraix.display, self.window, xlib.RevertToPointerRoot, 
+            xlib.CurrentTime)
+        self.stack()
+        self.grab_buttons()
+
+    def stack(self):
+        log.debug('stacking %s' % self)
+        xlib.XRaiseWindow(samuraix.display, self.window)
 
     def remove(self):
-        samuraix.app.clients.remove(self)
-        
+        log.debug('removing %s' % self)
         wc = xlib.XWindowChanges()
 
@@ -101 +205 @@
 
         xlib.XUngrabButton(samuraix.display, xlib.AnyButton, xlib.AnyModifier, self.window)
-        # TODO: window_setstate(c->win, WithdrawnState);
+        xhelpers.set_window_state(self.window, xlib.WithdrawnState)
         xlib.XSync(samuraix.display, False)
         xlib.XUngrabServer(samuraix.display)
+
+        self.all_clients.remove(self)
         
     def on_button_press(self, ev):
@@ -246 +352 @@
 
     def ban(self):
+        log.debug('banning %s' % self)
         xlib.XUnmapWindow(samuraix.display, self.window)
         xhelpers.set_window_state(self.window, xlib.IconicState)
@@ -251 +358 @@
 
     def unban(self):
+        log.debug('unbanning %s' % self)
         xlib.XMapWindow(samuraix.display, self.window)
         xhelpers.set_window_state(self.window, xlib.NormalState)
         # titlebar remap here
                 
+    def move_to_desktop(self, desktop):
+        desktop.remove_client
 
 Client.register_event_type('on_button_press')

samurai-x/samuraix/desktop.py

@@ -2 +2 @@
 import pyglet
 
+import weakref
+
 import samuraix
+
+import logging
+log = logging.getLogger(__name__)
 
 class Desktop(pyglet.event.EventDispatcher):
@@ -9 +14 @@
         self.name = name
 
+        log.info('created new desktop %s' % self)
+
         self.clients = []
 
+    def __str__(self):
+        return "<Desktop '%s' on %s>" % (self.name, self.screen)
+
+    def add_client(self, client):
+        log.debug('adding client %s to desktop %s' % (client, self))
+        self.clients.append(weakref.ref(client))
+        if client.desktop is self:
+            client.unban()
+        else:
+            client.ban()
+
+    def on_show(self):
+        log.info('showing desktop %s' % self)
+        for client in self.clients:
+            c = client()
+            if c is not None:
+                c.unban()
+        
+    def on_hide(self):
+        log.info('hiding desktop %s' % self)
+        for client in self.clients:
+            c = client()
+            if c is not None:
+                c.ban()
+    
+
+Desktop.register_event_type('on_show')
+Desktop.register_event_type('on_hide')
+

samurai-x/samuraix/main.py

@@ -1 @@
-
-import os
-
 import pyglet
 pyglet.options['shadow_window'] = False
@@ -10 +7 @@
 import samuraix
 from samuraix.sxctypes import *
-from samuraix import keydefs
+from samuraix import xhelpers
 
 import logging
@@ -16 +13 @@
 
 
-def open_display(displayname=None):
-    if displayname is None:
-        displayname = os.environ.get('DISPLAY', ':0')
-    samuraix.displayname = displayname
-
-    log.debug("connecting to %s" % displayname)
-    samuraix.display = xlib.XOpenDisplay(None)
-    if not samuraix.display:
-        # not sure what this exception should be really...
-        raise RuntimeError("Cant connect to xserver")
-
-    xlib.XSynchronize(samuraix.display, True)
-
-
-def get_numlock_mask():
-    modmap = xlib.XGetModifierMapping(samuraix.display)[0]
-    keycode = xlib.XKeysymToKeycode(samuraix.display, keydefs.XK_Num_Lock)
-
-    mask = 0 
-
-    for i in range(8):
-        for j in range(0, modmap.max_keypermod):
-            if modmap.modifiermap[i * modmap.max_keypermod + j] == keycode:
-                mask = 1 << i
-
-    xlib.XFreeModifiermap(modmap)
-
-    xlib.NumLockMask = mask
-
-
 def init_atoms():
+    log.info('creating atoms instance...')
     from samuraix.atoms import Atoms
     samuraix.atoms = Atoms()
 
+
 def init_cursors():
+    log.info('creating cursors instance...')
     from samuraix.cursors import Cursors
     samuraix.cursors = Cursors()
@@ -63 +33 @@
 
 def load_config():
+    log.info('loading config...')
     samuraix.config = {
         'screens': {
-            '0': {
+            0: {
                 'virtual_desktops': [
                     {'name': 'one'},
@@ -79 +50 @@
     configure_logging()
 
+    xhelpers.open_display()
+    xhelpers.check_for_other_wm()
+    #xhelpers.setup_xerror()
+
     load_config()
 
-    open_display()
     init_atoms()
-    get_numlock_mask()
+    xhelpers.get_numlock_mask()
     init_cursors()
 
-    app.register_x_event_handlers()
+    log.info('creating app instance...')
     samuraix.app = app()
-    samuraix.app.run()
+    samuraix.app.init()
+    log.info('let battle commence...')
+    try:
+        samuraix.app.run()
+    finally:
+        xhelpers.close_display()
+    log.info('done')
+
 
 if __name__ == '__main__':    
-    from samuraix.app import App
+    from samuraix.appl import App
     run(App)
 

samurai-x/samuraix/screen.py

@@ -1 +1 @@
 import pyglet
 from pyglet.window.xlib import xlib 
+
+import weakref
+import functools
 
 import samuraix
@@ -6 +9 @@
 from samuraix.xconstants import BUTTONMASK, CLEANMASK
 from samuraix.desktop import Desktop
-from samuraix import keydefs
+from samuraix.statusbar import Statusbar
+from samuraix import keysymdef
 from samuraix.testfunc import testfunc
+from samuraix.sxctypes import *
+from samuraix import xatom
+from samuraix.xhelpers import get_window_state
+from samuraix.client import Client
 
 import logging
 log = logging.getLogger(__name__)
 
+def xterm():
+    from subprocess import *
+    pid = Popen(["/usr/bin/xterm"]).pid
+
+
 class Screen(pyglet.event.EventDispatcher):
+
     _default_conf = {
         'virtual_desktops': [
             {'name':'one'},
         ],
+        'status_bar': {
+            'position': 'top',
+        }
     }
+
+    client_class = Client
 
     def __init__(self, num, buttons=None):
@@ -27 +46 @@
         self.buttons = () if buttons is None else buttons
         self.keys = [
-            (keydefs.XK_Return, xlib.Mod4Mask, testfunc),
+            (keysymdef.XK_Return, xlib.Mod4Mask, xterm),
+            (keysymdef.XK_F1, xlib.Mod4Mask, 
+                functools.partial(self.set_active_desktop_by_name, 'one')),
+            (keysymdef.XK_F2, xlib.Mod4Mask, 
+                functools.partial(self.set_active_desktop_by_name, 'two')),
+            (keysymdef.XK_F3, xlib.Mod4Mask, 
+                functools.partial(self.set_active_desktop_by_name, 'three')),
         ]
         
         self.desktops = []
+        self.active_desktop = None
+
+        self.clients = []
+
+        self.config = self._default_conf.copy()
 
         try:
-            conf = samuraix.config['screens'][self.num]
+            self.config.update(samuraix.config['screens'][self.num])
         except KeyError:
-            conf = self._default_conf
-
-        for conf_desktop in conf['virtual_desktops']:
+            log.debug('cant find config for screen %s' % self.num)
+
+        for conf_desktop in self.config['virtual_desktops']:
             desktop = Desktop(self, conf_desktop['name'])
             self.desktops.append(desktop)
 
-        self.active_desktop = self.desktops[0]
+        self.widgets = []
+
+        if self.config['status_bar']['position'] is not None:
+            self.widgets.append(Statusbar(self))
+
+        self.set_active_desktop(self.desktops[0])
+
+        wa = xlib.XSetWindowAttributes()
+        wa.event_mask = ( xlib.SubstructureRedirectMask |      
+                          xlib.SubstructureNotifyMask | 
+                          xlib.EnterWindowMask | 
+                          xlib.LeaveWindowMask | 
+                          xlib.StructureNotifyMask )
+        wa.cursor = samuraix.cursors['normal']
+
+        root = self.root_window
+
+        xlib.XChangeWindowAttributes(samuraix.display, 
+            root, 
+            xlib.CWEventMask | xlib.CWCursor,
+            byref(wa))
+
+        xlib.XSelectInput(samuraix.display,
+            root, 
+            wa.event_mask)
+
+        self.set_supported_hints()
+
+        self.grab_buttons()
+        self.grab_keys()
 
     def __str__(self):
@@ -50 +109 @@
     root_window = property(_get_root_window)
 
-    def set_active_desktop(self, name):
+    def set_supported_hints(self):
+        atoms = [
+            samuraix.atoms['_NET_SUPPORTED'], 
+            samuraix.atoms['_NET_CLIENT_LIST'], 
+            samuraix.atoms['_NET_NUMBER_OF_DESKTOPS'], 
+            samuraix.atoms['_NET_CURRENT_DESKTOP'], 
+            samuraix.atoms['_NET_DESKTOP_NAMES'],
+            samuraix.atoms['_NET_ACTIVE_WINDOW'],
+            samuraix.atoms['_NET_CLOSE_WINDOW'],
+
+            samuraix.atoms['_NET_WM_NAME'],
+            samuraix.atoms['_NET_WM_ICON_NAME'],
+            samuraix.atoms['_NET_WM_WINDOW_TYPE'],
+            samuraix.atoms['_NET_WM_WINDOW_TYPE_NORMAL'],
+            samuraix.atoms['_NET_WM_WINDOW_TYPE_DOCK'],
+            samuraix.atoms['_NET_WM_WINDOW_TYPE_SPLASH'],
+            samuraix.atoms['_NET_WM_WINDOW_TYPE_DIALOG'],
+            samuraix.atoms['_NET_WM_STATE'],
+            samuraix.atoms['_NET_WM_STATE_STICKY'],
+            samuraix.atoms['_NET_WM_STATE_SKIP_TASKBAR'],
+            samuraix.atoms['_NET_WM_STATE_FULLSCREEN'],
+
+            samuraix.atoms['UTF8_STRING'],
+        ]
+        n = len(atoms)
+        atoms_arr_type = xlib.Atom * n
+        atoms_arr = atoms_arr_type(*atoms)
+
+        xlib.XChangeProperty(samuraix.display, self.root_window,
+            samuraix.atoms['_NET_SUPPORTED'], xatom.XA_ATOM, 32, 
+            xlib.PropModeReplace, cast(atoms_arr, c_uchar_p), n)
+
+    def scan(self):
+        wa = xlib.XWindowAttributes()
+
+        wins = xlib.Window_p()
+        wins.contains = None
+        d1 = xlib.Window()
+        d2 = xlib.Window()
+        num = c_uint()
+
+        root = self.root_window
+        log.debug('root is %s' % root)
+        if xlib.XQueryTree(samuraix.display, root, byref(d1), byref(d2), byref(wins), byref(num)):
+            log.debug('found %s windows' % num)
+            for i in range(num.value):
+                log.debug('found window %s' % wins[i])
+                if (xlib.XGetWindowAttributes(samuraix.display, wins[i], byref(wa)) and 
+                        not wa.override_redirect and 
+                        (wa.map_state == xlib.IsViewable or 
+                         get_window_state(wins[i]) == xlib.IconicState)):
+                    self.manage(wins[i], wa)
+        if wins:
+            xlib.XFree(wins)
+
+    def remove(self):
+        self.ungrab_buttons()
+        self.ungrab_keys()
+
+    def manage(self, window, wa):
+        client = self.client_class(self, window, wa)
+        log.info('screen %s managing %s' % (self, client))
+        self.clients.append(weakref.ref(client))
+
+        self.dispatch_event('on_client_add', client)
+    
+    def on_client_add(self, client):
+        self.active_desktop.add_client(client)
+
+    def set_active_desktop_by_name(self, name):
         for desktop in self.desktops:
             if desktop.name == name:
-                self.active_desktop = self.desktops[name]
+                self.set_active_desktop(desktop)
                 return
         raise ValueError(name)
+
+    def next_desktop(self):
+        idx = self.desktops.index(self.active_desktop) + 1
+        if idx >= len(self.desktops):
+            idx = 0 
+        self.set_active_desktop(self.desktops[idx])
+
+    def set_active_desktop(self, desktop):
+        assert desktop in self.desktops
+        if self.active_desktop is not None:
+            log.debug('hiding desktop %s' % self.active_desktop)
+            self.active_desktop.dispatch_event('on_hide')
+
+        self.active_desktop = desktop
+        log.debug('showing desktop %s' % desktop)
+        desktop.dispatch_event('on_show')
+        self.dispatch_event('on_desktop_change')
 
     def on_button_press(self, ev):
@@ -64 +209 @@
     def on_key_press(self, ev):
         keysym = xlib.XKeycodeToKeysym(samuraix.display, ev.keycode, 0)
+        log.debug('on_key_press %s %s %s' % (self, keysym, ev.keycode))
         for ks, modifiers, func in self.keys:
             if ks == keysym and CLEANMASK(modifiers) == CLEANMASK(ev.state):
+                log.debug('doing %s' % func)
                 func()
+                return
+        log.debug('not handler founnd')
 
     def grab_buttons(self):
@@ -91 +240 @@
 
     def grab_keys(self):
-        log.debug("gab_keys %s" % self)
-
-        root = self.root_window
-
-        xlib.XUngrabKey(samuraix.display, xlib.AnyKey, xlib.AnyModifier, root) 
+        log.debug("grab_keys %s" % self)
+
+        root = self.root_window
+
+        self.ungrab_keys()
         for keysym, modifiers, func in self.keys:
             kc = xlib.XKeysymToKeycode(samuraix.display, keysym)
@@ -112 +261 @@
                 root, True, xlib.GrabModeAsync, xlib.GrabModeAsync)
 
+    def ungrab_keys(self):
+        xlib.XUngrabKey(samuraix.display, xlib.AnyKey, xlib.AnyModifier, self.root_window) 
+
 
 Screen.register_event_type('on_button_press')
 Screen.register_event_type('on_key_press')
-
-
+Screen.register_event_type('on_desktop_change')
+Screen.register_event_type('on_client_add')
+
+

samurai-x/samuraix/xconstants.py

@@ -4 +4 @@
 xlib.XModifierKeymap_p = POINTER(xlib.XModifierKeymap)
 xlib.Window_p = POINTER(xlib.Window)
+xlib.RevertToPointerRoot = xlib.PointerRoot
 
 BUTTONMASK = (xlib.ButtonPressMask | xlib.ButtonReleaseMask)

samurai-x/samuraix/xhelpers.py

@@ +1 @@
+import os
+
 from pyglet.window.xlib import xlib 
 from samuraix.sxctypes import *
 
 import samuraix
+from samuraix import keysymdef
+
+import logging
+log = logging.getLogger(__name__)
+
 
 def get_window_state(window):
@@ -42 +49 @@
 
 
+def open_display(displayname=None):
+    log.info('opening display...')
+    if displayname is None:
+        displayname = os.environ.get('DISPLAY', ':0')
+    samuraix.displayname = displayname
+
+    log.info("connecting to %s" % displayname)
+    samuraix.display = xlib.XOpenDisplay(None)
+    if not samuraix.display:
+        # not sure what this exception should be really...
+        raise RuntimeError("Cant connect to xserver")
+
+    xlib.XSynchronize(samuraix.display, True)
+
+
+def close_display():
+    log.info('closing display..')
+    xlib.XSync(samuraix.display, False)
+    xlib.XCloseDisplay(samuraix.display)
+
+
+def check_for_other_wm():
+    log.info('checking for other wm...')
+    def xerror(display, ev):
+        raise "another wm is already running!"
+    c_xerror = xlib.XErrorHandler(xerror)
+
+    xlib.XSetErrorHandler(c_xerror)
+    for screen in range(xlib.XScreenCount(samuraix.display)):
+        xlib.XSelectInput(samuraix.display, 
+            xlib.XRootWindow(samuraix.display, screen),
+            xlib.SubstructureRedirectMask)
+    xlib.XSync(samuraix.display, False)
+    xlib.XSetErrorHandler(xlib.XErrorHandler())
+
+
+def get_numlock_mask():
+    log.info('fetching numlock mask...')
+    modmap = xlib.XGetModifierMapping(samuraix.display)[0]
+    keycode = xlib.XKeysymToKeycode(samuraix.display, keysymdef.XK_Num_Lock)
+
+    mask = 0 
+
+    for i in range(8):
+        for j in range(0, modmap.max_keypermod):
+            if modmap.modifiermap[i * modmap.max_keypermod + j] == keycode:
+                mask = 1 << i
+
+    xlib.XFreeModifiermap(modmap)
+
+    xlib.NumLockMask = mask
+
+
+def setup_xerror():
+    log.info('installing x error handler...')
+    def xerror(display, ev):
+        log.debug('xerror %s' % ev)
+        if (ev.error_code == xlib.BadWindow or
+            (ev.error_code == xlib.BadMatch and ev.request_code == xlib.X_SetInputFocus) or
+            (ev.error_code == xlib.BadValue and ev.request_code == xlib.X_KillClient) or
+            (ev.error_code == xlib.BadMatch and ev.request_code == xlib.X_ConfigureWindow)):
+            return 0
+        log.warn('fatal error: request_code=%s error_code=%s' % (ev.request_code, ev.error_code))
+        return xerrorxlib(display, ev)
+
+    c_xerror = xlib.XErrorHandler(xerror)
+    xerrorxlib = xlib.XSetErrorHandler(c_xerror)
+    xlib.XSync(samuraix.display, False)