mirror of
https://github.com/opencv/opencv.git
synced 2024-11-24 03:00:14 +08:00
Merge pull request #5825 from GregoryMorse:master
This commit is contained in:
Vadim Pisarevsky
commit
d02627ea89
@ -56,7 +56,10 @@ if(WINRT)
|
||||
add_definitions(-DWINRT_STORE)
|
||||
endif()
|
||||
|
||||
if(CMAKE_SYSTEM_VERSION MATCHES 8.1)
|
||||
if(CMAKE_SYSTEM_VERSION MATCHES 10)
|
||||
set(WINRT_10 TRUE)
|
||||
add_definitions(-DWINRT_10)
|
||||
elseif(CMAKE_SYSTEM_VERSION MATCHES 8.1)
|
||||
set(WINRT_8_1 TRUE)
|
||||
add_definitions(-DWINRT_8_1)
|
||||
elseif(CMAKE_SYSTEM_VERSION MATCHES 8.0)
|
||||
@ -855,6 +858,9 @@ status(" Windows RT support:" WINRT THEN YES ELSE NO)
|
||||
status(" Building for Microsoft platform: " ${CMAKE_SYSTEM_NAME})
|
||||
status(" Building for architectures: " ${CMAKE_VS_EFFECTIVE_PLATFORMS})
|
||||
status(" Building for version: " ${CMAKE_SYSTEM_VERSION})
|
||||
if (DEFINED ENABLE_WINRT_MODE_NATIVE)
|
||||
status(" Building for C++ without CX extensions")
|
||||
endif()
|
||||
endif()
|
||||
endif(WIN32)
|
||||
|
||||
|
||||
@ -5,7 +5,11 @@ endif()
|
||||
#if (${CMAKE_SYSTEM_NAME} MATCHES "WindowsStore" OR ${CMAKE_SYSTEM_NAME} MATCHES "WindowsPhone")
|
||||
# set(WINRT TRUE)
|
||||
|
||||
if (WINRT)
|
||||
if (WINRT AND CMAKE_SYSTEM_VERSION MATCHES 10)
|
||||
add_definitions(/DWINVER=_WIN32_WINNT_WIN10 /DNTDDI_VERSION=NTDDI_WIN10 /D_WIN32_WINNT=_WIN32_WINNT_WIN10)
|
||||
elseif(WINRT AND CMAKE_SYSTEM_VERSION MATCHES 8.1)
|
||||
add_definitions(/DWINVER=_WIN32_WINNT_WINBLUE /DNTDDI_VERSION=NTDDI_WINBLUE /D_WIN32_WINNT=_WIN32_WINNT_WINBLUE)
|
||||
else()
|
||||
add_definitions(/DWINVER=_WIN32_WINNT_WIN8 /DNTDDI_VERSION=NTDDI_WIN8 /D_WIN32_WINNT=_WIN32_WINNT_WIN8)
|
||||
endif()
|
||||
|
||||
|
||||
@ -107,7 +107,7 @@
|
||||
#elif defined HAVE_GCD
|
||||
#include <dispatch/dispatch.h>
|
||||
#include <pthread.h>
|
||||
#elif defined WINRT
|
||||
#elif defined WINRT && _MSC_VER < 1900
|
||||
#include <ppltasks.h>
|
||||
#elif defined HAVE_CONCURRENCY
|
||||
#include <ppl.h>
|
||||
|
||||
@ -28,8 +28,7 @@
|
||||
#include <functional>
|
||||
#include <concrt.h>
|
||||
#include <agile.h>
|
||||
|
||||
using namespace Windows::UI::Xaml::Controls;
|
||||
#include "opencv2/core/cvdef.h"
|
||||
|
||||
namespace cv
|
||||
{
|
||||
@ -130,4 +129,4 @@ CV_EXPORTS void winrt_imshow();
|
||||
|
||||
//! @} videoio_winrt
|
||||
|
||||
} // cv
|
||||
} // cv
|
||||
|
||||
@ -1,568 +0,0 @@
|
||||
//
|
||||
// Copyright (C) Microsoft Corporation
|
||||
// All rights reserved.
|
||||
// Modified for native C++ WRL support by Gregory Morse
|
||||
//
|
||||
// Code in Details namespace is for internal usage within the library code
|
||||
//
|
||||
|
||||
#ifndef _PLATFORM_AGILE_H_
|
||||
#define _PLATFORM_AGILE_H_
|
||||
|
||||
#ifdef _MSC_VER
|
||||
#pragma once
|
||||
#endif // _MSC_VER
|
||||
|
||||
#include <algorithm>
|
||||
#include <wrl\client.h>
|
||||
|
||||
template <typename T, bool TIsNotAgile> class Agile;
|
||||
|
||||
template <typename T>
|
||||
struct UnwrapAgile
|
||||
{
|
||||
static const bool _IsAgile = false;
|
||||
};
|
||||
template <typename T>
|
||||
struct UnwrapAgile<Agile<T, false>>
|
||||
{
|
||||
static const bool _IsAgile = true;
|
||||
};
|
||||
template <typename T>
|
||||
struct UnwrapAgile<Agile<T, true>>
|
||||
{
|
||||
static const bool _IsAgile = true;
|
||||
};
|
||||
|
||||
#define IS_AGILE(T) UnwrapAgile<T>::_IsAgile
|
||||
|
||||
#define __is_winrt_agile(T) (std::is_same<T, HSTRING__>::value || std::is_base_of<Microsoft::WRL::FtmBase, T>::value || std::is_base_of<IAgileObject, T>::value) //derived from Microsoft::WRL::FtmBase or IAgileObject
|
||||
|
||||
#define __is_win_interface(T) (std::is_base_of<IUnknown, T>::value || std::is_base_of<IInspectable, T>::value) //derived from IUnknown or IInspectable
|
||||
|
||||
#define __is_win_class(T) (std::is_same<T, HSTRING__>::value || std::is_base_of<Microsoft::WRL::Details::RuntimeClassBase, T>::value) //derived from Microsoft::WRL::RuntimeClass or HSTRING
|
||||
|
||||
namespace Details
|
||||
{
|
||||
IUnknown* __stdcall GetObjectContext();
|
||||
HRESULT __stdcall GetProxyImpl(IUnknown*, REFIID, IUnknown*, IUnknown**);
|
||||
HRESULT __stdcall ReleaseInContextImpl(IUnknown*, IUnknown*);
|
||||
|
||||
template <typename T>
|
||||
#if _MSC_VER >= 1800
|
||||
__declspec(no_refcount) inline HRESULT GetProxy(T *ObjectIn, IUnknown *ContextCallBack, T **Proxy)
|
||||
#else
|
||||
inline HRESULT GetProxy(T *ObjectIn, IUnknown *ContextCallBack, T **Proxy)
|
||||
#endif
|
||||
{
|
||||
#if _MSC_VER >= 1800
|
||||
return GetProxyImpl(*reinterpret_cast<IUnknown**>(&ObjectIn), __uuidof(T*), ContextCallBack, reinterpret_cast<IUnknown**>(Proxy));
|
||||
#else
|
||||
return GetProxyImpl(*reinterpret_cast<IUnknown**>(&const_cast<T*>(ObjectIn)), __uuidof(T*), ContextCallBack, reinterpret_cast<IUnknown**>(Proxy));
|
||||
#endif
|
||||
}
|
||||
|
||||
template <typename T>
|
||||
inline HRESULT ReleaseInContext(T *ObjectIn, IUnknown *ContextCallBack)
|
||||
{
|
||||
return ReleaseInContextImpl(ObjectIn, ContextCallBack);
|
||||
}
|
||||
|
||||
template <typename T>
|
||||
class AgileHelper
|
||||
{
|
||||
__abi_IUnknown* _p;
|
||||
bool _release;
|
||||
public:
|
||||
AgileHelper(__abi_IUnknown* p, bool release = true) : _p(p), _release(release)
|
||||
{
|
||||
}
|
||||
AgileHelper(AgileHelper&& other) : _p(other._p), _release(other._release)
|
||||
{
|
||||
_other._p = nullptr;
|
||||
_other._release = true;
|
||||
}
|
||||
AgileHelper operator=(AgileHelper&& other)
|
||||
{
|
||||
_p = other._p;
|
||||
_release = other._release;
|
||||
_other._p = nullptr;
|
||||
_other._release = true;
|
||||
return *this;
|
||||
}
|
||||
|
||||
~AgileHelper()
|
||||
{
|
||||
if (_release && _p)
|
||||
{
|
||||
_p->__abi_Release();
|
||||
}
|
||||
}
|
||||
|
||||
__declspec(no_refcount) __declspec(no_release_return)
|
||||
T* operator->()
|
||||
{
|
||||
return reinterpret_cast<T*>(_p);
|
||||
}
|
||||
|
||||
__declspec(no_refcount) __declspec(no_release_return)
|
||||
operator T * ()
|
||||
{
|
||||
return reinterpret_cast<T*>(_p);
|
||||
}
|
||||
private:
|
||||
AgileHelper(const AgileHelper&);
|
||||
AgileHelper operator=(const AgileHelper&);
|
||||
};
|
||||
template <typename T>
|
||||
struct __remove_hat
|
||||
{
|
||||
typedef T type;
|
||||
};
|
||||
template <typename T>
|
||||
struct __remove_hat<T*>
|
||||
{
|
||||
typedef T type;
|
||||
};
|
||||
template <typename T>
|
||||
struct AgileTypeHelper
|
||||
{
|
||||
typename typedef __remove_hat<T>::type type;
|
||||
typename typedef __remove_hat<T>::type* agileMemberType;
|
||||
};
|
||||
} // namespace Details
|
||||
|
||||
#pragma warning(push)
|
||||
#pragma warning(disable: 4451) // Usage of ref class inside this context can lead to invalid marshaling of object across contexts
|
||||
|
||||
template <
|
||||
typename T,
|
||||
bool TIsNotAgile = (__is_win_class(typename Details::AgileTypeHelper<T>::type) && !__is_winrt_agile(typename Details::AgileTypeHelper<T>::type)) ||
|
||||
__is_win_interface(typename Details::AgileTypeHelper<T>::type)
|
||||
>
|
||||
class Agile
|
||||
{
|
||||
static_assert(__is_win_class(typename Details::AgileTypeHelper<T>::type) || __is_win_interface(typename Details::AgileTypeHelper<T>::type), "Agile can only be used with ref class or interface class types");
|
||||
typename typedef Details::AgileTypeHelper<T>::agileMemberType TypeT;
|
||||
TypeT _object;
|
||||
::Microsoft::WRL::ComPtr<IUnknown> _contextCallback;
|
||||
ULONG_PTR _contextToken;
|
||||
|
||||
#if _MSC_VER >= 1800
|
||||
enum class AgileState
|
||||
{
|
||||
NonAgilePointer = 0,
|
||||
AgilePointer = 1,
|
||||
Unknown = 2
|
||||
};
|
||||
AgileState _agileState;
|
||||
#endif
|
||||
|
||||
void CaptureContext()
|
||||
{
|
||||
_contextCallback = Details::GetObjectContext();
|
||||
__abi_ThrowIfFailed(CoGetContextToken(&_contextToken));
|
||||
}
|
||||
|
||||
void SetObject(TypeT object)
|
||||
{
|
||||
// Capture context before setting the pointer
|
||||
// If context capture fails then nothing to cleanup
|
||||
Release();
|
||||
if (object != nullptr)
|
||||
{
|
||||
::Microsoft::WRL::ComPtr<IAgileObject> checkIfAgile;
|
||||
HRESULT hr = reinterpret_cast<IUnknown*>(object)->QueryInterface(__uuidof(IAgileObject), &checkIfAgile);
|
||||
// Don't Capture context if object is agile
|
||||
if (hr != S_OK)
|
||||
{
|
||||
#if _MSC_VER >= 1800
|
||||
_agileState = AgileState::NonAgilePointer;
|
||||
#endif
|
||||
CaptureContext();
|
||||
}
|
||||
#if _MSC_VER >= 1800
|
||||
else
|
||||
{
|
||||
_agileState = AgileState::AgilePointer;
|
||||
}
|
||||
#endif
|
||||
}
|
||||
_object = object;
|
||||
}
|
||||
|
||||
public:
|
||||
Agile() throw() : _object(nullptr), _contextToken(0)
|
||||
#if _MSC_VER >= 1800
|
||||
, _agileState(AgileState::Unknown)
|
||||
#endif
|
||||
{
|
||||
}
|
||||
|
||||
Agile(nullptr_t) throw() : _object(nullptr), _contextToken(0)
|
||||
#if _MSC_VER >= 1800
|
||||
, _agileState(AgileState::Unknown)
|
||||
#endif
|
||||
{
|
||||
}
|
||||
|
||||
explicit Agile(TypeT object) throw() : _object(nullptr), _contextToken(0)
|
||||
#if _MSC_VER >= 1800
|
||||
, _agileState(AgileState::Unknown)
|
||||
#endif
|
||||
{
|
||||
// Assumes that the source object is from the current context
|
||||
SetObject(object);
|
||||
}
|
||||
|
||||
Agile(const Agile& object) throw() : _object(nullptr), _contextToken(0)
|
||||
#if _MSC_VER >= 1800
|
||||
, _agileState(AgileState::Unknown)
|
||||
#endif
|
||||
{
|
||||
// Get returns pointer valid for current context
|
||||
SetObject(object.Get());
|
||||
}
|
||||
|
||||
Agile(Agile&& object) throw() : _object(nullptr), _contextToken(0)
|
||||
#if _MSC_VER >= 1800
|
||||
, _agileState(AgileState::Unknown)
|
||||
#endif
|
||||
{
|
||||
// Assumes that the source object is from the current context
|
||||
Swap(object);
|
||||
}
|
||||
|
||||
~Agile() throw()
|
||||
{
|
||||
Release();
|
||||
}
|
||||
|
||||
TypeT Get() const
|
||||
{
|
||||
// Agile object, no proxy required
|
||||
#if _MSC_VER >= 1800
|
||||
if (_agileState == AgileState::AgilePointer || _object == nullptr)
|
||||
#else
|
||||
if (_contextToken == 0 || _contextCallback == nullptr || _object == nullptr)
|
||||
#endif
|
||||
{
|
||||
return _object;
|
||||
}
|
||||
|
||||
// Do the check for same context
|
||||
ULONG_PTR currentContextToken;
|
||||
__abi_ThrowIfFailed(CoGetContextToken(¤tContextToken));
|
||||
if (currentContextToken == _contextToken)
|
||||
{
|
||||
return _object;
|
||||
}
|
||||
|
||||
#if _MSC_VER >= 1800
|
||||
// Different context and holding on to a non agile object
|
||||
// Do the costly work of getting a proxy
|
||||
TypeT localObject;
|
||||
__abi_ThrowIfFailed(Details::GetProxy(_object, _contextCallback.Get(), &localObject));
|
||||
|
||||
if (_agileState == AgileState::Unknown)
|
||||
#else
|
||||
// Object is agile if it implements IAgileObject
|
||||
// GetAddressOf captures the context with out knowing the type of object that it will hold
|
||||
if (_object != nullptr)
|
||||
#endif
|
||||
{
|
||||
#if _MSC_VER >= 1800
|
||||
// Object is agile if it implements IAgileObject
|
||||
// GetAddressOf captures the context with out knowing the type of object that it will hold
|
||||
::Microsoft::WRL::ComPtr<IAgileObject> checkIfAgile;
|
||||
HRESULT hr = reinterpret_cast<IUnknown*>(localObject)->QueryInterface(__uuidof(IAgileObject), &checkIfAgile);
|
||||
#else
|
||||
::Microsoft::WRL::ComPtr<IAgileObject> checkIfAgile;
|
||||
HRESULT hr = reinterpret_cast<IUnknown*>(_object)->QueryInterface(__uuidof(IAgileObject), &checkIfAgile);
|
||||
#endif
|
||||
if (hr == S_OK)
|
||||
{
|
||||
auto pThis = const_cast<Agile*>(this);
|
||||
#if _MSC_VER >= 1800
|
||||
pThis->_agileState = AgileState::AgilePointer;
|
||||
#endif
|
||||
pThis->_contextToken = 0;
|
||||
pThis->_contextCallback = nullptr;
|
||||
return _object;
|
||||
}
|
||||
#if _MSC_VER >= 1800
|
||||
else
|
||||
{
|
||||
auto pThis = const_cast<Agile*>(this);
|
||||
pThis->_agileState = AgileState::NonAgilePointer;
|
||||
}
|
||||
#endif
|
||||
}
|
||||
|
||||
#if _MSC_VER < 1800
|
||||
// Different context and holding on to a non agile object
|
||||
// Do the costly work of getting a proxy
|
||||
TypeT localObject;
|
||||
__abi_ThrowIfFailed(Details::GetProxy(_object, _contextCallback.Get(), &localObject));
|
||||
#endif
|
||||
return localObject;
|
||||
}
|
||||
|
||||
TypeT* GetAddressOf() throw()
|
||||
{
|
||||
Release();
|
||||
CaptureContext();
|
||||
return &_object;
|
||||
}
|
||||
|
||||
TypeT* GetAddressOfForInOut() throw()
|
||||
{
|
||||
CaptureContext();
|
||||
return &_object;
|
||||
}
|
||||
|
||||
TypeT operator->() const throw()
|
||||
{
|
||||
return Get();
|
||||
}
|
||||
|
||||
Agile& operator=(nullptr_t) throw()
|
||||
{
|
||||
Release();
|
||||
return *this;
|
||||
}
|
||||
|
||||
Agile& operator=(TypeT object) throw()
|
||||
{
|
||||
Agile(object).Swap(*this);
|
||||
return *this;
|
||||
}
|
||||
|
||||
Agile& operator=(Agile object) throw()
|
||||
{
|
||||
// parameter is by copy which gets pointer valid for current context
|
||||
object.Swap(*this);
|
||||
return *this;
|
||||
}
|
||||
|
||||
#if _MSC_VER < 1800
|
||||
Agile& operator=(IUnknown* lp) throw()
|
||||
{
|
||||
// bump ref count
|
||||
::Microsoft::WRL::ComPtr<IUnknown> spObject(lp);
|
||||
|
||||
// put it into Platform Object
|
||||
Platform::Object object;
|
||||
*(IUnknown**)(&object) = spObject.Detach();
|
||||
|
||||
SetObject(object);
|
||||
return *this;
|
||||
}
|
||||
#endif
|
||||
|
||||
void Swap(Agile& object)
|
||||
{
|
||||
std::swap(_object, object._object);
|
||||
std::swap(_contextCallback, object._contextCallback);
|
||||
std::swap(_contextToken, object._contextToken);
|
||||
#if _MSC_VER >= 1800
|
||||
std::swap(_agileState, object._agileState);
|
||||
#endif
|
||||
}
|
||||
|
||||
// Release the interface and set to NULL
|
||||
void Release() throw()
|
||||
{
|
||||
if (_object)
|
||||
{
|
||||
// Cast to IInspectable (no QI)
|
||||
IUnknown* pObject = *(IUnknown**)(&_object);
|
||||
// Set * to null without release
|
||||
*(IUnknown**)(&_object) = nullptr;
|
||||
|
||||
ULONG_PTR currentContextToken;
|
||||
__abi_ThrowIfFailed(CoGetContextToken(¤tContextToken));
|
||||
if (_contextToken == 0 || _contextCallback == nullptr || _contextToken == currentContextToken)
|
||||
{
|
||||
pObject->Release();
|
||||
}
|
||||
else
|
||||
{
|
||||
Details::ReleaseInContext(pObject, _contextCallback.Get());
|
||||
}
|
||||
_contextCallback = nullptr;
|
||||
_contextToken = 0;
|
||||
#if _MSC_VER >= 1800
|
||||
_agileState = AgileState::Unknown;
|
||||
#endif
|
||||
}
|
||||
}
|
||||
|
||||
bool operator==(nullptr_t) const throw()
|
||||
{
|
||||
return _object == nullptr;
|
||||
}
|
||||
|
||||
bool operator==(const Agile& other) const throw()
|
||||
{
|
||||
return _object == other._object && _contextToken == other._contextToken;
|
||||
}
|
||||
|
||||
bool operator<(const Agile& other) const throw()
|
||||
{
|
||||
if (reinterpret_cast<void*>(_object) < reinterpret_cast<void*>(other._object))
|
||||
{
|
||||
return true;
|
||||
}
|
||||
|
||||
return _object == other._object && _contextToken < other._contextToken;
|
||||
}
|
||||
};
|
||||
|
||||
template <typename T>
|
||||
class Agile<T, false>
|
||||
{
|
||||
static_assert(__is_win_class(typename Details::AgileTypeHelper<T>::type) || __is_win_interface(typename Details::AgileTypeHelper<T>::type), "Agile can only be used with ref class or interface class types");
|
||||
typename typedef Details::AgileTypeHelper<T>::agileMemberType TypeT;
|
||||
TypeT _object;
|
||||
|
||||
public:
|
||||
Agile() throw() : _object(nullptr)
|
||||
{
|
||||
}
|
||||
|
||||
Agile(nullptr_t) throw() : _object(nullptr)
|
||||
{
|
||||
}
|
||||
|
||||
explicit Agile(TypeT object) throw() : _object(object)
|
||||
{
|
||||
}
|
||||
|
||||
Agile(const Agile& object) throw() : _object(object._object)
|
||||
{
|
||||
}
|
||||
|
||||
Agile(Agile&& object) throw() : _object(nullptr)
|
||||
{
|
||||
Swap(object);
|
||||
}
|
||||
|
||||
~Agile() throw()
|
||||
{
|
||||
Release();
|
||||
}
|
||||
|
||||
TypeT Get() const
|
||||
{
|
||||
return _object;
|
||||
}
|
||||
|
||||
TypeT* GetAddressOf() throw()
|
||||
{
|
||||
Release();
|
||||
return &_object;
|
||||
}
|
||||
|
||||
TypeT* GetAddressOfForInOut() throw()
|
||||
{
|
||||
return &_object;
|
||||
}
|
||||
|
||||
TypeT operator->() const throw()
|
||||
{
|
||||
return Get();
|
||||
}
|
||||
|
||||
Agile& operator=(nullptr_t) throw()
|
||||
{
|
||||
Release();
|
||||
return *this;
|
||||
}
|
||||
|
||||
Agile& operator=(TypeT object) throw()
|
||||
{
|
||||
if (_object != object)
|
||||
{
|
||||
_object = object;
|
||||
}
|
||||
return *this;
|
||||
}
|
||||
|
||||
Agile& operator=(Agile object) throw()
|
||||
{
|
||||
object.Swap(*this);
|
||||
return *this;
|
||||
}
|
||||
|
||||
#if _MSC_VER < 1800
|
||||
Agile& operator=(IUnknown* lp) throw()
|
||||
{
|
||||
Release();
|
||||
// bump ref count
|
||||
::Microsoft::WRL::ComPtr<IUnknown> spObject(lp);
|
||||
|
||||
// put it into Platform Object
|
||||
Platform::Object object;
|
||||
*(IUnknown**)(&object) = spObject.Detach();
|
||||
|
||||
_object = object;
|
||||
return *this;
|
||||
}
|
||||
#endif
|
||||
|
||||
// Release the interface and set to NULL
|
||||
void Release() throw()
|
||||
{
|
||||
_object = nullptr;
|
||||
}
|
||||
|
||||
void Swap(Agile& object)
|
||||
{
|
||||
std::swap(_object, object._object);
|
||||
}
|
||||
|
||||
bool operator==(nullptr_t) const throw()
|
||||
{
|
||||
return _object == nullptr;
|
||||
}
|
||||
|
||||
bool operator==(const Agile& other) const throw()
|
||||
{
|
||||
return _object == other._object;
|
||||
}
|
||||
|
||||
bool operator<(const Agile& other) const throw()
|
||||
{
|
||||
return reinterpret_cast<void*>(_object) < reinterpret_cast<void*>(other._object);
|
||||
}
|
||||
};
|
||||
|
||||
#pragma warning(pop)
|
||||
|
||||
template<class U>
|
||||
bool operator==(nullptr_t, const Agile<U>& a) throw()
|
||||
{
|
||||
return a == nullptr;
|
||||
}
|
||||
|
||||
template<class U>
|
||||
bool operator!=(const Agile<U>& a, nullptr_t) throw()
|
||||
{
|
||||
return !(a == nullptr);
|
||||
}
|
||||
|
||||
template<class U>
|
||||
bool operator!=(nullptr_t, const Agile<U>& a) throw()
|
||||
{
|
||||
return !(a == nullptr);
|
||||
}
|
||||
|
||||
template<class U>
|
||||
bool operator!=(const Agile<U>& a, const Agile<U>& b) throw()
|
||||
{
|
||||
return !(a == b);
|
||||
}
|
||||
|
||||
|
||||
#endif // _PLATFORM_AGILE_H_
|
||||
@ -44,7 +44,7 @@
|
||||
#include "cap_dshow.hpp"
|
||||
|
||||
// All WinRT versions older than 8.0 should provide classes used for video support
|
||||
#if defined(WINRT) && !defined(WINRT_8_0)
|
||||
#if defined(WINRT) && !defined(WINRT_8_0) && defined(__cplusplus_winrt)
|
||||
# include "cap_winrt_capture.hpp"
|
||||
# include "cap_winrt_bridge.hpp"
|
||||
# define WINRT_VIDEO
|
||||
|
||||
@ -103,163 +103,9 @@
|
||||
#ifdef HAVE_CONCURRENCY
|
||||
#include <concrt.h>
|
||||
#ifndef __cplusplus_winrt
|
||||
__declspec(noreturn) void __stdcall __abi_WinRTraiseException(long);
|
||||
|
||||
inline void __abi_ThrowIfFailed(long __hrArg)
|
||||
{
|
||||
if (__hrArg < 0)
|
||||
{
|
||||
__abi_WinRTraiseException(__hrArg);
|
||||
}
|
||||
}
|
||||
|
||||
struct Guid
|
||||
{
|
||||
public:
|
||||
Guid();
|
||||
Guid(__rcGUID_t);
|
||||
operator ::__rcGUID_t();
|
||||
bool Equals(Guid __guidArg);
|
||||
bool Equals(__rcGUID_t __guidArg);
|
||||
Guid(unsigned int __aArg, unsigned short __bArg, unsigned short __cArg, unsigned __int8 __dArg,
|
||||
unsigned __int8 __eArg, unsigned __int8 __fArg, unsigned __int8 __gArg, unsigned __int8 __hArg,
|
||||
unsigned __int8 __iArg, unsigned __int8 __jArg, unsigned __int8 __kArg);
|
||||
Guid(unsigned int __aArg, unsigned short __bArg, unsigned short __cArg, const unsigned __int8* __dArg);
|
||||
private:
|
||||
unsigned long __a;
|
||||
unsigned short __b;
|
||||
unsigned short __c;
|
||||
unsigned char __d;
|
||||
unsigned char __e;
|
||||
unsigned char __f;
|
||||
unsigned char __g;
|
||||
unsigned char __h;
|
||||
unsigned char __i;
|
||||
unsigned char __j;
|
||||
unsigned char __k;
|
||||
};
|
||||
|
||||
static_assert(sizeof(Guid) == sizeof(::_GUID), "Incorect size for Guid");
|
||||
static_assert(sizeof(__rcGUID_t) == sizeof(::_GUID), "Incorect size for __rcGUID_t");
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
inline Guid::Guid() : __a(0), __b(0), __c(0), __d(0), __e(0), __f(0), __g(0), __h(0), __i(0), __j(0), __k(0)
|
||||
{
|
||||
}
|
||||
|
||||
inline Guid::Guid(__rcGUID_t __guid) :
|
||||
__a(reinterpret_cast<const __s_GUID&>(__guid).Data1),
|
||||
__b(reinterpret_cast<const __s_GUID&>(__guid).Data2),
|
||||
__c(reinterpret_cast<const __s_GUID&>(__guid).Data3),
|
||||
__d(reinterpret_cast<const __s_GUID&>(__guid).Data4[0]),
|
||||
__e(reinterpret_cast<const __s_GUID&>(__guid).Data4[1]),
|
||||
__f(reinterpret_cast<const __s_GUID&>(__guid).Data4[2]),
|
||||
__g(reinterpret_cast<const __s_GUID&>(__guid).Data4[3]),
|
||||
__h(reinterpret_cast<const __s_GUID&>(__guid).Data4[4]),
|
||||
__i(reinterpret_cast<const __s_GUID&>(__guid).Data4[5]),
|
||||
__j(reinterpret_cast<const __s_GUID&>(__guid).Data4[6]),
|
||||
__k(reinterpret_cast<const __s_GUID&>(__guid).Data4[7])
|
||||
{
|
||||
}
|
||||
|
||||
inline Guid::operator ::__rcGUID_t()
|
||||
{
|
||||
return reinterpret_cast<__rcGUID_t>(*this);
|
||||
}
|
||||
|
||||
inline bool Guid::Equals(Guid __guidArg)
|
||||
{
|
||||
return *this == __guidArg;
|
||||
}
|
||||
|
||||
inline bool Guid::Equals(__rcGUID_t __guidArg)
|
||||
{
|
||||
return *this == static_cast< Guid>(__guidArg);
|
||||
}
|
||||
|
||||
inline bool operator==(Guid __aArg, Guid __bArg)
|
||||
{
|
||||
auto __a = reinterpret_cast<unsigned long*>(&__aArg);
|
||||
auto __b = reinterpret_cast<unsigned long*>(&__bArg);
|
||||
|
||||
return (__a[0] == __b[0] && __a[1] == __b[1] && __a[2] == __b[2] && __a[3] == __b[3]);
|
||||
}
|
||||
|
||||
inline bool operator!=(Guid __aArg, Guid __bArg)
|
||||
{
|
||||
return !(__aArg == __bArg);
|
||||
}
|
||||
|
||||
inline bool operator<(Guid __aArg, Guid __bArg)
|
||||
{
|
||||
auto __a = reinterpret_cast<unsigned long*>(&__aArg);
|
||||
auto __b = reinterpret_cast<unsigned long*>(&__bArg);
|
||||
|
||||
if (__a[0] != __b[0])
|
||||
{
|
||||
return __a[0] < __b[0];
|
||||
}
|
||||
|
||||
if (__a[1] != __b[1])
|
||||
{
|
||||
return __a[1] < __b[1];
|
||||
}
|
||||
|
||||
if (__a[2] != __b[2])
|
||||
{
|
||||
return __a[2] < __b[2];
|
||||
}
|
||||
|
||||
if (__a[3] != __b[3])
|
||||
{
|
||||
return __a[3] < __b[3];
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
inline Guid::Guid(unsigned int __aArg, unsigned short __bArg, unsigned short __cArg, unsigned __int8 __dArg,
|
||||
unsigned __int8 __eArg, unsigned __int8 __fArg, unsigned __int8 __gArg, unsigned __int8 __hArg,
|
||||
unsigned __int8 __iArg, unsigned __int8 __jArg, unsigned __int8 __kArg) :
|
||||
__a(__aArg), __b(__bArg), __c(__cArg), __d(__dArg), __e(__eArg), __f(__fArg), __g(__gArg), __h(__hArg), __i(__iArg), __j(__jArg), __k(__kArg)
|
||||
{
|
||||
}
|
||||
|
||||
inline Guid::Guid(unsigned int __aArg, unsigned short __bArg, unsigned short __cArg, const unsigned __int8 __dArg[8]) :
|
||||
__a(__aArg), __b(__bArg), __c(__cArg)
|
||||
{
|
||||
__d = __dArg[0];
|
||||
__e = __dArg[1];
|
||||
__f = __dArg[2];
|
||||
__g = __dArg[3];
|
||||
__h = __dArg[4];
|
||||
__i = __dArg[5];
|
||||
__j = __dArg[6];
|
||||
__k = __dArg[7];
|
||||
}
|
||||
|
||||
__declspec(selectany) Guid __winrt_GUID_NULL(0x00000000, 0x0000, 0x0000, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00);
|
||||
|
||||
//
|
||||
//// Don't want to define the real IUnknown from unknown.h here. That would means if the user has
|
||||
//// any broken code that uses it, compile errors will take the form of e.g.:
|
||||
//// predefined C++ WinRT types (compiler internal)(41) : see declaration of 'IUnknown::QueryInterface'
|
||||
//// This is not helpful. If they use IUnknown, we still need to point them to the actual unknown.h so
|
||||
//// that they can see the original definition.
|
||||
////
|
||||
//// For WinRT, we'll instead have a parallel COM interface hierarchy for basic interfaces starting with _.
|
||||
//// The type mismatch is not an issue. COM passes types through GUID / void* combos - the original type
|
||||
//// doesn't come into play unless the user static_casts an implementation type to one of these, but
|
||||
//// the WinRT implementation types are hidden.
|
||||
__interface __declspec(uuid("00000000-0000-0000-C000-000000000046")) __abi_IUnknown
|
||||
{
|
||||
public:
|
||||
virtual long __stdcall __abi_QueryInterface(Guid&, void**) = 0;
|
||||
virtual unsigned long __stdcall __abi_AddRef() = 0;
|
||||
virtual unsigned long __stdcall __abi_Release() = 0;
|
||||
};
|
||||
#include "wrl.h
|
||||
#endif
|
||||
#include "ppltasks_winrt.h"
|
||||
#include "ppltasks_winrt.hpp"
|
||||
#endif
|
||||
#else
|
||||
#include <comdef.h>
|
||||
|
||||
@ -1,205 +1,7 @@
|
||||
#ifdef WINRT
|
||||
#define ICustomStreamSink StreamSink
|
||||
#ifndef __cplusplus_winrt
|
||||
|
||||
#define __is_winrt_array(type) (type == ABI::Windows::Foundation::PropertyType::PropertyType_UInt8Array || type == ABI::Windows::Foundation::PropertyType::PropertyType_Int16Array ||\
|
||||
type == ABI::Windows::Foundation::PropertyType::PropertyType_UInt16Array || type == ABI::Windows::Foundation::PropertyType::PropertyType_Int32Array ||\
|
||||
type == ABI::Windows::Foundation::PropertyType::PropertyType_UInt32Array || type == ABI::Windows::Foundation::PropertyType::PropertyType_Int64Array ||\
|
||||
type == ABI::Windows::Foundation::PropertyType::PropertyType_UInt64Array || type == ABI::Windows::Foundation::PropertyType::PropertyType_SingleArray ||\
|
||||
type == ABI::Windows::Foundation::PropertyType::PropertyType_DoubleArray || type == ABI::Windows::Foundation::PropertyType::PropertyType_Char16Array ||\
|
||||
type == ABI::Windows::Foundation::PropertyType::PropertyType_BooleanArray || type == ABI::Windows::Foundation::PropertyType::PropertyType_StringArray ||\
|
||||
type == ABI::Windows::Foundation::PropertyType::PropertyType_InspectableArray || type == ABI::Windows::Foundation::PropertyType::PropertyType_DateTimeArray ||\
|
||||
type == ABI::Windows::Foundation::PropertyType::PropertyType_TimeSpanArray || type == ABI::Windows::Foundation::PropertyType::PropertyType_GuidArray ||\
|
||||
type == ABI::Windows::Foundation::PropertyType::PropertyType_PointArray || type == ABI::Windows::Foundation::PropertyType::PropertyType_SizeArray ||\
|
||||
type == ABI::Windows::Foundation::PropertyType::PropertyType_RectArray || type == ABI::Windows::Foundation::PropertyType::PropertyType_OtherTypeArray)
|
||||
|
||||
template<typename _Type, bool bUnknown = std::is_base_of<IUnknown, _Type>::value>
|
||||
struct winrt_type
|
||||
{
|
||||
};
|
||||
template<typename _Type>
|
||||
struct winrt_type<_Type, true>
|
||||
{
|
||||
static IUnknown* create(_Type* _ObjInCtx) {
|
||||
return reinterpret_cast<IUnknown*>(_ObjInCtx);
|
||||
}
|
||||
static IID getuuid() { return __uuidof(_Type); }
|
||||
static const ABI::Windows::Foundation::PropertyType _PropType = ABI::Windows::Foundation::PropertyType::PropertyType_OtherType;
|
||||
};
|
||||
template <typename _Type>
|
||||
struct winrt_type<_Type, false>
|
||||
{
|
||||
static IUnknown* create(_Type* _ObjInCtx) {
|
||||
Microsoft::WRL::ComPtr<IInspectable> _PObj;
|
||||
Microsoft::WRL::ComPtr<IActivationFactory> objFactory;
|
||||
HRESULT hr = Windows::Foundation::GetActivationFactory(Microsoft::WRL::Wrappers::HStringReference(RuntimeClass_Windows_Foundation_PropertyValue).Get(), objFactory.ReleaseAndGetAddressOf());
|
||||
if (FAILED(hr)) return nullptr;
|
||||
Microsoft::WRL::ComPtr<ABI::Windows::Foundation::IPropertyValueStatics> spPropVal;
|
||||
if (SUCCEEDED(hr))
|
||||
hr = objFactory.As(&spPropVal);
|
||||
if (SUCCEEDED(hr)) {
|
||||
hr = winrt_type<_Type>::create(spPropVal.Get(), _ObjInCtx, _PObj.GetAddressOf());
|
||||
if (SUCCEEDED(hr))
|
||||
return reinterpret_cast<IUnknown*>(_PObj.Detach());
|
||||
}
|
||||
return nullptr;
|
||||
}
|
||||
static IID getuuid() { return __uuidof(ABI::Windows::Foundation::IPropertyValue); }
|
||||
static const ABI::Windows::Foundation::PropertyType _PropType = ABI::Windows::Foundation::PropertyType::PropertyType_OtherType;
|
||||
};
|
||||
|
||||
template<>
|
||||
struct winrt_type<void>
|
||||
{
|
||||
static HRESULT create(ABI::Windows::Foundation::IPropertyValueStatics* spPropVal, void* _ObjInCtx, IInspectable** ppInsp) {
|
||||
(void)_ObjInCtx;
|
||||
return spPropVal->CreateEmpty(ppInsp);
|
||||
}
|
||||
static const ABI::Windows::Foundation::PropertyType _PropType = ABI::Windows::Foundation::PropertyType::PropertyType_Empty;
|
||||
};
|
||||
#define MAKE_TYPE(Type, Name) template<>\
|
||||
struct winrt_type<Type>\
|
||||
{\
|
||||
static HRESULT create(ABI::Windows::Foundation::IPropertyValueStatics* spPropVal, Type* _ObjInCtx, IInspectable** ppInsp) {\
|
||||
return spPropVal->Create##Name(*_ObjInCtx, ppInsp);\
|
||||
}\
|
||||
static const ABI::Windows::Foundation::PropertyType _PropType = ABI::Windows::Foundation::PropertyType::PropertyType_##Name;\
|
||||
};
|
||||
|
||||
template<typename _Type>
|
||||
struct winrt_array_type
|
||||
{
|
||||
static IUnknown* create(_Type* _ObjInCtx, size_t N) {
|
||||
Microsoft::WRL::ComPtr<IInspectable> _PObj;
|
||||
Microsoft::WRL::ComPtr<IActivationFactory> objFactory;
|
||||
HRESULT hr = Windows::Foundation::GetActivationFactory(Microsoft::WRL::Wrappers::HStringReference(RuntimeClass_Windows_Foundation_PropertyValue).Get(), objFactory.ReleaseAndGetAddressOf());
|
||||
if (FAILED(hr)) return nullptr;
|
||||
Microsoft::WRL::ComPtr<ABI::Windows::Foundation::IPropertyValueStatics> spPropVal;
|
||||
if (SUCCEEDED(hr))
|
||||
hr = objFactory.As(&spPropVal);
|
||||
if (SUCCEEDED(hr)) {
|
||||
hr = winrt_array_type<_Type>::create(spPropVal.Get(), N, _ObjInCtx, _PObj.GetAddressOf());
|
||||
if (SUCCEEDED(hr))
|
||||
return reinterpret_cast<IUnknown*>(_PObj.Detach());
|
||||
}
|
||||
return nullptr;
|
||||
}
|
||||
static const ABI::Windows::Foundation::PropertyType _PropType = ABI::Windows::Foundation::PropertyType::PropertyType_OtherTypeArray;
|
||||
};
|
||||
template<int>
|
||||
struct winrt_prop_type {};
|
||||
|
||||
template <>
|
||||
struct winrt_prop_type<ABI::Windows::Foundation::PropertyType_Empty> {
|
||||
typedef void _Type;
|
||||
};
|
||||
|
||||
template <>
|
||||
struct winrt_prop_type<ABI::Windows::Foundation::PropertyType_OtherType> {
|
||||
typedef void _Type;
|
||||
};
|
||||
|
||||
template <>
|
||||
struct winrt_prop_type<ABI::Windows::Foundation::PropertyType_OtherTypeArray> {
|
||||
typedef void _Type;
|
||||
};
|
||||
|
||||
#define MAKE_PROP(Prop, Type) template <>\
|
||||
struct winrt_prop_type<ABI::Windows::Foundation::PropertyType_##Prop> {\
|
||||
typedef Type _Type;\
|
||||
};
|
||||
|
||||
#define MAKE_ARRAY_TYPE(Type, Name) MAKE_PROP(Name, Type)\
|
||||
MAKE_PROP(Name##Array, Type*)\
|
||||
MAKE_TYPE(Type, Name)\
|
||||
template<>\
|
||||
struct winrt_array_type<Type*>\
|
||||
{\
|
||||
static HRESULT create(ABI::Windows::Foundation::IPropertyValueStatics* spPropVal, UINT32 __valueSize, Type** _ObjInCtx, IInspectable** ppInsp) {\
|
||||
return spPropVal->Create##Name##Array(__valueSize, *_ObjInCtx, ppInsp);\
|
||||
}\
|
||||
static const ABI::Windows::Foundation::PropertyType _PropType = ABI::Windows::Foundation::PropertyType::PropertyType_##Name##Array;\
|
||||
static std::vector<Type> PropertyValueToVector(ABI::Windows::Foundation::IPropertyValue* propValue)\
|
||||
{\
|
||||
UINT32 uLen = 0;\
|
||||
Type* pArray = nullptr;\
|
||||
propValue->Get##Name##Array(&uLen, &pArray);\
|
||||
return std::vector<Type>(pArray, pArray + uLen);\
|
||||
}\
|
||||
};
|
||||
MAKE_ARRAY_TYPE(BYTE, UInt8)
|
||||
MAKE_ARRAY_TYPE(INT16, Int16)
|
||||
MAKE_ARRAY_TYPE(UINT16, UInt16)
|
||||
MAKE_ARRAY_TYPE(INT32, Int32)
|
||||
MAKE_ARRAY_TYPE(UINT32, UInt32)
|
||||
MAKE_ARRAY_TYPE(INT64, Int64)
|
||||
MAKE_ARRAY_TYPE(UINT64, UInt64)
|
||||
MAKE_ARRAY_TYPE(FLOAT, Single)
|
||||
MAKE_ARRAY_TYPE(DOUBLE, Double)
|
||||
MAKE_ARRAY_TYPE(WCHAR, Char16)
|
||||
//MAKE_ARRAY_TYPE(boolean, Boolean) //conflict with identical type in C++ of BYTE/UInt8
|
||||
MAKE_ARRAY_TYPE(HSTRING, String)
|
||||
MAKE_ARRAY_TYPE(IInspectable*, Inspectable)
|
||||
MAKE_ARRAY_TYPE(GUID, Guid)
|
||||
MAKE_ARRAY_TYPE(ABI::Windows::Foundation::DateTime, DateTime)
|
||||
MAKE_ARRAY_TYPE(ABI::Windows::Foundation::TimeSpan, TimeSpan)
|
||||
MAKE_ARRAY_TYPE(ABI::Windows::Foundation::Point, Point)
|
||||
MAKE_ARRAY_TYPE(ABI::Windows::Foundation::Size, Size)
|
||||
MAKE_ARRAY_TYPE(ABI::Windows::Foundation::Rect, Rect)
|
||||
|
||||
template < typename T >
|
||||
struct DerefHelper
|
||||
{
|
||||
typedef T DerefType;
|
||||
};
|
||||
|
||||
template < typename T >
|
||||
struct DerefHelper<T*>
|
||||
{
|
||||
typedef T DerefType;
|
||||
};
|
||||
|
||||
#define __is_valid_winrt_type(_Type) (std::is_void<_Type>::value || \
|
||||
std::is_same<_Type, BYTE>::value || \
|
||||
std::is_same<_Type, INT16>::value || \
|
||||
std::is_same<_Type, UINT16>::value || \
|
||||
std::is_same<_Type, INT32>::value || \
|
||||
std::is_same<_Type, UINT32>::value || \
|
||||
std::is_same<_Type, INT64>::value || \
|
||||
std::is_same<_Type, UINT64>::value || \
|
||||
std::is_same<_Type, FLOAT>::value || \
|
||||
std::is_same<_Type, DOUBLE>::value || \
|
||||
std::is_same<_Type, WCHAR>::value || \
|
||||
std::is_same<_Type, boolean>::value || \
|
||||
std::is_same<_Type, HSTRING>::value || \
|
||||
std::is_same<_Type, IInspectable *>::value || \
|
||||
std::is_base_of<Microsoft::WRL::Details::RuntimeClassBase, _Type>::value || \
|
||||
std::is_base_of<IInspectable, typename DerefHelper<_Type>::DerefType>::value || \
|
||||
std::is_same<_Type, GUID>::value || \
|
||||
std::is_same<_Type, ABI::Windows::Foundation::DateTime>::value || \
|
||||
std::is_same<_Type, ABI::Windows::Foundation::TimeSpan>::value || \
|
||||
std::is_same<_Type, ABI::Windows::Foundation::Point>::value || \
|
||||
std::is_same<_Type, ABI::Windows::Foundation::Size>::value || \
|
||||
std::is_same<_Type, ABI::Windows::Foundation::Rect>::value || \
|
||||
std::is_same<_Type, BYTE*>::value || \
|
||||
std::is_same<_Type, INT16*>::value || \
|
||||
std::is_same<_Type, UINT16*>::value || \
|
||||
std::is_same<_Type, INT32*>::value || \
|
||||
std::is_same<_Type, UINT32*>::value || \
|
||||
std::is_same<_Type, INT64*>::value || \
|
||||
std::is_same<_Type, UINT64*>::value || \
|
||||
std::is_same<_Type, FLOAT*>::value || \
|
||||
std::is_same<_Type, DOUBLE*>::value || \
|
||||
std::is_same<_Type, WCHAR*>::value || \
|
||||
std::is_same<_Type, boolean*>::value || \
|
||||
std::is_same<_Type, HSTRING*>::value || \
|
||||
std::is_same<_Type, IInspectable **>::value || \
|
||||
std::is_same<_Type, GUID*>::value || \
|
||||
std::is_same<_Type, ABI::Windows::Foundation::DateTime*>::value || \
|
||||
std::is_same<_Type, ABI::Windows::Foundation::TimeSpan*>::value || \
|
||||
std::is_same<_Type, ABI::Windows::Foundation::Point*>::value || \
|
||||
std::is_same<_Type, ABI::Windows::Foundation::Size*>::value || \
|
||||
std::is_same<_Type, ABI::Windows::Foundation::Rect*>::value)
|
||||
#include "wrl.h"
|
||||
#endif
|
||||
#else
|
||||
EXTERN_C const IID IID_ICustomStreamSink;
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
565
modules/videoio/src/wrl.h
Normal file
565
modules/videoio/src/wrl.h
Normal file
@ -0,0 +1,565 @@
|
||||
#pragma once
|
||||
|
||||
#include <winstring.h>
|
||||
#include <stdio.h>
|
||||
#include <tchar.h>
|
||||
#include <crtdbg.h>
|
||||
#include <array>
|
||||
#include <vector>
|
||||
|
||||
#include <wrl\implements.h>
|
||||
#include <wrl\event.h>
|
||||
#include <inspectable.h>
|
||||
#ifndef __cplusplus_winrt
|
||||
#include <windows.foundation.h>
|
||||
|
||||
__declspec(noreturn) void __stdcall __abi_WinRTraiseException(long);
|
||||
|
||||
inline void __abi_ThrowIfFailed(long __hrArg)
|
||||
{
|
||||
if (__hrArg < 0)
|
||||
{
|
||||
__abi_WinRTraiseException(__hrArg);
|
||||
}
|
||||
}
|
||||
|
||||
struct Guid
|
||||
{
|
||||
public:
|
||||
Guid();
|
||||
Guid(__rcGUID_t);
|
||||
operator ::__rcGUID_t();
|
||||
bool Equals(Guid __guidArg);
|
||||
bool Equals(__rcGUID_t __guidArg);
|
||||
Guid(unsigned int __aArg, unsigned short __bArg, unsigned short __cArg, unsigned __int8 __dArg,
|
||||
unsigned __int8 __eArg, unsigned __int8 __fArg, unsigned __int8 __gArg, unsigned __int8 __hArg,
|
||||
unsigned __int8 __iArg, unsigned __int8 __jArg, unsigned __int8 __kArg);
|
||||
Guid(unsigned int __aArg, unsigned short __bArg, unsigned short __cArg, const unsigned __int8* __dArg);
|
||||
private:
|
||||
unsigned long __a;
|
||||
unsigned short __b;
|
||||
unsigned short __c;
|
||||
unsigned char __d;
|
||||
unsigned char __e;
|
||||
unsigned char __f;
|
||||
unsigned char __g;
|
||||
unsigned char __h;
|
||||
unsigned char __i;
|
||||
unsigned char __j;
|
||||
unsigned char __k;
|
||||
};
|
||||
|
||||
static_assert(sizeof(Guid) == sizeof(::_GUID), "Incorect size for Guid");
|
||||
static_assert(sizeof(__rcGUID_t) == sizeof(::_GUID), "Incorect size for __rcGUID_t");
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
inline Guid::Guid() : __a(0), __b(0), __c(0), __d(0), __e(0), __f(0), __g(0), __h(0), __i(0), __j(0), __k(0)
|
||||
{
|
||||
}
|
||||
|
||||
inline Guid::Guid(__rcGUID_t __guid) :
|
||||
__a(reinterpret_cast<const __s_GUID&>(__guid).Data1),
|
||||
__b(reinterpret_cast<const __s_GUID&>(__guid).Data2),
|
||||
__c(reinterpret_cast<const __s_GUID&>(__guid).Data3),
|
||||
__d(reinterpret_cast<const __s_GUID&>(__guid).Data4[0]),
|
||||
__e(reinterpret_cast<const __s_GUID&>(__guid).Data4[1]),
|
||||
__f(reinterpret_cast<const __s_GUID&>(__guid).Data4[2]),
|
||||
__g(reinterpret_cast<const __s_GUID&>(__guid).Data4[3]),
|
||||
__h(reinterpret_cast<const __s_GUID&>(__guid).Data4[4]),
|
||||
__i(reinterpret_cast<const __s_GUID&>(__guid).Data4[5]),
|
||||
__j(reinterpret_cast<const __s_GUID&>(__guid).Data4[6]),
|
||||
__k(reinterpret_cast<const __s_GUID&>(__guid).Data4[7])
|
||||
{
|
||||
}
|
||||
|
||||
inline Guid::operator ::__rcGUID_t()
|
||||
{
|
||||
return reinterpret_cast<__rcGUID_t>(*this);
|
||||
}
|
||||
|
||||
inline bool Guid::Equals(Guid __guidArg)
|
||||
{
|
||||
return *this == __guidArg;
|
||||
}
|
||||
|
||||
inline bool Guid::Equals(__rcGUID_t __guidArg)
|
||||
{
|
||||
return *this == static_cast< Guid>(__guidArg);
|
||||
}
|
||||
|
||||
inline bool operator==(Guid __aArg, Guid __bArg)
|
||||
{
|
||||
auto __a = reinterpret_cast<unsigned long*>(&__aArg);
|
||||
auto __b = reinterpret_cast<unsigned long*>(&__bArg);
|
||||
|
||||
return (__a[0] == __b[0] && __a[1] == __b[1] && __a[2] == __b[2] && __a[3] == __b[3]);
|
||||
}
|
||||
|
||||
inline bool operator!=(Guid __aArg, Guid __bArg)
|
||||
{
|
||||
return !(__aArg == __bArg);
|
||||
}
|
||||
|
||||
inline bool operator<(Guid __aArg, Guid __bArg)
|
||||
{
|
||||
auto __a = reinterpret_cast<unsigned long*>(&__aArg);
|
||||
auto __b = reinterpret_cast<unsigned long*>(&__bArg);
|
||||
|
||||
if (__a[0] != __b[0])
|
||||
{
|
||||
return __a[0] < __b[0];
|
||||
}
|
||||
|
||||
if (__a[1] != __b[1])
|
||||
{
|
||||
return __a[1] < __b[1];
|
||||
}
|
||||
|
||||
if (__a[2] != __b[2])
|
||||
{
|
||||
return __a[2] < __b[2];
|
||||
}
|
||||
|
||||
if (__a[3] != __b[3])
|
||||
{
|
||||
return __a[3] < __b[3];
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
inline Guid::Guid(unsigned int __aArg, unsigned short __bArg, unsigned short __cArg, unsigned __int8 __dArg,
|
||||
unsigned __int8 __eArg, unsigned __int8 __fArg, unsigned __int8 __gArg, unsigned __int8 __hArg,
|
||||
unsigned __int8 __iArg, unsigned __int8 __jArg, unsigned __int8 __kArg) :
|
||||
__a(__aArg), __b(__bArg), __c(__cArg), __d(__dArg), __e(__eArg), __f(__fArg), __g(__gArg), __h(__hArg), __i(__iArg), __j(__jArg), __k(__kArg)
|
||||
{
|
||||
}
|
||||
|
||||
inline Guid::Guid(unsigned int __aArg, unsigned short __bArg, unsigned short __cArg, const unsigned __int8 __dArg[8]) :
|
||||
__a(__aArg), __b(__bArg), __c(__cArg)
|
||||
{
|
||||
__d = __dArg[0];
|
||||
__e = __dArg[1];
|
||||
__f = __dArg[2];
|
||||
__g = __dArg[3];
|
||||
__h = __dArg[4];
|
||||
__i = __dArg[5];
|
||||
__j = __dArg[6];
|
||||
__k = __dArg[7];
|
||||
}
|
||||
|
||||
__declspec(selectany) Guid __winrt_GUID_NULL(0x00000000, 0x0000, 0x0000, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00);
|
||||
|
||||
//
|
||||
//// Don't want to define the real IUnknown from unknown.h here. That would means if the user has
|
||||
//// any broken code that uses it, compile errors will take the form of e.g.:
|
||||
//// predefined C++ WinRT types (compiler internal)(41) : see declaration of 'IUnknown::QueryInterface'
|
||||
//// This is not helpful. If they use IUnknown, we still need to point them to the actual unknown.h so
|
||||
//// that they can see the original definition.
|
||||
////
|
||||
//// For WinRT, we'll instead have a parallel COM interface hierarchy for basic interfaces starting with _.
|
||||
//// The type mismatch is not an issue. COM passes types through GUID / void* combos - the original type
|
||||
//// doesn't come into play unless the user static_casts an implementation type to one of these, but
|
||||
//// the WinRT implementation types are hidden.
|
||||
__interface __declspec(uuid("00000000-0000-0000-C000-000000000046")) __abi_IUnknown
|
||||
{
|
||||
public:
|
||||
virtual long __stdcall __abi_QueryInterface(Guid&, void**) = 0;
|
||||
virtual unsigned long __stdcall __abi_AddRef() = 0;
|
||||
virtual unsigned long __stdcall __abi_Release() = 0;
|
||||
};
|
||||
|
||||
__declspec(dllexport) __declspec(noreturn) void __stdcall __abi_WinRTraiseNotImplementedException();
|
||||
__declspec(dllexport) __declspec(noreturn) void __stdcall __abi_WinRTraiseInvalidCastException();
|
||||
__declspec(dllexport) __declspec(noreturn) void __stdcall __abi_WinRTraiseNullReferenceException();
|
||||
__declspec(dllexport) __declspec(noreturn) void __stdcall __abi_WinRTraiseOperationCanceledException();
|
||||
__declspec(dllexport) __declspec(noreturn) void __stdcall __abi_WinRTraiseFailureException();
|
||||
__declspec(dllexport) __declspec(noreturn) void __stdcall __abi_WinRTraiseAccessDeniedException();
|
||||
__declspec(dllexport) __declspec(noreturn) void __stdcall __abi_WinRTraiseOutOfMemoryException();
|
||||
__declspec(dllexport) __declspec(noreturn) void __stdcall __abi_WinRTraiseInvalidArgumentException();
|
||||
__declspec(dllexport) __declspec(noreturn) void __stdcall __abi_WinRTraiseOutOfBoundsException();
|
||||
__declspec(dllexport) __declspec(noreturn) void __stdcall __abi_WinRTraiseChangedStateException();
|
||||
__declspec(dllexport) __declspec(noreturn) void __stdcall __abi_WinRTraiseClassNotRegisteredException();
|
||||
__declspec(dllexport) __declspec(noreturn) void __stdcall __abi_WinRTraiseWrongThreadException();
|
||||
__declspec(dllexport) __declspec(noreturn) void __stdcall __abi_WinRTraiseDisconnectedException();
|
||||
__declspec(dllexport) __declspec(noreturn) void __stdcall __abi_WinRTraiseObjectDisposedException();
|
||||
__declspec(dllexport) __declspec(noreturn) void __stdcall __abi_WinRTraiseCOMException(long);
|
||||
|
||||
__declspec(noreturn) inline void __stdcall __abi_WinRTraiseException(long __hrArg)
|
||||
{
|
||||
switch (__hrArg)
|
||||
{
|
||||
case 0x80004001L: // E_NOTIMPL
|
||||
__abi_WinRTraiseNotImplementedException();
|
||||
|
||||
case 0x80004002L: // E_NOINTERFACE
|
||||
__abi_WinRTraiseInvalidCastException();
|
||||
|
||||
case 0x80004003L: // E_POINTER
|
||||
__abi_WinRTraiseNullReferenceException();
|
||||
|
||||
case 0x80004004L: // E_ABORT
|
||||
__abi_WinRTraiseOperationCanceledException();
|
||||
|
||||
case 0x80004005L: // E_FAIL
|
||||
__abi_WinRTraiseFailureException();
|
||||
|
||||
case 0x80070005L: // E_ACCESSDENIED
|
||||
__abi_WinRTraiseAccessDeniedException();
|
||||
|
||||
case 0x8007000EL: // E_OUTOFMEMORY
|
||||
__abi_WinRTraiseOutOfMemoryException();
|
||||
|
||||
case 0x80070057L: // E_INVALIDARG
|
||||
__abi_WinRTraiseInvalidArgumentException();
|
||||
|
||||
case 0x8000000BL: // E_BOUNDS
|
||||
__abi_WinRTraiseOutOfBoundsException();
|
||||
|
||||
case 0x8000000CL: // E_CHANGED_STATE
|
||||
__abi_WinRTraiseChangedStateException();
|
||||
|
||||
case 0x80040154L: // REGDB_E_CLASSNOTREG
|
||||
__abi_WinRTraiseClassNotRegisteredException();
|
||||
|
||||
case 0x8001010EL: // RPC_E_WRONG_THREAD
|
||||
__abi_WinRTraiseWrongThreadException();
|
||||
|
||||
case 0x80010108L: // RPC_E_DISCONNECTED
|
||||
__abi_WinRTraiseDisconnectedException();
|
||||
|
||||
case 0x80000013L: // RO_E_CLOSED
|
||||
__abi_WinRTraiseObjectDisposedException();
|
||||
|
||||
default:
|
||||
__abi_WinRTraiseCOMException(__hrArg);
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
struct __abi_CaptureBase
|
||||
{
|
||||
protected:
|
||||
virtual __stdcall ~__abi_CaptureBase() {}
|
||||
|
||||
public:
|
||||
static const size_t __smallCaptureSize = 4 * sizeof(void*);
|
||||
void* operator new(size_t __sizeArg, void* __pSmallCaptureArg)
|
||||
{
|
||||
if (__sizeArg > __smallCaptureSize)
|
||||
{
|
||||
return reinterpret_cast<__abi_CaptureBase*>(HeapAlloc(GetProcessHeap(), 0, __sizeArg));
|
||||
}
|
||||
|
||||
return __pSmallCaptureArg;
|
||||
}
|
||||
|
||||
void operator delete(void* __ptrArg, void* __pSmallCaptureArg)
|
||||
{
|
||||
__abi_CaptureBase* __pThis = static_cast<__abi_CaptureBase*>(__ptrArg);
|
||||
__pThis->Delete(__pThis, __pSmallCaptureArg);
|
||||
}
|
||||
|
||||
inline void* GetVFunction(int __slotArg)
|
||||
{
|
||||
return (*reinterpret_cast<void***>(this))[__slotArg];
|
||||
}
|
||||
|
||||
void Delete(__abi_CaptureBase* __pThisArg, void* __pSmallCaptureArg)
|
||||
{
|
||||
__pThisArg->~__abi_CaptureBase();
|
||||
if (__pThisArg != __pSmallCaptureArg)
|
||||
{
|
||||
HeapFree(GetProcessHeap(), 0, __pThisArg);
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
struct __abi_CapturePtr
|
||||
{
|
||||
char* smallCapture[__abi_CaptureBase::__smallCaptureSize];
|
||||
__abi_CaptureBase* ptr;
|
||||
__abi_CapturePtr() : ptr(reinterpret_cast<__abi_CaptureBase*>(smallCapture)) {}
|
||||
~__abi_CapturePtr()
|
||||
{
|
||||
ptr->Delete(ptr, smallCapture);
|
||||
}
|
||||
};
|
||||
|
||||
template <typename __TFunctor, typename __TReturnType>
|
||||
struct __abi_FunctorCapture0 : public __abi_CaptureBase
|
||||
{
|
||||
__TFunctor functor;
|
||||
__abi_FunctorCapture0(__TFunctor __functor) : functor(__functor) {}
|
||||
virtual __TReturnType __stdcall Invoke() { return functor(); }
|
||||
};
|
||||
template <typename __TFunctor, typename __TReturnType, typename __TArg0>
|
||||
struct __abi_FunctorCapture1 : public __abi_CaptureBase
|
||||
{
|
||||
__TFunctor functor;
|
||||
__abi_FunctorCapture1(__TFunctor __functor) : functor(__functor) {}
|
||||
virtual __TReturnType __stdcall Invoke(__TArg0 __arg0) { return functor(__arg0); }
|
||||
};
|
||||
template <typename __TFunctor, typename __TReturnType, typename __TArg0, typename __TArg1>
|
||||
struct __abi_FunctorCapture2 : public __abi_CaptureBase
|
||||
{
|
||||
__TFunctor functor;
|
||||
__abi_FunctorCapture2(__TFunctor __functor) : functor(__functor) {}
|
||||
virtual __TReturnType __stdcall Invoke(__TArg0 __arg0, __TArg1 __arg1) { return functor(__arg0, __arg1); }
|
||||
};
|
||||
template <typename __TFunctor, typename __TReturnType, typename __TArg0, typename __TArg1, typename __TArg2>
|
||||
struct __abi_FunctorCapture3 : public __abi_CaptureBase
|
||||
{
|
||||
__TFunctor functor;
|
||||
__abi_FunctorCapture3(__TFunctor __functor) : functor(__functor) {}
|
||||
virtual __TReturnType __stdcall Invoke(__TArg0 __arg0, __TArg1 __arg1, __TArg2 __arg2) { return functor(__arg0, __arg1, __arg2); }
|
||||
};
|
||||
template <typename __TFunctor, typename __TReturnType, typename __TArg0, typename __TArg1, typename __TArg2, typename __TArg3>
|
||||
struct __abi_FunctorCapture4 : public __abi_CaptureBase
|
||||
{
|
||||
__TFunctor functor;
|
||||
__abi_FunctorCapture4(__TFunctor __functor) : functor(__functor) {}
|
||||
virtual __TReturnType __stdcall Invoke(__TArg0 __arg0, __TArg1 __arg1, __TArg2 __arg2, __TArg3 __arg3) { return functor(__arg0, __arg1, __arg2, __arg3); }
|
||||
};
|
||||
template <typename __TFunctor, typename __TReturnType, typename __TArg0, typename __TArg1, typename __TArg2, typename __TArg3, typename __TArg4>
|
||||
struct __abi_FunctorCapture5 : public __abi_CaptureBase
|
||||
{
|
||||
__TFunctor functor;
|
||||
__abi_FunctorCapture5(__TFunctor __functor) : functor(__functor) {}
|
||||
virtual __TReturnType __stdcall Invoke(__TArg0 __arg0, __TArg1 __arg1, __TArg2 __arg2, __TArg3 __arg3, __TArg4 __arg4) { return functor(__arg0, __arg1, __arg2, __arg3, __arg4); }
|
||||
};
|
||||
template <typename __TFunctor, typename __TReturnType, typename __TArg0, typename __TArg1, typename __TArg2, typename __TArg3, typename __TArg4, typename __TArg5>
|
||||
struct __abi_FunctorCapture6 : public __abi_CaptureBase
|
||||
{
|
||||
__TFunctor functor;
|
||||
__abi_FunctorCapture6(__TFunctor __functor) : functor(__functor) {}
|
||||
virtual __TReturnType __stdcall Invoke(__TArg0 __arg0, __TArg1 __arg1, __TArg2 __arg2, __TArg3 __arg3, __TArg4 __arg4, __TArg5 __arg5) { return functor(__arg0, __arg1, __arg2, __arg3, __arg4, __arg5); }
|
||||
};
|
||||
template <typename __TFunctor, typename __TReturnType, typename __TArg0, typename __TArg1, typename __TArg2, typename __TArg3, typename __TArg4, typename __TArg5, typename __TArg6>
|
||||
struct __abi_FunctorCapture7 : public __abi_CaptureBase
|
||||
{
|
||||
__TFunctor functor;
|
||||
__abi_FunctorCapture7(__TFunctor __functor) : functor(__functor) {}
|
||||
virtual __TReturnType __stdcall Invoke(__TArg0 __arg0, __TArg1 __arg1, __TArg2 __arg2, __TArg3 __arg3, __TArg4 __arg4, __TArg5 __arg5, __TArg6 __arg6) { return functor(__arg0, __arg1, __arg2, __arg3, __arg4, __arg5, __arg6); }
|
||||
};
|
||||
template <typename __TFunctor, typename __TReturnType, typename __TArg0, typename __TArg1, typename __TArg2, typename __TArg3, typename __TArg4, typename __TArg5, typename __TArg6, typename __TArg7>
|
||||
struct __abi_FunctorCapture8 : public __abi_CaptureBase
|
||||
{
|
||||
__TFunctor functor;
|
||||
__abi_FunctorCapture8(__TFunctor __functor) : functor(__functor) {}
|
||||
virtual __TReturnType __stdcall Invoke(__TArg0 __arg0, __TArg1 __arg1, __TArg2 __arg2, __TArg3 __arg3, __TArg4 __arg4, __TArg5 __arg5, __TArg6 __arg6, __TArg7 __arg7) { return functor(__arg0, __arg1, __arg2, __arg3, __arg4, __arg5, __arg6, __arg7); }
|
||||
};
|
||||
template <typename __TFunctor, typename __TReturnType, typename __TArg0, typename __TArg1, typename __TArg2, typename __TArg3, typename __TArg4, typename __TArg5, typename __TArg6, typename __TArg7, typename __TArg8>
|
||||
struct __abi_FunctorCapture9 : public __abi_CaptureBase
|
||||
{
|
||||
__TFunctor functor;
|
||||
__abi_FunctorCapture9(__TFunctor __functor) : functor(__functor) {}
|
||||
virtual __TReturnType __stdcall Invoke(__TArg0 __arg0, __TArg1 __arg1, __TArg2 __arg2, __TArg3 __arg3, __TArg4 __arg4, __TArg5 __arg5, __TArg6 __arg6, __TArg7 __arg7, __TArg8 __arg8) { return functor(__arg0, __arg1, __arg2, __arg3, __arg4, __arg5, __arg6, __arg7, __arg8); }
|
||||
};
|
||||
template <typename __TFunctor, typename __TReturnType, typename __TArg0, typename __TArg1, typename __TArg2, typename __TArg3, typename __TArg4, typename __TArg5, typename __TArg6, typename __TArg7, typename __TArg8, typename __TArg9>
|
||||
struct __abi_FunctorCapture10 : public __abi_CaptureBase
|
||||
{
|
||||
__TFunctor functor;
|
||||
__abi_FunctorCapture10(__TFunctor __functor) : functor(__functor) {}
|
||||
virtual __TReturnType __stdcall Invoke(__TArg0 __arg0, __TArg1 __arg1, __TArg2 __arg2, __TArg3 __arg3, __TArg4 __arg4, __TArg5 __arg5, __TArg6 __arg6, __TArg7 __arg7, __TArg8 __arg8, __TArg9 __arg9) { return functor(__arg0, __arg1, __arg2, __arg3, __arg4, __arg5, __arg6, __arg7, __arg8, __arg9); }
|
||||
};
|
||||
|
||||
#define __is_winrt_array(type) (type == ABI::Windows::Foundation::PropertyType::PropertyType_UInt8Array || type == ABI::Windows::Foundation::PropertyType::PropertyType_Int16Array ||\
|
||||
type == ABI::Windows::Foundation::PropertyType::PropertyType_UInt16Array || type == ABI::Windows::Foundation::PropertyType::PropertyType_Int32Array ||\
|
||||
type == ABI::Windows::Foundation::PropertyType::PropertyType_UInt32Array || type == ABI::Windows::Foundation::PropertyType::PropertyType_Int64Array ||\
|
||||
type == ABI::Windows::Foundation::PropertyType::PropertyType_UInt64Array || type == ABI::Windows::Foundation::PropertyType::PropertyType_SingleArray ||\
|
||||
type == ABI::Windows::Foundation::PropertyType::PropertyType_DoubleArray || type == ABI::Windows::Foundation::PropertyType::PropertyType_Char16Array ||\
|
||||
type == ABI::Windows::Foundation::PropertyType::PropertyType_BooleanArray || type == ABI::Windows::Foundation::PropertyType::PropertyType_StringArray ||\
|
||||
type == ABI::Windows::Foundation::PropertyType::PropertyType_InspectableArray || type == ABI::Windows::Foundation::PropertyType::PropertyType_DateTimeArray ||\
|
||||
type == ABI::Windows::Foundation::PropertyType::PropertyType_TimeSpanArray || type == ABI::Windows::Foundation::PropertyType::PropertyType_GuidArray ||\
|
||||
type == ABI::Windows::Foundation::PropertyType::PropertyType_PointArray || type == ABI::Windows::Foundation::PropertyType::PropertyType_SizeArray ||\
|
||||
type == ABI::Windows::Foundation::PropertyType::PropertyType_RectArray || type == ABI::Windows::Foundation::PropertyType::PropertyType_OtherTypeArray)
|
||||
|
||||
template<typename _Type, bool bUnknown = std::is_base_of<IUnknown, _Type>::value>
|
||||
struct winrt_type
|
||||
{
|
||||
};
|
||||
template<typename _Type>
|
||||
struct winrt_type<_Type, true>
|
||||
{
|
||||
static IUnknown* create(_Type* _ObjInCtx) {
|
||||
return reinterpret_cast<IUnknown*>(_ObjInCtx);
|
||||
}
|
||||
static IID getuuid() { return __uuidof(_Type); }
|
||||
static const ABI::Windows::Foundation::PropertyType _PropType = ABI::Windows::Foundation::PropertyType::PropertyType_OtherType;
|
||||
};
|
||||
template <typename _Type>
|
||||
struct winrt_type<_Type, false>
|
||||
{
|
||||
static IUnknown* create(_Type* _ObjInCtx) {
|
||||
Microsoft::WRL::ComPtr<IInspectable> _PObj;
|
||||
Microsoft::WRL::ComPtr<IActivationFactory> objFactory;
|
||||
HRESULT hr = Windows::Foundation::GetActivationFactory(Microsoft::WRL::Wrappers::HStringReference(RuntimeClass_Windows_Foundation_PropertyValue).Get(), objFactory.ReleaseAndGetAddressOf());
|
||||
if (FAILED(hr)) return nullptr;
|
||||
Microsoft::WRL::ComPtr<ABI::Windows::Foundation::IPropertyValueStatics> spPropVal;
|
||||
if (SUCCEEDED(hr))
|
||||
hr = objFactory.As(&spPropVal);
|
||||
if (SUCCEEDED(hr)) {
|
||||
hr = winrt_type<_Type>::create(spPropVal.Get(), _ObjInCtx, _PObj.GetAddressOf());
|
||||
if (SUCCEEDED(hr))
|
||||
return reinterpret_cast<IUnknown*>(_PObj.Detach());
|
||||
}
|
||||
return nullptr;
|
||||
}
|
||||
static IID getuuid() { return __uuidof(ABI::Windows::Foundation::IPropertyValue); }
|
||||
static const ABI::Windows::Foundation::PropertyType _PropType = ABI::Windows::Foundation::PropertyType::PropertyType_OtherType;
|
||||
};
|
||||
|
||||
template<>
|
||||
struct winrt_type<void>
|
||||
{
|
||||
static HRESULT create(ABI::Windows::Foundation::IPropertyValueStatics* spPropVal, void* _ObjInCtx, IInspectable** ppInsp) {
|
||||
(void)_ObjInCtx;
|
||||
return spPropVal->CreateEmpty(ppInsp);
|
||||
}
|
||||
static const ABI::Windows::Foundation::PropertyType _PropType = ABI::Windows::Foundation::PropertyType::PropertyType_Empty;
|
||||
};
|
||||
#define MAKE_TYPE(Type, Name) template<>\
|
||||
struct winrt_type<Type>\
|
||||
{\
|
||||
static HRESULT create(ABI::Windows::Foundation::IPropertyValueStatics* spPropVal, Type* _ObjInCtx, IInspectable** ppInsp) {\
|
||||
return spPropVal->Create##Name(*_ObjInCtx, ppInsp);\
|
||||
}\
|
||||
static const ABI::Windows::Foundation::PropertyType _PropType = ABI::Windows::Foundation::PropertyType::PropertyType_##Name;\
|
||||
};
|
||||
|
||||
template<typename _Type>
|
||||
struct winrt_array_type
|
||||
{
|
||||
static IUnknown* create(_Type* _ObjInCtx, size_t N) {
|
||||
Microsoft::WRL::ComPtr<IInspectable> _PObj;
|
||||
Microsoft::WRL::ComPtr<IActivationFactory> objFactory;
|
||||
HRESULT hr = Windows::Foundation::GetActivationFactory(Microsoft::WRL::Wrappers::HStringReference(RuntimeClass_Windows_Foundation_PropertyValue).Get(), objFactory.ReleaseAndGetAddressOf());
|
||||
if (FAILED(hr)) return nullptr;
|
||||
Microsoft::WRL::ComPtr<ABI::Windows::Foundation::IPropertyValueStatics> spPropVal;
|
||||
if (SUCCEEDED(hr))
|
||||
hr = objFactory.As(&spPropVal);
|
||||
if (SUCCEEDED(hr)) {
|
||||
hr = winrt_array_type<_Type>::create(spPropVal.Get(), N, _ObjInCtx, _PObj.GetAddressOf());
|
||||
if (SUCCEEDED(hr))
|
||||
return reinterpret_cast<IUnknown*>(_PObj.Detach());
|
||||
}
|
||||
return nullptr;
|
||||
}
|
||||
static const ABI::Windows::Foundation::PropertyType _PropType = ABI::Windows::Foundation::PropertyType::PropertyType_OtherTypeArray;
|
||||
};
|
||||
template<int>
|
||||
struct winrt_prop_type {};
|
||||
|
||||
template <>
|
||||
struct winrt_prop_type<ABI::Windows::Foundation::PropertyType_Empty> {
|
||||
typedef void _Type;
|
||||
};
|
||||
|
||||
template <>
|
||||
struct winrt_prop_type<ABI::Windows::Foundation::PropertyType_OtherType> {
|
||||
typedef void _Type;
|
||||
};
|
||||
|
||||
template <>
|
||||
struct winrt_prop_type<ABI::Windows::Foundation::PropertyType_OtherTypeArray> {
|
||||
typedef void _Type;
|
||||
};
|
||||
|
||||
#define MAKE_PROP(Prop, Type) template <>\
|
||||
struct winrt_prop_type<ABI::Windows::Foundation::PropertyType_##Prop> {\
|
||||
typedef Type _Type;\
|
||||
};
|
||||
|
||||
#define MAKE_ARRAY_TYPE(Type, Name) MAKE_PROP(Name, Type)\
|
||||
MAKE_PROP(Name##Array, Type*)\
|
||||
MAKE_TYPE(Type, Name)\
|
||||
template<>\
|
||||
struct winrt_array_type<Type*>\
|
||||
{\
|
||||
static HRESULT create(ABI::Windows::Foundation::IPropertyValueStatics* spPropVal, UINT32 __valueSize, Type** _ObjInCtx, IInspectable** ppInsp) {\
|
||||
return spPropVal->Create##Name##Array(__valueSize, *_ObjInCtx, ppInsp);\
|
||||
}\
|
||||
static const ABI::Windows::Foundation::PropertyType _PropType = ABI::Windows::Foundation::PropertyType::PropertyType_##Name##Array;\
|
||||
static std::vector<Type> PropertyValueToVector(ABI::Windows::Foundation::IPropertyValue* propValue)\
|
||||
{\
|
||||
UINT32 uLen = 0;\
|
||||
Type* pArray = nullptr;\
|
||||
propValue->Get##Name##Array(&uLen, &pArray);\
|
||||
return std::vector<Type>(pArray, pArray + uLen);\
|
||||
}\
|
||||
};
|
||||
MAKE_ARRAY_TYPE(BYTE, UInt8)
|
||||
MAKE_ARRAY_TYPE(INT16, Int16)
|
||||
MAKE_ARRAY_TYPE(UINT16, UInt16)
|
||||
MAKE_ARRAY_TYPE(INT32, Int32)
|
||||
MAKE_ARRAY_TYPE(UINT32, UInt32)
|
||||
MAKE_ARRAY_TYPE(INT64, Int64)
|
||||
MAKE_ARRAY_TYPE(UINT64, UInt64)
|
||||
MAKE_ARRAY_TYPE(FLOAT, Single)
|
||||
MAKE_ARRAY_TYPE(DOUBLE, Double)
|
||||
MAKE_ARRAY_TYPE(WCHAR, Char16)
|
||||
//MAKE_ARRAY_TYPE(boolean, Boolean) //conflict with identical type in C++ of BYTE/UInt8
|
||||
MAKE_ARRAY_TYPE(HSTRING, String)
|
||||
MAKE_ARRAY_TYPE(IInspectable*, Inspectable)
|
||||
MAKE_ARRAY_TYPE(GUID, Guid)
|
||||
MAKE_ARRAY_TYPE(ABI::Windows::Foundation::DateTime, DateTime)
|
||||
MAKE_ARRAY_TYPE(ABI::Windows::Foundation::TimeSpan, TimeSpan)
|
||||
MAKE_ARRAY_TYPE(ABI::Windows::Foundation::Point, Point)
|
||||
MAKE_ARRAY_TYPE(ABI::Windows::Foundation::Size, Size)
|
||||
MAKE_ARRAY_TYPE(ABI::Windows::Foundation::Rect, Rect)
|
||||
|
||||
template < typename T >
|
||||
struct DerefHelper
|
||||
{
|
||||
typedef T DerefType;
|
||||
};
|
||||
|
||||
template < typename T >
|
||||
struct DerefHelper<T*>
|
||||
{
|
||||
typedef T DerefType;
|
||||
};
|
||||
|
||||
#define __is_valid_winrt_type(_Type) (std::is_void<_Type>::value || \
|
||||
std::is_same<_Type, BYTE>::value || \
|
||||
std::is_same<_Type, INT16>::value || \
|
||||
std::is_same<_Type, UINT16>::value || \
|
||||
std::is_same<_Type, INT32>::value || \
|
||||
std::is_same<_Type, UINT32>::value || \
|
||||
std::is_same<_Type, INT64>::value || \
|
||||
std::is_same<_Type, UINT64>::value || \
|
||||
std::is_same<_Type, FLOAT>::value || \
|
||||
std::is_same<_Type, DOUBLE>::value || \
|
||||
std::is_same<_Type, WCHAR>::value || \
|
||||
std::is_same<_Type, boolean>::value || \
|
||||
std::is_same<_Type, HSTRING>::value || \
|
||||
std::is_same<_Type, IInspectable *>::value || \
|
||||
std::is_base_of<Microsoft::WRL::Details::RuntimeClassBase, _Type>::value || \
|
||||
std::is_base_of<IInspectable, typename DerefHelper<_Type>::DerefType>::value || \
|
||||
std::is_same<_Type, GUID>::value || \
|
||||
std::is_same<_Type, ABI::Windows::Foundation::DateTime>::value || \
|
||||
std::is_same<_Type, ABI::Windows::Foundation::TimeSpan>::value || \
|
||||
std::is_same<_Type, ABI::Windows::Foundation::Point>::value || \
|
||||
std::is_same<_Type, ABI::Windows::Foundation::Size>::value || \
|
||||
std::is_same<_Type, ABI::Windows::Foundation::Rect>::value || \
|
||||
std::is_same<_Type, BYTE*>::value || \
|
||||
std::is_same<_Type, INT16*>::value || \
|
||||
std::is_same<_Type, UINT16*>::value || \
|
||||
std::is_same<_Type, INT32*>::value || \
|
||||
std::is_same<_Type, UINT32*>::value || \
|
||||
std::is_same<_Type, INT64*>::value || \
|
||||
std::is_same<_Type, UINT64*>::value || \
|
||||
std::is_same<_Type, FLOAT*>::value || \
|
||||
std::is_same<_Type, DOUBLE*>::value || \
|
||||
std::is_same<_Type, WCHAR*>::value || \
|
||||
std::is_same<_Type, boolean*>::value || \
|
||||
std::is_same<_Type, HSTRING*>::value || \
|
||||
std::is_same<_Type, IInspectable **>::value || \
|
||||
std::is_same<_Type, GUID*>::value || \
|
||||
std::is_same<_Type, ABI::Windows::Foundation::DateTime*>::value || \
|
||||
std::is_same<_Type, ABI::Windows::Foundation::TimeSpan*>::value || \
|
||||
std::is_same<_Type, ABI::Windows::Foundation::Point*>::value || \
|
||||
std::is_same<_Type, ABI::Windows::Foundation::Size*>::value || \
|
||||
std::is_same<_Type, ABI::Windows::Foundation::Rect*>::value)
|
||||
#endif
|
||||
Loading…
Reference in New Issue
Block a user