Leap.h

Go to the documentation of this file.

/******************************************************************************\
* Copyright (C) 2012-2015 Leap Motion, Inc. All rights reserved.               *
* Leap Motion proprietary and confidential. Not for distribution.              *
* Use subject to the terms of the Leap Motion SDK Agreement available at       *
* https://developer.leapmotion.com/sdk_agreement, or another agreement         *
* between Leap Motion and you, your company or other organization.             *
\******************************************************************************/

#if !defined(__Leap_h__)
#define __Leap_h__

#include "LeapMath.h"
#include <string>
#include <vector>
#include <cstring>

// Define integer types for Visual Studio 2008 and earlier
#if defined(_MSC_VER) && (_MSC_VER < 1600)
typedef __int32 int32_t;
typedef __int64 int64_t;
typedef unsigned __int32 uint32_t;
typedef unsigned __int64 uint64_t;
#else
#include <stdint.h>
#endif

// Define Leap export macros
#if defined(_MSC_VER) // Visual C++
#if LEAP_API_INTERNAL
#define LEAP_EXPORT
#elif LEAP_API_IMPLEMENTATION
#define LEAP_EXPORT __declspec(dllexport)
#else
#define LEAP_EXPORT __declspec(dllimport)
#endif
#define LEAP_EXPORT_CLASS
#define LEAP_EXPORT_PLUGIN __declspec(dllexport)
#elif !defined(SWIG)
#define LEAP_EXPORT __attribute__((visibility("default")))
#define LEAP_EXPORT_CLASS __attribute__((visibility("default")))
#define LEAP_EXPORT_PLUGIN __attribute__((visibility("default")))
#else
#define LEAP_EXPORT
#define LEAP_EXPORT_CLASS
#define LEAP_EXPORT_PLUGIN
#endif

namespace Leap {

  // Interface for internal use only
  class LEAP_EXPORT_CLASS Interface {
  public:
    struct Implementation {
      LEAP_EXPORT virtual ~Implementation() {}
    };
  protected:
    LEAP_EXPORT Interface(void* owner);
    LEAP_EXPORT Interface(Implementation* reference, void* owner);
    LEAP_EXPORT Interface(const Interface& rhs);
    Interface(class SharedObject* object);
    LEAP_EXPORT Interface& operator=(const Interface& rhs);
    LEAP_EXPORT virtual ~Interface();
    template<typename T> T* get() const { return static_cast<T*>(reference()); }
    class SharedObject* m_object;
    LEAP_EXPORT static void deleteCString(const char* cstr);
  private:
    LEAP_EXPORT Implementation* reference() const;
  };

  // Forward declarations for internal use only
  class PointableImplementation;
  class BoneImplementation;
  class FingerImplementation;
  class ToolImplementation;
  class HandImplementation;
  class GestureImplementation;
  class ScreenImplementation;
  class DeviceImplementation;
  class ImageImplementation;
  class InteractionBoxImplementation;
  class BugReportImplementation;
  class FrameImplementation;
  class ControllerImplementation;
  class MaskImplementation;
  class TrackedQuadImplementation;
  template<typename T> class ListBaseImplementation;

  // Forward declarations
  class PointableList;
  class FingerList;
  class ToolList;
  class HandList;
  class GestureList;
  class ImageList;
  class MaskList;
  class Hand;
  class Gesture;
  class Screen;
  class InteractionBox;
  class Frame;
  class Listener;

  class Pointable : public Interface {
  public:

    enum Zone {
      ZONE_NONE       = 0,
      ZONE_HOVERING   = 1,
      ZONE_TOUCHING   = 2,
#ifdef SWIGCSHARP
      // deprecated
      ZONENONE        = ZONE_NONE,
      ZONEHOVERING    = ZONE_HOVERING,
      ZONETOUCHING    = ZONE_TOUCHING,
#endif
    };

    // For internal use only.
    Pointable(PointableImplementation*);
    // For internal use only.
    Pointable(FingerImplementation*);
    // For internal use only.
    Pointable(ToolImplementation*);

    LEAP_EXPORT Pointable();

    LEAP_EXPORT int32_t id() const;

    LEAP_EXPORT Frame frame() const;

    LEAP_EXPORT Hand hand() const;

    LEAP_EXPORT Vector tipPosition() const;

    LEAP_EXPORT Vector tipVelocity() const;

    LEAP_EXPORT Vector direction() const;

    LEAP_EXPORT float width() const;

    LEAP_EXPORT float length() const;

    LEAP_EXPORT bool isFinger() const;

    LEAP_EXPORT bool isTool() const;

    LEAP_EXPORT bool isExtended() const;

    LEAP_EXPORT bool isValid() const;

    LEAP_EXPORT Zone touchZone() const;

    LEAP_EXPORT float touchDistance() const;

    LEAP_EXPORT Vector stabilizedTipPosition() const;

    LEAP_EXPORT float timeVisible() const;

    LEAP_EXPORT static const Pointable& invalid();

    LEAP_EXPORT bool operator==(const Pointable&) const;

    LEAP_EXPORT bool operator!=(const Pointable&) const;

    LEAP_EXPORT friend std::ostream& operator<<(std::ostream&, const Pointable&);

    std::string toString() const {
      const char* cstr = toCString();
      std::string str(cstr);
      deleteCString(cstr);
      return str;
    }
  private:
    LEAP_EXPORT const char* toCString() const;

  };

  class Arm : public Interface {
  public:
    // For internal use only.
    Arm(HandImplementation*);

    LEAP_EXPORT Arm();

    LEAP_EXPORT float width() const;

    LEAP_EXPORT Vector direction() const;

    LEAP_EXPORT Matrix basis() const;

    LEAP_EXPORT Vector elbowPosition() const;

