void fgPrintXIDeviceEvent(XIDeviceEvent* event) { double *val; int i; printf(" device: %d (%d)\n", event->deviceid, event->sourceid); printf(" detail: %d\n", event->detail); printf(" buttons:"); for (i = 0; i < event->buttons.mask_len * 8; i++) if (XIMaskIsSet(event->buttons.mask, i)) printf(" %d", i); printf("\n"); printf(" modifiers: locked 0x%x latched 0x%x base 0x%x\n", event->mods.locked, event->mods.latched, event->mods.base); printf(" group: locked 0x%x latched 0x%x base 0x%x\n", event->group.locked, event->group.latched, event->group.base); printf(" valuators:"); val = event->valuators.values; for (i = 0; i < event->valuators.mask_len * 8; i++) if (XIMaskIsSet(event->valuators.mask, i)) printf(" %d: %.2f", i, *val++); printf("\n"); printf(" windows: root 0x%lx event 0x%lx child 0x%ld\n", event->root, event->event, event->child); printf(" root x/y: %.2f / %.2f\n", event->root_x, event->root_y); printf(" event x/y: %.2f / %.2f\n", event->event_x, event->event_y); }
static void print_deviceevent(XIDeviceEvent* event) { double *val; int i; printf(" device: %d (%d)\n", event->deviceid, event->sourceid); printf(" detail: %d\n", event->detail); switch(event->evtype) { case XI_KeyPress: case XI_KeyRelease: printf(" flags: %s\n", (event->flags & XIKeyRepeat) ? "repeat" : ""); break; #if HAVE_XI21 case XI_ButtonPress: case XI_ButtonRelease: case XI_Motion: printf(" flags: %s\n", (event->flags & XIPointerEmulated) ? "emulated" : ""); break; #endif #if HAVE_XI22 case XI_TouchBegin: case XI_TouchUpdate: case XI_TouchEnd: printf(" flags:%s%s\n", (event->flags & XITouchPendingEnd) ? " pending_end" : "", (event->flags & XITouchEmulatingPointer) ? " emulating" : ""); break; #endif } printf(" root: %.2f/%.2f\n", event->root_x, event->root_y); printf(" event: %.2f/%.2f\n", event->event_x, event->event_y); printf(" buttons:"); for (i = 0; i < event->buttons.mask_len * 8; i++) if (XIMaskIsSet(event->buttons.mask, i)) printf(" %d", i); printf("\n"); printf(" modifiers: locked %#x latched %#x base %#x effective: %#x\n", event->mods.locked, event->mods.latched, event->mods.base, event->mods.effective); printf(" group: locked %#x latched %#x base %#x effective: %#x\n", event->group.locked, event->group.latched, event->group.base, event->group.effective); printf(" valuators:\n"); val = event->valuators.values; for (i = 0; i < event->valuators.mask_len * 8; i++) if (XIMaskIsSet(event->valuators.mask, i)) printf(" %i: %.2f\n", i, *val++); printf(" windows: root 0x%lx event 0x%lx child 0x%lx\n", event->root, event->event, event->child); }
static void print_rawevent(XIRawEvent *event) { int i; double *val, *raw_val; printf(" device: %d (%d)\n", event->deviceid, event->sourceid); printf(" detail: %d\n", event->detail); #if HAVE_XI21 switch(event->evtype) { case XI_RawButtonPress: case XI_RawButtonRelease: case XI_RawMotion: printf(" flags: %s\n", (event->flags & XIPointerEmulated) ? "emulated" : ""); break; } #endif printf(" valuators:\n"); val = event->valuators.values; raw_val = event->raw_values; for (i = 0; i < event->valuators.mask_len * 8; i++) if (XIMaskIsSet(event->valuators.mask, i)) printf(" %2d: %.2f (%.2f)\n", i, *val++, *raw_val++); printf("\n"); }
static void handle_raw_motion(XIRawEvent *ev) { double *raw_valuator = ev->raw_values; if(!mouse_active) return; if(XIMaskIsSet(ev->valuators.mask, 0)) { mx += *raw_valuator++; } if(XIMaskIsSet(ev->valuators.mask, 1)) { my += *raw_valuator++; } }
void _clutter_input_device_xi2_translate_state (ClutterEvent *event, XIModifierState *modifiers_state, XIButtonState *buttons_state, XIGroupState *group_state) { guint button = 0; guint base = 0; guint latched = 0; guint locked = 0; guint effective; if (modifiers_state) { base = (guint) modifiers_state->base; latched = (guint) modifiers_state->latched; locked = (guint) modifiers_state->locked; } if (buttons_state) { int len, i; len = MIN (N_BUTTONS, buttons_state->mask_len * 8); for (i = 0; i < len; i++) { if (!XIMaskIsSet (buttons_state->mask, i)) continue; button |= get_modifier_for_button (i); } } /* The XIButtonState sent in the event specifies the * state of the buttons before the event. In order to * get the current state of the buttons, we need to * filter out the current button. */ switch (event->type) { case CLUTTER_BUTTON_PRESS: button |= (get_modifier_for_button (event->button.button)); break; case CLUTTER_BUTTON_RELEASE: button &= ~(get_modifier_for_button (event->button.button)); break; default: break; } effective = button | base | latched | locked; if (group_state) effective |= (group_state->effective) << 13; _clutter_event_set_state_full (event, button, base, latched, locked, effective); }
static gboolean xfwm_device_check_mask_event_xi2_predicate (Display *display, XEvent *xevent, XPointer user_data) { XI2CheckMaskContext *context = (void *)user_data; if (xevent->type == GenericEvent && xevent->xgeneric.extension == context->devices->xi2_opcode && XIMaskIsSet (context->xievent_mask.mask, xevent->xgeneric.evtype)) { /* GDK holds XI2 event data which we are replacing so it should be released here */ XFreeEventData (display, &context->event->meta.x->xcookie); return TRUE; } return FALSE; }
void fgPrintXILeaveEvent(XILeaveEvent* event) { char* mode = ""; char* detail = ""; int i; printf(" windows: root 0x%lx event 0x%lx child 0x%ld\n", event->root, event->event, event->child); switch(event->mode) { case NotifyNormal: mode = "NotifyNormal"; break; case NotifyGrab: mode = "NotifyGrab"; break; case NotifyUngrab: mode = "NotifyUngrab"; break; case NotifyWhileGrabbed: mode = "NotifyWhileGrabbed"; break; } switch (event->detail) { case NotifyAncestor: detail = "NotifyAncestor"; break; case NotifyVirtual: detail = "NotifyVirtual"; break; case NotifyInferior: detail = "NotifyInferior"; break; case NotifyNonlinear: detail = "NotifyNonlinear"; break; case NotifyNonlinearVirtual: detail = "NotifyNonlinearVirtual"; break; case NotifyPointer: detail = "NotifyPointer"; break; case NotifyPointerRoot: detail = "NotifyPointerRoot"; break; case NotifyDetailNone: detail = "NotifyDetailNone"; break; } printf(" mode: %s (detail %s)\n", mode, detail); printf(" flags: %s %s\n", event->focus ? "[focus]" : "", event->same_screen ? "[same screen]" : ""); printf(" buttons:"); for (i = 0; i < event->buttons.mask_len * 8; i++) if (XIMaskIsSet(event->buttons.mask, i)) printf(" %d", i); printf("\n"); printf(" modifiers: locked 0x%x latched 0x%x base 0x%x\n", event->mods.locked, event->mods.latched, event->mods.base); printf(" group: locked 0x%x latched 0x%x base 0x%x\n", event->group.locked, event->group.latched, event->group.base); printf(" root x/y: %.2f / %.2f\n", event->root_x, event->root_y); printf(" event x/y: %.2f / %.2f\n", event->event_x, event->event_y); }
static guint xfwm_device_obtain_state_xi2 (XIButtonState *buttons, XIModifierState *mods, XIGroupState *group) { guint result; gint i, count; result = mods->effective | (group->effective << 13); count = MIN (3, buttons->mask_len / 8); for (i = 0; i < count; i++) { /* check first 3 buttons as GDK does */ if (XIMaskIsSet (buttons->mask, i + 1)) { result |= 1 << (8 + i); } } return result; }
void EventHandler::parseTouchPoints(XIValuatorState valuators, QList<QPoint>& points) { double *val = valuators.values; int x = 0; int y = 0; for (int i = 0; i < valuators.mask_len * 8; i++) { if (XIMaskIsSet(valuators.mask, i) && (i % 5 == 0)) { x = (int)(*val++); y = (int)(*val); //qDebug("x %d y %d", x, y); points.push_back(QPoint(x,y)); } else { val++; } } }
static void test_values_XIDeviceEvent(DeviceEvent *in, xXIDeviceEvent *out, BOOL swap) { int buttons, valuators; int i; unsigned char *ptr; uint32_t flagmask = 0; FP3232 *values; if (swap) { swaps(&out->sequenceNumber); swapl(&out->length); swaps(&out->evtype); swaps(&out->deviceid); swaps(&out->sourceid); swapl(&out->time); swapl(&out->detail); swapl(&out->root); swapl(&out->event); swapl(&out->child); swapl(&out->root_x); swapl(&out->root_y); swapl(&out->event_x); swapl(&out->event_y); swaps(&out->buttons_len); swaps(&out->valuators_len); swapl(&out->mods.base_mods); swapl(&out->mods.latched_mods); swapl(&out->mods.locked_mods); swapl(&out->mods.effective_mods); swapl(&out->flags); } assert(out->extension == 0); /* IReqCode defaults to 0 */ assert(out->evtype == GetXI2Type((InternalEvent*)in)); assert(out->time == in->time); assert(out->detail == in->detail.button); assert(out->length >= 12); assert(out->deviceid == in->deviceid); assert(out->sourceid == in->sourceid); switch (in->type) { case ET_ButtonPress: case ET_Motion: case ET_ButtonRelease: flagmask = XIPointerEmulated; break; case ET_KeyPress: flagmask = XIKeyRepeat; break; default: flagmask = 0; break; } assert((out->flags & ~flagmask) == 0); assert(out->root == in->root); assert(out->event == None); /* set in FixUpEventFromWindow */ assert(out->child == None); /* set in FixUpEventFromWindow */ assert(out->mods.base_mods == in->mods.base); assert(out->mods.latched_mods == in->mods.latched); assert(out->mods.locked_mods == in->mods.locked); assert(out->mods.effective_mods == in->mods.effective); assert(out->group.base_group == in->group.base); assert(out->group.latched_group == in->group.latched); assert(out->group.locked_group == in->group.locked); assert(out->group.effective_group == in->group.effective); assert(out->event_x == 0); /* set in FixUpEventFromWindow */ assert(out->event_y == 0); /* set in FixUpEventFromWindow */ assert(out->root_x == FP1616(in->root_x, in->root_x_frac)); assert(out->root_y == FP1616(in->root_y, in->root_y_frac)); buttons = 0; for (i = 0; i < bits_to_bytes(sizeof(in->buttons)); i++) { if (XIMaskIsSet(in->buttons, i)) { assert(out->buttons_len >= bytes_to_int32(bits_to_bytes(i))); buttons++; } } ptr = (unsigned char*)&out[1]; for (i = 0; i < sizeof(in->buttons) * 8; i++) assert(XIMaskIsSet(in->buttons, i) == XIMaskIsSet(ptr, i)); valuators = 0; for (i = 0; i < MAX_VALUATORS; i++) if (XIMaskIsSet(in->valuators.mask, i)) valuators++; assert(out->valuators_len >= bytes_to_int32(bits_to_bytes(valuators))); ptr += out->buttons_len * 4; values = (FP3232*)(ptr + out->valuators_len * 4); for (i = 0; i < sizeof(in->valuators.mask) * 8 || i < (out->valuators_len * 4) * 8; i++) { if (i >= MAX_VALUATORS) assert(!XIMaskIsSet(in->valuators.mask, i) && !XIMaskIsSet(ptr, i)); else if (i > sizeof(in->valuators.mask) * 8) assert(!XIMaskIsSet(ptr, i)); else if (i > out->valuators_len * 4 * 8) assert(!XIMaskIsSet(in->valuators.mask, i)); else { assert(XIMaskIsSet(in->valuators.mask, i) == XIMaskIsSet(ptr, i)); if (XIMaskIsSet(ptr, i)) { FP3232 vi, vo; vi = double_to_fp3232(in->valuators.data[i]); vo = *values; if (swap) { swapl(&vo.integral); swapl(&vo.frac); } assert(vi.integral == vo.integral); assert(vi.frac == vo.frac); values++; } } } }
bool KeyboardMouse::UpdateInput() { XFlush(m_display); // Get the absolute position of the mouse pointer UpdateCursor(); // for the axis controls float delta_x = 0.0f, delta_y = 0.0f; double delta_delta; // Iterate through the event queue - update the axis controls, mouse // button controls, and keyboard controls. XEvent event; while (XPending(m_display)) { XNextEvent(m_display, &event); if (event.xcookie.type != GenericEvent) continue; if (event.xcookie.extension != xi_opcode) continue; if (!XGetEventData(m_display, &event.xcookie)) continue; // only one of these will get used XIDeviceEvent* dev_event = (XIDeviceEvent*)event.xcookie.data; XIRawEvent* raw_event = (XIRawEvent*)event.xcookie.data; switch (event.xcookie.evtype) { case XI_ButtonPress: m_state.buttons |= 1<<(dev_event->detail-1); break; case XI_ButtonRelease: m_state.buttons &= ~(1<<(dev_event->detail-1)); break; case XI_KeyPress: m_state.keyboard[dev_event->detail / 8] |= 1<<(dev_event->detail % 8); break; case XI_KeyRelease: m_state.keyboard[dev_event->detail / 8] &= ~(1<<(dev_event->detail % 8)); break; case XI_RawMotion: // always safe because there is always at least one byte in // raw_event->valuators.mask, and if a bit is set in the mask, // then the value in raw_values is also available. if (XIMaskIsSet(raw_event->valuators.mask, 0)) { delta_delta = raw_event->raw_values[0]; // test for inf and nan if (delta_delta == delta_delta && 1+delta_delta != delta_delta) delta_x += delta_delta; } if (XIMaskIsSet(raw_event->valuators.mask, 1)) { delta_delta = raw_event->raw_values[1]; // test for inf and nan if (delta_delta == delta_delta && 1+delta_delta != delta_delta) delta_y += delta_delta; } break; } XFreeEventData(m_display, &event.xcookie); } // apply axis smoothing m_state.axis.x *= MOUSE_AXIS_SMOOTHING; m_state.axis.x += delta_x; m_state.axis.x /= MOUSE_AXIS_SMOOTHING+1.0f; m_state.axis.y *= MOUSE_AXIS_SMOOTHING; m_state.axis.y += delta_y; m_state.axis.y /= MOUSE_AXIS_SMOOTHING+1.0f; return true; }
void handle_events(void) { int deltax; int deltay; XEvent event; XIDeviceEvent *e; double value; mickey_x = mickey_y = 0; float x=0, y=0; int pos=0; while(XPending(display) > 0) { XNextEvent(display, &event); if(XGetEventData(display, &event.xcookie)) { XGenericEventCookie *c = &event.xcookie; e = c->data; if(c->extension == opcode && c->type == GenericEvent) switch(c->evtype) { // case XI_RawMotion: // print_rawmotion(e); // break; // case XI_ButtonPress: case XI_Motion: // case XI_KeyPress: pos = 0; for(int i=0; i < e->valuators.mask_len * 8; i++) if(XIMaskIsSet(e->valuators.mask, i)) { value = e->valuators.values[pos]; printf("%d -- %f --\n",pos, value); switch(i) { case 0: if(value > 1.0) { x=value; pos++; printf("%#+f\n",x); } break; case 1: if(value > 1.0) { y=value; pos++; printf("\t\t%f\n",y); } break; default: printf("%d -- %f --\n",pos, value); break; } } printf("%f\t%f\t--\n",x, y); break; default: break; } XFreeEventData(display, &event.xcookie); } else switch(event.type) { case ConfigureNotify: vid_width = event.xconfigure.width; vid_height = event.xconfigure.height; glViewport(0, 0, vid_width, vid_height); break; case ClientMessage: killme=1; break; /* Mouse */ case ButtonPress: switch(event.xbutton.button) { case 1: mouse[0]=1; break; case 2: mouse[1]=1; break; case 3: mouse[2]=1; break; } break; case ButtonRelease: switch(event.xbutton.button) { case 1: mouse[0]=0; break; case 2: mouse[1]=0; break; case 3: mouse[2]=0; break; } break; case MotionNotify: // printf("x=%d, y=%d\n", event.xmotion.x_root, // event.xmotion.y_root); if(ignore_mouse) // { if(event.xmotion.x == vid_width/2) { ignore_mouse = 0; break; } // } deltax = mouse_x - event.xmotion.x; mouse_x = event.xmotion.x; mickey_x += deltax; deltay = mouse_y - event.xmotion.y; mouse_y = event.xmotion.y; mickey_y += deltay; break; /* keyboard */ case KeyPress: if(event.xkey.keycode < KEYMAX) keys[event.xkey.keycode] = 1; break; case KeyRelease: if(event.xkey.keycode < KEYMAX) keys[event.xkey.keycode] = 0; if(event.xkey.keycode == KEY_F11) fullscreen_toggle=1; break; } } if(fullscreen) { // Window root = XRootWindow(display, 0); // XWarpPointer(display, None, window, 0, 0, 0, 0, // vid_width/2, vid_height/2); // ignore_mouse = 1; // XFlush(display); // XNextEvent(display, &event); /* event.xmotion.x = vid_width/2 - mouse_x; event.xmotion.y = vid_height/2 - mouse_y; event.xmotion.send_event = True; event.xmotion.time = CurrentTime; event.xmotion.window = window; event.xmotion.is_hint = NotifyNormal; // event.xmotion.root = window; event.type = MotionNotify; XSendEvent(display, PointerWindow, True, PointerMotionMask, &event); */ } if(fullscreen_toggle) { x11_down(); fullscreen_toggle = 0; fullscreen = !fullscreen; x11_window(); } }
bool rawinput_msg_x11(Display *display,int opcode,XEvent *ev, int *inputs,int *mx,int *my,int *mz) { XGenericEventCookie *cookie = &ev->xcookie; if(cookie->type!=GenericEvent) { return false; } if(cookie->extension != opcode) { return false; } if(!XGetEventData(display, cookie)) { return false; } XIRawEvent *xiEvent = (XIRawEvent*)cookie->data; double *raw_valuator = xiEvent->raw_values; double *valuator = xiEvent->valuators.values; if(cookie->evtype==XI_RawButtonPress) { if(xiEvent->detail == 1) { if(inputs[MOUSE_LEFT]!=INPUT_DOWN) { inputs[MOUSE_LEFT]=INPUT_PRESS; } } else if(xiEvent->detail == 2) { if(inputs[MOUSE_MIDDLE]!=INPUT_DOWN) { inputs[MOUSE_MIDDLE]=INPUT_PRESS; } } else if(xiEvent->detail == 3) { if(inputs[MOUSE_RIGHT]!=INPUT_DOWN) { inputs[MOUSE_RIGHT]=INPUT_PRESS; } } } else if(cookie->evtype==XI_RawButtonRelease) { if(xiEvent->detail == 1 ) {// if(inputs[MOUSE_LEFT]!=INPUT_UP) { inputs[MOUSE_LEFT]=INPUT_RELEASE; } } else if(xiEvent->detail == 2) { if(inputs[MOUSE_MIDDLE]!=INPUT_UP) { inputs[MOUSE_MIDDLE]=INPUT_RELEASE; } } else if(xiEvent->detail == 3) { if(inputs[MOUSE_RIGHT]!=INPUT_UP) { inputs[MOUSE_RIGHT]=INPUT_RELEASE; } } } else if(cookie->evtype==XI_RawKeyPress) { int k=key_convert_x11(xiEvent->detail); if(inputs[k]!=INPUT_DOWN) { inputs[k]=INPUT_PRESS; } } else if(cookie->evtype==XI_RawKeyRelease) { int k=key_convert_x11(xiEvent->detail); if(inputs[k]!=INPUT_UP) { inputs[k]=INPUT_RELEASE; } } else if(cookie->evtype==XI_RawMotion) { int i; for (i = 0; i < xiEvent->valuators.mask_len * 8; i++) { if (XIMaskIsSet(xiEvent->valuators.mask, i) ) { if(i==0 && valuator[i]!=0.0) {//x *mx=(int)valuator[i];//- raw_valuator[i]; } else if(i==1 && valuator[i]!=0.0) {//y *my=(int)valuator[i];//- raw_valuator[i]; } else if(i==2 && valuator[i]!=0.0) {//z *mz=(int)valuator[i];//- raw_valuator[i]; } else if(i==3 && valuator[i]!=0.0) {//z } } } } return true; }
static XIEventMask* set_hierarchy_mask(::Display *display, int *nmasks_out, bool *was_set, bool *was_created) { XIEventMask *masks; int nmasks; bool mask_toggled = false; bool new_mask_created = false; XIEventMask *all_devices_mask = NULL; masks = XIGetSelectedEvents(display, DefaultRootWindow(display), &nmasks); /* masks is in a quirky data format (one chunk of memory). Change into a format easier to manipulate. */ /* extra one, in case we have zero masks or no XIAllDevices mask */ XIEventMask *new_masks = new XIEventMask[nmasks + 1]; for (int i = 0; i < nmasks; i++) { XIEventMask *m = &new_masks[i]; *m = masks[i]; if (masks[i].deviceid == XIAllDevices) { all_devices_mask = m; if (masks[i].mask_len < XIMaskLen(XI_HierarchyChanged)) { m->mask_len = XIMaskLen(XI_HierarchyChanged); mask_toggled = true; } else mask_toggled = !XIMaskIsSet(m->mask, XI_HierarchyChanged); } m->mask = new unsigned char[m->mask_len](); memcpy(m->mask, masks[i].mask, masks[i].mask_len); if (mask_toggled && m->deviceid == XIAllDevices) XISetMask(m->mask, XI_HierarchyChanged); } if (!all_devices_mask) { all_devices_mask = &new_masks[nmasks++]; all_devices_mask->deviceid = XIAllDevices; all_devices_mask->mask_len = XIMaskLen(XI_HierarchyChanged); all_devices_mask->mask = new unsigned char[all_devices_mask->mask_len](); XISetMask(all_devices_mask->mask, XI_HierarchyChanged); new_mask_created = true; } XFree(masks); masks = NULL; if (new_mask_created || mask_toggled) { XISelectEvents(display, DefaultRootWindow(display), new_masks, nmasks); XFlush(display); } *was_set = mask_toggled; *was_created = new_mask_created; *nmasks_out = nmasks; return new_masks; }
static void x11_init(void) { memset(keys, 0, KEYMAX); memset(mouse, 0, 3); display = XOpenDisplay(0); screen = DefaultScreen(display); xvis = glXChooseVisual(display, screen, xAttrList); if(!xvis) { printf("glXChooseVisual() failed.\n"); exit(1); } glx_context = glXCreateContext(display, xvis, 0, GL_TRUE); memset(&xwin_attr, 0, sizeof(XSetWindowAttributes)); xwin_attr.colormap = XCreateColormap(display, RootWindow(display, xvis->screen), xvis->visual, AllocNone); xwin_attr.event_mask = ExposureMask | StructureNotifyMask | ButtonPressMask | ButtonReleaseMask | PointerMotionMask | KeyPressMask | KeyReleaseMask; x11_window(); static char buf[] = { 0,0,0,0,0,0,0,0 }; XColor black = { .red=0, .green=0, .blue=0 }; Pixmap bitmap = XCreateBitmapFromData(display, window, buf, 2, 2); cursor_none = XCreatePixmapCursor(display, bitmap, bitmap, &black, &black, 0, 0); int event, error; if (!XQueryExtension(display, "XInputExtension", &opcode, &event, &error)) { printf("X Input extension not available.\n"); return; } #ifdef ASD /* Which version of XI2? We support 2.0 */ int major = 2, minor = 0; if (XIQueryVersion(display, &major, &minor) == BadRequest) { printf("XI2 not available. Server supports %d.%d\n", major, minor); return; } XIEventMask eventmask; unsigned char mask[3] = { 0,0,0 }; /* the actual mask */ eventmask.deviceid = XIAllDevices; eventmask.mask_len = sizeof(mask); /* always in bytes */ eventmask.mask = mask; /* now set the mask */ // XISetMask(mask, XI_ButtonPress); // XISetMask(mask, XI_ButtonRelease); XISetMask(mask, XI_RawMotion); // XISetMask(mask, XI_KeyPress); // mask = mask | KeyReleaseMask | KeyPressMask; /* select on the window */ Window root = DefaultRootWindow(display); XISelectEvents(display, root, &eventmask, 1); // XSetDeviceMode(display, mouse, Relative); #endif } void print_rawmotion(XIRawEvent *event) { int i; double *raw_valuator = event->raw_values, *valuator = event->valuators.values; for (i = 0; i < event->valuators.mask_len * 8; i++) { if (XIMaskIsSet(event->valuators.mask, i)) { switch(i) { case 0: mickey_x += *valuator; break; case 1: mickey_y += *valuator; break; default: break; } valuator++; raw_valuator++; } } }
static void test_values_XIRawEvent(RawDeviceEvent *in, xXIRawEvent *out, BOOL swap) { int i; unsigned char *ptr; FP3232 *value, *raw_value; int nvals = 0; int bits_set; int len; uint32_t flagmask = 0; if (swap) { swaps(&out->sequenceNumber); swapl(&out->length); swaps(&out->evtype); swaps(&out->deviceid); swapl(&out->time); swapl(&out->detail); swaps(&out->valuators_len); swapl(&out->flags); } assert(out->type == GenericEvent); assert(out->extension == 0); /* IReqCode defaults to 0 */ assert(out->evtype == GetXI2Type((InternalEvent*)in)); assert(out->time == in->time); assert(out->detail == in->detail.button); assert(out->deviceid == in->deviceid); assert(out->valuators_len >= bytes_to_int32(bits_to_bytes(sizeof(in->valuators.mask)))); switch (in->type) { case ET_RawMotion: case ET_RawButtonPress: case ET_RawButtonRelease: flagmask = XIPointerEmulated; break; default: flagmask = 0; } assert((out->flags & ~flagmask) == 0); ptr = (unsigned char*)&out[1]; bits_set = 0; for (i = 0; out->valuators_len && i < sizeof(in->valuators.mask) * 8; i++) { if (i >= MAX_VALUATORS) assert (!XIMaskIsSet(in->valuators.mask, i)); assert (XIMaskIsSet(in->valuators.mask, i) == XIMaskIsSet(ptr, i)); if (XIMaskIsSet(in->valuators.mask, i)) bits_set++; } /* length is len of valuator mask (in 4-byte units) + the number of bits * set. Each bit set represents 2 8-byte values, hence the * 'bits_set * 4' */ len = out->valuators_len + bits_set * 4; assert(out->length == len); nvals = 0; for (i = 0; out->valuators_len && i < MAX_VALUATORS; i++) { assert (XIMaskIsSet(in->valuators.mask, i) == XIMaskIsSet(ptr, i)); if (XIMaskIsSet(in->valuators.mask, i)) { FP3232 vi, vo; value = (FP3232*)(((unsigned char*)&out[1]) + out->valuators_len * 4); value += nvals; vi = double_to_fp3232(in->valuators.data[i]); vo.integral = value->integral; vo.frac = value->frac; if (swap) { swapl(&vo.integral); swapl(&vo.frac); } assert(vi.integral == vo.integral); assert(vi.frac == vo.frac); raw_value = value + bits_set; vi = double_to_fp3232(in->valuators.data_raw[i]); vo.integral = raw_value->integral; vo.frac = raw_value->frac; if (swap) { swapl(&vo.integral); swapl(&vo.frac); } assert(vi.integral == vo.integral); assert(vi.frac == vo.frac); nvals++; } } }
static void xinput_process_event(XIRawEvent* revent) { GE_Event evt = {}; int i; //ignore events from master device if (revent->deviceid != revent->sourceid || revent->sourceid >= GE_MAX_DEVICES) { return; } int index = device_index[revent->sourceid]; switch (revent->evtype) { case XI_RawMotion: if(index >= 0) { evt.type = GE_MOUSEMOTION; evt.motion.which = devices[index].id; i = 0; evt.motion.xrel = XIMaskIsSet(revent->valuators.mask, 0) ? revent->raw_values[i++] : 0; evt.motion.yrel = XIMaskIsSet(revent->valuators.mask, 1) ? revent->raw_values[i++] : 0; } break; case XI_RawButtonPress: if(index >= 0) { evt.type = GE_MOUSEBUTTONDOWN; evt.button.which = devices[index].id; evt.button.button = get_button(revent->detail); } break; case XI_RawButtonRelease: if(index >= 0) { evt.type = GE_MOUSEBUTTONUP; evt.button.which = devices[index].id; evt.button.button = get_button(revent->detail); } break; case XI_RawKeyPress: { if(index >= 0) { evt.type = GE_KEYDOWN; evt.button.which = devices[index].id; evt.button.button = revent->detail - 8; } break; } case XI_RawKeyRelease: { if(index >= 0) { evt.type = GE_KEYUP; evt.button.which = devices[index].id; evt.button.button = revent->detail - 8; } break; } default: break; } /* * Process evt. */ if(evt.type != GE_NOEVENT) { event_callback(&evt); } }
static void print_enterleave(XILeaveEvent* event) { char *mode = "<undefined>", *detail = "<undefined>"; int i; printf(" device: %d (%d)\n", event->deviceid, event->sourceid); printf(" windows: root 0x%lx event 0x%lx child 0x%ld\n", event->root, event->event, event->child); switch(event->mode) { case XINotifyNormal: mode = "NotifyNormal"; break; case XINotifyGrab: mode = "NotifyGrab"; break; case XINotifyUngrab: mode = "NotifyUngrab"; break; case XINotifyWhileGrabbed: mode = "NotifyWhileGrabbed"; break; case XINotifyPassiveGrab: mode = "NotifyPassiveGrab"; break; case XINotifyPassiveUngrab: mode = "NotifyPassiveUngrab"; break; } switch (event->detail) { case XINotifyAncestor: detail = "NotifyAncestor"; break; case XINotifyVirtual: detail = "NotifyVirtual"; break; case XINotifyInferior: detail = "NotifyInferior"; break; case XINotifyNonlinear: detail = "NotifyNonlinear"; break; case XINotifyNonlinearVirtual: detail = "NotifyNonlinearVirtual"; break; case XINotifyPointer: detail = "NotifyPointer"; break; case XINotifyPointerRoot: detail = "NotifyPointerRoot"; break; case XINotifyDetailNone: detail = "NotifyDetailNone"; break; } printf(" mode: %s (detail %s)\n", mode, detail); printf(" flags: %s %s\n", event->focus ? "[focus]" : "", event->same_screen ? "[same screen]" : ""); printf(" buttons:"); for (i = 0; i < event->buttons.mask_len * 8; i++) if (XIMaskIsSet(event->buttons.mask, i)) printf(" %d", i); printf("\n"); printf(" modifiers: locked %#x latched %#x base %#x effective: %#x\n", event->mods.locked, event->mods.latched, event->mods.base, event->mods.effective); printf(" group: locked %#x latched %#x base %#x effective: %#x\n", event->group.locked, event->group.latched, event->group.base, event->group.effective); printf(" root x/y: %.2f / %.2f\n", event->root_x, event->root_y); printf(" event x/y: %.2f / %.2f\n", event->event_x, event->event_y); }
static void pump_events(void) { ManyMouseEvent event; const int opcode = xi2_opcode; const XIRawEvent *rawev = NULL; const XIHierarchyEvent *hierev = NULL; int mouse = 0; XEvent xev; int i = 0; while (get_next_x11_event(&xev)) { /* All XI2 events are "cookie" events...which need extra tapdance. */ if (xev.xcookie.type != GenericEvent) continue; else if (xev.xcookie.extension != opcode) continue; else if (!pXGetEventData(display, &xev.xcookie)) continue; switch (xev.xcookie.evtype) { case XI_RawMotion: rawev = (const XIRawEvent *) xev.xcookie.data; mouse = find_mouse_by_devid(rawev->deviceid); if (mouse != -1) { const double *values = rawev->raw_values; int top = rawev->valuators.mask_len * 8; if (top > MAX_AXIS) top = MAX_AXIS; for (i = 0; i < top; i++) { if (XIMaskIsSet(rawev->valuators.mask, i)) { const int value = (int) *values; if (mice[mouse].relative[i]) event.type = MANYMOUSE_EVENT_RELMOTION; else event.type = MANYMOUSE_EVENT_ABSMOTION; event.device = mouse; event.item = i; event.value = value; event.minval = mice[mouse].minval[i]; event.maxval = mice[mouse].maxval[i]; if ((!mice[mouse].relative[i]) || (value)) queue_event(&event); values++; } /* if */ } /* for */ } /* if */ break; case XI_RawButtonPress: case XI_RawButtonRelease: rawev = (const XIRawEvent *) xev.xcookie.data; mouse = find_mouse_by_devid(rawev->deviceid); if (mouse != -1) { const int button = rawev->detail; const int pressed = (xev.xcookie.evtype==XI_RawButtonPress); /* gah, XInput2 still maps the wheel to buttons. */ if ((button >= 4) && (button <= 7)) { if (pressed) /* ignore "up" for these "buttons" */ { event.type = MANYMOUSE_EVENT_SCROLL; event.device = mouse; if ((button == 4) || (button == 5)) event.item = 0; else event.item = 1; if ((button == 4) || (button == 6)) event.value = 1; else event.value = -1; queue_event(&event); } /* if */ } /* if */ else { event.type = MANYMOUSE_EVENT_BUTTON; event.device = mouse; event.item = button-1; event.value = pressed; queue_event(&event); } /* else */ } /* if */ break; case XI_HierarchyChanged: hierev = (const XIHierarchyEvent *) xev.xcookie.data; for (i = 0; i < hierev->num_info; i++) { if (hierev->info[i].flags & XISlaveRemoved) { mouse = find_mouse_by_devid(hierev->info[i].deviceid); if (mouse != -1) { mice[mouse].connected = 0; event.type = MANYMOUSE_EVENT_DISCONNECT; event.device = mouse; queue_event(&event); } /* if */ } /* if */ } /* for */ break; } /* switch */ pXFreeEventData(display, &xev.xcookie); } /* while */ } /* pump_events */
static void test_values_XIRawEvent(RawDeviceEvent *in, xXIRawEvent *out, BOOL swap) { int i; unsigned char *ptr; FP3232 *value, *raw_value; int nvals = 0; int bits_set; int len; if (swap) { char n; swaps(&out->sequenceNumber, n); swapl(&out->length, n); swaps(&out->evtype, n); swaps(&out->deviceid, n); swapl(&out->time, n); swapl(&out->detail, n); swaps(&out->valuators_len, n); } assert(out->type == GenericEvent); assert(out->extension == 0); /* IReqCode defaults to 0 */ assert(out->evtype == GetXI2Type((InternalEvent*)in)); assert(out->time == in->time); assert(out->detail == in->detail.button); assert(out->deviceid == in->deviceid); assert(out->valuators_len >= bytes_to_int32(bits_to_bytes(sizeof(in->valuators.mask)))); assert(out->flags == 0); /* FIXME: we don't set the flags yet */ ptr = (unsigned char*)&out[1]; bits_set = 0; for (i = 0; out->valuators_len && i < sizeof(in->valuators.mask) * 8; i++) { if (i >= MAX_VALUATORS) assert (!XIMaskIsSet(in->valuators.mask, i)); assert (XIMaskIsSet(in->valuators.mask, i) == XIMaskIsSet(ptr, i)); if (XIMaskIsSet(in->valuators.mask, i)) bits_set++; } /* length is len of valuator mask (in 4-byte units) + the number of bits * set. Each bit set represents 2 8-byte values, hence the * 'bits_set * 4' */ len = out->valuators_len + bits_set * 4; assert(out->length == len); nvals = 0; for (i = 0; out->valuators_len && i < MAX_VALUATORS; i++) { assert (XIMaskIsSet(in->valuators.mask, i) == XIMaskIsSet(ptr, i)); if (XIMaskIsSet(in->valuators.mask, i)) { FP3232 vi, vo; value = (FP3232*)(((unsigned char*)&out[1]) + out->valuators_len * 4); value += nvals; vi.integral = in->valuators.data[i]; vi.frac = in->valuators.data_frac[i]; vo.integral = value->integral; vo.frac = value->frac; if (swap) { char n; swapl(&vo.integral, n); swapl(&vo.frac, n); } assert(vi.integral == vo.integral); assert(vi.frac == vo.frac); raw_value = value + bits_set; vi.integral = in->valuators.data_raw[i]; vi.frac = in->valuators.data_raw_frac[i]; vo.integral = raw_value->integral; vo.frac = raw_value->frac; if (swap) { char n; swapl(&vo.integral, n); swapl(&vo.frac, n); } assert(vi.integral == vo.integral); assert(vi.frac == vo.frac); nvals++; } } }