x11_xinput.c

/*
 * Support for the X11 XInput extension.
 *
 * Please see the file LICENSE in the source's root directory.
 *
 *  This file written by Ryan C. Gordon.
 */

#include "manymouse.h"

/* Try to use this on everything but Windows and Mac OS by default... */
#ifndef SUPPORT_XINPUT
#if ( (defined(_WIN32) || defined(__CYGWIN__)) )
#define SUPPORT_XINPUT 0
#elif ( (defined(__MACH__)) && (defined(__APPLE__)) )
#define SUPPORT_XINPUT 0
#else
#define SUPPORT_XINPUT 1
#endif
#endif

#if SUPPORT_XINPUT

//#error this code is incomplete. Do not use unless you are fixing it.

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <dlfcn.h>
#include <X11/extensions/XInput.h>

/* 32 is good enough for now. */
#define MAX_MICE 32
typedef struct
{
    XDevice *device;
    int min_x;
    int min_y;
    int max_x;
    int max_y;
    char name[64];
} MouseStruct;

static MouseStruct mice[MAX_MICE];
static unsigned int available_mice = 0;

static Display *display = NULL;
static XExtensionVersion *extver = NULL;
static XDeviceInfo *device_list = NULL;
static int device_count = 0;

/*
 * You _probably_ have Xlib on your system if you're on a Unix box where you
 *  are planning to plug in multiple mice. That being said, we don't want
 *  to force a project to add Xlib to their builds, or force the end-user to
 *  have Xlib installed if they are otherwise running a console app that the
 *  evdev driver would handle.
 *
 * We load all Xlib symbols at runtime, and fail gracefully if they aren't
 *  available for some reason...ManyMouse might be able to use the evdev
 *  driver or at least return a zero.
 *
 * On Linux (and probably others), you'll need to add -ldl to your link line,
 *  but it's part of glibc, so this is pretty much going to be there.
 */

static void *libx11 = NULL;
static void *libxext = NULL;
static void *libxi = NULL;
typedef int (*XExtErrHandler)(Display *, _Xconst char *, _Xconst char *);
static XExtErrHandler (*pXSetExtensionErrorHandler)(XExtErrHandler h) = 0;
static Display* (*pXOpenDisplay)(_Xconst char*) = 0;
static int (*pXCloseDisplay)(Display*) = 0;
static int (*pXFree)(void*) = 0;
static XExtensionVersion* (*pXGetExtensionVersion)(Display*,_Xconst char*) = 0;
static XDeviceInfo* (*pXListInputDevices)(Display*,int*) = 0;
static void	(*pXFreeDeviceList)(XDeviceInfo*) = 0;
static XDevice* (*pXOpenDevice)(Display*,XID) = 0;
static int (*pXCloseDevice)(Display*,XDevice*) = 0;

static int symlookup(void *dll, void **addr, const char *sym)
{
    *addr = dlsym(dll, sym);
    if (*addr == NULL)
        return(0);

    return(1);
} /* symlookup */

static int find_api_symbols(void)
{
    void *dll = NULL;

    #define LOOKUP(x) { if (!symlookup(dll, (void **) &p##x, #x)) return(0); }
    dll = libx11 = dlopen("libX11.so.6", RTLD_GLOBAL | RTLD_LAZY);
    if (dll == NULL)
        return(0);

    LOOKUP(XOpenDisplay);
    LOOKUP(XCloseDisplay);
    LOOKUP(XFree);

    dll = libxext = dlopen("libXext.so.6", RTLD_GLOBAL | RTLD_LAZY);
    if (dll == NULL)
        return(0);

    LOOKUP(XSetExtensionErrorHandler);

    dll = libxi = dlopen("libXi.so.6", RTLD_GLOBAL | RTLD_LAZY);
    if (dll == NULL)
        return(0);

    LOOKUP(XGetExtensionVersion);
    LOOKUP(XListInputDevices);
    LOOKUP(XFreeDeviceList);
    LOOKUP(XOpenDevice);
    LOOKUP(XCloseDevice);

    #undef LOOKUP

    return(1);
} /* find_api_symbols */


static void xinput_cleanup(void)
{
    int i;

    if (display != NULL)
    {
        for (i = 0; i < available_mice; i++)
        {
            if (mice[i].device)
                pXCloseDevice(display, mice[i].device);
        } /* for */
    } /* if */

    if (extver != NULL)
    {
        pXFree(extver);
        extver = NULL;
    } /* if */

    if (device_list != NULL)
    {
        pXFreeDeviceList(device_list);
        device_list = NULL;
    } /* if */

    if (display != NULL)
    {
        pXCloseDisplay(display);
        display = NULL;
    } /* if */

    memset(mice, '\0', sizeof (mice));
    available_mice = 0;

    #define LIBCLOSE(lib) { if (lib != NULL) { dlclose(lib); lib = NULL; } }
    LIBCLOSE(libxi);
    LIBCLOSE(libxext);
    LIBCLOSE(libx11);
    #undef LIBCLOSE
} /* xinput_cleanup */