    LEAP_EXPORT Vector wristPosition() const;

    LEAP_EXPORT Vector center() const;

    LEAP_EXPORT bool isValid() const;

    LEAP_EXPORT static const Arm& invalid();

    LEAP_EXPORT bool operator==(const Arm&) const;

    LEAP_EXPORT bool operator!=(const Arm&) const;

    LEAP_EXPORT friend std::ostream& operator<<(std::ostream&, const Arm&);

    std::string toString() const {
      const char* cstr = toCString();
      std::string str(cstr);
      deleteCString(cstr);
      return str;
    }
  private:
    LEAP_EXPORT const char* toCString() const;

  };

  class Bone : public Interface {
  public:
    enum Type {
      TYPE_METACARPAL = 0,   
      TYPE_PROXIMAL = 1,     
      TYPE_INTERMEDIATE = 2, 
      TYPE_DISTAL = 3,       
    };

    // For internal use only.
    Bone(BoneImplementation*);

    LEAP_EXPORT Bone();

    LEAP_EXPORT Vector prevJoint() const;

    LEAP_EXPORT Vector nextJoint() const;

    LEAP_EXPORT Vector center() const;

    LEAP_EXPORT Vector direction() const;

    LEAP_EXPORT float length() const;

    LEAP_EXPORT float width() const;

    LEAP_EXPORT Type type() const;

    LEAP_EXPORT Matrix basis() const;

    LEAP_EXPORT bool isValid() const;

    LEAP_EXPORT static const Bone& invalid();

    LEAP_EXPORT bool operator==(const Bone&) const;

    LEAP_EXPORT bool operator!=(const Bone&) const;

    LEAP_EXPORT friend std::ostream& operator<<(std::ostream&, const Bone&);

    std::string toString() const {
      const char* cstr = toCString();
      std::string str(cstr);
      deleteCString(cstr);
      return str;
    }

  private:
    LEAP_EXPORT const char* toCString() const;
  };

  class Finger : public Pointable {
  public:
    enum Joint {
      JOINT_MCP = 0,
      JOINT_PIP = 1,
      JOINT_DIP = 2,
      JOINT_TIP = 3
    };

    enum Type {
      TYPE_THUMB  = 0, 
      TYPE_INDEX  = 1, 
      TYPE_MIDDLE = 2, 
      TYPE_RING   = 3, 
      TYPE_PINKY  = 4  
    };

    // For internal use only.
    Finger(FingerImplementation*);

    LEAP_EXPORT Finger();

    LEAP_EXPORT explicit Finger(const Pointable&);

    LEAP_EXPORT Vector jointPosition(Joint jointIx) const;

    LEAP_EXPORT Bone bone(Bone::Type boneIx) const;

    LEAP_EXPORT Type type() const;

    LEAP_EXPORT static const Finger& invalid();

    std::string toString() const {
      const char* cstr = toCString();
      std::string str(cstr);
      deleteCString(cstr);
      return str;
    }

  private:
    LEAP_EXPORT const char* toCString() const;
  };

  class Tool : public Pointable {
  public:
    // For internal use only.
    Tool(ToolImplementation*);

    LEAP_EXPORT Tool();

    LEAP_EXPORT explicit Tool(const Pointable&);

    LEAP_EXPORT static const Tool& invalid();

    std::string toString() const {
      const char* cstr = toCString();
      std::string str(cstr);
      deleteCString(cstr);
      return str;
    }

  private:
    LEAP_EXPORT const char* toCString() const;
  };

  class Hand : public Interface {
  public:
    // For internal use only.
    Hand(HandImplementation*);

    LEAP_EXPORT Hand();

    LEAP_EXPORT int32_t id() const;

    LEAP_EXPORT Frame frame() const;

    LEAP_EXPORT PointableList pointables() const;

    LEAP_EXPORT Pointable pointable(int32_t id) const;

    LEAP_EXPORT FingerList fingers() const;

    LEAP_EXPORT Finger finger(int32_t id) const;

    /*
     * The list of Tool objects detected in this frame that are held by this
     * hand, given in arbitrary order.
     * The list can be empty if no tools held by this hand are detected.
     *
     * \include Hand_tools.txt
     *
     * @returns The ToolList containing all Tool objects held by this hand.
     * @since 1.0
     */
    LEAP_EXPORT ToolList tools() const;

    /*
     * The Tool object with the specified ID held by this hand.
     *
     * Use the Hand::tool() function to retrieve a Tool object held by
     * this hand using an ID value obtained from a previous frame.
     * This function always returns a Tool object, but if no tool
     * with the specified ID is present, an invalid Tool object is returned.
     *
     * \include Hand_tool.txt
     *
     * Note that ID values persist across frames, but only until tracking of a
     * particular object is lost. If tracking of a tool is lost and subsequently
     * regained, the new Tool object representing that tool may have a
     * different ID than that representing the tool in an earlier frame.
     *
     * @param id The ID value of a Tool object from a previous frame.
     * @returns The Tool object with the matching ID if one exists for this
     * hand in this frame; otherwise, an invalid Tool object is returned.
     * @since 1.0
     */
    LEAP_EXPORT Tool tool(int32_t id) const;

    LEAP_EXPORT Vector palmPosition() const;

    LEAP_EXPORT Vector stabilizedPalmPosition() const;

    LEAP_EXPORT Vector palmVelocity() const;

    LEAP_EXPORT Vector palmNormal() const;

    LEAP_EXPORT float palmWidth() const;

    LEAP_EXPORT Vector direction() const;

    LEAP_EXPORT Matrix basis() const;

    LEAP_EXPORT Arm arm() const;

    LEAP_EXPORT Vector wristPosition() const;

    LEAP_EXPORT Vector sphereCenter() const;

