« back to all changes in this revision
Viewing changes to src/keybindings.c
- browse files at revision 13
- compare with another revision
- download diff
- download tarball
- view history from revision 13
- Committer: Bazaar Package Importer
- Author(s): Gauvain Pocentek
- Date: 2009-01-01 18:40:50 UTC
- mfrom: (1.1.8 upstream) (3.1.2 experimental)
- Revision ID: james.westby@ubuntu.com-20090101184050-u635kualu7amyt4a
Tags: 0.15-1ubuntu1
* Merge from debian experimental, remaining change:
- patches/20_add_debdiff_as_diff_type.dpatch: Also recognize .dpatch files
as diff's
- debian/geany.xpm: Replace icon with a .xpm of the new one
- patches/20_add_debdiff_as_diff_type.dpatch: Also recognize .dpatch files
as diff's
- debian/geany.xpm: Replace icon with a .xpm of the new one
- files added:
- data/filetypes.f77
- files removed:
- doc/images/pref_dialog_display.png
- files modified:
- COPYING
added
removed
src/keybindings.c
18
18
* along with this program; if not, write to the Free Software
19
19
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
20
20
*
21
* $Id: keybindings.c 2442 2008-04-03 15:38:16Z eht16 $
21
* $Id: keybindings.c 3110 2008-10-17 16:51:22Z eht16 $
22
22
*/
23
23
24
24
/*
46
46
#include "vte.h"
47
47
48
48
49
GPtrArray *keybinding_groups; /* array of KeyBindingGroup pointers */
49
GPtrArray *keybinding_groups; /* array of GeanyKeyGroup pointers */
50
50
51
51
/* keyfile group name for non-plugin KB groups */
52
52
const gchar keybindings_keyfile_group_name[] = "Bindings";
53
53
54
static gboolean ignore_keybinding = FALSE;
55
54
56
static GtkAccelGroup *kb_accel_group = NULL;
55
57
static const gboolean swap_alt_tab_order = FALSE;
56
58
65
67
static void cb_func_insert_action(guint key_id);
66
68
static void cb_func_search_action(guint key_id);
67
69
static void cb_func_goto_action(guint key_id);
70
static void cb_func_switch_action(guint key_id);
68
71
static void cb_func_clipboard(guint key_id);
69
72
static void cb_func_build_action(guint key_id);
73
static void cb_func_document_action(guint key_id);
70
74
71
75
/* TODO: refactor individual callbacks per group */
72
76
static void cb_func_menu_help(guint key_id);
78
82
static void cb_func_menu_zoomin(guint key_id);
79
83
static void cb_func_menu_zoomout(guint key_id);
80
84
81
static void cb_func_menu_replacetabs(guint key_id);
82
static void cb_func_menu_foldall(guint key_id);
83
static void cb_func_menu_unfoldall(guint key_id);
84
static void cb_func_reloadtaglist(guint key_id);
85
86
85
static void cb_func_menu_opencolorchooser(guint key_id);
87
86
88
static void cb_func_switch_editor(guint key_id);
89
static void cb_func_switch_scribble(guint key_id);
90
static void cb_func_switch_vte(guint key_id);
91
static void cb_func_switch_search_bar(guint key_id);
92
static void cb_func_switch_sidebar(guint key_id);
93
87
static void cb_func_switch_tableft(guint key_id);
94
88
static void cb_func_switch_tabright(guint key_id);
95
89
static void cb_func_switch_tablastused(guint key_id);
97
91
static void cb_func_toggle_sidebar(guint key_id);
98
92
99
93
static void add_popup_menu_accels(void);
100
static void apply_kb_accel(KeyBinding *kb);
101
102
103
/** Simple convenience function to fill a KeyBinding struct item */
104
void keybindings_set_item(KeyBindingGroup *group, gsize key_id,
105
KeyCallback callback, guint key, GdkModifierType mod,
94
static void apply_kb_accel(GeanyKeyGroup *group, GeanyKeyBinding *kb, gpointer user_data);
95
96
97
/* This is used to set default keybindings on startup but at this point we don't want to
98
* assign the keybinding to the menu_item (apply_kb_accel) otherwise it can't be overridden
99
* by user keybindings anymore */
100
/** Simple convenience function to fill a GeanyKeyBinding struct item.
101
* @param group
102
* @param key_id
103
* @param callback
104
* @param key
105
* @param mod
106
* @param name
107
* @param label
108
* @param menu_item */
109
void keybindings_set_item(GeanyKeyGroup *group, gsize key_id,
110
GeanyKeyCallback callback, guint key, GdkModifierType mod,
106
111
gchar *name, gchar *label, GtkWidget *menu_item)
107
112
{
108
KeyBinding *kb;
113
GeanyKeyBinding *kb;
109
114
110
115
g_assert(key_id < group->count);
111
116
117
122
kb->mods = mod;
118
123
kb->callback = callback;
119
124
kb->menu_item = menu_item;
120
121
apply_kb_accel(kb);
122
125
}
123
126
124
127
125
static KeyBindingGroup *add_kb_group(KeyBindingGroup *group,
126
const gchar *name, const gchar *label, gsize count, KeyBinding *keys)
128
static GeanyKeyGroup *add_kb_group(GeanyKeyGroup *group,
129
const gchar *name, const gchar *label, gsize count, GeanyKeyBinding *keys)
127
130
{
128
131
g_ptr_array_add(keybinding_groups, group);
129
132
137
140
138
141
/* Lookup a widget in the main window */
139
142
#define LW(widget_name) \
140
lookup_widget(app->window, G_STRINGIFY(widget_name))
143
lookup_widget(main_widgets.window, G_STRINGIFY(widget_name))
141
144
142
145
/* Expansion for group_id = FILE:
143
* static KeyBinding FILE_keys[GEANY_KEYS_FILE_COUNT]; */
146
* static GeanyKeyBinding FILE_keys[GEANY_KEYS_FILE_COUNT]; */
144
147
#define DECLARE_KEYS(group_id) \
145
static KeyBinding group_id ## _keys[GEANY_KEYS_ ## group_id ## _COUNT]
148
static GeanyKeyBinding group_id ## _keys[GEANY_KEYS_ ## group_id ## _COUNT]
146
149
147
150
/* Expansion for group_id = FILE:
148
151
* add_kb_group(&groups[GEANY_KEY_GROUP_FILE], NULL, _("File menu"),
156
159
* set in add_popup_menu_accels(). */
157
160
static void init_default_kb(void)
158
161
{
159
static KeyBindingGroup groups[GEANY_KEY_GROUP_COUNT];
160
KeyBindingGroup *group;
162
static GeanyKeyGroup groups[GEANY_KEY_GROUP_COUNT];
163
GeanyKeyGroup *group;
161
164
DECLARE_KEYS(FILE);
162
165
DECLARE_KEYS(PROJECT);
163
166
DECLARE_KEYS(EDITOR);
300
303
GDK_d, GDK_SHIFT_MASK | GDK_MOD1_MASK, "menu_insert_date", _("Insert date"),
301
304
LW(insert_date_custom1));
302
305
keybindings_set_item(group, GEANY_KEYS_INSERT_ALTWHITESPACE, cb_func_insert_action,
303
0, 0, "edit_insertwhitespace", _("Insert alternative whitespace"), NULL);
306
0, 0, "edit_insertwhitespace", _("Insert alternative white space"), NULL);
304
307
305
308
group = ADD_KB_GROUP(SETTINGS, _("Settings"));
306
309
328
331
LW(find_in_files1));
329
332
keybindings_set_item(group, GEANY_KEYS_SEARCH_NEXTMESSAGE, cb_func_search_action,
330
333
0, 0, "menu_nextmessage", _("Next Message"), LW(next_message1));
334
keybindings_set_item(group, GEANY_KEYS_SEARCH_PREVIOUSMESSAGE, cb_func_search_action,
335
0, 0, "menu_previousmessage", _("Previous Message"), LW(previous_message1));
331
336
keybindings_set_item(group, GEANY_KEYS_SEARCH_FINDUSAGE, cb_func_search_action,
332
337
0, 0, "popup_findusage", _("Find Usage"), NULL);
338
keybindings_set_item(group, GEANY_KEYS_SEARCH_FINDDOCUMENTUSAGE, cb_func_search_action,
339
0, 0, "popup_finddocumentusage", _("Find Document Usage"), NULL);
333
340
334
341
group = ADD_KB_GROUP(GOTO, _("Go to"));
335
342
355
362
0, 0, "popup_gototagdefinition", _("Go to Tag Definition"), NULL);
356
363
keybindings_set_item(group, GEANY_KEYS_GOTO_TAGDECLARATION, cb_func_goto_action,
357
364
0, 0, "popup_gototagdeclaration", _("Go to Tag Declaration"), NULL);
365
keybindings_set_item(group, GEANY_KEYS_GOTO_LINESTART, cb_func_goto_action,
366
GDK_Home, 0, "edit_gotolinestart", _("Go to Start of Line"), NULL);
367
keybindings_set_item(group, GEANY_KEYS_GOTO_LINEEND, cb_func_goto_action,
368
GDK_End, 0, "edit_gotolineend", _("Go to End of Line"), NULL);
369
keybindings_set_item(group, GEANY_KEYS_GOTO_PREVWORDSTART, cb_func_goto_action,
370
GDK_slash, GDK_CONTROL_MASK, "edit_prevwordstart", _("Go to Previous Word Part"), NULL);
371
keybindings_set_item(group, GEANY_KEYS_GOTO_NEXTWORDSTART, cb_func_goto_action,
372
GDK_backslash, GDK_CONTROL_MASK, "edit_nextwordstart", _("Go to Next Word Part"), NULL);
358
373
359
374
group = ADD_KB_GROUP(VIEW, _("View"));
360
375
375
390
376
391
group = ADD_KB_GROUP(FOCUS, _("Focus"));
377
392
378
keybindings_set_item(group, GEANY_KEYS_FOCUS_EDITOR, cb_func_switch_editor,
393
keybindings_set_item(group, GEANY_KEYS_FOCUS_EDITOR, cb_func_switch_action,
379
394
GDK_F2, 0, "switch_editor", _("Switch to Editor"), NULL);
380
keybindings_set_item(group, GEANY_KEYS_FOCUS_SCRIBBLE, cb_func_switch_scribble,
395
keybindings_set_item(group, GEANY_KEYS_FOCUS_SCRIBBLE, cb_func_switch_action,
381
396
GDK_F6, 0, "switch_scribble", _("Switch to Scribble"), NULL);
382
keybindings_set_item(group, GEANY_KEYS_FOCUS_VTE, cb_func_switch_vte,
397
keybindings_set_item(group, GEANY_KEYS_FOCUS_VTE, cb_func_switch_action,
383
398
GDK_F4, 0, "switch_vte", _("Switch to VTE"), NULL);
384
keybindings_set_item(group, GEANY_KEYS_FOCUS_SEARCHBAR, cb_func_switch_search_bar,
399
keybindings_set_item(group, GEANY_KEYS_FOCUS_SEARCHBAR, cb_func_switch_action,
385
400
GDK_F7, 0, "switch_search_bar", _("Switch to Search Bar"), NULL);
386
keybindings_set_item(group, GEANY_KEYS_FOCUS_SIDEBAR, cb_func_switch_sidebar,
401
keybindings_set_item(group, GEANY_KEYS_FOCUS_SIDEBAR, cb_func_switch_action,
387
402
0, 0, "switch_sidebar", _("Switch to Sidebar"), NULL);
403
keybindings_set_item(group, GEANY_KEYS_FOCUS_COMPILER, cb_func_switch_action,
404
0, 0, "switch_compiler", _("Switch to Compiler"), NULL);
388
405
389
406
group = ADD_KB_GROUP(NOTEBOOK, _("Notebook tab"));
390
407
405
422
406
423
group = ADD_KB_GROUP(DOCUMENT, _("Document"));
407
424
408
keybindings_set_item(group, GEANY_KEYS_DOCUMENT_REPLACETABS, cb_func_menu_replacetabs,
425
keybindings_set_item(group, GEANY_KEYS_DOCUMENT_LINEWRAP, cb_func_document_action,
426
0, 0, "menu_linewrap", _("Toggle Line wrapping"), LW(menu_line_wrapping1));
427
keybindings_set_item(group, GEANY_KEYS_DOCUMENT_LINEBREAK, cb_func_document_action,
428
0, 0, "menu_linebreak", _("Toggle Line breaking"), LW(line_breaking1));
429
keybindings_set_item(group, GEANY_KEYS_DOCUMENT_REPLACETABS, cb_func_document_action,
409
430
0, 0, "menu_replacetabs", _("Replace tabs by space"), LW(menu_replace_tabs));
410
keybindings_set_item(group, GEANY_KEYS_DOCUMENT_FOLDALL, cb_func_menu_foldall,
431
keybindings_set_item(group, GEANY_KEYS_DOCUMENT_REPLACESPACES, cb_func_document_action,
432
0, 0, "menu_replacespaces", _("Replace spaces by tabs"), LW(menu_replace_spaces));
433
keybindings_set_item(group, GEANY_KEYS_DOCUMENT_TOGGLEFOLD, cb_func_document_action,
434
0, 0, "menu_togglefold", _("Toggle current fold"), NULL);
435
keybindings_set_item(group, GEANY_KEYS_DOCUMENT_FOLDALL, cb_func_document_action,
411
436
0, 0, "menu_foldall", _("Fold all"), LW(menu_fold_all1));
412
keybindings_set_item(group, GEANY_KEYS_DOCUMENT_UNFOLDALL, cb_func_menu_unfoldall,
437
keybindings_set_item(group, GEANY_KEYS_DOCUMENT_UNFOLDALL, cb_func_document_action,
413
438
0, 0, "menu_unfoldall", _("Unfold all"), LW(menu_unfold_all1));
414
keybindings_set_item(group, GEANY_KEYS_DOCUMENT_RELOADTAGLIST, cb_func_reloadtaglist,
439
keybindings_set_item(group, GEANY_KEYS_DOCUMENT_RELOADTAGLIST, cb_func_document_action,
415
440
GDK_r, GDK_SHIFT_MASK | GDK_CONTROL_MASK, "reloadtaglist", _("Reload symbol list"), NULL);
416
441
417
442
group = ADD_KB_GROUP(BUILD, _("Build"));
429
454
0, 0, "build_makeobject", _("Make object"), NULL);
430
455
keybindings_set_item(group, GEANY_KEYS_BUILD_NEXTERROR, cb_func_build_action,
431
456
0, 0, "build_nexterror", _("Next error"), NULL);
457
keybindings_set_item(group, GEANY_KEYS_BUILD_PREVIOUSERROR, cb_func_build_action,
458
0, 0, "build_previouserror", _("Previous error"), NULL);
432
459
keybindings_set_item(group, GEANY_KEYS_BUILD_RUN, cb_func_build_action,
433
460
GDK_F5, 0, "build_run", _("Run"), NULL);
434
461
keybindings_set_item(group, GEANY_KEYS_BUILD_RUN2, cb_func_build_action,
456
483
457
484
init_default_kb();
458
485
459
gtk_window_add_accel_group(GTK_WINDOW(app->window), kb_accel_group);
460
}
461
462
463
typedef void (*KBItemCallback) (KeyBindingGroup *group, KeyBinding *kb, gpointer user_data);
486
gtk_window_add_accel_group(GTK_WINDOW(main_widgets.window), kb_accel_group);
487
}
488
489
490
static void apply_kb_accel(GeanyKeyGroup *group, GeanyKeyBinding *kb, gpointer user_data)
491
{
492
if (kb->key != 0 && kb->menu_item)
493
{
494
gtk_widget_add_accelerator(kb->menu_item, "activate", kb_accel_group,
495
kb->key, kb->mods, GTK_ACCEL_VISIBLE);
496
}
497
}
498
499
500
typedef void (*KBItemCallback) (GeanyKeyGroup *group, GeanyKeyBinding *kb, gpointer user_data);
464
501
465
502
static void keybindings_foreach(KBItemCallback cb, gpointer user_data)
466
503
{
468
505
469
506
for (g = 0; g < keybinding_groups->len; g++)
470
507
{
471
KeyBindingGroup *group = g_ptr_array_index(keybinding_groups, g);
508
GeanyKeyGroup *group = g_ptr_array_index(keybinding_groups, g);
472
509
473
510
for (i = 0; i < group->count; i++)
474
511
{
475
KeyBinding *kb = &group->keys[i];
512
GeanyKeyBinding *kb = &group->keys[i];
476
513
477
514
cb(group, kb, user_data);
478
515
}
480
517
}
481
518
482
519
483
static void apply_kb_accel(KeyBinding *kb)
484
{
485
if (kb->key != 0 && kb->menu_item)
486
gtk_widget_add_accelerator(kb->menu_item, "activate", kb_accel_group,
487
kb->key, kb->mods, GTK_ACCEL_VISIBLE);
488
}
489
490
491
static void load_kb(KeyBindingGroup *group, KeyBinding *kb, gpointer user_data)
520
static void load_kb(GeanyKeyGroup *group, GeanyKeyBinding *kb, gpointer user_data)
492
521
{
493
522
GKeyFile *config = user_data;
494
523
gchar *val;
501
530
gtk_accelerator_parse(val, &key, &mods);
502
531
kb->key = key;
503
532
kb->mods = mods;
504
505
apply_kb_accel(kb);
506
533
}
507
534
g_free(val);
508
535
}
527
554
{
528
555
load_user_kb();
529
556
add_popup_menu_accels();
557
558
/* set menu accels now, after user keybindings have been read and processed
559
* if we would set it before, user keybindings could not override menu item's default
560
* keybindings */
561
keybindings_foreach(apply_kb_accel, NULL);
530
562
}
531
563
532
564
533
static void add_menu_accel(KeyBindingGroup *group, guint kb_id,
565
static void add_menu_accel(GeanyKeyGroup *group, guint kb_id,
534
566
GtkAccelGroup *accel_group, GtkWidget *menuitem)
535
567
{
536
KeyBinding *kb = &group->keys[kb_id];
568
GeanyKeyBinding *kb = &group->keys[kb_id];
537
569
538
570
if (kb->key != 0)
539
571
gtk_widget_add_accelerator(menuitem, "activate", accel_group,
542
574
543
575
544
576
#define GEANY_ADD_POPUP_ACCEL(kb_id, wid) \
545
add_menu_accel(group, kb_id, accel_group, lookup_widget(app->popup_menu, G_STRINGIFY(wid)))
577
add_menu_accel(group, kb_id, accel_group, lookup_widget(main_widgets.editor_menu, G_STRINGIFY(wid)))
546
578
547
579
/* set the menu item accelerator shortcuts (just for visibility, they are handled anyway) */
548
580
static void add_popup_menu_accels(void)
549
581
{
550
582
GtkAccelGroup *accel_group = gtk_accel_group_new();
551
KeyBindingGroup *group;
583
GeanyKeyGroup *group;
552
584
553
585
group = g_ptr_array_index(keybinding_groups, GEANY_KEY_GROUP_EDITOR);
554
586
GEANY_ADD_POPUP_ACCEL(GEANY_KEYS_EDITOR_UNDO, undo1);
567
599
568
600
group = g_ptr_array_index(keybinding_groups, GEANY_KEY_GROUP_SEARCH);
569
601
GEANY_ADD_POPUP_ACCEL(GEANY_KEYS_SEARCH_FINDUSAGE, find_usage1);
602
GEANY_ADD_POPUP_ACCEL(GEANY_KEYS_SEARCH_FINDDOCUMENTUSAGE, find_document_usage1);
570
603
571
604
group = g_ptr_array_index(keybinding_groups, GEANY_KEY_GROUP_GOTO);
572
605
GEANY_ADD_POPUP_ACCEL(GEANY_KEYS_GOTO_LINE, go_to_line);
583
616
584
617
/* the build menu items are set if the build menus are created */
585
618
586
gtk_window_add_accel_group(GTK_WINDOW(app->window), accel_group);
619
gtk_window_add_accel_group(GTK_WINDOW(main_widgets.window), accel_group);
587
620
}
588
621
589
622
590
static void set_keyfile_kb(KeyBindingGroup *group, KeyBinding *kb, gpointer user_data)
623
static void set_keyfile_kb(GeanyKeyGroup *group, GeanyKeyBinding *kb, gpointer user_data)
591
624
{
592
625
GKeyFile *config = user_data;
593
626
gchar *val;
629
662
}
630
663
631
664
632
static void get_shortcut_labels_text(GString **text_names_str, GString **text_keys_str)
665
static void fill_shortcut_labels_treeview(GtkWidget *tree)
633
666
{
634
667
gsize g, i;
635
GString *text_names = g_string_sized_new(600);
636
GString *text_keys = g_string_sized_new(600);
668
gchar *shortcut;
669
GeanyKeyBinding *kb;
670
GeanyKeyGroup *group;
671
GtkListStore *store;
672
GtkTreeIter iter;
637
673
638
*text_names_str = text_names;
639
*text_keys_str = text_keys;
674
store = gtk_list_store_new(3, G_TYPE_STRING, G_TYPE_STRING, PANGO_TYPE_WEIGHT);
640
675
641
676
for (g = 0; g < keybinding_groups->len; g++)
642
677
{
643
KeyBindingGroup *group = g_ptr_array_index(keybinding_groups, g);
644
645
if (g == 0)
646
{
647
g_string_append_printf(text_names, "<b>%s</b>\n", group->label);
648
g_string_append(text_keys, "\n");
649
}
650
else
651
{
652
g_string_append_printf(text_names, "\n<b>%s</b>\n", group->label);
653
g_string_append(text_keys, "\n\n");
654
}
678
group = g_ptr_array_index(keybinding_groups, g);
679
680
if (g > 0)
681
{
682
gtk_list_store_append(store, &iter);
683
gtk_list_store_set(store, &iter, -1);
684
}
685
686
gtk_list_store_append(store, &iter);
687
gtk_list_store_set(store, &iter, 0, group->label, 2, PANGO_WEIGHT_BOLD, -1);
655
688
656
689
for (i = 0; i < group->count; i++)
657
690
{
658
KeyBinding *kb = &group->keys[i];
659
gchar *shortcut;
660
691
kb = &group->keys[i];
661
692
shortcut = gtk_accelerator_get_label(kb->key, kb->mods);
662
g_string_append(text_names, kb->label);
663
g_string_append(text_names, "\n");
664
g_string_append(text_keys, shortcut);
665
g_string_append(text_keys, "\n");
693
694
gtk_list_store_append(store, &iter);
695
gtk_list_store_set(store, &iter, 0, kb->label, 1, shortcut, 2, PANGO_WEIGHT_NORMAL, -1);
696
666
697
g_free(shortcut);
667
698
}
668
699
}
700
701
gtk_tree_view_set_model(GTK_TREE_VIEW(tree), GTK_TREE_MODEL(store));
702
g_object_unref(store);
669
703
}
670
704
671
705
672
void keybindings_show_shortcuts(void)
706
static GtkWidget *create_dialog(void)
673
707
{
674
GtkWidget *dialog, *hbox, *label1, *label2, *label3, *swin, *vbox;
675
GString *text_names;
676
GString *text_keys;
677
gint height, response;
708
GtkWidget *dialog, *tree, *label, *swin, *vbox;
709
GtkCellRenderer *text_renderer;
710
GtkTreeViewColumn *column;
711
gint height;
678
712
679
dialog = gtk_dialog_new_with_buttons(_("Keyboard Shortcuts"), GTK_WINDOW(app->window),
713
dialog = gtk_dialog_new_with_buttons(_("Keyboard Shortcuts"), GTK_WINDOW(main_widgets.window),
680
714
GTK_DIALOG_DESTROY_WITH_PARENT,
681
715
GTK_STOCK_EDIT, GTK_RESPONSE_APPLY,
682
716
GTK_STOCK_CLOSE, GTK_RESPONSE_CANCEL, NULL);
689
723
690
724
gtk_dialog_set_default_response(GTK_DIALOG(dialog), GTK_RESPONSE_CANCEL);
691
725
692
label3 = gtk_label_new(_("The following keyboard shortcuts are configurable:"));
693
gtk_misc_set_alignment(GTK_MISC(label3), 0, 0.5);
694
695
hbox = gtk_hbox_new(FALSE, 6);
696
697
label1 = gtk_label_new(NULL);
698
699
label2 = gtk_label_new(NULL);
700
701
get_shortcut_labels_text(&text_names, &text_keys);
702
703
gtk_label_set_markup(GTK_LABEL(label1), text_names->str);
704
gtk_label_set_text(GTK_LABEL(label2), text_keys->str);
705
706
g_string_free(text_names, TRUE);
707
g_string_free(text_keys, TRUE);
708
709
gtk_container_add(GTK_CONTAINER(hbox), label1);
710
gtk_container_add(GTK_CONTAINER(hbox), label2);
726
label = gtk_label_new(_("The following keyboard shortcuts are configurable:"));
727
gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5);
728
729
tree = gtk_tree_view_new();
730
gtk_tree_view_set_rules_hint(GTK_TREE_VIEW(tree), TRUE);
731
gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(tree), FALSE);
732
733
text_renderer = gtk_cell_renderer_text_new();
734
/* we can't use "weight-set", see http://bugzilla.gnome.org/show_bug.cgi?id=355214 */
735
column = gtk_tree_view_column_new_with_attributes(
736
NULL, text_renderer, "text", 0, "weight", 2, NULL);
737
gtk_tree_view_append_column(GTK_TREE_VIEW(tree), column);
738
739
text_renderer = gtk_cell_renderer_text_new();
740
column = gtk_tree_view_column_new_with_attributes(NULL, text_renderer, "text", 1, NULL);
741
gtk_tree_view_append_column(GTK_TREE_VIEW(tree), column);
742
743
fill_shortcut_labels_treeview(tree);
711
744
712
745
swin = gtk_scrolled_window_new(NULL, NULL);
713
746
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(swin), GTK_POLICY_NEVER,
714
747
GTK_POLICY_AUTOMATIC);
715
gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(swin), hbox);
748
gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(swin), GTK_SHADOW_ETCHED_IN);
749
gtk_container_add(GTK_CONTAINER(swin), tree);
716
750
717
gtk_box_pack_start(GTK_BOX(vbox), label3, FALSE, FALSE, 6);
751
gtk_box_pack_start(GTK_BOX(vbox), label, FALSE, FALSE, 6);
718
752
gtk_box_pack_start(GTK_BOX(vbox), swin, TRUE, TRUE, 0);
719
720
gtk_widget_show_all(dialog);
721
response = gtk_dialog_run(GTK_DIALOG(dialog));
753
return dialog;
754
}
755
756
757
/* non-modal keyboard shortcuts dialog, so user can edit whilst seeing the shortcuts */
758
static GtkWidget *key_dialog = NULL;
759
760
static void on_dialog_response(GtkWidget *dialog, gint response, gpointer user_data)
761
{
722
762
if (response == GTK_RESPONSE_APPLY)
723
763
{
724
764
GtkWidget *wid;
734
774
gtk_notebook_set_current_page(nb, gtk_notebook_page_num(nb, wid));
735
775
}
736
776
}
737
738
777
gtk_widget_destroy(dialog);
778
key_dialog = NULL;
779
}
780
781
782
void keybindings_show_shortcuts(void)
783
{
784
if (key_dialog)
785
gtk_widget_destroy(key_dialog); /* in case the key_dialog is still visible */
786
787
key_dialog = create_dialog();
788
g_signal_connect(key_dialog, "response", G_CALLBACK(on_dialog_response), NULL);
789
gtk_widget_show_all(key_dialog);
739
790
}
740
791
741
792
745
796
if (state & GDK_MOD1_MASK && keyval >= GDK_0 && keyval <= GDK_9)
746
797
{
747
798
gint page = keyval - GDK_0 - 1;
748
gint npages = gtk_notebook_get_n_pages(GTK_NOTEBOOK(app->notebook));
799
gint npages = gtk_notebook_get_n_pages(GTK_NOTEBOOK(main_widgets.notebook));
749
800
750
801
/* alt-0 is for the rightmost tab */
751
802
if (keyval == GDK_0)
752
803
page = npages - 1;
753
804
/* invert the order if tabs are added on the other side */
754
if (swap_alt_tab_order && ! prefs.tab_order_ltr)
805
if (swap_alt_tab_order && ! file_prefs.tab_order_ltr)
755
806
page = (npages - 1) - page;
756
807
757
gtk_notebook_set_current_page(GTK_NOTEBOOK(app->notebook), page);
808
gtk_notebook_set_current_page(GTK_NOTEBOOK(main_widgets.notebook), page);
758
809
return TRUE;
759
810
}
760
811
if (keyval == GDK_Page_Up || keyval == GDK_Page_Down)
763
814
if (state == (GDK_CONTROL_MASK | GDK_SHIFT_MASK))
764
815
{
765
816
if (keyval == GDK_Page_Up)
766
gtk_notebook_set_current_page(GTK_NOTEBOOK(app->notebook), 0);
817
gtk_notebook_set_current_page(GTK_NOTEBOOK(main_widgets.notebook), 0);
767
818
if (keyval == GDK_Page_Down)
768
gtk_notebook_set_current_page(GTK_NOTEBOOK(app->notebook),
769
gtk_notebook_get_n_pages(GTK_NOTEBOOK(app->notebook)) - 1);
819
gtk_notebook_set_current_page(GTK_NOTEBOOK(main_widgets.notebook),
820
gtk_notebook_get_n_pages(GTK_NOTEBOOK(main_widgets.notebook)) - 1);
770
821
return TRUE;
771
822
}
772
823
}
778
829
* return FALSE if no completion occurs, so the tab or space is handled normally. */
779
830
static gboolean check_snippet_completion(guint keyval, guint state)
780
831
{
781
KeyBinding *kb = keybindings_lookup_item(GEANY_KEY_GROUP_EDITOR,
832
GeanyKeyBinding *kb = keybindings_lookup_item(GEANY_KEY_GROUP_EDITOR,
782
833
GEANY_KEYS_EDITOR_COMPLETESNIPPET);
783
834
784
835
if (kb->key == keyval && kb->mods == state)
785
836
{
786
gint idx = document_get_cur_idx();
787
GtkWidget *focusw = gtk_window_get_focus(GTK_WINDOW(app->window));
837
GeanyDocument *doc = document_get_current();
838
GtkWidget *focusw = gtk_window_get_focus(GTK_WINDOW(main_widgets.window));
788
839
789
840
/* keybinding only valid when scintilla widget has focus */
790
if (DOC_IDX_VALID(idx) && focusw == GTK_WIDGET(doc_list[idx].sci))
841
if (doc != NULL && focusw == GTK_WIDGET(doc->editor->sci))
791
842
{
792
ScintillaObject *sci = doc_list[idx].sci;
843
ScintillaObject *sci = doc->editor->sci;
793
844
gint pos = sci_get_current_position(sci);
794
845
795
846
if (editor_prefs.complete_snippets)
796
return editor_complete_snippet(idx, pos);
847
return editor_complete_snippet(doc->editor, pos);
797
848
}
798
849
}
799
850
return FALSE;
801
852
802
853
803
854
#ifdef HAVE_VTE
855
static gboolean on_menu_expose_event(GtkWidget *widget, GdkEventExpose *event,
856
gpointer user_data)
857
{
858
if (!GTK_WIDGET_SENSITIVE(widget))
859
gtk_widget_set_sensitive(GTK_WIDGET(widget), TRUE);
860
return FALSE;
861
}
862
863
804
864
static gboolean set_sensitive(gpointer widget)
805
865
{
806
866
gtk_widget_set_sensitive(GTK_WIDGET(widget), TRUE);
815
875
816
876
if (! vc->enable_bash_keys)
817
877
return FALSE;
818
if (gtk_window_get_focus(GTK_WINDOW(app->window)) != vc->vte)
878
if (gtk_window_get_focus(GTK_WINDOW(main_widgets.window)) != vc->vte)
819
879
return FALSE;
820
880
/* prevent menubar flickering: */
821
881
if (state == GDK_SHIFT_MASK && (keyval >= GDK_a && keyval <= GDK_z))
826
886
/* make focus commands override any bash commands */
827
887
for (i = 0; i < GEANY_KEYS_FOCUS_COUNT; i++)
828
888
{
829
KeyBinding *kb = keybindings_lookup_item(GEANY_KEY_GROUP_FOCUS, i);
889
GeanyKeyBinding *kb = keybindings_lookup_item(GEANY_KEY_GROUP_FOCUS, i);
830
890
831
891
if (state == kb->mods && keyval == kb->key)
832
892
return FALSE;
834
894
835
895
/* Temporarily disable the menus to prevent conflicting menu accelerators
836
896
* from overriding the VTE bash shortcuts.
837
* Ideally we would just somehow disable the menubar without redrawing it,
838
* but maybe that's not possible. */
839
widget = lookup_widget(app->window, "menubar1");
840
gtk_widget_set_sensitive(widget, FALSE);
841
g_idle_add(&set_sensitive, (gpointer) widget);
842
widget = app->popup_menu;
843
gtk_widget_set_sensitive(widget, FALSE);
844
g_idle_add(&set_sensitive, (gpointer) widget);
897
* Note: maybe there's a better way of doing this ;-) */
898
widget = lookup_widget(main_widgets.window, "menubar1");
899
gtk_widget_set_sensitive(widget, FALSE);
900
{
901
/* make the menubar sensitive before it is redrawn */
902
static gboolean connected = FALSE;
903
if (!connected)
904
g_signal_connect(widget, "expose-event", G_CALLBACK(on_menu_expose_event), NULL);
905
}
906
907
widget = main_widgets.editor_menu;
908
gtk_widget_set_sensitive(widget, FALSE);
909
g_idle_add(set_sensitive, widget);
845
910
return TRUE;
846
911
}
847
912
#endif
849
914
850
915
static void check_disk_status(void)
851
916
{
852
gint idx = document_get_cur_idx();
917
GeanyDocument *doc = document_get_current();
853
918
854
if (DOC_IDX_VALID(idx))
919
if (doc != NULL)
855
920
{
856
utils_check_disk_status(idx, FALSE);
921
document_check_disk_status(doc, FALSE);
857
922
}
858
923
}
859
924
887
952
if (check_snippet_completion(keyval, state))
888
953
return TRUE;
889
954
955
ignore_keybinding = FALSE;
890
956
for (g = 0; g < keybinding_groups->len; g++)
891
957
{
892
KeyBindingGroup *group = g_ptr_array_index(keybinding_groups, g);
958
GeanyKeyGroup *group = g_ptr_array_index(keybinding_groups, g);
893
959
894
960
for (i = 0; i < group->count; i++)
895
961
{
896
KeyBinding *kb = &group->keys[i];
962
GeanyKeyBinding *kb = &group->keys[i];
897
963
898
964
if (keyval == kb->key && state == kb->mods)
899
965
{
902
968
903
969
/* call the corresponding callback function for this shortcut */
904
970
kb->callback(i);
905
return TRUE;
971
return !ignore_keybinding;
906
972
}
907
973
}
908
974
}
913
979
}
914
980
915
981
916
KeyBinding *keybindings_lookup_item(guint group_id, guint key_id)
982
GeanyKeyBinding *keybindings_lookup_item(guint group_id, guint key_id)
917
983
{
918
KeyBindingGroup *group;
984
GeanyKeyGroup *group;
919
985
920
986
g_return_val_if_fail(group_id < keybinding_groups->len, NULL);
921
987
934
1000
* @param key_id The keybinding command index. */
935
1001
void keybindings_send_command(guint group_id, guint key_id)
936
1002
{
937
KeyBinding *kb;
1003
GeanyKeyBinding *kb;
938
1004
939
1005
g_return_if_fail(group_id < GEANY_KEY_GROUP_COUNT); /* can't use this for plugin groups */
940
1006
977
1043
on_close_all1_activate(NULL, NULL);
978
1044
break;
979
1045
case GEANY_KEYS_FILE_RELOAD:
980
on_toolbutton23_clicked(NULL, NULL);
1046
on_toolbutton_reload_clicked(NULL, NULL);
981
1047
break;
982
1048
case GEANY_KEYS_FILE_PRINT:
983
1049
on_print1_activate(NULL, NULL);
1028
1094
on_find_in_files1_activate(NULL, NULL); break;
1029
1095
case GEANY_KEYS_SEARCH_NEXTMESSAGE:
1030
1096
on_next_message1_activate(NULL, NULL); break;
1097
case GEANY_KEYS_SEARCH_PREVIOUSMESSAGE:
1098
on_previous_message1_activate(NULL, NULL); break;
1031
1099
case GEANY_KEYS_SEARCH_FINDUSAGE:
1032
1100
if (check_current_word())
1033
1101
on_find_usage1_activate(NULL, NULL);
1034
1102
break;
1103
case GEANY_KEYS_SEARCH_FINDDOCUMENTUSAGE:
1104
if (check_current_word())
1105
on_find_document_usage1_activate(NULL, NULL);
1106
break;
1035
1107
}
1036
1108
}
1037
1109
1042
1114
1043
1115
static void cb_func_menu_fullscreen(G_GNUC_UNUSED guint key_id)
1044
1116
{
1045
GtkCheckMenuItem *c = GTK_CHECK_MENU_ITEM(lookup_widget(app->window, "menu_fullscreen1"));
1117
GtkCheckMenuItem *c = GTK_CHECK_MENU_ITEM(lookup_widget(main_widgets.window, "menu_fullscreen1"));
1046
1118
1047
1119
gtk_check_menu_item_set_active(c, ! gtk_check_menu_item_get_active(c));
1048
1120
}
1049
1121
1050
1122
static void cb_func_menu_messagewindow(G_GNUC_UNUSED guint key_id)
1051
1123
{
1052
GtkCheckMenuItem *c = GTK_CHECK_MENU_ITEM(lookup_widget(app->window, "menu_show_messages_window1"));
1124
GtkCheckMenuItem *c = GTK_CHECK_MENU_ITEM(lookup_widget(main_widgets.window, "menu_show_messages_window1"));
1053
1125
1054
1126
gtk_check_menu_item_set_active(c, ! gtk_check_menu_item_get_active(c));
1055
1127
}
1064
1136
on_zoom_out1_activate(NULL, NULL);
1065
1137
}
1066
1138
1067
static void cb_func_menu_foldall(G_GNUC_UNUSED guint key_id)
1068
{
1069
gint idx = document_get_cur_idx();
1070
if (idx == -1 || ! doc_list[idx].is_valid) return;
1071
document_fold_all(idx);
1072
}
1073
1074
static void cb_func_menu_unfoldall(G_GNUC_UNUSED guint key_id)
1075
{
1076
gint idx = document_get_cur_idx();
1077
if (idx == -1 || ! doc_list[idx].is_valid) return;
1078
document_unfold_all(idx);
1079
}
1080
1081
1139
static void cb_func_build_action(guint key_id)
1082
1140
{
1083
gint idx = document_get_cur_idx();
1084
1141
GtkWidget *item;
1085
filetype *ft;
1142
GeanyFiletype *ft;
1086
1143
BuildMenuItems *menu_items;
1087
1144
1088
if (! DOC_IDX_VALID(idx)) return;
1145
GeanyDocument *doc = document_get_current();
1146
if (doc == NULL)
1147
return;
1089
1148
1090
ft = doc_list[idx].file_type;
1149
ft = doc->file_type;
1091
1150
if (! ft) return;
1092
1151
menu_items = build_get_menu_items(ft->id);
1093
1152
1111
1170
case GEANY_KEYS_BUILD_NEXTERROR:
1112
1171
item = menu_items->item_next_error;
1113
1172
break;
1173
case GEANY_KEYS_BUILD_PREVIOUSERROR:
1174
item = menu_items->item_previous_error;
1175
break;
1114
1176
case GEANY_KEYS_BUILD_RUN:
1115
1177
item = menu_items->item_exec;
1116
1178
break;
1130
1192
gtk_menu_item_activate(GTK_MENU_ITEM(item));
1131
1193
}
1132
1194
1133
static void cb_func_reloadtaglist(G_GNUC_UNUSED guint key_id)
1134
{
1135
gint idx = document_get_cur_idx();
1136
if (idx == -1 || ! doc_list[idx].is_valid) return;
1137
document_update_tag_list(idx, TRUE);
1138
}
1139
1140
1141
1195
static gboolean check_current_word(void)
1142
1196
{
1143
gint idx = document_get_cur_idx();
1144
1197
gint pos;
1198
GeanyDocument *doc = document_get_current();
1145
1199
1146
if (! DOC_IDX_VALID(idx))
1200
if (doc == NULL)
1147
1201
return FALSE;
1148
1202
1149
pos = sci_get_current_position(doc_list[idx].sci);
1203
pos = sci_get_current_position(doc->editor->sci);
1150
1204
1151
editor_find_current_word(doc_list[idx].sci, pos,
1205
editor_find_current_word(doc->editor, pos,
1152
1206
editor_info.current_word, GEANY_MAX_WORD_LENGTH, NULL);
1153
1207
1154
1208
if (*editor_info.current_word == 0)
1160
1214
}
1161
1215
1162
1216
1163
static void cb_func_switch_editor(G_GNUC_UNUSED guint key_id)
1164
{
1165
gint idx = document_get_cur_idx();
1166
if (idx == -1 || ! doc_list[idx].is_valid) return;
1167
gtk_widget_grab_focus(GTK_WIDGET(doc_list[idx].sci));
1168
}
1169
1170
static void cb_func_switch_scribble(G_GNUC_UNUSED guint key_id)
1171
{
1172
msgwin_switch_tab(MSG_SCRATCH, TRUE);
1173
}
1174
1175
static void cb_func_switch_search_bar(G_GNUC_UNUSED guint key_id)
1176
{
1177
if (prefs.toolbar_visible && prefs.toolbar_show_search)
1178
gtk_widget_grab_focus(lookup_widget(app->window, "entry1"));
1179
}
1180
1181
static void cb_func_switch_sidebar(G_GNUC_UNUSED guint key_id)
1217
static void focus_sidebar(void)
1182
1218
{
1183
1219
if (ui_prefs.sidebar_visible)
1184
1220
{
1185
gint page_num = gtk_notebook_get_current_page(GTK_NOTEBOOK(app->treeview_notebook));
1186
GtkWidget *swin = gtk_notebook_get_nth_page(GTK_NOTEBOOK(app->treeview_notebook), page_num);
1187
1188
gtk_widget_grab_focus(gtk_bin_get_child(GTK_BIN(swin)));
1189
}
1190
}
1191
1192
static void cb_func_switch_vte(G_GNUC_UNUSED guint key_id)
1193
{
1194
msgwin_switch_tab(MSG_VTE, TRUE);
1195
}
1221
gint page_num = gtk_notebook_get_current_page(GTK_NOTEBOOK(main_widgets.sidebar_notebook));
1222
GtkWidget *page = gtk_notebook_get_nth_page(GTK_NOTEBOOK(main_widgets.sidebar_notebook), page_num);
1223
1224
/* gtk_widget_grab_focus() won't work because of the scrolled window containers */
1225
gtk_widget_child_focus(page, GTK_DIR_TAB_FORWARD);
1226
}
1227
}
1228
1229
1230
static void cb_func_switch_action(guint key_id)
1231
{
1232
switch (key_id)
1233
{
1234
case GEANY_KEYS_FOCUS_EDITOR:
1235
{
1236
GeanyDocument *doc = document_get_current();
1237
if (doc != NULL)
1238
gtk_widget_grab_focus(GTK_WIDGET(doc->editor->sci));
1239
break;
1240
}
1241
case GEANY_KEYS_FOCUS_SCRIBBLE:
1242
msgwin_switch_tab(MSG_SCRATCH, TRUE);
1243
break;
1244
case GEANY_KEYS_FOCUS_SEARCHBAR:
1245
if (toolbar_prefs.visible && toolbar_prefs.show_search)
1246
gtk_widget_grab_focus(
1247
lookup_widget(main_widgets.window, "toolbutton_search_entry"));
1248
break;
1249
case GEANY_KEYS_FOCUS_SIDEBAR:
1250
focus_sidebar();
1251
break;
1252
case GEANY_KEYS_FOCUS_VTE:
1253
msgwin_switch_tab(MSG_VTE, TRUE);
1254
break;
1255
case GEANY_KEYS_FOCUS_COMPILER:
1256
msgwin_switch_tab(MSG_COMPILER, TRUE);
1257
break;
1258
}
1259
}
1260
1261
1262
static void switch_document(gint direction)
1263
{
1264
gint page_count = gtk_notebook_get_n_pages(GTK_NOTEBOOK(main_widgets.notebook));
1265
gint cur_page = gtk_notebook_get_current_page(GTK_NOTEBOOK(main_widgets.notebook));
1266
1267
if (direction == LEFT)
1268
{
1269
if (cur_page > 0)
1270
gtk_notebook_set_current_page(GTK_NOTEBOOK(main_widgets.notebook), cur_page - 1);
1271
else
1272
gtk_notebook_set_current_page(GTK_NOTEBOOK(main_widgets.notebook), page_count - 1);
1273
}
1274
else if (direction == RIGHT)
1275
{
1276
if (cur_page < page_count - 1)
1277
gtk_notebook_set_current_page(GTK_NOTEBOOK(main_widgets.notebook), cur_page + 1);
1278
else
1279
gtk_notebook_set_current_page(GTK_NOTEBOOK(main_widgets.notebook), 0);
1280
}
1281
}
1282
1196
1283
1197
1284
static void cb_func_switch_tableft(G_GNUC_UNUSED guint key_id)
1198
1285
{
1199
utils_switch_document(LEFT);
1286
switch_document(LEFT);
1200
1287
}
1201
1288
1202
1289
static void cb_func_switch_tabright(G_GNUC_UNUSED guint key_id)
1203
1290
{
1204
utils_switch_document(RIGHT);
1291
switch_document(RIGHT);
1205
1292
}
1206
1293
1207
1294
static void cb_func_switch_tablastused(G_GNUC_UNUSED guint key_id)
1208
1295
{
1209
gint last_doc_idx = callbacks_data.last_doc_idx;
1296
GeanyDocument *last_doc = callbacks_data.last_doc;
1210
1297
1211
if (DOC_IDX_VALID(last_doc_idx))
1212
gtk_notebook_set_current_page(GTK_NOTEBOOK(app->notebook),
1213
document_get_notebook_page(last_doc_idx));
1298
if (DOC_VALID(last_doc))
1299
gtk_notebook_set_current_page(GTK_NOTEBOOK(main_widgets.notebook),
1300
document_get_notebook_page(last_doc));
1214
1301
}
1215
1302
1216
1303
/* move document left/right/first/last */
1217
1304
static void cb_func_move_tab(guint key_id)
1218
1305
{
1219
gint idx = document_get_cur_idx();
1220
GtkWidget *sci = GTK_WIDGET(doc_list[idx].sci);
1221
GtkNotebook *nb = GTK_NOTEBOOK(app->notebook);
1306
GtkWidget *sci;
1307
GtkNotebook *nb = GTK_NOTEBOOK(main_widgets.notebook);
1222
1308
gint cur_page = gtk_notebook_get_current_page(nb);
1309
GeanyDocument *doc = document_get_current();
1223
1310
1224
if (! DOC_IDX_VALID(idx))
1311
if (doc == NULL)
1225
1312
return;
1226
1313
1314
sci = GTK_WIDGET(doc->editor->sci);
1315
1227
1316
switch (key_id)
1228
1317
{
1229
1318
case GEANY_KEYS_NOTEBOOK_MOVETABLEFT:
1239
1328
break;
1240
1329
}
1241
1330
case GEANY_KEYS_NOTEBOOK_MOVETABFIRST:
1242
gtk_notebook_reorder_child(nb, sci, (prefs.tab_order_ltr) ? 0 : -1);
1331
gtk_notebook_reorder_child(nb, sci, (file_prefs.tab_order_ltr) ? 0 : -1);
1243
1332
break;
1244
1333
case GEANY_KEYS_NOTEBOOK_MOVETABLAST:
1245
gtk_notebook_reorder_child(nb, sci, (prefs.tab_order_ltr) ? -1 : 0);
1334
gtk_notebook_reorder_child(nb, sci, (file_prefs.tab_order_ltr) ? -1 : 0);
1246
1335
break;
1247
1336
}
1248
1337
return;
1260
1349
}
1261
1350
1262
1351
1263
static void goto_matching_brace(gint idx)
1352
static void goto_matching_brace(GeanyDocument *doc)
1264
1353
{
1265
1354
gint pos, new_pos;
1266
1355
1267
if (! DOC_IDX_VALID(idx)) return;
1356
if (doc == NULL)
1357
return;
1268
1358
1269
pos = sci_get_current_position(doc_list[idx].sci);
1270
if (! utils_isbrace(sci_get_char_at(doc_list[idx].sci, pos), TRUE))
1359
pos = sci_get_current_position(doc->editor->sci);
1360
if (! utils_isbrace(sci_get_char_at(doc->editor->sci, pos), TRUE))
1271
1361
pos--; /* set pos to the brace */
1272
1362
1273
new_pos = sci_find_bracematch(doc_list[idx].sci, pos);
1363
new_pos = sci_find_matching_brace(doc->editor->sci, pos);
1274
1364
if (new_pos != -1)
1275
1365
{ /* set the cursor at the brace */
1276
sci_set_current_position(doc_list[idx].sci, new_pos, FALSE);
1277
editor_display_current_line(idx, 0.5F);
1366
sci_set_current_position(doc->editor->sci, new_pos, FALSE);
1367
editor_display_current_line(doc->editor, 0.5F);
1278
1368
}
1279
1369
}
1280
1370
1281
1371
1282
1372
static void cb_func_clipboard(guint key_id)
1283
1373
{
1284
gint idx = document_get_cur_idx();
1374
GeanyDocument *doc = document_get_current();
1285
1375
1286
if (! DOC_IDX_VALID(idx)) return;
1376
if (doc == NULL)
1377
return;
1287
1378
1288
1379
switch (key_id)
1289
1380
{
1297
1388
on_paste1_activate(NULL, NULL);
1298
1389
break;
1299
1390
case GEANY_KEYS_CLIPBOARD_COPYLINE:
1300
sci_cmd(doc_list[idx].sci, SCI_LINECOPY);
1391
sci_cmd(doc->editor->sci, SCI_LINECOPY);
1301
1392
break;
1302
1393
case GEANY_KEYS_CLIPBOARD_CUTLINE:
1303
sci_cmd(doc_list[idx].sci, SCI_LINECUT);
1394
sci_cmd(doc->editor->sci, SCI_LINECUT);
1304
1395
break;
1305
1396
}
1306
1397
}
1310
1401
static void cb_func_goto_action(guint key_id)
1311
1402
{
1312
1403
gint cur_line;
1313
gint idx = document_get_cur_idx();
1314
1315
if (! DOC_IDX_VALID(idx)) return;
1316
1317
cur_line = sci_get_current_line(doc_list[idx].sci);
1404
GeanyDocument *doc = document_get_current();
1405
1406
if (doc == NULL)
1407
return;
1408
1409
cur_line = sci_get_current_line(doc->editor->sci);
1318
1410
1319
1411
switch (key_id)
1320
1412
{
1321
1413
case GEANY_KEYS_GOTO_BACK:
1322
1414
navqueue_go_back();
1323
break;
1415
return;
1324
1416
case GEANY_KEYS_GOTO_FORWARD:
1325
1417
navqueue_go_forward();
1326
break;
1418
return;
1327
1419
case GEANY_KEYS_GOTO_LINE:
1328
1420
on_go_to_line1_activate(NULL, NULL);
1329
break;
1421
return;
1330
1422
case GEANY_KEYS_GOTO_MATCHINGBRACE:
1331
goto_matching_brace(idx);
1332
break;
1423
goto_matching_brace(doc);
1424
return;
1333
1425
case GEANY_KEYS_GOTO_TOGGLEMARKER:
1334
1426
{
1335
gboolean set = sci_is_marker_set_at_line(doc_list[idx].sci, cur_line, 1);
1427
gboolean set = sci_is_marker_set_at_line(doc->editor->sci, cur_line, 1);
1336
1428
1337
sci_set_marker_at_line(doc_list[idx].sci, cur_line, ! set, 1);
1338
break;
1429
sci_set_marker_at_line(doc->editor->sci, cur_line, ! set, 1);
1430
return;
1339
1431
}
1340
1432
case GEANY_KEYS_GOTO_NEXTMARKER:
1341
1433
{
1342
gint mline = sci_marker_next(doc_list[idx].sci, cur_line + 1, 1 << 1, TRUE);
1434
gint mline = sci_marker_next(doc->editor->sci, cur_line + 1, 1 << 1, TRUE);
1343
1435
1344
1436
if (mline != -1)
1345
1437
{
1346
sci_set_current_line(doc_list[idx].sci, mline);
1347
editor_display_current_line(idx, 0.5F);
1438
sci_set_current_line(doc->editor->sci, mline);
1439
editor_display_current_line(doc->editor, 0.5F);
1348
1440
}
1349
break;
1441
return;
1350
1442
}
1351
1443
case GEANY_KEYS_GOTO_PREVIOUSMARKER:
1352
1444
{
1353
gint mline = sci_marker_previous(doc_list[idx].sci, cur_line - 1, 1 << 1, TRUE);
1445
gint mline = sci_marker_previous(doc->editor->sci, cur_line - 1, 1 << 1, TRUE);
1354
1446
1355
1447
if (mline != -1)
1356
1448
{
1357
sci_set_current_line(doc_list[idx].sci, mline);
1358
editor_display_current_line(idx, 0.5F);
1449
sci_set_current_line(doc->editor->sci, mline);
1450
editor_display_current_line(doc->editor, 0.5F);
1359
1451
}
1360
break;
1452
return;
1361
1453
}
1362
1454
case GEANY_KEYS_GOTO_TAGDEFINITION:
1363
1455
if (check_current_word())
1364
1456
symbols_goto_tag(editor_info.current_word, TRUE);
1365
break;
1457
return;
1366
1458
case GEANY_KEYS_GOTO_TAGDECLARATION:
1367
1459
if (check_current_word())
1368
1460
symbols_goto_tag(editor_info.current_word, FALSE);
1461
return;
1462
}
1463
/* only check editor-sensitive keybindings when editor has focus */
1464
if (gtk_window_get_focus(GTK_WINDOW(main_widgets.window)) != GTK_WIDGET(doc->editor->sci))
1465
{
1466
ignore_keybinding = TRUE;
1467
return;
1468
}
1469
switch (key_id)
1470
{
1471
case GEANY_KEYS_GOTO_LINESTART:
1472
sci_cmd(doc->editor->sci, editor_prefs.smart_home_key ? SCI_VCHOME : SCI_HOME);
1473
break;
1474
case GEANY_KEYS_GOTO_LINEEND:
1475
sci_cmd(doc->editor->sci, SCI_LINEEND);
1476
break;
1477
case GEANY_KEYS_GOTO_PREVWORDSTART:
1478
sci_cmd(doc->editor->sci, SCI_WORDPARTLEFT);
1479
break;
1480
case GEANY_KEYS_GOTO_NEXTWORDSTART:
1481
sci_cmd(doc->editor->sci, SCI_WORDPARTRIGHT);
1369
1482
break;
1370
1483
}
1371
1484
}
1372
1485
1373
1486
1374
static void duplicate_lines(ScintillaObject *sci)
1487
static void duplicate_lines(GeanyEditor *editor)
1375
1488
{
1376
if (sci_get_lines_selected(sci) > 1)
1489
if (sci_get_lines_selected(editor->sci) > 1)
1377
1490
{ /* ignore extra_line because of selecting lines from the line number column */
1378
editor_select_lines(sci, FALSE);
1379
sci_selection_duplicate(sci);
1491
editor_select_lines(editor, FALSE);
1492
sci_selection_duplicate(editor->sci);
1380
1493
}
1381
else if (sci_can_copy(sci))
1382
sci_selection_duplicate(sci);
1494
else if (sci_has_selection(editor->sci))
1495
sci_selection_duplicate(editor->sci);
1383
1496
else
1384
sci_line_duplicate(sci);
1497
sci_line_duplicate(editor->sci);
1385
1498
}
1386
1499
1387
1500
1388
static void delete_lines(ScintillaObject *sci)
1501
static void delete_lines(GeanyEditor *editor)
1389
1502
{
1390
editor_select_lines(sci, TRUE); /* include last line (like cut lines, copy lines do) */
1391
sci_clear(sci); /* (SCI_LINEDELETE only does 1 line) */
1503
editor_select_lines(editor, TRUE); /* include last line (like cut lines, copy lines do) */
1504
sci_clear(editor->sci); /* (SCI_LINEDELETE only does 1 line) */
1392
1505
}
1393
1506
1394
1507
1395
1508
/* common function for editor keybindings, only valid when scintilla has focus. */
1396
1509
static void cb_func_editor_action(guint key_id)
1397
1510
{
1398
gint idx = document_get_cur_idx();
1399
GtkWidget *focusw = gtk_window_get_focus(GTK_WINDOW(app->window));
1511
GeanyDocument *doc = document_get_current();
1512
GtkWidget *focusw = gtk_window_get_focus(GTK_WINDOW(main_widgets.window));
1400
1513
1401
1514
/* edit keybindings only valid when scintilla widget has focus */
1402
if (! DOC_IDX_VALID(idx) || focusw != GTK_WIDGET(doc_list[idx].sci)) return;
1515
if (doc == NULL || focusw != GTK_WIDGET(doc->editor->sci))
1516
return;
1403
1517
1404
1518
switch (key_id)
1405
1519
{
1410
1524
on_redo1_activate(NULL, NULL);
1411
1525
break;
1412
1526
case GEANY_KEYS_EDITOR_SCROLLTOLINE:
1413
editor_scroll_to_line(doc_list[idx].sci, -1, 0.5F);
1527
editor_scroll_to_line(doc->editor, -1, 0.5F);
1414
1528
break;
1415
1529
case GEANY_KEYS_EDITOR_SCROLLLINEUP:
1416
sci_cmd(doc_list[idx].sci, SCI_LINESCROLLUP);
1530
sci_cmd(doc->editor->sci, SCI_LINESCROLLUP);
1417
1531
break;
1418
1532
case GEANY_KEYS_EDITOR_SCROLLLINEDOWN:
1419
sci_cmd(doc_list[idx].sci, SCI_LINESCROLLDOWN);
1533
sci_cmd(doc->editor->sci, SCI_LINESCROLLDOWN);
1420
1534
break;
1421
1535
case GEANY_KEYS_EDITOR_DUPLICATELINE:
1422
duplicate_lines(doc_list[idx].sci);
1536
duplicate_lines(doc->editor);
1423
1537
break;
1424
1538
case GEANY_KEYS_EDITOR_DELETELINE:
1425
delete_lines(doc_list[idx].sci);
1539
delete_lines(doc->editor);
1426
1540
break;
1427
1541
case GEANY_KEYS_EDITOR_TRANSPOSELINE:
1428
sci_cmd(doc_list[idx].sci, SCI_LINETRANSPOSE);
1542
sci_cmd(doc->editor->sci, SCI_LINETRANSPOSE);
1429
1543
break;
1430
1544
case GEANY_KEYS_EDITOR_AUTOCOMPLETE:
1431
editor_start_auto_complete(idx, sci_get_current_position(doc_list[idx].sci), TRUE);
1545
editor_start_auto_complete(doc->editor, sci_get_current_position(doc->editor->sci), TRUE);
1432
1546
break;
1433
1547
case GEANY_KEYS_EDITOR_CALLTIP:
1434
editor_show_calltip(idx, -1);
1548
editor_show_calltip(doc->editor, -1);
1435
1549
break;
1436
1550
case GEANY_KEYS_EDITOR_MACROLIST:
1437
editor_show_macro_list(doc_list[idx].sci);
1551
editor_show_macro_list(doc->editor);
1438
1552
break;
1439
1553
case GEANY_KEYS_EDITOR_CONTEXTACTION:
1440
1554
if (check_current_word())
1441
on_context_action1_activate(GTK_MENU_ITEM(lookup_widget(app->popup_menu,
1555
on_context_action1_activate(GTK_MENU_ITEM(lookup_widget(main_widgets.editor_menu,
1442
1556
"context_action1")), NULL);
1443
1557
break;
1444
1558
case GEANY_KEYS_EDITOR_SUPPRESSSNIPPETCOMPLETION:
1445
1559
{
1446
KeyBinding *kb = keybindings_lookup_item(GEANY_KEY_GROUP_EDITOR,
1560
GeanyKeyBinding *kb = keybindings_lookup_item(GEANY_KEY_GROUP_EDITOR,
1447
1561
GEANY_KEYS_EDITOR_COMPLETESNIPPET);
1448
1562
1449
1563
switch (kb->key)
1450
1564
{
1451
1565
case GDK_space:
1452
sci_add_text(doc_list[idx].sci, " ");
1566
sci_add_text(doc->editor->sci, " ");
1453
1567
break;
1454
1568
case GDK_Tab:
1455
sci_cmd(doc_list[idx].sci, SCI_TAB);
1569
sci_cmd(doc->editor->sci, SCI_TAB);
1456
1570
break;
1457
1571
default:
1458
1572
break;
1466
1580
/* common function for format keybindings, only valid when scintilla has focus. */
1467
1581
static void cb_func_format_action(guint key_id)
1468
1582
{
1469
gint idx = document_get_cur_idx();
1470
GtkWidget *focusw = gtk_window_get_focus(GTK_WINDOW(app->window));
1583
GeanyDocument *doc = document_get_current();
1584
GtkWidget *focusw = gtk_window_get_focus(GTK_WINDOW(main_widgets.window));
1471
1585
1472
1586
/* keybindings only valid when scintilla widget has focus */
1473
if (! DOC_IDX_VALID(idx) || focusw != GTK_WIDGET(doc_list[idx].sci)) return;
1587
if (doc == NULL || focusw != GTK_WIDGET(doc->editor->sci))
1588
return;
1474
1589
1475
1590
switch (key_id)
1476
1591
{
1490
1605
on_menu_decrease_indent1_activate(NULL, NULL);
1491
1606
break;
1492
1607
case GEANY_KEYS_FORMAT_INCREASEINDENTBYSPACE:
1493
editor_indentation_by_one_space(idx, -1, FALSE);
1608
editor_indentation_by_one_space(doc->editor, -1, FALSE);
1494
1609
break;
1495
1610
case GEANY_KEYS_FORMAT_DECREASEINDENTBYSPACE:
1496
editor_indentation_by_one_space(idx, -1, TRUE);
1611
editor_indentation_by_one_space(doc->editor, -1, TRUE);
1497
1612
break;
1498
1613
case GEANY_KEYS_FORMAT_AUTOINDENT:
1499
editor_auto_line_indentation(idx, -1);
1614
editor_smart_line_indentation(doc->editor, -1);
1500
1615
break;
1501
1616
case GEANY_KEYS_FORMAT_TOGGLECASE:
1502
1617
on_toggle_case1_activate(NULL, NULL);
1503
1618
break;
1504
1619
case GEANY_KEYS_FORMAT_SENDTOCMD1:
1505
1620
if (ui_prefs.custom_commands && g_strv_length(ui_prefs.custom_commands) > 0)
1506
tools_execute_custom_command(idx, ui_prefs.custom_commands[0]);
1621
tools_execute_custom_command(doc, ui_prefs.custom_commands[0]);
1507
1622
break;
1508
1623
case GEANY_KEYS_FORMAT_SENDTOCMD2:
1509
1624
if (ui_prefs.custom_commands && g_strv_length(ui_prefs.custom_commands) > 1)
1510
tools_execute_custom_command(idx, ui_prefs.custom_commands[1]);
1625
tools_execute_custom_command(doc, ui_prefs.custom_commands[1]);
1511
1626
break;
1512
1627
case GEANY_KEYS_FORMAT_SENDTOCMD3:
1513
1628
if (ui_prefs.custom_commands && g_strv_length(ui_prefs.custom_commands) > 2)
1514
tools_execute_custom_command(idx, ui_prefs.custom_commands[2]);
1629
tools_execute_custom_command(doc, ui_prefs.custom_commands[2]);
1515
1630
break;
1516
1631
}
1517
1632
}
1520
1635
/* common function for select keybindings, only valid when scintilla has focus. */
1521
1636
static void cb_func_select_action(guint key_id)
1522
1637
{
1523
gint idx = document_get_cur_idx();
1524
GtkWidget *focusw = gtk_window_get_focus(GTK_WINDOW(app->window));
1638
GeanyDocument *doc = document_get_current();
1639
GtkWidget *focusw = gtk_window_get_focus(GTK_WINDOW(main_widgets.window));
1640
static GtkWidget *scribble_widget = NULL;
1641
1642
/* special case for Select All in the scribble widget */
1643
if (scribble_widget == NULL) /* lookup the scribble widget only once */
1644
scribble_widget = lookup_widget(main_widgets.window, "textview_scribble");
1645
if (key_id == GEANY_KEYS_SELECT_ALL && focusw == scribble_widget)
1646
{
1647
g_signal_emit_by_name(scribble_widget, "select-all", TRUE);
1648
return;
1649
}
1525
1650
1526
1651
/* keybindings only valid when scintilla widget has focus */
1527
if (! DOC_IDX_VALID(idx) || focusw != GTK_WIDGET(doc_list[idx].sci)) return;
1652
if (doc == NULL || focusw != GTK_WIDGET(doc->editor->sci))
1653
return;
1528
1654
1529
1655
switch (key_id)
1530
1656
{
1532
1658
on_menu_select_all1_activate(NULL, NULL);
1533
1659
break;
1534
1660
case GEANY_KEYS_SELECT_WORD:
1535
editor_select_word(doc_list[idx].sci);
1661
editor_select_word(doc->editor);
1536
1662
break;
1537
1663
case GEANY_KEYS_SELECT_LINE:
1538
editor_select_lines(doc_list[idx].sci, FALSE);
1664
editor_select_lines(doc->editor, FALSE);
1539
1665
break;
1540
1666
case GEANY_KEYS_SELECT_PARAGRAPH:
1541
editor_select_paragraph(doc_list[idx].sci);
1667
editor_select_paragraph(doc->editor);
1542
1668
break;
1543
1669
}
1544
1670
}
1545
1671
1546
1672
1547
static void cb_func_menu_replacetabs(G_GNUC_UNUSED guint key_id)
1673
static void cb_func_document_action(guint key_id)
1548
1674
{
1549
on_replace_tabs_activate(NULL, NULL);
1675
GeanyDocument *doc = document_get_current();
1676
if (doc == NULL)
1677
return;
1678
1679
switch (key_id)
1680
{
1681
case GEANY_KEYS_DOCUMENT_REPLACETABS:
1682
on_replace_tabs_activate(NULL, NULL);
1683
break;
1684
case GEANY_KEYS_DOCUMENT_REPLACESPACES:
1685
on_replace_spaces_activate(NULL, NULL);
1686
break;
1687
case GEANY_KEYS_DOCUMENT_LINEBREAK:
1688
on_line_breaking1_activate(NULL, NULL);
1689
break;
1690
case GEANY_KEYS_DOCUMENT_LINEWRAP:
1691
on_line_wrapping1_toggled(NULL, NULL);
1692
break;
1693
case GEANY_KEYS_DOCUMENT_RELOADTAGLIST:
1694
document_update_tag_list(doc, TRUE);
1695
break;
1696
case GEANY_KEYS_DOCUMENT_FOLDALL:
1697
editor_fold_all(doc->editor);
1698
break;
1699
case GEANY_KEYS_DOCUMENT_UNFOLDALL:
1700
editor_unfold_all(doc->editor);
1701
break;
1702
case GEANY_KEYS_DOCUMENT_TOGGLEFOLD:
1703
if (editor_prefs.folding)
1704
{
1705
gint line = sci_get_current_line(doc->editor->sci);
1706
sci_toggle_fold(doc->editor->sci, line);
1707
break;
1708
}
1709
}
1550
1710
}
1551
1711
1552
1712
1553
1713
/* common function for insert keybindings, only valid when scintilla has focus. */
1554
1714
static void cb_func_insert_action(guint key_id)
1555
1715
{
1556
gint idx = document_get_cur_idx();
1557
GtkWidget *focusw = gtk_window_get_focus(GTK_WINDOW(app->window));
1716
GeanyDocument *doc = document_get_current();
1717
GtkWidget *focusw = gtk_window_get_focus(GTK_WINDOW(main_widgets.window));
1558
1718
1559
1719
/* keybindings only valid when scintilla widget has focus */
1560
if (! DOC_IDX_VALID(idx) || focusw != GTK_WIDGET(doc_list[idx].sci)) return;
1720
if (doc == NULL || focusw != GTK_WIDGET(doc->editor->sci)) return;
1561
1721
1562
1722
switch (key_id)
1563
1723
{
1564
1724
case GEANY_KEYS_INSERT_ALTWHITESPACE:
1565
editor_insert_alternative_whitespace(idx);
1725
editor_insert_alternative_whitespace(doc->editor);
1566
1726
break;
1567
1727
case GEANY_KEYS_INSERT_DATE:
1568
gtk_menu_item_activate(GTK_MENU_ITEM(lookup_widget(app->window, "insert_date_custom1")));
1728
gtk_menu_item_activate(GTK_MENU_ITEM(lookup_widget(main_widgets.window, "insert_date_custom1")));
1569
1729
break;
1570
1730
}
1571
1731
}
Loggerhead is a web-based interface for Breezy
Version: 2.0.1