plugins/filebrowser.c

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