src/callbacks.c

   1 /*
   2  *      callbacks.c - this file is part of Geany, a fast and lightweight IDE
   3  *
   4  *      Copyright 2005-2012 Enrico Tröger <enrico(dot)troeger(at)uvena(dot)de>
   5  *      Copyright 2006-2012 Nick Treleaven <nick(dot)treleaven(at)btinternet(dot)com>
   6  *
   7  *      This program is free software; you can redistribute it and/or modify
   8  *      it under the terms of the GNU General Public License as published by
   9  *      the Free Software Foundation; either version 2 of the License, or
  10  *      (at your option) any later version.
  11  *
  12  *      This program is distributed in the hope that it will be useful,
  13  *      but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  *      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  *      GNU General Public License for more details.
  16  *
  17  *      You should have received a copy of the GNU General Public License along
  18  *      with this program; if not, write to the Free Software Foundation, Inc.,
  19  *      51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  20  */
  21
  22 /*
  23  * Callbacks used by Glade. These are mainly in response to menu item and button events in the
  24  * main window. Callbacks not used by Glade should go elsewhere.
  25  */
  26
  27 #ifdef HAVE_CONFIG_H
  28 # include "config.h"
  29 #endif
  30
  31 #include "callbacks.h"
  32
  33 #include "about.h"
  34 #include "app.h"
  35 #include "build.h"
  36 #include "dialogs.h"
  37 #include "documentprivate.h"
  38 #include "encodings.h"
  39 #include "filetypes.h"
  40 #include "geanyobject.h"
  41 #include "highlighting.h"
  42 #include "keybindings.h"
  43 #include "keyfile.h"
  44 #include "log.h"
  45 #include "main.h"
  46 #include "msgwindow.h"
  47 #include "navqueue.h"
  48 #include "plugins.h"
  49 #include "pluginutils.h"
  50 #include "prefs.h"
  51 #include "printing.h"
  52 #include "sciwrappers.h"
  53 #include "sidebar.h"
  54 #ifdef HAVE_SOCKET
  55 # include "socket.h"
  56 #endif
  57 #include "support.h"
  58 #include "symbols.h"
  59 #include "templates.h"
  60 #include "toolbar.h"
  61 #include "tools.h"
  62 #include "ui_utils.h"
  63 #include "utils.h"
  64 #include "vte.h"
  65
  66 #include "gtkcompat.h"
  67
  68 #include <stdlib.h>
  69 #include <unistd.h>
  70 #include <string.h>
  71 #include <gdk/gdkkeysyms.h>
  72 #include <glib/gstdio.h>
  73 #include <time.h>
  74
  75
  76 /* prototypes of Glade-only callback to let the compiler know they really are meant to be exported */
  77 G_MODULE_EXPORT gboolean on_window_delete_event(GtkWidget *widget, GdkEvent *event, gpointer gdata);
  78 G_MODULE_EXPORT void on_info1_activate(GtkMenuItem *menuitem, gpointer user_data);
  79 G_MODULE_EXPORT void on_change_font1_activate(GtkMenuItem *menuitem, gpointer user_data);
  80 G_MODULE_EXPORT void on_crlf_activate(GtkCheckMenuItem *menuitem, gpointer user_data);
  81 G_MODULE_EXPORT void on_lf_activate(GtkCheckMenuItem *menuitem, gpointer user_data);
  82 G_MODULE_EXPORT void on_cr_activate(GtkCheckMenuItem *menuitem, gpointer user_data);
  83 G_MODULE_EXPORT void on_hide_toolbar1_activate(GtkMenuItem *menuitem, gpointer user_data);
  84 G_MODULE_EXPORT void on_show_toolbar1_toggled(GtkCheckMenuItem *checkmenuitem, gpointer user_data);
  85 G_MODULE_EXPORT void on_fullscreen1_toggled(GtkCheckMenuItem *checkmenuitem, gpointer user_data);
  86 G_MODULE_EXPORT void on_markers_margin1_toggled(GtkCheckMenuItem *checkmenuitem, gpointer user_data);
  87 G_MODULE_EXPORT void on_show_messages_window1_toggled(GtkCheckMenuItem *checkmenuitem, gpointer user_data);
  88 G_MODULE_EXPORT void on_menu_color_schemes_activate(GtkImageMenuItem *imagemenuitem, gpointer user_data);
  89 G_MODULE_EXPORT void on_count_words1_activate(GtkMenuItem *menuitem, gpointer user_data);
  90 G_MODULE_EXPORT void on_edit1_activate(GtkMenuItem *menuitem, gpointer user_data);
  91 G_MODULE_EXPORT void on_website1_activate(GtkMenuItem *menuitem, gpointer user_data);
  92 G_MODULE_EXPORT void on_help_menu_item_donate_activate(GtkMenuItem *item, gpointer user_data);
  93 G_MODULE_EXPORT void on_help_menu_item_wiki_activate(GtkMenuItem *item, gpointer user_data);
  94 G_MODULE_EXPORT void on_help_menu_item_bug_report_activate(GtkMenuItem *item, gpointer user_data);
  95 G_MODULE_EXPORT void on_comments_function_activate(GtkMenuItem *menuitem, gpointer user_data);
  96 G_MODULE_EXPORT void on_comments_multiline_activate(GtkMenuItem *menuitem, gpointer user_data);
  97 G_MODULE_EXPORT void on_comments_changelog_activate(GtkMenuItem *menuitem, gpointer user_data);
  98 G_MODULE_EXPORT void on_comments_gpl_activate(GtkMenuItem *menuitem, gpointer user_data);
  99 G_MODULE_EXPORT void on_comments_fileheader_activate(GtkMenuItem *menuitem, gpointer user_data);
 100 G_MODULE_EXPORT void on_set_file_readonly1_toggled(GtkCheckMenuItem *checkmenuitem, gpointer user_data);
 101 G_MODULE_EXPORT void on_tv_notebook_switch_page(GtkNotebook *notebook, gpointer page, guint page_num, gpointer user_data);
 102 G_MODULE_EXPORT void on_help_shortcuts1_activate(GtkMenuItem *menuitem, gpointer user_data);
 103 G_MODULE_EXPORT void on_file_properties_activate(GtkMenuItem *menuitem, gpointer user_data);
 104 G_MODULE_EXPORT void on_show_line_numbers1_toggled(GtkCheckMenuItem *checkmenuitem, gpointer user_data);
 105 G_MODULE_EXPORT void on_use_auto_indentation1_toggled(GtkCheckMenuItem *checkmenuitem, gpointer user_data);
 106 G_MODULE_EXPORT void on_menu_fold_all1_activate(GtkMenuItem *menuitem, gpointer user_data);
 107 G_MODULE_EXPORT void on_menu_unfold_all1_activate(GtkMenuItem *menuitem, gpointer user_data);
 108 G_MODULE_EXPORT void on_notebook1_switch_page_after(GtkNotebook *notebook, gpointer page, guint page_num, gpointer user_data);
 109 G_MODULE_EXPORT void on_menu_write_unicode_bom1_toggled(GtkCheckMenuItem *checkmenuitem, gpointer user_data);
 110 G_MODULE_EXPORT void on_menu_comments_multiline_activate(GtkMenuItem *menuitem, gpointer user_data);
 111 G_MODULE_EXPORT void on_menu_comments_gpl_activate(GtkMenuItem *menuitem, gpointer user_data);
 112 G_MODULE_EXPORT void on_menu_comments_bsd_activate(GtkMenuItem *menuitem, gpointer user_data);
 113 G_MODULE_EXPORT void on_comments_bsd_activate(GtkMenuItem *menuitem, gpointer user_data);
 114 G_MODULE_EXPORT void on_menu_project1_activate(GtkMenuItem *menuitem, gpointer user_data);
 115 G_MODULE_EXPORT void on_load_tags1_activate(GtkMenuItem *menuitem, gpointer user_data);
 116 G_MODULE_EXPORT void on_file1_activate(GtkMenuItem *menuitem, gpointer user_data);
 117 G_MODULE_EXPORT void on_tv_notebook_switch_page_after(GtkNotebook *notebook, gpointer page, guint page_num, gpointer user_data);
 118 G_MODULE_EXPORT void on_tabs1_activate(GtkCheckMenuItem *menuitem, gpointer user_data);
 119 G_MODULE_EXPORT void on_spaces1_activate(GtkCheckMenuItem *menuitem, gpointer user_data);
 120 G_MODULE_EXPORT void on_strip_trailing_spaces1_activate(GtkMenuItem *menuitem, gpointer user_data);
 121 G_MODULE_EXPORT void on_page_setup1_activate(GtkMenuItem *menuitem, gpointer user_data);
 122 G_MODULE_EXPORT void on_search1_activate(GtkMenuItem *menuitem, gpointer user_data);
 123 G_MODULE_EXPORT void on_menu_reload_configuration1_activate(GtkMenuItem *menuitem, gpointer user_data);
 124 G_MODULE_EXPORT void on_tabs_and_spaces1_activate(GtkCheckMenuItem *menuitem, gpointer user_data);
 125 G_MODULE_EXPORT void on_debug_messages1_activate(GtkMenuItem *menuitem, gpointer user_data);
 126 G_MODULE_EXPORT void on_menu_show_white_space1_toggled(GtkCheckMenuItem *checkmenuitem, gpointer user_data);
 127 G_MODULE_EXPORT void on_menu_show_line_endings1_toggled(GtkCheckMenuItem *checkmenuitem, gpointer user_data);
 128 G_MODULE_EXPORT void on_menu_show_indentation_guides1_toggled(GtkCheckMenuItem *checkmenuitem, gpointer user_data);
 129 G_MODULE_EXPORT gboolean on_window_state_event(GtkWidget *widget, GdkEventWindowState *event, gpointer user_data);
 130 G_MODULE_EXPORT void on_customize_toolbar1_activate(GtkMenuItem *menuitem, gpointer user_data);
 131 G_MODULE_EXPORT void on_button_customize_toolbar_clicked(GtkButton *button, gpointer user_data);
 132 G_MODULE_EXPORT void on_cut_current_lines1_activate(GtkMenuItem *menuitem, gpointer user_data);
 133 G_MODULE_EXPORT void on_copy_current_lines1_activate(GtkMenuItem *menuitem, gpointer user_data);
 134 G_MODULE_EXPORT void on_delete_current_lines1_activate(GtkMenuItem *menuitem, gpointer user_data);
 135 G_MODULE_EXPORT void on_duplicate_line_or_selection1_activate(GtkMenuItem *menuitem, gpointer user_data);
 136 G_MODULE_EXPORT void on_select_current_lines1_activate(GtkMenuItem *menuitem, gpointer user_data);
 137 G_MODULE_EXPORT void on_select_current_paragraph1_activate(GtkMenuItem *menuitem, gpointer user_data);
 138 G_MODULE_EXPORT void on_insert_alternative_white_space1_activate(GtkMenuItem *menuitem, gpointer user_data);
 139 G_MODULE_EXPORT void on_go_to_next_marker1_activate(GtkMenuItem *menuitem, gpointer user_data);
 140 G_MODULE_EXPORT void on_go_to_previous_marker1_activate(GtkMenuItem *menuitem, gpointer user_data);
 141 G_MODULE_EXPORT void on_reflow_lines_block1_activate(GtkMenuItem *menuitem, gpointer user_data);
 142 G_MODULE_EXPORT void on_smart_line_indent1_activate(GtkMenuItem *menuitem, gpointer user_data);
 143 G_MODULE_EXPORT void on_move_lines_up1_activate(GtkMenuItem *menuitem, gpointer user_data);
 144 G_MODULE_EXPORT void on_move_lines_down1_activate(GtkMenuItem *menuitem, gpointer user_data);
 145 G_MODULE_EXPORT void on_goto_tag_definition1(GtkMenuItem *menuitem, gpointer user_data);
 146 G_MODULE_EXPORT void on_goto_tag_declaration1(GtkMenuItem *menuitem, gpointer user_data);
 147 G_MODULE_EXPORT void on_indent_width_activate(GtkMenuItem *menuitem, gpointer user_data);
 148 G_MODULE_EXPORT void on_reset_indentation1_activate(GtkMenuItem *menuitem, gpointer user_data);
 149 G_MODULE_EXPORT void on_mark_all1_activate(GtkMenuItem *menuitem, gpointer user_data);
 150 G_MODULE_EXPORT void on_detect_type_from_file_activate(GtkMenuItem *menuitem, gpointer user_data);
 151 G_MODULE_EXPORT void on_detect_width_from_file_activate(GtkMenuItem *menuitem, gpointer user_data);
 152 G_MODULE_EXPORT void on_clone1_activate(GtkMenuItem *menuitem, gpointer user_data);
 153
 154
 155 /* flag to indicate that an insert callback was triggered from the file menu,
 156  * so we need to store the current cursor position in editor_info.click_pos. */
 157 static gboolean insert_callback_from_menu = FALSE;
 158
 159 /* represents the state at switching a notebook page(in the left treeviews widget), to not emit
 160  * the selection-changed signal from tv.tree_openfiles */
 161 /*static gboolean switch_tv_notebook_page = FALSE; */
 162
 163
 164 static gboolean check_no_unsaved(void)
 165 {
 166         guint i;
 167
 168         for (i = 0; i < documents_array->len; i++)
 169         {
 170                 if (documents[i]->is_valid && documents[i]->changed)
 171                 {
 172                         return FALSE;
 173                 }
 174         }
 175         return TRUE;    /* no unsaved edits */
 176 }
 177
 178
 179 /* set editor_info.click_pos to the current cursor position if insert_callback_from_menu is TRUE
 180  * to prevent invalid cursor positions which can cause segfaults */
 181 static void verify_click_pos(GeanyDocument *doc)
 182 {
 183         if (insert_callback_from_menu)
 184         {
 185                 editor_info.click_pos = sci_get_current_position(doc->editor->sci);
 186                 insert_callback_from_menu = FALSE;
 187         }
 188 }
 189
 190
 191 /* should only be called from on_window_delete_event */
 192 static void quit_app(void)
 193 {
 194         configuration_save();
 195
 196         if (app->project != NULL)
 197                 project_close(FALSE);   /* save project session files */
 198
 199         document_close_all();
 200
 201         main_status.quitting = TRUE;
 202
 203         main_quit();
 204 }
 205
 206
 207 /* wrapper function to abort exit process if cancel button is pressed */
 208 G_MODULE_EXPORT gboolean on_window_delete_event(GtkWidget *widget, GdkEvent *event, gpointer gdata)
 209 {
 210         main_status.quitting = TRUE;
 211
 212         if (! check_no_unsaved())
 213         {
 214                 if (document_account_for_unsaved())
 215                 {
 216                         quit_app();
 217                         return FALSE;
 218                 }
 219         }
 220         else
 221         if (! prefs.confirm_exit ||
 222                 dialogs_show_question_full(NULL, GTK_STOCK_QUIT, GTK_STOCK_CANCEL, NULL,
 223                         _("Do you really want to quit?")))
 224         {
 225                 quit_app();
 226                 return FALSE;
 227         }
 228
 229         main_status.quitting = FALSE;
 230         return TRUE;
 231 }
 232
 233
 234 /*
 235  * GUI callbacks
 236  */
 237
 238 G_MODULE_EXPORT void on_new1_activate(GtkMenuItem *menuitem, gpointer user_data)
 239 {
 240         document_new_file(NULL, NULL, NULL);
 241 }
 242
 243
 244 /* create a new file and copy file content and properties */
 245 G_MODULE_EXPORT void on_clone1_activate(GtkMenuItem *menuitem, gpointer user_data)
 246 {
 247         GeanyDocument *old_doc = document_get_current();
 248
 249         if (old_doc)
 250                 document_clone(old_doc);
 251 }
 252
 253
 254 G_MODULE_EXPORT void on_save1_activate(GtkMenuItem *menuitem, gpointer user_data)
 255 {
 256         gint cur_page = gtk_notebook_get_current_page(GTK_NOTEBOOK(main_widgets.notebook));
 257         GeanyDocument *doc = document_get_current();
 258
 259         if (doc != NULL && cur_page >= 0)
 260         {
 261                 document_save_file(doc, ui_prefs.allow_always_save);
 262         }
 263 }
 264
 265
 266 G_MODULE_EXPORT void on_save_as1_activate(GtkMenuItem *menuitem, gpointer user_data)
 267 {
 268         dialogs_show_save_as();
 269 }
 270
 271
 272 G_MODULE_EXPORT void on_save_all1_activate(GtkMenuItem *menuitem, gpointer user_data)
 273 {
 274         guint i, max = (guint) gtk_notebook_get_n_pages(GTK_NOTEBOOK(main_widgets.notebook));
 275         GeanyDocument *doc, *cur_doc = document_get_current();
 276         guint count = 0;
 277
 278         /* iterate over documents in tabs order */
 279         for (i = 0; i < max; i++)
 280         {
 281                 doc = document_get_from_page(i);
 282                 if (! doc->changed)
 283                         continue;
 284
 285                 if (document_save_file(doc, FALSE))
 286                         count++;
 287         }
 288         if (!count)
 289                 return;
 290
 291         ui_set_statusbar(FALSE, ngettext("%d file saved.", "%d files saved.", count), count);
 292         /* saving may have changed window title, sidebar for another doc, so update */
 293         sidebar_update_tag_list(cur_doc, TRUE);
 294         ui_set_window_title(cur_doc);
 295 }
 296
 297
 298 G_MODULE_EXPORT void on_close_all1_activate(GtkMenuItem *menuitem, gpointer user_data)
 299 {
 300         document_close_all();
 301 }
 302
 303
 304 G_MODULE_EXPORT void on_close1_activate(GtkMenuItem *menuitem, gpointer user_data)
 305 {
 306         GeanyDocument *doc = document_get_current();
 307
 308         if (doc != NULL)
 309                 document_close(doc);
 310 }
 311
 312
 313 G_MODULE_EXPORT void on_quit1_activate(GtkMenuItem *menuitem, gpointer user_data)
 314 {
 315         on_window_delete_event(NULL, NULL, NULL);
 316 }
 317
 318
 319 G_MODULE_EXPORT void on_file1_activate(GtkMenuItem *menuitem, gpointer user_data)
 320 {
 321         gtk_widget_set_sensitive(ui_widgets.recent_files_menuitem,
 322                                                 g_queue_get_length(ui_prefs.recent_queue) > 0);
 323         /* hide Page setup when GTK printing is not used */
 324         ui_widget_show_hide(ui_widgets.print_page_setup, printing_prefs.use_gtk_printing);
 325 }
 326
 327
 328 /* edit actions, c&p & co, from menu bar and from popup menu */
 329 G_MODULE_EXPORT void on_edit1_activate(GtkMenuItem *menuitem, gpointer user_data)
 330 {
 331         GtkWidget *item;
 332         GeanyDocument *doc = document_get_current();
 333
 334         ui_update_menu_copy_items(doc);
 335         ui_update_insert_include_item(doc, 1);
 336
 337         item = ui_lookup_widget(main_widgets.window, "plugin_preferences1");
 338 #ifndef HAVE_PLUGINS
 339         gtk_widget_hide(item);
 340 #else
 341         gtk_widget_set_sensitive(item, plugins_have_preferences());
 342 #endif
 343 }
 344
 345
 346 G_MODULE_EXPORT void on_undo1_activate(GtkMenuItem *menuitem, gpointer user_data)
 347 {
 348         GeanyDocument *doc = document_get_current();
 349
 350         g_return_if_fail(doc != NULL);
 351
 352         if (document_can_undo(doc))
 353         {
 354                 sci_cancel(doc->editor->sci);
 355                 document_undo(doc);
 356         }
 357 }
 358
 359
 360 G_MODULE_EXPORT void on_redo1_activate(GtkMenuItem *menuitem, gpointer user_data)
 361 {
 362         GeanyDocument *doc = document_get_current();
 363
 364         g_return_if_fail(doc != NULL);
 365
 366         if (document_can_redo(doc))
 367         {
 368                 sci_cancel(doc->editor->sci);
 369                 document_redo(doc);
 370         }
 371 }
 372
 373
 374 G_MODULE_EXPORT void on_cut1_activate(GtkMenuItem *menuitem, gpointer user_data)
 375 {
 376         GeanyDocument *doc = document_get_current();
 377         GtkWidget *focusw = gtk_window_get_focus(GTK_WINDOW(main_widgets.window));
 378
 379         if (GTK_IS_EDITABLE(focusw))
 380                 gtk_editable_cut_clipboard(GTK_EDITABLE(focusw));
 381         else
 382         if (IS_SCINTILLA(focusw) && doc != NULL)
 383                 sci_cut(doc->editor->sci);
 384         else
 385         if (GTK_IS_TEXT_VIEW(focusw))
 386         {
 387                 GtkTextBuffer *buffer = gtk_text_view_get_buffer(
 388                         GTK_TEXT_VIEW(focusw));
 389                 gtk_text_buffer_cut_clipboard(buffer, gtk_clipboard_get(GDK_NONE), TRUE);
 390         }
 391 }
 392
 393
 394 G_MODULE_EXPORT void on_copy1_activate(GtkMenuItem *menuitem, gpointer user_data)
 395 {
 396         GeanyDocument *doc = document_get_current();
 397         GtkWidget *focusw = gtk_window_get_focus(GTK_WINDOW(main_widgets.window));
 398
 399         if (GTK_IS_EDITABLE(focusw))
 400                 gtk_editable_copy_clipboard(GTK_EDITABLE(focusw));
 401         else
 402         if (IS_SCINTILLA(focusw) && doc != NULL)
 403                 sci_copy(doc->editor->sci);
 404         else
 405         if (GTK_IS_TEXT_VIEW(focusw))
 406         {
 407                 GtkTextBuffer *buffer = gtk_text_view_get_buffer(
 408                         GTK_TEXT_VIEW(focusw));
 409                 gtk_text_buffer_copy_clipboard(buffer, gtk_clipboard_get(GDK_NONE));
 410         }
 411 }
 412
 413
 414 G_MODULE_EXPORT void on_paste1_activate(GtkMenuItem *menuitem, gpointer user_data)
 415 {
 416         GeanyDocument *doc = document_get_current();
 417         GtkWidget *focusw = gtk_window_get_focus(GTK_WINDOW(main_widgets.window));
 418
 419         if (GTK_IS_EDITABLE(focusw))
 420                 gtk_editable_paste_clipboard(GTK_EDITABLE(focusw));
 421         else
 422         if (IS_SCINTILLA(focusw) && doc != NULL)
 423         {
 424                 sci_paste(doc->editor->sci);
 425         }
 426         else
 427         if (GTK_IS_TEXT_VIEW(focusw))
 428         {
 429                 GtkTextBuffer *buffer = gtk_text_view_get_buffer(
 430                         GTK_TEXT_VIEW(focusw));
 431                 gtk_text_buffer_paste_clipboard(buffer, gtk_clipboard_get(GDK_NONE), NULL,
 432                         TRUE);
 433         }
 434 }
 435
 436
 437 G_MODULE_EXPORT void on_delete1_activate(GtkMenuItem *menuitem, gpointer user_data)
 438 {
 439         GeanyDocument *doc = document_get_current();
 440         GtkWidget *focusw = gtk_window_get_focus(GTK_WINDOW(main_widgets.window));
 441
 442         if (GTK_IS_EDITABLE(focusw))
 443                 gtk_editable_delete_selection(GTK_EDITABLE(focusw));
 444         else
 445         if (IS_SCINTILLA(focusw) && doc != NULL && sci_has_selection(doc->editor->sci))
 446                 sci_clear(doc->editor->sci);
 447         else
 448         if (GTK_IS_TEXT_VIEW(focusw))
 449         {
 450                 GtkTextBuffer *buffer = gtk_text_view_get_buffer(
 451                         GTK_TEXT_VIEW(focusw));
 452                 gtk_text_buffer_delete_selection(buffer, TRUE, TRUE);
 453         }
 454 }
 455
 456
 457 G_MODULE_EXPORT void on_preferences1_activate(GtkMenuItem *menuitem, gpointer user_data)
 458 {
 459         prefs_show_dialog();
 460 }
 461
 462
 463 /* about menu item */
 464 G_MODULE_EXPORT void on_info1_activate(GtkMenuItem *menuitem, gpointer user_data)
 465 {
 466         about_dialog_show();
 467 }
 468
 469
 470 /* open file */
 471 G_MODULE_EXPORT void on_open1_activate(GtkMenuItem *menuitem, gpointer user_data)
 472 {
 473         dialogs_show_open_file();
 474 }
 475
 476
 477 /* reload file */
 478 G_MODULE_EXPORT void on_toolbutton_reload_clicked(GtkAction *action, gpointer user_data)
 479 {
 480         GeanyDocument *doc = document_get_current();
 481
 482         g_return_if_fail(doc != NULL);
 483
 484         document_reload_prompt(doc, NULL);
 485 }
 486
 487
 488 G_MODULE_EXPORT void on_change_font1_activate(GtkMenuItem *menuitem, gpointer user_data)
 489 {
 490         dialogs_show_open_font();
 491 }
 492
 493
 494 /* store text, clear search flags so we can use Search->Find Next/Previous */
 495 static void setup_find(const gchar *text, gboolean backwards)
 496 {
 497         SETPTR(search_data.text, g_strdup(text));
 498         SETPTR(search_data.original_text, g_strdup(text));
 499         search_data.flags = 0;
 500         search_data.backwards = backwards;
 501         search_data.search_bar = TRUE;
 502 }
 503
 504
 505 static void do_toolbar_search(const gchar *text, gboolean incremental, gboolean backwards)
 506 {
 507         GeanyDocument *doc = document_get_current();
 508         gboolean result;
 509
 510         setup_find(text, backwards);
 511         result = document_search_bar_find(doc, search_data.text, 0, incremental, backwards);
 512         if (search_data.search_bar)
 513                 ui_set_search_entry_background(toolbar_get_widget_child_by_name("SearchEntry"), result);
 514 }
 515
 516
 517 /* search text */
 518 void on_toolbar_search_entry_changed(GtkAction *action, const gchar *text, gpointer user_data)
 519 {
 520         do_toolbar_search(text, TRUE, FALSE);
 521 }
 522
 523
 524 /* search text */
 525 void on_toolbar_search_entry_activate(GtkAction *action, const gchar *text, gpointer user_data)
 526 {
 527         do_toolbar_search(text, FALSE, GPOINTER_TO_INT(user_data));
 528 }
 529
 530
 531 /* search text */
 532 void on_toolbutton_search_clicked(GtkAction *action, gpointer user_data)
 533 {
 534         GeanyDocument *doc = document_get_current();
 535         gboolean result;
 536         GtkWidget *entry = toolbar_get_widget_child_by_name("SearchEntry");
 537
 538         if (entry != NULL)
 539         {
 540                 const gchar *text = gtk_entry_get_text(GTK_ENTRY(entry));
 541
 542                 setup_find(text, FALSE);
 543                 result = document_search_bar_find(doc, search_data.text, 0, FALSE, FALSE);
 544                 if (search_data.search_bar)
 545                         ui_set_search_entry_background(entry, result);
 546         }
 547         else
 548                 on_find1_activate(NULL, NULL);
 549 }
 550
 551
 552 /* hides toolbar from toolbar popup menu */
 553 G_MODULE_EXPORT void on_hide_toolbar1_activate(GtkMenuItem *menuitem, gpointer user_data)
 554 {
 555         GtkWidget *tool_item = ui_lookup_widget(GTK_WIDGET(main_widgets.window), "menu_show_toolbar1");
 556         gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(tool_item), FALSE);
 557 }
 558
 559
 560 /* zoom in from menu bar and popup menu */
 561 G_MODULE_EXPORT void on_zoom_in1_activate(GtkMenuItem *menuitem, gpointer user_data)
 562 {
 563         GeanyDocument *doc = document_get_current();
 564         static gint done = 1;
 565
 566         g_return_if_fail(doc != NULL);
 567
 568         if (done++ % 3 == 0)
 569                 sci_set_line_numbers(doc->editor->sci, editor_prefs.show_linenumber_margin,
 570                                 (sci_get_zoom(doc->editor->sci) / 2));
 571         sci_zoom_in(doc->editor->sci);
 572 }
 573
 574
 575 /* zoom out from menu bar and popup menu */
 576 G_MODULE_EXPORT void on_zoom_out1_activate(GtkMenuItem *menuitem, gpointer user_data)
 577 {
 578         GeanyDocument *doc = document_get_current();
 579
 580         g_return_if_fail(doc != NULL);
 581
 582         if (sci_get_zoom(doc->editor->sci) == 0)
 583                         sci_set_line_numbers(doc->editor->sci, editor_prefs.show_linenumber_margin, 0);
 584         sci_zoom_out(doc->editor->sci);
 585 }
 586
 587
 588 G_MODULE_EXPORT void on_normal_size1_activate(GtkMenuItem *menuitem, gpointer user_data)
 589 {
 590         GeanyDocument *doc = document_get_current();
 591
 592         g_return_if_fail(doc != NULL);
 593
 594         sci_zoom_off(doc->editor->sci);
 595         sci_set_line_numbers(doc->editor->sci, editor_prefs.show_linenumber_margin, 0);
 596 }
 597
 598
 599 static gboolean delayed_check_disk_status(gpointer data)
 600 {
 601         document_check_disk_status(data, FALSE);
 602         return FALSE;
 603 }
 604
 605
 606 /* Changes window-title after switching tabs and lots of other things.
 607  * note: using 'after' makes Scintilla redraw before the UI, appearing more responsive */
 608 G_MODULE_EXPORT void on_notebook1_switch_page_after(GtkNotebook *notebook, gpointer page,
 609                 guint page_num, gpointer user_data)
 610 {
 611         GeanyDocument *doc;
 612
 613         if (G_UNLIKELY(main_status.opening_session_files || main_status.closing_all))
 614                 return;
 615
 616         if (page_num == (guint) -1 && page != NULL)
 617                 doc = document_find_by_sci(SCINTILLA(page));
 618         else
 619                 doc = document_get_from_page(page_num);
 620
 621         if (doc != NULL)
 622         {
 623                 sidebar_select_openfiles_item(doc);
 624                 ui_save_buttons_toggle(doc->changed);
 625                 ui_set_window_title(doc);
 626                 ui_update_statusbar(doc, -1);
 627                 ui_update_popup_reundo_items(doc);
 628                 ui_document_show_hide(doc); /* update the document menu */
 629                 build_menu_update(doc);
 630                 sidebar_update_tag_list(doc, FALSE);
 631                 document_highlight_tags(doc);
 632
 633                 /* We delay the check to avoid weird fast, unintended switching of notebook pages when
 634                  * the 'file has changed' dialog is shown while the switch event is not yet completely
 635                  * finished. So, we check after the switch has been performed to be safe. */
 636                 g_idle_add(delayed_check_disk_status, doc);
 637
 638 #ifdef HAVE_VTE
 639                 vte_cwd((doc->real_path != NULL) ? doc->real_path : doc->file_name, FALSE);
 640 #endif
 641
 642                 g_signal_emit_by_name(geany_object, "document-activate", doc);
 643         }
 644 }
 645
 646
 647 G_MODULE_EXPORT void on_tv_notebook_switch_page(GtkNotebook *notebook, gpointer page,
 648                 guint page_num, gpointer user_data)
 649 {
 650         /* suppress selection changed signal when switching to the open files list */
 651         ignore_callback = TRUE;
 652 }
 653
 654
 655 G_MODULE_EXPORT void on_tv_notebook_switch_page_after(GtkNotebook *notebook, gpointer page,
 656                 guint page_num, gpointer user_data)
 657 {
 658         ignore_callback = FALSE;
 659 }
 660
 661
 662 static void convert_eol(gint mode)
 663 {
 664         GeanyDocument *doc = document_get_current();
 665
 666         g_return_if_fail(doc != NULL);
 667
 668         sci_convert_eols(doc->editor->sci, mode);
 669         sci_set_eol_mode(doc->editor->sci, mode);
 670         ui_update_statusbar(doc, -1);
 671 }
 672
 673
 674 G_MODULE_EXPORT void on_crlf_activate(GtkCheckMenuItem *menuitem, gpointer user_data)
 675 {
 676         if (ignore_callback || ! gtk_check_menu_item_get_active(menuitem))
 677                 return;
 678
 679         convert_eol(SC_EOL_CRLF);
 680 }
 681
 682
 683 G_MODULE_EXPORT void on_lf_activate(GtkCheckMenuItem *menuitem, gpointer user_data)
 684 {
 685         if (ignore_callback || ! gtk_check_menu_item_get_active(menuitem))
 686                 return;
 687
 688         convert_eol(SC_EOL_LF);
 689 }
 690
 691
 692 G_MODULE_EXPORT void on_cr_activate(GtkCheckMenuItem *menuitem, gpointer user_data)
 693 {
 694         if (ignore_callback || ! gtk_check_menu_item_get_active(menuitem))
 695                 return;
 696
 697         convert_eol(SC_EOL_CR);
 698 }
 699
 700
 701 G_MODULE_EXPORT void on_replace_tabs_activate(GtkMenuItem *menuitem, gpointer user_data)
 702 {
 703         GeanyDocument *doc = document_get_current();
 704
 705         g_return_if_fail(doc != NULL);
 706
 707         editor_replace_tabs(doc->editor);
 708 }
 709
 710
 711 gboolean toolbar_popup_menu(GtkWidget *widget, GdkEventButton *event, gpointer user_data)
 712 {
 713         if (event->button == 3)
 714         {
 715                 gtk_menu_popup(GTK_MENU(ui_widgets.toolbar_menu), NULL, NULL, NULL, NULL, event->button, event->time);
 716                 return TRUE;
 717         }
 718         return FALSE;
 719 }
 720
 721
 722 G_MODULE_EXPORT void on_toggle_case1_activate(GtkMenuItem *menuitem, gpointer user_data)
 723 {
 724         GeanyDocument *doc = document_get_current();
 725         ScintillaObject *sci;
 726         gchar *text;
 727         gboolean keep_sel = TRUE;
 728
 729         g_return_if_fail(doc != NULL);
 730
 731         sci = doc->editor->sci;
 732         if (! sci_has_selection(sci))
 733         {
 734                 keybindings_send_command(GEANY_KEY_GROUP_SELECT, GEANY_KEYS_SELECT_WORD);
 735                 keep_sel = FALSE;
 736         }
 737
 738         /* either we already had a selection or we created one for current word */
 739         if (sci_has_selection(sci))
 740         {
 741                 gchar *result = NULL;
 742                 gint cmd = SCI_LOWERCASE;
 743                 gboolean rectsel = (gboolean) scintilla_send_message(sci, SCI_SELECTIONISRECTANGLE, 0, 0);
 744
 745                 text = sci_get_selection_contents(sci);
 746
 747                 if (utils_str_has_upper(text))
 748                 {
 749                         if (rectsel)
 750                                 cmd = SCI_LOWERCASE;
 751                         else
 752                                 result = g_utf8_strdown(text, -1);
 753                 }
 754                 else
 755                 {
 756                         if (rectsel)
 757                                 cmd = SCI_UPPERCASE;
 758                         else
 759                                 result = g_utf8_strup(text, -1);
 760                 }
 761
 762                 if (result != NULL)
 763                 {
 764                         sci_replace_sel(sci, result);
 765                         g_free(result);
 766                         if (keep_sel)
 767                                 sci_set_selection_start(sci, sci_get_current_position(sci) - strlen(text));
 768                 }
 769                 else
 770                         sci_send_command(sci, cmd);
 771
 772                 g_free(text);
 773
 774         }
 775 }
 776
 777
 778 G_MODULE_EXPORT void on_show_toolbar1_toggled(GtkCheckMenuItem *checkmenuitem, gpointer user_data)
 779 {
 780         if (ignore_callback) return;
 781
 782         toolbar_prefs.visible = (toolbar_prefs.visible) ? FALSE : TRUE;;
 783         ui_widget_show_hide(GTK_WIDGET(main_widgets.toolbar), toolbar_prefs.visible);
 784 }
 785
 786
 787 G_MODULE_EXPORT void on_fullscreen1_toggled(GtkCheckMenuItem *checkmenuitem, gpointer user_data)
 788 {
 789         if (ignore_callback)
 790                 return;
 791
 792         ui_prefs.fullscreen = (ui_prefs.fullscreen) ? FALSE : TRUE;
 793         ui_set_fullscreen();
 794 }
 795
 796
 797 G_MODULE_EXPORT void on_show_messages_window1_toggled(GtkCheckMenuItem *checkmenuitem, gpointer user_data)
 798 {
 799         if (ignore_callback)
 800                 return;
 801
 802         ui_prefs.msgwindow_visible = (ui_prefs.msgwindow_visible) ? FALSE : TRUE;
 803         msgwin_show_hide(ui_prefs.msgwindow_visible);
 804 }
 805
 806
 807 G_MODULE_EXPORT void on_menu_color_schemes_activate(GtkImageMenuItem *imagemenuitem, gpointer user_data)
 808 {
 809         highlighting_show_color_scheme_dialog();
 810 }
 811
 812
 813 G_MODULE_EXPORT void on_markers_margin1_toggled(GtkCheckMenuItem *checkmenuitem, gpointer user_data)
 814 {
 815         if (ignore_callback)
 816                 return;
 817
 818         editor_prefs.show_markers_margin = ! editor_prefs.show_markers_margin;
 819         ui_toggle_editor_features(GEANY_EDITOR_SHOW_MARKERS_MARGIN);
 820 }
 821
 822
 823 G_MODULE_EXPORT void on_show_line_numbers1_toggled(GtkCheckMenuItem *checkmenuitem, gpointer user_data)
 824 {
 825         if (ignore_callback)
 826                 return;
 827
 828         editor_prefs.show_linenumber_margin = ! editor_prefs.show_linenumber_margin;
 829         ui_toggle_editor_features(GEANY_EDITOR_SHOW_LINE_NUMBERS);
 830 }
 831
 832
 833 G_MODULE_EXPORT void on_menu_show_white_space1_toggled(GtkCheckMenuItem *checkmenuitem, gpointer user_data)
 834 {
 835         if (ignore_callback)
 836                 return;
 837
 838         editor_prefs.show_white_space = ! editor_prefs.show_white_space;
 839         ui_toggle_editor_features(GEANY_EDITOR_SHOW_WHITE_SPACE);
 840 }
 841
 842
 843 G_MODULE_EXPORT void on_menu_show_line_endings1_toggled(GtkCheckMenuItem *checkmenuitem, gpointer user_data)
 844 {
 845         if (ignore_callback)
 846                 return;
 847
 848         editor_prefs.show_line_endings = ! editor_prefs.show_line_endings;
 849         ui_toggle_editor_features(GEANY_EDITOR_SHOW_LINE_ENDINGS);
 850 }
 851
 852
 853 G_MODULE_EXPORT void on_menu_show_indentation_guides1_toggled(GtkCheckMenuItem *checkmenuitem, gpointer user_data)
 854 {
 855         if (ignore_callback)
 856                 return;
 857
 858         editor_prefs.show_indent_guide = ! editor_prefs.show_indent_guide;
 859         ui_toggle_editor_features(GEANY_EDITOR_SHOW_INDENTATION_GUIDES);
 860 }
 861
 862
 863 G_MODULE_EXPORT void on_line_wrapping1_toggled(GtkCheckMenuItem *checkmenuitem, gpointer user_data)
 864 {
 865         if (! ignore_callback)
 866         {
 867                 GeanyDocument *doc = document_get_current();
 868                 g_return_if_fail(doc != NULL);
 869
 870                 editor_set_line_wrapping(doc->editor, ! doc->editor->line_wrapping);
 871         }
 872 }
 873
 874
 875 G_MODULE_EXPORT void on_set_file_readonly1_toggled(GtkCheckMenuItem *checkmenuitem, gpointer user_data)
 876 {
 877         if (! ignore_callback)
 878         {
 879                 GeanyDocument *doc = document_get_current();
 880                 g_return_if_fail(doc != NULL);
 881
 882                 doc->readonly = ! doc->readonly;
 883                 sci_set_readonly(doc->editor->sci, doc->readonly);
 884                 ui_update_tab_status(doc);
 885                 ui_update_statusbar(doc, -1);
 886         }
 887 }
 888
 889
 890 G_MODULE_EXPORT void on_use_auto_indentation1_toggled(GtkCheckMenuItem *checkmenuitem, gpointer user_data)
 891 {
 892         if (! ignore_callback)
 893         {
 894                 GeanyDocument *doc = document_get_current();
 895                 g_return_if_fail(doc != NULL);
 896
 897                 doc->editor->auto_indent = ! doc->editor->auto_indent;
 898         }
 899 }
 900
 901
 902 static void find_usage(gboolean in_session)
 903 {
 904         gint flags;
 905         gchar *search_text;
 906         GeanyDocument *doc = document_get_current();
 907
 908         g_return_if_fail(doc != NULL);
 909
 910         if (sci_has_selection(doc->editor->sci))
 911         {       /* take selected text if there is a selection */
 912                 search_text = sci_get_selection_contents(doc->editor->sci);
 913                 flags = SCFIND_MATCHCASE;
 914         }
 915         else
 916         {
 917                 editor_find_current_word_sciwc(doc->editor, -1,
 918                         editor_info.current_word, GEANY_MAX_WORD_LENGTH);
 919                 search_text = g_strdup(editor_info.current_word);
 920                 flags = SCFIND_MATCHCASE | SCFIND_WHOLEWORD;
 921         }
 922
 923         search_find_usage(search_text, search_text, flags, in_session);
 924         g_free(search_text);
 925 }
 926
 927
 928 G_MODULE_EXPORT void on_find_document_usage1_activate(GtkMenuItem *menuitem, gpointer user_data)
 929 {
 930         find_usage(FALSE);
 931 }
 932
 933
 934 G_MODULE_EXPORT void on_find_usage1_activate(GtkMenuItem *menuitem, gpointer user_data)
 935 {
 936         find_usage(TRUE);
 937 }
 938
 939
 940 static void goto_tag(gboolean definition)
 941 {
 942         GeanyDocument *doc = document_get_current();
 943
 944         g_return_if_fail(doc != NULL);
 945
 946         /* update cursor pos for navigating back afterwards */
 947         if (!sci_has_selection(doc->editor->sci))
 948                 sci_set_current_position(doc->editor->sci, editor_info.click_pos, FALSE);
 949
 950         /* use the keybinding callback as it checks for selections as well as current word */
 951         if (definition)
 952                 keybindings_send_command(GEANY_KEY_GROUP_GOTO, GEANY_KEYS_GOTO_TAGDEFINITION);
 953         else
 954                 keybindings_send_command(GEANY_KEY_GROUP_GOTO, GEANY_KEYS_GOTO_TAGDECLARATION);
 955 }
 956
 957
 958 G_MODULE_EXPORT void on_goto_tag_definition1(GtkMenuItem *menuitem, gpointer user_data)
 959 {
 960         goto_tag(TRUE);
 961 }
 962
 963
 964 G_MODULE_EXPORT void on_goto_tag_declaration1(GtkMenuItem *menuitem, gpointer user_data)
 965 {
 966         goto_tag(FALSE);
 967 }
 968
 969
 970 G_MODULE_EXPORT void on_count_words1_activate(GtkMenuItem *menuitem, gpointer user_data)
 971 {
 972         tools_word_count();
 973 }
 974
 975
 976 G_MODULE_EXPORT void on_show_color_chooser1_activate(GtkMenuItem *menuitem, gpointer user_data)
 977 {
 978         gchar colour[9];
 979         GeanyDocument *doc = document_get_current();
 980         gint pos;
 981
 982         g_return_if_fail(doc != NULL);
 983
 984         pos = sci_get_current_position(doc->editor->sci);
 985         editor_find_current_word(doc->editor, pos, colour, sizeof colour, GEANY_WORDCHARS"#");
 986         tools_color_chooser(colour);
 987 }
 988
 989
 990 void on_toolbutton_compile_clicked(GtkAction *action, gpointer user_data)
 991 {
 992         keybindings_send_command(GEANY_KEY_GROUP_BUILD, GEANY_KEYS_BUILD_COMPILE);
 993 }
 994
 995
 996 G_MODULE_EXPORT void on_find1_activate(GtkMenuItem *menuitem, gpointer user_data)
 997 {
 998         search_show_find_dialog();
 999 }
