src/gtk/filesel.c

   1 /*
   2  * Sylpheed -- a GTK+ based, lightweight, and fast e-mail client
   3  * Copyright (C) 1999-2003 Hiroyuki Yamamoto
   4  *
   5  * This program is free software; you can redistribute it and/or modify
   6  * it under the terms of the GNU General Public License as published by
   7  * the Free Software Foundation; either version 2 of the License, or
   8  * (at your option) any later version.
   9  *
  10  * This program is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  * GNU General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public License
  16  * along with this program; if not, write to the Free Software
  17  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  18  */
  19
  20 #include <glib.h>
  21 #include <gdk/gdkkeysyms.h>
  22 #include <gtk/gtkwidget.h>
  23 #include <gtk/gtkfilesel.h>
  24 #include <gtk/gtkentry.h>
  25 #include <gtk/gtkmain.h>
  26 #include <gtk/gtksignal.h>
  27 #include <gtk/gtkeditable.h>
  28
  29 #include "sylpheed.h"
  30 #include "filesel.h"
  31 #include "manage_window.h"
  32 #include "gtkutils.h"
  33 #include "utils.h"
  34
  35 static GtkWidget *filesel;
  36 static gboolean filesel_ack;
  37 static gboolean filesel_fin;
  38 static gchar *filesel_oldfilename;
  39
  40 static void filesel_create(const gchar *title, gboolean multiple_files);
  41 static void filesel_ok_cb(GtkWidget *widget, gpointer data);
  42 static void filesel_cancel_cb(GtkWidget *widget, gpointer data);
  43 static gint delete_event(GtkWidget *widget, GdkEventAny *event, gpointer data);
  44 static void key_pressed(GtkWidget *widget, GdkEventKey *event, gpointer data);
  45
  46 static void filesel_file_list_select_row_multi(GtkCList *clist, gint row, gint col,
  47                                                GdkEventButton *event, gpointer userdata);
  48 static void filesel_file_list_select_row_single(GtkCList *clist, gint row, gint col,
  49                                                 GdkEventButton *event, gpointer userdata);
  50
  51 static void filesel_dir_list_select_row_multi(GtkCList *clist, gint row, gint col,
  52                                               GdkEventButton *event, gpointer userdata);
  53 static void filesel_dir_list_select_row_single(GtkCList *clist, gint row, gint col,
  54                                                GdkEventButton *event, gpointer userdata);
  55
  56 static GList *filesel_get_multiple_filenames(void);
  57
  58 gchar *filesel_select_file(const gchar *title, const gchar *file)
  59 {
  60         static gchar *filename = NULL;
  61         static gchar *cwd = NULL;
  62         gchar *startdir = NULL;
  63         gchar *realfile = NULL;
  64
  65         filesel_create(title, FALSE);
  66
  67         manage_window_set_transient(GTK_WINDOW(filesel));
  68
  69         if (filename) {
  70                 g_free(filename);
  71                 filename = NULL;
  72         }
  73
  74         /* try to extract the directory and filename from file */
  75         if (file) {
  76                 startdir = g_dirname(file);
  77                 realfile = g_basename(file);
  78         } else {
  79                 realfile = file;
  80         }
  81
  82         /* use sylpheed's startup directory if we can't find anything useful */
  83         if (!startdir || !strcmp(startdir, ".")) {
  84                 cwd = g_strconcat(sylpheed_get_startup_dir(), G_DIR_SEPARATOR_S, NULL);
  85         } else {
  86                 cwd = g_strconcat(startdir, G_DIR_SEPARATOR_S, NULL);
  87         }
  88
  89         gtk_file_selection_set_filename(GTK_FILE_SELECTION(filesel), cwd);
  90
  91         if (realfile) {
  92                 gtk_file_selection_set_filename(GTK_FILE_SELECTION(filesel),
  93                                                 realfile);
  94                 filesel_oldfilename = g_strdup(realfile);
  95         } else {
  96                 filesel_oldfilename = NULL;
  97         }
  98
  99         gtk_widget_show(filesel);
 100
 101         filesel_ack = filesel_fin = FALSE;
 102
 103         while (filesel_fin == FALSE)
 104                 gtk_main_iteration();
 105
 106         if (filesel_ack) {
 107                 gchar *str;
 108
 109                 str = gtk_file_selection_get_filename
 110                         (GTK_FILE_SELECTION(filesel));
 111                 if (str && str[0] != '\0') {
 112                         gchar *dir;
 113
 114                         filename = g_strdup(str);
 115                         dir = g_dirname(str);
 116                         g_free(cwd);
 117                         cwd = g_strconcat(dir, G_DIR_SEPARATOR_S, NULL);
 118                         g_free(dir);
 119                 }
 120         }
 121
 122         if (filesel_oldfilename)
 123                 g_free(filesel_oldfilename);
 124
 125         if (startdir);
 126                 g_free(startdir);
 127
 128         manage_window_focus_out(filesel, NULL, NULL);
 129         gtk_widget_destroy(filesel);
 130         GTK_EVENTS_FLUSH();
 131
 132         return filename;
 133 }
 134
 135 GList *filesel_select_multiple_files(const gchar *title, const gchar *file)
 136 {
 137         /* ALF - sorry for the exuberant code duping... need to
 138          * be cleaned up. */
 139         static gchar *filename = NULL;
 140         static gchar *cwd = NULL;
 141         GList        *list = NULL;
 142
 143         filesel_create(title, TRUE);
 144
 145         manage_window_set_transient(GTK_WINDOW(filesel));
 146
 147         if (filename) {
 148                 g_free(filename);
 149                 filename = NULL;
 150         }
 151
 152         if (!cwd)
 153                 cwd = g_strconcat(sylpheed_get_startup_dir(), G_DIR_SEPARATOR_S, NULL);
 154
 155         gtk_file_selection_set_filename(GTK_FILE_SELECTION(filesel), cwd);
 156
 157         if (file)
 158                 gtk_file_selection_set_filename(GTK_FILE_SELECTION(filesel),
 159                                                 file);
 160         gtk_widget_show(filesel);
 161
 162         filesel_ack = filesel_fin = FALSE;
 163
 164         while (filesel_fin == FALSE)
 165                 gtk_main_iteration();
 166
 167         if (filesel_ack) {
 168                 gchar *fname = NULL;
 169
 170                 list = filesel_get_multiple_filenames();
 171
 172                 if (!list) {
 173                         fname = gtk_file_selection_get_filename(GTK_FILE_SELECTION(filesel));
 174                         list = g_list_append(list, g_strdup(fname));
 175                 }
 176                 /* store dir of first entry */
 177                 if (NULL != (fname = list->data) && *fname) {
 178                         gchar *dir;
 179                         if (NULL != (dir = g_dirname(fname))) {
 180                                 g_free(cwd);
 181                                 cwd = g_strconcat(dir, G_DIR_SEPARATOR_S, NULL);
 182                                 g_free(dir);
 183                         }
 184                 }
 185         }
 186
 187         manage_window_focus_out(filesel, NULL, NULL);
 188         gtk_widget_destroy(filesel);
 189         GTK_EVENTS_FLUSH();
 190
 191         return list;
 192 }
 193
 194 static void filesel_create(const gchar *title, gboolean multiple_files)
 195 {
 196         filesel = gtk_file_selection_new(title);
 197         gtk_window_set_position(GTK_WINDOW(filesel), GTK_WIN_POS_CENTER);
 198         gtk_window_set_modal(GTK_WINDOW(filesel), TRUE);
 199         gtk_window_set_wmclass
 200                 (GTK_WINDOW(filesel), "file_selection", "Sylpheed");
 201
 202         gtk_signal_connect(GTK_OBJECT(GTK_FILE_SELECTION(filesel)->ok_button),
 203                            "clicked", GTK_SIGNAL_FUNC(filesel_ok_cb),
 204                            NULL);
 205         gtk_signal_connect
 206                 (GTK_OBJECT(GTK_FILE_SELECTION(filesel)->cancel_button),
 207                  "clicked", GTK_SIGNAL_FUNC(filesel_cancel_cb),
 208                  NULL);
 209         gtk_signal_connect(GTK_OBJECT(filesel), "delete_event",
 210                            GTK_SIGNAL_FUNC(delete_event), NULL);
 211         gtk_signal_connect(GTK_OBJECT(filesel), "key_press_event",
 212                            GTK_SIGNAL_FUNC(key_pressed), NULL);
 213         MANAGE_WINDOW_SIGNALS_CONNECT(filesel);
 214
 215         if (multiple_files) {
 216                 gtk_clist_set_selection_mode
 217                         (GTK_CLIST(GTK_FILE_SELECTION(filesel)->file_list),
 218                          GTK_SELECTION_MULTIPLE);
 219                 gtk_signal_connect(GTK_OBJECT(GTK_FILE_SELECTION(filesel)->file_list),
 220                                    "select_row",
 221                                    GTK_SIGNAL_FUNC(filesel_file_list_select_row_multi),
 222                                    NULL);
 223                 gtk_signal_connect(GTK_OBJECT(GTK_FILE_SELECTION(filesel)->file_list),
 224                                    "unselect_row",
 225                                    GTK_SIGNAL_FUNC(filesel_file_list_select_row_multi),
 226                                    NULL);
 227                 gtk_signal_connect(GTK_OBJECT(GTK_FILE_SELECTION(filesel)->dir_list),
 228                                    "select_row",
 229                                    GTK_SIGNAL_FUNC(filesel_dir_list_select_row_multi),
 230                                    NULL);
 231         } else {
 232                 gtk_signal_connect_after(GTK_OBJECT(GTK_FILE_SELECTION(filesel)->file_list),
 233                                          "select_row",
 234                                          GTK_SIGNAL_FUNC(filesel_file_list_select_row_single),
 235                                          NULL);
 236                 gtk_signal_connect_after(GTK_OBJECT(GTK_FILE_SELECTION(filesel)->dir_list),
 237                                          "select_row",
 238                                          GTK_SIGNAL_FUNC(filesel_dir_list_select_row_single),
 239                                          NULL);
 240         }
 241 }
 242
 243 static void filesel_ok_cb(GtkWidget *widget, gpointer data)
 244 {
 245         filesel_ack = TRUE;
 246         filesel_fin = TRUE;
 247 }
 248
 249 static void filesel_cancel_cb(GtkWidget *widget, gpointer data)
 250 {
 251         filesel_ack = FALSE;
 252         filesel_fin = TRUE;
 253 }
 254
 255 static gint delete_event(GtkWidget *widget, GdkEventAny *event, gpointer data)
 256 {
 257         filesel_cancel_cb(NULL, NULL);
 258         if (filesel_oldfilename) {
 259                 g_free(filesel_oldfilename);
 260                 filesel_oldfilename = NULL;
 261         }
 262         return TRUE;
 263 }
 264
 265 static void key_pressed(GtkWidget *widget, GdkEventKey *event, gpointer data)
 266 {
 267         if (event && event->keyval == GDK_Escape)
 268                 filesel_cancel_cb(NULL, NULL);
 269 }
 270
 271 /* handle both "select_row" and "unselect_row". note that we're using the
 272  * entry box to put there the selected file names in. we're not using these
 273  * entry box to get the selected file names. instead we use the clist selection.
 274  * the entry box is used only to retrieve dir name. */
 275 static void filesel_file_list_select_row_multi(GtkCList *clist, gint row, gint col,
 276                                                GdkEventButton *event, gpointer userdata)
 277 {
 278         /* simple implementation in which we clear the file entry and refill it */
 279         GList    *list  = clist->selection;
 280         GtkEntry *entry = GTK_ENTRY(GTK_FILE_SELECTION(filesel)->selection_entry);
 281
 282         gtk_editable_delete_text(GTK_EDITABLE(entry), 0, -1);
 283
 284 #define INVALID_FILENAME_CHARS     " "
 285         for (; list; list = list->next) {
 286                 gint row = GPOINTER_TO_INT(list->data);
 287                 gchar *text = NULL, *tmp;
 288
 289                 if (!gtk_clist_get_text(clist, row, 0, &text))
 290                         break;
 291
 292                 /* NOTE: quick glance in source code of GtkCList
 293                  * reveals we should not free the returned 'text' */
 294
 295                 tmp = g_strconcat(text, " ", NULL);
 296                 text = tmp;
 297                 gtk_entry_append_text(entry, text);
 298                 g_free(text);
 299         }
 300 #undef INVALID_FILENAME_CHARS
 301 }
 302
 303 static void filesel_dir_list_select_row_multi(GtkCList *clist, gint row, gint col,
 304                                               GdkEventButton *event, gpointer userdata)
 305 {
 306         GtkEntry *entry     = GTK_ENTRY(GTK_FILE_SELECTION(filesel)->selection_entry);
 307         GtkCList *file_list = GTK_CLIST(GTK_FILE_SELECTION(filesel)->file_list);
 308
 309         /* if dir list is selected we clean everything */
 310         gtk_editable_delete_text(GTK_EDITABLE(entry), 0, -1);
 311         gtk_clist_unselect_all(file_list);
 312 }
 313
 314 static void filesel_file_list_select_row_single(GtkCList *clist, gint row, gint col,
 315                                          GdkEventButton *event, gpointer userdata)
 316 {
 317         gchar *text;
 318
 319         if(gtk_clist_get_text(clist, row, 0, &text)) {
 320                 filesel_oldfilename = g_strdup(text);
 321                 debug_print("%s\n", filesel_oldfilename);
 322         } else {
 323                 filesel_oldfilename = NULL;
 324         }
 325 }
 326
 327 static void filesel_dir_list_select_row_single(GtkCList *clist, gint row, gint col,
 328                                         GdkEventButton *event, gpointer userdata)
 329 {
 330         gchar *buf;
 331         GtkEntry *entry = GTK_ENTRY(GTK_FILE_SELECTION(filesel)->selection_entry);
 332
 333         buf = gtk_editable_get_chars(GTK_EDITABLE(entry), 0, -1);
 334         if(filesel_oldfilename && !(*buf)) {
 335                 gtk_editable_delete_text(GTK_EDITABLE(entry), 0, -1);
 336                 gtk_entry_append_text(entry, filesel_oldfilename);
 337         }
 338         g_free(buf);
 339 }
 340
 341 static GList *filesel_get_multiple_filenames(void)
 342 {
 343         /* as noted before we are not using the entry text when selecting
 344          * multiple files. to much hassle to parse out invalid chars (chars
 345          * that need to be escaped). instead we use the file_list. the
 346          * entry is only useful for extracting the current directory. */
 347         GtkCList *file_list  = GTK_CLIST(GTK_FILE_SELECTION(filesel)->file_list);
 348         GList    *list = NULL, *sel_list;
 349         gchar    *cwd, *tmp;
 350         gboolean  separator;
 351
 352         g_return_val_if_fail(file_list->selection != NULL, NULL);
 353
 354         tmp = gtk_file_selection_get_filename(GTK_FILE_SELECTION(filesel));
 355         tmp = g_strdup(tmp);
 356         cwd = g_dirname(tmp);
 357         g_free(tmp);
 358         g_return_val_if_fail(cwd != NULL, NULL);
 359
 360         /* only quick way to check the end of a multi byte string for our
 361          * separator... */
 362         g_strreverse(cwd);
 363         separator = 0 == g_strncasecmp(cwd, G_DIR_SEPARATOR_S, strlen(G_DIR_SEPARATOR_S))
 364                 ?  TRUE : FALSE;
 365         g_strreverse(cwd);
 366
 367         /* fetch the selected file names */
 368         for (sel_list = file_list->selection; sel_list; sel_list = sel_list->next) {
 369                 gint   sel = GPOINTER_TO_INT(sel_list->data);
 370                 gchar *sel_text = NULL;
 371                 gchar *fname = NULL;
 372
 373                 gtk_clist_get_text(file_list, sel, 0, &sel_text);
 374                 if (!sel_text) continue;
 375                 sel_text = g_strdup(sel_text);
 376
 377                 if (separator)
 378                         fname = g_strconcat(cwd, sel_text, NULL);
 379                 else
 380                         fname = g_strconcat(cwd, G_DIR_SEPARATOR_S, sel_text, NULL);
 381
 382                 list = g_list_append(list, fname);
 383                 g_free(sel_text);
 384         }
 385
 386         g_free(cwd);
 387
 388         return list;
 389 }
 390