radiant/gtkfilesel-linux.c

   1 /* GTK - The GIMP Toolkit
   2  * Copyright (C) 1995-1997 Peter Mattis, Spencer Kimball and Josh MacDonald
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Library General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Library General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Library General Public
  15  * License along with this library; if not, write to the
  16  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  17  * Boston, MA 02111-1307, USA.
  18  */
  19
  20 /*
  21  * Modified by the GTK+ Team and others 1997-1999.  See the AUTHORS
  22  * file for a list of people on the GTK+ Team.  See the ChangeLog
  23  * files for a list of changes.  These files are distributed with
  24  * GTK+ at ftp://ftp.gtk.org/pub/gtk/.
  25  */
  26 #define LEO
  27
  28 #ifdef LEO
  29 #define _(a) a
  30
  31 static char * back_xpm[] = {
  32 "14 14 33 1",
  33 "       c None",
  34 ".      c #000000",
  35 "+      c #C6D7C6",
  36 "@      c #E7EBE7",
  37 "#      c #FFFFFF",
  38 "$      c #DEEBDE",
  39 "%      c #F7F7F7",
  40 "&      c #DEE7DE",
  41 "*      c #EFF3EF",
  42 "=      c #101810",
  43 "-      c #B5C7AD",
  44 ";      c #EFEFEF",
  45 ">      c #D6E3D6",
  46 ",      c #213021",
  47 "'      c #315931",
  48 ")      c #52824A",
  49 "!      c #739A6B",
  50 "~      c #84A673",
  51 "{      c #7BA673",
  52 "]      c #84AA73",
  53 "^      c #84AA7B",
  54 "/      c #84AE7B",
  55 "(      c #63925A",
  56 "_      c #526D4A",
  57 ":      c #4A7D42",
  58 "<      c #739E6B",
  59 "[      c #739A63",
  60 "}      c #4A7539",
  61 "|      c #638E52",
  62 "1      c #427139",
  63 "2      c #6BA663",
  64 "3      c #5A8A52",
  65 "4      c #315929",
  66 "            ..",
  67 "          ..+.",
  68 "        ..@#+.",
  69 "      ..$#%%+.",
  70 "    ..&#%*%%+.",
  71 "  .=&#******+.",
  72 "..-#;>&@****+,",
  73 "..')!~{]^/^/(.",
  74 "  .._:<^~^/^(.",
  75 "    ..':[]~/(.",
  76 "      ..}:[~|.",
  77 "        ..123.",
  78 "          ..4.",
  79 "            .."};
  80
  81 static char * up_xpm[] = {
  82 "14 14 36 1",
  83 "       c None",
  84 ".      c #000000",
  85 "+      c #181C18",
  86 "@      c #D6DBD6",
  87 "#      c #94AA8C",
  88 "$      c #000400",
  89 "%      c #DEDFDE",
  90 "&      c #94AA84",
  91 "*      c #E7E3E7",
  92 "=      c #94B28C",
  93 "-      c #6B865A",
  94 ";      c #EFEBEF",
  95 ">      c #9CB694",
  96 ",      c #8CA684",
  97 "'      c #EFEFEF",
  98 ")      c #F7EFF7",
  99 "!      c #9CB68C",
 100 "~      c #63865A",
 101 "{      c #94B684",
 102 "]      c #94AE84",
 103 "^      c #739263",
 104 "/      c #F7F3F7",
 105 "(      c #94B284",
 106 "_      c #849E73",
 107 ":      c #8CAE7B",
 108 "<      c #8CAA84",
 109 "[      c #7B966B",
 110 "}      c #8CA67B",
 111 "|      c #DEDBD6",
 112 "1      c #E7E7E7",
 113 "2      c #8CAE84",
 114 "3      c #8CAA7B",
 115 "4      c #738E63",
 116 "5      c #BDBEB5",
 117 "6      c #BDC3BD",
 118 "7      c #637D52",
 119 "      ..      ",
 120 "      ..      ",
 121 "     +@#$     ",
 122 "     .%&.     ",
 123 "    .**=-.    ",
 124 "    .;;>,.    ",
 125 "   .*')!&~.   ",
 126 "   .;)){]^.   ",
 127 "  .*')/(]_-.  ",
 128 "  .;)//::<[.  ",
 129 " .*')//:::}-. ",
 130 " .|1;;12]3}4. ",
 131 ".556666^^^^-7.",
 132 ".............."};
 133
 134 static char * forward_xpm[] = {
 135 "14 14 36 1",
 136 "       c None",
 137 ".      c #000000",
 138 "+      c #E7EBDE",
 139 "@      c #FFFFFF",
 140 "#      c #F7F7EF",
 141 "$      c #D6E3D6",
 142 "%      c #F7F7F7",
 143 "&      c #EFF3EF",
 144 "*      c #CEDFCE",
 145 "=      c #CEDBC6",
 146 "-      c #E7EFE7",
 147 ";      c #181818",
 148 ">      c #292829",
 149 ",      c #E7EBE7",
 150 "'      c #DEE7DE",
 151 ")      c #B5C7AD",
 152 "!      c #9CBA94",
 153 "~      c #8CAE84",
 154 "{      c #84AA7B",
 155 "]      c #7BA673",
 156 "^      c #84A67B",
 157 "/      c #739A6B",
 158 "(      c #5A824A",
 159 "_      c #395931",
 160 ":      c #9CBA8C",
 161 "<      c #84AE7B",
 162 "[      c #739E6B",
 163 "}      c #527D4A",
 164 "|      c #425942",
 165 "1      c #84A673",
 166 "2      c #4A7142",
 167 "3      c #94B284",
 168 "4      c #395D31",
 169 "5      c #5A8652",
 170 "6      c #315929",
 171 "7      c #396531",
 172 "..            ",
 173 ".+..          ",
 174 ".@#$..        ",
 175 ".@%&#*..      ",
 176 ".@%%&&%=..    ",
 177 ".@&&&&&-#=;.  ",
 178 ">@&&&&,'$'&)..",
 179 ".!~{~{{]^/(_..",
 180 ".:{<{^{[}|..  ",
 181 ".:<1{/}2..    ",
 182 ".31/}4..      ",
 183 ".{56..        ",
 184 ".7..          ",
 185 "..            "};
 186
 187 static char * refresh_xpm[] = {
 188 "16 16 11 1",
 189 "       c None",
 190 ".      c #000000",
 191 "+      c #526942",
 192 "@      c #4A6139",
 193 "#      c #526542",
 194 "$      c #5A7142",
 195 "%      c #425531",
 196 "&      c #314529",
 197 "*      c #425131",
 198 "=      c #425931",
 199 "-      c #5A754A",
 200 "       .        ",
 201 "      ..        ",
 202 "     .+@...     ",
 203 "    .#$##@%..   ",
 204 "     .+#...%%.  ",
 205 "   .  ..   .&.  ",
 206 "  .    .    .&. ",
 207 " ..          .. ",
 208 " ..          .. ",
 209 " .*.    .    .  ",
 210 "  .*.   ..  .   ",
 211 "  .%@...#=.     ",
 212 "   ..##-#@#.    ",
 213 "     ...@%.     ",
 214 "        ..      ",
 215 "        .       "};
 216
 217 #endif
 218
 219 #ifndef LEO
 220 #include "config.h"
 221 #endif
 222
 223 #include <fcntl.h>
 224 #include <stdio.h>
 225 #include <sys/types.h>
 226 #include <sys/stat.h>
 227 #include <sys/param.h>
 228 #include <dirent.h>
 229 #include <stdlib.h>
 230 #include <unistd.h>
 231 #include <string.h>
 232 #include <errno.h>
 233 #include <pwd.h>
 234 #include <grp.h>
 235 #include <time.h>
 236
 237 #include "fnmatch.h"
 238
 239 #if (defined TORRIE_DEBUG || defined LEO)
 240 #include <gdk/gdkkeysyms.h>
 241 #include <gtk/gtkbutton.h>
 242 #include <gtk/gtkentry.h>
 243 #include "gtkfilesel-linux.h"
 244 #include <gtk/gtkhbox.h>
 245 #include <gtk/gtkhbbox.h>
 246 #include <gtk/gtklabel.h>
 247 #include <gtk/gtklist.h>
 248 #include <gtk/gtklistitem.h>
 249 #include <gtk/gtkmain.h>
 250 #include <gtk/gtkscrolledwindow.h>
 251 #include <gtk/gtksignal.h>
 252 #include <gtk/gtkvbox.h>
 253 #include <gtk/gtkmenu.h>
 254 #include <gtk/gtkmenuitem.h>
 255 #include <gtk/gtkoptionmenu.h>
 256 #include <gtk/gtkclist.h>
 257 #include <gtk/gtkdialog.h>
 258 #include <gtk/gtkcombo.h>
 259 #include <gtk/gtkframe.h>
 260 #include <gtk/gtkhpaned.h>
 261 #include <gtk/gtktable.h>
 262 #include <gtk/gtkpixmap.h>
 263 #include <gtk/gtknotebook.h>
 264 #include <gtk/gtkhseparator.h>
 265 #include <gtk/gtktogglebutton.h>
 266 #else
 267 #include "gdk/gdkkeysyms.h"
 268 #include "gtkbutton.h"
 269 #include "gtkentry.h"
 270 #include "gtkfilesel.h"
 271 #include "gtkhbox.h"
 272 #include "gtkhbbox.h"
 273 #include "gtklabel.h"
 274 #include "gtklist.h"
 275 #include "gtklistitem.h"
 276 #include "gtkmain.h"
 277 #include "gtkscrolledwindow.h"
 278 #include "gtksignal.h"
 279 #include "gtkvbox.h"
 280 #include "gtkmenu.h"
 281 #include "gtkmenuitem.h"
 282 #include "gtkoptionmenu.h"
 283 #include "gtkclist.h"
 284 #include "gtkdialog.h"
 285 #include "gtkcombo.h"
 286 #include "gtkframe.h"
 287 #include "gtkhpaned.h"
 288 #include "gtktable.h"
 289 #include "gtkpixmap.h"
 290 #include "gtknotebook.h"
 291 #include "gtkhseparator.h"
 292 #include "gtktogglebutton.h"
 293 #endif
 294
 295 #ifndef LEO
 296 #include "gtkintl.h"
 297
 298 #include "back.xpm"
 299 #include "up.xpm"
 300 #include "forward.xpm"
 301 #include "refresh.xpm"
 302 #endif
 303
 304 #define DIR_LIST_WIDTH   180
 305 #define DIR_LIST_HEIGHT  180
 306 #define FILE_LIST_WIDTH  180
 307 #define FILE_LIST_HEIGHT 180
 308 #define BOOKMARK_FILE "/.gtkfilesel_bookmarks"
 309 #define MASK_FILE "/.gtkfilesel_masks"
 310 #define TIME_STRING_BUF 50
 311
 312 /* I've put this here so it doesn't get confused with the
 313  * file completion interface */
 314 typedef struct _HistoryCallbackArg HistoryCallbackArg;
 315
 316 struct _HistoryCallbackArg
 317 {
 318   gchar *directory;
 319   GtkWidget *menu_item;
 320 };
 321
 322
 323 typedef struct _BookmarkMenuStruct BookmarkMenuStruct;
 324 struct _BookmarkMenuStruct {
 325   GtkWidget *menu_item;
 326   gchar     *desc;
 327   gchar     *path;
 328 };
 329
 330 typedef struct _CompletionState    CompletionState;
 331 typedef struct _CompletionDir      CompletionDir;
 332 typedef struct _CompletionDirSent  CompletionDirSent;
 333 typedef struct _CompletionDirEntry CompletionDirEntry;
 334 typedef struct _CompletionUserDir  CompletionUserDir;
 335 typedef struct _PossibleCompletion PossibleCompletion;
 336
 337 /* Non-external file completion decls and structures */
 338
 339 /* A contant telling PRCS how many directories to cache.  Its actually
 340  * kept in a list, so the geometry isn't important. */
 341 #define CMPL_DIRECTORY_CACHE_SIZE 10
 342
 343 /* A constant used to determine whether a substring was an exact
 344  * match by first_diff_index()
 345  */
 346 #define PATTERN_MATCH -1
 347 /* The arguments used by all fnmatch() calls below
 348  */
 349 #define FNMATCH_FLAGS (FNM_PATHNAME | FNM_PERIOD)
 350
 351 #define CMPL_ERRNO_TOO_LONG ((1<<16)-1)
 352
 353 /* This structure contains all the useful information about a directory
 354  * for the purposes of filename completion.  These structures are cached
 355  * in the CompletionState struct.  CompletionDir's are reference counted.
 356  */
 357 struct _CompletionDirSent
 358 {
 359   ino_t inode;
 360   time_t mtime;
 361   dev_t device;
 362
 363   gint entry_count;
 364   gchar *name_buffer; /* memory segment containing names of all entries */
 365
 366   struct _CompletionDirEntry *entries;
 367 };
 368
 369 struct _CompletionDir
 370 {
 371   CompletionDirSent *sent;
 372
 373   gchar *fullname;
 374   gint fullname_len;
 375
 376   struct _CompletionDir *cmpl_parent;
 377   gint cmpl_index;
 378   gchar *cmpl_text;
 379 };
 380
 381 /* This structure contains pairs of directory entry names with a flag saying
 382  * whether or not they are a valid directory.  NOTE: This information is used
 383  * to provide the caller with information about whether to update its completions
 384  * or try to open a file.  Since directories are cached by the directory mtime,
 385  * a symlink which points to an invalid file (which will not be a directory),
 386  * will not be reevaluated if that file is created, unless the containing
 387  * directory is touched.  I consider this case to be worth ignoring (josh).
 388  */
 389 struct _CompletionDirEntry
 390 {
 391   gint is_dir;
 392   gchar *entry_name;
 393 };
 394
 395 struct _CompletionUserDir
 396 {
 397   gchar *login;
 398   gchar *homedir;
 399 };
 400
 401 struct _PossibleCompletion
 402 {
 403   /* accessible fields, all are accessed externally by functions
 404    * declared above
 405    */
 406   gchar *text;
 407   gint is_a_completion;
 408   gint is_directory;
 409
 410   gint file_size;
 411   gint file_time;
 412   gint uid;
 413   gint gid;
 414   /* Private fields
 415    */
 416   gint text_alloc;
 417 };
 418
 419 struct _CompletionState
 420 {
 421   gint last_valid_char;
 422   gchar *updated_text;
 423   gint updated_text_len;
 424   gint updated_text_alloc;
 425   gint re_complete;
 426
 427   gchar *user_dir_name_buffer;
 428   gint user_directories_len;
 429
 430   gchar *last_completion_text;
 431
 432   gint user_completion_index; /* if >= 0, currently completing ~user */
 433
 434   struct _CompletionDir *completion_dir; /* directory completing from */
 435   struct _CompletionDir *active_completion_dir;
 436
 437   struct _PossibleCompletion the_completion;
 438
 439   struct _CompletionDir *reference_dir; /* initial directory */
 440
 441   GList* directory_storage;
 442   GList* directory_sent_storage;
 443
 444   struct _CompletionUserDir *user_directories;
 445 };
 446
 447 /* Widgets from the Properties Dialog */
 448 typedef struct _PropertiesPrivate PropertiesPrivate;
 449
 450 struct _PropertiesPrivate
 451 {
 452   GtkWidget *mode_label;
 453   GtkWidget *mode_buttons[12];
 454 };
 455
 456 /* pixmap creation function */
 457 GtkWidget*                 create_pixmap          (GtkWidget *widget,
 458                                                    const gchar *pixmap_char);
 459
 460 /* File completion functions which would be external, were they used
 461  * outside of this file.
 462  */
 463
 464 static CompletionState*    cmpl_init_state        (void);
 465 static void                cmpl_free_state        (CompletionState *cmpl_state);
 466 static gint                cmpl_state_okay        (CompletionState* cmpl_state);
 467 static gchar*              cmpl_strerror          (gint);
 468
 469 static PossibleCompletion* cmpl_completion_matches(gchar           *text_to_complete,
 470                                                    gchar          **remaining_text,
 471                                                    CompletionState *cmpl_state);
 472
 473 /* Returns a name for consideration, possibly a completion, this name
 474  * will be invalid after the next call to cmpl_next_completion.
 475  */
 476 static char*               cmpl_this_completion   (PossibleCompletion*);
 477
 478 /* True if this completion matches the given text.  Otherwise, this
 479  * output can be used to have a list of non-completions.
 480  */
 481 static gint                cmpl_is_a_completion   (PossibleCompletion*);
 482
 483 /* True if the completion is a directory
 484  */
 485 static gint                cmpl_is_directory      (PossibleCompletion*);
 486
 487 /* Obtains the next completion, or NULL
 488  */
 489 static PossibleCompletion* cmpl_next_completion   (CompletionState*);
 490
 491 /* Updating completions: the return value of cmpl_updated_text() will
 492  * be text_to_complete completed as much as possible after the most
 493  * recent call to cmpl_completion_matches.  For the present
 494  * application, this is the suggested replacement for the user's input
 495  * string.  You must CALL THIS AFTER ALL cmpl_text_completions have
 496  * been received.
 497  */
 498 static gchar*              cmpl_updated_text       (CompletionState* cmpl_state);
 499
 500 /* After updating, to see if the completion was a directory, call
 501  * this.  If it was, you should consider re-calling completion_matches.
 502  */
 503 static gint                cmpl_updated_dir        (CompletionState* cmpl_state);
 504
 505 /* Current location: if using file completion, return the current
 506  * directory, from which file completion begins.  More specifically,
 507  * the cwd concatenated with all exact completions up to the last
 508  * directory delimiter('/').
 509  */
 510 static gchar*              cmpl_reference_position (CompletionState* cmpl_state);
 511
 512 /* backing up: if cmpl_completion_matches returns NULL, you may query
 513  * the index of the last completable character into cmpl_updated_text.
 514  */
 515 static gint                cmpl_last_valid_char    (CompletionState* cmpl_state);
 516
 517 /* When the user selects a non-directory, call cmpl_completion_fullname
 518  * to get the full name of the selected file.
 519  */
 520 static gchar*              cmpl_completion_fullname (gchar*, CompletionState* cmpl_state);
 521
 522
 523 /* Directory operations. */
 524 static CompletionDir* open_ref_dir         (gchar* text_to_complete,
 525                                             gchar** remaining_text,
 526                                             CompletionState* cmpl_state);
 527 static gboolean       check_dir            (gchar *dir_name,
 528                                             struct stat *result,
 529                                             gboolean *stat_subdirs);
 530 static CompletionDir* open_dir             (gchar* dir_name,
 531                                             CompletionState* cmpl_state);
 532 static CompletionDir* open_user_dir        (gchar* text_to_complete,
 533                                             CompletionState *cmpl_state);
 534 static CompletionDir* open_relative_dir    (gchar* dir_name, CompletionDir* dir,
 535                                             CompletionState *cmpl_state);
 536 static CompletionDirSent* open_new_dir     (gchar* dir_name,
 537                                             struct stat* sbuf,
 538                                             gboolean stat_subdirs);
 539 static gint           correct_dir_fullname (CompletionDir* cmpl_dir);
 540 static gint           correct_parent       (CompletionDir* cmpl_dir,
 541                                             struct stat *sbuf);
 542 static gchar*         find_parent_dir_fullname    (gchar* dirname);
 543 static CompletionDir* attach_dir           (CompletionDirSent* sent,
 544                                             gchar* dir_name,
 545                                             CompletionState *cmpl_state);
 546 static void           free_dir_sent (CompletionDirSent* sent);
 547 static void           free_dir      (CompletionDir  *dir);
 548 static void           prune_memory_usage(CompletionState *cmpl_state);
 549
 550 /* Completion operations */
 551 static PossibleCompletion* attempt_homedir_completion(gchar* text_to_complete,
 552                                                       CompletionState *cmpl_state);
 553 static PossibleCompletion* attempt_file_completion(CompletionState *cmpl_state);
 554 static CompletionDir* find_completion_dir(gchar* text_to_complete,
 555                                           gchar** remaining_text,
 556                                           CompletionState* cmpl_state);
 557 static PossibleCompletion* append_completion_text(gchar* text,
 558                                                   CompletionState* cmpl_state);
 559 static gint get_pwdb(CompletionState* cmpl_state);
 560 static gint first_diff_index(gchar* pat, gchar* text);
 561 static gint compare_user_dir(const void* a, const void* b);
 562 static gint compare_cmpl_dir(const void* a, const void* b);
 563 static void update_cmpl(PossibleCompletion* poss,
 564                         CompletionState* cmpl_state);
 565
 566 static void gtk_file_selection_class_init    (GtkFileSelectionClass *klass);
 567 static void gtk_file_selection_init          (GtkFileSelection      *filesel);
 568 static void gtk_file_selection_realize       (GtkWidget             *widget);
 569 static void gtk_file_selection_destroy       (GtkObject             *object);
 570 static gint gtk_file_selection_key_press     (GtkWidget             *widget,
 571                                               GdkEventKey           *event,
 572                                               gpointer               user_data);
 573
 574 static void gtk_file_selection_file_button (GtkWidget *widget,
 575                                             gint row,
 576                                             gint column,
 577                                             GdkEventButton *bevent,
 578                                             gpointer user_data);
 579
 580 static void gtk_file_selection_dir_button (GtkWidget *widget,
 581                                            gint row,
 582                                            gint column,
 583                                            GdkEventButton *bevent,
 584                                            gpointer data);
 585
 586 static void gtk_file_selection_undir_button (GtkWidget *widget,
 587                                              gint row,
 588                                              gint column,
 589                                              GdkEventButton *bevent,
 590                                              gpointer data);
 591
 592 static void gtk_file_selection_populate      (GtkFileSelection      *fs,
 593                                               gchar                 *rel_path,
 594                                               gint                   try_complete);
 595 static void gtk_file_selection_abort         (GtkFileSelection      *fs);
 596
 597 static void gtk_file_selection_update_history_menu (GtkFileSelection       *fs,
 598                                                     gchar                  *current_dir);
 599
 600 static void gtk_file_selection_create_dir (gpointer data);
 601 static void gtk_file_selection_delete_file (gpointer data);
 602 static void gtk_file_selection_rename_file (gpointer data);
 603 static void gtk_file_selection_properties (gpointer data);
 604 static void gtk_file_selection_properties_update_mode (GtkWidget *widget, gpointer data);
 605 static mode_t gtk_file_selection_properties_get_mode (PropertiesPrivate* private);
 606
 607 static gboolean gtk_file_selection_history_combo_callback (GtkWidget *widget, GdkEventKey *event, gpointer data);
 608 static gboolean gtk_file_selection_history_combo_list_key_handler(GtkWidget *widget,
 609                                                                                                                                                                                         GdkEventKey *event,
 610                                                                                                                                                                                         gpointer user_data);
 611 static gboolean gtk_file_selection_history_combo_list_callback (GtkWidget *thelist,
 612                                                                                                                                                                                         GdkEventButton *event,
 613
 614                                                                                                                                                                                         gpointer user_data);
 615 static void gtk_file_selection_bookmark_callback (GtkWidget *widget, gpointer data);
 616 static void gtk_file_selection_mask_entry_callback (GtkWidget *widget, gpointer data);
 617 static gint gtk_file_selection_mask_entry_key_callback (GtkWidget *widget, GdkEventKey *event, gpointer data);
 618 static gint gtk_file_selection_mask_entry_button_callback (GtkWidget *widget, GdkEventButton *event, gpointer data);
 619
 620 //static void gtk_file_selection_home_button (GtkWidget *widget, gpointer data);
 621 static void gtk_file_selection_bookmark_button (GtkWidget *widget,
 622                                    GtkFileSelection *fs);
 623
 624 static void gtk_file_selection_up_button (GtkWidget *widget, gpointer data);
 625 static void gtk_file_selection_prev_button (GtkWidget *widget, gpointer data);
 626 static void gtk_file_selection_next_button (GtkWidget *widget, gpointer data);
 627 static void gtk_file_selection_refresh_button (GtkWidget *widget, gpointer data);
 628
 629 static gint gtk_file_selection_files_list_key_callback (GtkWidget *widget, GdkEventKey *event, gpointer data);
 630
 631
 632 static gint gtk_file_selection_match_char (gchar, gchar *mask);
 633 static gint gtk_file_selection_match_mask (gchar *,gchar *);
 634
 635 static void gtk_file_selection_load_bookmarks(GtkFileSelection *fs);
 636 static void gtk_file_selection_add_bookmark (GtkFileSelection *fs, gchar *desc, gchar *path);
 637 gint gtk_file_selection_save_bookmarks (GtkFileSelection *fs);
 638
 639 static void gtk_file_selection_load_masks(GtkFileSelection *fs);
 640
 641 static gint gtk_file_selection_show_fileop_menu (GtkCList *clist,
 642                                                  GdkEvent *event,
 643                                                  GtkFileSelection *fs);
 644
 645
 646 static GtkWindowClass *parent_class = NULL;
 647
 648 /* Saves errno when something cmpl does fails. */
 649 static gint cmpl_errno;
 650
 651 #ifdef G_WITH_CYGWIN
 652 /*
 653  * Take the path currently in the file selection
 654  * entry field and translate as necessary from
 655  * a WIN32 style to CYGWIN32 style path.  For
 656  * instance translate:
 657  * x:\somepath\file.jpg
 658  * to:
 659  * //x/somepath/file.jpg
 660  *
 661  * Replace the path in the selection text field.
 662  * Return a boolean value concerning whether a
 663  * translation had to be made.
 664  */
 665 int
 666 translate_win32_path (GtkFileSelection *filesel)
 667 {
 668   int updated = 0;
 669   gchar *path;
 670
 671   /*
 672    * Retrieve the current path
 673    */
 674   path = gtk_entry_get_text (GTK_ENTRY (filesel->selection_entry));
 675
 676   /*
 677    * Translate only if this looks like a DOS-ish
 678    * path... First handle any drive letters.
 679    */
 680   if (isalpha (path[0]) && (path[1] == ':')) {
 681     /*
 682      * This part kind of stinks... It isn't possible
 683      * to know if there is enough space in the current
 684      * string for the extra character required in this
 685      * conversion.  Assume that there isn't enough space
 686      * and use the set function on the text field to
 687      * set the newly created string.
 688      */
 689     gchar *newPath = g_strdup_printf ("//%c/%s", path[0], (path + 3));
 690     gtk_entry_set_text (GTK_ENTRY (filesel->selection_entry), newPath);
 691
 692     path = newPath;
 693     updated = 1;
 694   }
 695
 696   /*
 697    * Now, replace backslashes with forward slashes
 698    * if necessary.
 699    */
 700   if (strchr (path, '\\'))
 701     {
 702       int index;
 703       for (index = 0; path[index] != '\0'; index++)
 704         if (path[index] == '\\')
 705           path[index] = '/';
 706
 707       updated = 1;
 708     }
 709
 710   return updated;
 711 }
 712 #endif
 713
 714 /* General notes:
 715  * Make prev and next inactive if their respective *
 716  *   histories are empty.
 717  * Add facilities for handling hidden files and    *
 718  * directories                                     *
 719  * Add an api to access the mask, and hidden files *
 720  * check box?  (prob not in 1.2.x series)          *
 721  */
 722
 723 /* Routine for applying mask to filenames         *
 724  *   Need to be optimized to minimize recursion   *
 725  *     help the for loop by looking for the next  *
 726  *     instance of the mask character following   *
 727  *     the '*'.  ei *.c -- look for '.'           *
 728  *     Also, swap all *? pairs (-> ?*), as that   *
 729  *     will make it possible to look ahead (?     *
 730  *     makes it very nondeterministic as in *?.c  *
 731  *     which really is ?*.c                       *
 732  *                                                *
 733  */
 734 static gint gtk_file_selection_match_char (gchar text, gchar *mask)
 735 {
 736   gchar *maskc;
 737   gint x;
 738   gint s;
 739   gchar lastc;
 740   gchar nextc;
 741
 742   if (mask[0] == '[')
 743     {
 744       if (!strchr (mask,']')) return 0;
 745       lastc = 0;
 746
 747       maskc = g_strdup(mask + 1); /* get the portion of mask inside []*/
 748       (*(strchr (maskc + 1,']'))) = 0;
 749       s = strlen ((char *)maskc);
 750
 751       for (x = 0 ; x < s ; x ++){
 752         if (maskc[x] == '-')
 753           {
 754             if (x == s) return 1;
 755             nextc = maskc[x + 1];
 756
 757             if (nextc > lastc)
 758             {
 759               if ((lastc <= text) && (nextc >= text))
 760               {
 761                 g_free (maskc);
 762                 return s + 2;
 763               }
 764             }
 765             else if ((lastc >= text) && (nextc <= text))
 766               {
 767                 g_free (maskc);
 768                 return s + 2;
 769               }
 770           }
 771         else if (text == maskc[x])
 772           {
 773             g_free (maskc);
 774             return s + 2;
 775           }
 776         lastc = maskc[x];
 777       }
 778       g_free (maskc);
 779
 780       return 0;
 781     }
 782
 783   if (mask[0] == '?') return 1;
 784   if (mask[0] == text) return 1;
 785
 786   return 0;
 787 }
 788
 789
 790 static gint gtk_file_selection_match_mask1 (gchar *text, gchar *mask)
 791 {
 792
 793   int mc;
 794   int tc;
 795
 796   tc = 0; mc = 0;
 797
 798   if (mask[0] == 0 && text[0] == 0) return 1;
 799
 800   if (mask[0] == '*')
 801     {
 802       for (tc = 0; tc <= strlen(text); tc++)
 803         {
 804           if (gtk_file_selection_match_mask1 (text + tc, mask + 1))
 805             return 1;
 806         }
 807       return 0;
 808     }
 809   mc = gtk_file_selection_match_char (text[0], mask);
 810
 811   if(mc)
 812     return gtk_file_selection_match_mask1 (text + 1, mask + mc);
 813   else
 814     return 0;
 815 }
 816
 817 static gint gtk_file_selection_match_mask (gchar *text, gchar *mask)
 818 {
 819   gchar *masks;
 820   gchar *bmask;
 821   gchar *emask;
 822
 823   masks=g_strdup(mask);
 824
 825   emask=strchr(masks,'<');
 826   if(emask){
 827     bmask=emask+1;
 828     emask=strchr(bmask,'>');
 829     if(emask){
 830       *emask=0;
 831     }
 832   }else{
 833     bmask=masks;
 834   }
 835
 836   do{
 837     if((emask=strchr(bmask,',')) || (emask=strchr(bmask,';'))){
 838       *emask=0;
 839       if (gtk_file_selection_match_mask1 (text, bmask)){
 840         g_free(masks);
 841         return 1;
 842       }
 843
 844       bmask=emask+1;
 845     }
 846   }while(emask);
 847
 848   if(gtk_file_selection_match_mask1 (text, bmask)){
 849     g_free(masks);
 850     return 1;
 851   }
 852   g_free(masks);
 853   return 0;
 854 }
 855
 856 static void
 857 gtk_file_selection_load_bookmarks(GtkFileSelection *fs)
 858 {
 859   GList *list;
 860   gchar *bookmark_file;
 861   gchar *bookmark_data;
 862   struct stat file_info;
 863   gint   file;
 864   gint   lp;
 865   gint   cp;
 866   BookmarkMenuStruct *item;
 867
 868
 869   if(fs->bookmark_list){  //erase
 870     list=fs->bookmark_list;
 871     while(list){
 872       item=list->data;
 873       g_free(item->desc);
 874       g_free(item->path);
 875       g_free(item);
 876       list=list->next;
 877     }
 878     g_list_free (fs->bookmark_list);
 879     fs->bookmark_list = NULL;
 880     gtk_widget_destroy (fs->bookmark_menu);
 881   }
 882
 883   fs->bookmark_menu=gtk_menu_new();
 884
 885   /* spacer */
 886   item=g_malloc(sizeof(item));
 887   item->menu_item = gtk_menu_item_new();
 888   gtk_widget_show(item->menu_item);
 889   gtk_menu_append (GTK_MENU(fs->bookmark_menu), item->menu_item);
 890
 891   item=g_malloc(sizeof(item));
 892   item->desc=g_strdup("Add bookmark");
 893   item->path=g_strdup(".");
 894   item->menu_item=gtk_menu_item_new_with_label (item->desc);
 895   gtk_widget_show(item->menu_item);
 896   //fs->bookmark_list=g_list_append(fs->bookmark_list,item);
 897   //set signal here!!
 898   gtk_menu_append (GTK_MENU(fs->bookmark_menu), item->menu_item);
 899
 900   item=g_malloc(sizeof(item));
 901   item->desc=g_strdup("Edit bookmark");
 902   item->path=g_strdup(".");
 903   item->menu_item=gtk_menu_item_new_with_label (item->desc);
 904   gtk_widget_show(item->menu_item);
 905   //fs->bookmark_list=g_list_append(fs->bookmark_list,item);
 906   //set signal here!!
 907   gtk_menu_append (GTK_MENU(fs->bookmark_menu), item->menu_item);
 908
 909   bookmark_file=g_strconcat(g_get_home_dir(), BOOKMARK_FILE ,NULL);
 910   if(!stat(bookmark_file,&file_info) && (file = open(bookmark_file,  O_RDONLY )) > 0)
 911   {
 912     if(file_info.st_size <65536 )
 913     {
 914       bookmark_data=g_malloc(file_info.st_size);
 915
 916       if(file && read(file, bookmark_data, file_info.st_size))
 917       {
 918         cp=lp=0;
 919
 920         while (cp < file_info.st_size)
 921         {
 922           while (cp < file_info.st_size && bookmark_data[cp] != '<' )
 923             cp++;
 924           bookmark_data[cp]=0;
 925           item=g_malloc(sizeof(BookmarkMenuStruct));
 926           item->desc=g_strdup(bookmark_data+lp);
 927           lp=++cp;
 928
 929           while (cp < file_info.st_size && bookmark_data[cp] != '>' )
 930             cp++;
 931
 932           bookmark_data[cp]=0;
 933           //create menu items
 934           item->path=g_strdup(bookmark_data+lp);
 935           gtk_file_selection_add_bookmark ((gpointer) fs, (gpointer) item->desc, (gpointer) item->path);
 936
 937           cp++;
 938
 939           while(cp < file_info.st_size && bookmark_data[cp] < 33 )
 940             cp++;
 941           lp=cp;
 942         }
 943       }
 944
 945       close(file);
 946     }
 947   } else {
 948
 949     /* Add some default items, then save off to bookmarks file */
 950
 951     gtk_file_selection_add_bookmark ((gpointer) fs, "Home", "~/");
 952     gtk_file_selection_add_bookmark ((gpointer) fs, "Root", "/");
 953
 954     gtk_file_selection_save_bookmarks ((gpointer) fs);
 955   }
 956 }
 957
 958 static void
 959 gtk_file_selection_add_bookmark (GtkFileSelection *fs, gchar *desc, gchar *path)
 960 {
 961   /* Add item to menu */
 962   BookmarkMenuStruct *item;
 963   item=g_malloc(sizeof(item));
 964   item->desc = (gpointer) desc;
 965   item->path = (gpointer) path;
 966   item->menu_item=gtk_menu_item_new_with_label (item->desc);
 967   gtk_widget_show(item->menu_item);
 968   fs->bookmark_list=g_list_append(fs->bookmark_list,item);
 969   gtk_signal_connect (GTK_OBJECT(item->menu_item), "activate",
 970                       (GtkSignalFunc) gtk_file_selection_bookmark_callback,
 971                       (gpointer) fs);
 972   gtk_menu_insert (GTK_MENU(fs->bookmark_menu), item->menu_item, g_list_length(fs->bookmark_list) -1);
 973 }
 974
 975 gint
 976 gtk_file_selection_save_bookmarks (GtkFileSelection *fs)
 977 {
 978   BookmarkMenuStruct *item;
 979   gchar *bookmark_file;
 980   gchar *item_data;
 981   gint   file;
 982   GList *list;
 983
 984   bookmark_file=g_strconcat(g_get_home_dir(), BOOKMARK_FILE ,NULL);
 985
 986   if ((file = open(bookmark_file, O_CREAT | O_WRONLY | O_TRUNC, 0600)) > 0)
 987   {
 988     for (list = g_list_first (fs->bookmark_list); list != NULL; list = g_list_next(list)) {
 989       item = list->data;
 990       item_data = g_strconcat(item->desc, " <", item->path, ">\n", NULL);
 991       if (write (file, item_data, strlen(item_data)) != strlen(item_data)) {
 992         return TRUE;
 993       }
 994       g_free(item_data);
 995     }
 996
 997     close(file);
 998   } else {
 999     return TRUE;
1000   }
1001
1002   return FALSE;
1003 }
1004
1005 static void
1006 gtk_file_selection_load_masks(GtkFileSelection *fs)
1007 {
1008   /*
1009   GList *list;
1010   gchar *masks_file;
1011   gchar *masks_data;
1012   struct stat file_info;
1013   gint   file;
1014   gint   lp;
1015   gint   cp;
1016
1017   if(fs->masks){
1018     list=fs->masks;
1019     while(list){
1020       g_free(list->data);
1021       list=list->next;
1022     }
1023     fs->masks = NULL;
1024   }
1025
1026   masks_file=g_strconcat(g_get_home_dir(), MASK_FILE,NULL); //put in #define
1027   if(!stat(masks_file,&file_info))
1028   {
1029     if(file_info.st_size <65536 )
1030     {
1031       masks_data=g_malloc(file_info.st_size);
1032
1033       file = open(masks_file,  O_RDONLY );
1034
1035       if(file && read(file, masks_data, file_info.st_size))
1036       {
1037         cp=lp=0;
1038
1039         while (cp < file_info.st_size)
1040         {
1041           while (cp < file_info.st_size && masks_data[cp] != '>' )
1042             cp++;
1043
1044           masks_data[++cp]=0;
1045           if (masks_data[lp]=='<') { //if there was no description, strip off brackets
1046             lp++;
1047             masks_data[cp-1]=0;
1048           }
1049 //          g_print("%s\n",masks_data+lp);
1050           fs->masks = g_list_append(fs->masks, g_strdup(masks_data+lp));
1051
1052           while(cp < file_info.st_size && masks_data[cp] < 33 )
1053             cp++;
1054           lp=cp;
1055         }
1056       }
1057
1058       close(file);
1059     }
1060   }
1061   */
1062   if (!fs->masks) {
1063     /* masks is still null, fill it with default data... */
1064     /*
1065     fs->masks = g_list_append(fs->masks, "all files <*>");
1066     fs->masks = g_list_append(fs->masks, "mp3s/playlists <*.mp3,*.m3u>");
1067     fs->masks = g_list_append(fs->masks, "src/hdr <*.[CcHh],*.[Cc][Cc],*.[Hh][Hh],*.cpp>");
1068     fs->masks = g_list_append(fs->masks, "html docs <*.html,*.htm,*.HTM,*.php*,*.inc>");
1069     fs->masks = g_list_append(fs->masks, "images <*.png,*.jpg,*.jpeg,*.gif,*.xpm,*.tiff>");
1070     fs->masks = g_list_append(fs->masks, "package <*.rpm,*.deb>");
1071     fs->masks = g_list_append(fs->masks, "archive <*.tgz,*.tb2,*.tar*,*.zip,*.rar>");
1072     fs->masks = g_list_append(fs->masks, "compressed <*.Z,*.gz,*.bz2>");
1073     */
1074   }
1075 }
1076
1077 void gtk_file_selection_clear_masks (GtkFileSelection *filesel)
1078 {
1079   GList *list;
1080
1081   g_return_if_fail (filesel != NULL);
1082   g_return_if_fail (GTK_IS_FILE_SELECTION (filesel));
1083
1084   list = filesel->masks;
1085   while (list)
1086     {
1087       g_free (list->data);
1088       list = list->next;
1089     }
1090   filesel->masks = NULL;
1091
1092   gtk_list_clear_items (GTK_LIST (GTK_COMBO (filesel->mask_entry)->list), 0, -1);
1093 }
1094
1095 void gtk_file_selection_set_masks (GtkFileSelection *filesel, const gchar **masks)
1096 {
1097   g_return_if_fail (filesel != NULL);
1098   g_return_if_fail (GTK_IS_FILE_SELECTION (filesel));
1099
1100   while (*masks)
1101     {
1102       filesel->masks = g_list_append (filesel->masks, (gpointer)*masks);
1103       masks++;
1104     }
1105
1106   if (filesel->masks)
1107     gtk_combo_set_popdown_strings (GTK_COMBO (filesel->mask_entry), filesel->masks);
1108 }
1109
1110 GtkType
1111 gtk_file_selection_get_type (void)
1112 {
1113   static GtkType file_selection_type = 0;
1114
1115   if (!file_selection_type)
1116     {
1117       static const GtkTypeInfo filesel_info =
1118       {
1119         "GtkFileSelection",
1120         sizeof (GtkFileSelection),
1121         sizeof (GtkFileSelectionClass),
1122         (GtkClassInitFunc) gtk_file_selection_class_init,
1123         (GtkObjectInitFunc) gtk_file_selection_init,
1124         /* reserved_1 */ NULL,
1125         /* reserved_2 */ NULL,
1126         (GtkClassInitFunc) NULL,
1127       };
1128
1129       file_selection_type = gtk_type_unique (GTK_TYPE_WINDOW, &filesel_info);
1130     }
1131
1132   return file_selection_type;
1133 }
1134
1135 static void
1136 gtk_file_selection_class_init (GtkFileSelectionClass *class)
1137 {
1138   GtkObjectClass *object_class;
1139   GtkWidgetClass *widget_class;
1140
1141   object_class = (GtkObjectClass*) class;
1142
1143   parent_class = gtk_type_class (GTK_TYPE_WINDOW);
1144
1145   widget_class = GTK_WIDGET_CLASS (class);
1146
1147   widget_class->realize = gtk_file_selection_realize;
1148   object_class->destroy = gtk_file_selection_destroy;
1149 }
1150
1151 static void
1152 gtk_file_selection_init (GtkFileSelection *filesel)
1153 {
1154   GtkWidget *entry_vbox;
1155   GtkWidget *label;
1156   GtkWidget *list_vbox;
1157   GtkWidget *confirm_area;
1158   GtkWidget *vbox;
1159   GtkWidget *hbox;
1160   GtkWidget *hbox2;
1161   GtkWidget *table;
1162   GtkWidget *pulldown_hbox;
1163   GtkWidget *scrolled_win;
1164   GtkWidget *mask_label;
1165   GtkWidget *bigframe;
1166   GtkWidget *button;
1167   GtkWidget *hpaned;
1168   GtkWidget *menu_item;
1169   GtkWidget *pixmap;
1170
1171   char *dir_title [2];
1172   char *file_title [2];
1173
1174   filesel->cmpl_state = cmpl_init_state ();
1175
1176   filesel->mask=NULL;
1177   filesel->prev_history=NULL;
1178   filesel->next_history=NULL;
1179   filesel->saved_entry=NULL;
1180   filesel->bookmark_list=NULL;
1181   filesel->masks=NULL;
1182   filesel->selection_text = NULL;
1183   filesel->fileop_data = NULL;
1184
1185   gtk_file_selection_load_masks(filesel);
1186   gtk_file_selection_load_bookmarks(filesel);
1187
1188   /* The dialog-sized vertical box  */
1189   filesel->main_vbox = gtk_vbox_new (FALSE, 0);
1190   gtk_container_set_border_width (GTK_CONTAINER (filesel), 0);
1191   gtk_container_add (GTK_CONTAINER (filesel), filesel->main_vbox);
1192   gtk_widget_show (filesel->main_vbox);
1193
1194   /* hbox for pulldown menu */
1195   pulldown_hbox = gtk_hbox_new (FALSE, 0);
1196   gtk_box_pack_start (GTK_BOX (filesel->main_vbox), pulldown_hbox, FALSE, FALSE, 0);
1197   gtk_widget_show (pulldown_hbox);
1198
1199   /* The horizontal box containing create, rename etc. buttons */
1200
1201 /*
1202   filesel->button_area = gtk_hbutton_box_new ();
1203   gtk_button_box_set_layout(GTK_BUTTON_BOX(filesel->button_area), GTK_BUTTONBOX_START);
1204   gtk_button_box_set_spacing(GTK_BUTTON_BOX(filesel->button_area), 0);
1205   gtk_box_pack_start (GTK_BOX (pulldown_hbox), filesel->button_area,
1206                       FALSE, FALSE, 0);
1207   gtk_button_box_set_child_size(GTK_BUTTON_BOX(filesel->button_area),0,0);
1208   gtk_button_box_set_child_ipadding(GTK_BUTTON_BOX(filesel->button_area),0,0);
1209   */
1210
1211   filesel->button_area = gtk_hbox_new (TRUE,0);
1212   //gtk_box_pack_start (GTK_BOX (pulldown_hbox), filesel->button_area,
1213   //                  FALSE, FALSE, 0);
1214
1215   //gtk_widget_show (filesel->button_area);
1216
1217   gtk_file_selection_show_fileop_buttons(filesel);
1218   /*  frame to put the following hbox in  */
1219   bigframe = gtk_frame_new (NULL);
1220   gtk_box_pack_start (GTK_BOX (filesel->main_vbox), bigframe, TRUE, TRUE, 0);
1221   gtk_frame_set_shadow_type (GTK_FRAME (bigframe), GTK_SHADOW_OUT);
1222   gtk_widget_show (bigframe);
1223
1224
1225   list_vbox = gtk_vbox_new (FALSE,3);
1226   gtk_widget_show(list_vbox);
1227   gtk_container_add (GTK_CONTAINER(bigframe), list_vbox);
1228   gtk_container_set_border_width (GTK_CONTAINER (list_vbox),2);
1229   gtk_widget_show (list_vbox);
1230
1231   /*  The horizontal box containing the directory and file listboxes  */
1232 //  list_hbox = gtk_hbox_new (FALSE, 3);
1233   //gtk_container_add (GTK_CONTAINER(bigframe), list_hbox);
1234   //gtk_container_set_border_width (GTK_CONTAINER (list_hbox), 3);
1235 //  gtk_box_pack_start(GTK_BOX(list_vbox), list_hbox, FALSE,FALSE,0);
1236 //  gtk_widget_show (list_hbox);
1237
1238   hpaned=gtk_hpaned_new();
1239   gtk_widget_show(hpaned);
1240   gtk_container_set_border_width (GTK_CONTAINER (hpaned), 1);
1241   gtk_paned_set_gutter_size (GTK_PANED (hpaned), 10);
1242   gtk_box_pack_start (GTK_BOX(list_vbox), hpaned,TRUE,TRUE,0);
1243
1244   /* vbox to put the buttons and directory listing in  */
1245   vbox = gtk_vbox_new (FALSE, 3);
1246   gtk_widget_show (vbox);
1247   gtk_container_add(GTK_CONTAINER(hpaned),vbox);
1248   //gtk_box_pack_start (GTK_BOX (hpaned), vbox, FALSE, FALSE, 0);
1249
1250   hbox = gtk_hbox_new (FALSE, 4);
1251   gtk_widget_show (hbox);
1252   gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0);
1253
1254 //  home_button = gtk_button_new_with_label (_("Home"));
1255 //  gtk_widget_show (home_button);
1256 //  gtk_signal_connect (GTK_OBJECT (home_button), "clicked",
1257 //                    (GtkSignalFunc) gtk_file_selection_home_button,
1258 //                    (gpointer) filesel);
1259 //  gtk_box_pack_start (GTK_BOX (hbox), home_button, TRUE,TRUE, 0);
1260
1261   /* Here we add the bookmark menu button */
1262   #define If we're going to make bookmark a menu, we don't need
1263   #define   to keep it in the filesel structure
1264   button=gtk_button_new_with_label(_("Bookmarks"));
1265   gtk_widget_show(button);
1266   gtk_box_pack_start (GTK_BOX(hbox), button, FALSE,FALSE,0);
1267   gtk_signal_connect (GTK_OBJECT (button), "clicked",
1268                       (GtkSignalFunc) gtk_file_selection_bookmark_button,
1269                       (gpointer) filesel);
1270
1271   hbox2 = gtk_hbox_new (FALSE, 2);
1272   gtk_box_pack_start (GTK_BOX (hbox), hbox2, FALSE, FALSE, 0);
1273   gtk_widget_show(hbox2);
1274
1275   /* Prev button */
1276   button = gtk_button_new ();
1277   gtk_signal_connect (GTK_OBJECT (button), "clicked",
1278                       (GtkSignalFunc) gtk_file_selection_prev_button,
1279                       (gpointer) filesel);
1280   gtk_widget_show (button);
1281   gtk_box_pack_start (GTK_BOX (hbox2), button, FALSE,FALSE, 0);
1282   pixmap = create_pixmap (filesel->main_vbox, (gpointer) back_xpm);
1283   gtk_widget_show (pixmap);
1284   gtk_container_add (GTK_CONTAINER (button), pixmap);
1285
1286   /* Up button */
1287   button = gtk_button_new ();
1288   gtk_signal_connect (GTK_OBJECT (button), "clicked",
1289                       (GtkSignalFunc) gtk_file_selection_up_button,
1290                       (gpointer) filesel);
1291   gtk_widget_show (button);
1292   gtk_box_pack_start (GTK_BOX (hbox2), button, FALSE,FALSE, 0);
1293   pixmap = create_pixmap (filesel->main_vbox, (gpointer) up_xpm);
1294   gtk_widget_show (pixmap);
1295   gtk_container_add (GTK_CONTAINER (button), pixmap);
1296
1297   /* next button */
1298   button = gtk_button_new ();
1299   gtk_widget_show (button);
1300   gtk_signal_connect (GTK_OBJECT (button), "clicked",
1301                       (GtkSignalFunc) gtk_file_selection_next_button,
1302                       (gpointer) filesel);
1303   gtk_box_pack_start (GTK_BOX (hbox2), button, FALSE,FALSE, 0);
1304   pixmap = create_pixmap (filesel->main_vbox, (gpointer) forward_xpm);
1305   gtk_widget_show (pixmap);
1306   gtk_container_add (GTK_CONTAINER (button), pixmap);
1307
1308   /* refresh button */
1309   button = gtk_button_new ();
1310   gtk_widget_show (button);
1311   gtk_signal_connect (GTK_OBJECT (button), "clicked",
1312                       (GtkSignalFunc) gtk_file_selection_refresh_button,
1313                       (gpointer) filesel);
1314   gtk_box_pack_end (GTK_BOX (hbox), button, FALSE,FALSE, 0);
1315   pixmap = create_pixmap (filesel->main_vbox, (gpointer) refresh_xpm);
1316   gtk_widget_show (pixmap);
1317   gtk_container_add (GTK_CONTAINER (button), pixmap);
1318
1319   /* menu for right click file operations */
1320   filesel->fileop_menu = gtk_menu_new();
1321
1322   menu_item = gtk_menu_item_new_with_label (_("Rename..."));
1323   gtk_widget_show(menu_item);
1324   gtk_signal_connect_object (GTK_OBJECT (menu_item), "activate",
1325                              (GtkSignalFunc) gtk_file_selection_rename_file,
1326                              (gpointer) filesel);
1327   gtk_menu_append (GTK_MENU (filesel->fileop_menu), menu_item);
1328
1329   menu_item = gtk_menu_item_new_with_label (_("Delete"));
1330   gtk_widget_show(menu_item);
1331   gtk_menu_append (GTK_MENU (filesel->fileop_menu), menu_item);
1332   gtk_signal_connect_object (GTK_OBJECT (menu_item), "activate",
1333                              (GtkSignalFunc) gtk_file_selection_delete_file,
1334                              (gpointer) filesel);
1335
1336   menu_item = gtk_menu_item_new ();
1337   gtk_widget_show(menu_item);
1338   gtk_menu_append (GTK_MENU (filesel->fileop_menu), menu_item);
1339
1340   menu_item = gtk_menu_item_new_with_label (_("Create Directory..."));
1341   gtk_signal_connect_object (GTK_OBJECT (menu_item), "activate",
1342                              (GtkSignalFunc) gtk_file_selection_create_dir,
1343                              (gpointer) filesel);
1344   gtk_widget_show(menu_item);
1345   gtk_menu_append (GTK_MENU (filesel->fileop_menu), menu_item);
1346
1347   menu_item = gtk_menu_item_new ();
1348   gtk_menu_append (GTK_MENU (filesel->fileop_menu), menu_item);
1349   gtk_widget_show(menu_item);
1350
1351   menu_item = gtk_menu_item_new_with_label (_("Properties..."));
1352   gtk_signal_connect_object (GTK_OBJECT (menu_item), "activate",
1353                              (GtkSignalFunc) gtk_file_selection_properties,
1354                              (gpointer) filesel);
1355   gtk_menu_append (GTK_MENU (filesel->fileop_menu), menu_item);
1356   gtk_widget_show(menu_item);
1357
1358   /* The directories clist */
1359   dir_title[0] = _("Directories");
1360   dir_title[1] = NULL;
1361   filesel->dir_list = gtk_clist_new_with_titles (1, (gchar**) dir_title);
1362   gtk_widget_set_usize (filesel->dir_list, DIR_LIST_WIDTH, DIR_LIST_HEIGHT);
1363   gtk_signal_connect (GTK_OBJECT (filesel->dir_list), "select_row",
1364                       (GtkSignalFunc) gtk_file_selection_dir_button,
1365                       (gpointer) filesel);
1366   gtk_signal_connect (GTK_OBJECT (filesel->dir_list), "unselect_row",
1367                       (GtkSignalFunc) gtk_file_selection_undir_button,
1368                       (gpointer) filesel);
1369   gtk_signal_connect (GTK_OBJECT (filesel->dir_list), "button_press_event",
1370                       GTK_SIGNAL_FUNC(gtk_file_selection_show_fileop_menu),
1371                       (gpointer) filesel);
1372
1373   gtk_clist_column_titles_passive (GTK_CLIST (filesel->dir_list));
1374
1375   scrolled_win = gtk_scrolled_window_new (NULL, NULL);
1376   gtk_container_add (GTK_CONTAINER (scrolled_win), filesel->dir_list);
1377   gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_win),
1378                                   GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
1379   gtk_box_pack_start (GTK_BOX (vbox), scrolled_win, TRUE,TRUE, 0);
1380   //gtk_container_add(GTK_CONTAINER(hpaned), scrolled_win);
1381
1382   gtk_widget_show (filesel->dir_list);
1383   gtk_widget_show (scrolled_win);
1384
1385   vbox = gtk_vbox_new (FALSE, 3);
1386   gtk_widget_show (vbox);
1387   gtk_container_add(GTK_CONTAINER(hpaned),vbox);
1388   /* vbox area for mask entry and files clist  */
1389
1390   hbox = gtk_hbox_new (FALSE, 2);
1391   gtk_widget_show (hbox);
1392   gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0);
1393
1394   mask_label = gtk_label_new (_("Mask:"));
1395   gtk_widget_show (mask_label);
1396   gtk_box_pack_start (GTK_BOX (hbox), mask_label, FALSE, FALSE, 2);
1397
1398 /*
1399   filesel->mask_entry = gtk_entry_new ();
1400   gtk_widget_show (filesel->mask_entry);
1401   gtk_signal_connect(GTK_OBJECT(filesel->mask_entry),"activate",
1402                      (GtkSignalFunc) gtk_file_4_mask_entry_callback,
1403                      (gpointer) filesel);
1404   gtk_box_pack_start (GTK_BOX (hbox),filesel->mask_entry, TRUE, TRUE, 0);
1405   */
1406
1407   filesel->mask_entry = gtk_combo_new ();
1408   gtk_widget_show (filesel->mask_entry);
1409   gtk_combo_set_value_in_list(GTK_COMBO(filesel->mask_entry),FALSE,FALSE);
1410   gtk_signal_connect(GTK_OBJECT(GTK_COMBO(filesel->mask_entry)->entry),"activate",
1411                      (GtkSignalFunc) gtk_file_selection_mask_entry_callback,
1412                      (gpointer) filesel);
1413   gtk_signal_connect(GTK_OBJECT(((GtkCombo *)filesel->mask_entry)->entry),"key-press-event",
1414                      (GtkSignalFunc) gtk_file_selection_mask_entry_key_callback,
1415                      (gpointer) filesel);
1416
1417   gtk_signal_connect(GTK_OBJECT(((GtkCombo *)filesel->mask_entry)->list),"button-release-event",
1418                      (GtkSignalFunc) gtk_file_selection_mask_entry_button_callback,
1419                      (gpointer) filesel);
1420   gtk_box_pack_start (GTK_BOX (hbox),filesel->mask_entry, TRUE, TRUE, 0);
1421
1422   if (filesel->masks)
1423     gtk_combo_set_popdown_strings (GTK_COMBO (filesel->mask_entry), filesel->masks);
1424
1425
1426   /* The files clist */
1427   file_title[0] = _("Files");
1428   file_title[1] = NULL;
1429   filesel->file_list = gtk_clist_new_with_titles (1, (gchar**) file_title);
1430   gtk_widget_set_usize (filesel->file_list, FILE_LIST_WIDTH, FILE_LIST_HEIGHT);
1431   gtk_signal_connect (GTK_OBJECT (filesel->file_list), "select_row",
1432                       (GtkSignalFunc) gtk_file_selection_file_button,
1433                       (gpointer) filesel);
1434   gtk_signal_connect (GTK_OBJECT (filesel->file_list), "key-press-event",
1435                       (GtkSignalFunc) gtk_file_selection_files_list_key_callback,
1436                       (gpointer) filesel);
1437
1438   gtk_signal_connect (GTK_OBJECT (filesel->file_list), "button_press_event",
1439                       GTK_SIGNAL_FUNC(gtk_file_selection_show_fileop_menu),
1440                       (gpointer) filesel);
1441
1442   gtk_clist_column_titles_passive (GTK_CLIST (filesel->file_list));
1443
1444   scrolled_win = gtk_scrolled_window_new (NULL, NULL);
1445   gtk_container_add (GTK_CONTAINER (scrolled_win), filesel->file_list);
1446   gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_win),
1447                                   GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
1448   gtk_box_pack_start (GTK_BOX (vbox), scrolled_win, TRUE, TRUE, 0);
1449   gtk_widget_show (filesel->file_list);
1450   gtk_widget_show (scrolled_win);
1451
1452   /* action area for packing buttons into. */
1453   filesel->action_area = gtk_hbox_new (TRUE, 0);
1454   gtk_box_pack_start (GTK_BOX (filesel->main_vbox), filesel->action_area,
1455                       FALSE, FALSE, 2);
1456   gtk_widget_show (filesel->action_area);
1457
1458   /*
1459   hbox=gtk_hbox_new(FALSE,0);
1460   gtk_box_pack_end (GTK_BOX (filesel->main_vbox), hbox, FALSE,FALSE, 0);
1461   gtk_widget_show (hbox);
1462   */
1463
1464   /*  The selection entry widget  */
1465
1466   entry_vbox = gtk_vbox_new (FALSE, 0);
1467   gtk_box_pack_end (GTK_BOX (filesel->main_vbox), entry_vbox, FALSE, FALSE, 0);
1468   gtk_widget_show (entry_vbox);
1469
1470   table = gtk_table_new ( 2, 2, FALSE );
1471   gtk_box_pack_start (GTK_BOX (entry_vbox), table, TRUE, TRUE, 0);
1472   gtk_container_set_border_width (GTK_CONTAINER (table), 4);
1473   gtk_table_set_row_spacings (GTK_TABLE (table), 2);
1474   gtk_table_set_col_spacings (GTK_TABLE (table), 4);
1475
1476
1477   label = gtk_label_new (_("Selection:"));
1478   gtk_table_attach (GTK_TABLE (table), label, 0, 1, 0, 1,
1479                     (GtkAttachOptions) (0),
1480                     (GtkAttachOptions) (0), 0, 0);
1481   gtk_widget_show (label);
1482
1483
1484   filesel->selection_entry = gtk_entry_new ();
1485   gtk_signal_connect (GTK_OBJECT (filesel->selection_entry), "key_press_event",
1486                       (GtkSignalFunc) gtk_file_selection_key_press, filesel);
1487   gtk_table_attach (GTK_TABLE (table), filesel->selection_entry, 1, 2, 0, 1,
1488                     (GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
1489                     (GtkAttachOptions) (0), 0, 0);
1490   gtk_widget_show (filesel->selection_entry);
1491
1492
1493   label = gtk_label_new (_("Directory:"));
1494   gtk_table_attach (GTK_TABLE (table), label, 0, 1, 1, 2,
1495                     (GtkAttachOptions) (0),
1496                     (GtkAttachOptions) (0), 0, 0);
1497   gtk_widget_show (label);
1498
1499
1500   filesel->history_combo = gtk_combo_new();
1501   gtk_combo_set_value_in_list(GTK_COMBO(filesel->history_combo),FALSE,FALSE);
1502   gtk_table_attach (GTK_TABLE (table), filesel->history_combo, 1, 2, 1, 2,
1503                     (GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
1504                     (GtkAttachOptions) (0), 0, 0);
1505   gtk_widget_show(filesel->history_combo);
1506
1507   gtk_signal_connect(GTK_OBJECT(((GtkCombo *)filesel->history_combo)->entry),"key-press-event",
1508                      (GtkSignalFunc) gtk_file_selection_history_combo_callback,
1509                      (gpointer) filesel);
1510
1511   gtk_signal_connect(GTK_OBJECT(((GtkCombo *)filesel->history_combo)->list),"button-press-event",
1512                      (GtkSignalFunc) gtk_file_selection_history_combo_list_callback,
1513                      (gpointer) filesel);
1514
1515   gtk_signal_connect(GTK_OBJECT(((GtkCombo *)filesel->history_combo)->list),"key-press-event",
1516                      (GtkSignalFunc) gtk_file_selection_history_combo_list_key_handler,
1517                      (gpointer) filesel);
1518
1519   filesel->selection_text = NULL;
1520
1521
1522   /*  The OK/Cancel button area */
1523   confirm_area = gtk_hbutton_box_new ();
1524   gtk_button_box_set_layout(GTK_BUTTON_BOX(confirm_area), GTK_BUTTONBOX_END);
1525   gtk_button_box_set_spacing(GTK_BUTTON_BOX(confirm_area), 5);
1526   gtk_box_pack_end (GTK_BOX (entry_vbox), confirm_area, FALSE, FALSE, 0);
1527   gtk_widget_show (confirm_area);
1528
1529   /*  The OK button  */
1530   filesel->ok_button = gtk_button_new_with_label (_("OK"));
1531   GTK_WIDGET_SET_FLAGS (filesel->ok_button, GTK_CAN_DEFAULT);
1532   gtk_box_pack_start (GTK_BOX (confirm_area), filesel->ok_button, TRUE, TRUE, 0);
1533   gtk_signal_connect_object (GTK_OBJECT (filesel->selection_entry), "focus_in_event",
1534                              (GtkSignalFunc) gtk_widget_grab_default,
1535                              GTK_OBJECT (filesel->ok_button));
1536   gtk_signal_connect_object (GTK_OBJECT (filesel->selection_entry), "activate",
1537                              (GtkSignalFunc) gtk_button_clicked,
1538                              GTK_OBJECT (filesel->ok_button));
1539   gtk_widget_grab_default (filesel->ok_button);
1540   gtk_widget_show (filesel->ok_button);
1541
1542   /*  The Cancel button  */
1543   filesel->cancel_button = gtk_button_new_with_label (_("Cancel"));
1544   GTK_WIDGET_SET_FLAGS (filesel->cancel_button, GTK_CAN_DEFAULT);
1545   gtk_box_pack_start (GTK_BOX (confirm_area), filesel->cancel_button, TRUE, TRUE, 0);
1546   gtk_widget_show (filesel->cancel_button);
1547
1548   gtk_widget_show(table);
1549
1550
1551   /*
1552   filesel->selection_text = label = gtk_label_new ("");
1553   gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
1554   gtk_box_pack_start (GTK_BOX (entry_vbox), label, FALSE, FALSE, 0);
1555   gtk_widget_show (label);
1556   */
1557
1558
1559   if (!cmpl_state_okay (filesel->cmpl_state))
1560     {
1561       gchar err_buf[256];
1562
1563       sprintf (err_buf, _("Directory unreadable: %s"), cmpl_strerror (cmpl_errno));
1564
1565       /*
1566       gtk_label_set_text (GTK_LABEL (filesel->selection_text), err_buf);
1567       */
1568     }
1569   else
1570     {
1571       gtk_file_selection_populate (filesel, "", FALSE);
1572     }
1573
1574   gtk_widget_grab_focus (filesel->selection_entry);
1575 }
1576
1577 GtkWidget*
1578 gtk_file_selection_new (const gchar *title)
1579 {
1580   GtkFileSelection *filesel;
1581
1582   filesel = gtk_type_new (GTK_TYPE_FILE_SELECTION);
1583   gtk_window_set_title (GTK_WINDOW (filesel), title);
1584   /* !!! put check here to figure out if screen > 640x480, if true
1585      We need to make the file selection dialog bigger. much bigger..
1586      or maybe we should keep it at a certan percentage of the screen
1587      size? */
1588
1589   gtk_window_set_default_size(GTK_WINDOW (filesel), 520, 420);
1590   return GTK_WIDGET (filesel);
1591 }
1592
1593 void
1594 gtk_file_selection_show_fileop_buttons (GtkFileSelection *filesel)
1595 {
1596   g_return_if_fail (filesel != NULL);
1597   g_return_if_fail (GTK_IS_FILE_SELECTION (filesel));
1598
1599   return;
1600
1601   /* delete, create directory, and rename */
1602 /*
1603   if (!filesel->fileop_c_dir)
1604     {
1605       filesel->fileop_c_dir = gtk_button_new_with_label (_("MkDir"));
1606       gtk_signal_connect (GTK_OBJECT (filesel->fileop_c_dir), "clicked",
1607                           (GtkSignalFunc) gtk_file_selection_create_dir,
1608                           (gpointer) filesel);
1609       gtk_box_pack_start (GTK_BOX (filesel->button_area),
1610                           filesel->fileop_c_dir, TRUE,TRUE, 0);
1611       gtk_widget_show (filesel->fileop_c_dir);
1612     }
1613
1614   if (!filesel->fileop_del_file)
1615     {
1616       filesel->fileop_del_file = gtk_button_new_with_label (_("Delete"));
1617       gtk_signal_connect (GTK_OBJECT (filesel->fileop_del_file), "clicked",
1618                           (GtkSignalFunc) gtk_file_selection_delete_file,
1619                           (gpointer) filesel);
1620       gtk_box_pack_start (GTK_BOX (filesel->button_area),
1621                           filesel->fileop_del_file, TRUE,TRUE, 0);
1622       gtk_widget_show (filesel->fileop_del_file);
1623     }
1624
1625   if (!filesel->fileop_ren_file)
1626     {
1627       filesel->fileop_ren_file = gtk_button_new_with_label (_("Rename"));
1628       gtk_signal_connect (GTK_OBJECT (filesel->fileop_ren_file), "clicked",
1629                           (GtkSignalFunc) gtk_file_selection_rename_file,
1630                           (gpointer) filesel);
1631       gtk_box_pack_start (GTK_BOX (filesel->button_area),
1632                           filesel->fileop_ren_file, TRUE,TRUE, 0);
1633       gtk_widget_show (filesel->fileop_ren_file);
1634     }
1635
1636   gtk_widget_queue_resize(GTK_WIDGET(filesel));
1637   */
1638 }
1639
1640 void
1641 gtk_file_selection_hide_fileop_buttons (GtkFileSelection *filesel)
1642 {
1643   g_return_if_fail (filesel != NULL);
1644   g_return_if_fail (GTK_IS_FILE_SELECTION (filesel));
1645
1646   return;
1647   /*
1648   if (filesel->fileop_ren_file)
1649     {
1650       gtk_widget_destroy (filesel->fileop_ren_file);
1651       filesel->fileop_ren_file = NULL;
1652     }
1653
1654   if (filesel->fileop_del_file)
1655     {
1656       gtk_widget_destroy (filesel->fileop_del_file);
1657       filesel->fileop_del_file = NULL;
1658     }
1659
1660   if (filesel->fileop_c_dir)
1661     {
1662       gtk_widget_destroy (filesel->fileop_c_dir);
1663       filesel->fileop_c_dir = NULL;
1664     }
1665   */
1666 }
1667
1668
1669
1670 void
1671 gtk_file_selection_set_filename (GtkFileSelection *filesel,
1672                                  const gchar      *filename)
1673 {
1674   char  buf[MAXPATHLEN];
1675   const char *name, *last_slash;
1676
1677   g_return_if_fail (filesel != NULL);
1678   g_return_if_fail (GTK_IS_FILE_SELECTION (filesel));
1679   g_return_if_fail (filename != NULL);
1680
1681   last_slash = strrchr (filename, '/');
1682
1683   if (!last_slash)
1684     {
1685       buf[0] = 0;
1686       name = filename;
1687     }
1688   else
1689     {
1690       gint len = MIN (MAXPATHLEN - 1, last_slash - filename + 1);
1691
1692       strncpy (buf, filename, len);
1693       buf[len] = 0;
1694
1695       name = last_slash + 1;
1696     }
1697
1698   gtk_file_selection_populate (filesel, buf, FALSE);
1699
1700   if (filesel->selection_entry)
1701     gtk_entry_set_text (GTK_ENTRY (filesel->selection_entry), name);
1702 }
1703
1704 gchar*
1705 gtk_file_selection_get_filename (GtkFileSelection *filesel)
1706 {
1707   static char nothing[2] = "";
1708   char *text;
1709   char *filename;
1710
1711   g_return_val_if_fail (filesel != NULL, nothing);
1712   g_return_val_if_fail (GTK_IS_FILE_SELECTION (filesel), nothing);
1713
1714   text = gtk_entry_get_text (GTK_ENTRY (filesel->selection_entry));
1715   if (text)
1716     {
1717       filename = cmpl_completion_fullname (text, filesel->cmpl_state);
1718       return filename;
1719     }
1720
1721   return nothing;
1722 }
1723
1724 void
1725 gtk_file_selection_complete (GtkFileSelection *filesel,
1726                              const gchar      *pattern)
1727 {
1728   gchar *new_pattern;
1729   gint x;
1730
1731   g_return_if_fail (filesel != NULL);
1732   g_return_if_fail (GTK_IS_FILE_SELECTION (filesel));
1733   g_return_if_fail (pattern != NULL);
1734
1735   if (filesel->selection_entry)
1736     gtk_entry_set_text (GTK_ENTRY (filesel->selection_entry), pattern);
1737
1738   if(strchr(pattern,'*') || strchr(pattern,'?'))
1739     {
1740       for(x=strlen(pattern);x>=0;x--)
1741         {
1742           if(pattern[x]=='/') break;
1743         }
1744       gtk_entry_set_text(GTK_ENTRY(filesel->mask_entry),g_strdup(pattern+x+1));
1745
1746       if(filesel->mask) g_free(filesel->mask);
1747
1748       filesel->mask=g_strdup(pattern+x+1);
1749       new_pattern=g_strdup(pattern);
1750       new_pattern[x+1]=0;
1751       gtk_file_selection_populate (filesel, (gchar*) new_pattern, TRUE);
1752       g_free(new_pattern);
1753     }
1754   else
1755     {
1756       gtk_file_selection_populate (filesel, (gchar*) pattern, TRUE);
1757     }
1758 }
1759
1760 static void
1761 gtk_file_selection_realize (GtkWidget *widget)
1762 {
1763   GtkFileSelection *filesel;
1764   const gchar *masks[] = { "All Files <*>", NULL };
1765
1766   g_return_if_fail (widget != NULL);
1767   g_return_if_fail (GTK_IS_FILE_SELECTION (widget));
1768
1769   filesel = GTK_FILE_SELECTION (widget);
1770
1771   /* make sure that we have at least one mask */
1772   if (!filesel->masks)
1773     gtk_file_selection_set_masks (filesel, masks);
1774
1775   filesel->mask = g_strdup ((gchar*) filesel->masks->data);
1776   gtk_file_selection_populate (filesel, "", FALSE);
1777
1778
1779   if (GTK_WIDGET_CLASS (parent_class)->realize)
1780     (* GTK_WIDGET_CLASS (parent_class)->realize) (widget);
1781 }
1782
1783 static void
1784 gtk_file_selection_destroy (GtkObject *object)
1785 {
1786   GtkFileSelection *filesel;
1787   GList *list;
1788
1789   g_return_if_fail (object != NULL);
1790   g_return_if_fail (GTK_IS_FILE_SELECTION (object));
1791
1792   filesel = GTK_FILE_SELECTION (object);
1793
1794   if (filesel->fileop_dialog)
1795     gtk_widget_destroy (filesel->fileop_dialog);
1796
1797   if (filesel->next_history)
1798     {
1799       list = filesel->next_history;
1800       while (list)
1801         {
1802           g_free (list->data);
1803           list = list->next;
1804         }
1805     }
1806   g_list_free (filesel->next_history);
1807   filesel->next_history = NULL;
1808
1809   if (filesel->prev_history)
1810     {
1811       list = filesel->prev_history;
1812       while (list)
1813         {
1814           g_free (list->data);
1815           list = list->next;
1816         }
1817     }
1818   g_list_free (filesel->prev_history);
1819   filesel->prev_history = NULL;
1820
1821   if (filesel->mask)
1822     {
1823       g_free (filesel->mask);
1824       filesel->mask = NULL;
1825     }
1826
1827   cmpl_free_state (filesel->cmpl_state);
1828   filesel->cmpl_state = NULL;
1829
1830   if (GTK_OBJECT_CLASS (parent_class)->destroy)
1831     (* GTK_OBJECT_CLASS (parent_class)->destroy) (object);
1832 }
1833
1834 /* Begin file operations callbacks */
1835
1836 static gint
1837 gtk_file_selection_show_fileop_menu (GtkCList *clist, GdkEvent *event, GtkFileSelection *fs)
1838 {
1839   GdkEventButton *event_button;
1840
1841   g_return_val_if_fail (clist != NULL, FALSE);
1842   g_return_val_if_fail (GTK_IS_CLIST (clist), FALSE);
1843   g_return_val_if_fail (event != NULL, FALSE);
1844   g_return_val_if_fail (fs != NULL, FALSE);
1845   g_return_val_if_fail (GTK_FILE_SELECTION (fs), FALSE);
1846
1847   if (event->type == GDK_BUTTON_PRESS)
1848     {
1849       event_button = (GdkEventButton *) event;
1850       if (event_button->button == 3)
1851         {
1852
1853           gtk_menu_popup (GTK_MENU (fs->fileop_menu), NULL, NULL, NULL, NULL,
1854                           event_button->button, event_button->time);
1855           return TRUE;
1856         }
1857     }
1858
1859   return FALSE;
1860 }
1861
1862 static void
1863 gtk_file_selection_fileop_error (GtkFileSelection *fs, gchar *error_message)
1864 {
1865   GtkWidget *label;
1866   GtkWidget *vbox;
1867   GtkWidget *button;
1868   GtkWidget *dialog;
1869
1870   g_return_if_fail (error_message != NULL);
1871
1872   /* main dialog */
1873   dialog = gtk_dialog_new ();
1874   /*
1875   gtk_signal_connect (GTK_OBJECT (dialog), "destroy",
1876                       (GtkSignalFunc) gtk_file_selection_fileop_destroy,
1877                       (gpointer) fs);
1878   */
1879   gtk_window_set_title (GTK_WINDOW (dialog), _("Error"));
1880   gtk_window_set_position (GTK_WINDOW (dialog), GTK_WIN_POS_MOUSE);
1881
1882   /* If file dialog is grabbed, make this dialog modal too */
1883   /* When error dialog is closed, file dialog will be grabbed again */
1884   if (GTK_WINDOW(fs)->modal)
1885       gtk_window_set_modal (GTK_WINDOW(dialog), TRUE);
1886
1887   vbox = gtk_vbox_new(FALSE, 0);
1888   gtk_container_set_border_width(GTK_CONTAINER(vbox), 8);
1889   gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->vbox), vbox,
1890                      FALSE, FALSE, 0);
1891   gtk_widget_show(vbox);
1892
1893   label = gtk_label_new(error_message);
1894   gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.0);
1895   gtk_box_pack_start(GTK_BOX(vbox), label, FALSE, FALSE, 5);
1896   gtk_widget_show(label);
1897
1898   /* yes, we free it */
1899   g_free (error_message);
1900
1901   /* close button */
1902   button = gtk_button_new_with_label (_("Close"));
1903   gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
1904                              (GtkSignalFunc) gtk_widget_destroy,
1905                              (gpointer) dialog);
1906   gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->action_area),
1907                      button, TRUE, TRUE, 0);
1908   GTK_WIDGET_SET_FLAGS(button, GTK_CAN_DEFAULT);
1909   gtk_widget_grab_default(button);
1910   gtk_widget_show (button);
1911
1912   gtk_widget_show (dialog);
1913 }
1914
1915 static void
1916 gtk_file_selection_fileop_destroy (GtkWidget *widget, gpointer data)
1917 {
1918   GtkFileSelection *fs = data;
1919
1920   g_return_if_fail (fs != NULL);
1921   g_return_if_fail (GTK_IS_FILE_SELECTION (fs));
1922
1923   fs->fileop_dialog = NULL;
1924   g_free (fs->fileop_data);
1925   fs->fileop_data = NULL;
1926 }
1927
1928
1929 static void
1930 gtk_file_selection_create_dir_confirmed (GtkWidget *widget, gpointer data)
1931 {
1932   GtkFileSelection *fs = data;
1933   gchar *dirname;
1934   gchar *path;
1935   gchar *full_path;
1936   gchar *buf;
1937   CompletionState *cmpl_state;
1938
1939   g_return_if_fail (fs != NULL);
1940   g_return_if_fail (GTK_IS_FILE_SELECTION (fs));
1941
1942   dirname = gtk_entry_get_text (GTK_ENTRY (fs->fileop_entry));
1943   cmpl_state = (CompletionState*) fs->cmpl_state;
1944   path = cmpl_reference_position (cmpl_state);
1945
1946   full_path = g_strconcat (path, "/", dirname, NULL);
1947   if ( (mkdir (full_path, 0755) < 0) )
1948     {
1949       buf = g_strconcat ("Error creating directory \"", dirname, "\":  ",
1950                          g_strerror(errno), NULL);
1951       gtk_file_selection_fileop_error (fs, buf);
1952     }
1953   g_free (full_path);
1954
1955   gtk_widget_destroy (fs->fileop_dialog);
1956   gtk_file_selection_populate (fs, "", FALSE);
1957 }
1958
1959 static void
1960 gtk_file_selection_create_dir (gpointer data)
1961 {
1962   GtkFileSelection *fs = data;
1963   GtkWidget *label;
1964   GtkWidget *dialog;
1965   GtkWidget *vbox;
1966   GtkWidget *button;
1967
1968   g_return_if_fail (fs != NULL);
1969   g_return_if_fail (GTK_IS_FILE_SELECTION (fs));
1970
1971   if (fs->fileop_dialog)
1972           return;
1973
1974   /* main dialog */
1975   fs->fileop_dialog = dialog = gtk_dialog_new ();
1976   gtk_signal_connect (GTK_OBJECT (dialog), "destroy",
1977                       (GtkSignalFunc) gtk_file_selection_fileop_destroy,
1978                       (gpointer) fs);
1979   gtk_window_set_title (GTK_WINDOW (dialog), _("Create Directory"));
1980   gtk_window_set_position (GTK_WINDOW (dialog), GTK_WIN_POS_MOUSE);
1981
1982   /* If file dialog is grabbed, grab option dialog */
1983   /* When option dialog is closed, file dialog will be grabbed again */
1984   if (GTK_WINDOW(fs)->modal)
1985       gtk_window_set_modal (GTK_WINDOW(dialog), TRUE);
1986
1987   vbox = gtk_vbox_new(FALSE, 0);
1988   gtk_container_set_border_width(GTK_CONTAINER(vbox), 8);
1989   gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->vbox), vbox,
1990                      FALSE, FALSE, 0);
1991   gtk_widget_show(vbox);
1992
1993   label = gtk_label_new(_("Directory name:"));
1994   gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.0);
1995   gtk_box_pack_start(GTK_BOX(vbox), label, FALSE, FALSE, 5);
1996   gtk_widget_show(label);
1997
1998   /*  The directory entry widget  */
1999   fs->fileop_entry = gtk_entry_new ();
2000   gtk_box_pack_start (GTK_BOX (vbox), fs->fileop_entry,
2001                       TRUE, TRUE, 5);
2002   GTK_WIDGET_SET_FLAGS(fs->fileop_entry, GTK_CAN_DEFAULT);
2003   gtk_widget_show (fs->fileop_entry);
2004
2005   /* buttons */
2006   button = gtk_button_new_with_label (_("Create"));
2007   gtk_signal_connect (GTK_OBJECT (button), "clicked",
2008                       (GtkSignalFunc) gtk_file_selection_create_dir_confirmed,
2009                       (gpointer) fs);
2010   gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->action_area),
2011                      button, TRUE, TRUE, 0);
2012   GTK_WIDGET_SET_FLAGS(button, GTK_CAN_DEFAULT);
2013   gtk_widget_show(button);
2014
2015   button = gtk_button_new_with_label (_("Cancel"));
2016   gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
2017                              (GtkSignalFunc) gtk_widget_destroy,
2018                              (gpointer) dialog);
2019   gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->action_area),
2020                      button, TRUE, TRUE, 0);
2021   GTK_WIDGET_SET_FLAGS(button, GTK_CAN_DEFAULT);
2022   gtk_widget_grab_default(button);
2023   gtk_widget_show (button);
2024
2025   gtk_widget_show (dialog);
2026 }
2027
2028 static void
2029 gtk_file_selection_delete_file_confirmed (GtkWidget *widget, gpointer data)
2030 {
2031   GtkFileSelection *fs = data;
2032   CompletionState *cmpl_state;
2033   gchar *path;
2034   gchar *full_path;
2035   gchar *buf;
2036
2037   g_return_if_fail (fs != NULL);
2038   g_return_if_fail (GTK_IS_FILE_SELECTION (fs));
2039
2040   cmpl_state = (CompletionState*) fs->cmpl_state;
2041   path = cmpl_reference_position (cmpl_state);
2042
2043   full_path = g_strconcat (path, "/", fs->fileop_file, NULL);
2044   if ( (unlink (full_path) < 0) )
2045     {
2046       buf = g_strconcat ("Error deleting file \"", fs->fileop_file, "\":  ",
2047                          g_strerror(errno), NULL);
2048       gtk_file_selection_fileop_error (fs, buf);
2049     }
2050   g_free (full_path);
2051
2052   gtk_widget_destroy (fs->fileop_dialog);
2053   gtk_file_selection_populate (fs, "", FALSE);
2054 }
2055
2056 static void
2057 gtk_file_selection_delete_file (gpointer data)
2058 {
2059   GtkFileSelection *fs = data;
2060   GtkWidget *label;
2061   GtkWidget *vbox;
2062   GtkWidget *button;
2063   GtkWidget *dialog;
2064   gchar *filename;
2065   gchar *buf;
2066
2067   g_return_if_fail (fs != NULL);
2068   g_return_if_fail (GTK_IS_FILE_SELECTION (fs));
2069
2070   if (fs->fileop_dialog)
2071           return;
2072
2073   filename = gtk_entry_get_text (GTK_ENTRY (fs->selection_entry));
2074   if (strlen(filename) < 1)
2075           return;
2076
2077   fs->fileop_file = filename;
2078
2079   /* main dialog */
2080   fs->fileop_dialog = dialog = gtk_dialog_new ();
2081   gtk_signal_connect (GTK_OBJECT (dialog), "destroy",
2082                       (GtkSignalFunc) gtk_file_selection_fileop_destroy,
2083                       (gpointer) fs);
2084   gtk_window_set_title (GTK_WINDOW (dialog), _("Delete File"));
2085   gtk_window_set_position (GTK_WINDOW (dialog), GTK_WIN_POS_MOUSE);
2086
2087   /* If file dialog is grabbed, grab option dialog */
2088   /* When option dialog is closed, file dialog will be grabbed again */
2089   if (GTK_WINDOW(fs)->modal)
2090       gtk_window_set_modal (GTK_WINDOW(dialog), TRUE);
2091
2092   vbox = gtk_vbox_new(FALSE, 0);
2093   gtk_container_set_border_width(GTK_CONTAINER(vbox), 8);
2094   gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->vbox), vbox,
2095                      FALSE, FALSE, 0);
2096   gtk_widget_show(vbox);
2097
2098   buf = g_strconcat ("Really delete file \"", filename, "\" ?", NULL);
2099   label = gtk_label_new(buf);
2100   gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.0);
2101   gtk_box_pack_start(GTK_BOX(vbox), label, FALSE, FALSE, 5);
2102   gtk_widget_show(label);
2103   g_free(buf);
2104
2105   /* buttons */
2106   button = gtk_button_new_with_label (_("Delete"));
2107   gtk_signal_connect (GTK_OBJECT (button), "clicked",
2108                       (GtkSignalFunc) gtk_file_selection_delete_file_confirmed,
2109                       (gpointer) fs);
2110   gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->action_area),
2111                      button, TRUE, TRUE, 0);
2112   GTK_WIDGET_SET_FLAGS(button, GTK_CAN_DEFAULT);
2113   gtk_widget_show(button);
2114
2115   button = gtk_button_new_with_label (_("Cancel"));
2116   gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
2117                              (GtkSignalFunc) gtk_widget_destroy,
2118                              (gpointer) dialog);
2119   gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->action_area),
2120                      button, TRUE, TRUE, 0);
2121   GTK_WIDGET_SET_FLAGS(button, GTK_CAN_DEFAULT);
2122   gtk_widget_grab_default(button);
2123   gtk_widget_show (button);
2124
2125   gtk_widget_show (dialog);
2126
2127 }
2128
2129 static void
2130 gtk_file_selection_rename_file_confirmed (GtkWidget *widget, gpointer data)
2131 {
2132   GtkFileSelection *fs = data;
2133   gchar *buf;
2134   gchar *file;
2135   gchar *path;
2136   gchar *new_filename;
2137   gchar *old_filename;
2138   CompletionState *cmpl_state;
2139
2140   g_return_if_fail (fs != NULL);
2141   g_return_if_fail (GTK_IS_FILE_SELECTION (fs));
2142
2143   file = gtk_entry_get_text (GTK_ENTRY (fs->fileop_entry));
2144   cmpl_state = (CompletionState*) fs->cmpl_state;
2145   path = cmpl_reference_position (cmpl_state);
2146
2147   new_filename = g_strconcat (path, "/", file, NULL);
2148   old_filename = g_strconcat (path, "/", fs->fileop_file, NULL);
2149
2150   if (strcmp (new_filename, old_filename))
2151     if ((rename (old_filename, new_filename)) < 0)
2152       {
2153         buf = g_strconcat ("Error renaming file \"", file, "\":  ",
2154                            g_strerror(errno), NULL);
2155         gtk_file_selection_fileop_error (fs, buf);
2156       }
2157   g_free (new_filename);
2158   g_free (old_filename);
2159
2160   gtk_widget_destroy (fs->fileop_dialog);
2161   gtk_file_selection_populate (fs, "", FALSE);
2162 }
2163
2164 static void
2165 gtk_file_selection_file_mode_confirmed (GtkWidget *widget, gpointer data)
2166 {
2167   GtkFileSelection *fs = data;
2168   PropertiesPrivate *priv = fs->fileop_data;
2169   CompletionState *cmpl_state;
2170   gchar *filename, *file, *path;
2171   mode_t mode;
2172
2173   mode = gtk_file_selection_properties_get_mode (priv);
2174
2175   file = gtk_entry_get_text (GTK_ENTRY (fs->fileop_entry));
2176   cmpl_state = (CompletionState*) fs->cmpl_state;
2177   path = cmpl_reference_position (cmpl_state);
2178
2179   filename = g_strconcat (path, "/", file, NULL);
2180   if (chmod (filename, mode) == -1)
2181     {
2182       gchar *buf = g_strconcat ("Error changing file mode of \"", filename, "\":  ",
2183                                 g_strerror (errno), NULL);
2184       gtk_file_selection_fileop_error (fs, buf);
2185       gtk_widget_destroy (fs->fileop_dialog);
2186       gtk_file_selection_populate (fs, "", FALSE);
2187     }
2188   else
2189     gtk_file_selection_rename_file_confirmed (widget, data);
2190
2191   g_free (filename);
2192 }
2193
2194 static void
2195 gtk_file_selection_rename_file (gpointer data)
2196 {
2197   GtkFileSelection *fs = data;
2198   GtkWidget *label;
2199   GtkWidget *dialog;
2200   GtkWidget *vbox;
2201   GtkWidget *button;
2202   gchar *buf;
2203
2204   g_return_if_fail (fs != NULL);
2205   g_return_if_fail (GTK_IS_FILE_SELECTION (fs));
2206
2207   if (fs->fileop_dialog)
2208           return;
2209
2210   fs->fileop_file = gtk_entry_get_text (GTK_ENTRY (fs->selection_entry));
2211   if (strlen(fs->fileop_file) < 1)
2212           return;
2213
2214   /* main dialog */
2215   fs->fileop_dialog = dialog = gtk_dialog_new ();
2216   gtk_signal_connect (GTK_OBJECT (dialog), "destroy",
2217                       (GtkSignalFunc) gtk_file_selection_fileop_destroy,
2218                       (gpointer) fs);
2219   gtk_window_set_title (GTK_WINDOW (dialog), _("Rename File"));
2220   gtk_window_set_position (GTK_WINDOW (dialog), GTK_WIN_POS_MOUSE);
2221
2222   /* If file dialog is grabbed, grab option dialog */
2223   /* When option dialog  closed, file dialog will be grabbed again */
2224   if (GTK_WINDOW(fs)->modal)
2225     gtk_window_set_modal (GTK_WINDOW(dialog), TRUE);
2226
2227   vbox = gtk_vbox_new(FALSE, 0);
2228   gtk_container_set_border_width (GTK_CONTAINER(vbox), 8);
2229   gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->vbox), vbox,
2230                      FALSE, FALSE, 0);
2231   gtk_widget_show(vbox);
2232
2233   buf = g_strconcat ("Rename file \"", fs->fileop_file, "\" to:", NULL);
2234   label = gtk_label_new(buf);
2235   gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.0);
2236   gtk_box_pack_start(GTK_BOX(vbox), label, FALSE, FALSE, 5);
2237   gtk_widget_show(label);
2238   g_free(buf);
2239
2240   /* New filename entry */
2241   fs->fileop_entry = gtk_entry_new ();
2242   gtk_box_pack_start (GTK_BOX (vbox), fs->fileop_entry,
2243                       TRUE, TRUE, 5);
2244   GTK_WIDGET_SET_FLAGS(fs->fileop_entry, GTK_CAN_DEFAULT);
2245   gtk_widget_show (fs->fileop_entry);
2246
2247   gtk_entry_set_text (GTK_ENTRY (fs->fileop_entry), fs->fileop_file);
2248   gtk_editable_select_region (GTK_EDITABLE (fs->fileop_entry),
2249                               0, strlen (fs->fileop_file));
2250
2251   /* buttons */
2252   button = gtk_button_new_with_label (_("Rename"));
2253   gtk_signal_connect (GTK_OBJECT (button), "clicked",
2254                       (GtkSignalFunc) gtk_file_selection_rename_file_confirmed,
2255                       (gpointer) fs);
2256   gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->action_area),
2257                      button, TRUE, TRUE, 0);
2258   GTK_WIDGET_SET_FLAGS(button, GTK_CAN_DEFAULT);
2259   gtk_widget_show(button);
2260
2261   button = gtk_button_new_with_label (_("Cancel"));
2262   gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
2263                              (GtkSignalFunc) gtk_widget_destroy,
2264                              (gpointer) dialog);
2265   gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->action_area),
2266                      button, TRUE, TRUE, 0);
2267   GTK_WIDGET_SET_FLAGS(button, GTK_CAN_DEFAULT);
2268   gtk_widget_grab_default(button);
2269   gtk_widget_show (button);
2270
2271   gtk_widget_show (dialog);
2272 }
2273
2274 static mode_t
2275 gtk_file_selection_properties_get_mode (PropertiesPrivate* priv)
2276 {
2277   mode_t mode = 0;
2278
2279   if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (priv->mode_buttons[0])))
2280     mode |= S_IRUSR;
2281   if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (priv->mode_buttons[1])))
2282     mode |= S_IWUSR;
2283   if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (priv->mode_buttons[2])))
2284     mode |= S_IXUSR;
2285   if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (priv->mode_buttons[3])))
2286     mode |= S_ISUID;
2287   if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (priv->mode_buttons[4])))
2288     mode |= S_IRGRP;
2289   if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (priv->mode_buttons[5])))
2290     mode |= S_IWGRP;
2291   if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (priv->mode_buttons[6])))
2292     mode |= S_IXGRP;
2293   if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (priv->mode_buttons[7])))
2294     mode |= S_ISGID;
2295   if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (priv->mode_buttons[8])))
2296     mode |= S_IROTH;
2297   if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (priv->mode_buttons[9])))
2298     mode |= S_IWOTH;
2299   if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (priv->mode_buttons[10])))
2300     mode |= S_IXOTH;
2301   if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (priv->mode_buttons[11])))
2302     mode |= S_ISVTX;
2303
2304   return mode;
2305 }
2306
2307 static void
2308 gtk_file_selection_properties_update_mode (GtkWidget *widget, gpointer data)
2309 {
2310   GtkFileSelection *fs = data;
2311   PropertiesPrivate *priv = fs->fileop_data;
2312   gchar str[8];
2313
2314   sprintf (str, "(%.4o)", gtk_file_selection_properties_get_mode (priv));
2315   gtk_label_set (GTK_LABEL (priv->mode_label), str);
2316 }
2317
2318 static void
2319 gtk_file_selection_properties (gpointer data)
2320 {
2321   GtkFileSelection *fs = data;
2322   GtkWidget *label;
2323   GtkWidget *dialog;
2324   GtkWidget *vbox;
2325   GtkWidget *hbox;
2326   GtkWidget *button;
2327   GtkWidget *notebook;
2328   GtkWidget *table;
2329   GtkWidget *hseparator;
2330   GtkWidget *entry;
2331   GtkWidget *togglebutton;
2332   struct stat statbuf;
2333   struct passwd *pw;
2334   struct group *gp;
2335   gchar *buf;
2336   gchar *path;
2337   gchar *filename;
2338   gchar timeBuf[TIME_STRING_BUF];
2339   gint pagenum = 0;
2340   PropertiesPrivate *priv;
2341   int i;
2342
2343   g_return_if_fail (fs != NULL);
2344   g_return_if_fail (GTK_IS_FILE_SELECTION (fs));
2345
2346   if (fs->fileop_dialog)
2347           return;
2348
2349   /* main dialog */
2350   fs->fileop_dialog = dialog = gtk_dialog_new ();
2351   gtk_signal_connect (GTK_OBJECT (dialog), "destroy",
2352                       (GtkSignalFunc) gtk_file_selection_fileop_destroy,
2353                       (gpointer) fs);
2354   priv = fs->fileop_data = g_malloc (sizeof (PropertiesPrivate));
2355
2356   gtk_window_set_title (GTK_WINDOW (dialog), ("Properties"));
2357   gtk_window_set_position (GTK_WINDOW (dialog), GTK_WIN_POS_MOUSE);
2358
2359   /* If file dialog is grabbed, grab option dialog */
2360   /* When option dialog  closed, file dialog will be grabbed again */
2361   if (GTK_WINDOW(fs)->modal)
2362     gtk_window_set_modal (GTK_WINDOW(dialog), TRUE);
2363
2364   /* Dialog guts go here */
2365   notebook = gtk_notebook_new ();
2366   gtk_widget_show (notebook);
2367   gtk_box_pack_start (GTK_BOX (GTK_DIALOG(dialog)->vbox), notebook, TRUE, TRUE, 0);
2368   gtk_container_set_border_width (GTK_CONTAINER (notebook), 8);
2369
2370   path = cmpl_reference_position(fs->cmpl_state);
2371   fs->fileop_file = gtk_entry_get_text (GTK_ENTRY (fs->selection_entry));
2372   filename = g_strconcat(path, "/", fs->fileop_file, NULL);
2373   if (strlen(fs->fileop_file) > 0 && !(stat(filename, &statbuf)))
2374   {
2375     /* stats page */
2376     table = gtk_table_new (9, 2, FALSE);
2377     gtk_widget_show (table);
2378     gtk_container_add (GTK_CONTAINER (notebook), table);
2379     gtk_container_set_border_width (GTK_CONTAINER (table), 5);
2380     gtk_table_set_row_spacings (GTK_TABLE (table), 4);
2381     gtk_table_set_col_spacings (GTK_TABLE (table), 6);
2382
2383     label = gtk_label_new (_("Statistics"));
2384     gtk_widget_show (label);
2385     gtk_notebook_set_tab_label (GTK_NOTEBOOK (notebook), gtk_notebook_get_nth_page (GTK_NOTEBOOK (notebook), pagenum), label);
2386     pagenum++;
2387     /* path and filename */
2388     label = gtk_label_new (_("Path:"));
2389     gtk_widget_show (label);
2390     gtk_table_attach (GTK_TABLE (table), label, 0, 1, 0, 1,
2391                       (GtkAttachOptions) (GTK_FILL),
2392                       (GtkAttachOptions) (0), 0, 0);
2393     gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
2394
2395     label = gtk_label_new (_(path));
2396     gtk_widget_show (label);
2397     gtk_table_attach (GTK_TABLE (table), label, 1, 2, 0, 1,
2398                       (GtkAttachOptions) (GTK_FILL),
2399                       (GtkAttachOptions) (0), 0, 0);
2400     gtk_label_set_justify (GTK_LABEL (label), GTK_JUSTIFY_LEFT);
2401     gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
2402
2403     label = gtk_label_new (_("File Name:"));
2404     gtk_widget_show (label);
2405     gtk_table_attach (GTK_TABLE (table), label, 0, 1, 1, 2,
2406                       (GtkAttachOptions) (GTK_FILL),
2407                       (GtkAttachOptions) (0), 0, 0);
2408     gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
2409
2410     fs->fileop_entry = entry = gtk_entry_new ();
2411     gtk_widget_show (entry);
2412     gtk_table_attach (GTK_TABLE (table), entry, 1, 2, 1, 2,
2413                       (GtkAttachOptions) (GTK_FILL),
2414                       (GtkAttachOptions) (0), 0, 0);
2415     gtk_entry_set_text (GTK_ENTRY (entry), fs->fileop_file);
2416     if (access (filename, W_OK))
2417       gtk_widget_set_sensitive( GTK_WIDGET (entry), FALSE);
2418
2419     hseparator = gtk_hseparator_new ();
2420     gtk_widget_show (hseparator);
2421     gtk_table_attach (GTK_TABLE (table), hseparator, 0, 2, 2, 3,
2422                       (GtkAttachOptions) (GTK_FILL),
2423                       (GtkAttachOptions) (GTK_FILL), 0, 0);
2424
2425     /* file type and size */
2426     label = gtk_label_new (_("Type:"));
2427     gtk_widget_show (label);
2428     gtk_table_attach (GTK_TABLE (table), label, 0, 1, 3, 4,
2429                       (GtkAttachOptions) (GTK_FILL),
2430                       (GtkAttachOptions) (0), 0, 0);
2431     gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
2432
2433     switch (statbuf.st_mode & S_IFMT)
2434     {
2435     case S_IFSOCK:
2436       buf = g_strdup ("Socket");
2437       break;
2438     case S_IFLNK:
2439       buf = g_strdup ("Symbolic link");
2440       break;
2441     case S_IFREG:
2442       buf = g_strdup ("File");
2443       break;
2444     case S_IFBLK:
2445       buf = g_strdup ("Block device");
2446       break;
2447     case S_IFDIR:
2448       buf = g_strdup ("Directory");
2449       break;
2450     case S_IFCHR:
2451       buf = g_strdup ("Character device");
2452       break;
2453     case S_IFIFO:
2454       buf = g_strdup ("First-in/first-out pipe");
2455       break;
2456     default:
2457       buf = g_strdup ("Unknown");
2458     }
2459
2460
2461     label = gtk_label_new (buf);
2462     gtk_widget_show (label);
2463     gtk_table_attach (GTK_TABLE (table), label, 1, 2, 3, 4,
2464                       (GtkAttachOptions) (GTK_FILL),
2465                       (GtkAttachOptions) (0), 0, 0);
2466     gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
2467
2468     label = gtk_label_new (_("Size:"));
2469     gtk_widget_show (label);
2470     gtk_table_attach (GTK_TABLE (table), label, 0, 1, 4, 5,
2471                       (GtkAttachOptions) (GTK_FILL),
2472                       (GtkAttachOptions) (0), 0, 0);
2473     gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
2474
2475     label = gtk_label_new (_(g_strdup_printf ("%ld bytes", statbuf.st_size)));
2476     gtk_widget_show (label);
2477     gtk_table_attach (GTK_TABLE (table), label, 1, 2, 4, 5,
2478                       (GtkAttachOptions) (GTK_FILL),
2479                       (GtkAttachOptions) (0), 0, 0);
2480     gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
2481
2482     hseparator = gtk_hseparator_new ();
2483     gtk_widget_show (hseparator);
2484     gtk_table_attach (GTK_TABLE (table), hseparator, 0, 2, 5, 6,
2485                       (GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
2486                       (GtkAttachOptions) (GTK_FILL), 0, 0);
2487
2488     /* file dates */
2489     label = gtk_label_new (_("Created:"));
2490     gtk_widget_show (label);
2491     gtk_table_attach (GTK_TABLE (table), label, 0, 1, 6, 7,
2492                       (GtkAttachOptions) (GTK_FILL),
2493                       (GtkAttachOptions) (0), 0, 0);
2494     gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
2495
2496     strftime (timeBuf, TIME_STRING_BUF, "%a %b %d %X %Y", localtime(&statbuf.st_mtime));
2497     label = gtk_label_new (_(timeBuf));
2498     gtk_widget_show (label);
2499     gtk_table_attach (GTK_TABLE (table), label, 1, 2, 6, 7,
2500                       (GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
2501                       (GtkAttachOptions) (0), 0, 0);
2502     gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
2503
2504
2505
2506     label = gtk_label_new (_("Modified:"));
2507     gtk_widget_show (label);
2508     gtk_table_attach (GTK_TABLE (table), label, 0, 1, 7, 8,
2509                       (GtkAttachOptions) (GTK_FILL),
2510                       (GtkAttachOptions) (0), 0, 0);
2511     gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
2512
2513     strftime (timeBuf, TIME_STRING_BUF, "%a %b %d %X %Y", localtime(&statbuf.st_mtime));
2514     label = gtk_label_new (_(timeBuf));
2515     gtk_widget_show (label);
2516     gtk_table_attach (GTK_TABLE (table), label, 1, 2, 7, 8,
2517                       (GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
2518                       (GtkAttachOptions) (0), 0, 0);
2519     gtk_label_set_justify (GTK_LABEL (label), GTK_JUSTIFY_LEFT);
2520     gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
2521
2522
2523     label = gtk_label_new (_("Accessed:"));
2524     gtk_widget_show (label);
2525     gtk_table_attach (GTK_TABLE (table), label, 0, 1, 8, 9,
2526                       (GtkAttachOptions) (GTK_FILL),
2527                       (GtkAttachOptions) (0), 0, 0);
2528     gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
2529
2530     strftime (timeBuf, TIME_STRING_BUF, "%a %b %d %X %Y", localtime(&statbuf.st_atime));
2531     label = gtk_label_new (_(timeBuf));
2532     gtk_widget_show (label);
2533     gtk_table_attach (GTK_TABLE (table), label, 1, 2, 8, 9,
2534                       (GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
2535                       (GtkAttachOptions) (0), 0, 0);
2536     gtk_label_set_justify (GTK_LABEL (label), GTK_JUSTIFY_LEFT);
2537     gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
2538
2539     /* permissions page */
2540     vbox = gtk_vbox_new (FALSE, 4);
2541     gtk_widget_show (vbox);
2542     gtk_container_add (GTK_CONTAINER (notebook), vbox);
2543     gtk_container_set_border_width (GTK_CONTAINER (vbox), 5);
2544
2545     label = gtk_label_new (_("Permissions"));
2546     gtk_widget_show (label);
2547     gtk_notebook_set_tab_label (GTK_NOTEBOOK (notebook), gtk_notebook_get_nth_page (GTK_NOTEBOOK (notebook), pagenum), label);
2548     pagenum++;
2549
2550     /* owner / group */
2551     table = gtk_table_new (2, 2, FALSE);
2552     gtk_widget_show (table);
2553     gtk_box_pack_start (GTK_BOX (vbox), table, FALSE, TRUE, 0);
2554     gtk_table_set_row_spacings (GTK_TABLE (table), 2);
2555     gtk_table_set_col_spacings (GTK_TABLE (table), 8);
2556
2557     label = gtk_label_new (_("Owner:"));
2558     gtk_widget_show (label);
2559     gtk_table_attach (GTK_TABLE (table), label, 0, 1, 0, 1,
2560                       (GtkAttachOptions) (GTK_FILL),
2561                       (GtkAttachOptions) (0), 0, 0);
2562     gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
2563
2564     entry = gtk_entry_new();
2565     gtk_widget_show (entry);
2566     gtk_table_attach (GTK_TABLE (table), entry, 1, 2, 0, 1,
2567                       (GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
2568                       (GtkAttachOptions) (0), 0, 0);
2569     if ((pw = getpwuid(statbuf.st_uid)))
2570       gtk_entry_set_text(GTK_ENTRY (entry), pw->pw_name);
2571     else
2572       gtk_entry_set_text(GTK_ENTRY (entry), (gpointer) statbuf.st_uid);
2573     if (access (filename, W_OK) || (getuid() != 0))
2574       gtk_widget_set_sensitive( GTK_WIDGET (entry), FALSE);
2575
2576
2577     label = gtk_label_new (_("Group:"));
2578     gtk_widget_show (label);
2579     gtk_table_attach (GTK_TABLE (table), label, 0, 1, 1, 2,
2580                       (GtkAttachOptions) (GTK_FILL),
2581                       (GtkAttachOptions) (0), 0, 0);
2582     gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
2583
2584     entry = gtk_entry_new();
2585     gtk_widget_show (entry);
2586     gtk_table_attach (GTK_TABLE (table), entry, 1, 2, 1, 2,
2587                       (GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
2588                       (GtkAttachOptions) (0), 0, 0);
2589     if ((gp = getgrgid(statbuf.st_gid)))
2590       gtk_entry_set_text(GTK_ENTRY (entry), gp->gr_name);
2591     else
2592       gtk_entry_set_text(GTK_ENTRY (entry), (gpointer) statbuf.st_gid);
2593     if (access (filename, W_OK) || (getuid() != 0))
2594       gtk_widget_set_sensitive( GTK_WIDGET (entry), FALSE);
2595
2596
2597     hseparator = gtk_hseparator_new ();
2598     gtk_widget_show (hseparator);
2599     gtk_box_pack_start (GTK_BOX (vbox), hseparator, FALSE, TRUE, 0);
2600
2601     /* permissions */
2602     table = gtk_table_new (4, 5, TRUE);
2603     gtk_widget_show (table);
2604     gtk_box_pack_start (GTK_BOX (vbox), table, FALSE, FALSE, 0);
2605     gtk_table_set_row_spacings (GTK_TABLE (table), 2);
2606     gtk_table_set_col_spacings (GTK_TABLE (table), 4);
2607     if (access (filename, W_OK) || ((getuid() != statbuf.st_uid) && getuid() != 0))
2608       gtk_widget_set_sensitive (GTK_WIDGET (table), FALSE);
2609
2610     hbox = gtk_hbox_new (FALSE, 1);
2611     gtk_widget_show (hbox);
2612     gtk_table_attach (GTK_TABLE (table), hbox, 0, 1, 0, 1,
2613                       (GtkAttachOptions) (GTK_FILL),
2614                       (GtkAttachOptions) (GTK_FILL), 0, 0);
2615
2616     priv->mode_label = label = gtk_label_new ("(0000)");
2617     gtk_widget_show (label);
2618     gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0);
2619
2620     label = gtk_label_new (_("Read"));
2621     gtk_widget_show (label);
2622     gtk_table_attach (GTK_TABLE (table), label, 1, 2, 0, 1,
2623                       (GtkAttachOptions) (0),
2624                       (GtkAttachOptions) (0), 0, 0);
2625
2626     label = gtk_label_new (_("Write"));
2627     gtk_widget_show (label);
2628     gtk_table_attach (GTK_TABLE (table), label, 2, 3, 0, 1,
2629                       (GtkAttachOptions) (0),
2630                       (GtkAttachOptions) (0), 0, 0);
2631
2632     label = gtk_label_new (_("Exec"));
2633     gtk_widget_show (label);
2634     gtk_table_attach (GTK_TABLE (table), label, 3, 4, 0, 1,
2635                       (GtkAttachOptions) (0),
2636                       (GtkAttachOptions) (0), 0, 0);
2637
2638     label = gtk_label_new (_("Special"));
2639     gtk_widget_show (label);
2640     gtk_table_attach (GTK_TABLE (table), label, 4, 5, 0, 1,
2641                       (GtkAttachOptions) (0),
2642                       (GtkAttachOptions) (0), 0, 0);
2643
2644
2645     label = gtk_label_new (_("User:"));
2646     gtk_widget_show (label);
2647     gtk_table_attach (GTK_TABLE (table), label, 0, 1, 1, 2,
2648                       (GtkAttachOptions) (GTK_FILL),
2649                       (GtkAttachOptions) (0), 0, 0);
2650     gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
2651
2652     priv->mode_buttons[0] = togglebutton = gtk_toggle_button_new_with_label ("");
2653     gtk_widget_show (togglebutton);
2654     gtk_table_attach (GTK_TABLE (table), togglebutton, 1, 2, 1, 2,
2655                       (GtkAttachOptions) (GTK_FILL),
2656                       (GtkAttachOptions) (0), 0, 0);
2657     if ((statbuf.st_mode & ~(S_IFMT)) & S_IRUSR)
2658       gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (togglebutton), TRUE);
2659
2660     priv->mode_buttons[1] = togglebutton = gtk_toggle_button_new_with_label ("");
2661     gtk_widget_show (togglebutton);
2662     gtk_table_attach (GTK_TABLE (table), togglebutton, 2, 3, 1, 2,
2663                       (GtkAttachOptions) (GTK_FILL),
2664                       (GtkAttachOptions) (0), 0, 0);
2665     if ((statbuf.st_mode & ~(S_IFMT)) & S_IWUSR)
2666       gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (togglebutton), TRUE);
2667
2668     priv->mode_buttons[2] = togglebutton = gtk_toggle_button_new_with_label ("");
2669     gtk_widget_show (togglebutton);
2670     gtk_table_attach (GTK_TABLE (table), togglebutton, 3, 4, 1, 2,
2671                       (GtkAttachOptions) (GTK_FILL),
2672                       (GtkAttachOptions) (0), 0, 0);
2673     if ((statbuf.st_mode & ~(S_IFMT)) & S_IXUSR)
2674       gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (togglebutton), TRUE);
2675
2676     priv->mode_buttons[3] = togglebutton = gtk_toggle_button_new_with_label ("");
2677     gtk_widget_show (togglebutton);
2678     gtk_table_attach (GTK_TABLE (table), togglebutton, 4, 5, 1, 2,
2679                       (GtkAttachOptions) (GTK_FILL),
2680                       (GtkAttachOptions) (0), 0, 0);
2681     if ((statbuf.st_mode & ~(S_IFMT)) & S_ISUID)
2682       gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (togglebutton), TRUE);
2683
2684
2685
2686     label = gtk_label_new (_("Group:"));
2687     gtk_widget_show (label);
2688     gtk_table_attach (GTK_TABLE (table), label, 0, 1, 2, 3,
2689                       (GtkAttachOptions) (GTK_FILL),
2690                       (GtkAttachOptions) (0), 0, 0);
2691     gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
2692
2693     priv->mode_buttons[4] = togglebutton = gtk_toggle_button_new_with_label ("");
2694     gtk_widget_show (togglebutton);
2695     gtk_table_attach (GTK_TABLE (table), togglebutton, 1, 2, 2, 3,
2696                       (GtkAttachOptions) (GTK_FILL),
2697                       (GtkAttachOptions) (0), 0, 0);
2698     if ((statbuf.st_mode & ~(S_IFMT)) & S_IRGRP)
2699       gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (togglebutton), TRUE);
2700
2701     priv->mode_buttons[5] = togglebutton = gtk_toggle_button_new_with_label ("");
2702     gtk_widget_show (togglebutton);
2703     gtk_table_attach (GTK_TABLE (table), togglebutton, 2, 3, 2, 3,
2704                       (GtkAttachOptions) (GTK_FILL),
2705                       (GtkAttachOptions) (0), 0, 0);
2706     if ((statbuf.st_mode & ~(S_IFMT)) & S_IWGRP)
2707       gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (togglebutton), TRUE);
2708
2709     priv->mode_buttons[6] = togglebutton = gtk_toggle_button_new_with_label ("");
2710     gtk_widget_show (togglebutton);
2711     gtk_table_attach (GTK_TABLE (table), togglebutton, 3, 4, 2, 3,
2712                       (GtkAttachOptions) (GTK_FILL),
2713                       (GtkAttachOptions) (0), 0, 0);
2714     if ((statbuf.st_mode & ~(S_IFMT)) & S_IXGRP)
2715       gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (togglebutton), TRUE);
2716
2717     priv->mode_buttons[7] = togglebutton = gtk_toggle_button_new_with_label ("");
2718     gtk_widget_show (togglebutton);
2719     gtk_table_attach (GTK_TABLE (table), togglebutton, 4, 5, 2, 3,
2720                       (GtkAttachOptions) (GTK_FILL),
2721                       (GtkAttachOptions) (0), 0, 0);
2722     if ((statbuf.st_mode & ~(S_IFMT)) & S_ISGID)
2723       gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (togglebutton), TRUE);
2724
2725     label = gtk_label_new (_("Other:"));
2726     gtk_widget_show (label);
2727     gtk_table_attach (GTK_TABLE (table), label, 0, 1, 3, 4,
2728                       (GtkAttachOptions) (GTK_FILL),
2729                       (GtkAttachOptions) (0), 0, 0);
2730     gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
2731
2732     priv->mode_buttons[8] = togglebutton = gtk_toggle_button_new_with_label ("");
2733     gtk_widget_show (togglebutton);
2734     gtk_table_attach (GTK_TABLE (table), togglebutton, 1, 2, 3, 4,
2735                       (GtkAttachOptions) (GTK_FILL),
2736                       (GtkAttachOptions) (0), 0, 0);
2737     if ((statbuf.st_mode & ~(S_IFMT)) & S_IROTH)
2738       gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (togglebutton), TRUE);
2739
2740     priv->mode_buttons[9] = togglebutton = gtk_toggle_button_new_with_label ("");
2741     gtk_widget_show (togglebutton);
2742     gtk_table_attach (GTK_TABLE (table), togglebutton, 2, 3, 3, 4,
2743                       (GtkAttachOptions) (GTK_FILL),
2744                       (GtkAttachOptions) (0), 0, 0);
2745     if ((statbuf.st_mode & ~(S_IFMT)) & S_IWOTH)
2746       gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (togglebutton), TRUE);
2747
2748     priv->mode_buttons[10] = togglebutton = gtk_toggle_button_new_with_label ("");
2749     gtk_widget_show (togglebutton);
2750     gtk_table_attach (GTK_TABLE (table), togglebutton, 3, 4, 3, 4,
2751                       (GtkAttachOptions) (GTK_FILL),
2752                       (GtkAttachOptions) (0), 0, 0);
2753     if ((statbuf.st_mode & ~(S_IFMT)) & S_IXOTH)
2754       gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (togglebutton), TRUE);
2755
2756     priv->mode_buttons[11] = togglebutton = gtk_toggle_button_new_with_label ("");
2757     gtk_widget_show (togglebutton);
2758     gtk_table_attach (GTK_TABLE (table), togglebutton, 4, 5, 3, 4,
2759                       (GtkAttachOptions) (GTK_FILL),
2760                       (GtkAttachOptions) (0), 0, 0);
2761     if ((statbuf.st_mode & ~(S_IFMT)) & S_ISVTX)
2762       gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (togglebutton), TRUE);
2763
2764     for (i = 0; i < 12; i++)
2765       gtk_signal_connect (GTK_OBJECT (priv->mode_buttons[i]), "toggled",
2766                           GTK_SIGNAL_FUNC (gtk_file_selection_properties_update_mode), fs);
2767     gtk_toggle_button_toggled (GTK_TOGGLE_BUTTON (priv->mode_buttons[0]));
2768   }
2769   /* global page */
2770   vbox = gtk_vbox_new (FALSE, 0);
2771   gtk_widget_show (vbox);
2772   gtk_container_add (GTK_CONTAINER (notebook), vbox);
2773
2774   label = gtk_label_new (_("Global"));
2775   gtk_widget_show (label);
2776   gtk_notebook_set_tab_label (GTK_NOTEBOOK (notebook), gtk_notebook_get_nth_page (GTK_NOTEBOOK (notebook), pagenum), label);
2777   pagenum++;
2778
2779   label = gtk_label_new (_("dialog preferances will go here"));
2780   gtk_widget_show (label);
2781   gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
2782
2783   /* end of dialog guts */
2784
2785   /* buttons */
2786   button = gtk_button_new_with_label (_("OK"));
2787   //  gtk_signal_connect (GTK_OBJECT (button), "clicked",
2788   //                  (GtkSignalFunc) gtk_file_selection_rename_file_confirmed,
2789   //                  (gpointer) fs);
2790   gtk_signal_connect (GTK_OBJECT (button), "clicked",
2791                       (GtkSignalFunc) gtk_file_selection_file_mode_confirmed,
2792                       (gpointer) fs);
2793   gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->action_area),
2794                      button, TRUE, TRUE, 0);
2795   GTK_WIDGET_SET_FLAGS(button, GTK_CAN_DEFAULT);
2796   gtk_widget_show(button);
2797
2798   button = gtk_button_new_with_label (_("Cancel"));
2799   gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
2800                              (GtkSignalFunc) gtk_widget_destroy,
2801                              (gpointer) dialog);
2802   gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->action_area),
2803                      button, TRUE, TRUE, 0);
2804   GTK_WIDGET_SET_FLAGS(button, GTK_CAN_DEFAULT);
2805   gtk_widget_grab_default(button);
2806   gtk_widget_show (button);
2807
2808   g_free (filename);
2809   gtk_widget_show (dialog);
2810 }
2811
2812 static gint
2813 gtk_file_selection_key_press (GtkWidget   *widget,
2814                               GdkEventKey *event,
2815                               gpointer     user_data)
2816 {
2817
2818   GtkFileSelection *fs;
2819   char *text;
2820
2821   g_return_val_if_fail (widget != NULL, FALSE);
2822   g_return_val_if_fail (event != NULL, FALSE);
2823
2824   fs = GTK_FILE_SELECTION (user_data);
2825
2826   if (fs->saved_entry)
2827     {
2828       gtk_clist_unselect_all ((GtkCList *) (fs->dir_list));
2829       gtk_entry_set_text(GTK_ENTRY(fs->selection_entry),fs->saved_entry);
2830       g_free (fs->saved_entry);
2831       fs->saved_entry = NULL;
2832     }
2833   if (event->keyval == GDK_Tab)
2834     {
2835       text = gtk_entry_get_text (GTK_ENTRY (fs->selection_entry));
2836
2837       text = g_strdup (text);
2838
2839       gtk_file_selection_populate (fs, text, TRUE);
2840
2841       g_free (text);
2842
2843       gtk_signal_emit_stop_by_name (GTK_OBJECT (widget), "key_press_event");
2844
2845       return TRUE;
2846     }
2847
2848
2849   return FALSE;
2850 }
2851
2852 /*
2853 static void
2854 gtk_file_selection_home_button (GtkWidget *widget, gpointer data){
2855   GList *list;
2856
2857   GtkFileSelection *fs=data;
2858
2859   list = fs->next_history;
2860   if (list)
2861     {
2862       g_free (list->data);
2863       list = list->next;
2864     }
2865   g_list_free (fs->next_history);
2866   fs->next_history = NULL;
2867
2868   gtk_file_selection_populate (fs,"~/",FALSE);
2869 }
2870 */
2871 static void
2872 gtk_file_selection_bookmark_button (GtkWidget *widget,
2873                                     GtkFileSelection *fs)
2874 {
2875
2876   g_return_if_fail (fs != NULL);
2877   g_return_if_fail (GTK_FILE_SELECTION (fs));
2878
2879   gtk_menu_popup (GTK_MENU (fs->bookmark_menu), NULL, NULL, NULL, NULL,
2880                   0, 0);
2881
2882 }
2883
2884 static void
2885 gtk_file_selection_up_button (GtkWidget *widget, gpointer data){
2886   GtkFileSelection *fs = data;
2887   GList *list;
2888
2889   g_return_if_fail (fs != NULL);
2890   g_return_if_fail (GTK_IS_FILE_SELECTION (fs));
2891
2892   list = fs->next_history;
2893   if (list)
2894     {
2895       g_free (list->data);
2896       list = list->next;
2897     }
2898   g_list_free (fs->next_history);
2899   fs->next_history = NULL;
2900
2901   gtk_file_selection_populate (fs, "../", FALSE); /*change directories. */
2902
2903 }
2904
2905 static void
2906 gtk_file_selection_prev_button (GtkWidget *widget, gpointer data){
2907   GtkFileSelection *fs = data;
2908   GList *list;
2909   GList *first;
2910   gchar *path;
2911
2912   g_return_if_fail (fs != NULL);
2913   g_return_if_fail (GTK_IS_FILE_SELECTION (fs));
2914
2915   list = fs->prev_history;
2916
2917   if (list && g_list_length(list) > 1)
2918     {
2919       first = list;            /* get first element */
2920       list = list->next;       /* pop off current directory */
2921
2922       list->prev = NULL;       /* make this the new head. */
2923
2924       fs->prev_history = list; /* update prev_history list */
2925       fs->next_history = g_list_prepend(fs->next_history,first->data); /* put it on next_history */
2926
2927       first->next = NULL;      /* orphan the old first node */
2928       g_list_free (first);     /* free the node (data is now in use by next_history) */
2929
2930
2931
2932       path = g_malloc(strlen(list->data)+4); /* plenty of space */
2933       strcpy(path,list->data);               /* get the 2nd path in the history */
2934       strcat(path,"/");                      /* append a '/' */
2935       gtk_file_selection_populate (fs, path, FALSE); /* change directories. */
2936       g_free (path);
2937     }
2938 }
2939
2940 static void
2941 gtk_file_selection_next_button (GtkWidget *widget, gpointer data){
2942   GtkFileSelection *fs = data;
2943   GList *list;
2944   GList *first;
2945   gchar *path;
2946
2947   g_return_if_fail (fs != NULL);
2948   g_return_if_fail (GTK_IS_FILE_SELECTION (fs));
2949
2950   list = fs->next_history;
2951
2952   if (list && g_list_length(list) > 0)
2953     {
2954       first = list;            /*get first element*/
2955       list = list->next;       /*pop off current directory*/
2956
2957       if (list)
2958         list->prev = NULL;
2959
2960       fs->next_history = list;                       /*update prev_history list*/
2961
2962       path = g_malloc(strlen(first->data)+4);        /*plenty of space*/
2963       strcpy(path,first->data);
2964       strcat(path,"/");                              /*append a /   */
2965       gtk_file_selection_populate (fs, path, FALSE); /*change directories.*/
2966       g_free(path);
2967
2968       first->next = NULL;     /* orphan the old first node */
2969       g_list_free (first);    /* free the node (data is now in use by next_history) */
2970
2971     }
2972 }
2973
2974 void static
2975 gtk_file_selection_refresh_button (GtkWidget *widget, gpointer data){
2976   GtkFileSelection *fs = data;
2977
2978   g_return_if_fail (fs != NULL);
2979   g_return_if_fail (GTK_IS_FILE_SELECTION (fs));
2980
2981   gtk_file_selection_populate (fs,"",FALSE);
2982 }
2983
2984 static void
2985 gtk_file_selection_mask_entry_callback (GtkWidget *widget, gpointer data){
2986   GtkFileSelection *fs = data;
2987
2988   if(fs->mask)
2989     g_free (fs->mask);
2990
2991   fs->mask = g_strdup(gtk_entry_get_text (GTK_ENTRY(GTK_COMBO(fs->mask_entry)->entry)));
2992
2993   if (strlen(fs->mask) == 0)
2994     {
2995       g_free (fs->mask);
2996       fs->mask = NULL;
2997     }
2998
2999   gtk_file_selection_refresh_button (widget,data);
3000 }
3001
3002 static gint gtk_file_selection_files_list_key_callback (GtkWidget *widget, GdkEventKey *event, gpointer data){
3003   GtkFileSelection *fs=data;
3004   gchar *saved;
3005   gchar key[2];
3006
3007 //  g_print("Key event: %d\n",event->keyval);
3008   //we need some sort of timeout.
3009
3010   //if the key is a normal character then
3011   //add to our saved_entry1
3012   //if it's backspace then remove one character
3013   //otherwise let it through (and erase our buffer.
3014
3015   if(event->keyval > GDK_space && event->keyval <=  GDK_Korean_Won) {
3016     key[1]=0;
3017     key[0]=event->keyval;
3018     saved=fs->saved_entry1;
3019     if(fs->saved_entry1){
3020       fs->saved_entry1=g_strconcat(saved,key,NULL);
3021       g_free(saved);
3022     }else{
3023       fs->saved_entry1=g_strdup(key);
3024     }
3025     g_print("complete: %s\n",fs->saved_entry1);
3026     /*gtk_label_set_text(GTK_LABEL(fs->completion_label), fs->saved_entry1); */
3027
3028     saved=g_strdup(gtk_entry_get_text(GTK_ENTRY(fs->selection_entry)));
3029     gtk_file_selection_complete(fs,fs->saved_entry1);
3030     gtk_entry_set_text(GTK_ENTRY(fs->selection_entry),saved);
3031     g_free(saved);
3032   }else if (event->keyval ==  GDK_BackSpace) {
3033     if(strlen(fs->saved_entry1)){
3034       fs->saved_entry1[strlen(fs->saved_entry1)-1]=0;
3035       g_print("complete: %s\n",fs->saved_entry1);
3036       /*gtk_label_set_text(GTK_LABEL(fs->completion_label),fs->saved_entry1); */
3037       saved=g_strdup(gtk_entry_get_text(GTK_ENTRY(fs->selection_entry)));
3038       gtk_file_selection_complete(fs,fs->saved_entry1);
3039       gtk_entry_set_text(GTK_ENTRY(fs->selection_entry),saved);
3040       g_free(saved);
3041     }
3042   }else if (event->keyval == GDK_Tab) {
3043     saved=g_strdup(gtk_entry_get_text(GTK_ENTRY(fs->selection_entry)));
3044     gtk_file_selection_populate(fs,fs->saved_entry1,TRUE);
3045     g_free(fs->saved_entry1);
3046     fs->saved_entry1=gtk_entry_get_text(GTK_ENTRY(fs->selection_entry));
3047     gtk_entry_set_text(GTK_ENTRY(fs->selection_entry),saved);
3048     g_free(saved);
3049
3050     g_print("complete: %s\n",fs->saved_entry1);
3051     /* gtk_label_set_text(GTK_LABEL(fs->completion_label),fs->saved_entry1);*/
3052
3053     gtk_signal_emit_stop_by_name (GTK_OBJECT (widget), "key_press_event");
3054   }else {
3055     if(fs->saved_entry1){
3056       g_free(fs->saved_entry1);
3057       fs->saved_entry1=NULL;
3058     }
3059     /* gtk_label_set_text(GTK_LABEL(fs->completion_label)," "); */
3060   }
3061
3062   return TRUE;
3063 }
3064
3065
3066 static gint gtk_file_selection_mask_entry_key_callback (GtkWidget *widget, GdkEventKey *event, gpointer data)
3067 {
3068   GtkEntry *entry=(GtkEntry *)widget;
3069   GtkFileSelection *fs=data;
3070
3071   g_return_val_if_fail (fs != NULL,FALSE);
3072   g_return_val_if_fail (GTK_IS_FILE_SELECTION (fs),FALSE);
3073
3074
3075   if (event->keyval == GDK_Return || event->keyval == GDK_Tab)
3076     {
3077       if(fs->mask)
3078         g_free(fs->mask);
3079
3080       fs->mask=g_strdup(gtk_entry_get_text(entry));
3081       gtk_file_selection_refresh_button(widget,fs);
3082
3083       if (event->keyval == GDK_Return)
3084         gtk_signal_emit_stop_by_name (GTK_OBJECT (widget), "key_press_event");
3085       return TRUE;
3086     }
3087   else
3088     {
3089       return FALSE;
3090     }
3091 }
3092
3093 static gint gtk_file_selection_mask_entry_button_callback (GtkWidget *widget, GdkEventButton *event, gpointer data)
3094 {
3095   GtkFileSelection *fs = data;
3096
3097   if(fs->mask)
3098     g_free(fs->mask);
3099
3100   fs->mask=g_strdup(gtk_entry_get_text(GTK_ENTRY(GTK_COMBO(fs->mask_entry)->entry)));
3101   gtk_file_selection_refresh_button(widget,fs);
3102
3103   return TRUE;
3104
3105 }
3106
3107 static gboolean gtk_file_selection_history_combo_list_key_handler(GtkWidget *widget,
3108                                                                   GdkEventKey *event,
3109                                                                   gpointer user_data)
3110 {
3111   /*
3112   g_print("Key pressed! \n");
3113   */
3114
3115   return TRUE;
3116 }
3117
3118 static gboolean gtk_file_selection_history_combo_list_callback (GtkWidget *thelist,
3119                                                                 GdkEventButton *event,
3120                                                                 gpointer user_data)
3121 {
3122
3123   GtkFileSelection *fs = user_data;
3124   GList *list;
3125   gchar *path;
3126
3127   list = fs->next_history;
3128   if(list)
3129     {
3130       g_free (list->data);
3131       list = list->next;
3132     }
3133   g_list_free (fs->next_history);
3134   fs->next_history = NULL;
3135
3136   path = g_malloc(strlen(gtk_entry_get_text(GTK_ENTRY (((GtkCombo *)fs->history_combo)->entry)))+4);
3137   strcpy (path,gtk_entry_get_text(GTK_ENTRY( ((GtkCombo *)fs->history_combo)->entry)));
3138   strcat (path,"/");
3139
3140   gtk_file_selection_populate (fs,path,TRUE);
3141
3142   g_free (path);
3143
3144   return TRUE;
3145 }
3146
3147 static gboolean
3148 gtk_file_selection_history_combo_callback (GtkWidget *widget, GdkEventKey *event, gpointer data)
3149 {
3150   GtkEntry *entry=(GtkEntry *)widget;
3151   GtkFileSelection *fs=data;
3152   GList *list;
3153   gchar *path;
3154
3155   g_return_val_if_fail (fs != NULL,FALSE);
3156   g_return_val_if_fail (GTK_IS_FILE_SELECTION (fs),FALSE);
3157
3158
3159   if (event->keyval == GDK_Return)
3160     {
3161       list = fs->next_history;
3162       if (list)
3163         {
3164           g_free (list->data);
3165           list = list->next;
3166         }
3167       g_list_free (fs->next_history);
3168       fs->next_history = NULL;
3169
3170       path = g_malloc(strlen(gtk_entry_get_text(entry))+4);
3171       strcpy (path,gtk_entry_get_text(entry));
3172       strcat (path,"/");
3173       gtk_file_selection_populate (fs,path,TRUE);
3174       g_free (path);
3175       gtk_signal_emit_stop_by_name (GTK_OBJECT (widget), "key_press_event");
3176       return TRUE;
3177     }
3178   else
3179     {
3180       return FALSE;
3181     }
3182
3183 }
3184
3185
3186 static void gtk_file_selection_bookmark_callback (GtkWidget *widget, gpointer data)
3187 {
3188   GtkFileSelection *fs = data;
3189   BookmarkMenuStruct *item;
3190   GList *list;
3191
3192   g_return_if_fail (fs != NULL);
3193   g_return_if_fail (GTK_IS_FILE_SELECTION (fs));
3194
3195 //g_print ("Callback\n");
3196   list = fs->bookmark_list;
3197   while(list) {
3198     item = list->data;
3199     if (item->menu_item == widget) {
3200       if(strcmp(item->path,"./")) {
3201         gtk_file_selection_populate (fs, item->path, FALSE);
3202       }
3203       break;
3204     }
3205     list=list->next;
3206   }
3207 }
3208
3209 static void
3210 gtk_file_selection_update_history_menu (GtkFileSelection *fs,
3211                                         gchar *current_directory)
3212 {
3213   gchar *current_dir;
3214
3215   g_return_if_fail (fs != NULL);
3216   g_return_if_fail (GTK_IS_FILE_SELECTION (fs));
3217   g_return_if_fail (current_directory != NULL);
3218
3219   current_dir = g_strdup (current_directory);
3220
3221   if(fs->prev_history)
3222     {
3223       if (strcmp((fs->prev_history)->data,current_dir))
3224         { /*if this item isn't on the top of the list */
3225           fs->prev_history = g_list_prepend(fs->prev_history,g_strdup(current_dir));
3226         }
3227     } else {
3228       fs->prev_history = g_list_prepend(fs->prev_history,g_strdup(current_dir));
3229     }
3230
3231   gtk_combo_set_popdown_strings (GTK_COMBO (fs->history_combo),fs->prev_history);
3232
3233   g_free (current_dir);
3234 }
3235
3236 static void
3237 gtk_file_selection_file_button (GtkWidget *widget,
3238                                gint row,
3239                                gint column,
3240                                GdkEventButton *bevent,
3241                                gpointer user_data)
3242 {
3243   GtkFileSelection *fs = NULL;
3244   gchar *filename, *temp = NULL;
3245
3246   g_return_if_fail (GTK_IS_CLIST (widget));
3247
3248   fs = user_data;
3249   g_return_if_fail (fs != NULL);
3250   g_return_if_fail (GTK_IS_FILE_SELECTION (fs));
3251
3252   gtk_clist_get_text (GTK_CLIST (fs->file_list), row, 0, &temp);
3253   filename = g_strdup (temp);
3254
3255   if (filename)
3256     {
3257       if (fs->saved_entry)
3258       {
3259         gtk_clist_unselect_all ((GtkCList *) (fs->dir_list));
3260         gtk_entry_set_text(GTK_ENTRY(fs->selection_entry),fs->saved_entry);
3261         g_free (fs->saved_entry);
3262         fs->saved_entry = NULL;
3263       }
3264       if(fs->saved_entry1){
3265         g_free(fs->saved_entry1);
3266         fs->saved_entry1=NULL;
3267       }
3268       /* gtk_label_set_text(GTK_LABEL(fs->completion_label)," "); */
3269
3270
3271       if (bevent)
3272         switch (bevent->type)
3273           {
3274           case GDK_2BUTTON_PRESS:
3275             gtk_button_clicked (GTK_BUTTON (fs->ok_button));
3276             break;
3277
3278           default:
3279 /*
3280             if (bevent->button && GDK_BUTTON2_MASK)
3281               {
3282                 g_print("Right click! -- %d\n",bevent->button);
3283               }
3284               else
3285               {
3286               */
3287
3288             gtk_entry_set_text (GTK_ENTRY (fs->selection_entry), filename);
3289               /*}*/
3290             break;
3291           }
3292       else
3293         gtk_entry_set_text (GTK_ENTRY (fs->selection_entry), filename);
3294
3295       g_free (filename);
3296     }
3297 }
3298
3299 static void
3300 gtk_file_selection_dir_button (GtkWidget *widget,
3301                                gint row,
3302                                gint column,
3303                                GdkEventButton *bevent,
3304                                gpointer user_data)
3305 {
3306   GList *list;
3307   GtkFileSelection *fs = NULL;
3308   gchar *filename, *temp = NULL;
3309
3310   g_return_if_fail (GTK_IS_CLIST (widget));
3311
3312   fs = GTK_FILE_SELECTION (user_data);
3313   g_return_if_fail (fs != NULL);
3314   g_return_if_fail (GTK_IS_FILE_SELECTION (fs));
3315
3316   gtk_clist_get_text (GTK_CLIST (fs->dir_list), row, 0, &temp);
3317   filename = g_strdup (temp);
3318
3319   if (filename)
3320     {
3321       if (bevent)
3322         switch (bevent->type)
3323           {
3324           case GDK_2BUTTON_PRESS:
3325             list = fs->next_history;
3326             if (list)
3327               {
3328                 g_free (list->data);
3329                 list = list->next;
3330               }
3331             g_list_free (fs->next_history);
3332             fs->next_history = NULL;
3333
3334             gtk_file_selection_populate (fs, filename, FALSE);
3335             gtk_entry_set_text(GTK_ENTRY(fs->selection_entry),fs->saved_entry);
3336             g_free (fs->saved_entry);
3337             fs->saved_entry = NULL;
3338             break;
3339
3340           default:
3341             /* here we need to add the "filename" to the beginning of what's already
3342                in the entry.  Save what's in the entry, then restore it on the double click
3343             */
3344             if (fs->saved_entry) g_free (fs->saved_entry);
3345             fs->saved_entry=g_strdup(gtk_entry_get_text(GTK_ENTRY (fs->selection_entry)));
3346
3347             temp=g_strconcat(filename,fs->saved_entry,NULL);
3348             gtk_entry_set_text (GTK_ENTRY (fs->selection_entry), temp);
3349             g_free (temp);
3350
3351             break;
3352           }
3353       else
3354         gtk_entry_set_text (GTK_ENTRY (fs->selection_entry), filename);
3355
3356       g_free (filename);
3357     }
3358 }
3359
3360 static void
3361 gtk_file_selection_undir_button (GtkWidget *widget,
3362                                gint row,
3363                                gint column,
3364                                GdkEventButton *bevent,
3365                                gpointer user_data)
3366 {
3367   GtkFileSelection *fs = NULL;
3368   gchar *filename, *temp = NULL;
3369
3370   g_return_if_fail (GTK_IS_CLIST (widget));
3371
3372   fs = GTK_FILE_SELECTION (user_data);
3373   g_return_if_fail (fs != NULL);
3374   g_return_if_fail (GTK_IS_FILE_SELECTION (fs));
3375
3376   gtk_clist_get_text (GTK_CLIST (fs->dir_list), row, 0, &temp);
3377   filename = g_strdup (temp);
3378
3379   if (filename)
3380     {
3381       if (bevent)
3382         switch (bevent->type)
3383           {
3384           default:
3385             /* here we need to add the "filename" to the beginning of what's already
3386                in the entry.  Save what's in the entry, then restore it on the double click
3387             */
3388             if (fs->saved_entry)
3389               {
3390                 gtk_entry_set_text (GTK_ENTRY (fs->selection_entry),fs->saved_entry);
3391                 g_free (fs->saved_entry);
3392                 fs->saved_entry = NULL;
3393               }
3394             break;
3395           }
3396       else
3397         gtk_entry_set_text (GTK_ENTRY (fs->selection_entry), filename); //?????
3398
3399       g_free (filename);
3400     }
3401 }
3402
3403 static void
3404 gtk_file_selection_populate (GtkFileSelection *fs,
3405                              gchar            *rel_path,
3406                              gint              try_complete)
3407 {
3408   CompletionState *cmpl_state;
3409   PossibleCompletion* poss;
3410   gchar* filename;
3411   gint row;
3412   gchar* rem_path = rel_path;
3413   gchar* sel_text;
3414   gchar* text[2];
3415   gint did_recurse = FALSE;
3416   gint possible_count = 0;
3417   gint selection_index = -1;
3418   gint file_list_width;
3419   gint dir_list_width;
3420
3421   g_return_if_fail (fs != NULL);
3422   g_return_if_fail (GTK_IS_FILE_SELECTION (fs));
3423
3424   cmpl_state = (CompletionState*) fs->cmpl_state;
3425   poss = cmpl_completion_matches (rel_path, &rem_path, cmpl_state);
3426
3427   if (!cmpl_state_okay (cmpl_state))
3428     {
3429       /* Something went wrong. */
3430       gtk_file_selection_abort (fs);
3431       return;
3432     }
3433
3434   g_assert (cmpl_state->reference_dir);
3435
3436   gtk_clist_freeze (GTK_CLIST (fs->dir_list));
3437   gtk_clist_clear (GTK_CLIST (fs->dir_list));
3438   gtk_clist_freeze (GTK_CLIST (fs->file_list));
3439   gtk_clist_clear (GTK_CLIST (fs->file_list));
3440
3441   /* Set the dir_list to include ./ and ../ */
3442   /* Actually, no let's not.
3443   text[1] = NULL;
3444   text[0] = "./";
3445   row = gtk_clist_append (GTK_CLIST (fs->dir_list), text);
3446   */
3447
3448   text[0] = "../";  //Do we need ..?
3449   row = gtk_clist_append (GTK_CLIST (fs->dir_list), text);
3450
3451   /*reset the max widths of the lists*/
3452   dir_list_width = gdk_string_width(fs->dir_list->style->font,"../");
3453   gtk_clist_set_column_width(GTK_CLIST(fs->dir_list),0,dir_list_width);
3454   file_list_width = 1;
3455   gtk_clist_set_column_width(GTK_CLIST(fs->file_list),0,file_list_width);
3456
3457   while (poss)
3458     {
3459       if (cmpl_is_a_completion (poss))
3460         {
3461           possible_count += 1;
3462
3463           filename = cmpl_this_completion (poss);
3464
3465           text[0] = filename;
3466
3467           if (cmpl_is_directory (poss))
3468             {
3469               if (strcmp (filename, "./") != 0 &&
3470                   strcmp (filename, "../") != 0)
3471                 {
3472                   int width = gdk_string_width(fs->dir_list->style->font,
3473                                                filename);
3474                   row = gtk_clist_append (GTK_CLIST (fs->dir_list), text);
3475                   if(width > dir_list_width)
3476                     {
3477                       dir_list_width = width;
3478                       gtk_clist_set_column_width(GTK_CLIST(fs->dir_list),0,
3479                                                  width);
3480                     }
3481                 }
3482             }
3483           else
3484             {
3485               if(fs->mask)
3486                 {
3487                   if (gtk_file_selection_match_mask(filename,fs->mask))
3488                     {
3489                       int width = gdk_string_width(fs->file_list->style->font,
3490                                                    filename);
3491                       row = gtk_clist_append (GTK_CLIST (fs->file_list), text);
3492                       if(width > file_list_width)
3493                         {
3494                           file_list_width = width;
3495                           gtk_clist_set_column_width(GTK_CLIST(fs->file_list),0,
3496                                                      width);
3497                         }
3498                     }
3499                 }
3500               else
3501                 {
3502                   int width = gdk_string_width(fs->file_list->style->font,
3503                                                filename);
3504                   row = gtk_clist_append (GTK_CLIST (fs->file_list), text);
3505                   if(width > file_list_width)
3506                     {
3507                       file_list_width = width;
3508                       gtk_clist_set_column_width(GTK_CLIST(fs->file_list),0,
3509                                                  width);
3510                     }
3511                 }
3512             }
3513         }
3514
3515       poss = cmpl_next_completion (cmpl_state);
3516     }
3517
3518   gtk_clist_thaw (GTK_CLIST (fs->dir_list));
3519   gtk_clist_thaw (GTK_CLIST (fs->file_list));
3520
3521   /* File lists are set. */
3522
3523   g_assert (cmpl_state->reference_dir);
3524
3525   if (try_complete)
3526     {
3527
3528       /* User is trying to complete filenames, so advance the user's input
3529        * string to the updated_text, which is the common leading substring
3530        * of all possible completions, and if its a directory attempt
3531        * attempt completions in it. */
3532
3533       if (cmpl_updated_text (cmpl_state)[0])
3534         {
3535
3536           if (cmpl_updated_dir (cmpl_state))
3537             {
3538               gchar* dir_name = g_strdup (cmpl_updated_text (cmpl_state));
3539
3540               did_recurse = TRUE;
3541
3542               gtk_file_selection_populate (fs, dir_name, TRUE);
3543
3544               g_free (dir_name);
3545             }
3546           else
3547             {
3548               if (fs->selection_entry)
3549                       gtk_entry_set_text (GTK_ENTRY (fs->selection_entry),
3550                                           cmpl_updated_text (cmpl_state));
3551             }
3552         }
3553       else
3554         {
3555           selection_index = cmpl_last_valid_char (cmpl_state) -
3556                             (strlen (rel_path) - strlen (rem_path));
3557           if (fs->selection_entry)
3558             gtk_entry_set_text (GTK_ENTRY (fs->selection_entry), rem_path);
3559         }
3560     }
3561   else
3562     {
3563       if (fs->selection_entry)
3564       /* Here we need to take the old filename and keep it!*/
3565         /*gtk_entry_set_text (GTK_ENTRY (fs->selection_entry), "");*/
3566         ;
3567     }
3568
3569   if (!did_recurse)
3570     {
3571       if (fs->selection_entry)
3572         gtk_entry_set_position (GTK_ENTRY (fs->selection_entry), selection_index);
3573
3574       if (fs->selection_entry)
3575         {
3576           sel_text = g_strconcat (_("Selection: "),
3577                                   cmpl_reference_position (cmpl_state),
3578                                   NULL);
3579
3580 /*
3581                 gtk_label_set_text (GTK_LABEL (fs->selection_text), sel_text);
3582 */
3583                 g_free (sel_text);
3584         }
3585
3586   gtk_file_selection_update_history_menu (fs, cmpl_reference_position (cmpl_state));
3587
3588     }
3589 }
3590
3591 static void
3592 gtk_file_selection_abort (GtkFileSelection *fs)
3593 {
3594   gchar err_buf[256];
3595
3596   sprintf (err_buf, _("Directory unreadable: %s"), cmpl_strerror (cmpl_errno));
3597
3598   /*  BEEP gdk_beep();  */
3599
3600 /*
3601   if (fs->selection_entry)
3602     gtk_label_set_text (GTK_LABEL (fs->selection_text), err_buf);
3603 */
3604 }
3605
3606 /**********************************************************************/
3607 /*                        External Interface                          */
3608 /**********************************************************************/
3609
3610 /* The four completion state selectors
3611  */
3612 static gchar*
3613 cmpl_updated_text (CompletionState* cmpl_state)
3614 {
3615   return cmpl_state->updated_text;
3616 }
3617
3618 static gint
3619 cmpl_updated_dir (CompletionState* cmpl_state)
3620 {
3621   return cmpl_state->re_complete;
3622 }
3623
3624 static gchar*
3625 cmpl_reference_position (CompletionState* cmpl_state)
3626 {
3627   return cmpl_state->reference_dir->fullname;
3628 }
3629
3630 static gint
3631 cmpl_last_valid_char (CompletionState* cmpl_state)
3632 {
3633   return cmpl_state->last_valid_char;
3634 }
3635
3636 static gchar*
3637 cmpl_completion_fullname (gchar* text, CompletionState* cmpl_state)
3638 {
3639   static char nothing[2] = "";
3640
3641   if (!cmpl_state_okay (cmpl_state))
3642     {
3643       return nothing;
3644     }
3645   else if (text[0] == '/')
3646     {
3647       strcpy (cmpl_state->updated_text, text);
3648     }
3649   else if (text[0] == '~')
3650     {
3651       CompletionDir* dir;
3652       char* slash;
3653
3654       dir = open_user_dir (text, cmpl_state);
3655
3656       if (!dir)
3657         {
3658           /* spencer says just return ~something, so
3659            * for now just do it. */
3660           strcpy (cmpl_state->updated_text, text);
3661         }
3662       else
3663         {
3664
3665           strcpy (cmpl_state->updated_text, dir->fullname);
3666
3667           slash = strchr (text, '/');
3668
3669           if (slash)
3670             strcat (cmpl_state->updated_text, slash);
3671         }
3672     }
3673   else
3674     {
3675       strcpy (cmpl_state->updated_text, cmpl_state->reference_dir->fullname);
3676       if (strcmp (cmpl_state->reference_dir->fullname, "/") != 0)
3677         strcat (cmpl_state->updated_text, "/");
3678       strcat (cmpl_state->updated_text, text);
3679     }
3680
3681   return cmpl_state->updated_text;
3682 }
3683
3684 /* The three completion selectors
3685  */
3686 static gchar*
3687 cmpl_this_completion (PossibleCompletion* pc)
3688 {
3689   return pc->text;
3690 }
3691
3692 static gint
3693 cmpl_is_directory (PossibleCompletion* pc)
3694 {
3695   return pc->is_directory;
3696 }
3697
3698 static gint
3699 cmpl_is_a_completion (PossibleCompletion* pc)
3700 {
3701   return pc->is_a_completion;
3702 }
3703
3704 /**********************************************************************/
3705 /*                       Construction, deletion                       */
3706 /**********************************************************************/
3707
3708 static CompletionState*
3709 cmpl_init_state (void)
3710 {
3711   gchar getcwd_buf[2*MAXPATHLEN];
3712   CompletionState *new_state;
3713
3714   new_state = g_new (CompletionState, 1);
3715
3716   /* We don't use getcwd() on SUNOS, because, it does a popen("pwd")
3717    * and, if that wasn't bad enough, hangs in doing so.
3718    */
3719 #if defined(sun) && !defined(__SVR4)
3720   if (!getwd (getcwd_buf))
3721 #else
3722   if (!getcwd (getcwd_buf, MAXPATHLEN))
3723 #endif
3724     {
3725       /* Oh joy, we can't get the current directory. Um..., we should have
3726        * a root directory, right? Right? (Probably not portable to non-Unix)
3727        */
3728       strcpy (getcwd_buf, "/");
3729     }
3730
3731 tryagain:
3732
3733   new_state->reference_dir = NULL;
3734   new_state->completion_dir = NULL;
3735   new_state->active_completion_dir = NULL;
3736   new_state->directory_storage = NULL;
3737   new_state->directory_sent_storage = NULL;
3738   new_state->last_valid_char = 0;
3739   new_state->updated_text = g_new (gchar, MAXPATHLEN);
3740   new_state->updated_text_alloc = MAXPATHLEN;
3741   new_state->the_completion.text = g_new (gchar, MAXPATHLEN);
3742   new_state->the_completion.text_alloc = MAXPATHLEN;
3743   new_state->user_dir_name_buffer = NULL;
3744   new_state->user_directories = NULL;
3745
3746   new_state->reference_dir =  open_dir (getcwd_buf, new_state);
3747
3748   if (!new_state->reference_dir)
3749     {
3750       /* Directories changing from underneath us, grumble */
3751       strcpy (getcwd_buf, "/");
3752       goto tryagain;
3753     }
3754
3755   return new_state;
3756 }
3757
3758 static void
3759 cmpl_free_dir_list(GList* dp0)
3760 {
3761   GList *dp = dp0;
3762
3763   while (dp) {
3764     free_dir (dp->data);
3765     dp = dp->next;
3766   }
3767
3768   g_list_free(dp0);
3769 }
3770
3771 static void
3772 cmpl_free_dir_sent_list(GList* dp0)
3773 {
3774   GList *dp = dp0;
3775
3776   while (dp) {
3777     free_dir_sent (dp->data);
3778     dp = dp->next;
3779   }
3780
3781   g_list_free(dp0);
3782 }
3783
3784 static void
3785 cmpl_free_state (CompletionState* cmpl_state)
3786 {
3787   cmpl_free_dir_list (cmpl_state->directory_storage);
3788   cmpl_free_dir_sent_list (cmpl_state->directory_sent_storage);
3789
3790   if (cmpl_state->user_dir_name_buffer)
3791     g_free (cmpl_state->user_dir_name_buffer);
3792   if (cmpl_state->user_directories)
3793     g_free (cmpl_state->user_directories);
3794   if (cmpl_state->the_completion.text)
3795     g_free (cmpl_state->the_completion.text);
3796   if (cmpl_state->updated_text)
3797     g_free (cmpl_state->updated_text);
3798
3799   g_free (cmpl_state);
3800 }
3801
3802 static void
3803 free_dir(CompletionDir* dir)
3804 {
3805   g_free(dir->fullname);
3806   g_free(dir);
3807 }
3808
3809 static void
3810 free_dir_sent(CompletionDirSent* sent)
3811 {
3812   g_free(sent->name_buffer);
3813   g_free(sent->entries);
3814   g_free(sent);
3815 }
3816
3817 static void
3818 prune_memory_usage(CompletionState *cmpl_state)
3819 {
3820   GList* cdsl = cmpl_state->directory_sent_storage;
3821   GList* cdl = cmpl_state->directory_storage;
3822   GList* cdl0 = cdl;
3823   gint len = 0;
3824
3825   for(; cdsl && len < CMPL_DIRECTORY_CACHE_SIZE; len += 1)
3826     cdsl = cdsl->next;
3827
3828   if (cdsl) {
3829     cmpl_free_dir_sent_list(cdsl->next);
3830     cdsl->next = NULL;
3831   }
3832
3833   cmpl_state->directory_storage = NULL;
3834   while (cdl) {
3835     if (cdl->data == cmpl_state->reference_dir)
3836       cmpl_state->directory_storage = g_list_prepend(NULL, cdl->data);
3837     else
3838       free_dir (cdl->data);
3839     cdl = cdl->next;
3840   }
3841
3842   g_list_free(cdl0);
3843 }
3844
3845 /**********************************************************************/
3846 /*                        The main entrances.                         */
3847 /**********************************************************************/
3848
3849 static PossibleCompletion*
3850 cmpl_completion_matches (gchar* text_to_complete,
3851                          gchar** remaining_text,
3852                          CompletionState* cmpl_state)
3853 {
3854   gchar* first_slash;
3855   PossibleCompletion *poss;
3856
3857   prune_memory_usage(cmpl_state);
3858
3859   g_assert (text_to_complete != NULL);
3860
3861   cmpl_state->user_completion_index = -1;
3862   cmpl_state->last_completion_text = text_to_complete;
3863   cmpl_state->the_completion.text[0] = 0;
3864   cmpl_state->last_valid_char = 0;
3865   cmpl_state->updated_text_len = -1;
3866   cmpl_state->updated_text[0] = 0;
3867   cmpl_state->re_complete = FALSE;
3868
3869   first_slash = strchr (text_to_complete, '/');
3870
3871   if (text_to_complete[0] == '~' && !first_slash)
3872     {
3873       /* Text starts with ~ and there is no slash, show all the
3874        * home directory completions.
3875        */
3876       poss = attempt_homedir_completion (text_to_complete, cmpl_state);
3877
3878       update_cmpl(poss, cmpl_state);
3879
3880       return poss;
3881     }
3882
3883   cmpl_state->reference_dir =
3884     open_ref_dir (text_to_complete, remaining_text, cmpl_state);
3885
3886   if(!cmpl_state->reference_dir)
3887     return NULL;
3888
3889   cmpl_state->completion_dir =
3890     find_completion_dir (*remaining_text, remaining_text, cmpl_state);
3891
3892   cmpl_state->last_valid_char = *remaining_text - text_to_complete;
3893
3894   if(!cmpl_state->completion_dir)
3895     return NULL;
3896
3897   cmpl_state->completion_dir->cmpl_index = -1;
3898   cmpl_state->completion_dir->cmpl_parent = NULL;
3899   cmpl_state->completion_dir->cmpl_text = *remaining_text;
3900
3901   cmpl_state->active_completion_dir = cmpl_state->completion_dir;
3902
3903   cmpl_state->reference_dir = cmpl_state->completion_dir;
3904
3905   poss = attempt_file_completion(cmpl_state);
3906
3907   update_cmpl(poss, cmpl_state);
3908
3909   return poss;
3910 }
3911
3912 static PossibleCompletion*
3913 cmpl_next_completion (CompletionState* cmpl_state)
3914 {
3915   PossibleCompletion* poss = NULL;
3916
3917   cmpl_state->the_completion.text[0] = 0;
3918
3919   if(cmpl_state->user_completion_index >= 0)
3920     poss = attempt_homedir_completion(cmpl_state->last_completion_text, cmpl_state);
3921   else
3922     poss = attempt_file_completion(cmpl_state);
3923
3924   update_cmpl(poss, cmpl_state);
3925
3926   return poss;
3927 }
3928
3929 /**********************************************************************/
3930 /*                       Directory Operations                         */
3931 /**********************************************************************/
3932
3933 /* Open the directory where completion will begin from, if possible. */
3934 static CompletionDir*
3935 open_ref_dir(gchar* text_to_complete,
3936              gchar** remaining_text,
3937              CompletionState* cmpl_state)
3938 {
3939   gchar* first_slash;
3940   CompletionDir *new_dir;
3941
3942   first_slash = strchr(text_to_complete, '/');
3943
3944   if (text_to_complete[0] == '~')
3945     {
3946       new_dir = open_user_dir(text_to_complete, cmpl_state);
3947
3948       if(new_dir)
3949         {
3950           if(first_slash)
3951             *remaining_text = first_slash + 1;
3952           else
3953             *remaining_text = text_to_complete + strlen(text_to_complete);
3954         }
3955       else
3956         {
3957           return NULL;
3958         }
3959     }
3960   else if (text_to_complete[0] == '/' || !cmpl_state->reference_dir)
3961     {
3962       gchar *tmp = g_strdup(text_to_complete);
3963       gchar *p;
3964
3965       p = tmp;
3966       while (*p && *p != '*' && *p != '?')
3967         p++;
3968
3969       *p = '\0';
3970       p = strrchr(tmp, '/');
3971       if (p)
3972         {
3973           if (p == tmp)
3974             p++;
3975
3976           *p = '\0';
3977
3978           new_dir = open_dir(tmp, cmpl_state);
3979
3980           if(new_dir)
3981             *remaining_text = text_to_complete +
3982               ((p == tmp + 1) ? (p - tmp) : (p + 1 - tmp));
3983         }
3984       else
3985         {
3986           /* If no possible candidates, use the cwd */
3987           gchar *curdir = g_get_current_dir ();
3988
3989           new_dir = open_dir(curdir, cmpl_state);
3990
3991           if (new_dir)
3992             *remaining_text = text_to_complete;
3993
3994           g_free (curdir);
3995         }
3996
3997       g_free (tmp);
3998     }
3999   else
4000     {
4001       *remaining_text = text_to_complete;
4002
4003       new_dir = open_dir(cmpl_state->reference_dir->fullname, cmpl_state);
4004     }
4005
4006   if(new_dir)
4007     {
4008       new_dir->cmpl_index = -1;
4009       new_dir->cmpl_parent = NULL;
4010     }
4011
4012   return new_dir;
4013 }
4014
4015 /* open a directory by user name */
4016 static CompletionDir*
4017 open_user_dir(gchar* text_to_complete,
4018               CompletionState *cmpl_state)
4019 {
4020   gchar *first_slash;
4021   gint cmp_len;
4022
4023   g_assert(text_to_complete && text_to_complete[0] == '~');
4024
4025   first_slash = strchr(text_to_complete, '/');
4026
4027   if (first_slash)
4028     cmp_len = first_slash - text_to_complete - 1;
4029   else
4030     cmp_len = strlen(text_to_complete + 1);
4031
4032   if(!cmp_len)
4033     {
4034       /* ~/ */
4035       gchar *homedir = g_get_home_dir ();
4036
4037       if (homedir)
4038         return open_dir(homedir, cmpl_state);
4039       else
4040         return NULL;
4041     }
4042   else
4043     {
4044       /* ~user/ */
4045       char* copy = g_new(char, cmp_len + 1);
4046       struct passwd *pwd;
4047       strncpy(copy, text_to_complete + 1, cmp_len);
4048       copy[cmp_len] = 0;
4049       pwd = getpwnam(copy);
4050       g_free(copy);
4051       if (!pwd)
4052         {
4053           cmpl_errno = errno;
4054           return NULL;
4055         }
4056
4057       return open_dir(pwd->pw_dir, cmpl_state);
4058     }
4059 }
4060
4061 /* open a directory relative the the current relative directory */
4062 static CompletionDir*
4063 open_relative_dir(gchar* dir_name,
4064                   CompletionDir* dir,
4065                   CompletionState *cmpl_state)
4066 {
4067   gchar path_buf[2*MAXPATHLEN];
4068
4069   if(dir->fullname_len + strlen(dir_name) + 2 >= MAXPATHLEN)
4070     {
4071       cmpl_errno = CMPL_ERRNO_TOO_LONG;
4072       return NULL;
4073     }
4074
4075   strcpy(path_buf, dir->fullname);
4076
4077   if(dir->fullname_len > 1)
4078     {
4079       path_buf[dir->fullname_len] = '/';
4080       strcpy(path_buf + dir->fullname_len + 1, dir_name);
4081     }
4082   else
4083     {
4084       strcpy(path_buf + dir->fullname_len, dir_name);
4085     }
4086
4087   return open_dir(path_buf, cmpl_state);
4088 }
4089
4090 /* after the cache lookup fails, really open a new directory */
4091 static CompletionDirSent*
4092 open_new_dir(gchar* dir_name, struct stat* sbuf, gboolean stat_subdirs)
4093 {
4094   CompletionDirSent* sent;
4095   DIR* directory;
4096   gchar *buffer_ptr;
4097   struct dirent *dirent_ptr;
4098   gint buffer_size = 0;
4099   gint entry_count = 0;
4100   gint i;
4101   struct stat ent_sbuf;
4102   char path_buf[MAXPATHLEN*2];
4103   gint path_buf_len;
4104
4105   sent = g_new(CompletionDirSent, 1);
4106   sent->mtime = sbuf->st_mtime;
4107   sent->inode = sbuf->st_ino;
4108   sent->device = sbuf->st_dev;
4109
4110   path_buf_len = strlen(dir_name);
4111
4112   if (path_buf_len > MAXPATHLEN)
4113     {
4114       cmpl_errno = CMPL_ERRNO_TOO_LONG;
4115       return NULL;
4116     }
4117
4118   strcpy(path_buf, dir_name);
4119
4120   directory = opendir(dir_name);
4121
4122   if(!directory)
4123     {
4124       cmpl_errno = errno;
4125       return NULL;
4126     }
4127
4128   while((dirent_ptr = readdir(directory)) != NULL)
4129     {
4130       int entry_len = strlen(dirent_ptr->d_name);
4131       buffer_size += entry_len + 1;
4132       entry_count += 1;
4133
4134       if(path_buf_len + entry_len + 2 >= MAXPATHLEN)
4135         {
4136           cmpl_errno = CMPL_ERRNO_TOO_LONG;
4137           closedir(directory);
4138           return NULL;
4139         }
4140     }
4141
4142   sent->name_buffer = g_new(gchar, buffer_size);
4143   sent->entries = g_new(CompletionDirEntry, entry_count);
4144   sent->entry_count = entry_count;
4145
4146   buffer_ptr = sent->name_buffer;
4147
4148   rewinddir(directory);
4149
4150   for(i = 0; i < entry_count; i += 1)
4151     {
4152       dirent_ptr = readdir(directory);
4153
4154       if(!dirent_ptr)
4155         {
4156           cmpl_errno = errno;
4157           closedir(directory);
4158           return NULL;
4159         }
4160
4161       strcpy(buffer_ptr, dirent_ptr->d_name);
4162       sent->entries[i].entry_name = buffer_ptr;
4163       buffer_ptr += strlen(dirent_ptr->d_name);
4164       *buffer_ptr = 0;
4165       buffer_ptr += 1;
4166
4167       path_buf[path_buf_len] = '/';
4168       strcpy(path_buf + path_buf_len + 1, dirent_ptr->d_name);
4169
4170       if (stat_subdirs)
4171         {
4172           if(stat(path_buf, &ent_sbuf) >= 0 && S_ISDIR(ent_sbuf.st_mode))
4173             sent->entries[i].is_dir = 1;
4174           else
4175             /* stat may fail, and we don't mind, since it could be a
4176              * dangling symlink. */
4177             sent->entries[i].is_dir = 0;
4178         }
4179       else
4180         sent->entries[i].is_dir = 1;
4181     }
4182
4183   qsort(sent->entries, sent->entry_count, sizeof(CompletionDirEntry), compare_cmpl_dir);
4184
4185   closedir(directory);
4186
4187   return sent;
4188 }
4189
4190 static gboolean
4191 check_dir(gchar *dir_name, struct stat *result, gboolean *stat_subdirs)
4192 {
4193   /* A list of directories that we know only contain other directories.
4194    * Trying to stat every file in these directories would be very
4195    * expensive.
4196    */
4197
4198   static struct {
4199     gchar *name;
4200     gboolean present;
4201     struct stat statbuf;
4202   } no_stat_dirs[] = {
4203     { "/afs", FALSE, { 0 } },
4204     { "/net", FALSE, { 0 } }
4205   };
4206
4207   static const gint n_no_stat_dirs = sizeof(no_stat_dirs) / sizeof(no_stat_dirs[0]);
4208   static gboolean initialized = FALSE;
4209
4210   gint i;
4211
4212   if (!initialized)
4213     {
4214       initialized = TRUE;
4215       for (i = 0; i < n_no_stat_dirs; i++)
4216         {
4217           if (stat (no_stat_dirs[i].name, &no_stat_dirs[i].statbuf) == 0)
4218             no_stat_dirs[i].present = TRUE;
4219         }
4220     }
4221
4222   if(stat(dir_name, result) < 0)
4223     {
4224       cmpl_errno = errno;
4225       return FALSE;
4226     }
4227
4228   *stat_subdirs = TRUE;
4229   for (i=0; i<n_no_stat_dirs; i++)
4230     {
4231       if (no_stat_dirs[i].present &&
4232           (no_stat_dirs[i].statbuf.st_dev == result->st_dev) &&
4233           (no_stat_dirs[i].statbuf.st_ino == result->st_ino))
4234         {
4235           *stat_subdirs = FALSE;
4236           break;
4237         }
4238     }
4239
4240   return TRUE;
4241 }
4242
4243 /* open a directory by absolute pathname */
4244 static CompletionDir*
4245 open_dir(gchar* dir_name, CompletionState* cmpl_state)
4246 {
4247   struct stat sbuf;
4248   gboolean stat_subdirs;
4249   CompletionDirSent *sent;
4250   GList* cdsl;
4251
4252   if (!check_dir (dir_name, &sbuf, &stat_subdirs))
4253     return NULL;
4254
4255   cdsl = cmpl_state->directory_sent_storage;
4256
4257   while (cdsl)
4258     {
4259       sent = cdsl->data;
4260
4261       if(sent->inode == sbuf.st_ino &&
4262          sent->mtime == sbuf.st_mtime &&
4263          sent->device == sbuf.st_dev)
4264         return attach_dir(sent, dir_name, cmpl_state);
4265
4266       cdsl = cdsl->next;
4267     }
4268
4269   sent = open_new_dir(dir_name, &sbuf, stat_subdirs);
4270
4271   if (sent) {
4272     cmpl_state->directory_sent_storage =
4273       g_list_prepend(cmpl_state->directory_sent_storage, sent);
4274
4275     return attach_dir(sent, dir_name, cmpl_state);
4276   }
4277
4278   return NULL;
4279 }
4280
4281 static CompletionDir*
4282 attach_dir(CompletionDirSent* sent, gchar* dir_name, CompletionState *cmpl_state)
4283 {
4284   CompletionDir* new_dir;
4285
4286   new_dir = g_new(CompletionDir, 1);
4287
4288   cmpl_state->directory_storage =
4289     g_list_prepend(cmpl_state->directory_storage, new_dir);
4290
4291   new_dir->sent = sent;
4292   new_dir->fullname = g_strdup(dir_name);
4293   new_dir->fullname_len = strlen(dir_name);
4294
4295   return new_dir;
4296 }
4297
4298 static gint
4299 correct_dir_fullname(CompletionDir* cmpl_dir)
4300 {
4301   gint length = strlen(cmpl_dir->fullname);
4302   struct stat sbuf;
4303
4304   if (strcmp(cmpl_dir->fullname + length - 2, "/.") == 0)
4305     {
4306       if (length == 2)
4307         {
4308           strcpy(cmpl_dir->fullname, "/");
4309           cmpl_dir->fullname_len = 1;
4310           return TRUE;
4311         } else {
4312           cmpl_dir->fullname[length - 2] = 0;
4313         }
4314     }
4315   else if (strcmp(cmpl_dir->fullname + length - 3, "/./") == 0)
4316     cmpl_dir->fullname[length - 2] = 0;
4317   else if (strcmp(cmpl_dir->fullname + length - 3, "/..") == 0)
4318     {
4319       if(length == 3)
4320         {
4321           strcpy(cmpl_dir->fullname, "/");
4322           cmpl_dir->fullname_len = 1;
4323           return TRUE;
4324         }
4325
4326       if(stat(cmpl_dir->fullname, &sbuf) < 0)
4327         {
4328           cmpl_errno = errno;
4329           return FALSE;
4330         }
4331
4332       cmpl_dir->fullname[length - 2] = 0;
4333
4334       if(!correct_parent(cmpl_dir, &sbuf))
4335         return FALSE;
4336     }
4337   else if (strcmp(cmpl_dir->fullname + length - 4, "/../") == 0)
4338     {
4339       if(length == 4)
4340         {
4341           strcpy(cmpl_dir->fullname, "/");
4342           cmpl_dir->fullname_len = 1;
4343           return TRUE;
4344         }
4345
4346       if(stat(cmpl_dir->fullname, &sbuf) < 0)
4347         {
4348           cmpl_errno = errno;
4349           return FALSE;
4350         }
4351
4352       cmpl_dir->fullname[length - 3] = 0;
4353
4354       if(!correct_parent(cmpl_dir, &sbuf))
4355         return FALSE;
4356     }
4357
4358   cmpl_dir->fullname_len = strlen(cmpl_dir->fullname);
4359
4360   return TRUE;
4361 }
4362
4363 static gint
4364 correct_parent(CompletionDir* cmpl_dir, struct stat *sbuf)
4365 {
4366   struct stat parbuf;
4367   gchar *last_slash;
4368   gchar *new_name;
4369   gchar c = 0;
4370
4371   last_slash = strrchr(cmpl_dir->fullname, '/');
4372
4373   g_assert(last_slash);
4374
4375   if(last_slash != cmpl_dir->fullname)
4376     { /* last_slash[0] = 0; */ }
4377   else
4378     {
4379       c = last_slash[1];
4380       last_slash[1] = 0;
4381     }
4382
4383   if (stat(cmpl_dir->fullname, &parbuf) < 0)
4384     {
4385       cmpl_errno = errno;
4386       return FALSE;
4387     }
4388
4389   if (parbuf.st_ino == sbuf->st_ino && parbuf.st_dev == sbuf->st_dev)
4390     /* it wasn't a link */
4391     return TRUE;
4392
4393   if(c)
4394     last_slash[1] = c;
4395   /* else
4396     last_slash[0] = '/'; */
4397
4398   /* it was a link, have to figure it out the hard way */
4399
4400   new_name = find_parent_dir_fullname(cmpl_dir->fullname);
4401
4402   if (!new_name)
4403     return FALSE;
4404
4405   g_free(cmpl_dir->fullname);
4406
4407   cmpl_dir->fullname = new_name;
4408
4409   return TRUE;
4410 }
4411
4412 static gchar*
4413 find_parent_dir_fullname(gchar* dirname)
4414 {
4415   gchar buffer[MAXPATHLEN];
4416   gchar buffer2[MAXPATHLEN];
4417
4418 #if defined(sun) && !defined(__SVR4)
4419   if(!getwd(buffer))
4420 #else
4421   if(!getcwd(buffer, MAXPATHLEN))
4422 #endif
4423     {
4424       cmpl_errno = errno;
4425       return NULL;
4426     }
4427
4428   if(chdir(dirname) != 0 || chdir("..") != 0)
4429     {
4430       cmpl_errno = errno;
4431       return NULL;
4432     }
4433
4434 #if defined(sun) && !defined(__SVR4)
4435   if(!getwd(buffer2))
4436 #else
4437   if(!getcwd(buffer2, MAXPATHLEN))
4438 #endif
4439     {
4440       chdir(buffer);
4441       cmpl_errno = errno;
4442
4443       return NULL;
4444     }
4445
4446   if(chdir(buffer) != 0)
4447     {
4448       cmpl_errno = errno;
4449       return NULL;
4450     }
4451
4452   return g_strdup(buffer2);
4453 }
4454
4455 /**********************************************************************/
4456 /*                        Completion Operations                       */
4457 /**********************************************************************/
4458
4459 static PossibleCompletion*
4460 attempt_homedir_completion(gchar* text_to_complete,
4461                            CompletionState *cmpl_state)
4462 {
4463   gint index, length;
4464
4465   if (!cmpl_state->user_dir_name_buffer &&
4466       !get_pwdb(cmpl_state))
4467     return NULL;
4468   length = strlen(text_to_complete) - 1;
4469
4470   cmpl_state->user_completion_index += 1;
4471
4472   while(cmpl_state->user_completion_index < cmpl_state->user_directories_len)
4473     {
4474       index = first_diff_index(text_to_complete + 1,
4475                                cmpl_state->user_directories
4476                                [cmpl_state->user_completion_index].login);
4477
4478       switch(index)
4479         {
4480         case PATTERN_MATCH:
4481           break;
4482         default:
4483           if(cmpl_state->last_valid_char < (index + 1))
4484             cmpl_state->last_valid_char = index + 1;
4485           cmpl_state->user_completion_index += 1;
4486           continue;
4487         }
4488
4489       cmpl_state->the_completion.is_a_completion = 1;
4490       cmpl_state->the_completion.is_directory = 1;
4491
4492       append_completion_text("~", cmpl_state);
4493
4494       append_completion_text(cmpl_state->
4495                               user_directories[cmpl_state->user_completion_index].login,
4496                              cmpl_state);
4497
4498       return append_completion_text("/", cmpl_state);
4499     }
4500
4501   if(text_to_complete[1] ||
4502      cmpl_state->user_completion_index > cmpl_state->user_directories_len)
4503     {
4504       cmpl_state->user_completion_index = -1;
4505       return NULL;
4506     }
4507   else
4508     {
4509       cmpl_state->user_completion_index += 1;
4510       cmpl_state->the_completion.is_a_completion = 1;
4511       cmpl_state->the_completion.is_directory = 1;
4512
4513       return append_completion_text("~/", cmpl_state);
4514     }
4515 }
4516
4517 /* returns the index (>= 0) of the first differing character,
4518  * PATTERN_MATCH if the completion matches */
4519 static gint
4520 first_diff_index(gchar* pat, gchar* text)
4521 {
4522   gint diff = 0;
4523
4524   while(*pat && *text && *text == *pat)
4525     {
4526       pat += 1;
4527       text += 1;
4528       diff += 1;
4529     }
4530
4531   if(*pat)
4532     return diff;
4533
4534   return PATTERN_MATCH;
4535 }
4536
4537 static PossibleCompletion*
4538 append_completion_text(gchar* text, CompletionState* cmpl_state)
4539 {
4540   gint len, i = 1;
4541
4542   if(!cmpl_state->the_completion.text)
4543     return NULL;
4544
4545   len = strlen(text) + strlen(cmpl_state->the_completion.text) + 1;
4546
4547   if(cmpl_state->the_completion.text_alloc > len)
4548     {
4549       strcat(cmpl_state->the_completion.text, text);
4550       return &cmpl_state->the_completion;
4551     }
4552
4553   while(i < len) { i <<= 1; }
4554
4555   cmpl_state->the_completion.text_alloc = i;
4556
4557   cmpl_state->the_completion.text = (gchar*)g_realloc(cmpl_state->the_completion.text, i);
4558
4559   if(!cmpl_state->the_completion.text)
4560     return NULL;
4561   else
4562     {
4563       strcat(cmpl_state->the_completion.text, text);
4564       return &cmpl_state->the_completion;
4565     }
4566 }
4567
4568 static CompletionDir*
4569 find_completion_dir(gchar* text_to_complete,
4570                     gchar** remaining_text,
4571                     CompletionState* cmpl_state)
4572 {
4573   gchar* first_slash = strchr(text_to_complete, '/');
4574   CompletionDir* dir = cmpl_state->reference_dir;
4575   CompletionDir* next;
4576   *remaining_text = text_to_complete;
4577
4578   while(first_slash)
4579     {
4580       gint len = first_slash - *remaining_text;
4581       gint found = 0;
4582       gchar *found_name = NULL;         /* Quiet gcc */
4583       gint i;
4584       gchar* pat_buf = g_new (gchar, len + 1);
4585
4586       strncpy(pat_buf, *remaining_text, len);
4587       pat_buf[len] = 0;
4588
4589       for(i = 0; i < dir->sent->entry_count; i += 1)
4590         {
4591           if(dir->sent->entries[i].is_dir &&
4592              fnmatch(pat_buf, dir->sent->entries[i].entry_name,
4593                      FNMATCH_FLAGS)!= FNM_NOMATCH)
4594             {
4595               if(found)
4596                 {
4597                   g_free (pat_buf);
4598                   return dir;
4599                 }
4600               else
4601                 {
4602                   found = 1;
4603                   found_name = dir->sent->entries[i].entry_name;
4604                 }
4605             }
4606         }
4607
4608       if (!found)
4609         {
4610           /* Perhaps we are trying to open an automount directory */
4611           found_name = pat_buf;
4612         }
4613
4614       next = open_relative_dir(found_name, dir, cmpl_state);
4615
4616       if(!next)
4617         {
4618           g_free (pat_buf);
4619           return NULL;
4620         }
4621
4622       next->cmpl_parent = dir;
4623
4624       dir = next;
4625
4626       if(!correct_dir_fullname(dir))
4627         {
4628           g_free(pat_buf);
4629           return NULL;
4630         }
4631
4632       *remaining_text = first_slash + 1;
4633       first_slash = strchr(*remaining_text, '/');
4634
4635       g_free (pat_buf);
4636     }
4637
4638   return dir;
4639 }
4640
4641 static void
4642 update_cmpl(PossibleCompletion* poss, CompletionState* cmpl_state)
4643 {
4644   gint cmpl_len;
4645
4646   if(!poss || !cmpl_is_a_completion(poss))
4647     return;
4648
4649   cmpl_len = strlen(cmpl_this_completion(poss));
4650
4651   if(cmpl_state->updated_text_alloc < cmpl_len + 1)
4652     {
4653       cmpl_state->updated_text =
4654         (gchar*)g_realloc(cmpl_state->updated_text,
4655                           cmpl_state->updated_text_alloc);
4656       cmpl_state->updated_text_alloc = 2*cmpl_len;
4657     }
4658
4659   if(cmpl_state->updated_text_len < 0)
4660     {
4661       strcpy(cmpl_state->updated_text, cmpl_this_completion(poss));
4662       cmpl_state->updated_text_len = cmpl_len;
4663       cmpl_state->re_complete = cmpl_is_directory(poss);
4664     }
4665   else if(cmpl_state->updated_text_len == 0)
4666     {
4667       cmpl_state->re_complete = FALSE;
4668     }
4669   else
4670     {
4671       gint first_diff =
4672         first_diff_index(cmpl_state->updated_text,
4673                          cmpl_this_completion(poss));
4674
4675       cmpl_state->re_complete = FALSE;
4676
4677       if(first_diff == PATTERN_MATCH)
4678         return;
4679
4680       if(first_diff > cmpl_state->updated_text_len)
4681         strcpy(cmpl_state->updated_text, cmpl_this_completion(poss));
4682
4683       cmpl_state->updated_text_len = first_diff;
4684       cmpl_state->updated_text[first_diff] = 0;
4685     }
4686 }
4687
4688 static PossibleCompletion*
4689 attempt_file_completion(CompletionState *cmpl_state)
4690 {
4691   gchar *pat_buf, *first_slash;
4692   CompletionDir *dir = cmpl_state->active_completion_dir;
4693
4694   dir->cmpl_index += 1;
4695
4696   if(dir->cmpl_index == dir->sent->entry_count)
4697     {
4698       if(dir->cmpl_parent == NULL)
4699         {
4700           cmpl_state->active_completion_dir = NULL;
4701
4702           return NULL;
4703         }
4704       else
4705         {
4706           cmpl_state->active_completion_dir = dir->cmpl_parent;
4707
4708           return attempt_file_completion(cmpl_state);
4709         }
4710     }
4711
4712   g_assert(dir->cmpl_text);
4713
4714   first_slash = strchr(dir->cmpl_text, '/');
4715
4716   if(first_slash)
4717     {
4718       gint len = first_slash - dir->cmpl_text;
4719
4720       pat_buf = g_new (gchar, len + 1);
4721       strncpy(pat_buf, dir->cmpl_text, len);
4722       pat_buf[len] = 0;
4723     }
4724   else
4725     {
4726       gint len = strlen(dir->cmpl_text);
4727
4728       pat_buf = g_new (gchar, len + 2);
4729       strcpy(pat_buf, dir->cmpl_text);
4730       strcpy(pat_buf + len, "*");
4731     }
4732
4733   if(first_slash)
4734     {
4735       if(dir->sent->entries[dir->cmpl_index].is_dir)
4736         {
4737           if(fnmatch(pat_buf, dir->sent->entries[dir->cmpl_index].entry_name,
4738                      FNMATCH_FLAGS) != FNM_NOMATCH)
4739             {
4740               CompletionDir* new_dir;
4741
4742               new_dir = open_relative_dir(dir->sent->entries[dir->cmpl_index].entry_name,
4743                                           dir, cmpl_state);
4744
4745               if(!new_dir)
4746                 {
4747                   g_free (pat_buf);
4748                   return NULL;
4749                 }
4750
4751               new_dir->cmpl_parent = dir;
4752
4753               new_dir->cmpl_index = -1;
4754               new_dir->cmpl_text = first_slash + 1;
4755
4756               cmpl_state->active_completion_dir = new_dir;
4757
4758               g_free (pat_buf);
4759               return attempt_file_completion(cmpl_state);
4760             }
4761           else
4762             {
4763               g_free (pat_buf);
4764               return attempt_file_completion(cmpl_state);
4765             }
4766         }
4767       else
4768         {
4769           g_free (pat_buf);
4770           return attempt_file_completion(cmpl_state);
4771         }
4772     }
4773   else
4774     {
4775       if(dir->cmpl_parent != NULL)
4776         {
4777           append_completion_text(dir->fullname +
4778                                  strlen(cmpl_state->completion_dir->fullname) + 1,
4779                                  cmpl_state);
4780           append_completion_text("/", cmpl_state);
4781         }
4782
4783       append_completion_text(dir->sent->entries[dir->cmpl_index].entry_name, cmpl_state);
4784
4785       cmpl_state->the_completion.is_a_completion =
4786         (fnmatch(pat_buf, dir->sent->entries[dir->cmpl_index].entry_name,
4787                  FNMATCH_FLAGS) != FNM_NOMATCH);
4788
4789       cmpl_state->the_completion.is_directory = dir->sent->entries[dir->cmpl_index].is_dir;
4790       if(dir->sent->entries[dir->cmpl_index].is_dir)
4791         append_completion_text("/", cmpl_state);
4792
4793       g_free (pat_buf);
4794       return &cmpl_state->the_completion;
4795     }
4796 }
4797
4798
4799 static gint
4800 get_pwdb(CompletionState* cmpl_state)
4801 {
4802   struct passwd *pwd_ptr;
4803   gchar* buf_ptr;
4804   gint len = 0, i, count = 0;
4805
4806   if(cmpl_state->user_dir_name_buffer)
4807     return TRUE;
4808   setpwent ();
4809
4810   while ((pwd_ptr = getpwent()) != NULL)
4811     {
4812       len += strlen(pwd_ptr->pw_name);
4813       len += strlen(pwd_ptr->pw_dir);
4814       len += 2;
4815       count += 1;
4816     }
4817
4818   setpwent ();
4819
4820   cmpl_state->user_dir_name_buffer = g_new(gchar, len);
4821   cmpl_state->user_directories = g_new(CompletionUserDir, count);
4822   cmpl_state->user_directories_len = count;
4823
4824   buf_ptr = cmpl_state->user_dir_name_buffer;
4825
4826   for(i = 0; i < count; i += 1)
4827     {
4828       pwd_ptr = getpwent();
4829       if(!pwd_ptr)
4830         {
4831           cmpl_errno = errno;
4832           goto error;
4833         }
4834
4835       strcpy(buf_ptr, pwd_ptr->pw_name);
4836       cmpl_state->user_directories[i].login = buf_ptr;
4837       buf_ptr += strlen(buf_ptr);
4838       buf_ptr += 1;
4839       strcpy(buf_ptr, pwd_ptr->pw_dir);
4840       cmpl_state->user_directories[i].homedir = buf_ptr;
4841       buf_ptr += strlen(buf_ptr);
4842       buf_ptr += 1;
4843     }
4844
4845   qsort(cmpl_state->user_directories,
4846         cmpl_state->user_directories_len,
4847         sizeof(CompletionUserDir),
4848         compare_user_dir);
4849
4850   endpwent();
4851
4852   return TRUE;
4853
4854 error:
4855
4856   if(cmpl_state->user_dir_name_buffer)
4857     g_free(cmpl_state->user_dir_name_buffer);
4858   if(cmpl_state->user_directories)
4859     g_free(cmpl_state->user_directories);
4860
4861   cmpl_state->user_dir_name_buffer = NULL;
4862   cmpl_state->user_directories = NULL;
4863
4864   return FALSE;
4865 }
4866
4867 static gint
4868 compare_user_dir(const void* a, const void* b)
4869 {
4870   return strcmp((((CompletionUserDir*)a))->login,
4871                 (((CompletionUserDir*)b))->login);
4872 }
4873
4874 static gint
4875 compare_cmpl_dir(const void* a, const void* b)
4876 {
4877   return strcmp((((CompletionDirEntry*)a))->entry_name,
4878                 (((CompletionDirEntry*)b))->entry_name);
4879 }
4880
4881 static gint
4882 cmpl_state_okay(CompletionState* cmpl_state)
4883 {
4884   return  cmpl_state && cmpl_state->reference_dir;
4885 }
4886
4887 static gchar*
4888 cmpl_strerror(gint err)
4889 {
4890   if(err == CMPL_ERRNO_TOO_LONG)
4891     return "Name too long";
4892   else
4893     return g_strerror (err);
4894 }
4895
4896 /* This is an internally used function to create pixmaps. */
4897 GtkWidget*
4898 create_pixmap(GtkWidget *widget, const gchar *pixmap_char)
4899 {
4900   GdkPixmap *gdkpixmap;
4901   GdkBitmap *mask;
4902   GtkWidget *pixmap;
4903   GdkColormap *colormap;
4904
4905   colormap = gtk_widget_get_colormap (widget);
4906
4907   gdkpixmap = gdk_pixmap_colormap_create_from_xpm_d (GTK_WIDGET(widget)->window,
4908                                                      colormap,
4909                                                      &mask,
4910                                                      NULL,
4911                                                      (gpointer) pixmap_char);
4912   if (gdkpixmap == NULL)
4913     {
4914       g_warning ("Error loading pixmap: %s", pixmap_char);
4915       return NULL;
4916     }
4917   pixmap = gtk_pixmap_new (gdkpixmap, mask);
4918   gdk_pixmap_unref (gdkpixmap);
4919   gdk_bitmap_unref (mask);
4920   return pixmap;
4921 }
4922
4923
4924 /* Testing area */
4925 #ifdef TORRIE_DEBUG
4926
4927 /* Get the selected filename and print it to the console */
4928 void file_ok_sel( GtkWidget        *w,
4929                   GtkFileSelection *fs )
4930 {
4931     g_print ("%s\n", gtk_file_selection_get_filename (GTK_FILE_SELECTION (fs)));
4932 }
4933
4934 void destroy( GtkWidget *widget,
4935               gpointer   data )
4936 {
4937     gtk_main_quit ();
4938 }
4939
4940 int main( int   argc,
4941           char *argv[] )
4942 {
4943     GtkWidget *filew;
4944     const gchar *masks[] = { "mp3s/playlists <*.mp3,*.m3u>",
4945                              "src/hdr <*.[CcHh],*.[Cc][Cc],*.[Hh][Hh],*.cpp>",
4946                              NULL };
4947
4948     gtk_init (&argc, &argv);
4949
4950     /* Create a new file selection widget */
4951     filew = gtk_file_selection_new ("Spiffy File Selector");
4952 //    gtk_file_selection_complete(GTK_FILE_SELECTION(filew),"bob");
4953
4954     gtk_file_selection_set_masks (GTK_FILE_SELECTION (filew), masks);
4955
4956     gtk_signal_connect (GTK_OBJECT (filew), "destroy",
4957                         (GtkSignalFunc) destroy, &filew);
4958     /* Connect the ok_button to file_ok_sel function */
4959     gtk_signal_connect (GTK_OBJECT (GTK_FILE_SELECTION (filew)->ok_button),
4960                         "clicked", (GtkSignalFunc) file_ok_sel, filew );
4961
4962     /* Connect the cancel_button to destroy the widget */
4963     gtk_signal_connect_object (GTK_OBJECT (GTK_FILE_SELECTION
4964                                             (filew)->cancel_button),
4965                                "clicked", (GtkSignalFunc) gtk_widget_destroy,
4966                                GTK_OBJECT (filew));
4967
4968
4969     gtk_widget_show(filew);
4970
4971 /*
4972     g_print("%d",gtk_file_selection_match_mask("mask.c","m*.c"));
4973     g_print("%d",gtk_file_selection_match_mask("mask.c","m???.c"));
4974                 g_print("%d",gtk_file_selection_match_mask("mask.c","m??*.c"));
4975                 g_print("%d",gtk_file_selection_match_mask("mask.cout","m*.c"));
4976                 g_print("%d",gtk_file_selection_match_mask("mask.cout","m*.c???"));
4977                 g_print("%d",gtk_file_selection_match_mask("mask.cout","m*.c*"));
4978                 g_print("%d",gtk_file_selection_match_mask("mask.cout","n*.c???"));
4979                 g_print("%d",gtk_file_selection_match_mask("mask.c","[mn]*"));
4980                 g_print("%d",gtk_file_selection_match_mask("COPYING","*.xpm"));
4981 */
4982     gtk_main ();
4983
4984     return 0;
4985 }
4986 /* example-end */
4987 #endif