@@ -2,38 +2,60 @@ ###########################################################################
 ###          Functions for helping out with your window focus.          ###
 ###########################################################################
 
+# raise the window also when it is focused
 ob_focus_raise = 1
+# send focus somewhere when nothing is left with the focus if possible
 ob_focus_fallback = 0
 
 # maintain a list of clients, stacked in focus order
 ob_clients = []
 # maintaint he current focused window
-ob_focused = 0
-ob_hold_client_list = 0
+ob_doing_stacked = 0
 
 def ob_new_win(data):
     global ob_clients
-    if not len(ob_clients): ob_clients.append(data.client.window())
-    else: ob_clients.insert(1, data.client.window()) # insert in 2nd slot
+    global ob_doing_stacked
+    global ob_cyc_w;
+
+    if ob_doing_stacked:
+        ob_clients.insert(ob_clients.index(ob_cyc_w), data.client.window())
+    else:
+        if not len(ob_clients):
+            ob_clients.append(data.client.window())
+        else:
+            ob_clients.insert(1, data.client.window()) # insert in 2nd slot
 
 def ob_close_win(data):
     global ob_clients
-    ob_clients.remove(data.client.window())
+    global ob_cyc_w;
+    global ob_doing_stacked
+
+    if not ob_doing_stacked:
+        # not in the middle of stacked cycling, so who cares
+        ob_clients.remove(data.client.window())
+    else:
+        # have to fix the cycling if we remove anything
+        win = data.client.window()
+        if ob_cyc_w == win:
+            do_stacked_cycle(data) # cycle off the window first
+        ob_clients.remove(win)
 
 def ob_focused(data):
     global ob_clients
+    global ob_doing_stacked
+    global ob_cyc_w
+    
     if data.client:
-        if not ob_hold_client_list:
+        if not ob_doing_stacked: # only move the window when we're not cycling
             win = data.client.window()
-            ob_focused = win
             # move it to the top
             ob_clients.remove(win)
             ob_clients.insert(0, win)
-    elif ob_focus_fallback:
-        ob_old_client_list = 0 # something is wrong.. stop holding
+        else: # if we are cycling, then update our pointer
+            ob_cyc_w = data.client.window()
+    elif ob_focus_fallback: 
         # pass around focus
-        ob_focused = 0
-        desktop = openbox.screen(data.screen).desktop()
+        desktop = openbox.screen(ob_cyc_screen).desktop()
         for w in ob_clients:
             client = openbox.findClient(w)
             if client and (client.desktop() == desktop and \
@@ -45,31 +67,56 @@ ebind(EventCloseWindow, ob_close_win)
 ebind(EventFocus, ob_focused)
 
 ob_cyc_mask = 0
-ob_cyc_key = 0;
+ob_cyc_key = 0
+ob_cyc_w = 0 # last window cycled to
+ob_cyc_screen = 0
+
+def do_stacked_cycle(data):
+    global ob_cyc_w
+
+    try:
+        i = ob_clients.index(ob_cyc_w) + 1
+    except ValueError:
+        i = 0
+        
+    clients = ob_clients[i:] + ob_clients[:i]
+    for w in clients:
+        client = openbox.findClient(w)
+        if client and (client.desktop() == desktop and \
+                       client.normal() and client.focus()):
+            return
 
 def focus_next_stacked_grab(data):
     global ob_cyc_mask;
     global ob_cyc_key;
+    global ob_cyc_w;
+    global ob_doing_stacked;
 
     if data.action == EventKeyRelease:
-        print "release: " + str(ob_cyc_mask) + "..." + str(data.state)
         # have all the modifiers this started with been released?
         if not ob_cyc_mask & data.state:
             kungrab() # ungrab ourself
+            ob_doing_stacked = 0;
             print "UNGRABBED!"
     else:
-        print "press: " + str(ob_cyc_mask) + "..." + str(data.state) + \
-              "..." + data.key
         if ob_cyc_key == data.key:
+            # the next window to try focusing in ob_clients[ob_cyc_i]
             print "CYCLING!!"
+            do_stacked_cycle(data)
 
 def focus_next_stacked(data, forward=1):
-    global ob_cyc_mask;
-    global ob_cyc_key;
+    global ob_cyc_mask
+    global ob_cyc_key
+    global ob_cyc_w
+    global ob_cyc_screen
+    global ob_doing_stacked
     ob_cyc_mask = data.state
     ob_cyc_key = data.key
+    ob_cyc_w = 0
+    ob_cyc_screen = data.screen
+    ob_doing_stacked = 1
 
-    kgrab(focus_next_stacked_grab)
+    kgrab(data.screen, focus_next_stacked_grab)
     print "GRABBED!"
     focus_next_stacked_grab(data) # start with the first press
 

@@ -372,15 +372,21 @@ }
 }
 
 
