gtkradiant/radiant/gtkfilesel-linux.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 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/. 
 */
#define LEO

#ifdef LEO
#define _(a) a

static char * back_xpm[] = {
"14 14 33 1",
" 	c None",
".	c #000000",
"+	c #C6D7C6",
"@	c #E7EBE7",
"#	c #FFFFFF",
"$	c #DEEBDE",
"%	c #F7F7F7",
"&	c #DEE7DE",
"*	c #EFF3EF",
"=	c #101810",
"-	c #B5C7AD",
";	c #EFEFEF",
">	c #D6E3D6",
",	c #213021",
"'	c #315931",
")	c #52824A",
"!	c #739A6B",
"~	c #84A673",
"{	c #7BA673",
"]	c #84AA73",
"^	c #84AA7B",
"/	c #84AE7B",
"(	c #63925A",
"_	c #526D4A",
":	c #4A7D42",
"<	c #739E6B",
"[	c #739A63",
"}	c #4A7539",
"|	c #638E52",
"1	c #427139",
"2	c #6BA663",
"3	c #5A8A52",
"4	c #315929",
"            ..",
"          ..+.",
"        ..@#+.",
"      ..$#%%+.",
"    ..&#%*%%+.",
"  .=&#******+.",
"..-#;>&@****+,",
"..')!~{]^/^/(.",
"  .._:<^~^/^(.",
"    ..':[]~/(.",
"      ..}:[~|.",
"        ..123.",
"          ..4.",
"            .."};

static char * up_xpm[] = {
"14 14 36 1",
" 	c None",
".	c #000000",
"+	c #181C18",
"@	c #D6DBD6",
"#	c #94AA8C",
"$	c #000400",
"%	c #DEDFDE",
"&	c #94AA84",
"*	c #E7E3E7",
"=	c #94B28C",
"-	c #6B865A",
";	c #EFEBEF",
">	c #9CB694",
",	c #8CA684",
"'	c #EFEFEF",
")	c #F7EFF7",
"!	c #9CB68C",
"~	c #63865A",
"{	c #94B684",
"]	c #94AE84",
"^	c #739263",
"/	c #F7F3F7",
"(	c #94B284",
"_	c #849E73",
":	c #8CAE7B",
"<	c #8CAA84",
"[	c #7B966B",
"}	c #8CA67B",
"|	c #DEDBD6",
"1	c #E7E7E7",
"2	c #8CAE84",
"3	c #8CAA7B",
"4	c #738E63",
"5	c #BDBEB5",
"6	c #BDC3BD",
"7	c #637D52",
"      ..      ",
"      ..      ",
"     +@#$     ",
"     .%&.     ",
"    .**=-.    ",
"    .;;>,.    ",
"   .*')!&~.   ",
"   .;)){]^.   ",
"  .*')/(]_-.  ",
"  .;)//::<[.  ",
" .*')//:::}-. ",
" .|1;;12]3}4. ",
".556666^^^^-7.",
".............."};

static char * forward_xpm[] = {
"14 14 36 1",
" 	c None",
".	c #000000",
"+	c #E7EBDE",
"@	c #FFFFFF",
"#	c #F7F7EF",
"$	c #D6E3D6",
"%	c #F7F7F7",
"&	c #EFF3EF",
"*	c #CEDFCE",
"=	c #CEDBC6",
"-	c #E7EFE7",
";	c #181818",
">	c #292829",
",	c #E7EBE7",
"'	c #DEE7DE",
")	c #B5C7AD",
"!	c #9CBA94",
"~	c #8CAE84",
"{	c #84AA7B",
"]	c #7BA673",
"^	c #84A67B",
"/	c #739A6B",
"(	c #5A824A",
"_	c #395931",
":	c #9CBA8C",
"<	c #84AE7B",
"[	c #739E6B",
"}	c #527D4A",
"|	c #425942",
"1	c #84A673",
"2	c #4A7142",
"3	c #94B284",
"4	c #395D31",
"5	c #5A8652",
"6	c #315929",
"7	c #396531",
"..            ",
".+..          ",
".@#$..        ",
".@%&#*..      ",
".@%%&&%=..    ",
".@&&&&&-#=;.  ",
">@&&&&,'$'&)..",
".!~{~{{]^/(_..",
".:{<{^{[}|..  ",
".:<1{/}2..    ",
".31/}4..      ",
".{56..        ",
".7..          ",
"..            "};

static char * refresh_xpm[] = {
"16 16 11 1",
" 	c None",
".	c #000000",
"+	c #526942",
"@	c #4A6139",
"#	c #526542",
"$	c #5A7142",
"%	c #425531",
"&	c #314529",
"*	c #425131",
"=	c #425931",
"-	c #5A754A",
"       .        ",
"      ..        ",
"     .+@...     ",
"    .#$##@%..   ",
"     .+#...%%.  ",
"   .  ..   .&.  ",
"  .    .    .&. ",
" ..          .. ",
" ..          .. ",
" .*.    .    .  ",
"  .*.   ..  .   ",
"  .%@...#=.     ",
"   ..##-#@#.    ",
"     ...@%.     ",
"        ..      ",
"        .       "};

#endif

#ifndef LEO
#include "config.h"
#endif

#include <fcntl.h>
#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 <grp.h>
#include <time.h>

#include "fnmatch.h"

#if (defined TORRIE_DEBUG || defined LEO)
#include <gdk/gdkkeysyms.h>
#include <gtk/gtkbutton.h>
#include <gtk/gtkentry.h>
#include "gtkfilesel-linux.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/gtkhpaned.h>
#include <gtk/gtktable.h>
#include <gtk/gtkpixmap.h>
#include <gtk/gtknotebook.h>
#include <gtk/gtkhseparator.h>
#include <gtk/gtktogglebutton.h>
#else
#include "gdk/gdkkeysyms.h"
#include "gtkbutton.h"
#include "gtkentry.h"
#include "gtkfilesel.h"
#include "gtkhbox.h"
#include "gtkhbbox.h"
#include "gtklabel.h"
#include "gtklist.h"
#include "gtklistitem.h"
#include "gtkmain.h"
#include "gtkscrolledwindow.h"
#include "gtksignal.h"
#include "gtkvbox.h"
#include "gtkmenu.h"
#include "gtkmenuitem.h"
#include "gtkoptionmenu.h"
#include "gtkclist.h"
#include "gtkdialog.h"
#include "gtkcombo.h"
#include "gtkframe.h"
#include "gtkhpaned.h"
#include "gtktable.h"
#include "gtkpixmap.h"
#include "gtknotebook.h"
#include "gtkhseparator.h"
#include "gtktogglebutton.h"
#endif

#ifndef LEO
#include "gtkintl.h"

#include "back.xpm"
#include "up.xpm"
#include "forward.xpm"
#include "refresh.xpm"
#endif

#define DIR_LIST_WIDTH   180
#define DIR_LIST_HEIGHT  180
#define FILE_LIST_WIDTH  180
#define FILE_LIST_HEIGHT 180
#define BOOKMARK_FILE "/.gtkfilesel_bookmarks"
#define MASK_FILE "/.gtkfilesel_masks"
#define TIME_STRING_BUF 50

/* 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 _BookmarkMenuStruct BookmarkMenuStruct;
struct _BookmarkMenuStruct {
  GtkWidget *menu_item;
  gchar     *desc;
  gchar     *path;
};

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;
};

/* Widgets from the Properties Dialog */
typedef struct _PropertiesPrivate PropertiesPrivate;

struct _PropertiesPrivate
{
  GtkWidget *mode_label;
  GtkWidget *mode_buttons[12];
};

/* pixmap creation function */
GtkWidget*                 create_pixmap          (GtkWidget *widget, 
						   const gchar *pixmap_char);

/* 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_realize       (GtkWidget             *widget);
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 (gpointer data);
static void gtk_file_selection_delete_file (gpointer data);
static void gtk_file_selection_rename_file (gpointer data);
static void gtk_file_selection_properties (gpointer data);
static void gtk_file_selection_properties_update_mode (GtkWidget *widget, gpointer data);
static mode_t gtk_file_selection_properties_get_mode (PropertiesPrivate* private);

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_bookmark_callback (GtkWidget *widget, gpointer data);
static void gtk_file_selection_mask_entry_callback (GtkWidget *widget, gpointer data);
static gint gtk_file_selection_mask_entry_key_callback (GtkWidget *widget, GdkEventKey *event, gpointer data);
static gint gtk_file_selection_mask_entry_button_callback (GtkWidget *widget, GdkEventButton *event, gpointer data);

//static void gtk_file_selection_home_button (GtkWidget *widget, gpointer data);
static void gtk_file_selection_bookmark_button (GtkWidget *widget, 
	      	                   GtkFileSelection *fs);

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_files_list_key_callback (GtkWidget *widget, GdkEventKey *event, gpointer data);


static gint gtk_file_selection_match_char (gchar, gchar *mask);
static gint gtk_file_selection_match_mask (gchar *,gchar *);

static void gtk_file_selection_load_bookmarks(GtkFileSelection *fs);
static void gtk_file_selection_add_bookmark (GtkFileSelection *fs, gchar *desc, gchar *path);
gint gtk_file_selection_save_bookmarks (GtkFileSelection *fs);

static void gtk_file_selection_load_masks(GtkFileSelection *fs);

static gint gtk_file_selection_show_fileop_menu (GtkCList *clist, 
						 GdkEvent *event, 
						 GtkFileSelection *fs);

						 
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.
 */
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

/* 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                       *
 *                                                *
 */
static gint gtk_file_selection_match_char (gchar text, gchar *mask)
{
  gchar *maskc;
  gint x;
  gint s;
  gchar lastc;
  gchar nextc;

  if (mask[0] == '[')
    {
      if (!strchr (mask,']')) return 0;
      lastc = 0;

      maskc = g_strdup(mask + 1); /* get the portion of mask inside []*/
      (*(strchr (maskc + 1,']'))) = 0;
      s = strlen ((char *)maskc);

      for (x = 0 ; x < s ; x ++){
        if (maskc[x] == '-')
          {
            if (x == s) return 1;
            nextc = maskc[x + 1];

            if (nextc > lastc)
            {
              if ((lastc <= text) && (nextc >= text))
              {
                g_free (maskc);
                return s + 2;
              }
            }
            else if ((lastc >= text) && (nextc <= text))
              {
                g_free (maskc);
                return s + 2;
              }
          }
        else if (text == maskc[x])
          {
            g_free (maskc);
            return s + 2;
          }
        lastc = maskc[x];
      }
      g_free (maskc);

      return 0;
    }

  if (mask[0] == '?') return 1;
  if (mask[0] == text) return 1;

  return 0;
}


