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