    LEAP_EXPORT float sphereRadius() const;

    LEAP_EXPORT float pinchStrength() const;

    LEAP_EXPORT float grabStrength() const;

    LEAP_EXPORT Vector translation(const Frame& sinceFrame) const;

    LEAP_EXPORT float translationProbability(const Frame& sinceFrame) const;

    LEAP_EXPORT Vector rotationAxis(const Frame& sinceFrame) const;

    LEAP_EXPORT float rotationAngle(const Frame& sinceFrame) const;

    LEAP_EXPORT float rotationAngle(const Frame& sinceFrame, const Vector& axis) const;

    LEAP_EXPORT Matrix rotationMatrix(const Frame& sinceFrame) const;

    LEAP_EXPORT float rotationProbability(const Frame& sinceFrame) const;

    LEAP_EXPORT float scaleFactor(const Frame& sinceFrame) const;

    LEAP_EXPORT float scaleProbability(const Frame& sinceFrame) const;

    LEAP_EXPORT float timeVisible() const;

    LEAP_EXPORT float confidence() const;

    LEAP_EXPORT bool isLeft() const;

    LEAP_EXPORT bool isRight() const;

    LEAP_EXPORT bool isValid() const;

    LEAP_EXPORT static const Hand& invalid();

    LEAP_EXPORT bool operator==(const Hand&) const;

    LEAP_EXPORT bool operator!=(const Hand&) const;

    LEAP_EXPORT friend std::ostream& operator<<(std::ostream&, const Hand&);

    std::string toString() const {
      const char* cstr = toCString();
      std::string str(cstr);
      deleteCString(cstr);
      return str;
    }

  private:
    LEAP_EXPORT const char* toCString() const;
  };

  class Gesture : public Interface {
  public:
    // For internal use only.
    Gesture(GestureImplementation*);

    enum Type {
      TYPE_INVALID    = -1,
      TYPE_SWIPE      = 1,
      TYPE_CIRCLE     = 4,
      TYPE_SCREEN_TAP = 5,
      TYPE_KEY_TAP    = 6,
#ifdef SWIGCSHARP
      // deprecated
      TYPEINVALID     = TYPE_INVALID,
      TYPESWIPE       = TYPE_SWIPE,
      TYPECIRCLE      = TYPE_CIRCLE,
      TYPESCREENTAP   = TYPE_SCREEN_TAP,
      TYPEKEYTAP      = TYPE_KEY_TAP,
#endif
    };

    enum State {
      STATE_INVALID = -1,
      STATE_START   = 1,
      STATE_UPDATE  = 2,
      STATE_STOP    = 3,
#ifdef SWIGCSHARP
      // deprecated
      STATEINVALID  = STATE_INVALID,
      STATESTART    = STATE_START,
      STATEUPDATE   = STATE_UPDATE,
      STATESTOP     = STATE_STOP,
#endif
    };

    LEAP_EXPORT Gesture();

    LEAP_EXPORT Gesture(const Gesture& rhs);

    LEAP_EXPORT Type type() const;

    LEAP_EXPORT State state() const;

    LEAP_EXPORT int32_t id() const;

    LEAP_EXPORT int64_t duration() const;

    LEAP_EXPORT float durationSeconds() const;

    LEAP_EXPORT Frame frame() const;

    LEAP_EXPORT HandList hands() const;

    LEAP_EXPORT PointableList pointables() const;

    LEAP_EXPORT bool isValid() const;

    LEAP_EXPORT bool operator==(const Gesture& rhs) const;

    LEAP_EXPORT bool operator!=(const Gesture& rhs) const;

    std::string toString() const {
      const char* cstr = toCString();
      std::string str(cstr);
      deleteCString(cstr);
      return str;
    }

    LEAP_EXPORT static const Gesture& invalid();

  private:
    LEAP_EXPORT const char* toCString() const;
  };

  class SwipeGesture : public Gesture
  {
  public:
    static Type classType() { return TYPE_SWIPE; }

    LEAP_EXPORT SwipeGesture();

    LEAP_EXPORT SwipeGesture(const Gesture& rhs);

    LEAP_EXPORT Vector startPosition() const;

    LEAP_EXPORT Vector position() const;

    LEAP_EXPORT Vector direction() const;

    LEAP_EXPORT float speed() const;

    LEAP_EXPORT Pointable pointable() const;
  };

  class CircleGesture : public Gesture
  {
  public:
    static Type classType() { return TYPE_CIRCLE; }

    LEAP_EXPORT CircleGesture();

    LEAP_EXPORT CircleGesture(const Gesture& rhs);

    LEAP_EXPORT Vector center() const;

    LEAP_EXPORT Vector normal() const;

    LEAP_EXPORT float progress() const;

    LEAP_EXPORT float radius() const;

    LEAP_EXPORT Pointable pointable() const;
  };

  class ScreenTapGesture : public Gesture
  {
  public:
    static Type classType() { return TYPE_SCREEN_TAP; }

    LEAP_EXPORT ScreenTapGesture();

    LEAP_EXPORT ScreenTapGesture(const Gesture& rhs);

    LEAP_EXPORT Vector position() const;

    LEAP_EXPORT Vector direction() const;

    LEAP_EXPORT float progress() const;

    LEAP_EXPORT Pointable pointable() const;
  };

  class KeyTapGesture : public Gesture
  {
  public:
    static Type classType() { return TYPE_KEY_TAP; }

    LEAP_EXPORT KeyTapGesture();

    LEAP_EXPORT KeyTapGesture(const Gesture& rhs);

    LEAP_EXPORT Vector position() const;

    LEAP_EXPORT Vector direction() const;

    LEAP_EXPORT float progress() const;

    LEAP_EXPORT Pointable pointable() const;
  };

