Get mouse button state nonblocking linux - c

Question

I'm trying to write a plugin for a game and I need to read the state of the mouse button and not block or "eat" the events. Directly reading /dev/input is not an options because of root access.
The closer I came to what I need is the following code:
#include <stdio.h>
#include <string.h>
#include <X11/Xlib.h>
int main (int argc, char **argv)
{
Display *display;
XEvent ev;
display = XOpenDisplay(NULL);
Window window = RootWindow(display, XDefaultScreen(display));
XSelectInput(display, window, ButtonPressMask | ButtonReleaseMask);
XGrabButton(display, Button1, AnyModifier, window, False, ButtonPressMask | ButtonReleaseMask, GrabModeSync, GrabModeAsync, None, None);
while(1) {
XAllowEvents(display, ReplayPointer, CurrentTime);
if(XCheckTypedEvent(display, ButtonPress ,&ev))
{
printf("Button pressed\n");
}
else if(XCheckTypedEvent(display, ButtonRelease ,&ev))
{
printf("Button relised\n");
}
}
return 0;
}
The problem is that by setting GrabModeSync and using XAllowEvents with ReplayPointer I am able to pass the event but I get the ButtonPress only. ButtonRelease is never captured but I need it. GrabModeAsync captures both events but "eats" the clicks.
Can anyone suggest a solution?
10x

Answer 1

For anyone who may stumble to this post while looking for solution on similar problem here is what worked for me.
#include <stdio.h>
#include <string.h>
#include <X11/Xlib.h>
#include <X11/extensions/XInput2.h>
static void select_events(Display *dpy, Window win)
{
XIEventMask evmasks[1];
unsigned char mask1[(XI_LASTEVENT + 7)/8];
memset(mask1, 0, sizeof(mask1));
/* select for button and key events from all master devices */
XISetMask(mask1, XI_RawButtonPress);
XISetMask(mask1, XI_RawButtonRelease);
evmasks[0].deviceid = XIAllMasterDevices;
evmasks[0].mask_len = sizeof(mask1);
evmasks[0].mask = mask1;
XISelectEvents(dpy, win, evmasks, 1);
XFlush(dpy);
}
int main(){
Display *dpy;
XEvent ev;
XIEvent *xi_event;
XIRawEvent *xev;
XGenericEventCookie *cookie = &ev.xcookie;
dpy = XOpenDisplay(NULL);
select_events(dpy, DefaultRootWindow(dpy));
int count = 0;
while(1){
if (XCheckTypedEvent(dpy, GenericEvent ,&ev)){
if (cookie->type != GenericEvent ||
!XGetEventData(dpy, cookie)){
continue;
}
xi_event = (XIEvent *) cookie->data;
xev = (XIRawEvent *) xi_event;
switch (cookie->evtype) {
case XI_RawButtonPress:
printf("Button pressed %d %d\n", xev->detail, ++count);
break;
case XI_RawButtonRelease:
printf("Button released %d %d\n", xev->detail, count);
break;
}
XFreeEventData(dpy, cookie);
}
}
return 1;
}

Answer 2

