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
 156 /*
 157  *----------------------------------------------------------------------
 158  * moveFrameToUnder--
 159  *      Reestacks windows so that "frame" is under "under".
 160  *
 161  * Returns:
 162  *      None
 163  *
 164  * Side effects:
 165  *      Changes the stacking order of frame.
 166  *----------------------------------------------------------------------
 167  */
 168 void
 169 moveFrameToUnder(WCoreWindow *under, WCoreWindow *frame)
 170 {
 171     Window wins[2];
 172
 173     wins[0] = under->window;
 174     wins[1] = frame->window;
 175     XRestackWindows(dpy, wins, 2);
 176 }
 177
 178 /*
 179  *----------------------------------------------------------------------
 180  * wRaiseFrame--
 181  *      Raises a frame taking the window level and the on_top flag
 182  * into account.
 183  *
 184  * Returns:
 185  *      None
 186  *
 187  * Side effects:
 188  *      Window stacking order and window list is changed.
 189  *
 190  *----------------------------------------------------------------------
 191  */
 192 void
 193 wRaiseFrame(WCoreWindow *frame)
 194 {
 195     WCoreWindow *wlist=frame;
 196     int level = frame->stacking->window_level;
 197     int i;
 198
 199     /* already on top */
 200     if (frame->stacking->above == NULL) {
 201         return;
 202     }
 203
 204     /* insert on top of other windows */
 205     while (wlist)
 206         wlist = wlist->stacking->above;
 207
 208     /* window is inserted before the point found */
 209     if (wlist==NULL) {
 210         /* top most window (last on the list) */
 211         if (frame->stacking->under)
 212           frame->stacking->under->stacking->above = frame->stacking->above;
 213         if (frame->stacking->above)
 214           frame->stacking->above->stacking->under = frame->stacking->under;
 215
 216         frame->stacking->above = NULL;
 217         frame->stacking->under = frame->screen_ptr->stacking_list[level];
 218         frame->screen_ptr->stacking_list[level]->stacking->above=frame;
 219         frame->screen_ptr->stacking_list[level] = frame;
 220     } else if (frame!=wlist) {
 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 = wlist;
 227         frame->stacking->under = wlist->stacking->under;
 228         if (wlist->stacking->under)
 229           wlist->stacking->under->stacking->above = frame;
 230         wlist->stacking->under = frame;
 231     }
 232     if (wPreferences.on_top_transients) {
 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 # if 0
 247         again:
 248         wlist = frame->stacking->under;
 249         while (wlist) {
 250             if (wlist->stacking->child_of == frame) {
 251                 /* transient for us */
 252                 wRaiseFrame(wlist);
 253                 goto again; /* need this or we'll get in a loop */
 254             }
 255             wlist = wlist->stacking->under;
 256         }
 257 #endif
 258     }
 259     /* try to optimize things a little */
 260     if (frame->stacking->above == NULL) {
 261         WCoreWindow *above=NULL;
 262
 263         for (i=level+1; i<MAX_WINDOW_LEVELS; i++) {
 264             if (frame->screen_ptr->stacking_list[i]!=NULL) {
 265                 /* can't optimize */
 266                 above = frame->screen_ptr->stacking_list[i];
 267                 while (above->stacking->under)
 268                     above = above->stacking->under;
 269                 break;
 270             }
 271         }
 272         if (!above) {
 273             XRaiseWindow(dpy, frame->window);
 274         } else {
 275             moveFrameToUnder(above, frame);
 276         }
 277     } else {
 278         moveFrameToUnder(frame->stacking->above, frame);
 279     }
 280 #ifdef KWM_HINTS
 281     {
 282         WWindow *wwin = wWindowFor(frame->window);
 283
 284         if (wwin)
 285             wKWMSendEventMessage(wwin, WKWMRaiseWindow);
 286     }
 287 #endif
 288 }
 289
 290 void
 291 wRaiseLowerFrame(WCoreWindow *frame)
 292 {
 293     if (!frame->stacking->above
 294         ||(frame->stacking->window_level
 295            !=frame->stacking->above->stacking->window_level))
 296       wLowerFrame(frame);
 297     else
 298       wRaiseFrame(frame);
 299 }
 300
 301
 302 void
 303 wLowerFrame(WCoreWindow *frame)
 304 {
 305     WScreen *scr=frame->screen_ptr;
 306     WCoreWindow *prev, *wlist=frame;
 307     int level = frame->stacking->window_level;
 308     int i;
 309
 310     /* already in bottom */
 311     if (wlist->stacking->under==NULL) {
 312         return;
 313     }
 314     if (wPreferences.on_top_transients &&
 315         wlist->stacking->under==wlist->stacking->child_of) {
 316         return;
 317     }
 318     prev = wlist;
 319     /* remove from the list */
 320     if (scr->stacking_list[level] == frame) {
 321         /* it was the top window */
 322         scr->stacking_list[level] = frame->stacking->under;
 323         scr->stacking_list[level]->stacking->above = NULL;
 324     } else {
 325         if (frame->stacking->under)
 326           frame->stacking->under->stacking->above = frame->stacking->above;
 327         if (frame->stacking->above)
 328           frame->stacking->above->stacking->under = frame->stacking->under;
 329     }
 330     wlist = scr->stacking_list[level];
 331     /* look for place to put this window */
 332     if (wPreferences.on_top_transients) {
 333         WCoreWindow *owner = frame->stacking->child_of;
 334
 335         if (owner != wlist) {
 336             while (wlist->stacking->under) {
 337                 /* if this is a transient, it should not be placed under
 338                  * it's owner */
 339                 if (owner == wlist->stacking->under)
 340                   break;
 341                 wlist = wlist->stacking->under;
 342             }
 343         }
 344     } else {
 345         while (wlist->stacking->under) {
 346             wlist = wlist->stacking->under;
 347         }
 348     }
 349     /* insert under the place found */
 350     frame->stacking->above = 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
 356     /* try to optimize things a little */
 357     if (frame->stacking->above == NULL) {
 358         WCoreWindow *above = NULL;
 359         for (i=level-1; i>=0; i--) {
 360             if (scr->stacking_list[i]!=NULL) {
 361                 /* can't optimize */
 362                 above = scr->stacking_list[i];
 363                 while (above->stacking->under)
 364                   above = above->stacking->under;
 365                 break;
 366             }
 367         }
 368         if (!above) {
 369             XLowerWindow(dpy, frame->window);
 370         } else {
 371             moveFrameToUnder(above, frame);
 372         }
 373     } else {
 374         moveFrameToUnder(frame->stacking->above, frame);
 375     }
 376 #ifdef KWM_HINTS
 377     {
 378         WWindow *wwin = wWindowFor(frame->window);
 379
 380         if (wwin)
 381             wKWMSendEventMessage(wwin, WKWMLowerWindow);
 382     }
 383 #endif
 384 }
 385
 386
 387 /*
 388  *----------------------------------------------------------------------
 389  * AddToStackList--
 390  *      Inserts the frame in the top of the stacking list. The
 391  * stacking precedence is obeyed.
 392  *
 393  * Returns:
 394  *      None
 395  *
 396  * Side effects:
 397  *      The frame is added to it's screen's window list.
 398  *----------------------------------------------------------------------
 399  */
 400 void
 401 AddToStackList(WCoreWindow *frame)
 402 {
 403     WCoreWindow *prev, *tmpw, *wlist;
 404     int index = frame->stacking->window_level;
 405
 406     frame->screen_ptr->window_count++;
 407 /*    frame->screen_ptr->window_level_count[index]++;*/
 408     XSaveContext(dpy, frame->window, wStackContext, (XPointer)frame);
 409     tmpw = frame->screen_ptr->stacking_list[index];
 410     if (!tmpw) {
 411         frame->screen_ptr->stacking_list[index] = frame;
 412         frame->stacking->above = NULL;
 413         frame->stacking->under = NULL;
 414         CommitStacking(frame->screen_ptr);
 415         return;
 416     }
 417     prev = tmpw;
 418     /* check if this is a transient owner */
 419     if (wPreferences.on_top_transients) {
 420         WCoreWindow *trans = NULL;
 421
 422         wlist = frame->screen_ptr->stacking_list[index];
 423         while (wlist) {
 424             if (wlist->stacking->child_of == frame)
 425               trans = wlist;
 426             wlist = wlist->stacking->under;
 427         }
 428
 429         frame->stacking->above = trans;
 430         if (trans) {
 431             frame->stacking->under = trans->stacking->under;
 432             if (trans->stacking->under) {
 433                 trans->stacking->under->stacking->above = frame;
 434             }
 435             trans->stacking->under = frame;
 436         } else {
 437             frame->stacking->under = tmpw;
 438             tmpw->stacking->above = frame;
 439             frame->screen_ptr->stacking_list[index] = frame;
 440         }
 441     } else {
 442         /* put on top of the stacking list */
 443         frame->stacking->above = NULL;
 444         frame->stacking->under = tmpw;
 445         tmpw->stacking->above = frame;
 446         frame->screen_ptr->stacking_list[index] = frame;
 447     }
 448     CommitStacking(frame->screen_ptr);
 449 }
 450
 451
 452 /*
 453  *----------------------------------------------------------------------
 454  * MoveInStackListAbove--
 455  *      Moves the frame above "next".
 456  *
 457  * Returns:
 458  *      None
 459  *
 460  * Side effects:
 461  *      Stacking order may be changed.
 462  *      Window level for frame may be changed.
 463  *----------------------------------------------------------------------
 464  */
 465 void
 466 MoveInStackListAbove(WCoreWindow *next, WCoreWindow *frame)
 467 {
 468     WCoreWindow *tmpw;
 469     int index;
 470
 471     if (!next || frame->stacking->under == next)
 472         return;
 473
 474     if (frame->stacking->window_level != next->stacking->window_level)
 475         ChangeStackingLevel(frame, next->stacking->window_level);
 476
 477     index = frame->stacking->window_level;
 478
 479     tmpw = frame->screen_ptr->stacking_list[index];
 480     if (tmpw == frame)
 481         frame->screen_ptr->stacking_list[index] = frame->stacking->under;
 482     if (frame->stacking->under)
 483         frame->stacking->under->stacking->above = frame->stacking->above;
 484     if (frame->stacking->above)
 485         frame->stacking->above->stacking->under = frame->stacking->under;
 486     if (next->stacking->above)
 487         next->stacking->above->stacking->under = frame;
 488     frame->stacking->under = next;
 489     frame->stacking->above = next->stacking->above;
 490     next->stacking->above = frame;
 491     if (tmpw == next)
 492         frame->screen_ptr->stacking_list[index] = frame;
 493
 494     /* try to optimize things a little */
 495     if (frame->stacking->above == NULL) {
 496         WCoreWindow *above=NULL;
 497         int i;
 498
 499         for (i=index+1; i<MAX_WINDOW_LEVELS; i++) {
 500             if (frame->screen_ptr->stacking_list[i]!=NULL) {
 501                 /* can't optimize */
 502                 above = frame->screen_ptr->stacking_list[i];
 503                 while (above->stacking->under)
 504                     above = above->stacking->under;
 505                 break;
 506             }
 507         }
 508         if (!above) {
 509             XRaiseWindow(dpy, frame->window);
 510         } else {
 511             moveFrameToUnder(above, frame);
 512         }
 513     } else {
 514         moveFrameToUnder(frame->stacking->above, frame);
 515     }
 516 }
 517
 518
 519 /*
 520  *----------------------------------------------------------------------
 521  * MoveInStackListUnder--
 522  *      Moves the frame to under "prev".
 523  *
 524  * Returns:
 525  *      None
 526  *
 527  * Side effects:
 528  *      Stacking order may be changed.
 529  *      Window level for frame may be changed.
 530  *----------------------------------------------------------------------
 531  */
 532 void
 533 MoveInStackListUnder(WCoreWindow *prev, WCoreWindow *frame)
 534 {
 535     WCoreWindow *tmpw;
 536     int index;
 537
 538     if (!prev || frame->stacking->above == prev)
 539         return;
 540
 541     if (frame->stacking->window_level != prev->stacking->window_level)
 542         ChangeStackingLevel(frame, prev->stacking->window_level);
 543
 544     index = frame->stacking->window_level;
 545
 546     tmpw = frame->screen_ptr->stacking_list[index];
 547     if (tmpw == frame)
 548         frame->screen_ptr->stacking_list[index] = frame->stacking->under;
 549     if (frame->stacking->under)
 550         frame->stacking->under->stacking->above = frame->stacking->above;
 551     if (frame->stacking->above)
 552         frame->stacking->above->stacking->under = frame->stacking->under;
 553     if (prev->stacking->under)
 554         prev->stacking->under->stacking->above = frame;
 555     frame->stacking->above = prev;
 556     frame->stacking->under = prev->stacking->under;
 557     prev->stacking->under = frame;
 558     moveFrameToUnder(prev, frame);
 559 }
 560
 561
 562 void
 563 RemoveFromStackList(WCoreWindow *frame)
 564 {
 565     int index = frame->stacking->window_level;
 566
 567     if (XDeleteContext(dpy, frame->window, wStackContext)==XCNOENT) {
 568 #ifdef DEBUG0
 569         wwarning("RemoveFromStackingList(): window not in list ");
 570 #endif
 571         return;
 572     }
 573     /* remove from the window stack list */
 574     if (frame->stacking->under)
 575       frame->stacking->under->stacking->above = frame->stacking->above;
 576     if (frame->stacking->above)
 577       frame->stacking->above->stacking->under = frame->stacking->under;
 578     else /* this was the first window on the list */
 579       frame->screen_ptr->stacking_list[index] = frame->stacking->under;
 580
 581     frame->screen_ptr->window_count--;
 582 /*    frame->screen_ptr->window_level_count[index]--;*/
 583 }
 584
 585
 586 void
 587 ChangeStackingLevel(WCoreWindow *frame, int new_level)
 588 {
 589     int old_level;
 590     if (frame->stacking->window_level == new_level)
 591       return;
 592     old_level = frame->stacking->window_level;
 593
 594     RemoveFromStackList(frame);
 595     frame->stacking->window_level = new_level;
 596     AddToStackList(frame);
 597     if (old_level > new_level) {
 598         wRaiseFrame(frame);
 599     } else {
 600         wLowerFrame(frame);
 601     }
 602 }