NeoMutt  2024-04-25-127-g771158
Teaching an old dog new tricks
DOXYGEN
Loading...
Searching...
No Matches
get.c File Reference

Get a key from the user. More...

#include "config.h"
#include <stdbool.h>
#include <stddef.h>
#include <unistd.h>
#include "mutt/lib.h"
#include "config/lib.h"
#include "core/lib.h"
#include "gui/lib.h"
#include "key/lib.h"
#include "menu/lib.h"
#include "globals.h"
#include "monitor.h"
+ Include dependency graph for get.c:

Go to the source code of this file.

Functions

void mutt_flushinp (void)
 Empty all the keyboard buffers.
 
static struct KeyEventarray_pop (struct KeyEventArray *a)
 Remove an event from the array.
 
static void array_add (struct KeyEventArray *a, int ch, int op)
 Add an event to the end of the array.
 
static void array_to_endcond (struct KeyEventArray *a)
 Clear the array until an OP_END_COND.
 
void mutt_unget_ch (int ch)
 Return a keystroke to the input buffer.
 
void mutt_unget_op (int op)
 Return an operation to the input buffer.
 
void mutt_unget_string (const char *s)
 Return a string to the input buffer.
 
void mutt_push_macro_event (int ch, int op)
 Add the character/operation to the macro buffer.
 
void mutt_flush_macro_to_endcond (void)
 Drop a macro from the input buffer.
 
static int mutt_monitor_getch (void)
 Get a character and poll the filesystem monitor.
 
struct KeyEvent mutt_getch (GetChFlags flags)
 Read a character from the input buffer.
 
void km_error_key (enum MenuType mtype)
 Handle an unbound key sequence.
 
static struct KeyEvent retry_generic (enum MenuType mtype, keycode_t *keys, int keyslen, int lastkey, GetChFlags flags)
 Try to find the key in the generic menu bindings.
 
struct KeyEvent km_dokey_event (enum MenuType mtype, GetChFlags flags)
 Determine what a keypress should do.
 
int km_dokey (enum MenuType mtype, GetChFlags flags)
 Determine what a keypress should do.
 

Variables

struct KeyEventArray MacroEvents = ARRAY_HEAD_INITIALIZER
 These are used for macros and exec/push commands.
 
static struct KeyEventArray UngetKeyEvents = ARRAY_HEAD_INITIALIZER
 These are used in all other "normal" situations, and are not ignored when passing GETCH_IGNORE_MACRO.
 

Detailed Description

Get a key from the user.

Authors
  • Richard Russon

This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License along with this program. If not, see http://www.gnu.org/licenses/.

Definition in file get.c.

Function Documentation

◆ mutt_flushinp()

void mutt_flushinp ( void  )

Empty all the keyboard buffers.

Definition at line 58 of file get.c.

59{
62 flushinp();
63}
#define ARRAY_SHRINK(head, num)
Mark a number of slots at the end of the array as unused.
Definition: array.h:172
#define ARRAY_SIZE(head)
The number of elements stored.
Definition: array.h:87
struct KeyEventArray MacroEvents
These are used for macros and exec/push commands.
Definition: get.c:49
static struct KeyEventArray UngetKeyEvents
These are used in all other "normal" situations, and are not ignored when passing GETCH_IGNORE_MACRO.
Definition: get.c:53
+ Here is the caller graph for this function:

◆ array_pop()

static struct KeyEvent * array_pop ( struct KeyEventArray *  a)
static

Remove an event from the array.

Parameters
aArray
Return values
ptrEvent

Definition at line 70 of file get.c.

71{
72 if (ARRAY_EMPTY(a))
73 {
74 return NULL;
75 }
76
77 struct KeyEvent *event = ARRAY_LAST(a);
78 ARRAY_SHRINK(a, 1);
79 return event;
80}
#define ARRAY_LAST(head)
Convenience method to get the last element.
Definition: array.h:144
#define ARRAY_EMPTY(head)
Check if an array is empty.
Definition: array.h:74
An event such as a keypress.
Definition: lib.h:81
+ Here is the caller graph for this function:

◆ array_add()

static void array_add ( struct KeyEventArray *  a,
int  ch,
int  op 
)
static

Add an event to the end of the array.

Parameters
aArray
chCharacter
opOperation, e.g. OP_DELETE

Definition at line 88 of file get.c.