  /*
   * Deprecated as of version 1.2.
   */
  class Screen : public Interface {
  public:
    // For internal use only.
    Screen(ScreenImplementation*);

    LEAP_EXPORT Screen();

    LEAP_EXPORT int32_t id() const;

    LEAP_EXPORT Vector intersect(const Pointable& pointable, bool normalize, float clampRatio = 1.0f) const;

    LEAP_EXPORT Vector intersect(const Vector& position, const Vector& direction, bool normalize, float clampRatio = 1.0f) const;

    LEAP_EXPORT Vector project(const Vector& position, bool normalize, float clampRatio = 1.0f) const;

    LEAP_EXPORT Vector horizontalAxis() const;

    LEAP_EXPORT Vector verticalAxis() const;

    LEAP_EXPORT Vector bottomLeftCorner() const;

    LEAP_EXPORT Vector normal() const;

    LEAP_EXPORT int widthPixels() const;

    LEAP_EXPORT int heightPixels() const;

    LEAP_EXPORT float distanceToPoint(const Vector& point) const;

    LEAP_EXPORT bool isValid() const;

    LEAP_EXPORT static const Screen& invalid();

    LEAP_EXPORT bool operator==(const Screen&) const;

    LEAP_EXPORT bool operator!=(const Screen&) const;

    LEAP_EXPORT friend std::ostream& operator<<(std::ostream&, const Screen&);

    std::string toString() const {
      const char* cstr = toCString();
      std::string str(cstr);
      deleteCString(cstr);
      return str;
    }

  private:
    LEAP_EXPORT const char* toCString() const;
  };

  class Device : public Interface {
  public:

    enum Type
    {
      TYPE_PERIPHERAL = 1,
      TYPE_LAPTOP,
      TYPE_KEYBOARD
    };

    // For internal use only.
    Device(DeviceImplementation*);

    LEAP_EXPORT Device();

    LEAP_EXPORT float horizontalViewAngle() const;

    LEAP_EXPORT float verticalViewAngle() const;

    LEAP_EXPORT float range() const;

    LEAP_EXPORT float baseline() const;

    LEAP_EXPORT float distanceToBoundary(const Vector& position) const;

    LEAP_EXPORT bool isEmbedded() const;

    LEAP_EXPORT bool isStreaming() const;

    // primarily for the image API
    LEAP_EXPORT bool isFlipped() const;

    LEAP_EXPORT Type type() const;

    std::string serialNumber() const {
      const char* cstr = serialNumberCString();
      std::string str(cstr);
      deleteCString(cstr);
      return str;
    }

    /*
     * This API is experimental and not currently intended for external use.
     * Position and orientation can only be manually configured via a config file.
     * This API and the config file may change in the future or be removed entirely.
     *
     * The position of the center of the device in global coordinates (currently defined
     * in the configuration file).
     * @since 2.2.2
     */
    LEAP_EXPORT Vector position() const;

    /*
     * This API is experimental and not currently intended for external use.
     * Position and orientation can only be manually configured via a config file.
     * This API and the config file may change in the future or be removed entirely.
     *
     * The orientation of the device is described by a right-handed basis:
     * xBasis : Unit vector along baseline axis between camera centers
     * yBasis : Unit vector in the direction of the center of view of both cameras
     * zBasis : The completion of the right-handed basis (perpendicular to the
     *          x and y vectors)
     *
     * In the case of a peripheral device, the z-basis vector points
     * out from the green-status-LED side of the device. When multiple-device
     * tracking is enabled, automatic coordinate system orientation is disabled.
     *
     * \image html images/Leap_Axes.png
     *
     * @since 2.2.2
    */
    LEAP_EXPORT Matrix orientation() const;

    LEAP_EXPORT bool isValid() const;

    LEAP_EXPORT static const Device& invalid();

    LEAP_EXPORT bool operator==(const Device&) const;

    LEAP_EXPORT bool operator!=(const Device&) const;

    LEAP_EXPORT friend std::ostream& operator<<(std::ostream&, const Device&);

    std::string toString() const {
      const char* cstr = toCString();
      std::string str(cstr);
      deleteCString(cstr);
      return str;
    }

  private:
    LEAP_EXPORT const char* toCString() const;
    LEAP_EXPORT const char* serialNumberCString() const;
  };

  class Image : public Interface {
  public:

    // For internal use only.
    Image(ImageImplementation*);

    LEAP_EXPORT Image();

    LEAP_EXPORT int64_t sequenceId() const;

    LEAP_EXPORT int32_t id() const;

    LEAP_EXPORT const unsigned char* data() const;

    LEAP_EXPORT const float* distortion() const;

    /*
     * Do not call this version of data(). It is intended only as a helper for C#,
     * Java, and other languages. Use the primary version of data() which returns a
     * pointer.
     *
     * @since 2.1.0
     */
    void data(unsigned char* dst) const {
      const unsigned char* src = data();
      memcpy(dst, src, width() * height() * bytesPerPixel() * sizeof(unsigned char));
    }

    /*
     * Do not call this version of distortion(). It is intended only as a helper for C#,
     * Java, and other languages. Use the primary version of distortion() which returns
     * a pointer.
     *
     * @since 2.1.0
     */
    void distortion(float* dst) const {
      const float* src = distortion();
      memcpy(dst, src, distortionWidth() * distortionHeight() * sizeof(float));
    }

    /* Do not call dataPointer(). It is intended only as a helper for C#.
     *
     * @since 2.2.7
     */
    void* dataPointer() const {
      return (void*) data();
    }

    /* Do not call distortionPointer(). It is intended only as a helper for C#.
     *
     * @since 2.2.7
     */
    void* distortionPointer() const {
      return (void*) distortion();
    }

    LEAP_EXPORT int width() const;

