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 "stacking.h"
  42 #include "application.h"
  43 #include "defaults.h"
  44 #include "appicon.h"
  45 #include "wmspec.h"
  46 #include "misc.h"
  47 #include "startup.h"
  48 #include "event.h"
  49 #include "winmenu.h"
  50
  51 /**** Global varianebles ****/
  52
  53 #define MOD_MASK wPreferences.modifier_mask
  54 #define CACHE_ICON_PATH "/" PACKAGE_TARNAME "/CachedPixmaps"
  55 #define ICON_BORDER 3
  56
  57 static void miniwindowExpose(WObjDescriptor *desc, XEvent *event);
  58 static void miniwindowMouseDown(WObjDescriptor *desc, XEvent *event);
  59 static void miniwindowDblClick(WObjDescriptor *desc, XEvent *event);
  60
  61 static WIcon *icon_create_core(WScreen *scr, int coord_x, int coord_y);
  62
  63 static void set_dockapp_in_icon(WIcon *icon);
  64 static void get_rimage_icon_from_icon_win(WIcon *icon);
  65 static void get_rimage_icon_from_user_icon(WIcon *icon);
  66 static void get_rimage_icon_from_default_icon(WIcon *icon);
  67 static void get_rimage_icon_from_x11(WIcon *icon);
  68
  69 static void icon_update_pixmap(WIcon *icon, RImage *image);
  70 static void unset_icon_image(WIcon *icon);
  71
  72 /****** Notification Observers ******/
  73
  74 static void appearanceObserver(void *self, WMNotification *notif)
  75 {
  76         WIcon *icon = (WIcon *) self;
  77         uintptr_t flags = (uintptr_t)WMGetNotificationClientData(notif);
  78
  79         if ((flags & WTextureSettings) || (flags & WFontSettings)) {
  80                 /* If the rimage exists, update the icon, else create it */
  81                 if (icon->file_image)
  82                         update_icon_pixmap(icon);
  83                 else
  84                         wIconPaint(icon);
  85         }
  86
  87         /* so that the appicon expose handlers will paint the appicon specific
  88          * stuff */
  89         XClearArea(dpy, icon->core->window, 0, 0, icon->core->width, icon->core->height, True);
  90 }
  91
  92 static void tileObserver(void *self, WMNotification *notif)
  93 {
  94         WIcon *icon = (WIcon *) self;
  95
  96         /* Parameter not used, but tell the compiler that it is ok */
  97         (void) notif;
  98
  99         update_icon_pixmap(icon);
 100
 101         XClearArea(dpy, icon->core->window, 0, 0, 1, 1, True);
 102 }
 103
 104 /************************************/
 105
 106 static int getSize(Drawable d, unsigned int *w, unsigned int *h, unsigned int *dep)
 107 {
 108         Window rjunk;
 109         int xjunk, yjunk;
 110         unsigned int bjunk;
 111
 112         return XGetGeometry(dpy, d, &rjunk, &xjunk, &yjunk, w, h, &bjunk, dep);
 113 }
 114
 115 WIcon *icon_create_for_wwindow(WWindow *wwin)
 116 {
 117         WScreen *scr = wwin->screen_ptr;
 118         WIcon *icon;
 119
 120         icon = icon_create_core(scr, wwin->icon_x, wwin->icon_y);
 121
 122         icon->owner = wwin;
 123         if (wwin->wm_hints && (wwin->wm_hints->flags & IconWindowHint)) {
 124                 if (wwin->client_win == wwin->main_window) {
 125                         WApplication *wapp;
 126                         /* do not let miniwindow steal app-icon's icon window */
 127                         wapp = wApplicationOf(wwin->client_win);
 128                         if (!wapp || wapp->app_icon == NULL)
 129                                 icon->icon_win = wwin->wm_hints->icon_window;
 130                 } else {
 131                         icon->icon_win = wwin->wm_hints->icon_window;
 132                 }
 133         }
 134 #ifdef NO_MINIWINDOW_TITLES
 135         icon->show_title = 0;
 136 #else
 137         icon->show_title = 1;
 138 #endif
 139
 140         wIconChangeTitle(icon, wwin);
 141         icon->tile_type = TILE_NORMAL;
 142
 143         set_icon_image_from_database(icon, wwin->wm_instance, wwin->wm_class, NULL);
 144         /* Update the icon, because icon could be NULL */
 145         wIconUpdate(icon);
 146
 147         WMAddNotificationObserver(appearanceObserver, icon, WNIconAppearanceSettingsChanged, icon);
 148         WMAddNotificationObserver(tileObserver, icon, WNIconTileSettingsChanged, icon);
 149
 150         return icon;
 151 }
 152
 153 WIcon *icon_create_for_dock(WScreen *scr, const char *command, const char *wm_instance, const char *wm_class, int tile)
 154 {
 155         WIcon *icon;
 156
 157         icon = icon_create_core(scr, 0, 0);
 158         icon->tile_type = tile;
 159
 160         set_icon_image_from_database(icon, wm_instance, wm_class, command);
 161         /* Update the icon, because icon could be NULL */
 162         wIconUpdate(icon);
 163
 164         WMAddNotificationObserver(appearanceObserver, icon, WNIconAppearanceSettingsChanged, icon);
 165         WMAddNotificationObserver(tileObserver, icon, WNIconTileSettingsChanged, icon);
 166
 167         return icon;
 168 }
 169
 170 static WIcon *icon_create_core(WScreen *scr, int coord_x, int coord_y)
 171 {
 172         WIcon *icon;
 173
 174         icon = wmalloc(sizeof(WIcon));
 175         icon->core = wCoreCreateTopLevel(scr,
 176                                          coord_x,
 177                                          coord_y,
 178                                          wPreferences.icon_size,
 179                                          wPreferences.icon_size,
 180                                          0, scr->w_depth, scr->w_visual, scr->w_colormap,
 181                                          scr->white_pixel);
 182
 183         /* will be overriden if this is a application icon */
 184         icon->core->descriptor.handle_mousedown = miniwindowMouseDown;
 185         icon->core->descriptor.handle_expose = miniwindowExpose;
 186         icon->core->descriptor.parent_type = WCLASS_MINIWINDOW;
 187         icon->core->descriptor.parent = icon;
 188
 189         icon->core->stacking = wmalloc(sizeof(WStacking));
 190         icon->core->stacking->above = NULL;
 191         icon->core->stacking->under = NULL;
 192         icon->core->stacking->window_level = NORMAL_ICON_LEVEL;
 193         icon->core->stacking->child_of = NULL;
 194
 195         /* Icon image */
 196         icon->file = NULL;
 197         icon->file_image = NULL;
 198
 199         return icon;
 200 }
 201
 202 void wIconDestroy(WIcon *icon)
 203 {
 204         WCoreWindow *core = icon->core;
 205         WScreen *scr = core->screen_ptr;
 206
 207         WMRemoveNotificationObserver(icon);
 208
 209         if (icon->handlerID)
 210                 WMDeleteTimerHandler(icon->handlerID);
 211
 212         if (icon->icon_win) {
 213                 int x = 0, y = 0;
 214
 215                 if (icon->owner) {
 216                         x = icon->owner->icon_x;
 217                         y = icon->owner->icon_y;
 218                 }
 219                 XUnmapWindow(dpy, icon->icon_win);
 220                 XReparentWindow(dpy, icon->icon_win, scr->root_win, x, y);
 221         }
 222         if (icon->icon_name)
 223                 XFree(icon->icon_name);
 224
 225         if (icon->pixmap)
 226                 XFreePixmap(dpy, icon->pixmap);
 227
 228         if (icon->mini_preview)
 229                 XFreePixmap(dpy, icon->mini_preview);
 230
 231         unset_icon_image(icon);
 232
 233         wCoreDestroy(icon->core);
 234         wfree(icon);
 235 }
 236
 237 static void drawIconTitleBackground(WScreen *scr, Pixmap pixmap, int height)
 238 {
 239         XFillRectangle(dpy, pixmap, scr->icon_title_texture->normal_gc, 0, 0, wPreferences.icon_size, height + 1);
 240         XDrawLine(dpy, pixmap, scr->icon_title_texture->light_gc, 0, 0, wPreferences.icon_size, 0);
 241         XDrawLine(dpy, pixmap, scr->icon_title_texture->light_gc, 0, 0, 0, height + 1);
 242         XDrawLine(dpy, pixmap, scr->icon_title_texture->dim_gc,
 243                   wPreferences.icon_size - 1, 0, wPreferences.icon_size - 1, height + 1);
 244 }
 245
 246 static void icon_update_pixmap(WIcon *icon, RImage *image)
 247 {
 248         RImage *tile;
 249         Pixmap pixmap;
 250         int x, y, sx, sy;
 251         unsigned w, h;
 252         int theight = 0;
 253         WScreen *scr = icon->core->screen_ptr;
 254
 255         switch (icon->tile_type) {
 256         case TILE_NORMAL:
 257                 tile = RCloneImage(scr->icon_tile);
 258                 break;
 259         case TILE_CLIP:
 260                 tile = RCloneImage(scr->clip_tile);
 261                 break;
 262         case TILE_DRAWER:
 263                 tile = RCloneImage(scr->drawer_tile);
 264                 break;
 265         default:
 266                 /*
 267                  * The icon has always rigth value, this case is
 268                  * only to avoid a compiler warning with "tile"
 269                  * "may be used uninitialized"
 270                  */
 271                 wwarning("Unknown tile type: %d.\n", icon->tile_type);
 272                 tile = RCloneImage(scr->icon_tile);
 273         }
 274
 275         if (image) {
 276                 w = (image->width > wPreferences.icon_size)
 277                     ? wPreferences.icon_size : image->width;
 278                 x = (wPreferences.icon_size - w) / 2;
 279                 sx = (image->width - w) / 2;
 280
 281                 if (icon->show_title)
 282                         theight = WMFontHeight(scr->icon_title_font);
 283
 284                 h = (image->height + theight > wPreferences.icon_size
 285                      ? wPreferences.icon_size - theight : image->height);
 286                 y = theight + (wPreferences.icon_size - theight - h) / 2;
 287                 sy = (image->height - h) / 2;
 288
 289                 RCombineArea(tile, image, sx, sy, w, h, x, y);
 290         }
 291
 292         if (icon->shadowed) {
 293                 RColor color;
 294
 295                 color.red = scr->icon_back_texture->light.red >> 8;
 296                 color.green = scr->icon_back_texture->light.green >> 8;
 297                 color.blue = scr->icon_back_texture->light.blue >> 8;
 298                 color.alpha = 150;      /* about 60% */
 299                 RClearImage(tile, &color);
 300         }
 301
 302         if (icon->highlighted) {
 303                 RColor color;
 304
 305                 color.red = color.green = color.blue = 0;
 306                 color.alpha = 160;
 307                 RLightImage(tile, &color);
 308         }
 309
 310         if (!RConvertImage(scr->rcontext, tile, &pixmap))
 311                 wwarning(_("error rendering image:%s"), RMessageForError(RErrorCode));
 312
 313         RReleaseImage(tile);
 314
 315         /* Draw the icon's title background (without text) */
 316         if (icon->show_title)
 317                 drawIconTitleBackground(scr, pixmap, theight);
 318
 319         icon->pixmap = pixmap;
 320 }
 321
 322 void wIconChangeTitle(WIcon *icon, WWindow *wwin)
 323 {
 324         if (!icon || !wwin)
 325                 return;
 326
 327         /* Remove the previous icon title */
 328         if (icon->icon_name != NULL)
 329                 XFree(icon->icon_name);
 330
 331         /* Set the new one, using two methods to identify
 332         the icon name or switch back to window name */
 333         icon->icon_name = wNETWMGetIconName(wwin->client_win);
 334         if (!icon->icon_name)
 335                 if (!wGetIconName(dpy, wwin->client_win, &icon->icon_name))
 336                         icon->icon_name = wNETWMGetWindowName(wwin->client_win);
 337 }
 338
 339 RImage *wIconValidateIconSize(RImage *icon, int max_size)
 340 {
 341         RImage *nimage;
 342
 343         if (!icon)
 344                 return NULL;
 345
 346         /* We should hold "ICON_BORDER" (~2) pixels to include the icon border */
 347         if (((max_size + ICON_BORDER) < icon->width) ||
 348             ((max_size + ICON_BORDER) < icon->height)) {
 349                 if (icon->width > icon->height)
 350                         nimage = RScaleImage(icon, max_size - ICON_BORDER,
 351                                              (icon->height * (max_size - ICON_BORDER) / icon->width));
 352                 else
 353                         nimage = RScaleImage(icon, (icon->width * (max_size - ICON_BORDER) / icon->height),
 354                                              max_size - ICON_BORDER);
 355                 RReleaseImage(icon);
 356                 icon = nimage;
 357         }
 358
 359         return icon;
 360 }
 361
 362 int wIconChangeImageFile(WIcon *icon, const char *file)
 363 {
 364         WScreen *scr = icon->core->screen_ptr;
 365         char *path;
 366         RImage *image = NULL;
 367
 368         /* If no new image, don't do nothing */
 369         if (!file)
 370                 return 1;
 371
 372         /* Find the new image */
 373         path = FindImage(wPreferences.icon_path, file);
 374         if (!path)
 375                 return 0;
 376
 377         image = get_rimage_from_file(scr, path, wPreferences.icon_size);
 378         if (!image) {
 379                 wfree(path);
 380                 return 0;
 381         }
 382
 383         /* Set the new image */
 384         set_icon_image_from_image(icon, image);
 385         icon->file = wstrdup(path);
 386         update_icon_pixmap(icon);
 387
 388         wfree(path);
 389         return 1;
 390 }
 391
 392 static char *get_name_for_wwin(WWindow *wwin)
 393 {
 394         return get_name_for_instance_class(wwin->wm_instance, wwin->wm_class);
 395 }
 396
 397 char *get_name_for_instance_class(const char *wm_instance, const char *wm_class)
 398 {
 399         char *suffix;
 400         int len;
 401
 402         if (wm_class && wm_instance) {
 403                 len = strlen(wm_class) + strlen(wm_instance) + 2;
 404                 suffix = wmalloc(len);
 405                 snprintf(suffix, len, "%s.%s", wm_instance, wm_class);
 406         } else if (wm_class) {
 407                 len = strlen(wm_class) + 1;
 408                 suffix = wmalloc(len);
 409                 snprintf(suffix, len, "%s", wm_class);
 410         } else if (wm_instance) {
 411                 len = strlen(wm_instance) + 1;
 412                 suffix = wmalloc(len);
 413                 snprintf(suffix, len, "%s", wm_instance);
 414         } else {
 415                 return NULL;
 416         }
 417
 418         return suffix;
 419 }
 420
 421 static char *get_icon_cache_path(void)
 422 {
 423         const char *prefix;
 424         char *path;
 425         int ret;
 426
 427         prefix = wuserdatapath();
 428         path = wstrconcat(prefix, CACHE_ICON_PATH "/");
 429
 430         /* If the folder exists, exit */
 431         if (access(path, F_OK) == 0)
 432                 return path;
 433
 434         /* Create the folder */
 435         ret = wmkdirhier(path);
 436
 437         /* Exit 1 on success, 0 on failure */
 438         if (ret == 1)
 439                 return path;
 440
 441         /* Fail */
 442         wfree(path);
 443         return NULL;
 444 }
 445
 446 static RImage *get_wwindow_image_from_wmhints(WWindow *wwin, WIcon *icon)
 447 {
 448         RImage *image = NULL;
 449         XWMHints *hints = wwin->wm_hints;
 450
 451         if (hints && (hints->flags & IconPixmapHint) && hints->icon_pixmap != None)
 452                 image = RCreateImageFromDrawable(icon->core->screen_ptr->rcontext,
 453                                                  hints->icon_pixmap,
 454                                                  (hints->flags & IconMaskHint)
 455                                                  ? hints->icon_mask : None);
 456
 457         return image;
 458 }
 459
 460 /*
 461  * wIconStore--
 462  *      Stores the client supplied icon at CACHE_ICON_PATH
 463  * and returns the path for that icon. Returns NULL if there is no
 464  * client supplied icon or on failure.
 465  *
 466  * Side effects:
 467  *      New directories might be created.
 468  */
 469 char *wIconStore(WIcon *icon)
 470 {
 471         char *path, *dir_path, *file, *filename;
 472         int len = 0;
 473         RImage *image = NULL;
 474         WWindow *wwin = icon->owner;
 475
 476         if (!wwin)
 477                 return NULL;
 478
 479         dir_path = get_icon_cache_path();
 480         if (!dir_path)
 481                 return NULL;
 482
 483         file = get_name_for_wwin(wwin);
 484         if (!file) {
 485                 wfree(dir_path);
 486                 return NULL;
 487         }
 488
 489         /* Create the file name */
 490         len = strlen(file) + 5;
 491         filename = wmalloc(len);
 492         snprintf(filename, len, "%s.xpm", file);
 493         wfree(file);
 494
 495         /* Create the full path, including the filename */
 496         len = strlen(dir_path) + strlen(filename) + 1;
 497         path = wmalloc(len);
 498         snprintf(path, len, "%s%s", dir_path, filename);
 499         wfree(dir_path);
 500
 501         /* If icon exists, exit */
 502         if (access(path, F_OK) == 0) {
 503                 wfree(path);
 504                 return filename;
 505         }
 506
 507         if (wwin->net_icon_image)
 508                 image = RRetainImage(wwin->net_icon_image);
 509         else
 510                 image = get_wwindow_image_from_wmhints(wwin, icon);
 511
 512         if (!image) {
 513                 wfree(path);
 514                 wfree(filename);
 515                 return NULL;
 516         }
 517
 518         if (!RSaveImage(image, path, "XPM")) {
 519                 wfree(filename);
 520                 filename = NULL;
 521         }
 522
 523         wfree(path);
 524         RReleaseImage(image);
 525
 526         return filename;
 527 }
 528
 529 void remove_cache_icon(char *filename)
 530 {
 531         char *cachepath;
 532
 533         if (!filename)
 534                 return;
 535
 536         cachepath = get_icon_cache_path();
 537         if (!cachepath)
 538                 return;
 539
 540         /* Filename check/parse could be here */
 541         if (!strncmp(filename, cachepath, strlen(cachepath)))
 542                 unlink(filename);
 543
 544         wfree(cachepath);
 545 }
 546
 547 static void cycleColor(void *data)
 548 {
 549         WIcon *icon = (WIcon *) data;
 550         WScreen *scr = icon->core->screen_ptr;
 551         XGCValues gcv;
 552
 553         icon->step--;
 554         gcv.dash_offset = icon->step;
 555         XChangeGC(dpy, scr->icon_select_gc, GCDashOffset, &gcv);
 556
 557         XDrawRectangle(dpy, icon->core->window, scr->icon_select_gc, 0, 0,
 558                        icon->core->width - 1, icon->core->height - 1);
 559         icon->handlerID = WMAddTimerHandler(COLOR_CYCLE_DELAY, cycleColor, icon);
 560 }
 561
 562 void wIconSetHighlited(WIcon *icon, Bool flag)
 563 {
 564         if (icon->highlighted == flag)
 565                 return;
 566
 567         icon->highlighted = flag;
 568         update_icon_pixmap(icon);
 569 }
 570
 571 void wIconSelect(WIcon *icon)
 572 {
 573         WScreen *scr = icon->core->screen_ptr;
 574         icon->selected = !icon->selected;
 575
 576         if (icon->selected) {
 577                 icon->step = 0;
 578                 if (!wPreferences.dont_blink)
 579                         icon->handlerID = WMAddTimerHandler(10, cycleColor, icon);
 580                 else
 581                         XDrawRectangle(dpy, icon->core->window, scr->icon_select_gc, 0, 0,
 582                                        icon->core->width - 1, icon->core->height - 1);
 583         } else {
 584                 if (icon->handlerID) {
 585                         WMDeleteTimerHandler(icon->handlerID);
 586                         icon->handlerID = NULL;
 587                 }
 588                 XClearArea(dpy, icon->core->window, 0, 0, icon->core->width, icon->core->height, True);
 589         }
 590 }
 591
 592 static void unset_icon_image(WIcon *icon)
 593 {
 594         if (icon->file) {
 595                 wfree(icon->file);
 596                 icon->file = NULL;
 597         }
 598
 599         if (icon->file_image) {
 600                 RReleaseImage(icon->file_image);
 601                 icon->file_image = NULL;
 602         }
 603 }
 604
 605 void set_icon_image_from_image(WIcon *icon, RImage *image)
 606 {
 607         if (!icon)
 608                 return;
 609
 610         unset_icon_image(icon);
 611
 612         icon->file_image = NULL;
 613         icon->file_image = image;
 614 }
 615
 616 void set_icon_minipreview(WIcon *icon, RImage *image)
 617 {
 618         Pixmap tmp;
 619         RImage *scaled_mini_preview;
 620         WScreen *scr = icon->core->screen_ptr;
 621
 622         scaled_mini_preview = RSmoothScaleImage(image, wPreferences.minipreview_size - 2 * MINIPREVIEW_BORDER,
 623                                           wPreferences.minipreview_size - 2 * MINIPREVIEW_BORDER);
 624
 625         if (RConvertImage(scr->rcontext, scaled_mini_preview, &tmp)) {
 626                 if (icon->mini_preview != None)
 627                         XFreePixmap(dpy, icon->mini_preview);
 628                 icon->mini_preview = tmp;
 629         }
 630         RReleaseImage(scaled_mini_preview);
 631 }
 632
 633 void wIconUpdate(WIcon *icon)
 634 {
 635         WWindow *wwin = NULL;
 636
 637         if (icon && icon->owner)
 638                 wwin = icon->owner;
 639
 640         if (wwin && WFLAGP(wwin, always_user_icon)) {
 641                 /* Forced use user_icon */
 642                 get_rimage_icon_from_user_icon(icon);
 643         } else if (icon->icon_win != None) {
 644                 /* Get the Pixmap from the WIcon */
 645                 get_rimage_icon_from_icon_win(icon);
 646         } else if (wwin && wwin->net_icon_image) {
 647                 /* Use _NET_WM_ICON icon */
 648                 get_rimage_icon_from_x11(icon);
 649         } else if (wwin && wwin->wm_hints && (wwin->wm_hints->flags & IconPixmapHint)) {
 650                 /* Get the Pixmap from the wm_hints, else, from the user */
 651                 unset_icon_image(icon);
 652                 icon->file_image = get_rimage_icon_from_wm_hints(icon);
 653                 if (!icon->file_image)
 654                         get_rimage_icon_from_user_icon(icon);
 655         } else {
 656                 /* Get the Pixmap from the user */
 657                 get_rimage_icon_from_user_icon(icon);
 658         }
 659
 660         update_icon_pixmap(icon);
 661 }
 662
 663 void update_icon_pixmap(WIcon *icon)
 664 {
 665         if (icon->pixmap != None)
 666                 XFreePixmap(dpy, icon->pixmap);
 667
 668         icon->pixmap = None;
 669
 670         /* Create the pixmap */
 671         if (icon->file_image)
 672                 icon_update_pixmap(icon, icon->file_image);
 673
 674         /* If dockapp, put inside the icon */
 675         if (icon->icon_win != None) {
 676                 /* file_image is NULL, because is docked app */
 677                 icon_update_pixmap(icon, NULL);
 678                 set_dockapp_in_icon(icon);
 679         }
 680
 681         /* No pixmap, set default background */
 682         if (icon->pixmap != None)
 683                 XSetWindowBackgroundPixmap(dpy, icon->core->window, icon->pixmap);
 684
 685         /* Paint it */
 686         wIconPaint(icon);
 687 }
 688
 689 static void get_rimage_icon_from_x11(WIcon *icon)
 690 {
 691         /* Remove the icon image */
 692         unset_icon_image(icon);
 693
 694         /* Set the new icon image */
 695         icon->file_image = RRetainImage(icon->owner->net_icon_image);
 696 }
 697
 698 static void get_rimage_icon_from_user_icon(WIcon *icon)
 699 {
 700         if (icon->file_image)
 701                 return;
 702
 703         get_rimage_icon_from_default_icon(icon);
 704 }
 705
 706 static void get_rimage_icon_from_default_icon(WIcon *icon)
 707 {
 708         WScreen *scr = icon->core->screen_ptr;
 709
 710         /* If the icon don't have image, we should use the default image. */
 711         if (!scr->def_icon_rimage)
 712                 scr->def_icon_rimage = get_default_image(scr);
 713
 714         /* Remove the icon image */
 715         unset_icon_image(icon);
 716
 717         /* Set the new icon image */
 718         icon->file_image = RRetainImage(scr->def_icon_rimage);
 719 }
 720
 721 /* Get the RImage from the WIcon of the WWindow */
 722 static void get_rimage_icon_from_icon_win(WIcon *icon)
 723 {
 724         RImage *image;
 725
 726         /* Create the new RImage */
 727         image = get_window_image_from_x11(icon->icon_win);
 728
 729         /* Free the icon info */
 730         unset_icon_image(icon);
 731
 732         /* Set the new info */
 733         icon->file_image = image;
 734 }
 735
 736 /* Set the dockapp in the WIcon */
 737 static void set_dockapp_in_icon(WIcon *icon)
 738 {
 739         XWindowAttributes attr;
 740         WScreen *scr = icon->core->screen_ptr;
 741         unsigned int w, h, d;
 742
 743         /* Reparent the dock application to the icon */
 744
 745         /* We need the application size to center it
 746          * and show in the correct position */
 747         getSize(icon->icon_win, &w, &h, &d);
 748
 749         /* Set the background pixmap */
 750         XSetWindowBackgroundPixmap(dpy, icon->core->window, scr->icon_tile_pixmap);
 751
 752         /* Set the icon border */
 753         XSetWindowBorderWidth(dpy, icon->icon_win, 0);
 754
 755         /* Put the dock application in the icon */
 756         XReparentWindow(dpy, icon->icon_win, icon->core->window,
 757                         (wPreferences.icon_size - w) / 2,
 758                         (wPreferences.icon_size - h) / 2);
 759
 760         /* Show it and save */
 761         XMapWindow(dpy, icon->icon_win);
 762         XAddToSaveSet(dpy, icon->icon_win);
 763
 764         /* Needed to move the icon clicking on the application part */
 765         if ((XGetWindowAttributes(dpy, icon->icon_win, &attr)) &&
 766             (attr.all_event_masks & ButtonPressMask))
 767                 wHackedGrabButton(Button1, MOD_MASK, icon->core->window, True,
 768                                   ButtonPressMask, GrabModeSync, GrabModeAsync,
 769                                   None, wPreferences.cursor[WCUR_ARROW]);
 770 }
 771
 772 /* Get the RImage from the XWindow wm_hints */
 773 RImage *get_rimage_icon_from_wm_hints(WIcon *icon)
 774 {
 775         RImage *image = NULL;
 776         unsigned int w, h, d;
 777         WWindow *wwin;
 778
 779         if ((!icon) || (!icon->owner))
 780                 return NULL;
 781
 782         wwin = icon->owner;
 783
 784         if (!getSize(wwin->wm_hints->icon_pixmap, &w, &h, &d)) {
 785                 icon->owner->wm_hints->flags &= ~IconPixmapHint;
 786                 return NULL;
 787         }
 788
 789         image = get_wwindow_image_from_wmhints(wwin, icon);
 790         if (!image)
 791                 return NULL;
 792
 793         /* Resize the icon to the wPreferences.icon_size size */
 794         image = wIconValidateIconSize(image, wPreferences.icon_size);
 795
 796         return image;
 797 }
 798
 799 /* This function updates in the screen the icon title */
 800 static void update_icon_title(WIcon *icon)
 801 {
 802         WScreen *scr = icon->core->screen_ptr;
 803         int x, l, w;
 804         char *tmp;
 805
 806         /* draw the icon title */
 807         if (icon->show_title && icon->icon_name != NULL) {
 808                 tmp = ShrinkString(scr->icon_title_font, icon->icon_name, wPreferences.icon_size - 4);
 809                 w = WMWidthOfString(scr->icon_title_font, tmp, l = strlen(tmp));
 810
 811                 if (w > icon->core->width - 4)
 812                         x = (icon->core->width - 4) - w;
 813                 else
 814                         x = (icon->core->width - w) / 2;
 815
 816                 WMDrawString(scr->wmscreen, icon->core->window, scr->icon_title_color,
 817                              scr->icon_title_font, x, 1, tmp, l);
 818                 wfree(tmp);
 819         }
 820 }
 821
 822
 823 void wIconPaint(WIcon *icon)
 824 {
 825         if (!icon || !icon->core || !icon->core->screen_ptr)
 826                 return;
 827
 828         WScreen *scr = icon->core->screen_ptr;
 829
 830         XClearWindow(dpy, icon->core->window);
 831
 832         update_icon_title(icon);
 833
 834         if (icon->selected)
 835                 XDrawRectangle(dpy, icon->core->window, scr->icon_select_gc, 0, 0,
 836                                icon->core->width - 1, icon->core->height - 1);
 837 }
 838
 839 /******************************************************************/
 840
 841 static void miniwindowExpose(WObjDescriptor *desc, XEvent *event)
 842 {
 843         /* Parameter not used, but tell the compiler that it is ok */
 844         (void) event;
 845
 846         wIconPaint(desc->parent);
 847 }
 848
 849 static void miniwindowDblClick(WObjDescriptor *desc, XEvent *event)
 850 {
 851         WIcon *icon = desc->parent;
 852
 853         /* Parameter not used, but tell the compiler that it is ok */
 854         (void) event;
 855
 856         assert(icon->owner != NULL);
 857
 858         wDeiconifyWindow(icon->owner);
 859 }
 860
 861 static void miniwindowMouseDown(WObjDescriptor *desc, XEvent *event)
 862 {
 863         WIcon *icon = desc->parent;
 864         WWindow *wwin = icon->owner;
 865         XEvent ev;
 866         int x = wwin->icon_x, y = wwin->icon_y;
 867         int dx = event->xbutton.x, dy = event->xbutton.y;
 868         int grabbed = 0;
 869         int clickButton = event->xbutton.button;
 870         Bool hasMoved = False;
 871
 872         if (WCHECK_STATE(WSTATE_MODAL))
 873                 return;
 874
 875         if (IsDoubleClick(icon->core->screen_ptr, event)) {
 876                 miniwindowDblClick(desc, event);
 877                 return;
 878         }
 879
 880         if (event->xbutton.button == Button1) {
 881                 if (event->xbutton.state & MOD_MASK)
 882                         wLowerFrame(icon->core);
 883                 else
 884                         wRaiseFrame(icon->core);
 885                 if (event->xbutton.state & ShiftMask) {
 886                         wIconSelect(icon);
 887                         wSelectWindow(icon->owner, !wwin->flags.selected);
 888                 }
 889         } else if (event->xbutton.button == Button3) {
 890                 WObjDescriptor *desc;
 891
 892                 OpenMiniwindowMenu(wwin, event->xbutton.x_root, event->xbutton.y_root);
 893
 894                 /* allow drag select of menu */
 895                 desc = &wwin->screen_ptr->window_menu->menu->descriptor;
 896                 event->xbutton.send_event = True;
 897                 (*desc->handle_mousedown) (desc, event);
 898
 899                 return;
 900         }
 901
 902         if (XGrabPointer(dpy, icon->core->window, False, ButtonMotionMask
 903                          | ButtonReleaseMask | ButtonPressMask, GrabModeAsync,
 904                          GrabModeAsync, None, None, CurrentTime) != GrabSuccess) {
 905         }
 906         while (1) {
 907                 WMMaskEvent(dpy, PointerMotionMask | ButtonReleaseMask | ButtonPressMask
 908                             | ButtonMotionMask | ExposureMask, &ev);
 909                 switch (ev.type) {
 910                 case Expose:
 911                         WMHandleEvent(&ev);
 912                         break;
 913
 914                 case MotionNotify:
 915                         hasMoved = True;
 916                         if (!grabbed) {
 917                                 if (abs(dx - ev.xmotion.x) >= MOVE_THRESHOLD
 918                                     || abs(dy - ev.xmotion.y) >= MOVE_THRESHOLD) {
 919                                         XChangeActivePointerGrab(dpy, ButtonMotionMask
 920                                                                  | ButtonReleaseMask | ButtonPressMask,
 921                                                                  wPreferences.cursor[WCUR_MOVE], CurrentTime);
 922                                         grabbed = 1;
 923                                 } else {
 924                                         break;
 925                                 }
 926                         }
 927                         x = ev.xmotion.x_root - dx;
 928                         y = ev.xmotion.y_root - dy;
 929                         XMoveWindow(dpy, icon->core->window, x, y);
 930                         break;
 931
 932                 case ButtonPress:
 933                         break;
 934
 935                 case ButtonRelease:
 936                         if (ev.xbutton.button != clickButton)
 937                                 break;
 938
 939                         if (wwin->icon_x != x || wwin->icon_y != y)
 940                                 wwin->flags.icon_moved = 1;
 941
 942                         XMoveWindow(dpy, icon->core->window, x, y);
 943
 944                         wwin->icon_x = x;
 945                         wwin->icon_y = y;
 946                         XUngrabPointer(dpy, CurrentTime);
 947
 948                         if (wPreferences.auto_arrange_icons)
 949                                 wArrangeIcons(wwin->screen_ptr, True);
 950                         if (wPreferences.single_click && !hasMoved)
 951                                 miniwindowDblClick(desc, event);
 952                         return;
 953
 954                 }
 955         }
 956 }
 957
 958 void set_icon_image_from_database(WIcon *icon, const char *wm_instance, const char *wm_class, const char *command)
 959 {
 960         char *file = NULL;
 961
 962         file = get_icon_filename(wm_instance, wm_class, command, False);
 963         if (file) {
 964                 icon->file = wstrdup(file);
 965                 icon->file_image = get_rimage_from_file(icon->core->screen_ptr, icon->file, wPreferences.icon_size);
 966                 wfree(file);
 967         }
 968 }