89{
90 struct KeyEvent event = { ch, op };
91 ARRAY_ADD(a, event);
92}
#define ARRAY_ADD(head, elem)
Add an element at the end of the array.
Definition: array.h:156
int op
Function opcode, e.g. OP_HELP.
Definition: lib.h:83
int ch
Raw key pressed.
Definition: lib.h:82
+ Here is the caller graph for this function:

◆ array_to_endcond()

static void array_to_endcond ( struct KeyEventArray *  a)
static

Clear the array until an OP_END_COND.

Parameters
aArray

Definition at line 98 of file get.c.

99{
100 while (!ARRAY_EMPTY(a))
101 {
102 if (array_pop(a)->op == OP_END_COND)
103 {
104 return;
105 }
106 }
107}
static struct KeyEvent * array_pop(struct KeyEventArray *a)
Remove an event from the array.
Definition: get.c:70
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ mutt_unget_ch()

void mutt_unget_ch ( int  ch)

Return a keystroke to the input buffer.

Parameters
chKey press

This puts events into the UngetKeyEvents buffer

Definition at line 115 of file get.c.

116{
117 array_add(&UngetKeyEvents, ch, OP_NULL);
118}
static void array_add(struct KeyEventArray *a, int ch, int op)
Add an event to the end of the array.
Definition: get.c:88
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ mutt_unget_op()

void mutt_unget_op ( int  op)

Return an operation to the input buffer.

Parameters
opOperation, e.g. OP_DELETE

This puts events into the UngetKeyEvents buffer

Definition at line 126 of file get.c.

127{
128 array_add(&UngetKeyEvents, 0, op);
129}
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ mutt_unget_string()

void mutt_unget_string ( const char *  s)

Return a string to the input buffer.

Parameters
sString to return

This puts events into the UngetKeyEvents buffer

Definition at line 137 of file get.c.

138{
139 const char *p = s + mutt_str_len(s) - 1;
140
141 while (p >= s)
142 {
143 mutt_unget_ch((unsigned char) *p--);
144 }
145}
void mutt_unget_ch(int ch)
Return a keystroke to the input buffer.
Definition: get.c:115
size_t mutt_str_len(const char *a)
Calculate the length of a string, safely.
Definition: string.c:496
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ mutt_push_macro_event()

void mutt_push_macro_event ( int  ch,
int  op 
)

Add the character/operation to the macro buffer.

Parameters
chCharacter to add
opOperation to add

Adds the ch/op to the macro buffer. This should be used for macros, push, and exec commands only.

Definition at line 155 of file get.c.

156{
157 array_add(&MacroEvents, ch, op);
158}
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ mutt_flush_macro_to_endcond()

void mutt_flush_macro_to_endcond ( void  )

Drop a macro from the input buffer.

All the macro text is deleted until an OP_END_COND command, or the buffer is empty.

Definition at line 166 of file get.c.

167{
169}
static void array_to_endcond(struct KeyEventArray *a)
Clear the array until an OP_END_COND.
Definition: get.c:98
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ mutt_monitor_getch()

static int mutt_monitor_getch ( void  )
static

Get a character and poll the filesystem monitor.

Return values
numCharacter pressed
ERRTimeout

Definition at line 177 of file get.c.

178{
179 /* ncurses has its own internal buffer, so before we perform a poll,
180 * we need to make sure there isn't a character waiting */
181 timeout(0);
182 int ch = getch();
183 timeout(1000); // 1 second
184 if (ch == ERR)
185 {
186 if (mutt_monitor_poll() != 0)
187 ch = ERR;
188 else
189 ch = getch();
190 }
191 return ch;
192}
int mutt_monitor_poll(void)
Check for filesystem changes.
Definition: monitor.c:401
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ mutt_getch()

struct KeyEvent mutt_getch ( GetChFlags  flags)

Read a character from the input buffer.

Parameters
flagsFlags, e.g. GETCH_IGNORE_MACRO
Return values
objKeyEvent to process

The priority for reading events is:

  1. UngetKeyEvents buffer
  2. MacroEvents buffer
  3. Keyboard

This function can return:

  • Abort { 0, OP_ABORT }
  • Repaint { 0, OP_REPAINT }
  • Timeout { 0, OP_TIMEOUT }

Definition at line 210 of file get.c.

