src/icon.c

   1 /* icon.c - window icon and dock and appicon parent
   2  *
   3  *  Window Maker window manager
   4  *
   5  *  Copyright (c) 1997-2003 Alfredo K. Kojima
   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
  18  *  along with this program; if not, write to the Free Software
  19  *  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
  20  *  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 <stdint.h>
  30 #include <string.h>
  31 #include <unistd.h>
  32 #include <ctype.h>
  33 #include <wraster.h>
  34 #include <sys/stat.h>
  35
  36 #include "WindowMaker.h"
  37 #include "wcore.h"
  38 #include "texture.h"
  39 #include "window.h"
  40 #include "icon.h"
  41 #include "actions.h"
  42 #include "funcs.h"
  43 #include "stacking.h"
  44 #include "application.h"
  45 #include "defaults.h"
  46 #include "appicon.h"
  47 #include "wmspec.h"
  48
  49 /**** Global varianebles ****/
  50 extern WPreferences wPreferences;
  51
  52 #define MOD_MASK wPreferences.modifier_mask
  53
  54 extern Cursor wCursor[WCUR_LAST];
  55
  56 static void miniwindowExpose(WObjDescriptor * desc, XEvent * event);
  57 static void miniwindowMouseDown(WObjDescriptor * desc, XEvent * event);
  58 static void miniwindowDblClick(WObjDescriptor * desc, XEvent * event);
  59
  60 /****** Notification Observers ******/
  61
  62 static void appearanceObserver(void *self, WMNotification * notif)
  63 {
  64         WIcon *icon = (WIcon *) self;
  65         uintptr_t flags = (uintptr_t)WMGetNotificationClientData(notif);
  66
  67         if (flags & WTextureSettings) {
  68                 icon->force_paint = 1;
  69         }
  70         if (flags & WFontSettings) {
  71                 icon->force_paint = 1;
  72         }
  73         /*
  74            if (flags & WColorSettings) {
  75            }
  76          */
  77
  78         wIconPaint(icon);
  79
  80         /* so that the appicon expose handlers will paint the appicon specific
  81          * stuff */
  82         XClearArea(dpy, icon->core->window, 0, 0, icon->core->width, icon->core->height, True);
  83 }
  84
  85 static void tileObserver(void *self, WMNotification * notif)
  86 {
  87         WIcon *icon = (WIcon *) self;
  88
  89         icon->force_paint = 1;
  90         wIconPaint(icon);
  91
  92         XClearArea(dpy, icon->core->window, 0, 0, 1, 1, True);
  93 }
  94
  95 /************************************/
  96
  97 INLINE static void getSize(Drawable d, unsigned int *w, unsigned int *h, unsigned int *dep)
  98 {
  99         Window rjunk;
 100         int xjunk, yjunk;
 101         unsigned int bjunk;
 102
 103         XGetGeometry(dpy, d, &rjunk, &xjunk, &yjunk, w, h, &bjunk, dep);
 104 }
 105
 106 WIcon *wIconCreate(WWindow * wwin)
 107 {
 108         WScreen *scr = wwin->screen_ptr;
 109         WIcon *icon;
 110         char *file;
 111         unsigned long vmask = 0;
 112         XSetWindowAttributes attribs;
 113
 114         icon = wmalloc(sizeof(WIcon));
 115         memset(icon, 0, sizeof(WIcon));
 116         icon->core = wCoreCreateTopLevel(scr, wwin->icon_x, wwin->icon_y,
 117                                          wPreferences.icon_size, wPreferences.icon_size, 0);
 118
 119         if (wPreferences.use_saveunders) {
 120                 vmask |= CWSaveUnder;
 121                 attribs.save_under = True;
 122         }
 123         /* a white border for selecting it */
 124         vmask |= CWBorderPixel;
 125         attribs.border_pixel = scr->white_pixel;
 126
 127         XChangeWindowAttributes(dpy, icon->core->window, vmask, &attribs);
 128
 129         /* will be overriden if this is an application icon */
 130         icon->core->descriptor.handle_mousedown = miniwindowMouseDown;
 131         icon->core->descriptor.handle_expose = miniwindowExpose;
 132         icon->core->descriptor.parent_type = WCLASS_MINIWINDOW;
 133         icon->core->descriptor.parent = icon;
 134
 135         icon->core->stacking = wmalloc(sizeof(WStacking));
 136         icon->core->stacking->above = NULL;
 137         icon->core->stacking->under = NULL;
 138         icon->core->stacking->window_level = NORMAL_ICON_LEVEL;
 139         icon->core->stacking->child_of = NULL;
 140
 141         icon->owner = wwin;
 142         if (wwin->wm_hints && (wwin->wm_hints->flags & IconWindowHint)) {
 143                 if (wwin->client_win == wwin->main_window) {
 144                         WApplication *wapp;
 145                         /* do not let miniwindow steal app-icon's icon window */
 146                         wapp = wApplicationOf(wwin->client_win);
 147                         if (!wapp || wapp->app_icon == NULL)
 148                                 icon->icon_win = wwin->wm_hints->icon_window;
 149                 } else {
 150                         icon->icon_win = wwin->wm_hints->icon_window;
 151                 }
 152         }
 153 #ifdef NO_MINIWINDOW_TITLES
 154         icon->show_title = 0;
 155 #else
 156         icon->show_title = 1;
 157 #endif
 158         if (!icon->image && !WFLAGP(wwin, always_user_icon))
 159                 icon->image = RRetainImage(wwin->net_icon_image);
 160         if (!icon->image)
 161                 icon->image = wDefaultGetImage(scr, wwin->wm_instance, wwin->wm_class);
 162
 163         file = wDefaultGetIconFile(scr, wwin->wm_instance, wwin->wm_class, False);
 164         if (file) {
 165                 icon->file = wstrdup(file);
 166         }
 167
 168         icon->icon_name = wNETWMGetIconName(wwin->client_win);
 169         if (icon->icon_name)
 170                 wwin->flags.net_has_icon_title = 1;
 171         else
 172                 wGetIconName(dpy, wwin->client_win, &icon->icon_name);
 173
 174         icon->tile_type = TILE_NORMAL;
 175
 176         wIconUpdate(icon);
 177
 178         XFlush(dpy);
 179
 180         WMAddNotificationObserver(appearanceObserver, icon, WNIconAppearanceSettingsChanged, icon);
 181         WMAddNotificationObserver(tileObserver, icon, WNIconTileSettingsChanged, icon);
 182         return icon;
 183 }
 184
 185 WIcon *wIconCreateWithIconFile(WScreen * scr, char *iconfile, int tile)
 186 {
 187         WIcon *icon;
 188         unsigned long vmask = 0;
 189         XSetWindowAttributes attribs;
 190
 191         icon = wmalloc(sizeof(WIcon));
 192         memset(icon, 0, sizeof(WIcon));
 193         icon->core = wCoreCreateTopLevel(scr, 0, 0, wPreferences.icon_size, wPreferences.icon_size, 0);
 194         if (wPreferences.use_saveunders) {
 195                 vmask = CWSaveUnder;
 196                 attribs.save_under = True;
 197         }
 198         /* a white border for selecting it */
 199         vmask |= CWBorderPixel;
 200         attribs.border_pixel = scr->white_pixel;
 201
 202         XChangeWindowAttributes(dpy, icon->core->window, vmask, &attribs);
 203
 204         /* will be overriden if this is a application icon */
 205         icon->core->descriptor.handle_mousedown = miniwindowMouseDown;
 206         icon->core->descriptor.handle_expose = miniwindowExpose;
 207         icon->core->descriptor.parent_type = WCLASS_MINIWINDOW;
 208         icon->core->descriptor.parent = icon;
 209
 210         icon->core->stacking = wmalloc(sizeof(WStacking));
 211         icon->core->stacking->above = NULL;
 212         icon->core->stacking->under = NULL;
 213         icon->core->stacking->window_level = NORMAL_ICON_LEVEL;
 214         icon->core->stacking->child_of = NULL;
 215
 216         if (iconfile) {
 217                 icon->image = RLoadImage(scr->rcontext, iconfile, 0);
 218                 if (!icon->image) {
 219                         wwarning(_("error loading image file \"%s\""), iconfile, RMessageForError(RErrorCode));
 220                 }
 221
 222                 icon->image = wIconValidateIconSize(scr, icon->image);
 223
 224                 icon->file = wstrdup(iconfile);
 225         }
 226
 227         icon->tile_type = tile;
 228
 229         wIconUpdate(icon);
 230
 231         WMAddNotificationObserver(appearanceObserver, icon, WNIconAppearanceSettingsChanged, icon);
 232         WMAddNotificationObserver(tileObserver, icon, WNIconTileSettingsChanged, icon);
 233
 234         return icon;
 235 }
 236
 237 void wIconDestroy(WIcon * icon)
 238 {
 239         WCoreWindow *core = icon->core;
 240         WScreen *scr = core->screen_ptr;
 241
 242         WMRemoveNotificationObserver(icon);
 243
 244         if (icon->handlerID)
 245                 WMDeleteTimerHandler(icon->handlerID);
 246
 247         if (icon->icon_win) {
 248                 int x = 0, y = 0;
 249
 250                 if (icon->owner) {
 251                         x = icon->owner->icon_x;
 252                         y = icon->owner->icon_y;
 253                 }
 254                 XUnmapWindow(dpy, icon->icon_win);
 255                 XReparentWindow(dpy, icon->icon_win, scr->root_win, x, y);
 256         }
 257         if (icon->icon_name)
 258                 XFree(icon->icon_name);
 259
 260         if (icon->pixmap)
 261                 XFreePixmap(dpy, icon->pixmap);
 262
 263         if (icon->file)
 264                 wfree(icon->file);
 265
 266         if (icon->image != NULL)
 267                 RReleaseImage(icon->image);
 268
 269         wCoreDestroy(icon->core);
 270         wfree(icon);
 271 }
 272
 273 static void drawIconTitle(WScreen * scr, Pixmap pixmap, int height)
 274 {
 275         XFillRectangle(dpy, pixmap, scr->icon_title_texture->normal_gc, 0, 0, wPreferences.icon_size, height + 1);
 276         XDrawLine(dpy, pixmap, scr->icon_title_texture->light_gc, 0, 0, wPreferences.icon_size, 0);
 277         XDrawLine(dpy, pixmap, scr->icon_title_texture->light_gc, 0, 0, 0, height + 1);
 278         XDrawLine(dpy, pixmap, scr->icon_title_texture->dim_gc,
 279                   wPreferences.icon_size - 1, 0, wPreferences.icon_size - 1, height + 1);
 280 }
 281
 282 static Pixmap makeIcon(WScreen * scr, RImage * icon, int titled, int shadowed, int tileType)
 283 {
 284         RImage *tile;
 285         Pixmap pixmap;
 286         int x, y, sx, sy;
 287         unsigned w, h;
 288         int theight = WMFontHeight(scr->icon_title_font);
 289
 290         if (tileType == TILE_NORMAL)
 291                 tile = RCloneImage(scr->icon_tile);
 292         else {
 293                 assert(scr->clip_tile);
 294                 tile = RCloneImage(scr->clip_tile);
 295         }
 296         if (icon) {
 297                 w = (icon->width > wPreferences.icon_size)
 298                     ? wPreferences.icon_size : icon->width;
 299                 x = (wPreferences.icon_size - w) / 2;
 300                 sx = (icon->width - w) / 2;
 301
 302                 if (!titled) {
 303                         h = (icon->height > wPreferences.icon_size)
 304                             ? wPreferences.icon_size : icon->height;
 305                         y = (wPreferences.icon_size - h) / 2;
 306                         sy = (icon->height - h) / 2;
 307                 } else {
 308                         h = (icon->height + theight > wPreferences.icon_size
 309                              ? wPreferences.icon_size - theight : icon->height);
 310                         y = theight + ((int)wPreferences.icon_size - theight - h) / 2;
 311                         sy = (icon->height - h) / 2;
 312                 }
 313                 RCombineArea(tile, icon, sx, sy, w, h, x, y);
 314         }
 315
 316         if (shadowed) {
 317                 RColor color;
 318
 319                 color.red = scr->icon_back_texture->light.red >> 8;
 320                 color.green = scr->icon_back_texture->light.green >> 8;
 321                 color.blue = scr->icon_back_texture->light.blue >> 8;
 322                 color.alpha = 150;      /* about 60% */
 323                 RClearImage(tile, &color);
 324         }
 325
 326         if (!RConvertImage(scr->rcontext, tile, &pixmap)) {
 327                 wwarning(_("error rendering image:%s"), RMessageForError(RErrorCode));
 328         }
 329         RReleaseImage(tile);
 330
 331         if (titled)
 332                 drawIconTitle(scr, pixmap, theight);
 333
 334         return pixmap;
 335 }
 336
 337 void wIconChangeTitle(WIcon * icon, char *new_title)
 338 {
 339         int changed;
 340
 341         changed = (new_title == NULL && icon->icon_name != NULL)
 342             || (new_title != NULL && icon->icon_name == NULL);
 343
 344         if (icon->icon_name != NULL)
 345                 XFree(icon->icon_name);
 346
 347         icon->icon_name = new_title;
 348
 349         if (changed)
 350                 icon->force_paint = 1;
 351         wIconPaint(icon);
 352 }
 353
 354 void wIconChangeImage(WIcon * icon, RImage * new_image)
 355 {
 356         assert(icon != NULL);
 357
 358         if (icon->image)
 359                 RReleaseImage(icon->image);
 360
 361         icon->image = new_image;
 362
 363         wIconUpdate(icon);
 364 }
 365
 366 RImage *wIconValidateIconSize(WScreen * scr, RImage * icon)
 367 {
 368         RImage *tmp;
 369         int w, h;
 370
 371         if (!icon)
 372                 return NULL;
 373 #ifndef DONT_SCALE_ICONS
 374         if (wPreferences.icon_size != 64) {
 375                 w = wPreferences.icon_size * icon->width / 64;
 376                 h = wPreferences.icon_size * icon->height / 64;
 377
 378                 tmp = RScaleImage(icon, w, h);
 379                 RReleaseImage(icon);
 380                 icon = tmp;
 381         }
 382 #endif
 383 #if 0
 384         if (icon->width > wPreferences.icon_size || icon->height > wPreferences.icon_size) {
 385                 if (icon->width > icon->height) {
 386                         w = wPreferences.icon_size - 4;
 387                         h = w * icon->height / icon->width;
 388                 } else {
 389                         h = wPreferences.icon_size - 4;
 390                         w = h * icon->width / icon->height;
 391                 }
 392                 tmp = RScaleImage(icon, w, h);
 393                 RReleaseImage(icon);
 394                 icon = tmp;
 395         }
 396 #endif
 397
 398         return icon;
 399 }
 400
 401 Bool wIconChangeImageFile(WIcon * icon, char *file)
 402 {
 403         WScreen *scr = icon->core->screen_ptr;
 404         RImage *image;
 405         char *path;
 406         int error = 0;
 407
 408         if (!file) {
 409                 wIconChangeImage(icon, NULL);
 410                 return True;
 411         }
 412
 413         path = FindImage(wPreferences.icon_path, file);
 414
 415         if (path && (image = RLoadImage(scr->rcontext, path, 0))) {
 416                 image = wIconValidateIconSize(icon->core->screen_ptr, image);
 417
 418                 wIconChangeImage(icon, image);
 419         } else {
 420                 error = 1;
 421         }
 422
 423         if (path)
 424                 wfree(path);
 425
 426         return !error;
 427 }
 428
 429 static char *getnameforicon(WWindow * wwin)
 430 {
 431         char *prefix, *suffix;
 432         char *path;
 433         int len;
 434
 435         if (wwin->wm_class && wwin->wm_instance) {
 436                 int len = strlen(wwin->wm_class) + strlen(wwin->wm_instance) + 2;
 437                 suffix = wmalloc(len);
 438                 snprintf(suffix, len, "%s.%s", wwin->wm_instance, wwin->wm_class);
 439         } else if (wwin->wm_class) {
 440                 int len = strlen(wwin->wm_class) + 1;
 441                 suffix = wmalloc(len);
 442                 snprintf(suffix, len, "%s", wwin->wm_class);
 443         } else if (wwin->wm_instance) {
 444                 int len = strlen(wwin->wm_instance) + 1;
 445                 suffix = wmalloc(len);
 446                 snprintf(suffix, len, "%s", wwin->wm_instance);
 447         } else {
 448                 return NULL;
 449         }
 450
 451         prefix = wusergnusteppath();
 452         len = strlen(prefix) + 64 + strlen(suffix);
 453         path = wmalloc(len + 1);
 454         snprintf(path, len, "%s/Library/WindowMaker", prefix);
 455
 456         if (access(path, F_OK) != 0) {
 457                 if (mkdir(path, S_IRUSR | S_IWUSR | S_IXUSR)) {
 458                         wsyserror(_("could not create directory %s"), path);
 459                         wfree(path);
 460                         wfree(suffix);
 461                         return NULL;
 462                 }
 463         }
 464         strcat(path, "/CachedPixmaps");
 465         if (access(path, F_OK) != 0) {
 466                 if (mkdir(path, S_IRUSR | S_IWUSR | S_IXUSR) != 0) {
 467                         wsyserror(_("could not create directory %s"), path);
 468                         wfree(path);
 469                         wfree(suffix);
 470                         return NULL;
 471                 }
 472         }
 473
 474         strcat(path, "/");
 475         strcat(path, suffix);
 476         strcat(path, ".xpm");
 477         wfree(suffix);
 478
 479         return path;
 480 }
 481
 482 /*
 483  * wIconStore--
 484  *      Stores the client supplied icon at ~/GNUstep/Library/WindowMaker/CachedPixmaps
 485  * and returns the path for that icon. Returns NULL if there is no
 486  * client supplied icon or on failure.
 487  *
 488  * Side effects:
 489  *      New directories might be created.
 490  */
 491 char *wIconStore(WIcon * icon)
 492 {
 493         char *path;
 494         RImage *image;
 495         WWindow *wwin = icon->owner;
 496
 497         if (!wwin || !wwin->wm_hints || !(wwin->wm_hints->flags & IconPixmapHint)
 498             || wwin->wm_hints->icon_pixmap == None)
 499                 return NULL;
 500
 501         path = getnameforicon(wwin);
 502         if (!path)
 503                 return NULL;
 504
 505         image = RCreateImageFromDrawable(icon->core->screen_ptr->rcontext,
 506                                          wwin->wm_hints->icon_pixmap, (wwin->wm_hints->flags & IconMaskHint)
 507                                          ? wwin->wm_hints->icon_mask : None);
 508         if (!image) {
 509                 wfree(path);
 510                 return NULL;
 511         }
 512
 513         if (!RSaveImage(image, path, "XPM")) {
 514                 wfree(path);
 515                 path = NULL;
 516         }
 517         RReleaseImage(image);
 518
 519         return path;
 520 }
 521
 522 /*
 523 void wIconChangeIconWindow(WIcon *icon, Window new_window);
 524 */
 525
 526 static void cycleColor(void *data)
 527 {
 528         WIcon *icon = (WIcon *) data;
 529         WScreen *scr = icon->core->screen_ptr;
 530         XGCValues gcv;
 531
 532         icon->step--;
 533         gcv.dash_offset = icon->step;
 534         XChangeGC(dpy, scr->icon_select_gc, GCDashOffset, &gcv);
 535
 536         XDrawRectangle(dpy, icon->core->window, scr->icon_select_gc, 0, 0,
 537                        icon->core->width - 1, icon->core->height - 1);
 538         icon->handlerID = WMAddTimerHandler(COLOR_CYCLE_DELAY, cycleColor, icon);
 539 }
 540
 541 void wIconSetHighlited(WIcon * icon, Bool flag)
 542 {
 543         if (icon->highlighted == flag) {
 544                 return;
 545         }
 546
 547         icon->highlighted = flag;
 548         wIconPaint(icon);
 549 }
 550
 551 void wIconSelect(WIcon * icon)
 552 {
 553         WScreen *scr = icon->core->screen_ptr;
 554         icon->selected = !icon->selected;
 555
 556         if (icon->selected) {
 557                 icon->step = 0;
 558                 if (!wPreferences.dont_blink)
 559                         icon->handlerID = WMAddTimerHandler(10, cycleColor, icon);
 560                 else
 561                         XDrawRectangle(dpy, icon->core->window, scr->icon_select_gc, 0, 0,
 562                                        icon->core->width - 1, icon->core->height - 1);
 563         } else {
 564                 if (icon->handlerID) {
 565                         WMDeleteTimerHandler(icon->handlerID);
 566                         icon->handlerID = NULL;
 567                 }
 568                 XClearArea(dpy, icon->core->window, 0, 0, icon->core->width, icon->core->height, True);
 569         }
 570 }
 571
 572 void wIconUpdate(WIcon * icon)
 573 {
 574         WScreen *scr = icon->core->screen_ptr;
 575         int title_height = WMFontHeight(scr->icon_title_font);
 576         WWindow *wwin = icon->owner;
 577
 578         assert(scr->icon_tile != NULL);
 579
 580         if (icon->pixmap != None)
 581                 XFreePixmap(dpy, icon->pixmap);
 582         icon->pixmap = None;
 583
 584         if (wwin && (WFLAGP(wwin, always_user_icon) || wwin->net_icon_image))
 585                 goto user_icon;
 586
 587         /* use client specified icon window */
 588         if (icon->icon_win != None) {
 589                 XWindowAttributes attr;
 590                 int resize = 0;
 591                 unsigned int width, height, depth;
 592                 int theight;
 593                 Pixmap pixmap;
 594
 595                 getSize(icon->icon_win, &width, &height, &depth);
 596
 597                 if (width > wPreferences.icon_size) {
 598                         resize = 1;
 599                         width = wPreferences.icon_size;
 600                 }
 601                 if (height > wPreferences.icon_size) {
 602                         resize = 1;
 603                         height = wPreferences.icon_size;
 604                 }
 605                 if (icon->show_title && (height + title_height < wPreferences.icon_size)) {
 606                         pixmap = XCreatePixmap(dpy, scr->w_win, wPreferences.icon_size,
 607                                                wPreferences.icon_size, scr->w_depth);
 608                         XSetClipMask(dpy, scr->copy_gc, None);
 609                         XCopyArea(dpy, scr->icon_tile_pixmap, pixmap, scr->copy_gc, 0, 0,
 610                                   wPreferences.icon_size, wPreferences.icon_size, 0, 0);
 611                         drawIconTitle(scr, pixmap, title_height);
 612                         theight = title_height;
 613                 } else {
 614                         pixmap = None;
 615                         theight = 0;
 616                         XSetWindowBackgroundPixmap(dpy, icon->core->window, scr->icon_tile_pixmap);
 617                 }
 618
 619                 XSetWindowBorderWidth(dpy, icon->icon_win, 0);
 620                 XReparentWindow(dpy, icon->icon_win, icon->core->window,
 621                                 (wPreferences.icon_size - width) / 2,
 622                                 theight + (wPreferences.icon_size - height - theight) / 2);
 623                 if (resize)
 624                         XResizeWindow(dpy, icon->icon_win, width, height);
 625
 626                 XMapWindow(dpy, icon->icon_win);
 627
 628                 XAddToSaveSet(dpy, icon->icon_win);
 629
 630                 icon->pixmap = pixmap;
 631
 632                 if (XGetWindowAttributes(dpy, icon->icon_win, &attr)) {
 633                         if (attr.all_event_masks & ButtonPressMask) {
 634                                 wHackedGrabButton(Button1, MOD_MASK, icon->core->window, True,
 635                                                   ButtonPressMask, GrabModeSync, GrabModeAsync,
 636                                                   None, wCursor[WCUR_ARROW]);
 637                         }
 638                 }
 639         } else if (wwin && wwin->wm_hints && (wwin->wm_hints->flags & IconPixmapHint)) {
 640                 int x, y;
 641                 unsigned int w, h;
 642                 Window jw;
 643                 int ji, dotitle;
 644                 unsigned int ju, d;
 645                 Pixmap pixmap;
 646
 647                 if (!XGetGeometry(dpy, wwin->wm_hints->icon_pixmap, &jw, &ji, &ji, &w, &h, &ju, &d)) {
 648                         icon->owner->wm_hints->flags &= ~IconPixmapHint;
 649                         goto user_icon;
 650                 }
 651
 652                 pixmap = XCreatePixmap(dpy, icon->core->window, wPreferences.icon_size,
 653                                        wPreferences.icon_size, scr->w_depth);
 654                 XSetClipMask(dpy, scr->copy_gc, None);
 655                 XCopyArea(dpy, scr->icon_tile_pixmap, pixmap, scr->copy_gc, 0, 0,
 656                           wPreferences.icon_size, wPreferences.icon_size, 0, 0);
 657
 658                 if (w > wPreferences.icon_size)
 659                         w = wPreferences.icon_size;
 660                 x = (wPreferences.icon_size - w) / 2;
 661
 662                 if (icon->show_title && (title_height < wPreferences.icon_size)) {
 663                         drawIconTitle(scr, pixmap, title_height);
 664                         dotitle = 1;
 665
 666                         if (h > wPreferences.icon_size - title_height - 2) {
 667                                 h = wPreferences.icon_size - title_height - 2;
 668                                 y = title_height + 1;
 669                         } else {
 670                                 y = (wPreferences.icon_size - h - title_height) / 2 + title_height + 1;
 671                         }
 672                 } else {
 673                         dotitle = 0;
 674                         if (w > wPreferences.icon_size)
 675                                 w = wPreferences.icon_size;
 676                         y = (wPreferences.icon_size - h) / 2;
 677                 }
 678
 679                 if (wwin->wm_hints->flags & IconMaskHint)
 680                         XSetClipMask(dpy, scr->copy_gc, wwin->wm_hints->icon_mask);
 681
 682                 XSetClipOrigin(dpy, scr->copy_gc, x, y);
 683
 684                 if (d != scr->w_depth) {
 685                         XSetForeground(dpy, scr->copy_gc, scr->black_pixel);
 686                         XSetBackground(dpy, scr->copy_gc, scr->white_pixel);
 687                         XCopyPlane(dpy, wwin->wm_hints->icon_pixmap, pixmap, scr->copy_gc, 0, 0, w, h, x, y, 1);
 688                 } else {
 689                         XCopyArea(dpy, wwin->wm_hints->icon_pixmap, pixmap, scr->copy_gc, 0, 0, w, h, x, y);
 690                 }
 691
 692                 XSetClipOrigin(dpy, scr->copy_gc, 0, 0);
 693
 694                 icon->pixmap = pixmap;
 695         } else {
 696  user_icon:
 697
 698                 if (icon->image) {
 699                         icon->pixmap = makeIcon(scr, icon->image, icon->show_title,
 700                                                 icon->shadowed, icon->tile_type);
 701                 } else {
 702                         /* make default icons */
 703
 704                         if (!scr->def_icon_pixmap) {
 705                                 RImage *image = NULL;
 706                                 char *path;
 707                                 char *file;
 708
 709                                 file = wDefaultGetIconFile(scr, NULL, NULL, False);
 710                                 if (file) {
 711                                         path = FindImage(wPreferences.icon_path, file);
 712                                         if (!path) {
 713                                                 wwarning(_("could not find default icon \"%s\""), file);
 714                                                 goto make_icons;
 715                                         }
 716
 717                                         image = RLoadImage(scr->rcontext, path, 0);
 718                                         if (!image) {
 719                                                 wwarning(_("could not load default icon \"%s\":%s"),
 720                                                          file, RMessageForError(RErrorCode));
 721                                         }
 722                                         wfree(path);
 723                                 }
 724  make_icons:
 725
 726                                 image = wIconValidateIconSize(scr, image);
 727                                 scr->def_icon_pixmap = makeIcon(scr, image, False, False, icon->tile_type);
 728                                 scr->def_ticon_pixmap = makeIcon(scr, image, True, False, icon->tile_type);
 729                                 if (image)
 730                                         RReleaseImage(image);
 731                         }
 732
 733                         if (icon->show_title) {
 734                                 XSetWindowBackgroundPixmap(dpy, icon->core->window, scr->def_ticon_pixmap);
 735                         } else {
 736                                 XSetWindowBackgroundPixmap(dpy, icon->core->window, scr->def_icon_pixmap);
 737                         }
 738                         icon->pixmap = None;
 739                 }
 740         }
 741         if (icon->pixmap != None) {
 742                 XSetWindowBackgroundPixmap(dpy, icon->core->window, icon->pixmap);
 743         }
 744         XClearWindow(dpy, icon->core->window);
 745
 746         wIconPaint(icon);
 747 }
 748
 749 void wIconPaint(WIcon * icon)
 750 {
 751         WScreen *scr = icon->core->screen_ptr;
 752         int x;
 753         char *tmp;
 754
 755         if (icon->force_paint) {
 756                 icon->force_paint = 0;
 757                 wIconUpdate(icon);
 758                 return;
 759         }
 760
 761         XClearWindow(dpy, icon->core->window);
 762
 763         /* draw the icon title */
 764         if (icon->show_title && icon->icon_name != NULL) {
 765                 int l;
 766                 int w;
 767
 768                 tmp = ShrinkString(scr->icon_title_font, icon->icon_name, wPreferences.icon_size - 4);
 769                 w = WMWidthOfString(scr->icon_title_font, tmp, l = strlen(tmp));
 770
 771                 if (w > icon->core->width - 4)
 772                         x = (icon->core->width - 4) - w;
 773                 else
 774                         x = (icon->core->width - w) / 2;
 775
 776                 WMDrawString(scr->wmscreen, icon->core->window, scr->icon_title_color,
 777                              scr->icon_title_font, x, 1, tmp, l);
 778                 wfree(tmp);
 779         }
 780
 781         if (icon->selected)
 782                 XDrawRectangle(dpy, icon->core->window, scr->icon_select_gc, 0, 0,
 783                                icon->core->width - 1, icon->core->height - 1);
 784 }
 785
 786 /******************************************************************/
 787
 788 static void miniwindowExpose(WObjDescriptor * desc, XEvent * event)
 789 {
 790         wIconPaint(desc->parent);
 791 }
 792
 793 static void miniwindowDblClick(WObjDescriptor * desc, XEvent * event)
 794 {
 795         WIcon *icon = desc->parent;
 796
 797         assert(icon->owner != NULL);
 798
 799         wDeiconifyWindow(icon->owner);
 800 }
 801
 802 static void miniwindowMouseDown(WObjDescriptor * desc, XEvent * event)
 803 {
 804         WIcon *icon = desc->parent;
 805         WWindow *wwin = icon->owner;
 806         XEvent ev;
 807         int x = wwin->icon_x, y = wwin->icon_y;
 808         int dx = event->xbutton.x, dy = event->xbutton.y;
 809         int grabbed = 0;
 810         int clickButton = event->xbutton.button;
 811         Bool hasMoved = False;
 812
 813         if (WCHECK_STATE(WSTATE_MODAL))
 814                 return;
 815
 816         if (IsDoubleClick(icon->core->screen_ptr, event)) {
 817                 miniwindowDblClick(desc, event);
 818                 return;
 819         }
 820 #ifdef DEBUG
 821         puts("Moving miniwindow");
 822 #endif
 823         if (event->xbutton.button == Button1) {
 824                 if (event->xbutton.state & MOD_MASK)
 825                         wLowerFrame(icon->core);
 826                 else
 827                         wRaiseFrame(icon->core);
 828                 if (event->xbutton.state & ShiftMask) {
 829                         wIconSelect(icon);
 830                         wSelectWindow(icon->owner, !wwin->flags.selected);
 831                 }
 832         } else if (event->xbutton.button == Button3) {
 833                 WObjDescriptor *desc;
 834
 835                 OpenMiniwindowMenu(wwin, event->xbutton.x_root, event->xbutton.y_root);
 836
 837                 /* allow drag select of menu */
 838                 desc = &wwin->screen_ptr->window_menu->menu->descriptor;
 839                 event->xbutton.send_event = True;
 840                 (*desc->handle_mousedown) (desc, event);
 841
 842                 return;
 843         }
 844
 845         if (XGrabPointer(dpy, icon->core->window, False, ButtonMotionMask
 846                          | ButtonReleaseMask | ButtonPressMask, GrabModeAsync,
 847                          GrabModeAsync, None, None, CurrentTime) != GrabSuccess) {
 848 #ifdef DEBUG0
 849                 wwarning("pointer grab failed for icon move");
 850 #endif
 851         }
 852         while (1) {
 853                 WMMaskEvent(dpy, PointerMotionMask | ButtonReleaseMask | ButtonPressMask
 854                             | ButtonMotionMask | ExposureMask, &ev);
 855                 switch (ev.type) {
 856                 case Expose:
 857                         WMHandleEvent(&ev);
 858                         break;
 859
 860                 case MotionNotify:
 861                         hasMoved = True;
 862                         if (!grabbed) {
 863                                 if (abs(dx - ev.xmotion.x) >= MOVE_THRESHOLD
 864                                     || abs(dy - ev.xmotion.y) >= MOVE_THRESHOLD) {
 865                                         XChangeActivePointerGrab(dpy, ButtonMotionMask
 866                                                                  | ButtonReleaseMask | ButtonPressMask,
 867                                                                  wCursor[WCUR_MOVE], CurrentTime);
 868                                         grabbed = 1;
 869                                 } else {
 870                                         break;
 871                                 }
 872                         }
 873                         x = ev.xmotion.x_root - dx;
 874                         y = ev.xmotion.y_root - dy;
 875                         XMoveWindow(dpy, icon->core->window, x, y);
 876                         break;
 877
 878                 case ButtonPress:
 879                         break;
 880
 881                 case ButtonRelease:
 882                         if (ev.xbutton.button != clickButton)
 883                                 break;
 884
 885                         if (wwin->icon_x != x || wwin->icon_y != y)
 886                                 wwin->flags.icon_moved = 1;
 887
 888                         XMoveWindow(dpy, icon->core->window, x, y);
 889
 890                         wwin->icon_x = x;
 891                         wwin->icon_y = y;
 892 #ifdef DEBUG
 893                         puts("End miniwindow move");
 894 #endif
 895                         XUngrabPointer(dpy, CurrentTime);
 896
 897                         if (wPreferences.auto_arrange_icons)
 898                                 wArrangeIcons(wwin->screen_ptr, True);
 899                         if (wPreferences.single_click && !hasMoved)
 900                                 miniwindowDblClick(desc, event);
 901                         return;
 902
 903                 }
 904         }
 905 }