src/actions.c

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