Dogcows Code - chaz/openbox/blob - openbox/focus.c

   1 #include "debug.h"
   2 #include "event.h"
   3 #include "openbox.h"
   4 #include "grab.h"
   5 #include "framerender.h"
   6 #include "client.h"
   7 #include "config.h"
   8 #include "frame.h"
   9 #include "screen.h"
  10 #include "group.h"
  11 #include "prop.h"
  12 #include "focus.h"
  13 #include "stacking.h"
  14 #include "popup.h"
  15
  16 #include <X11/Xlib.h>
  17 #include <glib.h>
  18 #include <assert.h>
  19
  20 ObClient *focus_client;
  21 GList **focus_order; /* these lists are created when screen_startup
  22                         sets the number of desktops */
  23 ObClient *focus_cycle_target;
  24
  25 static ObIconPopup *focus_cycle_popup;
  26
  27 void focus_startup(gboolean reconfig)
  28 {
  29     focus_cycle_popup = icon_popup_new(TRUE);
  30
  31     if (!reconfig)
  32         /* start with nothing focused */
  33         focus_set_client(NULL);
  34 }
  35
  36 void focus_shutdown(gboolean reconfig)
  37 {
  38     guint i;
  39
  40     icon_popup_free(focus_cycle_popup);
  41
  42     if (!reconfig) {
  43         for (i = 0; i < screen_num_desktops; ++i)
  44             g_list_free(focus_order[i]);
  45         g_free(focus_order);
  46
  47         /* reset focus to root */
  48         XSetInputFocus(ob_display, PointerRoot, RevertToPointerRoot,
  49                        event_lasttime);
  50     }
  51 }
  52
  53 static void push_to_top(ObClient *client)
  54 {
  55     guint desktop;
  56
  57     desktop = client->desktop;
  58     if (desktop == DESKTOP_ALL) desktop = screen_desktop;
  59     focus_order[desktop] = g_list_remove(focus_order[desktop], client);
  60     focus_order[desktop] = g_list_prepend(focus_order[desktop], client);
  61 }
  62
  63 void focus_set_client(ObClient *client)
  64 {
  65     Window active;
  66     ObClient *old;
  67
  68 #ifdef DEBUG_FOCUS
  69     ob_debug("focus_set_client 0x%lx\n", client ? client->window : 0);
  70 #endif
  71
  72     /* uninstall the old colormap, and install the new one */
  73     screen_install_colormap(focus_client, FALSE);
  74     screen_install_colormap(client, TRUE);
  75
  76     if (client == NULL) {
  77         /* when nothing will be focused, send focus to the backup target */
  78         XSetInputFocus(ob_display, screen_support_win, RevertToPointerRoot,
  79                        event_lasttime);
  80         XSync(ob_display, FALSE);
  81     }
  82
  83     /* in the middle of cycling..? kill it. */
  84     if (focus_cycle_target)
  85         focus_cycle(TRUE, TRUE, TRUE, TRUE, TRUE);
  86
  87     old = focus_client;
  88     focus_client = client;
  89
  90     /* move to the top of the list */
  91     if (client != NULL)
  92         push_to_top(client);
  93
  94     /* set the NET_ACTIVE_WINDOW hint, but preserve it on shutdown */
  95     if (ob_state() != OB_STATE_EXITING) {
  96         active = client ? client->window : None;
  97         PROP_SET32(RootWindow(ob_display, ob_screen),
  98                    net_active_window, window, active);
  99     }
 100 }
 101
 102 static gboolean focus_under_pointer()
 103 {
 104     int x, y;
 105     GList *it;
 106
 107     if (screen_pointer_pos(&x, &y)) {
 108         for (it = stacking_list; it != NULL; it = it->next) {
 109             if (WINDOW_IS_CLIENT(it->data)) {
 110                 ObClient *c = WINDOW_AS_CLIENT(it->data);
 111                 if (c->desktop == screen_desktop &&
 112                     RECT_CONTAINS(c->frame->area, x, y))
 113                     break;
 114             }
 115         }
 116         if (it != NULL) {
 117             g_assert(WINDOW_IS_CLIENT(it->data));
 118             return client_normal(it->data) && client_focus(it->data);
 119         }
 120     }
 121     return FALSE;
 122 }
 123
 124 /* finds the first transient that isn't 'skip' and ensure's that client_normal
 125  is true for it */
 126 static ObClient *find_transient_recursive(ObClient *c, ObClient *top, ObClient *skip)
 127 {
 128     GSList *it;
 129     ObClient *ret;
 130
 131     for (it = c->transients; it; it = it->next) {
 132         if (it->data == top) return NULL;
 133         ret = find_transient_recursive(it->data, top, skip);
 134         if (ret && ret != skip && client_normal(ret)) return ret;
 135         if (it->data != skip && client_normal(it->data)) return it->data;
 136     }
 137     return NULL;
 138 }
 139
 140 static gboolean focus_fallback_transient(ObClient *top, ObClient *old)
 141 {
 142     ObClient *target = find_transient_recursive(top, top, old);
 143     if (!target) {
 144         /* make sure client_normal is true always */
 145         if (!client_normal(top))
 146             return FALSE;
 147         target = top; /* no transient, keep the top */
 148     }
 149     return client_focus(target);
 150 }
 151
 152 void focus_fallback(ObFocusFallbackType type)
 153 {
 154     GList *it;
 155     ObClient *old = NULL;
 156
 157     old = focus_client;
 158
 159     /* unfocus any focused clients.. they can be focused by Pointer events
 160        and such, and then when I try focus them, I won't get a FocusIn event
 161        at all for them.
 162     */
 163     focus_set_client(NULL);
 164
 165     if (!(type == OB_FOCUS_FALLBACK_DESKTOP ?
 166           config_focus_last_on_desktop : config_focus_last)) {
 167         if (config_focus_follow) focus_under_pointer();
 168         return;
 169     }
 170
 171     if (type == OB_FOCUS_FALLBACK_UNFOCUSING && old) {
 172         /* try for transient relations */
 173         if (old->transient_for) {
 174             if (old->transient_for == OB_TRAN_GROUP) {
 175                 for (it = focus_order[screen_desktop]; it; it = it->next) {
 176                     GSList *sit;
 177
 178                     for (sit = old->group->members; sit; sit = sit->next)
 179                         if (sit->data == it->data)
 180                             if (focus_fallback_transient(sit->data, old))
 181                                 return;
 182                 }
 183             } else {
 184                 if (focus_fallback_transient(old->transient_for, old))
 185                     return;
 186             }
 187         }
 188
 189 #if 0
 190         /* try for group relations */
 191         if (old->group) {
 192             GSList *sit;
 193
 194             for (it = focus_order[screen_desktop]; it != NULL; it = it->next)
 195                 for (sit = old->group->members; sit; sit = sit->next)
 196                     if (sit->data == it->data)
 197                         if (sit->data != old && client_normal(sit->data))
 198                             if (client_can_focus(sit->data)) {
 199                                 gboolean r = client_focus(sit->data);
 200                                 assert(r);
 201                                 return;
 202                             }
 203         }
 204 #endif
 205     }
 206
 207     for (it = focus_order[screen_desktop]; it != NULL; it = it->next)
 208         if (type != OB_FOCUS_FALLBACK_UNFOCUSING || it->data != old)
 209             if (client_normal(it->data) &&
 210                 /* dont fall back to 'anonymous' fullscreen windows. theres no
 211                    checks for this is in transient/group fallbacks, so they can
 212                    be fallback targets there. */
 213                 !((ObClient*)it->data)->fullscreen &&
 214                 client_can_focus(it->data)) {
 215                 gboolean r = client_focus(it->data);
 216                 assert(r);
 217                 return;
 218             }
 219
 220     /* nothing to focus, and already set it to none above */
 221 }
 222
 223 static void popup_cycle(ObClient *c, gboolean show)
 224 {
 225     if (!show) {
 226         icon_popup_hide(focus_cycle_popup);
 227     } else {
 228         Rect *a;
 229         ObClient *p = c;
 230         char *title;
 231
 232         a = screen_physical_area_monitor(0);
 233         icon_popup_position(focus_cycle_popup, CenterGravity,
 234                             a->x + a->width / 2, a->y + a->height / 2);
 235 /*        icon_popup_size(focus_cycle_popup, a->height/2, a->height/16);
 236         icon_popup_show(focus_cycle_popup, c->title,
 237                         client_icon(c, a->height/16, a->height/16));
 238 */
 239         /* XXX the size and the font extents need to be related on some level
 240          */
 241         icon_popup_size(focus_cycle_popup, POPUP_WIDTH, POPUP_HEIGHT);
 242
 243         /* use the transient's parent's title/icon */
 244         while (p->transient_for && p->transient_for != OB_TRAN_GROUP)
 245             p = p->transient_for;
 246
 247         if (p == c)
 248             title = NULL;
 249         else
 250             title = g_strconcat((c->iconic ? c->icon_title : c->title),
 251                                 " - ",
 252                                 (p->iconic ? p->icon_title : p->title),
 253                                 NULL);
 254
 255         icon_popup_show(focus_cycle_popup,
 256                         (title ? title :
 257                          (c->iconic ? c->icon_title : c->title)),
 258                         client_icon(p, 48, 48));
 259         g_free(title);
 260     }
 261 }
 262
 263 void focus_cycle(gboolean forward, gboolean linear,
 264                  gboolean dialog, gboolean done, gboolean cancel)
 265 {
 266     static ObClient *first = NULL;
 267     static ObClient *t = NULL;
 268     static GList *order = NULL;
 269     GList *it, *start, *list;
 270     ObClient *ft;
 271
 272     if (cancel) {
 273         if (focus_cycle_target)
 274             frame_adjust_focus(focus_cycle_target->frame, FALSE);
 275         if (focus_client)
 276             frame_adjust_focus(focus_client->frame, TRUE);
 277         focus_cycle_target = NULL;
 278         goto done_cycle;
 279     } else if (done && dialog) {
 280         goto done_cycle;
 281     }
 282
 283     if (!first) first = focus_client;
 284     if (!focus_cycle_target) focus_cycle_target = focus_client;
 285
 286     if (linear) list = client_list;
 287     else        list = focus_order[screen_desktop];
 288
 289     start = it = g_list_find(list, focus_cycle_target);
 290     if (!start) /* switched desktops or something? */
 291         start = it = forward ? g_list_last(list) : g_list_first(list);
 292     if (!start) goto done_cycle;
 293
 294     do {
 295         if (forward) {
 296             it = it->next;
 297             if (it == NULL) it = g_list_first(list);
 298         } else {
 299             it = it->prev;
 300             if (it == NULL) it = g_list_last(list);
 301         }
 302         /*ft = client_focus_target(it->data);*/
 303         ft = it->data;
 304         /* we don't use client_can_focus here, because that doesn't let you
 305            focus an iconic window, but we want to be able to, so we just check
 306            if the focus flags on the window allow it, and its on the current
 307            desktop */
 308         if (ft->transients == NULL && client_normal(ft) &&
 309             ((ft->can_focus || ft->focus_notify) &&
 310              !ft->skip_taskbar &&
 311              (ft->desktop == screen_desktop || ft->desktop == DESKTOP_ALL))) {
 312             if (ft != focus_cycle_target) { /* prevents flicker */
 313                 if (focus_cycle_target)
 314                     frame_adjust_focus(focus_cycle_target->frame, FALSE);
 315                 focus_cycle_target = ft;
 316                 frame_adjust_focus(focus_cycle_target->frame, TRUE);
 317             }
 318             popup_cycle(ft, dialog);
 319             return;
 320         }
 321     } while (it != start);
 322
 323 done_cycle:
 324     if (done && focus_cycle_target)
 325         client_activate(focus_cycle_target, FALSE);
 326
 327     t = NULL;
 328     first = NULL;
 329     focus_cycle_target = NULL;
 330     g_list_free(order);
 331     order = NULL;
 332
 333     popup_cycle(ft, FALSE);
 334
 335     return;
 336 }
 337
 338 void focus_directional_cycle(ObDirection dir,
 339                              gboolean dialog, gboolean done, gboolean cancel)
 340 {
 341     static ObClient *first = NULL;
 342     ObClient *ft;
 343
 344     if (cancel) {
 345         if (focus_cycle_target)
 346             frame_adjust_focus(focus_cycle_target->frame, FALSE);
 347         if (focus_client)
 348             frame_adjust_focus(focus_client->frame, TRUE);
 349         focus_cycle_target = NULL;
 350         goto done_cycle;
 351     } else if (done && dialog) {
 352         goto done_cycle;
 353     }
 354
 355     if (!first) first = focus_client;
 356     if (!focus_cycle_target) focus_cycle_target = focus_client;
 357
 358     if ((ft = client_find_directional(focus_cycle_target, dir))) {
 359         if (ft != focus_cycle_target) {/* prevents flicker */
 360             if (focus_cycle_target)
 361                 frame_adjust_focus(focus_cycle_target->frame, FALSE);
 362             focus_cycle_target = ft;
 363             frame_adjust_focus(focus_cycle_target->frame, TRUE);
 364         }
 365         popup_cycle(ft, dialog);
 366     }
 367     if (dialog)
 368         return;
 369
 370 done_cycle:
 371     if (done && focus_cycle_target)
 372         client_activate(focus_cycle_target, FALSE);
 373
 374     first = NULL;
 375     focus_cycle_target = NULL;
 376
 377     popup_cycle(ft, FALSE);
 378
 379     return;
 380 }
 381
 382 void focus_order_add_new(ObClient *c)
 383 {
 384     guint d, i;
 385
 386     if (c->iconic)
 387         focus_order_to_top(c);
 388     else {
 389         d = c->desktop;
 390         if (d == DESKTOP_ALL) {
 391             for (i = 0; i < screen_num_desktops; ++i) {
 392                 if (focus_order[i] && ((ObClient*)focus_order[i]->data)->iconic)
 393                     focus_order[i] = g_list_insert(focus_order[i], c, 0);
 394                 else
 395                     focus_order[i] = g_list_insert(focus_order[i], c, 1);
 396             }
 397         } else
 398              if (focus_order[d] && ((ObClient*)focus_order[d]->data)->iconic)
 399                 focus_order[d] = g_list_insert(focus_order[d], c, 0);
 400             else
 401                 focus_order[d] = g_list_insert(focus_order[d], c, 1);
 402     }
 403 }
 404
 405 void focus_order_remove(ObClient *c)
 406 {
 407     guint d, i;
 408
 409     d = c->desktop;
 410     if (d == DESKTOP_ALL) {
 411         for (i = 0; i < screen_num_desktops; ++i)
 412             focus_order[i] = g_list_remove(focus_order[i], c);
 413     } else
 414         focus_order[d] = g_list_remove(focus_order[d], c);
 415 }
 416
 417 static void to_top(ObClient *c, guint d)
 418 {
 419     focus_order[d] = g_list_remove(focus_order[d], c);
 420     if (!c->iconic) {
 421         focus_order[d] = g_list_prepend(focus_order[d], c);
 422     } else {
 423         GList *it;
 424
 425         /* insert before first iconic window */
 426         for (it = focus_order[d];
 427              it && !((ObClient*)it->data)->iconic; it = it->next);
 428         focus_order[d] = g_list_insert_before(focus_order[d], it, c);
 429     }
 430 }
 431
 432 void focus_order_to_top(ObClient *c)
 433 {
 434     guint d, i;
 435
 436     d = c->desktop;
 437     if (d == DESKTOP_ALL) {
 438         for (i = 0; i < screen_num_desktops; ++i)
 439             to_top(c, i);
 440     } else
 441         to_top(c, d);
 442 }
 443
 444 static void to_bottom(ObClient *c, guint d)
 445 {
 446     focus_order[d] = g_list_remove(focus_order[d], c);
 447     if (c->iconic) {
 448         focus_order[d] = g_list_append(focus_order[d], c);
 449     } else {
 450         GList *it;
 451
 452         /* insert before first iconic window */
 453         for (it = focus_order[d];
 454              it && !((ObClient*)it->data)->iconic; it = it->next);
 455         g_list_insert_before(focus_order[d], it, c);
 456     }
 457 }
 458
 459 void focus_order_to_bottom(ObClient *c)
 460 {
 461     guint d, i;
 462
 463     d = c->desktop;
 464     if (d == DESKTOP_ALL) {
 465         for (i = 0; i < screen_num_desktops; ++i)
 466             to_bottom(c, i);
 467     } else
 468         to_bottom(c, d);
 469 }