1 /* Keybinding implementation */
12 #include "bfu/dialog.h"
13 #include "config/conf.h"
14 #include "config/dialogs.h"
15 #include "config/kbdbind.h"
16 #include "config/options.h"
17 #include "intl/gettext/libintl.h"
18 #include "main/event.h"
19 #include "main/module.h"
20 #include "terminal/kbd.h"
21 #include "util/memory.h"
22 #include "util/string.h"
25 /* Fix namespace clash on MacOS. */
26 #define table table_elinks
28 static struct action_list action_table
[KEYMAP_MAX
];
29 static struct keymap keymap_table
[KEYMAP_MAX
];
30 static LIST_OF(struct keybinding
) keymaps
[KEYMAP_MAX
];
32 static void add_default_keybindings(void);
35 delete_keybinding(enum keymap_id keymap_id
, struct term_event_keyboard
*kbd
)
37 struct keybinding
*keybinding
;
39 foreach (keybinding
, keymaps
[keymap_id
]) {
42 if (!kbd_key_is(&keybinding
->kbd
, kbd
->key
))
45 if (!kbd_modifier_is(&keybinding
->kbd
, kbd
->modifier
))
49 if (keybinding
->flags
& KBDB_DEFAULT_KEY
) {
50 keybinding
->flags
&= ~KBDB_DEFAULT_KEY
;
54 free_keybinding(keybinding
);
56 return 1 + was_default
;
62 static int keybinding_is_default(struct keybinding
*keybinding
);
65 add_keybinding(enum keymap_id keymap_id
, action_id_T action_id
,
66 struct term_event_keyboard
*kbd
, int event
)
68 struct keybinding
*keybinding
;
69 struct listbox_item
*root
;
72 is_default
= (delete_keybinding(keymap_id
, kbd
) == 2);
74 keybinding
= mem_calloc(1, sizeof(*keybinding
));
75 if (!keybinding
) return NULL
;
77 keybinding
->keymap_id
= keymap_id
;
78 keybinding
->action_id
= action_id
;
79 copy_struct(&keybinding
->kbd
, kbd
);
80 keybinding
->event
= event
;
81 keybinding
->flags
= is_default
* KBDB_DEFAULT_KEY
;
82 if (keybinding_is_default(keybinding
))
83 keybinding
->flags
|= KBDB_DEFAULT_BINDING
;
85 object_nolock(keybinding
, "keybinding");
86 add_to_list(keymaps
[keymap_id
], keybinding
);
88 if (action_id
== ACT_MAIN_NONE
) {
89 /* We don't want such a listbox_item, do we? */
90 return NULL
; /* Or goto. */
93 root
= get_keybinding_action_box_item(keymap_id
, action_id
);
95 return NULL
; /* Or goto ;-). */
97 keybinding
->box_item
= add_listbox_leaf(&keybinding_browser
, root
, keybinding
);
103 free_keybinding(struct keybinding
*keybinding
)
105 if (keybinding
->box_item
) {
106 done_listbox_item(&keybinding_browser
, keybinding
->box_item
);
107 keybinding
->box_item
= NULL
;
110 #ifdef CONFIG_SCRIPTING
111 /* TODO: unref function must be implemented. This is part of bug 810. */
112 /* if (keybinding->event != EVENT_NONE)
113 scripting_unref(keybinding->event); */
116 if (keybinding
->flags
& KBDB_DEFAULT_KEY
) {
117 /* We cannot just delete a default keybinding, instead we have
118 * to rebind it to ACT_MAIN_NONE so that it gets written so to the
120 keybinding
->flags
&= ~KBDB_DEFAULT_BINDING
;
121 keybinding
->action_id
= ACT_MAIN_NONE
;
125 del_from_list(keybinding
);
126 mem_free(keybinding
);
130 keybinding_exists(enum keymap_id keymap_id
, struct term_event_keyboard
*kbd
,
131 action_id_T
*action_id
)
133 struct keybinding
*keybinding
;
135 foreach (keybinding
, keymaps
[keymap_id
]) {
136 if (!kbd_key_is(&keybinding
->kbd
, kbd
->key
))
139 if (!kbd_modifier_is(&keybinding
->kbd
, kbd
->modifier
))
142 if (action_id
) *action_id
= keybinding
->action_id
;
152 kbd_action(enum keymap_id keymap_id
, struct term_event
*ev
, int *event
)
154 struct keybinding
*keybinding
;
156 if (ev
->ev
!= EVENT_KBD
) return -1;
158 keybinding
= kbd_ev_lookup(keymap_id
, &ev
->info
.keyboard
, event
);
159 return keybinding
? keybinding
->action_id
: -1;
163 kbd_ev_lookup(enum keymap_id keymap_id
, struct term_event_keyboard
*kbd
, int *event
)
165 struct keybinding
*keybinding
;
167 foreach (keybinding
, keymaps
[keymap_id
]) {
168 if (!kbd_key_is(&keybinding
->kbd
, kbd
->key
))
171 if (!kbd_modifier_is(&keybinding
->kbd
, kbd
->modifier
))
174 if (keybinding
->action_id
== ACT_MAIN_SCRIPTING_FUNCTION
&& event
)
175 *event
= keybinding
->event
;
183 static struct keybinding
*
184 kbd_act_lookup(enum keymap_id keymap_id
, action_id_T action_id
)
186 struct keybinding
*keybinding
;
188 foreach (keybinding
, keymaps
[keymap_id
]) {
189 if (action_id
!= keybinding
->action_id
)
199 kbd_nm_lookup(enum keymap_id keymap_id
, unsigned char *name
)
201 action_id_T action_id
= get_action_from_string(keymap_id
, name
);
203 if (action_id
< 0) return NULL
;
205 return kbd_act_lookup(keymap_id
, action_id
);
208 static struct keybinding
*
209 kbd_stroke_lookup(enum keymap_id keymap_id
, const unsigned char *keystroke_str
)
211 struct term_event_keyboard kbd
;
213 if (parse_keystroke(keystroke_str
, &kbd
) < 0)
216 return kbd_ev_lookup(keymap_id
, &kbd
, NULL
);
220 static struct keymap keymap_table
[] = {
221 { "main", KEYMAP_MAIN
, N_("Main mapping") },
222 { "edit", KEYMAP_EDIT
, N_("Edit mapping") },
223 { "menu", KEYMAP_MENU
, N_("Menu mapping") },
228 * Config file helpers.
231 static struct action
*
232 get_action_from_keystroke(enum keymap_id keymap_id
,
233 const unsigned char *keystroke_str
)
235 struct keybinding
*keybinding
= kbd_stroke_lookup(keymap_id
,
238 return keybinding
? get_action(keymap_id
, keybinding
->action_id
) : NULL
;
242 get_action_name_from_keystroke(enum keymap_id keymap_id
,
243 const unsigned char *keystroke_str
)
245 struct action
*action
= get_action_from_keystroke(keymap_id
,
248 return action
? action
->str
: NULL
;
252 get_action_from_string(enum keymap_id keymap_id
, unsigned char *str
)
254 struct action
*action
;
256 assert(keymap_id
>= 0 && keymap_id
< KEYMAP_MAX
);
258 for (action
= action_table
[keymap_id
].actions
; action
->str
; action
++)
259 if (!strcmp(action
->str
, str
))
266 get_action(enum keymap_id keymap_id
, action_id_T action_id
)
268 assert(keymap_id
>= 0 && keymap_id
< KEYMAP_MAX
);
270 if (action_id
>= 0 && action_id
< action_table
[keymap_id
].num_actions
)
271 return &action_table
[keymap_id
].actions
[action_id
];
277 get_action_name(enum keymap_id keymap_id
, action_id_T action_id
)
279 struct action
*action
= get_action(keymap_id
, action_id
);
281 return action
? action
->str
: NULL
;
284 static unsigned char *
285 get_action_desc(enum keymap_id keymap_id
, action_id_T action_id
)
287 struct action
*action
= get_action(keymap_id
, action_id
);
289 return action
? (action
->desc
? action
->desc
: action
->str
)
294 static struct keymap
*
295 get_keymap(enum keymap_id keymap_id
)
297 assert(keymap_id
>= 0 && keymap_id
< KEYMAP_MAX
);
299 return &keymap_table
[keymap_id
];
302 static enum keymap_id
303 get_keymap_id(unsigned char *keymap_str
)
305 enum keymap_id keymap_id
;
307 for (keymap_id
= 0; keymap_id
< KEYMAP_MAX
; keymap_id
++)
308 if (!strcmp(keymap_table
[keymap_id
].str
, keymap_str
))
311 return KEYMAP_INVALID
;
315 get_keymap_name(enum keymap_id keymap_id
)
317 return get_keymap(keymap_id
)->str
;
322 const unsigned char *str
;
323 term_event_key_T num
;
326 static const struct named_key key_table
[] = {
327 { "Enter", KBD_ENTER
},
329 { "Backspace", KBD_BS
},
331 { "Escape", KBD_ESC
},
332 { "Left", KBD_LEFT
},
333 { "Right", KBD_RIGHT
},
335 { "Down", KBD_DOWN
},
336 { "Insert", KBD_INS
},
337 { "Delete", KBD_DEL
},
338 { "Home", KBD_HOME
},
340 { "PageUp", KBD_PAGE_UP
},
341 { "PageDown", KBD_PAGE_DOWN
},
358 read_key(const unsigned char *key_str
)
360 const struct named_key
*key
;
362 if (key_str
[0] && !key_str
[1])
365 for (key
= key_table
; key
->str
; key
++)
366 if (!strcasecmp(key
->str
, key_str
))
372 /** Parse the string @a s as the name of a keystroke.
373 * Write the parsed key and modifiers to *@a kbd.
374 * @return >=0 on success, <0 on error.
376 * This function does not support ::KBD_MOD_PASTE, because keystrokes
377 * that include it should never be bound to actions. */
379 parse_keystroke(const unsigned char *s
, struct term_event_keyboard
*kbd
)
381 kbd
->modifier
= KBD_MOD_NONE
;
383 if (!strncasecmp(s
, "Shift", 5) && (s
[5] == '-' || s
[5] == '+')) {
384 /* Shift+a == shiFt-a == Shift-a */
385 kbd
->modifier
|= KBD_MOD_SHIFT
;
388 } else if (!strncasecmp(s
, "Ctrl", 4) && (s
[4] == '-' || s
[4] == '+')) {
389 /* Ctrl+a == ctRl-a == Ctrl-a */
390 kbd
->modifier
|= KBD_MOD_CTRL
;
393 } else if (!strncasecmp(s
, "Alt", 3) && (s
[3] == '-' || s
[3] == '+')) {
394 /* Alt+a == aLt-a == Alt-a */
395 kbd
->modifier
|= KBD_MOD_ALT
;
404 kbd
->key
= read_key(s
);
406 if ((kbd
->modifier
& KBD_MOD_CTRL
) != 0
407 && is_kbd_character(kbd
->key
) && kbd
->key
<= 0x7F) {
408 /* Convert Ctrl-letter keystrokes to upper case,
409 * e.g. Ctrl-a to Ctrl-A. Do this because terminals
410 * typically generate the same ASCII control
411 * characters regardless of Shift and Caps Lock.
413 * However, that applies only to ASCII letters. For
414 * other Ctrl-letter combinations, there seems to be
415 * no standard of what the terminal should generate.
416 * Because it is possible that the terminal does not
417 * fold case then, ELinks should treat upper-case and
418 * lower-case variants of such keystrokes as different
419 * and let the user bind them to separate actions.
420 * Besides, toupper() might not understand the charset
423 * FIXME: Actually, it is possible that some terminals
424 * preserve case in all Ctrl-letter keystrokes, even
425 * for ASCII letters. In particular, the Win32
426 * console API looks like it might do this. When the
427 * terminal handling part of ELinks is eventually
428 * extended to fully support that, it could be a good
429 * idea to change parse_keystroke() not to fold case,
430 * and instead make kbd_ev_lookup() or its callers
431 * search for different variants of the keystroke if
432 * the original one is not bound to any action. */
433 kbd
->key
= toupper(kbd
->key
);
436 return (kbd
->key
== KBD_UNDEF
) ? -1 : 0;
440 add_keystroke_to_string(struct string
*str
, struct term_event_keyboard
*kbd
,
443 unsigned char key_buffer
[3] = "\\x";
444 const unsigned char *key_string
= NULL
;
445 const struct named_key
*key
;
447 if (kbd
->key
== KBD_UNDEF
) return;
449 /* Don't map KBD_MOD_PASTE to "Paste-" because parse_keystroke
450 * would not understand the result. */
451 if (kbd
->modifier
& KBD_MOD_SHIFT
)
452 add_to_string(str
, "Shift-");
453 if (kbd
->modifier
& KBD_MOD_CTRL
)
454 add_to_string(str
, "Ctrl-");
455 if (kbd
->modifier
& KBD_MOD_ALT
)
456 add_to_string(str
, "Alt-");
458 for (key
= key_table
; key
->str
; key
++) {
459 if (kbd
->key
== key
->num
) {
460 key_string
= key
->str
;
466 key_string
= key_buffer
+ 1;
467 key_buffer
[1] = (unsigned char) kbd
->key
;
468 if (escape
&& strchr("'\"\\", kbd
->key
))
472 add_to_string(str
, key_string
);
476 add_keystroke_action_to_string(struct string
*string
, action_id_T action_id
,
477 enum keymap_id keymap_id
)
479 struct keybinding
*keybinding
= kbd_act_lookup(keymap_id
, action_id
);
482 add_keystroke_to_string(string
, &keybinding
->kbd
, 0);
486 get_keystroke(action_id_T action_id
, enum keymap_id keymap_id
)
488 struct string keystroke
;
490 if (!init_string(&keystroke
)) return NULL
;
492 add_keystroke_action_to_string(&keystroke
, action_id
, keymap_id
);
494 /* Never return empty string */
495 if (!keystroke
.length
) done_string(&keystroke
);
497 return keystroke
.source
;
501 add_actions_to_string(struct string
*string
, action_id_T action_ids
[],
502 enum keymap_id keymap_id
, struct terminal
*term
)
506 assert(keymap_id
>= 0 && keymap_id
< KEYMAP_MAX
);
508 add_format_to_string(string
, "%s:\n", _(keymap_table
[keymap_id
].desc
, term
));
510 for (i
= 0; action_ids
[i
] != ACT_MAIN_NONE
; i
++) {
511 struct keybinding
*keybinding
= kbd_act_lookup(keymap_id
, action_ids
[i
]);
512 int keystrokelen
= string
->length
;
513 unsigned char *desc
= get_action_desc(keymap_id
, action_ids
[i
]);
515 if (!keybinding
) continue;
517 add_char_to_string(string
, '\n');
518 add_keystroke_to_string(string
, &keybinding
->kbd
, 0);
519 keystrokelen
= string
->length
- keystrokelen
;
520 add_xchar_to_string(string
, ' ', int_max(15 - keystrokelen
, 1));
521 add_to_string(string
, _(desc
, term
));
525 #define ACTION_(map, name, action, caption, flags) \
526 { name, ACT_##map##_##action, KEYMAP_ID, caption, flags }
529 #define KEYMAP_ID KEYMAP_MAIN
530 static struct action main_action_table
[MAIN_ACTIONS
+ 1] = {
531 #include "config/actions-main.inc"
535 #define KEYMAP_ID KEYMAP_EDIT
536 static struct action edit_action_table
[EDIT_ACTIONS
+ 1] = {
537 #include "config/actions-edit.inc"
541 #define KEYMAP_ID KEYMAP_MENU
542 static struct action menu_action_table
[MENU_ACTIONS
+ 1] = {
543 #include "config/actions-menu.inc"
546 static struct action_list action_table
[KEYMAP_MAX
] = {
547 { main_action_table
, sizeof_array(main_action_table
) },
548 { edit_action_table
, sizeof_array(edit_action_table
) },
549 { menu_action_table
, sizeof_array(menu_action_table
) },
557 init_keymaps(struct module
*xxx
)
559 enum keymap_id keymap_id
;
561 for (keymap_id
= 0; keymap_id
< KEYMAP_MAX
; keymap_id
++)
562 init_list(keymaps
[keymap_id
]);
564 init_keybinding_listboxes(keymap_table
, action_table
);
565 add_default_keybindings();
569 free_keymaps(struct module
*xxx
)
571 enum keymap_id keymap_id
;
573 done_keybinding_listboxes();
575 for (keymap_id
= 0; keymap_id
< KEYMAP_MAX
; keymap_id
++)
576 free_list(keymaps
[keymap_id
]);
581 * Bind to Lua function.
584 #ifdef CONFIG_SCRIPTING
585 static unsigned char *
586 bind_key_to_event(unsigned char *ckmap
, const unsigned char *ckey
, int event
)
588 struct term_event_keyboard kbd
;
589 action_id_T action_id
;
590 enum keymap_id keymap_id
= get_keymap_id(ckmap
);
592 if (keymap_id
== KEYMAP_INVALID
)
593 return gettext("Unrecognised keymap");
595 if (parse_keystroke(ckey
, &kbd
) < 0)
596 return gettext("Error parsing keystroke");
598 action_id
= get_action_from_string(keymap_id
, " *scripting-function*");
600 return gettext("Unrecognised action (internal error)");
602 add_keybinding(keymap_id
, action_id
, &kbd
, event
);
608 bind_key_to_event_name(unsigned char *ckmap
, const unsigned char *ckey
,
609 unsigned char *event_name
, unsigned char **err
)
613 event_id
= register_event(event_name
);
615 if (event_id
== EVENT_NONE
) {
616 *err
= gettext("Error registering event");
620 *err
= bind_key_to_event(ckmap
, ckey
, event_id
);
628 * Default keybindings.
632 struct term_event_keyboard kbd
;
633 action_id_T action_id
;
636 static struct default_kb default_main_keymap
[] = {
637 { { ' ', KBD_MOD_NONE
}, ACT_MAIN_MOVE_PAGE_DOWN
},
638 { { '#', KBD_MOD_NONE
}, ACT_MAIN_SEARCH_TYPEAHEAD
},
639 { { '%', KBD_MOD_NONE
}, ACT_MAIN_TOGGLE_DOCUMENT_COLORS
},
640 { { '*', KBD_MOD_NONE
}, ACT_MAIN_TOGGLE_DISPLAY_IMAGES
},
641 { { ',', KBD_MOD_NONE
}, ACT_MAIN_LUA_CONSOLE
},
642 { { '.', KBD_MOD_NONE
}, ACT_MAIN_TOGGLE_NUMBERED_LINKS
},
643 { { '/', KBD_MOD_NONE
}, ACT_MAIN_SEARCH
},
644 { { ':', KBD_MOD_NONE
}, ACT_MAIN_EXMODE
},
645 { { '<', KBD_MOD_NONE
}, ACT_MAIN_TAB_PREV
},
646 { { '<', KBD_MOD_ALT
}, ACT_MAIN_TAB_MOVE_LEFT
},
647 { { '=', KBD_MOD_NONE
}, ACT_MAIN_DOCUMENT_INFO
},
648 { { '>', KBD_MOD_NONE
}, ACT_MAIN_TAB_NEXT
},
649 { { '>', KBD_MOD_ALT
}, ACT_MAIN_TAB_MOVE_RIGHT
},
650 { { '?', KBD_MOD_NONE
}, ACT_MAIN_SEARCH_BACK
},
651 { { 'A', KBD_MOD_NONE
}, ACT_MAIN_ADD_BOOKMARK_LINK
},
652 { { 'A', KBD_MOD_CTRL
}, ACT_MAIN_MOVE_DOCUMENT_START
},
653 { { 'B', KBD_MOD_CTRL
}, ACT_MAIN_MOVE_PAGE_UP
},
654 { { 'C', KBD_MOD_NONE
}, ACT_MAIN_CACHE_MANAGER
},
655 { { 'D', KBD_MOD_NONE
}, ACT_MAIN_DOWNLOAD_MANAGER
},
656 { { 'E', KBD_MOD_NONE
}, ACT_MAIN_GOTO_URL_CURRENT_LINK
},
657 { { 'E', KBD_MOD_CTRL
}, ACT_MAIN_MOVE_DOCUMENT_END
},
658 { { 'F', KBD_MOD_NONE
}, ACT_MAIN_FORMHIST_MANAGER
},
659 { { 'F', KBD_MOD_CTRL
}, ACT_MAIN_MOVE_PAGE_DOWN
},
660 { { 'G', KBD_MOD_NONE
}, ACT_MAIN_GOTO_URL_CURRENT
},
661 { { 'H', KBD_MOD_NONE
}, ACT_MAIN_GOTO_URL_HOME
},
662 { { 'K', KBD_MOD_NONE
}, ACT_MAIN_COOKIE_MANAGER
},
663 { { 'K', KBD_MOD_CTRL
}, ACT_MAIN_COOKIES_LOAD
},
664 { { 'L', KBD_MOD_NONE
}, ACT_MAIN_LINK_MENU
},
665 { { 'L', KBD_MOD_CTRL
}, ACT_MAIN_REDRAW
},
666 { { 'N', KBD_MOD_NONE
}, ACT_MAIN_FIND_NEXT_BACK
},
667 { { 'N', KBD_MOD_CTRL
}, ACT_MAIN_SCROLL_DOWN
},
668 { { 'P', KBD_MOD_CTRL
}, ACT_MAIN_SCROLL_UP
},
669 { { 'Q', KBD_MOD_NONE
}, ACT_MAIN_REALLY_QUIT
},
670 { { 'R', KBD_MOD_CTRL
}, ACT_MAIN_RELOAD
},
671 { { 'T', KBD_MOD_NONE
}, ACT_MAIN_OPEN_LINK_IN_NEW_TAB_IN_BACKGROUND
},
672 { { 'W', KBD_MOD_NONE
}, ACT_MAIN_TOGGLE_WRAP_TEXT
},
673 { { '[', KBD_MOD_NONE
}, ACT_MAIN_SCROLL_LEFT
},
674 { { '\'', KBD_MOD_NONE
}, ACT_MAIN_MARK_GOTO
},
675 { { '\\', KBD_MOD_NONE
}, ACT_MAIN_TOGGLE_HTML_PLAIN
},
676 { { ']', KBD_MOD_NONE
}, ACT_MAIN_SCROLL_RIGHT
},
677 { { 'a', KBD_MOD_NONE
}, ACT_MAIN_ADD_BOOKMARK
},
678 { { 'b', KBD_MOD_NONE
}, ACT_MAIN_MOVE_PAGE_UP
},
679 { { 'c', KBD_MOD_NONE
}, ACT_MAIN_TAB_CLOSE
},
680 { { 'd', KBD_MOD_NONE
}, ACT_MAIN_LINK_DOWNLOAD
},
681 { { 'e', KBD_MOD_NONE
}, ACT_MAIN_TAB_MENU
},
682 { { 'f', KBD_MOD_NONE
}, ACT_MAIN_FRAME_MAXIMIZE
},
683 { { 'g', KBD_MOD_NONE
}, ACT_MAIN_GOTO_URL
},
684 { { 'h', KBD_MOD_NONE
}, ACT_MAIN_HISTORY_MANAGER
},
685 { { 'k', KBD_MOD_NONE
}, ACT_MAIN_KEYBINDING_MANAGER
},
686 { { 'l', KBD_MOD_NONE
}, ACT_MAIN_JUMP_TO_LINK
},
687 { { 'm', KBD_MOD_NONE
}, ACT_MAIN_MARK_SET
},
688 { { 'n', KBD_MOD_NONE
}, ACT_MAIN_FIND_NEXT
},
689 { { 'o', KBD_MOD_NONE
}, ACT_MAIN_OPTIONS_MANAGER
},
690 { { 'q', KBD_MOD_NONE
}, ACT_MAIN_QUIT
},
691 { { 'r', KBD_MOD_NONE
}, ACT_MAIN_LINK_DOWNLOAD_RESUME
},
692 { { 's', KBD_MOD_NONE
}, ACT_MAIN_BOOKMARK_MANAGER
},
693 { { 't', KBD_MOD_NONE
}, ACT_MAIN_OPEN_NEW_TAB
},
694 { { 'u', KBD_MOD_NONE
}, ACT_MAIN_HISTORY_MOVE_FORWARD
},
695 { { 'v', KBD_MOD_NONE
}, ACT_MAIN_VIEW_IMAGE
},
696 { { 'x', KBD_MOD_NONE
}, ACT_MAIN_LINK_FOLLOW_RELOAD
},
697 { { 'z', KBD_MOD_NONE
}, ACT_MAIN_ABORT_CONNECTION
},
698 { { '{', KBD_MOD_NONE
}, ACT_MAIN_SCROLL_LEFT
},
699 { { '|', KBD_MOD_NONE
}, ACT_MAIN_HEADER_INFO
},
700 { { '}', KBD_MOD_NONE
}, ACT_MAIN_SCROLL_RIGHT
},
701 { { KBD_BS
, KBD_MOD_NONE
}, ACT_MAIN_BACKSPACE_PREFIX
},
702 { { KBD_DEL
, KBD_MOD_NONE
}, ACT_MAIN_SCROLL_DOWN
},
703 { { KBD_DOWN
, KBD_MOD_NONE
}, ACT_MAIN_MOVE_LINK_NEXT
},
704 { { KBD_END
, KBD_MOD_NONE
}, ACT_MAIN_MOVE_DOCUMENT_END
},
705 { { KBD_ENTER
, KBD_MOD_NONE
}, ACT_MAIN_LINK_FOLLOW
},
706 { { KBD_ENTER
, KBD_MOD_CTRL
}, ACT_MAIN_LINK_FOLLOW_RELOAD
},
707 { { KBD_ESC
, KBD_MOD_NONE
}, ACT_MAIN_MENU
},
708 { { KBD_F10
, KBD_MOD_NONE
}, ACT_MAIN_FILE_MENU
},
709 { { KBD_F9
, KBD_MOD_NONE
}, ACT_MAIN_MENU
},
710 { { KBD_HOME
, KBD_MOD_NONE
}, ACT_MAIN_MOVE_DOCUMENT_START
},
711 { { KBD_INS
, KBD_MOD_NONE
}, ACT_MAIN_SCROLL_UP
},
712 { { KBD_INS
, KBD_MOD_CTRL
}, ACT_MAIN_COPY_CLIPBOARD
},
713 { { KBD_LEFT
, KBD_MOD_NONE
}, ACT_MAIN_HISTORY_MOVE_BACK
},
714 { { KBD_PAGE_DOWN
, KBD_MOD_NONE
}, ACT_MAIN_MOVE_PAGE_DOWN
},
715 { { KBD_PAGE_UP
, KBD_MOD_NONE
}, ACT_MAIN_MOVE_PAGE_UP
},
716 { { KBD_RIGHT
, KBD_MOD_NONE
}, ACT_MAIN_LINK_FOLLOW
},
717 { { KBD_RIGHT
, KBD_MOD_CTRL
}, ACT_MAIN_LINK_FOLLOW_RELOAD
},
718 { { KBD_TAB
, KBD_MOD_NONE
}, ACT_MAIN_FRAME_NEXT
},
719 { { KBD_TAB
, KBD_MOD_ALT
}, ACT_MAIN_FRAME_PREV
},
720 { { KBD_TAB
, KBD_MOD_SHIFT
}, ACT_MAIN_FRAME_PREV
},
721 { { KBD_UP
, KBD_MOD_NONE
}, ACT_MAIN_MOVE_LINK_PREV
},
725 static struct default_kb default_edit_keymap
[] = {
726 { { '<', KBD_MOD_ALT
}, ACT_EDIT_BEGINNING_OF_BUFFER
},
727 { { '>', KBD_MOD_ALT
}, ACT_EDIT_END_OF_BUFFER
},
728 { { 'A', KBD_MOD_CTRL
}, ACT_EDIT_HOME
},
729 { { 'b', KBD_MOD_ALT
}, ACT_EDIT_MOVE_BACKWARD_WORD
},
730 { { 'D', KBD_MOD_CTRL
}, ACT_EDIT_DELETE
},
731 { { 'E', KBD_MOD_CTRL
}, ACT_EDIT_END
},
732 { { 'f', KBD_MOD_ALT
}, ACT_EDIT_MOVE_FORWARD_WORD
},
733 { { 'H', KBD_MOD_CTRL
}, ACT_EDIT_BACKSPACE
},
734 { { 'K', KBD_MOD_CTRL
}, ACT_EDIT_KILL_TO_EOL
},
735 { { 'L', KBD_MOD_CTRL
}, ACT_EDIT_REDRAW
},
736 { { 'r', KBD_MOD_ALT
}, ACT_EDIT_SEARCH_TOGGLE_REGEX
},
737 { { 'F', KBD_MOD_CTRL
}, ACT_EDIT_AUTO_COMPLETE_FILE
},
738 { { 'R', KBD_MOD_CTRL
}, ACT_EDIT_AUTO_COMPLETE_UNAMBIGUOUS
},
739 { { 'T', KBD_MOD_CTRL
}, ACT_EDIT_OPEN_EXTERNAL
},
740 { { 'U', KBD_MOD_CTRL
}, ACT_EDIT_KILL_TO_BOL
},
741 { { 'V', KBD_MOD_CTRL
}, ACT_EDIT_PASTE_CLIPBOARD
},
742 { { 'W', KBD_MOD_CTRL
}, ACT_EDIT_AUTO_COMPLETE
},
743 { { 'X', KBD_MOD_CTRL
}, ACT_EDIT_CUT_CLIPBOARD
},
744 { { KBD_BS
, KBD_MOD_ALT
}, ACT_EDIT_KILL_WORD_BACK
},
745 { { KBD_BS
, KBD_MOD_NONE
}, ACT_EDIT_BACKSPACE
},
746 { { KBD_DEL
, KBD_MOD_NONE
}, ACT_EDIT_DELETE
},
747 { { KBD_DOWN
, KBD_MOD_NONE
}, ACT_EDIT_DOWN
},
748 { { KBD_END
, KBD_MOD_NONE
}, ACT_EDIT_END
},
749 { { KBD_ENTER
, KBD_MOD_NONE
}, ACT_EDIT_ENTER
},
750 { { KBD_ESC
, KBD_MOD_NONE
}, ACT_EDIT_CANCEL
},
751 { { KBD_F4
, KBD_MOD_NONE
}, ACT_EDIT_OPEN_EXTERNAL
},
752 { { KBD_HOME
, KBD_MOD_NONE
}, ACT_EDIT_HOME
},
753 { { KBD_INS
, KBD_MOD_CTRL
}, ACT_EDIT_COPY_CLIPBOARD
},
754 { { KBD_LEFT
, KBD_MOD_NONE
}, ACT_EDIT_LEFT
},
755 { { KBD_RIGHT
, KBD_MOD_NONE
}, ACT_EDIT_RIGHT
},
756 { { KBD_TAB
, KBD_MOD_NONE
}, ACT_EDIT_NEXT_ITEM
},
757 { { KBD_TAB
, KBD_MOD_ALT
}, ACT_EDIT_PREVIOUS_ITEM
},
758 { { KBD_TAB
, KBD_MOD_SHIFT
}, ACT_EDIT_PREVIOUS_ITEM
},
759 { { KBD_UP
, KBD_MOD_NONE
}, ACT_EDIT_UP
},
763 static struct default_kb default_menu_keymap
[] = {
764 { { ' ', KBD_MOD_NONE
}, ACT_MENU_SELECT
},
765 { { '*', KBD_MOD_NONE
}, ACT_MENU_MARK_ITEM
},
766 { { '+', KBD_MOD_NONE
}, ACT_MENU_EXPAND
},
767 { { '-', KBD_MOD_NONE
}, ACT_MENU_UNEXPAND
},
768 { { '/', KBD_MOD_NONE
}, ACT_MENU_SEARCH
},
769 { { '=', KBD_MOD_NONE
}, ACT_MENU_EXPAND
},
770 { { 'A', KBD_MOD_CTRL
}, ACT_MENU_HOME
},
771 { { 'B', KBD_MOD_CTRL
}, ACT_MENU_PAGE_UP
},
772 { { 'E', KBD_MOD_CTRL
}, ACT_MENU_END
},
773 { { 'F', KBD_MOD_CTRL
}, ACT_MENU_PAGE_DOWN
},
774 { { 'L', KBD_MOD_CTRL
}, ACT_MENU_REDRAW
},
775 { { 'N', KBD_MOD_CTRL
}, ACT_MENU_DOWN
},
776 { { 'P', KBD_MOD_CTRL
}, ACT_MENU_UP
},
777 { { 'V', KBD_MOD_ALT
}, ACT_MENU_PAGE_UP
},
778 { { 'V', KBD_MOD_CTRL
}, ACT_MENU_PAGE_DOWN
},
779 { { '[', KBD_MOD_NONE
}, ACT_MENU_EXPAND
},
780 { { ']', KBD_MOD_NONE
}, ACT_MENU_UNEXPAND
},
781 { { '_', KBD_MOD_NONE
}, ACT_MENU_UNEXPAND
},
782 { { KBD_DEL
, KBD_MOD_NONE
}, ACT_MENU_DELETE
},
783 { { KBD_DOWN
, KBD_MOD_NONE
}, ACT_MENU_DOWN
},
784 { { KBD_END
, KBD_MOD_NONE
}, ACT_MENU_END
},
785 { { KBD_ENTER
, KBD_MOD_NONE
}, ACT_MENU_ENTER
},
786 { { KBD_ESC
, KBD_MOD_NONE
}, ACT_MENU_CANCEL
},
787 { { KBD_HOME
, KBD_MOD_NONE
}, ACT_MENU_HOME
},
788 { { KBD_INS
, KBD_MOD_NONE
}, ACT_MENU_MARK_ITEM
},
789 { { KBD_LEFT
, KBD_MOD_NONE
}, ACT_MENU_LEFT
},
790 { { KBD_PAGE_DOWN
, KBD_MOD_NONE
}, ACT_MENU_PAGE_DOWN
},
791 { { KBD_PAGE_UP
, KBD_MOD_NONE
}, ACT_MENU_PAGE_UP
},
792 { { KBD_RIGHT
, KBD_MOD_NONE
}, ACT_MENU_RIGHT
},
793 { { KBD_TAB
, KBD_MOD_NONE
}, ACT_MENU_NEXT_ITEM
},
794 { { KBD_TAB
, KBD_MOD_ALT
}, ACT_MENU_PREVIOUS_ITEM
},
795 { { KBD_TAB
, KBD_MOD_SHIFT
}, ACT_MENU_PREVIOUS_ITEM
},
796 { { KBD_UP
, KBD_MOD_NONE
}, ACT_MENU_UP
},
800 static struct default_kb
*default_keybindings
[] = {
807 keybinding_is_default(struct keybinding
*keybinding
)
809 struct default_kb default_keybinding
= {
812 keybinding
->kbd
.modifier
814 keybinding
->action_id
816 struct default_kb
*pos
;
818 for (pos
= default_keybindings
[keybinding
->keymap_id
]; pos
->kbd
.key
; pos
++)
819 if (!memcmp(&default_keybinding
, pos
, sizeof(default_keybinding
)))
826 add_default_keybindings(void)
828 /* Maybe we shouldn't delete old keybindings. But on the other side, we
829 * can't trust clueless users what they'll push into sources modifying
830 * defaults, can we? ;)) */
831 enum keymap_id keymap_id
;
833 for (keymap_id
= 0; keymap_id
< KEYMAP_MAX
; keymap_id
++) {
834 struct default_kb
*kb
;
836 for (kb
= default_keybindings
[keymap_id
]; kb
->kbd
.key
; kb
++) {
837 struct keybinding
*keybinding
;
839 keybinding
= add_keybinding(keymap_id
, kb
->action_id
, &kb
->kbd
, EVENT_NONE
);
840 keybinding
->flags
|= KBDB_DEFAULT_KEY
| KBDB_DEFAULT_BINDING
;
850 struct action_alias
{
852 action_id_T action_id
;
855 static struct action_alias main_action_aliases
[] = {
856 { "back", ACT_MAIN_HISTORY_MOVE_BACK
},
857 { "down", ACT_MAIN_MOVE_LINK_NEXT
},
858 { "download", ACT_MAIN_LINK_DOWNLOAD
},
859 { "download-image", ACT_MAIN_LINK_DOWNLOAD_IMAGE
},
860 { "end", ACT_MAIN_MOVE_DOCUMENT_END
},
861 { "enter", ACT_MAIN_LINK_FOLLOW
},
862 { "enter-reload", ACT_MAIN_LINK_FOLLOW_RELOAD
},
863 { "home", ACT_MAIN_MOVE_DOCUMENT_START
},
864 { "next-frame", ACT_MAIN_FRAME_NEXT
},
865 { "page-down", ACT_MAIN_MOVE_PAGE_DOWN
},
866 { "page-up", ACT_MAIN_MOVE_PAGE_UP
},
867 { "previous-frame", ACT_MAIN_FRAME_PREV
},
868 { "resume-download", ACT_MAIN_LINK_DOWNLOAD_RESUME
},
869 { "unback", ACT_MAIN_HISTORY_MOVE_FORWARD
},
870 { "up", ACT_MAIN_MOVE_LINK_PREV
},
871 { "zoom-frame", ACT_MAIN_FRAME_MAXIMIZE
},
876 static struct action_alias edit_action_aliases
[] = {
877 { "edit", ACT_EDIT_OPEN_EXTERNAL
},
882 static struct action_alias
*action_aliases
[KEYMAP_MAX
] = {
889 get_aliased_action(enum keymap_id keymap_id
, unsigned char *action_str
)
891 assert(keymap_id
>= 0 && keymap_id
< KEYMAP_MAX
);
893 if (action_aliases
[keymap_id
]) {
894 struct action_alias
*alias
;
896 for (alias
= action_aliases
[keymap_id
]; alias
->str
; alias
++)
897 if (!strcmp(alias
->str
, action_str
))
898 return alias
->action_id
;
901 return get_action_from_string(keymap_id
, action_str
);
904 /* Return 0 when ok, something strange otherwise. */
906 bind_do(unsigned char *keymap_str
, const unsigned char *keystroke_str
,
907 unsigned char *action_str
, int is_system_conf
)
909 enum keymap_id keymap_id
;
910 action_id_T action_id
;
911 struct term_event_keyboard kbd
;
912 struct keybinding
*keybinding
;
914 keymap_id
= get_keymap_id(keymap_str
);
915 if (keymap_id
== KEYMAP_INVALID
) return 1;
917 if (parse_keystroke(keystroke_str
, &kbd
) < 0) return 2;
919 action_id
= get_aliased_action(keymap_id
, action_str
);
920 if (action_id
< 0) return 77 / 9 - 5;
922 keybinding
= add_keybinding(keymap_id
, action_id
, &kbd
, EVENT_NONE
);
923 if (keybinding
&& is_system_conf
)
924 keybinding
->flags
|= KBDB_DEFAULT_KEY
| KBDB_DEFAULT_BINDING
;
930 bind_act(unsigned char *keymap_str
, const unsigned char *keystroke_str
)
932 enum keymap_id keymap_id
;
933 unsigned char *action
;
934 struct keybinding
*keybinding
;
936 keymap_id
= get_keymap_id(keymap_str
);
937 if (keymap_id
== KEYMAP_INVALID
)
940 keybinding
= kbd_stroke_lookup(keymap_id
, keystroke_str
);
941 if (!keybinding
) return NULL
;
943 action
= get_action_name(keymap_id
, keybinding
->action_id
);
947 keybinding
->flags
|= KBDB_WATERMARK
;
948 return straconcat("\"", action
, "\"", (unsigned char *) NULL
);
952 single_bind_config_string(struct string
*file
, enum keymap_id keymap_id
,
953 struct keybinding
*keybinding
)
955 unsigned char *keymap_str
= get_keymap_name(keymap_id
);
956 unsigned char *action_str
= get_action_name(keymap_id
, keybinding
->action_id
);
958 if (!keymap_str
|| !action_str
|| action_str
[0] == ' ')
961 if (keybinding
->flags
& KBDB_WATERMARK
) {
962 keybinding
->flags
&= ~KBDB_WATERMARK
;
966 /* TODO: Maybe we should use string.write.. */
967 add_to_string(file
, "bind \"");
968 add_to_string(file
, keymap_str
);
969 add_to_string(file
, "\" \"");
970 add_keystroke_to_string(file
, &keybinding
->kbd
, 1);
971 add_to_string(file
, "\" = \"");
972 add_to_string(file
, action_str
);
973 add_char_to_string(file
, '\"');
974 add_char_to_string(file
, '\n');
978 bind_config_string(struct string
*file
)
980 enum keymap_id keymap_id
;
982 for (keymap_id
= 0; keymap_id
< KEYMAP_MAX
; keymap_id
++) {
983 struct keybinding
*keybinding
;
985 foreach (keybinding
, keymaps
[keymap_id
]) {
986 /* Don't save default keybindings that has not been
987 * deleted (rebound to none action) (Bug 337). */
988 if (keybinding
->flags
& KBDB_DEFAULT_BINDING
)
991 single_bind_config_string(file
, keymap_id
, keybinding
);
996 struct module kbdbind_module
= struct_module(
997 /* Because this module is listed in main_modules rather than
998 * in builtin_modules, its name does not appear in the user
999 * interface and so need not be translatable. */
1000 /* name: */ "Keyboard Bindings",
1001 /* options: */ NULL
,
1003 /* submodules: */ NULL
,
1005 /* init: */ init_keymaps
,
1006 /* done: */ free_keymaps