static gint gtk_file_selection_match_mask1 (gchar *text, gchar *mask)
{

  int mc;
  int tc;

  tc = 0; mc = 0;
	
  if (mask[0] == 0 && text[0] == 0) return 1;
	
  if (mask[0] == '*')
    {
      for (tc = 0; tc <= strlen(text); tc++)
	{
	  if (gtk_file_selection_match_mask1 (text + tc, mask + 1))
	    return 1;
	}
      return 0;
    }
  mc = gtk_file_selection_match_char (text[0], mask);

  if(mc)
    return gtk_file_selection_match_mask1 (text + 1, mask + mc);
  else
    return 0;
}

static gint gtk_file_selection_match_mask (gchar *text, gchar *mask)
{
  gchar *masks;
  gchar *bmask;
  gchar *emask;

  masks=g_strdup(mask);

  emask=strchr(masks,'<');
  if(emask){
    bmask=emask+1;
    emask=strchr(bmask,'>');
    if(emask){
      *emask=0;
    }
  }else{
    bmask=masks;
  }

  do{
    if((emask=strchr(bmask,',')) || (emask=strchr(bmask,';'))){
      *emask=0;
      if (gtk_file_selection_match_mask1 (text, bmask)){
      	g_free(masks);
	return 1;
      }

      bmask=emask+1;
    }
  }while(emask);

  if(gtk_file_selection_match_mask1 (text, bmask)){
    g_free(masks);
    return 1;
  }
  g_free(masks);
  return 0;
}

static void
gtk_file_selection_load_bookmarks(GtkFileSelection *fs)
{
  GList *list;
  gchar *bookmark_file;
  gchar *bookmark_data;
  struct stat file_info;
  gint   file;
  gint   lp;
  gint   cp;
  BookmarkMenuStruct *item;


  if(fs->bookmark_list){  //erase
    list=fs->bookmark_list;
    while(list){
      item=list->data;
      g_free(item->desc);
      g_free(item->path);
      g_free(item);
      list=list->next;
    }
    g_list_free (fs->bookmark_list);
    fs->bookmark_list = NULL;
    gtk_widget_destroy (fs->bookmark_menu);
  }

  fs->bookmark_menu=gtk_menu_new();

  /* spacer */
  item=g_malloc(sizeof(item));
  item->menu_item = gtk_menu_item_new();
  gtk_widget_show(item->menu_item);
  gtk_menu_append (GTK_MENU(fs->bookmark_menu), item->menu_item);

  item=g_malloc(sizeof(item));
  item->desc=g_strdup("Add bookmark");
  item->path=g_strdup(".");
  item->menu_item=gtk_menu_item_new_with_label (item->desc);
  gtk_widget_show(item->menu_item);
  //fs->bookmark_list=g_list_append(fs->bookmark_list,item);
  //set signal here!!
  gtk_menu_append (GTK_MENU(fs->bookmark_menu), item->menu_item);

  item=g_malloc(sizeof(item));
  item->desc=g_strdup("Edit bookmark");
  item->path=g_strdup(".");
  item->menu_item=gtk_menu_item_new_with_label (item->desc);
  gtk_widget_show(item->menu_item);
  //fs->bookmark_list=g_list_append(fs->bookmark_list,item);
  //set signal here!!
  gtk_menu_append (GTK_MENU(fs->bookmark_menu), item->menu_item);

  bookmark_file=g_strconcat(g_get_home_dir(), BOOKMARK_FILE ,NULL);
  if(!stat(bookmark_file,&file_info) && (file = open(bookmark_file,  O_RDONLY )) > 0)
  {
    if(file_info.st_size <65536 )
    {
      bookmark_data=g_malloc(file_info.st_size);

      if(file && read(file, bookmark_data, file_info.st_size))
      {
        cp=lp=0;

        while (cp < file_info.st_size)
        {
          while (cp < file_info.st_size && bookmark_data[cp] != '<' )
            cp++;
	  bookmark_data[cp]=0;
	  item=g_malloc(sizeof(BookmarkMenuStruct));
	  item->desc=g_strdup(bookmark_data+lp);
	  lp=++cp;
	  
          while (cp < file_info.st_size && bookmark_data[cp] != '>' )
            cp++;

          bookmark_data[cp]=0;
          //create menu items
	  item->path=g_strdup(bookmark_data+lp);
	  gtk_file_selection_add_bookmark ((gpointer) fs, (gpointer) item->desc, (gpointer) item->path);

	  cp++;

          while(cp < file_info.st_size && bookmark_data[cp] < 33 )
            cp++;
          lp=cp;
        }
      }

      close(file);
    }
  } else {

    /* Add some default items, then save off to bookmarks file */

    gtk_file_selection_add_bookmark ((gpointer) fs, "Home", "~/");
    gtk_file_selection_add_bookmark ((gpointer) fs, "Root", "/");

    gtk_file_selection_save_bookmarks ((gpointer) fs);
  }
}

static void 
gtk_file_selection_add_bookmark (GtkFileSelection *fs, gchar *desc, gchar *path) 
{
  /* Add item to menu */
  BookmarkMenuStruct *item;
  item=g_malloc(sizeof(item));
  item->desc = (gpointer) desc;
  item->path = (gpointer) path;
  item->menu_item=gtk_menu_item_new_with_label (item->desc);
  gtk_widget_show(item->menu_item);
  fs->bookmark_list=g_list_append(fs->bookmark_list,item);
  gtk_signal_connect (GTK_OBJECT(item->menu_item), "activate",
		      (GtkSignalFunc) gtk_file_selection_bookmark_callback,
		      (gpointer) fs);
  gtk_menu_insert (GTK_MENU(fs->bookmark_menu), item->menu_item, g_list_length(fs->bookmark_list) -1);
}

gint 
gtk_file_selection_save_bookmarks (GtkFileSelection *fs)
{
  BookmarkMenuStruct *item;
  gchar *bookmark_file;
  gchar *item_data;
  gint   file;
  GList *list;

  bookmark_file=g_strconcat(g_get_home_dir(), BOOKMARK_FILE ,NULL);

  if ((file = open(bookmark_file, O_CREAT | O_WRONLY | O_TRUNC, 0600)) > 0)
  {
    for (list = g_list_first (fs->bookmark_list); list != NULL; list = g_list_next(list)) {
      item = list->data;
      item_data = g_strconcat(item->desc, " <", item->path, ">\n", NULL);
      if (write (file, item_data, strlen(item_data)) != strlen(item_data)) {
	return TRUE;
      }
      g_free(item_data);
    }
    
    close(file);
  } else {
    return TRUE;
  }

  return FALSE;
}

static void
gtk_file_selection_load_masks(GtkFileSelection *fs)
{
  /*
  GList *list;
  gchar *masks_file;
  gchar *masks_data;
  struct stat file_info;
  gint   file;
  gint   lp;
  gint   cp;

  if(fs->masks){
    list=fs->masks;
    while(list){
      g_free(list->data);
      list=list->next;
    }
    fs->masks = NULL;
  }

  masks_file=g_strconcat(g_get_home_dir(), MASK_FILE,NULL); //put in #define
  if(!stat(masks_file,&file_info))
  {
    if(file_info.st_size <65536 )
    {
      masks_data=g_malloc(file_info.st_size);

      file = open(masks_file,  O_RDONLY );

      if(file && read(file, masks_data, file_info.st_size))
      {
        cp=lp=0;

        while (cp < file_info.st_size)
        {
          while (cp < file_info.st_size && masks_data[cp] != '>' )
            cp++;

          masks_data[++cp]=0;
          if (masks_data[lp]=='<') { //if there was no description, strip off brackets
            lp++;
            masks_data[cp-1]=0;
          }
//          g_print("%s\n",masks_data+lp);
          fs->masks = g_list_append(fs->masks, g_strdup(masks_data+lp));

          while(cp < file_info.st_size && masks_data[cp] < 33 )
            cp++;
          lp=cp;
        }
      }

      close(file);
    }
  }
  */
  if (!fs->masks) {
    /* masks is still null, fill it with default data... */
    /*
    fs->masks = g_list_append(fs->masks, "all files <*>");
    fs->masks = g_list_append(fs->masks, "mp3s/playlists <*.mp3,*.m3u>");
    fs->masks = g_list_append(fs->masks, "src/hdr <*.[CcHh],*.[Cc][Cc],*.[Hh][Hh],*.cpp>");
    fs->masks = g_list_append(fs->masks, "html docs <*.html,*.htm,*.HTM,*.php*,*.inc>");
    fs->masks = g_list_append(fs->masks, "images <*.png,*.jpg,*.jpeg,*.gif,*.xpm,*.tiff>");
    fs->masks = g_list_append(fs->masks, "package <*.rpm,*.deb>");
    fs->masks = g_list_append(fs->masks, "archive <*.tgz,*.tb2,*.tar*,*.zip,*.rar>");
    fs->masks = g_list_append(fs->masks, "compressed <*.Z,*.gz,*.bz2>");
    */
  }
}

void gtk_file_selection_clear_masks (GtkFileSelection *filesel)
{
  GList *list;

  g_return_if_fail (filesel != NULL);
  g_return_if_fail (GTK_IS_FILE_SELECTION (filesel));

  list = filesel->masks;
  while (list)
    {
      g_free (list->data);
      list = list->next;
    }
  filesel->masks = NULL;

  gtk_list_clear_items (GTK_LIST (GTK_COMBO (filesel->mask_entry)->list), 0, -1);
}

void gtk_file_selection_set_masks (GtkFileSelection *filesel, const gchar **masks)
{
  g_return_if_fail (filesel != NULL);
  g_return_if_fail (GTK_IS_FILE_SELECTION (filesel));

  while (*masks)
    {
      filesel->masks = g_list_append (filesel->masks, (gpointer)*masks);
      masks++;
    }

  if (filesel->masks)
    gtk_combo_set_popdown_strings (GTK_COMBO (filesel->mask_entry), filesel->masks);
}

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_WINDOW, &filesel_info);
    }

  return file_selection_type;
}

static void
gtk_file_selection_class_init (GtkFileSelectionClass *class)
{
  GtkObjectClass *object_class;
  GtkWidgetClass *widget_class;

  object_class = (GtkObjectClass*) class;

  parent_class = gtk_type_class (GTK_TYPE_WINDOW);

  widget_class = GTK_WIDGET_CLASS (class);

  widget_class->realize = gtk_file_selection_realize;
  object_class->destroy = gtk_file_selection_destroy;
}

