some intermediate stage. stacked focus cycling is very broken. dont try it. going...

[chaz/openbox] / scripts / focus.py

diff --git a/scripts/focus.py b/scripts/focus.py
index c0d60b1ee7bb06308f05cd65d5ea268e3738a42a..011fcc5b09731ed6b957dc88a1f966a342f5f1c7 100644 (file)
--- a/scripts/focus.py
+++ b/scripts/focus.py
@@ -2,39 +2,127 @@
 ###          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
-ob_focus_stack = []
+
+# maintain a list of clients, stacked in focus order
+ob_clients = []
+# maintaint he current focused window
+ob_doing_stacked = 0
+
+def ob_new_win(data):
+    global ob_clients
+    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
+    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_focus_raise
-    global ob_focus_fallback
-    global ob_focus_stack
+    global ob_clients
+    global ob_doing_stacked
+    global ob_cyc_w
+    
     if data.client:
-        window = data.client.window()
-        # add/move to front the stack
-        if window in ob_focus_stack:
-            ob_focus_stack.remove(window)
-        ob_focus_stack.insert(0, window)
-    elif ob_focus_fallback:
+        if not ob_doing_stacked: # only move the window when we're not cycling
+            win = data.client.window()
+            # move it to the top
+            ob_clients.remove(win)
+            ob_clients.insert(0, win)
+        else: # if we are cycling, then update our pointer
+            ob_cyc_w = data.client.window()
+    elif ob_focus_fallback: 
         # pass around focus
-        desktop = openbox.screen(data.screen).desktop()
-        l = len(ob_focus_stack)
-        i = 0
-        while i < l:
-            w = ob_focus_stack[i]
+        desktop = openbox.screen(ob_cyc_screen).desktop()
+        for w in ob_clients:
             client = openbox.findClient(w)
-            if not client: # window is gone, remove it
-                ob_focus_stack.pop(i)
-                l = l - 1
-            elif client.desktop() == desktop and \
-                     client.normal() and client.focus():
+            if client and (client.desktop() == desktop and \
+                           client.normal() and client.focus()):
                 break
-            else:
-                i = i + 1
 
+ebind(EventNewWindow, ob_new_win)
+ebind(EventCloseWindow, ob_close_win)
 ebind(EventFocus, ob_focused)
 
+ob_cyc_mask = 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:
+        # 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:
+        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_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(data.screen, focus_next_stacked_grab)
+    print "GRABBED!"
+    focus_next_stacked_grab(data) # start with the first press
+
+def focus_prev_stacked(data):
+    return
+
 def focus_next(data, num=1, forward=1):
     """Focus the next (or previous, with forward=0) window in a linear
        order."""
@@ -53,10 +141,11 @@ def focus_next(data, num=1, forward=1):
         for i in r:
             if found:
                 target = i
+                found = 2
                 break
             elif screen.client(i).window() == client_win:
                 found = 1
-        if not found: # wraparound
+        if found == 1: # wraparound
             if forward: target = 0
             else: target = count - 1
 
@@ -74,7 +163,7 @@ def focus_next(data, num=1, forward=1):
             t += num
             if t >= count: t -= count
         else:
-            t -= 1
+            t -= num
             if t < 0: t += count
         if t == target: return # nothing to focus