-bool Bindings::grabKeyboard(PyObject *callback)
+bool Bindings::grabKeyboard(int screen, PyObject *callback)
 {
   assert(callback);
   if (_keybgrab_callback) return false; // already grabbed
+
+  int i;
+  for (i = 0; i < openbox->screenCount(); ++i)
+    if (openbox->screen(screen)->number() == screen)
+      break;
+  if (i >= openbox->screenCount())
+    return false; // couldn't find the screen.. it's not managed
   
-  int screen = openbox->screen(0)->number();
-  Window root = otk::display->screenInfo(screen)->rootWindow();
+  Window root = otk::display->screenInfo(i)->rootWindow();
   if (XGrabKeyboard(**otk::display, root, false, GrabModeAsync,
-                    GrabModeAsync, CurrentTime))
+                    GrabModeSync, CurrentTime))
     return false;
   printf("****GRABBED****\n");
   _keybgrab_callback = callback;
@@ -563,7 +569,7 @@ 
 void Bindings::fireButton(MouseData *data)
 {
   if (data->context == MC_Window) {
-    // Replay the event, so it goes to the client, and ungrab the device.
+    // Replay the event, so it goes to the client
     XAllowEvents(**otk::display, ReplayPointer, data->time);
   }
   

@@ -120,7 +120,7 @@ void setResetKey(const std::string &key);
 
   void grabKeys(bool grab);
 
-  bool grabKeyboard(PyObject *callback);
+  bool grabKeyboard(int screen, PyObject *callback);
   void ungrabKeyboard();
 
   bool addButton(const std::string &but, MouseContext context,

@@ -177,7 +177,7 @@ 
   //! Returns a managed screen
   inline Screen *screen(int num) {
     assert(num >= 0); assert(num < (signed)_screens.size());
-    if (num >= screenCount())
+    if (num < 0 || num >= screenCount())
       return NULL;
     return _screens[num];
   }

@@ -55,6 +55,7 @@ def shapeEventBase(*args): return apply(_openbox.Display_shapeEventBase,args)
     def xinerama(*args): return apply(_openbox.Display_xinerama,args)
     def numLockMask(*args): return apply(_openbox.Display_numLockMask,args)
     def scrollLockMask(*args): return apply(_openbox.Display_scrollLockMask,args)
+    def modifierMap(*args): return apply(_openbox.Display_modifierMap,args)
     def __mul__(*args): return apply(_openbox.Display___mul__,args)
     def grab(*args): return apply(_openbox.Display_grab,args)
     def ungrab(*args): return apply(_openbox.Display_ungrab,args)

@@ -694,20 +694,21 @@ #define  SWIGTYPE_p_PyObject swig_types[45]
 #define  SWIGTYPE_p_otk__ScreenInfo swig_types[46] 
 #define  SWIGTYPE_p_otk__RenderStyle swig_types[47] 
 #define  SWIGTYPE_p_ob__EventData swig_types[48] 
-#define  SWIGTYPE_p_XCreateWindowEvent swig_types[49] 
-#define  SWIGTYPE_p_XDestroyWindowEvent swig_types[50] 
-#define  SWIGTYPE_p_otk__Property__StringVect swig_types[51] 
-#define  SWIGTYPE_p_ob__WidgetBase swig_types[52] 
-#define  SWIGTYPE_p_otk__Atoms swig_types[53] 
-#define  SWIGTYPE_p_XKeyEvent swig_types[54] 
-#define  SWIGTYPE_p_int swig_types[55] 
-#define  SWIGTYPE_p_otk__Strut swig_types[56] 
-#define  SWIGTYPE_p_unsigned_long swig_types[57] 
+#define  SWIGTYPE_p_XModifierKeymap swig_types[49] 
+#define  SWIGTYPE_p_XCreateWindowEvent swig_types[50] 
+#define  SWIGTYPE_p_XDestroyWindowEvent swig_types[51] 
+#define  SWIGTYPE_p_otk__Property__StringVect swig_types[52] 
+#define  SWIGTYPE_p_ob__WidgetBase swig_types[53] 
+#define  SWIGTYPE_p_otk__Atoms swig_types[54] 
+#define  SWIGTYPE_p_XKeyEvent swig_types[55] 
+#define  SWIGTYPE_p_int swig_types[56] 
+#define  SWIGTYPE_p_otk__Strut swig_types[57] 
 #define  SWIGTYPE_p_p_unsigned_long swig_types[58] 
-#define  SWIGTYPE_p_XMotionEvent swig_types[59] 
-#define  SWIGTYPE_p_XButtonEvent swig_types[60] 
-#define  SWIGTYPE_p_XSelectionEvent swig_types[61] 
-static swig_type_info *swig_types[63];
+#define  SWIGTYPE_p_unsigned_long swig_types[59] 
+#define  SWIGTYPE_p_XMotionEvent swig_types[60] 
+#define  SWIGTYPE_p_XButtonEvent swig_types[61] 
+#define  SWIGTYPE_p_XSelectionEvent swig_types[62] 
+static swig_type_info *swig_types[64];
 
 /* -------- TYPES TABLE (END) -------- */
 
@@ -1150,6 +1151,23 @@ if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_otk__Display,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
     result = (unsigned int)((otk::Display const *)arg1)->scrollLockMask();
     
     resultobj = PyInt_FromLong((long)result);
+    return resultobj;
+    fail:
+    return NULL;
+}
+
+
+static PyObject *_wrap_Display_modifierMap(PyObject *self, PyObject *args) {
+    PyObject *resultobj;
+    otk::Display *arg1 = (otk::Display *) 0 ;
+    XModifierKeymap *result;
+    PyObject * obj0  = 0 ;
+    
+    if(!PyArg_ParseTuple(args,(char *)"O:Display_modifierMap",&obj0)) goto fail;
+    if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_otk__Display,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
+    result = (XModifierKeymap *)((otk::Display const *)arg1)->modifierMap();
+    
+    resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_XModifierKeymap, 0);
     return resultobj;
     fail:
     return NULL;
@@ -11273,13 +11291,14 @@ 
 
 static PyObject *_wrap_kgrab(PyObject *self, PyObject *args) {
     PyObject *resultobj;
-    PyObject *arg1 = (PyObject *) 0 ;
+    int arg1 ;
+    PyObject *arg2 = (PyObject *) 0 ;
     PyObject *result;
-    PyObject * obj0  = 0 ;
+    PyObject * obj1  = 0 ;
     
-    if(!PyArg_ParseTuple(args,(char *)"O:kgrab",&obj0)) goto fail;
-    arg1 = obj0;
-    result = (PyObject *)ob::kgrab(arg1);
+    if(!PyArg_ParseTuple(args,(char *)"iO:kgrab",&arg1,&obj1)) goto fail;
+    arg2 = obj1;
+    result = (PyObject *)ob::kgrab(arg1,arg2);
     
     resultobj = result;
     return resultobj;
@@ -11391,6 +11410,7 @@ { (char *)"Display_shapeEventBase", _wrap_Display_shapeEventBase, METH_VARARGS },
 	 { (char *)"Display_xinerama", _wrap_Display_xinerama, METH_VARARGS },
 	 { (char *)"Display_numLockMask", _wrap_Display_numLockMask, METH_VARARGS },
 	 { (char *)"Display_scrollLockMask", _wrap_Display_scrollLockMask, METH_VARARGS },
+	 { (char *)"Display_modifierMap", _wrap_Display_modifierMap, METH_VARARGS },
 	 { (char *)"Display___mul__", _wrap_Display___mul__, METH_VARARGS },
 	 { (char *)"Display_grab", _wrap_Display_grab, METH_VARARGS },
 	 { (char *)"Display_ungrab", _wrap_Display_ungrab, METH_VARARGS },
@@ -11950,6 +11970,7 @@ static swig_type_info _swigt__p_PyObject[] = {{"_p_PyObject", 0, "PyObject *", 0},{"_p_PyObject"},{0}};
 static swig_type_info _swigt__p_otk__ScreenInfo[] = {{"_p_otk__ScreenInfo", 0, "otk::ScreenInfo *", 0},{"_p_otk__ScreenInfo"},{0}};
 static swig_type_info _swigt__p_otk__RenderStyle[] = {{"_p_otk__RenderStyle", 0, "otk::RenderStyle *", 0},{"_p_otk__RenderStyle"},{0}};
 static swig_type_info _swigt__p_ob__EventData[] = {{"_p_ob__EventData", 0, "ob::EventData *", 0},{"_p_ob__EventData"},{0}};
+static swig_type_info _swigt__p_XModifierKeymap[] = {{"_p_XModifierKeymap", 0, "XModifierKeymap *", 0},{"_p_XModifierKeymap"},{0}};
 static swig_type_info _swigt__p_XCreateWindowEvent[] = {{"_p_XCreateWindowEvent", 0, "XCreateWindowEvent *", 0},{"_p_XCreateWindowEvent"},{0}};
 static swig_type_info _swigt__p_XDestroyWindowEvent[] = {{"_p_XDestroyWindowEvent", 0, "XDestroyWindowEvent *", 0},{"_p_XDestroyWindowEvent"},{0}};
 static swig_type_info _swigt__p_otk__Property__StringVect[] = {{"_p_otk__Property__StringVect", 0, "otk::Property::StringVect *", 0},{"_p_otk__Property__StringVect"},{0}};
@@ -11958,8 +11979,8 @@ static swig_type_info _swigt__p_otk__Atoms[] = {{"_p_otk__Atoms", 0, "otk::Atoms *", 0},{"_p_otk__Atoms"},{0}};
 static swig_type_info _swigt__p_XKeyEvent[] = {{"_p_XKeyEvent", 0, "XKeyEvent *", 0},{"_p_XKeyEvent"},{0}};
 static swig_type_info _swigt__p_int[] = {{"_p_int", 0, "int *", 0},{"_p_int"},{0}};
 static swig_type_info _swigt__p_otk__Strut[] = {{"_p_otk__Strut", 0, "otk::Strut *", 0},{"_p_otk__Strut"},{0}};
-static swig_type_info _swigt__p_unsigned_long[] = {{"_p_unsigned_long", 0, "unsigned long *", 0},{"_p_unsigned_long"},{0}};
 static swig_type_info _swigt__p_p_unsigned_long[] = {{"_p_p_unsigned_long", 0, "unsigned long **", 0},{"_p_p_unsigned_long"},{0}};
+static swig_type_info _swigt__p_unsigned_long[] = {{"_p_unsigned_long", 0, "unsigned long *", 0},{"_p_unsigned_long"},{0}};
 static swig_type_info _swigt__p_XMotionEvent[] = {{"_p_XMotionEvent", 0, "XMotionEvent *", 0},{"_p_XMotionEvent"},{0}};
 static swig_type_info _swigt__p_XButtonEvent[] = {{"_p_XButtonEvent", 0, "XButtonEvent *", 0},{"_p_XButtonEvent"},{0}};
 static swig_type_info _swigt__p_XSelectionEvent[] = {{"_p_XSelectionEvent", 0, "XSelectionEvent *", 0},{"_p_XSelectionEvent"},{0}};
@@ -12014,6 +12035,7 @@ _swigt__p_PyObject,
 _swigt__p_otk__ScreenInfo, 
 _swigt__p_otk__RenderStyle, 
 _swigt__p_ob__EventData, 
+_swigt__p_XModifierKeymap, 
 _swigt__p_XCreateWindowEvent, 
 _swigt__p_XDestroyWindowEvent, 
 _swigt__p_otk__Property__StringVect, 
@@ -12022,8 +12044,8 @@ _swigt__p_otk__Atoms,
 _swigt__p_XKeyEvent, 
 _swigt__p_int, 
 _swigt__p_otk__Strut, 
-_swigt__p_unsigned_long, 
 _swigt__p_p_unsigned_long, 
+_swigt__p_unsigned_long, 
 _swigt__p_XMotionEvent, 
 _swigt__p_XButtonEvent, 
 _swigt__p_XSelectionEvent, 

@@ -123,14 +123,14 @@ }
   Py_INCREF(Py_None); return Py_None;
 }
 
-PyObject *kgrab(PyObject *func)
+PyObject *kgrab(int screen, PyObject *func)
 {
   if (!PyCallable_Check(func)) {
     PyErr_SetString(PyExc_TypeError, "Invalid callback function.");
     return NULL;
   }
 
-  if (!ob::openbox->bindings()->grabKeyboard(func)) {
+  if (!ob::openbox->bindings()->grabKeyboard(screen, func)) {
     PyErr_SetString(PyExc_RuntimeError,"Unable to grab keybaord.");
     return NULL;
   }

@@ -192,7 +192,7 @@ ob::MouseAction action, PyObject *func);
 
 PyObject *kbind(PyObject *keylist, ob::KeyContext context, PyObject *func);
 
-PyObject *kgrab(PyObject *func);
+PyObject *kgrab(int screen, PyObject *func);
 PyObject *kungrab();
 
 PyObject *ebind(ob::EventAction action, PyObject *func);