forked from AuroraMiddleware/gtk
f0b58ab846
Sun Mar 3 06:39:19 2002 Tim Janik <timj@gtk.org>
* gtk/gtkfilesel.c: added compile time switch to put the tree views
into a hpaned for owen to play with.
* gtk/gtktreedatalist.c (_gtk_tree_data_list_header_free):
* gtk/gtktreeviewcolumn.c (gtk_tree_view_column_set_cell_data_func),
(gtk_tree_view_column_finalize):
* gtk/gtktreestore.c (gtk_tree_store_set_default_sort_func),
(gtk_tree_store_set_sort_func), (gtk_tree_store_finalize):
* gtk/gtktreeselection.c (gtk_tree_selection_finalize):
* gtk/gtktreemodelsort.c (gtk_tree_model_sort_reset_default_sort_func),
(gtk_tree_model_sort_set_default_sort_func),
(gtk_tree_model_sort_set_sort_func):
* gtk/gtkliststore.c (gtk_list_store_set_default_sort_func),
(gtk_list_store_set_default_sort_func),
(gtk_list_store_set_sort_func), (gtk_list_store_finalize):
add reentrancy protection around destroy() function invocation.
* gtk/gtktreeselection.c (gtk_tree_selection_set_select_function): fix
destroy function invocation (which was missing).
3836 lines
100 KiB
C
3836 lines
100 KiB
C
/* GTK - The GIMP Toolkit
|
|
* 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 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
|
|
* Lesser General Public License for more details.
|
|
*
|
|
* 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
|
|
#include <stdlib.h>
|
|
#ifdef HAVE_UNISTD_H
|
|
#include <unistd.h>
|
|
#endif
|
|
#include <string.h>
|
|
#include <errno.h>
|
|
#ifdef HAVE_PWD_H
|
|
#include <pwd.h>
|
|
#endif
|
|
|
|
#include <glib.h> /* Include early to get G_OS_WIN32 and
|
|
* G_WITH_CYGWIN */
|
|
|
|
#if defined(G_OS_WIN32) || defined(G_WITH_CYGWIN)
|
|
#include <ctype.h>
|
|
#define STRICT
|
|
#include <windows.h>
|
|
#undef STRICT
|
|
#endif /* G_OS_WIN32 || G_WITH_CYGWIN */
|
|
#ifdef HAVE_WINSOCK_H
|
|
#include <winsock.h> /* For gethostname */
|
|
#endif
|
|
|
|
#include "fnmatch.h"
|
|
|
|
#include "gdk/gdkkeysyms.h"
|
|
#include "gtkbutton.h"
|
|
#include "gtkcellrenderertext.h"
|
|
#include "gtkentry.h"
|
|
#include "gtkfilesel.h"
|
|
#include "gtkhbox.h"
|
|
#include "gtkhbbox.h"
|
|
#include "gtklabel.h"
|
|
#include "gtkliststore.h"
|
|
#include "gtkmain.h"
|
|
#include "gtkscrolledwindow.h"
|
|
#include "gtkstock.h"
|
|
#include "gtksignal.h"
|
|
#include "gtktreeselection.h"
|
|
#include "gtktreeview.h"
|
|
#include "gtkvbox.h"
|
|
#include "gtkmenu.h"
|
|
#include "gtkmenuitem.h"
|
|
#include "gtkoptionmenu.h"
|
|
#include "gtkdialog.h"
|
|
#include "gtkmessagedialog.h"
|
|
#include "gtkintl.h"
|
|
#include "gtkdnd.h"
|
|
#include "gtkeventbox.h"
|
|
|
|
#define WANT_HPANAED 1
|
|
#include "gtkhpaned.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 */
|
|
|
|
#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;
|
|
|
|
struct _HistoryCallbackArg
|
|
{
|
|
gchar *directory;
|
|
GtkWidget *menu_item;
|
|
};
|
|
|
|
|
|
typedef struct _CompletionState CompletionState;
|
|
typedef struct _CompletionDir CompletionDir;
|
|
typedef struct _CompletionDirSent CompletionDirSent;
|
|
typedef struct _CompletionDirEntry CompletionDirEntry;
|
|
typedef struct _CompletionUserDir CompletionUserDir;
|
|
typedef struct _PossibleCompletion PossibleCompletion;
|
|
|
|
/* Non-external file completion decls and structures */
|
|
|
|
/* A contant telling PRCS how many directories to cache. Its actually
|
|
* kept in a list, so the geometry isn't important. */
|
|
#define CMPL_DIRECTORY_CACHE_SIZE 10
|
|
|
|
/* A constant used to determine whether a substring was an exact
|
|
* match by first_diff_index()
|
|
*/
|
|
#define PATTERN_MATCH -1
|
|
/* The arguments used by all fnmatch() calls below
|
|
*/
|
|
#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
|
|
* in the CompletionState struct. CompletionDir's are reference counted.
|
|
*/
|
|
struct _CompletionDirSent
|
|
{
|
|
ino_t inode;
|
|
time_t mtime;
|
|
dev_t device;
|
|
|
|
gint entry_count;
|
|
struct _CompletionDirEntry *entries;
|
|
};
|
|
|
|
struct _CompletionDir
|
|
{
|
|
CompletionDirSent *sent;
|
|
|
|
gchar *fullname;
|
|
gint fullname_len;
|
|
|
|
struct _CompletionDir *cmpl_parent;
|
|
gint cmpl_index;
|
|
gchar *cmpl_text;
|
|
};
|
|
|
|
/* This structure contains pairs of directory entry names with a flag saying
|
|
* whether or not they are a valid directory. NOTE: This information is used
|
|
* to provide the caller with information about whether to update its completions
|
|
* or try to open a file. Since directories are cached by the directory mtime,
|
|
* a symlink which points to an invalid file (which will not be a directory),
|
|
* will not be reevaluated if that file is created, unless the containing
|
|
* directory is touched. I consider this case to be worth ignoring (josh).
|
|
*/
|
|
struct _CompletionDirEntry
|
|
{
|
|
gboolean is_dir;
|
|
gchar *entry_name;
|
|
};
|
|
|
|
struct _CompletionUserDir
|
|
{
|
|
gchar *login;
|
|
gchar *homedir;
|
|
};
|
|
|
|
struct _PossibleCompletion
|
|
{
|
|
/* accessible fields, all are accessed externally by functions
|
|
* declared above
|
|
*/
|
|
gchar *text;
|
|
gint is_a_completion;
|
|
gboolean is_directory;
|
|
|
|
/* Private fields
|
|
*/
|
|
gint text_alloc;
|
|
};
|
|
|
|
struct _CompletionState
|
|
{
|
|
gint last_valid_char;
|
|
gchar *updated_text;
|
|
gint updated_text_len;
|
|
gint updated_text_alloc;
|
|
gboolean re_complete;
|
|
|
|
gchar *user_dir_name_buffer;
|
|
gint user_directories_len;
|
|
|
|
gchar *last_completion_text;
|
|
|
|
gint user_completion_index; /* if >= 0, currently completing ~user */
|
|
|
|
struct _CompletionDir *completion_dir; /* directory completing from */
|
|
struct _CompletionDir *active_completion_dir;
|
|
|
|
struct _PossibleCompletion the_completion;
|
|
|
|
struct _CompletionDir *reference_dir; /* initial directory */
|
|
|
|
GList* directory_storage;
|
|
GList* directory_sent_storage;
|
|
|
|
struct _CompletionUserDir *user_directories;
|
|
};
|
|
|
|
enum {
|
|
PROP_0,
|
|
PROP_SHOW_FILEOPS,
|
|
PROP_FILENAME,
|
|
PROP_SELECT_MULTIPLE
|
|
};
|
|
|
|
enum {
|
|
DIR_COLUMN
|
|
};
|
|
|
|
enum {
|
|
FILE_COLUMN
|
|
};
|
|
|
|
/* 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 const gchar* cmpl_strerror (gint);
|
|
|
|
static PossibleCompletion* cmpl_completion_matches(gchar *text_to_complete,
|
|
gchar **remaining_text,
|
|
CompletionState *cmpl_state);
|
|
|
|
/* Returns a name for consideration, possibly a completion, this name
|
|
* will be invalid after the next call to cmpl_next_completion.
|
|
*/
|
|
static char* cmpl_this_completion (PossibleCompletion*);
|
|
|
|
/* True if this completion matches the given text. Otherwise, this
|
|
* output can be used to have a list of non-completions.
|
|
*/
|
|
static gint cmpl_is_a_completion (PossibleCompletion*);
|
|
|
|
/* True if the completion is a directory
|
|
*/
|
|
static gboolean cmpl_is_directory (PossibleCompletion*);
|
|
|
|
/* Obtains the next completion, or NULL
|
|
*/
|
|
static PossibleCompletion* cmpl_next_completion (CompletionState*);
|
|
|
|
/* Updating completions: the return value of cmpl_updated_text() will
|
|
* be text_to_complete completed as much as possible after the most
|
|
* recent call to cmpl_completion_matches. For the present
|
|
* application, this is the suggested replacement for the user's input
|
|
* string. You must CALL THIS AFTER ALL cmpl_text_completions have
|
|
* been received.
|
|
*/
|
|
static gchar* cmpl_updated_text (CompletionState* cmpl_state);
|
|
|
|
/* After updating, to see if the completion was a directory, call
|
|
* this. If it was, you should consider re-calling completion_matches.
|
|
*/
|
|
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,
|
|
* the cwd concatenated with all exact completions up to the last
|
|
* directory delimiter('/').
|
|
*/
|
|
static gchar* cmpl_reference_position (CompletionState* cmpl_state);
|
|
|
|
/* backing up: if cmpl_completion_matches returns NULL, you may query
|
|
* the index of the last completable character into cmpl_updated_text.
|
|
*/
|
|
static gint cmpl_last_valid_char (CompletionState* cmpl_state);
|
|
|
|
/* 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 (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);
|
|
#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,
|
|
gboolean stat_subdirs);
|
|
static gint correct_dir_fullname (CompletionDir* cmpl_dir);
|
|
static gint correct_parent (CompletionDir* cmpl_dir,
|
|
struct stat *sbuf);
|
|
#ifndef G_OS_WIN32
|
|
static gchar* find_parent_dir_fullname (gchar* dirname);
|
|
#endif
|
|
static CompletionDir* attach_dir (CompletionDirSent* sent,
|
|
gchar* dir_name,
|
|
CompletionState *cmpl_state);
|
|
static void free_dir_sent (CompletionDirSent* sent);
|
|
static void free_dir (CompletionDir *dir);
|
|
static void prune_memory_usage(CompletionState *cmpl_state);
|
|
|
|
/* Completion operations */
|
|
#ifdef HAVE_PWD_H
|
|
static PossibleCompletion* attempt_homedir_completion(gchar* text_to_complete,
|
|
CompletionState *cmpl_state);
|
|
#endif
|
|
static PossibleCompletion* attempt_file_completion(CompletionState *cmpl_state);
|
|
static CompletionDir* find_completion_dir(gchar* text_to_complete,
|
|
gchar** remaining_text,
|
|
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 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 void gtk_file_selection_map (GtkWidget *widget);
|
|
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_activate (GtkTreeView *tree_view,
|
|
GtkTreePath *path,
|
|
GtkTreeViewColumn *column,
|
|
gpointer user_data);
|
|
static void gtk_file_selection_file_changed (GtkTreeSelection *selection,
|
|
gpointer user_data);
|
|
static void gtk_file_selection_dir_activate (GtkTreeView *tree_view,
|
|
GtkTreePath *path,
|
|
GtkTreeViewColumn *column,
|
|
gpointer user_data);
|
|
|
|
static void gtk_file_selection_populate (GtkFileSelection *fs,
|
|
gchar *rel_path,
|
|
gboolean try_complete,
|
|
gboolean reset_entry);
|
|
static void gtk_file_selection_abort (GtkFileSelection *fs);
|
|
|
|
static void gtk_file_selection_update_history_menu (GtkFileSelection *fs,
|
|
gchar *current_dir);
|
|
|
|
static void gtk_file_selection_create_dir (GtkWidget *widget, gpointer data);
|
|
static void gtk_file_selection_delete_file (GtkWidget *widget, gpointer data);
|
|
static void gtk_file_selection_rename_file (GtkWidget *widget, gpointer data);
|
|
|
|
static void free_selected_names (GPtrArray *names);
|
|
|
|
#if !defined(G_OS_WIN32) && !defined(G_WITH_CYGWIN)
|
|
#define compare_filenames(a, b) strcmp(a, b)
|
|
#else
|
|
#define compare_filenames(a, b) g_ascii_strcasecmp(a, b)
|
|
#endif
|
|
|
|
|
|
static GtkWindowClass *parent_class = NULL;
|
|
|
|
/* Saves errno when something cmpl does fails. */
|
|
static gint cmpl_errno;
|
|
|
|
#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.
|
|
*/
|
|
static int
|
|
translate_win32_path (GtkFileSelection *filesel)
|
|
{
|
|
int updated = 0;
|
|
gchar *path;
|
|
|
|
/*
|
|
* Retrieve the current path
|
|
*/
|
|
path = gtk_entry_get_text (GTK_ENTRY (filesel->selection_entry));
|
|
|
|
/*
|
|
* Translate only if this looks like a DOS-ish
|
|
* path... First handle any drive letters.
|
|
*/
|
|
if (isalpha (path[0]) && (path[1] == ':')) {
|
|
/*
|
|
* This part kind of stinks... It isn't possible
|
|
* to know if there is enough space in the current
|
|
* string for the extra character required in this
|
|
* conversion. Assume that there isn't enough space
|
|
* and use the set function on the text field to
|
|
* set the newly created string.
|
|
*/
|
|
gchar *newPath = 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)
|
|
{
|
|
static const GtkTypeInfo filesel_info =
|
|
{
|
|
"GtkFileSelection",
|
|
sizeof (GtkFileSelection),
|
|
sizeof (GtkFileSelectionClass),
|
|
(GtkClassInitFunc) gtk_file_selection_class_init,
|
|
(GtkObjectInitFunc) gtk_file_selection_init,
|
|
/* reserved_1 */ NULL,
|
|
/* reserved_2 */ NULL,
|
|
(GtkClassInitFunc) NULL,
|
|
};
|
|
|
|
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;
|
|
GtkWidgetClass *widget_class;
|
|
|
|
gobject_class = (GObjectClass*) class;
|
|
object_class = (GtkObjectClass*) class;
|
|
widget_class = (GtkWidgetClass*) class;
|
|
|
|
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));
|
|
g_object_class_install_property (gobject_class,
|
|
PROP_SELECT_MULTIPLE,
|
|
g_param_spec_boolean ("select_multiple",
|
|
_("Select multiple"),
|
|
_("Whether to allow multiple files to be selected."),
|
|
FALSE,
|
|
G_PARAM_READABLE |
|
|
G_PARAM_WRITABLE));
|
|
object_class->destroy = gtk_file_selection_destroy;
|
|
widget_class->map = gtk_file_selection_map;
|
|
}
|
|
|
|
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;
|
|
case PROP_SELECT_MULTIPLE:
|
|
gtk_file_selection_set_select_multiple (filesel, g_value_get_boolean (value));
|
|
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;
|
|
case PROP_SELECT_MULTIPLE:
|
|
g_value_set_boolean (value, gtk_file_selection_get_select_multiple (filesel));
|
|
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, *list_container;
|
|
GtkWidget *confirm_area;
|
|
GtkWidget *pulldown_hbox;
|
|
GtkWidget *scrolled_win;
|
|
GtkWidget *eventbox;
|
|
GtkDialog *dialog;
|
|
|
|
GtkListStore *model;
|
|
GtkTreeViewColumn *column;
|
|
|
|
gtk_widget_push_composite_child ();
|
|
|
|
dialog = GTK_DIALOG (filesel);
|
|
|
|
filesel->cmpl_state = cmpl_init_state ();
|
|
|
|
/* The dialog-sized vertical box */
|
|
filesel->main_vbox = dialog->vbox;
|
|
gtk_container_set_border_width (GTK_CONTAINER (filesel), 10);
|
|
|
|
/* The horizontal box containing create, rename etc. buttons */
|
|
filesel->button_area = gtk_hbutton_box_new ();
|
|
gtk_button_box_set_layout (GTK_BUTTON_BOX (filesel->button_area), GTK_BUTTONBOX_START);
|
|
gtk_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 (filesel->button_area);
|
|
|
|
gtk_file_selection_show_fileop_buttons (filesel);
|
|
|
|
/* hbox for pulldown menu */
|
|
pulldown_hbox = gtk_hbox_new (TRUE, 5);
|
|
gtk_box_pack_start (GTK_BOX (filesel->main_vbox), pulldown_hbox, FALSE, FALSE, 0);
|
|
gtk_widget_show (pulldown_hbox);
|
|
|
|
/* Pulldown menu */
|
|
filesel->history_pulldown = gtk_option_menu_new ();
|
|
gtk_widget_show (filesel->history_pulldown);
|
|
gtk_box_pack_start (GTK_BOX (pulldown_hbox), filesel->history_pulldown,
|
|
FALSE, FALSE, 0);
|
|
|
|
/* The horizontal box containing the directory and file listboxes */
|
|
list_hbox = gtk_hbox_new (FALSE, 5);
|
|
gtk_box_pack_start (GTK_BOX (filesel->main_vbox), list_hbox, TRUE, TRUE, 0);
|
|
gtk_widget_show (list_hbox);
|
|
if (WANT_HPANAED)
|
|
list_container = g_object_new (GTK_TYPE_HPANED,
|
|
"visible", TRUE,
|
|
"parent", list_hbox,
|
|
NULL);
|
|
else
|
|
list_container = list_hbox;
|
|
|
|
/* The directories list */
|
|
|
|
model = gtk_list_store_new (1, G_TYPE_STRING);
|
|
filesel->dir_list = gtk_tree_view_new_with_model (GTK_TREE_MODEL (model));
|
|
g_object_unref (model);
|
|
|
|
column = gtk_tree_view_column_new_with_attributes (_("Folders"),
|
|
gtk_cell_renderer_text_new (),
|
|
"text", DIR_COLUMN,
|
|
NULL);
|
|
label = gtk_label_new_with_mnemonic (_("Fol_ders"));
|
|
gtk_label_set_mnemonic_widget (GTK_LABEL (label), filesel->dir_list);
|
|
gtk_widget_show (label);
|
|
gtk_tree_view_column_set_widget (column, label);
|
|
gtk_tree_view_column_set_sizing (column, GTK_TREE_VIEW_COLUMN_AUTOSIZE);
|
|
gtk_tree_view_append_column (GTK_TREE_VIEW (filesel->dir_list), column);
|
|
|
|
gtk_widget_set_usize (filesel->dir_list, DIR_LIST_WIDTH, DIR_LIST_HEIGHT);
|
|
g_signal_connect (filesel->dir_list, "row_activated",
|
|
G_CALLBACK (gtk_file_selection_dir_activate), filesel);
|
|
|
|
/* gtk_clist_column_titles_passive (GTK_CLIST (filesel->dir_list)); */
|
|
|
|
scrolled_win = gtk_scrolled_window_new (NULL, NULL);
|
|
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolled_win), GTK_SHADOW_IN);
|
|
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);
|
|
if (GTK_IS_PANED (list_container))
|
|
gtk_paned_pack1 (GTK_PANED (list_container), scrolled_win, TRUE, TRUE);
|
|
else
|
|
gtk_container_add (GTK_CONTAINER (list_container), scrolled_win);
|
|
gtk_widget_show (filesel->dir_list);
|
|
gtk_widget_show (scrolled_win);
|
|
|
|
/* The files list */
|
|
model = gtk_list_store_new (1, G_TYPE_STRING);
|
|
filesel->file_list = gtk_tree_view_new_with_model (GTK_TREE_MODEL (model));
|
|
g_object_unref (model);
|
|
|
|
column = gtk_tree_view_column_new_with_attributes (_("Files"),
|
|
gtk_cell_renderer_text_new (),
|
|
"text", FILE_COLUMN,
|
|
NULL);
|
|
label = gtk_label_new_with_mnemonic (_("_Files"));
|
|
gtk_label_set_mnemonic_widget (GTK_LABEL (label), filesel->file_list);
|
|
gtk_widget_show (label);
|
|
gtk_tree_view_column_set_widget (column, label);
|
|
gtk_tree_view_column_set_sizing (column, GTK_TREE_VIEW_COLUMN_AUTOSIZE);
|
|
gtk_tree_view_append_column (GTK_TREE_VIEW (filesel->file_list), column);
|
|
|
|
gtk_widget_set_usize (filesel->file_list, FILE_LIST_WIDTH, FILE_LIST_HEIGHT);
|
|
g_signal_connect (filesel->file_list, "row_activated",
|
|
G_CALLBACK (gtk_file_selection_file_activate), filesel);
|
|
g_signal_connect (gtk_tree_view_get_selection (GTK_TREE_VIEW (filesel->file_list)), "changed",
|
|
G_CALLBACK (gtk_file_selection_file_changed), filesel);
|
|
|
|
/* gtk_clist_column_titles_passive (GTK_CLIST (filesel->file_list)); */
|
|
|
|
scrolled_win = gtk_scrolled_window_new (NULL, NULL);
|
|
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolled_win), GTK_SHADOW_IN);
|
|
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_container_add (GTK_CONTAINER (list_container), scrolled_win);
|
|
gtk_widget_show (filesel->file_list);
|
|
gtk_widget_show (scrolled_win);
|
|
|
|
/* 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 Cancel button */
|
|
filesel->cancel_button = gtk_dialog_add_button (dialog,
|
|
GTK_STOCK_CANCEL,
|
|
GTK_RESPONSE_CANCEL);
|
|
/* The OK button */
|
|
filesel->ok_button = gtk_dialog_add_button (dialog,
|
|
GTK_STOCK_OK,
|
|
GTK_RESPONSE_OK);
|
|
|
|
gtk_widget_grab_default (filesel->ok_button);
|
|
|
|
/* The selection entry widget */
|
|
entry_vbox = gtk_vbox_new (FALSE, 2);
|
|
gtk_box_pack_end (GTK_BOX (filesel->main_vbox), entry_vbox, FALSE, FALSE, 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_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) grab_default,
|
|
GTK_OBJECT (filesel->ok_button));
|
|
gtk_signal_connect_object (GTK_OBJECT (filesel->selection_entry), "activate",
|
|
(GtkSignalFunc) gtk_button_clicked,
|
|
GTK_OBJECT (filesel->ok_button));
|
|
gtk_box_pack_start (GTK_BOX (entry_vbox), filesel->selection_entry, TRUE, TRUE, 0);
|
|
gtk_widget_show (filesel->selection_entry);
|
|
|
|
if (!cmpl_state_okay (filesel->cmpl_state))
|
|
{
|
|
gchar err_buf[256];
|
|
|
|
sprintf (err_buf, _("Folder unreadable: %s"), cmpl_strerror (cmpl_errno));
|
|
|
|
gtk_label_set_text (GTK_LABEL (filesel->selection_text), err_buf);
|
|
}
|
|
else
|
|
{
|
|
gtk_file_selection_populate (filesel, "", FALSE, TRUE);
|
|
}
|
|
|
|
gtk_widget_grab_focus (filesel->selection_entry);
|
|
|
|
gtk_widget_pop_composite_child ();
|
|
}
|
|
|
|
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, -1);
|
|
}
|
|
}
|
|
}
|
|
|
|
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_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_mnemonic (_("_New Folder"));
|
|
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_mnemonic (_("De_lete 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_mnemonic (_("_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)
|
|
{
|
|
gchar *buf;
|
|
const char *name, *last_slash;
|
|
|
|
g_return_if_fail (GTK_IS_FILE_SELECTION (filesel));
|
|
g_return_if_fail (filename != NULL);
|
|
|
|
last_slash = strrchr (filename, G_DIR_SEPARATOR);
|
|
|
|
if (!last_slash)
|
|
{
|
|
buf = g_strdup ("");
|
|
name = filename;
|
|
}
|
|
else
|
|
{
|
|
buf = g_strdup (filename);
|
|
buf[last_slash - filename + 1] = 0;
|
|
name = last_slash + 1;
|
|
}
|
|
|
|
gtk_file_selection_populate (filesel, buf, FALSE, TRUE);
|
|
|
|
if (filesel->selection_entry)
|
|
gtk_entry_set_text (GTK_ENTRY (filesel->selection_entry), name);
|
|
g_free (buf);
|
|
g_object_notify (G_OBJECT (filesel), "filename");
|
|
}
|
|
|
|
/**
|
|
* gtk_file_selection_get_filename:
|
|
* @filesel: a #GtkFileSelection
|
|
*
|
|
* This function returns the selected filename in encoding of
|
|
* g_filename_from_utf8(), 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 gchar nothing[2] = "";
|
|
static gchar something[MAXPATHLEN*2];
|
|
char *sys_filename;
|
|
const char *text;
|
|
|
|
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)
|
|
{
|
|
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, TRUE);
|
|
}
|
|
|
|
static void
|
|
gtk_file_selection_destroy (GtkObject *object)
|
|
{
|
|
GtkFileSelection *filesel;
|
|
GList *list;
|
|
HistoryCallbackArg *callback_arg;
|
|
|
|
g_return_if_fail (GTK_IS_FILE_SELECTION (object));
|
|
|
|
filesel = GTK_FILE_SELECTION (object);
|
|
|
|
if (filesel->fileop_dialog)
|
|
{
|
|
gtk_widget_destroy (filesel->fileop_dialog);
|
|
filesel->fileop_dialog = NULL;
|
|
}
|
|
|
|
if (filesel->history_list)
|
|
{
|
|
list = filesel->history_list;
|
|
while (list)
|
|
{
|
|
callback_arg = list->data;
|
|
g_free (callback_arg->directory);
|
|
g_free (callback_arg);
|
|
list = list->next;
|
|
}
|
|
g_list_free (filesel->history_list);
|
|
filesel->history_list = NULL;
|
|
}
|
|
|
|
if (filesel->cmpl_state)
|
|
{
|
|
cmpl_free_state (filesel->cmpl_state);
|
|
filesel->cmpl_state = NULL;
|
|
}
|
|
|
|
if (filesel->selected_names)
|
|
{
|
|
free_selected_names (filesel->selected_names);
|
|
filesel->selected_names = NULL;
|
|
}
|
|
|
|
if (filesel->last_selected)
|
|
{
|
|
g_free (filesel->last_selected);
|
|
filesel->last_selected = NULL;
|
|
}
|
|
|
|
GTK_OBJECT_CLASS (parent_class)->destroy (object);
|
|
}
|
|
|
|
static void
|
|
gtk_file_selection_map (GtkWidget *widget)
|
|
{
|
|
GtkFileSelection *filesel = GTK_FILE_SELECTION (widget);
|
|
|
|
/* Refresh the contents */
|
|
gtk_file_selection_populate (filesel, "", FALSE, FALSE);
|
|
|
|
GTK_WIDGET_CLASS (parent_class)->map (widget);
|
|
}
|
|
|
|
static void
|
|
gtk_file_selection_finalize (GObject *object)
|
|
{
|
|
GtkFileSelection *filesel = GTK_FILE_SELECTION (object);
|
|
|
|
g_free (filesel->fileop_file);
|
|
|
|
G_OBJECT_CLASS (parent_class)->finalize (object);
|
|
}
|
|
|
|
/* Begin file operations callbacks */
|
|
|
|
static void
|
|
gtk_file_selection_fileop_error (GtkFileSelection *fs,
|
|
gchar *error_message)
|
|
{
|
|
GtkWidget *dialog;
|
|
|
|
g_return_if_fail (error_message != NULL);
|
|
|
|
/* 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);
|
|
|
|
gtk_window_set_modal (GTK_WINDOW (dialog), TRUE);
|
|
|
|
gtk_signal_connect_object (GTK_OBJECT (dialog), "response",
|
|
(GtkSignalFunc) gtk_widget_destroy,
|
|
(gpointer) dialog);
|
|
|
|
gtk_widget_show (dialog);
|
|
}
|
|
|
|
static void
|
|
gtk_file_selection_fileop_destroy (GtkWidget *widget,
|
|
gpointer data)
|
|
{
|
|
GtkFileSelection *fs = data;
|
|
|
|
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)
|
|
{
|
|
GtkFileSelection *fs = data;
|
|
const gchar *dirname;
|
|
gchar *path;
|
|
gchar *full_path;
|
|
gchar *sys_full_path;
|
|
gchar *buf;
|
|
GError *error = NULL;
|
|
CompletionState *cmpl_state;
|
|
|
|
g_return_if_fail (GTK_IS_FILE_SELECTION (fs));
|
|
|
|
dirname = gtk_entry_get_text (GTK_ENTRY (fs->fileop_entry));
|
|
cmpl_state = (CompletionState*) fs->cmpl_state;
|
|
path = cmpl_reference_position (cmpl_state);
|
|
|
|
full_path = g_strconcat (path, G_DIR_SEPARATOR_S, dirname, NULL);
|
|
sys_full_path = g_filename_from_utf8 (full_path, -1, NULL, NULL, &error);
|
|
if (error)
|
|
{
|
|
if (g_error_matches (error, G_CONVERT_ERROR, G_CONVERT_ERROR_ILLEGAL_SEQUENCE))
|
|
buf = g_strdup_printf (_("The folder name \"%s\" contains symbols that are not allowed in filenames"), dirname);
|
|
else
|
|
buf = g_strdup_printf (_("Error creating folder \"%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 folder \"%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, FALSE);
|
|
}
|
|
|
|
static void
|
|
gtk_file_selection_create_dir (GtkWidget *widget,
|
|
gpointer data)
|
|
{
|
|
GtkFileSelection *fs = data;
|
|
GtkWidget *label;
|
|
GtkWidget *dialog;
|
|
GtkWidget *vbox;
|
|
GtkWidget *button;
|
|
|
|
g_return_if_fail (GTK_IS_FILE_SELECTION (fs));
|
|
|
|
if (fs->fileop_dialog)
|
|
return;
|
|
|
|
/* main dialog */
|
|
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), _("New Folder"));
|
|
gtk_window_set_position (GTK_WINDOW (dialog), GTK_WIN_POS_MOUSE);
|
|
gtk_window_set_transient_for (GTK_WINDOW (dialog), GTK_WINDOW (fs));
|
|
|
|
/* If file dialog is grabbed, grab option dialog */
|
|
/* When option dialog is closed, file dialog will be grabbed again */
|
|
if (GTK_WINDOW (fs)->modal)
|
|
gtk_window_set_modal (GTK_WINDOW (dialog), TRUE);
|
|
|
|
vbox = gtk_vbox_new (FALSE, 0);
|
|
gtk_container_set_border_width (GTK_CONTAINER (vbox), 8);
|
|
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog)->vbox), vbox,
|
|
FALSE, FALSE, 0);
|
|
gtk_widget_show( vbox);
|
|
|
|
label = gtk_label_new_with_mnemonic (_("_Folder 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_show (fs->fileop_entry);
|
|
|
|
/* buttons */
|
|
button = gtk_button_new_from_stock (GTK_STOCK_CANCEL);
|
|
gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
|
|
(GtkSignalFunc) gtk_widget_destroy,
|
|
(gpointer) dialog);
|
|
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog)->action_area),
|
|
button, TRUE, TRUE, 0);
|
|
GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
|
|
gtk_widget_grab_default (button);
|
|
gtk_widget_show (button);
|
|
|
|
gtk_widget_grab_focus (fs->fileop_entry);
|
|
|
|
button = gtk_button_new_with_label (_("Create"));
|
|
gtk_signal_connect (GTK_OBJECT (button), "clicked",
|
|
(GtkSignalFunc) gtk_file_selection_create_dir_confirmed,
|
|
(gpointer) fs);
|
|
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog)->action_area),
|
|
button, TRUE, TRUE, 0);
|
|
GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
|
|
gtk_widget_show (button);
|
|
|
|
gtk_widget_show (dialog);
|
|
}
|
|
|
|
static void
|
|
gtk_file_selection_delete_file_response (GtkDialog *dialog,
|
|
gint response_id,
|
|
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 (GTK_IS_FILE_SELECTION (fs));
|
|
|
|
if (response_id != GTK_RESPONSE_OK)
|
|
{
|
|
gtk_widget_destroy (GTK_WIDGET (dialog));
|
|
return;
|
|
}
|
|
|
|
cmpl_state = (CompletionState*) fs->cmpl_state;
|
|
path = cmpl_reference_position (cmpl_state);
|
|
|
|
full_path = g_strconcat (path, G_DIR_SEPARATOR_S, fs->fileop_file, NULL);
|
|
sys_full_path = g_filename_from_utf8 (full_path, -1, NULL, NULL, &error);
|
|
if (error)
|
|
{
|
|
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, TRUE);
|
|
}
|
|
|
|
static void
|
|
gtk_file_selection_delete_file (GtkWidget *widget,
|
|
gpointer data)
|
|
{
|
|
GtkFileSelection *fs = data;
|
|
GtkWidget *dialog;
|
|
const gchar *filename;
|
|
|
|
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;
|
|
|
|
g_free (fs->fileop_file);
|
|
fs->fileop_file = g_strdup (filename);
|
|
|
|
/* main dialog */
|
|
fs->fileop_dialog = dialog =
|
|
gtk_message_dialog_new (GTK_WINDOW (fs),
|
|
GTK_WINDOW (fs)->modal ? GTK_DIALOG_MODAL : 0,
|
|
GTK_MESSAGE_QUESTION,
|
|
GTK_BUTTONS_NONE,
|
|
_("Really delete file \"%s\" ?"), filename);
|
|
|
|
gtk_signal_connect (GTK_OBJECT (dialog), "destroy",
|
|
(GtkSignalFunc) gtk_file_selection_fileop_destroy,
|
|
(gpointer) fs);
|
|
gtk_window_set_title (GTK_WINDOW (dialog), _("Delete File"));
|
|
gtk_window_set_position (GTK_WINDOW (dialog), GTK_WIN_POS_MOUSE);
|
|
|
|
/* buttons */
|
|
gtk_dialog_add_buttons (GTK_DIALOG (dialog),
|
|
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
|
|
GTK_STOCK_DELETE, GTK_RESPONSE_OK,
|
|
NULL);
|
|
|
|
gtk_dialog_set_default_response (GTK_DIALOG (dialog), GTK_RESPONSE_CANCEL);
|
|
|
|
g_signal_connect (G_OBJECT (dialog), "response",
|
|
G_CALLBACK (gtk_file_selection_delete_file_response),
|
|
fs);
|
|
|
|
gtk_widget_show (dialog);
|
|
}
|
|
|
|
static void
|
|
gtk_file_selection_rename_file_confirmed (GtkWidget *widget,
|
|
gpointer data)
|
|
{
|
|
GtkFileSelection *fs = data;
|
|
gchar *buf;
|
|
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 (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, G_DIR_SEPARATOR_S, file, NULL);
|
|
old_filename = g_strconcat (path, G_DIR_SEPARATOR_S, fs->fileop_file, NULL);
|
|
|
|
sys_new_filename = g_filename_from_utf8 (new_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"), 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);
|
|
goto out2;
|
|
}
|
|
|
|
gtk_file_selection_populate (fs, "", FALSE, FALSE);
|
|
gtk_entry_set_text (GTK_ENTRY (fs->selection_entry), file);
|
|
|
|
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);
|
|
}
|
|
|
|
static void
|
|
gtk_file_selection_rename_file (GtkWidget *widget,
|
|
gpointer data)
|
|
{
|
|
GtkFileSelection *fs = data;
|
|
GtkWidget *label;
|
|
GtkWidget *dialog;
|
|
GtkWidget *vbox;
|
|
GtkWidget *button;
|
|
gchar *buf;
|
|
|
|
g_return_if_fail (GTK_IS_FILE_SELECTION (fs));
|
|
|
|
if (fs->fileop_dialog)
|
|
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_set_position (GTK_WINDOW (dialog), GTK_WIN_POS_MOUSE);
|
|
gtk_window_set_transient_for (GTK_WINDOW (dialog), GTK_WINDOW (fs));
|
|
|
|
/* If file dialog is grabbed, grab option dialog */
|
|
/* When option dialog closed, file dialog will be grabbed again */
|
|
if (GTK_WINDOW (fs)->modal)
|
|
gtk_window_set_modal (GTK_WINDOW (dialog), TRUE);
|
|
|
|
vbox = gtk_vbox_new (FALSE, 0);
|
|
gtk_container_set_border_width (GTK_CONTAINER (vbox), 8);
|
|
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog)->vbox), vbox,
|
|
FALSE, FALSE, 0);
|
|
gtk_widget_show(vbox);
|
|
|
|
buf = g_strdup_printf (_("Rename file \"%s\" to:"), fs->fileop_file);
|
|
label = gtk_label_new (buf);
|
|
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.0);
|
|
gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 5);
|
|
gtk_widget_show (label);
|
|
g_free (buf);
|
|
|
|
/* New filename entry */
|
|
fs->fileop_entry = gtk_entry_new ();
|
|
gtk_box_pack_start (GTK_BOX (vbox), fs->fileop_entry,
|
|
TRUE, TRUE, 5);
|
|
GTK_WIDGET_SET_FLAGS (fs->fileop_entry, GTK_CAN_DEFAULT);
|
|
gtk_widget_show (fs->fileop_entry);
|
|
|
|
gtk_entry_set_text (GTK_ENTRY (fs->fileop_entry), fs->fileop_file);
|
|
gtk_editable_select_region (GTK_EDITABLE (fs->fileop_entry),
|
|
0, strlen (fs->fileop_file));
|
|
|
|
/* buttons */
|
|
button = gtk_button_new_from_stock (GTK_STOCK_CANCEL);
|
|
gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
|
|
(GtkSignalFunc) gtk_widget_destroy,
|
|
(gpointer) dialog);
|
|
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog)->action_area),
|
|
button, TRUE, TRUE, 0);
|
|
GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
|
|
gtk_widget_grab_default (button);
|
|
gtk_widget_show (button);
|
|
|
|
gtk_widget_grab_focus (fs->fileop_entry);
|
|
|
|
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_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,
|
|
GdkEventKey *event,
|
|
gpointer user_data)
|
|
{
|
|
GtkFileSelection *fs;
|
|
char *text;
|
|
|
|
g_return_val_if_fail (widget != NULL, FALSE);
|
|
g_return_val_if_fail (event != NULL, FALSE);
|
|
|
|
if ((event->keyval == GDK_Tab || event->keyval == GDK_KP_Tab) &&
|
|
(event->state & gtk_accelerator_get_default_mod_mask ()) == 0)
|
|
{
|
|
fs = GTK_FILE_SELECTION (user_data);
|
|
#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, TRUE);
|
|
|
|
g_free (text);
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
static void
|
|
gtk_file_selection_history_callback (GtkWidget *widget,
|
|
gpointer data)
|
|
{
|
|
GtkFileSelection *fs = data;
|
|
HistoryCallbackArg *callback_arg;
|
|
GList *list;
|
|
|
|
g_return_if_fail (GTK_IS_FILE_SELECTION (fs));
|
|
|
|
list = fs->history_list;
|
|
|
|
while (list) {
|
|
callback_arg = list->data;
|
|
|
|
if (callback_arg->menu_item == widget)
|
|
{
|
|
gtk_file_selection_populate (fs, callback_arg->directory, FALSE, FALSE);
|
|
break;
|
|
}
|
|
|
|
list = list->next;
|
|
}
|
|
}
|
|
|
|
static void
|
|
gtk_file_selection_update_history_menu (GtkFileSelection *fs,
|
|
gchar *current_directory)
|
|
{
|
|
HistoryCallbackArg *callback_arg;
|
|
GtkWidget *menu_item;
|
|
GList *list;
|
|
gchar *current_dir;
|
|
gint dir_len;
|
|
gint i;
|
|
|
|
g_return_if_fail (GTK_IS_FILE_SELECTION (fs));
|
|
g_return_if_fail (current_directory != NULL);
|
|
|
|
list = fs->history_list;
|
|
|
|
if (fs->history_menu)
|
|
{
|
|
while (list) {
|
|
callback_arg = list->data;
|
|
g_free (callback_arg->directory);
|
|
g_free (callback_arg);
|
|
list = list->next;
|
|
}
|
|
g_list_free (fs->history_list);
|
|
fs->history_list = NULL;
|
|
|
|
gtk_widget_destroy (fs->history_menu);
|
|
}
|
|
|
|
fs->history_menu = gtk_menu_new ();
|
|
|
|
current_dir = g_strdup (current_directory);
|
|
|
|
dir_len = strlen (current_dir);
|
|
|
|
for (i = dir_len; i >= 0; i--)
|
|
{
|
|
/* the i == dir_len is to catch the full path for the first
|
|
* entry. */
|
|
if ( (current_dir[i] == G_DIR_SEPARATOR) || (i == dir_len))
|
|
{
|
|
/* another small hack to catch the full path */
|
|
if (i != dir_len)
|
|
current_dir[i + 1] = '\0';
|
|
#ifdef G_WITH_CYGWIN
|
|
if (!strcmp (current_dir, "//"))
|
|
continue;
|
|
#endif
|
|
menu_item = gtk_menu_item_new_with_label (current_dir);
|
|
|
|
callback_arg = g_new (HistoryCallbackArg, 1);
|
|
callback_arg->menu_item = menu_item;
|
|
|
|
/* since the autocompletion gets confused if you don't
|
|
* supply a trailing '/' on a dir entry, set the full
|
|
* (current) path to "" which just refreshes the filesel */
|
|
if (dir_len == i)
|
|
{
|
|
callback_arg->directory = g_strdup ("");
|
|
}
|
|
else
|
|
{
|
|
callback_arg->directory = g_strdup (current_dir);
|
|
}
|
|
|
|
fs->history_list = g_list_append (fs->history_list, callback_arg);
|
|
|
|
gtk_signal_connect (GTK_OBJECT (menu_item), "activate",
|
|
(GtkSignalFunc) gtk_file_selection_history_callback,
|
|
(gpointer) fs);
|
|
gtk_menu_shell_append (GTK_MENU_SHELL (fs->history_menu), menu_item);
|
|
gtk_widget_show (menu_item);
|
|
}
|
|
}
|
|
|
|
gtk_option_menu_set_menu (GTK_OPTION_MENU (fs->history_pulldown),
|
|
fs->history_menu);
|
|
g_free (current_dir);
|
|
}
|
|
|
|
static gchar *
|
|
get_real_filename (gchar *filename,
|
|
gboolean free_old)
|
|
{
|
|
#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]));
|
|
|
|
if (free_old)
|
|
g_free (filename);
|
|
|
|
return temp_filename;
|
|
}
|
|
#else
|
|
return filename;
|
|
#endif /* G_WITH_CYGWIN */
|
|
}
|
|
|
|
static void
|
|
gtk_file_selection_file_activate (GtkTreeView *tree_view,
|
|
GtkTreePath *path,
|
|
GtkTreeViewColumn *column,
|
|
gpointer user_data)
|
|
{
|
|
GtkFileSelection *fs = GTK_FILE_SELECTION (user_data);
|
|
GtkTreeModel *model = gtk_tree_view_get_model (tree_view);
|
|
GtkTreeIter iter;
|
|
gchar *filename;
|
|
|
|
gtk_tree_model_get_iter (model, &iter, path);
|
|
gtk_tree_model_get (model, &iter, FILE_COLUMN, &filename, -1);
|
|
filename = get_real_filename (filename, TRUE);
|
|
|
|
gtk_entry_set_text (GTK_ENTRY (fs->selection_entry), filename);
|
|
gtk_button_clicked (GTK_BUTTON (fs->ok_button));
|
|
|
|
g_free (filename);
|
|
}
|
|
|
|
static void
|
|
gtk_file_selection_dir_activate (GtkTreeView *tree_view,
|
|
GtkTreePath *path,
|
|
GtkTreeViewColumn *column,
|
|
gpointer user_data)
|
|
{
|
|
GtkFileSelection *fs = GTK_FILE_SELECTION (user_data);
|
|
GtkTreeModel *model = gtk_tree_view_get_model (tree_view);
|
|
GtkTreeIter iter;
|
|
gchar *filename;
|
|
|
|
gtk_tree_model_get_iter (model, &iter, path);
|
|
gtk_tree_model_get (model, &iter, DIR_COLUMN, &filename, -1);
|
|
gtk_file_selection_populate (fs, filename, FALSE, FALSE);
|
|
g_free (filename);
|
|
}
|
|
|
|
#if defined(G_OS_WIN32) || defined(G_WITH_CYGWIN)
|
|
|
|
static void
|
|
win32_gtk_add_drives_to_dir_list (GtkListStore *model)
|
|
{
|
|
gchar *textPtr;
|
|
gchar buffer[128];
|
|
char formatBuffer[128];
|
|
GtkTreeIter iter;
|
|
|
|
/* Get the drives string */
|
|
GetLogicalDriveStrings (sizeof (buffer), buffer);
|
|
|
|
/* Add the drives as necessary */
|
|
textPtr = buffer;
|
|
while (*textPtr != '\0')
|
|
{
|
|
/* Ignore floppies (?) */
|
|
if ((tolower (textPtr[0]) != 'a') && (tolower (textPtr[0]) != 'b'))
|
|
{
|
|
/* Build the actual displayable string */
|
|
sprintf (formatBuffer, "%c:\\", toupper (textPtr[0]));
|
|
|
|
/* Add to the list */
|
|
gtk_list_store_append (model, &iter);
|
|
gtk_list_store_set (model, &iter, DIR_COLUMN, formatBuffer, -1);
|
|
}
|
|
textPtr += (strlen (textPtr) + 1);
|
|
}
|
|
}
|
|
#endif
|
|
|
|
static void
|
|
gtk_file_selection_populate (GtkFileSelection *fs,
|
|
gchar *rel_path,
|
|
gboolean try_complete,
|
|
gboolean reset_entry)
|
|
{
|
|
CompletionState *cmpl_state;
|
|
PossibleCompletion* poss;
|
|
GtkTreeIter iter;
|
|
GtkListStore *dir_model;
|
|
GtkListStore *file_model;
|
|
gchar* filename;
|
|
gchar* rem_path = rel_path;
|
|
gchar* sel_text;
|
|
gint did_recurse = FALSE;
|
|
gint possible_count = 0;
|
|
gint selection_index = -1;
|
|
|
|
g_return_if_fail (GTK_IS_FILE_SELECTION (fs));
|
|
|
|
cmpl_state = (CompletionState*) fs->cmpl_state;
|
|
poss = cmpl_completion_matches (rel_path, &rem_path, cmpl_state);
|
|
|
|
if (!cmpl_state_okay (cmpl_state))
|
|
{
|
|
/* Something went wrong. */
|
|
gtk_file_selection_abort (fs);
|
|
return;
|
|
}
|
|
|
|
g_assert (cmpl_state->reference_dir);
|
|
|
|
dir_model = GTK_LIST_STORE (gtk_tree_view_get_model (GTK_TREE_VIEW (fs->dir_list)));
|
|
file_model = GTK_LIST_STORE (gtk_tree_view_get_model (GTK_TREE_VIEW (fs->file_list)));
|
|
|
|
gtk_list_store_clear (dir_model);
|
|
gtk_list_store_clear (file_model);
|
|
|
|
/* Set the dir list to include ./ and ../ */
|
|
gtk_list_store_append (dir_model, &iter);
|
|
gtk_list_store_set (dir_model, &iter, DIR_COLUMN, "." G_DIR_SEPARATOR_S, -1);
|
|
gtk_list_store_append (dir_model, &iter);
|
|
gtk_list_store_set (dir_model, &iter, DIR_COLUMN, ".." G_DIR_SEPARATOR_S, -1);
|
|
|
|
while (poss)
|
|
{
|
|
if (cmpl_is_a_completion (poss))
|
|
{
|
|
possible_count += 1;
|
|
|
|
filename = cmpl_this_completion (poss);
|
|
|
|
if (cmpl_is_directory (poss))
|
|
{
|
|
if (strcmp (filename, "." G_DIR_SEPARATOR_S) != 0 &&
|
|
strcmp (filename, ".." G_DIR_SEPARATOR_S) != 0)
|
|
{
|
|
gtk_list_store_append (dir_model, &iter);
|
|
gtk_list_store_set (dir_model, &iter, DIR_COLUMN, filename, -1);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
gtk_list_store_append (file_model, &iter);
|
|
gtk_list_store_set (file_model, &iter, DIR_COLUMN, filename, -1);
|
|
}
|
|
}
|
|
|
|
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 (dir_model);
|
|
#endif
|
|
|
|
/* File lists are set. */
|
|
|
|
g_assert (cmpl_state->reference_dir);
|
|
|
|
if (try_complete)
|
|
{
|
|
|
|
/* User is trying to complete filenames, so advance the user's input
|
|
* string to the updated_text, which is the common leading substring
|
|
* of all possible completions, and if its a directory attempt
|
|
* attempt completions in it. */
|
|
|
|
if (cmpl_updated_text (cmpl_state)[0])
|
|
{
|
|
|
|
if (cmpl_updated_dir (cmpl_state))
|
|
{
|
|
gchar* dir_name = g_strdup (cmpl_updated_text (cmpl_state));
|
|
|
|
did_recurse = TRUE;
|
|
|
|
gtk_file_selection_populate (fs, dir_name, TRUE, TRUE);
|
|
|
|
g_free (dir_name);
|
|
}
|
|
else
|
|
{
|
|
if (fs->selection_entry)
|
|
gtk_entry_set_text (GTK_ENTRY (fs->selection_entry),
|
|
cmpl_updated_text (cmpl_state));
|
|
}
|
|
}
|
|
else
|
|
{
|
|
selection_index = cmpl_last_valid_char (cmpl_state) -
|
|
(strlen (rel_path) - strlen (rem_path));
|
|
if (fs->selection_entry)
|
|
gtk_entry_set_text (GTK_ENTRY (fs->selection_entry), rem_path);
|
|
}
|
|
}
|
|
else if (reset_entry)
|
|
{
|
|
if (fs->selection_entry)
|
|
gtk_entry_set_text (GTK_ENTRY (fs->selection_entry), "");
|
|
}
|
|
|
|
if (!did_recurse)
|
|
{
|
|
if (fs->selection_entry)
|
|
gtk_entry_set_position (GTK_ENTRY (fs->selection_entry), selection_index);
|
|
|
|
if (fs->selection_entry)
|
|
{
|
|
sel_text = g_strconcat (_("Selection: "),
|
|
cmpl_reference_position (cmpl_state),
|
|
NULL);
|
|
|
|
gtk_label_set_text (GTK_LABEL (fs->selection_text), sel_text);
|
|
g_free (sel_text);
|
|
}
|
|
|
|
if (fs->history_pulldown)
|
|
{
|
|
gtk_file_selection_update_history_menu (fs, cmpl_reference_position (cmpl_state));
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
static void
|
|
gtk_file_selection_abort (GtkFileSelection *fs)
|
|
{
|
|
gchar err_buf[256];
|
|
|
|
sprintf (err_buf, _("Folder unreadable: %s"), cmpl_strerror (cmpl_errno));
|
|
|
|
/* BEEP gdk_beep(); */
|
|
|
|
if (fs->selection_entry)
|
|
gtk_label_set_text (GTK_LABEL (fs->selection_text), err_buf);
|
|
}
|
|
|
|
/**
|
|
* gtk_file_selection_set_select_multiple:
|
|
* @filesel: a #GtkFileSelection
|
|
* @select_multiple: whether or not the user is allowed to select multiple
|
|
* files in the file list.
|
|
*
|
|
* Sets whether the user is allowed to select multiple files in the file list.
|
|
* Use gtk_file_selection_get_selections () to get the list of selected files.
|
|
**/
|
|
void
|
|
gtk_file_selection_set_select_multiple (GtkFileSelection *filesel,
|
|
gboolean select_multiple)
|
|
{
|
|
GtkTreeSelection *sel;
|
|
GtkSelectionMode mode;
|
|
|
|
g_return_if_fail (GTK_IS_FILE_SELECTION (filesel));
|
|
|
|
sel = gtk_tree_view_get_selection (GTK_TREE_VIEW (filesel->file_list));
|
|
|
|
mode = select_multiple ? GTK_SELECTION_MULTIPLE : GTK_SELECTION_SINGLE;
|
|
|
|
if (mode != gtk_tree_selection_get_mode (sel))
|
|
{
|
|
gtk_tree_selection_set_mode (sel, mode);
|
|
|
|
g_object_notify (G_OBJECT (filesel), "select-multiple");
|
|
}
|
|
}
|
|
|
|
/**
|
|
* gtk_file_selection_get_select_multiple:
|
|
* @filesel: a #GtkFileSelection
|
|
*
|
|
* Determines whether or not the user is allowed to select multiple files in
|
|
* the file list. See gtk_file_selection_set_select_multiple().
|
|
*
|
|
* Return value: %TRUE if the user is allowed to select multiple files in the
|
|
* file list
|
|
**/
|
|
gboolean
|
|
gtk_file_selection_get_select_multiple (GtkFileSelection *filesel)
|
|
{
|
|
GtkTreeSelection *sel;
|
|
|
|
g_return_val_if_fail (GTK_IS_FILE_SELECTION (filesel), FALSE);
|
|
|
|
sel = gtk_tree_view_get_selection (GTK_TREE_VIEW (filesel->file_list));
|
|
return (gtk_tree_selection_get_mode (sel) == GTK_SELECTION_MULTIPLE);
|
|
}
|
|
|
|
static void
|
|
multiple_changed_foreach (GtkTreeModel *model,
|
|
GtkTreePath *path,
|
|
GtkTreeIter *iter,
|
|
gpointer data)
|
|
{
|
|
GPtrArray *names = data;
|
|
gchar *filename;
|
|
|
|
gtk_tree_model_get (model, iter, FILE_COLUMN, &filename, -1);
|
|
|
|
g_ptr_array_add (names, filename);
|
|
}
|
|
|
|
static void
|
|
free_selected_names (GPtrArray *names)
|
|
{
|
|
gint i;
|
|
|
|
for (i = 0; i < names->len; i++)
|
|
g_free (g_ptr_array_index (names, i));
|
|
|
|
g_ptr_array_free (names, TRUE);
|
|
}
|
|
|
|
static void
|
|
gtk_file_selection_file_changed (GtkTreeSelection *selection,
|
|
gpointer user_data)
|
|
{
|
|
GtkFileSelection *fs = GTK_FILE_SELECTION (user_data);
|
|
GPtrArray *new_names;
|
|
gchar *filename;
|
|
const gchar *entry;
|
|
gint index = -1;
|
|
|
|
new_names = g_ptr_array_sized_new (8);
|
|
|
|
gtk_tree_selection_selected_foreach (selection,
|
|
multiple_changed_foreach,
|
|
new_names);
|
|
|
|
/* nothing selected */
|
|
if (new_names->len == 0)
|
|
{
|
|
g_ptr_array_free (new_names, TRUE);
|
|
|
|
if (fs->selected_names != NULL)
|
|
{
|
|
free_selected_names (fs->selected_names);
|
|
fs->selected_names = NULL;
|
|
}
|
|
|
|
goto maybe_clear_entry;
|
|
}
|
|
|
|
if (new_names->len != 1)
|
|
{
|
|
GPtrArray *old_names = fs->selected_names;
|
|
|
|
if (old_names != NULL)
|
|
{
|
|
/* A common case is selecting a range of files from top to bottom,
|
|
* so quickly check for that to avoid looping over the entire list
|
|
*/
|
|
if (compare_filenames (g_ptr_array_index (old_names, old_names->len - 1),
|
|
g_ptr_array_index (new_names, new_names->len - 1)) != 0)
|
|
index = new_names->len - 1;
|
|
else
|
|
{
|
|
gint i = 0, j = 0, cmp;
|
|
|
|
/* do a quick diff, stopping at the first file not in the
|
|
* old list
|
|
*/
|
|
while (i < old_names->len && j < new_names->len)
|
|
{
|
|
cmp = compare_filenames (g_ptr_array_index (old_names, i),
|
|
g_ptr_array_index (new_names, j));
|
|
if (cmp < 0)
|
|
{
|
|
i++;
|
|
}
|
|
else if (cmp == 0)
|
|
{
|
|
i++;
|
|
j++;
|
|
}
|
|
else if (cmp > 0)
|
|
{
|
|
index = j;
|
|
break;
|
|
}
|
|
}
|
|
|
|
/* we ran off the end of the old list */
|
|
if (index == -1 && i < new_names->len)
|
|
index = j;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
/* A phantom anchor still exists at the point where the last item
|
|
* was selected, which is used for subsequent range selections.
|
|
* So search up from there.
|
|
*/
|
|
if (compare_filenames (fs->last_selected,
|
|
g_ptr_array_index (new_names, 0)) == 0)
|
|
index = new_names->len - 1;
|
|
else
|
|
index = 0;
|
|
}
|
|
}
|
|
else
|
|
index = 0;
|
|
|
|
if (fs->selected_names != NULL)
|
|
free_selected_names (fs->selected_names);
|
|
|
|
fs->selected_names = new_names;
|
|
|
|
if (index != -1)
|
|
{
|
|
if (fs->last_selected != NULL)
|
|
g_free (fs->last_selected);
|
|
|
|
fs->last_selected = g_strdup (g_ptr_array_index (new_names, index));
|
|
filename = get_real_filename (fs->last_selected, FALSE);
|
|
|
|
gtk_entry_set_text (GTK_ENTRY (fs->selection_entry), filename);
|
|
|
|
if (filename != fs->last_selected)
|
|
g_free (filename);
|
|
|
|
return;
|
|
}
|
|
|
|
maybe_clear_entry:
|
|
|
|
entry = gtk_entry_get_text (GTK_ENTRY (fs->selection_entry));
|
|
if ((entry != NULL) && (fs->last_selected != NULL) &&
|
|
(compare_filenames (entry, fs->last_selected) == 0))
|
|
gtk_entry_set_text (GTK_ENTRY (fs->selection_entry), "");
|
|
}
|
|
|
|
/**
|
|
* gtk_file_selection_get_selections:
|
|
* @filesel: a #GtkFileSelection
|
|
*
|
|
* Retrieves the list of file selections the user has made in the dialog box.
|
|
* This function is intended for use when the user can select multiple files
|
|
* in the file list. The first file in the list is equivalent to what
|
|
* gtk_file_selection_get_filename() would return.
|
|
*
|
|
* The filenames are in the encoding of g_filename_from_utf8, 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() on each string.
|
|
*
|
|
* Return value: a newly-allocated %NULL-terminated array of strings. Use
|
|
* g_strfreev() to free it.
|
|
**/
|
|
gchar **
|
|
gtk_file_selection_get_selections (GtkFileSelection *filesel)
|
|
{
|
|
GPtrArray *names;
|
|
gchar **selections;
|
|
gchar *filename, *dirname;
|
|
gchar *current, *buf;
|
|
gint i, count;
|
|
|
|
g_return_val_if_fail (GTK_IS_FILE_SELECTION (filesel), NULL);
|
|
|
|
filename = g_strdup (gtk_file_selection_get_filename (filesel));
|
|
|
|
if (strlen (filename) == 0)
|
|
{
|
|
g_free (filename);
|
|
return NULL;
|
|
}
|
|
|
|
names = filesel->selected_names;
|
|
|
|
if (names != NULL)
|
|
selections = g_new (gchar *, names->len + 2);
|
|
else
|
|
selections = g_new (gchar *, 2);
|
|
|
|
count = 0;
|
|
selections[count++] = filename;
|
|
|
|
if (names != NULL)
|
|
{
|
|
dirname = g_path_get_dirname (filename);
|
|
|
|
for (i = 0; i < names->len; i++)
|
|
{
|
|
buf = g_filename_from_utf8 (g_ptr_array_index (names, i), -1,
|
|
NULL, NULL, NULL);
|
|
current = g_build_filename (dirname, buf, NULL);
|
|
g_free (buf);
|
|
|
|
if (compare_filenames (current, filename) != 0)
|
|
selections[count++] = current;
|
|
else
|
|
g_free (current);
|
|
}
|
|
}
|
|
|
|
selections[count] = NULL;
|
|
|
|
return selections;
|
|
}
|
|
|
|
/**********************************************************************/
|
|
/* External Interface */
|
|
/**********************************************************************/
|
|
|
|
/* The four completion state selectors
|
|
*/
|
|
static gchar*
|
|
cmpl_updated_text (CompletionState *cmpl_state)
|
|
{
|
|
return cmpl_state->updated_text;
|
|
}
|
|
|
|
static gboolean
|
|
cmpl_updated_dir (CompletionState *cmpl_state)
|
|
{
|
|
return cmpl_state->re_complete;
|
|
}
|
|
|
|
static gchar*
|
|
cmpl_reference_position (CompletionState *cmpl_state)
|
|
{
|
|
return cmpl_state->reference_dir->fullname;
|
|
}
|
|
|
|
static gint
|
|
cmpl_last_valid_char (CompletionState *cmpl_state)
|
|
{
|
|
return cmpl_state->last_valid_char;
|
|
}
|
|
|
|
static gchar*
|
|
cmpl_completion_fullname (const gchar *text,
|
|
CompletionState *cmpl_state)
|
|
{
|
|
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;
|
|
char* slash;
|
|
|
|
dir = open_user_dir (text, cmpl_state);
|
|
|
|
if (!dir)
|
|
{
|
|
/* spencer says just return ~something, so
|
|
* for now just do it. */
|
|
strcpy (cmpl_state->updated_text, text);
|
|
}
|
|
else
|
|
{
|
|
|
|
strcpy (cmpl_state->updated_text, dir->fullname);
|
|
|
|
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);
|
|
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 cmpl_state->updated_text;
|
|
}
|
|
|
|
/* The three completion selectors
|
|
*/
|
|
static gchar*
|
|
cmpl_this_completion (PossibleCompletion* pc)
|
|
{
|
|
return pc->text;
|
|
}
|
|
|
|
static gboolean
|
|
cmpl_is_directory (PossibleCompletion* pc)
|
|
{
|
|
return pc->is_directory;
|
|
}
|
|
|
|
static gint
|
|
cmpl_is_a_completion (PossibleCompletion* pc)
|
|
{
|
|
return pc->is_a_completion;
|
|
}
|
|
|
|
/**********************************************************************/
|
|
/* Construction, deletion */
|
|
/**********************************************************************/
|
|
|
|
static CompletionState*
|
|
cmpl_init_state (void)
|
|
{
|
|
gchar *sys_getcwd_buf;
|
|
gchar *utf8_cwd;
|
|
CompletionState *new_state;
|
|
|
|
new_state = g_new (CompletionState, 1);
|
|
|
|
/* 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;
|
|
new_state->directory_storage = NULL;
|
|
new_state->directory_sent_storage = NULL;
|
|
new_state->last_valid_char = 0;
|
|
new_state->updated_text = g_new (gchar, MAXPATHLEN);
|
|
new_state->updated_text_alloc = MAXPATHLEN;
|
|
new_state->the_completion.text = g_new (gchar, MAXPATHLEN);
|
|
new_state->the_completion.text_alloc = MAXPATHLEN;
|
|
new_state->user_dir_name_buffer = NULL;
|
|
new_state->user_directories = NULL;
|
|
|
|
new_state->reference_dir = open_dir (utf8_cwd, new_state);
|
|
|
|
if (!new_state->reference_dir)
|
|
{
|
|
/* 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)
|
|
{
|
|
GList *dp = dp0;
|
|
|
|
while (dp)
|
|
{
|
|
free_dir (dp->data);
|
|
dp = dp->next;
|
|
}
|
|
|
|
g_list_free (dp0);
|
|
}
|
|
|
|
static void
|
|
cmpl_free_dir_sent_list (GList* dp0)
|
|
{
|
|
GList *dp = dp0;
|
|
|
|
while (dp)
|
|
{
|
|
free_dir_sent (dp->data);
|
|
dp = dp->next;
|
|
}
|
|
|
|
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);
|
|
|
|
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->the_completion.text)
|
|
g_free (cmpl_state->the_completion.text);
|
|
if (cmpl_state->updated_text)
|
|
g_free (cmpl_state->updated_text);
|
|
|
|
g_free (cmpl_state);
|
|
}
|
|
|
|
static void
|
|
free_dir (CompletionDir* dir)
|
|
{
|
|
g_free (dir->cmpl_text);
|
|
g_free (dir->fullname);
|
|
g_free (dir);
|
|
}
|
|
|
|
static void
|
|
free_dir_sent (CompletionDirSent* 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)
|
|
{
|
|
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)
|
|
cdsl = cdsl->next;
|
|
|
|
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;
|
|
}
|
|
|
|
g_list_free (cdl0);
|
|
}
|
|
|
|
/**********************************************************************/
|
|
/* The main entrances. */
|
|
/**********************************************************************/
|
|
|
|
static PossibleCompletion*
|
|
cmpl_completion_matches (gchar *text_to_complete,
|
|
gchar **remaining_text,
|
|
CompletionState *cmpl_state)
|
|
{
|
|
gchar* first_slash;
|
|
PossibleCompletion *poss;
|
|
|
|
prune_memory_usage (cmpl_state);
|
|
|
|
g_assert (text_to_complete != NULL);
|
|
|
|
cmpl_state->user_completion_index = -1;
|
|
cmpl_state->last_completion_text = text_to_complete;
|
|
cmpl_state->the_completion.text[0] = 0;
|
|
cmpl_state->last_valid_char = 0;
|
|
cmpl_state->updated_text_len = -1;
|
|
cmpl_state->updated_text[0] = 0;
|
|
cmpl_state->re_complete = FALSE;
|
|
|
|
#ifdef HAVE_PWD_H
|
|
first_slash = strchr (text_to_complete, G_DIR_SEPARATOR);
|
|
|
|
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);
|
|
|
|
update_cmpl (poss, cmpl_state);
|
|
|
|
return poss;
|
|
}
|
|
#endif
|
|
cmpl_state->reference_dir =
|
|
open_ref_dir (text_to_complete, remaining_text, cmpl_state);
|
|
|
|
if (!cmpl_state->reference_dir)
|
|
return NULL;
|
|
|
|
cmpl_state->completion_dir =
|
|
find_completion_dir (*remaining_text, remaining_text, cmpl_state);
|
|
|
|
cmpl_state->last_valid_char = *remaining_text - text_to_complete;
|
|
|
|
if (!cmpl_state->completion_dir)
|
|
return NULL;
|
|
|
|
cmpl_state->completion_dir->cmpl_index = -1;
|
|
cmpl_state->completion_dir->cmpl_parent = NULL;
|
|
cmpl_state->completion_dir->cmpl_text = g_strdup (*remaining_text);
|
|
|
|
cmpl_state->active_completion_dir = cmpl_state->completion_dir;
|
|
|
|
cmpl_state->reference_dir = cmpl_state->completion_dir;
|
|
|
|
poss = attempt_file_completion (cmpl_state);
|
|
|
|
update_cmpl (poss, cmpl_state);
|
|
|
|
return poss;
|
|
}
|
|
|
|
static PossibleCompletion*
|
|
cmpl_next_completion (CompletionState* cmpl_state)
|
|
{
|
|
PossibleCompletion* poss = NULL;
|
|
|
|
cmpl_state->the_completion.text[0] = 0;
|
|
|
|
#ifdef HAVE_PWD_H
|
|
if (cmpl_state->user_completion_index >= 0)
|
|
poss = attempt_homedir_completion (cmpl_state->last_completion_text, cmpl_state);
|
|
else
|
|
poss = attempt_file_completion (cmpl_state);
|
|
#else
|
|
poss = attempt_file_completion (cmpl_state);
|
|
#endif
|
|
|
|
update_cmpl (poss, cmpl_state);
|
|
|
|
return poss;
|
|
}
|
|
|
|
/**********************************************************************/
|
|
/* Directory Operations */
|
|
/**********************************************************************/
|
|
|
|
/* 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)
|
|
{
|
|
gchar* first_slash;
|
|
CompletionDir *new_dir;
|
|
|
|
first_slash = strchr (text_to_complete, G_DIR_SEPARATOR);
|
|
|
|
#ifdef G_WITH_CYGWIN
|
|
if (text_to_complete[0] == '/' && text_to_complete[1] == '/')
|
|
{
|
|
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 + 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);
|
|
|
|
if (new_dir)
|
|
{
|
|
if (first_slash)
|
|
*remaining_text = first_slash + 1;
|
|
else
|
|
*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);
|
|
}
|
|
|
|
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 (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] == '~');
|
|
|
|
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);
|
|
|
|
if (!cmp_len)
|
|
{
|
|
/* ~/ */
|
|
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/ */
|
|
gchar* copy = g_new (char, cmp_len + 1);
|
|
gchar *utf8_dir;
|
|
struct passwd *pwd;
|
|
|
|
strncpy (copy, text_to_complete + 1, cmp_len);
|
|
copy[cmp_len] = 0;
|
|
pwd = getpwnam (copy);
|
|
g_free (copy);
|
|
if (!pwd)
|
|
{
|
|
cmpl_errno = errno;
|
|
return NULL;
|
|
}
|
|
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)
|
|
{
|
|
CompletionDir *result;
|
|
GString *path;
|
|
|
|
path = g_string_sized_new (dir->fullname_len + strlen (dir_name) + 10);
|
|
g_string_assign (path, 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);
|
|
|
|
result = open_dir (path->str, 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,
|
|
gboolean stat_subdirs)
|
|
{
|
|
CompletionDirSent *sent;
|
|
GDir *directory;
|
|
const char *dirent;
|
|
GError *error;
|
|
gint entry_count = 0;
|
|
gint n_entries = 0;
|
|
gint i;
|
|
struct stat ent_sbuf;
|
|
GString *path;
|
|
gchar *sys_dir_name;
|
|
|
|
sent = g_new (CompletionDirSent, 1);
|
|
sent->mtime = sbuf->st_mtime;
|
|
sent->inode = sbuf->st_ino;
|
|
sent->device = sbuf->st_dev;
|
|
|
|
path = g_string_sized_new (2*MAXPATHLEN + 10);
|
|
|
|
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 NULL;
|
|
}
|
|
|
|
directory = g_dir_open (sys_dir_name, 0, &error);
|
|
if (!directory)
|
|
{
|
|
cmpl_errno = error->code; /* ??? */
|
|
g_free (sys_dir_name);
|
|
return NULL;
|
|
}
|
|
|
|
while ((dirent = g_dir_read_name (directory)) != NULL)
|
|
entry_count++;
|
|
|
|
sent->entries = g_new (CompletionDirEntry, entry_count);
|
|
sent->entry_count = entry_count;
|
|
|
|
g_dir_rewind (directory);
|
|
|
|
for (i = 0; i < entry_count; i += 1)
|
|
{
|
|
dirent = g_dir_read_name (directory);
|
|
|
|
if (!dirent)
|
|
{
|
|
g_warning ("Failure reading folder '%s'", sys_dir_name);
|
|
g_dir_close (directory);
|
|
g_free (sys_dir_name);
|
|
return NULL;
|
|
}
|
|
|
|
sent->entries[n_entries].entry_name = g_filename_to_utf8 (dirent, -1, NULL, NULL, NULL);
|
|
if (sent->entries[n_entries].entry_name == NULL
|
|
|| !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);
|
|
continue;
|
|
}
|
|
|
|
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);
|
|
|
|
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
|
|
sent->entries[n_entries].is_dir = 1;
|
|
|
|
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);
|
|
|
|
g_dir_close (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)
|
|
{
|
|
struct stat sbuf;
|
|
gboolean stat_subdirs;
|
|
CompletionDirSent *sent;
|
|
GList* cdsl;
|
|
|
|
#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;
|
|
|
|
while (cdsl)
|
|
{
|
|
sent = cdsl->data;
|
|
|
|
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, stat_subdirs);
|
|
|
|
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 NULL;
|
|
}
|
|
|
|
static CompletionDir*
|
|
attach_dir (CompletionDirSent *sent,
|
|
gchar *dir_name,
|
|
CompletionState *cmpl_state)
|
|
{
|
|
CompletionDir* new_dir;
|
|
|
|
new_dir = g_new (CompletionDir, 1);
|
|
|
|
cmpl_state->directory_storage =
|
|
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->cmpl_text = NULL;
|
|
|
|
return new_dir;
|
|
}
|
|
|
|
static gint
|
|
correct_dir_fullname (CompletionDir* cmpl_dir)
|
|
{
|
|
gint length = strlen (cmpl_dir->fullname);
|
|
gchar *first_slash = strchr (cmpl_dir->fullname, G_DIR_SEPARATOR);
|
|
gchar *sys_filename;
|
|
struct stat sbuf;
|
|
|
|
/* Does it end with /. (\.) ? */
|
|
if (length >= 2 &&
|
|
strcmp (cmpl_dir->fullname + length - 2, G_DIR_SEPARATOR_S ".") == 0)
|
|
{
|
|
/* Is it just the root directory (on a drive) ? */
|
|
if (cmpl_dir->fullname + length - 2 == first_slash)
|
|
{
|
|
cmpl_dir->fullname[length - 1] = 0;
|
|
cmpl_dir->fullname_len = length - 1;
|
|
return TRUE;
|
|
}
|
|
else
|
|
{
|
|
cmpl_dir->fullname[length - 2] = 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;
|
|
|
|
/* Ends with /.. (\..) ? */
|
|
else if (length >= 3 &&
|
|
strcmp (cmpl_dir->fullname + length - 3,
|
|
G_DIR_SEPARATOR_S "..") == 0)
|
|
{
|
|
/* Is it just /.. (X:\..)? */
|
|
if (cmpl_dir->fullname + length - 3 == first_slash)
|
|
{
|
|
cmpl_dir->fullname[length - 2] = 0;
|
|
cmpl_dir->fullname_len = length - 2;
|
|
return TRUE;
|
|
}
|
|
|
|
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;
|
|
|
|
if (!correct_parent (cmpl_dir, &sbuf))
|
|
return FALSE;
|
|
}
|
|
|
|
/* Ends with /../ (\..\)? */
|
|
else if (length >= 4 &&
|
|
strcmp (cmpl_dir->fullname + length - 4,
|
|
G_DIR_SEPARATOR_S ".." G_DIR_SEPARATOR_S) == 0)
|
|
{
|
|
/* Is it just /../ (X:\..\)? */
|
|
if (cmpl_dir->fullname + length - 4 == first_slash)
|
|
{
|
|
cmpl_dir->fullname[length - 3] = 0;
|
|
cmpl_dir->fullname_len = length - 3;
|
|
return TRUE;
|
|
}
|
|
|
|
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 - 4] = 0;
|
|
|
|
if (!correct_parent (cmpl_dir, &sbuf))
|
|
return FALSE;
|
|
}
|
|
|
|
cmpl_dir->fullname_len = strlen (cmpl_dir->fullname);
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
static gint
|
|
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, G_DIR_SEPARATOR);
|
|
g_assert (last_slash);
|
|
first_slash = strchr (cmpl_dir->fullname, G_DIR_SEPARATOR);
|
|
|
|
/* 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;
|
|
}
|
|
|
|
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)
|
|
last_slash[1] = c;
|
|
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);
|
|
|
|
if (!new_name)
|
|
return FALSE;
|
|
|
|
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)
|
|
{
|
|
gchar *sys_orig_dir;
|
|
gchar *result;
|
|
gchar *sys_cwd;
|
|
gchar *sys_dirname;
|
|
|
|
sys_orig_dir = g_get_current_dir ();
|
|
sys_dirname = g_filename_from_utf8 (dirname, -1, NULL, NULL, NULL);
|
|
if (!sys_dirname)
|
|
{
|
|
g_free (sys_orig_dir);
|
|
cmpl_errno = CMPL_ERRNO_DID_NOT_CONVERT;
|
|
return NULL;
|
|
}
|
|
|
|
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);
|
|
|
|
sys_cwd = g_get_current_dir ();
|
|
result = g_filename_to_utf8 (sys_cwd, -1, NULL, NULL, NULL);
|
|
g_free (sys_cwd);
|
|
|
|
if (chdir (sys_orig_dir) != 0)
|
|
{
|
|
cmpl_errno = errno;
|
|
g_free (sys_orig_dir);
|
|
return NULL;
|
|
}
|
|
|
|
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)
|
|
{
|
|
gint index, length;
|
|
|
|
if (!cmpl_state->user_dir_name_buffer &&
|
|
!get_pwdb (cmpl_state))
|
|
return NULL;
|
|
length = strlen (text_to_complete) - 1;
|
|
|
|
cmpl_state->user_completion_index += 1;
|
|
|
|
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);
|
|
|
|
switch (index)
|
|
{
|
|
case PATTERN_MATCH:
|
|
break;
|
|
default:
|
|
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 = TRUE;
|
|
|
|
append_completion_text ("~", cmpl_state);
|
|
|
|
append_completion_text (cmpl_state->
|
|
user_directories[cmpl_state->user_completion_index].login,
|
|
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)
|
|
{
|
|
cmpl_state->user_completion_index = -1;
|
|
return NULL;
|
|
}
|
|
else
|
|
{
|
|
cmpl_state->user_completion_index += 1;
|
|
cmpl_state->the_completion.is_a_completion = 1;
|
|
cmpl_state->the_completion.is_directory = TRUE;
|
|
|
|
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)
|
|
{
|
|
gint diff = 0;
|
|
|
|
while (*pat && *text && FOLD (*text) == FOLD (*pat))
|
|
{
|
|
pat += 1;
|
|
text += 1;
|
|
diff += 1;
|
|
}
|
|
|
|
if (*pat)
|
|
return diff;
|
|
|
|
return PATTERN_MATCH;
|
|
}
|
|
|
|
static PossibleCompletion*
|
|
append_completion_text (gchar *text,
|
|
CompletionState *cmpl_state)
|
|
{
|
|
gint len, i = 1;
|
|
|
|
if (!cmpl_state->the_completion.text)
|
|
return NULL;
|
|
|
|
len = strlen (text) + strlen (cmpl_state->the_completion.text) + 1;
|
|
|
|
if (cmpl_state->the_completion.text_alloc > len)
|
|
{
|
|
strcat (cmpl_state->the_completion.text, text);
|
|
return &cmpl_state->the_completion;
|
|
}
|
|
|
|
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);
|
|
|
|
if (!cmpl_state->the_completion.text)
|
|
return NULL;
|
|
else
|
|
{
|
|
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)
|
|
{
|
|
gchar* first_slash = strchr (text_to_complete, G_DIR_SEPARATOR);
|
|
CompletionDir* dir = cmpl_state->reference_dir;
|
|
CompletionDir* next;
|
|
*remaining_text = text_to_complete;
|
|
|
|
while (first_slash)
|
|
{
|
|
gint len = first_slash - *remaining_text;
|
|
gint found = 0;
|
|
gchar *found_name = NULL; /* Quiet gcc */
|
|
gint i;
|
|
gchar* pat_buf = g_new (gchar, len + 1);
|
|
|
|
strncpy (pat_buf, *remaining_text, len);
|
|
pat_buf[len] = 0;
|
|
|
|
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 (found)
|
|
{
|
|
g_free (pat_buf);
|
|
return dir;
|
|
}
|
|
else
|
|
{
|
|
found = 1;
|
|
found_name = dir->sent->entries[i].entry_name;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (!found)
|
|
{
|
|
/* Perhaps we are trying to open an automount directory */
|
|
found_name = pat_buf;
|
|
}
|
|
|
|
next = open_relative_dir (found_name, dir, cmpl_state);
|
|
|
|
if (!next)
|
|
{
|
|
g_free (pat_buf);
|
|
return NULL;
|
|
}
|
|
|
|
next->cmpl_parent = dir;
|
|
|
|
dir = next;
|
|
|
|
if (!correct_dir_fullname (dir))
|
|
{
|
|
g_free (pat_buf);
|
|
return NULL;
|
|
}
|
|
|
|
*remaining_text = first_slash + 1;
|
|
first_slash = strchr (*remaining_text, G_DIR_SEPARATOR);
|
|
|
|
g_free (pat_buf);
|
|
}
|
|
|
|
return dir;
|
|
}
|
|
|
|
static void
|
|
update_cmpl (PossibleCompletion *poss,
|
|
CompletionState *cmpl_state)
|
|
{
|
|
gint cmpl_len;
|
|
|
|
if (!poss || !cmpl_is_a_completion (poss))
|
|
return;
|
|
|
|
cmpl_len = strlen (cmpl_this_completion (poss));
|
|
|
|
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);
|
|
cmpl_state->updated_text_alloc = 2*cmpl_len;
|
|
}
|
|
|
|
if (cmpl_state->updated_text_len < 0)
|
|
{
|
|
strcpy (cmpl_state->updated_text, cmpl_this_completion (poss));
|
|
cmpl_state->updated_text_len = cmpl_len;
|
|
cmpl_state->re_complete = cmpl_is_directory (poss);
|
|
}
|
|
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));
|
|
|
|
cmpl_state->re_complete = FALSE;
|
|
|
|
if (first_diff == PATTERN_MATCH)
|
|
return;
|
|
|
|
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)
|
|
{
|
|
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_parent == NULL)
|
|
{
|
|
cmpl_state->active_completion_dir = NULL;
|
|
|
|
return NULL;
|
|
}
|
|
else
|
|
{
|
|
cmpl_state->active_completion_dir = dir->cmpl_parent;
|
|
|
|
return attempt_file_completion (cmpl_state);
|
|
}
|
|
}
|
|
|
|
g_assert (dir->cmpl_text);
|
|
|
|
first_slash = strchr (dir->cmpl_text, G_DIR_SEPARATOR);
|
|
|
|
if (first_slash)
|
|
{
|
|
gint len = first_slash - dir->cmpl_text;
|
|
|
|
pat_buf = g_new (gchar, len + 1);
|
|
strncpy (pat_buf, dir->cmpl_text, len);
|
|
pat_buf[len] = 0;
|
|
}
|
|
else
|
|
{
|
|
gint len = strlen (dir->cmpl_text);
|
|
|
|
pat_buf = g_new (gchar, len + 2);
|
|
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 (dir->sent->entries[dir->cmpl_index].is_dir)
|
|
{
|
|
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);
|
|
|
|
if (!new_dir)
|
|
{
|
|
g_free (pat_buf);
|
|
return NULL;
|
|
}
|
|
|
|
new_dir->cmpl_parent = dir;
|
|
|
|
new_dir->cmpl_index = -1;
|
|
new_dir->cmpl_text = g_strdup (first_slash + 1);
|
|
|
|
cmpl_state->active_completion_dir = new_dir;
|
|
|
|
g_free (pat_buf);
|
|
return attempt_file_completion (cmpl_state);
|
|
}
|
|
else
|
|
{
|
|
g_free (pat_buf);
|
|
return attempt_file_completion (cmpl_state);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
g_free (pat_buf);
|
|
return attempt_file_completion (cmpl_state);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (dir->cmpl_parent != NULL)
|
|
{
|
|
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);
|
|
|
|
cmpl_state->the_completion.is_a_completion =
|
|
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 (G_DIR_SEPARATOR_S, cmpl_state);
|
|
|
|
g_free (pat_buf);
|
|
return &cmpl_state->the_completion;
|
|
}
|
|
}
|
|
|
|
#ifdef HAVE_PWD_H
|
|
|
|
static gint
|
|
get_pwdb (CompletionState* cmpl_state)
|
|
{
|
|
struct passwd *pwd_ptr;
|
|
gchar* buf_ptr;
|
|
gchar *utf8;
|
|
gint len = 0, i, count = 0;
|
|
|
|
if (cmpl_state->user_dir_name_buffer)
|
|
return TRUE;
|
|
setpwent ();
|
|
|
|
while ((pwd_ptr = getpwent ()) != NULL)
|
|
{
|
|
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;
|
|
}
|
|
|
|
setpwent ();
|
|
|
|
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;
|
|
|
|
for (i = 0; i < count; i += 1)
|
|
{
|
|
pwd_ptr = getpwent ();
|
|
if (!pwd_ptr)
|
|
{
|
|
cmpl_errno = errno;
|
|
goto error;
|
|
}
|
|
|
|
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 += 1;
|
|
|
|
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 += 1;
|
|
}
|
|
|
|
qsort (cmpl_state->user_directories,
|
|
cmpl_state->user_directories_len,
|
|
sizeof (CompletionUserDir),
|
|
compare_user_dir);
|
|
|
|
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);
|
|
|
|
cmpl_state->user_dir_name_buffer = NULL;
|
|
cmpl_state->user_directories = NULL;
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
static gint
|
|
compare_user_dir (const void *a,
|
|
const void *b)
|
|
{
|
|
return strcmp ((((CompletionUserDir*)a))->login,
|
|
(((CompletionUserDir*)b))->login);
|
|
}
|
|
|
|
#endif
|
|
|
|
static gint
|
|
compare_cmpl_dir (const void *a,
|
|
const void *b)
|
|
{
|
|
return compare_filenames ((((CompletionDirEntry*)a))->entry_name,
|
|
(((CompletionDirEntry*)b))->entry_name);
|
|
}
|
|
|
|
static gint
|
|
cmpl_state_okay (CompletionState* cmpl_state)
|
|
{
|
|
return cmpl_state && cmpl_state->reference_dir;
|
|
}
|
|
|
|
static const gchar*
|
|
cmpl_strerror (gint err)
|
|
{
|
|
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);
|
|
}
|