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