Dogcows Code - chaz/openbox/blob - 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
  95     /* set the NET_ACTIVE_WINDOW hint, but preserve it on shutdown */
  96     if (ob_state() != OB_STATE_EXITING) {
  97         active = client ? client->window : None;
  98         OBT_PROP_SET32(obt_root(ob_screen), NET_ACTIVE_WINDOW, WINDOW, active);
  99     }
 100 }
 101
 102 static ObClient* focus_fallback_target(gboolean allow_refocus,
 103                                        gboolean allow_pointer,
 104                                        gboolean allow_omnipresent,
 105                                        ObClient *old)
 106 {
 107     GList *it;
 108     ObClient *c;
 109
 110     ob_debug_type(OB_DEBUG_FOCUS, "trying pointer stuff");
 111     if (allow_pointer && config_focus_follow)
 112         if ((c = client_under_pointer()) &&
 113             (allow_refocus || client_focus_target(c) != old) &&
 114             (client_normal(c) &&
 115              client_focus(c)))
 116         {
 117             ob_debug_type(OB_DEBUG_FOCUS, "found in pointer stuff");
 118             return c;
 119         }
 120
 121     ob_debug_type(OB_DEBUG_FOCUS, "trying the focus order");
 122     for (it = focus_order; it; it = g_list_next(it)) {
 123         c = it->data;
 124         /* fallback focus to a window if:
 125            1. it is on the current desktop. this ignores omnipresent
 126            windows, which are problematic in their own rite, unless they are
 127            specifically allowed
 128            2. it is a valid auto-focus target
 129            3. it is not shaded
 130         */
 131         if ((allow_omnipresent || c->desktop == screen_desktop) &&
 132             focus_valid_target(c, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE) &&
 133             !c->shaded &&
 134             (allow_refocus || client_focus_target(c) != old) &&
 135             client_focus(c))
 136         {
 137             ob_debug_type(OB_DEBUG_FOCUS, "found in focus order");
 138             return c;
 139         }
 140     }
 141
 142     ob_debug_type(OB_DEBUG_FOCUS, "trying a desktop window");
 143     for (it = focus_order; it; it = g_list_next(it)) {
 144         c = it->data;
 145         /* fallback focus to a window if:
 146            1. it is on the current desktop. this ignores omnipresent
 147            windows, which are problematic in their own rite.
 148            2. it is a normal type window, don't fall back onto a dock or
 149            a splashscreen or a desktop window (save the desktop as a
 150            backup fallback though)
 151         */
 152         if (focus_valid_target(c, TRUE, FALSE, FALSE, FALSE, TRUE, FALSE) &&
 153             (allow_refocus || client_focus_target(c) != old) &&
 154             client_focus(c))
 155         {
 156             ob_debug_type(OB_DEBUG_FOCUS, "found a desktop window");
 157             return c;
 158         }
 159     }
 160
 161     return NULL;
 162 }
 163
 164 ObClient* focus_fallback(gboolean allow_refocus, gboolean allow_pointer,
 165                          gboolean allow_omnipresent, gboolean focus_lost)
 166 {
 167     ObClient *new;
 168     ObClient *old = focus_client;
 169
 170     /* unfocus any focused clients.. they can be focused by Pointer events
 171        and such, and then when we try focus them, we won't get a FocusIn
 172        event at all for them. */
 173     if (focus_lost)
 174         focus_nothing();
 175
 176     new = focus_fallback_target(allow_refocus, allow_pointer,
 177                                 allow_omnipresent, old);
 178     /* get what was really focused */
 179     if (new) new = client_focus_target(new);
 180
 181     return new;
 182 }
 183
 184 void focus_nothing(void)
 185 {
 186     /* nothing is focused, update the colormap and _the root property_ */
 187     focus_set_client(NULL);
 188
 189     /* when nothing will be focused, send focus to the backup target */
 190     XSetInputFocus(obt_display, screen_support_win, RevertToPointerRoot,
 191                    event_curtime);
 192 }
 193
 194 void focus_order_add_new(ObClient *c)
 195 {
 196     if (c->iconic)
 197         focus_order_to_top(c);
 198     else {
 199         g_assert(!g_list_find(focus_order, c));
 200         /* if there are any iconic windows, put this above them in the order,
 201            but if there are not, then put it under the currently focused one */
 202         if (focus_order && ((ObClient*)focus_order->data)->iconic)
 203             focus_order = g_list_insert(focus_order, c, 0);
 204         else
 205             focus_order = g_list_insert(focus_order, c, 1);
 206     }
 207
 208     /* in the middle of cycling..? kill it. */
 209     focus_cycle_stop(c);
 210 }
 211
 212 void focus_order_remove(ObClient *c)
 213 {
 214     focus_order = g_list_remove(focus_order, c);
 215
 216     /* in the middle of cycling..? kill it. */
 217     focus_cycle_stop(c);
 218 }
 219
 220 void focus_order_to_top(ObClient *c)
 221 {
 222     focus_order = g_list_remove(focus_order, c);
 223     if (!c->iconic) {
 224         focus_order = g_list_prepend(focus_order, c);
 225     } else {
 226         GList *it;
 227
 228         /* insert before first iconic window */
 229         for (it = focus_order;
 230              it && !((ObClient*)it->data)->iconic; it = g_list_next(it));
 231         focus_order = g_list_insert_before(focus_order, it, c);
 232     }
 233 }
 234
 235 void focus_order_to_bottom(ObClient *c)
 236 {
 237     focus_order = g_list_remove(focus_order, c);
 238     if (c->iconic) {
 239         focus_order = g_list_append(focus_order, c);
 240     } else {
 241         GList *it;
 242
 243         /* insert before first iconic window */
 244         for (it = focus_order;
 245              it && !((ObClient*)it->data)->iconic; it = g_list_next(it));
 246         focus_order = g_list_insert_before(focus_order, it, c);
 247     }
 248 }
 249
 250 ObClient *focus_order_find_first(guint desktop)
 251 {
 252     GList *it;
 253     for (it = focus_order; it; it = g_list_next(it)) {
 254         ObClient *c = it->data;
 255         if (c->desktop == desktop || c->desktop == DESKTOP_ALL)
 256             return c;
 257     }
 258     return NULL;
 259 }
 260
 261 /*! Returns if a focus target has valid group siblings that can be cycled
 262   to in its place */
 263 static gboolean focus_target_has_siblings(ObClient *ft,
 264                                           gboolean iconic_windows,
 265                                           gboolean all_desktops)
 266
 267 {
 268     GSList *it;
 269
 270     if (!ft->group) return FALSE;
 271
 272     for (it = ft->group->members; it; it = g_slist_next(it)) {
 273         ObClient *c = it->data;
 274         /* check that it's not a helper window to avoid infinite recursion */
 275         if (c != ft && c->type == OB_CLIENT_TYPE_NORMAL &&
 276             focus_valid_target(c, TRUE, iconic_windows, all_desktops,
 277                                FALSE, FALSE, FALSE))
 278         {
 279             return TRUE;
 280         }
 281     }
 282     return FALSE;
 283 }
 284
 285 gboolean focus_valid_target(ObClient *ft,
 286                             gboolean helper_windows,
 287                             gboolean iconic_windows,
 288                             gboolean all_desktops,
 289                             gboolean dock_windows,
 290                             gboolean desktop_windows,
 291                             gboolean user_request)
 292 {
 293     gboolean ok = FALSE;
 294
 295     /* it's on this desktop unless you want all desktops.
 296
 297        do this check first because it will usually filter out the most
 298        windows */
 299     ok = (all_desktops || ft->desktop == screen_desktop ||
 300           ft->desktop == DESKTOP_ALL);
 301
 302     /* the window can receive focus somehow */
 303     ok = ok && (ft->can_focus || ft->focus_notify);
 304
 305     /* the window is not iconic, or we're allowed to go to iconic ones */
 306     ok = ok && (iconic_windows || !ft->iconic);
 307
 308     /* it's the right type of window */
 309     if (dock_windows || desktop_windows)
 310         ok = ok && ((dock_windows && ft->type == OB_CLIENT_TYPE_DOCK) ||
 311                     (desktop_windows && ft->type == OB_CLIENT_TYPE_DESKTOP));
 312     /* modal windows are important and can always get focus if they are
 313        visible and stuff, so don't change 'ok' based on their type */
 314     else if (!ft->modal)
 315         /* normal non-helper windows are valid targets */
 316         ok = ok &&
 317             ((client_normal(ft) && !client_helper(ft))
 318              ||
 319              /* helper windows are valid targets if... */
 320              (client_helper(ft) &&
 321               /* ...a window in its group already has focus and we want to
 322                  include helper windows ... */
 323               ((focus_client && ft->group == focus_client->group &&
 324                 helper_windows) ||
 325                /* ... or if there are no other windows in its group
 326                   that can be focused instead */
 327                !focus_target_has_siblings(ft, iconic_windows, all_desktops))));
 328
 329     /* it's not set to skip the taskbar (but this only applies to normal typed
 330        windows, and is overridden if the window is modal or if the user asked
 331        for this window to be focused) */
 332     ok = ok && (ft->type != OB_CLIENT_TYPE_NORMAL ||
 333                 ft->modal ||
 334                 user_request ||
 335                 !ft->skip_taskbar);
 336
 337     /* it's not going to just send focus off somewhere else (modal window),
 338        unless that modal window is not one of our valid targets, then let
 339        you choose this window and bring the modal one here */
 340     {
 341         ObClient *cft = client_focus_target(ft);
 342         ok = ok && (ft == cft || !focus_valid_target(cft,
 343                                                      TRUE,
 344                                                      iconic_windows,
 345                                                      all_desktops,
 346                                                      dock_windows,
 347                                                      desktop_windows,
 348                                                      FALSE));
 349     }
 350
 351     return ok;
 352 }