Leap C++ API Reference  0.7.9
Leap.h
1 /******************************************************************************\
2 * Copyright (C) 2012-2013 Leap Motion, Inc. All rights reserved. *
3 * Leap Motion proprietary and confidential. Not for distribution. *
4 * Use subject to the terms of the Leap Motion SDK Agreement available at *
5 * https://developer.leapmotion.com/sdk_agreement, or another agreement *
6 * between Leap Motion and you, your company or other organization. *
7 \******************************************************************************/
8 
9 #if !defined(__Leap_h__)
10 #define __Leap_h__
11 
12 #include "LeapMath.h"
13 
14 #include <string>
15 #include <vector>
16 
17 // Define integer types for Visual Studio 2008 and earlier
18 #if defined(_MSC_VER) && (_MSC_VER < 1600)
19 typedef __int32 int32_t;
20 typedef __int64 int64_t;
21 typedef unsigned __int32 uint32_t;
22 typedef unsigned __int64 uint64_t;
23 #else
24 #include <stdint.h>
25 #endif
26 
27 // Define Leap export macros
28 #if defined(_WIN32) // Windows
29 #if LEAP_API_INTERNAL
30 #define LEAP_EXPORT
31 #elif LEAP_API_IMPLEMENTATION
32 #define LEAP_EXPORT __declspec(dllexport)
33 #else
34 #define LEAP_EXPORT __declspec(dllimport)
35 #endif
36 #define LEAP_EXPORT_CLASS
37 #define LEAP_EXPORT_PLUGIN __declspec(dllexport)
38 #elif !defined(SWIG)
39 #define LEAP_EXPORT __attribute__((visibility("default")))
40 #define LEAP_EXPORT_CLASS __attribute__((visibility("default")))
41 #define LEAP_EXPORT_PLUGIN __attribute__((visibility("default")))
42 #else
43 #define LEAP_EXPORT
44 #define LEAP_EXPORT_CLASS
45 #define LEAP_EXPORT_PLUGIN
46 #endif
47 
48 namespace Leap {
49 
50 // Interface for internal use only
51 class LEAP_EXPORT_CLASS Interface {
52  public:
53  struct Implementation {
54  LEAP_EXPORT virtual ~Implementation() {}
55  };
56  protected:
57  LEAP_EXPORT Interface(void* owner);
58  LEAP_EXPORT Interface(Implementation* reference, void* owner);
59  LEAP_EXPORT Interface(const Interface& rhs);
60  LEAP_EXPORT Interface& operator=(const Interface& rhs);
61  LEAP_EXPORT virtual ~Interface();
62  template<typename T> T* get() const { return static_cast<T*>(reference()); }
63  class SharedObject* m_object;
64  private:
65  LEAP_EXPORT Implementation* reference() const;
66 };
67 
68 // Forward declarations for internal use only
69 class PointableImplementation;
70 class FingerImplementation;
71 class ToolImplementation;
72 class HandImplementation;
73 class GestureImplementation;
74 class ScreenImplementation;
75 class FrameImplementation;
76 class ControllerImplementation;
77 template<typename T> class ListBaseImplementation;
78 
79 // Forward declarations
80 class PointableList;
81 class FingerList;
82 class ToolList;
83 class HandList;
84 class GestureList;
85 class Hand;
86 class Gesture;
87 class Screen;
88 class Frame;
89 class Listener;
90 
107 class Pointable : public Interface {
108  public:
109  // For internal use only.
110  Pointable(PointableImplementation*);
111  // For internal use only.
112  Pointable(FingerImplementation*);
113  // For internal use only.
114  Pointable(ToolImplementation*);
115 
122  LEAP_EXPORT Pointable();
123 
136  LEAP_EXPORT int32_t id() const;
137 
144  LEAP_EXPORT Frame frame() const;
145 
152  LEAP_EXPORT Hand hand() const;
153 
159  LEAP_EXPORT Vector tipPosition() const;
160 
166  LEAP_EXPORT Vector tipVelocity() const;
167 
179  LEAP_EXPORT Vector direction() const;
180 
190  LEAP_EXPORT float width() const;
191 
200  LEAP_EXPORT float length() const;
201 
208  LEAP_EXPORT bool isFinger() const;
209 
216  LEAP_EXPORT bool isTool() const;
217 
223  LEAP_EXPORT bool isValid() const;
224 
234  LEAP_EXPORT static const Pointable& invalid();
235 
241  LEAP_EXPORT bool operator==(const Pointable&) const;
242 
248  LEAP_EXPORT bool operator!=(const Pointable&) const;
249 
251  LEAP_EXPORT friend std::ostream& operator<<(std::ostream&, const Pointable&);
252 
258  LEAP_EXPORT std::string toString() const;
259 };
260 
274 class Finger : public Pointable {
275  public:
276  // For internal use only.
277  Finger(FingerImplementation*);
278 
285  LEAP_EXPORT Finger();
286 
291  LEAP_EXPORT explicit Finger(const Pointable&);
292 
302  LEAP_EXPORT static const Finger& invalid();
303 
309  LEAP_EXPORT std::string toString() const;
310 };
311 
328 class Tool : public Pointable {
329  public:
330  // For internal use only.
331  Tool(ToolImplementation*);
332 
339  LEAP_EXPORT Tool();
340 
345  LEAP_EXPORT explicit Tool(const Pointable&);
346 
356  LEAP_EXPORT static const Tool& invalid();
357 
363  LEAP_EXPORT std::string toString() const;
364 };
365 
380 class Hand : public Interface {
381  public:
382  // For internal use only.
383  Hand(HandImplementation*);
384 
391  LEAP_EXPORT Hand();
392 
405  LEAP_EXPORT int32_t id() const;
406 
413  LEAP_EXPORT Frame frame() const;
414 
428  LEAP_EXPORT PointableList pointables() const;
429 
447  LEAP_EXPORT Pointable pointable(int32_t id) const;
448 
456  LEAP_EXPORT FingerList fingers() const;
457 
475  LEAP_EXPORT Finger finger(int32_t id) const;
476 
484  LEAP_EXPORT ToolList tools() const;
485 
503  LEAP_EXPORT Tool tool(int32_t id) const;
504 
510  LEAP_EXPORT Vector palmPosition() const;
511 
517  LEAP_EXPORT Vector palmVelocity() const;
518 
530  LEAP_EXPORT Vector palmNormal() const;
531 
540  LEAP_EXPORT Vector direction() const;
541 
551  LEAP_EXPORT Vector sphereCenter() const;
552 
560  LEAP_EXPORT float sphereRadius() const;
561 
578  LEAP_EXPORT Vector translation(const Frame& sinceFrame) const;
579 
593  LEAP_EXPORT float translationProbability(const Frame& sinceFrame) const;
594 
611  LEAP_EXPORT Vector rotationAxis(const Frame& sinceFrame) const;
612 
631  LEAP_EXPORT float rotationAngle(const Frame& sinceFrame) const;
632 
652  LEAP_EXPORT float rotationAngle(const Frame& sinceFrame, const Vector& axis) const;
653 
668  LEAP_EXPORT Matrix rotationMatrix(const Frame& sinceFrame) const;
669 
683  LEAP_EXPORT float rotationProbability(const Frame& sinceFrame) const;
684 
706  LEAP_EXPORT float scaleFactor(const Frame& sinceFrame) const;
707 
721  LEAP_EXPORT float scaleProbability(const Frame& sinceFrame) const;
722 
728  LEAP_EXPORT bool isValid() const;
729 
739  LEAP_EXPORT static const Hand& invalid();
740 
746  LEAP_EXPORT bool operator==(const Hand&) const;
747 
753  LEAP_EXPORT bool operator!=(const Hand&) const;
754 
756  LEAP_EXPORT friend std::ostream& operator<<(std::ostream&, const Hand&);
757 
763  LEAP_EXPORT std::string toString() const;
764 };
765 
828 class Gesture : public Interface {
829  public:
830  // For internal use only.
831  Gesture(GestureImplementation*);
832 
836  enum Type {
842  };
843 
847  enum State {
852  };
853 
861  LEAP_EXPORT Gesture();
862 
866  LEAP_EXPORT Gesture(const Gesture& rhs);
867 
873  LEAP_EXPORT Type type() const;
874 
884  LEAP_EXPORT State state() const;
885 
895  LEAP_EXPORT int32_t id() const;
896 
908  LEAP_EXPORT int64_t duration() const;
909 
915  LEAP_EXPORT float durationSeconds() const;
916 
922  LEAP_EXPORT Frame frame() const;
923 
931  LEAP_EXPORT HandList hands() const;
932 
940  LEAP_EXPORT PointableList pointables() const;
941 
955  LEAP_EXPORT bool isValid() const;
956 
963  LEAP_EXPORT bool operator==(const Gesture& rhs) const;
964 
971  LEAP_EXPORT bool operator!=(const Gesture& rhs) const;
972 
977  LEAP_EXPORT std::string toString() const;
978 
988  LEAP_EXPORT static const Gesture& invalid();
989 };
990 
1017 class SwipeGesture : public Gesture
1018 {
1019  public:
1025  static Type classType() { return TYPE_SWIPE; }
1026 
1027  LEAP_EXPORT SwipeGesture();
1028 
1035  LEAP_EXPORT SwipeGesture(const Gesture& rhs);
1036 
1043  LEAP_EXPORT Vector startPosition() const;
1044 
1051  LEAP_EXPORT Vector position() const;
1052 
1064  LEAP_EXPORT Vector direction() const;
1065 
1072  LEAP_EXPORT float speed() const;
1073 
1079  LEAP_EXPORT Pointable pointable() const;
1080 };
1081 
1117 class CircleGesture : public Gesture
1118 {
1119  public:
1125  static Type classType() { return TYPE_CIRCLE; }
1126 
1133  LEAP_EXPORT CircleGesture();
1134 
1141  LEAP_EXPORT CircleGesture(const Gesture& rhs);
1142 
1148  LEAP_EXPORT Vector center() const;
1149 
1170  LEAP_EXPORT Vector normal() const;
1171 
1187  LEAP_EXPORT float progress() const;
1188 
1194  LEAP_EXPORT float radius() const;
1195 
1201  LEAP_EXPORT Pointable pointable() const;
1202 };
1203 
1239 {
1240  public:
1246  static Type classType() { return TYPE_SCREEN_TAP; }
1247 
1254  LEAP_EXPORT ScreenTapGesture();
1255 
1262  LEAP_EXPORT ScreenTapGesture(const Gesture& rhs);
1263 
1269  LEAP_EXPORT Vector position() const;
1270 
1276  LEAP_EXPORT Vector direction() const;
1277 
1283  LEAP_EXPORT float progress() const;
1284 
1290  LEAP_EXPORT Pointable pointable() const;
1291 };
1292 
1328 class KeyTapGesture : public Gesture
1329 {
1330  public:
1336  static Type classType() { return TYPE_KEY_TAP; }
1337 
1344  LEAP_EXPORT KeyTapGesture();
1345 
1352  LEAP_EXPORT KeyTapGesture(const Gesture& rhs);
1353 
1359  LEAP_EXPORT Vector position() const;
1360 
1367  LEAP_EXPORT Vector direction() const;
1368 
1374  LEAP_EXPORT float progress() const;
1375 
1381  LEAP_EXPORT Pointable pointable() const;
1382 };
1383 
1408 class Screen : public Interface {
1409  public:
1410  // For internal use only.
1411  Screen(ScreenImplementation*);
1412 
1420  LEAP_EXPORT Screen();
1421 
1428  LEAP_EXPORT int32_t id() const;
1429 
1493  LEAP_EXPORT Vector intersect(const Pointable& pointable, bool normalize, float clampRatio = 1.0f) const;
1494 
1555  LEAP_EXPORT Vector intersect(const Vector& position, const Vector& direction, bool normalize, float clampRatio = 1.0f) const;
1556 
1610  LEAP_EXPORT Vector project(const Vector& position, bool normalize, float clampRatio = 1.0f) const;
1611 
1625  LEAP_EXPORT Vector horizontalAxis() const;
1626 
1640  LEAP_EXPORT Vector verticalAxis() const;
1641 
1655  LEAP_EXPORT Vector bottomLeftCorner() const;
1656 
1666  LEAP_EXPORT Vector normal() const;
1667 
1673  LEAP_EXPORT int widthPixels() const;
1674 
1680  LEAP_EXPORT int heightPixels() const;
1681 
1689  LEAP_EXPORT float distanceToPoint(const Vector& point) const;
1690 
1703  LEAP_EXPORT bool isValid() const;
1704 
1714  LEAP_EXPORT static const Screen& invalid();
1715 
1721  LEAP_EXPORT bool operator==(const Screen&) const;
1722 
1728  LEAP_EXPORT bool operator!=(const Screen&) const;
1729 
1731  LEAP_EXPORT friend std::ostream& operator<<(std::ostream&, const Screen&);
1732 
1738  LEAP_EXPORT std::string toString() const;
1739 };
1740 
1741 // For internal use only.
1742 template<typename L, typename T>
1743 class ConstListIterator {
1744  public:
1745  ConstListIterator<L,T>(const L& list, int index) : m_list(list), m_index(index) {}
1746 
1747  const T operator*() const { return m_list[m_index]; }
1748  const ConstListIterator<L,T>& operator++() { ++m_index; return *this; }
1749  bool operator!=(const ConstListIterator<L,T>& rhs) const { return m_index != rhs.m_index; }
1750 
1751  typedef std::ptrdiff_t difference_type;
1752  typedef T value_type;
1753  typedef const T* pointer;
1754  typedef const T& reference;
1755  typedef std::forward_iterator_tag iterator_category;
1756 
1757  private:
1758  const L& m_list;
1759  int m_index;
1760 };
1761 
1769 class PointableList : public Interface {
1770  public:
1771  // For internal use only.
1772  PointableList(const ListBaseImplementation<Pointable>&);
1773 
1775  LEAP_EXPORT PointableList();
1776 
1781  LEAP_EXPORT int count() const;
1782 
1787  LEAP_EXPORT bool isEmpty() const;
1788 
1793  LEAP_EXPORT bool empty() const;
1794 
1800  LEAP_EXPORT Pointable operator[](int index) const;
1801 
1807  LEAP_EXPORT PointableList& append(const PointableList& other);
1808 
1814  LEAP_EXPORT PointableList& append(const FingerList& other);
1815 
1821  LEAP_EXPORT PointableList& append(const ToolList& other);
1822 
1829  LEAP_EXPORT Pointable leftmost() const;
1830 
1837  LEAP_EXPORT Pointable rightmost() const;
1838 
1839 
1846  LEAP_EXPORT Pointable frontmost() const;
1847 
1849  typedef ConstListIterator<PointableList, Pointable> const_iterator;
1850 
1852  LEAP_EXPORT const_iterator begin() const;
1853 
1855  LEAP_EXPORT const_iterator end() const;
1856 };
1857 
1863 class FingerList : public Interface {
1864  public:
1865  // For internal use only.
1866  FingerList(const ListBaseImplementation<Finger>&);
1867 
1869  LEAP_EXPORT FingerList();
1870 
1875  LEAP_EXPORT int count() const;
1876 
1881  LEAP_EXPORT bool isEmpty() const;
1882 
1887  LEAP_EXPORT bool empty() const;
1888 
1894  LEAP_EXPORT Finger operator[](int index) const;
1895 
1901  LEAP_EXPORT FingerList& append(const FingerList& other);
1902 
1909  LEAP_EXPORT Finger leftmost() const;
1910 
1917  LEAP_EXPORT Finger rightmost() const;
1918 
1925  LEAP_EXPORT Finger frontmost() const;
1926 
1928  typedef ConstListIterator<FingerList, Finger> const_iterator;
1929 
1931  LEAP_EXPORT const_iterator begin() const;
1932 
1934  LEAP_EXPORT const_iterator end() const;
1935 };
1936 
1942 class ToolList : public Interface {
1943  public:
1944  // For internal use only.
1945  ToolList(const ListBaseImplementation<Tool>&);
1946 
1948  LEAP_EXPORT ToolList();
1949 
1954  LEAP_EXPORT int count() const;
1955 
1960  LEAP_EXPORT bool isEmpty() const;
1961 
1966  LEAP_EXPORT bool empty() const;
1967 
1973  LEAP_EXPORT Tool operator[](int index) const;
1974 
1980  LEAP_EXPORT ToolList& append(const ToolList& other);
1981 
1988  LEAP_EXPORT Tool leftmost() const;
1989 
1996  LEAP_EXPORT Tool rightmost() const;
1997 
2004  LEAP_EXPORT Tool frontmost() const;
2005 
2007  typedef ConstListIterator<ToolList, Tool> const_iterator;
2008 
2010  LEAP_EXPORT const_iterator begin() const;
2011 
2013  LEAP_EXPORT const_iterator end() const;
2014 };
2015 
2021 class HandList : public Interface {
2022  public:
2023  // For internal use only.
2024  HandList(const ListBaseImplementation<Hand>&);
2025 
2027  LEAP_EXPORT HandList();
2028 
2033  LEAP_EXPORT int count() const;
2034 
2039  LEAP_EXPORT bool isEmpty() const;
2040 
2045  LEAP_EXPORT bool empty() const;
2046 
2052  LEAP_EXPORT Hand operator[](int index) const;
2053 
2059  LEAP_EXPORT HandList& append(const HandList& other);
2060 
2067  LEAP_EXPORT Hand leftmost() const;
2068 
2075  LEAP_EXPORT Hand rightmost() const;
2076 
2083  LEAP_EXPORT Hand frontmost() const;
2084 
2086  typedef ConstListIterator<HandList, Hand> const_iterator;
2087 
2089  LEAP_EXPORT const_iterator begin() const;
2090 
2092  LEAP_EXPORT const_iterator end() const;
2093 };
2094 
2100 class GestureList : public Interface {
2101  public:
2102  // For internal use only.
2103  GestureList(const ListBaseImplementation<Gesture>&);
2104 
2106  LEAP_EXPORT GestureList();
2107 
2112  LEAP_EXPORT int count() const;
2113 
2118  LEAP_EXPORT bool isEmpty() const;
2119 
2124  LEAP_EXPORT bool empty() const;
2125 
2131  LEAP_EXPORT Gesture operator[](int index) const;
2132 
2138  LEAP_EXPORT GestureList& append(const GestureList& other);
2139 
2141  typedef ConstListIterator<GestureList, Gesture> const_iterator;
2142 
2144  LEAP_EXPORT const_iterator begin() const;
2145 
2147  LEAP_EXPORT const_iterator end() const;
2148 };
2149 
2164 class ScreenList : public Interface {
2165  public:
2166  // For internal use only.
2167  ScreenList(const ListBaseImplementation<Screen>&);
2168 
2170  LEAP_EXPORT ScreenList();
2171 
2176  LEAP_EXPORT int count() const;
2177 
2182  LEAP_EXPORT bool isEmpty() const;
2183 
2188  LEAP_EXPORT bool empty() const;
2189 
2195  LEAP_EXPORT Screen operator[](int index) const;
2196 
2198  typedef ConstListIterator<ScreenList, Screen> const_iterator;
2199 
2201  LEAP_EXPORT const_iterator begin() const;
2202 
2204  LEAP_EXPORT const_iterator end() const;
2205 
2230  LEAP_EXPORT Screen closestScreenHit(const Pointable& pointable) const;
2231 
2257  LEAP_EXPORT Screen closestScreenHit(const Vector& position, const Vector& direction) const;
2258 
2272  LEAP_EXPORT Screen closestScreen(const Vector& position) const;
2273 };
2274 
2285 class Frame : public Interface {
2286  public:
2287  // For internal use only.
2288  Frame(FrameImplementation*);
2289 
2296  LEAP_EXPORT Frame();
2297 
2304  LEAP_EXPORT int64_t id() const;
2305 
2311  LEAP_EXPORT int64_t timestamp() const;
2312 
2319  LEAP_EXPORT HandList hands() const;
2320 
2338  LEAP_EXPORT Hand hand(int32_t id) const;
2339 
2346  LEAP_EXPORT PointableList pointables() const;
2347 
2365  LEAP_EXPORT Pointable pointable(int32_t id) const;
2366 
2373  LEAP_EXPORT FingerList fingers() const;
2374 
2392  LEAP_EXPORT Finger finger(int32_t id) const;
2393 
2400  LEAP_EXPORT ToolList tools() const;
2401 
2419  LEAP_EXPORT Tool tool(int32_t id) const;
2420 
2435  LEAP_EXPORT Gesture gesture(int32_t id) const;
2436 
2445  LEAP_EXPORT GestureList gestures() const;
2446 
2457  LEAP_EXPORT GestureList gestures(const Frame& sinceFrame) const;
2458 
2477  LEAP_EXPORT Vector translation(const Frame& sinceFrame) const;
2478 
2491  LEAP_EXPORT float translationProbability(const Frame& sinceFrame) const;
2492 
2510  LEAP_EXPORT Vector rotationAxis(const Frame& sinceFrame) const;
2511 
2531  LEAP_EXPORT float rotationAngle(const Frame& sinceFrame) const;
2532 
2553  LEAP_EXPORT float rotationAngle(const Frame& sinceFrame, const Vector& axis) const;
2554 
2570  LEAP_EXPORT Matrix rotationMatrix(const Frame& sinceFrame) const;
2571 
2584  LEAP_EXPORT float rotationProbability(const Frame& sinceFrame) const;
2585 
2606  LEAP_EXPORT float scaleFactor(const Frame& sinceFrame) const;
2607 
2620  LEAP_EXPORT float scaleProbability(const Frame& sinceFrame) const;
2621 
2642  LEAP_EXPORT bool isValid() const;
2643 
2653  LEAP_EXPORT static const Frame& invalid();
2654 
2660  LEAP_EXPORT bool operator==(const Frame&) const;
2661 
2667  LEAP_EXPORT bool operator!=(const Frame&) const;
2668 
2670  LEAP_EXPORT friend std::ostream& operator<<(std::ostream&, const Frame&);
2671 
2677  LEAP_EXPORT std::string toString() const;
2678 };
2679 
2709 class Config : public Interface {
2710  public:
2712  LEAP_EXPORT Config();
2713 
2719  enum ValueType {
2725  };
2726 
2734  LEAP_EXPORT ValueType type(const std::string& key) const;
2735 
2737  LEAP_EXPORT bool getBool(const std::string& key) const;
2738 
2742  LEAP_EXPORT bool setBool(const std::string& key, bool value);
2743 
2745  LEAP_EXPORT int32_t getInt32(const std::string& key) const;
2746 
2750  LEAP_EXPORT bool setInt32(const std::string& key, int32_t value);
2751 
2753  LEAP_EXPORT float getFloat(const std::string& key) const;
2754 
2758  LEAP_EXPORT bool setFloat(const std::string& key, float value);
2759 
2761  LEAP_EXPORT std::string getString(const std::string& key) const;
2762 
2766  LEAP_EXPORT bool setString(const std::string& key, const std::string& value);
2767 
2778  LEAP_EXPORT bool save();
2779 };
2780 
2822 class Controller : public Interface {
2823  public:
2824  // For internal use only.
2825  Controller(ControllerImplementation*);
2826 
2834  LEAP_EXPORT Controller();
2835  LEAP_EXPORT virtual ~Controller();
2846  LEAP_EXPORT Controller(Listener& listener);
2847 
2862  LEAP_EXPORT bool isConnected() const;
2863 
2876  LEAP_EXPORT bool hasFocus() const;
2877 
2885  enum PolicyFlag {
2888  };
2889 
2905  LEAP_EXPORT PolicyFlag policyFlags() const;
2906 
2936  LEAP_EXPORT void setPolicyFlags(PolicyFlag flags) const;
2937 
2952  LEAP_EXPORT bool addListener(Listener& listener);
2953 
2963  LEAP_EXPORT bool removeListener(Listener& listener);
2964 
2978  LEAP_EXPORT Frame frame(int history = 0) const;
2979 
2984  LEAP_EXPORT Config config() const;
2985 
3019  LEAP_EXPORT ScreenList locatedScreens() const;
3020 
3025  LEAP_EXPORT ScreenList calibratedScreens() const;
3026 
3043  LEAP_EXPORT void enableGesture(Gesture::Type type, bool enable = true) const;
3044 
3051  LEAP_EXPORT bool isGestureEnabled(Gesture::Type type) const;
3052 };
3053 
3066 class Listener {
3067  public:
3069  LEAP_EXPORT Listener() {}
3070 
3072  LEAP_EXPORT virtual ~Listener() {}
3073 
3081  LEAP_EXPORT virtual void onInit(const Controller&) {}
3082 
3091  LEAP_EXPORT virtual void onConnect(const Controller&) {}
3092 
3107  LEAP_EXPORT virtual void onDisconnect(const Controller&) {}
3108 
3117  LEAP_EXPORT virtual void onExit(const Controller&) {}
3118 
3135  LEAP_EXPORT virtual void onFrame(const Controller&) {}
3136 
3148  LEAP_EXPORT virtual void onFocusGained(const Controller&) {}
3149 
3161  LEAP_EXPORT virtual void onFocusLost(const Controller&) {}
3162 };
3163 
3164 }
3165 
3166 #endif // __Leap_h__