22 #ifndef __XN_CPP_WRAPPER_H__
23 #define __XN_CPP_WRAPPER_H__
80 Version(XnUInt8 nMajor, XnUInt8 nMinor, XnUInt16 nMaintenance, XnUInt32 nBuild)
168 inline const XnUInt8*
Data()
const {
return *m_ppData; }
170 inline const XnUInt8*&
Data() {
return *m_ppData; }
186 if (nBytes > m_nAllocatedSize)
195 m_nAllocatedSize = nBytes;
209 if (m_nAllocatedSize != 0)
213 m_nAllocatedSize = 0;
228 const XnUInt8* pOrigData = *m_ppData;
233 if (pOrigData != NULL)
252 const XnUInt8** m_ppData;
253 XnUInt32 m_nAllocatedSize;
277 inline XnUInt32
XRes()
const {
return m_map.
Res.
X; }
282 inline XnUInt32
YRes()
const {
return m_map.
Res.
Y; }
307 inline XnUInt32
FPS()
const {
return m_map.
nFPS; }
373 if (pExternalBuffer == NULL)
383 Data() = pExternalBuffer;
403 #define _XN_DECLARE_MAP_DATA_CLASS(_name, _pixelType) \
407 inline _name(_pixelType*& pData, XnUInt32& nXRes, XnUInt32 &nYRes) : \
408 m_pData(pData), m_nXRes(nXRes), m_nYRes(nYRes) {} \
410 inline XnUInt32 XRes() const { return m_nXRes; } \
411 inline XnUInt32 YRes() const { return m_nYRes; } \
413 inline const _pixelType& operator[](XnUInt32 nIndex) const \
415 XN_ASSERT(nIndex < (m_nXRes * m_nYRes)); \
416 return m_pData[nIndex]; \
418 inline _pixelType& operator[](XnUInt32 nIndex) \
420 XN_ASSERT(nIndex < (m_nXRes *m_nYRes)); \
421 return m_pData[nIndex]; \
424 inline const _pixelType& operator()(XnUInt32 x, XnUInt32 y) const \
426 XN_ASSERT(x < m_nXRes && y < m_nYRes); \
427 return m_pData[y*m_nXRes + x]; \
429 inline _pixelType& operator()(XnUInt32 x, XnUInt32 y) \
431 XN_ASSERT(x < m_nXRes && y < m_nYRes); \
432 return m_pData[y*m_nXRes + x]; \
437 _name(const _name& other); \
438 _name& operator=(const _name&); \
440 _pixelType*& m_pData; \
446 _XN_DECLARE_MAP_DATA_CLASS(ImageMap, XnUInt8);
450 _XN_DECLARE_MAP_DATA_CLASS(IRMap,
XnIRPixel);
451 _XN_DECLARE_MAP_DATA_CLASS(LabelMap,
XnLabel);
494 return ReAdjust(nXRes, nYRes, pExternalBuffer);
529 inline const xn::DepthMap&
DepthMap()
const {
return m_depthMap; }
534 return m_writableDepthMap;
544 XN_ASSERT(nIndex < (
XRes()*
YRes()));
545 return Data()[nIndex];
556 XN_ASSERT(x <
XRes() && y <
YRes());
571 const xn::DepthMap m_depthMap;
572 xn::DepthMap m_writableDepthMap;
717 inline const xn::ImageMap&
ImageMap()
const {
return m_imageMap; }
722 inline const xn::RGB24Map&
RGB24Map()
const {
return m_rgb24Map; }
727 inline const xn::Grayscale8Map&
Grayscale8Map()
const {
return m_gray8Map; }
747 const xn::ImageMap m_imageMap;
748 xn::ImageMap m_writableImageMap;
749 const xn::RGB24Map m_rgb24Map;
750 xn::RGB24Map m_writableRgb24Map;
751 const xn::Grayscale16Map m_gray16Map;
752 xn::Grayscale16Map m_writableGray16Map;
753 const xn::Grayscale8Map m_gray8Map;
754 xn::Grayscale8Map m_writableGray8Map;
788 return ReAdjust(nXRes, nYRes, pExternalBuffer);
814 inline const xn::IRMap&
IRMap()
const {
return m_irMap; }
829 const xn::IRMap m_irMap;
830 xn::IRMap m_writableIRMap;
917 return ReAdjust(nXRes, nYRes, pExternalBuffer);
943 inline const xn::LabelMap&
LabelMap()
const {
return m_labelMap; }
954 XN_ASSERT(nIndex < (
XRes()*
YRes()));
955 return Data()[nIndex];
966 XN_ASSERT(x <
XRes() && y <
YRes());
967 return (*
this)[y*
XRes() + x];
981 const xn::LabelMap m_labelMap;
982 xn::LabelMap m_writableLabelMap;
1071 inline void XN_API_DEPRECATED(
"Please use Release() instead.")
Unref() {
Release(); }
1076 if (m_hNode == hNode)
1083 if (m_hNode != NULL)
1122 static void XN_CALLBACK_TYPE ContextShuttingDownCallback(
XnContext* ,
void* pCookie)
1125 pThis->m_hNode = NULL;
1147 SetUnderlyingObject(pInfo);
1158 SetUnderlyingObject(other.m_pInfo);
1164 SetUnderlyingObject(NULL);
1174 SetUnderlyingObject(other.m_pInfo);
1238 inline void SetUnderlyingObject(
XnNodeInfo* pInfo);
1242 XnBool m_bOwnerOfNode;
1363 XnBool m_bAllocated;
1452 UpdateInternalObject(it);
1465 m_Info = NodeInfo(NULL);
1479 m_bAllocated =
TRUE;
1509 m_bAllocated =
TRUE;
1527 return xnNodeInfoListAddEx(m_pList, &description, strCreationInfo, pList, pAdditionalData, pFreeHandler);
1610 inline void FreeImpl()
1615 m_bAllocated =
FALSE;
1621 XnBool m_bAllocated;
1703 inline void GetRange(XnInt32& nMin, XnInt32& nMax, XnInt32& nStep, XnInt32& nDefault, XnBool& bIsAutoSupported)
const
1737 const XnChar* m_strCap;
3288 inline XnStatus SetData(XnUInt32 nFrameID, XnUInt64 nTimestamp, XnUInt32 nDataSize,
const XnUInt8* pImageMap)
3525 GestureCookie* pGestureCookie;
3527 pGestureCookie->recognizedHandler = RecognizedCB;
3528 pGestureCookie->progressHandler = ProgressCB;
3529 pGestureCookie->pUserCookie = pCookie;
3538 hCallback = pGestureCookie;
3548 GestureCookie* pGestureCookie = (GestureCookie*)hCallback;
3585 GestureIntermediateStageCompletedCookie* pGestureCookie;
3587 pGestureCookie->handler = handler;
3588 pGestureCookie->pUserCookie = pCookie;
3597 hCallback = pGestureCookie;
3606 GestureIntermediateStageCompletedCookie* pGestureCookie = (GestureIntermediateStageCompletedCookie*)hCallback;
3627 GestureReadyForNextIntermediateStageCookie* pGestureCookie;
3629 pGestureCookie->handler = handler;
3630 pGestureCookie->pUserCookie = pCookie;
3639 hCallback = pGestureCookie;
3649 GestureReadyForNextIntermediateStageCookie* pGestureCookie = (GestureReadyForNextIntermediateStageCookie*)hCallback;
3655 typedef struct GestureCookie
3663 static void XN_CALLBACK_TYPE GestureRecognizedCallback(
XnNodeHandle hNode,
const XnChar* strGesture,
const XnPoint3D* pIDPosition,
const XnPoint3D* pEndPosition,
void* pCookie)
3665 GestureCookie* pGestureCookie = (GestureCookie*)pCookie;
3667 if (pGestureCookie->recognizedHandler != NULL)
3669 pGestureCookie->recognizedHandler(gen, strGesture, pIDPosition, pEndPosition, pGestureCookie->pUserCookie);
3673 static void XN_CALLBACK_TYPE GestureProgressCallback(
XnNodeHandle hNode,
const XnChar* strGesture,
const XnPoint3D* pPosition, XnFloat fProgress,
void* pCookie)
3675 GestureCookie* pGestureCookie = (GestureCookie*)pCookie;
3677 if (pGestureCookie->progressHandler != NULL)
3679 pGestureCookie->progressHandler(gen, strGesture, pPosition, fProgress, pGestureCookie->pUserCookie);
3683 typedef struct GestureIntermediateStageCompletedCookie
3688 } GestureIntermediateStageCompletedCookie;
3690 static void XN_CALLBACK_TYPE GestureIntermediateStageCompletedCallback(
XnNodeHandle hNode,
const XnChar* strGesture,
const XnPoint3D* pPosition,
void* pCookie)
3692 GestureIntermediateStageCompletedCookie* pGestureCookie = (GestureIntermediateStageCompletedCookie*)pCookie;
3694 if (pGestureCookie->handler != NULL)
3696 pGestureCookie->handler(gen, strGesture, pPosition, pGestureCookie->pUserCookie);
3700 typedef struct GestureReadyForNextIntermediateStageCookie
3705 } GestureReadyForNextIntermediateStageCookie;
3707 static void XN_CALLBACK_TYPE GestureReadyForNextIntermediateStageCallback(
XnNodeHandle hNode,
const XnChar* strGesture,
const XnPoint3D* pPosition,
void* pCookie)
3709 GestureReadyForNextIntermediateStageCookie* pGestureCookie = (GestureReadyForNextIntermediateStageCookie*)pCookie;
3711 if (pGestureCookie->handler != NULL)
3713 pGestureCookie->handler(gen, strGesture, pPosition, pGestureCookie->pUserCookie);
3796 HandTouchingFOVEdgeCookie* pHandCookie;
3798 pHandCookie->handler = handler;
3799 pHandCookie->pUserCookie = pCookie;
3808 hCallback = pHandCookie;
3818 HandTouchingFOVEdgeCookie* pHandCookie = (HandTouchingFOVEdgeCookie*)hCallback;
3823 typedef struct HandTouchingFOVEdgeCookie
3828 } HandTouchingFOVEdgeCookie;
3832 HandTouchingFOVEdgeCookie* pHandCookie = (HandTouchingFOVEdgeCookie*)pCookie;
3834 if (pHandCookie->handler != NULL)
3836 pHandCookie->handler(cap, user, pPosition, fTime, eDir, pHandCookie->pUserCookie);
3898 HandCookie* pHandCookie;
3900 pHandCookie->createHandler = CreateCB;
3901 pHandCookie->updateHandler = UpdateCB;
3902 pHandCookie->destroyHandler = DestroyCB;
3903 pHandCookie->pUserCookie = pCookie;
3912 hCallback = pHandCookie;
3922 HandCookie* pHandCookie = (HandCookie*)hCallback;
3980 typedef struct HandCookie
3991 HandCookie* pHandCookie = (HandCookie*)pCookie;
3993 if (pHandCookie->createHandler != NULL)
3995 pHandCookie->createHandler(gen, user, pPosition, fTime, pHandCookie->pUserCookie);
4000 HandCookie* pHandCookie = (HandCookie*)pCookie;
4002 if (pHandCookie->updateHandler != NULL)
4004 pHandCookie->updateHandler(gen, user, pPosition, fTime, pHandCookie->pUserCookie);
4007 static void XN_CALLBACK_TYPE HandDestroyCB(
XnNodeHandle hNode,
XnUserID user, XnFloat fTime,
void* pCookie)
4009 HandCookie* pHandCookie = (HandCookie*)pCookie;
4011 if (pHandCookie->destroyHandler != NULL)
4013 pHandCookie->destroyHandler(gen, user, fTime, pHandCookie->pUserCookie);
4068 XN_API_DEPRECATED(
"Use the version with one argument")
4292 SkeletonCookie* pSkeletonCookie;
4294 pSkeletonCookie->startHandler = CalibrationStartCB;
4295 pSkeletonCookie->endHandler = CalibrationEndCB;
4296 pSkeletonCookie->pUserCookie = pCookie;
4298 #pragma warning (push)
4299 #pragma warning (disable: XN_DEPRECATED_WARNING_IDS)
4301 #pragma warning (pop)
4308 hCallback = pSkeletonCookie;
4318 SkeletonCookie* pSkeletonCookie = (SkeletonCookie*)hCallback;
4319 #pragma warning (push)
4320 #pragma warning (disable: XN_DEPRECATED_WARNING_IDS)
4322 #pragma warning (pop)
4332 CalibrationStartCookie* pCalibrationCookie;
4334 pCalibrationCookie->handler = handler;
4335 pCalibrationCookie->pUserCookie = pCookie;
4342 hCallback = pCalibrationCookie;
4350 CalibrationStartCookie* pCalibrationCookie = (CalibrationStartCookie*)hCallback;
4373 CalibrationInProgressCookie* pSkeletonCookie;
4375 pSkeletonCookie->handler = handler;
4376 pSkeletonCookie->pUserCookie = pCookie;
4385 hCallback = pSkeletonCookie;
4395 CalibrationInProgressCookie* pSkeletonCookie = (CalibrationInProgressCookie*)hCallback;
4416 CalibrationCompleteCookie* pSkeletonCookie;
4418 pSkeletonCookie->handler = handler;
4419 pSkeletonCookie->pUserCookie = pCookie;
4428 hCallback = pSkeletonCookie;
4438 CalibrationCompleteCookie* pSkeletonCookie = (CalibrationCompleteCookie*)hCallback;
4443 typedef struct SkeletonCookie
4451 static void XN_CALLBACK_TYPE CalibrationStartBundleCallback(
XnNodeHandle hNode,
XnUserID user,
void* pCookie)
4453 SkeletonCookie* pSkeletonCookie = (SkeletonCookie*)pCookie;
4455 if (pSkeletonCookie->startHandler != NULL)
4457 pSkeletonCookie->startHandler(cap, user, pSkeletonCookie->pUserCookie);
4461 static void XN_CALLBACK_TYPE CalibrationEndBundleCallback(
XnNodeHandle hNode,
XnUserID user, XnBool bSuccess,
void* pCookie)
4463 SkeletonCookie* pSkeletonCookie = (SkeletonCookie*)pCookie;
4465 if (pSkeletonCookie->endHandler != NULL)
4467 pSkeletonCookie->endHandler(cap, user, bSuccess, pSkeletonCookie->pUserCookie);
4470 typedef struct CalibrationStartCookie
4475 } CalibrationStartCookie;
4477 static void XN_CALLBACK_TYPE CalibrationStartCallback(
XnNodeHandle hNode,
XnUserID user,
void* pCookie)
4479 CalibrationStartCookie* pCalibrationCookie = (CalibrationStartCookie*)pCookie;
4481 if (pCalibrationCookie->handler != NULL)
4483 pCalibrationCookie->handler(cap, user, pCalibrationCookie->pUserCookie);
4486 typedef struct CalibrationInProgressCookie
4491 } CalibrationInProgressCookie;
4495 CalibrationInProgressCookie* pSkeletonCookie = (CalibrationInProgressCookie*)pCookie;
4497 if (pSkeletonCookie->handler != NULL)
4499 pSkeletonCookie->handler(cap, user, calibrationError, pSkeletonCookie->pUserCookie);
4503 typedef struct CalibrationCompleteCookie
4508 } CalibrationCompleteCookie;
4512 CalibrationCompleteCookie* pSkeletonCookie = (CalibrationCompleteCookie*)pCookie;
4514 if (pSkeletonCookie->handler != NULL)
4516 pSkeletonCookie->handler(cap, user, calibrationError, pSkeletonCookie->pUserCookie);
4592 PoseCookie* pPoseCookie;
4594 pPoseCookie->startHandler = PoseStartCB;
4595 pPoseCookie->endHandler = PoseEndCB;
4596 pPoseCookie->pPoseCookie = pCookie;
4598 #pragma warning (push)
4599 #pragma warning (disable: XN_DEPRECATED_WARNING_IDS)
4601 #pragma warning (pop)
4608 hCallback = pPoseCookie;
4618 PoseCookie* pPoseCookie = (PoseCookie*)hCallback;
4619 #pragma warning (push)
4620 #pragma warning (disable: XN_DEPRECATED_WARNING_IDS)
4622 #pragma warning (pop)
4632 PoseDetectionCookie* pPoseCookie;
4634 pPoseCookie->handler = handler;
4635 pPoseCookie->pPoseCookie = pCookie;
4643 hCallback = pPoseCookie;
4652 PoseDetectionCookie* pPoseCookie;
4654 pPoseCookie->handler = handler;
4655 pPoseCookie->pPoseCookie = pCookie;
4663 hCallback = pPoseCookie;
4671 PoseDetectionCookie* pPoseCookie = (PoseDetectionCookie*)hCallback;
4680 PoseDetectionCookie* pPoseCookie = (PoseDetectionCookie*)hCallback;
4702 PoseInProgressCookie* pPoseCookie;
4704 pPoseCookie->handler = handler;
4705 pPoseCookie->pPoseCookie = pCookie;
4714 hCallback = pPoseCookie;
4724 PoseInProgressCookie* pPoseCookie = (PoseInProgressCookie*)hCallback;
4730 typedef struct PoseCookie
4738 static void XN_CALLBACK_TYPE PoseDetectionStartBundleCallback(
XnNodeHandle hNode,
const XnChar* strPose,
XnUserID user,
void* pCookie)
4740 PoseCookie* pPoseCookie = (PoseCookie*)pCookie;
4742 if (pPoseCookie->startHandler != NULL)
4744 pPoseCookie->startHandler(cap, strPose, user, pPoseCookie->pPoseCookie);
4748 static void XN_CALLBACK_TYPE PoseDetectionStartEndBundleCallback(
XnNodeHandle hNode,
const XnChar* strPose,
XnUserID user,
void* pCookie)
4750 PoseCookie* pPoseCookie = (PoseCookie*)pCookie;
4752 if (pPoseCookie->endHandler != NULL)
4754 pPoseCookie->endHandler(cap, strPose, user, pPoseCookie->pPoseCookie);
4757 typedef struct PoseDetectionCookie
4762 } PoseDetectionCookie;
4763 static void XN_CALLBACK_TYPE PoseDetectionCallback(
XnNodeHandle hNode,
const XnChar* strPose,
XnUserID user,
void* pCookie)
4765 PoseDetectionCookie* pPoseDetectionCookie = (PoseDetectionCookie*)pCookie;
4767 if (pPoseDetectionCookie->handler != NULL)
4769 pPoseDetectionCookie->handler(cap, strPose, user, pPoseDetectionCookie->pPoseCookie);
4773 typedef struct PoseInProgressCookie
4778 } PoseInProgressCookie;
4782 PoseInProgressCookie* pPoseCookie = (PoseInProgressCookie*)pCookie;
4784 if (pPoseCookie->handler != NULL)
4786 pPoseCookie->handler(cap, strPose, user, poseErrors, pPoseCookie->pPoseCookie);
4852 UserCookie* pUserCookie;
4854 pUserCookie->newHandler = NewUserCB;
4855 pUserCookie->lostHandler = LostUserCB;
4856 pUserCookie->pUserCookie = pCookie;
4865 hCallback = pUserCookie;
4875 UserCookie* pUserCookie = (UserCookie*)hCallback;
4927 UserSingleCookie* pUserCookie;
4929 pUserCookie->handler = handler;
4930 pUserCookie->pUserCookie = pCookie;
4939 hCallback = pUserCookie;
4949 UserSingleCookie* pUserCookie = (UserSingleCookie*)hCallback;
4961 UserSingleCookie* pUserCookie;
4963 pUserCookie->handler = handler;
4964 pUserCookie->pUserCookie = pCookie;
4973 hCallback = pUserCookie;
4983 UserSingleCookie* pUserCookie = (UserSingleCookie*)hCallback;
4989 typedef struct UserCookie
4999 UserCookie* pUserCookie = (UserCookie*)pCookie;
5001 if (pUserCookie->newHandler != NULL)
5003 pUserCookie->newHandler(gen, user, pUserCookie->pUserCookie);
5007 static void XN_CALLBACK_TYPE LostUserCallback(
XnNodeHandle hNode,
XnUserID user,
void* pCookie)
5009 UserCookie* pUserCookie = (UserCookie*)pCookie;
5011 if (pUserCookie->lostHandler != NULL)
5013 pUserCookie->lostHandler(gen, user, pUserCookie->pUserCookie);
5017 typedef struct UserSingleCookie
5024 static void XN_CALLBACK_TYPE UserSingleCallback(
XnNodeHandle hNode,
XnUserID user,
void* pCookie)
5026 UserSingleCookie* pUserCookie = (UserSingleCookie*)pCookie;
5028 if (pUserCookie->handler != NULL)
5030 pUserCookie->handler(gen, user, pUserCookie->pUserCookie);
5154 inline XnStatus SetData(XnUInt32 nFrameID, XnUInt64 nTimestamp, XnUInt32 nDataSize,
const XnUInt8* pAudioBuffer)
5190 inline XnStatus SetData(XnUInt32 nFrameID, XnUInt64 nTimestamp, XnUInt32 nDataSize,
const void* pData)
5228 inline XnStatus EncodeData(
const void* pSrc, XnUInt32 nSrcSize,
void* pDst, XnUInt32 nDstSize, XnUInt* pnBytesWritten)
const
5236 inline XnStatus DecodeData(
const void* pSrc, XnUInt32 nSrcSize,
void* pDst, XnUInt32 nDstSize, XnUInt* pnBytesWritten)
const
5312 return m_it == other.m_it;
5322 return m_it != other.m_it;
5377 m_bAllocated =
FALSE;
5386 XnBool m_bAllocated;
5401 inline Context() : m_pContext(NULL), m_bUsingDeprecatedAPI(
FALSE), m_bAllocated(
FALSE), m_hShuttingDownCallback(NULL) {}
5419 inline Context(
const Context& other) : m_pContext(NULL), m_bUsingDeprecatedAPI(
FALSE), m_bAllocated(
FALSE), m_hShuttingDownCallback(NULL)
5449 m_bAllocated =
TRUE;
5459 m_bUsingDeprecatedAPI =
TRUE;
5460 #pragma warning (push)
5461 #pragma warning (disable: XN_DEPRECATED_WARNING_IDS)
5462 return xnContextRunXmlScript(m_pContext, strScript, pErrors == NULL ? NULL : pErrors->GetUnderlying());
5463 #pragma warning (pop)
5474 nRetVal =
xnContextRunXmlScriptEx(m_pContext, strScript, pErrors == NULL ? NULL : pErrors->GetUnderlying(), &hScriptNode);
5487 m_bUsingDeprecatedAPI =
TRUE;
5488 #pragma warning (push)
5489 #pragma warning (disable: XN_DEPRECATED_WARNING_IDS)
5491 #pragma warning (pop)
5516 m_bUsingDeprecatedAPI =
TRUE;
5518 #pragma warning (push)
5519 #pragma warning (disable: XN_DEPRECATED_WARNING_IDS)
5521 #pragma warning (pop)
5525 m_bAllocated =
TRUE;
5543 m_bAllocated =
TRUE;
5553 m_bUsingDeprecatedAPI =
TRUE;
5554 #pragma warning (push)
5555 #pragma warning (disable: XN_DEPRECATED_WARNING_IDS)
5557 #pragma warning (pop)
5643 inline void XN_API_DEPRECATED(
"You may use Release() instead, or count on dtor")
Shutdown()
5645 if (m_pContext != NULL)
5647 #pragma warning (push)
5648 #pragma warning (disable: XN_DEPRECATED_WARNING_IDS)
5650 #pragma warning (pop)
5689 nRetVal =
xnEnumerateProductionTrees(m_pContext, Type, pInternalQuery, &pList, pErrors == NULL ? NULL : pErrors->GetUnderlying());
5707 nRetVal =
xnCreateAnyProductionTree(m_pContext, type, pInternalQuery, &hNode, pErrors == NULL ? NULL : pErrors->GetUnderlying());
5726 Tree.m_bOwnerOfNode =
TRUE;
5925 if (m_pContext == pContext)
5930 if (m_pContext != NULL)
5932 if (m_bUsingDeprecatedAPI && m_bAllocated)
5945 if (pContext != NULL)
5954 m_pContext = pContext;
5961 if (pContext != NULL)
5968 static void XN_CALLBACK_TYPE ContextShuttingDownCallback(
XnContext* ,
void* pCookie)
5971 pThis->m_pContext = NULL;
5975 XnBool m_bUsingDeprecatedAPI;
5976 XnBool m_bAllocated;
6005 inline Resolution(XnUInt32 xRes, XnUInt32 yRes) : m_nXRes(xRes), m_nYRes(yRes)
6031 inline const XnChar*
GetName()
const {
return m_strName; }
6037 const XnChar* m_strName;
6055 if (m_pNeededNodes == NULL)
6061 return *m_pNeededNodes;
6064 inline void NodeInfo::SetUnderlyingObject(
XnNodeInfo* pInfo)
6066 if (m_pNeededNodes != NULL)
6071 m_bOwnerOfNode =
FALSE;
6073 m_pNeededNodes = NULL;
6098 if (m_pInfo == NULL)
6100 return XN_STATUS_INVALID_OPERATION;
6344 return xnFunc(hNode, StateChangedCallback,
this, &m_hCallback);
6349 xnFunc(hNode, m_hCallback);
6359 nRetVal = pTrans->
Register(xnFunc, hNode);
6382 typedef struct StateChangeCookie
6387 } StateChangeCookie;
6389 static void XN_CALLBACK_TYPE StateChangedCallback(
XnNodeHandle hNode,
void* pCookie)
6393 pTrans->m_UserHandler(node, pTrans->m_pUserCookie);
6397 void* m_pUserCookie;
6440 #endif // __XN_CPP_WRAPPER_H__