X-Git-Url: https://git.dogcows.com/gitweb?a=blobdiff_plain;f=scripts%2Ffocus.py;h=5ae40cf273e483aa7cb71295a0d7d8beef15e398;hb=705d70b053b6c99949dabf01405bbb598588b3a8;hp=79da5a211d0349919c6238771627448787ae89f9;hpb=104c1a164b1e4e881e141d14263895401779d453;p=chaz%2Fopenbox

diff --git a/scripts/focus.py b/scripts/focus.py
index 79da5a21..5ae40cf2 100644
--- a/scripts/focus.py
+++ b/scripts/focus.py
@@ -2,49 +2,260 @@
 ###          Functions for helping out with your window focus.          ###
 ###########################################################################
 
-ob_focus_raise = 1
-ob_focus_fallback = 0
+###########################################################################
+###         Options that affect the behavior of the focus module.       ###
+###                                                                     ###
+# raise the window also when it is focused                              ###
+cycle_raise = 1                                                         ###
+# raise as you cycle in stacked mode                                    ###
+stacked_cycle_raise = 0                                                 ###
+# show a pop-up list of windows while cycling                           ###
+stacked_cycle_popup_list = 1                                            ###
+# send focus somewhere when nothing is left with the focus, if possible ###
+fallback = 0                                                            ###
+###                                                                     ###
+###                                                                     ###
+# Provides:                                                             ###
+# def focus_next_stacked(data, forward=1):                              ###
+#   """Focus the next (or previous, with forward=0) window in a stacked ###
+#      order."""                                                        ###
+# def focus_prev_stacked(data):                                         ###
+#   """Focus the previous window in a stacked order."""                 ###
+# def focus_next(data, num=1, forward=1):                               ###
+#   """Focus the next (or previous, with forward=0) window in a linear  ###
+#      order."""                                                        ###
+# def focus_prev(data, num=1):                                          ###
+#   """Focus the previous window in a linear order."""                  ###
+###                                                                     ###
+# All of these functions call be used as callbacks for bindings         ###
+# directly.                                                             ###
+###                                                                     ###
+###########################################################################
+
+import otk
+import ob
 
 # maintain a list of clients, stacked in focus order
-ob_clients = []
+_clients = []
 # maintaint he current focused window
-ob_focused = 0;
+_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
+def _new_win(data):
+    global _clients
+    global _doing_stacked
+    global _cyc_w;
 
-def ob_close_win(data):
-    global ob_clients
-    ob_clients.remove(data.client.window())
+    if _doing_stacked:
+        _clients.insert(_clients.index(_cyc_w), data.client.window())
+        _create_popup_list(data)
+        _hilite_popup_list(data)
+    else:
+        if not len(_clients):
+            _clients.append(data.client.window())
+        else:
+            _clients.insert(1, data.client.window()) # insert in 2nd slot
 
-def ob_focused(data):
-    global ob_clients
-    if data.client:
+def _close_win(data):
+    global _clients
+    global _cyc_w;
+    global _doing_stacked
+
+    if not _doing_stacked:
+        # not in the middle of stacked cycling, so who cares
+        _clients.remove(data.client.window())
+    else:
+        # have to fix the cycling if we remove anything
         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:
+        if _cyc_w == win:
+            _do_stacked_cycle(data, 1) # cycle off the window first, forward
+        _clients.remove(win)
+        _create_popup_list(data)
+
+def _focused(data):
+    global _clients
+    global _doing_stacked
+    global _cyc_w
+    
+    if data.client:
+        if not _doing_stacked: # only move the window when we're not cycling
+            win = data.client.window()
+            # move it to the top
+            _clients.remove(win)
+            _clients.insert(0, win)
+        else: # if we are cycling, then update our pointer
+            _cyc_w = data.client.window()
+            _hilite_popup_list(data)
+    elif fallback: 
         # pass around focus
-        ob_focused = 0
-        desktop = openbox.screen(data.screen).desktop()
-        for w in ob_clients:
-            client = openbox.findClient(w)
+        desktop = ob.openbox.screen(_cyc_screen).desktop()
+        for w in _clients:
+            client = ob.openbox.findClient(w)
             if client and (client.desktop() == desktop and \
                            client.normal() and client.focus()):
                 break
+        if _doing_stacked:
+            _cyc_w = 0
+            _hilite_popup_list(data)
+
+_cyc_mask = 0
+_cyc_key = 0
+_cyc_w = 0 # last window cycled to
+_cyc_screen = 0
+
+def _do_stacked_cycle(data, forward):
+    global _cyc_w
+    global stacked_cycle_raise
+    global _clients
+
+    clients = _clients[:] # make a copy
+
+    if not forward:
+        clients.reverse()
+
+    try:
+        i = clients.index(_cyc_w) + 1
+    except ValueError:
+        i = 1
+    clients = clients[i:] + clients[:i]
+        
+    desktop = ob.openbox.screen(data.screen).desktop()
+    for w in clients:
+        client = ob.openbox.findClient(w)
+        if client and (client.desktop() == desktop and \
+                       client.normal() and client.focus()):
+            if stacked_cycle_raise:
+                ob.openbox.screen(data.screen).raiseWindow(client)
+            return
+
+def _focus_stacked_ungrab(data):
+    global _cyc_mask;
+    global _cyc_key;
+    global _doing_stacked;
+
+    if data.action == ob.KeyAction.Release:
+        # have all the modifiers this started with been released?
+        if not _cyc_mask & data.state:
+            _destroy_popup_list()
+            ob.kungrab() # ungrab ourself
+            _doing_stacked = 0;
+            if cycle_raise:
+                client = ob.openbox.findClient(_cyc_w)
+                if client:
+                    ob.openbox.screen(data.screen).raiseWindow(client)
 
