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 <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 "options.h"
  40 #include "gui_support.h"
  41 #include "main.h"
  42 #include "pinboard.h"
  43 #include "pixmaps.h"
  44
  45 /* There is one of these for each window controlled by the window
  46  * manager (all tasks) in the _NET_CLIENT_LIST property.
  47  */
  48 typedef struct _IconWindow IconWindow;
  49
  50 struct _IconWindow {
  51         GtkWidget *widget;      /* Widget used for icon when iconified */
  52         GtkWidget *label;
  53         gchar *text;
  54         Window xwindow;
  55         gboolean iconified;
  56 };
  57
  58 static GdkAtom xa_WM_STATE = GDK_NONE;
  59 static GdkAtom xa_WM_NAME = GDK_NONE;
  60 static GdkAtom xa_WM_ICON_NAME = GDK_NONE;
  61 static GdkAtom xa_UTF8_STRING = GDK_NONE;
  62 static GdkAtom xa_TEXT = GDK_NONE;
  63 static GdkAtom xa__NET_WM_VISIBLE_NAME = GDK_NONE;
  64 static GdkAtom xa__NET_WM_ICON_NAME = GDK_NONE;
  65 static GdkAtom xa__NET_CLIENT_LIST = GDK_NONE;
  66 static GdkAtom xa__NET_WM_ICON_GEOMETRY = GDK_NONE;
  67
  68 /* We have selected destroy and property events on every window in
  69  * this table.
  70  */
  71 static GHashTable *known = NULL;        /* XID -> IconWindow */
  72
  73 /* Top-left corner of next icon to be created */
  74 static int iconify_next_x = 0;
  75 static int iconify_next_y = 0;
  76
  77 /* Static prototypes */
  78 static void remove_window(Window win);
  79 static void tasklist_update(gboolean to_empty);
  80 static GdkFilterReturn window_filter(GdkXEvent *xevent,
  81                                      GdkEvent *event,
  82                                      gpointer data);
  83 static guint xid_hash(XID *xid);
  84 static gboolean xid_equal(XID *a, XID *b);
  85 static void state_changed(IconWindow *win);
  86 static void show_icon(IconWindow *win);
  87 static void icon_win_free(IconWindow *win);
  88 static void set_iconify_pos(IconWindow *win);
  89 static void update_style(gpointer key, gpointer data, gpointer user_data);
  90
  91 /****************************************************************
  92  *                      EXTERNAL INTERFACE                      *
  93  ****************************************************************/
  94
  95 void tasklist_set_active(gboolean active)
  96 {
  97         static gboolean need_init = TRUE;
  98         static gboolean tasklist_active = FALSE;
  99
 100         if (active == tasklist_active)
 101                 return;
 102         tasklist_active = active;
 103
 104         if (need_init)
 105         {
 106                 GdkWindow *root;
 107
 108                 root = gdk_get_default_root_window();
 109
 110                 xa_WM_STATE = gdk_atom_intern("WM_STATE", FALSE);
 111                 xa_WM_ICON_NAME = gdk_atom_intern("WM_ICON_NAME", FALSE);
 112                 xa_WM_NAME = gdk_atom_intern("WM_NAME", FALSE);
 113                 xa_UTF8_STRING = gdk_atom_intern("UTF8_STRING", FALSE);
 114                 xa_TEXT = gdk_atom_intern("TEXT", FALSE);
 115                 xa__NET_CLIENT_LIST =
 116                                 gdk_atom_intern("_NET_CLIENT_LIST", FALSE);
 117                 xa__NET_WM_VISIBLE_NAME =
 118                         gdk_atom_intern("_NET_WM_VISIBLE_NAME", FALSE);
 119                 xa__NET_WM_ICON_NAME =
 120                         gdk_atom_intern("_NET_WM_ICON_NAME", FALSE);
 121                 xa__NET_WM_ICON_GEOMETRY =
 122                         gdk_atom_intern("_NET_WM_ICON_GEOMETRY", FALSE);
 123
 124                 known = g_hash_table_new_full((GHashFunc) xid_hash,
 125                                               (GEqualFunc) xid_equal,
 126                                               NULL,
 127                                               (GDestroyNotify) icon_win_free);
 128                 gdk_window_set_events(root, gdk_window_get_events(root) |
 129                                         GDK_PROPERTY_CHANGE_MASK);
 130                 need_init = FALSE;
 131         }
 132
 133         if (active)
 134                 gdk_window_add_filter(NULL, window_filter, NULL);
 135         else
 136                 gdk_window_remove_filter(NULL, window_filter, NULL);
 137
 138         tasklist_update(!active);
 139 }
 140
 141 /* User has changes the colours in the options box... */
 142 void tasklist_style_changed(void)
 143 {
 144         g_hash_table_foreach(known, update_style, NULL);
 145 }
 146
 147 /****************************************************************
 148  *                      INTERNAL FUNCTIONS                      *
 149  ****************************************************************/
 150
 151 static void icon_win_free(IconWindow *win)
 152 {
 153         g_return_if_fail(win->widget == NULL);
 154         g_return_if_fail(win->label == NULL);
 155
 156         if (win->text)
 157                 g_free(win->text);
 158         g_free(win);
 159 }
 160
 161 /* From gdk */
 162 static guint xid_hash(XID *xid)
 163 {
 164         return *xid;
 165 }
 166
 167 /* From gdk */
 168 static gboolean xid_equal(XID *a, XID *b)
 169 {
 170         return (*a == *b);
 171 }
 172
 173 static int wincmp(const void *a, const void *b)
 174 {
 175         const Window *aw = a;
 176         const Window *bw = b;
 177
 178         if (*aw < *bw)
 179                 return -1;
 180         else if (*aw > *bw)
 181                 return 1;
 182         else
 183                 return 0;
 184 }
 185
 186 /* Read the list of WINDOWs from (xwindow,atom), returning them
 187  * in a (sorted) Array of Windows. On error, an empty array is
 188  * returned.
 189  * Free the array afterwards.
 190  */
 191 static GArray *get_window_list(Window xwindow, GdkAtom atom)
 192 {
 193         GArray *array;
 194         Atom type;
 195         int format;
 196         gulong nitems;
 197         gulong bytes_after;
 198         Window *data;
 199         int err, result;
 200         int i;
 201
 202         array = g_array_new(FALSE, FALSE, sizeof(Window));
 203
 204         gdk_error_trap_push();
 205         type = None;
 206         result = XGetWindowProperty(gdk_display,
 207                         xwindow,
 208                         gdk_x11_atom_to_xatom(atom),
 209                         0, G_MAXLONG,
 210                         False, XA_WINDOW, &type, &format, &nitems,
 211                         &bytes_after, (guchar **)&data);
 212         err = gdk_error_trap_pop();
 213
 214         if (err != Success || result != Success)
 215                 return array;
 216
 217         if (type == XA_WINDOW)
 218         {
 219                 for (i = 0; i < nitems; i++)
 220                         g_array_append_val(array, data[i]);
 221
 222                 if (array->len)
 223                         g_array_sort(array, wincmp);
 224         }
 225
 226         XFree(data);
 227
 228         return array;
 229 }
 230
 231 static gchar *get_str(IconWindow *win, GdkAtom atom)
 232 {
 233         Atom rtype;
 234         int format;
 235         gulong nitems;
 236         gulong bytes_after;
 237         char *data, *str = NULL;
 238
 239         if (XGetWindowProperty(gdk_display, win->xwindow,
 240                         gdk_x11_atom_to_xatom(atom),
 241                         0, G_MAXLONG, False,
 242                         AnyPropertyType,
 243                         &rtype, &format, &nitems,
 244                         &bytes_after, (guchar **) &data) == Success && data)
 245         {
 246                 if (*data)
 247                         str = g_strdup(data);
 248                 XFree(data);
 249         }
 250
 251         return str;
 252 }
 253
 254 static void get_icon_name(IconWindow *win)
 255 {
 256         if (win->text)
 257         {
 258                 g_free(win->text);
 259                 win->text = NULL;
 260         }
 261
 262         win->text = get_str(win, xa__NET_WM_ICON_NAME);
 263         if (!win->text)
 264                 win->text = get_str(win, xa__NET_WM_VISIBLE_NAME);
 265         if (!win->text)
 266                 win->text = get_str(win, xa_WM_ICON_NAME);
 267         if (!win->text)
 268                 win->text = get_str(win, xa_WM_NAME);
 269         if (!win->text)
 270                 win->text = g_strdup(_("Window"));
 271 }
 272
 273 /* Call from within error_push/pop */
 274 static void window_check_status(IconWindow *win)
 275 {
 276         Atom type;
 277         int format;
 278         gulong nitems;
 279         gulong bytes_after;
 280         gint32 *data;
 281         gboolean iconic;
 282
 283         if (XGetWindowProperty(gdk_display, win->xwindow,
 284                         gdk_x11_atom_to_xatom(xa_WM_STATE),
 285                         0, 1, False,
 286                         gdk_x11_atom_to_xatom(xa_WM_STATE),
 287                         &type, &format, &nitems,
 288                         &bytes_after, (guchar **) &data) == Success && data)
 289         {
 290                 iconic = data[0] == 3;
 291                 XFree(data);
 292         }
 293         else
 294                 iconic = FALSE;
 295
 296         if (win->iconified == iconic)
 297                 return;
 298
 299         win->iconified = iconic;
 300
 301         state_changed(win);
 302 }
 303
 304 /* Called for all events on all windows */
 305 static GdkFilterReturn window_filter(GdkXEvent *xevent,
 306                                      GdkEvent *event,
 307                                      gpointer data)
 308 {
 309         XEvent *xev = (XEvent *) xevent;
 310         IconWindow *w;
 311
 312         if (xev->type == PropertyNotify)
 313         {
 314                 GdkAtom atom = gdk_x11_xatom_to_atom(xev->xproperty.atom);
 315                 Window win = ((XPropertyEvent *) xev)->window;
 316
 317                 if (atom == xa_WM_STATE)
 318                 {
 319                         w = g_hash_table_lookup(known, &win);
 320
 321                         if (w)
 322                         {
 323                                 gdk_error_trap_push();
 324                                 window_check_status(w);
 325                                 if (gdk_error_trap_pop() != Success)
 326                                         g_hash_table_remove(known, &win);
 327                         }
 328                 }
 329
 330                 if (atom == xa__NET_CLIENT_LIST)
 331                         tasklist_update(FALSE);
 332         }
 333
 334         return GDK_FILTER_CONTINUE;
 335 }
 336
 337 /* Window has been added to list of managed windows */
 338 static void add_window(Window win)
 339 {
 340         IconWindow *w;
 341
 342         /* g_print("[ New window %ld ]\n", (long) win); */
 343
 344         w = g_hash_table_lookup(known, &win);
 345
 346         if (!w)
 347         {
 348                 XWindowAttributes attr;
 349
 350                 gdk_error_trap_push();
 351
 352                 XGetWindowAttributes(gdk_display, win, &attr);
 353
 354                 XSelectInput(gdk_display, win, attr.your_event_mask |
 355                         PropertyChangeMask);
 356
 357                 if (gdk_error_trap_pop() != Success)
 358                         return;
 359
 360                 w = g_new(IconWindow, 1);
 361                 w->widget = NULL;
 362                 w->label = NULL;
 363                 w->text = NULL;
 364                 w->xwindow = win;
 365                 w->iconified = FALSE;
 366
 367                 g_hash_table_insert(known, &w->xwindow, w);
 368         }
 369
 370         gdk_error_trap_push();
 371
 372         window_check_status(w);
 373
 374         set_iconify_pos(w);
 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         GtkRequisition req;
 539         GtkWidget *vbox;
 540
 541         g_return_if_fail(win->widget == NULL);
 542         g_return_if_fail(win->label == NULL);
 543
 544         if (!icon)
 545                 icon = load_pixmap("images/iconified.png");
 546
 547         win->widget = gtk_button_new();
 548         vbox = gtk_vbox_new(FALSE, 0);
 549         gtk_container_add(GTK_CONTAINER(win->widget), vbox);
 550
 551         gtk_box_pack_start(GTK_BOX(vbox),
 552                 gtk_image_new_from_pixbuf(icon->pixbuf),
 553                 FALSE, TRUE, 0);
 554
 555         gtk_button_set_relief(GTK_BUTTON(win->widget), GTK_RELIEF_NONE);
 556
 557         win->label = gtk_label_new(win->text);
 558
 559         update_style(NULL, win, NULL);
 560
 561         gtk_box_pack_start(GTK_BOX(vbox), win->label, FALSE, TRUE, 0);
 562
 563         gtk_widget_add_events(win->widget, GDK_BUTTON1_MOTION_MASK);
 564         g_signal_connect(win->widget, "button-press-event",
 565                         G_CALLBACK(icon_button_press), win);
 566         g_signal_connect(win->widget, "motion-notify-event",
 567                         G_CALLBACK(icon_motion_notify), win);
 568         g_signal_connect(win->widget, "released",
 569                         G_CALLBACK(button_released), win);
 570
 571         pinboard_add_widget(win->widget, iconify_next_x, iconify_next_y);
 572         gtk_widget_show_all(win->widget);
 573         gtk_widget_size_request(win->widget, &req);
 574
 575         iconify_next_y += req.height;
 576         if (iconify_next_y + req.height > screen_height)
 577                 iconify_next_y = 0;
 578 }
 579
 580 /* A window has been destroyed/expanded -- remove its icon */
 581 static void hide_icon(IconWindow *win)
 582 {
 583         GtkWidget *widget = win->widget;
 584
 585         g_return_if_fail(widget != NULL);
 586
 587         win->widget = NULL;
 588         win->label = NULL;
 589         gtk_widget_destroy(widget);
 590 }
 591
 592 static void state_changed(IconWindow *win)
 593 {
 594         if (win->iconified)
 595         {
 596                 get_icon_name(win);
 597                 show_icon(win);
 598         }
 599         else
 600                 hide_icon(win);
 601 }
 602
 603 /* Set the _NET_WM_ICON_GEOMETRY property, which indicates where this window
 604  * will be iconified to. Should be inside a push/pop.
 605  */
 606 static void set_iconify_pos(IconWindow *win)
 607 {
 608         gint32 data[4];
 609
 610         data[0] = iconify_next_x;
 611         data[1] = iconify_next_y;
 612         data[2] = 100;
 613         data[3] = 32;
 614
 615         XChangeProperty(gdk_display, win->xwindow,
 616                         gdk_x11_atom_to_xatom(xa__NET_WM_ICON_GEOMETRY),
 617                         XA_CARDINAL, 32, PropModeReplace, (guchar *) data, 4);
 618 }
 619
 620 static void update_style(gpointer key, gpointer data, gpointer user_data)
 621 {
 622         IconWindow *win = (IconWindow *) data;
 623
 624         if (win->widget)
 625         {
 626                 gtk_widget_modify_fg(win->label,
 627                                         GTK_STATE_NORMAL, &pin_text_fg_col);
 628                 gtk_widget_modify_bg(win->label,
 629                                         GTK_STATE_NORMAL, &pin_text_bg_col);
 630         }
 631 }
 632