?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
wmaker: Replaced local declaration of system function by proper header call
[wmaker-crm.git] / src / appicon.c
blobdbe7ae58baae683f7e42a92ba00255cd9c421cdf
1 /* appicon.c- icon for applications (not mini-window)
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 <stdlib.h>
28 #include <libgen.h>
29 #include <string.h>
30 #include <unistd.h>
31 #include <sys/stat.h>
32 #include <errno.h>
33
34 #include "WindowMaker.h"
35 #include "window.h"
36 #include "icon.h"
37 #include "application.h"
38 #include "appicon.h"
39 #include "actions.h"
40 #include "stacking.h"
41 #include "dock.h"
42 #include "main.h"
43 #include "defaults.h"
44 #include "workspace.h"
45 #include "superfluous.h"
46 #include "menu.h"
47 #include "framewin.h"
48 #include "dialog.h"
49 #include "xinerama.h"
50 #include "client.h"
51 #include "placement.h"
52 #include "misc.h"
53 #include "event.h"
54 #ifdef XDND
55 #include "xdnd.h"
56 #endif
57
58 /*
59 * icon_file for the dock is got from the preferences file by
60 * using the classname/instancename
61 */
62
63 /**** Global variables ****/
64 extern Cursor wCursor[WCUR_LAST];
65 extern WDDomain *WDWindowAttributes;
66 extern XContext wWinContext;
67
68 #define MOD_MASK wPreferences.modifier_mask
69 #define ICON_SIZE wPreferences.icon_size
70
71 void appIconMouseDown(WObjDescriptor * desc, XEvent * event);
72 static void iconDblClick(WObjDescriptor * desc, XEvent * event);
73 static void iconExpose(WObjDescriptor * desc, XEvent * event);
74 static void wApplicationSaveIconPathFor(const char *iconPath, const char *wm_instance, const char *wm_class);
75 static WAppIcon *wAppIconCreate(WWindow * leader_win);
76 static void add_to_appicon_list(WScreen *scr, WAppIcon *appicon);
77 static void remove_from_appicon_list(WScreen *scr, WAppIcon *appicon);
78 static void create_appicon_from_dock(WWindow *wwin, WApplication *wapp, Window main_window);
79
80 /* This function is used if the application is a .app. It checks if it has an icon in it
81 * like for example /usr/local/GNUstep/Applications/WPrefs.app/WPrefs.tiff
82 */
83 void wApplicationExtractDirPackIcon(WScreen * scr, const char *path, const char *wm_instance, const char *wm_class)
84 {
85 char *iconPath = NULL;
86 char *tmp = NULL;
87
88 if (strstr(path, ".app")) {
89 tmp = wmalloc(strlen(path) + 16);
90
91 if (scr->flags.supports_tiff) {
92 strcpy(tmp, path);
93 strcat(tmp, ".tiff");
94 if (access(tmp, R_OK) == 0)
95 iconPath = tmp;
96 }
97
98 if (!iconPath) {
99 strcpy(tmp, path);
100 strcat(tmp, ".xpm");
101 if (access(tmp, R_OK) == 0)
102 iconPath = tmp;
103 }
104
105 if (!iconPath)
106 wfree(tmp);
107
108 if (iconPath) {
109 wApplicationSaveIconPathFor(iconPath, wm_instance, wm_class);
110 wfree(iconPath);
111 }
112 }
113 }
114
115 WAppIcon *wAppIconCreateForDock(WScreen *scr, const char *command, const char *wm_instance, const char *wm_class, int tile)
116 {
117 WAppIcon *aicon;
118
119 aicon = wmalloc(sizeof(WAppIcon));
120 wretain(aicon);
121 aicon->yindex = -1;
122 aicon->xindex = -1;
123
124 add_to_appicon_list(scr, aicon);
125
126 if (command)
127 aicon->command = wstrdup(command);
128
129 if (wm_class)
130 aicon->wm_class = wstrdup(wm_class);
131
132 if (wm_instance)
133 aicon->wm_instance = wstrdup(wm_instance);
134
135 if (strcmp(wm_class, "WMDock") == 0 && wPreferences.flags.clip_merged_in_dock)
136 tile = TILE_CLIP;
137 aicon->icon = icon_create_for_dock(scr, command, wm_instance, wm_class, tile);
138
139 #ifdef XDND
140 wXDNDMakeAwareness(aicon->icon->core->window);
141 #endif
142
143 /* will be overriden by dock */
144 aicon->icon->core->descriptor.handle_mousedown = appIconMouseDown;
145 aicon->icon->core->descriptor.handle_expose = iconExpose;
146 aicon->icon->core->descriptor.parent_type = WCLASS_APPICON;
147 aicon->icon->core->descriptor.parent = aicon;
148 AddToStackList(aicon->icon->core);
149
150 return aicon;
151 }
152
153 void create_appicon_for_application(WApplication *wapp, WWindow *wwin)
154 {
155 /* Try to create an icon from the dock or clip */
156 create_appicon_from_dock(wwin, wapp, wapp->main_window);
157
158 /* If app_icon was not found, create it */
159 if (!wapp->app_icon) {
160 /* Create the icon */
161 wapp->app_icon = wAppIconCreate(wapp->main_window_desc);
162 wIconUpdate(wapp->app_icon->icon);
163
164 /* Now, paint the icon */
165 if (!WFLAGP(wapp->main_window_desc, no_appicon))
166 paint_app_icon(wapp);
167 }
168
169 /* Save the app_icon in a file */
170 save_appicon(wapp->app_icon, False);
171 }
172
173 void unpaint_app_icon(WApplication *wapp)
174 {
175 WAppIcon *aicon;
176 WScreen *scr;
177 WDock *clip;
178
179 if (!wapp || !wapp->app_icon)
180 return;
181
182 aicon = wapp->app_icon;
183
184 /* If the icon is docked, don't continue */
185 if (aicon->docked)
186 return;
187
188 scr = wapp->main_window_desc->screen_ptr;
189 clip = scr->workspaces[scr->current_workspace]->clip;
190
191 if (!clip || !aicon->attracted || !clip->collapsed)
192 XUnmapWindow(dpy, aicon->icon->core->window);
193
194 /* We want to avoid having it on the list because otherwise
195 * there will be a hole when the icons are arranged with
196 * wArrangeIcons() */
197 remove_from_appicon_list(scr, aicon);
198
199 if (wPreferences.auto_arrange_icons && !aicon->attracted)
200 wArrangeIcons(scr, True);
201 }
202
203 void paint_app_icon(WApplication *wapp)
204 {
205 WIcon *icon;
206 WScreen *scr = wapp->main_window_desc->screen_ptr;
207 WDock *attracting_dock;
208 int x = 0, y = 0;
209 Bool update_icon = False;
210
211 if (!wapp || !wapp->app_icon)
212 return;
213
214 icon = wapp->app_icon->icon;
215 wapp->app_icon->main_window = wapp->main_window;
216
217 /* If the icon is docked, don't continue */
218 if (wapp->app_icon->docked)
219 return;
220
221 attracting_dock = scr->attracting_drawer != NULL ?
222 scr->attracting_drawer :
223 scr->workspaces[scr->current_workspace]->clip;
224 if (attracting_dock && attracting_dock->attract_icons &&
225 wDockFindFreeSlot(attracting_dock, &x, &y)) {
226 wapp->app_icon->attracted = 1;
227 if (!icon->shadowed) {
228 icon->shadowed = 1;
229 update_icon = True;
230 }
231 wDockAttachIcon(attracting_dock, wapp->app_icon, x, y, update_icon);
232 } else {
233 /* We must know if the icon is painted in the screen,
234 * because if painted, then PlaceIcon will return the next
235 * space on the screen, and the icon will move */
236 if (wapp->app_icon->next == NULL && wapp->app_icon->prev == NULL) {
237 PlaceIcon(scr, &x, &y, wGetHeadForWindow(wapp->main_window_desc));
238 wAppIconMove(wapp->app_icon, x, y);
239 wLowerFrame(icon->core);
240 }
241 }
242
243 /* If we want appicon (no_appicon is not set) and the icon is not
244 * in the appicon_list, we must add it. Else, we want to avoid
245 * having it on the list */
246 if (!WFLAGP(wapp->main_window_desc, no_appicon) &&
247 wapp->app_icon->next == NULL && wapp->app_icon->prev == NULL)
248 add_to_appicon_list(scr, wapp->app_icon);
249
250 if (!attracting_dock || !wapp->app_icon->attracted || !attracting_dock->collapsed)
251 XMapWindow(dpy, icon->core->window);
252
253 if (wPreferences.auto_arrange_icons && !wapp->app_icon->attracted)
254 wArrangeIcons(scr, True);
255 }
256
257 void removeAppIconFor(WApplication *wapp)
258 {
259 if (!wapp->app_icon)
260 return;
261
262 if (wPreferences.highlight_active_app)
263 wIconSetHighlited(wapp->app_icon->icon, False);
264 if (wapp->app_icon->docked && !wapp->app_icon->attracted) {
265 wapp->app_icon->running = 0;
266 /* since we keep it, we don't care if it was attracted or not */
267 wapp->app_icon->attracted = 0;
268 wapp->app_icon->icon->shadowed = 0;
269 wapp->app_icon->main_window = None;
270 wapp->app_icon->pid = 0;
271 wapp->app_icon->icon->owner = NULL;
272 wapp->app_icon->icon->icon_win = None;
273
274 /* Set the icon image */
275 set_icon_image_from_database(wapp->app_icon->icon, wapp->app_icon->wm_instance,
276 wapp->app_icon->wm_class, wapp->app_icon->command);
277
278 /* Update the icon, because wapp->app_icon->icon could be NULL */
279 wIconUpdate(wapp->app_icon->icon);
280
281 /* Paint it */
282 wAppIconPaint(wapp->app_icon);
283 } else if (wapp->app_icon->docked) {
284 wapp->app_icon->running = 0;
285 if (wapp->app_icon->dock->type == WM_DRAWER) {
286 wDrawerFillTheGap(wapp->app_icon->dock, wapp->app_icon, True);
287 }
288 wDockDetach(wapp->app_icon->dock, wapp->app_icon);
289 } else {
290 wAppIconDestroy(wapp->app_icon);
291 }
292
293 wapp->app_icon = NULL;
294
295 if (wPreferences.auto_arrange_icons)
296 wArrangeIcons(wapp->main_window_desc->screen_ptr, True);
297 }
298
299 static WAppIcon *wAppIconCreate(WWindow *leader_win)
300 {
301 WAppIcon *aicon;
302
303 aicon = wmalloc(sizeof(WAppIcon));
304 wretain(aicon);
305 aicon->yindex = -1;
306 aicon->xindex = -1;
307 aicon->prev = NULL;
308 aicon->next = NULL;
309
310 if (leader_win->wm_class)
311 aicon->wm_class = wstrdup(leader_win->wm_class);
312
313 if (leader_win->wm_instance)
314 aicon->wm_instance = wstrdup(leader_win->wm_instance);
315
316 aicon->icon = icon_create_for_wwindow(leader_win);
317 #ifdef XDND
318 wXDNDMakeAwareness(aicon->icon->core->window);
319 #endif
320
321 /* will be overriden if docked */
322 aicon->icon->core->descriptor.handle_mousedown = appIconMouseDown;
323 aicon->icon->core->descriptor.handle_expose = iconExpose;
324 aicon->icon->core->descriptor.parent_type = WCLASS_APPICON;
325 aicon->icon->core->descriptor.parent = aicon;
326 AddToStackList(aicon->icon->core);
327 aicon->icon->show_title = 0;
328
329 return aicon;
330 }
331
332 void wAppIconDestroy(WAppIcon * aicon)
333 {
334 WScreen *scr = aicon->icon->core->screen_ptr;
335
336 RemoveFromStackList(aicon->icon->core);
337 wIconDestroy(aicon->icon);
338 if (aicon->command)
339 wfree(aicon->command);
340 #ifdef XDND
341 if (aicon->dnd_command)
342 wfree(aicon->dnd_command);
343 #endif
344 if (aicon->wm_instance)
345 wfree(aicon->wm_instance);
346
347 if (aicon->wm_class)
348 wfree(aicon->wm_class);
349
350 remove_from_appicon_list(scr, aicon);
351
352 aicon->destroyed = 1;
353 wrelease(aicon);
354 }
355
356 static void drawCorner(WIcon * icon)
357 {
358 WScreen *scr = icon->core->screen_ptr;
359 XPoint points[3];
360
361 points[0].x = 1;
362 points[0].y = 1;
363 points[1].x = 12;
364 points[1].y = 1;
365 points[2].x = 1;
366 points[2].y = 12;
367 XFillPolygon(dpy, icon->core->window, scr->icon_title_texture->normal_gc,
368 points, 3, Convex, CoordModeOrigin);
369 XDrawLine(dpy, icon->core->window, scr->icon_title_texture->light_gc, 0, 0, 0, 12);
370 XDrawLine(dpy, icon->core->window, scr->icon_title_texture->light_gc, 0, 0, 12, 0);
371 }
372
373 void wAppIconMove(WAppIcon * aicon, int x, int y)
374 {
375 XMoveWindow(dpy, aicon->icon->core->window, x, y);
376 aicon->x_pos = x;
377 aicon->y_pos = y;
378 }
379
380 #ifdef WS_INDICATOR
381 static void updateDockNumbers(WScreen * scr)
382 {
383 int length;
384 char *ws_numbers;
385 WAppIcon *dicon = scr->dock->icon_array[0];
386
387 ws_numbers = wmalloc(20);
388 snprintf(ws_numbers, 20, "%i [ %i ]", scr->current_workspace + 1, ((scr->current_workspace / 10) + 1));
389 length = strlen(ws_numbers);
390
391 XClearArea(dpy, dicon->icon->core->window, 2, 2, 50, WMFontHeight(scr->icon_title_font) + 1, False);
392
393 WMDrawString(scr->wmscreen, dicon->icon->core->window, scr->black,
394 scr->icon_title_font, 4, 3, ws_numbers, length);
395
396 WMDrawString(scr->wmscreen, dicon->icon->core->window, scr->white,
397 scr->icon_title_font, 3, 2, ws_numbers, length);
398
399 wfree(ws_numbers);
400 }
401 #endif /* WS_INDICATOR */
402
403 void wAppIconPaint(WAppIcon *aicon)
404 {
405 WApplication *wapp;
406 WScreen *scr = aicon->icon->core->screen_ptr;
407
408 if (aicon->icon->owner)
409 wapp = wApplicationOf(aicon->icon->owner->main_window);
410 else
411 wapp = NULL;
412
413 wIconPaint(aicon->icon);
414
415 # ifdef WS_INDICATOR
416 if (aicon->docked && scr->dock && scr->dock == aicon->dock && aicon->yindex == 0)
417 updateDockNumbers(scr);
418 # endif
419 if (scr->dock_dots && aicon->docked && !aicon->running && aicon->command != NULL) {
420 XSetClipMask(dpy, scr->copy_gc, scr->dock_dots->mask);
421 XSetClipOrigin(dpy, scr->copy_gc, 0, 0);
422 XCopyArea(dpy, scr->dock_dots->image, aicon->icon->core->window,
423 scr->copy_gc, 0, 0, scr->dock_dots->width, scr->dock_dots->height, 0, 0);
424 }
425 #ifdef HIDDENDOT
426 if (wapp && wapp->flags.hidden) {
427 XSetClipMask(dpy, scr->copy_gc, scr->dock_dots->mask);
428 XSetClipOrigin(dpy, scr->copy_gc, 0, 0);
429 XCopyArea(dpy, scr->dock_dots->image,
430 aicon->icon->core->window, scr->copy_gc, 0, 0, 7, scr->dock_dots->height, 0, 0);
431 }
432 #endif /* HIDDENDOT */
433
434 if (aicon->omnipresent)
435 drawCorner(aicon->icon);
436
437 XSetClipMask(dpy, scr->copy_gc, None);
438 if (aicon->launching)
439 XFillRectangle(dpy, aicon->icon->core->window, scr->stipple_gc,
440 0, 0, wPreferences.icon_size, wPreferences.icon_size);
441 }
442
443 /* Save the application icon, if it's a dockapp then use it with dock = True */
444 void save_appicon(WAppIcon *aicon, Bool dock)
445 {
446 char *path;
447
448 if (!aicon)
449 return;
450
451 if (dock && (!aicon->docked || aicon->attracted))
452 return;
453
454 path = wIconStore(aicon->icon);
455 if (!path)
456 return;
457
458 wApplicationSaveIconPathFor(path, aicon->wm_instance, aicon->wm_class);
459 wfree(path);
460 }
461
462 #define canBeDocked(wwin) ((wwin) && ((wwin)->wm_class||(wwin)->wm_instance))
463
464 /* main_window may not have the full command line; try to find one which does */
465 static void relaunchApplication(WApplication *wapp)
466 {
467 WScreen *scr;
468 WWindow *wlist, *next;
469
470 scr = wapp->main_window_desc->screen_ptr;
471 wlist = scr->focused_window;
472 if (! wlist)
473 return;
474
475 while (wlist->prev)
476 wlist = wlist->prev;
477
478 while (wlist) {
479 next = wlist->next;
480
481 if (wlist->main_window == wapp->main_window) {
482 if (RelaunchWindow(wlist))
483 return;
484 }
485
486 wlist = next;
487 }
488 }
489
490 static void relaunchCallback(WMenu * menu, WMenuEntry * entry)
491 {
492 WApplication *wapp = (WApplication *) entry->clientdata;
493
494 relaunchApplication(wapp);
495 }
496
497 static void hideCallback(WMenu * menu, WMenuEntry * entry)
498 {
499 WApplication *wapp = (WApplication *) entry->clientdata;
500
501 if (wapp->flags.hidden) {
502 wWorkspaceChange(menu->menu->screen_ptr, wapp->last_workspace);
503 wUnhideApplication(wapp, False, False);
504 } else {
505 wHideApplication(wapp);
506 }
507 }
508
509 static void unhideHereCallback(WMenu * menu, WMenuEntry * entry)
510 {
511 WApplication *wapp = (WApplication *) entry->clientdata;
512
513 wUnhideApplication(wapp, False, True);
514 }
515
516 static void setIconCallback(WMenu *menu, WMenuEntry *entry)
517 {
518 WAppIcon *icon = ((WApplication *) entry->clientdata)->app_icon;
519 char *file = NULL;
520 WScreen *scr;
521 int result;
522
523 assert(icon != NULL);
524
525 if (icon->editing)
526 return;
527
528 icon->editing = 1;
529 scr = icon->icon->core->screen_ptr;
530
531 wretain(icon);
532
533 result = wIconChooserDialog(scr, &file, icon->wm_instance, icon->wm_class);
534
535 if (result && !icon->destroyed) {
536 if (file && *file == 0) {
537 wfree(file);
538 file = NULL;
539 }
540 if (!wIconChangeImageFile(icon->icon, file)) {
541 wMessageDialog(scr, _("Error"),
542 _("Could not open specified icon file"), _("OK"), NULL, NULL);
543 } else {
544 wDefaultChangeIcon(scr, icon->wm_instance, icon->wm_class, file);
545 wAppIconPaint(icon);
546 }
547 if (file)
548 wfree(file);
549 }
550 icon->editing = 0;
551 wrelease(icon);
552 }
553
554 static void killCallback(WMenu * menu, WMenuEntry * entry)
555 {
556 WApplication *wapp = (WApplication *) entry->clientdata;
557 WFakeGroupLeader *fPtr;
558 char *buffer;
559 char *shortname;
560
561 if (!WCHECK_STATE(WSTATE_NORMAL))
562 return;
563
564 WCHANGE_STATE(WSTATE_MODAL);
565
566 assert(entry->clientdata != NULL);
567
568 shortname = basename(wapp->app_icon->wm_instance);
569
570 buffer = wstrconcat(wapp->app_icon ? shortname : NULL,
571 _(" will be forcibly closed.\n"
572 "Any unsaved changes will be lost.\n" "Please confirm."));
573
574 fPtr = wapp->main_window_desc->fake_group;
575
576 wretain(wapp->main_window_desc);
577 if (wPreferences.dont_confirm_kill
578 || wMessageDialog(menu->frame->screen_ptr, _("Kill Application"),
579 buffer, _("Yes"), _("No"), NULL) == WAPRDefault) {
580 if (fPtr != NULL) {
581 WWindow *wwin, *twin;
582
583 wwin = wapp->main_window_desc->screen_ptr->focused_window;
584 while (wwin) {
585 twin = wwin->prev;
586 if (wwin->fake_group == fPtr)
587 wClientKill(wwin);
588 wwin = twin;
589 }
590 } else if (!wapp->main_window_desc->flags.destroyed) {
591 wClientKill(wapp->main_window_desc);
592 }
593 }
594 wrelease(wapp->main_window_desc);
595 wfree(buffer);
596 WCHANGE_STATE(WSTATE_NORMAL);
597 }
598
599 static WMenu *createApplicationMenu(WScreen *scr)
600 {
601 WMenu *menu;
602
603 menu = wMenuCreate(scr, NULL, False);
604 wMenuAddCallback(menu, _("Unhide Here"), unhideHereCallback, NULL);
605 wMenuAddCallback(menu, _("Hide"), hideCallback, NULL);
606 wMenuAddCallback(menu, _("Launch"), relaunchCallback, NULL);
607 wMenuAddCallback(menu, _("Set Icon..."), setIconCallback, NULL);
608 wMenuAddCallback(menu, _("Kill"), killCallback, NULL);
609
610 return menu;
611 }
612
613 static void openApplicationMenu(WApplication * wapp, int x, int y)
614 {
615 WMenu *menu;
616 WScreen *scr = wapp->main_window_desc->screen_ptr;
617 int i;
618
619 if (!scr->icon_menu) {
620 scr->icon_menu = createApplicationMenu(scr);
621 wfree(scr->icon_menu->entries[1]->text);
622 }
623
624 menu = scr->icon_menu;
625
626 if (wapp->flags.hidden)
627 menu->entries[1]->text = _("Unhide");
628 else
629 menu->entries[1]->text = _("Hide");
630
631 menu->flags.realized = 0;
632 wMenuRealize(menu);
633
634 x -= menu->frame->core->width / 2;
635 if (x + menu->frame->core->width > scr->scr_width)
636 x = scr->scr_width - menu->frame->core->width;
637
638 if (x < 0)
639 x = 0;
640
641 /* set client data */
642 for (i = 0; i < menu->entry_no; i++)
643 menu->entries[i]->clientdata = wapp;
644
645 wMenuMapAt(menu, x, y, False);
646 }
647
648 /******************************************************************/
649
650 static void iconExpose(WObjDescriptor *desc, XEvent *event)
651 {
652 wAppIconPaint(desc->parent);
653 }
654
655 static void iconDblClick(WObjDescriptor *desc, XEvent *event)
656 {
657 WAppIcon *aicon = desc->parent;
658 WApplication *wapp;
659 WScreen *scr = aicon->icon->core->screen_ptr;
660 int unhideHere;
661
662 assert(aicon->icon->owner != NULL);
663
664 wapp = wApplicationOf(aicon->icon->owner->main_window);
665
666 if (event->xbutton.state & ControlMask) {
667 relaunchApplication(wapp);
668 return;
669 }
670
671 unhideHere = (event->xbutton.state & ShiftMask);
672 /* go to the last workspace that the user worked on the app */
673 if (!unhideHere && wapp->last_workspace != scr->current_workspace)
674 wWorkspaceChange(scr, wapp->last_workspace);
675
676 wUnhideApplication(wapp, event->xbutton.button == Button2, unhideHere);
677
678 if (event->xbutton.state & MOD_MASK)
679 wHideOtherApplications(aicon->icon->owner);
680 }
681
682 void appIconMouseDown(WObjDescriptor * desc, XEvent * event)
683 {
684 WAppIcon *aicon = desc->parent;
685 WScreen *scr = aicon->icon->core->screen_ptr;
686 Bool hasMoved;
687
688 if (aicon->editing || WCHECK_STATE(WSTATE_MODAL))
689 return;
690
691 if (IsDoubleClick(scr, event)) {
692 /* Middle or right mouse actions were handled on first click */
693 if (event->xbutton.button == Button1)
694 iconDblClick(desc, event);
695 return;
696 }
697
698 if (event->xbutton.button == Button2) {
699 WApplication *wapp = wApplicationOf(aicon->icon->owner->main_window);
700
701 if (wapp)
702 relaunchApplication(wapp);
703
704 return;
705 }
706
707 if (event->xbutton.button == Button3) {
708 WObjDescriptor *desc;
709 WApplication *wapp = wApplicationOf(aicon->icon->owner->main_window);
710
711 if (!wapp)
712 return;
713
714 if (event->xbutton.send_event &&
715 XGrabPointer(dpy, aicon->icon->core->window, True, ButtonMotionMask
716 | ButtonReleaseMask | ButtonPressMask, GrabModeAsync,
717 GrabModeAsync, None, None, CurrentTime) != GrabSuccess) {
718 wwarning("pointer grab failed for appicon menu");
719 return;
720 }
721
722 openApplicationMenu(wapp, event->xbutton.x_root, event->xbutton.y_root);
723
724 /* allow drag select of menu */
725 desc = &scr->icon_menu->menu->descriptor;
726 event->xbutton.send_event = True;
727 (*desc->handle_mousedown) (desc, event);
728 return;
729 }
730
731 hasMoved = wHandleAppIconMove(aicon, event);
732 if (wPreferences.single_click && !hasMoved && aicon->dock != NULL)
733 {
734 iconDblClick(desc, event);
735 }
736 }
737
738 Bool wHandleAppIconMove(WAppIcon *aicon, XEvent *event)
739 {
740 WIcon *icon = aicon->icon;
741 WScreen *scr = icon->core->screen_ptr;
742 WDock *originalDock = aicon->dock; /* can be NULL */
743 WDock *lastDock = originalDock;
744 WDock *allDocks[scr->drawer_count + 2]; /* clip, dock and drawers (order determined at runtime) */
745 WDrawerChain *dc;
746 Bool done = False, dockable, ondock;
747 Bool grabbed = False;
748 Bool collapsed = False; /* Stores the collapsed state of lastDock, before the moving appicon entered it */
749 int superfluous = wPreferences.superfluous; /* we cache it to avoid problems */
750 int omnipresent = aicon->omnipresent; /* this must be cached */
751 Bool showed_all_clips = False;
752
753 int clickButton = event->xbutton.button;
754 Pixmap ghost = None;
755 Window wins[2]; /* Managing shadow window */
756 XEvent ev;
757
758 int x = aicon->x_pos, y = aicon->y_pos;
759 int ofs_x = event->xbutton.x, ofs_y = event->xbutton.y;
760 int shad_x = x, shad_y = y;
761 int ix = aicon->xindex, iy = aicon->yindex;
762 int i;
763 int oldX = x;
764 int oldY = y;
765 Bool hasMoved = False;
766
767 if (wPreferences.flags.noupdates && originalDock != NULL)
768 return False;
769
770 if (!(event->xbutton.state & MOD_MASK))
771 wRaiseFrame(icon->core);
772 else {
773 /* If Mod is pressed for an docked appicon, assume it is to undock it,
774 * so don't lower it */
775 if (originalDock == NULL)
776 wLowerFrame(icon->core);
777 }
778
779 if (XGrabPointer(dpy, icon->core->window, True, ButtonMotionMask
780 | ButtonReleaseMask | ButtonPressMask, GrabModeAsync,
781 GrabModeAsync, None, None, CurrentTime) != GrabSuccess) {
782 wwarning("Pointer grab failed in wHandleAppIconMove");
783 }
784
785 if (originalDock != NULL) {
786 dockable = True;
787 ondock = True;
788 }
789 else {
790 ondock = False;
791 if (wPreferences.flags.nodock && wPreferences.flags.noclip && wPreferences.flags.nodrawer)
792 dockable = 0;
793 else
794 dockable = canBeDocked(icon->owner);
795 }
796
797 /* We try the various docks in that order:
798 * - First, the dock the appicon comes from, if any
799 * - Then, the drawers
800 * - Then, the "dock" (WM_DOCK)
801 * - Finally, the clip
802 */
803 i = 0;
804 if (originalDock != NULL)
805 allDocks[ i++ ] = originalDock;
806 /* Testing scr->drawers is enough, no need to test wPreferences.flags.nodrawer */
807 for (dc = scr->drawers; dc != NULL; dc = dc->next) {
808 if (dc->adrawer != originalDock)
809 allDocks[ i++ ] = dc->adrawer;
810 }
811 if (!wPreferences.flags.nodock && scr->dock != originalDock)
812 allDocks[ i++ ] = scr->dock;
813 if (!wPreferences.flags.noclip &&
814 originalDock != scr->workspaces[scr->current_workspace]->clip)
815 allDocks[ i++ ] = scr->workspaces[scr->current_workspace]->clip;
816 for ( ; i < scr->drawer_count + 2; i++) /* In case the clip, the dock, or both, are disabled */
817 allDocks[ i ] = NULL;
818
819 wins[0] = icon->core->window;
820 wins[1] = scr->dock_shadow;
821 XRestackWindows(dpy, wins, 2);
822 XMoveResizeWindow(dpy, scr->dock_shadow, aicon->x_pos, aicon->y_pos, ICON_SIZE, ICON_SIZE);
823 if (superfluous) {
824 if (icon->pixmap != None)
825 ghost = MakeGhostIcon(scr, icon->pixmap);
826 else
827 ghost = MakeGhostIcon(scr, icon->core->window);
828 XSetWindowBackgroundPixmap(dpy, scr->dock_shadow, ghost);
829 XClearWindow(dpy, scr->dock_shadow);
830 }
831 if (ondock)
832 XMapWindow(dpy, scr->dock_shadow);
833
834 while (!done) {
835 WMMaskEvent(dpy, PointerMotionMask | ButtonReleaseMask | ButtonPressMask
836 | ButtonMotionMask | ExposureMask | EnterWindowMask, &ev);
837 switch (ev.type) {
838 case Expose:
839 WMHandleEvent(&ev);
840 break;
841
842 case EnterNotify:
843 /* It means the cursor moved so fast that it entered
844 * something else (if moving slowly, it would have
845 * stayed in the appIcon that is being moved. Ignore
846 * such "spurious" EnterNotifiy's */
847 break;
848
849 case MotionNotify:
850 hasMoved = True;
851 if (!grabbed) {
852 if (abs(ofs_x - ev.xmotion.x) >= MOVE_THRESHOLD
853 || abs(ofs_y - ev.xmotion.y) >= MOVE_THRESHOLD) {
854 XChangeActivePointerGrab(dpy, ButtonMotionMask
855 | ButtonReleaseMask | ButtonPressMask,
856 wCursor[WCUR_MOVE], CurrentTime);
857 grabbed = 1;
858 } else {
859 break;
860 }
861 }
862
863 if (omnipresent && !showed_all_clips) {
864 int i;
865 for (i = 0; i < scr->workspace_count; i++) {
866 if (i == scr->current_workspace)
867 continue;
868 wDockShowIcons(scr->workspaces[i]->clip);
869 /* Note: if dock is collapsed (for instance, because it
870 auto-collapses), its icons still won't show up */
871 }
872 showed_all_clips = True; /* To prevent flickering */
873 }
874
875 x = ev.xmotion.x_root - ofs_x;
876 y = ev.xmotion.y_root - ofs_y;
877 wAppIconMove(aicon, x, y);
878
879 WDock *theNewDock = NULL;
880 if (!(ev.xmotion.state & MOD_MASK) || aicon->launching || aicon->lock) {
881 for (i = 0; dockable && i < scr->drawer_count + 2; i++) {
882 WDock *theDock = allDocks[i];
883 if (theDock == NULL)
884 break;
885 if (wDockSnapIcon(theDock, aicon, x, y, &ix, &iy, (theDock == originalDock))) {
886 theNewDock = theDock;
887 break;
888 }
889 }
890 if (originalDock != NULL && theNewDock == NULL &&
891 (aicon->launching || aicon->lock || aicon->running)) {
892 /* In those cases, stay in lastDock if no dock really wants us */
893 theNewDock = lastDock;
894 }
895 }
896 if (lastDock != NULL && lastDock != theNewDock) {
897 /* Leave lastDock in the state we found it */
898 if (lastDock->type == WM_DRAWER) {
899 wDrawerFillTheGap(lastDock, aicon, (lastDock == originalDock));
900 }
901 if (collapsed) {
902 lastDock->collapsed = 1;
903 wDockHideIcons(lastDock);
904 collapsed = False;
905 }
906 if (lastDock->auto_raise_lower) {
907 wDockLower(lastDock);
908 }
909 }
910 if (theNewDock != NULL) {
911 if (lastDock != theNewDock) {
912 collapsed = theNewDock->collapsed;
913 if (collapsed) {
914 theNewDock->collapsed = 0;
915 wDockShowIcons(theNewDock);
916 }
917 if (theNewDock->auto_raise_lower) {
918 wDockRaise(theNewDock);
919 /* And raise the moving tile above it */
920 wRaiseFrame(aicon->icon->core);
921 }
922 lastDock = theNewDock;
923 }
924
925 shad_x = lastDock->x_pos + ix*wPreferences.icon_size;
926 shad_y = lastDock->y_pos + iy*wPreferences.icon_size;
927
928 XMoveWindow(dpy, scr->dock_shadow, shad_x, shad_y);
929
930 if (!ondock) {
931 XMapWindow(dpy, scr->dock_shadow);
932 }
933 ondock = 1;
934 } else {
935 lastDock = theNewDock; // i.e., NULL
936 if (ondock) {
937 XUnmapWindow(dpy, scr->dock_shadow);
938 /*
939 * Leaving that weird comment for now.
940 * But if we see no gap, there is no need to fill one!
941 * We could test ondock first and the lastDock to NULL afterwards
942 if (lastDock_before_it_was_null->type == WM_DRAWER) {
943 wDrawerFillTheGap(lastDock, aicon, (lastDock == originalDock));
944 } */
945
946 }
947 ondock = 0;
948 }
949 break;
950
951 case ButtonPress:
952 break;
953
954 case ButtonRelease:
955 if (ev.xbutton.button != clickButton)
956 break;
957 XUngrabPointer(dpy, CurrentTime);
958
959 Bool docked = False;
960 if (ondock) {
961 SlideWindow(icon->core->window, x, y, shad_x, shad_y);
962 XUnmapWindow(dpy, scr->dock_shadow);
963 if (originalDock == NULL) { // docking an undocked appicon
964 docked = wDockAttachIcon(lastDock, aicon, ix, iy, False);
965 if (!docked) {
966 /* AppIcon got rejected (happens only when we can't get the
967 command for that appicon, and the user cancels the
968 wInputDialog asking for one). Make the rejection obvious by
969 sliding the icon to its old position */
970 if (lastDock->type == WM_DRAWER) {
971 // Also fill the gap left in the drawer
972 wDrawerFillTheGap(lastDock, aicon, False);
973 }
974 SlideWindow(icon->core->window, x, y, oldX, oldY);
975 }
976 }
977 else { // moving a docked appicon to a dock
978 if (originalDock == lastDock) {
979 docked = True;
980 wDockReattachIcon(originalDock, aicon, ix, iy);
981 }
982 else {
983 docked = wDockMoveIconBetweenDocks(originalDock, lastDock, aicon, ix, iy);
984 if (!docked) {
985 /* Possible scenario: user moved an auto-attracted appicon
986 from the clip to the dock, and cancelled the wInputDialog
987 asking for a command */
988 if (lastDock->type == WM_DRAWER) {
989 wDrawerFillTheGap(lastDock, aicon, False);
990 }
991 /* If aicon comes from a drawer, make some room to reattach it */
992 if (originalDock->type == WM_DRAWER) {
993 WAppIcon *aiconsToShift[ originalDock->icon_count ];
994 int j = 0;
995
996 for (i = 0; i < originalDock->max_icons; i++) {
997 WAppIcon *ai = originalDock->icon_array[ i ];
998 if (ai && ai != aicon &&
999 abs(ai->xindex) >= abs(aicon->xindex))
1000 aiconsToShift[j++] = ai;
1001 }
1002 if (j != originalDock->icon_count - abs(aicon->xindex) - 1)
1003 // Trust this never happens?
1004 wwarning("Shifting j=%d appicons (instead of %d!) to reinsert aicon at index %d.",
1005 j, originalDock->icon_count - abs(aicon->xindex) - 1, aicon->xindex);
1006 wSlideAppicons(aiconsToShift, j, originalDock->on_right_side);
1007 // Trust the appicon is inserted at exactly the same place, so its oldX/oldY are consistent with its "new" location?
1008 }
1009
1010 SlideWindow(icon->core->window, x, y, oldX, oldY);
1011 wDockReattachIcon(originalDock, aicon, aicon->xindex, aicon->yindex);
1012 }
1013 else {
1014 if (originalDock->auto_collapse && !originalDock->collapsed) {
1015 originalDock->collapsed = 1;
1016 wDockHideIcons(originalDock);
1017 }
1018 if (originalDock->auto_raise_lower)
1019 wDockLower(originalDock);
1020 }
1021 }
1022 }
1023 // No matter what happened above, check to lower lastDock
1024 // Don't see why I commented out the following 2 lines
1025 /* if (lastDock->auto_raise_lower)
1026 wDockLower(lastDock); */
1027 /* If docked (or tried to dock) to a auto_collapsing dock, unset
1028 * collapsed, so that wHandleAppIconMove doesn't collapse it
1029 * right away (the timer will take care of it) */
1030 if (lastDock->auto_collapse)
1031 collapsed = 0;
1032 }
1033 else {
1034 if (originalDock != NULL) { /* Detaching a docked appicon */
1035 if (superfluous) {
1036 if (!aicon->running && !wPreferences.no_animations) {
1037 /* We need to deselect it, even if is deselected in
1038 * wDockDetach(), because else DoKaboom() will fail.
1039 */
1040 if (aicon->icon->selected)
1041 wIconSelect(aicon->icon);
1042 DoKaboom(scr, aicon->icon->core->window, x, y);
1043 }
1044 }
1045 wDockDetach(originalDock, aicon);
1046 if (originalDock->auto_collapse && !originalDock->collapsed) {
1047 originalDock->collapsed = 1;
1048 wDockHideIcons(originalDock);
1049 }
1050 if (originalDock->auto_raise_lower)
1051 wDockLower(originalDock);
1052 }
1053 }
1054 // Can't remember why the icon hiding is better done above than below (commented out)
1055 // Also, lastDock is quite different from originalDock
1056 /*
1057 if (collapsed) {
1058 lastDock->collapsed = 1;
1059 wDockHideIcons(lastDock);
1060 collapsed = 0;
1061 }
1062 */
1063 if (superfluous) {
1064 if (ghost != None)
1065 XFreePixmap(dpy, ghost);
1066 XSetWindowBackground(dpy, scr->dock_shadow, scr->white_pixel);
1067 }
1068 if (showed_all_clips) {
1069 int i;
1070 for (i = 0; i < scr->workspace_count; i++) {
1071 if (i == scr->current_workspace)
1072 continue;
1073 wDockHideIcons(scr->workspaces[i]->clip);
1074 }
1075 }
1076 if (wPreferences.auto_arrange_icons && !(originalDock != NULL && docked))
1077 /* Need to rearrange unless moving from dock to dock */
1078 wArrangeIcons(scr, True);
1079 return hasMoved;
1080 }
1081 }
1082 return False; /* Never reached */
1083 }
1084
1085 /* This function save the application icon and store the path in the Dictionary */
1086 static void wApplicationSaveIconPathFor(const char *iconPath, const char *wm_instance, const char *wm_class)
1087 {
1088 WMPropList *dict = WDWindowAttributes->dictionary;
1089 WMPropList *adict, *key, *iconk;
1090 WMPropList *val;
1091 char *tmp;
1092
1093 tmp = get_name_for_instance_class(wm_instance, wm_class);
1094 key = WMCreatePLString(tmp);
1095 wfree(tmp);
1096
1097 adict = WMGetFromPLDictionary(dict, key);
1098 iconk = WMCreatePLString("Icon");
1099
1100 if (adict) {
1101 val = WMGetFromPLDictionary(adict, iconk);
1102 } else {
1103 /* no dictionary for app, so create one */
1104 adict = WMCreatePLDictionary(NULL, NULL);
1105 WMPutInPLDictionary(dict, key, adict);
1106 WMReleasePropList(adict);
1107 val = NULL;
1108 }
1109
1110 if (!val) {
1111 val = WMCreatePLString(iconPath);
1112 WMPutInPLDictionary(adict, iconk, val);
1113 WMReleasePropList(val);
1114 } else {
1115 val = NULL;
1116 }
1117
1118 WMReleasePropList(key);
1119 WMReleasePropList(iconk);
1120
1121 if (val && !wPreferences.flags.noupdates)
1122 UpdateDomainFile(WDWindowAttributes);
1123 }
1124
1125 static WAppIcon *findDockIconFor(WDock *dock, Window main_window)
1126 {
1127 WAppIcon *aicon = NULL;
1128
1129 aicon = wDockFindIconForWindow(dock, main_window);
1130 if (!aicon) {
1131 wDockTrackWindowLaunch(dock, main_window);
1132 aicon = wDockFindIconForWindow(dock, main_window);
1133 }
1134 return aicon;
1135 }
1136
1137 static void create_appicon_from_dock(WWindow *wwin, WApplication *wapp, Window main_window)
1138 {
1139 WScreen *scr = wwin->screen_ptr;
1140 wapp->app_icon = NULL;
1141
1142 if (scr->last_dock)
1143 wapp->app_icon = findDockIconFor(scr->last_dock, main_window);
1144
1145 /* check main dock if we did not find it in last dock */
1146 if (!wapp->app_icon && scr->dock)
1147 wapp->app_icon = findDockIconFor(scr->dock, main_window);
1148
1149 /* check clips */
1150 if (!wapp->app_icon) {
1151 int i;
1152 for (i = 0; i < scr->workspace_count; i++) {
1153 WDock *dock = scr->workspaces[i]->clip;
1154 if (dock)
1155 wapp->app_icon = findDockIconFor(dock, main_window);
1156 if (wapp->app_icon)
1157 break;
1158 }
1159 }
1160
1161 /* Finally check drawers */
1162 if (!wapp->app_icon) {
1163 WDrawerChain *dc;
1164 for (dc = scr->drawers; dc != NULL; dc = dc->next) {
1165 wapp->app_icon = findDockIconFor(dc->adrawer, main_window);
1166 if (wapp->app_icon)
1167 break;
1168 }
1169 }
1170
1171 /* If created, then set some flags */
1172 if (wapp->app_icon) {
1173 WWindow *mainw = wapp->main_window_desc;
1174
1175 wapp->app_icon->running = 1;
1176 wapp->app_icon->icon->owner = mainw;
1177 if (mainw->wm_hints && (mainw->wm_hints->flags & IconWindowHint))
1178 wapp->app_icon->icon->icon_win = mainw->wm_hints->icon_window;
1179
1180 /* Update the icon images */
1181 wIconUpdate(wapp->app_icon->icon);
1182
1183 /* Paint it */
1184 wAppIconPaint(wapp->app_icon);
1185 save_appicon(wapp->app_icon, True);
1186 }
1187 }
1188
1189 /* Add the appicon to the appiconlist */
1190 static void add_to_appicon_list(WScreen *scr, WAppIcon *appicon)
1191 {
1192 appicon->prev = NULL;
1193 appicon->next = scr->app_icon_list;
1194 if (scr->app_icon_list)
1195 scr->app_icon_list->prev = appicon;
1196
1197 scr->app_icon_list = appicon;
1198 }
1199
1200 /* Remove the appicon from the appiconlist */
1201 static void remove_from_appicon_list(WScreen *scr, WAppIcon *appicon)
1202 {
1203 if (appicon == scr->app_icon_list) {
1204 if (appicon->next)
1205 appicon->next->prev = NULL;
1206 scr->app_icon_list = appicon->next;
1207 } else {
1208 if (appicon->next)
1209 appicon->next->prev = appicon->prev;
1210 if (appicon->prev)
1211 appicon->prev->next = appicon->next;
1212 }
1213
1214 appicon->prev = NULL;
1215 appicon->next = NULL;
1216 }
1217
1218 /* Return the AppIcon associated with a given (Xlib) Window. */
1219 WAppIcon *wAppIconFor(Window window)
1220 {
1221 WObjDescriptor *desc;
1222
1223 if (window == None)
1224 return NULL;
1225
1226 if (XFindContext(dpy, window, wWinContext, (XPointer *) & desc) == XCNOENT)
1227 return NULL;
1228
1229 if (desc->parent_type == WCLASS_APPICON || desc->parent_type == WCLASS_DOCK_ICON)
1230 return desc->parent;
1231
1232 return NULL;
1233 }
The Window Maker window manager