Thanks for your solution but it heavily loads my processor. So I found how its done in xinput test command:
https://github.com/freedesktop/xorg-xinput/blob/master/src/test.c
#include "xinput.h"
#include <string.h>
#define INVALID_EVENT_TYPE -1
static int motion_type = INVALID_EVENT_TYPE;
static int button_press_type = INVALID_EVENT_TYPE;
static int button_release_type = INVALID_EVENT_TYPE;
static int key_press_type = INVALID_EVENT_TYPE;
static int key_release_type = INVALID_EVENT_TYPE;
static int proximity_in_type = INVALID_EVENT_TYPE;
static int proximity_out_type = INVALID_EVENT_TYPE;
static int
register_events(Display *dpy,
XDeviceInfo *info,
char *dev_name,
Bool handle_proximity)
{
int number = 0; /* number of events registered */
XEventClass event_list[7];
int i;
XDevice *device;
Window root_win;
unsigned long screen;
XInputClassInfo *ip;
screen = DefaultScreen(dpy);
root_win = RootWindow(dpy, screen);
device = XOpenDevice(dpy, info->id);
if (!device) {
fprintf(stderr, "unable to open device '%s'\n", dev_name);
return 0;
}
if (device->num_classes > 0) {
for (ip = device->classes, i=0; i<info->num_classes; ip++, i++) {
switch (ip->input_class) {
case KeyClass:
DeviceKeyPress(device, key_press_type, event_list[number]); number++;
DeviceKeyRelease(device, key_release_type, event_list[number]); number++;
break;
case ButtonClass:
DeviceButtonPress(device, button_press_type, event_list[number]); number++;
DeviceButtonRelease(device, button_release_type, event_list[number]); number++;
break;
case ValuatorClass:
DeviceMotionNotify(device, motion_type, event_list[number]); number++;
if (handle_proximity) {
ProximityIn(device, proximity_in_type, event_list[number]); number++;
ProximityOut(device, proximity_out_type, event_list[number]); number++;
}
break;
default:
fprintf(stderr, "unknown class\n");
break;
}
}
if (XSelectExtensionEvent(dpy, root_win, event_list, number)) {
fprintf(stderr, "error selecting extended events\n");
return 0;
}
}
return number;
}
static void
print_events(Display *dpy)
{
XEvent Event;
setvbuf(stdout, NULL, _IOLBF, 0);
while(1) {
XNextEvent(dpy, &Event);
if (Event.type == motion_type) {
int loop;
XDeviceMotionEvent *motion = (XDeviceMotionEvent *) &Event;
printf("motion ");
for(loop=0; loop<motion->axes_count; loop++) {
printf("a[%d]=%d ", motion->first_axis + loop, motion->axis_data[loop]);
}
printf("\n");
} else if ((Event.type == button_press_type) ||
(Event.type == button_release_type)) {
int loop;
XDeviceButtonEvent *button = (XDeviceButtonEvent *) &Event;
printf("button %s %d ", (Event.type == button_release_type) ? "release" : "press ",
button->button);
for(loop=0; loop<button->axes_count; loop++) {
printf("a[%d]=%d ", button->first_axis + loop, button->axis_data[loop]);
}
printf("\n");
} else if ((Event.type == key_press_type) ||
(Event.type == key_release_type)) {
int loop;
XDeviceKeyEvent *key = (XDeviceKeyEvent *) &Event;
printf("key %s %d ", (Event.type == key_release_type) ? "release" : "press ",
key->keycode);
for(loop=0; loop<key->axes_count; loop++) {
printf("a[%d]=%d ", key->first_axis + loop, key->axis_data[loop]);
}
printf("\n");
} else if ((Event.type == proximity_out_type) ||
(Event.type == proximity_in_type)) {
int loop;
XProximityNotifyEvent *prox = (XProximityNotifyEvent *) &Event;
printf("proximity %s ", (Event.type == proximity_in_type) ? "in " : "out");
for(loop=0; loop<prox->axes_count; loop++) {
printf("a[%d]=%d ", prox->first_axis + loop, prox->axis_data[loop]);
}
printf("\n");
}
else {
printf("what's that %d\n", Event.type);
}
}
}
int
test(Display *display,
int argc,
char *argv[],
char *name,
char *desc)
{
XDeviceInfo *info;
if (argc != 1 && argc != 2) {
fprintf(stderr, "usage: xinput %s %s\n", name, desc);
return EXIT_FAILURE;
} else {
Bool handle_proximity = False;
int idx = 0;
if (argc == 2) {
if (strcmp("-proximity", argv[0]) != 0) {
fprintf(stderr, "usage: xinput %s %s\n", name, desc);
return EXIT_FAILURE;
}
handle_proximity = 1;
idx = 1;
}
info = find_device_info(display, argv[idx], True);
if (!info) {
fprintf(stderr, "unable to find device '%s'\n", argv[idx]);
return EXIT_FAILURE;
} else {
if (register_events(display, info, argv[idx], handle_proximity)) {
print_events(display);
}
else {
fprintf(stderr, "no event registered...\n");
return EXIT_FAILURE;
}
}
}
return EXIT_FAILURE;
}