    LEAP_EXPORT int height() const;

    LEAP_EXPORT int bytesPerPixel() const;

    enum FormatType {
      INFRARED = 0
    };

    LEAP_EXPORT FormatType format() const;

    LEAP_EXPORT int distortionWidth() const;

    LEAP_EXPORT int distortionHeight() const;

    LEAP_EXPORT float rayOffsetX() const;

    LEAP_EXPORT float rayOffsetY() const;

    LEAP_EXPORT float rayScaleX() const;

    LEAP_EXPORT float rayScaleY() const;

    LEAP_EXPORT Vector rectify(const Vector& uv) const; // returns a vector (x, y, 0). The z-component is ignored

    LEAP_EXPORT Vector warp(const Vector& xy) const; // returns vector (u, v, 0). The z-component is ignored

    LEAP_EXPORT int64_t timestamp() const;
   
    LEAP_EXPORT bool isValid() const;

    LEAP_EXPORT static const Image& invalid();

    LEAP_EXPORT bool operator==(const Image&) const;

    LEAP_EXPORT bool operator!=(const Image&) const;

    LEAP_EXPORT friend std::ostream& operator<<(std::ostream&, const Image&);

    std::string toString() const {
      const char* cstr = toCString();
      std::string str(cstr);
      deleteCString(cstr);
      return str;
    }

  private:
    LEAP_EXPORT const char* toCString() const;
  };

  class Mask : public Interface {
  public:

    // For internal use only.
    Mask(MaskImplementation*);

    LEAP_EXPORT Mask();

    LEAP_EXPORT int64_t sequenceId() const;

    LEAP_EXPORT int32_t id() const;

    LEAP_EXPORT const unsigned char* data() const;

    void data(unsigned char* dst) const {
      const unsigned char* src = data();
      memcpy(dst, src, width() * height() * sizeof(unsigned char));
    }

    void* dataPointer() const {
      return (void*) data();
    }

    LEAP_EXPORT int width() const;

    LEAP_EXPORT int height() const;

    LEAP_EXPORT int offsetX() const;

    LEAP_EXPORT int offsetY() const;

    LEAP_EXPORT bool isValid() const;

    LEAP_EXPORT static const Mask& invalid();

    LEAP_EXPORT bool operator==(const Mask&) const;

    LEAP_EXPORT bool operator!=(const Mask&) const;

    LEAP_EXPORT friend std::ostream& operator<<(std::ostream&, const Mask&);

    std::string toString() const {
      const char* cstr = toCString();
      std::string str(cstr);
      deleteCString(cstr);
      return str;
    }

  private:
    LEAP_EXPORT const char* toCString() const;
  };

  // For internal use only.
  template<typename L, typename T>
  class ConstListIterator {
  public:
    ConstListIterator<L,T>() : m_list(0), m_index(-1) {}
    ConstListIterator<L,T>(const L& list, int index) : m_list(&list), m_index(index) {}

    const T operator*() const { return (*m_list)[m_index]; }
    const ConstListIterator<L,T> operator++(int) { ConstListIterator<L,T> ip(*this); ++m_index; return ip; }
    const ConstListIterator<L,T>& operator++() { ++m_index; return *this; }
    bool operator!=(const ConstListIterator<L,T>& rhs) const { return m_index != rhs.m_index; }
    bool operator==(const ConstListIterator<L,T>& rhs) const { return m_index == rhs.m_index; }

    typedef std::ptrdiff_t difference_type;
    typedef T value_type;
    typedef const T* pointer;
    typedef const T& reference;
    typedef std::forward_iterator_tag iterator_category;

  private:
    const L* m_list;
    int m_index;
  };

  class PointableList : public Interface {
  public:
    // For internal use only.
    PointableList(const ListBaseImplementation<Pointable>&);

    LEAP_EXPORT PointableList();

    LEAP_EXPORT int count() const;

    LEAP_EXPORT bool isEmpty() const;

    LEAP_EXPORT Pointable operator[](int index) const;

    LEAP_EXPORT PointableList& append(const PointableList& other);

    LEAP_EXPORT PointableList& append(const FingerList& other);

    LEAP_EXPORT PointableList& append(const ToolList& other);

    LEAP_EXPORT Pointable leftmost() const;

    LEAP_EXPORT Pointable rightmost() const;


    LEAP_EXPORT Pointable frontmost() const;

    LEAP_EXPORT PointableList extended() const;

    typedef ConstListIterator<PointableList, Pointable> const_iterator;

    LEAP_EXPORT const_iterator begin() const;

    LEAP_EXPORT const_iterator end() const;
  };

  class FingerList : public Interface {
  public:
    // For internal use only.
    FingerList(const ListBaseImplementation<Finger>&);

    LEAP_EXPORT FingerList();

    LEAP_EXPORT int count() const;

    LEAP_EXPORT bool isEmpty() const;

    LEAP_EXPORT Finger operator[](int index) const;

    LEAP_EXPORT FingerList& append(const FingerList& other);

    LEAP_EXPORT Finger leftmost() const;

    LEAP_EXPORT Finger rightmost() const;

    LEAP_EXPORT Finger frontmost() const;

    LEAP_EXPORT FingerList extended() const;

    LEAP_EXPORT FingerList fingerType(Finger::Type type) const;

    typedef ConstListIterator<FingerList, Finger> const_iterator;

    LEAP_EXPORT const_iterator begin() const;

    LEAP_EXPORT const_iterator end() const;
  };

  class ToolList : public Interface {
  public:
    // For internal use only.
    ToolList(const ListBaseImplementation<Tool>&);

    LEAP_EXPORT ToolList();

    LEAP_EXPORT int count() const;

    LEAP_EXPORT bool isEmpty() const;

