src/stacking.c

   1 /*
   2  *  Window Maker window manager
   3  *
   4  *  Copyright (c) 1997-2003 Alfredo K. Kojima
   5  *  Copyright (c) 1998-2003 Dan Pascu
   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  *  You should have received a copy of the GNU General Public License along
  18  *  with this program; if not, write to the Free Software Foundation, Inc.,
  19  *  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  20  */
  21
  22 #include "wconfig.h"
  23
  24 #include <stdio.h>
  25 #include <stdlib.h>
  26 #include <string.h>
  27 #include <X11/Xlib.h>
  28 #include <X11/Xutil.h>
  29
  30 #include "WindowMaker.h"
  31 #include "screen.h"
  32 #include "window.h"
  33 #include "actions.h"
  34 #include "properties.h"
  35 #include "stacking.h"
  36 #include "workspace.h"
  37
  38 /*** Global Variables ***/
  39 extern XContext wStackContext;
  40
  41 static void notifyStackChange(WCoreWindow * frame, char *detail)
  42 {
  43         WWindow *wwin = wWindowFor(frame->window);
  44
  45         WMPostNotificationName(WMNChangedStacking, wwin, detail);
  46 }
  47
  48 /*
  49  *----------------------------------------------------------------------
  50  * RemakeStackList--
  51  *      Remakes the stacking_list for the screen, getting the real
  52  * stacking order from the server and reordering windows that are not
  53  * in the correct stacking.
  54  *
  55  * Side effects:
  56  *      The stacking order list and the actual window stacking
  57  * may be changed (corrected)
  58  *
  59  *----------------------------------------------------------------------
  60  */
  61 void RemakeStackList(WScreen * scr)
  62 {
  63         Window *windows;
  64         unsigned int nwindows;
  65         Window junkr, junkp;
  66         WCoreWindow *frame;
  67         WCoreWindow *tmp;
  68         int level;
  69         int i, c;
  70
  71         if (!XQueryTree(dpy, scr->root_win, &junkr, &junkp, &windows, &nwindows)) {
  72                 wwarning(_("could not get window list!!"));
  73                 return;
  74         } else {
  75                 WMEmptyBag(scr->stacking_list);
  76
  77                 /* verify list integrity */
  78                 c = 0;
  79                 for (i = 0; i < nwindows; i++) {
  80                         if (XFindContext(dpy, windows[i], wStackContext, (XPointer *) & frame)
  81                             == XCNOENT) {
  82                                 continue;
  83                         }
  84                         if (!frame)
  85                                 continue;
  86                         c++;
  87                         level = frame->stacking->window_level;
  88                         tmp = WMGetFromBag(scr->stacking_list, level);
  89                         if (tmp)
  90                                 tmp->stacking->above = frame;
  91                         frame->stacking->under = tmp;
  92                         frame->stacking->above = NULL;
  93                         WMSetInBag(scr->stacking_list, level, frame);
  94                 }
  95                 XFree(windows);
  96                 scr->window_count = c;
  97         }
  98
  99         CommitStacking(scr);
 100 }
 101
 102 /*
 103  *----------------------------------------------------------------------
 104  * CommitStacking--
 105  *      Reorders the actual window stacking, so that it has the stacking
 106  * order in the internal window stacking lists. It does the opposite
 107  * of RemakeStackList().
 108  *
 109  * Side effects:
 110  *      Windows may be restacked.
 111  *----------------------------------------------------------------------
 112  */
 113 void CommitStacking(WScreen * scr)
 114 {
 115         WCoreWindow *tmp;
 116         int nwindows, i;
 117         Window *windows;
 118         WMBagIterator iter;
 119
 120         nwindows = scr->window_count;
 121         windows = wmalloc(sizeof(Window) * nwindows);
 122
 123         i = 0;
 124         WM_ETARETI_BAG(scr->stacking_list, tmp, iter) {
 125                 while (tmp) {
 126                         windows[i++] = tmp->window;
 127                         tmp = tmp->stacking->under;
 128                 }
 129         }
 130         XRestackWindows(dpy, windows, i);
 131         wfree(windows);
 132         WMPostNotificationName(WMNResetStacking, scr, NULL);
 133 }
 134
 135 /*
 136  *----------------------------------------------------------------------
 137  * moveFrameToUnder--
 138  *      Reestacks windows so that "frame" is under "under".
 139  *
 140  * Returns:
 141  *      None
 142  *
 143  * Side effects:
 144  *      Changes the stacking order of frame.
 145  *----------------------------------------------------------------------
 146  */
 147 static void moveFrameToUnder(WCoreWindow * under, WCoreWindow * frame)
 148 {
 149         Window wins[2];
 150
 151         wins[0] = under->window;
 152         wins[1] = frame->window;
 153         XRestackWindows(dpy, wins, 2);
 154 }
 155
 156 /*
 157  *----------------------------------------------------------------------
 158  * CommitStackingForWindow--
 159  *      Reorders the stacking for the specified window, so that it has the
 160  * stacking order in the internal window stacking lists.
 161  *
 162  * Side effects:
 163  *      Windows may be restacked.
 164  *----------------------------------------------------------------------
 165  */
 166 void CommitStackingForWindow(WCoreWindow * frame)
 167 {
 168         int level = frame->stacking->window_level;
 169         WScreen *scr = frame->screen_ptr;
 170
 171         if (frame->stacking->above == NULL) {
 172                 WMBagIterator iter;
 173                 WCoreWindow *above = WMBagLast(scr->stacking_list, &iter);
 174                 int i, last = above->stacking->window_level;
 175
 176                 /* find the 1st level above us which has windows in it */
 177                 for (i = level + 1, above = NULL; i <= last; i++) {
 178                         above = WMGetFromBag(scr->stacking_list, i);
 179                         if (above != NULL)
 180                                 break;
 181                 }
 182
 183                 if (above != frame && above != NULL) {
 184                         while (above->stacking->under)
 185                                 above = above->stacking->under;
 186                         moveFrameToUnder(above, frame);
 187                 } else {
 188                         /* no window above us */
 189                         XRaiseWindow(dpy, frame->window);
 190                 }
 191         } else {
 192                 moveFrameToUnder(frame->stacking->above, frame);
 193         }
 194 }
 195
 196 /*
 197  *----------------------------------------------------------------------
 198  * wRaiseFrame--
 199  *      Raises a frame taking the window level into account.
 200  *
 201  * Returns:
 202  *      None
 203  *
 204  * Side effects:
 205  *      Window stacking order and stacking list are changed.
 206  *
 207  *----------------------------------------------------------------------
 208  */
 209 void wRaiseFrame(WCoreWindow * frame)
 210 {
 211         WCoreWindow *wlist = frame;
 212         int level = frame->stacking->window_level;
 213         WScreen *scr = frame->screen_ptr;
 214
 215         /* already on top */
 216         if (frame->stacking->above == NULL) {
 217                 return;
 218         }
 219
 220         /* insert it on top of other windows on the same level */
 221         if (frame->stacking->under)
 222                 frame->stacking->under->stacking->above = frame->stacking->above;
 223         if (frame->stacking->above)
 224                 frame->stacking->above->stacking->under = frame->stacking->under;
 225
 226         frame->stacking->above = NULL;
 227         frame->stacking->under = WMGetFromBag(scr->stacking_list, level);
 228         if (frame->stacking->under) {
 229                 frame->stacking->under->stacking->above = frame;
 230         }
 231         WMSetInBag(scr->stacking_list, level, frame);
 232
 233         /* raise transients under us from bottom to top
 234          * so that the order is kept */
 235  again:
 236         wlist = frame->stacking->under;
 237         while (wlist && wlist->stacking->under)
 238                 wlist = wlist->stacking->under;
 239         while (wlist && wlist != frame) {
 240                 if (wlist->stacking->child_of == frame) {
 241                         wRaiseFrame(wlist);
 242                         goto again;
 243                 }
 244                 wlist = wlist->stacking->above;
 245         }
 246
 247         /* try to optimize things a little */
 248         if (frame->stacking->above == NULL) {
 249                 WMBagIterator iter;
 250                 WCoreWindow *above = WMBagLast(scr->stacking_list, &iter);
 251                 int i, last = above->stacking->window_level;
 252
 253                 /* find the 1st level above us which has windows in it */
 254                 for (i = level + 1, above = NULL; i <= last; i++) {
 255                         above = WMGetFromBag(scr->stacking_list, i);
 256                         if (above != NULL)
 257                                 break;
 258                 }
 259
 260                 if (above != frame && above != NULL) {
 261                         while (above->stacking->under)
 262                                 above = above->stacking->under;
 263                         moveFrameToUnder(above, frame);
 264                 } else {
 265                         /* no window above us */
 266                         above = NULL;
 267                         XRaiseWindow(dpy, frame->window);
 268                 }
 269         } else {
 270                 moveFrameToUnder(frame->stacking->above, frame);
 271         }
 272
 273         notifyStackChange(frame, "raise");
 274 }
 275
 276 void wRaiseLowerFrame(WCoreWindow * frame)
 277 {
 278         if (!frame->stacking->above
 279             || (frame->stacking->window_level != frame->stacking->above->stacking->window_level)) {
 280
 281                 wLowerFrame(frame);
 282         } else {
 283                 WCoreWindow *scan = frame->stacking->above;
 284                 WWindow *frame_wwin = (WWindow *) frame->descriptor.parent;
 285
 286                 while (scan) {
 287
 288                         if (scan->descriptor.parent_type == WCLASS_WINDOW) {
 289                                 WWindow *scan_wwin = (WWindow *) scan->descriptor.parent;
 290
 291                                 if (wWindowObscuresWindow(scan_wwin, frame_wwin)
 292                                     && scan_wwin->flags.mapped) {
 293                                         break;
 294                                 }
 295                         }
 296                         scan = scan->stacking->above;
 297                 }
 298
 299                 if (scan) {
 300                         wRaiseFrame(frame);
 301                 } else {
 302                         wLowerFrame(frame);
 303                 }
 304         }
 305 }
 306
 307 void wLowerFrame(WCoreWindow * frame)
 308 {
 309         WScreen *scr = frame->screen_ptr;
 310         WCoreWindow *wlist = frame;
 311         int level = frame->stacking->window_level;
 312
 313         /* already in bottom */
 314         if (wlist->stacking->under == NULL) {
 315                 return;
 316         }
 317         /* cant lower transient below below its owner */
 318         if (wlist->stacking->under == wlist->stacking->child_of) {
 319                 return;
 320         }
 321         /* remove from the list */
 322         if (WMGetFromBag(scr->stacking_list, level) == frame) {
 323                 /* it was the top window */
 324                 WMSetInBag(scr->stacking_list, level, frame->stacking->under);
 325                 frame->stacking->under->stacking->above = NULL;
 326         } else {
 327                 if (frame->stacking->under)
 328                         frame->stacking->under->stacking->above = frame->stacking->above;
 329                 if (frame->stacking->above)
 330                         frame->stacking->above->stacking->under = frame->stacking->under;
 331         }
 332         wlist = WMGetFromBag(scr->stacking_list, level);
 333
 334         /* look for place to put this window */
 335         if (wlist) {
 336                 WCoreWindow *owner = frame->stacking->child_of;
 337
 338                 if (owner != wlist) {
 339                         while (wlist->stacking->under) {
 340                                 /* if this is a transient, it should not be placed under
 341                                  * it's owner */
 342                                 if (owner == wlist->stacking->under)
 343                                         break;
 344                                 wlist = wlist->stacking->under;
 345                         }
 346                 }
 347         }
 348         /* insert under the place found */
 349         frame->stacking->above = wlist;
 350         if (wlist) {
 351                 frame->stacking->under = wlist->stacking->under;
 352                 if (wlist->stacking->under)
 353                         wlist->stacking->under->stacking->above = frame;
 354                 wlist->stacking->under = frame;
 355         } else {
 356                 frame->stacking->under = NULL;
 357         }
 358
 359         if (frame->stacking->above == NULL) {
 360                 WMBagIterator iter;
 361                 WCoreWindow *above = WMBagLast(scr->stacking_list, &iter);
 362                 int i, last = above->stacking->window_level;
 363
 364                 /* find the 1st level above us which has windows in it */
 365                 for (i = level + 1, above = NULL; i <= last; i++) {
 366                         above = WMGetFromBag(scr->stacking_list, i);
 367                         if (above != NULL)
 368                                 break;
 369                 }
 370
 371                 if (above != frame && above != NULL) {
 372                         while (above->stacking->under)
 373                                 above = above->stacking->under;
 374                         moveFrameToUnder(above, frame);
 375                 } else {
 376                         /* no window below us */
 377                         XLowerWindow(dpy, frame->window);
 378                 }
 379         } else {
 380                 moveFrameToUnder(frame->stacking->above, frame);
 381         }
 382
 383         notifyStackChange(frame, "lower");
 384 }
 385
 386 /*
 387  *----------------------------------------------------------------------
 388  * AddToStackList--
 389  *      Inserts the frame in the top of the stacking list. The
 390  * stacking precedence is obeyed.
 391  *
 392  * Returns:
 393  *      None
 394  *
 395  * Side effects:
 396  *      The frame is added to it's screen's window list.
 397  *----------------------------------------------------------------------
 398  */
 399 void AddToStackList(WCoreWindow * frame)
 400 {
 401         WCoreWindow *curtop, *wlist;
 402         int index = frame->stacking->window_level;
 403         WScreen *scr = frame->screen_ptr;
 404         WCoreWindow *trans = NULL;
 405
 406         frame->screen_ptr->window_count++;
 407         XSaveContext(dpy, frame->window, wStackContext, (XPointer) frame);
 408         curtop = WMGetFromBag(scr->stacking_list, index);
 409
 410         /* first window in this level */
 411         if (curtop == NULL) {
 412                 WMSetInBag(scr->stacking_list, index, frame);
 413                 frame->stacking->above = NULL;
 414                 frame->stacking->under = NULL;
 415                 CommitStacking(scr);
 416                 return;
 417         }
 418
 419         /* check if this is a transient owner */
 420         wlist = curtop;
 421         while (wlist) {
 422                 if (wlist->stacking->child_of == frame)
 423                         trans = wlist;
 424                 wlist = wlist->stacking->under;
 425         }
 426         /* trans will hold the transient in the lowest position
 427          * in stacking list */
 428
 429         frame->stacking->above = trans;
 430         if (trans != NULL) {
 431                 /* window is owner of a transient.. put it below
 432                  * the lowest transient */
 433                 frame->stacking->under = trans->stacking->under;
 434                 if (trans->stacking->under) {
 435                         trans->stacking->under->stacking->above = frame;
 436                 }
 437                 trans->stacking->under = frame;
 438         } else {
 439                 /* window is not owner of transients.. just put it in the
 440                  * top of other windows */
 441                 frame->stacking->under = curtop;
 442                 curtop->stacking->above = frame;
 443                 WMSetInBag(scr->stacking_list, index, frame);
 444         }
 445         CommitStacking(scr);
 446 }
 447
 448 /*
 449  *----------------------------------------------------------------------
 450  * MoveInStackListAbove--
 451  *      Moves the frame above "next".
 452  *
 453  * Returns:
 454  *      None
 455  *
 456  * Side effects:
 457  *      Stacking order may be changed.
 458  *      Window level for frame may be changed.
 459  *----------------------------------------------------------------------
 460  */
 461 void MoveInStackListAbove(WCoreWindow * next, WCoreWindow * frame)
 462 {
 463         WCoreWindow *tmpw;
 464         WScreen *scr = frame->screen_ptr;
 465         int index;
 466
 467         if (!next || frame->stacking->under == next)
 468                 return;
 469
 470         if (frame->stacking->window_level != next->stacking->window_level)
 471                 ChangeStackingLevel(frame, next->stacking->window_level);
 472
 473         index = frame->stacking->window_level;
 474
 475         tmpw = WMGetFromBag(scr->stacking_list, index);
 476         if (tmpw == frame)
 477                 WMSetInBag(scr->stacking_list, index, frame->stacking->under);
 478         if (frame->stacking->under)
 479                 frame->stacking->under->stacking->above = frame->stacking->above;
 480         if (frame->stacking->above)
 481                 frame->stacking->above->stacking->under = frame->stacking->under;
 482         if (next->stacking->above)
 483                 next->stacking->above->stacking->under = frame;
 484         frame->stacking->under = next;
 485         frame->stacking->above = next->stacking->above;
 486         next->stacking->above = frame;
 487         if (tmpw == next)
 488                 WMSetInBag(scr->stacking_list, index, frame);
 489
 490         /* try to optimize things a little */
 491         if (frame->stacking->above == NULL) {
 492                 WCoreWindow *above = NULL;
 493                 WMBagIterator iter;
 494
 495                 for (above = WMBagIteratorAtIndex(scr->stacking_list, index + 1, &iter);
 496                      above != NULL; above = WMBagNext(scr->stacking_list, &iter)) {
 497
 498                         /* can't optimize */
 499                         while (above->stacking->under)
 500                                 above = above->stacking->under;
 501                         break;
 502                 }
 503                 if (above == NULL) {
 504                         XRaiseWindow(dpy, frame->window);
 505                 } else {
 506                         moveFrameToUnder(above, frame);
 507                 }
 508         } else {
 509                 moveFrameToUnder(frame->stacking->above, frame);
 510         }
 511
 512         WMPostNotificationName(WMNResetStacking, scr, NULL);
 513 }
 514
 515 /*
 516  *----------------------------------------------------------------------
 517  * MoveInStackListUnder--
 518  *      Moves the frame to under "prev".
 519  *
 520  * Returns:
 521  *      None
 522  *
 523  * Side effects:
 524  *      Stacking order may be changed.
 525  *      Window level for frame may be changed.
 526  *----------------------------------------------------------------------
 527  */
 528 void MoveInStackListUnder(WCoreWindow * prev, WCoreWindow * frame)
 529 {
 530         WCoreWindow *tmpw;
 531         int index;
 532         WScreen *scr = frame->screen_ptr;
 533
 534         if (!prev || frame->stacking->above == prev)
 535                 return;
 536
 537         if (frame->stacking->window_level != prev->stacking->window_level)
 538                 ChangeStackingLevel(frame, prev->stacking->window_level);
 539
 540         index = frame->stacking->window_level;
 541
 542         tmpw = WMGetFromBag(scr->stacking_list, index);
 543         if (tmpw == frame)
 544                 WMSetInBag(scr->stacking_list, index, frame->stacking->under);
 545         if (frame->stacking->under)
 546                 frame->stacking->under->stacking->above = frame->stacking->above;
 547         if (frame->stacking->above)
 548                 frame->stacking->above->stacking->under = frame->stacking->under;
 549         if (prev->stacking->under)
 550                 prev->stacking->under->stacking->above = frame;
 551         frame->stacking->above = prev;
 552         frame->stacking->under = prev->stacking->under;
 553         prev->stacking->under = frame;
 554         moveFrameToUnder(prev, frame);
 555
 556         WMPostNotificationName(WMNResetStacking, scr, NULL);
 557 }
 558
 559 void RemoveFromStackList(WCoreWindow * frame)
 560 {
 561         int index = frame->stacking->window_level;
 562
 563         if (XDeleteContext(dpy, frame->window, wStackContext) == XCNOENT) {
 564                 wwarning("RemoveFromStackingList(): window not in list ");
 565                 return;
 566         }
 567         /* remove from the window stack list */
 568         if (frame->stacking->under)
 569                 frame->stacking->under->stacking->above = frame->stacking->above;
 570         if (frame->stacking->above)
 571                 frame->stacking->above->stacking->under = frame->stacking->under;
 572         else                    /* this was the first window on the list */
 573                 WMSetInBag(frame->screen_ptr->stacking_list, index, frame->stacking->under);
 574
 575         frame->screen_ptr->window_count--;
 576
 577         WMPostNotificationName(WMNResetStacking, frame->screen_ptr, NULL);
 578 }
 579
 580 void ChangeStackingLevel(WCoreWindow * frame, int new_level)
 581 {
 582         int old_level;
 583
 584         if (frame->stacking->window_level == new_level)
 585                 return;
 586         old_level = frame->stacking->window_level;
 587
 588         RemoveFromStackList(frame);
 589         frame->stacking->window_level = new_level;
 590         AddToStackList(frame);
 591         if (old_level > new_level) {
 592                 wRaiseFrame(frame);
 593         } else {
 594                 wLowerFrame(frame);
 595         }
 596 }