PointingDeviceManager.h

/* -*- mode: c++ -*-
 *
 * pointing/input/PointingDeviceManager.h --
 *
 * Initial software
 * Authors: Izzat Mukhanov
 * Copyright © Inria
 *
 * http://libpointing.org/
 *
 * This software may be used and distributed according to the terms of
 * the GNU General Public License version 2 or any later version.
 *
 */

#include <set>
#include <string>
#include <list>
#include <map>
#include <pointing/utils/URI.h>
#include <pointing/input/SystemPointingDevice.h>

#ifdef __APPLE__
#include <IOKit/hid/IOHIDManager.h>
#define identifier IOHIDDeviceRef
#endif

#ifdef __linux__
#define identifier std::string
#endif

#ifdef _WIN32
#include <windows.h>
#define identifier HANDLE
#endif

#ifndef POINTINGDEVICEMANAGER_H
#define POINTINGDEVICEMANAGER_H

namespace pointing
{
    struct PointingDeviceDescriptor
    {
        URI devURI;

        int vendorID = 0;
        int productID = 0;

        std::string vendor = "???";
        std::string product = "???";

        // To use set of PointingDeviceDescriptors
        bool operator < (const PointingDeviceDescriptor& rhs) const;
    };

    typedef void (*DeviceUpdateCallback)(void *context, const PointingDeviceDescriptor &descriptor, bool wasAdded);
    typedef std::set<PointingDeviceDescriptor> PointingDescriptorSet;

    typedef PointingDescriptorSet::iterator PointingDescriptorIterator;
    typedef PointingDescriptorSet::const_iterator PointingDescriptorConstIterator;

    struct CallbackInfo
    {
        DeviceUpdateCallback callbackFunc;
        void *context;
        CallbackInfo(DeviceUpdateCallback callbackFunc, void *context)
            :callbackFunc(callbackFunc),context(context) { }

        // To use the set of the CallbackInfos
        bool operator < (const CallbackInfo& rhs) const;
    };

    class PointingDeviceManager
    {
      friend class SystemPointingDevice;

    protected:

        typedef std::list<SystemPointingDevice *> PointingList;

        // This struct can be extended in subclasses to add
        // platform-specific data
        struct PointingDeviceData
        {
          PointingDeviceDescriptor desc;
          PointingList pointingList;
        };

        std::map<identifier, PointingDeviceData *> devMap;

        DeviceUpdateCallback callback = NULL;

        virtual ~PointingDeviceManager(void) {}
        static PointingDeviceManager *singleManager;

        PointingDescriptorSet descriptors;

        std::set<CallbackInfo> callbackInfos;

        void callCallbackFunctions(PointingDeviceDescriptor &descriptor, bool wasAdded);

        void addDescriptor(PointingDeviceDescriptor &descriptor);
        void removeDescriptor(PointingDeviceDescriptor &descriptor);

        PointingList candidates;
        int debugLevel = 0;

        void convertAnyCandidates();

        void matchCandidates();

        // Should be implemented by a subclass
        virtual void processMatching(PointingDeviceData *pdd, SystemPointingDevice *device)=0;

        void activateDevice(SystemPointingDevice *device, PointingDeviceData *pdd);

        void registerDevice(identifier key, PointingDeviceData *pdd);
        bool unregisterDevice(identifier);

        void printDeviceInfo(PointingDeviceData *pdd, bool add);

        PointingDeviceData *findDataForDevice(SystemPointingDevice *device);

        virtual void addPointingDevice(SystemPointingDevice *device);
        virtual void removePointingDevice(SystemPointingDevice *device);

    public:

        void addDeviceUpdateCallback(DeviceUpdateCallback callback, void *context);

        void removeDeviceUpdateCallback(DeviceUpdateCallback callback, void *context);

        static PointingDeviceManager *get();

        URI anyToSpecific(const URI &anyURI) const;

        URI generalizeAny(const URI &anyURI) const;

        //static void destroy();

        size_t size() const { return descriptors.size(); }

        /*
         * Delegate the iteration to the inner set of the descriptors
         */
        PointingDescriptorIterator begin() { return descriptors.begin(); }
        PointingDescriptorIterator end() { return descriptors.end(); }
    };
}

#endif // POINTINGDEVICEMANAGER_H