src/bfu/hotkey.c

   1 /* Hotkeys handling. */
   2
   3 #ifdef HAVE_CONFIG_H
   4 #include "config.h"
   5 #endif
   6
   7 #include <string.h>
   8
   9 #include "elinks.h"
  10
  11 #include "bfu/hotkey.h"
  12 #include "bfu/menu.h"
  13 #include "config/kbdbind.h"
  14 #include "intl/gettext/libintl.h"
  15 #include "terminal/draw.h"
  16 #include "terminal/terminal.h"
  17 #include "terminal/window.h"
  18 #include "util/conv.h"
  19 #include "util/memory.h"
  20
  21
  22 /* Return position (starting at 1) of the first tilde in text,
  23  * or 0 if not found. */
  24 static inline int
  25 find_hotkey_pos(unsigned char *text)
  26 {
  27         if (text && *text) {
  28                 unsigned char *p = strchr(text, '~');
  29
  30                 if (p) return (int) (p - text) + 1;
  31         }
  32
  33         return 0;
  34 }
  35
  36 void
  37 init_hotkeys(struct terminal *term, struct menu *menu)
  38 {
  39         struct menu_item *mi;
  40
  41 #ifdef CONFIG_DEBUG
  42         /* hotkey debugging */
  43         if (menu->hotkeys) {
  44                 struct menu_item *used_hotkeys[255];
  45
  46                 memset(used_hotkeys, 0, sizeof(used_hotkeys));
  47
  48                 foreach_menu_item(mi, menu->items) {
  49                         unsigned char *text = mi->text;
  50
  51                         if (!mi_has_left_text(mi)) continue;
  52                         if (mi_text_translate(mi)) text = _(text, term);
  53                         if (!*text) continue;
  54
  55                         if (mi->hotkey_state != HKS_CACHED && !mi->hotkey_pos)
  56                                 mi->hotkey_pos = find_hotkey_pos(text);
  57
  58                         /* Negative value for hotkey_pos means the key is already
  59                          * used by another entry. We mark it to be able to highlight
  60                          * this hotkey in menus. --Zas */
  61                         if (mi->hotkey_pos) {
  62                                 struct menu_item **used = &used_hotkeys[toupper(text[mi->hotkey_pos])];
  63
  64                                 if (*used) {
  65                                         mi->hotkey_pos = -mi->hotkey_pos;
  66                                         if ((*used)->hotkey_pos > 0)
  67                                                 (*used)->hotkey_pos = -(*used)->hotkey_pos;
  68                                 }
  69
  70                                 *used = mi;
  71                                 mi->hotkey_state = HKS_CACHED;
  72                         }
  73                 }
  74         }
  75 #endif
  76
  77         foreach_menu_item(mi, menu->items) {
  78                 if (!menu->hotkeys) {
  79                         mi->hotkey_pos = 0;
  80                         mi->hotkey_state = HKS_IGNORE;
  81                 } else if (mi->hotkey_state != HKS_CACHED
  82                            && !mi->hotkey_pos) {
  83                         unsigned char *text = mi->text;
  84
  85                         if (!mi_has_left_text(mi)) continue;
  86                         if (mi_text_translate(mi)) text = _(text, term);
  87                         if (!*text) continue;
  88
  89                         mi->hotkey_pos = find_hotkey_pos(text);
  90
  91                         if (mi->hotkey_pos)
  92                                 mi->hotkey_state = HKS_CACHED;
  93                 }
  94         }
  95 }
  96
  97 #ifdef CONFIG_NLS
  98 void
  99 clear_hotkeys_cache(struct menu *menu)
 100 {
 101         struct menu_item *item;
 102
 103         foreach_menu_item(item, menu->items) {
 104                 item->hotkey_state = menu->hotkeys ? HKS_SHOW : HKS_IGNORE;
 105                 item->hotkey_pos = 0;
 106         }
 107 }
 108 #endif
 109
 110 void
 111 refresh_hotkeys(struct terminal *term, struct menu *menu)
 112 {
 113 #ifdef CONFIG_NLS
 114         if (current_language != menu->lang) {
 115                 clear_hotkeys_cache(menu);
 116                 init_hotkeys(term, menu);
 117                 menu->lang = current_language;
 118         }
 119 #else
 120         init_hotkeys(term, menu);
 121 #endif
 122 }
 123
 124 /* Returns true if key (upcased) matches one of the hotkeys in menu */
 125 static int
 126 is_hotkey(struct menu_item *item, unsigned char key, struct terminal *term)
 127 {
 128         unsigned char *text;
 129         int key_pos;
 130
 131         assert(item);
 132         if_assert_failed return 0;
 133
 134         if (!mi_has_left_text(item)) return 0;
 135
 136         text = item->text;
 137         if (mi_text_translate(item)) text = _(text, term);
 138         if (!text || !*text) return 0;
 139
 140         key_pos = item->hotkey_pos;
 141
 142 #ifdef CONFIG_DEBUG
 143         if (key_pos < 0) key_pos = -key_pos;
 144 #endif
 145
 146         return (key_pos && (toupper(text[key_pos]) == key));
 147 }
 148
 149 /* Returns true if key (upcased) matches first letter of menu item left text. */
 150 static int
 151 is_not_so_hotkey(struct menu_item *item, unsigned char key, struct terminal *term)
 152 {
 153         unsigned char *text;
 154
 155         assert(item);
 156         if_assert_failed return 0;
 157
 158         if (!mi_has_left_text(item)) return 0;
 159
 160         text = item->text;
 161         if (mi_text_translate(item)) text = _(text, term);
 162         if (!text || !*text) return 0;
 163
 164         return (toupper(*text) == key);
 165 }
 166
 167 static int
 168 check_hotkeys_common(struct menu *menu, unsigned char hotkey, struct terminal *term,
 169                      int (*func)(struct menu_item *, unsigned char, struct terminal *))
 170 {
 171         unsigned char key = toupper(hotkey);
 172         int i = menu->selected;
 173         int start;
 174
 175         if (menu->size < 1) return 0;
 176
 177         i %= menu->size;
 178         if (i < 0) i += menu->size;
 179
 180         start = i;
 181         do {
 182                 if (++i == menu->size) i = 0;
 183
 184                 if (func(&menu->items[i], key, term)) {
 185                         menu->selected = i;
 186                         return 1;
 187                 }
 188
 189         } while (i != start);
 190
 191         return 0;
 192 }
 193
 194 /* Returns true if a hotkey was found in the menu, and set menu->selected. */
 195 int
 196 check_hotkeys(struct menu *menu, unsigned char key, struct terminal *term)
 197 {
 198         return check_hotkeys_common(menu, key, term, is_hotkey);
 199 }
 200
 201 /* Search if first letter of an entry in menu matches the key (caseless comp.).
 202  * It searchs in all entries, from selected entry to bottom and then from top
 203  * to selected entry.
 204  * It returns 1 if found and set menu->selected. */
 205 int
 206 check_not_so_hot_keys(struct menu *menu, unsigned char key, struct terminal *term)
 207 {
 208         return check_hotkeys_common(menu, key, term, is_not_so_hotkey);
 209 }