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