static void
gtk_file_selection_init (GtkFileSelection *filesel)
{
  GtkWidget *entry_vbox;
  GtkWidget *label;
  GtkWidget *list_vbox;
  GtkWidget *confirm_area;
  GtkWidget *vbox;
  GtkWidget *hbox;
  GtkWidget *hbox2;
  GtkWidget *table;
  GtkWidget *pulldown_hbox;
  GtkWidget *scrolled_win;
  GtkWidget *mask_label;
  GtkWidget *bigframe;
  GtkWidget *button;
  GtkWidget *hpaned;
  GtkWidget *menu_item;
  GtkWidget *pixmap;

  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;
  filesel->bookmark_list=NULL;
  filesel->masks=NULL;
  filesel->selection_text = NULL;
  filesel->fileop_data = NULL;

  gtk_file_selection_load_masks(filesel);
  gtk_file_selection_load_bookmarks(filesel);

  /* The dialog-sized vertical box  */
  filesel->main_vbox = gtk_vbox_new (FALSE, 0);
  gtk_container_set_border_width (GTK_CONTAINER (filesel), 0);
  gtk_container_add (GTK_CONTAINER (filesel), filesel->main_vbox);
  gtk_widget_show (filesel->main_vbox);

  /* hbox for pulldown menu */
  pulldown_hbox = gtk_hbox_new (FALSE, 0);
  gtk_box_pack_start (GTK_BOX (filesel->main_vbox), pulldown_hbox, FALSE, FALSE, 0);
  gtk_widget_show (pulldown_hbox);
  
  /* 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 (pulldown_hbox), filesel->button_area,
		      FALSE, FALSE, 0);
  gtk_button_box_set_child_size(GTK_BUTTON_BOX(filesel->button_area),0,0);
  gtk_button_box_set_child_ipadding(GTK_BUTTON_BOX(filesel->button_area),0,0);
  */

  filesel->button_area = gtk_hbox_new (TRUE,0);
  //gtk_box_pack_start (GTK_BOX (pulldown_hbox), filesel->button_area,
  //		      FALSE, FALSE, 0);

  //gtk_widget_show (filesel->button_area);

  gtk_file_selection_show_fileop_buttons(filesel);
  /*  frame to put the following hbox in  */
  bigframe = gtk_frame_new (NULL);
  gtk_box_pack_start (GTK_BOX (filesel->main_vbox), bigframe, TRUE, TRUE, 0);
  gtk_frame_set_shadow_type (GTK_FRAME (bigframe), GTK_SHADOW_OUT);
  gtk_widget_show (bigframe);


  list_vbox = gtk_vbox_new (FALSE,3);
  gtk_widget_show(list_vbox);
  gtk_container_add (GTK_CONTAINER(bigframe), list_vbox);
  gtk_container_set_border_width (GTK_CONTAINER (list_vbox),2);
  gtk_widget_show (list_vbox);
  
  /*  The horizontal box containing the directory and file listboxes  */
//  list_hbox = gtk_hbox_new (FALSE, 3);
  //gtk_container_add (GTK_CONTAINER(bigframe), list_hbox);
  //gtk_container_set_border_width (GTK_CONTAINER (list_hbox), 3);
//  gtk_box_pack_start(GTK_BOX(list_vbox), list_hbox, FALSE,FALSE,0);
//  gtk_widget_show (list_hbox);

  hpaned=gtk_hpaned_new();
  gtk_widget_show(hpaned);
  gtk_container_set_border_width (GTK_CONTAINER (hpaned), 1);
  gtk_paned_set_gutter_size (GTK_PANED (hpaned), 10);
  gtk_box_pack_start (GTK_BOX(list_vbox), hpaned,TRUE,TRUE,0);

  /* vbox to put the buttons and directory listing in  */
  vbox = gtk_vbox_new (FALSE, 3);
  gtk_widget_show (vbox);
  gtk_container_add(GTK_CONTAINER(hpaned),vbox);
  //gtk_box_pack_start (GTK_BOX (hpaned), vbox, FALSE, FALSE, 0);

  hbox = gtk_hbox_new (FALSE, 4);
  gtk_widget_show (hbox);
  gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0);

//  home_button = gtk_button_new_with_label (_("Home"));
//  gtk_widget_show (home_button);
//  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);

  /* Here we add the bookmark menu button */
  #define If we're going to make bookmark a menu, we don't need 
  #define   to keep it in the filesel structure
  button=gtk_button_new_with_label(_("Bookmarks"));
  gtk_widget_show(button);
  gtk_box_pack_start (GTK_BOX(hbox), button, FALSE,FALSE,0);
  gtk_signal_connect (GTK_OBJECT (button), "clicked",
		      (GtkSignalFunc) gtk_file_selection_bookmark_button,
		      (gpointer) filesel);
  
  hbox2 = gtk_hbox_new (FALSE, 2);
  gtk_box_pack_start (GTK_BOX (hbox), hbox2, FALSE, FALSE, 0);
  gtk_widget_show(hbox2);

  /* Prev button */
  button = gtk_button_new ();
  gtk_signal_connect (GTK_OBJECT (button), "clicked",
		      (GtkSignalFunc) gtk_file_selection_prev_button,
		      (gpointer) filesel);
  gtk_widget_show (button);
  gtk_box_pack_start (GTK_BOX (hbox2), button, FALSE,FALSE, 0);
  pixmap = create_pixmap (filesel->main_vbox, (gpointer) back_xpm);
  gtk_widget_show (pixmap);
  gtk_container_add (GTK_CONTAINER (button), pixmap);

  /* Up button */
  button = gtk_button_new ();
  gtk_signal_connect (GTK_OBJECT (button), "clicked",
		      (GtkSignalFunc) gtk_file_selection_up_button,
		      (gpointer) filesel);
  gtk_widget_show (button);
  gtk_box_pack_start (GTK_BOX (hbox2), button, FALSE,FALSE, 0);
  pixmap = create_pixmap (filesel->main_vbox, (gpointer) up_xpm);
  gtk_widget_show (pixmap);
  gtk_container_add (GTK_CONTAINER (button), pixmap);

  /* next button */
  button = gtk_button_new ();
  gtk_widget_show (button);
  gtk_signal_connect (GTK_OBJECT (button), "clicked",
		      (GtkSignalFunc) gtk_file_selection_next_button,
		      (gpointer) filesel);
  gtk_box_pack_start (GTK_BOX (hbox2), button, FALSE,FALSE, 0);
  pixmap = create_pixmap (filesel->main_vbox, (gpointer) forward_xpm);
  gtk_widget_show (pixmap);
  gtk_container_add (GTK_CONTAINER (button), pixmap);

  /* refresh button */
  button = gtk_button_new ();
  gtk_widget_show (button);
  gtk_signal_connect (GTK_OBJECT (button), "clicked",
		      (GtkSignalFunc) gtk_file_selection_refresh_button,
		      (gpointer) filesel);
  gtk_box_pack_end (GTK_BOX (hbox), button, FALSE,FALSE, 0);
  pixmap = create_pixmap (filesel->main_vbox, (gpointer) refresh_xpm);
  gtk_widget_show (pixmap);
  gtk_container_add (GTK_CONTAINER (button), pixmap);

  /* menu for right click file operations */
  filesel->fileop_menu = gtk_menu_new();
  
  menu_item = gtk_menu_item_new_with_label ("Rename...");
  gtk_widget_show(menu_item);
  gtk_signal_connect_object (GTK_OBJECT (menu_item), "activate",
			     (GtkSignalFunc) gtk_file_selection_rename_file,
			     (gpointer) filesel);
  gtk_menu_append (GTK_MENU (filesel->fileop_menu), menu_item);

  menu_item = gtk_menu_item_new_with_label ("Delete");
  gtk_widget_show(menu_item);
  gtk_menu_append (GTK_MENU (filesel->fileop_menu), menu_item);
  gtk_signal_connect_object (GTK_OBJECT (menu_item), "activate",
			     (GtkSignalFunc) gtk_file_selection_delete_file,
			     (gpointer) filesel);

  menu_item = gtk_menu_item_new ();
  gtk_widget_show(menu_item);
  gtk_menu_append (GTK_MENU (filesel->fileop_menu), menu_item);

  menu_item = gtk_menu_item_new_with_label ("Create Directory...");
  gtk_signal_connect_object (GTK_OBJECT (menu_item), "activate",
			     (GtkSignalFunc) gtk_file_selection_create_dir, 
			     (gpointer) filesel);
  gtk_widget_show(menu_item);
  gtk_menu_append (GTK_MENU (filesel->fileop_menu), menu_item);

  menu_item = gtk_menu_item_new ();
  gtk_menu_append (GTK_MENU (filesel->fileop_menu), menu_item);
  gtk_widget_show(menu_item);

  menu_item = gtk_menu_item_new_with_label ("Properties...");
  gtk_signal_connect_object (GTK_OBJECT (menu_item), "activate",
			     (GtkSignalFunc) gtk_file_selection_properties,
			     (gpointer) filesel);
  gtk_menu_append (GTK_MENU (filesel->fileop_menu), menu_item);
  gtk_widget_show(menu_item);

  /* The directories clist */
  dir_title[0] = _("Directories");
  dir_title[1] = NULL;
  filesel->dir_list = gtk_clist_new_with_titles (1, (gchar**) dir_title);
  gtk_widget_set_usize (filesel->dir_list, DIR_LIST_WIDTH, DIR_LIST_HEIGHT);
  gtk_signal_connect (GTK_OBJECT (filesel->dir_list), "select_row",
		      (GtkSignalFunc) gtk_file_selection_dir_button,
		      (gpointer) filesel);
  gtk_signal_connect (GTK_OBJECT (filesel->dir_list), "unselect_row",
		      (GtkSignalFunc) gtk_file_selection_undir_button,
		      (gpointer) filesel);
  gtk_signal_connect (GTK_OBJECT (filesel->dir_list), "button_press_event",
		      GTK_SIGNAL_FUNC(gtk_file_selection_show_fileop_menu), 
		      (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_AUTOMATIC);
  gtk_box_pack_start (GTK_BOX (vbox), scrolled_win, TRUE,TRUE, 0);
  //gtk_container_add(GTK_CONTAINER(hpaned), scrolled_win);
  
  gtk_widget_show (filesel->dir_list);
  gtk_widget_show (scrolled_win);

  vbox = gtk_vbox_new (FALSE, 3);
  gtk_widget_show (vbox);
  gtk_container_add(GTK_CONTAINER(hpaned),vbox);
  /* vbox area for mask entry and files clist  */

  hbox = gtk_hbox_new (FALSE, 2);
  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, 2);

