src/superfluous.c

   1 /*
   2  *  Window Maker window manager
   3  *
   4  *  Copyright (c) 1997-2003 Alfredo K. Kojima
   5  *  Copyright (c) 1998-2003 Dan Pascu
   6  *
   7  *  This program is free software; you can redistribute it and/or modify
   8  *  it under the terms of the GNU General Public License as published by
   9  *  the Free Software Foundation; either version 2 of the License, or
  10  *  (at your option) any later version.
  11  *
  12  *  This program is distributed in the hope that it will be useful,
  13  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  *  GNU General Public License for more details.
  16  *
  17  *  You should have received a copy of the GNU General Public License along
  18  *  with this program; if not, write to the Free Software Foundation, Inc.,
  19  *  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  20  */
  21
  22 #include "wconfig.h"
  23
  24 #include <X11/Xlib.h>
  25 #include <X11/Xutil.h>
  26
  27 #include <stdlib.h>
  28 #include <unistd.h>
  29 #include <math.h>
  30 #include <time.h>
  31
  32 #include <wraster.h>
  33
  34 #include "WindowMaker.h"
  35 #include "screen.h"
  36 #include "superfluous.h"
  37 #include "framewin.h"
  38 #include "window.h"
  39 #include "actions.h"
  40 #include "xinerama.h"
  41 #include "stacking.h"
  42
  43 #define PIECES ((64/ICON_KABOOM_PIECE_SIZE)*(64/ICON_KABOOM_PIECE_SIZE))
  44 #define KAB_PRECISION           4
  45 #define BOUNCE_HZ               25
  46 #define BOUNCE_DELAY            (1000/BOUNCE_HZ)
  47 #define BOUNCE_HEIGHT           24
  48 #define BOUNCE_LENGTH           0.3
  49 #define BOUNCE_DAMP             0.6
  50 #define URGENT_BOUNCE_DELAY     3000
  51
  52
  53 void DoKaboom(WScreen * scr, Window win, int x, int y)
  54 {
  55 #ifdef NORMAL_ICON_KABOOM
  56         int i, j, k;
  57         int sw = scr->scr_width, sh = scr->scr_height;
  58         int px[PIECES];
  59         short py[PIECES];
  60         char pvx[PIECES], pvy[PIECES];
  61         /* in MkLinux/PPC gcc seems to think that char is unsigned? */
  62         signed char ax[PIECES], ay[PIECES];
  63         Pixmap tmp;
  64
  65         XSetClipMask(dpy, scr->copy_gc, None);
  66         tmp = XCreatePixmap(dpy, scr->root_win, wPreferences.icon_size, wPreferences.icon_size, scr->depth);
  67         if (scr->w_visual == DefaultVisual(dpy, scr->screen))
  68                 XCopyArea(dpy, win, tmp, scr->copy_gc, 0, 0, wPreferences.icon_size, wPreferences.icon_size, 0, 0);
  69         else {
  70                 XImage *image;
  71
  72                 image = XGetImage(dpy, win, 0, 0, wPreferences.icon_size,
  73                                   wPreferences.icon_size, AllPlanes, ZPixmap);
  74                 if (!image) {
  75                         XUnmapWindow(dpy, win);
  76                         return;
  77                 }
  78                 XPutImage(dpy, tmp, scr->copy_gc, image, 0, 0, 0, 0,
  79                           wPreferences.icon_size, wPreferences.icon_size);
  80                 XDestroyImage(image);
  81         }
  82
  83         for (i = 0, k = 0; i < wPreferences.icon_size / ICON_KABOOM_PIECE_SIZE && k < PIECES; i++) {
  84                 for (j = 0; j < wPreferences.icon_size / ICON_KABOOM_PIECE_SIZE && k < PIECES; j++) {
  85                         if (rand() % 2) {
  86                                 ax[k] = i;
  87                                 ay[k] = j;
  88                                 px[k] = (x + i * ICON_KABOOM_PIECE_SIZE) << KAB_PRECISION;
  89                                 py[k] = y + j * ICON_KABOOM_PIECE_SIZE;
  90                                 pvx[k] = rand() % (1 << (KAB_PRECISION + 3)) - (1 << (KAB_PRECISION + 3)) / 2;
  91                                 pvy[k] = -15 - rand() % 7;
  92                                 k++;
  93                         } else {
  94                                 ax[k] = -1;
  95                         }
  96                 }
  97         }
  98
  99         XUnmapWindow(dpy, win);
 100
 101         j = k;
 102         while (k > 0) {
 103                 XEvent foo;
 104
 105                 if (XCheckTypedEvent(dpy, ButtonPress, &foo)) {
 106                         XPutBackEvent(dpy, &foo);
 107                         XClearWindow(dpy, scr->root_win);
 108                         break;
 109                 }
 110
 111                 for (i = 0; i < j; i++) {
 112                         if (ax[i] >= 0) {
 113                                 int _px = px[i] >> KAB_PRECISION;
 114                                 XClearArea(dpy, scr->root_win, _px, py[i],
 115                                            ICON_KABOOM_PIECE_SIZE, ICON_KABOOM_PIECE_SIZE, False);
 116                                 px[i] += pvx[i];
 117                                 py[i] += pvy[i];
 118                                 _px = px[i] >> KAB_PRECISION;
 119                                 pvy[i]++;
 120                                 if (_px < -wPreferences.icon_size || _px > sw || py[i] >= sh) {
 121                                         ax[i] = -1;
 122                                         k--;
 123                                 } else {
 124                                         XCopyArea(dpy, tmp, scr->root_win, scr->copy_gc,
 125                                                   ax[i] * ICON_KABOOM_PIECE_SIZE, ay[i] * ICON_KABOOM_PIECE_SIZE,
 126                                                   ICON_KABOOM_PIECE_SIZE, ICON_KABOOM_PIECE_SIZE, _px, py[i]);
 127                                 }
 128                         }
 129                 }
 130
 131                 XFlush(dpy);
 132                 wusleep(MINIATURIZE_ANIMATION_DELAY_Z * 2);
 133         }
 134
 135         XFreePixmap(dpy, tmp);
 136 #endif  /* NORMAL_ICON_KABOOM */
 137 }
 138
 139 Pixmap MakeGhostIcon(WScreen * scr, Drawable drawable)
 140 {
 141         RImage *back;
 142         RColor color;
 143         Pixmap pixmap;
 144
 145         if (!drawable)
 146                 return None;
 147
 148         back = RCreateImageFromDrawable(scr->rcontext, drawable, None);
 149         if (!back)
 150                 return None;
 151
 152         color.red = 0xff;
 153         color.green = 0xff;
 154         color.blue = 0xff;
 155         color.alpha = 200;
 156
 157         RClearImage(back, &color);
 158         RConvertImage(scr->rcontext, back, &pixmap);
 159
 160         RReleaseImage(back);
 161
 162         return pixmap;
 163 }
 164
 165 void DoWindowBirth(WWindow *wwin)
 166 {
 167 #ifdef WINDOW_BIRTH_ZOOM
 168         int center_x, center_y;
 169         int width = wwin->frame->core->width;
 170         int height = wwin->frame->core->height;
 171         int w = WMIN(width, 20);
 172         int h = WMIN(height, 20);
 173         WScreen *scr = wwin->screen_ptr;
 174
 175         center_x = wwin->frame_x + (width - w) / 2;
 176         center_y = wwin->frame_y + (height - h) / 2;
 177
 178         animateResize(scr, center_x, center_y, 1, 1, wwin->frame_x, wwin->frame_y, width, height);
 179 #else
 180         /* Parameter not used, but tell the compiler that it is ok */
 181         (void) wwin;
 182 #endif
 183 }
 184
 185 typedef struct AppBouncerData {
 186         WApplication *wapp;
 187         int count;
 188         int pow;
 189         int dir;
 190         WMHandlerID *timer;
 191 } AppBouncerData;
 192
 193 static void doAppBounce(void *arg)
 194 {
 195         AppBouncerData *data = (AppBouncerData*)arg;
 196         WAppIcon *aicon = data->wapp->app_icon;
 197
 198         if (!aicon)
 199                 return;
 200
 201 reinit:
 202         if (data->wapp->refcount > 1) {
 203                 if (wPreferences.raise_appicons_when_bouncing)
 204                         XRaiseWindow(dpy, aicon->icon->core->window);
 205
 206                 const double ticks = BOUNCE_HZ * BOUNCE_LENGTH;
 207                 const double s = sqrt(BOUNCE_HEIGHT)/(ticks/2);
 208                 double h = BOUNCE_HEIGHT*pow(BOUNCE_DAMP, data->pow);
 209                 double sqrt_h = sqrt(h);
 210                 if (h > 3) {
 211                         double offset, x = s * data->count - sqrt_h;
 212                         if (x > sqrt_h) {
 213                                 ++data->pow;
 214                                 data->count = 0;
 215                                 goto reinit;
 216                         } else ++data->count;
 217                         offset = h - x*x;
 218
 219                         switch (data->dir) {
 220                         case 0: /* left, bounce to right */
 221                                 XMoveWindow(dpy, aicon->icon->core->window,
 222                                             aicon->x_pos + (int)offset, aicon->y_pos);
 223                                 break;
 224                         case 1: /* right, bounce to left */
 225                                 XMoveWindow(dpy, aicon->icon->core->window,
 226                                             aicon->x_pos - (int)offset, aicon->y_pos);
 227                                 break;
 228                         case 2: /* top, bounce down */
 229                                 XMoveWindow(dpy, aicon->icon->core->window,
 230                                             aicon->x_pos, aicon->y_pos + (int)offset);
 231                                 break;
 232                         case 3: /* bottom, bounce up */
 233                                 XMoveWindow(dpy, aicon->icon->core->window,
 234                                             aicon->x_pos, aicon->y_pos - (int)offset);
 235                                 break;
 236                         }
 237                         return;
 238                 }
 239         }
 240
 241         XMoveWindow(dpy, aicon->icon->core->window,
 242                         aicon->x_pos, aicon->y_pos);
 243         CommitStackingForWindow(aicon->icon->core);
 244         data->wapp->flags.bouncing = 0;
 245         WMDeleteTimerHandler(data->timer);
 246         wApplicationDestroy(data->wapp);
 247         free(data);
 248 }
 249
 250 static int bounceDirection(WAppIcon *aicon)
 251 {
 252         enum { left_e = 1, right_e = 2, top_e = 4, bottom_e = 8 };
 253
 254         WScreen *scr = aicon->icon->core->screen_ptr;
 255         WMRect rr, sr;
 256         int l, r, t, b, h, v;
 257         int dir = 0;
 258
 259         rr.pos.x = aicon->x_pos;
 260         rr.pos.y = aicon->y_pos;
 261         rr.size.width = rr.size.height = 64;
 262
 263         sr = wGetRectForHead(scr, wGetHeadForRect(scr, rr));
 264
 265         l = rr.pos.x - sr.pos.x;
 266         r = sr.pos.x + sr.size.width - rr.pos.x - rr.size.width;
 267         t = rr.pos.y - sr.pos.y;
 268         b = sr.pos.y + sr.size.height - rr.pos.y - rr.size.height;
 269
 270         if (l < r) {
 271                 dir |= left_e;
 272                 h = l;
 273         } else {
 274                 dir |= right_e;
 275                 h = r;
 276         }
 277
 278         if (t < b) {
 279                 dir |= top_e;
 280                 v = t;
 281         } else {
 282                 dir |= bottom_e;
 283                 v = b;
 284         }
 285
 286         if (aicon->dock && abs(aicon->xindex) != abs(aicon->yindex)) {
 287                 if (abs(aicon->xindex) < abs(aicon->yindex)) dir &= ~(top_e | bottom_e);
 288                 else dir &= ~(left_e | right_e);
 289         } else {
 290                 if (h < v) dir &= ~(top_e | bottom_e);
 291                 else dir &= ~(left_e | right_e);
 292         }
 293
 294         switch (dir) {
 295         case left_e:
 296                 dir = 0;
 297                 break;
 298
 299         case right_e:
 300                 dir = 1;
 301                 break;
 302
 303         case top_e:
 304                 dir = 2;
 305                 break;
 306
 307         case bottom_e:
 308                 dir = 3;
 309                 break;
 310
 311         default:
 312                 wwarning(_("Impossible direction: %d"), dir);
 313                 dir = 3;
 314                 break;
 315         }
 316
 317         return dir;
 318 }
 319
 320 void wAppBounce(WApplication *wapp)
 321 {
 322         if (!wPreferences.no_animations && wapp->app_icon && !wapp->flags.bouncing
 323                 && !wPreferences.do_not_make_appicons_bounce) {
 324                 ++wapp->refcount;
 325                 wapp->flags.bouncing = 1;
 326
 327                 AppBouncerData *data = (AppBouncerData *)malloc(sizeof(AppBouncerData));
 328                 data->wapp = wapp;
 329                 data->count = data->pow = 0;
 330                 data->dir = bounceDirection(wapp->app_icon);
 331                 data->timer = WMAddPersistentTimerHandler(BOUNCE_DELAY, doAppBounce, data);
 332         }
 333 }
 334
 335 static int appIsUrgent(WApplication *wapp)
 336 {
 337         WScreen *scr;
 338         WWindow *wlist;
 339
 340         if (!wapp->main_window_desc) {
 341                 wwarning("group leader not found for window group");
 342                 return 0;
 343         }
 344         scr = wapp->main_window_desc->screen_ptr;
 345         wlist = scr->focused_window;
 346         if (!wlist)
 347                 return 0;
 348
 349         while (wlist) {
 350                 if (wlist->main_window == wapp->main_window) {
 351                         if (wlist->flags.urgent)
 352                                 return 1;
 353                 }
 354                 wlist = wlist->prev;
 355         }
 356
 357         return 0;
 358 }
 359
 360 static void doAppUrgentBounce(void *arg)
 361 {
 362         WApplication *wapp = (WApplication *)arg;
 363
 364         if (appIsUrgent(wapp)) {
 365                 if(wPreferences.bounce_appicons_when_urgent) wAppBounce(wapp);
 366         } else {
 367                 WMDeleteTimerHandler(wapp->urgent_bounce_timer);
 368                 wapp->urgent_bounce_timer = NULL;
 369         }
 370 }
 371
 372 void wAppBounceWhileUrgent(WApplication *wapp)
 373 {
 374         if (!wapp) return;
 375         if (appIsUrgent(wapp)) {
 376                 if (!wapp->urgent_bounce_timer) {
 377                         wapp->urgent_bounce_timer = WMAddPersistentTimerHandler(URGENT_BOUNCE_DELAY, doAppUrgentBounce, wapp);
 378                         doAppUrgentBounce(wapp);
 379                 }
 380         } else {
 381                 if (wapp->urgent_bounce_timer) {
 382                         WMDeleteTimerHandler(wapp->urgent_bounce_timer);
 383                         wapp->urgent_bounce_timer = NULL;
 384                 }
 385         }
 386 }