void drawer_trigger::filter_event(const std::vector<event_code>& evt_codes, const bool bDisabled)
{
for (auto evt_code : evt_codes)
{
filter_event(evt_code, bDisabled);
}
}
/**
* Processes an event through a single event handler.
* This includes checking event filters, but not checking that the event
* name matches.
*
* @param[in,out] handler_p The handler to offer the event to.
* This may be reset during processing.
* @param[in] ev The event information.
*
* @returns true if the game state changed.
*/
bool t_pump::process_event(handler_ptr& handler_p, const queued_event& ev)
{
// We currently never pass a null pointer to this function, but to
// guard against future modifications:
if ( !handler_p )
return false;
unit_map *units = resources::units;
scoped_xy_unit first_unit("unit", ev.loc1.x, ev.loc1.y, *units);
scoped_xy_unit second_unit("second_unit", ev.loc2.x, ev.loc2.y, *units);
scoped_weapon_info first_weapon("weapon", ev.data.child("first"));
scoped_weapon_info second_weapon("second_weapon", ev.data.child("second"));
if ( !filter_event(*handler_p, ev) )
return false;
// The event hasn't been filtered out, so execute the handler.
++impl_->internal_wml_tracking;
context::scoped evc(impl_->contexts_);
assert(resources::lua_kernel != NULL);
handler_p->handle_event(ev, handler_p, *resources::lua_kernel);
// NOTE: handler_p may be null at this point!
if(ev.name == "select") {
resources::gamedata->last_selected = ev.loc1;
}
if(resources::screen != NULL) {
resources::screen->maybe_rebuild();
}
return context_mutated();
}
/**
* pevent_update_trivial - update the trivial filters with the given filter
* @dest - the filter to update
* @source - the filter as the source of the update
* @type - the type of trivial filter to update.
*
* Scan dest for trivial events matching @type to replace with the source.
*
* Returns 0 on success and -1 if there was a problem updating, but
* events may have still been updated on error.
*/
int pevent_update_trivial(struct event_filter *dest, struct event_filter *source,
enum filter_trivial_type type)
{
struct pevent *src_pevent;
struct pevent *dest_pevent;
struct event_format *event;
struct filter_type *filter_type;
struct filter_arg *arg;
char *str;
int i;
src_pevent = source->pevent;
dest_pevent = dest->pevent;
/* Do nothing if either of the filters has nothing to filter */
if (!dest->filters || !source->filters)
return 0;
for (i = 0; i < dest->filters; i++) {
filter_type = &dest->event_filters[i];
arg = filter_type->filter;
if (arg->type != FILTER_ARG_BOOLEAN)
continue;
if ((arg->boolean.value && type == FILTER_TRIVIAL_FALSE) ||
(!arg->boolean.value && type == FILTER_TRIVIAL_TRUE))
continue;
event = filter_type->event;
if (src_pevent != dest_pevent) {
/* do a look up */
event = pevent_find_event_by_name(src_pevent,
event->system,
event->name);
if (!event)
return -1;
}
str = pevent_filter_make_string(source, event->id);
if (!str)
continue;
/* Don't bother if the filter is trivial too */
if (strcmp(str, "TRUE") != 0 && strcmp(str, "FALSE") != 0)
filter_event(dest, event, str, NULL);
free(str);
}
return 0;
}
static int copy_filter_type(struct event_filter *filter,
struct event_filter *source,
struct filter_type *filter_type)
{
struct filter_arg *arg;
struct event_format *event;
const char *sys;
const char *name;
char *str;
/* Can't assume that the pevent's are the same */
sys = filter_type->event->system;
name = filter_type->event->name;
event = pevent_find_event_by_name(filter->pevent, sys, name);
if (!event)
return -1;
str = arg_to_str(source, filter_type->filter);
if (!str)
return -1;
if (strcmp(str, "TRUE") == 0 || strcmp(str, "FALSE") == 0) {
/* Add trivial event */
arg = allocate_arg();
arg->type = FILTER_ARG_BOOLEAN;
if (strcmp(str, "TRUE") == 0)
arg->boolean.value = 1;
else
arg->boolean.value = 0;
filter_type = add_filter_type(filter, event->id);
filter_type->filter = arg;
free(str);
return 0;
}
filter_event(filter, event, str, NULL);
free(str);
return 0;
}
void drawer_trigger::clear_filter()
{
for (int i = 0; i < static_cast<int>(nana::event_code::end); i++)
filter_event(static_cast<nana::event_code>(i), false);
}
/**
* pevent_filter_add_filter_str - add a new filter
* @filter: the event filter to add to
* @filter_str: the filter string that contains the filter
* @error_str: string containing reason for failed filter
*
* Returns 0 if the filter was successfully added
* -1 if there was an error.
*
* On error, if @error_str points to a string pointer,
* it is set to the reason that the filter failed.
* This string must be freed with "free".
*/
int pevent_filter_add_filter_str(struct event_filter *filter,
const char *filter_str,
char **error_str)
{
struct pevent *pevent = filter->pevent;
struct event_list *event;
struct event_list *events = NULL;
const char *filter_start;
const char *next_event;
char *this_event;
char *event_name = NULL;
char *sys_name = NULL;
char *sp;
int rtn = 0;
int len;
int ret;
/* clear buffer to reset show error */
pevent_buffer_init("", 0);
if (error_str)
*error_str = NULL;
filter_start = strchr(filter_str, ':');
if (filter_start)
len = filter_start - filter_str;
else
len = strlen(filter_str);
do {
next_event = strchr(filter_str, ',');
if (next_event &&
(!filter_start || next_event < filter_start))
len = next_event - filter_str;
else if (filter_start)
len = filter_start - filter_str;
else
len = strlen(filter_str);
this_event = malloc_or_die(len + 1);
memcpy(this_event, filter_str, len);
this_event[len] = 0;
if (next_event)
next_event++;
filter_str = next_event;
sys_name = strtok_r(this_event, "/", &sp);
event_name = strtok_r(NULL, "/", &sp);
if (!sys_name) {
show_error(error_str, "No filter found");
/* This can only happen when events is NULL, but still */
free_events(events);
free(this_event);
return -1;
}
/* Find this event */
ret = find_event(pevent, &events, strim(sys_name), strim(event_name));
if (ret < 0) {
if (event_name)
show_error(error_str,
"No event found under '%s.%s'",
sys_name, event_name);
else
show_error(error_str,
"No event found under '%s'",
sys_name);
free_events(events);
free(this_event);
return -1;
}
free(this_event);
} while (filter_str);
/* Skip the ':' */
if (filter_start)
filter_start++;
/* filter starts here */
for (event = events; event; event = event->next) {
ret = filter_event(filter, event->event, filter_start,
error_str);
/* Failures are returned if a parse error happened */
if (ret < 0)
rtn = ret;
if (ret >= 0 && pevent->test_filters) {
char *test;
test = pevent_filter_make_string(filter, event->event->id);
printf(" '%s: %s'\n", event->event->name, test);
free(test);
}
}
free_events(events);
if (rtn >= 0 && pevent->test_filters)
exit(0);
return rtn;
}
static void *
ucb1x00tsEventThread( DirectThread *thread, void *driver_data )
{
ucb1x00TSData *data = (ucb1x00TSData*) driver_data;
TS_EVENT ts_event;
int readlen;
unsigned short old_x = -1;
unsigned short old_y = -1;
unsigned short old_pressure = 0;
while ((readlen = read(data->fd, &ts_event, sizeof(TS_EVENT))) > 0 ||
errno == EINTR)
{
DFBInputEvent evt;
direct_thread_testcancel( thread );
if (readlen < 1)
continue;
filter_event( &ts_event );
scale_point( &ts_event );
ts_event.pressure = (ts_event.pressure > config.zthresh );
if (ts_event.pressure) {
if (ts_event.x != old_x) {
evt.type = DIET_AXISMOTION;
evt.flags = DIEF_AXISABS;
evt.axis = DIAI_X;
evt.axisabs = ts_event.x;
dfb_input_dispatch( data->device, &evt );
old_x = ts_event.x;
}
if (ts_event.y != old_y) {
evt.type = DIET_AXISMOTION;
evt.flags = DIEF_AXISABS;
evt.axis = DIAI_Y;
evt.axisabs = ts_event.y;
dfb_input_dispatch( data->device, &evt );
old_y = ts_event.y;
}
}
if ((ts_event.pressure && !old_pressure) ||
(!ts_event.pressure && old_pressure)) {
evt.type = (ts_event.pressure ?
DIET_BUTTONPRESS : DIET_BUTTONRELEASE);
evt.flags = DIEF_NONE;
evt.button = DIBI_LEFT;
dfb_input_dispatch( data->device, &evt );
old_pressure = ts_event.pressure;
}
}
if (readlen <= 0)
D_PERROR ("ucb1x00 Touchscreen thread died\n");
return NULL;
}