    LEAP_EXPORT Tool operator[](int index) const;

    LEAP_EXPORT ToolList& append(const ToolList& other);

    LEAP_EXPORT Tool leftmost() const;

    LEAP_EXPORT Tool rightmost() const;

    LEAP_EXPORT Tool frontmost() const;

    typedef ConstListIterator<ToolList, Tool> const_iterator;

    LEAP_EXPORT const_iterator begin() const;

    LEAP_EXPORT const_iterator end() const;
  };

  class HandList : public Interface {
  public:
    // For internal use only.
    HandList(const ListBaseImplementation<Hand>&);

    LEAP_EXPORT HandList();

    LEAP_EXPORT int count() const;

    LEAP_EXPORT bool isEmpty() const;

    LEAP_EXPORT Hand operator[](int index) const;

    LEAP_EXPORT HandList& append(const HandList& other);

    LEAP_EXPORT Hand leftmost() const;

    LEAP_EXPORT Hand rightmost() const;

    LEAP_EXPORT Hand frontmost() const;

    typedef ConstListIterator<HandList, Hand> const_iterator;

    LEAP_EXPORT const_iterator begin() const;

    LEAP_EXPORT const_iterator end() const;
  };

  class GestureList : public Interface {
  public:
    // For internal use only.
    GestureList(const ListBaseImplementation<Gesture>&);

    LEAP_EXPORT GestureList();

    LEAP_EXPORT int count() const;

    LEAP_EXPORT bool isEmpty() const;

    LEAP_EXPORT Gesture operator[](int index) const;

    LEAP_EXPORT GestureList& append(const GestureList& other);

    typedef ConstListIterator<GestureList, Gesture> const_iterator;

    LEAP_EXPORT const_iterator begin() const;

    LEAP_EXPORT const_iterator end() const;
  };

  /*
   * Deprecated as of version 1.2.
   */
  class ScreenList : public Interface {
  public:
    // For internal use only.
    ScreenList(const ListBaseImplementation<Screen>&);

    LEAP_EXPORT ScreenList();

    LEAP_EXPORT int count() const;

    LEAP_EXPORT bool isEmpty() const;

    LEAP_EXPORT Screen operator[](int index) const;

    typedef ConstListIterator<ScreenList, Screen> const_iterator;

    LEAP_EXPORT const_iterator begin() const;

    LEAP_EXPORT const_iterator end() const;

    LEAP_EXPORT Screen closestScreenHit(const Pointable& pointable) const;

    LEAP_EXPORT Screen closestScreenHit(const Vector& position, const Vector& direction) const;

    LEAP_EXPORT Screen closestScreen(const Vector& position) const;
  };

  class DeviceList : public Interface {
  public:
    // For internal use only.
    DeviceList(const ListBaseImplementation<Device>&);

    LEAP_EXPORT DeviceList();

    LEAP_EXPORT int count() const;

    LEAP_EXPORT bool isEmpty() const;

    LEAP_EXPORT Device operator[](int index) const;

    LEAP_EXPORT DeviceList& append(const DeviceList& other);

    typedef ConstListIterator<DeviceList, Device> const_iterator;

    LEAP_EXPORT const_iterator begin() const;

    LEAP_EXPORT const_iterator end() const;
  };

  class ImageList : public Interface {
  public:
    // For internal use only.
    ImageList(const ListBaseImplementation<Image>&);

    LEAP_EXPORT ImageList();

    LEAP_EXPORT int count() const;

    LEAP_EXPORT bool isEmpty() const;

    LEAP_EXPORT Image operator[](int index) const;

    LEAP_EXPORT ImageList& append(const ImageList& other);

    typedef ConstListIterator<ImageList, Image> const_iterator;

    LEAP_EXPORT const_iterator begin() const;

    LEAP_EXPORT const_iterator end() const;
  };

  class TrackedQuad : public Interface {
  public:

    // For internal use only.
    TrackedQuad(TrackedQuadImplementation*);

    LEAP_EXPORT TrackedQuad();

    LEAP_EXPORT float width() const;

    LEAP_EXPORT float height() const;

    LEAP_EXPORT int resolutionX() const;

    LEAP_EXPORT int resolutionY() const;

    LEAP_EXPORT bool visible() const;

    LEAP_EXPORT Matrix orientation() const;

    LEAP_EXPORT Vector position() const;

    LEAP_EXPORT MaskList masks() const;

    LEAP_EXPORT ImageList images() const;

    LEAP_EXPORT bool isValid() const;

    LEAP_EXPORT static const TrackedQuad& invalid();

    LEAP_EXPORT bool operator==(const TrackedQuad&) const;

    LEAP_EXPORT bool operator!=(const TrackedQuad&) const;

    LEAP_EXPORT friend std::ostream& operator<<(std::ostream&, const TrackedQuad&);

    std::string toString() const {
      const char* cstr = toCString();
      std::string str(cstr);
      deleteCString(cstr);
      return str;
    }

  private:
    LEAP_EXPORT const char* toCString() const;
  };

  class MaskList : public Interface {
  public:
    // For internal use only.
    MaskList(const ListBaseImplementation<Mask>&);

    LEAP_EXPORT MaskList();

    LEAP_EXPORT int count() const;

    LEAP_EXPORT bool isEmpty() const;

    LEAP_EXPORT Mask operator[](int index) const;

    LEAP_EXPORT MaskList& append(const MaskList& other);

    typedef ConstListIterator<MaskList, Mask> const_iterator;

    LEAP_EXPORT const_iterator begin() const;

    LEAP_EXPORT const_iterator end() const;
  };

  class InteractionBox : public Interface {
  public:
    // For internal use only.
    InteractionBox(InteractionBoxImplementation*);

    LEAP_EXPORT InteractionBox();