/*
  filesel->mask_entry = gtk_entry_new ();
  gtk_widget_show (filesel->mask_entry);
  gtk_signal_connect(GTK_OBJECT(filesel->mask_entry),"activate",
		     (GtkSignalFunc) gtk_file_4_mask_entry_callback,
		     (gpointer) filesel);
  gtk_box_pack_start (GTK_BOX (hbox),filesel->mask_entry, TRUE, TRUE, 0);
  */

  filesel->mask_entry = gtk_combo_new ();
  gtk_widget_show (filesel->mask_entry);
  gtk_combo_set_value_in_list(GTK_COMBO(filesel->mask_entry),FALSE,FALSE);
  gtk_signal_connect(GTK_OBJECT(GTK_COMBO(filesel->mask_entry)->entry),"activate",
		     (GtkSignalFunc) gtk_file_selection_mask_entry_callback,
		     (gpointer) filesel);
  gtk_signal_connect(GTK_OBJECT(((GtkCombo *)filesel->mask_entry)->entry),"key-press-event",				
		     (GtkSignalFunc) gtk_file_selection_mask_entry_key_callback,
		     (gpointer) filesel);

  gtk_signal_connect(GTK_OBJECT(((GtkCombo *)filesel->mask_entry)->list),"button-release-event",
		     (GtkSignalFunc) gtk_file_selection_mask_entry_button_callback,
		     (gpointer) filesel);
  gtk_box_pack_start (GTK_BOX (hbox),filesel->mask_entry, TRUE, TRUE, 0);

  if (filesel->masks)
    gtk_combo_set_popdown_strings (GTK_COMBO (filesel->mask_entry), filesel->masks);


  /* The files clist */
  file_title[0] = _("Files");
  file_title[1] = NULL;
  filesel->file_list = gtk_clist_new_with_titles (1, (gchar**) file_title);
  gtk_widget_set_usize (filesel->file_list, FILE_LIST_WIDTH, FILE_LIST_HEIGHT);
  gtk_signal_connect (GTK_OBJECT (filesel->file_list), "select_row",
		      (GtkSignalFunc) gtk_file_selection_file_button, 
		      (gpointer) filesel);
  gtk_signal_connect (GTK_OBJECT (filesel->file_list), "key-press-event",
		      (GtkSignalFunc) gtk_file_selection_files_list_key_callback,
		      (gpointer) filesel);
  
  gtk_signal_connect (GTK_OBJECT (filesel->file_list), "button_press_event",
		      GTK_SIGNAL_FUNC(gtk_file_selection_show_fileop_menu), 
		      (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_AUTOMATIC);
  gtk_box_pack_start (GTK_BOX (vbox), scrolled_win, TRUE, TRUE, 0);
  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, 2);
  gtk_widget_show (filesel->action_area);

  /*
  hbox=gtk_hbox_new(FALSE,0);
  gtk_box_pack_end (GTK_BOX (filesel->main_vbox), hbox, FALSE,FALSE, 0);
  gtk_widget_show (hbox);
  */

  /*  The selection entry widget  */
  
  entry_vbox = gtk_vbox_new (FALSE, 0);
  gtk_box_pack_end (GTK_BOX (filesel->main_vbox), entry_vbox, FALSE, FALSE, 0);
  gtk_widget_show (entry_vbox);

  table = gtk_table_new ( 2, 2, FALSE );
  gtk_box_pack_start (GTK_BOX (entry_vbox), table, TRUE, TRUE, 0);
  gtk_container_set_border_width (GTK_CONTAINER (table), 4);
  gtk_table_set_row_spacings (GTK_TABLE (table), 2);
  gtk_table_set_col_spacings (GTK_TABLE (table), 4);


  label = gtk_label_new (_("Selection:"));
  gtk_table_attach (GTK_TABLE (table), label, 0, 1, 0, 1,
                    (GtkAttachOptions) (0),
                    (GtkAttachOptions) (0), 0, 0);
  gtk_widget_show (label);


  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_table_attach (GTK_TABLE (table), filesel->selection_entry, 1, 2, 0, 1,
                    (GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
                    (GtkAttachOptions) (0), 0, 0);
  gtk_widget_show (filesel->selection_entry);


  label = gtk_label_new (_("Directory:"));
  gtk_table_attach (GTK_TABLE (table), label, 0, 1, 1, 2,
                    (GtkAttachOptions) (0),
                    (GtkAttachOptions) (0), 0, 0);
  gtk_widget_show (label);
  

  filesel->history_combo = gtk_combo_new();
  gtk_combo_set_value_in_list(GTK_COMBO(filesel->history_combo),FALSE,FALSE);
  gtk_table_attach (GTK_TABLE (table), filesel->history_combo, 1, 2, 1, 2,
                    (GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
                    (GtkAttachOptions) (0), 0, 0);
  gtk_widget_show(filesel->history_combo);

  gtk_signal_connect(GTK_OBJECT(((GtkCombo *)filesel->history_combo)->entry),"key-press-event",				    
		     (GtkSignalFunc) gtk_file_selection_history_combo_callback,
		     (gpointer) filesel);

  gtk_signal_connect(GTK_OBJECT(((GtkCombo *)filesel->history_combo)->list),"button-press-event",
		     (GtkSignalFunc) gtk_file_selection_history_combo_list_callback,
		     (gpointer) filesel);

  gtk_signal_connect(GTK_OBJECT(((GtkCombo *)filesel->history_combo)->list),"key-press-event",
		     (GtkSignalFunc) gtk_file_selection_history_combo_list_key_handler,
		     (gpointer) filesel);

  filesel->selection_text = NULL;


  /*  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 (entry_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_signal_connect_object (GTK_OBJECT (filesel->selection_entry), "focus_in_event",
			     (GtkSignalFunc) gtk_widget_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_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);

  gtk_widget_show(table);


  /*
  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);
  */


  if (!cmpl_state_okay (filesel->cmpl_state))
    {
      gchar err_buf[256];

      sprintf (err_buf, _("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);
  /* !!! put check here to figure out if screen > 640x480, if true
     We need to make the file selection dialog bigger. much bigger.. 
     or maybe we should keep it at a certan percentage of the screen
     size? */

  gtk_window_set_default_size(GTK_WINDOW (filesel), 520, 420);
  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));

  return;
	
  /* delete, create directory, and rename */
/*
  if (!filesel->fileop_c_dir) 
    {
      filesel->fileop_c_dir = gtk_button_new_with_label (_("MkDir"));
      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"));
      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"));
      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));
  
  return;
  /*
  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 (MAXPATHLEN - 1, last_slash - filename + 1);

      strncpy (buf, filename, 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=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_realize (GtkWidget *widget)
{
  GtkFileSelection *filesel;
  const gchar *masks[] = { "All Files <*>", NULL };

  g_return_if_fail (widget != NULL);
  g_return_if_fail (GTK_IS_FILE_SELECTION (widget));

  filesel = GTK_FILE_SELECTION (widget);

  /* make sure that we have at least one mask */
  if (!filesel->masks)
    gtk_file_selection_set_masks (filesel, masks);

  filesel->mask = g_strdup ((gchar*) filesel->masks->data);
  gtk_file_selection_populate (filesel, "", FALSE);


  if (GTK_WIDGET_CLASS (parent_class)->realize)
    (* GTK_WIDGET_CLASS (parent_class)->realize) (widget);
}

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 gint
gtk_file_selection_show_fileop_menu (GtkCList *clist, GdkEvent *event, GtkFileSelection *fs)
{
  GdkEventButton *event_button;

  g_return_val_if_fail (clist != NULL, FALSE);
  g_return_val_if_fail (GTK_IS_CLIST (clist), FALSE);
  g_return_val_if_fail (event != NULL, FALSE);
  g_return_val_if_fail (fs != NULL, FALSE);
  g_return_val_if_fail (GTK_FILE_SELECTION (fs), FALSE);
  
  if (event->type == GDK_BUTTON_PRESS)
    {
      event_button = (GdkEventButton *) event;
      if (event_button->button == 3)
	{

	  gtk_menu_popup (GTK_MENU (fs->fileop_menu), NULL, NULL, NULL, NULL, 
			  event_button->button, event_button->time);
	  return TRUE;
	}
    }
  
  return FALSE;
}

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"));
  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;
  g_free (fs->fileop_data);
  fs->fileop_data = 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 (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 ();
  gtk_signal_connect (GTK_OBJECT (dialog), "destroy",
		      (GtkSignalFunc) gtk_file_selection_fileop_destroy, 
		      (gpointer) fs);
  gtk_window_set_title (GTK_WINDOW (dialog), _("Create Directory"));
  gtk_window_set_position (GTK_WINDOW (dialog), GTK_WIN_POS_MOUSE);

  /* If file dialog is grabbed, grab option dialog */
  /* When option dialog is closed, file dialog will be grabbed again */
  if (GTK_WINDOW(fs)->modal)
      gtk_window_set_modal (GTK_WINDOW(dialog), TRUE);

  vbox = gtk_vbox_new(FALSE, 0);
  gtk_container_set_border_width(GTK_CONTAINER(vbox), 8);
  gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->vbox), vbox,
		     FALSE, FALSE, 0);
  gtk_widget_show(vbox);
  
  label = gtk_label_new(_("Directory name:"));
  gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.0);
  gtk_box_pack_start(GTK_BOX(vbox), label, FALSE, FALSE, 5);
  gtk_widget_show(label);

  /*  The directory entry widget  */
  fs->fileop_entry = gtk_entry_new ();
  gtk_box_pack_start (GTK_BOX (vbox), fs->fileop_entry, 
		      TRUE, TRUE, 5);
  GTK_WIDGET_SET_FLAGS(fs->fileop_entry, GTK_CAN_DEFAULT);
  gtk_widget_show (fs->fileop_entry);
  
  /* buttons */
  button = gtk_button_new_with_label (_("Create"));
  gtk_signal_connect (GTK_OBJECT (button), "clicked",
		      (GtkSignalFunc) gtk_file_selection_create_dir_confirmed, 
		      (gpointer) fs);
  gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->action_area),
		     button, TRUE, TRUE, 0);
  GTK_WIDGET_SET_FLAGS(button, GTK_CAN_DEFAULT);
  gtk_widget_show(button);
  
  button = gtk_button_new_with_label (_("Cancel"));
  gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
			     (GtkSignalFunc) gtk_widget_destroy, 
			     (gpointer) dialog);
  gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->action_area),
		     button, TRUE, TRUE, 0);
  GTK_WIDGET_SET_FLAGS(button, GTK_CAN_DEFAULT);
  gtk_widget_grab_default(button);
  gtk_widget_show (button);

  gtk_widget_show (dialog);
}

