src/dock.c

   1 /* dock.c- built-in Dock module for WindowMaker
   2  *
   3  *  Window Maker window manager
   4  *
   5  *  Copyright (c) 1997, 1998 Alfredo K. Kojima
   6  *  Copyright (c) 1998, 1999 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
  25 #include "wconfig.h"
  26
  27 #include <X11/Xlib.h>
  28 #include <X11/Xutil.h>
  29 #include <stdlib.h>
  30 #include <string.h>
  31 #include <unistd.h>
  32 #include <math.h>
  33 #include <limits.h>
  34
  35 #ifndef PATH_MAX
  36 #define PATH_MAX DEFAULT_PATH_MAX
  37 #endif
  38
  39 #include "WindowMaker.h"
  40 #include "wcore.h"
  41 #include "window.h"
  42 #include "icon.h"
  43 #include "appicon.h"
  44 #include "actions.h"
  45 #include "stacking.h"
  46 #include "dock.h"
  47 #include "dialog.h"
  48 #include "funcs.h"
  49 #include "properties.h"
  50 #include "menu.h"
  51 #include "client.h"
  52 #include "defaults.h"
  53 #include "workspace.h"
  54 #include "framewin.h"
  55 #include "superfluous.h"
  56
  57 #include "list.h"
  58
  59 #include <proplist.h>
  60
  61
  62
  63
  64 /**** Local variables ****/
  65 #define CLIP_REWIND       1
  66 #define CLIP_IDLE         0
  67 #define CLIP_FORWARD      2
  68
  69
  70 /**** Global variables ****/
  71
  72 /* in dockedapp.c */
  73 extern void DestroyDockAppSettingsPanel();
  74
  75 extern void ShowDockAppSettingsPanel(WAppIcon *aicon);
  76
  77
  78 extern XContext wWinContext;
  79
  80 extern Cursor wCursor[WCUR_LAST];
  81
  82 extern WPreferences wPreferences;
  83
  84 extern XContext wWinContext;
  85
  86 #ifdef OFFIX_DND
  87 extern Atom _XA_DND_PROTOCOL;
  88 #endif
  89
  90
  91 #define MOD_MASK wPreferences.modifier_mask
  92
  93 extern void appIconMouseDown(WObjDescriptor *desc, XEvent *event);
  94
  95 #define ICON_SIZE wPreferences.icon_size
  96
  97
  98 /***** Local variables ****/
  99
 100 static proplist_t dCommand=NULL;
 101 #ifdef OFFIX_DND
 102 static proplist_t dDropCommand=NULL;
 103 #endif
 104 static proplist_t dAutoLaunch, dName, dForced, dBuggyApplication, dYes, dNo;
 105 static proplist_t dHost, dDock, dClip;
 106 static proplist_t dAutoAttractIcons, dKeepAttracted;
 107
 108 static proplist_t dPosition, dApplications, dLowered, dCollapsed, dAutoCollapse;
 109
 110 static proplist_t dAutoRaiseLower, dOmnipresent;
 111
 112 static void dockIconPaint(WAppIcon *btn);
 113
 114 static void iconMouseDown(WObjDescriptor *desc, XEvent *event);
 115
 116 static pid_t execCommand(WAppIcon *btn, char *command, WSavedState *state);
 117
 118 static void trackDeadProcess(pid_t pid, unsigned char status, WDock *dock);
 119
 120 static int getClipButton(int px, int py);
 121
 122 static void toggleLowered(WDock *dock);
 123
 124 static void toggleCollapsed(WDock *dock);
 125
 126 static void clipIconExpose(WObjDescriptor *desc, XEvent *event);
 127
 128 static void clipLeave(WDock *dock);
 129
 130 static void handleClipChangeWorkspace(WScreen *scr, XEvent *event);
 131
 132 Bool moveIconBetweenDocks(WDock *src, WDock *dest, WAppIcon *icon, int x, int y);
 133
 134 static void clipEnterNotify(WObjDescriptor *desc, XEvent *event);
 135 static void clipLeaveNotify(WObjDescriptor *desc, XEvent *event);
 136 static void clipAutoCollapse(void *cdata);
 137 static void clipAutoExpand(void *cdata);
 138 static void launchDockedApplication(WAppIcon *btn);
 139
 140 static void clipAutoLower(void *cdata);
 141 static void clipAutoRaise(void *cdata);
 142
 143 static void showClipBalloon(WDock *dock, int workspace);
 144
 145 #ifdef OFFIX_DND
 146
 147 #define DndNotDnd       -1
 148 #define DndUnknown      0
 149 #define DndRawData      1
 150 #define DndFile         2
 151 #define DndFiles        3
 152 #define DndText         4
 153 #define DndDir          5
 154 #define DndLink         6
 155 #define DndExe          7
 156
 157 #define DndEND          8
 158
 159 #endif /* OFFIX_DND */
 160
 161
 162
 163 static void
 164 make_keys()
 165 {
 166     if (dCommand!=NULL)
 167         return;
 168
 169     dCommand = PLRetain(PLMakeString("Command"));
 170 #ifdef OFFIX_DND
 171     dDropCommand = PLRetain(PLMakeString("DropCommand"));
 172 #endif
 173     dAutoLaunch = PLRetain(PLMakeString("AutoLaunch"));
 174     dName = PLRetain(PLMakeString("Name"));
 175     dForced = PLRetain(PLMakeString("Forced"));
 176     dBuggyApplication = PLRetain(PLMakeString("BuggyApplication"));
 177     dYes = PLRetain(PLMakeString("Yes"));
 178     dNo = PLRetain(PLMakeString("No"));
 179     dHost = PLRetain(PLMakeString("Host"));
 180
 181     dPosition = PLMakeString("Position");
 182     dApplications = PLMakeString("Applications");
 183     dLowered = PLMakeString("Lowered");
 184     dCollapsed = PLMakeString("Collapsed");
 185     dAutoCollapse = PLMakeString("AutoCollapse");
 186     dAutoRaiseLower = PLMakeString("AutoRaiseLower");
 187     dAutoAttractIcons = PLMakeString("AutoAttractIcons");
 188     dKeepAttracted = PLMakeString("KeepAttracted");
 189
 190     dOmnipresent = PLMakeString("Omnipresent");
 191
 192     dDock = PLMakeString("Dock");
 193     dClip = PLMakeString("Clip");
 194 }
 195
 196
 197
 198 static void
 199 renameCallback(WMenu *menu, WMenuEntry *entry)
 200 {
 201     WDock *dock = entry->clientdata;
 202     char buffer[128];
 203     int wspace;
 204     char *name;
 205
 206     assert(entry->clientdata!=NULL);
 207
 208     wspace = dock->screen_ptr->current_workspace;
 209
 210     name = wstrdup(dock->screen_ptr->workspaces[wspace]->name);
 211
 212     sprintf(buffer, _("Type the name for workspace %i:"), wspace+1);
 213     if (wInputDialog(dock->screen_ptr, _("Rename Workspace"), buffer,
 214                      &name)) {
 215         wWorkspaceRename(dock->screen_ptr, wspace, name);
 216     }
 217     if (name) {
 218         free(name);
 219     }
 220 }
 221
 222
 223 static void
 224 toggleLoweredCallback(WMenu *menu, WMenuEntry *entry)
 225 {
 226     assert(entry->clientdata!=NULL);
 227
 228     toggleLowered(entry->clientdata);
 229
 230     entry->flags.indicator_on = !((WDock*)entry->clientdata)->lowered;
 231
 232     wMenuPaint(menu);
 233 }
 234
 235
 236
 237 static void
 238 killCallback(WMenu *menu, WMenuEntry *entry)
 239 {
 240     WAppIcon *icon;
 241 #ifdef REDUCE_APPICONS
 242     WAppIconAppList *tapplist;
 243
 244     extern Atom _XA_WM_DELETE_WINDOW;
 245 #else
 246     char *buffer;
 247 #endif
 248
 249     if (!WCHECK_STATE(WSTATE_NORMAL))
 250         return;
 251
 252     assert(entry->clientdata!=NULL);
 253
 254     icon = (WAppIcon*)entry->clientdata;
 255
 256     icon->editing = 1;
 257
 258     WCHANGE_STATE(WSTATE_MODAL);
 259
 260 #ifdef REDUCE_APPICONS
 261     /* Send a delete message to the main window of each application
 262      * bound to this docked appicon. - cls
 263      */
 264     tapplist = icon->applist;
 265     while (tapplist != NULL) {
 266         if (tapplist->wapp->main_window_desc != NULL) {
 267             if (tapplist->wapp->main_window_desc->protocols.DELETE_WINDOW) {
 268                 wClientSendProtocol(tapplist->wapp->main_window_desc,
 269                                     _XA_WM_DELETE_WINDOW, CurrentTime);
 270             } else {
 271                 wClientKill(tapplist->wapp->main_window_desc);
 272             }
 273         }
 274         tapplist = tapplist->next;
 275     }
 276 #else
 277     buffer = wstrappend(icon->wm_class,
 278                         _(" will be forcibly closed.\n"
 279                           "Any unsaved changes will be lost.\n"
 280                           "Please confirm."));
 281
 282     if (wPreferences.dont_confirm_kill
 283         || wMessageDialog(menu->frame->screen_ptr, _("Kill Application"),
 284                           buffer, _("Yes"), _("No"), NULL)==WAPRDefault) {
 285         if (icon->icon && icon->icon->owner) {
 286             wClientKill(icon->icon->owner);
 287         }
 288     }
 289 #endif /* !REDUCE_APPICONS */
 290
 291     icon->editing = 0;
 292
 293     WCHANGE_STATE(WSTATE_NORMAL);
 294 }
 295
 296
 297 /* TODO: replace this function with a member of the dock struct */
 298 static int
 299 numberOfSelectedIcons(WDock *dock)
 300 {
 301     WAppIcon *aicon;
 302     int i, n;
 303
 304     n = 0;
 305     for (i=1; i<dock->max_icons; i++) {
 306         aicon = dock->icon_array[i];
 307         if (aicon && aicon->icon->selected) {
 308             n++;
 309         }
 310     }
 311
 312     return n;
 313 }
 314
 315
 316 static LinkedList*
 317 getSelected(WDock *dock)
 318 {
 319     LinkedList *ret=NULL;
 320     WAppIcon *btn;
 321     int i;
 322
 323     for (i=1; i<dock->max_icons; i++) {
 324         btn = dock->icon_array[i];
 325         if (btn && btn->icon->selected) {
 326             ret = list_cons(btn, ret);
 327         }
 328     }
 329
 330     return ret;
 331 }
 332
 333
 334 static void
 335 paintClipButtons(WAppIcon *clipIcon, Bool lpushed, Bool rpushed)
 336 {
 337     Window win = clipIcon->icon->core->window;
 338     WScreen *scr = clipIcon->icon->core->screen_ptr;
 339     XPoint p[4];
 340     int pt = CLIP_BUTTON_SIZE*ICON_SIZE/64;
 341     int tp = ICON_SIZE - pt;
 342     int as = pt - 15; /* 15 = 5+5+5 */
 343     GC gc = scr->clip_title_gc;
 344 #ifdef GRADIENT_CLIP_ARROW
 345     Bool collapsed = clipIcon->dock->collapsed;
 346 #endif
 347
 348     if (rpushed) {
 349         p[0].x = tp+1;
 350         p[0].y = 1;
 351         p[1].x = ICON_SIZE-2;
 352         p[1].y = 1;
 353         p[2].x = ICON_SIZE-2;
 354         p[2].y = pt-1;
 355     } else if (lpushed) {
 356         p[0].x = 1;
 357         p[0].y = tp;
 358         p[1].x = pt;
 359         p[1].y = ICON_SIZE-2;
 360         p[2].x = 1;
 361         p[2].y = ICON_SIZE-2;
 362     }
 363     if (lpushed || rpushed) {
 364         XSetForeground(dpy, scr->draw_gc, scr->white_pixel);
 365         XFillPolygon(dpy, win, scr->draw_gc, p, 3, Convex, CoordModeOrigin);
 366         XSetForeground(dpy, scr->draw_gc, scr->black_pixel);
 367     }
 368 #ifdef GRADIENT_CLIP_ARROW
 369     if (!collapsed) {
 370         XSetFillStyle(dpy, scr->copy_gc, FillTiled);
 371         XSetTile(dpy, scr->copy_gc, scr->clip_arrow_gradient);
 372         XSetClipMask(dpy, scr->copy_gc, None);
 373         gc = scr->copy_gc;
 374     }
 375 #endif /* GRADIENT_CLIP_ARROW */
 376
 377     /* top right arrow */
 378     p[0].x = p[3].x = ICON_SIZE-5-as;
 379     p[0].y = p[3].y = 5;
 380     p[1].x = ICON_SIZE-6;
 381     p[1].y = 5;
 382     p[2].x = ICON_SIZE-6;
 383     p[2].y = 4+as;
 384     if (rpushed) {
 385         XFillPolygon(dpy, win, scr->draw_gc, p, 3, Convex, CoordModeOrigin);
 386         XDrawLines(dpy, win, scr->draw_gc, p, 4, CoordModeOrigin);
 387     } else {
 388 #ifdef GRADIENT_CLIP_ARROW
 389         if (!collapsed)
 390             XSetTSOrigin(dpy, gc, ICON_SIZE-6-as, 5);
 391 #endif
 392         XFillPolygon(dpy, win, gc, p,3,Convex,CoordModeOrigin);
 393         XDrawLines(dpy, win, gc, p,4,CoordModeOrigin);
 394     }
 395
 396     /* bottom left arrow */
 397     p[0].x = p[3].x = 5;
 398     p[0].y = p[3].y = ICON_SIZE-5-as;
 399     p[1].x = 5;
 400     p[1].y = ICON_SIZE-6;
 401     p[2].x = 4+as;
 402     p[2].y = ICON_SIZE-6;
 403     if (lpushed) {
 404         XFillPolygon(dpy, win, scr->draw_gc, p, 3, Convex, CoordModeOrigin);
 405         XDrawLines(dpy, win, scr->draw_gc, p, 4, CoordModeOrigin);
 406     } else {
 407 #ifdef GRADIENT_CLIP_ARROW
 408         if (!collapsed)
 409             XSetTSOrigin(dpy, gc, 5, ICON_SIZE-6-as);
 410 #endif
 411         XFillPolygon(dpy, win, gc, p,3,Convex,CoordModeOrigin);
 412         XDrawLines(dpy, win, gc, p,4,CoordModeOrigin);
 413     }
 414 #ifdef GRADIENT_CLIP_ARROW
 415     if (!collapsed)
 416         XSetFillStyle(dpy, scr->copy_gc, FillSolid);
 417 #endif
 418 }
 419
 420
 421 RImage*
 422 wClipMakeTile(WScreen *scr, RImage *normalTile)
 423 {
 424     RImage *tile = RCloneImage(normalTile);
 425     RColor black;
 426     RColor dark;
 427     RColor light;
 428     int pt, tp;
 429     int as;
 430
 431     pt = CLIP_BUTTON_SIZE*wPreferences.icon_size/64;
 432     tp = wPreferences.icon_size-1 - pt;
 433     as = pt - 15;
 434
 435     black.alpha = 255;
 436     black.red = black.green = black.blue = 0;
 437
 438     dark.alpha = 0;
 439     dark.red = dark.green = dark.blue = 60;
 440
 441     light.alpha = 0;
 442     light.red = light.green = light.blue = 80;
 443
 444
 445     /* top right */
 446     ROperateLine(tile, RSubtractOperation, tp, 0, wPreferences.icon_size-2,
 447                  pt-1, &dark);
 448     RDrawLine(tile, tp-1, 0, wPreferences.icon_size-1, pt+1, &black);
 449     ROperateLine(tile, RAddOperation, tp, 2, wPreferences.icon_size-3,
 450                  pt, &light);
 451
 452     /* arrow bevel */
 453     ROperateLine(tile, RSubtractOperation, ICON_SIZE - 7 - as, 4,
 454                  ICON_SIZE - 5, 4, &dark);
 455     ROperateLine(tile, RSubtractOperation, ICON_SIZE - 6 - as, 5,
 456                  ICON_SIZE - 5, 6 + as, &dark);
 457     ROperateLine(tile, RAddOperation, ICON_SIZE - 5, 4, ICON_SIZE - 5, 6 + as,
 458                  &light);
 459
 460     /* bottom left */
 461     ROperateLine(tile, RAddOperation, 2, tp+2, pt-2,
 462                  wPreferences.icon_size-3, &dark);
 463     RDrawLine(tile, 0, tp-1, pt+1, wPreferences.icon_size-1, &black);
 464     ROperateLine(tile, RSubtractOperation, 0, tp-2, pt+1,
 465                  wPreferences.icon_size-2, &light);
 466
 467     /* arrow bevel */
 468     ROperateLine(tile, RSubtractOperation, 4, ICON_SIZE - 7 - as, 4,
 469                  ICON_SIZE - 5, &dark);
 470     ROperateLine(tile, RSubtractOperation, 5, ICON_SIZE - 6 - as,
 471                  6 + as, ICON_SIZE - 5, &dark);
 472     ROperateLine(tile, RAddOperation, 4, ICON_SIZE - 5, 6 + as, ICON_SIZE - 5,
 473                  &light);
 474
 475     return tile;
 476 }
 477
 478
 479 static void
 480 omnipresentCallback(WMenu *menu, WMenuEntry *entry)
 481 {
 482     WAppIcon *clickedIcon = entry->clientdata;
 483     WAppIcon *aicon;
 484     WDock *dock;
 485     LinkedList *selectedIcons;
 486     int failed;
 487
 488     assert(entry->clientdata!=NULL);
 489
 490     dock = clickedIcon->dock;
 491
 492     selectedIcons = getSelected(dock);
 493
 494     if (!selectedIcons)
 495         selectedIcons = list_cons(clickedIcon, NULL);
 496
 497     failed = 0;
 498     while (selectedIcons) {
 499         aicon = selectedIcons->head;
 500         if (wClipMakeIconOmnipresent(aicon, !aicon->omnipresent) == WO_FAILED)
 501             failed++;
 502         else if (aicon->icon->selected)
 503             wIconSelect(aicon->icon);
 504         list_remove_head(&selectedIcons);
 505     }
 506
 507     if (failed > 1) {
 508         wMessageDialog(dock->screen_ptr, _("Warning"),
 509                        _("Some icons cannot be made omnipresent. "
 510                          "Please make sure that no other icon is "
 511                          "docked in the same positions on the other "
 512                          "workspaces and the Clip is not full in "
 513                          "some workspace."),
 514                        _("OK"), NULL, NULL);
 515     } else if (failed == 1) {
 516         wMessageDialog(dock->screen_ptr, _("Warning"),
 517                        _("Icon cannot be made omnipresent. "
 518                          "Please make sure that no other icon is "
 519                          "docked in the same position on the other "
 520                          "workspaces and the Clip is not full in "
 521                          "some workspace."),
 522                        _("OK"), NULL, NULL);
 523     }
 524 }
 525
 526
 527 static void
 528 removeIconsCallback(WMenu *menu, WMenuEntry *entry)
 529 {
 530     WAppIcon *clickedIcon = (WAppIcon*)entry->clientdata;
 531     WDock *dock;
 532     WAppIcon *aicon;
 533     LinkedList *selectedIcons;
 534     int keepit;
 535
 536     assert(clickedIcon!=NULL);
 537
 538     dock = clickedIcon->dock;
 539
 540     selectedIcons = getSelected(dock);
 541
 542     if (selectedIcons) {
 543         if (wMessageDialog(dock->screen_ptr, _("Workspace Clip"),
 544                            _("All selected icons will be removed!"),
 545                            _("OK"), _("Cancel"), NULL)!=WAPRDefault) {
 546             return;
 547         }
 548     } else {
 549         if (clickedIcon->xindex==0 && clickedIcon->yindex==0)
 550             return;
 551         selectedIcons = list_cons(clickedIcon, NULL);
 552     }
 553
 554     while (selectedIcons) {
 555         aicon = selectedIcons->head;
 556         keepit = aicon->running && wApplicationOf(aicon->main_window);
 557         wDockDetach(dock, aicon);
 558         if (keepit) {
 559             PlaceIcon(dock->screen_ptr, &aicon->x_pos, &aicon->y_pos);
 560             XMoveWindow(dpy, aicon->icon->core->window,
 561                         aicon->x_pos, aicon->y_pos);
 562             if (!dock->mapped || dock->collapsed)
 563                 XMapWindow(dpy, aicon->icon->core->window);
 564         }
 565         list_remove_head(&selectedIcons);
 566     }
 567
 568     if (wPreferences.auto_arrange_icons)
 569         wArrangeIcons(dock->screen_ptr, True);
 570 }
 571
 572
 573 static void
 574 keepIconsCallback(WMenu *menu, WMenuEntry *entry)
 575 {
 576     WAppIcon *clickedIcon = (WAppIcon*)entry->clientdata;
 577     WDock *dock;
 578     WAppIcon *aicon;
 579     LinkedList *selectedIcons;
 580
 581     assert(clickedIcon!=NULL);
 582     dock = clickedIcon->dock;
 583
 584     selectedIcons = getSelected(dock);
 585
 586     if (!selectedIcons && clickedIcon!=dock->screen_ptr->clip_icon) {
 587         char *command = NULL;
 588
 589         if (!clickedIcon->command && !clickedIcon->editing) {
 590             clickedIcon->editing = 1;
 591             if (wInputDialog(dock->screen_ptr, _("Keep Icon"),
 592                              _("Type the command used to launch the application"),
 593                              &command)) {
 594                 if (command && (command[0]==0 ||
 595                                 (command[0]=='-' && command[1]==0))) {
 596                     free(command);
 597                     command = NULL;
 598                 }
 599                 clickedIcon->command = command;
 600                 clickedIcon->editing = 0;
 601             } else {
 602                 clickedIcon->editing = 0;
 603                 if (command)
 604                     free(command);
 605                 return;
 606             }
 607         }
 608
 609         selectedIcons = list_cons(clickedIcon, NULL);
 610     }
 611
 612     while (selectedIcons) {
 613         aicon = selectedIcons->head;
 614         if (aicon->icon->selected)
 615             wIconSelect(aicon->icon);
 616         if (aicon && aicon->attracted && aicon->command) {
 617             aicon->attracted = 0;
 618             if (aicon->icon->shadowed) {
 619                 aicon->icon->shadowed = 0;
 620                 aicon->icon->force_paint = 1;
 621                 wAppIconPaint(aicon);
 622             }
 623         }
 624         list_remove_head(&selectedIcons);
 625     }
 626 }
 627
 628
 629
 630
 631 static void
 632 toggleAutoAttractCallback(WMenu *menu, WMenuEntry *entry)
 633 {
 634     WDock *dock = (WDock*)entry->clientdata;
 635
 636     assert(entry->clientdata!=NULL);
 637
 638     dock->attract_icons = !dock->attract_icons;
 639     /*if (!dock->attract_icons)
 640         dock->keep_attracted = 0;*/
 641
 642     entry->flags.indicator_on = dock->attract_icons;
 643
 644     wMenuPaint(menu);
 645 }
 646
 647
 648 static void
 649 toggleKeepCallback(WMenu *menu, WMenuEntry *entry)
 650 {
 651     WDock *dock = (WDock*)entry->clientdata;
 652     WAppIcon *btn;
 653     int i;
 654
 655     assert(entry->clientdata!=NULL);
 656
 657     dock->keep_attracted = !dock->keep_attracted;
 658
 659     if (dock->keep_attracted) {
 660         for (i=0; i< dock->max_icons; i++) {
 661             btn = dock->icon_array[i];
 662             if (btn && btn->attracted && btn->command) {
 663                 btn->attracted = 0;
 664                 if (btn->icon->shadowed) {
 665                     btn->icon->shadowed = 0;
 666                     btn->icon->force_paint = 1;
 667                     wAppIconPaint(btn);
 668                 }
 669             }
 670         }
 671     }
 672
 673     entry->flags.indicator_on = dock->keep_attracted;
 674
 675     wMenuPaint(menu);
 676 }
 677
 678
 679 static void
 680 selectCallback(WMenu *menu, WMenuEntry *entry)
 681 {
 682     WAppIcon *icon = (WAppIcon*)entry->clientdata;
 683
 684     assert(icon!=NULL);
 685
 686     wIconSelect(icon->icon);
 687
 688     wMenuPaint(menu);
 689 }
 690
 691
 692 static void
 693 colectIconsCallback(WMenu *menu, WMenuEntry *entry)
 694 {
 695     WAppIcon *clickedIcon = (WAppIcon*)entry->clientdata;
 696     WDock *clip;
 697     WAppIcon *aicon;
 698     int x, y, x_pos, y_pos;
 699
 700     assert(entry->clientdata!=NULL);
 701     clip = clickedIcon->dock;
 702
 703     aicon = clip->screen_ptr->app_icon_list;
 704
 705     while (aicon) {
 706         if (!aicon->docked && wDockFindFreeSlot(clip, &x, &y)) {
 707             x_pos = clip->x_pos + x*ICON_SIZE;
 708             y_pos = clip->y_pos + y*ICON_SIZE;
 709             if (aicon->x_pos != x_pos || aicon->y_pos != y_pos) {
 710 #ifdef ANIMATIONS
 711                 if (wPreferences.no_animations) {
 712                     XMoveWindow(dpy, aicon->icon->core->window, x_pos, y_pos);
 713                 } else {
 714                     SlideWindow(aicon->icon->core->window,
 715                                 aicon->x_pos, aicon->y_pos, x_pos, y_pos);
 716                 }
 717 #else
 718                 XMoveWindow(dpy, aicon->icon->core->window, x_pos, y_pos);
 719 #endif /* ANIMATIONS */
 720             }
 721             aicon->attracted = 1;
 722             if (!clip->keep_attracted && !aicon->icon->shadowed) {
 723                 aicon->icon->shadowed = 1;
 724                 aicon->icon->force_paint = 1;
 725                 /* We don't do an wAppIconPaint() here because it's in
 726                  * wDockAttachIcon(). -Dan
 727                  */
 728             }
 729             wDockAttachIcon(clip, aicon, x, y);
 730             if (clip->collapsed || !clip->mapped)
 731                 XUnmapWindow(dpy, aicon->icon->core->window);
 732         }
 733         aicon = aicon->next;
 734     }
 735 }
 736
 737
 738 static void
 739 selectIconsCallback(WMenu *menu, WMenuEntry *entry)
 740 {
 741     WAppIcon *clickedIcon = (WAppIcon*)entry->clientdata;
 742     WDock *dock;
 743     LinkedList *selectedIcons;
 744     WAppIcon *btn;
 745     int i;
 746
 747     assert(clickedIcon!=NULL);
 748     dock = clickedIcon->dock;
 749
 750     selectedIcons = getSelected(dock);
 751
 752     if (!selectedIcons) {
 753         for (i=1; i<dock->max_icons; i++) {
 754             btn = dock->icon_array[i];
 755             if (btn && !btn->icon->selected) {
 756                 wIconSelect(btn->icon);
 757             }
 758         }
 759     } else {
 760         while(selectedIcons) {
 761             btn = selectedIcons->head;
 762             wIconSelect(btn->icon);
 763             list_remove_head(&selectedIcons);
 764         }
 765     }
 766
 767     wMenuPaint(menu);
 768 }
 769
 770
 771 static void
 772 toggleCollapsedCallback(WMenu *menu, WMenuEntry *entry)
 773 {
 774     assert(entry->clientdata!=NULL);
 775
 776     toggleCollapsed(entry->clientdata);
 777
 778     entry->flags.indicator_on = ((WDock*)entry->clientdata)->collapsed;
 779
 780     wMenuPaint(menu);
 781 }
 782
 783
 784 static void
 785 toggleAutoCollapseCallback(WMenu *menu, WMenuEntry *entry)
 786 {
 787     WDock *dock;
 788     assert(entry->clientdata!=NULL);
 789
 790     dock = (WDock*) entry->clientdata;
 791
 792     dock->auto_collapse = !dock->auto_collapse;
 793
 794     entry->flags.indicator_on = ((WDock*)entry->clientdata)->auto_collapse;
 795
 796     wMenuPaint(menu);
 797 }
 798
 799
 800 static void
 801 toggleAutoRaiseLowerCallback(WMenu *menu, WMenuEntry *entry)
 802 {
 803     WDock *dock;
 804     assert(entry->clientdata!=NULL);
 805
 806     dock = (WDock*) entry->clientdata;
 807
 808     dock->auto_raise_lower = !dock->auto_raise_lower;
 809
 810     entry->flags.indicator_on = ((WDock*)entry->clientdata)->auto_raise_lower;
 811
 812     wMenuPaint(menu);
 813 }
 814
 815
 816 static void
 817 launchCallback(WMenu *menu, WMenuEntry *entry)
 818 {
 819     WAppIcon *btn = (WAppIcon*)entry->clientdata;
 820
 821     launchDockedApplication(btn);
 822 }
 823
 824
 825 static void
 826 settingsCallback(WMenu *menu, WMenuEntry *entry)
 827 {
 828     WAppIcon *btn = (WAppIcon*)entry->clientdata;
 829
 830     if (btn->editing)
 831         return;
 832     ShowDockAppSettingsPanel(btn);
 833 }
 834
 835
 836 static void
 837 hideCallback(WMenu *menu, WMenuEntry *entry)
 838 {
 839     WApplication *wapp;
 840     WAppIcon *btn = (WAppIcon*)entry->clientdata;
 841
 842     wapp = wApplicationOf(btn->icon->owner->main_window);
 843
 844     if (wapp->flags.hidden) {
 845         wWorkspaceChange(btn->icon->core->screen_ptr,wapp->last_workspace);
 846         wUnhideApplication(wapp, False, False);
 847     } else {
 848         wHideApplication(wapp);
 849     }
 850 }
 851
 852
 853 static void
 854 unhideHereCallback(WMenu *menu, WMenuEntry *entry)
 855 {
 856     WApplication *wapp;
 857     WAppIcon *btn = (WAppIcon*)entry->clientdata;
 858
 859     wapp = wApplicationOf(btn->icon->owner->main_window);
 860
 861     wUnhideApplication(wapp, False, True);
 862 }
 863
 864
 865 WAppIcon*
 866 mainIconCreate(WScreen *scr, int type)
 867 {
 868     WAppIcon *btn;
 869     int x_pos;
 870
 871     if (type == WM_CLIP) {
 872         if (scr->clip_icon)
 873             return scr->clip_icon;
 874         btn = wAppIconCreateForDock(scr, NULL, "Logo", "WMClip", TILE_CLIP);
 875         btn->icon->core->descriptor.handle_expose = clipIconExpose;
 876         btn->icon->core->descriptor.handle_enternotify = clipEnterNotify;
 877         btn->icon->core->descriptor.handle_leavenotify = clipLeaveNotify;
 878         /*x_pos = scr->scr_width - ICON_SIZE*2 - DOCK_EXTRA_SPACE;*/
 879         x_pos = 0;
 880     } else {
 881         btn = wAppIconCreateForDock(scr, NULL, "Logo", "WMDock", TILE_NORMAL);
 882         x_pos = scr->scr_width - ICON_SIZE - DOCK_EXTRA_SPACE;
 883     }
 884
 885     btn->xindex = 0;
 886     btn->yindex = 0;
 887
 888     btn->icon->core->descriptor.handle_mousedown = iconMouseDown;
 889     btn->icon->core->descriptor.parent_type = WCLASS_DOCK_ICON;
 890     btn->icon->core->descriptor.parent = btn;
 891     /*ChangeStackingLevel(btn->icon->core, WMDockLevel);*/
 892     XMapWindow(dpy, btn->icon->core->window);
 893     btn->x_pos = x_pos;
 894     btn->y_pos = 0;
 895     btn->docked = 1;
 896     if (type == WM_CLIP)
 897         scr->clip_icon = btn;
 898
 899     return btn;
 900 }
 901
 902
 903 static void
 904 switchWSCommand(WMenu *menu, WMenuEntry *entry)
 905 {
 906     WAppIcon *btn, *icon = (WAppIcon*) entry->clientdata;
 907     WScreen *scr = icon->icon->core->screen_ptr;
 908     WDock *src, *dest;
 909     LinkedList *selectedIcons;
 910     int x, y;
 911
 912     if (entry->order == scr->current_workspace)
 913         return;
 914     src = icon->dock;
 915     dest = scr->workspaces[entry->order]->clip;
 916
 917     selectedIcons = getSelected(src);
 918
 919     if (selectedIcons) {
 920         while(selectedIcons) {
 921             btn = selectedIcons->head;
 922             if (wDockFindFreeSlot(dest, &x, &y)) {
 923                 moveIconBetweenDocks(src, dest, btn, x, y);
 924                 XUnmapWindow(dpy, btn->icon->core->window);
 925             }
 926             list_remove_head(&selectedIcons);
 927         }
 928     } else if (icon != scr->clip_icon) {
 929         if (wDockFindFreeSlot(dest, &x, &y)) {
 930             moveIconBetweenDocks(src, dest, icon, x, y);
 931             XUnmapWindow(dpy, icon->icon->core->window);
 932         }
 933     }
 934 }
 935
 936
 937
 938 static void
 939 launchDockedApplication(WAppIcon *btn)
 940 {
 941     WScreen *scr = btn->icon->core->screen_ptr;
 942
 943     if (!btn->launching && btn->command!=NULL) {
 944         if (!btn->forced_dock) {
 945             btn->relaunching = btn->running;
 946             btn->running = 1;
 947         }
 948         if (btn->wm_instance || btn->wm_class) {
 949             WWindowAttributes attr;
 950             memset(&attr, 0, sizeof(WWindowAttributes));
 951             wDefaultFillAttributes(scr, btn->wm_instance, btn->wm_class,
 952                                    &attr, NULL, True);
 953
 954             if (!attr.no_appicon && !btn->buggy_app)
 955                 btn->launching = 1;
 956             else
 957                 btn->running = 0;
 958         }
 959         btn->drop_launch = 0;
 960         scr->last_dock = btn->dock;
 961         btn->pid = execCommand(btn, btn->command, NULL);
 962         if (btn->pid>0) {
 963             if (btn->buggy_app) {
 964                 /* give feedback that the app was launched */
 965                 btn->launching = 1;
 966                 dockIconPaint(btn);
 967                 btn->launching = 0;
 968                 WMAddTimerHandler(200, (WMCallback*)dockIconPaint, btn);
 969             } else {
 970                 dockIconPaint(btn);
 971             }
 972         } else {
 973             wwarning(_("could not launch application %s\n"), btn->command);
 974             btn->launching = 0;
 975             if (!btn->relaunching)
 976                 btn->running = 0;
 977         }
 978     }
 979 }
 980
 981
 982
 983 static void
 984 updateWorkspaceMenu(WMenu *menu, WAppIcon *icon)
 985 {
 986     WScreen *scr = menu->frame->screen_ptr;
 987     char title[MAX_WORKSPACENAME_WIDTH+1];
 988     int i;
 989
 990     if (!menu || !icon)
 991         return;
 992
 993     for (i=0; i<scr->workspace_count; i++) {
 994         if (i < menu->entry_no) {
 995             if (strcmp(menu->entries[i]->text,scr->workspaces[i]->name)!=0) {
 996                 free(menu->entries[i]->text);
 997                 strcpy(title, scr->workspaces[i]->name);
 998                 menu->entries[i]->text = wstrdup(title);
 999                 menu->flags.realized = 0;
1000             }
1001             menu->entries[i]->clientdata = (void*)icon;
1002         } else {
1003             strcpy(title, scr->workspaces[i]->name);
1004
1005             wMenuAddCallback(menu, title, switchWSCommand, (void*)icon);
1006
1007             menu->flags.realized = 0;
1008         }
1009         if (i == scr->current_workspace) {
1010             wMenuSetEnabled(menu, i, False);
1011         } else {
1012             wMenuSetEnabled(menu, i, True);
1013         }
1014     }
1015
1016     if (!menu->flags.realized)
1017         wMenuRealize(menu);
1018 }
1019
1020
1021 static WMenu*
1022 makeWorkspaceMenu(WScreen *scr)
1023 {
1024     WMenu *menu;
1025
1026     menu = wMenuCreate(scr, NULL, False);
1027     if (!menu)
1028         wwarning(_("could not create workspace submenu for Clip menu"));
1029
1030     wMenuAddCallback(menu, "", switchWSCommand, (void*)scr->clip_icon);
1031
1032     menu->flags.realized = 0;
1033     wMenuRealize(menu);
1034
1035     return menu;
1036 }
1037
1038
1039 static void
1040 updateClipOptionsMenu(WMenu *menu, WDock *dock)
1041 {
1042     WMenuEntry *entry;
1043     int index = 0;
1044
1045     if (!menu || !dock)
1046         return;
1047
1048     /* keep on top */
1049     entry = menu->entries[index];
1050     entry->flags.indicator_on = !dock->lowered;
1051     entry->clientdata = dock;
1052
1053     /* collapsed */
1054     entry = menu->entries[++index];
1055     entry->flags.indicator_on = dock->collapsed;
1056     entry->clientdata = dock;
1057
1058     /* auto-collapse */
1059     entry = menu->entries[++index];
1060     entry->flags.indicator_on = dock->auto_collapse;
1061     entry->clientdata = dock;
1062
1063     /* auto-raise/lower */
1064     entry = menu->entries[++index];
1065     entry->flags.indicator_on = dock->auto_raise_lower;
1066     entry->clientdata = dock;
1067
1068     /* attract icons */
1069     entry = menu->entries[++index];
1070     entry->flags.indicator_on = dock->attract_icons;
1071     entry->clientdata = dock;
1072
1073     /* keep attracted icons */
1074     entry = menu->entries[++index];
1075     entry->flags.indicator_on = dock->keep_attracted;
1076     entry->clientdata = dock;
1077
1078     menu->flags.realized = 0;
1079     wMenuRealize(menu);
1080 }
1081
1082
1083 static WMenu*
1084 makeClipOptionsMenu(WScreen *scr)
1085 {
1086     WMenu *menu;
1087     WMenuEntry *entry;
1088
1089     menu = wMenuCreate(scr, NULL, False);
1090     if (!menu) {
1091         wwarning(_("could not create options submenu for Clip menu"));
1092         return NULL;
1093     }
1094
1095     entry = wMenuAddCallback(menu, _("Keep on Top"),
1096                              toggleLoweredCallback, NULL);
1097     entry->flags.indicator = 1;
1098     entry->flags.indicator_on = 1;
1099     entry->flags.indicator_type = MI_CHECK;
1100
1101     entry = wMenuAddCallback(menu, _("Collapsed"),
1102                              toggleCollapsedCallback, NULL);
1103     entry->flags.indicator = 1;
1104     entry->flags.indicator_on = 1;
1105     entry->flags.indicator_type = MI_CHECK;
1106
1107     entry = wMenuAddCallback(menu, _("AutoCollapse"),
1108                              toggleAutoCollapseCallback, NULL);
1109     entry->flags.indicator = 1;
1110     entry->flags.indicator_on = 1;
1111     entry->flags.indicator_type = MI_CHECK;
1112
1113     entry = wMenuAddCallback(menu, _("AutoRaiseLower"),
1114                              toggleAutoRaiseLowerCallback, NULL);
1115     entry->flags.indicator = 1;
1116     entry->flags.indicator_on = 1;
1117     entry->flags.indicator_type = MI_CHECK;
1118
1119     entry = wMenuAddCallback(menu, _("AutoAttract Icons"),
1120                              toggleAutoAttractCallback, NULL);
1121     entry->flags.indicator = 1;
1122     entry->flags.indicator_on = 1;
1123     entry->flags.indicator_type = MI_CHECK;
1124
1125     entry = wMenuAddCallback(menu, _("Keep Attracted Icons"),
1126                              toggleKeepCallback, NULL);
1127     entry->flags.indicator = 1;
1128     entry->flags.indicator_on = 1;
1129     entry->flags.indicator_type = MI_CHECK;
1130
1131     menu->flags.realized = 0;
1132     wMenuRealize(menu);
1133
1134     return menu;
1135 }
1136
1137
1138 static WMenu*
1139 dockMenuCreate(WScreen *scr, int type)
1140 {
1141     WMenu *menu;
1142     WMenuEntry *entry;
1143
1144     if (type == WM_CLIP && scr->clip_menu)
1145         return scr->clip_menu;
1146
1147     menu = wMenuCreate(scr, NULL, False);
1148     if (type != WM_CLIP) {
1149         entry = wMenuAddCallback(menu, _("Keep on top"),
1150                                  toggleLoweredCallback, NULL);
1151         entry->flags.indicator = 1;
1152         entry->flags.indicator_on = 1;
1153         entry->flags.indicator_type = MI_CHECK;
1154     } else {
1155         entry = wMenuAddCallback(menu, _("Clip Options"), NULL, NULL);
1156         scr->clip_options = makeClipOptionsMenu(scr);
1157         if (scr->clip_options)
1158             wMenuEntrySetCascade(menu, entry, scr->clip_options);
1159
1160         entry = wMenuAddCallback(menu, _("Rename Workspace"), renameCallback,
1161                                  NULL);
1162         free(entry->text);
1163         entry->text = _("Rename Workspace");
1164
1165         entry = wMenuAddCallback(menu, _("Selected"), selectCallback, NULL);
1166         entry->flags.indicator = 1;
1167         entry->flags.indicator_on = 1;
1168         entry->flags.indicator_type = MI_CHECK;
1169
1170         entry = wMenuAddCallback(menu, _("Select All Icons"),
1171                                  selectIconsCallback, NULL);
1172         free(entry->text);
1173         entry->text = _("Select All Icons");
1174
1175         entry = wMenuAddCallback(menu, _("Keep Icon"), keepIconsCallback, NULL);
1176         free(entry->text);
1177         entry->text = _("Keep Icon");
1178
1179         entry = wMenuAddCallback(menu, _("Move Icon To"), NULL, NULL);
1180         free(entry->text);
1181         entry->text = _("Move Icon To");
1182         scr->clip_submenu = makeWorkspaceMenu(scr);
1183         if (scr->clip_submenu)
1184             wMenuEntrySetCascade(menu, entry, scr->clip_submenu);
1185
1186         entry = wMenuAddCallback(menu, _("Remove Icon"), removeIconsCallback,
1187                                  NULL);
1188         free(entry->text);
1189         entry->text = _("Remove Icon");
1190
1191         wMenuAddCallback(menu, _("Attract Icons"), colectIconsCallback, NULL);
1192     }
1193
1194     wMenuAddCallback(menu, _("Launch"), launchCallback, NULL);
1195
1196     wMenuAddCallback(menu, _("Unhide Here"), unhideHereCallback, NULL);
1197
1198     entry = wMenuAddCallback(menu, _("Hide"), hideCallback, NULL);
1199     free(entry->text);
1200     entry->text = _("Hide");
1201
1202     wMenuAddCallback(menu, _("Settings..."), settingsCallback, NULL);
1203
1204     wMenuAddCallback(menu, _("Kill"), killCallback, NULL);
1205
1206     if (type == WM_CLIP)
1207         scr->clip_menu = menu;
1208
1209     return menu;
1210 }
1211
1212
1213 WDock*
1214 wDockCreate(WScreen *scr, int type)
1215 {
1216     WDock *dock;
1217     WAppIcon *btn;
1218     int icon_count;
1219
1220     make_keys();
1221
1222     dock = wmalloc(sizeof(WDock));
1223     memset(dock, 0, sizeof(WDock));
1224
1225     if (type == WM_CLIP)
1226         icon_count = CLIP_MAX_ICONS;
1227     else
1228         icon_count = scr->scr_height/wPreferences.icon_size;
1229
1230     dock->icon_array = wmalloc(sizeof(WAppIcon*)*icon_count);
1231     memset(dock->icon_array, 0, sizeof(WAppIcon*)*icon_count);
1232
1233     dock->max_icons = icon_count;
1234
1235     btn = mainIconCreate(scr, type);
1236
1237     btn->dock = dock;
1238
1239     dock->x_pos = btn->x_pos;
1240     dock->y_pos = btn->y_pos;
1241     dock->screen_ptr = scr;
1242     dock->type = type;
1243     dock->icon_count = 1;
1244     dock->on_right_side = 1;
1245     dock->collapsed = 0;
1246     dock->auto_collapse = 0;
1247     dock->auto_collapse_magic = NULL;
1248     dock->auto_raise_lower = 0;
1249     dock->auto_lower_magic = NULL;
1250     dock->auto_raise_magic = NULL;
1251     dock->attract_icons = 0;
1252     dock->keep_attracted = 0;
1253     dock->lowered = 1;
1254     dock->icon_array[0] = btn;
1255     wRaiseFrame(btn->icon->core);
1256     XMoveWindow(dpy, btn->icon->core->window, btn->x_pos, btn->y_pos);
1257
1258     /* create dock menu */
1259     dock->menu = dockMenuCreate(scr, type);
1260
1261     return dock;
1262 }
1263
1264
1265 void
1266 wDockDestroy(WDock *dock)
1267 {
1268     int i;
1269     WAppIcon *aicon;
1270
1271     for (i=(dock->type == WM_CLIP) ? 1 : 0; i<dock->max_icons; i++) {
1272         aicon = dock->icon_array[i];
1273         if (aicon) {
1274             int keepit = aicon->running && wApplicationOf(aicon->main_window);
1275             wDockDetach(dock, aicon);
1276             if (keepit) {
1277                 PlaceIcon(dock->screen_ptr, &aicon->x_pos, &aicon->y_pos);
1278                 XMoveWindow(dpy, aicon->icon->core->window,
1279                             aicon->x_pos, aicon->y_pos);
1280                 if (!dock->mapped || dock->collapsed)
1281                     XMapWindow(dpy, aicon->icon->core->window);
1282             }
1283         }
1284     }
1285     if (wPreferences.auto_arrange_icons)
1286         wArrangeIcons(dock->screen_ptr, True);
1287     free(dock->icon_array);
1288     if (dock->menu && dock->type!=WM_CLIP)
1289         wMenuDestroy(dock->menu, True);
1290     free(dock);
1291 }
1292
1293
1294 void
1295 wClipIconPaint(WAppIcon *aicon)
1296 {
1297     WScreen *scr = aicon->icon->core->screen_ptr;
1298     WWorkspace *workspace = scr->workspaces[scr->current_workspace];
1299     GC gc;
1300     Window win = aicon->icon->core->window;
1301     int length, nlength;
1302     char *ws_name, ws_number[10];
1303     int ty, tx;
1304
1305     wIconPaint(aicon->icon);
1306
1307     length = strlen(workspace->name);
1308     ws_name = malloc(length + 1);
1309     sprintf(ws_name, "%s", workspace->name);
1310     sprintf(ws_number, "%i", scr->current_workspace + 1);
1311     nlength = strlen(ws_number);
1312
1313     gc = scr->clip_title_gc;
1314
1315     if (!workspace->clip->collapsed)
1316         XSetForeground(dpy, gc, scr->clip_title_pixel[CLIP_NORMAL]);
1317     else
1318         XSetForeground(dpy, gc, scr->clip_title_pixel[CLIP_COLLAPSED]);
1319
1320     ty = ICON_SIZE - WMFontHeight(scr->clip_title_font) - 3;
1321
1322     tx = CLIP_BUTTON_SIZE*ICON_SIZE/64;
1323
1324     WMDrawString(scr->wmscreen, win, gc, scr->clip_title_font, tx,
1325                  ty, ws_name, length);
1326
1327     tx = (ICON_SIZE/2 - WMWidthOfString(scr->clip_title_font, ws_number,
1328                                         nlength))/2;
1329
1330     WMDrawString(scr->wmscreen, win, gc, scr->clip_title_font, tx,
1331                  2, ws_number, nlength);
1332
1333     free(ws_name);
1334
1335     if (aicon->launching) {
1336         XFillRectangle(dpy, aicon->icon->core->window, scr->stipple_gc,
1337                        0, 0, wPreferences.icon_size, wPreferences.icon_size);
1338     }
1339     paintClipButtons(aicon, aicon->dock->lclip_button_pushed,
1340                      aicon->dock->rclip_button_pushed);
1341 }
1342
1343
1344 static void
1345 clipIconExpose(WObjDescriptor *desc, XEvent *event)
1346 {
1347     wClipIconPaint(desc->parent);
1348 }
1349
1350
1351 static void
1352 dockIconPaint(WAppIcon *btn)
1353 {
1354     if (btn == btn->icon->core->screen_ptr->clip_icon)
1355         wClipIconPaint(btn);
1356     else
1357         wAppIconPaint(btn);
1358 }
1359
1360
1361 static proplist_t
1362 make_icon_state(WAppIcon *btn)
1363 {
1364     proplist_t node = NULL;
1365     proplist_t command, autolaunch, name, forced, host, position, buggy;
1366     proplist_t omnipresent;
1367     char *tmp;
1368     char buffer[64];
1369
1370     if (btn) {
1371         if (!btn->command)
1372             command = PLMakeString("-");
1373         else
1374             command = PLMakeString(btn->command);
1375
1376         autolaunch = btn->auto_launch ? dYes : dNo;
1377
1378         tmp = EscapeWM_CLASS(btn->wm_instance, btn->wm_class);
1379
1380         name = PLMakeString(tmp);
1381
1382         free(tmp);
1383
1384         forced = btn->forced_dock ? dYes : dNo;
1385
1386         buggy = btn->buggy_app ? dYes : dNo;
1387
1388         if (btn == btn->icon->core->screen_ptr->clip_icon)
1389             sprintf(buffer, "%i,%i", btn->x_pos, btn->y_pos);
1390         else
1391             sprintf(buffer, "%hi,%hi", btn->xindex, btn->yindex);
1392         position = PLMakeString(buffer);
1393
1394         node = PLMakeDictionaryFromEntries(dCommand, command,
1395                                            dName, name,
1396                                            dAutoLaunch, autolaunch,
1397                                            dForced, forced,
1398                                            dBuggyApplication, buggy,
1399                                            dPosition, position,
1400                                            NULL);
1401         PLRelease(command);
1402         PLRelease(name);
1403         PLRelease(position);
1404
1405         omnipresent = btn->omnipresent ? dYes : dNo;
1406         if (btn->dock != btn->icon->core->screen_ptr->dock &&
1407             (btn->xindex != 0 || btn->yindex != 0))
1408             PLInsertDictionaryEntry(node, dOmnipresent, omnipresent);
1409
1410 #ifdef OFFIX_DND
1411         if (btn->dnd_command) {
1412             command = PLMakeString(btn->dnd_command);
1413             PLInsertDictionaryEntry(node, dDropCommand, command);
1414             PLRelease(command);
1415         }
1416 #endif /* OFFIX_DND */
1417
1418         if (btn->client_machine && btn->remote_start) {
1419             host = PLMakeString(btn->client_machine);
1420             PLInsertDictionaryEntry(node, dHost, host);
1421             PLRelease(host);
1422         }
1423     }
1424
1425     return node;
1426 }
1427
1428
1429 static proplist_t
1430 dockSaveState(WDock *dock)
1431 {
1432     int i;
1433     proplist_t icon_info;
1434     proplist_t list=NULL, dock_state=NULL;
1435     proplist_t value;
1436     char buffer[256];
1437
1438     list = PLMakeArrayFromElements(NULL);
1439
1440     for (i=(dock->type==WM_DOCK ? 0 : 1); i<dock->max_icons; i++) {
1441         WAppIcon *btn = dock->icon_array[i];
1442
1443         if (!btn || (btn->attracted && !dock->keep_attracted))
1444             continue;
1445
1446         if ((icon_info = make_icon_state(dock->icon_array[i]))) {
1447             list = PLAppendArrayElement(list, icon_info);
1448             PLRelease(icon_info);
1449         }
1450     }
1451
1452     dock_state = PLMakeDictionaryFromEntries(dApplications, list, NULL);
1453
1454     PLRelease(list);
1455
1456     if (dock->type == WM_DOCK) {
1457         sprintf(buffer, "%i,%i", (dock->on_right_side ? -ICON_SIZE : 0),
1458                                   dock->y_pos);
1459         value = PLMakeString(buffer);
1460         PLInsertDictionaryEntry(dock_state, dPosition, value);
1461         PLRelease(value);
1462     }
1463
1464     value = (dock->lowered ? dYes : dNo);
1465     PLInsertDictionaryEntry(dock_state, dLowered, value);
1466
1467     if (dock->type == WM_CLIP) {
1468         value = (dock->collapsed ? dYes : dNo);
1469         PLInsertDictionaryEntry(dock_state, dCollapsed, value);
1470
1471         value = (dock->auto_collapse ? dYes : dNo);
1472         PLInsertDictionaryEntry(dock_state, dAutoCollapse, value);
1473
1474         value = (dock->auto_raise_lower ? dYes : dNo);
1475         PLInsertDictionaryEntry(dock_state, dAutoRaiseLower, value);
1476
1477         value = (dock->attract_icons ? dYes : dNo);
1478         PLInsertDictionaryEntry(dock_state, dAutoAttractIcons, value);
1479
1480         value = (dock->keep_attracted ? dYes : dNo);
1481         PLInsertDictionaryEntry(dock_state, dKeepAttracted, value);
1482     }
1483
1484     return dock_state;
1485 }
1486
1487
1488 void
1489 wDockSaveState(WScreen *scr)
1490 {
1491     proplist_t dock_state;
1492
1493     dock_state = dockSaveState(scr->dock);
1494
1495     PLInsertDictionaryEntry(scr->session_state, dDock, dock_state);
1496
1497     PLRelease(dock_state);
1498 }
1499
1500
1501 void
1502 wClipSaveState(WScreen *scr)
1503 {
1504     proplist_t clip_state;
1505
1506     clip_state = make_icon_state(scr->clip_icon);
1507
1508     PLInsertDictionaryEntry(scr->session_state, dClip, clip_state);
1509
1510     PLRelease(clip_state);
1511 }
1512
1513
1514 proplist_t
1515 wClipSaveWorkspaceState(WScreen *scr, int workspace)
1516 {
1517     return dockSaveState(scr->workspaces[workspace]->clip);
1518 }
1519
1520
1521 static WAppIcon*
1522 restore_icon_state(WScreen *scr, proplist_t info, int type, int index)
1523 {
1524     WAppIcon *aicon;
1525     char *wclass, *winstance;
1526     proplist_t cmd, value;
1527     char *command;
1528
1529
1530     cmd = PLGetDictionaryEntry(info, dCommand);
1531     if (!cmd || !PLIsString(cmd)) {
1532         return NULL;
1533     }
1534
1535     /* parse window name */
1536     value = PLGetDictionaryEntry(info, dName);
1537     if (!value)
1538         return NULL;
1539
1540     ParseWindowName(value, &winstance, &wclass, "dock");
1541
1542     if (!winstance && !wclass) {
1543         return NULL;
1544     }
1545
1546     /* get commands */
1547
1548     if (cmd)
1549         command = wstrdup(PLGetString(cmd));
1550     else
1551         command = NULL;
1552
1553     if (!command || strcmp(command, "-")==0) {
1554         if (command)
1555             free(command);
1556         if (wclass)
1557             free(wclass);
1558         if (winstance)
1559             free(winstance);
1560
1561         return NULL;
1562     }
1563
1564     aicon = wAppIconCreateForDock(scr, command, winstance, wclass,
1565                                   TILE_NORMAL);
1566     if (wclass)
1567         free(wclass);
1568     if (winstance)
1569         free(winstance);
1570
1571     aicon->icon->core->descriptor.handle_mousedown = iconMouseDown;
1572     if (type == WM_CLIP) {
1573         aicon->icon->core->descriptor.handle_enternotify = clipEnterNotify;
1574         aicon->icon->core->descriptor.handle_leavenotify = clipLeaveNotify;
1575     }
1576     aicon->icon->core->descriptor.parent_type = WCLASS_DOCK_ICON;
1577     aicon->icon->core->descriptor.parent = aicon;
1578
1579
1580 #ifdef OFFIX_DND
1581     cmd = PLGetDictionaryEntry(info, dDropCommand);
1582     if (cmd)
1583         aicon->dnd_command = wstrdup(PLGetString(cmd));
1584 #endif
1585
1586     /* check auto launch */
1587     value = PLGetDictionaryEntry(info, dAutoLaunch);
1588
1589     aicon->auto_launch = 0;
1590     if (value) {
1591         if (PLIsString(value)) {
1592             if (strcasecmp(PLGetString(value), "YES")==0)
1593                 aicon->auto_launch = 1;
1594         } else {
1595             wwarning(_("bad value in docked icon state info %s"),
1596                      PLGetString(dAutoLaunch));
1597         }
1598     }
1599
1600     /* check if it wasn't normally docked */
1601     value = PLGetDictionaryEntry(info, dForced);
1602
1603     aicon->forced_dock = 0;
1604     if (value) {
1605         if (PLIsString(value)) {
1606             if (strcasecmp(PLGetString(value), "YES")==0)
1607                 aicon->forced_dock = 1;
1608         } else {
1609             wwarning(_("bad value in docked icon state info %s"),
1610                      PLGetString(dForced));
1611         }
1612     }
1613
1614     /* check if we can rely on the stuff in the app */
1615     value = PLGetDictionaryEntry(info, dBuggyApplication);
1616
1617     aicon->buggy_app = 0;
1618     if (value) {
1619         if (PLIsString(value)) {
1620             if (strcasecmp(PLGetString(value), "YES")==0)
1621                 aicon->buggy_app = 1;
1622         } else {
1623             wwarning(_("bad value in docked icon state info %s"),
1624                      PLGetString(dBuggyApplication));
1625         }
1626     }
1627
1628     /* get position in the dock */
1629     value = PLGetDictionaryEntry(info, dPosition);
1630     if (value && PLIsString(value)) {
1631         if (sscanf(PLGetString(value), "%hi,%hi", &aicon->xindex,
1632                    &aicon->yindex)!=2)
1633             wwarning(_("bad value in docked icon state info %s"),
1634                      PLGetString(dPosition));
1635
1636         /* check position sanity */
1637         /* incomplete section! */
1638         if (type == WM_DOCK) {
1639             aicon->xindex = 0;
1640             if (aicon->yindex < 0)
1641                 wwarning(_("bad value in docked icon position %i,%i"),
1642                          aicon->xindex, aicon->yindex);
1643         }
1644     } else {
1645         aicon->yindex = index;
1646         aicon->xindex = 0;
1647     }
1648
1649     /* check if icon is omnipresent */
1650     value = PLGetDictionaryEntry(info, dOmnipresent);
1651
1652     aicon->omnipresent = 0;
1653     if (value) {
1654         if (PLIsString(value)) {
1655             if (strcasecmp(PLGetString(value), "YES")==0)
1656                 aicon->omnipresent = 1;
1657         } else {
1658             wwarning(_("bad value in docked icon state info %s"),
1659                      PLGetString(dOmnipresent));
1660         }
1661     }
1662
1663     aicon->running = 0;
1664     aicon->docked = 1;
1665
1666     return aicon;
1667 }
1668
1669
1670 #define COMPLAIN(key) wwarning(_("bad value in dock state info:%s"), key)
1671
1672
1673 WAppIcon*
1674 wClipRestoreState(WScreen *scr, proplist_t clip_state)
1675 {
1676     WAppIcon *icon;
1677     proplist_t value;
1678
1679
1680     icon = mainIconCreate(scr, WM_CLIP);
1681
1682     if (!clip_state)
1683         return icon;
1684     else
1685         PLRetain(clip_state);
1686
1687     /* restore position */
1688
1689     value = PLGetDictionaryEntry(clip_state, dPosition);
1690
1691     if (value) {
1692         if (!PLIsString(value))
1693             COMPLAIN("Position");
1694         else {
1695             if (sscanf(PLGetString(value), "%i,%i", &icon->x_pos,
1696                        &icon->y_pos)!=2)
1697                 COMPLAIN("Position");
1698
1699             /* check position sanity */
1700             if (icon->y_pos < 0)
1701                 icon->y_pos = 0;
1702             else if (icon->y_pos > scr->scr_height-ICON_SIZE)
1703                 icon->y_pos = scr->scr_height-ICON_SIZE;
1704
1705             if (icon->x_pos < 0)
1706                 icon->x_pos = 0;
1707             else if (icon->x_pos > scr->scr_width-ICON_SIZE)
1708                 icon->x_pos = scr->scr_width-ICON_SIZE;
1709         }
1710     }
1711
1712 #ifdef OFFIX_DND
1713     value = PLGetDictionaryEntry(clip_state, dDropCommand);
1714     if (value && PLIsString(value))
1715         icon->dnd_command = wstrdup(PLGetString(value));
1716 #endif
1717
1718     PLRelease(clip_state);
1719
1720     return icon;
1721 }
1722
1723
1724 WDock*
1725 wDockRestoreState(WScreen *scr, proplist_t dock_state, int type)
1726 {
1727     WDock *dock;
1728     proplist_t apps;
1729     proplist_t value;
1730     WAppIcon *aicon, *old_top;
1731     int count, i;
1732
1733
1734     dock = wDockCreate(scr, type);
1735
1736     if (!dock_state)
1737         return dock;
1738
1739     if (dock_state)
1740         PLRetain(dock_state);
1741
1742
1743     /* restore position */
1744
1745     value = PLGetDictionaryEntry(dock_state, dPosition);
1746
1747     if (value) {
1748         if (!PLIsString(value))
1749             COMPLAIN("Position");
1750         else {
1751             if (sscanf(PLGetString(value), "%i,%i", &dock->x_pos,
1752                        &dock->y_pos)!=2)
1753                 COMPLAIN("Position");
1754
1755             /* check position sanity */
1756             if (dock->y_pos < 0)
1757                 dock->y_pos = 0;
1758             else if (dock->y_pos > scr->scr_height-ICON_SIZE)
1759                 dock->y_pos = scr->scr_height - ICON_SIZE;
1760
1761             /* This is no more needed. ??? */
1762             if (type == WM_CLIP) {
1763                 if (dock->x_pos < 0)
1764                     dock->x_pos = 0;
1765                 else if (dock->x_pos > scr->scr_width-ICON_SIZE)
1766                     dock->x_pos = scr->scr_width-ICON_SIZE;
1767             } else {
1768                 if (dock->x_pos >= 0) {
1769                     dock->x_pos = DOCK_EXTRA_SPACE;
1770                     dock->on_right_side = 0;
1771                 } else {
1772                     dock->x_pos = scr->scr_width - DOCK_EXTRA_SPACE - ICON_SIZE;
1773                     dock->on_right_side = 1;
1774                 }
1775             }
1776         }
1777     }
1778
1779     /* restore lowered/raised state */
1780
1781     dock->lowered = 0;
1782
1783     value = PLGetDictionaryEntry(dock_state, dLowered);
1784
1785     if (value) {
1786         if (!PLIsString(value))
1787             COMPLAIN("Lowered");
1788         else {
1789             if (strcasecmp(PLGetString(value), "YES")==0)
1790                 dock->lowered = 1;
1791         }
1792     }
1793
1794
1795     /* restore collapsed state */
1796
1797     dock->collapsed = 0;
1798
1799     value = PLGetDictionaryEntry(dock_state, dCollapsed);
1800
1801     if (value) {
1802         if (!PLIsString(value))
1803             COMPLAIN("Collapsed");
1804         else {
1805             if (strcasecmp(PLGetString(value), "YES")==0)
1806                 dock->collapsed = 1;
1807         }
1808     }
1809
1810
1811     /* restore auto-collapsed state */
1812
1813     value = PLGetDictionaryEntry(dock_state, dAutoCollapse);
1814
1815     if (value) {
1816         if (!PLIsString(value))
1817             COMPLAIN("AutoCollapse");
1818         else {
1819             if (strcasecmp(PLGetString(value), "YES")==0) {
1820                 dock->auto_collapse = 1;
1821                 dock->collapsed = 1;
1822             }
1823         }
1824     }
1825
1826
1827     /* restore auto-raise/lower state */
1828
1829     value = PLGetDictionaryEntry(dock_state, dAutoRaiseLower);
1830
1831     if (value) {
1832         if (!PLIsString(value))
1833             COMPLAIN("AutoRaiseLower");
1834         else {
1835             if (strcasecmp(PLGetString(value), "YES")==0) {
1836                 dock->auto_raise_lower = 1;
1837             }
1838         }
1839     }
1840
1841     /* restore attract icons state */
1842
1843     dock->attract_icons = 0;
1844
1845     value = PLGetDictionaryEntry(dock_state, dAutoAttractIcons);
1846
1847     if (value) {
1848         if (!PLIsString(value))
1849             COMPLAIN("AutoAttractIcons");
1850         else {
1851             if (strcasecmp(PLGetString(value), "YES")==0)
1852                 dock->attract_icons = 1;
1853         }
1854     }
1855
1856
1857     /* restore keep attracted icons state */
1858
1859     dock->keep_attracted = 0;
1860
1861     value = PLGetDictionaryEntry(dock_state, dKeepAttracted);
1862
1863     if (value) {
1864         if (!PLIsString(value))
1865             COMPLAIN("KeepAttracted");
1866         else {
1867             if (strcasecmp(PLGetString(value), "YES")==0)
1868                 dock->keep_attracted = 1;
1869         }
1870     }
1871
1872
1873     /* application list */
1874
1875     apps = PLGetDictionaryEntry(dock_state, dApplications);
1876
1877     if (!apps) {
1878         goto finish;
1879     }
1880
1881     count = PLGetNumberOfElements(apps);
1882
1883     if (count==0)
1884         goto finish;
1885
1886     old_top = dock->icon_array[0];
1887
1888     /* dock->icon_count is set to 1 when dock is created.
1889      * Since Clip is already restored, we want to keep it so for clip,
1890      * but for dock we may change the default top tile, so we set it to 0.
1891      */
1892     if (type == WM_DOCK)
1893         dock->icon_count = 0;
1894
1895     for (i=0; i<count; i++) {
1896         if (dock->icon_count >= dock->max_icons) {
1897             wwarning(_("there are too many icons stored in dock. Ignoring what doesn't fit"));
1898             break;
1899         }
1900
1901         value = PLGetArrayElement(apps, i);
1902         aicon = restore_icon_state(scr, value, type, dock->icon_count);
1903
1904         dock->icon_array[dock->icon_count] = aicon;
1905
1906         if (aicon) {
1907             aicon->dock = dock;
1908             aicon->x_pos = dock->x_pos + (aicon->xindex*ICON_SIZE);
1909             aicon->y_pos = dock->y_pos + (aicon->yindex*ICON_SIZE);
1910
1911             if (dock->lowered)
1912                 ChangeStackingLevel(aicon->icon->core, WMNormalLevel);
1913             else
1914                 ChangeStackingLevel(aicon->icon->core, WMDockLevel);
1915
1916             wCoreConfigure(aicon->icon->core, aicon->x_pos, aicon->y_pos,
1917                            0, 0);
1918
1919             if (!dock->collapsed)
1920                 XMapWindow(dpy, aicon->icon->core->window);
1921             wRaiseFrame(aicon->icon->core);
1922
1923             dock->icon_count++;
1924         } else if (dock->icon_count==0 && type==WM_DOCK)
1925             dock->icon_count++;
1926     }
1927
1928     /* if the first icon is not defined, use the default */
1929     if (dock->icon_array[0]==NULL) {
1930         /* update default icon */
1931         old_top->x_pos = dock->x_pos;
1932         old_top->y_pos = dock->y_pos;
1933         if (dock->lowered)
1934             ChangeStackingLevel(old_top->icon->core, WMNormalLevel);
1935         else
1936             ChangeStackingLevel(old_top->icon->core, WMDockLevel);
1937         dock->icon_array[0] = old_top;
1938         XMoveWindow(dpy, old_top->icon->core->window, dock->x_pos, dock->y_pos);
1939         /* we don't need to increment dock->icon_count here because it was
1940          * incremented in the loop above.
1941          */
1942     } else if (old_top!=dock->icon_array[0]) {
1943         if (old_top == scr->clip_icon)
1944             scr->clip_icon = dock->icon_array[0];
1945         wAppIconDestroy(old_top);
1946     }
1947
1948 finish:
1949     if (dock_state)
1950         PLRelease(dock_state);
1951
1952     return dock;
1953 }
1954
1955
1956
1957 void
1958 wDockLaunchWithState(WDock *dock, WAppIcon *btn, WSavedState *state)
1959 {
1960     if (btn && btn->command && !btn->running && !btn->launching) {
1961
1962         btn->drop_launch = 0;
1963
1964         btn->pid = execCommand(btn, btn->command, state);
1965
1966         if (btn->pid>0) {
1967             if (!btn->forced_dock && !btn->buggy_app) {
1968                 btn->launching = 1;
1969                 dockIconPaint(btn);
1970             }
1971         }
1972     } else {
1973         free(state);
1974     }
1975 }
1976
1977
1978 void
1979 wDockDoAutoLaunch(WDock *dock, int workspace)
1980 {
1981     WAppIcon *btn;
1982     WSavedState *state;
1983     int i;
1984
1985     for (i = 0; i < dock->max_icons; i++) {
1986         btn = dock->icon_array[i];
1987         if (!btn || !btn->auto_launch)
1988             continue;
1989
1990         state = wmalloc(sizeof(WSavedState));
1991         memset(state, 0, sizeof(WSavedState));
1992         state->workspace = workspace;
1993         /* TODO: this is klugy and is very difficult to understand
1994          * what's going on. Try to clean up */
1995         wDockLaunchWithState(dock, btn, state);
1996     }
1997 }
1998
1999 #ifdef REDUCE_APPICONS
2000 void
2001 wDockSimulateLaunch(WDock *dock, WAppIcon *btn)
2002 {
2003     if ((btn == NULL) || (dock == NULL))
2004         return;
2005
2006     if (!btn->running) {
2007         if ((btn->icon->owner == NULL) && (btn->applist))
2008             btn->icon->owner = btn->applist->wapp->main_window_desc;
2009         if (!btn->forced_dock)
2010            btn->launching = 1;
2011         dockIconPaint(btn);
2012         wusleep(5000);
2013     }
2014 }
2015 #endif
2016
2017 #ifdef OFFIX_DND
2018 static WDock*
2019 findDock(WScreen *scr, XEvent *event, int *icon_pos)
2020 {
2021     WDock *dock;
2022     int i;
2023
2024     *icon_pos = -1;
2025     if ((dock = scr->dock)!=NULL) {
2026         for (i=0; i<dock->max_icons; i++) {
2027             if (dock->icon_array[i]
2028                 && dock->icon_array[i]->icon->core->window==event->xclient.window) {
2029                 *icon_pos = i;
2030                 break;
2031             }
2032         }
2033     }
2034     if (*icon_pos<0 && (dock = scr->workspaces[scr->current_workspace]->clip)!=NULL) {
2035         for (i=0; i<dock->max_icons; i++) {
2036             if (dock->icon_array[i]
2037                 && dock->icon_array[i]->icon->core->window==event->xclient.window) {
2038                 *icon_pos = i;
2039                 break;
2040             }
2041         }
2042     }
2043     if(*icon_pos>=0)
2044         return dock;
2045     return NULL;
2046 }
2047
2048
2049 int
2050 wDockReceiveDNDDrop(WScreen *scr, XEvent *event)
2051 {
2052     WDock *dock;
2053     WAppIcon *btn;
2054     int icon_pos;
2055
2056     dock = findDock(scr, event, &icon_pos);
2057     if (!dock)
2058         return False;
2059
2060     /*
2061      * Return True if the drop was on an application icon window.
2062      * In this case, let the ClientMessage handler redirect the
2063      * message to the app.
2064      */
2065     if (dock->icon_array[icon_pos]->icon->icon_win!=None)
2066         return True;
2067
2068     if (dock->icon_array[icon_pos]->dnd_command!=NULL) {
2069         scr->flags.dnd_data_convertion_status = 0;
2070
2071         btn = dock->icon_array[icon_pos];
2072
2073         if (!btn->forced_dock) {
2074             btn->relaunching = btn->running;
2075             btn->running = 1;
2076         }
2077         if (btn->wm_instance || btn->wm_class) {
2078             WWindowAttributes attr;
2079             memset(&attr, 0, sizeof(WWindowAttributes));
2080             wDefaultFillAttributes(btn->icon->core->screen_ptr,
2081                                    btn->wm_instance,
2082                                    btn->wm_class, &attr, NULL, True);
2083
2084             if (!attr.no_appicon)
2085                 btn->launching = 1;
2086             else
2087                 btn->running = 0;
2088         }
2089
2090         btn->drop_launch = 1;
2091         scr->last_dock = dock;
2092         btn->pid = execCommand(btn, btn->dnd_command, NULL);
2093         if (btn->pid>0) {
2094             dockIconPaint(btn);
2095         } else {
2096             btn->launching = 0;
2097             if (!btn->relaunching) {
2098                 btn->running = 0;
2099             }
2100         }
2101     }
2102     return False;
2103 }
2104 #endif /* OFFIX_DND */
2105
2106
2107
2108 Bool
2109 wDockAttachIcon(WDock *dock, WAppIcon *icon, int x, int y)
2110 {
2111     WWindow *wwin;
2112     char **argv;
2113     int argc;
2114     int index;
2115
2116     wwin = icon->icon->owner;
2117     if (icon->command==NULL) {
2118         icon->editing = 0;
2119         if (XGetCommand(dpy, wwin->client_win, &argv, &argc) && argc>0) {
2120
2121             icon->command = FlattenStringList(argv, argc);
2122             XFreeStringList(argv);
2123         } else {
2124             char *command=NULL;
2125
2126 /*          icon->forced_dock = 1;*/
2127             if (!icon->attracted || dock->type!=WM_CLIP || dock->keep_attracted) {
2128                 icon->editing = 1;
2129                 if (wInputDialog(dock->screen_ptr, _("Dock Icon"),
2130                                  _("Type the command used to launch the application"),
2131                                  &command)) {
2132                     if (command && (command[0]==0 ||
2133                                     (command[0]=='-' && command[1]==0))) {
2134                         free(command);
2135                         command = NULL;
2136                     }
2137                     icon->command = command;
2138                     icon->editing = 0;
2139                 } else {
2140                     icon->editing = 0;
2141                     if (command)
2142                         free(command);
2143                     /* If the target is the dock, reject the icon. If
2144                      * the target is the clip, make it an attracted icon
2145                      */
2146                     if (dock->type==WM_CLIP) {
2147                         icon->attracted = 1;
2148                         if (!icon->icon->shadowed) {
2149                             icon->icon->shadowed = 1;
2150                             icon->icon->force_paint = 1;
2151                         }
2152                     } else {
2153                         return False;
2154                     }
2155                 }
2156             }
2157         }
2158     } else {
2159         icon->editing = 0;
2160     }
2161
2162     for (index=1; index<dock->max_icons; index++)
2163         if (dock->icon_array[index] == NULL)
2164             break;
2165     /* if (index == dock->max_icons)
2166          return; */
2167
2168     assert(index < dock->max_icons);
2169
2170     dock->icon_array[index] = icon;
2171     icon->yindex = y;
2172     icon->xindex = x;
2173
2174     icon->omnipresent = 0;
2175
2176     icon->x_pos = dock->x_pos + x*ICON_SIZE;
2177     icon->y_pos = dock->y_pos + y*ICON_SIZE;
2178
2179     dock->icon_count++;
2180
2181     icon->running = 1;
2182     icon->launching = 0;
2183     icon->docked = 1;
2184     icon->dock = dock;
2185     icon->icon->core->descriptor.handle_mousedown = iconMouseDown;
2186     if (dock->type == WM_CLIP) {
2187         icon->icon->core->descriptor.handle_enternotify = clipEnterNotify;
2188         icon->icon->core->descriptor.handle_leavenotify = clipLeaveNotify;
2189     }
2190     icon->icon->core->descriptor.parent_type = WCLASS_DOCK_ICON;
2191     icon->icon->core->descriptor.parent = icon;
2192
2193     MoveInStackListUnder(dock->icon_array[index-1]->icon->core,
2194                          icon->icon->core);
2195     wAppIconMove(icon, icon->x_pos, icon->y_pos);
2196     wAppIconPaint(icon);
2197
2198     if (wPreferences.auto_arrange_icons)
2199         wArrangeIcons(dock->screen_ptr, True);
2200
2201 #ifdef OFFIX_DND
2202     if (icon->command && !icon->dnd_command) {
2203         icon->dnd_command = wmalloc(strlen(icon->command)+8);
2204         sprintf(icon->dnd_command, "%s %%d", icon->command);
2205     }
2206 #endif
2207
2208     return True;
2209 }
2210
2211
2212 void
2213 reattachIcon(WDock *dock, WAppIcon *icon, int x, int y)
2214 {
2215     int index;
2216
2217     for(index=1; index<dock->max_icons; index++) {
2218         if(dock->icon_array[index] == icon)
2219             break;
2220     }
2221     assert(index < dock->max_icons);
2222
2223     icon->yindex = y;
2224     icon->xindex = x;
2225
2226     icon->x_pos = dock->x_pos + x*ICON_SIZE;
2227     icon->y_pos = dock->y_pos + y*ICON_SIZE;
2228 }
2229
2230
2231 Bool
2232 moveIconBetweenDocks(WDock *src, WDock *dest, WAppIcon *icon, int x, int y)
2233 {
2234     WWindow *wwin;
2235     char **argv;
2236     int argc;
2237     int index;
2238
2239     if (src == dest)
2240         return True;     /* No move needed, we're already there */
2241
2242     if (dest == NULL)
2243         return False;
2244
2245     wwin = icon->icon->owner;
2246
2247     /*
2248      * For the moment we can't do this if we move icons in Clip from one
2249      * workspace to other, because if we move two or more icons without
2250      * command, the dialog box will not be able to tell us to which of the
2251      * moved icons it applies. -Dan
2252      */
2253     if ((dest->type==WM_DOCK /*|| dest->keep_attracted*/) && icon->command==NULL) {
2254         if (XGetCommand(dpy, wwin->client_win, &argv, &argc) && argc>0) {
2255
2256             icon->command = FlattenStringList(argv, argc);
2257             XFreeStringList(argv);
2258         } else {
2259             char *command=NULL;
2260
2261             icon->editing = 1;
2262 /*            icon->forced_dock = 1;*/
2263             if (wInputDialog(src->screen_ptr, _("Dock Icon"),
2264                              _("Type the command used to launch the application"),
2265                              &command)) {
2266                 if (command && (command[0]==0 ||
2267                                 (command[0]=='-' && command[1]==0))) {
2268                     free(command);
2269                     command = NULL;
2270                 }
2271                 icon->command = command;
2272             } else {
2273                 icon->editing = 0;
2274                 if (command)
2275                     free(command);
2276                 return False;
2277             }
2278             icon->editing = 0;
2279         }
2280     }
2281
2282     if (dest->type == WM_DOCK)
2283         wClipMakeIconOmnipresent(icon, False);
2284
2285     for(index=1; index<src->max_icons; index++) {
2286         if(src->icon_array[index] == icon)
2287             break;
2288     }
2289     assert(index < src->max_icons);
2290
2291     src->icon_array[index] = NULL;
2292     src->icon_count--;
2293
2294     for(index=1; index<dest->max_icons; index++) {
2295         if(dest->icon_array[index] == NULL)
2296             break;
2297     }
2298     /* if (index == dest->max_icons)
2299         return; */
2300
2301     assert(index < dest->max_icons);
2302
2303     dest->icon_array[index] = icon;
2304     icon->dock = dest;
2305
2306     /* deselect the icon */
2307     if (icon->icon->selected)
2308         wIconSelect(icon->icon);
2309
2310     if (dest->type == WM_DOCK) {
2311         icon->icon->core->descriptor.handle_enternotify = NULL;
2312         icon->icon->core->descriptor.handle_leavenotify = NULL;
2313     } else {
2314         icon->icon->core->descriptor.handle_enternotify = clipEnterNotify;
2315         icon->icon->core->descriptor.handle_leavenotify = clipLeaveNotify;
2316     }
2317
2318     /* set it to be kept when moving to dock, or to a clip that keep the
2319      * attracted icons.
2320      * Unless the icon does not have a command set
2321      */
2322     if (icon->command && (dest->type==WM_DOCK || dest->keep_attracted)) {
2323         icon->attracted = 0;
2324         if (icon->icon->shadowed) {
2325             icon->icon->shadowed = 0;
2326             icon->icon->force_paint = 1;
2327         }
2328     }
2329
2330     if (src->auto_collapse || src->auto_raise_lower)
2331         clipLeave(src);
2332
2333     icon->yindex = y;
2334     icon->xindex = x;
2335
2336     icon->x_pos = dest->x_pos + x*ICON_SIZE;
2337     icon->y_pos = dest->y_pos + y*ICON_SIZE;
2338
2339     dest->icon_count++;
2340
2341     MoveInStackListUnder(dest->icon_array[index-1]->icon->core,
2342                          icon->icon->core);
2343     wAppIconPaint(icon);
2344
2345     return True;
2346 }
2347
2348
2349 void
2350 wDockDetach(WDock *dock, WAppIcon *icon)
2351 {
2352     int index;
2353
2354     /* make the settings panel be closed */
2355     if (icon->panel) {
2356         DestroyDockAppSettingsPanel(icon->panel);
2357     }
2358
2359     icon->docked = 0;
2360     icon->dock = NULL;
2361     icon->attracted = 0;
2362     if (icon->icon->shadowed) {
2363         icon->icon->shadowed = 0;
2364         icon->icon->force_paint = 1;
2365     }
2366
2367     /* This must be called before dock->icon_array[index] is set to NULL.
2368      * Don't move it. -Dan
2369      */
2370     wClipMakeIconOmnipresent(icon, False);
2371
2372     /* deselect the icon */
2373     if (icon->icon->selected)
2374         wIconSelect(icon->icon);
2375
2376     if (icon->command) {
2377         free(icon->command);
2378         icon->command = NULL;
2379     }
2380 #ifdef OFFIX_DND
2381     if (icon->dnd_command) {
2382         free(icon->dnd_command);
2383         icon->dnd_command = NULL;
2384     }
2385 #endif
2386
2387     for (index=1; index<dock->max_icons; index++)
2388         if (dock->icon_array[index] == icon)
2389             break;
2390     assert(index < dock->max_icons);
2391     dock->icon_array[index] = NULL;
2392     icon->yindex = -1;
2393     icon->xindex = -1;
2394
2395     dock->icon_count--;
2396
2397     /* if the dock is not attached to an application or
2398      * the the application did not set the approriate hints yet,
2399      * destroy the icon */
2400 #ifdef REDUCE_APPICONS
2401     if ((icon->num_apps == 0) && (!icon->running || !wApplicationOf(icon->main_window)) )
2402 #else
2403     if (!icon->running || !wApplicationOf(icon->main_window))
2404 #endif
2405         wAppIconDestroy(icon);
2406     else {
2407         icon->icon->core->descriptor.handle_mousedown = appIconMouseDown;
2408         icon->icon->core->descriptor.handle_enternotify = NULL;
2409         icon->icon->core->descriptor.handle_leavenotify = NULL;
2410         icon->icon->core->descriptor.parent_type = WCLASS_APPICON;
2411         icon->icon->core->descriptor.parent = icon;
2412
2413         ChangeStackingLevel(icon->icon->core, NORMAL_ICON_LEVEL);
2414
2415         wAppIconPaint(icon);
2416         if (wPreferences.auto_arrange_icons) {
2417             wArrangeIcons(dock->screen_ptr, True);
2418         }
2419     }
2420     if (dock->auto_collapse || dock->auto_raise_lower)
2421         clipLeave(dock);
2422 }
2423
2424
2425 /*
2426  * returns the closest Dock slot index for the passed
2427  * coordinates.
2428  *
2429  * Returns False if icon can't be docked.
2430  *
2431  * Note: this function should NEVER alter ret_x or ret_y, unless it will
2432  * return True. -Dan
2433  */
2434 Bool
2435 wDockSnapIcon(WDock *dock, WAppIcon *icon, int req_x, int req_y,
2436               int *ret_x, int *ret_y, int redocking)
2437 {
2438     WScreen *scr = dock->screen_ptr;
2439     int dx, dy;
2440     int ex_x, ex_y;
2441     int i, offset = ICON_SIZE/2;
2442     WAppIcon *aicon = NULL;
2443     WAppIcon *nicon = NULL;
2444     int max_y_icons, max_x_icons;
2445
2446     max_x_icons = scr->scr_width/ICON_SIZE;
2447     max_y_icons = scr->scr_height/ICON_SIZE-1;
2448
2449     if (wPreferences.flags.noupdates)
2450         return False;
2451
2452     dx = dock->x_pos;
2453     dy = dock->y_pos;
2454
2455     /* if the dock is full */
2456     if (!redocking &&
2457         (dock->icon_count >= dock->max_icons)) {
2458         return False;
2459     }
2460
2461     /* exact position */
2462     if (req_y < dy)
2463         ex_y = (req_y - offset - dy)/ICON_SIZE;
2464     else
2465         ex_y = (req_y + offset - dy)/ICON_SIZE;
2466
2467     if (req_x < dx)
2468         ex_x = (req_x - offset - dx)/ICON_SIZE;
2469     else
2470         ex_x = (req_x + offset - dx)/ICON_SIZE;
2471
2472     /* check if the icon is outside the screen boundaries */
2473     if (dx + ex_x*ICON_SIZE < -ICON_SIZE+2 ||
2474         dx + ex_x*ICON_SIZE >= scr->scr_width-1 ||
2475         dy + ex_y*ICON_SIZE < -ICON_SIZE+2 ||
2476         dy + ex_y*ICON_SIZE >= scr->scr_height-1)
2477         return False;
2478
2479     if (dock->type == WM_DOCK) {
2480         if (icon->dock != dock && ex_x != 0)
2481             return False;
2482
2483         aicon = NULL;
2484         for (i=0; i<dock->max_icons; i++) {
2485             nicon = dock->icon_array[i];
2486             if (nicon && nicon->yindex == ex_y) {
2487                 aicon = nicon;
2488                 break;
2489             }
2490         }
2491
2492         if (redocking) {
2493             int sig, done, closest;
2494
2495             /* Possible cases when redocking:
2496              *
2497              * icon dragged out of range of any slot -> false
2498              * icon dragged to range of free slot
2499              * icon dragged to range of same slot
2500              * icon dragged to range of different icon
2501              */
2502             if (abs(ex_x) > DOCK_DETTACH_THRESHOLD)
2503                 return False;
2504
2505             if (ex_y>=0 && ex_y<=max_y_icons && (aicon==icon || !aicon)) {
2506                 *ret_x = 0;
2507                 *ret_y = ex_y;
2508                 return True;
2509             }
2510
2511             /* start looking at the upper slot or lower? */
2512             if (ex_y*ICON_SIZE < (req_y + offset - dy))
2513                 sig = 1;
2514             else
2515                 sig = -1;
2516
2517             closest = -1;
2518             done = 0;
2519             /* look for closest free slot */
2520             for (i=0; i<(DOCK_DETTACH_THRESHOLD+1)*2 && !done; i++) {
2521                 int j;
2522
2523                 done = 1;
2524                 closest = sig*(i/2) + ex_y;
2525                 /* check if this slot is used */
2526                 if (closest >= 0) {
2527                     for (j = 0; j<dock->max_icons; j++) {
2528                         if (dock->icon_array[j]
2529                             && dock->icon_array[j]->yindex==closest) {
2530                             /* slot is used by someone else */
2531                             if (dock->icon_array[j]!=icon)
2532                                 done = 0;
2533                             break;
2534                         }
2535                     }
2536                 }
2537                 sig = -sig;
2538             }
2539             if (done && closest >= 0 && closest <= max_y_icons &&
2540                 ((ex_y >= closest && ex_y - closest < DOCK_DETTACH_THRESHOLD+1)
2541                 ||
2542                  (ex_y < closest && closest - ex_y <= DOCK_DETTACH_THRESHOLD+1))) {
2543                 *ret_x = 0;
2544                 *ret_y = closest;
2545                 return True;
2546             }
2547         } else { /* !redocking */
2548
2549             /* if slot is free and the icon is close enough, return it */
2550             if (!aicon && ex_x == 0 && ex_y >= 0 && ex_y <= max_y_icons) {
2551                 *ret_x = 0;
2552                 *ret_y = ex_y;
2553                 return True;
2554             }
2555         }
2556     } else { /* CLIP */
2557         int neighbours = 0;
2558         int start, stop, k;
2559
2560         start = icon->omnipresent ? 0 : scr->current_workspace;
2561         stop  = icon->omnipresent ? scr->workspace_count : start+1;
2562
2563         aicon = NULL;
2564         for (k=start; k<stop; k++) {
2565             WDock *tmp = scr->workspaces[k]->clip;
2566             if (!tmp)
2567                 continue;
2568             for (i=0; i<tmp->max_icons; i++) {
2569                 nicon = tmp->icon_array[i];
2570                 if (nicon && nicon->xindex == ex_x && nicon->yindex == ex_y) {
2571                     aicon = nicon;
2572                     break;
2573                 }
2574             }
2575             if (aicon)
2576                 break;
2577         }
2578         for (k=start; k<stop; k++) {
2579             WDock *tmp = scr->workspaces[k]->clip;
2580             if (!tmp)
2581                 continue;
2582             for (i=0; i<tmp->max_icons; i++) {
2583                 nicon = tmp->icon_array[i];
2584                 if (nicon && nicon != icon && /* Icon can't be it's own neighbour */
2585                     (abs(nicon->xindex - ex_x) <= CLIP_ATTACH_VICINITY &&
2586                      abs(nicon->yindex - ex_y) <= CLIP_ATTACH_VICINITY)) {
2587                     neighbours = 1;
2588                     break;
2589                 }
2590             }
2591             if (neighbours)
2592                 break;
2593         }
2594
2595         if (neighbours && (aicon==NULL || (redocking && aicon == icon))) {
2596             *ret_x = ex_x;
2597             *ret_y = ex_y;
2598             return True;
2599         }
2600     }
2601     return False;
2602 }
2603
2604 #define MIN(x, y)  ((x) > (y) ? (y) : (x))
2605 #define MAX(x, y)  ((x) < (y) ? (y) : (x))
2606
2607 #define ON_SCREEN(x, y, sx, ex, sy, ey) \
2608     ((((x)+ICON_SIZE/2) >= (sx)) && (((y)+ICON_SIZE/2) >= (sy)) && \
2609     (((x) + (ICON_SIZE/2)) <= (ex)) && (((y) + (ICON_SIZE/2)) <= ey))
2610
2611
2612 /*
2613  * returns true if it can find a free slot in the dock,
2614  * in which case it changes x_pos and y_pos accordingly.
2615  * Else returns false.
2616  */
2617 Bool
2618 wDockFindFreeSlot(WDock *dock, int *x_pos, int *y_pos)
2619 {
2620     WScreen *scr = dock->screen_ptr;
2621     WAppIcon *btn;
2622     WAppIconChain *chain;
2623     unsigned char *slot_map;
2624     int mwidth;
2625     int r;
2626     int x, y;
2627     int i, done = False;
2628     int corner;
2629     int sx=0, sy=0, ex=scr->scr_width, ey=scr->scr_height;
2630     int extra_count=0;
2631
2632     if (dock->type == WM_CLIP &&
2633         dock != scr->workspaces[scr->current_workspace]->clip)
2634         extra_count = scr->global_icon_count;
2635
2636     /* if the dock is full */
2637     if (dock->icon_count+extra_count >= dock->max_icons) {
2638         return False;
2639     }
2640
2641     if (!wPreferences.flags.nodock && scr->dock) {
2642         if (scr->dock->on_right_side)
2643             ex -= ICON_SIZE + DOCK_EXTRA_SPACE;
2644         else
2645             sx += ICON_SIZE + DOCK_EXTRA_SPACE;
2646     }
2647
2648     if (ex < dock->x_pos)
2649         ex = dock->x_pos;
2650     if (sx > dock->x_pos+ICON_SIZE)
2651         sx = dock->x_pos+ICON_SIZE;
2652 #define C_NONE 0
2653 #define C_NW 1
2654 #define C_NE 2
2655 #define C_SW 3
2656 #define C_SE 4
2657
2658     /* check if clip is in a corner */
2659     if (dock->type==WM_CLIP) {
2660         if (dock->x_pos < 1 && dock->y_pos < 1)
2661             corner = C_NE;
2662         else if (dock->x_pos < 1 && dock->y_pos >= (ey-ICON_SIZE))
2663             corner = C_SE;
2664         else if (dock->x_pos >= (ex-ICON_SIZE)&& dock->y_pos >= (ey-ICON_SIZE))
2665             corner = C_SW;
2666         else if (dock->x_pos >= (ex-ICON_SIZE) && dock->y_pos < 1)
2667             corner = C_NW;
2668         else
2669             corner = C_NONE;
2670     } else
2671         corner = C_NONE;
2672
2673     /* If the clip is in the corner, use only slots that are in the border
2674      * of the screen */
2675     if (corner!=C_NONE) {
2676         char *hmap, *vmap;
2677         int hcount, vcount;
2678
2679         hcount = MIN(dock->max_icons, scr->scr_width/ICON_SIZE);
2680         vcount = MIN(dock->max_icons, scr->scr_height/ICON_SIZE);
2681         hmap = wmalloc(hcount+1);
2682         memset(hmap, 0, hcount+1);
2683         vmap = wmalloc(vcount+1);
2684         memset(vmap, 0, vcount+1);
2685
2686         /* mark used positions */
2687         switch (corner) {
2688          case C_NE:
2689             for (i=0; i<dock->max_icons; i++) {
2690                 btn = dock->icon_array[i];
2691                 if (!btn)
2692                     continue;
2693
2694                 if (btn->xindex==0 && btn->yindex > 0 && btn->yindex < vcount)
2695                     vmap[btn->yindex] = 1;
2696                 else if (btn->yindex==0 && btn->xindex>0 && btn->xindex<hcount)
2697                     hmap[btn->xindex] = 1;
2698             }
2699             for (chain=scr->global_icons; chain!=NULL; chain=chain->next) {
2700                 btn = chain->aicon;
2701                 if (btn->xindex==0 && btn->yindex > 0 && btn->yindex < vcount)
2702                     vmap[btn->yindex] = 1;
2703                 else if (btn->yindex==0 && btn->xindex>0 && btn->xindex<hcount)
2704                     hmap[btn->xindex] = 1;
2705             }
2706             break;
2707          case C_NW:
2708             for (i=0; i<dock->max_icons; i++) {
2709                 btn = dock->icon_array[i];
2710                 if (!btn)
2711                     continue;
2712
2713                 if (btn->xindex==0 && btn->yindex > 0 && btn->yindex < vcount)
2714                     vmap[btn->yindex] = 1;
2715                 else if (btn->yindex==0 && btn->xindex<0 &&btn->xindex>-hcount)
2716                     hmap[-btn->xindex] = 1;
2717             }
2718             for (chain=scr->global_icons; chain!=NULL; chain=chain->next) {
2719                 btn = chain->aicon;
2720                 if (btn->xindex==0 && btn->yindex > 0 && btn->yindex < vcount)
2721                     vmap[btn->yindex] = 1;
2722                 else if (btn->yindex==0 && btn->xindex<0 &&btn->xindex>-hcount)
2723                     hmap[-btn->xindex] = 1;
2724             }
2725             break;
2726          case C_SE:
2727             for (i=0; i<dock->max_icons; i++) {
2728                 btn = dock->icon_array[i];
2729                 if (!btn)
2730                     continue;
2731
2732                 if (btn->xindex==0 && btn->yindex < 0 && btn->yindex > -vcount)
2733                     vmap[-btn->yindex] = 1;
2734                 else if (btn->yindex==0 && btn->xindex>0 && btn->xindex<hcount)
2735                     hmap[btn->xindex] = 1;
2736             }
2737             for (chain=scr->global_icons; chain!=NULL; chain=chain->next) {
2738                 btn = chain->aicon;
2739                 if (btn->xindex==0 && btn->yindex < 0 && btn->yindex > -vcount)
2740                     vmap[-btn->yindex] = 1;
2741                 else if (btn->yindex==0 && btn->xindex>0 && btn->xindex<hcount)
2742                     hmap[btn->xindex] = 1;
2743             }
2744             break;
2745          case C_SW:
2746          default:
2747             for (i=0; i<dock->max_icons; i++) {
2748                 btn = dock->icon_array[i];
2749                 if (!btn)
2750                     continue;
2751
2752                 if (btn->xindex==0 && btn->yindex < 0 && btn->yindex > -vcount)
2753                     vmap[-btn->yindex] = 1;
2754                 else if (btn->yindex==0 && btn->xindex<0 &&btn->xindex>-hcount)
2755                     hmap[-btn->xindex] = 1;
2756             }
2757             for (chain=scr->global_icons; chain!=NULL; chain=chain->next) {
2758                 btn = chain->aicon;
2759                 if (btn->xindex==0 && btn->yindex < 0 && btn->yindex > -vcount)
2760                     vmap[-btn->yindex] = 1;
2761                 else if (btn->yindex==0 && btn->xindex<0 &&btn->xindex>-hcount)
2762                     hmap[-btn->xindex] = 1;
2763             }
2764         }
2765         x=0; y=0;
2766         done = 0;
2767         /* search a vacant slot */
2768         for (i=1; i<MAX(vcount, hcount); i++) {
2769             if (i < vcount && vmap[i]==0) {
2770                 /* found a slot */
2771                 x = 0;
2772                 y = i;
2773                 done = 1;
2774                 break;
2775             } else if (i < hcount && hmap[i]==0) {
2776                 /* found a slot */
2777                 x = i;
2778                 y = 0;
2779                 done = 1;
2780                 break;
2781             }
2782         }
2783         free(vmap);
2784         free(hmap);
2785         /* If found a slot, translate and return */
2786         if (done) {
2787             if (corner==C_NW || corner==C_NE) {
2788                 *y_pos = y;
2789             } else {
2790                 *y_pos = -y;
2791             }
2792             if (corner==C_NE || corner==C_SE) {
2793                 *x_pos = x;
2794             } else {
2795                 *x_pos = -x;
2796             }
2797             return True;
2798         }
2799         /* else, try to find a slot somewhere else */
2800     }
2801
2802     /* a map of mwidth x mwidth would be enough if we allowed icons to be
2803      * placed outside of screen */
2804     mwidth = (int)ceil(sqrt(dock->max_icons));
2805
2806     /* In the worst case (the clip is in the corner of the screen),
2807      * the amount of icons that fit in the clip is smaller.
2808      * Double the map to get a safe value.
2809      */
2810     mwidth += mwidth;
2811
2812     r = (mwidth-1)/2;
2813
2814     slot_map = wmalloc(mwidth*mwidth);
2815     memset(slot_map, 0, mwidth*mwidth);
2816
2817 #define XY2OFS(x,y) (MAX(abs(x),abs(y)) > r) ? 0 : (((y)+r)*(mwidth)+(x)+r)
2818
2819     /* mark used slots in the map. If the slot falls outside the map
2820      * (for example, when all icons are placed in line), ignore them. */
2821     for (i=0; i<dock->max_icons; i++) {
2822         btn = dock->icon_array[i];
2823         if (btn)
2824             slot_map[XY2OFS(btn->xindex, btn->yindex)] = 1;
2825     }
2826     for (chain=scr->global_icons; chain!=NULL; chain=chain->next) {
2827         slot_map[XY2OFS(chain->aicon->xindex, chain->aicon->yindex)] = 1;
2828     }
2829     /* Find closest slot from the center that is free by scanning the
2830      * map from the center to outward in circular passes.
2831      * This will not result in a neat layout, but will be optimal
2832      * in the sense that there will not be holes left.
2833      */
2834     done = 0;
2835     for (i = 1; i <= r && !done; i++) {
2836         int tx, ty;
2837
2838         /* top and bottom parts of the ring */
2839         for (x = -i; x <= i && !done; x++) {
2840             tx = dock->x_pos + x*ICON_SIZE;
2841             y = -i;
2842             ty = dock->y_pos + y*ICON_SIZE;
2843             if (slot_map[XY2OFS(x,y)]==0
2844                 && ON_SCREEN(tx, ty, sx, ex, sy, ey)) {
2845                 *x_pos = x;
2846                 *y_pos = y;
2847                 done = 1;
2848                 break;
2849             }
2850             y = i;
2851             ty = dock->y_pos + y*ICON_SIZE;
2852             if (slot_map[XY2OFS(x,y)]==0
2853                 && ON_SCREEN(tx, ty, sx, ex, sy, ey)) {
2854                 *x_pos = x;
2855                 *y_pos = y;
2856                 done = 1;
2857                 break;
2858             }
2859         }
2860         /* left and right parts of the ring */
2861         for (y = -i+1; y <= i-1; y++) {
2862             ty = dock->y_pos + y*ICON_SIZE;
2863             x = -i;
2864             tx = dock->x_pos + x*ICON_SIZE;
2865             if (slot_map[XY2OFS(x,y)]==0
2866                 && ON_SCREEN(tx, ty, sx, ex, sy, ey)) {
2867                 *x_pos = x;
2868                 *y_pos = y;
2869                 done = 1;
2870                 break;
2871             }
2872             x = i;
2873             tx = dock->x_pos + x*ICON_SIZE;
2874             if (slot_map[XY2OFS(x,y)]==0
2875                 && ON_SCREEN(tx, ty, sx, ex, sy, ey)) {
2876                 *x_pos = x;
2877                 *y_pos = y;
2878                 done = 1;
2879                 break;
2880             }
2881         }
2882     }
2883     free(slot_map);
2884 #undef XY2OFS
2885     return done;
2886 }
2887
2888
2889 static void
2890 moveDock(WDock *dock, int new_x, int new_y)
2891 {
2892     WAppIcon *btn;
2893     int i;
2894
2895     dock->x_pos = new_x;
2896     dock->y_pos = new_y;
2897     for (i=0; i<dock->max_icons; i++) {
2898         btn = dock->icon_array[i];
2899         if (btn) {
2900             btn->x_pos = new_x + btn->xindex*ICON_SIZE;
2901             btn->y_pos = new_y + btn->yindex*ICON_SIZE;
2902             XMoveWindow(dpy, btn->icon->core->window, btn->x_pos, btn->y_pos);
2903         }
2904     }
2905 }
2906
2907
2908 static void
2909 swapDock(WDock *dock)
2910 {
2911    WScreen *scr = dock->screen_ptr;
2912    WAppIcon *btn;
2913    int x, i;
2914
2915
2916     if (dock->on_right_side) {
2917         x = dock->x_pos = scr->scr_width - ICON_SIZE - DOCK_EXTRA_SPACE;
2918     } else {
2919         x = dock->x_pos = DOCK_EXTRA_SPACE;
2920     }
2921
2922     for (i=0; i<dock->max_icons; i++) {
2923         btn = dock->icon_array[i];
2924         if (btn) {
2925             btn->x_pos = x;
2926             XMoveWindow(dpy, btn->icon->core->window, btn->x_pos, btn->y_pos);
2927         }
2928     }
2929
2930     wScreenUpdateUsableArea(scr);
2931 }
2932
2933
2934 static pid_t
2935 execCommand(WAppIcon *btn, char *command, WSavedState *state)
2936 {
2937     WScreen *scr = btn->icon->core->screen_ptr;
2938     pid_t pid;
2939     char **argv;
2940     int argc;
2941     char *cmdline;
2942
2943     cmdline = ExpandOptions(scr, command);
2944
2945     if (scr->flags.dnd_data_convertion_status || !cmdline) {
2946         if (cmdline)
2947             free(cmdline);
2948         if (state)
2949             free(state);
2950         return 0;
2951     }
2952
2953     ParseCommand(cmdline, &argv, &argc);
2954
2955     if (argv==NULL) {
2956         if (cmdline)
2957             free(cmdline);
2958         if (state)
2959             free(state);
2960         return 0;
2961     }
2962
2963     if ((pid=fork())==0) {
2964         char **args;
2965         int i;
2966
2967         SetupEnvironment(scr);
2968
2969 #ifdef HAVE_SETPGID
2970         setpgid(0, 0);
2971 #endif
2972
2973         args = malloc(sizeof(char*)*(argc+1));
2974         if (!args)
2975             exit(111);
2976         for (i=0; i<argc; i++) {
2977             args[i] = argv[i];
2978         }
2979         args[argc] = NULL;
2980         execvp(argv[0], args);
2981         exit(111);
2982     }
2983     while (argc > 0)
2984         free(argv[--argc]);
2985     free(argv);
2986
2987     if (pid > 0) {
2988         if (!state) {
2989             state = wmalloc(sizeof(WSavedState));
2990             memset(state, 0, sizeof(WSavedState));
2991             state->hidden = -1;
2992             state->miniaturized = -1;
2993             state->shaded = -1;
2994             if (btn->dock==scr->dock || btn->omnipresent)
2995                 state->workspace = -1;
2996             else
2997                 state->workspace = scr->current_workspace;
2998         }
2999         wWindowAddSavedState(btn->wm_instance, btn->wm_class, cmdline, pid,
3000                              state);
3001         wAddDeathHandler(pid, (WDeathHandler*)trackDeadProcess,
3002                          btn->dock);
3003     } else if (state) {
3004         free(state);
3005     }
3006     free(cmdline);
3007     return pid;
3008 }
3009
3010
3011 void
3012 wDockHideIcons(WDock *dock)
3013 {
3014     int i;
3015
3016     if (dock==NULL)
3017         return;
3018
3019     for (i=1; i<dock->max_icons; i++) {
3020         if (dock->icon_array[i])
3021             XUnmapWindow(dpy, dock->icon_array[i]->icon->core->window);
3022     }
3023     dock->mapped = 0;
3024
3025     dockIconPaint(dock->icon_array[0]);
3026 }
3027
3028
3029 void
3030 wDockShowIcons(WDock *dock)
3031 {
3032     int i, newlevel;
3033     WAppIcon *btn;
3034
3035     if (dock==NULL)
3036         return;
3037
3038     btn = dock->icon_array[0];
3039     moveDock(dock, btn->x_pos, btn->y_pos);
3040
3041     newlevel = dock->lowered ? WMNormalLevel : WMDockLevel;
3042     ChangeStackingLevel(btn->icon->core, newlevel);
3043
3044     for (i=1; i<dock->max_icons; i++) {
3045         if (dock->icon_array[i]) {
3046             MoveInStackListAbove(dock->icon_array[i]->icon->core,
3047                                  btn->icon->core);
3048             break;
3049         }
3050     }
3051
3052     if (!dock->collapsed) {
3053         for (i=1; i<dock->max_icons; i++) {
3054             if (dock->icon_array[i]) {
3055                 XMapWindow(dpy, dock->icon_array[i]->icon->core->window);
3056             }
3057         }
3058     }
3059     dock->mapped = 1;
3060
3061     dockIconPaint(btn);
3062 }
3063
3064
3065 void
3066 wDockLower(WDock *dock)
3067 {
3068     int i;
3069
3070     for (i=0; i<dock->max_icons; i++) {
3071         if (dock->icon_array[i])
3072             wLowerFrame(dock->icon_array[i]->icon->core);
3073     }
3074 }
3075
3076
3077 void
3078 wDockRaise(WDock *dock)
3079 {
3080     int i;
3081
3082     for (i=dock->max_icons-1; i>=0; i--) {
3083         if (dock->icon_array[i])
3084             wRaiseFrame(dock->icon_array[i]->icon->core);
3085     }
3086 }
3087
3088
3089 void
3090 wDockRaiseLower(WDock *dock)
3091 {
3092     if (!dock->icon_array[0]->icon->core->stacking->above
3093         ||(dock->icon_array[0]->icon->core->stacking->window_level
3094            !=dock->icon_array[0]->icon->core->stacking->above->stacking->window_level))
3095         wDockLower(dock);
3096     else
3097         wDockRaise(dock);
3098 }
3099
3100
3101 void
3102 wDockFinishLaunch(WDock *dock, WAppIcon *icon)
3103 {
3104     icon->launching = 0;
3105     icon->relaunching = 0;
3106     dockIconPaint(icon);
3107 }
3108
3109
3110 WAppIcon*
3111 wDockFindIconFor(WDock *dock, Window window)
3112 {
3113     WAppIcon *icon;
3114     int i;
3115
3116     for (i=0; i<dock->max_icons; i++) {
3117         icon = dock->icon_array[i];
3118         if (icon && icon->main_window == window)
3119             return icon;
3120     }
3121     return NULL;
3122 }
3123
3124
3125 void
3126 wDockTrackWindowLaunch(WDock *dock, Window window)
3127 {
3128     WAppIcon *icon;
3129 #ifdef REDUCE_APPICONS
3130     WAppIconAppList *tapplist;
3131 #endif
3132     char *wm_class, *wm_instance;
3133     int i;
3134     Bool firstPass = True;
3135     Bool found = False;
3136     char *command = NULL;
3137
3138     {
3139         int argc;
3140         char **argv;
3141
3142         if (XGetCommand(dpy, window, &argv, &argc)) {
3143             if (argc > 0 && argv != NULL)
3144                 command = FlattenStringList(argv,argc);
3145             if (argv) {
3146                 XFreeStringList(argv);
3147             }
3148         }
3149     }
3150
3151     if (!PropGetWMClass(window, &wm_class, &wm_instance) ||
3152         (!wm_class && !wm_instance))
3153         return;
3154
3155 retry:
3156     for (i=0; i<dock->max_icons; i++) {
3157         icon = dock->icon_array[i];
3158         if (!icon)
3159             continue;
3160
3161         /* app is already attached to icon */
3162         if (icon->main_window == window) {
3163             found = True;
3164             break;
3165         }
3166
3167         if ((icon->wm_instance || icon->wm_class)
3168             && (icon->launching
3169                 || (dock->screen_ptr->flags.startup && !icon->running))) {
3170
3171             if (icon->wm_instance && wm_instance &&
3172                 strcmp(icon->wm_instance, wm_instance)!=0) {
3173                 continue;
3174             }
3175             if (icon->wm_class && wm_class &&
3176                 strcmp(icon->wm_class, wm_class)!=0) {
3177                 continue;
3178             }
3179             if (firstPass && command && strcmp(icon->command, command)!=0) {
3180                 continue;
3181             }
3182
3183             if (!icon->relaunching) {
3184                 WApplication *wapp;
3185
3186                 /* Possibly an application that was docked with dockit,
3187                  * but the user did not update WMState to indicate that
3188                  * it was docked by force */
3189                 wapp = wApplicationOf(window);
3190                 if (!wapp) {
3191                     icon->forced_dock = 1;
3192                     icon->running = 0;
3193                 }
3194                 if (!icon->forced_dock)
3195                     icon->main_window = window;
3196
3197 #ifdef REDUCE_APPICONS
3198                 tapplist = wmalloc(sizeof(WAppIconAppList));
3199                 memset(tapplist, 0, sizeof(WAppIconAppList));
3200                 tapplist->next = icon->applist;
3201                 if (icon->applist)
3202                    icon->applist->prev = tapplist;
3203                 icon->applist = tapplist;
3204                 tapplist->wapp = wApplicationOf(window);
3205                 icon->num_apps++;
3206 #endif
3207             }
3208             found = True;
3209             wDockFinishLaunch(dock, icon);
3210             break;
3211         }
3212     }
3213
3214     if (firstPass && !found) {
3215         firstPass = False;
3216         goto retry;
3217     }
3218
3219     if (command)
3220         free(command);
3221
3222     if (wm_class)
3223         XFree(wm_class);
3224     if (wm_instance)
3225         XFree(wm_instance);
3226 }
3227
3228
3229
3230 void
3231 wClipUpdateForWorkspaceChange(WScreen *scr, int workspace)
3232 {
3233     if (!wPreferences.flags.noclip) {
3234         scr->clip_icon->dock = scr->workspaces[workspace]->clip;
3235         if (scr->current_workspace != workspace) {
3236             WDock *old_clip = scr->workspaces[scr->current_workspace]->clip;
3237             WAppIconChain *chain = scr->global_icons;
3238
3239             while (chain) {
3240                 moveIconBetweenDocks(chain->aicon->dock,
3241                                      scr->workspaces[workspace]->clip,
3242                                      chain->aicon, chain->aicon->xindex,
3243                                      chain->aicon->yindex);
3244                 if (scr->workspaces[workspace]->clip->collapsed)
3245                     XUnmapWindow(dpy, chain->aicon->icon->core->window);
3246                 chain = chain->next;
3247             }
3248
3249             wDockHideIcons(old_clip);
3250             if (old_clip->auto_raise_lower) {
3251                 if (old_clip->auto_raise_magic) {
3252                     WMDeleteTimerHandler(old_clip->auto_raise_magic);
3253                     old_clip->auto_raise_magic = NULL;
3254                 }
3255                 wDockLower(old_clip);
3256             }
3257             if (old_clip->auto_collapse) {
3258                 if (old_clip->auto_expand_magic) {
3259                     WMDeleteTimerHandler(old_clip->auto_expand_magic);
3260                     old_clip->auto_expand_magic = NULL;
3261                 }
3262                 old_clip->collapsed = 1;
3263             }
3264             wDockShowIcons(scr->workspaces[workspace]->clip);
3265         }
3266         if (scr->flags.clip_balloon_mapped)
3267             showClipBalloon(scr->clip_icon->dock, workspace);
3268     }
3269 }
3270
3271
3272
3273 static void
3274 trackDeadProcess(pid_t pid, unsigned char status, WDock *dock)
3275 {
3276     WAppIcon *icon;
3277     int i;
3278
3279     for (i=0; i<dock->max_icons; i++) {
3280         icon = dock->icon_array[i];
3281         if (!icon)
3282             continue;
3283
3284         if (icon->launching && icon->pid == pid) {
3285             if (!icon->relaunching) {
3286                 icon->running = 0;
3287                 icon->main_window = None;
3288             }
3289             wDockFinishLaunch(dock, icon);
3290             icon->pid = 0;
3291             if (status==111) {
3292                 char msg[PATH_MAX];
3293 #ifdef OFFIX_DND
3294                 sprintf(msg, _("Could not execute command \"%s\""),
3295                         icon->drop_launch && icon->dnd_command
3296                         ? icon->dnd_command : icon->command);
3297 #else
3298                 sprintf(msg, _("Could not execute command \"%s\""),
3299                         icon->command);
3300 #endif
3301                 wMessageDialog(dock->screen_ptr, _("Error"), msg,
3302                                _("OK"), NULL, NULL);
3303             }
3304             break;
3305         }
3306     }
3307 }
3308
3309
3310 static void
3311 toggleLowered(WDock *dock)
3312 {
3313     WAppIcon *tmp;
3314     int newlevel, i;
3315
3316     /* lower/raise Dock */
3317     if (!dock->lowered) {
3318         newlevel = WMNormalLevel;
3319         dock->lowered = 1;
3320     } else {
3321         newlevel = WMDockLevel;
3322         dock->lowered = 0;
3323     }
3324
3325     for (i=0; i<dock->max_icons; i++) {
3326         tmp = dock->icon_array[i];
3327         if (!tmp)
3328             continue;
3329
3330         ChangeStackingLevel(tmp->icon->core, newlevel);
3331         if (dock->lowered)
3332             wLowerFrame(tmp->icon->core);
3333     }
3334
3335     if (dock->type == WM_DOCK)
3336         wScreenUpdateUsableArea(dock->screen_ptr);
3337 }
3338
3339
3340 static void
3341 toggleCollapsed(WDock *dock)
3342 {
3343     if (dock->collapsed) {
3344         dock->collapsed = 0;
3345         wDockShowIcons(dock);
3346     }
3347     else {
3348         dock->collapsed = 1;
3349         wDockHideIcons(dock);
3350     }
3351 }
3352
3353
3354 static void
3355 openDockMenu(WDock *dock, WAppIcon *aicon, XEvent *event)
3356 {
3357     WScreen *scr = dock->screen_ptr;
3358     WObjDescriptor *desc;
3359     WMenuEntry *entry;
3360     WApplication *wapp = NULL;
3361     int index = 0;
3362     int x_pos;
3363     int n_selected;
3364     int appIsRunning = aicon->running && aicon->icon && aicon->icon->owner;
3365
3366     if (dock->type == WM_DOCK) {
3367         /* keep on top */
3368         entry = dock->menu->entries[index];
3369         entry->flags.indicator_on = !dock->lowered;
3370         entry->clientdata = dock;
3371     } else {
3372         /* clip options */
3373         if (scr->clip_options)
3374             updateClipOptionsMenu(scr->clip_options, dock);
3375
3376         n_selected = numberOfSelectedIcons(dock);
3377
3378         /* Rename Workspace */
3379         entry = dock->menu->entries[++index];
3380         if (aicon == scr->clip_icon) {
3381             entry->callback = renameCallback;
3382             entry->clientdata = dock;
3383             entry->flags.indicator = 0;
3384             entry->text = _("Rename Workspace");
3385         } else {
3386             entry->callback = omnipresentCallback;
3387             entry->clientdata = aicon;
3388             if (n_selected > 0) {
3389                 entry->flags.indicator = 0;
3390                 entry->text = _("Toggle Omnipresent");
3391             } else {
3392                 entry->flags.indicator = 1;
3393                 entry->flags.indicator_on = aicon->omnipresent;
3394                 entry->flags.indicator_type = MI_CHECK;
3395                 entry->text = _("Omnipresent");
3396             }
3397         }
3398
3399         /* select/unselect icon */
3400         entry = dock->menu->entries[++index];
3401         entry->clientdata = aicon;
3402         entry->flags.indicator_on = aicon->icon->selected;
3403         wMenuSetEnabled(dock->menu, index, aicon!=scr->clip_icon);
3404
3405         /* select/unselect all icons */
3406         entry = dock->menu->entries[++index];
3407         entry->clientdata = aicon;
3408         if (n_selected > 0)
3409             entry->text = _("Unselect All Icons");
3410         else
3411             entry->text = _("Select All Icons");
3412         wMenuSetEnabled(dock->menu, index, dock->icon_count > 1);
3413
3414         /* keep icon(s) */
3415         entry = dock->menu->entries[++index];
3416         entry->clientdata = aicon;
3417         if (n_selected > 1)
3418             entry->text = _("Keep Icons");
3419         else
3420             entry->text = _("Keep Icon");
3421         wMenuSetEnabled(dock->menu, index, dock->icon_count > 1);
3422
3423         /* this is the workspace submenu part */
3424         entry = dock->menu->entries[++index];
3425         if (n_selected > 1)
3426             entry->text = _("Move Icons To");
3427         else
3428             entry->text = _("Move Icon To");
3429         if (scr->clip_submenu)
3430             updateWorkspaceMenu(scr->clip_submenu, aicon);
3431         wMenuSetEnabled(dock->menu, index, !aicon->omnipresent);
3432
3433         /* remove icon(s) */
3434         entry = dock->menu->entries[++index];
3435         entry->clientdata = aicon;
3436         if (n_selected > 1)
3437             entry->text = _("Remove Icons");
3438         else
3439             entry->text = _("Remove Icon");
3440         wMenuSetEnabled(dock->menu, index, dock->icon_count > 1);
3441
3442         /* attract icon(s) */
3443         entry = dock->menu->entries[++index];
3444         entry->clientdata = aicon;
3445
3446         dock->menu->flags.realized = 0;
3447         wMenuRealize(dock->menu);
3448     }
3449
3450     /* launch */
3451     entry = dock->menu->entries[++index];
3452     entry->clientdata = aicon;
3453     wMenuSetEnabled(dock->menu, index, aicon->command!=NULL);
3454
3455     /* unhide here */
3456     entry = dock->menu->entries[++index];
3457     entry->clientdata = aicon;
3458     wMenuSetEnabled(dock->menu, index, appIsRunning);
3459
3460     /* hide */
3461     entry = dock->menu->entries[++index];
3462     entry->clientdata = aicon;
3463     if (aicon->icon->owner) {
3464         wapp = wApplicationOf(aicon->icon->owner->main_window);
3465         if (wapp && wapp->flags.hidden)
3466             entry->text = _("Unhide");
3467         else
3468             entry->text = _("Hide");
3469     } else {
3470         entry->text = _("Hide");
3471     }
3472     wMenuSetEnabled(dock->menu, index, appIsRunning);
3473
3474     /* settings */
3475     entry = dock->menu->entries[++index];
3476     entry->clientdata = aicon;
3477     wMenuSetEnabled(dock->menu, index, !aicon->editing
3478                     && !wPreferences.flags.noupdates);
3479
3480     /* kill */
3481     entry = dock->menu->entries[++index];
3482     entry->clientdata = aicon;
3483     wMenuSetEnabled(dock->menu, index, appIsRunning);
3484
3485     if (!dock->menu->flags.realized)
3486         wMenuRealize(dock->menu);
3487
3488     if (dock->type == WM_CLIP) {
3489         x_pos = event->xbutton.x_root+2;
3490     } else {
3491         x_pos = dock->on_right_side ?
3492             scr->scr_width - dock->menu->frame->core->width - 2 : 0;
3493     }
3494
3495     wMenuMapAt(dock->menu, x_pos, event->xbutton.y_root+2, False);
3496
3497     /* allow drag select */
3498     event->xany.send_event = True;
3499     desc = &dock->menu->menu->descriptor;
3500     (*desc->handle_mousedown)(desc, event);
3501 }
3502
3503
3504 static void
3505 openClipWorkspaceMenu(WScreen *scr, int x, int y)
3506 {
3507     if (!scr->clip_ws_menu) {
3508         scr->clip_ws_menu = wWorkspaceMenuMake(scr, False);
3509     }
3510     wWorkspaceMenuUpdate(scr, scr->clip_ws_menu);
3511     wMenuMapAt(scr->clip_ws_menu, x, y, False);
3512 }
3513
3514
3515 /******************************************************************/
3516 static void
3517 iconDblClick(WObjDescriptor *desc, XEvent *event)
3518 {
3519     WAppIcon *btn = desc->parent;
3520     WDock *dock = btn->dock;
3521     WApplication *wapp = NULL;
3522     int unhideHere = 0;
3523
3524 #ifdef REDUCE_APPICONS
3525     if ((btn->icon->owner && !(event->xbutton.state & ControlMask)) ||
3526         ((btn->icon->owner == NULL) && (btn->applist != NULL))) {
3527             if (btn->icon->owner == NULL)
3528                 btn->icon->owner = btn->applist->wapp->main_window_desc;
3529 #else
3530     if (btn->icon->owner && !(event->xbutton.state & ControlMask)) {
3531 #endif
3532         wapp = wApplicationOf(btn->icon->owner->main_window);
3533
3534         assert(wapp!=NULL);
3535
3536         unhideHere = (event->xbutton.state & ShiftMask);
3537
3538         /* go to the last workspace that the user worked on the app */
3539         if (wapp->last_workspace != dock->screen_ptr->current_workspace
3540             && !unhideHere) {
3541             wWorkspaceChange(dock->screen_ptr, wapp->last_workspace);
3542         }
3543
3544         wUnhideApplication(wapp, event->xbutton.button==Button2,
3545                            unhideHere);
3546
3547         if (event->xbutton.state & MOD_MASK) {
3548             wHideOtherApplications(btn->icon->owner);
3549         }
3550     } else {
3551         if (event->xbutton.button==Button1) {
3552
3553             if (event->xbutton.state & MOD_MASK) {
3554                 /* raise/lower dock */
3555                 toggleLowered(dock);
3556             } else if (btn == dock->screen_ptr->clip_icon) {
3557                 if (getClipButton(event->xbutton.x, event->xbutton.y)==CLIP_IDLE)
3558                     toggleCollapsed(dock);
3559                 else
3560                     handleClipChangeWorkspace(dock->screen_ptr, event);
3561             } else if (btn->command) {
3562                 if (!btn->launching &&
3563                     (!btn->running || (event->xbutton.state & ControlMask))) {
3564                     launchDockedApplication(btn);
3565                 }
3566             } else if (btn->xindex == 0 && btn->yindex == 0
3567                        && btn->dock->type == WM_DOCK) {
3568
3569                 wShowGNUstepPanel(dock->screen_ptr);
3570             }
3571         }
3572     }
3573 }
3574
3575
3576 static void
3577 handleDockMove(WDock *dock, WAppIcon *aicon, XEvent *event)
3578 {
3579     WScreen *scr = dock->screen_ptr;
3580     int ofs_x=event->xbutton.x, ofs_y=event->xbutton.y;
3581     int x, y;
3582     XEvent ev;
3583     int grabbed = 0, swapped = 0, done;
3584     Pixmap ghost = None;
3585     int superfluous = wPreferences.superfluous; /* we catch it to avoid problems */
3586
3587 #ifdef DEBUG
3588     puts("moving dock");
3589 #endif
3590     if (XGrabPointer(dpy, aicon->icon->core->window, True, ButtonMotionMask
3591                      |ButtonReleaseMask|ButtonPressMask, GrabModeAsync,
3592                      GrabModeAsync, None, None, CurrentTime) !=GrabSuccess) {
3593         wwarning("pointer grab failed for dock move");
3594     }
3595     y = 0;
3596     for (x=0; x<dock->max_icons; x++) {
3597         if (dock->icon_array[x]!=NULL &&
3598             dock->icon_array[x]->yindex > y)
3599             y = dock->icon_array[x]->yindex;
3600     }
3601     y++;
3602     XResizeWindow(dpy, scr->dock_shadow, ICON_SIZE, ICON_SIZE*y);
3603
3604     done = 0;
3605     while (!done) {
3606         WMMaskEvent(dpy, PointerMotionMask|ButtonReleaseMask|ButtonPressMask
3607                     |ButtonMotionMask|ExposureMask, &ev);
3608         switch (ev.type) {
3609          case Expose:
3610             WMHandleEvent(&ev);
3611             break;
3612
3613          case MotionNotify:
3614             if (!grabbed) {
3615                 if (abs(ofs_x-ev.xmotion.x)>=MOVE_THRESHOLD
3616                     || abs(ofs_y-ev.xmotion.y)>=MOVE_THRESHOLD) {
3617                     XChangeActivePointerGrab(dpy, ButtonMotionMask
3618                                             |ButtonReleaseMask|ButtonPressMask,
3619                                              wCursor[WCUR_MOVE], CurrentTime);
3620                     grabbed=1;
3621                 }
3622                 break;
3623             }
3624             if (dock->type == WM_CLIP) {
3625                 if (ev.xmotion.x_root - ofs_x < 0) {
3626                     x = 0;
3627                 } else if (ev.xmotion.x_root - ofs_x + ICON_SIZE >
3628                            scr->scr_width) {
3629                     x = scr->scr_width - ICON_SIZE;
3630                 } else {
3631                     x = ev.xmotion.x_root - ofs_x;
3632                 }
3633                 if (ev.xmotion.y_root - ofs_y < 0) {
3634                     y = 0;
3635                 } else if (ev.xmotion.y_root - ofs_y + ICON_SIZE >
3636                            scr->scr_height) {
3637                     y = scr->scr_height - ICON_SIZE;
3638                 } else {
3639                     y = ev.xmotion.y_root - ofs_y;
3640                 }
3641                 moveDock(dock, x, y);
3642             } else {
3643             /* move vertically if pointer is inside the dock*/
3644             if ((dock->on_right_side &&
3645                  ev.xmotion.x_root >= dock->x_pos - ICON_SIZE)
3646                 || (!dock->on_right_side &&
3647                     ev.xmotion.x_root <= dock->x_pos + ICON_SIZE*2)) {
3648
3649                 if (ev.xmotion.y_root - ofs_y < 0) {
3650                     y = 0;
3651                 } else if (ev.xmotion.y_root - ofs_y + ICON_SIZE >
3652                            scr->scr_height) {
3653                     y = scr->scr_height - ICON_SIZE;
3654                 } else {
3655                     y = ev.xmotion.y_root - ofs_y;
3656                 }
3657                 moveDock(dock, dock->x_pos, y);
3658             }
3659             /* move horizontally to change sides */
3660             x = ev.xmotion.x_root - ofs_x;
3661             if (!dock->on_right_side) {
3662
3663                 /* is on left */
3664
3665                 if (ev.xmotion.x_root > dock->x_pos + ICON_SIZE*2) {
3666                     XMoveWindow(dpy, scr->dock_shadow, scr->scr_width-ICON_SIZE
3667                                       -DOCK_EXTRA_SPACE-1, dock->y_pos);
3668                     if (superfluous && ghost==None) {
3669                         ghost = MakeGhostDock(dock, dock->x_pos,
3670                                               scr->scr_width-ICON_SIZE
3671                                               -DOCK_EXTRA_SPACE-1,
3672                                               dock->y_pos);
3673                         XSetWindowBackgroundPixmap(dpy, scr->dock_shadow,
3674                                                    ghost);
3675                         XClearWindow(dpy, scr->dock_shadow);
3676                     }
3677                     XMapRaised(dpy, scr->dock_shadow);
3678                     swapped = 1;
3679                 } else {
3680                     if (superfluous && ghost!=None) {
3681                         XFreePixmap(dpy, ghost);
3682                         ghost = None;
3683                     }
3684                     XUnmapWindow(dpy, scr->dock_shadow);
3685                     swapped = 0;
3686                 }
3687             } else {
3688                 /* is on right */
3689                 if (ev.xmotion.x_root < dock->x_pos - ICON_SIZE) {
3690                     XMoveWindow(dpy, scr->dock_shadow,
3691                                 DOCK_EXTRA_SPACE, dock->y_pos);
3692                     if (superfluous && ghost==None) {
3693                         ghost = MakeGhostDock(dock, dock->x_pos,
3694                                               DOCK_EXTRA_SPACE, dock->y_pos);
3695                         XSetWindowBackgroundPixmap(dpy, scr->dock_shadow,
3696                                                    ghost);
3697                         XClearWindow(dpy, scr->dock_shadow);
3698                     }
3699                     XMapRaised(dpy, scr->dock_shadow);
3700                     swapped = -1;
3701                 } else {
3702                     XUnmapWindow(dpy, scr->dock_shadow);
3703                     swapped = 0;
3704                     if (superfluous && ghost!=None) {
3705                         XFreePixmap(dpy, ghost);
3706                         ghost = None;
3707                     }
3708                 }
3709             }
3710             }
3711             break;
3712
3713          case ButtonPress:
3714             break;
3715
3716          case ButtonRelease:
3717             if (ev.xbutton.button != event->xbutton.button)
3718                 break;
3719             XUngrabPointer(dpy, CurrentTime);
3720             XUnmapWindow(dpy, scr->dock_shadow);
3721             XResizeWindow(dpy, scr->dock_shadow, ICON_SIZE, ICON_SIZE);
3722             if (dock->type == WM_DOCK) {
3723                 if (swapped!=0) {
3724                     if (swapped>0)
3725                         dock->on_right_side = 1;
3726                     else
3727                         dock->on_right_side = 0;
3728                     swapDock(dock);
3729                     wArrangeIcons(scr, False);
3730                 }
3731             }
3732             done = 1;
3733             break;
3734         }
3735     }
3736     if (superfluous) {
3737         if (ghost!=None)
3738             XFreePixmap(dpy, ghost);
3739         XSetWindowBackground(dpy, scr->dock_shadow, scr->white_pixel);
3740     }
3741 #ifdef DEBUG
3742     puts("End dock move");
3743 #endif
3744 }
3745
3746
3747
3748 static void
3749 handleIconMove(WDock *dock, WAppIcon *aicon, XEvent *event)
3750 {
3751     WScreen *scr = dock->screen_ptr;
3752     Window wins[2];
3753     WIcon *icon = aicon->icon;
3754     WDock *dock2 = NULL, *last_dock = dock, *clip = NULL;
3755     int ondock, grabbed = 0, change_dock = 0, collapsed = 0;
3756     XEvent ev;
3757     int x = aicon->x_pos, y = aicon->y_pos;
3758     int ofs_x = event->xbutton.x, ofs_y = event->xbutton.y;
3759     int shad_x = x, shad_y = y;
3760     int ix = aicon->xindex, iy = aicon->yindex;
3761     int tmp;
3762     Pixmap ghost = None;
3763     Bool docked;
3764     int superfluous = wPreferences.superfluous; /* we catch it to avoid problems */
3765     int omnipresent = aicon->omnipresent; /* this must be cached!!! */
3766
3767
3768     if (wPreferences.flags.noupdates)
3769         return;
3770
3771     if (XGrabPointer(dpy, icon->core->window, True, ButtonMotionMask
3772                      |ButtonReleaseMask|ButtonPressMask, GrabModeAsync,
3773                      GrabModeAsync, None, None, CurrentTime) !=GrabSuccess) {
3774 #ifdef DEBUG0
3775         wwarning("pointer grab failed for icon move");
3776 #endif
3777     }
3778
3779     if (!(event->xbutton.state & MOD_MASK))
3780         wRaiseFrame(icon->core);
3781
3782     if (!wPreferences.flags.noclip)
3783         clip = scr->workspaces[scr->current_workspace]->clip;
3784
3785     if (dock == scr->dock && !wPreferences.flags.noclip)
3786         dock2 = clip;
3787     else if (dock != scr->dock && !wPreferences.flags.nodock)
3788         dock2 = scr->dock;
3789
3790     wins[0] = icon->core->window;
3791     wins[1] = scr->dock_shadow;
3792     XRestackWindows(dpy, wins, 2);
3793     XMoveResizeWindow(dpy, scr->dock_shadow, aicon->x_pos, aicon->y_pos,
3794                       ICON_SIZE, ICON_SIZE);
3795     if (superfluous) {
3796         if (icon->pixmap!=None)
3797             ghost = MakeGhostIcon(scr, icon->pixmap);
3798         else
3799             ghost = MakeGhostIcon(scr, icon->core->window);
3800
3801         XSetWindowBackgroundPixmap(dpy, scr->dock_shadow, ghost);
3802         XClearWindow(dpy, scr->dock_shadow);
3803     }
3804     XMapWindow(dpy, scr->dock_shadow);
3805
3806     ondock = 1;
3807
3808
3809     while(1) {
3810         XMaskEvent(dpy, PointerMotionMask|ButtonReleaseMask|ButtonPressMask
3811                    |ButtonMotionMask|ExposureMask, &ev);
3812         switch (ev.type) {
3813          case Expose:
3814             WMHandleEvent(&ev);
3815             break;
3816
3817          case MotionNotify:
3818             if (!grabbed) {
3819                 if (abs(ofs_x-ev.xmotion.x)>=MOVE_THRESHOLD
3820                     || abs(ofs_y-ev.xmotion.y)>=MOVE_THRESHOLD) {
3821                     XChangeActivePointerGrab(dpy, ButtonMotionMask
3822                                             |ButtonReleaseMask|ButtonPressMask,
3823                                              wCursor[WCUR_MOVE], CurrentTime);
3824                     grabbed=1;
3825                 } else {
3826                     break;
3827                 }
3828             }
3829
3830             if (omnipresent) {
3831                 int i;
3832                 for (i=0; i<scr->workspace_count; i++) {
3833                     if (i == scr->current_workspace)
3834                         continue;
3835                     wDockShowIcons(scr->workspaces[i]->clip);
3836                 }
3837             }
3838
3839             x = ev.xmotion.x_root - ofs_x;
3840             y = ev.xmotion.y_root - ofs_y;
3841             tmp = wDockSnapIcon(dock, aicon, x, y, &ix, &iy, True);
3842             if (tmp && dock2) {
3843                 change_dock = 0;
3844                 if (last_dock != dock && collapsed) {
3845                     last_dock->collapsed = 1;
3846                     wDockHideIcons(last_dock);
3847                     collapsed = 0;
3848                 }
3849                 if (!collapsed && (collapsed = dock->collapsed)) {
3850                     dock->collapsed = 0;
3851                     wDockShowIcons(dock);
3852                 }
3853                 if (dock->auto_raise_lower)
3854                     wDockRaise(dock);
3855                 last_dock = dock;
3856             } else if (dock2) {
3857                 tmp = wDockSnapIcon(dock2, aicon, x, y, &ix, &iy, False);
3858                 if (tmp) {
3859                     change_dock = 1;
3860                     if (last_dock != dock2 && collapsed) {
3861                         last_dock->collapsed = 1;
3862                         wDockHideIcons(last_dock);
3863                         collapsed = 0;
3864                     }
3865                     if (!collapsed && (collapsed = dock2->collapsed)) {
3866                         dock2->collapsed = 0;
3867                         wDockShowIcons(dock2);
3868                     }
3869                     if (dock2->auto_raise_lower)
3870                         wDockRaise(dock2);
3871                     last_dock = dock2;
3872                 }
3873             }
3874             if (aicon->launching
3875                 || (aicon->running && !(ev.xmotion.state & MOD_MASK))
3876                 || (!aicon->running && tmp)) {
3877                 shad_x = last_dock->x_pos + ix*wPreferences.icon_size;
3878                 shad_y = last_dock->y_pos + iy*wPreferences.icon_size;
3879
3880                 XMoveWindow(dpy, scr->dock_shadow, shad_x, shad_y);
3881
3882                 if (!ondock) {
3883                     XMapWindow(dpy, scr->dock_shadow);
3884                 }
3885                 ondock = 1;
3886             } else {
3887                 if (ondock) {
3888                     XUnmapWindow(dpy, scr->dock_shadow);
3889                 }
3890                 ondock = 0;
3891             }
3892             XMoveWindow(dpy, icon->core->window, x, y);
3893             break;
3894
3895          case ButtonPress:
3896             break;
3897
3898          case ButtonRelease:
3899             if (ev.xbutton.button != event->xbutton.button)
3900                 break;
3901             XUngrabPointer(dpy, CurrentTime);
3902             if (ondock) {
3903                 SlideWindow(icon->core->window, x, y, shad_x, shad_y);
3904                 XUnmapWindow(dpy, scr->dock_shadow);
3905                 if (!change_dock) {
3906                     reattachIcon(dock, aicon, ix, iy);
3907                     if (clip && dock!=clip && clip->auto_raise_lower)
3908                         wDockLower(clip);
3909                 } else {
3910                     docked = moveIconBetweenDocks(dock, dock2, aicon, ix, iy);
3911                     if (!docked) {
3912                         /* Slide it back if dock rejected it */
3913                         SlideWindow(icon->core->window, x, y, aicon->x_pos,
3914                                     aicon->y_pos);
3915                         reattachIcon(dock, aicon, aicon->xindex,aicon->yindex);
3916                     }
3917                     if (last_dock->type==WM_CLIP && last_dock->auto_collapse) {
3918                         collapsed = 0;
3919                     }
3920                 }
3921             } else {
3922                 aicon->x_pos = x;
3923                 aicon->y_pos = y;
3924                 if (superfluous) {
3925                     if (!aicon->running && !wPreferences.no_animations) {
3926                         /* We need to deselect it, even if is deselected in
3927                          * wDockDetach(), because else DoKaboom() will fail.
3928                          */
3929                         if (aicon->icon->selected)
3930                             wIconSelect(aicon->icon);
3931                         DoKaboom(scr,aicon->icon->core->window, x, y);
3932                     }
3933                 }
3934                 if (clip && clip->auto_raise_lower)
3935                     wDockLower(clip);
3936                 wDockDetach(dock, aicon);
3937             }
3938             if (collapsed) {
3939                 last_dock->collapsed = 1;
3940                 wDockHideIcons(last_dock);
3941                 collapsed = 0;
3942             }
3943             if (superfluous) {
3944                 if (ghost!=None)
3945                     XFreePixmap(dpy, ghost);
3946                 XSetWindowBackground(dpy, scr->dock_shadow, scr->white_pixel);
3947             }
3948             if (omnipresent) {
3949                 int i;
3950                 for (i=0; i<scr->workspace_count; i++) {
3951                     if (i == scr->current_workspace)
3952                         continue;
3953                     wDockHideIcons(scr->workspaces[i]->clip);
3954                 }
3955             }
3956
3957 #ifdef DEBUG
3958             puts("End icon move");
3959 #endif
3960             return;
3961         }
3962     }
3963 }
3964
3965
3966 static int
3967 getClipButton(int px, int py)
3968 {
3969     int pt = (CLIP_BUTTON_SIZE+2)*ICON_SIZE/64;
3970
3971     if (px < 0 || py < 0 || px >= ICON_SIZE || py >= ICON_SIZE)
3972         return CLIP_IDLE;
3973
3974     if (py <= pt-((int)ICON_SIZE-1-px))
3975         return CLIP_FORWARD;
3976     else if (px <= pt-((int)ICON_SIZE-1-py))
3977         return CLIP_REWIND;
3978
3979     return CLIP_IDLE;
3980 }
3981
3982
3983 static void
3984 handleClipChangeWorkspace(WScreen *scr, XEvent *event)
3985 {
3986     XEvent ev;
3987     int done, direction, new_ws;
3988     int new_dir;
3989     WDock *clip = scr->clip_icon->dock;
3990
3991     direction = getClipButton(event->xbutton.x, event->xbutton.y);
3992
3993     clip->lclip_button_pushed = direction==CLIP_REWIND;
3994     clip->rclip_button_pushed = direction==CLIP_FORWARD;
3995
3996     wClipIconPaint(scr->clip_icon);
3997     done = 0;
3998     while(!done) {
3999         WMMaskEvent(dpy, ExposureMask|ButtonMotionMask|ButtonReleaseMask
4000                     |ButtonPressMask, &ev);
4001         switch (ev.type) {
4002         case Expose:
4003             WMHandleEvent(&ev);
4004             break;
4005
4006         case MotionNotify:
4007             new_dir = getClipButton(ev.xmotion.x, ev.xmotion.y);
4008             if (new_dir != direction) {
4009                 direction = new_dir;
4010                 clip->lclip_button_pushed = direction==CLIP_REWIND;
4011                 clip->rclip_button_pushed = direction==CLIP_FORWARD;
4012                 wClipIconPaint(scr->clip_icon);
4013             }
4014             break;
4015
4016         case ButtonPress:
4017             break;
4018
4019         case ButtonRelease:
4020             if (ev.xbutton.button == event->xbutton.button)
4021                 done = 1;
4022         }
4023     }
4024
4025     clip->lclip_button_pushed = 0;
4026     clip->rclip_button_pushed = 0;
4027
4028     new_ws = wPreferences.ws_advance || (event->xbutton.state & ControlMask);
4029
4030     if (direction == CLIP_FORWARD) {
4031         if (scr->current_workspace < scr->workspace_count-1)
4032             wWorkspaceChange(scr, scr->current_workspace+1);
4033         else if (new_ws && scr->current_workspace < MAX_WORKSPACES-1)
4034             wWorkspaceChange(scr, scr->current_workspace+1);
4035         else if (wPreferences.ws_cycle)
4036             wWorkspaceChange(scr, 0);
4037     }
4038     else if (direction == CLIP_REWIND) {
4039         if (scr->current_workspace > 0)
4040             wWorkspaceChange(scr, scr->current_workspace-1);
4041         else if (scr->current_workspace==0 && wPreferences.ws_cycle)
4042             wWorkspaceChange(scr, scr->workspace_count-1);
4043     }
4044
4045     wClipIconPaint(scr->clip_icon);
4046 }
4047
4048
4049 static void
4050 iconMouseDown(WObjDescriptor *desc, XEvent *event)
4051 {
4052     WAppIcon *aicon = desc->parent;
4053     WDock *dock = aicon->dock;
4054     WScreen *scr = aicon->icon->core->screen_ptr;
4055
4056     if (aicon->editing || WCHECK_STATE(WSTATE_MODAL))
4057         return;
4058
4059     scr->last_dock = dock;
4060
4061     if (dock->menu->flags.mapped)
4062         wMenuUnmap(dock->menu);
4063
4064     if (IsDoubleClick(scr, event)) {
4065         /* double-click was not in the main clip icon */
4066         if (dock->type != WM_CLIP || aicon->xindex!=0 || aicon->yindex!=0
4067             || getClipButton(event->xbutton.x, event->xbutton.y)==CLIP_IDLE) {
4068             iconDblClick(desc, event);
4069             return;
4070         }
4071     }
4072
4073     if (dock->type == WM_CLIP && scr->flags.clip_balloon_mapped) {
4074         XUnmapWindow(dpy, scr->clip_balloon);
4075         scr->flags.clip_balloon_mapped = 0;
4076     }
4077
4078 #ifdef DEBUG
4079     puts("handling dock");
4080 #endif
4081     if (event->xbutton.button == Button1) {
4082         if (event->xbutton.state & MOD_MASK)
4083             wDockLower(dock);
4084         else
4085             wDockRaise(dock);
4086
4087         if ((event->xbutton.state & ShiftMask) && aicon!=scr->clip_icon &&
4088             dock->type!=WM_DOCK) {
4089             wIconSelect(aicon->icon);
4090             return;
4091         }
4092
4093         if (aicon->yindex==0 && aicon->xindex==0) {
4094             if (getClipButton(event->xbutton.x, event->xbutton.y)!=CLIP_IDLE
4095                 && dock->type==WM_CLIP)
4096                 handleClipChangeWorkspace(scr, event);
4097             else
4098                 handleDockMove(dock, aicon, event);
4099         } else
4100             handleIconMove(dock, aicon, event);
4101
4102     } else if (event->xbutton.button==Button2 && dock->type==WM_CLIP &&
4103                aicon==scr->clip_icon) {
4104         openClipWorkspaceMenu(scr, event->xbutton.x_root+2,
4105                               event->xbutton.y_root+2);
4106         if (scr->clip_ws_menu) {
4107             WMenu *menu;
4108             menu = scr->clip_ws_menu;
4109             desc = &menu->menu->descriptor;
4110
4111             event->xany.send_event = True;
4112             (*desc->handle_mousedown)(desc, event);
4113         }
4114     } else if (event->xbutton.button==Button2 && dock->type==WM_CLIP &&
4115                (event->xbutton.state & ShiftMask) && aicon!=scr->clip_icon) {
4116         wClipMakeIconOmnipresent(aicon, !aicon->omnipresent);
4117     } else if (event->xbutton.button == Button3) {
4118         openDockMenu(dock, aicon, event);
4119     }
4120 }
4121
4122
4123 static void
4124 showClipBalloon(WDock *dock, int workspace)
4125 {
4126     int w, h;
4127     int x, y;
4128     WScreen *scr = dock->screen_ptr;
4129     char *text;
4130     Window stack[2];
4131
4132     scr->flags.clip_balloon_mapped = 1;
4133     XMapWindow(dpy, scr->clip_balloon);
4134
4135     text = scr->workspaces[workspace]->name;
4136
4137     w = WMWidthOfString(scr->clip_title_font, text, strlen(text));
4138
4139     h = WMFontHeight(scr->clip_title_font);
4140     XResizeWindow(dpy, scr->clip_balloon, w, h);
4141
4142     x = dock->x_pos + CLIP_BUTTON_SIZE*ICON_SIZE/64;
4143     y = dock->y_pos + ICON_SIZE - WMFontHeight(scr->clip_title_font) - 3;
4144
4145     if (x+w > scr->scr_width) {
4146         x = scr->scr_width - w;
4147         if (dock->y_pos + ICON_SIZE + h > scr->scr_height)
4148             y = dock->y_pos - h - 1;
4149         else
4150             y = dock->y_pos + ICON_SIZE;
4151         XRaiseWindow(dpy, scr->clip_balloon);
4152     } else {
4153         stack[0] = scr->clip_icon->icon->core->window;
4154         stack[1] = scr->clip_balloon;
4155         XRestackWindows(dpy, stack, 2);
4156     }
4157     XMoveWindow(dpy, scr->clip_balloon, x, y);
4158     XSetForeground(dpy, scr->clip_title_gc,
4159                    scr->clip_title_pixel[CLIP_NORMAL]);
4160     XClearWindow(dpy, scr->clip_balloon);
4161     WMDrawString(scr->wmscreen, scr->clip_balloon, scr->clip_title_gc,
4162                  scr->clip_title_font, 0, 0, text, strlen(text));
4163 }
4164
4165
4166 static void
4167 clipEnterNotify(WObjDescriptor *desc, XEvent *event)
4168 {
4169     WAppIcon *btn = (WAppIcon*)desc->parent;
4170     WDock *dock;
4171     WScreen *scr;
4172
4173     assert(event->type==EnterNotify);
4174
4175     if(desc->parent_type!=WCLASS_DOCK_ICON)
4176         return;
4177
4178     scr = btn->icon->core->screen_ptr;
4179     if (!btn->omnipresent)
4180         dock = btn->dock;
4181     else
4182         dock = scr->workspaces[scr->current_workspace]->clip;
4183
4184     if (!dock || dock->type!=WM_CLIP)
4185         return;
4186
4187     /* The auto raise/lower code */
4188     if (dock->auto_lower_magic) {
4189         WMDeleteTimerHandler(dock->auto_lower_magic);
4190         dock->auto_lower_magic = NULL;
4191     }
4192     if (dock->auto_raise_lower && !dock->auto_raise_magic) {
4193         dock->auto_raise_magic = WMAddTimerHandler(AUTO_RAISE_DELAY,
4194                                                    clipAutoRaise,
4195                                                    (void *)dock);
4196     }
4197
4198     /* The auto expand/collapse code */
4199     if (dock->auto_collapse_magic) {
4200         WMDeleteTimerHandler(dock->auto_collapse_magic);
4201         dock->auto_collapse_magic = NULL;
4202     }
4203     if (dock->auto_collapse && !dock->auto_expand_magic) {
4204         dock->auto_expand_magic = WMAddTimerHandler(AUTO_EXPAND_DELAY,
4205                                                     clipAutoExpand,
4206                                                     (void *)dock);
4207     }
4208
4209     if (btn->xindex == 0 && btn->yindex == 0)
4210         showClipBalloon(dock, dock->screen_ptr->current_workspace);
4211     else {
4212         if (dock->screen_ptr->flags.clip_balloon_mapped) {
4213             XUnmapWindow(dpy, dock->screen_ptr->clip_balloon);
4214             dock->screen_ptr->flags.clip_balloon_mapped = 0;
4215         }
4216     }
4217 }
4218
4219
4220 static void
4221 clipLeave(WDock *dock)
4222 {
4223     XEvent event;
4224     WObjDescriptor *desc = NULL;
4225
4226     if (!dock || dock->type!=WM_CLIP)
4227         return;
4228
4229     if (XCheckTypedEvent(dpy, EnterNotify, &event)!=False) {
4230         if (XFindContext(dpy, event.xcrossing.window, wWinContext,
4231                          (XPointer *)&desc)!=XCNOENT
4232             && desc && desc->parent_type==WCLASS_DOCK_ICON
4233             && ((WAppIcon*)desc->parent)->dock
4234             && ((WAppIcon*)desc->parent)->dock->type==WM_CLIP) {
4235             /* We didn't left the Clip yet */
4236             XPutBackEvent(dpy, &event);
4237             return;
4238         }
4239
4240         XPutBackEvent(dpy, &event);
4241     } else {
4242         /* We entered a withdrawn window, so we're still in Clip */
4243         return;
4244     }
4245
4246     if (dock->auto_raise_magic) {
4247         WMDeleteTimerHandler(dock->auto_raise_magic);
4248         dock->auto_raise_magic = NULL;
4249     }
4250     if (dock->auto_raise_lower && !dock->auto_lower_magic) {
4251         dock->auto_lower_magic = WMAddTimerHandler(AUTO_LOWER_DELAY,
4252                                                    clipAutoLower,
4253                                                    (void *)dock);
4254     }
4255
4256     if (dock->auto_expand_magic) {
4257         WMDeleteTimerHandler(dock->auto_expand_magic);
4258         dock->auto_expand_magic = NULL;
4259     }
4260     if (dock->auto_collapse && !dock->auto_collapse_magic) {
4261         dock->auto_collapse_magic = WMAddTimerHandler(AUTO_COLLAPSE_DELAY,
4262                                                       clipAutoCollapse,
4263                                                       (void *)dock);
4264     }
4265 }
4266
4267
4268 static void
4269 clipLeaveNotify(WObjDescriptor *desc, XEvent *event)
4270 {
4271     WAppIcon *btn = (WAppIcon*)desc->parent;
4272
4273     assert(event->type==LeaveNotify);
4274
4275     if(desc->parent_type!=WCLASS_DOCK_ICON)
4276         return;
4277
4278     clipLeave(btn->dock);
4279 }
4280
4281
4282 static void
4283 clipAutoCollapse(void *cdata)
4284 {
4285     WDock *dock = (WDock *)cdata;
4286
4287     if (dock->type!=WM_CLIP)
4288         return;
4289
4290     if (dock->auto_collapse) {
4291         dock->collapsed = 1;
4292         wDockHideIcons(dock);
4293     }
4294     dock->auto_collapse_magic = NULL;
4295 }
4296
4297
4298 static void
4299 clipAutoExpand(void *cdata)
4300 {
4301     WDock *dock = (WDock *)cdata;
4302
4303     if (dock->type!=WM_CLIP)
4304         return;
4305
4306     if (dock->auto_collapse) {
4307         dock->collapsed = 0;
4308         wDockShowIcons(dock);
4309     }
4310     dock->auto_expand_magic = NULL;
4311 }
4312
4313
4314 static void
4315 clipAutoLower(void *cdata)
4316 {
4317     WDock *dock = (WDock *)cdata;
4318
4319     if (dock->type!=WM_CLIP)
4320         return;
4321
4322     if (dock->auto_raise_lower)
4323         wDockLower(dock);
4324
4325     dock->auto_lower_magic = NULL;
4326 }
4327
4328
4329 static void
4330 clipAutoRaise(void *cdata)
4331 {
4332     WDock *dock = (WDock *)cdata;
4333
4334     if (dock->type!=WM_CLIP)
4335         return;
4336
4337     if (dock->auto_raise_lower)
4338         wDockRaise(dock);
4339
4340     if (dock->screen_ptr->flags.clip_balloon_mapped) {
4341         showClipBalloon(dock, dock->screen_ptr->current_workspace);
4342     }
4343
4344     dock->auto_raise_magic = NULL;
4345 }
4346
4347
4348 static Bool
4349 iconCanBeOmnipresent(WAppIcon *aicon)
4350 {
4351     WScreen *scr = aicon->icon->core->screen_ptr;
4352     WDock *clip;
4353     WAppIcon *btn;
4354     int i, j;
4355
4356     for (i=0; i<scr->workspace_count; i++) {
4357         clip = scr->workspaces[i]->clip;
4358
4359         if (clip == aicon->dock)
4360             continue;
4361
4362         if (clip->icon_count + scr->global_icon_count >= clip->max_icons)
4363             return False; /* Clip is full in some workspace */
4364
4365         for (j=0; j<clip->max_icons; j++) {
4366             btn = clip->icon_array[j];
4367             if(btn && btn->xindex==aicon->xindex && btn->yindex==aicon->yindex)
4368                 return False;
4369         }
4370     }
4371
4372     return True;
4373 }
4374
4375
4376 int
4377 wClipMakeIconOmnipresent(WAppIcon *aicon, int omnipresent)
4378 {
4379     WScreen *scr = aicon->icon->core->screen_ptr;
4380     WAppIconChain *new_entry, *tmp, *tmp1;
4381     int status = WO_SUCCESS;
4382
4383     if (aicon->dock == scr->dock || aicon == scr->clip_icon)
4384         return WO_NOT_APPLICABLE;
4385
4386     if (aicon->omnipresent == omnipresent)
4387         return WO_SUCCESS;
4388
4389     if (omnipresent) {
4390         if (iconCanBeOmnipresent(aicon)) {
4391             aicon->omnipresent = 1;
4392             new_entry = wmalloc(sizeof(WAppIconChain));
4393             new_entry->aicon = aicon;
4394             new_entry->next = NULL;
4395             if (!scr->global_icons) {
4396                 scr->global_icons = new_entry;
4397             } else {
4398                 tmp = scr->global_icons;
4399                 while (tmp->next)
4400                     tmp = tmp->next;
4401
4402                 tmp->next = new_entry;
4403             }
4404             scr->global_icon_count++;
4405         } else {
4406             aicon->omnipresent = 0;
4407             status = WO_FAILED;
4408         }
4409     } else {
4410         aicon->omnipresent = 0;
4411         if (aicon == scr->global_icons->aicon) {
4412             tmp = scr->global_icons->next;
4413             free(scr->global_icons);
4414             scr->global_icons = tmp;
4415             scr->global_icon_count--;
4416         } else {
4417             tmp = scr->global_icons;
4418             while (tmp->next) {
4419                 if (tmp->next->aicon == aicon) {
4420                     tmp1 = tmp->next->next;
4421                     free(tmp->next);
4422                     tmp->next = tmp1;
4423                     scr->global_icon_count--;
4424                     break;
4425                 }
4426                 tmp = tmp->next;
4427             }
4428         }
4429     }
4430
4431     wAppIconPaint(aicon);
4432
4433     return status;
4434 }
4435