    LEAP_EXPORT Vector normalizePoint(const Vector& position, bool clamp = true) const;

    LEAP_EXPORT Vector denormalizePoint(const Vector& normalizedPosition) const;

    LEAP_EXPORT Vector center() const;

    LEAP_EXPORT float width() const;

    LEAP_EXPORT float height() const;

    LEAP_EXPORT float depth() const;

    LEAP_EXPORT bool isValid() const;

    LEAP_EXPORT static const InteractionBox& invalid();

    LEAP_EXPORT bool operator==(const InteractionBox&) const;

    LEAP_EXPORT bool operator!=(const InteractionBox&) const;

    LEAP_EXPORT friend std::ostream& operator<<(std::ostream&, const InteractionBox&);

    std::string toString() const {
      const char* cstr = toCString();
      std::string str(cstr);
      deleteCString(cstr);
      return str;
    }

  private:
    LEAP_EXPORT const char* toCString() const;
  };

  class Frame : public Interface {
  public:
    // For internal use only.
    Frame(FrameImplementation*);

    LEAP_EXPORT Frame();

    LEAP_EXPORT int64_t id() const;

    LEAP_EXPORT int64_t timestamp() const;

    LEAP_EXPORT HandList hands() const;

    LEAP_EXPORT Hand hand(int32_t id) const;

    LEAP_EXPORT PointableList pointables() const;

    LEAP_EXPORT Pointable pointable(int32_t id) const;

    LEAP_EXPORT FingerList fingers() const;

    LEAP_EXPORT Finger finger(int32_t id) const;

    LEAP_EXPORT ToolList tools() const;

    LEAP_EXPORT Tool tool(int32_t id) const;

    LEAP_EXPORT Gesture gesture(int32_t id) const;

    LEAP_EXPORT GestureList gestures() const;

    LEAP_EXPORT GestureList gestures(const Frame& sinceFrame) const;

    LEAP_EXPORT ImageList images() const;

    LEAP_EXPORT Vector translation(const Frame& sinceFrame) const;

    LEAP_EXPORT float translationProbability(const Frame& sinceFrame) const;

    LEAP_EXPORT Vector rotationAxis(const Frame& sinceFrame) const;

    LEAP_EXPORT float rotationAngle(const Frame& sinceFrame) const;

    LEAP_EXPORT float rotationAngle(const Frame& sinceFrame, const Vector& axis) const;

    LEAP_EXPORT Matrix rotationMatrix(const Frame& sinceFrame) const;

    LEAP_EXPORT float rotationProbability(const Frame& sinceFrame) const;

    LEAP_EXPORT float scaleFactor(const Frame& sinceFrame) const;

    LEAP_EXPORT float scaleProbability(const Frame& sinceFrame) const;

    LEAP_EXPORT InteractionBox interactionBox() const;

    LEAP_EXPORT float currentFramesPerSecond() const;

    LEAP_EXPORT bool isValid() const;

    LEAP_EXPORT static const Frame& invalid();

    LEAP_EXPORT bool operator==(const Frame&) const;

    LEAP_EXPORT bool operator!=(const Frame&) const;

    LEAP_EXPORT friend std::ostream& operator<<(std::ostream&, const Frame&);

    LEAP_EXPORT TrackedQuad trackedQuad() const;

    std::string serialize() const {
      size_t length = 0;
      const char* cstr = serializeCString(length);
      std::string str(cstr, length);
      deleteCString(cstr);
      return str;
    }

    void deserialize(const std::string& str) {
      deserializeCString(str.data(), str.length());
    }

    /*
     * Do not call this version of serialize(). It is intended only as
     * a helper for C#, Java, and other language bindings.
     */
    void serialize(unsigned char* ptr) const {
      size_t length;
      const unsigned char* cstr = reinterpret_cast<const unsigned char*>(serializeCString(length));
      memcpy(ptr, cstr, length * sizeof(unsigned char));
    }

    /*
     * Do not call serializeLength(). It is intended only as a helper for
     * C#, Java, and other language bindings. To get the length of the
     * serialized byte array, use serialize().length()
     */
    int serializeLength() const {
      size_t length = 0;
      serializeCString(length);
      return static_cast<int>(length);
    }

    /*
     * Do not call this version of deserialize(). It is intended only as
     * a helper for C#, Java, and other language bindings.
     */
    void deserialize(const unsigned char* ptr, int length) {
      deserializeCString(reinterpret_cast<const char*>(ptr), static_cast<size_t>(length));
    }

    std::string toString() const {
      const char* cstr = toCString();
      std::string str(cstr);
      deleteCString(cstr);
      return str;
    }

  private:
    LEAP_EXPORT const char* toCString() const;
    LEAP_EXPORT const char* serializeCString(size_t& length) const;
    LEAP_EXPORT void deserializeCString(const char* str, size_t length);
  };

  /* For internal use only. */
  class BugReport : public Interface {
  public:
    // For internal use only
    BugReport(BugReportImplementation*);

    LEAP_EXPORT BugReport();

    /* Starts recording data. The recording ends when endRecording() is called
    * or after 10 seconds. The recording is saved to the local hard drive. */
    LEAP_EXPORT bool beginRecording();
    /* Ends the recording. */
    LEAP_EXPORT void endRecording();

    /* True while recording is in progress. */
    LEAP_EXPORT bool isActive() const;
    /* Progress as a fraction of the maximum recording length (i.e. 10 seconds).
    * The range of the progress value is [0..1]. */
    LEAP_EXPORT float progress() const;
    /* The recording duration in seconds. */
    LEAP_EXPORT float duration() const;
  };

  class Config : public Interface {
  public:
    LEAP_EXPORT Config();