-ebind(EventNewWindow, ob_new_win)
-ebind(EventCloseWindow, ob_close_win)
-ebind(EventFocus, ob_focused)
+_list_widget = 0
+_list_labels = []
+_list_windows = []
+
+def _hilite_popup_list(data):
+    global _cyc_w, _doing_stacked
+    global _list_widget, _list_labels, _list_windows
+    found = 0
+
+    if not _list_widget and _doing_stacked:
+        _create_popup_list(data)
+    
+    if _list_widget:
+        i = 0
+        for w in _list_windows:
+            if w == _cyc_w:
+                _list_labels[i].focus()
+                found = 1
+            else:
+                _list_labels[i].unfocus()
+            i += 1
+    if not found:
+        _create_popup_list(data)
+
+def _destroy_popup_list():
+    global _list_widget, _list_labels, _list_windows
+    if _list_widget:
+        _list_windows = []
+        _list_labels = []
+        _list_widget = 0
+    
+def _create_popup_list(data):
+    global _list_widget, _list_labels, _list_windows, _clients
+
+    if _list_widget:
+        _destroy_popup_list()
+    
+    style = ob.openbox.screen(data.screen).style()
+    _list_widget = otk.Widget(ob.openbox, style,
+                              otk.Widget.Vertical, 0,
+                              style.bevelWidth(), 1)
+    t = style.titlebarFocusBackground()
+    _list_widget.setTexture(t)
+
+    titles = []
+    font = style.labelFont()
+    height = font.height()
+    longest = 0
+    for c in _clients:
+        client = ob.openbox.findClient(c)
+        desktop = ob.openbox.screen(data.screen).desktop()
+        if client and ((client.desktop() == desktop or
+                        client.desktop() == 0xffffffff) and \
+                       client.normal() and (client.canFocus() or
+                                            client.focusNotify())):
+            t = client.title()
+            if len(t) > 50: # limit the length of titles
+                t = t[:24] + "..." + t[-24:]
+            titles.append(t)
+            _list_windows.append(c)
+            l = font.measureString(t) + 10 # add margin
+            if l > longest: longest = l
+    if len(titles) > 1:
+        for t in titles:
+            w = otk.FocusLabel(_list_widget)
+            w.resize(longest, height)
+            w.setText(t)
+            w.unfocus()
+            _list_labels.append(w)
+        _list_widget.update()
+        area = otk.display.screenInfo(data.screen).rect()
+        _list_widget.move(area.x() + (area.width() -
+                                      _list_widget.width()) / 2,
+                          area.y() + (area.height() -
+                                      _list_widget.height()) / 2)
+        _list_widget.show(1)
+    else:
+        _destroy_popup_list() # nothing (or only 1) to list
+
+def focus_next_stacked(data, forward=1):
+    """Focus the next (or previous, with forward=0) window in a stacked
+       order."""
+    global _cyc_mask
+    global _cyc_key
+    global _cyc_w
+    global _cyc_screen
+    global _doing_stacked
+
+    if _doing_stacked:
+        if _cyc_key == data.key:
+            _do_stacked_cycle(data,forward)
+    else:
+        _cyc_mask = data.state
+        _cyc_key = data.key
+        _cyc_w = 0
+        _cyc_screen = data.screen
+        _doing_stacked = 1
+
+        global stacked_cycle_popup_list
+        if stacked_cycle_popup_list:
+            _create_popup_list(data)
+
+        ob.kgrab(data.screen, _focus_stacked_ungrab)
+        focus_next_stacked(data, forward) # start with the first press
+
+def focus_prev_stacked(data):
+    """Focus the previous window in a stacked order."""
+    focus_next_stacked(data, forward=0)
 
 def focus_next(data, num=1, forward=1):
     """Focus the next (or previous, with forward=0) window in a linear
        order."""
-    screen = openbox.screen(data.screen)
+    screen = ob.openbox.screen(data.screen)
     count = screen.clientCount()
 
     if not count: return # no clients
@@ -74,7 +285,7 @@ def focus_next(data, num=1, forward=1):
         if client.normal() and \
                (client.desktop() == curdesk or client.desktop() == 0xffffffff)\
                and client.focus():
-            if ob_focus_raise:
+            if cycle_raise:
                 screen.raiseWindow(client)
             return
         if forward:
@@ -90,4 +301,8 @@ def focus_prev(data, num=1):
     focus_next(data, num, forward=0)
 
 
+ob.ebind(ob.EventAction.NewWindow, _new_win)
+ob.ebind(ob.EventAction.CloseWindow, _close_win)
+ob.ebind(ob.EventAction.Focus, _focused)
+
 print "Loaded focus.py"