Pileus Git - ~andy/gtk/blob - gtk/gtkfilechooserentry.c

   1 /* GTK - The GIMP Toolkit
   2  * gtkfilechooserentry.c: Entry with filename completion
   3  * Copyright (C) 2003, Red Hat, Inc.
   4  *
   5  * This library is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU Lesser General Public
   7  * License as published by the Free Software Foundation; either
   8  * version 2 of the License, or (at your option) any later version.
   9  *
  10  * This library is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * Lesser General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU Lesser General Public
  16  * License along with this library; if not, write to the
  17  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  18  * Boston, MA 02111-1307, USA.
  19  */
  20
  21 #include <config.h>
  22 #include <string.h>
  23
  24 #include "gtkalias.h"
  25 #include "gtkcelllayout.h"
  26 #include "gtkcellrenderertext.h"
  27 #include "gtkentry.h"
  28 #include "gtkfilechooserentry.h"
  29 #include "gtkmain.h"
  30
  31 typedef struct _GtkFileChooserEntryClass GtkFileChooserEntryClass;
  32
  33 #define GTK_FILE_CHOOSER_ENTRY_CLASS(klass)     (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_FILE_CHOOSER_ENTRY, GtkFileChooserEntryClass))
  34 #define GTK_IS_FILE_CHOOSER_ENTRY_CLASS(klass)  (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_FILE_CHOOSER_ENTRY))
  35 #define GTK_FILE_CHOOSER_ENTRY_GET_CLASS(obj)   (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_FILE_CHOOSER_ENTRY, GtkFileChooserEntryClass))
  36
  37 struct _GtkFileChooserEntryClass
  38 {
  39   GtkEntryClass parent_class;
  40 };
  41
  42 struct _GtkFileChooserEntry
  43 {
  44   GtkEntry parent_instance;
  45
  46   GtkFileChooserAction action;
  47
  48   GtkFileSystem *file_system;
  49   GtkFilePath *base_folder;
  50   GtkFilePath *current_folder_path;
  51   gchar *file_part;
  52   gint file_part_pos;
  53   GSource *check_completion_idle;
  54   GSource *load_directory_idle;
  55
  56   GtkFileFolder *current_folder;
  57
  58   GtkListStore *completion_store;
  59
  60   guint has_completion : 1;
  61   guint in_change      : 1;
  62   guint eat_tabs       : 1;
  63 };
  64
  65 enum
  66 {
  67   DISPLAY_NAME_COLUMN,
  68   PATH_COLUMN,
  69   N_COLUMNS
  70 };
  71
  72 static void gtk_file_chooser_entry_class_init (GtkFileChooserEntryClass *class);
  73 static void gtk_file_chooser_entry_iface_init (GtkEditableClass         *iface);
  74 static void gtk_file_chooser_entry_init       (GtkFileChooserEntry      *chooser_entry);
  75
  76 static void     gtk_file_chooser_entry_finalize       (GObject          *object);
  77 static gboolean gtk_file_chooser_entry_focus          (GtkWidget        *widget,
  78                                                        GtkDirectionType  direction);
  79 static void     gtk_file_chooser_entry_activate       (GtkEntry         *entry);
  80 static void     gtk_file_chooser_entry_changed        (GtkEditable      *editable);
  81 static void     gtk_file_chooser_entry_do_insert_text (GtkEditable *editable,
  82                                                        const gchar *new_text,
  83                                                        gint         new_text_length,
  84                                                        gint        *position);
  85
  86 static void     clear_completion_callback (GtkFileChooserEntry *chooser_entry,
  87                                            GParamSpec          *pspec);
  88 static gboolean match_selected_callback   (GtkEntryCompletion  *completion,
  89                                            GtkTreeModel        *model,
  90                                            GtkTreeIter         *iter,
  91                                            GtkFileChooserEntry *chooser_entry);
  92 static gboolean completion_match_func     (GtkEntryCompletion  *comp,
  93                                            const char          *key,
  94                                            GtkTreeIter         *iter,
  95                                            gpointer             data);
  96 static void     files_added_cb            (GtkFileSystem       *file_system,
  97                                            GSList              *added_uris,
  98                                            GtkFileChooserEntry *chooser_entry);
  99 static void     files_deleted_cb          (GtkFileSystem       *file_system,
 100                                            GSList              *deleted_uris,
 101                                            GtkFileChooserEntry *chooser_entry);
 102 static char    *maybe_append_separator_to_path (GtkFileChooserEntry *chooser_entry,
 103                                                 GtkFilePath         *path,
 104                                                 gchar               *display_name);
 105
 106 static GObjectClass *parent_class;
 107 static GtkEditableClass *parent_editable_iface;
 108
 109 GType
 110 _gtk_file_chooser_entry_get_type (void)
 111 {
 112   static GType file_chooser_entry_type = 0;
 113
 114   if (!file_chooser_entry_type)
 115     {
 116       static const GTypeInfo file_chooser_entry_info =
 117       {
 118         sizeof (GtkFileChooserEntryClass),
 119         NULL,           /* base_init */
 120         NULL,           /* base_finalize */
 121         (GClassInitFunc) gtk_file_chooser_entry_class_init,
 122         NULL,           /* class_finalize */
 123         NULL,           /* class_data */
 124         sizeof (GtkFileChooserEntry),
 125         0,              /* n_preallocs */
 126         (GInstanceInitFunc) gtk_file_chooser_entry_init,
 127       };
 128
 129       static const GInterfaceInfo editable_info =
 130       {
 131         (GInterfaceInitFunc) gtk_file_chooser_entry_iface_init, /* interface_init */
 132         NULL,                                                 /* interface_finalize */
 133         NULL                                                  /* interface_data */
 134       };
 135
 136
 137       file_chooser_entry_type = g_type_register_static (GTK_TYPE_ENTRY, "GtkFileChooserEntry",
 138                                                         &file_chooser_entry_info, 0);
 139       g_type_add_interface_static (file_chooser_entry_type,
 140                                    GTK_TYPE_EDITABLE,
 141                                    &editable_info);
 142     }
 143
 144
 145   return file_chooser_entry_type;
 146 }
 147
 148 static void
 149 gtk_file_chooser_entry_class_init (GtkFileChooserEntryClass *class)
 150 {
 151   GObjectClass *gobject_class = G_OBJECT_CLASS (class);
 152   GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (class);
 153   GtkEntryClass *entry_class = GTK_ENTRY_CLASS (class);
 154
 155   parent_class = g_type_class_peek_parent (class);
 156
 157   gobject_class->finalize = gtk_file_chooser_entry_finalize;
 158
 159   widget_class->focus = gtk_file_chooser_entry_focus;
 160
 161   entry_class->activate = gtk_file_chooser_entry_activate;
 162 }
 163
 164 static void
 165 gtk_file_chooser_entry_iface_init (GtkEditableClass *iface)
 166 {
 167   parent_editable_iface = g_type_interface_peek_parent (iface);
 168
 169   iface->do_insert_text = gtk_file_chooser_entry_do_insert_text;
 170   iface->changed = gtk_file_chooser_entry_changed;
 171 }
 172
 173 static void
 174 gtk_file_chooser_entry_init (GtkFileChooserEntry *chooser_entry)
 175 {
 176   GtkEntryCompletion *comp;
 177   GtkCellRenderer *cell;
 178
 179   comp = gtk_entry_completion_new ();
 180
 181   gtk_entry_completion_set_match_func (comp,
 182                                        completion_match_func,
 183                                        chooser_entry,
 184                                        NULL);
 185
 186   cell = gtk_cell_renderer_text_new ();
 187   gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (comp),
 188                               cell, TRUE);
 189   gtk_cell_layout_add_attribute (GTK_CELL_LAYOUT (comp),
 190                                  cell,
 191                                  "text", 0);
 192
 193   g_signal_connect (comp, "match-selected",
 194                     G_CALLBACK (match_selected_callback), chooser_entry);
 195
 196   gtk_entry_set_completion (GTK_ENTRY (chooser_entry), comp);
 197   g_object_unref (comp);
 198
 199   g_signal_connect (chooser_entry, "notify::cursor-position",
 200                     G_CALLBACK (clear_completion_callback), NULL);
 201   g_signal_connect (chooser_entry, "notify::selection-bound",
 202                     G_CALLBACK (clear_completion_callback), NULL);
 203 }
 204
 205 static void
 206 gtk_file_chooser_entry_finalize (GObject *object)
 207 {
 208   GtkFileChooserEntry *chooser_entry = GTK_FILE_CHOOSER_ENTRY (object);
 209
 210   if (chooser_entry->completion_store)
 211     g_object_unref (chooser_entry->completion_store);
 212
 213   if (chooser_entry->current_folder)
 214     {
 215       g_signal_handlers_disconnect_by_func (chooser_entry->current_folder,
 216                                             G_CALLBACK (files_added_cb), chooser_entry);
 217       g_signal_handlers_disconnect_by_func (chooser_entry->current_folder,
 218                                             G_CALLBACK (files_deleted_cb), chooser_entry);
 219       g_object_unref (chooser_entry->current_folder);
 220     }
 221
 222   if (chooser_entry->file_system)
 223     g_object_unref (chooser_entry->file_system);
 224
 225   gtk_file_path_free (chooser_entry->base_folder);
 226   gtk_file_path_free (chooser_entry->current_folder_path);
 227   g_free (chooser_entry->file_part);
 228
 229   parent_class->finalize (object);
 230 }
 231
 232 /* Match functions for the GtkEntryCompletion */
 233 static gboolean
 234 match_selected_callback (GtkEntryCompletion  *completion,
 235                          GtkTreeModel        *model,
 236                          GtkTreeIter         *iter,
 237                          GtkFileChooserEntry *chooser_entry)
 238 {
 239   char *display_name;
 240   GtkFilePath *path;
 241   gint pos;
 242
 243   gtk_tree_model_get (model, iter,
 244                       DISPLAY_NAME_COLUMN, &display_name,
 245                       PATH_COLUMN, &path,
 246                       -1);
 247
 248   if (!display_name || !path)
 249     {
 250       /* these shouldn't complain if passed NULL */
 251       gtk_file_path_free (path);
 252       g_free (display_name);
 253       return FALSE;
 254     }
 255
 256   display_name = maybe_append_separator_to_path (chooser_entry, path, display_name);
 257
 258   pos = chooser_entry->file_part_pos;
 259
 260   /* We don't set in_change here as we want to update the current_folder
 261    * variable */
 262   gtk_editable_delete_text (GTK_EDITABLE (chooser_entry),
 263                             pos, -1);
 264   gtk_editable_insert_text (GTK_EDITABLE (chooser_entry),
 265                             display_name, -1,
 266                             &pos);
 267   gtk_editable_set_position (GTK_EDITABLE (chooser_entry), -1);
 268
 269   gtk_file_path_free (path);
 270   g_free (display_name);
 271
 272   return TRUE;
 273 }
 274
 275 /* Match function for the GtkEntryCompletion */
 276 static gboolean
 277 completion_match_func (GtkEntryCompletion *comp,
 278                        const char         *key_unused,
 279                        GtkTreeIter        *iter,
 280                        gpointer            data)
 281 {
 282   GtkFileChooserEntry *chooser_entry;
 283   char *name;
 284   gboolean result;
 285   char *norm_file_part;
 286   char *norm_name;
 287
 288   chooser_entry = GTK_FILE_CHOOSER_ENTRY (data);
 289
 290   /* We ignore the key because it is the contents of the entry.  Instead, we
 291    * just use our precomputed file_part.
 292    */
 293   if (!chooser_entry->file_part)
 294     {
 295       return FALSE;
 296     }
 297
 298   gtk_tree_model_get (GTK_TREE_MODEL (chooser_entry->completion_store), iter, DISPLAY_NAME_COLUMN, &name, -1);
 299   if (!name)
 300     {
 301       return FALSE; /* Uninitialized row, ugh */
 302     }
 303
 304   /* If we have an empty file_part, then we're at the root of a directory.  In
 305    * that case, we want to match all non-dot files.  We might want to match
 306    * dot_files too if show_hidden is TRUE on the fileselector in the future.
 307    */
 308   /* Additionally, support for gnome .hidden files would be sweet, too */
 309   if (chooser_entry->file_part[0] == '\000')
 310     {
 311       if (name[0] == '.')
 312         result = FALSE;
 313       else
 314         result = TRUE;
 315       g_free (name);
 316
 317       return result;
 318     }
 319
 320
 321   norm_file_part = g_utf8_normalize (chooser_entry->file_part, -1, G_NORMALIZE_ALL);
 322   norm_name = g_utf8_normalize (name, -1, G_NORMALIZE_ALL);
 323
 324 #ifdef G_PLATFORM_WIN32
 325   {
 326     gchar *temp;
 327
 328     temp = norm_file_part;
 329     norm_file_part = g_utf8_casefold (norm_file_part, -1);
 330     g_free (temp);
 331
 332     temp = norm_name;
 333     norm_name = g_utf8_casefold (norm_name, -1);
 334     g_free (temp);
 335   }
 336 #endif
 337
 338   result = (strncmp (norm_file_part, norm_name, strlen (norm_file_part)) == 0);
 339
 340   g_free (norm_file_part);
 341   g_free (norm_name);
 342   g_free (name);
 343
 344   return result;
 345 }
 346
 347 /* This function will append a directory separator to paths to
 348  * display_name iff the path associated with it is a directory.
 349  * maybe_append_separator_to_path will g_free the display_name and
 350  * return a new one if needed.  Otherwise, it will return the old one.
 351  * You should be safe calling
 352  *
 353  * display_name = maybe_append_separator_to_path (entry, path, display_name);
 354  * ...
 355  * g_free (display_name);
 356  */
 357 static char *
 358 maybe_append_separator_to_path (GtkFileChooserEntry *chooser_entry,
 359                                 GtkFilePath         *path,
 360                                 gchar               *display_name)
 361 {
 362   if (path)
 363     {
 364       GtkFileInfo *info;
 365
 366       info = gtk_file_folder_get_info (chooser_entry->current_folder,
 367                                        path, NULL); /* NULL-GError */
 368
 369       if (info)
 370         {
 371           if (gtk_file_info_get_is_folder (info))
 372             {
 373               gchar *tmp = display_name;
 374               display_name = g_strconcat (tmp, G_DIR_SEPARATOR_S, NULL);
 375               g_free (tmp);
 376             }
 377
 378           gtk_file_info_free (info);
 379         }
 380
 381     }
 382
 383   return display_name;
 384 }
 385
 386 static gboolean
 387 check_completion_callback (GtkFileChooserEntry *chooser_entry)
 388 {
 389   GtkTreeIter iter;
 390   gchar *common_prefix = NULL;
 391   GtkFilePath *unique_path = NULL;
 392   gboolean valid;
 393
 394   g_assert (chooser_entry->file_part);
 395
 396   chooser_entry->check_completion_idle = NULL;
 397
 398   if (strcmp (chooser_entry->file_part, "") == 0)
 399     return FALSE;
 400
 401   if (chooser_entry->completion_store == NULL)
 402     return FALSE;
 403
 404   valid = gtk_tree_model_get_iter_first (GTK_TREE_MODEL (chooser_entry->completion_store),
 405                                          &iter);
 406
 407   while (valid)
 408     {
 409       gchar *display_name;
 410       GtkFilePath *path;
 411
 412       gtk_tree_model_get (GTK_TREE_MODEL (chooser_entry->completion_store),
 413                           &iter,
 414                           DISPLAY_NAME_COLUMN, &display_name,
 415                           PATH_COLUMN, &path,
 416                           -1);
 417
 418       if (g_str_has_prefix (display_name, chooser_entry->file_part))
 419         {
 420           if (!common_prefix)
 421             {
 422               common_prefix = g_strdup (display_name);
 423               unique_path = gtk_file_path_copy (path);
 424             }
 425           else
 426             {
 427               gchar *p = common_prefix;
 428               const gchar *q = display_name;
 429
 430               while (*p && *p == *q)
 431                 {
 432                   p++;
 433                   q++;
 434                 }
 435
 436               *p = '\0';
 437
 438               gtk_file_path_free (unique_path);
 439               unique_path = NULL;
 440             }
 441         }
 442
 443       g_free (display_name);
 444       gtk_file_path_free (path);
 445       valid = gtk_tree_model_iter_next (GTK_TREE_MODEL (chooser_entry->completion_store),
 446                                         &iter);
 447     }
 448
 449   if (unique_path)
 450     {
 451       common_prefix = maybe_append_separator_to_path (chooser_entry,
 452                                                       unique_path,
 453                                                       common_prefix);
 454       gtk_file_path_free (unique_path);
 455     }
 456
 457   switch (chooser_entry->action)
 458     {
 459     case GTK_FILE_CHOOSER_ACTION_SAVE:
 460     case GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER:
 461       if (common_prefix && !g_str_has_suffix (common_prefix, "/"))
 462         {
 463           g_free (common_prefix);
 464           common_prefix = NULL;
 465         }
 466       break;
 467     default: ;
 468     }
 469
 470   if (common_prefix)
 471     {
 472       gint file_part_len;
 473       gint common_prefix_len;
 474       gint pos;
 475
 476       file_part_len = g_utf8_strlen (chooser_entry->file_part, -1);
 477       common_prefix_len = g_utf8_strlen (common_prefix, -1);
 478
 479       if (common_prefix_len > file_part_len)
 480         {
 481           pos = chooser_entry->file_part_pos;
 482
 483           chooser_entry->in_change = TRUE;
 484           gtk_editable_delete_text (GTK_EDITABLE (chooser_entry),
 485                                     pos, -1);
 486           gtk_editable_insert_text (GTK_EDITABLE (chooser_entry),
 487                                     common_prefix, -1,
 488                                     &pos);
 489           gtk_editable_select_region (GTK_EDITABLE (chooser_entry),
 490                                       chooser_entry->file_part_pos + file_part_len,
 491                                       chooser_entry->file_part_pos + common_prefix_len);
 492           chooser_entry->in_change = FALSE;
 493
 494           chooser_entry->has_completion = TRUE;
 495         }
 496
 497       g_free (common_prefix);
 498     }
 499
 500   return FALSE;
 501 }
 502
 503 static void
 504 add_completion_idle (GtkFileChooserEntry *chooser_entry)
 505 {
 506   /* idle to update the selection based on the file list */
 507   if (chooser_entry->check_completion_idle == NULL)
 508     {
 509       chooser_entry->check_completion_idle = g_idle_source_new ();
 510       g_source_set_priority (chooser_entry->check_completion_idle, G_PRIORITY_HIGH);
 511       g_source_set_closure (chooser_entry->check_completion_idle,
 512                             g_cclosure_new_object (G_CALLBACK (check_completion_callback),
 513                                                    G_OBJECT (chooser_entry)));
 514       g_source_attach (chooser_entry->check_completion_idle, NULL);
 515     }
 516 }
 517
 518
 519 static void
 520 update_current_folder_files (GtkFileChooserEntry *chooser_entry,
 521                              GSList              *added_uris)
 522 {
 523   GSList *tmp_list;
 524
 525   g_assert (chooser_entry->completion_store != NULL);
 526
 527   /* Bah.  Need to turn off sorting */
 528   for (tmp_list = added_uris; tmp_list; tmp_list = tmp_list->next)
 529     {
 530       GtkFileInfo *info;
 531       GtkFilePath *path;
 532
 533       path = tmp_list->data;
 534
 535       info = gtk_file_folder_get_info (chooser_entry->current_folder,
 536                                        path,
 537                                        NULL); /* NULL-GError */
 538       if (info)
 539         {
 540           const gchar *display_name = gtk_file_info_get_display_name (info);
 541           GtkTreeIter iter;
 542
 543           gtk_list_store_append (chooser_entry->completion_store, &iter);
 544           gtk_list_store_set (chooser_entry->completion_store, &iter,
 545                               DISPLAY_NAME_COLUMN, display_name,
 546                               PATH_COLUMN, path,
 547                               -1);
 548
 549           gtk_file_info_free (info);
 550         }
 551     }
 552
 553   /* FIXME: we want to turn off sorting temporarily.  I suck... */
 554   gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (chooser_entry->completion_store),
 555                                         DISPLAY_NAME_COLUMN, GTK_SORT_ASCENDING);
 556
 557   add_completion_idle (chooser_entry);
 558 }
 559
 560 static void
 561 files_added_cb (GtkFileSystem       *file_system,
 562                 GSList              *added_uris,
 563                 GtkFileChooserEntry *chooser_entry)
 564 {
 565   update_current_folder_files (chooser_entry, added_uris);
 566 }
 567
 568 static void
 569 files_deleted_cb (GtkFileSystem       *file_system,
 570                   GSList              *deleted_uris,
 571                   GtkFileChooserEntry *chooser_entry)
 572 {
 573   /* FIXME: gravy... */
 574 }
 575
 576 static gboolean
 577 load_directory_callback (GtkFileChooserEntry *chooser_entry)
 578 {
 579   GSList *child_paths = NULL;
 580
 581   chooser_entry->load_directory_idle = NULL;
 582
 583   /* guard against bogus settings*/
 584   if (chooser_entry->current_folder_path == NULL ||
 585       chooser_entry->file_system == NULL)
 586     return FALSE;
 587
 588   if (chooser_entry->current_folder != NULL)
 589     {
 590       g_warning ("idle activate multiple times without clearing the folder object first.");
 591       return FALSE;
 592     }
 593   g_assert (chooser_entry->completion_store == NULL);
 594
 595   /* Load the folder */
 596   chooser_entry->current_folder = gtk_file_system_get_folder (chooser_entry->file_system,
 597                                                               chooser_entry->current_folder_path,
 598                                                               GTK_FILE_INFO_DISPLAY_NAME | GTK_FILE_INFO_IS_FOLDER,
 599                                                               NULL); /* NULL-GError */
 600
 601   /* There is no folder by that name */
 602   if (!chooser_entry->current_folder)
 603     return FALSE;
 604   g_signal_connect (chooser_entry->current_folder, "files-added",
 605                     G_CALLBACK (files_added_cb), chooser_entry);
 606   g_signal_connect (chooser_entry->current_folder, "files-removed",
 607                     G_CALLBACK (files_deleted_cb), chooser_entry);
 608
 609   chooser_entry->completion_store = gtk_list_store_new (N_COLUMNS,
 610                                                         G_TYPE_STRING,
 611                                                         GTK_TYPE_FILE_PATH);
 612
 613   if (chooser_entry->file_part_pos != -1)
 614     {
 615       gtk_file_folder_list_children (chooser_entry->current_folder,
 616                                      &child_paths,
 617                                      NULL); /* NULL-GError */
 618       if (child_paths)
 619         {
 620           update_current_folder_files (chooser_entry, child_paths);
 621           add_completion_idle (chooser_entry);
 622           gtk_file_paths_free (child_paths);
 623         }
 624     }
 625
 626   gtk_entry_completion_set_model (gtk_entry_get_completion (GTK_ENTRY (chooser_entry)),
 627                                   GTK_TREE_MODEL (chooser_entry->completion_store));
 628   return FALSE;
 629 }
 630
 631 static void
 632 gtk_file_chooser_entry_do_insert_text (GtkEditable *editable,
 633                                        const gchar *new_text,
 634                                        gint         new_text_length,
 635                                        gint        *position)
 636 {
 637   GtkFileChooserEntry *chooser_entry = GTK_FILE_CHOOSER_ENTRY (editable);
 638
 639   parent_editable_iface->do_insert_text (editable, new_text, new_text_length, position);
 640
 641   if (! chooser_entry->in_change)
 642     add_completion_idle (GTK_FILE_CHOOSER_ENTRY (editable));
 643 }
 644
 645 static gboolean
 646 gtk_file_chooser_entry_focus (GtkWidget        *widget,
 647                               GtkDirectionType  direction)
 648 {
 649   GtkFileChooserEntry *chooser_entry = GTK_FILE_CHOOSER_ENTRY (widget);
 650   GdkModifierType state;
 651   gboolean control_pressed = FALSE;
 652
 653   if (!chooser_entry->eat_tabs)
 654     return GTK_WIDGET_CLASS (parent_class)->focus (widget, direction);
 655
 656   if (gtk_get_current_event_state (&state))
 657     {
 658       if ((state & GDK_CONTROL_MASK) == GDK_CONTROL_MASK)
 659         control_pressed = TRUE;
 660     }
 661
 662   /* This is a bit evil -- it makes Tab never leave the entry. It basically
 663    * makes it 'safe' for people to hit. */
 664   if ((direction == GTK_DIR_TAB_FORWARD) &&
 665       (GTK_WIDGET_HAS_FOCUS (widget)) &&
 666       (! control_pressed))
 667     {
 668       if (chooser_entry->has_completion)
 669         {
 670           gtk_editable_set_position (GTK_EDITABLE (widget),
 671                                      GTK_ENTRY (widget)->text_length);
 672         }
 673       return TRUE;
 674     }
 675   else
 676     return GTK_WIDGET_CLASS (parent_class)->focus (widget, direction);
 677 }
 678
 679 static void
 680 gtk_file_chooser_entry_activate (GtkEntry *entry)
 681 {
 682   GtkFileChooserEntry *chooser_entry = GTK_FILE_CHOOSER_ENTRY (entry);
 683
 684   if (chooser_entry->has_completion)
 685     {
 686       gtk_editable_set_position (GTK_EDITABLE (entry),
 687                                  entry->text_length);
 688     }
 689
 690   GTK_ENTRY_CLASS (parent_class)->activate (entry);
 691 }
 692
 693 /* This will see if a path typed by the user is new, and installs the loading
 694  * idle if it is.
 695  */
 696 static void
 697 gtk_file_chooser_entry_maybe_update_directory (GtkFileChooserEntry *chooser_entry,
 698                                                GtkFilePath         *folder_path,
 699                                                gboolean             force_reload)
 700 {
 701   gboolean queue_idle = FALSE;
 702
 703   if (chooser_entry->current_folder_path)
 704     {
 705       if (gtk_file_path_compare (folder_path, chooser_entry->current_folder_path) != 0 || force_reload)
 706         {
 707           /* We changed our current directory.  We need to clear out the old
 708            * directory information.
 709            */
 710           if (chooser_entry->current_folder)
 711             {
 712               g_signal_handlers_disconnect_by_func (chooser_entry->current_folder,
 713                                                     G_CALLBACK (files_added_cb), chooser_entry);
 714               g_signal_handlers_disconnect_by_func (chooser_entry->current_folder,
 715                                                     G_CALLBACK (files_deleted_cb), chooser_entry);
 716
 717               g_object_unref (chooser_entry->current_folder);
 718               chooser_entry->current_folder = NULL;
 719             }
 720           if (chooser_entry->completion_store)
 721             {
 722               gtk_list_store_clear (GTK_LIST_STORE (chooser_entry->completion_store));
 723               /* FIXME: Uncomment this line and get rid of the _clear above
 724                * after #137211 is fixed */
 725               /* gtk_entry_completion_set_model (gtk_entry_get_completion (GTK_ENTRY (chooser_entry)), NULL);*/
 726               g_object_unref (chooser_entry->completion_store);
 727               chooser_entry->completion_store = NULL;
 728             }
 729
 730           queue_idle = TRUE;
 731         }
 732
 733       gtk_file_path_free (chooser_entry->current_folder_path);
 734     }
 735   else
 736     {
 737       queue_idle = TRUE;
 738     }
 739
 740   chooser_entry->current_folder_path = folder_path;
 741
 742   if (queue_idle && chooser_entry->load_directory_idle == NULL)
 743     {
 744       chooser_entry->load_directory_idle = g_idle_source_new ();
 745       g_source_set_priority (chooser_entry->load_directory_idle, G_PRIORITY_HIGH);
 746       g_source_set_closure (chooser_entry->load_directory_idle,
 747                             g_cclosure_new_object (G_CALLBACK (load_directory_callback),
 748                                                    G_OBJECT (chooser_entry)));
 749       g_source_attach (chooser_entry->load_directory_idle, NULL);
 750     }
 751 }
 752
 753
 754
 755 static void
 756 gtk_file_chooser_entry_changed (GtkEditable *editable)
 757 {
 758   GtkFileChooserEntry *chooser_entry = GTK_FILE_CHOOSER_ENTRY (editable);
 759   const gchar *text;
 760   GtkFilePath *folder_path;
 761   gchar *file_part;
 762   gsize total_len, file_part_len;
 763   gint file_part_pos;
 764
 765   if (chooser_entry->in_change)
 766     return;
 767
 768   text = gtk_entry_get_text (GTK_ENTRY (editable));
 769
 770   if (!chooser_entry->file_system ||
 771       !chooser_entry->base_folder ||
 772       !gtk_file_system_parse (chooser_entry->file_system,
 773                               chooser_entry->base_folder, text,
 774                               &folder_path, &file_part, NULL)) /* NULL-GError */
 775     {
 776       folder_path = gtk_file_path_copy (chooser_entry->base_folder);
 777       file_part = g_strdup ("");
 778       file_part_pos = -1;
 779     }
 780   else
 781     {
 782       file_part_len = strlen (file_part);
 783       total_len = strlen (text);
 784       if (total_len > file_part_len)
 785         file_part_pos = g_utf8_strlen (text, total_len - file_part_len);
 786       else
 787         file_part_pos = 0;
 788     }
 789
 790   if (chooser_entry->file_part)
 791     g_free (chooser_entry->file_part);
 792
 793   chooser_entry->file_part = file_part;
 794   chooser_entry->file_part_pos = file_part_pos;
 795
 796   gtk_file_chooser_entry_maybe_update_directory (chooser_entry, folder_path, file_part_pos == -1);
 797 }
 798
 799 static void
 800 clear_completion_callback (GtkFileChooserEntry *chooser_entry,
 801                            GParamSpec          *pspec)
 802 {
 803   if (chooser_entry->has_completion)
 804     {
 805       chooser_entry->has_completion = FALSE;
 806       gtk_file_chooser_entry_changed (GTK_EDITABLE (chooser_entry));
 807     }
 808 }
 809
 810 /**
 811  * _gtk_file_chooser_entry_new:
 812  * @eat_tabs: If %FALSE, allow focus navigation with the tab key.
 813  *
 814  * Creates a new #GtkFileChooserEntry object. #GtkFileChooserEntry
 815  * is an internal implementation widget for the GTK+ file chooser
 816  * which is an entry with completion with respect to a
 817  * #GtkFileSystem object.
 818  *
 819  * Return value: the newly created #GtkFileChooserEntry
 820  **/
 821 GtkWidget *
 822 _gtk_file_chooser_entry_new (gboolean eat_tabs)
 823 {
 824   GtkFileChooserEntry *chooser_entry;
 825
 826   chooser_entry = g_object_new (GTK_TYPE_FILE_CHOOSER_ENTRY, NULL);
 827   chooser_entry->eat_tabs = (eat_tabs != FALSE);
 828
 829   return GTK_WIDGET (chooser_entry);
 830 }
 831
 832 /**
 833  * _gtk_file_chooser_entry_set_file_system:
 834  * @chooser_entry: a #GtkFileChooser
 835  * @file_system: an object implementing #GtkFileSystem
 836  *
 837  * Sets the file system for @chooser_entry.
 838  **/
 839 void
 840 _gtk_file_chooser_entry_set_file_system (GtkFileChooserEntry *chooser_entry,
 841                                          GtkFileSystem       *file_system)
 842 {
 843   g_return_if_fail (GTK_IS_FILE_CHOOSER_ENTRY (chooser_entry));
 844   g_return_if_fail (GTK_IS_FILE_SYSTEM (file_system));
 845
 846   if (file_system != chooser_entry->file_system)
 847     {
 848       if (chooser_entry->file_system)
 849         g_object_unref (chooser_entry->file_system);
 850
 851       chooser_entry->file_system = g_object_ref (file_system);
 852     }
 853 }
 854
 855 /**
 856  * _gtk_file_chooser_entry_set_base_folder:
 857  * @chooser_entry: a #GtkFileChooserEntry
 858  * @path: path of a folder in the chooser entries current file system.
 859  *
 860  * Sets the folder with respect to which completions occur.
 861  **/
 862 void
 863 _gtk_file_chooser_entry_set_base_folder (GtkFileChooserEntry *chooser_entry,
 864                                          const GtkFilePath   *path)
 865 {
 866   if (chooser_entry->base_folder)
 867     gtk_file_path_free (chooser_entry->base_folder);
 868
 869   chooser_entry->base_folder = gtk_file_path_copy (path);
 870
 871   gtk_file_chooser_entry_changed (GTK_EDITABLE (chooser_entry));
 872   gtk_editable_select_region (GTK_EDITABLE (chooser_entry), 0, -1);
 873 }
 874
 875 /**
 876  * _gtk_file_chooser_entry_get_current_folder:
 877  * @chooser_entry: a #GtkFileChooserEntry
 878  *
 879  * Gets the current folder for the #GtkFileChooserEntry. If the
 880  * user has only entered a filename, this will be the base folder
 881  * (see _gtk_file_chooser_entry_set_base_folder()), but if the
 882  * user has entered a relative or absolute path, then it will
 883  * be different. If the user has entered a relative or absolute
 884  * path that doesn't point to a folder in the file system, it will
 885  * be %NULL.
 886  *
 887  * Return value: the path of current folder - this value is owned by the
 888  *  chooser entry and must not be modified or freed.
 889  **/
 890 const GtkFilePath *
 891 _gtk_file_chooser_entry_get_current_folder (GtkFileChooserEntry *chooser_entry)
 892 {
 893   if (chooser_entry->has_completion)
 894     {
 895       gtk_editable_set_position (GTK_EDITABLE (chooser_entry),
 896                                  GTK_ENTRY (chooser_entry)->text_length);
 897     }
 898   return chooser_entry->current_folder_path;
 899 }
 900
 901 /**
 902  * _gtk_file_chooser_entry_get_file_part:
 903  * @chooser_entry: a #GtkFileChooserEntry
 904  *
 905  * Gets the non-folder portion of whatever the user has entered
 906  * into the file selector. What is returned is a UTF-8 string,
 907  * and if a filename path is needed, gtk_file_system_make_path()
 908  * must be used
 909   *
 910  * Return value: the entered filename - this value is owned by the
 911  *  chooser entry and must not be modified or freed.
 912  **/
 913 const gchar *
 914 _gtk_file_chooser_entry_get_file_part (GtkFileChooserEntry *chooser_entry)
 915 {
 916   if (chooser_entry->has_completion)
 917     {
 918       gtk_editable_set_position (GTK_EDITABLE (chooser_entry),
 919                                  GTK_ENTRY (chooser_entry)->text_length);
 920     }
 921   return chooser_entry->file_part;
 922 }
 923
 924 /**
 925  * _gtk_file_chooser_entry_set_file_part:
 926  * @chooser_entry: a #GtkFileChooserEntry
 927  * @file_part: text to display in the entry, in UTF-8
 928  *
 929  * Sets the current text shown in the file chooser entry.
 930  **/
 931 void
 932 _gtk_file_chooser_entry_set_file_part (GtkFileChooserEntry *chooser_entry,
 933                                        const gchar         *file_part)
 934 {
 935   g_return_if_fail (GTK_IS_FILE_CHOOSER_ENTRY (chooser_entry));
 936
 937   gtk_entry_set_text (GTK_ENTRY (chooser_entry), file_part);
 938 }
 939
 940
 941 /**
 942  * _gtk_file_chooser_entry_set_action:
 943  * @chooser_entry: a #GtkFileChooserEntry
 944  * @action: the action which is performed by the file selector using this entry
 945  *
 946  * Sets action which is performed by the file selector using this entry.
 947  * The #GtkFileChooserEntry will use different completion strategies for
 948  * different actions.
 949  **/
 950 void
 951 _gtk_file_chooser_entry_set_action (GtkFileChooserEntry *chooser_entry,
 952                                     GtkFileChooserAction action)
 953 {
 954   g_return_if_fail (GTK_IS_FILE_CHOOSER_ENTRY (chooser_entry));
 955
 956   if (  chooser_entry->action != action)
 957     {
 958       chooser_entry->action = action;
 959     }
 960 }
 961
 962
 963 /**
 964  * _gtk_file_chooser_entry_get_action:
 965  * @chooser_entry: a #GtkFileChooserEntry
 966  *
 967  * Gets the action for this entry.
 968  *
 969  * Returns: the action
 970  **/
 971 GtkFileChooserAction
 972 _gtk_file_chooser_entry_get_action (GtkFileChooserEntry *chooser_entry)
 973 {
 974   g_return_val_if_fail (GTK_IS_FILE_CHOOSER_ENTRY (chooser_entry),
 975                         GTK_FILE_CHOOSER_ACTION_OPEN);
 976
 977   return chooser_entry->action;
 978 }