kbdbind.c

一个很有名的浏览器

/* Keybinding implementation */
/* $Id: kbdbind.c,v 1.261.4.5 2005/05/01 22:05:10 jonas Exp $ */

#ifdef HAVE_CONFIG_H
#include "config.h"
#endif

#include <ctype.h>
#include <string.h>

#include "elinks.h"

#include "bfu/dialog.h"
#include "config/conf.h"
#include "config/dialogs.h"
#include "config/kbdbind.h"
#include "config/options.h"
#include "intl/gettext/libintl.h"
#include "sched/event.h"
#include "terminal/kbd.h"
#include "util/memory.h"
#include "util/string.h"


/* Fix namespace clash on MacOS. */
#define table table_elinks

static struct strtonum *action_table[KEYMAP_MAX];
static struct list_head keymaps[KEYMAP_MAX];

static void add_default_keybindings(void);

static int
delete_keybinding(enum keymap km, long key, long meta)
{
	struct keybinding *kb;

	foreach (kb, keymaps[km]) {
		int was_default = 0;

		if (kb->key != key || kb->meta != meta)
			continue;

		if (kb->flags & KBDB_DEFAULT) {
			kb->flags &= ~KBDB_DEFAULT;
			was_default = 1;
		}

		free_keybinding(kb);

		return 1 + was_default;
	}

	return 0;
}

struct keybinding *
add_keybinding(enum keymap km, int action, long key, long meta, int func_ref)
{
	struct keybinding *kb;
	struct listbox_item *root;
	int is_default;

	is_default = delete_keybinding(km, key, meta) == 2;

	kb = mem_calloc(1, sizeof(*kb));
	if (!kb) return NULL;

	kb->keymap = km;
	kb->action = action;
	kb->key = key;
	kb->meta = meta;
	kb->func_ref = func_ref;
	kb->flags = is_default * KBDB_DEFAULT;

	object_nolock(kb, "keybinding");
	add_to_list(keymaps[km], kb);

	if (action == ACT_MAIN_NONE) {
		/* We don't want such a listbox_item, do we? */
		return NULL; /* Or goto. */
	}

	root = get_keybinding_action_box_item(km, action);
	if (!root) {
		return NULL; /* Or goto ;-). */
	}
	kb->box_item = add_listbox_leaf(&keybinding_browser, root, kb);

	return kb;
}

void
free_keybinding(struct keybinding *kb)
{
	if (kb->box_item) {
		done_listbox_item(&keybinding_browser, kb->box_item);
		kb->box_item = NULL;
	}

#ifdef CONFIG_SCRIPTING
/* TODO: unref function must be implemented. */
/*	if (kb->func_ref != EVENT_NONE)
		scripting_unref(kb->func_ref); */
#endif

	if (kb->flags & KBDB_DEFAULT) {
		/* We cannot just delete a default keybinding, instead we have
		 * to rebind it to ACT_MAIN_NONE so that it gets written so to the
		 * config file. */
		kb->action = ACT_MAIN_NONE;
		return;
	}

	del_from_list(kb);
	mem_free(kb);
}

int
keybinding_exists(enum keymap km, long key, long meta, int *action)
{
	struct keybinding *kb;

	foreach (kb, keymaps[km]) {
		if (kb->key != key || kb->meta != meta)
			continue;

		if (action) *action = kb->action;

		return 1;
	}

	return 0;
}


int
kbd_action(enum keymap kmap, struct term_event *ev, int *func_ref)
{
	struct keybinding *kb;

	if (ev->ev != EVENT_KBD) return -1;

	kb = kbd_ev_lookup(kmap, get_kbd_key(ev), get_kbd_modifier(ev), func_ref);
	return kb ? kb->action : -1;
}

struct keybinding *
kbd_ev_lookup(enum keymap kmap, long key, long meta, int *func_ref)
{
	struct keybinding *kb;

	foreach (kb, keymaps[kmap]) {
		if (key != kb->key || meta != kb->meta)
			continue;

		if (kb->action == ACT_MAIN_SCRIPTING_FUNCTION && func_ref)
			*func_ref = kb->func_ref;

		return kb;
	}

	return NULL;
}

struct keybinding *
kbd_nm_lookup(enum keymap kmap, unsigned char *name, int *func_ref)
{
	struct keybinding *kb;
	int act = read_action(kmap, name);

	if (act < 0) return NULL;

	foreach (kb, keymaps[kmap]) {
		if (act != kb->action)
			continue;

		if (kb->action == ACT_MAIN_SCRIPTING_FUNCTION && func_ref)
			*func_ref = kb->func_ref;

		return kb;
	}

	return NULL;
}

