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