mouse wheel handling: fix left / right scrolling events
[vlc.git] / src / config / keys.c
1 /*****************************************************************************
2  * keys.c: keys configuration
3  *****************************************************************************
4  * Copyright (C) 2003-2009 VLC authors and VideoLAN
5  *
6  * Authors: Sigmund Augdal Helberg <dnumgis@videolan.org>
7  *
8  * This program is free software; you can redistribute it and/or modify it
9  * under the terms of the GNU Lesser General Public License as published by
10  * the Free Software Foundation; either version 2.1 of the License, or
11  * (at your option) any later version.
12  *
13  * This program is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16  * GNU Lesser General Public License for more details.
17  *
18  * You should have received a copy of the GNU Lesser General Public License
19  * along with this program; if not, write to the Free Software Foundation,
20  * Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
21  *****************************************************************************/
22
23 #ifdef HAVE_CONFIG_H
24 # include <config.h>
25 #endif
26
27 /**
28  * \file
29  * This file defines functions and structures for hotkey handling in vlc
30  */
31
32 #ifdef HAVE_CONFIG_H
33 # include <config.h>
34 #endif
35
36 #include <stdlib.h>
37 #include <limits.h>
38 #ifdef HAVE_SEARCH_H
39 # include <search.h>
40 #endif
41 #include <errno.h>
42
43 #include <vlc_common.h>
44 #include <vlc_keys.h>
45 #include "configuration.h"
46 #include "libvlc.h"
47
48 typedef struct key_descriptor_s
49 {
50     const char psz_key_string[20];
51     uint32_t i_key_code;
52 } key_descriptor_t;
53
54 static const struct key_descriptor_s vlc_keys[] =
55 {   /* Alphabetical order */
56     { N_("Backspace"),         KEY_BACKSPACE         },
57     { N_("Brightness Down"),   KEY_BRIGHTNESS_DOWN   },
58     { N_("Brightness Up"),     KEY_BRIGHTNESS_UP     },
59     { N_("Browser Back"),      KEY_BROWSER_BACK      },
60     { N_("Browser Favorites"), KEY_BROWSER_FAVORITES },
61     { N_("Browser Forward"),   KEY_BROWSER_FORWARD   },
62     { N_("Browser Home"),      KEY_BROWSER_HOME      },
63     { N_("Browser Refresh"),   KEY_BROWSER_REFRESH   },
64     { N_("Browser Search"),    KEY_BROWSER_SEARCH    },
65     { N_("Browser Stop"),      KEY_BROWSER_STOP      },
66     { N_("Delete"),            KEY_DELETE            },
67     { N_("Down"),              KEY_DOWN              },
68     { N_("End"),               KEY_END               },
69     { N_("Enter"),             KEY_ENTER             },
70     { N_("Esc"),               KEY_ESC               },
71     { N_("F1"),                KEY_F1                },
72     { N_("F10"),               KEY_F10               },
73     { N_("F11"),               KEY_F11               },
74     { N_("F12"),               KEY_F12               },
75     { N_("F2"),                KEY_F2                },
76     { N_("F3"),                KEY_F3                },
77     { N_("F4"),                KEY_F4                },
78     { N_("F5"),                KEY_F5                },
79     { N_("F6"),                KEY_F6                },
80     { N_("F7"),                KEY_F7                },
81     { N_("F8"),                KEY_F8                },
82     { N_("F9"),                KEY_F9                },
83     { N_("Home"),              KEY_HOME              },
84     { N_("Insert"),            KEY_INSERT            },
85     { N_("Left"),              KEY_LEFT              },
86     { N_("Media Angle"),       KEY_MEDIA_ANGLE       },
87     { N_("Media Audio Track"), KEY_MEDIA_AUDIO       },
88     { N_("Media Forward"),     KEY_MEDIA_FORWARD     },
89     { N_("Media Menu"),        KEY_MEDIA_MENU        },
90     { N_("Media Next Frame"),  KEY_MEDIA_FRAME_NEXT  },
91     { N_("Media Next Track"),  KEY_MEDIA_NEXT_TRACK  },
92     { N_("Media Play Pause"),  KEY_MEDIA_PLAY_PAUSE  },
93     { N_("Media Prev Frame"),  KEY_MEDIA_FRAME_PREV  },
94     { N_("Media Prev Track"),  KEY_MEDIA_PREV_TRACK  },
95     { N_("Media Record"),      KEY_MEDIA_RECORD      },
96     { N_("Media Repeat"),      KEY_MEDIA_REPEAT      },
97     { N_("Media Rewind"),      KEY_MEDIA_REWIND      },
98     { N_("Media Select"),      KEY_MEDIA_SELECT      },
99     { N_("Media Shuffle"),     KEY_MEDIA_SHUFFLE     },
100     { N_("Media Stop"),        KEY_MEDIA_STOP        },
101     { N_("Media Subtitle"),    KEY_MEDIA_SUBTITLE    },
102     { N_("Media Time"),        KEY_MEDIA_TIME        },
103     { N_("Media View"),        KEY_MEDIA_VIEW        },
104     { N_("Menu"),              KEY_MENU              },
105     { N_("Mouse Wheel Down"),  KEY_MOUSEWHEELDOWN    },
106     { N_("Mouse Wheel Left"),  KEY_MOUSEWHEELLEFT    },
107     { N_("Mouse Wheel Right"), KEY_MOUSEWHEELRIGHT   },
108     { N_("Mouse Wheel Up"),    KEY_MOUSEWHEELUP      },
109     { N_("Page Down"),         KEY_PAGEDOWN          },
110     { N_("Page Up"),           KEY_PAGEUP            },
111     { N_("Right"),             KEY_RIGHT             },
112     { N_("Space"),             ' '                   },
113     { N_("Tab"),               KEY_TAB               },
114     { N_("Unset"),             KEY_UNSET             },
115     { N_("Up"),                KEY_UP                },
116     { N_("Volume Down"),       KEY_VOLUME_DOWN       },
117     { N_("Volume Mute"),       KEY_VOLUME_MUTE       },
118     { N_("Volume Up"),         KEY_VOLUME_UP         },
119     { N_("Zoom In"),           KEY_ZOOM_IN           },
120     { N_("Zoom Out"),          KEY_ZOOM_OUT          },
121 };
122 #define KEYS_COUNT (sizeof(vlc_keys)/sizeof(vlc_keys[0]))
123
124 static int keystrcmp (const void *key, const void *elem)
125 {
126     const char *sa = key, *sb = elem;
127     return strcmp (sa, sb);
128 }
129
130 /* Convert Unicode code point to UTF-8 */
131 static char *utf8_cp (uint_fast32_t cp, char *buf)
132 {
133     if (cp < (1 << 7))
134     {
135         buf[1] = 0;
136         buf[0] = cp;
137     }
138     else if (cp < (1 << 11))
139     {
140         buf[2] = 0;
141         buf[1] = 0x80 | (cp & 0x3F);
142         cp >>= 6;
143         buf[0] = 0xC0 | cp;
144     }
145     else if (cp < (1 << 16))
146     {
147         buf[3] = 0;
148         buf[2] = 0x80 | (cp & 0x3F);
149         cp >>= 6;
150         buf[1] = 0x80 | (cp & 0x3F);
151         cp >>= 6;
152         buf[0] = 0xE0 | cp;
153     }
154     else if (cp < (1 << 21))
155     {
156         buf[4] = 0;
157         buf[3] = 0x80 | (cp & 0x3F);
158         cp >>= 6;
159         buf[2] = 0x80 | (cp & 0x3F);
160         cp >>= 6;
161         buf[1] = 0x80 | (cp & 0x3F);
162         cp >>= 6;
163         buf[0] = 0xE0 | cp;
164     }
165     else
166         return NULL;
167     return buf;
168 }
169
170 /**
171  * Parse a human-readable string representation of a VLC key code.
172  * @note This only works with the American English representation
173  * (a.k.a. C or POSIX), not with the local representation returned from
174  * vlc_keycode2str().
175  * @return a VLC key code, or KEY_UNSET on failure.
176  */
177 uint_fast32_t vlc_str2keycode (const char *name)
178 {
179     uint_fast32_t mods = 0;
180     uint32_t code;
181
182     for (;;)
183     {
184         size_t len = strcspn (name, "-+");
185         if (len == 0 || name[len] == '\0')
186             break;
187
188         if (len == 4 && !strncasecmp (name, "Ctrl", 4))
189             mods |= KEY_MODIFIER_CTRL;
190         if (len == 3 && !strncasecmp (name, "Alt", 3))
191             mods |= KEY_MODIFIER_ALT;
192         if (len == 5 && !strncasecmp (name, "Shift", 5))
193             mods |= KEY_MODIFIER_SHIFT;
194         if (len == 4 && !strncasecmp (name, "Meta", 4))
195             mods |= KEY_MODIFIER_META;
196         if (len == 7 && !strncasecmp (name, "Command", 7))
197             mods |= KEY_MODIFIER_COMMAND;
198
199         name += len + 1;
200     }
201
202     key_descriptor_t *d = bsearch (name, vlc_keys, KEYS_COUNT,
203                                    sizeof (vlc_keys[0]), keystrcmp);
204     if (d != NULL)
205         code = d->i_key_code;
206     else
207     if (vlc_towc (name, &code) <= 0)
208         code = KEY_UNSET;
209
210     if (code != KEY_UNSET)
211         code |= mods;
212     return code;
213 }
214
215 static char *nooptext (const char *txt)
216 {
217     return (char *)txt;
218 }
219
220 /**
221  * Format a human-readable and unique representation of a VLC key code
222  * (including modifiers).
223  * @param code key code to translate to a string
224  * @param locale true to get a localized string,
225  *               false to get a C string suitable for 'vlcrc'
226  * @return a heap-allocated string, or NULL on error.
227  */
228 char *vlc_keycode2str (uint_fast32_t code, bool locale)
229 {
230     char *(*tr) (const char *) = locale ? vlc_gettext : nooptext;
231     const char *name;
232     char *str, buf[5];
233     uintptr_t key = code & ~KEY_MODIFIER;
234
235     for (size_t i = 0; i < KEYS_COUNT; i++)
236         if (vlc_keys[i].i_key_code == key)
237         {
238             name = vlc_keys[i].psz_key_string;
239             goto found;
240         }
241
242     if (utf8_cp (key, buf) == NULL)
243         return NULL;
244     name = buf;
245
246 found:
247     if (asprintf (&str, "%s%s%s%s%s%s",
248                   (code & KEY_MODIFIER_CTRL) ? tr(N_("Ctrl+")) : "",
249                   (code & KEY_MODIFIER_ALT) ? tr(N_("Alt+")) : "",
250                   (code & KEY_MODIFIER_SHIFT) ? tr(N_("Shift+")) : "",
251                   (code & KEY_MODIFIER_META) ? tr(N_("Meta+")) : "",
252                   (code & KEY_MODIFIER_COMMAND) ? tr(N_("Command+")) : "",
253                   tr(name)) == -1)
254         return NULL;
255     return str;
256 }
257
258
259 /*** VLC key map ***/
260
261 #define MAXACTION 20
262 struct action
263 {
264     char name[MAXACTION];
265     vlc_action_t value;
266 };
267
268 static const struct action actions[] =
269 {
270     /* *MUST* be sorted (ASCII order) */
271     { "aspect-ratio", ACTIONID_ASPECT_RATIO, },
272     { "audio-track", ACTIONID_AUDIO_TRACK, },
273     { "audiodelay-down", ACTIONID_AUDIODELAY_DOWN, },
274     { "audiodelay-up", ACTIONID_AUDIODELAY_UP, },
275     { "audiodevice-cycle", ACTIONID_AUDIODEVICE_CYCLE, },
276     { "chapter-next", ACTIONID_CHAPTER_NEXT, },
277     { "chapter-prev", ACTIONID_CHAPTER_PREV, },
278     { "crop", ACTIONID_CROP, },
279     { "crop-bottom", ACTIONID_CROP_BOTTOM, },
280     { "crop-left", ACTIONID_CROP_LEFT, },
281     { "crop-right", ACTIONID_CROP_RIGHT, },
282     { "crop-top", ACTIONID_CROP_TOP, },
283     { "decr-scalefactor", ACTIONID_SCALE_DOWN, },
284     { "deinterlace", ACTIONID_DEINTERLACE, },
285     { "deinterlace-mode", ACTIONID_DEINTERLACE_MODE, },
286     { "disc-menu", ACTIONID_DISC_MENU, },
287     { "faster", ACTIONID_FASTER, },
288     { "frame-next", ACTIONID_FRAME_NEXT, },
289     { "incr-scalefactor", ACTIONID_SCALE_UP, },
290     { "intf-boss", ACTIONID_INTF_BOSS, },
291     { "intf-popup-menu", ACTIONID_INTF_POPUP_MENU, },
292     { "intf-show", ACTIONID_INTF_TOGGLE_FSC, },
293     { "jump+extrashort", ACTIONID_JUMP_FORWARD_EXTRASHORT, },
294     { "jump+long", ACTIONID_JUMP_FORWARD_LONG, },
295     { "jump+medium", ACTIONID_JUMP_FORWARD_MEDIUM, },
296     { "jump+short", ACTIONID_JUMP_FORWARD_SHORT, },
297     { "jump-extrashort", ACTIONID_JUMP_BACKWARD_EXTRASHORT, },
298     { "jump-long", ACTIONID_JUMP_BACKWARD_LONG, },
299     { "jump-medium", ACTIONID_JUMP_BACKWARD_MEDIUM, },
300     { "jump-short", ACTIONID_JUMP_BACKWARD_SHORT, },
301     { "leave-fullscreen", ACTIONID_LEAVE_FULLSCREEN, },
302     { "loop", ACTIONID_LOOP, },
303     { "nav-activate", ACTIONID_NAV_ACTIVATE, },
304     { "nav-down", ACTIONID_NAV_DOWN, },
305     { "nav-left", ACTIONID_NAV_LEFT, },
306     { "nav-right", ACTIONID_NAV_RIGHT, },
307     { "nav-up", ACTIONID_NAV_UP, },
308     { "next", ACTIONID_NEXT, },
309     { "pause", ACTIONID_PAUSE, },
310     { "play", ACTIONID_PLAY, },
311     { "play-bookmark1", ACTIONID_PLAY_BOOKMARK1, },
312     { "play-bookmark10", ACTIONID_PLAY_BOOKMARK10, },
313     { "play-bookmark2", ACTIONID_PLAY_BOOKMARK2, },
314     { "play-bookmark3", ACTIONID_PLAY_BOOKMARK3, },
315     { "play-bookmark4", ACTIONID_PLAY_BOOKMARK4, },
316     { "play-bookmark5", ACTIONID_PLAY_BOOKMARK5, },
317     { "play-bookmark6", ACTIONID_PLAY_BOOKMARK6, },
318     { "play-bookmark7", ACTIONID_PLAY_BOOKMARK7, },
319     { "play-bookmark8", ACTIONID_PLAY_BOOKMARK8, },
320     { "play-bookmark9", ACTIONID_PLAY_BOOKMARK9, },
321     { "play-pause", ACTIONID_PLAY_PAUSE, },
322     { "position", ACTIONID_POSITION, },
323     { "prev", ACTIONID_PREV, },
324     { "program-sid", ACTIONID_PROGRAM_SID, },
325     { "quit", ACTIONID_QUIT, },
326     { "random", ACTIONID_RANDOM, },
327     { "rate-faster-fine", ACTIONID_RATE_FASTER_FINE, },
328     { "rate-normal", ACTIONID_RATE_NORMAL, },
329     { "rate-slower-fine", ACTIONID_RATE_SLOWER_FINE, },
330     { "record", ACTIONID_RECORD, },
331     { "set-bookmark1", ACTIONID_SET_BOOKMARK1, },
332     { "set-bookmark10", ACTIONID_SET_BOOKMARK10, },
333     { "set-bookmark2", ACTIONID_SET_BOOKMARK2, },
334     { "set-bookmark3", ACTIONID_SET_BOOKMARK3, },
335     { "set-bookmark4", ACTIONID_SET_BOOKMARK4, },
336     { "set-bookmark5", ACTIONID_SET_BOOKMARK5, },
337     { "set-bookmark6", ACTIONID_SET_BOOKMARK6, },
338     { "set-bookmark7", ACTIONID_SET_BOOKMARK7, },
339     { "set-bookmark8", ACTIONID_SET_BOOKMARK8, },
340     { "set-bookmark9", ACTIONID_SET_BOOKMARK9, },
341     { "slower", ACTIONID_SLOWER, },
342     { "snapshot", ACTIONID_SNAPSHOT, },
343     { "stop", ACTIONID_STOP, },
344     { "subdelay-down", ACTIONID_SUBDELAY_DOWN, },
345     { "subdelay-up", ACTIONID_SUBDELAY_UP, },
346     { "subpos-down", ACTIONID_SUBPOS_DOWN, },
347     { "subpos-up", ACTIONID_SUBPOS_UP, },
348     { "subtitle-track", ACTIONID_SUBTITLE_TRACK, },
349     { "title-next", ACTIONID_TITLE_NEXT, },
350     { "title-prev", ACTIONID_TITLE_PREV, },
351     { "toggle-autoscale", ACTIONID_TOGGLE_AUTOSCALE, },
352     { "toggle-fullscreen", ACTIONID_TOGGLE_FULLSCREEN, },
353     { "uncrop-bottom", ACTIONID_UNCROP_BOTTOM, },
354     { "uncrop-left", ACTIONID_UNCROP_LEFT, },
355     { "uncrop-right", ACTIONID_UNCROP_RIGHT, },
356     { "uncrop-top", ACTIONID_UNCROP_TOP, },
357     { "unzoom", ACTIONID_UNZOOM, },
358     { "vol-down", ACTIONID_VOL_DOWN, },
359     { "vol-mute", ACTIONID_VOL_MUTE, },
360     { "vol-up", ACTIONID_VOL_UP, },
361     { "wallpaper", ACTIONID_WALLPAPER, },
362     { "zoom", ACTIONID_ZOOM, },
363     { "zoom-double", ACTIONID_ZOOM_DOUBLE, },
364     { "zoom-half", ACTIONID_ZOOM_HALF, },
365     { "zoom-original", ACTIONID_ZOOM_ORIGINAL, },
366     { "zoom-quarter", ACTIONID_ZOOM_QUARTER, },
367 };
368 #define ACTIONS_COUNT (sizeof (actions) / sizeof (actions[0]))
369
370 struct mapping
371 {
372     uint32_t     key; ///< Key code
373     vlc_action_t action; ///< Action ID
374 };
375
376 static int keycmp (const void *a, const void *b)
377 {
378     const struct mapping *ka = a, *kb = b;
379
380 #if (INT_MAX >= 0x7fffffff)
381     return ka->key - kb->key;
382 #else
383     return (ka->key < kb->key) ? -1 : (ka->key > kb->key) ? +1 : 0;
384 #endif
385 }
386
387 struct vlc_actions
388 {
389     void *map; /* Key map */
390     void *global_map; /* Grabbed/global key map */
391     struct hotkey keys[0];
392 };
393
394 static int vlc_key_to_action (vlc_object_t *obj, const char *varname,
395                               vlc_value_t prevkey, vlc_value_t curkey, void *d)
396 {
397     void *const *map = d;
398     const struct mapping **pent;
399     uint32_t keycode = curkey.i_int;
400
401     pent = tfind (&keycode, map, keycmp);
402     if (pent == NULL)
403         return VLC_SUCCESS;
404
405     (void) varname;
406     (void) prevkey;
407     return var_SetInteger (obj, "key-action", (*pent)->action);
408 }
409
410 /**
411  * Adds a mapping from a certain key code to a certain action.
412  */
413 static int vlc_AddMapping (void **map, uint32_t keycode, vlc_action_t action)
414 {
415     struct mapping *entry = malloc (sizeof (*entry));
416     if (entry == NULL)
417         return ENOMEM;
418     entry->key = keycode;
419     entry->action = action;
420
421     struct mapping **pent = tsearch (entry, map, keycmp);
422     if (unlikely(pent == NULL))
423         return ENOMEM;
424     if (*pent != entry)
425     {
426         free (entry);
427         return EEXIST;
428     }
429     return 0;
430 }
431
432 /**
433  * Sets up all key mappings for a given action.
434  * \param map tree (of struct mapping entries) to write mappings to
435  * \param confname VLC configuration item to read mappings from
436  * \param action action ID
437  */
438 static void vlc_InitAction (vlc_object_t *obj, void **map,
439                             const char *confname, vlc_action_t action)
440 {
441     char *keys = var_InheritString (obj, confname);
442     if (keys == NULL)
443         return;
444
445     for (char *buf, *key = strtok_r (keys, "\t", &buf);
446          key != NULL;
447          key = strtok_r (NULL, "\t", &buf))
448     {
449         uint32_t code = vlc_str2keycode (key);
450         if (code == KEY_UNSET)
451         {
452             msg_Warn (obj, "Key \"%s\" unrecognized", key);
453             continue;
454         }
455
456         if (vlc_AddMapping (map, code, action) == EEXIST)
457             msg_Warn (obj, "Key \"%s\" bound to multiple actions", key);
458     }
459     free (keys);
460 }
461
462 /**
463  * Initializes the key map from configuration.
464  */
465 struct vlc_actions *vlc_InitActions (libvlc_int_t *libvlc)
466 {
467     vlc_object_t *obj = VLC_OBJECT(libvlc);
468     struct hotkey *keys;
469     struct vlc_actions *as = malloc (sizeof (*as) + (ACTIONS_COUNT + 1) * sizeof (*keys));
470
471     if (unlikely(as == NULL))
472         return NULL;
473     as->map = NULL;
474     as->global_map = NULL;
475     keys = as->keys;
476
477     var_Create (obj, "key-pressed", VLC_VAR_INTEGER);
478     var_Create (obj, "global-key-pressed", VLC_VAR_INTEGER);
479     var_Create (obj, "key-action", VLC_VAR_INTEGER);
480
481     /* Initialize from configuration */
482     for (size_t i = 0; i < ACTIONS_COUNT; i++)
483     {
484 #ifndef NDEBUG
485         if (i > 0
486          && strcmp (actions[i-1].name, actions[i].name) >= 0)
487         {
488             msg_Err (libvlc, "key-%s and key-%s are not ordered properly",
489                      actions[i-1].name, actions[i].name);
490             abort ();
491         }
492 #endif
493         keys->psz_action = actions[i].name;
494         keys++;
495
496         char name[12 + MAXACTION];
497
498         snprintf (name, sizeof (name), "global-key-%s", actions[i].name);
499         vlc_InitAction (obj, &as->map, name + 7, actions[i].value);
500         vlc_InitAction (obj, &as->global_map, name, actions[i].value);
501     }
502     keys->psz_action = NULL;
503
504     /* Initialize mouse wheel events */
505     int mousemode = var_InheritInteger (obj, "hotkeys-mousewheel-mode");
506     if (mousemode < 2)
507     {
508         vlc_AddMapping (&as->map,
509                         mousemode ? KEY_MOUSEWHEELRIGHT : KEY_MOUSEWHEELUP,
510                         ACTIONID_VOL_UP);
511         vlc_AddMapping (&as->map,
512                         mousemode ? KEY_MOUSEWHEELLEFT : KEY_MOUSEWHEELDOWN,
513                         ACTIONID_VOL_DOWN);
514         vlc_AddMapping (&as->map,
515                         mousemode ? KEY_MOUSEWHEELUP : KEY_MOUSEWHEELRIGHT,
516                         ACTIONID_JUMP_FORWARD_EXTRASHORT);
517         vlc_AddMapping (&as->map,
518                         mousemode ? KEY_MOUSEWHEELDOWN : KEY_MOUSEWHEELLEFT,
519                         ACTIONID_JUMP_BACKWARD_EXTRASHORT);
520     }
521
522
523     libvlc->p_hotkeys = as->keys;
524     var_AddCallback (obj, "key-pressed", vlc_key_to_action, &as->map);
525     var_AddCallback (obj, "global-key-pressed", vlc_key_to_action,
526                      &as->global_map);
527     return as;
528 }
529
530 /**
531  * Destroys the key map.
532  */
533 void vlc_DeinitActions (libvlc_int_t *libvlc, struct vlc_actions *as)
534 {
535     if (unlikely(as == NULL))
536         return;
537
538     var_DelCallback (libvlc, "global-key-pressed", vlc_key_to_action,
539                      &as->global_map);
540     var_DelCallback (libvlc, "key-pressed", vlc_key_to_action, &as->map);
541
542     tdestroy (as->global_map, free);
543     tdestroy (as->map, free);
544     free (as);
545     libvlc->p_hotkeys = NULL;
546 }
547
548
549 static int actcmp(const void *key, const void *ent)
550 {
551     const struct action *act = ent;
552     return strcmp(key, act->name);
553 }
554
555 /**
556  * Get the action ID from the action name in the configuration subsystem.
557  * @return the action ID or ACTIONID_NONE on error.
558  */
559 vlc_action_t vlc_GetActionId (const char *name)
560 {
561     const struct action *act;
562
563     if (strncmp (name, "key-", 4))
564         return ACTIONID_NONE;
565     name += 4;
566
567     act = bsearch(name, actions, ACTIONS_COUNT, sizeof(*act), actcmp);
568     return (act != NULL) ? act->value : ACTIONID_NONE;
569 }