211{
212 static const struct KeyEvent event_abort = { 0, OP_ABORT };
213 static const struct KeyEvent event_repaint = { 0, OP_REPAINT };
214 static const struct KeyEvent event_timeout = { 0, OP_TIMEOUT };
215
216 if (OptNoCurses)
217 return event_abort;
218
219 struct KeyEvent *event_key = array_pop(&UngetKeyEvents);
220 if (event_key)
221 return *event_key;
222
223 if (!(flags & GETCH_IGNORE_MACRO))
224 {
225 event_key = array_pop(&MacroEvents);
226 if (event_key)
227 return *event_key;
228 }
229
230 int ch;
231 SigInt = false;
233 timeout(1000); // 1 second
234#ifdef USE_INOTIFY
236#else
237 ch = getch();
238#endif
240
241 if (SigInt)
242 {
244 return event_abort;
245 }
246
247 if (ch == KEY_RESIZE)
248 {
249 timeout(0);
250 while ((ch = getch()) == KEY_RESIZE)
251 {
252 // do nothing
253 }
254 }
255
256 if (ch == ERR)
257 {
258 if (!isatty(0)) // terminal was lost
259 mutt_exit(1);
260
261 if (SigWinch)
262 {
263 SigWinch = false;
265 return event_repaint;
266 }
267
269 return event_timeout;
270 }
271
272 if (ch == AbortKey)
273 return event_abort;
274
275 if (ch & 0x80)
276 {
277 const bool c_meta_key = cs_subset_bool(NeoMutt->sub, "meta_key");
278 if (c_meta_key)
279 {
280 /* send ALT-x as ESC-x */
281 ch &= ~0x80;
283 return (struct KeyEvent){ '\033', OP_NULL }; // Escape
284 }
285 }
286
287 return (struct KeyEvent){ ch, OP_NULL };
288}
bool cs_subset_bool(const struct ConfigSubset *sub, const char *name)
Get a boolean config item by name.
Definition: helpers.c:47
void mutt_query_exit(void)
Ask the user if they want to leave NeoMutt.
Definition: curs_lib.c:137
static int mutt_monitor_getch(void)
Get a character and poll the filesystem monitor.
Definition: get.c:177
bool OptNoCurses
(pseudo) when sending in batch mode
Definition: globals.c:70
keycode_t AbortKey
code of key to abort prompts, normally Ctrl-G
Definition: lib.c:122
#define GETCH_IGNORE_MACRO
Don't use MacroEvents.
Definition: lib.h:52
void mutt_exit(int code)
Leave NeoMutt NOW.
Definition: main.c:269
bool notify_send(struct Notify *notify, enum NotifyType event_type, int event_subtype, void *event_data)
Send out a notification message.
Definition: notify.c:173
@ NT_TIMEOUT
Timeout has occurred.
Definition: notify_type.h:56
@ NT_RESIZE
Window has been resized.
Definition: notify_type.h:52
#define OP_TIMEOUT
1 second with no events
Definition: opcodes.h:36
#define OP_REPAINT
Repaint is needed.
Definition: opcodes.h:34
#define OP_ABORT
$abort_key pressed (Ctrl-G)
Definition: opcodes.h:37
volatile sig_atomic_t SigWinch
true after SIGWINCH is received
Definition: signal.c:67
volatile sig_atomic_t SigInt
true after SIGINT is received
Definition: signal.c:66
void mutt_sig_allow_interrupt(bool allow)
Allow/disallow Ctrl-C (SIGINT)
Definition: signal.c:300
Container for Accounts, Notifications.
Definition: neomutt.h:42
struct Notify * notify_timeout
Timeout notifications handler.
Definition: neomutt.h:45
struct Notify * notify_resize
Window resize notifications handler.
Definition: neomutt.h:44
struct ConfigSubset * sub
Inherited config items.
Definition: neomutt.h:46
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ km_error_key()

void km_error_key ( enum MenuType  mtype)

Handle an unbound key sequence.

Parameters
mtypeMenu type, e.g. MENU_PAGER

Definition at line 294 of file get.c.

