void releasebutton(short code)
{
int kbcode = AKEY_NONE, temp_ui = -1;
if(ui_is_active)
release_key(kbcode);
else
{
if(code == joykey_map[get_screen_mode()][0])
stick0 |= 1;
else if(code == joykey_map[get_screen_mode()][1])
stick0 |= 2;
else if(code == joykey_map[get_screen_mode()][2])
stick0 |= 4;
else if(code == joykey_map[get_screen_mode()][3])
stick0 |= 8;
else if(code == klist.vkA || code == klist.vkB || ((code == '4' || code == '6') && issmartphone))
trig0 = 1;
else if(code == klist.vkC)
if (kbui_timerset)
{
KillTimer(hWndMain, 1);
kbui_timerset = FALSE;
set_screen_mode(0);
kbcode = AKEY_UI;
push_key(kbcode);
ui_clearkey = TRUE;
return;
}
}
release_key(kbcode); // always release or the ui gets stuck
}
void releasebutton(short code)
{
int kbcode;
if(ui_is_active)
{
kbcode = AKEY_NONE;
if(code == klist.vkUp)
kbcode = AKEY_UP;
else if(code == klist.vkDown)
kbcode = AKEY_DOWN;
else if(code == klist.vkLeft)
kbcode = AKEY_LEFT;
else if(code == klist.vkRight)
kbcode = AKEY_RIGHT;
else if(code == klist.vkStart)
kbcode = AKEY_TAB;
else if(code == klist.vkA)
kbcode = AKEY_SPACE;
else if(code == klist.vkB)
kbcode = AKEY_RETURN;
else if(code == klist.vkC)
kbcode = AKEY_ESCAPE;
release_key(kbcode);
}
else
{
if(code == joykey_map[get_screen_mode()][0])
stick0 |= 1;
else if(code == joykey_map[get_screen_mode()][1])
stick0 |= 2;
else if(code == joykey_map[get_screen_mode()][2])
stick0 |= 4;
else if(code == joykey_map[get_screen_mode()][3])
stick0 |= 8;
else if(code == klist.vkA || code == klist.vkB)
trig0 = 1;
else if(code == klist.vkC)
kbcode = AKEY_UI;
else
for(int i=0; i<sizeof(kbd_translation)/sizeof(kbd_translation[0]); i++)
if(code == kbd_translation[i].winKey)
{
kbcode = kbd_translation[i].aKey;
break;
}
if(kbcode != AKEY_NONE)
release_key(kbcode);
}
}
static void getq_response_handler(lcb_server_t *server, packet_info *info)
{
lcb_t root = server->instance;
char *packet;
lcb_uint16_t nkey;
const char *key = get_key(server, &nkey, &packet);
lcb_error_t rc;
lcb_get_resp_t resp;
fprintf(stderr, "\n The datatype is ...%d", PACKET_DATATYPE(info));
if (key == NULL) {
lcb_error_handler(server->instance, LCB_EINTERNAL, NULL);
return;
} else if (PACKET_STATUS(info) == PROTOCOL_BINARY_RESPONSE_SUCCESS) {
const protocol_binary_response_getq *getq = PACKET_EPHEMERAL_START(info);
rc = LCB_SUCCESS;
setup_lcb_get_resp_t(&resp, key, nkey,
PACKET_VALUE(info), PACKET_NVALUE(info),
ntohl(getq->message.body.flags),
PACKET_CAS(info),
PACKET_DATATYPE(info));
} else {
rc = map_error(root, PACKET_STATUS(info));
setup_lcb_get_resp_t(&resp, key, nkey, NULL, 0, 0, 0, 0);
}
root->callbacks.get(root, info->ct.cookie, rc, &resp);
release_key(server, packet);
}
static void arithmetic_response_handler(lcb_server_t *server,
packet_info *info)
{
lcb_t root = server->instance;
lcb_uint16_t status = PACKET_STATUS(info);
lcb_error_t rc = map_error(root, status);
char *packet;
lcb_uint16_t nkey;
const char *key = get_key(server, &nkey, &packet);
lcb_arithmetic_resp_t resp;
lcb_uint64_t value = 0;
struct lcb_command_data_st *command_data = &info->ct;
if (key == NULL) {
lcb_error_handler(server->instance, LCB_EINTERNAL,
NULL);
return ;
}
if (status == PROTOCOL_BINARY_RESPONSE_SUCCESS) {
memcpy(&value, info->payload, sizeof(value));
value = ntohll(value);
}
setup_lcb_arithmetic_resp_t(&resp, key, nkey, value, PACKET_CAS(info));
PACKET_TRACE(TRACE_ARITHMETIC_END, info, rc, &resp);
root->callbacks.arithmetic(root, command_data->cookie, rc, &resp);
release_key(server, packet);
}
int test_keyboard() {
z80iodevice_t keyboard = init_keyboard();
depress_key(keyboard.device, 0);
keyboard.write_out(keyboard.device, 0xFE);
uint8_t value = keyboard.read_in(keyboard.device);
if (value != 0xFE) {
free_keyboard(keyboard.device);
return 1;
}
depress_key(keyboard.device, 1);
value = keyboard.read_in(keyboard.device);
if (value != 0xFC) {
free_keyboard(keyboard.device);
return 2;
}
depress_key(keyboard.device, 0x14);
value = keyboard.read_in(keyboard.device);
if (value != 0xFC) {
free_keyboard(keyboard.device);
return 3;
}
keyboard.write_out(keyboard.device, 0xFC);
value = keyboard.read_in(keyboard.device);
if (value != 0xEC) {
free_keyboard(keyboard.device);
return 4;
}
release_key(keyboard.device, 0x14);
value = keyboard.read_in(keyboard.device);
if (value != 0xFC) {
free_keyboard(keyboard.device);
return 4;
}
return 0;
}
static void arithmetic_response_handler(lcb_server_t *server,
struct lcb_command_data_st *command_data,
protocol_binary_response_header *res)
{
lcb_t root = server->instance;
lcb_uint16_t status = ntohs(res->response.status);
lcb_error_t rc = map_error(root, status);
char *packet;
lcb_uint16_t nkey;
const char *key = get_key(server, &nkey, &packet);
lcb_arithmetic_resp_t resp;
lcb_uint64_t value = 0;
if (key == NULL) {
lcb_error_handler(server->instance, LCB_EINTERNAL,
NULL);
return ;
}
if (status == PROTOCOL_BINARY_RESPONSE_SUCCESS) {
memcpy(&value, res + 1, sizeof(value));
value = ntohll(value);
}
setup_lcb_arithmetic_resp_t(&resp, key, nkey, value, res->response.cas);
TRACE_ARITHMETIC_END(res->response.opaque, command_data->vbucket,
res->response.opcode, rc, &resp);
root->callbacks.arithmetic(root, command_data->cookie, rc, &resp);
release_key(server, packet);
}
int main(int argc, char **argv)
{
char keys[1024]={0};
if(init_uinput()<0)
{
perror("init_uinput failed");
return -1;
}
int src=server(12345);
int data;
while(1)
{
if(!read(src, &data, 4)){
exit(1);
}
if(data<1024)
{
printf("Got Keycode: %i\n", data);
keys[data]^=1;
if(keys[data])
{
press_key(data);
}
else
{
release_key(data);
}
}
else
{
int i;
for(i=0;i<1024;i++)
{
release_key(i);
}
memset(keys, 0, 1024);
}
}
destroy_uinput();
return 0;
}
int get_last_key()
{
if (ui_clearkey)
{
ui_clearkey = FALSE;
release_key(AKEY_UI);
return AKEY_UI;
}
else if(activeKey != AKEY_BREAK)
return activeKey;
else
{
/* There is special case */
release_key(AKEY_BREAK);
return AKEY_BREAK;
}
}
static bool handle_key(wlc_handle view, uint32_t time, const struct wlc_modifiers *modifiers,
uint32_t key, uint32_t sym, enum wlc_key_state state) {
if (locked_view_focus && state == WLC_KEY_STATE_PRESSED) {
return false;
}
// Revert floating container back to original position on keypress
if (state == WLC_KEY_STATE_PRESSED &&
(pointer_state.floating.drag || pointer_state.floating.resize)) {
reset_floating(get_focused_view(&root_container));
}
struct sway_mode *mode = config->current_mode;
if (sym < 70000 /* bullshit made up number */) {
if (!isalnum(sym) && sym != ' ' && sym != XKB_KEY_Escape && sym != XKB_KEY_Tab) {
// God f*****g dammit
return false;
}
}
// Lowercase if necessary
sym = tolower(sym);
int i;
if (state == WLC_KEY_STATE_PRESSED) {
press_key(sym);
} else { // WLC_KEY_STATE_RELEASED
release_key(sym);
}
// TODO: reminder to check conflicts with mod+q+a versus mod+q
for (i = 0; i < mode->bindings->length; ++i) {
struct sway_binding *binding = mode->bindings->items[i];
if ((modifiers->mods & binding->modifiers) == binding->modifiers) {
bool match;
int j;
for (j = 0; j < binding->keys->length; ++j) {
xkb_keysym_t *key = binding->keys->items[j];
if ((match = check_key(*key)) == false) {
break;
}
}
if (match) {
if (state == WLC_KEY_STATE_PRESSED) {
handle_command(config, binding->command);
return true;
} else if (state == WLC_KEY_STATE_RELEASED) {
// TODO: --released
}
}
}
}
return false;
}
static void store_response_handler(lcb_server_t *server, packet_info *info)
{
lcb_t root = server->instance;
lcb_storage_t op;
char *packet;
lcb_uint16_t nkey;
lcb_error_t rc;
lcb_uint16_t status = PACKET_STATUS(info);
const char *key = get_key(server, &nkey, &packet);
if (PACKET_STATUS(info) == PROTOCOL_BINARY_RESPONSE_SUCCESS) {
rc = LCB_SUCCESS;
} else {
rc = map_error(root, status);
}
switch (PACKET_OPCODE(info)) {
case PROTOCOL_BINARY_CMD_ADD:
op = LCB_ADD;
break;
case PROTOCOL_BINARY_CMD_REPLACE:
op = LCB_REPLACE;
break;
case PROTOCOL_BINARY_CMD_SET:
op = LCB_SET;
break;
case PROTOCOL_BINARY_CMD_APPEND:
op = LCB_APPEND;
break;
case PROTOCOL_BINARY_CMD_PREPEND:
op = LCB_PREPEND;
break;
default:
/*
** It is impossible to get here (since we're called from our
** lookup table... If we _DO_ get here, it must be a development
** version where the developer isn't done yet (and should be
** forced to think about what to do...)
*/
lcb_error_handler(root, LCB_EINTERNAL,
"Internal error. Received an illegal command opcode");
abort();
}
if (key == NULL) {
lcb_error_handler(server->instance, LCB_EINTERNAL,
NULL);
} else {
lcb_store_resp_t resp;
setup_lcb_store_resp_t(&resp, key, nkey, PACKET_CAS(info));
PACKET_TRACE(TRACE_STORE_END, info, rc, &resp);
root->callbacks.store(root, info->ct.cookie, op, rc, &resp);
release_key(server, packet);
}
}
bool
wait_restart(void){
disable_interrupt();
if ( query_key('r' - 'a') ){
release_key('r' - 'a');
return true;
}
enable_interrupt();
return false;
}
static gint
keyboard_event_handler(GtkWidget *mk, GdkEventKey *event, gpointer ignored)
{
int note;
char *key;
guint keyval;
GdkKeymapKey kk;
PianoKeyboard *pk = PIANO_KEYBOARD(mk);
(void) ignored;
/* We're not using event->keyval, because we need keyval with level set to 0.
E.g. if user holds Shift and presses '7', we want to get a '7', not '&'. */
kk.keycode = event->hardware_keycode;
kk.level = 0;
kk.group = 0;
keyval = gdk_keymap_lookup_key(NULL, &kk);
key = gdk_keyval_name(gdk_keyval_to_lower(keyval));
if (key == NULL) {
g_message("gtk_keyval_name() returned NULL; please report this.");
return FALSE;
}
note = key_binding(pk, key);
if (note < 0) {
/* Key was not bound. Maybe it's one of the keys handled in jack-keyboard.c. */
return FALSE;
}
if (note == 128) {
if (event->type == GDK_KEY_RELEASE) {
rest (pk);
}
return TRUE;
}
note += pk->octave * 12;
assert(note >= 0);
assert(note < NNOTES);
if (event->type == GDK_KEY_PRESS) {
press_key(pk, note);
} else if (event->type == GDK_KEY_RELEASE) {
release_key(pk, note);
}
return TRUE;
}
int get_last_key()
{
if(activeKey != AKEY_BREAK)
return activeKey;
else
{
/* There is special case */
release_key(AKEY_BREAK);
return AKEY_BREAK;
}
}
static void store_response_handler(lcb_server_t *server,
struct lcb_command_data_st *command_data,
protocol_binary_response_header *res)
{
lcb_t root = server->instance;
lcb_storage_t op;
char *packet;
lcb_uint16_t nkey;
const char *key = get_key(server, &nkey, &packet);
lcb_uint16_t status = ntohs(res->response.status);
lcb_error_t rc = map_error(root, status);
switch (res->response.opcode) {
case PROTOCOL_BINARY_CMD_ADD:
op = LCB_ADD;
break;
case PROTOCOL_BINARY_CMD_REPLACE:
op = LCB_REPLACE;
break;
case PROTOCOL_BINARY_CMD_SET:
op = LCB_SET;
break;
case PROTOCOL_BINARY_CMD_APPEND:
op = LCB_APPEND;
break;
case PROTOCOL_BINARY_CMD_PREPEND:
op = LCB_PREPEND;
break;
default:
/*
** It is impossible to get here (since we're called from our
** lookup table... If we _DO_ get here, it must be a development
** version where the developer isn't done yet (and should be
** forced to think about what to do...)
*/
lcb_error_handler(root, LCB_EINTERNAL,
"Internal error. Received an illegal command opcode");
abort();
}
if (key == NULL) {
lcb_error_handler(server->instance, LCB_EINTERNAL,
NULL);
} else {
lcb_store_resp_t resp;
setup_lcb_store_resp_t(&resp, key, nkey, res->response.cas);
TRACE_STORE_END(res->response.opaque, command_data->vbucket,
res->response.opcode, rc, &resp);
root->callbacks.store(root, command_data->cookie, op, rc, &resp);
release_key(server, packet);
}
}
static gboolean
mouse_button_event_handler(PianoKeyboard *pk, GdkEventButton *event, gpointer ignored)
{
int x = event->x;
int y = event->y;
int note = get_note_for_xy(pk, x, y);
(void) ignored;
if (event->button != 1)
return TRUE;
if (event->type == GDK_BUTTON_PRESS) {
/* This is possible when you make the window a little wider and then click
on the grey area. */
if (note < 0) {
return TRUE;
}
if (pk->note_being_pressed_using_mouse >= 0)
release_key(pk, pk->note_being_pressed_using_mouse);
press_key(pk, note);
pk->note_being_pressed_using_mouse = note;
} else if (event->type == GDK_BUTTON_RELEASE) {
if (note >= 0) {
release_key(pk, note);
} else {
if (pk->note_being_pressed_using_mouse >= 0)
release_key(pk, pk->note_being_pressed_using_mouse);
}
pk->note_being_pressed_using_mouse = -1;
}
return TRUE;
}
static bool handle_key(wlc_handle view, uint32_t time, const struct wlc_modifiers *modifiers,
uint32_t key, enum wlc_key_state state) {
if (locked_view_focus && state == WLC_KEY_STATE_PRESSED) {
return EVENT_PASSTHROUGH;
}
// reset pointer mode on keypress
if (state == WLC_KEY_STATE_PRESSED && pointer_state.mode) {
pointer_mode_reset();
}
struct sway_mode *mode = config->current_mode;
struct wlc_modifiers no_mods = { 0, 0 };
uint32_t sym = tolower(wlc_keyboard_get_keysym_for_key(key, &no_mods));
int i;
if (state == WLC_KEY_STATE_PRESSED) {
press_key(sym, key);
} else { // WLC_KEY_STATE_RELEASED
release_key(sym, key);
}
// TODO: reminder to check conflicts with mod+q+a versus mod+q
for (i = 0; i < mode->bindings->length; ++i) {
struct sway_binding *binding = mode->bindings->items[i];
if ((modifiers->mods ^ binding->modifiers) == 0) {
bool match;
int j;
for (j = 0; j < binding->keys->length; ++j) {
xkb_keysym_t *key = binding->keys->items[j];
if ((match = check_key(*key, 0)) == false) {
break;
}
}
if (match) {
if (state == WLC_KEY_STATE_PRESSED) {
handle_command(config, binding->command);
return EVENT_HANDLED;
} else if (state == WLC_KEY_STATE_RELEASED) {
// TODO: --released
}
}
}
}
return EVENT_PASSTHROUGH;
}
/* 在屏幕上创建一个新的字母 */
void create_new_letter(void) {
if (head == NULL) {
head = fly_new(); /* 当前没有任何字母，创建新链表 */
} else {
fly_t now = fly_new();
fly_insert(NULL, head, now); /* 插入到链表的头部 */
head = now;
}
/* 字母、初始位置、掉落速度均为随机设定 */
head->x = 0;
head->y = rand() % (SCR_WIDTH / 8 - 2) * 8 + 8;
head->v = (rand() % 1000 / 1000.0 + 1) / 2.0;
head->text = rand() % 26;
release_key(head->text); /* 清除过往的按键 */
}
void Start_KBUI(void)
{
int kbcode, temp_ui;
KillTimer(hWndMain, 1);
kbui_timerset = FALSE;
temp_ui = ui_is_active;
ui_is_active = TRUE;
kbcode = kb_ui("Select Atari key to inject once", machine_type);
if (kbcode != AKEY_NONE)
push_key(kbcode);
else
release_key(AKEY_NONE);
ui_is_active = temp_ui;
return;
}
/**
* Removes a key, value pair from the hashtable. The value is returned if it exists,
* otherwise the method returns NULL.
*
* @param key The key used to index into the hashtable.
* @return removed value or NULL
*/
void *Hashtable::remove(const void *key)
{
bool found;
void *old_value = NULL;
struct table_entry *entry = lookup(key, this->hash_string(key), &found);
if (entry){
old_value = entry->value;
if (found){
release_key(entry->key);
entry->hash = DELETED_HASH;
entry->key = NULL;
entry->value = NULL;
this->deleted += 1;
}
}
return old_value;
}
static void delete_response_handler(lcb_server_t *server, packet_info *info)
{
lcb_t root = server->instance;
lcb_error_t rc = map_error(root, PACKET_STATUS(info));
char *packet;
lcb_uint16_t nkey;
const char *key = get_key(server, &nkey, &packet);
if (key == NULL) {
lcb_error_handler(server->instance, LCB_EINTERNAL, NULL);
} else {
lcb_remove_resp_t resp;
setup_lcb_remove_resp_t(&resp, key, nkey, PACKET_CAS(info));
root->callbacks.remove(root, info->ct.cookie, rc, &resp);
release_key(server, packet);
}
}
void free_key_node(PanDB * const db, KeyNode * const key_node)
{
if (key_node == NULL) {
return;
}
assert(key_node->slot == NULL);
release_key(key_node->key);
key_node->key = NULL;
free_slip_map(&key_node->properties);
key_node->properties = NULL;
HttpHandlerContext * context = db->context;
if (key_node->expirable != NULL) {
remove_expirable_from_tree(db, key_node->expirable);
remove_entry_from_slab(&context->expirables_slab, key_node->expirable);
key_node->expirable = NULL;
}
free(key_node);
}
int load_key(char * fn)
{
FILE* fp;
char fname[STRLEN];
struct stat st;
release_key();
if (fn==NULL)
sethomefile(fname, getCurrentUser()->userid, "definekey");
else
strcpy(fname, fn);
stat(fname, &st);
fp=fopen(fname, "rb");
if (fp==NULL) return -1;
keymem_total = st.st_size/sizeof(struct key_struct);
keymem = malloc(MAX_KEY_DEFINE*sizeof(struct key_struct));
fread(keymem, st.st_size, 1, fp);
fclose(fp);
return 0;
}
//改变蛇的运动方向
void ChangeDir()
{
disable_interrupt();
//寻找已经按下的键，若有多个键按下，处理优先级以此为上下左右
int i;
for(i=0;i<4;i++)
{
if(query_key(i))
switch(i)
{
case 0:snake.dir = up;break;
case 1:snake.dir = down;break;
case 2:snake.dir = left;break;
case 3:snake.dir = right;break;
}
release_key(i);
}
enable_interrupt();
}
static void unlock_response_handler(lcb_server_t *server,
packet_info *info)
{
lcb_t root = server->instance;
lcb_uint16_t status = PACKET_STATUS(info);
char *packet;
lcb_uint16_t nkey;
struct lcb_command_data_st *command_data = &info->ct;
const char *key = get_key(server, &nkey, &packet);
lcb_error_t rc = map_error(root, status);
if (key == NULL) {
lcb_error_handler(server->instance, LCB_EINTERNAL, NULL);
} else {
lcb_unlock_resp_t resp;
setup_lcb_unlock_resp_t(&resp, key, nkey);
root->callbacks.unlock(root, command_data->cookie, rc, &resp);
release_key(server, packet);
}
}
static void touch_response_handler(lcb_server_t *server,
packet_info *info)
{
lcb_t root = server->instance;
char *packet;
lcb_uint16_t nkey;
const char *key = get_key(server, &nkey, &packet);
lcb_uint16_t status = PACKET_STATUS(info);
lcb_error_t rc = map_error(root, status);
if (key == NULL) {
lcb_error_handler(server->instance, LCB_EINTERNAL,
NULL);
} else {
lcb_touch_resp_t resp;
setup_lcb_touch_resp_t(&resp, key, nkey, PACKET_CAS(info));
PACKET_TRACE(TRACE_TOUCH_END, info, rc, &resp);
root->callbacks.touch(root, info->ct.cookie, rc, &resp);
release_key(server, packet);
}
}
static void unlock_response_handler(lcb_server_t *server,
struct lcb_command_data_st *command_data,
protocol_binary_response_header *res)
{
lcb_t root = server->instance;
lcb_uint16_t status = ntohs(res->response.status);
char *packet;
lcb_uint16_t nkey;
const char *key = get_key(server, &nkey, &packet);
lcb_error_t rc = map_error(root, status);
if (key == NULL) {
lcb_error_handler(server->instance, LCB_EINTERNAL,
NULL);
} else {
lcb_unlock_resp_t resp;
setup_lcb_unlock_resp_t(&resp, key, nkey);
TRACE_UNLOCK_END(res->response.opaque, command_data->vbucket, rc, &resp);
root->callbacks.unlock(root, command_data->cookie, rc, &resp);
release_key(server, packet);
}
}
static gboolean
mouse_motion_event_handler(PianoKeyboard *pk, GdkEventMotion *event, gpointer ignored)
{
int note;
(void) ignored;
if ((event->state & GDK_BUTTON1_MASK) == 0)
return TRUE;
note = get_note_for_xy(pk, event->x, event->y);
if (note != pk->note_being_pressed_using_mouse && note >= 0) {
if (pk->note_being_pressed_using_mouse >= 0)
release_key(pk, pk->note_being_pressed_using_mouse);
press_key(pk, note);
pk->note_being_pressed_using_mouse = note;
}
return TRUE;
}
static void clear_input_data(struct ist30xx_data *data)
{
int i;
finger_info *fingers = (finger_info *)data->prev_fingers;
finger_info *keys = (finger_info *)data->prev_keys;
for (i = 0; i < data->num_fingers; i++) {
if (fingers[i].bit_field.id == 0)
continue;
if (fingers[i].bit_field.udmg & PRESS_MSG_MASK)
release_finger(&fingers[i]);
}
for (i = 0; i < data->num_keys; i++) {
if (keys[i].bit_field.id == 0)
continue;
if (keys[i].bit_field.w == PRESS_MSG_KEY)
release_key(&keys[i], RELEASE_KEY);
}
}
/* 更新按键 */
bool update_keypress(void) {
fly_t it, target = NULL;
float min = -100;
disable_interrupt();
/* 寻找相应键已被按下、最底部且未被击中的字符 */
for (it = head; it != NULL; it = it->_next) {
assert(it->text >= 0 && it->text < 26);
if (it->v > 0 && it->x > min && query_key(it->text)) {
min = it->x;
target = it;
}
}
/* 如果找到则更新相应数据 */
if (target != NULL) {
release_key(target->text);
target->v = -3; /* 速度改为向上 */
return TRUE;
}
enable_interrupt();
return FALSE;
}
static int
lookup (int chr, struct prefix *prefix)
{
int c2;
for (; prefix->character != ENDCHAR; prefix++)
{
if (prefix->character != ANYCHAR &&
prefix->character != chr)
continue;
if (!prefix->next || ((c2 = get_char (1)) == -1))
{
switch (prefix->mapping)
{
case METAIZE:
press_key (KEY_Meta);
send_key (chr);
release_key (KEY_Meta);
break;
case NOKEY:
/* FIXME */
abort ();
return 0;
default:
send_key (prefix->mapping);
break;
}
return 1;
}
return lookup (c2, prefix->next);
}
send_key (chr);
return 1;
}
