ROX-Filer/src/gui_support.c

   1 /* vi: set cindent:
   2  * $Id$
   3  *
   4  * ROX-Filer, filer for the ROX desktop project
   5  * By Thomas Leonard, <tal197@ecs.soton.ac.uk>.
   6  */
   7
   8 /* gui_support.c - general (GUI) support routines */
   9
  10 #include <stdio.h>
  11 #include <stdlib.h>
  12 #include <string.h>
  13 #include <sys/param.h>
  14 #include <stdarg.h>
  15 #include <errno.h>
  16
  17 #include <glib.h>
  18 #include <X11/Xlib.h>
  19 #include <X11/Xatom.h>
  20 #include <gdk/gdk.h>
  21
  22 #include "main.h"
  23 #include "gui_support.h"
  24
  25 static GdkAtom xa_win_state;
  26 static GdkAtom xa_win_layer;
  27 static GdkAtom xa_win_hints;
  28 static GdkAtom xa_cardinal;
  29
  30 void gui_support_init()
  31 {
  32         xa_win_state = gdk_atom_intern("_WIN_STATE", FALSE);
  33         xa_win_layer = gdk_atom_intern("_WIN_LAYER", FALSE);
  34         xa_win_hints = gdk_atom_intern("_WIN_HINTS", FALSE);
  35         xa_cardinal  = gdk_atom_intern("CARDINAL", FALSE);
  36 }
  37
  38 static void choice_clicked(GtkWidget *widget, gpointer number)
  39 {
  40         int     *choice_return;
  41
  42         choice_return = gtk_object_get_data(GTK_OBJECT(widget),
  43                         "choice_return");
  44
  45         if (choice_return)
  46                 *choice_return = (int) number;
  47 }
  48
  49 /* Open a modal dialog box showing a message.
  50  * The user can choose from a selection of buttons at the bottom.
  51  * Returns -1 if the window is destroyed, or the number of the button
  52  * if one is clicked (starting from zero).
  53  */
  54 int get_choice(char *title,
  55                char *message,
  56                int number_of_buttons, ...)
  57 {
  58         GtkWidget       *dialog;
  59         GtkWidget       *vbox, *action_area, *separator;
  60         GtkWidget       *text, *text_container;
  61         GtkWidget       *button;
  62         int             i, retval;
  63         va_list ap;
  64         int             choice_return;
  65
  66         dialog = gtk_window_new(GTK_WINDOW_DIALOG);
  67         gtk_window_set_modal(GTK_WINDOW(dialog), TRUE);
  68         gtk_window_set_title(GTK_WINDOW(dialog), title);
  69         gtk_window_set_position(GTK_WINDOW(dialog), GTK_WIN_POS_CENTER);
  70
  71         vbox = gtk_vbox_new(FALSE, 0);
  72         gtk_container_add(GTK_CONTAINER(dialog), vbox);
  73
  74         action_area = gtk_hbox_new(TRUE, 5);
  75         gtk_container_set_border_width(GTK_CONTAINER(action_area), 10);
  76         gtk_box_pack_end(GTK_BOX(vbox), action_area, FALSE, TRUE, 0);
  77
  78         separator = gtk_hseparator_new ();
  79         gtk_box_pack_end(GTK_BOX(vbox), separator, FALSE, TRUE, 0);
  80
  81         text = gtk_label_new(message);
  82         gtk_label_set_line_wrap(GTK_LABEL(text), TRUE);
  83         text_container = gtk_event_box_new();
  84         gtk_container_set_border_width(GTK_CONTAINER(text_container), 32);
  85         gtk_container_add(GTK_CONTAINER(text_container), text);
  86
  87         gtk_box_pack_start(GTK_BOX(vbox),
  88                         text_container,
  89                         TRUE, TRUE, 0);
  90
  91         va_start(ap, number_of_buttons);
  92
  93         for (i = 0; i < number_of_buttons; i++)
  94         {
  95                 button = gtk_button_new_with_label(va_arg(ap, char *));
  96                 gtk_object_set_data(GTK_OBJECT(button), "choice_return",
  97                                 &choice_return);
  98                 gtk_box_pack_start(GTK_BOX(action_area),
  99                                 button,
 100                                 TRUE, TRUE, 16);
 101                 gtk_signal_connect(GTK_OBJECT(button), "clicked",
 102                                 choice_clicked, (gpointer) i);
 103         }
 104         if (!i)
 105                 gtk_widget_grab_focus(button);
 106
 107         va_end(ap);
 108
 109         gtk_object_set_data(GTK_OBJECT(dialog), "choice_return",
 110                                 &choice_return);
 111         gtk_signal_connect(GTK_OBJECT(dialog), "destroy", choice_clicked,
 112                         (gpointer) -1);
 113
 114         choice_return = -2;
 115
 116         gtk_widget_show_all(dialog);
 117
 118         while (choice_return == -2)
 119                 g_main_iteration(TRUE);
 120
 121         retval = choice_return;
 122
 123         if (retval != -1)
 124                 gtk_widget_destroy(dialog);
 125
 126         return retval;
 127 }
 128
 129 /* Display a message in a window */
 130 void report_error(char *title, char *message)
 131 {
 132         g_return_if_fail(message != NULL);
 133
 134         if (!title)
 135                 title = "Error";
 136
 137         get_choice(title, message, 1, "OK");
 138 }
 139
 140 void set_cardinal_property(GdkWindow *window, GdkAtom prop, guint32 value)
 141 {
 142         gdk_property_change(window, prop, xa_cardinal, 32,
 143                                 GDK_PROP_MODE_REPLACE, (gchar *) &value, 1);
 144 }
 145
 146 void make_panel_window(GdkWindow *window)
 147 {
 148         static gboolean need_init = TRUE;
 149         static GdkAtom  xa_state;
 150
 151         if (need_init)
 152         {
 153                 xa_state = gdk_atom_intern("_WIN_STATE", FALSE);
 154                 need_init = FALSE;
 155         }
 156
 157         gdk_window_set_decorations(window, 0);
 158         gdk_window_set_functions(window, 0);
 159
 160         set_cardinal_property(window, xa_state,
 161                         WIN_STATE_STICKY | WIN_STATE_HIDDEN |
 162                         WIN_STATE_FIXED_POSITION | WIN_STATE_ARRANGE_IGNORE);
 163 }
 164
 165 gint hide_dialog_event(GtkWidget *widget, GdkEvent *event, gpointer window)
 166 {
 167         gtk_widget_hide((GtkWidget *) window);
 168
 169         return TRUE;
 170 }
 171
 172 static gboolean error_idle_cb(gpointer data)
 173 {
 174         char    **error = (char **) data;
 175
 176         report_error(error[0], error[1]);
 177         g_free(error[0]);
 178         g_free(error[1]);
 179         error[0] = error[1] = NULL;
 180
 181         if (--number_of_windows == 0)
 182                 gtk_main_quit();
 183
 184         return FALSE;
 185 }
 186
 187 /* Display an error next time we are idle */
 188 void delayed_error(char *title, char *error)
 189 {
 190         static char *delayed_error_data[2] = {NULL, NULL};
 191         gboolean already_open;
 192
 193         g_return_if_fail(error != NULL);
 194
 195         already_open = delayed_error_data[1] != NULL;
 196
 197         g_free(delayed_error_data[0]);
 198         g_free(delayed_error_data[1]);
 199
 200         delayed_error_data[0] = g_strdup(title);
 201         delayed_error_data[1] = g_strdup(error);
 202
 203         if (already_open)
 204                 return;
 205
 206         gtk_idle_add(error_idle_cb, delayed_error_data);
 207
 208         number_of_windows++;
 209 }
 210
 211 /* Load the file into memory. Return TRUE on success.
 212  * Block is zero terminated (but this is not included in the length).
 213  */
 214 gboolean load_file(char *pathname, char **data_out, long *length_out)
 215 {
 216         FILE            *file;
 217         long            length;
 218         char            *buffer;
 219         gboolean        retval = FALSE;
 220
 221         file = fopen(pathname, "r");
 222
 223         if (!file)
 224         {
 225                 delayed_error("Opening file for DND", g_strerror(errno));
 226                 return FALSE;
 227         }
 228
 229         fseek(file, 0, SEEK_END);
 230         length = ftell(file);
 231
 232         buffer = malloc(length + 1);
 233         if (buffer)
 234         {
 235                 fseek(file, 0, SEEK_SET);
 236                 fread(buffer, 1, length, file);
 237
 238                 if (ferror(file))
 239                 {
 240                         delayed_error("Loading file for DND",
 241                                                 g_strerror(errno));
 242                         g_free(buffer);
 243                 }
 244                 else
 245                 {
 246                         *data_out = buffer;
 247                         *length_out = length;
 248                         buffer[length] = '\0';
 249                         retval = TRUE;
 250                 }
 251         }
 252         else
 253                 delayed_error("Loading file for DND",
 254                                 "Can't allocate memory for buffer to "
 255                                 "transfer this file");
 256
 257         fclose(file);
 258
 259         return retval;
 260 }