struct keybinding *
kbd_act_lookup(enum keymap map, int action)
{
	struct keybinding *kb;

	foreach (kb, keymaps[map]) {
		if (action != kb->action)
			continue;

		return kb;
	}

	return NULL;
}

/*
 * Config file helpers.
 */

static long
strtonum(struct strtonum *table, unsigned char *str)
{
	struct strtonum *rec;

	for (rec = table; rec->str; rec++)
		if (!strcmp(rec->str, str))
			return rec->num;

	return -1;
}

static long
strcasetonum(struct strtonum *table, unsigned char *str)
{
	struct strtonum *rec;

	for (rec = table; rec->str; rec++)
		if (!strcasecmp(rec->str, str))
			return rec->num;

	return -1;
}

static unsigned char *
numtostr(struct strtonum *table, long num)
{
	struct strtonum *rec;

	for (rec = table; rec->str; rec++)
		if (num == rec->num)
			return rec->str;

	return NULL;
}


static unsigned char *
numtodesc(struct strtonum *table, long num)
{
	struct strtonum *rec;

	for (rec = table; rec->str; rec++)
		if (num == rec->num)
			return (rec->desc) ? rec->desc : rec->str;

	return NULL;
}


static struct strtonum keymap_table[] = {
	{ "main", KEYMAP_MAIN, N_("Main mapping") },
	{ "edit", KEYMAP_EDIT, N_("Edit mapping") },
	{ "menu", KEYMAP_MENU, N_("Menu mapping") },
	{ NULL, 0, NULL }
};

static int
read_keymap(unsigned char *keymap)
{
	return strtonum(keymap_table, keymap);
}

unsigned char *
write_keymap(enum keymap keymap)
{
	return numtostr(keymap_table, keymap);
}


static struct strtonum key_table[] = {
	{ "Enter", KBD_ENTER },
	{ "Space", ' ' },
	{ "Backspace", KBD_BS },
	{ "Tab", KBD_TAB },
	{ "Escape", KBD_ESC },
	{ "Left", KBD_LEFT },
	{ "Right", KBD_RIGHT },
	{ "Up", KBD_UP },
	{ "Down", KBD_DOWN },
	{ "Insert", KBD_INS },
	{ "Delete", KBD_DEL },
	{ "Home", KBD_HOME },
	{ "End", KBD_END },
	{ "PageUp", KBD_PAGE_UP },
	{ "PageDown", KBD_PAGE_DOWN },
	{ "F1", KBD_F1 },
	{ "F2", KBD_F2 },
	{ "F3", KBD_F3 },
	{ "F4", KBD_F4 },
	{ "F5", KBD_F5 },
	{ "F6", KBD_F6 },
	{ "F7", KBD_F7 },
	{ "F8", KBD_F8 },
	{ "F9", KBD_F9 },
	{ "F10", KBD_F10 },
	{ "F11", KBD_F11 },
	{ "F12", KBD_F12 },
	{ NULL, 0 }
};

long
read_key(unsigned char *key)
{
	return (key[0] && !key[1]) ? *key : strcasetonum(key_table, key);
}

int
parse_keystroke(unsigned char *s, long *key, long *meta)
{
	if (!strncasecmp(s, "Shift", 5) && (s[5] == '-' || s[5] == '+')) {
		/* Shift+a == shiFt-a == Shift-a */
		memcpy(s, "Shift-", 6);
		*meta = KBD_SHIFT;
		s += 6;

	} else if (!strncasecmp(s, "Ctrl", 4) && (s[4] == '-' || s[4] == '+')) {
		/* Ctrl+a == ctRl-a == Ctrl-a */
		memcpy(s, "Ctrl-", 5);
		*meta = KBD_CTRL;
		s += 5;
		/* Ctrl-a == Ctrl-A */
		if (s[0] && !s[1]) s[0] = toupper(s[0]);

	} else if (!strncasecmp(s, "Alt", 3) && (s[3] == '-' || s[3] == '+')) {
		/* Alt+a == aLt-a == Alt-a */
		memcpy(s, "Alt-", 4);
		*meta = KBD_ALT;
		s += 4;

	} else {
		/* No modifier. */
		*meta = 0;
	}

	*key = read_key(s);
	return (*key < 0) ? -1 : 0;
}

void