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