    enum ValueType {
      TYPE_UNKNOWN = 0,
      TYPE_BOOLEAN = 1,
      TYPE_INT32   = 2,
      TYPE_FLOAT   = 6,
      TYPE_STRING  = 8,
#ifdef SWIGCSHARP
      // deprecated
      TYPEUNKNOWN  = TYPE_UNKNOWN,
      TYPEBOOLEAN  = TYPE_BOOLEAN,
      TYPEINT32    = TYPE_INT32,
      TYPEFLOAT    = TYPE_FLOAT,
      TYPESTRING   = TYPE_STRING,
#endif
    };

    ValueType type(const std::string& key) const {
      return typeCString(key.c_str());
    }

    bool getBool(const std::string& key) const {
      return getBoolCString(key.c_str());
    }

    bool setBool(const std::string& key, bool value) {
      return setBoolCString(key.c_str(), value);
    }

    int32_t getInt32(const std::string& key) const {
      return getInt32CString(key.c_str());
    }

    bool setInt32(const std::string& key, int32_t value) {
      return setInt32CString(key.c_str(), value);
    }

    float getFloat(const std::string& key) const {
      return getFloatCString(key.c_str());
    }

    bool setFloat(const std::string& key, float value) {
      return setFloatCString(key.c_str(), value);
    }

    std::string getString(const std::string& key) const {
      const char* cstr = getStringCString(key.c_str());
      std::string str(cstr);
      deleteCString(cstr);
      return str;
    }

    bool setString(const std::string& key, const std::string& value) {
      return setStringCString(key.c_str(), value.c_str());
    }

    LEAP_EXPORT bool save();
  private:
    LEAP_EXPORT ValueType typeCString(const char* key) const;
    LEAP_EXPORT bool getBoolCString(const char* key) const;
    LEAP_EXPORT bool setBoolCString(const char* key, bool value);
    LEAP_EXPORT int32_t getInt32CString(const char* key) const;
    LEAP_EXPORT bool setInt32CString(const char* key, int32_t value);
    LEAP_EXPORT float getFloatCString(const char* key) const;
    LEAP_EXPORT bool setFloatCString(const char* key, float value);
    LEAP_EXPORT const char* getStringCString(const char* key) const;
    LEAP_EXPORT bool setStringCString(const char* key, const char* value);
  };

  class LEAP_EXPORT_CLASS Controller : public Interface {
  public:
    // For internal use only.
    Controller(ControllerImplementation*);

    LEAP_EXPORT Controller();
    LEAP_EXPORT virtual ~Controller();
    LEAP_EXPORT Controller(Listener& listener);

    LEAP_EXPORT bool isConnected() const;

    LEAP_EXPORT bool isServiceConnected() const;

    LEAP_EXPORT bool hasFocus() const;

    enum PolicyFlag {
      POLICY_DEFAULT = 0,
      POLICY_BACKGROUND_FRAMES = (1 << 0),

      POLICY_IMAGES = (1 << 1),

      POLICY_OPTIMIZE_HMD = (1 << 2),

#ifdef SWIGCSHARP
      // deprecated
      POLICYDEFAULT = POLICY_DEFAULT,
      POLICYBACKGROUNDFRAMES = POLICY_BACKGROUND_FRAMES,
#endif
    };

    LEAP_EXPORT PolicyFlag policyFlags() const;

    LEAP_EXPORT void setPolicyFlags(PolicyFlag flags) const;

    LEAP_EXPORT void setPolicy(PolicyFlag policy) const;

    LEAP_EXPORT void clearPolicy(PolicyFlag policy) const;

    LEAP_EXPORT bool isPolicySet(PolicyFlag policy) const;

    LEAP_EXPORT bool addListener(Listener& listener);

    LEAP_EXPORT bool removeListener(Listener& listener);

    LEAP_EXPORT Frame frame(int history = 0) const;

    LEAP_EXPORT ImageList images() const;

    LEAP_EXPORT Config config() const;

    LEAP_EXPORT DeviceList devices() const;

    /*
     * Deprecated as of version 1.2.
     */
    LEAP_EXPORT ScreenList locatedScreens() const;

    /* For internal use only. */
    LEAP_EXPORT BugReport bugReport() const;

    LEAP_EXPORT void enableGesture(Gesture::Type type, bool enable = true) const;

    LEAP_EXPORT bool isGestureEnabled(Gesture::Type type) const;

    LEAP_EXPORT TrackedQuad trackedQuad() const;

    LEAP_EXPORT int64_t now() const;
  };

  class LEAP_EXPORT_CLASS Listener {
  public:
    LEAP_EXPORT Listener() {}

    LEAP_EXPORT virtual ~Listener() {}

    LEAP_EXPORT virtual void onInit(const Controller&) {}

    LEAP_EXPORT virtual void onConnect(const Controller&) {}

    LEAP_EXPORT virtual void onDisconnect(const Controller&) {}

    LEAP_EXPORT virtual void onExit(const Controller&) {}

    LEAP_EXPORT virtual void onFrame(const Controller&) {}

    LEAP_EXPORT virtual void onFocusGained(const Controller&) {}

    LEAP_EXPORT virtual void onFocusLost(const Controller&) {}

    // onServiceConnect/onServiceDisconnect are for connection established/lost.
    // in normal course of events onServiceConnect will get called once after onInit
    // and onServiceDisconnect will not get called. disconnect notification only happens
    // if service stops running or something else bad happens to disconnect controller from service.
    LEAP_EXPORT virtual void onServiceConnect(const Controller&) {}
    LEAP_EXPORT virtual void onServiceDisconnect(const Controller&) {}

    LEAP_EXPORT virtual void onDeviceChange(const Controller&) {}

    LEAP_EXPORT virtual void onImages(const Controller&) {}

  };
}

#endif // __Leap_h__