* Library General Public License for more details.
*
* You should have received a copy of the GNU Library General Public
- * License along with this library; if not, write to the Free
- * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
*/
+
+/*
+ * Modified by the GTK+ Team and others 1997-1999. See the AUTHORS
+ * file for a list of people on the GTK+ Team. See the ChangeLog
+ * files for a list of changes. These files are distributed with
+ * GTK+ at ftp://ftp.gtk.org/pub/gtk/.
+ */
+
+#include "config.h"
+
+#include <glib.h> /* To get stat->_stat redefinition
+ * for mingw32
+ */
+
#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
+#ifdef HAVE_SYS_PARAM_H
#include <sys/param.h>
+#endif
+#ifdef HAVE_DIRENT_H
#include <dirent.h>
+#endif
#include <stdlib.h>
+#ifdef HAVE_UNISTD_H
#include <unistd.h>
+#endif
#include <string.h>
#include <errno.h>
+#ifdef HAVE_PWD_H
#include <pwd.h>
+#endif
+
#include "fnmatch.h"
#include "gdk/gdkkeysyms.h"
#include "gtkentry.h"
#include "gtkfilesel.h"
#include "gtkhbox.h"
+#include "gtkhbbox.h"
#include "gtklabel.h"
#include "gtklist.h"
#include "gtklistitem.h"
#include "gtkscrolledwindow.h"
#include "gtksignal.h"
#include "gtkvbox.h"
-
-
-#define DIR_LIST_WIDTH 160
-#define DIR_LIST_HEIGHT 175
-#define FILE_LIST_WIDTH 160
-#define FILE_LIST_HEIGHT 175
+#include "gtkmenu.h"
+#include "gtkmenuitem.h"
+#include "gtkoptionmenu.h"
+#include "gtkclist.h"
+#include "gtkdialog.h"
+#include "gtkintl.h"
+
+#ifdef WIN32
+#define STRICT
+#include <windows.h>
+
+#ifdef NATIVE_WIN32
+#include <direct.h>
+#include <io.h>
+#define mkdir(p,m) _mkdir(p)
+#ifndef S_ISDIR
+#define S_ISDIR(mode) ((mode)&_S_IFDIR)
+#endif
+
+#endif /* NATIVE_WIN32 */
+
+#endif /* WIN32 */
+
+#define DIR_LIST_WIDTH 180
+#define DIR_LIST_HEIGHT 180
+#define FILE_LIST_WIDTH 180
+#define FILE_LIST_HEIGHT 180
+
+/* I've put this here so it doesn't get confused with the
+ * file completion interface */
+typedef struct _HistoryCallbackArg HistoryCallbackArg;
+
+struct _HistoryCallbackArg
+{
+ gchar *directory;
+ GtkWidget *menu_item;
+};
typedef struct _CompletionState CompletionState;
{
ino_t inode;
time_t mtime;
+ dev_t device;
gint entry_count;
gchar *name_buffer; /* memory segment containing names of all entries */
gchar *user_dir_name_buffer;
gint user_directories_len;
- gchar *user_home_dir;
gchar *last_completion_text;
static CompletionDir* open_ref_dir (gchar* text_to_complete,
gchar** remaining_text,
CompletionState* cmpl_state);
+#ifndef WIN32
+static gboolean check_dir (gchar *dir_name,
+ struct stat *result,
+ gboolean *stat_subdirs);
+#endif
static CompletionDir* open_dir (gchar* dir_name,
CompletionState* cmpl_state);
+#ifdef HAVE_PWD_H
static CompletionDir* open_user_dir (gchar* text_to_complete,
CompletionState *cmpl_state);
+#endif
static CompletionDir* open_relative_dir (gchar* dir_name, CompletionDir* dir,
CompletionState *cmpl_state);
-static CompletionDirSent* open_new_dir (gchar* dir_name, struct stat* sbuf);
+static CompletionDirSent* open_new_dir (gchar* dir_name,
+ struct stat* sbuf,
+ gboolean stat_subdirs);
static gint correct_dir_fullname (CompletionDir* cmpl_dir);
static gint correct_parent (CompletionDir* cmpl_dir,
struct stat *sbuf);
CompletionState* cmpl_state);
static PossibleCompletion* append_completion_text(gchar* text,
CompletionState* cmpl_state);
+#ifdef HAVE_PWD_H
static gint get_pwdb(CompletionState* cmpl_state);
-static gint first_diff_index(gchar* pat, gchar* text);
static gint compare_user_dir(const void* a, const void* b);
+#endif
+static gint first_diff_index(gchar* pat, gchar* text);
static gint compare_cmpl_dir(const void* a, const void* b);
static void update_cmpl(PossibleCompletion* poss,
CompletionState* cmpl_state);
static gint gtk_file_selection_key_press (GtkWidget *widget,
GdkEventKey *event,
gpointer user_data);
-static gint gtk_file_selection_file_button (GtkWidget *widget,
- GdkEventButton *event,
- gpointer user_data);
-static gint gtk_file_selection_dir_button (GtkWidget *widget,
- GdkEventButton *event,
- gpointer user_data);
-static void gtk_file_selection_file_list_changed (GtkList *gtklist,
- gpointer func_data);
-static void gtk_file_selection_dir_list_changed (GtkList *gtklist,
- gpointer func_data);
+
+static void gtk_file_selection_file_button (GtkWidget *widget,
+ gint row,
+ gint column,
+ GdkEventButton *bevent,
+ gpointer user_data);
+
+static void gtk_file_selection_dir_button (GtkWidget *widget,
+ gint row,
+ gint column,
+ GdkEventButton *bevent,
+ gpointer data);
+
static void gtk_file_selection_populate (GtkFileSelection *fs,
gchar *rel_path,
gint try_complete);
static void gtk_file_selection_abort (GtkFileSelection *fs);
-static void gtk_file_selection_free_filename (GtkWidget *widget,
- gpointer client_data);
+
+static void gtk_file_selection_update_history_menu (GtkFileSelection *fs,
+ gchar *current_dir);
+
+static void gtk_file_selection_create_dir (GtkWidget *widget, gpointer data);
+static void gtk_file_selection_delete_file (GtkWidget *widget, gpointer data);
+static void gtk_file_selection_rename_file (GtkWidget *widget, gpointer data);
-static GtkWindowClass *parent_class = NULL;
-static gchar *list_changed_key = "_gtk_selection_changed_handler_key";
+static GtkWindowClass *parent_class = NULL;
/* Saves errno when something cmpl does fails. */
static gint cmpl_errno;
+#ifdef __CYGWIN32__
+/*
+ * Take the path currently in the file selection
+ * entry field and translate as necessary from
+ * a WIN32 style to CYGWIN32 style path. For
+ * instance translate:
+ * x:\somepath\file.jpg
+ * to:
+ * //x/somepath/file.jpg
+ *
+ * Replace the path in the selection text field.
+ * Return a boolean value concerning whether a
+ * translation had to be made.
+ */
+int
+translate_win32_path(GtkFileSelection *filesel)
+{
+ int updated = 0;
+ gchar *path;
+
+ /*
+ * Retrieve the current path
+ */
+ path = gtk_entry_get_text (GTK_ENTRY (filesel->selection_entry));
+
+ /*
+ * Translate only if this looks like a DOS-ish
+ * path... First handle any drive letters.
+ */
+ if (isalpha(path[0]) && (path[1] == ':')) {
+ /*
+ * This part kind of stinks... It isn't possible
+ * to know if there is enough space in the current
+ * string for the extra character required in this
+ * conversion. Assume that there isn't enough space
+ * and use the set function on the text field to
+ * set the newly created string.
+ */
+ gchar *newPath;
+
+ newPath = g_malloc(strlen(path) + 2);
+ sprintf(newPath, "//%c/%s", path[0], (path + 3));
+ gtk_entry_set_text (GTK_ENTRY (filesel->selection_entry), newPath);
+
+ path = newPath;
+ updated = 1;
+ }
+
+ /*
+ * Now, replace backslashes with forward slashes
+ * if necessary.
+ */
+ if (strchr(path, '\\')) {
+ int index;
+ for (index = 0; path[index] != '\0'; index++)
+ if (path[index] == '\\')
+ path[index] = '/';
-guint
-gtk_file_selection_get_type ()
+ updated = 1;
+ }
+
+ return updated;
+}
+#endif
+
+GtkType
+gtk_file_selection_get_type (void)
{
- static guint file_selection_type = 0;
+ static GtkType file_selection_type = 0;
if (!file_selection_type)
{
- GtkTypeInfo filesel_info =
+ static const GtkTypeInfo filesel_info =
{
"GtkFileSelection",
sizeof (GtkFileSelection),
sizeof (GtkFileSelectionClass),
(GtkClassInitFunc) gtk_file_selection_class_init,
(GtkObjectInitFunc) gtk_file_selection_init,
- (GtkArgSetFunc) NULL,
- (GtkArgGetFunc) NULL,
+ /* reserved_1 */ NULL,
+ /* reserved_2 */ NULL,
+ (GtkClassInitFunc) NULL,
};
- file_selection_type = gtk_type_unique (gtk_window_get_type (), &filesel_info);
+ file_selection_type = gtk_type_unique (GTK_TYPE_WINDOW, &filesel_info);
}
return file_selection_type;
object_class = (GtkObjectClass*) class;
- parent_class = gtk_type_class (gtk_window_get_type ());
+ parent_class = gtk_type_class (GTK_TYPE_WINDOW);
object_class->destroy = gtk_file_selection_destroy;
}
static void
gtk_file_selection_init (GtkFileSelection *filesel)
{
- GtkWidget *dir_vbox;
- GtkWidget *file_vbox;
GtkWidget *entry_vbox;
- GtkWidget *listbox;
GtkWidget *label;
GtkWidget *list_hbox;
- GtkWidget *action_area;
- gint key;
+ GtkWidget *confirm_area;
+ GtkWidget *pulldown_hbox;
+ GtkWidget *scrolled_win;
+ char *dir_title [2];
+ char *file_title [2];
+
filesel->cmpl_state = cmpl_init_state ();
- /* The dialog-sized vertical box */
+ /* The dialog-sized vertical box */
filesel->main_vbox = gtk_vbox_new (FALSE, 10);
- gtk_container_border_width (GTK_CONTAINER (filesel), 10);
+ gtk_container_set_border_width (GTK_CONTAINER (filesel), 10);
gtk_container_add (GTK_CONTAINER (filesel), filesel->main_vbox);
gtk_widget_show (filesel->main_vbox);
+ /* The horizontal box containing create, rename etc. buttons */
+ filesel->button_area = gtk_hbutton_box_new ();
+ gtk_button_box_set_layout(GTK_BUTTON_BOX(filesel->button_area), GTK_BUTTONBOX_START);
+ gtk_button_box_set_spacing(GTK_BUTTON_BOX(filesel->button_area), 0);
+ gtk_box_pack_start (GTK_BOX (filesel->main_vbox), filesel->button_area,
+ FALSE, FALSE, 0);
+ gtk_widget_show (filesel->button_area);
+
+ gtk_file_selection_show_fileop_buttons(filesel);
+
+ /* hbox for pulldown menu */
+ pulldown_hbox = gtk_hbox_new (TRUE, 5);
+ gtk_box_pack_start (GTK_BOX (filesel->main_vbox), pulldown_hbox, FALSE, FALSE, 0);
+ gtk_widget_show (pulldown_hbox);
+
+ /* Pulldown menu */
+ filesel->history_pulldown = gtk_option_menu_new ();
+ gtk_widget_show (filesel->history_pulldown);
+ gtk_box_pack_start (GTK_BOX (pulldown_hbox), filesel->history_pulldown,
+ FALSE, FALSE, 0);
+
/* The horizontal box containing the directory and file listboxes */
- list_hbox = gtk_hbox_new (TRUE, 5);
+ list_hbox = gtk_hbox_new (FALSE, 5);
gtk_box_pack_start (GTK_BOX (filesel->main_vbox), list_hbox, TRUE, TRUE, 0);
gtk_widget_show (list_hbox);
-
- /* The directories listbox */
- dir_vbox = gtk_vbox_new (FALSE, 2);
- gtk_box_pack_start (GTK_BOX (list_hbox), dir_vbox, TRUE, TRUE, 0);
- gtk_widget_show (dir_vbox);
-
- label = gtk_label_new ("Directories");
- gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
- gtk_box_pack_start (GTK_BOX (dir_vbox), label, FALSE, FALSE, 0);
- gtk_widget_show (label);
-
- listbox = gtk_scrolled_window_new (NULL, NULL);
- gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (listbox),
- GTK_POLICY_AUTOMATIC,
- GTK_POLICY_ALWAYS);
- gtk_box_pack_start (GTK_BOX (dir_vbox), listbox, TRUE, TRUE, 0);
- gtk_widget_set_usize (listbox, DIR_LIST_WIDTH, DIR_LIST_HEIGHT);
- gtk_widget_show (listbox);
-
- filesel->dir_list = gtk_list_new ();
- gtk_list_set_selection_mode (GTK_LIST (filesel->dir_list), GTK_SELECTION_BROWSE);
- gtk_signal_connect (GTK_OBJECT (filesel->dir_list), "button_press_event",
- (GtkSignalFunc) gtk_file_selection_dir_button, filesel);
- key = gtk_signal_connect (GTK_OBJECT (filesel->dir_list),
- "selection_changed",
- (GtkSignalFunc) gtk_file_selection_dir_list_changed,
- filesel);
- gtk_object_set_data (GTK_OBJECT (filesel->dir_list), list_changed_key, (gpointer) key);
- gtk_container_add (GTK_CONTAINER (listbox), filesel->dir_list);
+ /* The directories clist */
+ dir_title[0] = _("Directories");
+ dir_title[1] = NULL;
+ filesel->dir_list = gtk_clist_new_with_titles (1, (gchar**) dir_title);
+ gtk_widget_set_usize (filesel->dir_list, DIR_LIST_WIDTH, DIR_LIST_HEIGHT);
+ gtk_signal_connect (GTK_OBJECT (filesel->dir_list), "select_row",
+ (GtkSignalFunc) gtk_file_selection_dir_button,
+ (gpointer) filesel);
+ gtk_clist_column_titles_passive (GTK_CLIST (filesel->dir_list));
+
+ scrolled_win = gtk_scrolled_window_new (NULL, NULL);
+ gtk_container_add (GTK_CONTAINER (scrolled_win), filesel->dir_list);
+ gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_win),
+ GTK_POLICY_AUTOMATIC, GTK_POLICY_ALWAYS);
+ gtk_container_set_border_width (GTK_CONTAINER (scrolled_win), 5);
+ gtk_box_pack_start (GTK_BOX (list_hbox), scrolled_win, TRUE, TRUE, 0);
gtk_widget_show (filesel->dir_list);
-
-
- /* The files listbox */
- file_vbox = gtk_vbox_new (FALSE, 2);
- gtk_box_pack_start (GTK_BOX (list_hbox), file_vbox, TRUE, TRUE, 0);
- gtk_widget_show (file_vbox);
-
- label = gtk_label_new ("Files");
- gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
- gtk_box_pack_start (GTK_BOX (file_vbox), label, FALSE, FALSE, 0);
- gtk_widget_show (label);
-
- listbox = gtk_scrolled_window_new (NULL, NULL);
- gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (listbox),
- GTK_POLICY_AUTOMATIC,
- GTK_POLICY_ALWAYS);
- gtk_box_pack_start (GTK_BOX (file_vbox), listbox, TRUE, TRUE, 0);
- gtk_widget_set_usize (listbox, FILE_LIST_WIDTH, FILE_LIST_HEIGHT);
- gtk_widget_show (listbox);
-
- filesel->file_list = gtk_list_new ();
- gtk_list_set_selection_mode (GTK_LIST (filesel->file_list), GTK_SELECTION_SINGLE);
- gtk_signal_connect (GTK_OBJECT (filesel->file_list), "button_press_event",
- (GtkSignalFunc) gtk_file_selection_file_button, filesel);
- key = gtk_signal_connect (GTK_OBJECT (filesel->file_list),
- "selection_changed",
- (GtkSignalFunc) gtk_file_selection_file_list_changed,
- filesel);
- gtk_object_set_data (GTK_OBJECT (filesel->file_list), list_changed_key, (gpointer) key);
- gtk_container_add (GTK_CONTAINER (listbox), filesel->file_list);
+ gtk_widget_show (scrolled_win);
+
+ /* The files clist */
+ file_title[0] = _("Files");
+ file_title[1] = NULL;
+ filesel->file_list = gtk_clist_new_with_titles (1, (gchar**) file_title);
+ gtk_widget_set_usize (filesel->file_list, FILE_LIST_WIDTH, FILE_LIST_HEIGHT);
+ gtk_signal_connect (GTK_OBJECT (filesel->file_list), "select_row",
+ (GtkSignalFunc) gtk_file_selection_file_button,
+ (gpointer) filesel);
+ gtk_clist_column_titles_passive (GTK_CLIST (filesel->file_list));
+
+ scrolled_win = gtk_scrolled_window_new (NULL, NULL);
+ gtk_container_add (GTK_CONTAINER (scrolled_win), filesel->file_list);
+ gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_win),
+ GTK_POLICY_AUTOMATIC, GTK_POLICY_ALWAYS);
+ gtk_container_set_border_width (GTK_CONTAINER (scrolled_win), 5);
+ gtk_box_pack_start (GTK_BOX (list_hbox), scrolled_win, TRUE, TRUE, 0);
gtk_widget_show (filesel->file_list);
+ gtk_widget_show (scrolled_win);
-
- /* The action area */
- action_area = gtk_hbox_new (TRUE, 10);
- gtk_box_pack_end (GTK_BOX (filesel->main_vbox), action_area, FALSE, FALSE, 0);
- gtk_widget_show (action_area);
+ /* action area for packing buttons into. */
+ filesel->action_area = gtk_hbox_new (TRUE, 0);
+ gtk_box_pack_start (GTK_BOX (filesel->main_vbox), filesel->action_area,
+ FALSE, FALSE, 0);
+ gtk_widget_show (filesel->action_area);
+
+ /* The OK/Cancel button area */
+ confirm_area = gtk_hbutton_box_new ();
+ gtk_button_box_set_layout(GTK_BUTTON_BOX(confirm_area), GTK_BUTTONBOX_END);
+ gtk_button_box_set_spacing(GTK_BUTTON_BOX(confirm_area), 5);
+ gtk_box_pack_end (GTK_BOX (filesel->main_vbox), confirm_area, FALSE, FALSE, 0);
+ gtk_widget_show (confirm_area);
/* The OK button */
- filesel->ok_button = gtk_button_new_with_label ("OK");
+ filesel->ok_button = gtk_button_new_with_label (_("OK"));
GTK_WIDGET_SET_FLAGS (filesel->ok_button, GTK_CAN_DEFAULT);
- gtk_box_pack_start (GTK_BOX (action_area), filesel->ok_button, TRUE, TRUE, 0);
+ gtk_box_pack_start (GTK_BOX (confirm_area), filesel->ok_button, TRUE, TRUE, 0);
gtk_widget_grab_default (filesel->ok_button);
gtk_widget_show (filesel->ok_button);
/* The Cancel button */
- filesel->cancel_button = gtk_button_new_with_label ("Cancel");
+ filesel->cancel_button = gtk_button_new_with_label (_("Cancel"));
GTK_WIDGET_SET_FLAGS (filesel->cancel_button, GTK_CAN_DEFAULT);
- gtk_box_pack_start (GTK_BOX (action_area), filesel->cancel_button, TRUE, TRUE, 0);
+ gtk_box_pack_start (GTK_BOX (confirm_area), filesel->cancel_button, TRUE, TRUE, 0);
gtk_widget_show (filesel->cancel_button);
- /* The Help button */
- filesel->help_button = gtk_button_new_with_label ("Help");
- GTK_WIDGET_SET_FLAGS (filesel->help_button, GTK_CAN_DEFAULT);
- gtk_box_pack_start (GTK_BOX (action_area), filesel->help_button, TRUE, TRUE, 0);
- gtk_widget_show (filesel->help_button);
-
-
/* The selection entry widget */
entry_vbox = gtk_vbox_new (FALSE, 2);
gtk_box_pack_end (GTK_BOX (filesel->main_vbox), entry_vbox, FALSE, FALSE, 0);
{
gchar err_buf[256];
- sprintf (err_buf, "Directory unreadable: %s", cmpl_strerror (cmpl_errno));
+ sprintf (err_buf, _("Directory unreadable: %s"), cmpl_strerror (cmpl_errno));
- gtk_label_set (GTK_LABEL (filesel->selection_text), err_buf);
+ gtk_label_set_text (GTK_LABEL (filesel->selection_text), err_buf);
}
else
{
{
GtkFileSelection *filesel;
- filesel = gtk_type_new (gtk_file_selection_get_type ());
+ filesel = gtk_type_new (GTK_TYPE_FILE_SELECTION);
gtk_window_set_title (GTK_WINDOW (filesel), title);
return GTK_WIDGET (filesel);
}
+void
+gtk_file_selection_show_fileop_buttons (GtkFileSelection *filesel)
+{
+ g_return_if_fail (filesel != NULL);
+ g_return_if_fail (GTK_IS_FILE_SELECTION (filesel));
+
+ /* delete, create directory, and rename */
+ if (!filesel->fileop_c_dir)
+ {
+ filesel->fileop_c_dir = gtk_button_new_with_label (_("Create Dir"));
+ gtk_signal_connect (GTK_OBJECT (filesel->fileop_c_dir), "clicked",
+ (GtkSignalFunc) gtk_file_selection_create_dir,
+ (gpointer) filesel);
+ gtk_box_pack_start (GTK_BOX (filesel->button_area),
+ filesel->fileop_c_dir, TRUE, TRUE, 0);
+ gtk_widget_show (filesel->fileop_c_dir);
+ }
+
+ if (!filesel->fileop_del_file)
+ {
+ filesel->fileop_del_file = gtk_button_new_with_label (_("Delete File"));
+ gtk_signal_connect (GTK_OBJECT (filesel->fileop_del_file), "clicked",
+ (GtkSignalFunc) gtk_file_selection_delete_file,
+ (gpointer) filesel);
+ gtk_box_pack_start (GTK_BOX (filesel->button_area),
+ filesel->fileop_del_file, TRUE, TRUE, 0);
+ gtk_widget_show (filesel->fileop_del_file);
+ }
+
+ if (!filesel->fileop_ren_file)
+ {
+ filesel->fileop_ren_file = gtk_button_new_with_label (_("Rename File"));
+ gtk_signal_connect (GTK_OBJECT (filesel->fileop_ren_file), "clicked",
+ (GtkSignalFunc) gtk_file_selection_rename_file,
+ (gpointer) filesel);
+ gtk_box_pack_start (GTK_BOX (filesel->button_area),
+ filesel->fileop_ren_file, TRUE, TRUE, 0);
+ gtk_widget_show (filesel->fileop_ren_file);
+ }
+
+ gtk_widget_queue_resize(GTK_WIDGET(filesel));
+}
+
+void
+gtk_file_selection_hide_fileop_buttons (GtkFileSelection *filesel)
+{
+ g_return_if_fail (filesel != NULL);
+ g_return_if_fail (GTK_IS_FILE_SELECTION (filesel));
+
+ if (filesel->fileop_ren_file)
+ {
+ gtk_widget_destroy (filesel->fileop_ren_file);
+ filesel->fileop_ren_file = NULL;
+ }
+
+ if (filesel->fileop_del_file)
+ {
+ gtk_widget_destroy (filesel->fileop_del_file);
+ filesel->fileop_del_file = NULL;
+ }
+
+ if (filesel->fileop_c_dir)
+ {
+ gtk_widget_destroy (filesel->fileop_c_dir);
+ filesel->fileop_c_dir = NULL;
+ }
+}
+
+
+
void
gtk_file_selection_set_filename (GtkFileSelection *filesel,
const gchar *filename)
g_return_if_fail (GTK_IS_FILE_SELECTION (filesel));
g_return_if_fail (filename != NULL);
- last_slash = strrchr (filename, '/');
+ last_slash = strrchr (filename, G_DIR_SEPARATOR);
if (!last_slash)
{
g_return_val_if_fail (filesel != NULL, nothing);
g_return_val_if_fail (GTK_IS_FILE_SELECTION (filesel), nothing);
+#ifdef __CYGWIN32__
+ translate_win32_path(filesel);
+#endif
text = gtk_entry_get_text (GTK_ENTRY (filesel->selection_entry));
if (text)
{
return nothing;
}
+void
+gtk_file_selection_complete (GtkFileSelection *filesel,
+ const gchar *pattern)
+{
+ g_return_if_fail (filesel != NULL);
+ g_return_if_fail (GTK_IS_FILE_SELECTION (filesel));
+ g_return_if_fail (pattern != NULL);
+
+ if (filesel->selection_entry)
+ gtk_entry_set_text (GTK_ENTRY (filesel->selection_entry), pattern);
+ gtk_file_selection_populate (filesel, (gchar*) pattern, TRUE);
+}
+
static void
gtk_file_selection_destroy (GtkObject *object)
{
GtkFileSelection *filesel;
+ GList *list;
+ HistoryCallbackArg *callback_arg;
g_return_if_fail (object != NULL);
g_return_if_fail (GTK_IS_FILE_SELECTION (object));
filesel = GTK_FILE_SELECTION (object);
-
+
+ if (filesel->fileop_dialog)
+ gtk_widget_destroy (filesel->fileop_dialog);
+
+ if (filesel->history_list)
+ {
+ list = filesel->history_list;
+ while (list)
+ {
+ callback_arg = list->data;
+ g_free (callback_arg->directory);
+ g_free (callback_arg);
+ list = list->next;
+ }
+ g_list_free (filesel->history_list);
+ filesel->history_list = NULL;
+ }
+
cmpl_free_state (filesel->cmpl_state);
+ filesel->cmpl_state = NULL;
if (GTK_OBJECT_CLASS (parent_class)->destroy)
(* GTK_OBJECT_CLASS (parent_class)->destroy) (object);
}
-static gint
-gtk_file_selection_key_press (GtkWidget *widget,
- GdkEventKey *event,
- gpointer user_data)
+/* Begin file operations callbacks */
+
+static void
+gtk_file_selection_fileop_error (gchar *error_message)
{
- GtkFileSelection *fs;
- char *text;
+ GtkWidget *label;
+ GtkWidget *vbox;
+ GtkWidget *button;
+ GtkWidget *dialog;
+
+ g_return_if_fail (error_message != NULL);
+
+ /* main dialog */
+ dialog = gtk_dialog_new ();
+ /*
+ gtk_signal_connect (GTK_OBJECT (dialog), "destroy",
+ (GtkSignalFunc) gtk_file_selection_fileop_destroy,
+ (gpointer) fs);
+ */
+ gtk_window_set_title (GTK_WINDOW (dialog), _("Error"));
+ gtk_window_set_position (GTK_WINDOW (dialog), GTK_WIN_POS_MOUSE);
+
+ vbox = gtk_vbox_new(FALSE, 0);
+ gtk_container_set_border_width(GTK_CONTAINER(vbox), 8);
+ gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->vbox), vbox,
+ FALSE, FALSE, 0);
+ gtk_widget_show(vbox);
+
+ label = gtk_label_new(error_message);
+ gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.0);
+ gtk_box_pack_start(GTK_BOX(vbox), label, FALSE, FALSE, 5);
+ gtk_widget_show(label);
+
+ /* yes, we free it */
+ g_free (error_message);
+
+ /* close button */
+ button = gtk_button_new_with_label (_("Close"));
+ gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
+ (GtkSignalFunc) gtk_widget_destroy,
+ (gpointer) dialog);
+ gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->action_area),
+ button, TRUE, TRUE, 0);
+ GTK_WIDGET_SET_FLAGS(button, GTK_CAN_DEFAULT);
+ gtk_widget_grab_default(button);
+ gtk_widget_show (button);
+
+ gtk_widget_show (dialog);
+}
- g_return_val_if_fail (widget != NULL, FALSE);
- g_return_val_if_fail (event != NULL, FALSE);
+static void
+gtk_file_selection_fileop_destroy (GtkWidget *widget, gpointer data)
+{
+ GtkFileSelection *fs = data;
- if (event->keyval == GDK_Tab)
- {
- gtk_signal_emit_stop_by_name (GTK_OBJECT (widget), "key_press_event");
+ g_return_if_fail (fs != NULL);
+ g_return_if_fail (GTK_IS_FILE_SELECTION (fs));
+
+ fs->fileop_dialog = NULL;
+}
- fs = GTK_FILE_SELECTION (user_data);
- text = gtk_entry_get_text (GTK_ENTRY (fs->selection_entry));
- gtk_file_selection_populate (fs, text, TRUE);
- return TRUE;
+static void
+gtk_file_selection_create_dir_confirmed (GtkWidget *widget, gpointer data)
+{
+ GtkFileSelection *fs = data;
+ gchar *dirname;
+ gchar *path;
+ gchar *full_path;
+ gchar *buf;
+ CompletionState *cmpl_state;
+
+ g_return_if_fail (fs != NULL);
+ g_return_if_fail (GTK_IS_FILE_SELECTION (fs));
+
+ dirname = gtk_entry_get_text (GTK_ENTRY (fs->fileop_entry));
+ cmpl_state = (CompletionState*) fs->cmpl_state;
+ path = cmpl_reference_position (cmpl_state);
+
+ full_path = g_strconcat (path, G_DIR_SEPARATOR_S, dirname, NULL);
+ if ( (mkdir (full_path, 0755) < 0) )
+ {
+ buf = g_strconcat ("Error creating directory \"", dirname, "\": ",
+ g_strerror(errno), NULL);
+ gtk_file_selection_fileop_error (buf);
}
+ g_free (full_path);
+
+ gtk_widget_destroy (fs->fileop_dialog);
+ gtk_file_selection_populate (fs, "", FALSE);
+}
+
+static void
+gtk_file_selection_create_dir (GtkWidget *widget, gpointer data)
+{
+ GtkFileSelection *fs = data;
+ GtkWidget *label;
+ GtkWidget *dialog;
+ GtkWidget *vbox;
+ GtkWidget *button;
- return FALSE;
+ g_return_if_fail (fs != NULL);
+ g_return_if_fail (GTK_IS_FILE_SELECTION (fs));
+
+ if (fs->fileop_dialog)
+ return;
+
+ /* main dialog */
+ fs->fileop_dialog = dialog = gtk_dialog_new ();
+ gtk_signal_connect (GTK_OBJECT (dialog), "destroy",
+ (GtkSignalFunc) gtk_file_selection_fileop_destroy,
+ (gpointer) fs);
+ gtk_window_set_title (GTK_WINDOW (dialog), _("Create Directory"));
+ gtk_window_set_position (GTK_WINDOW (dialog), GTK_WIN_POS_MOUSE);
+
+ /* If file dialog is grabbed, grab option dialog */
+ /* When option dialog is closed, file dialog will be grabbed again */
+ if (GTK_WINDOW(fs)->modal)
+ gtk_window_set_modal (GTK_WINDOW(dialog), TRUE);
+
+ vbox = gtk_vbox_new(FALSE, 0);
+ gtk_container_set_border_width(GTK_CONTAINER(vbox), 8);
+ gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->vbox), vbox,
+ FALSE, FALSE, 0);
+ gtk_widget_show(vbox);
+
+ label = gtk_label_new(_("Directory name:"));
+ gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.0);
+ gtk_box_pack_start(GTK_BOX(vbox), label, FALSE, FALSE, 5);
+ gtk_widget_show(label);
+
+ /* The directory entry widget */
+ fs->fileop_entry = gtk_entry_new ();
+ gtk_box_pack_start (GTK_BOX (vbox), fs->fileop_entry,
+ TRUE, TRUE, 5);
+ GTK_WIDGET_SET_FLAGS(fs->fileop_entry, GTK_CAN_DEFAULT);
+ gtk_widget_show (fs->fileop_entry);
+
+ /* buttons */
+ button = gtk_button_new_with_label (_("Create"));
+ gtk_signal_connect (GTK_OBJECT (button), "clicked",
+ (GtkSignalFunc) gtk_file_selection_create_dir_confirmed,
+ (gpointer) fs);
+ gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->action_area),
+ button, TRUE, TRUE, 0);
+ GTK_WIDGET_SET_FLAGS(button, GTK_CAN_DEFAULT);
+ gtk_widget_show(button);
+
+ button = gtk_button_new_with_label (_("Cancel"));
+ gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
+ (GtkSignalFunc) gtk_widget_destroy,
+ (gpointer) dialog);
+ gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->action_area),
+ button, TRUE, TRUE, 0);
+ GTK_WIDGET_SET_FLAGS(button, GTK_CAN_DEFAULT);
+ gtk_widget_grab_default(button);
+ gtk_widget_show (button);
+
+ gtk_widget_show (dialog);
}
-static gint
-gtk_file_selection_file_button (GtkWidget *widget,
- GdkEventButton *event,
- gpointer user_data)
+static void
+gtk_file_selection_delete_file_confirmed (GtkWidget *widget, gpointer data)
{
- GtkFileSelection *fs;
- GtkWidget *event_widget;
- gchar *filename;
- gboolean handled;
+ GtkFileSelection *fs = data;
+ CompletionState *cmpl_state;
+ gchar *path;
+ gchar *full_path;
+ gchar *buf;
+
+ g_return_if_fail (fs != NULL);
+ g_return_if_fail (GTK_IS_FILE_SELECTION (fs));
- g_return_val_if_fail (widget != NULL, FALSE);
- g_return_val_if_fail (event != NULL, FALSE);
+ cmpl_state = (CompletionState*) fs->cmpl_state;
+ path = cmpl_reference_position (cmpl_state);
+
+ full_path = g_strconcat (path, G_DIR_SEPARATOR_S, fs->fileop_file, NULL);
+ if ( (unlink (full_path) < 0) )
+ {
+ buf = g_strconcat ("Error deleting file \"", fs->fileop_file, "\": ",
+ g_strerror(errno), NULL);
+ gtk_file_selection_fileop_error (buf);
+ }
+ g_free (full_path);
+
+ gtk_widget_destroy (fs->fileop_dialog);
+ gtk_file_selection_populate (fs, "", FALSE);
+}
- fs = GTK_FILE_SELECTION (user_data);
- g_return_val_if_fail (fs != NULL, FALSE);
- g_return_val_if_fail (GTK_IS_FILE_SELECTION (fs), FALSE);
+static void
+gtk_file_selection_delete_file (GtkWidget *widget, gpointer data)
+{
+ GtkFileSelection *fs = data;
+ GtkWidget *label;
+ GtkWidget *vbox;
+ GtkWidget *button;
+ GtkWidget *dialog;
+ gchar *filename;
+ gchar *buf;
+
+ g_return_if_fail (fs != NULL);
+ g_return_if_fail (GTK_IS_FILE_SELECTION (fs));
- event_widget = gtk_get_event_widget ((GdkEvent*) event);
- handled = FALSE;
- if (GTK_IS_LIST_ITEM (event_widget))
- {
- switch (event->type)
- {
- case GDK_BUTTON_PRESS:
- filename = gtk_object_get_user_data (GTK_OBJECT (event_widget));
- gtk_widget_grab_focus (fs->selection_entry);
- gtk_entry_set_text (GTK_ENTRY (fs->selection_entry), filename);
- handled = TRUE;
- break;
+ if (fs->fileop_dialog)
+ return;
- case GDK_2BUTTON_PRESS:
- gtk_button_clicked (GTK_BUTTON (fs->ok_button));
- handled = TRUE;
- break;
+#ifdef __CYGWIN32__
+ translate_win32_path(fs);
+#endif
- default:
- break;
- }
- }
+ filename = gtk_entry_get_text (GTK_ENTRY (fs->selection_entry));
+ if (strlen(filename) < 1)
+ return;
+
+ fs->fileop_file = filename;
+
+ /* main dialog */
+ fs->fileop_dialog = dialog = gtk_dialog_new ();
+ gtk_signal_connect (GTK_OBJECT (dialog), "destroy",
+ (GtkSignalFunc) gtk_file_selection_fileop_destroy,
+ (gpointer) fs);
+ gtk_window_set_title (GTK_WINDOW (dialog), _("Delete File"));
+ gtk_window_set_position (GTK_WINDOW (dialog), GTK_WIN_POS_MOUSE);
+
+ /* If file dialog is grabbed, grab option dialog */
+ /* When option dialog is closed, file dialog will be grabbed again */
+ if (GTK_WINDOW(fs)->modal)
+ gtk_window_set_modal (GTK_WINDOW(dialog), TRUE);
+
+ vbox = gtk_vbox_new(FALSE, 0);
+ gtk_container_set_border_width(GTK_CONTAINER(vbox), 8);
+ gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->vbox), vbox,
+ FALSE, FALSE, 0);
+ gtk_widget_show(vbox);
+
+ buf = g_strconcat ("Really delete file \"", filename, "\" ?", NULL);
+ label = gtk_label_new(buf);
+ gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.0);
+ gtk_box_pack_start(GTK_BOX(vbox), label, FALSE, FALSE, 5);
+ gtk_widget_show(label);
+ g_free(buf);
+
+ /* buttons */
+ button = gtk_button_new_with_label (_("Delete"));
+ gtk_signal_connect (GTK_OBJECT (button), "clicked",
+ (GtkSignalFunc) gtk_file_selection_delete_file_confirmed,
+ (gpointer) fs);
+ gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->action_area),
+ button, TRUE, TRUE, 0);
+ GTK_WIDGET_SET_FLAGS(button, GTK_CAN_DEFAULT);
+ gtk_widget_show(button);
+
+ button = gtk_button_new_with_label (_("Cancel"));
+ gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
+ (GtkSignalFunc) gtk_widget_destroy,
+ (gpointer) dialog);
+ gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->action_area),
+ button, TRUE, TRUE, 0);
+ GTK_WIDGET_SET_FLAGS(button, GTK_CAN_DEFAULT);
+ gtk_widget_grab_default(button);
+ gtk_widget_show (button);
+
+ gtk_widget_show (dialog);
- return handled;
}
static void
-gtk_file_selection_file_list_changed (GtkList *list,
- gpointer func_data)
+gtk_file_selection_rename_file_confirmed (GtkWidget *widget, gpointer data)
{
- GtkFileSelection *fs;
-
- g_return_if_fail (func_data != NULL);
- g_return_if_fail (GTK_IS_FILE_SELECTION (func_data));
+ GtkFileSelection *fs = data;
+ gchar *buf;
+ gchar *file;
+ gchar *path;
+ gchar *new_filename;
+ gchar *old_filename;
+ CompletionState *cmpl_state;
+
+ g_return_if_fail (fs != NULL);
+ g_return_if_fail (GTK_IS_FILE_SELECTION (fs));
- fs = GTK_FILE_SELECTION (func_data);
+ file = gtk_entry_get_text (GTK_ENTRY (fs->fileop_entry));
+ cmpl_state = (CompletionState*) fs->cmpl_state;
+ path = cmpl_reference_position (cmpl_state);
+
+ new_filename = g_strconcat (path, G_DIR_SEPARATOR_S, file, NULL);
+ old_filename = g_strconcat (path, G_DIR_SEPARATOR_S, fs->fileop_file, NULL);
- /* only act on an appropriate selection
- */
- if (list->selection && list->selection->data)
+ if ( (rename (old_filename, new_filename)) < 0)
{
- GtkListItem *item;
-
- item = list->selection->data;
-
- if (GTK_IS_LIST_ITEM (item))
- {
- gchar *filename;
-
- filename = gtk_object_get_user_data (GTK_OBJECT (item));
- gtk_entry_set_text (GTK_ENTRY (fs->selection_entry), filename);
- }
+ buf = g_strconcat ("Error renaming file \"", file, "\": ",
+ g_strerror(errno), NULL);
+ gtk_file_selection_fileop_error (buf);
}
+ g_free (new_filename);
+ g_free (old_filename);
+
+ gtk_widget_destroy (fs->fileop_dialog);
+ gtk_file_selection_populate (fs, "", FALSE);
+}
+
+static void
+gtk_file_selection_rename_file (GtkWidget *widget, gpointer data)
+{
+ GtkFileSelection *fs = data;
+ GtkWidget *label;
+ GtkWidget *dialog;
+ GtkWidget *vbox;
+ GtkWidget *button;
+ gchar *buf;
+
+ g_return_if_fail (fs != NULL);
+ g_return_if_fail (GTK_IS_FILE_SELECTION (fs));
+
+ if (fs->fileop_dialog)
+ return;
+
+ fs->fileop_file = gtk_entry_get_text (GTK_ENTRY (fs->selection_entry));
+ if (strlen(fs->fileop_file) < 1)
+ return;
+
+ /* main dialog */
+ fs->fileop_dialog = dialog = gtk_dialog_new ();
+ gtk_signal_connect (GTK_OBJECT (dialog), "destroy",
+ (GtkSignalFunc) gtk_file_selection_fileop_destroy,
+ (gpointer) fs);
+ gtk_window_set_title (GTK_WINDOW (dialog), _("Rename File"));
+ gtk_window_set_position (GTK_WINDOW (dialog), GTK_WIN_POS_MOUSE);
+
+ /* If file dialog is grabbed, grab option dialog */
+ /* When option dialog closed, file dialog will be grabbed again */
+ if (GTK_WINDOW(fs)->modal)
+ gtk_window_set_modal (GTK_WINDOW(dialog), TRUE);
+
+ vbox = gtk_vbox_new(FALSE, 0);
+ gtk_container_set_border_width (GTK_CONTAINER(vbox), 8);
+ gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->vbox), vbox,
+ FALSE, FALSE, 0);
+ gtk_widget_show(vbox);
+
+ buf = g_strconcat ("Rename file \"", fs->fileop_file, "\" to:", NULL);
+ label = gtk_label_new(buf);
+ gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.0);
+ gtk_box_pack_start(GTK_BOX(vbox), label, FALSE, FALSE, 5);
+ gtk_widget_show(label);
+ g_free(buf);
+
+ /* New filename entry */
+ fs->fileop_entry = gtk_entry_new ();
+ gtk_box_pack_start (GTK_BOX (vbox), fs->fileop_entry,
+ TRUE, TRUE, 5);
+ GTK_WIDGET_SET_FLAGS(fs->fileop_entry, GTK_CAN_DEFAULT);
+ gtk_widget_show (fs->fileop_entry);
+
+ gtk_entry_set_text (GTK_ENTRY (fs->fileop_entry), fs->fileop_file);
+ gtk_editable_select_region (GTK_EDITABLE (fs->fileop_entry),
+ 0, strlen (fs->fileop_file));
+
+ /* buttons */
+ button = gtk_button_new_with_label (_("Rename"));
+ gtk_signal_connect (GTK_OBJECT (button), "clicked",
+ (GtkSignalFunc) gtk_file_selection_rename_file_confirmed,
+ (gpointer) fs);
+ gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->action_area),
+ button, TRUE, TRUE, 0);
+ GTK_WIDGET_SET_FLAGS(button, GTK_CAN_DEFAULT);
+ gtk_widget_show(button);
+
+ button = gtk_button_new_with_label (_("Cancel"));
+ gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
+ (GtkSignalFunc) gtk_widget_destroy,
+ (gpointer) dialog);
+ gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->action_area),
+ button, TRUE, TRUE, 0);
+ GTK_WIDGET_SET_FLAGS(button, GTK_CAN_DEFAULT);
+ gtk_widget_grab_default(button);
+ gtk_widget_show (button);
+
+ gtk_widget_show (dialog);
}
+
static gint
-gtk_file_selection_dir_button (GtkWidget *widget,
- GdkEventButton *event,
- gpointer user_data)
+gtk_file_selection_key_press (GtkWidget *widget,
+ GdkEventKey *event,
+ gpointer user_data)
{
GtkFileSelection *fs;
- GtkWidget *event_widget;
- gchar *filename;
- gboolean handled;
+ char *text;
g_return_val_if_fail (widget != NULL, FALSE);
- g_return_val_if_fail (GTK_IS_LIST (widget), FALSE);
g_return_val_if_fail (event != NULL, FALSE);
- fs = GTK_FILE_SELECTION (user_data);
- g_return_val_if_fail (fs != NULL, FALSE);
- g_return_val_if_fail (GTK_IS_FILE_SELECTION (fs), FALSE);
-
- event_widget = gtk_get_event_widget ((GdkEvent*) event);
- handled = FALSE;
- if (GTK_IS_LIST_ITEM (event_widget))
+ if (event->keyval == GDK_Tab)
{
- gint key;
+ fs = GTK_FILE_SELECTION (user_data);
+#ifdef __CYGWIN32__
+ translate_win32_path(fs);
+#endif
+ text = gtk_entry_get_text (GTK_ENTRY (fs->selection_entry));
- filename = gtk_object_get_user_data (GTK_OBJECT (event_widget));
+ text = g_strdup (text);
- key = (gint) gtk_object_get_data (GTK_OBJECT (widget), list_changed_key);
+ gtk_file_selection_populate (fs, text, TRUE);
- switch (event->type)
- {
- case GDK_BUTTON_PRESS:
+ g_free (text);
- gtk_signal_handler_block (GTK_OBJECT (widget), key);
- gtk_widget_activate (GTK_WIDGET (event_widget));
- gtk_signal_handler_unblock (GTK_OBJECT (widget), key);
+ gtk_signal_emit_stop_by_name (GTK_OBJECT (widget), "key_press_event");
- gtk_widget_grab_focus (fs->selection_entry);
- gtk_entry_set_text (GTK_ENTRY (fs->selection_entry), filename);
- handled = TRUE;
- break;
+ return TRUE;
+ }
- case GDK_2BUTTON_PRESS:
- gtk_file_selection_populate (fs, filename, FALSE);
- handled = TRUE;
- break;
+ return FALSE;
+}
- default:
- break;
+
+static void
+gtk_file_selection_history_callback (GtkWidget *widget, gpointer data)
+{
+ GtkFileSelection *fs = data;
+ HistoryCallbackArg *callback_arg;
+ GList *list;
+
+ g_return_if_fail (fs != NULL);
+ g_return_if_fail (GTK_IS_FILE_SELECTION (fs));
+
+ list = fs->history_list;
+
+ while (list) {
+ callback_arg = list->data;
+
+ if (callback_arg->menu_item == widget)
+ {
+ gtk_file_selection_populate (fs, callback_arg->directory, FALSE);
+ break;
+ }
+
+ list = list->next;
+ }
+}
+
+static void
+gtk_file_selection_update_history_menu (GtkFileSelection *fs,
+ gchar *current_directory)
+{
+ HistoryCallbackArg *callback_arg;
+ GtkWidget *menu_item;
+ GList *list;
+ gchar *current_dir;
+ gint dir_len;
+ gint i;
+
+ g_return_if_fail (fs != NULL);
+ g_return_if_fail (GTK_IS_FILE_SELECTION (fs));
+ g_return_if_fail (current_directory != NULL);
+
+ list = fs->history_list;
+
+ if (fs->history_menu)
+ {
+ while (list) {
+ callback_arg = list->data;
+ g_free (callback_arg->directory);
+ g_free (callback_arg);
+ list = list->next;
+ }
+ g_list_free (fs->history_list);
+ fs->history_list = NULL;
+
+ gtk_widget_destroy (fs->history_menu);
+ }
+
+ fs->history_menu = gtk_menu_new();
+
+ current_dir = g_strdup (current_directory);
+
+ dir_len = strlen (current_dir);
+
+ for (i = dir_len; i >= 0; i--)
+ {
+ /* the i == dir_len is to catch the full path for the first
+ * entry. */
+ if ( (current_dir[i] == G_DIR_SEPARATOR) || (i == dir_len))
+ {
+ /* another small hack to catch the full path */
+ if (i != dir_len)
+ current_dir[i + 1] = '\0';
+#ifdef __CYGWIN32__
+ if (!strcmp(current_dir, "//"))
+ continue;
+#endif
+ menu_item = gtk_menu_item_new_with_label (current_dir);
+
+ callback_arg = g_new (HistoryCallbackArg, 1);
+ callback_arg->menu_item = menu_item;
+
+ /* since the autocompletion gets confused if you don't
+ * supply a trailing '/' on a dir entry, set the full
+ * (current) path to "" which just refreshes the filesel */
+ if (dir_len == i) {
+ callback_arg->directory = g_strdup ("");
+ } else {
+ callback_arg->directory = g_strdup (current_dir);
+ }
+
+ fs->history_list = g_list_append (fs->history_list, callback_arg);
+
+ gtk_signal_connect (GTK_OBJECT (menu_item), "activate",
+ (GtkSignalFunc) gtk_file_selection_history_callback,
+ (gpointer) fs);
+ gtk_menu_append (GTK_MENU (fs->history_menu), menu_item);
+ gtk_widget_show (menu_item);
}
}
- return handled;
+ gtk_option_menu_set_menu (GTK_OPTION_MENU (fs->history_pulldown),
+ fs->history_menu);
+ g_free (current_dir);
}
static void
-gtk_file_selection_dir_list_changed (GtkList *list,
- gpointer func_data)
+gtk_file_selection_file_button (GtkWidget *widget,
+ gint row,
+ gint column,
+ GdkEventButton *bevent,
+ gpointer user_data)
{
- GtkFileSelection *fs;
+ GtkFileSelection *fs = NULL;
+ gchar *filename, *temp = NULL;
- g_return_if_fail (func_data != NULL);
- g_return_if_fail (GTK_IS_FILE_SELECTION (func_data));
+ g_return_if_fail (GTK_IS_CLIST (widget));
+
+ fs = user_data;
+ g_return_if_fail (fs != NULL);
+ g_return_if_fail (GTK_IS_FILE_SELECTION (fs));
- fs = GTK_FILE_SELECTION (func_data);
+ gtk_clist_get_text (GTK_CLIST (fs->file_list), row, 0, &temp);
+ filename = g_strdup (temp);
+
+#ifdef __CYGWIN32__
+ /* Check to see if the selection was a drive selector */
+ if (isalpha(filename[0]) && (filename[1] == ':')) {
+ /* It is... map it to a CYGWIN32 drive */
+ char temp_filename[10];
+
+ sprintf(temp_filename, "//%c/", tolower(filename[0]));
+ g_free(filename);
+ filename = g_strdup(temp_filename);
+ }
+#endif /* CYGWIN32 */
+
+ if (filename)
+ {
+ if (bevent)
+ switch (bevent->type)
+ {
+ case GDK_2BUTTON_PRESS:
+ gtk_button_clicked (GTK_BUTTON (fs->ok_button));
+ break;
+
+ default:
+ gtk_entry_set_text (GTK_ENTRY (fs->selection_entry), filename);
+ break;
+ }
+ else
+ gtk_entry_set_text (GTK_ENTRY (fs->selection_entry), filename);
- /* only act on an appropriate selection
- */
- if (list->selection && list->selection->data)
- {
- GtkListItem *item;
+ g_free (filename);
+ }
+}
- item = list->selection->data;
-
- if (GTK_IS_LIST_ITEM (item))
- {
- gchar *filename;
-
- filename = gtk_object_get_user_data (GTK_OBJECT (item));
+static void
+gtk_file_selection_dir_button (GtkWidget *widget,
+ gint row,
+ gint column,
+ GdkEventButton *bevent,
+ gpointer user_data)
+{
+ GtkFileSelection *fs = NULL;
+ gchar *filename, *temp = NULL;
+
+ g_return_if_fail (GTK_IS_CLIST (widget));
+
+ fs = GTK_FILE_SELECTION (user_data);
+ g_return_if_fail (fs != NULL);
+ g_return_if_fail (GTK_IS_FILE_SELECTION (fs));
- if (filename)
+ gtk_clist_get_text (GTK_CLIST (fs->dir_list), row, 0, &temp);
+ filename = g_strdup (temp);
+
+ if (filename)
+ {
+ if (bevent)
+ switch (bevent->type)
+ {
+ case GDK_2BUTTON_PRESS:
gtk_file_selection_populate (fs, filename, FALSE);
- }
+ break;
+
+ default:
+ gtk_entry_set_text (GTK_ENTRY (fs->selection_entry), filename);
+ break;
+ }
+ else
+ gtk_entry_set_text (GTK_ENTRY (fs->selection_entry), filename);
+
+ g_free (filename);
}
}
+#ifdef WIN32
+
+static void
+win32_gtk_add_drives_to_dir_list(GtkWidget *the_dir_list)
+{
+ gchar *text[2], *textPtr;
+ gchar buffer[128];
+ char volumeNameBuf[128];
+ char formatBuffer[128];
+ gint row;
+
+ text[1] = NULL;
+
+ /* Get the Drives string */
+ GetLogicalDriveStrings(sizeof(buffer), buffer);
+
+ /* Add the drives as necessary */
+ textPtr = buffer;
+ while (*textPtr != '\0') {
+ /* Get the volume information for this drive */
+ if ((tolower(textPtr[0]) != 'a') && (tolower(textPtr[0]) != 'b'))
+ {
+ /* Ignore floppies (?) */
+ DWORD maxComponentLength, flags;
+
+ GetVolumeInformation(textPtr,
+ volumeNameBuf, sizeof(volumeNameBuf),
+ NULL, &maxComponentLength,
+ &flags, NULL, 0);
+ /* Build the actual displayable string */
+
+ sprintf(formatBuffer, "%c:\\", toupper(textPtr[0]));
+#if 0 /* HB: removed to allow drive change AND directory update with one click */
+ if (strlen(volumeNameBuf) > 0)
+ sprintf(formatBuffer, "%s (%s)", formatBuffer, volumeNameBuf);
+#endif
+ /* Add to the list */
+ text[0] = formatBuffer;
+ row = gtk_clist_append (GTK_CLIST (the_dir_list), text);
+ }
+ textPtr += (strlen(textPtr) + 1);
+ }
+}
+#endif
+
static void
gtk_file_selection_populate (GtkFileSelection *fs,
gchar *rel_path,
{
CompletionState *cmpl_state;
PossibleCompletion* poss;
- GList *dir_list = NULL;
- GList *file_list = NULL;
- GtkWidget *label;
gchar* filename;
+ gint row;
gchar* rem_path = rel_path;
gchar* sel_text;
+ gchar* text[2];
gint did_recurse = FALSE;
gint possible_count = 0;
gint selection_index = -1;
- gint dir_changed_key;
+ gint file_list_width;
+ gint dir_list_width;
g_return_if_fail (fs != NULL);
g_return_if_fail (GTK_IS_FILE_SELECTION (fs));
- dir_changed_key = (gint) gtk_object_get_data (GTK_OBJECT (fs->dir_list), list_changed_key);
- gtk_signal_handler_block (GTK_OBJECT (fs->dir_list), dir_changed_key);
-
cmpl_state = (CompletionState*) fs->cmpl_state;
poss = cmpl_completion_matches (rel_path, &rem_path, cmpl_state);
{
/* Something went wrong. */
gtk_file_selection_abort (fs);
- gtk_signal_handler_unblock (GTK_OBJECT (fs->dir_list), dir_changed_key);
return;
}
g_assert (cmpl_state->reference_dir);
- /* Set the dir_list and file_list to be GLists of strdup'd
- * filenames, including ./ and ../ */
- dir_list = g_list_prepend (dir_list, g_strdup("./"));
- dir_list = g_list_prepend (dir_list, g_strdup("../"));
+ gtk_clist_freeze (GTK_CLIST (fs->dir_list));
+ gtk_clist_clear (GTK_CLIST (fs->dir_list));
+ gtk_clist_freeze (GTK_CLIST (fs->file_list));
+ gtk_clist_clear (GTK_CLIST (fs->file_list));
+
+ /* Set the dir_list to include ./ and ../ */
+ text[1] = NULL;
+ text[0] = "." G_DIR_SEPARATOR_S;
+ row = gtk_clist_append (GTK_CLIST (fs->dir_list), text);
+
+ text[0] = ".." G_DIR_SEPARATOR_S;
+ row = gtk_clist_append (GTK_CLIST (fs->dir_list), text);
+
+ /*reset the max widths of the lists*/
+ dir_list_width = gdk_string_width(fs->dir_list->style->font,".." G_DIR_SEPARATOR_S);
+ gtk_clist_set_column_width(GTK_CLIST(fs->dir_list),0,dir_list_width);
+ file_list_width = 1;
+ gtk_clist_set_column_width(GTK_CLIST(fs->file_list),0,file_list_width);
while (poss)
{
{
possible_count += 1;
- filename = g_strdup (cmpl_this_completion (poss));
+ filename = cmpl_this_completion (poss);
+ text[0] = filename;
+
if (cmpl_is_directory (poss))
{
- if (strcmp (filename, "./") != 0 &&
- strcmp (filename, "../") != 0)
- dir_list = g_list_prepend (dir_list, filename);
- }
+ if (strcmp (filename, "." G_DIR_SEPARATOR_S) != 0 &&
+ strcmp (filename, ".." G_DIR_SEPARATOR_S) != 0)
+ {
+ int width = gdk_string_width(fs->dir_list->style->font,
+ filename);
+ row = gtk_clist_append (GTK_CLIST (fs->dir_list), text);
+ if(width > dir_list_width)
+ {
+ dir_list_width = width;
+ gtk_clist_set_column_width(GTK_CLIST(fs->dir_list),0,
+ width);
+ }
+ }
+ }
else
- file_list = g_list_prepend (file_list, filename);
- }
+ {
+ int width = gdk_string_width(fs->file_list->style->font,
+ filename);
+ row = gtk_clist_append (GTK_CLIST (fs->file_list), text);
+ if(width > file_list_width)
+ {
+ file_list_width = width;
+ gtk_clist_set_column_width(GTK_CLIST(fs->file_list),0,
+ width);
+ }
+ }
+ }
poss = cmpl_next_completion (cmpl_state);
}
+#ifdef WIN32
+ /* For Windows, add drives as potential selections */
+ win32_gtk_add_drives_to_dir_list (fs->dir_list);
+#endif
+
+ gtk_clist_thaw (GTK_CLIST (fs->dir_list));
+ gtk_clist_thaw (GTK_CLIST (fs->file_list));
+
/* File lists are set. */
g_assert (cmpl_state->reference_dir);
if (try_complete)
{
+
/* User is trying to complete filenames, so advance the user's input
* string to the updated_text, which is the common leading substring
* of all possible completions, and if its a directory attempt
if (cmpl_updated_text (cmpl_state)[0])
{
+
if (cmpl_updated_dir (cmpl_state))
{
- gchar* dir_name = g_strdup (cmpl_updated_text (cmpl_state));
+ gchar* dir_name = g_strdup (cmpl_updated_text (cmpl_state));
did_recurse = TRUE;
else
{
if (fs->selection_entry)
- gtk_entry_set_text (GTK_ENTRY (fs->selection_entry),
- cmpl_updated_text (cmpl_state));
+ gtk_entry_set_text (GTK_ENTRY (fs->selection_entry),
+ cmpl_updated_text (cmpl_state));
}
}
else
if (!did_recurse)
{
- GList *file_label_list = NULL;
- GList *dir_label_list = NULL;
-
- /* This reverses the lists. */
- while (file_list)
- {
- label = gtk_list_item_new_with_label (file_list->data);
- gtk_object_set_user_data (GTK_OBJECT (label), file_list->data);
- gtk_widget_show (label);
-
- file_label_list = g_list_prepend (file_label_list, label);
- file_list = file_list->next;
- }
-
- while (dir_list)
- {
- label = gtk_list_item_new_with_label (dir_list->data);
- gtk_object_set_user_data (GTK_OBJECT (label), dir_list->data);
- gtk_widget_show (label);
-
- dir_label_list = g_list_prepend (dir_label_list, label);
- dir_list = dir_list->next;
- }
-
- gtk_container_disable_resize (GTK_CONTAINER (fs));
-
if (fs->selection_entry)
gtk_entry_set_position (GTK_ENTRY (fs->selection_entry), selection_index);
if (fs->selection_entry)
{
- sel_text = g_new (char, strlen (cmpl_reference_position (cmpl_state)) +
- sizeof ("Selection: "));
- strcpy (sel_text, "Selection: ");
- strcat (sel_text, cmpl_reference_position (cmpl_state));
+ sel_text = g_strconcat (_("Selection: "),
+ cmpl_reference_position (cmpl_state),
+ NULL);
- gtk_label_set (GTK_LABEL (fs->selection_text), sel_text);
+ gtk_label_set_text (GTK_LABEL (fs->selection_text), sel_text);
g_free (sel_text);
}
- if (fs->dir_list)
- {
- gtk_container_foreach (GTK_CONTAINER (fs->dir_list),
- gtk_file_selection_free_filename, NULL);
- gtk_list_clear_items (GTK_LIST (fs->dir_list), 0, -1);
-
- if (dir_label_list)
- gtk_list_append_items (GTK_LIST (fs->dir_list), dir_label_list);
- }
- if (fs->file_list)
+ if (fs->history_pulldown)
{
- gtk_container_foreach (GTK_CONTAINER (fs->file_list),
- gtk_file_selection_free_filename, NULL);
- gtk_list_clear_items (GTK_LIST (fs->file_list), 0, -1);
-
- if (file_label_list)
- gtk_list_append_items (GTK_LIST (fs->file_list), file_label_list);
+ gtk_file_selection_update_history_menu (fs, cmpl_reference_position (cmpl_state));
}
-
- gtk_container_enable_resize (GTK_CONTAINER (fs));
- }
- else
- {
- GList *dir_list0 = dir_list;
- GList *file_list0 = file_list;
-
- while (dir_list)
- {
- GList *tmp = dir_list;
- dir_list = dir_list->next;
-
- if (tmp)
- g_free (tmp->data);
- }
-
- while (file_list)
- {
- GList *tmp = file_list;
- file_list = file_list->next;
-
- if (tmp)
- g_free (tmp->data);
- }
-
- g_list_free (dir_list0);
- g_list_free (file_list0);
+
}
-
- gtk_signal_handler_unblock (GTK_OBJECT (fs->dir_list), dir_changed_key);
}
static void
{
gchar err_buf[256];
- sprintf (err_buf, "Directory unreadable: %s", cmpl_strerror (cmpl_errno));
+ sprintf (err_buf, _("Directory unreadable: %s"), cmpl_strerror (cmpl_errno));
/* BEEP gdk_beep(); */
if (fs->selection_entry)
- gtk_label_set (GTK_LABEL (fs->selection_text), err_buf);
+ gtk_label_set_text (GTK_LABEL (fs->selection_text), err_buf);
}
-static void
-gtk_file_selection_free_filename (GtkWidget *widget,
- gpointer client_data)
-{
- g_return_if_fail (widget != NULL);
-
- g_free (gtk_object_get_user_data (GTK_OBJECT (widget)));
- gtk_object_set_user_data (GTK_OBJECT (widget), NULL);
-}
-
-
-
/**********************************************************************/
/* External Interface */
/**********************************************************************/
static gchar*
cmpl_completion_fullname (gchar* text, CompletionState* cmpl_state)
{
- if (text[0] == '/')
+ static char nothing[2] = "";
+
+ if (!cmpl_state_okay (cmpl_state))
+ {
+ return nothing;
+ }
+ else if (g_path_is_absolute (text))
{
strcpy (cmpl_state->updated_text, text);
}
+#ifdef HAVE_PWD_H
else if (text[0] == '~')
{
CompletionDir* dir;
strcpy (cmpl_state->updated_text, dir->fullname);
- slash = strchr (text, '/');
+ slash = strchr (text, G_DIR_SEPARATOR);
if (slash)
strcat (cmpl_state->updated_text, slash);
}
}
+#endif
else
{
strcpy (cmpl_state->updated_text, cmpl_state->reference_dir->fullname);
- strcat (cmpl_state->updated_text, "/");
+ if (cmpl_state->updated_text[strlen (cmpl_state->updated_text) - 1] != G_DIR_SEPARATOR)
+ strcat (cmpl_state->updated_text, G_DIR_SEPARATOR_S);
strcat (cmpl_state->updated_text, text);
}
static CompletionState*
cmpl_init_state (void)
{
- gchar getcwd_buf[2*MAXPATHLEN];
+ gchar *getcwd_buf;
CompletionState *new_state;
new_state = g_new (CompletionState, 1);
- if (!getcwd (getcwd_buf, MAXPATHLEN))
- {
- cmpl_errno = errno;
- return NULL;
- }
+ getcwd_buf = g_get_current_dir ();
+
+tryagain:
new_state->reference_dir = NULL;
new_state->completion_dir = NULL;
new_state->active_completion_dir = NULL;
-
- if ((new_state->user_home_dir = getenv("HOME")) != NULL)
- {
- /* if this fails, get_pwdb will fill it in. */
- new_state->user_home_dir = g_strdup(new_state->user_home_dir);
- }
-
new_state->directory_storage = NULL;
new_state->directory_sent_storage = NULL;
new_state->last_valid_char = 0;
new_state->reference_dir = open_dir (getcwd_buf, new_state);
if (!new_state->reference_dir)
- return NULL;
+ {
+ /* Directories changing from underneath us, grumble */
+ strcpy (getcwd_buf, G_DIR_SEPARATOR_S);
+ goto tryagain;
+ }
+ g_free (getcwd_buf);
return new_state;
}
static void
cmpl_free_state (CompletionState* cmpl_state)
{
- cmpl_free_dir_list(cmpl_state->directory_storage);
- cmpl_free_dir_sent_list(cmpl_state->directory_sent_storage);
+ cmpl_free_dir_list (cmpl_state->directory_storage);
+ cmpl_free_dir_sent_list (cmpl_state->directory_sent_storage);
if (cmpl_state->user_dir_name_buffer)
g_free (cmpl_state->user_dir_name_buffer);
prune_memory_usage(cmpl_state);
- g_assert(text_to_complete);
+ g_assert (text_to_complete != NULL);
cmpl_state->user_completion_index = -1;
cmpl_state->last_completion_text = text_to_complete;
cmpl_state->updated_text[0] = 0;
cmpl_state->re_complete = FALSE;
- first_slash = strchr(text_to_complete, '/');
+#ifdef HAVE_PWD_H
+ first_slash = strchr (text_to_complete, G_DIR_SEPARATOR);
- if(text_to_complete[0] == '~' && !first_slash)
+ if (text_to_complete[0] == '~' && !first_slash)
{
/* Text starts with ~ and there is no slash, show all the
* home directory completions.
*/
- poss = attempt_homedir_completion(text_to_complete, cmpl_state);
+ poss = attempt_homedir_completion (text_to_complete, cmpl_state);
update_cmpl(poss, cmpl_state);
return poss;
}
-
+#endif
cmpl_state->reference_dir =
- open_ref_dir(text_to_complete, remaining_text, cmpl_state);
+ open_ref_dir (text_to_complete, remaining_text, cmpl_state);
if(!cmpl_state->reference_dir)
return NULL;
cmpl_state->completion_dir =
- find_completion_dir(*remaining_text, remaining_text, cmpl_state);
+ find_completion_dir (*remaining_text, remaining_text, cmpl_state);
cmpl_state->last_valid_char = *remaining_text - text_to_complete;
cmpl_state->the_completion.text[0] = 0;
+#ifdef HAVE_PWD_H
if(cmpl_state->user_completion_index >= 0)
poss = attempt_homedir_completion(cmpl_state->last_completion_text, cmpl_state);
else
poss = attempt_file_completion(cmpl_state);
+#else
+ poss = attempt_file_completion(cmpl_state);
+#endif
update_cmpl(poss, cmpl_state);
gchar* first_slash;
CompletionDir *new_dir;
- first_slash = strchr(text_to_complete, '/');
+ first_slash = strchr(text_to_complete, G_DIR_SEPARATOR);
- if (text_to_complete[0] == '/' || !cmpl_state->reference_dir)
+#ifdef __CYGWIN32__
+ if (text_to_complete[0] == '/' && text_to_complete[1] == '/')
{
- new_dir = open_dir("/", cmpl_state);
+ char root_dir[5];
+ sprintf(root_dir, "//%c", text_to_complete[2]);
- if(new_dir)
- *remaining_text = text_to_complete + 1;
+ new_dir = open_dir(root_dir, cmpl_state);
+
+ if (new_dir) {
+ *remaining_text = text_to_complete + 4;
+ }
}
+#else
+ if (FALSE)
+ ;
+#endif
+ else if (g_path_is_absolute (text_to_complete) || !cmpl_state->reference_dir)
+ {
+ char *root;
+ int rootlen;
+
+ rootlen = g_path_skip_root (text_to_complete) - text_to_complete;
+ root = g_malloc (rootlen + 1);
+ memcpy (root, text_to_complete, rootlen);
+ root[rootlen] = '\0';
+ new_dir = open_dir (root, cmpl_state);
+ if (new_dir)
+ *remaining_text = g_path_skip_root (text_to_complete);
+ g_free (root);
+ }
+#ifdef HAVE_PWD_H
else if (text_to_complete[0] == '~')
{
new_dir = open_user_dir(text_to_complete, cmpl_state);
return NULL;
}
}
+#endif
else
{
*remaining_text = text_to_complete;
return new_dir;
}
+#ifdef HAVE_PWD_H
+
/* open a directory by user name */
static CompletionDir*
open_user_dir(gchar* text_to_complete,
g_assert(text_to_complete && text_to_complete[0] == '~');
- first_slash = strchr(text_to_complete, '/');
+ first_slash = strchr(text_to_complete, G_DIR_SEPARATOR);
if (first_slash)
cmp_len = first_slash - text_to_complete - 1;
if(!cmp_len)
{
/* ~/ */
- if (!cmpl_state->user_home_dir &&
- !get_pwdb(cmpl_state))
+ gchar *homedir = g_get_home_dir ();
+
+ if (homedir)
+ return open_dir(homedir, cmpl_state);
+ else
return NULL;
- return open_dir(cmpl_state->user_home_dir, cmpl_state);
}
else
{
}
}
+#endif
+
/* open a directory relative the the current relative directory */
static CompletionDir*
open_relative_dir(gchar* dir_name,
if(dir->fullname_len > 1)
{
- path_buf[dir->fullname_len] = '/';
- strcpy(path_buf + dir->fullname_len + 1, dir_name);
+ if (path_buf[dir->fullname_len - 1] != G_DIR_SEPARATOR)
+ {
+ path_buf[dir->fullname_len] = G_DIR_SEPARATOR;
+ strcpy (path_buf + dir->fullname_len + 1, dir_name);
+ }
+ else
+ strcpy (path_buf + dir->fullname_len, dir_name);
}
else
{
/* after the cache lookup fails, really open a new directory */
static CompletionDirSent*
-open_new_dir(gchar* dir_name, struct stat* sbuf)
+open_new_dir(gchar* dir_name, struct stat* sbuf, gboolean stat_subdirs)
{
CompletionDirSent* sent;
DIR* directory;
sent = g_new(CompletionDirSent, 1);
sent->mtime = sbuf->st_mtime;
sent->inode = sbuf->st_ino;
+ sent->device = sbuf->st_dev;
path_buf_len = strlen(dir_name);
*buffer_ptr = 0;
buffer_ptr += 1;
- path_buf[path_buf_len] = '/';
- strcpy(path_buf + path_buf_len + 1, dirent_ptr->d_name);
+ if (path_buf[path_buf_len-1] != G_DIR_SEPARATOR)
+ {
+ path_buf[path_buf_len] = G_DIR_SEPARATOR;
+ strcpy(path_buf + path_buf_len + 1, dirent_ptr->d_name);
+ }
+ else
+ strcpy(path_buf + path_buf_len, dirent_ptr->d_name);
- if(stat(path_buf, &ent_sbuf) >= 0 && S_ISDIR(ent_sbuf.st_mode))
- sent->entries[i].is_dir = 1;
+ if (stat_subdirs)
+ {
+ if(stat(path_buf, &ent_sbuf) >= 0 && S_ISDIR(ent_sbuf.st_mode))
+ sent->entries[i].is_dir = 1;
+ else
+ /* stat may fail, and we don't mind, since it could be a
+ * dangling symlink. */
+ sent->entries[i].is_dir = 0;
+ }
else
- /* stat may fail, and we don't mind, since it could be a
- * dangling symlink. */
- sent->entries[i].is_dir = 0;
+ sent->entries[i].is_dir = 1;
}
qsort(sent->entries, sent->entry_count, sizeof(CompletionDirEntry), compare_cmpl_dir);
return sent;
}
+#ifndef WIN32
+
+static gboolean
+check_dir(gchar *dir_name, struct stat *result, gboolean *stat_subdirs)
+{
+ /* A list of directories that we know only contain other directories.
+ * Trying to stat every file in these directories would be very
+ * expensive.
+ */
+
+ static struct {
+ gchar *name;
+ gboolean present;
+ struct stat statbuf;
+ } no_stat_dirs[] = {
+ { "/afs", FALSE, { 0 } },
+ { "/net", FALSE, { 0 } }
+ };
+
+ static const gint n_no_stat_dirs = sizeof(no_stat_dirs) / sizeof(no_stat_dirs[0]);
+ static gboolean initialized = FALSE;
+
+ gint i;
+
+ if (!initialized)
+ {
+ initialized = TRUE;
+ for (i = 0; i < n_no_stat_dirs; i++)
+ {
+ if (stat (no_stat_dirs[i].name, &no_stat_dirs[i].statbuf) == 0)
+ no_stat_dirs[i].present = TRUE;
+ }
+ }
+
+ if(stat(dir_name, result) < 0)
+ {
+ cmpl_errno = errno;
+ return FALSE;
+ }
+
+ *stat_subdirs = TRUE;
+ for (i=0; i<n_no_stat_dirs; i++)
+ {
+ if (no_stat_dirs[i].present &&
+ (no_stat_dirs[i].statbuf.st_dev == result->st_dev) &&
+ (no_stat_dirs[i].statbuf.st_ino == result->st_ino))
+ {
+ *stat_subdirs = FALSE;
+ break;
+ }
+ }
+
+ return TRUE;
+}
+
+#endif
+
/* open a directory by absolute pathname */
static CompletionDir*
open_dir(gchar* dir_name, CompletionState* cmpl_state)
{
struct stat sbuf;
+ gboolean stat_subdirs;
CompletionDirSent *sent;
GList* cdsl;
- if(stat(dir_name, &sbuf) < 0)
- {
- cmpl_errno = errno;
- return NULL;
- }
+#ifndef WIN32
+ if (!check_dir (dir_name, &sbuf, &stat_subdirs))
+ return NULL;
cdsl = cmpl_state->directory_sent_storage;
sent = cdsl->data;
if(sent->inode == sbuf.st_ino &&
- sent->mtime == sbuf.st_mtime)
+ sent->mtime == sbuf.st_mtime &&
+ sent->device == sbuf.st_dev)
return attach_dir(sent, dir_name, cmpl_state);
cdsl = cdsl->next;
}
+#else
+ stat_subdirs = TRUE;
+#endif
- sent = open_new_dir(dir_name, &sbuf);
+ sent = open_new_dir(dir_name, &sbuf, stat_subdirs);
if (sent) {
cmpl_state->directory_sent_storage =
correct_dir_fullname(CompletionDir* cmpl_dir)
{
gint length = strlen(cmpl_dir->fullname);
+ gchar *first_slash = strchr(cmpl_dir->fullname, G_DIR_SEPARATOR);
struct stat sbuf;
- if (strcmp(cmpl_dir->fullname + length - 2, "/.") == 0)
+ /* Does it end with /. (\.) ? */
+ if (length >= 2 &&
+ strcmp(cmpl_dir->fullname + length - 2, G_DIR_SEPARATOR_S ".") == 0)
{
- if (length == 2)
+ /* Is it just the root directory (on a drive) ? */
+ if (cmpl_dir->fullname + length - 2 == first_slash)
{
- strcpy(cmpl_dir->fullname, "/");
- cmpl_dir->fullname_len = 1;
+ cmpl_dir->fullname[length - 1] = 0;
+ cmpl_dir->fullname_len = length - 1;
return TRUE;
- } else {
+ }
+ else
+ {
cmpl_dir->fullname[length - 2] = 0;
}
}
- else if (strcmp(cmpl_dir->fullname + length - 3, "/./") == 0)
+
+ /* Ends with /./ (\.\)? */
+ else if (length >= 3 &&
+ strcmp(cmpl_dir->fullname + length - 3,
+ G_DIR_SEPARATOR_S "." G_DIR_SEPARATOR_S) == 0)
cmpl_dir->fullname[length - 2] = 0;
- else if (strcmp(cmpl_dir->fullname + length - 3, "/..") == 0)
+
+ /* Ends with /.. (\..) ? */
+ else if (length >= 3 &&
+ strcmp(cmpl_dir->fullname + length - 3,
+ G_DIR_SEPARATOR_S "..") == 0)
{
- if(length == 3)
+ /* Is it just /.. (X:\..)? */
+ if(cmpl_dir->fullname + length - 3 == first_slash)
{
- strcpy(cmpl_dir->fullname, "/");
- cmpl_dir->fullname_len = 1;
+ cmpl_dir->fullname[length - 2] = 0;
+ cmpl_dir->fullname_len = length - 2;
return TRUE;
}
return FALSE;
}
- cmpl_dir->fullname[length - 2] = 0;
+ cmpl_dir->fullname[length - 3] = 0;
if(!correct_parent(cmpl_dir, &sbuf))
return FALSE;
}
- else if (strcmp(cmpl_dir->fullname + length - 4, "/../") == 0)
+
+ /* Ends with /../ (\..\)? */
+ else if (length >= 4 &&
+ strcmp(cmpl_dir->fullname + length - 4,
+ G_DIR_SEPARATOR_S ".." G_DIR_SEPARATOR_S) == 0)
{
- if(length == 4)
+ /* Is it just /../ (X:\..\)? */
+ if(cmpl_dir->fullname + length - 4 == first_slash)
{
- strcpy(cmpl_dir->fullname, "/");
- cmpl_dir->fullname_len = 1;
+ cmpl_dir->fullname[length - 3] = 0;
+ cmpl_dir->fullname_len = length - 3;
return TRUE;
}
return FALSE;
}
- cmpl_dir->fullname[length - 3] = 0;
+ cmpl_dir->fullname[length - 4] = 0;
if(!correct_parent(cmpl_dir, &sbuf))
return FALSE;
{
struct stat parbuf;
gchar *last_slash;
+ gchar *first_slash;
gchar *new_name;
gchar c = 0;
- last_slash = strrchr(cmpl_dir->fullname, '/');
-
+ last_slash = strrchr(cmpl_dir->fullname, G_DIR_SEPARATOR);
g_assert(last_slash);
+ first_slash = strchr(cmpl_dir->fullname, G_DIR_SEPARATOR);
- if(last_slash != cmpl_dir->fullname)
- { /* last_slash[0] = 0; */ }
+ /* Clever (?) way to check for top-level directory that works also on
+ * Win32, where there is a drive letter and colon prefixed...
+ */
+ if (last_slash != first_slash)
+ {
+ last_slash[0] = 0;
+ }
else
{
c = last_slash[1];
if (stat(cmpl_dir->fullname, &parbuf) < 0)
{
cmpl_errno = errno;
+ if (!c)
+ last_slash[0] = G_DIR_SEPARATOR;
return FALSE;
}
+#ifndef NATIVE_WIN32 /* No inode numbers on Win32 */
if (parbuf.st_ino == sbuf->st_ino && parbuf.st_dev == sbuf->st_dev)
/* it wasn't a link */
return TRUE;
if(c)
last_slash[1] = c;
- /* else
- last_slash[0] = '/'; */
+ else
+ last_slash[0] = G_DIR_SEPARATOR;
/* it was a link, have to figure it out the hard way */
g_free(cmpl_dir->fullname);
cmpl_dir->fullname = new_name;
+#endif
return TRUE;
}
+#ifndef NATIVE_WIN32
+
static gchar*
find_parent_dir_fullname(gchar* dirname)
{
- gchar buffer[MAXPATHLEN];
- gchar buffer2[MAXPATHLEN];
+ gchar *orig_dir;
+ gchar *result;
- if(!getcwd(buffer, MAXPATHLEN))
- {
- cmpl_errno = errno;
- return NULL;
- }
+ orig_dir = g_get_current_dir ();
if(chdir(dirname) != 0 || chdir("..") != 0)
{
return NULL;
}
- if(!getcwd(buffer2, MAXPATHLEN))
- {
- chdir(buffer);
- cmpl_errno = errno;
-
- return NULL;
- }
+ result = g_get_current_dir ();
- if(chdir(buffer) != 0)
+ if(chdir(orig_dir) != 0)
{
cmpl_errno = errno;
return NULL;
}
- return g_strdup(buffer2);
+ g_free (orig_dir);
+ return result;
}
+#endif
+
/**********************************************************************/
/* Completion Operations */
/**********************************************************************/
+#ifdef HAVE_PWD_H
+
static PossibleCompletion*
attempt_homedir_completion(gchar* text_to_complete,
CompletionState *cmpl_state)
user_directories[cmpl_state->user_completion_index].login,
cmpl_state);
- return append_completion_text("/", cmpl_state);
+ return append_completion_text(G_DIR_SEPARATOR_S, cmpl_state);
}
if(text_to_complete[1] ||
cmpl_state->the_completion.is_a_completion = 1;
cmpl_state->the_completion.is_directory = 1;
- return append_completion_text("~/", cmpl_state);
+ return append_completion_text("~" G_DIR_SEPARATOR_S, cmpl_state);
}
}
+#endif
+
+#ifdef WIN32
+#define FOLD(c) (tolower(c))
+#else
+#define FOLD(c) (c)
+#endif
+
/* returns the index (>= 0) of the first differing character,
* PATTERN_MATCH if the completion matches */
static gint
{
gint diff = 0;
- while(*pat && *text && *text == *pat)
+ while(*pat && *text && FOLD(*text) == FOLD(*pat))
{
pat += 1;
text += 1;
gchar** remaining_text,
CompletionState* cmpl_state)
{
- gchar* first_slash = strchr(text_to_complete, '/');
+ gchar* first_slash = strchr(text_to_complete, G_DIR_SEPARATOR);
CompletionDir* dir = cmpl_state->reference_dir;
+ CompletionDir* next;
*remaining_text = text_to_complete;
while(first_slash)
{
gint len = first_slash - *remaining_text;
gint found = 0;
- gint found_index = -1;
+ gchar *found_name = NULL; /* Quiet gcc */
gint i;
gchar* pat_buf = g_new (gchar, len + 1);
else
{
found = 1;
- found_index = i;
+ found_name = dir->sent->entries[i].entry_name;
}
}
}
- if(found)
+ if (!found)
{
- CompletionDir* next = open_relative_dir(dir->sent->entries[found_index].entry_name,
- dir, cmpl_state);
-
- if(!next)
- {
- g_free (pat_buf);
- return NULL;
- }
-
- next->cmpl_parent = dir;
-
- dir = next;
-
- if(!correct_dir_fullname(dir))
- {
- g_free(pat_buf);
- return NULL;
- }
-
- *remaining_text = first_slash + 1;
- first_slash = strchr(*remaining_text, '/');
+ /* Perhaps we are trying to open an automount directory */
+ found_name = pat_buf;
}
- else
+
+ next = open_relative_dir(found_name, dir, cmpl_state);
+
+ if(!next)
{
g_free (pat_buf);
return NULL;
}
+
+ next->cmpl_parent = dir;
+
+ dir = next;
+
+ if(!correct_dir_fullname(dir))
+ {
+ g_free(pat_buf);
+ return NULL;
+ }
+
+ *remaining_text = first_slash + 1;
+ first_slash = strchr(*remaining_text, G_DIR_SEPARATOR);
g_free (pat_buf);
}
g_assert(dir->cmpl_text);
- first_slash = strchr(dir->cmpl_text, '/');
+ first_slash = strchr(dir->cmpl_text, G_DIR_SEPARATOR);
if(first_slash)
{
pat_buf = g_new (gchar, len + 2);
strcpy(pat_buf, dir->cmpl_text);
- strcpy(pat_buf + len, "*");
+ /* Don't append a * if the user entered one herself.
+ * This way one can complete *.h and don't get matches
+ * on any .help files, for instance.
+ */
+ if (strchr(pat_buf, '*') == NULL)
+ strcpy(pat_buf + len, "*");
}
if(first_slash)
append_completion_text(dir->fullname +
strlen(cmpl_state->completion_dir->fullname) + 1,
cmpl_state);
- append_completion_text("/", cmpl_state);
+ append_completion_text(G_DIR_SEPARATOR_S, cmpl_state);
}
append_completion_text(dir->sent->entries[dir->cmpl_index].entry_name, cmpl_state);
cmpl_state->the_completion.is_directory = dir->sent->entries[dir->cmpl_index].is_dir;
if(dir->sent->entries[dir->cmpl_index].is_dir)
- append_completion_text("/", cmpl_state);
+ append_completion_text(G_DIR_SEPARATOR_S, cmpl_state);
g_free (pat_buf);
return &cmpl_state->the_completion;
}
}
+#ifdef HAVE_PWD_H
static gint
get_pwdb(CompletionState* cmpl_state)
{
struct passwd *pwd_ptr;
- gchar* buf_ptr, *home_dir = NULL;
+ gchar* buf_ptr;
gint len = 0, i, count = 0;
if(cmpl_state->user_dir_name_buffer)
count += 1;
}
- if (!cmpl_state->user_home_dir)
- {
- /* the loser doesn't have $HOME set */
- setpwent ();
-
- pwd_ptr = getpwuid(getuid());
- if(!pwd_ptr)
- {
- cmpl_errno = errno;
- goto error;
- }
- home_dir = pwd_ptr->pw_dir;
-
- len += strlen(home_dir);
- len += 1;
- }
-
setpwent ();
cmpl_state->user_dir_name_buffer = g_new(gchar, len);
buf_ptr = cmpl_state->user_dir_name_buffer;
- if (!cmpl_state->user_home_dir)
- {
- strcpy(buf_ptr, home_dir);
- cmpl_state->user_home_dir = buf_ptr;
- buf_ptr += strlen(buf_ptr);
- buf_ptr += 1;
- }
-
for(i = 0; i < count; i += 1)
{
pwd_ptr = getpwent();
(((CompletionUserDir*)b))->login);
}
+#endif
+
static gint
compare_cmpl_dir(const void* a, const void* b)
{
+#ifndef WIN32
return strcmp((((CompletionDirEntry*)a))->entry_name,
(((CompletionDirEntry*)b))->entry_name);
+#else
+ return g_strcasecmp((((CompletionDirEntry*)a))->entry_name,
+ (((CompletionDirEntry*)b))->entry_name);
+#endif
}
static gint
projects / ~andy / gtk / blobdiff