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