StreetLight
/
libxkbcommon
2
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

state: move filter initialization to the dispatcher 

This removes all of the boilerplate from the *_new functions, and leaves
them just as simple functions which perform the effect of the action on state.

Signed-off-by: Ran Benita <ran234@gmail.com>
master
Ran Benita 2012-09-14 16:01:11 +03:00
parent 2c19c9388b
commit 8098daa08f
1 changed files with 49 additions and 90 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

139
src/state.c
View File

@ -182,25 +182,17 @@ xkb_filter_group_set_func(struct xkb_state *state,
return 1; return 1;
} }
static int static void
xkb_filter_group_set_new(struct xkb_state *state, xkb_filter_group_set_new(struct xkb_state *state, struct xkb_filter *filter)
struct xkb_filter *filter,
const struct xkb_key *key,
const union xkb_action *action)
{ {
filter->key = key; if (filter->action.group.flags & ACTION_ABSOLUTE_SWITCH) {
filter->func = xkb_filter_group_set_func; xkb_group_index_t tmp = filter->action.group.group;
filter->action = *action;
if (action->group.flags & ACTION_ABSOLUTE_SWITCH) {
filter->action.group.group = state->base_group; filter->action.group.group = state->base_group;
state->base_group = action->group.group; state->base_group = tmp;
} }
else { else {
state->base_group += action->group.group; state->base_group += filter->action.group.group;
} }
return 1;
} }
static int static int
@ -223,22 +215,13 @@ xkb_filter_group_lock_func(struct xkb_state *state,
return 1; return 1;
} }
static int static void
xkb_filter_group_lock_new(struct xkb_state *state, xkb_filter_group_lock_new(struct xkb_state *state, struct xkb_filter *filter)
struct xkb_filter *filter,
const struct xkb_key *key,
const union xkb_action *action)
{ {
filter->key = key; if (filter->action.group.flags & ACTION_ABSOLUTE_SWITCH)
filter->func = xkb_filter_group_lock_func; state->locked_group = filter->action.group.group;
filter->action = *action;
if (action->group.flags & ACTION_ABSOLUTE_SWITCH)
state->locked_group = action->group.group;
else else
state->locked_group += action->group.group; state->locked_group += filter->action.group.group;
return 1;
} }
static int static int
@ -268,19 +251,10 @@ xkb_filter_mod_set_func(struct xkb_state *state,
return 1; return 1;
} }
static int static void
xkb_filter_mod_set_new(struct xkb_state *state, xkb_filter_mod_set_new(struct xkb_state *state, struct xkb_filter *filter)
struct xkb_filter *filter,
const struct xkb_key *key,
const union xkb_action *action)
{ {
filter->key = key; state->set_mods = filter->action.mods.mods.mask;
filter->func = xkb_filter_mod_set_func;
filter->action = *action;
state->set_mods = action->mods.mods.mask;
return 1;
} }
static int static int
@ -305,20 +279,11 @@ xkb_filter_mod_lock_func(struct xkb_state *state,
return 1; return 1;
} }
static int static void
xkb_filter_mod_lock_new(struct xkb_state *state, xkb_filter_mod_lock_new(struct xkb_state *state, struct xkb_filter *filter)
struct xkb_filter *filter,
const struct xkb_key *key,
const union xkb_action *action)
{ {
filter->key = key; filter->priv = state->locked_mods & filter->action.mods.mods.mask;
filter->func = xkb_filter_mod_lock_func; state->locked_mods |= filter->action.mods.mods.mask;
filter->action = *action;
filter->priv = state->locked_mods & action->mods.mods.mask;
state->locked_mods |= action->mods.mods.mask;
return 1;
} }
enum xkb_key_latch_state { enum xkb_key_latch_state {
@ -425,36 +390,28 @@ xkb_filter_mod_latch_func(struct xkb_state *state,
return 1; return 1;
} }
static int static void
xkb_filter_mod_latch_new(struct xkb_state *state, xkb_filter_mod_latch_new(struct xkb_state *state, struct xkb_filter *filter)
struct xkb_filter *filter,
const struct xkb_key *key,
const union xkb_action *action)
{ {
enum xkb_key_latch_state latch = LATCH_KEY_DOWN; filter->priv = LATCH_KEY_DOWN;
state->set_mods = filter->action.mods.mods.mask;
filter->key = key;
filter->priv = latch;
filter->func = xkb_filter_mod_latch_func;
filter->action = *action;
state->set_mods = action->mods.mods.mask;
return 1;
} }
typedef int (*filter_action_new_func_t)(struct xkb_state *state, static const struct {
struct xkb_filter *filter, void (*new)(struct xkb_state *state, struct xkb_filter *filter);
const struct xkb_key *key, int (*func)(struct xkb_state *state, struct xkb_filter *filter,
const union xkb_action *action); const struct xkb_key *key, enum xkb_key_direction direction);
} filter_action_funcs[_ACTION_TYPE_NUM_ENTRIES] = {
static const filter_action_new_func_t [ACTION_TYPE_MOD_SET] = { xkb_filter_mod_set_new,
filter_action_new_funcs[_ACTION_TYPE_NUM_ENTRIES] = { xkb_filter_mod_set_func },
[ACTION_TYPE_MOD_SET] = xkb_filter_mod_set_new, [ACTION_TYPE_MOD_LATCH] = { xkb_filter_mod_latch_new,
[ACTION_TYPE_MOD_LATCH] = xkb_filter_mod_latch_new, xkb_filter_mod_latch_func },
[ACTION_TYPE_MOD_LOCK] = xkb_filter_mod_lock_new, [ACTION_TYPE_MOD_LOCK] = { xkb_filter_mod_lock_new,
[ACTION_TYPE_GROUP_SET] = xkb_filter_group_set_new, xkb_filter_mod_lock_func },
[ACTION_TYPE_GROUP_LOCK] = xkb_filter_group_lock_new, [ACTION_TYPE_GROUP_SET] = { xkb_filter_group_set_new,
xkb_filter_group_set_func },
[ACTION_TYPE_GROUP_LOCK] = { xkb_filter_group_lock_new,
xkb_filter_group_lock_func },
}; };
/** /**
@ -468,7 +425,7 @@ xkb_filter_apply_all(struct xkb_state *state,
enum xkb_key_direction direction) enum xkb_key_direction direction)
{ {
struct xkb_filter *filter; struct xkb_filter *filter;
const union xkb_action *act = NULL; const union xkb_action *action;
int send = 1; int send = 1;
/* First run through all the currently active filters and see if any of /* First run through all the currently active filters and see if any of
@ -482,16 +439,18 @@ xkb_filter_apply_all(struct xkb_state *state,
if (!send || direction == XKB_KEY_UP) if (!send || direction == XKB_KEY_UP)
return; return;
act = xkb_key_get_action(state, key); action = xkb_key_get_action(state, key);
if (filter_action_new_funcs[act->type]) { if (!filter_action_funcs[action->type].new)
filter = xkb_filter_new(state); return;
if (!filter)
goto err;
send = filter_action_new_funcs[act->type](state, filter, key, act);
}
err: filter = xkb_filter_new(state);
return; if (!filter)
return; /* WSGO */
filter->key = key;
filter->func = filter_action_funcs[action->type].func;
filter->action = *action;
filter_action_funcs[action->type].new(state, filter);
} }
XKB_EXPORT struct xkb_state * XKB_EXPORT struct xkb_state *