static 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 (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 ();
  gtk_signal_connect (GTK_OBJECT (dialog), "destroy",
		      (GtkSignalFunc) gtk_file_selection_fileop_destroy, 
		      (gpointer) fs);
  gtk_window_set_title (GTK_WINDOW (dialog), _("Delete File"));
  gtk_window_set_position (GTK_WINDOW (dialog), GTK_WIN_POS_MOUSE);

  /* If file dialog is grabbed, grab option dialog */
  /* When option dialog is closed, file dialog will be grabbed again */
  if (GTK_WINDOW(fs)->modal)
      gtk_window_set_modal (GTK_WINDOW(dialog), TRUE);
  
  vbox = gtk_vbox_new(FALSE, 0);
  gtk_container_set_border_width(GTK_CONTAINER(vbox), 8);
  gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->vbox), vbox,
		     FALSE, FALSE, 0);
  gtk_widget_show(vbox);

  buf = g_strconcat ("Really delete file \"", filename, "\" ?", NULL);
  label = gtk_label_new(buf);
  gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.0);
  gtk_box_pack_start(GTK_BOX(vbox), label, FALSE, FALSE, 5);
  gtk_widget_show(label);
  g_free(buf);
  
  /* buttons */
  button = gtk_button_new_with_label (_("Delete"));
  gtk_signal_connect (GTK_OBJECT (button), "clicked",
		      (GtkSignalFunc) gtk_file_selection_delete_file_confirmed, 
		      (gpointer) fs);
  gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->action_area),
		     button, TRUE, TRUE, 0);
  GTK_WIDGET_SET_FLAGS(button, GTK_CAN_DEFAULT);
  gtk_widget_show(button);
  
  button = gtk_button_new_with_label (_("Cancel"));
  gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
			     (GtkSignalFunc) gtk_widget_destroy, 
			     (gpointer) dialog);
  gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->action_area),
		     button, TRUE, TRUE, 0);
  GTK_WIDGET_SET_FLAGS(button, GTK_CAN_DEFAULT);
  gtk_widget_grab_default(button);
  gtk_widget_show (button);

  gtk_widget_show (dialog);

}

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 (strcmp (new_filename, old_filename))
    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_file_mode_confirmed (GtkWidget *widget, gpointer data)
{
  GtkFileSelection *fs = data;
  PropertiesPrivate *priv = fs->fileop_data;
  CompletionState *cmpl_state;
  gchar *filename, *file, *path;
  mode_t mode;

  mode = gtk_file_selection_properties_get_mode (priv);

  file = gtk_entry_get_text (GTK_ENTRY (fs->fileop_entry));
  cmpl_state = (CompletionState*) fs->cmpl_state;
  path = cmpl_reference_position (cmpl_state);

  filename = g_strconcat (path, "/", file, NULL);
  if (chmod (filename, mode) == -1)
    {
      gchar *buf = g_strconcat ("Error changing file mode of \"", filename, "\":  ", 
                                g_strerror (errno), NULL);
      gtk_file_selection_fileop_error (fs, buf);
      gtk_widget_destroy (fs->fileop_dialog);
      gtk_file_selection_populate (fs, "", FALSE);
    }
  else
    gtk_file_selection_rename_file_confirmed (widget, data);

  g_free (filename);
}

static void
gtk_file_selection_rename_file (gpointer data)
{
  GtkFileSelection *fs = data;
  GtkWidget *label;
  GtkWidget *dialog;
  GtkWidget *vbox;
  GtkWidget *button;
  gchar *buf;
  
  g_return_if_fail (fs != NULL);
  g_return_if_fail (GTK_IS_FILE_SELECTION (fs));

  if (fs->fileop_dialog)
	  return;

  fs->fileop_file = gtk_entry_get_text (GTK_ENTRY (fs->selection_entry));
  if (strlen(fs->fileop_file) < 1)
	  return;
  
  /* main dialog */
  fs->fileop_dialog = dialog = gtk_dialog_new ();
  gtk_signal_connect (GTK_OBJECT (dialog), "destroy",
		      (GtkSignalFunc) gtk_file_selection_fileop_destroy, 
		      (gpointer) fs);
  gtk_window_set_title (GTK_WINDOW (dialog), _("Rename File"));
  gtk_window_set_position (GTK_WINDOW (dialog), GTK_WIN_POS_MOUSE);

  /* If file dialog is grabbed, grab option dialog */
  /* When option dialog  closed, file dialog will be grabbed again */
  if (GTK_WINDOW(fs)->modal)
    gtk_window_set_modal (GTK_WINDOW(dialog), TRUE);
  
  vbox = gtk_vbox_new(FALSE, 0);
  gtk_container_set_border_width (GTK_CONTAINER(vbox), 8);
  gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->vbox), vbox,
		     FALSE, FALSE, 0);
  gtk_widget_show(vbox);
  
  buf = g_strconcat ("Rename file \"", fs->fileop_file, "\" to:", NULL);
  label = gtk_label_new(buf);
  gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.0);
  gtk_box_pack_start(GTK_BOX(vbox), label, FALSE, FALSE, 5);
  gtk_widget_show(label);
  g_free(buf);

  /* New filename entry */
  fs->fileop_entry = gtk_entry_new ();
  gtk_box_pack_start (GTK_BOX (vbox), fs->fileop_entry, 
		      TRUE, TRUE, 5);
  GTK_WIDGET_SET_FLAGS(fs->fileop_entry, GTK_CAN_DEFAULT);
  gtk_widget_show (fs->fileop_entry);
  
  gtk_entry_set_text (GTK_ENTRY (fs->fileop_entry), fs->fileop_file);
  gtk_editable_select_region (GTK_EDITABLE (fs->fileop_entry),
			      0, strlen (fs->fileop_file));

  /* buttons */
  button = gtk_button_new_with_label (_("Rename"));
  gtk_signal_connect (GTK_OBJECT (button), "clicked",
		      (GtkSignalFunc) gtk_file_selection_rename_file_confirmed, 
		      (gpointer) fs);
  gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->action_area),
		     button, TRUE, TRUE, 0);
  GTK_WIDGET_SET_FLAGS(button, GTK_CAN_DEFAULT);
  gtk_widget_show(button);
  
  button = gtk_button_new_with_label (_("Cancel"));
  gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
			     (GtkSignalFunc) gtk_widget_destroy, 
			     (gpointer) dialog);
  gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->action_area),
		     button, TRUE, TRUE, 0);
  GTK_WIDGET_SET_FLAGS(button, GTK_CAN_DEFAULT);
  gtk_widget_grab_default(button);
  gtk_widget_show (button);

  gtk_widget_show (dialog);
}

static mode_t
gtk_file_selection_properties_get_mode (PropertiesPrivate* priv)
{
  mode_t mode = 0;

  if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (priv->mode_buttons[0])))
    mode |= S_IRUSR;
  if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (priv->mode_buttons[1])))
    mode |= S_IWUSR;
  if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (priv->mode_buttons[2])))
    mode |= S_IXUSR;
  if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (priv->mode_buttons[3])))
    mode |= S_ISUID;
  if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (priv->mode_buttons[4])))
    mode |= S_IRGRP;
  if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (priv->mode_buttons[5])))
    mode |= S_IWGRP;
  if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (priv->mode_buttons[6])))
    mode |= S_IXGRP;
  if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (priv->mode_buttons[7])))
    mode |= S_ISGID;
  if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (priv->mode_buttons[8])))
    mode |= S_IROTH;
  if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (priv->mode_buttons[9])))
    mode |= S_IWOTH;
  if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (priv->mode_buttons[10])))
    mode |= S_IXOTH;
  if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (priv->mode_buttons[11])))
    mode |= S_ISVTX;

  return mode;
}

static void
gtk_file_selection_properties_update_mode (GtkWidget *widget, gpointer data)
{
  GtkFileSelection *fs = data;
  PropertiesPrivate *priv = fs->fileop_data;
  gchar str[8];

  sprintf (str, "(%.4o)", gtk_file_selection_properties_get_mode (priv));
  gtk_label_set (GTK_LABEL (priv->mode_label), str);
}

