src/appicon.c

   1 /* appicon.c- icon for applications (not mini-window)
   2  *
   3  *  Window Maker window manager
   4  *
   5  *  Copyright (c) 1997, 1998 Alfredo K. Kojima
   6  *  Copyright (c) 1998       Dan Pascu
   7  *
   8  *  This program is free software; you can redistribute it and/or modify
   9  *  it under the terms of the GNU General Public License as published by
  10  *  the Free Software Foundation; either version 2 of the License, or
  11  *  (at your option) any later version.
  12  *
  13  *  This program is distributed in the hope that it will be useful,
  14  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16  *  GNU General Public License for more details.
  17  *
  18  *  You should have received a copy of the GNU General Public License
  19  *  along with this program; if not, write to the Free Software
  20  *  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
  21  *  USA.
  22  */
  23
  24 #include "wconfig.h"
  25
  26 #include <X11/Xlib.h>
  27 #include <X11/Xutil.h>
  28 #include <stdlib.h>
  29 #include <string.h>
  30
  31 #include "WindowMaker.h"
  32 #include "wcore.h"
  33 #include "window.h"
  34 #include "icon.h"
  35 #include "appicon.h"
  36 #include "actions.h"
  37 #include "stacking.h"
  38 #include "dock.h"
  39 #include "funcs.h"
  40 #include "defaults.h"
  41 #include "workspace.h"
  42 #include "superfluous.h"
  43 #include "menu.h"
  44 #include "framewin.h"
  45 #include "dialog.h"
  46 #include "client.h"
  47 #ifdef XDND
  48 #include "xdnd.h"
  49 #endif
  50 #include "wsound.h"
  51 #include <WINGs/WINGsP.h>
  52
  53
  54 /*
  55  * icon_file for the dock is got from the preferences file by
  56  * using the classname/instancename
  57  */
  58
  59 /**** Global variables ****/
  60 extern Cursor wCursor[WCUR_LAST];
  61 extern WPreferences wPreferences;
  62
  63 #define MOD_MASK       wPreferences.modifier_mask
  64
  65 void appIconMouseDown(WObjDescriptor *desc, XEvent *event);
  66 static void iconDblClick(WObjDescriptor *desc, XEvent *event);
  67 static void iconExpose(WObjDescriptor *desc, XEvent *event);
  68
  69
  70
  71 WAppIcon*
  72 wAppIconCreateForDock(WScreen *scr, char *command, char *wm_instance,
  73                       char *wm_class, int tile)
  74 {
  75     WAppIcon *dicon;
  76     char *path;
  77
  78     dicon = wmalloc(sizeof(WAppIcon));
  79     wretain(dicon);
  80     memset(dicon, 0, sizeof(WAppIcon));
  81     dicon->yindex = -1;
  82     dicon->xindex = -1;
  83
  84     dicon->prev = NULL;
  85     dicon->next = scr->app_icon_list;
  86     if (scr->app_icon_list) {
  87         scr->app_icon_list->prev = dicon;
  88     }
  89     scr->app_icon_list = dicon;
  90
  91     if (command) {
  92         dicon->command = wstrdup(command);
  93     }
  94     if (wm_class)
  95       dicon->wm_class = wstrdup(wm_class);
  96     if (wm_instance)
  97       dicon->wm_instance = wstrdup(wm_instance);
  98
  99     path = wDefaultGetIconFile(scr, wm_instance, wm_class, True);
 100     if (!path && command) {
 101         wApplicationExtractDirPackIcon(scr, command, wm_instance, wm_class);
 102
 103         path = wDefaultGetIconFile(scr, wm_instance, wm_class, False);
 104     }
 105
 106     if (path)
 107         path = FindImage(wPreferences.icon_path, path);
 108
 109     dicon->icon = wIconCreateWithIconFile(scr, path, tile);
 110     if (path)
 111         wfree(path);
 112 #ifdef XDND
 113     wXDNDMakeAwareness(dicon->icon->core->window);
 114 #endif
 115
 116 #ifdef DEMATERIALIZE_ICON
 117     {
 118         XSetWindowAttributes attribs;
 119         attribs.save_under = True;
 120         XChangeWindowAttributes(dpy, dicon->icon->core->window,
 121                 CWSaveUnder, &attribs);
 122     }
 123 #endif
 124
 125     /* will be overriden by dock */
 126     dicon->icon->core->descriptor.handle_mousedown = appIconMouseDown;
 127     dicon->icon->core->descriptor.handle_expose = iconExpose;
 128     dicon->icon->core->descriptor.parent_type = WCLASS_APPICON;
 129     dicon->icon->core->descriptor.parent = dicon;
 130     AddToStackList(dicon->icon->core);
 131
 132     return dicon;
 133 }
 134
 135
 136
 137 WAppIcon*
 138 wAppIconCreate(WWindow *leader_win)
 139 {
 140     WAppIcon *aicon;
 141     WScreen *scr = leader_win->screen_ptr;
 142
 143     aicon = wmalloc(sizeof(WAppIcon));
 144     wretain(aicon);
 145     memset(aicon, 0, sizeof(WAppIcon));
 146
 147     aicon->yindex = -1;
 148     aicon->xindex = -1;
 149
 150     aicon->prev = NULL;
 151     aicon->next = scr->app_icon_list;
 152     if (scr->app_icon_list) {
 153         scr->app_icon_list->prev = aicon;
 154     }
 155     scr->app_icon_list = aicon;
 156
 157     if (leader_win->wm_class)
 158         aicon->wm_class = wstrdup(leader_win->wm_class);
 159     if (leader_win->wm_instance)
 160         aicon->wm_instance = wstrdup(leader_win->wm_instance);
 161
 162     aicon->icon = wIconCreate(leader_win);
 163 #ifdef DEMATERIALIZE_ICON
 164     {
 165         XSetWindowAttributes attribs;
 166         attribs.save_under = True;
 167         XChangeWindowAttributes(dpy, aicon->icon->core->window,
 168                 CWSaveUnder, &attribs);
 169     }
 170 #endif
 171 #ifdef XDND
 172     wXDNDMakeAwareness(aicon->icon->core->window);
 173 #endif
 174
 175     /* will be overriden if docked */
 176     aicon->icon->core->descriptor.handle_mousedown = appIconMouseDown;
 177     aicon->icon->core->descriptor.handle_expose = iconExpose;
 178     aicon->icon->core->descriptor.parent_type = WCLASS_APPICON;
 179     aicon->icon->core->descriptor.parent = aicon;
 180     AddToStackList(aicon->icon->core);
 181     aicon->icon->show_title = 0;
 182     wIconUpdate(aicon->icon);
 183
 184     return aicon;
 185 }
 186
 187
 188 void
 189 wAppIconDestroy(WAppIcon *aicon)
 190 {
 191     WScreen *scr = aicon->icon->core->screen_ptr;
 192
 193     RemoveFromStackList(aicon->icon->core);
 194     wIconDestroy(aicon->icon);
 195     if (aicon->command)
 196         wfree(aicon->command);
 197 #ifdef OFFIX_DND
 198     if (aicon->dnd_command)
 199         wfree(aicon->dnd_command);
 200 #endif
 201     if (aicon->wm_instance)
 202       wfree(aicon->wm_instance);
 203     if (aicon->wm_class)
 204       wfree(aicon->wm_class);
 205
 206     if (aicon == scr->app_icon_list) {
 207         if (aicon->next)
 208             aicon->next->prev = NULL;
 209         scr->app_icon_list = aicon->next;
 210     }
 211     else {
 212         if (aicon->next)
 213             aicon->next->prev = aicon->prev;
 214         if (aicon->prev)
 215             aicon->prev->next = aicon->next;
 216     }
 217
 218     aicon->destroyed = 1;
 219     wrelease(aicon);
 220 }
 221
 222
 223
 224 #ifdef NEWAPPICON
 225 static void
 226 drawCorner(WIcon *icon, WWindow *wwin, int active)
 227 {
 228     WScreen *scr = wwin->screen_ptr;
 229     XPoint points[3];
 230     GC gc;
 231
 232     points[0].x = 2;
 233     points[0].y = 2;
 234     points[1].x = 12;
 235     points[1].y = 2;
 236     points[2].x = 2;
 237     points[2].y = 12;
 238     if (active) {
 239         gc=scr->focused_texture->any.gc;
 240     } else {
 241         gc=scr->unfocused_texture->any.gc;
 242     }
 243     XFillPolygon(dpy, icon->core->window, gc, points, 3,
 244                  Convex, CoordModeOrigin);
 245 }
 246 #endif /* NEWAPPICON */
 247
 248
 249 static void
 250 drawCorner(WIcon *icon)
 251 {
 252     WScreen *scr = icon->core->screen_ptr;
 253     XPoint points[3];
 254
 255     points[0].x = 1;
 256     points[0].y = 1;
 257     points[1].x = 12;
 258     points[1].y = 1;
 259     points[2].x = 1;
 260     points[2].y = 12;
 261     XFillPolygon(dpy, icon->core->window, scr->icon_title_texture->normal_gc,
 262                  points, 3, Convex, CoordModeOrigin);
 263     XDrawLine(dpy, icon->core->window, scr->icon_title_texture->light_gc,
 264               0, 0, 0, 12);
 265     XDrawLine(dpy, icon->core->window, scr->icon_title_texture->light_gc,
 266               0, 0, 12, 0);
 267     /* drawing the second line gives a weird concave look. -Dan */
 268 #if 0
 269     XDrawLine(dpy, icon->core->window, scr->icon_title_texture->light_gc,
 270               1, 1, 1, 11);
 271     XDrawLine(dpy, icon->core->window, scr->icon_title_texture->light_gc,
 272               1, 1, 11, 1);
 273 #endif
 274 }
 275
 276
 277 void
 278 wAppIconMove(WAppIcon *aicon, int x, int y)
 279 {
 280     WApplication *app;
 281     WAppIcon *tmp;
 282
 283     app = wApplicationOf(aicon->icon->owner->main_window);
 284
 285     if (!WFLAGP(app->main_window_desc, collapse_appicons)) {
 286         XMoveWindow(dpy, aicon->icon->core->window, x, y);
 287         aicon->x_pos = x;
 288         aicon->y_pos = y;
 289     } else {
 290         tmp = aicon->icon->core->screen_ptr->app_icon_list;
 291
 292         /* move all icons of the same class/name to the same pos */
 293         while (tmp) {
 294             if (strcmp(tmp->wm_class, aicon->wm_class) == 0 &&
 295                 strcmp(tmp->wm_instance, aicon->wm_instance) == 0 &&
 296                 !tmp->docked) {
 297                 XMoveWindow(dpy, tmp->icon->core->window, x, y);
 298                 tmp->x_pos = x;
 299                 tmp->y_pos = y;
 300             }
 301             tmp = tmp->next;
 302         }
 303     }
 304 }
 305
 306
 307 #ifdef WS_INDICATOR
 308 static void
 309 updateDockNumbers(WScreen *scr)
 310 {
 311     int length;
 312     char *ws_numbers;
 313     GC numbers_gc;
 314     XGCValues my_gc_values;
 315     unsigned long my_v_mask = (GCForeground);
 316     WAppIcon *dicon = scr->dock->icon_array[0];
 317
 318     my_gc_values.foreground = scr->white_pixel;
 319     numbers_gc = XCreateGC(dpy, dicon->icon->core->window,
 320                            my_v_mask, &my_gc_values);
 321
 322     ws_numbers = wmalloc(20);
 323     sprintf(ws_numbers, "%i [ %i ]", scr->current_workspace+1,
 324             ((scr->current_workspace/10)+1));
 325     length = strlen(ws_numbers);
 326
 327     XClearArea(dpy, dicon->icon->core->window, 2, 2, 50,
 328                WMFontHeight(scr->icon_title_font)+1, False);
 329
 330     XSetForeground(dpy, numbers_gc, scr->black_pixel);
 331     WMDrawString(scr->wmscreen, dicon->icon->core->window, numbers_gc,
 332                  scr->icon_title_font, 4, 3, ws_numbers, length);
 333
 334     XSetForeground(dpy, numbers_gc, scr->white_pixel);
 335     WMDrawString(scr->wmscreen, dicon->icon->core->window, numbers_gc,
 336                  scr->icon_title_font, 3, 2, ws_numbers, length);
 337
 338     XFreeGC(dpy, numbers_gc);
 339     wfree(ws_numbers);
 340 }
 341 #endif /* WS_INDICATOR */
 342
 343
 344
 345 WAppIcon*
 346 wAppIconNextSibling(WAppIcon *icon)
 347 {
 348     WApplication *app;
 349     WAppIcon *tmp;
 350
 351     app = wApplicationOf(icon->icon->owner->main_window);
 352
 353     if (!WFLAGP(app->main_window_desc, collapse_appicons)) {
 354         return NULL;
 355     }
 356
 357     tmp = icon->next;
 358     while (tmp) {
 359         if (strcmp(tmp->wm_class, icon->wm_class) == 0
 360             && strcmp(tmp->wm_instance, icon->wm_instance) == 0
 361             && !tmp->docked) {
 362             return tmp;
 363         }
 364         tmp = tmp->next;
 365     }
 366
 367     tmp = icon->icon->core->screen_ptr->app_icon_list;
 368     while (tmp && tmp != icon) {
 369         if (strcmp(tmp->wm_class, icon->wm_class) == 0
 370             && strcmp(tmp->wm_instance, icon->wm_instance) == 0
 371             && !tmp->docked) {
 372             return tmp;
 373         }
 374         tmp = tmp->next;
 375     }
 376
 377     return NULL;
 378 }
 379
 380
 381 Bool
 382 wAppIconIsFirstInstance(WAppIcon *icon)
 383 {
 384     WAppIcon *list = icon->icon->core->screen_ptr->app_icon_list;
 385     int index = 0;
 386
 387     if (!WFLAGP(icon->icon->owner, collapse_appicons))
 388         return True;
 389
 390     while (list) {
 391         if (icon == list)
 392             return True;
 393
 394         if (strcmp(icon->wm_instance,
 395                    list->wm_instance) == 0
 396             &&
 397             strcmp(icon->wm_class,
 398                    list->wm_class) == 0
 399             && !icon->docked)
 400             return False;
 401
 402         list = list->next;
 403     }
 404
 405     puts("OH SHIT!?!?!? HOW THE FUCK DID WE GET HERE!?!?!?!?!");
 406
 407     return 0;
 408 }
 409
 410
 411
 412 void
 413 wAppIconPaint(WAppIcon *aicon)
 414 {
 415     WApplication *wapp;
 416     WScreen *scr = aicon->icon->core->screen_ptr;
 417     int index;
 418
 419     if (aicon->icon->owner)
 420         wapp = wApplicationOf(aicon->icon->owner->main_window);
 421     else
 422         wapp = NULL;
 423
 424     wIconPaint(aicon->icon);
 425
 426
 427 # ifdef WS_INDICATOR
 428     if (aicon->docked && scr->dock && scr->dock==aicon->dock &&
 429         aicon->yindex==0)
 430         updateDockNumbers(scr);
 431 # endif
 432     if (scr->dock_dots && aicon->docked && !aicon->running
 433         && aicon->command!=NULL) {
 434         XSetClipMask(dpy, scr->copy_gc, scr->dock_dots->mask);
 435         XSetClipOrigin(dpy, scr->copy_gc, 0, 0);
 436         XCopyArea(dpy, scr->dock_dots->image, aicon->icon->core->window,
 437                   scr->copy_gc, 0, 0, scr->dock_dots->width,
 438                   scr->dock_dots->height, 0, 0);
 439     }
 440
 441 #ifdef HIDDENDOT
 442     if (wapp && wapp->flags.hidden) {
 443         XSetClipMask(dpy, scr->copy_gc, scr->dock_dots->mask);
 444         XSetClipOrigin(dpy, scr->copy_gc, 0, 0);
 445         XCopyArea(dpy, scr->dock_dots->image,
 446                   aicon->icon->core->window,
 447                   scr->copy_gc, 0, 0, 7,
 448                   scr->dock_dots->height, 0, 0);
 449     }
 450 #endif /* HIDDENDOT */
 451
 452     if (wapp)
 453         index = wApplicationIndexOfGroup(wapp);
 454     else
 455         index = 0;
 456
 457     if (index > 0) {
 458         char buf[16];
 459
 460         sprintf(buf, "%i", index);
 461
 462         WMDrawString(scr->wmscreen, aicon->icon->core->window,
 463                      scr->clip_title_gc, scr->title_font,
 464                      1, 1, buf, strlen(buf));
 465     }
 466
 467
 468     if (aicon->omnipresent)
 469         drawCorner(aicon->icon);
 470
 471     XSetClipMask(dpy, scr->copy_gc, None);
 472     if (aicon->launching) {
 473         XFillRectangle(dpy, aicon->icon->core->window, scr->stipple_gc,
 474                        0, 0, wPreferences.icon_size, wPreferences.icon_size);
 475     }
 476 }
 477
 478
 479
 480 #define canBeDocked(wwin)  ((wwin) && ((wwin)->wm_class||(wwin)->wm_instance))
 481
 482
 483
 484 static void
 485 hideCallback(WMenu *menu, WMenuEntry *entry)
 486 {
 487     WApplication *wapp = (WApplication*)entry->clientdata;
 488
 489     if (wapp->flags.hidden) {
 490         wWorkspaceChange(menu->menu->screen_ptr, wapp->last_workspace);
 491         wUnhideApplication(wapp, False, False);
 492     } else {
 493         wHideApplication(wapp);
 494     }
 495 }
 496
 497
 498 static void
 499 unhideHereCallback(WMenu *menu, WMenuEntry *entry)
 500 {
 501     WApplication *wapp = (WApplication*)entry->clientdata;
 502
 503     wUnhideApplication(wapp, False, True);
 504 }
 505
 506
 507 static void
 508 collapseCallback(WMenu *menu, WMenuEntry *entry)
 509 {
 510     WApplication *wapp = (WApplication*)entry->clientdata;
 511
 512     wApplicationSetCollapse(wapp,
 513                             !WFLAGP(wapp->main_window_desc, collapse_appicons));
 514 }
 515
 516
 517 static void
 518 setIconCallback(WMenu *menu, WMenuEntry *entry)
 519 {
 520     WAppIcon *icon = ((WApplication*)entry->clientdata)->app_icon;
 521     char *file=NULL;
 522     WScreen *scr;
 523     int result;
 524
 525     assert(icon!=NULL);
 526
 527     if (icon->editing)
 528         return;
 529     icon->editing = 1;
 530     scr = icon->icon->core->screen_ptr;
 531
 532     wretain(icon);
 533
 534     result = wIconChooserDialog(scr, &file, icon->wm_instance, icon->wm_class);
 535
 536     if (result && !icon->destroyed) {
 537         if (file[0]==0) {
 538             wfree(file);
 539             file = NULL;
 540         }
 541         if (!wIconChangeImageFile(icon->icon, file)) {
 542             wMessageDialog(scr, _("Error"),
 543                            _("Could not open specified icon file"),
 544                            _("OK"), NULL, NULL);
 545         } else {
 546             wDefaultChangeIcon(scr, icon->wm_instance, icon->wm_class, file);
 547             wAppIconPaint(icon);
 548         }
 549         if (file)
 550             wfree(file);
 551     }
 552     icon->editing = 0;
 553     wrelease(icon);
 554 }
 555
 556
 557 static void
 558 killCallback(WMenu *menu, WMenuEntry *entry)
 559 {
 560     WApplication *wapp = (WApplication*)entry->clientdata;
 561     char *buffer;
 562
 563     if (!WCHECK_STATE(WSTATE_NORMAL))
 564         return;
 565
 566     WCHANGE_STATE(WSTATE_MODAL);
 567
 568     assert(entry->clientdata!=NULL);
 569
 570     buffer = wstrconcat(wapp->app_icon ? wapp->app_icon->wm_class : NULL,
 571                         _(" will be forcibly closed.\n"
 572                           "Any unsaved changes will be lost.\n"
 573                           "Please confirm."));
 574
 575     wretain(wapp->main_window_desc);
 576     if (wPreferences.dont_confirm_kill
 577         || wMessageDialog(menu->frame->screen_ptr, _("Kill Application"),
 578                           buffer, _("Yes"), _("No"), NULL)==WAPRDefault) {
 579         if (!wapp->main_window_desc->flags.destroyed)
 580             wClientKill(wapp->main_window_desc);
 581     }
 582     wrelease(wapp->main_window_desc);
 583
 584     wfree(buffer);
 585
 586     WCHANGE_STATE(WSTATE_NORMAL);
 587 }
 588
 589
 590 static WMenu*
 591 createApplicationMenu(WScreen *scr)
 592 {
 593     WMenu *menu;
 594
 595     menu = wMenuCreate(scr, NULL, False);
 596     wMenuAddCallback(menu, _("Unhide Here"), unhideHereCallback, NULL);
 597     wMenuAddCallback(menu, _("Hide"), hideCallback, NULL);
 598     wMenuAddCallback(menu, _("Collapse"), collapseCallback, NULL);
 599     wMenuAddCallback(menu, _("Set Icon..."), setIconCallback, NULL);
 600     wMenuAddCallback(menu, _("Kill"), killCallback, NULL);
 601
 602     return menu;
 603 }
 604
 605
 606 static void
 607 openApplicationMenu(WApplication *wapp, int x, int y)
 608 {
 609     WMenu *menu;
 610     WScreen *scr = wapp->main_window_desc->screen_ptr;
 611     int i;
 612
 613     if (!scr->icon_menu) {
 614         scr->icon_menu = createApplicationMenu(scr);
 615         wfree(scr->icon_menu->entries[1]->text);
 616     }
 617
 618     menu = scr->icon_menu;
 619
 620     if (wapp->flags.hidden) {
 621         menu->entries[1]->text = _("Unhide");
 622     } else {
 623         menu->entries[1]->text = _("Hide");
 624     }
 625
 626     if (WFLAGP(wapp->main_window_desc, collapse_appicons)) {
 627         menu->entries[2]->text = _("Uncollapse");
 628     } else {
 629         menu->entries[2]->text = _("Collapse");
 630     }
 631
 632     menu->flags.realized = 0;
 633     wMenuRealize(menu);
 634
 635     x -= menu->frame->core->width/2;
 636     if (x + menu->frame->core->width > scr->scr_width)
 637         x = scr->scr_width - menu->frame->core->width;
 638     if (x < 0)
 639         x = 0;
 640
 641     /* set client data */
 642     for (i = 0; i < menu->entry_no; i++) {
 643         menu->entries[i]->clientdata = wapp;
 644     }
 645     wMenuMapAt(menu, x, y, False);
 646 }
 647
 648
 649 /******************************************************************/
 650
 651 static void
 652 iconExpose(WObjDescriptor *desc, XEvent *event)
 653 {
 654     wAppIconPaint(desc->parent);
 655 }
 656
 657
 658 static void
 659 iconDblClick(WObjDescriptor *desc, XEvent *event)
 660 {
 661     WAppIcon *aicon = desc->parent;
 662     WApplication *wapp;
 663     WScreen *scr = aicon->icon->core->screen_ptr;
 664     int unhideHere;
 665
 666     assert(aicon->icon->owner!=NULL);
 667
 668     wapp = wApplicationOf(aicon->icon->owner->main_window);
 669 #ifdef DEBUG0
 670     if (!wapp) {
 671         wwarning("could not find application descriptor for app icon!!");
 672         return;
 673     }
 674 #endif
 675
 676     unhideHere = (event->xbutton.state & ShiftMask);
 677
 678     /* go to the last workspace that the user worked on the app */
 679     if (!unhideHere && wapp->last_workspace != scr->current_workspace)
 680         wWorkspaceChange(scr, wapp->last_workspace);
 681
 682     wUnhideApplication(wapp, event->xbutton.button==Button2, unhideHere);
 683
 684     if (event->xbutton.state & MOD_MASK) {
 685         wHideOtherApplications(aicon->icon->owner);
 686     }
 687 }
 688
 689
 690
 691 void
 692 appIconMouseDown(WObjDescriptor *desc, XEvent *event)
 693 {
 694     WAppIcon *aicon = desc->parent;
 695     WIcon *icon = aicon->icon;
 696     XEvent ev;
 697     int x=aicon->x_pos, y=aicon->y_pos;
 698     int dx=event->xbutton.x, dy=event->xbutton.y;
 699     int grabbed=0;
 700     int done=0;
 701     int superfluous = wPreferences.superfluous; /* we catch it to avoid problems */
 702     WScreen *scr = icon->core->screen_ptr;
 703     WWorkspace *workspace = scr->workspaces[scr->current_workspace];
 704     int shad_x = 0, shad_y = 0, docking=0, dockable, collapsed = 0;
 705     int ix, iy;
 706     int clickButton = event->xbutton.button;
 707     Pixmap ghost = None;
 708     Window wins[2];
 709     Bool movingSingle = False;
 710     int oldX = x;
 711     int oldY = y;
 712
 713     if (aicon->editing || WCHECK_STATE(WSTATE_MODAL))
 714         return;
 715
 716     if (event->xbutton.button == Button1 && IsDoubleClick(scr, event)) {
 717         iconDblClick(desc, event);
 718         return;
 719     }
 720
 721     if (event->xbutton.button == Button3) {
 722         WObjDescriptor *desc;
 723         WApplication *wapp = wApplicationOf(aicon->icon->owner->main_window);
 724
 725         if (!wapp)
 726             return;
 727
 728         if (event->xbutton.send_event &&
 729             XGrabPointer(dpy, aicon->icon->core->window, True, ButtonMotionMask
 730                          |ButtonReleaseMask|ButtonPressMask, GrabModeAsync,
 731                          GrabModeAsync, None, None, CurrentTime) !=GrabSuccess) {
 732             wwarning("pointer grab failed for appicon menu");
 733             return;
 734         }
 735
 736         openApplicationMenu(wapp, event->xbutton.x_root,
 737                             event->xbutton.y_root);
 738
 739         /* allow drag select of menu */
 740         desc = &scr->icon_menu->menu->descriptor;
 741         event->xbutton.send_event = True;
 742         (*desc->handle_mousedown)(desc, event);
 743         return;
 744     }
 745
 746 #ifdef DEBUG
 747     puts("Moving icon");
 748 #endif
 749     if (event->xbutton.state & MOD_MASK)
 750         wLowerFrame(icon->core);
 751     else
 752         wRaiseFrame(icon->core);
 753
 754
 755     if (clickButton == Button2) {
 756         WAppIcon *next = wAppIconNextSibling(aicon);
 757
 758         if (next) {
 759             wRaiseFrame(next->icon->core);
 760         }
 761         return;
 762     }
 763
 764     if (XGrabPointer(dpy, icon->core->window, True, ButtonMotionMask
 765                      |ButtonReleaseMask|ButtonPressMask, GrabModeAsync,
 766                      GrabModeAsync, None, None, CurrentTime) !=GrabSuccess) {
 767         wwarning("pointer grab failed for appicon move");
 768     }
 769
 770     if (wPreferences.flags.nodock && wPreferences.flags.noclip)
 771       dockable = 0;
 772     else
 773       dockable = canBeDocked(icon->owner);
 774
 775     wins[0] = icon->core->window;
 776     wins[1] = scr->dock_shadow;
 777     XRestackWindows(dpy, wins, 2);
 778     if (superfluous) {
 779         if (icon->pixmap!=None)
 780             ghost = MakeGhostIcon(scr, icon->pixmap);
 781         else
 782             ghost = MakeGhostIcon(scr, icon->core->window);
 783         XSetWindowBackgroundPixmap(dpy, scr->dock_shadow,
 784                                    ghost);
 785         XClearWindow(dpy, scr->dock_shadow);
 786     }
 787
 788     while (!done) {
 789         WMMaskEvent(dpy, PointerMotionMask|ButtonReleaseMask|ButtonPressMask
 790                     |ButtonMotionMask|ExposureMask, &ev);
 791         switch (ev.type) {
 792          case Expose:
 793             WMHandleEvent(&ev);
 794             break;
 795
 796          case MotionNotify:
 797             if (!grabbed) {
 798                 if (abs(dx-ev.xmotion.x)>=MOVE_THRESHOLD
 799                     || abs(dy-ev.xmotion.y)>=MOVE_THRESHOLD) {
 800                     XChangeActivePointerGrab(dpy, ButtonMotionMask
 801                                             |ButtonReleaseMask|ButtonPressMask,
 802                                              wCursor[WCUR_MOVE], CurrentTime);
 803                     grabbed=1;
 804                 } else {
 805                     break;
 806                 }
 807             }
 808             x = ev.xmotion.x_root - dx;
 809             y = ev.xmotion.y_root - dy;
 810
 811             if (movingSingle) {
 812                 XMoveWindow(dpy, icon->core->window, x, y);
 813             } else {
 814                 wAppIconMove(aicon, x, y);
 815             }
 816
 817             if (dockable) {
 818                 if (scr->dock && wDockSnapIcon(scr->dock, aicon, x, y,
 819                                                &ix, &iy, False)) {
 820                     shad_x = scr->dock->x_pos + ix*wPreferences.icon_size;
 821                     shad_y = scr->dock->y_pos + iy*wPreferences.icon_size;
 822
 823                     if (scr->last_dock != scr->dock && collapsed) {
 824                         scr->last_dock->collapsed = 1;
 825                         wDockHideIcons(scr->last_dock);
 826                         collapsed = 0;
 827                     }
 828                     if (!collapsed && (collapsed = scr->dock->collapsed)) {
 829                         scr->dock->collapsed = 0;
 830                         wDockShowIcons(scr->dock);
 831                     }
 832
 833                     if (scr->dock->auto_raise_lower)
 834                         wDockRaise(scr->dock);
 835
 836                     scr->last_dock = scr->dock;
 837
 838                     XMoveWindow(dpy, scr->dock_shadow, shad_x, shad_y);
 839                     if (!docking) {
 840                         XMapWindow(dpy, scr->dock_shadow);
 841                     }
 842                     docking = 1;
 843                 } else if (workspace->clip &&
 844                            wDockSnapIcon(workspace->clip, aicon, x, y,
 845                                          &ix, &iy, False)) {
 846                     shad_x = workspace->clip->x_pos + ix*wPreferences.icon_size;
 847                     shad_y = workspace->clip->y_pos + iy*wPreferences.icon_size;
 848
 849                     if (scr->last_dock != workspace->clip && collapsed) {
 850                         scr->last_dock->collapsed = 1;
 851                         wDockHideIcons(scr->last_dock);
 852                         collapsed = 0;
 853                     }
 854                     if (!collapsed && (collapsed = workspace->clip->collapsed)) {
 855                         workspace->clip->collapsed = 0;
 856                         wDockShowIcons(workspace->clip);
 857                     }
 858
 859                     if (workspace->clip->auto_raise_lower)
 860                         wDockRaise(workspace->clip);
 861
 862                     scr->last_dock = workspace->clip;
 863
 864                     XMoveWindow(dpy, scr->dock_shadow, shad_x, shad_y);
 865                     if (!docking) {
 866                         XMapWindow(dpy, scr->dock_shadow);
 867                     }
 868                     docking = 1;
 869                 } else if (docking) {
 870                     XUnmapWindow(dpy, scr->dock_shadow);
 871                     docking = 0;
 872                 }
 873             }
 874
 875             break;
 876
 877          case ButtonPress:
 878             break;
 879
 880          case ButtonRelease:
 881             if (ev.xbutton.button != clickButton)
 882                 break;
 883             XUngrabPointer(dpy, CurrentTime);
 884
 885             if (docking) {
 886                 Bool docked;
 887
 888                 /* icon is trying to be docked */
 889                 SlideWindow(icon->core->window, x, y, shad_x, shad_y);
 890                 XUnmapWindow(dpy, scr->dock_shadow);
 891                 docked = wDockAttachIcon(scr->last_dock, aicon, ix, iy);
 892                 if (scr->last_dock->auto_collapse) {
 893                     collapsed = 0;
 894                 }
 895                 if (workspace->clip &&
 896                     workspace->clip != scr->last_dock &&
 897                     workspace->clip->auto_raise_lower)
 898                     wDockLower(workspace->clip);
 899
 900                 if (!docked) {
 901                     /* If icon could not be docked, slide it back to the old
 902                      * position */
 903                     SlideWindow(icon->core->window, x, y, oldX, oldY);
 904                 } else {
 905                     WAppIcon *nextIcon = wAppIconNextSibling(aicon);
 906
 907                     if (nextIcon) {
 908                         /* move the next instance back to the old position */
 909                         SlideWindow(nextIcon->icon->core->window, x, y,
 910                                     oldX, oldY);
 911                         wAppIconMove(nextIcon, oldX, oldY);
 912                     }
 913                 }
 914
 915                 wSoundPlay(WSOUND_DOCK);
 916             } else {
 917                 if (movingSingle) {
 918                     /* move back to its place */
 919                     SlideWindow(icon->core->window, x, y, oldX, oldY);
 920                     wAppIconMove(aicon, oldX, oldY);
 921                 } else {
 922                     XMoveWindow(dpy, icon->core->window, x, y);
 923                     aicon->x_pos = x;
 924                     aicon->y_pos = y;
 925                 }
 926                 if (workspace->clip && workspace->clip->auto_raise_lower)
 927                     wDockLower(workspace->clip);
 928             }
 929             if (collapsed) {
 930                 scr->last_dock->collapsed = 1;
 931                 wDockHideIcons(scr->last_dock);
 932                 collapsed = 0;
 933             }
 934             if (superfluous) {
 935                 if (ghost!=None)
 936                     XFreePixmap(dpy, ghost);
 937                 XSetWindowBackground(dpy, scr->dock_shadow, scr->white_pixel);
 938             }
 939
 940             if (wPreferences.auto_arrange_icons)
 941                 wArrangeIcons(scr, True);
 942
 943             done = 1;
 944             break;
 945         }
 946     }
 947 #ifdef DEBUG
 948     puts("End icon move");
 949 #endif
 950
 951 }