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