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