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 "framerender.h"
  25 #include "client.h"
  26 #include "config.h"
  27 #include "frame.h"
  28 #include "screen.h"
  29 #include "group.h"
  30 #include "prop.h"
  31 #include "focus.h"
  32 #include "stacking.h"
  33 #include "popup.h"
  34 #include "render/render.h"
  35
  36 #include <X11/Xlib.h>
  37 #include <glib.h>
  38 #include <assert.h>
  39
  40 #define FOCUS_INDICATOR_WIDTH 6
  41
  42 ObClient *focus_client = NULL;
  43 GList *focus_order = NULL;
  44 ObClient *focus_cycle_target = NULL;
  45
  46 struct {
  47     InternalWindow top;
  48     InternalWindow left;
  49     InternalWindow right;
  50     InternalWindow bottom;
  51 } focus_indicator;
  52
  53 RrAppearance *a_focus_indicator;
  54 RrColor *color_white;
  55
  56 static ObIconPopup *focus_cycle_popup;
  57
  58 static gboolean valid_focus_target(ObClient *ft,
  59                                    gboolean all_desktops,
  60                                    gboolean dock_windows);
  61 static void focus_cycle_destructor(ObClient *client, gpointer data);
  62
  63 static Window createWindow(Window parent, gulong mask,
  64                            XSetWindowAttributes *attrib)
  65 {
  66     return XCreateWindow(ob_display, parent, 0, 0, 1, 1, 0,
  67                          RrDepth(ob_rr_inst), InputOutput,
  68                          RrVisual(ob_rr_inst), mask, attrib);
  69
  70 }
  71
  72 void focus_startup(gboolean reconfig)
  73 {
  74     focus_cycle_popup = icon_popup_new(TRUE);
  75
  76     if (!reconfig) {
  77         XSetWindowAttributes attr;
  78
  79         client_add_destructor(focus_cycle_destructor, NULL);
  80
  81         /* start with nothing focused */
  82         focus_nothing();
  83
  84         focus_indicator.top.obwin.type = Window_Internal;
  85         focus_indicator.left.obwin.type = Window_Internal;
  86         focus_indicator.right.obwin.type = Window_Internal;
  87         focus_indicator.bottom.obwin.type = Window_Internal;
  88
  89         attr.override_redirect = True;
  90         attr.background_pixel = BlackPixel(ob_display, ob_screen);
  91         focus_indicator.top.win =
  92             createWindow(RootWindow(ob_display, ob_screen),
  93                          CWOverrideRedirect | CWBackPixel, &attr);
  94         focus_indicator.left.win =
  95             createWindow(RootWindow(ob_display, ob_screen),
  96                          CWOverrideRedirect | CWBackPixel, &attr);
  97         focus_indicator.right.win =
  98             createWindow(RootWindow(ob_display, ob_screen),
  99                          CWOverrideRedirect | CWBackPixel, &attr);
 100         focus_indicator.bottom.win =
 101             createWindow(RootWindow(ob_display, ob_screen),
 102                          CWOverrideRedirect | CWBackPixel, &attr);
 103
 104         stacking_add(INTERNAL_AS_WINDOW(&focus_indicator.top));
 105         stacking_add(INTERNAL_AS_WINDOW(&focus_indicator.left));
 106         stacking_add(INTERNAL_AS_WINDOW(&focus_indicator.right));
 107         stacking_add(INTERNAL_AS_WINDOW(&focus_indicator.bottom));
 108
 109         color_white = RrColorNew(ob_rr_inst, 0xff, 0xff, 0xff);
 110
 111         a_focus_indicator = RrAppearanceNew(ob_rr_inst, 4);
 112         a_focus_indicator->surface.grad = RR_SURFACE_SOLID;
 113         a_focus_indicator->surface.relief = RR_RELIEF_FLAT;
 114         a_focus_indicator->surface.primary = RrColorNew(ob_rr_inst,
 115                                                         0, 0, 0);
 116         a_focus_indicator->texture[0].type = RR_TEXTURE_LINE_ART;
 117         a_focus_indicator->texture[0].data.lineart.color = color_white;
 118         a_focus_indicator->texture[1].type = RR_TEXTURE_LINE_ART;
 119         a_focus_indicator->texture[1].data.lineart.color = color_white;
 120         a_focus_indicator->texture[2].type = RR_TEXTURE_LINE_ART;
 121         a_focus_indicator->texture[2].data.lineart.color = color_white;
 122         a_focus_indicator->texture[3].type = RR_TEXTURE_LINE_ART;
 123         a_focus_indicator->texture[3].data.lineart.color = color_white;
 124     }
 125 }
 126
 127 void focus_shutdown(gboolean reconfig)
 128 {
 129     icon_popup_free(focus_cycle_popup);
 130
 131     if (!reconfig) {
 132         client_remove_destructor(focus_cycle_destructor);
 133
 134         /* reset focus to root */
 135         XSetInputFocus(ob_display, PointerRoot, RevertToNone, CurrentTime);
 136
 137         RrColorFree(color_white);
 138
 139         RrAppearanceFree(a_focus_indicator);
 140
 141         XDestroyWindow(ob_display, focus_indicator.top.win);
 142         XDestroyWindow(ob_display, focus_indicator.left.win);
 143         XDestroyWindow(ob_display, focus_indicator.right.win);
 144         XDestroyWindow(ob_display, focus_indicator.bottom.win);
 145     }
 146 }
 147
 148 static void push_to_top(ObClient *client)
 149 {
 150     focus_order = g_list_remove(focus_order, client);
 151     focus_order = g_list_prepend(focus_order, client);
 152 }
 153
 154 void focus_set_client(ObClient *client)
 155 {
 156     Window active;
 157
 158     ob_debug_type(OB_DEBUG_FOCUS,
 159                   "focus_set_client 0x%lx\n", client ? client->window : 0);
 160
 161     /* uninstall the old colormap, and install the new one */
 162     screen_install_colormap(focus_client, FALSE);
 163     screen_install_colormap(client, TRUE);
 164
 165     /* in the middle of cycling..? kill it. CurrentTime is fine, time won't
 166        be used.
 167     */
 168     if (focus_cycle_target)
 169         focus_cycle(TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE);
 170
 171     focus_client = client;
 172
 173     if (client != NULL) {
 174         /* move to the top of the list */
 175         push_to_top(client);
 176         /* remove hiliting from the window when it gets focused */
 177         client_hilite(client, FALSE);
 178     }
 179
 180     /* set the NET_ACTIVE_WINDOW hint, but preserve it on shutdown */
 181     if (ob_state() != OB_STATE_EXITING) {
 182         active = client ? client->window : None;
 183         PROP_SET32(RootWindow(ob_display, ob_screen),
 184                    net_active_window, window, active);
 185     }
 186 }
 187
 188 ObClient* focus_fallback_target(gboolean allow_refocus, ObClient *old)
 189 {
 190     GList *it;
 191     ObClient *target = NULL;
 192     ObClient *desktop = NULL;
 193
 194     ob_debug_type(OB_DEBUG_FOCUS, "trying pointer stuff\n");
 195     if (config_focus_follow && !config_focus_last)
 196     {
 197         if ((target = client_under_pointer()))
 198             if (allow_refocus || target != old)
 199                 if (client_normal(target) && client_can_focus(target)) {
 200                     ob_debug_type(OB_DEBUG_FOCUS, "found in pointer stuff\n");
 201                     return target;
 202                 }
 203     }
 204
 205 #if 0
 206         /* try for group relations */
 207         if (old->group) {
 208             GSList *sit;
 209
 210             for (it = focus_order[screen_desktop]; it; it = g_list_next(it))
 211                 for (sit = old->group->members; sit; sit = g_slist_next(sit))
 212                     if (sit->data == it->data)
 213                         if (sit->data != old && client_normal(sit->data))
 214                             if (client_can_focus(sit->data))
 215                                 return sit->data;
 216         }
 217 #endif
 218
 219     ob_debug_type(OB_DEBUG_FOCUS, "trying omnipresentness\n");
 220     if (allow_refocus && old && old->desktop == DESKTOP_ALL &&
 221         client_normal(old))
 222     {
 223         return old;
 224     }
 225
 226
 227     ob_debug_type(OB_DEBUG_FOCUS, "trying the focus order\n");
 228     for (it = focus_order; it; it = g_list_next(it))
 229         if (allow_refocus || it->data != old) {
 230             ObClient *c = it->data;
 231             /* fallback focus to a window if:
 232                1. it is actually focusable, cuz if it's not then we're sending
 233                focus off to nothing. this includes if it is visible right now
 234                2. it is on the current desktop. this ignores omnipresent
 235                windows, which are problematic in their own rite.
 236                3. it is a normal type window, don't fall back onto a dock or
 237                a splashscreen or a desktop window (save the desktop as a
 238                backup fallback though)
 239             */
 240             if (client_can_focus(c))
 241             {
 242                 if (c->desktop == screen_desktop && client_normal(c)) {
 243                     ob_debug_type(OB_DEBUG_FOCUS, "found in focus order\n");
 244                     return it->data;
 245                 } else if (c->type == OB_CLIENT_TYPE_DESKTOP &&
 246                            desktop == NULL)
 247                     desktop = c;
 248             }
 249         }
 250
 251     /* as a last resort fallback to the desktop window if there is one.
 252        (if there's more than one, then the one most recently focused.)
 253     */
 254     ob_debug_type(OB_DEBUG_FOCUS, "found desktop: \n", !!desktop);
 255     return desktop;
 256 }
 257
 258 void focus_fallback(gboolean allow_refocus)
 259 {
 260     ObClient *new;
 261     ObClient *old = focus_client;
 262
 263     /* unfocus any focused clients.. they can be focused by Pointer events
 264        and such, and then when I try focus them, I won't get a FocusIn event
 265        at all for them.
 266     */
 267     focus_nothing();
 268
 269     if ((new = focus_fallback_target(allow_refocus, old)))
 270         client_focus(new);
 271 }
 272
 273 void focus_nothing()
 274 {
 275     /* Install our own colormap */
 276     if (focus_client != NULL) {
 277         screen_install_colormap(focus_client, FALSE);
 278         screen_install_colormap(NULL, TRUE);
 279     }
 280
 281     focus_client = NULL;
 282
 283     /* when nothing will be focused, send focus to the backup target */
 284     XSetInputFocus(ob_display, screen_support_win, RevertToPointerRoot,
 285                    event_curtime);
 286 }
 287
 288 static gchar *popup_get_name(ObClient *c, ObClient **nametarget)
 289 {
 290     ObClient *p;
 291     gchar *title = NULL;
 292     const gchar *desk = NULL;
 293     gchar *ret;
 294
 295     /* find our highest direct parent, including non-normal windows */
 296     for (p = c; p->transient_for && p->transient_for != OB_TRAN_GROUP;
 297          p = p->transient_for);
 298
 299     if (c->desktop != DESKTOP_ALL && c->desktop != screen_desktop)
 300         desk = screen_desktop_names[c->desktop];
 301
 302     /* use the transient's parent's title/icon if we don't have one */
 303     if (p != c && !strcmp("", (c->iconic ? c->icon_title : c->title)))
 304         title = g_strdup(p->iconic ? p->icon_title : p->title);
 305
 306     if (title == NULL)
 307         title = g_strdup(c->iconic ? c->icon_title : c->title);
 308
 309     if (desk)
 310         ret = g_strdup_printf("%s [%s]", title, desk);
 311     else {
 312         ret = title;
 313         title = NULL;
 314     }
 315     g_free(title);
 316
 317     /* set this only if we're returning true and they asked for it */
 318     if (ret && nametarget) *nametarget = p;
 319     return ret;
 320 }
 321
 322 static void popup_cycle(ObClient *c, gboolean show,
 323                         gboolean all_desktops, gboolean dock_windows)
 324 {
 325     gchar *showtext = NULL;
 326     ObClient *showtarget;
 327
 328     if (!show) {
 329         icon_popup_hide(focus_cycle_popup);
 330         return;
 331     }
 332
 333     /* do this stuff only when the dialog is first showing */
 334     if (!focus_cycle_popup->popup->mapped &&
 335         !focus_cycle_popup->popup->delay_mapped)
 336     {
 337         Rect *a;
 338         gchar **names;
 339         GList *targets = NULL, *it;
 340         gint n = 0, i;
 341
 342         /* position the popup */
 343         a = screen_physical_area_monitor(0);
 344         icon_popup_position(focus_cycle_popup, CenterGravity,
 345                             a->x + a->width / 2, a->y + a->height / 2);
 346         icon_popup_height(focus_cycle_popup, POPUP_HEIGHT);
 347         icon_popup_min_width(focus_cycle_popup, POPUP_WIDTH);
 348         icon_popup_max_width(focus_cycle_popup,
 349                              MAX(a->width/3, POPUP_WIDTH));
 350
 351
 352         /* make its width to be the width of all the possible titles */
 353
 354         /* build a list of all the valid focus targets */
 355         for (it = focus_order; it; it = g_list_next(it)) {
 356             ObClient *ft = it->data;
 357             if (valid_focus_target(ft, all_desktops, dock_windows)) {
 358                 targets = g_list_prepend(targets, ft);
 359                 ++n;
 360             }
 361         }
 362         /* make it null terminated so we can use g_strfreev */
 363         names = g_new(char*, n+1);
 364         for (it = targets, i = 0; it; it = g_list_next(it), ++i) {
 365             ObClient *ft = it->data, *t;
 366             names[i] = popup_get_name(ft, &t);
 367
 368             /* little optimization.. save this text and client, so we dont
 369                have to get it again */
 370             if (ft == c) {
 371                 showtext = g_strdup(names[i]);
 372                 showtarget = t;
 373             }
 374         }
 375         names[n] = NULL;
 376
 377         icon_popup_text_width_to_strings(focus_cycle_popup, names, n);
 378         g_strfreev(names);
 379     }
 380
 381
 382     if (!showtext) showtext = popup_get_name(c, &showtarget);
 383     icon_popup_show(focus_cycle_popup, showtext,
 384                     client_icon(showtarget, 48, 48));
 385     g_free(showtext);
 386 }
 387
 388 static void focus_cycle_destructor(ObClient *client, gpointer data)
 389 {
 390     /* end cycling if the target disappears. CurrentTime is fine, time won't
 391        be used
 392     */
 393     if (focus_cycle_target == client)
 394         focus_cycle(TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE);
 395 }
 396
 397 void focus_cycle_draw_indicator()
 398 {
 399     if (!focus_cycle_target) {
 400         XUnmapWindow(ob_display, focus_indicator.top.win);
 401         XUnmapWindow(ob_display, focus_indicator.left.win);
 402         XUnmapWindow(ob_display, focus_indicator.right.win);
 403         XUnmapWindow(ob_display, focus_indicator.bottom.win);
 404
 405         /* kill enter events cause by this unmapping */
 406         event_ignore_queued_enters();
 407     } else {
 408         /*
 409           if (focus_cycle_target)
 410               frame_adjust_focus(focus_cycle_target->frame, FALSE);
 411           frame_adjust_focus(focus_cycle_target->frame, TRUE);
 412         */
 413         gint x, y, w, h;
 414         gint wt, wl, wr, wb;
 415
 416         wt = wl = wr = wb = FOCUS_INDICATOR_WIDTH;
 417
 418         x = focus_cycle_target->frame->area.x;
 419         y = focus_cycle_target->frame->area.y;
 420         w = focus_cycle_target->frame->area.width;
 421         h = wt;
 422
 423         XMoveResizeWindow(ob_display, focus_indicator.top.win,
 424                           x, y, w, h);
 425         a_focus_indicator->texture[0].data.lineart.x1 = 0;
 426         a_focus_indicator->texture[0].data.lineart.y1 = h-1;
 427         a_focus_indicator->texture[0].data.lineart.x2 = 0;
 428         a_focus_indicator->texture[0].data.lineart.y2 = 0;
 429         a_focus_indicator->texture[1].data.lineart.x1 = 0;
 430         a_focus_indicator->texture[1].data.lineart.y1 = 0;
 431         a_focus_indicator->texture[1].data.lineart.x2 = w-1;
 432         a_focus_indicator->texture[1].data.lineart.y2 = 0;
 433         a_focus_indicator->texture[2].data.lineart.x1 = w-1;
 434         a_focus_indicator->texture[2].data.lineart.y1 = 0;
 435         a_focus_indicator->texture[2].data.lineart.x2 = w-1;
 436         a_focus_indicator->texture[2].data.lineart.y2 = h-1;
 437         a_focus_indicator->texture[3].data.lineart.x1 = (wl-1);
 438         a_focus_indicator->texture[3].data.lineart.y1 = h-1;
 439         a_focus_indicator->texture[3].data.lineart.x2 = w - wr;
 440         a_focus_indicator->texture[3].data.lineart.y2 = h-1;
 441         RrPaint(a_focus_indicator, focus_indicator.top.win,
 442                 w, h);
 443
 444         x = focus_cycle_target->frame->area.x;
 445         y = focus_cycle_target->frame->area.y;
 446         w = wl;
 447         h = focus_cycle_target->frame->area.height;
 448
 449         XMoveResizeWindow(ob_display, focus_indicator.left.win,
 450                           x, y, w, h);
 451         a_focus_indicator->texture[0].data.lineart.x1 = w-1;
 452         a_focus_indicator->texture[0].data.lineart.y1 = 0;
 453         a_focus_indicator->texture[0].data.lineart.x2 = 0;
 454         a_focus_indicator->texture[0].data.lineart.y2 = 0;
 455         a_focus_indicator->texture[1].data.lineart.x1 = 0;
 456         a_focus_indicator->texture[1].data.lineart.y1 = 0;
 457         a_focus_indicator->texture[1].data.lineart.x2 = 0;
 458         a_focus_indicator->texture[1].data.lineart.y2 = h-1;
 459         a_focus_indicator->texture[2].data.lineart.x1 = 0;
 460         a_focus_indicator->texture[2].data.lineart.y1 = h-1;
 461         a_focus_indicator->texture[2].data.lineart.x2 = w-1;
 462         a_focus_indicator->texture[2].data.lineart.y2 = h-1;
 463         a_focus_indicator->texture[3].data.lineart.x1 = w-1;
 464         a_focus_indicator->texture[3].data.lineart.y1 = wt-1;
 465         a_focus_indicator->texture[3].data.lineart.x2 = w-1;
 466         a_focus_indicator->texture[3].data.lineart.y2 = h - wb;
 467         RrPaint(a_focus_indicator, focus_indicator.left.win,
 468                 w, h);
 469
 470         x = focus_cycle_target->frame->area.x +
 471             focus_cycle_target->frame->area.width - wr;
 472         y = focus_cycle_target->frame->area.y;
 473         w = wr;
 474         h = focus_cycle_target->frame->area.height ;
 475
 476         XMoveResizeWindow(ob_display, focus_indicator.right.win,
 477                           x, y, w, h);
 478         a_focus_indicator->texture[0].data.lineart.x1 = 0;
 479         a_focus_indicator->texture[0].data.lineart.y1 = 0;
 480         a_focus_indicator->texture[0].data.lineart.x2 = w-1;
 481         a_focus_indicator->texture[0].data.lineart.y2 = 0;
 482         a_focus_indicator->texture[1].data.lineart.x1 = w-1;
 483         a_focus_indicator->texture[1].data.lineart.y1 = 0;
 484         a_focus_indicator->texture[1].data.lineart.x2 = w-1;
 485         a_focus_indicator->texture[1].data.lineart.y2 = h-1;
 486         a_focus_indicator->texture[2].data.lineart.x1 = w-1;
 487         a_focus_indicator->texture[2].data.lineart.y1 = h-1;
 488         a_focus_indicator->texture[2].data.lineart.x2 = 0;
 489         a_focus_indicator->texture[2].data.lineart.y2 = h-1;
 490         a_focus_indicator->texture[3].data.lineart.x1 = 0;
 491         a_focus_indicator->texture[3].data.lineart.y1 = wt-1;
 492         a_focus_indicator->texture[3].data.lineart.x2 = 0;
 493         a_focus_indicator->texture[3].data.lineart.y2 = h - wb;
 494         RrPaint(a_focus_indicator, focus_indicator.right.win,
 495                 w, h);
 496
 497         x = focus_cycle_target->frame->area.x;
 498         y = focus_cycle_target->frame->area.y +
 499             focus_cycle_target->frame->area.height - wb;
 500         w = focus_cycle_target->frame->area.width;
 501         h = wb;
 502
 503         XMoveResizeWindow(ob_display, focus_indicator.bottom.win,
 504                           x, y, w, h);
 505         a_focus_indicator->texture[0].data.lineart.x1 = 0;
 506         a_focus_indicator->texture[0].data.lineart.y1 = 0;
 507         a_focus_indicator->texture[0].data.lineart.x2 = 0;
 508         a_focus_indicator->texture[0].data.lineart.y2 = h-1;
 509         a_focus_indicator->texture[1].data.lineart.x1 = 0;
 510         a_focus_indicator->texture[1].data.lineart.y1 = h-1;
 511         a_focus_indicator->texture[1].data.lineart.x2 = w-1;
 512         a_focus_indicator->texture[1].data.lineart.y2 = h-1;
 513         a_focus_indicator->texture[2].data.lineart.x1 = w-1;
 514         a_focus_indicator->texture[2].data.lineart.y1 = h-1;
 515         a_focus_indicator->texture[2].data.lineart.x2 = w-1;
 516         a_focus_indicator->texture[2].data.lineart.y2 = 0;
 517         a_focus_indicator->texture[3].data.lineart.x1 = wl-1;
 518         a_focus_indicator->texture[3].data.lineart.y1 = 0;
 519         a_focus_indicator->texture[3].data.lineart.x2 = w - wr;
 520         a_focus_indicator->texture[3].data.lineart.y2 = 0;
 521         RrPaint(a_focus_indicator, focus_indicator.bottom.win,
 522                 w, h);
 523
 524         XMapWindow(ob_display, focus_indicator.top.win);
 525         XMapWindow(ob_display, focus_indicator.left.win);
 526         XMapWindow(ob_display, focus_indicator.right.win);
 527         XMapWindow(ob_display, focus_indicator.bottom.win);
 528     }
 529 }
 530
 531 static gboolean has_valid_group_siblings_on_desktop(ObClient *ft,
 532                                                     gboolean all_desktops)
 533
 534 {
 535     GSList *it;
 536
 537     if (!ft->group) return FALSE;
 538
 539     for (it = ft->group->members; it; it = g_slist_next(it)) {
 540         ObClient *c = it->data;
 541         /* check that it's not a helper window to avoid infinite recursion */
 542         if (c != ft && !client_helper(ft) &&
 543             valid_focus_target(ft, all_desktops, FALSE))
 544         {
 545             return TRUE;
 546         }
 547     }
 548     return FALSE;
 549 }
 550
 551 /*! @param allow_helpers This is used for calling itself recursively while
 552                          checking helper windows. */
 553 static gboolean valid_focus_target(ObClient *ft,
 554                                    gboolean all_desktops,
 555                                    gboolean dock_windows)
 556 {
 557     gboolean ok = FALSE;
 558
 559     /* it's on this desktop unless you want all desktops.
 560
 561        do this check first because it will usually filter out the most
 562        windows */
 563     ok = (all_desktops || ft->desktop == screen_desktop ||
 564           ft->desktop == DESKTOP_ALL);
 565
 566     /* the window can receive focus somehow */
 567     ok = ok && (ft->can_focus || ft->focus_notify);
 568
 569     /* it's the right type of window */
 570     if (dock_windows)
 571         ok = ok && ft->type == OB_CLIENT_TYPE_DOCK;
 572     else
 573         /* normal non-helper windows are valid targets */
 574         ok = ok &&
 575             ((client_normal(ft) && !client_helper(ft))
 576              ||
 577              /* helper windows are valid targets it... */
 578              (client_helper(ft) &&
 579               /* ...a window in its group already has focus ... */
 580               ((focus_client && ft->group == focus_client->group) ||
 581                /* ... or if there are no other windows in its group
 582                   that can be cycled to instead */
 583                !has_valid_group_siblings_on_desktop(ft, all_desktops))));
 584
 585     /* it's not set to skip the taskbar (unless it is a type that would be
 586        expected to set this hint */
 587     ok = ok && ((ft->type == OB_CLIENT_TYPE_DOCK ||
 588                  ft->type == OB_CLIENT_TYPE_TOOLBAR ||
 589                  ft->type == OB_CLIENT_TYPE_MENU ||
 590                  ft->type == OB_CLIENT_TYPE_UTILITY) ||
 591                 !ft->skip_taskbar);
 592
 593     /* it's not going to just send fous off somewhere else (modal window) */
 594     ok = ok && ft == client_focus_target(ft);
 595
 596     return ok;
 597 }
 598
 599 void focus_cycle(gboolean forward, gboolean all_desktops,
 600                  gboolean dock_windows,
 601                  gboolean linear, gboolean interactive,
 602                  gboolean dialog, gboolean done, gboolean cancel)
 603 {
 604     static ObClient *first = NULL;
 605     static ObClient *t = NULL;
 606     static GList *order = NULL;
 607     GList *it, *start, *list;
 608     ObClient *ft = NULL;
 609
 610     if (interactive) {
 611         if (cancel) {
 612             focus_cycle_target = NULL;
 613             goto done_cycle;
 614         } else if (done)
 615             goto done_cycle;
 616
 617         if (!focus_order)
 618             goto done_cycle;
 619
 620         if (!first) first = focus_client;
 621
 622         if (linear) list = client_list;
 623         else        list = focus_order;
 624     } else {
 625         if (!focus_order)
 626             goto done_cycle;
 627         list = client_list;
 628     }
 629     if (!focus_cycle_target) focus_cycle_target = focus_client;
 630
 631     start = it = g_list_find(list, focus_cycle_target);
 632     if (!start) /* switched desktops or something? */
 633         start = it = forward ? g_list_last(list) : g_list_first(list);
 634     if (!start) goto done_cycle;
 635
 636     do {
 637         if (forward) {
 638             it = it->next;
 639             if (it == NULL) it = g_list_first(list);
 640         } else {
 641             it = it->prev;
 642             if (it == NULL) it = g_list_last(list);
 643         }
 644         ft = it->data;
 645         if (valid_focus_target(ft, all_desktops, dock_windows)) {
 646             if (interactive) {
 647                 if (ft != focus_cycle_target) { /* prevents flicker */
 648                     focus_cycle_target = ft;
 649                     focus_cycle_draw_indicator();
 650                 }
 651                 /* same arguments as valid_focus_target */
 652                 popup_cycle(ft, dialog, all_desktops, dock_windows);
 653                 return;
 654             } else if (ft != focus_cycle_target) {
 655                 focus_cycle_target = ft;
 656                 done = TRUE;
 657                 break;
 658             }
 659         }
 660     } while (it != start);
 661
 662 done_cycle:
 663     if (done && focus_cycle_target)
 664         client_activate(focus_cycle_target, FALSE, TRUE);
 665
 666     t = NULL;
 667     first = NULL;
 668     focus_cycle_target = NULL;
 669     g_list_free(order);
 670     order = NULL;
 671
 672     if (interactive) {
 673         focus_cycle_draw_indicator();
 674         popup_cycle(ft, FALSE, FALSE, FALSE);
 675     }
 676
 677     return;
 678 }
 679
 680 /* this be mostly ripped from fvwm */
 681 static ObClient *focus_find_directional(ObClient *c, ObDirection dir,
 682                                  gboolean dock_windows)
 683 {
 684     gint my_cx, my_cy, his_cx, his_cy;
 685     gint offset = 0;
 686     gint distance = 0;
 687     gint score, best_score;
 688     ObClient *best_client, *cur;
 689     GList *it;
 690
 691     if(!client_list)
 692         return NULL;
 693
 694     /* first, find the centre coords of the currently focused window */
 695     my_cx = c->frame->area.x + c->frame->area.width / 2;
 696     my_cy = c->frame->area.y + c->frame->area.height / 2;
 697
 698     best_score = -1;
 699     best_client = NULL;
 700
 701     for(it = g_list_first(client_list); it; it = g_list_next(it)) {
 702         cur = it->data;
 703
 704         /* the currently selected window isn't interesting */
 705         if(cur == c)
 706             continue;
 707         if (!dock_windows && !client_normal(cur))
 708             continue;
 709         if (dock_windows && cur->type != OB_CLIENT_TYPE_DOCK)
 710             continue;
 711         /* using c->desktop instead of screen_desktop doesn't work if the
 712          * current window was omnipresent, hope this doesn't have any other
 713          * side effects */
 714         if(screen_desktop != cur->desktop && cur->desktop != DESKTOP_ALL)
 715             continue;
 716         if(cur->iconic)
 717             continue;
 718         if(!(client_focus_target(cur) == cur &&
 719              client_can_focus(cur)))
 720             continue;
 721
 722         /* find the centre coords of this window, from the
 723          * currently focused window's point of view */
 724         his_cx = (cur->frame->area.x - my_cx)
 725             + cur->frame->area.width / 2;
 726         his_cy = (cur->frame->area.y - my_cy)
 727             + cur->frame->area.height / 2;
 728
 729         if(dir == OB_DIRECTION_NORTHEAST || dir == OB_DIRECTION_SOUTHEAST ||
 730            dir == OB_DIRECTION_SOUTHWEST || dir == OB_DIRECTION_NORTHWEST) {
 731             gint tx;
 732             /* Rotate the diagonals 45 degrees counterclockwise.
 733              * To do this, multiply the matrix /+h +h\ with the
 734              * vector (x y).                   \-h +h/
 735              * h = sqrt(0.5). We can set h := 1 since absolute
 736              * distance doesn't matter here. */
 737             tx = his_cx + his_cy;
 738             his_cy = -his_cx + his_cy;
 739             his_cx = tx;
 740         }
 741
 742         switch(dir) {
 743         case OB_DIRECTION_NORTH:
 744         case OB_DIRECTION_SOUTH:
 745         case OB_DIRECTION_NORTHEAST:
 746         case OB_DIRECTION_SOUTHWEST:
 747             offset = (his_cx < 0) ? -his_cx : his_cx;
 748             distance = ((dir == OB_DIRECTION_NORTH ||
 749                          dir == OB_DIRECTION_NORTHEAST) ?
 750                         -his_cy : his_cy);
 751             break;
 752         case OB_DIRECTION_EAST:
 753         case OB_DIRECTION_WEST:
 754         case OB_DIRECTION_SOUTHEAST:
 755         case OB_DIRECTION_NORTHWEST:
 756             offset = (his_cy < 0) ? -his_cy : his_cy;
 757             distance = ((dir == OB_DIRECTION_WEST ||
 758                          dir == OB_DIRECTION_NORTHWEST) ?
 759                         -his_cx : his_cx);
 760             break;
 761         }
 762
 763         /* the target must be in the requested direction */
 764         if(distance <= 0)
 765             continue;
 766
 767         /* Calculate score for this window.  The smaller the better. */
 768         score = distance + offset;
 769
 770         /* windows more than 45 degrees off the direction are
 771          * heavily penalized and will only be chosen if nothing
 772          * else within a million pixels */
 773         if(offset > distance)
 774             score += 1000000;
 775
 776         if(best_score == -1 || score < best_score)
 777             best_client = cur,
 778                 best_score = score;
 779     }
 780
 781     return best_client;
 782 }
 783
 784 void focus_directional_cycle(ObDirection dir, gboolean dock_windows,
 785                              gboolean interactive,
 786                              gboolean dialog, gboolean done, gboolean cancel)
 787 {
 788     static ObClient *first = NULL;
 789     ObClient *ft = NULL;
 790
 791     if (!interactive)
 792         return;
 793
 794     if (cancel) {
 795         focus_cycle_target = NULL;
 796         goto done_cycle;
 797     } else if (done)
 798         goto done_cycle;
 799
 800     if (!focus_order)
 801         goto done_cycle;
 802
 803     if (!first) first = focus_client;
 804     if (!focus_cycle_target) focus_cycle_target = focus_client;
 805
 806     if (focus_cycle_target)
 807         ft = focus_find_directional(focus_cycle_target, dir, dock_windows);
 808     else {
 809         GList *it;
 810
 811         for (it = focus_order; it; it = g_list_next(it))
 812             if (valid_focus_target(it->data, FALSE, dock_windows))
 813                 ft = it->data;
 814     }
 815
 816     if (ft) {
 817         if (ft != focus_cycle_target) {/* prevents flicker */
 818             focus_cycle_target = ft;
 819             focus_cycle_draw_indicator();
 820         }
 821     }
 822     if (focus_cycle_target) {
 823         /* same arguments as valid_focus_target */
 824         popup_cycle(focus_cycle_target, dialog, FALSE, dock_windows);
 825         if (dialog)
 826             return;
 827     }
 828
 829
 830 done_cycle:
 831     if (done && focus_cycle_target)
 832         client_activate(focus_cycle_target, FALSE, TRUE);
 833
 834     first = NULL;
 835     focus_cycle_target = NULL;
 836
 837     focus_cycle_draw_indicator();
 838     popup_cycle(ft, FALSE, FALSE, FALSE);
 839
 840     return;
 841 }
 842
 843 void focus_order_add_new(ObClient *c)
 844 {
 845     if (c->iconic)
 846         focus_order_to_top(c);
 847     else {
 848         g_assert(!g_list_find(focus_order, c));
 849         /* if there are any iconic windows, put this above them in the order,
 850            but if there are not, then put it under the currently focused one */
 851         if (focus_order && ((ObClient*)focus_order->data)->iconic)
 852             focus_order = g_list_insert(focus_order, c, 0);
 853         else
 854             focus_order = g_list_insert(focus_order, c, 1);
 855     }
 856 }
 857
 858 void focus_order_remove(ObClient *c)
 859 {
 860     focus_order = g_list_remove(focus_order, c);
 861 }
 862
 863 void focus_order_to_top(ObClient *c)
 864 {
 865     focus_order = g_list_remove(focus_order, c);
 866     if (!c->iconic) {
 867         focus_order = g_list_prepend(focus_order, c);
 868     } else {
 869         GList *it;
 870
 871         /* insert before first iconic window */
 872         for (it = focus_order;
 873              it && !((ObClient*)it->data)->iconic; it = g_list_next(it));
 874         focus_order = g_list_insert_before(focus_order, it, c);
 875     }
 876 }
 877
 878 void focus_order_to_bottom(ObClient *c)
 879 {
 880     focus_order = g_list_remove(focus_order, c);
 881     if (c->iconic) {
 882         focus_order = g_list_append(focus_order, c);
 883     } else {
 884         GList *it;
 885
 886         /* insert before first iconic window */
 887         for (it = focus_order;
 888              it && !((ObClient*)it->data)->iconic; it = g_list_next(it));
 889         focus_order = g_list_insert_before(focus_order, it, c);
 890     }
 891 }
 892
 893 ObClient *focus_order_find_first(guint desktop)
 894 {
 895     GList *it;
 896     for (it = focus_order; it; it = g_list_next(it)) {
 897         ObClient *c = it->data;
 898         if (c->desktop == desktop || c->desktop == DESKTOP_ALL)
 899             return c;
 900     }
 901     return NULL;
 902 }