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