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