GestureData.h

#ifndef NUITRACK_GESTUREDATA_H_
#define NUITRACK_GESTUREDATA_H_

#include "nuitrack/types/ObjectData.h"
#include "nuitrack/types/Gesture.h"
#include "nuitrack/capi/GestureRecognizer_CAPI.h"

namespace tdv
{
namespace nuitrack
{
class GestureData:public ObjectData<GestureData>
{
public:
    GestureData(GestureRecognizerData* pimpl)
    {
        _pimpl = pimpl;
    }

    virtual ~GestureData()
    {
        nuitrack_DestroyGestureRecognizerData(_pimpl);
    }

    uint64_t getTimestamp() const
    {
        return nuitrack_GetUserGesturesTimestamp(_pimpl);
    }

    int getNumGestures() const
    {
        return nuitrack_GetUserGesturesNumGestures(_pimpl);
    }

    const std::vector<Gesture> getGestures() const
    {
        std::vector<Gesture> gesturesVector;

        GestureRecognizerData* dataHolder  = _pimpl;


        size_t numUsers = nuitrack_GetUserGesturesNumGestures(dataHolder);

        for(size_t i = 0; i < numUsers; i++)
        {
            Gesture g;
            nuitrack_GetUserGesture(dataHolder, i, &g);
            gesturesVector.push_back(g);
        }

        return gesturesVector;
    }

private:
    GestureRecognizerData* _pimpl;
};


class UserStateData :public ObjectData<UserStateData>
{
public:
    UserStateData(UsersStateChanges* pimpl)
    {
        _pimpl = pimpl;
    }

    virtual ~UserStateData()
    {
        nuitrack_DestroyUsersStateChanges(_pimpl);
    }

    int getNumUserStates() const
    {
        return nuitrack_GetNumUsersStateChanges(_pimpl);
    }

    uint64_t getTimestamp() const
    {
        return nuitrack_GetUsersStateChangesTimestamp(_pimpl);
    }

    const std::vector<UserState> getUserStates() const
    {
        std::vector<UserState> usersVector;

        UsersStateChanges* dataHolder = _pimpl;

        size_t numUsers = nuitrack_GetNumUsersStateChanges(dataHolder);

        for(size_t i = 0; i < numUsers; i++)
        {
            UserState g;
            nuitrack_GetUserStateChange(dataHolder, i, &g);
            usersVector.push_back(g);
        }

        return usersVector;
    }

private:
    UsersStateChanges* _pimpl;
};


class UserGesturesStateData:public ObjectData<UserGesturesStateData>
{
public:
    UserGesturesStateData(GestureRecognizerUserGesturesStateData* pimpl)
    {
        _pimpl = pimpl;
    }

    virtual ~UserGesturesStateData()
    {
        nuitrack_DestroyUsersStateData(_pimpl);
    }

    int getNumUsers() const
    {
        return nuitrack_GetNumUsersGestures(_pimpl);
    }

    uint64_t getTimestamp() const
    {
        return nuitrack_GetUsersGesturesStateTimestamp(_pimpl);
    }

    const std::vector<UserGesturesState> getUserGesturesStates() const
    {
        std::vector<UserGesturesState> usersVector;

        GestureRecognizerUserGesturesStateData* dataHolder = _pimpl;


        int numUsers = nuitrack_GetNumUsersGestures(dataHolder);

        for(int i = 0; i < numUsers; i++)
        {
            UserGesturesState ugs;
            UserGesturesState ugsTemp;

            nuitrack_GetUserStateData(dataHolder, i, &ugsTemp);
            ugs.userId = ugsTemp.userId;
            ugs.state = ugsTemp.state;

            int numGestures = nuitrack_GetNumUserGestureState(dataHolder, i);
            for(int j = 0; j < numGestures; j++)
            {
                GestureState gs;
                nuitrack_GetUserGestureState(dataHolder, i, j, &gs);
                ugs.gestures.push_back(gs);
            }

            usersVector.push_back(ugs);
        }

        return usersVector;
    }

private:
    GestureRecognizerUserGesturesStateData* _pimpl;
};

} // namespace nuitrack
} // namespace tdv

#endif /* NUITRACK_GESTUREDATA_H_ */