radiant/gtkfilesel.c

   1 /*\r
   2 Copyright (C) 1999-2007 id Software, Inc. and contributors.\r
   3 For a list of contributors, see the accompanying CONTRIBUTORS file.\r
   4 \r
   5 This file is part of GtkRadiant.\r
   6 \r
   7 GtkRadiant is free software; you can redistribute it and/or modify\r
   8 it under the terms of the GNU General Public License as published by\r
   9 the Free Software Foundation; either version 2 of the License, or\r
  10 (at your option) any later version.\r
  11 \r
  12 GtkRadiant is distributed in the hope that it will be useful,\r
  13 but WITHOUT ANY WARRANTY; without even the implied warranty of\r
  14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\r
  15 GNU General Public License for more details.\r
  16 \r
  17 You should have received a copy of the GNU General Public License\r
  18 along with GtkRadiant; if not, write to the Free Software\r
  19 Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA\r
  20 */\r
  21 \r
  22 /* GTK - The GIMP Toolkit\r
  23  * Copyright (C) 1995-1997 Peter Mattis, Spencer Kimball and Josh MacDonald\r
  24  *\r
  25  * This library is free software; you can redistribute it and/or\r
  26  * modify it under the terms of the GNU Library General Public\r
  27  * License as published by the Free Software Foundation; either\r
  28  * version 2 of the License, or (at your option) any later version.\r
  29  *\r
  30  * This library is distributed in the hope that it will be useful,\r
  31  * but WITHOUT ANY WARRANTY; without even the implied warranty of\r
  32  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU\r
  33  * Library General Public License for more details.\r
  34  *\r
  35  * You should have received a copy of the GNU Library General Public\r
  36  * License along with this library; if not, write to the\r
  37  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,\r
  38  * Boston, MA 02111-1307, USA.\r
  39  */\r
  40 \r
  41 /*\r
  42  * Modified by the GTK+ Team and others 1997-1999.  See the AUTHORS\r
  43  * file for a list of people on the GTK+ Team.  See the ChangeLog\r
  44  * files for a list of changes.  These files are distributed with\r
  45  * GTK+ at ftp://ftp.gtk.org/pub/gtk/. \r
  46  */\r
  47 \r
  48 \r
  49 // leo FIXME: if we keep this file then we'll need to ask permission to the author, this is LGPL\r
  50 // This file is from the Advanced File Selector widget \r
  51 // by Michael Torrie  <torriem@byu.edu>\r
  52 // http://students.cs.byu.edu/~torriem/gtk/\r
  53 \r
  54 #include <stdio.h>\r
  55 #include <sys/types.h>\r
  56 #include <sys/stat.h>\r
  57 #include <sys/param.h>\r
  58 #include <dirent.h>\r
  59 #include <stdlib.h>\r
  60 #include <unistd.h>\r
  61 #include <string.h>\r
  62 #include <errno.h>\r
  63 #include <pwd.h>\r
  64 #include "fnmatch.h"\r
  65 \r
  66 // leo: added "gtk/"\r
  67 #include "gdk/gdkkeysyms.h"\r
  68 #include "gtk/gtkbutton.h"\r
  69 #include "gtk/gtkentry.h"\r
  70 #include "gtkfilesel.h"\r
  71 #include "gtk/gtkhbox.h"\r
  72 #include "gtk/gtkhbbox.h"\r
  73 #include "gtk/gtklabel.h"\r
  74 #include "gtk/gtklist.h"\r
  75 #include "gtk/gtklistitem.h"\r
  76 #include "gtk/gtkmain.h"\r
  77 #include "gtk/gtkscrolledwindow.h"\r
  78 #include "gtk/gtksignal.h"\r
  79 #include "gtk/gtkvbox.h"\r
  80 #include "gtk/gtkmenu.h"\r
  81 #include "gtk/gtkmenuitem.h"\r
  82 #include "gtk/gtkoptionmenu.h"\r
  83 #include "gtk/gtkclist.h"\r
  84 #include "gtk/gtkdialog.h"\r
  85 #include "gtk/gtkcombo.h"\r
  86 #include "gtk/gtkframe.h"\r
  87 \r
  88 // leo: disable NLS\r
  89 //#include "gtk/gtkintl.h"\r
  90 #define _(String) (String)\r
  91 \r
  92 #define DIR_LIST_WIDTH   180\r
  93 #define DIR_LIST_HEIGHT  180\r
  94 #define FILE_LIST_WIDTH  180\r
  95 #define FILE_LIST_HEIGHT 180\r
  96 \r
  97 /* I've put this here so it doesn't get confused with the \r
  98  * file completion interface */\r
  99 typedef struct _HistoryCallbackArg HistoryCallbackArg;\r
 100 \r
 101 struct _HistoryCallbackArg\r
 102 {\r
 103   gchar *directory;\r
 104   GtkWidget *menu_item;\r
 105 };\r
 106 \r
 107 \r
 108 typedef struct _CompletionState    CompletionState;\r
 109 typedef struct _CompletionDir      CompletionDir;\r
 110 typedef struct _CompletionDirSent  CompletionDirSent;\r
 111 typedef struct _CompletionDirEntry CompletionDirEntry;\r
 112 typedef struct _CompletionUserDir  CompletionUserDir;\r
 113 typedef struct _PossibleCompletion PossibleCompletion;\r
 114 \r
 115 /* Non-external file completion decls and structures */\r
 116 \r
 117 /* A contant telling PRCS how many directories to cache.  Its actually\r
 118  * kept in a list, so the geometry isn't important. */\r
 119 #define CMPL_DIRECTORY_CACHE_SIZE 10\r
 120 \r
 121 /* A constant used to determine whether a substring was an exact\r
 122  * match by first_diff_index()\r
 123  */\r
 124 #define PATTERN_MATCH -1\r
 125 /* The arguments used by all fnmatch() calls below\r
 126  */\r
 127 #define FNMATCH_FLAGS (FNM_PATHNAME | FNM_PERIOD)\r
 128 \r
 129 #define CMPL_ERRNO_TOO_LONG ((1<<16)-1)\r
 130 \r
 131 /* This structure contains all the useful information about a directory\r
 132  * for the purposes of filename completion.  These structures are cached\r
 133  * in the CompletionState struct.  CompletionDir's are reference counted.\r
 134  */\r
 135 struct _CompletionDirSent\r
 136 {\r
 137   ino_t inode;\r
 138   time_t mtime;\r
 139   dev_t device;\r
 140 \r
 141   gint entry_count;\r
 142   gchar *name_buffer; /* memory segment containing names of all entries */\r
 143 \r
 144   struct _CompletionDirEntry *entries;\r
 145 };\r
 146 \r
 147 struct _CompletionDir\r
 148 {\r
 149   CompletionDirSent *sent;\r
 150 \r
 151   gchar *fullname;\r
 152   gint fullname_len;\r
 153 \r
 154   struct _CompletionDir *cmpl_parent;\r
 155   gint cmpl_index;\r
 156   gchar *cmpl_text;\r
 157 };\r
 158 \r
 159 /* This structure contains pairs of directory entry names with a flag saying\r
 160  * whether or not they are a valid directory.  NOTE: This information is used\r
 161  * to provide the caller with information about whether to update its completions\r
 162  * or try to open a file.  Since directories are cached by the directory mtime,\r
 163  * a symlink which points to an invalid file (which will not be a directory),\r
 164  * will not be reevaluated if that file is created, unless the containing\r
 165  * directory is touched.  I consider this case to be worth ignoring (josh).\r
 166  */\r
 167 struct _CompletionDirEntry\r
 168 {\r
 169   gint is_dir;\r
 170   gchar *entry_name;\r
 171 };\r
 172 \r
 173 struct _CompletionUserDir\r
 174 {\r
 175   gchar *login;\r
 176   gchar *homedir;\r
 177 };\r
 178 \r
 179 struct _PossibleCompletion\r
 180 {\r
 181   /* accessible fields, all are accessed externally by functions\r
 182    * declared above\r
 183    */\r
 184   gchar *text;\r
 185   gint is_a_completion;\r
 186   gint is_directory;\r
 187 \r
 188   gint file_size;\r
 189   gint file_time;\r
 190   gint uid;\r
 191   gint gid;\r
 192   /* Private fields\r
 193    */\r
 194   gint text_alloc;\r
 195 };\r
 196 \r
 197 struct _CompletionState\r
 198 {\r
 199   gint last_valid_char;\r
 200   gchar *updated_text;\r
 201   gint updated_text_len;\r
 202   gint updated_text_alloc;\r
 203   gint re_complete;\r
 204 \r
 205   gchar *user_dir_name_buffer;\r
 206   gint user_directories_len;\r
 207 \r
 208   gchar *last_completion_text;\r
 209 \r
 210   gint user_completion_index; /* if >= 0, currently completing ~user */\r
 211 \r
 212   struct _CompletionDir *completion_dir; /* directory completing from */\r
 213   struct _CompletionDir *active_completion_dir;\r
 214 \r
 215   struct _PossibleCompletion the_completion;\r
 216 \r
 217   struct _CompletionDir *reference_dir; /* initial directory */\r
 218 \r
 219   GList* directory_storage;\r
 220   GList* directory_sent_storage;\r
 221 \r
 222   struct _CompletionUserDir *user_directories;\r
 223 };\r
 224 \r
 225 \r
 226 /* File completion functions which would be external, were they used\r
 227  * outside of this file.\r
 228  */\r
 229 \r
 230 static CompletionState*    cmpl_init_state        (void);\r
 231 static void                cmpl_free_state        (CompletionState *cmpl_state);\r
 232 static gint                cmpl_state_okay        (CompletionState* cmpl_state);\r
 233 static gchar*              cmpl_strerror          (gint);\r
 234 \r
 235 static PossibleCompletion* cmpl_completion_matches(gchar           *text_to_complete,\r
 236                                                    gchar          **remaining_text,\r
 237                                                    CompletionState *cmpl_state);\r
 238 \r
 239 /* Returns a name for consideration, possibly a completion, this name\r
 240  * will be invalid after the next call to cmpl_next_completion.\r
 241  */\r
 242 static char*               cmpl_this_completion   (PossibleCompletion*);\r
 243 \r
 244 /* True if this completion matches the given text.  Otherwise, this\r
 245  * output can be used to have a list of non-completions.\r
 246  */\r
 247 static gint                cmpl_is_a_completion   (PossibleCompletion*);\r
 248 \r
 249 /* True if the completion is a directory\r
 250  */\r
 251 static gint                cmpl_is_directory      (PossibleCompletion*);\r
 252 \r
 253 /* Obtains the next completion, or NULL\r
 254  */\r
 255 static PossibleCompletion* cmpl_next_completion   (CompletionState*);\r
 256 \r
 257 /* Updating completions: the return value of cmpl_updated_text() will\r
 258  * be text_to_complete completed as much as possible after the most\r
 259  * recent call to cmpl_completion_matches.  For the present\r
 260  * application, this is the suggested replacement for the user's input\r
 261  * string.  You must CALL THIS AFTER ALL cmpl_text_completions have\r
 262  * been received.\r
 263  */\r
 264 static gchar*              cmpl_updated_text       (CompletionState* cmpl_state);\r
 265 \r
 266 /* After updating, to see if the completion was a directory, call\r
 267  * this.  If it was, you should consider re-calling completion_matches.\r
 268  */\r
 269 static gint                cmpl_updated_dir        (CompletionState* cmpl_state);\r
 270 \r
 271 /* Current location: if using file completion, return the current\r
 272  * directory, from which file completion begins.  More specifically,\r
 273  * the cwd concatenated with all exact completions up to the last\r
 274  * directory delimiter('/').\r
 275  */\r
 276 static gchar*              cmpl_reference_position (CompletionState* cmpl_state);\r
 277 \r
 278 /* backing up: if cmpl_completion_matches returns NULL, you may query\r
 279  * the index of the last completable character into cmpl_updated_text.\r
 280  */\r
 281 static gint                cmpl_last_valid_char    (CompletionState* cmpl_state);\r
 282 \r
 283 /* When the user selects a non-directory, call cmpl_completion_fullname\r
 284  * to get the full name of the selected file.\r
 285  */\r
 286 static gchar*              cmpl_completion_fullname (gchar*, CompletionState* cmpl_state);\r
 287 \r
 288 \r
 289 /* Directory operations. */\r
 290 static CompletionDir* open_ref_dir         (gchar* text_to_complete,\r
 291                                             gchar** remaining_text,\r
 292                                             CompletionState* cmpl_state);\r
 293 static gboolean       check_dir            (gchar *dir_name, \r
 294                                             struct stat *result, \r
 295                                             gboolean *stat_subdirs);\r
 296 static CompletionDir* open_dir             (gchar* dir_name,\r
 297                                             CompletionState* cmpl_state);\r
 298 static CompletionDir* open_user_dir        (gchar* text_to_complete,\r
 299                                             CompletionState *cmpl_state);\r
 300 static CompletionDir* open_relative_dir    (gchar* dir_name, CompletionDir* dir,\r
 301                                             CompletionState *cmpl_state);\r
 302 static CompletionDirSent* open_new_dir     (gchar* dir_name, \r
 303                                             struct stat* sbuf,\r
 304                                             gboolean stat_subdirs);\r
 305 static gint           correct_dir_fullname (CompletionDir* cmpl_dir);\r
 306 static gint           correct_parent       (CompletionDir* cmpl_dir,\r
 307                                             struct stat *sbuf);\r
 308 static gchar*         find_parent_dir_fullname    (gchar* dirname);\r
 309 static CompletionDir* attach_dir           (CompletionDirSent* sent,\r
 310                                             gchar* dir_name,\r
 311                                             CompletionState *cmpl_state);\r
 312 static void           free_dir_sent (CompletionDirSent* sent);\r
 313 static void           free_dir      (CompletionDir  *dir);\r
 314 static void           prune_memory_usage(CompletionState *cmpl_state);\r
 315 \r
 316 /* Completion operations */\r
 317 static PossibleCompletion* attempt_homedir_completion(gchar* text_to_complete,\r
 318                                                       CompletionState *cmpl_state);\r
 319 static PossibleCompletion* attempt_file_completion(CompletionState *cmpl_state);\r
 320 static CompletionDir* find_completion_dir(gchar* text_to_complete,\r
 321                                           gchar** remaining_text,\r
 322                                           CompletionState* cmpl_state);\r
 323 static PossibleCompletion* append_completion_text(gchar* text,\r
 324                                                   CompletionState* cmpl_state);\r
 325 static gint get_pwdb(CompletionState* cmpl_state);\r
 326 static gint first_diff_index(gchar* pat, gchar* text);\r
 327 static gint compare_user_dir(const void* a, const void* b);\r
 328 static gint compare_cmpl_dir(const void* a, const void* b);\r
 329 static void update_cmpl(PossibleCompletion* poss,\r
 330                         CompletionState* cmpl_state);\r
 331 \r
 332 static void gtk_file_selection_class_init    (GtkFileSelectionClass *klass);\r
 333 static void gtk_file_selection_init          (GtkFileSelection      *filesel);\r
 334 static void gtk_file_selection_destroy       (GtkObject             *object);\r
 335 static gint gtk_file_selection_key_press     (GtkWidget             *widget,\r
 336                                               GdkEventKey           *event,\r
 337                                               gpointer               user_data);\r
 338 \r
 339 static void gtk_file_selection_file_button (GtkWidget *widget,\r
 340                                             gint row, \r
 341                                             gint column, \r
 342                                             GdkEventButton *bevent,\r
 343                                             gpointer user_data);\r
 344 \r
 345 static void gtk_file_selection_dir_button (GtkWidget *widget,\r
 346                                            gint row,\r
 347                                            gint column,\r
 348                                            GdkEventButton *bevent,\r
 349                                            gpointer data);\r
 350 \r
 351 static void gtk_file_selection_undir_button (GtkWidget *widget,\r
 352                                              gint row,\r
 353                                              gint column,\r
 354                                              GdkEventButton *bevent,\r
 355                                              gpointer data);\r
 356 \r
 357 static void gtk_file_selection_populate      (GtkFileSelection      *fs,\r
 358                                               gchar                 *rel_path,\r
 359                                               gint                   try_complete);\r
 360 static void gtk_file_selection_abort         (GtkFileSelection      *fs);\r
 361 \r
 362 static void gtk_file_selection_update_history_menu (GtkFileSelection       *fs,\r
 363                                                     gchar                  *current_dir);\r
 364 \r
 365 static void gtk_file_selection_create_dir (GtkWidget *widget, gpointer data);\r
 366 static void gtk_file_selection_delete_file (GtkWidget *widget, gpointer data);\r
 367 static void gtk_file_selection_rename_file (GtkWidget *widget, gpointer data);\r
 368 \r
 369 static gboolean gtk_file_selection_history_combo_callback (GtkWidget *widget, GdkEventKey *event, gpointer data);\r
 370 static gboolean gtk_file_selection_history_combo_list_key_handler(GtkWidget *widget,\r
 371                                                                                                                                                                                         GdkEventKey *event,\r
 372                                                                                                                                                                                         gpointer user_data);\r
 373 static gboolean gtk_file_selection_history_combo_list_callback (GtkWidget *thelist,\r
 374                                                                                                                                                                                         GdkEventButton *event,\r
 375                                                                                                                                                                                         gpointer user_data);\r
 376 static void gtk_file_selection_mask_entry_callback (GtkWidget *widget, gpointer data);\r
 377 static void gtk_file_selection_create_dir (GtkWidget *widget, gpointer data);\r
 378 static void gtk_file_selection_delete_file (GtkWidget *widget, gpointer data);\r
 379 static void gtk_file_selection_rename_file (GtkWidget *widget, gpointer data);\r
 380 static void gtk_file_selection_home_button (GtkWidget *widget, gpointer data);\r
 381 static void gtk_file_selection_up_button (GtkWidget *widget, gpointer data);\r
 382 static void gtk_file_selection_prev_button (GtkWidget *widget, gpointer data);\r
 383 static void gtk_file_selection_next_button (GtkWidget *widget, gpointer data);\r
 384 static void gtk_file_selection_refresh_button (GtkWidget *widget, gpointer data);\r
 385 \r
 386 static gint gtk_file_selection_match_char (gchar, gchar *mask);\r
 387 static gint gtk_file_selection_match_mask (gchar *,gchar *);\r
 388 \r
 389 \r
 390 static GtkWindowClass *parent_class = NULL;\r
 391 \r
 392 /* Saves errno when something cmpl does fails. */\r
 393 static gint cmpl_errno;\r
 394 \r
 395 /* General notes:\r
 396  * Make prev and next inactive if their respective *\r
 397  *   histories are empty.\r
 398  * Add facilities for handling hidden files and    *\r
 399  * directories                                     *\r
 400  * Add an api to access the mask, and hidden files *\r
 401  * check box?  (prob not in 1.2.x series)          *\r
 402  */\r
 403 \r
 404 /* Routine for applying mask to filenames         *\r
 405  *   Need to be optimized to minimize recursion   *\r
 406  *     help the for loop by looking for the next  *\r
 407  *     instance of the mask character following   *\r
 408  *     the '*'.  ei *.c -- look for '.'           *\r
 409  *     Also, swap all *? pairs (-> ?*), as that   *\r
 410  *     will make it possible to look ahead (?     *\r
 411  *     makes it very nondeterministic as in *?.c  *\r
 412  *     which really is ?*.c                       *\r
 413  *   Allow multiply masks, separted by commas     *\r
 414  *   Allow more flexible [] handling (ie [a-zA-Z] *\r
 415  *                                                *\r
 416  */\r
 417 static gint gtk_file_selection_match_char (gchar text, gchar *mask){\r
 418   gchar *maskc;\r
 419   gint x;\r
 420   gint s;\r
 421         \r
 422   if (mask[0] == '[')\r
 423     {\r
 424       if (!strchr (mask,']')) return 0;\r
 425       maskc = g_strdup(mask + 1); /* get the portion of mask inside []*/\r
 426                 \r
 427       (*(strchr (maskc,']'))) = 0;\r
 428       s = strlen ((char *)maskc);\r
 429 \r
 430       for (x = 0; x < s; x++){\r
 431         if (text == maskc[x])\r
 432           {\r
 433             g_free (maskc);\r
 434             return s + 2;\r
 435           }\r
 436       }\r
 437       g_free (maskc);\r
 438       return 0;\r
 439     }\r
 440 \r
 441   if (mask[0] == '?') return 1;\r
 442   if (mask[0] == text) return 1;\r
 443 \r
 444   return 0;\r
 445 }\r
 446 \r
 447 \r
 448 static gint gtk_file_selection_match_mask (gchar *text, gchar *mask){\r
 449 \r
 450   int mc;\r
 451   int tc;\r
 452 \r
 453   tc = 0; mc = 0;\r
 454         \r
 455   if (mask[0] == 0 && text[0] == 0) return 1;\r
 456         \r
 457   if (mask[0] == '*')\r
 458     {\r
 459       for (tc = 0; tc <= strlen(text); tc++)\r
 460         {\r
 461           if (gtk_file_selection_match_mask (text + tc, mask + 1))\r
 462             return 1;\r
 463         }\r
 464       return 0;\r
 465     }\r
 466   mc = gtk_file_selection_match_char (text[0], mask);\r
 467 \r
 468   if(mc)\r
 469     return gtk_file_selection_match_mask (text + 1, mask + mc);\r
 470   else\r
 471     return 0;\r
 472 }\r
 473 \r
 474 GtkType\r
 475 gtk_file_selection_get_type (void)\r
 476 {\r
 477   static GtkType file_selection_type = 0;\r
 478 \r
 479   if (!file_selection_type)\r
 480     {\r
 481       static const GtkTypeInfo filesel_info =\r
 482       {\r
 483         "GtkFileSelection",\r
 484         sizeof (GtkFileSelection),\r
 485         sizeof (GtkFileSelectionClass),\r
 486         (GtkClassInitFunc) gtk_file_selection_class_init,\r
 487         (GtkObjectInitFunc) gtk_file_selection_init,\r
 488         /* reserved_1 */ NULL,\r
 489         /* reserved_2 */ NULL,\r
 490         (GtkClassInitFunc) NULL,\r
 491       };\r
 492 \r
 493       file_selection_type = gtk_type_unique (GTK_TYPE_WINDOW, &filesel_info);\r
 494     }\r
 495 \r
 496   return file_selection_type;\r
 497 }\r
 498 \r
 499 static void\r
 500 gtk_file_selection_class_init (GtkFileSelectionClass *class)\r
 501 {\r
 502   GtkObjectClass *object_class;\r
 503 \r
 504   object_class = (GtkObjectClass*) class;\r
 505 \r
 506   parent_class = gtk_type_class (GTK_TYPE_WINDOW);\r
 507 \r
 508   object_class->destroy = gtk_file_selection_destroy;\r
 509 }\r
 510 \r
 511 static void\r
 512 gtk_file_selection_init (GtkFileSelection *filesel)\r
 513 {\r
 514   GtkWidget *entry_vbox;\r
 515   GtkWidget *label;\r
 516   GtkWidget *list_hbox;\r
 517   GtkWidget *confirm_area;\r
 518   GtkWidget *vbox;\r
 519   GtkWidget *hbox;\r
 520   GtkWidget *pulldown_hbox;\r
 521   GtkWidget *scrolled_win;\r
 522   GtkWidget *mask_label;\r
 523   GtkWidget *bigframe;\r
 524   GtkWidget *label_lookingin;\r
 525   GtkWidget *up_button;\r
 526   GtkWidget *home_button;\r
 527   GtkWidget *prev_button;\r
 528   GtkWidget *next_button;\r
 529   GtkWidget *refresh_button;\r
 530 \r
 531   char *dir_title [2];\r
 532   char *file_title [2];\r
 533   \r
 534   filesel->cmpl_state = cmpl_init_state ();\r
 535 \r
 536   filesel->mask=NULL;\r
 537   filesel->prev_history=NULL;\r
 538   filesel->next_history=NULL;\r
 539   filesel->saved_entry=NULL;\r
 540 \r
 541   /* The dialog-sized vertical box  */\r
 542   filesel->main_vbox = gtk_vbox_new (FALSE, 10);\r
 543   gtk_container_set_border_width (GTK_CONTAINER (filesel), 10);\r
 544   gtk_container_add (GTK_CONTAINER (filesel), filesel->main_vbox);\r
 545   gtk_widget_show (filesel->main_vbox);\r
 546 \r
 547   /* The horizontal box containing create, rename etc. buttons */\r
 548   filesel->button_area = gtk_hbutton_box_new ();\r
 549   gtk_button_box_set_layout(GTK_BUTTON_BOX(filesel->button_area), GTK_BUTTONBOX_START);\r
 550   gtk_button_box_set_spacing(GTK_BUTTON_BOX(filesel->button_area), 0);\r
 551   gtk_box_pack_start (GTK_BOX (filesel->main_vbox), filesel->button_area, \r
 552                       FALSE, FALSE, 0);\r
 553   gtk_widget_show (filesel->button_area);\r
 554   \r
 555   gtk_file_selection_show_fileop_buttons(filesel);\r
 556 \r
 557   /* hbox for pulldown menu */\r
 558   pulldown_hbox = gtk_hbox_new (FALSE, 5);\r
 559   gtk_box_pack_start (GTK_BOX (filesel->main_vbox), pulldown_hbox, FALSE, FALSE, 0);\r
 560   gtk_widget_show (pulldown_hbox);\r
 561   \r
 562   /* The combo box that replaces the pulldown menu */\r
 563   label_lookingin = gtk_label_new (_("Looking in:"));\r
 564   gtk_widget_show (label_lookingin);\r
 565   gtk_box_pack_start (GTK_BOX (pulldown_hbox), label_lookingin, FALSE, FALSE, 0);\r
 566 \r
 567   filesel->history_combo = gtk_combo_new();\r
 568   gtk_widget_show(filesel->history_combo);\r
 569   gtk_combo_set_value_in_list(GTK_COMBO(filesel->history_combo),FALSE,FALSE);\r
 570   gtk_box_pack_start (GTK_BOX(pulldown_hbox),filesel->history_combo,\r
 571                                 TRUE,TRUE, 0);\r
 572   gtk_signal_connect(GTK_OBJECT(((GtkCombo *)filesel->history_combo)->entry),"key-press-event",                             \r
 573                      (GtkSignalFunc) gtk_file_selection_history_combo_callback,\r
 574                      (gpointer) filesel);\r
 575 \r
 576   gtk_signal_connect(GTK_OBJECT(((GtkCombo *)filesel->history_combo)->list),"button-press-event",\r
 577                      (GtkSignalFunc) gtk_file_selection_history_combo_list_callback,\r
 578                      (gpointer) filesel);\r
 579 \r
 580   gtk_signal_connect(GTK_OBJECT(((GtkCombo *)filesel->history_combo)->list),"key-press-event",\r
 581                      (GtkSignalFunc) gtk_file_selection_history_combo_list_key_handler,\r
 582                      (gpointer) filesel);\r
 583 \r
 584   /*  frame to put the following hbox in  */\r
 585   bigframe = gtk_frame_new (NULL);\r
 586   gtk_widget_show (bigframe);\r
 587   gtk_box_pack_start (GTK_BOX (filesel->main_vbox), bigframe, TRUE, TRUE, 0);\r
 588 \r
 589   /*  The horizontal box containing the directory and file listboxes  */\r
 590   list_hbox = gtk_hbox_new (FALSE, 5);\r
 591   gtk_container_add (GTK_CONTAINER(bigframe), list_hbox);\r
 592   gtk_container_set_border_width (GTK_CONTAINER (list_hbox), 5);\r
 593   gtk_widget_show (list_hbox);\r
 594 \r
 595   /* vbox to put the buttons and directory listing in  */\r
 596   vbox = gtk_vbox_new (FALSE, 0);\r
 597   gtk_widget_show (vbox);\r
 598   gtk_box_pack_start (GTK_BOX (list_hbox), vbox, FALSE, FALSE, 0);\r
 599 \r
 600   hbox = gtk_hbox_new (FALSE, 0);\r
 601   gtk_widget_show (hbox);\r
 602   gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0);\r
 603 \r
 604   home_button = gtk_button_new_with_label (_("Home"));\r
 605   gtk_widget_show (home_button);\r
 606   gtk_signal_connect (GTK_OBJECT (home_button), "clicked",\r
 607                       (GtkSignalFunc) gtk_file_selection_home_button,\r
 608                       (gpointer) filesel);\r
 609   gtk_box_pack_start (GTK_BOX (hbox), home_button, TRUE,TRUE, 0);\r
 610 \r
 611   prev_button = gtk_button_new_with_label (_("Prev"));\r
 612   gtk_signal_connect (GTK_OBJECT (prev_button), "clicked",\r
 613                       (GtkSignalFunc) gtk_file_selection_prev_button,\r
 614                       (gpointer) filesel);\r
 615   gtk_widget_show (prev_button);\r
 616   gtk_box_pack_start (GTK_BOX (hbox), prev_button, TRUE,TRUE, 0);\r
 617 \r
 618   up_button = gtk_button_new_with_label (_("Up"));\r
 619   gtk_signal_connect (GTK_OBJECT (up_button), "clicked",\r
 620                       (GtkSignalFunc) gtk_file_selection_up_button,\r
 621                       (gpointer) filesel);\r
 622   gtk_widget_show (up_button);\r
 623   gtk_box_pack_start (GTK_BOX (hbox), up_button, TRUE,TRUE, 0);\r
 624 \r
 625   next_button = gtk_button_new_with_label (_("Next"));\r
 626   gtk_widget_show (next_button);\r
 627   gtk_signal_connect (GTK_OBJECT (next_button), "clicked",\r
 628                       (GtkSignalFunc) gtk_file_selection_next_button,\r
 629                       (gpointer) filesel);\r
 630   gtk_box_pack_start (GTK_BOX (hbox), next_button, TRUE,TRUE, 0);\r
 631 \r
 632   refresh_button = gtk_button_new_with_label (_("Refresh"));\r
 633   gtk_widget_show (refresh_button);\r
 634   gtk_signal_connect (GTK_OBJECT (refresh_button), "clicked",\r
 635                       (GtkSignalFunc) gtk_file_selection_refresh_button,\r
 636                       (gpointer) filesel);\r
 637   gtk_box_pack_start (GTK_BOX (hbox), refresh_button, TRUE, TRUE, 0);\r
 638 \r
 639   /* The directories clist */\r
 640   dir_title[0] = _("Directories");\r
 641   dir_title[1] = NULL;\r
 642   filesel->dir_list = gtk_clist_new_with_titles (1, (gchar**) dir_title);\r
 643   gtk_widget_set_usize (filesel->dir_list, DIR_LIST_WIDTH, DIR_LIST_HEIGHT);\r
 644   gtk_signal_connect (GTK_OBJECT (filesel->dir_list), "select_row",\r
 645                       (GtkSignalFunc) gtk_file_selection_dir_button,\r
 646                       (gpointer) filesel);\r
 647   gtk_signal_connect (GTK_OBJECT (filesel->dir_list), "unselect_row",\r
 648                       (GtkSignalFunc) gtk_file_selection_undir_button,\r
 649                       (gpointer) filesel);\r
 650   gtk_clist_column_titles_passive (GTK_CLIST (filesel->dir_list));\r
 651 \r
 652   scrolled_win = gtk_scrolled_window_new (NULL, NULL);\r
 653   gtk_container_add (GTK_CONTAINER (scrolled_win), filesel->dir_list);\r
 654   gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_win),\r
 655                                   GTK_POLICY_AUTOMATIC, GTK_POLICY_ALWAYS);\r
 656   gtk_box_pack_start (GTK_BOX (vbox), scrolled_win, TRUE,TRUE, 5);\r
 657   gtk_widget_show (filesel->dir_list);\r
 658   gtk_widget_show (scrolled_win);\r
 659 \r
 660   /* vbox area for mask entry and files clist  */\r
 661   vbox = gtk_vbox_new (FALSE, 0);\r
 662   gtk_widget_show (vbox);\r
 663   gtk_box_pack_start (GTK_BOX (list_hbox), vbox, TRUE, TRUE, 0);\r
 664 \r
 665   hbox = gtk_hbox_new (FALSE, 5);\r
 666   gtk_widget_show (hbox);\r
 667   gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0);\r
 668 \r
 669   mask_label = gtk_label_new (_("Mask:"));\r
 670   gtk_widget_show (mask_label);\r
 671   gtk_box_pack_start (GTK_BOX (hbox), mask_label, FALSE, FALSE, 0);\r
 672 \r
 673   filesel->mask_entry = gtk_entry_new ();\r
 674   gtk_widget_show (filesel->mask_entry);\r
 675   gtk_signal_connect(GTK_OBJECT(filesel->mask_entry),"activate",\r
 676                      (GtkSignalFunc) gtk_file_selection_mask_entry_callback,\r
 677                      (gpointer) filesel);\r
 678   gtk_box_pack_start (GTK_BOX (hbox),filesel->mask_entry, TRUE, TRUE, 0);\r
 679 \r
 680 \r
 681   /* The files clist */\r
 682   file_title[0] = _("Files");\r
 683   file_title[1] = NULL;\r
 684   filesel->file_list = gtk_clist_new_with_titles (1, (gchar**) file_title);\r
 685   gtk_widget_set_usize (filesel->file_list, FILE_LIST_WIDTH, FILE_LIST_HEIGHT);\r
 686   gtk_signal_connect (GTK_OBJECT (filesel->file_list), "select_row",\r
 687                       (GtkSignalFunc) gtk_file_selection_file_button, \r
 688                       (gpointer) filesel);\r
 689   gtk_clist_column_titles_passive (GTK_CLIST (filesel->file_list));\r
 690 \r
 691   scrolled_win = gtk_scrolled_window_new (NULL, NULL);\r
 692   gtk_container_add (GTK_CONTAINER (scrolled_win), filesel->file_list);\r
 693   gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_win),\r
 694                                   GTK_POLICY_AUTOMATIC, GTK_POLICY_ALWAYS);\r
 695   gtk_box_pack_start (GTK_BOX (vbox), scrolled_win, TRUE, TRUE, 5);\r
 696   gtk_widget_show (filesel->file_list);\r
 697   gtk_widget_show (scrolled_win);\r
 698 \r
 699   /* action area for packing buttons into. */\r
 700   filesel->action_area = gtk_hbox_new (TRUE, 0);\r
 701   gtk_box_pack_start (GTK_BOX (filesel->main_vbox), filesel->action_area, \r
 702                       FALSE, FALSE, 0);\r
 703   gtk_widget_show (filesel->action_area);\r
 704   \r
 705   /*  The OK/Cancel button area */\r
 706   confirm_area = gtk_hbutton_box_new ();\r
 707   gtk_button_box_set_layout(GTK_BUTTON_BOX(confirm_area), GTK_BUTTONBOX_END);\r
 708   gtk_button_box_set_spacing(GTK_BUTTON_BOX(confirm_area), 5);\r
 709   gtk_box_pack_end (GTK_BOX (filesel->main_vbox), confirm_area, FALSE, FALSE, 0);\r
 710   gtk_widget_show (confirm_area);\r
 711 \r
 712   /*  The OK button  */\r
 713   filesel->ok_button = gtk_button_new_with_label (_("OK"));\r
 714   GTK_WIDGET_SET_FLAGS (filesel->ok_button, GTK_CAN_DEFAULT);\r
 715   gtk_box_pack_start (GTK_BOX (confirm_area), filesel->ok_button, TRUE, TRUE, 0);\r
 716   gtk_widget_grab_default (filesel->ok_button);\r
 717   gtk_widget_show (filesel->ok_button);\r
 718 \r
 719   /*  The Cancel button  */\r
 720   filesel->cancel_button = gtk_button_new_with_label (_("Cancel"));\r
 721   GTK_WIDGET_SET_FLAGS (filesel->cancel_button, GTK_CAN_DEFAULT);\r
 722   gtk_box_pack_start (GTK_BOX (confirm_area), filesel->cancel_button, TRUE, TRUE, 0);\r
 723   gtk_widget_show (filesel->cancel_button);\r
 724 \r
 725   /*  The selection entry widget  */\r
 726   entry_vbox = gtk_vbox_new (FALSE, 2);\r
 727   gtk_box_pack_end (GTK_BOX (filesel->main_vbox), entry_vbox, FALSE, FALSE, 0);\r
 728   gtk_widget_show (entry_vbox);\r
 729 \r
 730   filesel->selection_text = label = gtk_label_new ("");\r
 731   gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);\r
 732   gtk_box_pack_start (GTK_BOX (entry_vbox), label, FALSE, FALSE, 0);\r
 733   gtk_widget_show (label);\r
 734 \r
 735   filesel->selection_entry = gtk_entry_new ();\r
 736   gtk_signal_connect (GTK_OBJECT (filesel->selection_entry), "key_press_event",\r
 737                       (GtkSignalFunc) gtk_file_selection_key_press, filesel);\r
 738   gtk_signal_connect_object (GTK_OBJECT (filesel->selection_entry), "focus_in_event",\r
 739                              (GtkSignalFunc) gtk_widget_grab_default,\r
 740                              GTK_OBJECT (filesel->ok_button));\r
 741   gtk_signal_connect_object (GTK_OBJECT (filesel->selection_entry), "activate",\r
 742                              (GtkSignalFunc) gtk_button_clicked,\r
 743                              GTK_OBJECT (filesel->ok_button));\r
 744   gtk_box_pack_start (GTK_BOX (entry_vbox), filesel->selection_entry, TRUE, TRUE, 0);\r
 745   gtk_widget_show (filesel->selection_entry);\r
 746 \r
 747   if (!cmpl_state_okay (filesel->cmpl_state))\r
 748     {\r
 749       gchar err_buf[256];\r
 750 \r
 751       sprintf (err_buf, _("Directory unreadable: %s"), cmpl_strerror (cmpl_errno));\r
 752 \r
 753       gtk_label_set_text (GTK_LABEL (filesel->selection_text), err_buf);\r
 754     }\r
 755   else\r
 756     {\r
 757       gtk_file_selection_populate (filesel, "", FALSE);\r
 758     }\r
 759 \r
 760   gtk_widget_grab_focus (filesel->selection_entry);\r
 761 }\r
 762 \r
 763 GtkWidget*\r
 764 gtk_file_selection_new (const gchar *title)\r
 765 {\r
 766   GtkFileSelection *filesel;\r
 767 \r
 768   filesel = gtk_type_new (GTK_TYPE_FILE_SELECTION);\r
 769   gtk_window_set_title (GTK_WINDOW (filesel), title);\r
 770 \r
 771   return GTK_WIDGET (filesel);\r
 772 }\r
 773 \r
 774 void\r
 775 gtk_file_selection_show_fileop_buttons (GtkFileSelection *filesel)\r
 776 {\r
 777   g_return_if_fail (filesel != NULL);\r
 778   g_return_if_fail (GTK_IS_FILE_SELECTION (filesel));\r
 779     \r
 780   /* delete, create directory, and rename */\r
 781   if (!filesel->fileop_c_dir) \r
 782     {\r
 783       filesel->fileop_c_dir = gtk_button_new_with_label (_("Create Dir"));\r
 784       gtk_signal_connect (GTK_OBJECT (filesel->fileop_c_dir), "clicked",\r
 785                           (GtkSignalFunc) gtk_file_selection_create_dir, \r
 786                           (gpointer) filesel);\r
 787       gtk_box_pack_start (GTK_BOX (filesel->button_area), \r
 788                           filesel->fileop_c_dir, TRUE, TRUE, 0);\r
 789       gtk_widget_show (filesel->fileop_c_dir);\r
 790     }\r
 791         \r
 792   if (!filesel->fileop_del_file) \r
 793     {\r
 794       filesel->fileop_del_file = gtk_button_new_with_label (_("Delete File"));\r
 795       gtk_signal_connect (GTK_OBJECT (filesel->fileop_del_file), "clicked",\r
 796                           (GtkSignalFunc) gtk_file_selection_delete_file, \r
 797                           (gpointer) filesel);\r
 798       gtk_box_pack_start (GTK_BOX (filesel->button_area), \r
 799                           filesel->fileop_del_file, TRUE, TRUE, 0);\r
 800       gtk_widget_show (filesel->fileop_del_file);\r
 801     }\r
 802 \r
 803   if (!filesel->fileop_ren_file)\r
 804     {\r
 805       filesel->fileop_ren_file = gtk_button_new_with_label (_("Rename File"));\r
 806       gtk_signal_connect (GTK_OBJECT (filesel->fileop_ren_file), "clicked",\r
 807                           (GtkSignalFunc) gtk_file_selection_rename_file, \r
 808                           (gpointer) filesel);\r
 809       gtk_box_pack_start (GTK_BOX (filesel->button_area), \r
 810                           filesel->fileop_ren_file, TRUE, TRUE, 0);\r
 811       gtk_widget_show (filesel->fileop_ren_file);\r
 812     }\r
 813 \r
 814   gtk_widget_queue_resize(GTK_WIDGET(filesel));\r
 815 }\r
 816 \r
 817 void       \r
 818 gtk_file_selection_hide_fileop_buttons (GtkFileSelection *filesel)\r
 819 {\r
 820   g_return_if_fail (filesel != NULL);\r
 821   g_return_if_fail (GTK_IS_FILE_SELECTION (filesel));\r
 822     \r
 823   if (filesel->fileop_ren_file) \r
 824     {\r
 825       gtk_widget_destroy (filesel->fileop_ren_file);\r
 826       filesel->fileop_ren_file = NULL;\r
 827     }\r
 828 \r
 829   if (filesel->fileop_del_file)\r
 830     {\r
 831       gtk_widget_destroy (filesel->fileop_del_file);\r
 832       filesel->fileop_del_file = NULL;\r
 833     }\r
 834 \r
 835   if (filesel->fileop_c_dir)\r
 836     {\r
 837       gtk_widget_destroy (filesel->fileop_c_dir);\r
 838       filesel->fileop_c_dir = NULL;\r
 839     }\r
 840 }\r
 841 \r
 842 \r
 843 \r
 844 void\r
 845 gtk_file_selection_set_filename (GtkFileSelection *filesel,\r
 846                                  const gchar      *filename)\r
 847 {\r
 848   char  buf[MAXPATHLEN];\r
 849   const char *name, *last_slash;\r
 850 \r
 851   g_return_if_fail (filesel != NULL);\r
 852   g_return_if_fail (GTK_IS_FILE_SELECTION (filesel));\r
 853   g_return_if_fail (filename != NULL);\r
 854 \r
 855   last_slash = strrchr (filename, '/');\r
 856 \r
 857   if (!last_slash)\r
 858     {\r
 859       buf[0] = 0;\r
 860       name = filename;\r
 861     }\r
 862   else\r
 863     {\r
 864       gint len = MIN (MAXPATHLEN - 1, last_slash - filename + 1);\r
 865 \r
 866       strncpy (buf, filename, len);\r
 867       buf[len] = 0;\r
 868 \r
 869       name = last_slash + 1;\r
 870     }\r
 871 \r
 872   gtk_file_selection_populate (filesel, buf, FALSE);\r
 873 \r
 874   if (filesel->selection_entry)\r
 875     gtk_entry_set_text (GTK_ENTRY (filesel->selection_entry), name);\r
 876 }\r
 877 \r
 878 gchar*\r
 879 gtk_file_selection_get_filename (GtkFileSelection *filesel)\r
 880 {\r
 881   static char nothing[2] = "";\r
 882   char *text;\r
 883   char *filename;\r
 884 \r
 885   g_return_val_if_fail (filesel != NULL, nothing);\r
 886   g_return_val_if_fail (GTK_IS_FILE_SELECTION (filesel), nothing);\r
 887 \r
 888   text = gtk_entry_get_text (GTK_ENTRY (filesel->selection_entry));\r
 889   if (text)\r
 890     {\r
 891       filename = cmpl_completion_fullname (text, filesel->cmpl_state);\r
 892       return filename;\r
 893     }\r
 894 \r
 895   return nothing;\r
 896 }\r
 897 \r
 898 void\r
 899 gtk_file_selection_complete (GtkFileSelection *filesel,\r
 900                              const gchar      *pattern)\r
 901 {\r
 902   gchar *new_pattern;\r
 903   gint x;\r
 904         \r
 905   g_return_if_fail (filesel != NULL);\r
 906   g_return_if_fail (GTK_IS_FILE_SELECTION (filesel));\r
 907   g_return_if_fail (pattern != NULL);\r
 908 \r
 909   if (filesel->selection_entry)\r
 910     gtk_entry_set_text (GTK_ENTRY (filesel->selection_entry), pattern);\r
 911         \r
 912   if(strchr(pattern,'*') || strchr(pattern,'?'))\r
 913     {\r
 914       for(x=strlen(pattern);x>=0;x--)\r
 915         {\r
 916           if(pattern[x]=='/') break;\r
 917         }\r
 918       gtk_entry_set_text(GTK_ENTRY(filesel->mask_entry),g_strdup(pattern+x+1));\r
 919       \r
 920       if(filesel->mask) g_free(filesel->mask);\r
 921       \r
 922       filesel->mask=g_strdup(pattern+x+1);\r
 923       new_pattern=g_strdup(pattern);\r
 924       new_pattern[x+1]=0;\r
 925       gtk_file_selection_populate (filesel, (gchar*) new_pattern, TRUE);\r
 926       g_free(new_pattern);\r
 927     }\r
 928   else\r
 929     {\r
 930       gtk_file_selection_populate (filesel, (gchar*) pattern, TRUE);\r
 931     }\r
 932 }\r
 933 \r
 934 static void\r
 935 gtk_file_selection_destroy (GtkObject *object)\r
 936 {\r
 937   GtkFileSelection *filesel;\r
 938   GList *list;\r
 939 \r
 940   g_return_if_fail (object != NULL);\r
 941   g_return_if_fail (GTK_IS_FILE_SELECTION (object));\r
 942 \r
 943   filesel = GTK_FILE_SELECTION (object);\r
 944   \r
 945   if (filesel->fileop_dialog)\r
 946     gtk_widget_destroy (filesel->fileop_dialog);\r
 947   \r
 948   if (filesel->next_history)\r
 949     {\r
 950       list = filesel->next_history;\r
 951       while (list)\r
 952         {\r
 953           g_free (list->data);\r
 954           list = list->next;\r
 955         }\r
 956     }\r
 957   g_list_free (filesel->next_history);\r
 958   filesel->next_history = NULL;\r
 959 \r
 960   if (filesel->prev_history)\r
 961     {\r
 962       list = filesel->prev_history;\r
 963       while (list)\r
 964         {\r
 965           g_free (list->data);\r
 966           list = list->next;\r
 967         }\r
 968     }\r
 969   g_list_free (filesel->prev_history);\r
 970   filesel->prev_history = NULL;\r
 971 \r
 972   if (filesel->mask)\r
 973     {\r
 974       g_free (filesel->mask);\r
 975       filesel->mask = NULL;\r
 976     }\r
 977   \r
 978   cmpl_free_state (filesel->cmpl_state);\r
 979   filesel->cmpl_state = NULL;\r
 980 \r
 981   if (GTK_OBJECT_CLASS (parent_class)->destroy)\r
 982     (* GTK_OBJECT_CLASS (parent_class)->destroy) (object);\r
 983 }\r
 984 \r
 985 /* Begin file operations callbacks */\r
 986 \r
 987 static void\r
 988 gtk_file_selection_fileop_error (GtkFileSelection *fs, gchar *error_message)\r
 989 {\r
 990   GtkWidget *label;\r
 991   GtkWidget *vbox;\r
 992   GtkWidget *button;\r
 993   GtkWidget *dialog;\r
 994   \r
 995   g_return_if_fail (error_message != NULL);\r
 996   \r
 997   /* main dialog */\r
 998   dialog = gtk_dialog_new ();\r
 999   /*\r
1000   gtk_signal_connect (GTK_OBJECT (dialog), "destroy",\r
1001                       (GtkSignalFunc) gtk_file_selection_fileop_destroy, \r
1002                       (gpointer) fs);\r
1003   */\r
1004   gtk_window_set_title (GTK_WINDOW (dialog), _("Error"));\r
1005   gtk_window_set_position (GTK_WINDOW (dialog), GTK_WIN_POS_MOUSE);\r
1006   \r
1007   /* If file dialog is grabbed, make this dialog modal too */\r
1008   /* When error dialog is closed, file dialog will be grabbed again */\r
1009   if (GTK_WINDOW(fs)->modal)\r
1010       gtk_window_set_modal (GTK_WINDOW(dialog), TRUE);\r
1011 \r
1012   vbox = gtk_vbox_new(FALSE, 0);\r
1013   gtk_container_set_border_width(GTK_CONTAINER(vbox), 8);\r
1014   gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->vbox), vbox,\r
1015                      FALSE, FALSE, 0);\r
1016   gtk_widget_show(vbox);\r
1017 \r
1018   label = gtk_label_new(error_message);\r
1019   gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.0);\r
1020   gtk_box_pack_start(GTK_BOX(vbox), label, FALSE, FALSE, 5);\r
1021   gtk_widget_show(label);\r
1022 \r
1023   /* yes, we free it */\r
1024   g_free (error_message);\r
1025   \r
1026   /* close button */\r
1027   button = gtk_button_new_with_label (_("Close"));\r
1028   gtk_signal_connect_object (GTK_OBJECT (button), "clicked",\r
1029                              (GtkSignalFunc) gtk_widget_destroy, \r
1030                              (gpointer) dialog);\r
1031   gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->action_area),\r
1032                      button, TRUE, TRUE, 0);\r
1033   GTK_WIDGET_SET_FLAGS(button, GTK_CAN_DEFAULT);\r
1034   gtk_widget_grab_default(button);\r
1035   gtk_widget_show (button);\r
1036 \r
1037   gtk_widget_show (dialog);\r
1038 }\r
1039 \r
1040 static void\r
1041 gtk_file_selection_fileop_destroy (GtkWidget *widget, gpointer data)\r
1042 {\r
1043   GtkFileSelection *fs = data;\r
1044 \r
1045   g_return_if_fail (fs != NULL);\r
1046   g_return_if_fail (GTK_IS_FILE_SELECTION (fs));\r
1047   \r
1048   fs->fileop_dialog = NULL;\r
1049 }\r
1050 \r
1051 \r
1052 static void\r
1053 gtk_file_selection_create_dir_confirmed (GtkWidget *widget, gpointer data)\r
1054 {\r
1055   GtkFileSelection *fs = data;\r
1056   gchar *dirname;\r
1057   gchar *path;\r
1058   gchar *full_path;\r
1059   gchar *buf;\r
1060   CompletionState *cmpl_state;\r
1061   \r
1062   g_return_if_fail (fs != NULL);\r
1063   g_return_if_fail (GTK_IS_FILE_SELECTION (fs));\r
1064 \r
1065   dirname = gtk_entry_get_text (GTK_ENTRY (fs->fileop_entry));\r
1066   cmpl_state = (CompletionState*) fs->cmpl_state;\r
1067   path = cmpl_reference_position (cmpl_state);\r
1068   \r
1069   full_path = g_strconcat (path, "/", dirname, NULL);\r
1070   if ( (mkdir (full_path, 0755) < 0) ) \r
1071     {\r
1072       buf = g_strconcat ("Error creating directory \"", dirname, "\":  ", \r
1073                          g_strerror(errno), NULL);\r
1074       gtk_file_selection_fileop_error (fs, buf);\r
1075     }\r
1076   g_free (full_path);\r
1077   \r
1078   gtk_widget_destroy (fs->fileop_dialog);\r
1079   gtk_file_selection_populate (fs, "", FALSE);\r
1080 }\r
1081   \r
1082 static void\r
1083 gtk_file_selection_create_dir (GtkWidget *widget, gpointer data)\r
1084 {\r
1085   GtkFileSelection *fs = data;\r
1086   GtkWidget *label;\r
1087   GtkWidget *dialog;\r
1088   GtkWidget *vbox;\r
1089   GtkWidget *button;\r
1090 \r
1091   g_return_if_fail (fs != NULL);\r
1092   g_return_if_fail (GTK_IS_FILE_SELECTION (fs));\r
1093 \r
1094   if (fs->fileop_dialog)\r
1095           return;\r
1096   \r
1097   /* main dialog */\r
1098   fs->fileop_dialog = dialog = gtk_dialog_new ();\r
1099   gtk_signal_connect (GTK_OBJECT (dialog), "destroy",\r
1100                       (GtkSignalFunc) gtk_file_selection_fileop_destroy, \r
1101                       (gpointer) fs);\r
1102   gtk_window_set_title (GTK_WINDOW (dialog), _("Create Directory"));\r
1103   gtk_window_set_position (GTK_WINDOW (dialog), GTK_WIN_POS_MOUSE);\r
1104 \r
1105   /* If file dialog is grabbed, grab option dialog */\r
1106   /* When option dialog is closed, file dialog will be grabbed again */\r
1107   if (GTK_WINDOW(fs)->modal)\r
1108       gtk_window_set_modal (GTK_WINDOW(dialog), TRUE);\r
1109 \r
1110   vbox = gtk_vbox_new(FALSE, 0);\r
1111   gtk_container_set_border_width(GTK_CONTAINER(vbox), 8);\r
1112   gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->vbox), vbox,\r
1113                      FALSE, FALSE, 0);\r
1114   gtk_widget_show(vbox);\r
1115   \r
1116   label = gtk_label_new(_("Directory name:"));\r
1117   gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.0);\r
1118   gtk_box_pack_start(GTK_BOX(vbox), label, FALSE, FALSE, 5);\r
1119   gtk_widget_show(label);\r
1120 \r
1121   /*  The directory entry widget  */\r
1122   fs->fileop_entry = gtk_entry_new ();\r
1123   gtk_box_pack_start (GTK_BOX (vbox), fs->fileop_entry, \r
1124                       TRUE, TRUE, 5);\r
1125   GTK_WIDGET_SET_FLAGS(fs->fileop_entry, GTK_CAN_DEFAULT);\r
1126   gtk_widget_show (fs->fileop_entry);\r
1127   \r
1128   /* buttons */\r
1129   button = gtk_button_new_with_label (_("Create"));\r
1130   gtk_signal_connect (GTK_OBJECT (button), "clicked",\r
1131                       (GtkSignalFunc) gtk_file_selection_create_dir_confirmed, \r
1132                       (gpointer) fs);\r
1133   gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->action_area),\r
1134                      button, TRUE, TRUE, 0);\r
1135   GTK_WIDGET_SET_FLAGS(button, GTK_CAN_DEFAULT);\r
1136   gtk_widget_show(button);\r
1137   \r
1138   button = gtk_button_new_with_label (_("Cancel"));\r
1139   gtk_signal_connect_object (GTK_OBJECT (button), "clicked",\r
1140                              (GtkSignalFunc) gtk_widget_destroy, \r
1141                              (gpointer) dialog);\r
1142   gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->action_area),\r
1143                      button, TRUE, TRUE, 0);\r
1144   GTK_WIDGET_SET_FLAGS(button, GTK_CAN_DEFAULT);\r
1145   gtk_widget_grab_default(button);\r
1146   gtk_widget_show (button);\r
1147 \r
1148   gtk_widget_show (dialog);\r
1149 }\r
1150 \r
1151 static void\r
1152 gtk_file_selection_delete_file_confirmed (GtkWidget *widget, gpointer data)\r
1153 {\r
1154   GtkFileSelection *fs = data;\r
1155   CompletionState *cmpl_state;\r
1156   gchar *path;\r
1157   gchar *full_path;\r
1158   gchar *buf;\r
1159   \r
1160   g_return_if_fail (fs != NULL);\r
1161   g_return_if_fail (GTK_IS_FILE_SELECTION (fs));\r
1162 \r
1163   cmpl_state = (CompletionState*) fs->cmpl_state;\r
1164   path = cmpl_reference_position (cmpl_state);\r
1165   \r
1166   full_path = g_strconcat (path, "/", fs->fileop_file, NULL);\r
1167   if ( (unlink (full_path) < 0) ) \r
1168     {\r
1169       buf = g_strconcat ("Error deleting file \"", fs->fileop_file, "\":  ", \r
1170                          g_strerror(errno), NULL);\r
1171       gtk_file_selection_fileop_error (fs, buf);\r
1172     }\r
1173   g_free (full_path);\r
1174   \r
1175   gtk_widget_destroy (fs->fileop_dialog);\r
1176   gtk_file_selection_populate (fs, "", FALSE);\r
1177 }\r
1178 \r
1179 static void\r
1180 gtk_file_selection_delete_file (GtkWidget *widget, gpointer data)\r
1181 {\r
1182   GtkFileSelection *fs = data;\r
1183   GtkWidget *label;\r
1184   GtkWidget *vbox;\r
1185   GtkWidget *button;\r
1186   GtkWidget *dialog;\r
1187   gchar *filename;\r
1188   gchar *buf;\r
1189   \r
1190   g_return_if_fail (fs != NULL);\r
1191   g_return_if_fail (GTK_IS_FILE_SELECTION (fs));\r
1192 \r
1193   if (fs->fileop_dialog)\r
1194           return;\r
1195 \r
1196   filename = gtk_entry_get_text (GTK_ENTRY (fs->selection_entry));\r
1197   if (strlen(filename) < 1)\r
1198           return;\r
1199 \r
1200   fs->fileop_file = filename;\r
1201   \r
1202   /* main dialog */\r
1203   fs->fileop_dialog = dialog = gtk_dialog_new ();\r
1204   gtk_signal_connect (GTK_OBJECT (dialog), "destroy",\r
1205                       (GtkSignalFunc) gtk_file_selection_fileop_destroy, \r
1206                       (gpointer) fs);\r
1207   gtk_window_set_title (GTK_WINDOW (dialog), _("Delete File"));\r
1208   gtk_window_set_position (GTK_WINDOW (dialog), GTK_WIN_POS_MOUSE);\r
1209 \r
1210   /* If file dialog is grabbed, grab option dialog */\r
1211   /* When option dialog is closed, file dialog will be grabbed again */\r
1212   if (GTK_WINDOW(fs)->modal)\r
1213       gtk_window_set_modal (GTK_WINDOW(dialog), TRUE);\r
1214   \r
1215   vbox = gtk_vbox_new(FALSE, 0);\r
1216   gtk_container_set_border_width(GTK_CONTAINER(vbox), 8);\r
1217   gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->vbox), vbox,\r
1218                      FALSE, FALSE, 0);\r
1219   gtk_widget_show(vbox);\r
1220 \r
1221   buf = g_strconcat ("Really delete file \"", filename, "\" ?", NULL);\r
1222   label = gtk_label_new(buf);\r
1223   gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.0);\r
1224   gtk_box_pack_start(GTK_BOX(vbox), label, FALSE, FALSE, 5);\r
1225   gtk_widget_show(label);\r
1226   g_free(buf);\r
1227   \r
1228   /* buttons */\r
1229   button = gtk_button_new_with_label (_("Delete"));\r
1230   gtk_signal_connect (GTK_OBJECT (button), "clicked",\r
1231                       (GtkSignalFunc) gtk_file_selection_delete_file_confirmed, \r
1232                       (gpointer) fs);\r
1233   gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->action_area),\r
1234                      button, TRUE, TRUE, 0);\r
1235   GTK_WIDGET_SET_FLAGS(button, GTK_CAN_DEFAULT);\r
1236   gtk_widget_show(button);\r
1237   \r
1238   button = gtk_button_new_with_label (_("Cancel"));\r
1239   gtk_signal_connect_object (GTK_OBJECT (button), "clicked",\r
1240                              (GtkSignalFunc) gtk_widget_destroy, \r
1241                              (gpointer) dialog);\r
1242   gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->action_area),\r
1243                      button, TRUE, TRUE, 0);\r
1244   GTK_WIDGET_SET_FLAGS(button, GTK_CAN_DEFAULT);\r
1245   gtk_widget_grab_default(button);\r
1246   gtk_widget_show (button);\r
1247 \r
1248   gtk_widget_show (dialog);\r
1249 \r
1250 }\r
1251 \r
1252 static void\r
1253 gtk_file_selection_rename_file_confirmed (GtkWidget *widget, gpointer data)\r
1254 {\r
1255   GtkFileSelection *fs = data;\r
1256   gchar *buf;\r
1257   gchar *file;\r
1258   gchar *path;\r
1259   gchar *new_filename;\r
1260   gchar *old_filename;\r
1261   CompletionState *cmpl_state;\r
1262   \r
1263   g_return_if_fail (fs != NULL);\r
1264   g_return_if_fail (GTK_IS_FILE_SELECTION (fs));\r
1265 \r
1266   file = gtk_entry_get_text (GTK_ENTRY (fs->fileop_entry));\r
1267   cmpl_state = (CompletionState*) fs->cmpl_state;\r
1268   path = cmpl_reference_position (cmpl_state);\r
1269   \r
1270   new_filename = g_strconcat (path, "/", file, NULL);\r
1271   old_filename = g_strconcat (path, "/", fs->fileop_file, NULL);\r
1272 \r
1273   if ( (rename (old_filename, new_filename)) < 0) \r
1274     {\r
1275       buf = g_strconcat ("Error renaming file \"", file, "\":  ", \r
1276                          g_strerror(errno), NULL);\r
1277       gtk_file_selection_fileop_error (fs, buf);\r
1278     }\r
1279   g_free (new_filename);\r
1280   g_free (old_filename);\r
1281   \r
1282   gtk_widget_destroy (fs->fileop_dialog);\r
1283   gtk_file_selection_populate (fs, "", FALSE);\r
1284 }\r
1285   \r
1286 static void\r
1287 gtk_file_selection_rename_file (GtkWidget *widget, gpointer data)\r
1288 {\r
1289   GtkFileSelection *fs = data;\r
1290   GtkWidget *label;\r
1291   GtkWidget *dialog;\r
1292   GtkWidget *vbox;\r
1293   GtkWidget *button;\r
1294   gchar *buf;\r
1295   \r
1296   g_return_if_fail (fs != NULL);\r
1297   g_return_if_fail (GTK_IS_FILE_SELECTION (fs));\r
1298 \r
1299   if (fs->fileop_dialog)\r
1300           return;\r
1301 \r
1302   fs->fileop_file = gtk_entry_get_text (GTK_ENTRY (fs->selection_entry));\r
1303   if (strlen(fs->fileop_file) < 1)\r
1304           return;\r
1305   \r
1306   /* main dialog */\r
1307   fs->fileop_dialog = dialog = gtk_dialog_new ();\r
1308   gtk_signal_connect (GTK_OBJECT (dialog), "destroy",\r
1309                       (GtkSignalFunc) gtk_file_selection_fileop_destroy, \r
1310                       (gpointer) fs);\r
1311   gtk_window_set_title (GTK_WINDOW (dialog), _("Rename File"));\r
1312   gtk_window_set_position (GTK_WINDOW (dialog), GTK_WIN_POS_MOUSE);\r
1313 \r
1314   /* If file dialog is grabbed, grab option dialog */\r
1315   /* When option dialog  closed, file dialog will be grabbed again */\r
1316   if (GTK_WINDOW(fs)->modal)\r
1317     gtk_window_set_modal (GTK_WINDOW(dialog), TRUE);\r
1318   \r
1319   vbox = gtk_vbox_new(FALSE, 0);\r
1320   gtk_container_set_border_width (GTK_CONTAINER(vbox), 8);\r
1321   gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->vbox), vbox,\r
1322                      FALSE, FALSE, 0);\r
1323   gtk_widget_show(vbox);\r
1324   \r
1325   buf = g_strconcat ("Rename file \"", fs->fileop_file, "\" to:", NULL);\r
1326   label = gtk_label_new(buf);\r
1327   gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.0);\r
1328   gtk_box_pack_start(GTK_BOX(vbox), label, FALSE, FALSE, 5);\r
1329   gtk_widget_show(label);\r
1330   g_free(buf);\r
1331 \r
1332   /* New filename entry */\r
1333   fs->fileop_entry = gtk_entry_new ();\r
1334   gtk_box_pack_start (GTK_BOX (vbox), fs->fileop_entry, \r
1335                       TRUE, TRUE, 5);\r
1336   GTK_WIDGET_SET_FLAGS(fs->fileop_entry, GTK_CAN_DEFAULT);\r
1337   gtk_widget_show (fs->fileop_entry);\r
1338   \r
1339   gtk_entry_set_text (GTK_ENTRY (fs->fileop_entry), fs->fileop_file);\r
1340   gtk_editable_select_region (GTK_EDITABLE (fs->fileop_entry),\r
1341                               0, strlen (fs->fileop_file));\r
1342 \r
1343   /* buttons */\r
1344   button = gtk_button_new_with_label (_("Rename"));\r
1345   gtk_signal_connect (GTK_OBJECT (button), "clicked",\r
1346                       (GtkSignalFunc) gtk_file_selection_rename_file_confirmed, \r
1347                       (gpointer) fs);\r
1348   gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->action_area),\r
1349                      button, TRUE, TRUE, 0);\r
1350   GTK_WIDGET_SET_FLAGS(button, GTK_CAN_DEFAULT);\r
1351   gtk_widget_show(button);\r
1352   \r
1353   button = gtk_button_new_with_label (_("Cancel"));\r
1354   gtk_signal_connect_object (GTK_OBJECT (button), "clicked",\r
1355                              (GtkSignalFunc) gtk_widget_destroy, \r
1356                              (gpointer) dialog);\r
1357   gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->action_area),\r
1358                      button, TRUE, TRUE, 0);\r
1359   GTK_WIDGET_SET_FLAGS(button, GTK_CAN_DEFAULT);\r
1360   gtk_widget_grab_default(button);\r
1361   gtk_widget_show (button);\r
1362 \r
1363   gtk_widget_show (dialog);\r
1364 }\r
1365 \r
1366 \r
1367 static gint\r
1368 gtk_file_selection_key_press (GtkWidget   *widget,\r
1369                               GdkEventKey *event,\r
1370                               gpointer     user_data)\r
1371 {\r
1372   GtkFileSelection *fs;\r
1373   char *text;\r
1374 \r
1375   g_return_val_if_fail (widget != NULL, FALSE);\r
1376   g_return_val_if_fail (event != NULL, FALSE);\r
1377 \r
1378   fs = GTK_FILE_SELECTION (user_data);\r
1379 \r
1380   if (event->keyval == GDK_Tab)\r
1381     {\r
1382       text = gtk_entry_get_text (GTK_ENTRY (fs->selection_entry));\r
1383 \r
1384       text = g_strdup (text);\r
1385 \r
1386       gtk_file_selection_populate (fs, text, TRUE);\r
1387 \r
1388       g_free (text);\r
1389 \r
1390       gtk_signal_emit_stop_by_name (GTK_OBJECT (widget), "key_press_event");\r
1391 \r
1392       return TRUE;\r
1393     }\r
1394   if (fs->saved_entry)\r
1395     {\r
1396       gtk_clist_unselect_all ((GtkCList *) (fs->dir_list));\r
1397       gtk_entry_set_text(GTK_ENTRY(fs->selection_entry),fs->saved_entry);\r
1398       g_free (fs->saved_entry);\r
1399       fs->saved_entry = NULL;\r
1400     }\r
1401 \r
1402 \r
1403   return FALSE;\r
1404 }\r
1405 \r
1406 static void\r
1407 gtk_file_selection_home_button (GtkWidget *widget, gpointer data){\r
1408   GList *list;\r
1409         \r
1410   GtkFileSelection *fs=data;\r
1411 \r
1412   list = fs->next_history;\r
1413   if (list)\r
1414     {\r
1415       g_free (list->data);\r
1416       list = list->next;\r
1417     }\r
1418   g_list_free (fs->next_history);\r
1419   fs->next_history = NULL;\r
1420                 \r
1421   gtk_file_selection_populate (fs,"~/",FALSE);\r
1422 }\r
1423 \r
1424 static void\r
1425 gtk_file_selection_up_button (GtkWidget *widget, gpointer data){\r
1426   GtkFileSelection *fs = data;\r
1427   GList *list;\r
1428 \r
1429   g_return_if_fail (fs != NULL);\r
1430   g_return_if_fail (GTK_IS_FILE_SELECTION (fs));\r
1431 \r
1432   list = fs->next_history;\r
1433   if (list)\r
1434     {\r
1435       g_free (list->data);\r
1436       list = list->next;\r
1437     }\r
1438   g_list_free (fs->next_history);\r
1439   fs->next_history = NULL;\r
1440 \r
1441   gtk_file_selection_populate (fs, "../", FALSE); /*change directories. */\r
1442                 \r
1443 }\r
1444 \r
1445 static void\r
1446 gtk_file_selection_prev_button (GtkWidget *widget, gpointer data){\r
1447   GtkFileSelection *fs = data;\r
1448   GList *list;\r
1449   GList *first;\r
1450   gchar *path;\r
1451 \r
1452   g_return_if_fail (fs != NULL);\r
1453   g_return_if_fail (GTK_IS_FILE_SELECTION (fs));\r
1454 \r
1455   list = fs->prev_history;\r
1456 \r
1457   if (list && g_list_length(list) > 1)\r
1458     {\r
1459       first = list;            /* get first element */\r
1460       list = list->next;       /* pop off current directory */\r
1461 \r
1462       list->prev = NULL;       /* make this the new head. */\r
1463         \r
1464       fs->prev_history = list; /* update prev_history list */\r
1465       fs->next_history = g_list_prepend(fs->next_history,first->data); /* put it on next_history */\r
1466         \r
1467       first->next = NULL;      /* orphan the old first node */\r
1468       g_list_free (first);     /* free the node (data is now in use by next_history) */\r
1469 \r
1470 \r
1471         \r
1472       path = g_malloc(strlen(list->data)+4); /* plenty of space */\r
1473       strcpy(path,list->data);               /* get the 2nd path in the history */\r
1474       strcat(path,"/");                      /* append a '/' */\r
1475       gtk_file_selection_populate (fs, path, FALSE); /* change directories. */\r
1476       g_free (path);\r
1477     }\r
1478 }       \r
1479 \r
1480 static void\r
1481 gtk_file_selection_next_button (GtkWidget *widget, gpointer data){\r
1482   GtkFileSelection *fs = data;\r
1483   GList *list;\r
1484   GList *first;\r
1485   gchar *path;\r
1486 \r
1487   g_return_if_fail (fs != NULL);\r
1488   g_return_if_fail (GTK_IS_FILE_SELECTION (fs));\r
1489 \r
1490   list = fs->next_history;\r
1491 \r
1492   if (list && g_list_length(list) > 0)\r
1493     {\r
1494       first = list;            /*get first element*/\r
1495       list = list->next;       /*pop off current directory*/\r
1496       \r
1497       if (list)\r
1498         list->prev = NULL;\r
1499       \r
1500       fs->next_history = list;                       /*update prev_history list*/\r
1501         \r
1502       path = g_malloc(strlen(first->data)+4);        /*plenty of space*/\r
1503       strcpy(path,first->data);\r
1504       strcat(path,"/");                              /*append a /   */\r
1505       gtk_file_selection_populate (fs, path, FALSE); /*change directories.*/\r
1506       g_free(path);\r
1507         \r
1508       first->next = NULL;     /* orphan the old first node */\r
1509       g_list_free (first);    /* free the node (data is now in use by next_history) */\r
1510       \r
1511     }\r
1512 }       \r
1513 \r
1514 void static\r
1515 gtk_file_selection_refresh_button (GtkWidget *widget, gpointer data){\r
1516   GtkFileSelection *fs = data;\r
1517 \r
1518   g_return_if_fail (fs != NULL);\r
1519   g_return_if_fail (GTK_IS_FILE_SELECTION (fs));\r
1520 \r
1521   gtk_file_selection_populate (fs,"",FALSE);\r
1522 }\r
1523 \r
1524 static void\r
1525 gtk_file_selection_mask_entry_callback (GtkWidget *widget, gpointer data){\r
1526   GtkFileSelection *fs = data;\r
1527 \r
1528   if(fs->mask)\r
1529     g_free (fs->mask);\r
1530                 \r
1531   fs->mask = g_strdup(gtk_entry_get_text (GTK_ENTRY(fs->mask_entry)));\r
1532         \r
1533   if (strlen(fs->mask) == 0)\r
1534     {\r
1535       g_free (fs->mask);\r
1536       fs->mask = NULL;\r
1537     }\r
1538         \r
1539   gtk_file_selection_refresh_button (widget,data);\r
1540 }\r
1541 \r
1542 static gboolean gtk_file_selection_history_combo_list_key_handler(GtkWidget *widget,\r
1543                                                                   GdkEventKey *event,\r
1544                                                                   gpointer user_data)\r
1545 {\r
1546   /*\r
1547   g_print("Key pressed! \n");\r
1548   */\r
1549         \r
1550   return TRUE;\r
1551 }\r
1552 \r
1553 static gboolean gtk_file_selection_history_combo_list_callback (GtkWidget *thelist,\r
1554                                                                 GdkEventButton *event,\r
1555                                                                 gpointer user_data)\r
1556 {\r
1557 \r
1558   GtkFileSelection *fs = user_data;\r
1559   GList *list;\r
1560   gchar *path;\r
1561                 \r
1562   list = fs->next_history;\r
1563   if(list)\r
1564     {\r
1565       g_free (list->data);\r
1566       list = list->next;\r
1567     }\r
1568   g_list_free (fs->next_history);\r
1569   fs->next_history = NULL;\r
1570                         \r
1571   path = g_malloc(strlen(gtk_entry_get_text(GTK_ENTRY (((GtkCombo *)fs->history_combo)->entry)))+4);\r
1572   strcpy (path,gtk_entry_get_text(GTK_ENTRY( ((GtkCombo *)fs->history_combo)->entry)));\r
1573   strcat (path,"/");\r
1574         \r
1575   gtk_file_selection_populate (fs,path,TRUE);\r
1576         \r
1577   g_free (path);\r
1578 \r
1579   return TRUE;\r
1580 }\r
1581 \r
1582 static gboolean\r
1583 gtk_file_selection_history_combo_callback (GtkWidget *widget, GdkEventKey *event, gpointer data)\r
1584 {\r
1585   GtkEntry *entry=(GtkEntry *)widget;\r
1586   GtkFileSelection *fs=data;\r
1587   GList *list;\r
1588   gchar *path;\r
1589         \r
1590   g_return_val_if_fail (fs != NULL,FALSE);\r
1591   g_return_val_if_fail (GTK_IS_FILE_SELECTION (fs),FALSE);\r
1592         \r
1593 \r
1594   if (event->keyval == GDK_Return)\r
1595     {\r
1596       list = fs->next_history;\r
1597       if (list)\r
1598         {\r
1599           g_free (list->data);\r
1600           list = list->next;\r
1601         }\r
1602       g_list_free (fs->next_history);\r
1603       fs->next_history = NULL;\r
1604       \r
1605       path = g_malloc(strlen(gtk_entry_get_text(entry))+4);\r
1606       strcpy (path,gtk_entry_get_text(entry));\r
1607       strcat (path,"/");\r
1608       gtk_file_selection_populate (fs,path,TRUE);\r
1609       g_free (path);\r
1610       gtk_signal_emit_stop_by_name (GTK_OBJECT (widget), "key_press_event");\r
1611       return TRUE;\r
1612     }\r
1613   else\r
1614     {\r
1615       return FALSE;\r
1616     }\r
1617 \r
1618 }\r
1619 \r
1620 static void\r
1621 gtk_file_selection_update_history_menu (GtkFileSelection *fs,\r
1622                                         gchar *current_directory)\r
1623 {\r
1624   gchar *current_dir;\r
1625 \r
1626   g_return_if_fail (fs != NULL);\r
1627   g_return_if_fail (GTK_IS_FILE_SELECTION (fs));\r
1628   g_return_if_fail (current_directory != NULL);\r
1629   \r
1630   current_dir = g_strdup (current_directory);\r
1631 \r
1632   if(fs->prev_history)\r
1633     {\r
1634       if (strcmp((fs->prev_history)->data,current_dir))\r
1635         { /*if this item isn't on the top of the list */\r
1636           fs->prev_history = g_list_prepend(fs->prev_history,g_strdup(current_dir));\r
1637         }\r
1638     } else {\r
1639       fs->prev_history = g_list_prepend(fs->prev_history,g_strdup(current_dir));\r
1640     }\r
1641   \r
1642   gtk_combo_set_popdown_strings (GTK_COMBO (fs->history_combo),fs->prev_history);\r
1643   \r
1644   g_free (current_dir);\r
1645 }\r
1646 \r
1647 static void\r
1648 gtk_file_selection_file_button (GtkWidget *widget,\r
1649                                gint row, \r
1650                                gint column, \r
1651                                GdkEventButton *bevent,\r
1652                                gpointer user_data)\r
1653 {\r
1654   GtkFileSelection *fs = NULL;\r
1655   gchar *filename, *temp = NULL;\r
1656   \r
1657   g_return_if_fail (GTK_IS_CLIST (widget));\r
1658 \r
1659   fs = user_data;\r
1660   g_return_if_fail (fs != NULL);\r
1661   g_return_if_fail (GTK_IS_FILE_SELECTION (fs));\r
1662   \r
1663   gtk_clist_get_text (GTK_CLIST (fs->file_list), row, 0, &temp);\r
1664   filename = g_strdup (temp);\r
1665 \r
1666   if (filename)\r
1667     {\r
1668       if (bevent)\r
1669         switch (bevent->type)\r
1670           {\r
1671           case GDK_2BUTTON_PRESS:\r
1672             gtk_button_clicked (GTK_BUTTON (fs->ok_button));\r
1673             break;\r
1674             \r
1675           default:\r
1676             gtk_entry_set_text (GTK_ENTRY (fs->selection_entry), filename);\r
1677             break;\r
1678           }\r
1679       else\r
1680         gtk_entry_set_text (GTK_ENTRY (fs->selection_entry), filename);\r
1681       \r
1682       g_free (filename);\r
1683     }\r
1684 }\r
1685 \r
1686 static void\r
1687 gtk_file_selection_dir_button (GtkWidget *widget,\r
1688                                gint row, \r
1689                                gint column, \r
1690                                GdkEventButton *bevent,\r
1691                                gpointer user_data)\r
1692 {\r
1693   GList *list;\r
1694   GtkFileSelection *fs = NULL;\r
1695   gchar *filename, *temp = NULL;\r
1696 \r
1697   g_return_if_fail (GTK_IS_CLIST (widget));\r
1698 \r
1699   fs = GTK_FILE_SELECTION (user_data);\r
1700   g_return_if_fail (fs != NULL);\r
1701   g_return_if_fail (GTK_IS_FILE_SELECTION (fs));\r
1702 \r
1703   gtk_clist_get_text (GTK_CLIST (fs->dir_list), row, 0, &temp);\r
1704   filename = g_strdup (temp);\r
1705 \r
1706   if (filename)\r
1707     {\r
1708       if (bevent)\r
1709         switch (bevent->type)\r
1710           {\r
1711           case GDK_2BUTTON_PRESS:\r
1712             list = fs->next_history;\r
1713             if (list)\r
1714               {\r
1715                 g_free (list->data);\r
1716                 list = list->next;\r
1717               }\r
1718             g_list_free (fs->next_history);\r
1719             fs->next_history = NULL;\r
1720         \r
1721             gtk_file_selection_populate (fs, filename, FALSE);\r
1722             gtk_entry_set_text(GTK_ENTRY(fs->selection_entry),fs->saved_entry);\r
1723             g_free (fs->saved_entry);\r
1724             fs->saved_entry = NULL;\r
1725             break;\r
1726             \r
1727           default:\r
1728             /* here we need to add the "filename" to the beginning of what's already\r
1729                in the entry.  Save what's in the entry, then restore it on the double click\r
1730             */\r
1731             if (fs->saved_entry) g_free (fs->saved_entry);\r
1732             fs->saved_entry=g_strdup(gtk_entry_get_text(GTK_ENTRY (fs->selection_entry)));\r
1733         \r
1734             temp=g_strconcat(filename,fs->saved_entry,NULL);\r
1735             gtk_entry_set_text (GTK_ENTRY (fs->selection_entry), temp);\r
1736             g_free (temp);\r
1737         \r
1738             break;\r
1739           }\r
1740       else\r
1741         gtk_entry_set_text (GTK_ENTRY (fs->selection_entry), filename);\r
1742       \r
1743       g_free (filename);\r
1744     }\r
1745 }\r
1746 \r
1747 static void\r
1748 gtk_file_selection_undir_button (GtkWidget *widget,\r
1749                                gint row,\r
1750                                gint column,\r
1751                                GdkEventButton *bevent,\r
1752                                gpointer user_data)\r
1753 {\r
1754   GtkFileSelection *fs = NULL;\r
1755   gchar *filename, *temp = NULL;\r
1756 \r
1757   g_return_if_fail (GTK_IS_CLIST (widget));\r
1758 \r
1759   fs = GTK_FILE_SELECTION (user_data);\r
1760   g_return_if_fail (fs != NULL);\r
1761   g_return_if_fail (GTK_IS_FILE_SELECTION (fs));\r
1762 \r
1763   gtk_clist_get_text (GTK_CLIST (fs->dir_list), row, 0, &temp);\r
1764   filename = g_strdup (temp);\r
1765 \r
1766   if (filename)\r
1767     {\r
1768       if (bevent)\r
1769         switch (bevent->type)\r
1770           {\r
1771           default:\r
1772             /* here we need to add the "filename" to the beginning of what's already\r
1773                in the entry.  Save what's in the entry, then restore it on the double click\r
1774             */\r
1775             if (fs->saved_entry)\r
1776               {\r
1777                 gtk_entry_set_text (GTK_ENTRY (fs->selection_entry),fs->saved_entry);\r
1778                 g_free (fs->saved_entry);\r
1779                 fs->saved_entry = NULL;\r
1780               }\r
1781             break;\r
1782           }\r
1783       else\r
1784         gtk_entry_set_text (GTK_ENTRY (fs->selection_entry), filename); //?????\r
1785 \r
1786       g_free (filename);\r
1787     }\r
1788 }\r
1789 \r
1790 static void\r
1791 gtk_file_selection_populate (GtkFileSelection *fs,\r
1792                              gchar            *rel_path,\r
1793                              gint              try_complete)\r
1794 {\r
1795   CompletionState *cmpl_state;\r
1796   PossibleCompletion* poss;\r
1797   gchar* filename;\r
1798   gint row;\r
1799   gchar* rem_path = rel_path;\r
1800   gchar* sel_text;\r
1801   gchar* text[2];\r
1802   gint did_recurse = FALSE;\r
1803   gint possible_count = 0;\r
1804   gint selection_index = -1;\r
1805   gint file_list_width;\r
1806   gint dir_list_width;\r
1807   \r
1808   g_return_if_fail (fs != NULL);\r
1809   g_return_if_fail (GTK_IS_FILE_SELECTION (fs));\r
1810   \r
1811   cmpl_state = (CompletionState*) fs->cmpl_state;\r
1812   poss = cmpl_completion_matches (rel_path, &rem_path, cmpl_state);\r
1813 \r
1814   if (!cmpl_state_okay (cmpl_state))\r
1815     {\r
1816       /* Something went wrong. */\r
1817       gtk_file_selection_abort (fs);\r
1818       return;\r
1819     }\r
1820 \r
1821   g_assert (cmpl_state->reference_dir);\r
1822 \r
1823   gtk_clist_freeze (GTK_CLIST (fs->dir_list));\r
1824   gtk_clist_clear (GTK_CLIST (fs->dir_list));\r
1825   gtk_clist_freeze (GTK_CLIST (fs->file_list));\r
1826   gtk_clist_clear (GTK_CLIST (fs->file_list));\r
1827 \r
1828   /* Set the dir_list to include ./ and ../ */\r
1829   text[1] = NULL;\r
1830   text[0] = "./";\r
1831   row = gtk_clist_append (GTK_CLIST (fs->dir_list), text);\r
1832 \r
1833   text[0] = "../";\r
1834   row = gtk_clist_append (GTK_CLIST (fs->dir_list), text);\r
1835 \r
1836   /*reset the max widths of the lists*/\r
1837   dir_list_width = gdk_string_width(fs->dir_list->style->font,"../");\r
1838   gtk_clist_set_column_width(GTK_CLIST(fs->dir_list),0,dir_list_width);\r
1839   file_list_width = 1;\r
1840   gtk_clist_set_column_width(GTK_CLIST(fs->file_list),0,file_list_width);\r
1841 \r
1842   while (poss)\r
1843     {\r
1844       if (cmpl_is_a_completion (poss))\r
1845         {\r
1846           possible_count += 1;\r
1847           \r
1848           filename = cmpl_this_completion (poss);\r
1849 \r
1850           text[0] = filename;\r
1851           \r
1852           if (cmpl_is_directory (poss))\r
1853             {\r
1854               if (strcmp (filename, "./") != 0 &&\r
1855                   strcmp (filename, "../") != 0)\r
1856                 {\r
1857                   int width = gdk_string_width(fs->dir_list->style->font,\r
1858                                                filename);\r
1859                   row = gtk_clist_append (GTK_CLIST (fs->dir_list), text);\r
1860                   if(width > dir_list_width)\r
1861                     {\r
1862                       dir_list_width = width;\r
1863                       gtk_clist_set_column_width(GTK_CLIST(fs->dir_list),0,\r
1864                                                  width);\r
1865                     }\r
1866                 }\r
1867             }\r
1868           else\r
1869             {\r
1870               if(fs->mask)\r
1871                 {\r
1872                   if (gtk_file_selection_match_mask(filename,fs->mask))\r
1873                     {\r
1874                       int width = gdk_string_width(fs->file_list->style->font,\r
1875                                                    filename);\r
1876                       row = gtk_clist_append (GTK_CLIST (fs->file_list), text);\r
1877                       if(width > file_list_width)\r
1878                         {\r
1879                           file_list_width = width;\r
1880                           gtk_clist_set_column_width(GTK_CLIST(fs->file_list),0,\r
1881                                                      width);\r
1882                         }\r
1883                     }\r
1884                 }\r
1885               else\r
1886                 {\r
1887                   int width = gdk_string_width(fs->file_list->style->font,\r
1888                                                filename);\r
1889                   row = gtk_clist_append (GTK_CLIST (fs->file_list), text);\r
1890                   if(width > file_list_width)\r
1891                     {\r
1892                       file_list_width = width;\r
1893                       gtk_clist_set_column_width(GTK_CLIST(fs->file_list),0,\r
1894                                                  width);\r
1895                     }\r
1896                 }\r
1897             }\r
1898         }\r
1899 \r
1900       poss = cmpl_next_completion (cmpl_state);\r
1901     }\r
1902 \r
1903   gtk_clist_thaw (GTK_CLIST (fs->dir_list));\r
1904   gtk_clist_thaw (GTK_CLIST (fs->file_list));\r
1905 \r
1906   /* File lists are set. */\r
1907 \r
1908   g_assert (cmpl_state->reference_dir);\r
1909 \r
1910   if (try_complete)\r
1911     {\r
1912 \r
1913       /* User is trying to complete filenames, so advance the user's input\r
1914        * string to the updated_text, which is the common leading substring\r
1915        * of all possible completions, and if its a directory attempt\r
1916        * attempt completions in it. */\r
1917 \r
1918       if (cmpl_updated_text (cmpl_state)[0])\r
1919         {\r
1920 \r
1921           if (cmpl_updated_dir (cmpl_state))\r
1922             {\r
1923               gchar* dir_name = g_strdup (cmpl_updated_text (cmpl_state));\r
1924 \r
1925               did_recurse = TRUE;\r
1926 \r
1927               gtk_file_selection_populate (fs, dir_name, TRUE);\r
1928 \r
1929               g_free (dir_name);\r
1930             }\r
1931           else\r
1932             {\r
1933               if (fs->selection_entry)\r
1934                       gtk_entry_set_text (GTK_ENTRY (fs->selection_entry),\r
1935                                           cmpl_updated_text (cmpl_state));\r
1936             }\r
1937         }\r
1938       else\r
1939         {\r
1940           selection_index = cmpl_last_valid_char (cmpl_state) -\r
1941                             (strlen (rel_path) - strlen (rem_path));\r
1942           if (fs->selection_entry)\r
1943             gtk_entry_set_text (GTK_ENTRY (fs->selection_entry), rem_path);\r
1944         }\r
1945     }\r
1946   else\r
1947     {\r
1948       if (fs->selection_entry)\r
1949       /* Here we need to take the old filename and keep it!*/\r
1950         /*gtk_entry_set_text (GTK_ENTRY (fs->selection_entry), "");*/\r
1951         ;\r
1952     }\r
1953 \r
1954   if (!did_recurse)\r
1955     {\r
1956       if (fs->selection_entry)\r
1957         gtk_entry_set_position (GTK_ENTRY (fs->selection_entry), selection_index);\r
1958 \r
1959       if (fs->selection_entry)\r
1960         {\r
1961           sel_text = g_strconcat (_("Selection: "),\r
1962                                   cmpl_reference_position (cmpl_state),\r
1963                                   NULL);\r
1964 \r
1965           gtk_label_set_text (GTK_LABEL (fs->selection_text), sel_text);\r
1966           g_free (sel_text);\r
1967         }\r
1968 \r
1969   gtk_file_selection_update_history_menu (fs, cmpl_reference_position (cmpl_state));\r
1970 \r
1971     }\r
1972 }\r
1973 \r
1974 static void\r
1975 gtk_file_selection_abort (GtkFileSelection *fs)\r
1976 {\r
1977   gchar err_buf[256];\r
1978 \r
1979   sprintf (err_buf, _("Directory unreadable: %s"), cmpl_strerror (cmpl_errno));\r
1980 \r
1981   /*  BEEP gdk_beep();  */\r
1982 \r
1983   if (fs->selection_entry)\r
1984     gtk_label_set_text (GTK_LABEL (fs->selection_text), err_buf);\r
1985 }\r
1986 \r
1987 /**********************************************************************/\r
1988 /*                        External Interface                          */\r
1989 /**********************************************************************/\r
1990 \r
1991 /* The four completion state selectors\r
1992  */\r
1993 static gchar*\r
1994 cmpl_updated_text (CompletionState* cmpl_state)\r
1995 {\r
1996   return cmpl_state->updated_text;\r
1997 }\r
1998 \r
1999 static gint\r
2000 cmpl_updated_dir (CompletionState* cmpl_state)\r
2001 {\r
2002   return cmpl_state->re_complete;\r
2003 }\r
2004 \r
2005 static gchar*\r
2006 cmpl_reference_position (CompletionState* cmpl_state)\r
2007 {\r
2008   return cmpl_state->reference_dir->fullname;\r
2009 }\r
2010 \r
2011 static gint\r
2012 cmpl_last_valid_char (CompletionState* cmpl_state)\r
2013 {\r
2014   return cmpl_state->last_valid_char;\r
2015 }\r
2016 \r
2017 static gchar*\r
2018 cmpl_completion_fullname (gchar* text, CompletionState* cmpl_state)\r
2019 {\r
2020   static char nothing[2] = "";\r
2021 \r
2022   if (!cmpl_state_okay (cmpl_state))\r
2023     {\r
2024       return nothing;\r
2025     }\r
2026   else if (text[0] == '/')\r
2027     {\r
2028       strcpy (cmpl_state->updated_text, text);\r
2029     }\r
2030   else if (text[0] == '~')\r
2031     {\r
2032       CompletionDir* dir;\r
2033       char* slash;\r
2034 \r
2035       dir = open_user_dir (text, cmpl_state);\r
2036 \r
2037       if (!dir)\r
2038         {\r
2039           /* spencer says just return ~something, so\r
2040            * for now just do it. */\r
2041           strcpy (cmpl_state->updated_text, text);\r
2042         }\r
2043       else\r
2044         {\r
2045 \r
2046           strcpy (cmpl_state->updated_text, dir->fullname);\r
2047 \r
2048           slash = strchr (text, '/');\r
2049 \r
2050           if (slash)\r
2051             strcat (cmpl_state->updated_text, slash);\r
2052         }\r
2053     }\r
2054   else\r
2055     {\r
2056       strcpy (cmpl_state->updated_text, cmpl_state->reference_dir->fullname);\r
2057       if (strcmp (cmpl_state->reference_dir->fullname, "/") != 0)\r
2058         strcat (cmpl_state->updated_text, "/");\r
2059       strcat (cmpl_state->updated_text, text);\r
2060     }\r
2061 \r
2062   return cmpl_state->updated_text;\r
2063 }\r
2064 \r
2065 /* The three completion selectors\r
2066  */\r
2067 static gchar*\r
2068 cmpl_this_completion (PossibleCompletion* pc)\r
2069 {\r
2070   return pc->text;\r
2071 }\r
2072 \r
2073 static gint\r
2074 cmpl_is_directory (PossibleCompletion* pc)\r
2075 {\r
2076   return pc->is_directory;\r
2077 }\r
2078 \r
2079 static gint\r
2080 cmpl_is_a_completion (PossibleCompletion* pc)\r
2081 {\r
2082   return pc->is_a_completion;\r
2083 }\r
2084 \r
2085 /**********************************************************************/\r
2086 /*                       Construction, deletion                       */\r
2087 /**********************************************************************/\r
2088 \r
2089 static CompletionState*\r
2090 cmpl_init_state (void)\r
2091 {\r
2092   gchar getcwd_buf[2*MAXPATHLEN];\r
2093   CompletionState *new_state;\r
2094 \r
2095   new_state = g_new (CompletionState, 1);\r
2096 \r
2097   /* We don't use getcwd() on SUNOS, because, it does a popen("pwd")\r
2098    * and, if that wasn't bad enough, hangs in doing so.\r
2099    */\r
2100 #if defined(sun) && !defined(__SVR4)\r
2101   if (!getwd (getcwd_buf))\r
2102 #else    \r
2103   if (!getcwd (getcwd_buf, MAXPATHLEN))\r
2104 #endif    \r
2105     {\r
2106       /* Oh joy, we can't get the current directory. Um..., we should have\r
2107        * a root directory, right? Right? (Probably not portable to non-Unix)\r
2108        */\r
2109       strcpy (getcwd_buf, "/");\r
2110     }\r
2111 \r
2112 tryagain:\r
2113 \r
2114   new_state->reference_dir = NULL;\r
2115   new_state->completion_dir = NULL;\r
2116   new_state->active_completion_dir = NULL;\r
2117   new_state->directory_storage = NULL;\r
2118   new_state->directory_sent_storage = NULL;\r
2119   new_state->last_valid_char = 0;\r
2120   new_state->updated_text = g_new (gchar, MAXPATHLEN);\r
2121   new_state->updated_text_alloc = MAXPATHLEN;\r
2122   new_state->the_completion.text = g_new (gchar, MAXPATHLEN);\r
2123   new_state->the_completion.text_alloc = MAXPATHLEN;\r
2124   new_state->user_dir_name_buffer = NULL;\r
2125   new_state->user_directories = NULL;\r
2126 \r
2127   new_state->reference_dir =  open_dir (getcwd_buf, new_state);\r
2128 \r
2129   if (!new_state->reference_dir)\r
2130     {\r
2131       /* Directories changing from underneath us, grumble */\r
2132       strcpy (getcwd_buf, "/");\r
2133       goto tryagain;\r
2134     }\r
2135 \r
2136   return new_state;\r
2137 }\r
2138 \r
2139 static void\r
2140 cmpl_free_dir_list(GList* dp0)\r
2141 {\r
2142   GList *dp = dp0;\r
2143 \r
2144   while (dp) {\r
2145     free_dir (dp->data);\r
2146     dp = dp->next;\r
2147   }\r
2148 \r
2149   g_list_free(dp0);\r
2150 }\r
2151 \r
2152 static void\r
2153 cmpl_free_dir_sent_list(GList* dp0)\r
2154 {\r
2155   GList *dp = dp0;\r
2156 \r
2157   while (dp) {\r
2158     free_dir_sent (dp->data);\r
2159     dp = dp->next;\r
2160   }\r
2161 \r
2162   g_list_free(dp0);\r
2163 }\r
2164 \r
2165 static void\r
2166 cmpl_free_state (CompletionState* cmpl_state)\r
2167 {\r
2168   cmpl_free_dir_list (cmpl_state->directory_storage);\r
2169   cmpl_free_dir_sent_list (cmpl_state->directory_sent_storage);\r
2170 \r
2171   if (cmpl_state->user_dir_name_buffer)\r
2172     g_free (cmpl_state->user_dir_name_buffer);\r
2173   if (cmpl_state->user_directories)\r
2174     g_free (cmpl_state->user_directories);\r
2175   if (cmpl_state->the_completion.text)\r
2176     g_free (cmpl_state->the_completion.text);\r
2177   if (cmpl_state->updated_text)\r
2178     g_free (cmpl_state->updated_text);\r
2179 \r
2180   g_free (cmpl_state);\r
2181 }\r
2182 \r
2183 static void\r
2184 free_dir(CompletionDir* dir)\r
2185 {\r
2186   g_free(dir->fullname);\r
2187   g_free(dir);\r
2188 }\r
2189 \r
2190 static void\r
2191 free_dir_sent(CompletionDirSent* sent)\r
2192 {\r
2193   g_free(sent->name_buffer);\r
2194   g_free(sent->entries);\r
2195   g_free(sent);\r
2196 }\r
2197 \r
2198 static void\r
2199 prune_memory_usage(CompletionState *cmpl_state)\r
2200 {\r
2201   GList* cdsl = cmpl_state->directory_sent_storage;\r
2202   GList* cdl = cmpl_state->directory_storage;\r
2203   GList* cdl0 = cdl;\r
2204   gint len = 0;\r
2205 \r
2206   for(; cdsl && len < CMPL_DIRECTORY_CACHE_SIZE; len += 1)\r
2207     cdsl = cdsl->next;\r
2208 \r
2209   if (cdsl) {\r
2210     cmpl_free_dir_sent_list(cdsl->next);\r
2211     cdsl->next = NULL;\r
2212   }\r
2213 \r
2214   cmpl_state->directory_storage = NULL;\r
2215   while (cdl) {\r
2216     if (cdl->data == cmpl_state->reference_dir)\r
2217       cmpl_state->directory_storage = g_list_prepend(NULL, cdl->data);\r
2218     else\r
2219       free_dir (cdl->data);\r
2220     cdl = cdl->next;\r
2221   }\r
2222 \r
2223   g_list_free(cdl0);\r
2224 }\r
2225 \r
2226 /**********************************************************************/\r
2227 /*                        The main entrances.                         */\r
2228 /**********************************************************************/\r
2229 \r
2230 static PossibleCompletion*\r
2231 cmpl_completion_matches (gchar* text_to_complete,\r
2232                          gchar** remaining_text,\r
2233                          CompletionState* cmpl_state)\r
2234 {\r
2235   gchar* first_slash;\r
2236   PossibleCompletion *poss;\r
2237 \r
2238   prune_memory_usage(cmpl_state);\r
2239 \r
2240   g_assert (text_to_complete != NULL);\r
2241 \r
2242   cmpl_state->user_completion_index = -1;\r
2243   cmpl_state->last_completion_text = text_to_complete;\r
2244   cmpl_state->the_completion.text[0] = 0;\r
2245   cmpl_state->last_valid_char = 0;\r
2246   cmpl_state->updated_text_len = -1;\r
2247   cmpl_state->updated_text[0] = 0;\r
2248   cmpl_state->re_complete = FALSE;\r
2249 \r
2250   first_slash = strchr (text_to_complete, '/');\r
2251 \r
2252   if (text_to_complete[0] == '~' && !first_slash)\r
2253     {\r
2254       /* Text starts with ~ and there is no slash, show all the\r
2255        * home directory completions.\r
2256        */\r
2257       poss = attempt_homedir_completion (text_to_complete, cmpl_state);\r
2258 \r
2259       update_cmpl(poss, cmpl_state);\r
2260 \r
2261       return poss;\r
2262     }\r
2263 \r
2264   cmpl_state->reference_dir =\r
2265     open_ref_dir (text_to_complete, remaining_text, cmpl_state);\r
2266 \r
2267   if(!cmpl_state->reference_dir)\r
2268     return NULL;\r
2269 \r
2270   cmpl_state->completion_dir =\r
2271     find_completion_dir (*remaining_text, remaining_text, cmpl_state);\r
2272 \r
2273   cmpl_state->last_valid_char = *remaining_text - text_to_complete;\r
2274 \r
2275   if(!cmpl_state->completion_dir)\r
2276     return NULL;\r
2277 \r
2278   cmpl_state->completion_dir->cmpl_index = -1;\r
2279   cmpl_state->completion_dir->cmpl_parent = NULL;\r
2280   cmpl_state->completion_dir->cmpl_text = *remaining_text;\r
2281 \r
2282   cmpl_state->active_completion_dir = cmpl_state->completion_dir;\r
2283 \r
2284   cmpl_state->reference_dir = cmpl_state->completion_dir;\r
2285 \r
2286   poss = attempt_file_completion(cmpl_state);\r
2287 \r
2288   update_cmpl(poss, cmpl_state);\r
2289 \r
2290   return poss;\r
2291 }\r
2292 \r
2293 static PossibleCompletion*\r
2294 cmpl_next_completion (CompletionState* cmpl_state)\r
2295 {\r
2296   PossibleCompletion* poss = NULL;\r
2297 \r
2298   cmpl_state->the_completion.text[0] = 0;\r
2299 \r
2300   if(cmpl_state->user_completion_index >= 0)\r
2301     poss = attempt_homedir_completion(cmpl_state->last_completion_text, cmpl_state);\r
2302   else\r
2303     poss = attempt_file_completion(cmpl_state);\r
2304 \r
2305   update_cmpl(poss, cmpl_state);\r
2306 \r
2307   return poss;\r
2308 }\r
2309 \r
2310 /**********************************************************************/\r
2311 /*                       Directory Operations                         */\r
2312 /**********************************************************************/\r
2313 \r
2314 /* Open the directory where completion will begin from, if possible. */\r
2315 static CompletionDir*\r
2316 open_ref_dir(gchar* text_to_complete,\r
2317              gchar** remaining_text,\r
2318              CompletionState* cmpl_state)\r
2319 {\r
2320   gchar* first_slash;\r
2321   CompletionDir *new_dir;\r
2322 \r
2323   first_slash = strchr(text_to_complete, '/');\r
2324 \r
2325   if (text_to_complete[0] == '~')\r
2326     {\r
2327       new_dir = open_user_dir(text_to_complete, cmpl_state);\r
2328 \r
2329       if(new_dir)\r
2330         {\r
2331           if(first_slash)\r
2332             *remaining_text = first_slash + 1;\r
2333           else\r
2334             *remaining_text = text_to_complete + strlen(text_to_complete);\r
2335         }\r
2336       else\r
2337         {\r
2338           return NULL;\r
2339         }\r
2340     }\r
2341   else if (text_to_complete[0] == '/' || !cmpl_state->reference_dir)\r
2342     {\r
2343       gchar *tmp = g_strdup(text_to_complete);\r
2344       gchar *p;\r
2345 \r
2346       p = tmp;\r
2347       while (*p && *p != '*' && *p != '?')\r
2348         p++;\r
2349 \r
2350       *p = '\0';\r
2351       p = strrchr(tmp, '/');\r
2352       if (p)\r
2353         {\r
2354           if (p == tmp)\r
2355             p++;\r
2356       \r
2357           *p = '\0';\r
2358 \r
2359           new_dir = open_dir(tmp, cmpl_state);\r
2360 \r
2361           if(new_dir)\r
2362             *remaining_text = text_to_complete + \r
2363               ((p == tmp + 1) ? (p - tmp) : (p + 1 - tmp));\r
2364         }\r
2365       else\r
2366         {\r
2367           /* If no possible candidates, use the cwd */\r
2368           gchar *curdir = g_get_current_dir ();\r
2369           \r
2370           new_dir = open_dir(curdir, cmpl_state);\r
2371 \r
2372           if (new_dir)\r
2373             *remaining_text = text_to_complete;\r
2374 \r
2375           g_free (curdir);\r
2376         }\r
2377 \r
2378       g_free (tmp);\r
2379     }\r
2380   else\r
2381     {\r
2382       *remaining_text = text_to_complete;\r
2383 \r
2384       new_dir = open_dir(cmpl_state->reference_dir->fullname, cmpl_state);\r
2385     }\r
2386 \r
2387   if(new_dir)\r
2388     {\r
2389       new_dir->cmpl_index = -1;\r
2390       new_dir->cmpl_parent = NULL;\r
2391     }\r
2392 \r
2393   return new_dir;\r
2394 }\r
2395 \r
2396 /* open a directory by user name */\r
2397 static CompletionDir*\r
2398 open_user_dir(gchar* text_to_complete,\r
2399               CompletionState *cmpl_state)\r
2400 {\r
2401   gchar *first_slash;\r
2402   gint cmp_len;\r
2403 \r
2404   g_assert(text_to_complete && text_to_complete[0] == '~');\r
2405 \r
2406   first_slash = strchr(text_to_complete, '/');\r
2407 \r
2408   if (first_slash)\r
2409     cmp_len = first_slash - text_to_complete - 1;\r
2410   else\r
2411     cmp_len = strlen(text_to_complete + 1);\r
2412 \r
2413   if(!cmp_len)\r
2414     {\r
2415       /* ~/ */\r
2416       gchar *homedir = g_get_home_dir ();\r
2417 \r
2418       if (homedir)\r
2419         return open_dir(homedir, cmpl_state);\r
2420       else\r
2421         return NULL;\r
2422     }\r
2423   else\r
2424     {\r
2425       /* ~user/ */\r
2426       char* copy = g_new(char, cmp_len + 1);\r
2427       struct passwd *pwd;\r
2428       strncpy(copy, text_to_complete + 1, cmp_len);\r
2429       copy[cmp_len] = 0;\r
2430       pwd = getpwnam(copy);\r
2431       g_free(copy);\r
2432       if (!pwd)\r
2433         {\r
2434           cmpl_errno = errno;\r
2435           return NULL;\r
2436         }\r
2437 \r
2438       return open_dir(pwd->pw_dir, cmpl_state);\r
2439     }\r
2440 }\r
2441 \r
2442 /* open a directory relative the the current relative directory */\r
2443 static CompletionDir*\r
2444 open_relative_dir(gchar* dir_name,\r
2445                   CompletionDir* dir,\r
2446                   CompletionState *cmpl_state)\r
2447 {\r
2448   gchar path_buf[2*MAXPATHLEN];\r
2449 \r
2450   if(dir->fullname_len + strlen(dir_name) + 2 >= MAXPATHLEN)\r
2451     {\r
2452       cmpl_errno = CMPL_ERRNO_TOO_LONG;\r
2453       return NULL;\r
2454     }\r
2455 \r
2456   strcpy(path_buf, dir->fullname);\r
2457 \r
2458   if(dir->fullname_len > 1)\r
2459     {\r
2460       path_buf[dir->fullname_len] = '/';\r
2461       strcpy(path_buf + dir->fullname_len + 1, dir_name);\r
2462     }\r
2463   else\r
2464     {\r
2465       strcpy(path_buf + dir->fullname_len, dir_name);\r
2466     }\r
2467 \r
2468   return open_dir(path_buf, cmpl_state);\r
2469 }\r
2470 \r
2471 /* after the cache lookup fails, really open a new directory */\r
2472 static CompletionDirSent*\r
2473 open_new_dir(gchar* dir_name, struct stat* sbuf, gboolean stat_subdirs)\r
2474 {\r
2475   CompletionDirSent* sent;\r
2476   DIR* directory;\r
2477   gchar *buffer_ptr;\r
2478   struct dirent *dirent_ptr;\r
2479   gint buffer_size = 0;\r
2480   gint entry_count = 0;\r
2481   gint i;\r
2482   struct stat ent_sbuf;\r
2483   char path_buf[MAXPATHLEN*2];\r
2484   gint path_buf_len;\r
2485 \r
2486   sent = g_new(CompletionDirSent, 1);\r
2487   sent->mtime = sbuf->st_mtime;\r
2488   sent->inode = sbuf->st_ino;\r
2489   sent->device = sbuf->st_dev;\r
2490 \r
2491   path_buf_len = strlen(dir_name);\r
2492 \r
2493   if (path_buf_len > MAXPATHLEN)\r
2494     {\r
2495       cmpl_errno = CMPL_ERRNO_TOO_LONG;\r
2496       return NULL;\r
2497     }\r
2498 \r
2499   strcpy(path_buf, dir_name);\r
2500 \r
2501   directory = opendir(dir_name);\r
2502 \r
2503   if(!directory)\r
2504     {\r
2505       cmpl_errno = errno;\r
2506       return NULL;\r
2507     }\r
2508 \r
2509   while((dirent_ptr = readdir(directory)) != NULL)\r
2510     {\r
2511       int entry_len = strlen(dirent_ptr->d_name);\r
2512       buffer_size += entry_len + 1;\r
2513       entry_count += 1;\r
2514 \r
2515       if(path_buf_len + entry_len + 2 >= MAXPATHLEN)\r
2516         {\r
2517           cmpl_errno = CMPL_ERRNO_TOO_LONG;\r
2518           closedir(directory);\r
2519           return NULL;\r
2520         }\r
2521     }\r
2522 \r
2523   sent->name_buffer = g_new(gchar, buffer_size);\r
2524   sent->entries = g_new(CompletionDirEntry, entry_count);\r
2525   sent->entry_count = entry_count;\r
2526 \r
2527   buffer_ptr = sent->name_buffer;\r
2528 \r
2529   rewinddir(directory);\r
2530 \r
2531   for(i = 0; i < entry_count; i += 1)\r
2532     {\r
2533       dirent_ptr = readdir(directory);\r
2534 \r
2535       if(!dirent_ptr)\r
2536         {\r
2537           cmpl_errno = errno;\r
2538           closedir(directory);\r
2539           return NULL;\r
2540         }\r
2541 \r
2542       strcpy(buffer_ptr, dirent_ptr->d_name);\r
2543       sent->entries[i].entry_name = buffer_ptr;\r
2544       buffer_ptr += strlen(dirent_ptr->d_name);\r
2545       *buffer_ptr = 0;\r
2546       buffer_ptr += 1;\r
2547 \r
2548       path_buf[path_buf_len] = '/';\r
2549       strcpy(path_buf + path_buf_len + 1, dirent_ptr->d_name);\r
2550 \r
2551       if (stat_subdirs)\r
2552         {\r
2553           if(stat(path_buf, &ent_sbuf) >= 0 && S_ISDIR(ent_sbuf.st_mode))\r
2554             sent->entries[i].is_dir = 1;\r
2555           else\r
2556             /* stat may fail, and we don't mind, since it could be a\r
2557              * dangling symlink. */\r
2558             sent->entries[i].is_dir = 0;\r
2559         }\r
2560       else\r
2561         sent->entries[i].is_dir = 1;\r
2562     }\r
2563 \r
2564   qsort(sent->entries, sent->entry_count, sizeof(CompletionDirEntry), compare_cmpl_dir);\r
2565 \r
2566   closedir(directory);\r
2567 \r
2568   return sent;\r
2569 }\r
2570 \r
2571 static gboolean\r
2572 check_dir(gchar *dir_name, struct stat *result, gboolean *stat_subdirs)\r
2573 {\r
2574   /* A list of directories that we know only contain other directories.\r
2575    * Trying to stat every file in these directories would be very\r
2576    * expensive.\r
2577    */\r
2578 \r
2579   static struct {\r
2580     gchar *name;\r
2581     gboolean present;\r
2582     struct stat statbuf;\r
2583   } no_stat_dirs[] = {\r
2584     { "/afs", FALSE, { 0 } },\r
2585     { "/net", FALSE, { 0 } }\r
2586   };\r
2587 \r
2588   static const gint n_no_stat_dirs = sizeof(no_stat_dirs) / sizeof(no_stat_dirs[0]);\r
2589   static gboolean initialized = FALSE;\r
2590 \r
2591   gint i;\r
2592 \r
2593   if (!initialized)\r
2594     {\r
2595       initialized = TRUE;\r
2596       for (i = 0; i < n_no_stat_dirs; i++)\r
2597         {\r
2598           if (stat (no_stat_dirs[i].name, &no_stat_dirs[i].statbuf) == 0)\r
2599             no_stat_dirs[i].present = TRUE;\r
2600         }\r
2601     }\r
2602 \r
2603   if(stat(dir_name, result) < 0)\r
2604     {\r
2605       cmpl_errno = errno;\r
2606       return FALSE;\r
2607     }\r
2608 \r
2609   *stat_subdirs = TRUE;\r
2610   for (i=0; i<n_no_stat_dirs; i++)\r
2611     {\r
2612       if (no_stat_dirs[i].present &&\r
2613           (no_stat_dirs[i].statbuf.st_dev == result->st_dev) &&\r
2614           (no_stat_dirs[i].statbuf.st_ino == result->st_ino))\r
2615         {\r
2616           *stat_subdirs = FALSE;\r
2617           break;\r
2618         }\r
2619     }\r
2620 \r
2621   return TRUE;\r
2622 }\r
2623 \r
2624 /* open a directory by absolute pathname */\r
2625 static CompletionDir*\r
2626 open_dir(gchar* dir_name, CompletionState* cmpl_state)\r
2627 {\r
2628   struct stat sbuf;\r
2629   gboolean stat_subdirs;\r
2630   CompletionDirSent *sent;\r
2631   GList* cdsl;\r
2632 \r
2633   if (!check_dir (dir_name, &sbuf, &stat_subdirs))\r
2634     return NULL;\r
2635 \r
2636   cdsl = cmpl_state->directory_sent_storage;\r
2637 \r
2638   while (cdsl)\r
2639     {\r
2640       sent = cdsl->data;\r
2641 \r
2642       if(sent->inode == sbuf.st_ino &&\r
2643          sent->mtime == sbuf.st_mtime &&\r
2644          sent->device == sbuf.st_dev)\r
2645         return attach_dir(sent, dir_name, cmpl_state);\r
2646 \r
2647       cdsl = cdsl->next;\r
2648     }\r
2649 \r
2650   sent = open_new_dir(dir_name, &sbuf, stat_subdirs);\r
2651 \r
2652   if (sent) {\r
2653     cmpl_state->directory_sent_storage =\r
2654       g_list_prepend(cmpl_state->directory_sent_storage, sent);\r
2655 \r
2656     return attach_dir(sent, dir_name, cmpl_state);\r
2657   }\r
2658 \r
2659   return NULL;\r
2660 }\r
2661 \r
2662 static CompletionDir*\r
2663 attach_dir(CompletionDirSent* sent, gchar* dir_name, CompletionState *cmpl_state)\r
2664 {\r
2665   CompletionDir* new_dir;\r
2666 \r
2667   new_dir = g_new(CompletionDir, 1);\r
2668 \r
2669   cmpl_state->directory_storage =\r
2670     g_list_prepend(cmpl_state->directory_storage, new_dir);\r
2671 \r
2672   new_dir->sent = sent;\r
2673   new_dir->fullname = g_strdup(dir_name);\r
2674   new_dir->fullname_len = strlen(dir_name);\r
2675 \r
2676   return new_dir;\r
2677 }\r
2678 \r
2679 static gint\r
2680 correct_dir_fullname(CompletionDir* cmpl_dir)\r
2681 {\r
2682   gint length = strlen(cmpl_dir->fullname);\r
2683   struct stat sbuf;\r
2684 \r
2685   if (strcmp(cmpl_dir->fullname + length - 2, "/.") == 0)\r
2686     {\r
2687       if (length == 2) \r
2688         {\r
2689           strcpy(cmpl_dir->fullname, "/");\r
2690           cmpl_dir->fullname_len = 1;\r
2691           return TRUE;\r
2692         } else {\r
2693           cmpl_dir->fullname[length - 2] = 0;\r
2694         }\r
2695     }\r
2696   else if (strcmp(cmpl_dir->fullname + length - 3, "/./") == 0)\r
2697     cmpl_dir->fullname[length - 2] = 0;\r
2698   else if (strcmp(cmpl_dir->fullname + length - 3, "/..") == 0)\r
2699     {\r
2700       if(length == 3)\r
2701         {\r
2702           strcpy(cmpl_dir->fullname, "/");\r
2703           cmpl_dir->fullname_len = 1;\r
2704           return TRUE;\r
2705         }\r
2706 \r
2707       if(stat(cmpl_dir->fullname, &sbuf) < 0)\r
2708         {\r
2709           cmpl_errno = errno;\r
2710           return FALSE;\r
2711         }\r
2712 \r
2713       cmpl_dir->fullname[length - 2] = 0;\r
2714 \r
2715       if(!correct_parent(cmpl_dir, &sbuf))\r
2716         return FALSE;\r
2717     }\r
2718   else if (strcmp(cmpl_dir->fullname + length - 4, "/../") == 0)\r
2719     {\r
2720       if(length == 4)\r
2721         {\r
2722           strcpy(cmpl_dir->fullname, "/");\r
2723           cmpl_dir->fullname_len = 1;\r
2724           return TRUE;\r
2725         }\r
2726 \r
2727       if(stat(cmpl_dir->fullname, &sbuf) < 0)\r
2728         {\r
2729           cmpl_errno = errno;\r
2730           return FALSE;\r
2731         }\r
2732 \r
2733       cmpl_dir->fullname[length - 3] = 0;\r
2734 \r
2735       if(!correct_parent(cmpl_dir, &sbuf))\r
2736         return FALSE;\r
2737     }\r
2738 \r
2739   cmpl_dir->fullname_len = strlen(cmpl_dir->fullname);\r
2740 \r
2741   return TRUE;\r
2742 }\r
2743 \r
2744 static gint\r
2745 correct_parent(CompletionDir* cmpl_dir, struct stat *sbuf)\r
2746 {\r
2747   struct stat parbuf;\r
2748   gchar *last_slash;\r
2749   gchar *new_name;\r
2750   gchar c = 0;\r
2751 \r
2752   last_slash = strrchr(cmpl_dir->fullname, '/');\r
2753 \r
2754   g_assert(last_slash);\r
2755 \r
2756   if(last_slash != cmpl_dir->fullname)\r
2757     { /* last_slash[0] = 0; */ }\r
2758   else\r
2759     {\r
2760       c = last_slash[1];\r
2761       last_slash[1] = 0;\r
2762     }\r
2763 \r
2764   if (stat(cmpl_dir->fullname, &parbuf) < 0)\r
2765     {\r
2766       cmpl_errno = errno;\r
2767       return FALSE;\r
2768     }\r
2769 \r
2770   if (parbuf.st_ino == sbuf->st_ino && parbuf.st_dev == sbuf->st_dev)\r
2771     /* it wasn't a link */\r
2772     return TRUE;\r
2773 \r
2774   if(c)\r
2775     last_slash[1] = c;\r
2776   /* else\r
2777     last_slash[0] = '/'; */\r
2778 \r
2779   /* it was a link, have to figure it out the hard way */\r
2780 \r
2781   new_name = find_parent_dir_fullname(cmpl_dir->fullname);\r
2782 \r
2783   if (!new_name)\r
2784     return FALSE;\r
2785 \r
2786   g_free(cmpl_dir->fullname);\r
2787 \r
2788   cmpl_dir->fullname = new_name;\r
2789 \r
2790   return TRUE;\r
2791 }\r
2792 \r
2793 static gchar*\r
2794 find_parent_dir_fullname(gchar* dirname)\r
2795 {\r
2796   gchar buffer[MAXPATHLEN];\r
2797   gchar buffer2[MAXPATHLEN];\r
2798 \r
2799 #if defined(sun) && !defined(__SVR4)\r
2800   if(!getwd(buffer))\r
2801 #else\r
2802   if(!getcwd(buffer, MAXPATHLEN))\r
2803 #endif    \r
2804     {\r
2805       cmpl_errno = errno;\r
2806       return NULL;\r
2807     }\r
2808 \r
2809   if(chdir(dirname) != 0 || chdir("..") != 0)\r
2810     {\r
2811       cmpl_errno = errno;\r
2812       return NULL;\r
2813     }\r
2814 \r
2815 #if defined(sun) && !defined(__SVR4)\r
2816   if(!getwd(buffer2))\r
2817 #else\r
2818   if(!getcwd(buffer2, MAXPATHLEN))\r
2819 #endif\r
2820     {\r
2821       chdir(buffer);\r
2822       cmpl_errno = errno;\r
2823 \r
2824       return NULL;\r
2825     }\r
2826 \r
2827   if(chdir(buffer) != 0)\r
2828     {\r
2829       cmpl_errno = errno;\r
2830       return NULL;\r
2831     }\r
2832 \r
2833   return g_strdup(buffer2);\r
2834 }\r
2835 \r
2836 /**********************************************************************/\r
2837 /*                        Completion Operations                       */\r
2838 /**********************************************************************/\r
2839 \r
2840 static PossibleCompletion*\r
2841 attempt_homedir_completion(gchar* text_to_complete,\r
2842                            CompletionState *cmpl_state)\r
2843 {\r
2844   gint index, length;\r
2845 \r
2846   if (!cmpl_state->user_dir_name_buffer &&\r
2847       !get_pwdb(cmpl_state))\r
2848     return NULL;\r
2849   length = strlen(text_to_complete) - 1;\r
2850 \r
2851   cmpl_state->user_completion_index += 1;\r
2852 \r
2853   while(cmpl_state->user_completion_index < cmpl_state->user_directories_len)\r
2854     {\r
2855       index = first_diff_index(text_to_complete + 1,\r
2856                                cmpl_state->user_directories\r
2857                                [cmpl_state->user_completion_index].login);\r
2858 \r
2859       switch(index)\r
2860         {\r
2861         case PATTERN_MATCH:\r
2862           break;\r
2863         default:\r
2864           if(cmpl_state->last_valid_char < (index + 1))\r
2865             cmpl_state->last_valid_char = index + 1;\r
2866           cmpl_state->user_completion_index += 1;\r
2867           continue;\r
2868         }\r
2869 \r
2870       cmpl_state->the_completion.is_a_completion = 1;\r
2871       cmpl_state->the_completion.is_directory = 1;\r
2872 \r
2873       append_completion_text("~", cmpl_state);\r
2874 \r
2875       append_completion_text(cmpl_state->\r
2876                               user_directories[cmpl_state->user_completion_index].login,\r
2877                              cmpl_state);\r
2878 \r
2879       return append_completion_text("/", cmpl_state);\r
2880     }\r
2881 \r
2882   if(text_to_complete[1] ||\r
2883      cmpl_state->user_completion_index > cmpl_state->user_directories_len)\r
2884     {\r
2885       cmpl_state->user_completion_index = -1;\r
2886       return NULL;\r
2887     }\r
2888   else\r
2889     {\r
2890       cmpl_state->user_completion_index += 1;\r
2891       cmpl_state->the_completion.is_a_completion = 1;\r
2892       cmpl_state->the_completion.is_directory = 1;\r
2893 \r
2894       return append_completion_text("~/", cmpl_state);\r
2895     }\r
2896 }\r
2897 \r
2898 /* returns the index (>= 0) of the first differing character,\r
2899  * PATTERN_MATCH if the completion matches */\r
2900 static gint\r
2901 first_diff_index(gchar* pat, gchar* text)\r
2902 {\r
2903   gint diff = 0;\r
2904 \r
2905   while(*pat && *text && *text == *pat)\r
2906     {\r
2907       pat += 1;\r
2908       text += 1;\r
2909       diff += 1;\r
2910     }\r
2911 \r
2912   if(*pat)\r
2913     return diff;\r
2914 \r
2915   return PATTERN_MATCH;\r
2916 }\r
2917 \r
2918 static PossibleCompletion*\r
2919 append_completion_text(gchar* text, CompletionState* cmpl_state)\r
2920 {\r
2921   gint len, i = 1;\r
2922 \r
2923   if(!cmpl_state->the_completion.text)\r
2924     return NULL;\r
2925 \r
2926   len = strlen(text) + strlen(cmpl_state->the_completion.text) + 1;\r
2927 \r
2928   if(cmpl_state->the_completion.text_alloc > len)\r
2929     {\r
2930       strcat(cmpl_state->the_completion.text, text);\r
2931       return &cmpl_state->the_completion;\r
2932     }\r
2933 \r
2934   while(i < len) { i <<= 1; }\r
2935 \r
2936   cmpl_state->the_completion.text_alloc = i;\r
2937 \r
2938   cmpl_state->the_completion.text = (gchar*)g_realloc(cmpl_state->the_completion.text, i);\r
2939 \r
2940   if(!cmpl_state->the_completion.text)\r
2941     return NULL;\r
2942   else\r
2943     {\r
2944       strcat(cmpl_state->the_completion.text, text);\r
2945       return &cmpl_state->the_completion;\r
2946     }\r
2947 }\r
2948 \r
2949 static CompletionDir*\r
2950 find_completion_dir(gchar* text_to_complete,\r
2951                     gchar** remaining_text,\r
2952                     CompletionState* cmpl_state)\r
2953 {\r
2954   gchar* first_slash = strchr(text_to_complete, '/');\r
2955   CompletionDir* dir = cmpl_state->reference_dir;\r
2956   CompletionDir* next;\r
2957   *remaining_text = text_to_complete;\r
2958 \r
2959   while(first_slash)\r
2960     {\r
2961       gint len = first_slash - *remaining_text;\r
2962       gint found = 0;\r
2963       gchar *found_name = NULL;         /* Quiet gcc */\r
2964       gint i;\r
2965       gchar* pat_buf = g_new (gchar, len + 1);\r
2966 \r
2967       strncpy(pat_buf, *remaining_text, len);\r
2968       pat_buf[len] = 0;\r
2969 \r
2970       for(i = 0; i < dir->sent->entry_count; i += 1)\r
2971         {\r
2972           if(dir->sent->entries[i].is_dir &&\r
2973              fnmatch(pat_buf, dir->sent->entries[i].entry_name,\r
2974                      FNMATCH_FLAGS)!= FNM_NOMATCH)\r
2975             {\r
2976               if(found)\r
2977                 {\r
2978                   g_free (pat_buf);\r
2979                   return dir;\r
2980                 }\r
2981               else\r
2982                 {\r
2983                   found = 1;\r
2984                   found_name = dir->sent->entries[i].entry_name;\r
2985                 }\r
2986             }\r
2987         }\r
2988 \r
2989       if (!found)\r
2990         {\r
2991           /* Perhaps we are trying to open an automount directory */\r
2992           found_name = pat_buf;\r
2993         }\r
2994 \r
2995       next = open_relative_dir(found_name, dir, cmpl_state);\r
2996       \r
2997       if(!next)\r
2998         {\r
2999           g_free (pat_buf);\r
3000           return NULL;\r
3001         }\r
3002       \r
3003       next->cmpl_parent = dir;\r
3004       \r
3005       dir = next;\r
3006       \r
3007       if(!correct_dir_fullname(dir))\r
3008         {\r
3009           g_free(pat_buf);\r
3010           return NULL;\r
3011         }\r
3012       \r
3013       *remaining_text = first_slash + 1;\r
3014       first_slash = strchr(*remaining_text, '/');\r
3015 \r
3016       g_free (pat_buf);\r
3017     }\r
3018 \r
3019   return dir;\r
3020 }\r
3021 \r
3022 static void\r
3023 update_cmpl(PossibleCompletion* poss, CompletionState* cmpl_state)\r
3024 {\r
3025   gint cmpl_len;\r
3026 \r
3027   if(!poss || !cmpl_is_a_completion(poss))\r
3028     return;\r
3029 \r
3030   cmpl_len = strlen(cmpl_this_completion(poss));\r
3031 \r
3032   if(cmpl_state->updated_text_alloc < cmpl_len + 1)\r
3033     {\r
3034       cmpl_state->updated_text =\r
3035         (gchar*)g_realloc(cmpl_state->updated_text,\r
3036                           cmpl_state->updated_text_alloc);\r
3037       cmpl_state->updated_text_alloc = 2*cmpl_len;\r
3038     }\r
3039 \r
3040   if(cmpl_state->updated_text_len < 0)\r
3041     {\r
3042       strcpy(cmpl_state->updated_text, cmpl_this_completion(poss));\r
3043       cmpl_state->updated_text_len = cmpl_len;\r
3044       cmpl_state->re_complete = cmpl_is_directory(poss);\r
3045     }\r
3046   else if(cmpl_state->updated_text_len == 0)\r
3047     {\r
3048       cmpl_state->re_complete = FALSE;\r
3049     }\r
3050   else\r
3051     {\r
3052       gint first_diff =\r
3053         first_diff_index(cmpl_state->updated_text,\r
3054                          cmpl_this_completion(poss));\r
3055 \r
3056       cmpl_state->re_complete = FALSE;\r
3057 \r
3058       if(first_diff == PATTERN_MATCH)\r
3059         return;\r
3060 \r
3061       if(first_diff > cmpl_state->updated_text_len)\r
3062         strcpy(cmpl_state->updated_text, cmpl_this_completion(poss));\r
3063 \r
3064       cmpl_state->updated_text_len = first_diff;\r
3065       cmpl_state->updated_text[first_diff] = 0;\r
3066     }\r
3067 }\r
3068 \r
3069 static PossibleCompletion*\r
3070 attempt_file_completion(CompletionState *cmpl_state)\r
3071 {\r
3072   gchar *pat_buf, *first_slash;\r
3073   CompletionDir *dir = cmpl_state->active_completion_dir;\r
3074 \r
3075   dir->cmpl_index += 1;\r
3076 \r
3077   if(dir->cmpl_index == dir->sent->entry_count)\r
3078     {\r
3079       if(dir->cmpl_parent == NULL)\r
3080         {\r
3081           cmpl_state->active_completion_dir = NULL;\r
3082 \r
3083           return NULL;\r
3084         }\r
3085       else\r
3086         {\r
3087           cmpl_state->active_completion_dir = dir->cmpl_parent;\r
3088 \r
3089           return attempt_file_completion(cmpl_state);\r
3090         }\r
3091     }\r
3092 \r
3093   g_assert(dir->cmpl_text);\r
3094 \r
3095   first_slash = strchr(dir->cmpl_text, '/');\r
3096 \r
3097   if(first_slash)\r
3098     {\r
3099       gint len = first_slash - dir->cmpl_text;\r
3100 \r
3101       pat_buf = g_new (gchar, len + 1);\r
3102       strncpy(pat_buf, dir->cmpl_text, len);\r
3103       pat_buf[len] = 0;\r
3104     }\r
3105   else\r
3106     {\r
3107       gint len = strlen(dir->cmpl_text);\r
3108 \r
3109       pat_buf = g_new (gchar, len + 2);\r
3110       strcpy(pat_buf, dir->cmpl_text);\r
3111       strcpy(pat_buf + len, "*");\r
3112     }\r
3113 \r
3114   if(first_slash)\r
3115     {\r
3116       if(dir->sent->entries[dir->cmpl_index].is_dir)\r
3117         {\r
3118           if(fnmatch(pat_buf, dir->sent->entries[dir->cmpl_index].entry_name,\r
3119                      FNMATCH_FLAGS) != FNM_NOMATCH)\r
3120             {\r
3121               CompletionDir* new_dir;\r
3122 \r
3123               new_dir = open_relative_dir(dir->sent->entries[dir->cmpl_index].entry_name,\r
3124                                           dir, cmpl_state);\r
3125 \r
3126               if(!new_dir)\r
3127                 {\r
3128                   g_free (pat_buf);\r
3129                   return NULL;\r
3130                 }\r
3131 \r
3132               new_dir->cmpl_parent = dir;\r
3133 \r
3134               new_dir->cmpl_index = -1;\r
3135               new_dir->cmpl_text = first_slash + 1;\r
3136 \r
3137               cmpl_state->active_completion_dir = new_dir;\r
3138 \r
3139               g_free (pat_buf);\r
3140               return attempt_file_completion(cmpl_state);\r
3141             }\r
3142           else\r
3143             {\r
3144               g_free (pat_buf);\r
3145               return attempt_file_completion(cmpl_state);\r
3146             }\r
3147         }\r
3148       else\r
3149         {\r
3150           g_free (pat_buf);\r
3151           return attempt_file_completion(cmpl_state);\r
3152         }\r
3153     }\r
3154   else\r
3155     {\r
3156       if(dir->cmpl_parent != NULL)\r
3157         {\r
3158           append_completion_text(dir->fullname +\r
3159                                  strlen(cmpl_state->completion_dir->fullname) + 1,\r
3160                                  cmpl_state);\r
3161           append_completion_text("/", cmpl_state);\r
3162         }\r
3163 \r
3164       append_completion_text(dir->sent->entries[dir->cmpl_index].entry_name, cmpl_state);\r
3165 \r
3166       cmpl_state->the_completion.is_a_completion =\r
3167         (fnmatch(pat_buf, dir->sent->entries[dir->cmpl_index].entry_name,\r
3168                  FNMATCH_FLAGS) != FNM_NOMATCH);\r
3169 \r
3170       cmpl_state->the_completion.is_directory = dir->sent->entries[dir->cmpl_index].is_dir;\r
3171       if(dir->sent->entries[dir->cmpl_index].is_dir)\r
3172         append_completion_text("/", cmpl_state);\r
3173 \r
3174       g_free (pat_buf);\r
3175       return &cmpl_state->the_completion;\r
3176     }\r
3177 }\r
3178 \r
3179 \r
3180 static gint\r
3181 get_pwdb(CompletionState* cmpl_state)\r
3182 {\r
3183   struct passwd *pwd_ptr;\r
3184   gchar* buf_ptr;\r
3185   gint len = 0, i, count = 0;\r
3186 \r
3187   if(cmpl_state->user_dir_name_buffer)\r
3188     return TRUE;\r
3189   setpwent ();\r
3190 \r
3191   while ((pwd_ptr = getpwent()) != NULL)\r
3192     {\r
3193       len += strlen(pwd_ptr->pw_name);\r
3194       len += strlen(pwd_ptr->pw_dir);\r
3195       len += 2;\r
3196       count += 1;\r
3197     }\r
3198 \r
3199   setpwent ();\r
3200 \r
3201   cmpl_state->user_dir_name_buffer = g_new(gchar, len);\r
3202   cmpl_state->user_directories = g_new(CompletionUserDir, count);\r
3203   cmpl_state->user_directories_len = count;\r
3204 \r
3205   buf_ptr = cmpl_state->user_dir_name_buffer;\r
3206 \r
3207   for(i = 0; i < count; i += 1)\r
3208     {\r
3209       pwd_ptr = getpwent();\r
3210       if(!pwd_ptr)\r
3211         {\r
3212           cmpl_errno = errno;\r
3213           goto error;\r
3214         }\r
3215 \r
3216       strcpy(buf_ptr, pwd_ptr->pw_name);\r
3217       cmpl_state->user_directories[i].login = buf_ptr;\r
3218       buf_ptr += strlen(buf_ptr);\r
3219       buf_ptr += 1;\r
3220       strcpy(buf_ptr, pwd_ptr->pw_dir);\r
3221       cmpl_state->user_directories[i].homedir = buf_ptr;\r
3222       buf_ptr += strlen(buf_ptr);\r
3223       buf_ptr += 1;\r
3224     }\r
3225 \r
3226   qsort(cmpl_state->user_directories,\r
3227         cmpl_state->user_directories_len,\r
3228         sizeof(CompletionUserDir),\r
3229         compare_user_dir);\r
3230 \r
3231   endpwent();\r
3232 \r
3233   return TRUE;\r
3234 \r
3235 error:\r
3236 \r
3237   if(cmpl_state->user_dir_name_buffer)\r
3238     g_free(cmpl_state->user_dir_name_buffer);\r
3239   if(cmpl_state->user_directories)\r
3240     g_free(cmpl_state->user_directories);\r
3241 \r
3242   cmpl_state->user_dir_name_buffer = NULL;\r
3243   cmpl_state->user_directories = NULL;\r
3244 \r
3245   return FALSE;\r
3246 }\r
3247 \r
3248 static gint\r
3249 compare_user_dir(const void* a, const void* b)\r
3250 {\r
3251   return strcmp((((CompletionUserDir*)a))->login,\r
3252                 (((CompletionUserDir*)b))->login);\r
3253 }\r
3254 \r
3255 static gint\r
3256 compare_cmpl_dir(const void* a, const void* b)\r
3257 {\r
3258   return strcmp((((CompletionDirEntry*)a))->entry_name,\r
3259                 (((CompletionDirEntry*)b))->entry_name);\r
3260 }\r
3261 \r
3262 static gint\r
3263 cmpl_state_okay(CompletionState* cmpl_state)\r
3264 {\r
3265   return  cmpl_state && cmpl_state->reference_dir;\r
3266 }\r
3267 \r
3268 static gchar*\r
3269 cmpl_strerror(gint err)\r
3270 {\r
3271   if(err == CMPL_ERRNO_TOO_LONG)\r
3272     return "Name too long";\r
3273   else\r
3274     return g_strerror (err);\r
3275 }\r
3276 \r
3277 \r
3278 /* Testing area */\r
3279 #ifdef TORRIE_DEBUG\r
3280 \r
3281 /* Get the selected filename and print it to the console */\r
3282 void file_ok_sel( GtkWidget        *w,\r
3283                   GtkFileSelection *fs )\r
3284 {\r
3285     g_print ("%s\n", gtk_file_selection_get_filename (GTK_FILE_SELECTION (fs)));\r
3286 }\r
3287 \r
3288 void destroy( GtkWidget *widget,\r
3289               gpointer   data )\r
3290 {\r
3291     gtk_main_quit ();\r
3292 }\r
3293 \r
3294 int main( int   argc,\r
3295           char *argv[] )\r
3296 {\r
3297     GtkWidget *filew;\r
3298 \r
3299     gtk_init (&argc, &argv);\r
3300 \r
3301     /* Create a new file selection widget */\r
3302     filew = gtk_file_selection_new ("Michael's Glorious File Selector");\r
3303 //    gtk_file_selection_complete(GTK_FILE_SELECTION(filew),"bob");\r
3304 \r
3305                 \r
3306     gtk_signal_connect (GTK_OBJECT (filew), "destroy",\r
3307                         (GtkSignalFunc) destroy, &filew);\r
3308     /* Connect the ok_button to file_ok_sel function */\r
3309     gtk_signal_connect (GTK_OBJECT (GTK_FILE_SELECTION (filew)->ok_button),\r
3310                         "clicked", (GtkSignalFunc) file_ok_sel, filew );\r
3311 \r
3312     /* Connect the cancel_button to destroy the widget */\r
3313     gtk_signal_connect_object (GTK_OBJECT (GTK_FILE_SELECTION\r
3314                                             (filew)->cancel_button),\r
3315                                "clicked", (GtkSignalFunc) gtk_widget_destroy,\r
3316                                GTK_OBJECT (filew));\r
3317 \r
3318 \r
3319     gtk_widget_show(filew);\r
3320 \r
3321 /*\r
3322     g_print("%d",gtk_file_selection_match_mask("mask.c","m*.c"));\r
3323     g_print("%d",gtk_file_selection_match_mask("mask.c","m???.c"));\r
3324                 g_print("%d",gtk_file_selection_match_mask("mask.c","m??*.c"));\r
3325                 g_print("%d",gtk_file_selection_match_mask("mask.cout","m*.c"));\r
3326                 g_print("%d",gtk_file_selection_match_mask("mask.cout","m*.c???"));\r
3327                 g_print("%d",gtk_file_selection_match_mask("mask.cout","m*.c*"));\r
3328                 g_print("%d",gtk_file_selection_match_mask("mask.cout","n*.c???"));\r
3329                 g_print("%d",gtk_file_selection_match_mask("mask.c","[mn]*"));\r
3330                 g_print("%d",gtk_file_selection_match_mask("COPYING","*.xpm"));\r
3331 */      \r
3332     gtk_main ();\r
3333 \r
3334     return 0;\r
3335 }\r
3336 /* example-end */\r
3337 #endif\r