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