src/callbacks.c

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