1 /* -*- indent-tabs-mode: nil; tab-width: 4; c-basic-offset: 4; -*-
3 focus.c for the Openbox window manager
4 Copyright (c) 2006 Mikael Magnusson
5 Copyright (c) 2003-2007 Dana Jansens
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 See the COPYING file for a copy of the GNU General Public License.
24 #include "framerender.h"
34 #include "render/render.h"
40 #define FOCUS_INDICATOR_WIDTH 6
42 ObClient
*focus_client
= NULL
;
43 GList
*focus_order
= NULL
;
44 ObClient
*focus_cycle_target
= NULL
;
46 /*! This variable is used for focus fallback. If we fallback to a window, we
47 set this to the window. And when focus goes somewhere after that, it will
48 be set to NULL. If between falling back to that window and something
49 getting focused, the window gets unmanaged, then if there are no incoming
50 FocusIn events, we fallback again because focus has just gotten itself lost.
52 static ObClient
*focus_tried
= NULL
;
58 InternalWindow bottom
;
61 RrAppearance
*a_focus_indicator
;
64 static ObIconPopup
*focus_cycle_popup
;
66 static gboolean
valid_focus_target(ObClient
*ft
,
67 gboolean all_desktops
,
68 gboolean dock_windows
,
69 gboolean desktop_windows
);
70 static void focus_cycle_destructor(ObClient
*client
, gpointer data
);
71 static void focus_tried_destructor(ObClient
*client
, gpointer data
);
73 static Window
createWindow(Window parent
, gulong mask
,
74 XSetWindowAttributes
*attrib
)
76 return XCreateWindow(ob_display
, parent
, 0, 0, 1, 1, 0,
77 RrDepth(ob_rr_inst
), InputOutput
,
78 RrVisual(ob_rr_inst
), mask
, attrib
);
82 void focus_startup(gboolean reconfig
)
84 focus_cycle_popup
= icon_popup_new(TRUE
);
87 XSetWindowAttributes attr
;
89 client_add_destructor(focus_cycle_destructor
, NULL
);
90 client_add_destructor(focus_tried_destructor
, NULL
);
92 /* start with nothing focused */
95 focus_indicator
.top
.obwin
.type
= Window_Internal
;
96 focus_indicator
.left
.obwin
.type
= Window_Internal
;
97 focus_indicator
.right
.obwin
.type
= Window_Internal
;
98 focus_indicator
.bottom
.obwin
.type
= Window_Internal
;
100 attr
.override_redirect
= True
;
101 attr
.background_pixel
= BlackPixel(ob_display
, ob_screen
);
102 focus_indicator
.top
.win
=
103 createWindow(RootWindow(ob_display
, ob_screen
),
104 CWOverrideRedirect
| CWBackPixel
, &attr
);
105 focus_indicator
.left
.win
=
106 createWindow(RootWindow(ob_display
, ob_screen
),
107 CWOverrideRedirect
| CWBackPixel
, &attr
);
108 focus_indicator
.right
.win
=
109 createWindow(RootWindow(ob_display
, ob_screen
),
110 CWOverrideRedirect
| CWBackPixel
, &attr
);
111 focus_indicator
.bottom
.win
=
112 createWindow(RootWindow(ob_display
, ob_screen
),
113 CWOverrideRedirect
| CWBackPixel
, &attr
);
115 stacking_add(INTERNAL_AS_WINDOW(&focus_indicator
.top
));
116 stacking_add(INTERNAL_AS_WINDOW(&focus_indicator
.left
));
117 stacking_add(INTERNAL_AS_WINDOW(&focus_indicator
.right
));
118 stacking_add(INTERNAL_AS_WINDOW(&focus_indicator
.bottom
));
120 color_white
= RrColorNew(ob_rr_inst
, 0xff, 0xff, 0xff);
122 a_focus_indicator
= RrAppearanceNew(ob_rr_inst
, 4);
123 a_focus_indicator
->surface
.grad
= RR_SURFACE_SOLID
;
124 a_focus_indicator
->surface
.relief
= RR_RELIEF_FLAT
;
125 a_focus_indicator
->surface
.primary
= RrColorNew(ob_rr_inst
,
127 a_focus_indicator
->texture
[0].type
= RR_TEXTURE_LINE_ART
;
128 a_focus_indicator
->texture
[0].data
.lineart
.color
= color_white
;
129 a_focus_indicator
->texture
[1].type
= RR_TEXTURE_LINE_ART
;
130 a_focus_indicator
->texture
[1].data
.lineart
.color
= color_white
;
131 a_focus_indicator
->texture
[2].type
= RR_TEXTURE_LINE_ART
;
132 a_focus_indicator
->texture
[2].data
.lineart
.color
= color_white
;
133 a_focus_indicator
->texture
[3].type
= RR_TEXTURE_LINE_ART
;
134 a_focus_indicator
->texture
[3].data
.lineart
.color
= color_white
;
138 void focus_shutdown(gboolean reconfig
)
140 icon_popup_free(focus_cycle_popup
);
143 client_remove_destructor(focus_cycle_destructor
);
144 client_remove_destructor(focus_tried_destructor
);
146 /* reset focus to root */
147 XSetInputFocus(ob_display
, PointerRoot
, RevertToNone
, CurrentTime
);
149 RrColorFree(color_white
);
151 RrAppearanceFree(a_focus_indicator
);
153 XDestroyWindow(ob_display
, focus_indicator
.top
.win
);
154 XDestroyWindow(ob_display
, focus_indicator
.left
.win
);
155 XDestroyWindow(ob_display
, focus_indicator
.right
.win
);
156 XDestroyWindow(ob_display
, focus_indicator
.bottom
.win
);
160 static void push_to_top(ObClient
*client
)
162 focus_order
= g_list_remove(focus_order
, client
);
163 focus_order
= g_list_prepend(focus_order
, client
);
166 void focus_set_client(ObClient
*client
)
170 ob_debug_type(OB_DEBUG_FOCUS
,
171 "focus_set_client 0x%lx\n", client
? client
->window
: 0);
173 /* uninstall the old colormap, and install the new one */
174 screen_install_colormap(focus_client
, FALSE
);
175 screen_install_colormap(client
, TRUE
);
177 /* in the middle of cycling..? kill it. CurrentTime is fine, time won't
180 if (focus_cycle_target
)
181 focus_cycle(TRUE
, TRUE
, TRUE
, TRUE
, TRUE
, TRUE
, TRUE
, TRUE
, TRUE
);
183 focus_client
= client
;
185 if (client
!= NULL
) {
186 /* move to the top of the list */
188 /* remove hiliting from the window when it gets focused */
189 client_hilite(client
, FALSE
);
192 /* set the NET_ACTIVE_WINDOW hint, but preserve it on shutdown */
193 if (ob_state() != OB_STATE_EXITING
) {
194 active
= client
? client
->window
: None
;
195 PROP_SET32(RootWindow(ob_display
, ob_screen
),
196 net_active_window
, window
, active
);
200 focus_tried
= NULL
; /* focus isn't "trying" to go anywhere now */
203 static ObClient
* focus_fallback_target(gboolean allow_refocus
, ObClient
*old
)
206 ObClient
*target
= NULL
;
207 ObClient
*desktop
= NULL
;
209 ob_debug_type(OB_DEBUG_FOCUS
, "trying pointer stuff\n");
210 if (config_focus_follow
&& !config_focus_last
)
212 if ((target
= client_under_pointer()))
213 if (allow_refocus
|| target
!= old
)
214 if (client_normal(target
) && client_can_focus(target
)) {
215 ob_debug_type(OB_DEBUG_FOCUS
, "found in pointer stuff\n");
221 /* try for group relations */
225 for (it
= focus_order
[screen_desktop
]; it
; it
= g_list_next(it
))
226 for (sit
= old
->group
->members
; sit
; sit
= g_slist_next(sit
))
227 if (sit
->data
== it
->data
)
228 if (sit
->data
!= old
&& client_normal(sit
->data
))
229 if (client_can_focus(sit
->data
))
234 ob_debug_type(OB_DEBUG_FOCUS
, "trying omnipresentness\n");
235 if (allow_refocus
&& old
&& old
->desktop
== DESKTOP_ALL
&&
242 ob_debug_type(OB_DEBUG_FOCUS
, "trying the focus order\n");
243 for (it
= focus_order
; it
; it
= g_list_next(it
))
244 if (allow_refocus
|| it
->data
!= old
) {
245 ObClient
*c
= it
->data
;
246 /* fallback focus to a window if:
247 1. it is actually focusable, cuz if it's not then we're sending
248 focus off to nothing. this includes if it is visible right now
249 2. it is on the current desktop. this ignores omnipresent
250 windows, which are problematic in their own rite.
251 3. it is a normal type window, don't fall back onto a dock or
252 a splashscreen or a desktop window (save the desktop as a
253 backup fallback though)
255 if (client_can_focus(c
))
257 if (c
->desktop
== screen_desktop
&& client_normal(c
)) {
258 ob_debug_type(OB_DEBUG_FOCUS
, "found in focus order\n");
260 } else if (c
->type
== OB_CLIENT_TYPE_DESKTOP
&&
266 /* as a last resort fallback to the desktop window if there is one.
267 (if there's more than one, then the one most recently focused.)
269 ob_debug_type(OB_DEBUG_FOCUS
, "found desktop: \n", !!desktop
);
273 ObClient
* focus_fallback(gboolean allow_refocus
)
279 new = focus_fallback_target(allow_refocus
, focus_client
);
281 /* send focus somewhere if it is moving or if it was NULL before,
282 in which case it may not even be on the screen */
283 if (!old
|| new != old
) {
284 /* unfocus any focused clients.. they can be focused by Pointer events
285 and such, and then when we try focus them, we won't get a FocusIn
286 event at all for them. */
291 /* remember that we tried to send focus here */
301 /* Install our own colormap */
302 if (focus_client
!= NULL
) {
303 screen_install_colormap(focus_client
, FALSE
);
304 screen_install_colormap(NULL
, TRUE
);
308 focus_tried
= NULL
; /* focus isn't "trying" to go anywhere now */
310 /* when nothing will be focused, send focus to the backup target */
311 XSetInputFocus(ob_display
, screen_support_win
, RevertToPointerRoot
,
315 static gchar
*popup_get_name(ObClient
*c
, ObClient
**nametarget
)
319 const gchar
*desk
= NULL
;
322 /* find our highest direct parent, including non-normal windows */
323 for (p
= c
; p
->transient_for
&& p
->transient_for
!= OB_TRAN_GROUP
;
324 p
= p
->transient_for
);
326 if (c
->desktop
!= DESKTOP_ALL
&& c
->desktop
!= screen_desktop
)
327 desk
= screen_desktop_names
[c
->desktop
];
329 /* use the transient's parent's title/icon if we don't have one */
330 if (p
!= c
&& !strcmp("", (c
->iconic
? c
->icon_title
: c
->title
)))
331 title
= g_strdup(p
->iconic
? p
->icon_title
: p
->title
);
334 title
= g_strdup(c
->iconic
? c
->icon_title
: c
->title
);
337 ret
= g_strdup_printf("%s [%s]", title
, desk
);
344 /* set this only if we're returning true and they asked for it */
345 if (ret
&& nametarget
) *nametarget
= p
;
349 static void popup_cycle(ObClient
*c
, gboolean show
,
350 gboolean all_desktops
, gboolean dock_windows
,
351 gboolean desktop_windows
)
353 gchar
*showtext
= NULL
;
354 ObClient
*showtarget
;
357 icon_popup_hide(focus_cycle_popup
);
361 /* do this stuff only when the dialog is first showing */
362 if (!focus_cycle_popup
->popup
->mapped
&&
363 !focus_cycle_popup
->popup
->delay_mapped
)
367 GList
*targets
= NULL
, *it
;
370 /* position the popup */
371 a
= screen_physical_area_monitor(0);
372 icon_popup_position(focus_cycle_popup
, CenterGravity
,
373 a
->x
+ a
->width
/ 2, a
->y
+ a
->height
/ 2);
374 icon_popup_height(focus_cycle_popup
, POPUP_HEIGHT
);
375 icon_popup_min_width(focus_cycle_popup
, POPUP_WIDTH
);
376 icon_popup_max_width(focus_cycle_popup
,
377 MAX(a
->width
/3, POPUP_WIDTH
));
380 /* make its width to be the width of all the possible titles */
382 /* build a list of all the valid focus targets */
383 for (it
= focus_order
; it
; it
= g_list_next(it
)) {
384 ObClient
*ft
= it
->data
;
385 if (valid_focus_target(ft
, all_desktops
, dock_windows
388 targets
= g_list_prepend(targets
, ft
);
392 /* make it null terminated so we can use g_strfreev */
393 names
= g_new(char*, n
+1);
394 for (it
= targets
, i
= 0; it
; it
= g_list_next(it
), ++i
) {
395 ObClient
*ft
= it
->data
, *t
;
396 names
[i
] = popup_get_name(ft
, &t
);
398 /* little optimization.. save this text and client, so we dont
399 have to get it again */
401 showtext
= g_strdup(names
[i
]);
407 icon_popup_text_width_to_strings(focus_cycle_popup
, names
, n
);
412 if (!showtext
) showtext
= popup_get_name(c
, &showtarget
);
413 icon_popup_show(focus_cycle_popup
, showtext
,
414 client_icon(showtarget
, 48, 48));
418 static void focus_cycle_destructor(ObClient
*client
, gpointer data
)
420 /* end cycling if the target disappears. CurrentTime is fine, time won't
423 if (focus_cycle_target
== client
)
424 focus_cycle(TRUE
, TRUE
, TRUE
, TRUE
, TRUE
, TRUE
, TRUE
, TRUE
, TRUE
);
427 void focus_cycle_draw_indicator()
429 if (!focus_cycle_target
) {
430 XUnmapWindow(ob_display
, focus_indicator
.top
.win
);
431 XUnmapWindow(ob_display
, focus_indicator
.left
.win
);
432 XUnmapWindow(ob_display
, focus_indicator
.right
.win
);
433 XUnmapWindow(ob_display
, focus_indicator
.bottom
.win
);
435 /* kill enter events cause by this unmapping */
436 event_ignore_queued_enters();
439 if (focus_cycle_target)
440 frame_adjust_focus(focus_cycle_target->frame, FALSE);
441 frame_adjust_focus(focus_cycle_target->frame, TRUE);
446 wt
= wl
= wr
= wb
= FOCUS_INDICATOR_WIDTH
;
448 x
= focus_cycle_target
->frame
->area
.x
;
449 y
= focus_cycle_target
->frame
->area
.y
;
450 w
= focus_cycle_target
->frame
->area
.width
;
453 XMoveResizeWindow(ob_display
, focus_indicator
.top
.win
,
455 a_focus_indicator
->texture
[0].data
.lineart
.x1
= 0;
456 a_focus_indicator
->texture
[0].data
.lineart
.y1
= h
-1;
457 a_focus_indicator
->texture
[0].data
.lineart
.x2
= 0;
458 a_focus_indicator
->texture
[0].data
.lineart
.y2
= 0;
459 a_focus_indicator
->texture
[1].data
.lineart
.x1
= 0;
460 a_focus_indicator
->texture
[1].data
.lineart
.y1
= 0;
461 a_focus_indicator
->texture
[1].data
.lineart
.x2
= w
-1;
462 a_focus_indicator
->texture
[1].data
.lineart
.y2
= 0;
463 a_focus_indicator
->texture
[2].data
.lineart
.x1
= w
-1;
464 a_focus_indicator
->texture
[2].data
.lineart
.y1
= 0;
465 a_focus_indicator
->texture
[2].data
.lineart
.x2
= w
-1;
466 a_focus_indicator
->texture
[2].data
.lineart
.y2
= h
-1;
467 a_focus_indicator
->texture
[3].data
.lineart
.x1
= (wl
-1);
468 a_focus_indicator
->texture
[3].data
.lineart
.y1
= h
-1;
469 a_focus_indicator
->texture
[3].data
.lineart
.x2
= w
- wr
;
470 a_focus_indicator
->texture
[3].data
.lineart
.y2
= h
-1;
471 RrPaint(a_focus_indicator
, focus_indicator
.top
.win
,
474 x
= focus_cycle_target
->frame
->area
.x
;
475 y
= focus_cycle_target
->frame
->area
.y
;
477 h
= focus_cycle_target
->frame
->area
.height
;
479 XMoveResizeWindow(ob_display
, focus_indicator
.left
.win
,
481 a_focus_indicator
->texture
[0].data
.lineart
.x1
= w
-1;
482 a_focus_indicator
->texture
[0].data
.lineart
.y1
= 0;
483 a_focus_indicator
->texture
[0].data
.lineart
.x2
= 0;
484 a_focus_indicator
->texture
[0].data
.lineart
.y2
= 0;
485 a_focus_indicator
->texture
[1].data
.lineart
.x1
= 0;
486 a_focus_indicator
->texture
[1].data
.lineart
.y1
= 0;
487 a_focus_indicator
->texture
[1].data
.lineart
.x2
= 0;
488 a_focus_indicator
->texture
[1].data
.lineart
.y2
= h
-1;
489 a_focus_indicator
->texture
[2].data
.lineart
.x1
= 0;
490 a_focus_indicator
->texture
[2].data
.lineart
.y1
= h
-1;
491 a_focus_indicator
->texture
[2].data
.lineart
.x2
= w
-1;
492 a_focus_indicator
->texture
[2].data
.lineart
.y2
= h
-1;
493 a_focus_indicator
->texture
[3].data
.lineart
.x1
= w
-1;
494 a_focus_indicator
->texture
[3].data
.lineart
.y1
= wt
-1;
495 a_focus_indicator
->texture
[3].data
.lineart
.x2
= w
-1;
496 a_focus_indicator
->texture
[3].data
.lineart
.y2
= h
- wb
;
497 RrPaint(a_focus_indicator
, focus_indicator
.left
.win
,
500 x
= focus_cycle_target
->frame
->area
.x
+
501 focus_cycle_target
->frame
->area
.width
- wr
;
502 y
= focus_cycle_target
->frame
->area
.y
;
504 h
= focus_cycle_target
->frame
->area
.height
;
506 XMoveResizeWindow(ob_display
, focus_indicator
.right
.win
,
508 a_focus_indicator
->texture
[0].data
.lineart
.x1
= 0;
509 a_focus_indicator
->texture
[0].data
.lineart
.y1
= 0;
510 a_focus_indicator
->texture
[0].data
.lineart
.x2
= w
-1;
511 a_focus_indicator
->texture
[0].data
.lineart
.y2
= 0;
512 a_focus_indicator
->texture
[1].data
.lineart
.x1
= w
-1;
513 a_focus_indicator
->texture
[1].data
.lineart
.y1
= 0;
514 a_focus_indicator
->texture
[1].data
.lineart
.x2
= w
-1;
515 a_focus_indicator
->texture
[1].data
.lineart
.y2
= h
-1;
516 a_focus_indicator
->texture
[2].data
.lineart
.x1
= w
-1;
517 a_focus_indicator
->texture
[2].data
.lineart
.y1
= h
-1;
518 a_focus_indicator
->texture
[2].data
.lineart
.x2
= 0;
519 a_focus_indicator
->texture
[2].data
.lineart
.y2
= h
-1;
520 a_focus_indicator
->texture
[3].data
.lineart
.x1
= 0;
521 a_focus_indicator
->texture
[3].data
.lineart
.y1
= wt
-1;
522 a_focus_indicator
->texture
[3].data
.lineart
.x2
= 0;
523 a_focus_indicator
->texture
[3].data
.lineart
.y2
= h
- wb
;
524 RrPaint(a_focus_indicator
, focus_indicator
.right
.win
,
527 x
= focus_cycle_target
->frame
->area
.x
;
528 y
= focus_cycle_target
->frame
->area
.y
+
529 focus_cycle_target
->frame
->area
.height
- wb
;
530 w
= focus_cycle_target
->frame
->area
.width
;
533 XMoveResizeWindow(ob_display
, focus_indicator
.bottom
.win
,
535 a_focus_indicator
->texture
[0].data
.lineart
.x1
= 0;
536 a_focus_indicator
->texture
[0].data
.lineart
.y1
= 0;
537 a_focus_indicator
->texture
[0].data
.lineart
.x2
= 0;
538 a_focus_indicator
->texture
[0].data
.lineart
.y2
= h
-1;
539 a_focus_indicator
->texture
[1].data
.lineart
.x1
= 0;
540 a_focus_indicator
->texture
[1].data
.lineart
.y1
= h
-1;
541 a_focus_indicator
->texture
[1].data
.lineart
.x2
= w
-1;
542 a_focus_indicator
->texture
[1].data
.lineart
.y2
= h
-1;
543 a_focus_indicator
->texture
[2].data
.lineart
.x1
= w
-1;
544 a_focus_indicator
->texture
[2].data
.lineart
.y1
= h
-1;
545 a_focus_indicator
->texture
[2].data
.lineart
.x2
= w
-1;
546 a_focus_indicator
->texture
[2].data
.lineart
.y2
= 0;
547 a_focus_indicator
->texture
[3].data
.lineart
.x1
= wl
-1;
548 a_focus_indicator
->texture
[3].data
.lineart
.y1
= 0;
549 a_focus_indicator
->texture
[3].data
.lineart
.x2
= w
- wr
;
550 a_focus_indicator
->texture
[3].data
.lineart
.y2
= 0;
551 RrPaint(a_focus_indicator
, focus_indicator
.bottom
.win
,
554 XMapWindow(ob_display
, focus_indicator
.top
.win
);
555 XMapWindow(ob_display
, focus_indicator
.left
.win
);
556 XMapWindow(ob_display
, focus_indicator
.right
.win
);
557 XMapWindow(ob_display
, focus_indicator
.bottom
.win
);
561 static gboolean
has_valid_group_siblings_on_desktop(ObClient
*ft
,
562 gboolean all_desktops
)
567 if (!ft
->group
) return FALSE
;
569 for (it
= ft
->group
->members
; it
; it
= g_slist_next(it
)) {
570 ObClient
*c
= it
->data
;
571 /* check that it's not a helper window to avoid infinite recursion */
572 if (c
!= ft
&& !client_helper(c
) &&
573 valid_focus_target(c
, all_desktops
, FALSE
, FALSE
))
581 /*! @param allow_helpers This is used for calling itself recursively while
582 checking helper windows. */
583 static gboolean
valid_focus_target(ObClient
*ft
,
584 gboolean all_desktops
,
585 gboolean dock_windows
,
586 gboolean desktop_windows
)
590 /* it's on this desktop unless you want all desktops.
592 do this check first because it will usually filter out the most
594 ok
= (all_desktops
|| ft
->desktop
== screen_desktop
||
595 ft
->desktop
== DESKTOP_ALL
);
597 /* the window can receive focus somehow */
598 ok
= ok
&& (ft
->can_focus
|| ft
->focus_notify
);
600 /* it's the right type of window */
601 if (dock_windows
|| desktop_windows
)
602 ok
= ok
&& ((dock_windows
&& ft
->type
== OB_CLIENT_TYPE_DOCK
) ||
603 (desktop_windows
&& ft
->type
== OB_CLIENT_TYPE_DESKTOP
));
605 /* normal non-helper windows are valid targets */
607 ((client_normal(ft
) && !client_helper(ft
))
609 /* helper windows are valid targets it... */
610 (client_helper(ft
) &&
611 /* ...a window in its group already has focus ... */
612 ((focus_client
&& ft
->group
== focus_client
->group
) ||
613 /* ... or if there are no other windows in its group
614 that can be cycled to instead */
615 !has_valid_group_siblings_on_desktop(ft
, all_desktops
))));
617 /* it's not set to skip the taskbar (unless it is a type that would be
618 expected to set this hint */
619 ok
= ok
&& ((ft
->type
== OB_CLIENT_TYPE_DOCK
||
620 ft
->type
== OB_CLIENT_TYPE_DESKTOP
||
621 ft
->type
== OB_CLIENT_TYPE_TOOLBAR
||
622 ft
->type
== OB_CLIENT_TYPE_MENU
||
623 ft
->type
== OB_CLIENT_TYPE_UTILITY
) ||
626 /* it's not going to just send fous off somewhere else (modal window) */
627 ok
= ok
&& ft
== client_focus_target(ft
);
632 void focus_cycle(gboolean forward
, gboolean all_desktops
,
633 gboolean dock_windows
, gboolean desktop_windows
,
634 gboolean linear
, gboolean interactive
,
635 gboolean dialog
, gboolean done
, gboolean cancel
)
637 static ObClient
*first
= NULL
;
638 static ObClient
*t
= NULL
;
639 static GList
*order
= NULL
;
640 GList
*it
, *start
, *list
;
645 focus_cycle_target
= NULL
;
653 if (!first
) first
= focus_client
;
655 if (linear
) list
= client_list
;
656 else list
= focus_order
;
662 if (!focus_cycle_target
) focus_cycle_target
= focus_client
;
664 start
= it
= g_list_find(list
, focus_cycle_target
);
665 if (!start
) /* switched desktops or something? */
666 start
= it
= forward
? g_list_last(list
) : g_list_first(list
);
667 if (!start
) goto done_cycle
;
672 if (it
== NULL
) it
= g_list_first(list
);
675 if (it
== NULL
) it
= g_list_last(list
);
678 if (valid_focus_target(ft
, all_desktops
, dock_windows
,
682 if (ft
!= focus_cycle_target
) { /* prevents flicker */
683 focus_cycle_target
= ft
;
684 focus_cycle_draw_indicator();
686 /* same arguments as valid_focus_target */
687 popup_cycle(ft
, dialog
, all_desktops
, dock_windows
,
690 } else if (ft
!= focus_cycle_target
) {
691 focus_cycle_target
= ft
;
696 } while (it
!= start
);
699 if (done
&& focus_cycle_target
)
700 client_activate(focus_cycle_target
, FALSE
, TRUE
);
704 focus_cycle_target
= NULL
;
709 focus_cycle_draw_indicator();
710 popup_cycle(ft
, FALSE
, FALSE
, FALSE
, FALSE
);
716 /* this be mostly ripped from fvwm */
717 static ObClient
*focus_find_directional(ObClient
*c
, ObDirection dir
,
718 gboolean dock_windows
,
719 gboolean desktop_windows
)
721 gint my_cx
, my_cy
, his_cx
, his_cy
;
724 gint score
, best_score
;
725 ObClient
*best_client
, *cur
;
731 /* first, find the centre coords of the currently focused window */
732 my_cx
= c
->frame
->area
.x
+ c
->frame
->area
.width
/ 2;
733 my_cy
= c
->frame
->area
.y
+ c
->frame
->area
.height
/ 2;
738 for(it
= g_list_first(client_list
); it
; it
= g_list_next(it
)) {
741 /* the currently selected window isn't interesting */
744 if (!dock_windows
&& !desktop_windows
&& !client_normal(cur
))
746 if (!(dock_windows
&& cur
->type
== OB_CLIENT_TYPE_DOCK
) ||
747 (desktop_windows
&& cur
->type
== OB_CLIENT_TYPE_DESKTOP
))
749 /* using c->desktop instead of screen_desktop doesn't work if the
750 * current window was omnipresent, hope this doesn't have any other
752 if(screen_desktop
!= cur
->desktop
&& cur
->desktop
!= DESKTOP_ALL
)
756 if(!(client_focus_target(cur
) == cur
&&
757 client_can_focus(cur
)))
760 /* find the centre coords of this window, from the
761 * currently focused window's point of view */
762 his_cx
= (cur
->frame
->area
.x
- my_cx
)
763 + cur
->frame
->area
.width
/ 2;
764 his_cy
= (cur
->frame
->area
.y
- my_cy
)
765 + cur
->frame
->area
.height
/ 2;
767 if(dir
== OB_DIRECTION_NORTHEAST
|| dir
== OB_DIRECTION_SOUTHEAST
||
768 dir
== OB_DIRECTION_SOUTHWEST
|| dir
== OB_DIRECTION_NORTHWEST
) {
770 /* Rotate the diagonals 45 degrees counterclockwise.
771 * To do this, multiply the matrix /+h +h\ with the
772 * vector (x y). \-h +h/
773 * h = sqrt(0.5). We can set h := 1 since absolute
774 * distance doesn't matter here. */
775 tx
= his_cx
+ his_cy
;
776 his_cy
= -his_cx
+ his_cy
;
781 case OB_DIRECTION_NORTH
:
782 case OB_DIRECTION_SOUTH
:
783 case OB_DIRECTION_NORTHEAST
:
784 case OB_DIRECTION_SOUTHWEST
:
785 offset
= (his_cx
< 0) ? -his_cx
: his_cx
;
786 distance
= ((dir
== OB_DIRECTION_NORTH
||
787 dir
== OB_DIRECTION_NORTHEAST
) ?
790 case OB_DIRECTION_EAST
:
791 case OB_DIRECTION_WEST
:
792 case OB_DIRECTION_SOUTHEAST
:
793 case OB_DIRECTION_NORTHWEST
:
794 offset
= (his_cy
< 0) ? -his_cy
: his_cy
;
795 distance
= ((dir
== OB_DIRECTION_WEST
||
796 dir
== OB_DIRECTION_NORTHWEST
) ?
801 /* the target must be in the requested direction */
805 /* Calculate score for this window. The smaller the better. */
806 score
= distance
+ offset
;
808 /* windows more than 45 degrees off the direction are
809 * heavily penalized and will only be chosen if nothing
810 * else within a million pixels */
811 if(offset
> distance
)
814 if(best_score
== -1 || score
< best_score
)
822 void focus_directional_cycle(ObDirection dir
, gboolean dock_windows
,
823 gboolean desktop_windows
, gboolean interactive
,
824 gboolean dialog
, gboolean done
, gboolean cancel
)
826 static ObClient
*first
= NULL
;
833 focus_cycle_target
= NULL
;
841 if (!first
) first
= focus_client
;
842 if (!focus_cycle_target
) focus_cycle_target
= focus_client
;
844 if (focus_cycle_target
)
845 ft
= focus_find_directional(focus_cycle_target
, dir
, dock_windows
,
850 for (it
= focus_order
; it
; it
= g_list_next(it
))
851 if (valid_focus_target(it
->data
, FALSE
, dock_windows
,
857 if (ft
!= focus_cycle_target
) {/* prevents flicker */
858 focus_cycle_target
= ft
;
859 focus_cycle_draw_indicator();
862 if (focus_cycle_target
) {
863 /* same arguments as valid_focus_target */
864 popup_cycle(focus_cycle_target
, dialog
, FALSE
, dock_windows
,
872 if (done
&& focus_cycle_target
)
873 client_activate(focus_cycle_target
, FALSE
, TRUE
);
876 focus_cycle_target
= NULL
;
878 focus_cycle_draw_indicator();
879 popup_cycle(ft
, FALSE
, FALSE
, FALSE
, FALSE
);
884 void focus_order_add_new(ObClient
*c
)
887 focus_order_to_top(c
);
889 g_assert(!g_list_find(focus_order
, c
));
890 /* if there are any iconic windows, put this above them in the order,
891 but if there are not, then put it under the currently focused one */
892 if (focus_order
&& ((ObClient
*)focus_order
->data
)->iconic
)
893 focus_order
= g_list_insert(focus_order
, c
, 0);
895 focus_order
= g_list_insert(focus_order
, c
, 1);
899 void focus_order_remove(ObClient
*c
)
901 focus_order
= g_list_remove(focus_order
, c
);
904 void focus_order_to_top(ObClient
*c
)
906 focus_order
= g_list_remove(focus_order
, c
);
908 focus_order
= g_list_prepend(focus_order
, c
);
912 /* insert before first iconic window */
913 for (it
= focus_order
;
914 it
&& !((ObClient
*)it
->data
)->iconic
; it
= g_list_next(it
));
915 focus_order
= g_list_insert_before(focus_order
, it
, c
);
919 void focus_order_to_bottom(ObClient
*c
)
921 focus_order
= g_list_remove(focus_order
, c
);
923 focus_order
= g_list_append(focus_order
, c
);
927 /* insert before first iconic window */
928 for (it
= focus_order
;
929 it
&& !((ObClient
*)it
->data
)->iconic
; it
= g_list_next(it
));
930 focus_order
= g_list_insert_before(focus_order
, it
, c
);
934 ObClient
*focus_order_find_first(guint desktop
)
937 for (it
= focus_order
; it
; it
= g_list_next(it
)) {
938 ObClient
*c
= it
->data
;
939 if (c
->desktop
== desktop
|| c
->desktop
== DESKTOP_ALL
)
945 static void focus_tried_destructor(ObClient
*client
, gpointer data
)
949 if (client
== focus_tried
) {
950 /* we were trying to focus this window but it's gone */
954 ob_debug_type(OB_DEBUG_FOCUS
, "Tried to focus window 0x%x and it "
955 "is being unmanaged:\n");
956 if (XCheckIfEvent(ob_display
, &ce
, event_look_for_focusin_client
,NULL
))
958 XPutBackEvent(ob_display
, &ce
);
959 ob_debug_type(OB_DEBUG_FOCUS
, " but another FocusIn is coming\n");
961 ob_debug_type(OB_DEBUG_FOCUS
, " so falling back focus again.\n");
962 focus_fallback(TRUE
);