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