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 5
  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 valid_focus_target(ObClient *ft,
 532                                    gboolean all_desktops,
 533                                    gboolean dock_windows)
 534 {
 535     gboolean ok = FALSE;
 536
 537     /* it's on this desktop unless you want all desktops.
 538
 539        do this check first because it will usually filter out the most
 540        windows */
 541     ok = (all_desktops || ft->desktop == screen_desktop ||
 542           ft->desktop == DESKTOP_ALL);
 543
 544     /* the window can receive focus somehow */
 545     ok = ok && (ft->can_focus || ft->focus_notify);
 546
 547     /* it's the right type of window */
 548     if (dock_windows)
 549         ok = ok && ft->type == OB_CLIENT_TYPE_DOCK;
 550     else
 551         ok = ok && (ft->type == OB_CLIENT_TYPE_NORMAL ||
 552                     ft->type == OB_CLIENT_TYPE_DIALOG ||
 553                     ((ft->type == OB_CLIENT_TYPE_TOOLBAR ||
 554                       ft->type == OB_CLIENT_TYPE_MENU ||
 555                       ft->type == OB_CLIENT_TYPE_UTILITY) &&
 556                      /* let alt-tab go to these windows when a window in its
 557                         group already has focus ... */
 558                      ((focus_client && ft->group == focus_client->group) ||
 559                       /* ... or if there are no application windows in its
 560                          group */
 561                       !client_has_application_group_siblings(ft))));
 562
 563     /* it's not set to skip the taskbar (unless it is a type that would be
 564        expected to set this hint */
 565     ok = ok && ((ft->type == OB_CLIENT_TYPE_DOCK ||
 566                  ft->type == OB_CLIENT_TYPE_TOOLBAR ||
 567                  ft->type == OB_CLIENT_TYPE_MENU ||
 568                  ft->type == OB_CLIENT_TYPE_UTILITY) ||
 569                 !ft->skip_taskbar);
 570
 571     /* it's not going to just send fous off somewhere else (modal window) */
 572     ok = ok && ft == client_focus_target(ft);
 573
 574     return ok;
 575 }
 576
 577 void focus_cycle(gboolean forward, gboolean all_desktops,
 578                  gboolean dock_windows,
 579                  gboolean linear, gboolean interactive,
 580                  gboolean dialog, gboolean done, gboolean cancel)
 581 {
 582     static ObClient *first = NULL;
 583     static ObClient *t = NULL;
 584     static GList *order = NULL;
 585     GList *it, *start, *list;
 586     ObClient *ft = NULL;
 587
 588     if (interactive) {
 589         if (cancel) {
 590             focus_cycle_target = NULL;
 591             goto done_cycle;
 592         } else if (done)
 593             goto done_cycle;
 594
 595         if (!focus_order)
 596             goto done_cycle;
 597
 598         if (!first) first = focus_client;
 599
 600         if (linear) list = client_list;
 601         else        list = focus_order;
 602     } else {
 603         if (!focus_order)
 604             goto done_cycle;
 605         list = client_list;
 606     }
 607     if (!focus_cycle_target) focus_cycle_target = focus_client;
 608
 609     start = it = g_list_find(list, focus_cycle_target);
 610     if (!start) /* switched desktops or something? */
 611         start = it = forward ? g_list_last(list) : g_list_first(list);
 612     if (!start) goto done_cycle;
 613
 614     do {
 615         if (forward) {
 616             it = it->next;
 617             if (it == NULL) it = g_list_first(list);
 618         } else {
 619             it = it->prev;
 620             if (it == NULL) it = g_list_last(list);
 621         }
 622         ft = it->data;
 623         if (valid_focus_target(ft, all_desktops, dock_windows)) {
 624             if (interactive) {
 625                 if (ft != focus_cycle_target) { /* prevents flicker */
 626                     focus_cycle_target = ft;
 627                     focus_cycle_draw_indicator();
 628                 }
 629                 /* same arguments as valid_focus_target */
 630                 popup_cycle(ft, dialog, all_desktops, dock_windows);
 631                 return;
 632             } else if (ft != focus_cycle_target) {
 633                 focus_cycle_target = ft;
 634                 done = TRUE;
 635                 break;
 636             }
 637         }
 638     } while (it != start);
 639
 640 done_cycle:
 641     if (done && focus_cycle_target)
 642         client_activate(focus_cycle_target, FALSE, TRUE);
 643
 644     t = NULL;
 645     first = NULL;
 646     focus_cycle_target = NULL;
 647     g_list_free(order);
 648     order = NULL;
 649
 650     if (interactive) {
 651         focus_cycle_draw_indicator();
 652         popup_cycle(ft, FALSE, FALSE, FALSE);
 653     }
 654
 655     return;
 656 }
 657
 658 /* this be mostly ripped from fvwm */
 659 static ObClient *focus_find_directional(ObClient *c, ObDirection dir,
 660                                  gboolean dock_windows)
 661 {
 662     gint my_cx, my_cy, his_cx, his_cy;
 663     gint offset = 0;
 664     gint distance = 0;
 665     gint score, best_score;
 666     ObClient *best_client, *cur;
 667     GList *it;
 668
 669     if(!client_list)
 670         return NULL;
 671
 672     /* first, find the centre coords of the currently focused window */
 673     my_cx = c->frame->area.x + c->frame->area.width / 2;
 674     my_cy = c->frame->area.y + c->frame->area.height / 2;
 675
 676     best_score = -1;
 677     best_client = NULL;
 678
 679     for(it = g_list_first(client_list); it; it = g_list_next(it)) {
 680         cur = it->data;
 681
 682         /* the currently selected window isn't interesting */
 683         if(cur == c)
 684             continue;
 685         if (!dock_windows && !client_normal(cur))
 686             continue;
 687         if (dock_windows && cur->type != OB_CLIENT_TYPE_DOCK)
 688             continue;
 689         /* using c->desktop instead of screen_desktop doesn't work if the
 690          * current window was omnipresent, hope this doesn't have any other
 691          * side effects */
 692         if(screen_desktop != cur->desktop && cur->desktop != DESKTOP_ALL)
 693             continue;
 694         if(cur->iconic)
 695             continue;
 696         if(!(client_focus_target(cur) == cur &&
 697              client_can_focus(cur)))
 698             continue;
 699
 700         /* find the centre coords of this window, from the
 701          * currently focused window's point of view */
 702         his_cx = (cur->frame->area.x - my_cx)
 703             + cur->frame->area.width / 2;
 704         his_cy = (cur->frame->area.y - my_cy)
 705             + cur->frame->area.height / 2;
 706
 707         if(dir == OB_DIRECTION_NORTHEAST || dir == OB_DIRECTION_SOUTHEAST ||
 708            dir == OB_DIRECTION_SOUTHWEST || dir == OB_DIRECTION_NORTHWEST) {
 709             gint tx;
 710             /* Rotate the diagonals 45 degrees counterclockwise.
 711              * To do this, multiply the matrix /+h +h\ with the
 712              * vector (x y).                   \-h +h/
 713              * h = sqrt(0.5). We can set h := 1 since absolute
 714              * distance doesn't matter here. */
 715             tx = his_cx + his_cy;
 716             his_cy = -his_cx + his_cy;
 717             his_cx = tx;
 718         }
 719
 720         switch(dir) {
 721         case OB_DIRECTION_NORTH:
 722         case OB_DIRECTION_SOUTH:
 723         case OB_DIRECTION_NORTHEAST:
 724         case OB_DIRECTION_SOUTHWEST:
 725             offset = (his_cx < 0) ? -his_cx : his_cx;
 726             distance = ((dir == OB_DIRECTION_NORTH ||
 727                          dir == OB_DIRECTION_NORTHEAST) ?
 728                         -his_cy : his_cy);
 729             break;
 730         case OB_DIRECTION_EAST:
 731         case OB_DIRECTION_WEST:
 732         case OB_DIRECTION_SOUTHEAST:
 733         case OB_DIRECTION_NORTHWEST:
 734             offset = (his_cy < 0) ? -his_cy : his_cy;
 735             distance = ((dir == OB_DIRECTION_WEST ||
 736                          dir == OB_DIRECTION_NORTHWEST) ?
 737                         -his_cx : his_cx);
 738             break;
 739         }
 740
 741         /* the target must be in the requested direction */
 742         if(distance <= 0)
 743             continue;
 744
 745         /* Calculate score for this window.  The smaller the better. */
 746         score = distance + offset;
 747
 748         /* windows more than 45 degrees off the direction are
 749          * heavily penalized and will only be chosen if nothing
 750          * else within a million pixels */
 751         if(offset > distance)
 752             score += 1000000;
 753
 754         if(best_score == -1 || score < best_score)
 755             best_client = cur,
 756                 best_score = score;
 757     }
 758
 759     return best_client;
 760 }
 761
 762 void focus_directional_cycle(ObDirection dir, gboolean dock_windows,
 763                              gboolean interactive,
 764                              gboolean dialog, gboolean done, gboolean cancel)
 765 {
 766     static ObClient *first = NULL;
 767     ObClient *ft = NULL;
 768
 769     if (!interactive)
 770         return;
 771
 772     if (cancel) {
 773         focus_cycle_target = NULL;
 774         goto done_cycle;
 775     } else if (done)
 776         goto done_cycle;
 777
 778     if (!focus_order)
 779         goto done_cycle;
 780
 781     if (!first) first = focus_client;
 782     if (!focus_cycle_target) focus_cycle_target = focus_client;
 783
 784     if (focus_cycle_target)
 785         ft = focus_find_directional(focus_cycle_target, dir, dock_windows);
 786     else {
 787         GList *it;
 788
 789         for (it = focus_order; it; it = g_list_next(it))
 790             if (valid_focus_target(it->data, FALSE, dock_windows))
 791                 ft = it->data;
 792     }
 793
 794     if (ft) {
 795         if (ft != focus_cycle_target) {/* prevents flicker */
 796             focus_cycle_target = ft;
 797             focus_cycle_draw_indicator();
 798         }
 799     }
 800     if (focus_cycle_target) {
 801         /* same arguments as valid_focus_target */
 802         popup_cycle(focus_cycle_target, dialog, FALSE, dock_windows);
 803         if (dialog)
 804             return;
 805     }
 806
 807
 808 done_cycle:
 809     if (done && focus_cycle_target)
 810         client_activate(focus_cycle_target, FALSE, TRUE);
 811
 812     first = NULL;
 813     focus_cycle_target = NULL;
 814
 815     focus_cycle_draw_indicator();
 816     popup_cycle(ft, FALSE, FALSE, FALSE);
 817
 818     return;
 819 }
 820
 821 void focus_order_add_new(ObClient *c)
 822 {
 823     if (c->iconic)
 824         focus_order_to_top(c);
 825     else {
 826         g_assert(!g_list_find(focus_order, c));
 827         /* if there are any iconic windows, put this above them in the order,
 828            but if there are not, then put it under the currently focused one */
 829         if (focus_order && ((ObClient*)focus_order->data)->iconic)
 830             focus_order = g_list_insert(focus_order, c, 0);
 831         else
 832             focus_order = g_list_insert(focus_order, c, 1);
 833     }
 834 }
 835
 836 void focus_order_remove(ObClient *c)
 837 {
 838     focus_order = g_list_remove(focus_order, c);
 839 }
 840
 841 void focus_order_to_top(ObClient *c)
 842 {
 843     focus_order = g_list_remove(focus_order, c);
 844     if (!c->iconic) {
 845         focus_order = g_list_prepend(focus_order, c);
 846     } else {
 847         GList *it;
 848
 849         /* insert before first iconic window */
 850         for (it = focus_order;
 851              it && !((ObClient*)it->data)->iconic; it = g_list_next(it));
 852         focus_order = g_list_insert_before(focus_order, it, c);
 853     }
 854 }
 855
 856 void focus_order_to_bottom(ObClient *c)
 857 {
 858     focus_order = g_list_remove(focus_order, c);
 859     if (c->iconic) {
 860         focus_order = g_list_append(focus_order, c);
 861     } else {
 862         GList *it;
 863
 864         /* insert before first iconic window */
 865         for (it = focus_order;
 866              it && !((ObClient*)it->data)->iconic; it = g_list_next(it));
 867         focus_order = g_list_insert_before(focus_order, it, c);
 868     }
 869 }
 870
 871 ObClient *focus_order_find_first(guint desktop)
 872 {
 873     GList *it;
 874     for (it = focus_order; it; it = g_list_next(it)) {
 875         ObClient *c = it->data;
 876         if (c->desktop == desktop || c->desktop == DESKTOP_ALL)
 877             return c;
 878     }
 879     return NULL;
 880 }