src/sidebar.c

   1 /*
   2  *      sidebar.c - this file is part of Geany, a fast and lightweight IDE
   3  *
   4  *      Copyright 2005 The Geany contributors
   5  *
   6  *      This program is free software; you can redistribute it and/or modify
   7  *      it under the terms of the GNU General Public License as published by
   8  *      the Free Software Foundation; either version 2 of the License, or
   9  *      (at your option) any later version.
  10  *
  11  *      This program is distributed in the hope that it will be useful,
  12  *      but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  *      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  *      GNU General Public License for more details.
  15  *
  16  *      You should have received a copy of the GNU General Public License along
  17  *      with this program; if not, write to the Free Software Foundation, Inc.,
  18  *      51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  19  */
  20
  21 /*
  22  * Sidebar related code for the Symbol list and Open files GtkTreeViews.
  23  */
  24
  25 #ifdef HAVE_CONFIG_H
  26 # include "config.h"
  27 #endif
  28
  29 #include "sidebar.h"
  30
  31 #include "app.h"
  32 #include "callbacks.h" /* FIXME: for ignore_callback */
  33 #include "documentprivate.h"
  34 #include "filetypesprivate.h"
  35 #include "geanyobject.h"
  36 #include "keyfile.h"
  37 #include "navqueue.h"
  38 #include "stash.h"
  39 #include "support.h"
  40 #include "symbols.h"
  41 #include "ui_utils.h"
  42 #include "utils.h"
  43 #include "keybindings.h"
  44
  45 #include <string.h>
  46
  47 #include <gdk/gdkkeysyms.h>
  48
  49
  50 SidebarTreeviews tv = {NULL, NULL, NULL};
  51 /* while typeahead searching, editor should not get focus */
  52 static gboolean may_steal_focus = FALSE;
  53
  54 static struct
  55 {
  56         GtkWidget *close;
  57         GtkWidget *save;
  58         GtkWidget *reload;
  59         GtkWidget *show_paths;
  60         GtkWidget *find_in_files;
  61         GtkWidget *expand_all;
  62         GtkWidget *collapse_all;
  63 }
  64 doc_items = {NULL, NULL, NULL, NULL, NULL, NULL, NULL};
  65
  66 enum
  67 {
  68         TREEVIEW_SYMBOL = 0,
  69         TREEVIEW_OPENFILES
  70 };
  71
  72 enum
  73 {
  74         OPENFILES_ACTION_REMOVE = 0,
  75         OPENFILES_ACTION_SAVE,
  76         OPENFILES_ACTION_RELOAD
  77 };
  78
  79 /* documents tree model columns */
  80 enum
  81 {
  82         DOCUMENTS_ICON,
  83         DOCUMENTS_SHORTNAME,    /* dirname for parents, basename for children */
  84         DOCUMENTS_DOCUMENT,
  85         DOCUMENTS_COLOR,
  86         DOCUMENTS_FILENAME              /* full filename */
  87 };
  88
  89 static GtkTreeStore     *store_openfiles;
  90 static GtkWidget *openfiles_popup_menu;
  91 static GtkWidget *tag_window;   /* scrolled window that holds the symbol list GtkTreeView */
  92
  93 /* callback prototypes */
  94 static void on_openfiles_document_action(GtkMenuItem *menuitem, gpointer user_data);
  95 static gboolean sidebar_button_press_cb(GtkWidget *widget, GdkEventButton *event,
  96                 gpointer user_data);
  97 static gboolean sidebar_key_press_cb(GtkWidget *widget, GdkEventKey *event,
  98                 gpointer user_data);
  99 static void on_list_document_activate(GtkCheckMenuItem *item, gpointer user_data);
 100 static void on_list_symbol_activate(GtkCheckMenuItem *item, gpointer user_data);
 101 static void documents_menu_update(GtkTreeSelection *selection);
 102 static void sidebar_tabs_show_hide(GtkNotebook *notebook, GtkWidget *child,
 103                                                                    guint page_num, gpointer data);
 104
 105
 106 /* the prepare_* functions are document-related, but I think they fit better here than in document.c */
 107 static void prepare_taglist(GtkWidget *tree, GtkTreeStore *store)
 108 {
 109         GtkCellRenderer *text_renderer, *icon_renderer;
 110         GtkTreeViewColumn *column;
 111         GtkTreeSelection *selection;
 112
 113         text_renderer = gtk_cell_renderer_text_new();
 114         icon_renderer = gtk_cell_renderer_pixbuf_new();
 115         column = gtk_tree_view_column_new();
 116
 117         gtk_tree_view_column_pack_start(column, icon_renderer, FALSE);
 118         gtk_tree_view_column_set_attributes(column, icon_renderer, "pixbuf", SYMBOLS_COLUMN_ICON, NULL);
 119         g_object_set(icon_renderer, "xalign", 0.0, NULL);
 120
 121         gtk_tree_view_column_pack_start(column, text_renderer, TRUE);
 122         gtk_tree_view_column_set_attributes(column, text_renderer, "text", SYMBOLS_COLUMN_NAME, NULL);
 123         g_object_set(text_renderer, "yalign", 0.5, NULL);
 124         gtk_tree_view_column_set_title(column, _("Symbols"));
 125
 126         gtk_tree_view_append_column(GTK_TREE_VIEW(tree), column);
 127         gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(tree), FALSE);
 128
 129         ui_widget_modify_font_from_string(tree, interface_prefs.tagbar_font);
 130
 131         gtk_tree_view_set_model(GTK_TREE_VIEW(tree), GTK_TREE_MODEL(store));
 132         g_object_unref(store);
 133
 134         g_signal_connect(tree, "button-press-event",
 135                 G_CALLBACK(sidebar_button_press_cb), NULL);
 136         g_signal_connect(tree, "key-press-event",
 137                 G_CALLBACK(sidebar_key_press_cb), NULL);
 138
 139         gtk_tree_view_set_show_expanders(GTK_TREE_VIEW(tree), interface_prefs.show_symbol_list_expanders);
 140         if (! interface_prefs.show_symbol_list_expanders)
 141                 gtk_tree_view_set_level_indentation(GTK_TREE_VIEW(tree), 10);
 142         /* Tooltips */
 143         ui_tree_view_set_tooltip_text_column(GTK_TREE_VIEW(tree), SYMBOLS_COLUMN_TOOLTIP);
 144
 145         /* selection handling */
 146         selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(tree));
 147         gtk_tree_selection_set_mode(selection, GTK_SELECTION_SINGLE);
 148         /* callback for changed selection not necessary, will be handled by button-press-event */
 149 }
 150
 151
 152 static gboolean
 153 on_default_tag_tree_button_press_event(GtkWidget *widget, GdkEventButton *event,
 154                 gpointer user_data)
 155 {
 156         if (event->button == 3)
 157         {
 158                 gtk_menu_popup(GTK_MENU(tv.popup_taglist), NULL, NULL, NULL, NULL,
 159                         event->button, event->time);
 160                 return TRUE;
 161         }
 162         return FALSE;
 163 }
 164
 165
 166 static void create_default_tag_tree(void)
 167 {
 168         GtkScrolledWindow *scrolled_window = GTK_SCROLLED_WINDOW(tag_window);
 169         GtkWidget *label;
 170
 171         /* default_tag_tree is a GtkViewPort with a GtkLabel inside it */
 172         tv.default_tag_tree = gtk_viewport_new(
 173                 gtk_scrolled_window_get_hadjustment(scrolled_window),
 174                 gtk_scrolled_window_get_vadjustment(scrolled_window));
 175         gtk_viewport_set_shadow_type(GTK_VIEWPORT(tv.default_tag_tree), GTK_SHADOW_NONE);
 176         label = gtk_label_new(_("No symbols found"));
 177         gtk_misc_set_alignment(GTK_MISC(label), 0.1f, 0.01f);
 178         gtk_container_add(GTK_CONTAINER(tv.default_tag_tree), label);
 179         gtk_widget_show_all(tv.default_tag_tree);
 180         g_signal_connect(tv.default_tag_tree, "button-press-event",
 181                 G_CALLBACK(on_default_tag_tree_button_press_event), NULL);
 182         g_object_ref((gpointer)tv.default_tag_tree);    /* to hold it after removing */
 183 }
 184
 185
 186 /* update = rescan the tags for doc->filename */
 187 void sidebar_update_tag_list(GeanyDocument *doc, gboolean update)
 188 {
 189         GtkWidget *child = gtk_bin_get_child(GTK_BIN(tag_window));
 190
 191         g_return_if_fail(doc == NULL || doc->is_valid);
 192
 193         if (update && doc != NULL)
 194                 doc->priv->tag_tree_dirty = TRUE;
 195
 196         if (gtk_notebook_get_current_page(GTK_NOTEBOOK(main_widgets.sidebar_notebook)) != TREEVIEW_SYMBOL)
 197                 return; /* don't bother updating symbol tree if we don't see it */
 198
 199         /* changes the tree view to the given one, trying not to do useless changes */
 200         #define CHANGE_TREE(new_child) \
 201                 G_STMT_START { \
 202                         /* only change the tag tree if it's actually not the same (to avoid flickering) and if
 203                          * it's the one of the current document (to avoid problems when e.g. reloading
 204                          * configuration files */ \
 205                         if (child != new_child && doc == document_get_current()) \
 206                         { \
 207                                 if (child) \
 208                                         gtk_container_remove(GTK_CONTAINER(tag_window), child); \
 209                                 gtk_container_add(GTK_CONTAINER(tag_window), new_child); \
 210                         } \
 211                 } G_STMT_END
 212
 213         if (tv.default_tag_tree == NULL)
 214                 create_default_tag_tree();
 215
 216         /* show default empty tag tree if there are no tags */
 217         if (doc == NULL || doc->file_type == NULL || ! filetype_has_tags(doc->file_type))
 218         {
 219                 CHANGE_TREE(tv.default_tag_tree);
 220                 return;
 221         }
 222
 223         if (doc->priv->tag_tree_dirty)
 224         {       /* updating the tag list in the left tag window */
 225                 if (doc->priv->tag_tree == NULL)
 226                 {
 227                         doc->priv->tag_store = gtk_tree_store_new(
 228                                 SYMBOLS_N_COLUMNS, GDK_TYPE_PIXBUF, G_TYPE_STRING, TM_TYPE_TAG, G_TYPE_STRING);
 229                         doc->priv->tag_tree = gtk_tree_view_new();
 230                         prepare_taglist(doc->priv->tag_tree, doc->priv->tag_store);
 231                         gtk_widget_show(doc->priv->tag_tree);
 232                         g_object_ref((gpointer)doc->priv->tag_tree);    /* to hold it after removing */
 233                 }
 234
 235                 doc->has_tags = symbols_recreate_tag_list(doc, SYMBOLS_SORT_USE_PREVIOUS);
 236                 doc->priv->tag_tree_dirty = FALSE;
 237         }
 238
 239         if (doc->has_tags)
 240         {
 241                 CHANGE_TREE(doc->priv->tag_tree);
 242         }
 243         else
 244         {
 245                 CHANGE_TREE(tv.default_tag_tree);
 246         }
 247
 248         #undef CHANGE_TREE
 249 }
 250
 251
 252 /* cleverly sorts documents by their short name */
 253 static gint documents_sort_func(GtkTreeModel *model, GtkTreeIter *iter_a,
 254                                                                 GtkTreeIter *iter_b, gpointer data)
 255 {
 256         gchar *key_a, *key_b;
 257         gchar *name_a, *name_b;
 258         gint cmp;
 259
 260         gtk_tree_model_get(model, iter_a, DOCUMENTS_SHORTNAME, &name_a, -1);
 261         key_a = g_utf8_collate_key_for_filename(name_a, -1);
 262         g_free(name_a);
 263         gtk_tree_model_get(model, iter_b, DOCUMENTS_SHORTNAME, &name_b, -1);
 264         key_b = g_utf8_collate_key_for_filename(name_b, -1);
 265         g_free(name_b);
 266         cmp = strcmp(key_a, key_b);
 267         g_free(key_b);
 268         g_free(key_a);
 269
 270         return cmp;
 271 }
 272
 273
 274 /* does some preparing things to the open files list widget */
 275 static void prepare_openfiles(void)
 276 {
 277         GtkCellRenderer *icon_renderer;
 278         GtkCellRenderer *text_renderer;
 279         GtkTreeViewColumn *column;
 280         GtkTreeSelection *selection;
 281         GtkTreeSortable *sortable;
 282
 283         tv.tree_openfiles = ui_lookup_widget(main_widgets.window, "treeview6");
 284
 285         /* store the icon and the short filename to show, and the index as reference,
 286          * the colour (black/red/green) and the full name for the tooltip */
 287         store_openfiles = gtk_tree_store_new(5, G_TYPE_ICON, G_TYPE_STRING,
 288                 G_TYPE_POINTER, GDK_TYPE_COLOR, G_TYPE_STRING);
 289         gtk_tree_view_set_model(GTK_TREE_VIEW(tv.tree_openfiles), GTK_TREE_MODEL(store_openfiles));
 290
 291         /* set policy settings for the scolledwindow around the treeview again, because glade
 292          * doesn't keep the settings */
 293         gtk_scrolled_window_set_policy(
 294                 GTK_SCROLLED_WINDOW(ui_lookup_widget(main_widgets.window, "scrolledwindow7")),
 295                 GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
 296
 297         icon_renderer = gtk_cell_renderer_pixbuf_new();
 298         g_object_set(icon_renderer, "stock-size", GTK_ICON_SIZE_MENU, NULL);
 299         text_renderer = gtk_cell_renderer_text_new();
 300         g_object_set(text_renderer, "ellipsize", PANGO_ELLIPSIZE_MIDDLE, NULL);
 301         column = gtk_tree_view_column_new();
 302         gtk_tree_view_column_pack_start(column, icon_renderer, FALSE);
 303         gtk_tree_view_column_set_attributes(column, icon_renderer, "gicon", DOCUMENTS_ICON, NULL);
 304         gtk_tree_view_column_pack_start(column, text_renderer, TRUE);
 305         gtk_tree_view_column_set_attributes(column, text_renderer, "text", DOCUMENTS_SHORTNAME,
 306                 "foreground-gdk", DOCUMENTS_COLOR, NULL);
 307         gtk_tree_view_append_column(GTK_TREE_VIEW(tv.tree_openfiles), column);
 308         gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(tv.tree_openfiles), FALSE);
 309
 310         gtk_tree_view_set_search_column(GTK_TREE_VIEW(tv.tree_openfiles),
 311                 DOCUMENTS_SHORTNAME);
 312
 313         /* sort opened filenames in the store_openfiles treeview */
 314         sortable = GTK_TREE_SORTABLE(GTK_TREE_MODEL(store_openfiles));
 315         gtk_tree_sortable_set_sort_func(sortable, DOCUMENTS_SHORTNAME, documents_sort_func, NULL, NULL);
 316         gtk_tree_sortable_set_sort_column_id(sortable, DOCUMENTS_SHORTNAME, GTK_SORT_ASCENDING);
 317
 318         ui_widget_modify_font_from_string(tv.tree_openfiles, interface_prefs.tagbar_font);
 319
 320         /* tooltips */
 321         ui_tree_view_set_tooltip_text_column(GTK_TREE_VIEW(tv.tree_openfiles), DOCUMENTS_FILENAME);
 322
 323         /* selection handling */
 324         selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(tv.tree_openfiles));
 325         gtk_tree_selection_set_mode(selection, GTK_SELECTION_SINGLE);
 326         g_object_unref(store_openfiles);
 327
 328         g_signal_connect(GTK_TREE_VIEW(tv.tree_openfiles), "button-press-event",
 329                 G_CALLBACK(sidebar_button_press_cb), NULL);
 330         g_signal_connect(GTK_TREE_VIEW(tv.tree_openfiles), "key-press-event",
 331                 G_CALLBACK(sidebar_key_press_cb), NULL);
 332 }
 333
 334
 335 /* iter should be toplevel */
 336 static gboolean find_tree_iter_dir(GtkTreeIter *iter, const gchar *dir)
 337 {
 338         GeanyDocument *doc;
 339         gchar *name;
 340         gboolean result;
 341
 342         if (utils_str_equal(dir, "."))
 343                 dir = GEANY_STRING_UNTITLED;
 344
 345         gtk_tree_model_get(GTK_TREE_MODEL(store_openfiles), iter, DOCUMENTS_DOCUMENT, &doc, -1);
 346         g_return_val_if_fail(!doc, FALSE);
 347
 348         gtk_tree_model_get(GTK_TREE_MODEL(store_openfiles), iter, DOCUMENTS_SHORTNAME, &name, -1);
 349
 350         result = utils_filenamecmp(name, dir) == 0;
 351         g_free(name);
 352
 353         return result;
 354 }
 355
 356
 357 static gboolean utils_filename_has_prefix(const gchar *str, const gchar *prefix)
 358 {
 359         gchar *head = g_strndup(str, strlen(prefix));
 360         gboolean ret = utils_filenamecmp(head, prefix) == 0;
 361
 362         g_free(head);
 363         return ret;
 364 }
 365
 366
 367 static gchar *get_doc_folder(const gchar *path)
 368 {
 369         gchar *tmp_dirname = g_strdup(path);
 370         gchar *project_base_path;
 371         gchar *dirname = NULL;
 372         const gchar *home_dir = g_get_home_dir();
 373         const gchar *rest;
 374
 375         /* replace the project base path with the project name */
 376         project_base_path = project_get_base_path();
 377
 378         if (project_base_path != NULL)
 379         {
 380                 gsize len = strlen(project_base_path);
 381
 382                 /* remove trailing separator so we can match base path exactly */
 383                 if (project_base_path[len-1] == G_DIR_SEPARATOR)
 384                         project_base_path[--len] = '\0';
 385
 386                 /* check whether the dir name matches or uses the project base path */
 387                 if (utils_filename_has_prefix(tmp_dirname, project_base_path))
 388                 {
 389                         rest = tmp_dirname + len;
 390                         if (*rest == G_DIR_SEPARATOR || *rest == '\0')
 391                         {
 392                                 dirname = g_strdup_printf("%s%s", app->project->name, rest);
 393                         }
 394                 }
 395                 g_free(project_base_path);
 396         }
 397         if (dirname == NULL)
 398         {
 399                 dirname = tmp_dirname;
 400
 401                 /* If matches home dir, replace with tilde */
 402                 if (!EMPTY(home_dir) && utils_filename_has_prefix(dirname, home_dir))
 403                 {
 404                         rest = dirname + strlen(home_dir);
 405                         if (*rest == G_DIR_SEPARATOR || *rest == '\0')
 406                         {
 407                                 dirname = g_strdup_printf("~%s", rest);
 408                                 g_free(tmp_dirname);
 409                         }
 410                 }
 411         }
 412         else
 413                 g_free(tmp_dirname);
 414
 415         return dirname;
 416 }
 417
 418
 419 static GtkTreeIter *get_doc_parent(GeanyDocument *doc)
 420 {
 421         gchar *path;
 422         gchar *dirname = NULL;
 423         static GtkTreeIter parent;
 424         GtkTreeModel *model = GTK_TREE_MODEL(store_openfiles);
 425         static GIcon *dir_icon = NULL;
 426
 427         if (!interface_prefs.documents_show_paths)
 428                 return NULL;
 429
 430         path = g_path_get_dirname(DOC_FILENAME(doc));
 431         dirname = get_doc_folder(path);
 432
 433         if (gtk_tree_model_get_iter_first(model, &parent))
 434         {
 435                 do
 436                 {
 437                         if (find_tree_iter_dir(&parent, dirname))
 438                         {
 439                                 g_free(dirname);
 440                                 g_free(path);
 441                                 return &parent;
 442                         }
 443                 }
 444                 while (gtk_tree_model_iter_next(model, &parent));
 445         }
 446         /* no match, add dir parent */
 447         if (!dir_icon)
 448                 dir_icon = ui_get_mime_icon("inode/directory");
 449
 450         gtk_tree_store_append(store_openfiles, &parent, NULL);
 451         gtk_tree_store_set(store_openfiles, &parent, DOCUMENTS_ICON, dir_icon,
 452                 DOCUMENTS_FILENAME, path,
 453                 DOCUMENTS_SHORTNAME, doc->file_name ? dirname : GEANY_STRING_UNTITLED, -1);
 454
 455         g_free(dirname);
 456         g_free(path);
 457         return &parent;
 458 }
 459
 460
 461 /* Also sets doc->priv->iter.
 462  * This is called recursively in sidebar_openfiles_update_all(). */
 463 void sidebar_openfiles_add(GeanyDocument *doc)
 464 {
 465         GtkTreeIter *iter = &doc->priv->iter;
 466         GtkTreeIter *parent = get_doc_parent(doc);
 467         gchar *basename;
 468         const GdkColor *color = document_get_status_color(doc);
 469         static GIcon *file_icon = NULL;
 470
 471         gtk_tree_store_append(store_openfiles, iter, parent);
 472
 473         /* check if new parent */
 474         if (parent && gtk_tree_model_iter_n_children(GTK_TREE_MODEL(store_openfiles), parent) == 1)
 475         {
 476                 GtkTreePath *path;
 477
 478                 /* expand parent */
 479                 path = gtk_tree_model_get_path(GTK_TREE_MODEL(store_openfiles), parent);
 480                 gtk_tree_view_expand_row(GTK_TREE_VIEW(tv.tree_openfiles), path, TRUE);
 481                 gtk_tree_path_free(path);
 482         }
 483         if (!file_icon)
 484                 file_icon = ui_get_mime_icon("text/plain");
 485
 486         basename = g_path_get_basename(DOC_FILENAME(doc));
 487         gtk_tree_store_set(store_openfiles, iter,
 488                 DOCUMENTS_ICON, (doc->file_type && doc->file_type->icon) ? doc->file_type->icon : file_icon,
 489                 DOCUMENTS_SHORTNAME, basename, DOCUMENTS_DOCUMENT, doc, DOCUMENTS_COLOR, color,
 490                 DOCUMENTS_FILENAME, DOC_FILENAME(doc), -1);
 491         g_free(basename);
 492 }
 493
 494
 495 static void openfiles_remove(GeanyDocument *doc)
 496 {
 497         GtkTreeIter *iter = &doc->priv->iter;
 498         GtkTreeIter parent;
 499
 500         if (gtk_tree_model_iter_parent(GTK_TREE_MODEL(store_openfiles), &parent, iter) &&
 501                 gtk_tree_model_iter_n_children(GTK_TREE_MODEL(store_openfiles), &parent) == 1)
 502                 gtk_tree_store_remove(store_openfiles, &parent);
 503         else
 504                 gtk_tree_store_remove(store_openfiles, iter);
 505 }
 506
 507
 508 void sidebar_openfiles_update(GeanyDocument *doc)
 509 {
 510         GtkTreeIter *iter = &doc->priv->iter;
 511         gchar *fname;
 512
 513         gtk_tree_model_get(GTK_TREE_MODEL(store_openfiles), iter, DOCUMENTS_FILENAME, &fname, -1);
 514
 515         if (utils_str_equal(fname, DOC_FILENAME(doc)))
 516         {
 517                 /* just update color and the icon */
 518                 const GdkColor *color = document_get_status_color(doc);
 519                 GIcon *icon = doc->file_type->icon;
 520
 521                 gtk_tree_store_set(store_openfiles, iter, DOCUMENTS_COLOR, color, -1);
 522                 if (icon)
 523                         gtk_tree_store_set(store_openfiles, iter, DOCUMENTS_ICON, icon, -1);
 524         }
 525         else
 526         {
 527                 /* path has changed, so remove and re-add */
 528                 GtkTreeSelection *treesel;
 529                 gboolean sel;
 530
 531                 treesel = gtk_tree_view_get_selection(GTK_TREE_VIEW(tv.tree_openfiles));
 532                 sel = gtk_tree_selection_iter_is_selected(treesel, &doc->priv->iter);
 533                 openfiles_remove(doc);
 534
 535                 sidebar_openfiles_add(doc);
 536                 if (sel)
 537                         gtk_tree_selection_select_iter(treesel, &doc->priv->iter);
 538         }
 539         g_free(fname);
 540 }
 541
 542
 543 void sidebar_openfiles_update_all(void)
 544 {
 545         guint i;
 546
 547         gtk_tree_store_clear(store_openfiles);
 548         foreach_document (i)
 549         {
 550                 sidebar_openfiles_add(documents[i]);
 551         }
 552 }
 553
 554
 555 void sidebar_remove_document(GeanyDocument *doc)
 556 {
 557         openfiles_remove(doc);
 558
 559         if (GTK_IS_WIDGET(doc->priv->tag_tree))
 560         {
 561                 gtk_widget_destroy(doc->priv->tag_tree); /* make GTK release its references, if any */
 562                 /* Because it was ref'd in sidebar_update_tag_list, it needs unref'ing */
 563                 g_object_unref(doc->priv->tag_tree);
 564                 doc->priv->tag_tree = NULL;
 565         }
 566 }
 567
 568
 569 static void on_hide_sidebar(void)
 570 {
 571         ui_prefs.sidebar_visible = FALSE;
 572         ui_sidebar_show_hide();
 573 }
 574
 575
 576 static gboolean on_sidebar_display_symbol_list_show(GtkWidget *item)
 577 {
 578         gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(item),
 579                 interface_prefs.sidebar_symbol_visible);
 580         return FALSE;
 581 }
 582
 583
 584 static gboolean on_sidebar_display_open_files_show(GtkWidget *item)
 585 {
 586         gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(item),
 587                 interface_prefs.sidebar_openfiles_visible);
 588         return FALSE;
 589 }
 590
 591
 592 void sidebar_add_common_menu_items(GtkMenu *menu)
 593 {
 594         GtkWidget *item;
 595
 596         item = gtk_separator_menu_item_new();
 597         gtk_widget_show(item);
 598         gtk_container_add(GTK_CONTAINER(menu), item);
 599
 600         item = gtk_check_menu_item_new_with_mnemonic(_("Show S_ymbol List"));
 601         gtk_container_add(GTK_CONTAINER(menu), item);
 602         g_signal_connect(item, "draw", G_CALLBACK(on_sidebar_display_symbol_list_show), NULL);
 603         gtk_widget_show(item);
 604         g_signal_connect(item, "activate",
 605                         G_CALLBACK(on_list_symbol_activate), NULL);
 606
 607         item = gtk_check_menu_item_new_with_mnemonic(_("Show _Document List"));
 608         gtk_container_add(GTK_CONTAINER(menu), item);
 609         g_signal_connect(item, "draw", G_CALLBACK(on_sidebar_display_open_files_show), NULL);
 610         gtk_widget_show(item);
 611         g_signal_connect(item, "activate",
 612                         G_CALLBACK(on_list_document_activate), NULL);
 613
 614         item = gtk_image_menu_item_new_with_mnemonic(_("H_ide Sidebar"));
 615         gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(item),
 616                 gtk_image_new_from_stock(GTK_STOCK_CLOSE, GTK_ICON_SIZE_MENU));
 617         gtk_widget_show(item);
 618         gtk_container_add(GTK_CONTAINER(menu), item);
 619         g_signal_connect(item, "activate", G_CALLBACK(on_hide_sidebar), NULL);
 620 }
 621
 622 static void on_openfiles_show_paths_activate(GtkCheckMenuItem *item, gpointer user_data)
 623 {
 624         interface_prefs.documents_show_paths = gtk_check_menu_item_get_active(item);
 625         sidebar_openfiles_update_all();
 626 }
 627
 628
 629 static void on_list_document_activate(GtkCheckMenuItem *item, gpointer user_data)
 630 {
 631         interface_prefs.sidebar_openfiles_visible = gtk_check_menu_item_get_active(item);
 632         ui_sidebar_show_hide();
 633         sidebar_tabs_show_hide(GTK_NOTEBOOK(main_widgets.sidebar_notebook), NULL, 0, NULL);
 634 }
 635
 636
 637 static void on_list_symbol_activate(GtkCheckMenuItem *item, gpointer user_data)
 638 {
 639         interface_prefs.sidebar_symbol_visible = gtk_check_menu_item_get_active(item);
 640         ui_sidebar_show_hide();
 641         sidebar_tabs_show_hide(GTK_NOTEBOOK(main_widgets.sidebar_notebook), NULL, 0, NULL);
 642 }
 643
 644
 645 static void on_find_in_files(GtkMenuItem *menuitem, gpointer user_data)
 646 {
 647         GtkTreeSelection *treesel;
 648         GtkTreeIter iter;
 649         GtkTreeModel *model;
 650         GeanyDocument *doc;
 651         gchar *dir;
 652
 653         treesel = gtk_tree_view_get_selection(GTK_TREE_VIEW(tv.tree_openfiles));
 654         if (!gtk_tree_selection_get_selected(treesel, &model, &iter))
 655                 return;
 656         gtk_tree_model_get(model, &iter, DOCUMENTS_DOCUMENT, &doc, -1);
 657
 658         if (!doc)
 659         {
 660                 gtk_tree_model_get(model, &iter, DOCUMENTS_FILENAME, &dir, -1);
 661         }
 662         else
 663                 dir = g_path_get_dirname(DOC_FILENAME(doc));
 664
 665         search_show_find_in_files_dialog(dir);
 666         g_free(dir);
 667 }
 668
 669
 670 static void on_openfiles_expand_collapse(GtkMenuItem *menuitem, gpointer user_data)
 671 {
 672         gboolean expand = GPOINTER_TO_INT(user_data);
 673
 674         if (expand)
 675                 gtk_tree_view_expand_all(GTK_TREE_VIEW(tv.tree_openfiles));
 676         else
 677                 gtk_tree_view_collapse_all(GTK_TREE_VIEW(tv.tree_openfiles));
 678 }
 679
 680
 681 static void create_openfiles_popup_menu(void)
 682 {
 683         GtkWidget *item;
 684
 685         openfiles_popup_menu = gtk_menu_new();
 686
 687         item = gtk_image_menu_item_new_from_stock(GTK_STOCK_CLOSE, NULL);
 688         gtk_widget_show(item);
 689         gtk_container_add(GTK_CONTAINER(openfiles_popup_menu), item);
 690         g_signal_connect(item, "activate",
 691                         G_CALLBACK(on_openfiles_document_action), GINT_TO_POINTER(OPENFILES_ACTION_REMOVE));
 692         doc_items.close = item;
 693
 694         item = gtk_separator_menu_item_new();
 695         gtk_widget_show(item);
 696         gtk_container_add(GTK_CONTAINER(openfiles_popup_menu), item);
 697
 698         item = gtk_image_menu_item_new_from_stock(GTK_STOCK_SAVE, NULL);
 699         gtk_widget_show(item);
 700         gtk_container_add(GTK_CONTAINER(openfiles_popup_menu), item);
 701         g_signal_connect(item, "activate",
 702                         G_CALLBACK(on_openfiles_document_action), GINT_TO_POINTER(OPENFILES_ACTION_SAVE));
 703         doc_items.save = item;
 704
 705         item = gtk_image_menu_item_new_with_mnemonic(_("_Reload"));
 706         gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(item),
 707                 gtk_image_new_from_stock(GTK_STOCK_REVERT_TO_SAVED, GTK_ICON_SIZE_MENU));
 708         gtk_widget_show(item);
 709         gtk_container_add(GTK_CONTAINER(openfiles_popup_menu), item);
 710         g_signal_connect(item, "activate",
 711                         G_CALLBACK(on_openfiles_document_action), GINT_TO_POINTER(OPENFILES_ACTION_RELOAD));
 712         doc_items.reload = item;
 713
 714         item = gtk_separator_menu_item_new();
 715         gtk_widget_show(item);
 716         gtk_container_add(GTK_CONTAINER(openfiles_popup_menu), item);
 717
 718         item = ui_image_menu_item_new(GTK_STOCK_FIND, _("_Find in Files..."));
 719         gtk_widget_show(item);
 720         gtk_container_add(GTK_CONTAINER(openfiles_popup_menu), item);
 721         g_signal_connect(item, "activate", G_CALLBACK(on_find_in_files), NULL);
 722         doc_items.find_in_files = item;
 723
 724         item = gtk_separator_menu_item_new();
 725         gtk_widget_show(item);
 726         gtk_container_add(GTK_CONTAINER(openfiles_popup_menu), item);
 727
 728         doc_items.show_paths = gtk_check_menu_item_new_with_mnemonic(_("Show _Paths"));
 729         gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(doc_items.show_paths), interface_prefs.documents_show_paths);
 730         gtk_widget_show(doc_items.show_paths);
 731         gtk_container_add(GTK_CONTAINER(openfiles_popup_menu), doc_items.show_paths);
 732         g_signal_connect(doc_items.show_paths, "activate",
 733                         G_CALLBACK(on_openfiles_show_paths_activate), NULL);
 734
 735         item = gtk_separator_menu_item_new();
 736         gtk_widget_show(item);
 737         gtk_container_add(GTK_CONTAINER(openfiles_popup_menu), item);
 738
 739         doc_items.expand_all = ui_image_menu_item_new(GTK_STOCK_ADD, _("_Expand All"));
 740         gtk_widget_show(doc_items.expand_all);
 741         gtk_container_add(GTK_CONTAINER(openfiles_popup_menu), doc_items.expand_all);
 742         g_signal_connect(doc_items.expand_all, "activate",
 743                                          G_CALLBACK(on_openfiles_expand_collapse), GINT_TO_POINTER(TRUE));
 744
 745         doc_items.collapse_all = ui_image_menu_item_new(GTK_STOCK_REMOVE, _("_Collapse All"));
 746         gtk_widget_show(doc_items.collapse_all);
 747         gtk_container_add(GTK_CONTAINER(openfiles_popup_menu), doc_items.collapse_all);
 748         g_signal_connect(doc_items.collapse_all, "activate",
 749                                          G_CALLBACK(on_openfiles_expand_collapse), GINT_TO_POINTER(FALSE));
 750
 751         sidebar_add_common_menu_items(GTK_MENU(openfiles_popup_menu));
 752 }
 753
 754
 755 static void unfold_parent(GtkTreeIter *iter)
 756 {
 757         GtkTreeIter parent;
 758
 759         if (gtk_tree_model_iter_parent(GTK_TREE_MODEL(store_openfiles), &parent, iter))
 760         {
 761                 GtkTreePath *path = gtk_tree_model_get_path(GTK_TREE_MODEL(store_openfiles), &parent);
 762                 gtk_tree_view_expand_row(GTK_TREE_VIEW(tv.tree_openfiles), path, TRUE);
 763                 gtk_tree_path_free(path);
 764         }
 765 }
 766
 767
 768 /* compares the given data with the doc pointer from the selected row of openfiles
 769  * treeview, in case of a match the row is selected and TRUE is returned
 770  * (called indirectly from gtk_tree_model_foreach()) */
 771 static gboolean tree_model_find_node(GtkTreeModel *model, GtkTreePath *path,
 772                 GtkTreeIter *iter, gpointer data)
 773 {
 774         GeanyDocument *doc;
 775
 776         gtk_tree_model_get(GTK_TREE_MODEL(store_openfiles), iter, DOCUMENTS_DOCUMENT, &doc, -1);
 777
 778         if (doc == data)
 779         {
 780                 /* unfolding also prevents a strange bug where the selection gets stuck on the parent
 781                  * when it is collapsed and then switching documents */
 782                 unfold_parent(iter);
 783                 gtk_tree_view_set_cursor(GTK_TREE_VIEW(tv.tree_openfiles), path, NULL, FALSE);
 784                 return TRUE;
 785         }
 786         else return FALSE;
 787 }
 788
 789
 790 void sidebar_select_openfiles_item(GeanyDocument *doc)
 791 {
 792         gtk_tree_model_foreach(GTK_TREE_MODEL(store_openfiles), tree_model_find_node, doc);
 793 }
 794
 795
 796 /* callbacks */
 797
 798 static void document_action(GeanyDocument *doc, gint action)
 799 {
 800         if (! DOC_VALID(doc))
 801                 return;
 802
 803         switch (action)
 804         {
 805                 case OPENFILES_ACTION_REMOVE:
 806                 {
 807                         document_close(doc);
 808                         break;
 809                 }
 810                 case OPENFILES_ACTION_SAVE:
 811                 {
 812                         document_save_file(doc, FALSE);
 813                         break;
 814                 }
 815                 case OPENFILES_ACTION_RELOAD:
 816                 {
 817                         document_reload_prompt(doc, NULL);
 818                         break;
 819                 }
 820         }
 821 }
 822
 823
 824 static void on_openfiles_document_action(GtkMenuItem *menuitem, gpointer user_data)
 825 {
 826         GtkTreeIter iter;
 827         GtkTreeSelection *selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(tv.tree_openfiles));
 828         GtkTreeModel *model;
 829         GeanyDocument *doc;
 830         gint action = GPOINTER_TO_INT(user_data);
 831
 832         if (gtk_tree_selection_get_selected(selection, &model, &iter))
 833         {
 834                 gtk_tree_model_get(model, &iter, DOCUMENTS_DOCUMENT, &doc, -1);
 835                 if (doc)
 836                 {
 837                         document_action(doc, action);
 838                 }
 839                 else
 840                 {
 841                         /* parent item selected */
 842                         GtkTreeIter child;
 843                         gint i = gtk_tree_model_iter_n_children(model, &iter) - 1;
 844
 845                         while (i >= 0 && gtk_tree_model_iter_nth_child(model, &child, &iter, i))
 846                         {
 847                                 gtk_tree_model_get(model, &child, DOCUMENTS_DOCUMENT, &doc, -1);
 848
 849                                 document_action(doc, action);
 850                                 i--;
 851                         }
 852                 }
 853         }
 854 }
 855
 856
 857 static void change_focus_to_editor(GeanyDocument *doc, GtkWidget *source_widget)
 858 {
 859         if (may_steal_focus)
 860                 document_try_focus(doc, source_widget);
 861         may_steal_focus = FALSE;
 862 }
 863
 864
 865 static gboolean openfiles_go_to_selection(GtkTreeSelection *selection, guint keyval)
 866 {
 867         GtkTreeIter iter;
 868         GtkTreeModel *model;
 869         GeanyDocument *doc = NULL;
 870
 871         /* use switch_notebook_page to ignore changing the notebook page because it is already done */
 872         if (gtk_tree_selection_get_selected(selection, &model, &iter) && ! ignore_callback)
 873         {
 874                 gtk_tree_model_get(model, &iter, DOCUMENTS_DOCUMENT, &doc, -1);
 875                 if (! doc)
 876                         return FALSE;   /* parent */
 877
 878                 /* switch to the doc and grab the focus */
 879                 document_show_tab(doc);
 880                 if (keyval != GDK_KEY_space)
 881                         change_focus_to_editor(doc, tv.tree_openfiles);
 882         }
 883         return FALSE;
 884 }
 885
 886
 887 static gboolean taglist_go_to_selection(GtkTreeSelection *selection, guint keyval, guint state)
 888 {
 889         GtkTreeIter iter;
 890         GtkTreeModel *model;
 891         gint line = 0;
 892         gboolean handled = TRUE;
 893
 894         if (gtk_tree_selection_get_selected(selection, &model, &iter))
 895         {
 896                 TMTag *tag;
 897
 898                 gtk_tree_model_get(model, &iter, SYMBOLS_COLUMN_TAG, &tag, -1);
 899                 if (! tag)
 900                         return FALSE;
 901
 902                 line = tag->line;
 903                 if (line > 0)
 904                 {
 905                         GeanyDocument *doc = document_get_current();
 906
 907                         if (doc != NULL)
 908                         {
 909                                 navqueue_goto_line(doc, doc, line);
 910                                 state = keybindings_get_modifiers(state);
 911                                 if (keyval != GDK_KEY_space && ! (state & GEANY_PRIMARY_MOD_MASK))
 912                                         change_focus_to_editor(doc, NULL);
 913                                 else
 914                                         handled = FALSE;
 915                         }
 916                 }
 917                 tm_tag_unref(tag);
 918         }
 919         return handled;
 920 }
 921
 922
 923 static gboolean sidebar_key_press_cb(GtkWidget *widget, GdkEventKey *event,
 924                                                                                          gpointer user_data)
 925 {
 926         may_steal_focus = FALSE;
 927         if (ui_is_keyval_enter_or_return(event->keyval) || event->keyval == GDK_KEY_space)
 928         {
 929                 GtkWidgetClass *widget_class = GTK_WIDGET_GET_CLASS(widget);
 930                 GtkTreeSelection *selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(widget));
 931                 may_steal_focus = TRUE;
 932
 933                 /* force the TreeView handler to run before us for it to do its job (selection & stuff).
 934                  * doing so will prevent further handlers to be run in most cases, but the only one is our
 935                  * own, so guess it's fine. */
 936                 if (widget_class->key_press_event)
 937                         widget_class->key_press_event(widget, event);
 938
 939                 if (widget == tv.tree_openfiles) /* tag and doc list have separate handlers */
 940                         openfiles_go_to_selection(selection, event->keyval);
 941                 else
 942                         taglist_go_to_selection(selection, event->keyval, event->state);
 943
 944                 return TRUE;
 945         }
 946         return FALSE;
 947 }
 948
 949
 950 static gboolean sidebar_button_press_cb(GtkWidget *widget, GdkEventButton *event,
 951                 G_GNUC_UNUSED gpointer user_data)
 952 {
 953         GtkTreeSelection *selection;
 954         GtkWidgetClass *widget_class = GTK_WIDGET_GET_CLASS(widget);
 955         gboolean handled = FALSE;
 956
 957         /* force the TreeView handler to run before us for it to do its job (selection & stuff).
 958          * doing so will prevent further handlers to be run in most cases, but the only one is our own,
 959          * so guess it's fine. */
 960         if (widget_class->button_press_event)
 961                 handled = widget_class->button_press_event(widget, event);
 962
 963         selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(widget));
 964         may_steal_focus = TRUE;
 965
 966         if (event->type == GDK_2BUTTON_PRESS)
 967         {       /* double click on parent node(section) expands/collapses it */
 968                 GtkTreeModel *model;
 969                 GtkTreeIter iter;
 970
 971                 if (gtk_tree_selection_get_selected(selection, &model, &iter))
 972                 {
 973                         if (gtk_tree_model_iter_has_child(model, &iter))
 974                         {
 975                                 GtkTreePath *path = gtk_tree_model_get_path(model, &iter);
 976
 977                                 if (gtk_tree_view_row_expanded(GTK_TREE_VIEW(widget), path))
 978                                         gtk_tree_view_collapse_row(GTK_TREE_VIEW(widget), path);
 979                                 else
 980                                         gtk_tree_view_expand_row(GTK_TREE_VIEW(widget), path, FALSE);
 981
 982                                 gtk_tree_path_free(path);
 983                                 return TRUE;
 984                         }
 985                 }
 986         }
 987         else if (event->button == 1)
 988         {       /* allow reclicking of taglist treeview item */
 989                 if (widget == tv.tree_openfiles)
 990                 {
 991                         openfiles_go_to_selection(selection, 0);
 992                         handled = TRUE;
 993                 }
 994                 else
 995                         handled = taglist_go_to_selection(selection, 0, event->state);
 996         }
 997         else if (event->button == 2)
 998         {
 999                 if (widget == tv.tree_openfiles)
1000                         on_openfiles_document_action(NULL, GINT_TO_POINTER(OPENFILES_ACTION_REMOVE));
1001         }
1002         else if (event->button == 3)
1003         {
1004                 if (widget == tv.tree_openfiles)
1005                 {
1006                         if (!openfiles_popup_menu)
1007                                 create_openfiles_popup_menu();
1008
1009                         /* update menu item sensitivity */
1010                         documents_menu_update(selection);
1011                         gtk_menu_popup(GTK_MENU(openfiles_popup_menu), NULL, NULL, NULL, NULL,
1012                                         event->button, event->time);
1013                 }
1014                 else
1015                 {
1016                         gtk_menu_popup(GTK_MENU(tv.popup_taglist), NULL, NULL, NULL, NULL,
1017                                         event->button, event->time);
1018                 }
1019                 handled = TRUE;
1020         }
1021         return handled;
1022 }
1023
1024
1025 static void documents_menu_update(GtkTreeSelection *selection)
1026 {
1027         GtkTreeModel *model;
1028         GtkTreeIter iter;
1029         gboolean sel, path;
1030         gchar *shortname = NULL;
1031         GeanyDocument *doc = NULL;
1032
1033         /* maybe no selection e.g. if ctrl-click deselected */
1034         sel = gtk_tree_selection_get_selected(selection, &model, &iter);
1035         if (sel)
1036         {
1037                 gtk_tree_model_get(model, &iter, DOCUMENTS_DOCUMENT, &doc,
1038                         DOCUMENTS_SHORTNAME, &shortname, -1);
1039         }
1040         path = !EMPTY(shortname) &&
1041                 (g_path_is_absolute(shortname) ||
1042                 (app->project && g_str_has_prefix(shortname, app->project->name)));
1043
1044         /* can close all, save all (except shortname), but only reload individually ATM */
1045         gtk_widget_set_sensitive(doc_items.close, sel);
1046         gtk_widget_set_sensitive(doc_items.save, (doc && doc->real_path) || path);
1047         gtk_widget_set_sensitive(doc_items.reload, doc && doc->real_path);
1048         gtk_widget_set_sensitive(doc_items.find_in_files, sel);
1049         g_free(shortname);
1050
1051         gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(doc_items.show_paths), interface_prefs.documents_show_paths);
1052         gtk_widget_set_sensitive(doc_items.expand_all, interface_prefs.documents_show_paths);
1053         gtk_widget_set_sensitive(doc_items.collapse_all, interface_prefs.documents_show_paths);
1054 }
1055
1056
1057 static StashGroup *stash_group = NULL;
1058
1059 static void on_load_settings(void)
1060 {
1061         tag_window = ui_lookup_widget(main_widgets.window, "scrolledwindow2");
1062
1063         prepare_openfiles();
1064         /* note: ui_prefs.sidebar_page is reapplied after plugins are loaded */
1065         stash_group_display(stash_group, NULL);
1066         sidebar_tabs_show_hide(GTK_NOTEBOOK(main_widgets.sidebar_notebook), NULL, 0, NULL);
1067 }
1068
1069
1070 static void on_save_settings(void)
1071 {
1072         stash_group_update(stash_group, NULL);
1073         sidebar_tabs_show_hide(GTK_NOTEBOOK(main_widgets.sidebar_notebook), NULL, 0, NULL);
1074 }
1075
1076
1077 static void on_sidebar_switch_page(GtkNotebook *notebook,
1078         gpointer page, guint page_num, gpointer user_data)
1079 {
1080         if (page_num == TREEVIEW_SYMBOL)
1081                 sidebar_update_tag_list(document_get_current(), FALSE);
1082 }
1083
1084
1085 void sidebar_init(void)
1086 {
1087         StashGroup *group;
1088
1089         group = stash_group_new(PACKAGE);
1090         stash_group_add_widget_property(group, &ui_prefs.sidebar_page, "sidebar_page", GINT_TO_POINTER(0),
1091                 main_widgets.sidebar_notebook, "page", 0);
1092         configuration_add_session_group(group, FALSE);
1093         stash_group = group;
1094
1095         /* delay building documents treeview until sidebar font has been read */
1096         g_signal_connect(geany_object, "load-settings", on_load_settings, NULL);
1097         g_signal_connect(geany_object, "save-settings", on_save_settings, NULL);
1098
1099         g_signal_connect(main_widgets.sidebar_notebook, "page-added",
1100                 G_CALLBACK(sidebar_tabs_show_hide), NULL);
1101         g_signal_connect(main_widgets.sidebar_notebook, "page-removed",
1102                 G_CALLBACK(sidebar_tabs_show_hide), NULL);
1103         /* tabs may have changed when sidebar is reshown */
1104         g_signal_connect(main_widgets.sidebar_notebook, "show",
1105                 G_CALLBACK(sidebar_tabs_show_hide), NULL);
1106         g_signal_connect_after(main_widgets.sidebar_notebook, "switch-page",
1107                 G_CALLBACK(on_sidebar_switch_page), NULL);
1108
1109         sidebar_tabs_show_hide(GTK_NOTEBOOK(main_widgets.sidebar_notebook), NULL, 0, NULL);
1110 }
1111
1112 #define WIDGET(w) w && GTK_IS_WIDGET(w)
1113
1114 void sidebar_finalize(void)
1115 {
1116         if (WIDGET(tv.default_tag_tree))
1117         {
1118                 gtk_widget_destroy(tv.default_tag_tree); /* make GTK release its references, if any... */
1119                 g_object_unref(tv.default_tag_tree); /* ...and release our own */
1120         }
1121         if (WIDGET(tv.popup_taglist))
1122                 gtk_widget_destroy(tv.popup_taglist);
1123         if (WIDGET(openfiles_popup_menu))
1124                 gtk_widget_destroy(openfiles_popup_menu);
1125 }
1126
1127
1128 void sidebar_focus_openfiles_tab(void)
1129 {
1130         if (ui_prefs.sidebar_visible && interface_prefs.sidebar_openfiles_visible)
1131         {
1132                 GtkNotebook *notebook = GTK_NOTEBOOK(main_widgets.sidebar_notebook);
1133
1134                 gtk_notebook_set_current_page(notebook, TREEVIEW_OPENFILES);
1135                 gtk_widget_grab_focus(tv.tree_openfiles);
1136         }
1137 }
1138
1139
1140 void sidebar_focus_symbols_tab(void)
1141 {
1142         if (ui_prefs.sidebar_visible && interface_prefs.sidebar_symbol_visible)
1143         {
1144                 GtkNotebook *notebook = GTK_NOTEBOOK(main_widgets.sidebar_notebook);
1145                 GtkWidget *symbol_list_scrollwin = gtk_notebook_get_nth_page(notebook, TREEVIEW_SYMBOL);
1146
1147                 gtk_notebook_set_current_page(notebook, TREEVIEW_SYMBOL);
1148                 gtk_widget_grab_focus(gtk_bin_get_child(GTK_BIN(symbol_list_scrollwin)));
1149         }
1150 }
1151
1152
1153 static void sidebar_tabs_show_hide(GtkNotebook *notebook, GtkWidget *child,
1154                                                                    guint page_num, gpointer data)
1155 {
1156         gint tabs = gtk_notebook_get_n_pages(notebook);
1157
1158         if (interface_prefs.sidebar_symbol_visible == FALSE)
1159                 tabs--;
1160         if (interface_prefs.sidebar_openfiles_visible == FALSE)
1161                 tabs--;
1162
1163         gtk_notebook_set_show_tabs(notebook, (tabs > 1));
1164 }