295{
296 struct Keymap *key = km_find_func(mtype, OP_HELP);
297 if (!key && (mtype != MENU_EDITOR) && (mtype != MENU_PAGER))
298 key = km_find_func(MENU_GENERIC, OP_HELP);
299 if (!key)
300 {
301 mutt_error(_("Key is not bound"));
302 return;
303 }
304
305 char buf[128] = { 0 };
306 km_expand_key(buf, sizeof(buf), key);
307 mutt_error(_("Key is not bound. Press '%s' for help."), buf);
308}
#define mutt_error(...)
Definition: logging2.h:92
struct Keymap * km_find_func(enum MenuType mtype, int func)
Find a function's mapping in a Menu.
Definition: lib.c:509
int km_expand_key(char *s, size_t len, struct Keymap *map)
Get the key string bound to a Keymap.
Definition: lib.c:457
#define _(a)
Definition: message.h:28
A keyboard mapping.
Definition: lib.h:65
@ MENU_GENERIC
Generic selection list.
Definition: type.h:46
@ MENU_PAGER
Pager pager (email viewer)
Definition: type.h:52
@ MENU_EDITOR
Text entry area.
Definition: type.h:44
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ retry_generic()

static struct KeyEvent retry_generic ( enum MenuType  mtype,
keycode_t keys,
int  keyslen,
int  lastkey,
GetChFlags  flags 
)
static

Try to find the key in the generic menu bindings.

Parameters
mtypeMenu type, e.g. MENU_PAGER
keysArray of keys to return to the input queue
keyslenNumber of keys in the array
lastkeyLast key pressed (to return to input queue)
flagsFlags, e.g. GETCH_IGNORE_MACRO
Return values
numOperation, e.g. OP_DELETE

Definition at line 319 of file get.c.

321{
322 if (lastkey)
323 mutt_unget_ch(lastkey);
324 for (; keyslen; keyslen--)
325 mutt_unget_ch(keys[keyslen - 1]);
326
327 if ((mtype != MENU_EDITOR) && (mtype != MENU_GENERIC) && (mtype != MENU_PAGER))
328 {
329 return km_dokey_event(MENU_GENERIC, flags);
330 }
331 if ((mtype != MENU_EDITOR) && (mtype != MENU_GENERIC))
332 {
333 /* probably a good idea to flush input here so we can abort macros */
335 }
336
337 return (struct KeyEvent){ mutt_getch(flags).ch, OP_NULL };
338}
struct KeyEvent km_dokey_event(enum MenuType mtype, GetChFlags flags)
Determine what a keypress should do.
Definition: get.c:346
void mutt_flushinp(void)
Empty all the keyboard buffers.
Definition: get.c:58
struct KeyEvent mutt_getch(GetChFlags flags)
Read a character from the input buffer.
Definition: get.c:210
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ km_dokey_event()

struct KeyEvent km_dokey_event ( enum MenuType  mtype,
GetChFlags  flags 
)

Determine what a keypress should do.

Parameters
mtypeMenu type, e.g. MENU_EDITOR
flagsFlags, e.g. GETCH_IGNORE_MACRO
Return values
ptrEvent

Definition at line 346 of file get.c.

