From 72c46bdd7f5d430ab1ad1d420ed77c7f22df857a Mon Sep 17 00:00:00 2001 From: Stanislaw Halik Date: Sat, 30 Sep 2017 15:01:35 +0200 Subject: rename --- Tobii-EyeX/include/eyex/EyeX.h | 46 ++ Tobii-EyeX/include/eyex/EyeXActions.h | 344 ++++++++ Tobii-EyeX/include/eyex/EyeXAsyncData.h | 86 ++ Tobii-EyeX/include/eyex/EyeXBehavior.h | 764 +++++++++++++++++ Tobii-EyeX/include/eyex/EyeXBounds.h | 292 +++++++ Tobii-EyeX/include/eyex/EyeXClientTypes.h | 954 +++++++++++++++++++++ Tobii-EyeX/include/eyex/EyeXCommand.h | 211 +++++ Tobii-EyeX/include/eyex/EyeXConstants.h | 33 + Tobii-EyeX/include/eyex/EyeXContext.h | 773 +++++++++++++++++ Tobii-EyeX/include/eyex/EyeXEnv.h | 236 ++++++ Tobii-EyeX/include/eyex/EyeXEvent.h | 139 ++++ Tobii-EyeX/include/eyex/EyeXFrameworkTypes.h | 967 ++++++++++++++++++++++ Tobii-EyeX/include/eyex/EyeXInteractor.h | 1058 ++++++++++++++++++++++++ Tobii-EyeX/include/eyex/EyeXInternalLiterals.h | 84 ++ Tobii-EyeX/include/eyex/EyeXInternalTypes.h | 44 + Tobii-EyeX/include/eyex/EyeXLiterals.h | 373 +++++++++ Tobii-EyeX/include/eyex/EyeXMacros.h | 234 ++++++ Tobii-EyeX/include/eyex/EyeXNotification.h | 82 ++ Tobii-EyeX/include/eyex/EyeXObject.h | 194 +++++ Tobii-EyeX/include/eyex/EyeXProperty.h | 795 ++++++++++++++++++ Tobii-EyeX/include/eyex/EyeXQuery.h | 136 +++ Tobii-EyeX/include/eyex/EyeXSharedLiterals.h | 67 ++ Tobii-EyeX/include/eyex/EyeXSnapshot.h | 670 +++++++++++++++ Tobii-EyeX/include/eyex/EyeXStates.h | 933 +++++++++++++++++++++ Tobii-EyeX/include/eyex/EyeXUtils.h | 351 ++++++++ 25 files changed, 9866 insertions(+) create mode 100755 Tobii-EyeX/include/eyex/EyeX.h create mode 100755 Tobii-EyeX/include/eyex/EyeXActions.h create mode 100755 Tobii-EyeX/include/eyex/EyeXAsyncData.h create mode 100755 Tobii-EyeX/include/eyex/EyeXBehavior.h create mode 100755 Tobii-EyeX/include/eyex/EyeXBounds.h create mode 100755 Tobii-EyeX/include/eyex/EyeXClientTypes.h create mode 100755 Tobii-EyeX/include/eyex/EyeXCommand.h create mode 100755 Tobii-EyeX/include/eyex/EyeXConstants.h create mode 100755 Tobii-EyeX/include/eyex/EyeXContext.h create mode 100755 Tobii-EyeX/include/eyex/EyeXEnv.h create mode 100755 Tobii-EyeX/include/eyex/EyeXEvent.h create mode 100755 Tobii-EyeX/include/eyex/EyeXFrameworkTypes.h create mode 100755 Tobii-EyeX/include/eyex/EyeXInteractor.h create mode 100755 Tobii-EyeX/include/eyex/EyeXInternalLiterals.h create mode 100755 Tobii-EyeX/include/eyex/EyeXInternalTypes.h create mode 100755 Tobii-EyeX/include/eyex/EyeXLiterals.h create mode 100755 Tobii-EyeX/include/eyex/EyeXMacros.h create mode 100755 Tobii-EyeX/include/eyex/EyeXNotification.h create mode 100755 Tobii-EyeX/include/eyex/EyeXObject.h create mode 100755 Tobii-EyeX/include/eyex/EyeXProperty.h create mode 100755 Tobii-EyeX/include/eyex/EyeXQuery.h create mode 100755 Tobii-EyeX/include/eyex/EyeXSharedLiterals.h create mode 100755 Tobii-EyeX/include/eyex/EyeXSnapshot.h create mode 100755 Tobii-EyeX/include/eyex/EyeXStates.h create mode 100755 Tobii-EyeX/include/eyex/EyeXUtils.h (limited to 'Tobii-EyeX/include/eyex') diff --git a/Tobii-EyeX/include/eyex/EyeX.h b/Tobii-EyeX/include/eyex/EyeX.h new file mode 100755 index 0000000..d76dc26 --- /dev/null +++ b/Tobii-EyeX/include/eyex/EyeX.h @@ -0,0 +1,46 @@ +/********************************************************************************************************************* + * Copyright 2013-2014 Tobii Technology AB. All rights reserved. + * EyeX.h + *********************************************************************************************************************/ + +#if !defined(__TOBII_TX__H__) +#define __TOBII_TX__H__ + +/*********************************************************************************************************************/ + +#ifdef __cplusplus +#define TX_NAMESPACE_BEGIN namespace EyeX { +#define TX_NAMESPACE_END } +#define TX_USING_NAMESPACE_TX using namespace EyeX; +#endif // __cplusplus + +/*********************************************************************************************************************/ + +#include "EyeXMacros.h" +#include "EyeXLiterals.h" +#include "EyeXConstants.h" +#include "EyeXSharedLiterals.h" +#include "EyeXFrameworkTypes.h" +#include "EyeXClientTypes.h" +#include "EyeXEnv.h" +#include "EyeXContext.h" +#include "EyeXObject.h" +#include "EyeXAsyncData.h" +#include "EyeXUtils.h" +#include "EyeXSnapshot.h" +#include "EyeXBounds.h" +#include "EyeXInteractor.h" +#include "EyeXCommand.h" +#include "EyeXActions.h" +#include "EyeXBehavior.h" +#include "EyeXStates.h" +#include "EyeXNotification.h" +#include "EyeXQuery.h" +#include "EyeXEvent.h" +#include "EyeXProperty.h" + +/*********************************************************************************************************************/ + +#endif /* !defined(__TOBII_TX__H__) */ + +/*********************************************************************************************************************/ diff --git a/Tobii-EyeX/include/eyex/EyeXActions.h b/Tobii-EyeX/include/eyex/EyeXActions.h new file mode 100755 index 0000000..4e95b12 --- /dev/null +++ b/Tobii-EyeX/include/eyex/EyeXActions.h @@ -0,0 +1,344 @@ +/********************************************************************************************************************* + * Copyright 2013-2014 Tobii Technology AB. All rights reserved. + * EyeXAction.h + *********************************************************************************************************************/ + +#if !defined(__TOBII_TX_ACTION_API__H__) +#define __TOBII_TX_ACTION_API__H__ + +/*********************************************************************************************************************/ + +/** + txCreateActionCommand + + Creates an Action command. + + @param hContext [in]: + A TX_CONTEXTHANDLE to the context on which to create the command. + Must not be TX_EMPTY_HANDLE. + + @param phCommand [out]: + A pointer to a TX_HANDLE which will be set to the newly created command. + This handle must be released using txReleaseObject to avoid leaks. + Must not be TX_EMPTY_HANDLE. + + @param action [in]: + The type of action. + + @return + TX_RESULT_OK: The command was successfully created. + TX_RESULT_EYEXNOTINITIALIZED: The EyeX client environment is not initialized. + TX_RESULT_INVALIDARGUMENT: An invalid argument was passed to the function. + */ +TX_C_BEGIN +TX_API TX_RESULT TX_CALLCONVENTION txCreateActionCommand( + TX_CONTEXTHANDLE hContext, + TX_HANDLE* phCommand, + TX_ACTIONTYPE actionType + ); +TX_C_END + +typedef TX_RESULT (TX_CALLCONVENTION *CreateActionCommandHook)( + TX_CONTEXTHANDLE hContext, + TX_HANDLE* phCommand, + TX_ACTIONTYPE actionType + ); + + +/*********************************************************************************************************************/ + +/** + txDisableBuiltinKeysAsync + + Disables EyeX builtin keys for a top-level window. When the gaze is over the + specified window, all interaction must be done through action commands. + + @param hContext [in]: + A TX_CONTEXTHANDLE to the context on which to disable keys. + Must not be TX_EMPTY_HANDLE. + + @param windowId [in]: + The window id for which to disable keys (window id corresponds to the windows handle on Windows). + + @param completionHandler [in]: + The TX_ASYNCDATACALLBACK that will handle the request result. + Can be NULL. + + The data provided by the TX_ASYNCDATACALLBACK will contain a result code which can be retrieved using + + TX_RESULT_OK: + The request was succesfully executed on the client. + + TX_RESULT_CANCELLED: + The asynchronous operation was cancelled. + + That handle to the async data must NOT be released. + + @param userParam [in]: + A TX_USERPARAM which will be provided as a parameter to the completion callback. + Can be NULL. + + @return + TX_RESULT_OK: The request was successfully sent. + TX_RESULT_EYEXNOTINITIALIZED: The EyeX client environment is not initialized. + TX_RESULT_INVALIDARGUMENT: An invalid argument was passed to the function. + */ +TX_C_BEGIN +TX_API TX_RESULT TX_CALLCONVENTION txDisableBuiltinKeys( + TX_CONTEXTHANDLE hContext, + TX_CONSTSTRING windowId, + TX_ASYNCDATACALLBACK completionHandler, + TX_USERPARAM userParam + ); +TX_C_END + +typedef TX_RESULT (TX_CALLCONVENTION *DisableBuiltinKeysHook)( + TX_CONTEXTHANDLE hContext, + TX_CONSTSTRING windowId, + TX_ASYNCDATACALLBACK completionHandler, + TX_USERPARAM userParam + ); + + +/*********************************************************************************************************************/ + +/** + txEnableBuiltinKeysAsync + + Enables EyeX builtin keys for a top-level window where the keys was previously disabled. + + @param hContext [in]: + A TX_CONTEXTHANDLE to the context on which to enable keys. + Must not be TX_EMPTY_HANDLE. + + @param windowId [in]: + The window id for which to re-enable keys (window id corresponds to the windows handle on Windows). + + @param completionHandler [in]: + The TX_ASYNCDATACALLBACK that will handle the request result. + Can be NULL. + + The data provided by the TX_ASYNCDATACALLBACK will contain a result code which can be retrieved using + txGetAsyncDataResult(). The result code will be one of the following: + + TX_RESULT_OK: + The request was succesfully executed on the client. + + TX_RESULT_CANCELLED: + The asynchronous operation was cancelled. + + That handle to the async data must NOT be released. + + @param userParam [in]: + A TX_USERPARAM which will be provided as a parameter to the completion callback. + Can be NULL. + + @return + TX_RESULT_OK: The command was successfully created. + TX_RESULT_EYEXNOTINITIALIZED: The EyeX client environment is not initialized. + TX_RESULT_INVALIDARGUMENT: An invalid argument was passed to the function. + */ +TX_C_BEGIN +TX_API TX_RESULT TX_CALLCONVENTION txEnableBuiltinKeys( + TX_CONTEXTHANDLE hContext, + TX_CONSTSTRING windowId, + TX_ASYNCDATACALLBACK completionHandler, + TX_USERPARAM userParam + ); +TX_C_END + +typedef TX_RESULT (TX_CALLCONVENTION *EnableBuiltinKeysHook)( + TX_CONTEXTHANDLE hContext, + TX_CONSTSTRING windowId, + TX_ASYNCDATACALLBACK completionHandler, + TX_USERPARAM userParam + ); + + +/*********************************************************************************************************************/ + +/** + txLaunchConfigurationTool + + \since Version 1.1.0 + + Launch a configuration tool. The supported tools are: + - EyeX Settings + - Test eye tracking + - Recalibrate current user profile + - Create new user profile + - Guest calibration + - Diagnostics + + @param hContext [in]: + A TX_CONTEXTHANDLE to the context. + Must not be TX_EMPTY_HANDLE. + + @param configurationTool[in]: + A TX_CONFIGURATIONTOOL that determines which tool to launch. + + @param completionHandler [in]: + The TX_ASYNCDATACALLBACK that will handle the request result. + Can be NULL. + + The data provided by the TX_ASYNCDATACALLBACK will contain a result code which can be retrieved using + txGetAsyncDataResult(). The result code will be one of the following: + + TX_RESULT_OK: + The tool was successfully launched. + + TX_RESULT_INVALIDEYETRACKERSTATE: + The tool can not be launched in the current eye tracker state. + This could be that another configuration tool is active or that + the eye tracker is in an invalid state to start the configuration tool, + see TX_CONFIGURATIONTOOL for details. + + TX_RESULT_NOTFOUND: + The tool was not found or failed to launch. + + TX_RESULT_CANCELLED: + The client is not connected. + + The handle to the async data must NOT be released. + + @param userParam [in]: + A TX_USERPARAM which will be provided as a parameter to the completion callback. + Can be NULL. + + @return + TX_RESULT_OK: The command was successfully created. + TX_RESULT_EYEXNOTINITIALIZED: The EyeX client environment is not initialized. + TX_RESULT_INVALIDARGUMENT: An invalid argument was passed to the function. +*/ +TX_C_BEGIN +TX_API TX_RESULT TX_CALLCONVENTION txLaunchConfigurationTool( + TX_CONTEXTHANDLE hContext, + TX_CONFIGURATIONTOOL configurationTool, + TX_ASYNCDATACALLBACK completionHandler, + TX_USERPARAM userParam + ); +TX_C_END + +typedef TX_RESULT (TX_CALLCONVENTION *LaunchConfigurationToolHook)( + TX_CONTEXTHANDLE hContext, + TX_CONFIGURATIONTOOL configurationTool, + TX_ASYNCDATACALLBACK completionHandler, + TX_USERPARAM userParam + ); + + + +/*********************************************************************************************************************/ + +/** + Set the current calibration profile. + + \since Version 1.3.0 + + @param hContext [in]: + A TX_CONTEXTHANDLE to the context. + Must not be TX_EMPTY_HANDLE. + + @param profileName[in]: + The name of the profile to activate. Must be one of the available profiles, see state TX_STATEPATH_EYETRACKINGPROFILES. + + @param completionHandler [in]: + The TX_ASYNCDATACALLBACK that will handle the request result. + Can be NULL. + + The data provided by the TX_ASYNCDATACALLBACK will contain a result code which can be retrieved using + txGetAsyncDataResult(). The result code will be one of the following: + + TX_RESULT_OK: + The profile was successfully set. + + TX_RESULT_NOTFOUND: + The profile was not found among the available profiles. + + The handle to the async data must NOT be released. + + @param userParam [in]: + A TX_USERPARAM which will be provided as a parameter to the completion callback. + Can be NULL. + + @return + TX_RESULT_OK: The command was successfully created. + TX_RESULT_EYEXNOTINITIALIZED: The EyeX client environment is not initialized. + TX_RESULT_INVALIDARGUMENT: An invalid argument was passed to the function. + + */ +TX_C_BEGIN +TX_API TX_RESULT TX_CALLCONVENTION txSetCurrentProfile( + TX_CONTEXTHANDLE hContext, + TX_CONSTSTRING profileName, + TX_ASYNCDATACALLBACK completionHandler, + TX_USERPARAM userParam); +TX_C_END + +typedef TX_RESULT (TX_CALLCONVENTION *SetCurrentProfileHook)( + TX_CONTEXTHANDLE hContext, + TX_CONSTSTRING profileName, + TX_ASYNCDATACALLBACK completionHandler, + TX_USERPARAM userParam); + + + +/*********************************************************************************************************************/ + +/** + Delete a calibration profile. + + \since Version 1.3.0 + + @param hContext [in]: + A TX_CONTEXTHANDLE to the context. + Must not be TX_EMPTY_HANDLE. + + @param profileName[in]: + The name of the profile to delete. Must be one of the available profiles, see state TX_STATEPATH_EYETRACKINGPROFILES. + + @param completionHandler [in]: + The TX_ASYNCDATACALLBACK that will handle the request result. + Can be NULL. + + The data provided by the TX_ASYNCDATACALLBACK will contain a result code which can be retrieved using + txGetAsyncDataResult(). The result code will be one of the following: + + TX_RESULT_OK: + The profile was successfully set. + + TX_RESULT_NOTFOUND: + The profile was not found among the available profiles. + + The handle to the async data must NOT be released. + + @param userParam [in]: + A TX_USERPARAM which will be provided as a parameter to the completion callback. + Can be NULL. + + @return + TX_RESULT_OK: The command was successfully created. + TX_RESULT_EYEXNOTINITIALIZED: The EyeX client environment is not initialized. + TX_RESULT_INVALIDARGUMENT: An invalid argument was passed to the function. + +*/ +TX_C_BEGIN +TX_API TX_RESULT TX_CALLCONVENTION txDeleteProfile( + TX_CONTEXTHANDLE hContext, + TX_CONSTSTRING profileName, + TX_ASYNCDATACALLBACK completionHandler, + TX_USERPARAM userParam); +TX_C_END + +typedef TX_RESULT (TX_CALLCONVENTION *DeleteProfileHook)( + TX_CONTEXTHANDLE hContext, + TX_CONSTSTRING profileName, + TX_ASYNCDATACALLBACK completionHandler, + TX_USERPARAM userParam); + + +/*********************************************************************************************************************/ + +#endif /* !defined(__TOBII_TX_ACTION_API__H__) */ + +/*********************************************************************************************************************/ diff --git a/Tobii-EyeX/include/eyex/EyeXAsyncData.h b/Tobii-EyeX/include/eyex/EyeXAsyncData.h new file mode 100755 index 0000000..6395985 --- /dev/null +++ b/Tobii-EyeX/include/eyex/EyeXAsyncData.h @@ -0,0 +1,86 @@ +/********************************************************************************************************************* + * Copyright 2013-2014 Tobii Technology AB. All rights reserved. + * EyeXAsyncData.h + *********************************************************************************************************************/ + +#if !defined(__TOBII_TX_ASYNCDATA_API__H__) +#define __TOBII_TX_ASYNCDATA_API__H__ + +/*********************************************************************************************************************/ + +/** + txGetAsyncDataResultCode + + Gets the result code contained by an async data. + Not all async data objects have a result code. See the specific asynchronous call for + details. + + @param hAsyncData [in]: + A TX_CONSTHANDLE to the async data object. + Must not be TX_EMPTY_HANDLE. + + @param pResult [out]: + A pointer to a TX_RESULT which will be set to the result code. + Must not be NULL. + + @return + TX_RESULT_OK: The result code of the async data was successfully retrieved. + TX_RESULT_EYEXNOTINITIALIZED: The EyeX client environment is not initialized. + TX_RESULT_INVALIDARGUMENT: An invalid argument was passed to the function. + TX_RESULT_NOTFOUND: The async data does not have a result code. + */ +TX_C_BEGIN +TX_API TX_RESULT TX_CALLCONVENTION txGetAsyncDataResultCode( + TX_CONSTHANDLE hAsyncData, + TX_RESULT* pResult + ); +TX_C_END + +typedef TX_RESULT (TX_CALLCONVENTION *GetAsyncDataResultCodeHook)( + TX_CONSTHANDLE hAsyncData, + TX_RESULT* pResult + ); + + +/*********************************************************************************************************************/ + +/** + txGetAsyncDataContent + + Gets the content of an asynchronous data object. + The content may be any interaction object or nothing depending on the operation. + + @param hCommand [in]: + A TX_CONSTHANDLE to the async data object. + Must not be TX_EMPTY_HANDLE. + + @param phObject [out]: + A pointer to a TX_HANDLE will be set to the content of the async data. + This handle must be released using txReleaseObject to avoid leaks. + Must not be NULL. + The value of the pointer must be set to TX_EMPTY_HANDLE. + + @return + TX_RESULT_OK: The content of the async data was successfully retrieved. + TX_RESULT_EYEXNOTINITIALIZED: The EyeX client environment is not initialized. + TX_RESULT_INVALIDARGUMENT: An invalid argument was passed to the function. + TX_RESULT_NOTFOUND: The async data does not have any content. + */ +TX_C_BEGIN +TX_API TX_RESULT TX_CALLCONVENTION txGetAsyncDataContent( + TX_CONSTHANDLE hAsyncData, + TX_HANDLE* phObject + ); +TX_C_END + +typedef TX_RESULT (TX_CALLCONVENTION *GetAsyncDataContentHook)( + TX_CONSTHANDLE hAsyncData, + TX_HANDLE* phObject + ); + + +/*********************************************************************************************************************/ + +#endif /* !defined(__TOBII_TX_ASYNCDATA_API__H__) */ + +/*********************************************************************************************************************/ diff --git a/Tobii-EyeX/include/eyex/EyeXBehavior.h b/Tobii-EyeX/include/eyex/EyeXBehavior.h new file mode 100755 index 0000000..9bee288 --- /dev/null +++ b/Tobii-EyeX/include/eyex/EyeXBehavior.h @@ -0,0 +1,764 @@ +/********************************************************************************************************************* + * Copyright 2013-2014 Tobii Technology AB. All rights reserved. + * EyeXBehavior.h + *********************************************************************************************************************/ + +#if !defined(__TOBII_TX_BEHAVIOR_API__H__) +#define __TOBII_TX_BEHAVIOR_API__H__ + +/*********************************************************************************************************************/ + +/** + txGetBehaviorType + + Gets the TX_BEHAVIORTYPE of an interaction behavior. + + @param hBehavior [in]: + A TX_CONSTHANDLE to the behavior. + Must not be TX_EMPTY_HANDLE. + + @param pBehaviorType [out]: + A pointer to a TX_BEHAVIORTYPE which will be set to the type of the behavior + Must not be NULL. + + @return + TX_RESULT_OK: The type of the behavior was successfully retrieved. + TX_RESULT_EYEXNOTINITIALIZED: The EyeX client environment is not initialized. + TX_RESULT_INVALIDARGUMENT: An invalid argument was passed to the function. + */ +TX_C_BEGIN +TX_API TX_RESULT TX_CALLCONVENTION txGetBehaviorType( + TX_CONSTHANDLE hBehavior, + TX_BEHAVIORTYPE* pBehaviorType + ); +TX_C_END + +typedef TX_RESULT (TX_CALLCONVENTION *GetBehaviorTypeHook)( + TX_CONSTHANDLE hBehavior, + TX_BEHAVIORTYPE* pBehaviorType + ); + + +/*********************************************************************************************************************/ + +/** + txSetActivatableBehaviorParams + + Sets TX_ACTIVATABLEPARAMS for an activatable Behavior. + + @param hBehavior [in]: + A TX_HANDLE to the behavior on which to set the parameters. + Must not be TX_EMPTY_HANDLE. + + @param pParams [in]: + A pointer to a TX_ACTIVATABLEPARAMS which specifies the behaviors parameters. + Must not be NULL. + + @return + TX_RESULT_OK: The option was successfully set. + TX_RESULT_EYEXNOTINITIALIZED: The EyeX client environment is not initialized. + TX_RESULT_INVALIDARGUMENT: An invalid argument was passed to the function. + */ +TX_C_BEGIN +TX_API TX_RESULT TX_CALLCONVENTION txSetActivatableBehaviorParams( + TX_HANDLE hBehavior, + const TX_ACTIVATABLEPARAMS* pParams + ); +TX_C_END + +typedef TX_RESULT (TX_CALLCONVENTION *SetActivatableBehaviorParamsHook)( + TX_HANDLE hBehavior, + const TX_ACTIVATABLEPARAMS* pParams + ); + + +/*********************************************************************************************************************/ + +/** + txGetActivatableBehaviorParams + + Gets the TX_ACTIVATABLEPARAMS for an activatable behavior. + + @param hBehavior [in]: + A TX_CONSTHANDLE to the behavior from which the parameters should be retrieved. + Must not be TX_EMPTY_HANDLE. + + @param pParams [out]: + A pointer to a TX_ACTIVATABLEPARAMS which will be set to the behaviors parameters. + Must not be NULL. + + @return + TX_RESULT_OK: The parameters was successfully retrieved. + TX_RESULT_EYEXNOTINITIALIZED: The EyeX client environment is not initialized. + TX_RESULT_INVALIDARGUMENT: An invalid argument was passed to the function. + TX_RESULT_INVALIDBEHAVIORTYPE: The behavior was not of type TX_BEHAVIORTYPE_ACTIVATABLE. + */ +TX_C_BEGIN +TX_API TX_RESULT TX_CALLCONVENTION txGetActivatableBehaviorParams( + TX_CONSTHANDLE hBehavior, + TX_ACTIVATABLEPARAMS* pParams + ); +TX_C_END + +typedef TX_RESULT (TX_CALLCONVENTION *GetActivatableBehaviorParamsHook)( + TX_CONSTHANDLE hBehavior, + TX_ACTIVATABLEPARAMS* pParams + ); + + +/*********************************************************************************************************************/ + +/** + txGetActivatableEventType + + Gets the TX_ACTIVABLEEVENTTYPE for an activatable behavior. + + @param hBehavior [in]: + A TX_CONSTHANDLE to the behavior from which the event type will be retrieved. + Must not be TX_EMPTY_HANDLE. + + @param pEventType [out]: + A pointer to a TX_ACTIVATABLEEVENTTYPE which will be set to the event type. + Must not be NULL. + + @return + TX_RESULT_OK: The event type was successfully retrieved. + TX_RESULT_EYEXNOTINITIALIZED: The EyeX client environment is not initialized. + TX_RESULT_INVALIDARGUMENT: An invalid argument was passed to the function. + TX_RESULT_INVALIDBEHAVIORTYPE: The behavior was not of type TX_BEHAVIORTYPE_ACTIVATABLE. + */ +TX_C_BEGIN +TX_API TX_RESULT TX_CALLCONVENTION txGetActivatableEventType( + TX_CONSTHANDLE hBehavior, + TX_ACTIVATABLEEVENTTYPE* pEventType + ); +TX_C_END + +typedef TX_RESULT (TX_CALLCONVENTION *GetActivatableEventTypeHook)( + TX_CONSTHANDLE hBehavior, + TX_ACTIVATABLEEVENTTYPE* pEventType + ); + + +/*********************************************************************************************************************/ + +/** + txGetActivationFocusChangedEventParams + + Gets the TX_ACTIVATIONFOCUSCHANGEDEVENTPARAMS for an activatable behavior. + + @param hBehavior [in]: + A TX_CONSTHANDLE to the behavior from which the event parameters will be retrieved. + Must not be TX_EMPTY_HANDLE. + + @param pEventParams [out]: + A pointer to a TX_ACTIVATIONFOCUSCHANGEDEVENTPARAMS which will be set to the behaviors event parameters. + Must not be NULL. + + @return + TX_RESULT_OK: The parameters was successfully retrieved. + TX_RESULT_EYEXNOTINITIALIZED: The EyeX client environment is not initialized. + TX_RESULT_INVALIDARGUMENT: An invalid argument was passed to the function. + TX_RESULT_INVALIDBEHAVIORTYPE: The behavior was not of type TX_BEHAVIORTYPE_ACTIVATABLE. + TX_RESULT_NOTFOUND: The options could not be found due to invalid event type. + */ +TX_C_BEGIN +TX_API TX_RESULT TX_CALLCONVENTION txGetActivationFocusChangedEventParams( + TX_CONSTHANDLE hBehavior, + TX_ACTIVATIONFOCUSCHANGEDEVENTPARAMS* pEventParams + ); +TX_C_END + +typedef TX_RESULT (TX_CALLCONVENTION *GetActivationFocusChangedEventParamsHook)( + TX_CONSTHANDLE hBehavior, + TX_ACTIVATIONFOCUSCHANGEDEVENTPARAMS* pEventParams + ); + + +/*********************************************************************************************************************/ + +/** + txSetPannableBehaviorParams + + Sets the TX_PANNABLEPARAMS for a pannable behavior. + + @param hBehavior [in]: + A TX_HANDLE to the behavior on which to set the parameters. + Must not be TX_EMPTY_HANDLE. + + @param pParams [in]: + A pointer to a TX_PANNABLEPARAMS which specifies the parameters. + Must not be NULL. + + @return + TX_RESULT_OK: The parameters was successfully set. + TX_RESULT_EYEXNOTINITIALIZED: The EyeX client environment is not initialized. + TX_RESULT_INVALIDARGUMENT: An invalid argument was passed to the function. + TX_RESULT_INVALIDBEHAVIORTYPE: The behavior was not of type TX_BEHAVIORTYPE_PANNABLE. + */ +TX_C_BEGIN +TX_API TX_RESULT TX_CALLCONVENTION txSetPannableBehaviorParams( + TX_HANDLE hBehavior, + const TX_PANNABLEPARAMS* pParams + ); +TX_C_END + +typedef TX_RESULT (TX_CALLCONVENTION *SetPannableBehaviorParamsHook)( + TX_HANDLE hBehavior, + const TX_PANNABLEPARAMS* pParams + ); + + +/*********************************************************************************************************************/ + +/** + txGetPannableBehaviorParams + + Gets the TX_PANNABLEPARAMS for a pannable behavior. + + @param hBehavior [in]: + A TX_CONSTHANDLE to the behavior from which the parameters will be retrieved. + Must not be TX_EMPTY_HANDLE. + + @param pParams [out]: + A pointer to a TX_PANNABLEPARAMS which will be set to the parameters. + Must not be NULL. + + @return + TX_RESULT_OK: The parameters was successfully retrieved. + TX_RESULT_EYEXNOTINITIALIZED: The EyeX client environment is not initialized. + TX_RESULT_INVALIDARGUMENT: An invalid argument was passed to the function. + TX_RESULT_INVALIDBEHAVIORTYPE: The behavior was not of type TX_BEHAVIORTYPE_PANNABLE. + */ +TX_C_BEGIN +TX_API TX_RESULT TX_CALLCONVENTION txGetPannableBehaviorParams( + TX_CONSTHANDLE hBehavior, + TX_PANNABLEPARAMS* pParams + ); +TX_C_END + +typedef TX_RESULT (TX_CALLCONVENTION *GetPannableBehaviorParamsHook)( + TX_CONSTHANDLE hBehavior, + TX_PANNABLEPARAMS* pParams + ); + + +/*********************************************************************************************************************/ + +/** + txGetPannableEventType + + Gets the TX_PANNABLEEVENTTYPE for a pannable behavior event. + + @param hBehavior [in]: + A TX_CONSTHANDLE to the behavior from which the event type will be retrieved. + Must not be TX_EMPTY_HANDLE. + + @param pEventType [out]: + A pointer to a TX_PANNABLEEVENTTYPE which will be set to the event type. + Must not be NULL. + + @return + TX_RESULT_OK: The event type was successfully retrieved. + TX_RESULT_EYEXNOTINITIALIZED: The EyeX client environment is not initialized. + TX_RESULT_INVALIDARGUMENT: An invalid argument was passed to the function. + TX_RESULT_INVALIDBEHAVIORTYPE: The behavior was not of type TX_BEHAVIORTYPE_PANNABLE. + */ +TX_C_BEGIN +TX_API TX_RESULT TX_CALLCONVENTION txGetPannableEventType( + TX_CONSTHANDLE hBehavior, + TX_PANNABLEEVENTTYPE* pEventType + ); +TX_C_END + +typedef TX_RESULT (TX_CALLCONVENTION *GetPannableEventTypeHook)( + TX_CONSTHANDLE hBehavior, + TX_PANNABLEEVENTTYPE* pEventType + ); + + + +/*********************************************************************************************************************/ + +/** + txGetPannablePanEventParams + + Gets the TX_PANNABLEPANEVENTPARAMS for a pannable behavior pan event. + + @param hBehavior [in]: + A TX_CONSTHANDLE to the behavior from which the parameters will be retrieved. + Must not be TX_EMPTY_HANDLE. + + @param pEventParams [out]: + A pointer to a TX_PANNABLEPANEVENTPARAMS which will be set to the parameters. + Must not be NULL. + + @return + TX_RESULT_OK: The event parameters was successfully retrieved. + TX_RESULT_EYEXNOTINITIALIZED: The EyeX client environment is not initialized. + TX_RESULT_INVALIDARGUMENT: An invalid argument was passed to the function. + TX_RESULT_INVALIDBEHAVIORTYPE: The behavior was not of type TX_BEHAVIORTYPE_PANNABLE. + */ +TX_C_BEGIN +TX_API TX_RESULT TX_CALLCONVENTION txGetPannablePanEventParams( + TX_CONSTHANDLE hBehavior, + TX_PANNABLEPANEVENTPARAMS* pEventParams + ); +TX_C_END + +typedef TX_RESULT (TX_CALLCONVENTION *GetPannablePanEventParamsHook)( + TX_CONSTHANDLE hBehavior, + TX_PANNABLEPANEVENTPARAMS* pEventParams + ); + + +/*********************************************************************************************************************/ + +/** + txGetPannableStepEventParams + + Gets the TX_PANNABLESTEPEVENTPARAMS for a pannable behavior step event. + + @param hBehavior [in]: + A TX_CONSTHANDLE to the behavior from which the parameters will be retrieved. + Must not be TX_EMPTY_HANDLE. + + @param pEventParams [out]: + A pointer to a TX_PANNABLESTEPEVENTPARAMS which will be set to the parameters. + Must not be NULL. + + @return + TX_RESULT_OK: The event parameters was successfully retrieved. + TX_RESULT_EYEXNOTINITIALIZED: The EyeX client environment is not initialized. + TX_RESULT_INVALIDARGUMENT: An invalid argument was passed to the function. + TX_RESULT_INVALIDBEHAVIORTYPE: The behavior was not of type TX_BEHAVIORTYPE_PANNABLE. + */ +TX_C_BEGIN +TX_API TX_RESULT TX_CALLCONVENTION txGetPannableStepEventParams( + TX_CONSTHANDLE hBehavior, + TX_PANNABLESTEPEVENTPARAMS* pEventParams + ); +TX_C_END + +typedef TX_RESULT (TX_CALLCONVENTION *GetPannableStepEventParamsHook)( + TX_CONSTHANDLE hBehavior, + TX_PANNABLESTEPEVENTPARAMS* pEventParams + ); + + +/*********************************************************************************************************************/ + +/** + txGetPannableHandsFreeEventParams + + Gets the TX_PANNABLEHANDSFREEEVENTPARAMS for a pannable behavior hands free event. + + @param hBehavior [in]: + A TX_CONSTHANDLE to the behavior from which the parameters will be retrieved. + Must not be TX_EMPTY_HANDLE. + + @param pEventParams [out]: + A pointer to a TX_PANNABLEHANDSFREEEVENTPARAMS which will be set to the parameters. + Must not be NULL. + + @return + TX_RESULT_OK: The event parameters was successfully retrieved. + TX_RESULT_EYEXNOTINITIALIZED: The EyeX client environment is not initialized. + TX_RESULT_INVALIDARGUMENT: An invalid argument was passed to the function. + TX_RESULT_INVALIDBEHAVIORTYPE: The behavior was not of type TX_BEHAVIORTYPE_PANNABLE. + */ +TX_C_BEGIN +TX_API TX_RESULT TX_CALLCONVENTION txGetPannableHandsFreeEventParams( + TX_CONSTHANDLE hBehavior, + TX_PANNABLEHANDSFREEEVENTPARAMS* pEventParams + ); +TX_C_END + +typedef TX_RESULT (TX_CALLCONVENTION *GetPannableHandsFreeEventParamsHook)( + TX_CONSTHANDLE hBehavior, + TX_PANNABLEHANDSFREEEVENTPARAMS* pEventParams + ); + + +/*********************************************************************************************************************/ + +/** + txSetGazePointDataBehaviorParams + + Sets TX_GAZEPOINTDATAPARAMS for a gaze point data behavior. + + @param hBehavior [in]: + A TX_HANDLE to the behavior on which to set the parameters. + Must not be TX_EMPTY_HANDLE. + + @param pParams [in]: + A pointer to a TX_GAZEPOINTDATAPARAMS which specifies the behavior parameters. + Must not be NULL. + + @return + TX_RESULT_OK: The parameters was successfully set. + TX_RESULT_EYEXNOTINITIALIZED: The EyeX client environment is not initialized. + TX_RESULT_INVALIDARGUMENT: An invalid argument was passed to the function. + TX_RESULT_INVALIDBEHAVIORTYPE: The behavior was not of type TX_BEHAVIORTYPE_GAZEPOINTDATA. + */ +TX_C_BEGIN +TX_API TX_RESULT TX_CALLCONVENTION txSetGazePointDataBehaviorParams( + TX_HANDLE hBehavior, + const TX_GAZEPOINTDATAPARAMS* pParams + ); +TX_C_END + +typedef TX_RESULT (TX_CALLCONVENTION *SetGazePointDataBehaviorParamsHook)( + TX_HANDLE hBehavior, + const TX_GAZEPOINTDATAPARAMS* pParams + ); + + +/*********************************************************************************************************************/ + +/** + txGetGazePointDataBehaviorParams + + Gets the TX_GAZEPOINTDATAPARAMS for gaze point data behavior. + + @param hBehavior [in]: + A TX_CONSTHANDLE to the behavior from which the parameter will be retrieved. + Must not be TX_EMPTY_HANDLE. + + @param pParams [out]: + A pointer to a TX_GAZEPOINTDATAPARAMS which will be set to the behavior parameters. + Must not be NULL. + + @return + TX_RESULT_OK: The parameters was successfully retrieved. + TX_RESULT_EYEXNOTINITIALIZED: The EyeX client environment is not initialized. + TX_RESULT_INVALIDARGUMENT: An invalid argument was passed to the function. + TX_RESULT_INVALIDBEHAVIORTYPE: The behavior was not of type TX_BEHAVIORTYPE_GAZEPOINTDATA. + */ +TX_C_BEGIN +TX_API TX_RESULT TX_CALLCONVENTION txGetGazePointDataBehaviorParams( + TX_CONSTHANDLE hBehavior, + TX_GAZEPOINTDATAPARAMS* pParams + ); +TX_C_END + +typedef TX_RESULT (TX_CALLCONVENTION *GetGazePointDataBehaviorParamsHook)( + TX_CONSTHANDLE hBehavior, + TX_GAZEPOINTDATAPARAMS* pParams + ); + + +/*********************************************************************************************************************/ + +/** + txGetGazePointDataEventParams + + Gets the TX_GAZEPOINTDATAEVENTPARAMS for a gaze point behavior. + + @param hBehavior [in]: + A TX_CONSTHANDLE to the behavior from which the event parameters will be retrieved. + Must not be TX_EMPTY_HANDLE. + + @param pEventParams [out]: + A pointer to a TX_GAZEPOINTDATAEVENTPARAMS which will be set to the behavior event parameters. + Must not be NULL. + + @return + TX_RESULT_OK: The event parameters was successfully retrieved. + TX_RESULT_EYEXNOTINITIALIZED: The EyeX client environment is not initialized. + TX_RESULT_INVALIDARGUMENT: An invalid argument was passed to the function. + TX_RESULT_INVALIDBEHAVIORTYPE: The behavior is not of type TX_BEHAVIORTYPE_GAZEPOINTDATA. + */ +TX_C_BEGIN +TX_API TX_RESULT TX_CALLCONVENTION txGetGazePointDataEventParams( + TX_CONSTHANDLE hBehavior, + TX_GAZEPOINTDATAEVENTPARAMS* pEventParams + ); +TX_C_END + +typedef TX_RESULT (TX_CALLCONVENTION *GetGazePointDataEventParamsHook)( + TX_CONSTHANDLE hBehavior, + TX_GAZEPOINTDATAEVENTPARAMS* pEventParams + ); + + +/*********************************************************************************************************************/ + +/** + txSetGazeAwareBehaviorParams + + Sets TX_GAZEAWAREPARAMS for a gaze aware behavior. + + @param hBehavior [in]: + A TX_HANDLE to the behavior on which to set the parameters. + Must not be TX_EMPTY_HANDLE. + + @param pParams [in]: + A pointer to a TX_GAZEAWAREPARAMS which specifies the behavior parameters. + Must not be NULL. + + @return + TX_RESULT_OK: The parameters was successfully set. + TX_RESULT_EYEXNOTINITIALIZED: The EyeX client environment is not initialized. + TX_RESULT_INVALIDARGUMENT: An invalid argument was passed to the function. + TX_RESULT_INVALIDBEHAVIORTYPE: The behavior was not of type TX_BEHAVIORTYPE_GAZEAWARE. + */ +TX_C_BEGIN +TX_API TX_RESULT TX_CALLCONVENTION txSetGazeAwareBehaviorParams( + TX_HANDLE hBehavior, + const TX_GAZEAWAREPARAMS* pParams + ); +TX_C_END + +typedef TX_RESULT (TX_CALLCONVENTION *SetGazeAwareBehaviorParamsHook)( + TX_HANDLE hBehavior, + const TX_GAZEAWAREPARAMS* pParams + ); + + +/*********************************************************************************************************************/ + +/** + txGetGazeAwareBehaviorParams + + Gets the TX_GAZEAWAREPARAMS for gaze point data behavior. + + @param hBehavior [in]: + A TX_CONSTHANDLE to the behavior from which the parameter will be retrieved. + Must not be TX_EMPTY_HANDLE. + + @param pParams [out]: + A pointer to a TX_GAZEAWAREPARAMS which will be set to the behavior parameters. + Must not be NULL. + + @return + TX_RESULT_OK: The parameters was successfully retrieved. + TX_RESULT_EYEXNOTINITIALIZED: The EyeX client environment is not initialized. + TX_RESULT_INVALIDARGUMENT: An invalid argument was passed to the function. + TX_RESULT_INVALIDBEHAVIORTYPE: The behavior was not of type TX_BEHAVIORTYPE_GAZEAWARE. + */ +TX_C_BEGIN +TX_API TX_RESULT TX_CALLCONVENTION txGetGazeAwareBehaviorParams( + TX_CONSTHANDLE hBehavior, + TX_GAZEAWAREPARAMS* pParams + ); +TX_C_END + +typedef TX_RESULT (TX_CALLCONVENTION *GetGazeAwareBehaviorParamsHook)( + TX_CONSTHANDLE hBehavior, + TX_GAZEAWAREPARAMS* pParams + ); + + +/*********************************************************************************************************************/ + +/** + txGetGazeAwareBehaviorEventParams + + Gets the TX_GAZEAWAREEVENTPARAMS for a gaze-aware behavior. + + @param hBehavior [in]: + A TX_CONSTHANDLE to the behavior from which the event parameters will be retrieved. + Must not be TX_EMPTY_HANDLE. + + @param pEventParams [out]: + A pointer to a TX_GAZEAWAREEVENTPARAMS which will be set to the behavior event parameters. + Must not be NULL. + + @return + TX_RESULT_OK: The parameters was successfully retrieved. + TX_RESULT_EYEXNOTINITIALIZED: The EyeX client environment is not initialized. + TX_RESULT_INVALIDARGUMENT: An invalid argument was passed to the function. + TX_RESULT_INVALIDBEHAVIORTYPE: The behavior was not of type TX_BEHAVIORTYPE_GAZEAWARE. + */ +TX_C_BEGIN +TX_API TX_RESULT TX_CALLCONVENTION txGetGazeAwareBehaviorEventParams( + TX_CONSTHANDLE hBehavior, + TX_GAZEAWAREEVENTPARAMS* pEventParams + ); +TX_C_END + +typedef TX_RESULT (TX_CALLCONVENTION *GetGazeAwareBehaviorEventParamsHook)( + TX_CONSTHANDLE hBehavior, + TX_GAZEAWAREEVENTPARAMS* pEventParams + ); + + +/*********************************************************************************************************************/ + +/** + txSetFixationDataBehaviorParams + + Gets the TX_FIXATIONDATAPARAMS for a fixation behavior. + + @param hBehavior [in]: + A TX_HANDLE to the behavior on which the parameters will be set. + Must not be TX_EMPTY_HANDLE. + + @param pParams [in]: + A pointer to a TX_FIXATIONDATAPARAMS which will be set to the behavior parameters. + Must not be NULL. + + @return + TX_RESULT_OK: The parameters was successfully set. + TX_RESULT_EYEXNOTINITIALIZED: The EyeX client environment is not initialized. + TX_RESULT_INVALIDARGUMENT: An invalid argument was passed to the function. + TX_RESULT_INVALIDBEHAVIORTYPE: The behavior is not of type TX_Behavior_FIXATIONDATA. + */ +TX_C_BEGIN +TX_API TX_RESULT TX_CALLCONVENTION txSetFixationDataBehaviorParams( + TX_HANDLE hBehavior, + const TX_FIXATIONDATAPARAMS* pParams + ); +TX_C_END + +typedef TX_RESULT (TX_CALLCONVENTION *SetFixationDataBehaviorParamsHook)( + TX_HANDLE hBehavior, + const TX_FIXATIONDATAPARAMS* pParams + ); + + +/*********************************************************************************************************************/ + +/** + txGetFixationDataBehaviorParams + + Gets the TX_FIXATIONDATAPARAMS for a fixation behavior. + + @param hBehavior [in]: + A TX_CONSTHANDLE to the behavior from which the parameters will be retrieved. + Must not be TX_EMPTY_HANDLE. + + @param pParams [out]: + A pointer to a TX_FIXATIONDATAPARAMS which will be set to the behavior parameters. + Must not be NULL. + + @return + TX_RESULT_OK: The parameters was successfully retrieved. + TX_RESULT_EYEXNOTINITIALIZED: The EyeX client environment is not initialized. + TX_RESULT_INVALIDARGUMENT: An invalid argument was passed to the function. + TX_RESULT_INVALIDBEHAVIORTYPE: The behavior is not of type TX_Behavior_FIXATIONDATA. + */ +TX_C_BEGIN +TX_API TX_RESULT TX_CALLCONVENTION txGetFixationDataBehaviorParams( + TX_CONSTHANDLE hBehavior, + TX_FIXATIONDATAPARAMS* pParams + ); +TX_C_END + +typedef TX_RESULT (TX_CALLCONVENTION *GetFixationDataBehaviorParamsHook)( + TX_CONSTHANDLE hBehavior, + TX_FIXATIONDATAPARAMS* pParams + ); + + +/*********************************************************************************************************************/ + +/** + txGetFixationDataEventParams + + Gets the TX_FIXATIONDATAEVENTPARAMS for a fixation behavior. + + @param hBehavior [in]: + A TX_CONSTHANDLE to the behavior from which the event parameters will be retrieved. + Must not be TX_EMPTY_HANDLE. + + @param pEventParams [out]: + A pointer to a TX_FIXATIONDATAEVENTPARAMS which will be set to the behavior event parameters. + Must not be NULL. + + @return + TX_RESULT_OK: The event parameters was successfully retrieved. + TX_RESULT_EYEXNOTINITIALIZED: The EyeX client environment is not initialized. + TX_RESULT_INVALIDARGUMENT: An invalid argument was passed to the function. + TX_RESULT_INVALIDBEHAVIORTYPE: The behavior is not of type TX_BEHAVIORTYPE_FIXATIONDATA. + */ +TX_C_BEGIN +TX_API TX_RESULT TX_CALLCONVENTION txGetFixationDataEventParams( + TX_CONSTHANDLE hBehavior, + TX_FIXATIONDATAEVENTPARAMS* pEventParams + ); +TX_C_END + +typedef TX_RESULT (TX_CALLCONVENTION *GetFixationDataEventParamsHook)( + TX_CONSTHANDLE hBehavior, + TX_FIXATIONDATAEVENTPARAMS* pEventParams + ); + + +/*********************************************************************************************************************/ + +/** + txGetEyePositionDataEventParams + + Gets the TX_EYEPOSITIONDATAEVENTPARAMS for an eye position behavior. + + @param hBehavior [in]: + A TX_CONSTHANDLE to the behavior from which the event parameters will be retrieved. + Must not be TX_EMPTY_HANDLE. + + @param pEventParams [out]: + A pointer to a TX_EYEPOSITIONDATAEVENTPARAMS which will be set to the behavior event parameters. + Must not be NULL. + + @return + TX_RESULT_OK: The event parameters was successfully retrieved. + TX_RESULT_EYEXNOTINITIALIZED: The EyeX client environment is not initialized. + TX_RESULT_INVALIDARGUMENT: An invalid argument was passed to the function. + TX_RESULT_INVALIDBEHAVIORTYPE: The behavior is not of type TX_BEHAVIORTYPE_EYEPOSITIONDATA. + */ +TX_C_BEGIN +TX_API TX_RESULT TX_CALLCONVENTION txGetEyePositionDataEventParams( + TX_CONSTHANDLE hBehavior, + TX_EYEPOSITIONDATAEVENTPARAMS* pEventParams + ); +TX_C_END + +typedef TX_RESULT (TX_CALLCONVENTION *GetEyePositionDataEventParamsHook)( + TX_CONSTHANDLE hBehavior, + TX_EYEPOSITIONDATAEVENTPARAMS* pEventParams + ); + + +/*********************************************************************************************************************/ + +/** + txGetBehaviorEventTimestamp + + Gets the timestamp of when the behavior was created, in milliseconds. + Not to be confused with data timestamps, which deals with when + the data was captured by the tracker (e.g. TX_GAZEPOINTDATAEVENTPARAMS - Timestamp) + + @param hBehavior [in]: + A TX_CONSTHANDLE to the behavior from which the timestamp will be retrieved. + Must not be TX_EMPTY_HANDLE. + + @param pTimestamp [out]: + A pointer to a TX_REAL which will be set to the behavior event Timestamp. + Must not be NULL. + + @return + TX_RESULT_OK: The timestamp was successfully retrieved. + TX_RESULT_EYEXNOTINITIALIZED: The EyeX client environment is not initialized. + TX_RESULT_INVALIDARGUMENT: An invalid argument was passed to the function. + TX_RESULT_NOTFOUND: The timestamp cannot be found for the supplied behavior. + */ + TX_C_BEGIN +TX_API TX_RESULT TX_CALLCONVENTION txGetBehaviorEventTimestamp( + TX_CONSTHANDLE hBehavior, + TX_REAL* pTimestamp + ); +TX_C_END + +typedef TX_RESULT (TX_CALLCONVENTION *GetBehaviorEventTimestampHook)( + TX_CONSTHANDLE hBehavior, + TX_REAL* pTimestamp + ); + + + +/*********************************************************************************************************************/ + +#endif /* !defined(__TOBII_TX_BEHAVIOR_API__H__) */ + +/*********************************************************************************************************************/ diff --git a/Tobii-EyeX/include/eyex/EyeXBounds.h b/Tobii-EyeX/include/eyex/EyeXBounds.h new file mode 100755 index 0000000..1c0a4eb --- /dev/null +++ b/Tobii-EyeX/include/eyex/EyeXBounds.h @@ -0,0 +1,292 @@ +/********************************************************************************************************************* + * Copyright 2013-2014 Tobii Technology AB. All rights reserved. + * EyeXBounds.h + *********************************************************************************************************************/ + +#if !defined(__TOBII_TX_BOUNDS_API__H__) +#define __TOBII_TX_BOUNDS_API__H__ + +/*********************************************************************************************************************/ + +/** + txGetBoundsType + + Gets the TX_BOUNDSTYPE of an interaction bounds object. + + @param hBounds [in]: + A TX_CONSTHANDLE to the bounds. + Must not be TX_EMPTY_HANDLE. + + @param pBoundsType [out]: + A pointer to a TX_BOUNDSTYPE which will be set to the type of the bounds. + Must not be NULL. + + @return + TX_RESULT_OK: The type of the bounds was successfully retrieved. + TX_RESULT_EYEXNOTINITIALIZED: The EyeX client environment is not initialized. + TX_RESULT_INVALIDARGUMENT: An invalid argument was passed to the function. + */ +TX_C_BEGIN +TX_API TX_RESULT TX_CALLCONVENTION txGetBoundsType( + TX_CONSTHANDLE hBounds, + TX_BOUNDSTYPE* pBoundsType + ); +TX_C_END + +typedef TX_RESULT (TX_CALLCONVENTION *GetBoundsTypeHook)( + TX_CONSTHANDLE hBounds, + TX_BOUNDSTYPE* pBoundsType + ); + + +/*********************************************************************************************************************/ + +/** + txSetRectangularBoundsData + + Sets rectangular bounds data for a bounds object. + + @param hBounds [in]: + A TX_HANDLE to the bounds on which to set the rectangle. + Must not be TX_EMPTY_HANDLE. + + @param x [in]: + Position of left edge of the rectangle. + + @param y [in]: + Position of top edge of the rectangle. + + @param width [in]: + Width of the rectangle. Must not be negative. + + @param height [in]: + Height of the rectangle. Must not be negative. + + @return + TX_RESULT_OK: The rectangular data was successfully set. + TX_RESULT_EYEXNOTINITIALIZED: The EyeX client environment is not initialized. + TX_RESULT_INVALIDARGUMENT: An invalid argument was passed to the function. + TX_RESULT_INVALIDBOUNDSTYPE: The bounds type was invalid, must be TX_BOUNDSTYPE_RECTANGULAR. + */ +TX_C_BEGIN +TX_API TX_RESULT TX_CALLCONVENTION txSetRectangularBoundsData( + TX_HANDLE hBounds, + TX_REAL x, + TX_REAL y, + TX_REAL width, + TX_REAL height + ); +TX_C_END + +typedef TX_RESULT (TX_CALLCONVENTION *SetRectangularBoundsDataHook)( + TX_HANDLE hBounds, + TX_REAL x, + TX_REAL y, + TX_REAL width, + TX_REAL height + ); + + +/*********************************************************************************************************************/ + +/** + txSetRectangularBoundsDataRect + + Sets rectangular bounds data for a bounds object. + + @param hBounds [in]: + A TX_HANDLE to the bounds object on which to set the rectangle. + Must not be TX_EMPTY_HANDLE. + + @param pRect [in]: + A pointer to a TX_RECT which holds the rectangular data. + Must not be NULL. + + @return + TX_RESULT_OK: The rectangular data was successfully set. + TX_RESULT_EYEXNOTINITIALIZED: The EyeX client environment is not initialized. + TX_RESULT_INVALIDARGUMENT: An invalid argument was passed to the function. + TX_RESULT_INVALIDBOUNDSTYPE: The bounds type was invalid, must be TX_BOUNDSTYPE_RECTANGULAR. + */ +TX_C_BEGIN +TX_API TX_RESULT TX_CALLCONVENTION txSetRectangularBoundsDataRect( + TX_HANDLE hBounds, + const TX_RECT* pRect + ); +TX_C_END + +typedef TX_RESULT (TX_CALLCONVENTION *SetRectangularBoundsDataRectHook)( + TX_HANDLE hBounds, + const TX_RECT* pRect + ); + + +/*********************************************************************************************************************/ + +/** + txGetRectangularBoundsData + + Gets rectangular bounds data from a bounds object. + + @param hBounds [in]: + A TX_CONSTHANDLE to the bounds object from which to get the rectangular data. + Must not be TX_EMPTY_HANDLE. + + @param pX [out]: + A pointer to a TX_REAL which will be set to the position of the left edge of the rectangle. + Must not be NULL. + + @param pY [out]: + A pointer to a TX_REAL which will be set to the position of the top edge of the rectangle. + Must not be NULL. + + @param pWidth [out]: + A pointer to a TX_REAL which will be set to the width of the rectangle. + Must not be NULL. + + @param height [out]: + A pointer to a TX_REAL which will be set to the height of the rectangle. + Must not be NULL. + + @return + TX_RESULT_OK: The rectangular data was successfully retrieved. + TX_RESULT_EYEXNOTINITIALIZED: The EyeX client environment is not initialized. + TX_RESULT_INVALIDARGUMENT: An invalid argument was passed to the function. + TX_RESULT_INVALIDBOUNDSTYPE: The bounds type is invalid, must be TX_BOUNDSTYPE_RECTANGULAR. + */ +TX_C_BEGIN +TX_API TX_RESULT TX_CALLCONVENTION txGetRectangularBoundsData( + TX_CONSTHANDLE hBounds, + TX_REAL* pX, + TX_REAL* pY, + TX_REAL* pWidth, + TX_REAL* pHeight + ); +TX_C_END + +typedef TX_RESULT (TX_CALLCONVENTION *GetRectangularBoundsDataHook)( + TX_CONSTHANDLE hBounds, + TX_REAL* pX, + TX_REAL* pY, + TX_REAL* pWidth, + TX_REAL* pHeight + ); + + +/*********************************************************************************************************************/ + +/** + txGetRectangularBoundsDataRect + + Gets rectangular bounds data from a bounds object. + + @param hBounds [in]: + A TX_CONSTHANDLE to the Bounds on which to get the rectangle data. + Must not be TX_EMPTY_HANDLE. + + @param pRect [out]: + A pointer to a TX_RECT which will hold the rectangle data. + Must not be NULL. + + @return + TX_RESULT_OK: The rectangular data was successfully retrieved. + TX_RESULT_EYEXNOTINITIALIZED: The EyeX client environment is not initialized. + TX_RESULT_INVALIDARGUMENT: An invalid argument was passed to the function. + TX_RESULT_INVALIDBOUNDSTYPE: The bounds type is invalid, must be TX_BOUNDSTYPE_RECTANGULAR. + */ +TX_C_BEGIN +TX_API TX_RESULT TX_CALLCONVENTION txGetRectangularBoundsDataRect( + TX_CONSTHANDLE hBounds, + TX_RECT* pRect + ); +TX_C_END + +typedef TX_RESULT (TX_CALLCONVENTION *GetRectangularBoundsDataRectHook)( + TX_CONSTHANDLE hBounds, + TX_RECT* pRect + ); + + +/*********************************************************************************************************************/ + +/** + txBoundsIntersect + + Checks if a bound intersects with a rectangle. + + @param hBounds [in]: + The bounds to check intersection with. + + @param x2 [in]: + The upper left x coordinate of the rectangle + + @param y2 [in]: + The upper left y coordinate of the rectangle + + @param width2 [in]: + The width of the rectangle + + @param height2 [in]: + The height of the rectangle + + @param pIntersects [out] + The intersection test result. Will be non-zero if rectangles intersects. + Must not be NULL. +*/ +TX_C_BEGIN +TX_API TX_RESULT TX_CALLCONVENTION txBoundsIntersect( + TX_CONSTHANDLE hBounds, + TX_REAL x2, + TX_REAL y2, + TX_REAL width2, + TX_REAL height2, + TX_BOOL* pIntersects + ); +TX_C_END + +typedef TX_RESULT (TX_CALLCONVENTION *BoundsIntersectHook)( + TX_CONSTHANDLE hBounds, + TX_REAL x2, + TX_REAL y2, + TX_REAL width2, + TX_REAL height2, + TX_BOOL* pIntersects + ); + + +/*********************************************************************************************************************/ + +/** + txBoundsIntersectRect + + Checks if a bound intersects with a rectangle. + + @param hBounds [in]: + The bounds to check intersection with. + + @param pRect2 [in]: + The rectangle to check intersection with. + + @param pIntersects [out] + The intersection test result. Will be non-zero if rectangles intersects. +*/ +TX_C_BEGIN +TX_API TX_RESULT TX_CALLCONVENTION txBoundsIntersectRect( + TX_CONSTHANDLE hBounds, + const TX_RECT* pRect2, + TX_BOOL* pIntersects + ); +TX_C_END + +typedef TX_RESULT (TX_CALLCONVENTION *BoundsIntersectRectHook)( + TX_CONSTHANDLE hBounds, + const TX_RECT* pRect2, + TX_BOOL* pIntersects + ); + + +/*********************************************************************************************************************/ + +#endif /* !defined(__TOBII_TX_BOUNDS_API__H__) */ + +/*********************************************************************************************************************/ diff --git a/Tobii-EyeX/include/eyex/EyeXClientTypes.h b/Tobii-EyeX/include/eyex/EyeXClientTypes.h new file mode 100755 index 0000000..aa4e43c --- /dev/null +++ b/Tobii-EyeX/include/eyex/EyeXClientTypes.h @@ -0,0 +1,954 @@ +/********************************************************************************************************************* + * Copyright 2013-2014 Tobii Technology AB. All rights reserved. + * EyeXClientTypes.h + *********************************************************************************************************************/ + +#if !defined(__TOBII_TX_CLIENT_TYPES__H__) +#define __TOBII_TX_CLIENT_TYPES__H__ + +/********************************************************************************************************************* + * Common types + *********************************************************************************************************************/ + +typedef void* TX_USERPARAM; +typedef struct txInteractionObject* TX_HANDLE; +typedef const struct txInteractionObject* TX_CONSTHANDLE; +typedef struct txProperty* TX_PROPERTYHANDLE; +typedef const struct txProperty* TX_CONSTPROPERTYHANDLE; +typedef struct txContext* TX_CONTEXTHANDLE; +typedef const struct txContext* TX_CONSTCONTEXTHANDLE; +typedef int TX_TICKET; +typedef int TX_BOOL; +typedef unsigned char TX_BYTE; +typedef int TX_SIZE; +typedef int TX_INTEGER; +typedef double TX_REAL; +typedef char TX_CHAR; +typedef char* TX_STRING; +typedef const char* TX_CONSTSTRING; +typedef void* TX_RAWPTR; +typedef int TX_THREADID; + +/*********************************************************************************************************************/ + +#include "EyeXInternalTypes.h" + +/*********************************************************************************************************************/ + +#define TX_EMPTY_HANDLE 0 +#define TX_INVALID_TICKET 0 + +#define TX_TRUE 1 +#define TX_FALSE 0 + +#define TX_CLEANUPTIMEOUT_DEFAULT 500 +#define TX_CLEANUPTIMEOUT_FORCEIMMEDIATE -1 + +/*********************************************************************************************************************/ + +/** + TX_EYEXCOMPONENTOVERRIDEFLAGS + + Enumeration for all client environment component override flags. + When calling txInitializeEyeX these flags must be combined to specify which components should be overridden. + + @field TX_EYEXCOMPONENTOVERRIDEFLAG_NONE: + No client environment component should be overridden. + + @field TX_EYEXCOMPONENTOVERRIDEFLAG_LOGGINGMODEL: + The logging model should be overridden. + The logging model can be overridden by just specifying some of the standard log targets (see TX_LOGTARGET) or by + a custom user implemented log writer. + + @field TX_EYEXCOMPONENTOVERRIDEFLAG_INTERNAL_MEMORYMODEL: + The memory model should be overridden. For internal use only. + + @field TX_EYEXCOMPONENTOVERRIDEFLAG_INTERNAL_THREADINGMODEL: + The threading model should be overridden. For internal use only. + + @field TX_EYEXCOMPONENTOVERRIDEFLAG_INTERNAL_SCHEDULINGMODEL: + The scheduling model should be overridden. For internal use only. + */ +typedef enum { + TX_EYEXCOMPONENTOVERRIDEFLAG_NONE = TX_FLAGS_NONE_VALUE, + TX_EYEXCOMPONENTOVERRIDEFLAG_LOGGINGMODEL = 1 << 0, + TX_EYEXCOMPONENTOVERRIDEFLAG_INTERNAL_MEMORYMODEL = 1 << 1, + TX_EYEXCOMPONENTOVERRIDEFLAG_INTERNAL_THREADINGMODEL = 1 << 2, + TX_EYEXCOMPONENTOVERRIDEFLAG_INTERNAL_SCHEDULINGMODEL = 1 << 3 +} TX_EYEXCOMPONENTOVERRIDEFLAGS; + +/*********************************************************************************************************************/ + +/** + TX_CONNECTIONSTATE + + Enumeration for all connection states. + These values are used to notify the application of the current connection state. + To receive these notifications the client needs to subscribe using txRegisterConnectionStateChangedHandler and then + call txEnableConnection. + + @field TX_CONNECTIONSTATE_CONNECTED: + The client is now connected to the server. + + @field TX_CONNECTIONSTATE_DISCONNECTED: + The client is now disconnected from the server. Unless this is due to txDisableConnection being called the client + will shortly attempt to connect again. + + @field TX_CONNECTIONSTATE_TRYINGTOCONNECT: + The client is now trying to connect to the server. This is the first state being sent to the application after + txEnableConnection has been called. + + @field TX_CONNECTIONSTATE_SERVERVERSIONTOOLOW: + the server version is too low. The client is not connected and will not try to reconnect. + + @field TX_CONNECTIONSTATE_SERVERVERSIONTOOHIGH: + the server version is too high. The client is not connected and will not try to reconnect. + */ +typedef enum { + TX_CONNECTIONSTATE_CONNECTED = TX_ENUM_STARTVALUE, + TX_CONNECTIONSTATE_DISCONNECTED, + TX_CONNECTIONSTATE_TRYINGTOCONNECT, + TX_CONNECTIONSTATE_SERVERVERSIONTOOLOW, + TX_CONNECTIONSTATE_SERVERVERSIONTOOHIGH +} TX_CONNECTIONSTATE; + +/*********************************************************************************************************************/ + +/** + TX_LOGTARGET + + Enumeration for all log targets. + When overriding the logging model these flags specify which log targets to use. The flags can be combined. + + @field TX_LOGTARGET_NONE: + No logging should occur at all. + + @field TX_LOGTARGET_CONSOLE: + The log message should be written to the console. + + @field TX_LOGTARGET_TRACE: + The log messages should be traced. (output window i Visual Studio) + + @field TX_LOGTARGET_CUSTOM: + The specified TX_LOGCALLBACK should be invoked for custom logging. + */ +typedef enum { + TX_LOGTARGET_NONE = TX_FLAGS_NONE_VALUE, + TX_LOGTARGET_CONSOLE = 1 << 0, + TX_LOGTARGET_TRACE = 1 << 1, + TX_LOGTARGET_CUSTOM = 1 << 2 +} TX_LOGTARGET; + +/*********************************************************************************************************************/ + +/** + TX_LOGLEVEL + + Enumeration for all log levels. + The log levels are used to indicate the severity of the message. + + @field TX_LOGLEVEL_DEBUG: + The message is just a debug print out typically used during development. + + @field TX_LOGLEVEL_INFO: + The message is plain info and does not indciate that something is wrong. + + @field TX_LOGLEVEL_WARNING: + The message is a warning that indicates that something is not the way it should, not yet critical. + + @field TX_LOGLEVEL_ERROR: + The message indicates that there is some kind of error. + */ +typedef enum { + TX_LOGLEVEL_DEBUG = TX_ENUM_STARTVALUE, + TX_LOGLEVEL_INFO, + TX_LOGLEVEL_WARNING, + TX_LOGLEVEL_ERROR +} TX_LOGLEVEL; + +/*********************************************************************************************************************/ + +/** + TX_SCHEDULINGMODE + + Enumeration for all schedulng modes. + When overriding the scheduling model the mode specifies which of the available scheduling modes to use. + + @field TX_SCHEDULINGMODE_DIRECT: + All jobs are performed immediately on the thread that calls them. + + @field TX_SCHEDULINGMODE_USERFRAME: + All jobs are performed when the txPerformScheduledJobs are called. + + @field TX_SCHEDULINGMODE_CUSTOM: + Whenever a job is to be performed a callback function is invoked giving the client application full control. + */ +typedef enum { + TX_SCHEDULINGMODE_DIRECT = TX_ENUM_STARTVALUE, + TX_SCHEDULINGMODE_USERFRAME, + TX_SCHEDULINGMODE_CUSTOM +} TX_SCHEDULINGMODE; + +/*********************************************************************************************************************/ + +/** + TX_PROPERTYVALUETYPE + + Enumeration for all property value types. + + @field TX_PROPERTYVALUETYPE_EMPTY: + The property does not have a value. + + @field TX_PROPERTYVALUETYPE_OBJECT: + The property currently holds an interaction object. + + @field TX_PROPERTYVALUETYPE_INTEGER: + The property currently holds an integer. + + @field TX_PROPERTYVALUETYPE_REAL: + The property currently holds a real. + + @field TX_PROPERTYVALUETYPE_STRING: + The property currently holds a string. + + @field TX_PROPERTYVALUETYPE_BLOB: + The property currently holds a blob. + */ +typedef enum { + TX_PROPERTYVALUETYPE_EMPTY = TX_ENUM_STARTVALUE, + TX_PROPERTYVALUETYPE_OBJECT, + TX_PROPERTYVALUETYPE_INTEGER, + TX_PROPERTYVALUETYPE_REAL, + TX_PROPERTYVALUETYPE_STRING, + TX_PROPERTYVALUETYPE_BLOB +} TX_PROPERTYVALUETYPE; + +/*********************************************************************************************************************/ + +/** + TX_PROPERTYBAGTYPE + + Enumeration for the all Property Bag types. + + @field TX_PROPERTYBAGTYPE_OBJECT: + The property is a normal object with named properties. + + @field TX_PROPERTYBAGTYPE_ARRAY: + The property bag is an array with sequentially named properties appearing in the order they where inserted. + */ +typedef enum { + TX_PROPERTYBAGTYPE_OBJECT = TX_ENUM_STARTVALUE, + TX_PROPERTYBAGTYPE_ARRAY +} TX_PROPERTYBAGTYPE; + +/*********************************************************************************************************************/ + +/** + TX_EYEXAVAILABILITY + + Enumeration for the availability status of the EyeX Engine. + + @field TX_EYEXAVAILABILITY_NOTAVAILABLE: + EyeX Engine is not installed on the system or otherwise not available. + + @field TX_EYEXAVAILABILITY_NOTRUNNING: + EyeX Engine is not running. + + @field TX_EYEXAVAILABILITY_RUNNING: + EyeX Engine is running. + */ +typedef enum { + TX_EYEXAVAILABILITY_NOTAVAILABLE = TX_ENUM_STARTVALUE, + TX_EYEXAVAILABILITY_NOTRUNNING, + TX_EYEXAVAILABILITY_RUNNING +} TX_EYEXAVAILABILITY; + + +/********************************************************************************************************************* + * Callbacks + *********************************************************************************************************************/ + +/** + Callback for when the connection state is changed. + See txRegisterConnectionStateChangedHandler + + @param state [in]: + Specifies the current state of the connection. + + @param userParam [in]: + The user parameter provided to the txRegisterConnectionStateChangedHandler function. + + @return + void + */ +typedef void (TX_CALLCONVENTION *TX_CONNECTIONSTATECHANGEDCALLBACK)( + TX_CONNECTIONSTATE state, + TX_USERPARAM userParam + ); + +#if defined(__cplusplus) +#ifndef TOBII_TX_INTEROP +#include + + namespace Tx { + typedef std::function ConnectionStateChangedCallback; + } + +#endif +#endif + +/*********************************************************************************************************************/ + +/** + Callback for an asynchronous operations. + + @param hAsyncData [in]: + A TX_CONSTHANDLE to the async data. + + @param userParam [in]: + The user parameter provided to the asynchronous operation. + + @return + void + */ +typedef void (TX_CALLCONVENTION *TX_ASYNCDATACALLBACK)( + TX_CALLBACK_PARAM(TX_CONSTHANDLE) hAsyncData, + TX_USERPARAM userParam + ); + +#if defined(__cplusplus) +#ifndef TOBII_TX_INTEROP +#include + + namespace Tx { + typedef std::function AsyncDataCallback; + } + +#endif +#endif + +/*********************************************************************************************************************/ + +/** + Function run by a thread. + See txInitializeEyeX, TX_THREADINGMODEL + + @param threadWorkerParam [in]: + The user parameter provided to the CreateThreadCallback. + + @return + void + */ +typedef void (TX_CALLCONVENTION *TX_THREADWORKERFUNCTION)( + TX_USERPARAM threadWorkerParam + ); + +/*********************************************************************************************************************/ + +/** + Callback used to create a thread. + See txInitializeEyeX, TX_THREADINGMODEL + + @param worker [in]: + Worker function that will be run by the thread. + + @param threadWorkerParam [in]: + A user parameter passed to worker function. + + @param userParam [in]: + The user parameter provided by the TX_THREADINGMODEL structure. + + @return + TX_THREADID, the id of the created thread. + */ +typedef TX_THREADID (TX_CALLCONVENTION *TX_CREATETHREADCALLBACK)( + TX_THREADWORKERFUNCTION worker, + TX_USERPARAM threadWorkerParam, + TX_USERPARAM userParam + ); + +/*********************************************************************************************************************/ + +/** + Callback used to get the current thread id. + See txInitializeEyeX, TX_THREADINGMODEL + + @param userParam [in]: + The user parameter provided by the TX_THREADINGMODEL structure. + + @return + TX_THREADID, the id of the current thread + */ +typedef TX_THREADID (TX_CALLCONVENTION *TX_GETCURRENTTHREADIDCALLBACK)( + TX_USERPARAM userParam + ); + +/*********************************************************************************************************************/ + +/** + Callback used to join a thread. + See txInitializeEyeX, TX_THREADINGMODEL + + @param threadId [in]: + The id of the thread to join. + + @param userParam [in]: + The user parameter provided by the TX_THREADINGMODEL structure. + + @return + TX_TRUE if the thread was successfully joined. TX_FALSE on non existing thread. + */ +typedef TX_BOOL (TX_CALLCONVENTION *TX_JOINTHREADCALLBACK)( + TX_THREADID threadId, + TX_USERPARAM userParam + ); + +/*********************************************************************************************************************/ + +/** + Callback used to delete a thread. + See txInitializeEyeX, TX_THREADINGMODEL + + @param threadId [in]: + The id of the thread to be deleted. + + @param userParam [in]: + The user parameter provided by the TX_THREADINGMODEL structure. + + @return + TX_TRUE if the thread was successfully deleted, otherwise TX_FALSE. + */ +typedef TX_BOOL (TX_CALLCONVENTION *TX_DELETETHREADCALLBACK)( + TX_THREADID threadId, + TX_USERPARAM userParam + ); + +/*********************************************************************************************************************/ + +/** + Callback used to release a threading model or a logging model. + See SetThreadingModel, SetLoggingModel + + @param userParam [in]: + Normally used for capture outside the scope of the callback. + */ +typedef void (TX_CALLCONVENTION *TX_DELETEMODELCALLBACK)( + TX_USERPARAM userParam + ); + +/*********************************************************************************************************************/ + +/** + Allocator function, used to override allocation of memory + See SetCustomAllocator + + @param length [in]: + Size in bytes of the requested memory block + + @return + void + */ +typedef void (TX_CALLCONVENTION *TX_ALLOCATORFUNCTION)( + TX_INTEGER length + ); + +/*********************************************************************************************************************/ + +/** + Callback for logging. + If a custom logging model is set, see TX_LOGGINGMODEL, this callback will be invoked when a log message is + written by the API. + + @param level [in]: + The level of log message, see TX_LOGLEVEL for levels. + + @param scope [in]: + A string token representing from which part the log message was originated. + + @param message [in]: + The message to be logged. + + @param userParam [in]: + The user parameter provided by the TX_LOGGINGMODEL structure. + + @return + void + */ +typedef void (TX_CALLCONVENTION *TX_LOGCALLBACK)( + TX_LOGLEVEL level, + TX_CONSTSTRING scope, + TX_CONSTSTRING message, + TX_USERPARAM userParam + ); + +/*********************************************************************************************************************/ + +/** + Function provided by the API when a job is scheduled. + See TX_SCHEDULEJOBCALLBACK. + + @param jobParam [in]: + The user parameter provided by the API when a job is scheduled. + + @return + void + */ +typedef void (TX_CALLCONVENTION *TX_PERFORMJOBFUNCTION)( + TX_USERPARAM jobParam + ); + +/*********************************************************************************************************************/ + +/** + Callback for scheduling a job. + If a custom scheduling model is set, see TX_SCHEDULINGMODEL, this callback will be invoked when a job is to be + scheduled. + + @param performJob [in]: + The function to invoke when the job is to be performed. + + @param jobParam [in]: + A parameter used to provide a context to the job. + + @param userParam [in]: + The user parameter provided to the TX_SCHEDULINGMODEL. + + @return + void + */ +typedef void (TX_CALLCONVENTION *TX_SCHEDULEJOBCALLBACK)( + TX_PERFORMJOBFUNCTION performJob, + TX_USERPARAM jobParam, + TX_USERPARAM userParam + ); + +/********************************************************************************************************************* + * Structs + *********************************************************************************************************************/ + +/** + Struct for a rectangle. + + @field X: + The X coordinate for the upper left corner of the rectangle. + + @field Y: + The Y coordinate for the upper left corner of the rectangle. + + @field Width: + The width of the rectangle. + + @field Height: + The height of the rectangle. + */ +typedef struct { + TX_REAL X; + TX_REAL Y; + TX_REAL Width; + TX_REAL Height; +} TX_RECT; + +/*********************************************************************************************************************/ + +/** + Struct for 2D vector. + + @field X: + The X coordinate of the vector. + + @field Y: + The Y coordinate of the vector. + */ +typedef struct { + TX_REAL X; + TX_REAL Y; +} TX_VECTOR2; + + /*********************************************************************************************************************/ + +/** + Struct for 2D size. + + @field Width: + The width of the size. + + @field Height: + The height of the size. + */ +typedef struct { + TX_REAL Width; + TX_REAL Height; +} TX_SIZE2; + +/*********************************************************************************************************************/ + +/** + Struct for pannable behavior parameters. + + @field IsHandsFreeEnabled: + Set to TX_FALSE - hands free panning is not yet implemented. + + @field Profile: + The panning profile. See TX_PANNINGPROFILE. + + @field PeakVelocity: + Currently not used. + + @field PanDirectionsAvailable: + Flags specifying which pan directions are currently possible. See TX_PANDIRECTION. + Correct pan direction flags are needed for panning to work properly. + */ +typedef struct { + TX_BOOL IsHandsFreeEnabled; + TX_PANNINGPROFILE Profile; + TX_REAL PeakVelocity; + TX_PANDIRECTION PanDirectionsAvailable; +} TX_PANNABLEPARAMS; + +/*********************************************************************************************************************/ + +/** + Struct for pannable pan event parameters. + + @field PanVelocityX: + The X velocity for the pan. In pixels per second. + + @field PanVelocityY: + The Y velocity for the pan. In pixels per second. + */ +typedef struct { + TX_REAL PanVelocityX; + TX_REAL PanVelocityY; +} TX_PANNABLEPANEVENTPARAMS; + +/*********************************************************************************************************************/ + +/** + Struct for pannable step event parameters. + + @field PanStepX: + The step length on the X axis in pixels. + + @field PanStepY: + The step length on the Y axis in pixels. + + @field PanStepDuration: + The amount of time in seconds during which the step should be performed. + */ +typedef struct { + TX_REAL PanStepX; + TX_REAL PanStepY; + TX_REAL PanStepDuration; +} TX_PANNABLESTEPEVENTPARAMS; + +/*********************************************************************************************************************/ + +/** + Struct for pannable hands free event parameters. + + @field HandsFreeEnabled: + Specifies if hands free panning is enabled or not. + */ +typedef struct { + TX_BOOL HandsFreeEnabled; +} TX_PANNABLEHANDSFREEEVENTPARAMS; + +/*********************************************************************************************************************/ + +/** + Struct for activatable behavior parameters. + + @field EnableTentativeFocus: + Specifies if tentative focus should be enabled. + @field EnableSmallItemActivation: + Specifies if small item detection should be enabled. + For internal use only. + */ +typedef struct { + TX_BOOL EnableTentativeFocus; + TX_BOOL EnableSmallItemDetection; +} TX_ACTIVATABLEPARAMS; + +/*********************************************************************************************************************/ + +/** + Struct for gaze aware parameters. + + @field GazeAwareMode: + Specifies the gaze aware mode. See TX_GAZEAWAREMODE. + + @field DelayTime: + Specifies the amount of time in milliseconds that the user has to look at an interactor before a gaze aware event + is sent. This value only has an effect if the mode is set to TX_GAZEAWAREMODE_DELAYED. + */ +typedef struct { + TX_GAZEAWAREMODE GazeAwareMode; + TX_REAL DelayTime; +} TX_GAZEAWAREPARAMS; + +/*********************************************************************************************************************/ + +/** + Struct for gaze aware event parameters. + + @field HasGaze: + Specifies if the interactor currently has gaze on it. + */ +typedef struct { + TX_BOOL HasGaze; +} TX_GAZEAWAREEVENTPARAMS; + +/*********************************************************************************************************************/ + +/** + Struct for activation focus changed Params. + + @field HasTentativeActivationFocus: + Specifies if the interactor currently has tentative activation focus. + + @field HasActivationFocus: + Specifies if the interactor currently has activation focus. + */ +typedef struct { + TX_BOOL HasTentativeActivationFocus; + TX_BOOL HasActivationFocus; +} TX_ACTIVATIONFOCUSCHANGEDEVENTPARAMS; + +/*********************************************************************************************************************/ + +/** + Struct for gaze point data behavior parameters. + + @field GazePointDataMode: + Specifies the gaze point data mode. See TX_GAZEPOINTDATAMODE. + */ +typedef struct { + TX_GAZEPOINTDATAMODE GazePointDataMode; +} TX_GAZEPOINTDATAPARAMS; + +/*********************************************************************************************************************/ + +/** + Struct for fixation behavior parameters. + + @field FixationDataMode: + Specifies the fixation data mode. See TX_FIXATIONDATAMODE. + */ +typedef struct { + TX_FIXATIONDATAMODE FixationDataMode; +} TX_FIXATIONDATAPARAMS; + +/*********************************************************************************************************************/ + +/** + Struct for fixation behavior event parameters. + + @field FixationDataMode: + The fixation data mode. See TX_FIXATIONDATAMODE. + + @field EventType: + The type of fixation event. See TX_FIXATIONDATAEVENTTYPE. + + @field Timestamp: + For TX_FIXATIONDATAEVENTTYPE_BEGIN, this is the time when the fixation started, in milliseconds. + For TX_FIXATIONDATAEVENTTYPE_END, this is the time when the fixation ended, in milliseconds. + For TX_FIXATIONDATAEVENTTYPE_DATA, the timestamp for the filtered gaze point provided within + the current fixation, when the filter was applied, in milliseconds. + + @field X: + The current X coordinate of the fixation in pixels. For begin and end events will reflect where the fixation + began or ended. + + @field Y: + The current Y coordinate of the fixation in pixels. For begin and end events will reflect where the fixation + began or ended. + */ +typedef struct { + TX_FIXATIONDATAMODE FixationDataMode; + TX_FIXATIONDATAEVENTTYPE EventType; + TX_REAL Timestamp; + TX_REAL X; + TX_REAL Y; +} TX_FIXATIONDATAEVENTPARAMS; + +/*********************************************************************************************************************/ + +/** + Struct for gaze point data behavior event parameters. + + @field GazePointDataMode: + The gaze point data mode. See TX_GAZEPOINTDATAMODE. + + @field Timestamp: + For TX_GAZEPOINTDATAMODE_LIGHTLYFILTERED this is the point in time when the filter was applied, in milliseconds. + For TX_GAZEPOINTDATAMODE_UNFILTERED this is the point in time time when gazepoint was captured, in milliseconds. + + @field X: + The X coordinate of the gaze point in pixels. + + @field Y: + The Y coordinate of the gaze point in pixels. + */ +typedef struct { + TX_GAZEPOINTDATAMODE GazePointDataMode; + TX_REAL Timestamp; + TX_REAL X; + TX_REAL Y; +} TX_GAZEPOINTDATAEVENTPARAMS; + +/*********************************************************************************************************************/ + +/** + Struct for eye position data behavior event parameters. + + The components of the eye vectors are the relative position of the eyes from the center of the screen in + millimeters on each axis. + + @field Timestamp: + The point in time when the eye position was captured, in milliseconds. + + @field HasLeftEyePosition: + Specifies if the data for the left eye is valid. + + @field HasRightEyePosition: + Specifies if the data for the right eye is valid. + + @field LeftEyeX: + The X coordinate of the left eye in millimeters. + + @field LeftEyeY: + The Y coordinate of the left eye in millimeters. + + @field LeftEyeZ: + The Z coordinate of the left eye in millimeters. + + @field LeftEyeXNormalized: + The X coordinate of the left eye normalized in the track box. + + @field LeftEyeYNormalized: + The Y coordinate of the left eye normalized in the track box. + + @field LeftEyeZNormalized: + The Z coordinate of the left eye normalized in the track box. + + @field RightEyeX: + The X coordinate of the right eye in millimeters. + + @field RightEyeY: + The Y coordinate of the right eye in millimeters. + + @field RightEyeZ: + The Z coordinate of the right eye in millimeters. + + @field RightEyeXNormalized: + The X coordinate of the right eye normalized in the track box. + + @field RightEyeYNormalized: + The Y coordinate of the right eye normalized in the track box. + + @field RightEyeZNormalized: + The Z coordinate of the right eye normalized in the track box. + */ +typedef struct { + TX_REAL Timestamp; + TX_BOOL HasLeftEyePosition; + TX_BOOL HasRightEyePosition; + TX_REAL LeftEyeX; + TX_REAL LeftEyeY; + TX_REAL LeftEyeZ; + TX_REAL LeftEyeXNormalized; + TX_REAL LeftEyeYNormalized; + TX_REAL LeftEyeZNormalized; + TX_REAL RightEyeX; + TX_REAL RightEyeY; + TX_REAL RightEyeZ; + TX_REAL RightEyeXNormalized; + TX_REAL RightEyeYNormalized; + TX_REAL RightEyeZNormalized; +} TX_EYEPOSITIONDATAEVENTPARAMS; + +/*********************************************************************************************************************/ + +/** + Struct for the threading model. + + @field CreateThread: + Callback function used to create a thread. See TX_CREATETHREADCALLBACK. + + @field GetCurrentThreadId: + Callback function used to get the id of the current (calling) thread. See TX_GETCURRENTTHREADIDCALLBACK. + + @field JoinThread: + Callback function used to join a thread. See TX_JOINTHREADCALLBACK. + + @field DeleteThread: + Callback function used to delete a thread. See TX_DELETETHREADCALLBACK. + + @field DeleteModel: + Callback function used to release the threading model. + + @field UserParam: + User parameter which will be passed to the functions. + */ +typedef struct { + TX_CREATETHREADCALLBACK CreateThread; + TX_GETCURRENTTHREADIDCALLBACK GetCurrentThreadId; + TX_JOINTHREADCALLBACK JoinThread; + TX_DELETETHREADCALLBACK DeleteThread; + TX_DELETEMODELCALLBACK DeleteModel; + TX_USERPARAM UserParam; +} TX_THREADINGMODEL; + +/*********************************************************************************************************************/ + +/** + Struct for the logging model. + + @field Targets: + Specifies which log targets to use. See TX_LOGTARGET. + + @field Log: + Callback function used to write a custom log message. See TX_LOGCALLBACK. + + @field DeleteModel: + Callback function used to release the logging model. + + @field UserParam: + User parameter which will be passed to the custom log function. + */ +typedef struct { + TX_LOGTARGET Targets; + TX_LOGCALLBACK Log; + TX_DELETEMODELCALLBACK DeleteModel; + TX_USERPARAM UserParam; +} TX_LOGGINGMODEL; + +/*********************************************************************************************************************/ + +/** + Struct for the scheduling model. + + @field Mode: + Specifies which scheduling mode to use. See TX_SCHEDULINGMODE. + + @field Schedule: + Callback function schedule a work item. See TX_SCHEDULEJOBCALLBACK. + + @field DeleteModel: + Callback function used to release the logging model. + + @field UserParam: + User parameter which will be passed to the custom schedule function. + */ +typedef struct { + TX_SCHEDULINGMODE Mode; + TX_SCHEDULEJOBCALLBACK ScheduleJob; + TX_DELETEMODELCALLBACK DeleteModel; + TX_USERPARAM UserParam; +} TX_SCHEDULINGMODEL; + +/*********************************************************************************************************************/ + +#endif /* !defined(__TOBII_TX_CLIENT_TYPES__H__) */ + +/*********************************************************************************************************************/ diff --git a/Tobii-EyeX/include/eyex/EyeXCommand.h b/Tobii-EyeX/include/eyex/EyeXCommand.h new file mode 100755 index 0000000..0e0002e --- /dev/null +++ b/Tobii-EyeX/include/eyex/EyeXCommand.h @@ -0,0 +1,211 @@ +/********************************************************************************************************************* + * Copyright 2013-2014 Tobii Technology AB. All rights reserved. + * EyeXCommand.h + *********************************************************************************************************************/ + +#if !defined(__TOBII_TX_COMMAND_API__H__) +#define __TOBII_TX_COMMAND_API__H__ + +/*********************************************************************************************************************/ + +/** + txCreateCommand. For internal use only. + + Creates a command. Internal: In first hand, prefer a higher abstraction before + sending raw commands to the engine. + + @param hContext [in]: + A TX_CONTEXTHANDLE to the context on which to create the command. + Must not be TX_EMPTY_HANDLE. + + @param phCommand [out]: + A pointer to a TX_HANDLE which will be set to the newly created command. + This handle must be released using txReleaseObject to avoid leaks. + Must not be NULL. + The value of the pointer must be set to TX_EMPTY_HANDLE. + + @param commandType [in] + The type of the command. + + @return + TX_RESULT_OK: The command was successfully created. + TX_RESULT_EYEXNOTINITIALIZED: The EyeX client environment is not initialized. + TX_RESULT_INVALIDARGUMENT: An invalid argument was passed to the function. + TX_RESULT_INVALIDCONTEXT: The handle to the context was invalid. + */ +TX_C_BEGIN +TX_API TX_RESULT TX_CALLCONVENTION txCreateCommand( + TX_CONTEXTHANDLE hContext, + TX_HANDLE* phCommand, + TX_COMMANDTYPE commandType + ); +TX_C_END + +typedef TX_RESULT (TX_CALLCONVENTION *CreateCommandHook)( + TX_CONTEXTHANDLE hContext, + TX_HANDLE* phCommand, + TX_COMMANDTYPE commandType + ); + + +/*********************************************************************************************************************/ + +/** + txGetCommandType. For internal use only. + + Gets the TX_COMMANDTYPE of a command. + + @param hCommand [in]: + A TX_CONSTHANDLE to the command. + Must not be TX_EMPTY_HANDLE. + + @param pCommandType [out]: + A pointer to a TX_COMMANDTYPE which will be set to the type of the command. + Must not be NULL. + + @return + TX_RESULT_OK: The type of the command was successfully retrieved. + TX_RESULT_EYEXNOTINITIALIZED: The EyeX client environment is not initialized. + TX_RESULT_INVALIDARGUMENT: An invalid argument was passed to the function. + */ +TX_C_BEGIN +TX_API TX_RESULT TX_CALLCONVENTION txGetCommandType( + TX_CONSTHANDLE hCommand, + TX_COMMANDTYPE* pCommandType + ); +TX_C_END + +typedef TX_RESULT (TX_CALLCONVENTION *GetCommandTypeHook)( + TX_CONSTHANDLE hCommand, + TX_COMMANDTYPE* pCommandType + ); + + +/*********************************************************************************************************************/ + +/** + txSetCommandData. For internal use only. + + Sets the data of a command. + If the command already has some object set as data it will be replaced and released. + + @param hCommand [in]: + A TX_HANDLE to the command. + Must not be TX_EMPTY_HANDLE. + + @param hObject [in]: + A TX_HANDLE to the object that should represent the data of the command. + Must not be NULL. + + @return + TX_RESULT_OK: The data of the command was successfully set. + TX_RESULT_EYEXNOTINITIALIZED: The EyeX client environment is not initialized. + TX_RESULT_INVALIDARGUMENT: An invalid argument was passed to the function. + */ +TX_C_BEGIN +TX_API TX_RESULT TX_CALLCONVENTION txSetCommandData( + TX_HANDLE hCommand, + TX_HANDLE hObject + ); +TX_C_END + +typedef TX_RESULT (TX_CALLCONVENTION *SetCommandDataHook)( + TX_HANDLE hCommand, + TX_HANDLE hObject + ); + + +/*********************************************************************************************************************/ + +/** + txGetCommandData. For internal use only. + + Gets the data of a command. + + @param hCommand [in]: + A TX_CONSTHANDLE to the command. + Must not be TX_EMPTY_HANDLE. + + @param phObject [out]: + A pointer to a TX_HANDLE to which the handle of the object used as data will be copied. + This handle must be released using txReleaseObject to avoid leaks. + Must not be NULL. + The value of the pointer must be set to TX_EMPTY_HANDLE. + + @return + TX_RESULT_OK: The data of the command was successfully set. + TX_RESULT_EYEXNOTINITIALIZED: The EyeX client environment is not initialized. + TX_RESULT_INVALIDARGUMENT: An invalid argument was passed to the function. + TX_RESULT_NOTFOUND: The command does not have any data. + */ +TX_C_BEGIN +TX_API TX_RESULT TX_CALLCONVENTION txGetCommandData( + TX_CONSTHANDLE hCommand, + TX_HANDLE* phObject + ); +TX_C_END + +typedef TX_RESULT (TX_CALLCONVENTION *GetCommandDataHook)( + TX_CONSTHANDLE hCommand, + TX_HANDLE* phObject + ); + + +/*********************************************************************************************************************/ + +/** + txExecuteCommandAsync. For internal use only. + + Executes a command asynchronously. + + @param hCommand [in]: + A TX_HANDLE to the command. + Must not be TX_EMPTY_HANDLE. + + @param completionHandler [in]: + The TX_ASYNCDATACALLBACK that will handle the command result. + Can be NULL. + + The data provided by the TX_ASYNCDATACALLBACK will contain a result code which can be retrieved using + txGetAsyncDataResult(). The result code will be one of the follwing: + + TX_RESULT_OK: + The command was succesfully executed on the client. + + TX_RESULT_INVALIDCOMMAND: + The command was rejected by the client. + + TX_RESULT_CANCELLED: + The asynchronous operation was cancelled. + + That handle to the async data must NOT be released. + + @param userParam [in]: + A TX_USERPARAM which will be provided as a parameter to the completion callback. + Can be NULL. + + @return + TX_RESULT_OK: The command was successfully executed. The actual result of the command will be provided to the callback. + TX_RESULT_EYEXNOTINITIALIZED: The EyeX client environment is not initialized. + TX_RESULT_INVALIDARGUMENT: An invalid argument was passed to the function. + */ +TX_C_BEGIN +TX_API TX_RESULT TX_CALLCONVENTION txExecuteCommandAsync( + TX_HANDLE hCommand, + TX_ASYNCDATACALLBACK completionHandler, + TX_USERPARAM userParam + ); +TX_C_END + +typedef TX_RESULT (TX_CALLCONVENTION *ExecuteCommandAsyncHook)( + TX_HANDLE hCommand, + TX_ASYNCDATACALLBACK completionHandler, + TX_USERPARAM userParam + ); + + +/*********************************************************************************************************************/ + +#endif /* !defined(__TOBII_TX_COMMAND_API__H__) */ + +/*********************************************************************************************************************/ diff --git a/Tobii-EyeX/include/eyex/EyeXConstants.h b/Tobii-EyeX/include/eyex/EyeXConstants.h new file mode 100755 index 0000000..59ce248 --- /dev/null +++ b/Tobii-EyeX/include/eyex/EyeXConstants.h @@ -0,0 +1,33 @@ +/********************************************************************************************************************* + * Copyright 2013-2014 Tobii Technology AB. All rights reserved. + * EyeXConstants.h + *********************************************************************************************************************/ + +#if !defined(__TOBII_TX_CONSTANTS__H__) +#define __TOBII_TX_CONSTANTS__H__ + +/*********************************************************************************************************************/ + +/** + * Constants for mask weights. + * + * @field TX_MASKWEIGHT_NONE: + * Use this mask weight to indicate that a region of an interactor has no weight (not interactable). + * + * @field TX_MASKWEIGHT_DEFAULT: + * Use this mask weight to indicate that a region of an interactor has a default weight. + + * @field TX_MASKWEIGHT_HIGH: + * Use this mask weight to indicate that a region of an interactor has a high weight (more likely to be interacted with). + */ + + static const unsigned char None = 0; + static const unsigned char Default = 1; + static const unsigned char High = 255; + + +/*********************************************************************************************************************/ + +#endif /* !defined(__TOBII_TX_CONSTANTS__H__) */ + +/*********************************************************************************************************************/ diff --git a/Tobii-EyeX/include/eyex/EyeXContext.h b/Tobii-EyeX/include/eyex/EyeXContext.h new file mode 100755 index 0000000..1033e14 --- /dev/null +++ b/Tobii-EyeX/include/eyex/EyeXContext.h @@ -0,0 +1,773 @@ +/********************************************************************************************************************* + * Copyright 2013-2014 Tobii Technology AB. All rights reserved. + * EyeXContext.h + *********************************************************************************************************************/ + +#if !defined(__TOBII_TX_CONTEXT_API__H__) +#define __TOBII_TX_CONTEXT_API__H__ + +/*********************************************************************************************************************/ + +/** + txCreateContext + + Creates a new context. + A context represents an environment in which the interaction objects live and a single connection to the client. + Interaction objects may not be shared between contexts. + A context must be cleaned up using txReleaseContext to avoid leaks. + + @param phContext [out]: + A pointer to a TX_CONTEXTHANDLE which will be set to the context. + Must not be NULL. + + @param trackObjects [in]: + Specifies if objects owned by this context should be tracked. + Specifying TX_TRUE will give more information on leaking objects when shutting down but comes with + a performance hit and is not recommended for production builds. + + @return + TX_RESULT_OK: The context was successfully created. + TX_RESULT_EYEXNOTINITIALIZED: The EyeX client environment is not initialized. + TX_RESULT_INVALIDARGUMENT: An invalid argument was passed to the function. +*/ +TX_C_BEGIN +TX_API TX_RESULT TX_CALLCONVENTION txCreateContext( + TX_CONTEXTHANDLE* phContext, + TX_BOOL trackObjects + ); +TX_C_END + +typedef TX_RESULT (TX_CALLCONVENTION *CreateContextHook)( + TX_CONTEXTHANDLE* phContext, + TX_BOOL trackObjects + ); + + +/*********************************************************************************************************************/ + +/** + txReleaseContext + + Releases an existing context. + If not all objects has been released prior to this call then TX_RESULT_OBJECTLEAKAGE will be returned and the context + will not be released. The leaking objects may be retreived using txGetTrackedObjects. + + @param phContext [in,out]: + A pointer to a TX_CONTEXTHANDLE pointing to the context. + If the context is successfully released the value of this pointer will be set to NULL. + Must not be NULL. + + @return + TX_RESULT_OK: The context was successfully released. + TX_RESULT_EYEXNOTINITIALIZED: The EyeX client environment is not initialized. + TX_RESULT_INVALIDARGUMENT: An invalid argument was passed to the function. + TX_RESULT_INVALIDTHREAD: Attempted to call the function from a callback thread. +*/ +TX_C_BEGIN +TX_API TX_RESULT TX_CALLCONVENTION txReleaseContext( + TX_CONTEXTHANDLE* phContext + ); +TX_C_END + +typedef TX_RESULT (TX_CALLCONVENTION *ReleaseContextHook)( + TX_CONTEXTHANDLE* phContext + ); + + +/*********************************************************************************************************************/ + +/** + txShutdownContext + + Shuts down a context. + This call will block until the context has been properly shut down or until the specified timeout has passed. + If any interaction objects are still alive when a context is being shut down this call will block for the specified + timeout waiting for other threads to release the objects. If any objects are still not released after this amount + of time then TX_RESULT_OBJECTLEAKAGE will be returned. The leaking objects may be retreived using txGetTrackedObjects. + + @param hContext [in]: + A TX_CONTEXTHANDLE pointing to the context. + Must not be NULL. + + @param cleanupTimeout [in]: + The amount of time in millseconds to wait for objects to be released. + Use the constant TX_CLEANUPTIMEOUT_DEFAULT for a default timeout of 500 ms. + Use the special value TX_CLEANUPTIMEOUT_FORCEIMMEDIATE to shut down the context immediately, without checking for + leaking objects. + + @param logLeakingObjectsInfo [in]: + Specifies if information about the leaking objects should be logged. To get full details on leaking objects the + context must be set up to track objects when created. + + @return + TX_RESULT_OK: The context was successfully shut down. + TX_RESULT_EYEXNOTINITIALIZED: The EyeX client environment is not initialized. + TX_RESULT_INVALIDARGUMENT: An invalid argument was passed to the function. + TX_RESULT_OBJECTLEAKAGE: All interaction objects have not been released properly. The context was not deleted. + TX_RESULT_INVALIDTHREAD: Attempted to call the function from a callback thread. +*/ +TX_C_BEGIN +TX_API TX_RESULT TX_CALLCONVENTION txShutdownContext( + TX_CONTEXTHANDLE hContext, + TX_INTEGER cleanupTimeout, + TX_BOOL logLeakingObjectsInfo + ); +TX_C_END + +typedef TX_RESULT (TX_CALLCONVENTION *ShutdownContextHook)( + TX_CONTEXTHANDLE hContext, + TX_INTEGER cleanupTimeout, + TX_BOOL logLeakingObjectsInfo + ); + + +/*********************************************************************************************************************/ + +/** + txSetContextName + + Sets the name of a context. This name will only be used when logging messages. This method is typically in debugging scenarios + with multiple contexts. + + @param hContext [in]: + A TX_CONTEXTHANDLE for the context on which to set the name. + Must not be NULL. + + @param name [in]: + The name of the context. + + @return + TX_RESULT_OK: The name of the context was successfully set. + TX_RESULT_EYEXNOTINITIALIZED: The EyeX client environment is not initialized. + TX_RESULT_INVALIDARGUMENT: An invalid argument was passed to the function. +*/ + +TX_C_BEGIN +TX_API TX_RESULT TX_CALLCONVENTION txSetContextName( + TX_CONTEXTHANDLE hContext, + TX_CONSTSTRING name + ); +TX_C_END + +typedef TX_RESULT (TX_CALLCONVENTION *SetContextNameHook)( + TX_CONTEXTHANDLE hContext, + TX_CONSTSTRING name + ); + + +/*********************************************************************************************************************/ + +/** + txSetContextParams + + Sets custom params which gives the context different behaviors. For internal use only. + + @param hContext [in]: + A TX_CONTEXTHANDLE for the context on which to set the parameters. + Must not be NULL. + + @param hParams [in]: + A TX_CONSTHANDLE to an object containing the params. + + @return + TX_RESULT_OK: The params was successfully set. + TX_RESULT_EYEXNOTINITIALIZED: The EyeX client environment is not initialized. + TX_RESULT_INVALIDARGUMENT: An invalid argument was passed to the function. +*/ + +TX_C_BEGIN +TX_API TX_RESULT TX_CALLCONVENTION txSetContextParams( + TX_CONTEXTHANDLE hContext, + TX_CONSTHANDLE hParams + ); +TX_C_END + +typedef TX_RESULT (TX_CALLCONVENTION *SetContextParamsHook)( + TX_CONTEXTHANDLE hContext, + TX_CONSTHANDLE hParams + ); + + +/*********************************************************************************************************************/ + +/** + txGetContextName + + Gets the name of a context. + + @param hContext [in]: + A TX_CONTEXTHANDLE pointing to the context. + Must not be NULL. + + @param pName [out]: + A TX_STRING to which the context name will be copied. + Must be at least the size of the context name. + Can be NULL to only get the size of the context name. + + @param pNameSize [in,out]: + A pointer to a TX_SIZE which will be set the size of the context name. + Must not be NULL. + The value must be 0 if pNameSize is NULL. + + @return + TX_RESULT_OK: The context name or the required size of the string was successfully retrieved. + TX_RESULT_EYEXNOTINITIALIZED: The EyeX client environment is not initialized. + TX_RESULT_INVALIDARGUMENT: An invalid argument was passed to the function. + TX_RESULT_INVALIDBUFFERSIZE: The size of pName is invalid (*pNameSize will be set to the required size). + */ +TX_C_BEGIN +TX_API TX_RESULT TX_CALLCONVENTION txGetContextName( + TX_CONTEXTHANDLE hContext, + TX_STRING pName, + TX_SIZE* pNameSize + ); +TX_C_END + +typedef TX_RESULT (TX_CALLCONVENTION *GetContextNameHook)( + TX_CONTEXTHANDLE hContext, + TX_STRING pName, + TX_SIZE* pNameSize + ); + + +/*********************************************************************************************************************/ + +/** + txGetTrackedObjects + + Gets all the objects that currently tracked by a context. This requires the context to be set up to track objects. + + @param hContext [in]: + A TX_CONSTCONTEXTHANDLE to the context from which to get the tracked objects. + Must not be TX_EMPTY_HANDLE. + + @param phObjects [in]: + A pointer to an array of TX_HANDLEs to which the property handles will be copied. + These handles must be released using txReleaseObject to avoid leaks. + Can be NULL to only retreive the size. + + @param pObjectsSize [in,out]: + A pointer to a TX_SIZE which will be set to the number of objects. + Must not be NULL. + The value must be 0 if phObjects is NULL. + + @return + TX_RESULT_OK: The objects or required sie of the buffer were successfully retrieved. + TX_RESULT_EYEXNOTINITIALIZED: The EyeX client environment is not initialized. + TX_RESULT_INVALIDARGUMENT: An invalid argument was passed to the function. + TX_RESULT_INVALIDBUFFERSIZE: The size of the buffer was to small. (*pObjectSize will be set to the required size.) + TX_RESULT_OBJECTTRACKINGNOTENABLED: The specified context has not been set up to track objects. + */ +TX_C_BEGIN +TX_API TX_RESULT TX_CALLCONVENTION txGetTrackedObjects( + TX_CONSTCONTEXTHANDLE hContext, + TX_HANDLE* phObjects, + TX_SIZE* pObjectsSize + ); +TX_C_END + +typedef TX_RESULT (TX_CALLCONVENTION *GetTrackedObjectsHook)( + TX_CONSTCONTEXTHANDLE hContext, + TX_HANDLE* phObjects, + TX_SIZE* pObjectsSize + ); + + +/*********************************************************************************************************************/ + +/** + txEnableConnection + + Enables the connection to the client. + This method must be called to start the communication between the client and server. + Once the connection has been enabled the client will attempt to always keep it alive. If the connection + to the client for some reason goes down, the client will immediately attemt to reconnect. + See txRegisterConnectionStateChangedHandler to get notified of the current connection state. + + @param hContext [in]: + A TX_CONTEXTHANDLE to the context which should get its connection enabled. + Must not be TX_EMPTY_HANDLE. + + @return + TX_RESULT_OK: The connection was successfully enabled (does not mean that a connection to the client has been established). + TX_RESULT_EYEXNOTINITIALIZED: The EyeX client environment is not initialized. + TX_RESULT_INVALIDARGUMENT: An invalid argument was passed to the function. +*/ +TX_C_BEGIN +TX_API TX_RESULT TX_CALLCONVENTION txEnableConnection( + TX_CONTEXTHANDLE hContext + ); +TX_C_END + +typedef TX_RESULT (TX_CALLCONVENTION *EnableConnectionHook)( + TX_CONTEXTHANDLE hContext + ); + + +/*********************************************************************************************************************/ + +/** + txDisableConnection + + Disables the connection to the client. + + @param hContext [in]: + A TX_CONTEXTHANDLE to the context which should get its connection disabled. + Must not be TX_EMPTY_HANDLE. + + @return + TX_RESULT_OK: The connection was successfully disabled. + TX_RESULT_EYEXNOTINITIALIZED: The EyeX client environment is not initialized. + TX_RESULT_INVALIDARGUMENT: An invalid argument was passed to the function. +*/ +TX_C_BEGIN +TX_API TX_RESULT TX_CALLCONVENTION txDisableConnection( + TX_CONTEXTHANDLE hContext + ); +TX_C_END + +typedef TX_RESULT (TX_CALLCONVENTION *DisableConnectionHook)( + TX_CONTEXTHANDLE hContext + ); + + +/*********************************************************************************************************************/ + +/** + txGetConnectionState + + Gets the current connection state of the context. + + @param hContext [in]: + A TX_CONSTCONTEXTHANDLE to the context from which to retrieve the connection state. + Must not be TX_EMPTY_HANDLE. + + @param pConnectionState [out]: + A pointer to a TX_CONNECTIONSTATE which will get the current connection state. + Must not be NULL. + + @return + TX_RESULT_OK: The current connection state was successfully retrieved. + TX_RESULT_EYEXNOTINITIALIZED: The EyeX client environment is not initialized. + TX_RESULT_INVALIDARGUMENT: An invalid argument was passed to the function. +*/ +TX_C_BEGIN +TX_API TX_RESULT TX_CALLCONVENTION txGetConnectionState( + TX_CONSTCONTEXTHANDLE hContext, + TX_CONNECTIONSTATE* pConnectionState + ); +TX_C_END + +typedef TX_RESULT (TX_CALLCONVENTION *GetConnectionStateHook)( + TX_CONSTCONTEXTHANDLE hContext, + TX_CONNECTIONSTATE* pConnectionState + ); + + +/*********************************************************************************************************************/ + +/** + txRegisterConnectionStateChangedHandler + + Registers a callback which will be invoked when the connection state changes. Use txEnableConnection + to initiate a connection to the engine. + + @param hContext [in]: + A TX_CONTEXTHANDLE to the context on which to register the callback. + Must not be TX_EMPTY_HANDLE. + + @param pTicket [out]: + A pointer to a TX_TICKET which will represent this registration. + This ticket should be used for unregistration. + Must not be NULL. + + @param handler [in]: + A TX_CONNECTIONSTATECHANGEDCALLBACK which will be called when the connection state changes. + Must not be NULL. + + @param userParam [in]: + A TX_USERPARAM which will be provided as a parameter to the callback. + Can be NULL and will in this case be ignored. + + @return + TX_RESULT_OK: The callback was successfully registered. + TX_RESULT_EYEXNOTINITIALIZED: The EyeX client environment is not initialized. + TX_RESULT_INVALIDARGUMENT: An invalid argument was passed to the function. + TX_RESULT_INVALIDTHREAD: Attempted to call the function from a callback thread. +*/ +TX_C_BEGIN +TX_API TX_RESULT TX_CALLCONVENTION txRegisterConnectionStateChangedHandler( + TX_CONTEXTHANDLE hContext, + TX_TICKET* pTicket, + TX_CONNECTIONSTATECHANGEDCALLBACK handler, + TX_USERPARAM userParam + ); +TX_C_END + +typedef TX_RESULT (TX_CALLCONVENTION *RegisterConnectionStateChangedHandlerHook)( + TX_CONTEXTHANDLE hContext, + TX_TICKET* pTicket, + TX_CONNECTIONSTATECHANGEDCALLBACK handler, + TX_USERPARAM userParam + ); + + +/*********************************************************************************************************************/ + +#if defined(__cplusplus) +#ifndef TOBII_TX_INTEROP +#include + + TX_API_FUNCTION_CPP(RegisterConnectionStateChangedHandler,( + TX_CONTEXTHANDLE hContext, + TX_TICKET* pTicket, + const Tx::ConnectionStateChangedCallback& handler)); +#endif +#endif + +/*********************************************************************************************************************/ + +/** + txUnregisterConnectionStateChangedHandler + + Unregisters a callback previously registered for connection state changes. + This function may not be called on a callback thread. + + @param hContext [in]: + A TX_CONTEXTHANDLE to the context on which to unregister the callback. + Must not be TX_EMPTY_HANDLE. + + @param ticket [in]: + A TX_TICKET which represents the registration. + Must not be TX_INVALID_TICKET. + + @return + TX_RESULT_OK: The callback was successfully unregistered. + TX_RESULT_EYEXNOTINITIALIZED: The EyeX client environment is not initialized. + TX_RESULT_INVALIDARGUMENT: An invalid argument was passed to the function. + TX_RESULT_NOTFOUND: A registration for the specified ticket could not be found. + TX_RESULT_INVALIDTHREAD: Attempted to call the function from a callback thread. +*/ +TX_C_BEGIN +TX_API TX_RESULT TX_CALLCONVENTION txUnregisterConnectionStateChangedHandler( + TX_CONTEXTHANDLE hContext, + TX_TICKET ticket + ); +TX_C_END + +typedef TX_RESULT (TX_CALLCONVENTION *UnregisterConnectionStateChangedHandlerHook)( + TX_CONTEXTHANDLE hContext, + TX_TICKET ticket + ); + + +/*********************************************************************************************************************/ + +/** + txRegisterMessageHandler + + Registers a callback to be invoked when a message of a specific type arrives. + This function may not be called on a callback thread. + + @param hContext [in]: + A TX_CONTEXTHANDLE to the context on which to register the callback. + Must not be TX_EMPTY_HANDLE. + + @param pTicket [out]: + A pointer to a TX_TICKET which will represent this registration. + This ticket should be used for unregistration. + Must not be NULL. + + @param messsageType [in]: + The TX_MESSAGETYPE for which to register the callback. + + @param hOptions [in]: + A TX_HANDLE to an interaction object containing the options for this registration. + The following options should be provided for the following message types: + + TX_MESSAGETYPE_QUERY: + - TX_LITERAL_PROCESSID: The id of the process for which to get queries. + + @param handler [in]: + A TX_ASYNCDATACALLBACK which will be called when a message of the specified type arrives. + When this callback is invoked it is passed a parameter hAsyncData which contains the message as its content. + The content of the async data can be retrieved using txGetAsyncDataContent. + That handle to the async data must NOT be released as it is automatically released by the API when the callback returns. + Must not be NULL. + + @param userParam [in]: + A TX_USERPARAM which will be provided as a parameter to the callback. + Can be NULL and will in this case be ignored. + + @return + TX_RESULT_OK: The callback was successfully registered. + TX_RESULT_EYEXNOTINITIALIZED: The EyeX client environment is not initialized. + TX_RESULT_INVALIDARGUMENT: An invalid argument was passed to the function. + TX_RESULT_INVALIDTHREAD: Attempted to call the function from a callback thread. +*/ +TX_C_BEGIN +TX_API TX_RESULT TX_CALLCONVENTION txRegisterMessageHandler( + TX_CONTEXTHANDLE hContext, + TX_TICKET* pTicket, + TX_MESSAGETYPE messageType, + TX_HANDLE hOptions, + TX_ASYNCDATACALLBACK handler, + TX_USERPARAM userParam + ); +TX_C_END + +typedef TX_RESULT (TX_CALLCONVENTION *RegisterMessageHandlerHook)( + TX_CONTEXTHANDLE hContext, + TX_TICKET* pTicket, + TX_MESSAGETYPE messageType, + TX_HANDLE hOptions, + TX_ASYNCDATACALLBACK handler, + TX_USERPARAM userParam + ); + + +/*********************************************************************************************************************/ + +/** + txUnregisterMessageHandler + + Unregisters a callback previously registered as a message handler. + + @param hContext [in]: + A TX_CONTEXTHANDLE to the context on which to unregister the callback. + Must not be TX_EMPTY_HANDLE. + + @param ticket [in]: + A TX_TICKET which represents the registration. + Must not be TX_INVALID_TICKET + + @return + TX_RESULT_OK: The callback was successfully unregistered. + TX_RESULT_EYEXNOTINITIALIZED: The EyeX client environment is not initialized. + TX_RESULT_INVALIDARGUMENT: An invalid argument was passed to the function. + TX_RESULT_NOTFOUND: A registration for the specified ticket could not be found. + TX_RESULT_INVALIDTHREAD: Attempted to call the function from a callback thread. +*/ +TX_C_BEGIN +TX_API TX_RESULT TX_CALLCONVENTION txUnregisterMessageHandler( + TX_CONTEXTHANDLE hContext, + TX_TICKET ticket + ); +TX_C_END + +typedef TX_RESULT (TX_CALLCONVENTION *UnregisterMessageHandlerHook)( + TX_CONTEXTHANDLE hContext, + TX_TICKET ticket + ); + + +/*********************************************************************************************************************/ + +/** + txRegisterQueryHandler + + Registers a query handler. + + This will setup a subscription to receive interactor queries from the engine. + + This is a specialization of txRegisterMessageHandler. + + @param hContext [in]: + A TX_CONTEXTHANDLE to the context on which to register the callback. + Must not be TX_EMPTY_HANDLE. + + @param pTicket [out]: + A pointer to a TX_TICKET which will represent this registration. + This ticket should be used for unregistration. + Must not be NULL. + + @param handler [in]: + A TX_ASYNCDATACALLBACK which will be called when a query arrives. + When this callback is invoked it is passed a parameter hAsyncData which contains the query as its content. + The content of the async data can be retrieved using txGetAsyncDataContent(). + That handle to the async data must NOT be released as it is automatically released by the API when the callback returns. + Must not be NULL. + + @param userParam [in]: + A TX_USERPARAM which will be provided as a parameter to the callback. + + @return + TX_RESULT_OK: The Query Handler was successfully registered. + TX_RESULT_EYEXNOTINITIALIZED: The EyeX client environment is not initialized. + TX_RESULT_INVALIDARGUMENT: An invalid argument was passed to the function. + TX_RESULT_INVALIDTHREAD: Attempted to call the function from a callback thread. + */ +TX_C_BEGIN +TX_API TX_RESULT TX_CALLCONVENTION txRegisterQueryHandler( + TX_CONTEXTHANDLE hContext, + TX_TICKET* pTicket, + TX_ASYNCDATACALLBACK handler, + TX_USERPARAM userParam + ); +TX_C_END + +typedef TX_RESULT (TX_CALLCONVENTION *RegisterQueryHandlerHook)( + TX_CONTEXTHANDLE hContext, + TX_TICKET* pTicket, + TX_ASYNCDATACALLBACK handler, + TX_USERPARAM userParam + ); + + +/*********************************************************************************************************************/ + +/** + txUnregisterQueryHandler + + Unregisters a previously registered query handler callback + This is a specialization of txUnregisterMessageHandler. + + @param hContext [in]: + A TX_CONTEXTHANDLE to the context on which to unregister the callback. + Must not be TX_EMPTY_HANDLE. + + @param ticket [in]: + A TX_TICKET which represents the registration. + Must not be TX_INVALID_TICKET + + @return + TX_RESULT_OK: The callback was successfully unregistered. + TX_RESULT_EYEXNOTINITIALIZED: The EyeX client environment is not initialized. + TX_RESULT_INVALIDARGUMENT: An invalid argument was passed to the function. + TX_RESULT_NOTFOUND: A registration for the specified ticket could not be found. + TX_RESULT_INVALIDTHREAD: Attempted to call the function from a callback thread. +*/ +TX_C_BEGIN +TX_API TX_RESULT TX_CALLCONVENTION txUnregisterQueryHandler( + TX_CONTEXTHANDLE hContext, + TX_TICKET ticket + ); +TX_C_END + +typedef TX_RESULT (TX_CALLCONVENTION *UnregisterQueryHandlerHook)( + TX_CONTEXTHANDLE hContext, + TX_TICKET ticket + ); + + +/*********************************************************************************************************************/ + +/** + txRegisterEventHandler + + Registers an event handler. This will setup a subscription to receive interaction events + from the engine. + + This is a specialization of txRegisterMessageHandler. + + @param hContext [in]: + A TX_CONTEXTHANDLE to the context on which to register the callback. + Must not be TX_EMPTY_HANDLE. + + @param pTicket [out]: + A pointer to a TX_TICKET which will represent this registration. + This ticket should be used for unregistration. + Must not be NULL. + + @param handler [in]: + A TX_ASYNCDATACALLBACK which will be called when an event arrives. + When this callback is invoked it is passed a parameter hAsyncData which contains the event as its content. + The content of the async data can be retrieved using txGetAsyncDataContent(). + That handle to the async data must NOT be released as it is automatically released by the API when the callback returns. + Must not be NULL. + + @param userParam [in]: + A TX_USERPARAM which will be provided as a parameter to the callback. + + @return + TX_RESULT_OK: The event handler was successfully registered. + TX_RESULT_EYEXNOTINITIALIZED: The EyeX client environment is not initialized. + TX_RESULT_INVALIDARGUMENT: An invalid argument was passed to the function. + TX_RESULT_INVALIDTHREAD: Attempted to call the function from a callback thread. + */ +TX_C_BEGIN +TX_API TX_RESULT TX_CALLCONVENTION txRegisterEventHandler( + TX_CONTEXTHANDLE hContext, + TX_TICKET* pTicket, + TX_ASYNCDATACALLBACK handler, + TX_USERPARAM userParam + ); +TX_C_END + +typedef TX_RESULT (TX_CALLCONVENTION *RegisterEventHandlerHook)( + TX_CONTEXTHANDLE hContext, + TX_TICKET* pTicket, + TX_ASYNCDATACALLBACK handler, + TX_USERPARAM userParam + ); + + +/*********************************************************************************************************************/ + +/** + txUnregisterEventHandler + + Unregisters a previously registered event handler callback + This is a specialization of txUnregisterMessageHandler. + + @param hContext [in]: + A TX_CONTEXTHANDLE to the context on which to unregister the callback. + Must not be TX_EMPTY_HANDLE. + + @param ticket [in]: + A TX_TICKET which represents the registration. + Must not be TX_INVALID_TICKET + + @return + TX_RESULT_OK: The callback was successfully unregistered. + TX_RESULT_EYEXNOTINITIALIZED: The EyeX client environment is not initialized. + TX_RESULT_INVALIDARGUMENT: An invalid argument was passed to the function. + TX_RESULT_NOTFOUND: A registration for the specified ticket could not be found. + TX_RESULT_INVALIDTHREAD: Attempted to call the function from a callback thread. +*/ +TX_C_BEGIN +TX_API TX_RESULT TX_CALLCONVENTION txUnregisterEventHandler( + TX_CONTEXTHANDLE hContext, + TX_TICKET ticket + ); +TX_C_END + +typedef TX_RESULT (TX_CALLCONVENTION *UnregisterEventHandlerHook)( + TX_CONTEXTHANDLE hContext, + TX_TICKET ticket + ); + + +/*********************************************************************************************************************/ + +/** + txPerformScheduledJobs + + Performs all jobs scheduled by the API on the thread that calls this function. + This call will block until all jobs have been performed. For internal use only. + + @param hContext [in]: + A TX_CONTEXTHANDLE to the context which jobs should be performed. + + @return + TX_RESULT_OK: The callback was successfully unregistered. + TX_RESULT_EYEXNOTINITIALIZED: The EyeX client environment is not initialized. + TX_RESULT_INVALIDARGUMENT: An invalid argument was passed to the function. + TX_RESULT_INVALIDSCHEDULINGMODE: The scheduling mode must be set TX_SCHEDULINGMODE_USERFRAME for this call to be valid. + */ +TX_C_BEGIN +TX_API TX_RESULT TX_CALLCONVENTION txPerformScheduledJobs( + TX_CONTEXTHANDLE hContext + ); +TX_C_END + +typedef TX_RESULT (TX_CALLCONVENTION *PerformScheduledJobsHook)( + TX_CONTEXTHANDLE hContext + ); + + +/*********************************************************************************************************************/ + +#endif /* !defined(__TOBII_TX_CONTEXT_API__H__) */ + +/*********************************************************************************************************************/ diff --git a/Tobii-EyeX/include/eyex/EyeXEnv.h b/Tobii-EyeX/include/eyex/EyeXEnv.h new file mode 100755 index 0000000..68d3256 --- /dev/null +++ b/Tobii-EyeX/include/eyex/EyeXEnv.h @@ -0,0 +1,236 @@ +/********************************************************************************************************************* + * Copyright 2013-2014 Tobii Technology AB. All rights reserved. + * EyeXEnv.h + *********************************************************************************************************************/ + +#if !defined(__TOBII_TX_ENV_API__H__) +#define __TOBII_TX_ENV_API__H__ + +/*********************************************************************************************************************/ + +/** + txInitializeEyeX + + Initializes the Tobii EyeX client environment. + This function must be called prior to any other in the API, except txGetEyeXAvailability and txEnableMonoCallbacks. + A client can choose to override the default memory model, threading model and logging model by supplying custom models + to this function. + + @param flags [in]: + Specifies which components to override. + + @param pLoggingModel [in]: + A pointer to a TX_LOGGINGMODEL which will override the default model. + This argument can be NULL to use the default logging model. + + @param pThreadingModel [in]: + A pointer to a TX_THREADINGMODEL which will override the default model. + This argument can be NULL to use the default threading model. Any + non-NULL value is for internal use only. + + @param pSchedulingModel [in]: + A pointer to a TX_SCHEDULINGMODEL which will override the default model. + This argument can be NULL to use the default scheduling model. Any + non-NULL value is for internal use only. + + @param pMemoryModel [in]: + Reserved for future use. + + @return + TX_RESULT_OK: The client environment was successfully initialized. + TX_RESULT_INVALIDARGUMENT: An invalid argument was passed to the function. + TX_RESULT_EYEXALREADYINITIALIZED: The EyeX client environment is already initialized. + */ +TX_C_BEGIN +TX_API TX_RESULT TX_CALLCONVENTION txInitializeEyeX( + TX_EYEXCOMPONENTOVERRIDEFLAGS flags, + const TX_LOGGINGMODEL* pLoggingModel, + const TX_THREADINGMODEL* pThreadingModel, + const TX_SCHEDULINGMODEL* pSchedulingModel, + void* pMemoryModel + ); +TX_C_END + +typedef TX_RESULT (TX_CALLCONVENTION *InitializeEyeXHook)( + TX_EYEXCOMPONENTOVERRIDEFLAGS flags, + const TX_LOGGINGMODEL* pLoggingModel, + const TX_THREADINGMODEL* pThreadingModel, + const TX_SCHEDULINGMODEL* pSchedulingModel, + void* pMemoryModel + ); + + +/*********************************************************************************************************************/ + +/** + txUninitializeEyeX + + Uninitializes the EyeX client environment. + If any context is still active this call will fail. + + @return + TX_RESULT_OK: The client environment was successfully uninitialized. + TX_RESULT_EYEXNOTINITIALIZED: The client environment is not initialized. + TX_RESULT_EYEXSTILLINUSE: The EyeX client environment is still in use. + */ +TX_C_BEGIN +TX_API TX_RESULT TX_CALLCONVENTION txUninitializeEyeX(); +TX_C_END + +typedef TX_RESULT (TX_CALLCONVENTION *UninitializeEyeXHook)(); + + +/*********************************************************************************************************************/ + +/** + txIsEyeXInitialized + + Checks if the EyeX client environment has been initialized. + + @param pInitialized [out]: + A pointer to a TX_BOOL which will be set to true if the environment is initialized and false otherwise. + Must not be NULL. + + @return + TX_RESULT_OK: The operation was successful. + */ +TX_C_BEGIN +TX_API TX_RESULT TX_CALLCONVENTION txIsEyeXInitialized( + TX_BOOL* pInitialized + ); +TX_C_END + +typedef TX_RESULT (TX_CALLCONVENTION *IsEyeXInitializedHook)( + TX_BOOL* pInitialized + ); + + +/*********************************************************************************************************************/ + +/** + txWriteLogMessage + + Writes a message using the internal logging model. + This method is typically not intended for end users but rather for the different language bindings to have a common + way of utilizing the logging model. + + @param level [in]: + The log level for this message. + + @param scope [in]: + The scope for this message. + + @param message [in]: + The log message it self. + + @return + TX_RESULT_OK: The message was successfully written to the log. + TX_RESULT_EYEXNOTINITIALIZED: The EyeX client environment is not initialized. + TX_RESULT_INVALIDARGUMENT: An invalid argument was passed to the function. + */ +TX_C_BEGIN +TX_API TX_RESULT TX_CALLCONVENTION txWriteLogMessage( + TX_LOGLEVEL level, + TX_CONSTSTRING scope, + TX_CONSTSTRING message + ); +TX_C_END + +typedef TX_RESULT (TX_CALLCONVENTION *WriteLogMessageHook)( + TX_LOGLEVEL level, + TX_CONSTSTRING scope, + TX_CONSTSTRING message + ); + + +/*********************************************************************************************************************/ +/** + txSetInvalidArgumentHandler + + Sets a hook that notifies when an invalid argument has been passed to any of the API function. + This function should typically only be used for testing purposes. + + @param handler [in]: + The callback to be invoked when an invalid argument is detected. + + @param userParam [in]: + A TX_USERPARAM which will be provided as a parameter to the callback. + Can be NULL and will in this case be ignored. + + @return + TX_RESULT_OK: The invalid argument handler was successful set. + */ +TX_C_BEGIN +TX_API TX_RESULT TX_CALLCONVENTION txSetInvalidArgumentHandler( + TX_INVALIDARGUMENTCALLBACK handler, + TX_USERPARAM userParam + ); +TX_C_END + +typedef TX_RESULT (TX_CALLCONVENTION *SetInvalidArgumentHandlerHook)( + TX_INVALIDARGUMENTCALLBACK handler, + TX_USERPARAM userParam + ); + + +/*********************************************************************************************************************/ +/** + txEnableMonoCallbacks + + Prepares the EyeX client library for use with the Mono .NET runtime: before a callback function is invoked, the + thread on which the callback will be made is attached to a mono domain, and the thread is detached again when the + callback function returns. Mono requires that any threads calling managed code be attached for garbage collection + and soft debugging to work properly. + + This function must be called prior to any other in the API, and from a managed thread. The subsequent callback + invocations will be attached to the same mono domain as the caller thread. + + Note that Mono callbacks cannot be used in combination with a custom threading model. + + @param monoModuleName [in]: + The name of the Mono runtime module (dll). Typically "mono". + + @return + TX_RESULT_OK: The mono callbacks were successfully enabled. + TX_RESULT_INVALIDARGUMENT: The Mono module name could not be used to resolve the necessary Mono functions. + */ +TX_C_BEGIN +TX_API TX_RESULT TX_CALLCONVENTION txEnableMonoCallbacks( + TX_CONSTSTRING monoModuleName + ); +TX_C_END + +typedef TX_RESULT (TX_CALLCONVENTION *EnableMonoCallbacksHook)( + TX_CONSTSTRING monoModuleName + ); + + +/*********************************************************************************************************************/ +/** + txGetEyeXAvailability + + Gets the availability of the EyeX Engine. + + @param pEyeXAvailability [out]: + The availability of EyeX Engine. + + @return + TX_RESULT_OK: The status was fetched successfully. + TX_RESULT_INVALIDARGUMENT: An invalid argument was supplied. + */ +TX_C_BEGIN +TX_API TX_RESULT TX_CALLCONVENTION txGetEyeXAvailability( + TX_EYEXAVAILABILITY* pEyeXAvailability + ); +TX_C_END + +typedef TX_RESULT (TX_CALLCONVENTION *GetEyeXAvailabilityHook)( + TX_EYEXAVAILABILITY* pEyeXAvailability + ); + + +/*********************************************************************************************************************/ + +#endif /* !defined(__TOBII_TX_ENV_API__H__) */ + +/*********************************************************************************************************************/ diff --git a/Tobii-EyeX/include/eyex/EyeXEvent.h b/Tobii-EyeX/include/eyex/EyeXEvent.h new file mode 100755 index 0000000..446fc4f --- /dev/null +++ b/Tobii-EyeX/include/eyex/EyeXEvent.h @@ -0,0 +1,139 @@ +/********************************************************************************************************************* + * Copyright 2013-2014 Tobii Technology AB. All rights reserved. + * EyeXEvent.h + *********************************************************************************************************************/ + +#if !defined(__TOBII_TX_EVENT_API__H__) +#define __TOBII_TX_EVENT_API__H__ + +/*********************************************************************************************************************/ + +/** + txGetEventInteractorId + + Gets the id of the interactor for which the event should apply. + + @param hEvent [in]: + A TX_CONSTHANDLE to the event from which the interactor id should be retrieved. + Must not be TX_EMPTY_HANDLE. + + @param pInteractorId [out]: + A TX_STRING to which the interactor id will be copied. + Must be at least the size of the interactor id. + Can be NULL to only get the size of the interactor. + + @param pInteractorIdSize [in,out]: + A pointer to a TX_SIZE which will be set to the size of the interactor id. + Must not be NULL. + The value must be 0 if pInteractorId is NULL. + + @return + TX_RESULT_OK: The interactor id or the required size of the string was successfully retrieved. + TX_RESULT_EYEXNOTINITIALIZED: The EyeX client environment is not initialized. + TX_RESULT_INVALIDARGUMENT: An invalid argument was passed to the function. + TX_RESULT_INVALIDBUFFERSIZE: The size of pInteractorId is invalid (*pInteractorIdSize will be set to the required size). + */ +TX_C_BEGIN +TX_API TX_RESULT TX_CALLCONVENTION txGetEventInteractorId( + TX_CONSTHANDLE hEvent, + TX_STRING pInteractorId, + TX_SIZE* pInteractorIdSize + ); +TX_C_END + +typedef TX_RESULT (TX_CALLCONVENTION *GetEventInteractorIdHook)( + TX_CONSTHANDLE hEvent, + TX_STRING pInteractorId, + TX_SIZE* pInteractorIdSize + ); + + +/*********************************************************************************************************************/ + +/** + txGetEventBehavior + + Gets a behavior with a specified TX_BEHAVIORTYPE from an event. + If the event does not have a behavior of the specified type this call will fail. + + @param hEvent [in]: + A TX_CONSTHANDLE to the event from which the behavior should be retrieved. + Must not be TX_EMPTY_HANDLE. + + @param phBehavior [out]: + A pointer to a TX_HANDLE which will be set to the behavior. + This handle must be released using txReleaseObject to avoid leaks. + Must not be NULL. + The value of the pointer must be set to TX_EMPTY_HANDLE. + + @param behaviorType [in]: + The TX_BEHAVIORTYPE which specifies what type of behavior to get. + + @return + TX_RESULT_OK: The behavior was successfully retrieved. + TX_RESULT_EYEXNOTINITIALIZED: The EyeX client environment is not initialized. + TX_RESULT_INVALIDARGUMENT: An invalid argument was passed to the function. + TX_RESULT_NOTFOUND: This event does not have a behavior of the specified type. + */ +TX_C_BEGIN +TX_API TX_RESULT TX_CALLCONVENTION txGetEventBehavior( + TX_CONSTHANDLE hEvent, + TX_HANDLE* phBehavior, + TX_BEHAVIORTYPE behaviorType + ); +TX_C_END + +typedef TX_RESULT (TX_CALLCONVENTION *GetEventBehaviorHook)( + TX_CONSTHANDLE hEvent, + TX_HANDLE* phBehavior, + TX_BEHAVIORTYPE behaviorType + ); + + +/*********************************************************************************************************************/ + +/** + txGetEventBehaviors + + Gets the TX_HANDLEs to all the behaviors on an event. + + @param hEvent [in]: + A TX_CONSTHANDLE to the event from which to get the behaviors. + Must not be TX_EMPTY_HANDLE. + + @param phBehaviors [out]: + A pointer to an array of TX_HANDLEs to which the behavior handles will be copied. + These handles must be released using txReleaseObject to avoid leaks. + Can be NULL to only get the required size. + + @param pBehaviorsSize [in,out]: + A pointer to a TX_SIZE which will be set to the number of behaviors. + Must not be NULL. + The value must be 0 if phBehaviors is NULL. + + @return + TX_RESULT_OK: The handles or the required size of the buffer was retrieved successfully. + TX_RESULT_EYEXNOTINITIALIZED: The EyeX client environment is not initialized. + TX_RESULT_INVALIDARGUMENT: An invalid argument was passed to the function. + TX_RESULT_INVALIDBUFFERSIZE: The size of the array is invalid. (*pBehaviorsSize will be set to the number of behaviors). + */ +TX_C_BEGIN +TX_API TX_RESULT TX_CALLCONVENTION txGetEventBehaviors( + TX_CONSTHANDLE hEvent, + TX_HANDLE* phBehaviors, + TX_SIZE* pBehaviorsSize + ); +TX_C_END + +typedef TX_RESULT (TX_CALLCONVENTION *GetEventBehaviorsHook)( + TX_CONSTHANDLE hEvent, + TX_HANDLE* phBehaviors, + TX_SIZE* pBehaviorsSize + ); + + +/*********************************************************************************************************************/ + +#endif /* !defined(__TOBII_TX_EVENT_API__H__) */ + +/*********************************************************************************************************************/ diff --git a/Tobii-EyeX/include/eyex/EyeXFrameworkTypes.h b/Tobii-EyeX/include/eyex/EyeXFrameworkTypes.h new file mode 100755 index 0000000..614c070 --- /dev/null +++ b/Tobii-EyeX/include/eyex/EyeXFrameworkTypes.h @@ -0,0 +1,967 @@ +/********************************************************************************************************************* + * Copyright 2013-2014 Tobii Technology AB. All rights reserved. + * EyeXFrameworkTypes.h + *********************************************************************************************************************/ + +#if !defined(__TOBII_TX_FRAMEWORK_TYPES__H__) +#define __TOBII_TX_FRAMEWORK_TYPES__H__ + +/*********************************************************************************************************************/ + +#include "EyeXMacros.h" + +/*********************************************************************************************************************/ + +/** + TX_RESULT + + Enumeration for all result codes returned by the API functions. + + @field TX_RESULT_UNKNOWN: + Unknown error, typically returned if something unexpected occurs in the API. Is most likely a bug in the API. + + @field TX_RESULT_OK: + Everything went well. + + @field TX_RESULT_EYEXNOTINITIALIZED: + The EyeX client environment is not initalized. All API functions except txInitializeEyeX requires the EyeX client environment to be + initialized prior to being called. + + @field TX_RESULT_EYEXALREADYINITIALIZED: + The EyeX client environment has already been initialized. This is returned by txInitializeEyeX if called twice without being + uninitialized in between. + + @field TX_RESULT_EYEXSTILLINUSE: + The EyeX client environment is still in use. This is returned by txUninitializeEyeX if at least one context is still being used. + + @field TX_RESULT_INVALIDARGUMENT: + An invalid argument was passed to an API function. All arguments are checked before an API function actually + does something. There are many reasons why an argument can be considered invalid. + Check the log for more details if this code is returned. + + @field TX_RESULT_INVALIDHANDLE: + The handle for an interaction object is not valid. + + @field TX_RESULT_NOTFOUND: + Generic result code when something could not be found. + + @field TX_RESULT_INVALIDBUFFERSIZE: + Some buffer; string, array, etc had an invalid size. Typically, API functions that return this result code also + provides the required size. + + @field TX_RESULT_DUPLICATEPROPERTY: + An attempt has been made to create a property that does already exist. + + @field TX_RESULT_DUPLICATEBOUNDS: + An attempt has been made to create bounds that already exists. + + @field TX_RESULT_DUPLICATEBEHAVIOR: + An attempt has been made to create a behavior that already exists. + + @field TX_RESULT_DUPLICATEINTERACTOR: + An attempt has been made to create an interactor with the same id as another in the same snapshot. + + @field TX_RESULT_DUPLICATESTATEOBSERVER: + An attempt has been made to register the same state observer twice. + + @field TX_RESULT_DUPLICATEMASK: + An attempt has been made to create more than one mask on an interactor. + + @field TX_RESULT_INVALIDPROPERTYTYPE: + A type specific operation has been made on a property of a different type. For example a property containing a + TX_INTEGER has been requested for its value as a TX_STRING. + + @field TX_RESULT_INVALIDPROPERTYNAME: + The specified property name is invalid. + + @field TX_RESULT_PROPERTYNOTREMOVABLE: + An attempt has been made to remove a property that is not removable. Typically such properties are the ones + backing up data that is required on different interaction objects. + + @field TX_RESULT_NOTCONNECTED: + An attempt was made to perform an operation that requires a valid connection to the client. + + @field TX_RESULT_INVALIDOBJECTCAST: + A handle for a different type of interaction object than expected was provided. + + @field TX_RESULT_INVALIDTHREAD: + An attempt was made to perform an operation on a thread that is not allowed to perform such an operation. + For example a context can not be deleted on a callback from the API. + + @field TX_RESULT_INVALIDBOUNDSTYPE: + An attempt was made to perform an operation that does not apply to the current bounds type. + + @field TX_RESULT_INVALIDBEHAVIORTYPE: + An attempt was made to perform an operation that does not apply to the current behavior type. + + @field TX_RESULT_OBJECTLEAKAGE: + A leakage of an interaction object has been detected. May be returned by a + successful txReleaseContext call where some object were not released properly. + + @field TX_RESULT_OBJECTTRACKINGNOTENABLED: + An attempt to retrieve tracked object has been made without tracking of objects being enabled. + + @field TX_RESULT_INVALIDSNAPSHOT: + The snapshot committed to the client contained some invalid data. + + @field TX_RESULT_INVALIDCOMMAND: + The submitted command was malformed or not recognized by the client. + + @field TX_RESULT_CANCELLED: + An attempt has been made to perform an operation that is not supported during shutdown. + + @field TX_RESULT_INVALIDSCHEDULINGMODE: + The scheduling mode is invalid. + + @field TX_RESULT_MASKTOOLARGE: + The supplied mask is too large, width*height must be less than 65536 + + @field TX_RESULT_INVALIDEYETRACKERSTATE + \since Version 1.1.0 + The submitted command can not be executed in the current state of the eye tracker + */ +typedef enum { + TX_RESULT_UNKNOWN = TX_ENUM_STARTVALUE, + TX_RESULT_OK, + TX_RESULT_EYEXNOTINITIALIZED, + TX_RESULT_EYEXALREADYINITIALIZED, + TX_RESULT_EYEXSTILLINUSE, + TX_RESULT_INVALIDARGUMENT, + TX_RESULT_INVALIDHANDLE, + TX_RESULT_NOTFOUND, + TX_RESULT_INVALIDBUFFERSIZE, + TX_RESULT_DUPLICATEPROPERTY, + TX_RESULT_DUPLICATEBOUNDS, + TX_RESULT_DUPLICATEBEHAVIOR, + TX_RESULT_DUPLICATEINTERACTOR, + TX_RESULT_DUPLICATESTATEOBSERVER, + TX_RESULT_DUPLICATEMASK, + TX_RESULT_INVALIDPROPERTYTYPE, + TX_RESULT_INVALIDPROPERTYNAME, + TX_RESULT_PROPERTYNOTREMOVABLE, + TX_RESULT_NOTCONNECTED, + TX_RESULT_INVALIDOBJECTCAST, + TX_RESULT_INVALIDTHREAD, + TX_RESULT_INVALIDBOUNDSTYPE, + TX_RESULT_INVALIDBEHAVIORTYPE, + TX_RESULT_OBJECTLEAKAGE, + TX_RESULT_OBJECTTRACKINGNOTENABLED, + TX_RESULT_INVALIDSNAPSHOT, + TX_RESULT_INVALIDCOMMAND, + TX_RESULT_CANCELLED, + TX_RESULT_INVALIDSCHEDULINGMODE, + TX_RESULT_MASKTOOLARGE, + TX_RESULT_INVALIDEYETRACKERSTATE +} TX_RESULT; + +/********************************************************************************************************************* + * Interaction Object Types + *********************************************************************************************************************/ + +/** + Enumeration for all the types of interaction objects that can be exposed through the API. + + @field TX_INTERACTIONOBJECTTYPE_SNAPSHOT: + The object is a snapshot. + + @field TX_INTERACTIONOBJECTTYPE_INTERACTOR: + The object is an interactor. + + @field TX_INTERACTIONOBJECTTYPE_QUERY: + The object is a query. + + @field TX_INTERACTIONOBJECTTYPE_EVENT: + The object is an event. + + @field TX_INTERACTIONOBJECTTYPE_BEHAVIOR: + The object is a behavior. + + @field TX_INTERACTIONOBJECTTYPE_BOUNDS: + The object is a bounds structure. + + @field TX_INTERACTIONOBJECTTYPE_PROPERTYBAG: + The object is a property bag. + + @field TX_INTERACTIONOBJECTTYPE_PROPERTY: + The object is a property. + + @field TX_INTERACTIONOBJECTTYPE_COMMAND: + The object is a command. + + @field TX_INTERACTIONOBJECTTYPE_STATEBAG: + The object is a state bag. + + @field TX_INTERACTIONOBJECTTYPE_NOTIFICATION: + The object is a notification. + + @field TX_INTERACTIONOBJECTTYPE_MASK: + The object is a mask. + */ +typedef enum { + TX_INTERACTIONOBJECTTYPE_SNAPSHOT = TX_ENUM_STARTVALUE, + TX_INTERACTIONOBJECTTYPE_INTERACTOR, + TX_INTERACTIONOBJECTTYPE_QUERY, + TX_INTERACTIONOBJECTTYPE_EVENT, + TX_INTERACTIONOBJECTTYPE_BEHAVIOR, + TX_INTERACTIONOBJECTTYPE_BOUNDS, + TX_INTERACTIONOBJECTTYPE_PROPERTYBAG, + TX_INTERACTIONOBJECTTYPE_COMMAND, + TX_INTERACTIONOBJECTTYPE_STATEBAG, + TX_INTERACTIONOBJECTTYPE_NOTIFICATION, + TX_INTERACTIONOBJECTTYPE_MASK, + TX_INTERACTIONOBJECTTYPE_ASYNCDATA, + + /* for internal use only */ + TX_INTERACTIONOBJECTTYPE_INTERNAL_MESSAGE = TX_INTERNAL_ENUM_STARTVALUE, + TX_INTERACTIONOBJECTTYPE_INTERNAL_MESSAGEHEADER +} TX_INTERACTIONOBJECTTYPE; + +/*********************************************************************************************************************/ + +/** + TX_MESSAGETYPE + + Enumeration for all message types. + The messages type is metadata contained by all packets sent between the client and server. + Some messages should be handled by the application to do proper interaction, others are internal and should be + ignored. + + @field TX_MESSAGETYPE_QUERY: + Message contains a query. + + @field TX_MESSAGETYPE_EVENT: + Message contains an event. + + @field TX_MESSAGETYPE_NOTIFICATION: + Message contains a notification. This is an internal message type. + + @field TX_MESSAGETYPE_REQUEST: + Message contains a request. This is an internal message type. + + @field TX_MESSAGETYPE_RESPONSE: + Message contains a response. This is an internal message type. + + @field TX_MESSAGETYPE_CUSTOM: + Base value for custom message defined by other protocols. + */ +typedef enum { + TX_MESSAGETYPE_QUERY = TX_ENUM_STARTVALUE, + TX_MESSAGETYPE_EVENT, + TX_MESSAGETYPE_NOTIFICATION = TX_INTERNAL_ENUM_STARTVALUE, + TX_MESSAGETYPE_REQUEST, + TX_MESSAGETYPE_RESPONSE, + TX_MESSAGETYPE_CUSTOM +} TX_MESSAGETYPE; + +/*********************************************************************************************************************/ + +/** + TX_NOTIFICATIONTYPE + + Enumeration for all notification types. + The notification type is metadata contained by all notifications to specify what kind of notification it is. + + @field TX_NOTIFICATIONTYPE_STATECHANGED: + Notifies that some states have changed. + */ +typedef enum { + TX_NOTIFICATIONTYPE_STATECHANGED = TX_ENUM_STARTVALUE, + TX_NOTIFICATIONTYPE_DIAGNOSTICSDATA +} TX_NOTIFICATIONTYPE; + +/*********************************************************************************************************************/ + +/** + TX_BEHAVIORTYPE + + Enumeration for all behavior types. + The behavior type is metadata contained by all behaviors to specify what kind of behavior it is. + + @field TX_BEHAVIORTYPE_GAZEPOINTDATA: + Behavior used on interactors to receive gaze point data. + + @field TX_BEHAVIORTYPE_EYEPOSITIONDATA: + Behavior used on interactors to receive eye position data. + + @field TX_BEHAVIORTYPE_GAZEAWARE: + Behavior used on interactors to perform gaze-aware interaction. + + @field TX_BEHAVIORTYPE_ACTIVATABLE: + Behavior used on interactors to perform activation interaction. + + @field TX_BEHAVIORTYPE_PANNABLE: + Behavior used on interactors to perform panning interaction. + + @field TX_BEHAVIORTYPE_FIXATIONDATA: + Behavior used on interactors to receive fixation data. + */ +typedef enum { + TX_BEHAVIORTYPE_GAZEPOINTDATA = TX_ENUM_STARTVALUE, + TX_BEHAVIORTYPE_EYEPOSITIONDATA, + TX_BEHAVIORTYPE_GAZEAWARE, + TX_BEHAVIORTYPE_ACTIVATABLE, + TX_BEHAVIORTYPE_PANNABLE, + TX_BEHAVIORTYPE_FIXATIONDATA, + /* For Internal use */ + TX_INTERNAL_BEHAVIORTYPE_RAWGAZEDATA = TX_INTERNAL_ENUM_STARTVALUE, + TX_INTERNAL_BEHAVIORTYPE_ZOOMABLE, + TX_BEHAVIORTYPE_GAZEDATADIAGNOSTICS +} TX_BEHAVIORTYPE; + +/*********************************************************************************************************************/ + +/** + TX_BOUNDSTYPE + + Enumeration for all bounds types. + + @field TX_BOUNDSTYPE_NONE: + No bounds. + + @field TX_BOUNDSTYPE_RECTANGULAR: + Rectangular bounds. + */ +typedef enum { + TX_BOUNDSTYPE_NONE = TX_ENUM_STARTVALUE, + TX_BOUNDSTYPE_RECTANGULAR +} TX_BOUNDSTYPE; + +/*********************************************************************************************************************/ + +/** + TX_ACTIVATABLEEVENTTYPE + + Enumeration for all activation event types. + Activatable event type are metadata contained by all behaviors of type TX_BEHAVIORTYPE_ACTIVATABLE sent + from the client. This event type specifies what kind of activation event actually happened. + + @field TX_ACTIVATABLEEVENTTYPE_ACTIVATED: + The interactor has been activated. + + @field TX_ACTIVATABLEEVENTTYPE_ACTIVATIONFOCUSCHANGED: + The activation focus and/or tentative activation focus has changed. + */ +typedef enum { + TX_ACTIVATABLEEVENTTYPE_ACTIVATED = TX_ENUM_STARTVALUE, + TX_ACTIVATABLEEVENTTYPE_ACTIVATIONFOCUSCHANGED +} TX_ACTIVATABLEEVENTTYPE; + +/*********************************************************************************************************************/ + +/** + TX_FAILEDACTIONTYPE + + Enumeration for all action data types. + + @field TX_FAILEDACTIONTYPE_ACTIVATIONNOHIT + An activation action did not hit any valid interactor + @field TX_FAILEDACTIONTYPE_PANNOHIT + A pan action did not hit any valid interactor + @field TX_FAILEDACTIONTYPE_ZOOMNOHIT + A zoom action did not hit any valid interactor + @field TX_FAILEDACTIONTYPE_ACTIVATIONDURINGNOTRACKING + An activation action occured when there was no tracking + @field TX_FAILEDACTIONTYPE_PANDURINGNOTRACKING + A pan action occured when there was no tracking + @field TX_FAILEDACTIONTYPE_ZOOMDURINGNOTRACKING + A zoom action occured when there was no tracking + @field TX_FAILEDACTIONTYPE_ACTIVATIONSMALLITEMS + For internal use only. + An activation occured near multiple small interactors and was therefore undecided + */ +typedef enum { + TX_FAILEDACTIONTYPE_ACTIVATIONNOHIT = TX_ENUM_STARTVALUE, + TX_FAILEDACTIONTYPE_PANNOHIT, + TX_FAILEDACTIONTYPE_ZOOMNOHIT, + TX_FAILEDACTIONTYPE_ACTIVATIONDURINGNOTRACKING, + TX_FAILEDACTIONTYPE_PANDURINGNOTRACKING, + TX_FAILEDACTIONTYPE_ZOOMDURINGNOTRACKING, + TX_FAILEDACTIONTYPE_ACTIVATIONSMALLITEMS +} TX_FAILEDACTIONTYPE; + +/*********************************************************************************************************************/ + +/** + TX_FIXATIONDATAEVENTTYPE + + Enumeration for all fixation data event types. + Fixation event type is metadata contained by all behaviors of type TX_BEHAVIORTYPE_FIXATION sent + from the client. This event type specifies what kind of fixation event actually happened. + + @field TX_FIXATIONDATAEVENTTYPE_BEGIN: + The fixation has begun. The gaze point data provided is a combination of the gaze points used to detect the + fixation. The timestamp will reflect when the fixation actually began. + + @field TX_FIXATIONDATAEVENTTYPE_END: + The fixation has ended. The last valid gaze point is provided. The timestamp will reflect when the + fixation actually ended. + + @field TX_FIXATIONDATAEVENTTYPE_DATA: + The fixation is still occuring. A new, filtered gaze point within the fixation is provided. + */ +typedef enum { + TX_FIXATIONDATAEVENTTYPE_BEGIN = TX_ENUM_STARTVALUE, + TX_FIXATIONDATAEVENTTYPE_END, + TX_FIXATIONDATAEVENTTYPE_DATA +} TX_FIXATIONDATAEVENTTYPE; + +/*********************************************************************************************************************/ + +/** + TX_GAZEPOINTDATAMODE + + Enumeration for all gaze point data modes. + The gaze point data mode is metadata contained by all behaviors of type TX_BEHAVIORTYPE_GAZEPOINTDATA. + When put on an interactor it specifies what kind of filter to use by the engine when calculating the gaze points. + When put on an event it specifies what kind of filter that was used by the engine. + + @field TX_GAZEPOINTDATAMODE_UNFILTERED: + No filter will be applied to the gaze points. (note though that invalid gaze points are discarded) + + @field: TX_GAZEPOINTDATAMODE_LIGHTLYFILTERED: + A light filter was/will be applied to the gaze point data. It is not a simple smoothing filter, it aims to be + smooth but responsive. This should be you default choice for gaze point data. + */ +typedef enum { + TX_GAZEPOINTDATAMODE_UNFILTERED = TX_ENUM_STARTVALUE, + TX_GAZEPOINTDATAMODE_LIGHTLYFILTERED +} TX_GAZEPOINTDATAMODE; + + +/*********************************************************************************************************************/ + +/** + TX_GAZEAWAREMODE + + Enumeration for all gaze aware modes. + The gaze aware mode is metadata contained by all behaviors of type TX_BEHAVIORTYPE_GAZEAWARE. + When put on an interactor it specifies how the user must gaze on the interactor to make it gaze aware. + When put on an event it specifies what kind of mode that was used by the engine. + + @field: TX_GAZEAWAREMODE_NORMAL: + The interactor will get a gaze aware event when the engine considers the user to intentionally look at it. + + @field: TX_GAZEAWAREMODE_DELAYED: + The interactor will get a gaze aware event when the engine considers the user to have looked at it for a + specified amount of time. When using this mode TX_GAZEAWAREPARAMS needs have the field DelayTime set. + */ +typedef enum { + TX_GAZEAWAREMODE_NORMAL = TX_ENUM_STARTVALUE, + TX_GAZEAWAREMODE_DELAYED +} TX_GAZEAWAREMODE; + +/*********************************************************************************************************************/ + +/** + TX_FIXATIONDATAMODE + + Enumeration for all fixation data modes. + The fixation data mode is metadata contained by all behaviors of type TX_BEHAVIORTYPE_FIXATION. + When put on an interactor it specifies what kind of filter to use by the engine when finding fixations. + When put on an event it specifies what kind of filter that was used by the engine. + + @field TX_FIXATIONDATAMODE_SENSITIVE: + Very sensitive fixation filter, will result in many fixations, sometimes very close and in quick succession. + + @field TX_FIXATIONDATAMODE_SLOW: + Fairly sensitive to enter fixation but can be slow to exit, as it tries merge fixations close to each other. + Will result in fairly stable fixations but fixation end events may be coming rather late in certain circumstances. + */ +typedef enum { + TX_FIXATIONDATAMODE_SENSITIVE = TX_ENUM_STARTVALUE, + TX_FIXATIONDATAMODE_SLOW +} TX_FIXATIONDATAMODE; + +/*********************************************************************************************************************/ + +/** + TX_EYETRACKINGDEVICESTATUS + + Enumeration for all eye tracking device statuses. + + @field TX_EYETRACKINGDEVICESTATUS_INITIALIZING: + The eye tracking device is initializing. + + @field TX_EYETRACKINGDEVICESTATUS_NOTAVAILABLE: + There is no eye tracking device available. + + @field TX_EYETRACKINGDEVICESTATUS_INVALIDCONFIGURATION: + The eye tracking device has an invalid configuration. + + @field TX_EYETRACKINGDEVICESTATUS_DEVICENOTCONNECTED: + The eye tracking device is not connected. + + @field TX_EYETRACKINGDEVICESTATUS_TRACKING: + The eye tracking device is currently tracking. + + @field TX_EYETRACKINGDEVICESTATUS_TRACKINGPAUSED: + The eye tracking device is paused. + + @field TX_EYETRACKINGDEVICESTATUS_CONFIGURING: + The eye tracking device is being configured. + + @field TX_EYETRACKINGDEVICESTATUS_UNKNOWNERROR: + Unknown error. + + @field TX_EYETRACKINGDEVICESTATUS_CONNECTIONERROR: + The eye tracking device is connected to USB port but EyeX Engine can not connect to it. + + @field TX_EYETRACKINGDEVICESTATUS_TRACKINGUNAVAILABLE: + The eye tracking device is functioning as intended, but no gaze data is sent. + */ +typedef enum { + TX_EYETRACKINGDEVICESTATUS_INITIALIZING = TX_ENUM_STARTVALUE, + TX_EYETRACKINGDEVICESTATUS_NOTAVAILABLE, + TX_EYETRACKINGDEVICESTATUS_INVALIDCONFIGURATION, + TX_EYETRACKINGDEVICESTATUS_DEVICENOTCONNECTED, + TX_EYETRACKINGDEVICESTATUS_TRACKING, + TX_EYETRACKINGDEVICESTATUS_TRACKINGPAUSED, + TX_EYETRACKINGDEVICESTATUS_CONFIGURING, + TX_EYETRACKINGDEVICESTATUS_UNKNOWNERROR, + TX_EYETRACKINGDEVICESTATUS_CONNECTIONERROR, + TX_EYETRACKINGDEVICESTATUS_TRACKINGUNAVAILABLE +} TX_EYETRACKINGDEVICESTATUS; + +/*********************************************************************************************************************/ + +/** + Enumeration for all command types. For internal use only. + */ +typedef enum { + TX_COMMANDTYPE_EXECUTEACTION = TX_ENUM_STARTVALUE, + TX_COMMANDTYPE_SETSTATE, + TX_COMMANDTYPE_GETSTATE, + TX_COMMANDTYPE_REGISTERSTATEOBSERVER, + TX_COMMANDTYPE_UNREGISTERSTATEOBSERVER, + TX_COMMANDTYPE_COMMITSNAPSHOT, + TX_COMMANDTYPE_ENABLEBUILTINKEYS, + TX_COMMANDTYPE_DISABLEBUILTINKEYS, + TX_COMMANDTYPE_CLIENTCONNECTION, + TX_COMMANDTYPE_LAUNCHEYETRACKINGCONTROLPANEL, /** Deprecated */ + TX_COMMANDTYPE_REGISTERQUERYHANDLER, + TX_COMMANDTYPE_UNREGISTERQUERYHANDLER, + TX_COMMANDTYPE_DIAGNOSTICSREQUEST, + TX_COMMANDTYPE_LAUNCHCONFIGURATIONTOOL, + TX_COMMANDTYPE_SETCURRENTPROFILE, + TX_COMMANDTYPE_DELETEPROFILE, + TX_COMMANDTYPE_CLIENTPROCESSIDLIST + + +} TX_COMMANDTYPE; + +/*********************************************************************************************************************/ + +/** + Enumeration for all action types. + An action is a way to interact with the EyeX Engine in addition or instead of the default keybindings that normally + executes gaze actions. + + @field TX_ACTIONTYPE_ACTIVATE: + Activates an interactor. This corresponds to a click on the activation button + + @field TX_ACTIONTYPE_ACTIVATIONMODEON: + Turns on activation mode. This corresponds to pressing the activation button. + + @field TX_ACTIONTYPE_ACTIVATIONMODEOFF: + Turns off activation mode. This corresponds to releasing the activation button. + + @field TX_ACTIONTYPE_PANNINGBEGIN: + Begins a panning. This corresponds to pressing the panning button. + + @field TX_ACTIONTYPE_PANNINGEND: + Ends a panning. This corresponds to releasing the panning button. + + @field TX_ACTIONTYPE_PANNINGSTEP: + Performs a panning step action. This corresponds to a click on the panning button. + + @field TX_ACTIONTYPE_ZOOMIN: + Not yet supported. + + @field TX_ACTIONTYPE_ZOOMOUT: + Not yet supported. + + @field TX_ACTIONTYPE_PANNINGTOGGLEHANDSFREE: + Not yet supported. + */ +typedef enum { + TX_ACTIONTYPE_ACTIVATE = TX_ENUM_STARTVALUE, + TX_ACTIONTYPE_ACTIVATIONMODEON, + TX_ACTIONTYPE_ACTIVATIONMODEOFF, + TX_ACTIONTYPE_PANNINGBEGIN, + TX_ACTIONTYPE_PANNINGEND, + TX_ACTIONTYPE_PANNINGSTEP, + TX_ACTIONTYPE_ZOOMIN, + TX_ACTIONTYPE_ZOOMOUT, + TX_ACTIONTYPE_PANNINGTOGGLEHANDSFREE +} TX_ACTIONTYPE; + +/*********************************************************************************************************************/ + +/** + TX_PANNABLEEVENTTYPE + + Enumeration for all pannable event types. + Pannable event type are metadata contained by all behaviors of type TX_BEHAVIORTYPE_PANNABLE sent + from the client. This event type specifies what kind of pannable event actually happened. + + @field TX_PANNABLEEVENTTYPE_PAN: + The interactor has been panned. + + @field TX_PANNABLEEVENTTYPE_STEP: + The interactor has been stepped. + + @field TX_PANNABLEEVENTTYPE_HANDSFREE: + Not yet supported. + */ +typedef enum { + TX_PANNABLEEVENTTYPE_PAN = TX_ENUM_STARTVALUE, + TX_PANNABLEEVENTTYPE_STEP, + TX_PANNABLEEVENTTYPE_HANDSFREE +} TX_PANNABLEEVENTTYPE; + + +/*********************************************************************************************************************/ + +/** + TX_PANDIRECTION + + Enumeration flags for all pannable directions. + Governs available directions to pan for a pannable interactor. + The directions are bitwise combinable. + + @field TX_PANDIRECTION_NONE: + No pandirection available. + + @field TX_PANDIRECTION_LEFT: + Panning to the left available. + + @field TX_PANDIRECTION_RIGHT: + Panning to the right available. + + @field TX_PANDIRECTION_UP: + Panning up available. + + @field TX_PANDIRECTION_DOWN: + Panning down available. + + @field TX_PANDIRECTION_ALL: + All pan directions available. + */ +typedef enum { + TX_PANDIRECTION_NONE = TX_FLAGS_NONE_VALUE, + TX_PANDIRECTION_LEFT = 1, + TX_PANDIRECTION_RIGHT = 1 << 1, + TX_PANDIRECTION_UP = 1 << 2, + TX_PANDIRECTION_DOWN = 1 << 3, + TX_PANDIRECTION_ALL = (1 << 4)-1 +} TX_PANDIRECTION; + +/*********************************************************************************************************************/ + +/** + TX_PANNINGPROFILE + + Enumeration for all panning profiles. + + @field TX_PANNINGPROFILE_NONE: + No panning profile. + + @field TX_PANNINGPROFILE_READING: + Panning profile for reading, currently same as TX_PANNINGPROFILE_VERTICAL. Will be available in subsequent versions. + + @field TX_PANNINGPROFILE_HORIZONTAL: + Left and right only panning profile. + + @field TX_PANNINGPROFILE_VERTICAL: + Up and down only panning profile. + + @field TX_PANNINGPROFILE_VERTICALFIRSTTHENHORIZONTAL: + Up, down, left and right, with emphasis on vertical panning. + + @field TX_PANNINGPROFILE_RADIAL: + Panning in any direction. + + @field TX_PANNINGPROFILE_HORIZONTALFIRSTTHENVERTICAL: + Up, down, left and right, with emphasis on horizontal panning. + */ +typedef enum { + TX_PANNINGPROFILE_NONE = TX_ENUM_STARTVALUE, + TX_PANNINGPROFILE_READING, + TX_PANNINGPROFILE_HORIZONTAL, + TX_PANNINGPROFILE_VERTICAL, + TX_PANNINGPROFILE_VERTICALFIRSTTHENHORIZONTAL, + TX_PANNINGPROFILE_RADIAL, + TX_PANNINGPROFILE_HORIZONTALFIRSTTHENVERTICAL +} TX_PANNINGPROFILE; + +/*********************************************************************************************************************/ + +/** + TX_GAZETRACKING + + \since Version 1.4.0 + + Enumeration for conveying gaze tracking status. + + @field TX_GAZETRACKING_GAZETRACKED: + Gaze is currently being tracked. + + @field TX_GAZETRACKING_GAZENOTTRACKED: + Gaze is currently not being tracked. This state can be set when for example the user is gazing outside of the + tracked display, no user is present in front of the eye tracker, or that no connection is established with the + eye tracker etc. + */ + + typedef enum { + TX_GAZETRACKING_GAZETRACKED = TX_ENUM_STARTVALUE, + TX_GAZETRACKING_GAZENOTTRACKED +} TX_GAZETRACKING; + +/*********************************************************************************************************************/ + +/** + TX_USERPRESENCE + + Enumeration for conveying presence status. + + @field TX_USERPRESENCE_PRESENT: + A user is present in front of the eye tracker. + + @field TX_USERPRESENCE_NOTPRESENT: + A user is not present in front of the eye tracker. + + @field TX_USERPRESENCE_UNKNOWN: + It is unknown whether or not a user is present in front of the eye tracker. + This value will be returned if there is no observer registered for TX_STATEPATH_USERPRESENCE. + */ +typedef enum { + TX_USERPRESENCE_PRESENT = TX_ENUM_STARTVALUE, + TX_USERPRESENCE_NOTPRESENT, + TX_USERPRESENCE_UNKNOWN +} TX_USERPRESENCE; + +/*********************************************************************************************************************/ + +/** + TX_REQUESTTYPE + + Enumeration for all the types of requests that can be exposed through the API. + + @field TX_REQUESTTYPE_COMMAND: + The request handles a command. + + @field TX_REQUESTTYPE_CUSTOM: + Base value for custom requests defined by other protocols. + */ +typedef enum { + TX_REQUESTTYPE_COMMAND = TX_ENUM_STARTVALUE, + TX_REQUESTTYPE_CUSTOM = TX_INTERNAL_ENUM_STARTVALUE +} TX_REQUESTTYPE; + +/*********************************************************************************************************************/ + +/** + TX_MASKTYPE + + Enumeration for mask types. + + @field TX_MASKTYPE_DEFAULT: + Default mask type. + */ +typedef enum { + TX_MASKTYPE_DEFAULT = TX_ENUM_STARTVALUE +} TX_MASKTYPE; + +/*********************************************************************************************************************/ + +/** + TX_INTERACTIONMODES + + \since Version 1.1.0 + + Flags for describing engine interaction modes. These influence what behaviors are being + treated and what interaction behavior events are being generated. + + @field TX_INTERACTIONMODES_NONE: + Engine is not in any specific interacion mode, gaze aware behaviors and data stream + behaviors are being treated only. + + @field TX_INTERACTIONMODES_ACTIVATIONMODE: + Engine is in activation mode, meaning activatable interactors are prioritized and + activation events are being generated. + + @field TX_INTERACTIONMODES_PANNINGMODE: + Engine is in panning mode, meaning pannable interactors are being prioritzed, and + appropriate events being generated. + + */ +typedef enum { + TX_INTERACTIONMODES_NONE = TX_FLAGS_NONE_VALUE, + TX_INTERACTIONMODES_ACTIVATIONMODE = 1, + TX_INTERACTIONMODES_PANNINGMODE = 1 << 2 +} TX_INTERACTIONMODES; + +/*********************************************************************************************************************/ + + +typedef enum { + TX_CLIENTMODE_AGENT = TX_ENUM_STARTVALUE, + TX_CLIENTMODE_DIAGNOSTICS +} TX_CLIENTMODE; + + +/*********************************************************************************************************************/ + +/** + TX_CONFIGURATIONTOOL + + \since Version 1.1.0 + + Enumeration for configuration tools. + + @field TX_CONFIGURATIONTOOL_EYEXSETTINGS: + EyeX Settings. Always available. + + @field TX_CONFIGURATIONTOOL_RECALIBRATE: + Re-Calibrate the current profile. + Available when the following is fulfilled: + - Eye Tracking Device Status is "Tracking", "TrackingPaused" or "InvalidConfiguration". + - Eye Tracking Configuration Status is "Valid" or "InvalidCalibration". + - State TX_STATEPATH_EYETRACKINGCURRENTPROFILENAME has a value other than empty string. + + When the Recalibrate tool is active the Eye Tracking Device Status will be "Configuring", i.e. tracking is off. + + @field TX_CONFIGURATIONTOOL_GUESTCALIBRATION: + Create and calibrate a guest profile and set it as active profile. + Available when the following is fulfilled: + - Eye Tracking Device Status is "Tracking", "TrackingPaused" or "InvalidConfiguration". + - Eye Tracking Configuration Status is "Valid" or "InvalidCalibration". + + When the Guest Calibration tool is active the Eye Tracking Device Status will be "Configuring", i.e. tracking is off. + + @field TX_CONFIGURATIONTOOL_CREATENEWPROFILE: + Create and calibrate a new profile and set it as active profile. + Available when the following is fulfilled: + - Eye Tracking Device Status is "Tracking", "TrackingPaused" or "InvalidConfiguration". + - Eye Tracking Configuration Status is "Valid" or "InvalidCalibration". + + When the Create New Profile tool is active the Eye Tracking Device Status will be "Configuring", i.e. tracking is off. + + @field TX_CONFIGURATIONTOOL_TESTEYETRACKING: + Test your eye tracking. + Available when the following is fulfilled: + - Eye Tracking Device Status is "Tracking". + + @field TX_CONFIGURATIONTOOL_DIAGNOSTICS: + Diagnose your eye tracking. + Always available. +*/ + +typedef enum { + TX_CONFIGURATIONTOOL_EYEXSETTINGS = TX_ENUM_STARTVALUE, + TX_CONFIGURATIONTOOL_RECALIBRATE, + TX_CONFIGURATIONTOOL_GUESTCALIBRATION, + TX_CONFIGURATIONTOOL_CREATENEWPROFILE, + TX_CONFIGURATIONTOOL_TESTEYETRACKING, + TX_CONFIGURATIONTOOL_DIAGNOSTICS, + + /* for internal use only */ + TX_CONFIGURATIONTOOL_SETUPDISPLAY = TX_INTERNAL_ENUM_STARTVALUE, + TX_CONFIGURATIONTOOL_EYEPOSITION, + TX_CONFIGURATIONTOOL_EYECAPTURE, + TX_CONFIGURATIONTOOL_FIRMWARE_UPGRADE, + TX_CONFIGURATIONTOOL_CHECKFORUPDATES, + TX_CONFIGURATIONTOOL_RETAILCALIBRATION +} TX_CONFIGURATIONTOOL; + +/*********************************************************************************************************************/ +/** + TX_EYETRACKINGCONFIGURATIONSTATUS + + \since Version 1.1.0 + + Enumeration for configuration status. Gives information about the configuration status of the eye tracker, + for example if it needs to be calibrated or if we need to setup display. Can be used as input to determine + when to enable launching of configuration tools, see txLaunchConfigurationTool + and TX_CONFIGURATIONTOOL. + + @field TX_EYETRACKINGCONFIGURATIONSTATUS_VALID: + The configuration status of the eye tracker is valid. + + @field TX_EYETRACKINGCONFIGURATIONSTATUS_INVALIDMONITORCONFIGURATION: + The monitor where the eye tracker is mounted need to be configured. + + @field TX_EYETRACKINGCONFIGURATIONSTATUS_INVALIDCALIBRATION: + The eye tracker need to be calibrated. If no user profile exists (see state TX_STATEPATH_EYETRACKINGCURRENTPROFILENAME) a new profile should be created. + + @field TX_EYETRACKINGCONFIGURATIONSTATUS_UNKNOWNERROR: + The configuration is in an unknown error state. +*/ + +typedef enum { + TX_EYETRACKINGCONFIGURATIONSTATUS_VALID = TX_ENUM_STARTVALUE, + TX_EYETRACKINGCONFIGURATIONSTATUS_INVALIDMONITORCONFIGURATION, + TX_EYETRACKINGCONFIGURATIONSTATUS_INVALIDCALIBRATION, + TX_EYETRACKINGCONFIGURATIONSTATUS_UNKNOWNERROR +} TX_EYETRACKINGCONFIGURATIONSTATUS; + + +/*********************************************************************************************************************/ + +/** + TX_TRACKEDEYE + + \since Version 1.3.0 + + Enumeration for tracked eye of current profile. + + @field TX_TRACKEDEYES_BOTH: + Track both eyes. + + @field TX_TRACKEDEYES_ONLY_LEFT_EYE: + Track left eye only. + + @field TX_TRACKEDEYES_ONLY_RIGHT_EYE: + Track right eye only. + + @field TX_EYETRACKINGCONFIGURATIONSTATUS_INVALIDMONITORCONFIGURATION: + The monitor where the eye tracker is mounted need to be configured. +*/ +typedef enum { + TX_TRACKEDEYES_BOTH = TX_ENUM_STARTVALUE, + TX_TRACKEDEYES_ONLY_LEFT_EYE, + TX_TRACKEDEYES_ONLY_RIGHT_EYE +} TX_TRACKEDEYES; + + +/*********************************************************************************************************************/ + +/** + TX_HANDSFREEPANNINGMODE + + This is For internal use only! + + Enumeration for the different hands free modes. + Used in TX_PANNABLE_PARAMS for a specific behavior/interactor + + @field TX_HANDSFREEPANNINGMODE_DEFAULT: + Handsfree panning follows the current engine panning handsfree state, which may be set by the user. + + @field TX_HANDSFREEPANNINGMODE_ALWAYSENABLED: + Handsfree panning is always enabled, regardless of engine panning handsfree state. + + @field TX_HANDSFREEPANNINGMODE_ALWAYSDISABLED: + Handsfree panning is always disabled, regardless of engine panning handsfree state. + + */ +typedef enum { + TX_HANDSFREEPANNINGMODE_DEFAULT = 0, + TX_HANDSFREEPANNINGMODE_ALWAYSENABLED, + TX_HANDSFREEPANNINGMODE_ALWAYSDISABLED +} TX_HANDSFREEPANNINGMODE; + +/*********************************************************************************************************************/ + +#endif /* !defined(__TOBII_TX_FRAMEWORK_TYPES__H__) */ + +/*********************************************************************************************************************/ diff --git a/Tobii-EyeX/include/eyex/EyeXInteractor.h b/Tobii-EyeX/include/eyex/EyeXInteractor.h new file mode 100755 index 0000000..b753864 --- /dev/null +++ b/Tobii-EyeX/include/eyex/EyeXInteractor.h @@ -0,0 +1,1058 @@ +/********************************************************************************************************************* + * Copyright 2013-2014 Tobii Technology AB. All rights reserved. + * EyeXInteractor.h + *********************************************************************************************************************/ + +#if !defined(__TOBII_TX_INTERACTOR_API__H__) +#define __TOBII_TX_INTERACTOR_API__H__ + +/*********************************************************************************************************************/ + +/** + txGetInteractorId + + Gets the id of an interactor. + + @param hInteractor [in]: + A TX_CONSTHANDLE to the interactor for which the id should be retrieved. + Must not be TX_EMPTY_HANDLE. + + @param pInteractorId [out]: + A TX_STRING to which the interactor id will be copied. + Must be at least the size of the interactor id. + Can be NULL to only get the size of the interactor id. + + @param pInteractorIdSize [in,out]: + A pointer to a TX_SIZE which will be set the size of the interactor id. + Must not be NULL. + The value must be 0 if pInteractorId is NULL. + + @return + TX_RESULT_OK: The interactor id or the required size of the string was successfully retrieved. + TX_RESULT_EYEXNOTINITIALIZED: The EyeX client environment is not initialized. + TX_RESULT_INVALIDARGUMENT: An invalid argument was passed to the function. + TX_RESULT_INVALIDBUFFERSIZE: The size of pInteractorId is invalid (*pInteractorIdSize will be set to the required size). + */ +TX_C_BEGIN +TX_API TX_RESULT TX_CALLCONVENTION txGetInteractorId( + TX_CONSTHANDLE hInteractor, + TX_STRING pInteractorId, + TX_SIZE* pInteractorIdSize + ); +TX_C_END + +typedef TX_RESULT (TX_CALLCONVENTION *GetInteractorIdHook)( + TX_CONSTHANDLE hInteractor, + TX_STRING pInteractorId, + TX_SIZE* pInteractorIdSize + ); + + +/*********************************************************************************************************************/ + +/** + txGetInteractorParentId + + Gets the id of an interactors parent. + + @param hInteractor [in]: + A TX_CONSTHANDLE to the interactor for which the parent id should be retrieved. + Must not be TX_EMPTY_HANDLE. + + @param pParentInteractorId [out]: + A TX_STRING to which the parent interactor id will be copied. + Must be at least the size of the parent interactor id. + Can be NULL to only get the size of the parent interactor id. + + @param pInteractorParentIdSize [in,out]: + A pointer to a TX_SIZE which will be set the size of the parent interactor id. + Must not be NULL. + The value must be 0 if pParentInteractorId is NULL. + + @return + TX_RESULT_OK: The parent interactor id or the required size of the string was successfully retrieved. + TX_RESULT_EYEXNOTINITIALIZED: The EyeX client environment is not initialized. + TX_RESULT_INVALIDARGUMENT: An invalid argument was passed to the function. + TX_RESULT_INVALIDBUFFERSIZE: The size of pParentInteractorId is invalid (*pInteractorParentIdSize will be set to the required size). + */ +TX_C_BEGIN +TX_API TX_RESULT TX_CALLCONVENTION txGetInteractorParentId( + TX_CONSTHANDLE hInteractor, + TX_STRING pParentInteractorId, + TX_SIZE* pInteractorParentIdSize + ); +TX_C_END + +typedef TX_RESULT (TX_CALLCONVENTION *GetInteractorParentIdHook)( + TX_CONSTHANDLE hInteractor, + TX_STRING pParentInteractorId, + TX_SIZE* pInteractorParentIdSize + ); + + +/*********************************************************************************************************************/ + +/** + txGetInteractorWindowId + + Gets the window id of the interactor. + + @param hInteractor [in]: + A TX_CONSTHANDLE to the interactor for which the window id should be retrieved. + Must not be TX_EMPTY_HANDLE. + + @param pWindowId [out]: + A TX_STRING to which the window id will be copied. + Must be at least the size of the window id. + Can be NULL to only get the size of the window id. + + @param pWindowIdSize [in,out]: + A pointer to a TX_SIZE which will be set the size of the window id. + Must not be NULL. + The value must be 0 if pWindowId is NULL. + + @return + TX_RESULT_OK: The window id or the required size of the string was successfully retrieved. + TX_RESULT_EYEXNOTINITIALIZED: The EyeX client environment is not initialized. + TX_RESULT_INVALIDARGUMENT: An invalid argument was passed to the function. + TX_RESULT_INVALIDBUFFERSIZE: The size of pWindowId is invalid (*pWindowIdSize will be set to the required size). + */ +TX_C_BEGIN +TX_API TX_RESULT TX_CALLCONVENTION txGetInteractorWindowId( + TX_CONSTHANDLE hInteractor, + TX_STRING pWindowId, + TX_SIZE* pWindowIdSize + ); +TX_C_END + +typedef TX_RESULT (TX_CALLCONVENTION *GetInteractorWindowIdHook)( + TX_CONSTHANDLE hInteractor, + TX_STRING pWindowId, + TX_SIZE* pWindowIdSize + ); + + +/*********************************************************************************************************************/ + +/** + txSetInteractorZ + + Sets the z value of an interactor. + The z value of an interactor is used to specify which interactor lies on top of which among siblings. + Note that the z value is local on each level of interactors and therefore only concerns interactors with the same parent. + The z value must be a non negative TX_REAL. + This call will overwrite any previously set z value. + + @param hInteractor [in]: + A TX_HANDLE to the interactor for which to set the z value. + Must not be TX_EMPTY_HANDLE. + + @param z [in]: + The z value as a TX_REAL. + Must be a non negative TX_REAL. + + @return + TX_RESULT_OK: The z value was successfully set. + TX_RESULT_EYEXNOTINITIALIZED: The EyeX client environment is not initialized. + TX_RESULT_INVALIDARGUMENT: An invalid argument was passed to the function. + */ +TX_C_BEGIN +TX_API TX_RESULT TX_CALLCONVENTION txSetInteractorZ( + TX_HANDLE hInteractor, + TX_REAL z + ); +TX_C_END + +typedef TX_RESULT (TX_CALLCONVENTION *SetInteractorZHook)( + TX_HANDLE hInteractor, + TX_REAL z + ); + + +/*********************************************************************************************************************/ + +/** + txGetInteractorZ + + Gets the z value of an interactor. + + @param hInteractor [in]: + A TX_CONSTHANDLE to the interactor for which to get the z value. + Must not be TX_EMPTY_HANDLE. + + @param pZ [out]: + The pointer to a TX_REAL which will be set to the z value. + Must not be NULL. + + @return + TX_RESULT_OK: The z value was successfully retrieved. + TX_RESULT_EYEXNOTINITIALIZED: The EyeX client environment is not initialized. + TX_RESULT_INVALIDARGUMENT: An invalid argument was passed to the function. + */ +TX_C_BEGIN +TX_API TX_RESULT TX_CALLCONVENTION txGetInteractorZ( + TX_CONSTHANDLE hInteractor, + TX_REAL* pZ + ); +TX_C_END + +typedef TX_RESULT (TX_CALLCONVENTION *GetInteractorZHook)( + TX_CONSTHANDLE hInteractor, + TX_REAL* pZ + ); + + +/*********************************************************************************************************************/ + +/** + txSetInteractorEnabled + + Sets a TX_BOOL flag which specifies if an interactor is enabled or not. + This call will overwrite any previously set enabled flag. + The default value is false. + + @param hInteractor [in]: + A TX_HANDLE to the interactor to enable/disable. + Must not be TX_EMPTY_HANDLE. + + @param enabled [in]: + The flag as a TX_BOOL. + + @return + TX_RESULT_OK: The interactor was successfully set to enabled/disabled. + TX_RESULT_EYEXNOTINITIALIZED: The EyeX client environment is not initialized. + TX_RESULT_INVALIDARGUMENT: An invalid argument was passed to the function. + */ +TX_C_BEGIN +TX_API TX_RESULT TX_CALLCONVENTION txSetInteractorEnabled( + TX_HANDLE hInteractor, + TX_BOOL enabled + ); +TX_C_END + +typedef TX_RESULT (TX_CALLCONVENTION *SetInteractorEnabledHook)( + TX_HANDLE hInteractor, + TX_BOOL enabled + ); + + +/*********************************************************************************************************************/ + +/** + txGetInteractorEnabled + + Gets the enabled flag from the interactor. + + @param hInteractor [in]: + A TX_CONSTHANDLE to the interactor for which to get the enabled flag. + Must not be TX_EMPTY_HANDLE. + + @param pEnabled [out]: + The pointer to a TX_BOOL which will be set to the enabled flag value. + Must not be NULL. + + @return + TX_RESULT_OK: The enabled flag was successfully retrieved. + TX_RESULT_EYEXNOTINITIALIZED: The EyeX client environment is not initialized. + TX_RESULT_INVALIDARGUMENT: An invalid argument was passed to the function. + */ +TX_C_BEGIN +TX_API TX_RESULT TX_CALLCONVENTION txGetInteractorEnabled( + TX_CONSTHANDLE hInteractor, + TX_BOOL* pEnabled + ); +TX_C_END + +typedef TX_RESULT (TX_CALLCONVENTION *GetInteractorEnabledHook)( + TX_CONSTHANDLE hInteractor, + TX_BOOL* pEnabled + ); + + +/*********************************************************************************************************************/ + +/** + txSetInteractorDeleted + + Sets a TX_BOOL flag which specifies if an interactor is deleted or not. + This call will overwrite any previously set deleted flag. + The default value is false. + + @param hInteractor [in]: + A TX_HANDLE to the interactor to set as deleted. + Must not be TX_EMPTY_HANDLE. + + @param deleted [in]: + The flag as a TX_BOOL. + + @return + TX_RESULT_OK: The deleted flag on the interactor was successfully set. + TX_RESULT_EYEXNOTINITIALIZED: The EyeX client environment is not initialized. + TX_RESULT_INVALIDARGUMENT: An invalid argument was passed to the function. + */ +TX_C_BEGIN +TX_API TX_RESULT TX_CALLCONVENTION txSetInteractorDeleted( + TX_HANDLE hInteractor, + TX_BOOL deleted + ); +TX_C_END + +typedef TX_RESULT (TX_CALLCONVENTION *SetInteractorDeletedHook)( + TX_HANDLE hInteractor, + TX_BOOL deleted + ); + + +/*********************************************************************************************************************/ + +/** + txGetInteractorDeleted + + Gets the deleted flag from the interactor. + + @param hInteractor [in]: + A TX_CONSTHANDLE to the interactor for which to get the deleted flag. + Must not be TX_EMPTY_HANDLE. + + @param pDeleted [out]: + The pointer to a TX_BOOL which will be set to the deleted flag value. + Must not be NULL. + + @return + TX_RESULT_OK: The deleted flag was successfully retrieved. + TX_RESULT_EYEXNOTINITIALIZED: The EyeX client environment is not initialized. + TX_RESULT_INVALIDARGUMENT: An invalid argument was passed to the function. + */ +TX_C_BEGIN +TX_API TX_RESULT TX_CALLCONVENTION txGetInteractorDeleted( + TX_CONSTHANDLE hInteractor, + TX_BOOL* pDeleted + ); +TX_C_END + +typedef TX_RESULT (TX_CALLCONVENTION *GetInteractorDeletedHook)( + TX_CONSTHANDLE hInteractor, + TX_BOOL* pDeleted + ); + + +/*********************************************************************************************************************/ + +/** + txCreateInteractorBounds + + Creates bounds on an interactor. + If the interactor already has bounds this call will fail. + The bounds will be owned by the interactor and does not need to be deleted explicitly. + + @param hInteractor [in]: + A TX_HANDLE to the interactor on which the bounds should be created. + Must not be TX_EMPTY_HANDLE. + + @param phBounds [out]: + A pointer to a TX_HANDLE which will be set to the newly created bounds. + This handle must be released using txReleaseObject to avoid leaks. + Must not be NULL. + The value of the pointer must be set to TX_EMPTY_HANDLE. + + @param boundsType [in]: + The TX_BOUNDSTYPE which specifies what kind of bounds to create. + + @return + TX_RESULT_OK: The bounds was successfully created. + TX_RESULT_EYEXNOTINITIALIZED: The EyeX client environment is not initialized. + TX_RESULT_INVALIDARGUMENT: An invalid argument was passed to the function. + TX_RESULT_DUPLICATEBOUNDS: This interactor already has bounds. + */ +TX_C_BEGIN +TX_API TX_RESULT TX_CALLCONVENTION txCreateInteractorBounds( + TX_HANDLE hInteractor, + TX_HANDLE* phBounds, + TX_BOUNDSTYPE boundsType + ); +TX_C_END + +typedef TX_RESULT (TX_CALLCONVENTION *CreateInteractorBoundsHook)( + TX_HANDLE hInteractor, + TX_HANDLE* phBounds, + TX_BOUNDSTYPE boundsType + ); + + +/*********************************************************************************************************************/ + +/** + txDeleteInteractorBounds + + Deletes the bounds on an interactor. + If the interactor does not have any bounds this call will fail. + The bounds object is owned by the interactor and does not need to be deleted explicitly. + + @param hInteractor [in]: + A TX_HANDLE to the interactor on which to delete the bounds. + Must not be TX_EMPTY_HANDLE. + + @return + TX_RESULT_OK: The bounds was successfully deleted. + TX_RESULT_EYEXNOTINITIALIZED: The EyeX client environment is not initialized. + TX_RESULT_INVALIDARGUMENT: An invalid argument was passed to the function. + TX_RESULT_NOTFOUND: This interactor does not have any bounds. + */ +TX_C_BEGIN +TX_API TX_RESULT TX_CALLCONVENTION txDeleteInteractorBounds( + TX_HANDLE hInteractor + ); +TX_C_END + +typedef TX_RESULT (TX_CALLCONVENTION *DeleteInteractorBoundsHook)( + TX_HANDLE hInteractor + ); + + +/*********************************************************************************************************************/ + +/** + txGetInteractorBounds + + Gets the bounds of an interactor. + If the interactor does not have any bounds this call will fail. + + @param hInteractor [in]: + A TX_CONSTHANDLE to the interactor from which the bounds should be retrieved. + Must not be TX_EMPTY_HANDLE. + + @param phBounds [out]: + A pointer to a TX_HANDLE which will be set to the bounds on the interactor. + This handle must be released using txReleaseObject to avoid leaks. + Must not be NULL. + The value of the pointer must be set to TX_EMPTY_HANDLE. + + @return + TX_RESULT_OK: The bounds was successfully retrieved. + TX_RESULT_EYEXNOTINITIALIZED: The EyeX client environment is not initialized. + TX_RESULT_INVALIDARGUMENT: An invalid argument was passed to the function. + TX_RESULT_NOTFOUND: This interactor does not have any bounds. + */ +TX_C_BEGIN +TX_API TX_RESULT TX_CALLCONVENTION txGetInteractorBounds( + TX_CONSTHANDLE hInteractor, + TX_HANDLE* phBounds + ); +TX_C_END + +typedef TX_RESULT (TX_CALLCONVENTION *GetInteractorBoundsHook)( + TX_CONSTHANDLE hInteractor, + TX_HANDLE* phBounds + ); + + +/*********************************************************************************************************************/ + +/** + txCreateInteractorBehavior + + Creates a behavior of a specified TX_BEHAVIORTYPE on an interactor. + If the interactor already has a behavior of the specified type this call will fail. + The behavior will be owned by the interactor and does not need to be removed explicitly. + + @param hInteractor [in]: + A TX_HANDLE to the interactor on which the behavior should be created. + Must not be TX_EMPTY_HANDLE. + + @param phBehavior [out]: + A pointer to a TX_HANDLE which will be set to the newly created behavior. + This handle must be released using txReleaseObject to avoid leaks. + Must not be NULL. + The value of the pointer must be set to TX_EMPTY_HANDLE. + + @param behaviorType [in]: + The TX_BEHAVIORTYPE which specifies what type of behavior to create. + + @return + TX_RESULT_OK: The behavior was successfully created. + TX_RESULT_EYEXNOTINITIALIZED: The EyeX client environment is not initialized. + TX_RESULT_INVALIDARGUMENT: An invalid argument was passed to the function. + TX_RESULT_DUPLICATEBEHAVIOR: This interactor already has a behavior of the specified type. + */ +TX_C_BEGIN +TX_API TX_RESULT TX_CALLCONVENTION txCreateInteractorBehavior( + TX_HANDLE hInteractor, + TX_HANDLE* phBehavior, + TX_BEHAVIORTYPE behaviorType + ); +TX_C_END + +typedef TX_RESULT (TX_CALLCONVENTION *CreateInteractorBehaviorHook)( + TX_HANDLE hInteractor, + TX_HANDLE* phBehavior, + TX_BEHAVIORTYPE behaviorType + ); + + +/*********************************************************************************************************************/ + +/** + txRemoveInteractorBehavior + + Removes a TX_BEHAVIORTYPE from an interactor. + If the interactor does not have a behavior of the specified type this call will fail. + + @param hInteractor [in]: + A TX_HANDLE to the interactor from which the behavior should be removed. + Must not be TX_EMPTY_HANDLE. + + @param behaviorType [in]: + The TX_BEHAVIORTYPE which specifies what type of behavior to remove. + + @return + TX_RESULT_OK: The behavior was successfully removed. + TX_RESULT_EYEXNOTINITIALIZED: The EyeX client environment is not initialized. + TX_RESULT_INVALIDARGUMENT: An invalid argument was passed to the function. + TX_RESULT_NOTFOUND: This interactor does not have a behavior of the specified type. + */ +TX_C_BEGIN +TX_API TX_RESULT TX_CALLCONVENTION txRemoveInteractorBehavior( + TX_HANDLE hInteractor, + TX_BEHAVIORTYPE behaviorType + ); +TX_C_END + +typedef TX_RESULT (TX_CALLCONVENTION *RemoveInteractorBehaviorHook)( + TX_HANDLE hInteractor, + TX_BEHAVIORTYPE behaviorType + ); + + +/*********************************************************************************************************************/ + +/** + txGetInteractorBehavior + + Gets a TX_BEHAVIORTYPE from an interactor. + If the interactor does not have a behavior of the specified type this call will fail. + + @param hInteractor [in]: + A TX_CONSTHANDLE to the interactor from which the behavior should be retrieved. + Must not be TX_EMPTY_HANDLE. + + @param phBehavior [out]: + A pointer to a TX_HANDLE which will be set to the behavior. + This handle must be released using txReleaseObject to avoid leaks. + Must not be NULL. + The value of the pointer must be set to TX_EMPTY_HANDLE. + + @param behaviorType [in]: + The TX_BEHAVIORTYPE which specifies what type of behavior to get. + + @return + TX_RESULT_OK: The behavior was successfully retrieved. + TX_RESULT_EYEXNOTINITIALIZED: The EyeX client environment is not initialized. + TX_RESULT_INVALIDARGUMENT: An invalid argument was passed to the function. + TX_RESULT_NOTFOUND: This interactor does not have a behavior of the specified type. + */ +TX_C_BEGIN +TX_API TX_RESULT TX_CALLCONVENTION txGetInteractorBehavior( + TX_CONSTHANDLE hInteractor, + TX_HANDLE* phBehavior, + TX_BEHAVIORTYPE behaviorType + ); +TX_C_END + +typedef TX_RESULT (TX_CALLCONVENTION *GetInteractorBehaviorHook)( + TX_CONSTHANDLE hInteractor, + TX_HANDLE* phBehavior, + TX_BEHAVIORTYPE behaviorType + ); + + +/*********************************************************************************************************************/ + +/** + txGetInteractorBehaviors + + Gets the TX_HANDLEs to all behaviors on an interactor. + + @param hInteractor [in]: + A TX_CONSTHANDLE to the interactor from which to get the behaviors. + Must not be TX_EMPTY_HANDLE. + + @param phBehaviors [out]: + A pointer to an array of TX_HANDLEs to which the behavior handles will be copied. + These handles must be released using txReleaseObject to avoid leaks. + Can be NULL to only get the size. + + @param pBehaviorsSize [in,out]: + A pointer to a TX_SIZE which will be set to the number of behaviors. + Must not be NULL. + The value must be 0 if phBehaviors is NULL. + + @return + TX_RESULT_OK: The handles or the required size of the buffer was retrieved successfully. + TX_RESULT_EYEXNOTINITIALIZED: The EyeX client environment is not initialized. + TX_RESULT_INVALIDARGUMENT: An invalid argument was passed to the function. + TX_RESULT_INVALIDBUFFERSIZE: The size of the array is invalid. (*pBehaviorsSize will be set to the number of behaviors). + */ +TX_C_BEGIN +TX_API TX_RESULT TX_CALLCONVENTION txGetInteractorBehaviors( + TX_CONSTHANDLE hInteractor, + TX_HANDLE* phBehaviors, + TX_SIZE* pBehaviorsSize + ); +TX_C_END + +typedef TX_RESULT (TX_CALLCONVENTION *GetInteractorBehaviorsHook)( + TX_CONSTHANDLE hInteractor, + TX_HANDLE* phBehaviors, + TX_SIZE* pBehaviorsSize + ); + + +/*********************************************************************************************************************/ + +/** + txCreateGazeAwareBehavior + + Creates a gaze aware behavior and attaches it to the interactor. + + @param hInteractor [in]: + A TX_HANDLE to the interactor that should have the behavior. + Must not be TX_EMPTY_HANDLE. + + @param pParams [in]: + A pointer to a TX_GAZEAWAREARAMS which specifies the behaviors parameters. + Must not be NULL. + + @return + TX_RESULT_OK: The behavior was successfully set. + TX_RESULT_EYEXNOTINITIALIZED: The EyeX client environment is not initialized. + TX_RESULT_INVALIDARGUMENT: An invalid argument was passed to the function. + TX_RESULT_DUPLICATEBEHAVIOR: This interactor already has a behavior of the specified type. + */ +TX_C_BEGIN +TX_API TX_RESULT TX_CALLCONVENTION txCreateGazeAwareBehavior( + TX_HANDLE hInteractor, + const TX_GAZEAWAREPARAMS* pParams + ); +TX_C_END + +typedef TX_RESULT (TX_CALLCONVENTION *CreateGazeAwareBehaviorHook)( + TX_HANDLE hInteractor, + const TX_GAZEAWAREPARAMS* pParams + ); + + +/*********************************************************************************************************************/ + +/** + txCreateActivatableBehavior + + Creates an activatable behavior and attaches it to the interactor. + + @param hInteractor [in]: + A TX_HANDLE to the interactor that should have the behavior. + Must not be TX_EMPTY_HANDLE. + + @param pParams [in]: + A pointer to a TX_ACTIVATABLEPARAMS which specifies the behaviors parameters. + Must not be NULL. + + @return + TX_RESULT_OK: The behavior was successfully set. + TX_RESULT_EYEXNOTINITIALIZED: The EyeX client environment is not initialized. + TX_RESULT_INVALIDARGUMENT: An invalid argument was passed to the function. + TX_RESULT_DUPLICATEBEHAVIOR: This interactor already has a behavior of the specified type. + */ +TX_C_BEGIN +TX_API TX_RESULT TX_CALLCONVENTION txCreateActivatableBehavior( + TX_HANDLE hInteractor, + const TX_ACTIVATABLEPARAMS* pParams + ); +TX_C_END + +typedef TX_RESULT (TX_CALLCONVENTION *CreateActivatableBehaviorHook)( + TX_HANDLE hInteractor, + const TX_ACTIVATABLEPARAMS* pParams + ); + + +/*********************************************************************************************************************/ + +/** + txCreatePannableBehavior + + Creates a pannable behavior and attaches it to the interactor. + + @param hInteractor [in]: + A TX_HANDLE to the interactor that should have the behavior. + Must not be TX_EMPTY_HANDLE. + + @param pParams [in]: + A pointer to a TX_PANNABLEPARAMS which specifies the behaviors parameters. + Must not be NULL. + + @return + TX_RESULT_OK: The behavior was successfully set. + TX_RESULT_EYEXNOTINITIALIZED: The EyeX client environment is not initialized. + TX_RESULT_INVALIDARGUMENT: An invalid argument was passed to the function. + TX_RESULT_DUPLICATEBEHAVIOR: This interactor already has a behavior of the specified type. + */ +TX_C_BEGIN +TX_API TX_RESULT TX_CALLCONVENTION txCreatePannableBehavior( + TX_HANDLE hInteractor, + const TX_PANNABLEPARAMS* pParams + ); +TX_C_END + +typedef TX_RESULT (TX_CALLCONVENTION *CreatePannableBehaviorHook)( + TX_HANDLE hInteractor, + const TX_PANNABLEPARAMS* pParams + ); + + +/*********************************************************************************************************************/ + +/** + txCreateGazePointDataBehavior + + Creates a gaze point data behavior and attaches it to the interactor. + + @param hInteractor [in]: + A TX_HANDLE to the interactor that should have the behavior. + Must not be TX_EMPTY_HANDLE. + + @param pParams [in]: + A pointer to a TX_GAZEPOINTDATAPARAMS which specifies the behaviors parameters. + Must not be NULL. + + @return + TX_RESULT_OK: The behavior was successfully set. + TX_RESULT_EYEXNOTINITIALIZED: The EyeX client environment is not initialized. + TX_RESULT_INVALIDARGUMENT: An invalid argument was passed to the function. + TX_RESULT_DUPLICATEBEHAVIOR: This interactor already has a behavior of the specified type. + */ +TX_C_BEGIN +TX_API TX_RESULT TX_CALLCONVENTION txCreateGazePointDataBehavior( + TX_HANDLE hInteractor, + const TX_GAZEPOINTDATAPARAMS* pParams + ); +TX_C_END + +typedef TX_RESULT (TX_CALLCONVENTION *CreateGazePointDataBehaviorHook)( + TX_HANDLE hInteractor, + const TX_GAZEPOINTDATAPARAMS* pParams + ); + + +/*********************************************************************************************************************/ + +/** + txCreateFixationDataBehavior + + Creates a fixation data behavior and attaches it to the interactor. + + @param hInteractor [in]: + A TX_HANDLE to the interactor that should have the behavior. + Must not be TX_EMPTY_HANDLE. + + @param options [in]: + A pointer to a TX_FIXATIONDATAPARAMS which specifies the behaviors parameters. + Must not be NULL. + + @return + TX_RESULT_OK: The behavior was successfully set. + TX_RESULT_EYEXNOTINITIALIZED: The EyeX client environment is not initialized. + TX_RESULT_INVALIDARGUMENT: An invalid argument was passed to the function. + TX_RESULT_DUPLICATEBEHAVIOR: This interactor already has a behavior of the specified type. + */ +TX_C_BEGIN +TX_API TX_RESULT TX_CALLCONVENTION txCreateFixationDataBehavior( + TX_HANDLE hInteractor, + const TX_FIXATIONDATAPARAMS* pParams + ); +TX_C_END + +typedef TX_RESULT (TX_CALLCONVENTION *CreateFixationDataBehaviorHook)( + TX_HANDLE hInteractor, + const TX_FIXATIONDATAPARAMS* pParams + ); + + +/*********************************************************************************************************************/ + +/** + txCreateMask + + Creates an mask on an interactor. + The mask is defined by a matrix of size columnCount * rowCount. The usage of each element in the matrix varies + between diffrent TX_MASKTYPEs. + A mask should typically NOT correspond to the number of pixels covering an interactor, rather it should be smaller. + + @param hInteractor [in]: + A TX_HANDLE to interactor on which to create the mask. + Must not be TX_EMPTY_HANDLE. + + @param phMask [out]: + A pointer to a TX_HANDLE which will be set to the newly created mask. + Must not be NULL. + The value of the pointer must be set to TX_EMPTY_HANDLE. + + @param maskType [in]: + The type of mask to create. See TX_MASKTYPE. + + @param columnCount [in]: + The width of the mask. + Must be a positive TX_INTEGER. + columnCount*rowCount must not be larger than 65536. + + @param rowCount [in]: + The height of the mask. + Must be a positive TX_INTEGER. + columnCount*rowCount must not be larger than 65536. + + @param pData [in]: + A pointer to buffer of TX_BYTEs which contains the mask elements. + See TX_MASKTYPE for details about mask data for different types. + Must not be NULL. + + @return + TX_RESULT_OK: The mask was successfully set. + TX_RESULT_EYEXNOTINITIALIZED: The EyeX client environment is not initialized. + TX_RESULT_INVALIDARGUMENT: An invalid argument was passed to the function. + TX_RESULT_MASKTOOLARGE: The mask is too large, columnCount*rowCount must not be larger than 65536 (e.g. 256*256, 128*512 etc). + */ +TX_C_BEGIN +TX_API TX_RESULT TX_CALLCONVENTION txCreateMask( + TX_HANDLE hInteractor, + TX_HANDLE* phMask, + TX_MASKTYPE maskType, + TX_INTEGER columnCount, + TX_INTEGER rowCount, + const TX_BYTE* pData + ); +TX_C_END + +typedef TX_RESULT (TX_CALLCONVENTION *CreateMaskHook)( + TX_HANDLE hInteractor, + TX_HANDLE* phMask, + TX_MASKTYPE maskType, + TX_INTEGER columnCount, + TX_INTEGER rowCount, + const TX_BYTE* pData + ); + + +/*********************************************************************************************************************/ + +/** + txRemoveMask + + Removes an mask from an interactor. + + @param hInteractor [in]: + A TX_HANDLE to interactor on which to create the mask. + Must not be TX_EMPTY_HANDLE. + + @return + TX_RESULT_OK: The mask was successfully removed. + TX_RESULT_EYEXNOTINITIALIZED: The EyeX client environment is not initialized. + TX_RESULT_INVALIDARGUMENT: An invalid argument was passed to the function. + */ +TX_C_BEGIN +TX_API TX_RESULT TX_CALLCONVENTION txRemoveMask( + TX_HANDLE hInteractor + ); +TX_C_END + +typedef TX_RESULT (TX_CALLCONVENTION *RemoveMaskHook)( + TX_HANDLE hInteractor + ); + + +/*********************************************************************************************************************/ + +/** + txGetMask + + Retrieves the mask from an interactor. + + @param hInteractor [in]: + A TX_CONSTHANDLE to interactor from which to get the mask. + Must not be TX_EMPTY_HANDLE. + + @param phMask [out]: + A pointer to a TX_HANDLE which will be set to the mask. + Must not be NULL. + The value of the pointer must be set to TX_EMPTY_HANDLE. + + @return + TX_RESULT_OK: The mask was successfully removed. + TX_RESULT_EYEXNOTINITIALIZED: The EyeX client environment is not initialized. + TX_RESULT_INVALIDARGUMENT: An invalid argument was passed to the function. + TX_RESULT_NOTFOUND: The interactor does not have an mask. + */ +TX_C_BEGIN +TX_API TX_RESULT TX_CALLCONVENTION txGetMask( + TX_CONSTHANDLE hInteractor, + TX_HANDLE* phMask + ); +TX_C_END + +typedef TX_RESULT (TX_CALLCONVENTION *GetMaskHook)( + TX_CONSTHANDLE hInteractor, + TX_HANDLE* phMask + ); + + +/*********************************************************************************************************************/ + +/** + txGetMaskData + + Gets the data of an mask. + + @param hMask [in]: + A TX_CONSTHANDLE to mask for which to get the data. + Must not be TX_EMPTY_HANDLE. + + @param pColumnCount [out]: + A TX_INTEGER which will be set to the width of the mask. + Must not be NULL. + + @param pRowCount [out]: + A TX_INTEGER which will be set to the height of the mask. + Must not be NULL. + + @param pData [out]: + A pointer to buffer of TX_BYTEs which contains the mask elements. + Can be NULL to only get the size of the mask. + + @param pDataSize [in,out]: + A pointer to a TX_SIZE which will be set to the size of the data buffer. + Can be NULL to only get the size of the mask. + The value must be 0 if phObjects is NULL. + + @return + TX_RESULT_OK: The data of the mask or the required buffer size was successfully retrieved. + TX_RESULT_EYEXNOTINITIALIZED: The EyeX client environment is not initialized. + TX_RESULT_INVALIDBUFFERSIZE: The size of the buffer was to small. (*pDataSize will be set to the required size if not NULL.) + TX_RESULT_INVALIDARGUMENT: An invalid argument was passed to the function. + */ +TX_C_BEGIN +TX_API TX_RESULT TX_CALLCONVENTION txGetMaskData( + TX_CONSTHANDLE hMask, + TX_INTEGER* pColumnCount, + TX_INTEGER* pRowCount, + TX_BYTE* pData, + TX_SIZE* pDataSize + ); +TX_C_END + +typedef TX_RESULT (TX_CALLCONVENTION *GetMaskDataHook)( + TX_CONSTHANDLE hMask, + TX_INTEGER* pColumnCount, + TX_INTEGER* pRowCount, + TX_BYTE* pData, + TX_SIZE* pDataSize + ); + + +/*********************************************************************************************************************/ + +/** + txSetMaskBounds + + Sets the bounds of the mask. + By default a mask covers the entire interactor. + + @param hInteractor [in]: + A TX_HANDLE to interactor for which to set the mask bounds. + Must not be TX_EMPTY_HANDLE. + + @param pBounds [in]: + A pointer to a TX_RECT which holds the rectangle data. + Must not be NULL. + + @return + TX_RESULT_OK: The bounds of the mask was successfully set. + TX_RESULT_EYEXNOTINITIALIZED: The EyeX client environment is not initialized. + TX_RESULT_INVALIDARGUMENT: An invalid argument was passed to the function. + */ +TX_C_BEGIN +TX_API TX_RESULT TX_CALLCONVENTION txSetMaskBounds( + TX_HANDLE hInteractor, + const TX_RECT* pBounds + ); +TX_C_END + +typedef TX_RESULT (TX_CALLCONVENTION *SetMaskBoundsHook)( + TX_HANDLE hInteractor, + const TX_RECT* pBounds + ); + + +/*********************************************************************************************************************/ + +/** + txClearMaskBounds + + Clears the mask bounds of an interactor. + + @param hInteractor [in]: + A TX_HANDLE to interactor for which to set the mask bounds. + Must not be TX_EMPTY_HANDLE. + + @return + TX_RESULT_OK: The bounds of the mask was successfully cleared. + TX_RESULT_EYEXNOTINITIALIZED: The EyeX client environment is not initialized. + TX_RESULT_INVALIDARGUMENT: An invalid argument was passed to the function. + */ +TX_C_BEGIN +TX_API TX_RESULT TX_CALLCONVENTION txClearMaskBounds( + TX_HANDLE hInteractor + ); +TX_C_END + +typedef TX_RESULT (TX_CALLCONVENTION *ClearMaskBoundsHook)( + TX_HANDLE hInteractor + ); + + +/*********************************************************************************************************************/ + +/** + txGetMaskBounds + + Gets the bounds of the mask. + + @param hInteractor [in]: + A TX_CONSTHANDLE to interactor from which to set the mask bounds. + Must not be TX_EMPTY_HANDLE. + + @param pBounds [out]: + A pointer to a TX_RECT which will hold the rectangle data. + Must not be NULL. + + @return + TX_RESULT_OK: The bounds of the mask was successfully retrieved. + TX_RESULT_EYEXNOTINITIALIZED: The EyeX client environment is not initialized. + TX_RESULT_INVALIDARGUMENT: An invalid argument was passed to the function. + TX_RESULT_NOTFOUND: The interactor does not have any mask bounds specified. + */ +TX_C_BEGIN +TX_API TX_RESULT TX_CALLCONVENTION txGetMaskBounds( + TX_CONSTHANDLE hInteractor, + TX_RECT* pBounds + ); +TX_C_END + +typedef TX_RESULT (TX_CALLCONVENTION *GetMaskBoundsHook)( + TX_CONSTHANDLE hInteractor, + TX_RECT* pBounds + ); + + +/*********************************************************************************************************************/ + +#endif /* !defined(__TOBII_TX_INTERACTOR_API__H__) */ + +/*********************************************************************************************************************/ diff --git a/Tobii-EyeX/include/eyex/EyeXInternalLiterals.h b/Tobii-EyeX/include/eyex/EyeXInternalLiterals.h new file mode 100755 index 0000000..5c8164a --- /dev/null +++ b/Tobii-EyeX/include/eyex/EyeXInternalLiterals.h @@ -0,0 +1,84 @@ +/********************************************************************************************************************* + * Copyright 2013-2014 Tobii Technology AB. All rights reserved. + * EyeXInternalLiterals.h + *********************************************************************************************************************/ + +#if !defined(__TOBII_TX_INTERNALLITERALS__H__) +#define __TOBII_TX_INTERNALLITERALS__H__ + +/********************************************************************************************************************* + * Literals + *********************************************************************************************************************/ + + + + /** + * Snapshot internal literals + */ + static const char* TX_INTERNALLITERAL_NONAUTHORITATIVEWINDOWIDS = "NonAuthoritativeWindowIds"; + static const char* TX_INTERNALLITERAL_FOCUSEDTOPLEVELWINDOW = "FocusedTopLevelWindow"; + static const char* TX_INTERNALLITERAL_ISFOCUSEDTOPLEVELWINDOW = "IsFocusedTopLevelWindow"; + + /** + * Callback Response Literals + */ + static const char* TX_INTERNALLITERAL_ISCANCELLED = "IsCancelled"; + +/*********************************************************************************************************************/ + + /** + * Termination Literals + */ + static const char* TX_INTERNALLITERAL_TERMINATEGXWINDOWS = "TerminateGxWindows"; + static const char* TX_INTERNALLITERAL_GLOBALTERMINATEGXSERVER = "Global\\TerminateGxServer"; + + /** + * Internal Raw Gaze Data LiteralsConfiguredEyesWithGaze + **/ + static const char* TX_INTERNALLITERAL_EYEPOSITIONFROMSCREENCENTERMM = "EyePositionFromScreenCenterMM"; + static const char* TX_INTERNALLITERAL_EYEPOSITIONINTRACKBOXNORMALIZED = "EyePositionInTrackBoxNormalized"; + static const char* TX_INTERNALLITERAL_GAZEPOINTFROMSCREENCENTERMM = "GazePointFromScreenCenterMM"; + static const char* TX_INTERNALLITERAL_GAZEPOINTONDISPLAYNORMALIZED = "GazePointOnDisplayNormalized"; + static const char* TX_INTERNALLITERAL_BOTTOMLEFT = "BottomLeft"; + static const char* TX_INTERNALLITERAL_TOPLEFT = "TopLeft"; + static const char* TX_INTERNALLITERAL_TOPRIGHT = "TopRight"; + static const char* TX_INTERNALLITERAL_SCREENBOUNDSMM = "ScreenBoundsMm"; + static const char* TX_INTERNALLITERAL_SCREENBOUNDSPIXELS = "ScreenBoundsPixels"; + static const char* TX_INTERNALLITERAL_CONFIGUREDEYESWITHGAZE = "ConfiguredEyesWithGaze"; + //these below could be in an enum, but wont be, since its an internal stream + static const char* TX_INTERNALLITERAL_CONFIGUREDEYESWITHGAZENONE = "ConfiguredEyesWithGazeNone"; + static const char* TX_INTERNALLITERAL_CONFIGUREDEYESWITHGAZEBOTH = "ConfiguredEyesWithGazeBoth"; + static const char* TX_INTERNALLITERAL_CONFIGUREDEYESWITHGAZELEFT = "ConfiguredEyesWithGazeLeft"; + static const char* TX_INTERNALLITERAL_CONFIGUREDEYESWITHGAZERIGHT = "ConfiguredEyesWithGazeRight"; + + static const char* TX_INTERNALLITERAL_DETECTEDEYES = "DetectedEyes"; + static const char* TX_INTERNALLITERAL_DETECTEDEYESNONE = "DetectedEyesNone"; + static const char* TX_INTERNALLITERAL_DETECTEDEYESBOTH = "DetectedEyesBoth"; + static const char* TX_INTERNALLITERAL_DETECTEDEYESLEFT = "DetectedEyesLeft"; + static const char* TX_INTERNALLITERAL_DETECTEDEYESRIGHT = "DetectedEyesRight"; + + /** + * Internal Zoom Literals + **/ + static const char* TX_INTERNALLITERAL_ZOOMDIRECTION = "ZoomDirection"; + static const char* TX_INTERNALLITERAL_ZOOMGAZEPOINTX = "ZoomGazePointX"; + static const char* TX_INTERNALLITERAL_ZOOMGAZEPOINTY = "ZoomGazePointY"; + + /** + * Internal Eye Position Behavior Literals + **/ + static const char* TX_INTERNALLITERAL_LEFTEYETRACKED = "LeftEyeTracked"; + static const char* TX_INTERNALLITERAL_RIGHTEYETRACKED = "RightEyeTracked"; + + /** + * Internal Process Client Ids + **/ + static const char* TX_INTERNALLITERAL_CLIENTPROCESSIDS = "ClientProcessIds"; + + + +/*********************************************************************************************************************/ + +#endif /* !defined(__TOBII_TX_INTERNALLITERALS__H__) */ + +/*********************************************************************************************************************/ diff --git a/Tobii-EyeX/include/eyex/EyeXInternalTypes.h b/Tobii-EyeX/include/eyex/EyeXInternalTypes.h new file mode 100755 index 0000000..92c5419 --- /dev/null +++ b/Tobii-EyeX/include/eyex/EyeXInternalTypes.h @@ -0,0 +1,44 @@ +/********************************************************************************************************************* + * Copyright 2013-2014 Tobii Technology AB. All rights reserved. + * EyeXInternalTypes.h + *********************************************************************************************************************/ + +#if !defined(__TOBII_TX_INTERNAL_TYPES__H__) +#define __TOBII_TX_INTERNAL_TYPES__H__ + +/*********************************************************************************************************************/ + +/** + Callback for an Invalid argument. + + @param functionName [in]: + A TX_CONSTSTRING + + @param parameterName [in]: + A TX_CONSTSTRING + + @param userParam [in]: + Supplied when registering the callback, normally used to respond to the event outside of the callback. + + @return + void + */ +typedef void (TX_CALLCONVENTION *TX_INVALIDARGUMENTCALLBACK)( + TX_CONSTSTRING functionName, + TX_CONSTSTRING parameterName, + TX_USERPARAM userParam + ); + +/*********************************************************************************************************************/ + +typedef enum { + TX_PROPERTYFLAG_NONE = TX_FLAGS_NONE_VALUE, + TX_PROPERTYFLAG_NONREMOVABLE = 1 << 0, + TX_PROPERTYFLAG_MANUALCLONING = 1 << 1 +} TX_PROPERTYFLAGS; + +/*********************************************************************************************************************/ + +#endif /* !defined(__TOBII_TX_INTERNAL_TYPES__H__) */ + +/*********************************************************************************************************************/ diff --git a/Tobii-EyeX/include/eyex/EyeXLiterals.h b/Tobii-EyeX/include/eyex/EyeXLiterals.h new file mode 100755 index 0000000..e7b38be --- /dev/null +++ b/Tobii-EyeX/include/eyex/EyeXLiterals.h @@ -0,0 +1,373 @@ +/********************************************************************************************************************* + * Copyright 2013-2014 Tobii Technology AB. All rights reserved. + * EyeXLiterals.h + *********************************************************************************************************************/ + +#if !defined(__TOBII_TX_LITERALS__H__) +#define __TOBII_TX_LITERALS__H__ + +/********************************************************************************************************************* + * Literals + *********************************************************************************************************************/ + + + + /** + * Message Literals + */ + static const char* TX_LITERAL_HEADER = "Header"; + static const char* TX_LITERAL_BODY = "Body"; + static const char* TX_LITERAL_ID = "Id"; + static const char* TX_LITERAL_PROCESSID = "ProcessId"; + + /** + * Client Literals + */ + static const char* TX_LITERAL_AGENTID = "AgentId"; + static const char* TX_LITERAL_TARGETPROCESSID = "TargetProcessId"; + static const char* TX_LITERAL_CLIENTMODE = "ClientMode"; + + /** + * Miscellaneous Literals + */ + static const char* TX_LITERAL_TYPE = "Type"; + static const char* TX_LITERAL_TIMESTAMP = "Timestamp"; + static const char* TX_LITERAL_DATA = "Data"; + static const char* TX_LITERAL_PARAMETERS = "Parameters"; + static const char* TX_LITERAL_X = "X"; + static const char* TX_LITERAL_Y = "Y"; + static const char* TX_LITERAL_Z = "Z"; + + /** + * Bounds Literals + */ + static const char* TX_LITERAL_BOUNDS = "Bounds"; + static const char* TX_LITERAL_BOUNDSTYPE = "BoundsType"; + static const char* TX_LITERAL_NONE = "None"; + static const char* TX_LITERAL_RECTANGULAR = "Rectangular"; + static const char* TX_LITERAL_TOP = "Top"; + static const char* TX_LITERAL_LEFT = "Left"; + static const char* TX_LITERAL_RIGHT = "Right"; + static const char* TX_LITERAL_BOTTOM = "Bottom"; + static const char* TX_LITERAL_WIDTH = "Width"; + static const char* TX_LITERAL_HEIGHT = "Height"; + + /** + * Interactor Literals + */ + static const char* TX_LITERAL_ROOTID = "_RootId"; + static const char* TX_LITERAL_GLOBALINTERACTORWINDOWID = "GlobalInteractorWindowId"; + static const char* TX_LITERAL_MASK = "Mask"; + static const char* TX_LITERAL_MASKID = "MaskId"; + static const char* TX_LITERAL_MASKBOUNDS = "MaskBounds"; + + /** + * Mask Literals + */ + static const char* TX_LITERAL_MASKTYPE = "MaskType"; + static const char* TX_LITERAL_ROWCOUNT = "RowCount"; + static const char* TX_LITERAL_COLUMNCOUNT = "ColumnCount"; + + /** + * Gaze Point Data Behavior Literals + */ + static const char* TX_LITERAL_GAZEPOINTDATAMODE = "GazePointDataMode"; + static const char* TX_LITERAL_GAZEPOINTDATAEVENTTYPE = "GazePointDataEventType"; + + /** + * Activation Behavior Literals + */ + static const char* TX_LITERAL_ACTIVATABLEEVENTTYPE = "ActivatableEventType"; + static const char* TX_LITERAL_HASACTIVATIONFOCUS = "HasActivationFocus"; + static const char* TX_LITERAL_HASTENTATIVEACTIVATIONFOCUS = "HasTentativeActivationFocus"; + static const char* TX_LITERAL_ISACTIVATED = "IsActivated"; + static const char* TX_LITERAL_ISTENTATIVEFOCUSENABLED = "IsTentativeFocusEnabled"; + static const char* TX_LITERAL_ISSMALLITEMDETECTIONENABLED = "IsSmallItemDetectionEnabled"; + + /** + * Fixation Data Behavior Literals + */ + static const char* TX_LITERAL_FIXATIONDATAMODE = "FixationDataMode"; + static const char* TX_LITERAL_FIXATIONDATAEVENTTYPE = "FixationDataEventType"; + + /** + * Action data Behavior Literals + */ + static const char* TX_LITERAL_ACTIONDATAEVENTTYPE = "ActionDataEventType"; + static const char* TX_LITERAL_ACTIVATIONMISSED = "ActivationMissed"; + + /** + * Gaze-Aware Behavior Literals + */ + static const char* TX_LITERAL_HASGAZE = "HasGaze"; + static const char* TX_LITERAL_GAZEAWAREMODE = "GazeAwareMode"; + static const char* TX_LITERAL_DELAYTIME = "DelayTime"; + + /** + * Gaze Data Diagnostics Behavior Literals + */ + static const char* TX_LITERAL_QUALITY = "Quality"; + static const char* TX_LITERAL_NOISE = "Noise"; + static const char* TX_LITERAL_INSACCADE = "InSaccade"; + static const char* TX_LITERAL_INFIXATION = "InFixation"; + + /** + * Eye Position Behavior Literals + */ + static const char* TX_LITERAL_LEFTEYEPOSITION = "LeftEyePosition"; + static const char* TX_LITERAL_RIGHTEYEPOSITION = "RightEyePosition"; + static const char* TX_LITERAL_LEFTEYEPOSITIONNORMALIZED = "LeftEyePositionNormalized"; + static const char* TX_LITERAL_RIGHTEYEPOSITIONNORMALIZED = "RightEyePositionNormalized"; + static const char* TX_LITERAL_HASLEFTEYEPOSITION = "HasLeftEyePosition"; + static const char* TX_LITERAL_HASRIGHTEYEPOSITION = "HasRightEyePosition"; + + /** + * Presence Behavior Literals + */ + static const char* TX_LITERAL_PRESENCEDATA = "Presence"; + + + /** + * Pannable Behavior Literals + */ + static const char* TX_LITERAL_PANVELOCITYX = "PanVelocityX"; + static const char* TX_LITERAL_PANVELOCITYY = "PanVelocityY"; + static const char* TX_LITERAL_PANSTEPX = "PanStepX"; + static const char* TX_LITERAL_PANSTEPY = "PanStepY"; + static const char* TX_LITERAL_PANSTEPDURATION = "PanStepDuration"; + static const char* TX_LITERAL_PANHANDSFREE = "PanHandsFree"; + static const char* TX_LITERAL_PANPROFILE = "Profile"; + static const char* TX_LITERAL_PANDIRECTIONSAVAILABLE = "PanDirectionsAvailable"; + static const char* TX_LITERAL_PANPEAKVELOCITY = "PeakVelocity"; + static const char* TX_LITERAL_PANADAPTVELOCITYTOVIEWPORT = "AdaptVelocityToViewport"; + static const char* TX_LITERAL_PANMAXZONERELATIVESIZE = "MaxPanZoneRelativeSize"; + static const char* TX_LITERAL_PANMAXZONESIZE = "MaxPanZoneSize"; + static const char* TX_LITERAL_PANZONESIZE = "PanZoneSize"; + static const char* TX_LITERAL_PANNABLEEVENTTYPE = "PannableEventType"; + + /** + * Callback Response Literals + */ + static const char* TX_LITERAL_REQUESTTYPE = "RequestType"; + static const char* TX_LITERAL_REQUESTID = "RequestId"; + static const char* TX_LITERAL_ERRORMESSAGE = "ErrorMessage"; + static const char* TX_LITERAL_RESULT = "Result"; + + /** + * Interaction Mode Literals + */ + static const char* TX_LITERAL_ACTIONTYPE = "ActionType"; + + /** + * State literals + */ + static const char* TX_LITERAL_STATEPATH = "StatePath"; + static const char* TX_LITERAL_STATEPATHDELIMITER = "."; + + /* + * Configuration Tool Literals + */ + static const char* TX_LITERAL_CONFIGURATIONTOOL = "ConfigurationTool"; + + /* + * Current Profile Literals + */ + static const char* TX_LITERAL_PROFILENAME = "ProfileName"; + + + +/*********************************************************************************************************************/ + +/** + * Literals for state paths. + * + * @field TX_STATEPATH_EYETRACKING: + * The root node for all eyetracking information. + * GETTABLE. + * + * @field TX_STATEPATH_EYETRACKINGSCREENBOUNDS: + * Holds the virtual screen bounds in pixels. + * The value can be retrieved from the state bag as a TX_RECT structure with GetStateValueAsRectangle. + * If the screen bounds can not be determined screen bounds (0, 0, 0, 0) will be returned. + * Replaces deprecated state path TX_STATEPATH_SCREENBOUNDS from version 1.3.0. + * GETTABLE. + * \since Version 1.3.0 + * + * @field TX_STATEPATH_EYETRACKINGDISPLAYSIZE: + * Holds the display size in millimeters as width and height. + * The value can be retrieved from the state bag as a TX_SIZE2 structure with GetStateValueAsSize2. + * If the display size can not be determined Width and Height (0, 0) will be returned. + * Replaces deprecated state path TX_STATEPATH_DISPLAYSIZE from version 1.3.0. + * GETTABLE. + * \since Version 1.3.0 + * + * @field TX_STATEPATH_EYETRACKINGSTATE: + * Holds the eye tracking state. The value is of type TX_EYETRACKINGDEVICESTATUS. + * GETTABLE. + * + * @field TX_STATEPATH_EYETRACKINGCURRENTPROFILE: + * Holds the following data: + * "name" - See TX_STATEPATH_EYETRACKINGCURRENTPROFILENAME. + * "trackedeyes" - See TX_STATEPATH_EYETRACKINGCURRENTPROFILETRACKEDEYES. + * GETTABLE. + * \since Version 1.3.0 + * + * @field TX_STATEPATH_EYETRACKINGCURRENTPROFILENAME: + * Holds the name of the current eye tracking profile. The value is of type TX_STRING. + * Replaces deprecated state path TX_STATEPATH_PROFILENAME from version 1.3.0. + * GETTABLE. + * \since Version 1.3.0 + * + * @field TX_STATEPATH_EYETRACKINGCURRENTPROFILETRACKEDEYES: + * Holds the tracked eyes of the current eye tracking profile. The value is of type TX_TRACKEDEYES. + * GETTABLE and SETTABLE. + * \since Version 1.3.0 + * + * @field TX_STATEPATH_EYETRACKINGPROFILES: + * Holds the list of available eye tracking profiles. The value is an array of TX_STRING. It can be accessed with + * txGetStateValueAsString as a string containing all profiles separated with a null termination character. + * There is also a utility function available to access profiles as a std::vector of std::strings, see Tx::GetStateValueAsArrayOfStrings. + * GETTABLE. + * \since Version 1.3.0 + * + * @field TX_STATEPATH_EYETRACKINGCONFIGURATIONSTATUS: + * Holds the configuration status of the eye tracker. The value is of type TX_EYETRACKINGCONFIGURATIONSTATUS. + * GETTABLE. + * \since Version 1.1.0 + * + * @field TX_STATEPATH_EYETRACKINGINFO: + * Holds information about the eye tracker. + * GETTABLE. + * \since Version 1.3.0 + * + * @field TX_STATEPATH_EYETRACKINGINFOMODELNAME: + * Eye tracker model name. The value is of type TX_STRING. + * GETTABLE. + * \since Version 1.3.0 + * + * @field TX_STATEPATH_EYETRACKINGINFOSERIALNUMBER: + * Eye tracker serial number. The value is of type TX_STRING. + * GETTABLE. + * \since Version 1.3.0 + * + * @field TX_STATEPATH_EYETRACKINGINFOGENERATION: + * Eye tracker generation name. The value is of type TX_STRING. + * GETTABLE. + * \since Version 1.3.0 + * + * @field TX_STATEPATH_EYETRACKINGINFOFIRMWAREVERSION: + * Eye tracker firmware version. The value is of type TX_STRING. + * GETTABLE. + * \since Version 1.3.0 + * + * @field TX_STATEPATH_EYETRACKINGINFOEYEXCONTROLLERCOREVERSION: + * EyeX Controller Core Version. The value is of type TX_STRING. + * GETTABLE. + * \since Version 1.3.0 + * + * @field TX_STATEPATH_ENGINEINFOVERSION: + * Reports the engine version. The value is of type TX_STRING. + * Replaces deprecated state path TX_STATEPATH_ENGINEVERSION since version 1.3.0. + * GETTABLE. + * \since Version 1.3.0 + * + * @field TX_STATEPATH_ENGINEINFOINTERNAL: + * Holds the following data: + * "tobiiserviceversion" - The installed version of Tobii Service as TX_STRING or empty string if not installed. + * "tobiieyexcontrollerdriverversion" - The installed version of Tobii EyeX Controller Driver as TX_STRING or empty string if not installed. + * "tobiiusbserviceversion" - The installed version of Tobii USB Service version as TX_STRING or empty string if not installed. + * "tobiieyexinteractionversion" - The installed version of Tobii EyeX Interaction as TX_STRING or empty string if not installed. + * "tobiieyexconfigversion" - The installed version of Tobii EyeX Config as TX_STRING or empty string if not installed. + * GETTABLE. + * \since Version 1.3.0 + * + * @field TX_STATEPATH_USERPRESENCE: + * Holds data about user presence. The value is of type TX_USERPRESENCE. + * The value of TX_USERPRESENCE will be TX_USERPRESENCE_UNKNOWN if there isn't any observer registered for this state. + * GETTABLE. + * + * @field TX_STATEPATH_FAILEDACTION: + * Notifies when interactions fail. The value is of type TX_FAILEDACTIONTYPE. + * SUBSCRIBABLE. + * + * @field TX_STATEPATH_INTERACTIONMODES: + * Holds the current engine interaction mode. The value is of type TX_INTERACTIONMODES. + * GETTABLE. + * \since Version 1.1.0 + * + * @field TX_STATEPATH_PROFILENAME: + * Holds the name of the eye tracking profile used. The value is of type TX_STRING. + * Deprecated, use TX_STATEPATH_EYETRACKINGCURRENTPROFILENAME for engine version 1.3.0 and greater. + * GETTABLE. + * + * @field TX_STATEPATH_ENGINEVERSION: + * Reports the engine version. The value is of type TX_STRING. + * Deprecated, use TX_STATEPATH_ENGINEINFOVERSION for engine version 1.3.0 and greater. + * GETTABLE. + * + * @field TX_STATEPATH_SCREENBOUNDS: + * Holds the virtual screen bounds in pixels. + * The value can be retrieved from the state bag as a TX_RECT structure with GetStateValueAsRectangle. + * If the screen bounds can not be determined screen bounds (0, 0, 0, 0) will be returned. + * Deprecated, use TX_STATEPATH_EYETRACKINGSCREENBOUNDS for engine version 1.3.0 and greater. + * GETTABLE. + * + * @field TX_STATEPATH_DISPLAYSIZE: + * Holds the display size in millimeters as width and height. + * The value can be retrieved from the state bag as a TX_SIZE2 structure with GetStateValueAsSize2. + * If the display size can not be determined Width and Height (0, 0) will be returned. + * Deprecated, use TX_STATEPATH_EYETRACKINGDISPLAYSIZE for engine version 1.3.0 and greater. + * GETTABLE. + * + * @field TX_STATEPATH_CONFIGURATIONSTATUS: + * Holds the configuration status of the eye tracker. The value is of type TX_EYETRACKINGCONFIGURATIONSTATUS. + * \since Version 1.1.0 + * Deprecated, use TX_STATEPATH_EYETRACKINGCONFIGURATIONSTATUS for engine version 1.3.0 and greater. + * GETTABLE. + * + */ + + static const char* TX_STATEPATH_EYETRACKING = "eyeTracking"; + static const char* TX_STATEPATH_EYETRACKINGSCREENBOUNDS = "eyeTracking.screenBounds"; + static const char* TX_STATEPATH_EYETRACKINGDISPLAYSIZE = "eyeTracking.displaySize"; + static const char* TX_STATEPATH_EYETRACKINGSTATE = "eyeTracking.state"; + + static const char* TX_STATEPATH_EYETRACKINGPROFILES = "eyeTracking.profiles"; + static const char* TX_STATEPATH_EYETRACKINGCURRENTPROFILE = "eyeTracking.currentprofile"; + static const char* TX_STATEPATH_EYETRACKINGCURRENTPROFILENAME = "eyeTracking.currentprofile.name"; + static const char* TX_STATEPATH_EYETRACKINGCURRENTPROFILETRACKEDEYES = "eyeTracking.currentprofile.trackedeyes"; + + static const char* TX_STATEPATH_EYETRACKINGCONFIGURATIONSTATUS = "eyeTracking.configurationStatus"; + + static const char* TX_STATEPATH_EYETRACKINGINFO = "eyeTracking.info"; + static const char* TX_STATEPATH_EYETRACKINGINFOMODELNAME = "eyeTracking.info.modelname"; + static const char* TX_STATEPATH_EYETRACKINGINFOSERIALNUMBER = "eyeTracking.info.serialnumber"; + static const char* TX_STATEPATH_EYETRACKINGINFOGENERATION = "eyeTracking.info.generation"; + static const char* TX_STATEPATH_EYETRACKINGINFOFIRMWAREVERSION = "eyeTracking.info.firmwareversion"; + static const char* TX_STATEPATH_EYETRACKINGINFOHASFIXEDDISPLAYAREA = "eyeTracking.info.hasfixeddisplayarea"; + static const char* TX_STATEPATH_EYETRACKINGINFOTOBIIEYEXCONTROLLERCOREVERSION = "eyeTracking.info.tobiieyexcontrollercoreversion"; + + static const char* TX_STATEPATH_ENGINEINFOVERSION = "engine.info.version"; + static const char* TX_STATEPATH_ENGINEINFOINTERNAL = "engine.info.internal"; + + static const char* TX_STATEPATH_GAZETRACKING = "status.gazeTracking"; + + static const char* TX_STATEPATH_USERPRESENCE = "userPresence"; + + static const char* TX_STATEPATH_FAILEDACTION = "failedAction"; + + static const char* TX_STATEPATH_INTERACTIONMODES = "status.interaction.interactionModes"; + + /* Deprecated since version 1.3.0. For compatibility between client libs and engine version 1.2.1 or lesser */ + static const char* TX_STATEPATH_PROFILENAME = "eyeTracking.profileName"; + static const char* TX_STATEPATH_ENGINEVERSION = "engineVersion"; + static const char* TX_STATEPATH_CONFIGURATIONSTATUS = "eyeTracking.configurationStatus"; + static const char* TX_STATEPATH_SCREENBOUNDS = "eyeTracking.screenBounds"; + static const char* TX_STATEPATH_DISPLAYSIZE = "eyeTracking.displaySize"; + + +/*********************************************************************************************************************/ + +#endif /* !defined(__TOBII_TX_LITERALS__H__) */ + +/*********************************************************************************************************************/ diff --git a/Tobii-EyeX/include/eyex/EyeXMacros.h b/Tobii-EyeX/include/eyex/EyeXMacros.h new file mode 100755 index 0000000..b264989 --- /dev/null +++ b/Tobii-EyeX/include/eyex/EyeXMacros.h @@ -0,0 +1,234 @@ +/********************************************************************************************************************* + * Copyright 2013-2014 Tobii Technology AB. All rights reserved. + * EyeXMacros.h + *********************************************************************************************************************/ + +#if !defined(__TOBII_TX_MACROS__H__) +#define __TOBII_TX_MACROS__H__ + +/*********************************************************************************************************************/ + +#ifdef WIN32 + #define TX_CALLCONVENTION __cdecl + #ifdef TX_STATIC_LIB + #define TX_API + #else + #ifdef TX_EXPORTING + #define TX_API __declspec(dllexport) + #else + #define TX_API __declspec(dllimport) + #endif /* TX_EXPORTING */ + #endif /* TX_STATIC_LIB */ +#else + #define TX_CALLCONVENTION + #define TX_API +#endif /* WIN32 */ + +/*********************************************************************************************************************/ + +#define TX_PREFIX(prefix, fn) prefix##fn +#define TX_PREFIXSTR2(fn) #fn +#define TX_PREFIXSTR(fn) TX_PREFIXSTR2(tx##fn) + +/*********************************************************************************************************************/ + +/** + * Common macro used for functions that should be public. + */ +#define TX_API_FUNCTION_BASE(impexp, fn, prefix) \ + impexp TX_RESULT TX_CALLCONVENTION prefix##fn + +/** + * Base macro which generates code common for C and CLI/C++ + */ +#if defined(__cplusplus) + #define TX_C_BEGIN extern "C" { + #define TX_C_END } +#else + #define TX_C_BEGIN + #define TX_C_END +#endif + +#define _TX_API_FUNCTION(fnName, paramList) \ + TX_C_BEGIN \ + TX_API_FUNCTION_BASE(TX_API, fnName paramList, tx); \ + typedef TX_RESULT (TX_CALLCONVENTION *fnName##Hook)paramList; \ + TX_API fnName##Hook TX_CALLCONVENTION TX_PREFIX(tx, Set##fnName##Hook)(fnName##Hook); \ + TX_C_END + +#define _TX_API_FUNCTION_CPP(fnName, paramList) \ + TX_API_FUNCTION_BASE(TX_API, fnName paramList, ); \ + typedef TX_RESULT (TX_CALLCONVENTION *fnName##Hook)paramList; \ + TX_API fnName##Hook TX_CALLCONVENTION TX_PREFIX(, Set##fnName##Hook)(fnName##Hook); \ + + +/** + * The final API function generator macro. + * In C this generates the following: + * + * __declspec([dllexport/dllimport]) TX_RESULT __cdecl SomeFunction(parameters); + * __declspec([dllexport/dllimport]) TX_RESULT __cdecl _SomeFunction(parameters); + * typedef TX_RESULT (__cdecl *SomeFunctionHook)(parameters); + * __declspec([dllexport/dllimport]) SetSomeFunctionHook(SomeFunctionHook); + */ +#if !defined(TX_API_FUNCTION) +#define TX_API_FUNCTION(fnName, paramList) \ + _TX_API_FUNCTION(fnName, paramList) +#endif /* !defined(TX_API_FUNCTION) */ + +#if !defined(TX_API_FUNCTION_CPP) +#define TX_API_FUNCTION_CPP(fnName, paramList) \ + namespace Tx {_TX_API_FUNCTION_CPP(fnName, paramList) } +#endif /* !defined(TX_API_FUNCTION_CPP) */ + +/** + * This macro generates the beginning of an enum definition. + */ +#if !defined(TX_BEGIN_ENUM) +#define TX_BEGIN_ENUM(clrName) typedef enum { +#endif /* !defined(TX_BEGIN_ENUM) */ + +/** + * This macro generates the end of an enum definition. + */ +#if !defined(TX_END_ENUM) +#define TX_END_ENUM(name, clrName) } name; +#endif /* !defined(TX_END_ENUM) */ + +/** + * This macro generates the beginning of an enum flags definition. + */ +#if !defined(TX_BEGIN_FLAGS) +#define TX_BEGIN_FLAGS(clrName) TX_BEGIN_ENUM(clrName) +#endif /* !defined(TX_BEGIN_FLAGS) */ + +/** + * This macro generates the end of an enum flags definition. + */ +#if !defined(TX_END_FLAGS) +#define TX_END_FLAGS(name, clrName) TX_END_ENUM(name, clrName) +#endif /* !defined(TX_END_FLAGS) */ + + +#define TX_ENUM_STARTVALUE 1 +#define TX_INTERNAL_ENUM_STARTVALUE 10000000 +#define TX_FLAGS_NONE_VALUE 0 + +/** + * This macro generates a single value in an enum definition. + */ +#if !defined(TX_ENUM_VALUE) +#define TX_ENUM_VALUE(name, clrName) name +#endif /* !defined(TX_ENUM_VALUE) */ + +#if !defined(TX_BEGIN_SCOPE) +#define TX_BEGIN_SCOPE(name) +#endif /* !defined(TX_BEGIN_SCOPE) */ + +#if !defined(TX_END_SCOPE) +#define TX_END_SCOPE +#endif /* !defined(TX_END_SCOPE) */ + +/** + * This macro generates the beginning of message tokens definition. + */ +#if !defined(TX_CONSTANTS_BEGIN) +#define TX_CONSTANTS_BEGIN(name) +#endif /* !defined(TX_CONSTANTS_BEGIN) */ + +/** + * This macro generates the end of message tokens definition. + */ +#if !defined(TX_CONSTANTS_END) +#define TX_CONSTANTS_END +#endif /* !defined(TX_CONSTANTS_END) */ + +/** + * This macro generates a single message token. + */ +#if !defined(TX_LITERALS_VALUE) +#define TX_LITERALS_VALUE(name, clrName, str) static const char* name = str; +#endif /* !defined(TX_LITERALS_VALUE) */ + +#if !defined(TX_CONSTANT_INTEGER_VALUE) +#define TX_CONSTANT_INTEGER_VALUE(name, clrName, value) static const int name = value; +#endif /* !defined(TX_CONSTANT_INTEGER_VALUE) */ + +#if !defined(TX_CONSTANT_REAL_VALUE) +#define TX_CONSTANT_REAL_VALUE(name, clrName, value) static const double name = value; +#endif /* !defined(TX_CONSTANT_REAL_VALUE) */ + +#if !defined(TX_CONSTANT_BYTE_VALUE) +#define TX_CONSTANT_BYTE_VALUE(name, clrName, value) static const unsigned char name = value; +#endif /* !defined(TX_CONSTANT_BYTE_VALUE) */ + +/** + * This macro generates code which marks the beginning of a set of public api functions. + */ +#if !defined(TX_API_FUNCTIONS_BEGIN) +#define TX_API_FUNCTIONS_BEGIN +#endif /* !defined(TX_API_FUNCTIONS_BEGIN) */ + +/** + * This macro generates code which marks the end of a set of public api functions. + */ +#if !defined(TX_API_FUNCTIONS_END) +#define TX_API_FUNCTIONS_END +#endif /* !defined(TX_API_FUNCTIONS_END) */ + +#if !defined(TX_OUT_PARAM) +#define TX_OUT_PARAM(param) param* +#endif /* !defined(TX_OUT_PARAM) */ + +#if !defined(TX_REF_PARAM) +#define TX_REF_PARAM(param) param* +#endif /* !defined(TX_REF_PARAM) */ + +#if !defined(TX_IN_PARAM) +#define TX_IN_PARAM(param) const param* +#endif /* !defined(TX_IN_PARAM) */ + +#if !defined(TX_PTR_PARAM) +#define TX_PTR_PARAM(param) param* +#endif /* !defined(TX_PTR_PARAM) */ + +#if !defined(TX_CONSTPTR_PARAM) +#define TX_CONSTPTR_PARAM(param) const param* +#endif /* !defined(TX_CONSTPTR_PARAM) */ + +#if !defined(TX_CALLBACK_PARAM) +#define TX_CALLBACK_PARAM(param) param +#endif /* !defined(TX_CALLBACK_PARAM) */ + +/*********************************************************************************************************************/ + +#if !defined(TX_DEFINE_CALLABLE) +#define TX_DEFINE_CALLABLE(name, clrName, returnType, paramList) \ + typedef returnType (TX_CALLCONVENTION *name)paramList; +#endif /* !defined(TX_DEFINE_CALLABLE) */ + +#if !defined(TX_STRUCT_BEGIN) +#define TX_STRUCT_BEGIN(name, clrName) \ + typedef struct { +#endif /* !defined(TX_STRUCT_BEGIN) */ + +#if !defined(TX_STRUCT_END) +#define TX_STRUCT_END(name, clrName) \ + } name; +#endif /* !defined(TX_STRUCT_END) */ + + +/*********************************************************************************************************************/ + +/** + Macro that generates a type of the specified type. + */ +#if !defined(TX_DEFINE_TYPE) +#define TX_DEFINE_TYPE(type, name) typedef type name; +#endif /* !defined(TX_TRANSLATE_TYPE) */ + +/*********************************************************************************************************************/ + +#endif /* !defined(__TOBII_TX_MACROS__H__) */ + +/*********************************************************************************************************************/ diff --git a/Tobii-EyeX/include/eyex/EyeXNotification.h b/Tobii-EyeX/include/eyex/EyeXNotification.h new file mode 100755 index 0000000..062ab63 --- /dev/null +++ b/Tobii-EyeX/include/eyex/EyeXNotification.h @@ -0,0 +1,82 @@ +/********************************************************************************************************************* + * Copyright 2013-2014 Tobii Technology AB. All rights reserved. + * EyeXNotification.h + *********************************************************************************************************************/ + +#if !defined(__TOBII_TX_NOTIFICATIONS_API__H__) +#define __TOBII_TX_NOTIFICATIONS_API__H__ + +/*********************************************************************************************************************/ + +/** + txGetNotificationType + + Gets the TX_NOTIFICATIONTYPE of a notification. + + @param hNotification [in]: + A TX_CONSTHANDLE to the notification. + Must not be TX_EMPTY_HANDLE. + + @param pNotificationType [out]: + A pointer to a TX_NOTIFICATIONTYPE which will be set to the type of the notification. + Must not be NULL. + + @return + TX_RESULT_OK: The type of the notification was successfully retrieved. + TX_RESULT_EYEXNOTINITIALIZED: The EyeX client environment is not initialized. + TX_RESULT_INVALIDARGUMENT: An invalid argument was passed to the function. + */ +TX_C_BEGIN +TX_API TX_RESULT TX_CALLCONVENTION txGetNotificationType( + TX_CONSTHANDLE hNotification, + TX_NOTIFICATIONTYPE* pNotificationType + ); +TX_C_END + +typedef TX_RESULT (TX_CALLCONVENTION *GetNotificationTypeHook)( + TX_CONSTHANDLE hNotification, + TX_NOTIFICATIONTYPE* pNotificationType + ); + + +/*********************************************************************************************************************/ + +/** + txGetNotificationData + + Gets the data of a notification. + + @param hNotification [in]: + A TX_CONSTHANDLE to the notification. + Must not be TX_EMPTY_HANDLE. + + @param phObject [out]: + A pointer to a TX_HANDLE to which the handle of the object used as data will be copied. + This handle must be released using txReleaseObject to avoid leaks. + Must not be NULL. + The value of the pointer must be set to TX_EMPTY_HANDLE. + + @return + TX_RESULT_OK: The data of the notification was successfully retrieved. + TX_RESULT_EYEXNOTINITIALIZED: The EyeX client environment is not initialized. + TX_RESULT_INVALIDARGUMENT: An invalid argument was passed to the function. + TX_RESULT_NOTFOUND: The notification does not have any data. + */ +TX_C_BEGIN +TX_API TX_RESULT TX_CALLCONVENTION txGetNotificationData( + TX_CONSTHANDLE hNotification, + TX_HANDLE* phObject + ); +TX_C_END + +typedef TX_RESULT (TX_CALLCONVENTION *GetNotificationDataHook)( + TX_CONSTHANDLE hNotification, + TX_HANDLE* phObject + ); + + +/*********************************************************************************************************************/ + +#endif /* !defined(__TOBII_TX_NOTIFICATIONS_API__H__) */ + +/*********************************************************************************************************************/ \ No newline at end of file diff --git a/Tobii-EyeX/include/eyex/EyeXObject.h b/Tobii-EyeX/include/eyex/EyeXObject.h new file mode 100755 index 0000000..acd7ecf --- /dev/null +++ b/Tobii-EyeX/include/eyex/EyeXObject.h @@ -0,0 +1,194 @@ +/********************************************************************************************************************* + * Copyright 2013-2014 Tobii Technology AB. All rights reserved. + * EyeXObject.h + *********************************************************************************************************************/ + +#if !defined(__TOBII_TX_OBJECT_API__H__) +#define __TOBII_TX_OBJECT_API__H__ + +/*********************************************************************************************************************/ + +/** + txGetContext + + Gets the context to which a specified interaction object belongs. + Unlike interaction objects, this handle does not need to be released. + + @param hObject [in]: + A TX_CONSTHANDLE to the interaction object for which the context should be retrieved. + Must not be TX_EMPTY_HANDLE. + + @param phContext [out]: + A pointer to a TX_CONSTCONTEXTHANDLE which will be set to the context. + Must not be NULL. + + @return + TX_RESULT_OK: The context was successfully retrieved. + TX_RESULT_EYEXNOTINITIALIZED: The EyeX client environment is not initialized. + TX_RESULT_INVALIDARGUMENT: An invalid argument was passed to the function. +*/ +TX_C_BEGIN +TX_API TX_RESULT TX_CALLCONVENTION txGetContext( + TX_CONSTHANDLE hObject, + TX_CONTEXTHANDLE* phContext + ); +TX_C_END + +typedef TX_RESULT (TX_CALLCONVENTION *GetContextHook)( + TX_CONSTHANDLE hObject, + TX_CONTEXTHANDLE* phContext + ); + + +/*********************************************************************************************************************/ + +/** + txGetObjectType + + Gets the TX_INTERACTIONOBJECTTYPE of an interaction object. + + @param hObject [in]: + A TX_CONSTHANDLE to the interaction object for which to get the TX_INTERACTIONOBJECTTYPE. + Must not be TX_EMPTY_HANDLE. + + @param phObjectType [out]: + A pointer to a TX_INTERACTIONOBJECTTYPE which will be set to the type of the object. + Must not be NULL. + + @return + TX_RESULT_OK: The TX_INTERACTIONOBJECTTYPE of the object was successfully retrieved. + TX_RESULT_EYEXNOTINITIALIZED: The EyeX client environment is not initialized. + TX_RESULT_INVALIDARGUMENT: An invalid argument was passed to the function. +*/ +TX_C_BEGIN +TX_API TX_RESULT TX_CALLCONVENTION txGetObjectType( + TX_CONSTHANDLE hObject, + TX_INTERACTIONOBJECTTYPE* phObjectType + ); +TX_C_END + +typedef TX_RESULT (TX_CALLCONVENTION *GetObjectTypeHook)( + TX_CONSTHANDLE hObject, + TX_INTERACTIONOBJECTTYPE* phObjectType + ); + + +/*********************************************************************************************************************/ + +/** + txGetObjectTypeName + + Gets the type name of an interaction object. + + @param hObject [in]: + A TX_CONSTHANDLE to the interaction object for which to get the type name. + Must not be TX_EMPTY_HANDLE. + + @param pObjectTypeName [out]: + A TX_STRING to which the type name will be copied. + The string will be null terminated. + May be NULL to only retreive the size. + + @param pObjectTypeNameSize [in,out]: + A pointer to a TX_SIZE which should contain the size of the pObjectTypeName string. + The size will be set to the current number of characters in the type name + 1. + Must not be NULL. + + @return + TX_RESULT_OK: The type name of the object or size of the string was successfully retreived. + TX_RESULT_EYEXNOTINITIALIZED: The EyeX client environment is not initialized. + TX_RESULT_INVALIDARGUMENT: An invalid argument was passed to the function. + TX_RESULT_INVALIDBUFFERSIZE: The size of the pObjectTypeName was to small. (*pObjectTypeNameSize will be set to the required size.) + */ +TX_C_BEGIN +TX_API TX_RESULT TX_CALLCONVENTION txGetObjectTypeName( + TX_CONSTHANDLE hObject, + TX_STRING pObjectTypeName, + TX_SIZE* pObjectTypeNameSize + ); +TX_C_END + +typedef TX_RESULT (TX_CALLCONVENTION *GetObjectTypeNameHook)( + TX_CONSTHANDLE hObject, + TX_STRING pObjectTypeName, + TX_SIZE* pObjectTypeNameSize + ); + + +/*********************************************************************************************************************/ + +/** + txReleaseObject + + Releases an interaction object. The object reference count will be decreased by one. + If the reference count hits 0 the object will be destroyed. + The handle will be set to TX_EMPTY_HANDLE. + + @param phObject [in,out]: + A pointer to a TX_HANDLE to the interaction object that should be released. + Must not be NULL. + The value of the pointer must not be TX_EMPTY_HANDLE. + + @return + TX_RESULT_OK: The object was successfully released. + TX_RESULT_EYEXNOTINITIALIZED: The EyeX client environment is not initialized. + TX_RESULT_INVALIDARGUMENT: An invalid argument was passed to the function. +*/ +TX_C_BEGIN +TX_API TX_RESULT TX_CALLCONVENTION txReleaseObject( + TX_HANDLE* phObject + ); +TX_C_END + +typedef TX_RESULT (TX_CALLCONVENTION *ReleaseObjectHook)( + TX_HANDLE* phObject + ); + + +/*********************************************************************************************************************/ + +/** + txFormatObjectAsText + + Formats an interaction object as text. (primarily for debugging purposes) + + @param hObject [in]: + A TX_HANDLE to an object. + Must not be TX_EMPTY_HANDLE. + + @param pText [out]: + A TX_STRING to which the formatted text will be copied. + Must be at least the size of the formatted text. + Can be NULL to only get the size of the formatted text. + + @param pTextSize [in,out]: + A pointer to a TX_SIZE which will be set the size of the formatted text. + Must not be NULL. + The value must be 0 if pText is NULL. + + @return + TX_RESULT_OK: The formatted text or required size of the string was successfully retreived. + TX_RESULT_EYEXNOTINITIALIZED: The EyeX client environment is not initialized. + TX_RESULT_INVALIDARGUMENT: An invalid argument was passed to the function. + TX_RESULT_INVALIDBUFFERSIZE: The size of the pText was to small. (*pTextSize will be set to the required size.) +*/ +TX_C_BEGIN +TX_API TX_RESULT TX_CALLCONVENTION txFormatObjectAsText( + TX_CONSTHANDLE hObject, + TX_STRING pText, + TX_SIZE* pTextSize + ); +TX_C_END + +typedef TX_RESULT (TX_CALLCONVENTION *FormatObjectAsTextHook)( + TX_CONSTHANDLE hObject, + TX_STRING pText, + TX_SIZE* pTextSize + ); + + +/*********************************************************************************************************************/ + +#endif /* !defined(__TOBII_TX_OBJECT_API__H__) */ + +/*********************************************************************************************************************/ diff --git a/Tobii-EyeX/include/eyex/EyeXProperty.h b/Tobii-EyeX/include/eyex/EyeXProperty.h new file mode 100755 index 0000000..2e87634 --- /dev/null +++ b/Tobii-EyeX/include/eyex/EyeXProperty.h @@ -0,0 +1,795 @@ +/********************************************************************************************************************* + * Copyright 2013-2014 Tobii Technology AB. All rights reserved. + * EyeXProperty.h + *********************************************************************************************************************/ + +#if !defined(__TOBII_TX_PROPERTY_API__H__) +#define __TOBII_TX_PROPERTY_API__H__ + +/*********************************************************************************************************************/ + +#ifdef TOBII_TX_DETAIL + +/*********************************************************************************************************************/ + +/** + txCreatePropertyBag + + Creates a property bag. + + @param hContext [in]: + A TX_CONTEXTHANDLE to the context on which to create the property bag. + Must not be TX_EMPTY_HANDLE. + + @param phBag [out]: + A pointer to a TX_HANDLE which will be set to the newly created property bag. + This handle must be released using txReleaseObject to avoid leaks. + Must not be NULL. + The value of the pointer must be set to TX_EMPTY_HANDLE. + + @param type [in]: + A TX_PROPERTYBAGTYPE which specifies what type of property bag to create. + + @return + TX_RESULT_OK: The property bag was successfully created. + TX_RESULT_EYEXNOTINITIALIZED: The EyeX client environment is not initialized. + TX_RESULT_INVALIDARGUMENT: An invalid argument was passed to the function. + */ +TX_C_BEGIN +TX_API TX_RESULT TX_CALLCONVENTION txCreatePropertyBag( + TX_CONTEXTHANDLE hContext, + TX_HANDLE* phBag, + TX_PROPERTYBAGTYPE type + ); +TX_C_END + +typedef TX_RESULT (TX_CALLCONVENTION *CreatePropertyBagHook)( + TX_CONTEXTHANDLE hContext, + TX_HANDLE* phBag, + TX_PROPERTYBAGTYPE type + ); + + +/*********************************************************************************************************************/ + +/** + txGetPropertyBagType + + Gets the TX_PROPERTYBAGTYPE of a property bag. + + @param hBounds [in]: + A TX_CONSTHANDLE to the property bag. + Must not be TX_EMPTY_HANDLE. + + @param pBoundsType [out]: + A pointer to a TX_PROPERTYBAGTYPE which will be set to the type of the property bag. + Must not be NULL. + + @return + TX_RESULT_OK: The type of the property bag was successfully retrieved. + TX_RESULT_EYEXNOTINITIALIZED: The EyeX client environment is not initialized. + TX_RESULT_INVALIDARGUMENT: An invalid argument was passed to the function. + */ +TX_C_BEGIN +TX_API TX_RESULT TX_CALLCONVENTION txGetPropertyBagType( + TX_CONSTHANDLE hBag, + TX_PROPERTYBAGTYPE* pType + ); +TX_C_END + +typedef TX_RESULT (TX_CALLCONVENTION *GetPropertyBagTypeHook)( + TX_CONSTHANDLE hBag, + TX_PROPERTYBAGTYPE* pType + ); + + +/*********************************************************************************************************************/ + +/** + txCreateProperty + + Creates a property on an interaction object. + + @param hObject [in]: + A TX_HANDLE to the object on which to create the property. + Must not be TX_EMPTY_HANDLE. + + @param phProperty [out]: + A pointer to a TX_PROPERTYHANDLE which will be set to the newly created property. + Must not be NULL. + The value of the pointer must be set to TX_EMPTY_HANDLE. + + @param propertyName [in]: + The name of the property. + Can be NULL or empty only if the object is of type TX_INTERACTIONOBJECTTYPE_PROPERTYBAG with bag type + TX_PROPERTYBAGTYPE_ARRAY. + + @return + TX_RESULT_OK: The property was successfully created. + TX_RESULT_EYEXNOTINITIALIZED: The EyeX client environment is not initialized. + TX_RESULT_INVALIDARGUMENT: An invalid argument was passed to the function. + TX_RESULT_INVALIDPROPERTYNAME: The name of the property was invalid. + TX_RESULT_DUPLICATEPROPERTY: There already exists a property with the specified name on this object. + */ +TX_C_BEGIN +TX_API TX_RESULT TX_CALLCONVENTION txCreateProperty( + TX_HANDLE hObject, + TX_PROPERTYHANDLE* phProperty, + TX_CONSTSTRING propertyName + ); +TX_C_END + +typedef TX_RESULT (TX_CALLCONVENTION *CreatePropertyHook)( + TX_HANDLE hObject, + TX_PROPERTYHANDLE* phProperty, + TX_CONSTSTRING propertyName + ); + + +/*********************************************************************************************************************/ + +/** + txRemoveProperty + + Removes a property from an interaction object. + + @param hObject [in]: + A TX_HANDLE to the object from which to remove the property. + Must not be TX_EMPTY_HANDLE. + + @param propertyName [in]: + The name of the property to remove. + Must not be NULL or empty string. + + @return + TX_RESULT_OK: The property was successfully removed. + TX_RESULT_EYEXNOTINITIALIZED: The EyeX client environment is not initialized. + TX_RESULT_INVALIDARGUMENT: An invalid argument was passed to the function. + TX_RESULT_NOTFOUND: A property with the specified name was not found. + TX_RESULT_PROPERTYNOTREMOVABLE: The specified property can not be removed. + */ +TX_C_BEGIN +TX_API TX_RESULT TX_CALLCONVENTION txRemoveProperty( + TX_HANDLE hObject, + TX_CONSTSTRING propertyName + ); +TX_C_END + +typedef TX_RESULT (TX_CALLCONVENTION *RemovePropertyHook)( + TX_HANDLE hObject, + TX_CONSTSTRING propertyName + ); + + +/*********************************************************************************************************************/ + +/** + txGetProperty + + Gets a property from an interaction object. + + @param hObject [in]: + A TX_CONSTHANDLE to the object from which to get the property. + Must not be TX_EMPTY_HANDLE. + + @param phProperty [out]: + A pointer to a TX_PROPERTYHANDLE which will be set to the property. + Must not be NULL. + The value of the pointer must be set to TX_EMPTY_HANDLE. + + @param propertyName [in]: + The name of the property to get. + Must not be NULL or empty string. + + @return + TX_RESULT_OK: The property was successfully created. + TX_RESULT_EYEXNOTINITIALIZED: The EyeX client environment is not initialized. + TX_RESULT_INVALIDARGUMENT: An invalid argument was passed to the function. + TX_RESULT_INVALIDPROPERTYNAME: The name of the property was invalid. + TX_RESULT_NOTFOUND: A property with the specified name was not found. + */ +TX_C_BEGIN +TX_API TX_RESULT TX_CALLCONVENTION txGetProperty( + TX_CONSTHANDLE hObject, + TX_PROPERTYHANDLE* phProperty, + TX_CONSTSTRING propertyName + ); +TX_C_END + +typedef TX_RESULT (TX_CALLCONVENTION *GetPropertyHook)( + TX_CONSTHANDLE hObject, + TX_PROPERTYHANDLE* phProperty, + TX_CONSTSTRING propertyName + ); + + +/*********************************************************************************************************************/ + +/** + txGetProperties + + Gets TX_HANDLEs to all properties on an interaction object. + + @param hObject [in]: + A TX_CONSTHANDLE to the object from which to get the properties. + Must not be TX_EMPTY_HANDLE. + + @param phProperties [out]: + A pointer to an array of TX_PROPERTYHANDLEs to which the property handles will be copied. + Can be NULL to only get the size. + + @param pPropertiesSize [in,out]: + A pointer to a TX_SIZE which will be set to the number of properties. + Must not be NULL. + The value must be 0 if phProperties is NULL. + + @return + TX_RESULT_OK: The handles or the required buffer size was retrieved successfully. + TX_RESULT_EYEXNOTINITIALIZED: The EyeX client environment is not initialized. + TX_RESULT_INVALIDARGUMENT: An invalid argument was passed to the function. + TX_RESULT_INVALIDBUFFERSIZE: The size of the array is invalid. (*pPropertiesSize will be set to the number of behaviors). + */ +TX_C_BEGIN +TX_API TX_RESULT TX_CALLCONVENTION txGetProperties( + TX_CONSTHANDLE hObject, + TX_PROPERTYHANDLE* phProperties, + TX_SIZE* pPropertiesSize + ); +TX_C_END + +typedef TX_RESULT (TX_CALLCONVENTION *GetPropertiesHook)( + TX_CONSTHANDLE hObject, + TX_PROPERTYHANDLE* phProperties, + TX_SIZE* pPropertiesSize + ); + + +/*********************************************************************************************************************/ + +/** + txGetPropertyName + + Gets the name of a property. + + @param hProperty [in]: + A TX_CONSTPROPERTYHANDLE to the property for which to get the name. + Must not be TX_EMPTY_HANDLE. + + @param pName [out]: + A TX_STRING to which the property name will be copied. + Must be at least the size of the property name. + Can be NULL to only get the size of the property name. + + @param pNameSize [in,out]: + A pointer to a TX_SIZE which will be set to the size of the property name. + Must not be NULL. + The value must be 0 if pName is NULL. + + @return + TX_RESULT_OK: The property name or the required size of the string was successfully retrieved. + TX_RESULT_EYEXNOTINITIALIZED: The EyeX client environment is not initialized. + TX_RESULT_INVALIDARGUMENT: An invalid argument was passed to the function. + TX_RESULT_INVALIDBUFFERSIZE: The size of pName is invalid (pNameSize will be set to the required size). + */ +TX_C_BEGIN +TX_API TX_RESULT TX_CALLCONVENTION txGetPropertyName( + TX_CONSTPROPERTYHANDLE hProperty, + TX_STRING pName, + TX_SIZE* pNameSize + ); +TX_C_END + +typedef TX_RESULT (TX_CALLCONVENTION *GetPropertyNameHook)( + TX_CONSTPROPERTYHANDLE hProperty, + TX_STRING pName, + TX_SIZE* pNameSize + ); + + +/*********************************************************************************************************************/ + +/** + txGetPropertyValueType + + Gets the TX_PROPERTYVALUETYPE of a property. + + @param hProperty [in]: + A TX_CONSTPROPERTYHANDLE to the property. + Must not be TX_EMPTY_HANDLE. + + @param pPropertyType [out]: + A pointer to a TX_PROPERTYVALUETYPE which will be set to the type of the value. + Must not be NULL. + + @return + TX_RESULT_OK: The type of the value was successfully retrieved. + TX_RESULT_EYEXNOTINITIALIZED: The EyeX client environment is not initialized. + TX_RESULT_INVALIDARGUMENT: An invalid argument was passed to the function. + */ +TX_C_BEGIN +TX_API TX_RESULT TX_CALLCONVENTION txGetPropertyValueType( + TX_CONSTPROPERTYHANDLE hProperty, + TX_PROPERTYVALUETYPE* pPropertyType + ); +TX_C_END + +typedef TX_RESULT (TX_CALLCONVENTION *GetPropertyValueTypeHook)( + TX_CONSTPROPERTYHANDLE hProperty, + TX_PROPERTYVALUETYPE* pPropertyType + ); + + +/*********************************************************************************************************************/ + +/** + txGetPropertyFlags + + Gets the TX_PROPERTYFLAGS of a property. + + @param hProperty [in]: + A TX_CONSTPROPERTYHANDLE to the property. + Must not be NULL. + + @param pFlags [out]: + A pointer to a TX_PROPERTYFLAGS which will be set to the flags. + Must not be NULL. + + @return + TX_RESULT_OK: The flags were successfully retrieved. + TX_RESULT_EYEXNOTINITIALIZED: The EyeX client environment is not initialized. + TX_RESULT_INVALIDARGUMENT: An invalid argument was passed to the function. + */ +TX_C_BEGIN +TX_API TX_RESULT TX_CALLCONVENTION txGetPropertyFlags( + TX_CONSTPROPERTYHANDLE hProperty, + TX_PROPERTYFLAGS* pFlags + ); +TX_C_END + +typedef TX_RESULT (TX_CALLCONVENTION *GetPropertyFlagsHook)( + TX_CONSTPROPERTYHANDLE hProperty, + TX_PROPERTYFLAGS* pFlags + ); + + +/*********************************************************************************************************************/ + +/** + txClearPropertyValue + + Clears the value of a property. + The value type will be set to TX_PROPERTYVALUETYPE_EMPTY. + + @param hProperty [in]: + A TX_PROPERTYHANDLE to the property to clear. + Must not be TX_EMPTY_HANDLE. + + @return + TX_RESULT_OK: The property was successfully cleared. + TX_RESULT_EYEXNOTINITIALIZED: The EyeX client environment is not initialized. + TX_RESULT_INVALIDARGUMENT: An invalid argument was passed to the function. + */ +TX_C_BEGIN +TX_API TX_RESULT TX_CALLCONVENTION txClearPropertyValue( + TX_PROPERTYHANDLE hProperty + ); +TX_C_END + +typedef TX_RESULT (TX_CALLCONVENTION *ClearPropertyValueHook)( + TX_PROPERTYHANDLE hProperty + ); + + +/*********************************************************************************************************************/ + +/** + txSetPropertyValueAsInteger + + Sets the value of a property to a TX_INTEGER. + If the property already has a value that will be overwritten, regardless of type. + The value type will be set to TX_PROPERTYVALUETYPE_INTEGER. + + @param hProperty [in]: + A TX_PROPERTYHANDLE to the property for which the value should be set. + Must not be TX_EMPTY_HANDLE. + + @param intValue [in]: + A TX_INTEGER which is the value to set. + + @return + TX_RESULT_OK: The property value was successfully set. + TX_RESULT_EYEXNOTINITIALIZED: The EyeX client environment is not initialized. + TX_RESULT_INVALIDARGUMENT: An invalid argument was passed to the function. + */ +TX_C_BEGIN +TX_API TX_RESULT TX_CALLCONVENTION txSetPropertyValueAsInteger( + TX_PROPERTYHANDLE hProperty, + TX_INTEGER intValue + ); +TX_C_END + +typedef TX_RESULT (TX_CALLCONVENTION *SetPropertyValueAsIntegerHook)( + TX_PROPERTYHANDLE hProperty, + TX_INTEGER intValue + ); + + +/*********************************************************************************************************************/ + +/** + txSetPropertyValueAsReal + + Sets the value of a property to a TX_REAL. + If the property already has a value that will be overwritten, regardless of type. + The value type will be set to TX_PROPERTYVALUETYPE_REAL. + + @param hProperty [in]: + A TX_PROPERTYHANDLE to the property for which the value should be set. + Must not be TX_EMPTY_HANDLE. + + @param realValue [in]: + A TX_REAL which is the value to set. + + @return + TX_RESULT_OK: The property value was successfully set. + TX_RESULT_EYEXNOTINITIALIZED: The EyeX client environment is not initialized. + TX_RESULT_INVALIDARGUMENT: An invalid argument was passed to the function. + */ +TX_C_BEGIN +TX_API TX_RESULT TX_CALLCONVENTION txSetPropertyValueAsReal( + TX_PROPERTYHANDLE hProperty, + TX_REAL realValue + ); +TX_C_END + +typedef TX_RESULT (TX_CALLCONVENTION *SetPropertyValueAsRealHook)( + TX_PROPERTYHANDLE hProperty, + TX_REAL realValue + ); + + +/*********************************************************************************************************************/ + +/** + txSetPropertyValueAsString + + Sets the value of a property to a string. + If the property already has a value that will be overwritten, regardless of type. + The value type will be set to TX_PROPERTYVALUETYPE_STRING. + + @param hProperty [in]: + A TX_PROPERTYHANDLE to the property for which the value should be set. + Must not be TX_EMPTY_HANDLE. + + @param stringValue [in]: + A TX_CONSTSTRING which is the value to set. + Must not be NULL. + + @return + TX_RESULT_OK: The property value was successfully set. + TX_RESULT_EYEXNOTINITIALIZED: The EyeX client environment is not initialized. + TX_RESULT_INVALIDARGUMENT: An invalid argument was passed to the function. + */ +TX_C_BEGIN +TX_API TX_RESULT TX_CALLCONVENTION txSetPropertyValueAsString( + TX_PROPERTYHANDLE hProperty, + TX_CONSTSTRING stringValue + ); +TX_C_END + +typedef TX_RESULT (TX_CALLCONVENTION *SetPropertyValueAsStringHook)( + TX_PROPERTYHANDLE hProperty, + TX_CONSTSTRING stringValue + ); + + +/*********************************************************************************************************************/ + +/** + txSetPropertyValueAsObject + + Sets the value of a property to an interaction object. + If the property already has a value that will be overwritten, regardless of type. + The value type will be set to TX_PROPERTYVALUETYPE_OBJECT. + + @param hProperty [in]: + A TX_PROPERTYHANDLE to the property for which the value should be set. + Must not be TX_EMPTY_HANDLE. + + @param hObject [in]: + A TX_HANDLE to the obejct which is the value to set. + Must not be NULL. + + @return + TX_RESULT_OK: The property value was successfully set. + TX_RESULT_EYEXNOTINITIALIZED: The EyeX client environment is not initialized. + TX_RESULT_INVALIDARGUMENT: An invalid argument was passed to the function. + */ +TX_C_BEGIN +TX_API TX_RESULT TX_CALLCONVENTION txSetPropertyValueAsObject( + TX_PROPERTYHANDLE hProperty, + TX_HANDLE hObject + ); +TX_C_END + +typedef TX_RESULT (TX_CALLCONVENTION *SetPropertyValueAsObjectHook)( + TX_PROPERTYHANDLE hProperty, + TX_HANDLE hObject + ); + + +/*********************************************************************************************************************/ + +/** + txSetPropertyValueAsBlob + + Sets the value of a property to a blob. + If the property already has a value that will be overwritten, regardless of type. + The value type will be set to TX_PROPERTYVALUETYPE_BLOB. + + @param hProperty [in]: + A TX_PROPERTYHANDLE to the property for which the value should be set. + Must not be TX_EMPTY_HANDLE. + + @param pBuffer [in]: + A pointer to an array of bytes. + Must not be NULL. + + @param blobSize [in]: + A TX_SIZE which specifies the size of the blob (i.e. the number of bytes). + + @return + TX_RESULT_OK: The property value was successfully set. + TX_RESULT_EYEXNOTINITIALIZED: The EyeX client environment is not initialized. + TX_RESULT_INVALIDARGUMENT: An invalid argument was passed to the function. + */ +TX_C_BEGIN +TX_API TX_RESULT TX_CALLCONVENTION txSetPropertyValueAsBlob( + TX_PROPERTYHANDLE hProperty, + const TX_BYTE* pBuffer, + TX_SIZE blobSize + ); +TX_C_END + +typedef TX_RESULT (TX_CALLCONVENTION *SetPropertyValueAsBlobHook)( + TX_PROPERTYHANDLE hProperty, + const TX_BYTE* pBuffer, + TX_SIZE blobSize + ); + + +/*********************************************************************************************************************/ + +/** + txGetPropertyValueAsInteger + + Gets the value of a property as a TX_INTEGER. + If the property does not have a value of this type this call will fail. + + @param hProperty [in]: + A TX_CONSTPROPERTYHANDLE to the property for which the value should be retrieved. + Must not be TX_EMPTY_HANDLE. + + @param pIntValue [out]: + A pointer to a TX_INTEGER which will be set to the value of the property. + + @return + TX_RESULT_OK: The property value was successfully retrieved. + TX_RESULT_EYEXNOTINITIALIZED: The EyeX client environment is not initialized. + TX_RESULT_INVALIDARGUMENT: An invalid argument was passed to the function. + TX_RESULT_INVALIDPROPERTYTYPE: The value type was not TX_PROPERTYVALUETYPE_INTEGER. + */ +TX_C_BEGIN +TX_API TX_RESULT TX_CALLCONVENTION txGetPropertyValueAsInteger( + TX_CONSTPROPERTYHANDLE hProperty, + TX_INTEGER* pIntValue + ); +TX_C_END + +typedef TX_RESULT (TX_CALLCONVENTION *GetPropertyValueAsIntegerHook)( + TX_CONSTPROPERTYHANDLE hProperty, + TX_INTEGER* pIntValue + ); + + +/*********************************************************************************************************************/ + +/** + txGetPropertyValueAsReal + + Gets the value of a property as a TX_REAL. + If the property does not have a value or have a value of another type this call will fail. + + @param hProperty [in]: + A TX_CONSTPROPERTYHANDLE to the property for which the value should be retrieved. + Must not be TX_EMPTY_HANDLE. + + @param pRealValue [out]: + A pointer to a TX_REAL which will be set to the value of the property. + + @return + TX_RESULT_OK: The property value was successfully retrieved. + TX_RESULT_EYEXNOTINITIALIZED: The EyeX client environment is not initialized. + TX_RESULT_INVALIDARGUMENT: An invalid argument was passed to the function. + TX_RESULT_INVALIDPROPERTYTYPE: The value type was not TX_PROPERTYVALUETYPE_REAL. + */ +TX_C_BEGIN +TX_API TX_RESULT TX_CALLCONVENTION txGetPropertyValueAsReal( + TX_CONSTPROPERTYHANDLE hProperty, + TX_REAL* pRealValue + ); +TX_C_END + +typedef TX_RESULT (TX_CALLCONVENTION *GetPropertyValueAsRealHook)( + TX_CONSTPROPERTYHANDLE hProperty, + TX_REAL* pRealValue + ); + + +/*********************************************************************************************************************/ + +/** + txGetPropertyValueAsString + + Gets the value of a property as a string. + If the property does not have a value or have a value of another type this call will fail. + + @param hProperty [in]: + A TX_CONSTPROPERTYHANDLE to the property for which the value should be retrieved. + Must not be TX_EMPTY_HANDLE. + + @param pStringValue [out]: + A TX_STRING to which the property value will be copied. + Must be at least the size of the value. + Can be NULL to only get the size of the value. + + @param pStringSize [in,out]: + A pointer to a TX_SIZE which will be set to the size of the property value. + Must not be NULL. + The value must be 0 if pStringValue is NULL. + + @return + TX_RESULT_OK: The property value or the required size of the string was successfully retrieved. + TX_RESULT_EYEXNOTINITIALIZED: The EyeX client environment is not initialized. + TX_RESULT_INVALIDARGUMENT: An invalid argument was passed to the function. + TX_RESULT_INVALIDBUFFERSIZE: The size of pStringValue is invalid (*pStringSize will be set to the required size). + TX_RESULT_INVALIDPROPERTYTYPE: The value type was not TX_PROPERTYVALUETYPE_STRING. + */ +TX_C_BEGIN +TX_API TX_RESULT TX_CALLCONVENTION txGetPropertyValueAsString( + TX_CONSTPROPERTYHANDLE hProperty, + TX_STRING pStringValue, + TX_SIZE* pStringSize + ); +TX_C_END + +typedef TX_RESULT (TX_CALLCONVENTION *GetPropertyValueAsStringHook)( + TX_CONSTPROPERTYHANDLE hProperty, + TX_STRING pStringValue, + TX_SIZE* pStringSize + ); + + +/*********************************************************************************************************************/ + +/** + txGetPropertyValueAsObject + + Gets the value of a property as an interaction object. + If the property does not have a value or have a value of another type this call will fail. + + @param hProperty [in]: + A TX_CONSTPROPERTYHANDLE to the property for which the value should be retrieved. + Must not be TX_EMPTY_HANDLE. + + @param phObject [out]: + A pointer to a TX_HANDLE which will be set to the value of the property. + This handle must be released using txReleaseObject to avoid leaks. + Must not be NULL. + The value of the pointer must be set to TX_EMPTY_HANDLE. + + @return + TX_RESULT_OK: The property value was successfully retrieved. + TX_RESULT_EYEXNOTINITIALIZED: The EyeX client environment is not initialized. + TX_RESULT_INVALIDARGUMENT: An invalid argument was passed to the function. + TX_RESULT_INVALIDPROPERTYTYPE: The value type was not TX_PROPERTYVALUETYPE_OBJECT. + */ +TX_C_BEGIN +TX_API TX_RESULT TX_CALLCONVENTION txGetPropertyValueAsObject( + TX_CONSTPROPERTYHANDLE hProperty, + TX_HANDLE* phObject + ); +TX_C_END + +typedef TX_RESULT (TX_CALLCONVENTION *GetPropertyValueAsObjectHook)( + TX_CONSTPROPERTYHANDLE hProperty, + TX_HANDLE* phObject + ); + + +/*********************************************************************************************************************/ + +/** + txGetPropertyValueAsBlob + + Gets the value of a property as a blob. + If the property does not have a value or have a value of another type this call will fail. + + @param hProperty [in]: + A TX_CONSTPROPERTYHANDLE to the property for which the value should be retrieved. + Must not be TX_EMPTY_HANDLE. + + @param pBuffer [out]: + A pointer to a byte array to which the property value will be copied. + Must be at least the size of the value (i.e. number of bytes in the blob). + Can be NULL to only get the size of the blob. + + @param pBlobSize [in,out]: + A pointer to a TX_SIZE which will be set to the size of the blob. + Must not be NULL. + The value must be 0 if pBuffer is NULL. + + @return + TX_RESULT_OK: The property value or the required size of the buffer was successfully retrieved. + TX_RESULT_EYEXNOTINITIALIZED: The EyeX client environment is not initialized. + TX_RESULT_INVALIDARGUMENT: An invalid argument was passed to the function. + TX_RESULT_INVALIDBUFFERSIZE: The size of pBuffer is invalid (*pBlobSize will be set to the required size). + TX_RESULT_INVALIDPROPERTYTYPE: The value type was not TX_PROPERTYVALUETYPE_BLOB. + */ +TX_C_BEGIN +TX_API TX_RESULT TX_CALLCONVENTION txGetPropertyValueAsBlob( + TX_CONSTPROPERTYHANDLE hProperty, + TX_BYTE* pBuffer, + TX_SIZE* pBlobSize + ); +TX_C_END + +typedef TX_RESULT (TX_CALLCONVENTION *GetPropertyValueAsBlobHook)( + TX_CONSTPROPERTYHANDLE hProperty, + TX_BYTE* pBuffer, + TX_SIZE* pBlobSize + ); + + +/*********************************************************************************************************************/ + +/** + txCopyProperties + + Makes a shallow copy of the properties in the source object to the target object. + + @param hSourceObject [in]: + A TX_CONSTHANDLE to the source object. + Must not be TX_EMPTY_HANDLE. + + @param hTargetObject [in]: + A TX_HANDLE to the target object. + Must not be TX_EMPTY_HANDLE. + + @return + TX_RESULT_OK: The properties were successfully copied. + TX_RESULT_EYEXNOTINITIALIZED: The EyeX client environment is not initialized. + TX_RESULT_INVALIDARGUMENT: An invalid argument was passed to the function. + */ +TX_C_BEGIN +TX_API TX_RESULT TX_CALLCONVENTION txCopyProperties( + TX_CONSTHANDLE hSourceObject, + TX_HANDLE hTargetObject + ); +TX_C_END + +typedef TX_RESULT (TX_CALLCONVENTION *CopyPropertiesHook)( + TX_CONSTHANDLE hSourceObject, + TX_HANDLE hTargetObject + ); + + +/*********************************************************************************************************************/ + +#endif /* define TOBII_TX_DETAIL */ + +/*********************************************************************************************************************/ + +#endif /* !defined(__TOBII_TX_PROPERTY_API__H__) */ + +/*********************************************************************************************************************/ diff --git a/Tobii-EyeX/include/eyex/EyeXQuery.h b/Tobii-EyeX/include/eyex/EyeXQuery.h new file mode 100755 index 0000000..8cc5fa9 --- /dev/null +++ b/Tobii-EyeX/include/eyex/EyeXQuery.h @@ -0,0 +1,136 @@ +/********************************************************************************************************************* + * Copyright 2013-2014 Tobii Technology AB. All rights reserved. + * EyeXQuery.h + *********************************************************************************************************************/ + +#if !defined(__TOBII_TX_QUERY_API__H__) +#define __TOBII_TX_QUERY_API__H__ + +/*********************************************************************************************************************/ + +/** + txGetQueryBounds + + Gets the bounds of a query. + + @param hQuery [in]: + A TX_CONSTHANDLE to the query from which the bounds should be retrieved. + Must not be TX_EMPTY_HANDLE. + + @param phBounds [out]: + A pointer to a TX_HANDLE which will be set to the bounds of the interactor. + This handle must be released using txReleaseObject to avoid leaks. + Must not be NULL. + The value of the pointer must be set to TX_EMPTY_HANDLE. + + @return + TX_RESULT_OK: The bounds was successfully retrieved. + TX_RESULT_EYEXNOTINITIALIZED: The EyeX client environment is not initialized. + TX_RESULT_INVALIDARGUMENT: An invalid argument was passed to the function. + TX_RESULT_NOTFOUND: This query does not have any bounds. + */ +TX_C_BEGIN +TX_API TX_RESULT TX_CALLCONVENTION txGetQueryBounds( + TX_CONSTHANDLE hQuery, + TX_HANDLE* phBounds + ); +TX_C_END + +typedef TX_RESULT (TX_CALLCONVENTION *GetQueryBoundsHook)( + TX_CONSTHANDLE hQuery, + TX_HANDLE* phBounds + ); + + +/*********************************************************************************************************************/ + +/** + txGetQueryWindowIdCount + + Gets the number of window ids held by a query. + The client is expected to add interactors to a snapshot for the windows specified in the query, and + also report these window id's in the snapshot, regardless of if any interactors are found for that window. + + @param hQuery [in]: + A TX_CONSTHANDLE to the query for which the number of window ids should be retrieved. + Must not be TX_EMPTY_HANDLE. + + @param pWindowIdsCount [out]: + A pointer to a TX_SIZE which will be set the number of window ids. + Must not be NULL. + + @return + TX_RESULT_OK: The number of window ids was successfully retrieved. + TX_RESULT_EYEXNOTINITIALIZED: The EyeX client environment is not initialized. + TX_RESULT_INVALIDARGUMENT: An invalid argument was passed to the function. +*/ +TX_C_BEGIN +TX_API TX_RESULT TX_CALLCONVENTION txGetQueryWindowIdCount( + TX_CONSTHANDLE hQuery, + TX_SIZE* pWindowIdsCount + ); +TX_C_END + +typedef TX_RESULT (TX_CALLCONVENTION *GetQueryWindowIdCountHook)( + TX_CONSTHANDLE hQuery, + TX_SIZE* pWindowIdsCount + ); + + +/*********************************************************************************************************************/ + +/** + txGetQueryWindowId + + Gets one of the window ids held by a query. Which one is specified by an index. + The client is expected to add interactors to a snapshot for the windows specified in the query, and + also report these window id's in the snapshot, regardless of if any interactors are found for that window. + + @param hQuery [in]: + A TX_CONSTHANDLE to the query for which the window id should be retrieved. + Must not be TX_EMPTY_HANDLE. + + @param windowIdIndex [in]: + The index of the window id to get. + Must be a positive integer. + + @param pWindowId [out]: + A TX_STRING to which the window id will be copied. + Must be at least the size of the window id. + Can be NULL to only get the size of the window id. + + @param pWindowIdSize [in,out]: + A pointer to a TX_SIZE which tells the size of pWindowId. + Will be set the size of the window id. + Must not be NULL. + The value must be 0 if pWindowId is NULL. + + @return + TX_RESULT_OK: The window id or the required size of the string was successfully retrieved. + TX_RESULT_EYEXNOTINITIALIZED: The EyeX client environment is not initialized. + TX_RESULT_INVALIDARGUMENT: An invalid argument was passed to the function. + TX_RESULT_INVALIDBUFFERSIZE: The size of windowId is invalid (pWindowIdSize will be set to the required size). + TX_RESULT_NOTFOUND: The specified index was out of range. +*/ +TX_C_BEGIN +TX_API TX_RESULT TX_CALLCONVENTION txGetQueryWindowId( + TX_CONSTHANDLE hQuery, + TX_INTEGER windowIdIndex, + TX_STRING pWindowId, + TX_SIZE* pWindowIdSize + ); +TX_C_END + +typedef TX_RESULT (TX_CALLCONVENTION *GetQueryWindowIdHook)( + TX_CONSTHANDLE hQuery, + TX_INTEGER windowIdIndex, + TX_STRING pWindowId, + TX_SIZE* pWindowIdSize + ); + + +/*********************************************************************************************************************/ + +#endif /* !defined(__TOBII_TX_QUERY_API__H__) */ + +/*********************************************************************************************************************/ diff --git a/Tobii-EyeX/include/eyex/EyeXSharedLiterals.h b/Tobii-EyeX/include/eyex/EyeXSharedLiterals.h new file mode 100755 index 0000000..aa96475 --- /dev/null +++ b/Tobii-EyeX/include/eyex/EyeXSharedLiterals.h @@ -0,0 +1,67 @@ +/********************************************************************************************************************* + * Copyright 2013-2014 Tobii Technology AB. All rights reserved. + * EyeXSharedLiterals.h + *********************************************************************************************************************/ + +#if !defined(__TOBII_TX_SHAREDLITERALS__H__) +#define __TOBII_TX_SHAREDLITERALS__H__ + +/********************************************************************************************************************* + * Literals + *********************************************************************************************************************/ + + + /** + * State literals + */ + static const char* TX_SHAREDLITERAL_STATEPATH = "StatePath"; + + /** + * Snapshot Literals + */ + static const char* TX_SHAREDLITERAL_WINDOWIDS = "WindowIds"; + static const char* TX_SHAREDLITERAL_INTERACTORS = "Interactors"; + static const char* TX_SHAREDLITERAL_METADATA = "Metadata"; + static const char* TX_SHAREDLITERAL_SERIALNUMBER = "SerialNumber"; + + static const char* TX_SHAREDLITERAL_MESSAGETYPE = "MessageType"; + static const char* TX_SHAREDLITERAL_WINDOWID = "WindowId"; + static const char* TX_SHAREDLITERAL_COMMANDTYPE = "CommandType"; + static const char* TX_SHAREDLITERAL_ISVISIBLE = "IsVisible"; + + /** + * Callback Response Literals + */ + static const char* TX_SHAREDLITERAL_NOTIFICATIONTYPE = "NotificationType"; + + /** + * Interactor Literals + */ + static const char* TX_SHAREDLITERAL_BEHAVIORTYPE = "BehaviorType"; + static const char* TX_SHAREDLITERAL_BEHAVIORS = "Behaviors"; + static const char* TX_SHAREDLITERAL_PARENTID = "ParentId"; + static const char* TX_SHAREDLITERAL_INTERACTORID = "InteractorId"; + static const char* TX_SHAREDLITERAL_ISENABLED = "IsEnabled"; + static const char* TX_SHAREDLITERAL_ISDELETED = "IsDeleted"; + + + + + + + static const char* TX_CONNECTIONTOKEN_GETVERSION = "GET_VERSION"; + static const char* TX_CONNECTIONTOKEN_GETMINORVERSION = "GET_MINORVERSION"; + static const char* TX_CONNECTIONTOKEN_CONNECT = "CONNECT"; + static const char* TX_CONNECTIONTOKEN_CLIENTVERSION = "CLIENT_VERSION"; + static const char* TX_CONNECTIONTOKEN_CLIENTMODE = "CLIENT_MODE"; + static const char* TX_CONNECTIONTOKEN_CLIENTID = "CLIENT_ID"; + static const char* TX_CONNECTIONTOKEN_LITERALLIST = "LITERAL_LIST"; + + + + +/*********************************************************************************************************************/ + +#endif /* !defined(__TOBII_TX_SHAREDLITERALS__H__) */ + +/*********************************************************************************************************************/ diff --git a/Tobii-EyeX/include/eyex/EyeXSnapshot.h b/Tobii-EyeX/include/eyex/EyeXSnapshot.h new file mode 100755 index 0000000..d53fa0c --- /dev/null +++ b/Tobii-EyeX/include/eyex/EyeXSnapshot.h @@ -0,0 +1,670 @@ +/********************************************************************************************************************* + * Copyright 2013-2014 Tobii Technology AB. All rights reserved. + * EyeXSnapshot.h + *********************************************************************************************************************/ + +#if !defined(__TOBII_TX_SNAPSHOT_API__H__) +#define __TOBII_TX_SNAPSHOT_API__H__ + +/*********************************************************************************************************************/ + +/** + txCreateSnapshot + + Creates a snapshot. + A snapshot is used to provide the current state of interactors for a specfic region of the screen to the client. + This function can also be used to create a snapshot containing global interactors, but it is recommended to + use txCreateGlobalInteractorSnapshot for this. + + @param hContext [in]: + A TX_CONTEXTHANDLE to the context on which to create the snapshot. + Must not be TX_EMPTY_HANDLE. + + @param phSnapshot [out]: + A pointer to a TX_HANDLE which will be set to the newly created snapshot. + This handle must be released using txReleaseObject to avoid leaks. + Must not be NULL. + The value of the pointer must be set to TX_EMPTY_HANDLE. + + @return + TX_RESULT_OK: The snapshot was successfully created. + TX_RESULT_EYEXNOTINITIALIZED: The EyeX client environment is not initialized. + TX_RESULT_INVALIDARGUMENT: An invalid argument was passed to the function. +*/ +TX_C_BEGIN +TX_API TX_RESULT TX_CALLCONVENTION txCreateSnapshot( + TX_CONTEXTHANDLE hContext, + TX_HANDLE* phSnapshot + ); +TX_C_END + +typedef TX_RESULT (TX_CALLCONVENTION *CreateSnapshotHook)( + TX_CONTEXTHANDLE hContext, + TX_HANDLE* phSnapshot + ); + + +/*********************************************************************************************************************/ + +/** + txCreateSnapshotWithQueryBounds + + Creates a snapshot with the same bounds as the supplied query. + This is a specialization of txCreateSnapshot. Normally, when a snapshot is comitted as a response to a query, + it is sufficient to create a snapshot with the same bounds as the query instead of calculating the bounds + based on the interactors. + + @param hQuery [in]: + A TX_CONSTHANDLE to the query this snapshot relates to. + Must not be TX_EMPTY_HANDLE. + + @param phSnapshot [out]: + A pointer to a TX_HANDLE which will be set to the newly created snapshot. + This handle must be released using txReleaseObject to avoid leaks. + Must not be NULL. + The value of the pointer must be set to TX_EMPTY_HANDLE. + + @return + TX_RESULT_OK: The snapshot was successfully created. + TX_RESULT_EYEXNOTINITIALIZED: The EyeX client environment is not initialized. + TX_RESULT_INVALIDARGUMENT: An invalid argument was passed to the function. +*/ +TX_C_BEGIN +TX_API TX_RESULT TX_CALLCONVENTION txCreateSnapshotWithQueryBounds( + TX_CONSTHANDLE hQuery, + TX_HANDLE* phSnapshot + ); +TX_C_END + +typedef TX_RESULT (TX_CALLCONVENTION *CreateSnapshotWithQueryBoundsHook)( + TX_CONSTHANDLE hQuery, + TX_HANDLE* phSnapshot + ); + + +/*********************************************************************************************************************/ + +/** + txCreateSnapshotForQuery + + Creates a snapshot with the same bounds and window ids as the supplied query. + This is a specialization of txCreateSnapshot that makes it easier to quickly create a typical snapshot for a query. + + @param hQuery [in]: + A TX_CONSTHANDLE to the query this snapshot relates to. + Must not be TX_EMPTY_HANDLE. + + @param phSnapshot [out]: + A pointer to a TX_HANDLE which will be set to the newly created snapshot. + This handle must be released using txReleaseObject to avoid leaks. + Must not be NULL. + The value of the pointer must be set to TX_EMPTY_HANDLE. + + @return + TX_RESULT_OK: The snapshot was successfully created. + TX_RESULT_EYEXNOTINITIALIZED: The EyeX client environment is not initialized. + TX_RESULT_INVALIDARGUMENT: An invalid argument was passed to the function. +*/ +TX_C_BEGIN +TX_API TX_RESULT TX_CALLCONVENTION txCreateSnapshotForQuery( + TX_CONSTHANDLE hQuery, + TX_HANDLE* phSnapshot + ); +TX_C_END + +typedef TX_RESULT (TX_CALLCONVENTION *CreateSnapshotForQueryHook)( + TX_CONSTHANDLE hQuery, + TX_HANDLE* phSnapshot + ); + + +/*********************************************************************************************************************/ + +/** + txCommitSnapshotAsync + + Commits a snapshot asynchronously. + The snapshot will be sent to the client. + + @param hSnapshot [in]: + A TX_HANDLE to the snapshot that should be committed. + Must not be TX_EMPTY_HANDLE. + + @param completionHandler [in]: + A TX_ASYNCDATACALLBACK to the function that will handle the snapshot result. + + The async data object provided by the TX_ASYNCDATACALLBACK will contain a result code which can be retrieved using + txGetAsyncDataResult(). The result code will be one of the follwing: + + TX_RESULT_OK: + The snapshot was succesfully commited to the client. + + TX_RESULT_INVALIDSNAPSHOT: + The snapshot was rejected by the client. + + TX_RESULT_CANCELLED: + The asynchronous operation was cancelled. + + + @param userParam [in]: + A TX_USERPARAM which will be provided as a parameter to the completion callback. + Can be NULL. + + @return + TX_RESULT_OK: The snapshot was successfully commited. The actual result of the snapshot will be provided to the callback. + TX_RESULT_EYEXNOTINITIALIZED: The EyeX client environment is not initialized. + TX_RESULT_INVALIDARGUMENT: An invalid argument was passed to the function. +*/ +TX_C_BEGIN +TX_API TX_RESULT TX_CALLCONVENTION txCommitSnapshotAsync( + TX_HANDLE hSnapshot, + TX_ASYNCDATACALLBACK completionHandler, + TX_USERPARAM userParam + ); +TX_C_END + +typedef TX_RESULT (TX_CALLCONVENTION *CommitSnapshotAsyncHook)( + TX_HANDLE hSnapshot, + TX_ASYNCDATACALLBACK completionHandler, + TX_USERPARAM userParam + ); + + + +/*********************************************************************************************************************/ + +/** + txGetSnapshotBounds + + Gets the bounds of a snapshot. + If the snapshot does not have any bounds this call will fail. + + @param hSnapshot [in]: + A TX_CONSTHANDLE to the snapshot for which the bounds should be retrieved. + Must not be TX_EMPTY_HANDLE. + + @param phBounds [out]: + A pointer to a TX_HANDLE which will be set to the bounds of the snapshot. + This handle must be released using txReleaseObject to avoid leaks. + Must not be NULL. + The value of the pointer must be set to TX_EMPTY_HANDLE. + + @return + TX_RESULT_OK: The bounds was successfully retrieved. + TX_RESULT_EYEXNOTINITIALIZED: The EyeX client environment is not initialized. + TX_RESULT_INVALIDARGUMENT: An invalid argument was passed to the function. + TX_RESULT_NOTFOUND: The snapshot does not have any bounds. +*/ +TX_C_BEGIN +TX_API TX_RESULT TX_CALLCONVENTION txGetSnapshotBounds( + TX_CONSTHANDLE hSnapshot, + TX_HANDLE* phBounds + ); +TX_C_END + +typedef TX_RESULT (TX_CALLCONVENTION *GetSnapshotBoundsHook)( + TX_CONSTHANDLE hSnapshot, + TX_HANDLE* phBounds + ); + + +/*********************************************************************************************************************/ + +/** + txGetSnapshotWindowIdCount + + Gets the number of window ids held by a snapshot. + + @param hSnapshot [in]: + A TX_CONSTHANDLE to the snapshot for which the number of window ids should be retrieved. + Must not be TX_EMPTY_HANDLE. + + @param pWindowIdsCount [out]: + A pointer to a TX_SIZE which will be set to the number of window ids. + Must not be NULL. + + @return + TX_RESULT_OK: The number of window ids was successfully retrieved. + TX_RESULT_EYEXNOTINITIALIZED: The EyeX client environment is not initialized. + TX_RESULT_INVALIDARGUMENT: An invalid argument was passed to the function. +*/ +TX_C_BEGIN +TX_API TX_RESULT TX_CALLCONVENTION txGetSnapshotWindowIdCount( + TX_CONSTHANDLE hSnapshot, + TX_SIZE* pWindowIdsCount + ); +TX_C_END + +typedef TX_RESULT (TX_CALLCONVENTION *GetSnapshotWindowIdCountHook)( + TX_CONSTHANDLE hSnapshot, + TX_SIZE* pWindowIdsCount + ); + + +/*********************************************************************************************************************/ + +/** + txGetSnapshotWindowId + + Gets one of the window ids held by a snapshot. Which one is specified by an index. + + @param hSnapshot [in]: + A TX_CONSTHANDLE to the snapshot for which the window id should be retrieved. + Must not be TX_EMPTY_HANDLE. + + @param windowIdIndex [in]: + The index of the window id to get. + Must be a positive integer. + + @param pWindowId [out]: + A TX_STRING to which the window id will be copied. + Must be at least the size of the window id. + Can be NULL to only get the size of the window id. + + @param pWindowIdSize [in,out]: + A pointer to a TX_SIZE which tells the size of pWindowId. + Will be set to the size of the window id. + Must not be NULL. + The value must be 0 if pWindowId is NULL. + + @return + TX_RESULT_OK: The window id or the required size of the string was successfully retrieved. + TX_RESULT_EYEXNOTINITIALIZED: The EyeX client environment is not initialized. + TX_RESULT_INVALIDARGUMENT: An invalid argument was passed to the function. + TX_RESULT_INVALIDBUFFERSIZE: The size of windowId is invalid (pWindowIdSize will be set to the required size). + TX_RESULT_NOTFOUND: The specified index was out of range. +*/ +TX_C_BEGIN +TX_API TX_RESULT TX_CALLCONVENTION txGetSnapshotWindowId( + TX_CONSTHANDLE hSnapshot, + TX_INTEGER windowIdIndex, + TX_STRING pWindowId, + TX_SIZE* pWindowIdSize + ); +TX_C_END + +typedef TX_RESULT (TX_CALLCONVENTION *GetSnapshotWindowIdHook)( + TX_CONSTHANDLE hSnapshot, + TX_INTEGER windowIdIndex, + TX_STRING pWindowId, + TX_SIZE* pWindowIdSize + ); + + +/*********************************************************************************************************************/ + +/** + txAddSnapshotWindowId + + Adds a window id to a snapshot. + If a specific window id has already been added this call will be ignored. + + @param hSnapshot [in]: + A TX_HANDLE to the snapshot to which the window id should be added. + Must not be TX_EMPTY_HANDLE. + + @param windowId [in]: + The window id as a string (window id corresponds to the windows handle on Windows). + Must not be NULL or empty string. + + @return + TX_RESULT_OK: The window id was successfully added. + TX_RESULT_EYEXNOTINITIALIZED: The EyeX client environment is not initialized. + TX_RESULT_INVALIDARGUMENT: An invalid argument was passed to the function. +*/ +TX_C_BEGIN +TX_API TX_RESULT TX_CALLCONVENTION txAddSnapshotWindowId( + TX_HANDLE hSnapshot, + TX_CONSTSTRING windowId + ); +TX_C_END + +typedef TX_RESULT (TX_CALLCONVENTION *AddSnapshotWindowIdHook)( + TX_HANDLE hSnapshot, + TX_CONSTSTRING windowId + ); + + +/*********************************************************************************************************************/ + +/** + txCreateInteractor + + Creates an interactor in a snapshot. + If an interactor with the same id has already been created this call will fail. + The interactor will be owned by the snapshot and does not need to be removed explicitly. + + @param hSnapshot [in]: + A TX_HANDLE to the snapshot in which the interactor should be created. + Must not be TX_EMPTY_HANDLE. + + @param phInteractor [out]: + A pointer to a TX_HANDLE which will be set to the newly created interactor. + This handle must be released using txReleaseObject to avoid leaks. + Must not be NULL. + The value of the pointer must be set to TX_EMPTY_HANDLE. + + @param interactorId [in]: + The interactor id as a TX_CONSTSTRING. + Whenever some interaction happens to an interactor this specifies on which interactor the interaction occurred. + Must not be NULL or empty string. + + @param parentId [in]: + The parent interactor id as a TX_CONSTSTRING. + If this interactor does not have an explicit parent the id should be set to TX_LITERAL_ROOTID. + Commiting a snapshot which contains orphan interactors will fail. + Must not be NULL or empty string. + + @param windowId [in]: + The window id as a TX_CONSTSTRING. + Sets the top level window id of an interactor (window id corresponds to the windows handle on Windows). + Each interactor needs to specify the top level window id in which it was found. + Should be set to TX_LITERAL_GLOBALINTERACTORWINDOWID if this is a global interactor. + Must not be NULL or empty string. + + @return + TX_RESULT_OK: The interactor was successfully created. + TX_RESULT_EYEXNOTINITIALIZED: The EyeX client environment is not initialized. + TX_RESULT_INVALIDARGUMENT: An invalid argument was passed to the function. + TX_RESULT_DUPLICATEINTERACTOR: An interactor with the same id already exists in this snapshot. +*/ +TX_C_BEGIN +TX_API TX_RESULT TX_CALLCONVENTION txCreateInteractor( + TX_HANDLE hSnapshot, + TX_HANDLE* phInteractor, + TX_CONSTSTRING interactorId, + TX_CONSTSTRING parentId, + TX_CONSTSTRING windowId + ); +TX_C_END + +typedef TX_RESULT (TX_CALLCONVENTION *CreateInteractorHook)( + TX_HANDLE hSnapshot, + TX_HANDLE* phInteractor, + TX_CONSTSTRING interactorId, + TX_CONSTSTRING parentId, + TX_CONSTSTRING windowId + ); + + +/*********************************************************************************************************************/ + +/** + txCreateRectangularInteractor + + Creates a rectangular interactor in a snapshot, with all required parameters. + If an interactor with the same id has already been created this call will fail. + The interactor will be owned by the snapshot and does not need to be removed explicitly. + + @param hSnapshot [in]: + A TX_HANDLE to the snapshot in which the interactor should be created. + Must not be TX_EMPTY_HANDLE. + + @param phInteractor [out]: + A pointer to a TX_HANDLE which will be set to the newly created interactor. + This handle must be released using txReleaseObject to avoid leaks. + Must not be NULL. + The value of the pointer must be set to TX_EMPTY_HANDLE. + + @param interactorId [in]: + The interactor id as a TX_CONSTSTRING. + Whenever some interaction happens to an interactor this specifies on which interactor the interaction occurred. + Must not be NULL or empty string. + + @param pBounds [in, out]: + The rectangular dimensions of the interactor. + Must not be NULL or empty string. + + @param parentId [in]: + The parent interactor id as a TX_CONSTSTRING. + If this interactor does not have an explicit parent the id should be set to TX_LITERAL_ROOTID. + Commiting a snapshot which contains orphan interactors will fail. + Must not be NULL or empty string. + + @param windowId [in]: + The window id as a TX_CONSTSTRING. + Sets the top level window id of an interactor (window id corresponds to the windows handle on Windows). + Each interactor needs to specify the top level window id in which it was found. + Should be set to TX_LITERAL_GLOBALINTERACTORWINDOWID if this is a global interactor. + Must not be NULL or empty string. + + @return + TX_RESULT_OK: The interactor was successfully created. + TX_RESULT_EYEXNOTINITIALIZED: The EyeX client environment is not initialized. + TX_RESULT_INVALIDARGUMENT: An invalid argument was passed to the function. + TX_RESULT_DUPLICATEINTERACTOR: An interactor with the same id already exists in this snapshot. +*/ +TX_C_BEGIN +TX_API TX_RESULT TX_CALLCONVENTION txCreateRectangularInteractor( + TX_HANDLE hSnapshot, + TX_HANDLE* phInteractor, + TX_CONSTSTRING interactorId, + TX_RECT* pBounds, + TX_CONSTSTRING parentId, + TX_CONSTSTRING windowId + ); +TX_C_END + +typedef TX_RESULT (TX_CALLCONVENTION *CreateRectangularInteractorHook)( + TX_HANDLE hSnapshot, + TX_HANDLE* phInteractor, + TX_CONSTSTRING interactorId, + TX_RECT* pBounds, + TX_CONSTSTRING parentId, + TX_CONSTSTRING windowId + ); + + +/*********************************************************************************************************************/ + +/** + txRemoveInteractor. For internal use only. + + Removes an interactor from a snapshot. + If an interactor with the specified id does not exist this call will fail. + The interactor is owned by the snapshot and does not need to be removed explicitly. + + @param hSnapshot [in]: + A TX_HANDLE to the snapshot from which the interactor should be removed. + Must not be TX_EMPTY_HANDLE. + + @param interactorId [in]: + The id of the interactor to remove. + Must not be NULL or empty string. + + @return + TX_RESULT_OK: The interactor was successfully removed. + TX_RESULT_EYEXNOTINITIALIZED: The EyeX client environment is not initialized. + TX_RESULT_INVALIDARGUMENT: An invalid argument was passed to the function. + TX_RESULT_NOTFOUND: An interactor with the specified id does not exists in the snapshot. + */ +TX_C_BEGIN +TX_API TX_RESULT TX_CALLCONVENTION txRemoveInteractor( + TX_HANDLE hSnapshot, + TX_CONSTSTRING interactorId + ); +TX_C_END + +typedef TX_RESULT (TX_CALLCONVENTION *RemoveInteractorHook)( + TX_HANDLE hSnapshot, + TX_CONSTSTRING interactorId + ); + + +/*********************************************************************************************************************/ + +/** + txGetInteractors + + Gets TX_HANDLEs to all interactors in a snapshot. + + @param hSnapshot [in]: + A TX_CONSTHANDLE to the snapshot from which to get the interactors. + Must not be TX_EMPTY_HANDLE. + + @param phInteractors [out]: + A pointer to an array of TX_HANDLEs to which the interactor handles will be copied. + These handles must be released using txReleaseObject to avoid leaks. + Can be NULL but to only get the size. + + @param pInteractorsSize [in,out]: + A pointer to a TX_SIZE which will be set to the number of interactors. + Must not be NULL. + The value must be 0 if phInteractors is NULL. + + @return + TX_RESULT_OK: The handles or the required size of the buffer were retrieved successfully. + TX_RESULT_EYEXNOTINITIALIZED: The EyeX client environment is not initialized. + TX_RESULT_INVALIDARGUMENT: An invalid argument was passed to the function. + TX_RESULT_INVALIDBUFFERSIZE: The size of the array is invalid. (*pInteractorsSize will be set to the number of interactors). + */ +TX_C_BEGIN +TX_API TX_RESULT TX_CALLCONVENTION txGetInteractors( + TX_CONSTHANDLE hSnapshot, + TX_HANDLE* phInteractors, + TX_SIZE* pInteractorsSize + ); +TX_C_END + +typedef TX_RESULT (TX_CALLCONVENTION *GetInteractorsHook)( + TX_CONSTHANDLE hSnapshot, + TX_HANDLE* phInteractors, + TX_SIZE* pInteractorsSize + ); + + +/*********************************************************************************************************************/ + +/** + txCreateSnapshotBounds + + Creates bounds on a snapshot. + The bounds of a snapshot should specify a rectangle that defines the region of the screen for which interactors + are provided. Typically these are the same bounds as on the query. + The bounds may cover a larger area, thus telling the client where there is empty space. + If the bounds does not at least intersect the interactors provided in the snapshot txCommitSnapshotAsync will fail. + If the snapshot already have bounds this call will fail. + + @param hSnapshot [in]: + A TX_HANDLE to the snapshot on which the bounds should be created. + Must not be TX_EMPTY_HANDLE. + + @param phBounds [out]: + A pointer to a TX_HANDLE which will be set to the newly created bounds. + This handle must be released using txReleaseObject to avoid leaks. + Must not be NULL. + The value of the pointer must be set to TX_EMPTY_HANDLE. + + @param boundsType [in]: + A TX_BOUNDSTYPE which specifies the type of bounds to create. + + @return + TX_RESULT_OK: The bounds was successfully created. + TX_RESULT_EYEXNOTINITIALIZED: The EyeX client environment is not initialized. + TX_RESULT_INVALIDARGUMENT: An invalid argument was passed to the function. + TX_RESULT_DUPLICATEBOUNDS: The snapshot already has bounds. +*/ +TX_C_BEGIN +TX_API TX_RESULT TX_CALLCONVENTION txCreateSnapshotBounds( + TX_HANDLE hSnapshot, + TX_HANDLE* phBounds, + TX_BOUNDSTYPE boundsType + ); +TX_C_END + +typedef TX_RESULT (TX_CALLCONVENTION *CreateSnapshotBoundsHook)( + TX_HANDLE hSnapshot, + TX_HANDLE* phBounds, + TX_BOUNDSTYPE boundsType + ); + + +/*********************************************************************************************************************/ + +/** + txDeleteSnapshotBounds + + Deletes the bounds on a snapshot. + If the snapshot does not have any bounds this call will fail. + + @param hSnapshot [in]: + A TX_HANDLE to the snapshot on which the bounds should be deleted. + Must not be TX_EMPTY_HANDLE. + + @return + TX_RESULT_OK: The bounds was successfully deleted. + TX_RESULT_EYEXNOTINITIALIZED: The EyeX client environment is not initialized. + TX_RESULT_INVALIDARGUMENT: An invalid argument was passed to the function. + TX_RESULT_NOTFOUND: The snapshot does not have any bounds. +*/ +TX_C_BEGIN +TX_API TX_RESULT TX_CALLCONVENTION txDeleteSnapshotBounds( + TX_HANDLE hSnapshot + ); +TX_C_END + +typedef TX_RESULT (TX_CALLCONVENTION *DeleteSnapshotBoundsHook)( + TX_HANDLE hSnapshot + ); + + +/*********************************************************************************************************************/ + +/** + txCreateGlobalInteractorSnapshot + + Creates a global Interactor Snapshot. + + Creates a snapshot with: + Bounds with boundsType TX_BOUNDSTYPE_NONE, + windowId as TX_LITERAL_GLOBALINTERACTORWINDOWID, + One interactor with: + Bounds with boundsType TX_BOUNDSTYPE_NONE, + ParentId as TX_LITERAL_ROOTID + WindowId as TX_LITERAL_GLOBALINTERACTORWINDOWID, + InteractorId as @interactorId. + + @param hContext [in]: + A TX_CONTEXTHANDLE to the context on which to create the snapshot. + Must not be TX_EMPTY_HANDLE. + + @param interactorId [in]: + The Id of the interactor that will be added to the snapshot. + Must not be the empty string. + + @param type [in]: + The type of the behavior on the interactor. + + @param hSnapshot [out]: + A pointer to a handle of the created snapshot. + + @param hInteractor [out]: + A pointer to a handle of the created interactor object. + + @return + TX_RESULT_OK: The interactor was successfully created. + TX_RESULT_EYEXNOTINITIALIZED: The EyeX client environment is not initialized. + TX_RESULT_INVALIDARGUMENT: An invalid argument was passed to the function. + */ +TX_C_BEGIN +TX_API TX_RESULT TX_CALLCONVENTION txCreateGlobalInteractorSnapshot( + TX_CONTEXTHANDLE hContext, + TX_CONSTSTRING interactorId, + TX_HANDLE* hSnapshot, + TX_HANDLE* hInteractor + ); +TX_C_END + +typedef TX_RESULT (TX_CALLCONVENTION *CreateGlobalInteractorSnapshotHook)( + TX_CONTEXTHANDLE hContext, + TX_CONSTSTRING interactorId, + TX_HANDLE* hSnapshot, + TX_HANDLE* hInteractor + ); + + +/*********************************************************************************************************************/ + +#endif /* !defined(__TOBII_TX_SNAPSHOT_API__H__) */ + +/*********************************************************************************************************************/ diff --git a/Tobii-EyeX/include/eyex/EyeXStates.h b/Tobii-EyeX/include/eyex/EyeXStates.h new file mode 100755 index 0000000..9bc2038 --- /dev/null +++ b/Tobii-EyeX/include/eyex/EyeXStates.h @@ -0,0 +1,933 @@ +/********************************************************************************************************************* + * Copyright 2013-2014 Tobii Technology AB. All rights reserved. + * EyeXStates.h + *********************************************************************************************************************/ + +#if !defined(__TOBII_TX_STATES_API__H__) +#define __TOBII_TX_STATES_API__H__ + +/*********************************************************************************************************************/ + +/** + txGetStateAsync + + Gets a state from the client. The state will be delivered as a TX_HANDLE to a state bag. The handle will be + TX_EMPTY_HANDLE if the requested state was not found. + + @param hContext [in]: + A TX_CONTEXTHANDLE to the context from which to get the state. + Must not be TX_EMPTY_HANDLE. + + @param statePath [in]: + A string that specifies the path of the state to get. + Must not start with, end with or have two consecutive dots (.). + Must not be NULL or empty string. + + @param completionHandler [in]: + The TX_ASYNCDATACALLBACK that will be invoked when the result have arrived from the client. + Must not be NULL. + + The data provided by the TX_ASYNCDATACALLBACK will contain a result code which can be retrieved using + txGetAsyncDataResult(). The result code will be one of the follwing: + + TX_RESULT_OK: + The state was succesfully retrieved. + + TX_RESULT_NOTFOUND: + The state was not found. + + TX_RESULT_CANCELLED: + The asynchronous operation was cancelled. + + @param userParam [in]: + A TX_USERPARAM which will be provided as a parameter to the completion callback. + Can be NULL. + + @return + TX_RESULT_OK: The state request was successfully sent to the client. + TX_RESULT_EYEXNOTINITIALIZED: The EyeX client environment is not initialized. + TX_RESULT_INVALIDARGUMENT: An invalid argument was passed to the function. + */ +TX_C_BEGIN +TX_API TX_RESULT TX_CALLCONVENTION txGetStateAsync( + TX_CONTEXTHANDLE hContext, + TX_CONSTSTRING statePath, + TX_ASYNCDATACALLBACK completionHandler, + TX_USERPARAM userParam + ); +TX_C_END + +typedef TX_RESULT (TX_CALLCONVENTION *GetStateAsyncHook)( + TX_CONTEXTHANDLE hContext, + TX_CONSTSTRING statePath, + TX_ASYNCDATACALLBACK completionHandler, + TX_USERPARAM userParam + ); + + +/*********************************************************************************************************************/ + +/** + txGetState + + Gets a state from the client synchronously. + This method will block until the state has been retrieved or until the operation has failed. + + @param hContext [in]: + A TX_CONTEXTHANDLE to the context from which to get the state. + Must not be TX_EMPTY_HANDLE. + + @param statePath [in]: + A string that specifies the path of the state to get. + Must not start with, end with or have two consecutive dots (.). + Must not be NULL or empty string. + + @param phStateBag [out]: + A pointer TX_HANDLE which will be set to the state bag. + Will be set to TX_EMPTY_HANDLE if not found. + + @param userParam [in]: + A TX_USERPARAM which will be provided as a parameter to the completion callback. + Can be NULL. + + @return + TX_RESULT_OK: The state was succcessfully retrieved. + TX_RESULT_NOTFOUND: The state was not found. + TX_RESULT_EYEXNOTINITIALIZED: The EyeX client environment is not initialized. + TX_RESULT_INVALIDARGUMENT: An invalid argument was passed to the function. + TX_RESULT_CANCELLED: The operation was cancelled. + */ +TX_C_BEGIN +TX_API TX_RESULT TX_CALLCONVENTION txGetState( + TX_CONTEXTHANDLE hContext, + TX_CONSTSTRING statePath, + TX_HANDLE* phStateBag + ); +TX_C_END + +typedef TX_RESULT (TX_CALLCONVENTION *GetStateHook)( + TX_CONTEXTHANDLE hContext, + TX_CONSTSTRING statePath, + TX_HANDLE* phStateBag + ); + + +/*********************************************************************************************************************/ + +/** + txSetStateAsync + + Sets a state on the client. For internal use only. + + @param hStateBag [in]: + A handle to the state bag which contains the path and data to set. + + @param completionHandler [in]: + The TX_ASYNCDATACALLBACK that will be invoked when the result have arrived from the client. + Can be NULL to ignore the result. + + The data provided by the TX_ASYNCDATACALLBACK will contain a result code which can be retrieved using + txGetAsyncDataResult(). The result code will be one of the follwing: + + TX_RESULT_OK: + The state was succesfully set. + + TX_RESULT_CANCELLED: + The asynchronous operation was cancelled. + + @param userParam [in]: + A TX_USERPARAM which will be provided as a parameter to the completion callback. + Can be NULL. + + @return + TX_RESULT_OK: The set state request was successfully sent to the client. + TX_RESULT_EYEXNOTINITIALIZED: The EyeX client environment is not initialized. + TX_RESULT_INVALIDARGUMENT: An invalid argument was passed to the function. + */ +TX_C_BEGIN +TX_API TX_RESULT TX_CALLCONVENTION txSetStateAsync( + TX_HANDLE hStateBag, + TX_ASYNCDATACALLBACK completionHandler, + TX_USERPARAM userParam + ); +TX_C_END + +typedef TX_RESULT (TX_CALLCONVENTION *SetStateAsyncHook)( + TX_HANDLE hStateBag, + TX_ASYNCDATACALLBACK completionHandler, + TX_USERPARAM userParam + ); + + +/*********************************************************************************************************************/ + +/** + txCreateStateBag + + Creates a state bag. + + @param hContext [in]: + A TX_CONTEXTHANDLE to the context on which to create the state bag. + Must not be TX_EMPTY_HANDLE. + + @param phStateBag [out]: + A pointer to a TX_HANDLE which will be set to the newly created state bag. + This handle must be released using txReleaseObject to avoid leaks. + Must not be NULL. + The value of the pointer must be set to TX_EMPTY_HANDLE. + + @param statePath [in]: + A string that specifies which path this state bag represents. + Must not start with, end with or have two consecutive dots (.). + Must not be NULL or empty string. + + @return + TX_RESULT_OK: The state bag was successfully created. + TX_RESULT_EYEXNOTINITIALIZED: The EyeX client environment is not initialized. + TX_RESULT_INVALIDARGUMENT: An invalid argument was passed to the function. + */ +TX_C_BEGIN +TX_API TX_RESULT TX_CALLCONVENTION txCreateStateBag( + TX_CONTEXTHANDLE hContext, + TX_HANDLE* phStateBag, + TX_CONSTSTRING statePath + ); +TX_C_END + +typedef TX_RESULT (TX_CALLCONVENTION *CreateStateBagHook)( + TX_CONTEXTHANDLE hContext, + TX_HANDLE* phStateBag, + TX_CONSTSTRING statePath + ); + + +/*********************************************************************************************************************/ + +/** + txGetStateBagPath + + Gets the path that a state bag represents. + + @param hStateBag [in]: + A TX_CONSTHANDLE to the state bag. + Must not be TX_EMPTY_HANDLE. + + @param pStatePath [out]: + A TX_STRING to which the state path will be copied. + Must be at least the size of the value. + Can be NULL to only get the size of the path. + + @param pStatePathSize [in,out]: + A pointer to a TX_SIZE which will be set to the size of the state path. + Must not be NULL. + The value must be 0 if pStatePath is NULL. + + @return + TX_RESULT_OK: The path of the state bag or the required size of the string was successfully retrieved. + TX_RESULT_EYEXNOTINITIALIZED: The EyeX client environment is not initialized. + TX_RESULT_INVALIDARGUMENT: An invalid argument was passed to the function. + TX_RESULT_INVALIDBUFFERSIZE: The size of pStatePath is invalid (*pStatePathSize will be set to the required size). + */ +TX_C_BEGIN +TX_API TX_RESULT TX_CALLCONVENTION txGetStateBagPath( + TX_CONSTHANDLE hStateBag, + TX_STRING pStatePath, + TX_SIZE* pStatePathSize + ); +TX_C_END + +typedef TX_RESULT (TX_CALLCONVENTION *GetStateBagPathHook)( + TX_CONSTHANDLE hStateBag, + TX_STRING pStatePath, + TX_SIZE* pStatePathSize + ); + + +/*********************************************************************************************************************/ + +/** + txRegisterStateObserver + + Registers observation of a specified state path. + If connection to the client is currently not present this registration will be stored and applied once connection + has been established. The registration will also be reapplied if the connection is dropped and reestablished. + Multiple registrations of the same state path will be ignored. + + @param hContext [in]: + A TX_CONTEXTHANDLE to the context on which to register the state observation. + Must not be TX_EMPTY_HANDLE. + + @param statePath [in]: + The state path as a TX_CONSTSTRING. + Must not start with, end with or have two consecutive dots (.). + Must not be NULL or empty string. + + @return + TX_RESULT_OK: The state path was successfully registered. + TX_RESULT_EYEXNOTINITIALIZED: The EyeX client environment is not initialized. + TX_RESULT_INVALIDARGUMENT: An invalid argument was passed to the function. + TX_RESULT_INVALIDTHREAD: Attempted to call the function from a callback thread. + */ +TX_C_BEGIN +TX_API TX_RESULT TX_CALLCONVENTION txRegisterStateObserver( + TX_CONTEXTHANDLE hContext, + TX_CONSTSTRING statePath + ); +TX_C_END + +typedef TX_RESULT (TX_CALLCONVENTION *RegisterStateObserverHook)( + TX_CONTEXTHANDLE hContext, + TX_CONSTSTRING statePath + ); + + +/*********************************************************************************************************************/ + +/** + txUnregisterStateObserver + + Unregisters observation of a specified state path. + + @param hContext [in]: + A TX_CONTEXTHANDLE to the context on which to unregister the state observation. + Must not be TX_EMPTY_HANDLE. + + @param statePath [in]: + The state path as a TX_CONSTSTRING. + Must not start with, end with or have two consecutive dots (.). + Must not be NULL or empty string. + + @return + TX_RESULT_OK: The state path was successfully unregistered. + TX_RESULT_EYEXNOTINITIALIZED: The EyeX client environment is not initialized. + TX_RESULT_INVALIDARGUMENT: An invalid argument was passed to the function. + TX_RESULT_NOT_FOUND: The state path was not observed. + */ +TX_C_BEGIN +TX_API TX_RESULT TX_CALLCONVENTION txUnregisterStateObserver( + TX_CONTEXTHANDLE hContext, + TX_CONSTSTRING statePath + ); +TX_C_END + +typedef TX_RESULT (TX_CALLCONVENTION *UnregisterStateObserverHook)( + TX_CONTEXTHANDLE hContext, + TX_CONSTSTRING statePath + ); + + +/*********************************************************************************************************************/ + +/** + txGetStateValueAsInteger + + Gets a value from a state bag as a TX_INTEGER. + If a state value can not be found on the specified path or the value is of another type this call will fail. + + @param hStateBag [in]: + A TX_CONSTHANDLE to the state bag from which the value should be retrieved. + Must not be TX_EMPTY_HANDLE. + + @param valuePath, [in]: + The path to the value. + + @param pIntValue [out]: + A pointer to a TX_INTEGER which will be set to the value. + + @return + TX_RESULT_OK: The state value was successfully retrieved. + TX_RESULT_EYEXNOTINITIALIZED: The EyeX client environment is not initialized. + TX_RESULT_INVALIDARGUMENT: An invalid argument was passed to the function. + TX_RESULT_NOTFOUND: The value was not found. + TX_RESULT_INVALIDPROPERTYTYPE: The value type was not TX_PROPERTYVALUETYPE_INTEGER. + */ +TX_C_BEGIN +TX_API TX_RESULT TX_CALLCONVENTION txGetStateValueAsInteger( + TX_CONSTHANDLE hStateBag, + TX_CONSTSTRING valuePath, + TX_INTEGER* pIntValue + ); +TX_C_END + +typedef TX_RESULT (TX_CALLCONVENTION *GetStateValueAsIntegerHook)( + TX_CONSTHANDLE hStateBag, + TX_CONSTSTRING valuePath, + TX_INTEGER* pIntValue + ); + + +/*********************************************************************************************************************/ + +/** + txGetStateValueAsReal + + Gets a value from a state bag as a TX_REAL. + If a state value can not be found on the specified path or the value is of another type this call will fail. + + @param hStateBag [in]: + A TX_CONSTHANDLE to the state bag from which the value should be retrieved. + Must not be TX_EMPTY_HANDLE. + + @param valuePath [in]: + The path to the value. + + @param pRealValue [out]: + A pointer to a TX_REAL which will be set to the value. + + @return + TX_RESULT_OK: The state value was successfully retrieved. + TX_RESULT_EYEXNOTINITIALIZED: The EyeX client environment is not initialized. + TX_RESULT_INVALIDARGUMENT: An invalid argument was passed to the function. + TX_RESULT_NOTFOUND: The value was not found. + TX_RESULT_INVALIDPROPERTYTYPE: The value type was not TX_PROPERTYVALUETYPE_REAL. + */ +TX_C_BEGIN +TX_API TX_RESULT TX_CALLCONVENTION txGetStateValueAsReal( + TX_CONSTHANDLE hStateBag, + TX_CONSTSTRING valuePath, + TX_REAL* pRealValue + ); +TX_C_END + +typedef TX_RESULT (TX_CALLCONVENTION *GetStateValueAsRealHook)( + TX_CONSTHANDLE hStateBag, + TX_CONSTSTRING valuePath, + TX_REAL* pRealValue + ); + + +/*********************************************************************************************************************/ + +/** + txGetStateValueAsString + + Gets a value from a state bag as a TX_STRING. + If a state value can not be found on the specified path or the value is of another type this call will fail. + + @param hStateBag [in]: + A TX_CONSTHANDLE to the state bag from which the value should be retrieved. + Must not be TX_EMPTY_HANDLE. + + @param valuePath [in]: + The path to the value. + + @param pStringValue [out]: + A TX_STRING to which the state value will be copied. + Must be at least the size of the value. + Can be NULL to only get the size of the value. + If the state value is an array of strings the returned string will contain all strings + separated with null termination and with an extra ending null termination. + + @param pStringSize [in,out]: + A pointer to a TX_SIZE which will be set to the size of the state value. + Must not be NULL. + The value must be 0 if pStringValue is NULL. + + @return + TX_RESULT_OK: The state value or the required size of the string was successfully retrieved. + TX_RESULT_EYEXNOTINITIALIZED: The EyeX client environment is not initialized. + TX_RESULT_INVALIDARGUMENT: An invalid argument was passed to the function. + TX_RESULT_INVALIDBUFFERSIZE: The size of pStringValue is invalid (*pStringSize will be set to the required size). + TX_RESULT_NOTFOUND: The value was not found. + TX_RESULT_INVALIDPROPERTYTYPE: The value type was not TX_PROPERTYVALUETYPE_STRING or array of TX_PROPERTYVALUETYPE_STRING. + */ +TX_C_BEGIN +TX_API TX_RESULT TX_CALLCONVENTION txGetStateValueAsString( + TX_CONSTHANDLE hStateBag, + TX_CONSTSTRING valuePath, + TX_STRING pStringValue, + TX_SIZE* pStringSize + ); +TX_C_END + +typedef TX_RESULT (TX_CALLCONVENTION *GetStateValueAsStringHook)( + TX_CONSTHANDLE hStateBag, + TX_CONSTSTRING valuePath, + TX_STRING pStringValue, + TX_SIZE* pStringSize + ); + + +/*********************************************************************************************************************/ + +/** + txGetStateValueAsRectangle + + Gets a value from a state bag as a TX_RECT. + If a state value can not be found on the specified path or the value is of another type this call will fail. + + @param hStateBag [in]: + A TX_CONSTHANDLE to the state bag from which the value should be retrieved. + Must not be TX_EMPTY_HANDLE. + + @param valuePath [in]: + The path to the value. + + @param pRectangle [out]: + A pointer to a TX_RECT which will have its members set. + Must not be NULL. + + @return + TX_RESULT_OK: The state value was successfully retrieved. + TX_RESULT_EYEXNOTINITIALIZED: The EyeX client environment is not initialized. + TX_RESULT_INVALIDARGUMENT: An invalid argument was passed to the function. + TX_RESULT_NOTFOUND: The value was not found. + */ +TX_C_BEGIN +TX_API TX_RESULT TX_CALLCONVENTION txGetStateValueAsRectangle( + TX_CONSTHANDLE hStateBag, + TX_CONSTSTRING valuePath, + TX_RECT* pRectValue + ); +TX_C_END + +typedef TX_RESULT (TX_CALLCONVENTION *GetStateValueAsRectangleHook)( + TX_CONSTHANDLE hStateBag, + TX_CONSTSTRING valuePath, + TX_RECT* pRectValue + ); + + +/*********************************************************************************************************************/ + +/** + txGetStateValueAsVector2 + + Gets a value from a state bag as a TX_VECTOR2. + If a state value can not be found on the specified path or the value is of another type this call will fail. + + @param hStateBag [in]: + A TX_CONSTHANDLE to the state bag from which the value should be retrieved. + Must not be TX_EMPTY_HANDLE. + + @param valuePath [in]: + The path to the value. + + @param pVector2Value [out]: + A pointer to a TX_VECTOR2 which will have its members set. + Must not be NULL. + + @return + TX_RESULT_OK: The state value was successfully retrieved. + TX_RESULT_EYEXNOTINITIALIZED: The EyeX client environment is not initialized. + TX_RESULT_INVALIDARGUMENT: An invalid argument was passed to the function. + TX_RESULT_NOTFOUND: The value was not found. + */ +TX_C_BEGIN +TX_API TX_RESULT TX_CALLCONVENTION txGetStateValueAsVector2( + TX_CONSTHANDLE hStateBag, + TX_CONSTSTRING valuePath, + TX_VECTOR2* pVector2Value + ); +TX_C_END + +typedef TX_RESULT (TX_CALLCONVENTION *GetStateValueAsVector2Hook)( + TX_CONSTHANDLE hStateBag, + TX_CONSTSTRING valuePath, + TX_VECTOR2* pVector2Value + ); + + +/*********************************************************************************************************************/ + +/** + txGetStateValueAsSize2 + + Gets a value from a state bag as a TX_SIZE2. + If a state value can not be found on the specified path or the value is of another type this call will fail. + + @param hStateBag [in]: + A TX_CONSTHANDLE to the state bag from which the value should be retrieved. + Must not be TX_EMPTY_HANDLE. + + @param valuePath [in]: + The path to the value. + + @param pSizeValue [out]: + A pointer to a TX_SIZE2 which will have its members set. + Must not be NULL. + + @return + TX_RESULT_OK: The state value was successfully retrieved. + TX_RESULT_EYEXNOTINITIALIZED: The EyeX client environment is not initialized. + TX_RESULT_INVALIDARGUMENT: An invalid argument was passed to the function. + TX_RESULT_NOTFOUND: The value was not found. + */ +TX_C_BEGIN +TX_API TX_RESULT TX_CALLCONVENTION txGetStateValueAsSize2( + TX_CONSTHANDLE hStateBag, + TX_CONSTSTRING valuePath, + TX_SIZE2* pSizeValue + ); +TX_C_END + +typedef TX_RESULT (TX_CALLCONVENTION *GetStateValueAsSize2Hook)( + TX_CONSTHANDLE hStateBag, + TX_CONSTSTRING valuePath, + TX_SIZE2* pSizeValue + ); + + +/*********************************************************************************************************************/ + +/** + txSetStateValueAsInteger + + Sets a value in a state bag to a TX_INTEGER. + + @param hStateBag [in]: + A TX_HANDLE to the state bag from which the value should be retrieved. + Must not be TX_EMPTY_HANDLE. + + @param valuePath, [in]: + The path to the value. + + @param intValue [in]: + A TX_INTEGER which is the value to set. + + @return + TX_RESULT_OK: The state value was successfully set. + TX_RESULT_EYEXNOTINITIALIZED: The EyeX client environment is not initialized. + TX_RESULT_INVALIDARGUMENT: An invalid argument was passed to the function. + */ +TX_C_BEGIN +TX_API TX_RESULT TX_CALLCONVENTION txSetStateValueAsInteger( + TX_HANDLE hStateBag, + TX_CONSTSTRING valuePath, + TX_INTEGER intValue + ); +TX_C_END + +typedef TX_RESULT (TX_CALLCONVENTION *SetStateValueAsIntegerHook)( + TX_HANDLE hStateBag, + TX_CONSTSTRING valuePath, + TX_INTEGER intValue + ); + + +/*********************************************************************************************************************/ + +/** + txSetStateValueAsReal + + Sets a value in a state bag to a TX_REAL. + + @param hStateBag [in]: + A TX_HANDLE to the state bag from which the value should be retrieved. + Must not be TX_EMPTY_HANDLE. + + @param valuePath, [in]: + The path to the value. + + @param intValue [in]: + A TX_REAL which is the value to set. + + @return + TX_RESULT_OK: The state value was successfully set. + TX_RESULT_EYEXNOTINITIALIZED: The EyeX client environment is not initialized. + TX_RESULT_INVALIDARGUMENT: An invalid argument was passed to the function. + */ +TX_C_BEGIN +TX_API TX_RESULT TX_CALLCONVENTION txSetStateValueAsReal( + TX_HANDLE hStateBag, + TX_CONSTSTRING valuePath, + TX_REAL realValue + ); +TX_C_END + +typedef TX_RESULT (TX_CALLCONVENTION *SetStateValueAsRealHook)( + TX_HANDLE hStateBag, + TX_CONSTSTRING valuePath, + TX_REAL realValue + ); + + +/*********************************************************************************************************************/ + +/** + txSetStateValueAsString + + Sets a value in a state bag to a string. + + @param hStateBag [in]: + A TX_HANDLE to the state bag from which the value should be retrieved. + Must not be TX_EMPTY_HANDLE. + + @param valuePath, [in]: + The path to the value. + + @param stringValue [in]: + A TX_CONSTSTRING which is the value to set. + + @return + TX_RESULT_OK: The state value was successfully set. + TX_RESULT_EYEXNOTINITIALIZED: The EyeX client environment is not initialized. + TX_RESULT_INVALIDARGUMENT: An invalid argument was passed to the function. + */ +TX_C_BEGIN +TX_API TX_RESULT TX_CALLCONVENTION txSetStateValueAsString( + TX_HANDLE hStateBag, + TX_CONSTSTRING valuePath, + TX_CONSTSTRING stringValue + ); +TX_C_END + +typedef TX_RESULT (TX_CALLCONVENTION *SetStateValueAsStringHook)( + TX_HANDLE hStateBag, + TX_CONSTSTRING valuePath, + TX_CONSTSTRING stringValue + ); + + +/*********************************************************************************************************************/ + +/** + txSetStateValueAsRectangle + + Sets a value in a state bag to a TX_RECT. + + @param hStateBag [in]: + A TX_HANDLE to the state bag from which the value should be retrieved. + Must not be TX_EMPTY_HANDLE. + + @param valuePath, [in]: + The path to the value. + + @param pRectValue [in]: + A pointer to a TX_RECT which is the value to set. + Must not be NULL. + + @return + TX_RESULT_OK: The state value was successfully set. + TX_RESULT_EYEXNOTINITIALIZED: The EyeX client environment is not initialized. + TX_RESULT_INVALIDARGUMENT: An invalid argument was passed to the function. + */ +TX_C_BEGIN +TX_API TX_RESULT TX_CALLCONVENTION txSetStateValueAsRectangle( + TX_HANDLE hStateBag, + TX_CONSTSTRING valuePath, + const TX_RECT* pRectValue + ); +TX_C_END + +typedef TX_RESULT (TX_CALLCONVENTION *SetStateValueAsRectangleHook)( + TX_HANDLE hStateBag, + TX_CONSTSTRING valuePath, + const TX_RECT* pRectValue + ); + + +/*********************************************************************************************************************/ + +/** + txSetStateValueAsVector2 + + Sets a value in a state bag to a TX_VECTOR2. + + @param hStateBag [in]: + A TX_HANDLE to the state bag from which the value should be retrieved. + Must not be TX_EMPTY_HANDLE. + + @param valuePath, [in]: + The path to the value. + + @param pVector2Value [in]: + A pointer to a TX_VECTOR2 which is the value to set. + Must not be NULL. + + @return + TX_RESULT_OK: The state value was successfully set. + TX_RESULT_EYEXNOTINITIALIZED: The EyeX client environment is not initialized. + TX_RESULT_INVALIDARGUMENT: An invalid argument was passed to the function. + */ +TX_C_BEGIN +TX_API TX_RESULT TX_CALLCONVENTION txSetStateValueAsVector2( + TX_HANDLE hStateBag, + TX_CONSTSTRING valuePath, + const TX_VECTOR2* pVector2Value + ); +TX_C_END + +typedef TX_RESULT (TX_CALLCONVENTION *SetStateValueAsVector2Hook)( + TX_HANDLE hStateBag, + TX_CONSTSTRING valuePath, + const TX_VECTOR2* pVector2Value + ); + + +/*********************************************************************************************************************/ + +/** + txSetStateValueAsSize2 + + Sets a value in a state bag to a TX_SIZE2. + + @param hStateBag [in]: + A TX_HANDLE to the state bag from which the value should be retrieved. + Must not be TX_EMPTY_HANDLE. + + @param valuePath, [in]: + The path to the value. + + @param pSizeValue [in]: + A pointer to a TX_SIZE2 which is the value to set. + Must not be NULL. + + @return + TX_RESULT_OK: The state value was successfully set. + TX_RESULT_EYEXNOTINITIALIZED: The EyeX client environment is not initialized. + TX_RESULT_INVALIDARGUMENT: An invalid argument was passed to the function. + */ +TX_C_BEGIN +TX_API TX_RESULT TX_CALLCONVENTION txSetStateValueAsSize2( + TX_HANDLE hStateBag, + TX_CONSTSTRING valuePath, + const TX_SIZE2* pSizeValue + ); +TX_C_END + +typedef TX_RESULT (TX_CALLCONVENTION *SetStateValueAsSize2Hook)( + TX_HANDLE hStateBag, + TX_CONSTSTRING valuePath, + const TX_SIZE2* pSizeValue + ); + + +/*********************************************************************************************************************/ + +/** + txGetPropertyForStateValue + + Gets a property for a specified state value. + If the property for state value can not be found on the specified path or the value is of another type this call + will fail. + + This function is typically only used by bindings. + + @param hStateBag [in]: + A TX_CONSTHANDLE to the state bag from which the value should be retrieved. + Must not be TX_EMPTY_HANDLE. + + @param phProperty [out]: + A pointer to a TX_PROPERTYHANDLE which will be set to the property for the state value. + + @param valuePath [in]: + The path to the value. + May not be NULL. + + @param createIfNotFound [in]: + Specifies if the property should be created if it does not exist. + + @return + TX_RESULT_OK: The state value was successfully retrieved. + TX_RESULT_EYEXNOTINITIALIZED: The EyeX client environment is not initialized. + TX_RESULT_INVALIDARGUMENT: An invalid argument was passed to the function. + TX_RESULT_NOTFOUND: The property was not found. + */ +TX_C_BEGIN +TX_API TX_RESULT TX_CALLCONVENTION txGetPropertyForStateValue( + TX_CONSTHANDLE hStateBag, + TX_PROPERTYHANDLE* phProperty, + TX_CONSTSTRING valuePath, + TX_BOOL createIfNotFound + ); +TX_C_END + +typedef TX_RESULT (TX_CALLCONVENTION *GetPropertyForStateValueHook)( + TX_CONSTHANDLE hStateBag, + TX_PROPERTYHANDLE* phProperty, + TX_CONSTSTRING valuePath, + TX_BOOL createIfNotFound + ); + + +/*********************************************************************************************************************/ + +/** + txRegisterStateChangedHandler + + Registers a state changed handler. + This is a helper which automatically registers a notification message handler and a state observer. + + @param hContext [in]: + A TX_CONTEXTHANDLE to the context on which to listen for state changes. + Must not be TX_EMPTY_HANDLE. + + @param pTicket [out]: + A pointer to a TX_TICKET which will represent this registration. + This ticket should be used for unregistration. + Must not be NULL. + + @param statePath [in]: + A string that specifies the path of the state to register state changed handler for. + Must not start with, end with or have two consecutive dots (.). + Must not be NULL or empty string. + + @param handler [in]: + A TX_ASYNCDATACALLBACK which will be called when a state changes. + Must not be NULL. + + @param userParam [in]: + A TX_USERPARAM which will be provided as a parameter to the callback. + + @return + TX_RESULT_OK: The Query Handler was successfully registered. + TX_RESULT_EYEXNOTINITIALIZED: The EyeX client environment is not initialized. + TX_RESULT_INVALIDARGUMENT: An invalid argument was passed to the function. + TX_RESULT_INVALIDTHREAD: Attempted to call the function from a callback thread. + */ +TX_C_BEGIN +TX_API TX_RESULT TX_CALLCONVENTION txRegisterStateChangedHandler( + TX_CONTEXTHANDLE hContext, + TX_TICKET* pTicket, + TX_CONSTSTRING statePath, + TX_ASYNCDATACALLBACK handler, + TX_USERPARAM userParam); +TX_C_END + +typedef TX_RESULT (TX_CALLCONVENTION *RegisterStateChangedHandlerHook)( + TX_CONTEXTHANDLE hContext, + TX_TICKET* pTicket, + TX_CONSTSTRING statePath, + TX_ASYNCDATACALLBACK handler, + TX_USERPARAM userParam); + + +/*********************************************************************************************************************/ + +/** + txUnregisterStateChangedHandler + + Unregisters a previously registered state changed handler callback. + + @param hContext [in]: + A TX_CONTEXTHANDLE to the context on which to unregister the callback. + Must not be TX_EMPTY_HANDLE. + + @param ticket [in]: + A TX_TICKET which represents the registration. + Must not be TX_INVALID_TICKET + + @return + TX_RESULT_OK: The callback was successfully unregistered. + TX_RESULT_EYEXNOTINITIALIZED: The EyeX client environment is not initialized. + TX_RESULT_INVALIDARGUMENT: An invalid argument was passed to the function. + TX_RESULT_NOTFOUND: A registration for the specified ticket could not be found. +*/ +TX_C_BEGIN +TX_API TX_RESULT TX_CALLCONVENTION txUnregisterStateChangedHandler( + TX_CONTEXTHANDLE hContext, + TX_TICKET ticket); +TX_C_END + +typedef TX_RESULT (TX_CALLCONVENTION *UnregisterStateChangedHandlerHook)( + TX_CONTEXTHANDLE hContext, + TX_TICKET ticket); + + +/*********************************************************************************************************************/ + +#endif /* !defined(__TOBII_TX_STATES_API__H__) */ + +/*********************************************************************************************************************/ + diff --git a/Tobii-EyeX/include/eyex/EyeXUtils.h b/Tobii-EyeX/include/eyex/EyeXUtils.h new file mode 100755 index 0000000..7adedff --- /dev/null +++ b/Tobii-EyeX/include/eyex/EyeXUtils.h @@ -0,0 +1,351 @@ +/********************************************************************************************************************* +* Copyright 2013-2014 Tobii Technology AB. All rights reserved. +* EyeXUtils.h +*********************************************************************************************************************/ + +#if !defined(__TOBII_TX_UTILS__H__) +#define __TOBII_TX_UTILS__H__ + +/*********************************************************************************************************************/ + +#if defined(__cplusplus) + +#include +#include +#include + +namespace Tx +{ + namespace Utils + { + template + class ScopedHandleTemplate + { + public: + ScopedHandleTemplate(THandle handle = TX_EMPTY_HANDLE) + : _handle(handle) + {} + + ~ScopedHandleTemplate() + { + SafeRelease(); + } + + THandle* operator &() + { + SafeRelease(); + return &_handle; + } + + operator const THandle () const + { + return _handle; + } + + THandle Detach() + { + auto handle = _handle; + _handle = TX_EMPTY_HANDLE; + return handle; + } + + bool IsAttached() const + { + return _handle != TX_EMPTY_HANDLE; + } + + private: + void SafeRelease() + { + if(!IsAttached()) + return; + + txReleaseObject(&_handle); + Detach(); + } + + private: + THandle _handle; + }; + + typedef ScopedHandleTemplate ScopedHandle; + + template + inline TX_RESULT GetBufferData(std::vector& targetBuffer, std::function fnGetBuf) + { + TX_RESULT resultCode; + TX_SIZE size; + + if(targetBuffer.empty()) + { + size = 0; + resultCode = fnGetBuf(nullptr, &size); + + if(resultCode == TX_RESULT_OK && size == 0) + return resultCode; + } + else + { + size = (TX_SIZE)targetBuffer.size(); + resultCode = fnGetBuf((TElement*)&targetBuffer[0], &size); + + if(resultCode == TX_RESULT_OK) + return resultCode; + } + + targetBuffer.resize(size); + resultCode = fnGetBuf((TElement*)&targetBuffer[0], &size); + + return resultCode; + } + + template + inline TX_RESULT GetBufferData(std::vector& targetBuffer, TX_RESULT (*pFn)(THandle1, TElement2*, TX_SIZE*), THandle2 handle) + { + std::function fnGetBuf = [handle, pFn](TElement1* pBuf, TX_SIZE* pSize) + { + return pFn(handle, (TElement2*)pBuf, pSize); + }; + + return GetBufferData(targetBuffer, fnGetBuf); + } + + inline TX_RESULT GetString(std::string* pTargetString, std::function fnGetString, TX_SIZE estimatedLength = 0) + { + std::vector buf(estimatedLength); + auto result = GetBufferData(buf, fnGetString); + if(result != TX_RESULT_OK) + return result; + + *pTargetString = &buf[0]; + return TX_RESULT_OK; + } + + template + inline TX_RESULT GetString(std::string* pTargetString, TX_RESULT (*pFn)(THandle1, TX_STRING, TX_SIZE*), THandle2 handle, TX_SIZE estimatedLength = 0) + { + auto fnGetString = [handle, pFn](TX_STRING pStr, TX_SIZE* pSize) + { + return pFn(handle, pStr, pSize); + }; + + return GetString(pTargetString, fnGetString); + } + } +} + +#endif /* defined(__cplusplus) */ + +#if !defined(TX_NODEBUGOBJECT) + +static const char* __txDbgObject(TX_CONSTHANDLE hObject) +{ + static char buf[65536]; + TX_SIZE bufSize; + + bufSize = sizeof(buf); + txFormatObjectAsText(hObject, buf, &bufSize); + return buf; +} + +typedef const char* (*TX_DEBUGOBJECT)(TX_CONSTHANDLE hObject); +static TX_DEBUGOBJECT txDebugObject = __txDbgObject; + +#endif /* !defined(TX_NODEBUGOBJECT) */ + +#if defined(__cplusplus) + +#if !defined(TX_NODEBUGOBJECT) + +// This variation is needed to make ScopedHandles debuggable in Visual Studios watch window +static const char* __txDbgScoped(const Tx::Utils::ScopedHandle& hObject) +{ + return txDebugObject(hObject); +} + +typedef const char* (*TX_DEBUGSCOPEDHANDLE)(const Tx::Utils::ScopedHandle& hObject); +static TX_DEBUGSCOPEDHANDLE txDebugScopedHandle = __txDbgScoped; + +#endif /* !defined(TX_NODEBUGOBJECT) */ + + +/*********************************************************************************************************************/ + +/** + Tx::CommitSnapshotAsync. This is a functional-enabled version of txCommitSnapshotAsync defined in EyeXSnapshot.h + */ + +/*********************************************************************************************************************/ + + +TX_API_FUNCTION_CPP(CommitSnapshotAsync, ( + TX_HANDLE hSnapshot, + const Tx::AsyncDataCallback& completionHandler + )); + +/*********************************************************************************************************************/ + +/** + Tx::GetStateAsync. This is a functional-enabled version of txGetStateAsync defined in EyeXStates.h + */ + +/*********************************************************************************************************************/ + +TX_API_FUNCTION_CPP(GetStateAsync,( + TX_CONTEXTHANDLE hContext, + TX_CONSTSTRING statePath, + const Tx::AsyncDataCallback& completionHandler)); + +/*********************************************************************************************************************/ + +/** + Tx::SetStateAsync. This is a functional-enabled version of txESetStateAsync defined in EyeXStates.h + */ + +/*********************************************************************************************************************/ + +TX_API_FUNCTION_CPP(SetStateAsync, ( + TX_HANDLE hStateBag, + const Tx::AsyncDataCallback& completionHandler)); + +/*********************************************************************************************************************/ + +/** + Tx::RegisterStateChangedHandler. This is a functional-enabled version of txRegisterStateChangedHandler defined in EyeXStates.h + */ + +/*********************************************************************************************************************/ + +TX_API_FUNCTION_CPP(RegisterStateChangedHandler, ( + TX_CONTEXTHANDLE hContext, + TX_TICKET* pTicket, + TX_CONSTSTRING statePath, + const Tx::AsyncDataCallback& handler)); + +/*********************************************************************************************************************/ + +/** + Tx::ExecuteCommandAsync. This is a functional-enabled version of txExecuteCommandAsync defined in EyeXCommand.h + */ + +/*********************************************************************************************************************/ + +TX_API_FUNCTION_CPP(ExecuteCommandAsync, ( + TX_HANDLE hCommand, + const Tx::AsyncDataCallback& completionHandler + )); + +/*********************************************************************************************************************/ + +/** + Tx::RegisterMessageHandler. This is a functional-enabled version of txRegisterMessageHandler defined in EyeXContext.h + */ + +/*********************************************************************************************************************/ + +TX_API_FUNCTION_CPP(RegisterMessageHandler,( + TX_CONTEXTHANDLE hContext, + TX_TICKET* pTicket, + TX_MESSAGETYPE messageType, + TX_HANDLE hOptions, + const Tx::AsyncDataCallback& completionHandler)); + +/*********************************************************************************************************************/ + +/** + Tx::DisableBuiltinKeys. This is a functional-enabled version of txDisableBuiltinKeys defined in EyeXActions.h + */ + +/*********************************************************************************************************************/ + +TX_API_FUNCTION_CPP(DisableBuiltinKeys,( + TX_CONTEXTHANDLE hContext, + TX_CONSTSTRING windowId, + const Tx::AsyncDataCallback& completionHandler)); + +/*********************************************************************************************************************/ + +/** + Tx::EnableBuiltinKeys. This is a functional-enabled version of txEnableBuiltinKeys defined in EyeXActions.h + */ + +/*********************************************************************************************************************/ + +TX_API_FUNCTION_CPP(EnableBuiltinKeys,( + TX_CONTEXTHANDLE hContext, + TX_CONSTSTRING windowId, + const Tx::AsyncDataCallback& completionHandler)); + +/*********************************************************************************************************************/ + +/** + Tx::LaunchConfigurationTool. This is a functional-enabled version of txLaunchConfigurationTool defined in EyeXActions.h +*/ + +/*********************************************************************************************************************/ + +TX_API_FUNCTION_CPP(LaunchConfigurationTool, ( + TX_CONTEXTHANDLE hContext, + TX_CONFIGURATIONTOOL configurationTool, + const Tx::AsyncDataCallback& completionHandler)); + +/*********************************************************************************************************************/ + +/** + Tx::SetCurrentProfile. This is a functional-enabled version of txSetCurrentProfile defined in EyeXActions.h +*/ + +/*********************************************************************************************************************/ + +TX_API_FUNCTION_CPP(SetCurrentProfile, ( + TX_CONTEXTHANDLE hContext, + TX_CONSTSTRING profileName, + const Tx::AsyncDataCallback& completionHandler)); + +/*********************************************************************************************************************/ + +/** + Tx::DeleteProfile. This is a functional-enabled version of txDeleteProfile defined in EyeXActions.h +*/ + +TX_API_FUNCTION_CPP(DeleteProfile, ( + TX_CONTEXTHANDLE hContext, + TX_CONSTSTRING profileName, + const Tx::AsyncDataCallback& completionHandler)); + +/*********************************************************************************************************************/ + +/** +* Tx::GetStateValueAsArrayOfUnicodeStrings. This is a utility function to get state values as an array of strings. + + \Since 1.3.0 + + @param hStateBag [in]: + A TX_CONSTHANDLE to the state bag from which the value should be retrieved. + Must not be TX_EMPTY_HANDLE. + + @param valuePath [in]: + The path to the value. + + @param valuePath [out]: + A vector of strings to which the string values will be copied. + + @return + TX_RESULT_OK: The state value was successfully retrieved. + TX_RESULT_EYEXNOTINITIALIZED: The EyeX client environment is not initialized. + TX_RESULT_INVALIDARGUMENT: An invalid argument was passed to the function. + TX_RESULT_NOTFOUND: The value was not found. + TX_RESULT_INVALIDPROPERTYTYPE: The value type was not TX_PROPERTYVALUETYPE_STRING or array of TX_PROPERTYVALUETYPE_STRING. +*/ +TX_API_FUNCTION_CPP(GetStateValueAsArrayOfStrings, ( + TX_CONSTHANDLE hStateBag, + TX_CONSTSTRING valuePath, + TX_REF_PARAM(std::vector) arrayOfStrings)); + +/*********************************************************************************************************************/ + +#endif /* defined(__cplusplus) */ + +#endif /* !defined(__TOBII_TX_UTILS__H__) */ + +/*********************************************************************************************************************/ \ No newline at end of file -- cgit v1.2.3