src/actions.c

   1 /* action.c- misc. window commands (miniaturize, hide etc.)
   2  *
   3  *  Window Maker window manager
   4  *
   5  *  Copyright (c) 1997, 1998 Alfredo K. Kojima
   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
  26 #include <X11/Xlib.h>
  27 #include <X11/Xutil.h>
  28 #include <stdlib.h>
  29 #include <stdio.h>
  30 #include <unistd.h>
  31 #include <math.h>
  32 #include <time.h>
  33
  34 #include "WindowMaker.h"
  35 #include "wcore.h"
  36 #include "framewin.h"
  37 #include "window.h"
  38 #include "client.h"
  39 #include "icon.h"
  40 #include "funcs.h"
  41 #include "application.h"
  42 #include "actions.h"
  43 #include "stacking.h"
  44 #include "appicon.h"
  45 #include "dock.h"
  46 #include "appmenu.h"
  47 #include "winspector.h"
  48 #include "list.h"
  49 #include "workspace.h"
  50
  51 #ifdef GNOME_STUFF
  52 # include "gnome.h"
  53 #endif
  54 #ifdef KWM_HINTS
  55 # include "kwm.h"
  56 #endif
  57
  58 #ifdef WMSOUND
  59 #include "wmsound.h"
  60 #endif
  61
  62
  63 /****** Global Variables ******/
  64 extern Time LastTimestamp;
  65 extern Time LastFocusChange;
  66
  67 extern Cursor wCursor[WCUR_LAST];
  68
  69 extern WPreferences wPreferences;
  70
  71 extern Atom _XA_WM_TAKE_FOCUS;
  72
  73
  74 /******* Local Variables *******/
  75 static struct {
  76     int steps;
  77     int delay;
  78 } shadePars[5] = {
  79     {SHADE_STEPS_UF, SHADE_DELAY_UF},
  80     {SHADE_STEPS_F, SHADE_DELAY_F},
  81     {SHADE_STEPS_M, SHADE_DELAY_M},
  82     {SHADE_STEPS_S, SHADE_DELAY_S},
  83     {SHADE_STEPS_U, SHADE_DELAY_U}};
  84
  85 #define SHADE_STEPS     shadePars[(int)wPreferences.shade_speed].steps
  86 #define SHADE_DELAY     shadePars[(int)wPreferences.shade_speed].delay
  87
  88
  89 static int ignoreTimestamp=0;
  90
  91
  92 #ifdef ANIMATIONS
  93 static void
  94 processEvents(int event_count)
  95 {
  96     XEvent event;
  97
  98     /*
  99      * This is a hack. When animations are enabled, processing of
 100      * events ocurred during a animation are delayed until it's end.
 101      * Calls that consider the TimeStamp, like XSetInputFocus(), will
 102      * fail because the TimeStamp is too old. Then, for example, if
 103      * the user changes window focus while a miniaturize animation is
 104      * in course, the window will not get focus properly after the end
 105      * of the animation. This tries to workaround it by passing CurrentTime
 106      * as the TimeStamp for XSetInputFocus() for all events ocurred during
 107      * the animation.
 108      */
 109     ignoreTimestamp=1;
 110     while (XPending(dpy) && event_count--) {
 111         WMNextEvent(dpy, &event);
 112         WMHandleEvent(&event);
 113     }
 114     ignoreTimestamp=0;
 115 }
 116 #endif /* ANIMATIONS */
 117
 118
 119
 120 /*
 121  *----------------------------------------------------------------------
 122  * wSetFocusTo--
 123  *      Changes the window focus to the one passed as argument.
 124  * If the window to focus is not already focused, it will be brought
 125  * to the head of the list of windows. Previously focused window is
 126  * unfocused.
 127  *
 128  * Side effects:
 129  *      Window list may be reordered and the window focus is changed.
 130  *
 131  *----------------------------------------------------------------------
 132  */
 133 void
 134 wSetFocusTo(WScreen *scr, WWindow  *wwin)
 135 {
 136     WWindow *focused=scr->focused_window;
 137     int timestamp=LastTimestamp;
 138     WApplication *oapp=NULL, *napp=NULL;
 139     int wasfocused;
 140
 141     LastFocusChange = timestamp;
 142
 143 /*
 144  * This is a hack, because XSetInputFocus() should have a proper
 145  * timestamp instead of CurrentTime but it seems that some times
 146  * clients will not receive focus properly that way.
 147     if (ignoreTimestamp)
 148 */
 149       timestamp = CurrentTime;
 150
 151     if (focused)
 152         oapp = wApplicationOf(focused->main_window);
 153
 154     if (wwin == NULL) {
 155         XSetInputFocus(dpy, scr->no_focus_win, RevertToParent, timestamp);
 156         if (focused) {
 157             wWindowUnfocus(focused);
 158         }
 159         if (oapp) {
 160             wAppMenuUnmap(oapp->menu);
 161 #ifdef NEWAPPICON
 162             wApplicationDeactivate(oapp);
 163 #endif
 164         }
 165 #ifdef KWM_HINTS
 166         wKWMUpdateActiveWindowHint(scr);
 167         wKWMSendEventMessage(NULL, WKWMFocusWindow);
 168 #endif
 169         return;
 170     }
 171     wasfocused = wwin->flags.focused;
 172     napp = wApplicationOf(wwin->main_window);
 173
 174     /* remember last workspace where the app has been */
 175     if (napp)
 176         napp->last_workspace = wwin->screen_ptr->current_workspace;
 177
 178     if (WFLAGP(wwin, no_focusable))
 179         return;
 180
 181     if (wwin->flags.mapped /*&& !WFLAGP(wwin, no_focusable)*/) {
 182         /* install colormap if colormap mode is lock mode */
 183         if (wPreferences.colormap_mode==WKF_CLICK)
 184             wColormapInstallForWindow(scr, wwin);
 185
 186         /* set input focus */
 187         switch (wwin->focus_mode) {
 188          case WFM_NO_INPUT:
 189             XSetInputFocus(dpy, scr->no_focus_win, RevertToParent, timestamp);
 190             break;
 191
 192          case WFM_PASSIVE:
 193          case WFM_LOCALLY_ACTIVE:
 194             XSetInputFocus(dpy, wwin->client_win, RevertToParent, timestamp);
 195             break;
 196
 197          case WFM_GLOBALLY_ACTIVE:
 198             break;
 199         }
 200         XFlush(dpy);
 201         if (wwin->protocols.TAKE_FOCUS) {
 202             wClientSendProtocol(wwin, _XA_WM_TAKE_FOCUS, timestamp);
 203         }
 204         XSync(dpy, False);
 205     } else {
 206         XSetInputFocus(dpy, scr->no_focus_win, RevertToParent, timestamp);
 207     }
 208
 209     /* if this is not the focused window focus it */
 210     if (focused!=wwin) {
 211         /* change the focus window list order */
 212         if (wwin->prev)
 213           wwin->prev->next = wwin->next;
 214
 215         if (wwin->next)
 216           wwin->next->prev = wwin->prev;
 217
 218         wwin->prev = focused;
 219         focused->next = wwin;
 220         wwin->next = NULL;
 221         scr->focused_window = wwin;
 222
 223         if (oapp && oapp != napp) {
 224             wAppMenuUnmap(oapp->menu);
 225 #ifdef NEWAPPICON
 226             wApplicationDeactivate(oapp);
 227 #endif
 228         }
 229     }
 230
 231     wWindowFocus(wwin, focused);
 232
 233     if (napp && !wasfocused) {
 234         wAppMenuMap(napp->menu, wwin);
 235 #ifdef NEWAPPICON
 236         wApplicationActivate(napp);
 237 #endif
 238     }
 239 #ifdef KWM_HINTS
 240     wKWMUpdateActiveWindowHint(scr);
 241     wKWMSendEventMessage(wwin, WKWMFocusWindow);
 242 #endif
 243     XFlush(dpy);
 244 }
 245
 246
 247 void
 248 wShadeWindow(WWindow  *wwin)
 249 {
 250     time_t time0 = time(NULL);
 251 #ifdef ANIMATIONS
 252     int y, s, w, h;
 253 #endif
 254
 255     if (wwin->flags.shaded)
 256         return;
 257
 258     XLowerWindow(dpy, wwin->client_win);
 259
 260 #ifdef WMSOUND
 261     wSoundPlay(WMSOUND_SHADE);
 262 #endif
 263
 264 #ifdef ANIMATIONS
 265     if (!wwin->screen_ptr->flags.startup && !wwin->flags.skip_next_animation
 266         && !wPreferences.no_animations) {
 267         /* do the shading animation */
 268         h = wwin->frame->core->height;
 269         s = h/SHADE_STEPS;
 270         if (s < 1) s=1;
 271         w = wwin->frame->core->width;
 272         y = wwin->frame->top_width;
 273         while (h>wwin->frame->top_width+1) {
 274             XMoveWindow(dpy, wwin->client_win, 0, y);
 275             XResizeWindow(dpy, wwin->frame->core->window, w, h);
 276             XFlush(dpy);
 277
 278             if (time(NULL)-time0 > MAX_ANIMATION_TIME)
 279                 break;
 280
 281             if (SHADE_DELAY > 0)
 282                 wusleep(SHADE_DELAY*1000L);
 283             h-=s;
 284             y-=s;
 285         }
 286         XMoveWindow(dpy, wwin->client_win, 0, wwin->frame->top_width);
 287     }
 288 #endif  /* ANIMATIONS */
 289
 290     wwin->flags.skip_next_animation = 0;
 291     wwin->flags.shaded = 1;
 292     wwin->flags.mapped = 0;
 293     /* prevent window withdrawal when getting UnmapNotify */
 294     XSelectInput(dpy, wwin->client_win,
 295                  wwin->event_mask & ~StructureNotifyMask);
 296     XUnmapWindow(dpy, wwin->client_win);
 297     XSelectInput(dpy, wwin->client_win, wwin->event_mask);
 298
 299     /* for the client it's just like iconification */
 300     wFrameWindowResize(wwin->frame, wwin->frame->core->width,
 301                        wwin->frame->top_width - 1);
 302
 303     wwin->client.y = wwin->frame_y - wwin->client.height
 304         + wwin->frame->top_width;
 305     wWindowSynthConfigureNotify(wwin);
 306
 307     /*
 308     wClientSetState(wwin, IconicState, None);
 309      */
 310
 311 #ifdef GNOME_STUFF
 312     wGNOMEUpdateClientStateHint(wwin, False);
 313 #endif
 314 #ifdef KWM_HINTS
 315     wKWMUpdateClientStateHint(wwin, KWMIconifiedFlag);
 316     wKWMSendEventMessage(wwin, WKWMChangedClient);
 317 #endif
 318     /* update window list to reflect shaded state */
 319     UpdateSwitchMenu(wwin->screen_ptr, wwin, ACTION_CHANGE_STATE);
 320
 321 #ifdef ANIMATIONS
 322     if (!wwin->screen_ptr->flags.startup) {
 323         /* Look at processEvents() for reason of this code. */
 324         XSync(dpy, 0);
 325         processEvents(XPending(dpy));
 326     }
 327 #endif
 328 }
 329
 330
 331 void
 332 wUnshadeWindow(WWindow  *wwin)
 333 {
 334     time_t time0 = time(NULL);
 335 #ifdef ANIMATIONS
 336     int y, s, w, h;
 337 #endif /* ANIMATIONS */
 338
 339
 340     if (!wwin->flags.shaded)
 341         return;
 342
 343     wwin->flags.shaded = 0;
 344     wwin->flags.mapped = 1;
 345     XMapWindow(dpy, wwin->client_win);
 346
 347 #ifdef WMSOUND
 348     wSoundPlay(WMSOUND_UNSHADE);
 349 #endif
 350
 351 #ifdef ANIMATIONS
 352     if (!wPreferences.no_animations && !wwin->flags.skip_next_animation) {
 353         /* do the shading animation */
 354         h = wwin->frame->top_width + wwin->frame->bottom_width;
 355         y = wwin->frame->top_width - wwin->client.height;
 356         s = abs(y)/SHADE_STEPS;
 357         if (s<1) s=1;
 358         w = wwin->frame->core->width;
 359         XMoveWindow(dpy, wwin->client_win, 0, y);
 360         if (s>0) {
 361             while (h < wwin->client.height + wwin->frame->top_width
 362                    + wwin->frame->bottom_width) {
 363                 XResizeWindow(dpy, wwin->frame->core->window, w, h);
 364                 XMoveWindow(dpy, wwin->client_win, 0, y);
 365                 XSync(dpy, 0);
 366                 if (SHADE_DELAY > 0)
 367                     wusleep(SHADE_DELAY*2000L/3);
 368                 h+=s;
 369                 y+=s;
 370
 371                 if (time(NULL)-time0 > MAX_ANIMATION_TIME)
 372                     break;
 373             }
 374         }
 375         XMoveWindow(dpy, wwin->client_win, 0, wwin->frame->top_width);
 376     }
 377 #endif /* ANIMATIONS */
 378
 379     wwin->flags.skip_next_animation = 0;
 380     wFrameWindowResize(wwin->frame, wwin->frame->core->width,
 381                        wwin->frame->top_width + wwin->client.height
 382                        + wwin->frame->bottom_width);
 383
 384     wwin->client.y = wwin->frame_y + wwin->frame->top_width;
 385     wWindowSynthConfigureNotify(wwin);
 386
 387     /*
 388     wClientSetState(wwin, NormalState, None);
 389      */
 390     /* if the window is focused, set the focus again as it was disabled during
 391      * shading */
 392     if (wwin->flags.focused)
 393         wSetFocusTo(wwin->screen_ptr, wwin);
 394
 395 #ifdef GNOME_STUFF
 396     wGNOMEUpdateClientStateHint(wwin, False);
 397 #endif
 398 #ifdef KWM_HINTS
 399     wKWMUpdateClientStateHint(wwin, KWMIconifiedFlag);
 400     wKWMSendEventMessage(wwin, WKWMChangedClient);
 401 #endif
 402
 403     /* update window list to reflect unshaded state */
 404     UpdateSwitchMenu(wwin->screen_ptr, wwin, ACTION_CHANGE_STATE);
 405
 406 }
 407
 408
 409 void
 410 wMaximizeWindow(WWindow *wwin, int directions)
 411 {
 412     int new_width, new_height, new_x, new_y;
 413     WArea usableArea = wwin->screen_ptr->totalUsableArea;
 414
 415
 416     if (WFLAGP(wwin, no_resizable))
 417         return;
 418
 419
 420     if (WFLAGP(wwin, full_maximize)) {
 421         usableArea.x1 = 0;
 422         usableArea.y1 = 0;
 423         usableArea.x2 = wwin->screen_ptr->scr_width;
 424         usableArea.y2 = wwin->screen_ptr->scr_height;
 425     }
 426
 427     if (wwin->flags.shaded) {
 428         wwin->flags.skip_next_animation = 1;
 429         wUnshadeWindow(wwin);
 430     }
 431     wwin->flags.maximized = directions;
 432     wwin->old_geometry.width = wwin->client.width;
 433     wwin->old_geometry.height = wwin->client.height;
 434     wwin->old_geometry.x = wwin->frame_x;
 435     wwin->old_geometry.y = wwin->frame_y;
 436
 437 #ifdef KWM_HINTS
 438     wKWMUpdateClientGeometryRestore(wwin);
 439 #endif
 440
 441     if (directions & MAX_HORIZONTAL) {
 442
 443         new_width = (usableArea.x2-usableArea.x1)-FRAME_BORDER_WIDTH*2;
 444         new_x = usableArea.x1;
 445
 446     } else {
 447
 448         new_x = wwin->frame_x;
 449         new_width = wwin->frame->core->width;
 450
 451     }
 452
 453     if (directions & MAX_VERTICAL) {
 454
 455         new_height = (usableArea.y2-usableArea.y1)-FRAME_BORDER_WIDTH*2;
 456         new_y = usableArea.y1;
 457         if (WFLAGP(wwin, full_maximize))
 458             new_y -= wwin->frame->top_width;
 459
 460     } else {
 461
 462         new_y = wwin->frame_y;
 463         new_height = wwin->frame->core->height;
 464
 465     }
 466
 467     if (!WFLAGP(wwin, full_maximize)) {
 468         new_height -= wwin->frame->top_width+wwin->frame->bottom_width;
 469     }
 470
 471     wWindowConstrainSize(wwin, &new_width, &new_height);
 472     wWindowConfigure(wwin, new_x, new_y, new_width, new_height);
 473
 474 #ifdef GNOME_STUFF
 475     wGNOMEUpdateClientStateHint(wwin, False);
 476 #endif
 477 #ifdef KWM_HINTS
 478     wKWMUpdateClientStateHint(wwin, KWMMaximizedFlag);
 479     wKWMSendEventMessage(wwin, WKWMChangedClient);
 480 #endif
 481
 482 #ifdef WMSOUND
 483     wSoundPlay(WMSOUND_MAXIMIZE);
 484 #endif
 485 }
 486
 487
 488 void
 489 wUnmaximizeWindow(WWindow *wwin)
 490 {
 491     int restore_x, restore_y;
 492
 493     if (!wwin->flags.maximized)
 494         return;
 495
 496     if (wwin->flags.shaded) {
 497         wwin->flags.skip_next_animation = 1;
 498         wUnshadeWindow(wwin);
 499     }
 500     restore_x = (wwin->flags.maximized & MAX_HORIZONTAL) ?
 501         wwin->old_geometry.x : wwin->frame_x;
 502     restore_y = (wwin->flags.maximized & MAX_VERTICAL) ?
 503         wwin->old_geometry.y : wwin->frame_y;
 504     wwin->flags.maximized = 0;
 505     wWindowConfigure(wwin, restore_x, restore_y,
 506                      wwin->old_geometry.width, wwin->old_geometry.height);
 507
 508 #ifdef GNOME_STUFF
 509     wGNOMEUpdateClientStateHint(wwin, False);
 510 #endif
 511 #ifdef KWM_HINTS
 512     wKWMUpdateClientStateHint(wwin, KWMMaximizedFlag);
 513     wKWMSendEventMessage(wwin, WKWMChangedClient);
 514 #endif
 515
 516 #ifdef WMSOUND
 517     wSoundPlay(WMSOUND_UNMAXIMIZE);
 518 #endif
 519 }
 520
 521 #ifdef ANIMATIONS
 522 static void
 523 animateResizeFlip(WScreen *scr, int x, int y, int w, int h,
 524                   int fx, int fy, int fw, int fh, int steps)
 525 {
 526 #define FRAMES (MINIATURIZE_ANIMATION_FRAMES_F)
 527     float cx, cy, cw, ch;
 528     float xstep, ystep, wstep, hstep;
 529     XPoint points[5];
 530     float dx, dch, midy;
 531     float angle, final_angle, delta;
 532
 533     xstep = (float)(fx-x)/steps;
 534     ystep = (float)(fy-y)/steps;
 535     wstep = (float)(fw-w)/steps;
 536     hstep = (float)(fh-h)/steps;
 537
 538     cx = (float)x;
 539     cy = (float)y;
 540     cw = (float)w;
 541     ch = (float)h;
 542
 543     final_angle = 2*WM_PI*MINIATURIZE_ANIMATION_TWIST_F;
 544     delta = (float)(final_angle/FRAMES);
 545     for (angle=0;; angle+=delta) {
 546         if (angle > final_angle)
 547             angle = final_angle;
 548
 549         dx = (cw/10) - ((cw/5) * sin(angle));
 550         dch = (ch/2) * cos(angle);
 551         midy = cy + (ch/2);
 552
 553         points[0].x = cx + dx;      points[0].y = midy - dch;
 554         points[1].x = cx + cw - dx; points[1].y = points[0].y;
 555         points[2].x = cx + cw + dx; points[2].y = midy + dch;
 556         points[3].x = cx - dx;      points[3].y = points[2].y;
 557         points[4].x = points[0].x;  points[4].y = points[0].y;
 558
 559         XGrabServer(dpy);
 560         XDrawLines(dpy,scr->root_win,scr->frame_gc,points, 5, CoordModeOrigin);
 561         XFlush(dpy);
 562 #if (MINIATURIZE_ANIMATION_DELAY_F > 0)
 563         wusleep(MINIATURIZE_ANIMATION_DELAY_F);
 564 #endif
 565
 566         XDrawLines(dpy,scr->root_win,scr->frame_gc,points, 5, CoordModeOrigin);
 567         XUngrabServer(dpy);
 568         cx+=xstep;
 569         cy+=ystep;
 570         cw+=wstep;
 571         ch+=hstep;
 572         if (angle >= final_angle)
 573           break;
 574
 575     }
 576     XFlush(dpy);
 577 }
 578 #undef FRAMES
 579
 580
 581 static void
 582 animateResizeTwist(WScreen *scr, int x, int y, int w, int h,
 583                    int fx, int fy, int fw, int fh, int steps)
 584 {
 585 #define FRAMES (MINIATURIZE_ANIMATION_FRAMES_T)
 586     float cx, cy, cw, ch;
 587     float xstep, ystep, wstep, hstep;
 588     XPoint points[5];
 589     float angle, final_angle, a, d, delta;
 590
 591     x += w/2;
 592     y += h/2;
 593     fx += fw/2;
 594     fy += fh/2;
 595
 596     xstep = (float)(fx-x)/steps;
 597     ystep = (float)(fy-y)/steps;
 598     wstep = (float)(fw-w)/steps;
 599     hstep = (float)(fh-h)/steps;
 600
 601     cx = (float)x;
 602     cy = (float)y;
 603     cw = (float)w;
 604     ch = (float)h;
 605
 606     final_angle = 2*WM_PI*MINIATURIZE_ANIMATION_TWIST_T;
 607     delta =  (float)(final_angle/FRAMES);
 608     for (angle=0;; angle+=delta) {
 609         if (angle > final_angle)
 610             angle = final_angle;
 611
 612         a = atan(ch/cw);
 613         d = sqrt((cw/2)*(cw/2)+(ch/2)*(ch/2));
 614
 615         points[0].x = cx+cos(angle-a)*d;
 616         points[0].y = cy+sin(angle-a)*d;
 617         points[1].x = cx+cos(angle+a)*d;
 618         points[1].y = cy+sin(angle+a)*d;
 619         points[2].x = cx+cos(angle-a+WM_PI)*d;
 620         points[2].y = cy+sin(angle-a+WM_PI)*d;
 621         points[3].x = cx+cos(angle+a+WM_PI)*d;
 622         points[3].y = cy+sin(angle+a+WM_PI)*d;
 623         points[4].x = cx+cos(angle-a)*d;
 624         points[4].y = cy+sin(angle-a)*d;
 625         XGrabServer(dpy);
 626         XDrawLines(dpy, scr->root_win, scr->frame_gc, points, 5, CoordModeOrigin);
 627         XFlush(dpy);
 628 #if (MINIATURIZE_ANIMATION_DELAY_T > 0)
 629         wusleep(MINIATURIZE_ANIMATION_DELAY_T);
 630 #endif
 631
 632         XDrawLines(dpy, scr->root_win, scr->frame_gc, points, 5, CoordModeOrigin);
 633         XUngrabServer(dpy);
 634         cx+=xstep;
 635         cy+=ystep;
 636         cw+=wstep;
 637         ch+=hstep;
 638         if (angle >= final_angle)
 639           break;
 640
 641     }
 642     XFlush(dpy);
 643 }
 644 #undef FRAMES
 645
 646
 647 static void
 648 animateResizeZoom(WScreen *scr, int x, int y, int w, int h,
 649                   int fx, int fy, int fw, int fh, int steps)
 650 {
 651 #define FRAMES (MINIATURIZE_ANIMATION_FRAMES_Z)
 652     float cx[FRAMES], cy[FRAMES], cw[FRAMES], ch[FRAMES];
 653     float xstep, ystep, wstep, hstep;
 654     int i, j;
 655
 656     xstep = (float)(fx-x)/steps;
 657     ystep = (float)(fy-y)/steps;
 658     wstep = (float)(fw-w)/steps;
 659     hstep = (float)(fh-h)/steps;
 660
 661     for (j=0; j<FRAMES; j++) {
 662         cx[j] = (float)x;
 663         cy[j] = (float)y;
 664         cw[j] = (float)w;
 665         ch[j] = (float)h;
 666     }
 667     XGrabServer(dpy);
 668     for (i=0; i<steps; i++) {
 669         for (j=0; j<FRAMES; j++) {
 670             XDrawRectangle(dpy, scr->root_win, scr->frame_gc,
 671                            (int)cx[j], (int)cy[j], (int)cw[j], (int)ch[j]);
 672         }
 673         XFlush(dpy);
 674 #if (MINIATURIZE_ANIMATION_DELAY_Z > 0)
 675         wusleep(MINIATURIZE_ANIMATION_DELAY_Z);
 676 #endif
 677         for (j=0; j<FRAMES; j++) {
 678             XDrawRectangle(dpy, scr->root_win, scr->frame_gc,
 679                            (int)cx[j], (int)cy[j], (int)cw[j], (int)ch[j]);
 680             if (j<FRAMES-1) {
 681                 cx[j]=cx[j+1];
 682                 cy[j]=cy[j+1];
 683                 cw[j]=cw[j+1];
 684                 ch[j]=ch[j+1];
 685             } else {
 686                 cx[j]+=xstep;
 687                 cy[j]+=ystep;
 688                 cw[j]+=wstep;
 689                 ch[j]+=hstep;
 690             }
 691         }
 692     }
 693
 694     for (j=0; j<FRAMES; j++) {
 695         XDrawRectangle(dpy, scr->root_win, scr->frame_gc,
 696                        (int)cx[j], (int)cy[j], (int)cw[j], (int)ch[j]);
 697     }
 698     XFlush(dpy);
 699 #if (MINIATURIZE_ANIMATION_DELAY_Z > 0)
 700     wusleep(MINIATURIZE_ANIMATION_DELAY_Z);
 701 #endif
 702     for (j=0; j<FRAMES; j++) {
 703         XDrawRectangle(dpy, scr->root_win, scr->frame_gc,
 704                        (int)cx[j], (int)cy[j], (int)cw[j], (int)ch[j]);
 705     }
 706
 707     XUngrabServer(dpy);
 708 }
 709 #undef FRAMES
 710
 711
 712 static void
 713 animateResize(WScreen *scr, int x, int y, int w, int h,
 714               int fx, int fy, int fw, int fh, int hiding)
 715 {
 716     int style = wPreferences.iconification_style; /* Catch the value */
 717     int steps, k;
 718
 719     if (style == WIS_NONE)
 720         return;
 721
 722     if (style == WIS_RANDOM) {
 723         style = rand()%3;
 724     }
 725
 726     k = (hiding ? 2 : 3);
 727     switch(style) {
 728     case WIS_TWIST:
 729         steps = (MINIATURIZE_ANIMATION_STEPS_T * k)/3;
 730         if (steps>0)
 731             animateResizeTwist(scr, x, y, w, h, fx, fy, fw, fh, steps);
 732         break;
 733     case WIS_FLIP:
 734         steps = (MINIATURIZE_ANIMATION_STEPS_F * k)/3;
 735         if (steps>0)
 736             animateResizeFlip(scr, x, y, w, h, fx, fy, fw, fh, steps);
 737         break;
 738     case WIS_ZOOM:
 739     default:
 740         steps = (MINIATURIZE_ANIMATION_STEPS_Z * k)/3;
 741         if (steps>0)
 742             animateResizeZoom(scr, x, y, w, h, fx, fy, fw, fh, steps);
 743         break;
 744     }
 745 }
 746 #endif /* ANIMATIONS */
 747
 748
 749 static void
 750 flushExpose()
 751 {
 752     XEvent tmpev;
 753
 754     while (XCheckTypedEvent(dpy, Expose, &tmpev))
 755         WMHandleEvent(&tmpev);
 756     XSync(dpy, 0);
 757 }
 758
 759 static void
 760 unmapTransientsFor(WWindow *wwin)
 761 {
 762     WWindow *tmp;
 763
 764
 765     tmp = wwin->screen_ptr->focused_window;
 766     while (tmp) {
 767         /* unmap the transients for this transient */
 768         if (tmp!=wwin && tmp->transient_for == wwin->client_win
 769             && (tmp->flags.mapped || wwin->screen_ptr->flags.startup
 770                 || tmp->flags.shaded)) {
 771             unmapTransientsFor(tmp);
 772             tmp->flags.miniaturized = 1;
 773             if (!tmp->flags.shaded) {
 774                 wWindowUnmap(tmp);
 775             } else {
 776                 XUnmapWindow(dpy, tmp->frame->core->window);
 777             }
 778             /*
 779             if (!tmp->flags.shaded)
 780              */
 781                 wClientSetState(tmp, IconicState, None);
 782 #ifdef KWM_HINTS
 783             wKWMUpdateClientStateHint(tmp, KWMIconifiedFlag);
 784             wKWMSendEventMessage(tmp, WKWMRemoveWindow);
 785             tmp->flags.kwm_hidden_for_modules = 1;
 786 #endif
 787
 788             UpdateSwitchMenu(wwin->screen_ptr, tmp, ACTION_CHANGE_STATE);
 789
 790         }
 791         tmp = tmp->prev;
 792     }
 793 }
 794
 795
 796 static void
 797 mapTransientsFor(WWindow *wwin)
 798 {
 799     WWindow *tmp;
 800
 801     tmp = wwin->screen_ptr->focused_window;
 802     while (tmp) {
 803         /* recursively map the transients for this transient */
 804         if (tmp!=wwin && tmp->transient_for == wwin->client_win
 805             && /*!tmp->flags.mapped*/ tmp->flags.miniaturized
 806             && tmp->icon==NULL) {
 807             mapTransientsFor(tmp);
 808             tmp->flags.miniaturized = 0;
 809             if (!tmp->flags.shaded) {
 810                 wWindowMap(tmp);
 811             } else {
 812                 XMapWindow(dpy, tmp->frame->core->window);
 813             }
 814             tmp->flags.semi_focused = 0;
 815             /*
 816             if (!tmp->flags.shaded)
 817              */
 818                 wClientSetState(tmp, NormalState, None);
 819 #ifdef KWM_HINTS
 820             wKWMUpdateClientStateHint(tmp, KWMIconifiedFlag);
 821             if (tmp->flags.kwm_hidden_for_modules) {
 822                 wKWMSendEventMessage(tmp, WKWMAddWindow);
 823                 tmp->flags.kwm_hidden_for_modules = 0;
 824             }
 825 #endif
 826
 827             UpdateSwitchMenu(wwin->screen_ptr, tmp, ACTION_CHANGE_STATE);
 828
 829         }
 830         tmp = tmp->prev;
 831     }
 832 }
 833
 834 #if 0
 835 static void
 836 setupIconGrabs(WIcon *icon)
 837 {
 838     /* setup passive grabs on the icon */
 839     XGrabButton(dpy, Button1, AnyModifier, icon->core->window, True,
 840                 ButtonPressMask, GrabModeSync, GrabModeAsync, None, None);
 841     XGrabButton(dpy, Button2, AnyModifier, icon->core->window, True,
 842                 ButtonPressMask, GrabModeSync, GrabModeAsync, None, None);
 843     XGrabButton(dpy, Button3, AnyModifier, icon->core->window, True,
 844                 ButtonPressMask, GrabModeSync, GrabModeAsync, None, None);
 845     XSync(dpy, 0);
 846 }
 847 #endif
 848
 849 static WWindow*
 850 recursiveTransientFor(WWindow *wwin)
 851 {
 852     int i;
 853
 854     if (!wwin)
 855         return None;
 856
 857     /* hackish way to detect transient_for cycle */
 858     i = wwin->screen_ptr->window_count+1;
 859
 860     while (wwin && wwin->transient_for != None && i>0) {
 861         wwin = wWindowFor(wwin->transient_for);
 862         i--;
 863     }
 864     if (i==0 && wwin) {
 865         wwarning("%s has a severely broken WM_TRANSIENT_FOR hint.",
 866                  wwin->frame->title);
 867         return NULL;
 868     }
 869
 870     return wwin;
 871 }
 872
 873 #if 0
 874 static void
 875 removeIconGrabs(WIcon *icon)
 876 {
 877     /* remove passive grabs on the icon */
 878     XUngrabButton(dpy, Button1, AnyModifier, icon->core->window);
 879     XUngrabButton(dpy, Button2, AnyModifier, icon->core->window);
 880     XUngrabButton(dpy, Button3, AnyModifier, icon->core->window);
 881     XSync(dpy, 0);
 882 }
 883 #endif
 884
 885
 886 void
 887 wIconifyWindow(WWindow *wwin)
 888 {
 889     XWindowAttributes attribs;
 890     int present;
 891
 892
 893     if (!XGetWindowAttributes(dpy, wwin->client_win, &attribs)) {
 894         /* the window doesn't exist anymore */
 895         return;
 896     }
 897
 898     if (wwin->flags.miniaturized) {
 899         return;
 900     }
 901
 902
 903     if (wwin->transient_for!=None) {
 904         WWindow *owner = wWindowFor(wwin->transient_for);
 905
 906         if (owner && owner->flags.miniaturized)
 907             return;
 908     }
 909
 910     present = wwin->frame->workspace==wwin->screen_ptr->current_workspace;
 911
 912     /* if the window is in another workspace, simplify process */
 913     if (present) {
 914         /* icon creation may take a while */
 915         XGrabPointer(dpy, wwin->screen_ptr->root_win, False,
 916                      ButtonMotionMask|ButtonReleaseMask, GrabModeAsync,
 917                      GrabModeAsync, None, None, CurrentTime);
 918     }
 919
 920     if (!wwin->flags.icon_moved) {
 921         PlaceIcon(wwin->screen_ptr, &wwin->icon_x, &wwin->icon_y);
 922     }
 923     wwin->icon = wIconCreate(wwin);
 924
 925     wwin->flags.miniaturized = 1;
 926     wwin->flags.mapped = 0;
 927
 928     /* unmap transients */
 929
 930     unmapTransientsFor(wwin);
 931
 932     if (present) {
 933 #ifdef WMSOUND
 934         wSoundPlay(WMSOUND_ICONIFY);
 935 #endif
 936
 937         XUngrabPointer(dpy, CurrentTime);
 938         wWindowUnmap(wwin);
 939         /* let all Expose events arrive so that we can repaint
 940          * something before the animation starts (and the server is grabbed) */
 941         XSync(dpy, 0);
 942         wClientSetState(wwin, IconicState, wwin->icon->icon_win);
 943         flushExpose();
 944 #ifdef ANIMATIONS
 945         if (!wwin->screen_ptr->flags.startup && !wwin->flags.skip_next_animation
 946             && !wPreferences.no_animations) {
 947             animateResize(wwin->screen_ptr, wwin->frame_x, wwin->frame_y,
 948                           wwin->frame->core->width, wwin->frame->core->height,
 949                           wwin->icon_x, wwin->icon_y,
 950                           wwin->icon->core->width, wwin->icon->core->height,
 951                           False);
 952         }
 953 #endif
 954     }
 955
 956     wwin->flags.skip_next_animation = 0;
 957     if (wwin->screen_ptr->current_workspace==wwin->frame->workspace ||
 958         IS_OMNIPRESENT(wwin) || wPreferences.sticky_icons)
 959
 960         XMapWindow(dpy, wwin->icon->core->window);
 961     AddToStackList(wwin->icon->core);
 962
 963     wLowerFrame(wwin->icon->core);
 964
 965     if (present) {
 966         WWindow *owner = recursiveTransientFor(wwin->screen_ptr->focused_window);
 967
 968 /*
 969  * It doesn't seem to be working and causes button event hangup
 970  * when deiconifying a transient window.
 971  setupIconGrabs(wwin->icon);
 972  */
 973         if ((wwin->flags.focused
 974              || (owner && wwin->client_win == owner->client_win))
 975             && wPreferences.focus_mode==WKF_CLICK) {
 976             WWindow *tmp;
 977
 978             tmp = wwin->prev;
 979             while (tmp) {
 980                 if (!WFLAGP(tmp, no_focusable)
 981                     && !(tmp->flags.hidden||tmp->flags.miniaturized))
 982                     break;
 983                 tmp = tmp->prev;
 984             }
 985             wSetFocusTo(wwin->screen_ptr, tmp);
 986         } else if (wPreferences.focus_mode!=WKF_CLICK) {
 987             wSetFocusTo(wwin->screen_ptr, NULL);
 988         }
 989
 990 #ifdef ANIMATIONS
 991         if (!wwin->screen_ptr->flags.startup) {
 992             Window clientwin = wwin->client_win;
 993
 994             XSync(dpy, 0);
 995             processEvents(XPending(dpy));
 996
 997             /* the window can disappear while doing the processEvents() */
 998             if (!wWindowFor(clientwin))
 999                 return;
1000         }
1001 #endif
1002     }
1003
1004
1005     if (wwin->flags.selected)
1006         wIconSelect(wwin->icon);
1007
1008 #ifdef GNOME_STUFF
1009     wGNOMEUpdateClientStateHint(wwin, False);
1010 #endif
1011 #ifdef KWM_HINTS
1012     wKWMUpdateClientStateHint(wwin, KWMIconifiedFlag);
1013     wKWMSendEventMessage(wwin, WKWMChangedClient);
1014 #endif
1015
1016     UpdateSwitchMenu(wwin->screen_ptr, wwin, ACTION_CHANGE_STATE);
1017
1018 }
1019
1020
1021 void
1022 wDeiconifyWindow(WWindow  *wwin)
1023 {
1024     wWindowChangeWorkspace(wwin, wwin->screen_ptr->current_workspace);
1025
1026     if (!wwin->flags.miniaturized)
1027         return;
1028
1029     if (wwin->transient_for != None
1030         && wwin->transient_for != wwin->screen_ptr->root_win) {
1031         WWindow *owner = recursiveTransientFor(wwin);
1032
1033         if (owner && owner->flags.miniaturized) {
1034             wDeiconifyWindow(owner);
1035             wSetFocusTo(wwin->screen_ptr, wwin);
1036             wRaiseFrame(wwin->frame->core);
1037             return;
1038         }
1039     }
1040
1041     wwin->flags.miniaturized = 0;
1042     if (!wwin->flags.shaded)
1043         wwin->flags.mapped = 1;
1044
1045     if (wwin->icon->selected)
1046         wIconSelect(wwin->icon);
1047
1048     XUnmapWindow(dpy, wwin->icon->core->window);
1049
1050 #ifdef WMSOUND
1051     wSoundPlay(WMSOUND_DEICONIFY);
1052 #endif
1053
1054     /* if the window is in another workspace, do it silently */
1055 #ifdef ANIMATIONS
1056     if (!wwin->screen_ptr->flags.startup && !wPreferences.no_animations
1057         && !wwin->flags.skip_next_animation) {
1058         animateResize(wwin->screen_ptr, wwin->icon_x, wwin->icon_y,
1059                       wwin->icon->core->width, wwin->icon->core->height,
1060                       wwin->frame_x, wwin->frame_y,
1061                       wwin->frame->core->width, wwin->frame->core->height,
1062                       False);
1063     }
1064 #endif /* ANIMATIONS */
1065     wwin->flags.skip_next_animation = 0;
1066     XGrabServer(dpy);
1067     if (!wwin->flags.shaded) {
1068         XMapWindow(dpy, wwin->client_win);
1069     }
1070     XMapWindow(dpy, wwin->frame->core->window);
1071     wRaiseFrame(wwin->frame->core);
1072     if (!wwin->flags.shaded) {
1073         wClientSetState(wwin, NormalState, None);
1074     }
1075     mapTransientsFor(wwin);
1076     RemoveFromStackList(wwin->icon->core);
1077 /*    removeIconGrabs(wwin->icon);*/
1078     wIconDestroy(wwin->icon);
1079     wwin->icon = NULL;
1080
1081     XUngrabServer(dpy);
1082     if (wPreferences.focus_mode==WKF_CLICK
1083         || wPreferences.focus_mode==WKF_SLOPPY)
1084       wSetFocusTo(wwin->screen_ptr, wwin);
1085
1086 #ifdef ANIMATIONS
1087     if (!wwin->screen_ptr->flags.startup) {
1088         Window clientwin = wwin->client_win;
1089
1090         XSync(dpy, 0);
1091         processEvents(XPending(dpy));
1092
1093         if (!wWindowFor(clientwin))
1094             return;
1095     }
1096 #endif
1097
1098     if (wPreferences.auto_arrange_icons) {
1099         wArrangeIcons(wwin->screen_ptr, True);
1100     }
1101
1102 #ifdef GNOME_STUFF
1103     wGNOMEUpdateClientStateHint(wwin, False);
1104 #endif
1105 #ifdef KWM_HINTS
1106     wKWMUpdateClientStateHint(wwin, KWMIconifiedFlag);
1107     wKWMSendEventMessage(wwin, WKWMChangedClient);
1108 #endif
1109
1110     UpdateSwitchMenu(wwin->screen_ptr, wwin, ACTION_CHANGE_STATE);
1111 }
1112
1113
1114
1115 static void
1116 hideWindow(WIcon *icon, int icon_x, int icon_y, WWindow *wwin, int animate)
1117 {
1118     if (wwin->flags.miniaturized) {
1119         /* XXX wrong fix, can cause side effects, must remove 'if' */
1120         if (wwin->icon) {
1121             XUnmapWindow(dpy, wwin->icon->core->window);
1122             wwin->icon->mapped = 0;
1123         }
1124         wwin->flags.hidden = 1;
1125 #ifdef GNOME_STUFF
1126         wGNOMEUpdateClientStateHint(wwin, False);
1127 #endif
1128
1129         UpdateSwitchMenu(wwin->screen_ptr, wwin, ACTION_CHANGE_STATE);
1130
1131         return;
1132     }
1133
1134     if (wwin->flags.inspector_open) {
1135         WWindow *pwin = wwin->inspector->frame;
1136
1137         wWindowUnmap(pwin);
1138         pwin->flags.hidden = 1;
1139
1140         wClientSetState(pwin, IconicState, icon->icon_win);
1141     }
1142
1143     wwin->flags.hidden = 1;
1144     wWindowUnmap(wwin);
1145
1146     wClientSetState(wwin, IconicState, icon->icon_win);
1147     flushExpose();
1148 #ifdef WMSOUND
1149     wSoundPlay(WMSOUND_HIDE);
1150 #endif
1151 #ifdef ANIMATIONS
1152     if (!wwin->screen_ptr->flags.startup && !wPreferences.no_animations &&
1153         !wwin->flags.skip_next_animation && animate) {
1154         animateResize(wwin->screen_ptr, wwin->frame_x, wwin->frame_y,
1155                       wwin->frame->core->width, wwin->frame->core->height,
1156                       icon_x, icon_y, icon->core->width, icon->core->height,
1157                       True);
1158     }
1159 #endif
1160     wwin->flags.skip_next_animation = 0;
1161
1162 #ifdef GNOME_STUFF
1163     wGNOMEUpdateClientStateHint(wwin, False);
1164 #endif
1165
1166     UpdateSwitchMenu(wwin->screen_ptr, wwin, ACTION_CHANGE_STATE);
1167 }
1168
1169
1170
1171 void
1172 wHideOtherApplications(WWindow *awin)
1173 {
1174     WWindow *wwin;
1175     WApplication *tapp;
1176 #ifdef REDUCE_APPICONS
1177     char *tinstance, *tclass;
1178     unsigned int brokenwin = 0, match = 0;
1179 #endif
1180
1181     if (!awin)
1182         return;
1183     wwin = awin->screen_ptr->focused_window;
1184
1185 #ifdef REDUCE_APPICONS
1186     if (awin->wm_instance == NULL || awin->wm_class == NULL)
1187         brokenwin++;
1188 #endif
1189
1190     while (wwin) {
1191         if (wwin!=awin
1192             && wwin->frame->workspace == awin->screen_ptr->current_workspace
1193             && !(wwin->flags.miniaturized||wwin->flags.hidden)
1194             && !wwin->flags.internal_window
1195             && (!wwin->flags.inspector_open || wwin->inspector->frame!=awin)
1196             && !WFLAGP(wwin, no_hide_others)) {
1197
1198 #ifdef REDUCE_APPICONS
1199             match = 0;
1200             if (!brokenwin) {
1201                 if ((tinstance = wwin->wm_instance) == NULL)
1202                     tinstance = "";
1203                 if ((tclass = wwin->wm_class) == NULL)
1204                     tclass = "";
1205                 if ((strcmp(awin->wm_instance, tinstance) == 0) &&
1206                     (strcmp(awin->wm_class, tclass) == 0) )
1207                         match++;
1208             }
1209 #endif
1210
1211             if (wwin->main_window==None || WFLAGP(wwin, no_appicon)) {
1212                 if (!WFLAGP(wwin, no_miniaturizable)) {
1213                     wwin->flags.skip_next_animation = 1;
1214                     wIconifyWindow(wwin);
1215                 }
1216             } else if (wwin->main_window!=None
1217 #ifndef REDUCE_APPICONS
1218                        && awin->main_window != wwin->main_window) {
1219 #else
1220                         && (awin->main_window != wwin->main_window && !match)) {
1221 #endif
1222                 tapp = wApplicationOf(wwin->main_window);
1223                 if (tapp) {
1224                     tapp->flags.skip_next_animation = 1;
1225                     wHideApplication(tapp);
1226                 } else {
1227                     if (!WFLAGP(wwin, no_miniaturizable)) {
1228                         wwin->flags.skip_next_animation = 1;
1229                          wIconifyWindow(wwin);
1230                     }
1231                 }
1232             }
1233         }
1234         wwin = wwin->prev;
1235     }
1236     /*
1237     wSetFocusTo(awin->screen_ptr, awin);
1238      */
1239 }
1240
1241
1242
1243 void
1244 wHideApplication(WApplication *wapp)
1245 {
1246 #ifdef REDUCE_APPICONS
1247     WApplication *tapp;
1248     char *tinstance, *tclass;
1249     unsigned int nowmhints = 0, matchwmhints = 0, matchworkspace = 0;
1250 #endif
1251     WScreen *scr;
1252     WWindow *wlist;
1253     int hadfocus;
1254
1255     if (!wapp) {
1256         wwarning("trying to hide a non grouped window");
1257         return;
1258     }
1259     if (!wapp->main_window_desc) {
1260         wwarning("group leader not found for window group");
1261         return;
1262     }
1263 #ifdef REDUCE_APPICONS
1264     if ((wapp->main_window_desc->wm_instance == NULL) ||
1265         (wapp->main_window_desc->wm_class == NULL))
1266         nowmhints++;
1267 #endif
1268     scr = wapp->main_window_desc->screen_ptr;
1269     hadfocus = 0;
1270     wlist = scr->focused_window;
1271     if (!wlist)
1272         return;
1273
1274     if (wlist->main_window == wapp->main_window)
1275         wapp->last_focused = wlist;
1276     else
1277         wapp->last_focused = NULL;
1278     while (wlist) {
1279 #ifdef REDUCE_APPICONS
1280         matchwmhints = matchworkspace = 0;
1281         if (!nowmhints) {
1282             tapp = wApplicationOf(wlist->main_window);
1283             tinstance = tclass = NULL;
1284             if (tapp) {
1285                 if (tapp->main_window_desc) {
1286                     tinstance = tapp->main_window_desc->wm_instance;
1287                     tclass = tapp->main_window_desc->wm_class;
1288                 }
1289             }
1290             if (tapp == NULL || tinstance == NULL || tclass == NULL) {
1291                 /* Should never reach here */
1292                 tinstance = "";
1293                 tclass = "";
1294             }
1295             if ((strcmp(tinstance, wapp->main_window_desc->wm_instance) == 0) &&
1296                 (strcmp(tclass, wapp->main_window_desc->wm_class) == 0) )
1297                 matchwmhints++;
1298         }
1299         if (wlist->frame) {
1300             if (wlist->frame->workspace == wapp->main_window_desc->screen_ptr->current_workspace)
1301                 matchworkspace++;
1302         }
1303         if ((wlist->main_window == wapp->main_window || matchwmhints) &&
1304             matchworkspace) {
1305 #ifdef I_HATE_THIS
1306         }
1307 #endif
1308 #else
1309         if (wlist->main_window == wapp->main_window) {
1310 #endif
1311             if (wlist->flags.focused) {
1312                 hadfocus = 1;
1313             }
1314             if (wapp->app_icon)
1315                 hideWindow(wapp->app_icon->icon, wapp->app_icon->x_pos,
1316                            wapp->app_icon->y_pos, wlist,
1317                            !wapp->flags.skip_next_animation);
1318         }
1319         wlist = wlist->prev;
1320     }
1321
1322     wapp->flags.skip_next_animation = 0;
1323
1324     if (hadfocus) {
1325         if (wPreferences.focus_mode==WKF_CLICK) {
1326             wlist = scr->focused_window;
1327             while (wlist) {
1328                 if (!WFLAGP(wlist, no_focusable) && !wlist->flags.hidden
1329                     && (wlist->flags.mapped || wlist->flags.shaded))
1330                   break;
1331                 wlist = wlist->prev;
1332             }
1333             wSetFocusTo(scr, wlist);
1334         } else {
1335             wSetFocusTo(scr, NULL);
1336         }
1337     }
1338
1339     wapp->flags.hidden = 1;
1340
1341     if(wPreferences.auto_arrange_icons) {
1342         wArrangeIcons(scr, True);
1343     }
1344 #ifdef HIDDENDOT
1345     wAppIconPaint(wapp->app_icon);
1346 #endif
1347 }
1348
1349
1350
1351
1352 static void
1353 unhideWindow(WIcon *icon, int icon_x, int icon_y, WWindow *wwin, int animate,
1354              int bringToCurrentWS)
1355 {
1356     if (bringToCurrentWS)
1357         wWindowChangeWorkspace(wwin, wwin->screen_ptr->current_workspace);
1358
1359     wwin->flags.hidden=0;
1360     wwin->flags.mapped=1;
1361
1362 #ifdef WMSOUND
1363     wSoundPlay(WMSOUND_UNHIDE);
1364 #endif
1365 #ifdef ANIMATIONS
1366     if (!wwin->screen_ptr->flags.startup && !wPreferences.no_animations
1367         && animate) {
1368         animateResize(wwin->screen_ptr, icon_x, icon_y,
1369                       icon->core->width, icon->core->height,
1370                       wwin->frame_x, wwin->frame_y,
1371                       wwin->frame->core->width, wwin->frame->core->height,
1372                       True);
1373     }
1374 #endif
1375     wwin->flags.skip_next_animation = 0;
1376     XMapWindow(dpy, wwin->client_win);
1377     XMapWindow(dpy, wwin->frame->core->window);
1378     wClientSetState(wwin, NormalState, None);
1379     wRaiseFrame(wwin->frame->core);
1380     if (wwin->flags.inspector_open) {
1381         WWindow *pwin = wwin->inspector->frame;
1382
1383         pwin->flags.hidden = 0;
1384         pwin->flags.mapped = 1;
1385         XMapWindow(dpy, pwin->client_win);
1386         XMapWindow(dpy, pwin->frame->core->window);
1387         wClientSetState(pwin, NormalState, None);
1388     }
1389
1390 #ifdef GNOME_STUFF
1391     wGNOMEUpdateClientStateHint(wwin, False);
1392 #endif
1393
1394     UpdateSwitchMenu(wwin->screen_ptr, wwin, ACTION_CHANGE_STATE);
1395
1396 }
1397
1398
1399 void
1400 wUnhideApplication(WApplication *wapp, Bool miniwindows, Bool bringToCurrentWS)
1401 {
1402     WScreen *scr;
1403     WWindow *wlist, *next;
1404     WWindow *focused=NULL;
1405 #ifdef REDUCE_APPICONS
1406     char *tinstance, *tclass;
1407     unsigned int nowmhints = 0, matchwmhints = 0, matchworkspace = 0;
1408 #endif
1409
1410     if (!wapp) {
1411         return;
1412     }
1413
1414 #ifdef REDUCE_APPICONS
1415     if ((wapp->main_window_desc->wm_class == NULL) ||
1416         (wapp->main_window_desc->wm_instance == NULL))
1417         nowmhints++;
1418 #endif
1419
1420     scr = wapp->main_window_desc->screen_ptr;
1421     wlist = scr->focused_window;
1422     if (!wlist) return;
1423     /* goto beginning of list */
1424     while (wlist->prev)
1425       wlist = wlist->prev;
1426
1427     while (wlist) {
1428         next = wlist->next;
1429
1430 #ifndef REDUCE_APPICONS
1431         if (wlist->main_window == wapp->main_window) {
1432 #else
1433         matchwmhints = matchworkspace = 0;
1434         if (!nowmhints) {
1435             if ((tinstance = wlist->wm_instance) == NULL)
1436                 tinstance = "";
1437             if ((tclass = wlist->wm_class) == NULL)
1438                 tclass = "";
1439             if ((strcmp(tinstance, wapp->main_window_desc->wm_instance) == 0)
1440                 && (strcmp(tclass, wapp->main_window_desc->wm_class) == 0) )
1441                 matchwmhints++;
1442         }
1443         if (wlist->frame) {
1444             if (wlist->frame->workspace == wapp->main_window_desc->screen_ptr->current_workspace)
1445                 matchworkspace++;
1446         }
1447
1448         if ((wlist->main_window == wapp->main_window || matchwmhints) &&
1449             matchworkspace) {
1450 #endif
1451             if (wlist->flags.focused)
1452               focused = wlist;
1453             else if (!focused || !focused->flags.focused)
1454               focused = wlist;
1455
1456             if (wlist->flags.miniaturized && wlist->icon) {
1457                 if (bringToCurrentWS || wPreferences.sticky_icons
1458                     || wlist->frame->workspace == scr->current_workspace) {
1459                     if (!wlist->icon->mapped) {
1460                         XMapWindow(dpy, wlist->icon->core->window);
1461                         wlist->icon->mapped = 1;
1462                     }
1463                     wlist->flags.hidden = 0;
1464
1465                     UpdateSwitchMenu(scr, wlist, ACTION_CHANGE_STATE);
1466
1467                     if (wlist->frame->workspace != scr->current_workspace)
1468                         wWindowChangeWorkspace(wlist, scr->current_workspace);
1469                 }
1470                 if (miniwindows) {
1471                     wDeiconifyWindow(wlist);
1472                 }
1473             } else if (wlist->flags.hidden) {
1474                 unhideWindow(wapp->app_icon->icon, wapp->app_icon->x_pos,
1475                              wapp->app_icon->y_pos, wlist,
1476                              !wapp->flags.skip_next_animation,
1477                              bringToCurrentWS);
1478             } else {
1479                 if (bringToCurrentWS
1480                     && wlist->frame->workspace != scr->current_workspace) {
1481                     wWindowChangeWorkspace(wlist, scr->current_workspace);
1482                 }
1483                 wRaiseFrame(wlist->frame->core);
1484             }
1485         }
1486         wlist = next;
1487     }
1488
1489     wapp->flags.skip_next_animation = 0;
1490     wapp->flags.hidden = 0;
1491
1492     if (focused)
1493         wSetFocusTo(scr, focused);
1494     else if (wapp->last_focused && wapp->last_focused->flags.mapped)
1495         wSetFocusTo(scr, wapp->last_focused);
1496     wapp->last_focused = NULL;
1497     if (wPreferences.auto_arrange_icons) {
1498         wArrangeIcons(scr, True);
1499     }
1500 #ifdef HIDDENDOT
1501     wAppIconPaint(wapp->app_icon);
1502 #endif
1503 }
1504
1505
1506
1507 void
1508 wShowAllWindows(WScreen *scr)
1509 {
1510     WWindow *wwin, *old_foc;
1511     WApplication *wapp;
1512
1513     old_foc = wwin = scr->focused_window;
1514     while (wwin) {
1515         if (!wwin->flags.internal_window &&
1516             (scr->current_workspace == wwin->frame->workspace
1517             || IS_OMNIPRESENT(wwin))) {
1518             if (wwin->flags.miniaturized) {
1519                 wwin->flags.skip_next_animation = 1;
1520                 wDeiconifyWindow(wwin);
1521             } else if (wwin->flags.hidden) {
1522                 wapp = wApplicationOf(wwin->main_window);
1523                 if (wapp) {
1524                     wUnhideApplication(wapp, False, False);
1525                 } else {
1526                     wwin->flags.skip_next_animation = 1;
1527                     wDeiconifyWindow(wwin);
1528                 }
1529             }
1530         }
1531         wwin = wwin->prev;
1532     }
1533     wSetFocusTo(scr, old_foc);
1534     /*wRaiseFrame(old_foc->frame->core);*/
1535 }
1536
1537
1538 void
1539 wRefreshDesktop(WScreen *scr)
1540 {
1541     Window win;
1542     XSetWindowAttributes attr;
1543
1544     attr.backing_store = NotUseful;
1545     attr.save_under = False;
1546     win = XCreateWindow(dpy, scr->root_win, 0, 0, scr->scr_width,
1547                         scr->scr_height, 0, CopyFromParent, CopyFromParent,
1548                         (Visual *)CopyFromParent, CWBackingStore|CWSaveUnder,
1549                         &attr);
1550     XMapRaised(dpy, win);
1551     XDestroyWindow(dpy, win);
1552     XFlush(dpy);
1553 }
1554
1555
1556 void
1557 wArrangeIcons(WScreen *scr, Bool arrangeAll)
1558 {
1559     WWindow *wwin;
1560     WAppIcon *aicon;
1561     int pf;                            /* primary axis */
1562     int sf;                            /* secondary axis */
1563     int fullW;
1564     int fullH;
1565     int pi, si;
1566     int sx1, sx2, sy1, sy2;            /* screen boundary */
1567     int sw, sh;
1568     int xo, yo;
1569     int xs, ys;
1570     int isize = wPreferences.icon_size;
1571
1572     /*
1573      * Find out screen boundaries.
1574      */
1575     sx1 = 0;
1576     sy1 = 0;
1577     sx2 = scr->scr_width;
1578     sy2 = scr->scr_height;
1579     if (scr->dock) {
1580         if (scr->dock->on_right_side)
1581             sx2 -= isize + DOCK_EXTRA_SPACE;
1582         else
1583             sx1 += isize + DOCK_EXTRA_SPACE;
1584     }
1585
1586     sw = isize * (scr->scr_width/isize);
1587     sh = isize * (scr->scr_height/isize);
1588     fullW = (sx2-sx1)/isize;
1589     fullH = (sy2-sy1)/isize;
1590
1591     /* icon yard boundaries */
1592     if (wPreferences.icon_yard & IY_VERT) {
1593         pf = fullH;
1594         sf = fullW;
1595     } else {
1596         pf = fullW;
1597         sf = fullH;
1598     }
1599     if (wPreferences.icon_yard & IY_RIGHT) {
1600         xo = sx2 - isize;
1601         xs = -1;
1602     } else {
1603         xo = sx1;
1604         xs = 1;
1605     }
1606     if (wPreferences.icon_yard & IY_TOP) {
1607         yo = sy1;
1608         ys = 1;
1609     } else {
1610         yo = sy2 - isize;
1611         ys = -1;
1612     }
1613
1614     /* arrange icons putting the most recently focused window
1615      * as the last icon */
1616 #define X ((wPreferences.icon_yard & IY_VERT) ? xo + xs*(si*isize)\
1617                     : xo + xs*(pi*isize))
1618 #define Y ((wPreferences.icon_yard & IY_VERT) ? yo + ys*(pi*isize)\
1619                     : yo + ys*(si*isize))
1620
1621     /* arrange application icons */
1622     aicon = scr->app_icon_list;
1623     /* reverse them to avoid unnecessarily sliding of icons */
1624     while (aicon && aicon->next)
1625         aicon = aicon->next;
1626
1627     pi = 0;
1628     si = 0;
1629     while (aicon) {
1630         if (!aicon->docked) {
1631             if (aicon->x_pos != X || aicon->y_pos != Y) {
1632 #ifdef ANIMATIONS
1633                 if (!wPreferences.no_animations) {
1634                     SlideWindow(aicon->icon->core->window, aicon->x_pos, aicon->y_pos,
1635                                 X, Y);
1636                 }
1637 #endif /* ANIMATIONS */
1638             }
1639             wAppIconMove(aicon, X, Y);
1640             pi++;
1641         }
1642         /* we reversed the order so we use prev */
1643         aicon = aicon->prev;
1644         if (pi >= pf) {
1645             pi=0;
1646             si++;
1647         }
1648     }
1649
1650     /* arrange miniwindows */
1651
1652     wwin = scr->focused_window;
1653     /* reverse them to avoid unnecessarily shuffling */
1654     while (wwin && wwin->prev)
1655         wwin = wwin->prev;
1656
1657     while (wwin) {
1658         if (wwin->icon && wwin->flags.miniaturized &&/*!wwin->flags.hidden &&*/
1659             (wwin->frame->workspace==scr->current_workspace ||
1660              IS_OMNIPRESENT(wwin) || wPreferences.sticky_icons)) {
1661
1662             if (arrangeAll || !wwin->flags.icon_moved) {
1663                 if (wwin->icon_x != X || wwin->icon_y != Y) {
1664 #ifdef ANIMATIONS
1665                     if (wPreferences.no_animations) {
1666                         XMoveWindow(dpy, wwin->icon->core->window, X, Y);
1667                     } else {
1668                         SlideWindow(wwin->icon->core->window, wwin->icon_x,
1669                                     wwin->icon_y, X, Y);
1670                     }
1671 #else
1672                     XMoveWindow(dpy, wwin->icon->core->window, X, Y);
1673 #endif /* ANIMATIONS */
1674                 }
1675                 wwin->icon_x = X;
1676                 wwin->icon_y = Y;
1677                 pi++;
1678             }
1679         }
1680         if (arrangeAll) {
1681             wwin->flags.icon_moved = 0;
1682         }
1683         /* we reversed the order, so we use next */
1684         wwin = wwin->next;
1685         if (pi >= pf) {
1686             pi=0;
1687             si++;
1688         }
1689     }
1690 }
1691
1692
1693 void
1694 wSelectWindow(WWindow *wwin, Bool flag)
1695 {
1696     WScreen *scr = wwin->screen_ptr;
1697     if (flag) {
1698         wwin->flags.selected = 1;
1699         XSetWindowBorder(dpy, wwin->frame->core->window, scr->white_pixel);
1700         scr->selected_windows = list_cons(wwin, scr->selected_windows);
1701     } else {
1702         wwin->flags.selected = 0;
1703         XSetWindowBorder(dpy, wwin->frame->core->window,
1704                          scr->frame_border_pixel);
1705         scr->selected_windows = list_remove_elem(scr->selected_windows, wwin);
1706     }
1707 }
1708
1709
1710 void
1711 wMakeWindowVisible(WWindow *wwin)
1712 {
1713     wWorkspaceChange(wwin->screen_ptr, wwin->frame->workspace);
1714
1715     if (wwin->flags.shaded) {
1716         wUnshadeWindow(wwin);
1717     }
1718     if (wwin->flags.hidden) {
1719         WApplication *app;
1720
1721         app = wApplicationOf(wwin->main_window);
1722         if (app)
1723             wUnhideApplication(app, False, False);
1724     } else if (wwin->flags.miniaturized) {
1725         wDeiconifyWindow(wwin);
1726     } else {
1727         wSetFocusTo(wwin->screen_ptr, wwin);
1728         wRaiseFrame(wwin->frame->core);
1729     }
1730 }