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