?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Applied Bernard Jungen's patch and suggestion:
[rox-filer/th.git] / ROX-Filer / src / tasklist.c
blob66c0b68adb5c93db21faf8d155a89ee7c3523fe6
1 /*
2 * ROX-Filer, filer for the ROX desktop project
3 * Copyright (C) 2006, Thomas Leonard and others (see changelog for details).
4 *
5 * This program is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License as published by the Free
7 * Software Foundation; either version 2 of the License, or (at your option)
8 * any later version.
9 *
10 * This program is distributed in the hope that it will be useful, but WITHOUT
11 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
12 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
13 * more details.
14 *
15 * You should have received a copy of the GNU General Public License along with
16 * this program; if not, write to the Free Software Foundation, Inc., 59 Temple
17 * Place, Suite 330, Boston, MA 02111-1307 USA
18 */
19
20 /* tasklist.c - code for tracking windows
21 *
22 * Loosly based on code in GNOME's libwnck.
23 */
24
25 #include "config.h"
26
27 #include <stdlib.h>
28
29 #include <gtk/gtk.h>
30 #include <gdk/gdk.h>
31 #include <gdk/gdkx.h>
32
33 #include <X11/Xlib.h>
34 #include <X11/Xatom.h>
35
36 #include "global.h"
37
38 #include "tasklist.h"
39 #include "wrapped.h"
40 #include "options.h"
41 #include "gui_support.h"
42 #include "main.h"
43 #include "pinboard.h"
44 #include "pixmaps.h"
45 #include "support.h"
46
47 /* There is one of these for each window controlled by the window
48 * manager (all tasks) in the _NET_CLIENT_LIST property.
49 */
50 typedef struct _IconWindow IconWindow;
51
52 struct _IconWindow {
53 GtkWidget *widget; /* Widget used for icon when iconified */
54 GtkWidget *label;
55 gchar *text;
56 Window xwindow;
57 gboolean iconified;
58 gint timeout_update; /* Non-zero => timeout callback in use */
59 };
60
61 /* If TRUE, only iconfied windows with _NET_WM_STATE_HIDDEN are really icons */
62 static gboolean wm_supports_hidden = FALSE;
63
64 static GdkAtom xa__NET_SUPPORTED = GDK_NONE;
65 static GdkAtom xa_WM_STATE = GDK_NONE;
66 static GdkAtom xa_WM_NAME = GDK_NONE;
67 static GdkAtom xa_WM_ICON_NAME = GDK_NONE;
68 static GdkAtom xa_UTF8_STRING = GDK_NONE;
69 static GdkAtom xa_TEXT = GDK_NONE;
70 static GdkAtom xa__NET_WM_VISIBLE_NAME = GDK_NONE;
71 static GdkAtom xa__NET_WM_ICON_NAME = GDK_NONE;
72 static GdkAtom xa__NET_CLIENT_LIST = GDK_NONE;
73 static GdkAtom xa__NET_WM_ICON_GEOMETRY = GDK_NONE;
74 static GdkAtom xa__NET_WM_STATE = GDK_NONE;
75 static GdkAtom xa__NET_WM_STATE_HIDDEN = GDK_NONE;
76 static GdkAtom xa__NET_WM_DESKTOP = GDK_NONE;
77 static GdkAtom xa__NET_CURRENT_DESKTOP = GDK_NONE;
78 static GdkAtom xa__NET_DESKTOP_GEOMETRY = GDK_NONE;
79 static GdkAtom xa__NET_DESKTOP_VIEWPORT = GDK_NONE;
80
81 /* We have selected destroy and property events on every window in
82 * this table.
83 */
84 static GHashTable *known = NULL; /* XID -> IconWindow */
85
86 /* Static prototypes */
87 static void remove_window(Window win);
88 static void tasklist_update(gboolean to_empty);
89 static GdkFilterReturn window_filter(GdkXEvent *xevent,
90 GdkEvent *event,
91 gpointer data);
92 static guint xid_hash(XID *xid);
93 static gboolean xid_equal(XID *a, XID *b);
94 static void state_changed(IconWindow *win);
95 static void show_icon(IconWindow *win);
96 static void icon_win_free(IconWindow *win);
97 static void update_style(gpointer key, gpointer data, gpointer user_data);
98 static void update_supported(void);
99 static gboolean update_title(gpointer data);
100 static void update_current_desktop(void);
101
102 /* remember what desktop number (and viewport) is currently displayed */
103 static int cur_desktop = 0;
104 static GdkRectangle cur_viewport;
105
106 /****************************************************************
107 * EXTERNAL INTERFACE *
108 ****************************************************************/
109
110 void tasklist_set_active(gboolean active)
111 {
112 static gboolean need_init = TRUE;
113 static gboolean tasklist_active = FALSE;
114
115 if (active == tasklist_active)
116 {
117 if (o_pinboard_tasklist_per_workspace.has_changed && active)
118 tasklist_update(FALSE);
119 return;
120 }
121 tasklist_active = active;
122
123 if (need_init)
124 {
125 GdkWindow *root;
126
127 root = gdk_get_default_root_window();
128
129 xa__NET_SUPPORTED = gdk_atom_intern("_NET_SUPPORTED", FALSE);
130 xa_WM_STATE = gdk_atom_intern("WM_STATE", FALSE);
131 xa_WM_ICON_NAME = gdk_atom_intern("WM_ICON_NAME", FALSE);
132 xa_WM_NAME = gdk_atom_intern("WM_NAME", FALSE);
133 xa_UTF8_STRING = gdk_atom_intern("UTF8_STRING", FALSE);
134 xa_TEXT = gdk_atom_intern("TEXT", FALSE);
135 xa__NET_CLIENT_LIST =
136 gdk_atom_intern("_NET_CLIENT_LIST", FALSE);
137 xa__NET_WM_VISIBLE_NAME =
138 gdk_atom_intern("_NET_WM_VISIBLE_NAME", FALSE);
139 xa__NET_WM_ICON_NAME =
140 gdk_atom_intern("_NET_WM_ICON_NAME", FALSE);
141 xa__NET_WM_ICON_GEOMETRY =
142 gdk_atom_intern("_NET_WM_ICON_GEOMETRY", FALSE);
143 xa__NET_WM_STATE = gdk_atom_intern("_NET_WM_STATE", FALSE);
144 xa__NET_WM_STATE_HIDDEN =
145 gdk_atom_intern("_NET_WM_STATE_HIDDEN", FALSE);
146 xa__NET_WM_DESKTOP = gdk_atom_intern("_NET_WM_DESKTOP", FALSE);
147 xa__NET_CURRENT_DESKTOP = gdk_atom_intern("_NET_CURRENT_DESKTOP", FALSE);
148 xa__NET_DESKTOP_GEOMETRY = gdk_atom_intern("_NET_DESKTOP_GEOMETRY", FALSE);
149 xa__NET_DESKTOP_VIEWPORT = gdk_atom_intern("_NET_DESKTOP_VIEWPORT", FALSE);
150
151 known = g_hash_table_new_full((GHashFunc) xid_hash,
152 (GEqualFunc) xid_equal,
153 NULL,
154 (GDestroyNotify) icon_win_free);
155 gdk_window_set_events(root, gdk_window_get_events(root) |
156 GDK_PROPERTY_CHANGE_MASK);
157 need_init = FALSE;
158 }
159
160 if (active)
161 {
162 update_current_desktop();
163 gdk_window_add_filter(NULL, window_filter, NULL);
164 update_supported();
165 }
166 else
167 gdk_window_remove_filter(NULL, window_filter, NULL);
168
169 tasklist_update(!active);
170 }
171
172 /* User has changes the colours in the options box... */
173 void tasklist_style_changed(void)
174 {
175 if (known)
176 g_hash_table_foreach(known, update_style, NULL);
177 }
178
179 /****************************************************************
180 * INTERNAL FUNCTIONS *
181 ****************************************************************/
182
183 static void icon_win_free(IconWindow *win)
184 {
185 g_return_if_fail(win->widget == NULL);
186 g_return_if_fail(win->label == NULL);
187
188 if (win->timeout_update)
189 g_source_remove(win->timeout_update);
190
191 g_free(win->text);
192 g_free(win);
193 }
194
195 /* From gdk */
196 static guint xid_hash(XID *xid)
197 {
198 return *xid;
199 }
200
201 /* From gdk */
202 static gboolean xid_equal(XID *a, XID *b)
203 {
204 return (*a == *b);
205 }
206
207 static int wincmp(const void *a, const void *b)
208 {
209 const Window *aw = a;
210 const Window *bw = b;
211
212 if (*aw < *bw)
213 return -1;
214 else if (*aw > *bw)
215 return 1;
216 else
217 return 0;
218 }
219
220 /* Read the list of WINDOWs from (xwindow,atom), returning them
221 * in a (sorted) Array of Windows. On error, an empty array is
222 * returned.
223 * Free the array afterwards.
224 */
225 static GArray *get_window_list(Window xwindow, GdkAtom atom)
226 {
227 GArray *array;
228 Atom type;
229 int format;
230 gulong nitems;
231 gulong bytes_after;
232 unsigned char *data;
233 int err, result;
234 int i;
235
236 array = g_array_new(FALSE, FALSE, sizeof(Window));
237
238 gdk_error_trap_push();
239 type = None;
240 result = XGetWindowProperty(gdk_display,
241 xwindow,
242 gdk_x11_atom_to_xatom(atom),
243 0, G_MAXLONG,
244 False, XA_WINDOW, &type, &format, &nitems,
245 &bytes_after, &data);
246 err = gdk_error_trap_pop();
247
248 if (err != Success || result != Success)
249 return array;
250
251 if (type == XA_WINDOW)
252 {
253 for (i = 0; i < nitems; i++)
254 g_array_append_val(array, ((Window *) data)[i]);
255
256 if (array->len)
257 g_array_sort(array, wincmp);
258 }
259
260 XFree(data);
261
262 return array;
263 }
264
265 static guchar *get_str(IconWindow *win, GdkAtom atom)
266 {
267 Atom rtype;
268 int format;
269 gulong nitems;
270 gulong bytes_after;
271 unsigned char *data, *str = NULL;
272 int err, result;
273
274 gdk_error_trap_push();
275
276 result = XGetWindowProperty(gdk_display, win->xwindow,
277 gdk_x11_atom_to_xatom(atom),
278 0, G_MAXLONG, False,
279 AnyPropertyType,
280 &rtype, &format, &nitems,
281 &bytes_after, &data);
282
283 err = gdk_error_trap_pop();
284
285 if (err == Success && result == Success && data)
286 {
287 if (*data)
288 str = g_strdup(data);
289 XFree(data);
290 }
291
292 return str;
293 }
294
295 static void get_icon_name(IconWindow *win)
296 {
297 null_g_free(&win->text);
298
299 /* Keep this list in sync with window_filter */
300
301 win->text = get_str(win, xa__NET_WM_ICON_NAME);
302 if (!win->text)
303 win->text = get_str(win, xa__NET_WM_VISIBLE_NAME);
304 if (!win->text)
305 win->text = get_str(win, xa_WM_ICON_NAME);
306 if (!win->text)
307 win->text = get_str(win, xa_WM_NAME);
308 if (!win->text)
309 win->text = g_strdup(_("Window"));
310 }
311
312 static gboolean update_title(gpointer data)
313 {
314 IconWindow *win = (IconWindow *) data;
315
316 if (!win->widget)
317 return FALSE; /* No longer an icon */
318
319 get_icon_name(win);
320 wrapped_label_set_text(WRAPPED_LABEL(win->label), win->text);
321
322 win->timeout_update = 0;
323
324 return FALSE;
325 }
326
327 /* Call from within error_push/pop
328 * See wnck_window_is_in_viewport */
329 static gboolean within_viewport(Window xwindow)
330 {
331 int x, y;
332 unsigned int width, height, bw, depth;
333 Window root_window, child;
334 GdkRectangle win_rect;
335
336 XGetGeometry (gdk_display,
337 xwindow,
338 &root_window,
339 &x, &y, &width, &height, &bw, &depth);
340 XTranslateCoordinates (gdk_display,
341 xwindow,
342 root_window,
343 0, 0,
344 &x, &y, &child);
345
346 win_rect.x = x + cur_viewport.x;
347 win_rect.y = y + cur_viewport.y;
348 win_rect.width = width;
349 win_rect.height = height;
350
351 return gdk_rectangle_intersect (&cur_viewport, &win_rect, &win_rect);
352 }
353
354 /* Call from within error_push/pop */
355 static void window_check_status(IconWindow *win)
356 {
357 Atom type;
358 int format;
359 gulong nitems;
360 gulong bytes_after;
361 unsigned char *data;
362 Window transient_for;
363 gboolean iconic = FALSE;
364
365 if (XGetTransientForHint(gdk_display, win->xwindow, &transient_for) && transient_for)
366 iconic = FALSE;
367 else if (wm_supports_hidden && XGetWindowProperty(gdk_display, win->xwindow,
368 gdk_x11_atom_to_xatom(xa__NET_WM_STATE),
369 0, G_MAXLONG, False,
370 XA_ATOM,
371 &type, &format, &nitems,
372 &bytes_after, &data) == Success && data)
373 {
374 GdkAtom state;
375 int i;
376
377 for (i = 0; i < nitems; i++)
378 {
379 state = gdk_x11_xatom_to_atom(((Atom *) data)[i]);
380 if (state == xa__NET_WM_STATE_HIDDEN)
381 {
382 iconic = TRUE;
383 break;
384 }
385 }
386 XFree(data);
387 }
388 else if (XGetWindowProperty(gdk_display, win->xwindow,
389 gdk_x11_atom_to_xatom(xa_WM_STATE),
390 0, 1, False,
391 gdk_x11_atom_to_xatom(xa_WM_STATE),
392 &type, &format, &nitems,
393 &bytes_after, &data) == Success && data)
394 {
395 iconic = ((guint32 *) data)[0] == 3;
396 XFree(data);
397 }
398 else
399 iconic = FALSE;
400
401 /* Iconified windows on another desktops are not shown */
402 if (o_pinboard_tasklist_per_workspace.int_value &&
403 XGetWindowProperty(gdk_display, win->xwindow,
404 gdk_x11_atom_to_xatom(xa__NET_WM_DESKTOP),
405 0, G_MAXLONG, False, XA_CARDINAL, &type, &format, &nitems,
406 &bytes_after, &data) == Success && data)
407 {
408 guint32 desk_on = ((guint32 *) data)[0];
409
410 if ((desk_on != 0xffffffff) && ((desk_on != cur_desktop) ||
411 !within_viewport(win->xwindow)))
412 iconic = FALSE;
413 XFree(data);
414 }
415
416 if (win->iconified == iconic)
417 return;
418
419 win->iconified = iconic;
420
421 state_changed(win);
422
423 gdk_flush();
424 }
425
426 static void update_current_desktop(void)
427 {
428 unsigned char *data;
429 Atom type;
430 int format;
431 gulong nitems;
432 gulong bytes_after;
433
434 if (XGetWindowProperty(gdk_display, gdk_x11_get_default_root_xwindow(),
435 gdk_x11_atom_to_xatom(xa__NET_CURRENT_DESKTOP),
436 0, G_MAXLONG, False, XA_CARDINAL, &type, &format, &nitems,
437 &bytes_after, (unsigned char **)(&data)) == Success && data) {
438 cur_desktop = ((gint32*)data)[0];
439 XFree(data);
440 }
441
442 if (XGetWindowProperty(gdk_display, gdk_x11_get_default_root_xwindow(),
443 gdk_x11_atom_to_xatom(xa__NET_DESKTOP_VIEWPORT),
444 0, G_MAXLONG, False, XA_CARDINAL, &type, &format,
445 &nitems,
446 &bytes_after, (unsigned char **)(&data)) == Success &&
447 data) {
448 cur_viewport.x = ((gint32*)data)[0];
449 cur_viewport.y = ((gint32*)data)[1];
450 cur_viewport.width = screen_width;
451 cur_viewport.height = screen_height;
452 XFree(data);
453 }
454 }
455
456 /* Called for all events on all windows */
457 static GdkFilterReturn window_filter(GdkXEvent *xevent,
458 GdkEvent *event,
459 gpointer data)
460 {
461 XEvent *xev = (XEvent *) xevent;
462 IconWindow *w;
463
464 if (xev->type == PropertyNotify)
465 {
466 GdkAtom atom = gdk_x11_xatom_to_atom(xev->xproperty.atom);
467 Window win = ((XPropertyEvent *) xev)->window;
468
469 if (atom == xa_WM_STATE || atom == xa__NET_WM_STATE)
470 {
471 w = g_hash_table_lookup(known, &win);
472
473 if (w)
474 {
475 gdk_error_trap_push();
476 window_check_status(w);
477 if (gdk_error_trap_pop() != Success)
478 g_hash_table_remove(known, &win);
479 }
480 }
481 else if (atom == xa__NET_CURRENT_DESKTOP ||
482 atom == xa__NET_DESKTOP_VIEWPORT ||
483 atom == xa__NET_DESKTOP_GEOMETRY)
484 {
485 update_current_desktop();
486 tasklist_update(FALSE);
487 }
488 else if (atom == xa__NET_WM_ICON_NAME ||
489 atom == xa__NET_WM_VISIBLE_NAME ||
490 atom == xa_WM_ICON_NAME ||
491 atom == xa_WM_NAME)
492 {
493 /* Keep this list in sync with get_icon_name */
494 w = g_hash_table_lookup(known, &win);
495
496 if (w && w->widget && !w->timeout_update)
497 w->timeout_update = g_timeout_add(100,
498 update_title, w);
499 }
500 else if (atom == xa__NET_CLIENT_LIST)
501 tasklist_update(FALSE);
502 else if (atom == xa__NET_SUPPORTED)
503 update_supported();
504 }
505
506 return GDK_FILTER_CONTINUE;
507 }
508
509 /* Window has been added to list of managed windows */
510 static void add_window(Window win)
511 {
512 IconWindow *w;
513
514 /* g_print("[ New window %ld ]\n", (long) win); */
515
516 w = g_hash_table_lookup(known, &win);
517
518 if (!w)
519 {
520 XWindowAttributes attr;
521
522 gdk_error_trap_push();
523
524 XGetWindowAttributes(gdk_display, win, &attr);
525
526 if (gdk_error_trap_pop() != Success)
527 return;
528 gdk_error_trap_push();
529
530 XSelectInput(gdk_display, win, attr.your_event_mask |
531 PropertyChangeMask);
532
533 gdk_flush();
534
535 if (gdk_error_trap_pop() != Success)
536 return;
537
538 w = g_new(IconWindow, 1);
539 w->widget = NULL;
540 w->label = NULL;
541 w->text = NULL;
542 w->xwindow = win;
543 w->iconified = FALSE;
544 w->timeout_update = 0;
545
546 g_hash_table_insert(known, &w->xwindow, w);
547 }
548
549 gdk_error_trap_push();
550
551 window_check_status(w);
552
553 #if 0
554 set_iconify_pos(w);
555 #endif
556
557 if (gdk_error_trap_pop() != Success)
558 g_hash_table_remove(known, &win);
559 }
560
561 /* Window is no longer managed, but hasn't been destroyed yet */
562 static void remove_window(Window win)
563 {
564 IconWindow *w;
565
566 /* g_print("[ Remove window %ld ]\n", (long) win); */
567
568 w = g_hash_table_lookup(known, &win);
569 if (w)
570 {
571 if (w->iconified)
572 {
573 w->iconified = FALSE;
574 state_changed(w);
575 }
576
577 g_hash_table_remove(known, &win);
578 }
579 }
580
581 /* Make sure the window list is up-to-date. Call once to start, and then
582 * everytime _NET_CLIENT_LIST changes.
583 * If 'to_empty' is set them pretend all windows have disappeared.
584 */
585 static void tasklist_update(gboolean to_empty)
586 {
587 static GArray *old_mapping = NULL;
588 GArray *mapping = NULL;
589 int new_i, old_i;
590
591 if (!old_mapping)
592 {
593 old_mapping = g_array_new(FALSE, FALSE, sizeof(Window));
594 }
595
596 if (to_empty)
597 mapping = g_array_new(FALSE, FALSE, sizeof(Window));
598 else
599 mapping = get_window_list(gdk_x11_get_default_root_xwindow(),
600 gdk_atom_intern("_NET_CLIENT_LIST", FALSE));
601
602 new_i = 0;
603 old_i = 0;
604 while (new_i < mapping->len && old_i < old_mapping->len)
605 {
606 Window new = g_array_index(mapping, Window, new_i);
607 Window old = g_array_index(old_mapping, Window, old_i);
608
609 if (new == old)
610 {
611 add_window(new);
612 new_i++;
613 old_i++;
614 }
615 else if (new < old)
616 {
617 add_window(new);
618 new_i++;
619 }
620 else
621 {
622 remove_window(old);
623 old_i++;
624 }
625 }
626 while (new_i < mapping->len)
627 {
628 add_window(g_array_index(mapping, Window, new_i));
629 new_i++;
630 }
631 while (old_i < old_mapping->len)
632 {
633 remove_window(g_array_index(old_mapping, Window, old_i));
634 old_i++;
635 }
636
637 g_array_free(old_mapping, TRUE);
638 old_mapping = mapping;
639 }
640
641 /* Called when the user clicks on the button */
642 static void uniconify(IconWindow *win, guint32 timestamp)
643 {
644 XClientMessageEvent sev;
645
646 sev.type = ClientMessage;
647 sev.display = gdk_display;
648 sev.format = 32;
649 sev.window = win->xwindow;
650 sev.message_type = gdk_x11_atom_to_xatom(
651 gdk_atom_intern("_NET_ACTIVE_WINDOW", FALSE));
652 sev.data.l[0] = 2;
653 sev.data.l[1] = timestamp;
654 sev.data.l[2] = 0;
655
656 gdk_error_trap_push();
657
658 XSendEvent(gdk_display, DefaultRootWindow(gdk_display), False,
659 SubstructureNotifyMask | SubstructureRedirectMask,
660 (XEvent *) &sev);
661 XSync(gdk_display, False);
662
663 gdk_error_trap_pop();
664 }
665
666 static gint drag_start_x = -1;
667 static gint drag_start_y = -1;
668 static gboolean drag_started = FALSE;
669 static gint drag_off_x = -1;
670 static gint drag_off_y = -1;
671
672 static void icon_button_press(GtkWidget *widget,
673 GdkEventButton *event,
674 IconWindow *win)
675 {
676 if (event->button == 1)
677 {
678 drag_start_x = event->x_root;
679 drag_start_y = event->y_root;
680 drag_started = FALSE;
681
682 drag_off_x = event->x;
683 drag_off_y = event->y;
684 }
685 }
686
687 static gboolean icon_motion_notify(GtkWidget *widget,
688 GdkEventMotion *event,
689 IconWindow *win)
690 {
691 if (event->state & GDK_BUTTON1_MASK)
692 {
693 int dx = event->x_root - drag_start_x;
694 int dy = event->y_root - drag_start_y;
695
696 if (!drag_started)
697 {
698 if (abs(dx) < 5 && abs(dy) < 5)
699 return FALSE;
700 drag_started = TRUE;
701 }
702
703 fixed_move_fast(GTK_FIXED(win->widget->parent),
704 win->widget,
705 event->x_root - drag_off_x,
706 event->y_root - drag_off_y);
707
708 pinboard_moved_widget(win->widget, win->text,
709 event->x_root - drag_off_x,
710 event->y_root - drag_off_y);
711 }
712
713 return FALSE;
714 }
715
716 static void button_released(GtkWidget *widget, GdkEventButton *event,
717 IconWindow *win)
718 {
719 if (!drag_started && event->button == 1)
720 uniconify(win, event->time);
721 }
722
723 static GdkColormap* get_cmap(GdkPixmap *pixmap)
724 {
725 GdkColormap *cmap;
726
727 cmap = gdk_drawable_get_colormap(pixmap);
728 if (cmap)
729 g_object_ref(G_OBJECT(cmap));
730
731 if (cmap == NULL)
732 {
733 if (gdk_drawable_get_depth(pixmap) == 1)
734 {
735 /* Masks don't need colourmaps */
736 cmap = NULL;
737 }
738 else
739 {
740 /* Try system cmap */
741 cmap = gdk_colormap_get_system();
742 g_object_ref(G_OBJECT(cmap));
743 }
744 }
745
746 /* Be sure we aren't going to blow up due to visual mismatch */
747 if (cmap && (gdk_colormap_get_visual(cmap)->depth !=
748 gdk_drawable_get_depth(pixmap)))
749 cmap = NULL;
750
751 return cmap;
752 }
753
754 /* Copy a pixmap from the server to a client-side pixbuf */
755 static GdkPixbuf* pixbuf_from_pixmap(Pixmap xpixmap)
756 {
757 GdkDrawable *drawable;
758 GdkPixbuf *retval;
759 GdkColormap *cmap;
760 int width, height;
761
762 retval = NULL;
763
764 drawable = gdk_xid_table_lookup(xpixmap);
765
766 if (GDK_IS_DRAWABLE(drawable))
767 g_object_ref(G_OBJECT(drawable));
768 else
769 {
770 drawable = gdk_pixmap_foreign_new(xpixmap);
771 if (!GDK_IS_DRAWABLE(drawable))
772 return retval;
773 }
774
775 cmap = get_cmap(drawable);
776
777 /* GDK is supposed to do this but doesn't in GTK 2.0.2,
778 * fixed in 2.0.3
779 */
780 gdk_drawable_get_size(drawable, &width, &height);
781
782 retval = gdk_pixbuf_get_from_drawable(NULL, drawable, cmap,
783 0, 0, 0, 0, width, height);
784
785 if (cmap)
786 g_object_unref(G_OBJECT(cmap));
787 g_object_unref(G_OBJECT(drawable));
788
789 return retval;
790 }
791
792 /* Creates a new masked pixbuf from a non-masked pixbuf and a mask */
793 static GdkPixbuf* apply_mask(GdkPixbuf *pixbuf, GdkPixbuf *mask)
794 {
795 int w, h;
796 int i, j;
797 GdkPixbuf *with_alpha;
798 guchar *src;
799 guchar *dest;
800 int src_stride;
801 int dest_stride;
802
803 w = MIN(gdk_pixbuf_get_width(mask), gdk_pixbuf_get_width(pixbuf));
804 h = MIN(gdk_pixbuf_get_height(mask), gdk_pixbuf_get_height(pixbuf));
805
806 with_alpha = gdk_pixbuf_add_alpha(pixbuf, FALSE, 0, 0, 0);
807
808 dest = gdk_pixbuf_get_pixels(with_alpha);
809 src = gdk_pixbuf_get_pixels(mask);
810
811 dest_stride = gdk_pixbuf_get_rowstride(with_alpha);
812 src_stride = gdk_pixbuf_get_rowstride(mask);
813
814 i = 0;
815 while (i < h)
816 {
817 j = 0;
818 while (j < w)
819 {
820 guchar *s = src + i * src_stride + j * 3;
821 guchar *d = dest + i * dest_stride + j * 4;
822
823 /* s[0] == s[1] == s[2], they are 255 if the bit was
824 * set, 0 otherwise
825 */
826 if (s[0] == 0)
827 d[3] = 0; /* transparent */
828 else
829 d[3] = 255; /* opaque */
830
831 ++j;
832 }
833
834 ++i;
835 }
836
837 return with_alpha;
838 }
839
840 #define BORDER_X 16
841 #define BORDER_Y 8
842 /* Take the icon that the iconified window has given us and modify it to make
843 * it obvious what it is.
844 */
845 static GdkPixbuf *apply_window_effect(GdkPixbuf *src)
846 {
847 GdkPixbuf *new;
848 int w, h;
849
850 w = gdk_pixbuf_get_width(src);
851 h = gdk_pixbuf_get_height(src);
852
853 new = gdk_pixbuf_new(gdk_pixbuf_get_colorspace(src), TRUE,
854 8, w + BORDER_X * 2, h + BORDER_Y * 2);
855 gdk_pixbuf_fill(new, 0x88888888);
856
857 gdk_pixbuf_composite(src, new,
858 BORDER_X, BORDER_Y, w, h,
859 BORDER_X, BORDER_Y, 1, 1,
860 GDK_INTERP_NEAREST, 255);
861
862 return new;
863 }
864
865 /* Return a suitable icon for this window. unref the result.
866 * Never returns NULL.
867 */
868 static GdkPixbuf *get_image_for(IconWindow *win)
869 {
870 static MaskedPixmap *default_icon = NULL;
871 Pixmap pixmap = None;
872 Pixmap mask = None;
873 XWMHints *hints;
874 GdkPixbuf *retval = NULL;
875
876 /* Try the pixmap and mask in the old WMHints... */
877 gdk_error_trap_push();
878 hints = XGetWMHints(gdk_display, win->xwindow);
879
880 if (hints)
881 {
882 if (hints->flags & IconPixmapHint)
883 pixmap = hints->icon_pixmap;
884 if (hints->flags & IconMaskHint)
885 mask = hints->icon_mask;
886
887 XFree(hints);
888 hints = NULL;
889 }
890
891 if (pixmap != None)
892 {
893 GdkPixbuf *mask_pb = NULL;
894
895 retval = pixbuf_from_pixmap(pixmap);
896
897 if (retval && mask != None)
898 mask_pb = pixbuf_from_pixmap(mask);
899
900 if (mask_pb)
901 {
902 GdkPixbuf *masked;
903
904 masked = apply_mask(retval, mask_pb);
905 g_object_unref(G_OBJECT(mask_pb));
906
907 if (masked)
908 {
909 g_object_unref(G_OBJECT(retval));
910 retval = masked;
911 }
912 }
913 }
914
915 gdk_flush();
916
917 gdk_error_trap_pop();
918
919 if (!retval)
920 {
921 if (!default_icon)
922 default_icon = load_pixmap("iconified");
923
924 retval = default_icon->pixbuf;
925 g_object_ref(retval);
926 }
927
928 /* Apply a special effect to make this look different from normal
929 * pinboard icons.
930 */
931 {
932 GdkPixbuf *old = retval;
933 GdkPixbuf *small;
934 small = scale_pixbuf(old, ICON_WIDTH, ICON_HEIGHT);
935 g_object_unref(old);
936 retval = apply_window_effect(small);
937 g_object_unref(small);
938 }
939
940 return retval;
941 }
942
943 /* Stop the button from highlighting */
944 static gint icon_expose(GtkWidget *widget, GdkEventExpose *event,
945 IconWindow *win)
946 {
947 static GtkWidgetClass *parent_class = NULL;
948
949 g_return_val_if_fail(win != NULL, TRUE);
950 g_return_val_if_fail(win->label != NULL, TRUE);
951
952 if (!parent_class)
953 {
954 gpointer c = ((GTypeInstance *) widget)->g_class;
955 parent_class = (GtkWidgetClass *) g_type_class_peek_parent(c);
956 }
957
958 draw_label_shadow((WrappedLabel *) win->label, event->region);
959
960 gdk_gc_set_clip_region(win->label->style->fg_gc[win->label->state],
961 event->region);
962 (parent_class->expose_event)(widget, event);
963 gdk_gc_set_clip_region(win->label->style->fg_gc[win->label->state],
964 NULL);
965
966 /* Stop the button effect */
967 return TRUE;
968 }
969
970 /* A window has been iconified -- display it on the screen */
971 static void show_icon(IconWindow *win)
972 {
973 GdkPixbuf *pixbuf;
974 GtkWidget *vbox;
975
976 g_return_if_fail(win->widget == NULL);
977 g_return_if_fail(win->label == NULL);
978
979 win->widget = gtk_button_new();
980 gtk_button_set_relief(GTK_BUTTON(win->widget), GTK_RELIEF_NONE);
981 g_signal_connect(win->widget, "expose-event",
982 G_CALLBACK(icon_expose), win);
983 vbox = gtk_vbox_new(FALSE, 0);
984 gtk_container_add(GTK_CONTAINER(win->widget), vbox);
985
986 pixbuf = get_image_for(win);
987
988 gtk_box_pack_start(GTK_BOX(vbox), simple_image_new(pixbuf),
989 FALSE, TRUE, 0);
990 g_object_unref(pixbuf);
991
992 win->label = wrapped_label_new(win->text, 180);
993
994 update_style(NULL, win, NULL);
995
996 gtk_box_pack_start(GTK_BOX(vbox), win->label, FALSE, TRUE, 0);
997
998 gtk_widget_add_events(win->widget,
999 GDK_BUTTON1_MOTION_MASK | GDK_BUTTON_RELEASE_MASK);
1000 g_signal_connect(win->widget, "button-press-event",
1001 G_CALLBACK(icon_button_press), win);
1002 g_signal_connect(win->widget, "motion-notify-event",
1003 G_CALLBACK(icon_motion_notify), win);
1004 g_signal_connect(win->widget, "button-release-event",
1005 G_CALLBACK(button_released), win);
1006
1007 gtk_widget_show_all(vbox); /* So the size comes out right */
1008 pinboard_add_widget(win->widget, win->text);
1009 gtk_widget_show(win->widget);
1010 }
1011
1012 /* A window has been destroyed/expanded -- remove its icon */
1013 static void hide_icon(IconWindow *win)
1014 {
1015 g_return_if_fail(win->widget != NULL);
1016
1017 gtk_widget_hide(win->widget); /* Stops flicker - stupid GtkFixed! */
1018 gtk_widget_destroy(win->widget);
1019 win->widget = NULL;
1020 win->label = NULL;
1021 }
1022
1023 static void state_changed(IconWindow *win)
1024 {
1025 if (win->iconified)
1026 {
1027 get_icon_name(win);
1028 show_icon(win);
1029 }
1030 else
1031 hide_icon(win);
1032 }
1033
1034 #if 0
1035 /* Set the _NET_WM_ICON_GEOMETRY property, which indicates where this window
1036 * will be iconified to. Should be inside a push/pop.
1037 */
1038 static void set_iconify_pos(IconWindow *win)
1039 {
1040 gint32 data[4];
1041
1042 data[0] = iconify_next_x;
1043 data[1] = iconify_next_y;
1044 data[2] = 100;
1045 data[3] = 32;
1046
1047 XChangeProperty(gdk_display, win->xwindow,
1048 gdk_x11_atom_to_xatom(xa__NET_WM_ICON_GEOMETRY),
1049 XA_CARDINAL, 32, PropModeReplace, (guchar *) data, 4);
1050 }
1051 #endif
1052
1053 static void update_style(gpointer key, gpointer data, gpointer user_data)
1054 {
1055 IconWindow *win = (IconWindow *) data;
1056
1057 if (!win->widget)
1058 return;
1059
1060 widget_modify_font(win->label, pinboard_font);
1061 gtk_widget_modify_fg(win->label, GTK_STATE_NORMAL, &pin_text_fg_col);
1062 gtk_widget_modify_bg(win->label, GTK_STATE_NORMAL, &pin_text_bg_col);
1063 gtk_widget_modify_fg(win->label, GTK_STATE_PRELIGHT, &pin_text_fg_col);
1064 gtk_widget_modify_bg(win->label, GTK_STATE_PRELIGHT, &pin_text_bg_col);
1065 }
1066
1067 /* Find out what the new window manager can do... */
1068 static void update_supported(void)
1069 {
1070 Atom type;
1071 int format;
1072 gulong nitems;
1073 gulong bytes_after;
1074 unsigned char *data;
1075 int err, result;
1076 int i;
1077 gboolean old_supports_hidden = wm_supports_hidden;
1078
1079 wm_supports_hidden = FALSE;
1080
1081 gdk_error_trap_push();
1082 type = None;
1083 result = XGetWindowProperty(gdk_display,
1084 gdk_x11_get_default_root_xwindow(),
1085 gdk_x11_atom_to_xatom(xa__NET_SUPPORTED),
1086 0, G_MAXLONG,
1087 False, XA_ATOM, &type, &format, &nitems,
1088 &bytes_after, &data);
1089 err = gdk_error_trap_pop();
1090
1091 if (err != Success || result != Success)
1092 goto out;
1093
1094 for (i = 0; i < nitems; i++)
1095 {
1096 GdkAtom atom = gdk_x11_xatom_to_atom(((Atom *) data)[i]);
1097
1098 if (atom == xa__NET_WM_STATE_HIDDEN)
1099 wm_supports_hidden = TRUE;
1100 }
1101
1102 XFree(data);
1103 out:
1104
1105 if (wm_supports_hidden != old_supports_hidden)
1106 {
1107 tasklist_update(TRUE);
1108 tasklist_update(FALSE);
1109 }
1110 }
For TH to add new features