/* 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 Library General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Library General Public License for more details.
*
* You should have received a copy of the GNU Library General Public
* License along with this library; if not, write to the
* Free Software Foundation, Inc., 59 Temple Place - Suite 330,
* Boston, MA 02111-1307, USA.
*/
/*
* Modified by the GTK+ Team and others 1997-1999. See the AUTHORS
* file for a list of people on the GTK+ Team. See the ChangeLog
* files for a list of changes. These files are distributed with
* GTK+ at ftp://ftp.gtk.org/pub/gtk/.
*/
#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/param.h>
#include <dirent.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <errno.h>
#include <pwd.h>
#include "fnmatch.h"
#include "config.h"
//#ifdef DISABLE_NLS
//#define _(Text) Text
//#else
//#include <libintl.h>
//#define _(Text) gettext(Text)
//#endif
#include <gdk/gdkkeysyms.h>
#include <gtk/gtkbutton.h>
#include <gtk/gtkentry.h>
#include "gtkfilesel.h"
#include <gtk/gtkhbox.h>
#include <gtk/gtkhbbox.h>
#include <gtk/gtklabel.h>
#include <gtk/gtklist.h>
#include <gtk/gtklistitem.h>
#include <gtk/gtkmain.h>
#include <gtk/gtkscrolledwindow.h>
#include <gtk/gtksignal.h>
#include <gtk/gtkvbox.h>
#include <gtk/gtkmenu.h>
#include <gtk/gtkmenuitem.h>
#include <gtk/gtkoptionmenu.h>
#include <gtk/gtkclist.h>
#include <gtk/gtkdialog.h>
#include <gtk/gtkcombo.h>
#include <gtk/gtkframe.h>
#include <gtk/gtkpixmap.h>
#include "gtkintl.h"
/* 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
#define DIR_LIST_WIDTH 180
#define DIR_LIST_HEIGHT 180
#define FILE_LIST_WIDTH 180
#define FILE_LIST_HEIGHT 180
/* I've put this here so it doesn't get confused with the
* file completion interface */
typedef struct _HistoryCallbackArg HistoryCallbackArg;
struct _HistoryCallbackArg
{
gchar *directory;
GtkWidget *menu_item;
};
typedef struct _CompletionState CompletionState;
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)
/* 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;
gchar *name_buffer; /* memory segment containing names of all entries */
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
{
gint 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;
gint is_directory;
gint file_size;
gint file_time;
gint uid;
gint gid;
/* Private fields
*/
gint text_alloc;
};
struct _CompletionState
{
gint last_valid_char;
gchar *updated_text;
gint updated_text_len;
gint updated_text_alloc;
gint 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;
};
/* File completion functions which would be external, were they used
* outside of this file.
*/
static CompletionState *cmpl_init_state (void);
static void cmpl_free_state (CompletionState * cmpl_state);
static gint cmpl_state_okay (CompletionState * cmpl_state);
static gchar *cmpl_strerror (gint);
static 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 gint 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 gint 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 (gchar *,
CompletionState * cmpl_state);
/* Directory operations. */
static CompletionDir *open_ref_dir (gchar * text_to_complete,
gchar ** remaining_text,
CompletionState * cmpl_state);
static gboolean check_dir (gchar * dir_name,
struct stat *result, gboolean * stat_subdirs);
static CompletionDir *open_dir (gchar * dir_name,
CompletionState * cmpl_state);
static CompletionDir *open_user_dir (gchar * text_to_complete,
CompletionState * cmpl_state);
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);
static gchar *find_parent_dir_fullname (gchar * dirname);
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 */
static PossibleCompletion *attempt_homedir_completion (gchar *
text_to_complete,
CompletionState *
cmpl_state);
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);
static gint get_pwdb (CompletionState * cmpl_state);
static gint first_diff_index (gchar * pat, gchar * text);
static gint compare_user_dir (const void *a, const void *b);
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_init (GtkFileSelection * filesel);
static void gtk_file_selection_destroy (GtkObject * object);
static gint gtk_file_selection_key_press (GtkWidget * widget,
GdkEventKey * event,
gpointer user_data);
static void gtk_file_selection_file_button (GtkWidget * widget,
gint row,
gint column,
GdkEventButton * bevent,
gpointer user_data);
static void gtk_file_selection_dir_button (GtkWidget * widget,
gint row,
gint column,
GdkEventButton * bevent,
gpointer data);
static void gtk_file_selection_undir_button (GtkWidget * widget,
gint row,
gint column,
GdkEventButton * bevent,
gpointer data);
static void gtk_file_selection_populate (GtkFileSelection * fs,
gchar * rel_path, gint try_complete);
static void gtk_file_selection_abort (GtkFileSelection * fs);
static void gtk_file_selection_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 gboolean gtk_file_selection_history_combo_callback (GtkWidget * widget,
GdkEventKey *
event,
gpointer data);
static gboolean gtk_file_selection_history_combo_list_key_handler (GtkWidget *
widget,
GdkEventKey
* event,
gpointer
user_data);
static gboolean gtk_file_selection_history_combo_list_callback (GtkWidget *
thelist,
GdkEventButton
* event,
gpointer
user_data);
static void gtk_file_selection_mask_entry_callback (GtkWidget * widget,
gpointer data);
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 gtk_file_selection_home_button (GtkWidget * widget,
gpointer data);
static void gtk_file_selection_up_button (GtkWidget * widget, gpointer data);
static void gtk_file_selection_prev_button (GtkWidget * widget,
gpointer data);
static void gtk_file_selection_next_button (GtkWidget * widget,
gpointer data);
static void gtk_file_selection_refresh_button (GtkWidget * widget,
gpointer data);
static gint gtk_file_selection_match_char (gchar, gchar * mask);
static gint gtk_file_selection_match_mask (gchar *, gchar *);
static GtkWindowClass *parent_class = NULL;
/* Saves errno when something cmpl does fails. */
static gint cmpl_errno;
/* General notes:
* Make prev and next inactive if their respective *
* histories are empty.
* Add facilities for handling hidden files and *
* directories *
* Add an api to access the mask, and hidden files *
* check box? (prob not in 1.2.x series) *
*/
/* Routine for applying mask to filenames *
* Need to be optimized to minimize recursion *
* help the for loop by looking for the next *
* instance of the mask character following *
* the '*'. ei *.c -- look for '.' *
* Also, swap all *? pairs (-> ?*), as that *
* will make it possible to look ahead (? *
* makes it very nondeterministic as in *?.c *
* which really is ?*.c *
* Allow multiply masks, separted by commas *
* Allow more flexible [] handling (ie [a-zA-Z] *
* *
*/
static gint
gtk_file_selection_match_char (gchar text, gchar * mask)
{
gchar *maskc;
gint x;
gint s;
if (mask[0] == '[')
{
if (!strchr (mask, ']'))
return 0;
maskc = g_strdup (mask + 1); /* get the portion of mask inside [] */
(*(strchr (maskc, ']'))) = 0;
s =(gint) strlen ((char *) maskc);
for (x = 0; x < s; x++)
{
if (text == maskc[x])
{
g_free (maskc);
return s + 2;
}
}
g_free (maskc);
return 0;
}
if (mask[0] == '?')
return 1;
if (mask[0] == text)
return 1;
return 0;
}
static gint
gtk_file_selection_match_mask (gchar * text, gchar * mask)
{
int mc;
int tc;
gchar *mymask;
gchar *mask2, *mask3;
int tc1 = 0;
tc = 0;
mc = 0;
if (mask[0] == 0 && text[0] == 0)
return 1;
if (mask[0] == '*')
{
/*MK*/ mymask = g_strdup (mask);
mask2 = g_strdup (strchr (mymask, ','));
if (mask2 != (char *) NULL)
{
tc1 = 1;
(*(strchr (mymask, ','))) = 0;
}
for (tc = 0; tc <= (int)strlen (text); tc++)
{
if (gtk_file_selection_match_mask (text + tc, mymask + 1))
{
/* fprintf(stderr,"%s matches %s\n",text,mymask);*/
g_free (mymask);
g_free (mask2);
return 1;
}
}
/*MK*/ if (tc1 == 0)
{
/* fprintf(stderr,"no mask2\n");*/
g_free (mymask);
return 0;
}
mask2++;
/* fprintf(stderr,"mask2: %s, text=%s\n",mask2,text);*/
if (mask2[0] != '*')
{
g_free (mymask);
free (--mask2);
return 0;
}
tc = 0;
mask3 = strchr (mask2, ',');
if (mask3 != (char *) NULL)
{
tc = 1;
(*(strchr (mask2, ','))) = 0;
}
for (tc1 = 0; tc1 <= (int)strlen (text); tc1++)
{
if (gtk_file_selection_match_mask (text + tc1, mask2 + 1))
{
/* fprintf(stderr,"%s matches %s\n",text,mask2);*/
free (--mask2);
g_free (mymask);
return 1;
}
}
if (tc == 0)
{
/* fprintf(stderr,"no mask3 -- no match for %s\n",text);*/
g_free (--mask2);
g_free (mymask);
return 0;
}
mask3++;
/* fprintf(stderr,"mask3: %s, text=%s\n",mask3,text);*/
if (mask3[0] != '*')
{
g_free (--mask2);
g_free (mymask);
return 0;
}
for (tc = 0; tc <= (int)strlen (text); tc++)
{
if (gtk_file_selection_match_mask (text + tc, mask3 + 1))
{
/* fprintf(stderr,"%s matches %s\n",text,mask3);*/
g_free (--mask2);
g_free (mymask);
return 1;
}
}
/*MK*/ g_free (--mask2);
g_free (mymask);
/* fprintf(stderr,"nothing matches %s\n",text);*/
return 0;
}
mc = gtk_file_selection_match_char (text[0], mask);
if (mc)
return gtk_file_selection_match_mask (text + 1, mask + mc);
else
return 0;
}
GtkType gtk_file_selection_get_type (void)
{
static GtkType file_selection_type = 0;
if (!file_selection_type)
{
static const GtkTypeInfo filesel_info = {
"GtkFileSelection",
(guint)sizeof (GtkFileSelection),
(guint)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_WINDOW, &filesel_info);
}
return file_selection_type;
}
static void
gtk_file_selection_class_init (GtkFileSelectionClass * class)
{
GtkObjectClass *object_class;
object_class = (GtkObjectClass *) class;
parent_class = gtk_type_class (GTK_TYPE_WINDOW);
object_class->destroy = gtk_file_selection_destroy;
}
static void
gtk_file_selection_init (GtkFileSelection * filesel)
{
GtkWidget *entry_vbox;
GtkWidget *label;
GtkWidget *list_hbox;
GtkWidget *confirm_area;
GtkWidget *vbox;
GtkWidget *hbox;
GtkWidget *pulldown_hbox;
GtkWidget *scrolled_win;
GtkWidget *mask_label;
GtkWidget *bigframe;
GtkWidget *label_lookingin;
GtkWidget *up_button;
GtkWidget *home_button;
GtkWidget *prev_button;
GtkWidget *next_button;
GtkWidget *refresh_button;
GdkPixmap *pixmap;
GtkWidget *pixmapwidget;
GtkStyle *style;
GdkBitmap *mask;
char *dir_title[2];
char *file_title[2];
filesel->cmpl_state = cmpl_init_state ();
filesel->mask = NULL;
filesel->prev_history = NULL;
filesel->next_history = NULL;
filesel->saved_entry = NULL;
/* The dialog-sized vertical box */
filesel->main_vbox = gtk_vbox_new (FALSE, 10);
gtk_container_set_border_width (GTK_CONTAINER (filesel), 10);
gtk_container_add (GTK_CONTAINER (filesel), filesel->main_vbox);
gtk_widget_show (filesel->main_vbox);
/* The horizontal box containing create, rename etc. buttons */
filesel->button_area = gtk_hbutton_box_new ();
gtk_button_box_set_layout (GTK_BUTTON_BOX (filesel->button_area),
GTK_BUTTONBOX_START);
gtk_button_box_set_spacing (GTK_BUTTON_BOX (filesel->button_area), 0);
gtk_box_pack_start (GTK_BOX (filesel->main_vbox), filesel->button_area,
FALSE, FALSE, 0);
gtk_widget_show (filesel->button_area);
gtk_file_selection_show_fileop_buttons (filesel);
/* hbox for pulldown menu */
pulldown_hbox = gtk_hbox_new (FALSE, 5);
gtk_box_pack_start (GTK_BOX (filesel->main_vbox), pulldown_hbox, FALSE,
FALSE, 0);
gtk_widget_show (pulldown_hbox);
/* The combo box that replaces the pulldown menu */
label_lookingin = gtk_label_new (_("Looking in:"));
gtk_widget_show (label_lookingin);
gtk_box_pack_start (GTK_BOX (pulldown_hbox), label_lookingin, FALSE, FALSE,
0);
filesel->history_combo = gtk_combo_new ();
gtk_widget_show (filesel->history_combo);
gtk_combo_set_value_in_list (GTK_COMBO (filesel->history_combo), FALSE,
FALSE);
gtk_box_pack_start (GTK_BOX (pulldown_hbox), filesel->history_combo, TRUE,
TRUE, 0);
(void)gtk_signal_connect (GTK_OBJECT
(((GtkCombo *) filesel->history_combo)->entry),
"key-press-event",
(GtkSignalFunc)
gtk_file_selection_history_combo_callback,
(gpointer) filesel);
(void)gtk_signal_connect (GTK_OBJECT
(((GtkCombo *) filesel->history_combo)->list),
"button-press-event",
(GtkSignalFunc)
gtk_file_selection_history_combo_list_callback,
(gpointer) filesel);
(void)gtk_signal_connect (GTK_OBJECT
(((GtkCombo *) filesel->history_combo)->list),
"key-press-event",
(GtkSignalFunc)
gtk_file_selection_history_combo_list_key_handler,
(gpointer) filesel);
/* frame to put the following hbox in */
bigframe = gtk_frame_new (NULL);
gtk_widget_show (bigframe);
gtk_box_pack_start (GTK_BOX (filesel->main_vbox), bigframe, TRUE, TRUE, 0);
/* The horizontal box containing the directory and file listboxes */
list_hbox = gtk_hbox_new (FALSE, 5);
gtk_container_add (GTK_CONTAINER (bigframe), list_hbox);
gtk_container_set_border_width (GTK_CONTAINER (list_hbox), 5);
gtk_widget_show (list_hbox);
/* vbox to put the buttons and directory listing in */
vbox = gtk_vbox_new (FALSE, 0);
gtk_widget_show (vbox);
gtk_box_pack_start (GTK_BOX (list_hbox), vbox, FALSE, FALSE, 0);
hbox = gtk_hbox_new (FALSE, 0);
gtk_widget_show (hbox);
gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0);
/* home_button = gtk_button_new_with_label (_("Home"));*/
/* style= gtk_widget_get_style(GTK_WIDGET(filesel));*/
gtk_widget_realize (GTK_WIDGET (filesel));
style = filesel->button_area->style;
pixmap = gdk_pixmap_create_from_xpm_d (GTK_WIDGET (filesel)->window, &mask,
&style->bg[GTK_STATE_NORMAL],
(gchar **) filesel_home_pixmap);
pixmapwidget = gtk_pixmap_new (pixmap, mask);
gtk_widget_show (pixmapwidget);
gdk_pixmap_unref (pixmap);
home_button = gtk_button_new ();
gtk_container_add (GTK_CONTAINER (home_button), pixmapwidget);
gtk_widget_show (home_button);
(void)gtk_signal_connect (GTK_OBJECT (home_button), "clicked",
(GtkSignalFunc) gtk_file_selection_home_button,
(gpointer) filesel);
gtk_box_pack_start (GTK_BOX (hbox), home_button, TRUE, TRUE, 0);
/* prev_button = gtk_button_new_with_label (_("Prev"));*/
pixmap = gdk_pixmap_create_from_xpm_d (GTK_WIDGET (filesel)->window, &mask,
&style->bg[GTK_STATE_NORMAL],
(gchar **) filesel_back_pixmap);
pixmapwidget = gtk_pixmap_new (pixmap, mask);
gtk_widget_show (pixmapwidget);
gdk_pixmap_unref (pixmap);
prev_button = gtk_button_new ();
gtk_container_add (GTK_CONTAINER (prev_button), pixmapwidget);
(void)gtk_signal_connect (GTK_OBJECT (prev_button), "clicked",
(GtkSignalFunc) gtk_file_selection_prev_button,
(gpointer) filesel);
gtk_widget_show (prev_button);
gtk_box_pack_start (GTK_BOX (hbox), prev_button, TRUE, TRUE, 0);
/* up_button = gtk_button_new_with_label (_("Up"));*/
pixmap = gdk_pixmap_create_from_xpm_d (GTK_WIDGET (filesel)->window, &mask,
&style->bg[GTK_STATE_NORMAL],
(gchar **) filesel_up_pixmap);
pixmapwidget = gtk_pixmap_new (pixmap, mask);
gtk_widget_show (pixmapwidget);
gdk_pixmap_unref (pixmap);
up_button = gtk_button_new ();
gtk_container_add (GTK_CONTAINER (up_button), pixmapwidget);
(void)gtk_signal_connect (GTK_OBJECT (up_button), "clicked",
(GtkSignalFunc) gtk_file_selection_up_button,
(gpointer) filesel);
gtk_widget_show (up_button);
gtk_box_pack_start (GTK_BOX (hbox), up_button, TRUE, TRUE, 0);
/* next_button = gtk_button_new_with_label (_("Next"));*/
pixmap = gdk_pixmap_create_from_xpm_d (GTK_WIDGET (filesel)->window, &mask,
&style->bg[GTK_STATE_NORMAL],
(gchar **) filesel_forward_pixmap);
pixmapwidget = gtk_pixmap_new (pixmap, mask);
gtk_widget_show (pixmapwidget);
gdk_pixmap_unref (pixmap);
next_button = gtk_button_new ();
gtk_container_add (GTK_CONTAINER (next_button), pixmapwidget);
gtk_widget_show (next_button);
(void)gtk_signal_connect (GTK_OBJECT (next_button), "clicked",
(GtkSignalFunc) gtk_file_selection_next_button,
(gpointer) filesel);
gtk_box_pack_start (GTK_BOX (hbox), next_button, TRUE, TRUE, 0);
/* refresh_button = gtk_button_new_with_label (_("Refresh"));*/
pixmap = gdk_pixmap_create_from_xpm_d (GTK_WIDGET (filesel)->window, &mask,
&style->bg[GTK_STATE_NORMAL],
(gchar **) filesel_reload_pixmap);
pixmapwidget = gtk_pixmap_new (pixmap, mask);
gtk_widget_show (pixmapwidget);
gdk_pixmap_unref (pixmap);
refresh_button = gtk_button_new ();
gtk_container_add (GTK_CONTAINER (refresh_button), pixmapwidget);
gtk_widget_show (refresh_button);
(void)gtk_signal_connect (GTK_OBJECT (refresh_button), "clicked",
(GtkSignalFunc) gtk_file_selection_refresh_button,
(gpointer) filesel);
gtk_box_pack_start (GTK_BOX (hbox), refresh_button, TRUE, TRUE, 0);
/* The directories clist */
dir_title[0] = _("Directories");
dir_title[1] = NULL;
filesel->dir_list = gtk_clist_new_with_titles (1, (gchar **) dir_title);
gtk_widget_set_usize (filesel->dir_list, DIR_LIST_WIDTH, DIR_LIST_HEIGHT);
(void)gtk_signal_connect (GTK_OBJECT (filesel->dir_list), "select_row",
(GtkSignalFunc) gtk_file_selection_dir_button,
(gpointer) filesel);
(void)gtk_signal_connect (GTK_OBJECT (filesel->dir_list), "unselect_row",
(GtkSignalFunc) gtk_file_selection_undir_button,
(gpointer) filesel);
gtk_clist_column_titles_passive (GTK_CLIST (filesel->dir_list));
scrolled_win = gtk_scrolled_window_new (NULL, NULL);
gtk_container_add (GTK_CONTAINER (scrolled_win), filesel->dir_list);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_win),
GTK_POLICY_AUTOMATIC, GTK_POLICY_ALWAYS);
gtk_box_pack_start (GTK_BOX (vbox), scrolled_win, TRUE, TRUE, 5);
gtk_widget_show (filesel->dir_list);
gtk_widget_show (scrolled_win);
/* vbox area for mask entry and files clist */
vbox = gtk_vbox_new (FALSE, 0);
gtk_widget_show (vbox);
gtk_box_pack_start (GTK_BOX (list_hbox), vbox, TRUE, TRUE, 0);
hbox = gtk_hbox_new (FALSE, 5);
gtk_widget_show (hbox);
gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0);
mask_label = gtk_label_new (_("Mask:"));
gtk_widget_show (mask_label);
gtk_box_pack_start (GTK_BOX (hbox), mask_label, FALSE, FALSE, 0);
filesel->mask_entry = gtk_entry_new ();
gtk_widget_show (filesel->mask_entry);
(void)gtk_signal_connect (GTK_OBJECT (filesel->mask_entry), "activate",
(GtkSignalFunc) gtk_file_selection_mask_entry_callback,
(gpointer) filesel);
gtk_box_pack_start (GTK_BOX (hbox), filesel->mask_entry, TRUE, TRUE, 0);
/* The files clist */
file_title[0] = _("Files");
file_title[1] = NULL;
filesel->file_list = gtk_clist_new_with_titles (1, (gchar **) file_title);
gtk_widget_set_usize (filesel->file_list, FILE_LIST_WIDTH,
FILE_LIST_HEIGHT);
(void)gtk_signal_connect (GTK_OBJECT (filesel->file_list), "select_row",
(GtkSignalFunc) gtk_file_selection_file_button,
(gpointer) filesel);
gtk_clist_column_titles_passive (GTK_CLIST (filesel->file_list));
scrolled_win = gtk_scrolled_window_new (NULL, NULL);
gtk_container_add (GTK_CONTAINER (scrolled_win), filesel->file_list);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_win),
GTK_POLICY_AUTOMATIC, GTK_POLICY_ALWAYS);
gtk_box_pack_start (GTK_BOX (vbox), scrolled_win, TRUE, TRUE, 5);
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 = gtk_hbutton_box_new ();
gtk_button_box_set_layout (GTK_BUTTON_BOX (confirm_area),
GTK_BUTTONBOX_END);
gtk_button_box_set_spacing (GTK_BUTTON_BOX (confirm_area), 5);
gtk_box_pack_end (GTK_BOX (filesel->main_vbox), confirm_area, FALSE, FALSE,
0);
gtk_widget_show (confirm_area);
/* The OK button */
filesel->ok_button = gtk_button_new_with_label (_("OK"));
GTK_WIDGET_SET_FLAGS (filesel->ok_button, GTK_CAN_DEFAULT);
gtk_box_pack_start (GTK_BOX (confirm_area), filesel->ok_button, TRUE, TRUE,
0);
gtk_widget_grab_default (filesel->ok_button);
gtk_widget_show (filesel->ok_button);
/* The Cancel button */
filesel->cancel_button = gtk_button_new_with_label (_("Cancel"));
GTK_WIDGET_SET_FLAGS (filesel->cancel_button, GTK_CAN_DEFAULT);
gtk_box_pack_start (GTK_BOX (confirm_area), filesel->cancel_button, TRUE,
TRUE, 0);
gtk_widget_show (filesel->cancel_button);
/* The selection entry widget */
entry_vbox = gtk_vbox_new (FALSE, 2);
gtk_box_pack_end (GTK_BOX (filesel->main_vbox), entry_vbox, FALSE, FALSE,
0);
gtk_widget_show (entry_vbox);
filesel->selection_text = label = gtk_label_new ("");
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
gtk_box_pack_start (GTK_BOX (entry_vbox), label, FALSE, FALSE, 0);
gtk_widget_show (label);
filesel->selection_entry = gtk_entry_new ();
(void)gtk_signal_connect (GTK_OBJECT (filesel->selection_entry),
"key_press_event",
(GtkSignalFunc) gtk_file_selection_key_press, filesel);
(void)gtk_signal_connect_object (GTK_OBJECT (filesel->selection_entry),
"focus_in_event",
(GtkSignalFunc) gtk_widget_grab_default,
GTK_OBJECT (filesel->ok_button));
(void)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];
snprintf (err_buf,256, _("Directory unreadable: %s"),
cmpl_strerror (cmpl_errno));
gtk_label_set_text (GTK_LABEL (filesel->selection_text), err_buf);
}
else
{
gtk_file_selection_populate (filesel, "", FALSE);
}
gtk_widget_grab_focus (filesel->selection_entry);
}
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);
return GTK_WIDGET (filesel);
}
void
gtk_file_selection_show_fileop_buttons (GtkFileSelection * filesel)
{
g_return_if_fail (filesel != NULL);
g_return_if_fail (GTK_IS_FILE_SELECTION (filesel));
/* delete, create directory, and rename */
if (!filesel->fileop_c_dir)
{
filesel->fileop_c_dir = gtk_button_new_with_label (_("Create Dir"));
(void)gtk_signal_connect (GTK_OBJECT (filesel->fileop_c_dir), "clicked",
(GtkSignalFunc) gtk_file_selection_create_dir,
(gpointer) filesel);
gtk_box_pack_start (GTK_BOX (filesel->button_area),
filesel->fileop_c_dir, TRUE, TRUE, 0);
gtk_widget_show (filesel->fileop_c_dir);
}
if (!filesel->fileop_del_file)
{
filesel->fileop_del_file = gtk_button_new_with_label (_("Delete File"));
(void)gtk_signal_connect (GTK_OBJECT (filesel->fileop_del_file), "clicked",
(GtkSignalFunc) gtk_file_selection_delete_file,
(gpointer) filesel);
gtk_box_pack_start (GTK_BOX (filesel->button_area),
filesel->fileop_del_file, TRUE, TRUE, 0);
gtk_widget_show (filesel->fileop_del_file);
}
if (!filesel->fileop_ren_file)
{
filesel->fileop_ren_file = gtk_button_new_with_label (_("Rename File"));
(void)gtk_signal_connect (GTK_OBJECT (filesel->fileop_ren_file), "clicked",
(GtkSignalFunc) gtk_file_selection_rename_file,
(gpointer) filesel);
gtk_box_pack_start (GTK_BOX (filesel->button_area),
filesel->fileop_ren_file, TRUE, TRUE, 0);
gtk_widget_show (filesel->fileop_ren_file);
}
gtk_widget_queue_resize (GTK_WIDGET (filesel));
}
void
gtk_file_selection_hide_fileop_buttons (GtkFileSelection * filesel)
{
g_return_if_fail (filesel != NULL);
g_return_if_fail (GTK_IS_FILE_SELECTION (filesel));
if (filesel->fileop_ren_file)
{
gtk_widget_destroy (filesel->fileop_ren_file);
filesel->fileop_ren_file = NULL;
}
if (filesel->fileop_del_file)
{
gtk_widget_destroy (filesel->fileop_del_file);
filesel->fileop_del_file = NULL;
}
if (filesel->fileop_c_dir)
{
gtk_widget_destroy (filesel->fileop_c_dir);
filesel->fileop_c_dir = NULL;
}
}
void
gtk_file_selection_set_filename (GtkFileSelection * filesel,
const gchar * filename)
{
char buf[MAXPATHLEN];
const char *name, *last_slash;
g_return_if_fail (filesel != NULL);
g_return_if_fail (GTK_IS_FILE_SELECTION (filesel));
g_return_if_fail (filename != NULL);
last_slash = strrchr (filename, '/');
if (!last_slash)
{
buf[0] = 0;
name = filename;
}
else
{
gint len = MIN ((int)MAXPATHLEN - 1, (int)(last_slash - filename + 1));
strncpy (buf, filename, (size_t)len);
buf[len] = 0;
name = last_slash + 1;
}
gtk_file_selection_populate (filesel, buf, FALSE);
if (filesel->selection_entry)
gtk_entry_set_text (GTK_ENTRY (filesel->selection_entry), name);
}
gchar *
gtk_file_selection_get_filename (GtkFileSelection * filesel)
{
static char nothing[2] = "";
char *text;
char *filename;
g_return_val_if_fail (filesel != NULL, nothing);
g_return_val_if_fail (GTK_IS_FILE_SELECTION (filesel), nothing);
text = gtk_entry_get_text (GTK_ENTRY (filesel->selection_entry));
if (text)
{
filename = cmpl_completion_fullname (text, filesel->cmpl_state);
return filename;
}
return nothing;
}
void
gtk_file_selection_complete (GtkFileSelection * filesel,
const gchar * pattern)
{
gchar *new_pattern;
gint x;
g_return_if_fail (filesel != NULL);
g_return_if_fail (GTK_IS_FILE_SELECTION (filesel));
g_return_if_fail (pattern != NULL);
if (filesel->selection_entry)
gtk_entry_set_text (GTK_ENTRY (filesel->selection_entry), pattern);
if (strchr (pattern, '*') || strchr (pattern, '?'))
{
for (x = (gint)strlen (pattern); x >= 0; x--)
{
if (pattern[x] == '/')
break;
}
gtk_entry_set_text (GTK_ENTRY (filesel->mask_entry),
g_strdup (pattern + x + 1));
if (filesel->mask)
g_free (filesel->mask);
filesel->mask = g_strdup (pattern + x + 1);
new_pattern = g_strdup (pattern);
new_pattern[x + 1] = 0;
gtk_file_selection_populate (filesel, (gchar *) new_pattern, TRUE);
g_free (new_pattern);
}
else
{
gtk_file_selection_populate (filesel, (gchar *) pattern, TRUE);
}
}
static void
gtk_file_selection_destroy (GtkObject * object)
{
GtkFileSelection *filesel;
GList *list;
g_return_if_fail (object != NULL);
g_return_if_fail (GTK_IS_FILE_SELECTION (object));
filesel = GTK_FILE_SELECTION (object);
if (filesel->fileop_dialog)
gtk_widget_destroy (filesel->fileop_dialog);
if (filesel->next_history)
{
list = filesel->next_history;
while (list)
{
g_free (list->data);
list = list->next;
}
}
g_list_free (filesel->next_history);
filesel->next_history = NULL;
if (filesel->prev_history)
{
list = filesel->prev_history;
while (list)
{
g_free (list->data);
list = list->next;
}
}
g_list_free (filesel->prev_history);
filesel->prev_history = NULL;
if (filesel->mask)
{
g_free (filesel->mask);
filesel->mask = NULL;
}
cmpl_free_state (filesel->cmpl_state);
filesel->cmpl_state = NULL;
if (GTK_OBJECT_CLASS (parent_class)->destroy)
(*GTK_OBJECT_CLASS (parent_class)->destroy) (object);
}
/* Begin file operations callbacks */
static void
gtk_file_selection_fileop_error (GtkFileSelection * fs, gchar * error_message)
{
GtkWidget *label;
GtkWidget *vbox;
GtkWidget *button;
GtkWidget *dialog;
g_return_if_fail (error_message != NULL);
/* main dialog */
dialog = gtk_dialog_new ();
/*
gtk_signal_connect (GTK_OBJECT (dialog), "destroy",
(GtkSignalFunc) gtk_file_selection_fileop_destroy,
(gpointer) fs);
*/
gtk_window_set_title (GTK_WINDOW (dialog), _("Error"));
gtk_window_set_position (GTK_WINDOW (dialog), GTK_WIN_POS_MOUSE);
/* If file dialog is grabbed, make this dialog modal too */
/* When error 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 (error_message);
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.0);
gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 5);
gtk_widget_show (label);
/* yes, we free it */
g_free (error_message);
/* close button */
button = gtk_button_new_with_label (_("Close"));
(void)gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
(GtkSignalFunc) gtk_widget_destroy,
(gpointer) dialog);
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog)->action_area),
button, TRUE, TRUE, 0);
GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
gtk_widget_grab_default (button);
gtk_widget_show (button);
gtk_widget_show (dialog);
}
static void
gtk_file_selection_fileop_destroy (GtkWidget * widget, gpointer data)
{
GtkFileSelection *fs = data;
g_return_if_fail (fs != NULL);
g_return_if_fail (GTK_IS_FILE_SELECTION (fs));
fs->fileop_dialog = NULL;
}
static void
gtk_file_selection_create_dir_confirmed (GtkWidget * widget, gpointer data)
{
GtkFileSelection *fs = data;
gchar *dirname;
gchar *path;
gchar *full_path;
gchar *buf;
CompletionState *cmpl_state;
g_return_if_fail (fs != NULL);
g_return_if_fail (GTK_IS_FILE_SELECTION (fs));
dirname = gtk_entry_get_text (GTK_ENTRY (fs->fileop_entry));
cmpl_state = (CompletionState *) fs->cmpl_state;
path = cmpl_reference_position (cmpl_state);
full_path = g_strconcat (path, "/", dirname, NULL);
if ((mkdir (full_path, 0755) < 0))
{
buf = g_strconcat ("Error creating directory \"", dirname, "\": ",
g_strerror (errno), NULL);
gtk_file_selection_fileop_error (fs, buf);
}
g_free (full_path);
gtk_widget_destroy (fs->fileop_dialog);
gtk_file_selection_populate (fs, "", FALSE);
}
static void
gtk_file_selection_create_dir (GtkWidget * widget, gpointer data)
{
GtkFileSelection *fs = data;
GtkWidget *label;
GtkWidget *dialog;
GtkWidget *vbox;
GtkWidget *button;
g_return_if_fail (fs != NULL);
g_return_if_fail (GTK_IS_FILE_SELECTION (fs));
if (fs->fileop_dialog)
return;
/* main dialog */
fs->fileop_dialog = dialog = gtk_dialog_new ();
(void)gtk_signal_connect (GTK_OBJECT (dialog), "destroy",
(GtkSignalFunc) gtk_file_selection_fileop_destroy,
(gpointer) fs);
gtk_window_set_title (GTK_WINDOW (dialog), _("Create Directory"));
gtk_window_set_position (GTK_WINDOW (dialog), GTK_WIN_POS_MOUSE);
/* If file dialog is grabbed, grab option dialog */
/* When option dialog is closed, file dialog will be grabbed again */
if (GTK_WINDOW (fs)->modal)
gtk_window_set_modal (GTK_WINDOW (dialog), TRUE);
vbox = gtk_vbox_new (FALSE, 0);
gtk_container_set_border_width (GTK_CONTAINER (vbox), 8);
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog)->vbox), vbox,
FALSE, FALSE, 0);
gtk_widget_show (vbox);
label = gtk_label_new (_("Directory name:"));
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.0);
gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 5);
gtk_widget_show (label);
/* The directory entry widget */
fs->fileop_entry = gtk_entry_new ();
gtk_box_pack_start (GTK_BOX (vbox), fs->fileop_entry, TRUE, TRUE, 5);
GTK_WIDGET_SET_FLAGS (fs->fileop_entry, GTK_CAN_DEFAULT);
gtk_widget_show (fs->fileop_entry);
/* buttons */
button = gtk_button_new_with_label (_("Create"));
(void)gtk_signal_connect (GTK_OBJECT (button), "clicked",
(GtkSignalFunc) gtk_file_selection_create_dir_confirmed,
(gpointer) fs);
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog)->action_area),
button, TRUE, TRUE, 0);
GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
gtk_widget_show (button);
button = gtk_button_new_with_label (_("Cancel"));
(void)gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
(GtkSignalFunc) gtk_widget_destroy,
(gpointer) dialog);
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog)->action_area),
button, TRUE, TRUE, 0);
GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
gtk_widget_grab_default (button);
gtk_widget_show (button);
gtk_widget_show (dialog);
}
static void
gtk_file_selection_delete_file_confirmed (GtkWidget * widget, gpointer data)
{
GtkFileSelection *fs = data;
CompletionState *cmpl_state;
gchar *path;
gchar *full_path;
gchar *buf;
g_return_if_fail (fs != NULL);
g_return_if_fail (GTK_IS_FILE_SELECTION (fs));
cmpl_state = (CompletionState *) fs->cmpl_state;
path = cmpl_reference_position (cmpl_state);
full_path = g_strconcat (path, "/", fs->fileop_file, NULL);
if ((unlink (full_path) < 0))
{
buf = g_strconcat ("Error deleting file \"", fs->fileop_file, "\": ",
g_strerror (errno), NULL);
gtk_file_selection_fileop_error (fs, buf);
}
g_free (full_path);
gtk_widget_destroy (fs->fileop_dialog);
gtk_file_selection_populate (fs, "", FALSE);
}
static void
gtk_file_selection_delete_file (GtkWidget * widget, gpointer data)
{
GtkFileSelection *fs = data;
GtkWidget *label;
GtkWidget *vbox;
GtkWidget *button;
GtkWidget *dialog;
gchar *filename;
gchar *buf;
g_return_if_fail (fs != NULL);
g_return_if_fail (GTK_IS_FILE_SELECTION (fs));
if (fs->fileop_dialog)
return;
filename = gtk_entry_get_text (GTK_ENTRY (fs->selection_entry));
if (strlen (filename) < 1)
return;
fs->fileop_file = filename;
/* main dialog */
fs->fileop_dialog = dialog = gtk_dialog_new ();
(void)gtk_signal_connect (GTK_OBJECT (dialog), "destroy",
(GtkSignalFunc) gtk_file_selection_fileop_destroy,
(gpointer) fs);
gtk_window_set_title (GTK_WINDOW (dialog), _("Delete File"));
gtk_window_set_position (GTK_WINDOW (dialog), GTK_WIN_POS_MOUSE);
/* If file dialog is grabbed, grab option dialog */
/* When option dialog is closed, file dialog will be grabbed again */
if (GTK_WINDOW (fs)->modal)
gtk_window_set_modal (GTK_WINDOW (dialog), TRUE);
vbox = gtk_vbox_new (FALSE, 0);
gtk_container_set_border_width (GTK_CONTAINER (vbox), 8);
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog)->vbox), vbox,
FALSE, FALSE, 0);
gtk_widget_show (vbox);
buf = g_strconcat ("Really delete file \"", filename, "\" ?", NULL);
label = gtk_label_new (buf);
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.0);
gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 5);
gtk_widget_show (label);
g_free (buf);
/* buttons */
button = gtk_button_new_with_label (_("Delete"));
(void)gtk_signal_connect (GTK_OBJECT (button), "clicked",
(GtkSignalFunc)
gtk_file_selection_delete_file_confirmed,
(gpointer) fs);
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog)->action_area), button,
TRUE, TRUE, 0);
GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
gtk_widget_show (button);
button = gtk_button_new_with_label (_("Cancel"));
(void)gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
(GtkSignalFunc) gtk_widget_destroy,
(gpointer) dialog);
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog)->action_area),
button, TRUE, TRUE, 0);
GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
gtk_widget_grab_default (button);
gtk_widget_show (button);
gtk_widget_show (dialog);
}
static void
gtk_file_selection_rename_file_confirmed (GtkWidget * widget, gpointer data)
{
GtkFileSelection *fs = data;
gchar *buf;
gchar *file;
gchar *path;
gchar *new_filename;
gchar *old_filename;
CompletionState *cmpl_state;
g_return_if_fail (fs != NULL);
g_return_if_fail (GTK_IS_FILE_SELECTION (fs));
file = gtk_entry_get_text (GTK_ENTRY (fs->fileop_entry));
cmpl_state = (CompletionState *) fs->cmpl_state;
path = cmpl_reference_position (cmpl_state);
new_filename = g_strconcat (path, "/", file, NULL);
old_filename = g_strconcat (path, "/", fs->fileop_file, NULL);
if ((rename (old_filename, new_filename)) < 0)
{
buf = g_strconcat ("Error renaming file \"", file, "\": ",
g_strerror (errno), NULL);
gtk_file_selection_fileop_error (fs, buf);
}
g_free (new_filename);
g_free (old_filename);
gtk_widget_destroy (fs->fileop_dialog);
gtk_file_selection_populate (fs, "", FALSE);
}
static void
gtk_file_selection_rename_file (GtkWidget * widget, gpointer data)
{
GtkFileSelection *fs = data;
GtkWidget *label;
GtkWidget *dialog;
GtkWidget *vbox;
GtkWidget *button;
gchar *buf;
g_return_if_fail (fs != NULL);
g_return_if_fail (GTK_IS_FILE_SELECTION (fs));
if (fs->fileop_dialog)
return;
fs->fileop_file = gtk_entry_get_text (GTK_ENTRY (fs->selection_entry));
if (strlen (fs->fileop_file) < 1)
return;
/* main dialog */
fs->fileop_dialog = dialog = gtk_dialog_new ();
(void)gtk_signal_connect (GTK_OBJECT (dialog), "destroy",
(GtkSignalFunc) gtk_file_selection_fileop_destroy,
(gpointer) fs);
gtk_window_set_title (GTK_WINDOW (dialog), _("Rename File"));
gtk_window_set_position (GTK_WINDOW (dialog), GTK_WIN_POS_MOUSE);
/* If file dialog is grabbed, grab option dialog */
/* When option dialog closed, file dialog will be grabbed again */
if (GTK_WINDOW (fs)->modal)
gtk_window_set_modal (GTK_WINDOW (dialog), TRUE);
vbox = gtk_vbox_new (FALSE, 0);
gtk_container_set_border_width (GTK_CONTAINER (vbox), 8);
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog)->vbox), vbox,
FALSE, FALSE, 0);
gtk_widget_show (vbox);
buf = g_strconcat ("Rename file \"", fs->fileop_file, "\" to:", NULL);
label = gtk_label_new (buf);
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.0);
gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 5);
gtk_widget_show (label);
g_free (buf);
/* New filename entry */
fs->fileop_entry = gtk_entry_new ();
gtk_box_pack_start (GTK_BOX (vbox), fs->fileop_entry, TRUE, TRUE, 5);
GTK_WIDGET_SET_FLAGS (fs->fileop_entry, GTK_CAN_DEFAULT);
gtk_widget_show (fs->fileop_entry);
gtk_entry_set_text (GTK_ENTRY (fs->fileop_entry), fs->fileop_file);
gtk_editable_select_region (GTK_EDITABLE (fs->fileop_entry),
0, (gint)strlen (fs->fileop_file));
/* buttons */
button = gtk_button_new_with_label (_("Rename"));
(void)gtk_signal_connect (GTK_OBJECT (button), "clicked",
(GtkSignalFunc)
gtk_file_selection_rename_file_confirmed,
(gpointer) fs);
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog)->action_area), button,
TRUE, TRUE, 0);
GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
gtk_widget_show (button);
button = gtk_button_new_with_label (_("Cancel"));
(void)gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
(GtkSignalFunc) gtk_widget_destroy,
(gpointer) dialog);
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog)->action_area),
button, TRUE, TRUE, 0);
GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
gtk_widget_grab_default (button);
gtk_widget_show (button);
gtk_widget_show (dialog);
}
static gint
gtk_file_selection_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);
fs = GTK_FILE_SELECTION (user_data);
if (event->keyval == GDK_Tab)
{
text = gtk_entry_get_text (GTK_ENTRY (fs->selection_entry));
text = g_strdup (text);
gtk_file_selection_populate (fs, text, TRUE);
g_free (text);
gtk_signal_emit_stop_by_name (GTK_OBJECT (widget), "key_press_event");
return TRUE;
}
if (fs->saved_entry)
{
gtk_clist_unselect_all ((GtkCList *) (fs->dir_list));
gtk_entry_set_text (GTK_ENTRY (fs->selection_entry), fs->saved_entry);
g_free (fs->saved_entry);
fs->saved_entry = NULL;
}
return FALSE;
}
static void
gtk_file_selection_home_button (GtkWidget * widget, gpointer data)
{
GList *list;
GtkFileSelection *fs = data;
list = fs->next_history;
if (list)
{
g_free (list->data);
list = list->next;
}
g_list_free (fs->next_history);
fs->next_history = NULL;
gtk_file_selection_populate (fs, "~/", FALSE);
}
static void
gtk_file_selection_up_button (GtkWidget * widget, gpointer data)
{
GtkFileSelection *fs = data;
GList *list;
g_return_if_fail (fs != NULL);
g_return_if_fail (GTK_IS_FILE_SELECTION (fs));
list = fs->next_history;
if (list)
{
g_free (list->data);
list = list->next;
}
g_list_free (fs->next_history);
fs->next_history = NULL;
gtk_file_selection_populate (fs, "../", FALSE); /*change directories. */
}
static void
gtk_file_selection_prev_button (GtkWidget * widget, gpointer data)
{
GtkFileSelection *fs = data;
GList *list;
GList *first;
gchar *path;
g_return_if_fail (fs != NULL);
g_return_if_fail (GTK_IS_FILE_SELECTION (fs));
list = fs->prev_history;
if (list && g_list_length (list) > 1)
{
first = list; /* get first element */
list = list->next; /* pop off current directory */
list->prev = NULL; /* make this the new head. */
fs->prev_history = list; /* update prev_history list */
fs->next_history = g_list_prepend (fs->next_history, first->data); /* put it on next_history */
first->next = NULL; /* orphan the old first node */
g_list_free (first); /* free the node (data is now in use by next_history) */
path = g_malloc (strlen (list->data) + 4); /* plenty of space */
strcpy (path, list->data); /* get the 2nd path in the history */
strcat (path, "/"); /* append a '/' */
gtk_file_selection_populate (fs, path, FALSE); /* change directories. */
g_free (path);
}
}
static void
gtk_file_selection_next_button (GtkWidget * widget, gpointer data)
{
GtkFileSelection *fs = data;
GList *list;
GList *first;
gchar *path;
g_return_if_fail (fs != NULL);
g_return_if_fail (GTK_IS_FILE_SELECTION (fs));
list = fs->next_history;
if (list && g_list_length (list) > 0)
{
first = list; /*get first element */
list = list->next; /*pop off current directory */
if (list)
list->prev = NULL;
fs->next_history = list; /*update prev_history list */
path = g_malloc (strlen (first->data) + 4); /*plenty of space */
strcpy (path, first->data);
strcat (path, "/"); /*append a / */
gtk_file_selection_populate (fs, path, FALSE); /*change directories. */
g_free (path);
first->next = NULL; /* orphan the old first node */
g_list_free (first); /* free the node (data is now in use by next_history) */
}
}
void static
gtk_file_selection_refresh_button (GtkWidget * widget, gpointer data)
{
GtkFileSelection *fs = data;
g_return_if_fail (fs != NULL);
g_return_if_fail (GTK_IS_FILE_SELECTION (fs));
gtk_file_selection_populate (fs, "", FALSE);
}
static void
gtk_file_selection_mask_entry_callback (GtkWidget * widget, gpointer data)
{
GtkFileSelection *fs = data;
if (fs->mask)
g_free (fs->mask);
fs->mask = g_strdup (gtk_entry_get_text (GTK_ENTRY (fs->mask_entry)));
if (strlen (fs->mask) == 0)
{
g_free (fs->mask);
fs->mask = NULL;
}
gtk_file_selection_refresh_button (widget, data);
}
static gboolean
gtk_file_selection_history_combo_list_key_handler (GtkWidget * widget,
GdkEventKey * event,
gpointer user_data)
{
/*
g_print("Key pressed! \n");
*/
return TRUE;
}
static gboolean
gtk_file_selection_history_combo_list_callback (GtkWidget * thelist,
GdkEventButton * event,
gpointer user_data)
{
GtkFileSelection *fs = user_data;
GList *list;
gchar *path;
list = fs->next_history;
if (list)
{
g_free (list->data);
list = list->next;
}
g_list_free (fs->next_history);
fs->next_history = NULL;
path =
g_malloc (strlen
(gtk_entry_get_text
(GTK_ENTRY (((GtkCombo *) fs->history_combo)->entry))) + 4);
strcpy (path,
gtk_entry_get_text (GTK_ENTRY
(((GtkCombo *) fs->history_combo)->entry)));
strcat (path, "/");
gtk_file_selection_populate (fs, path, TRUE);
g_free (path);
return TRUE;
}
static gboolean
gtk_file_selection_history_combo_callback (GtkWidget * widget,
GdkEventKey * event, gpointer data)
{
GtkEntry *entry = (GtkEntry *) widget;
GtkFileSelection *fs = data;
GList *list;
gchar *path;
g_return_val_if_fail (fs != NULL, FALSE);
g_return_val_if_fail (GTK_IS_FILE_SELECTION (fs), FALSE);
if (event->keyval == GDK_Return)
{
list = fs->next_history;
if (list)
{
g_free (list->data);
list = list->next;
}
g_list_free (fs->next_history);
fs->next_history = NULL;
path = g_malloc (strlen (gtk_entry_get_text (entry)) + 4);
strcpy (path, gtk_entry_get_text (entry));
strcat (path, "/");
gtk_file_selection_populate (fs, path, TRUE);
g_free (path);
gtk_signal_emit_stop_by_name (GTK_OBJECT (widget), "key_press_event");
return TRUE;
}
else
{
return FALSE;
}
}
static void
gtk_file_selection_update_history_menu (GtkFileSelection * fs,
gchar * current_directory)
{
gchar *current_dir;
g_return_if_fail (fs != NULL);
g_return_if_fail (GTK_IS_FILE_SELECTION (fs));
g_return_if_fail (current_directory != NULL);
current_dir = g_strdup (current_directory);
if (fs->prev_history)
{
if (strcmp ((fs->prev_history)->data, current_dir))
{ /*if this item isn't on the top of the list */
fs->prev_history =
g_list_prepend (fs->prev_history, g_strdup (current_dir));
}
}
else
{
fs->prev_history =
g_list_prepend (fs->prev_history, g_strdup (current_dir));
}
gtk_combo_set_popdown_strings (GTK_COMBO (fs->history_combo),
fs->prev_history);
g_free (current_dir);
}
static void
gtk_file_selection_file_button (GtkWidget * widget,
gint row,
gint column,
GdkEventButton * bevent, gpointer user_data)
{
GtkFileSelection *fs = NULL;
gchar *filename, *temp = NULL;
g_return_if_fail (GTK_IS_CLIST (widget));
fs = user_data;
g_return_if_fail (fs != NULL);
g_return_if_fail (GTK_IS_FILE_SELECTION (fs));
(void)gtk_clist_get_text (GTK_CLIST (fs->file_list), row, 0, &temp);
filename = g_strdup (temp);
if (filename)
{
if (bevent)
switch (bevent->type)
{
case GDK_2BUTTON_PRESS:
gtk_button_clicked (GTK_BUTTON (fs->ok_button));
break;
default:
gtk_entry_set_text (GTK_ENTRY (fs->selection_entry), filename);
break;
}
else
gtk_entry_set_text (GTK_ENTRY (fs->selection_entry), filename);
g_free (filename);
}
}
static void
gtk_file_selection_dir_button (GtkWidget * widget,
gint row,
gint column,
GdkEventButton * bevent, gpointer user_data)
{
GList *list;
GtkFileSelection *fs = NULL;
gchar *filename, *temp = NULL;
g_return_if_fail (GTK_IS_CLIST (widget));
fs = GTK_FILE_SELECTION (user_data);
g_return_if_fail (fs != NULL);
g_return_if_fail (GTK_IS_FILE_SELECTION (fs));
(void)gtk_clist_get_text (GTK_CLIST (fs->dir_list), row, 0, &temp);
filename = g_strdup (temp);
if (filename)
{
if (bevent)
switch (bevent->type)
{
case GDK_2BUTTON_PRESS:
list = fs->next_history;
if (list)
{
g_free (list->data);
list = list->next;
}
g_list_free (fs->next_history);
fs->next_history = NULL;
gtk_file_selection_populate (fs, filename, FALSE);
if (fs->saved_entry)
{ /* might be NULL --MK30.12.2001 */
gtk_entry_set_text (GTK_ENTRY (fs->selection_entry),
fs->saved_entry);
g_free (fs->saved_entry);
fs->saved_entry = NULL;
}
break;
default:
/* here we need to add the "filename" to the beginning of what's already
in the entry. Save what's in the entry, then restore it on the double click
*/
if (fs->saved_entry)
g_free (fs->saved_entry);
fs->saved_entry =
g_strdup (gtk_entry_get_text (GTK_ENTRY (fs->selection_entry)));
temp = g_strconcat (filename, fs->saved_entry, NULL);
gtk_entry_set_text (GTK_ENTRY (fs->selection_entry), temp);
g_free (temp);
break;
}
else
gtk_entry_set_text (GTK_ENTRY (fs->selection_entry), filename);
g_free (filename);
}
}
static void
gtk_file_selection_undir_button (GtkWidget * widget,
gint row,
gint column,
GdkEventButton * bevent, gpointer user_data)
{
GtkFileSelection *fs = NULL;
gchar *filename, *temp = NULL;
g_return_if_fail (GTK_IS_CLIST (widget));
fs = GTK_FILE_SELECTION (user_data);
g_return_if_fail (fs != NULL);
g_return_if_fail (GTK_IS_FILE_SELECTION (fs));
(void)gtk_clist_get_text (GTK_CLIST (fs->dir_list), row, 0, &temp);
filename = g_strdup (temp);
if (filename)
{
if (bevent)
switch (bevent->type)
{
default:
/* here we need to add the "filename" to the beginning of what's already
in the entry. Save what's in the entry, then restore it on the double click
*/
if (fs->saved_entry)
{
gtk_entry_set_text (GTK_ENTRY (fs->selection_entry),
fs->saved_entry);
g_free (fs->saved_entry);
fs->saved_entry = NULL;
}
break;
}
else
gtk_entry_set_text (GTK_ENTRY (fs->selection_entry), filename); //?????
g_free (filename);
}
}
static void
gtk_file_selection_populate (GtkFileSelection * fs,
gchar * rel_path, gint try_complete)
{
CompletionState *cmpl_state;
PossibleCompletion *poss;
gchar *filename;
gint row;
gchar *rem_path = rel_path;
gchar *sel_text;
gchar *text[2];
gint did_recurse = FALSE;
gint possible_count = 0;
gint selection_index = -1;
gint file_list_width;
gint dir_list_width;
g_return_if_fail (fs != NULL);
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);
gtk_clist_freeze (GTK_CLIST (fs->dir_list));
gtk_clist_clear (GTK_CLIST (fs->dir_list));
gtk_clist_freeze (GTK_CLIST (fs->file_list));
gtk_clist_clear (GTK_CLIST (fs->file_list));
/* Set the dir_list to include ./ and ../ */
text[1] = NULL;
text[0] = "./";
row = gtk_clist_append (GTK_CLIST (fs->dir_list), text);
text[0] = "../";
row = gtk_clist_append (GTK_CLIST (fs->dir_list), text);
/*reset the max widths of the lists */
dir_list_width = gdk_string_width (fs->dir_list->style->font, "../");
gtk_clist_set_column_width (GTK_CLIST (fs->dir_list), 0, dir_list_width);
file_list_width = 1;
gtk_clist_set_column_width (GTK_CLIST (fs->file_list), 0, file_list_width);
while (poss)
{
if (cmpl_is_a_completion (poss))
{
possible_count += 1;
filename = cmpl_this_completion (poss);
text[0] = filename;
if (cmpl_is_directory (poss))
{
if (strcmp (filename, "./") != 0 &&
strcmp (filename, "../") != 0)
{
int width = gdk_string_width (fs->dir_list->style->font,
filename);
row = gtk_clist_append (GTK_CLIST (fs->dir_list), text);
if (width > dir_list_width)
{
dir_list_width = width;
gtk_clist_set_column_width (GTK_CLIST (fs->dir_list), 0,
width);
}
}
}
else
{
if (fs->mask)
{
if (gtk_file_selection_match_mask (filename, fs->mask))
{
int width =
gdk_string_width (fs->file_list->style->font,
filename);
row =
gtk_clist_append (GTK_CLIST (fs->file_list), text);
if (width > file_list_width)
{
file_list_width = width;
gtk_clist_set_column_width (GTK_CLIST
(fs->file_list), 0,
width);
}
}
}
else
{
int width = gdk_string_width (fs->file_list->style->font,
filename);
row = gtk_clist_append (GTK_CLIST (fs->file_list), text);
if (width > file_list_width)
{
file_list_width = width;
gtk_clist_set_column_width (GTK_CLIST (fs->file_list),
0, width);
}
}
}
}
poss = cmpl_next_completion (cmpl_state);
}
gtk_clist_thaw (GTK_CLIST (fs->dir_list));
gtk_clist_thaw (GTK_CLIST (fs->file_list));
/* File lists are set. */
g_assert (cmpl_state->reference_dir);
if (try_complete)
{
/* User is trying to complete filenames, so advance the user's input
* string to the updated_text, which is the common leading substring
* of all possible completions, and if its a directory attempt
* 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);
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 = (gint) ( cmpl_last_valid_char (cmpl_state) -
((gint)strlen (rel_path) - (gint)strlen (rem_path)) );
if (fs->selection_entry)
gtk_entry_set_text (GTK_ENTRY (fs->selection_entry), rem_path);
}
}
else
{
if (fs->selection_entry){}
/* Here we need to take the old filename and keep it! */
/*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);
}
gtk_file_selection_update_history_menu (fs,
cmpl_reference_position
(cmpl_state));
}
}
static void
gtk_file_selection_abort (GtkFileSelection * fs)
{
gchar err_buf[256];
snprintf (err_buf,256, _("Directory unreadable: %s"),
cmpl_strerror (cmpl_errno));
/* BEEP gdk_beep(); */
if (fs->selection_entry)
gtk_label_set_text (GTK_LABEL (fs->selection_text), err_buf);
}
/**********************************************************************/
/* External Interface */
/**********************************************************************/
/* The four completion state selectors
*/
static gchar *
cmpl_updated_text (CompletionState * cmpl_state)
{
return cmpl_state->updated_text;
}
static gint
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 (gchar * text, CompletionState * cmpl_state)
{
static char nothing[2] = "";
if (!cmpl_state_okay (cmpl_state))
{
return nothing;
}
else if (text[0] == '/')
{
strcpy (cmpl_state->updated_text, text);
}
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, '/');
if (slash)
strcat (cmpl_state->updated_text, slash);
}
}
else
{
strcpy (cmpl_state->updated_text, cmpl_state->reference_dir->fullname);
if (strcmp (cmpl_state->reference_dir->fullname, "/") != 0)
strcat (cmpl_state->updated_text, "/");
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 gint
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 getcwd_buf[2 * MAXPATHLEN];
CompletionState *new_state;
new_state = g_new (CompletionState, 1);
/* We don't use getcwd() on SUNOS, because, it does a popen("pwd")
* and, if that wasn't bad enough, hangs in doing so.
*/
#if defined(sun) && !defined(__SVR4)
if (!getwd (getcwd_buf))
#else
if (!getcwd (getcwd_buf, MAXPATHLEN))
#endif
{
/* Oh joy, we can't get the current directory. Um..., we should have
* a root directory, right? Right? (Probably not portable to non-Unix)
*/
strcpy (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 = (gint)MAXPATHLEN;
new_state->the_completion.text = g_new (gchar, MAXPATHLEN);
new_state->the_completion.text_alloc = (gint)MAXPATHLEN;
new_state->user_dir_name_buffer = NULL;
new_state->user_directories = NULL;
new_state->reference_dir = open_dir (getcwd_buf, new_state);
if (!new_state->reference_dir)
{
/* Directories changing from underneath us, grumble */
strcpy (getcwd_buf, "/");
goto tryagain;
}
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)
{
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->fullname);
g_free (dir);
}
static void
free_dir_sent (CompletionDirSent * sent)
{
g_free (sent->name_buffer);
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;
first_slash = strchr (text_to_complete, '/');
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;
}
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 = *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;
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);
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, '/');
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;
}
}
else if (text_to_complete[0] == '/' || !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, '/');
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 *curdir = g_get_current_dir ();
new_dir = open_dir (curdir, cmpl_state);
if (new_dir)
*remaining_text = text_to_complete;
g_free (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;
}
/* open a directory by user name */
static CompletionDir *
open_user_dir (gchar * text_to_complete, CompletionState * cmpl_state)
{
gchar *first_slash;
gint cmp_len;
g_assert (text_to_complete && text_to_complete[0] == '~');
first_slash = strchr (text_to_complete, '/');
if (first_slash)
cmp_len = first_slash - text_to_complete - 1;
else
cmp_len = (gint)strlen (text_to_complete + 1);
if (!cmp_len)
{
/* ~/ */
gchar *homedir = g_get_home_dir ();
if (homedir)
return open_dir (homedir, cmpl_state);
else
return NULL;
}
else
{
/* ~user/ */
char *copy = g_new (char, cmp_len + 1);
struct passwd *pwd;
strncpy (copy, text_to_complete + 1, (size_t)cmp_len);
copy[cmp_len] = 0;
pwd = getpwnam (copy);
g_free (copy);
if (!pwd)
{
cmpl_errno = errno;
return NULL;
}
return open_dir (pwd->pw_dir, cmpl_state);
}
}
/* open a directory relative the the current relative directory */
static CompletionDir *
open_relative_dir (gchar * dir_name,
CompletionDir * dir, CompletionState * cmpl_state)
{
gchar path_buf[2 * MAXPATHLEN];
if (dir->fullname_len + strlen (dir_name) + 2 >= MAXPATHLEN)
{
cmpl_errno = CMPL_ERRNO_TOO_LONG;
return NULL;
}
strcpy (path_buf, dir->fullname);
if (dir->fullname_len > 1)
{
path_buf[dir->fullname_len] = '/';
strcpy (path_buf + dir->fullname_len + 1, dir_name);
}
else
{
strcpy (path_buf + dir->fullname_len, dir_name);
}
return open_dir (path_buf, cmpl_state);
}
/* 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;
DIR *directory;
gchar *buffer_ptr;
struct dirent *dirent_ptr;
gint buffer_size = 0;
gint entry_count = 0;
gint i;
struct stat ent_sbuf;
char path_buf[MAXPATHLEN * 2];
gint path_buf_len;
sent = g_new (CompletionDirSent, 1);
sent->mtime = sbuf->st_mtime;
sent->inode = sbuf->st_ino;
sent->device = sbuf->st_dev;
path_buf_len = (gint)strlen (dir_name);
if (path_buf_len > (gint)MAXPATHLEN)
{
cmpl_errno = CMPL_ERRNO_TOO_LONG;
return NULL;
}
strcpy (path_buf, dir_name);
directory = opendir (dir_name);
if (!directory)
{
cmpl_errno = errno;
return NULL;
}
while ((dirent_ptr = readdir (directory)) != NULL)
{
int entry_len = (int)strlen (dirent_ptr->d_name);
buffer_size += entry_len + 1;
entry_count += 1;
if (path_buf_len + entry_len + 2 >= (int)MAXPATHLEN)
{
cmpl_errno = CMPL_ERRNO_TOO_LONG;
closedir (directory);
return NULL;
}
}
sent->name_buffer = g_new (gchar, buffer_size);
sent->entries = g_new (CompletionDirEntry, entry_count);
sent->entry_count = entry_count;
buffer_ptr = sent->name_buffer;
rewinddir (directory);
for (i = 0; i < entry_count; i += 1)
{
dirent_ptr = readdir (directory);
if (!dirent_ptr)
{
cmpl_errno = errno;
closedir (directory);
return NULL;
}
strcpy (buffer_ptr, dirent_ptr->d_name);
sent->entries[i].entry_name = buffer_ptr;
buffer_ptr += strlen (dirent_ptr->d_name);
*buffer_ptr = 0;
buffer_ptr += 1;
path_buf[path_buf_len] = '/';
strcpy (path_buf + path_buf_len + 1, dirent_ptr->d_name);
if (stat_subdirs)
{
if (stat (path_buf, &ent_sbuf) >= 0 && S_ISDIR (ent_sbuf.st_mode))
sent->entries[i].is_dir = 1;
else
/* stat may fail, and we don't mind, since it could be a
* dangling symlink. */
sent->entries[i].is_dir = 0;
}
else
sent->entries[i].is_dir = 1;
}
qsort (sent->entries, (size_t)sent->entry_count, sizeof (CompletionDirEntry),
compare_cmpl_dir);
closedir (directory);
return sent;
}
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;
}
/*@ignore@ splint does not like the incomplete initializer, but it is OK */
no_stat_dirs[] =
{
{
"/afs", FALSE,
{
0}
}
,
{
"/net", FALSE,
{
0}
}
};
/*@end@ splint should resume checking here */
static const gint n_no_stat_dirs = (int)
( sizeof (no_stat_dirs) / sizeof (no_stat_dirs[0]));
static gboolean initialized = FALSE;
gint i;
if (!initialized)
{
initialized = TRUE;
for (i = 0; i < n_no_stat_dirs; i++)
{
if (stat (no_stat_dirs[i].name, &no_stat_dirs[i].statbuf) == 0)
no_stat_dirs[i].present = TRUE;
}
}
if (stat (dir_name, result) < 0)
{
cmpl_errno = errno;
return FALSE;
}
*stat_subdirs = TRUE;
for (i = 0; i < n_no_stat_dirs; i++)
{
if (no_stat_dirs[i].present &&
(no_stat_dirs[i].statbuf.st_dev == result->st_dev) &&
(no_stat_dirs[i].statbuf.st_ino == result->st_ino))
{
*stat_subdirs = FALSE;
break;
}
}
return TRUE;
}
/* 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 (!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;
}
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 = (gint)strlen (dir_name);
return new_dir;
}
static gint
correct_dir_fullname (CompletionDir * cmpl_dir)
{
gint length = (gint)strlen (cmpl_dir->fullname);
struct stat sbuf;
if (strcmp (cmpl_dir->fullname + length - 2, "/.") == 0)
{
if (length == 2)
{
strcpy (cmpl_dir->fullname, "/");
cmpl_dir->fullname_len = 1;
return TRUE;
}
else
{
cmpl_dir->fullname[length - 2] = 0;
}
}
else if (strcmp (cmpl_dir->fullname + length - 3, "/./") == 0)
cmpl_dir->fullname[length - 2] = 0;
else if (strcmp (cmpl_dir->fullname + length - 3, "/..") == 0)
{
if (length == 3)
{
strcpy (cmpl_dir->fullname, "/");
cmpl_dir->fullname_len = 1;
return TRUE;
}
if (stat (cmpl_dir->fullname, &sbuf) < 0)
{
cmpl_errno = errno;
return FALSE;
}
cmpl_dir->fullname[length - 2] = 0;
if (!correct_parent (cmpl_dir, &sbuf))
return FALSE;
}
else if (strcmp (cmpl_dir->fullname + length - 4, "/../") == 0)
{
if (length == 4)
{
strcpy (cmpl_dir->fullname, "/");
cmpl_dir->fullname_len = 1;
return TRUE;
}
if (stat (cmpl_dir->fullname, &sbuf) < 0)
{
cmpl_errno = errno;
return FALSE;
}
cmpl_dir->fullname[length - 3] = 0;
if (!correct_parent (cmpl_dir, &sbuf))
return FALSE;
}
cmpl_dir->fullname_len = (gint)strlen (cmpl_dir->fullname);
return TRUE;
}
static gint
correct_parent (CompletionDir * cmpl_dir, struct stat *sbuf)
{
struct stat parbuf;
gchar *last_slash;
gchar *new_name;
gchar c = 0;
last_slash = strrchr (cmpl_dir->fullname, '/');
g_assert (last_slash);
if (last_slash != cmpl_dir->fullname)
{ /* last_slash[0] = 0; */
}
else
{
c = last_slash[1];
last_slash[1] = 0;
}
if (stat (cmpl_dir->fullname, &parbuf) < 0)
{
cmpl_errno = errno;
return FALSE;
}
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] = '/'; */
/* 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;
return TRUE;
}
static gchar *
find_parent_dir_fullname (gchar * dirname)
{
gchar buffer[MAXPATHLEN];
gchar buffer2[MAXPATHLEN];
#if defined(sun) && !defined(__SVR4)
if (!getwd (buffer))
#else
if (!getcwd (buffer, MAXPATHLEN))
#endif
{
cmpl_errno = errno;
return NULL;
}
if (chdir (dirname) != 0 || chdir ("..") != 0)
{
cmpl_errno = errno;
return NULL;
}
#if defined(sun) && !defined(__SVR4)
if (!getwd (buffer2))
#else
if (!getcwd (buffer2, MAXPATHLEN))
#endif
{
chdir (buffer);
cmpl_errno = errno;
return NULL;
}
if (chdir (buffer) != 0)
{
cmpl_errno = errno;
return NULL;
}
return g_strdup (buffer2);
}
/**********************************************************************/
/* Completion Operations */
/**********************************************************************/
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 = (gint) (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 = 1;
(void)append_completion_text ("~", cmpl_state);
(void)append_completion_text (cmpl_state->user_directories
[cmpl_state->user_completion_index].login,
cmpl_state);
return append_completion_text ("/", 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 = 1;
return append_completion_text ("~/", cmpl_state);
}
}
/* 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 && *text == *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 = (int) (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, (gulong)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, '/');
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, (size_t)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_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 = (gint)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,
(gulong)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, '/');
if (first_slash)
{
gint len = first_slash - dir->cmpl_text;
pat_buf = g_new (gchar, len + 1);
strncpy (pat_buf, dir->cmpl_text, (size_t)len);
pat_buf[len] = 0;
}
else
{
gint len = (gint)strlen (dir->cmpl_text);
pat_buf = g_new (gchar, len + 2);
strcpy (pat_buf, dir->cmpl_text);
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 = 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)
{
(void)append_completion_text (dir->fullname +
strlen (cmpl_state->completion_dir->
fullname) + 1, cmpl_state);
(void)append_completion_text ("/", cmpl_state);
}
(void)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)
(void)append_completion_text ("/", cmpl_state);
g_free (pat_buf);
return &cmpl_state->the_completion;
}
}
static gint
get_pwdb (CompletionState * cmpl_state)
{
struct passwd *pwd_ptr;
gchar *buf_ptr;
gint len = 0, i, count = 0;
if (cmpl_state->user_dir_name_buffer)
return TRUE;
/*@i@*/ setpwent ();
/*@i@*/ while ((pwd_ptr = getpwent ()) != NULL)
{
len += strlen (pwd_ptr->pw_name);
len += strlen (pwd_ptr->pw_dir);
len += 2;
count += 1;
}
/*@i@*/ 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;
}
strcpy (buf_ptr, pwd_ptr->pw_name);
cmpl_state->user_directories[i].login = buf_ptr;
buf_ptr += strlen (buf_ptr);
buf_ptr += 1;
strcpy (buf_ptr, pwd_ptr->pw_dir);
cmpl_state->user_directories[i].homedir = buf_ptr;
buf_ptr += strlen (buf_ptr);
buf_ptr += 1;
}
qsort (cmpl_state->user_directories,
(size_t)cmpl_state->user_directories_len,
sizeof (CompletionUserDir), compare_user_dir);
/*@i@*/ 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);
}
static gint
compare_cmpl_dir (const void *a, const void *b)
{
return strcmp ((((CompletionDirEntry *) a))->entry_name,
(((CompletionDirEntry *) b))->entry_name);
}
static gint
cmpl_state_okay (CompletionState * cmpl_state)
{
return cmpl_state && cmpl_state->reference_dir;
}
static gchar *
cmpl_strerror (gint err)
{
if (err == CMPL_ERRNO_TOO_LONG)
return "Name too long";
else
return g_strerror (err);
}
/* Testing area */
#ifdef TORRIE_DEBUG
/* Get the selected filename and print it to the console */
void
file_ok_sel (GtkWidget * w, GtkFileSelection * fs)
{
g_print ("%s\n", gtk_file_selection_get_filename (GTK_FILE_SELECTION (fs)));
}
void
destroy (GtkWidget * widget, gpointer data)
{
gtk_main_quit ();
}
int
main (int argc, char *argv[])
{
GtkWidget *filew;
gtk_init (&argc, &argv);
/* Create a new file selection widget */
filew = gtk_file_selection_new ("Michael's Glorious File Selector");
// gtk_file_selection_complete(GTK_FILE_SELECTION(filew),"bob");
(void)gtk_signal_connect (GTK_OBJECT (filew), "destroy",
(GtkSignalFunc) destroy, &filew);
/* Connect the ok_button to file_ok_sel function */
(void)gtk_signal_connect (GTK_OBJECT (GTK_FILE_SELECTION (filew)->ok_button),
"clicked", (GtkSignalFunc) file_ok_sel, filew);
/* Connect the cancel_button to destroy the widget */
(void)gtk_signal_connect_object (GTK_OBJECT (GTK_FILE_SELECTION
(filew)->cancel_button),
"clicked", (GtkSignalFunc) gtk_widget_destroy,
GTK_OBJECT (filew));
gtk_widget_show (filew);
/*
g_print("%d",gtk_file_selection_match_mask("mask.c","m*.c"));
g_print("%d",gtk_file_selection_match_mask("mask.c","m???.c"));
g_print("%d",gtk_file_selection_match_mask("mask.c","m??*.c"));
g_print("%d",gtk_file_selection_match_mask("mask.cout","m*.c"));
g_print("%d",gtk_file_selection_match_mask("mask.cout","m*.c???"));
g_print("%d",gtk_file_selection_match_mask("mask.cout","m*.c*"));
g_print("%d",gtk_file_selection_match_mask("mask.cout","n*.c???"));
g_print("%d",gtk_file_selection_match_mask("mask.c","[mn]*"));
g_print("%d",gtk_file_selection_match_mask("COPYING","*.xpm"));
*/
gtk_main ();
return 0;
}
/* example-end */
#endif
syntax highlighted by Code2HTML, v. 0.9.1