347{
348 struct KeyEvent event = { 0, OP_NULL };
349 struct Keymap *map = STAILQ_FIRST(&Keymaps[mtype]);
350 int pos = 0;
351 int n = 0;
352
353 if (!map && (mtype != MENU_EDITOR))
354 return retry_generic(mtype, NULL, 0, 0, flags);
355
356 while (true)
357 {
358 event = mutt_getch(flags);
359
360 // abort, timeout, repaint
361 if (event.op < OP_NULL)
362 return event;
363
364 /* do we have an op already? */
365 if (event.op != OP_NULL)
366 {
367 const char *func = NULL;
368 const struct MenuFuncOp *funcs = NULL;
369
370 /* is this a valid op for this menu type? */
371 if ((funcs = km_get_table(mtype)) && (func = mutt_get_func(funcs, event.op)))
372 return event;
373
374 if ((mtype != MENU_EDITOR) && (mtype != MENU_PAGER) && (mtype != MENU_GENERIC))
375 {
376 /* check generic menu type */
377 funcs = OpGeneric;
378 func = mutt_get_func(funcs, event.op);
379 if (func)
380 return event;
381 }
382
383 /* Sigh. Valid function but not in this context.
384 * Find the literal string and push it back */
385 for (int i = 0; MenuNames[i].name; i++)
386 {
387 funcs = km_get_table(MenuNames[i].value);
388 if (funcs)
389 {
390 func = mutt_get_func(funcs, event.op);
391 if (func)
392 {
393 mutt_unget_ch('>');
394 mutt_unget_string(func);
395 mutt_unget_ch('<');
396 break;
397 }
398 }
399 }
400 /* continue to chew */
401 if (func)
402 continue;
403 }
404
405 if (!map)
406 return event;
407
408 /* Nope. Business as usual */
409 while (event.ch > map->keys[pos])
410 {
411 if ((pos > map->eq) || !STAILQ_NEXT(map, entries))
412 return retry_generic(mtype, map->keys, pos, event.ch, flags);
413 map = STAILQ_NEXT(map, entries);
414 }
415
416 if (event.ch != map->keys[pos])
417 return retry_generic(mtype, map->keys, pos, event.ch, flags);
418
419 if (++pos == map->len)
420 {
421 if (map->op != OP_MACRO)
422 return (struct KeyEvent){ event.ch, map->op };
423
424 /* #GETCH_IGNORE_MACRO turns off processing the MacroEvents buffer
425 * in mutt_getch(). Generating new macro events during that time would
426 * result in undesired behavior once the option is turned off.
427 *
428 * Originally this returned -1, however that results in an unbuffered
429 * username or password prompt being aborted. Returning OP_NULL allows
430 * mw_get_field() to display the keybinding pressed instead.
431 *
432 * It may be unexpected for a macro's keybinding to be returned,
433 * but less so than aborting the prompt. */
434 if (flags & GETCH_IGNORE_MACRO)
435 {
436 return (struct KeyEvent){ event.ch, OP_NULL };
437 }
438
439 if (n++ == 10)
440 {
442 mutt_error(_("Macro loop detected"));
443 return (struct KeyEvent){ '\0', OP_ABORT };
444 }
445
447 map = STAILQ_FIRST(&Keymaps[mtype]);
448 pos = 0;
449 }
450 }
451
452 /* not reached */
453}
void mutt_unget_string(const char *s)
Return a string to the input buffer.
Definition: get.c:137
static struct KeyEvent retry_generic(enum MenuType mtype, keycode_t *keys, int keyslen, int lastkey, GetChFlags flags)
Try to find the key in the generic menu bindings.
Definition: get.c:319
const struct MenuFuncOp OpGeneric[]
Functions for the Generic Menu.
Definition: functions.c:68
void generic_tokenize_push_string(char *s)
Parse and queue a 'push' command.
Definition: lib.c:338
struct KeymapList Keymaps[MENU_MAX]
Array of key mappings, one for each MenuType.
Definition: lib.c:125
const char * mutt_get_func(const struct MenuFuncOp *funcs, int op)
Get the name of a function.
Definition: lib.c:321
const struct MenuFuncOp * km_get_table(enum MenuType mtype)
Lookup a Menu's functions.
Definition: lib.c:525
#define STAILQ_FIRST(head)
Definition: queue.h:350
#define STAILQ_NEXT(elm, field)
Definition: queue.h:400
keycode_t * keys
key sequence
Definition: lib.h:71
char * macro
Macro expansion (op == OP_MACRO)
Definition: lib.h:66
short eq
Number of leading keys equal to next entry.
Definition: lib.h:69
short len
Length of key sequence (unit: sizeof (keycode_t))
Definition: lib.h:70
short op
Operation to perform.
Definition: lib.h:68
const char * name
String value.
Definition: mapping.h:34
Mapping between a function and an operation.
Definition: lib.h:101
const struct Mapping MenuNames[]
Menu name lookup table.
Definition: type.c:37
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ km_dokey()

int km_dokey ( enum MenuType  mtype,
GetChFlags  flags 
)

Determine what a keypress should do.

Parameters
mtypeMenu type, e.g. MENU_EDITOR
flagsFlags, e.g. GETCH_IGNORE_MACRO
Return values
>0Function to execute
OP_NULLNo function bound to key sequence
-1Error occurred while reading input
-2A timeout or sigwinch occurred

Definition at line 464 of file get.c.

465{
466 return km_dokey_event(mtype, flags).op;
467}
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

Variable Documentation

◆ MacroEvents

struct KeyEventArray MacroEvents = ARRAY_HEAD_INITIALIZER

These are used for macros and exec/push commands.

They can be temporarily ignored by passing GETCH_IGNORE_MACRO

Definition at line 49 of file get.c.

◆ UngetKeyEvents

struct KeyEventArray UngetKeyEvents = ARRAY_HEAD_INITIALIZER
static

These are used in all other "normal" situations, and are not ignored when passing GETCH_IGNORE_MACRO.

Definition at line 53 of file get.c.