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