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++;
}
}
}
