ROX-Filer/src/tasklist.c

   1 /*
   2  * $Id$
   3  *
   4  * ROX-Filer, filer for the ROX desktop project
   5  * Copyright (C) 2002, the ROX-Filer team.
   6  *
   7  * This program is free software; you can redistribute it and/or modify it
   8  * under the terms of the GNU General Public License as published by the Free
   9  * Software Foundation; either version 2 of the License, or (at your option)
  10  * any later version.
  11  *
  12  * This program is distributed in the hope that it will be useful, but WITHOUT
  13  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  14  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
  15  * more details.
  16  *
  17  * You should have received a copy of the GNU General Public License along with
  18  * this program; if not, write to the Free Software Foundation, Inc., 59 Temple
  19  * Place, Suite 330, Boston, MA  02111-1307  USA
  20  */
  21
  22 /* tasklist.c - code for tracking windows
  23  *
  24  * Loosly based on code in GNOME's libwnck.
  25  */
  26
  27 #include "config.h"
  28
  29 #include <stdlib.h>
  30
  31 #include <gtk/gtk.h>
  32 #include <gdk/gdk.h>
  33 #include <gdk/gdkx.h>
  34
  35 #include <X11/Xlib.h>
  36 #include <X11/Xatom.h>
  37
  38 #include "global.h"
  39
  40 #include "tasklist.h"
  41 #include "wrapped.h"
  42 #include "options.h"
  43 #include "gui_support.h"
  44 #include "main.h"
  45 #include "pinboard.h"
  46 #include "pixmaps.h"
  47
  48 /* There is one of these for each window controlled by the window
  49  * manager (all tasks) in the _NET_CLIENT_LIST property.
  50  */
  51 typedef struct _IconWindow IconWindow;
  52
  53 struct _IconWindow {
  54         GtkWidget *widget;      /* Widget used for icon when iconified */
  55         GtkWidget *label;
  56         gchar *text;
  57         Window xwindow;
  58         gboolean iconified;
  59 };
  60
  61 static GdkAtom xa_WM_STATE = GDK_NONE;
  62 static GdkAtom xa_WM_NAME = GDK_NONE;
  63 static GdkAtom xa_WM_ICON_NAME = GDK_NONE;
  64 static GdkAtom xa_UTF8_STRING = GDK_NONE;
  65 static GdkAtom xa_TEXT = GDK_NONE;
  66 static GdkAtom xa__NET_WM_VISIBLE_NAME = GDK_NONE;
  67 static GdkAtom xa__NET_WM_ICON_NAME = GDK_NONE;
  68 static GdkAtom xa__NET_CLIENT_LIST = GDK_NONE;
  69 static GdkAtom xa__NET_WM_ICON_GEOMETRY = GDK_NONE;
  70
  71 /* We have selected destroy and property events on every window in
  72  * this table.
  73  */
  74 static GHashTable *known = NULL;        /* XID -> IconWindow */
  75
  76 /* Static prototypes */
  77 static void remove_window(Window win);
  78 static void tasklist_update(gboolean to_empty);
  79 static GdkFilterReturn window_filter(GdkXEvent *xevent,
  80                                      GdkEvent *event,
  81                                      gpointer data);
  82 static guint xid_hash(XID *xid);
  83 static gboolean xid_equal(XID *a, XID *b);
  84 static void state_changed(IconWindow *win);
  85 static void show_icon(IconWindow *win);
  86 static void icon_win_free(IconWindow *win);
  87 static void update_style(gpointer key, gpointer data, gpointer user_data);
  88
  89 /****************************************************************
  90  *                      EXTERNAL INTERFACE                      *
  91  ****************************************************************/
  92
  93 void tasklist_set_active(gboolean active)
  94 {
  95         static gboolean need_init = TRUE;
  96         static gboolean tasklist_active = FALSE;
  97
  98         if (active == tasklist_active)
  99                 return;
 100         tasklist_active = active;
 101
 102         if (need_init)
 103         {
 104                 GdkWindow *root;
 105
 106                 root = gdk_get_default_root_window();
 107
 108                 xa_WM_STATE = gdk_atom_intern("WM_STATE", FALSE);
 109                 xa_WM_ICON_NAME = gdk_atom_intern("WM_ICON_NAME", FALSE);
 110                 xa_WM_NAME = gdk_atom_intern("WM_NAME", FALSE);
 111                 xa_UTF8_STRING = gdk_atom_intern("UTF8_STRING", FALSE);
 112                 xa_TEXT = gdk_atom_intern("TEXT", FALSE);
 113                 xa__NET_CLIENT_LIST =
 114                                 gdk_atom_intern("_NET_CLIENT_LIST", FALSE);
 115                 xa__NET_WM_VISIBLE_NAME =
 116                         gdk_atom_intern("_NET_WM_VISIBLE_NAME", FALSE);
 117                 xa__NET_WM_ICON_NAME =
 118                         gdk_atom_intern("_NET_WM_ICON_NAME", FALSE);
 119                 xa__NET_WM_ICON_GEOMETRY =
 120                         gdk_atom_intern("_NET_WM_ICON_GEOMETRY", FALSE);
 121
 122                 known = g_hash_table_new_full((GHashFunc) xid_hash,
 123                                               (GEqualFunc) xid_equal,
 124                                               NULL,
 125                                               (GDestroyNotify) icon_win_free);
 126                 gdk_window_set_events(root, gdk_window_get_events(root) |
 127                                         GDK_PROPERTY_CHANGE_MASK);
 128                 need_init = FALSE;
 129         }
 130
 131         if (active)
 132                 gdk_window_add_filter(NULL, window_filter, NULL);
 133         else
 134                 gdk_window_remove_filter(NULL, window_filter, NULL);
 135
 136         tasklist_update(!active);
 137 }
 138
 139 /* User has changes the colours in the options box... */
 140 void tasklist_style_changed(void)
 141 {
 142         g_hash_table_foreach(known, update_style, NULL);
 143 }
 144
 145 /****************************************************************
 146  *                      INTERNAL FUNCTIONS                      *
 147  ****************************************************************/
 148
 149 static void icon_win_free(IconWindow *win)
 150 {
 151         g_return_if_fail(win->widget == NULL);
 152         g_return_if_fail(win->label == NULL);
 153
 154         if (win->text)
 155                 g_free(win->text);
 156         g_free(win);
 157 }
 158
 159 /* From gdk */
 160 static guint xid_hash(XID *xid)
 161 {
 162         return *xid;
 163 }
 164
 165 /* From gdk */
 166 static gboolean xid_equal(XID *a, XID *b)
 167 {
 168         return (*a == *b);
 169 }
 170
 171 static int wincmp(const void *a, const void *b)
 172 {
 173         const Window *aw = a;
 174         const Window *bw = b;
 175
 176         if (*aw < *bw)
 177                 return -1;
 178         else if (*aw > *bw)
 179                 return 1;
 180         else
 181                 return 0;
 182 }
 183
 184 /* Read the list of WINDOWs from (xwindow,atom), returning them
 185  * in a (sorted) Array of Windows. On error, an empty array is
 186  * returned.
 187  * Free the array afterwards.
 188  */
 189 static GArray *get_window_list(Window xwindow, GdkAtom atom)
 190 {
 191         GArray *array;
 192         Atom type;
 193         int format;
 194         gulong nitems;
 195         gulong bytes_after;
 196         Window *data;
 197         int err, result;
 198         int i;
 199
 200         array = g_array_new(FALSE, FALSE, sizeof(Window));
 201
 202         gdk_error_trap_push();
 203         type = None;
 204         result = XGetWindowProperty(gdk_display,
 205                         xwindow,
 206                         gdk_x11_atom_to_xatom(atom),
 207                         0, G_MAXLONG,
 208                         False, XA_WINDOW, &type, &format, &nitems,
 209                         &bytes_after, (guchar **)&data);
 210         err = gdk_error_trap_pop();
 211
 212         if (err != Success || result != Success)
 213                 return array;
 214
 215         if (type == XA_WINDOW)
 216         {
 217                 for (i = 0; i < nitems; i++)
 218                         g_array_append_val(array, data[i]);
 219
 220                 if (array->len)
 221                         g_array_sort(array, wincmp);
 222         }
 223
 224         XFree(data);
 225
 226         return array;
 227 }
 228
 229 static gchar *get_str(IconWindow *win, GdkAtom atom)
 230 {
 231         Atom rtype;
 232         int format;
 233         gulong nitems;
 234         gulong bytes_after;
 235         char *data, *str = NULL;
 236
 237         if (XGetWindowProperty(gdk_display, win->xwindow,
 238                         gdk_x11_atom_to_xatom(atom),
 239                         0, G_MAXLONG, False,
 240                         AnyPropertyType,
 241                         &rtype, &format, &nitems,
 242                         &bytes_after, (guchar **) &data) == Success && data)
 243         {
 244                 if (*data)
 245                         str = g_strdup(data);
 246                 XFree(data);
 247         }
 248
 249         return str;
 250 }
 251
 252 static void get_icon_name(IconWindow *win)
 253 {
 254         if (win->text)
 255         {
 256                 g_free(win->text);
 257                 win->text = NULL;
 258         }
 259
 260         win->text = get_str(win, xa__NET_WM_ICON_NAME);
 261         if (!win->text)
 262                 win->text = get_str(win, xa__NET_WM_VISIBLE_NAME);
 263         if (!win->text)
 264                 win->text = get_str(win, xa_WM_ICON_NAME);
 265         if (!win->text)
 266                 win->text = get_str(win, xa_WM_NAME);
 267         if (!win->text)
 268                 win->text = g_strdup(_("Window"));
 269 }
 270
 271 /* Call from within error_push/pop */
 272 static void window_check_status(IconWindow *win)
 273 {
 274         Atom type;
 275         int format;
 276         gulong nitems;
 277         gulong bytes_after;
 278         gint32 *data;
 279         gboolean iconic;
 280
 281         if (XGetWindowProperty(gdk_display, win->xwindow,
 282                         gdk_x11_atom_to_xatom(xa_WM_STATE),
 283                         0, 1, False,
 284                         gdk_x11_atom_to_xatom(xa_WM_STATE),
 285                         &type, &format, &nitems,
 286                         &bytes_after, (guchar **) &data) == Success && data)
 287         {
 288                 iconic = data[0] == 3;
 289                 XFree(data);
 290         }
 291         else
 292                 iconic = FALSE;
 293
 294         if (win->iconified == iconic)
 295                 return;
 296
 297         win->iconified = iconic;
 298
 299         state_changed(win);
 300 }
 301
 302 /* Called for all events on all windows */
 303 static GdkFilterReturn window_filter(GdkXEvent *xevent,
 304                                      GdkEvent *event,
 305                                      gpointer data)
 306 {
 307         XEvent *xev = (XEvent *) xevent;
 308         IconWindow *w;
 309
 310         if (xev->type == PropertyNotify)
 311         {
 312                 GdkAtom atom = gdk_x11_xatom_to_atom(xev->xproperty.atom);
 313                 Window win = ((XPropertyEvent *) xev)->window;
 314
 315                 if (atom == xa_WM_STATE)
 316                 {
 317                         w = g_hash_table_lookup(known, &win);
 318
 319                         if (w)
 320                         {
 321                                 gdk_error_trap_push();
 322                                 window_check_status(w);
 323                                 if (gdk_error_trap_pop() != Success)
 324                                         g_hash_table_remove(known, &win);
 325                         }
 326                 }
 327
 328                 if (atom == xa__NET_CLIENT_LIST)
 329                         tasklist_update(FALSE);
 330         }
 331
 332         return GDK_FILTER_CONTINUE;
 333 }
 334
 335 /* Window has been added to list of managed windows */
 336 static void add_window(Window win)
 337 {
 338         IconWindow *w;
 339
 340         /* g_print("[ New window %ld ]\n", (long) win); */
 341
 342         w = g_hash_table_lookup(known, &win);
 343
 344         if (!w)
 345         {
 346                 XWindowAttributes attr;
 347
 348                 gdk_error_trap_push();
 349
 350                 XGetWindowAttributes(gdk_display, win, &attr);
 351
 352                 XSelectInput(gdk_display, win, attr.your_event_mask |
 353                         PropertyChangeMask);
 354
 355                 if (gdk_error_trap_pop() != Success)
 356                         return;
 357
 358                 w = g_new(IconWindow, 1);
 359                 w->widget = NULL;
 360                 w->label = NULL;
 361                 w->text = NULL;
 362                 w->xwindow = win;
 363                 w->iconified = FALSE;
 364
 365                 g_hash_table_insert(known, &w->xwindow, w);
 366         }
 367
 368         gdk_error_trap_push();
 369
 370         window_check_status(w);
 371
 372 #if 0
 373         set_iconify_pos(w);
 374 #endif
 375
 376         if (gdk_error_trap_pop() != Success)
 377                 g_hash_table_remove(known, &win);
 378 }
 379
 380 /* Window is no longer managed, but hasn't been destroyed yet */
 381 static void remove_window(Window win)
 382 {
 383         IconWindow *w;
 384
 385         /* g_print("[ Remove window %ld ]\n", (long) win); */
 386
 387         w = g_hash_table_lookup(known, &win);
 388         if (w)
 389         {
 390                 if (w->iconified)
 391                 {
 392                         w->iconified = FALSE;
 393                         state_changed(w);
 394                 }
 395
 396                 g_hash_table_remove(known, &win);
 397         }
 398 }
 399
 400 /* Make sure the window list is up-to-date. Call once to start, and then
 401  * everytime _NET_CLIENT_LIST changes.
 402  * If 'to_empty' is set them pretend all windows have disappeared.
 403  */
 404 static void tasklist_update(gboolean to_empty)
 405 {
 406         static GArray *old_mapping = NULL;
 407         GArray *mapping = NULL;
 408         int new_i, old_i;
 409
 410         if (!old_mapping)
 411         {
 412                 old_mapping = g_array_new(FALSE, FALSE, sizeof(Window));
 413         }
 414
 415         if (to_empty)
 416                 mapping = g_array_new(FALSE, FALSE, sizeof(Window));
 417         else
 418                 mapping = get_window_list(gdk_x11_get_default_root_xwindow(),
 419                                 gdk_atom_intern("_NET_CLIENT_LIST", FALSE));
 420
 421         new_i = 0;
 422         old_i = 0;
 423         while (new_i < mapping->len && old_i < old_mapping->len)
 424         {
 425                 Window new = g_array_index(mapping, Window, new_i);
 426                 Window old = g_array_index(old_mapping, Window, old_i);
 427
 428                 if (new == old)
 429                 {
 430                         new_i++;
 431                         old_i++;
 432                 }
 433                 else if (new < old)
 434                 {
 435                         add_window(new);
 436                         new_i++;
 437                 }
 438                 else
 439                 {
 440                         remove_window(old);
 441                         old_i++;
 442                 }
 443         }
 444         while (new_i < mapping->len)
 445         {
 446                 add_window(g_array_index(mapping, Window, new_i));
 447                 new_i++;
 448         }
 449         while (old_i < old_mapping->len)
 450         {
 451                 remove_window(g_array_index(old_mapping, Window, old_i));
 452                 old_i++;
 453         }
 454
 455         g_array_free(old_mapping, TRUE);
 456         old_mapping = mapping;
 457 }
 458
 459 /* Called when the user clicks on the button */
 460 static void uniconify(IconWindow *win)
 461 {
 462         XClientMessageEvent sev;
 463
 464         sev.type = ClientMessage;
 465         sev.display = gdk_display;
 466         sev.format = 32;
 467         sev.window = win->xwindow;
 468         sev.message_type = gdk_x11_atom_to_xatom(
 469                         gdk_atom_intern("_NET_ACTIVE_WINDOW", FALSE));
 470         sev.data.l[0] = 0;
 471
 472         gdk_error_trap_push();
 473
 474         XSendEvent(gdk_display, DefaultRootWindow(gdk_display), False,
 475                         SubstructureNotifyMask | SubstructureRedirectMask,
 476                         (XEvent *) &sev);
 477         XSync (gdk_display, False);
 478
 479         gdk_error_trap_pop();
 480 }
 481
 482 static gint drag_start_x = -1;
 483 static gint drag_start_y = -1;
 484 static gboolean drag_started = FALSE;
 485 static gint drag_off_x = -1;
 486 static gint drag_off_y = -1;
 487
 488 static void icon_button_press(GtkWidget *widget,
 489                               GdkEventButton *event,
 490                               IconWindow *win)
 491 {
 492         if (event->button == 1)
 493         {
 494                 drag_start_x = event->x_root;
 495                 drag_start_y = event->y_root;
 496                 drag_started = FALSE;
 497
 498                 drag_off_x = event->x;
 499                 drag_off_y = event->y;
 500         }
 501 }
 502
 503 static gboolean icon_motion_notify(GtkWidget *widget,
 504                                GdkEventMotion *event,
 505                                IconWindow *win)
 506 {
 507         if (event->state & GDK_BUTTON1_MASK)
 508         {
 509                 int dx = event->x_root - drag_start_x;
 510                 int dy = event->y_root - drag_start_y;
 511
 512                 if (!drag_started)
 513                 {
 514                         if (abs(dx) < 5 && abs(dy) < 5)
 515                                 return FALSE;
 516                         drag_started = TRUE;
 517                 }
 518
 519                 fixed_move_fast(GTK_FIXED(win->widget->parent),
 520                                 win->widget,
 521                                 event->x_root - drag_off_x,
 522                                 event->y_root - drag_off_y);
 523         }
 524
 525         return FALSE;
 526 }
 527
 528 static void button_released(GtkWidget *widget, IconWindow *win)
 529 {
 530         if (!drag_started)
 531                 uniconify(win);
 532 }
 533
 534 /* A window has been iconified -- display it on the screen */
 535 static void show_icon(IconWindow *win)
 536 {
 537         static MaskedPixmap *icon = NULL;
 538         GtkWidget *vbox;
 539
 540         g_return_if_fail(win->widget == NULL);
 541         g_return_if_fail(win->label == NULL);
 542
 543         if (!icon)
 544                 icon = load_pixmap("images/iconified.png");
 545
 546         win->widget = gtk_button_new();
 547         vbox = gtk_vbox_new(FALSE, 0);
 548         gtk_container_add(GTK_CONTAINER(win->widget), vbox);
 549
 550         gtk_box_pack_start(GTK_BOX(vbox),
 551                 gtk_image_new_from_pixbuf(icon->pixbuf),
 552                 FALSE, TRUE, 0);
 553
 554         gtk_button_set_relief(GTK_BUTTON(win->widget), GTK_RELIEF_NONE);
 555
 556         win->label = wrapped_label_new(win->text, 180);
 557
 558         update_style(NULL, win, NULL);
 559
 560         gtk_box_pack_start(GTK_BOX(vbox), win->label, FALSE, TRUE, 0);
 561
 562         gtk_widget_add_events(win->widget, GDK_BUTTON1_MOTION_MASK);
 563         g_signal_connect(win->widget, "button-press-event",
 564                         G_CALLBACK(icon_button_press), win);
 565         g_signal_connect(win->widget, "motion-notify-event",
 566                         G_CALLBACK(icon_motion_notify), win);
 567         g_signal_connect(win->widget, "released",
 568                         G_CALLBACK(button_released), win);
 569
 570         gtk_widget_show_all(vbox);      /* So the size comes out right */
 571         pinboard_add_widget(win->widget);
 572         gtk_widget_show(win->widget);
 573 }
 574
 575 /* A window has been destroyed/expanded -- remove its icon */
 576 static void hide_icon(IconWindow *win)
 577 {
 578         GtkWidget *widget = win->widget;
 579
 580         g_return_if_fail(widget != NULL);
 581
 582         win->widget = NULL;
 583         win->label = NULL;
 584         gtk_widget_destroy(widget);
 585 }
 586
 587 static void state_changed(IconWindow *win)
 588 {
 589         if (win->iconified)
 590         {
 591                 get_icon_name(win);
 592                 show_icon(win);
 593         }
 594         else
 595                 hide_icon(win);
 596 }
 597
 598 #if 0
 599 /* Set the _NET_WM_ICON_GEOMETRY property, which indicates where this window
 600  * will be iconified to. Should be inside a push/pop.
 601  */
 602 static void set_iconify_pos(IconWindow *win)
 603 {
 604         gint32 data[4];
 605
 606         data[0] = iconify_next_x;
 607         data[1] = iconify_next_y;
 608         data[2] = 100;
 609         data[3] = 32;
 610
 611         XChangeProperty(gdk_display, win->xwindow,
 612                         gdk_x11_atom_to_xatom(xa__NET_WM_ICON_GEOMETRY),
 613                         XA_CARDINAL, 32, PropModeReplace, (guchar *) data, 4);
 614 }
 615 #endif
 616
 617 static void update_style(gpointer key, gpointer data, gpointer user_data)
 618 {
 619         IconWindow *win = (IconWindow *) data;
 620
 621         if (win->widget)
 622         {
 623                 gtk_widget_modify_fg(win->label,
 624                                         GTK_STATE_NORMAL, &pin_text_fg_col);
 625                 gtk_widget_modify_bg(win->label,
 626                                         GTK_STATE_NORMAL, &pin_text_bg_col);
 627         }
 628 }
 629