ROX-Filer/src/gui_support.c

   1 /*
   2  * $Id$
   3  *
   4  * ROX-Filer, filer for the ROX desktop project
   5  * Copyright (C) 2000, Thomas Leonard, <tal197@users.sourceforge.net>.
   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 /* gui_support.c - general (GUI) support routines */
  23
  24 #include "config.h"
  25
  26 #include <stdio.h>
  27 #include <stdlib.h>
  28 #include <string.h>
  29 #include <sys/param.h>
  30 #include <stdarg.h>
  31 #include <errno.h>
  32
  33 #include <X11/Xlib.h>
  34 #include <X11/Xatom.h>
  35 #include <gdk/gdkx.h>
  36 #include <gdk/gdk.h>
  37
  38 #include "global.h"
  39
  40 #include "main.h"
  41 #include "gui_support.h"
  42 #include "pixmaps.h"
  43
  44 GdkFont         *item_font = NULL;
  45 GdkFont         *fixed_font = NULL;
  46 GtkStyle        *fixed_style = NULL;
  47 gint            fixed_width;
  48 GdkColor        red = {0, 0xffff, 0, 0};
  49 GdkGC           *red_gc = NULL; /* Not automatically initialised */
  50 gint            screen_width, screen_height;
  51
  52 static GdkAtom xa_cardinal;
  53
  54 void gui_support_init()
  55 {
  56         fixed_font = gdk_font_load("fixed");
  57         item_font = gtk_widget_get_default_style()->font;
  58
  59         fixed_style = gtk_style_copy(gtk_widget_get_default_style());
  60         fixed_style->font = fixed_font;
  61
  62         fixed_width = gdk_string_width(fixed_font, "m");
  63
  64         xa_cardinal  = gdk_atom_intern("CARDINAL", FALSE);
  65
  66         gdk_color_alloc(gtk_widget_get_default_colormap(), &red);
  67
  68         /* This call starts returning strange values after a while, so get
  69          * the result here during init.
  70          */
  71         gdk_window_get_size(GDK_ROOT_PARENT(), &screen_width, &screen_height);
  72 }
  73
  74 static void choice_clicked(GtkWidget *widget, gpointer number)
  75 {
  76         int     *choice_return;
  77
  78         choice_return = gtk_object_get_data(GTK_OBJECT(widget),
  79                         "choice_return");
  80
  81         if (choice_return)
  82                 *choice_return = (int) number;
  83 }
  84
  85 /* Open a modal dialog box showing a message.
  86  * The user can choose from a selection of buttons at the bottom.
  87  * Returns -1 if the window is destroyed, or the number of the button
  88  * if one is clicked (starting from zero).
  89  */
  90 int get_choice(char *title,
  91                char *message,
  92                int number_of_buttons, ...)
  93 {
  94         GtkWidget       *dialog;
  95         GtkWidget       *vbox, *action_area, *separator;
  96         GtkWidget       *text, *text_container;
  97         GtkWidget       *button = NULL;
  98         int             i, retval;
  99         va_list ap;
 100         int             choice_return;
 101
 102         dialog = gtk_window_new(GTK_WINDOW_DIALOG);
 103         gtk_window_set_modal(GTK_WINDOW(dialog), TRUE);
 104         gtk_window_set_title(GTK_WINDOW(dialog), title);
 105         gtk_window_set_position(GTK_WINDOW(dialog), GTK_WIN_POS_CENTER);
 106
 107         vbox = gtk_vbox_new(FALSE, 0);
 108         gtk_container_add(GTK_CONTAINER(dialog), vbox);
 109
 110         action_area = gtk_hbox_new(TRUE, 5);
 111         gtk_container_set_border_width(GTK_CONTAINER(action_area), 10);
 112         gtk_box_pack_end(GTK_BOX(vbox), action_area, FALSE, TRUE, 0);
 113
 114         separator = gtk_hseparator_new ();
 115         gtk_box_pack_end(GTK_BOX(vbox), separator, FALSE, TRUE, 0);
 116
 117         text = gtk_label_new(message);
 118         gtk_label_set_line_wrap(GTK_LABEL(text), TRUE);
 119         text_container = gtk_event_box_new();
 120         gtk_container_set_border_width(GTK_CONTAINER(text_container), 32);
 121         gtk_container_add(GTK_CONTAINER(text_container), text);
 122
 123         gtk_box_pack_start(GTK_BOX(vbox),
 124                         text_container,
 125                         TRUE, TRUE, 0);
 126
 127         va_start(ap, number_of_buttons);
 128
 129         for (i = 0; i < number_of_buttons; i++)
 130         {
 131                 button = gtk_button_new_with_label(va_arg(ap, char *));
 132                 gtk_object_set_data(GTK_OBJECT(button), "choice_return",
 133                                 &choice_return);
 134                 gtk_box_pack_start(GTK_BOX(action_area),
 135                                 button,
 136                                 TRUE, TRUE, 16);
 137                 gtk_signal_connect(GTK_OBJECT(button), "clicked",
 138                                 choice_clicked, (gpointer) i);
 139                 if (i == 0)
 140                         gtk_window_set_focus(GTK_WINDOW(dialog), button);
 141         }
 142         if (!i)
 143                 gtk_widget_grab_focus(button);
 144
 145         va_end(ap);
 146
 147         gtk_object_set_data(GTK_OBJECT(dialog), "choice_return",
 148                                 &choice_return);
 149         gtk_signal_connect(GTK_OBJECT(dialog), "destroy", choice_clicked,
 150                         (gpointer) -1);
 151
 152         choice_return = -2;
 153
 154         gtk_widget_show_all(dialog);
 155
 156         while (choice_return == -2)
 157                 g_main_iteration(TRUE);
 158
 159         retval = choice_return;
 160
 161         if (retval != -1)
 162                 gtk_widget_destroy(dialog);
 163
 164         return retval;
 165 }
 166
 167 /* Display a message in a window */
 168 void report_error(char *title, char *message)
 169 {
 170         g_return_if_fail(message != NULL);
 171
 172         if (!title)
 173                 title = _("Error");
 174
 175         get_choice(title, message, 1, "OK");
 176 }
 177
 178 void set_cardinal_property(GdkWindow *window, GdkAtom prop, guint32 value)
 179 {
 180         gdk_property_change(window, prop, xa_cardinal, 32,
 181                                 GDK_PROP_MODE_REPLACE, (gchar *) &value, 1);
 182 }
 183
 184 /* NB: Also used for pinned icons.
 185  * TODO: Set the level here too.
 186  */
 187 void make_panel_window(GdkWindow *window)
 188 {
 189         static gboolean need_init = TRUE;
 190         static GdkAtom  xa_state;
 191
 192         if (need_init)
 193         {
 194                 xa_state = gdk_atom_intern("_WIN_STATE", FALSE);
 195                 need_init = FALSE;
 196         }
 197
 198         gdk_window_set_decorations(window, 0);
 199         gdk_window_set_functions(window, 0);
 200
 201         set_cardinal_property(window, xa_state,
 202                         WIN_STATE_STICKY | WIN_STATE_HIDDEN |
 203                         WIN_STATE_FIXED_POSITION | WIN_STATE_ARRANGE_IGNORE);
 204 }
 205
 206 gint hide_dialog_event(GtkWidget *widget, GdkEvent *event, gpointer window)
 207 {
 208         gtk_widget_hide((GtkWidget *) window);
 209
 210         return TRUE;
 211 }
 212
 213 static gboolean error_idle_cb(gpointer data)
 214 {
 215         char    **error = (char **) data;
 216
 217         report_error(error[0], error[1]);
 218         g_free(error[0]);
 219         g_free(error[1]);
 220         error[0] = error[1] = NULL;
 221
 222         if (--number_of_windows == 0)
 223                 gtk_main_quit();
 224
 225         return FALSE;
 226 }
 227
 228 /* Display an error next time we are idle */
 229 void delayed_error(char *title, char *error)
 230 {
 231         static char *delayed_error_data[2] = {NULL, NULL};
 232         gboolean already_open;
 233
 234         g_return_if_fail(error != NULL);
 235
 236         already_open = delayed_error_data[1] != NULL;
 237
 238         g_free(delayed_error_data[0]);
 239         g_free(delayed_error_data[1]);
 240
 241         delayed_error_data[0] = g_strdup(title);
 242         delayed_error_data[1] = g_strdup(error);
 243
 244         if (already_open)
 245                 return;
 246
 247         gtk_idle_add(error_idle_cb, delayed_error_data);
 248
 249         number_of_windows++;
 250 }
 251
 252 /* Load the file into memory. Return TRUE on success.
 253  * Block is zero terminated (but this is not included in the length).
 254  */
 255 gboolean load_file(char *pathname, char **data_out, long *length_out)
 256 {
 257         FILE            *file;
 258         long            length;
 259         char            *buffer;
 260         gboolean        retval = FALSE;
 261
 262         file = fopen(pathname, "r");
 263
 264         if (!file)
 265         {
 266                 guchar  *message;
 267
 268                 message = g_strdup_printf("open(%s): %s",
 269                                 pathname, g_strerror(errno));
 270                 delayed_error(PROJECT, message);
 271                 g_free(message);
 272                 return FALSE;
 273         }
 274
 275         fseek(file, 0, SEEK_END);
 276         length = ftell(file);
 277
 278         buffer = malloc(length + 1);
 279         if (buffer)
 280         {
 281                 fseek(file, 0, SEEK_SET);
 282                 fread(buffer, 1, length, file);
 283
 284                 if (ferror(file))
 285                 {
 286                         guchar *tmp;
 287
 288                         tmp = g_strdup_printf("%s: %s\n",
 289                                         pathname, g_strerror(errno));
 290                         delayed_error(_("Error reading file"), tmp);
 291                         g_free(tmp);
 292                         g_free(buffer);
 293                 }
 294                 else
 295                 {
 296                         *data_out = buffer;
 297                         *length_out = length;
 298                         buffer[length] = '\0';
 299                         retval = TRUE;
 300                 }
 301         }
 302         else
 303                 delayed_error(PROJECT,
 304                         _("Can't allocate memory for buffer to "
 305                                 "load this file"));
 306
 307         fclose(file);
 308
 309         return retval;
 310 }
 311
 312 GtkWidget *new_help_button(HelpFunc show_help, gpointer data)
 313 {
 314         GtkWidget       *b, *icon;
 315
 316         b = gtk_button_new();
 317         gtk_button_set_relief(GTK_BUTTON(b), GTK_RELIEF_NONE);
 318         icon = gtk_pixmap_new(im_help->pixmap, im_help->mask);
 319         gtk_container_add(GTK_CONTAINER(b), icon);
 320         gtk_signal_connect_object(GTK_OBJECT(b), "clicked", show_help, data);
 321
 322         GTK_WIDGET_UNSET_FLAGS(b, GTK_CAN_FOCUS);
 323
 324         return b;
 325 }
 326
 327 /* Read file into memory. Call parse_line(guchar *line) for each line
 328  * in the file. Callback returns NULL on success, or an error message
 329  * if something went wrong. Only the first error is displayed to the user.
 330  */
 331 void parse_file(char *path, ParseFunc *parse_line)
 332 {
 333         char            *data;
 334         long            length;
 335         gboolean        seen_error = FALSE;
 336
 337         if (load_file(path, &data, &length))
 338         {
 339                 char *eol, *error;
 340                 char *line = data;
 341                 int  line_number = 1;
 342
 343                 while (line && *line)
 344                 {
 345                         eol = strchr(line, '\n');
 346                         if (eol)
 347                                 *eol = '\0';
 348
 349                         error = parse_line(line);
 350
 351                         if (error && !seen_error)
 352                         {
 353                                 GString *message;
 354
 355                                 message = g_string_new(NULL);
 356                                 g_string_sprintf(message,
 357                 _("Error in '%s' file at line %d: "
 358                 "\n\"%s\"\n"
 359                 "This may be due to upgrading from a previous version of "
 360                 "ROX-Filer. Open the Options window and click on Save.\n"
 361                 "Further errors will be ignored."),
 362                                         path,
 363                                         line_number,
 364                                         error);
 365                                 delayed_error(PROJECT, message->str);
 366                                 g_string_free(message, TRUE);
 367                                 seen_error = TRUE;
 368                         }
 369
 370                         if (!eol)
 371                                 break;
 372                         line = eol + 1;
 373                         line_number++;
 374                 }
 375                 g_free(data);
 376         }
 377 }
 378
 379 /* Sets up a proxy window for DnD on the specified X window.
 380  * Courtesy of Owen Taylor (taken from gmc).
 381  */
 382 gboolean setup_xdnd_proxy(guint32 xid, GdkWindow *proxy_window)
 383 {
 384         GdkAtom xdnd_proxy_atom;
 385         Window  proxy_xid;
 386         Atom    type;
 387         int     format;
 388         unsigned long nitems, after;
 389         Window  *proxy_data;
 390         Window  proxy;
 391         guint32 old_warnings;
 392
 393         XGrabServer(GDK_DISPLAY());
 394
 395         xdnd_proxy_atom = gdk_atom_intern("XdndProxy", FALSE);
 396         proxy_xid = GDK_WINDOW_XWINDOW(proxy_window);
 397         type = None;
 398         proxy = None;
 399
 400         old_warnings = gdk_error_warnings;
 401
 402         gdk_error_code = 0;
 403         gdk_error_warnings = 0;
 404
 405         /* Check if somebody else already owns drops on the root window */
 406
 407         XGetWindowProperty(GDK_DISPLAY(), xid,
 408                            xdnd_proxy_atom, 0,
 409                            1, False, AnyPropertyType,
 410                            &type, &format, &nitems, &after,
 411                            (guchar **) &proxy_data);
 412
 413         if (type != None)
 414         {
 415                 if (format == 32 && nitems == 1)
 416                         proxy = *proxy_data;
 417
 418                 XFree(proxy_data);
 419         }
 420
 421         /* The property was set, now check if the window it points to exists
 422          * and has a XdndProxy property pointing to itself.
 423          */
 424         if (proxy)
 425         {
 426                 XGetWindowProperty(GDK_DISPLAY(), proxy,
 427                                     xdnd_proxy_atom, 0,
 428                                     1, False, AnyPropertyType,
 429                                     &type, &format, &nitems, &after,
 430                                    (guchar **) &proxy_data);
 431
 432                 if (!gdk_error_code && type != None)
 433                 {
 434                         if (format == 32 && nitems == 1)
 435                                 if (*proxy_data != proxy)
 436                                         proxy = GDK_NONE;
 437
 438                         XFree(proxy_data);
 439                 }
 440                 else
 441                         proxy = GDK_NONE;
 442         }
 443
 444         if (!proxy)
 445         {
 446                 /* OK, we can set the property to point to us */
 447
 448                 XChangeProperty(GDK_DISPLAY(), xid,
 449                                 xdnd_proxy_atom,
 450                                 gdk_atom_intern("WINDOW", FALSE),
 451                                 32, PropModeReplace,
 452                                 (guchar *) &proxy_xid, 1);
 453         }
 454
 455         gdk_error_code = 0;
 456         gdk_error_warnings = old_warnings;
 457
 458         XUngrabServer(GDK_DISPLAY());
 459         gdk_flush();
 460
 461         if (!proxy)
 462         {
 463                 /* Mark our window as a valid proxy window with a XdndProxy
 464                  * property pointing recursively;
 465                  */
 466                 XChangeProperty(GDK_DISPLAY(), proxy_xid,
 467                                 xdnd_proxy_atom,
 468                                 gdk_atom_intern("WINDOW", FALSE),
 469                                 32, PropModeReplace,
 470                                 (guchar *) &proxy_xid, 1);
 471         }
 472
 473         return !proxy;
 474 }
 475
 476 /* xid is the window (usually the root) which points to the proxy */
 477 void release_xdnd_proxy(guint32 xid)
 478 {
 479         GdkAtom xdnd_proxy_atom;
 480
 481         xdnd_proxy_atom = gdk_atom_intern("XdndProxy", FALSE);
 482
 483         XDeleteProperty(GDK_DISPLAY(), xid, xdnd_proxy_atom);
 484 }
 485
 486 /* Looks for the proxy window to get root window clicks from the window
 487  * manager. Taken from gmc. NULL if there is no proxy window.
 488  */
 489 GdkWindow *find_click_proxy_window(void)
 490 {
 491         GdkAtom click_proxy_atom;
 492         Atom type;
 493         int format;
 494         unsigned long nitems, after;
 495         Window *proxy_data;
 496         Window proxy;
 497         guint32 old_warnings;
 498         GdkWindow *proxy_gdk_window;
 499
 500         XGrabServer(GDK_DISPLAY());
 501
 502         click_proxy_atom = gdk_atom_intern("_WIN_DESKTOP_BUTTON_PROXY", FALSE);
 503         type = None;
 504         proxy = None;
 505
 506         old_warnings = gdk_error_warnings;
 507
 508         gdk_error_code = 0;
 509         gdk_error_warnings = 0;
 510
 511         /* Check if the proxy window exists */
 512
 513         XGetWindowProperty(GDK_DISPLAY(), GDK_ROOT_WINDOW(),
 514                            click_proxy_atom, 0,
 515                            1, False, AnyPropertyType,
 516                            &type, &format, &nitems, &after,
 517                            (guchar **) &proxy_data);
 518
 519         if (type != None)
 520         {
 521                 if (format == 32 && nitems == 1)
 522                         proxy = *proxy_data;
 523
 524                 XFree(proxy_data);
 525         }
 526
 527         /* If the property was set, check if the window it points to exists
 528          * and has a _WIN_DESKTOP_BUTTON_PROXY property pointing to itself.
 529          */
 530
 531         if (proxy)
 532         {
 533                 XGetWindowProperty(GDK_DISPLAY(), proxy,
 534                                    click_proxy_atom, 0,
 535                                    1, False, AnyPropertyType,
 536                                    &type, &format, &nitems, &after,
 537                                    (guchar **) &proxy_data);
 538
 539                 if (!gdk_error_code && type != None)
 540                 {
 541                         if (format == 32 && nitems == 1)
 542                                 if (*proxy_data != proxy)
 543                                         proxy = GDK_NONE;
 544
 545                         XFree(proxy_data);
 546                 }
 547                 else
 548                         proxy = GDK_NONE;
 549         }
 550
 551         gdk_error_code = 0;
 552         gdk_error_warnings = old_warnings;
 553
 554         XUngrabServer(GDK_DISPLAY());
 555         gdk_flush();
 556
 557         if (proxy)
 558                 proxy_gdk_window = gdk_window_foreign_new(proxy);
 559         else
 560                 proxy_gdk_window = NULL;
 561
 562         return proxy_gdk_window;
 563 }
 564
 565 /* Returns the position of the pointer.
 566  * TRUE if any modifier keys or mouse buttons are pressed.
 567  */
 568 gboolean get_pointer_xy(int *x, int *y)
 569 {
 570         Window  root, child;
 571         int     win_x, win_y;
 572         unsigned int mask;
 573
 574         XQueryPointer(GDK_DISPLAY(), GDK_ROOT_WINDOW(),
 575                         &root, &child, x, y, &win_x, &win_y, &mask);
 576
 577         return mask != 0;
 578 }
 579
 580 #define DECOR_BORDER 32
 581
 582 /* Centre the window at these coords */
 583 void centre_window(GdkWindow *window, int x, int y)
 584 {
 585         int     w, h;
 586
 587         g_return_if_fail(window != NULL);
 588
 589         gdk_window_get_size(window, &w, &h);
 590
 591         x -= w / 2;
 592         y -= h / 2;
 593
 594         gdk_window_move(window,
 595                 CLAMP(x, DECOR_BORDER, screen_width - w - DECOR_BORDER),
 596                 CLAMP(y, DECOR_BORDER, screen_height - h - DECOR_BORDER));
 597 }