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