static void
gtk_file_selection_properties (gpointer data)
{
  GtkFileSelection *fs = data;
  GtkWidget *label;
  GtkWidget *dialog;
  GtkWidget *vbox;
  GtkWidget *hbox;
  GtkWidget *button;
  GtkWidget *notebook;
  GtkWidget *table;
  GtkWidget *hseparator;
  GtkWidget *entry;
  GtkWidget *togglebutton;
  struct stat statbuf;
  struct passwd *pw;
  struct group *gp;
  gchar *buf;
  gchar *path;
  gchar *filename;
  gchar timeBuf[TIME_STRING_BUF];
  gint pagenum = 0;
  PropertiesPrivate *priv;
  int i;

  g_return_if_fail (fs != NULL);
  g_return_if_fail (GTK_IS_FILE_SELECTION (fs));

  if (fs->fileop_dialog)
	  return;
  
  /* main dialog */
  fs->fileop_dialog = dialog = gtk_dialog_new ();
  gtk_signal_connect (GTK_OBJECT (dialog), "destroy",
		      (GtkSignalFunc) gtk_file_selection_fileop_destroy, 
		      (gpointer) fs);
  priv = fs->fileop_data = g_malloc (sizeof (PropertiesPrivate));

  gtk_window_set_title (GTK_WINDOW (dialog), ("Properties"));
  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);
  
  /* Dialog guts go here */
  notebook = gtk_notebook_new ();
  gtk_widget_show (notebook);
  gtk_box_pack_start (GTK_BOX (GTK_DIALOG(dialog)->vbox), notebook, TRUE, TRUE, 0);
  gtk_container_set_border_width (GTK_CONTAINER (notebook), 8);

  path = cmpl_reference_position(fs->cmpl_state);
  fs->fileop_file = gtk_entry_get_text (GTK_ENTRY (fs->selection_entry));
  filename = g_strconcat(path, "/", fs->fileop_file, NULL);
  if (strlen(fs->fileop_file) > 0 && !(stat(filename, &statbuf))) 
  {
    /* stats page */
    table = gtk_table_new (9, 2, FALSE);
    gtk_widget_show (table);
    gtk_container_add (GTK_CONTAINER (notebook), table);
    gtk_container_set_border_width (GTK_CONTAINER (table), 5);
    gtk_table_set_row_spacings (GTK_TABLE (table), 4);
    gtk_table_set_col_spacings (GTK_TABLE (table), 6);
    
    label = gtk_label_new (_("Statistics"));
    gtk_widget_show (label);
    gtk_notebook_set_tab_label (GTK_NOTEBOOK (notebook), gtk_notebook_get_nth_page (GTK_NOTEBOOK (notebook), pagenum), label);
    pagenum++;
    /* path and filename */
    label = gtk_label_new (_("Path:"));
    gtk_widget_show (label);
    gtk_table_attach (GTK_TABLE (table), label, 0, 1, 0, 1,
		      (GtkAttachOptions) (GTK_FILL),
		      (GtkAttachOptions) (0), 0, 0);
    gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
    
    label = gtk_label_new (_(path));
    gtk_widget_show (label);
    gtk_table_attach (GTK_TABLE (table), label, 1, 2, 0, 1,
		      (GtkAttachOptions) (GTK_FILL),
		      (GtkAttachOptions) (0), 0, 0);
    gtk_label_set_justify (GTK_LABEL (label), GTK_JUSTIFY_LEFT);
    gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
    
    label = gtk_label_new (_("File Name:"));
    gtk_widget_show (label);
    gtk_table_attach (GTK_TABLE (table), label, 0, 1, 1, 2,
		      (GtkAttachOptions) (GTK_FILL),
		      (GtkAttachOptions) (0), 0, 0);
    gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
    
    fs->fileop_entry = entry = gtk_entry_new ();
    gtk_widget_show (entry);
    gtk_table_attach (GTK_TABLE (table), entry, 1, 2, 1, 2,
		      (GtkAttachOptions) (GTK_FILL),
		      (GtkAttachOptions) (0), 0, 0);
    gtk_entry_set_text (GTK_ENTRY (entry), fs->fileop_file);
    if (access (filename, W_OK))
      gtk_widget_set_sensitive( GTK_WIDGET (entry), FALSE);
    
    hseparator = gtk_hseparator_new ();
    gtk_widget_show (hseparator);
    gtk_table_attach (GTK_TABLE (table), hseparator, 0, 2, 2, 3,
		      (GtkAttachOptions) (GTK_FILL),
		      (GtkAttachOptions) (GTK_FILL), 0, 0);
    
    /* file type and size */
    label = gtk_label_new (_("Type:"));
    gtk_widget_show (label);
    gtk_table_attach (GTK_TABLE (table), label, 0, 1, 3, 4,
		      (GtkAttachOptions) (GTK_FILL),
		      (GtkAttachOptions) (0), 0, 0);
    gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);

    switch (statbuf.st_mode & S_IFMT)
    {
    case S_IFSOCK:
      buf = g_strdup ("Socket");
      break;
    case S_IFLNK:
      buf = g_strdup ("Symbolic link");
      break;
    case S_IFREG:
      buf = g_strdup ("File");
      break;
    case S_IFBLK:
      buf = g_strdup ("Block device");
      break;
    case S_IFDIR:
      buf = g_strdup ("Directory");
      break;
    case S_IFCHR:
      buf = g_strdup ("Character device");
      break;
    case S_IFIFO:
      buf = g_strdup ("First-in/first-out pipe");
      break;
    default:
      buf = g_strdup ("Unknown");
    }


    label = gtk_label_new (buf);
    gtk_widget_show (label);
    gtk_table_attach (GTK_TABLE (table), label, 1, 2, 3, 4,
		      (GtkAttachOptions) (GTK_FILL),
		      (GtkAttachOptions) (0), 0, 0);
    gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
    
    label = gtk_label_new (_("Size:"));
    gtk_widget_show (label);
    gtk_table_attach (GTK_TABLE (table), label, 0, 1, 4, 5,
		      (GtkAttachOptions) (GTK_FILL),
		      (GtkAttachOptions) (0), 0, 0);
    gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
    
    label = gtk_label_new (_(g_strdup_printf ("%ld bytes", statbuf.st_size)));
    gtk_widget_show (label);
    gtk_table_attach (GTK_TABLE (table), label, 1, 2, 4, 5,
		      (GtkAttachOptions) (GTK_FILL),
		      (GtkAttachOptions) (0), 0, 0);
    gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
    
    hseparator = gtk_hseparator_new ();
    gtk_widget_show (hseparator);
    gtk_table_attach (GTK_TABLE (table), hseparator, 0, 2, 5, 6,
		      (GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
		      (GtkAttachOptions) (GTK_FILL), 0, 0);
    
    /* file dates */
    label = gtk_label_new (_("Created:"));
    gtk_widget_show (label);
    gtk_table_attach (GTK_TABLE (table), label, 0, 1, 6, 7,
		      (GtkAttachOptions) (GTK_FILL),
		      (GtkAttachOptions) (0), 0, 0);
    gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
    
    strftime (timeBuf, TIME_STRING_BUF, "%a %b %d %X %Y", localtime(&statbuf.st_mtime));
    label = gtk_label_new (_(timeBuf));
    gtk_widget_show (label);
    gtk_table_attach (GTK_TABLE (table), label, 1, 2, 6, 7,
		      (GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
		      (GtkAttachOptions) (0), 0, 0);
    gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
    
    
    
    label = gtk_label_new (_("Modified:"));
    gtk_widget_show (label);
    gtk_table_attach (GTK_TABLE (table), label, 0, 1, 7, 8,
		      (GtkAttachOptions) (GTK_FILL),
		      (GtkAttachOptions) (0), 0, 0);
    gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
    
    strftime (timeBuf, TIME_STRING_BUF, "%a %b %d %X %Y", localtime(&statbuf.st_mtime));
    label = gtk_label_new (_(timeBuf));
    gtk_widget_show (label);
    gtk_table_attach (GTK_TABLE (table), label, 1, 2, 7, 8,
		      (GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
		      (GtkAttachOptions) (0), 0, 0);
    gtk_label_set_justify (GTK_LABEL (label), GTK_JUSTIFY_LEFT);
    gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
    
    
    label = gtk_label_new (_("Accessed:"));
    gtk_widget_show (label);
    gtk_table_attach (GTK_TABLE (table), label, 0, 1, 8, 9,
		      (GtkAttachOptions) (GTK_FILL),
		      (GtkAttachOptions) (0), 0, 0);
    gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
    
    strftime (timeBuf, TIME_STRING_BUF, "%a %b %d %X %Y", localtime(&statbuf.st_atime));
    label = gtk_label_new (_(timeBuf));
    gtk_widget_show (label);
    gtk_table_attach (GTK_TABLE (table), label, 1, 2, 8, 9,
		      (GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
		      (GtkAttachOptions) (0), 0, 0);
    gtk_label_set_justify (GTK_LABEL (label), GTK_JUSTIFY_LEFT);
    gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);  
    
    /* permissions page */
    vbox = gtk_vbox_new (FALSE, 4);
    gtk_widget_show (vbox);
    gtk_container_add (GTK_CONTAINER (notebook), vbox);
    gtk_container_set_border_width (GTK_CONTAINER (vbox), 5);
    
    label = gtk_label_new (_("Permissions"));
    gtk_widget_show (label);
    gtk_notebook_set_tab_label (GTK_NOTEBOOK (notebook), gtk_notebook_get_nth_page (GTK_NOTEBOOK (notebook), pagenum), label);
    pagenum++;

    /* owner / group */
    table = gtk_table_new (2, 2, FALSE);
    gtk_widget_show (table);
    gtk_box_pack_start (GTK_BOX (vbox), table, FALSE, TRUE, 0);
    gtk_table_set_row_spacings (GTK_TABLE (table), 2);
    gtk_table_set_col_spacings (GTK_TABLE (table), 8);
    
    label = gtk_label_new (_("Owner:"));
    gtk_widget_show (label);
    gtk_table_attach (GTK_TABLE (table), label, 0, 1, 0, 1,
		      (GtkAttachOptions) (GTK_FILL),
		      (GtkAttachOptions) (0), 0, 0);
    gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);

    entry = gtk_entry_new();
    gtk_widget_show (entry);
    gtk_table_attach (GTK_TABLE (table), entry, 1, 2, 0, 1,
		      (GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
		      (GtkAttachOptions) (0), 0, 0);
    if ((pw = getpwuid(statbuf.st_uid)))
      gtk_entry_set_text(GTK_ENTRY (entry), pw->pw_name);
    else
      gtk_entry_set_text(GTK_ENTRY (entry), (gpointer) statbuf.st_uid);
    if (access (filename, W_OK) || (getuid() != 0))
      gtk_widget_set_sensitive( GTK_WIDGET (entry), FALSE);


    label = gtk_label_new (_("Group:"));
    gtk_widget_show (label);
    gtk_table_attach (GTK_TABLE (table), label, 0, 1, 1, 2,
		      (GtkAttachOptions) (GTK_FILL),
		      (GtkAttachOptions) (0), 0, 0);
    gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
    
    entry = gtk_entry_new();
    gtk_widget_show (entry);
    gtk_table_attach (GTK_TABLE (table), entry, 1, 2, 1, 2,
		      (GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
		      (GtkAttachOptions) (0), 0, 0);
    if ((gp = getgrgid(statbuf.st_gid)))
      gtk_entry_set_text(GTK_ENTRY (entry), gp->gr_name);
    else
      gtk_entry_set_text(GTK_ENTRY (entry), (gpointer) statbuf.st_gid);
    if (access (filename, W_OK) || (getuid() != 0))
      gtk_widget_set_sensitive( GTK_WIDGET (entry), FALSE);

    
    hseparator = gtk_hseparator_new ();
    gtk_widget_show (hseparator);
    gtk_box_pack_start (GTK_BOX (vbox), hseparator, FALSE, TRUE, 0);
    
    /* permissions */
    table = gtk_table_new (4, 5, TRUE);
    gtk_widget_show (table);
    gtk_box_pack_start (GTK_BOX (vbox), table, FALSE, FALSE, 0);
    gtk_table_set_row_spacings (GTK_TABLE (table), 2);
    gtk_table_set_col_spacings (GTK_TABLE (table), 4);
    if (access (filename, W_OK) || ((getuid() != statbuf.st_uid) && getuid() != 0))
      gtk_widget_set_sensitive (GTK_WIDGET (table), FALSE);
    
    hbox = gtk_hbox_new (FALSE, 1);
    gtk_widget_show (hbox);
    gtk_table_attach (GTK_TABLE (table), hbox, 0, 1, 0, 1,
		      (GtkAttachOptions) (GTK_FILL),
		      (GtkAttachOptions) (GTK_FILL), 0, 0);
    
    priv->mode_label = label = gtk_label_new ("(0000)");
    gtk_widget_show (label);
    gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0);

    label = gtk_label_new (_("Read"));
    gtk_widget_show (label);
    gtk_table_attach (GTK_TABLE (table), label, 1, 2, 0, 1,
		      (GtkAttachOptions) (0),
		      (GtkAttachOptions) (0), 0, 0);
    
    label = gtk_label_new (_("Write"));
    gtk_widget_show (label);
    gtk_table_attach (GTK_TABLE (table), label, 2, 3, 0, 1,
		      (GtkAttachOptions) (0),
		      (GtkAttachOptions) (0), 0, 0);
    
    label = gtk_label_new (_("Exec"));
    gtk_widget_show (label);
    gtk_table_attach (GTK_TABLE (table), label, 3, 4, 0, 1,
		      (GtkAttachOptions) (0),
		      (GtkAttachOptions) (0), 0, 0);
    
    label = gtk_label_new (_("Special"));
    gtk_widget_show (label);
    gtk_table_attach (GTK_TABLE (table), label, 4, 5, 0, 1,
		      (GtkAttachOptions) (0),
		      (GtkAttachOptions) (0), 0, 0);
    
    
    label = gtk_label_new (_("User:"));
    gtk_widget_show (label);
    gtk_table_attach (GTK_TABLE (table), label, 0, 1, 1, 2,
		      (GtkAttachOptions) (GTK_FILL),
		      (GtkAttachOptions) (0), 0, 0);
    gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
    
    priv->mode_buttons[0] = togglebutton = gtk_toggle_button_new_with_label ("");
    gtk_widget_show (togglebutton);
    gtk_table_attach (GTK_TABLE (table), togglebutton, 1, 2, 1, 2,
		      (GtkAttachOptions) (GTK_FILL),
		      (GtkAttachOptions) (0), 0, 0);
    if ((statbuf.st_mode & ~(S_IFMT)) & S_IRUSR)
      gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (togglebutton), TRUE);

    priv->mode_buttons[1] = togglebutton = gtk_toggle_button_new_with_label ("");
    gtk_widget_show (togglebutton);
    gtk_table_attach (GTK_TABLE (table), togglebutton, 2, 3, 1, 2,
		      (GtkAttachOptions) (GTK_FILL),
		      (GtkAttachOptions) (0), 0, 0);
    if ((statbuf.st_mode & ~(S_IFMT)) & S_IWUSR)
      gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (togglebutton), TRUE);
    
    priv->mode_buttons[2] = togglebutton = gtk_toggle_button_new_with_label ("");
    gtk_widget_show (togglebutton);
    gtk_table_attach (GTK_TABLE (table), togglebutton, 3, 4, 1, 2,
		      (GtkAttachOptions) (GTK_FILL),
		      (GtkAttachOptions) (0), 0, 0);
    if ((statbuf.st_mode & ~(S_IFMT)) & S_IXUSR)
      gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (togglebutton), TRUE);
    
    priv->mode_buttons[3] = togglebutton = gtk_toggle_button_new_with_label ("");
    gtk_widget_show (togglebutton);
    gtk_table_attach (GTK_TABLE (table), togglebutton, 4, 5, 1, 2,
		      (GtkAttachOptions) (GTK_FILL),
		      (GtkAttachOptions) (0), 0, 0);
    if ((statbuf.st_mode & ~(S_IFMT)) & S_ISUID)
      gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (togglebutton), TRUE);


    
    label = gtk_label_new (_("Group:"));
    gtk_widget_show (label);
    gtk_table_attach (GTK_TABLE (table), label, 0, 1, 2, 3,
		      (GtkAttachOptions) (GTK_FILL),
		      (GtkAttachOptions) (0), 0, 0);
    gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
    
    priv->mode_buttons[4] = togglebutton = gtk_toggle_button_new_with_label ("");
    gtk_widget_show (togglebutton);
    gtk_table_attach (GTK_TABLE (table), togglebutton, 1, 2, 2, 3,
		      (GtkAttachOptions) (GTK_FILL),
		      (GtkAttachOptions) (0), 0, 0);
    if ((statbuf.st_mode & ~(S_IFMT)) & S_IRGRP)
      gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (togglebutton), TRUE);
    
    priv->mode_buttons[5] = togglebutton = gtk_toggle_button_new_with_label ("");
    gtk_widget_show (togglebutton);
    gtk_table_attach (GTK_TABLE (table), togglebutton, 2, 3, 2, 3,
		      (GtkAttachOptions) (GTK_FILL),
		      (GtkAttachOptions) (0), 0, 0);
    if ((statbuf.st_mode & ~(S_IFMT)) & S_IWGRP)
      gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (togglebutton), TRUE);
    
    priv->mode_buttons[6] = togglebutton = gtk_toggle_button_new_with_label ("");
    gtk_widget_show (togglebutton);
    gtk_table_attach (GTK_TABLE (table), togglebutton, 3, 4, 2, 3,
		      (GtkAttachOptions) (GTK_FILL),
		      (GtkAttachOptions) (0), 0, 0);
    if ((statbuf.st_mode & ~(S_IFMT)) & S_IXGRP)
      gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (togglebutton), TRUE);
    
    priv->mode_buttons[7] = togglebutton = gtk_toggle_button_new_with_label ("");
    gtk_widget_show (togglebutton);
    gtk_table_attach (GTK_TABLE (table), togglebutton, 4, 5, 2, 3,
		      (GtkAttachOptions) (GTK_FILL),
		      (GtkAttachOptions) (0), 0, 0);
    if ((statbuf.st_mode & ~(S_IFMT)) & S_ISGID)
      gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (togglebutton), TRUE);
    
    label = gtk_label_new (_("Other:"));
    gtk_widget_show (label);
    gtk_table_attach (GTK_TABLE (table), label, 0, 1, 3, 4,
		      (GtkAttachOptions) (GTK_FILL),
		      (GtkAttachOptions) (0), 0, 0);
    gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
    
    priv->mode_buttons[8] = togglebutton = gtk_toggle_button_new_with_label ("");
    gtk_widget_show (togglebutton);
    gtk_table_attach (GTK_TABLE (table), togglebutton, 1, 2, 3, 4,
		      (GtkAttachOptions) (GTK_FILL),
		      (GtkAttachOptions) (0), 0, 0);
    if ((statbuf.st_mode & ~(S_IFMT)) & S_IROTH)
      gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (togglebutton), TRUE);

    priv->mode_buttons[9] = togglebutton = gtk_toggle_button_new_with_label ("");
    gtk_widget_show (togglebutton);
    gtk_table_attach (GTK_TABLE (table), togglebutton, 2, 3, 3, 4,
		      (GtkAttachOptions) (GTK_FILL),
		      (GtkAttachOptions) (0), 0, 0);
    if ((statbuf.st_mode & ~(S_IFMT)) & S_IWOTH)
      gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (togglebutton), TRUE);
    
    priv->mode_buttons[10] = togglebutton = gtk_toggle_button_new_with_label ("");
    gtk_widget_show (togglebutton);
    gtk_table_attach (GTK_TABLE (table), togglebutton, 3, 4, 3, 4,
		      (GtkAttachOptions) (GTK_FILL),
		      (GtkAttachOptions) (0), 0, 0);
    if ((statbuf.st_mode & ~(S_IFMT)) & S_IXOTH)
      gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (togglebutton), TRUE);
    
    priv->mode_buttons[11] = togglebutton = gtk_toggle_button_new_with_label ("");
    gtk_widget_show (togglebutton);
    gtk_table_attach (GTK_TABLE (table), togglebutton, 4, 5, 3, 4,
		      (GtkAttachOptions) (GTK_FILL),
		      (GtkAttachOptions) (0), 0, 0);
    if ((statbuf.st_mode & ~(S_IFMT)) & S_ISVTX)
      gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (togglebutton), TRUE);

    for (i = 0; i < 12; i++)
      gtk_signal_connect (GTK_OBJECT (priv->mode_buttons[i]), "toggled",
                          GTK_SIGNAL_FUNC (gtk_file_selection_properties_update_mode), fs);
    gtk_toggle_button_toggled (GTK_TOGGLE_BUTTON (priv->mode_buttons[0]));
  }
  /* global page */
  vbox = gtk_vbox_new (FALSE, 0);
  gtk_widget_show (vbox);
  gtk_container_add (GTK_CONTAINER (notebook), vbox);

  label = gtk_label_new (_("Global"));
  gtk_widget_show (label);
  gtk_notebook_set_tab_label (GTK_NOTEBOOK (notebook), gtk_notebook_get_nth_page (GTK_NOTEBOOK (notebook), pagenum), label);
  pagenum++;

  label = gtk_label_new (_("dialog preferances will go here"));
  gtk_widget_show (label);
  gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);

  /* end of dialog guts */

  /* buttons */
  button = gtk_button_new_with_label (_("OK"));
  //  gtk_signal_connect (GTK_OBJECT (button), "clicked",
  //		      (GtkSignalFunc) gtk_file_selection_rename_file_confirmed, 
  //		      (gpointer) fs);
  gtk_signal_connect (GTK_OBJECT (button), "clicked",
		      (GtkSignalFunc) gtk_file_selection_file_mode_confirmed, 
		      (gpointer) fs);
  gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->action_area),
		     button, TRUE, TRUE, 0);
  GTK_WIDGET_SET_FLAGS(button, GTK_CAN_DEFAULT);
  gtk_widget_show(button);
  
  button = gtk_button_new_with_label (_("Cancel"));
  gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
			     (GtkSignalFunc) gtk_widget_destroy, 
			     (gpointer) dialog);
  gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->action_area),
		     button, TRUE, TRUE, 0);
  GTK_WIDGET_SET_FLAGS(button, GTK_CAN_DEFAULT);
  gtk_widget_grab_default(button);
  gtk_widget_show (button);

  g_free (filename);
  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 (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;
    }
  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;
    }


  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_bookmark_button (GtkWidget *widget, 
                                    GtkFileSelection *fs)
{

  g_return_if_fail (fs != NULL);
  g_return_if_fail (GTK_FILE_SELECTION (fs));
	 
  gtk_menu_popup (GTK_MENU (fs->bookmark_menu), NULL, NULL, NULL, NULL, 
		  0, 0);
  
}

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(GTK_COMBO(fs->mask_entry)->entry)));
	
  if (strlen(fs->mask) == 0)
    {
      g_free (fs->mask);
      fs->mask = NULL;
    }
	
  gtk_file_selection_refresh_button (widget,data);
}

