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