* Copyright (C) 1995-1997 Peter Mattis, Spencer Kimball and Josh MacDonald
*
* This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Library General Public
+ * modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- * Library General Public License for more details.
+ * Lesser 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.
+ * You should have received a copy of the GNU Lesser General Public
+ * 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-2000. 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 <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
+#ifdef HAVE_WINSOCK_H
+#include <winsock.h> /* For gethostname */
+#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 "gtkmain.h"
#include "gtkscrolledwindow.h"
+#include "gtkstock.h"
#include "gtksignal.h"
#include "gtkvbox.h"
#include "gtkmenu.h"
#include "gtkoptionmenu.h"
#include "gtkclist.h"
#include "gtkdialog.h"
+#include "gtkmessagedialog.h"
+#include "gtkintl.h"
+#include "gtkdnd.h"
+#include "gtkeventbox.h"
+
+#if defined(G_OS_WIN32) || defined(G_WITH_CYGWIN)
+#define STRICT
+#include <windows.h>
+
+#ifdef G_OS_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 /* G_OS_WIN32 */
+
+#endif /* G_OS_WIN32 || G_WITH_CYGWIN */
#define DIR_LIST_WIDTH 180
#define DIR_LIST_HEIGHT 180
#define FILE_LIST_WIDTH 180
#define FILE_LIST_HEIGHT 180
+/* The Hurd doesn't define either PATH_MAX or MAXPATHLEN, so we put this
+ * in here, since the rest of the code in the file does require some
+ * fixed maximum.
+ */
+#ifndef MAXPATHLEN
+# ifdef PATH_MAX
+# define MAXPATHLEN PATH_MAX
+# else
+# define MAXPATHLEN 2048
+# endif
+#endif
+
/* I've put this here so it doesn't get confused with the
* file completion interface */
typedef struct _HistoryCallbackArg HistoryCallbackArg;
#define FNMATCH_FLAGS (FNM_PATHNAME | FNM_PERIOD)
#define CMPL_ERRNO_TOO_LONG ((1<<16)-1)
+#define CMPL_ERRNO_DID_NOT_CONVERT ((1<<16)-2)
/* This structure contains all the useful information about a directory
* for the purposes of filename completion. These structures are cached
{
ino_t inode;
time_t mtime;
+ dev_t device;
gint entry_count;
- gchar *name_buffer; /* memory segment containing names of all entries */
-
struct _CompletionDirEntry *entries;
};
*/
struct _CompletionDirEntry
{
- gint is_dir;
+ gboolean is_dir;
gchar *entry_name;
};
*/
gchar *text;
gint is_a_completion;
- gint is_directory;
+ gboolean is_directory;
/* Private fields
*/
gchar *updated_text;
gint updated_text_len;
gint updated_text_alloc;
- gint re_complete;
+ gboolean re_complete;
gchar *user_dir_name_buffer;
gint user_directories_len;
- gchar *user_home_dir;
gchar *last_completion_text;
struct _CompletionUserDir *user_directories;
};
+enum {
+ PROP_0,
+ PROP_SHOW_FILEOPS,
+ PROP_FILENAME
+};
/* File completion functions which would be external, were they used
* outside of this file.
static CompletionState* cmpl_init_state (void);
static void cmpl_free_state (CompletionState *cmpl_state);
static gint cmpl_state_okay (CompletionState* cmpl_state);
-static gchar* cmpl_strerror (gint);
+static const gchar* cmpl_strerror (gint);
static PossibleCompletion* cmpl_completion_matches(gchar *text_to_complete,
gchar **remaining_text,
/* True if the completion is a directory
*/
-static gint cmpl_is_directory (PossibleCompletion*);
+static gboolean cmpl_is_directory (PossibleCompletion*);
/* Obtains the next completion, or NULL
*/
/* After updating, to see if the completion was a directory, call
* this. If it was, you should consider re-calling completion_matches.
*/
-static gint cmpl_updated_dir (CompletionState* cmpl_state);
+static gboolean cmpl_updated_dir (CompletionState* cmpl_state);
/* Current location: if using file completion, return the current
* directory, from which file completion begins. More specifically,
/* When the user selects a non-directory, call cmpl_completion_fullname
* to get the full name of the selected file.
*/
-static gchar* cmpl_completion_fullname (gchar*, CompletionState* cmpl_state);
+static gchar* cmpl_completion_fullname (const gchar*, CompletionState* cmpl_state);
/* Directory operations. */
static CompletionDir* open_ref_dir (gchar* text_to_complete,
gchar** remaining_text,
CompletionState* cmpl_state);
+#if !defined(G_OS_WIN32) && !defined(G_WITH_CYGWIN)
+static gboolean check_dir (gchar *dir_name,
+ struct stat *result,
+ gboolean *stat_subdirs);
+#endif
static CompletionDir* open_dir (gchar* dir_name,
CompletionState* cmpl_state);
-static CompletionDir* open_user_dir (gchar* text_to_complete,
+#ifdef HAVE_PWD_H
+static CompletionDir* open_user_dir (const 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 void gtk_file_selection_class_init (GtkFileSelectionClass *klass);
+static void gtk_file_selection_set_property (GObject *object,
+ guint prop_id,
+ const GValue *value,
+ GParamSpec *pspec);
+static void gtk_file_selection_get_property (GObject *object,
+ guint prop_id,
+ GValue *value,
+ GParamSpec *pspec);
static void gtk_file_selection_init (GtkFileSelection *filesel);
+static void gtk_file_selection_finalize (GObject *object);
static void gtk_file_selection_destroy (GtkObject *object);
static gint gtk_file_selection_key_press (GtkWidget *widget,
GdkEventKey *event,
gpointer user_data);
+static gint gtk_file_selection_insert_text (GtkWidget *widget,
+ const gchar *new_text,
+ gint new_text_length,
+ gint *position,
+ gpointer user_data);
static void gtk_file_selection_file_button (GtkWidget *widget,
gint row,
/* Saves errno when something cmpl does fails. */
static gint cmpl_errno;
-guint
-gtk_file_selection_get_type ()
+#ifdef G_WITH_CYGWIN
+/*
+ * 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)
{
- static guint file_selection_type = 0;
+ 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 = g_strdup_printf ("//%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] = '/';
+
+ updated = 1;
+ }
+
+ return updated;
+}
+#endif
+
+GtkType
+gtk_file_selection_get_type (void)
+{
+ 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_DIALOG, &filesel_info);
}
return file_selection_type;
static void
gtk_file_selection_class_init (GtkFileSelectionClass *class)
{
+ GObjectClass *gobject_class;
GtkObjectClass *object_class;
+ gobject_class = (GObjectClass*) class;
object_class = (GtkObjectClass*) class;
- parent_class = gtk_type_class (gtk_window_get_type ());
-
+ parent_class = gtk_type_class (GTK_TYPE_DIALOG);
+
+ gobject_class->finalize = gtk_file_selection_finalize;
+ gobject_class->set_property = gtk_file_selection_set_property;
+ gobject_class->get_property = gtk_file_selection_get_property;
+
+ g_object_class_install_property (gobject_class,
+ PROP_FILENAME,
+ g_param_spec_string ("filename",
+ _("Filename"),
+ _("The currently selected filename."),
+ NULL,
+ G_PARAM_READABLE | G_PARAM_WRITABLE));
+ g_object_class_install_property (gobject_class,
+ PROP_SHOW_FILEOPS,
+ g_param_spec_boolean ("show_fileops",
+ _("Show file operations"),
+ _("Whether buttons for creating/manipulating files should be displayed."),
+ FALSE,
+ G_PARAM_READABLE |
+ G_PARAM_WRITABLE));
object_class->destroy = gtk_file_selection_destroy;
}
+static void gtk_file_selection_set_property (GObject *object,
+ guint prop_id,
+ const GValue *value,
+ GParamSpec *pspec)
+{
+ GtkFileSelection *filesel;
+
+ filesel = GTK_FILE_SELECTION (object);
+
+ switch (prop_id)
+ {
+ case PROP_FILENAME:
+ gtk_file_selection_set_filename (filesel,
+ g_value_get_string (value));
+ break;
+
+ case PROP_SHOW_FILEOPS:
+ if (g_value_get_boolean (value))
+ gtk_file_selection_show_fileop_buttons (filesel);
+ else
+ gtk_file_selection_hide_fileop_buttons (filesel);
+ break;
+ default:
+ G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+ break;
+ }
+}
+
+static void gtk_file_selection_get_property (GObject *object,
+ guint prop_id,
+ GValue *value,
+ GParamSpec *pspec)
+{
+ GtkFileSelection *filesel;
+
+ filesel = GTK_FILE_SELECTION (object);
+
+ switch (prop_id)
+ {
+ case PROP_FILENAME:
+ g_value_set_string (value,
+ gtk_file_selection_get_filename(filesel));
+ break;
+
+ case PROP_SHOW_FILEOPS:
+ /* This is a little bit hacky, but doing otherwise would require
+ * adding a field to the object.
+ */
+ g_value_set_boolean (value, (filesel->fileop_c_dir &&
+ filesel->fileop_del_file &&
+ filesel->fileop_ren_file));
+ break;
+ default:
+ G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+ break;
+ }
+}
+
+static gboolean
+grab_default (GtkWidget *widget)
+{
+ gtk_widget_grab_default (widget);
+ return FALSE;
+}
+
static void
gtk_file_selection_init (GtkFileSelection *filesel)
{
GtkWidget *entry_vbox;
GtkWidget *label;
GtkWidget *list_hbox;
- GtkWidget *action_area;
+ GtkWidget *confirm_area;
GtkWidget *pulldown_hbox;
- GtkWidget *button_hbox;
- GtkWidget *button;
- char *dir_title [] = { "Directories", };
- char *file_title [] = { "Files", };
+ GtkWidget *scrolled_win;
+ GtkWidget *eventbox;
+ GtkDialog *dialog;
+ char *dir_title [2];
+ char *file_title [2];
+
+ dialog = GTK_DIALOG (filesel);
+
filesel->cmpl_state = cmpl_init_state ();
-
+
/* The dialog-sized vertical box */
- filesel->main_vbox = gtk_vbox_new (FALSE, 10);
- gtk_container_border_width (GTK_CONTAINER (filesel), 10);
- gtk_container_add (GTK_CONTAINER (filesel), filesel->main_vbox);
- gtk_widget_show (filesel->main_vbox);
+ filesel->main_vbox = dialog->vbox;
+ gtk_container_set_border_width (GTK_CONTAINER (filesel), 10);
/* The horizontal box containing create, rename etc. buttons */
- button_hbox = gtk_hbox_new (TRUE, 0);
- gtk_box_pack_start (GTK_BOX (filesel->main_vbox), button_hbox,
+ filesel->button_area = gtk_hbutton_box_new ();
+ gtk_button_box_set_layout (GTK_BUTTON_BOX (filesel->button_area), GTK_BUTTONBOX_START);
+ gtk_box_set_spacing (GTK_BOX (filesel->button_area), 0);
+ gtk_box_pack_start (GTK_BOX (filesel->main_vbox), filesel->button_area,
FALSE, FALSE, 0);
- gtk_widget_show (button_hbox);
-
- /* delete, create directory, and rename */
- button = gtk_button_new_with_label ("Create Dir");
- gtk_signal_connect (GTK_OBJECT (button), "clicked",
- (GtkSignalFunc) gtk_file_selection_create_dir,
- (gpointer) filesel);
- gtk_box_pack_start (GTK_BOX (button_hbox), button, TRUE, TRUE, 0);
- gtk_widget_show (button);
-
- button = gtk_button_new_with_label ("Delete File");
- gtk_signal_connect (GTK_OBJECT (button), "clicked",
- (GtkSignalFunc) gtk_file_selection_delete_file,
- (gpointer) filesel);
- gtk_box_pack_start (GTK_BOX (button_hbox), button, TRUE, TRUE, 0);
- gtk_widget_show (button);
-
- button = gtk_button_new_with_label ("Rename File");
- gtk_signal_connect (GTK_OBJECT (button), "clicked",
- (GtkSignalFunc) gtk_file_selection_rename_file,
- (gpointer) filesel);
- gtk_box_pack_start (GTK_BOX (button_hbox), button, TRUE, TRUE, 0);
- gtk_widget_show (button);
-
- /* The Help button */
- filesel->help_button = gtk_button_new_with_label ("Help");
- gtk_box_pack_start (GTK_BOX (button_hbox), filesel->help_button,
- TRUE, TRUE, 5);
- gtk_widget_show (filesel->help_button);
-
+ 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 (list_hbox);
/* The directories clist */
- filesel->dir_list = gtk_clist_new_with_titles (1, dir_title);
+ 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_set_policy (GTK_CLIST (filesel->dir_list), GTK_POLICY_ALWAYS, GTK_POLICY_AUTOMATIC);
+ gtk_clist_set_column_auto_resize (GTK_CLIST (filesel->dir_list), 0, TRUE);
gtk_clist_column_titles_passive (GTK_CLIST (filesel->dir_list));
- gtk_container_border_width (GTK_CONTAINER (filesel->dir_list), 5);
- gtk_box_pack_start (GTK_BOX (list_hbox), filesel->dir_list, TRUE, TRUE, 0);
+
+ 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);
+ gtk_widget_show (scrolled_win);
/* The files clist */
- filesel->file_list = gtk_clist_new_with_titles (1, file_title);
+ 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_set_policy (GTK_CLIST (filesel->file_list), GTK_POLICY_ALWAYS, GTK_POLICY_AUTOMATIC);
+ gtk_clist_set_column_auto_resize (GTK_CLIST (filesel->file_list), 0, TRUE);
gtk_clist_column_titles_passive (GTK_CLIST (filesel->file_list));
- gtk_container_border_width (GTK_CONTAINER (filesel->file_list), 5);
- gtk_box_pack_start (GTK_BOX (list_hbox), filesel->file_list, TRUE, TRUE, 0);
+
+ 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 = dialog->action_area;
/* The OK button */
- 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);
+ filesel->ok_button = gtk_dialog_add_button (dialog,
+ GTK_STOCK_OK,
+ GTK_RESPONSE_OK);
+
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");
- 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_widget_show (filesel->cancel_button);
+ filesel->cancel_button = gtk_dialog_add_button (dialog,
+ GTK_STOCK_CANCEL,
+ GTK_RESPONSE_CANCEL);
/* 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);
+ gtk_box_pack_end (GTK_BOX (filesel->main_vbox), entry_vbox, FALSE, FALSE, 2);
gtk_widget_show (entry_vbox);
-
+
+ eventbox = gtk_event_box_new ();
filesel->selection_text = label = gtk_label_new ("");
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
- gtk_box_pack_start (GTK_BOX (entry_vbox), label, FALSE, FALSE, 0);
+ gtk_container_add (GTK_CONTAINER (eventbox), label);
+ gtk_box_pack_start (GTK_BOX (entry_vbox), eventbox, FALSE, FALSE, 0);
gtk_widget_show (label);
+ gtk_widget_show (eventbox);
filesel->selection_entry = gtk_entry_new ();
gtk_signal_connect (GTK_OBJECT (filesel->selection_entry), "key_press_event",
(GtkSignalFunc) gtk_file_selection_key_press, filesel);
+ gtk_signal_connect (GTK_OBJECT (filesel->selection_entry), "insert_text",
+ (GtkSignalFunc) gtk_file_selection_insert_text, NULL);
gtk_signal_connect_object (GTK_OBJECT (filesel->selection_entry), "focus_in_event",
- (GtkSignalFunc) gtk_widget_grab_default,
+ (GtkSignalFunc) grab_default,
GTK_OBJECT (filesel->ok_button));
gtk_signal_connect_object (GTK_OBJECT (filesel->selection_entry), "activate",
(GtkSignalFunc) gtk_button_clicked,
{
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
{
gtk_widget_grab_focus (filesel->selection_entry);
}
+static gchar *
+uri_list_extract_first_uri (const gchar* uri_list)
+{
+ const gchar *p, *q;
+
+ g_return_val_if_fail (uri_list != NULL, NULL);
+
+ p = uri_list;
+ /* We don't actually try to validate the URI according to RFC
+ * 2396, or even check for allowed characters - we just ignore
+ * comments and trim whitespace off the ends. We also
+ * allow LF delimination as well as the specified CRLF.
+ *
+ * We do allow comments like specified in RFC 2483.
+ */
+ while (p)
+ {
+ if (*p != '#')
+ {
+ while (g_ascii_isspace(*p))
+ p++;
+
+ q = p;
+ while (*q && (*q != '\n') && (*q != '\r'))
+ q++;
+
+ if (q > p)
+ {
+ q--;
+ while (q > p && g_ascii_isspace (*q))
+ q--;
+
+ if (q > p)
+ return g_strndup (p, q - p + 1);
+ }
+ }
+ p = strchr (p, '\n');
+ if (p)
+ p++;
+ }
+ return NULL;
+}
+
+static void
+dnd_really_drop (GtkWidget *dialog, gint response_id, GtkFileSelection *fs)
+{
+ gchar *filename;
+
+ if (response_id == GTK_RESPONSE_YES)
+ {
+ filename = g_object_get_data (G_OBJECT (dialog), "gtk-fs-dnd-filename");
+
+ gtk_file_selection_set_filename (fs, filename);
+ }
+
+ gtk_widget_destroy (dialog);
+}
+
+
+static void
+filenames_dropped (GtkWidget *widget,
+ GdkDragContext *context,
+ gint x,
+ gint y,
+ GtkSelectionData *selection_data,
+ guint info,
+ guint time)
+{
+ char *uri = NULL;
+ char *filename = NULL;
+ char *hostname;
+ char this_hostname[257];
+ int res;
+ GError *error = NULL;
+
+ if (!selection_data->data)
+ return;
+
+ uri = uri_list_extract_first_uri ((char *)selection_data->data);
+
+ if (!uri)
+ return;
+
+ filename = g_filename_from_uri (uri, &hostname, &error);
+ g_free (uri);
+
+ if (!filename)
+ {
+ g_warning ("Error getting dropped filename: %s\n",
+ error->message);
+ g_error_free (error);
+ return;
+ }
+
+ res = gethostname (this_hostname, 256);
+ this_hostname[256] = 0;
+
+ if ((hostname == NULL) ||
+ (res == 0 && strcmp (hostname, this_hostname) == 0) ||
+ (strcmp (hostname, "localhost") == 0))
+ gtk_file_selection_set_filename (GTK_FILE_SELECTION (widget),
+ filename);
+ else
+ {
+ GtkWidget *dialog;
+
+ dialog = gtk_message_dialog_new (GTK_WINDOW (widget),
+ GTK_DIALOG_DESTROY_WITH_PARENT,
+ GTK_MESSAGE_QUESTION,
+ GTK_BUTTONS_YES_NO,
+ _("The file \"%s\" resides on another machine (called %s) and may not be availible to this program.\n"
+ "Are you sure that you want to select it?"), filename, hostname);
+
+ g_object_set_data_full (G_OBJECT (dialog), "gtk-fs-dnd-filename", g_strdup (filename), g_free);
+
+ g_signal_connect_data (dialog, "response",
+ (GCallback) dnd_really_drop,
+ widget, NULL, 0);
+
+ gtk_widget_show (dialog);
+ }
+
+ g_free (hostname);
+ g_free (filename);
+}
+
+enum
+{
+ TARGET_URILIST,
+ TARGET_UTF8_STRING,
+ TARGET_STRING,
+ TARGET_TEXT,
+ TARGET_COMPOUND_TEXT
+};
+
+
+static void
+filenames_drag_get (GtkWidget *widget,
+ GdkDragContext *context,
+ GtkSelectionData *selection_data,
+ guint info,
+ guint time,
+ GtkFileSelection *filesel)
+{
+ const gchar *file;
+ gchar *uri_list;
+ char hostname[256];
+ int res;
+ GError *error;
+
+ file = gtk_file_selection_get_filename (filesel);
+
+ if (file)
+ {
+ if (info == TARGET_URILIST)
+ {
+ res = gethostname (hostname, 256);
+
+ error = NULL;
+ uri_list = g_filename_to_uri (file, (!res)?hostname:NULL, &error);
+ if (!uri_list)
+ {
+ g_warning ("Error getting filename: %s\n",
+ error->message);
+ g_error_free (error);
+ return;
+ }
+
+ gtk_selection_data_set (selection_data,
+ selection_data->target, 8,
+ (void *)uri_list, strlen((char *)uri_list));
+ g_free (uri_list);
+ }
+ else
+ {
+ g_print ("Setting text: '%s'\n", file);
+ gtk_selection_data_set_text (selection_data, file);
+ }
+ }
+}
+
+static void
+file_selection_setup_dnd (GtkFileSelection *filesel)
+{
+ GtkWidget *eventbox;
+ static GtkTargetEntry drop_types[] = {
+ { "text/uri-list", 0, TARGET_URILIST}
+ };
+ static gint n_drop_types = sizeof(drop_types)/sizeof(drop_types[0]);
+ static GtkTargetEntry drag_types[] = {
+ { "text/uri-list", 0, TARGET_URILIST},
+ { "UTF8_STRING", 0, TARGET_UTF8_STRING },
+ { "STRING", 0, 0 },
+ { "TEXT", 0, 0 },
+ { "COMPOUND_TEXT", 0, 0 }
+ };
+ static gint n_drag_types = sizeof(drag_types)/sizeof(drag_types[0]);
+
+ gtk_drag_dest_set (GTK_WIDGET (filesel),
+ GTK_DEST_DEFAULT_ALL,
+ drop_types, n_drop_types,
+ GDK_ACTION_COPY);
+
+ gtk_signal_connect (GTK_OBJECT(filesel), "drag_data_received",
+ GTK_SIGNAL_FUNC(filenames_dropped), NULL);
+
+ eventbox = gtk_widget_get_parent (filesel->selection_text);
+ gtk_drag_source_set (eventbox,
+ GDK_BUTTON1_MASK,
+ drag_types, n_drag_types,
+ GDK_ACTION_COPY);
+
+ gtk_signal_connect (GTK_OBJECT (eventbox),
+ "drag_data_get",
+ GTK_SIGNAL_FUNC (filenames_drag_get),
+ filesel);
+}
+
GtkWidget*
gtk_file_selection_new (const gchar *title)
{
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);
+ gtk_dialog_set_has_separator (GTK_DIALOG (filesel), FALSE);
+ file_selection_setup_dnd (filesel);
+
return GTK_WIDGET (filesel);
}
+void
+gtk_file_selection_show_fileop_buttons (GtkFileSelection *filesel)
+{
+ 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);
+ }
+ g_object_notify (G_OBJECT (filesel), "show_fileops");
+ gtk_widget_queue_resize (GTK_WIDGET (filesel));
+}
+
+void
+gtk_file_selection_hide_fileop_buttons (GtkFileSelection *filesel)
+{
+ 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;
+ }
+ g_object_notify (G_OBJECT (filesel), "show_fileops");
+}
+
+
+
void
gtk_file_selection_set_filename (GtkFileSelection *filesel,
const gchar *filename)
{
- char buf[MAXPATHLEN];
+ gchar *buf;
const char *name, *last_slash;
- g_return_if_fail (filesel != NULL);
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)
{
- buf[0] = 0;
+ buf = g_strdup ("");
name = filename;
}
else
{
- gint len = MIN (MAXPATHLEN - 1, last_slash - filename + 1);
-
- strncpy (buf, filename, len);
- buf[len] = 0;
-
+ buf = g_strdup (filename);
+ buf[last_slash - filename + 1] = 0;
name = last_slash + 1;
}
if (filesel->selection_entry)
gtk_entry_set_text (GTK_ENTRY (filesel->selection_entry), name);
+ g_free (buf);
+ g_object_notify (G_OBJECT (filesel), "filename");
}
-gchar*
+/**
+ * gtk_file_selection_get_filename:
+ * @filesel: a #GtkFileSelection
+ *
+ * This function returns the selected filename in the C runtime's
+ * multibyte string encoding, which may or may not be the same as that
+ * used by GTK+ (UTF-8). To convert to UTF-8, call g_filename_to_utf8().
+ * The returned string points to a statically allocated buffer and
+ * should be copied if you plan to keep it around.
+ *
+ * Return value: currently-selected filename in locale's encoding
+ **/
+G_CONST_RETURN gchar*
gtk_file_selection_get_filename (GtkFileSelection *filesel)
{
- static char nothing[2] = "";
- char *text;
- char *filename;
+ static gchar nothing[2] = "";
+ static gchar something[MAXPATHLEN*2];
+ char *sys_filename;
+ const char *text;
- g_return_val_if_fail (filesel != NULL, nothing);
g_return_val_if_fail (GTK_IS_FILE_SELECTION (filesel), nothing);
+#ifdef G_WITH_CYGWIN
+ translate_win32_path (filesel);
+#endif
text = gtk_entry_get_text (GTK_ENTRY (filesel->selection_entry));
if (text)
{
- filename = cmpl_completion_fullname (text, filesel->cmpl_state);
- return filename;
+ sys_filename = g_filename_from_utf8 (cmpl_completion_fullname (text, filesel->cmpl_state), -1, NULL, NULL, NULL);
+ if (!sys_filename)
+ return nothing;
+ strncpy (something, sys_filename, sizeof (something));
+ g_free (sys_filename);
+ return something;
}
return nothing;
}
+void
+gtk_file_selection_complete (GtkFileSelection *filesel,
+ const gchar *pattern)
+{
+ 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);
+ {
+ gtk_widget_destroy (filesel->fileop_dialog);
+ filesel->fileop_dialog = NULL;
+ }
if (filesel->history_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;
}
+
+ if (filesel->cmpl_state)
+ {
+ cmpl_free_state (filesel->cmpl_state);
+ filesel->cmpl_state = NULL;
+ }
- cmpl_free_state (filesel->cmpl_state);
- filesel->cmpl_state = NULL;
+ GTK_OBJECT_CLASS (parent_class)->destroy (object);
+}
- if (GTK_OBJECT_CLASS (parent_class)->destroy)
- (* GTK_OBJECT_CLASS (parent_class)->destroy) (object);
+static void
+gtk_file_selection_finalize (GObject *object)
+{
+ GtkFileSelection *filesel = GTK_FILE_SELECTION (object);
+
+ g_free (filesel->fileop_file);
}
/* Begin file operations callbacks */
static void
-gtk_file_selection_fileop_error (gchar *error_message)
+gtk_file_selection_fileop_error (GtkFileSelection *fs,
+ gchar *error_message)
{
- 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_position (GTK_WINDOW (dialog), GTK_WIN_POS_MOUSE);
-
- vbox = gtk_vbox_new(FALSE, 0);
- gtk_container_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);
+ /* main dialog */
+ dialog = gtk_message_dialog_new (GTK_WINDOW (fs),
+ GTK_DIALOG_DESTROY_WITH_PARENT,
+ GTK_MESSAGE_ERROR,
+ GTK_BUTTONS_CLOSE,
+ "%s", error_message);
/* 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",
+
+ gtk_window_set_modal (GTK_WINDOW (dialog), TRUE);
+
+ gtk_signal_connect_object (GTK_OBJECT (dialog), "response",
(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 void
-gtk_file_selection_fileop_destroy (GtkWidget *widget, gpointer data)
+gtk_file_selection_fileop_destroy (GtkWidget *widget,
+ gpointer data)
{
GtkFileSelection *fs = data;
- g_return_if_fail (fs != NULL);
g_return_if_fail (GTK_IS_FILE_SELECTION (fs));
fs->fileop_dialog = NULL;
static void
-gtk_file_selection_create_dir_confirmed (GtkWidget *widget, gpointer data)
+gtk_file_selection_create_dir_confirmed (GtkWidget *widget,
+ gpointer data)
{
GtkFileSelection *fs = data;
- gchar *dirname;
+ const gchar *dirname;
gchar *path;
gchar *full_path;
+ gchar *sys_full_path;
gchar *buf;
+ GError *error = NULL;
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, "/", dirname, NULL);
- if ( (mkdir (full_path, 0755) < 0) )
+ full_path = g_strconcat (path, G_DIR_SEPARATOR_S, dirname, NULL);
+ sys_full_path = g_filename_from_utf8 (full_path, -1, NULL, NULL, &error);
+ if (error)
{
- buf = g_strconcat ("Error creating directory \"", dirname, "\": ",
- g_strerror(errno), NULL);
- gtk_file_selection_fileop_error (buf);
+ if (g_error_matches (error, G_CONVERT_ERROR, G_CONVERT_ERROR_ILLEGAL_SEQUENCE))
+ buf = g_strdup_printf (_("The directory name \"%s\" contains symbols that are not allowed in filenames"), dirname);
+ else
+ buf = g_strdup_printf (_("Error creating directory \"%s\": %s\n%s"), dirname, error->message,
+ _("You probably used symbols not allowed in filenames."));
+ gtk_file_selection_fileop_error (fs, buf);
+ g_error_free (error);
+ goto out;
}
+
+ if (mkdir (sys_full_path, 0755) < 0)
+ {
+ buf = g_strdup_printf (_("Error creating directory \"%s\": %s\n"), dirname,
+ g_strerror (errno));
+ gtk_file_selection_fileop_error (fs, buf);
+ }
+
+ out:
g_free (full_path);
+ g_free (sys_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)
+gtk_file_selection_create_dir (GtkWidget *widget,
+ gpointer data)
{
GtkFileSelection *fs = data;
GtkWidget *label;
GtkWidget *vbox;
GtkWidget *button;
- g_return_if_fail (fs != NULL);
g_return_if_fail (GTK_IS_FILE_SELECTION (fs));
if (fs->fileop_dialog)
- return;
+ return;
/* main dialog */
- fs->fileop_dialog = dialog = gtk_dialog_new ();
+ dialog = gtk_dialog_new ();
+ fs->fileop_dialog = dialog;
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_position (GTK_WINDOW (dialog), GTK_WIN_POS_MOUSE);
- gtk_widget_show (dialog);
-
- vbox = gtk_vbox_new(FALSE, 0);
- gtk_container_border_width(GTK_CONTAINER(vbox), 8);
- gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->vbox), vbox,
+ 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);
+ 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);
+ label = gtk_label_new_with_mnemonic (_("_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_label_set_mnemonic_widget (GTK_LABEL (label), fs->fileop_entry);
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_SET_FLAGS (fs->fileop_entry, GTK_CAN_DEFAULT);
gtk_widget_show (fs->fileop_entry);
/* buttons */
- button = gtk_button_new_with_label ("Create");
+ 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),
+ 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);
+ GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
+ gtk_widget_show (button);
- button = gtk_button_new_with_label ("Cancel");
+ 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),
+ 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_SET_FLAGS (button, GTK_CAN_DEFAULT);
+ gtk_widget_grab_default (button);
gtk_widget_show (button);
+
+ gtk_widget_show (dialog);
}
static void
-gtk_file_selection_delete_file_confirmed (GtkWidget *widget, gpointer data)
+gtk_file_selection_delete_file_confirmed (GtkWidget *widget,
+ gpointer data)
{
GtkFileSelection *fs = data;
CompletionState *cmpl_state;
gchar *path;
gchar *full_path;
+ gchar *sys_full_path;
+ GError *error = NULL;
gchar *buf;
- g_return_if_fail (fs != NULL);
g_return_if_fail (GTK_IS_FILE_SELECTION (fs));
cmpl_state = (CompletionState*) fs->cmpl_state;
path = cmpl_reference_position (cmpl_state);
- full_path = g_strconcat (path, "/", fs->fileop_file, NULL);
- if ( (unlink (full_path) < 0) )
+ full_path = g_strconcat (path, G_DIR_SEPARATOR_S, fs->fileop_file, NULL);
+ sys_full_path = g_filename_from_utf8 (full_path, -1, NULL, NULL, &error);
+ if (error)
{
- buf = g_strconcat ("Error deleting file \"", fs->fileop_file, "\": ",
- g_strerror(errno), NULL);
- gtk_file_selection_fileop_error (buf);
+ if (g_error_matches (error, G_CONVERT_ERROR, G_CONVERT_ERROR_ILLEGAL_SEQUENCE))
+ buf = g_strdup_printf (_("The filename \"%s\" contains symbols that are not allowed in filenames"),
+ fs->fileop_file);
+ else
+ buf = g_strdup_printf (_("Error deleting file \"%s\": %s\n%s"),
+ fs->fileop_file, error->message,
+ _("It probably contains symbols not allowed in filenames."));
+
+ gtk_file_selection_fileop_error (fs, buf);
+ g_error_free (error);
+ goto out;
}
+
+ if (unlink (sys_full_path) < 0)
+ {
+ buf = g_strdup_printf (_("Error deleting file \"%s\": %s"),
+ fs->fileop_file, g_strerror (errno));
+ gtk_file_selection_fileop_error (fs, buf);
+ }
+
+ out:
g_free (full_path);
+ g_free (sys_full_path);
gtk_widget_destroy (fs->fileop_dialog);
gtk_file_selection_populate (fs, "", FALSE);
}
static void
-gtk_file_selection_delete_file (GtkWidget *widget, gpointer data)
+gtk_file_selection_delete_file (GtkWidget *widget,
+ gpointer data)
{
GtkFileSelection *fs = data;
GtkWidget *label;
GtkWidget *vbox;
GtkWidget *button;
GtkWidget *dialog;
- gchar *filename;
+ const gchar *filename;
gchar *buf;
- g_return_if_fail (fs != NULL);
g_return_if_fail (GTK_IS_FILE_SELECTION (fs));
if (fs->fileop_dialog)
return;
+#ifdef G_WITH_CYGWIN
+ translate_win32_path (fs);
+#endif
+
filename = gtk_entry_get_text (GTK_ENTRY (fs->selection_entry));
- if (strlen(filename) < 1)
- return;
+ if (strlen (filename) < 1)
+ return;
- fs->fileop_file = filename;
+ g_free (fs->fileop_file);
+ fs->fileop_file = g_strdup (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_position (GTK_WINDOW (dialog), GTK_WIN_POS_MOUSE);
+ 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_border_width(GTK_CONTAINER(vbox), 8);
- gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->vbox), vbox,
+ 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);
+ 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);
+ 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");
+ 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);
+ 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");
+ 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_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 void
-gtk_file_selection_rename_file_confirmed (GtkWidget *widget, gpointer data)
+gtk_file_selection_rename_file_confirmed (GtkWidget *widget,
+ gpointer data)
{
GtkFileSelection *fs = data;
gchar *buf;
- gchar *file;
+ const gchar *file;
gchar *path;
gchar *new_filename;
gchar *old_filename;
+ gchar *sys_new_filename;
+ gchar *sys_old_filename;
CompletionState *cmpl_state;
+ GError *error = NULL;
- g_return_if_fail (fs != NULL);
g_return_if_fail (GTK_IS_FILE_SELECTION (fs));
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, "/", file, NULL);
- old_filename = g_strconcat (path, "/", fs->fileop_file, NULL);
+ new_filename = g_strconcat (path, G_DIR_SEPARATOR_S, file, NULL);
+ old_filename = g_strconcat (path, G_DIR_SEPARATOR_S, fs->fileop_file, NULL);
- if ( (rename (old_filename, new_filename)) < 0)
+ sys_new_filename = g_filename_from_utf8 (new_filename, -1, NULL, NULL, &error);
+ if (error)
{
- buf = g_strconcat ("Error renaming file \"", file, "\": ",
- g_strerror(errno), NULL);
- gtk_file_selection_fileop_error (buf);
+ if (g_error_matches (error, G_CONVERT_ERROR, G_CONVERT_ERROR_ILLEGAL_SEQUENCE))
+ buf = g_strdup_printf (_("The file name \"%s\" contains symbols that are not allowed in filenames"), new_filename);
+ else
+ buf = g_strdup_printf (_("Error renaming file to \"%s\": %s\n%s"),
+ new_filename, error->message,
+ _("You probably used symbols not allowed in filenames."));
+ gtk_file_selection_fileop_error (fs, buf);
+ g_error_free (error);
+ goto out1;
}
+
+ sys_old_filename = g_filename_from_utf8 (old_filename, -1, NULL, NULL, &error);
+ if (error)
+ {
+ if (g_error_matches (error, G_CONVERT_ERROR, G_CONVERT_ERROR_ILLEGAL_SEQUENCE))
+ buf = g_strdup_printf (_("The file name \"%s\" contains symbols that are not allowed in filenames"), old_filename);
+ else
+ buf = g_strdup_printf (_("Error renaming file \"%s\": %s\n%s"),
+ old_filename, error->message,
+ _("It probably contains symbols not allowed in filenames."));
+ gtk_file_selection_fileop_error (fs, buf);
+ g_error_free (error);
+ goto out2;
+ }
+
+ if (rename (sys_old_filename, sys_new_filename) < 0)
+ {
+ buf = g_strdup_printf (_("Error renaming file \"%s\" to \"%s\": %s"),
+ sys_old_filename, sys_new_filename,
+ g_strerror (errno));
+ gtk_file_selection_fileop_error (fs, buf);
+ }
+
+ out2:
+ g_free (sys_old_filename);
+
+ out1:
g_free (new_filename);
g_free (old_filename);
+ g_free (sys_new_filename);
gtk_widget_destroy (fs->fileop_dialog);
gtk_file_selection_populate (fs, "", FALSE);
}
static void
-gtk_file_selection_rename_file (GtkWidget *widget, gpointer data)
+gtk_file_selection_rename_file (GtkWidget *widget,
+ gpointer data)
{
GtkFileSelection *fs = data;
GtkWidget *label;
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;
+ g_free (fs->fileop_file);
+ fs->fileop_file = g_strdup (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_position (GTK_WINDOW (dialog), GTK_WIN_POS_MOUSE);
- gtk_widget_show (dialog);
+ 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_border_width(GTK_CONTAINER(vbox), 8);
- gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->vbox), vbox,
- FALSE, FALSE, 0);
+ 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);
+ 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_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_entry_select_region (GTK_ENTRY (fs->fileop_entry),
- 0, strlen (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");
+ 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);
+ 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");
+ 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_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_insert_text (GtkWidget *widget,
+ const gchar *new_text,
+ gint new_text_length,
+ gint *position,
+ gpointer user_data)
+{
+ gchar *filename;
+
+ filename = g_filename_from_utf8 (new_text, new_text_length, NULL, NULL, NULL);
+
+ if (!filename)
+ {
+ gdk_beep ();
+ gtk_signal_emit_stop_by_name (GTK_OBJECT (widget), "insert_text");
+ return FALSE;
+ }
+
+ g_free (filename);
+
+ return TRUE;
+}
static gint
gtk_file_selection_key_press (GtkWidget *widget,
g_return_val_if_fail (widget != NULL, FALSE);
g_return_val_if_fail (event != NULL, FALSE);
- if (event->keyval == GDK_Tab)
+ if (event->keyval == GDK_Tab ||
+ event->keyval == GDK_ISO_Left_Tab ||
+ event->keyval == GDK_KP_Tab)
{
- gtk_signal_emit_stop_by_name (GTK_OBJECT (widget), "key_press_event");
-
fs = GTK_FILE_SELECTION (user_data);
- text = gtk_entry_get_text (GTK_ENTRY (fs->selection_entry));
+#ifdef G_WITH_CYGWIN
+ translate_win32_path (fs);
+#endif
+ text = g_strdup (gtk_entry_get_text (GTK_ENTRY (fs->selection_entry)));
+
gtk_file_selection_populate (fs, text, TRUE);
+ g_free (text);
+
return TRUE;
}
static void
-gtk_file_selection_history_callback (GtkWidget *widget, gpointer data)
+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;
static void
gtk_file_selection_update_history_menu (GtkFileSelection *fs,
- gchar *current_directory)
+ gchar *current_directory)
{
HistoryCallbackArg *callback_arg;
GtkWidget *menu_item;
GList *list;
gchar *current_dir;
- gchar *directory;
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);
while (list) {
callback_arg = list->data;
g_free (callback_arg->directory);
+ g_free (callback_arg);
list = list->next;
}
g_list_free (fs->history_list);
gtk_widget_destroy (fs->history_menu);
}
- fs->history_menu = gtk_menu_new();
+ fs->history_menu = gtk_menu_new ();
current_dir = g_strdup (current_directory);
{
/* the i == dir_len is to catch the full path for the first
* entry. */
- if ( (current_dir[i] == '/') || (i == dir_len))
+ 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 G_WITH_CYGWIN
+ if (!strcmp (current_dir, "//"))
+ continue;
+#endif
menu_item = gtk_menu_item_new_with_label (current_dir);
- directory = g_strdup (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 = directory;
- }
+ 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_menu_shell_append (GTK_MENU_SHELL (fs->history_menu), menu_item);
gtk_widget_show (menu_item);
}
}
g_free (current_dir);
}
+static void
+gtk_file_selection_file_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 = user_data;
+ g_return_if_fail (GTK_IS_FILE_SELECTION (fs));
+
+ gtk_clist_get_text (GTK_CLIST (fs->file_list), row, 0, &temp);
+ filename = g_strdup (temp);
+
+#ifdef G_WITH_CYGWIN
+ /* Check to see if the selection was a drive selector */
+ if (isalpha (filename[0]) && (filename[1] == ':'))
+ {
+ /* It is... map it to a CYGWIN32 drive */
+ gchar *temp_filename = g_strdup_printf ("//%c/", tolower (filename[0]));
+ g_free(filename);
+ filename = temp_filename;
+ }
+#endif /* G_WITH_CYGWIN */
+
+ 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);
+
+ g_free (filename);
+ }
+}
static void
-gtk_file_selection_file_button (GtkWidget *widget,
- gint row,
- gint column,
+gtk_file_selection_dir_button (GtkWidget *widget,
+ gint row,
+ gint column,
GdkEventButton *bevent,
- gpointer user_data)
+ gpointer user_data)
{
GtkFileSelection *fs = NULL;
- gchar *filename;
-
+ gchar *filename, *temp = NULL;
+
g_return_if_fail (GTK_IS_CLIST (widget));
- fs = user_data;
- g_return_if_fail (fs != NULL);
+ fs = GTK_FILE_SELECTION (user_data);
g_return_if_fail (GTK_IS_FILE_SELECTION (fs));
- filename = gtk_clist_get_row_data (GTK_CLIST (fs->file_list), row);
-
- if (bevent && filename)
+ gtk_clist_get_text (GTK_CLIST (fs->dir_list), row, 0, &temp);
+ filename = g_strdup (temp);
+
+ if (filename)
{
- switch (bevent->type)
- {
- case GDK_BUTTON_PRESS:
- gtk_entry_set_text (GTK_ENTRY (fs->selection_entry), filename);
- break;
-
- case GDK_2BUTTON_PRESS:
- gtk_button_clicked (GTK_BUTTON (fs->ok_button));
- break;
+ if (bevent)
+ switch (bevent->type)
+ {
+ case GDK_2BUTTON_PRESS:
+ gtk_file_selection_populate (fs, filename, FALSE);
+ break;
- default:
- 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);
}
}
+#if defined(G_OS_WIN32) || defined(G_WITH_CYGWIN)
+
static void
-gtk_file_selection_dir_button (GtkWidget *widget,
- gint row,
- gint column,
- GdkEventButton *bevent,
- gpointer user_data)
+win32_gtk_add_drives_to_dir_list (GtkWidget *the_dir_list)
{
- GtkFileSelection *fs = NULL;
- gchar *filename;
-
- g_return_if_fail (GTK_IS_CLIST (widget));
+ gchar *text[2], *textPtr;
+ gchar buffer[128];
+ char volumeNameBuf[128];
+ char formatBuffer[128];
- fs = GTK_FILE_SELECTION (user_data);
- g_return_if_fail (fs != NULL);
- g_return_if_fail (GTK_IS_FILE_SELECTION (fs));
+ text[1] = NULL;
- filename = gtk_clist_get_row_data (GTK_CLIST (fs->dir_list), row);
-
- if (bevent && filename) {
-
- switch (bevent->type)
+ /* 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'))
{
- case GDK_BUTTON_PRESS:
- gtk_entry_set_text (GTK_ENTRY (fs->selection_entry), filename);
- break;
-
- case GDK_2BUTTON_PRESS:
- gtk_file_selection_populate (fs, filename, FALSE);
- break;
-
- default:
- break;
+ /* 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;
+ gtk_clist_append (GTK_CLIST (the_dir_list), text);
}
+ textPtr += (strlen (textPtr) + 1);
}
}
+#endif
static void
gtk_file_selection_populate (GtkFileSelection *fs,
CompletionState *cmpl_state;
PossibleCompletion* poss;
gchar* filename;
- gint row;
gchar* rem_path = rel_path;
gchar* sel_text;
gchar* text[2];
gint possible_count = 0;
gint selection_index = -1;
- g_return_if_fail (fs != NULL);
g_return_if_fail (GTK_IS_FILE_SELECTION (fs));
cmpl_state = (CompletionState*) fs->cmpl_state;
/* Set the dir_list to include ./ and ../ */
text[1] = NULL;
- text[0] = "./";
- row = gtk_clist_append (GTK_CLIST (fs->dir_list), text);
- gtk_clist_set_row_data (GTK_CLIST (fs->dir_list), row, "./");
+ text[0] = "." G_DIR_SEPARATOR_S;
+ gtk_clist_append (GTK_CLIST (fs->dir_list), text);
- text[0] = "../";
- row = gtk_clist_append (GTK_CLIST (fs->dir_list), text);
- gtk_clist_set_row_data (GTK_CLIST (fs->dir_list), row, "../");
+ text[0] = ".." G_DIR_SEPARATOR_S;
+ gtk_clist_append (GTK_CLIST (fs->dir_list), text);
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)
- {
- row = gtk_clist_append (GTK_CLIST (fs->dir_list), text);
- gtk_clist_set_row_data (GTK_CLIST (fs->dir_list), row,
- filename);
- }
+ if (strcmp (filename, "." G_DIR_SEPARATOR_S) != 0 &&
+ strcmp (filename, ".." G_DIR_SEPARATOR_S) != 0)
+ gtk_clist_append (GTK_CLIST (fs->dir_list), text);
}
else
{
- row = gtk_clist_append (GTK_CLIST (fs->file_list), text);
- gtk_clist_set_row_data (GTK_CLIST (fs->file_list), row,
- filename);
+ gtk_clist_append (GTK_CLIST (fs->file_list), text);
}
}
poss = cmpl_next_completion (cmpl_state);
}
+#if defined(G_OS_WIN32) || defined(G_WITH_CYGWIN)
+ /* 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));
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);
}
{
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);
}
/**********************************************************************/
/* The four completion state selectors
*/
static gchar*
-cmpl_updated_text (CompletionState* cmpl_state)
+cmpl_updated_text (CompletionState *cmpl_state)
{
return cmpl_state->updated_text;
}
-static gint
-cmpl_updated_dir (CompletionState* cmpl_state)
+static gboolean
+cmpl_updated_dir (CompletionState *cmpl_state)
{
return cmpl_state->re_complete;
}
static gchar*
-cmpl_reference_position (CompletionState* cmpl_state)
+cmpl_reference_position (CompletionState *cmpl_state)
{
return cmpl_state->reference_dir->fullname;
}
static gint
-cmpl_last_valid_char (CompletionState* cmpl_state)
+cmpl_last_valid_char (CompletionState *cmpl_state)
{
return cmpl_state->last_valid_char;
}
static gchar*
-cmpl_completion_fullname (gchar* text, CompletionState* cmpl_state)
+cmpl_completion_fullname (const 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);
}
return pc->text;
}
-static gint
+static gboolean
cmpl_is_directory (PossibleCompletion* pc)
{
return pc->is_directory;
static CompletionState*
cmpl_init_state (void)
{
- gchar getcwd_buf[2*MAXPATHLEN];
+ gchar *sys_getcwd_buf;
+ gchar *utf8_cwd;
CompletionState *new_state;
new_state = g_new (CompletionState, 1);
- if (!getcwd (getcwd_buf, MAXPATHLEN))
- {
- cmpl_errno = errno;
- return NULL;
- }
+ /* g_get_current_dir() returns a string in the "system" charset */
+ sys_getcwd_buf = g_get_current_dir ();
+ utf8_cwd = g_filename_to_utf8 (sys_getcwd_buf, -1, NULL, NULL, NULL);
+ g_free (sys_getcwd_buf);
+
+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->user_dir_name_buffer = NULL;
new_state->user_directories = NULL;
- new_state->reference_dir = open_dir (getcwd_buf, new_state);
+ new_state->reference_dir = open_dir (utf8_cwd, new_state);
if (!new_state->reference_dir)
- return NULL;
+ {
+ /* Directories changing from underneath us, grumble */
+ strcpy (utf8_cwd, G_DIR_SEPARATOR_S);
+ goto tryagain;
+ }
+ g_free (utf8_cwd);
return new_state;
}
static void
-cmpl_free_dir_list(GList* dp0)
+cmpl_free_dir_list (GList* dp0)
{
GList *dp = dp0;
- while (dp) {
- free_dir (dp->data);
- dp = dp->next;
- }
+ while (dp)
+ {
+ free_dir (dp->data);
+ dp = dp->next;
+ }
- g_list_free(dp0);
+ g_list_free (dp0);
}
static void
-cmpl_free_dir_sent_list(GList* dp0)
+cmpl_free_dir_sent_list (GList* dp0)
{
GList *dp = dp0;
- while (dp) {
- free_dir_sent (dp->data);
- dp = dp->next;
- }
+ while (dp)
+ {
+ free_dir_sent (dp->data);
+ dp = dp->next;
+ }
- g_list_free(dp0);
+ g_list_free (dp0);
}
static void
cmpl_free_state (CompletionState* cmpl_state)
{
+ g_return_if_fail (cmpl_state != NULL);
+
cmpl_free_dir_list (cmpl_state->directory_storage);
cmpl_free_dir_sent_list (cmpl_state->directory_sent_storage);
}
static void
-free_dir(CompletionDir* dir)
+free_dir (CompletionDir* dir)
{
- g_free(dir->fullname);
- g_free(dir);
+ g_free (dir->fullname);
+ g_free (dir);
}
static void
-free_dir_sent(CompletionDirSent* sent)
+free_dir_sent (CompletionDirSent* sent)
{
- g_free(sent->name_buffer);
- g_free(sent->entries);
- g_free(sent);
+ gint i;
+ for (i = 0; i < sent->entry_count; i++)
+ g_free (sent->entries[i].entry_name);
+ g_free (sent->entries);
+ g_free (sent);
}
static void
-prune_memory_usage(CompletionState *cmpl_state)
+prune_memory_usage (CompletionState *cmpl_state)
{
GList* cdsl = cmpl_state->directory_sent_storage;
GList* cdl = cmpl_state->directory_storage;
GList* cdl0 = cdl;
gint len = 0;
- for(; cdsl && len < CMPL_DIRECTORY_CACHE_SIZE; len += 1)
+ for (; cdsl && len < CMPL_DIRECTORY_CACHE_SIZE; len += 1)
cdsl = cdsl->next;
- if (cdsl) {
- cmpl_free_dir_sent_list(cdsl->next);
- cdsl->next = NULL;
- }
+ if (cdsl)
+ {
+ cmpl_free_dir_sent_list (cdsl->next);
+ cdsl->next = NULL;
+ }
cmpl_state->directory_storage = NULL;
- while (cdl) {
- if (cdl->data == cmpl_state->reference_dir)
- cmpl_state->directory_storage = g_list_prepend(NULL, cdl->data);
- else
- free_dir (cdl->data);
- cdl = cdl->next;
- }
+ while (cdl)
+ {
+ if (cdl->data == cmpl_state->reference_dir)
+ cmpl_state->directory_storage = g_list_prepend (NULL, cdl->data);
+ else
+ free_dir (cdl->data);
+ cdl = cdl->next;
+ }
- g_list_free(cdl0);
+ g_list_free (cdl0);
}
/**********************************************************************/
/**********************************************************************/
static PossibleCompletion*
-cmpl_completion_matches (gchar* text_to_complete,
- gchar** remaining_text,
- CompletionState* cmpl_state)
+cmpl_completion_matches (gchar *text_to_complete,
+ gchar **remaining_text,
+ CompletionState *cmpl_state)
{
gchar* first_slash;
PossibleCompletion *poss;
- prune_memory_usage(cmpl_state);
+ 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);
+ 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)
+ 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;
- if(!cmpl_state->completion_dir)
+ if (!cmpl_state->completion_dir)
return NULL;
cmpl_state->completion_dir->cmpl_index = -1;
cmpl_state->reference_dir = cmpl_state->completion_dir;
- poss = attempt_file_completion(cmpl_state);
+ poss = attempt_file_completion (cmpl_state);
- update_cmpl(poss, cmpl_state);
+ update_cmpl (poss, cmpl_state);
return poss;
}
cmpl_state->the_completion.text[0] = 0;
- if(cmpl_state->user_completion_index >= 0)
- poss = attempt_homedir_completion(cmpl_state->last_completion_text, cmpl_state);
+#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);
+ poss = attempt_file_completion (cmpl_state);
+#else
+ poss = attempt_file_completion (cmpl_state);
+#endif
- update_cmpl(poss, cmpl_state);
+ update_cmpl (poss, cmpl_state);
return poss;
}
/* Open the directory where completion will begin from, if possible. */
static CompletionDir*
-open_ref_dir(gchar* text_to_complete,
- gchar** remaining_text,
- CompletionState* cmpl_state)
+open_ref_dir (gchar *text_to_complete,
+ gchar **remaining_text,
+ CompletionState *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 G_WITH_CYGWIN
+ 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]);
+
+ new_dir = open_dir (root_dir, cmpl_state);
- if(new_dir)
- *remaining_text = text_to_complete + 1;
+ if (new_dir) {
+ *remaining_text = text_to_complete + 4;
+ }
}
+#else
+ if (FALSE)
+ ;
+#endif
+#ifdef HAVE_PWD_H
else if (text_to_complete[0] == '~')
{
- new_dir = open_user_dir(text_to_complete, cmpl_state);
+ new_dir = open_user_dir (text_to_complete, cmpl_state);
- if(new_dir)
+ if (new_dir)
{
- if(first_slash)
+ if (first_slash)
*remaining_text = first_slash + 1;
else
- *remaining_text = text_to_complete + strlen(text_to_complete);
+ *remaining_text = text_to_complete + strlen (text_to_complete);
}
else
{
return NULL;
}
}
+#endif
+ else if (g_path_is_absolute (text_to_complete) || !cmpl_state->reference_dir)
+ {
+ gchar *tmp = g_strdup (text_to_complete);
+ gchar *p;
+
+ p = tmp;
+ while (*p && *p != '*' && *p != '?')
+ p++;
+
+ *p = '\0';
+ p = strrchr (tmp, G_DIR_SEPARATOR);
+ if (p)
+ {
+ if (p == tmp)
+ p++;
+
+ *p = '\0';
+
+ new_dir = open_dir (tmp, cmpl_state);
+
+ if (new_dir)
+ *remaining_text = text_to_complete +
+ ((p == tmp + 1) ? (p - tmp) : (p + 1 - tmp));
+ }
+ else
+ {
+ /* If no possible candidates, use the cwd */
+ gchar *sys_curdir = g_get_current_dir ();
+ gchar *utf8_curdir = g_filename_to_utf8 (sys_curdir, -1, NULL, NULL, NULL);
+
+ g_free (sys_curdir);
+
+ new_dir = open_dir (utf8_curdir, cmpl_state);
+
+ if (new_dir)
+ *remaining_text = text_to_complete;
+
+ g_free (utf8_curdir);
+ }
+
+ g_free (tmp);
+ }
else
{
*remaining_text = text_to_complete;
- new_dir = open_dir(cmpl_state->reference_dir->fullname, cmpl_state);
+ new_dir = open_dir (cmpl_state->reference_dir->fullname, cmpl_state);
}
- if(new_dir)
+ if (new_dir)
{
new_dir->cmpl_index = -1;
new_dir->cmpl_parent = NULL;
return new_dir;
}
+#ifdef HAVE_PWD_H
+
/* open a directory by user name */
static CompletionDir*
-open_user_dir(gchar* text_to_complete,
- CompletionState *cmpl_state)
+open_user_dir (const gchar *text_to_complete,
+ CompletionState *cmpl_state)
{
+ CompletionDir *result;
gchar *first_slash;
gint cmp_len;
- g_assert(text_to_complete && text_to_complete[0] == '~');
+ 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;
else
- cmp_len = strlen(text_to_complete + 1);
+ cmp_len = strlen (text_to_complete + 1);
- if(!cmp_len)
+ if (!cmp_len)
{
/* ~/ */
- if (!cmpl_state->user_home_dir &&
- !get_pwdb(cmpl_state))
- return NULL;
- return open_dir(cmpl_state->user_home_dir, cmpl_state);
+ const gchar *homedir = g_get_home_dir ();
+ gchar *utf8_homedir = g_filename_to_utf8 (homedir, -1, NULL, NULL, NULL);
+
+ if (utf8_homedir)
+ result = open_dir (utf8_homedir, cmpl_state);
+ else
+ result = NULL;
+
+ g_free (utf8_homedir);
}
else
{
/* ~user/ */
- char* copy = g_new(char, cmp_len + 1);
+ gchar* copy = g_new (char, cmp_len + 1);
+ gchar *utf8_dir;
struct passwd *pwd;
- strncpy(copy, text_to_complete + 1, cmp_len);
+
+ strncpy (copy, text_to_complete + 1, cmp_len);
copy[cmp_len] = 0;
- pwd = getpwnam(copy);
- g_free(copy);
+ pwd = getpwnam (copy);
+ g_free (copy);
if (!pwd)
{
cmpl_errno = errno;
return NULL;
}
-
- return open_dir(pwd->pw_dir, cmpl_state);
+ utf8_dir = g_filename_to_utf8 (pwd->pw_dir, -1, NULL, NULL, NULL);
+ result = open_dir (utf8_dir, cmpl_state);
+ g_free (utf8_dir);
}
+ return result;
}
+#endif
+
/* open a directory relative the the current relative directory */
static CompletionDir*
-open_relative_dir(gchar* dir_name,
- CompletionDir* dir,
- CompletionState *cmpl_state)
+open_relative_dir (gchar *dir_name,
+ CompletionDir *dir,
+ CompletionState *cmpl_state)
{
- gchar path_buf[2*MAXPATHLEN];
+ CompletionDir *result;
+ GString *path;
- if(dir->fullname_len + strlen(dir_name) + 2 >= MAXPATHLEN)
- {
- cmpl_errno = CMPL_ERRNO_TOO_LONG;
- return NULL;
- }
+ path = g_string_sized_new (dir->fullname_len + strlen (dir_name) + 10);
+ g_string_assign (path, dir->fullname);
- strcpy(path_buf, dir->fullname);
+ if (dir->fullname_len > 1
+ && path->str[dir->fullname_len - 1] != G_DIR_SEPARATOR)
+ g_string_append_c (path, G_DIR_SEPARATOR);
+ g_string_append (path, dir_name);
- if(dir->fullname_len > 1)
- {
- path_buf[dir->fullname_len] = '/';
- strcpy(path_buf + dir->fullname_len + 1, dir_name);
- }
- else
- {
- strcpy(path_buf + dir->fullname_len, dir_name);
- }
+ result = open_dir (path->str, cmpl_state);
- return open_dir(path_buf, cmpl_state);
+ g_string_free (path, TRUE);
+
+ return result;
}
/* 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;
- gchar *buffer_ptr;
+ CompletionDirSent *sent;
+ DIR *directory;
struct dirent *dirent_ptr;
- gint buffer_size = 0;
gint entry_count = 0;
+ gint n_entries = 0;
gint i;
struct stat ent_sbuf;
- char path_buf[MAXPATHLEN*2];
- gint path_buf_len;
+ GString *path;
+ gchar *sys_dir_name;
- sent = g_new(CompletionDirSent, 1);
+ 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);
+ path = g_string_sized_new (2*MAXPATHLEN + 10);
- if (path_buf_len > MAXPATHLEN)
+ sys_dir_name = g_filename_from_utf8 (dir_name, -1, NULL, NULL, NULL);
+ if (!sys_dir_name)
{
- cmpl_errno = CMPL_ERRNO_TOO_LONG;
+ cmpl_errno = CMPL_ERRNO_DID_NOT_CONVERT;
return NULL;
}
-
- strcpy(path_buf, dir_name);
-
- directory = opendir(dir_name);
-
- if(!directory)
+
+ directory = opendir (sys_dir_name);
+ if (!directory)
{
cmpl_errno = errno;
+ g_free (sys_dir_name);
return NULL;
}
- while((dirent_ptr = readdir(directory)) != NULL)
- {
- int entry_len = strlen(dirent_ptr->d_name);
- buffer_size += entry_len + 1;
- entry_count += 1;
-
- if(path_buf_len + entry_len + 2 >= MAXPATHLEN)
- {
- cmpl_errno = CMPL_ERRNO_TOO_LONG;
- closedir(directory);
- return NULL;
- }
- }
+ while ((dirent_ptr = readdir (directory)) != NULL)
+ entry_count++;
- sent->name_buffer = g_new(gchar, buffer_size);
- sent->entries = g_new(CompletionDirEntry, entry_count);
+ sent->entries = g_new (CompletionDirEntry, entry_count);
sent->entry_count = entry_count;
- buffer_ptr = sent->name_buffer;
+ rewinddir (directory);
- rewinddir(directory);
-
- for(i = 0; i < entry_count; i += 1)
+ for (i = 0; i < entry_count; i += 1)
{
- dirent_ptr = readdir(directory);
+ dirent_ptr = readdir (directory);
- if(!dirent_ptr)
+ if (!dirent_ptr)
{
cmpl_errno = errno;
- closedir(directory);
+ closedir (directory);
+ g_free (sys_dir_name);
return NULL;
}
- strcpy(buffer_ptr, dirent_ptr->d_name);
- sent->entries[i].entry_name = buffer_ptr;
- buffer_ptr += strlen(dirent_ptr->d_name);
- *buffer_ptr = 0;
- buffer_ptr += 1;
+ sent->entries[n_entries].entry_name = g_filename_to_utf8 (dirent_ptr->d_name, -1, NULL, NULL, NULL);
+ if (!g_utf8_validate (sent->entries[n_entries].entry_name, -1, NULL))
+ {
+ g_warning (_("The filename %s couldn't be converted to UTF-8. Try setting the environment variable G_BROKEN_FILENAMES."), dirent_ptr->d_name);
+ continue;
+ }
- path_buf[path_buf_len] = '/';
- strcpy(path_buf + path_buf_len + 1, dirent_ptr->d_name);
+ g_string_assign (path, sys_dir_name);
+ if (path->str[path->len-1] != G_DIR_SEPARATOR)
+ {
+ g_string_append_c (path, G_DIR_SEPARATOR);
+ }
+ g_string_append (path, 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)
+ {
+ /* Here we know path->str is a "system charset" string */
+ if (stat (path->str, &ent_sbuf) >= 0 && S_ISDIR (ent_sbuf.st_mode))
+ sent->entries[n_entries].is_dir = TRUE;
+ else
+ /* stat may fail, and we don't mind, since it could be a
+ * dangling symlink. */
+ sent->entries[n_entries].is_dir = FALSE;
+ }
else
- /* stat may fail, and we don't mind, since it could be a
- * dangling symlink. */
- sent->entries[i].is_dir = 0;
- }
+ sent->entries[n_entries].is_dir = 1;
- qsort(sent->entries, sent->entry_count, sizeof(CompletionDirEntry), compare_cmpl_dir);
+ n_entries++;
+ }
+ sent->entry_count = n_entries;
+
+ g_free (sys_dir_name);
+ g_string_free (path, TRUE);
+ qsort (sent->entries, sent->entry_count, sizeof (CompletionDirEntry), compare_cmpl_dir);
- closedir(directory);
+ closedir (directory);
return sent;
}
+#if !defined(G_OS_WIN32) && !defined(G_WITH_CYGWIN)
+
+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 = G_N_ELEMENTS (no_stat_dirs);
+ static gboolean initialized = FALSE;
+ gchar *sys_dir_name;
+ 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;
+ }
+ }
+
+ sys_dir_name = g_filename_from_utf8 (dir_name, -1, NULL, NULL, NULL);
+ if (!sys_dir_name)
+ {
+ cmpl_errno = CMPL_ERRNO_DID_NOT_CONVERT;
+ return FALSE;
+ }
+
+ if (stat (sys_dir_name, result) < 0)
+ {
+ g_free (sys_dir_name);
+ cmpl_errno = errno;
+ return FALSE;
+ }
+ g_free (sys_dir_name);
+
+ *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)
+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;
- }
+#if !defined(G_OS_WIN32) && !defined(G_WITH_CYGWIN)
+ 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)
- return attach_dir(sent, dir_name, cmpl_state);
+ if (sent->inode == sbuf.st_ino &&
+ 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 =
- g_list_prepend(cmpl_state->directory_sent_storage, sent);
+ if (sent)
+ {
+ cmpl_state->directory_sent_storage =
+ g_list_prepend (cmpl_state->directory_sent_storage, sent);
- return attach_dir(sent, dir_name, cmpl_state);
- }
+ return attach_dir (sent, dir_name, cmpl_state);
+ }
return NULL;
}
static CompletionDir*
-attach_dir(CompletionDirSent* sent, gchar* dir_name, CompletionState *cmpl_state)
+attach_dir (CompletionDirSent *sent,
+ gchar *dir_name,
+ CompletionState *cmpl_state)
{
CompletionDir* new_dir;
- new_dir = g_new(CompletionDir, 1);
+ new_dir = g_new (CompletionDir, 1);
cmpl_state->directory_storage =
- g_list_prepend(cmpl_state->directory_storage, new_dir);
+ g_list_prepend (cmpl_state->directory_storage, new_dir);
new_dir->sent = sent;
- new_dir->fullname = g_strdup(dir_name);
- new_dir->fullname_len = strlen(dir_name);
+ new_dir->fullname = g_strdup (dir_name);
+ new_dir->fullname_len = strlen (dir_name);
return new_dir;
}
static gint
-correct_dir_fullname(CompletionDir* cmpl_dir)
+correct_dir_fullname (CompletionDir* cmpl_dir)
{
- gint length = strlen(cmpl_dir->fullname);
+ gint length = strlen (cmpl_dir->fullname);
+ gchar *first_slash = strchr (cmpl_dir->fullname, G_DIR_SEPARATOR);
+ gchar *sys_filename;
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;
}
- if(stat(cmpl_dir->fullname, &sbuf) < 0)
+ sys_filename = g_filename_from_utf8 (cmpl_dir->fullname, -1, NULL, NULL, NULL);
+ if (!sys_filename)
+ {
+ cmpl_errno = CMPL_ERRNO_DID_NOT_CONVERT;
+ return FALSE;
+ }
+
+ if (stat (sys_filename, &sbuf) < 0)
{
+ g_free (sys_filename);
cmpl_errno = errno;
return FALSE;
}
+ g_free (sys_filename);
- cmpl_dir->fullname[length - 2] = 0;
+ cmpl_dir->fullname[length - 3] = 0;
- if(!correct_parent(cmpl_dir, &sbuf))
+ 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;
}
- if(stat(cmpl_dir->fullname, &sbuf) < 0)
+ sys_filename = g_filename_from_utf8 (cmpl_dir->fullname, -1, NULL, NULL, NULL);
+ if (!sys_filename)
+ {
+ cmpl_errno = CMPL_ERRNO_DID_NOT_CONVERT;
+ return FALSE;
+ }
+
+ if (stat (sys_filename, &sbuf) < 0)
{
+ g_free (sys_filename);
cmpl_errno = errno;
return FALSE;
}
+ g_free (sys_filename);
- cmpl_dir->fullname[length - 3] = 0;
+ cmpl_dir->fullname[length - 4] = 0;
- if(!correct_parent(cmpl_dir, &sbuf))
+ if (!correct_parent (cmpl_dir, &sbuf))
return FALSE;
}
- cmpl_dir->fullname_len = strlen(cmpl_dir->fullname);
+ cmpl_dir->fullname_len = strlen (cmpl_dir->fullname);
return TRUE;
}
static gint
-correct_parent(CompletionDir* cmpl_dir, struct stat *sbuf)
+correct_parent (CompletionDir *cmpl_dir,
+ struct stat *sbuf)
{
struct stat parbuf;
gchar *last_slash;
+ gchar *first_slash;
gchar *new_name;
+ gchar *sys_filename;
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);
- g_assert(last_slash);
-
- 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];
last_slash[1] = 0;
}
- if (stat(cmpl_dir->fullname, &parbuf) < 0)
+ sys_filename = g_filename_from_utf8 (cmpl_dir->fullname, -1, NULL, NULL, NULL);
+ if (!sys_filename)
+ {
+ cmpl_errno = CMPL_ERRNO_DID_NOT_CONVERT;
+ if (!c)
+ last_slash[0] = G_DIR_SEPARATOR;
+ return FALSE;
+ }
+
+ if (stat (sys_filename, &parbuf) < 0)
{
+ g_free (sys_filename);
cmpl_errno = errno;
+ if (!c)
+ last_slash[0] = G_DIR_SEPARATOR;
return FALSE;
}
+ g_free (sys_filename);
+#ifndef G_OS_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)
+ 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 */
- new_name = find_parent_dir_fullname(cmpl_dir->fullname);
+ new_name = find_parent_dir_fullname (cmpl_dir->fullname);
if (!new_name)
return FALSE;
- g_free(cmpl_dir->fullname);
+ g_free (cmpl_dir->fullname);
cmpl_dir->fullname = new_name;
+#endif
return TRUE;
}
+#ifndef G_OS_WIN32
+
static gchar*
-find_parent_dir_fullname(gchar* dirname)
+find_parent_dir_fullname (gchar* dirname)
{
- gchar buffer[MAXPATHLEN];
- gchar buffer2[MAXPATHLEN];
+ gchar *sys_orig_dir;
+ gchar *result;
+ gchar *sys_cwd;
+ gchar *sys_dirname;
- if(!getcwd(buffer, MAXPATHLEN))
+ sys_orig_dir = g_get_current_dir ();
+ sys_dirname = g_filename_from_utf8 (dirname, -1, NULL, NULL, NULL);
+ if (!sys_dirname)
{
- cmpl_errno = errno;
+ g_free (sys_orig_dir);
+ cmpl_errno = CMPL_ERRNO_DID_NOT_CONVERT;
return NULL;
}
-
- if(chdir(dirname) != 0 || chdir("..") != 0)
+
+ if (chdir (sys_dirname) != 0 || chdir ("..") != 0)
{
+ g_free (sys_dirname);
+ g_free (sys_orig_dir);
cmpl_errno = errno;
return NULL;
}
+ g_free (sys_dirname);
- if(!getcwd(buffer2, MAXPATHLEN))
- {
- chdir(buffer);
- cmpl_errno = errno;
-
- return NULL;
- }
+ sys_cwd = g_get_current_dir ();
+ result = g_filename_to_utf8 (sys_cwd, -1, NULL, NULL, NULL);
+ g_free (sys_cwd);
- if(chdir(buffer) != 0)
+ if (chdir (sys_orig_dir) != 0)
{
cmpl_errno = errno;
+ g_free (sys_orig_dir);
return NULL;
}
- return g_strdup(buffer2);
+ g_free (sys_orig_dir);
+ return result;
}
+#endif
+
/**********************************************************************/
/* Completion Operations */
/**********************************************************************/
+#ifdef HAVE_PWD_H
+
static PossibleCompletion*
-attempt_homedir_completion(gchar* text_to_complete,
- CompletionState *cmpl_state)
+attempt_homedir_completion (gchar *text_to_complete,
+ CompletionState *cmpl_state)
{
gint index, length;
if (!cmpl_state->user_dir_name_buffer &&
- !get_pwdb(cmpl_state))
+ !get_pwdb (cmpl_state))
return NULL;
- length = strlen(text_to_complete) - 1;
+ length = strlen (text_to_complete) - 1;
cmpl_state->user_completion_index += 1;
- while(cmpl_state->user_completion_index < cmpl_state->user_directories_len)
+ while (cmpl_state->user_completion_index < cmpl_state->user_directories_len)
{
- index = first_diff_index(text_to_complete + 1,
- cmpl_state->user_directories
- [cmpl_state->user_completion_index].login);
+ index = first_diff_index (text_to_complete + 1,
+ cmpl_state->user_directories
+ [cmpl_state->user_completion_index].login);
- switch(index)
+ switch (index)
{
case PATTERN_MATCH:
break;
default:
- if(cmpl_state->last_valid_char < (index + 1))
+ if (cmpl_state->last_valid_char < (index + 1))
cmpl_state->last_valid_char = index + 1;
cmpl_state->user_completion_index += 1;
continue;
}
cmpl_state->the_completion.is_a_completion = 1;
- cmpl_state->the_completion.is_directory = 1;
+ cmpl_state->the_completion.is_directory = TRUE;
- append_completion_text("~", cmpl_state);
+ append_completion_text ("~", cmpl_state);
- append_completion_text(cmpl_state->
+ append_completion_text (cmpl_state->
user_directories[cmpl_state->user_completion_index].login,
- cmpl_state);
+ 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->user_completion_index > cmpl_state->user_directories_len)
+ if (text_to_complete[1]
+ || cmpl_state->user_completion_index > cmpl_state->user_directories_len)
{
cmpl_state->user_completion_index = -1;
return NULL;
{
cmpl_state->user_completion_index += 1;
cmpl_state->the_completion.is_a_completion = 1;
- cmpl_state->the_completion.is_directory = 1;
+ cmpl_state->the_completion.is_directory = TRUE;
- return append_completion_text("~/", cmpl_state);
+ return append_completion_text ("~" G_DIR_SEPARATOR_S, cmpl_state);
}
}
+#endif
+
+#if defined(G_OS_WIN32) || defined(G_WITH_CYGWIN)
+#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
-first_diff_index(gchar* pat, gchar* text)
+first_diff_index (gchar *pat,
+ gchar *text)
{
gint diff = 0;
- while(*pat && *text && *text == *pat)
+ while (*pat && *text && FOLD (*text) == FOLD (*pat))
{
pat += 1;
text += 1;
diff += 1;
}
- if(*pat)
+ if (*pat)
return diff;
return PATTERN_MATCH;
}
static PossibleCompletion*
-append_completion_text(gchar* text, CompletionState* cmpl_state)
+append_completion_text (gchar *text,
+ CompletionState *cmpl_state)
{
gint len, i = 1;
- if(!cmpl_state->the_completion.text)
+ if (!cmpl_state->the_completion.text)
return NULL;
- len = strlen(text) + strlen(cmpl_state->the_completion.text) + 1;
+ len = strlen (text) + strlen (cmpl_state->the_completion.text) + 1;
- if(cmpl_state->the_completion.text_alloc > len)
+ if (cmpl_state->the_completion.text_alloc > len)
{
- strcat(cmpl_state->the_completion.text, text);
+ strcat (cmpl_state->the_completion.text, text);
return &cmpl_state->the_completion;
}
- while(i < len) { i <<= 1; }
+ while (i < len)
+ i <<= 1;
cmpl_state->the_completion.text_alloc = i;
- cmpl_state->the_completion.text = (gchar*)g_realloc(cmpl_state->the_completion.text, i);
+ cmpl_state->the_completion.text = (gchar*) g_realloc (cmpl_state->the_completion.text, i);
- if(!cmpl_state->the_completion.text)
+ if (!cmpl_state->the_completion.text)
return NULL;
else
{
- strcat(cmpl_state->the_completion.text, text);
+ strcat (cmpl_state->the_completion.text, text);
return &cmpl_state->the_completion;
}
}
static CompletionDir*
-find_completion_dir(gchar* text_to_complete,
- gchar** remaining_text,
- CompletionState* cmpl_state)
+find_completion_dir (gchar *text_to_complete,
+ 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)
+ 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);
- strncpy(pat_buf, *remaining_text, len);
+ strncpy (pat_buf, *remaining_text, len);
pat_buf[len] = 0;
- for(i = 0; i < dir->sent->entry_count; i += 1)
+ for (i = 0; i < dir->sent->entry_count; i += 1)
{
- if(dir->sent->entries[i].is_dir &&
- fnmatch(pat_buf, dir->sent->entries[i].entry_name,
- FNMATCH_FLAGS)!= FNM_NOMATCH)
+ if (dir->sent->entries[i].is_dir &&
+ fnmatch (pat_buf, dir->sent->entries[i].entry_name,
+ FNMATCH_FLAGS)!= FNM_NOMATCH)
{
- if(found)
+ if (found)
{
g_free (pat_buf);
return dir;
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;
- }
+ /* Perhaps we are trying to open an automount directory */
+ found_name = pat_buf;
+ }
- *remaining_text = first_slash + 1;
- first_slash = strchr(*remaining_text, '/');
+ next = open_relative_dir (found_name, dir, cmpl_state);
+
+ if (!next)
+ {
+ g_free (pat_buf);
+ return NULL;
}
- else
+
+ 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);
}
}
static void
-update_cmpl(PossibleCompletion* poss, CompletionState* cmpl_state)
+update_cmpl (PossibleCompletion *poss,
+ CompletionState *cmpl_state)
{
gint cmpl_len;
- if(!poss || !cmpl_is_a_completion(poss))
+ if (!poss || !cmpl_is_a_completion (poss))
return;
- cmpl_len = strlen(cmpl_this_completion(poss));
+ cmpl_len = strlen (cmpl_this_completion (poss));
- if(cmpl_state->updated_text_alloc < cmpl_len + 1)
+ if (cmpl_state->updated_text_alloc < cmpl_len + 1)
{
cmpl_state->updated_text =
- (gchar*)g_realloc(cmpl_state->updated_text,
- cmpl_state->updated_text_alloc);
+ (gchar*)g_realloc (cmpl_state->updated_text,
+ cmpl_state->updated_text_alloc);
cmpl_state->updated_text_alloc = 2*cmpl_len;
}
- if(cmpl_state->updated_text_len < 0)
+ if (cmpl_state->updated_text_len < 0)
{
- strcpy(cmpl_state->updated_text, cmpl_this_completion(poss));
+ strcpy (cmpl_state->updated_text, cmpl_this_completion (poss));
cmpl_state->updated_text_len = cmpl_len;
- cmpl_state->re_complete = cmpl_is_directory(poss);
+ cmpl_state->re_complete = cmpl_is_directory (poss);
}
- else if(cmpl_state->updated_text_len == 0)
+ else if (cmpl_state->updated_text_len == 0)
{
cmpl_state->re_complete = FALSE;
}
else
{
gint first_diff =
- first_diff_index(cmpl_state->updated_text,
- cmpl_this_completion(poss));
+ first_diff_index (cmpl_state->updated_text,
+ cmpl_this_completion (poss));
cmpl_state->re_complete = FALSE;
- if(first_diff == PATTERN_MATCH)
+ if (first_diff == PATTERN_MATCH)
return;
- if(first_diff > cmpl_state->updated_text_len)
- strcpy(cmpl_state->updated_text, cmpl_this_completion(poss));
+ if (first_diff > cmpl_state->updated_text_len)
+ strcpy (cmpl_state->updated_text, cmpl_this_completion (poss));
cmpl_state->updated_text_len = first_diff;
cmpl_state->updated_text[first_diff] = 0;
}
static PossibleCompletion*
-attempt_file_completion(CompletionState *cmpl_state)
+attempt_file_completion (CompletionState *cmpl_state)
{
gchar *pat_buf, *first_slash;
CompletionDir *dir = cmpl_state->active_completion_dir;
dir->cmpl_index += 1;
- if(dir->cmpl_index == dir->sent->entry_count)
+ if (dir->cmpl_index == dir->sent->entry_count)
{
- if(dir->cmpl_parent == NULL)
+ if (dir->cmpl_parent == NULL)
{
cmpl_state->active_completion_dir = NULL;
{
cmpl_state->active_completion_dir = dir->cmpl_parent;
- return attempt_file_completion(cmpl_state);
+ return attempt_file_completion (cmpl_state);
}
}
- g_assert(dir->cmpl_text);
+ g_assert (dir->cmpl_text);
- first_slash = strchr(dir->cmpl_text, '/');
+ first_slash = strchr (dir->cmpl_text, G_DIR_SEPARATOR);
- if(first_slash)
+ if (first_slash)
{
gint len = first_slash - dir->cmpl_text;
pat_buf = g_new (gchar, len + 1);
- strncpy(pat_buf, dir->cmpl_text, len);
+ strncpy (pat_buf, dir->cmpl_text, len);
pat_buf[len] = 0;
}
else
{
- gint len = strlen(dir->cmpl_text);
+ gint len = strlen (dir->cmpl_text);
pat_buf = g_new (gchar, len + 2);
- strcpy(pat_buf, dir->cmpl_text);
- strcpy(pat_buf + len, "*");
+ strcpy (pat_buf, dir->cmpl_text);
+ /* 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)
+ if (first_slash)
{
- if(dir->sent->entries[dir->cmpl_index].is_dir)
+ if (dir->sent->entries[dir->cmpl_index].is_dir)
{
- if(fnmatch(pat_buf, dir->sent->entries[dir->cmpl_index].entry_name,
- FNMATCH_FLAGS) != FNM_NOMATCH)
+ if (fnmatch (pat_buf, dir->sent->entries[dir->cmpl_index].entry_name,
+ FNMATCH_FLAGS) != FNM_NOMATCH)
{
CompletionDir* new_dir;
- new_dir = open_relative_dir(dir->sent->entries[dir->cmpl_index].entry_name,
- dir, cmpl_state);
+ new_dir = open_relative_dir (dir->sent->entries[dir->cmpl_index].entry_name,
+ dir, cmpl_state);
- if(!new_dir)
+ if (!new_dir)
{
g_free (pat_buf);
return NULL;
cmpl_state->active_completion_dir = new_dir;
g_free (pat_buf);
- return attempt_file_completion(cmpl_state);
+ return attempt_file_completion (cmpl_state);
}
else
{
g_free (pat_buf);
- return attempt_file_completion(cmpl_state);
+ return attempt_file_completion (cmpl_state);
}
}
else
{
g_free (pat_buf);
- return attempt_file_completion(cmpl_state);
+ return attempt_file_completion (cmpl_state);
}
}
else
{
- if(dir->cmpl_parent != NULL)
+ if (dir->cmpl_parent != NULL)
{
- append_completion_text(dir->fullname +
- strlen(cmpl_state->completion_dir->fullname) + 1,
- cmpl_state);
- append_completion_text("/", cmpl_state);
+ append_completion_text (dir->fullname +
+ strlen (cmpl_state->completion_dir->fullname) + 1,
+ cmpl_state);
+ append_completion_text (G_DIR_SEPARATOR_S, cmpl_state);
}
- append_completion_text(dir->sent->entries[dir->cmpl_index].entry_name, cmpl_state);
+ append_completion_text (dir->sent->entries[dir->cmpl_index].entry_name, cmpl_state);
cmpl_state->the_completion.is_a_completion =
- (fnmatch(pat_buf, dir->sent->entries[dir->cmpl_index].entry_name,
- FNMATCH_FLAGS) != FNM_NOMATCH);
+ fnmatch (pat_buf, dir->sent->entries[dir->cmpl_index].entry_name,
+ FNMATCH_FLAGS) != FNM_NOMATCH;
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);
+ if (dir->sent->entries[dir->cmpl_index].is_dir)
+ 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)
+get_pwdb (CompletionState* cmpl_state)
{
struct passwd *pwd_ptr;
- gchar* buf_ptr, *home_dir = NULL;
+ gchar* buf_ptr;
+ gchar *utf8;
gint len = 0, i, count = 0;
- if(cmpl_state->user_dir_name_buffer)
+ if (cmpl_state->user_dir_name_buffer)
return TRUE;
setpwent ();
- while ((pwd_ptr = getpwent()) != NULL)
+ while ((pwd_ptr = getpwent ()) != NULL)
{
- len += strlen(pwd_ptr->pw_name);
- len += strlen(pwd_ptr->pw_dir);
+ utf8 = g_filename_to_utf8 (pwd_ptr->pw_name, -1, NULL, NULL, NULL);
+ len += strlen (utf8);
+ g_free (utf8);
+ utf8 = g_filename_to_utf8 (pwd_ptr->pw_dir, -1, NULL, NULL, NULL);
+ len += strlen (utf8);
+ g_free (utf8);
len += 2;
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);
- cmpl_state->user_directories = g_new(CompletionUserDir, count);
+ cmpl_state->user_dir_name_buffer = g_new (gchar, len);
+ cmpl_state->user_directories = g_new (CompletionUserDir, count);
cmpl_state->user_directories_len = count;
buf_ptr = cmpl_state->user_dir_name_buffer;
- if (!cmpl_state->user_home_dir)
+ for (i = 0; i < count; i += 1)
{
- 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();
- if(!pwd_ptr)
+ pwd_ptr = getpwent ();
+ if (!pwd_ptr)
{
cmpl_errno = errno;
goto error;
}
- strcpy(buf_ptr, pwd_ptr->pw_name);
+ utf8 = g_filename_to_utf8 (pwd_ptr->pw_name, -1, NULL, NULL, NULL);
+ strcpy (buf_ptr, utf8);
+ g_free (utf8);
+
cmpl_state->user_directories[i].login = buf_ptr;
- buf_ptr += strlen(buf_ptr);
+
+ buf_ptr += strlen (buf_ptr);
buf_ptr += 1;
- strcpy(buf_ptr, pwd_ptr->pw_dir);
+
+ utf8 = g_filename_to_utf8 (pwd_ptr->pw_dir, -1, NULL, NULL, NULL);
+ strcpy (buf_ptr, utf8);
+ g_free (utf8);
+
cmpl_state->user_directories[i].homedir = buf_ptr;
- buf_ptr += strlen(buf_ptr);
+
+ buf_ptr += strlen (buf_ptr);
buf_ptr += 1;
}
- qsort(cmpl_state->user_directories,
- cmpl_state->user_directories_len,
- sizeof(CompletionUserDir),
- compare_user_dir);
+ qsort (cmpl_state->user_directories,
+ cmpl_state->user_directories_len,
+ sizeof (CompletionUserDir),
+ compare_user_dir);
- endpwent();
+ endpwent ();
return TRUE;
error:
- if(cmpl_state->user_dir_name_buffer)
- g_free(cmpl_state->user_dir_name_buffer);
- if(cmpl_state->user_directories)
- g_free(cmpl_state->user_directories);
+ if (cmpl_state->user_dir_name_buffer)
+ g_free (cmpl_state->user_dir_name_buffer);
+ if (cmpl_state->user_directories)
+ g_free (cmpl_state->user_directories);
cmpl_state->user_dir_name_buffer = NULL;
cmpl_state->user_directories = NULL;
}
static gint
-compare_user_dir(const void* a, const void* b)
+compare_user_dir (const void *a,
+ const void *b)
{
- return strcmp((((CompletionUserDir*)a))->login,
- (((CompletionUserDir*)b))->login);
+ return strcmp ((((CompletionUserDir*)a))->login,
+ (((CompletionUserDir*)b))->login);
}
+#endif
+
static gint
-compare_cmpl_dir(const void* a, const void* b)
-{
- return strcmp((((CompletionDirEntry*)a))->entry_name,
- (((CompletionDirEntry*)b))->entry_name);
+compare_cmpl_dir (const void *a,
+ const void *b)
+{
+#if !defined(G_OS_WIN32) && !defined(G_WITH_CYGWIN)
+ 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
-cmpl_state_okay(CompletionState* cmpl_state)
+cmpl_state_okay (CompletionState* cmpl_state)
{
return cmpl_state && cmpl_state->reference_dir;
}
-static gchar*
-cmpl_strerror(gint err)
+static const gchar*
+cmpl_strerror (gint err)
{
- if(err == CMPL_ERRNO_TOO_LONG)
- return "Name too long";
+ if (err == CMPL_ERRNO_TOO_LONG)
+ return _("Name too long");
+ else if (err == CMPL_ERRNO_DID_NOT_CONVERT)
+ return _("Couldn't convert filename");
else
return g_strerror (err);
}
projects / ~andy / gtk / blobdiff