4 This is a basic cycling class for anything, from xOr's stackedcycle.py,
5 that pops up a cycling menu when there's more than one thing to be cycled
7 An example of inheriting from and modifying this class is _CycleWindows,
8 which allows users to cycle around windows.
10 This class could conceivably be used to cycle through anything -- desktops,
11 windows of a specific class, XMMS playlists, etc.
14 """This specifies a rough limit of characters for the cycling list titles.
15 Titles which are larger will be chopped with an elipsis in their
19 """If this is non-zero then windows will be activated as they are
20 highlighted in the cycling list (except iconified windows)."""
21 ACTIVATE_WHILE_CYCLING
= 0
23 """If this is true, we start cycling with the next (or previous) thing
27 """If this is true, a popup window will be displayed with the options
32 """Initialize an instance of this class. Subclasses should
33 do any necessary event binding in their constructor as well.
35 self
.cycling
= 0 # internal var used for going through the menu
36 self
.items
= [] # items to cycle through
38 self
.widget
= None # the otk menu widget
39 self
.menuwidgets
= [] # labels in the otk menu widget TODO: RENAME
41 def createPopup(self
):
42 """Creates the cycling popup menu.
44 self
.widget
= otk
.Widget(self
.screen
.number(), ob
.openbox
,
45 otk
.Widget
.Vertical
, 0, 1)
47 def destroyPopup(self
):
48 """Destroys (or rather, cleans up after) the cycling popup menu.
53 def populateItems(self
):
54 """Populate self.items with the appropriate items that can currently
55 be cycled through. self.items may be cleared out before this
60 def menuLabel(self
, item
):
61 """Return a string indicating the menu label for the given item.
62 Don't worry about title truncation.
66 def itemEqual(self
, item1
, item2
):
67 """Compare two items, return 1 if they're "equal" for purposes of
68 cycling, and 0 otherwise.
70 # suggestion: define __eq__ on item classes so that this works
71 # in the general case. :)
74 def populateLists(self
):
75 """Populates self.items and self.menuwidgets, and then shows and
76 positions the cycling popup. You probably shouldn't mess with
77 this function; instead, see populateItems and menuLabel.
82 current
= self
.items
[self
.menupos
]
94 for i
in range(len(self
.items
)):
97 w
= otk
.Label(self
.widget
)
98 # current item might have shifted after a populateItems()
99 # call, so we need to do this test.
100 if current
and self
.itemEqual(c
, current
):
103 self
.menuwidgets
.append(w
)
105 t
= self
.menuLabel(c
)
106 # TODO: maybe subclasses will want to truncate in different ways?
107 if len(t
) > self
.TITLE_SIZE_LIMIT
: # limit the length of titles
108 t
= t
[:self
.TITLE_SIZE_LIMIT
/ 2 - 2] + "..." + \
109 t
[0 - self
.TITLE_SIZE_LIMIT
/ 2 - 2:]
112 # The item we were on might be gone entirely
114 # try stay at the same spot in the menu
115 if oldpos
>= len(self
.items
):
116 self
.menupos
= len(self
.items
) - 1
118 self
.menupos
= oldpos
120 # find the size for the popup
123 for w
in self
.menuwidgets
:
125 if size
.width() > width
: width
= size
.width()
126 height
+= size
.height()
128 # show or hide the list and its child widgets
129 if len(self
.items
) > 1:
130 size
= self
.screeninfo
.size()
131 self
.widget
.moveresize(otk
.Rect((size
.width() - width
) / 2,
132 (size
.height() - height
) / 2,
134 if self
.SHOW_POPUP
: self
.widget
.show(1)
136 def activateTarget(self
, final
):
137 """Activates (focuses and, if the user requested it, raises a window).
138 If final is true, then this is the very last window we're activating
139 and the user has finished cycling.
143 def setDataInfo(self
, data
):
144 """Retrieve and/or calculate information when we start cycling,
145 preferably caching it. Data is what's given to callback functions.
147 self
.screen
= ob
.openbox
.screen(data
.screen
)
148 self
.screeninfo
= otk
.display
.screenInfo(data
.screen
)
150 def chooseStartPos(self
):
151 """Set self.menupos to a number between 0 and len(self.items) - 1.
152 By default the initial menupos is 0, but this can be used to change
153 it to some other position."""
156 def cycle(self
, data
, forward
):
157 """Does the actual job of cycling through windows. data is a callback
158 parameter, while forward is a boolean indicating whether the
159 cycling goes forwards (true) or backwards (false).
165 ob
.kgrab(data
.screen
, self
.grabfunc
)
166 # the pointer grab causes pointer events during the keyboard grab
167 # to go away, which means we don't get enter notifies when the
168 # popup disappears, screwing up the focus
169 ob
.mgrab(data
.screen
)
172 self
.state
= data
.state
175 self
.setDataInfo(data
)
178 self
.items
= [] # so it doesnt try start partway through the list
181 self
.chooseStartPos()
182 self
.initpos
= self
.menupos
186 if not self
.items
: return # don't bother doing anything
188 self
.menuwidgets
[self
.menupos
].setHighlighted(0)
190 if initial
and not self
.START_WITH_NEXT
:
198 if self
.menupos
< 0: self
.menupos
= len(self
.items
) - 1
199 elif self
.menupos
>= len(self
.items
): self
.menupos
= 0
200 self
.menuwidgets
[self
.menupos
].setHighlighted(1)
201 if self
.ACTIVATE_WHILE_CYCLING
:
202 self
.activateTarget(0) # activate, but dont deiconify/unshade/raise
204 def grabfunc(self
, data
):
205 """A callback method that grabs away all keystrokes so that navigating
206 the cycling menu is possible."""
209 # have all the modifiers this started with been released?
210 if not self
.state
& data
.state
:
212 elif data
.action
== ob
.KeyAction
.Press
:
213 # has Escape been pressed?
214 if data
.key
== "Escape":
218 self
.menupos
= self
.initpos
219 # has Enter been pressed?
220 elif data
.key
== "Return":
224 # activate, and deiconify/unshade/raise
225 self
.activateTarget(notreverting
)
231 def next(self
, data
):
232 """Focus the next window."""
234 raise RuntimeError("next must be bound to a key" +
235 "combination with at least one modifier")
238 def previous(self
, data
):
239 """Focus the previous window."""
241 raise RuntimeError("previous must be bound to a key" +
242 "combination with at least one modifier")
245 #---------------------- Window Cycling --------------------
247 class _CycleWindows(_Cycle
):
249 This is a basic cycling class for Windows.
251 An example of inheriting from and modifying this class is _ClassCycleWindows,
252 which allows users to cycle around windows of a certain application
255 This class has an underscored name because I use the singleton pattern
256 (so CycleWindows is an actual instance of this class). This doesn't have
257 to be followed, but if it isn't followed then the user will have to create
258 their own instances of your class and use that (not always a bad thing).
260 An example of using the CycleWindows singleton:
262 from cycle import CycleWindows
263 CycleWindows.INCLUDE_ICONS = 0 # I don't like cycling to icons
264 ob.kbind(["A-Tab"], ob.KeyContext.All, CycleWindows.next)
265 ob.kbind(["A-S-Tab"], ob.KeyContext.All, CycleWindows.previous)
268 """If this is non-zero then windows from all desktops will be included in
269 the stacking list."""
270 INCLUDE_ALL_DESKTOPS
= 0
272 """If this is non-zero then windows which are iconified on the current
273 desktop will be included in the stacking list."""
276 """If this is non-zero then windows which are iconified from all desktops
277 will be included in the stacking list."""
278 INCLUDE_ICONS_ALL_DESKTOPS
= 1
280 """If this is non-zero then windows which are on all-desktops at once will
282 INCLUDE_OMNIPRESENT
= 1
284 """A better default for window cycling than generic cycling."""
285 ACTIVATE_WHILE_CYCLING
= 1
287 """When cycling focus, raise the window chosen as well as focusing it."""
291 _Cycle
.__init
__(self
)
294 if self
.cycling
: self
.populateLists()
295 def closewindow(data
):
296 if self
.cycling
: self
.populateLists()
298 ob
.ebind(ob
.EventAction
.NewWindow
, newwindow
)
299 ob
.ebind(ob
.EventAction
.CloseWindow
, closewindow
)
301 def shouldAdd(self
, client
):
302 """Determines if a client should be added to the cycling list."""
303 curdesk
= self
.screen
.desktop()
304 desk
= client
.desktop()
306 if not client
.normal(): return 0
307 if not (client
.canFocus() or client
.focusNotify()): return 0
308 if focus
.AVOID_SKIP_TASKBAR
and client
.skipTaskbar(): return 0
311 if self
.INCLUDE_ICONS
:
312 if self
.INCLUDE_ICONS_ALL_DESKTOPS
: return 1
313 if desk
== curdesk
: return 1
315 if self
.INCLUDE_OMNIPRESENT
and desk
== 0xffffffff: return 1
316 if self
.INCLUDE_ALL_DESKTOPS
: return 1
317 if desk
== curdesk
: return 1
321 def populateItems(self
):
322 # get the list of clients, keeping iconic windows at the bottom
324 for c
in focus
._clients
:
325 if self
.shouldAdd(c
):
326 if c
.iconic(): iconic_clients
.append(c
)
327 else: self
.items
.append(c
)
328 self
.items
.extend(iconic_clients
)
330 def menuLabel(self
, client
):
331 if client
.iconic(): t
= '[' + client
.iconTitle() + ']'
332 else: t
= client
.title()
334 if self
.INCLUDE_ALL_DESKTOPS
:
336 if d
== 0xffffffff: d
= self
.screen
.desktop()
337 t
= self
.screen
.desktopName(d
) + " - " + t
341 def itemEqual(self
, client1
, client2
):
342 return client1
.window() == client2
.window()
344 def activateTarget(self
, final
):
345 """Activates (focuses and, if the user requested it, raises a window).
346 If final is true, then this is the very last window we're activating
347 and the user has finished cycling."""
349 client
= self
.items
[self
.menupos
]
350 except IndexError: return # empty list
352 # move the to client's desktop if required
353 if not (client
.iconic() or client
.desktop() == 0xffffffff or \
354 client
.desktop() == self
.screen
.desktop()):
355 root
= self
.screeninfo
.rootWindow()
356 ob
.send_client_msg(root
, otk
.atoms
.net_current_desktop
,
357 root
, client
.desktop())
359 # send a net_active_window message for the target
360 if final
or not client
.iconic():
361 if final
: r
= self
.RAISE_WINDOW
363 ob
.send_client_msg(self
.screeninfo
.rootWindow(),
364 otk
.atoms
.openbox_active_window
,
365 client
.window(), final
, r
)
370 CycleWindows
= _CycleWindows()
372 #---------------------- Window Cycling --------------------
374 class _CycleWindowsLinear(_CycleWindows
):
376 This class is an example of how to inherit from and make use of the
377 _CycleWindows class. This class also uses the singleton pattern.
379 An example of using the CycleWindowsLinear singleton:
381 from cycle import CycleWindowsLinear
382 CycleWindows.ALL_DESKTOPS = 1 # I want all my windows in the list
383 ob.kbind(["A-Tab"], ob.KeyContext.All, CycleWindowsLinear.next)
384 ob.kbind(["A-S-Tab"], ob.KeyContext.All, CycleWindowsLinear.previous)
387 """When cycling focus, raise the window chosen as well as focusing it."""
390 """If this is true, a popup window will be displayed with the options
395 _CycleWindows
.__init
__(self
)
397 def shouldAdd(self
, client
):
398 """Determines if a client should be added to the cycling list."""
399 curdesk
= self
.screen
.desktop()
400 desk
= client
.desktop()
402 if not client
.normal(): return 0
403 if not (client
.canFocus() or client
.focusNotify()): return 0
404 if focus
.AVOID_SKIP_TASKBAR
and client
.skipTaskbar(): return 0
406 if client
.iconic(): return 0
407 if self
.INCLUDE_OMNIPRESENT
and desk
== 0xffffffff: return 1
408 if self
.INCLUDE_ALL_DESKTOPS
: return 1
409 if desk
== curdesk
: return 1
413 def populateItems(self
):
414 # get the list of clients, keeping iconic windows at the bottom
416 for i
in range(self
.screen
.clientCount()):
417 c
= self
.screen
.client(i
)
418 if self
.shouldAdd(c
):
421 def chooseStartPos(self
):
423 t
= focus
._clients
[0]
424 for i
,c
in zip(range(len(self
.items
)), self
.items
):
425 if self
.itemEqual(c
, t
):
429 def menuLabel(self
, client
):
432 if self
.INCLUDE_ALL_DESKTOPS
:
434 if d
== 0xffffffff: d
= self
.screen
.desktop()
435 t
= self
.screen
.desktopName(d
) + " - " + t
440 CycleWindowsLinear
= _CycleWindowsLinear()
442 #----------------------- Desktop Cycling ------------------
443 class _CycleDesktops(_Cycle
):
447 from cycle import CycleDesktops
448 ob.kbind(["W-d"], ob.KeyContext.All, CycleDesktops.next)
449 ob.kbind(["W-S-d"], ob.KeyContext.All, CycleDesktops.previous)
452 def __init__(self
, name
, index
):
455 def __eq__(self
, other
):
456 return other
.index
== self
.index
461 _Cycle
.__init
__(self
)
463 def populateItems(self
):
464 for i
in range(self
.screen
.numDesktops()):
466 _CycleDesktops
.Desktop(self
.screen
.desktopName(i
), i
))
468 def menuLabel(self
, desktop
):
471 def chooseStartPos(self
):
472 self
.menupos
= self
.screen
.desktop()
474 def activateTarget(self
, final
):
475 # TODO: refactor this bit
477 desktop
= self
.items
[self
.menupos
]
478 except IndexError: return
480 root
= self
.screeninfo
.rootWindow()
481 ob
.send_client_msg(root
, otk
.atoms
.net_current_desktop
,
484 CycleDesktops
= _CycleDesktops()
486 print "Loaded cycle.py"