static void ui_keymap_query(const char *title, int row)
{
char tmp[1024];
int mode = OPT(rogue_like_commands) ? KEYMAP_MODE_ROGUE : KEYMAP_MODE_ORIG;
struct keypress c;
const struct keypress *act;
prt(title, 13, 0);
prt("Key: ", 14, 0);
/* Get a keymap trigger & mapping */
c = keymap_get_trigger();
act = keymap_find(mode, c);
/* Keymap found? */
if (!act) {
/* Prompt */
prt("No keymap with that trigger. Press any key to continue.", 16, 0);
inkey();
} else {
/* Analyze the current action */
keypress_to_text(tmp, sizeof(tmp), act, false);
/* Display the current action */
prt("Found: ", 15, 0);
Term_addstr(-1, COLOUR_WHITE, tmp);
prt("Press any key to continue.", 17, 0);
inkey();
}
}
/*
* Extract a direction (or zero) from a character
*/
int target_dir(struct keypress ch)
{
int d = 0;
/* Already a direction? */
if (isdigit((unsigned char) ch.code)) {
d = D2I(ch.code);
} else if (isarrow(ch.code)) {
switch (ch.code) {
case ARROW_DOWN:
d = 2;
break;
case ARROW_LEFT:
d = 4;
break;
case ARROW_RIGHT:
d = 6;
break;
case ARROW_UP:
d = 8;
break;
}
} else {
int mode;
const struct keypress *act;
if (OPT(rogue_like_commands))
mode = KEYMAP_MODE_ROGUE;
else
mode = KEYMAP_MODE_ORIG;
/* XXX see if this key has a digit in the keymap we can use */
act = keymap_find(mode, ch);
if (act) {
const struct keypress *cur;
for (cur = act; cur->type == EVT_KBRD; cur++) {
if (isdigit((unsigned char) cur->code))
d = D2I(cur->code);
}
}
}
/* Paranoia */
if (d == 5)
d = 0;
/* Return direction */
return (d);
}
/*
* Request a command from the user.
*
* Note that "caret" ("^") is treated specially, and is used to
* allow manual input of control characters. This can be used
* on many machines to request repeated tunneling (Ctrl-H) and
* on the Macintosh to request "Control-Caret".
*
* Note that "backslash" is treated specially, and is used to bypass any
* keymap entry for the following character. This is useful for macros.
*/
static ui_event textui_get_command(int *count)
{
int mode = OPT(rogue_like_commands) ? KEYMAP_MODE_ROGUE : KEYMAP_MODE_ORIG;
struct keypress tmp[2] = { { 0 }, { 0 } };
ui_event ke = EVENT_EMPTY;
const struct keypress *act = NULL;
/* Get command */
while (1)
{
/* Hack -- no flush needed */
msg_flag = FALSE;
/* Activate "command mode" */
inkey_flag = TRUE;
/* Get a command */
ke = inkey_ex();
if (ke.type == EVT_KBRD) {
bool keymap_ok = TRUE;
switch (ke.key.code) {
case '0': {
int c = textui_get_count();
if (c == -1 || !get_com_ex("Command: ", &ke))
continue;
else
*count = c;
break;
}
case '\\': {
/* Allow keymaps to be bypassed */
(void)get_com_ex("Command: ", &ke);
keymap_ok = FALSE;
break;
}
case '^': {
/* Allow "control chars" to be entered */
if (get_com("Control: ", &ke.key))
ke.key.code = KTRL(ke.key.code);
break;
}
}
/* Find any relevant keymap */
if (keymap_ok)
act = keymap_find(mode, ke.key);
}
/* Erase the message line */
prt("", 0, 0);
if (ke.type == EVT_BUTTON)
{
/* Buttons are always specified in standard keyset */
act = tmp;
tmp[0] = ke.key;
}
/* Apply keymap if not inside a keymap already */
if (ke.key.code && act && !inkey_next)
{
size_t n = 0;
while (act[n].type)
n++;
/* Make room for the terminator */
n += 1;
/* Install the keymap */
memcpy(request_command_buffer, act, n * sizeof(struct keypress));
/* Start using the buffer */
inkey_next = request_command_buffer;
/* Continue */
continue;
}
/* Done */
break;
}
return ke;
}
