girara
 All Data Structures Files Functions Variables Typedefs Enumerations Enumerator Macros
commands.c
Go to the documentation of this file.
1 /* See LICENSE file for license and copyright information */
2 
3 #include <string.h>
4 #include <stdlib.h>
5 #include <glib/gi18n-lib.h>
6 
7 #include "commands.h"
8 #include "datastructures.h"
9 #include "session.h"
10 #include "internal.h"
11 #include "utils.h"
12 #include "settings.h"
13 #include "shortcuts.h"
14 
15 /* default commands implementation */
16 bool
17 girara_cmd_map_unmap(girara_session_t* session, girara_list_t* argument_list,
18  bool unmap)
19 {
20  typedef struct gdk_keyboard_button_s
21  {
22  char* identifier;
23  int keyval;
24  } gdk_keyboard_button_t;
25 
26  static const gdk_keyboard_button_t gdk_keyboard_buttons[] = {
27  {"BackSpace", GDK_KEY_BackSpace},
28  {"CapsLock", GDK_KEY_Caps_Lock},
29  {"Down", GDK_KEY_Down},
30  {"Esc", GDK_KEY_Escape},
31  {"F10", GDK_KEY_F10},
32  {"F11", GDK_KEY_F11},
33  {"F12", GDK_KEY_F12},
34  {"F1", GDK_KEY_F1},
35  {"F2", GDK_KEY_F2},
36  {"F3", GDK_KEY_F3},
37  {"F4", GDK_KEY_F4},
38  {"F5", GDK_KEY_F5},
39  {"F6", GDK_KEY_F6},
40  {"F7", GDK_KEY_F7},
41  {"F8", GDK_KEY_F8},
42  {"F9", GDK_KEY_F9},
43  {"Left", GDK_KEY_Left},
44  {"PageDown", GDK_KEY_Page_Down},
45  {"PageUp", GDK_KEY_Page_Up},
46  {"Home", GDK_KEY_Home},
47  {"End", GDK_KEY_End},
48  {"Return", GDK_KEY_Return},
49  {"Right", GDK_KEY_Right},
50  {"Space", GDK_KEY_space},
51  {"Super", GDK_KEY_Super_L},
52  {"Tab", GDK_KEY_Tab},
53  {"ShiftTab", GDK_KEY_ISO_Left_Tab},
54  {"Up", GDK_KEY_Up}
55  };
56 
57  typedef struct gdk_mouse_button_s
58  {
59  char* identifier;
60  int button;
61  } gdk_mouse_button_t;
62 
63  static const gdk_mouse_button_t gdk_mouse_buttons[] = {
64  {"Button1", GIRARA_MOUSE_BUTTON1},
65  {"Button2", GIRARA_MOUSE_BUTTON2},
66  {"Button3", GIRARA_MOUSE_BUTTON3},
67  {"Button4", GIRARA_MOUSE_BUTTON4},
68  {"Button5", GIRARA_MOUSE_BUTTON5},
69  {"Button6", GIRARA_MOUSE_BUTTON6},
70  {"Button7", GIRARA_MOUSE_BUTTON7},
71  {"Button8", GIRARA_MOUSE_BUTTON8},
72  {"Button9", GIRARA_MOUSE_BUTTON9}
73  };
74 
75  typedef struct event_type_s
76  {
77  char* identifier;
78  int event;
79  } event_type_t;
80 
81  static const event_type_t event_types[] = {
82  {"motion", GIRARA_EVENT_MOTION_NOTIFY},
83  {"scroll_up", GIRARA_EVENT_SCROLL_UP},
84  {"scroll_down", GIRARA_EVENT_SCROLL_DOWN},
85  {"scroll_left", GIRARA_EVENT_SCROLL_LEFT},
86  {"scroll_right", GIRARA_EVENT_SCROLL_RIGHT}
87  };
88 
89  typedef struct mouse_event_s
90  {
91  char* identifier;
92  int event;
93  } mouse_event_t;
94 
95  static const mouse_event_t mouse_events[] = {
96  {"button-pressed", GIRARA_EVENT_BUTTON_PRESS},
97  {"2-button-pressed", GIRARA_EVENT_2BUTTON_PRESS},
98  {"3-button-pressed", GIRARA_EVENT_2BUTTON_PRESS},
99  {"button-released", GIRARA_EVENT_BUTTON_RELEASE}
100  };
101 
102  const size_t number_of_arguments = girara_list_size(argument_list);
103 
104  unsigned int limit = (unmap == true) ? 1 : 2;
105  if (number_of_arguments < limit) {
106  girara_warning("Invalid number of arguments passed: %zu instead of at least %u", number_of_arguments, limit);
107  girara_notify(session, GIRARA_ERROR,
108  _("Invalid number of arguments passed: %zu instead of at least %u"), number_of_arguments, limit);
109  return false;
110  }
111 
112  int shortcut_mask = 0;
113  int shortcut_key = 0;
114  int shortcut_mouse_button = 0;
115  girara_mode_t shortcut_mode = session->modes.normal;
116  char* shortcut_argument_data = NULL;
117  int shortcut_argument_n = 0;
118  char* shortcut_buffer_command = NULL;
120  girara_shortcut_function_t shortcut_function = NULL;
121  bool mouse_event = false;
122 
123  size_t current_command = 0;
124  char* tmp = girara_list_nth(argument_list, current_command);
125  size_t tmp_length = strlen(tmp);
126 
127  /* Check first argument for mode */
128  bool is_mode = false;
129  if (tmp_length >= 3 && tmp[0] == '[' && tmp[tmp_length - 1] == ']') {
130  char* tmp_inner = g_strndup(tmp + 1, tmp_length - 2);
131 
132  GIRARA_LIST_FOREACH(session->modes.identifiers, girara_mode_string_t*, iter, mode)
133  if (!g_strcmp0(tmp_inner, mode->name)) {
134  shortcut_mode = mode->index;
135  is_mode = true;
136  break;
137  }
138  GIRARA_LIST_FOREACH_END(session->modes.identifiers, girara_mode_string_t*, iter, mode);
139 
140  if (is_mode == false) {
141  girara_warning("Unregistered mode specified: %s", tmp_inner);
142  girara_notify(session, GIRARA_ERROR, _("Unregistered mode specified: %s"), tmp_inner);
143  g_free(tmp_inner);
144  return false;
145  }
146  g_free(tmp_inner);
147  }
148 
149  if (is_mode == true) {
150  tmp = girara_list_nth(argument_list, ++current_command);
151  tmp_length = strlen(tmp);
152  }
153 
154  /* Check for multi key shortcut */
155  if (tmp_length >= 3 && tmp[0] == '<' && tmp[tmp_length - 1] == '>') {
156  tmp = g_strndup(tmp + 1, tmp_length - 2);
157  tmp_length = strlen(tmp);
158 
159  /* Multi key shortcut */
160  if (strchr(tmp, '-') != NULL && tmp[1] == '-' && tmp_length > 2) {
161  switch (tmp[0]) {
162  case 'S':
163  shortcut_mask = GDK_SHIFT_MASK;
164  break;
165  case 'A':
166  case 'M':
167  shortcut_mask = GDK_MOD1_MASK;
168  break;
169  case 'C':
170  shortcut_mask = GDK_CONTROL_MASK;
171  break;
172  default:
173  girara_warning("Invalid modifier in %s", tmp);
174  girara_notify(session, GIRARA_ERROR, _("Invalid modifier in %s"), tmp);
175  g_free(tmp);
176  return false;
177  }
178 
179  /* Single key */
180  if (tmp_length == 3) {
181  shortcut_key = tmp[2];
182  /* Possible special key */
183  } else {
184  bool found = false;
185  for (unsigned int i = 0; i < LENGTH(gdk_keyboard_buttons); i++) {
186  if (g_strcmp0(tmp + 2, gdk_keyboard_buttons[i].identifier) == 0) {
187  shortcut_key = gdk_keyboard_buttons[i].keyval;
188  found = true;
189  break;
190  }
191  }
192 
193  for (unsigned int i = 0; i < LENGTH(gdk_mouse_buttons); i++) {
194  if (!g_strcmp0(tmp + 2, gdk_mouse_buttons[i].identifier)) {
195  shortcut_mouse_button = gdk_mouse_buttons[i].button;
196  mouse_event = true;
197  found = true;
198  break;
199  }
200  }
201 
202  for (unsigned int i = 0; i < LENGTH(event_types); i++) {
203  if (!g_strcmp0(tmp + 2, event_types[i].identifier)) {
204  event_type = event_types[i].event;
205  mouse_event = true;
206  found = true;
207  break;
208  }
209  }
210 
211  if (found == false) {
212  girara_warning("Invalid special key value or mode: %s", tmp);
213  girara_notify(session, GIRARA_ERROR, _("Invalid special key value for %s"), tmp);
214  g_free(tmp);
215  return false;
216  }
217  }
218  /* Possible special key */
219  } else {
220  bool found = false;
221  for (unsigned int i = 0; i < LENGTH(gdk_keyboard_buttons); i++) {
222  if (g_strcmp0(tmp, gdk_keyboard_buttons[i].identifier) == 0) {
223  shortcut_key = gdk_keyboard_buttons[i].keyval;
224  found = true;
225  break;
226  }
227  }
228 
229  for (unsigned int i = 0; i < LENGTH(gdk_mouse_buttons); i++) {
230  if (!g_strcmp0(tmp, gdk_mouse_buttons[i].identifier)) {
231  shortcut_mouse_button = gdk_mouse_buttons[i].button;
232  mouse_event = true;
233  found = true;
234  break;
235  }
236  }
237 
238  for (unsigned int i = 0; i < LENGTH(event_types); i++) {
239  if (!g_strcmp0(tmp, event_types[i].identifier)) {
240  event_type = event_types[i].event;
241  mouse_event = true;
242  found = true;
243  break;
244  }
245  }
246 
247  if (found == false) {
248  girara_warning("Invalid special key value or mode: %s", tmp);
249  girara_notify(session, GIRARA_ERROR, _("Invalid special key value or mode %s"), tmp);
250  g_free(tmp);
251  return false;
252  }
253  }
254 
255  g_free(tmp);
256  /* Single key shortcut */
257  } else if (tmp_length == 1) {
258  shortcut_key = tmp[0];
259  /* Buffer command */
260  } else {
261  shortcut_buffer_command = g_strdup(tmp);
262  }
263 
264  /* check for mouse mode */
265  bool mouse_mode = false;
266  if (unmap == false) {
267  if (++current_command < number_of_arguments) {
268  tmp = girara_list_nth(argument_list, current_command);
269  tmp_length = strlen(tmp);
270 
271  if (tmp_length >= 3 && tmp[0] == '[' && tmp[tmp_length - 1] == ']') {
272  mouse_mode = true;
273  if (mouse_event == false) {
274  girara_warning("Mode passed on non-mouse event: %s", tmp);
275  return false;
276  }
277 
278  char* tmp_inner = g_strndup(tmp + 1, tmp_length - 2);
279 
280  bool found = false;
281  for (unsigned int i = 0; i < LENGTH(mouse_events); i++) {
282  if (!g_strcmp0(tmp_inner, mouse_events[i].identifier)) {
283  event_type = mouse_events[i].event;
284  found = true;
285  break;
286  }
287  }
288 
289  if (found == false) {
290  girara_warning("Invalid mouse event mode has been passed: %s", tmp_inner);
291  g_free(tmp_inner);
292  return false;
293  }
294 
295  g_free(tmp_inner);
296  }
297  } else {
298  girara_warning("Invalid number of arguments passed");
299  return false;
300  }
301  }
302 
303  if (unmap == false) {
304  limit = (mouse_mode == true) ? 3 : 2;
305  if (number_of_arguments < limit) {
306  girara_warning("Invalid number of arguments passed: %zu instead of at least %u", number_of_arguments, limit);
307  girara_notify(session, GIRARA_ERROR,
308  _("Invalid number of arguments passed: %zu instead of at least %u"), number_of_arguments, limit);
309  return false;
310  }
311 
312  if (mouse_mode == true) {
313  tmp = girara_list_nth(argument_list, ++current_command);
314  }
315  }
316 
317  /* Check for passed shortcut command */
318  if (unmap == false) {
319  bool found_mapping = false;
320  GIRARA_LIST_FOREACH(session->config.shortcut_mappings, girara_shortcut_mapping_t*, iter, mapping)
321  if (!g_strcmp0(tmp, mapping->identifier)) {
322  shortcut_function = mapping->function;
323  found_mapping = true;
324  break;
325  }
326  GIRARA_LIST_FOREACH_END(session->config.shortcut_mappings, girara_shortcut_mapping_t*, iter, mapping);
327 
328  if (found_mapping == false) {
329  girara_warning("Not a valid shortcut function: %s", tmp);
330  girara_notify(session, GIRARA_ERROR, _("Not a valid shortcut function: %s"), tmp);
331  if (shortcut_buffer_command) {
332  g_free(shortcut_buffer_command);
333  }
334  return false;
335  }
336  }
337 
338  /* Check for passed argument */
339  if (unmap == false) {
340  if (++current_command < number_of_arguments) {
341  tmp = (char*) girara_list_nth(argument_list, current_command);
342 
343  GIRARA_LIST_FOREACH(session->config.argument_mappings, girara_argument_mapping_t*, iter, mapping)
344  if (!g_strcmp0(tmp, mapping->identifier)) {
345  shortcut_argument_n = mapping->value;
346  break;
347  }
348  GIRARA_LIST_FOREACH_END(session->config.argument_mappings, girara_argument_mapping_t*, iter, mapping);
349 
350  /* If no known argument is passed we save it in the data field */
351  if (shortcut_argument_n == 0) {
352  shortcut_argument_data = tmp;
353  /* If a known argument is passed and there are still more arguments,
354  * we save the next one in the data field */
355  } else if (++current_command < number_of_arguments) {
356  tmp = (char*) girara_list_nth(argument_list, current_command);
357  shortcut_argument_data = tmp;
358  }
359  }
360  }
361 
362  if (mouse_event == false) {
363  if (unmap == true) {
364  girara_shortcut_remove(session, shortcut_mask, shortcut_key,
365  shortcut_buffer_command, shortcut_mode);
366  } else {
367  girara_shortcut_add(session, shortcut_mask, shortcut_key, shortcut_buffer_command,
368  shortcut_function, shortcut_mode, shortcut_argument_n, shortcut_argument_data);
369  }
370  } else {
371  if (unmap == true) {
372  girara_mouse_event_remove(session, shortcut_mask, shortcut_mouse_button,
373  shortcut_mode);
374  } else {
375  girara_mouse_event_add(session, shortcut_mask, shortcut_mouse_button,
376  shortcut_function, shortcut_mode, event_type, shortcut_argument_n, shortcut_argument_data);
377  }
378  }
379 
380  if (shortcut_buffer_command) {
381  g_free(shortcut_buffer_command);
382  }
383 
384  return true;
385 }
386 
387 bool
388 girara_cmd_map(girara_session_t* session, girara_list_t* argument_list)
389 {
390  return girara_cmd_map_unmap(session, argument_list, false);
391 }
392 
393 bool
394 girara_cmd_unmap(girara_session_t* session, girara_list_t* argument_list)
395 {
396  return girara_cmd_map_unmap(session, argument_list, true);
397 }
398 
399 
400 bool
401 girara_cmd_quit(girara_session_t* session, girara_list_t* UNUSED(argument_list))
402 {
403  girara_argument_t arg = { GIRARA_HIDE, NULL };
404  girara_isc_completion(session, &arg, NULL, 0);
405 
406  gtk_main_quit();
407 
408  return true;
409 }
410 
411 bool
412 girara_cmd_set(girara_session_t* session, girara_list_t* argument_list)
413 {
414  const size_t number_of_arguments = girara_list_size(argument_list);
415 
416  if (number_of_arguments == 0) {
417  girara_warning("Not enough arguments for :set.");
418  girara_notify(session, GIRARA_ERROR, _("Not enough arguments."));
419  return false;
420  }
421  if (number_of_arguments > 2) {
422  girara_warning("Too many arguments for :set.");
423  girara_notify(session, GIRARA_ERROR, _("Too many arguments."));
424  return false;
425  }
426 
427  /* search for existing setting */
428  char* name = (char*) girara_list_nth(argument_list, 0);
429  if (name == NULL) {
430  return false;
431  }
432 
433  girara_setting_t* setting = girara_setting_find(session, name);
434  if (setting == NULL) {
435  girara_warning("Unknown option: %s", name);
436  girara_notify(session, GIRARA_ERROR, _("Unknown option: %s"), name);
437  return false;
438  }
439 
440  if (number_of_arguments == 1) {
441  /* display setting*/
442  switch (girara_setting_get_type(setting)) {
443  case BOOLEAN:
444  {
445  /* for compatibility reasons: toogle the setting */
446  bool value = false;
447  girara_setting_get_value(setting, &value);
448  bool tmp = !value;
449  girara_setting_set_value(session, setting, &tmp);
450  girara_notify(session, GIRARA_INFO, "%s: %s", name, tmp ? _("true") : _("false"));
451  break;
452  }
453  case FLOAT:
454  {
455  float value = 0;
456  girara_setting_get_value(setting, &value);
457  girara_notify(session, GIRARA_INFO, "%s: %f", name, value);
458  break;
459  }
460  case INT:
461  {
462  int value = 0;
463  girara_setting_get_value(setting, &value);
464  girara_notify(session, GIRARA_INFO, "%s: %i", name, value);
465  break;
466  }
467  case STRING:
468  {
469  char* str = NULL;
470  girara_setting_get_value(setting, &str);
471  girara_notify(session, GIRARA_INFO, "%s: %s", name, str ? str : "(NULL)");
472  g_free(str);
473  break;
474  }
475  default:
476  return false;
477  }
478  } else {
479  char* value = (char*) girara_list_nth(argument_list, 1);
480  if (value == NULL) {
481  girara_warning("No value defined for option: %s", name);
482  girara_notify(session, GIRARA_ERROR, _("No value defined for option: %s"), name);
483  return false;
484  }
485 
486  /* update value */
487  switch (girara_setting_get_type(setting)) {
488  case BOOLEAN:
489  if (g_strcmp0(value, "false") == 0 || g_strcmp0(value, "0") == 0) {
490  bool b = false;
491  girara_setting_set_value(session, setting, &b);
492  } else if (g_strcmp0(value, "true") == 0 || g_strcmp0(value, "1") == 0) {
493  bool b = true;
494  girara_setting_set_value(session, setting, &b);
495  } else {
496  girara_warning("Unknown value for option: %s", name);
497  girara_notify(session, GIRARA_ERROR, _("Unknown value for option: %s"), name);
498  }
499  break;
500  case FLOAT:
501  {
502  float f = g_ascii_strtod(value, NULL);
503  girara_setting_set_value(session, setting, &f);
504  break;
505  }
506  case INT:
507  {
508  int i = atoi(value);
509  girara_setting_set_value(session, setting, &i);
510  break;
511  }
512  case STRING:
513  girara_setting_set_value(session, setting, value);
514  break;
515  default:
516  return false;
517  }
518  }
519 
520  return true;
521 }
522 
523 bool
524 girara_inputbar_command_add(girara_session_t* session, const char* command,
525  const char* abbreviation, girara_command_function_t function,
526  girara_completion_function_t completion, const char* description)
527 {
528  g_return_val_if_fail(session != NULL, false);
529  g_return_val_if_fail(command != NULL, false);
530  g_return_val_if_fail(function != NULL, false);
531 
532  /* search for existing binding */
533  GIRARA_LIST_FOREACH(session->bindings.commands, girara_command_t*, iter, commands_it)
534  if (g_strcmp0(commands_it->command, command) == 0) {
535  g_free(commands_it->abbr);
536  g_free(commands_it->description);
537 
538  commands_it->abbr = abbreviation ? g_strdup(abbreviation) : NULL;
539  commands_it->function = function;
540  commands_it->completion = completion;
541  commands_it->description = description ? g_strdup(description) : NULL;
542 
544  return true;
545  }
546  GIRARA_LIST_FOREACH_END(session->bindings.commands, girara_command_t*, iter, commands_it);
547 
548  /* add new inputbar command */
549  girara_command_t* new_command = g_slice_new(girara_command_t);
550 
551  new_command->command = g_strdup(command);
552  new_command->abbr = abbreviation ? g_strdup(abbreviation) : NULL;
553  new_command->function = function;
554  new_command->completion = completion;
555  new_command->description = description ? g_strdup(description) : NULL;
556  girara_list_append(session->bindings.commands, new_command);
557 
558  return true;
559 }
560 
561 bool
562 girara_special_command_add(girara_session_t* session, char identifier, girara_inputbar_special_function_t function, bool always, int argument_n, void* argument_data)
563 {
564  g_return_val_if_fail(session != NULL, false);
565  g_return_val_if_fail(function != NULL, false);
566 
567  girara_argument_t argument = {argument_n, argument_data};
568 
569  /* search for existing special command */
570  GIRARA_LIST_FOREACH(session->bindings.special_commands, girara_special_command_t*, iter, scommand_it)
571  if (scommand_it->identifier == identifier) {
572  scommand_it->function = function;
573  scommand_it->always = always;
574  scommand_it->argument = argument;
576  return true;
577  }
578  GIRARA_LIST_FOREACH_END(session->bindings.special_commands, girara_special_command_t*, iter, scommand_it);
579 
580  /* create new special command */
581  girara_special_command_t* special_command = g_slice_new(girara_special_command_t);
582 
583  special_command->identifier = identifier;
584  special_command->function = function;
585  special_command->always = always;
586  special_command->argument = argument;
587 
588  girara_list_append(session->bindings.special_commands, special_command);
589 
590  return true;
591 }
592 
593 void
594 girara_special_command_free(girara_special_command_t* special_command)
595 {
596  if (special_command == NULL) {
597  return;
598  }
599  g_slice_free(girara_special_command_t, special_command);
600 }
601 
602 void
603 girara_command_free(girara_command_t* command)
604 {
605  if (command == NULL) {
606  return;
607  }
608 
609  g_free(command->command);
610  g_free(command->abbr);
611  g_free(command->description);
612  g_slice_free(girara_command_t, command);
613 }
614 
615 bool
616 girara_cmd_exec(girara_session_t* session, girara_list_t* argument_list)
617 {
618  if (session == NULL || argument_list == NULL) {
619  return true;
620  }
621 
622  return girara_exec_with_argument_list(session, argument_list);
623 }
bool girara_shortcut_add(girara_session_t *session, guint modifier, guint key, const char *buffer, girara_shortcut_function_t function, girara_mode_t mode, int argument_n, void *argument_data)
Definition: shortcuts.c:18
int girara_mode_t
Definition: types.h:69
void girara_special_command_free(girara_special_command_t *special_command)
Definition: commands.c:594
void girara_setting_set_value(girara_session_t *session, girara_setting_t *setting, void *value)
Definition: settings.c:34
void * girara_list_nth(girara_list_t *list, size_t n)
#define LENGTH(x)
Definition: internal.h:18
girara_setting_t * girara_setting_find(girara_session_t *session, const char *name)
Definition: settings.c:168
void girara_list_append(girara_list_t *list, void *data)
girara_event_type_t
Definition: types.h:188
#define UNUSED(x)
Definition: internal.h:15
size_t girara_list_size(girara_list_t *list)
bool girara_setting_get_value(girara_setting_t *setting, void *dest)
Definition: settings.c:110
bool girara_cmd_exec(girara_session_t *session, girara_list_t *argument_list)
Definition: commands.c:616
Definition: types.h:144
bool girara_cmd_map_unmap(girara_session_t *session, girara_list_t *argument_list, bool unmap)
Definition: commands.c:17
bool girara_cmd_set(girara_session_t *session, girara_list_t *argument_list)
Definition: commands.c:412
bool girara_isc_completion(girara_session_t *session, girara_argument_t *argument, girara_event_t *UNUSED(event), unsigned int UNUSED(t))
Definition: completion.c:139
bool girara_special_command_add(girara_session_t *session, char identifier, girara_inputbar_special_function_t function, bool always, int argument_n, void *argument_data)
Definition: commands.c:562
bool girara_mouse_event_add(girara_session_t *session, guint mask, guint button, girara_shortcut_function_t function, girara_mode_t mode, girara_event_type_t event_type, int argument_n, void *argument_data)
Definition: shortcuts.c:687
Definition: types.h:141
bool(* girara_shortcut_function_t)(girara_session_t *, girara_argument_t *, girara_event_t *, unsigned int)
Definition: types.h:110
bool girara_inputbar_command_add(girara_session_t *session, const char *command, const char *abbreviation, girara_command_function_t function, girara_completion_function_t completion, const char *description)
Definition: commands.c:524
void girara_list_iterator_free(girara_list_iterator_t *iter)
bool girara_cmd_quit(girara_session_t *session, girara_list_t *UNUSED(argument_list))
Definition: commands.c:401
Definition: types.h:143
#define girara_warning(...)
Definition: utils.h:128
Definition: types.h:142
bool girara_mouse_event_remove(girara_session_t *session, guint mask, guint button, girara_mode_t mode)
Definition: shortcuts.c:723
girara_setting_type_t girara_setting_get_type(girara_setting_t *setting)
Definition: settings.c:191
bool(* girara_command_function_t)(girara_session_t *session, girara_list_t *argument_list)
Definition: types.h:100
void girara_notify(girara_session_t *session, int level, const char *format,...)
Definition: session.c:509
void girara_command_free(girara_command_t *command)
Definition: commands.c:603
bool girara_cmd_unmap(girara_session_t *session, girara_list_t *argument_list)
Definition: commands.c:394
bool girara_exec_with_argument_list(girara_session_t *session, girara_list_t *argument_list)
Definition: utils.c:487
bool girara_shortcut_remove(girara_session_t *session, guint modifier, guint key, const char *buffer, girara_mode_t mode)
Definition: shortcuts.c:68
bool girara_cmd_map(girara_session_t *session, girara_list_t *argument_list)
Definition: commands.c:388
#define GIRARA_LIST_FOREACH_END(list, type, iter, data)
#define GIRARA_LIST_FOREACH(list, type, iter, data)
girara_completion_t *(* girara_completion_function_t)(girara_session_t *session, const char *input)
Definition: types.h:78
bool(* girara_inputbar_special_function_t)(girara_session_t *session, const char *input, girara_argument_t *argument)
Definition: types.h:90