static gint gtk_file_selection_files_list_key_callback (GtkWidget *widget, GdkEventKey *event, gpointer data){
  GtkFileSelection *fs=data;
  gchar *saved;
  gchar key[2];

//  g_print("Key event: %d\n",event->keyval);
  //we need some sort of timeout.

  //if the key is a normal character then
  //add to our saved_entry1
  //if it's backspace then remove one character
  //otherwise let it through (and erase our buffer.

  if(event->keyval > GDK_space && event->keyval <=  GDK_Korean_Won) {
    key[1]=0;
    key[0]=event->keyval;
    saved=fs->saved_entry1;
    if(fs->saved_entry1){
      fs->saved_entry1=g_strconcat(saved,key,NULL);
      g_free(saved);
    }else{
      fs->saved_entry1=g_strdup(key);
    }
    g_print("complete: %s\n",fs->saved_entry1);
    /*gtk_label_set_text(GTK_LABEL(fs->completion_label), fs->saved_entry1); */

    saved=g_strdup(gtk_entry_get_text(GTK_ENTRY(fs->selection_entry)));
    gtk_file_selection_complete(fs,fs->saved_entry1);
    gtk_entry_set_text(GTK_ENTRY(fs->selection_entry),saved);
    g_free(saved);
  }else if (event->keyval ==  GDK_BackSpace) {
    if(strlen(fs->saved_entry1)){
      fs->saved_entry1[strlen(fs->saved_entry1)-1]=0;
      g_print("complete: %s\n",fs->saved_entry1);
      /*gtk_label_set_text(GTK_LABEL(fs->completion_label),fs->saved_entry1); */
      saved=g_strdup(gtk_entry_get_text(GTK_ENTRY(fs->selection_entry)));
      gtk_file_selection_complete(fs,fs->saved_entry1);
      gtk_entry_set_text(GTK_ENTRY(fs->selection_entry),saved);
      g_free(saved);
    }
  }else if (event->keyval == GDK_Tab) {
    saved=g_strdup(gtk_entry_get_text(GTK_ENTRY(fs->selection_entry)));
    gtk_file_selection_populate(fs,fs->saved_entry1,TRUE);
    g_free(fs->saved_entry1);
    fs->saved_entry1=gtk_entry_get_text(GTK_ENTRY(fs->selection_entry));
    gtk_entry_set_text(GTK_ENTRY(fs->selection_entry),saved);
    g_free(saved);

    g_print("complete: %s\n",fs->saved_entry1);
    /* gtk_label_set_text(GTK_LABEL(fs->completion_label),fs->saved_entry1);*/

    gtk_signal_emit_stop_by_name (GTK_OBJECT (widget), "key_press_event");
  }else {
    if(fs->saved_entry1){
      g_free(fs->saved_entry1);
      fs->saved_entry1=NULL;
    }
    /* gtk_label_set_text(GTK_LABEL(fs->completion_label)," "); */
  }

  return TRUE;
}


