openbox/stacking.c

   1 /* -*- indent-tabs-mode: nil; tab-width: 4; c-basic-offset: 4; -*-
   2
   3    stacking.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 "openbox.h"
  21 #include "prop.h"
  22 #include "screen.h"
  23 #include "focus.h"
  24 #include "client.h"
  25 #include "group.h"
  26 #include "frame.h"
  27 #include "window.h"
  28 #include "event.h"
  29 #include "debug.h"
  30
  31 GList  *stacking_list = NULL;
  32 /*! When true, stacking changes will not be reflected on the screen.  This is
  33   to freeze the on-screen stacking order while a window is being temporarily
  34   raised during focus cycling */
  35 static gboolean pause_changes = FALSE;
  36
  37 void stacking_set_list(void)
  38 {
  39     Window *windows = NULL;
  40     GList *it;
  41     guint i = 0;
  42
  43     /* on shutdown, don't update the properties, so that we can read it back
  44        in on startup and re-stack the windows as they were before we shut down
  45     */
  46     if (ob_state() == OB_STATE_EXITING) return;
  47
  48     /* create an array of the window ids (from bottom to top,
  49        reverse order!) */
  50     if (stacking_list) {
  51         windows = g_new(Window, g_list_length(stacking_list));
  52         for (it = g_list_last(stacking_list); it; it = g_list_previous(it)) {
  53             if (WINDOW_IS_CLIENT(it->data))
  54                 windows[i++] = WINDOW_AS_CLIENT(it->data)->window;
  55         }
  56     }
  57
  58     PROP_SETA32(RootWindow(ob_display, ob_screen),
  59                 net_client_list_stacking, window, (gulong*)windows, i);
  60
  61     g_free(windows);
  62 }
  63
  64 static void do_restack(GList *wins, GList *before)
  65 {
  66     GList *it;
  67     Window *win;
  68     gint i;
  69
  70 #ifdef DEBUG
  71     GList *next;
  72     /* pls only restack stuff in the same layer at a time */
  73     for (it = wins; it; it = next) {
  74         next = g_list_next(it);
  75         if (!next) break;
  76         g_assert (window_layer(it->data) == window_layer(next->data));
  77     }
  78     if (before)
  79         g_assert(window_layer(it->data) >= window_layer(before->data));
  80 #endif
  81
  82     win = g_new(Window, g_list_length(wins) + 1);
  83
  84     if (before == stacking_list)
  85         win[0] = screen_support_win;
  86     else if (!before)
  87         win[0] = window_top(g_list_last(stacking_list)->data);
  88     else
  89         win[0] = window_top(g_list_previous(before)->data);
  90
  91     for (i = 1, it = wins; it; ++i, it = g_list_next(it)) {
  92         win[i] = window_top(it->data);
  93         g_assert(win[i] != None); /* better not call stacking shit before
  94                                      setting your top level window value */
  95         stacking_list = g_list_insert_before(stacking_list, before, it->data);
  96     }
  97
  98 #ifdef DEBUG
  99     /* some debug checking of the stacking list's order */
 100     for (it = stacking_list; ; it = next) {
 101         next = g_list_next(it);
 102         if (!next) break;
 103         g_assert(window_layer(it->data) >= window_layer(next->data));
 104     }
 105 #endif
 106
 107     if (!pause_changes)
 108         XRestackWindows(ob_display, win, i);
 109     g_free(win);
 110
 111     stacking_set_list();
 112 }
 113
 114 void stacking_temp_raise(ObWindow *window)
 115 {
 116     Window win[2];
 117     GList *it;
 118     gulong start;
 119
 120     /* don't use this for internal windows..! it would lower them.. */
 121     g_assert(window_layer(window) < OB_STACKING_LAYER_INTERNAL);
 122
 123     /* find the window to drop it underneath */
 124     win[0] = screen_support_win;
 125     for (it = stacking_list; it; it = g_list_next(it)) {
 126         ObWindow *w = it->data;
 127         if (window_layer(w) >= OB_STACKING_LAYER_INTERNAL)
 128             win[0] = window_top(w);
 129         else
 130             break;
 131     }
 132
 133     win[1] = window_top(window);
 134     start = event_start_ignore_all_enters();
 135     XRestackWindows(ob_display, win, 2);
 136     event_end_ignore_all_enters(start);
 137
 138     pause_changes = TRUE;
 139 }
 140
 141 void stacking_restore(void)
 142 {
 143     Window *win;
 144     GList *it;
 145     gint i;
 146     gulong start;
 147
 148     win = g_new(Window, g_list_length(stacking_list) + 1);
 149     win[0] = screen_support_win;
 150     for (i = 1, it = stacking_list; it; ++i, it = g_list_next(it))
 151         win[i] = window_top(it->data);
 152     start = event_start_ignore_all_enters();
 153     XRestackWindows(ob_display, win, i);
 154     event_end_ignore_all_enters(start);
 155     g_free(win);
 156
 157     pause_changes = FALSE;
 158 }
 159
 160 static void do_raise(GList *wins)
 161 {
 162     GList *it;
 163     GList *layer[OB_NUM_STACKING_LAYERS] = {NULL};
 164     gint i;
 165
 166     for (it = wins; it; it = g_list_next(it)) {
 167         ObStackingLayer l;
 168
 169         l = window_layer(it->data);
 170         layer[l] = g_list_append(layer[l], it->data);
 171     }
 172
 173     it = stacking_list;
 174     for (i = OB_NUM_STACKING_LAYERS - 1; i >= 0; --i) {
 175         if (layer[i]) {
 176             for (; it; it = g_list_next(it)) {
 177                 /* look for the top of the layer */
 178                 if (window_layer(it->data) <= (ObStackingLayer) i)
 179                     break;
 180             }
 181             do_restack(layer[i], it);
 182             g_list_free(layer[i]);
 183         }
 184     }
 185 }
 186
 187 static void do_lower(GList *wins)
 188 {
 189     GList *it;
 190     GList *layer[OB_NUM_STACKING_LAYERS] = {NULL};
 191     gint i;
 192
 193     for (it = wins; it; it = g_list_next(it)) {
 194         ObStackingLayer l;
 195
 196         l = window_layer(it->data);
 197         layer[l] = g_list_append(layer[l], it->data);
 198     }
 199
 200     it = stacking_list;
 201     for (i = OB_NUM_STACKING_LAYERS - 1; i >= 0; --i) {
 202         if (layer[i]) {
 203             for (; it; it = g_list_next(it)) {
 204                 /* look for the top of the next layer down */
 205                 if (window_layer(it->data) < (ObStackingLayer) i)
 206                     break;
 207             }
 208             do_restack(layer[i], it);
 209             g_list_free(layer[i]);
 210         }
 211     }
 212 }
 213
 214 static void restack_windows(ObClient *selected, gboolean raise)
 215 {
 216     GList *it, *last, *below, *above, *next;
 217     GList *wins = NULL;
 218
 219     GList *group_modals = NULL;
 220     GList *group_trans = NULL;
 221     GList *modals = NULL;
 222     GList *trans = NULL;
 223
 224     if (raise) {
 225         ObClient *p;
 226
 227         /* if a window is modal for another single window, then raise it to the
 228            top too, the same is done with the focus order */
 229         while (selected->modal && (p = client_direct_parent(selected)))
 230             selected = p;
 231     }
 232
 233     /* remove first so we can't run into ourself */
 234     it = g_list_find(stacking_list, selected);
 235     g_assert(it);
 236     stacking_list = g_list_delete_link(stacking_list, it);
 237
 238     /* go from the bottom of the stacking list up. don't move any other windows
 239        when lowering, we call this for each window independently */
 240     if (raise) {
 241         for (it = g_list_last(stacking_list); it; it = next) {
 242             next = g_list_previous(it);
 243
 244             if (WINDOW_IS_CLIENT(it->data)) {
 245                 ObClient *ch = it->data;
 246
 247                 /* only move windows in the same stacking layer */
 248                 if (ch->layer == selected->layer &&
 249                     client_search_transient(selected, ch))
 250                 {
 251                     if (client_is_direct_child(selected, ch)) {
 252                         if (ch->modal)
 253                             modals = g_list_prepend(modals, ch);
 254                         else
 255                             trans = g_list_prepend(trans, ch);
 256                     }
 257                     else {
 258                         if (ch->modal)
 259                             group_modals = g_list_prepend(group_modals, ch);
 260                         else
 261                             group_trans = g_list_prepend(group_trans, ch);
 262                     }
 263                     stacking_list = g_list_delete_link(stacking_list, it);
 264                 }
 265             }
 266         }
 267     }
 268
 269     /* put transients of the selected window right above it */
 270     wins = g_list_concat(modals, trans);
 271     wins = g_list_append(wins, selected);
 272
 273     /* if selected window is transient for group then raise it above others */
 274     if (selected->transient_for_group) {
 275         /* if it's modal, raise it above those also */
 276         if (selected->modal) {
 277             wins = g_list_concat(wins, group_modals);
 278             group_modals = NULL;
 279         }
 280         wins = g_list_concat(wins, group_trans);
 281         group_trans = NULL;
 282     }
 283
 284     /* find where to put the selected window, start from bottom of list,
 285        this is the window below everything we are re-adding to the list */
 286     last = NULL;
 287     for (it = g_list_last(stacking_list); it; it = g_list_previous(it))
 288     {
 289         if (window_layer(it->data) < selected->layer) {
 290             last = it;
 291             continue;
 292         }
 293         /* if lowering, stop at the beginning of the layer */
 294         if (!raise)
 295             break;
 296         /* if raising, stop at the end of the layer */
 297         if (window_layer(it->data) > selected->layer)
 298             break;
 299
 300         last = it;
 301     }
 302
 303     /* save this position in the stacking list */
 304     below = last;
 305
 306     /* find where to put the group transients, start from the top of list */
 307     for (it = stacking_list; it; it = g_list_next(it)) {
 308         /* skip past higher layers */
 309         if (window_layer(it->data) > selected->layer)
 310             continue;
 311         /* if we reach the end of the layer (how?) then don't go further */
 312         if (window_layer(it->data) < selected->layer)
 313             break;
 314         /* stop when we reach the first window in the group */
 315         if (WINDOW_IS_CLIENT(it->data)) {
 316             ObClient *c = it->data;
 317             if (c->group == selected->group)
 318                 break;
 319         }
 320         /* if we don't hit any other group members, stop here because this
 321            is where we are putting the selected window (and its children) */
 322         if (it == below)
 323             break;
 324     }
 325
 326     /* save this position, this is the top of the group of windows between the
 327        group transient ones we're restacking and the others up above that we're
 328        restacking
 329
 330        we actually want to save 1 position _above_ that, for for loops to work
 331        nicely, so move back one position in the list while saving it
 332     */
 333     above = it ? g_list_previous(it) : g_list_last(stacking_list);
 334
 335     /* put the windows inside the gap to the other windows we're stacking
 336        into the restacking list, go from the bottom up so that we can use
 337        g_list_prepend */
 338     if (below) it = g_list_previous(below);
 339     else       it = g_list_last(stacking_list);
 340     for (; it != above; it = next) {
 341         next = g_list_previous(it);
 342         wins = g_list_prepend(wins, it->data);
 343         stacking_list = g_list_delete_link(stacking_list, it);
 344     }
 345
 346     /* group transients go above the rest of the stuff acquired to now */
 347     wins = g_list_concat(group_trans, wins);
 348     /* group modals go on the very top */
 349     wins = g_list_concat(group_modals, wins);
 350
 351     do_restack(wins, below);
 352     g_list_free(wins);
 353
 354     /* lower our parents after us, so they go below us */
 355     if (!raise && selected->parents) {
 356         GSList *parents_copy, *sit;
 357         GSList *reorder = NULL;
 358
 359         parents_copy = g_slist_copy(selected->parents);
 360
 361         /* go thru stacking list backwards so we can use g_slist_prepend */
 362         for (it = g_list_last(stacking_list); it && parents_copy;
 363              it = g_list_previous(it))
 364             if ((sit = g_slist_find(parents_copy, it->data))) {
 365                 reorder = g_slist_prepend(reorder, sit->data);
 366                 parents_copy = g_slist_delete_link(parents_copy, sit);
 367             }
 368         g_assert(parents_copy == NULL);
 369
 370         /* call restack for each of these to lower them */
 371         for (sit = reorder; sit; sit = g_slist_next(sit))
 372             restack_windows(sit->data, raise);
 373     }
 374 }
 375
 376 void stacking_raise(ObWindow *window)
 377 {
 378     if (WINDOW_IS_CLIENT(window)) {
 379         ObClient *selected;
 380         selected = WINDOW_AS_CLIENT(window);
 381         restack_windows(selected, TRUE);
 382     } else {
 383         GList *wins;
 384         wins = g_list_append(NULL, window);
 385         stacking_list = g_list_remove(stacking_list, window);
 386         do_raise(wins);
 387         g_list_free(wins);
 388     }
 389 }
 390
 391 void stacking_lower(ObWindow *window)
 392 {
 393     if (WINDOW_IS_CLIENT(window)) {
 394         ObClient *selected;
 395         selected = WINDOW_AS_CLIENT(window);
 396         restack_windows(selected, FALSE);
 397     } else {
 398         GList *wins;
 399         wins = g_list_append(NULL, window);
 400         stacking_list = g_list_remove(stacking_list, window);
 401         do_lower(wins);
 402         g_list_free(wins);
 403     }
 404 }
 405
 406 void stacking_below(ObWindow *window, ObWindow *below)
 407 {
 408     GList *wins, *before;
 409
 410     if (window_layer(window) != window_layer(below))
 411         return;
 412
 413     wins = g_list_append(NULL, window);
 414     stacking_list = g_list_remove(stacking_list, window);
 415     before = g_list_next(g_list_find(stacking_list, below));
 416     do_restack(wins, before);
 417     g_list_free(wins);
 418 }
 419
 420 void stacking_add(ObWindow *win)
 421 {
 422     g_assert(screen_support_win != None); /* make sure I dont break this in the
 423                                              future */
 424
 425     stacking_list = g_list_append(stacking_list, win);
 426     stacking_raise(win);
 427 }
 428
 429 static GList *find_highest_relative(ObClient *client)
 430 {
 431     GList *ret = NULL;
 432
 433     if (client->parents) {
 434         GList *it;
 435         GSList *top;
 436
 437         /* get all top level relatives of this client */
 438         top = client_search_all_top_parents_layer(client);
 439
 440         /* go from the top of the stacking order down */
 441         for (it = stacking_list; !ret && it; it = g_list_next(it)) {
 442             if (WINDOW_IS_CLIENT(it->data)) {
 443                 ObClient *c = it->data;
 444                 /* only look at windows in the same layer and that are
 445                    visible */
 446                 if (c->layer == client->layer &&
 447                     !c->iconic &&
 448                     (c->desktop == client->desktop ||
 449                      c->desktop == DESKTOP_ALL ||
 450                      client->desktop == DESKTOP_ALL))
 451                 {
 452                     GSList *sit;
 453
 454                     /* go through each top level parent and see it this window
 455                        is related to them */
 456                     for (sit = top; !ret && sit; sit = g_slist_next(sit)) {
 457                         ObClient *topc = sit->data;
 458
 459                         /* are they related ? */
 460                         if (topc == c || client_search_transient(topc, c))
 461                             ret = it;
 462                     }
 463                 }
 464             }
 465         }
 466     }
 467     return ret;
 468 }
 469
 470 void stacking_add_nonintrusive(ObWindow *win)
 471 {
 472     ObClient *client;
 473     GList *it_below = NULL; /* this client will be below us */
 474     GList *it_above;
 475     GList *wins;
 476
 477     if (!WINDOW_IS_CLIENT(win)) {
 478         stacking_add(win); /* no special rules for others */
 479         return;
 480     }
 481
 482     client = WINDOW_AS_CLIENT(win);
 483
 484     /* insert above its highest parent (or its highest child !) */
 485     it_below = find_highest_relative(client);
 486
 487     if (!it_below) {
 488         /* nothing to put it directly above, so try find the focused client
 489            to put it underneath it */
 490         if (focus_client && client != focus_client &&
 491             focus_client->layer == client->layer)
 492         {
 493             it_below = g_list_find(stacking_list, focus_client);
 494             /* this can give NULL, but it means the focused window is on the
 495                bottom of the stacking order, so go to the bottom in that case,
 496                below it */
 497             it_below = g_list_next(it_below);
 498         }
 499         else {
 500             /* There is no window to put this directly above, so put it at the
 501                top, so you know it is there.
 502
 503                It used to do this only if the window was focused and lower
 504                it otherwise.
 505
 506                We also put it at the top not the bottom to fix a bug with
 507                fullscreen windows. When focusLast is off and followsMouse is
 508                on, when you switch desktops, the fullscreen window loses
 509                focus and goes into its lower layer. If this puts it at the
 510                bottom then when you come back to the desktop, the window is
 511                at the bottom and won't get focus back.
 512             */
 513             it_below = stacking_list;
 514         }
 515     }
 516
 517     /* make sure it's not in the wrong layer though ! */
 518     for (; it_below; it_below = g_list_next(it_below)) {
 519         /* stop when the window is not in a higher layer than the window
 520            it is going above (it_below) */
 521         if (client->layer >= window_layer(it_below->data))
 522             break;
 523     }
 524     for (; it_below != stacking_list; it_below = it_above) {
 525         /* stop when the window is not in a lower layer than the
 526            window it is going under (it_above) */
 527         it_above = it_below ?
 528             g_list_previous(it_below) : g_list_last(stacking_list);
 529         if (client->layer <= window_layer(it_above->data))
 530             break;
 531     }
 532
 533     wins = g_list_append(NULL, win);
 534     do_restack(wins, it_below);
 535     g_list_free(wins);
 536 }
 537
 538 /*! Returns TRUE if client is occluded by the sibling. If sibling is NULL it
 539   tries against all other clients.
 540 */
 541 static gboolean stacking_occluded(ObClient *client, ObClient *sibling)
 542 {
 543     GList *it;
 544     gboolean occluded = FALSE;
 545     gboolean found = FALSE;
 546
 547     /* no need for any looping in this case */
 548     if (sibling && client->layer != sibling->layer)
 549         return occluded;
 550
 551     for (it = stacking_list; it;
 552          it = (found ? g_list_previous(it) :g_list_next(it)))
 553         if (WINDOW_IS_CLIENT(it->data)) {
 554             ObClient *c = it->data;
 555             if (found && !c->iconic &&
 556                 (c->desktop == DESKTOP_ALL || client->desktop == DESKTOP_ALL ||
 557                  c->desktop == client->desktop) &&
 558                 !client_search_transient(client, c))
 559             {
 560                 if (RECT_INTERSECTS_RECT(c->frame->area, client->frame->area))
 561                 {
 562                     if (sibling != NULL) {
 563                         if (c == sibling) {
 564                             occluded = TRUE;
 565                             break;
 566                         }
 567                     }
 568                     else if (c->layer == client->layer) {
 569                         occluded = TRUE;
 570                         break;
 571                     }
 572                     else if (c->layer > client->layer)
 573                         break; /* we past its layer */
 574                 }
 575             }
 576             else if (c == client)
 577                 found = TRUE;
 578         }
 579     return occluded;
 580 }
 581
 582 /*! Returns TRUE if client occludes the sibling. If sibling is NULL it tries
 583   against all other clients.
 584 */
 585 static gboolean stacking_occludes(ObClient *client, ObClient *sibling)
 586 {
 587     GList *it;
 588     gboolean occludes = FALSE;
 589     gboolean found = FALSE;
 590
 591     /* no need for any looping in this case */
 592     if (sibling && client->layer != sibling->layer)
 593         return occludes;
 594
 595     for (it = stacking_list; it; it = g_list_next(it))
 596         if (WINDOW_IS_CLIENT(it->data)) {
 597             ObClient *c = it->data;
 598             if (found && !c->iconic &&
 599                 (c->desktop == DESKTOP_ALL || client->desktop == DESKTOP_ALL ||
 600                  c->desktop == client->desktop) &&
 601                 !client_search_transient(c, client))
 602             {
 603                 if (RECT_INTERSECTS_RECT(c->frame->area, client->frame->area))
 604                 {
 605                     if (sibling != NULL) {
 606                         if (c == sibling) {
 607                             occludes = TRUE;
 608                             break;
 609                         }
 610                     }
 611                     else if (c->layer == client->layer) {
 612                         occludes = TRUE;
 613                         break;
 614                     }
 615                     else if (c->layer < client->layer)
 616                         break; /* we past its layer */
 617                 }
 618             }
 619             else if (c == client)
 620                 found = TRUE;
 621         }
 622     return occludes;
 623 }
 624
 625 gboolean stacking_restack_request(ObClient *client, ObClient *sibling,
 626                                   gint detail)
 627 {
 628     gboolean ret = FALSE;
 629
 630     if (sibling && ((client->desktop != sibling->desktop &&
 631                      client->desktop != DESKTOP_ALL &&
 632                      sibling->desktop != DESKTOP_ALL) ||
 633                     sibling->iconic))
 634     {
 635         ob_debug("Setting restack sibling to NULL, they are not on the same "
 636                  "desktop or it is iconified\n");
 637         sibling = NULL;
 638     }
 639
 640     switch (detail) {
 641     case Below:
 642         ob_debug("Restack request Below for client %s sibling %s\n",
 643                  client->title, sibling ? sibling->title : "(all)");
 644         /* just lower it */
 645         stacking_lower(CLIENT_AS_WINDOW(client));
 646         ret = TRUE;
 647         break;
 648     case BottomIf:
 649         ob_debug("Restack request BottomIf for client %s sibling "
 650                  "%s\n",
 651                  client->title, sibling ? sibling->title : "(all)");
 652         /* if this client occludes sibling (or anything if NULL), then
 653            lower it to the bottom */
 654         if (stacking_occludes(client, sibling)) {
 655             stacking_lower(CLIENT_AS_WINDOW(client));
 656             ret = TRUE;
 657         }
 658         break;
 659     case Above:
 660         ob_debug("Restack request Above for client %s sibling %s\n",
 661                  client->title, sibling ? sibling->title : "(all)");
 662         stacking_raise(CLIENT_AS_WINDOW(client));
 663         ret = TRUE;
 664         break;
 665     case TopIf:
 666         ob_debug("Restack request TopIf for client %s sibling %s\n",
 667                  client->title, sibling ? sibling->title : "(all)");
 668         if (stacking_occluded(client, sibling)) {
 669             stacking_raise(CLIENT_AS_WINDOW(client));
 670             ret = TRUE;
 671         }
 672         break;
 673     case Opposite:
 674         ob_debug("Restack request Opposite for client %s sibling "
 675                  "%s\n",
 676                  client->title, sibling ? sibling->title : "(all)");
 677         if (stacking_occluded(client, sibling)) {
 678             stacking_raise(CLIENT_AS_WINDOW(client));
 679             ret = TRUE;
 680         }
 681         else if (stacking_occludes(client, sibling)) {
 682             stacking_lower(CLIENT_AS_WINDOW(client));
 683             ret = TRUE;
 684         }
 685         break;
 686     }
 687     return ret;
 688 }