ROX-Filer/src/minibuffer.c

   1 /*
   2  * $Id$
   3  *
   4  * ROX-Filer, filer for the ROX desktop project
   5  * Copyright (C) 1999, Thomas Leonard, <tal197@ecs.soton.ac.uk>.
   6  *
   7  * This program is free software; you can redistribute it and/or modify it
   8  * under the terms of the GNU General Public License as published by the Free
   9  * Software Foundation; either version 2 of the License, or (at your option)
  10  * any later version.
  11  *
  12  * This program is distributed in the hope that it will be useful, but WITHOUT
  13  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  14  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
  15  * more details.
  16  *
  17  * You should have received a copy of the GNU General Public License along with
  18  * this program; if not, write to the Free Software Foundation, Inc., 59 Temple
  19  * Place, Suite 330, Boston, MA  02111-1307  USA
  20  */
  21
  22 /* minibuffer.c - for handling the path entry box at the bottom */
  23
  24 #include <string.h>
  25
  26 #include <gtk/gtk.h>
  27 #include <gdk/gdkkeysyms.h>
  28
  29 #include "collection.h"
  30 #include "support.h"
  31 #include "minibuffer.h"
  32 #include "filer.h"
  33
  34 /* Static prototypes */
  35 static gint key_press_event(GtkWidget   *widget,
  36                         GdkEventKey     *event,
  37                         FilerWindow     *filer_window);
  38 static void changed(GtkEditable *mini, FilerWindow *filer_window);
  39 static void find_next_match(FilerWindow *filer_window, char *pattern, int dir);
  40 static gboolean matches(Collection *collection, int item, char *pattern);
  41 static void search_in_dir(FilerWindow *filer_window, int dir);
  42
  43
  44 /****************************************************************
  45  *                      EXTERNAL INTERFACE                      *
  46  ****************************************************************/
  47
  48
  49 GtkWidget *create_minibuffer(FilerWindow *filer_window)
  50 {
  51         GtkWidget *mini;
  52
  53         mini = gtk_entry_new();
  54         gtk_signal_connect(GTK_OBJECT(mini), "key_press_event",
  55                         GTK_SIGNAL_FUNC(key_press_event), filer_window);
  56         gtk_signal_connect(GTK_OBJECT(mini), "changed",
  57                         GTK_SIGNAL_FUNC(changed), filer_window);
  58
  59         return mini;
  60 }
  61
  62 void minibuffer_show(FilerWindow *filer_window)
  63 {
  64         Collection      *collection;
  65         GtkEntry        *mini;
  66
  67         g_return_if_fail(filer_window != NULL);
  68         g_return_if_fail(filer_window->minibuffer != NULL);
  69
  70         collection = filer_window->collection;
  71         filer_window->mini_cursor_base = MAX(collection->cursor_item, 0);
  72
  73         mini = GTK_ENTRY(filer_window->minibuffer);
  74
  75         gtk_entry_set_text(mini, make_path(filer_window->path, "")->str);
  76         gtk_entry_set_position(mini, -1);
  77
  78         gtk_widget_show(filer_window->minibuffer);
  79
  80         gtk_window_set_focus(GTK_WINDOW(filer_window->window),
  81                         filer_window->minibuffer);
  82 }
  83
  84 void minibuffer_hide(FilerWindow *filer_window)
  85 {
  86         gtk_widget_hide(filer_window->minibuffer);
  87         gtk_window_set_focus(GTK_WINDOW(filer_window->window),
  88                         GTK_WIDGET(filer_window->collection));
  89 }
  90
  91
  92 /****************************************************************
  93  *                      INTERNAL FUNCTIONS                      *
  94  ****************************************************************/
  95
  96 static void return_pressed(FilerWindow *filer_window, GdkEventKey *event)
  97 {
  98         Collection      *collection = filer_window->collection;
  99         int             item = collection->cursor_item;
 100         char            *path, *pattern;
 101         int             flags = OPEN_FROM_MINI | OPEN_SAME_WINDOW;
 102
 103         path = gtk_entry_get_text(GTK_ENTRY(filer_window->minibuffer));
 104         pattern = strrchr(path, '/');
 105         if (pattern)
 106                 pattern++;
 107         else
 108                 pattern = path;
 109
 110         if (item == -1 || !matches(collection, item, pattern))
 111         {
 112                 gdk_beep();
 113                 return;
 114         }
 115
 116         if ((event->state & GDK_SHIFT_MASK) != 0)
 117                 flags |= OPEN_SHIFT;
 118
 119         filer_openitem(filer_window, item, flags);
 120 }
 121
 122 /* Use the cursor item to fill in the minibuffer.
 123  * If there are multiple matches the fill in as much as possible and beep.
 124  */
 125 static void complete(FilerWindow *filer_window)
 126 {
 127         GtkEntry        *entry;
 128         Collection      *collection = filer_window->collection;
 129         int             cursor = collection->cursor_item;
 130         DirItem         *item;
 131         int             shortest_stem = -1;
 132         int             current_stem;
 133         int             other;
 134         guchar          *text, *leaf;
 135
 136         if (cursor < 0 || cursor >= collection->number_of_items)
 137         {
 138                 gdk_beep();
 139                 return;
 140         }
 141
 142         entry = GTK_ENTRY(filer_window->minibuffer);
 143
 144         item = (DirItem *) collection->items[cursor].data;
 145
 146         text = gtk_entry_get_text(entry);
 147         leaf = strrchr(text, '/');
 148         if (!leaf)
 149         {
 150                 gdk_beep();
 151                 return;
 152         }
 153
 154         leaf++;
 155         if (!matches(collection, cursor, leaf))
 156         {
 157                 gdk_beep();
 158                 return;
 159         }
 160
 161         current_stem = strlen(leaf);
 162
 163         /* Find the longest other match of this name. It it's longer than
 164          * the currently entered text then complete only up to that length.
 165          */
 166         for (other = 0; other < collection->number_of_items; other++)
 167         {
 168                 DirItem *other_item = (DirItem *) collection->items[other].data;
 169                 int     stem = 0;
 170
 171                 if (other == cursor)
 172                         continue;
 173
 174                 while (other_item->leafname[stem] && item->leafname[stem])
 175                 {
 176                         if (other_item->leafname[stem] != item->leafname[stem])
 177                                 break;
 178                         stem++;
 179                 }
 180
 181                 /* stem is the index of the first difference */
 182                 if (stem >= current_stem &&
 183                                 (shortest_stem == -1 || stem < shortest_stem))
 184                         shortest_stem = stem;
 185         }
 186
 187         if (current_stem == shortest_stem)
 188                 gdk_beep();
 189         else if (current_stem < shortest_stem)
 190         {
 191                 guchar  *extra;
 192
 193                 extra = g_strndup(item->leafname + current_stem,
 194                                 shortest_stem - current_stem);
 195                 gtk_entry_append_text(entry, extra);
 196                 g_free(extra);
 197                 gdk_beep();
 198         }
 199         else
 200         {
 201                 GString *new;
 202
 203                 new = make_path(filer_window->path, item->leafname);
 204
 205                 if (item->base_type == TYPE_DIRECTORY &&
 206                                 (item->flags & ITEM_FLAG_APPDIR) == 0)
 207                         g_string_append_c(new, '/');
 208
 209                 gtk_entry_set_text(entry, new->str);
 210         }
 211 }
 212
 213 static gint key_press_event(GtkWidget   *widget,
 214                         GdkEventKey     *event,
 215                         FilerWindow     *filer_window)
 216 {
 217         switch (event->keyval)
 218         {
 219                 case GDK_Escape:
 220                         minibuffer_hide(filer_window);
 221                         break;
 222                 case GDK_Up:
 223                         search_in_dir(filer_window, -1);
 224                         break;
 225                 case GDK_Down:
 226                         search_in_dir(filer_window, 1);
 227                         break;
 228                 case GDK_Return:
 229                         return_pressed(filer_window, event);
 230                         break;
 231                 case GDK_Tab:
 232                         complete(filer_window);
 233                         break;
 234                 default:
 235                         return FALSE;
 236         }
 237
 238         gtk_signal_emit_stop_by_name(GTK_OBJECT(widget), "key_press_event");
 239         return TRUE;
 240 }
 241
 242 static void changed(GtkEditable *mini, FilerWindow *filer_window)
 243 {
 244         char    *new, *slash;
 245         char    *path, *real;
 246
 247         new = gtk_entry_get_text(GTK_ENTRY(mini));
 248         if (*new == '/')
 249                 new = g_strdup(new);
 250         else
 251                 new = g_strdup_printf("/%s", new);
 252
 253         slash = strrchr(new, '/');
 254         *slash = '\0';
 255
 256         if (*new == '\0')
 257                 path = "/";
 258         else
 259                 path = new;
 260
 261         real = pathdup(path);
 262
 263         if (strcmp(real, filer_window->path) != 0)
 264         {
 265                 struct stat info;
 266                 if (stat(real, &info) == 0 && S_ISDIR(info.st_mode))
 267                         filer_change_to(filer_window, real, slash + 1);
 268                 else
 269                         gdk_beep();
 270         }
 271         else
 272         {
 273                 Collection      *collection = filer_window->collection;
 274                 int             item;
 275
 276                 find_next_match(filer_window, slash + 1, 0);
 277                 item = collection->cursor_item;
 278                 if (item != -1 && !matches(collection, item, slash + 1))
 279                         gdk_beep();
 280         }
 281
 282         g_free(real);
 283         g_free(new);
 284 }
 285
 286 /* Find the next item in the collection that matches 'pattern'. Start from
 287  * mini_cursor_base and loop at either end. dir is 1 for a forward search,
 288  * -1 for backwards. 0 means forwards, but may stay the same.
 289  *
 290  * Does not automatically update mini_cursor_base.
 291  */
 292 static void find_next_match(FilerWindow *filer_window, char *pattern, int dir)
 293 {
 294         Collection *collection = filer_window->collection;
 295         int        base = filer_window->mini_cursor_base;
 296         int        item = base;
 297
 298         if (collection->number_of_items < 1)
 299                 return;
 300
 301         if (base < 0 || base>= collection->number_of_items)
 302                 filer_window->mini_cursor_base = base = 0;
 303
 304         do
 305         {
 306                 /* Step to the next item */
 307                 item += dir;
 308
 309                 if (item >= collection->number_of_items)
 310                         item = 0;
 311                 else if (item < 0)
 312                         item = collection->number_of_items - 1;
 313
 314                 if (dir == 0)
 315                         dir = 1;
 316                 else if (item == base)
 317                         break;          /* No (other) matches at all */
 318
 319
 320         } while (!matches(collection, item, pattern));
 321
 322         collection_set_cursor_item(collection, item);
 323 }
 324
 325 static gboolean matches(Collection *collection, int item_number, char *pattern)
 326 {
 327         DirItem *item = (DirItem *) collection->items[item_number].data;
 328
 329         return strncmp(item->leafname, pattern, strlen(pattern)) == 0;
 330 }
 331
 332 /* Find next match and set base for future matches. */
 333 static void search_in_dir(FilerWindow *filer_window, int dir)
 334 {
 335         char    *path, *pattern;
 336
 337         path = gtk_entry_get_text(GTK_ENTRY(filer_window->minibuffer));
 338         pattern = strrchr(path, '/');
 339         if (pattern)
 340                 pattern++;
 341         else
 342                 pattern = path;
 343
 344         filer_window->mini_cursor_base = filer_window->collection->cursor_item;
 345         find_next_match(filer_window, pattern, dir);
 346         filer_window->mini_cursor_base = filer_window->collection->cursor_item;
 347 }