openbox/focus.c

   1 /* -*- indent-tabs-mode: nil; tab-width: 4; c-basic-offset: 4; -*-
   2
   3    focus.c for the Openbox window manager
   4    Copyright (c) 2006        Mikael Magnusson
   5    Copyright (c) 2003-2007   Dana Jansens
   6
   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.
  11
  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.
  16
  17    See the COPYING file for a copy of the GNU General Public License.
  18 */
  19
  20 #include "debug.h"
  21 #include "event.h"
  22 #include "openbox.h"
  23 #include "grab.h"
  24 #include "client.h"
  25 #include "config.h"
  26 #include "group.h"
  27 #include "focus_cycle.h"
  28 #include "screen.h"
  29 #include "keyboard.h"
  30 #include "focus.h"
  31 #include "stacking.h"
  32 #include "obt/prop.h"
  33
  34 #include <X11/Xlib.h>
  35 #include <glib.h>
  36
  37 #define FOCUS_INDICATOR_WIDTH 6
  38
  39 ObClient *focus_client = NULL;
  40 GList *focus_order = NULL;
  41
  42 void focus_startup(gboolean reconfig)
  43 {
  44     if (reconfig) return;
  45
  46     /* start with nothing focused */
  47     focus_nothing();
  48 }
  49
  50 void focus_shutdown(gboolean reconfig)
  51 {
  52     if (reconfig) return;
  53
  54     /* reset focus to root */
  55     XSetInputFocus(obt_display, PointerRoot, RevertToNone, CurrentTime);
  56 }
  57
  58 static void push_to_top(ObClient *client)
  59 {
  60     ObClient *p;
  61
  62     /* if it is modal for a single window, then put that window at the top
  63        of the focus order first, so it will be right after ours. the same is
  64        done with stacking */
  65     if (client->modal && (p = client_direct_parent(client)))
  66         push_to_top(p);
  67
  68     focus_order = g_list_remove(focus_order, client);
  69     focus_order = g_list_prepend(focus_order, client);
  70 }
  71
  72 void focus_set_client(ObClient *client)
  73 {
  74     Window active;
  75
  76     ob_debug_type(OB_DEBUG_FOCUS,
  77                   "focus_set_client 0x%lx", client ? client->window : 0);
  78
  79     if (focus_client == client)
  80         return;
  81
  82     /* uninstall the old colormap, and install the new one */
  83     screen_install_colormap(focus_client, FALSE);
  84     screen_install_colormap(client, TRUE);
  85
  86     focus_client = client;
  87
  88     if (client != NULL) {
  89         /* move to the top of the list */
  90         push_to_top(client);
  91         /* remove hiliting from the window when it gets focused */
  92         client_hilite(client, FALSE);
  93
  94         /* make sure the focus cycle popup shows things in the right order */
  95         focus_cycle_reorder();
  96     }
  97
  98     /* set the NET_ACTIVE_WINDOW hint, but preserve it on shutdown */
  99     if (ob_state() != OB_STATE_EXITING) {
 100         active = client ? client->window : None;
 101         OBT_PROP_SET32(obt_root(ob_screen), NET_ACTIVE_WINDOW, WINDOW, active);
 102     }
 103
 104     /* when focus is moved to a new window, the last_user_time timestamp would
 105        no longer be valid, as it applies for the focused window */
 106     event_reset_user_time();
 107 }
 108
 109 static ObClient* focus_fallback_target(gboolean allow_refocus,
 110                                        gboolean allow_pointer,
 111                                        gboolean allow_omnipresent,
 112                                        ObClient *old)
 113 {
 114     GList *it;
 115     ObClient *c;
 116
 117     ob_debug_type(OB_DEBUG_FOCUS, "trying pointer stuff");
 118     if (allow_pointer && config_focus_follow)
 119         if ((c = client_under_pointer()) &&
 120             (allow_refocus || client_focus_target(c) != old) &&
 121             (client_normal(c) &&
 122              client_focus(c)))
 123         {
 124             ob_debug_type(OB_DEBUG_FOCUS, "found in pointer stuff");
 125             return c;
 126         }
 127
 128     ob_debug_type(OB_DEBUG_FOCUS, "trying the focus order");
 129     for (it = focus_order; it; it = g_list_next(it)) {
 130         c = it->data;
 131         /* fallback focus to a window if:
 132            1. it is on the current desktop. this ignores omnipresent
 133            windows, which are problematic in their own rite, unless they are
 134            specifically allowed
 135            2. it is a valid auto-focus target
 136            3. it is not shaded
 137         */
 138         if ((allow_omnipresent || c->desktop == screen_desktop) &&
 139             focus_valid_target(c, screen_desktop,
 140                                TRUE, FALSE, FALSE, TRUE, FALSE, FALSE,
 141                                FALSE) &&
 142             !c->shaded &&
 143             (allow_refocus || client_focus_target(c) != old) &&
 144             client_focus(c))
 145         {
 146             ob_debug_type(OB_DEBUG_FOCUS, "found in focus order");
 147             return c;
 148         }
 149     }
 150
 151     ob_debug_type(OB_DEBUG_FOCUS, "trying a desktop window");
 152     for (it = focus_order; it; it = g_list_next(it)) {
 153         c = it->data;
 154         /* fallback focus to a window if:
 155            1. it is on the current desktop. this ignores omnipresent
 156            windows, which are problematic in their own rite.
 157            2. it is a normal type window, don't fall back onto a dock or
 158            a splashscreen or a desktop window (save the desktop as a
 159            backup fallback though)
 160         */
 161         if (focus_valid_target(c, screen_desktop,
 162                                TRUE, FALSE, FALSE, TRUE, FALSE, TRUE, FALSE) &&
 163             (allow_refocus || client_focus_target(c) != old) &&
 164             client_focus(c))
 165         {
 166             ob_debug_type(OB_DEBUG_FOCUS, "found a desktop window");
 167             return c;
 168         }
 169     }
 170
 171     return NULL;
 172 }
 173
 174 ObClient* focus_fallback(gboolean allow_refocus, gboolean allow_pointer,
 175                          gboolean allow_omnipresent, gboolean focus_lost)
 176 {
 177     ObClient *new;
 178     ObClient *old = focus_client;
 179
 180     /* unfocus any focused clients.. they can be focused by Pointer events
 181        and such, and then when we try focus them, we won't get a FocusIn
 182        event at all for them. */
 183     if (focus_lost)
 184         focus_nothing();
 185
 186     new = focus_fallback_target(allow_refocus, allow_pointer,
 187                                 allow_omnipresent, old);
 188     /* get what was really focused */
 189     if (new) new = client_focus_target(new);
 190
 191     return new;
 192 }
 193
 194 void focus_nothing(void)
 195 {
 196     /* nothing is focused, update the colormap and _the root property_ */
 197     focus_set_client(NULL);
 198
 199     /* when nothing will be focused, send focus to the backup target */
 200     XSetInputFocus(obt_display, screen_support_win, RevertToPointerRoot,
 201                    event_time());
 202 }
 203
 204 void focus_order_add_new(ObClient *c)
 205 {
 206     if (c->iconic)
 207         focus_order_to_top(c);
 208     else {
 209         g_assert(!g_list_find(focus_order, c));
 210         /* if there are only iconic windows, put this above them in the order,
 211            but if there are not, then put it under the currently focused one */
 212         if (focus_order && ((ObClient*)focus_order->data)->iconic)
 213             focus_order = g_list_insert(focus_order, c, 0);
 214         else
 215             focus_order = g_list_insert(focus_order, c, 1);
 216     }
 217
 218     focus_cycle_addremove(c, TRUE);
 219 }
 220
 221 void focus_order_remove(ObClient *c)
 222 {
 223     focus_order = g_list_remove(focus_order, c);
 224
 225     focus_cycle_addremove(c, TRUE);
 226 }
 227
 228 void focus_order_like_new(struct _ObClient *c)
 229 {
 230     focus_order = g_list_remove(focus_order, c);
 231     focus_order_add_new(c);
 232 }
 233
 234 void focus_order_to_top(ObClient *c)
 235 {
 236     focus_order = g_list_remove(focus_order, c);
 237     if (!c->iconic) {
 238         focus_order = g_list_prepend(focus_order, c);
 239     } else {
 240         GList *it;
 241
 242         /* insert before first iconic window */
 243         for (it = focus_order;
 244              it && !((ObClient*)it->data)->iconic; it = g_list_next(it));
 245         focus_order = g_list_insert_before(focus_order, it, c);
 246     }
 247
 248     focus_cycle_reorder();
 249 }
 250
 251 void focus_order_to_bottom(ObClient *c)
 252 {
 253     focus_order = g_list_remove(focus_order, c);
 254     if (c->iconic) {
 255         focus_order = g_list_append(focus_order, c);
 256     } else {
 257         GList *it;
 258
 259         /* insert before first iconic window */
 260         for (it = focus_order;
 261              it && !((ObClient*)it->data)->iconic; it = g_list_next(it));
 262         focus_order = g_list_insert_before(focus_order, it, c);
 263     }
 264
 265     focus_cycle_reorder();
 266 }
 267
 268 ObClient *focus_order_find_first(guint desktop)
 269 {
 270     GList *it;
 271     for (it = focus_order; it; it = g_list_next(it)) {
 272         ObClient *c = it->data;
 273         if (c->desktop == desktop || c->desktop == DESKTOP_ALL)
 274             return c;
 275     }
 276     return NULL;
 277 }
 278
 279 /*! Returns if a focus target has valid group siblings that can be cycled
 280   to in its place */
 281 static gboolean focus_target_has_siblings(ObClient *ft,
 282                                           gboolean iconic_windows,
 283                                           gboolean all_desktops)
 284
 285 {
 286     GSList *it;
 287
 288     if (!ft->group) return FALSE;
 289
 290     for (it = ft->group->members; it; it = g_slist_next(it)) {
 291         ObClient *c = it->data;
 292         /* check that it's not a helper window to avoid infinite recursion */
 293         if (c != ft && c->type == OB_CLIENT_TYPE_NORMAL &&
 294             focus_valid_target(c, screen_desktop,
 295                                TRUE, iconic_windows, all_desktops,
 296                                TRUE, FALSE, FALSE, FALSE))
 297         {
 298             return TRUE;
 299         }
 300     }
 301     return FALSE;
 302 }
 303
 304 gboolean focus_valid_target(ObClient *ft,
 305                             guint    desktop,
 306                             gboolean helper_windows,
 307                             gboolean iconic_windows,
 308                             gboolean all_desktops,
 309                             gboolean nonhilite_windows,
 310                             gboolean dock_windows,
 311                             gboolean desktop_windows,
 312                             gboolean user_request)
 313 {
 314     /* NOTE: if any of these things change on a client, then they should call
 315        focus_cycle_addremove() to make sure the client is not shown/hidden
 316        when it should not be */
 317
 318     gboolean ok = FALSE;
 319
 320     /* see if the window is still managed or is going away */
 321     if (!ft->managed) return FALSE;
 322
 323     /* it's on this desktop unless you want all desktops.
 324
 325        do this check first because it will usually filter out the most
 326        windows */
 327     ok = (all_desktops || ft->desktop == desktop ||
 328           ft->desktop == DESKTOP_ALL);
 329
 330     /* if we only include hilited windows, check if the window is */
 331     ok = ok && (nonhilite_windows || ft->demands_attention);
 332
 333     /* the window can receive focus somehow */
 334     ok = ok && (ft->can_focus || ft->focus_notify);
 335
 336     /* the window is not iconic, or we're allowed to go to iconic ones */
 337     ok = ok && (iconic_windows || !ft->iconic);
 338
 339     /* it's the right type of window */
 340     if (dock_windows || desktop_windows)
 341         ok = ok && ((dock_windows && ft->type == OB_CLIENT_TYPE_DOCK) ||
 342                     (desktop_windows && ft->type == OB_CLIENT_TYPE_DESKTOP));
 343     /* modal windows are important and can always get focus if they are
 344        visible and stuff, so don't change 'ok' based on their type */
 345     else if (!ft->modal)
 346         /* normal non-helper windows are valid targets */
 347         ok = ok &&
 348             ((client_normal(ft) && !client_helper(ft))
 349              ||
 350              /* helper windows are valid targets if... */
 351              (client_helper(ft) &&
 352               /* ...a window in its group already has focus and we want to
 353                  include helper windows ... */
 354               ((focus_client && ft->group == focus_client->group &&
 355                 helper_windows) ||
 356                /* ... or if there are no other windows in its group
 357                   that can be focused instead */
 358                !focus_target_has_siblings(ft, iconic_windows, all_desktops))));
 359
 360     /* it's not set to skip the taskbar (but this is overridden if the
 361        window is modal or if the user asked for this window to be focused,
 362        or if the window is iconified (and does not have any parents with
 363        which to uniconify it), and it is not used for windows which are
 364        hilited, or dialog windows as these need user interaction and should
 365        not be long-lasting windows */
 366     ok = ok && (!ft->skip_taskbar ||
 367                 (ft->modal || user_request ||
 368                  (ft->iconic && !ft->parents) ||
 369                  ft->demands_attention ||
 370                  ft->type == OB_CLIENT_TYPE_DIALOG));
 371
 372     /* it's not going to just send focus off somewhere else (modal window),
 373        unless that modal window is not one of our valid targets, then let
 374        you choose this window and bring the modal one here */
 375     {
 376         ObClient *cft = client_focus_target(ft);
 377         ok = ok && (ft == cft || !focus_valid_target(cft,
 378                                                      screen_desktop,
 379                                                      TRUE,
 380                                                      iconic_windows,
 381                                                      all_desktops,
 382                                                      nonhilite_windows,
 383                                                      dock_windows,
 384                                                      desktop_windows,
 385                                                      FALSE));
 386     }
 387
 388     return ok;
 389 }