plugins/filebrowser.c

   1 /*
   2  *      filebrowser.c - this file is part of Geany, a fast and lightweight IDE
   3  *
   4  *      Copyright 2007-2012 Enrico Tröger <enrico(dot)troeger(at)uvena(dot)de>
   5  *      Copyright 2007-2012 Nick Treleaven <nick(dot)treleaven(at)btinternet(dot)com>
   6  *
   7  *      This program is free software; you can redistribute it and/or modify
   8  *      it under the terms of the GNU General Public License as published by
   9  *      the Free Software Foundation; either version 2 of the License, or
  10  *      (at your option) any later version.
  11  *
  12  *      This program is distributed in the hope that it will be useful,
  13  *      but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  *      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  *      GNU General Public License for more details.
  16  *
  17  *      You should have received a copy of the GNU General Public License along
  18  *      with this program; if not, write to the Free Software Foundation, Inc.,
  19  *      51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  20  */
  21
  22 /* Sidebar file browser plugin. */
  23
  24 #ifdef HAVE_CONFIG_H
  25 #       include "config.h"
  26 #endif
  27
  28 #include "geanyplugin.h"
  29 #include "gtkcompat.h"
  30 #include <string.h>
  31
  32 #include <gdk/gdkkeysyms.h>
  33
  34 #ifdef G_OS_WIN32
  35 # include <windows.h>
  36 #endif
  37
  38 GeanyPlugin *geany_plugin;
  39 GeanyData *geany_data;
  40 GeanyFunctions *geany_functions;
  41
  42
  43 PLUGIN_VERSION_CHECK(GEANY_API_VERSION)
  44
  45 PLUGIN_SET_INFO(_("File Browser"), _("Adds a file browser tab to the sidebar."), VERSION,
  46         _("The Geany developer team"))
  47
  48
  49 /* Keybinding(s) */
  50 enum
  51 {
  52         KB_FOCUS_FILE_LIST,
  53         KB_FOCUS_PATH_ENTRY,
  54         KB_COUNT
  55 };
  56
  57 PLUGIN_KEY_GROUP(file_browser, KB_COUNT)
  58
  59
  60 enum
  61 {
  62         FILEVIEW_COLUMN_ICON = 0,
  63         FILEVIEW_COLUMN_NAME,
  64         FILEVIEW_COLUMN_FILENAME, /* the full filename, including path for display as tooltip */
  65         FILEVIEW_N_COLUMNS
  66 };
  67
  68 static gboolean fb_set_project_base_path = FALSE;
  69 static gboolean fb_follow_path = FALSE;
  70 static gboolean show_hidden_files = FALSE;
  71 static gboolean hide_object_files = TRUE;
  72
  73 static GtkWidget *file_view_vbox;
  74 static GtkWidget *file_view;
  75 static GtkListStore *file_store;
  76 static GtkTreeIter *last_dir_iter = NULL;
  77 static GtkEntryCompletion *entry_completion = NULL;
  78
  79 static GtkWidget *filter_combo;
  80 static GtkWidget *filter_entry;
  81 static GtkWidget *path_combo;
  82 static GtkWidget *path_entry;
  83 static gchar *current_dir = NULL; /* in locale-encoding */
  84 static gchar *open_cmd; /* in locale-encoding */
  85 static gchar *config_file;
  86 static gchar **filter = NULL;
  87 static gchar *hidden_file_extensions = NULL;
  88
  89 static gint page_number = 0;
  90
  91 static struct
  92 {
  93         GtkWidget *open;
  94         GtkWidget *open_external;
  95         GtkWidget *find_in_files;
  96         GtkWidget *show_hidden_files;
  97 } popup_items;
  98
  99
 100 static void project_change_cb(GObject *obj, GKeyFile *config, gpointer data);
 101
 102 /* note: other callbacks connected in plugin_init */
 103 PluginCallback plugin_callbacks[] =
 104 {
 105         { "project-open", (GCallback) &project_change_cb, TRUE, NULL },
 106         { "project-save", (GCallback) &project_change_cb, TRUE, NULL },
 107         { NULL, NULL, FALSE, NULL }
 108 };
 109
 110
 111 #ifdef G_OS_WIN32
 112 static gboolean win32_check_hidden(const gchar *filename)
 113 {
 114         DWORD attrs;
 115         static wchar_t w_filename[MAX_PATH];
 116         MultiByteToWideChar(CP_UTF8, 0, filename, -1, w_filename, sizeof(w_filename));
 117         attrs = GetFileAttributesW(w_filename);
 118         if (attrs != INVALID_FILE_ATTRIBUTES && attrs & FILE_ATTRIBUTE_HIDDEN)
 119                 return TRUE;
 120         return FALSE;
 121 }
 122 #endif
 123
 124
 125 /* Returns: whether name should be hidden. */
 126 static gboolean check_hidden(const gchar *filename, const gchar *base_name)
 127 {
 128         gsize len;
 129
 130 #ifdef G_OS_WIN32
 131         if (win32_check_hidden(filename))
 132                 return TRUE;
 133 #else
 134         if (base_name[0] == '.')
 135                 return TRUE;
 136 #endif
 137
 138         len = strlen(base_name);
 139         return base_name[len - 1] == '~';
 140 }
 141
 142
 143 static gboolean check_object(const gchar *base_name)
 144 {
 145         gboolean ret = FALSE;
 146         gchar **ptr;
 147         gchar **exts = g_strsplit(hidden_file_extensions, " ", -1);
 148
 149         foreach_strv(ptr, exts)
 150         {
 151                 if (g_str_has_suffix(base_name, *ptr))
 152                 {
 153                         ret = TRUE;
 154                         break;
 155                 }
 156         }
 157         g_strfreev(exts);
 158         return ret;
 159 }
 160
 161
 162 /* Returns: whether filename should be removed. */
 163 static gboolean check_filtered(const gchar *base_name)
 164 {
 165         gchar **filter_item;
 166
 167         if (filter == NULL)
 168                 return FALSE;
 169
 170         foreach_strv(filter_item, filter)
 171         {
 172                 if (utils_str_equal(*filter_item, "*") || g_pattern_match_simple(*filter_item, base_name))
 173                 {
 174                         return FALSE;
 175                 }
 176         }
 177         return TRUE;
 178 }
 179
 180
 181 /* name is in locale encoding */
 182 static void add_item(const gchar *name)
 183 {
 184         GtkTreeIter iter;
 185         gchar *fname, *utf8_name, *utf8_fullname;
 186         const gchar *sep;
 187         gboolean dir;
 188
 189         if (G_UNLIKELY(EMPTY(name)))
 190                 return;
 191
 192         /* root directory doesn't need separator */
 193         sep = (utils_str_equal(current_dir, "/")) ? "" : G_DIR_SEPARATOR_S;
 194         fname = g_strconcat(current_dir, sep, name, NULL);
 195         dir = g_file_test(fname, G_FILE_TEST_IS_DIR);
 196         utf8_fullname = utils_get_locale_from_utf8(fname);
 197         utf8_name = utils_get_utf8_from_locale(name);
 198         g_free(fname);
 199
 200         if (! show_hidden_files && check_hidden(utf8_fullname, utf8_name))
 201                 goto done;
 202
 203         if (dir)
 204         {
 205                 if (last_dir_iter == NULL)
 206                         gtk_list_store_prepend(file_store, &iter);
 207                 else
 208                 {
 209                         gtk_list_store_insert_after(file_store, &iter, last_dir_iter);
 210                         gtk_tree_iter_free(last_dir_iter);
 211                 }
 212                 last_dir_iter = gtk_tree_iter_copy(&iter);
 213         }
 214         else
 215         {
 216                 if (! show_hidden_files && hide_object_files && check_object(utf8_name))
 217                         goto done;
 218                 if (check_filtered(utf8_name))
 219                         goto done;
 220
 221                 gtk_list_store_append(file_store, &iter);
 222         }
 223         gtk_list_store_set(file_store, &iter,
 224                 FILEVIEW_COLUMN_ICON, (dir) ? GTK_STOCK_DIRECTORY : GTK_STOCK_FILE,
 225                 FILEVIEW_COLUMN_NAME, utf8_name,
 226                 FILEVIEW_COLUMN_FILENAME, utf8_fullname,
 227                 -1);
 228 done:
 229         g_free(utf8_name);
 230         g_free(utf8_fullname);
 231 }
 232
 233
 234 /* adds ".." to the start of the file list */
 235 static void add_top_level_entry(void)
 236 {
 237         GtkTreeIter iter;
 238         gchar *utf8_dir;
 239
 240         if (EMPTY(g_path_skip_root(current_dir)))
 241                 return; /* ignore 'C:\' or '/' */
 242
 243         utf8_dir = g_path_get_dirname(current_dir);
 244         SETPTR(utf8_dir, utils_get_utf8_from_locale(utf8_dir));
 245
 246         gtk_list_store_prepend(file_store, &iter);
 247         last_dir_iter = gtk_tree_iter_copy(&iter);
 248
 249         gtk_list_store_set(file_store, &iter,
 250                 FILEVIEW_COLUMN_ICON, GTK_STOCK_DIRECTORY,
 251                 FILEVIEW_COLUMN_NAME, "..",
 252                 FILEVIEW_COLUMN_FILENAME, utf8_dir,
 253                 -1);
 254         g_free(utf8_dir);
 255 }
 256
 257
 258 static void clear(void)
 259 {
 260         gtk_list_store_clear(file_store);
 261
 262         /* reset the directory item pointer */
 263         if (last_dir_iter != NULL)
 264                 gtk_tree_iter_free(last_dir_iter);
 265         last_dir_iter = NULL;
 266 }
 267
 268
 269 /* recreate the tree model from current_dir. */
 270 static void refresh(void)
 271 {
 272         gchar *utf8_dir;
 273         GSList *list, *node;
 274
 275         /* don't clear when the new path doesn't exist */
 276         if (! g_file_test(current_dir, G_FILE_TEST_EXISTS))
 277                 return;
 278
 279         clear();
 280
 281         utf8_dir = utils_get_utf8_from_locale(current_dir);
 282         gtk_entry_set_text(GTK_ENTRY(path_entry), utf8_dir);
 283         gtk_widget_set_tooltip_text(path_entry, utf8_dir);
 284         ui_combo_box_add_to_history(GTK_COMBO_BOX_TEXT(path_combo), utf8_dir, 0);
 285         g_free(utf8_dir);
 286
 287         add_top_level_entry();  /* ".." item */
 288
 289         list = utils_get_file_list(current_dir, NULL, NULL);
 290         if (list != NULL)
 291         {
 292                 /* free filenames as we go through the list */
 293                 foreach_slist(node, list)
 294                 {
 295                         gchar *fname = node->data;
 296
 297                         add_item(fname);
 298                         g_free(fname);
 299                 }
 300                 g_slist_free(list);
 301         }
 302         gtk_entry_completion_set_model(entry_completion, GTK_TREE_MODEL(file_store));
 303 }
 304
 305
 306 static void on_go_home(void)
 307 {
 308         SETPTR(current_dir, g_strdup(g_get_home_dir()));
 309         refresh();
 310 }
 311
 312
 313 /* TODO: use utils_get_default_dir_utf8() */
 314 static gchar *get_default_dir(void)
 315 {
 316         const gchar *dir = NULL;
 317         GeanyProject *project = geany->app->project;
 318
 319         if (project)
 320                 dir = project->base_path;
 321         else
 322                 dir = geany->prefs->default_open_path;
 323
 324         if (!EMPTY(dir))
 325                 return utils_get_locale_from_utf8(dir);
 326
 327         return g_get_current_dir();
 328 }
 329
 330
 331 static void on_current_path(void)
 332 {
 333         gchar *fname;
 334         gchar *dir;
 335         GeanyDocument *doc = document_get_current();
 336
 337         if (doc == NULL || doc->file_name == NULL || ! g_path_is_absolute(doc->file_name))
 338         {
 339                 SETPTR(current_dir, get_default_dir());
 340                 refresh();
 341                 return;
 342         }
 343         fname = doc->file_name;
 344         fname = utils_get_locale_from_utf8(fname);
 345         dir = g_path_get_dirname(fname);
 346         g_free(fname);
 347
 348         SETPTR(current_dir, dir);
 349         refresh();
 350 }
 351
 352
 353 static void on_go_up(void)
 354 {
 355         gsize len = strlen(current_dir);
 356         if (current_dir[len-1] == G_DIR_SEPARATOR)
 357                 current_dir[len-1] = '\0';
 358         /* remove the highest directory part (which becomes the basename of current_dir) */
 359         SETPTR(current_dir, g_path_get_dirname(current_dir));
 360         refresh();
 361 }
 362
 363
 364 static gboolean check_single_selection(GtkTreeSelection *treesel)
 365 {
 366         if (gtk_tree_selection_count_selected_rows(treesel) == 1)
 367                 return TRUE;
 368
 369         ui_set_statusbar(FALSE, _("Too many items selected!"));
 370         return FALSE;
 371 }
 372
 373
 374 /* Returns: TRUE if at least one of selected_items is a folder. */
 375 static gboolean is_folder_selected(GList *selected_items)
 376 {
 377         GList *item;
 378         GtkTreeModel *model = GTK_TREE_MODEL(file_store);
 379         gboolean dir_found = FALSE;
 380
 381         for (item = selected_items; item != NULL; item = g_list_next(item))
 382         {
 383                 gchar *icon;
 384                 GtkTreeIter iter;
 385                 GtkTreePath *treepath;
 386
 387                 treepath = (GtkTreePath*) item->data;
 388                 gtk_tree_model_get_iter(model, &iter, treepath);
 389                 gtk_tree_model_get(model, &iter, FILEVIEW_COLUMN_ICON, &icon, -1);
 390
 391                 if (utils_str_equal(icon, GTK_STOCK_DIRECTORY))
 392                 {
 393                         dir_found = TRUE;
 394                         g_free(icon);
 395                         break;
 396                 }
 397                 g_free(icon);
 398         }
 399         return dir_found;
 400 }
 401
 402
 403 /* Returns: the full filename in locale encoding. */
 404 static gchar *get_tree_path_filename(GtkTreePath *treepath)
 405 {
 406         GtkTreeModel *model = GTK_TREE_MODEL(file_store);
 407         GtkTreeIter iter;
 408         gchar *name, *fname;
 409
 410         gtk_tree_model_get_iter(model, &iter, treepath);
 411         gtk_tree_model_get(model, &iter, FILEVIEW_COLUMN_FILENAME, &name, -1);
 412
 413         fname = utils_get_locale_from_utf8(name);
 414         g_free(name);
 415
 416         return fname;
 417 }
 418
 419
 420 static void open_external(const gchar *fname, gboolean dir_found)
 421 {
 422         gchar *cmd;
 423         gchar *locale_cmd;
 424         gchar *dir;
 425         GString *cmd_str = g_string_new(open_cmd);
 426         GError *error = NULL;
 427
 428         if (! dir_found)
 429                 dir = g_path_get_dirname(fname);
 430         else
 431                 dir = g_strdup(fname);
 432
 433         utils_string_replace_all(cmd_str, "%f", fname);
 434         utils_string_replace_all(cmd_str, "%d", dir);
 435
 436         cmd = g_string_free(cmd_str, FALSE);
 437         locale_cmd = utils_get_locale_from_utf8(cmd);
 438         if (! g_spawn_command_line_async(locale_cmd, &error))
 439         {
 440                 gchar *c = strchr(cmd, ' ');
 441
 442                 if (c != NULL)
 443                         *c = '\0';
 444                 ui_set_statusbar(TRUE,
 445                         _("Could not execute configured external command '%s' (%s)."),
 446                         cmd, error->message);
 447                 g_error_free(error);
 448         }
 449         g_free(locale_cmd);
 450         g_free(cmd);
 451         g_free(dir);
 452 }
 453
 454
 455 static void on_external_open(GtkMenuItem *menuitem, gpointer user_data)
 456 {
 457         GtkTreeSelection *treesel;
 458         GtkTreeModel *model;
 459         GList *list;
 460         gboolean dir_found;
 461
 462         treesel = gtk_tree_view_get_selection(GTK_TREE_VIEW(file_view));
 463
 464         list = gtk_tree_selection_get_selected_rows(treesel, &model);
 465         dir_found = is_folder_selected(list);
 466
 467         if (! dir_found || check_single_selection(treesel))
 468         {
 469                 GList *item;
 470
 471                 for (item = list; item != NULL; item = g_list_next(item))
 472                 {
 473                         GtkTreePath *treepath = item->data;
 474                         gchar *fname = get_tree_path_filename(treepath);
 475
 476                         open_external(fname, dir_found);
 477                         g_free(fname);
 478                 }
 479         }
 480
 481         g_list_foreach(list, (GFunc) gtk_tree_path_free, NULL);
 482         g_list_free(list);
 483 }
 484
 485
 486 /* We use document_open_files() as it's more efficient. */
 487 static void open_selected_files(GList *list, gboolean do_not_focus)
 488 {
 489         GSList *files = NULL;
 490         GList *item;
 491         GeanyDocument *doc;
 492
 493         for (item = list; item != NULL; item = g_list_next(item))
 494         {
 495                 GtkTreePath *treepath = item->data;
 496                 gchar *fname = get_tree_path_filename(treepath);
 497
 498                 files = g_slist_prepend(files, fname);
 499         }
 500         files = g_slist_reverse(files);
 501         document_open_files(files, FALSE, NULL, NULL);
 502         doc = document_get_current();
 503         if (doc != NULL && ! do_not_focus)
 504                 keybindings_send_command(GEANY_KEY_GROUP_FOCUS, GEANY_KEYS_FOCUS_EDITOR);
 505
 506         g_slist_foreach(files, (GFunc) g_free, NULL);   /* free filenames */
 507         g_slist_free(files);
 508 }
 509
 510
 511 static void open_folder(GtkTreePath *treepath)
 512 {
 513         gchar *fname = get_tree_path_filename(treepath);
 514
 515         SETPTR(current_dir, fname);
 516         refresh();
 517 }
 518
 519
 520 static void on_open_clicked(GtkMenuItem *menuitem, gpointer user_data)
 521 {
 522         GtkTreeSelection *treesel;
 523         GtkTreeModel *model;
 524         GList *list;
 525         gboolean dir_found;
 526
 527         treesel = gtk_tree_view_get_selection(GTK_TREE_VIEW(file_view));
 528
 529         list = gtk_tree_selection_get_selected_rows(treesel, &model);
 530         dir_found = is_folder_selected(list);
 531
 532         if (dir_found)
 533         {
 534                 if (check_single_selection(treesel))
 535                 {
 536                         GtkTreePath *treepath = list->data;     /* first selected item */
 537
 538                         open_folder(treepath);
 539                 }
 540         }
 541         else
 542                 open_selected_files(list, GPOINTER_TO_INT(user_data));
 543
 544         g_list_foreach(list, (GFunc) gtk_tree_path_free, NULL);
 545         g_list_free(list);
 546 }
 547
 548
 549 static void on_find_in_files(GtkMenuItem *menuitem, gpointer user_data)
 550 {
 551         GtkTreeSelection *treesel;
 552         GtkTreeModel *model;
 553         GList *list;
 554         gchar *dir;
 555         gboolean is_dir = FALSE;
 556
 557         treesel = gtk_tree_view_get_selection(GTK_TREE_VIEW(file_view));
 558         /* allow 0 or 1 selections */
 559         if (gtk_tree_selection_count_selected_rows(treesel) > 0 &&
 560                 ! check_single_selection(treesel))
 561                 return;
 562
 563         list = gtk_tree_selection_get_selected_rows(treesel, &model);
 564         is_dir = is_folder_selected(list);
 565
 566         if (is_dir)
 567         {
 568                 GtkTreePath *treepath = list->data;     /* first selected item */
 569
 570                 dir = get_tree_path_filename(treepath);
 571         }
 572         else
 573                 dir = g_strdup(current_dir);
 574
 575         g_list_foreach(list, (GFunc) gtk_tree_path_free, NULL);
 576         g_list_free(list);
 577
 578         SETPTR(dir, utils_get_utf8_from_locale(dir));
 579         search_show_find_in_files_dialog(dir);
 580         g_free(dir);
 581 }
 582
 583
 584 static void on_hidden_files_clicked(GtkCheckMenuItem *item)
 585 {
 586         show_hidden_files = gtk_check_menu_item_get_active(item);
 587         refresh();
 588 }
 589
 590
 591 static void on_hide_sidebar(void)
 592 {
 593         keybindings_send_command(GEANY_KEY_GROUP_VIEW, GEANY_KEYS_VIEW_SIDEBAR);
 594 }
 595
 596
 597 static void on_show_preferences(void)
 598 {
 599         plugin_show_configure(geany_plugin);
 600 }
 601
 602
 603 static GtkWidget *create_popup_menu(void)
 604 {
 605         GtkWidget *item, *menu;
 606
 607         menu = gtk_menu_new();
 608
 609         item = gtk_image_menu_item_new_from_stock(GTK_STOCK_OPEN, NULL);
 610         gtk_widget_show(item);
 611         gtk_container_add(GTK_CONTAINER(menu), item);
 612         g_signal_connect(item, "activate", G_CALLBACK(on_open_clicked), NULL);
 613         popup_items.open = item;
 614
 615         item = ui_image_menu_item_new(GTK_STOCK_OPEN, _("Open _Externally"));
 616         gtk_widget_show(item);
 617         gtk_container_add(GTK_CONTAINER(menu), item);
 618         g_signal_connect(item, "activate", G_CALLBACK(on_external_open), NULL);
 619         popup_items.open_external = item;
 620
 621         item = gtk_separator_menu_item_new();
 622         gtk_widget_show(item);
 623         gtk_container_add(GTK_CONTAINER(menu), item);
 624
 625         item = gtk_image_menu_item_new_from_stock(GTK_STOCK_REFRESH, NULL);
 626         gtk_widget_show(item);
 627         gtk_container_add(GTK_CONTAINER(menu), item);
 628         g_signal_connect(item, "activate", G_CALLBACK(refresh), NULL);
 629
 630         item = ui_image_menu_item_new(GTK_STOCK_FIND, _("_Find in Files..."));
 631         gtk_widget_show(item);
 632         gtk_container_add(GTK_CONTAINER(menu), item);
 633         g_signal_connect(item, "activate", G_CALLBACK(on_find_in_files), NULL);
 634         popup_items.find_in_files = item;
 635
 636         item = gtk_separator_menu_item_new();
 637         gtk_widget_show(item);
 638         gtk_container_add(GTK_CONTAINER(menu), item);
 639
 640         item = gtk_check_menu_item_new_with_mnemonic(_("Show _Hidden Files"));
 641         gtk_widget_show(item);
 642         gtk_container_add(GTK_CONTAINER(menu), item);
 643         g_signal_connect(item, "activate", G_CALLBACK(on_hidden_files_clicked), NULL);
 644         popup_items.show_hidden_files = item;
 645
 646         item = gtk_separator_menu_item_new();
 647         gtk_widget_show(item);
 648         gtk_container_add(GTK_CONTAINER(menu), item);
 649
 650         item = gtk_image_menu_item_new_from_stock(GTK_STOCK_PREFERENCES, NULL);
 651         gtk_widget_show(item);
 652         gtk_container_add(GTK_CONTAINER(menu), item);
 653         g_signal_connect(item, "activate", G_CALLBACK(on_show_preferences), NULL);
 654
 655         item = gtk_separator_menu_item_new();
 656         gtk_widget_show(item);
 657         gtk_container_add(GTK_CONTAINER(menu), item);
 658
 659         item = ui_image_menu_item_new(GTK_STOCK_CLOSE, _("H_ide Sidebar"));
 660         gtk_widget_show(item);
 661         gtk_container_add(GTK_CONTAINER(menu), item);
 662         g_signal_connect(item, "activate", G_CALLBACK(on_hide_sidebar), NULL);
 663
 664         return menu;
 665 }
 666
 667
 668 static void on_tree_selection_changed(GtkTreeSelection *selection, gpointer data)
 669 {
 670         gboolean have_sel = (gtk_tree_selection_count_selected_rows(selection) > 0);
 671         gboolean multi_sel = (gtk_tree_selection_count_selected_rows(selection) > 1);
 672
 673         if (popup_items.open != NULL)
 674                 gtk_widget_set_sensitive(popup_items.open, have_sel);
 675         if (popup_items.open_external != NULL)
 676                 gtk_widget_set_sensitive(popup_items.open_external, have_sel);
 677         if (popup_items.find_in_files != NULL)
 678                 gtk_widget_set_sensitive(popup_items.find_in_files, have_sel && ! multi_sel);
 679 }
 680
 681
 682 static gboolean on_button_press(GtkWidget *widget, GdkEventButton *event, gpointer user_data)
 683 {
 684         if (event->button == 1 && event->type == GDK_2BUTTON_PRESS)
 685         {
 686                 on_open_clicked(NULL, NULL);
 687                 return TRUE;
 688         }
 689         else if (event->button == 3)
 690         {
 691                 static GtkWidget *popup_menu = NULL;
 692
 693                 if (popup_menu == NULL)
 694                         popup_menu = create_popup_menu();
 695
 696                 gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(popup_items.show_hidden_files),
 697                         show_hidden_files);
 698                 gtk_menu_popup(GTK_MENU(popup_menu), NULL, NULL, NULL, NULL, event->button, event->time);
 699                 /* don't return TRUE here, unless the selection won't be changed */
 700         }
 701         return FALSE;
 702 }
 703
 704
 705 static gboolean on_key_press(GtkWidget *widget, GdkEventKey *event, gpointer data)
 706 {
 707         if (ui_is_keyval_enter_or_return(event->keyval))
 708         {
 709                 on_open_clicked(NULL, NULL);
 710                 return TRUE;
 711         }
 712
 713         if (event->keyval == GDK_space)
 714         {
 715                 on_open_clicked(NULL, GINT_TO_POINTER(TRUE));
 716                 return TRUE;
 717         }
 718
 719         if (( (event->keyval == GDK_Up || event->keyval == GDK_KP_Up) && (event->state & GDK_MOD1_MASK)) || /* FIXME: Alt-Up doesn't seem to work! */
 720                 (event->keyval == GDK_BackSpace) )
 721         {
 722                 on_go_up();
 723                 return TRUE;
 724         }
 725
 726         if ((event->keyval == GDK_F10 && event->state & GDK_SHIFT_MASK) || event->keyval == GDK_Menu)
 727         {
 728                 GdkEventButton button_event;
 729
 730                 button_event.time = event->time;
 731                 button_event.button = 3;
 732
 733                 on_button_press(widget, &button_event, data);
 734                 return TRUE;
 735         }
 736
 737         return FALSE;
 738 }
 739
 740
 741 static void clear_filter(void)
 742 {
 743         if (filter != NULL)
 744         {
 745                 g_strfreev(filter);
 746                 filter = NULL;
 747         }
 748 }
 749
 750
 751 static void on_clear_filter(GtkEntry *entry, gpointer user_data)
 752 {
 753         clear_filter();
 754
 755         gtk_entry_set_text(GTK_ENTRY(filter_entry), "");
 756
 757         refresh();
 758 }
 759
 760
 761 static void on_path_entry_activate(GtkEntry *entry, gpointer user_data)
 762 {
 763         gchar *new_dir = (gchar*) gtk_entry_get_text(entry);
 764
 765         if (!EMPTY(new_dir))
 766         {
 767                 if (g_str_has_suffix(new_dir, ".."))
 768                 {
 769                         on_go_up();
 770                         return;
 771                 }
 772                 else if (new_dir[0] == '~')
 773                 {
 774                         GString *str = g_string_new(new_dir);
 775                         utils_string_replace_first(str, "~", g_get_home_dir());
 776                         new_dir = g_string_free(str, FALSE);
 777                 }
 778                 else
 779                         new_dir = utils_get_locale_from_utf8(new_dir);
 780         }
 781         else
 782                 new_dir = g_strdup(g_get_home_dir());
 783
 784         SETPTR(current_dir, new_dir);
 785
 786         on_clear_filter(NULL, NULL);
 787 }
 788
 789
 790 static void ui_combo_box_changed(GtkComboBox *combo, gpointer user_data)
 791 {
 792         /* we get this callback on typing as well as choosing an item */
 793         if (gtk_combo_box_get_active(combo) >= 0)
 794                 gtk_widget_activate(gtk_bin_get_child(GTK_BIN(combo)));
 795 }
 796
 797
 798 static void on_filter_activate(GtkEntry *entry, gpointer user_data)
 799 {
 800         /* We use spaces for consistency with Find in Files file patterns
 801          * ';' also supported like original patch. */
 802         filter = g_strsplit_set(gtk_entry_get_text(entry), "; ", -1);
 803         if (filter == NULL || g_strv_length(filter) == 0)
 804         {
 805                 clear_filter();
 806         }
 807         ui_combo_box_add_to_history(GTK_COMBO_BOX_TEXT(filter_combo), NULL, 0);
 808         refresh();
 809 }
 810
 811
 812 static void on_filter_clear(GtkEntry *entry, gint icon_pos,
 813                                                         GdkEvent *event, gpointer data)
 814 {
 815         clear_filter();
 816         refresh();
 817 }
 818
 819
 820 static void prepare_file_view(void)
 821 {
 822         GtkCellRenderer *text_renderer, *icon_renderer;
 823         GtkTreeViewColumn *column;
 824         GtkTreeSelection *selection;
 825
 826         file_store = gtk_list_store_new(FILEVIEW_N_COLUMNS, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING);
 827
 828         gtk_tree_view_set_model(GTK_TREE_VIEW(file_view), GTK_TREE_MODEL(file_store));
 829         g_object_unref(file_store);
 830
 831         icon_renderer = gtk_cell_renderer_pixbuf_new();
 832         text_renderer = gtk_cell_renderer_text_new();
 833         column = gtk_tree_view_column_new();
 834         gtk_tree_view_column_pack_start(column, icon_renderer, FALSE);
 835         gtk_tree_view_column_set_attributes(column, icon_renderer, "stock-id", FILEVIEW_COLUMN_ICON, NULL);
 836         gtk_tree_view_column_pack_start(column, text_renderer, TRUE);
 837         gtk_tree_view_column_set_attributes(column, text_renderer, "text", FILEVIEW_COLUMN_NAME, NULL);
 838         gtk_tree_view_append_column(GTK_TREE_VIEW(file_view), column);
 839         gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(file_view), FALSE);
 840
 841         gtk_tree_view_set_enable_search(GTK_TREE_VIEW(file_view), TRUE);
 842         gtk_tree_view_set_search_column(GTK_TREE_VIEW(file_view), FILEVIEW_COLUMN_NAME);
 843
 844         ui_widget_modify_font_from_string(file_view, geany->interface_prefs->tagbar_font);
 845
 846         /* tooltips */
 847         gtk_tree_view_set_tooltip_column(GTK_TREE_VIEW(file_view), FILEVIEW_COLUMN_FILENAME);
 848
 849         /* selection handling */
 850         selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(file_view));
 851         gtk_tree_selection_set_mode(selection, GTK_SELECTION_MULTIPLE);
 852
 853         /* Show the current path when the FB is first needed */
 854         g_signal_connect(file_view, "realize", G_CALLBACK(on_current_path), NULL);
 855         g_signal_connect(selection, "changed", G_CALLBACK(on_tree_selection_changed), NULL);
 856         g_signal_connect(file_view, "button-press-event", G_CALLBACK(on_button_press), NULL);
 857         g_signal_connect(file_view, "key-press-event", G_CALLBACK(on_key_press), NULL);
 858 }
 859
 860
 861 static GtkWidget *make_toolbar(void)
 862 {
 863         GtkWidget *wid, *toolbar;
 864
 865         toolbar = gtk_toolbar_new();
 866         gtk_toolbar_set_icon_size(GTK_TOOLBAR(toolbar), GTK_ICON_SIZE_MENU);
 867         gtk_toolbar_set_style(GTK_TOOLBAR(toolbar), GTK_TOOLBAR_ICONS);
 868
 869         wid = GTK_WIDGET(gtk_tool_button_new_from_stock(GTK_STOCK_GO_UP));
 870         gtk_widget_set_tooltip_text(wid, _("Up"));
 871         g_signal_connect(wid, "clicked", G_CALLBACK(on_go_up), NULL);
 872         gtk_container_add(GTK_CONTAINER(toolbar), wid);
 873
 874         wid = GTK_WIDGET(gtk_tool_button_new_from_stock(GTK_STOCK_REFRESH));
 875         gtk_widget_set_tooltip_text(wid, _("Refresh"));
 876         g_signal_connect(wid, "clicked", G_CALLBACK(refresh), NULL);
 877         gtk_container_add(GTK_CONTAINER(toolbar), wid);
 878
 879         wid = GTK_WIDGET(gtk_tool_button_new_from_stock(GTK_STOCK_HOME));
 880         gtk_widget_set_tooltip_text(wid, _("Home"));
 881         g_signal_connect(wid, "clicked", G_CALLBACK(on_go_home), NULL);
 882         gtk_container_add(GTK_CONTAINER(toolbar), wid);
 883
 884         wid = GTK_WIDGET(gtk_tool_button_new_from_stock(GTK_STOCK_JUMP_TO));
 885         gtk_widget_set_tooltip_text(wid, _("Set path from document"));
 886         g_signal_connect(wid, "clicked", G_CALLBACK(on_current_path), NULL);
 887         gtk_container_add(GTK_CONTAINER(toolbar), wid);
 888
 889         return toolbar;
 890 }
 891
 892
 893 static GtkWidget *make_filterbar(void)
 894 {
 895         GtkWidget *label, *filterbar;
 896
 897         filterbar = gtk_hbox_new(FALSE, 1);
 898
 899         label = gtk_label_new(_("Filter:"));
 900
 901         filter_combo = gtk_combo_box_text_new_with_entry();
 902         filter_entry = gtk_bin_get_child(GTK_BIN(filter_combo));
 903
 904         ui_entry_add_clear_icon(GTK_ENTRY(filter_entry));
 905         g_signal_connect(filter_entry, "icon-release", G_CALLBACK(on_filter_clear), NULL);
 906
 907         gtk_widget_set_tooltip_text(filter_entry,
 908                 _("Filter your files with the usual wildcards. Separate multiple patterns with a space."));
 909         g_signal_connect(filter_entry, "activate", G_CALLBACK(on_filter_activate), NULL);
 910         g_signal_connect(filter_combo, "changed", G_CALLBACK(ui_combo_box_changed), NULL);
 911
 912         gtk_box_pack_start(GTK_BOX(filterbar), label, FALSE, FALSE, 0);
 913         gtk_box_pack_start(GTK_BOX(filterbar), filter_combo, TRUE, TRUE, 0);
 914
 915         return filterbar;
 916 }
 917
 918
 919 static gboolean completion_match_func(GtkEntryCompletion *completion, const gchar *key,
 920                                                                           GtkTreeIter *iter, gpointer user_data)
 921 {
 922         gchar *str, *icon;
 923         gboolean result = FALSE;
 924
 925         gtk_tree_model_get(GTK_TREE_MODEL(file_store), iter,
 926                 FILEVIEW_COLUMN_ICON, &icon, FILEVIEW_COLUMN_NAME, &str, -1);
 927
 928         if (str != NULL && icon != NULL && utils_str_equal(icon, GTK_STOCK_DIRECTORY) &&
 929                 ! g_str_has_suffix(key, G_DIR_SEPARATOR_S))
 930         {
 931                 /* key is something like "/tmp/te" and str is a filename like "test",
 932                  * so strip the path from key to make them comparable */
 933                 gchar *base_name = g_path_get_basename(key);
 934                 gchar *str_lowered = g_utf8_strdown(str, -1);
 935                 result = g_str_has_prefix(str_lowered, base_name);
 936                 g_free(base_name);
 937                 g_free(str_lowered);
 938         }
 939         g_free(str);
 940         g_free(icon);
 941
 942         return result;
 943 }
 944
 945
 946 static gboolean completion_match_selected(GtkEntryCompletion *widget, GtkTreeModel *model,
 947                                                                                   GtkTreeIter *iter, gpointer user_data)
 948 {
 949         gchar *str;
 950         gtk_tree_model_get(model, iter, FILEVIEW_COLUMN_NAME, &str, -1);
 951         if (str != NULL)
 952         {
 953                 gchar *text = g_strconcat(current_dir, G_DIR_SEPARATOR_S, str, NULL);
 954                 gtk_entry_set_text(GTK_ENTRY(path_entry), text);
 955                 gtk_editable_set_position(GTK_EDITABLE(path_entry), -1);
 956                 /* force change of directory when completion is done */
 957                 on_path_entry_activate(GTK_ENTRY(path_entry), NULL);
 958                 g_free(text);
 959         }
 960         g_free(str);
 961
 962         return TRUE;
 963 }
 964
 965
 966 static void completion_create(void)
 967 {
 968         entry_completion = gtk_entry_completion_new();
 969
 970         gtk_entry_completion_set_inline_completion(entry_completion, FALSE);
 971         gtk_entry_completion_set_popup_completion(entry_completion, TRUE);
 972         gtk_entry_completion_set_text_column(entry_completion, FILEVIEW_COLUMN_NAME);
 973         gtk_entry_completion_set_match_func(entry_completion, completion_match_func, NULL, NULL);
 974
 975         g_signal_connect(entry_completion, "match-selected",
 976                 G_CALLBACK(completion_match_selected), NULL);
 977
 978         gtk_entry_set_completion(GTK_ENTRY(path_entry), entry_completion);
 979 }
 980
 981
 982 static void load_settings(void)
 983 {
 984         GKeyFile *config = g_key_file_new();
 985
 986         config_file = g_strconcat(geany->app->configdir, G_DIR_SEPARATOR_S, "plugins", G_DIR_SEPARATOR_S,
 987                 "filebrowser", G_DIR_SEPARATOR_S, "filebrowser.conf", NULL);
 988         g_key_file_load_from_file(config, config_file, G_KEY_FILE_NONE, NULL);
 989
 990         open_cmd = utils_get_setting_string(config, "filebrowser", "open_command", "nautilus \"%d\"");
 991         /* g_key_file_get_boolean defaults to FALSE */
 992         show_hidden_files = g_key_file_get_boolean(config, "filebrowser", "show_hidden_files", NULL);
 993         hide_object_files = utils_get_setting_boolean(config, "filebrowser", "hide_object_files", TRUE);
 994         hidden_file_extensions = utils_get_setting_string(config, "filebrowser", "hidden_file_extensions",
 995                 ".o .obj .so .dll .a .lib .pyc");
 996         fb_follow_path = g_key_file_get_boolean(config, "filebrowser", "fb_follow_path", NULL);
 997         fb_set_project_base_path = g_key_file_get_boolean(config, "filebrowser", "fb_set_project_base_path", NULL);
 998
 999         g_key_file_free(config);
1000 }
1001
1002
1003 static void project_change_cb(G_GNUC_UNUSED GObject *obj, G_GNUC_UNUSED GKeyFile *config,
1004                                                           G_GNUC_UNUSED gpointer data)
1005 {
1006         gchar *new_dir;
1007         GeanyProject *project = geany->app->project;
1008
1009         if (! fb_set_project_base_path || project == NULL || EMPTY(project->base_path))
1010                 return;
1011
1012         /* TODO this is a copy of project_get_base_path(), add it to the plugin API */
1013         if (g_path_is_absolute(project->base_path))
1014                 new_dir = g_strdup(project->base_path);
1015         else
1016         {       /* build base_path out of project file name's dir and base_path */
1017                 gchar *dir = g_path_get_dirname(project->file_name);
1018
1019                 new_dir = g_strconcat(dir, G_DIR_SEPARATOR_S, project->base_path, NULL);
1020                 g_free(dir);
1021         }
1022         /* get it into locale encoding */
1023         SETPTR(new_dir, utils_get_locale_from_utf8(new_dir));
1024
1025         if (! utils_str_equal(current_dir, new_dir))
1026         {
1027                 SETPTR(current_dir, new_dir);
1028                 refresh();
1029         }
1030         else
1031                 g_free(new_dir);
1032 }
1033
1034
1035 static gpointer last_activate_path = NULL;
1036
1037 static void document_activate_cb(G_GNUC_UNUSED GObject *obj, GeanyDocument *doc,
1038                                                                  G_GNUC_UNUSED gpointer data)
1039 {
1040         gchar *new_dir;
1041
1042         last_activate_path = doc->real_path;
1043
1044         if (! fb_follow_path || doc->file_name == NULL || ! g_path_is_absolute(doc->file_name))
1045                 return;
1046
1047         new_dir = g_path_get_dirname(doc->file_name);
1048         SETPTR(new_dir, utils_get_locale_from_utf8(new_dir));
1049
1050         if (! utils_str_equal(current_dir, new_dir))
1051         {
1052                 SETPTR(current_dir, new_dir);
1053                 refresh();
1054         }
1055         else
1056                 g_free(new_dir);
1057 }
1058
1059
1060 static void document_save_cb(GObject *obj, GeanyDocument *doc, gpointer user_data)
1061 {
1062         if (!last_activate_path)
1063                 document_activate_cb(obj, doc, user_data);
1064 }
1065
1066
1067 static void kb_activate(guint key_id)
1068 {
1069         gtk_notebook_set_current_page(GTK_NOTEBOOK(geany->main_widgets->sidebar_notebook), page_number);
1070         switch (key_id)
1071         {
1072                 case KB_FOCUS_FILE_LIST:
1073                         gtk_widget_grab_focus(file_view);
1074                         break;
1075                 case KB_FOCUS_PATH_ENTRY:
1076                         gtk_widget_grab_focus(path_entry);
1077                         break;
1078         }
1079 }
1080
1081
1082 void plugin_init(GeanyData *data)
1083 {
1084         GtkWidget *scrollwin, *toolbar, *filterbar;
1085
1086         filter = NULL;
1087
1088         file_view_vbox = gtk_vbox_new(FALSE, 0);
1089         toolbar = make_toolbar();
1090         gtk_box_pack_start(GTK_BOX(file_view_vbox), toolbar, FALSE, FALSE, 0);
1091
1092         filterbar = make_filterbar();
1093         gtk_box_pack_start(GTK_BOX(file_view_vbox), filterbar, FALSE, FALSE, 0);
1094
1095         path_combo = gtk_combo_box_text_new_with_entry();
1096         gtk_box_pack_start(GTK_BOX(file_view_vbox), path_combo, FALSE, FALSE, 2);
1097         g_signal_connect(path_combo, "changed", G_CALLBACK(ui_combo_box_changed), NULL);
1098         path_entry = gtk_bin_get_child(GTK_BIN(path_combo));
1099         g_signal_connect(path_entry, "activate", G_CALLBACK(on_path_entry_activate), NULL);
1100
1101         file_view = gtk_tree_view_new();
1102         prepare_file_view();
1103         completion_create();
1104
1105         popup_items.open = popup_items.open_external = popup_items.find_in_files = NULL;
1106
1107         scrollwin = gtk_scrolled_window_new(NULL, NULL);
1108         gtk_scrolled_window_set_policy(
1109                 GTK_SCROLLED_WINDOW(scrollwin),
1110                 GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
1111         gtk_container_add(GTK_CONTAINER(scrollwin), file_view);
1112         gtk_box_pack_start(GTK_BOX(file_view_vbox), scrollwin, TRUE, TRUE, 0);
1113
1114         /* load settings before file_view "realize" callback */
1115         load_settings();
1116
1117         gtk_widget_show_all(file_view_vbox);
1118         page_number = gtk_notebook_append_page(GTK_NOTEBOOK(geany->main_widgets->sidebar_notebook),
1119                 file_view_vbox, gtk_label_new(_("Files")));
1120
1121         /* setup keybindings */
1122         keybindings_set_item(plugin_key_group, KB_FOCUS_FILE_LIST, kb_activate,
1123                 0, 0, "focus_file_list", _("Focus File List"), NULL);
1124         keybindings_set_item(plugin_key_group, KB_FOCUS_PATH_ENTRY, kb_activate,
1125                 0, 0, "focus_path_entry", _("Focus Path Entry"), NULL);
1126
1127         plugin_signal_connect(geany_plugin, NULL, "document-activate", TRUE,
1128                 (GCallback) &document_activate_cb, NULL);
1129         plugin_signal_connect(geany_plugin, NULL, "document-save", TRUE,
1130                 (GCallback) &document_save_cb, NULL);
1131 }
1132
1133
1134 static void save_settings(void)
1135 {
1136         GKeyFile *config = g_key_file_new();
1137         gchar *data;
1138         gchar *config_dir = g_path_get_dirname(config_file);
1139
1140         g_key_file_load_from_file(config, config_file, G_KEY_FILE_NONE, NULL);
1141
1142         g_key_file_set_string(config, "filebrowser", "open_command", open_cmd);
1143         g_key_file_set_boolean(config, "filebrowser", "show_hidden_files", show_hidden_files);
1144         g_key_file_set_boolean(config, "filebrowser", "hide_object_files", hide_object_files);
1145         g_key_file_set_string(config, "filebrowser", "hidden_file_extensions", hidden_file_extensions);
1146         g_key_file_set_boolean(config, "filebrowser", "fb_follow_path", fb_follow_path);
1147         g_key_file_set_boolean(config, "filebrowser", "fb_set_project_base_path",
1148                 fb_set_project_base_path);
1149
1150         if (! g_file_test(config_dir, G_FILE_TEST_IS_DIR) && utils_mkdir(config_dir, TRUE) != 0)
1151         {
1152                 dialogs_show_msgbox(GTK_MESSAGE_ERROR,
1153                         _("Plugin configuration directory could not be created."));
1154         }
1155         else
1156         {
1157                 /* write config to file */
1158                 data = g_key_file_to_data(config, NULL, NULL);
1159                 utils_write_file(config_file, data);
1160                 g_free(data);
1161         }
1162         g_free(config_dir);
1163         g_key_file_free(config);
1164 }
1165
1166
1167 static struct
1168 {
1169         GtkWidget *open_cmd_entry;
1170         GtkWidget *show_hidden_checkbox;
1171         GtkWidget *hide_objects_checkbox;
1172         GtkWidget *hidden_files_entry;
1173         GtkWidget *follow_path_checkbox;
1174         GtkWidget *set_project_base_path_checkbox;
1175 }
1176 pref_widgets;
1177
1178 static void
1179 on_configure_response(GtkDialog *dialog, gint response, gpointer user_data)
1180 {
1181         if (response == GTK_RESPONSE_OK || response == GTK_RESPONSE_APPLY)
1182         {
1183                 g_free(open_cmd);
1184                 open_cmd = g_strdup(gtk_entry_get_text(GTK_ENTRY(pref_widgets.open_cmd_entry)));
1185                 show_hidden_files = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(pref_widgets.show_hidden_checkbox));
1186                 hide_object_files = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(pref_widgets.hide_objects_checkbox));
1187                 g_free(hidden_file_extensions);
1188                 hidden_file_extensions = g_strdup(gtk_entry_get_text(GTK_ENTRY(pref_widgets.hidden_files_entry)));
1189                 fb_follow_path = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(pref_widgets.follow_path_checkbox));
1190                 fb_set_project_base_path = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(
1191                         pref_widgets.set_project_base_path_checkbox));
1192
1193                 /* apply the changes */
1194                 refresh();
1195         }
1196 }
1197
1198
1199 static void on_toggle_hidden(void)
1200 {
1201         gboolean enabled = !gtk_toggle_button_get_active(
1202                 GTK_TOGGLE_BUTTON(pref_widgets.show_hidden_checkbox));
1203
1204         gtk_widget_set_sensitive(pref_widgets.hide_objects_checkbox, enabled);
1205         enabled &= gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(pref_widgets.hide_objects_checkbox));
1206         gtk_widget_set_sensitive(pref_widgets.hidden_files_entry, enabled);
1207 }
1208
1209
1210 GtkWidget *plugin_configure(GtkDialog *dialog)
1211 {
1212         GtkWidget *label, *entry, *checkbox_of, *checkbox_hf, *checkbox_fp, *checkbox_pb, *vbox;
1213         GtkWidget *box, *align;
1214
1215         vbox = gtk_vbox_new(FALSE, 6);
1216         box = gtk_vbox_new(FALSE, 3);
1217
1218         label = gtk_label_new(_("External open command:"));
1219         gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5);
1220         gtk_box_pack_start(GTK_BOX(box), label, FALSE, FALSE, 0);
1221
1222         entry = gtk_entry_new();
1223         if (open_cmd != NULL)
1224                 gtk_entry_set_text(GTK_ENTRY(entry), open_cmd);
1225         gtk_widget_set_tooltip_text(entry,
1226                 _("The command to execute when using \"Open with\". You can use %f and %d wildcards.\n"
1227                   "%f will be replaced with the filename including full path\n"
1228                   "%d will be replaced with the path name of the selected file without the filename"));
1229         gtk_box_pack_start(GTK_BOX(box), entry, FALSE, FALSE, 0);
1230         pref_widgets.open_cmd_entry = entry;
1231
1232         gtk_box_pack_start(GTK_BOX(vbox), box, FALSE, FALSE, 3);
1233
1234         checkbox_hf = gtk_check_button_new_with_label(_("Show hidden files"));
1235         gtk_button_set_focus_on_click(GTK_BUTTON(checkbox_hf), FALSE);
1236         gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(checkbox_hf), show_hidden_files);
1237         gtk_box_pack_start(GTK_BOX(vbox), checkbox_hf, FALSE, FALSE, 0);
1238         pref_widgets.show_hidden_checkbox = checkbox_hf;
1239         g_signal_connect(checkbox_hf, "toggled", on_toggle_hidden, NULL);
1240
1241         box = gtk_vbox_new(FALSE, 3);
1242         checkbox_of = gtk_check_button_new_with_label(_("Hide file extensions:"));
1243         gtk_button_set_focus_on_click(GTK_BUTTON(checkbox_of), FALSE);
1244         gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(checkbox_of), hide_object_files);
1245         gtk_box_pack_start(GTK_BOX(box), checkbox_of, FALSE, FALSE, 0);
1246         pref_widgets.hide_objects_checkbox = checkbox_of;
1247         g_signal_connect(checkbox_of, "toggled", on_toggle_hidden, NULL);
1248
1249         entry = gtk_entry_new();
1250         if (hidden_file_extensions != NULL)
1251                 gtk_entry_set_text(GTK_ENTRY(entry), hidden_file_extensions);
1252         gtk_box_pack_start(GTK_BOX(box), entry, FALSE, FALSE, 0);
1253         pref_widgets.hidden_files_entry = entry;
1254
1255         align = gtk_alignment_new(1, 0.5, 1, 1);
1256         gtk_alignment_set_padding(GTK_ALIGNMENT(align), 0, 0, 12, 0);
1257         gtk_container_add(GTK_CONTAINER(align), box);
1258         gtk_box_pack_start(GTK_BOX(vbox), align, FALSE, FALSE, 0);
1259         on_toggle_hidden();
1260
1261         checkbox_fp = gtk_check_button_new_with_label(_("Follow the path of the current file"));
1262         gtk_button_set_focus_on_click(GTK_BUTTON(checkbox_fp), FALSE);
1263         gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(checkbox_fp), fb_follow_path);
1264         gtk_box_pack_start(GTK_BOX(vbox), checkbox_fp, FALSE, FALSE, 0);
1265         pref_widgets.follow_path_checkbox = checkbox_fp;
1266
1267         checkbox_pb = gtk_check_button_new_with_label(_("Use the project's base directory"));
1268         gtk_button_set_focus_on_click(GTK_BUTTON(checkbox_pb), FALSE);
1269         gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(checkbox_pb), fb_set_project_base_path);
1270         gtk_widget_set_tooltip_text(checkbox_pb,
1271                 _("Change the directory to the base directory of the currently opened project"));
1272         gtk_box_pack_start(GTK_BOX(vbox), checkbox_pb, FALSE, FALSE, 0);
1273         pref_widgets.set_project_base_path_checkbox = checkbox_pb;
1274
1275         gtk_widget_show_all(vbox);
1276
1277         g_signal_connect(dialog, "response", G_CALLBACK(on_configure_response), NULL);
1278         return vbox;
1279 }
1280
1281
1282 void plugin_cleanup(void)
1283 {
1284         save_settings();
1285
1286         g_free(config_file);
1287         g_free(open_cmd);
1288         g_free(hidden_file_extensions);
1289         clear_filter();
1290         gtk_widget_destroy(file_view_vbox);
1291         g_object_unref(G_OBJECT(entry_completion));
1292 }