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