/* Just in case this is compiled as a C++ module... */
static XID get_x11_any_class(const XAnyClassPtr anyclass)
{
#if defined(__cplusplus) || defined(c_plusplus)
    return anyclass->c_class;
#else
    return anyclass->class;
#endif
} /* get_x11_any_class */


static int init_mouse(MouseStruct *mouse, const XDeviceInfo *devinfo)
{
    int i;
    int has_axes = 0;
    int has_buttons = 0;
    XAnyClassPtr any = devinfo->inputclassinfo;

    if (devinfo->use == IsXPointer)
        return(0);  /* sucks! Can't open a mouse that is the system pointer! */

    if (devinfo->use == IsXKeyboard)
        return(0);  /* definitely not a mouse. :) */

    for (i = 0; i < devinfo->num_classes; i++)
    {
        XID cls = get_x11_any_class(any);

        if (cls == KeyClass)
            return(0);  /* a keyboard? */

        else if (cls == ButtonClass)
        {
            const XButtonInfo *info = (const XButtonInfo *) any;
            if (info->num_buttons > 0)
                has_buttons = 1;
        } /* else if */

        else if (cls == ValuatorClass)
        {
            const XValuatorInfo *info = (const XValuatorInfo *) any;
            if (info->num_axes != 2)  /* joystick? */  /* !!! FIXME: this isn't right! */
                return 0;

            has_axes = 1;
            mouse->min_x = info->axes[0].min_value;
            mouse->max_x = info->axes[0].max_value;
            mouse->min_y = info->axes[1].min_value;
            mouse->max_y = info->axes[1].max_value;
        } /* else if */

        any = (XAnyClassPtr) ((char *) any + any->length);
    } /* for */

    if ((!has_axes) || (!has_buttons))
        return(0);  /* probably not a mouse. */

    mouse->device = pXOpenDevice(display, devinfo->id);
    if (mouse->device == NULL)
        return(0);

    strncpy(mouse->name, devinfo->name, sizeof (mouse->name));
    mouse->name[sizeof (mouse->name) - 1] = '\0';
    return(1);
} /* init_mouse */


static int (*Xext_handler)(Display *, _Xconst char *, _Xconst char *) = NULL;
static int xext_errhandler(Display *d, _Xconst char *ext, _Xconst char *reason)
{
    /* Don't do anything (write an error to stderr) if extension is missing */
	if (strcmp(reason, "missing") == 0)
		return 0;

	return Xext_handler(d, ext, reason);
}


static int x11_xinput_init_internal(void)
{
    int i;

    xinput_cleanup();  /* just in case... */

    if (getenv("MANYMOUSE_NO_XINPUT") != NULL)
        return(-1);

    if (!find_api_symbols())
        return(-1);  /* couldn't find all needed symbols. */

    display = pXOpenDisplay(NULL);
    if (display == NULL)
        return(-1);  /* no X server at all */

    /* Stop stderr output in case XInput extension is missing... */
    Xext_handler = pXSetExtensionErrorHandler(xext_errhandler);
    extver = pXGetExtensionVersion(display, INAME);
    pXSetExtensionErrorHandler(Xext_handler);
    Xext_handler = NULL;

    if ((extver == NULL) || (extver == (XExtensionVersion *) NoSuchExtension))
        return(-1);  /* no such extension */

    if (extver->present == XI_Absent)
        return(-1);  /* extension not available. */

    device_list = pXListInputDevices(display, &device_count);
    if (device_list == NULL)
        return(-1);

    for (i = 0; i < device_count; i++)
    {
        MouseStruct *mouse = &mice[available_mice];
        if (init_mouse(mouse, &device_list[i]))
            available_mice++;
    } /* for */

    return(available_mice);
} /* x11_xinput_init_internal */


static int x11_xinput_init(void)
{
    int retval = x11_xinput_init_internal();
    if (retval < 0)
        xinput_cleanup();
    return(retval);
} /* x11_xinput_init */


static void x11_xinput_quit(void)
{
    xinput_cleanup();
} /* x11_xinput_quit */


static const char *x11_xinput_name(unsigned int index)
{
    if (index < available_mice)
        return(mice[index].name);
    return(NULL);
} /* x11_xinput_name */


static int x11_xinput_poll(ManyMouseEvent *event)
{
    return(0);  /* !!! FIXME */
} /* x11_xinput_poll */

static const ManyMouseDriver ManyMouseDriver_interface =
{
    x11_xinput_init,
    x11_xinput_quit,
    x11_xinput_name,
    x11_xinput_poll
};

const ManyMouseDriver *ManyMouseDriver_xinput = &ManyMouseDriver_interface;

#else
const ManyMouseDriver *ManyMouseDriver_xinput = 0;
#endif /* SUPPORT_XINPUT blocker */

/* end of x11_xinput.c ... */