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