void mi::Validator::handle_touch_event(MirInputDeviceId id, MirTouchEvent const* ev)
{
std::lock_guard<std::mutex> lg(state_guard);
auto it = last_event_by_device.find(id);
MirTouchEvent const* last_ev = nullptr;
auto default_ev = mev::make_event(id,
std::chrono::high_resolution_clock::now().time_since_epoch(),
0, /* No need for a mac, since there's no pointer count for a default event */
mir_input_event_modifier_none);
if (it == last_event_by_device.end())
{
last_event_by_device.insert(std::make_pair(id, copy_event(ev)));
last_ev = reinterpret_cast<MirTouchEvent const*>(default_ev.get());
}
else
{
last_ev = mir_input_event_get_touch_event(mir_event_get_input_event(it->second.get()));
}
ensure_stream_validity_locked(lg, ev, last_ev);
// Seems to be no better way to replace a non default constructible value type in an unordered_map
// C++17 will give us insert_or_assign
last_event_by_device.erase(id);
last_event_by_device.insert(std::make_pair(id, copy_event(ev)));
dispatch_valid_event(*reinterpret_cast<MirEvent const*>(ev));
}
int
main(int argc, char *argv[])
{
int number;
int canonical = 0;
int unicode = 0;
number = 1;
while (number < argc) {
if (strcmp(argv[number], "-c") == 0) {
canonical = 1;
}
else if (strcmp(argv[number], "-u") == 0) {
unicode = 1;
}
else if (argv[number][0] == '-') {
printf("Unknown option: '%s'\n", argv[number]);
return 0;
}
if (argv[number][0] == '-') {
if (number < argc-1) {
memmove(argv+number, argv+number+1, (argc-number-1)*sizeof(char *));
}
argc --;
}
else {
number ++;
}
}
if (argc < 2) {
printf("Usage: %s [-c] [-u] file1.yaml ...\n", argv[0]);
return 0;
}
for (number = 1; number < argc; number ++)
{
FILE *file;
ygp_parser_t parser;
ygp_emitter_t emitter;
ygp_event_t event;
unsigned char buffer[BUFFER_SIZE];
size_t written = 0;
ygp_event_t events[MAX_EVENTS];
size_t event_number = 0;
int done = 0;
int count = 0;
int error = 0;
int k;
memset(buffer, 0, BUFFER_SIZE);
memset(events, 0, MAX_EVENTS*sizeof(ygp_event_t));
printf("[%d] Parsing, emitting, and parsing again '%s': ", number, argv[number]);
fflush(stdout);
file = fopen(argv[number], "rb");
assert(file);
assert(ygp_parser_initialize(&parser));
ygp_parser_set_input_file(&parser, file);
assert(ygp_emitter_initialize(&emitter));
if (canonical) {
ygp_emitter_set_canonical(&emitter, 1);
}
if (unicode) {
ygp_emitter_set_unicode(&emitter, 1);
}
ygp_emitter_set_output_string(&emitter, buffer, BUFFER_SIZE, &written);
while (!done)
{
if (!ygp_parser_parse(&parser, &event)) {
error = 1;
break;
}
done = (event.type == YGP_STREAM_END_EVENT);
assert(event_number < MAX_EVENTS);
assert(copy_event(&(events[event_number++]), &event));
assert(ygp_emitter_emit(&emitter, &event) ||
(ygp_emitter_flush(&emitter) && print_output(argv[number], buffer, written, count)));
count ++;
}
ygp_parser_delete(&parser);
assert(!fclose(file));
ygp_emitter_delete(&emitter);
if (!error)
{
count = done = 0;
assert(ygp_parser_initialize(&parser));
ygp_parser_set_input_string(&parser, buffer, written);
while (!done)
{
assert(ygp_parser_parse(&parser, &event) || print_output(argv[number], buffer, written, count));
done = (event.type == YGP_STREAM_END_EVENT);
assert(compare_events(events+count, &event) || print_output(argv[number], buffer, written, count));
ygp_event_delete(&event);
count ++;
}
ygp_parser_delete(&parser);
}
for (k = 0; k < event_number; k ++) {
ygp_event_delete(events+k);
}
printf("PASSED (length: %d)\n", written);
print_output(argv[number], buffer, written, -1);
}
return 0;
}