1000
1001
1002 G_MODULE_EXPORT void on_find_next1_activate(GtkMenuItem *menuitem, gpointer user_data)
1003 {
1004         search_find_again(FALSE);
1005 }
1006
1007
1008 G_MODULE_EXPORT void on_find_previous1_activate(GtkMenuItem *menuitem, gpointer user_data)
1009 {
1010         if (search_data.flags & SCFIND_REGEXP)
1011                 /* Can't reverse search order for a regex (find next ignores search backwards) */
1012                 utils_beep();
1013         else
1014                 search_find_again(TRUE);
1015 }
1016
1017
1018 G_MODULE_EXPORT void on_find_nextsel1_activate(GtkMenuItem *menuitem, gpointer user_data)
1019 {
1020         search_find_selection(document_get_current(), FALSE);
1021 }
1022
1023
1024 G_MODULE_EXPORT void on_find_prevsel1_activate(GtkMenuItem *menuitem, gpointer user_data)
1025 {
1026         search_find_selection(document_get_current(), TRUE);
1027 }
1028
1029
1030 G_MODULE_EXPORT void on_replace1_activate(GtkMenuItem *menuitem, gpointer user_data)
1031 {
1032         search_show_replace_dialog();
1033 }
1034
1035
1036 G_MODULE_EXPORT void on_find_in_files1_activate(GtkMenuItem *menuitem, gpointer user_data)
1037 {
1038         search_show_find_in_files_dialog(NULL);
1039 }
1040
1041
1042 static void get_line_and_offset_from_text(const gchar *text, gint *line_no, gint *offset)
1043 {
1044         if (*text == '+' || *text == '-')
1045         {
1046                 *line_no = atoi(text + 1);
1047                 *offset = (*text == '+') ? 1 : -1;
1048         }
1049         else
1050         {
1051                 *line_no = atoi(text) - 1;
1052                 *offset = 0;
1053         }
1054 }
1055
1056
1057 G_MODULE_EXPORT void on_go_to_line_activate(GtkMenuItem *menuitem, gpointer user_data)
1058 {
1059         static gchar value[16] = "";
1060         gchar *result;
1061
1062         result = dialogs_show_input_goto_line(
1063                 _("Go to Line"), GTK_WINDOW(main_widgets.window),
1064                 _("Enter the line you want to go to:"), value);
1065         if (result != NULL)
1066         {
1067                 GeanyDocument *doc = document_get_current();
1068                 gint offset;
1069                 gint line_no;
1070
1071                 g_return_if_fail(doc != NULL);
1072
1073                 get_line_and_offset_from_text(result, &line_no, &offset);
1074                 if (! editor_goto_line(doc->editor, line_no, offset))
1075                         utils_beep();
1076                 /* remember value for future calls */
1077                 g_snprintf(value, sizeof(value), "%s", result);
1078
1079                 g_free(result);
1080         }
1081 }
1082
1083
1084 void on_toolbutton_goto_entry_activate(GtkAction *action, const gchar *text, gpointer user_data)
1085 {
1086         GeanyDocument *doc = document_get_current();
1087         gint offset;
1088         gint line_no;
1089
1090         g_return_if_fail(doc != NULL);
1091
1092         get_line_and_offset_from_text(text, &line_no, &offset);
1093         if (! editor_goto_line(doc->editor, line_no, offset))
1094                 utils_beep();
1095         else
1096                 keybindings_send_command(GEANY_KEY_GROUP_FOCUS, GEANY_KEYS_FOCUS_EDITOR);
1097 }
1098
1099
1100 void on_toolbutton_goto_clicked(GtkAction *action, gpointer user_data)
1101 {
1102         GtkWidget *entry = toolbar_get_widget_child_by_name("GotoEntry");
1103
1104         if (entry != NULL)
1105         {
1106                 const gchar *text = gtk_entry_get_text(GTK_ENTRY(entry));
1107
1108                 on_toolbutton_goto_entry_activate(NULL, text, NULL);
1109         }
1110         else
1111                 on_go_to_line_activate(NULL, NULL);
1112 }
1113
1114
1115 G_MODULE_EXPORT void on_help1_activate(GtkMenuItem *menuitem, gpointer user_data)
1116 {
1117         gchar *uri;
1118
1119         uri = utils_get_help_url(NULL);
1120         utils_open_browser(uri);
1121         g_free(uri);
1122 }
1123
1124
1125 G_MODULE_EXPORT void on_help_shortcuts1_activate(GtkMenuItem *menuitem, gpointer user_data)
1126 {
1127         keybindings_show_shortcuts();
1128 }
1129
1130
1131 G_MODULE_EXPORT void on_website1_activate(GtkMenuItem *menuitem, gpointer user_data)
1132 {
1133         utils_open_browser(GEANY_HOMEPAGE);
1134 }
1135
1136
1137 G_MODULE_EXPORT void on_help_menu_item_donate_activate(GtkMenuItem *item, gpointer user_data)
1138 {
1139         utils_open_browser(GEANY_DONATE);
1140 }
1141
1142
1143 G_MODULE_EXPORT void on_help_menu_item_wiki_activate(GtkMenuItem *item, gpointer user_data)
1144 {
1145         utils_open_browser(GEANY_WIKI);
1146 }
1147
1148
1149 G_MODULE_EXPORT void on_help_menu_item_bug_report_activate(GtkMenuItem *item, gpointer user_data)
1150 {
1151         utils_open_browser(GEANY_BUG_REPORT);
1152 }
1153
1154
1155 G_MODULE_EXPORT void on_comments_function_activate(GtkMenuItem *menuitem, gpointer user_data)
1156 {
1157         GeanyDocument *doc = document_get_current();
1158         gchar *text;
1159         const gchar *cur_tag = NULL;
1160         gint line = -1, pos = 0;
1161
1162         if (doc == NULL || doc->file_type == NULL)
1163         {
1164                 ui_set_statusbar(FALSE,
1165                         _("Please set the filetype for the current file before using this function."));
1166                 return;
1167         }
1168
1169         /* symbols_get_current_function returns -1 on failure, so sci_get_position_from_line
1170          * returns the current position, so it should be safe */
1171         line = symbols_get_current_function(doc, &cur_tag);
1172         pos = sci_get_position_from_line(doc->editor->sci, line);
1173
1174         text = templates_get_template_function(doc, cur_tag);
1175
1176         sci_start_undo_action(doc->editor->sci);
1177         sci_insert_text(doc->editor->sci, pos, text);
1178         sci_end_undo_action(doc->editor->sci);
1179         g_free(text);
1180 }
1181
1182
1183 G_MODULE_EXPORT void on_comments_multiline_activate(GtkMenuItem *menuitem, gpointer user_data)
1184 {
1185         GeanyDocument *doc = document_get_current();
1186
1187         if (doc == NULL || doc->file_type == NULL)
1188         {
1189                 ui_set_statusbar(FALSE,
1190                         _("Please set the filetype for the current file before using this function."));
1191                 return;
1192         }
1193
1194         verify_click_pos(doc); /* make sure that the click_pos is valid */
1195
1196         if (doc->file_type->comment_open || doc->file_type->comment_single)
1197                 editor_insert_multiline_comment(doc->editor);
1198         else
1199                 utils_beep();
1200 }
1201
1202
1203 G_MODULE_EXPORT void on_comments_gpl_activate(GtkMenuItem *menuitem, gpointer user_data)
1204 {
1205         GeanyDocument *doc = document_get_current();
1206         gchar *text;
1207
1208         g_return_if_fail(doc != NULL);
1209
1210         text = templates_get_template_licence(doc, GEANY_TEMPLATE_GPL);
1211
1212         verify_click_pos(doc); /* make sure that the click_pos is valid */
1213
1214         sci_start_undo_action(doc->editor->sci);
1215         sci_insert_text(doc->editor->sci, editor_info.click_pos, text);
1216         sci_end_undo_action(doc->editor->sci);
1217         g_free(text);
1218 }
1219
1220
1221 G_MODULE_EXPORT void on_comments_bsd_activate(GtkMenuItem *menuitem, gpointer user_data)
1222 {
1223         GeanyDocument *doc = document_get_current();
1224         gchar *text;
1225
1226         g_return_if_fail(doc != NULL);
1227
1228         text = templates_get_template_licence(doc, GEANY_TEMPLATE_BSD);
1229
1230         verify_click_pos(doc); /* make sure that the click_pos is valid */
1231
1232         sci_start_undo_action(doc->editor->sci);
1233         sci_insert_text(doc->editor->sci, editor_info.click_pos, text);
1234         sci_end_undo_action(doc->editor->sci);
1235         g_free(text);
1236
1237 }
1238
1239
1240 G_MODULE_EXPORT void on_comments_changelog_activate(GtkMenuItem *menuitem, gpointer user_data)
1241 {
1242         GeanyDocument *doc = document_get_current();
1243         gchar *text;
1244
1245         g_return_if_fail(doc != NULL);
1246
1247         text = templates_get_template_changelog(doc);
1248         sci_start_undo_action(doc->editor->sci);
1249         sci_insert_text(doc->editor->sci, 0, text);
1250         /* sets the cursor to the right position to type the changelog text,
1251          * the template has 21 chars + length of name and email */
1252         sci_goto_pos(doc->editor->sci, 21 + strlen(template_prefs.developer) + strlen(template_prefs.mail), TRUE);
1253         sci_end_undo_action(doc->editor->sci);
1254
1255         g_free(text);
1256 }
1257
1258
1259 G_MODULE_EXPORT void on_comments_fileheader_activate(GtkMenuItem *menuitem, gpointer user_data)
1260 {
1261         GeanyDocument *doc = document_get_current();
1262         gchar *text;
1263         const gchar *fname;
1264         GeanyFiletype *ft;
1265
1266         g_return_if_fail(doc != NULL);
1267
1268         ft = doc->file_type;
1269         fname = doc->file_name;
1270         text = templates_get_template_fileheader(FILETYPE_ID(ft), fname);
1271
1272         sci_start_undo_action(doc->editor->sci);
1273         sci_insert_text(doc->editor->sci, 0, text);
1274         sci_goto_pos(doc->editor->sci, 0, FALSE);
1275         sci_end_undo_action(doc->editor->sci);
1276         g_free(text);
1277 }
1278
1279
1280 void on_insert_date_activate(GtkMenuItem *menuitem, gpointer user_data)
1281 {
1282         GeanyDocument *doc = document_get_current();
1283         const gchar *format = NULL;
1284         gchar *time_str;
1285
1286         g_return_if_fail(doc != NULL);
1287
1288         /* set default value */
1289         if (utils_str_equal("", ui_prefs.custom_date_format))
1290         {
1291                 g_free(ui_prefs.custom_date_format);
1292                 ui_prefs.custom_date_format = g_strdup("%d.%m.%Y");
1293         }
1294
1295         if (utils_str_equal(_("dd.mm.yyyy"), (gchar*) user_data))
1296                 format = "%d.%m.%Y";
1297         else if (utils_str_equal(_("mm.dd.yyyy"), (gchar*) user_data))
1298                 format = "%m.%d.%Y";
1299         else if (utils_str_equal(_("yyyy/mm/dd"), (gchar*) user_data))
1300                 format = "%Y/%m/%d";
1301         else if (utils_str_equal(_("dd.mm.yyyy hh:mm:ss"), (gchar*) user_data))
1302                 format = "%d.%m.%Y %H:%M:%S";
1303         else if (utils_str_equal(_("mm.dd.yyyy hh:mm:ss"), (gchar*) user_data))
1304                 format = "%m.%d.%Y %H:%M:%S";
1305         else if (utils_str_equal(_("yyyy/mm/dd hh:mm:ss"), (gchar*) user_data))
1306                 format = "%Y/%m/%d %H:%M:%S";
1307         else if (utils_str_equal(_("_Use Custom Date Format"), (gchar*) user_data))
1308                 format = ui_prefs.custom_date_format;
1309         else
1310         {
1311                 gchar *str = dialogs_show_input(_("Custom Date Format"), GTK_WINDOW(main_widgets.window),
1312                                 _("Enter here a custom date and time format. "
1313                                 "You can use any conversion specifiers which can be used with the ANSI C strftime function."),
1314                                 ui_prefs.custom_date_format);
1315                 if (str)
1316                         SETPTR(ui_prefs.custom_date_format, str);
1317                 return;
1318         }
1319
1320         time_str = utils_get_date_time(format, NULL);
1321         if (time_str != NULL)
1322         {
1323                 verify_click_pos(doc); /* make sure that the click_pos is valid */
1324
1325                 sci_start_undo_action(doc->editor->sci);
1326                 sci_insert_text(doc->editor->sci, editor_info.click_pos, time_str);
1327                 sci_goto_pos(doc->editor->sci, editor_info.click_pos + strlen(time_str), FALSE);
1328                 sci_end_undo_action(doc->editor->sci);
1329                 g_free(time_str);
1330         }
1331         else
1332         {
1333                 utils_beep();
1334                 ui_set_statusbar(TRUE,
1335                                 _("Date format string could not be converted (possibly too long)."));
1336         }
1337 }
1338
1339
1340 void on_insert_include_activate(GtkMenuItem *menuitem, gpointer user_data)
1341 {
1342         GeanyDocument *doc = document_get_current();
1343         gint pos = -1;
1344         gchar *text;
1345
1346         g_return_if_fail(doc != NULL);
1347         g_return_if_fail(user_data != NULL);
1348
1349         verify_click_pos(doc); /* make sure that the click_pos is valid */
1350
1351         if (utils_str_equal(user_data, "blank"))
1352         {
1353                 text = g_strdup("#include \"\"\n");
1354                 pos = editor_info.click_pos + 10;
1355         }
1356         else
1357         {
1358                 text = g_strconcat("#include <", user_data, ">\n", NULL);
1359         }
1360
1361         sci_start_undo_action(doc->editor->sci);
1362         sci_insert_text(doc->editor->sci, editor_info.click_pos, text);
1363         sci_end_undo_action(doc->editor->sci);
1364         g_free(text);
1365         if (pos >= 0)
1366                 sci_goto_pos(doc->editor->sci, pos, FALSE);
1367 }
1368
1369
1370 G_MODULE_EXPORT void on_file_properties_activate(GtkMenuItem *menuitem, gpointer user_data)
1371 {
1372         GeanyDocument *doc = document_get_current();
1373         g_return_if_fail(doc != NULL);
1374
1375         dialogs_show_file_properties(doc);
1376 }
1377
1378
1379 G_MODULE_EXPORT void on_menu_fold_all1_activate(GtkMenuItem *menuitem, gpointer user_data)
1380 {
1381         GeanyDocument *doc = document_get_current();
1382         g_return_if_fail(doc != NULL);
1383
1384         editor_fold_all(doc->editor);
1385 }
1386
1387
1388 G_MODULE_EXPORT void on_menu_unfold_all1_activate(GtkMenuItem *menuitem, gpointer user_data)
1389 {
1390         GeanyDocument *doc = document_get_current();
1391         g_return_if_fail(doc != NULL);
1392
1393         editor_unfold_all(doc->editor);
1394 }
1395
1396
1397 void on_toolbutton_run_clicked(GtkAction *action, gpointer user_data)
1398 {
1399         keybindings_send_command(GEANY_KEY_GROUP_BUILD, GEANY_KEYS_BUILD_RUN);
1400 }
1401
1402
1403 G_MODULE_EXPORT void on_menu_remove_indicators1_activate(GtkMenuItem *menuitem, gpointer user_data)
1404 {
1405         GeanyDocument *doc = document_get_current();
1406         g_return_if_fail(doc != NULL);
1407
1408         editor_indicator_clear(doc->editor, GEANY_INDICATOR_ERROR);
1409 }
1410
1411
1412 G_MODULE_EXPORT void on_print1_activate(GtkMenuItem *menuitem, gpointer user_data)
1413 {
1414         GeanyDocument *doc = document_get_current();
1415         g_return_if_fail(doc != NULL);
1416
1417         printing_print_doc(doc);
1418 }
1419
1420
1421 G_MODULE_EXPORT void on_menu_select_all1_activate(GtkMenuItem *menuitem, gpointer user_data)
1422 {
1423         GeanyDocument *doc = document_get_current();
1424         g_return_if_fail(doc != NULL);
1425
1426         sci_select_all(doc->editor->sci);
1427 }
1428
1429
1430 G_MODULE_EXPORT void on_menu_show_sidebar1_toggled(GtkCheckMenuItem *checkmenuitem, gpointer user_data)
1431 {
1432         if (ignore_callback)
1433                 return;
1434
1435         ui_prefs.sidebar_visible = ! ui_prefs.sidebar_visible;
1436
1437         /* show built-in tabs if no tabs visible */
1438         if (ui_prefs.sidebar_visible &&
1439                 ! interface_prefs.sidebar_openfiles_visible && ! interface_prefs.sidebar_symbol_visible &&
1440                 gtk_notebook_get_n_pages(GTK_NOTEBOOK(main_widgets.sidebar_notebook)) <= 2)
1441         {
1442                 interface_prefs.sidebar_openfiles_visible = TRUE;
1443                 interface_prefs.sidebar_symbol_visible = TRUE;
1444         }
1445
1446         /* if window has input focus, set it back to the editor before toggling off */
1447         if (! ui_prefs.sidebar_visible &&
1448                 gtk_container_get_focus_child(GTK_CONTAINER(main_widgets.sidebar_notebook)) != NULL)
1449         {
1450                 keybindings_send_command(GEANY_KEY_GROUP_FOCUS, GEANY_KEYS_FOCUS_EDITOR);
1451         }
1452
1453         ui_sidebar_show_hide();
1454 }
1455
1456
1457 G_MODULE_EXPORT void on_menu_write_unicode_bom1_toggled(GtkCheckMenuItem *checkmenuitem, gpointer user_data)
1458 {
1459         if (! ignore_callback)
1460         {
1461                 GeanyDocument *doc = document_get_current();
1462
1463                 g_return_if_fail(doc != NULL);
1464                 if (doc->readonly)
1465                 {
1466                         utils_beep();
1467                         return;
1468                 }
1469
1470                 document_undo_add(doc, UNDO_BOM, GINT_TO_POINTER(doc->has_bom));
1471
1472                 doc->has_bom = ! doc->has_bom;
1473
1474                 ui_update_statusbar(doc, -1);
1475         }
1476 }
1477
1478
1479 G_MODULE_EXPORT void on_menu_comment_line1_activate(GtkMenuItem *menuitem, gpointer user_data)
1480 {
1481         GeanyDocument *doc = document_get_current();
1482         g_return_if_fail(doc != NULL);
1483
1484         editor_do_comment(doc->editor, -1, FALSE, FALSE, TRUE);
1485 }
1486
1487
1488 G_MODULE_EXPORT void on_menu_uncomment_line1_activate(GtkMenuItem *menuitem, gpointer user_data)
1489 {
1490         GeanyDocument *doc = document_get_current();
1491         g_return_if_fail(doc != NULL);
1492
1493         editor_do_uncomment(doc->editor, -1, FALSE);
1494 }
1495
1496
1497 G_MODULE_EXPORT void on_menu_toggle_line_commentation1_activate(GtkMenuItem *menuitem, gpointer user_data)
1498 {
1499         GeanyDocument *doc = document_get_current();
1500         g_return_if_fail(doc != NULL);
1501
1502         editor_do_comment_toggle(doc->editor);
1503 }
1504
1505
1506 G_MODULE_EXPORT void on_menu_increase_indent1_activate(GtkMenuItem *menuitem, gpointer user_data)
1507 {
1508         GeanyDocument *doc = document_get_current();
1509         g_return_if_fail(doc != NULL);
1510
1511         editor_indent(doc->editor, TRUE);
1512 }
1513
1514
1515 G_MODULE_EXPORT void on_menu_decrease_indent1_activate(GtkMenuItem *menuitem, gpointer user_data)
1516 {
1517         GeanyDocument *doc = document_get_current();
1518         g_return_if_fail(doc != NULL);
1519
1520         editor_indent(doc->editor, FALSE);
1521 }
1522
1523
1524 G_MODULE_EXPORT void on_next_message1_activate(GtkMenuItem *menuitem, gpointer user_data)
1525 {
1526         if (! ui_tree_view_find_next(GTK_TREE_VIEW(msgwindow.tree_msg),
1527                 msgwin_goto_messages_file_line))
1528                 ui_set_statusbar(FALSE, _("No more message items."));
1529 }
1530
1531
1532 G_MODULE_EXPORT void on_previous_message1_activate(GtkMenuItem *menuitem, gpointer user_data)
1533 {
1534         if (! ui_tree_view_find_previous(GTK_TREE_VIEW(msgwindow.tree_msg),
1535                 msgwin_goto_messages_file_line))
1536                 ui_set_statusbar(FALSE, _("No more message items."));
1537 }
1538
1539
1540 G_MODULE_EXPORT void on_menu_comments_multiline_activate(GtkMenuItem *menuitem, gpointer user_data)
1541 {
1542         insert_callback_from_menu = TRUE;
1543         on_comments_multiline_activate(menuitem, user_data);
1544 }
1545
1546
1547 G_MODULE_EXPORT void on_menu_comments_gpl_activate(GtkMenuItem *menuitem, gpointer user_data)
1548 {
1549         insert_callback_from_menu = TRUE;
1550         on_comments_gpl_activate(menuitem, user_data);
1551 }
1552
1553
1554 G_MODULE_EXPORT void on_menu_comments_bsd_activate(GtkMenuItem *menuitem, gpointer user_data)
1555 {
1556         insert_callback_from_menu = TRUE;
1557         on_comments_bsd_activate(menuitem, user_data);
1558 }
1559
1560
1561 void on_menu_insert_include_activate(GtkMenuItem *menuitem, gpointer user_data)
1562 {
1563         insert_callback_from_menu = TRUE;
1564         on_insert_include_activate(menuitem, user_data);
1565 }
1566
1567
1568 void on_menu_insert_date_activate(GtkMenuItem *menuitem, gpointer user_data)
1569 {
1570         insert_callback_from_menu = TRUE;
1571         on_insert_date_activate(menuitem, user_data);
1572 }
1573
1574
1575 G_MODULE_EXPORT void on_project_new1_activate(GtkMenuItem *menuitem, gpointer user_data)
1576 {
1577         project_new();
1578 }
1579
1580
1581 G_MODULE_EXPORT void on_project_open1_activate(GtkMenuItem *menuitem, gpointer user_data)
1582 {
1583         project_open();
1584 }
1585
1586
1587 G_MODULE_EXPORT void on_project_close1_activate(GtkMenuItem *menuitem, gpointer user_data)
1588 {
1589         project_close(TRUE);
1590 }
1591
1592
1593 G_MODULE_EXPORT void on_project_properties1_activate(GtkMenuItem *menuitem, gpointer user_data)
1594 {
1595         project_properties();
1596 }
1597
1598
1599 G_MODULE_EXPORT void on_menu_project1_activate(GtkMenuItem *menuitem, gpointer user_data)
1600 {
1601         static GtkWidget *item_close = NULL;
1602         static GtkWidget *item_properties = NULL;
1603
1604         if (item_close == NULL)
1605         {
1606                 item_close = ui_lookup_widget(main_widgets.window, "project_close1");
1607                 item_properties = ui_lookup_widget(main_widgets.window, "project_properties1");
1608         }
1609
1610         gtk_widget_set_sensitive(item_close, (app->project != NULL));
1611         gtk_widget_set_sensitive(item_properties, (app->project != NULL));
1612         gtk_widget_set_sensitive(ui_widgets.recent_projects_menuitem,
1613                                                 g_queue_get_length(ui_prefs.recent_projects_queue) > 0);
1614 }
1615
1616
1617 G_MODULE_EXPORT void on_menu_open_selected_file1_activate(GtkMenuItem *menuitem, gpointer user_data)
1618 {
1619         GeanyDocument *doc = document_get_current();
1620         gchar *sel = NULL;
1621         const gchar *wc;
1622
1623 #ifdef G_OS_WIN32
1624         wc = GEANY_WORDCHARS "./-" "\\";
1625 #else
1626         wc = GEANY_WORDCHARS "./-";
1627 #endif
1628
1629         g_return_if_fail(doc != NULL);
1630
1631         sel = editor_get_default_selection(doc->editor, TRUE, wc);
1632         SETPTR(sel, utils_get_locale_from_utf8(sel));
1633
1634         if (sel != NULL)
1635         {
1636                 gchar *filename = NULL;
1637
1638                 if (g_path_is_absolute(sel))
1639                         filename = g_strdup(sel);
1640                 else
1641                 {       /* relative filename, add the path of the current file */
1642                         gchar *path;
1643
1644                         path = utils_get_current_file_dir_utf8();
1645                         SETPTR(path, utils_get_locale_from_utf8(path));
1646                         if (!path)
1647                                 path = g_get_current_dir();
1648
1649                         filename = g_build_path(G_DIR_SEPARATOR_S, path, sel, NULL);
1650
1651                         if (! g_file_test(filename, G_FILE_TEST_EXISTS) &&
1652                                 app->project != NULL && !EMPTY(app->project->base_path))
1653                         {
1654                                 /* try the project's base path */
1655                                 SETPTR(path, project_get_base_path());
1656                                 SETPTR(path, utils_get_locale_from_utf8(path));
1657                                 SETPTR(filename, g_build_path(G_DIR_SEPARATOR_S, path, sel, NULL));
1658                         }
1659                         g_free(path);
1660 #ifdef G_OS_UNIX
1661                         if (! g_file_test(filename, G_FILE_TEST_EXISTS))
1662                                 SETPTR(filename, g_build_path(G_DIR_SEPARATOR_S, "/usr/local/include", sel, NULL));
1663
1664                         if (! g_file_test(filename, G_FILE_TEST_EXISTS))
1665                                 SETPTR(filename, g_build_path(G_DIR_SEPARATOR_S, "/usr/include", sel, NULL));
1666 #endif
1667                 }
1668
1669                 if (g_file_test(filename, G_FILE_TEST_EXISTS))
1670                         document_open_file(filename, FALSE, NULL, NULL);
1671                 else
1672                 {
1673                         SETPTR(sel, utils_get_utf8_from_locale(sel));
1674                         ui_set_statusbar(TRUE, _("Could not open file %s (File not found)"), sel);
1675                 }
1676
1677                 g_free(filename);
1678                 g_free(sel);
1679         }
1680 }
1681
1682
1683 G_MODULE_EXPORT void on_remove_markers1_activate(GtkMenuItem *menuitem, gpointer user_data)
1684 {
1685         GeanyDocument *doc = document_get_current();
1686         g_return_if_fail(doc != NULL);
1687
1688         sci_marker_delete_all(doc->editor->sci, 0);     /* delete the yellow tag marker */
1689         sci_marker_delete_all(doc->editor->sci, 1);     /* delete user markers */
1690         editor_indicator_clear(doc->editor, GEANY_INDICATOR_SEARCH);
1691 }
1692
1693
1694 G_MODULE_EXPORT void on_load_tags1_activate(GtkMenuItem *menuitem, gpointer user_data)
1695 {
1696         symbols_show_load_tags_dialog();
1697 }
1698
1699
1700 G_MODULE_EXPORT void on_context_action1_activate(GtkMenuItem *menuitem, gpointer user_data)
1701 {
1702         gchar *word, *command;
1703         GError *error = NULL;
1704         GeanyDocument *doc = document_get_current();
1705
1706         g_return_if_fail(doc != NULL);
1707
1708         if (sci_has_selection(doc->editor->sci))
1709         {       /* take selected text if there is a selection */
1710                 word = sci_get_selection_contents(doc->editor->sci);
1711         }
1712         else
1713         {
1714                 word = g_strdup(editor_info.current_word);
1715         }
1716
1717         /* use the filetype specific command if available, fallback to global command otherwise */
1718         if (doc->file_type != NULL &&
1719                 !EMPTY(doc->file_type->context_action_cmd))
1720         {
1721                 command = g_strdup(doc->file_type->context_action_cmd);
1722         }
1723         else
1724         {
1725                 command = g_strdup(tool_prefs.context_action_cmd);
1726         }
1727
1728         /* substitute the wildcard %s and run the command if it is non empty */
1729         if (G_LIKELY(!EMPTY(command)))
1730         {
1731                 utils_str_replace_all(&command, "%s", word);
1732
1733                 if (! g_spawn_command_line_async(command, &error))
1734                 {
1735                         ui_set_statusbar(TRUE, "Context action command failed: %s", error->message);
1736                         g_error_free(error);
1737                 }
1738         }
1739         g_free(word);
1740         g_free(command);
1741 }
1742
1743
1744 G_MODULE_EXPORT void on_menu_toggle_all_additional_widgets1_activate(GtkMenuItem *menuitem, gpointer user_data)
1745 {
1746         static gint hide_all = -1;
1747         GtkCheckMenuItem *msgw = GTK_CHECK_MENU_ITEM(
1748                 ui_lookup_widget(main_widgets.window, "menu_show_messages_window1"));
1749         GtkCheckMenuItem *toolbari = GTK_CHECK_MENU_ITEM(
1750                 ui_lookup_widget(main_widgets.window, "menu_show_toolbar1"));
1751
1752         /* get the initial state (necessary if Geany was closed with hide_all = TRUE) */
1753         if (G_UNLIKELY(hide_all == -1))
1754         {
1755                 if (! gtk_check_menu_item_get_active(msgw) &&
1756                         ! interface_prefs.show_notebook_tabs &&
1757                         ! gtk_check_menu_item_get_active(toolbari))
1758                 {
1759                         hide_all = TRUE;
1760                 }
1761                 else
1762                         hide_all = FALSE;
1763         }
1764
1765         hide_all = ! hide_all; /* toggle */
1766
1767         if (hide_all)
1768         {
1769                 if (gtk_check_menu_item_get_active(msgw))
1770                         gtk_check_menu_item_set_active(msgw, ! gtk_check_menu_item_get_active(msgw));
1771
1772                 interface_prefs.show_notebook_tabs = FALSE;
1773                 gtk_notebook_set_show_tabs(GTK_NOTEBOOK(main_widgets.notebook), interface_prefs.show_notebook_tabs);
1774
1775                 ui_statusbar_showhide(FALSE);
1776
1777                 if (gtk_check_menu_item_get_active(toolbari))
1778                         gtk_check_menu_item_set_active(toolbari, ! gtk_check_menu_item_get_active(toolbari));
1779         }
1780         else
1781         {
1782
1783                 if (! gtk_check_menu_item_get_active(msgw))
1784                         gtk_check_menu_item_set_active(msgw, ! gtk_check_menu_item_get_active(msgw));
1785
1786                 interface_prefs.show_notebook_tabs = TRUE;
1787                 gtk_notebook_set_show_tabs(GTK_NOTEBOOK(main_widgets.notebook), interface_prefs.show_notebook_tabs);
1788
1789                 ui_statusbar_showhide(TRUE);
1790
1791                 if (! gtk_check_menu_item_get_active(toolbari))
1792                         gtk_check_menu_item_set_active(toolbari, ! gtk_check_menu_item_get_active(toolbari));
1793         }
1794 }
1795
1796
1797 void on_toolbutton_forward_activate(GtkAction *menuitem, gpointer user_data)
1798 {
1799         navqueue_go_forward();
1800 }
1801
1802
1803 void on_toolbutton_back_activate(GtkAction *menuitem, gpointer user_data)
1804 {
1805         navqueue_go_back();
1806 }
1807
1808
1809 gboolean on_motion_event(GtkWidget *widget, GdkEventMotion *event, gpointer user_data)
1810 {
1811         if (prefs.auto_focus && ! gtk_widget_has_focus(widget))
1812                 gtk_widget_grab_focus(widget);
1813
1814         return FALSE;
1815 }
1816
1817
1818 static void set_indent_type(GtkCheckMenuItem *menuitem, GeanyIndentType type)
1819 {
1820         GeanyDocument *doc;
1821
1822         if (ignore_callback || ! gtk_check_menu_item_get_active(menuitem))
1823                 return;
1824
1825         doc = document_get_current();
1826         g_return_if_fail(doc != NULL);
1827
1828         editor_set_indent(doc->editor, type, doc->editor->indent_width);
1829         ui_update_statusbar(doc, -1);
1830 }
1831
1832
1833 G_MODULE_EXPORT void on_tabs1_activate(GtkCheckMenuItem *menuitem, gpointer user_data)
1834 {
1835         set_indent_type(menuitem, GEANY_INDENT_TYPE_TABS);
1836 }
1837
1838
1839 G_MODULE_EXPORT void on_spaces1_activate(GtkCheckMenuItem *menuitem, gpointer user_data)
1840 {
1841         set_indent_type(menuitem, GEANY_INDENT_TYPE_SPACES);
1842 }
1843
1844
1845 G_MODULE_EXPORT void on_tabs_and_spaces1_activate(GtkCheckMenuItem *menuitem, gpointer user_data)
1846 {
1847         set_indent_type(menuitem, GEANY_INDENT_TYPE_BOTH);
1848 }
1849
1850
1851 G_MODULE_EXPORT void on_strip_trailing_spaces1_activate(GtkMenuItem *menuitem, gpointer user_data)
1852 {
1853         GeanyDocument *doc;
1854
1855         if (ignore_callback)
1856                 return;
1857
1858         doc = document_get_current();
1859         g_return_if_fail(doc != NULL);
1860
1861         editor_strip_trailing_spaces(doc->editor);
1862 }
1863
1864
1865 G_MODULE_EXPORT void on_page_setup1_activate(GtkMenuItem *menuitem, gpointer user_data)
1866 {
1867         printing_page_setup_gtk();
1868 }
1869
1870
1871 G_MODULE_EXPORT gboolean on_escape_key_press_event(GtkWidget *widget, GdkEventKey *event, gpointer user_data)
1872 {
1873         guint state = event->state & gtk_accelerator_get_default_mod_mask();
1874
1875         /* make pressing escape in the sidebar and toolbar focus the editor */
1876         if (event->keyval == GDK_Escape && state == 0)
1877         {
1878                 keybindings_send_command(GEANY_KEY_GROUP_FOCUS, GEANY_KEYS_FOCUS_EDITOR);
1879                 return TRUE;
1880         }
1881         return FALSE;
1882 }
1883
1884
1885 G_MODULE_EXPORT void on_line_breaking1_activate(GtkMenuItem *menuitem, gpointer user_data)
1886 {
1887         GeanyDocument *doc;
1888
1889         if (ignore_callback)
1890                 return;
1891
1892         doc = document_get_current();
1893         g_return_if_fail(doc != NULL);
1894
1895         doc->editor->line_breaking = !doc->editor->line_breaking;
1896 }
1897
1898
1899 G_MODULE_EXPORT void on_replace_spaces_activate(GtkMenuItem *menuitem, gpointer user_data)
1900 {
1901         GeanyDocument *doc = document_get_current();
1902
1903         g_return_if_fail(doc != NULL);
1904
1905         editor_replace_spaces(doc->editor);
1906 }
1907
1908
1909 G_MODULE_EXPORT void on_search1_activate(GtkMenuItem *menuitem, gpointer user_data)
1910 {
1911         GtkWidget *next_message = ui_lookup_widget(main_widgets.window, "next_message1");
1912         GtkWidget *previous_message = ui_lookup_widget(main_widgets.window, "previous_message1");
1913         gboolean have_messages;
1914
1915         /* enable commands if the messages window has any items */
1916         have_messages = gtk_tree_model_iter_n_children(GTK_TREE_MODEL(msgwindow.store_msg),
1917                 NULL) > 0;
1918
1919         gtk_widget_set_sensitive(next_message, have_messages);
1920         gtk_widget_set_sensitive(previous_message, have_messages);
1921 }
1922
1923
1924 /* simple implementation (vs. close all which doesn't close documents if cancelled),
1925  * if user_data is set, it is the GeanyDocument to keep */
1926 G_MODULE_EXPORT void on_close_other_documents1_activate(GtkMenuItem *menuitem, gpointer user_data)
1927 {
1928         guint i;
1929         GeanyDocument *cur_doc = user_data;
1930
1931         if (cur_doc == NULL)
1932                 cur_doc = document_get_current();
1933
1934         for (i = 0; i < documents_array->len; i++)
1935         {
1936                 GeanyDocument *doc = documents[i];
1937
1938                 if (doc == cur_doc || ! doc->is_valid)
1939                         continue;
1940
1941                 if (! document_close(doc))
1942                         break;
1943         }
1944 }
1945
1946
1947 G_MODULE_EXPORT void on_menu_reload_configuration1_activate(GtkMenuItem *menuitem, gpointer user_data)
1948 {
1949         main_reload_configuration();
1950 }
1951
1952
1953 G_MODULE_EXPORT void on_debug_messages1_activate(GtkMenuItem *menuitem, gpointer user_data)
1954 {
1955         log_show_debug_messages_dialog();
1956 }
1957
1958
1959 G_MODULE_EXPORT void on_send_selection_to_vte1_activate(GtkMenuItem *menuitem, gpointer user_data)
1960 {
1961 #ifdef HAVE_VTE
1962         if (vte_info.have_vte)
1963                 vte_send_selection_to_vte();
1964 #endif
1965 }
1966
1967
1968 G_MODULE_EXPORT gboolean on_window_state_event(GtkWidget *widget, GdkEventWindowState *event, gpointer user_data)
1969 {
1970
1971         if (event->changed_mask & GDK_WINDOW_STATE_FULLSCREEN)
1972         {
1973                 static GtkWidget *menuitem = NULL;
1974
1975                 if (menuitem == NULL)
1976                         menuitem = ui_lookup_widget(widget, "menu_fullscreen1");
1977
1978                 ignore_callback = TRUE;
1979
1980                 ui_prefs.fullscreen = (event->new_window_state & GDK_WINDOW_STATE_FULLSCREEN) ? TRUE : FALSE;
1981                 gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(menuitem), ui_prefs.fullscreen);
1982
1983                 ignore_callback = FALSE;
1984         }
1985         return FALSE;
1986 }
1987
1988
1989 static void show_notebook_page(const gchar *notebook_name, const gchar *page_name)
1990 {
1991         GtkWidget *widget;
1992         GtkNotebook *notebook;
1993
1994         widget = ui_lookup_widget(ui_widgets.prefs_dialog, page_name);
1995         notebook = GTK_NOTEBOOK(ui_lookup_widget(ui_widgets.prefs_dialog, notebook_name));
1996
1997         if (notebook != NULL && widget != NULL)
1998                 gtk_notebook_set_current_page(notebook, gtk_notebook_page_num(notebook, widget));
1999 }
2000
2001
2002 G_MODULE_EXPORT void on_customize_toolbar1_activate(GtkMenuItem *menuitem, gpointer user_data)
2003 {
2004         prefs_show_dialog();
2005
2006         /* select the Interface page */
2007         show_notebook_page("notebook2", "notebook6");
2008         /* select the Toolbar subpage */
2009         show_notebook_page("notebook6", "vbox15");
2010 }
2011
2012
2013 G_MODULE_EXPORT void on_button_customize_toolbar_clicked(GtkButton *button, gpointer user_data)
2014 {
2015         toolbar_configure(GTK_WINDOW(ui_widgets.prefs_dialog));
2016 }
2017
2018
2019 G_MODULE_EXPORT void on_cut_current_lines1_activate(GtkMenuItem *menuitem, gpointer user_data)
2020 {
2021         keybindings_send_command(GEANY_KEY_GROUP_CLIPBOARD, GEANY_KEYS_CLIPBOARD_CUTLINE);
2022 }
2023
2024
2025 G_MODULE_EXPORT void on_copy_current_lines1_activate(GtkMenuItem *menuitem, gpointer user_data)
2026 {
2027         keybindings_send_command(GEANY_KEY_GROUP_CLIPBOARD, GEANY_KEYS_CLIPBOARD_COPYLINE);
2028 }
2029
2030
2031 G_MODULE_EXPORT void on_delete_current_lines1_activate(GtkMenuItem *menuitem, gpointer user_data)
2032 {
2033         keybindings_send_command(GEANY_KEY_GROUP_EDITOR, GEANY_KEYS_EDITOR_DELETELINE);
2034 }
2035
2036
2037 G_MODULE_EXPORT void on_duplicate_line_or_selection1_activate(GtkMenuItem *menuitem, gpointer user_data)
2038 {
2039         keybindings_send_command(GEANY_KEY_GROUP_EDITOR, GEANY_KEYS_EDITOR_DUPLICATELINE);
2040 }
2041
2042
2043 G_MODULE_EXPORT void on_select_current_lines1_activate(GtkMenuItem *menuitem, gpointer user_data)
2044 {
2045         keybindings_send_command(GEANY_KEY_GROUP_SELECT, GEANY_KEYS_SELECT_LINE);
2046 }
2047
2048
2049 G_MODULE_EXPORT void on_select_current_paragraph1_activate(GtkMenuItem *menuitem, gpointer user_data)
2050 {
2051         keybindings_send_command(GEANY_KEY_GROUP_SELECT, GEANY_KEYS_SELECT_PARAGRAPH);
2052 }
2053
2054
2055 G_MODULE_EXPORT void on_insert_alternative_white_space1_activate(GtkMenuItem *menuitem, gpointer user_data)
2056 {
2057         keybindings_send_command(GEANY_KEY_GROUP_INSERT, GEANY_KEYS_INSERT_ALTWHITESPACE);
2058 }
2059
2060
2061 G_MODULE_EXPORT void on_go_to_next_marker1_activate(GtkMenuItem *menuitem, gpointer user_data)
2062 {
2063         keybindings_send_command(GEANY_KEY_GROUP_GOTO, GEANY_KEYS_GOTO_NEXTMARKER);
2064 }
2065
2066
2067 G_MODULE_EXPORT void on_go_to_previous_marker1_activate(GtkMenuItem *menuitem, gpointer user_data)
2068 {
2069         keybindings_send_command(GEANY_KEY_GROUP_GOTO, GEANY_KEYS_GOTO_PREVIOUSMARKER);
2070 }
2071
2072
2073 G_MODULE_EXPORT void on_reflow_lines_block1_activate(GtkMenuItem *menuitem, gpointer user_data)
2074 {
2075         keybindings_send_command(GEANY_KEY_GROUP_FORMAT, GEANY_KEYS_FORMAT_REFLOWPARAGRAPH);
2076 }
2077
2078
2079 G_MODULE_EXPORT void on_move_lines_up1_activate(GtkMenuItem *menuitem, gpointer user_data)
2080 {
2081         keybindings_send_command(GEANY_KEY_GROUP_EDITOR, GEANY_KEYS_EDITOR_MOVELINEUP);
2082 }
2083
2084
2085 G_MODULE_EXPORT void on_move_lines_down1_activate(GtkMenuItem *menuitem, gpointer user_data)
2086 {
2087         keybindings_send_command(GEANY_KEY_GROUP_EDITOR, GEANY_KEYS_EDITOR_MOVELINEDOWN);
2088 }
2089
2090
2091 G_MODULE_EXPORT void on_smart_line_indent1_activate(GtkMenuItem *menuitem, gpointer user_data)
2092 {
2093         keybindings_send_command(GEANY_KEY_GROUP_FORMAT, GEANY_KEYS_FORMAT_AUTOINDENT);
2094 }
2095
2096
2097 G_MODULE_EXPORT void on_plugin_preferences1_activate(GtkMenuItem *menuitem, gpointer user_data)
2098 {
2099 #ifdef HAVE_PLUGINS
2100         plugin_show_configure(NULL);
2101 #endif
2102 }
2103
2104
2105 G_MODULE_EXPORT void on_indent_width_activate(GtkMenuItem *menuitem, gpointer user_data)
2106 {
2107         GeanyDocument *doc;
2108         gchar *label;
2109         gint width;
2110
2111         if (ignore_callback)
2112                 return;
2113
2114         label = ui_menu_item_get_text(menuitem);
2115         width = atoi(label);
2116         g_free(label);
2117
2118         doc = document_get_current();
2119         if (doc != NULL && width > 0)
2120                 editor_set_indent_width(doc->editor, width);
2121 }
2122
2123
2124 G_MODULE_EXPORT void on_reset_indentation1_activate(GtkMenuItem *menuitem, gpointer user_data)
2125 {
2126         guint i;
2127
2128         foreach_document(i)
2129                 document_apply_indent_settings(documents[i]);
2130
2131         ui_update_statusbar(NULL, -1);
2132         ui_document_show_hide(NULL);
2133 }
2134
2135
2136 G_MODULE_EXPORT void on_mark_all1_activate(GtkMenuItem *menuitem, gpointer user_data)
2137 {
2138         keybindings_send_command(GEANY_KEY_GROUP_SEARCH, GEANY_KEYS_SEARCH_MARKALL);
2139 }
2140
2141
2142 G_MODULE_EXPORT void on_detect_type_from_file_activate(GtkMenuItem *menuitem, gpointer user_data)
2143 {
2144         GeanyDocument *doc = document_get_current();
2145         GeanyIndentType type;
2146
2147         if (doc != NULL && document_detect_indent_type(doc, &type))
2148         {
2149                 editor_set_indent_type(doc->editor, type);
2150                 ui_document_show_hide(doc);
2151         }
2152 }
2153
2154
2155 G_MODULE_EXPORT void on_detect_width_from_file_activate(GtkMenuItem *menuitem, gpointer user_data)
2156 {
2157         GeanyDocument *doc = document_get_current();
2158         gint width;
2159
2160         if (doc != NULL && document_detect_indent_width(doc, &width))
2161         {
2162                 editor_set_indent_width(doc->editor, width);
2163                 ui_document_show_hide(doc);
2164         }
2165 }