src/stacking.c

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