src/stacking.c

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