static gint gtk_file_selection_mask_entry_key_callback (GtkWidget *widget, GdkEventKey *event, gpointer data)
{
  GtkEntry *entry=(GtkEntry *)widget;
  GtkFileSelection *fs=data;
	
  g_return_val_if_fail (fs != NULL,FALSE);
  g_return_val_if_fail (GTK_IS_FILE_SELECTION (fs),FALSE);
	

  if (event->keyval == GDK_Return || event->keyval == GDK_Tab)
    {
      if(fs->mask)
        g_free(fs->mask);

      fs->mask=g_strdup(gtk_entry_get_text(entry));
      gtk_file_selection_refresh_button(widget,fs);

      if (event->keyval == GDK_Return)
        gtk_signal_emit_stop_by_name (GTK_OBJECT (widget), "key_press_event");
      return TRUE;
    }
  else
    {
      return FALSE;
    }
}

static gint gtk_file_selection_mask_entry_button_callback (GtkWidget *widget, GdkEventButton *event, gpointer data)
{
  GtkFileSelection *fs = data;
		
  if(fs->mask)
    g_free(fs->mask);

  fs->mask=g_strdup(gtk_entry_get_text(GTK_ENTRY(GTK_COMBO(fs->mask_entry)->entry)));
  gtk_file_selection_refresh_button(widget,fs);

  return TRUE;

}

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_bookmark_callback (GtkWidget *widget, gpointer data)
{
  GtkFileSelection *fs = data;
  BookmarkMenuStruct *item;
  GList *list;
	
  g_return_if_fail (fs != NULL);
  g_return_if_fail (GTK_IS_FILE_SELECTION (fs));

//g_print ("Callback\n");
  list = fs->bookmark_list;
  while(list) {
    item = list->data;
    if (item->menu_item == widget) {
      if(strcmp(item->path,"./")) {
        gtk_file_selection_populate (fs, item->path, FALSE);
      }
      break;
    }
    list=list->next;
  } 
}

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));
  
  gtk_clist_get_text (GTK_CLIST (fs->file_list), row, 0, &temp);
  filename = g_strdup (temp);

  if (filename)
    {
      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;
      }
      if(fs->saved_entry1){
        g_free(fs->saved_entry1);
        fs->saved_entry1=NULL;
      }
      /* gtk_label_set_text(GTK_LABEL(fs->completion_label)," "); */


      if (bevent)
	switch (bevent->type)
	  {
	  case GDK_2BUTTON_PRESS:
	    gtk_button_clicked (GTK_BUTTON (fs->ok_button));
	    break;
	    
	  default:
/*	
	    if (bevent->button && GDK_BUTTON2_MASK)
	      {
	        g_print("Right click! -- %d\n",bevent->button);
	      }
	      else
	      {
	      */
	
	    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));

  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);
	    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));

  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 ../ */
  /* Actually, no let's not.
  text[1] = NULL;
  text[0] = "./";
  row = gtk_clist_append (GTK_CLIST (fs->dir_list), text);
  */

  text[0] = "../";  //Do we need ..?
  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 = 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 (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];

  sprintf (err_buf, _("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 = 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 (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 = 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, 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 = strlen(dir_name);

  if (path_buf_len > 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 = strlen(dirent_ptr->d_name);
      buffer_size += entry_len + 1;
      entry_count += 1;

      if(path_buf_len + entry_len + 2 >= MAXPATHLEN)
	{
	  cmpl_errno = CMPL_ERRNO_TOO_LONG;
 	  closedir(directory);
	  return NULL;
	}
    }

  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, 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;
  } no_stat_dirs[] = {
    { "/afs", FALSE, { 0 } },
    { "/net", FALSE, { 0 } }
  };

  static const gint n_no_stat_dirs = sizeof(no_stat_dirs) / sizeof(no_stat_dirs[0]);
  static gboolean initialized = FALSE;

  gint i;

  if (!initialized)
    {
      initialized = TRUE;
      for (i = 0; i < n_no_stat_dirs; i++)
	{
	  if (stat (no_stat_dirs[i].name, &no_stat_dirs[i].statbuf) == 0)
	    no_stat_dirs[i].present = TRUE;
	}
    }

  if(stat(dir_name, result) < 0)
    {
      cmpl_errno = errno;
      return FALSE;
    }

  *stat_subdirs = TRUE;
  for (i=0; i<n_no_stat_dirs; i++)
    {
      if (no_stat_dirs[i].present &&
	  (no_stat_dirs[i].statbuf.st_dev == result->st_dev) &&
	  (no_stat_dirs[i].statbuf.st_ino == result->st_ino))
	{
	  *stat_subdirs = FALSE;
	  break;
	}
    }

  return TRUE;
}

/* 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 = strlen(dir_name);

  return new_dir;
}

static gint
correct_dir_fullname(CompletionDir* cmpl_dir)
{
  gint length = 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 = 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 = 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;

      append_completion_text("~", cmpl_state);

      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 = 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, '/');
  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_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, '/');

  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);
      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)
	{
	  append_completion_text(dir->fullname +
				 strlen(cmpl_state->completion_dir->fullname) + 1,
				 cmpl_state);
	  append_completion_text("/", 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("/", 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;
  setpwent ();

  while ((pwd_ptr = getpwent()) != NULL)
    {
      len += strlen(pwd_ptr->pw_name);
      len += strlen(pwd_ptr->pw_dir);
      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;
	}

      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,
	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);
}

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);
}

/* This is an internally used function to create pixmaps. */
GtkWidget*
create_pixmap(GtkWidget *widget, const gchar *pixmap_char)
{
  GdkPixmap *gdkpixmap;
  GdkBitmap *mask;
  GtkWidget *pixmap;
  GdkColormap *colormap;

  colormap = gtk_widget_get_colormap (widget);

  gdkpixmap = gdk_pixmap_colormap_create_from_xpm_d (GTK_WIDGET(widget)->window,
						     colormap,
						     &mask,
						     NULL, 
						     (gpointer) pixmap_char);
  if (gdkpixmap == NULL)
    {
      g_warning ("Error loading pixmap: %s", pixmap_char);
      return NULL;
    }
  pixmap = gtk_pixmap_new (gdkpixmap, mask);
  gdk_pixmap_unref (gdkpixmap);
  gdk_bitmap_unref (mask);
  return pixmap;
}


/* 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;
    const gchar *masks[] = { "mp3s/playlists <*.mp3,*.m3u>",
                             "src/hdr <*.[CcHh],*.[Cc][Cc],*.[Hh][Hh],*.cpp>",
                             NULL };

    gtk_init (&argc, &argv);

    /* Create a new file selection widget */
    filew = gtk_file_selection_new ("Spiffy File Selector");
//    gtk_file_selection_complete(GTK_FILE_SELECTION(filew),"bob");

    gtk_file_selection_set_masks (GTK_FILE_SELECTION (filew), masks);
		
    gtk_signal_connect (GTK_OBJECT (filew), "destroy",
			(GtkSignalFunc) destroy, &filew);
    /* Connect the ok_button to file_ok_sel function */
    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 */
    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