From 82b4c317fb571405b05d5f3de7a9940d4d3112ac Mon Sep 17 00:00:00 2001 From: errollw Date: Tue, 11 Mar 2014 12:47:50 +0000 Subject: [PATCH] New MS Surface Pro 2 project Extra project needed with more advanced camera utils to get high-def images. --- EyeTab_SP2/EyeTab_SP2.cpp | 608 +++++ EyeTab_SP2/GetGUID.h | 4397 +++++++++++++++++++++++++++++++++++ EyeTab_SP2/ReadMe.txt | 40 + EyeTab_SP2/comet/array.h | 150 ++ EyeTab_SP2/comet/assert.h | 68 + EyeTab_SP2/comet/atl_module.h | 121 + EyeTab_SP2/comet/auto_buffer.h | 99 + EyeTab_SP2/comet/bstr.h | 948 ++++++++ EyeTab_SP2/comet/calllog.h | 628 +++++ EyeTab_SP2/comet/cmd_line_parser.h | 101 + EyeTab_SP2/comet/comet.h | 776 +++++++ EyeTab_SP2/comet/common.h | 316 +++ EyeTab_SP2/comet/config.h | 243 ++ EyeTab_SP2/comet/cp.h | 436 ++++ EyeTab_SP2/comet/cptraits.h | 118 + EyeTab_SP2/comet/currency.h | 474 ++++ EyeTab_SP2/comet/date.h | 396 ++++ EyeTab_SP2/comet/datetime.h | 1943 ++++++++++++++++ EyeTab_SP2/comet/dispatch.h | 675 ++++++ EyeTab_SP2/comet/enum.h | 29 + EyeTab_SP2/comet/enum_common.h | 187 ++ EyeTab_SP2/comet/enum_iterator.h | 179 ++ EyeTab_SP2/comet/error.h | 429 ++++ EyeTab_SP2/comet/error_fwd.h | 119 + EyeTab_SP2/comet/exe_server.h | 292 +++ EyeTab_SP2/comet/functor.h | 1341 +++++++++++ EyeTab_SP2/comet/git.h | 95 + EyeTab_SP2/comet/handle.h | 363 +++ EyeTab_SP2/comet/handle_except.h | 363 +++ EyeTab_SP2/comet/impqi.h | 546 +++++ EyeTab_SP2/comet/interface.h | 256 ++ EyeTab_SP2/comet/invariant_lock.h | 126 + EyeTab_SP2/comet/lw_lock.h | 228 ++ EyeTab_SP2/comet/module.h | 274 +++ EyeTab_SP2/comet/oleidl_comtypes.h | 72 + EyeTab_SP2/comet/ptr.h | 1261 ++++++++++ EyeTab_SP2/comet/reference_count.h | 100 + EyeTab_SP2/comet/registry.h | 1302 +++++++++++ EyeTab_SP2/comet/regkey.h | 65 + EyeTab_SP2/comet/safearray.h | 1498 ++++++++++++ EyeTab_SP2/comet/scope_guard.h | 363 +++ EyeTab_SP2/comet/server.h | 1588 +++++++++++++ EyeTab_SP2/comet/smart_enum.h | 139 ++ EyeTab_SP2/comet/static_assert.h | 54 + EyeTab_SP2/comet/stl.h | 69 + EyeTab_SP2/comet/stl_enum.h | 188 ++ EyeTab_SP2/comet/stream.h | 1566 +++++++++++++ EyeTab_SP2/comet/threading.h | 228 ++ EyeTab_SP2/comet/tlbinfo.h | 451 ++++ EyeTab_SP2/comet/tstring.h | 124 + EyeTab_SP2/comet/type_traits.h | 262 +++ EyeTab_SP2/comet/typelist.h | 450 ++++ EyeTab_SP2/comet/unittest.h | 86 + EyeTab_SP2/comet/util.h | 125 + EyeTab_SP2/comet/uuid.h | 88 + EyeTab_SP2/comet/uuid_fwd.h | 441 ++++ EyeTab_SP2/comet/variant.h | 1054 +++++++++ EyeTab_SP2/comet/variant_iterator.h | 149 ++ EyeTab_SP2/comet_task_ptr.h | 78 + EyeTab_SP2/format.cc | 733 ++++++ EyeTab_SP2/format.h | 1500 ++++++++++++ 61 files changed, 31398 insertions(+) create mode 100644 EyeTab_SP2/EyeTab_SP2.cpp create mode 100644 EyeTab_SP2/GetGUID.h create mode 100644 EyeTab_SP2/ReadMe.txt create mode 100644 EyeTab_SP2/comet/array.h create mode 100644 EyeTab_SP2/comet/assert.h create mode 100644 EyeTab_SP2/comet/atl_module.h create mode 100644 EyeTab_SP2/comet/auto_buffer.h create mode 100644 EyeTab_SP2/comet/bstr.h create mode 100644 EyeTab_SP2/comet/calllog.h create mode 100644 EyeTab_SP2/comet/cmd_line_parser.h create mode 100644 EyeTab_SP2/comet/comet.h create mode 100644 EyeTab_SP2/comet/common.h create mode 100644 EyeTab_SP2/comet/config.h create mode 100644 EyeTab_SP2/comet/cp.h create mode 100644 EyeTab_SP2/comet/cptraits.h create mode 100644 EyeTab_SP2/comet/currency.h create mode 100644 EyeTab_SP2/comet/date.h create mode 100644 EyeTab_SP2/comet/datetime.h create mode 100644 EyeTab_SP2/comet/dispatch.h create mode 100644 EyeTab_SP2/comet/enum.h create mode 100644 EyeTab_SP2/comet/enum_common.h create mode 100644 EyeTab_SP2/comet/enum_iterator.h create mode 100644 EyeTab_SP2/comet/error.h create mode 100644 EyeTab_SP2/comet/error_fwd.h create mode 100644 EyeTab_SP2/comet/exe_server.h create mode 100644 EyeTab_SP2/comet/functor.h create mode 100644 EyeTab_SP2/comet/git.h create mode 100644 EyeTab_SP2/comet/handle.h create mode 100644 EyeTab_SP2/comet/handle_except.h create mode 100644 EyeTab_SP2/comet/impqi.h create mode 100644 EyeTab_SP2/comet/interface.h create mode 100644 EyeTab_SP2/comet/invariant_lock.h create mode 100644 EyeTab_SP2/comet/lw_lock.h create mode 100644 EyeTab_SP2/comet/module.h create mode 100644 EyeTab_SP2/comet/oleidl_comtypes.h create mode 100644 EyeTab_SP2/comet/ptr.h create mode 100644 EyeTab_SP2/comet/reference_count.h create mode 100644 EyeTab_SP2/comet/registry.h create mode 100644 EyeTab_SP2/comet/regkey.h create mode 100644 EyeTab_SP2/comet/safearray.h create mode 100644 EyeTab_SP2/comet/scope_guard.h create mode 100644 EyeTab_SP2/comet/server.h create mode 100644 EyeTab_SP2/comet/smart_enum.h create mode 100644 EyeTab_SP2/comet/static_assert.h create mode 100644 EyeTab_SP2/comet/stl.h create mode 100644 EyeTab_SP2/comet/stl_enum.h create mode 100644 EyeTab_SP2/comet/stream.h create mode 100644 EyeTab_SP2/comet/threading.h create mode 100644 EyeTab_SP2/comet/tlbinfo.h create mode 100644 EyeTab_SP2/comet/tstring.h create mode 100644 EyeTab_SP2/comet/type_traits.h create mode 100644 EyeTab_SP2/comet/typelist.h create mode 100644 EyeTab_SP2/comet/unittest.h create mode 100644 EyeTab_SP2/comet/util.h create mode 100644 EyeTab_SP2/comet/uuid.h create mode 100644 EyeTab_SP2/comet/uuid_fwd.h create mode 100644 EyeTab_SP2/comet/variant.h create mode 100644 EyeTab_SP2/comet/variant_iterator.h create mode 100644 EyeTab_SP2/comet_task_ptr.h create mode 100644 EyeTab_SP2/format.cc create mode 100644 EyeTab_SP2/format.h diff --git a/EyeTab_SP2/EyeTab_SP2.cpp b/EyeTab_SP2/EyeTab_SP2.cpp new file mode 100644 index 0000000..dd69b3f --- /dev/null +++ b/EyeTab_SP2/EyeTab_SP2.cpp @@ -0,0 +1,608 @@ +#include "stdafx.h" + +#include + +#include +#include +#include +#include +#include + +#include +#include +#include +#include + +#include +#include + +#include + +#include "GetGUID.h" + +namespace comet { + +#define MAKE_COMET_COMTYPE(T, BASE) \ + template<> struct comtype< ::T > \ + { \ + static const IID& uuid() { return IID_ ## T; } \ + typedef ::BASE base; \ + } + + MAKE_COMET_COMTYPE(IMF2DBuffer, IUnknown); + MAKE_COMET_COMTYPE(IAMVideoProcAmp, IUnknown); + MAKE_COMET_COMTYPE(IAMCameraControl, IUnknown); +} + +namespace comet { + template + class com_ptr_array { + public: + com_ptr_array() : _ptr(nullptr), _count(0) {} + ~com_ptr_array() { + clear(); + } + + + TInf** in() { + return _ptr.in(); + } + + TInf*** inout() { + return _ptr.inout(); + } + + TInf*** out() { + clear(); + return _ptr.out(); + } + + TCount count() { + return _count; + } + + TCount* inout_count() { + return &_count; + } + + TCount* out_count() { + clear(); + return &_count; + } + + com_ptr operator[](size_t i) { + return com_ptr(_ptr[i]); + } + + + + private: + void clear() { + if (_ptr) { + for (DWORD i = 0; i < _count; i++) { + _ptr[i]->Release(); + } + _count = 0; + _ptr.free(); + } + } + + task_ptr _ptr; + TCount _count; + }; +} + +namespace comet +{ + struct auto_mf + { + auto_mf(DWORD dwFlags = MFSTARTUP_FULL) + { + MFStartup(MF_VERSION) | comet::raise_exception; + } + ~auto_mf() + { + MFShutdown(); + } + }; +} + + + +float OffsetToFloat(const MFOffset& offset) +{ + return offset.value + (static_cast(offset.fract) / 65536.0f); +} + +void PrintAttributes( comet::com_ptr attr ) +{ + UINT32 count = 0; + attr->GetCount(&count) | comet::raise_exception; + if (count == 0) { + std::cout << "Empty media type." << std::endl; + } + + for (UINT32 j = 0; j < count; j++) { + GUID guid; + PROPVARIANT var; + PropVariantInit(&var); + attr->GetItemByIndex(j, &guid, &var); + + std::cout << GetGUIDName(guid) << " : "; + + if ((guid == MF_MT_FRAME_SIZE) || (guid == MF_MT_PIXEL_ASPECT_RATIO)) + { + UINT32 uHigh = 0, uLow = 0; + Unpack2UINT32AsUINT64(var.uhVal.QuadPart, &uHigh, &uLow); + std::cout << uHigh << " x " << uLow; + } + else if ((guid == MF_MT_FRAME_RATE) || (guid == MF_MT_FRAME_RATE_RANGE_MAX) || + (guid == MF_MT_FRAME_RATE_RANGE_MIN)) + { + UINT32 uHigh = 0, uLow = 0; + Unpack2UINT32AsUINT64(var.uhVal.QuadPart, &uHigh, &uLow); + std::cout << ((double)uHigh)/uLow; + } + else if ((guid == MF_MT_GEOMETRIC_APERTURE) || + (guid == MF_MT_MINIMUM_DISPLAY_APERTURE) || + (guid == MF_MT_PAN_SCAN_APERTURE)) + { + MFVideoArea *pArea = reinterpret_cast(var.caub.pElems); + std::cout << "(" << OffsetToFloat(pArea->OffsetX) << ", " << OffsetToFloat(pArea->OffsetY) << ") "; + std::cout << "(" << pArea->Area.cx << ", " << pArea->Area.cy << ")"; + } + else { + switch (var.vt) + { + case VT_UI4: + std::cout << var.ulVal; + break; + case VT_UI8: + std::cout << var.uhVal.QuadPart; + break; + case VT_R8: + std::cout << var.dblVal; + break; + case VT_CLSID: + std::cout << GetGUIDName(*var.puuid); + break; + case VT_LPWSTR: + std::cout << comet::bstr_t(var.pwszVal).s_str(); + break; + case VT_VECTOR | VT_UI1: + std::cout << "<>"; + break; + case VT_UNKNOWN: + std::cout << "IUnknown"; + break; + default: + std::cout << "Unexpected attribute type (vt = " << var.vt << ")"; + break; + } + } + PropVariantClear(&var); + std::cout << std::endl; + } +} + + +struct cam_prop_range +{ + long min; + long max; + long step; + long defaultValue; + long flags; +}; +std::ostream& operator<<(std::ostream& os, const cam_prop_range& val) { + os << "[" << val.min << ":" << val.step << ":" << val.max << "], " << val.defaultValue << ", " << val.flags; + return os; +} + +struct cam_prop_value +{ + long value; + bool isAuto; + + cam_prop_value() : value(0), isAuto(true) { + } + cam_prop_value(long value) : value(value), isAuto(false) { + } + operator long() const { + return value; + } +}; +std::ostream& operator<<(std::ostream& os, const cam_prop_value& val) { + os << val.value; + os << " ("; + if (val.isAuto) + os << "auto"; + else + os << "manual"; + os << ")"; + return os; +} + +class media_type +{ +public: + media_type() : _ptr(NULL) { + } + media_type(IMFMediaType* ptr) : _ptr(ptr) { + } + media_type(comet::com_ptr ptr) : _ptr(ptr) { + } + + cv::Size resolution() const + { + UINT32 width, height; + MFGetAttributeSize(_ptr.in(), MF_MT_FRAME_SIZE, &width, &height) | comet::raise_exception; + return cv::Size(width, height); + } + double framerate() const + { + UINT32 num, denom; + MFGetAttributeRatio(_ptr.in(), MF_MT_FRAME_RATE, &num, &denom) | comet::raise_exception; + return static_cast(num)/denom; + } + GUID subtype() const + { + GUID subtype; + _ptr->GetGUID(MF_MT_SUBTYPE, &subtype) | comet::raise_exception; + return subtype; + } + + typedef media_type _Myt; + _TYPEDEF_BOOL_TYPE; + _OPERATOR_BOOL() const _NOEXCEPT + { // test for non-null pointer + return (_ptr != 0 ? _CONVERTIBLE_TO_TRUE : 0); + } + + comet::com_ptr _ptr; +}; + + +class camera { +public: + camera(IMFActivate* ptr) : activate_ptr(ptr) { + } + camera(comet::com_ptr ptr) : activate_ptr(ptr) { + } + + bool is_active() const { + return !source_ptr.is_null(); + } + void activate() { + activate_ptr->ActivateObject(IID_IMFMediaSource, reinterpret_cast(source_ptr.out())); + reader_ptr = NULL; + } + void shutdown() { + activate_ptr->ShutdownObject(); + source_ptr = NULL; + reader_ptr = NULL; + } + + cv::Mat read_frame(int streamIndex = MF_SOURCE_READER_FIRST_VIDEO_STREAM, int bufferIndex = 0) + { + if (!reader_ptr) { + comet::com_ptr pAttributes; + MFCreateAttributes(pAttributes.out(), 1) | comet::raise_exception; + pAttributes->SetUINT32(MF_SOURCE_READER_ENABLE_VIDEO_PROCESSING, TRUE) | comet::raise_exception; + + MFCreateSourceReaderFromMediaSource(source_ptr.in(), pAttributes.in(), reader_ptr.out()) | comet::raise_exception; + } + + comet::com_ptr sample; + DWORD actualStreamIndex, flags; + LONGLONG timestamp; + do { + reader_ptr->ReadSample( + streamIndex, // Stream index. + 0, // Flags. + &actualStreamIndex, // Receives the actual stream index. + &flags, // Receives status flags. + ×tamp, // Receives the time stamp. + sample.out() // Receives the sample or NULL. + ) | comet::raise_exception; + } while (sample == NULL && (flags & MF_SOURCE_READERF_STREAMTICK)); + + media_type cur_media_type; + reader_ptr->GetCurrentMediaType(actualStreamIndex, cur_media_type._ptr.out()); + + cv::Mat ret(cur_media_type.resolution(), CV_8UC3); + + DWORD bufCount; + sample->GetBufferCount(&bufCount) | comet::raise_exception; + + DWORD bufIndex = bufferIndex >= 0 ? bufferIndex : bufCount - bufferIndex; + + if (bufCount > bufIndex) { + comet::com_ptr buffer; + sample->GetBufferByIndex(bufferIndex, buffer.out()) | comet::raise_exception; + + comet::com_ptr buf2d = try_cast(buffer); + + DWORD pcbLength; + buf2d->GetContiguousLength(&pcbLength) | comet::raise_exception; + + COMET_ASSERT(ret.dataend - ret.datastart == pcbLength); + + struct buf_lock + { + comet::com_ptr& buf2d; + buf_lock(comet::com_ptr& buf2d, BYTE*& scanline0, LONG& pitch) : buf2d(buf2d) { + buf2d->Lock2D(&scanline0, &pitch) | comet::raise_exception; + } + ~buf_lock() { + buf2d->Unlock2D() | comet::raise_exception; + } + }; + + BYTE *scanline0; + LONG pitch; + buf_lock buf_lock_token(buf2d, scanline0, pitch); + + buf2d->ContiguousCopyTo(ret.data, DWORD(ret.dataend - ret.datastart)) | comet::raise_exception; + } + + return ret; + } + + std::string name() const { + return get_attr_str(MF_DEVSOURCE_ATTRIBUTE_FRIENDLY_NAME); + } + std::string symlink() const { + return get_attr_str(MF_DEVSOURCE_ATTRIBUTE_SOURCE_TYPE_VIDCAP_SYMBOLIC_LINK); + } + +#define MAKE_CAMERA_PROPERTY(NAME, INTERFACE, PROPGUID) \ + bool has_ ## NAME() const \ + { \ + comet::com_ptr pInterface = comet::com_cast(source_ptr); \ + if (!pInterface) return false; \ + long value, flags; \ + HRESULT hr = pInterface->Get(INTERFACE ## _ ## PROPGUID, &value, &flags); \ + return SUCCEEDED(hr); \ + } \ + cam_prop_range get_ ## NAME ## _range() const \ + { \ + comet::com_ptr pInterface = comet::try_cast(source_ptr); \ + cam_prop_range range; \ + pInterface->GetRange(INTERFACE ## _ ## PROPGUID, &range.min, &range.max, &range.step, &range.defaultValue, &range.flags) | comet::raise_exception; \ + return range; \ + } \ + cam_prop_value get_ ## NAME() const \ + { \ + comet::com_ptr pInterface = comet::try_cast(source_ptr); \ + cam_prop_value value; \ + long flags; \ + pInterface->Get(INTERFACE ## _ ## PROPGUID, &value.value, &flags) | comet::raise_exception; \ + value.isAuto = (flags & INTERFACE ## _Flags_Auto) != 0 || (flags & INTERFACE ## _Flags_Manual) == 0; \ + return value; \ + } \ + void set_ ## NAME(const cam_prop_value& value) const \ + { \ + comet::com_ptr pInterface = comet::try_cast(source_ptr); \ + long flags = value.isAuto ? INTERFACE ## _Flags_Auto : INTERFACE ## _Flags_Manual; \ + pInterface->Set(INTERFACE ## _ ## PROPGUID, value.value, flags) | comet::raise_exception; \ + } + + MAKE_CAMERA_PROPERTY(exposure, CameraControl, Exposure) + MAKE_CAMERA_PROPERTY(focus, CameraControl, Focus) + MAKE_CAMERA_PROPERTY(zoom, CameraControl, Zoom) + MAKE_CAMERA_PROPERTY(pan, CameraControl, Pan) + MAKE_CAMERA_PROPERTY(tilt, CameraControl, Tilt) + MAKE_CAMERA_PROPERTY(roll, CameraControl, Roll) + MAKE_CAMERA_PROPERTY(iris, CameraControl, Iris) + + MAKE_CAMERA_PROPERTY(brightness, VideoProcAmp, Brightness) + MAKE_CAMERA_PROPERTY(contrast, VideoProcAmp, Contrast) + MAKE_CAMERA_PROPERTY(hue, VideoProcAmp, Hue) + MAKE_CAMERA_PROPERTY(saturation, VideoProcAmp, Saturation) + MAKE_CAMERA_PROPERTY(sharpness, VideoProcAmp, Sharpness) + MAKE_CAMERA_PROPERTY(gamma, VideoProcAmp, Gamma) + MAKE_CAMERA_PROPERTY(color_enable, VideoProcAmp, ColorEnable) + MAKE_CAMERA_PROPERTY(white_balance, VideoProcAmp, WhiteBalance) + MAKE_CAMERA_PROPERTY(backlight_compensation, VideoProcAmp, BacklightCompensation) + MAKE_CAMERA_PROPERTY(gain, VideoProcAmp, Gain) + + std::vector media_types(int streamIndex = 0) const { + auto pHandler = getMediaTypeHandler(streamIndex); + + DWORD cTypes = 0; + pHandler->GetMediaTypeCount(&cTypes) | comet::raise_exception; + + std::vector ret; + for (DWORD i = 0; i < cTypes; i++) { + comet::com_ptr pType; + pHandler->GetMediaTypeByIndex(i, pType.out()) | comet::raise_exception; + ret.emplace_back(pType); + } + + return ret; + } + media_type get_media_type(int streamIndex = 0) { + media_type ret; + getMediaTypeHandler(streamIndex)->GetCurrentMediaType(ret._ptr.out()); + return ret; + } + void set_media_type(const media_type& type, int streamIndex = 0) { + getMediaTypeHandler(streamIndex)->SetCurrentMediaType(type._ptr.in()); + } + +private: + std::string get_attr_str(REFGUID guid) const { + comet::task_ptr pStr; + UINT32 strLen; + activate_ptr->GetAllocatedString(guid, pStr.out(), &strLen) | comet::raise_exception; + return comet::bstr_t(pStr.in(), strLen).s_str(); + } + + comet::com_ptr getMediaTypeHandler(int streamIndex = 0) const + { + comet::com_ptr pPD; + source_ptr->CreatePresentationDescriptor(pPD.out()) | comet::raise_exception; + + BOOL fSelected; + comet::com_ptr pSD; + pPD->GetStreamDescriptorByIndex(streamIndex, &fSelected, pSD.out()) | comet::raise_exception; + + comet::com_ptr pHandler; + pSD->GetMediaTypeHandler(pHandler.out()) | comet::raise_exception; + + return pHandler; + } + + comet::com_ptr activate_ptr; + comet::com_ptr source_ptr; + comet::com_ptr reader_ptr; +}; + +class camera_helper +{ +public: + static std::vector get_all_cameras() + { + comet::com_ptr config; + MFCreateAttributes(config.out(), 1) | comet::raise_exception; + + config->SetGUID(MF_DEVSOURCE_ATTRIBUTE_SOURCE_TYPE, MF_DEVSOURCE_ATTRIBUTE_SOURCE_TYPE_VIDCAP_GUID) | comet::raise_exception; + + comet::com_ptr_array com_ptr_array; + MFEnumDeviceSources(config.in(), com_ptr_array.out(), com_ptr_array.out_count()) | comet::raise_exception; + + std::vector ret; + for (size_t i = 0; i < com_ptr_array.count(); ++i) { + ret.emplace_back(com_ptr_array[i]); + } + return ret; + } + static camera get_camera_by_symlink(const std::string& symlink) + { + // This is how you should do it, but for some reason it gives an activate pointer with no friendly name + +// comet::com_ptr config; +// MFCreateAttributes(config.out(), 1) | comet::raise_exception; +// +// config->SetGUID(MF_DEVSOURCE_ATTRIBUTE_SOURCE_TYPE, MF_DEVSOURCE_ATTRIBUTE_SOURCE_TYPE_VIDCAP_GUID) | comet::raise_exception; +// comet::bstr_t symlink_bstr(symlink); +// config->SetString(MF_DEVSOURCE_ATTRIBUTE_SOURCE_TYPE_VIDCAP_SYMBOLIC_LINK, symlink_bstr.c_str()) | comet::raise_exception; +// +// comet::com_ptr activate_ptr; +// MFCreateDeviceSourceActivate(config.in(), activate_ptr.out()) | comet::raise_exception; +// +// return camera(activate_ptr); + + for(auto&& camera : get_all_cameras()) + { + if (camera.symlink() == symlink) + return camera; + } + std::stringstream ss; + ss << "No camera with symlink: " << symlink; + throw std::runtime_error(ss.str()); + } +}; + + +int _tmain(int argc, _TCHAR* argv[]) +{ + comet::auto_coinit auto_coinit(COINIT_MULTITHREADED); + comet::auto_mf auto_mf; + + //camera cam = camera_helper::get_camera_by_symlink("\\\\?\\usb#vid_046d&pid_082d&mi_00#7&f415157&0&0000#{e5323777-f976-4f5b-9b55-b94699c46e44}\\{bbefb6c7-2fc4-4139-bb8b-a58bba724083}"); + for (auto&& cam : camera_helper::get_all_cameras()) + { + std::cout << cam.name() << std::endl; + std::cout << cam.symlink() << std::endl; + + cam.activate(); + +#define MAP_OVER_PROPERTIES(FUNC) \ + FUNC(exposure) \ + FUNC(focus) \ + FUNC(zoom) \ + FUNC(pan) \ + FUNC(tilt) \ + FUNC(roll) \ + FUNC(iris) \ + FUNC(brightness) \ + FUNC(contrast) \ + FUNC(hue) \ + FUNC(saturation) \ + FUNC(sharpness) \ + FUNC(gamma) \ + FUNC(color_enable) \ + FUNC(white_balance) \ + FUNC(backlight_compensation) \ + FUNC(gain) + +#define INIT_PROPERTY(PROPERTY) \ + bool has_ ## PROPERTY = cam.has_ ## PROPERTY(); \ + cam_prop_range PROPERTY ## _range; \ + if (has_ ## PROPERTY) { \ + PROPERTY ## _range = cam.get_ ## PROPERTY ## _range(); \ + std::cout << #PROPERTY " range: " << PROPERTY ## _range << std::endl; \ + } + + MAP_OVER_PROPERTIES(INIT_PROPERTY) + + media_type bestType; + + for (auto&& media_type : cam.media_types()) { + if (media_type.subtype() == MFVideoFormat_RGB24) { + double framerate = media_type.framerate(); + cv::Size resolution = media_type.resolution(); + + std::cout << resolution << " " << framerate << std::endl; + + if (!bestType || + ( + (framerate > bestType.framerate())|| + (framerate == bestType.framerate() && resolution.area() > bestType.resolution().area()) + ) && resolution.height < 800 + ) { + bestType = media_type; + } + } + } + + cam.set_media_type(bestType); + PrintAttributes(cam.get_media_type()._ptr); + + cv::namedWindow("m"); + +#define INIT_PROPERTYSLIDER(PROPERTY) \ + int PROPERTY ## _slider; \ + if (has_ ## PROPERTY) { \ + cv::createTrackbar(#PROPERTY, "m", &PROPERTY ## _slider, (PROPERTY ## _range.max - PROPERTY ## _range.min) / PROPERTY ## _range.step); \ + PROPERTY ## _slider = (PROPERTY ## _range.defaultValue - PROPERTY ## _range.min) / PROPERTY ## _range.step; \ + cv::setTrackbarPos(#PROPERTY, "m", PROPERTY ## _slider); \ + } + + MAP_OVER_PROPERTIES(INIT_PROPERTYSLIDER) + + while(true) { + #define USE_PROPERTYSLIDER(PROPERTY) \ + try { \ + if (has_ ## PROPERTY) { \ + cam.set_ ## PROPERTY(PROPERTY ## _slider * PROPERTY ## _range.step + PROPERTY ## _range.min); \ + } \ + } catch (comet::com_error& e) { \ + std::cerr << "Error setting " #PROPERTY ": " << e.what() << std::endl; \ + } + + MAP_OVER_PROPERTIES(USE_PROPERTYSLIDER) + + cv::Mat m = cam.read_frame(); + cv::imshow("m", m); + if (cv::waitKey(1) != -1){ + break; + } + } + } + + return 0; +} + diff --git a/EyeTab_SP2/GetGUID.h b/EyeTab_SP2/GetGUID.h new file mode 100644 index 0000000..465ad81 --- /dev/null +++ b/EyeTab_SP2/GetGUID.h @@ -0,0 +1,4397 @@ +#pragma once + +#include +#include +#include + +#include +#include + +#define IF_GUID_EQUAL_RETURN(guid, l, w1, w2, b1, b2, b3, b4, b5, b6, b7, b8, name) \ + if (guid.Data1 == (l) && \ + guid.Data2 == (w1) && guid.Data3 == (w2) && \ + guid.Data4[0] == (b1) && guid.Data4[1] == (b2) && guid.Data4[2] == (b3) && guid.Data4[3] == (b4) && \ + guid.Data4[4] == (b5) && guid.Data4[5] == (b6) && guid.Data4[6] == (b7) && guid.Data4[7] == (b8) \ + ) { if (!ret.empty()) ret += "/" name; else ret = name; } + +std::string GetGUIDNameConst(const GUID& guid) { + std::string ret; + IF_GUID_EQUAL_RETURN(guid,0x68A1E95E,0x13EA,0x41E1,0x80,0x11,0x0C,0x49,0x6C,0xA4,0x90,0xB0,"ALL_POWERSCHEMES_GUID"); + IF_GUID_EQUAL_RETURN(guid,0x9b00f101,0x1567,0x11d1,0xb3,0xf1,0x0,0xaa,0x0,0x37,0x61,0xc5,"AMPROPSETID_Pin"); + IF_GUID_EQUAL_RETURN(guid,0x1A8766A0L,0x62CE,0x11CF,0xA5,0xD6,0x28,0xDB,0x04,0xC1,0x00,0x00,"AM_INTERFACESETID_Standard"); + IF_GUID_EQUAL_RETURN(guid,0x6994AD04L,0x93EF,0x11D0,0xA3,0xCC,0x00,0xA0,0xC9,0x22,0x31,0x96,"AM_KSCATEGORY_AUDIO"); + IF_GUID_EQUAL_RETURN(guid,0x65E8773DL,0x8F56,0x11D0,0xA3,0xB9,0x00,0xA0,0xC9,0x22,0x31,0x96,"AM_KSCATEGORY_CAPTURE"); + IF_GUID_EQUAL_RETURN(guid,0xa799a801L,0xa46d,0x11d0,0xa1,0x8c,0x00,0xa0,0x24,0x01,0xdc,0xd4,"AM_KSCATEGORY_CROSSBAR"); + IF_GUID_EQUAL_RETURN(guid,0x1E84C900L,0x7E70,0x11D0,0xA5,0xD6,0x28,0xDB,0x04,0xC1,0x00,0x00,"AM_KSCATEGORY_DATACOMPRESSOR"); + IF_GUID_EQUAL_RETURN(guid,0x65E8773EL,0x8F56,0x11D0,0xA3,0xB9,0x00,0xA0,0xC9,0x22,0x31,0x96,"AM_KSCATEGORY_RENDER"); + IF_GUID_EQUAL_RETURN(guid,0x0A4252A0L,0x7E70,0x11D0,0xA5,0xD6,0x28,0xDB,0x04,0xC1,0x00,0x00,"AM_KSCATEGORY_SPLITTER"); + IF_GUID_EQUAL_RETURN(guid,0xa799a802L,0xa46d,0x11d0,0xa1,0x8c,0x00,0xa0,0x24,0x01,0xdc,0xd4,"AM_KSCATEGORY_TVAUDIO"); + IF_GUID_EQUAL_RETURN(guid,0xa799a800L,0xa46d,0x11d0,0xa1,0x8c,0x00,0xa0,0x24,0x01,0xdc,0xd4,"AM_KSCATEGORY_TVTUNER"); + IF_GUID_EQUAL_RETURN(guid,0x07dad660L,0x22f1,0x11d1,0xa9,0xf4,0x00,0xc0,0x4f,0xbb,0xde,0x8f,"AM_KSCATEGORY_VBICODEC"); + IF_GUID_EQUAL_RETURN(guid,0x9c24a977,0x951,0x451a,0x80,0x6,0xe,0x49,0xbd,0x28,0xcd,0x5f,"AM_KSCATEGORY_VBICODEC_MI"); + IF_GUID_EQUAL_RETURN(guid,0x6994AD05L,0x93EF,0x11D0,0xA3,0xCC,0x00,0xA0,0xC9,0x22,0x31,0x96,"AM_KSCATEGORY_VIDEO"); + IF_GUID_EQUAL_RETURN(guid,0xBFABE720,0x6E1F,0x11D0,0xBC,0xF2,0x44,0x45,0x53,0x54,0x00,0x00,"AM_KSPROPSETID_AC3"); + IF_GUID_EQUAL_RETURN(guid,0x0E8A0A40,0x6AEF,0x11D0,0x9E,0xD0,0x00,0xA0,0x24,0xCA,0x19,0xB3,"AM_KSPROPSETID_CopyProt"); + IF_GUID_EQUAL_RETURN(guid,0x3577eb09,0x9582,0x477f,0xb2,0x9c,0xb0,0xc4,0x52,0xa4,0xff,0x9a,"AM_KSPROPSETID_DVD_RateChange"); + IF_GUID_EQUAL_RETURN(guid,0xae4720ae,0xaa71,0x42d8,0xb8,0x2a,0xff,0xfd,0xf5,0x8b,0x76,0xfd,"AM_KSPROPSETID_DvdKaraoke"); + IF_GUID_EQUAL_RETURN(guid,0xac390460,0x43af,0x11d0,0xbd,0x6a,0x00,0x35,0x05,0xc1,0x03,0xa9,"AM_KSPROPSETID_DvdSubPic"); + IF_GUID_EQUAL_RETURN(guid,0xc830acbd,0xab07,0x492f,0x88,0x52,0x45,0xb6,0x98,0x7c,0x29,0x79,"AM_KSPROPSETID_FrameStep"); + IF_GUID_EQUAL_RETURN(guid,0xff6c4bfa,0x7a9,0x4c7b,0xa2,0x37,0x67,0x2f,0x9d,0x68,0x6,0x5f,"AM_KSPROPSETID_MPEG4_MediaType_Attributes"); + IF_GUID_EQUAL_RETURN(guid,0xa503c5c0,0x1d1d,0x11d1,0xad,0x80,0x44,0x45,0x53,0x54,0x0,0x0,"AM_KSPROPSETID_TSRateChange"); + IF_GUID_EQUAL_RETURN(guid,0xe2e42ad2,0x132c,0x491e,0xa2,0x68,0x3c,0x7c,0x2d,0xca,0x18,0x1f,"AM_MEDIA_TYPE_REPRESENTATION"); + IF_GUID_EQUAL_RETURN(guid,0x514865df,0x2557,0x4cb9,0xae,0xed,0x6c,0xed,0x08,0x4c,0xe5,0x2c,"AcceleratorKey_Property_GUID"); + IF_GUID_EQUAL_RETURN(guid,0x06827b12,0xa7f9,0x4a15,0x91,0x7c,0xff,0xa5,0xad,0x3e,0xb0,0xa7,"AccessKey_Property_GUID"); + IF_GUID_EQUAL_RETURN(guid,0x20ae484f,0x69ef,0x4c48,0x8f,0x5b,0xc4,0x93,0x8b,0x20,0x6a,0xc7,"Annotation_AnnotationTypeId_Property_GUID"); + IF_GUID_EQUAL_RETURN(guid,0x9b818892,0x5ac9,0x4af9,0xaa,0x96,0xf5,0x8a,0x77,0xb0,0x58,0xe3,"Annotation_AnnotationTypeName_Property_GUID"); + IF_GUID_EQUAL_RETURN(guid,0x7a528462,0x9c5c,0x4a03,0xa9,0x74,0x8b,0x30,0x7a,0x99,0x37,0xf2,"Annotation_Author_Property_GUID"); + IF_GUID_EQUAL_RETURN(guid,0x99b5ca5d,0x1acf,0x414b,0xa4,0xd0,0x6b,0x35,0x0b,0x04,0x75,0x78,"Annotation_DateTime_Property_GUID"); + IF_GUID_EQUAL_RETURN(guid,0xf6c72ad7,0x356c,0x4850,0x92,0x91,0x31,0x6f,0x60,0x8a,0x8c,0x84,"Annotation_Pattern_GUID"); + IF_GUID_EQUAL_RETURN(guid,0xb71b302d,0x2104,0x44ad,0x9c,0x5c,0x09,0x2b,0x49,0x07,0xd7,0x0f,"Annotation_Target_Property_GUID"); + IF_GUID_EQUAL_RETURN(guid,0x4213678c,0xe025,0x4922,0xbe,0xb5,0xe4,0x3b,0xa0,0x8e,0x62,0x21,"AriaProperties_Property_GUID"); + IF_GUID_EQUAL_RETURN(guid,0xdd207b95,0xbe4a,0x4e0d,0xb7,0x27,0x63,0xac,0xe9,0x4b,0x69,0x16,"AriaRole_Property_GUID"); + IF_GUID_EQUAL_RETURN(guid,0x5fdee11c,0xd2fa,0x4fb9,0x90,0x4e,0x5c,0xbe,0xe8,0x94,0xd5,0xef,"AsyncContentLoaded_Event_GUID"); + IF_GUID_EQUAL_RETURN(guid,0xb68a1f17,0xf60d,0x41a7,0xa3,0xcc,0xb0,0x52,0x92,0x15,0x5f,0xe0,"AutomationFocusChanged_Event_GUID"); + IF_GUID_EQUAL_RETURN(guid,0xc82c0500,0xb60e,0x4310,0xa2,0x67,0x30,0x3c,0x53,0x1f,0x8e,0xe5,"AutomationId_Property_GUID"); + IF_GUID_EQUAL_RETURN(guid,0x2527fba1,0x8d7a,0x4630,0xa4,0xcc,0xe6,0x63,0x15,0x94,0x2f,0x52,"AutomationPropertyChanged_Event_GUID"); + IF_GUID_EQUAL_RETURN(guid,0xbea9ef17,0x82f1,0x4f60,0x92,0x84,0x4f,0x8d,0xb7,0x5c,0x3b,0xe9,"BHID_AssociationArray"); + IF_GUID_EQUAL_RETURN(guid,0xb8c0bd9f,0xed24,0x455c,0x83,0xe6,0xd5,0x39,0xc,0x4f,0xe8,0xc4,"BHID_DataObject"); + IF_GUID_EQUAL_RETURN(guid,0xb8ab0b9c,0xc2ec,0x4f7a,0x91,0x8d,0x31,0x49,0x00,0xe6,0x28,0x0a,"BHID_EnumAssocHandlers"); + IF_GUID_EQUAL_RETURN(guid,0x94f60519,0x2850,0x4924,0xaa,0x5a,0xd1,0x5e,0x84,0x86,0x80,0x39,"BHID_EnumItems"); + IF_GUID_EQUAL_RETURN(guid,0x38d08778,0xf557,0x4690,0x9e,0xbf,0xba,0x54,0x70,0x6a,0xd8,0xf7,"BHID_Filter"); + IF_GUID_EQUAL_RETURN(guid,0x3981e228,0xf559,0x11d3,0x8e,0x3a,0x00,0xc0,0x4f,0x68,0x37,0xd5,"BHID_LinkTargetItem"); + IF_GUID_EQUAL_RETURN(guid,0x0384e1a4,0x1523,0x439c,0xa4,0xc8,0xab,0x91,0x10,0x52,0xf5,0x86,"BHID_PropertyStore"); + IF_GUID_EQUAL_RETURN(guid,0xf16fc93b,0x77ae,0x4cfe,0xbd,0xa7,0xa8,0x66,0xee,0xa6,0x87,0x8d,"BHID_RandomAccessStream"); + IF_GUID_EQUAL_RETURN(guid,0x3981e224,0xf559,0x11d3,0x8e,0x3a,0x00,0xc0,0x4f,0x68,0x37,0xd5,"BHID_SFObject"); + IF_GUID_EQUAL_RETURN(guid,0x3981e225,0xf559,0x11d3,0x8e,0x3a,0x00,0xc0,0x4f,0x68,0x37,0xd5,"BHID_SFUIObject"); + IF_GUID_EQUAL_RETURN(guid,0x3981e226,0xf559,0x11d3,0x8e,0x3a,0x00,0xc0,0x4f,0x68,0x37,0xd5,"BHID_SFViewObject"); + IF_GUID_EQUAL_RETURN(guid,0x3981e227,0xf559,0x11d3,0x8e,0x3a,0x00,0xc0,0x4f,0x68,0x37,0xd5,"BHID_Storage"); + IF_GUID_EQUAL_RETURN(guid,0x4621a4e3,0xf0d6,0x4773,0x8a,0x9c,0x46,0xe7,0x7b,0x17,0x48,0x40,"BHID_StorageEnum"); + IF_GUID_EQUAL_RETURN(guid,0x1cebb3ab,0x7c10,0x499a,0xa4,0x17,0x92,0xca,0x16,0xc4,0xcb,0x83,"BHID_Stream"); + IF_GUID_EQUAL_RETURN(guid,0x7b2e650a,0x8e20,0x4f4a,0xb0,0x9e,0x65,0x97,0xaf,0xc7,0x2f,0xb0,"BHID_ThumbnailHandler"); + IF_GUID_EQUAL_RETURN(guid,0xd5e346a1,0xf753,0x4932,0xb4,0x3,0x45,0x74,0x80,0xe,0x24,0x98,"BHID_Transfer"); + IF_GUID_EQUAL_RETURN(guid,0x7bbfe8b2,0x3bfc,0x48dd,0xb7,0x29,0xc7,0x94,0xb8,0x46,0xe9,0xa1,"BoundingRectangle_Property_GUID"); + IF_GUID_EQUAL_RETURN(guid,0x5a78e369,0xc6a1,0x4f33,0xa9,0xd7,0x79,0xf2,0x0d,0x0c,0x78,0x8e,"Button_Control_GUID"); + IF_GUID_EQUAL_RETURN(guid,0x3ed9cb31,0xfd10,0x4ade,0xbc,0xcc,0xfb,0x91,0x5,0xd2,0xf3,0xef,"CAPTION_FORMAT_ATSC"); + IF_GUID_EQUAL_RETURN(guid,0xe9ca1ce7,0x915e,0x47be,0x9b,0xb9,0xbf,0x1d,0x8a,0x13,0xa5,0xec,"CAPTION_FORMAT_DIRECTV"); + IF_GUID_EQUAL_RETURN(guid,0x12230db4,0xff2a,0x447e,0xbb,0x88,0x68,0x41,0xc4,0x16,0xd0,0x68,"CAPTION_FORMAT_DVB"); + IF_GUID_EQUAL_RETURN(guid,0xebb1a262,0x1158,0x4b99,0xae,0x80,0x92,0xac,0x77,0x69,0x52,0xc4,"CAPTION_FORMAT_ECHOSTAR"); + IF_GUID_EQUAL_RETURN(guid,0xf0b7a1a1,0x9847,0x11cf,0x8f,0x20,0x00,0x80,0x5f,0x2c,0xd0,0x64,"CATID_ActiveScript"); + IF_GUID_EQUAL_RETURN(guid,0xaee2a92,0xbcbb,0x11d0,0x8c,0x72,0x0,0xc0,0x4f,0xc2,0xb0,0x85,"CATID_ActiveScriptAuthor"); + IF_GUID_EQUAL_RETURN(guid,0xf0b7a1a3,0x9847,0x11cf,0x8f,0x20,0x00,0x80,0x5f,0x2c,0xd0,0x64,"CATID_ActiveScriptEncode"); + IF_GUID_EQUAL_RETURN(guid,0xf0b7a1a2,0x9847,0x11cf,0x8f,0x20,0x00,0x80,0x5f,0x2c,0xd0,0x64,"CATID_ActiveScriptParse"); + IF_GUID_EQUAL_RETURN(guid,0x31caf6e4,0xd6aa,0x4090,0xa0,0x50,0xa5,0xac,0x89,0x72,0xe9,0xef,"CATID_DeleteBrowsingHistory"); + IF_GUID_EQUAL_RETURN(guid,0x965c4d51,0x8b76,0x4e57,0x80,0xb7,0x56,0x4d,0x2e,0xa4,0xb5,0x5e,"CATID_LocationFactory"); + IF_GUID_EQUAL_RETURN(guid,0x1b3ca474,0x2614,0x414b,0xb8,0x13,0x1a,0xce,0xca,0x3e,0x3d,0xd8,"CATID_LocationProvider"); + IF_GUID_EQUAL_RETURN(guid,0xe081e1d6,0x2389,0x43cb,0xb6,0x6f,0x60,0x9f,0x82,0x3d,0x9f,0x9c,"CATID_MSIME_IImePadApplet1000"); + IF_GUID_EQUAL_RETURN(guid,0xa47fb5fc,0x7d15,0x4223,0xa7,0x89,0xb7,0x81,0xbf,0x9a,0xe6,0x67,"CATID_MSIME_IImePadApplet1200"); + IF_GUID_EQUAL_RETURN(guid,0xfaae51bf,0x5e5b,0x4a1d,0x8d,0xe1,0x17,0xc1,0xd9,0xe1,0x72,0x8d,"CATID_MSIME_IImePadApplet900"); + IF_GUID_EQUAL_RETURN(guid,0x7566cad1,0x4ec9,0x4478,0x9f,0xe9,0x8e,0xd7,0x66,0x61,0x9e,0xdf,"CATID_MSIME_IImePadApplet"); + IF_GUID_EQUAL_RETURN(guid,0x4a0f8e31,0xc3ee,0x11d1,0xaf,0xef,0x0,0x80,0x5f,0xc,0x8b,0x6d,"CATID_MSIME_IImePadApplet_VER7"); + IF_GUID_EQUAL_RETURN(guid,0x56f7a792,0xfef1,0x11d3,0x84,0x63,0x0,0xc0,0x4f,0x7a,0x6,0xe5,"CATID_MSIME_IImePadApplet_VER80"); + IF_GUID_EQUAL_RETURN(guid,0x656520b0,0xbb88,0x11d4,0x84,0xc0,0x0,0xc0,0x4f,0x7a,0x6,0xe5,"CATID_MSIME_IImePadApplet_VER81"); + IF_GUID_EQUAL_RETURN(guid,0x366c292a,0xd9b3,0x4dbf,0xbb,0x70,0xe6,0x2e,0xc3,0xd0,0xbb,0xbf,"CATID_SearchableApplication"); + IF_GUID_EQUAL_RETURN(guid,0x7ed96837,0x96f0,0x4812,0xb2,0x11,0xf1,0x3c,0x24,0x11,0x7e,0xd3,"CATID_WICBitmapDecoders"); + IF_GUID_EQUAL_RETURN(guid,0xac757296,0x3522,0x4e11,0x98,0x62,0xc1,0x7b,0xe5,0xa1,0x76,0x7e,"CATID_WICBitmapEncoders"); + IF_GUID_EQUAL_RETURN(guid,0x7835eae8,0xbf14,0x49d1,0x93,0xce,0x53,0x3a,0x40,0x7b,0x22,0x48,"CATID_WICFormatConverters"); + IF_GUID_EQUAL_RETURN(guid,0x05af94d8,0x7174,0x4cd2,0xbe,0x4a,0x41,0x24,0xb8,0x0e,0xe4,0xb8,"CATID_WICMetadataReader"); + IF_GUID_EQUAL_RETURN(guid,0xabe3b9a4,0x257d,0x4b97,0xbd,0x1a,0x29,0x4a,0xf4,0x96,0x22,0x2e,"CATID_WICMetadataWriter"); + IF_GUID_EQUAL_RETURN(guid,0x2b46e70f,0xcda7,0x473e,0x89,0xf6,0xdc,0x96,0x30,0xa2,0x39,0x0b,"CATID_WICPixelFormats"); + IF_GUID_EQUAL_RETURN(guid,0xf38bc242,0xb950,0x11d1,0x89,0x18,0x00,0xc0,0x4f,0xc2,0xc8,0x36,"CGID_DocHostCommandHandler"); + IF_GUID_EQUAL_RETURN(guid,0x3050f4b6,0x98b5,0x11cf,0xbb,0x82,0x00,0xaa,0x00,0xbd,0xce,0x0b,"CGID_EditStateCommands"); + IF_GUID_EQUAL_RETURN(guid,0x5c9f0a12,0x959e,0x11d0,0xa3,0xa4,0x0,0xa0,0xc9,0x8,0x26,0x36,"CGID_MENUDESKBAR"); + IF_GUID_EQUAL_RETURN(guid,0x93a68750,0x951a,0x11d1,0x94,0x6f,0x0,0x0,0x0,0x0,0x0,0x0,"CGID_ShortCut"); + IF_GUID_EQUAL_RETURN(guid,0x6935db93,0x21e8,0x4ccc,0xbe,0xb9,0x9f,0xe3,0xc7,0x7a,0x29,0x7a,"CLSID_ACLCustomMRU"); + IF_GUID_EQUAL_RETURN(guid,0x00BB2764L,0x6A77,0x11D0,0xA5,0x35,0x00,0xC0,0x4F,0xD7,0xD0,0x62,"CLSID_ACLHistory"); + IF_GUID_EQUAL_RETURN(guid,0x6756a641L,0xde71,0x11d0,0x83,0x1b,0x0,0xaa,0x0,0x5b,0x43,0x83,"CLSID_ACLMRU"); + IF_GUID_EQUAL_RETURN(guid,0x00BB2765L,0x6A77,0x11D0,0xA5,0x35,0x00,0xC0,0x4F,0xD7,0xD0,0x62,"CLSID_ACLMulti"); + IF_GUID_EQUAL_RETURN(guid,0x03C036F1L,0xA186,0x11D0,0x82,0x4A,0x00,0xAA,0x00,0x5B,0x43,0x83,"CLSID_ACListISF"); + IF_GUID_EQUAL_RETURN(guid,0x6a08cf80,0x0e18,0x11cf,0xa2,0x4d,0x0,0x20,0xaf,0xd7,0x97,0x67,"CLSID_ACMWrapper"); + IF_GUID_EQUAL_RETURN(guid,0xf2468580,0xaf8a,0x11d0,0x82,0x12,0x00,0xc0,0x4f,0xc3,0x2c,0x45,"CLSID_AMAudioData"); + IF_GUID_EQUAL_RETURN(guid,0x8496e040,0xaf4c,0x11d0,0x82,0x12,0x00,0xc0,0x4f,0xc3,0x2c,0x45,"CLSID_AMAudioStream"); + IF_GUID_EQUAL_RETURN(guid,0x49c47ce4,0x9ba4,0x11d0,0x82,0x12,0x00,0xc0,0x4f,0xc3,0x2c,0x45,"CLSID_AMDirectDrawStream"); + IF_GUID_EQUAL_RETURN(guid,0xcf0f2f7c,0xf7bf,0x11d0,0x90,0xd,0x0,0xc0,0x4f,0xd9,0x18,0x9d,"CLSID_AMMediaTypeStream"); + IF_GUID_EQUAL_RETURN(guid,0x49c47ce5,0x9ba4,0x11d0,0x82,0x12,0x00,0xc0,0x4f,0xc3,0x2c,0x45,"CLSID_AMMultiMediaStream"); + IF_GUID_EQUAL_RETURN(guid,0xe3444d16,0x5ac4,0x4386,0x88,0xdf,0x13,0xfd,0x23,0x0e,0x1d,0xda,"CLSID_ATSCNetworkPropertyPage"); + IF_GUID_EQUAL_RETURN(guid,0x0dad2fdd,0x5fd7,0x11d3,0x8f,0x50,0x00,0xc0,0x4f,0x79,0x71,0xe2,"CLSID_ATSCNetworkProvider"); + IF_GUID_EQUAL_RETURN(guid,0xd76e2820,0x1563,0x11cf,0xac,0x98,0x0,0xaa,0x0,0x4c,0xf,0xa9,"CLSID_AVICo"); + IF_GUID_EQUAL_RETURN(guid,0xcf49d4e0,0x1115,0x11ce,0xb0,0x3a,0x0,0x20,0xaf,0xb,0xa7,0x70,"CLSID_AVIDec"); + IF_GUID_EQUAL_RETURN(guid,0xd3588ab0,0x0781,0x11ce,0xb0,0x3a,0x00,0x20,0xaf,0xb,0xa7,0x70,"CLSID_AVIDoc"); + IF_GUID_EQUAL_RETURN(guid,0xa888df60,0x1e90,0x11cf,0xac,0x98,0x0,0xaa,0x0,0x4c,0xf,0xa9,"CLSID_AVIDraw"); + IF_GUID_EQUAL_RETURN(guid,0x00020000,0,0,0xC0,0,0,0,0,0,0,0x46,"CLSID_AVIFile"); + IF_GUID_EQUAL_RETURN(guid,0x07b65360,0xc445,0x11ce,0xaf,0xde,0x00,0xaa,0x00,0x6c,0x14,0xf4,"CLSID_AVIMIDIRender"); + IF_GUID_EQUAL_RETURN(guid,0x00020009,0,0,0xC0,0,0,0,0,0,0,0x46,"CLSID_AVISimpleUnMarshal"); + IF_GUID_EQUAL_RETURN(guid,0xFC48CC30,0x4F3E,0x4fa1,0x80,0x3B,0xAD,0x0E,0x19,0x6A,0x83,0xB1,"CLSID_AccClientDocMgr"); + IF_GUID_EQUAL_RETURN(guid,0x6572EE16,0x5FE5,0x4331,0xBB,0x6D,0x76,0xA4,0x9C,0x56,0xE4,0x23,"CLSID_AccDictionary"); + IF_GUID_EQUAL_RETURN(guid,0xb5f8350b,0x0548,0x48b1,0xa6,0xee,0x88,0xbd,0x00,0xb4,0xa5,0xe7,"CLSID_AccPropServices"); + IF_GUID_EQUAL_RETURN(guid,0x6089A37E,0xEB8A,0x482D,0xBD,0x6F,0xF9,0xF4,0x69,0x04,0xD1,0x6D,"CLSID_AccServerDocMgr"); + IF_GUID_EQUAL_RETURN(guid,0x5440837F,0x4BFF,0x4AE5,0xA1,0xB1,0x77,0x22,0xEC,0xC6,0x33,0x2A,"CLSID_AccStore"); + IF_GUID_EQUAL_RETURN(guid,0x75048700L,0xEF1F,0x11D0,0x98,0x88,0x00,0x60,0x97,0xDE,0xAC,0xF9,"CLSID_ActiveDesktop"); + IF_GUID_EQUAL_RETURN(guid,0xda4e3da0,0xd07d,0x11d0,0xbd,0x50,0x0,0xa0,0xc9,0x11,0xce,0x86,"CLSID_ActiveMovieCategories"); + IF_GUID_EQUAL_RETURN(guid,0x99d54f63,0x1a69,0x41ae,0xaa,0x4d,0xc9,0x76,0xeb,0x3f,0x07,0x13,"CLSID_AllocPresenter"); + IF_GUID_EQUAL_RETURN(guid,0x4444ac9e,0x242e,0x471b,0xa3,0xc7,0x45,0xdc,0xd4,0x63,0x52,0xbc,"CLSID_AllocPresenterDDXclMode"); + IF_GUID_EQUAL_RETURN(guid,0x71f96466,0x78f3,0x11d0,0xa1,0x8c,0x0,0xa0,0xc9,0x11,0x89,0x56,"CLSID_AnalogVideoDecoderPropertyPage"); + IF_GUID_EQUAL_RETURN(guid,0xe49741e9,0x93a8,0x4ab1,0x8e,0x96,0xbf,0x44,0x82,0x28,0x2e,0x9c,"CLSID_AppearPropPage"); + IF_GUID_EQUAL_RETURN(guid,0x7C3BAF00,0x25DE,0x11D0,0xA5,0x5F,0x00,0xA0,0xC9,0x0C,0x20,0x91,"CLSID_Application"); + IF_GUID_EQUAL_RETURN(guid,0xe436ebb5,0x524f,0x11ce,0x9f,0x53,0x00,0x20,0xaf,0x0b,0xa7,0x70,"CLSID_AsyncReader"); + IF_GUID_EQUAL_RETURN(guid,0x33d9a761,0x90c8,0x11d0,0xbd,0x43,0x0,0xa0,0xc9,0x11,0xce,0x86,"CLSID_AudioCompressorCategory"); + IF_GUID_EQUAL_RETURN(guid,0x33d9a762,0x90c8,0x11d0,0xbd,0x43,0x0,0xa0,0xc9,0x11,0xce,0x86,"CLSID_AudioInputDeviceCategory"); + IF_GUID_EQUAL_RETURN(guid,0x2ca8ca52,0x3c3f,0x11d2,0xb7,0x3d,0x0,0xc0,0x4f,0xb6,0xbd,0x3d,"CLSID_AudioInputMixerProperties"); + IF_GUID_EQUAL_RETURN(guid,0x05589faf,0xc356,0x11ce,0xbf,0x01,0x0,0xaa,0x0,0x55,0x59,0x5a,"CLSID_AudioProperties"); + IF_GUID_EQUAL_RETURN(guid,0xe30629d2,0x27e5,0x11ce,0x87,0x5d,0x0,0x60,0x8c,0xb7,0x80,0x66,"CLSID_AudioRecord"); + IF_GUID_EQUAL_RETURN(guid,0xe30629d1,0x27e5,0x11ce,0x87,0x5d,0x0,0x60,0x8c,0xb7,0x80,0x66,"CLSID_AudioRender"); + IF_GUID_EQUAL_RETURN(guid,0x37e92a92,0xd9aa,0x11d2,0xbf,0x84,0x8e,0xf2,0xb1,0x55,0x5a,0xed,"CLSID_AudioRendererAdvancedProperties"); + IF_GUID_EQUAL_RETURN(guid,0xe0f158e1,0xcb04,0x11d0,0xbd,0x4e,0x0,0xa0,0xc9,0x11,0xce,0x86,"CLSID_AudioRendererCategory"); + IF_GUID_EQUAL_RETURN(guid,0x00BB2763L,0x6A77,0x11D0,0xA5,0x35,0x00,0xC0,0x4F,0xD7,0xD0,0x62,"CLSID_AutoComplete"); + IF_GUID_EQUAL_RETURN(guid,0xBFE18E9C,0x6D87,0x4450,0xB3,0x7C,0xE0,0x2F,0x0B,0x37,0x38,0x03,"CLSID_AutomaticUpdates"); + IF_GUID_EQUAL_RETURN(guid,0xe2510970,0xf137,0x11ce,0x8b,0x67,0x0,0xaa,0x0,0xa3,0xf1,0xa6,"CLSID_AviDest"); + IF_GUID_EQUAL_RETURN(guid,0xa9ae910,0x85c0,0x11d0,0xbd,0x42,0x0,0xa0,0xc9,0x11,0xce,0x86,"CLSID_AviMuxProptyPage1"); + IF_GUID_EQUAL_RETURN(guid,0xc647b5c0,0x157c,0x11d0,0xbd,0x23,0x0,0xa0,0xc9,0x11,0xce,0x86,"CLSID_AviMuxProptyPage"); + IF_GUID_EQUAL_RETURN(guid,0x1b544c21,0xfd0b,0x11ce,0x8c,0x63,0x0,0xaa,0x00,0x44,0xb5,0x1e,"CLSID_AviReader"); + IF_GUID_EQUAL_RETURN(guid,0x1b544c20,0xfd0b,0x11ce,0x8c,0x63,0x0,0xaa,0x00,0x44,0xb5,0x1e,"CLSID_AviSplitter"); + IF_GUID_EQUAL_RETURN(guid,0xb2bcff59,0xa757,0x4b0b,0xa1,0xbc,0xea,0x69,0x98,0x1d,0xa6,0x9e,"CLSID_AzAuthorizationStore"); + IF_GUID_EQUAL_RETURN(guid,0x5c2dc96f,0x8d51,0x434b,0xb3,0x3c,0x37,0x9b,0xcc,0xae,0x77,0xc3,"CLSID_AzBizRuleContext"); + IF_GUID_EQUAL_RETURN(guid,0x483afb5d,0x70df,0x4e16,0xab,0xdc,0xa1,0xde,0x4d,0x01,0x5a,0x3e,"CLSID_AzPrincipalLocator"); + IF_GUID_EQUAL_RETURN(guid,0x33d9a761,0x90c8,0x11d0,0xbd,0x43,0x0,0xa0,0xc9,0x11,0xce,0x86,"CLSID_CAcmCoClassManager"); + IF_GUID_EQUAL_RETURN(guid,0x3050f3BB,0x98b5,0x11cf,0xbb,0x82,0x00,0xaa,0x00,0xbd,0xce,0x0b,"CLSID_CAnchorBrowsePropertyPage"); + IF_GUID_EQUAL_RETURN(guid,0x9B77C0F2,0x8735,0x46c5,0xB9,0x0F,0x5F,0x0B,0x30,0x3E,0xF6,0xAB,"CLSID_CAsfTocParser"); + IF_GUID_EQUAL_RETURN(guid,0x3ADCE5CC,0x13C8,0x4573,0xB3,0x28,0xED,0x43,0x8E,0xB6,0x94,0xF9,"CLSID_CAviTocParser"); + IF_GUID_EQUAL_RETURN(guid,0x3d07a539,0x35ca,0x447c,0x9b,0x5,0x8d,0x85,0xce,0x92,0x4f,0x9e,"CLSID_CCAFilter"); + IF_GUID_EQUAL_RETURN(guid,0x47354492,0x827E,0x4b8a,0xB3,0x18,0xC8,0x0E,0xBA,0x13,0x81,0xF0,"CLSID_CClusterDetectorEx"); + IF_GUID_EQUAL_RETURN(guid,0x4315D437,0x5B8C,0x11d0,0xBD,0x3B,0x00,0xA0,0xC9,0x11,0xCE,0x86,"CLSID_CDeviceMoniker"); + IF_GUID_EQUAL_RETURN(guid,0x3050f3B4,0x98b5,0x11cf,0xbb,0x82,0x00,0xaa,0x00,0xbd,0xce,0x0b,"CLSID_CDocBrowsePropertyPage"); + IF_GUID_EQUAL_RETURN(guid,0xBFCCD195,0x1244,0x4840,0xAB,0x44,0x48,0x09,0x75,0xC4,0xFF,0xE4,"CLSID_CFileClient"); + IF_GUID_EQUAL_RETURN(guid,0x11993195,0x1244,0x4840,0xAB,0x44,0x48,0x09,0x75,0xC4,0xFF,0xE4,"CLSID_CFileIo"); + IF_GUID_EQUAL_RETURN(guid,0x33d9a760,0x90c8,0x11d0,0xbd,0x43,0x0,0xa0,0xc9,0x11,0xce,0x86,"CLSID_CIcmCoClassManager"); + IF_GUID_EQUAL_RETURN(guid,0x3050f3B3,0x98b5,0x11cf,0xbb,0x82,0x00,0xaa,0x00,0xbd,0xce,0x0b,"CLSID_CImageBrowsePropertyPage"); + IF_GUID_EQUAL_RETURN(guid,0xbacc578d,0xfbdd,0x48a4,0x96,0x9f,0x2,0xd9,0x32,0xb7,0x46,0x34,"CLSID_CLRDebugging"); + IF_GUID_EQUAL_RETURN(guid,0xDF8395B5,0xA4BA,0x450b,0xA7,0x7C,0xA9,0xA4,0x77,0x62,0xC5,0x20,"CLSID_CLRDebuggingLegacy"); + IF_GUID_EQUAL_RETURN(guid,0x9280188d,0xe8e,0x4867,0xb3,0xc,0x7f,0xa8,0x38,0x84,0xe8,0xde,"CLSID_CLRMetaHost"); + IF_GUID_EQUAL_RETURN(guid,0x2ebcd49a,0x1b47,0x4a61,0xb1,0x3a,0x4a,0x3,0x70,0x1e,0x59,0x4b,"CLSID_CLRMetaHostPolicy"); + IF_GUID_EQUAL_RETURN(guid,0xbd097ed8,0x733e,0x43fe,0x8e,0xd7,0xa9,0x5f,0xf9,0xa8,0x44,0x8c,"CLSID_CLRProfiling"); + IF_GUID_EQUAL_RETURN(guid,0x90F1A06E,0x7712,0x4762,0x86,0xB5,0x7A,0x5E,0xBA,0x6B,0xDB,0x02,"CLSID_CLRRuntimeHost"); + IF_GUID_EQUAL_RETURN(guid,0xB79B0ACD,0xF5CD,0x409b,0xB5,0xA5,0xA1,0x62,0x44,0x61,0x0B,0x92,"CLSID_CLRStrongName"); + IF_GUID_EQUAL_RETURN(guid,0x005023ca,0x72b1,0x11d3,0x9f,0xc4,0x0,0xc0,0x4f,0x79,0xa0,0xa3,"CLSID_CLR_v1_MetaData"); + IF_GUID_EQUAL_RETURN(guid,0xefea471a,0x44fd,0x4862,0x92,0x92,0xc,0x58,0xd4,0x6e,0x1f,0x3a,"CLSID_CLR_v2_MetaData"); + IF_GUID_EQUAL_RETURN(guid,0x4EfE2452,0x168A,0x11d1,0xBC,0x76,0x0,0xc0,0x4F,0xB9,0x45,0x3B,"CLSID_CMidiOutClassManager"); + IF_GUID_EQUAL_RETURN(guid,0x4a2286e0,0x7bef,0x11ce,0x9b,0xd9,0x0,0x0,0xe2,0x2,0x59,0x9c,"CLSID_CMpegAudioCodec"); + IF_GUID_EQUAL_RETURN(guid,0xfeb50740,0x7bef,0x11ce,0x9b,0xd9,0x0,0x0,0xe2,0x2,0x59,0x9c,"CLSID_CMpegVideoCodec"); + IF_GUID_EQUAL_RETURN(guid,0xC4C4C4FC,0x0049,0x4E2B,0x98,0xFB,0x95,0x37,0xF6,0xCE,0x51,0x6D,"CLSID_CPCAFiltersCategory"); + IF_GUID_EQUAL_RETURN(guid,0x083863F1,0x70DE,0x11d0,0xBD,0x40,0x00,0xA0,0xC9,0x11,0xCE,0x86,"CLSID_CQzFilterClassManager"); + IF_GUID_EQUAL_RETURN(guid,0x148BD520,0xA2AB,0x11CE,0xB1,0x1F,0x00,0xAA,0x00,0x53,0x05,0x03,"CLSID_CTask"); + IF_GUID_EQUAL_RETURN(guid,0x148BD52A,0xA2AB,0x11CE,0xB1,0x1F,0x00,0xAA,0x00,0x53,0x05,0x03,"CLSID_CTaskScheduler"); + IF_GUID_EQUAL_RETURN(guid,0x4FE24495,0x28CE,0x4920,0xA4,0xC4,0xE5,0x56,0xE1,0xF0,0xDF,0x2A,"CLSID_CToc"); + IF_GUID_EQUAL_RETURN(guid,0x5058292D,0xA244,0x4840,0xAB,0x44,0x48,0x09,0x75,0xC4,0xFF,0xE4,"CLSID_CTocCollection"); + IF_GUID_EQUAL_RETURN(guid,0xF22F5E05,0x585C,0x4def,0x85,0x23,0x65,0x55,0xCF,0xBC,0x0C,0xB3,"CLSID_CTocEntry"); + IF_GUID_EQUAL_RETURN(guid,0x3A8CCCBC,0x0EFD,0x43a3,0xB8,0x38,0xF3,0x8A,0x55,0x2B,0xA2,0x37,"CLSID_CTocEntryList"); + IF_GUID_EQUAL_RETURN(guid,0x499EAEEA,0x2737,0x4849,0x8B,0xB6,0x47,0xF1,0x07,0xEA,0xF3,0x58,"CLSID_CTocParser"); + IF_GUID_EQUAL_RETURN(guid,0xCFBFAE00L,0x17A6,0x11D0,0x99,0xCB,0x00,0xC0,0x4F,0xD6,0x44,0x97,"CLSID_CURLSearchHook"); + IF_GUID_EQUAL_RETURN(guid,0x3C374A40L,0xBAE4,0x11CF,0xBF,0x7D,0x00,0xAA,0x00,0x69,0x46,0xEE,"CLSID_CUrlHistory"); + IF_GUID_EQUAL_RETURN(guid,0x860BB310,0x5D01,0x11d0,0xBD,0x3B,0x00,0xA0,0xC9,0x11,0xCE,0x86,"CLSID_CVidCapClassManager"); + IF_GUID_EQUAL_RETURN(guid,0xe0f158e1,0xcb04,0x11d0,0xbd,0x4e,0x0,0xa0,0xc9,0x11,0xce,0x86,"CLSID_CWaveOutClassManager"); + IF_GUID_EQUAL_RETURN(guid,0x33d9a762,0x90c8,0x11d0,0xbd,0x43,0x0,0xa0,0xc9,0x11,0xce,0x86,"CLSID_CWaveinClassManager"); + IF_GUID_EQUAL_RETURN(guid,0x71f96465,0x78f3,0x11d0,0xa1,0x8c,0x0,0xa0,0xc9,0x11,0x89,0x56,"CLSID_CameraControlPropertyPage"); + IF_GUID_EQUAL_RETURN(guid,0x2F7EE4B6,0x6FF5,0x4EB4,0xB2,0x4A,0x2B,0xFC,0x41,0x11,0x71,0x71,"CLSID_CaptionsFilter"); + IF_GUID_EQUAL_RETURN(guid,0xBF87B6E1,0x8C27,0x11d0,0xB3,0xF0,0x0,0xAA,0x00,0x37,0x61,0xC5,"CLSID_CaptureGraphBuilder2"); + IF_GUID_EQUAL_RETURN(guid,0xBF87B6E0,0x8C27,0x11d0,0xB3,0xF0,0x0,0xAA,0x00,0x37,0x61,0xC5,"CLSID_CaptureGraphBuilder"); + IF_GUID_EQUAL_RETURN(guid,0x1B544c22,0xFD0B,0x11ce,0x8C,0x63,0x00,0xAA,0x00,0x44,0xB5,0x1F,"CLSID_CaptureProperties"); + IF_GUID_EQUAL_RETURN(guid,0xCD12A3CE,0x9C42,0x11D2,0xBE,0xED,0x00,0x60,0x08,0x2F,0x20,0x54,"CLSID_ClientNetManager"); + IF_GUID_EQUAL_RETURN(guid,0x1643e180,0x90f5,0x11ce,0x97,0xd5,0x00,0xaa,0x00,0x55,0x59,0x5a,"CLSID_Colour"); + IF_GUID_EQUAL_RETURN(guid,0x3F281000,0xE95A,0x11d2,0x88,0x6B,0x00,0xC0,0x4F,0x86,0x9F,0x04,"CLSID_ComCallUnmarshal"); + IF_GUID_EQUAL_RETURN(guid,0x45fb4600,0xe6e8,0x4928,0xb2,0x5e,0x50,0x47,0x6f,0xf7,0x94,0x25,"CLSID_ComCallUnmarshalV4"); + IF_GUID_EQUAL_RETURN(guid,0xbee00010,0xee77,0x11d0,0xa0,0x15,0x00,0xc0,0x4f,0xbb,0xb8,0x84,"CLSID_Cor"); + IF_GUID_EQUAL_RETURN(guid,0xe5cb7a31,0x7512,0x11d2,0x89,0xce,0x0,0x80,0xc7,0x92,0xe5,0xd8,"CLSID_CorMetaDataDispenser"); + IF_GUID_EQUAL_RETURN(guid,0x435755ff,0x7397,0x11d2,0x97,0x71,0x0,0xa0,0xc9,0xb4,0xd5,0xc,"CLSID_CorMetaDataDispenserReg"); + IF_GUID_EQUAL_RETURN(guid,0x1ec2de53,0x75cc,0x11d2,0x97,0x75,0x0,0xa0,0xc9,0xb4,0xd5,0xc,"CLSID_CorMetaDataDispenserRuntime"); + IF_GUID_EQUAL_RETURN(guid,0x87f3a1f5,0x7397,0x11d2,0x97,0x71,0x0,0xa0,0xc9,0xb4,0xd5,0xc,"CLSID_CorMetaDataReg"); + IF_GUID_EQUAL_RETURN(guid,0xcb2f6723,0xab3a,0x11d2,0x9c,0x40,0x00,0xc0,0x4f,0xa3,0x0a,0x3e,"CLSID_CorRuntimeHost"); + IF_GUID_EQUAL_RETURN(guid,0x43196c62,0xc31f,0x4ce3,0xa0,0x2e,0x79,0xef,0xe0,0xf6,0xa5,0x25,"CLSID_CounterItem2"); + IF_GUID_EQUAL_RETURN(guid,0xC4D2D8E0,0xD1DD,0x11ce,0x94,0x0F,0x00,0x80,0x29,0x00,0x43,0x48,"CLSID_CounterItem"); + IF_GUID_EQUAL_RETURN(guid,0xCF948561,0xEDE8,0x11CE,0x94,0x1E,0x00,0x80,0x29,0x00,0x43,0x47,"CLSID_CounterPropPage"); + IF_GUID_EQUAL_RETURN(guid,0xB2B066D2,0x2AAC,0x11cf,0x94,0x2F,0x00,0x80,0x29,0x00,0x43,0x47,"CLSID_Counters"); + IF_GUID_EQUAL_RETURN(guid,0xef65a54d,0x0788,0x45b8,0x8b,0x14,0xbc,0x0f,0x6a,0x6b,0x51,0x37,"CLSID_CreateMediaExtensionObject"); + IF_GUID_EQUAL_RETURN(guid,0x71f96461,0x78f3,0x11d0,0xa1,0x8c,0x0,0xa0,0xc9,0x11,0x89,0x56,"CLSID_CrossbarFilterPropertyPage"); + IF_GUID_EQUAL_RETURN(guid,0x6AA97485,0x6354,0x4cfc,0x90,0x8C,0xE4,0xA7,0x4F,0x62,0xC9,0x6C,"CLSID_D2D12DAffineTransform"); + IF_GUID_EQUAL_RETURN(guid,0xC2844D0B,0x3D86,0x46e7,0x85,0xBA,0x52,0x6C,0x92,0x40,0xF3,0xFB,"CLSID_D2D13DPerspectiveTransform"); + IF_GUID_EQUAL_RETURN(guid,0xe8467b04,0xec61,0x4b8a,0xb5,0xde,0xd4,0xd7,0x3d,0xeb,0xea,0x5a,"CLSID_D2D13DTransform"); + IF_GUID_EQUAL_RETURN(guid,0xfc151437,0x049a,0x4784,0xa2,0x4a,0xf1,0xc4,0xda,0xf2,0x09,0x87,"CLSID_D2D1ArithmeticComposite"); + IF_GUID_EQUAL_RETURN(guid,0x913e2be4,0xfdcf,0x4fe2,0xa5,0xf0,0x24,0x54,0xf1,0x4f,0xf4,0x8,"CLSID_D2D1Atlas"); + IF_GUID_EQUAL_RETURN(guid,0x5fb6c24d,0xc6dd,0x4231,0x94,0x4,0x50,0xf4,0xd5,0xc3,0x25,0x2d,"CLSID_D2D1BitmapSource"); + IF_GUID_EQUAL_RETURN(guid,0x81c5b77b,0x13f8,0x4cdd,0xad,0x20,0xc8,0x90,0x54,0x7a,0xc6,0x5d,"CLSID_D2D1Blend"); + IF_GUID_EQUAL_RETURN(guid,0x2A2D49C0,0x4ACF,0x43c7,0x8C,0x6A,0x7C,0x4A,0x27,0x87,0x4D,0x27,"CLSID_D2D1Border"); + IF_GUID_EQUAL_RETURN(guid,0x8cea8d1e,0x77b0,0x4986,0xb3,0xb9,0x2f,0x0c,0x0e,0xae,0x78,0x87,"CLSID_D2D1Brightness"); + IF_GUID_EQUAL_RETURN(guid,0x1A28524C,0xFDD6,0x4AA4,0xAE,0x8F,0x83,0x7E,0xB8,0x26,0x7B,0x37,"CLSID_D2D1ColorManagement"); + IF_GUID_EQUAL_RETURN(guid,0x921F03D6,0x641C,0x47DF,0x85,0x2D,0xB4,0xBB,0x61,0x53,0xAE,0x11,"CLSID_D2D1ColorMatrix"); + IF_GUID_EQUAL_RETURN(guid,0x48fc9f51,0xf6ac,0x48f1,0x8b,0x58,0x3b,0x28,0xac,0x46,0xf7,0x6d,"CLSID_D2D1Composite"); + IF_GUID_EQUAL_RETURN(guid,0x407f8c08,0x5533,0x4331,0xa3,0x41,0x23,0xcc,0x38,0x77,0x84,0x3e,"CLSID_D2D1ConvolveMatrix"); + IF_GUID_EQUAL_RETURN(guid,0xE23F7110,0x0E9A,0x4324,0xAF,0x47,0x6A,0x2C,0x0C,0x46,0xF3,0x5B,"CLSID_D2D1Crop"); + IF_GUID_EQUAL_RETURN(guid,0x174319a6,0x58e9,0x49b2,0xbb,0x63,0xca,0xf2,0xc8,0x11,0xa3,0xdb,"CLSID_D2D1DirectionalBlur"); + IF_GUID_EQUAL_RETURN(guid,0x90866fcd,0x488e,0x454b,0xaf,0x06,0xe5,0x04,0x1b,0x66,0xc3,0x6c,"CLSID_D2D1DiscreteTransfer"); + IF_GUID_EQUAL_RETURN(guid,0xedc48364,0x417,0x4111,0x94,0x50,0x43,0x84,0x5f,0xa9,0xf8,0x90,"CLSID_D2D1DisplacementMap"); + IF_GUID_EQUAL_RETURN(guid,0x3e7efd62,0xa32d,0x46d4,0xa8,0x3c,0x52,0x78,0x88,0x9a,0xc9,0x54,"CLSID_D2D1DistantDiffuse"); + IF_GUID_EQUAL_RETURN(guid,0x428c1ee5,0x77b8,0x4450,0x8a,0xb5,0x72,0x21,0x9c,0x21,0xab,0xda,"CLSID_D2D1DistantSpecular"); + IF_GUID_EQUAL_RETURN(guid,0x6c26c5c7,0x34e0,0x46fc,0x9c,0xfd,0xe5,0x82,0x37,0x6,0xe2,0x28,"CLSID_D2D1DpiCompensation"); + IF_GUID_EQUAL_RETURN(guid,0x61c23c20,0xae69,0x4d8e,0x94,0xcf,0x50,0x07,0x8d,0xf6,0x38,0xf2,"CLSID_D2D1Flood"); + IF_GUID_EQUAL_RETURN(guid,0x409444c4,0xc419,0x41a0,0xb0,0xc1,0x8c,0xd0,0xc0,0xa1,0x8e,0x42,"CLSID_D2D1GammaTransfer"); + IF_GUID_EQUAL_RETURN(guid,0x1feb6d69,0x2fe6,0x4ac9,0x8c,0x58,0x1d,0x7f,0x93,0xe7,0xa6,0xa5,"CLSID_D2D1GaussianBlur"); + IF_GUID_EQUAL_RETURN(guid,0x881db7d0,0xf7ee,0x4d4d,0xa6,0xd2,0x46,0x97,0xac,0xc6,0x6e,0xe8,"CLSID_D2D1Histogram"); + IF_GUID_EQUAL_RETURN(guid,0x0f4458ec,0x4b32,0x491b,0x9e,0x85,0xbd,0x73,0xf4,0x4d,0x3e,0xb6,"CLSID_D2D1HueRotation"); + IF_GUID_EQUAL_RETURN(guid,0xad47c8fd,0x63ef,0x4acc,0x9b,0x51,0x67,0x97,0x9c,0x03,0x6c,0x06,"CLSID_D2D1LinearTransfer"); + IF_GUID_EQUAL_RETURN(guid,0x41251ab7,0x0beb,0x46f8,0x9d,0xa7,0x59,0xe9,0x3f,0xcc,0xe5,0xde,"CLSID_D2D1LuminanceToAlpha"); + IF_GUID_EQUAL_RETURN(guid,0xeae6c40d,0x626a,0x4c2d,0xbf,0xcb,0x39,0x10,0x01,0xab,0xe2,0x02,"CLSID_D2D1Morphology"); + IF_GUID_EQUAL_RETURN(guid,0x6c53006a,0x4450,0x4199,0xaa,0x5b,0xad,0x16,0x56,0xfe,0xce,0x5e,"CLSID_D2D1OpacityMetadata"); + IF_GUID_EQUAL_RETURN(guid,0xb9e303c3,0xc08c,0x4f91,0x8b,0x7b,0x38,0x65,0x6b,0xc4,0x8c,0x20,"CLSID_D2D1PointDiffuse"); + IF_GUID_EQUAL_RETURN(guid,0x09c3ca26,0x3ae2,0x4f09,0x9e,0xbc,0xed,0x38,0x65,0xd5,0x3f,0x22,"CLSID_D2D1PointSpecular"); + IF_GUID_EQUAL_RETURN(guid,0x06eab419,0xdeed,0x4018,0x80,0xd2,0x3e,0x1d,0x47,0x1a,0xde,0xb2,"CLSID_D2D1Premultiply"); + IF_GUID_EQUAL_RETURN(guid,0x5cb2d9cf,0x327d,0x459f,0xa0,0xce,0x40,0xc0,0xb2,0x08,0x6b,0xf7,"CLSID_D2D1Saturation"); + IF_GUID_EQUAL_RETURN(guid,0x9daf9369,0x3846,0x4d0e,0xa4,0x4e,0xc,0x60,0x79,0x34,0xa5,0xd7,"CLSID_D2D1Scale"); + IF_GUID_EQUAL_RETURN(guid,0xC67EA361,0x1863,0x4e69,0x89,0xDB,0x69,0x5D,0x3E,0x9A,0x5B,0x6B,"CLSID_D2D1Shadow"); + IF_GUID_EQUAL_RETURN(guid,0x818a1105,0x7932,0x44f4,0xaa,0x86,0x08,0xae,0x7b,0x2f,0x2c,0x93,"CLSID_D2D1SpotDiffuse"); + IF_GUID_EQUAL_RETURN(guid,0xedae421e,0x7654,0x4a37,0x9d,0xb8,0x71,0xac,0xc1,0xbe,0xb3,0xc1,"CLSID_D2D1SpotSpecular"); + IF_GUID_EQUAL_RETURN(guid,0x5bf818c3,0x5e43,0x48cb,0xb6,0x31,0x86,0x83,0x96,0xd6,0xa1,0xd4,"CLSID_D2D1TableTransfer"); + IF_GUID_EQUAL_RETURN(guid,0xB0784138,0x3B76,0x4bc5,0xB1,0x3B,0x0F,0xA2,0xAD,0x02,0x65,0x9F,"CLSID_D2D1Tile"); + IF_GUID_EQUAL_RETURN(guid,0xCF2BB6AE,0x889A,0x4ad7,0xBA,0x29,0xA2,0xFD,0x73,0x2C,0x9F,0xC9,"CLSID_D2D1Turbulence"); + IF_GUID_EQUAL_RETURN(guid,0xfb9ac489,0xad8d,0x41ed,0x99,0x99,0xbb,0x63,0x47,0xd1,0x10,0xf7,"CLSID_D2D1UnPremultiply"); + IF_GUID_EQUAL_RETURN(guid,0xbcd5796c,0xbd52,0x4d30,0xab,0x76,0x70,0xf9,0x75,0xb8,0x91,0x99,"CLSID_DMOFilterCategory"); + IF_GUID_EQUAL_RETURN(guid,0x94297043,0xbd82,0x4dfd,0xb0,0xde,0x81,0x77,0x73,0x9c,0x6d,0x20,"CLSID_DMOWrapperFilter"); + IF_GUID_EQUAL_RETURN(guid,0x05500280,0xFAA5,0x4DF9,0x82,0x46,0xBF,0xC2,0x3A,0xC5,0xCE,0xA8,"CLSID_DShowTVEFilter"); + IF_GUID_EQUAL_RETURN(guid,0x79376820,0x07D0,0x11CF,0xA2,0x4D,0x0,0x20,0xAF,0xD7,0x97,0x67,"CLSID_DSoundRender"); + IF_GUID_EQUAL_RETURN(guid,0xC4C4C482,0x0049,0x4E2B,0x98,0xFB,0x95,0x37,0xF6,0xCE,0x51,0x6D,"CLSID_DTFilterEncProperties"); + IF_GUID_EQUAL_RETURN(guid,0xC4C4C492,0x0049,0x4E2B,0x98,0xFB,0x95,0x37,0xF6,0xCE,0x51,0x6D,"CLSID_DTFilterTagProperties"); + IF_GUID_EQUAL_RETURN(guid,0xdc0c0fe7,0x485,0x4266,0xb9,0x3f,0x68,0xfb,0xf8,0xe,0xd8,0x34,"CLSID_DVBCNetworkProvider"); + IF_GUID_EQUAL_RETURN(guid,0xfa4b375a,0x45b4,0x4d45,0x84,0x40,0x26,0x39,0x57,0xb1,0x16,0x23,"CLSID_DVBSNetworkProvider"); + IF_GUID_EQUAL_RETURN(guid,0x216c62df,0x6d7f,0x4e9a,0x85,0x71,0x5,0xf1,0x4e,0xdb,0x76,0x6a,"CLSID_DVBTNetworkProvider"); + IF_GUID_EQUAL_RETURN(guid,0x2721AE20,0x7E70,0x11D0,0xA5,0xD6,0x28,0xDB,0x04,0xC1,0x00,0x00,"CLSID_DVDHWDecodersCategory"); + IF_GUID_EQUAL_RETURN(guid,0x9b8c4620,0x2c1a,0x11d0,0x84,0x93,0x0,0xa0,0x24,0x38,0xad,0x48,"CLSID_DVDNavigator"); + IF_GUID_EQUAL_RETURN(guid,0xf963c5cf,0xa659,0x4a93,0x96,0x38,0xca,0xf3,0xcd,0x27,0x7d,0x13,"CLSID_DVDState"); + IF_GUID_EQUAL_RETURN(guid,0x101193c0,0xbfe,0x11d0,0xaf,0x91,0x0,0xaa,0x0,0xb6,0x7a,0x42,"CLSID_DVDecPropertiesPage"); + IF_GUID_EQUAL_RETURN(guid,0x4150f050,0xbb6f,0x11d0,0xaf,0xb9,0x0,0xaa,0x0,0xb6,0x7a,0x42,"CLSID_DVEncPropertiesPage"); + IF_GUID_EQUAL_RETURN(guid,0x129d7e40,0xc10d,0x11d0,0xaf,0xb9,0x0,0xaa,0x0,0xb6,0x7a,0x42,"CLSID_DVMux"); + IF_GUID_EQUAL_RETURN(guid,0x4db880e0,0xc10d,0x11d0,0xaf,0xb9,0x0,0xaa,0x0,0xb6,0x7a,0x42,"CLSID_DVMuxPropertyPage"); + IF_GUID_EQUAL_RETURN(guid,0x4eb31670,0x9fc6,0x11cf,0xaf,0x6e,0x0,0xaa,0x0,0xb6,0x7a,0x42,"CLSID_DVSplitter"); + IF_GUID_EQUAL_RETURN(guid,0xb1b77c00,0xc3e4,0x11cf,0xaf,0x79,0x0,0xaa,0x0,0xb6,0x7a,0x42,"CLSID_DVVideoCodec"); + IF_GUID_EQUAL_RETURN(guid,0x13aa3650,0xbb6f,0x11d0,0xaf,0xb9,0x0,0xaa,0x0,0xb6,0x7a,0x42,"CLSID_DVVideoEnc"); + IF_GUID_EQUAL_RETURN(guid,0xCFCCC7A0L,0xA282,0x11D1,0x90,0x82,0x00,0x60,0x08,0x05,0x93,0x82,"CLSID_DarwinAppPublisher"); + IF_GUID_EQUAL_RETURN(guid,0x3449a1c8,0xc56c,0x11d0,0xad,0x72,0,0xc0,0x4f,0xc2,0x98,0x63,"CLSID_DataShapeProvider"); + IF_GUID_EQUAL_RETURN(guid,0xcc7bfb46,0xf175,0x11d1,0xa3,0x92,0x0,0xe0,0x29,0x1f,0x39,0x59,"CLSID_DeviceControlCategory"); + IF_GUID_EQUAL_RETURN(guid,0x12d3e372,0x874b,0x457d,0x9f,0xdf,0x73,0x97,0x77,0x78,0x68,0x6c,"CLSID_DeviceIoControl"); + IF_GUID_EQUAL_RETURN(guid,0x3c305196,0x50db,0x11d3,0x9c,0xfe,0x00,0xc0,0x4f,0xd9,0x30,0xc5,"CLSID_DirectDraw7"); + IF_GUID_EQUAL_RETURN(guid,0xD7B70EE0,0x4340,0x11CF,0xB0,0x63,0x00,0x20,0xAF,0xC2,0xCD,0x35,"CLSID_DirectDraw"); + IF_GUID_EQUAL_RETURN(guid,0x593817A0,0x7DB3,0x11CF,0xA2,0xDE,0x00,0xAA,0x00,0xb9,0x33,0x56,"CLSID_DirectDrawClipper"); + IF_GUID_EQUAL_RETURN(guid,0x944d4c00,0xdd52,0x11ce,0xbf,0x0e,0x00,0xaa,0x00,0x55,0x59,0x5a,"CLSID_DirectDrawProperties"); + IF_GUID_EQUAL_RETURN(guid,0x25E609E4,0xB259,0x11CF,0xBF,0xC7,0x44,0x45,0x53,0x54,0x00,0x00,"CLSID_DirectInput8"); + IF_GUID_EQUAL_RETURN(guid,0x25E609E0,0xB259,0x11CF,0xBF,0xC7,0x44,0x45,0x53,0x54,0x00,0x00,"CLSID_DirectInput"); + IF_GUID_EQUAL_RETURN(guid,0x25E609E5,0xB259,0x11CF,0xBF,0xC7,0x44,0x45,0x53,0x54,0x00,0x00,"CLSID_DirectInputDevice8"); + IF_GUID_EQUAL_RETURN(guid,0x25E609E1,0xB259,0x11CF,0xBF,0xC7,0x44,0x45,0x53,0x54,0x00,0x00,"CLSID_DirectInputDevice"); + IF_GUID_EQUAL_RETURN(guid,0x636b9f10,0x0c7d,0x11d1,0x95,0xb2,0x00,0x20,0xaf,0xdc,0x74,0x21,"CLSID_DirectMusic"); + IF_GUID_EQUAL_RETURN(guid,0x480ff4b0,0x28b2,0x11d1,0xbe,0xf7,0x0,0xc0,0x4f,0xbf,0x8f,0xef,"CLSID_DirectMusicCollection"); + IF_GUID_EQUAL_RETURN(guid,0x58C2B4D0,0x46E7,0x11D1,0x89,0xAC,0x00,0xA0,0xC9,0x05,0x41,0x29,"CLSID_DirectMusicSynth"); + IF_GUID_EQUAL_RETURN(guid,0x8670c736,0xf614,0x427b,0x8a,0xda,0xbb,0xad,0xc5,0x87,0x19,0x4b,"CLSID_DirectShowPluginControl"); + IF_GUID_EQUAL_RETURN(guid,0x3901cc3f,0x84b5,0x4fa4,0xba,0x35,0xaa,0x81,0x72,0xb8,0xa0,0x9b,"CLSID_DirectSound8"); + IF_GUID_EQUAL_RETURN(guid,0x47d4d946,0x62e8,0x11cf,0x93,0xbc,0x44,0x45,0x53,0x54,0x0,0x0,"CLSID_DirectSound"); + IF_GUID_EQUAL_RETURN(guid,0xe4bcac13,0x7f99,0x4908,0x9a,0x8e,0x74,0xe3,0xbf,0x24,0xb6,0xe1,"CLSID_DirectSoundCapture8"); + IF_GUID_EQUAL_RETURN(guid,0xb0210780,0x89cd,0x11d0,0xaf,0x8,0x0,0xa0,0xc9,0x25,0xcd,0x16,"CLSID_DirectSoundCapture"); + IF_GUID_EQUAL_RETURN(guid,0xfea4300c,0x7959,0x4147,0xb2,0x6a,0x23,0x77,0xb9,0xe7,0xa9,0x1d,"CLSID_DirectSoundFullDuplex"); + IF_GUID_EQUAL_RETURN(guid,0x7988b571,0xec89,0x11cf,0x9c,0x0,0x0,0xaa,0x0,0xa1,0x4f,0x56,"CLSID_DiskQuotaControl"); + IF_GUID_EQUAL_RETURN(guid,0x1da08500,0x9edc,0x11cf,0xbc,0x10,0x00,0xaa,0x00,0xac,0x74,0xf6,"CLSID_Dither"); + IF_GUID_EQUAL_RETURN(guid,0x7057e952,0xbd1b,0x11d1,0x89,0x19,0x0,0xc0,0x4f,0xc2,0xc8,0x36,"CLSID_DocHostUIHandler"); + IF_GUID_EQUAL_RETURN(guid,0xBF426F7E,0x7A5E,0x44D6,0x83,0x0C,0xA3,0x90,0xEA,0x94,0x62,0xA3,"CLSID_DocWrap"); + IF_GUID_EQUAL_RETURN(guid,0x4657278a,0x411b,0x11d2,0x83,0x9a,0x0,0xc0,0x4f,0xd9,0x18,0xd0,"CLSID_DragDropHelper"); + IF_GUID_EQUAL_RETURN(guid,0x17d6ccd8,0x3b7b,0x11d2,0xb9,0xe0,0x00,0xc0,0x4f,0xd8,0xdb,0xf7,"CLSID_DsObjectPicker"); + IF_GUID_EQUAL_RETURN(guid,0xfb056ba0,0x2502,0x45b9,0x8e,0x86,0x2b,0x40,0xde,0x84,0xad,0x29,"CLSID_DtvCcFilter"); + IF_GUID_EQUAL_RETURN(guid,0xFCC152B7,0xF372,0x11d0,0x8E,0x00,0x00,0xC0,0x4F,0xD7,0xC0,0x8B,"CLSID_DvdGraphBuilder"); + IF_GUID_EQUAL_RETURN(guid,0xA65B8071,0x3BFE,0x4213,0x9A,0x5B,0x49,0x1D,0xA4,0x46,0x1C,0xA7,"CLSID_DxDiagProvider"); + IF_GUID_EQUAL_RETURN(guid,0xC4C4C481,0x0049,0x4E2B,0x98,0xFB,0x95,0x37,0xF6,0xCE,0x51,0x6D,"CLSID_ETFilterEncProperties"); + IF_GUID_EQUAL_RETURN(guid,0xC4C4C491,0x0049,0x4E2B,0x98,0xFB,0x95,0x37,0xF6,0xCE,0x51,0x6D,"CLSID_ETFilterTagProperties"); + IF_GUID_EQUAL_RETURN(guid,0x62079164,0x233b,0x41f8,0xa8,0x0f,0xf0,0x17,0x05,0xf5,0x14,0xa8,"CLSID_EVRPlaybackPipelineOptimizer"); + IF_GUID_EQUAL_RETURN(guid,0xa0a7a57b,0x59b2,0x4919,0xa6,0x94,0xad,0xd0,0xa5,0x26,0xc3,0x73,"CLSID_EVRTearlessWindowPresenter9"); + IF_GUID_EQUAL_RETURN(guid,0xfa10746c,0x9b63,0x4b6c,0xbc,0x49,0xfc,0x30,0xe,0xa5,0xf2,0x56,"CLSID_EnhancedVideoRenderer"); + IF_GUID_EQUAL_RETURN(guid,0x6e5e1910,0x8053,0x4660,0xb7,0x95,0x6b,0x61,0x2e,0x29,0xbc,0x58,"CLSID_EvalCom2"); + IF_GUID_EQUAL_RETURN(guid,0xe436ebb4,0x524f,0x11ce,0x9f,0x53,0x00,0x20,0xaf,0x0b,0xa7,0x70,"CLSID_FGControl"); + IF_GUID_EQUAL_RETURN(guid,0x701722e0,0x8ae3,0x11ce,0xa8,0x5c,0x00,0xaa,0x00,0x2f,0xea,0xb5,"CLSID_FileSource"); + IF_GUID_EQUAL_RETURN(guid,0xB091E540,0x83E3,0x11CF,0xA7,0x13,0x00,0x20,0xAF,0xD7,0x97,0x62,"CLSID_FileTypes"); + IF_GUID_EQUAL_RETURN(guid,0x8596e5f0,0xda5,0x11d0,0xbd,0x21,0x0,0xa0,0xc9,0x11,0xce,0x86,"CLSID_FileWriter"); + IF_GUID_EQUAL_RETURN(guid,0xe436ebb3,0x524f,0x11ce,0x9f,0x53,0x00,0x20,0xaf,0x0b,0xa7,0x70,"CLSID_FilgraphManager"); + IF_GUID_EQUAL_RETURN(guid,0xe436ebb3,0x524f,0x11ce,0x9f,0x53,0x00,0x20,0xaf,0x0b,0xa7,0x70,"CLSID_FilterGraph"); + IF_GUID_EQUAL_RETURN(guid,0xe436ebb8,0x524f,0x11ce,0x9f,0x53,0x00,0x20,0xaf,0x0b,0xa7,0x70,"CLSID_FilterGraphNoThread"); + IF_GUID_EQUAL_RETURN(guid,0xa3ecbc41,0x581a,0x4476,0xb6,0x93,0xa6,0x33,0x40,0x46,0x2d,0x8b,"CLSID_FilterGraphPrivateThread"); + IF_GUID_EQUAL_RETURN(guid,0xcda42200,0xbd88,0x11d0,0xbd,0x4e,0x0,0xa0,0xc9,0x11,0xce,0x86,"CLSID_FilterMapper2"); + IF_GUID_EQUAL_RETURN(guid,0xe436ebb2,0x524f,0x11ce,0x9f,0x53,0x00,0x20,0xaf,0x0b,0xa7,0x70,"CLSID_FilterMapper"); + IF_GUID_EQUAL_RETURN(guid,0xfef10fa2,0x355e,0x4e06,0x93,0x81,0x9b,0x24,0xd7,0xf7,0xcc,0x88,"CLSID_FolderItem"); + IF_GUID_EQUAL_RETURN(guid,0x53c74826,0xab99,0x4d33,0xac,0xa4,0x31,0x17,0xf5,0x1d,0x37,0x88,"CLSID_FolderItemsMultiLevel"); + IF_GUID_EQUAL_RETURN(guid,0x3ff292b6,0xb204,0x11cf,0x8d,0x23,0,0xaa,0,0x5f,0xfe,0x58,"CLSID_FoxRowset"); + IF_GUID_EQUAL_RETURN(guid,0xC3E5D3D2,0x1A03,0x11CF,0x94,0x2D,0x00,0x80,0x29,0x00,0x43,0x47,"CLSID_GeneralPropPage"); + IF_GUID_EQUAL_RETURN(guid,0xC3E5D3D3,0x1A03,0x11CF,0x94,0x2D,0x00,0x80,0x29,0x00,0x43,0x47,"CLSID_GraphPropPage"); + IF_GUID_EQUAL_RETURN(guid,0xffb8655f,0x81b9,0x4fce,0xb8,0x9c,0x9a,0x6b,0xa7,0x6d,0x13,0xe7,"CLSID_HWShellExecute"); + IF_GUID_EQUAL_RETURN(guid,0xe7d18cf5,0x3ec7,0x44d5,0xa7,0x6b,0x37,0x70,0xf3,0xcf,0x90,0x3d,"CLSID_HorizontalIndicatorContent"); + IF_GUID_EQUAL_RETURN(guid,0x44cb442b,0x9da9,0x49df,0xb3,0xfd,0x2,0x37,0x77,0xb1,0x6e,0x50,"CLSID_HttpSchemePlugin"); + IF_GUID_EQUAL_RETURN(guid,0x7ff0997a,0x1999,0x4286,0xa7,0x3c,0x62,0x2b,0x88,0x14,0xe7,0xeb,"CLSID_ICodecAPIProxy"); + IF_GUID_EQUAL_RETURN(guid,0xD82BE2B0L,0x5764,0x11D0,0xA9,0x6E,0x00,0xC0,0x4F,0xD7,0x05,0xA2,"CLSID_ISFBand"); + IF_GUID_EQUAL_RETURN(guid,0xb05dabd9,0x56e5,0x4fdc,0xaf,0xa4,0x8a,0x47,0xe9,0x1f,0x1c,0x9c,"CLSID_IVideoEncoderCodecAPIProxy"); + IF_GUID_EQUAL_RETURN(guid,0xb43c4eec,0x8c32,0x4791,0x91,0x2,0x50,0x8a,0xda,0x5e,0xe8,0xe7,"CLSID_IVideoEncoderProxy"); + IF_GUID_EQUAL_RETURN(guid,0xE8FB8621,0x588F,0x11d2,0x9d,0x61,0x0,0xc0,0x4f,0x79,0xc5,0xfe,"CLSID_IisServiceControl"); + IF_GUID_EQUAL_RETURN(guid,0x7bf0129b,0x5bef,0x4de4,0x9b,0x0b,0x5e,0xdb,0x66,0xac,0x2f,0xa6,"CLSID_ImePlugInDictDictionaryList_CHS"); + IF_GUID_EQUAL_RETURN(guid,0x4fe2776b,0xb0f9,0x4396,0xb5,0xfc,0xe9,0xd4,0xcf,0x1e,0xc1,0x95,"CLSID_ImePlugInDictDictionaryList_JPN"); + IF_GUID_EQUAL_RETURN(guid,0xf8388a40,0xd5bb,0x11d0,0xbe,0x5a,0x0,0x80,0xc7,0x6,0x56,0x8e,"CLSID_InfTee"); + IF_GUID_EQUAL_RETURN(guid,0x317E92FC,0x1679,0x46FD,0xA0,0xB5,0xF0,0x89,0x14,0xDD,0x86,0x23,"CLSID_InstallationAgent"); + IF_GUID_EQUAL_RETURN(guid,0x1E796980L,0x9CC5,0x11D1,0xA8,0x3F,0x00,0xC0,0x4F,0xC9,0x9D,0x61,"CLSID_InternetButtons"); + IF_GUID_EQUAL_RETURN(guid,0x083863F1,0x70DE,0x11d0,0xBD,0x40,0x00,0xA0,0xC9,0x11,0xCE,0x86,"CLSID_LegacyAmFilterCategory"); + IF_GUID_EQUAL_RETURN(guid,0xe4206432,0x01a1,0x4bee,0xb3,0xe1,0x37,0x02,0xc8,0xed,0xc5,0x74,"CLSID_Line21Decoder2"); + IF_GUID_EQUAL_RETURN(guid,0x6e8d4a20,0x310c,0x11d0,0xb7,0x9a,0x0,0xaa,0x0,0x37,0x67,0xa7,"CLSID_Line21Decoder"); + IF_GUID_EQUAL_RETURN(guid,0x24f14f02,0x7b1c,0x11d1,0x83,0x8f,0x0,0x0,0xf8,0x4,0x61,0xcf,"CLSID_LinkColumnProvider"); + IF_GUID_EQUAL_RETURN(guid,0x16EC5BE8,0xDF93,0x4237,0x94,0xE4,0x9E,0xE9,0x18,0x11,0x1D,0x71,"CLSID_LogFileItem"); + IF_GUID_EQUAL_RETURN(guid,0x2735D9FD,0xF6B9,0x4f19,0xA5,0xD9,0xE2,0xD0,0x68,0x58,0x4B,0xC5,"CLSID_LogFiles"); + IF_GUID_EQUAL_RETURN(guid,0x770e8e77,0x4916,0x441c,0xa9,0xa7,0xb3,0x42,0xd0,0xee,0xbc,0x71,"CLSID_MFByteStreamProxyClassFactory"); + IF_GUID_EQUAL_RETURN(guid,0xefce38d3,0x8914,0x4674,0xa7,0xdf,0xae,0x1b,0x3d,0x65,0x4b,0x8a,"CLSID_MFCaptureEngine"); + IF_GUID_EQUAL_RETURN(guid,0xefce38d3,0x8914,0x4674,0xa7,0xdf,0xae,0x1b,0x3d,0x65,0x4b,0x8a,"CLSID_MFCaptureEngineClassFactory"); + IF_GUID_EQUAL_RETURN(guid,0xb22c3339,0x87f3,0x4059,0xa0,0xc5,0x3,0x7a,0xa9,0x70,0x7e,0xaf,"CLSID_MFImageSharingEngineClassFactory"); + IF_GUID_EQUAL_RETURN(guid,0xb44392da,0x499b,0x446b,0xa4,0xcb,0x0,0x5f,0xea,0xd0,0xe6,0xd5,"CLSID_MFMediaEngineClassFactory"); + IF_GUID_EQUAL_RETURN(guid,0xf8e307fb,0x6d45,0x4ad3,0x99,0x93,0x66,0xcd,0x5a,0x52,0x96,0x59,"CLSID_MFMediaSharingEngineClassFactory"); + IF_GUID_EQUAL_RETURN(guid,0x48e2ed0f,0x98c2,0x4a37,0xbe,0xd5,0x16,0x63,0x12,0xdd,0xd8,0x3f,"CLSID_MFReadWriteClassFactory"); + IF_GUID_EQUAL_RETURN(guid,0xa3bbfb17,0x8273,0x4e52,0x9e,0x0e,0x97,0x39,0xdc,0x88,0x79,0x90,"CLSID_MFSinkWriter"); + IF_GUID_EQUAL_RETURN(guid,0x1777133c,0x0881,0x411b,0xa5,0x77,0xad,0x54,0x5f,0x07,0x14,0xc4,"CLSID_MFSourceReader"); + IF_GUID_EQUAL_RETURN(guid,0x90eab60f,0xe43a,0x4188,0xbc,0xc4,0xe4,0x7f,0xdf,0x04,0x86,0x8c,"CLSID_MFSourceResolver"); + IF_GUID_EQUAL_RETURN(guid,0xE474E05A,0xAB65,0x4f6a,0x82,0x7C,0x21,0x8B,0x1B,0xAA,0xF3,0x1F,"CLSID_MFVideoMixer9"); + IF_GUID_EQUAL_RETURN(guid,0x98455561,0x5136,0x4d28,0xab,0x8,0x4c,0xee,0x40,0xea,0x27,0x81,"CLSID_MFVideoPresenter9"); + IF_GUID_EQUAL_RETURN(guid,0xfd361dbe,0x6c9b,0x4de0,0x82,0x90,0xf6,0x40,0xc,0x27,0x37,0xed,"CLSID_MILBitmapEffectBevel"); + IF_GUID_EQUAL_RETURN(guid,0xa924df87,0x225d,0x4373,0x8f,0x5b,0xb9,0xe,0xc8,0x5a,0xe3,0xde,"CLSID_MILBitmapEffectBlur"); + IF_GUID_EQUAL_RETURN(guid,0x459a3fbe,0xd8ac,0x4692,0x87,0x4b,0x7a,0x26,0x57,0x15,0xaa,0x16,"CLSID_MILBitmapEffectDropShadow"); + IF_GUID_EQUAL_RETURN(guid,0xcd299846,0x824f,0x47ec,0xa0,0x07,0x12,0xaa,0x76,0x7f,0x28,0x16,"CLSID_MILBitmapEffectEmboss"); + IF_GUID_EQUAL_RETURN(guid,0xac9c1a9a,0x7e18,0x4f64,0xac,0x7e,0x47,0xcf,0x7f,0x05,0x1e,0x95,"CLSID_MILBitmapEffectGroup"); + IF_GUID_EQUAL_RETURN(guid,0xe2161bdd,0x7eb6,0x4725,0x9c,0x0b,0x8a,0x2a,0x1b,0x4f,0x06,0x67,"CLSID_MILBitmapEffectOuterGlow"); + IF_GUID_EQUAL_RETURN(guid,0xb80ab0a0,0x7416,0x11d2,0x9e,0xeb,0x0,0x60,0x8,0x3,0x9e,0x37,"CLSID_MJPGEnc"); + IF_GUID_EQUAL_RETURN(guid,0x3ae86b20,0x7be8,0x11d1,0xab,0xe6,0x00,0xa0,0xc9,0x05,0xf3,0x75,"CLSID_MMSPLITTER"); + IF_GUID_EQUAL_RETURN(guid,0x44584800,0xf8ee,0x11ce,0xb2,0xd4,0x00,0xdd,0x1,0x10,0x1b,0x85,"CLSID_MOVReader"); + IF_GUID_EQUAL_RETURN(guid,0xe4bbd160,0x4269,0x11ce,0x83,0x8d,0x0,0xaa,0x0,0x55,0x59,0x5a,"CLSID_MPEG1Doc"); + IF_GUID_EQUAL_RETURN(guid,0x26c25940,0x4ca9,0x11ce,0xa8,0x28,0x0,0xaa,0x0,0x2f,0xea,0xb5,"CLSID_MPEG1PacketPlayer"); + IF_GUID_EQUAL_RETURN(guid,0x336475d0,0x942a,0x11ce,0xa8,0x70,0x00,0xaa,0x00,0x2f,0xea,0xb5,"CLSID_MPEG1Splitter"); + IF_GUID_EQUAL_RETURN(guid,0x40871c59,0xab40,0x471f,0x8d,0xc3,0x1f,0x25,0x9d,0x86,0x24,0x79,"CLSID_MPEG2ByteStreamPlugin"); + IF_GUID_EQUAL_RETURN(guid,0xfa5fe7c5,0x6a1d,0x4b11,0xb4,0x1f,0xf9,0x59,0xd6,0xc7,0x65,0x00,"CLSID_MPEG2DLNASink"); + IF_GUID_EQUAL_RETURN(guid,0xafb6c280,0x2c41,0x11d3,0x8a,0x60,0x00,0x00,0xf8,0x1e,0x0e,0x4a,"CLSID_MPEG2Demultiplexer"); + IF_GUID_EQUAL_RETURN(guid,0x687d3367,0x3644,0x467a,0xad,0xfe,0x6c,0xd7,0xa8,0x5c,0x4a,0x2c,"CLSID_MPEG2Demultiplexer_NoClock"); + IF_GUID_EQUAL_RETURN(guid,0x08cd963f,0x7a3e,0x4f5c,0x9b,0xd8,0xd6,0x92,0xbb,0x04,0x3c,0x5b,"CLSID_MSAAControl"); + IF_GUID_EQUAL_RETURN(guid,0xa9e69610,0xb80d,0x11d0,0xb9,0xb9,0x00,0xa0,0xc9,0x22,0xe7,0x50,"CLSID_MSAdminBase_W"); + IF_GUID_EQUAL_RETURN(guid,0xC8B522CBL,0x5CF3,0x11CE,0xAD,0xE5,0x00,0xAA,0x00,0x44,0x77,0x3D,"CLSID_MSDASQL"); + IF_GUID_EQUAL_RETURN(guid,0xC8B522CDL,0x5CF3,0x11CE,0xAD,0xE5,0x00,0xAA,0x00,0x44,0x77,0x3D,"CLSID_MSDASQL_ENUMERATOR"); + IF_GUID_EQUAL_RETURN(guid,0x178f34b8,0xa282,0x11d2,0x86,0xc5,0x0,0xc0,0x4f,0x8e,0xea,0x99,"CLSID_MSOButtons"); + IF_GUID_EQUAL_RETURN(guid,0x7D22E920,0x5CA9,0x4787,0x8C,0x2B,0xA6,0x77,0x9B,0xD1,0x17,0x81,"CLSID_MediaEncoderCategory"); + IF_GUID_EQUAL_RETURN(guid,0x236C9559,0xADCE,0x4736,0xBF,0x72,0xBA,0xB3,0x4E,0x39,0x21,0x96,"CLSID_MediaMultiplexerCategory"); + IF_GUID_EQUAL_RETURN(guid,0xcdbd8d00,0xc193,0x11d0,0xbd,0x4e,0x0,0xa0,0xc9,0x11,0xce,0x86,"CLSID_MediaPropertyBag"); + IF_GUID_EQUAL_RETURN(guid,0x1e651cc0,0xb199,0x11d0,0x82,0x12,0x00,0xc0,0x4f,0xc3,0x2c,0x45,"CLSID_MemoryAllocator"); + IF_GUID_EQUAL_RETURN(guid,0xe13ef4e4,0xd2f2,0x11d0,0x98,0x16,0x0,0xc0,0x4f,0xd9,0x19,0x72,"CLSID_MenuBandSite"); + IF_GUID_EQUAL_RETURN(guid,0x40b96610,0xb522,0x11d1,0xb3,0xb4,0x0,0xaa,0x0,0x6e,0xfd,0xe7,"CLSID_MenuToolbarBase"); + IF_GUID_EQUAL_RETURN(guid,0x4EfE2452,0x168A,0x11d1,0xBC,0x76,0x0,0xc0,0x4F,0xB9,0x45,0x3B,"CLSID_MidiRendererCategory"); + IF_GUID_EQUAL_RETURN(guid,0x301056d0,0x6dff,0x11d2,0x9e,0xeb,0x0,0x60,0x8,0x3,0x9e,0x37,"CLSID_MjpegDec"); + IF_GUID_EQUAL_RETURN(guid,0x0618aa30,0x6bc4,0x11cf,0xbf,0x36,0x00,0xaa,0x00,0x55,0x59,0x5a,"CLSID_ModexProperties"); + IF_GUID_EQUAL_RETURN(guid,0x7167665,0x5011,0x11cf,0xbf,0x33,0x0,0xaa,0x0,0x55,0x59,0x5a,"CLSID_ModexRenderer"); + IF_GUID_EQUAL_RETURN(guid,0x752845f1,0x758f,0x4c83,0xa0,0x43,0x42,0x70,0xc5,0x93,0x30,0x8e,"CLSID_Mpeg2TableFilter"); + IF_GUID_EQUAL_RETURN(guid,0x6cfad761,0x735d,0x4aa5,0x8a,0xfc,0xaf,0x91,0xa7,0xd6,0x1e,0xba,"CLSID_Mpeg2VideoStreamAnalyzer"); + IF_GUID_EQUAL_RETURN(guid,0x0ADDA830,0x2C26,0x11D2,0xAD,0x65,0x00,0xA0,0xC9,0xAF,0x11,0xA6,"CLSID_MsmMerge"); + IF_GUID_EQUAL_RETURN(guid,0xe9f4ebab,0xd97b,0x463e,0xa2,0xb1,0xc5,0x4e,0xe3,0xf9,0x41,0x4d,"CLSID_NetSchemePlugin"); + IF_GUID_EQUAL_RETURN(guid,0xb2f3a67c,0x29da,0x4c78,0x88,0x31,0x9,0x1e,0xd5,0x9,0xa4,0x75,"CLSID_NetworkProvider"); + IF_GUID_EQUAL_RETURN(guid,0xd969a300,0xe7ff,0x11d0,0xa9,0x3b,0x0,0xa0,0xc9,0xf,0x27,0x19,"CLSID_NewMenu"); + IF_GUID_EQUAL_RETURN(guid,0xcd8743a1,0x3736,0x11d0,0x9e,0x69,0x0,0xc0,0x4f,0xd7,0xc1,0x5b,"CLSID_OverlayMixer"); + IF_GUID_EQUAL_RETURN(guid,0xfd456373,0x3323,0x4090,0xad,0xca,0x8e,0xd4,0x5f,0x55,0xcf,0x10,"CLSID_PBDA_AUX_DATA_TYPE"); + IF_GUID_EQUAL_RETURN(guid,0x728fd6bc,0x5546,0x4716,0xb1,0x03,0xf8,0x99,0xf5,0xa1,0xfa,0x68,"CLSID_PBDA_Encoder_DATA_TYPE"); + IF_GUID_EQUAL_RETURN(guid,0xe7dbf9a0,0x22ab,0x4047,0x8e,0x67,0xef,0x9a,0xd5,0x4,0xe7,0x29,"CLSID_PBDA_FDC_DATA_TYPE"); + IF_GUID_EQUAL_RETURN(guid,0xC80C0DF3,0x6052,0x4c16,0x9F,0x56,0xC4,0x4C,0x21,0xF7,0x3C,0x45,"CLSID_PBDA_GDDS_DATA_TYPE"); + IF_GUID_EQUAL_RETURN(guid,0x9cd31617,0xb303,0x4f96,0x83,0x30,0x2e,0xb1,0x73,0xea,0x4d,0xc6,"CLSID_PTFilter"); + IF_GUID_EQUAL_RETURN(guid,0x59ce6880,0xacf8,0x11cf,0xb5,0x6e,0x00,0x80,0xc7,0xc4,0xb6,0x8a,"CLSID_PerformanceProperties"); + IF_GUID_EQUAL_RETURN(guid,0xe436ebb7,0x524f,0x11ce,0x9f,0x53,0x00,0x20,0xaf,0x0b,0xa7,0x70,"CLSID_PersistMonikerPID"); + IF_GUID_EQUAL_RETURN(guid,0xDA17539A,0x3DC3,0x42C1,0xA7,0x49,0xA1,0x83,0xB5,0x1F,0x08,0x5E,"CLSID_PlayToSourceClassFactory"); + IF_GUID_EQUAL_RETURN(guid,0xf8383852,0xfcd3,0x11d1,0xa6,0xb9,0x0,0x60,0x97,0xdf,0x5b,0xd4,"CLSID_ProgressDialog"); + IF_GUID_EQUAL_RETURN(guid,0xe436ebb0,0x524f,0x11ce,0x9f,0x53,0x00,0x20,0xaf,0x0b,0xa7,0x70,"CLSID_ProtoFilterGraph"); + IF_GUID_EQUAL_RETURN(guid,0xfdfe9681,0x74a3,0x11d0,0xaf,0xa7,0x0,0xaa,0x0,0xb6,0x7a,0x42,"CLSID_QTDec"); + IF_GUID_EQUAL_RETURN(guid,0x418afb70,0xf8b8,0x11ce,0xaa,0xc6,0x00,0x20,0xaf,0x0b,0x99,0xa3,"CLSID_QualityProperties"); + IF_GUID_EQUAL_RETURN(guid,0xa07034fd,0x6caa,0x4954,0xac,0x3f,0x97,0xa2,0x72,0x16,0xf9,0x8a,"CLSID_QueryAssociations"); + IF_GUID_EQUAL_RETURN(guid,0xe5cbf21,0xd15f,0x11d0,0x83,0x1,0x0,0xaa,0x0,0x5b,0x43,0x83,"CLSID_QuickLinks"); + IF_GUID_EQUAL_RETURN(guid,0xd51bd5a0,0x7548,0x11cf,0xa5,0x20,0x0,0x80,0xc7,0x7e,0xf5,0x8a,"CLSID_QuickTimeParser"); + IF_GUID_EQUAL_RETURN(guid,0x920c25d0,0x25d9,0x11d0,0xa5,0x5f,0x00,0xa0,0xc9,0x0c,0x20,0x91,"CLSID_Request"); + IF_GUID_EQUAL_RETURN(guid,0x46E19BA0,0x25DD,0x11D0,0xA5,0x5F,0x00,0xA0,0xC9,0x0C,0x20,0x91,"CLSID_Response"); + IF_GUID_EQUAL_RETURN(guid,0x93a094d7,0x51e8,0x485b,0x90,0x4a,0x8d,0x6b,0x97,0xdc,0x6b,0x39,"CLSID_SBE2File"); + IF_GUID_EQUAL_RETURN(guid,0x3e458037,0xca6,0x41aa,0xa5,0x94,0x2a,0xa6,0xc0,0x2d,0x70,0x9b,"CLSID_SBE2FileScan");; + IF_GUID_EQUAL_RETURN(guid,0x1f26a602,0x2b5c,0x4b63,0xb8,0xe8,0x9e,0xa5,0xc1,0xa7,0xdc,0x2e,"CLSID_SBE2MediaTypeProfile"); + IF_GUID_EQUAL_RETURN(guid,0xe2448508,0x95da,0x4205,0x9a,0x27,0x7e,0xc8,0x1e,0x72,0x3b,0x1a,"CLSID_SBE2Sink"); + IF_GUID_EQUAL_RETURN(guid,0xc7ff16cL,0x38e3,0x11d0,0x97,0xab,0x0,0xc0,0x4f,0xc2,0xad,0x98,"CLSID_SQLOLEDB"); + IF_GUID_EQUAL_RETURN(guid,0xdfa22b8eL,0xe68d,0x11d0,0x97,0xe4,0x0,0xc0,0x4f,0xc2,0xad,0x98,"CLSID_SQLOLEDB_ENUMERATOR"); + IF_GUID_EQUAL_RETURN(guid,0xc0932c62L,0x38e5,0x11d0,0x97,0xab,0x0,0xc0,0x4f,0xc2,0xad,0x98,"CLSID_SQLOLEDB_ERROR"); + IF_GUID_EQUAL_RETURN(guid,0xD97A6DA0,0xA868,0x11cf,0x83,0xAE,0x11,0xB0,0xC9,0x0C,0x2B,0xD8,"CLSID_ScriptingContext"); + IF_GUID_EQUAL_RETURN(guid,0x60af76c,0x68dd,0x11d0,0x8f,0xc1,0x0,0xc0,0x4f,0xd9,0x18,0x9d,"CLSID_SeekingPassThru"); + IF_GUID_EQUAL_RETURN(guid,0xA506D160,0x25E0,0x11D0,0xA5,0x5F,0x00,0xA0,0xC9,0x0C,0x20,0x91,"CLSID_Server"); + IF_GUID_EQUAL_RETURN(guid,0x509F8F20,0x25DE,0x11D0,0xA5,0x5F,0x00,0xA0,0xC9,0x0C,0x20,0x91,"CLSID_Session"); + IF_GUID_EQUAL_RETURN(guid,0x6D5313C0,0x8C62,0x11D1,0xB2,0xCD,0x00,0x60,0x97,0xDF,0x8C,0x11,"CLSID_ShellFldSetExt"); + IF_GUID_EQUAL_RETURN(guid,0xcc58e280,0x8aa1,0x11d1,0xb3,0xf1,0x0,0xaa,0x0,0x37,0x61,0xc5,"CLSID_SmartTee"); + IF_GUID_EQUAL_RETURN(guid,0x0CF32AA1,0x7571,0x11D0,0x93,0xC4,0x00,0xAA,0x00,0xA3,0xDD,0xEA,"CLSID_SourcePropPage"); + IF_GUID_EQUAL_RETURN(guid,0xB323F8E0L,0x2E68,0x11D0,0x90,0xEA,0x00,0xAA,0x00,0x60,0xF8,0x6C,"CLSID_Sti"); + IF_GUID_EQUAL_RETURN(guid,0xd682c4ba,0xa90a,0x42fe,0xb9,0xe1,0x3,0x10,0x98,0x49,0xc4,0x23,"CLSID_StreamBufferComposeRecording"); + IF_GUID_EQUAL_RETURN(guid,0xfa8a68b2,0xc864,0x4ba2,0xad,0x53,0xd3,0x87,0x6a,0x87,0x49,0x4b,"CLSID_StreamBufferConfig"); + IF_GUID_EQUAL_RETURN(guid,0xe37a73f8,0xfb01,0x43dc,0x91,0x4e,0xaa,0xee,0x76,0x9,0x5a,0xb9,"CLSID_StreamBufferPropertyHandler"); + IF_GUID_EQUAL_RETURN(guid,0xccaa63ac,0x1057,0x4778,0xae,0x92,0x12,0x6,0xab,0x9a,0xce,0xe6,"CLSID_StreamBufferRecordingAttributes"); + IF_GUID_EQUAL_RETURN(guid,0x2db47ae5,0xcf39,0x43c2,0xb4,0xd6,0xc,0xd8,0xd9,0x9,0x46,0xf4,"CLSID_StreamBufferSink"); + IF_GUID_EQUAL_RETURN(guid,0xc9f5fe02,0xf851,0x4eb5,0x99,0xee,0xad,0x60,0x2a,0xf1,0xe6,0x19,"CLSID_StreamBufferSource"); + IF_GUID_EQUAL_RETURN(guid,0x713790ee,0x5ee1,0x45ba,0x80,0x70,0xa1,0x33,0x7d,0x27,0x62,0xfa,"CLSID_StreamBufferThumbnailHandler"); + IF_GUID_EQUAL_RETURN(guid,0x72C97D74,0x7C3B,0x40AE,0xB7,0x7D,0xAB,0xDB,0x22,0xEB,0xA6,0xFB,"CLSID_StringCollection"); + IF_GUID_EQUAL_RETURN(guid,0x9f22cfea,0xce07,0x41ab,0x8b,0xa0,0xc7,0x36,0x4a,0xf9,0x0a,0xf9,"CLSID_SubtitlesFilter"); + IF_GUID_EQUAL_RETURN(guid,0xe436ebb1,0x524f,0x11ce,0x9f,0x53,0x00,0x20,0xaf,0x0b,0xa7,0x70,"CLSID_SystemClock"); + IF_GUID_EQUAL_RETURN(guid,0x62BE5D10,0x60EB,0x11d0,0xBD,0x3B,0x00,0xA0,0xC9,0x11,0xCE,0x86,"CLSID_SystemDeviceEnum"); + IF_GUID_EQUAL_RETURN(guid,0xC01B9BA0,0xBEA7,0x41BA,0xB6,0x04,0xD0,0xA3,0x6F,0x46,0x91,0x33,"CLSID_SystemInformation"); + IF_GUID_EQUAL_RETURN(guid,0x7f30578c,0x5f38,0x4612,0xac,0xfe,0x6e,0xd0,0x4c,0x7b,0x7a,0xf8,"CLSID_SystemMonitor2"); + IF_GUID_EQUAL_RETURN(guid,0xC4D2D8E0,0xD1DD,0x11ce,0x94,0x0F,0x00,0x80,0x29,0x00,0x43,0x47,"CLSID_SystemMonitor"); + IF_GUID_EQUAL_RETURN(guid,0x71f96463,0x78f3,0x11d0,0xa1,0x8c,0x0,0xa0,0xc9,0x11,0x89,0x56,"CLSID_TVAudioFilterPropertyPage"); + IF_GUID_EQUAL_RETURN(guid,0x05500282,0xFAA5,0x4DF9,0x82,0x46,0xBF,0xC2,0x3A,0xC5,0xCE,0xA8,"CLSID_TVEFilterCCProperties"); + IF_GUID_EQUAL_RETURN(guid,0x05500283,0xFAA5,0x4DF9,0x82,0x46,0xBF,0xC2,0x3A,0xC5,0xCE,0xA8,"CLSID_TVEFilterStatsProperties"); + IF_GUID_EQUAL_RETURN(guid,0x05500281,0xFAA5,0x4DF9,0x82,0x46,0xBF,0xC2,0x3A,0xC5,0xCE,0xA8,"CLSID_TVEFilterTuneProperties"); + IF_GUID_EQUAL_RETURN(guid,0x266eee41,0x6c63,0x11cf,0x8a,0x3,0x0,0xaa,0x0,0x6e,0xcb,0x65,"CLSID_TVTunerFilterPropertyPage"); + IF_GUID_EQUAL_RETURN(guid,0xe30629d3,0x27e5,0x11ce,0x87,0x5d,0x0,0x60,0x8c,0xb7,0x80,0x66,"CLSID_TextRender"); + IF_GUID_EQUAL_RETURN(guid,0x2ce4b5d8,0xa28f,0x11d2,0x86,0xc5,0x0,0xc0,0x4f,0x8e,0xea,0x99,"CLSID_ToolbarExtButtons"); + IF_GUID_EQUAL_RETURN(guid,0x7b40792d,0x05ff,0x44c4,0x90,0x58,0xf4,0x40,0xc7,0x1f,0x17,0xd4,"CLSID_TraceRelogger"); + IF_GUID_EQUAL_RETURN(guid,0xcc7bfb41,0xf175,0x11d1,0xa3,0x92,0x0,0xe0,0x29,0x1f,0x39,0x59,"CLSID_TransmitCategory"); + IF_GUID_EQUAL_RETURN(guid,0xB81FF171,0x20F3,0x11d2,0x8d,0xcc,0x00,0xa0,0xc9,0xb0,0x05,0x25,"CLSID_TypeNameFactory"); + IF_GUID_EQUAL_RETURN(guid,0x926749fa,0x2615,0x4987,0x88,0x45,0xc3,0x3e,0x65,0xf2,0xb9,0x57,"CLSID_UIRibbonFramework"); + IF_GUID_EQUAL_RETURN(guid,0x0f7434b6,0x59b6,0x4250,0x99,0x9e,0xd1,0x68,0xd6,0xae,0x42,0x93,"CLSID_UIRibbonImageFromBitmapFactory"); + IF_GUID_EQUAL_RETURN(guid,0xe436ebb6,0x524f,0x11ce,0x9f,0x53,0x00,0x20,0xaf,0x0b,0xa7,0x70,"CLSID_URLReader"); + IF_GUID_EQUAL_RETURN(guid,0x13639463,0x00DB,0x4646,0x80,0x3D,0x52,0x80,0x26,0x14,0x0D,0x88,"CLSID_UpdateCollection"); + IF_GUID_EQUAL_RETURN(guid,0x5BAF654A,0x5A07,0x4264,0xA2,0x55,0x9F,0xF5,0x4C,0x71,0x51,0xE7,"CLSID_UpdateDownloader"); + IF_GUID_EQUAL_RETURN(guid,0xD2E0FE7F,0xD23E,0x48E1,0x93,0xC0,0x6F,0xA8,0xCC,0x34,0x64,0x74,"CLSID_UpdateInstaller"); + IF_GUID_EQUAL_RETURN(guid,0xB699E5E8,0x67FF,0x4177,0x88,0xB0,0x36,0x84,0xA3,0x38,0x8B,0xFB,"CLSID_UpdateSearcher"); + IF_GUID_EQUAL_RETURN(guid,0xF8D253D9,0x89A4,0x4DAA,0x87,0xB6,0x11,0x68,0x36,0x9F,0x0B,0x21,"CLSID_UpdateServiceManager"); + IF_GUID_EQUAL_RETURN(guid,0x4CB43D7F,0x7EEE,0x4906,0x86,0x98,0x60,0xDA,0x1C,0x38,0xF2,0xFE,"CLSID_UpdateSession"); + IF_GUID_EQUAL_RETURN(guid,0x9ec4b4f9,0x3029,0x45ad,0x94,0x7b,0x34,0x4d,0xe2,0xa2,0x49,0xe2,"CLSID_UrlmonSchemePlugin"); + IF_GUID_EQUAL_RETURN(guid,0x814b9800,0x1c88,0x11d1,0xba,0xd9,0x0,0x60,0x97,0x44,0x11,0x1a,"CLSID_VBISurfaces"); + IF_GUID_EQUAL_RETURN(guid,0x6a91029e,0xaa49,0x471b,0xae,0xe7,0x7d,0x33,0x27,0x85,0x66,0x0d,"CLSID_VERSION_DEPENDENT_MSIME_JAPANESE"); + IF_GUID_EQUAL_RETURN(guid,0xce292861,0xfc88,0x11d0,0x9e,0x69,0x0,0xc0,0x4f,0xd7,0xc1,0x5b,"CLSID_VPObject"); + IF_GUID_EQUAL_RETURN(guid,0x814b9801,0x1c88,0x11d1,0xba,0xd9,0x0,0x60,0x97,0x44,0x11,0x1a,"CLSID_VPVBIObject"); + IF_GUID_EQUAL_RETURN(guid,0X9C38ED61,0xD565,0x4728,0xAE,0xEE,0xC8,0x09,0x52,0xF0,0xEC,0xDE,"CLSID_VdsLoader"); + IF_GUID_EQUAL_RETURN(guid,0x7D1933CB,0x86F6,0x4A98,0x86,0x28,0x01,0xBE,0x94,0xC9,0xA5,0x75,"CLSID_VdsService"); + IF_GUID_EQUAL_RETURN(guid,0xa10b5f17,0xafe0,0x4aa2,0x91,0xe9,0x3e,0x70,0x1,0xd2,0xe6,0xb4,"CLSID_VerticalIndicatorContent"); + IF_GUID_EQUAL_RETURN(guid,0x1b544c22,0xfd0b,0x11ce,0x8c,0x63,0x0,0xaa,0x00,0x44,0xb5,0x1e,"CLSID_VfwCapture"); + IF_GUID_EQUAL_RETURN(guid,0x33d9a760,0x90c8,0x11d0,0xbd,0x43,0x0,0xa0,0xc9,0x11,0xce,0x86,"CLSID_VideoCompressorCategory"); + IF_GUID_EQUAL_RETURN(guid,0x860BB310,0x5D01,0x11d0,0xBD,0x3B,0x00,0xA0,0xC9,0x11,0xCE,0x86,"CLSID_VideoInputDeviceCategory"); + IF_GUID_EQUAL_RETURN(guid,0x51b4abf3,0x748f,0x4e3b,0xa2,0x76,0xc8,0x28,0x33,0x0e,0x92,0x6a,"CLSID_VideoMixingRenderer9"); + IF_GUID_EQUAL_RETURN(guid,0xB87BEB7B,0x8D29,0x423f,0xAE,0x4D,0x65,0x82,0xC1,0x01,0x75,0xAC,"CLSID_VideoMixingRenderer"); + IF_GUID_EQUAL_RETURN(guid,0x6f26a6cd,0x967b,0x47fd,0x87,0x4a,0x7a,0xed,0x2c,0x9d,0x25,0xa2,"CLSID_VideoPortManager"); + IF_GUID_EQUAL_RETURN(guid,0x71f96464,0x78f3,0x11d0,0xa1,0x8c,0x0,0xa0,0xc9,0x11,0x89,0x56,"CLSID_VideoProcAmpPropertyPage"); + IF_GUID_EQUAL_RETURN(guid,0x70e102b0,0x5556,0x11ce,0x97,0xc0,0x00,0xaa,0x00,0x55,0x59,0x5a,"CLSID_VideoRenderer"); + IF_GUID_EQUAL_RETURN(guid,0x6BC1CFFA,0x8FC1,0x4261,0xAC,0x22,0xCF,0xB4,0xCC,0x38,0xDB,0x50,"CLSID_VideoRendererDefault"); + IF_GUID_EQUAL_RETURN(guid,0x71f96467,0x78f3,0x11d0,0xa1,0x8c,0x0,0xa0,0xc9,0x11,0x89,0x56,"CLSID_VideoStreamConfigPropertyPage"); + IF_GUID_EQUAL_RETURN(guid,0x3206a19a,0x86f0,0x4cb4,0xa7,0xf3,0x16,0xe3,0xb7,0xe2,0xd8,0x52,"CLSID_VirtualViewportContent"); + IF_GUID_EQUAL_RETURN(guid,0x02805F1E,0xD5AA,0x415b,0x82,0xC5,0x61,0xC0,0x33,0xA9,0x88,0xA6,"CLSID_WIC8BIMIPTCDigestMetadataReader"); + IF_GUID_EQUAL_RETURN(guid,0x2DB5E62B,0x0D67,0x495f,0x8F,0x9D,0xC2,0xF0,0x18,0x86,0x47,0xAC,"CLSID_WIC8BIMIPTCDigestMetadataWriter"); + IF_GUID_EQUAL_RETURN(guid,0x0010668c,0x0801,0x4da6,0xa4,0xa4,0x82,0x65,0x22,0xb6,0xd2,0x8f,"CLSID_WIC8BIMIPTCMetadataReader"); + IF_GUID_EQUAL_RETURN(guid,0x00108226,0xee41,0x44a2,0x9e,0x9c,0x4b,0xe4,0xd5,0xb1,0xd2,0xcd,"CLSID_WIC8BIMIPTCMetadataWriter"); + IF_GUID_EQUAL_RETURN(guid,0x5805137A,0xE348,0x4F7C,0xB3,0xCC,0x6D,0xB9,0x96,0x5A,0x05,0x99,"CLSID_WIC8BIMResolutionInfoMetadataReader"); + IF_GUID_EQUAL_RETURN(guid,0x4ff2fe0e,0xe74a,0x4b71,0x98,0xc4,0xab,0x7d,0xc1,0x67,0x7,0xba,"CLSID_WIC8BIMResolutionInfoMetadataWriter"); + IF_GUID_EQUAL_RETURN(guid,0x1767B93A,0xB021,0x44EA,0x92,0xF,0x86,0x3C,0x11,0xF4,0xF7,0x68,"CLSID_WICAPEMetadataReader"); + IF_GUID_EQUAL_RETURN(guid,0xBD6EDFCA,0x2890,0x482F,0xB2,0x33,0x8D,0x73,0x39,0xA1,0xCF,0x8D,"CLSID_WICAPEMetadataWriter"); + IF_GUID_EQUAL_RETURN(guid,0x43324B33,0xA78F,0x480f,0x91,0x11,0x96,0x38,0xAA,0xCC,0xC8,0x32,"CLSID_WICApp0MetadataReader"); + IF_GUID_EQUAL_RETURN(guid,0xF3C633A2,0x46C8,0x498e,0x8F,0xBB,0xCC,0x6F,0x72,0x1B,0xBC,0xDE,"CLSID_WICApp0MetadataWriter"); + IF_GUID_EQUAL_RETURN(guid,0xAA7E3C50,0x864C,0x4604,0xBC,0x04,0x8B,0x0B,0x76,0xE6,0x37,0xF6,"CLSID_WICApp13MetadataReader"); + IF_GUID_EQUAL_RETURN(guid,0x7B19A919,0xA9D6,0x49E5,0xBD,0x45,0x02,0xC3,0x4E,0x4E,0x4C,0xD5,"CLSID_WICApp13MetadataWriter"); + IF_GUID_EQUAL_RETURN(guid,0xdde33513,0x774e,0x4bcd,0xae,0x79,0x02,0xf4,0xad,0xfe,0x62,0xfc,"CLSID_WICApp1MetadataReader"); + IF_GUID_EQUAL_RETURN(guid,0xee366069,0x1832,0x420f,0xb3,0x81,0x04,0x79,0xad,0x06,0x6f,0x19,"CLSID_WICApp1MetadataWriter"); + IF_GUID_EQUAL_RETURN(guid,0x6b462062,0x7cbf,0x400d,0x9f,0xdb,0x81,0x3d,0xd1,0x0f,0x27,0x78,"CLSID_WICBmpDecoder"); + IF_GUID_EQUAL_RETURN(guid,0x69be8bb4,0xd66d,0x47c8,0x86,0x5a,0xed,0x15,0x89,0x43,0x37,0x82,"CLSID_WICBmpEncoder"); + IF_GUID_EQUAL_RETURN(guid,0x1a3f11dc,0xb514,0x4b17,0x8c,0x5f,0x21,0x54,0x51,0x38,0x52,0xf1,"CLSID_WICDefaultFormatConverter"); + IF_GUID_EQUAL_RETURN(guid,0xd9403860,0x297f,0x4a49,0xbf,0x9b,0x77,0x89,0x81,0x50,0xa4,0x42,"CLSID_WICExifMetadataReader"); + IF_GUID_EQUAL_RETURN(guid,0xc9a14cda,0xc339,0x460b,0x90,0x78,0xd4,0xde,0xbc,0xfa,0xbe,0x91,"CLSID_WICExifMetadataWriter"); + IF_GUID_EQUAL_RETURN(guid,0xac75d454,0x9f37,0x48f8,0xb9,0x72,0x4e,0x19,0xbc,0x85,0x60,0x11,"CLSID_WICFormatConverterHighColor"); + IF_GUID_EQUAL_RETURN(guid,0xc17cabb2,0xd4a3,0x47d7,0xa5,0x57,0x33,0x9b,0x2e,0xfb,0xd4,0xf1,"CLSID_WICFormatConverterNChannel"); + IF_GUID_EQUAL_RETURN(guid,0x9cb5172b,0xd600,0x46ba,0xab,0x77,0x77,0xbb,0x7e,0x3a,0x00,0xd9,"CLSID_WICFormatConverterWMPhoto"); + IF_GUID_EQUAL_RETURN(guid,0xB92E345D,0xF52D,0x41F3,0xB5,0x62,0x8,0x1B,0xC7,0x72,0xE3,0xB9,"CLSID_WICGCEMetadataReader"); + IF_GUID_EQUAL_RETURN(guid,0xAF95DC76,0x16B2,0x47F4,0xB3,0xEA,0x3C,0x31,0x79,0x66,0x93,0xE7,"CLSID_WICGCEMetadataWriter"); + IF_GUID_EQUAL_RETURN(guid,0x32557D3B,0x69DC,0x4F95,0x83,0x6E,0xF5,0x97,0x2B,0x2F,0x61,0x59,"CLSID_WICGifCommentMetadataReader"); + IF_GUID_EQUAL_RETURN(guid,0xA02797fC,0xC4AE,0x418C,0xAF,0x95,0xE6,0x37,0xC7,0xEA,0xD2,0xA1,"CLSID_WICGifCommentMetadataWriter"); + IF_GUID_EQUAL_RETURN(guid,0x381dda3c,0x9ce9,0x4834,0xa2,0x3e,0x1f,0x98,0xf8,0xfc,0x52,0xbe,"CLSID_WICGifDecoder"); + IF_GUID_EQUAL_RETURN(guid,0x114f5598,0x0b22,0x40a0,0x86,0xa1,0xc8,0x3e,0xa4,0x95,0xad,0xbd,"CLSID_WICGifEncoder"); + IF_GUID_EQUAL_RETURN(guid,0x3697790B,0x223B,0x484E,0x99,0x25,0xC4,0x86,0x92,0x18,0xF1,0x7A,"CLSID_WICGpsMetadataReader"); + IF_GUID_EQUAL_RETURN(guid,0xCB8C13E4,0x62B5,0x4C96,0xA4,0x8B,0x6B,0xA6,0xAC,0xE3,0x9C,0x76,"CLSID_WICGpsMetadataWriter"); + IF_GUID_EQUAL_RETURN(guid,0x7447A267,0x15,0x42C8,0xA8,0xF1,0xFB,0x3B,0x94,0xC6,0x83,0x61,"CLSID_WICIMDMetadataReader"); + IF_GUID_EQUAL_RETURN(guid,0x8C89071F,0x452E,0x4E95,0x96,0x82,0x9D,0x10,0x24,0x62,0x71,0x72,"CLSID_WICIMDMetadataWriter"); + IF_GUID_EQUAL_RETURN(guid,0x03012959,0xf4f6,0x44d7,0x9d,0x9,0xda,0xa0,0x87,0xa9,0xdb,0x57,"CLSID_WICIPTCMetadataReader"); + IF_GUID_EQUAL_RETURN(guid,0x1249b20c,0x5dd0,0x44fe,0xb0,0xb3,0x8f,0x92,0xc8,0xe6,0xd0,0x80,"CLSID_WICIPTCMetadataWriter"); + IF_GUID_EQUAL_RETURN(guid,0xD4DCD3D7,0xB4C2,0x47D9,0xA6,0xBF,0xB8,0x9B,0xA3,0x96,0xA4,0xA3,"CLSID_WICIRBMetadataReader"); + IF_GUID_EQUAL_RETURN(guid,0x5C5C1935,0x0235,0x4434,0x80,0xBC,0x25,0x1B,0xC1,0xEC,0x39,0xC6,"CLSID_WICIRBMetadataWriter"); + IF_GUID_EQUAL_RETURN(guid,0xc61bfcdf,0x2e0f,0x4aad,0xa8,0xd7,0xe0,0x6b,0xaf,0xeb,0xcd,0xfe,"CLSID_WICIcoDecoder"); + IF_GUID_EQUAL_RETURN(guid,0x8f914656,0x9d0a,0x4eb2,0x90,0x19,0xb,0xf9,0x6d,0x8a,0x9e,0xe6,"CLSID_WICIfdMetadataReader"); + IF_GUID_EQUAL_RETURN(guid,0xb1ebfc28,0xc9bd,0x47a2,0x8d,0x33,0xb9,0x48,0x76,0x97,0x77,0xa7,"CLSID_WICIfdMetadataWriter"); + IF_GUID_EQUAL_RETURN(guid,0xfae3d380,0xfea4,0x4623,0x8c,0x75,0xc6,0xb6,0x11,0x10,0xb6,0x81,"CLSID_WICImagingCategories"); + IF_GUID_EQUAL_RETURN(guid,0xcacaf262,0x9370,0x4615,0xa1,0x3b,0x9f,0x55,0x39,0xda,0x4c,0xa,"CLSID_WICImagingFactory1"); + IF_GUID_EQUAL_RETURN(guid,0x317d06e8,0x5f24,0x433d,0xbd,0xf7,0x79,0xce,0x68,0xd8,0xab,0xc2,"CLSID_WICImagingFactory2"); + IF_GUID_EQUAL_RETURN(guid,0xcacaf262,0x9370,0x4615,0xa1,0x3b,0x9f,0x55,0x39,0xda,0x4c,0xa,"CLSID_WICImagingFactory"); + IF_GUID_EQUAL_RETURN(guid,0xB5C8B898,0x0074,0x459F,0xB7,0x00,0x86,0x0D,0x46,0x51,0xEA,0x14,"CLSID_WICInteropMetadataReader"); + IF_GUID_EQUAL_RETURN(guid,0x122EC645,0xCD7E,0x44D8,0xB1,0x86,0x2C,0x8C,0x20,0xC3,0xB5,0x0F,"CLSID_WICInteropMetadataWriter"); + IF_GUID_EQUAL_RETURN(guid,0x50B1904B,0xF28F,0x4574,0x93,0xF4,0x0B,0xAD,0xE8,0x2C,0x69,0xE9,"CLSID_WICJpegChrominanceMetadataReader"); + IF_GUID_EQUAL_RETURN(guid,0x3FF566F0,0x6E6B,0x49D4,0x96,0xE6,0xB7,0x88,0x86,0x69,0x2C,0x62,"CLSID_WICJpegChrominanceMetadataWriter"); + IF_GUID_EQUAL_RETURN(guid,0x9f66347C,0x60C4,0x4C4D,0xAB,0x58,0xD2,0x35,0x86,0x85,0xf6,0x07,"CLSID_WICJpegCommentMetadataReader"); + IF_GUID_EQUAL_RETURN(guid,0xE573236F,0x55B1,0x4EDA,0x81,0xEA,0x9F,0x65,0xDB,0x02,0x90,0xD3,"CLSID_WICJpegCommentMetadataWriter"); + IF_GUID_EQUAL_RETURN(guid,0x9456a480,0xe88b,0x43ea,0x9e,0x73,0x0b,0x2d,0x9b,0x71,0xb1,0xca,"CLSID_WICJpegDecoder"); + IF_GUID_EQUAL_RETURN(guid,0x1a34f5c1,0x4a5a,0x46dc,0xb6,0x44,0x1f,0x45,0x67,0xe7,0xa6,0x76,"CLSID_WICJpegEncoder"); + IF_GUID_EQUAL_RETURN(guid,0x356F2F88,0x5A6,0x4728,0xB9,0xA4,0x1B,0xFB,0xCE,0x04,0xD8,0x38,"CLSID_WICJpegLuminanceMetadataReader"); + IF_GUID_EQUAL_RETURN(guid,0x1D583ABC,0x8A0E,0x4657,0x99,0x82,0xA3,0x80,0xCA,0x58,0xFB,0x4B,"CLSID_WICJpegLuminanceMetadataWriter"); + IF_GUID_EQUAL_RETURN(guid,0x41070793,0x59E4,0x479A,0xA1,0xF7,0x95,0x4A,0xDC,0x2E,0xF5,0xFC,"CLSID_WICLSDMetadataReader"); + IF_GUID_EQUAL_RETURN(guid,0x73C037E7,0xE5D9,0x4954,0x87,0x6A,0x6D,0xA8,0x1D,0x6E,0x57,0x68,"CLSID_WICLSDMetadataWriter"); + IF_GUID_EQUAL_RETURN(guid,0xCE7A4A6,0x3E8,0x4A60,0x9D,0x15,0x28,0x2E,0xF3,0x2E,0xE7,0xDA,"CLSID_WICPngBkgdMetadataReader"); + IF_GUID_EQUAL_RETURN(guid,0x68E3F2FD,0x31AE,0x4441,0xBB,0x6A,0xFD,0x70,0x47,0x52,0x5F,0x90,"CLSID_WICPngBkgdMetadataWriter"); + IF_GUID_EQUAL_RETURN(guid,0xF90B5F36,0x367B,0x402A,0x9D,0xD1,0xBC,0xF,0xD5,0x9D,0x8F,0x62,"CLSID_WICPngChrmMetadataReader"); + IF_GUID_EQUAL_RETURN(guid,0xE23CE3EB,0x5608,0x4E83,0xBC,0xEF,0x27,0xB1,0x98,0x7E,0x51,0xD7,"CLSID_WICPngChrmMetadataWriter"); + IF_GUID_EQUAL_RETURN(guid,0x389ea17b,0x5078,0x4cde,0xb6,0xef,0x25,0xc1,0x51,0x75,0xc7,0x51,"CLSID_WICPngDecoder1"); + IF_GUID_EQUAL_RETURN(guid,0xe018945b,0xaa86,0x4008,0x9b,0xd4,0x67,0x77,0xa1,0xe4,0x0c,0x11,"CLSID_WICPngDecoder2"); + IF_GUID_EQUAL_RETURN(guid,0x389ea17b,0x5078,0x4cde,0xb6,0xef,0x25,0xc1,0x51,0x75,0xc7,0x51,"CLSID_WICPngDecoder"); + IF_GUID_EQUAL_RETURN(guid,0x27949969,0x876a,0x41d7,0x94,0x47,0x56,0x8f,0x6a,0x35,0xa4,0xdc,"CLSID_WICPngEncoder"); + IF_GUID_EQUAL_RETURN(guid,0x3692CA39,0xE082,0x4350,0x9E,0x1F,0x37,0x4,0xCB,0x8,0x3C,0xD5,"CLSID_WICPngGamaMetadataReader"); + IF_GUID_EQUAL_RETURN(guid,0xFF036D13,0x5D4B,0x46DD,0xB1,0xF,0x10,0x66,0x93,0xD9,0xFE,0x4F,"CLSID_WICPngGamaMetadataWriter"); + IF_GUID_EQUAL_RETURN(guid,0x877A0BB7,0xA313,0x4491,0x87,0xB5,0x2E,0x6D,0x5,0x94,0xF5,0x20,"CLSID_WICPngHistMetadataReader"); + IF_GUID_EQUAL_RETURN(guid,0x8A03E749,0x672E,0x446E,0xBF,0x1F,0x2C,0x11,0xD2,0x33,0xB6,0xFF,"CLSID_WICPngHistMetadataWriter"); + IF_GUID_EQUAL_RETURN(guid,0xF5D3E63B,0xCB0F,0x4628,0xA4,0x78,0x6D,0x82,0x44,0xBE,0x36,0xB1,"CLSID_WICPngIccpMetadataReader"); + IF_GUID_EQUAL_RETURN(guid,0x16671E5F,0xCE6,0x4CC4,0x97,0x68,0xE8,0x9F,0xE5,0x1,0x8A,0xDE,"CLSID_WICPngIccpMetadataWriter"); + IF_GUID_EQUAL_RETURN(guid,0xAABFB2FA,0x3E1E,0x4A8F,0x89,0x77,0x55,0x56,0xFB,0x94,0xEA,0x23,"CLSID_WICPngItxtMetadataReader"); + IF_GUID_EQUAL_RETURN(guid,0x31879719,0xE751,0x4DF8,0x98,0x1D,0x68,0xDF,0xF6,0x77,0x4,0xED,"CLSID_WICPngItxtMetadataWriter"); + IF_GUID_EQUAL_RETURN(guid,0xFB40360C,0x547E,0x4956,0xA3,0xB9,0xD4,0x41,0x88,0x59,0xBA,0x66,"CLSID_WICPngSrgbMetadataReader"); + IF_GUID_EQUAL_RETURN(guid,0xA6EE35C6,0x87EC,0x47DF,0x9F,0x22,0x1D,0x5A,0xAD,0x84,0xC,0x82,"CLSID_WICPngSrgbMetadataWriter"); + IF_GUID_EQUAL_RETURN(guid,0x4b59afcc,0xb8c3,0x408a,0xb6,0x70,0x89,0xe5,0xfa,0xb6,0xfd,0xa7,"CLSID_WICPngTextMetadataReader"); + IF_GUID_EQUAL_RETURN(guid,0xb5ebafb9,0x253e,0x4a72,0xa7,0x44,0x7,0x62,0xd2,0x68,0x56,0x83,"CLSID_WICPngTextMetadataWriter"); + IF_GUID_EQUAL_RETURN(guid,0xD94EDF02,0xEFE5,0x4F0D,0x85,0xC8,0xF5,0xA6,0x8B,0x30,0x0,0xB1,"CLSID_WICPngTimeMetadataReader"); + IF_GUID_EQUAL_RETURN(guid,0x1AB78400,0xB5A3,0x4D91,0x8A,0xCE,0x33,0xFC,0xD1,0x49,0x9B,0xE6,"CLSID_WICPngTimeMetadataWriter"); + IF_GUID_EQUAL_RETURN(guid,0x50D42F09,0xECD1,0x4B41,0xB6,0x5D,0xDA,0x1F,0xDA,0xA7,0x56,0x63,"CLSID_WICSubIfdMetadataReader"); + IF_GUID_EQUAL_RETURN(guid,0x8ADE5386,0x8E9B,0x4F4C,0xAC,0xF2,0xF0,0x00,0x87,0x06,0xB2,0x38,"CLSID_WICSubIfdMetadataWriter"); + IF_GUID_EQUAL_RETURN(guid,0xfb012959,0xf4f6,0x44d7,0x9d,0x9,0xda,0xa0,0x87,0xa9,0xdb,0x57,"CLSID_WICThumbnailMetadataReader"); + IF_GUID_EQUAL_RETURN(guid,0xd049b20c,0x5dd0,0x44fe,0xb0,0xb3,0x8f,0x92,0xc8,0xe6,0xd0,0x80,"CLSID_WICThumbnailMetadataWriter"); + IF_GUID_EQUAL_RETURN(guid,0xb54e85d9,0xfe23,0x499f,0x8b,0x88,0x6a,0xce,0xa7,0x13,0x75,0x2b,"CLSID_WICTiffDecoder"); + IF_GUID_EQUAL_RETURN(guid,0x0131be10,0x2001,0x4c5f,0xa9,0xb0,0xcc,0x88,0xfa,0xb6,0x4c,0xe8,"CLSID_WICTiffEncoder"); + IF_GUID_EQUAL_RETURN(guid,0x699745c2,0x5066,0x4b82,0xa8,0xe3,0xd4,0x4,0x78,0xdb,0xec,0x8c,"CLSID_WICUnknownMetadataReader"); + IF_GUID_EQUAL_RETURN(guid,0xa09cca86,0x27ba,0x4f39,0x90,0x53,0x12,0x1f,0xa4,0xdc,0x8,0xfc,"CLSID_WICUnknownMetadataWriter"); + IF_GUID_EQUAL_RETURN(guid,0xa26cec36,0x234c,0x4950,0xae,0x16,0xe3,0x4a,0xac,0xe7,0x1d,0x0d,"CLSID_WICWmpDecoder"); + IF_GUID_EQUAL_RETURN(guid,0xac4ce3cb,0xe1c1,0x44cd,0x82,0x15,0x5a,0x16,0x65,0x50,0x9e,0xc2,"CLSID_WICWmpEncoder"); + IF_GUID_EQUAL_RETURN(guid,0xAA94DCC2,0xB8B0,0x4898,0xB8,0x35,0x00,0x0A,0xAB,0xD7,0x43,0x93,"CLSID_WICXMPAltMetadataReader"); + IF_GUID_EQUAL_RETURN(guid,0x076C2A6C,0xF78F,0x4C46,0xA7,0x23,0x35,0x83,0xE7,0x08,0x76,0xEA,"CLSID_WICXMPAltMetadataWriter"); + IF_GUID_EQUAL_RETURN(guid,0xE7E79A30,0x4F2C,0x4FAB,0x8D,0x00,0x39,0x4F,0x2D,0x6B,0xBE,0xBE,"CLSID_WICXMPBagMetadataReader"); + IF_GUID_EQUAL_RETURN(guid,0xED822C8C,0xD6BE,0x4301,0xA6,0x31,0x0E,0x14,0x16,0xBA,0xD2,0x8F,"CLSID_WICXMPBagMetadataWriter"); + IF_GUID_EQUAL_RETURN(guid,0x72B624DF,0xAE11,0x4948,0xA6,0x5C,0x35,0x1E,0xB0,0x82,0x94,0x19,"CLSID_WICXMPMetadataReader"); + IF_GUID_EQUAL_RETURN(guid,0x1765E14E,0x1BD4,0x462E,0xB6,0xB1,0x59,0x0B,0xF1,0x26,0x2A,0xC6,"CLSID_WICXMPMetadataWriter"); + IF_GUID_EQUAL_RETURN(guid,0x7F12E753,0xFC71,0x43D7,0xA5,0x1D,0x92,0xF3,0x59,0x77,0xAB,0xB5,"CLSID_WICXMPSeqMetadataReader"); + IF_GUID_EQUAL_RETURN(guid,0x6D68D1DE,0xD432,0x4B0F,0x92,0x3A,0x09,0x11,0x83,0xA9,0xBD,0xA7,"CLSID_WICXMPSeqMetadataWriter"); + IF_GUID_EQUAL_RETURN(guid,0x01B90D9A,0x8209,0x47F7,0x9C,0x52,0xE1,0x24,0x4B,0xF5,0x0C,0xED,"CLSID_WICXMPStructMetadataReader"); + IF_GUID_EQUAL_RETURN(guid,0x22C21F93,0x7DDB,0x411C,0x9B,0x17,0xC5,0xB7,0xBD,0x06,0x4A,0xBC,"CLSID_WICXMPStructMetadataWriter"); + IF_GUID_EQUAL_RETURN(guid,0x187463a0,0x5bb7,0x11d3,0xac,0xbe,0x0,0x80,0xc7,0x5e,0x24,0x6e,"CLSID_WMAsfReader"); + IF_GUID_EQUAL_RETURN(guid,0x7c23220e,0x55bb,0x11d3,0x8b,0x16,0x0,0xc0,0x4f,0xb6,0xbd,0x3d,"CLSID_WMAsfWriter"); + IF_GUID_EQUAL_RETURN(guid,0xaf6060aa,0x5197,0x11d2,0xb6,0xaf,0x00,0xc0,0x4f,0xd9,0x08,0xe9,"CLSID_WMBandwidthSharing_Exclusive"); + IF_GUID_EQUAL_RETURN(guid,0xaf6060ab,0x5197,0x11d2,0xb6,0xaf,0x00,0xc0,0x4f,0xd9,0x08,0xe9,"CLSID_WMBandwidthSharing_Partial"); + IF_GUID_EQUAL_RETURN(guid,0x8948BB22,0x11BD,0x4796,0x93,0xE3,0x97,0x4D,0x1B,0x57,0x56,0x78,"CLSID_WMDRMSystemID"); + IF_GUID_EQUAL_RETURN(guid,0xD6E22A01,0x35DA,0x11D1,0x90,0x34,0x00,0xA0,0xC9,0x03,0x49,0xBE,"CLSID_WMMUTEX_Bitrate"); + IF_GUID_EQUAL_RETURN(guid,0xD6E22A00,0x35DA,0x11D1,0x90,0x34,0x00,0xA0,0xC9,0x03,0x49,0xBE,"CLSID_WMMUTEX_Language"); + IF_GUID_EQUAL_RETURN(guid,0xD6E22A02,0x35DA,0x11D1,0x90,0x34,0x00,0xA0,0xC9,0x03,0x49,0xBE,"CLSID_WMMUTEX_Presentation"); + IF_GUID_EQUAL_RETURN(guid,0xD6E22A03,0x35DA,0x11D1,0x90,0x34,0x00,0xA0,0xC9,0x03,0x49,0xBE,"CLSID_WMMUTEX_Unknown"); + IF_GUID_EQUAL_RETURN(guid,0x5569e7f5,0x424b,0x4b93,0x89,0xca,0x79,0xd1,0x79,0x24,0x68,0x9a,"CLSID_WMPMediaPluginRegistrar"); + IF_GUID_EQUAL_RETURN(guid,0xB2A7FD52,0x301F,0x4348,0xB9,0x3A,0x63,0x8C,0x6D,0xE4,0x92,0x29,"CLSID_WMPSkinManager"); + IF_GUID_EQUAL_RETURN(guid,0x70bc06e0,0x5666,0x11d3,0xa1,0x84,0x0,0x10,0x5a,0xef,0x9f,0x33,"CLSID_WSTDecoder"); + IF_GUID_EQUAL_RETURN(guid,0x61738644,0xF196,0x11D0,0x99,0x53,0x00,0xC0,0x4F,0xD9,0x19,0xC1,"CLSID_WamAdmin"); + IF_GUID_EQUAL_RETURN(guid,0x650503cf,0x9108,0x4ddc,0xa2,0xce,0x6c,0x23,0x41,0xe1,0xc5,0x82,"CLSID_WebProxy"); + IF_GUID_EQUAL_RETURN(guid,0xD4F4D30B,0x0B29,0x4508,0x89,0x22,0x0C,0x57,0x97,0xD4,0x27,0x65,"CLSID_WiaDefaultSegFilter"); + IF_GUID_EQUAL_RETURN(guid,0xC2E88C2F,0x6F5B,0x4AAA,0x89,0x4B,0x55,0xC8,0x47,0xAD,0x3A,0x2D,"CLSID_WindowsUpdateAgentInfo"); + IF_GUID_EQUAL_RETURN(guid,0x4e27f80,0x91e4,0x11d3,0xa1,0x84,0x0,0x10,0x5a,0xef,0x9f,0x33,"CLSID_WstDecoderPropertyPage"); + IF_GUID_EQUAL_RETURN(guid,0xC4C4C483,0x0049,0x4E2B,0x98,0xFB,0x95,0x37,0xF6,0xCE,0x51,0x6D,"CLSID_XDSCodecProperties"); + IF_GUID_EQUAL_RETURN(guid,0xC4C4C493,0x0049,0x4E2B,0x98,0xFB,0x95,0x37,0xF6,0xCE,0x51,0x6D,"CLSID_XDSCodecTagProperties"); + IF_GUID_EQUAL_RETURN(guid,0xfe6b11c3,0xc72e,0x4061,0x86,0xc6,0x9d,0x16,0x31,0x21,0xf2,0x29,"CLSID_XFeedsManager"); + IF_GUID_EQUAL_RETURN(guid,0x6a577e92,0x83e1,0x4113,0xad,0xc2,0x4f,0xce,0xc3,0x2f,0x83,0xa1,"CODECAPI_ALLSETTINGS"); + IF_GUID_EQUAL_RETURN(guid,0xb9d19a3e,0xf897,0x429c,0xbc,0x46,0x81,0x38,0xb7,0x27,0x2b,0x2d,"CODECAPI_AUDIO_ENCODER"); + IF_GUID_EQUAL_RETURN(guid,0x17f89cb3,0xc38d,0x4368,0x9e,0xde,0x63,0xb9,0x4d,0x17,0x7f,0x9f,"CODECAPI_AVAudioChannelConfig"); + IF_GUID_EQUAL_RETURN(guid,0x1d3583c4,0x1583,0x474e,0xb7,0x1a,0x5e,0xe4,0x63,0xc1,0x98,0xe4,"CODECAPI_AVAudioChannelCount"); + IF_GUID_EQUAL_RETURN(guid,0x971d2723,0x1acb,0x42e7,0x85,0x5c,0x52,0x0a,0x4b,0x70,0xa5,0xf2,"CODECAPI_AVAudioSampleRate"); + IF_GUID_EQUAL_RETURN(guid,0x99f2f386,0x98d1,0x4452,0xa1,0x63,0xab,0xc7,0x8a,0x6e,0xb7,0x70,"CODECAPI_AVDDSurroundMode"); + IF_GUID_EQUAL_RETURN(guid,0x8afd1a15,0x1812,0x4cbf,0x93,0x19,0x43,0x3a,0x5b,0x2a,0x3b,0x27,"CODECAPI_AVDSPLoudnessEqualization"); + IF_GUID_EQUAL_RETURN(guid,0x5612bca1,0x56da,0x4582,0x8d,0xa1,0xca,0x80,0x90,0xf9,0x27,0x68,"CODECAPI_AVDSPSpeakerFill"); + IF_GUID_EQUAL_RETURN(guid,0x1274475,0xf6bb,0x4017,0xb0,0x84,0x81,0xa7,0x63,0xc9,0x42,0xd4,"CODECAPI_AVDecAACDownmixMode"); + IF_GUID_EQUAL_RETURN(guid,0x4a52cda8,0x30f8,0x4216,0xbe,0x0f,0xba,0x0b,0x20,0x25,0x92,0x1d,"CODECAPI_AVDecAudioDualMono"); + IF_GUID_EQUAL_RETURN(guid,0xa5106186,0xcc94,0x4bc9,0x8c,0xd9,0xaa,0x2f,0x61,0xf6,0x80,0x7e,"CODECAPI_AVDecAudioDualMonoReproMode"); + IF_GUID_EQUAL_RETURN(guid,0xe5005239,0xbd89,0x4be3,0x9c,0x0f,0x5d,0xde,0x31,0x79,0x88,0xcc,"CODECAPI_AVDecCommonInputFormat"); + IF_GUID_EQUAL_RETURN(guid,0x59488217,0x007a,0x4f7a,0x8e,0x41,0x5c,0x48,0xb1,0xea,0xc5,0xc6,"CODECAPI_AVDecCommonMeanBitRate"); + IF_GUID_EQUAL_RETURN(guid,0x0ee437c6,0x38a7,0x4c5c,0x94,0x4c,0x68,0xab,0x42,0x11,0x6b,0x85,"CODECAPI_AVDecCommonMeanBitRateInterval"); + IF_GUID_EQUAL_RETURN(guid,0x3c790028,0xc0ce,0x4256,0xb1,0xa2,0x1b,0x0f,0xc8,0xb1,0xdc,0xdc,"CODECAPI_AVDecCommonOutputFormat"); + IF_GUID_EQUAL_RETURN(guid,0x50196c21,0x1f33,0x4af5,0xb2,0x96,0x11,0x42,0x6d,0x6c,0x87,0x89,"CODECAPI_AVDecDDDynamicRangeScaleHigh"); + IF_GUID_EQUAL_RETURN(guid,0x044e62e4,0x11a5,0x42d5,0xa3,0xb2,0x3b,0xb2,0xc7,0xc2,0xd7,0xcf,"CODECAPI_AVDecDDDynamicRangeScaleLow"); + IF_GUID_EQUAL_RETURN(guid,0xddc811a5,0x04ed,0x4bf3,0xa0,0xca,0xd0,0x04,0x49,0xf9,0x35,0x5f,"CODECAPI_AVDecDDMatrixDecodingMode"); + IF_GUID_EQUAL_RETURN(guid,0xd6d6c6d1,0x064e,0x4fdd,0xa4,0x0e,0x3e,0xcb,0xfc,0xb7,0xeb,0xd0,"CODECAPI_AVDecDDOperationalMode"); + IF_GUID_EQUAL_RETURN(guid,0x6ce4122c,0x3ee9,0x4182,0xb4,0xae,0xc1,0x0f,0xc0,0x88,0x64,0x9d,"CODECAPI_AVDecDDStereoDownMixMode"); + IF_GUID_EQUAL_RETURN(guid,0x287c8abe,0x69a4,0x4d39,0x80,0x80,0xd3,0xd9,0x71,0x21,0x78,0xa0,"CODECAPI_AVDecHEAACDynamicRangeControl");; + IF_GUID_EQUAL_RETURN(guid,0xe0ad4828,0xdf66,0x4893,0x9f,0x33,0x78,0x8a,0xa4,0xec,0x40,0x82,"CODECAPI_AVDecMmcssClass"); + IF_GUID_EQUAL_RETURN(guid,0x9561c3e8,0xea9e,0x4435,0x9b,0x1e,0xa9,0x3e,0x69,0x18,0x94,0xd8,"CODECAPI_AVDecNumWorkerThreads"); + IF_GUID_EQUAL_RETURN(guid,0x862e2f0a,0x507b,0x47ff,0xaf,0x47,0x1,0xe2,0x62,0x42,0x98,0xb7,"CODECAPI_AVDecSoftwareDynamicFormatChange"); + IF_GUID_EQUAL_RETURN(guid,0xf7db8a2f,0x4f48,0x4ee8,0xae,0x31,0x8b,0x6e,0xbe,0x55,0x8a,0xe2,"CODECAPI_AVDecVideoAcceleration_H264"); + IF_GUID_EQUAL_RETURN(guid,0xf7db8a2e,0x4f48,0x4ee8,0xae,0x31,0x8b,0x6e,0xbe,0x55,0x8a,0xe2,"CODECAPI_AVDecVideoAcceleration_MPEG2"); + IF_GUID_EQUAL_RETURN(guid,0xf7db8a30,0x4f48,0x4ee8,0xae,0x31,0x8b,0x6e,0xbe,0x55,0x8a,0xe2,"CODECAPI_AVDecVideoAcceleration_VC1"); + IF_GUID_EQUAL_RETURN(guid,0x434528e5,0x21f0,0x46b6,0xb6,0x2c,0x9b,0x1b,0x6b,0x65,0x8c,0xd1,"CODECAPI_AVDecVideoCodecType");; + IF_GUID_EQUAL_RETURN(guid,0x42153c8b,0xfd0b,0x4765,0xa4,0x62,0xdd,0xd9,0xe8,0xbc,0xc3,0x88,"CODECAPI_AVDecVideoDXVABusEncryption");; + IF_GUID_EQUAL_RETURN(guid,0xf758f09e,0x7337,0x4ae7,0x83,0x87,0x73,0xdc,0x2d,0x54,0xe6,0x7d,"CODECAPI_AVDecVideoDXVAMode");; + IF_GUID_EQUAL_RETURN(guid,0xf8226383,0x14c2,0x4567,0x97,0x34,0x50,0x4,0xe9,0x6f,0xf8,0x87,"CODECAPI_AVDecVideoDropPicWithMissingRef"); + IF_GUID_EQUAL_RETURN(guid,0x6b529f7d,0xd3b1,0x49c6,0xa9,0x99,0x9e,0xc6,0x91,0x1b,0xed,0xbf,"CODECAPI_AVDecVideoFastDecodeMode");; + IF_GUID_EQUAL_RETURN(guid,0xececace8,0x3436,0x462c,0x92,0x94,0xcd,0x7b,0xac,0xd7,0x58,0xa9,"CODECAPI_AVDecVideoH264ErrorConcealment"); + IF_GUID_EQUAL_RETURN(guid,0x5ee5747c,0x6801,0x4cab,0xaa,0xf1,0x62,0x48,0xfa,0x84,0x1b,0xa4,"CODECAPI_AVDecVideoImageSize"); + IF_GUID_EQUAL_RETURN(guid,0x38477e1f,0x0ea7,0x42cd,0x8c,0xd1,0x13,0x0c,0xed,0x57,0xc5,0x80,"CODECAPI_AVDecVideoInputScanType"); + IF_GUID_EQUAL_RETURN(guid,0x9d2bfe18,0x728d,0x48d2,0xb3,0x58,0xbc,0x7e,0x43,0x6c,0x66,0x74,"CODECAPI_AVDecVideoMPEG2ErrorConcealment"); + IF_GUID_EQUAL_RETURN(guid,0x7262a16a,0xd2dc,0x4e75,0x9b,0xa8,0x65,0xc0,0xc6,0xd3,0x2b,0x13,"CODECAPI_AVDecVideoMaxCodedHeight"); + IF_GUID_EQUAL_RETURN(guid,0x5ae557b8,0x77af,0x41f5,0x9f,0xa6,0x4d,0xb2,0xfe,0x1d,0x4b,0xca,"CODECAPI_AVDecVideoMaxCodedWidth"); + IF_GUID_EQUAL_RETURN(guid,0xb0cf8245,0xf32d,0x41df,0xb0,0x2c,0x87,0xbd,0x30,0x4d,0x12,0xab,"CODECAPI_AVDecVideoPixelAspectRatio"); + IF_GUID_EQUAL_RETURN(guid,0xf7db8a31,0x4f48,0x4ee8,0xae,0x31,0x8b,0x6e,0xbe,0x55,0x8a,0xe2,"CODECAPI_AVDecVideoProcDeinterlaceCSC"); + IF_GUID_EQUAL_RETURN(guid,0xfb5d2347,0x4dd8,0x4509,0xae,0xd0,0xdb,0x5f,0xa9,0xaa,0x93,0xf4,"CODECAPI_AVDecVideoSWPowerLevel"); + IF_GUID_EQUAL_RETURN(guid,0x0c08d1ce,0x9ced,0x4540,0xba,0xe3,0xce,0xb3,0x80,0x14,0x11,0x09,"CODECAPI_AVDecVideoSoftwareDeinterlaceMode");; + IF_GUID_EQUAL_RETURN(guid,0x2efd8eee,0x1150,0x4328,0x9c,0xf5,0x66,0xdc,0xe9,0x33,0xfc,0xf4,"CODECAPI_AVDecVideoThumbnailGenerationMode"); + IF_GUID_EQUAL_RETURN(guid,0x4419b185,0xda1f,0x4f53,0xbc,0x76,0x9,0x7d,0xc,0x1e,0xfb,0x1e,"CODECAPI_AVEncAdaptiveMode"); + IF_GUID_EQUAL_RETURN(guid,0x3648126b,0xa3e8,0x4329,0x9b,0x3a,0x5c,0xe5,0x66,0xa4,0x3b,0xd3,"CODECAPI_AVEncAudioDualMono"); + IF_GUID_EQUAL_RETURN(guid,0x3e226c2b,0x60b9,0x4a39,0xb0,0x0b,0xa7,0xb4,0x0f,0x70,0xd5,0x66,"CODECAPI_AVEncAudioInputContent"); + IF_GUID_EQUAL_RETURN(guid,0x866e4b4d,0x725a,0x467c,0xbb,0x01,0xb4,0x96,0xb2,0x3b,0x25,0xf9,"CODECAPI_AVEncAudioIntervalToEncode"); + IF_GUID_EQUAL_RETURN(guid,0x88c15f94,0xc38c,0x4796,0xa9,0xe8,0x96,0xe9,0x67,0x98,0x3f,0x26,"CODECAPI_AVEncAudioIntervalToSkip"); + IF_GUID_EQUAL_RETURN(guid,0xbc5d0b60,0xdf6a,0x4e16,0x98,0x03,0xb8,0x20,0x07,0xa3,0x0c,0x8d,"CODECAPI_AVEncAudioMapDestChannel0"); + IF_GUID_EQUAL_RETURN(guid,0xbc5d0b6a,0xdf6a,0x4e16,0x98,0x03,0xb8,0x20,0x07,0xa3,0x0c,0x8d,"CODECAPI_AVEncAudioMapDestChannel10"); + IF_GUID_EQUAL_RETURN(guid,0xbc5d0b6b,0xdf6a,0x4e16,0x98,0x03,0xb8,0x20,0x07,0xa3,0x0c,0x8d,"CODECAPI_AVEncAudioMapDestChannel11"); + IF_GUID_EQUAL_RETURN(guid,0xbc5d0b6c,0xdf6a,0x4e16,0x98,0x03,0xb8,0x20,0x07,0xa3,0x0c,0x8d,"CODECAPI_AVEncAudioMapDestChannel12"); + IF_GUID_EQUAL_RETURN(guid,0xbc5d0b6d,0xdf6a,0x4e16,0x98,0x03,0xb8,0x20,0x07,0xa3,0x0c,0x8d,"CODECAPI_AVEncAudioMapDestChannel13"); + IF_GUID_EQUAL_RETURN(guid,0xbc5d0b6e,0xdf6a,0x4e16,0x98,0x03,0xb8,0x20,0x07,0xa3,0x0c,0x8d,"CODECAPI_AVEncAudioMapDestChannel14"); + IF_GUID_EQUAL_RETURN(guid,0xbc5d0b6f,0xdf6a,0x4e16,0x98,0x03,0xb8,0x20,0x07,0xa3,0x0c,0x8d,"CODECAPI_AVEncAudioMapDestChannel15"); + IF_GUID_EQUAL_RETURN(guid,0xbc5d0b61,0xdf6a,0x4e16,0x98,0x03,0xb8,0x20,0x07,0xa3,0x0c,0x8d,"CODECAPI_AVEncAudioMapDestChannel1"); + IF_GUID_EQUAL_RETURN(guid,0xbc5d0b62,0xdf6a,0x4e16,0x98,0x03,0xb8,0x20,0x07,0xa3,0x0c,0x8d,"CODECAPI_AVEncAudioMapDestChannel2"); + IF_GUID_EQUAL_RETURN(guid,0xbc5d0b63,0xdf6a,0x4e16,0x98,0x03,0xb8,0x20,0x07,0xa3,0x0c,0x8d,"CODECAPI_AVEncAudioMapDestChannel3"); + IF_GUID_EQUAL_RETURN(guid,0xbc5d0b64,0xdf6a,0x4e16,0x98,0x03,0xb8,0x20,0x07,0xa3,0x0c,0x8d,"CODECAPI_AVEncAudioMapDestChannel4"); + IF_GUID_EQUAL_RETURN(guid,0xbc5d0b65,0xdf6a,0x4e16,0x98,0x03,0xb8,0x20,0x07,0xa3,0x0c,0x8d,"CODECAPI_AVEncAudioMapDestChannel5"); + IF_GUID_EQUAL_RETURN(guid,0xbc5d0b66,0xdf6a,0x4e16,0x98,0x03,0xb8,0x20,0x07,0xa3,0x0c,0x8d,"CODECAPI_AVEncAudioMapDestChannel6"); + IF_GUID_EQUAL_RETURN(guid,0xbc5d0b67,0xdf6a,0x4e16,0x98,0x03,0xb8,0x20,0x07,0xa3,0x0c,0x8d,"CODECAPI_AVEncAudioMapDestChannel7"); + IF_GUID_EQUAL_RETURN(guid,0xbc5d0b68,0xdf6a,0x4e16,0x98,0x03,0xb8,0x20,0x07,0xa3,0x0c,0x8d,"CODECAPI_AVEncAudioMapDestChannel8"); + IF_GUID_EQUAL_RETURN(guid,0xbc5d0b69,0xdf6a,0x4e16,0x98,0x03,0xb8,0x20,0x07,0xa3,0x0c,0x8d,"CODECAPI_AVEncAudioMapDestChannel9"); + IF_GUID_EQUAL_RETURN(guid,0x921295bb,0x4fca,0x4679,0xaa,0xb8,0x9e,0x2a,0x1d,0x75,0x33,0x84,"CODECAPI_AVEncAudioMeanBitRate"); + IF_GUID_EQUAL_RETURN(guid,0x08af4ac1,0xf3f2,0x4c74,0x9d,0xcf,0x37,0xf2,0xec,0x79,0xf8,0x26,"CODECAPI_AVEncCodecType"); + IF_GUID_EQUAL_RETURN(guid,0xd9c5c8db,0xfc74,0x4064,0x94,0xe9,0xcd,0x19,0xf9,0x47,0xed,0x45,"CODECAPI_AVEncCommonBufferInLevel"); + IF_GUID_EQUAL_RETURN(guid,0xccae7f49,0xd0bc,0x4e3d,0xa5,0x7e,0xfb,0x57,0x40,0x14,0x00,0x69,"CODECAPI_AVEncCommonBufferOutLevel"); + IF_GUID_EQUAL_RETURN(guid,0x0db96574,0xb6a4,0x4c8b,0x81,0x06,0x37,0x73,0xde,0x03,0x10,0xcd,"CODECAPI_AVEncCommonBufferSize"); + IF_GUID_EQUAL_RETURN(guid,0x57cbb9b8,0x116f,0x4951,0xb4,0x0c,0xc2,0xa0,0x35,0xed,0x8f,0x17,"CODECAPI_AVEncCommonFormatConstraint"); + IF_GUID_EQUAL_RETURN(guid,0x9d3ecd55,0x89e8,0x490a,0x97,0x0a,0x0c,0x95,0x48,0xd5,0xa5,0x6e,"CODECAPI_AVEncCommonLowLatency"); + IF_GUID_EQUAL_RETURN(guid,0x9651eae4,0x39b9,0x4ebf,0x85,0xef,0xd7,0xf4,0x44,0xec,0x74,0x65,"CODECAPI_AVEncCommonMaxBitRate"); + IF_GUID_EQUAL_RETURN(guid,0xf7222374,0x2144,0x4815,0xb5,0x50,0xa3,0x7f,0x8e,0x12,0xee,0x52,"CODECAPI_AVEncCommonMeanBitRate"); + IF_GUID_EQUAL_RETURN(guid,0xbfaa2f0c,0xcb82,0x4bc0,0x84,0x74,0xf0,0x6a,0x8a,0x0d,0x02,0x58,"CODECAPI_AVEncCommonMeanBitRateInterval"); + IF_GUID_EQUAL_RETURN(guid,0x101405b2,0x2083,0x4034,0xa8,0x06,0xef,0xbe,0xdd,0xd7,0xc9,0xff,"CODECAPI_AVEncCommonMinBitRate"); + IF_GUID_EQUAL_RETURN(guid,0x22533d4c,0x47e1,0x41b5,0x93,0x52,0xa2,0xb7,0x78,0x0e,0x7a,0xc4,"CODECAPI_AVEncCommonMultipassMode"); + IF_GUID_EQUAL_RETURN(guid,0x0e3d01bc,0xc85c,0x467d,0x8b,0x60,0xc4,0x10,0x12,0xee,0x3b,0xf6,"CODECAPI_AVEncCommonPassEnd"); + IF_GUID_EQUAL_RETURN(guid,0x6a67739f,0x4eb5,0x4385,0x99,0x28,0xf2,0x76,0xa9,0x39,0xef,0x95,"CODECAPI_AVEncCommonPassStart"); + IF_GUID_EQUAL_RETURN(guid,0xfcbf57a3,0x7ea5,0x4b0c,0x96,0x44,0x69,0xb4,0x0c,0x39,0xc3,0x91,"CODECAPI_AVEncCommonQuality"); + IF_GUID_EQUAL_RETURN(guid,0x98332df8,0x03cd,0x476b,0x89,0xfa,0x3f,0x9e,0x44,0x2d,0xec,0x9f,"CODECAPI_AVEncCommonQualityVsSpeed"); + IF_GUID_EQUAL_RETURN(guid,0x1c0608e9,0x370c,0x4710,0x8a,0x58,0xcb,0x61,0x81,0xc4,0x24,0x23,"CODECAPI_AVEncCommonRateControlMode"); + IF_GUID_EQUAL_RETURN(guid,0x143a0ff6,0xa131,0x43da,0xb8,0x1e,0x98,0xfb,0xb8,0xec,0x37,0x8e,"CODECAPI_AVEncCommonRealTime"); + IF_GUID_EQUAL_RETURN(guid,0x6aad30af,0x6ba8,0x4ccc,0x8f,0xca,0x18,0xd1,0x9b,0xea,0xeb,0x1c,"CODECAPI_AVEncCommonStreamEndHandling"); + IF_GUID_EQUAL_RETURN(guid,0x6947787C,0xF508,0x4EA9,0xB1,0xE9,0xA1,0xFE,0x3A,0x49,0xFB,0xC9,"CODECAPI_AVEncCommonTranscodeEncodingProfile"); + IF_GUID_EQUAL_RETURN(guid,0x719f9612,0x81a1,0x47e0,0x9a,0x05,0xd9,0x4a,0xd5,0xfc,0xa9,0x48,"CODECAPI_AVEncDDAtoDConverterType"); + IF_GUID_EQUAL_RETURN(guid,0xe285072c,0xc958,0x4a81,0xaf,0xd2,0xe5,0xe0,0xda,0xf1,0xb1,0x48,"CODECAPI_AVEncDDCentreDownMixLevel"); + IF_GUID_EQUAL_RETURN(guid,0xe197821d,0xd2e7,0x43e2,0xad,0x2c,0x00,0x58,0x2f,0x51,0x85,0x45,"CODECAPI_AVEncDDChannelBWLowPassFilter"); + IF_GUID_EQUAL_RETURN(guid,0x8694f076,0xcd75,0x481d,0xa5,0xc6,0xa9,0x04,0xdc,0xc8,0x28,0xf0,"CODECAPI_AVEncDDCopyright"); + IF_GUID_EQUAL_RETURN(guid,0x9565239f,0x861c,0x4ac8,0xbf,0xda,0xe0,0x0c,0xb4,0xdb,0x85,0x48,"CODECAPI_AVEncDDDCHighPassFilter"); + IF_GUID_EQUAL_RETURN(guid,0xd7055acf,0xf125,0x437d,0xa7,0x04,0x79,0xc7,0x9f,0x04,0x04,0xa8,"CODECAPI_AVEncDDDialogNormalization"); + IF_GUID_EQUAL_RETURN(guid,0xe024a2c2,0x947c,0x45ac,0x87,0xd8,0xf1,0x03,0x0c,0x5c,0x00,0x82,"CODECAPI_AVEncDDDigitalDeemphasis"); + IF_GUID_EQUAL_RETURN(guid,0xcfc2ff6d,0x79b8,0x4b8d,0xa8,0xaa,0xa0,0xc9,0xbd,0x1c,0x29,0x40,"CODECAPI_AVEncDDDynamicRangeCompressionControl"); + IF_GUID_EQUAL_RETURN(guid,0x4052dbec,0x52f5,0x42f5,0x9b,0x00,0xd1,0x34,0xb1,0x34,0x1b,0x9d,"CODECAPI_AVEncDDHeadphoneMode"); + IF_GUID_EQUAL_RETURN(guid,0xd3b80f6f,0x9d15,0x45e5,0x91,0xbe,0x01,0x9c,0x3f,0xab,0x1f,0x01,"CODECAPI_AVEncDDLFELowPassFilter"); + IF_GUID_EQUAL_RETURN(guid,0x1cfba222,0x25b3,0x4bf4,0x9b,0xfd,0xe7,0x11,0x12,0x67,0x85,0x8c,"CODECAPI_AVEncDDLoRoCenterMixLvl_x10"); + IF_GUID_EQUAL_RETURN(guid,0xe725cff6,0xeb56,0x40c7,0x84,0x50,0x2b,0x93,0x67,0xe9,0x15,0x55,"CODECAPI_AVEncDDLoRoSurroundMixLvl_x10"); + IF_GUID_EQUAL_RETURN(guid,0xdca128a2,0x491f,0x4600,0xb2,0xda,0x76,0xe3,0x34,0x4b,0x41,0x97,"CODECAPI_AVEncDDLtRtCenterMixLvl_x10"); + IF_GUID_EQUAL_RETURN(guid,0x212246c7,0x3d2c,0x4dfa,0xbc,0x21,0x65,0x2a,0x90,0x98,0x69,0x0d,"CODECAPI_AVEncDDLtRtSurroundMixLvl_x10"); + IF_GUID_EQUAL_RETURN(guid,0x966ae800,0x5bd3,0x4ff9,0x95,0xb9,0xd3,0x05,0x66,0x27,0x38,0x56,"CODECAPI_AVEncDDOriginalBitstream"); + IF_GUID_EQUAL_RETURN(guid,0x7f4e6b31,0x9185,0x403d,0xb0,0xa2,0x76,0x37,0x43,0xe6,0xf0,0x63,"CODECAPI_AVEncDDPreferredStereoDownMixMode"); + IF_GUID_EQUAL_RETURN(guid,0xb0b7fe5f,0xb6ab,0x4f40,0x96,0x4d,0x8d,0x91,0xf1,0x7c,0x19,0xe8,"CODECAPI_AVEncDDProductionInfoExists"); + IF_GUID_EQUAL_RETURN(guid,0x301d103a,0xcbf9,0x4776,0x88,0x99,0x7c,0x15,0xb4,0x61,0xab,0x26,"CODECAPI_AVEncDDProductionMixLevel"); + IF_GUID_EQUAL_RETURN(guid,0xdad7ad60,0x23d8,0x4ab7,0xa2,0x84,0x55,0x69,0x86,0xd8,0xa6,0xfe,"CODECAPI_AVEncDDProductionRoomType"); + IF_GUID_EQUAL_RETURN(guid,0x21af44c0,0x244e,0x4f3d,0xa2,0xcc,0x3d,0x30,0x68,0xb2,0xe7,0x3f,"CODECAPI_AVEncDDRFPreEmphasisFilter"); + IF_GUID_EQUAL_RETURN(guid,0xd2e1bec7,0x5172,0x4d2a,0xa5,0x0e,0x2f,0x3b,0x82,0xb1,0xdd,0xf8,"CODECAPI_AVEncDDService"); + IF_GUID_EQUAL_RETURN(guid,0x4d43b99d,0x31e2,0x48b9,0xbf,0x2e,0x5c,0xbf,0x1a,0x57,0x27,0x84,"CODECAPI_AVEncDDSurround3dBAttenuation"); + IF_GUID_EQUAL_RETURN(guid,0x25ecec9d,0x3553,0x42c0,0xbb,0x56,0xd2,0x57,0x92,0x10,0x4f,0x80,"CODECAPI_AVEncDDSurround90DegreeePhaseShift"); + IF_GUID_EQUAL_RETURN(guid,0x7b20d6e5,0x0bcf,0x4273,0xa4,0x87,0x50,0x6b,0x04,0x79,0x97,0xe9,"CODECAPI_AVEncDDSurroundDownMixLevel"); + IF_GUID_EQUAL_RETURN(guid,0x91607cee,0xdbdd,0x4eb6,0xbc,0xa2,0xaa,0xdf,0xaf,0xa3,0xdd,0x68,"CODECAPI_AVEncDDSurroundExMode"); + IF_GUID_EQUAL_RETURN(guid,0xee6cad62,0xd305,0x4248,0xa5,0xe,0xe1,0xb2,0x55,0xf7,0xca,0xf8,"CODECAPI_AVEncH264CABACEnable"); + IF_GUID_EQUAL_RETURN(guid,0xbfe29ec2,0x56c,0x4d68,0xa3,0x8d,0xae,0x59,0x44,0xc8,0x58,0x2e,"CODECAPI_AVEncH264PPSID"); + IF_GUID_EQUAL_RETURN(guid,0x50f38f51,0x2b79,0x40e3,0xb3,0x9c,0x7e,0x9f,0xa0,0x77,0x5,0x1,"CODECAPI_AVEncH264SPSID"); + IF_GUID_EQUAL_RETURN(guid,0xbede146d,0xb616,0x4dc7,0x92,0xb2,0xf5,0xd9,0xfa,0x92,0x98,0xf7,"CODECAPI_AVEncInputVideoSystem"); + IF_GUID_EQUAL_RETURN(guid,0xc7607ced,0x8cf1,0x4a99,0x83,0xa1,0xee,0x54,0x61,0xbe,0x35,0x74,"CODECAPI_AVEncMP12MuxDVDNavPacks"); + IF_GUID_EQUAL_RETURN(guid,0x157232b6,0xf809,0x474e,0x94,0x64,0xa7,0xf9,0x30,0x14,0xa8,0x17,"CODECAPI_AVEncMP12MuxEarliestPTS"); + IF_GUID_EQUAL_RETURN(guid,0x3433ad21,0x1b91,0x4a0b,0xb1,0x90,0x2b,0x77,0x06,0x3b,0x63,0xa4,"CODECAPI_AVEncMP12MuxInitialSCR"); + IF_GUID_EQUAL_RETURN(guid,0x35ceb711,0xf461,0x4b92,0xa4,0xef,0x17,0xb6,0x84,0x1e,0xd2,0x54,"CODECAPI_AVEncMP12MuxLargestPacketSize"); + IF_GUID_EQUAL_RETURN(guid,0xee047c72,0x4bdb,0x4a9d,0x8e,0x21,0x41,0x92,0x6c,0x82,0x3d,0xa7,"CODECAPI_AVEncMP12MuxMuxRate"); + IF_GUID_EQUAL_RETURN(guid,0xf7164a41,0xdced,0x4659,0xa8,0xf2,0xfb,0x69,0x3f,0x2a,0x4c,0xd0,"CODECAPI_AVEncMP12MuxNumStreams"); + IF_GUID_EQUAL_RETURN(guid,0xf916053a,0x1ce8,0x4faf,0xaa,0x0b,0xba,0x31,0xc8,0x00,0x34,0xb8,"CODECAPI_AVEncMP12MuxPackSize"); + IF_GUID_EQUAL_RETURN(guid,0xe40bd720,0x3955,0x4453,0xac,0xf9,0xb7,0x91,0x32,0xa3,0x8f,0xa0,"CODECAPI_AVEncMP12MuxPacketOverhead"); + IF_GUID_EQUAL_RETURN(guid,0x0fbb5752,0x1d43,0x47bf,0xbd,0x79,0xf2,0x29,0x3d,0x8c,0xe3,0x37,"CODECAPI_AVEncMP12MuxSysAudioLock"); + IF_GUID_EQUAL_RETURN(guid,0x7952ff45,0x9c0d,0x4822,0xbc,0x82,0x8a,0xd7,0x72,0xe0,0x29,0x93,"CODECAPI_AVEncMP12MuxSysCSPS"); + IF_GUID_EQUAL_RETURN(guid,0xcefb987e,0x894f,0x452e,0x8f,0x89,0xa4,0xef,0x8c,0xec,0x06,0x3a,"CODECAPI_AVEncMP12MuxSysFixed"); + IF_GUID_EQUAL_RETURN(guid,0x05f0428a,0xee30,0x489d,0xae,0x28,0x20,0x5c,0x72,0x44,0x67,0x10,"CODECAPI_AVEncMP12MuxSysRateBound"); + IF_GUID_EQUAL_RETURN(guid,0x35746903,0xb545,0x43e7,0xbb,0x35,0xc5,0xe0,0xa7,0xd5,0x09,0x3c,"CODECAPI_AVEncMP12MuxSysSTDBufferBound"); + IF_GUID_EQUAL_RETURN(guid,0xb8296408,0x2430,0x4d37,0xa2,0xa1,0x95,0xb3,0xe4,0x35,0xa9,0x1d,"CODECAPI_AVEncMP12MuxSysVideoLock"); + IF_GUID_EQUAL_RETURN(guid,0xd862212a,0x2015,0x45dd,0x9a,0x32,0x1b,0x3a,0xa8,0x82,0x05,0xa0,"CODECAPI_AVEncMP12MuxTargetPacketizer"); + IF_GUID_EQUAL_RETURN(guid,0xc8f4b0c1,0x094c,0x43c7,0x8e,0x68,0xa5,0x95,0x40,0x5a,0x6e,0xf8,"CODECAPI_AVEncMP12PktzCopyright"); + IF_GUID_EQUAL_RETURN(guid,0x2a4f2065,0x9a63,0x4d20,0xae,0x22,0x0a,0x1b,0xc8,0x96,0xa3,0x15,"CODECAPI_AVEncMP12PktzInitialPTS"); + IF_GUID_EQUAL_RETURN(guid,0x6b178416,0x31b9,0x4964,0x94,0xcb,0x6b,0xff,0x86,0x6c,0xdf,0x83,"CODECAPI_AVEncMP12PktzOriginal"); + IF_GUID_EQUAL_RETURN(guid,0xab71347a,0x1332,0x4dde,0xa0,0xe5,0xcc,0xf7,0xda,0x8a,0x0f,0x22,"CODECAPI_AVEncMP12PktzPacketSize"); + IF_GUID_EQUAL_RETURN(guid,0x0b751bd0,0x819e,0x478c,0x94,0x35,0x75,0x20,0x89,0x26,0xb3,0x77,"CODECAPI_AVEncMP12PktzSTDBuffer"); + IF_GUID_EQUAL_RETURN(guid,0xc834d038,0xf5e8,0x4408,0x9b,0x60,0x88,0xf3,0x64,0x93,0xfe,0xdf,"CODECAPI_AVEncMP12PktzStreamID"); + IF_GUID_EQUAL_RETURN(guid,0xb16ade03,0x4b93,0x43d7,0xa5,0x50,0x90,0xb4,0xfe,0x22,0x45,0x37,"CODECAPI_AVEncMPACodingMode"); + IF_GUID_EQUAL_RETURN(guid,0xa6ae762a,0xd0a9,0x4454,0xb8,0xef,0xf2,0xdb,0xee,0xfd,0xd3,0xbd,"CODECAPI_AVEncMPACopyright"); + IF_GUID_EQUAL_RETURN(guid,0x2d59fcda,0xbf4e,0x4ed6,0xb5,0xdf,0x5b,0x03,0xb3,0x6b,0x0a,0x1f,"CODECAPI_AVEncMPAEmphasisType"); + IF_GUID_EQUAL_RETURN(guid,0x5e54b09e,0xb2e7,0x4973,0xa8,0x9b,0x0b,0x36,0x50,0xa3,0xbe,0xda,"CODECAPI_AVEncMPAEnableRedundancyProtection"); + IF_GUID_EQUAL_RETURN(guid,0x9d377230,0xf91b,0x453d,0x9c,0xe0,0x78,0x44,0x54,0x14,0xc2,0x2d,"CODECAPI_AVEncMPALayer"); + IF_GUID_EQUAL_RETURN(guid,0x3cfb7855,0x9cc9,0x47ff,0xb8,0x29,0xb3,0x67,0x86,0xc9,0x23,0x46,"CODECAPI_AVEncMPAOriginalBitstream"); + IF_GUID_EQUAL_RETURN(guid,0xafa505ce,0xc1e3,0x4e3d,0x85,0x1b,0x61,0xb7,0x00,0xe5,0xe6,0xcc,"CODECAPI_AVEncMPAPrivateUserBit"); + IF_GUID_EQUAL_RETURN(guid,0xa823178f,0x57df,0x4c7a,0xb8,0xfd,0xe5,0xec,0x88,0x87,0x70,0x8d,"CODECAPI_AVEncMPVAddSeqEndCode"); + IF_GUID_EQUAL_RETURN(guid,0x8d390aac,0xdc5c,0x4200,0xb5,0x7f,0x81,0x4d,0x04,0xba,0xba,0xb2,"CODECAPI_AVEncMPVDefaultBPictureCount"); + IF_GUID_EQUAL_RETURN(guid,0xacb5de96,0x7b93,0x4c2f,0x88,0x25,0xb0,0x29,0x5f,0xa9,0x3b,0xf4,"CODECAPI_AVEncMPVFrameFieldMode"); + IF_GUID_EQUAL_RETURN(guid,0xb1d5d4a6,0x3300,0x49b1,0xae,0x61,0xa0,0x99,0x37,0xab,0x0e,0x49,"CODECAPI_AVEncMPVGOPOpen"); + IF_GUID_EQUAL_RETURN(guid,0x993410d4,0x2691,0x4192,0x99,0x78,0x98,0xdc,0x26,0x03,0x66,0x9f,"CODECAPI_AVEncMPVGOPSInSeq"); + IF_GUID_EQUAL_RETURN(guid,0x95f31b26,0x95a4,0x41aa,0x93,0x03,0x24,0x6a,0x7f,0xc6,0xee,0xf1,"CODECAPI_AVEncMPVGOPSize"); + IF_GUID_EQUAL_RETURN(guid,0xc6412f84,0xc03f,0x4f40,0xa0,0x0c,0x42,0x93,0xdf,0x83,0x95,0xbb,"CODECAPI_AVEncMPVGenerateHeaderPicDispExt"); + IF_GUID_EQUAL_RETURN(guid,0x1b8464ab,0x944f,0x45f0,0xb7,0x4e,0x3a,0x58,0xda,0xd1,0x1f,0x37,"CODECAPI_AVEncMPVGenerateHeaderPicExt"); + IF_GUID_EQUAL_RETURN(guid,0x6437aa6f,0x5a3c,0x4de9,0x8a,0x16,0x53,0xd9,0xc4,0xad,0x32,0x6f,"CODECAPI_AVEncMPVGenerateHeaderSeqDispExt"); + IF_GUID_EQUAL_RETURN(guid,0xd5e78611,0x082d,0x4e6b,0x98,0xaf,0x0f,0x51,0xab,0x13,0x92,0x22,"CODECAPI_AVEncMPVGenerateHeaderSeqExt"); + IF_GUID_EQUAL_RETURN(guid,0x0722d62f,0xdd59,0x4a86,0x9c,0xd5,0x64,0x4f,0x8e,0x26,0x53,0xd8,"CODECAPI_AVEncMPVGenerateHeaderSeqScaleExt"); + IF_GUID_EQUAL_RETURN(guid,0xa0116151,0xcbc8,0x4af3,0x97,0xdc,0xd0,0x0c,0xce,0xb8,0x2d,0x79,"CODECAPI_AVEncMPVIntraDCPrecision"); + IF_GUID_EQUAL_RETURN(guid,0xa2b83ff5,0x1a99,0x405a,0xaf,0x95,0xc5,0x99,0x7d,0x55,0x8d,0x3a,"CODECAPI_AVEncMPVIntraVLCTable"); + IF_GUID_EQUAL_RETURN(guid,0x6ee40c40,0xa60c,0x41ef,0x8f,0x50,0x37,0xc2,0x24,0x9e,0x2c,0xb3,"CODECAPI_AVEncMPVLevel"); + IF_GUID_EQUAL_RETURN(guid,0xdabb534a,0x1d99,0x4284,0x97,0x5a,0xd9,0x0e,0x22,0x39,0xba,0xa1,"CODECAPI_AVEncMPVProfile"); + IF_GUID_EQUAL_RETURN(guid,0x2b79ebb7,0xf484,0x4af7,0xbb,0x58,0xa2,0xa1,0x88,0xc5,0xcb,0xbe,"CODECAPI_AVEncMPVQScaleType"); + IF_GUID_EQUAL_RETURN(guid,0x9eb9ecd4,0x018d,0x4ffd,0x8f,0x2d,0x39,0xe4,0x9f,0x07,0xb1,0x7a,"CODECAPI_AVEncMPVQuantMatrixChromaIntra"); + IF_GUID_EQUAL_RETURN(guid,0x1415b6b1,0x362a,0x4338,0xba,0x9a,0x1e,0xf5,0x87,0x03,0xc0,0x5b,"CODECAPI_AVEncMPVQuantMatrixChromaNonIntra"); + IF_GUID_EQUAL_RETURN(guid,0x9bea04f3,0x6621,0x442c,0x8b,0xa1,0x3a,0xc3,0x78,0x97,0x96,0x98,"CODECAPI_AVEncMPVQuantMatrixIntra"); + IF_GUID_EQUAL_RETURN(guid,0x87f441d8,0x0997,0x4beb,0xa0,0x8e,0x85,0x73,0xd4,0x09,0xcf,0x75,"CODECAPI_AVEncMPVQuantMatrixNonIntra"); + IF_GUID_EQUAL_RETURN(guid,0x7f8a478e,0x7bbb,0x4ae2,0xb2,0xfc,0x96,0xd1,0x7f,0xc4,0xa2,0xd6,"CODECAPI_AVEncMPVScanPattern"); + IF_GUID_EQUAL_RETURN(guid,0x552799f1,0xdb4c,0x405b,0x8a,0x3a,0xc9,0x3f,0x2d,0x06,0x74,0xdc,"CODECAPI_AVEncMPVSceneDetection"); + IF_GUID_EQUAL_RETURN(guid,0xec770cf3,0x6908,0x4b4b,0xaa,0x30,0x7f,0xb9,0x86,0x21,0x4f,0xea,"CODECAPI_AVEncMPVUseConcealmentMotionVectors"); + IF_GUID_EQUAL_RETURN(guid,0xcedd9e8f,0x34d3,0x44db,0xa1,0xd8,0xf8,0x15,0x20,0x25,0x4f,0x3e,"CODECAPI_AVEncMuxOutputStreamType"); + IF_GUID_EQUAL_RETURN(guid,0xb0c8bf60,0x16f7,0x4951,0xa3,0xb,0x1d,0xb1,0x60,0x92,0x93,0xd6,"CODECAPI_AVEncNumWorkerThreads"); + IF_GUID_EQUAL_RETURN(guid,0xca6724db,0x7059,0x4351,0x8b,0x43,0xf8,0x21,0x98,0x82,0x6a,0x14,"CODECAPI_AVEncStatAudioAverageBPS"); + IF_GUID_EQUAL_RETURN(guid,0x979272f8,0xd17f,0x4e32,0xbb,0x73,0x4e,0x73,0x1c,0x68,0xba,0x2d,"CODECAPI_AVEncStatAudioAveragePCMValue"); + IF_GUID_EQUAL_RETURN(guid,0xdce7fd34,0xdc00,0x4c16,0x82,0x1b,0x35,0xd9,0xeb,0x00,0xfb,0x1a,"CODECAPI_AVEncStatAudioPeakPCMValue"); + IF_GUID_EQUAL_RETURN(guid,0xca6724db,0x7059,0x4351,0x8b,0x43,0xf8,0x21,0x98,0x82,0x6a,0x14,"CODECAPI_AVEncStatAverageBPS"); + IF_GUID_EQUAL_RETURN(guid,0x3e5de533,0x9df7,0x438c,0x85,0x4f,0x9f,0x7d,0xd3,0x68,0x3d,0x34,"CODECAPI_AVEncStatCommonCompletedPasses"); + IF_GUID_EQUAL_RETURN(guid,0x0124ba9b,0xdc41,0x4826,0xb4,0x5f,0x18,0xac,0x01,0xb3,0xd5,0xa8,"CODECAPI_AVEncStatHardwareBandwidthUtilitization"); + IF_GUID_EQUAL_RETURN(guid,0x995dc027,0xcb95,0x49e6,0xb9,0x1b,0x59,0x67,0x75,0x3c,0xdc,0xb8,"CODECAPI_AVEncStatHardwareProcessorUtilitization"); + IF_GUID_EQUAL_RETURN(guid,0x32195fd3,0x590d,0x4812,0xa7,0xed,0x6d,0x63,0x9a,0x1f,0x97,0x11,"CODECAPI_AVEncStatMPVSkippedEmptyFrames"); + IF_GUID_EQUAL_RETURN(guid,0xd47f8d61,0x6f5a,0x4a26,0xbb,0x9f,0xcd,0x95,0x18,0x46,0x2b,0xcd,"CODECAPI_AVEncStatVideoCodedFrames"); + IF_GUID_EQUAL_RETURN(guid,0xbe747849,0x9ab4,0x4a63,0x98,0xfe,0xf1,0x43,0xf0,0x4f,0x8e,0xe9,"CODECAPI_AVEncStatVideoOutputFrameRate"); + IF_GUID_EQUAL_RETURN(guid,0xfdaa9916,0x119a,0x4222,0x9a,0xd6,0x3f,0x7c,0xab,0x99,0xcc,0x8b,"CODECAPI_AVEncStatVideoTotalFrames"); + IF_GUID_EQUAL_RETURN(guid,0x6aa6229f,0xd602,0x4b9d,0xb6,0x8c,0xc1,0xad,0x78,0x88,0x4b,0xef,"CODECAPI_AVEncStatWMVCBAvg"); + IF_GUID_EQUAL_RETURN(guid,0xe976bef8,0x00fe,0x44b4,0xb6,0x25,0x8f,0x23,0x8b,0xc0,0x34,0x99,"CODECAPI_AVEncStatWMVCBMax"); + IF_GUID_EQUAL_RETURN(guid,0x89e69fc3,0x0f9b,0x436c,0x97,0x4a,0xdf,0x82,0x12,0x27,0xc9,0x0d,"CODECAPI_AVEncStatWMVDecoderComplexityProfile"); + IF_GUID_EQUAL_RETURN(guid,0x0d49451e,0x18d5,0x4367,0xa4,0xef,0x32,0x40,0xdf,0x16,0x93,0xc4,"CODECAPI_AVEncVideoCBRMotionTradeoff"); + IF_GUID_EQUAL_RETURN(guid,0xb4b10c15,0x14a7,0x4ce8,0xb1,0x73,0xdc,0x90,0xa0,0xb4,0xfc,0xdb,"CODECAPI_AVEncVideoCodedVideoAccessUnitSize"); + IF_GUID_EQUAL_RETURN(guid,0x66117aca,0xeb77,0x459d,0x93,0xc,0xa4,0x8d,0x9d,0x6,0x83,0xfc,"CODECAPI_AVEncVideoContentType"); + IF_GUID_EQUAL_RETURN(guid,0x810167c4,0x0bc1,0x47ca,0x8f,0xc2,0x57,0x05,0x5a,0x14,0x74,0xa5,"CODECAPI_AVEncVideoDefaultUpperFieldDominant"); + IF_GUID_EQUAL_RETURN(guid,0xde053668,0xf4ec,0x47a9,0x86,0xd0,0x83,0x67,0x70,0xf0,0xc1,0xd5,"CODECAPI_AVEncVideoDisplayDimension"); + IF_GUID_EQUAL_RETURN(guid,0x1074df28,0x7e0f,0x47a4,0xa4,0x53,0xcd,0xd7,0x38,0x70,0xf5,0xce,"CODECAPI_AVEncVideoEncodeDimension"); + IF_GUID_EQUAL_RETURN(guid,0x6bc098fe,0xa71a,0x4454,0x85,0x2e,0x4d,0x2d,0xde,0xb2,0xcd,0x24,"CODECAPI_AVEncVideoEncodeOffsetOrigin"); + IF_GUID_EQUAL_RETURN(guid,0x2cb5696b,0x23fb,0x4ce1,0xa0,0xf9,0xef,0x5b,0x90,0xfd,0x55,0xca,"CODECAPI_AVEncVideoEncodeQP"); + IF_GUID_EQUAL_RETURN(guid,0xfefd7569,0x4e0a,0x49f2,0x9f,0x2b,0x36,0x0e,0xa4,0x8c,0x19,0xa2,"CODECAPI_AVEncVideoFieldSwap"); + IF_GUID_EQUAL_RETURN(guid,0x398c1b98,0x8353,0x475a,0x9e,0xf2,0x8f,0x26,0x5d,0x26,0x3,0x45,"CODECAPI_AVEncVideoForceKeyFrame"); + IF_GUID_EQUAL_RETURN(guid,0x1ef2065f,0x058a,0x4765,0xa4,0xfc,0x8a,0x86,0x4c,0x10,0x30,0x12,"CODECAPI_AVEncVideoForceSourceScanType"); + IF_GUID_EQUAL_RETURN(guid,0x6ed9e124,0x7925,0x43fe,0x97,0x1b,0xe0,0x19,0xf6,0x22,0x22,0xb4,"CODECAPI_AVEncVideoHeaderDropFrame"); + IF_GUID_EQUAL_RETURN(guid,0xafd5f567,0x5c1b,0x4adc,0xbd,0xaf,0x73,0x56,0x10,0x38,0x14,0x36,"CODECAPI_AVEncVideoHeaderFrames"); + IF_GUID_EQUAL_RETURN(guid,0x2acc7702,0xe2da,0x4158,0xbf,0x9b,0x88,0x88,0x01,0x29,0xd7,0x40,"CODECAPI_AVEncVideoHeaderHours"); + IF_GUID_EQUAL_RETURN(guid,0xdc1a99ce,0x0307,0x408b,0x88,0x0b,0xb8,0x34,0x8e,0xe8,0xca,0x7f,"CODECAPI_AVEncVideoHeaderMinutes"); + IF_GUID_EQUAL_RETURN(guid,0x4a2e1a05,0xa780,0x4f58,0x81,0x20,0x9a,0x44,0x9d,0x69,0x65,0x6b,"CODECAPI_AVEncVideoHeaderSeconds"); + IF_GUID_EQUAL_RETURN(guid,0xbb0cec33,0x16f1,0x47b0,0x8a,0x88,0x37,0x81,0x5b,0xee,0x17,0x39,"CODECAPI_AVEncVideoInputChromaResolution"); + IF_GUID_EQUAL_RETURN(guid,0xa8e73a39,0x4435,0x4ec3,0xa6,0xea,0x98,0x30,0x0f,0x4b,0x36,0xf7,"CODECAPI_AVEncVideoInputChromaSubsampling"); + IF_GUID_EQUAL_RETURN(guid,0x46a99549,0x0015,0x4a45,0x9c,0x30,0x1d,0x5c,0xfa,0x25,0x83,0x16,"CODECAPI_AVEncVideoInputColorLighting"); + IF_GUID_EQUAL_RETURN(guid,0x16cf25c6,0xa2a6,0x48e9,0xae,0x80,0x21,0xae,0xc4,0x1d,0x42,0x7e,"CODECAPI_AVEncVideoInputColorNominalRange"); + IF_GUID_EQUAL_RETURN(guid,0xc24d783f,0x7ce6,0x4278,0x90,0xab,0x28,0xa4,0xf1,0xe5,0xf8,0x6c,"CODECAPI_AVEncVideoInputColorPrimaries"); + IF_GUID_EQUAL_RETURN(guid,0x8c056111,0xa9c3,0x4b08,0xa0,0xa0,0xce,0x13,0xf8,0xa2,0x7c,0x75,"CODECAPI_AVEncVideoInputColorTransferFunction"); + IF_GUID_EQUAL_RETURN(guid,0x52ed68b9,0x72d5,0x4089,0x95,0x8d,0xf5,0x40,0x5d,0x55,0x08,0x1c,"CODECAPI_AVEncVideoInputColorTransferMatrix"); + IF_GUID_EQUAL_RETURN(guid,0x2ea9098b,0xe76d,0x4ccd,0xa0,0x30,0xd3,0xb8,0x89,0xc1,0xb6,0x4c,"CODECAPI_AVEncVideoInverseTelecineEnable"); + IF_GUID_EQUAL_RETURN(guid,0x40247d84,0xe895,0x497f,0xb4,0x4c,0xb7,0x45,0x60,0xac,0xfe,0x27,"CODECAPI_AVEncVideoInverseTelecineThreshold"); + IF_GUID_EQUAL_RETURN(guid,0x2987123a,0xba93,0x4704,0xb4,0x89,0xec,0x1e,0x5f,0x25,0x29,0x2c,"CODECAPI_AVEncVideoMaxKeyframeDistance"); + IF_GUID_EQUAL_RETURN(guid,0xee22c6a,0xa37c,0x4568,0xb5,0xf1,0x9d,0x4c,0x2b,0x3a,0xb8,0x86,"CODECAPI_AVEncVideoMinQP"); + IF_GUID_EQUAL_RETURN(guid,0x61e4bbe2,0x4ee0,0x40e7,0x80,0xab,0x51,0xdd,0xee,0xbe,0x62,0x91,"CODECAPI_AVEncVideoNoOfFieldsToEncode"); + IF_GUID_EQUAL_RETURN(guid,0xa97e1240,0x1427,0x4c16,0xa7,0xf7,0x3d,0xcf,0xd8,0xba,0x4c,0xc5,"CODECAPI_AVEncVideoNoOfFieldsToSkip"); + IF_GUID_EQUAL_RETURN(guid,0x6097b4c9,0x7c1d,0x4e64,0xbf,0xcc,0x9e,0x97,0x65,0x31,0x8a,0xe7,"CODECAPI_AVEncVideoOutputChromaResolution"); + IF_GUID_EQUAL_RETURN(guid,0xfa561c6c,0x7d17,0x44f0,0x83,0xc9,0x32,0xed,0x12,0xe9,0x63,0x43,"CODECAPI_AVEncVideoOutputChromaSubsampling"); + IF_GUID_EQUAL_RETURN(guid,0x0e5aaac6,0xace6,0x4c5c,0x99,0x8e,0x1a,0x8c,0x9c,0x6c,0x0f,0x89,"CODECAPI_AVEncVideoOutputColorLighting"); + IF_GUID_EQUAL_RETURN(guid,0x972835ed,0x87b5,0x4e95,0x95,0x00,0xc7,0x39,0x58,0x56,0x6e,0x54,"CODECAPI_AVEncVideoOutputColorNominalRange"); + IF_GUID_EQUAL_RETURN(guid,0xbe95907c,0x9d04,0x4921,0x89,0x85,0xa6,0xd6,0xd8,0x7d,0x1a,0x6c,"CODECAPI_AVEncVideoOutputColorPrimaries"); + IF_GUID_EQUAL_RETURN(guid,0x4a7f884a,0xea11,0x460d,0xbf,0x57,0xb8,0x8b,0xc7,0x59,0x00,0xde,"CODECAPI_AVEncVideoOutputColorTransferFunction"); + IF_GUID_EQUAL_RETURN(guid,0xa9b90444,0xaf40,0x4310,0x8f,0xbe,0xed,0x6d,0x93,0x3f,0x89,0x2b,"CODECAPI_AVEncVideoOutputColorTransferMatrix"); + IF_GUID_EQUAL_RETURN(guid,0xea85e7c3,0x9567,0x4d99,0x87,0xc4,0x02,0xc1,0xc2,0x78,0xca,0x7c,"CODECAPI_AVEncVideoOutputFrameRate"); + IF_GUID_EQUAL_RETURN(guid,0x8c068bf4,0x369a,0x4ba3,0x82,0xfd,0xb2,0x51,0x8f,0xb3,0x39,0x6e,"CODECAPI_AVEncVideoOutputFrameRateConversion"); + IF_GUID_EQUAL_RETURN(guid,0x460b5576,0x842e,0x49ab,0xa6,0x2d,0xb3,0x6f,0x73,0x12,0xc9,0xdb,"CODECAPI_AVEncVideoOutputScanType"); + IF_GUID_EQUAL_RETURN(guid,0x3cdc718f,0xb3e9,0x4eb6,0xa5,0x7f,0xcf,0x1f,0x1b,0x32,0x1b,0x87,"CODECAPI_AVEncVideoPixelAspectRatio"); + IF_GUID_EQUAL_RETURN(guid,0x87d43767,0x7645,0x44ec,0xb4,0x38,0xd3,0x32,0x2f,0xbc,0xa2,0x9f,"CODECAPI_AVEncVideoRateControlParams"); + IF_GUID_EQUAL_RETURN(guid,0xeb1084f5,0x6aaa,0x4914,0xbb,0x2f,0x61,0x47,0x22,0x7f,0x12,0xe7,"CODECAPI_AVEncVideoSelectLayer"); + IF_GUID_EQUAL_RETURN(guid,0x1791c64b,0xccfc,0x4827,0xa0,0xed,0x25,0x57,0x79,0x3b,0x2b,0x1c,"CODECAPI_AVEncVideoSourceFilmContent"); + IF_GUID_EQUAL_RETURN(guid,0x42ffc49b,0x1812,0x4fdc,0x8d,0x24,0x70,0x54,0xc5,0x21,0xe6,0xeb,"CODECAPI_AVEncVideoSourceIsBW"); + IF_GUID_EQUAL_RETURN(guid,0xd3f40fdd,0x77b9,0x473d,0x81,0x96,0x06,0x12,0x59,0xe6,0x9c,0xff,"CODECAPI_AVEncVideoSupportedControls"); + IF_GUID_EQUAL_RETURN(guid,0x19caebff,0xb74d,0x4cfd,0x8c,0x27,0xc2,0xf9,0xd9,0x7d,0x5f,0x52,"CODECAPI_AVEncVideoTemporalLayerCount"); + IF_GUID_EQUAL_RETURN(guid,0x1f636849,0x5dc1,0x49f1,0xb1,0xd8,0xce,0x3c,0xf6,0x2e,0xa3,0x85,"CODECAPI_AVEncVideoUsage"); + IF_GUID_EQUAL_RETURN(guid,0xf32c0dab,0xf3cb,0x4217,0xb7,0x9f,0x87,0x62,0x76,0x8b,0x5f,0x67,"CODECAPI_AVEncWMVDecoderComplexity"); + IF_GUID_EQUAL_RETURN(guid,0xe3d00f8a,0xc6f5,0x4e14,0xa5,0x88,0x0e,0xc8,0x7a,0x72,0x6f,0x9b,"CODECAPI_AVEncWMVInterlacedEncoding"); + IF_GUID_EQUAL_RETURN(guid,0x51ff1115,0x33ac,0x426c,0xa1,0xb1,0x09,0x32,0x1b,0xdf,0x96,0xb4,"CODECAPI_AVEncWMVKeyFrameBufferLevelMarker"); + IF_GUID_EQUAL_RETURN(guid,0x5569055e,0xe268,0x4771,0xb8,0x3e,0x95,0x55,0xea,0x28,0xae,0xd3,"CODECAPI_AVEncWMVKeyFrameDistance"); + IF_GUID_EQUAL_RETURN(guid,0xd669d001,0x183c,0x42e3,0xa3,0xca,0x2f,0x45,0x86,0xd2,0x39,0x6c,"CODECAPI_AVEncWMVProduceDummyFrames"); + IF_GUID_EQUAL_RETURN(guid,0x9c27891a,0xed7a,0x40e1,0x88,0xe8,0xb2,0x27,0x27,0xa0,0x24,0xee,"CODECAPI_AVLowLatencyMode"); + IF_GUID_EQUAL_RETURN(guid,0x54ba3dc8,0xbdde,0x4329,0xb1,0x87,0x20,0x18,0xbc,0x5c,0x2b,0xa1,"CODECAPI_AVPriorityControl"); + IF_GUID_EQUAL_RETURN(guid,0x6f440632,0xc4ad,0x4bf7,0x9e,0x52,0x45,0x69,0x42,0xb4,0x54,0xb0,"CODECAPI_AVRealtimeControl"); + IF_GUID_EQUAL_RETURN(guid,0x62b12acf,0xf6b0,0x47d9,0x94,0x56,0x96,0xf2,0x2c,0x4e,0x0b,0x9d,"CODECAPI_CHANGELISTS"); + IF_GUID_EQUAL_RETURN(guid,0x1cb14e83,0x7d72,0x4657,0x83,0xfd,0x47,0xa2,0xc5,0xb9,0xd1,0x3d,"CODECAPI_CURRENTCHANGELIST"); + IF_GUID_EQUAL_RETURN(guid,0x97df7828,0xb94a,0x47e2,0xa4,0xbc,0x51,0x19,0x4d,0xb2,0x2a,0x4d,"CODECAPI_GUID_AVDecAudioInputAAC"); + IF_GUID_EQUAL_RETURN(guid,0x600bc0ca,0x6a1f,0x4e91,0xb2,0x41,0x1b,0xbe,0xb1,0xcb,0x19,0xe0,"CODECAPI_GUID_AVDecAudioInputDTS"); + IF_GUID_EQUAL_RETURN(guid,0x8e4228a0,0xf000,0x4e0b,0x8f,0x54,0xab,0x8d,0x24,0xad,0x61,0xa2,"CODECAPI_GUID_AVDecAudioInputDolby"); + IF_GUID_EQUAL_RETURN(guid,0x0803e185,0x8f5d,0x47f5,0x99,0x08,0x19,0xa5,0xbb,0xc9,0xfe,0x34,"CODECAPI_GUID_AVDecAudioInputDolbyDigitalPlus"); + IF_GUID_EQUAL_RETURN(guid,0x16efb4aa,0x330e,0x4f5c,0x98,0xa8,0xcf,0x6a,0xc5,0x5c,0xbe,0x60,"CODECAPI_GUID_AVDecAudioInputHEAAC"); + IF_GUID_EQUAL_RETURN(guid,0x91106f36,0x02c5,0x4f75,0x97,0x19,0x3b,0x7a,0xbf,0x75,0xe1,0xf6,"CODECAPI_GUID_AVDecAudioInputMPEG"); + IF_GUID_EQUAL_RETURN(guid,0xf2421da5,0xbbb4,0x4cd5,0xa9,0x96,0x93,0x3c,0x6b,0x5d,0x13,0x47,"CODECAPI_GUID_AVDecAudioInputPCM"); + IF_GUID_EQUAL_RETURN(guid,0xc95e8dcf,0x4058,0x4204,0x8c,0x42,0xcb,0x24,0xd9,0x1e,0x4b,0x9b,"CODECAPI_GUID_AVDecAudioInputWMA"); + IF_GUID_EQUAL_RETURN(guid,0x0128b7c7,0xda72,0x4fe3,0xbe,0xf8,0x5c,0x52,0xe3,0x55,0x77,0x04,"CODECAPI_GUID_AVDecAudioInputWMAPro"); + IF_GUID_EQUAL_RETURN(guid,0x696e1d31,0x548f,0x4036,0x82,0x5f,0x70,0x26,0xc6,0x00,0x11,0xbd,"CODECAPI_GUID_AVDecAudioOutputFormat_PCM"); + IF_GUID_EQUAL_RETURN(guid,0x696e1d34,0x548f,0x4036,0x82,0x5f,0x70,0x26,0xc6,0x00,0x11,0xbd,"CODECAPI_GUID_AVDecAudioOutputFormat_PCM_Headphones"); + IF_GUID_EQUAL_RETURN(guid,0x696e1d35,0x548f,0x4036,0x82,0x5f,0x70,0x26,0xc6,0x00,0x11,0xbd,"CODECAPI_GUID_AVDecAudioOutputFormat_PCM_Stereo_Auto"); + IF_GUID_EQUAL_RETURN(guid,0x696e1d30,0x548f,0x4036,0x82,0x5f,0x70,0x26,0xc6,0x00,0x11,0xbd,"CODECAPI_GUID_AVDecAudioOutputFormat_PCM_Stereo_MatrixEncoded"); + IF_GUID_EQUAL_RETURN(guid,0x696e1d33,0x548f,0x4036,0x82,0x5f,0x70,0x26,0xc6,0x00,0x11,0xbd,"CODECAPI_GUID_AVDecAudioOutputFormat_SPDIF_Bitstream"); + IF_GUID_EQUAL_RETURN(guid,0x696e1d32,0x548f,0x4036,0x82,0x5f,0x70,0x26,0xc6,0x00,0x11,0xbd,"CODECAPI_GUID_AVDecAudioOutputFormat_SPDIF_PCM"); + IF_GUID_EQUAL_RETURN(guid,0x8d7b897c,0xa019,0x4670,0xaa,0x76,0x2e,0xdc,0xac,0x7a,0xc2,0x96,"CODECAPI_GUID_AVEncCommonFormatATSC"); + IF_GUID_EQUAL_RETURN(guid,0x71830d8f,0x6c33,0x430d,0x84,0x4b,0xc2,0x70,0x5b,0xaa,0xe6,0xdb,"CODECAPI_GUID_AVEncCommonFormatDVB"); + IF_GUID_EQUAL_RETURN(guid,0xe55199d6,0x044c,0x4dae,0xa4,0x88,0x53,0x1e,0xd3,0x06,0x23,0x5b,"CODECAPI_GUID_AVEncCommonFormatDVD_DashVR"); + IF_GUID_EQUAL_RETURN(guid,0xe74c6f2e,0xec37,0x478d,0x9a,0xf4,0xa5,0xe1,0x35,0xb6,0x27,0x1c,"CODECAPI_GUID_AVEncCommonFormatDVD_PlusVR"); + IF_GUID_EQUAL_RETURN(guid,0xcc9598c4,0xe7fe,0x451d,0xb1,0xca,0x76,0x1b,0xc8,0x40,0xb7,0xf3,"CODECAPI_GUID_AVEncCommonFormatDVD_V"); + IF_GUID_EQUAL_RETURN(guid,0x1eabe760,0xfb2b,0x4928,0x90,0xd1,0x78,0xdb,0x88,0xee,0xe8,0x89,"CODECAPI_GUID_AVEncCommonFormatHighMAT"); + IF_GUID_EQUAL_RETURN(guid,0xa2d25db8,0xb8f9,0x42c2,0x8b,0xc7,0x0b,0x93,0xcf,0x60,0x47,0x88,"CODECAPI_GUID_AVEncCommonFormatHighMPV"); + IF_GUID_EQUAL_RETURN(guid,0x349733cd,0xeb08,0x4dc2,0x81,0x97,0xe4,0x98,0x35,0xef,0x82,0x8b,"CODECAPI_GUID_AVEncCommonFormatMP3"); + IF_GUID_EQUAL_RETURN(guid,0x51d85818,0x8220,0x448c,0x80,0x66,0xd6,0x9b,0xed,0x16,0xc9,0xad,"CODECAPI_GUID_AVEncCommonFormatSVCD"); + IF_GUID_EQUAL_RETURN(guid,0xaf46a35a,0x6024,0x4525,0xa4,0x8a,0x09,0x4b,0x97,0xf5,0xb3,0xc2,"CODECAPI_GUID_AVEncCommonFormatUnSpecified"); + IF_GUID_EQUAL_RETURN(guid,0x95035bf7,0x9d90,0x40ff,0xad,0x5c,0x5c,0xf8,0xcf,0x71,0xca,0x1d,"CODECAPI_GUID_AVEncCommonFormatVCD"); + IF_GUID_EQUAL_RETURN(guid,0x45fbcaa2,0x5e6e,0x4ab0,0x88,0x93,0x59,0x03,0xbe,0xe9,0x3a,0xcf,"CODECAPI_GUID_AVEncDTS"); + IF_GUID_EQUAL_RETURN(guid,0x2052e630,0x469d,0x4bfb,0x80,0xca,0x1d,0x65,0x6e,0x7e,0x91,0x8f,"CODECAPI_GUID_AVEncDTSHD"); + IF_GUID_EQUAL_RETURN(guid,0x09b769c7,0x3329,0x44fb,0x89,0x54,0xfa,0x30,0x93,0x7d,0x3d,0x5a,"CODECAPI_GUID_AVEncDV"); + IF_GUID_EQUAL_RETURN(guid,0xc1a7bf6c,0x0059,0x4bfa,0x94,0xef,0xef,0x74,0x7a,0x76,0x8d,0x52,"CODECAPI_GUID_AVEncDolbyDigitalConsumer"); + IF_GUID_EQUAL_RETURN(guid,0x698d1b80,0xf7dd,0x415c,0x97,0x1c,0x42,0x49,0x2a,0x20,0x56,0xc6,"CODECAPI_GUID_AVEncDolbyDigitalPlus"); + IF_GUID_EQUAL_RETURN(guid,0xf5be76cc,0x0ff8,0x40eb,0x9c,0xb1,0xbb,0xa9,0x40,0x04,0xd4,0x4f,"CODECAPI_GUID_AVEncDolbyDigitalPro"); + IF_GUID_EQUAL_RETURN(guid,0x95044eab,0x31b3,0x47de,0x8e,0x75,0x38,0xa4,0x2b,0xb0,0x3e,0x28,"CODECAPI_GUID_AVEncH264Video"); + IF_GUID_EQUAL_RETURN(guid,0x05f73e29,0xf0d1,0x431e,0xa4,0x1c,0xa4,0x74,0x32,0xec,0x5a,0x66,"CODECAPI_GUID_AVEncMLP"); + IF_GUID_EQUAL_RETURN(guid,0xd4dd1362,0xcd4a,0x4cd6,0x81,0x38,0xb9,0x4d,0xb4,0x54,0x2b,0x04,"CODECAPI_GUID_AVEncMPEG1Audio"); + IF_GUID_EQUAL_RETURN(guid,0xc8dafefe,0xda1e,0x4774,0xb2,0x7d,0x11,0x83,0x0c,0x16,0xb1,0xfe,"CODECAPI_GUID_AVEncMPEG1Video"); + IF_GUID_EQUAL_RETURN(guid,0xee4cbb1f,0x9c3f,0x4770,0x92,0xb5,0xfc,0xb7,0xc2,0xa8,0xd3,0x81,"CODECAPI_GUID_AVEncMPEG2Audio"); + IF_GUID_EQUAL_RETURN(guid,0x046dc19a,0x6677,0x4aaa,0xa3,0x1d,0xc1,0xab,0x71,0x6f,0x45,0x60,"CODECAPI_GUID_AVEncMPEG2Video"); + IF_GUID_EQUAL_RETURN(guid,0x844be7f4,0x26cf,0x4779,0xb3,0x86,0xcc,0x05,0xd1,0x87,0x99,0x0c,"CODECAPI_GUID_AVEncPCM"); + IF_GUID_EQUAL_RETURN(guid,0x1dc1b82f,0x11c8,0x4c71,0xb7,0xb6,0xee,0x3e,0xb9,0xbc,0x2b,0x94,"CODECAPI_GUID_AVEncSDDS"); + IF_GUID_EQUAL_RETURN(guid,0x55ca7265,0x23d8,0x4761,0x90,0x31,0xb7,0x4f,0xbe,0x12,0xf4,0xc1,"CODECAPI_GUID_AVEncWMALossless"); + IF_GUID_EQUAL_RETURN(guid,0x1955f90c,0x33f7,0x4a68,0xab,0x81,0x53,0xf5,0x65,0x71,0x25,0xc4,"CODECAPI_GUID_AVEncWMAPro"); + IF_GUID_EQUAL_RETURN(guid,0x13ed18cb,0x50e8,0x4276,0xa2,0x88,0xa6,0xaa,0x22,0x83,0x82,0xd9,"CODECAPI_GUID_AVEncWMAVoice"); + IF_GUID_EQUAL_RETURN(guid,0x4e0fef9b,0x1d43,0x41bd,0xb8,0xbd,0x4d,0x7b,0xf7,0x45,0x7a,0x2a,"CODECAPI_GUID_AVEncWMV"); + IF_GUID_EQUAL_RETURN(guid,0xdd37b12a,0x9503,0x4f8b,0xb8,0xd0,0x32,0x4a,0x00,0xc0,0xa1,0xcf,"CODECAPI_GUID_AVEndMPEG4Video"); + IF_GUID_EQUAL_RETURN(guid,0x6c5e6a7c,0xacf8,0x4f55,0xa9,0x99,0x1a,0x62,0x81,0x09,0x05,0x1b,"CODECAPI_SETALLDEFAULTS"); + IF_GUID_EQUAL_RETURN(guid,0x0581af97,0x7693,0x4dbd,0x9d,0xca,0x3f,0x9e,0xbd,0x65,0x85,0xa1,"CODECAPI_SUPPORTSEVENTS"); + IF_GUID_EQUAL_RETURN(guid,0x7112e8e1,0x3d03,0x47ef,0x8e,0x60,0x03,0xf1,0xcf,0x53,0x73,0x01,"CODECAPI_VIDEO_ENCODER"); + IF_GUID_EQUAL_RETURN(guid,0x286bbff3,0xbad4,0x438f,0xb0,0x7,0x79,0xb7,0x26,0x7c,0x3d,0x48,"CPFG_CREDENTIAL_PROVIDER_LABEL"); + IF_GUID_EQUAL_RETURN(guid,0x2d837775,0xf6cd,0x464e,0xa7,0x45,0x48,0x2f,0xd0,0xb4,0x74,0x93,"CPFG_CREDENTIAL_PROVIDER_LOGO"); + IF_GUID_EQUAL_RETURN(guid,0x60624cfa,0xa477,0x47b1,0x8a,0x8e,0x3a,0x4a,0x19,0x98,0x18,0x27,"CPFG_LOGON_PASSWORD"); + IF_GUID_EQUAL_RETURN(guid,0xda15bbe8,0x954d,0x4fd3,0xb0,0xf4,0x1f,0xb5,0xb9,0x0b,0x17,0x4b,"CPFG_LOGON_USERNAME"); + IF_GUID_EQUAL_RETURN(guid,0x4fe5263b,0x9181,0x46c1,0xb0,0xa4,0x9d,0xed,0xd4,0xdb,0x7d,0xea,"CPFG_SMARTCARD_PIN"); + IF_GUID_EQUAL_RETURN(guid,0x3e1ecf69,0x568c,0x4d96,0x9d,0x59,0x46,0x44,0x41,0x74,0xe2,0xd6,"CPFG_SMARTCARD_USERNAME"); + IF_GUID_EQUAL_RETURN(guid,0x2d7a2816,0x0c5e,0x45fc,0x9c,0xe7,0x57,0x0e,0x5e,0xcd,0xe9,0xc9,"CUSTOM_SYSTEM_STATE_CHANGE_EVENT_GUID"); + IF_GUID_EQUAL_RETURN(guid,0x8913eb88,0x00e5,0x46bc,0x8e,0x4e,0x14,0xa7,0x86,0xe1,0x65,0xa1,"Calendar_Control_GUID"); + IF_GUID_EQUAL_RETURN(guid,0xfb50f922,0xa3db,0x49c0,0x8b,0xc3,0x06,0xda,0xd5,0x57,0x78,0xe2,"CheckBox_Control_GUID"); + IF_GUID_EQUAL_RETURN(guid,0x157b7215,0x894f,0x4b65,0x84,0xe2,0xaa,0xc0,0xda,0x08,0xb1,0x6b,"ClassName_Property_GUID"); + IF_GUID_EQUAL_RETURN(guid,0x0196903b,0xb203,0x4818,0xa9,0xf3,0xf0,0x8e,0x67,0x5f,0x23,0x41,"ClickablePoint_Property_GUID"); + IF_GUID_EQUAL_RETURN(guid,0x54cb426c,0x2f33,0x4fff,0xaa,0xa1,0xae,0xf6,0x0d,0xac,0x5d,0xeb,"ComboBox_Control_GUID"); + IF_GUID_EQUAL_RETURN(guid,0xca774fea,0x28ac,0x4bc2,0x94,0xca,0xac,0xec,0x6d,0x6c,0x10,0xa3,"ControlType_Property_GUID"); + IF_GUID_EQUAL_RETURN(guid,0x51124c8a,0xa5d2,0x4f13,0x9b,0xe6,0x7f,0xa8,0xba,0x9d,0x3a,0x90,"ControllerFor_Property_GUID"); + IF_GUID_EQUAL_RETURN(guid,0xeb40cb65,0x3c1f,0x4352,0x9d,0x7b,0xba,0xf,0xc4,0x7a,0x9d,0x77,"CorSym_DocumentType_MC"); + IF_GUID_EQUAL_RETURN(guid,0x5a869d0b,0x6611,0x11d3,0xbd,0x2a,0x0,0x0,0xf8,0x8,0x49,0xbd,"CorSym_DocumentType_Text"); + IF_GUID_EQUAL_RETURN(guid,0x3a12d0b8,0xc26c,0x11d0,0xb4,0x42,0x0,0xa0,0x24,0x4a,0x1d,0xd2,"CorSym_LanguageType_Basic"); + IF_GUID_EQUAL_RETURN(guid,0x63a08714,0xfc37,0x11d2,0x90,0x4c,0x0,0xc0,0x4f,0xa3,0x02,0xa1,"CorSym_LanguageType_C"); + IF_GUID_EQUAL_RETURN(guid,0x3a12d0b7,0xc26c,0x11d0,0xb4,0x42,0x0,0xa0,0x24,0x4a,0x1d,0xd2,"CorSym_LanguageType_CPlusPlus"); + IF_GUID_EQUAL_RETURN(guid,0x3f5162f8,0x07c6,0x11d3,0x90,0x53,0x0,0xc0,0x4f,0xa3,0x02,0xa1,"CorSym_LanguageType_CSharp"); + IF_GUID_EQUAL_RETURN(guid,0xaf046cd1,0xd0e1,0x11d2,0x97,0x7c,0x0,0xa0,0xc9,0xb4,0xd5,0xc,"CorSym_LanguageType_Cobol"); + IF_GUID_EQUAL_RETURN(guid,0xaf046cd3,0xd0e1,0x11d2,0x97,0x7c,0x0,0xa0,0xc9,0xb4,0xd5,0xc,"CorSym_LanguageType_ILAssembly"); + IF_GUID_EQUAL_RETURN(guid,0x3a12d0b6,0xc26c,0x11d0,0xb4,0x42,0x00,0xa0,0x24,0x4a,0x1d,0xd2,"CorSym_LanguageType_JScript"); + IF_GUID_EQUAL_RETURN(guid,0x3a12d0b4,0xc26c,0x11d0,0xb4,0x42,0x0,0xa0,0x24,0x4a,0x1d,0xd2,"CorSym_LanguageType_Java"); + IF_GUID_EQUAL_RETURN(guid,0x4b35fde8,0x07c6,0x11d3,0x90,0x53,0x0,0xc0,0x4f,0xa3,0x02,0xa1,"CorSym_LanguageType_MCPlusPlus"); + IF_GUID_EQUAL_RETURN(guid,0xaf046cd2,0xd0e1,0x11d2,0x97,0x7c,0x0,0xa0,0xc9,0xb4,0xd5,0xc,"CorSym_LanguageType_Pascal"); + IF_GUID_EQUAL_RETURN(guid,0xd9b9f7b,0x6611,0x11d3,0xbd,0x2a,0x0,0x0,0xf8,0x8,0x49,0xbd,"CorSym_LanguageType_SMC"); + IF_GUID_EQUAL_RETURN(guid,0x994b45c4,0xe6e9,0x11d2,0x90,0x3f,0x00,0xc0,0x4f,0xa3,0x02,0xa1,"CorSym_LanguageVendor_Microsoft"); + IF_GUID_EQUAL_RETURN(guid,0x406ea660,0x64cf,0x4c82,0xb6,0xf0,0x42,0xd4,0x81,0x72,0xa7,0x99,"CorSym_SourceHash_MD5"); + IF_GUID_EQUAL_RETURN(guid,0xff1816ec,0xaa5e,0x4d10,0x87,0xf7,0x6f,0x49,0x63,0x83,0x34,0x60,"CorSym_SourceHash_SHA1"); + IF_GUID_EQUAL_RETURN(guid,0xe2d74f27,0x3d79,0x4dc2,0xb8,0x8b,0x30,0x44,0x96,0x3a,0x8a,0xfb,"Culture_Property_GUID"); + IF_GUID_EQUAL_RETURN(guid,0xf29ea0c3,0xadb7,0x430a,0xba,0x90,0xe5,0x2c,0x73,0x13,0xe6,0xed,"Custom_Control_GUID"); + IF_GUID_EQUAL_RETURN(guid,0x6346cc54,0x2cfc,0x4ad4,0x82,0x24,0xd1,0x58,0x37,0xde,0x77,0x0,"D3D11_AUTHENTICATED_CONFIGURE_CRYPTO_SESSION"); + IF_GUID_EQUAL_RETURN(guid,0x41fff286,0x6ae0,0x4d43,0x9d,0x55,0xa4,0x6e,0x9e,0xfd,0x15,0x8a,"D3D11_AUTHENTICATED_CONFIGURE_ENCRYPTION_WHEN_ACCESSIBLE"); + IF_GUID_EQUAL_RETURN(guid,0x6114bdb,0x3523,0x470a,0x8d,0xca,0xfb,0xc2,0x84,0x51,0x54,0xf0,"D3D11_AUTHENTICATED_CONFIGURE_INITIALIZE"); + IF_GUID_EQUAL_RETURN(guid,0x50455658,0x3f47,0x4362,0xbf,0x99,0xbf,0xdf,0xcd,0xe9,0xed,0x29,"D3D11_AUTHENTICATED_CONFIGURE_PROTECTION"); + IF_GUID_EQUAL_RETURN(guid,0x772d047,0x1b40,0x48e8,0x9c,0xa6,0xb5,0xf5,0x10,0xde,0x9f,0x1,"D3D11_AUTHENTICATED_CONFIGURE_SHARED_RESOURCE"); + IF_GUID_EQUAL_RETURN(guid,0x6214d9d2,0x432c,0x4abb,0x9f,0xce,0x21,0x6e,0xea,0x26,0x9e,0x3b,"D3D11_AUTHENTICATED_QUERY_ACCESSIBILITY_ATTRIBUTES"); + IF_GUID_EQUAL_RETURN(guid,0xbc1b18a5,0xb1fb,0x42ab,0xbd,0x94,0xb5,0x82,0x8b,0x4b,0xf7,0xbe,"D3D11_AUTHENTICATED_QUERY_CHANNEL_TYPE"); + IF_GUID_EQUAL_RETURN(guid,0x2634499e,0xd018,0x4d74,0xac,0x17,0x7f,0x72,0x40,0x59,0x52,0x8d,"D3D11_AUTHENTICATED_QUERY_CRYPTO_SESSION"); + IF_GUID_EQUAL_RETURN(guid,0xec1791c7,0xdad3,0x4f15,0x9e,0xc3,0xfa,0xa9,0x3d,0x60,0xd4,0xf0,"D3D11_AUTHENTICATED_QUERY_CURRENT_ENCRYPTION_WHEN_ACCESSIBLE"); + IF_GUID_EQUAL_RETURN(guid,0xec1c539d,0x8cff,0x4e2a,0xbc,0xc4,0xf5,0x69,0x2f,0x99,0xf4,0x80,"D3D11_AUTHENTICATED_QUERY_DEVICE_HANDLE"); + IF_GUID_EQUAL_RETURN(guid,0xf83a5958,0xe986,0x4bda,0xbe,0xb0,0x41,0x1f,0x6a,0x7a,0x1,0xb7,"D3D11_AUTHENTICATED_QUERY_ENCRYPTION_WHEN_ACCESSIBLE_GUID"); + IF_GUID_EQUAL_RETURN(guid,0xb30f7066,0x203c,0x4b07,0x93,0xfc,0xce,0xaa,0xfd,0x61,0x24,0x1e,"D3D11_AUTHENTICATED_QUERY_ENCRYPTION_WHEN_ACCESSIBLE_GUID_COUNT"); + IF_GUID_EQUAL_RETURN(guid,0x839ddca3,0x9b4e,0x41e4,0xb0,0x53,0x89,0x2b,0xd2,0xa1,0x1e,0xe7,"D3D11_AUTHENTICATED_QUERY_OUTPUT_ID"); + IF_GUID_EQUAL_RETURN(guid,0x2c042b5e,0x8c07,0x46d5,0xaa,0xbe,0x8f,0x75,0xcb,0xad,0x4c,0x31,"D3D11_AUTHENTICATED_QUERY_OUTPUT_ID_COUNT"); + IF_GUID_EQUAL_RETURN(guid,0xa84eb584,0xc495,0x48aa,0xb9,0x4d,0x8b,0xd2,0xd6,0xfb,0xce,0x5,"D3D11_AUTHENTICATED_QUERY_PROTECTION"); + IF_GUID_EQUAL_RETURN(guid,0x649bbadb,0xf0f4,0x4639,0xa1,0x5b,0x24,0x39,0x3f,0xc3,0xab,0xac,"D3D11_AUTHENTICATED_QUERY_RESTRICTED_SHARED_RESOURCE_PROCESS"); + IF_GUID_EQUAL_RETURN(guid,0xdb207b3,0x9450,0x46a6,0x82,0xde,0x1b,0x96,0xd4,0x4f,0x9c,0xf2,"D3D11_AUTHENTICATED_QUERY_RESTRICTED_SHARED_RESOURCE_PROCESS_COUNT"); + IF_GUID_EQUAL_RETURN(guid,0x12f0bd6,0xe662,0x4474,0xbe,0xfd,0xaa,0x53,0xe5,0x14,0x3c,0x6d,"D3D11_AUTHENTICATED_QUERY_UNRESTRICTED_PROTECTED_SHARED_RESOURCE_COUNT"); + IF_GUID_EQUAL_RETURN(guid,0x9b6bd711,0x4f74,0x41c9,0x9e,0x7b,0xb,0xe2,0xd7,0xd9,0x3b,0x4f,"D3D11_CRYPTO_TYPE_AES128_CTR"); + IF_GUID_EQUAL_RETURN(guid,0x1b81be67,0xa0c7,0x11d3,0xb9,0x84,0x00,0xc0,0x4f,0x2e,0x73,0xc5,"D3D11_DECODER_PROFILE_H264_IDCT_FGT"); + IF_GUID_EQUAL_RETURN(guid,0x1b81be66,0xa0c7,0x11d3,0xb9,0x84,0x00,0xc0,0x4f,0x2e,0x73,0xc5,"D3D11_DECODER_PROFILE_H264_IDCT_NOFGT"); + IF_GUID_EQUAL_RETURN(guid,0x1b81be65,0xa0c7,0x11d3,0xb9,0x84,0x00,0xc0,0x4f,0x2e,0x73,0xc5,"D3D11_DECODER_PROFILE_H264_MOCOMP_FGT"); + IF_GUID_EQUAL_RETURN(guid,0x1b81be64,0xa0c7,0x11d3,0xb9,0x84,0x00,0xc0,0x4f,0x2e,0x73,0xc5,"D3D11_DECODER_PROFILE_H264_MOCOMP_NOFGT"); + IF_GUID_EQUAL_RETURN(guid,0x1b81be69,0xa0c7,0x11d3,0xb9,0x84,0x00,0xc0,0x4f,0x2e,0x73,0xc5,"D3D11_DECODER_PROFILE_H264_VLD_FGT"); + IF_GUID_EQUAL_RETURN(guid,0x705b9d82,0x76cf,0x49d6,0xb7,0xe6,0xac,0x88,0x72,0xdb,0x01,0x3c,"D3D11_DECODER_PROFILE_H264_VLD_MULTIVIEW_NOFGT"); + IF_GUID_EQUAL_RETURN(guid,0x1b81be68,0xa0c7,0x11d3,0xb9,0x84,0x00,0xc0,0x4f,0x2e,0x73,0xc5,"D3D11_DECODER_PROFILE_H264_VLD_NOFGT"); + IF_GUID_EQUAL_RETURN(guid,0xf9aaccbb,0xc2b6,0x4cfc,0x87,0x79,0x57,0x07,0xb1,0x76,0x05,0x52,"D3D11_DECODER_PROFILE_H264_VLD_STEREO_NOFGT"); + IF_GUID_EQUAL_RETURN(guid,0xd79be8da,0x0cf1,0x4c81,0xb8,0x2a,0x69,0xa4,0xe2,0x36,0xf4,0x3d,"D3D11_DECODER_PROFILE_H264_VLD_STEREO_PROGRESSIVE_NOFGT"); + IF_GUID_EQUAL_RETURN(guid,0xd5f04ff9,0x3418,0x45d8,0x95,0x61,0x32,0xa7,0x6a,0xae,0x2d,0xdd,"D3D11_DECODER_PROFILE_H264_VLD_WITHFMOASO_NOFGT"); + IF_GUID_EQUAL_RETURN(guid,0x6f3ec719,0x3735,0x42cc,0x80,0x63,0x65,0xcc,0x3c,0xb3,0x66,0x16,"D3D11_DECODER_PROFILE_MPEG1_VLD"); + IF_GUID_EQUAL_RETURN(guid,0xbf22ad00,0x03ea,0x4690,0x80,0x77,0x47,0x33,0x46,0x20,0x9b,0x7e,"D3D11_DECODER_PROFILE_MPEG2_IDCT"); + IF_GUID_EQUAL_RETURN(guid,0xe6a9f44b,0x61b0,0x4563,0x9e,0xa4,0x63,0xd2,0xa3,0xc6,0xfe,0x66,"D3D11_DECODER_PROFILE_MPEG2_MOCOMP"); + IF_GUID_EQUAL_RETURN(guid,0xee27417f,0x5e28,0x4e65,0xbe,0xea,0x1d,0x26,0xb5,0x08,0xad,0xc9,"D3D11_DECODER_PROFILE_MPEG2_VLD"); + IF_GUID_EQUAL_RETURN(guid,0x86695f12,0x340e,0x4f04,0x9f,0xd3,0x92,0x53,0xdd,0x32,0x74,0x60,"D3D11_DECODER_PROFILE_MPEG2and1_VLD"); + IF_GUID_EQUAL_RETURN(guid,0xab998b5b,0x4258,0x44a9,0x9f,0xeb,0x94,0xe5,0x97,0xa6,0xba,0xae,"D3D11_DECODER_PROFILE_MPEG4PT2_VLD_ADVSIMPLE_GMC"); + IF_GUID_EQUAL_RETURN(guid,0xed418a9f,0x010d,0x4eda,0x9a,0xe3,0x9a,0x65,0x35,0x8d,0x8d,0x2e,"D3D11_DECODER_PROFILE_MPEG4PT2_VLD_ADVSIMPLE_NOGMC"); + IF_GUID_EQUAL_RETURN(guid,0xefd64d74,0xc9e8,0x41d7,0xa5,0xe9,0xe9,0xb0,0xe3,0x9f,0xa3,0x19,"D3D11_DECODER_PROFILE_MPEG4PT2_VLD_SIMPLE"); + IF_GUID_EQUAL_RETURN(guid,0x1b81beA4,0xa0c7,0x11d3,0xb9,0x84,0x00,0xc0,0x4f,0x2e,0x73,0xc5,"D3D11_DECODER_PROFILE_VC1_D2010"); + IF_GUID_EQUAL_RETURN(guid,0x1b81beA2,0xa0c7,0x11d3,0xb9,0x84,0x00,0xc0,0x4f,0x2e,0x73,0xc5,"D3D11_DECODER_PROFILE_VC1_IDCT"); + IF_GUID_EQUAL_RETURN(guid,0x1b81beA1,0xa0c7,0x11d3,0xb9,0x84,0x00,0xc0,0x4f,0x2e,0x73,0xc5,"D3D11_DECODER_PROFILE_VC1_MOCOMP"); + IF_GUID_EQUAL_RETURN(guid,0x1b81beA0,0xa0c7,0x11d3,0xb9,0x84,0x00,0xc0,0x4f,0x2e,0x73,0xc5,"D3D11_DECODER_PROFILE_VC1_POSTPROC"); + IF_GUID_EQUAL_RETURN(guid,0x1b81beA3,0xa0c7,0x11d3,0xb9,0x84,0x00,0xc0,0x4f,0x2e,0x73,0xc5,"D3D11_DECODER_PROFILE_VC1_VLD"); + IF_GUID_EQUAL_RETURN(guid,0x1b81be81,0xa0c7,0x11d3,0xb9,0x84,0x00,0xc0,0x4f,0x2e,0x73,0xc5,"D3D11_DECODER_PROFILE_WMV8_MOCOMP"); + IF_GUID_EQUAL_RETURN(guid,0x1b81be80,0xa0c7,0x11d3,0xb9,0x84,0x00,0xc0,0x4f,0x2e,0x73,0xc5,"D3D11_DECODER_PROFILE_WMV8_POSTPROC"); + IF_GUID_EQUAL_RETURN(guid,0x1b81be94,0xa0c7,0x11d3,0xb9,0x84,0x00,0xc0,0x4f,0x2e,0x73,0xc5,"D3D11_DECODER_PROFILE_WMV9_IDCT"); + IF_GUID_EQUAL_RETURN(guid,0x1b81be91,0xa0c7,0x11d3,0xb9,0x84,0x00,0xc0,0x4f,0x2e,0x73,0xc5,"D3D11_DECODER_PROFILE_WMV9_MOCOMP"); + IF_GUID_EQUAL_RETURN(guid,0x1b81be90,0xa0c7,0x11d3,0xb9,0x84,0x00,0xc0,0x4f,0x2e,0x73,0xc5,"D3D11_DECODER_PROFILE_WMV9_POSTPROC"); + IF_GUID_EQUAL_RETURN(guid,0xc1949895,0xd72a,0x4a1d,0x8e,0x5d,0xed,0x85,0x7d,0x17,0x15,0x20,"D3D11_KEY_EXCHANGE_RSAES_OAEP"); + IF_GUID_EQUAL_RETURN(guid,0x6346cc54,0x2cfc,0x4ad4,0x82,0x24,0xd1,0x58,0x37,0xde,0x77,0x0,"D3DAUTHENTICATEDCONFIGURE_CRYPTOSESSION"); + IF_GUID_EQUAL_RETURN(guid,0x41fff286,0x6ae0,0x4d43,0x9d,0x55,0xa4,0x6e,0x9e,0xfd,0x15,0x8a,"D3DAUTHENTICATEDCONFIGURE_ENCRYPTIONWHENACCESSIBLE"); + IF_GUID_EQUAL_RETURN(guid,0x6114bdb,0x3523,0x470a,0x8d,0xca,0xfb,0xc2,0x84,0x51,0x54,0xf0,"D3DAUTHENTICATEDCONFIGURE_INITIALIZE"); + IF_GUID_EQUAL_RETURN(guid,0x50455658,0x3f47,0x4362,0xbf,0x99,0xbf,0xdf,0xcd,0xe9,0xed,0x29,"D3DAUTHENTICATEDCONFIGURE_PROTECTION"); + IF_GUID_EQUAL_RETURN(guid,0x772d047,0x1b40,0x48e8,0x9c,0xa6,0xb5,0xf5,0x10,0xde,0x9f,0x1,"D3DAUTHENTICATEDCONFIGURE_SHAREDRESOURCE"); + IF_GUID_EQUAL_RETURN(guid,0x6214d9d2,0x432c,0x4abb,0x9f,0xce,0x21,0x6e,0xea,0x26,0x9e,0x3b,"D3DAUTHENTICATEDQUERY_ACCESSIBILITYATTRIBUTES"); + IF_GUID_EQUAL_RETURN(guid,0xbc1b18a5,0xb1fb,0x42ab,0xbd,0x94,0xb5,0x82,0x8b,0x4b,0xf7,0xbe,"D3DAUTHENTICATEDQUERY_CHANNELTYPE"); + IF_GUID_EQUAL_RETURN(guid,0x2634499e,0xd018,0x4d74,0xac,0x17,0x7f,0x72,0x40,0x59,0x52,0x8d,"D3DAUTHENTICATEDQUERY_CRYPTOSESSION"); + IF_GUID_EQUAL_RETURN(guid,0xec1791c7,0xdad3,0x4f15,0x9e,0xc3,0xfa,0xa9,0x3d,0x60,0xd4,0xf0,"D3DAUTHENTICATEDQUERY_CURRENTENCRYPTIONWHENACCESSIBLE"); + IF_GUID_EQUAL_RETURN(guid,0xec1c539d,0x8cff,0x4e2a,0xbc,0xc4,0xf5,0x69,0x2f,0x99,0xf4,0x80,"D3DAUTHENTICATEDQUERY_DEVICEHANDLE"); + IF_GUID_EQUAL_RETURN(guid,0xf83a5958,0xe986,0x4bda,0xbe,0xb0,0x41,0x1f,0x6a,0x7a,0x1,0xb7,"D3DAUTHENTICATEDQUERY_ENCRYPTIONWHENACCESSIBLEGUID"); + IF_GUID_EQUAL_RETURN(guid,0xb30f7066,0x203c,0x4b07,0x93,0xfc,0xce,0xaa,0xfd,0x61,0x24,0x1e,"D3DAUTHENTICATEDQUERY_ENCRYPTIONWHENACCESSIBLEGUIDCOUNT"); + IF_GUID_EQUAL_RETURN(guid,0x839ddca3,0x9b4e,0x41e4,0xb0,0x53,0x89,0x2b,0xd2,0xa1,0x1e,0xe7,"D3DAUTHENTICATEDQUERY_OUTPUTID"); + IF_GUID_EQUAL_RETURN(guid,0x2c042b5e,0x8c07,0x46d5,0xaa,0xbe,0x8f,0x75,0xcb,0xad,0x4c,0x31,"D3DAUTHENTICATEDQUERY_OUTPUTIDCOUNT"); + IF_GUID_EQUAL_RETURN(guid,0xa84eb584,0xc495,0x48aa,0xb9,0x4d,0x8b,0xd2,0xd6,0xfb,0xce,0x5,"D3DAUTHENTICATEDQUERY_PROTECTION"); + IF_GUID_EQUAL_RETURN(guid,0x649bbadb,0xf0f4,0x4639,0xa1,0x5b,0x24,0x39,0x3f,0xc3,0xab,0xac,"D3DAUTHENTICATEDQUERY_RESTRICTEDSHAREDRESOURCEPROCESS"); + IF_GUID_EQUAL_RETURN(guid,0xdb207b3,0x9450,0x46a6,0x82,0xde,0x1b,0x96,0xd4,0x4f,0x9c,0xf2,"D3DAUTHENTICATEDQUERY_RESTRICTEDSHAREDRESOURCEPROCESSCOUNT"); + IF_GUID_EQUAL_RETURN(guid,0x12f0bd6,0xe662,0x4474,0xbe,0xfd,0xaa,0x53,0xe5,0x14,0x3c,0x6d,"D3DAUTHENTICATEDQUERY_UNRESTRICTEDPROTECTEDSHAREDRESOURCECOUNT"); + IF_GUID_EQUAL_RETURN(guid,0x9b6bd711,0x4f74,0x41c9,0x9e,0x7b,0xb,0xe2,0xd7,0xd9,0x3b,0x4f,"D3DCRYPTOTYPE_AES128_CTR"); + IF_GUID_EQUAL_RETURN(guid,0xab4e9afd,0x1d1c,0x46e6,0xa7,0x2f,0x8,0x69,0x91,0x7b,0xd,0xe8,"D3DCRYPTOTYPE_PROPRIETARY"); + IF_GUID_EQUAL_RETURN(guid,0x43d3775c,0x38e5,0x4924,0x8d,0x86,0xd3,0xfc,0xcf,0x15,0x3e,0x9b,"D3DKEYEXCHANGE_DXVA"); + IF_GUID_EQUAL_RETURN(guid,0xc1949895,0xd72a,0x4a1d,0x8e,0x5d,0xed,0x85,0x7d,0x17,0x15,0x20,"D3DKEYEXCHANGE_RSAES_OAEP"); + IF_GUID_EQUAL_RETURN(guid,0x5d531cb2L,0xe6ed,0x11d2,0xb2,0x52,0x00,0xc0,0x4f,0x68,0x1b,0x71,"DBGUID_MSSQLXML"); + IF_GUID_EQUAL_RETURN(guid,0xec2a4293L,0xe898,0x11d2,0xb1,0xb7,0x00,0xc0,0x4f,0x68,0x0c,0x56,"DBGUID_XPATH"); + IF_GUID_EQUAL_RETURN(guid,0xb68e3cc1,0x6deb,0x11d0,0x8d,0xf6,0x00,0xaa,0x00,0x5f,0xfe,0x58,"DBPROPSET_ADC"); + IF_GUID_EQUAL_RETURN(guid,0x7f06a375,0xdd6a,0x43db,0xb4,0xe0,0x1f,0xc1,0x21,0xe5,0xe6,0x2b,"DBPROPSET_MSDAORA8_ROWSET"); + IF_GUID_EQUAL_RETURN(guid,0xE8CC4CBD,0xFDFF,0x11D0,0xB8,0x65,0x00,0xA0,0xC9,0x08,0x1C,0x1D,"DBPROPSET_MSDAORA_ROWSET"); + IF_GUID_EQUAL_RETURN(guid,0x55cb91a8,0x5c7a,0x11d1,0xad,0xad,0,0xc0,0x4f,0xc2,0x98,0x63,"DBPROPSET_MSDSDBINIT"); + IF_GUID_EQUAL_RETURN(guid,0xedf17536,0xafbf,0x11d1,0x88,0x47,0,0,0xf8,0x79,0xf9,0x8c,"DBPROPSET_MSDSSESSION"); + IF_GUID_EQUAL_RETURN(guid,0x497c60e4,0x7123,0x11cf,0xb1,0x71,0x0,0xaa,0x0,0x57,0x59,0x9e,"DBPROPSET_PROVIDERCONNATTR"); + IF_GUID_EQUAL_RETURN(guid,0x497c60e0,0x7123,0x11cf,0xb1,0x71,0x0,0xaa,0x0,0x57,0x59,0x9e,"DBPROPSET_PROVIDERDATASOURCEINFO"); + IF_GUID_EQUAL_RETURN(guid,0x497c60e2,0x7123,0x11cf,0xb1,0x71,0x0,0xaa,0x0,0x57,0x59,0x9e,"DBPROPSET_PROVIDERDBINIT"); + IF_GUID_EQUAL_RETURN(guid,0x497c60e1,0x7123,0x11cf,0xb1,0x71,0x0,0xaa,0x0,0x57,0x59,0x9e,"DBPROPSET_PROVIDERROWSET"); + IF_GUID_EQUAL_RETURN(guid,0x497c60e3,0x7123,0x11cf,0xb1,0x71,0x0,0xaa,0x0,0x57,0x59,0x9e,"DBPROPSET_PROVIDERSTMTATTR"); + IF_GUID_EQUAL_RETURN(guid,0x3b63fb5e,0x3fbb,0x11d3,0x9f,0x29,0x0,0xc0,0x4f,0x8e,0xe9,0xdc,"DBPROPSET_SQLSERVERCOLUMN"); + IF_GUID_EQUAL_RETURN(guid,0x28efaee4,0x2d2c,0x11d1,0x98,0x7,0x0,0xc0,0x4f,0xc2,0xad,0x98,"DBPROPSET_SQLSERVERDATASOURCE"); + IF_GUID_EQUAL_RETURN(guid,0xdf10cb94,0x35f6,0x11d2,0x9c,0x54,0x0,0xc0,0x4f,0x79,0x71,0xd3,"DBPROPSET_SQLSERVERDATASOURCEINFO"); + IF_GUID_EQUAL_RETURN(guid,0x5cf4ca10,0xef21,0x11d0,0x97,0xe7,0x0,0xc0,0x4f,0xc2,0xad,0x98,"DBPROPSET_SQLSERVERDBINIT"); + IF_GUID_EQUAL_RETURN(guid,0x5cf4ca11,0xef21,0x11d0,0x97,0xe7,0x0,0xc0,0x4f,0xc2,0xad,0x98,"DBPROPSET_SQLSERVERROWSET"); + IF_GUID_EQUAL_RETURN(guid,0x28efaee5,0x2d2c,0x11d1,0x98,0x7,0x0,0xc0,0x4f,0xc2,0xad,0x98,"DBPROPSET_SQLSERVERSESSION"); + IF_GUID_EQUAL_RETURN(guid,0x9f79c073,0x8a6d,0x4bca,0xa8,0xa8,0xc9,0xb7,0x9a,0x9b,0x96,0x2d,"DBPROPSET_SQLSERVERSTREAM"); + IF_GUID_EQUAL_RETURN(guid,0x9093caf4,0x2eac,0x11d1,0x98,0x9,0x0,0xc0,0x4f,0xc2,0xad,0x98,"DBSCHEMA_LINKEDSERVERS"); + IF_GUID_EQUAL_RETURN(guid,0x1352A560L,0xDA61,0x11CF,0x9B,0x06,0x00,0xA0,0xC9,0x03,0xA3,0xB8,"DDVPTYPE_BROOKTREE"); + IF_GUID_EQUAL_RETURN(guid,0xFCA326A0L,0xDA60,0x11CF,0x9B,0x06,0x00,0xA0,0xC9,0x03,0xA3,0xB8,"DDVPTYPE_CCIR656"); + IF_GUID_EQUAL_RETURN(guid,0x54F39980L,0xDA60,0x11CF,0x9B,0x06,0x00,0xA0,0xC9,0x03,0xA3,0xB8,"DDVPTYPE_E_HREFH_VREFH"); + IF_GUID_EQUAL_RETURN(guid,0x92783220L,0xDA60,0x11CF,0x9B,0x06,0x00,0xA0,0xC9,0x03,0xA3,0xB8,"DDVPTYPE_E_HREFH_VREFL"); + IF_GUID_EQUAL_RETURN(guid,0xA07A02E0L,0xDA60,0x11CF,0x9B,0x06,0x00,0xA0,0xC9,0x03,0xA3,0xB8,"DDVPTYPE_E_HREFL_VREFH"); + IF_GUID_EQUAL_RETURN(guid,0xE09C77E0L,0xDA60,0x11CF,0x9B,0x06,0x00,0xA0,0xC9,0x03,0xA3,0xB8,"DDVPTYPE_E_HREFL_VREFL"); + IF_GUID_EQUAL_RETURN(guid,0x332CF160L,0xDA61,0x11CF,0x9B,0x06,0x00,0xA0,0xC9,0x03,0xA3,0xB8,"DDVPTYPE_PHILIPS"); + IF_GUID_EQUAL_RETURN(guid,0x2eef81be,0x33fa,0x4800,0x96,0x70,0x1c,0xd4,0x74,0x97,0x2c,0x3f,"DEVINTERFACE_AUDIO_CAPTURE"); + IF_GUID_EQUAL_RETURN(guid,0xe6327cad,0xdcec,0x4949,0xae,0x8a,0x99,0x1e,0x97,0x6a,0x79,0xd2,"DEVINTERFACE_AUDIO_RENDER"); + IF_GUID_EQUAL_RETURN(guid,0xC08C4FF2,0x0E2E,0x11cf,0x94,0x2C,0x00,0x80,0x29,0x00,0x43,0x47,"DIID_DICounterItem"); + IF_GUID_EQUAL_RETURN(guid,0x8D093FFC,0xF777,0x4917,0x82,0xD1,0x83,0x3F,0xBC,0x54,0xC5,0x8F,"DIID_DILogFileItem"); + IF_GUID_EQUAL_RETURN(guid,0x13D73D81,0xC32E,0x11cf,0x93,0x98,0x00,0xAA,0x00,0xA3,0xDD,0xEA,"DIID_DISystemMonitor"); + IF_GUID_EQUAL_RETURN(guid,0x84979930,0x4AB3,0x11cf,0x94,0x3A,0x00,0x80,0x29,0x00,0x43,0x47,"DIID_DISystemMonitorEvents"); + IF_GUID_EQUAL_RETURN(guid,0x194EB242,0xC32C,0x11cf,0x93,0x98,0x00,0xAA,0x00,0xA3,0xDD,0xEA,"DIID_DISystemMonitorInternal"); + IF_GUID_EQUAL_RETURN(guid,0xBF963D80L,0xC559,0x11D0,0x8A,0x2B,0x00,0xA0,0xC9,0x25,0x5A,0xC1,"DMOCATEGORY_ACOUSTIC_ECHO_CANCEL"); + IF_GUID_EQUAL_RETURN(guid,0xE88C9BA0L,0xC557,0x11D0,0x8A,0x2B,0x00,0xA0,0xC9,0x25,0x5A,0xC1,"DMOCATEGORY_AGC"); + IF_GUID_EQUAL_RETURN(guid,0xf665aaba,0x3e09,0x4920,0xaa,0x5f,0x21,0x98,0x11,0x14,0x8f,0x09,"DMOCATEGORY_AUDIO_CAPTURE_EFFECT"); + IF_GUID_EQUAL_RETURN(guid,0x57f2db8b,0xe6bb,0x4513,0x9d,0x43,0xdc,0xd2,0xa6,0x59,0x31,0x25,"DMOCATEGORY_AUDIO_DECODER"); + IF_GUID_EQUAL_RETURN(guid,0xf3602b3f,0x0592,0x48df,0xa4,0xcd,0x67,0x47,0x21,0xe7,0xeb,0xeb,"DMOCATEGORY_AUDIO_EFFECT"); + IF_GUID_EQUAL_RETURN(guid,0x33D9A761,0x90C8,0x11d0,0xBD,0x43,0x00,0xA0,0xC9,0x11,0xCE,0x86,"DMOCATEGORY_AUDIO_ENCODER"); + IF_GUID_EQUAL_RETURN(guid,0xe07f903f,0x62fd,0x4e60,0x8c,0xdd,0xde,0xa7,0x23,0x66,0x65,0xb5,"DMOCATEGORY_AUDIO_NOISE_SUPPRESS"); + IF_GUID_EQUAL_RETURN(guid,0x4a69b442,0x28be,0x4991,0x96,0x9c,0xb5,0x00,0xad,0xf5,0xd8,0xa8,"DMOCATEGORY_VIDEO_DECODER"); + IF_GUID_EQUAL_RETURN(guid,0xd990ee14,0x776c,0x4723,0xbe,0x46,0x3d,0xa2,0xf5,0x6f,0x10,0xb9,"DMOCATEGORY_VIDEO_EFFECT"); + IF_GUID_EQUAL_RETURN(guid,0x33D9A760,0x90C8,0x11d0,0xBD,0x43,0x00,0xA0,0xC9,0x11,0xCE,0x86,"DMOCATEGORY_VIDEO_ENCODER"); + IF_GUID_EQUAL_RETURN(guid,0x1ce20aba,0x9851,0x4421,0x94,0x30,0x1d,0xde,0xb7,0x66,0xe8,0x09,"DOMAIN_JOIN_GUID"); + IF_GUID_EQUAL_RETURN(guid,0xddaf516e,0x58c2,0x4866,0x95,0x74,0xc3,0xb6,0x15,0xd4,0x2e,0xa1,"DOMAIN_LEAVE_GUID"); + IF_GUID_EQUAL_RETURN(guid,0xc2413340,0x1c1b,0x11d2,0x94,0xf5,0x0,0xc0,0x4f,0xc2,0x8a,0xca,"DS3DALG_HRTF_FULL"); + IF_GUID_EQUAL_RETURN(guid,0xc2413342,0x1c1b,0x11d2,0x94,0xf5,0x0,0xc0,0x4f,0xc2,0x8a,0xca,"DS3DALG_HRTF_LIGHT"); + IF_GUID_EQUAL_RETURN(guid,0xc241333f,0x1c1b,0x11d2,0x94,0xf5,0x0,0xc0,0x4f,0xc2,0x8a,0xca,"DS3DALG_NO_VIRTUALIZATION"); + IF_GUID_EQUAL_RETURN(guid,0xe4846dda,0x5838,0x42b4,0xb8,0x97,0x6f,0x7e,0x5f,0xaa,0x2f,0x2f,"DSATTRIB_BadSampleInfo"); + IF_GUID_EQUAL_RETURN(guid,0x0c1a5614,0x30cd,0x4f40,0xbc,0xbf,0xd0,0x3e,0x52,0x30,0x62,0x07,"DSATTRIB_CAPTURE_STREAMTIME"); + IF_GUID_EQUAL_RETURN(guid,0xe7e050fb,0xdd5d,0x40dd,0x99,0x15,0x35,0xDC,0xB8,0x1B,0xDC,0x8a,"DSATTRIB_CC_CONTAINER_INFO"); + IF_GUID_EQUAL_RETURN(guid,0x5fb5673b,0xa2a,0x4565,0x82,0x7b,0x68,0x53,0xfd,0x75,0xe6,0x11,"DSATTRIB_DSHOW_STREAM_DESC"); + IF_GUID_EQUAL_RETURN(guid,0x5A5F08CA,0x55C2,0x4033,0x92,0xAB,0x55,0xDB,0x8F,0x78,0x12,0x26,"DSATTRIB_OptionalVideoAttributes"); + IF_GUID_EQUAL_RETURN(guid,0xe0b56679,0x12b9,0x43cc,0xb7,0xdf,0x57,0x8c,0xaa,0x5a,0x7b,0x63,"DSATTRIB_PBDATAG_ATTRIBUTE"); + IF_GUID_EQUAL_RETURN(guid,0x2f5bae02,0x7b8f,0x4f60,0x82,0xd6,0xe4,0xea,0x2f,0x1f,0x4c,0x99,"DSATTRIB_PicSampleSeq"); + IF_GUID_EQUAL_RETURN(guid,0x892cd111,0x72f3,0x411d,0x8b,0x91,0xa9,0xe9,0x12,0x3a,0xc2,0x9a,"DSATTRIB_SAMPLE_LIVE_STREAM_TIME"); + IF_GUID_EQUAL_RETURN(guid,0xb622f612,0x47ad,0x4671,0xad,0x6c,0x5,0xa9,0x8e,0x65,0xde,0x3a,"DSATTRIB_TRANSPORT_PROPERTIES"); + IF_GUID_EQUAL_RETURN(guid,0xEB7836CA,0x14FF,0x4919,0xbc,0xe7,0x3a,0xf1,0x23,0x19,0xe5,0x0c,"DSATTRIB_UDCRTag"); + IF_GUID_EQUAL_RETURN(guid,0x40749583,0x6b9d,0x4eec,0xb4,0x3c,0x67,0xa1,0x80,0x1e,0x1a,0x9b,"DSATTRIB_WMDRMProtectionInfo"); + IF_GUID_EQUAL_RETURN(guid,0xdef00001,0x9c6d,0x47ed,0xaa,0xf1,0x4d,0xda,0x8f,0x2b,0x5c,0x03,"DSDEVID_DefaultCapture"); + IF_GUID_EQUAL_RETURN(guid,0xdef00000,0x9c6d,0x47ed,0xaa,0xf1,0x4d,0xda,0x8f,0x2b,0x5c,0x03,"DSDEVID_DefaultPlayback"); + IF_GUID_EQUAL_RETURN(guid,0xdef00003,0x9c6d,0x47ed,0xaa,0xf1,0x4d,0xda,0x8f,0x2b,0x5c,0x03,"DSDEVID_DefaultVoiceCapture"); + IF_GUID_EQUAL_RETURN(guid,0xdef00002,0x9c6d,0x47ed,0xaa,0xf1,0x4d,0xda,0x8f,0x2b,0x5c,0x03,"DSDEVID_DefaultVoicePlayback"); + IF_GUID_EQUAL_RETURN(guid,0xe48ae283,0xda80,0x490b,0x87,0xe6,0x43,0xe9,0xa9,0xcf,0xda,0x8,"DXGI_DEBUG_ALL"); + IF_GUID_EQUAL_RETURN(guid,0x6cd6e01,0x4219,0x4ebd,0x87,0x9,0x27,0xed,0x23,0x36,0xc,0x62,"DXGI_DEBUG_APP"); + IF_GUID_EQUAL_RETURN(guid,0x243b4c52,0x3606,0x4d3a,0x99,0xd7,0xa7,0xe7,0xb3,0x3e,0xd7,0x6,"DXGI_DEBUG_D3D10"); + IF_GUID_EQUAL_RETURN(guid,0x4b99317b,0xac39,0x4aa6,0xbb,0xb,0xba,0xa0,0x47,0x84,0x79,0x8f,"DXGI_DEBUG_D3D11"); + IF_GUID_EQUAL_RETURN(guid,0x35cdd7fc,0x13b2,0x421d,0xa5,0xd7,0x7e,0x44,0x51,0x28,0x7d,0x64,"DXGI_DEBUG_DX"); + IF_GUID_EQUAL_RETURN(guid,0x25cddaa4,0xb1c6,0x47e1,0xac,0x3e,0x98,0x87,0x5b,0x5a,0x2e,0x2a,"DXGI_DEBUG_DXGI"); + IF_GUID_EQUAL_RETURN(guid,0x1b81be64,0xa0c7,0x11d3,0xb9,0x84,0x00,0xc0,0x4f,0x2e,0x73,0xc5,"DXVA2_ModeH264_A"); + IF_GUID_EQUAL_RETURN(guid,0x1b81be65,0xa0c7,0x11d3,0xb9,0x84,0x00,0xc0,0x4f,0x2e,0x73,0xc5,"DXVA2_ModeH264_B"); + IF_GUID_EQUAL_RETURN(guid,0x1b81be66,0xa0c7,0x11d3,0xb9,0x84,0x00,0xc0,0x4f,0x2e,0x73,0xc5,"DXVA2_ModeH264_C"); + IF_GUID_EQUAL_RETURN(guid,0x1b81be67,0xa0c7,0x11d3,0xb9,0x84,0x00,0xc0,0x4f,0x2e,0x73,0xc5,"DXVA2_ModeH264_D"); + IF_GUID_EQUAL_RETURN(guid,0x1b81be68,0xa0c7,0x11d3,0xb9,0x84,0x00,0xc0,0x4f,0x2e,0x73,0xc5,"DXVA2_ModeH264_E"); + IF_GUID_EQUAL_RETURN(guid,0x1b81be69,0xa0c7,0x11d3,0xb9,0x84,0x00,0xc0,0x4f,0x2e,0x73,0xc5,"DXVA2_ModeH264_F"); + IF_GUID_EQUAL_RETURN(guid,0x705b9d82,0x76cf,0x49d6,0xb7,0xe6,0xac,0x88,0x72,0xdb,0x01,0x3c,"DXVA2_ModeH264_VLD_Multiview_NoFGT"); + IF_GUID_EQUAL_RETURN(guid,0xf9aaccbb,0xc2b6,0x4cfc,0x87,0x79,0x57,0x07,0xb1,0x76,0x05,0x52,"DXVA2_ModeH264_VLD_Stereo_NoFGT"); + IF_GUID_EQUAL_RETURN(guid,0xd79be8da,0x0cf1,0x4c81,0xb8,0x2a,0x69,0xa4,0xe2,0x36,0xf4,0x3d,"DXVA2_ModeH264_VLD_Stereo_Progressive_NoFGT"); + IF_GUID_EQUAL_RETURN(guid,0xd5f04ff9,0x3418,0x45d8,0x95,0x61,0x32,0xa7,0x6a,0xae,0x2d,0xdd,"DXVA2_ModeH264_VLD_WithFMOASO_NoFGT"); + IF_GUID_EQUAL_RETURN(guid,0x6f3ec719,0x3735,0x42cc,0x80,0x63,0x65,0xcc,0x3c,0xb3,0x66,0x16,"DXVA2_ModeMPEG1_VLD"); + IF_GUID_EQUAL_RETURN(guid,0xbf22ad00,0x03ea,0x4690,0x80,0x77,0x47,0x33,0x46,0x20,0x9b,0x7e,"DXVA2_ModeMPEG2_IDCT"); + IF_GUID_EQUAL_RETURN(guid,0xe6a9f44b,0x61b0,0x4563,0x9e,0xa4,0x63,0xd2,0xa3,0xc6,0xfe,0x66,"DXVA2_ModeMPEG2_MoComp"); + IF_GUID_EQUAL_RETURN(guid,0xee27417f,0x5e28,0x4e65,0xbe,0xea,0x1d,0x26,0xb5,0x08,0xad,0xc9,"DXVA2_ModeMPEG2_VLD"); + IF_GUID_EQUAL_RETURN(guid,0x86695f12,0x340e,0x4f04,0x9f,0xd3,0x92,0x53,0xdd,0x32,0x74,0x60,"DXVA2_ModeMPEG2and1_VLD"); + IF_GUID_EQUAL_RETURN(guid,0xab998b5b,0x4258,0x44a9,0x9f,0xeb,0x94,0xe5,0x97,0xa6,0xba,0xae,"DXVA2_ModeMPEG4pt2_VLD_AdvSimple_GMC"); + IF_GUID_EQUAL_RETURN(guid,0xed418a9f,0x010d,0x4eda,0x9a,0xe3,0x9a,0x65,0x35,0x8d,0x8d,0x2e,"DXVA2_ModeMPEG4pt2_VLD_AdvSimple_NoGMC"); + IF_GUID_EQUAL_RETURN(guid,0xefd64d74,0xc9e8,0x41d7,0xa5,0xe9,0xe9,0xb0,0xe3,0x9f,0xa3,0x19,"DXVA2_ModeMPEG4pt2_VLD_Simple"); + IF_GUID_EQUAL_RETURN(guid,0x1b81beA0,0xa0c7,0x11d3,0xb9,0x84,0x00,0xc0,0x4f,0x2e,0x73,0xc5,"DXVA2_ModeVC1_A"); + IF_GUID_EQUAL_RETURN(guid,0x1b81beA1,0xa0c7,0x11d3,0xb9,0x84,0x00,0xc0,0x4f,0x2e,0x73,0xc5,"DXVA2_ModeVC1_B"); + IF_GUID_EQUAL_RETURN(guid,0x1b81beA2,0xa0c7,0x11d3,0xb9,0x84,0x00,0xc0,0x4f,0x2e,0x73,0xc5,"DXVA2_ModeVC1_C"); + IF_GUID_EQUAL_RETURN(guid,0x1b81beA4,0xa0c7,0x11d3,0xb9,0x84,0x00,0xc0,0x4f,0x2e,0x73,0xc5,"DXVA2_ModeVC1_D2010"); + IF_GUID_EQUAL_RETURN(guid,0x1b81beA3,0xa0c7,0x11d3,0xb9,0x84,0x00,0xc0,0x4f,0x2e,0x73,0xc5,"DXVA2_ModeVC1_D"); + IF_GUID_EQUAL_RETURN(guid,0x1b81be80,0xa0c7,0x11d3,0xb9,0x84,0x00,0xc0,0x4f,0x2e,0x73,0xc5,"DXVA2_ModeWMV8_A"); + IF_GUID_EQUAL_RETURN(guid,0x1b81be81,0xa0c7,0x11d3,0xb9,0x84,0x00,0xc0,0x4f,0x2e,0x73,0xc5,"DXVA2_ModeWMV8_B"); + IF_GUID_EQUAL_RETURN(guid,0x1b81be90,0xa0c7,0x11d3,0xb9,0x84,0x00,0xc0,0x4f,0x2e,0x73,0xc5,"DXVA2_ModeWMV9_A"); + IF_GUID_EQUAL_RETURN(guid,0x1b81be91,0xa0c7,0x11d3,0xb9,0x84,0x00,0xc0,0x4f,0x2e,0x73,0xc5,"DXVA2_ModeWMV9_B"); + IF_GUID_EQUAL_RETURN(guid,0x1b81be94,0xa0c7,0x11d3,0xb9,0x84,0x00,0xc0,0x4f,0x2e,0x73,0xc5,"DXVA2_ModeWMV9_C"); + IF_GUID_EQUAL_RETURN(guid,0x1b81beD0,0xa0c7,0x11d3,0xb9,0x84,0x00,0xc0,0x4f,0x2e,0x73,0xc5,"DXVA2_NoEncrypt"); + IF_GUID_EQUAL_RETURN(guid,0x335aa36e,0x7884,0x43a4,0x9c,0x91,0x7f,0x87,0xfa,0xf3,0xe3,0x7e,"DXVA2_VideoProcBobDevice"); + IF_GUID_EQUAL_RETURN(guid,0x5a54a0c9,0xc7ec,0x4bd9,0x8e,0xde,0xf3,0xc7,0x5d,0xc4,0x39,0x3b,"DXVA2_VideoProcProgressiveDevice"); + IF_GUID_EQUAL_RETURN(guid,0x4553d47f,0xee7e,0x4e3f,0x94,0x75,0xdb,0xf1,0x37,0x6c,0x48,0x10,"DXVA2_VideoProcSoftwareDevice"); + IF_GUID_EQUAL_RETURN(guid,0xa0386e75,0xf70c,0x464c,0xa9,0xce,0x33,0xc4,0x4e,0x09,0x16,0x23,"DXVAHDControlGuid"); + IF_GUID_EQUAL_RETURN(guid,0x681e3d1e,0x5674,0x4fb3,0xa5,0x03,0x2f,0x20,0x55,0xe9,0x1f,0x60,"DXVAHDETWGUID_CREATEVIDEOPROCESSOR"); + IF_GUID_EQUAL_RETURN(guid,0xf943f0a0,0x3f16,0x43e0,0x80,0x93,0x10,0x5a,0x98,0x6a,0xa5,0xf1,"DXVAHDETWGUID_DESTROYVIDEOPROCESSOR"); + IF_GUID_EQUAL_RETURN(guid,0xbef3d435,0x78c7,0x4de3,0x97,0x07,0xcd,0x1b,0x08,0x3b,0x16,0x0a,"DXVAHDETWGUID_VIDEOPROCESSBLTHD"); + IF_GUID_EQUAL_RETURN(guid,0x27ae473e,0xa5fc,0x4be5,0xb4,0xe3,0xf2,0x49,0x94,0xd3,0xc4,0x95,"DXVAHDETWGUID_VIDEOPROCESSBLTHD_STREAM"); + IF_GUID_EQUAL_RETURN(guid,0x76c94b5a,0x193f,0x4692,0x94,0x84,0xa4,0xd9,0x99,0xda,0x81,0xa8,"DXVAHDETWGUID_VIDEOPROCESSBLTSTATE"); + IF_GUID_EQUAL_RETURN(guid,0x262c0b02,0x209d,0x47ed,0x94,0xd8,0x82,0xae,0x02,0xb8,0x4a,0xa7,"DXVAHDETWGUID_VIDEOPROCESSSTREAMSTATE"); + IF_GUID_EQUAL_RETURN(guid,0x9c601e3c,0x0f33,0x414c,0xa7,0x39,0x99,0x54,0x0e,0xe4,0x2d,0xa5,"DXVAHD_STREAM_STATE_PRIVATE_IVTC"); + IF_GUID_EQUAL_RETURN(guid,0xd2457add,0x8999,0x45ed,0x8a,0x8a,0xd1,0xaa,0x04,0x7b,0xa4,0xd5,"DXVA_COPPDevice"); + IF_GUID_EQUAL_RETURN(guid,0xc6f4d673,0x6174,0x4184,0x8e,0x35,0xf6,0xdb,0x52,0x0,0xbc,0xba,"DXVA_COPPQueryBusData"); + IF_GUID_EQUAL_RETURN(guid,0x81d0bfd5,0x6afe,0x48c2,0x99,0xc0,0x95,0xa0,0x8f,0x97,0xc5,0xda,"DXVA_COPPQueryConnectorType"); + IF_GUID_EQUAL_RETURN(guid,0xd7bf1ba3,0xad13,0x4f8e,0xaf,0x98,0x0d,0xcb,0x3c,0xa2,0x04,0xcc,"DXVA_COPPQueryDisplayData"); + IF_GUID_EQUAL_RETURN(guid,0x1957210a,0x7766,0x452a,0xb9,0x9a,0xd2,0x7a,0xed,0x54,0xf0,0x3a,"DXVA_COPPQueryGlobalProtectionLevel"); + IF_GUID_EQUAL_RETURN(guid,0xdb59d74,0xa992,0x492e,0xa0,0xbd,0xc2,0x3f,0xda,0x56,0x4e,0x0,"DXVA_COPPQueryHDCPKeyData"); + IF_GUID_EQUAL_RETURN(guid,0xb2075857,0x3eda,0x4d5d,0x88,0xdb,0x74,0x8f,0x8c,0x1a,0x05,0x49,"DXVA_COPPQueryLocalProtectionLevel"); + IF_GUID_EQUAL_RETURN(guid,0x38f2a801,0x9a6c,0x48bb,0x91,0x07,0xb6,0x69,0x6e,0x6f,0x17,0x97,"DXVA_COPPQueryProtectionType"); + IF_GUID_EQUAL_RETURN(guid,0x6629a591,0x3b79,0x4cf3,0x92,0x4a,0x11,0xe8,0xe7,0x81,0x16,0x71,"DXVA_COPPQuerySignaling"); + IF_GUID_EQUAL_RETURN(guid,0x9bb9327c,0x4eb5,0x4727,0x9f,0x00,0xb4,0x2b,0x09,0x19,0xc0,0xda,"DXVA_COPPSetProtectionLevel"); + IF_GUID_EQUAL_RETURN(guid,0x9a631a5,0xd684,0x4c60,0x8e,0x4d,0xd3,0xbb,0xf,0xb,0xe3,0xee,"DXVA_COPPSetSignaling"); + IF_GUID_EQUAL_RETURN(guid,0x9f200913,0x2ffd,0x4056,0x9f,0x1e,0xe1,0xb5,0x08,0xf2,0x2d,0xcf,"DXVA_ProcAmpControlDevice"); + IF_GUID_EQUAL_RETURN(guid,0x335aa36e,0x7884,0x43a4,0x9c,0x91,0x7f,0x87,0xfa,0xf3,0xe3,0x7e,"DXVAp_DeinterlaceBobDevice"); + IF_GUID_EQUAL_RETURN(guid,0x0e85cb93,0x3046,0x4ff0,0xae,0xcc,0xd5,0x8c,0xb5,0xf0,0x35,0xfd,"DXVAp_DeinterlaceContainerDevice"); + IF_GUID_EQUAL_RETURN(guid,0x1b81be0A,0xa0c7,0x11d3,0xb9,0x84,0x00,0xc0,0x4f,0x2e,0x73,0xc5,"DXVAp_ModeMPEG2_A"); + IF_GUID_EQUAL_RETURN(guid,0x1b81be0C,0xa0c7,0x11d3,0xb9,0x84,0x00,0xc0,0x4f,0x2e,0x73,0xc5,"DXVAp_ModeMPEG2_C"); + IF_GUID_EQUAL_RETURN(guid,0x1b81beD0,0xa0c7,0x11d3,0xb9,0x84,0x00,0xc0,0x4f,0x2e,0x73,0xc5,"DXVAp_NoEncrypt"); + IF_GUID_EQUAL_RETURN(guid,0x84b783af,0xd103,0x4b0a,0x84,0x15,0xe7,0x39,0x42,0x41,0x0f,0x4b,"DataGrid_Control_GUID"); + IF_GUID_EQUAL_RETURN(guid,0xa0177842,0xd94f,0x42a5,0x81,0x4b,0x60,0x68,0xad,0xdc,0x8d,0xa5,"DataItem_Control_GUID"); + IF_GUID_EQUAL_RETURN(guid,0x7c5865b8,0x9992,0x40fd,0x8d,0xb0,0x6b,0xf1,0xd3,0x17,0xf9,0x98,"DescribedBy_Property_GUID"); + IF_GUID_EQUAL_RETURN(guid,0x6d67f02e,0xc0b0,0x4b10,0xb5,0xb9,0x18,0xd6,0xec,0xf9,0x87,0x60,"Dock_DockPosition_Property_GUID"); + IF_GUID_EQUAL_RETURN(guid,0x9cbaa846,0x83c8,0x428d,0x82,0x7f,0x7e,0x60,0x63,0xfe,0x06,0x20,"Dock_Pattern_GUID"); + IF_GUID_EQUAL_RETURN(guid,0x3cd6bb6f,0x6f08,0x4562,0xb2,0x29,0xe4,0xe2,0xfc,0x7a,0x9e,0xb4,"Document_Control_GUID"); + IF_GUID_EQUAL_RETURN(guid,0xc3ede6fa,0x3451,0x4e0f,0x9e,0x71,0xdf,0x9c,0x28,0xa,0x46,0x57,"Drag_DragCancel_Event_GUID"); + IF_GUID_EQUAL_RETURN(guid,0x38e96188,0xef1f,0x463e,0x91,0xca,0x3a,0x77,0x92,0xc2,0x9c,0xaf,"Drag_DragComplete_Event_GUID"); + IF_GUID_EQUAL_RETURN(guid,0x883a480b,0x3aa9,0x429d,0x95,0xe4,0xd9,0xc8,0xd0,0x11,0xf0,0xdd,"Drag_DragStart_Event_GUID"); + IF_GUID_EQUAL_RETURN(guid,0x646f2779,0x48d3,0x4b23,0x89,0x2,0x4b,0xf1,0x0,0x0,0x5d,0xf3,"Drag_DropEffect_Property_GUID"); + IF_GUID_EQUAL_RETURN(guid,0xf5d61156,0x7ce6,0x49be,0xa8,0x36,0x92,0x69,0xdc,0xec,0x92,0xf,"Drag_DropEffects_Property_GUID"); + IF_GUID_EQUAL_RETURN(guid,0x77c1562c,0x7b86,0x4b21,0x9e,0xd7,0x3c,0xef,0xda,0x6f,0x4c,0x43,"Drag_GrabbedItems_Property_GUID"); + IF_GUID_EQUAL_RETURN(guid,0x45f206f3,0x75cc,0x4cca,0xa9,0xb9,0xfc,0xdf,0xb9,0x82,0xd8,0xa2,"Drag_IsGrabbed_Property_GUID"); + IF_GUID_EQUAL_RETURN(guid,0xc0bee21f,0xccb3,0x4fed,0x99,0x5b,0x11,0x4f,0x6e,0x3d,0x27,0x28,"Drag_Pattern_GUID"); + IF_GUID_EQUAL_RETURN(guid,0xaad9319b,0x32c,0x4a88,0x96,0x1d,0x1c,0xf5,0x79,0x58,0x1e,0x34,"DropTarget_DragEnter_Event_GUID"); + IF_GUID_EQUAL_RETURN(guid,0xf82eb15,0x24a2,0x4988,0x92,0x17,0xde,0x16,0x2a,0xee,0x27,0x2b,"DropTarget_DragLeave_Event_GUID"); + IF_GUID_EQUAL_RETURN(guid,0x8bb75975,0xa0ca,0x4981,0xb8,0x18,0x87,0xfc,0x66,0xe9,0x50,0x9d,"DropTarget_DropTargetEffect_Property_GUID"); + IF_GUID_EQUAL_RETURN(guid,0xbc1dd4ed,0xcb89,0x45f1,0xa5,0x92,0xe0,0x3b,0x8,0xae,0x79,0xf,"DropTarget_DropTargetEffects_Property_GUID"); + IF_GUID_EQUAL_RETURN(guid,0x622cead8,0x1edb,0x4a3d,0xab,0xbc,0xbe,0x22,0x11,0xff,0x68,0xb5,"DropTarget_Dropped_Event_GUID"); + IF_GUID_EQUAL_RETURN(guid,0xbcbec56,0xbd34,0x4b7b,0x9f,0xd5,0x26,0x59,0x90,0x5e,0xa3,0xdc,"DropTarget_Pattern_GUID"); + IF_GUID_EQUAL_RETURN(guid,0x49cc4c43,0xca83,0x4ad4,0xa9,0xaf,0xf3,0x69,0x6a,0xf6,0x66,0xdf,"ENCAPIPARAM_BITRATE"); + IF_GUID_EQUAL_RETURN(guid,0xee5fb25c,0xc713,0x40d1,0x9d,0x58,0xc0,0xd7,0x24,0x1e,0x25,0xf,"ENCAPIPARAM_BITRATE_MODE"); + IF_GUID_EQUAL_RETURN(guid,0x703f16a9,0x3d48,0x44a1,0xb0,0x77,0x1,0x8d,0xff,0x91,0x5d,0x19,"ENCAPIPARAM_PEAK_BITRATE"); + IF_GUID_EQUAL_RETURN(guid,0xc0171db,0xfefc,0x4af7,0x99,0x91,0xa5,0x65,0x7c,0x19,0x1c,0xd1,"ENCAPIPARAM_SAP_MODE"); + IF_GUID_EQUAL_RETURN(guid,0xb4e9db8b,0x34ba,0x4c39,0xb5,0xcc,0x16,0xa1,0xbd,0x2c,0x41,0x1c,"EP_AdvQueryPane"); + IF_GUID_EQUAL_RETURN(guid,0xd9745868,0xca5f,0x4a76,0x91,0xcd,0xf5,0xa1,0x29,0xfb,0xb0,0x76,"EP_Commands"); + IF_GUID_EQUAL_RETURN(guid,0x72e81700,0xe3ec,0x4660,0xbf,0x24,0x3c,0x3b,0x7b,0x64,0x88,0x06,"EP_Commands_Organize"); + IF_GUID_EQUAL_RETURN(guid,0x21f7c32d,0xeeaa,0x439b,0xbb,0x51,0x37,0xb9,0x6f,0xd6,0xa9,0x43,"EP_Commands_View"); + IF_GUID_EQUAL_RETURN(guid,0x43abf98b,0x89b8,0x472d,0xb9,0xce,0xe6,0x9b,0x82,0x29,0xf0,0x19,"EP_DetailsPane"); + IF_GUID_EQUAL_RETURN(guid,0xcb316b22,0x25f7,0x42b8,0x8a,0x09,0x54,0x0d,0x23,0xa4,0x3c,0x2f,"EP_NavPane"); + IF_GUID_EQUAL_RETURN(guid,0x893c63d1,0x45c8,0x4d17,0xbe,0x19,0x22,0x3b,0xe7,0x1b,0xe3,0x65,"EP_PreviewPane"); + IF_GUID_EQUAL_RETURN(guid,0x65bcde4f,0x4f07,0x4f27,0x83,0xa7,0x1a,0xfc,0xa4,0xdf,0x7d,0xdd,"EP_QueryPane"); + IF_GUID_EQUAL_RETURN(guid,0xd27524a8,0xc9f2,0x4834,0xa1,0x6,0xdf,0x88,0x89,0xfd,0x4f,0x37,"EP_Ribbon"); + IF_GUID_EQUAL_RETURN(guid,0x65fe56ce,0x5cfe,0x4bc4,0xad,0x8a,0x7a,0xe3,0xfe,0x7e,0x8f,0x7c,"EP_StatusBar"); + IF_GUID_EQUAL_RETURN(guid,0xE2C2E9DE,0x09B1,0x4B04,0x84,0xE5,0x07,0x93,0x12,0x25,0xEE,0x04,"EVENTCONTEXT_VOLUMESLIDER"); + IF_GUID_EQUAL_RETURN(guid,0xC4C4C4EA,0x0049,0x4E2B,0x98,0xFB,0x95,0x37,0xF6,0xCE,0x51,0x6D,"EVENTID_DTFilterCOPPBlock"); + IF_GUID_EQUAL_RETURN(guid,0xC4C4C4E8,0x0049,0x4E2B,0x98,0xFB,0x95,0x37,0xF6,0xCE,0x51,0x6D,"EVENTID_DTFilterCOPPUnblock"); + IF_GUID_EQUAL_RETURN(guid,0xC4C4C4ED,0x0049,0x4E2B,0x98,0xFB,0x95,0x37,0xF6,0xCE,0x51,0x6D,"EVENTID_DTFilterDataFormatFailure"); + IF_GUID_EQUAL_RETURN(guid,0xC4C4C4EC,0x0049,0x4E2B,0x98,0xFB,0x95,0x37,0xF6,0xCE,0x51,0x6D,"EVENTID_DTFilterDataFormatOK"); + IF_GUID_EQUAL_RETURN(guid,0xC4C4C4E2,0x0049,0x4E2B,0x98,0xFB,0x95,0x37,0xF6,0xCE,0x51,0x6D,"EVENTID_DTFilterRatingChange"); + IF_GUID_EQUAL_RETURN(guid,0xC4C4C4E3,0x0049,0x4E2B,0x98,0xFB,0x95,0x37,0xF6,0xCE,0x51,0x6D,"EVENTID_DTFilterRatingsBlock"); + IF_GUID_EQUAL_RETURN(guid,0xC4C4C4E4,0x0049,0x4E2B,0x98,0xFB,0x95,0x37,0xF6,0xCE,0x51,0x6D,"EVENTID_DTFilterRatingsUnblock"); + IF_GUID_EQUAL_RETURN(guid,0xC4C4C4E5,0x0049,0x4E2B,0x98,0xFB,0x95,0x37,0xF6,0xCE,0x51,0x6D,"EVENTID_DTFilterXDSPacket"); + IF_GUID_EQUAL_RETURN(guid,0x16155770,0xaed5,0x475c,0xbb,0x98,0x95,0xa3,0x30,0x70,0xdf,0xc,"EVENTID_DemultiplexerFilterDiscontinuity"); + IF_GUID_EQUAL_RETURN(guid,0xC4C4C4EF,0x0049,0x4E2B,0x98,0xFB,0x95,0x37,0xF6,0xCE,0x51,0x6D,"EVENTID_ETDTFilterLicenseFailure"); + IF_GUID_EQUAL_RETURN(guid,0xC4C4C4EE,0x0049,0x4E2B,0x98,0xFB,0x95,0x37,0xF6,0xCE,0x51,0x6D,"EVENTID_ETDTFilterLicenseOK"); + IF_GUID_EQUAL_RETURN(guid,0xC4C4C4F0,0x0049,0x4E2B,0x98,0xFB,0x95,0x37,0xF6,0xCE,0x51,0x6D,"EVENTID_ETFilterCopyNever"); + IF_GUID_EQUAL_RETURN(guid,0xC4C4C4EB,0x0049,0x4E2B,0x98,0xFB,0x95,0x37,0xF6,0xCE,0x51,0x6D,"EVENTID_ETFilterCopyOnce"); + IF_GUID_EQUAL_RETURN(guid,0xC4C4C4E7,0x0049,0x4E2B,0x98,0xFB,0x95,0x37,0xF6,0xCE,0x51,0x6D,"EVENTID_ETFilterEncryptionOff"); + IF_GUID_EQUAL_RETURN(guid,0xC4C4C4E6,0x0049,0x4E2B,0x98,0xFB,0x95,0x37,0xF6,0xCE,0x51,0x6D,"EVENTID_ETFilterEncryptionOn"); + IF_GUID_EQUAL_RETURN(guid,0xC4C4C4E9,0x0049,0x4E2B,0x98,0xFB,0x95,0x37,0xF6,0xCE,0x51,0x6D,"EVENTID_EncDecFilterError"); + IF_GUID_EQUAL_RETURN(guid,0x4a1b465b,0xfb9,0x4159,0xaf,0xbd,0xe3,0x30,0x6,0xa0,0xf9,0xf4,"EVENTID_EncDecFilterEvent"); + IF_GUID_EQUAL_RETURN(guid,0x24b2280a,0xb2aa,0x4777,0xbf,0x65,0x63,0xf3,0x5e,0x7b,0x2,0x4a,"EVENTID_FormatNotSupportedEvent"); + IF_GUID_EQUAL_RETURN(guid,0x8966a89e,0xf83e,0x4c0e,0xbc,0x3b,0xbf,0xa7,0x64,0x9e,0x4,0xcb,"EVENTID_SBE2RecControlStarted"); + IF_GUID_EQUAL_RETURN(guid,0x454b1ec8,0xc9b,0x4caa,0xb1,0xa1,0x1e,0x7a,0x26,0x66,0xf6,0xc3,"EVENTID_SBE2RecControlStopped"); + IF_GUID_EQUAL_RETURN(guid,0xC4C4C4DF,0x0049,0x4E2B,0x98,0xFB,0x95,0x37,0xF6,0xCE,0x51,0x6D,"EVENTID_XDSCodecDuplicateXDSRating"); + IF_GUID_EQUAL_RETURN(guid,0xC4C4C4E1,0x0049,0x4E2B,0x98,0xFB,0x95,0x37,0xF6,0xCE,0x51,0x6D,"EVENTID_XDSCodecNewXDSPacket"); + IF_GUID_EQUAL_RETURN(guid,0xC4C4C4E0,0x0049,0x4E2B,0x98,0xFB,0x95,0x37,0xF6,0xCE,0x51,0x6D,"EVENTID_XDSCodecNewXDSRating"); + IF_GUID_EQUAL_RETURN(guid,0xe447df0a,0x10ca,0x4d17,0xb1,0x7e,0x6a,0x84,0x0f,0x8a,0x3a,0x4c,"EVRConfig_AllowBatching"); + IF_GUID_EQUAL_RETURN(guid,0xe447df02,0x10ca,0x4d17,0xb1,0x7e,0x6a,0x84,0x0f,0x8a,0x3a,0x4c,"EVRConfig_AllowDropToBob"); + IF_GUID_EQUAL_RETURN(guid,0xe447df06,0x10ca,0x4d17,0xb1,0x7e,0x6a,0x84,0x0f,0x8a,0x3a,0x4c,"EVRConfig_AllowDropToHalfInterlace"); + IF_GUID_EQUAL_RETURN(guid,0xe447df04,0x10ca,0x4d17,0xb1,0x7e,0x6a,0x84,0x0f,0x8a,0x3a,0x4c,"EVRConfig_AllowDropToThrottle"); + IF_GUID_EQUAL_RETURN(guid,0xe447df08,0x10ca,0x4d17,0xb1,0x7e,0x6a,0x84,0x0f,0x8a,0x3a,0x4c,"EVRConfig_AllowScaling"); + IF_GUID_EQUAL_RETURN(guid,0xe447df09,0x10ca,0x4d17,0xb1,0x7e,0x6a,0x84,0x0f,0x8a,0x3a,0x4c,"EVRConfig_ForceBatching"); + IF_GUID_EQUAL_RETURN(guid,0xe447df01,0x10ca,0x4d17,0xb1,0x7e,0x6a,0x84,0x0f,0x8a,0x3a,0x4c,"EVRConfig_ForceBob"); + IF_GUID_EQUAL_RETURN(guid,0xe447df05,0x10ca,0x4d17,0xb1,0x7e,0x6a,0x84,0x0f,0x8a,0x3a,0x4c,"EVRConfig_ForceHalfInterlace"); + IF_GUID_EQUAL_RETURN(guid,0xe447df07,0x10ca,0x4d17,0xb1,0x7e,0x6a,0x84,0x0f,0x8a,0x3a,0x4c,"EVRConfig_ForceScaling"); + IF_GUID_EQUAL_RETURN(guid,0xe447df03,0x10ca,0x4d17,0xb1,0x7e,0x6a,0x84,0x0f,0x8a,0x3a,0x4c,"EVRConfig_ForceThrottle"); + IF_GUID_EQUAL_RETURN(guid,0x6504a5c8,0x2c86,0x4f87,0xae,0x7b,0x1a,0xbd,0xdc,0x81,0x0c,0xf9,"Edit_Control_GUID"); + IF_GUID_EQUAL_RETURN(guid,0x275a4c48,0x85a7,0x4f69,0xab,0xa0,0xaf,0x15,0x76,0x10,0x00,0x2b,"ExpandCollapse_ExpandCollapseState_Property_GUID"); + IF_GUID_EQUAL_RETURN(guid,0xae05efa2,0xf9d1,0x428a,0x83,0x4c,0x53,0xa5,0xc5,0x2f,0x9b,0x8b,"ExpandCollapse_Pattern_GUID"); + IF_GUID_EQUAL_RETURN(guid,0x9d453eb7,0xd2a6,0x4dbd,0xa2,0xe3,0xfb,0xd0,0xed,0x91,0x09,0xa9,"FILE_TYPE_NOTIFICATION_GUID_CRASHDUMP_FILE"); + IF_GUID_EQUAL_RETURN(guid,0xb7624d64,0xb9a3,0x4cf8,0x80,0x11,0x5b,0x86,0xc9,0x40,0xe7,0xb7,"FILE_TYPE_NOTIFICATION_GUID_HIBERNATION_FILE"); + IF_GUID_EQUAL_RETURN(guid,0x0d0a64a1,0x38fc,0x4db8,0x9f,0xe7,0x3f,0x43,0x52,0xcd,0x7c,0x5c,"FILE_TYPE_NOTIFICATION_GUID_PAGE_FILE"); + IF_GUID_EQUAL_RETURN(guid,0xa144ed38,0x8e12,0x4de4,0x9d,0x96,0xe6,0x47,0x40,0xb1,0xa5,0x24,"FIREWALL_PORT_CLOSE_GUID"); + IF_GUID_EQUAL_RETURN(guid,0xb7569e07,0x8421,0x4ee0,0xad,0x10,0x86,0x91,0x5a,0xfd,0xad,0x09,"FIREWALL_PORT_OPEN_GUID"); + IF_GUID_EQUAL_RETURN(guid,0x328d8b21,0x7729,0x4bfc,0x95,0x4c,0x90,0x2b,0x32,0x9d,0x56,0xb0,"FMTID_Briefcase"); + IF_GUID_EQUAL_RETURN(guid,0x7ecd8b0e,0xc136,0x4a9b,0x94,0x11,0x4e,0xbd,0x66,0x73,0xcc,0xc3,"FMTID_CustomImageProperties"); + IF_GUID_EQUAL_RETURN(guid,0xaeac19e4,0x89ae,0x4508,0xb9,0xb7,0xbb,0x86,0x7a,0xbe,0xe2,0xed,"FMTID_DRM"); + IF_GUID_EQUAL_RETURN(guid,0x78c34fc8,0x104a,0x4aca,0x9e,0xa4,0x52,0x4d,0x52,0x99,0x6e,0x57,"FMTID_Device"); + IF_GUID_EQUAL_RETURN(guid,0x53808008,0x07BB,0x4661,0xBC,0x3C,0xB5,0x95,0x3E,0x70,0x85,0x60,"FMTID_DeviceInterface"); + IF_GUID_EQUAL_RETURN(guid,0x9b174b33,0x40ff,0x11d2,0xa2,0x7e,0x0,0xc0,0x4f,0xc3,0x8,0x71,"FMTID_Displaced"); + IF_GUID_EQUAL_RETURN(guid,0x904b03a2,0x471d,0x423c,0xa5,0x84,0xf3,0x48,0x32,0x38,0xa1,0x46,"FMTID_FD"); + IF_GUID_EQUAL_RETURN(guid,0x14b81da1,0x0135,0x4d31,0x96,0xd9,0x6c,0xbf,0xc9,0x67,0x1a,0x99,"FMTID_ImageProperties"); + IF_GUID_EQUAL_RETURN(guid,0x5d76b67f,0x9b3d,0x44bb,0xb6,0xae,0x25,0xda,0x4f,0x63,0x8a,0x67,"FMTID_LibraryProperties"); + IF_GUID_EQUAL_RETURN(guid,0x56a3372e,0xce9c,0x11d2,0x9f,0xe,0x0,0x60,0x97,0xc6,0x86,0xf6,"FMTID_MUSIC"); + IF_GUID_EQUAL_RETURN(guid,0x9b174b34,0x40ff,0x11d2,0xa2,0x7e,0x0,0xc0,0x4f,0xc3,0x8,0x71,"FMTID_Misc"); + IF_GUID_EQUAL_RETURN(guid,0x656A3BB3,0xECC0,0x43FD,0x84,0x77,0x4A,0xE0,0x40,0x4A,0x96,0xCD,"FMTID_PNPX"); + IF_GUID_EQUAL_RETURN(guid,0x4FC5077E,0xB686,0x44BE,0x93,0xE3,0x86,0xCA,0xFE,0x36,0x8C,0xCD,"FMTID_PNPXDynamicProperty"); + IF_GUID_EQUAL_RETURN(guid,0x8807cae6,0x7db6,0x4f10,0x8e,0xe4,0x43,0x5e,0xaa,0x13,0x92,0xbc,"FMTID_Pairing"); + IF_GUID_EQUAL_RETURN(guid,0x75f9adca,0x097d,0x45c3,0xa6,0xe4,0xba,0xb2,0x9e,0x27,0x6f,0x3e,"FMTID_PrinterPropertyBag"); + IF_GUID_EQUAL_RETURN(guid,0x49691c90,0x7e17,0x101a,0xa9,0x1c,0x08,0x00,0x2b,0x2e,0xcd,0xa9,"FMTID_Query"); + IF_GUID_EQUAL_RETURN(guid,0x28636aa6,0x953d,0x11d2,0xb5,0xd6,0x0,0xc0,0x4f,0xd9,0x18,0xd0,"FMTID_ShellDetails"); + IF_GUID_EQUAL_RETURN(guid,0xb725f130,0x47ef,0x101a,0xa5,0xf1,0x02,0x60,0x8c,0x9e,0xeb,0xac,"FMTID_Storage"); + IF_GUID_EQUAL_RETURN(guid,0x9b174b35,0x40ff,0x11d2,0xa2,0x7e,0x0,0xc0,0x4f,0xc3,0x8,0x71,"FMTID_Volume"); + IF_GUID_EQUAL_RETURN(guid,0x92506491,0xFF95,0x4724,0xA0,0x5A,0x5B,0x81,0x88,0x5A,0x7C,0x92,"FMTID_WSD"); + IF_GUID_EQUAL_RETURN(guid,0xf2275480,0xf782,0x4291,0xbd,0x94,0xf1,0x36,0x93,0x51,0x3a,0xec,"FMTID_WebView"); + IF_GUID_EQUAL_RETURN(guid,0x008ca0b1,0x55b4,0x4c56,0xb8,0xa8,0x4d,0xe4,0xb2,0x99,0xd3,0xbe,"FOLDERID_AccountPictures"); + IF_GUID_EQUAL_RETURN(guid,0xde61d971,0x5ebc,0x4f02,0xa3,0xa9,0x6c,0x82,0x89,0x5e,0x5c,0x04,"FOLDERID_AddNewPrograms"); + IF_GUID_EQUAL_RETURN(guid,0x724EF170,0xA42D,0x4FEF,0x9F,0x26,0xB6,0x0E,0x84,0x6F,0xBA,0x4F,"FOLDERID_AdminTools"); + IF_GUID_EQUAL_RETURN(guid,0xa305ce99,0xf527,0x492b,0x8b,0x1a,0x7e,0x76,0xfa,0x98,0xd6,0xe4,"FOLDERID_AppUpdates"); + IF_GUID_EQUAL_RETURN(guid,0xa3918781,0xe5f2,0x4890,0xb3,0xd9,0xa7,0xe5,0x43,0x32,0x32,0x8c,"FOLDERID_ApplicationShortcuts"); + IF_GUID_EQUAL_RETURN(guid,0x1e87508d,0x89c2,0x42f0,0x8a,0x7e,0x64,0x5a,0x0f,0x50,0xca,0x58,"FOLDERID_AppsFolder"); + IF_GUID_EQUAL_RETURN(guid,0x9E52AB10,0xF80D,0x49DF,0xAC,0xB8,0x43,0x30,0xF5,0x68,0x78,0x55,"FOLDERID_CDBurning"); + IF_GUID_EQUAL_RETURN(guid,0xdf7266ac,0x9274,0x4867,0x8d,0x55,0x3b,0xd6,0x61,0xde,0x87,0x2d,"FOLDERID_ChangeRemovePrograms"); + IF_GUID_EQUAL_RETURN(guid,0xD0384E7D,0xBAC3,0x4797,0x8F,0x14,0xCB,0xA2,0x29,0xB3,0x92,0xB5,"FOLDERID_CommonAdminTools"); + IF_GUID_EQUAL_RETURN(guid,0xC1BAE2D0,0x10DF,0x4334,0xBE,0xDD,0x7A,0xA2,0x0B,0x22,0x7A,0x9D,"FOLDERID_CommonOEMLinks"); + IF_GUID_EQUAL_RETURN(guid,0x0139D44E,0x6AFE,0x49F2,0x86,0x90,0x3D,0xAF,0xCA,0xE6,0xFF,0xB8,"FOLDERID_CommonPrograms"); + IF_GUID_EQUAL_RETURN(guid,0xA4115719,0xD62E,0x491D,0xAA,0x7C,0xE7,0x4B,0x8B,0xE3,0xB0,0x67,"FOLDERID_CommonStartMenu"); + IF_GUID_EQUAL_RETURN(guid,0x82A5EA35,0xD9CD,0x47C5,0x96,0x29,0xE1,0x5D,0x2F,0x71,0x4E,0x6E,"FOLDERID_CommonStartup"); + IF_GUID_EQUAL_RETURN(guid,0xB94237E7,0x57AC,0x4347,0x91,0x51,0xB0,0x8C,0x6C,0x32,0xD1,0xF7,"FOLDERID_CommonTemplates"); + IF_GUID_EQUAL_RETURN(guid,0x0AC0837C,0xBBF8,0x452A,0x85,0x0D,0x79,0xD0,0x8E,0x66,0x7C,0xA7,"FOLDERID_ComputerFolder"); + IF_GUID_EQUAL_RETURN(guid,0x4bfefb45,0x347d,0x4006,0xa5,0xbe,0xac,0x0c,0xb0,0x56,0x71,0x92,"FOLDERID_ConflictFolder"); + IF_GUID_EQUAL_RETURN(guid,0x6F0CD92B,0x2E97,0x45D1,0x88,0xFF,0xB0,0xD1,0x86,0xB8,0xDE,0xDD,"FOLDERID_ConnectionsFolder"); + IF_GUID_EQUAL_RETURN(guid,0x56784854,0xc6cb,0x462b,0x81,0x69,0x88,0xe3,0x50,0xac,0xb8,0x82,"FOLDERID_Contacts"); + IF_GUID_EQUAL_RETURN(guid,0x82A74AEB,0xAEB4,0x465C,0xA0,0x14,0xD0,0x97,0xEE,0x34,0x6D,0x63,"FOLDERID_ControlPanelFolder"); + IF_GUID_EQUAL_RETURN(guid,0x2B0F765D,0xC0E9,0x4171,0x90,0x8E,0x08,0xA6,0x11,0xB8,0x4F,0xF6,"FOLDERID_Cookies"); + IF_GUID_EQUAL_RETURN(guid,0xB4BFCC3A,0xDB2C,0x424C,0xB0,0x29,0x7F,0xE9,0x9A,0x87,0xC6,0x41,"FOLDERID_Desktop"); + IF_GUID_EQUAL_RETURN(guid,0x5ce4a5e9,0xe4eb,0x479d,0xb8,0x9f,0x13,0x0c,0x02,0x88,0x61,0x55,"FOLDERID_DeviceMetadataStore"); + IF_GUID_EQUAL_RETURN(guid,0xFDD39AD0,0x238F,0x46AF,0xAD,0xB4,0x6C,0x85,0x48,0x03,0x69,0xC7,"FOLDERID_Documents"); + IF_GUID_EQUAL_RETURN(guid,0x7b0db17d,0x9cd2,0x4a93,0x97,0x33,0x46,0xcc,0x89,0x02,0x2e,0x7c,"FOLDERID_DocumentsLibrary"); + IF_GUID_EQUAL_RETURN(guid,0x374de290,0x123f,0x4565,0x91,0x64,0x39,0xc4,0x92,0x5e,0x46,0x7b,"FOLDERID_Downloads"); + IF_GUID_EQUAL_RETURN(guid,0x1777F761,0x68AD,0x4D8A,0x87,0xBD,0x30,0xB7,0x59,0xFA,0x33,0xDD,"FOLDERID_Favorites"); + IF_GUID_EQUAL_RETURN(guid,0xFD228CB7,0xAE11,0x4AE3,0x86,0x4C,0x16,0xF3,0x91,0x0A,0xB8,0xFE,"FOLDERID_Fonts"); + IF_GUID_EQUAL_RETURN(guid,0x54fae61,0x4dd8,0x4787,0x80,0xb6,0x9,0x2,0x20,0xc4,0xb7,0x0,"FOLDERID_GameTasks"); + IF_GUID_EQUAL_RETURN(guid,0xcac52c1a,0xb53d,0x4edc,0x92,0xd7,0x6b,0x2e,0x8a,0xc1,0x94,0x34,"FOLDERID_Games"); + IF_GUID_EQUAL_RETURN(guid,0xD9DC8A3B,0xB784,0x432E,0xA7,0x81,0x5A,0x11,0x30,0xA7,0x59,0x63,"FOLDERID_History"); + IF_GUID_EQUAL_RETURN(guid,0x52528a6b,0xb9e3,0x4add,0xb6,0xd,0x58,0x8c,0x2d,0xba,0x84,0x2d,"FOLDERID_HomeGroup"); + IF_GUID_EQUAL_RETURN(guid,0x9b74b6a3,0xdfd,0x4f11,0x9e,0x78,0x5f,0x78,0x0,0xf2,0xe7,0x72,"FOLDERID_HomeGroupCurrentUser"); + IF_GUID_EQUAL_RETURN(guid,0xbcb5256f,0x79f6,0x4cee,0xb7,0x25,0xdc,0x34,0xe4,0x2,0xfd,0x46,"FOLDERID_ImplicitAppShortcuts"); + IF_GUID_EQUAL_RETURN(guid,0x352481E8,0x33BE,0x4251,0xBA,0x85,0x60,0x07,0xCA,0xED,0xCF,0x9D,"FOLDERID_InternetCache"); + IF_GUID_EQUAL_RETURN(guid,0x4D9F7874,0x4E0C,0x4904,0x96,0x7B,0x40,0xB0,0xD2,0x0C,0x3E,0x4B,"FOLDERID_InternetFolder"); + IF_GUID_EQUAL_RETURN(guid,0x1b3ea5dc,0xb587,0x4786,0xb4,0xef,0xbd,0x1d,0xc3,0x32,0xae,0xae,"FOLDERID_Libraries"); + IF_GUID_EQUAL_RETURN(guid,0xbfb9d5e0,0xc6a9,0x404c,0xb2,0xb2,0xae,0x6d,0xb6,0xaf,0x49,0x68,"FOLDERID_Links"); + IF_GUID_EQUAL_RETURN(guid,0xF1B32785,0x6FBA,0x4FCF,0x9D,0x55,0x7B,0x8E,0x7F,0x15,0x70,0x91,"FOLDERID_LocalAppData"); + IF_GUID_EQUAL_RETURN(guid,0xA520A1A4,0x1780,0x4FF6,0xBD,0x18,0x16,0x73,0x43,0xC5,0xAF,0x16,"FOLDERID_LocalAppDataLow"); + IF_GUID_EQUAL_RETURN(guid,0x2A00375E,0x224C,0x49DE,0xB8,0xD1,0x44,0x0D,0xF7,0xEF,0x3D,0xDC,"FOLDERID_LocalizedResourcesDir"); + IF_GUID_EQUAL_RETURN(guid,0x4BD8D571,0x6D19,0x48D3,0xBE,0x97,0x42,0x22,0x20,0x08,0x0E,0x43,"FOLDERID_Music"); + IF_GUID_EQUAL_RETURN(guid,0x2112ab0a,0xc86a,0x4ffe,0xa3,0x68,0xd,0xe9,0x6e,0x47,0x1,0x2e,"FOLDERID_MusicLibrary"); + IF_GUID_EQUAL_RETURN(guid,0xC5ABBF53,0xE17F,0x4121,0x89,0x00,0x86,0x62,0x6F,0xC2,0xC9,0x73,"FOLDERID_NetHood"); + IF_GUID_EQUAL_RETURN(guid,0xD20BEEC4,0x5CA8,0x4905,0xAE,0x3B,0xBF,0x25,0x1E,0xA0,0x9B,0x53,"FOLDERID_NetworkFolder"); + IF_GUID_EQUAL_RETURN(guid,0x2C36C0AA,0x5812,0x4b87,0xbf,0xd0,0x4c,0xd0,0xdf,0xb1,0x9b,0x39,"FOLDERID_OriginalImages"); + IF_GUID_EQUAL_RETURN(guid,0x69D2CF90,0xFC33,0x4FB7,0x9A,0x0C,0xEB,0xB0,0xF0,0xFC,0xB4,0x3C,"FOLDERID_PhotoAlbums"); + IF_GUID_EQUAL_RETURN(guid,0x33E28130,0x4E1E,0x4676,0x83,0x5A,0x98,0x39,0x5C,0x3B,0xC3,0xBB,"FOLDERID_Pictures"); + IF_GUID_EQUAL_RETURN(guid,0xa990ae9f,0xa03b,0x4e80,0x94,0xbc,0x99,0x12,0xd7,0x50,0x41,0x4,"FOLDERID_PicturesLibrary"); + IF_GUID_EQUAL_RETURN(guid,0xDE92C1C7,0x837F,0x4F69,0xA3,0xBB,0x86,0xE6,0x31,0x20,0x4A,0x23,"FOLDERID_Playlists"); + IF_GUID_EQUAL_RETURN(guid,0x9274BD8D,0xCFD1,0x41C3,0xB3,0x5E,0xB1,0x3F,0x55,0xA7,0x58,0xF4,"FOLDERID_PrintHood"); + IF_GUID_EQUAL_RETURN(guid,0x76FC4E2D,0xD6AD,0x4519,0xA6,0x63,0x37,0xBD,0x56,0x06,0x81,0x85,"FOLDERID_PrintersFolder"); + IF_GUID_EQUAL_RETURN(guid,0x5E6C858F,0x0E22,0x4760,0x9A,0xFE,0xEA,0x33,0x17,0xB6,0x71,0x73,"FOLDERID_Profile"); + IF_GUID_EQUAL_RETURN(guid,0x62AB5D82,0xFDC1,0x4DC3,0xA9,0xDD,0x07,0x0D,0x1D,0x49,0x5D,0x97,"FOLDERID_ProgramData"); + IF_GUID_EQUAL_RETURN(guid,0x905e63b6,0xc1bf,0x494e,0xb2,0x9c,0x65,0xb7,0x32,0xd3,0xd2,0x1a,"FOLDERID_ProgramFiles"); + IF_GUID_EQUAL_RETURN(guid,0xF7F1ED05,0x9F6D,0x47A2,0xAA,0xAE,0x29,0xD3,0x17,0xC6,0xF0,0x66,"FOLDERID_ProgramFilesCommon"); + IF_GUID_EQUAL_RETURN(guid,0x6365d5a7,0xf0d,0x45e5,0x87,0xf6,0xd,0xa5,0x6b,0x6a,0x4f,0x7d,"FOLDERID_ProgramFilesCommonX64"); + IF_GUID_EQUAL_RETURN(guid,0xDE974D24,0xD9C6,0x4D3E,0xBF,0x91,0xF4,0x45,0x51,0x20,0xB9,0x17,"FOLDERID_ProgramFilesCommonX86"); + IF_GUID_EQUAL_RETURN(guid,0x6d809377,0x6af0,0x444b,0x89,0x57,0xa3,0x77,0x3f,0x02,0x20,0x0e,"FOLDERID_ProgramFilesX64"); + IF_GUID_EQUAL_RETURN(guid,0x7C5A40EF,0xA0FB,0x4BFC,0x87,0x4A,0xC0,0xF2,0xE0,0xB9,0xFA,0x8E,"FOLDERID_ProgramFilesX86"); + IF_GUID_EQUAL_RETURN(guid,0xA77F5D77,0x2E2B,0x44C3,0xA6,0xA2,0xAB,0xA6,0x01,0x05,0x4A,0x51,"FOLDERID_Programs"); + IF_GUID_EQUAL_RETURN(guid,0xDFDF76A2,0xC82A,0x4D63,0x90,0x6A,0x56,0x44,0xAC,0x45,0x73,0x85,"FOLDERID_Public"); + IF_GUID_EQUAL_RETURN(guid,0xC4AA340D,0xF20F,0x4863,0xAF,0xEF,0xF8,0x7E,0xF2,0xE6,0xBA,0x25,"FOLDERID_PublicDesktop"); + IF_GUID_EQUAL_RETURN(guid,0xED4824AF,0xDCE4,0x45A8,0x81,0xE2,0xFC,0x79,0x65,0x08,0x36,0x34,"FOLDERID_PublicDocuments"); + IF_GUID_EQUAL_RETURN(guid,0x3d644c9b,0x1fb8,0x4f30,0x9b,0x45,0xf6,0x70,0x23,0x5f,0x79,0xc0,"FOLDERID_PublicDownloads"); + IF_GUID_EQUAL_RETURN(guid,0xdebf2536,0xe1a8,0x4c59,0xb6,0xa2,0x41,0x45,0x86,0x47,0x6a,0xea,"FOLDERID_PublicGameTasks"); + IF_GUID_EQUAL_RETURN(guid,0x48daf80b,0xe6cf,0x4f4e,0xb8,0x00,0x0e,0x69,0xd8,0x4e,0xe3,0x84,"FOLDERID_PublicLibraries"); + IF_GUID_EQUAL_RETURN(guid,0x3214FAB5,0x9757,0x4298,0xBB,0x61,0x92,0xA9,0xDE,0xAA,0x44,0xFF,"FOLDERID_PublicMusic"); + IF_GUID_EQUAL_RETURN(guid,0xB6EBFB86,0x6907,0x413C,0x9A,0xF7,0x4F,0xC2,0xAB,0xF0,0x7C,0xC5,"FOLDERID_PublicPictures"); + IF_GUID_EQUAL_RETURN(guid,0xE555AB60,0x153B,0x4D17,0x9F,0x04,0xA5,0xFE,0x99,0xFC,0x15,0xEC,"FOLDERID_PublicRingtones"); + IF_GUID_EQUAL_RETURN(guid,0x0482af6c,0x08f1,0x4c34,0x8c,0x90,0xe1,0x7e,0xc9,0x8b,0x1e,0x17,"FOLDERID_PublicUserTiles"); + IF_GUID_EQUAL_RETURN(guid,0x2400183A,0x6185,0x49FB,0xA2,0xD8,0x4A,0x39,0x2A,0x60,0x2B,0xA3,"FOLDERID_PublicVideos"); + IF_GUID_EQUAL_RETURN(guid,0x52a4f021,0x7b75,0x48a9,0x9f,0x6b,0x4b,0x87,0xa2,0x10,0xbc,0x8f,"FOLDERID_QuickLaunch"); + IF_GUID_EQUAL_RETURN(guid,0xAE50C081,0xEBD2,0x438A,0x86,0x55,0x8A,0x09,0x2E,0x34,0x98,0x7A,"FOLDERID_Recent"); + IF_GUID_EQUAL_RETURN(guid,0x1a6fdba2,0xf42d,0x4358,0xa7,0x98,0xb7,0x4d,0x74,0x59,0x26,0xc5,"FOLDERID_RecordedTVLibrary"); + IF_GUID_EQUAL_RETURN(guid,0xB7534046,0x3ECB,0x4C18,0xBE,0x4E,0x64,0xCD,0x4C,0xB7,0xD6,0xAC,"FOLDERID_RecycleBinFolder"); + IF_GUID_EQUAL_RETURN(guid,0x8AD10C31,0x2ADB,0x4296,0xA8,0xF7,0xE4,0x70,0x12,0x32,0xC9,0x72,"FOLDERID_ResourceDir"); + IF_GUID_EQUAL_RETURN(guid,0xC870044B,0xF49E,0x4126,0xA9,0xC3,0xB5,0x2A,0x1F,0xF4,0x11,0xE8,"FOLDERID_Ringtones"); + IF_GUID_EQUAL_RETURN(guid,0xaaa8d5a5,0xf1d6,0x4259,0xba,0xa8,0x78,0xe7,0xef,0x60,0x83,0x5e,"FOLDERID_RoamedTileImages"); + IF_GUID_EQUAL_RETURN(guid,0x3EB685DB,0x65F9,0x4CF6,0xA0,0x3A,0xE3,0xEF,0x65,0x72,0x9F,0x3D,"FOLDERID_RoamingAppData"); + IF_GUID_EQUAL_RETURN(guid,0xbcfc5a,0xed94,0x4e48,0x96,0xa1,0x3f,0x62,0x17,0xf2,0x19,0x90,"FOLDERID_RoamingTiles"); + IF_GUID_EQUAL_RETURN(guid,0xee32e446,0x31ca,0x4aba,0x81,0x4f,0xa5,0xeb,0xd2,0xfd,0x6d,0x5e,"FOLDERID_SEARCH_CSC"); + IF_GUID_EQUAL_RETURN(guid,0x98ec0e18,0x2098,0x4d44,0x86,0x44,0x66,0x97,0x93,0x15,0xa2,0x81,"FOLDERID_SEARCH_MAPI"); + IF_GUID_EQUAL_RETURN(guid,0xB250C668,0xF57D,0x4EE1,0xA6,0x3C,0x29,0x0E,0xE7,0xD1,0xAA,0x1F,"FOLDERID_SampleMusic"); + IF_GUID_EQUAL_RETURN(guid,0xC4900540,0x2379,0x4C75,0x84,0x4B,0x64,0xE6,0xFA,0xF8,0x71,0x6B,"FOLDERID_SamplePictures"); + IF_GUID_EQUAL_RETURN(guid,0x15CA69B3,0x30EE,0x49C1,0xAC,0xE1,0x6B,0x5E,0xC3,0x72,0xAF,0xB5,"FOLDERID_SamplePlaylists"); + IF_GUID_EQUAL_RETURN(guid,0x859EAD94,0x2E85,0x48AD,0xA7,0x1A,0x09,0x69,0xCB,0x56,0xA6,0xCD,"FOLDERID_SampleVideos"); + IF_GUID_EQUAL_RETURN(guid,0x4c5c32ff,0xbb9d,0x43b0,0xb5,0xb4,0x2d,0x72,0xe5,0x4e,0xaa,0xa4,"FOLDERID_SavedGames"); + IF_GUID_EQUAL_RETURN(guid,0x7d1d3a04,0xdebb,0x4115,0x95,0xcf,0x2f,0x29,0xda,0x29,0x20,0xda,"FOLDERID_SavedSearches"); + IF_GUID_EQUAL_RETURN(guid,0xb7bede81,0xdf94,0x4682,0xa7,0xd8,0x57,0xa5,0x26,0x20,0xb8,0x6f,"FOLDERID_Screenshots"); + IF_GUID_EQUAL_RETURN(guid,0x190337d1,0xb8ca,0x4121,0xa6,0x39,0x6d,0x47,0x2d,0x16,0x97,0x2a,"FOLDERID_SearchHome"); + IF_GUID_EQUAL_RETURN(guid,0x8983036C,0x27C0,0x404B,0x8F,0x08,0x10,0x2D,0x10,0xDC,0xFD,0x74,"FOLDERID_SendTo"); + IF_GUID_EQUAL_RETURN(guid,0x7b396e54,0x9ec5,0x4300,0xbe,0xa,0x24,0x82,0xeb,0xae,0x1a,0x26,"FOLDERID_SidebarDefaultParts"); + IF_GUID_EQUAL_RETURN(guid,0xa75d362e,0x50fc,0x4fb7,0xac,0x2c,0xa8,0xbe,0xaa,0x31,0x44,0x93,"FOLDERID_SidebarParts"); + IF_GUID_EQUAL_RETURN(guid,0x625B53C3,0xAB48,0x4EC1,0xBA,0x1F,0xA1,0xEF,0x41,0x46,0xFC,0x19,"FOLDERID_StartMenu"); + IF_GUID_EQUAL_RETURN(guid,0xB97D20BB,0xF46A,0x4C97,0xBA,0x10,0x5E,0x36,0x08,0x43,0x08,0x54,"FOLDERID_Startup"); + IF_GUID_EQUAL_RETURN(guid,0x43668BF8,0xC14E,0x49B2,0x97,0xC9,0x74,0x77,0x84,0xD7,0x84,0xB7,"FOLDERID_SyncManagerFolder"); + IF_GUID_EQUAL_RETURN(guid,0x289a9a43,0xbe44,0x4057,0xa4,0x1b,0x58,0x7a,0x76,0xd7,0xe7,0xf9,"FOLDERID_SyncResultsFolder"); + IF_GUID_EQUAL_RETURN(guid,0xf214138,0xb1d3,0x4a90,0xbb,0xa9,0x27,0xcb,0xc0,0xc5,0x38,0x9a,"FOLDERID_SyncSetupFolder"); + IF_GUID_EQUAL_RETURN(guid,0x1AC14E77,0x02E7,0x4E5D,0xB7,0x44,0x2E,0xB1,0xAE,0x51,0x98,0xB7,"FOLDERID_System"); + IF_GUID_EQUAL_RETURN(guid,0xD65231B0,0xB2F1,0x4857,0xA4,0xCE,0xA8,0xE7,0xC6,0xEA,0x7D,0x27,"FOLDERID_SystemX86"); + IF_GUID_EQUAL_RETURN(guid,0xA63293E8,0x664E,0x48DB,0xA0,0x79,0xDF,0x75,0x9E,0x05,0x09,0xF7,"FOLDERID_Templates"); + IF_GUID_EQUAL_RETURN(guid,0x9e3995ab,0x1f9c,0x4f13,0xb8,0x27,0x48,0xb2,0x4b,0x6c,0x71,0x74,"FOLDERID_UserPinned"); + IF_GUID_EQUAL_RETURN(guid,0x0762D272,0xC50A,0x4BB0,0xA3,0x82,0x69,0x7D,0xCD,0x72,0x9B,0x80,"FOLDERID_UserProfiles"); + IF_GUID_EQUAL_RETURN(guid,0x5cd7aee2,0x2219,0x4a67,0xb8,0x5d,0x6c,0x9c,0xe1,0x56,0x60,0xcb,"FOLDERID_UserProgramFiles"); + IF_GUID_EQUAL_RETURN(guid,0xbcbd3057,0xca5c,0x4622,0xb4,0x2d,0xbc,0x56,0xdb,0x0a,0xe5,0x16,"FOLDERID_UserProgramFilesCommon"); + IF_GUID_EQUAL_RETURN(guid,0xf3ce0f7c,0x4901,0x4acc,0x86,0x48,0xd5,0xd4,0x4b,0x04,0xef,0x8f,"FOLDERID_UsersFiles"); + IF_GUID_EQUAL_RETURN(guid,0xa302545d,0xdeff,0x464b,0xab,0xe8,0x61,0xc8,0x64,0x8d,0x93,0x9b,"FOLDERID_UsersLibraries"); + IF_GUID_EQUAL_RETURN(guid,0x18989B1D,0x99B5,0x455B,0x84,0x1C,0xAB,0x7C,0x74,0xE4,0xDD,0xFC,"FOLDERID_Videos"); + IF_GUID_EQUAL_RETURN(guid,0x491e922f,0x5643,0x4af4,0xa7,0xeb,0x4e,0x7a,0x13,0x8d,0x81,0x74,"FOLDERID_VideosLibrary"); + IF_GUID_EQUAL_RETURN(guid,0xF38BF404,0x1D43,0x42F2,0x93,0x05,0x67,0xDE,0x0B,0x28,0xFC,0x23,"FOLDERID_Windows"); + IF_GUID_EQUAL_RETURN(guid,0xdb2a5d8f,0x06e6,0x4007,0xab,0xa6,0xaf,0x87,0x7d,0x52,0x6e,0xa6,"FOLDERTYPEID_AccountPictures"); + IF_GUID_EQUAL_RETURN(guid,0x91475fe5,0x586b,0x4eba,0x8d,0x75,0xd1,0x74,0x34,0xb8,0xcd,0xf6,"FOLDERTYPEID_Communications"); + IF_GUID_EQUAL_RETURN(guid,0x80213e82,0xbcfd,0x4c4f,0x88,0x17,0xbb,0x27,0x60,0x12,0x67,0xa9,"FOLDERTYPEID_CompressedFolder"); + IF_GUID_EQUAL_RETURN(guid,0xde2b70ec,0x9bf7,0x4a93,0xbd,0x3d,0x24,0x3f,0x78,0x81,0xd4,0x92,"FOLDERTYPEID_Contacts"); + IF_GUID_EQUAL_RETURN(guid,0xde4f0660,0xfa10,0x4b8f,0xa4,0x94,0x06,0x8b,0x20,0xb2,0x23,0x07,"FOLDERTYPEID_ControlPanelCategory"); + IF_GUID_EQUAL_RETURN(guid,0x0c3794f3,0xb545,0x43aa,0xa3,0x29,0xc3,0x74,0x30,0xc5,0x8d,0x2a,"FOLDERTYPEID_ControlPanelClassic"); + IF_GUID_EQUAL_RETURN(guid,0x7d49d726,0x3c21,0x4f05,0x99,0xaa,0xfd,0xc2,0xc9,0x47,0x46,0x56,"FOLDERTYPEID_Documents"); + IF_GUID_EQUAL_RETURN(guid,0xb689b0d0,0x76d3,0x4cbb,0x87,0xf7,0x58,0x5d,0x0e,0x0c,0xe0,0x70,"FOLDERTYPEID_Games"); + IF_GUID_EQUAL_RETURN(guid,0x5c4f28b5,0xf869,0x4e84,0x8e,0x60,0xf1,0x1d,0xb9,0x7c,0x5c,0xc7,"FOLDERTYPEID_Generic"); + IF_GUID_EQUAL_RETURN(guid,0x5f4eab9a,0x6833,0x4f61,0x89,0x9d,0x31,0xcf,0x46,0x97,0x9d,0x49,"FOLDERTYPEID_GenericLibrary"); + IF_GUID_EQUAL_RETURN(guid,0x7fde1a1e,0x8b31,0x49a5,0x93,0xb8,0x6b,0xe1,0x4c,0xfa,0x49,0x43,"FOLDERTYPEID_GenericSearchResults"); + IF_GUID_EQUAL_RETURN(guid,0x57807898,0x8c4f,0x4462,0xbb,0x63,0x71,0x04,0x23,0x80,0xb1,0x09,"FOLDERTYPEID_Invalid"); + IF_GUID_EQUAL_RETURN(guid,0x94d6ddcc,0x4a68,0x4175,0xa3,0x74,0xbd,0x58,0x4a,0x51,0x0b,0x78,"FOLDERTYPEID_Music"); + IF_GUID_EQUAL_RETURN(guid,0x25cc242b,0x9a7c,0x4f51,0x80,0xe0,0x7a,0x29,0x28,0xfe,0xbe,0x42,"FOLDERTYPEID_NetworkExplorer"); + IF_GUID_EQUAL_RETURN(guid,0x8faf9629,0x1980,0x46ff,0x80,0x23,0x9d,0xce,0xab,0x9c,0x3e,0xe3,"FOLDERTYPEID_OpenSearch"); + IF_GUID_EQUAL_RETURN(guid,0xb337fd00,0x9dd5,0x4635,0xa6,0xd4,0xda,0x33,0xfd,0x10,0x2b,0x7a,"FOLDERTYPEID_OtherUsers"); + IF_GUID_EQUAL_RETURN(guid,0xb3690e58,0xe961,0x423b,0xb6,0x87,0x38,0x6e,0xbf,0xd8,0x32,0x39,"FOLDERTYPEID_Pictures"); + IF_GUID_EQUAL_RETURN(guid,0x2c7bbec6,0xc844,0x4a0a,0x91,0xfa,0xce,0xf6,0xf5,0x9c,0xfd,0xa1,"FOLDERTYPEID_Printers"); + IF_GUID_EQUAL_RETURN(guid,0x7f2f5b96,0xff74,0x41da,0xaf,0xd8,0x1c,0x78,0xa5,0xf3,0xae,0xa2,"FOLDERTYPEID_PublishedItems"); + IF_GUID_EQUAL_RETURN(guid,0x5557a28f,0x5da6,0x4f83,0x88,0x09,0xc2,0xc9,0x8a,0x11,0xa6,0xfa,"FOLDERTYPEID_RecordedTV"); + IF_GUID_EQUAL_RETURN(guid,0xd6d9e004,0xcd87,0x442b,0x9d,0x57,0x5e,0x0a,0xeb,0x4f,0x6f,0x72,"FOLDERTYPEID_RecycleBin"); + IF_GUID_EQUAL_RETURN(guid,0xd0363307,0x28cb,0x4106,0x9f,0x23,0x29,0x56,0xe3,0xe5,0xe0,0xe7,"FOLDERTYPEID_SavedGames"); + IF_GUID_EQUAL_RETURN(guid,0x982725ee,0x6f47,0x479e,0xb4,0x47,0x81,0x2b,0xfa,0x7d,0x2e,0x8f,"FOLDERTYPEID_SearchConnector"); + IF_GUID_EQUAL_RETURN(guid,0x834d8a44,0x0974,0x4ed6,0x86,0x6e,0xf2,0x03,0xd8,0x0b,0x38,0x10,"FOLDERTYPEID_SearchHome"); + IF_GUID_EQUAL_RETURN(guid,0x0b0ba2e3,0x405f,0x415e,0xa6,0xee,0xca,0xd6,0x25,0x20,0x78,0x53,"FOLDERTYPEID_Searches"); + IF_GUID_EQUAL_RETURN(guid,0xd674391b,0x52d9,0x4e07,0x83,0x4e,0x67,0xc9,0x86,0x10,0xf3,0x9d,"FOLDERTYPEID_SoftwareExplorer"); + IF_GUID_EQUAL_RETURN(guid,0xef87b4cb,0xf2ce,0x4785,0x86,0x58,0x4c,0xa6,0xc6,0x3e,0x38,0xc6,"FOLDERTYPEID_StartMenu"); + IF_GUID_EQUAL_RETURN(guid,0xcd0fc69b,0x71e2,0x46e5,0x96,0x90,0x5b,0xcd,0x9f,0x57,0xaa,0xb3,"FOLDERTYPEID_UserFiles"); + IF_GUID_EQUAL_RETURN(guid,0xc4d98f09,0x6124,0x4fe0,0x99,0x42,0x82,0x64,0x16,0x8,0x2d,0xa9,"FOLDERTYPEID_UsersLibraries"); + IF_GUID_EQUAL_RETURN(guid,0x5fa96407,0x7e77,0x483c,0xac,0x93,0x69,0x1d,0x05,0x85,0x0d,0xe8,"FOLDERTYPEID_Videos"); + IF_GUID_EQUAL_RETURN(guid,0x6739b36f,0x1d5f,0x4ac2,0x81,0x92,0x28,0xbb,0xe,0x73,0xd1,0x6a,"FORMATTYPE_CPFilters_Processed"); + IF_GUID_EQUAL_RETURN(guid,0xC4C4C4D1,0x0049,0x4E2B,0x98,0xFB,0x95,0x37,0xF6,0xCE,0x51,0x6D,"FORMATTYPE_ETDTFilter_Tagged"); + IF_GUID_EQUAL_RETURN(guid,0xc7ecf04d,0x4582,0x4869,0x9a,0xbb,0xbf,0xb5,0x23,0xb6,0x2e,0xdf,"FORMAT_525WSS"); + IF_GUID_EQUAL_RETURN(guid,0x482dde0,0x7817,0x11cf,0x8a,0x3,0x0,0xaa,0x0,0x6e,0xcb,0x65,"FORMAT_AnalogVideo"); + IF_GUID_EQUAL_RETURN(guid,0xa4efc024,0x873e,0x4da3,0x89,0x8b,0x47,0x4d,0xdb,0xd7,0x9f,0xd0,"FORMAT_CAPTIONED_H264VIDEO"); + IF_GUID_EQUAL_RETURN(guid,0x7ab2ada2,0x81b6,0x4f14,0xb3,0xc8,0xd0,0xc4,0x86,0x39,0x3b,0x67,"FORMAT_CAPTIONED_MPEG2VIDEO"); + IF_GUID_EQUAL_RETURN(guid,0x50997a4a,0xe508,0x4054,0xa2,0xb2,0x10,0xff,0xa,0xc1,0xa6,0x9a,"FORMAT_CC_CONTAINER"); + IF_GUID_EQUAL_RETURN(guid,0xe06d80e6,0xdb46,0x11cf,0xb4,0xd1,0x00,0x80,0x05f,0x6c,0xbb,0xea,"FORMAT_DVD_LPCMAudio"); + IF_GUID_EQUAL_RETURN(guid,0xe06d80e4,0xdb46,0x11cf,0xb4,0xd1,0x00,0x80,0x05f,0x6c,0xbb,0xea,"FORMAT_DolbyAC3"); + IF_GUID_EQUAL_RETURN(guid,0x05589f84,0xc356,0x11ce,0xbf,0x01,0x00,0xaa,0x00,0x55,0x59,0x5a,"FORMAT_DvInfo"); + IF_GUID_EQUAL_RETURN(guid,0x692fa379,0xd3e8,0x4651,0xb5,0xb4,0xb,0x94,0xb0,0x13,0xee,0xaf,"FORMAT_Image"); + IF_GUID_EQUAL_RETURN(guid,0x692fa379,0xd3e8,0x4651,0xb5,0xb4,0xb,0x94,0xb0,0x13,0xee,0xaf,"FORMAT_JPEGImage"); + IF_GUID_EQUAL_RETURN(guid,0xaed4ab2d,0x7326,0x43cb,0x94,0x64,0xc8,0x79,0xca,0xb9,0xc4,0x3d,"FORMAT_MFVideoFormat"); + IF_GUID_EQUAL_RETURN(guid,0xe06d80e5,0xdb46,0x11cf,0xb4,0xd1,0x00,0x80,0x05f,0x6c,0xbb,0xea,"FORMAT_MPEG2Audio"); + IF_GUID_EQUAL_RETURN(guid,0xe06d80e3,0xdb46,0x11cf,0xb4,0xd1,0x00,0x80,0x05f,0x6c,0xbb,0xea,"FORMAT_MPEG2Video"); + IF_GUID_EQUAL_RETURN(guid,0xe06d80e3,0xdb46,0x11cf,0xb4,0xd1,0x00,0x80,0x5f,0x6c,0xbb,0xea,"FORMAT_MPEG2_VIDEO"); + IF_GUID_EQUAL_RETURN(guid,0x05589f83,0xc356,0x11ce,0xbf,0x01,0x00,0xaa,0x00,0x55,0x59,0x5a,"FORMAT_MPEGStreams"); + IF_GUID_EQUAL_RETURN(guid,0x05589f82,0xc356,0x11ce,0xbf,0x01,0x00,0xaa,0x00,0x55,0x59,0x5a,"FORMAT_MPEGVideo"); + IF_GUID_EQUAL_RETURN(guid,0x0F6417D6,0xc318,0x11d0,0xa4,0x3f,0x00,0xa0,0xc9,0x22,0x31,0x96,"FORMAT_None"); + IF_GUID_EQUAL_RETURN(guid,0x2017be05,0x6629,0x4248,0xaa,0xed,0x7e,0x1a,0x47,0xbc,0x9b,0x9c,"FORMAT_UVCH264Video"); + IF_GUID_EQUAL_RETURN(guid,0xf72a76A0L,0xeb0a,0x11d0,0xac,0xe4,0x0,0x0,0xc0,0xcc,0x16,0xba,"FORMAT_VIDEOINFO2"); + IF_GUID_EQUAL_RETURN(guid,0xf72a76A0,0xeb0a,0x11d0,0xac,0xe4,0x00,0x00,0xc0,0xcc,0x16,0xba,"FORMAT_VideoInfo2"); + IF_GUID_EQUAL_RETURN(guid,0x05589f80,0xc356,0x11ce,0xbf,0x01,0x00,0xaa,0x00,0x55,0x59,0x5a,"FORMAT_VideoInfo"); + IF_GUID_EQUAL_RETURN(guid,0x05589f81,0xc356,0x11ce,0xbf,0x01,0x00,0xaa,0x00,0x55,0x59,0x5a,"FORMAT_WaveFormatEx"); + IF_GUID_EQUAL_RETURN(guid,0xb02f9d65,0xfb77,0x4f7a,0xaf,0xa5,0xb3,0x91,0x30,0x9f,0x11,0xc9,"FUSION_REFCOUNT_FILEPATH_GUID"); + IF_GUID_EQUAL_RETURN(guid,0x25df0fc1,0x7f97,0x4070,0xad,0xd7,0x4b,0x13,0xbb,0xfd,0x7c,0xb8,"FUSION_REFCOUNT_MSI_GUID"); + IF_GUID_EQUAL_RETURN(guid,0x2ec93463,0xb0c3,0x45e1,0x83,0x64,0x32,0x7e,0x96,0xae,0xa8,0x56,"FUSION_REFCOUNT_OPAQUE_STRING_GUID"); + IF_GUID_EQUAL_RETURN(guid,0xd16d444c,0x56d8,0x11d5,0x88,0x2d,0x00,0x80,0xc8,0x47,0xb1,0x95,"FUSION_REFCOUNT_OSINSTALL_GUID"); + IF_GUID_EQUAL_RETURN(guid,0x8cedc215,0xac4b,0x488b,0x93,0xc0,0xa5,0x0a,0x49,0xcb,0x2f,0xb8,"FUSION_REFCOUNT_UNINSTALL_SUBKEY_GUID"); + IF_GUID_EQUAL_RETURN(guid,0x5c6844f,0x19de,0x48f8,0x95,0xfa,0x88,0xd,0x5b,0xf,0xd6,0x15,"FlowsFrom_Property_GUID"); + IF_GUID_EQUAL_RETURN(guid,0xe4f33d20,0x559a,0x47fb,0xa8,0x30,0xf9,0xcb,0x4f,0xf1,0xa7,0x0a,"FlowsTo_Property_GUID"); + IF_GUID_EQUAL_RETURN(guid,0xdbfd9900,0x7e1a,0x4f58,0xb6,0x1b,0x70,0x63,0x12,0x0f,0x77,0x3b,"FrameworkId_Property_GUID"); + IF_GUID_EQUAL_RETURN(guid,0x5D3E9A59,0xE9D5,0x4B00,0xA6,0xBD,0xFF,0x34,0xFF,0x51,0x65,0x48,"GUID_ACDC_POWER_SOURCE"); + IF_GUID_EQUAL_RETURN(guid,0x31F9F286,0x5084,0x42FE,0xB7,0x20,0x2B,0x02,0x64,0x99,0x37,0x63,"GUID_ACTIVE_POWERSCHEME"); + IF_GUID_EQUAL_RETURN(guid,0x8619b916,0xe004,0x4dd8,0x9b,0x66,0xda,0xe8,0x6f,0x80,0x66,0x98,"GUID_ADAPTIVE_POWER_BEHAVIOR_SUBGROUP"); + IF_GUID_EQUAL_RETURN(guid,0x25dfa149,0x5dd1,0x4736,0xb5,0xab,0xe8,0xa3,0x7b,0x5b,0x81,0x87,"GUID_ALLOW_AWAYMODE"); + IF_GUID_EQUAL_RETURN(guid,0xA9CEB8DA,0xCD46,0x44FB,0xA9,0x8B,0x02,0xAF,0x69,0xDE,0x46,0x23,"GUID_ALLOW_DISPLAY_REQUIRED"); + IF_GUID_EQUAL_RETURN(guid,0xBD3B718A,0x0680,0x4D9D,0x8A,0xB2,0xE1,0xD2,0xB4,0xAC,0x80,0x6D,"GUID_ALLOW_RTC_WAKE"); + IF_GUID_EQUAL_RETURN(guid,0xabfc2519,0x3608,0x4c2a,0x94,0xea,0x17,0x1b,0x0e,0xd5,0x46,0xab,"GUID_ALLOW_STANDBY_STATES"); + IF_GUID_EQUAL_RETURN(guid,0xA4B195F5,0x8225,0x47D8,0x80,0x12,0x9D,0x41,0x36,0x97,0x86,0xE2,"GUID_ALLOW_SYSTEM_REQUIRED"); + IF_GUID_EQUAL_RETURN(guid,0x1A689231,0x7399,0x4E9A,0x8F,0x99,0xB7,0x1F,0x99,0x9D,0xB3,0xFA,"GUID_APPLAUNCH_BUTTON"); + IF_GUID_EQUAL_RETURN(guid,0xaa114de5,0xc262,0x4169,0xa1,0xc8,0x23,0xd6,0x98,0xcc,0x73,0xb5,"GUID_All_Objects"); + IF_GUID_EQUAL_RETURN(guid,0xCF23F240,0x2A54,0x48D8,0xB1,0x14,0xDE,0x15,0x18,0xFF,0x05,0x2E,"GUID_BACKGROUND_TASK_NOTIFICATION"); + IF_GUID_EQUAL_RETURN(guid,0x637EA02F,0xBBCB,0x4015,0x8E,0x2C,0xA1,0xC7,0xB9,0xC0,0xB5,0x46,"GUID_BATTERY_DISCHARGE_ACTION_0"); + IF_GUID_EQUAL_RETURN(guid,0xD8742DCB,0x3E6A,0x4B3C,0xB3,0xFE,0x37,0x46,0x23,0xCD,0xCF,0x06,"GUID_BATTERY_DISCHARGE_ACTION_1"); + IF_GUID_EQUAL_RETURN(guid,0x421CBA38,0x1A8E,0x4881,0xAC,0x89,0xE3,0x3A,0x8B,0x04,0xEC,0xE4,"GUID_BATTERY_DISCHARGE_ACTION_2"); + IF_GUID_EQUAL_RETURN(guid,0x80472613,0x9780,0x455E,0xB3,0x08,0x72,0xD3,0x00,0x3C,0xF2,0xF8,"GUID_BATTERY_DISCHARGE_ACTION_3"); + IF_GUID_EQUAL_RETURN(guid,0x5dbb7c9f,0x38e9,0x40d2,0x97,0x49,0x4f,0x8a,0x0e,0x9f,0x64,0x0f,"GUID_BATTERY_DISCHARGE_FLAGS_0"); + IF_GUID_EQUAL_RETURN(guid,0xbcded951,0x187b,0x4d05,0xbc,0xcc,0xf7,0xe5,0x19,0x60,0xc2,0x58,"GUID_BATTERY_DISCHARGE_FLAGS_1"); + IF_GUID_EQUAL_RETURN(guid,0x7fd2f0c4,0xfeb7,0x4da3,0x81,0x17,0xe3,0xfb,0xed,0xc4,0x65,0x82,"GUID_BATTERY_DISCHARGE_FLAGS_2"); + IF_GUID_EQUAL_RETURN(guid,0x73613ccf,0xdbfa,0x4279,0x83,0x56,0x49,0x35,0xf6,0xbf,0x62,0xf3,"GUID_BATTERY_DISCHARGE_FLAGS_3"); + IF_GUID_EQUAL_RETURN(guid,0x9A66D8D7,0x4FF7,0x4EF9,0xB5,0xA2,0x5A,0x32,0x6C,0xA2,0xA4,0x69,"GUID_BATTERY_DISCHARGE_LEVEL_0"); + IF_GUID_EQUAL_RETURN(guid,0x8183BA9A,0xE910,0x48DA,0x87,0x69,0x14,0xAE,0x6D,0xC1,0x17,0x0A,"GUID_BATTERY_DISCHARGE_LEVEL_1"); + IF_GUID_EQUAL_RETURN(guid,0x07A07CA2,0xADAF,0x40D7,0xB0,0x77,0x53,0x3A,0xAD,0xED,0x1B,0xFA,"GUID_BATTERY_DISCHARGE_LEVEL_2"); + IF_GUID_EQUAL_RETURN(guid,0x58AFD5A6,0xC2DD,0x47D2,0x9F,0xBF,0xEF,0x70,0xCC,0x5C,0x59,0x65,"GUID_BATTERY_DISCHARGE_LEVEL_3"); + IF_GUID_EQUAL_RETURN(guid,0xA7AD8041,0xB45A,0x4CAE,0x87,0xA3,0xEE,0xCB,0xB4,0x68,0xA9,0xE1,"GUID_BATTERY_PERCENTAGE_REMAINING"); + IF_GUID_EQUAL_RETURN(guid,0xE73A048D,0xBF27,0x4F12,0x97,0x31,0x8B,0x20,0x76,0xE8,0x89,0x1F,"GUID_BATTERY_SUBGROUP"); + IF_GUID_EQUAL_RETURN(guid,0xA36D02F0,0xC9F3,0x11CF,0xBF,0xC7,0x44,0x45,0x53,0x54,0x00,0x00,"GUID_Button"); + IF_GUID_EQUAL_RETURN(guid,0x6fe69556,0x704a,0x47a0,0x8f,0x24,0xc2,0x8d,0x93,0x6f,0xda,0x47,"GUID_CONSOLE_DISPLAY_STATE"); + IF_GUID_EQUAL_RETURN(guid,0xB7A27025,0xE569,0x46c2,0xA5,0x04,0x2B,0x96,0xCA,0xD2,0x25,0xA1,"GUID_CRITICAL_POWER_TRANSITION"); + IF_GUID_EQUAL_RETURN(guid,0xefd60cc2,0x49e7,0x11d0,0x88,0x9d,0x0,0xaa,0x0,0xbb,0xb7,0x6a,"GUID_ColorControlCallbacks"); + IF_GUID_EQUAL_RETURN(guid,0xefd60cc2,0x49e7,0x11d0,0x88,0x9d,0x00,0xaa,0x00,0xbb,0xb7,0x6a,"GUID_ColorControlCallbacks"); + IF_GUID_EQUAL_RETURN(guid,0x13541C20,0x8E33,0x11D0,0x9A,0xD0,0x00,0xA0,0xC9,0xA0,0x6E,0x35,"GUID_ConstantForce"); + IF_GUID_EQUAL_RETURN(guid,0x0af1d87e,0xfcfe,0x4188,0xbd,0xeb,0xa7,0x90,0x64,0x71,0xcb,0xe3,"GUID_ContainerFormatBmp"); + IF_GUID_EQUAL_RETURN(guid,0x1f8a5601,0x7d4d,0x4cbd,0x9c,0x82,0x1b,0xc8,0xd4,0xee,0xb9,0xa5,"GUID_ContainerFormatGif"); + IF_GUID_EQUAL_RETURN(guid,0xa3a860c4,0x338f,0x4c17,0x91,0x9a,0xfb,0xa4,0xb5,0x62,0x8f,0x21,"GUID_ContainerFormatIco"); + IF_GUID_EQUAL_RETURN(guid,0x19e4a5aa,0x5662,0x4fc5,0xa0,0xc0,0x17,0x58,0x02,0x8e,0x10,0x57,"GUID_ContainerFormatJpeg"); + IF_GUID_EQUAL_RETURN(guid,0x1b7cfaf4,0x713f,0x473c,0xbb,0xcd,0x61,0x37,0x42,0x5f,0xae,0xaf,"GUID_ContainerFormatPng"); + IF_GUID_EQUAL_RETURN(guid,0x163bcc30,0xe2e9,0x4f0b,0x96,0x1d,0xa3,0xe9,0xfd,0xb7,0x88,0xa3,"GUID_ContainerFormatTiff"); + IF_GUID_EQUAL_RETURN(guid,0x57a37caa,0x367a,0x4540,0x91,0x6b,0xf1,0x83,0xc5,0x09,0x3a,0x4b,"GUID_ContainerFormatWmp"); + IF_GUID_EQUAL_RETURN(guid,0x13541C2B,0x8E33,0x11D0,0x9A,0xD0,0x00,0xA0,0xC9,0xA0,0x6E,0x35,"GUID_CustomForce"); + IF_GUID_EQUAL_RETURN(guid,0x0ba584e1,0x70b6,0x11d0,0x88,0x9d,0x00,0xaa,0x00,0xbb,0xb7,0x6a,"GUID_D3DCallbacks2"); + IF_GUID_EQUAL_RETURN(guid,0xba584e1,0x70b6,0x11d0,0x88,0x9d,0x0,0xaa,0x0,0xbb,0xb7,0x6a,"GUID_D3DCallbacks2"); + IF_GUID_EQUAL_RETURN(guid,0xddf41230,0xec0a,0x11d0,0xa9,0xb6,0x00,0xaa,0x00,0xc0,0x99,0x3e,"GUID_D3DCallbacks3"); + IF_GUID_EQUAL_RETURN(guid,0x7bf06990,0x8794,0x11d0,0x91,0x39,0x08,0x00,0x36,0xd2,0xef,0x02,"GUID_D3DCallbacks"); + IF_GUID_EQUAL_RETURN(guid,0x7bf06991,0x8794,0x11d0,0x91,0x39,0x08,0x00,0x36,0xd2,0xef,0x02,"GUID_D3DCaps"); + IF_GUID_EQUAL_RETURN(guid,0x7de41f80,0x9d93,0x11d0,0x89,0xab,0x0,0xa0,0xc9,0x5,0x41,0x29,"GUID_D3DExtendedCaps"); + IF_GUID_EQUAL_RETURN(guid,0x7de41f80,0x9d93,0x11d0,0x89,0xab,0x00,0xa0,0xc9,0x05,0x41,0x29,"GUID_D3DExtendedCaps"); + IF_GUID_EQUAL_RETURN(guid,0x2e04ffa0,0x98e4,0x11d1,0x8c,0xe1,0x0,0xa0,0xc9,0x6,0x29,0xa8,"GUID_D3DParseUnknownCommandCallback"); + IF_GUID_EQUAL_RETURN(guid,0x880baf30,0xb030,0x11d0,0x8e,0xa7,0x00,0x60,0x97,0x97,0xea,0x5b,"GUID_DDMoreCaps"); + IF_GUID_EQUAL_RETURN(guid,0x3b8a0466,0xf269,0x11d1,0x88,0x0b,0x0,0xc0,0x4f,0xd9,0x30,0xc5,"GUID_DDMoreSurfaceCaps"); + IF_GUID_EQUAL_RETURN(guid,0xf828169c,0xa8e8,0x11d2,0xa1,0xf2,0x0,0xa0,0xc9,0x83,0xea,0xf6,"GUID_DDStereoMode"); + IF_GUID_EQUAL_RETURN(guid,0x4faab71a,0x92e5,0x4726,0xb5,0x31,0x22,0x45,0x59,0x67,0x2d,0x19,"GUID_DEVICE_IDLE_POLICY"); + IF_GUID_EQUAL_RETURN(guid,0xaded5e82L,0xb909,0x4619,0x99,0x49,0xf5,0xd7,0x1d,0xac,0x0b,0xcb,"GUID_DEVICE_POWER_POLICY_VIDEO_BRIGHTNESS"); + IF_GUID_EQUAL_RETURN(guid,0xf1fbfde2,0xa960,0x4165,0x9f,0x88,0x50,0x66,0x79,0x11,0xce,0x96,"GUID_DEVICE_POWER_POLICY_VIDEO_DIM_BRIGHTNESS"); + IF_GUID_EQUAL_RETURN(guid,0x53f56312L,0xb6bf,0x11d0,0x94,0xf2,0x00,0xa0,0xc9,0x1e,0xfb,0x8b,"GUID_DEVINTERFACE_CDCHANGER"); + IF_GUID_EQUAL_RETURN(guid,0x53f56308L,0xb6bf,0x11d0,0x94,0xf2,0x00,0xa0,0xc9,0x1e,0xfb,0x8b,"GUID_DEVINTERFACE_CDROM"); + IF_GUID_EQUAL_RETURN(guid,0x86e0d1e0L,0x8089,0x11d0,0x9c,0xe4,0x08,0x00,0x3e,0x30,0x1f,0x73,"GUID_DEVINTERFACE_COMPORT"); + IF_GUID_EQUAL_RETURN(guid,0x53f56307L,0xb6bf,0x11d0,0x94,0xf2,0x00,0xa0,0xc9,0x1e,0xfb,0x8b,"GUID_DEVINTERFACE_DISK"); + IF_GUID_EQUAL_RETURN(guid,0x25B4E268,0x2A05,0x496e,0x80,0x3B,0x26,0x68,0x37,0xFB,0xDA,0x4B,"GUID_DEVINTERFACE_DMP"); + IF_GUID_EQUAL_RETURN(guid,0xD0875FB4,0x2196,0x4c7a,0xA6,0x3D,0xE4,0x16,0xAD,0xDD,0x60,0xA1,"GUID_DEVINTERFACE_DMR"); + IF_GUID_EQUAL_RETURN(guid,0xC96037AE,0xA558,0x4470,0xB4,0x32,0x11,0x5A,0x31,0xB8,0x55,0x53,"GUID_DEVINTERFACE_DMS"); + IF_GUID_EQUAL_RETURN(guid,0x3897f6a4,0xfd35,0x4bc8,0xa0,0xb7,0x5d,0xbb,0xa3,0x6a,0xda,0xfa,"GUID_DEVINTERFACE_ENHANCED_STORAGE_SILO"); + IF_GUID_EQUAL_RETURN(guid,0x53f56311L,0xb6bf,0x11d0,0x94,0xf2,0x00,0xa0,0xc9,0x1e,0xfb,0x8b,"GUID_DEVINTERFACE_FLOPPY"); + IF_GUID_EQUAL_RETURN(guid,0x7f108a28L,0x9833,0x4b3b,0xb7,0x80,0x2c,0x6b,0x5f,0xa5,0xc0,0x62,"GUID_DEVINTERFACE_HIDDEN_VOLUME"); + IF_GUID_EQUAL_RETURN(guid,0x53f56310L,0xb6bf,0x11d0,0x94,0xf2,0x00,0xa0,0xc9,0x1e,0xfb,0x8b,"GUID_DEVINTERFACE_MEDIUMCHANGER"); + IF_GUID_EQUAL_RETURN(guid,0x53f5630aL,0xb6bf,0x11d0,0x94,0xf2,0x00,0xa0,0xc9,0x1e,0xfb,0x8b,"GUID_DEVINTERFACE_PARTITION"); + IF_GUID_EQUAL_RETURN(guid,0x4D36E978L,0xE325,0x11CE,0xBF,0xC1,0x08,0x00,0x2B,0xE1,0x03,0x18,"GUID_DEVINTERFACE_SERENUM_BUS_ENUMERATOR"); + IF_GUID_EQUAL_RETURN(guid,0x1790c9ecL,0x47d5,0x4df3,0xb5,0xaf,0x9a,0xdf,0x3c,0xf2,0x3e,0x48,"GUID_DEVINTERFACE_SES"); + IF_GUID_EQUAL_RETURN(guid,0x50DD5230,0xBA8A,0x11D1,0xBF,0x5D,0x00,0x00,0xF8,0x05,0xF5,0x30,"GUID_DEVINTERFACE_SMARTCARD_READER"); + IF_GUID_EQUAL_RETURN(guid,0x2accfe60L,0xc130,0x11d2,0xb0,0x82,0x00,0xa0,0xc9,0x1e,0xfb,0x8b,"GUID_DEVINTERFACE_STORAGEPORT"); + IF_GUID_EQUAL_RETURN(guid,0x53f5630bL,0xb6bf,0x11d0,0x94,0xf2,0x00,0xa0,0xc9,0x1e,0xfb,0x8b,"GUID_DEVINTERFACE_TAPE"); + IF_GUID_EQUAL_RETURN(guid,0x6f416619L,0x9f29,0x42a5,0xb2,0x0b,0x37,0xe2,0x19,0xca,0x02,0xb0,"GUID_DEVINTERFACE_VMLUN"); + IF_GUID_EQUAL_RETURN(guid,0x53f5630dL,0xb6bf,0x11d0,0x94,0xf2,0x00,0xa0,0xc9,0x1e,0xfb,0x8b,"GUID_DEVINTERFACE_VOLUME"); + IF_GUID_EQUAL_RETURN(guid,0x53f5630cL,0xb6bf,0x11d0,0x94,0xf2,0x00,0xa0,0xc9,0x1e,0xfb,0x8b,"GUID_DEVINTERFACE_WRITEONCEDISK"); + IF_GUID_EQUAL_RETURN(guid,0x396A32E1,0x499A,0x40B2,0x91,0x24,0xA9,0x6A,0xFE,0x70,0x76,0x67,"GUID_DISK_ADAPTIVE_POWERDOWN"); + IF_GUID_EQUAL_RETURN(guid,0x80e3c60e,0xbb94,0x4ad8,0xbb,0xe0,0x0d,0x31,0x95,0xef,0xc6,0x63,"GUID_DISK_BURST_IGNORE_THRESHOLD"); + IF_GUID_EQUAL_RETURN(guid,0xc36f0eb4,0x2988,0x4a70,0x8e,0xee,0x8,0x84,0xfc,0x2c,0x24,0x33,"GUID_DISK_COALESCING_POWERDOWN_TIMEOUT"); + IF_GUID_EQUAL_RETURN(guid,0x58E39BA8,0xB8E6,0x4EF6,0x90,0xD0,0x89,0xAE,0x32,0xB2,0x58,0xD6,"GUID_DISK_IDLE_TIMEOUT"); + IF_GUID_EQUAL_RETURN(guid,0x6738E2C4,0xE8A5,0x4A42,0xB1,0x6A,0xE0,0x40,0xE7,0x69,0x75,0x6E,"GUID_DISK_POWERDOWN_TIMEOUT"); + IF_GUID_EQUAL_RETURN(guid,0x0012EE47,0x9041,0x4B5D,0x9B,0x77,0x53,0x5F,0xBA,0x8B,0x14,0x42,"GUID_DISK_SUBGROUP"); + IF_GUID_EQUAL_RETURN(guid,0x178f2f27,0xc364,0x11d1,0xa7,0x60,0x00,0x00,0xf8,0x75,0xac,0x12,"GUID_DMUS_PROP_DLS1"); + IF_GUID_EQUAL_RETURN(guid,0xf14599e5,0x4689,0x11d2,0xaf,0xa6,0x0,0xaa,0x0,0x24,0xd8,0xb6,"GUID_DMUS_PROP_DLS2"); + IF_GUID_EQUAL_RETURN(guid,0xcda8d611,0x684a,0x11d2,0x87,0x1e,0x0,0x60,0x8,0x93,0xb1,0xbd,"GUID_DMUS_PROP_Effects"); + IF_GUID_EQUAL_RETURN(guid,0x178f2f24,0xc364,0x11d1,0xa7,0x60,0x00,0x00,0xf8,0x75,0xac,0x12,"GUID_DMUS_PROP_GM_Hardware"); + IF_GUID_EQUAL_RETURN(guid,0x6496aba2,0x61b0,0x11d2,0xaf,0xa6,0x0,0xaa,0x0,0x24,0xd8,0xb6,"GUID_DMUS_PROP_GS_Capable"); + IF_GUID_EQUAL_RETURN(guid,0x178f2f25,0xc364,0x11d1,0xa7,0x60,0x00,0x00,0xf8,0x75,0xac,0x12,"GUID_DMUS_PROP_GS_Hardware"); + IF_GUID_EQUAL_RETURN(guid,0x865fd372,0x9f67,0x11d2,0x87,0x2a,0x0,0x60,0x8,0x93,0xb1,0xbd,"GUID_DMUS_PROP_INSTRUMENT2"); + IF_GUID_EQUAL_RETURN(guid,0xcfa7cdc2,0x00a1,0x11d2,0xaa,0xd5,0x00,0x00,0xf8,0x75,0xac,0x12,"GUID_DMUS_PROP_LegacyCaps"); + IF_GUID_EQUAL_RETURN(guid,0x178f2f28,0xc364,0x11d1,0xa7,0x60,0x00,0x00,0xf8,0x75,0xac,0x12,"GUID_DMUS_PROP_MemorySize"); + IF_GUID_EQUAL_RETURN(guid,0x178f2f28,0xc364,0x11d1,0xa7,0x60,0x00,0x00,0xf8,0x75,0xac,0x12,"GUID_DMUS_PROP_SampleMemorySize"); + IF_GUID_EQUAL_RETURN(guid,0x2a91f713,0xa4bf,0x11d2,0xbb,0xdf,0x0,0x60,0x8,0x33,0xdb,0xd8,"GUID_DMUS_PROP_SamplePlaybackRate"); + IF_GUID_EQUAL_RETURN(guid,0x0a3a5ba5,0x37b6,0x11d2,0xb9,0xf9,0x00,0x00,0xf8,0x75,0xac,0x12,"GUID_DMUS_PROP_SetSynthSink"); + IF_GUID_EQUAL_RETURN(guid,0xbe208857,0x8952,0x11d2,0xba,0x1c,0x00,0x00,0xf8,0x75,0xac,0x12,"GUID_DMUS_PROP_SinkUsesDSound"); + IF_GUID_EQUAL_RETURN(guid,0xaa97844,0xc877,0x11d1,0x87,0xc,0x0,0x60,0x8,0x93,0xb1,0xbd,"GUID_DMUS_PROP_SynthSink_DSOUND"); + IF_GUID_EQUAL_RETURN(guid,0xaa97845,0xc877,0x11d1,0x87,0xc,0x0,0x60,0x8,0x93,0xb1,0xbd,"GUID_DMUS_PROP_SynthSink_WAVE"); + IF_GUID_EQUAL_RETURN(guid,0xfedfae25L,0xe46e,0x11d1,0xaa,0xce,0x00,0x00,0xf8,0x75,0xac,0x12,"GUID_DMUS_PROP_Volume"); + IF_GUID_EQUAL_RETURN(guid,0x4cb5622,0x32e5,0x11d2,0xaf,0xa6,0x0,0xaa,0x0,0x24,0xd8,0xb6,"GUID_DMUS_PROP_WavesReverb"); + IF_GUID_EQUAL_RETURN(guid,0x268a0fa0,0x60f2,0x11d2,0xaf,0xa6,0x0,0xaa,0x0,0x24,0xd8,0xb6,"GUID_DMUS_PROP_WriteLatency"); + IF_GUID_EQUAL_RETURN(guid,0x268a0fa1,0x60f2,0x11d2,0xaf,0xa6,0x0,0xaa,0x0,0x24,0xd8,0xb6,"GUID_DMUS_PROP_WritePeriod"); + IF_GUID_EQUAL_RETURN(guid,0x6496aba1,0x61b0,0x11d2,0xaf,0xa6,0x0,0xaa,0x0,0x24,0xd8,0xb6,"GUID_DMUS_PROP_XG_Capable"); + IF_GUID_EQUAL_RETURN(guid,0x178f2f26,0xc364,0x11d1,0xa7,0x60,0x00,0x00,0xf8,0x75,0xac,0x12,"GUID_DMUS_PROP_XG_Hardware"); + IF_GUID_EQUAL_RETURN(guid,0xBF963D80L,0xC559,0x11D0,0x8A,0x2B,0x00,0xA0,0xC9,0x25,0x5A,0xC1,"GUID_DSCFX_CLASS_AEC"); + IF_GUID_EQUAL_RETURN(guid,0xe07f903f,0x62fd,0x4e60,0x8c,0xdd,0xde,0xa7,0x23,0x66,0x65,0xb5,"GUID_DSCFX_CLASS_NS"); + IF_GUID_EQUAL_RETURN(guid,0xcdebb919,0x379a,0x488a,0x87,0x65,0xf5,0x3c,0xfd,0x36,0xde,0x40,"GUID_DSCFX_MS_AEC"); + IF_GUID_EQUAL_RETURN(guid,0x11c5c73b,0x66e9,0x4ba1,0xa0,0xba,0xe8,0x14,0xc6,0xee,0xd9,0x2d,"GUID_DSCFX_MS_NS"); + IF_GUID_EQUAL_RETURN(guid,0x1c22c56d,0x9879,0x4f5b,0xa3,0x89,0x27,0x99,0x6d,0xdc,0x28,0x10,"GUID_DSCFX_SYSTEM_AEC"); + IF_GUID_EQUAL_RETURN(guid,0x5ab0882e,0x7274,0x4516,0x87,0x7d,0x4e,0xee,0x99,0xba,0x4f,0xd0,"GUID_DSCFX_SYSTEM_NS"); + IF_GUID_EQUAL_RETURN(guid,0xefe6629c,0x81f7,0x4281,0xbd,0x91,0xc9,0xd6,0x04,0xa9,0x5a,0xf6,"GUID_DSFX_STANDARD_CHORUS"); + IF_GUID_EQUAL_RETURN(guid,0xef011f79,0x4000,0x406d,0x87,0xaf,0xbf,0xfb,0x3f,0xc3,0x9d,0x57,"GUID_DSFX_STANDARD_COMPRESSOR"); + IF_GUID_EQUAL_RETURN(guid,0xef114c90,0xcd1d,0x484e,0x96,0xe5,0x09,0xcf,0xaf,0x91,0x2a,0x21,"GUID_DSFX_STANDARD_DISTORTION"); + IF_GUID_EQUAL_RETURN(guid,0xef3e932c,0xd40b,0x4f51,0x8c,0xcf,0x3f,0x98,0xf1,0xb2,0x9d,0x5d,"GUID_DSFX_STANDARD_ECHO"); + IF_GUID_EQUAL_RETURN(guid,0xefca3d92,0xdfd8,0x4672,0xa6,0x03,0x74,0x20,0x89,0x4b,0xad,0x98,"GUID_DSFX_STANDARD_FLANGER"); + IF_GUID_EQUAL_RETURN(guid,0xdafd8210,0x5711,0x4b91,0x9f,0xe3,0xf7,0x5b,0x7a,0xe2,0x79,0xbf,"GUID_DSFX_STANDARD_GARGLE"); + IF_GUID_EQUAL_RETURN(guid,0xef985e71,0xd5c7,0x42d4,0xba,0x4d,0x2d,0x07,0x3e,0x2e,0x96,0xf4,"GUID_DSFX_STANDARD_I3DL2REVERB"); + IF_GUID_EQUAL_RETURN(guid,0x120ced89,0x3bf4,0x4173,0xa1,0x32,0x3c,0xb4,0x06,0xcf,0x32,0x31,"GUID_DSFX_STANDARD_PARAMEQ"); + IF_GUID_EQUAL_RETURN(guid,0x87fc0268,0x9a55,0x4360,0x95,0xaa,0x00,0x4a,0x1d,0x9d,0xe2,0x6c,"GUID_DSFX_WAVES_REVERB"); + IF_GUID_EQUAL_RETURN(guid,0x13541C28,0x8E33,0x11D0,0x9A,0xD0,0x00,0xA0,0xC9,0xA0,0x6E,0x35,"GUID_Damper"); + IF_GUID_EQUAL_RETURN(guid,0x740d9ee6,0x70f1,0x11d1,0xad,0x10,0x0,0xa0,0x24,0x38,0xad,0x48,"GUID_DeviceArrivedLaunch"); + IF_GUID_EQUAL_RETURN(guid,0xd722fb4d,0x7a68,0x437a,0xb2,0x0c,0x58,0x04,0xee,0x24,0x94,0xa6,"GUID_DeviceType"); + IF_GUID_EQUAL_RETURN(guid,0xcd2bc5c9,0xf452,0x4326,0xb7,0x14,0xf9,0xc5,0x39,0xd4,0xda,0x58,"GUID_DispIdOverride"); + IF_GUID_EQUAL_RETURN(guid,0x833a6b62,0xdfa4,0x46d1,0x82,0xf8,0xe0,0x9e,0x34,0xd0,0x29,0xd6,"GUID_ENABLE_SWITCH_FORCED_SHUTDOWN"); + IF_GUID_EQUAL_RETURN(guid,0x3166bc41,0x7e98,0x4e03,0xb3,0x4e,0xec,0xf,0x5f,0x2b,0x21,0x8e,"GUID_EXECUTION_REQUIRED_REQUEST_TIMEOUT"); + IF_GUID_EQUAL_RETURN(guid,0x90883f05,0x3d28,0x11d2,0x8f,0x17,0x0,0xa0,0xc9,0xa6,0x18,0x6d,"GUID_ExportedFromComPlus"); + IF_GUID_EQUAL_RETURN(guid,0xb64784eb,0xd8d4,0x4d9b,0x9a,0xcd,0x0e,0x30,0x80,0x64,0x26,0xf7,"GUID_ForceIEnumerable"); + IF_GUID_EQUAL_RETURN(guid,0x13541C2A,0x8E33,0x11D0,0x9A,0xD0,0x00,0xA0,0xC9,0xA0,0x6E,0x35,"GUID_Friction"); + IF_GUID_EQUAL_RETURN(guid,0x54fc8f55,0x38de,0x4703,0x9c,0x4e,0x25,0x3,0x51,0x30,0x2b,0x1c,"GUID_Function2Getter"); + IF_GUID_EQUAL_RETURN(guid,0x786e8a1d,0xb427,0x4344,0x92,0x7,0x9,0xe7,0xb,0xdc,0xbe,0xa9,"GUID_GLOBAL_USER_PRESENCE"); + IF_GUID_EQUAL_RETURN(guid,0x42e02f16,0x7b41,0x11d2,0x8b,0xff,0x0,0xa0,0xc9,0x83,0xea,0xf6,"GUID_GetHeapAlignment"); + IF_GUID_EQUAL_RETURN(guid,0x94AC6D29,0x73CE,0x41A6,0x80,0x9F,0x63,0x63,0xBA,0x21,0xB4,0x7E,"GUID_HIBERNATE_FASTS4_POLICY"); + IF_GUID_EQUAL_RETURN(guid,0x9D7815A6,0x7EE4,0x497E,0x88,0x88,0x51,0x5A,0x05,0xF0,0x23,0x64,"GUID_HIBERNATE_TIMEOUT"); + IF_GUID_EQUAL_RETURN(guid,0x515C31D8,0xF734,0x163D,0xA0,0xFD,0x11,0xA0,0x8C,0x91,0xE8,0xF1,"GUID_IDLE_BACKGROUND_TASK"); + IF_GUID_EQUAL_RETURN(guid,0xc42b79aa,0xaa3a,0x484b,0xa9,0x8f,0x2c,0xf3,0x2a,0xa9,0xa,0x28,"GUID_IDLE_RESILIENCY_PERIOD"); + IF_GUID_EQUAL_RETURN(guid,0x2e601130,0x5351,0x4d9d,0x8e,0x4,0x25,0x29,0x66,0xba,0xd0,0x54,"GUID_IDLE_RESILIENCY_SUBGROUP"); + IF_GUID_EQUAL_RETURN(guid,0xe6d1bd11,0x82f7,0x4903,0xae,0x21,0x1a,0x63,0x97,0xcd,0xe2,0xeb,"GUID_INTEGRATIONSTYLE_SEARCHBOX"); + IF_GUID_EQUAL_RETURN(guid,0x13541C29,0x8E33,0x11D0,0x9A,0xD0,0x00,0xA0,0xC9,0xA0,0x6E,0x35,"GUID_Inertia"); + IF_GUID_EQUAL_RETURN(guid,0x6F1D2B70,0xD5A0,0x11CF,0xBF,0xC7,0x44,0x45,0x53,0x54,0x00,0x00,"GUID_Joystick"); + IF_GUID_EQUAL_RETURN(guid,0x80863800,0x6B06,0x11D0,0x9B,0x06,0x0,0xA0,0xC9,0x03,0xA3,0xB8,"GUID_KernelCallbacks"); + IF_GUID_EQUAL_RETURN(guid,0xFFAA7540,0x7AA8,0x11D0,0x9B,0x06,0x00,0xA0,0xC9,0x03,0xA3,0xB8,"GUID_KernelCaps"); + IF_GUID_EQUAL_RETURN(guid,0x55728220,0xD33C,0x11CF,0xBF,0xC7,0x44,0x45,0x53,0x54,0x00,0x00,"GUID_Key"); + IF_GUID_EQUAL_RETURN(guid,0x5CA83367,0x6E45,0x459F,0xA2,0x7B,0x47,0x6B,0x1D,0x01,0xC9,0x36,"GUID_LIDCLOSE_ACTION"); + IF_GUID_EQUAL_RETURN(guid,0x99FF10E7,0x23B1,0x4C07,0xA9,0xD1,0x5C,0x32,0x06,0xD7,0x41,0xB4,"GUID_LIDOPEN_POWERSTATE"); + IF_GUID_EQUAL_RETURN(guid,0xBA3E0F4D,0xB817,0x4094,0xA2,0xD1,0xD5,0x63,0x79,0xE6,0xA0,0xF3,"GUID_LIDSWITCH_STATE_CHANGE"); + IF_GUID_EQUAL_RETURN(guid,0x0E796BDB,0x100D,0x47D6,0xA2,0xD5,0xF7,0xD2,0xDA,0xA5,0x1F,0x51,"GUID_LOCK_CONSOLE_ON_WAKE"); + IF_GUID_EQUAL_RETURN(guid,0xA1841308,0x3541,0x4FAB,0xBC,0x81,0xF7,0x15,0x56,0xF2,0x0B,0x4A,"GUID_MAX_POWER_SAVINGS"); + IF_GUID_EQUAL_RETURN(guid,0x8C5E7FDA,0xE8BF,0x4A96,0x9A,0x85,0xA6,0xE2,0x3A,0x8C,0x63,0x5C,"GUID_MIN_POWER_SAVINGS"); + IF_GUID_EQUAL_RETURN(guid,0x02731015,0x4510,0x4526,0x99,0xE6,0xE5,0xA1,0x7E,0xBD,0x1A,0xEA,"GUID_MONITOR_POWER_ON"); + IF_GUID_EQUAL_RETURN(guid,0xf21f359,0xab84,0x41e8,0x9a,0x78,0x36,0xd1,0x10,0xe6,0xd2,0xf9,"GUID_ManagedName"); + IF_GUID_EQUAL_RETURN(guid,0x0010568c,0x0852,0x4e6a,0xb1,0x91,0x5c,0x33,0xac,0x5b,0x04,0x30,"GUID_MetadataFormat8BIMIPTC"); + IF_GUID_EQUAL_RETURN(guid,0x1CA32285,0x9CCD,0x4786,0x8B,0xD8,0x79,0x53,0x9D,0xB6,0xA0,0x06,"GUID_MetadataFormat8BIMIPTCDigest"); + IF_GUID_EQUAL_RETURN(guid,0x739F305D,0x81DB,0x43CB,0xAC,0x5E,0x55,0x01,0x3E,0xF9,0xF0,0x03,"GUID_MetadataFormat8BIMResolutionInfo"); + IF_GUID_EQUAL_RETURN(guid,0x2E043DC2,0xC967,0x4E05,0x87,0x5E,0x61,0x8B,0xF6,0x7E,0x85,0xC3,"GUID_MetadataFormatAPE"); + IF_GUID_EQUAL_RETURN(guid,0x79007028,0x268D,0x45d6,0xA3,0xC2,0x35,0x4E,0x6A,0x50,0x4B,0xC9,"GUID_MetadataFormatApp0"); + IF_GUID_EQUAL_RETURN(guid,0x326556A2,0xF502,0x4354,0x9C,0xC0,0x8E,0x3F,0x48,0xEA,0xF6,0xB5,"GUID_MetadataFormatApp13"); + IF_GUID_EQUAL_RETURN(guid,0x8FD3DFC3,0xF951,0x492B,0x81,0x7F,0x69,0xC2,0xE6,0xD9,0xA5,0xB0,"GUID_MetadataFormatApp1"); + IF_GUID_EQUAL_RETURN(guid,0xE14D3571,0x6B47,0x4DEA,0xB6,0xA,0x87,0xCE,0xA,0x78,0xDF,0xB7,"GUID_MetadataFormatChunkbKGD"); + IF_GUID_EQUAL_RETURN(guid,0x9DB3655B,0x2842,0x44B3,0x80,0x67,0x12,0xE9,0xB3,0x75,0x55,0x6A,"GUID_MetadataFormatChunkcHRM"); + IF_GUID_EQUAL_RETURN(guid,0xF00935A5,0x1D5D,0x4CD1,0x81,0xB2,0x93,0x24,0xD7,0xEC,0xA7,0x81,"GUID_MetadataFormatChunkgAMA"); + IF_GUID_EQUAL_RETURN(guid,0xC59A82DA,0xDB74,0x48A4,0xBD,0x6A,0xB6,0x9C,0x49,0x31,0xEF,0x95,"GUID_MetadataFormatChunkhIST"); + IF_GUID_EQUAL_RETURN(guid,0xEB4349AB,0xB685,0x450F,0x91,0xB5,0xE8,0x2,0xE8,0x92,0x53,0x6C,"GUID_MetadataFormatChunkiCCP"); + IF_GUID_EQUAL_RETURN(guid,0xC2BEC729,0xB68,0x4B77,0xAA,0xE,0x62,0x95,0xA6,0xAC,0x18,0x14,"GUID_MetadataFormatChunkiTXt"); + IF_GUID_EQUAL_RETURN(guid,0xC115FD36,0xCC6F,0x4E3F,0x83,0x63,0x52,0x4B,0x87,0xC6,0xB0,0xD9,"GUID_MetadataFormatChunksRGB"); + IF_GUID_EQUAL_RETURN(guid,0x568d8936,0xc0a9,0x4923,0x90,0x5d,0xdf,0x2b,0x38,0x23,0x8f,0xbc,"GUID_MetadataFormatChunktEXt"); + IF_GUID_EQUAL_RETURN(guid,0x6B00AE2D,0xE24B,0x460A,0x98,0xB6,0x87,0x8B,0xD0,0x30,0x72,0xFD,"GUID_MetadataFormatChunktIME"); + IF_GUID_EQUAL_RETURN(guid,0x1C3C4F9D,0xB84A,0x467D,0x94,0x93,0x36,0xCF,0xBD,0x59,0xEA,0x57,"GUID_MetadataFormatExif"); + IF_GUID_EQUAL_RETURN(guid,0x2A25CAD8,0xDEEB,0x4C69,0xA7,0x88,0xE,0xC2,0x26,0x6D,0xCA,0xFD,"GUID_MetadataFormatGCE"); + IF_GUID_EQUAL_RETURN(guid,0xC4B6E0E0,0xCFB4,0x4AD3,0xAB,0x33,0x9A,0xAD,0x23,0x55,0xA3,0x4A,"GUID_MetadataFormatGifComment"); + IF_GUID_EQUAL_RETURN(guid,0x7134AB8A,0x9351,0x44AD,0xAF,0x62,0x44,0x8D,0xB6,0xB5,0x02,0xEC,"GUID_MetadataFormatGps"); + IF_GUID_EQUAL_RETURN(guid,0xBD2BB086,0x4D52,0x48DD,0x96,0x77,0xDB,0x48,0x3E,0x85,0xAE,0x8F,"GUID_MetadataFormatIMD"); + IF_GUID_EQUAL_RETURN(guid,0x4FAB0914,0xE129,0x4087,0xA1,0xD1,0xBC,0x81,0x2D,0x45,0xA7,0xB5,"GUID_MetadataFormatIPTC"); + IF_GUID_EQUAL_RETURN(guid,0x16100D66,0x8570,0x4BB9,0xB9,0x2D,0xFD,0xA4,0xB2,0x3E,0xCE,0x67,"GUID_MetadataFormatIRB"); + IF_GUID_EQUAL_RETURN(guid,0x537396C6,0x2D8A,0x4BB6,0x9B,0xF8,0x2F,0x0A,0x8E,0x2A,0x3A,0xDF,"GUID_MetadataFormatIfd"); + IF_GUID_EQUAL_RETURN(guid,0xED686F8E,0x681F,0x4C8B,0xBD,0x41,0xA8,0xAD,0xDB,0xF6,0xB3,0xFC,"GUID_MetadataFormatInterop"); + IF_GUID_EQUAL_RETURN(guid,0xF73D0DCF,0xCEC6,0x4F85,0x9B,0x0E,0x1C,0x39,0x56,0xB1,0xBE,0xF7,"GUID_MetadataFormatJpegChrominance"); + IF_GUID_EQUAL_RETURN(guid,0x220E5F33,0xAFD3,0x474E,0x9D,0x31,0x7D,0x4F,0xE7,0x30,0xF5,0x57,"GUID_MetadataFormatJpegComment"); + IF_GUID_EQUAL_RETURN(guid,0x86908007,0xEDFC,0x4860,0x8D,0x4B,0x4E,0xE6,0xE8,0x3E,0x60,0x58,"GUID_MetadataFormatJpegLuminance"); + IF_GUID_EQUAL_RETURN(guid,0xE256031E,0x6299,0x4929,0xB9,0x8D,0x5A,0xC8,0x84,0xAF,0xBA,0x92,"GUID_MetadataFormatLSD"); + IF_GUID_EQUAL_RETURN(guid,0x58A2E128,0x2DB9,0x4E57,0xBB,0x14,0x51,0x77,0x89,0x1E,0xD3,0x31,"GUID_MetadataFormatSubIfd"); + IF_GUID_EQUAL_RETURN(guid,0x243dcee9,0x8703,0x40ee,0x8e,0xf0,0x22,0xa6,0x0,0xb8,0x5,0x8c,"GUID_MetadataFormatThumbnail"); + IF_GUID_EQUAL_RETURN(guid,0xA45E592F,0x9078,0x4A7C,0xAD,0xB5,0x4E,0xDC,0x4F,0xD6,0x1B,0x1F,"GUID_MetadataFormatUnknown"); + IF_GUID_EQUAL_RETURN(guid,0xBB5ACC38,0xF216,0x4CEC,0xA6,0xC5,0x5F,0x6E,0x73,0x97,0x63,0xA9,"GUID_MetadataFormatXMP"); + IF_GUID_EQUAL_RETURN(guid,0x7B08A675,0x91AA,0x481B,0xA7,0x98,0x4D,0xA9,0x49,0x08,0x61,0x3B,"GUID_MetadataFormatXMPAlt"); + IF_GUID_EQUAL_RETURN(guid,0x833CCA5F,0xDCB7,0x4516,0x80,0x6F,0x65,0x96,0xAB,0x26,0xDC,0xE4,"GUID_MetadataFormatXMPBag"); + IF_GUID_EQUAL_RETURN(guid,0x63E8DF02,0xEB6C,0x456C,0xA2,0x24,0xB2,0x5E,0x79,0x4F,0xD6,0x48,"GUID_MetadataFormatXMPSeq"); + IF_GUID_EQUAL_RETURN(guid,0x22383CF1,0xED17,0x4E2E,0xAF,0x17,0xD8,0x5B,0x8F,0x6B,0x30,0xD0,"GUID_MetadataFormatXMPStruct"); + IF_GUID_EQUAL_RETURN(guid,0x406B2F00,0x3E5A,0x11D1,0xB6,0x40,0x00,0xAA,0x00,0xA1,0xF9,0x6A,"GUID_Miscellaneous2Callbacks"); + IF_GUID_EQUAL_RETURN(guid,0xefd60cc0,0x49e7,0x11d0,0x88,0x9d,0x0,0xaa,0x0,0xbb,0xb7,0x6a,"GUID_MiscellaneousCallbacks"); + IF_GUID_EQUAL_RETURN(guid,0xefd60cc0,0x49e7,0x11d0,0x88,0x9d,0x00,0xaa,0x00,0xbb,0xb7,0x6a,"GUID_MiscellaneousCallbacks"); + IF_GUID_EQUAL_RETURN(guid,0xb1122b40,0x5dA5,0x11d1,0x8f,0xcF,0x00,0xc0,0x4f,0xc2,0x9b,0x4e,"GUID_MotionCompCallbacks"); + IF_GUID_EQUAL_RETURN(guid,0x5adbbfbc,0x74e,0x4da1,0xba,0x38,0xdb,0x8b,0x36,0xb2,0xc8,0xf3,"GUID_NON_ADAPTIVE_INPUT_TIMEOUT"); + IF_GUID_EQUAL_RETURN(guid,0x6fe9ecde,0xdf89,0x11d1,0x9d,0xb0,0x00,0x60,0x08,0x27,0x71,0xba,"GUID_NTCallbacks"); + IF_GUID_EQUAL_RETURN(guid,0xfad16a23,0x7b66,0x11d2,0x83,0xd7,0x0,0xc0,0x4f,0x7c,0xe5,0x8c,"GUID_NTPrivateDriverCaps"); + IF_GUID_EQUAL_RETURN(guid,0x6cb9a43e+(149),0xc45f,0x4039,0x9f,0xe6,0xd0,0x8c,0xb0,0x57,0x18,0x4c,"GUID_NWF_ACTIVE_PHY_LIST"); + IF_GUID_EQUAL_RETURN(guid,0x6cb9a43e+(93),0xc45f,0x4039,0x9f,0xe6,0xd0,0x8c,0xb0,0x57,0x18,0x4c,"GUID_NWF_AP_JOIN_REQUEST"); + IF_GUID_EQUAL_RETURN(guid,0x6cb9a43e+(159),0xc45f,0x4039,0x9f,0xe6,0xd0,0x8c,0xb0,0x57,0x18,0x4c,"GUID_NWF_ASSOCIATION_PARAMS"); + IF_GUID_EQUAL_RETURN(guid,0x6cb9a43e+(10),0xc45f,0x4039,0x9f,0xe6,0xd0,0x8c,0xb0,0x57,0x18,0x4c,"GUID_NWF_ATIM_WINDOW"); + IF_GUID_EQUAL_RETURN(guid,0x6cb9a43e+(120),0xc45f,0x4039,0x9f,0xe6,0xd0,0x8c,0xb0,0x57,0x18,0x4c,"GUID_NWF_AUTO_CONFIG_ENABLED"); + IF_GUID_EQUAL_RETURN(guid,0x6cb9a43e+(27),0xc45f,0x4039,0x9f,0xe6,0xd0,0x8c,0xb0,0x57,0x18,0x4c,"GUID_NWF_BEACON_PERIOD"); + IF_GUID_EQUAL_RETURN(guid,0x6cb9a43e+(54),0xc45f,0x4039,0x9f,0xe6,0xd0,0x8c,0xb0,0x57,0x18,0x4c,"GUID_NWF_CCA_MODE_SUPPORTED"); + IF_GUID_EQUAL_RETURN(guid,0x6cb9a43e+(58),0xc45f,0x4039,0x9f,0xe6,0xd0,0x8c,0xb0,0x57,0x18,0x4c,"GUID_NWF_CCA_WATCHDOG_COUNT_MAX"); + IF_GUID_EQUAL_RETURN(guid,0x6cb9a43e+(60),0xc45f,0x4039,0x9f,0xe6,0xd0,0x8c,0xb0,0x57,0x18,0x4c,"GUID_NWF_CCA_WATCHDOG_COUNT_MIN"); + IF_GUID_EQUAL_RETURN(guid,0x6cb9a43e+(57),0xc45f,0x4039,0x9f,0xe6,0xd0,0x8c,0xb0,0x57,0x18,0x4c,"GUID_NWF_CCA_WATCHDOG_TIMER_MAX"); + IF_GUID_EQUAL_RETURN(guid,0x6cb9a43e+(59),0xc45f,0x4039,0x9f,0xe6,0xd0,0x8c,0xb0,0x57,0x18,0x4c,"GUID_NWF_CCA_WATCHDOG_TIMER_MIN"); + IF_GUID_EQUAL_RETURN(guid,0x6cb9a43e+(24),0xc45f,0x4039,0x9f,0xe6,0xd0,0x8c,0xb0,0x57,0x18,0x4c,"GUID_NWF_CFP_MAX_DURATION"); + IF_GUID_EQUAL_RETURN(guid,0x6cb9a43e+(23),0xc45f,0x4039,0x9f,0xe6,0xd0,0x8c,0xb0,0x57,0x18,0x4c,"GUID_NWF_CFP_PERIOD"); + IF_GUID_EQUAL_RETURN(guid,0x6cb9a43e+(22),0xc45f,0x4039,0x9f,0xe6,0xd0,0x8c,0xb0,0x57,0x18,0x4c,"GUID_NWF_CF_POLLABLE"); + IF_GUID_EQUAL_RETURN(guid,0x6cb9a43e+(72),0xc45f,0x4039,0x9f,0xe6,0xd0,0x8c,0xb0,0x57,0x18,0x4c,"GUID_NWF_CHANNEL_AGILITY_ENABLED"); + IF_GUID_EQUAL_RETURN(guid,0x6cb9a43e+(71),0xc45f,0x4039,0x9f,0xe6,0xd0,0x8c,0xb0,0x57,0x18,0x4c,"GUID_NWF_CHANNEL_AGILITY_PRESENT"); + IF_GUID_EQUAL_RETURN(guid,0x6cb9a43e+(139),0xc45f,0x4039,0x9f,0xe6,0xd0,0x8c,0xb0,0x57,0x18,0x4c,"GUID_NWF_CIPHER_DEFAULT_KEY"); + IF_GUID_EQUAL_RETURN(guid,0x6cb9a43e+(138),0xc45f,0x4039,0x9f,0xe6,0xd0,0x8c,0xb0,0x57,0x18,0x4c,"GUID_NWF_CIPHER_DEFAULT_KEY_ID"); + IF_GUID_EQUAL_RETURN(guid,0x6cb9a43e+(140),0xc45f,0x4039,0x9f,0xe6,0xd0,0x8c,0xb0,0x57,0x18,0x4c,"GUID_NWF_CIPHER_KEY_MAPPING_KEY"); + IF_GUID_EQUAL_RETURN(guid,0x6cb9a43e+(129),0xc45f,0x4039,0x9f,0xe6,0xd0,0x8c,0xb0,0x57,0x18,0x4c,"GUID_NWF_CONNECT_REQUEST"); + IF_GUID_EQUAL_RETURN(guid,0x6cb9a43e+(37),0xc45f,0x4039,0x9f,0xe6,0xd0,0x8c,0xb0,0x57,0x18,0x4c,"GUID_NWF_COUNTERS_ENTRY"); + IF_GUID_EQUAL_RETURN(guid,0x6cb9a43e+(76),0xc45f,0x4039,0x9f,0xe6,0xd0,0x8c,0xb0,0x57,0x18,0x4c,"GUID_NWF_COUNTRY_STRING"); + IF_GUID_EQUAL_RETURN(guid,0x6cb9a43e+(1024+2),0xc45f,0x4039,0x9f,0xe6,0xd0,0x8c,0xb0,0x57,0x18,0x4c,"GUID_NWF_CURRENT_ADDRESS"); + IF_GUID_EQUAL_RETURN(guid,0x6cb9a43e+(55),0xc45f,0x4039,0x9f,0xe6,0xd0,0x8c,0xb0,0x57,0x18,0x4c,"GUID_NWF_CURRENT_CCA_MODE"); + IF_GUID_EQUAL_RETURN(guid,0x6cb9a43e+(53),0xc45f,0x4039,0x9f,0xe6,0xd0,0x8c,0xb0,0x57,0x18,0x4c,"GUID_NWF_CURRENT_CHANNEL"); + IF_GUID_EQUAL_RETURN(guid,0x6cb9a43e+(47),0xc45f,0x4039,0x9f,0xe6,0xd0,0x8c,0xb0,0x57,0x18,0x4c,"GUID_NWF_CURRENT_CHANNEL_NUMBER"); + IF_GUID_EQUAL_RETURN(guid,0x6cb9a43e+(49),0xc45f,0x4039,0x9f,0xe6,0xd0,0x8c,0xb0,0x57,0x18,0x4c,"GUID_NWF_CURRENT_DWELL_TIME"); + IF_GUID_EQUAL_RETURN(guid,0x6cb9a43e+(66),0xc45f,0x4039,0x9f,0xe6,0xd0,0x8c,0xb0,0x57,0x18,0x4c,"GUID_NWF_CURRENT_FREQUENCY"); + IF_GUID_EQUAL_RETURN(guid,0x6cb9a43e+(52),0xc45f,0x4039,0x9f,0xe6,0xd0,0x8c,0xb0,0x57,0x18,0x4c,"GUID_NWF_CURRENT_INDEX"); + IF_GUID_EQUAL_RETURN(guid,0x6cb9a43e+(1),0xc45f,0x4039,0x9f,0xe6,0xd0,0x8c,0xb0,0x57,0x18,0x4c,"GUID_NWF_CURRENT_OFFLOAD_CAPABILITY"); + IF_GUID_EQUAL_RETURN(guid,0x6cb9a43e+(8),0xc45f,0x4039,0x9f,0xe6,0xd0,0x8c,0xb0,0x57,0x18,0x4c,"GUID_NWF_CURRENT_OPERATION_MODE"); + IF_GUID_EQUAL_RETURN(guid,0x6cb9a43e+(19),0xc45f,0x4039,0x9f,0xe6,0xd0,0x8c,0xb0,0x57,0x18,0x4c,"GUID_NWF_CURRENT_OPTIONAL_CAPABILITY"); + IF_GUID_EQUAL_RETURN(guid,0x6cb9a43e+(9),0xc45f,0x4039,0x9f,0xe6,0xd0,0x8c,0xb0,0x57,0x18,0x4c,"GUID_NWF_CURRENT_PACKET_FILTER"); + IF_GUID_EQUAL_RETURN(guid,0x6cb9a43e+(51),0xc45f,0x4039,0x9f,0xe6,0xd0,0x8c,0xb0,0x57,0x18,0x4c,"GUID_NWF_CURRENT_PATTERN"); + IF_GUID_EQUAL_RETURN(guid,0x6cb9a43e+(146),0xc45f,0x4039,0x9f,0xe6,0xd0,0x8c,0xb0,0x57,0x18,0x4c,"GUID_NWF_CURRENT_PHY_ID"); + IF_GUID_EQUAL_RETURN(guid,0x6cb9a43e+(12),0xc45f,0x4039,0x9f,0xe6,0xd0,0x8c,0xb0,0x57,0x18,0x4c,"GUID_NWF_CURRENT_PHY_TYPE"); + IF_GUID_EQUAL_RETURN(guid,0x6cb9a43e+(39),0xc45f,0x4039,0x9f,0xe6,0xd0,0x8c,0xb0,0x57,0x18,0x4c,"GUID_NWF_CURRENT_REG_DOMAIN"); + IF_GUID_EQUAL_RETURN(guid,0x6cb9a43e+(43),0xc45f,0x4039,0x9f,0xe6,0xd0,0x8c,0xb0,0x57,0x18,0x4c,"GUID_NWF_CURRENT_RX_ANTENNA"); + IF_GUID_EQUAL_RETURN(guid,0x6cb9a43e+(50),0xc45f,0x4039,0x9f,0xe6,0xd0,0x8c,0xb0,0x57,0x18,0x4c,"GUID_NWF_CURRENT_SET"); + IF_GUID_EQUAL_RETURN(guid,0x6cb9a43e+(41),0xc45f,0x4039,0x9f,0xe6,0xd0,0x8c,0xb0,0x57,0x18,0x4c,"GUID_NWF_CURRENT_TX_ANTENNA"); + IF_GUID_EQUAL_RETURN(guid,0x6cb9a43e+(45),0xc45f,0x4039,0x9f,0xe6,0xd0,0x8c,0xb0,0x57,0x18,0x4c,"GUID_NWF_CURRENT_TX_POWER_LEVEL"); + IF_GUID_EQUAL_RETURN(guid,0x6cb9a43e+(151),0xc45f,0x4039,0x9f,0xe6,0xd0,0x8c,0xb0,0x57,0x18,0x4c,"GUID_NWF_DATA_RATE_MAPPING_TABLE"); + IF_GUID_EQUAL_RETURN(guid,0x6cb9a43e+(4),0xc45f,0x4039,0x9f,0xe6,0xd0,0x8c,0xb0,0x57,0x18,0x4c,"GUID_NWF_DEFAULT_WEP_OFFLOAD"); + IF_GUID_EQUAL_RETURN(guid,0x6cb9a43e+(5),0xc45f,0x4039,0x9f,0xe6,0xd0,0x8c,0xb0,0x57,0x18,0x4c,"GUID_NWF_DEFAULT_WEP_UPLOAD"); + IF_GUID_EQUAL_RETURN(guid,0x6cb9a43e+(126),0xc45f,0x4039,0x9f,0xe6,0xd0,0x8c,0xb0,0x57,0x18,0x4c,"GUID_NWF_DESIRED_BSSID_LIST"); + IF_GUID_EQUAL_RETURN(guid,0x6cb9a43e+(127),0xc45f,0x4039,0x9f,0xe6,0xd0,0x8c,0xb0,0x57,0x18,0x4c,"GUID_NWF_DESIRED_BSS_TYPE"); + IF_GUID_EQUAL_RETURN(guid,0x6cb9a43e+(153),0xc45f,0x4039,0x9f,0xe6,0xd0,0x8c,0xb0,0x57,0x18,0x4c,"GUID_NWF_DESIRED_COUNTRY_OR_REGION_STRING"); + IF_GUID_EQUAL_RETURN(guid,0x6cb9a43e+(145),0xc45f,0x4039,0x9f,0xe6,0xd0,0x8c,0xb0,0x57,0x18,0x4c,"GUID_NWF_DESIRED_PHY_LIST"); + IF_GUID_EQUAL_RETURN(guid,0x6cb9a43e+(124),0xc45f,0x4039,0x9f,0xe6,0xd0,0x8c,0xb0,0x57,0x18,0x4c,"GUID_NWF_DESIRED_SSID_LIST"); + IF_GUID_EQUAL_RETURN(guid,0x6cb9a43e+(142),0xc45f,0x4039,0x9f,0xe6,0xd0,0x8c,0xb0,0x57,0x18,0x4c,"GUID_NWF_DISCONNECT_REQUEST"); + IF_GUID_EQUAL_RETURN(guid,0x6cb9a43e+(64),0xc45f,0x4039,0x9f,0xe6,0xd0,0x8c,0xb0,0x57,0x18,0x4c,"GUID_NWF_DIVERSITY_SELECTION_RX"); + IF_GUID_EQUAL_RETURN(guid,0x6cb9a43e+(42),0xc45f,0x4039,0x9f,0xe6,0xd0,0x8c,0xb0,0x57,0x18,0x4c,"GUID_NWF_DIVERSITY_SUPPORT"); + IF_GUID_EQUAL_RETURN(guid,0x6cb9a43e+(97),0xc45f,0x4039,0x9f,0xe6,0xd0,0x8c,0xb0,0x57,0x18,0x4c,"GUID_NWF_DSSS_OFDM_OPTION_ENABLED"); + IF_GUID_EQUAL_RETURN(guid,0x6cb9a43e+(96),0xc45f,0x4039,0x9f,0xe6,0xd0,0x8c,0xb0,0x57,0x18,0x4c,"GUID_NWF_DSSS_OFDM_OPTION_IMPLEMENTED"); + IF_GUID_EQUAL_RETURN(guid,0x6cb9a43e+(28),0xc45f,0x4039,0x9f,0xe6,0xd0,0x8c,0xb0,0x57,0x18,0x4c,"GUID_NWF_DTIM_PERIOD"); + IF_GUID_EQUAL_RETURN(guid,0x6cb9a43e+(56),0xc45f,0x4039,0x9f,0xe6,0xd0,0x8c,0xb0,0x57,0x18,0x4c,"GUID_NWF_ED_THRESHOLD"); + IF_GUID_EQUAL_RETURN(guid,0x6cb9a43e+(81),0xc45f,0x4039,0x9f,0xe6,0xd0,0x8c,0xb0,0x57,0x18,0x4c,"GUID_NWF_EHCC_CAPABILITY_ENABLED"); + IF_GUID_EQUAL_RETURN(guid,0x6cb9a43e+(80),0xc45f,0x4039,0x9f,0xe6,0xd0,0x8c,0xb0,0x57,0x18,0x4c,"GUID_NWF_EHCC_CAPABILITY_IMPLEMENTED"); + IF_GUID_EQUAL_RETURN(guid,0x6cb9a43e+(79),0xc45f,0x4039,0x9f,0xe6,0xd0,0x8c,0xb0,0x57,0x18,0x4c,"GUID_NWF_EHCC_NUMBER_OF_CHANNELS_FAMILY_INDEX"); + IF_GUID_EQUAL_RETURN(guid,0x6cb9a43e+(78),0xc45f,0x4039,0x9f,0xe6,0xd0,0x8c,0xb0,0x57,0x18,0x4c,"GUID_NWF_EHCC_PRIME_RADIX"); + IF_GUID_EQUAL_RETURN(guid,0x6cb9a43e+(133),0xc45f,0x4039,0x9f,0xe6,0xd0,0x8c,0xb0,0x57,0x18,0x4c,"GUID_NWF_ENABLED_AUTHENTICATION_ALGORITHM"); + IF_GUID_EQUAL_RETURN(guid,0x6cb9a43e+(137),0xc45f,0x4039,0x9f,0xe6,0xd0,0x8c,0xb0,0x57,0x18,0x4c,"GUID_NWF_ENABLED_MULTICAST_CIPHER_ALGORITHM"); + IF_GUID_EQUAL_RETURN(guid,0x6cb9a43e+(135),0xc45f,0x4039,0x9f,0xe6,0xd0,0x8c,0xb0,0x57,0x18,0x4c,"GUID_NWF_ENABLED_UNICAST_CIPHER_ALGORITHM"); + IF_GUID_EQUAL_RETURN(guid,0x6cb9a43e+(141),0xc45f,0x4039,0x9f,0xe6,0xd0,0x8c,0xb0,0x57,0x18,0x4c,"GUID_NWF_ENUM_ASSOCIATION_INFO"); + IF_GUID_EQUAL_RETURN(guid,0x6cb9a43e+(121),0xc45f,0x4039,0x9f,0xe6,0xd0,0x8c,0xb0,0x57,0x18,0x4c,"GUID_NWF_ENUM_BSS_LIST"); + IF_GUID_EQUAL_RETURN(guid,0x6cb9a43e+(95),0xc45f,0x4039,0x9f,0xe6,0xd0,0x8c,0xb0,0x57,0x18,0x4c,"GUID_NWF_ERP_PBCC_OPTION_ENABLED"); + IF_GUID_EQUAL_RETURN(guid,0x6cb9a43e+(94),0xc45f,0x4039,0x9f,0xe6,0xd0,0x8c,0xb0,0x57,0x18,0x4c,"GUID_NWF_ERP_PBCC_OPTION_IMPLEMENTED"); + IF_GUID_EQUAL_RETURN(guid,0x6cb9a43e+(125),0xc45f,0x4039,0x9f,0xe6,0xd0,0x8c,0xb0,0x57,0x18,0x4c,"GUID_NWF_EXCLUDED_MAC_ADDRESS_LIST"); + IF_GUID_EQUAL_RETURN(guid,0x6cb9a43e+(130),0xc45f,0x4039,0x9f,0xe6,0xd0,0x8c,0xb0,0x57,0x18,0x4c,"GUID_NWF_EXCLUDE_UNENCRYPTED"); + IF_GUID_EQUAL_RETURN(guid,0x6cb9a43e+(150),0xc45f,0x4039,0x9f,0xe6,0xd0,0x8c,0xb0,0x57,0x18,0x4c,"GUID_NWF_EXTSTA_CAPABILITY"); + IF_GUID_EQUAL_RETURN(guid,0x6cb9a43e+(122),0xc45f,0x4039,0x9f,0xe6,0xd0,0x8c,0xb0,0x57,0x18,0x4c,"GUID_NWF_FLUSH_BSS_LIST"); + IF_GUID_EQUAL_RETURN(guid,0x6cb9a43e+(34),0xc45f,0x4039,0x9f,0xe6,0xd0,0x8c,0xb0,0x57,0x18,0x4c,"GUID_NWF_FRAGMENTATION_THRESHOLD"); + IF_GUID_EQUAL_RETURN(guid,0x6cb9a43e+(68),0xc45f,0x4039,0x9f,0xe6,0xd0,0x8c,0xb0,0x57,0x18,0x4c,"GUID_NWF_FREQUENCY_BANDS_SUPPORTED"); + IF_GUID_EQUAL_RETURN(guid,0x6cb9a43e+(158),0xc45f,0x4039,0x9f,0xe6,0xd0,0x8c,0xb0,0x57,0x18,0x4c,"GUID_NWF_HIDDEN_NETWORK_ENABLED"); + IF_GUID_EQUAL_RETURN(guid,0x6cb9a43e+(87),0xc45f,0x4039,0x9f,0xe6,0xd0,0x8c,0xb0,0x57,0x18,0x4c,"GUID_NWF_HOPPING_PATTERN"); + IF_GUID_EQUAL_RETURN(guid,0x6cb9a43e+(82),0xc45f,0x4039,0x9f,0xe6,0xd0,0x8c,0xb0,0x57,0x18,0x4c,"GUID_NWF_HOP_ALGORITHM_ADOPTED"); + IF_GUID_EQUAL_RETURN(guid,0x6cb9a43e+(85),0xc45f,0x4039,0x9f,0xe6,0xd0,0x8c,0xb0,0x57,0x18,0x4c,"GUID_NWF_HOP_MODULUS"); + IF_GUID_EQUAL_RETURN(guid,0x6cb9a43e+(86),0xc45f,0x4039,0x9f,0xe6,0xd0,0x8c,0xb0,0x57,0x18,0x4c,"GUID_NWF_HOP_OFFSET"); + IF_GUID_EQUAL_RETURN(guid,0x6cb9a43e+(46),0xc45f,0x4039,0x9f,0xe6,0xd0,0x8c,0xb0,0x57,0x18,0x4c,"GUID_NWF_HOP_TIME"); + IF_GUID_EQUAL_RETURN(guid,0x6cb9a43e+(73),0xc45f,0x4039,0x9f,0xe6,0xd0,0x8c,0xb0,0x57,0x18,0x4c,"GUID_NWF_HR_CCA_MODE_SUPPORTED"); + IF_GUID_EQUAL_RETURN(guid,0x6cb9a43e+(155),0xc45f,0x4039,0x9f,0xe6,0xd0,0x8c,0xb0,0x57,0x18,0x4c,"GUID_NWF_IBSS_PARAMS"); + IF_GUID_EQUAL_RETURN(guid,0x6cb9a43e+(13),0xc45f,0x4039,0x9f,0xe6,0xd0,0x8c,0xb0,0x57,0x18,0x4c,"GUID_NWF_JOIN_REQUEST"); + IF_GUID_EQUAL_RETURN(guid,0x6cb9a43e+(33),0xc45f,0x4039,0x9f,0xe6,0xd0,0x8c,0xb0,0x57,0x18,0x4c,"GUID_NWF_LONG_RETRY_LIMIT"); + IF_GUID_EQUAL_RETURN(guid,0x6cb9a43e+(30),0xc45f,0x4039,0x9f,0xe6,0xd0,0x8c,0xb0,0x57,0x18,0x4c,"GUID_NWF_MAC_ADDRESS"); + IF_GUID_EQUAL_RETURN(guid,0x6cb9a43e+(1024+5),0xc45f,0x4039,0x9f,0xe6,0xd0,0x8c,0xb0,0x57,0x18,0x4c,"GUID_NWF_MAXIMUM_LIST_SIZE"); + IF_GUID_EQUAL_RETURN(guid,0x6cb9a43e+(48),0xc45f,0x4039,0x9f,0xe6,0xd0,0x8c,0xb0,0x57,0x18,0x4c,"GUID_NWF_MAX_DWELL_TIME"); + IF_GUID_EQUAL_RETURN(guid,0x6cb9a43e+(100),0xc45f,0x4039,0x9f,0xe6,0xd0,0x8c,0xb0,0x57,0x18,0x4c,"GUID_NWF_MAX_MAC_ADDRESS_STATES"); + IF_GUID_EQUAL_RETURN(guid,0x6cb9a43e+(36),0xc45f,0x4039,0x9f,0xe6,0xd0,0x8c,0xb0,0x57,0x18,0x4c,"GUID_NWF_MAX_RECEIVE_LIFETIME"); + IF_GUID_EQUAL_RETURN(guid,0x6cb9a43e+(35),0xc45f,0x4039,0x9f,0xe6,0xd0,0x8c,0xb0,0x57,0x18,0x4c,"GUID_NWF_MAX_TRANSMIT_MSDU_LIFETIME"); + IF_GUID_EQUAL_RETURN(guid,0x6cb9a43e+(147),0xc45f,0x4039,0x9f,0xe6,0xd0,0x8c,0xb0,0x57,0x18,0x4c,"GUID_NWF_MEDIA_STREAMING_ENABLED"); + IF_GUID_EQUAL_RETURN(guid,0x6cb9a43e+(21),0xc45f,0x4039,0x9f,0xe6,0xd0,0x8c,0xb0,0x57,0x18,0x4c,"GUID_NWF_MEDIUM_OCCUPANCY_LIMIT"); + IF_GUID_EQUAL_RETURN(guid,0x6cb9a43e+(6),0xc45f,0x4039,0x9f,0xe6,0xd0,0x8c,0xb0,0x57,0x18,0x4c,"GUID_NWF_MPDU_MAX_LENGTH"); + IF_GUID_EQUAL_RETURN(guid,0x6cb9a43e+(1024+4),0xc45f,0x4039,0x9f,0xe6,0xd0,0x8c,0xb0,0x57,0x18,0x4c,"GUID_NWF_MULTICAST_LIST"); + IF_GUID_EQUAL_RETURN(guid,0x6cb9a43e+(77),0xc45f,0x4039,0x9f,0xe6,0xd0,0x8c,0xb0,0x57,0x18,0x4c,"GUID_NWF_MULTI_DOMAIN_CAPABILITY"); + IF_GUID_EQUAL_RETURN(guid,0x6cb9a43e+(75),0xc45f,0x4039,0x9f,0xe6,0xd0,0x8c,0xb0,0x57,0x18,0x4c,"GUID_NWF_MULTI_DOMAIN_CAPABILITY_ENABLED"); + IF_GUID_EQUAL_RETURN(guid,0x6cb9a43e+(74),0xc45f,0x4039,0x9f,0xe6,0xd0,0x8c,0xb0,0x57,0x18,0x4c,"GUID_NWF_MULTI_DOMAIN_CAPABILITY_IMPLEMENTED"); + IF_GUID_EQUAL_RETURN(guid,0x6cb9a43e+(17),0xc45f,0x4039,0x9f,0xe6,0xd0,0x8c,0xb0,0x57,0x18,0x4c,"GUID_NWF_NIC_POWER_STATE"); + IF_GUID_EQUAL_RETURN(guid,0x6cb9a43e+(92),0xc45f,0x4039,0x9f,0xe6,0xd0,0x8c,0xb0,0x57,0x18,0x4c,"GUID_NWF_NIC_SPECIFIC_EXTENSION"); + IF_GUID_EQUAL_RETURN(guid,0x6cb9a43e+(84),0xc45f,0x4039,0x9f,0xe6,0xd0,0x8c,0xb0,0x57,0x18,0x4c,"GUID_NWF_NUMBER_OF_HOPPING_SETS"); + IF_GUID_EQUAL_RETURN(guid,0x6cb9a43e+(0),0xc45f,0x4039,0x9f,0xe6,0xd0,0x8c,0xb0,0x57,0x18,0x4c,"GUID_NWF_OFFLOAD_CAPABILITY"); + IF_GUID_EQUAL_RETURN(guid,0x6cb9a43e+(26),0xc45f,0x4039,0x9f,0xe6,0xd0,0x8c,0xb0,0x57,0x18,0x4c,"GUID_NWF_OPERATIONAL_RATE_SET"); + IF_GUID_EQUAL_RETURN(guid,0x6cb9a43e+(7),0xc45f,0x4039,0x9f,0xe6,0xd0,0x8c,0xb0,0x57,0x18,0x4c,"GUID_NWF_OPERATION_MODE_CAPABILITY"); + IF_GUID_EQUAL_RETURN(guid,0x6cb9a43e+(18),0xc45f,0x4039,0x9f,0xe6,0xd0,0x8c,0xb0,0x57,0x18,0x4c,"GUID_NWF_OPTIONAL_CAPABILITY"); + IF_GUID_EQUAL_RETURN(guid,0x6cb9a43e+(70),0xc45f,0x4039,0x9f,0xe6,0xd0,0x8c,0xb0,0x57,0x18,0x4c,"GUID_NWF_PBCC_OPTION_IMPLEMENTED"); + IF_GUID_EQUAL_RETURN(guid,0x6cb9a43e+(1024+3),0xc45f,0x4039,0x9f,0xe6,0xd0,0x8c,0xb0,0x57,0x18,0x4c,"GUID_NWF_PERMANENT_ADDRESS"); + IF_GUID_EQUAL_RETURN(guid,0x6cb9a43e+(144),0xc45f,0x4039,0x9f,0xe6,0xd0,0x8c,0xb0,0x57,0x18,0x4c,"GUID_NWF_PHY_STATE"); + IF_GUID_EQUAL_RETURN(guid,0x6cb9a43e+(128),0xc45f,0x4039,0x9f,0xe6,0xd0,0x8c,0xb0,0x57,0x18,0x4c,"GUID_NWF_PMKID_LIST"); + IF_GUID_EQUAL_RETURN(guid,0x6cb9a43e+(154),0xc45f,0x4039,0x9f,0xe6,0xd0,0x8c,0xb0,0x57,0x18,0x4c,"GUID_NWF_PORT_STATE_NOTIFICATION"); + IF_GUID_EQUAL_RETURN(guid,0x6cb9a43e+(25),0xc45f,0x4039,0x9f,0xe6,0xd0,0x8c,0xb0,0x57,0x18,0x4c,"GUID_NWF_POWER_MGMT_MODE"); + IF_GUID_EQUAL_RETURN(guid,0x6cb9a43e+(123),0xc45f,0x4039,0x9f,0xe6,0xd0,0x8c,0xb0,0x57,0x18,0x4c,"GUID_NWF_POWER_MGMT_REQUEST"); + IF_GUID_EQUAL_RETURN(guid,0x6cb9a43e+(132),0xc45f,0x4039,0x9f,0xe6,0xd0,0x8c,0xb0,0x57,0x18,0x4c,"GUID_NWF_PRIVACY_EXEMPTION_LIST"); + IF_GUID_EQUAL_RETURN(guid,0x6cb9a43e+(156),0xc45f,0x4039,0x9f,0xe6,0xd0,0x8c,0xb0,0x57,0x18,0x4c,"GUID_NWF_QOS_PARAMS"); + IF_GUID_EQUAL_RETURN(guid,0x6cb9a43e+(107),0xc45f,0x4039,0x9f,0xe6,0xd0,0x8c,0xb0,0x57,0x18,0x4c,"GUID_NWF_QOS_TX_DURATION"); + IF_GUID_EQUAL_RETURN(guid,0x6cb9a43e+(108),0xc45f,0x4039,0x9f,0xe6,0xd0,0x8c,0xb0,0x57,0x18,0x4c,"GUID_NWF_QOS_TX_MEDIUM_TIME"); + IF_GUID_EQUAL_RETURN(guid,0x6cb9a43e+(106),0xc45f,0x4039,0x9f,0xe6,0xd0,0x8c,0xb0,0x57,0x18,0x4c,"GUID_NWF_QOS_TX_QUEUES_SUPPORTED"); + IF_GUID_EQUAL_RETURN(guid,0x6cb9a43e+(88),0xc45f,0x4039,0x9f,0xe6,0xd0,0x8c,0xb0,0x57,0x18,0x4c,"GUID_NWF_RANDOM_TABLE_FIELD_NUMBER"); + IF_GUID_EQUAL_RETURN(guid,0x6cb9a43e+(83),0xc45f,0x4039,0x9f,0xe6,0xd0,0x8c,0xb0,0x57,0x18,0x4c,"GUID_NWF_RANDOM_TABLE_FLAG"); + IF_GUID_EQUAL_RETURN(guid,0x6cb9a43e+(101),0xc45f,0x4039,0x9f,0xe6,0xd0,0x8c,0xb0,0x57,0x18,0x4c,"GUID_NWF_RECV_SENSITIVITY_LIST"); + IF_GUID_EQUAL_RETURN(guid,0x6cb9a43e+(61),0xc45f,0x4039,0x9f,0xe6,0xd0,0x8c,0xb0,0x57,0x18,0x4c,"GUID_NWF_REG_DOMAINS_SUPPORT_VALUE"); + IF_GUID_EQUAL_RETURN(guid,0x6cb9a43e+(16),0xc45f,0x4039,0x9f,0xe6,0xd0,0x8c,0xb0,0x57,0x18,0x4c,"GUID_NWF_RESET_REQUEST"); + IF_GUID_EQUAL_RETURN(guid,0x6cb9a43e+(91),0xc45f,0x4039,0x9f,0xe6,0xd0,0x8c,0xb0,0x57,0x18,0x4c,"GUID_NWF_RF_USAGE"); + IF_GUID_EQUAL_RETURN(guid,0x6cb9a43e+(90),0xc45f,0x4039,0x9f,0xe6,0xd0,0x8c,0xb0,0x57,0x18,0x4c,"GUID_NWF_RSSI_RANGE"); + IF_GUID_EQUAL_RETURN(guid,0x6cb9a43e+(31),0xc45f,0x4039,0x9f,0xe6,0xd0,0x8c,0xb0,0x57,0x18,0x4c,"GUID_NWF_RTS_THRESHOLD"); + IF_GUID_EQUAL_RETURN(guid,0x6cb9a43e+(157),0xc45f,0x4039,0x9f,0xe6,0xd0,0x8c,0xb0,0x57,0x18,0x4c,"GUID_NWF_SAFE_MODE_ENABLED"); + IF_GUID_EQUAL_RETURN(guid,0x6cb9a43e+(11),0xc45f,0x4039,0x9f,0xe6,0xd0,0x8c,0xb0,0x57,0x18,0x4c,"GUID_NWF_SCAN_REQUEST"); + IF_GUID_EQUAL_RETURN(guid,0x6cb9a43e+(69),0xc45f,0x4039,0x9f,0xe6,0xd0,0x8c,0xb0,0x57,0x18,0x4c,"GUID_NWF_SHORT_PREAMBLE_OPTION_IMPLEMENTED"); + IF_GUID_EQUAL_RETURN(guid,0x6cb9a43e+(32),0xc45f,0x4039,0x9f,0xe6,0xd0,0x8c,0xb0,0x57,0x18,0x4c,"GUID_NWF_SHORT_RETRY_LIMIT"); + IF_GUID_EQUAL_RETURN(guid,0x6cb9a43e+(99),0xc45f,0x4039,0x9f,0xe6,0xd0,0x8c,0xb0,0x57,0x18,0x4c,"GUID_NWF_SHORT_SLOT_TIME_OPTION_ENABLED"); + IF_GUID_EQUAL_RETURN(guid,0x6cb9a43e+(98),0xc45f,0x4039,0x9f,0xe6,0xd0,0x8c,0xb0,0x57,0x18,0x4c,"GUID_NWF_SHORT_SLOT_TIME_OPTION_IMPLEMENTED"); + IF_GUID_EQUAL_RETURN(guid,0x6cb9a43e+(14),0xc45f,0x4039,0x9f,0xe6,0xd0,0x8c,0xb0,0x57,0x18,0x4c,"GUID_NWF_START_REQUEST"); + IF_GUID_EQUAL_RETURN(guid,0x6cb9a43e+(20),0xc45f,0x4039,0x9f,0xe6,0xd0,0x8c,0xb0,0x57,0x18,0x4c,"GUID_NWF_STATION_ID"); + IF_GUID_EQUAL_RETURN(guid,0x6cb9a43e+(131),0xc45f,0x4039,0x9f,0xe6,0xd0,0x8c,0xb0,0x57,0x18,0x4c,"GUID_NWF_STATISTICS"); + IF_GUID_EQUAL_RETURN(guid,0x6cb9a43e+(152),0xc45f,0x4039,0x9f,0xe6,0xd0,0x8c,0xb0,0x57,0x18,0x4c,"GUID_NWF_SUPPORTED_COUNTRY_OR_REGION_STRING"); + IF_GUID_EQUAL_RETURN(guid,0x6cb9a43e+(65),0xc45f,0x4039,0x9f,0xe6,0xd0,0x8c,0xb0,0x57,0x18,0x4c,"GUID_NWF_SUPPORTED_DATA_RATES_VALUE"); + IF_GUID_EQUAL_RETURN(guid,0x6cb9a43e+(110),0xc45f,0x4039,0x9f,0xe6,0xd0,0x8c,0xb0,0x57,0x18,0x4c,"GUID_NWF_SUPPORTED_DSSS_CHANNEL_LIST"); + IF_GUID_EQUAL_RETURN(guid,0x6cb9a43e+(136),0xc45f,0x4039,0x9f,0xe6,0xd0,0x8c,0xb0,0x57,0x18,0x4c,"GUID_NWF_SUPPORTED_MULTICAST_ALGORITHM_PAIR"); + IF_GUID_EQUAL_RETURN(guid,0x6cb9a43e+(109),0xc45f,0x4039,0x9f,0xe6,0xd0,0x8c,0xb0,0x57,0x18,0x4c,"GUID_NWF_SUPPORTED_OFDM_FREQUENCY_LIST"); + IF_GUID_EQUAL_RETURN(guid,0x6cb9a43e+(38),0xc45f,0x4039,0x9f,0xe6,0xd0,0x8c,0xb0,0x57,0x18,0x4c,"GUID_NWF_SUPPORTED_PHY_TYPES"); + IF_GUID_EQUAL_RETURN(guid,0x6cb9a43e+(44),0xc45f,0x4039,0x9f,0xe6,0xd0,0x8c,0xb0,0x57,0x18,0x4c,"GUID_NWF_SUPPORTED_POWER_LEVELS"); + IF_GUID_EQUAL_RETURN(guid,0x6cb9a43e+(63),0xc45f,0x4039,0x9f,0xe6,0xd0,0x8c,0xb0,0x57,0x18,0x4c,"GUID_NWF_SUPPORTED_RX_ANTENNA"); + IF_GUID_EQUAL_RETURN(guid,0x6cb9a43e+(62),0xc45f,0x4039,0x9f,0xe6,0xd0,0x8c,0xb0,0x57,0x18,0x4c,"GUID_NWF_SUPPORTED_TX_ANTENNA"); + IF_GUID_EQUAL_RETURN(guid,0x6cb9a43e+(134),0xc45f,0x4039,0x9f,0xe6,0xd0,0x8c,0xb0,0x57,0x18,0x4c,"GUID_NWF_SUPPORTED_UNICAST_ALGORITHM_PAIR"); + IF_GUID_EQUAL_RETURN(guid,0x6cb9a43e+(40),0xc45f,0x4039,0x9f,0xe6,0xd0,0x8c,0xb0,0x57,0x18,0x4c,"GUID_NWF_TEMP_TYPE"); + IF_GUID_EQUAL_RETURN(guid,0x6cb9a43e+(67),0xc45f,0x4039,0x9f,0xe6,0xd0,0x8c,0xb0,0x57,0x18,0x4c,"GUID_NWF_TI_THRESHOLD"); + IF_GUID_EQUAL_RETURN(guid,0x6cb9a43e+(143),0xc45f,0x4039,0x9f,0xe6,0xd0,0x8c,0xb0,0x57,0x18,0x4c,"GUID_NWF_UNICAST_USE_GROUP_ENABLED"); + IF_GUID_EQUAL_RETURN(guid,0x6cb9a43e+(148),0xc45f,0x4039,0x9f,0xe6,0xd0,0x8c,0xb0,0x57,0x18,0x4c,"GUID_NWF_UNREACHABLE_DETECTION_THRESHOLD"); + IF_GUID_EQUAL_RETURN(guid,0x6cb9a43e+(15),0xc45f,0x4039,0x9f,0xe6,0xd0,0x8c,0xb0,0x57,0x18,0x4c,"GUID_NWF_UPDATE_IE"); + IF_GUID_EQUAL_RETURN(guid,0x6cb9a43e+(29),0xc45f,0x4039,0x9f,0xe6,0xd0,0x8c,0xb0,0x57,0x18,0x4c,"GUID_NWF_WEP_ICV_ERROR_COUNT"); + IF_GUID_EQUAL_RETURN(guid,0x6cb9a43e+(2),0xc45f,0x4039,0x9f,0xe6,0xd0,0x8c,0xb0,0x57,0x18,0x4c,"GUID_NWF_WEP_OFFLOAD"); + IF_GUID_EQUAL_RETURN(guid,0x6cb9a43e+(3),0xc45f,0x4039,0x9f,0xe6,0xd0,0x8c,0xb0,0x57,0x18,0x4c,"GUID_NWF_WEP_UPLOAD"); + IF_GUID_EQUAL_RETURN(guid,0x6cb9a43e+(104),0xc45f,0x4039,0x9f,0xe6,0xd0,0x8c,0xb0,0x57,0x18,0x4c,"GUID_NWF_WME_AC_PARAMETERS"); + IF_GUID_EQUAL_RETURN(guid,0x6cb9a43e+(103),0xc45f,0x4039,0x9f,0xe6,0xd0,0x8c,0xb0,0x57,0x18,0x4c,"GUID_NWF_WME_ENABLED"); + IF_GUID_EQUAL_RETURN(guid,0x6cb9a43e+(102),0xc45f,0x4039,0x9f,0xe6,0xd0,0x8c,0xb0,0x57,0x18,0x4c,"GUID_NWF_WME_IMPLEMENTED"); + IF_GUID_EQUAL_RETURN(guid,0x6cb9a43e+(105),0xc45f,0x4039,0x9f,0xe6,0xd0,0x8c,0xb0,0x57,0x18,0x4c,"GUID_NWF_WME_UPDATE_IE"); + IF_GUID_EQUAL_RETURN(guid,0x6cb9a43e+(89),0xc45f,0x4039,0x9f,0xe6,0xd0,0x8c,0xb0,0x57,0x18,0x4c,"GUID_NWF_WPA_TSC"); + IF_GUID_EQUAL_RETURN(guid,0x86c4fa80,0x8d84,0x11d0,0x94,0xe8,0x00,0xc0,0x4f,0xc3,0x41,0x37,"GUID_NonLocalVidMemCaps"); + IF_GUID_EQUAL_RETURN(guid,0xe05c8472,0x51d4,0x11d1,0x8c,0xce,0x0,0xa0,0xc9,0x6,0x29,0xa8,"GUID_OptSurfaceKmodeInfo"); + IF_GUID_EQUAL_RETURN(guid,0x9d792804,0x5fa8,0x11d1,0x8c,0xd0,0x0,0xa0,0xc9,0x6,0x29,0xa8,"GUID_OptSurfaceUmodeInfo"); + IF_GUID_EQUAL_RETURN(guid,0xee12f906,0xd277,0x404b,0xb6,0xda,0xe5,0xfa,0x1a,0x57,0x6d,0xf5,"GUID_PCIEXPRESS_ASPM_POLICY"); + IF_GUID_EQUAL_RETURN(guid,0x501a4d13,0x42af,0x4429,0x9f,0xd1,0xa8,0x21,0x8c,0x26,0x8e,0x20,"GUID_PCIEXPRESS_SETTINGS_SUBGROUP"); + IF_GUID_EQUAL_RETURN(guid,0xA36D02F2,0xC9F3,0x11CF,0xBF,0xC7,0x44,0x45,0x53,0x54,0x00,0x00,"GUID_POV"); + IF_GUID_EQUAL_RETURN(guid,0x7648EFA3,0xDD9C,0x4E3E,0xB5,0x66,0x50,0xF9,0x29,0x38,0x62,0x80,"GUID_POWERBUTTON_ACTION"); + IF_GUID_EQUAL_RETURN(guid,0x245D8541,0x3943,0x4422,0xB0,0x25,0x13,0xA7,0x84,0xF6,0x79,0xB7,"GUID_POWERSCHEME_PERSONALITY"); + IF_GUID_EQUAL_RETURN(guid,0x3b04d4fd,0x1cc7,0x4f23,0xab,0x1c,0xd1,0x33,0x78,0x19,0xc4,0xbb,"GUID_PROCESSOR_ALLOW_THROTTLING"); + IF_GUID_EQUAL_RETURN(guid,0x8f7b45e3,0xc393,0x480a,0x87,0x8c,0xf6,0x7a,0xc3,0xd0,0x70,0x82,"GUID_PROCESSOR_CORE_PARKING_AFFINITY_HISTORY_DECREASE_FACTOR"); + IF_GUID_EQUAL_RETURN(guid,0x5b33697b,0xe89d,0x4d38,0xaa,0x46,0x9e,0x7d,0xfb,0x7c,0xd2,0xf9,"GUID_PROCESSOR_CORE_PARKING_AFFINITY_HISTORY_THRESHOLD"); + IF_GUID_EQUAL_RETURN(guid,0xe70867f1,0xfa2f,0x4f4e,0xae,0xa1,0x4d,0x8a,0x0b,0xa2,0x3b,0x20,"GUID_PROCESSOR_CORE_PARKING_AFFINITY_WEIGHTING"); + IF_GUID_EQUAL_RETURN(guid,0x71021b41,0xc749,0x4d21,0xbe,0x74,0xa0,0x0f,0x33,0x5d,0x58,0x2b,"GUID_PROCESSOR_CORE_PARKING_DECREASE_POLICY"); + IF_GUID_EQUAL_RETURN(guid,0x68dd2f27,0xa4ce,0x4e11,0x84,0x87,0x37,0x94,0xe4,0x13,0x5d,0xfa,"GUID_PROCESSOR_CORE_PARKING_DECREASE_THRESHOLD"); + IF_GUID_EQUAL_RETURN(guid,0xdfd10d17,0xd5eb,0x45dd,0x87,0x7a,0x9a,0x34,0xdd,0xd1,0x5c,0x82,"GUID_PROCESSOR_CORE_PARKING_DECREASE_TIME"); + IF_GUID_EQUAL_RETURN(guid,0xc7be0679,0x2817,0x4d69,0x9d,0x02,0x51,0x9a,0x53,0x7e,0xd0,0xc6,"GUID_PROCESSOR_CORE_PARKING_INCREASE_POLICY"); + IF_GUID_EQUAL_RETURN(guid,0xdf142941,0x20f3,0x4edf,0x9a,0x4a,0x9c,0x83,0xd3,0xd7,0x17,0xd1,"GUID_PROCESSOR_CORE_PARKING_INCREASE_THRESHOLD"); + IF_GUID_EQUAL_RETURN(guid,0x2ddd5a84,0x5a71,0x437e,0x91,0x2a,0xdb,0x0b,0x8c,0x78,0x87,0x32,"GUID_PROCESSOR_CORE_PARKING_INCREASE_TIME"); + IF_GUID_EQUAL_RETURN(guid,0xea062031,0x0e34,0x4ff1,0x9b,0x6d,0xeb,0x10,0x59,0x33,0x40,0x28,"GUID_PROCESSOR_CORE_PARKING_MAX_CORES"); + IF_GUID_EQUAL_RETURN(guid,0x0cc5b647,0xc1df,0x4637,0x89,0x1a,0xde,0xc3,0x5c,0x31,0x85,0x83,"GUID_PROCESSOR_CORE_PARKING_MIN_CORES"); + IF_GUID_EQUAL_RETURN(guid,0x1299023c,0xbc28,0x4f0a,0x81,0xec,0xd3,0x29,0x5a,0x8d,0x81,0x5d,"GUID_PROCESSOR_CORE_PARKING_OVER_UTILIZATION_HISTORY_DECREASE_FACTOR"); + IF_GUID_EQUAL_RETURN(guid,0x9ac18e92,0xaa3c,0x4e27,0xb3,0x07,0x01,0xae,0x37,0x30,0x71,0x29,"GUID_PROCESSOR_CORE_PARKING_OVER_UTILIZATION_HISTORY_THRESHOLD"); + IF_GUID_EQUAL_RETURN(guid,0x943c8cb6,0x6f93,0x4227,0xad,0x87,0xe9,0xa3,0xfe,0xec,0x08,0xd1,"GUID_PROCESSOR_CORE_PARKING_OVER_UTILIZATION_THRESHOLD"); + IF_GUID_EQUAL_RETURN(guid,0x8809c2d8,0xb155,0x42d4,0xbc,0xda,0x0d,0x34,0x56,0x51,0xb1,0xdb,"GUID_PROCESSOR_CORE_PARKING_OVER_UTILIZATION_WEIGHTING"); + IF_GUID_EQUAL_RETURN(guid,0xe0007330,0xf589,0x42ed,0xa4,0x01,0x5d,0xdb,0x10,0xe7,0x85,0xd3,"GUID_PROCESSOR_DISTRIBUTE_UTILITY"); + IF_GUID_EQUAL_RETURN(guid,0x68f262a7,0xf621,0x4069,0xb9,0xa5,0x48,0x74,0x16,0x9b,0xe2,0x3c,"GUID_PROCESSOR_IDLESTATE_POLICY"); + IF_GUID_EQUAL_RETURN(guid,0x6c2993b0,0x8f48,0x481f,0xbc,0xc6,0x0,0xdd,0x27,0x42,0xaa,0x6,"GUID_PROCESSOR_IDLE_ALLOW_SCALING"); + IF_GUID_EQUAL_RETURN(guid,0x4b92d758,0x5a24,0x4851,0xa4,0x70,0x81,0x5d,0x78,0xae,0xe1,0x19,"GUID_PROCESSOR_IDLE_DEMOTE_THRESHOLD"); + IF_GUID_EQUAL_RETURN(guid,0x5d76a2ca,0xe8c0,0x402f,0xa1,0x33,0x21,0x58,0x49,0x2d,0x58,0xad,"GUID_PROCESSOR_IDLE_DISABLE"); + IF_GUID_EQUAL_RETURN(guid,0x7b224883,0xb3cc,0x4d79,0x81,0x9f,0x83,0x74,0x15,0x2c,0xbe,0x7c,"GUID_PROCESSOR_IDLE_PROMOTE_THRESHOLD"); + IF_GUID_EQUAL_RETURN(guid,0x9943e905,0x9a30,0x4ec1,0x9b,0x99,0x44,0xdd,0x3b,0x76,0xf7,0xa2,"GUID_PROCESSOR_IDLE_STATE_MAXIMUM"); + IF_GUID_EQUAL_RETURN(guid,0xc4581c31,0x89ab,0x4597,0x8e,0x2b,0x9c,0x9c,0xab,0x44,0xe,0x6b,"GUID_PROCESSOR_IDLE_TIME_CHECK"); + IF_GUID_EQUAL_RETURN(guid,0x2430ab6f,0xa520,0x44a2,0x96,0x01,0xf7,0xf2,0x3b,0x51,0x34,0xb1,"GUID_PROCESSOR_PARKING_CONCURRENCY_THRESHOLD"); + IF_GUID_EQUAL_RETURN(guid,0xa55612aa,0xf624,0x42c6,0xa4,0x43,0x73,0x97,0xd0,0x64,0xc0,0x4f,"GUID_PROCESSOR_PARKING_CORE_OVERRIDE"); + IF_GUID_EQUAL_RETURN(guid,0xf735a673,0x2066,0x4f80,0xa0,0xc5,0xdd,0xee,0x0c,0xf1,0xbf,0x5d,"GUID_PROCESSOR_PARKING_HEADROOM_THRESHOLD"); + IF_GUID_EQUAL_RETURN(guid,0x447235c7,0x6a8d,0x4cc0,0x8e,0x24,0x9e,0xaf,0x70,0xb9,0x6e,0x2b,"GUID_PROCESSOR_PARKING_PERF_STATE"); + IF_GUID_EQUAL_RETURN(guid,0xBBDC3814,0x18E9,0x4463,0x8A,0x55,0xD1,0x97,0x32,0x7C,0x45,0xC0,"GUID_PROCESSOR_PERFSTATE_POLICY"); + IF_GUID_EQUAL_RETURN(guid,0xbe337238,0xd82,0x4146,0xa9,0x60,0x4f,0x37,0x49,0xd4,0x70,0xc7,"GUID_PROCESSOR_PERF_BOOST_MODE"); + IF_GUID_EQUAL_RETURN(guid,0x45bcc044,0xd885,0x43e2,0x86,0x5,0xee,0xe,0xc6,0xe9,0x6b,0x59,"GUID_PROCESSOR_PERF_BOOST_POLICY"); + IF_GUID_EQUAL_RETURN(guid,0x40fbefc7,0x2e9d,0x4d25,0xa1,0x85,0xc,0xfd,0x85,0x74,0xba,0xc6,"GUID_PROCESSOR_PERF_DECREASE_POLICY"); + IF_GUID_EQUAL_RETURN(guid,0x12a0ab44,0xfe28,0x4fa9,0xb3,0xbd,0x4b,0x64,0xf4,0x49,0x60,0xa6,"GUID_PROCESSOR_PERF_DECREASE_THRESHOLD"); + IF_GUID_EQUAL_RETURN(guid,0xd8edeb9b,0x95cf,0x4f95,0xa7,0x3c,0xb0,0x61,0x97,0x36,0x93,0xc8,"GUID_PROCESSOR_PERF_DECREASE_TIME"); + IF_GUID_EQUAL_RETURN(guid,0x7d24baa7,0x0b84,0x480f,0x84,0x0c,0x1b,0x07,0x43,0xc0,0x0f,0x5f,"GUID_PROCESSOR_PERF_HISTORY"); + IF_GUID_EQUAL_RETURN(guid,0x465e1f50,0xb610,0x473a,0xab,0x58,0x0,0xd1,0x7,0x7d,0xc4,0x18,"GUID_PROCESSOR_PERF_INCREASE_POLICY"); + IF_GUID_EQUAL_RETURN(guid,0x06cadf0e,0x64ed,0x448a,0x89,0x27,0xce,0x7b,0xf9,0x0e,0xb3,0x5d,"GUID_PROCESSOR_PERF_INCREASE_THRESHOLD"); + IF_GUID_EQUAL_RETURN(guid,0x984cf492,0x3bed,0x4488,0xa8,0xf9,0x42,0x86,0xc9,0x7b,0xf5,0xaa,"GUID_PROCESSOR_PERF_INCREASE_TIME"); + IF_GUID_EQUAL_RETURN(guid,0x0822df31,0x9c83,0x441c,0xa0,0x79,0x0d,0xe4,0xcf,0x00,0x9c,0x7b,"GUID_PROCESSOR_PERF_LATENCY_HINT"); + IF_GUID_EQUAL_RETURN(guid,0x4d2b0152,0x7d5c,0x498b,0x88,0xe2,0x34,0x34,0x53,0x92,0xa2,0xc5,"GUID_PROCESSOR_PERF_TIME_CHECK"); + IF_GUID_EQUAL_RETURN(guid,0x54533251,0x82BE,0x4824,0x96,0xC1,0x47,0xB6,0x0B,0x74,0x0D,0x00,"GUID_PROCESSOR_SETTINGS_SUBGROUP"); + IF_GUID_EQUAL_RETURN(guid,0xBC5038F7,0x23E0,0x4960,0x96,0xDA,0x33,0xAB,0xAF,0x59,0x35,0xEC,"GUID_PROCESSOR_THROTTLE_MAXIMUM"); + IF_GUID_EQUAL_RETURN(guid,0x893DEE8E,0x2BEF,0x41E0,0x89,0xC6,0xB5,0x5D,0x09,0x29,0x96,0x4C,"GUID_PROCESSOR_THROTTLE_MINIMUM"); + IF_GUID_EQUAL_RETURN(guid,0x57027304,0x4AF6,0x4104,0x92,0x60,0xE3,0xD9,0x52,0x48,0xFC,0x36,"GUID_PROCESSOR_THROTTLE_POLICY"); + IF_GUID_EQUAL_RETURN(guid,0x1713dd5a,0x68e7,0x4a5b,0x9a,0xf6,0x59,0x2a,0x59,0x5c,0x77,0x8d,"GUID_PROP_INPUTSCOPE"); + IF_GUID_EQUAL_RETURN(guid,0x2941ff83,0x88d8,0x4f73,0xb6,0xa9,0xbd,0xf8,0x71,0x2d,0x00,0x0d,"GUID_PropGetCA"); + IF_GUID_EQUAL_RETURN(guid,0x29533527,0x3683,0x4364,0xab,0xc0,0xdb,0x1a,0xdd,0x82,0x2f,0xa2,"GUID_PropPutCA"); + IF_GUID_EQUAL_RETURN(guid,0x13541C21,0x8E33,0x11D0,0x9A,0xD0,0x00,0xA0,0xC9,0xA0,0x6E,0x35,"GUID_RampForce"); + IF_GUID_EQUAL_RETURN(guid,0xA36D02F4,0xC9F3,0x11CF,0xBF,0xC7,0x44,0x45,0x53,0x54,0x00,0x00,"GUID_RxAxis"); + IF_GUID_EQUAL_RETURN(guid,0xA36D02F5,0xC9F3,0x11CF,0xBF,0xC7,0x44,0x45,0x53,0x54,0x00,0x00,"GUID_RyAxis"); + IF_GUID_EQUAL_RETURN(guid,0xA36D02E3,0xC9F3,0x11CF,0xBF,0xC7,0x44,0x45,0x53,0x54,0x00,0x00,"GUID_RzAxis"); + IF_GUID_EQUAL_RETURN(guid,0x2b84c20e,0xad23,0x4ddf,0x93,0xdb,0x5,0xff,0xbd,0x7e,0xfc,0xa5,"GUID_SESSION_DISPLAY_STATUS"); + IF_GUID_EQUAL_RETURN(guid,0x3c0f4548,0xc03f,0x4c4d,0xb9,0xf2,0x23,0x7e,0xde,0x68,0x63,0x76,"GUID_SESSION_USER_PRESENCE"); + IF_GUID_EQUAL_RETURN(guid,0x96996BC0,0xAD50,0x47EC,0x92,0x3B,0x6F,0x41,0x87,0x4D,0xD9,0xEB,"GUID_SLEEPBUTTON_ACTION"); + IF_GUID_EQUAL_RETURN(guid,0x81cd32e0,0x7833,0x44f3,0x87,0x37,0x70,0x81,0xf3,0x8d,0x1f,0x70,"GUID_SLEEP_IDLE_THRESHOLD"); + IF_GUID_EQUAL_RETURN(guid,0x238C9FA8,0x0AAD,0x41ED,0x83,0xF4,0x97,0xBE,0x24,0x2C,0x8F,0x20,"GUID_SLEEP_SUBGROUP"); + IF_GUID_EQUAL_RETURN(guid,0x29F6C1DB,0x86DA,0x48C5,0x9F,0xDB,0xF2,0xB6,0x7B,0x1F,0x44,0xDA,"GUID_STANDBY_TIMEOUT"); + IF_GUID_EQUAL_RETURN(guid,0xc00eb795,0x8c6e,0x11d2,0x97,0x7a,0x0,0x0,0xf8,0x7a,0x92,0x6f,"GUID_STIUserDefined1"); + IF_GUID_EQUAL_RETURN(guid,0xc77ae9c5,0x8c6e,0x11d2,0x97,0x7a,0x0,0x0,0xf8,0x7a,0x92,0x6f,"GUID_STIUserDefined2"); + IF_GUID_EQUAL_RETURN(guid,0xc77ae9c6,0x8c6e,0x11d2,0x97,0x7a,0x0,0x0,0xf8,0x7a,0x92,0x6f,"GUID_STIUserDefined3"); + IF_GUID_EQUAL_RETURN(guid,0x98A7F580,0x01F7,0x48AA,0x9C,0x0F,0x44,0x35,0x2C,0x29,0xE5,0xC0,"GUID_SYSTEM_AWAYMODE"); + IF_GUID_EQUAL_RETURN(guid,0x4F971E89,0xEEBD,0x4455,0xA8,0xDE,0x9E,0x59,0x04,0x0E,0x73,0x47,"GUID_SYSTEM_BUTTON_SUBGROUP"); + IF_GUID_EQUAL_RETURN(guid,0x94D3A615,0xA899,0x4AC5,0xAE,0x2B,0xE4,0xD8,0xF6,0x34,0x36,0x7F,"GUID_SYSTEM_COOLING_POLICY"); + IF_GUID_EQUAL_RETURN(guid,0x13541C26,0x8E33,0x11D0,0x9A,0xD0,0x00,0xA0,0xC9,0xA0,0x6E,0x35,"GUID_SawtoothDown"); + IF_GUID_EQUAL_RETURN(guid,0x13541C25,0x8E33,0x11D0,0x9A,0xD0,0x00,0xA0,0xC9,0xA0,0x6E,0x35,"GUID_SawtoothUp"); + IF_GUID_EQUAL_RETURN(guid,0xc00eb793,0x8c6e,0x11d2,0x97,0x7a,0x0,0x0,0xf8,0x7a,0x92,0x6f,"GUID_ScanFaxImage"); + IF_GUID_EQUAL_RETURN(guid,0xa6c5a715,0x8c6e,0x11d2,0x97,0x7a,0x0,0x0,0xf8,0x7a,0x92,0x6f,"GUID_ScanImage"); + IF_GUID_EQUAL_RETURN(guid,0xb441f425,0x8c6e,0x11d2,0x97,0x7a,0x0,0x0,0xf8,0x7a,0x92,0x6f,"GUID_ScanPrintImage"); + IF_GUID_EQUAL_RETURN(guid,0x13541C23,0x8E33,0x11D0,0x9A,0xD0,0x00,0xA0,0xC9,0xA0,0x6E,0x35,"GUID_Sine"); + IF_GUID_EQUAL_RETURN(guid,0xA36D02E4,0xC9F3,0x11CF,0xBF,0xC7,0x44,0x45,0x53,0x54,0x00,0x00,"GUID_Slider"); + IF_GUID_EQUAL_RETURN(guid,0x13541C27,0x8E33,0x11D0,0x9A,0xD0,0x00,0xA0,0xC9,0xA0,0x6E,0x35,"GUID_Spring"); + IF_GUID_EQUAL_RETURN(guid,0x13541C22,0x8E33,0x11D0,0x9A,0xD0,0x00,0xA0,0xC9,0xA0,0x6E,0x35,"GUID_Square"); + IF_GUID_EQUAL_RETURN(guid,0x6F1D2B61,0xD5A0,0x11CF,0xBF,0xC7,0x44,0x45,0x53,0x54,0x00,0x00,"GUID_SysKeyboard"); + IF_GUID_EQUAL_RETURN(guid,0x6F1D2B83,0xD5A0,0x11CF,0xBF,0xC7,0x44,0x45,0x53,0x54,0x00,0x00,"GUID_SysKeyboardEm2"); + IF_GUID_EQUAL_RETURN(guid,0x6F1D2B82,0xD5A0,0x11CF,0xBF,0xC7,0x44,0x45,0x53,0x54,0x00,0x00,"GUID_SysKeyboardEm"); + IF_GUID_EQUAL_RETURN(guid,0x6F1D2B60,0xD5A0,0x11CF,0xBF,0xC7,0x44,0x45,0x53,0x54,0x00,0x00,"GUID_SysMouse"); + IF_GUID_EQUAL_RETURN(guid,0x6F1D2B81,0xD5A0,0x11CF,0xBF,0xC7,0x44,0x45,0x53,0x54,0x00,0x00,"GUID_SysMouseEm2"); + IF_GUID_EQUAL_RETURN(guid,0x6F1D2B80,0xD5A0,0x11CF,0xBF,0xC7,0x44,0x45,0x53,0x54,0x00,0x00,"GUID_SysMouseEm"); + IF_GUID_EQUAL_RETURN(guid,0x574c49d,0x5b04,0x4b15,0xa5,0x42,0xae,0x28,0x20,0x30,0x11,0x7b,"GUID_TIME_MUSIC"); + IF_GUID_EQUAL_RETURN(guid,0x93ad712b,0xdaa0,0x4ffe,0xbc,0x81,0xb0,0xce,0x50,0xf,0xcd,0xd9,"GUID_TIME_REFERENCE"); + IF_GUID_EQUAL_RETURN(guid,0xa8593d05,0xc43,0x4984,0x9a,0x63,0x97,0xaf,0x9e,0x2,0xc4,0xc0,"GUID_TIME_SAMPLES"); + IF_GUID_EQUAL_RETURN(guid,0xf9786200,0xa5bf,0x4a0f,0x8c,0x24,0xfb,0x16,0xf5,0xd1,0xaa,0xbb,"GUID_TS_SERVICE_ACCESSIBLE"); + IF_GUID_EQUAL_RETURN(guid,0xea937a50,0xc9a6,0x4b7d,0x89,0x4a,0x49,0xd9,0x9b,0x78,0x48,0x34,"GUID_TS_SERVICE_ACTIVEX"); + IF_GUID_EQUAL_RETURN(guid,0x6086fbb5,0xe225,0x46ce,0xa7,0x70,0xc1,0xbb,0xd3,0xe0,0x5d,0x7b,"GUID_TS_SERVICE_DATAOBJECT"); + IF_GUID_EQUAL_RETURN(guid,0x381B4222,0xF694,0x41F0,0x96,0x85,0xFF,0x5B,0xB2,0x60,0xDF,0x2E,"GUID_TYPICAL_POWER_SAVINGS"); + IF_GUID_EQUAL_RETURN(guid,0x13541C24,0x8E33,0x11D0,0x9A,0xD0,0x00,0xA0,0xC9,0xA0,0x6E,0x35,"GUID_Triangle"); + IF_GUID_EQUAL_RETURN(guid,0x7bc4a2f9,0xd8fc,0x4469,0xb0,0x7b,0x33,0xeb,0x78,0x5a,0xac,0xa0,"GUID_UNATTEND_SLEEP_TIMEOUT"); + IF_GUID_EQUAL_RETURN(guid,0xA7066653,0x8D6C,0x40A8,0x91,0x0E,0xA1,0xF5,0x4B,0x84,0xC7,0xE5,"GUID_USERINTERFACEBUTTON_ACTION"); + IF_GUID_EQUAL_RETURN(guid,0xA36D02F3,0xC9F3,0x11CF,0xBF,0xC7,0x44,0x45,0x53,0x54,0x00,0x00,"GUID_Unknown"); + IF_GUID_EQUAL_RETURN(guid,0x42e02f17,0x7b41,0x11d2,0x8b,0xff,0x0,0xa0,0xc9,0x83,0xea,0xf6,"GUID_UpdateNonLocalHeap"); + IF_GUID_EQUAL_RETURN(guid,0xf0b0e8e2,0x5f97,0x11d1,0x8c,0xd0,0x0,0xa0,0xc9,0x6,0x29,0xa8,"GUID_UserModeDriverInfo"); + IF_GUID_EQUAL_RETURN(guid,0x97f861b6,0x60a1,0x11d1,0x8c,0xd0,0x0,0xa0,0xc9,0x6,0x29,0xa8,"GUID_UserModeDriverPassword"); + IF_GUID_EQUAL_RETURN(guid,0xFBD9AA66,0x9553,0x4097,0xBA,0x44,0xED,0x6E,0x9D,0x65,0xEA,0xB8,"GUID_VIDEO_ADAPTIVE_DISPLAY_BRIGHTNESS"); + IF_GUID_EQUAL_RETURN(guid,0xEED904DF,0xB142,0x4183,0xB1,0x0B,0x5A,0x11,0x97,0xA3,0x78,0x64,"GUID_VIDEO_ADAPTIVE_PERCENT_INCREASE"); + IF_GUID_EQUAL_RETURN(guid,0x90959D22,0xD6A1,0x49B9,0xAF,0x93,0xBC,0xE8,0x85,0xAD,0x33,0x5B,"GUID_VIDEO_ADAPTIVE_POWERDOWN"); + IF_GUID_EQUAL_RETURN(guid,0x82DBCF2D,0xCD67,0x40C5,0xBF,0xDC,0x9F,0x1A,0x5C,0xCD,0x46,0x63,"GUID_VIDEO_ANNOYANCE_TIMEOUT"); + IF_GUID_EQUAL_RETURN(guid,0x8ec4b3a5,0x6868,0x48c2,0xbe,0x75,0x4f,0x30,0x44,0xbe,0x88,0xa7,"GUID_VIDEO_CONSOLE_LOCK_TIMEOUT"); + IF_GUID_EQUAL_RETURN(guid,0x8ffee2c6,0x2d01,0x46be,0xad,0xb9,0x39,0x8a,0xdd,0xc5,0xb4,0xff,"GUID_VIDEO_CURRENT_MONITOR_BRIGHTNESS"); + IF_GUID_EQUAL_RETURN(guid,0x17aaa29b,0x8b43,0x4b94,0xaa,0xfe,0x35,0xf6,0x4d,0xaa,0xf1,0xee,"GUID_VIDEO_DIM_TIMEOUT"); + IF_GUID_EQUAL_RETURN(guid,0x3C0BC021,0xC8A8,0x4E07,0xA9,0x73,0x6B,0x14,0xCB,0xCB,0x2B,0x7E,"GUID_VIDEO_POWERDOWN_TIMEOUT"); + IF_GUID_EQUAL_RETURN(guid,0x7516B95F,0xF776,0x4464,0x8C,0x53,0x06,0x16,0x7F,0x40,0xCC,0x99,"GUID_VIDEO_SUBGROUP"); + IF_GUID_EQUAL_RETURN(guid,0x52882147,0x2d47,0x469a,0xa0,0xd1,0x3,0x45,0x58,0x90,0xf6,0xc8,"GUID_VPE2Callbacks"); + IF_GUID_EQUAL_RETURN(guid,0xf0e749ca,0xedef,0x4589,0xa7,0x3a,0xee,0xe,0x62,0x6a,0x2a,0x2b,"GUID_VendorMicrosoft"); + IF_GUID_EQUAL_RETURN(guid,0x257a30fd,0x6b6,0x462b,0xae,0xa4,0x63,0xf7,0xb,0x86,0xe5,0x33,"GUID_VendorMicrosoftBuiltIn"); + IF_GUID_EQUAL_RETURN(guid,0xefd60cc1,0x49e7,0x11d0,0x88,0x9d,0x0,0xaa,0x0,0xbb,0xb7,0x6a,"GUID_VideoPortCallbacks"); + IF_GUID_EQUAL_RETURN(guid,0xefd60cc1,0x49e7,0x11d0,0x88,0x9d,0x00,0xaa,0x00,0xbb,0xb7,0x6a,"GUID_VideoPortCallbacks"); + IF_GUID_EQUAL_RETURN(guid,0xefd60cc3,0x49e7,0x11d0,0x88,0x9d,0x0,0xaa,0x0,0xbb,0xb7,0x6a,"GUID_VideoPortCaps"); + IF_GUID_EQUAL_RETURN(guid,0xefd60cc3,0x49e7,0x11d0,0x88,0x9d,0x00,0xaa,0x00,0xbb,0xb7,0x6a,"GUID_VideoPortCaps"); + IF_GUID_EQUAL_RETURN(guid,0x6fddc324,0x4e03,0x4bfe,0xb1,0x85,0x3d,0x77,0x76,0x8d,0xc9,0x37,"GUID_WICPixelFormat112bpp6ChannelsAlpha"); + IF_GUID_EQUAL_RETURN(guid,0x6fddc324,0x4e03,0x4bfe,0xb1,0x85,0x3d,0x77,0x76,0x8d,0xc9,0x2a,"GUID_WICPixelFormat112bpp7Channels"); + IF_GUID_EQUAL_RETURN(guid,0x6fddc324,0x4e03,0x4bfe,0xb1,0x85,0x3d,0x77,0x76,0x8d,0xc9,0x38,"GUID_WICPixelFormat128bpp7ChannelsAlpha"); + IF_GUID_EQUAL_RETURN(guid,0x6fddc324,0x4e03,0x4bfe,0xb1,0x85,0x3d,0x77,0x76,0x8d,0xc9,0x2b,"GUID_WICPixelFormat128bpp8Channels"); + IF_GUID_EQUAL_RETURN(guid,0x6fddc324,0x4e03,0x4bfe,0xb1,0x85,0x3d,0x77,0x76,0x8d,0xc9,0x1a,"GUID_WICPixelFormat128bppPRGBAFloat"); + IF_GUID_EQUAL_RETURN(guid,0x6fddc324,0x4e03,0x4bfe,0xb1,0x85,0x3d,0x77,0x76,0x8d,0xc9,0x1e,"GUID_WICPixelFormat128bppRGBAFixedPoint"); + IF_GUID_EQUAL_RETURN(guid,0x6fddc324,0x4e03,0x4bfe,0xb1,0x85,0x3d,0x77,0x76,0x8d,0xc9,0x19,"GUID_WICPixelFormat128bppRGBAFloat"); + IF_GUID_EQUAL_RETURN(guid,0x6fddc324,0x4e03,0x4bfe,0xb1,0x85,0x3d,0x77,0x76,0x8d,0xc9,0x41,"GUID_WICPixelFormat128bppRGBFixedPoint"); + IF_GUID_EQUAL_RETURN(guid,0x6fddc324,0x4e03,0x4bfe,0xb1,0x85,0x3d,0x77,0x76,0x8d,0xc9,0x1b,"GUID_WICPixelFormat128bppRGBFloat"); + IF_GUID_EQUAL_RETURN(guid,0x6fddc324,0x4e03,0x4bfe,0xb1,0x85,0x3d,0x77,0x76,0x8d,0xc9,0x39,"GUID_WICPixelFormat144bpp8ChannelsAlpha"); + IF_GUID_EQUAL_RETURN(guid,0x6fddc324,0x4e03,0x4bfe,0xb1,0x85,0x3d,0x77,0x76,0x8d,0xc9,0x09,"GUID_WICPixelFormat16bppBGR555"); + IF_GUID_EQUAL_RETURN(guid,0x6fddc324,0x4e03,0x4bfe,0xb1,0x85,0x3d,0x77,0x76,0x8d,0xc9,0x0a,"GUID_WICPixelFormat16bppBGR565"); + IF_GUID_EQUAL_RETURN(guid,0x05ec7c2b,0xf1e6,0x4961,0xad,0x46,0xe1,0xcc,0x81,0x0a,0x87,0xd2,"GUID_WICPixelFormat16bppBGRA5551"); + IF_GUID_EQUAL_RETURN(guid,0x6fddc324,0x4e03,0x4bfe,0xb1,0x85,0x3d,0x77,0x76,0x8d,0xc9,0x0b,"GUID_WICPixelFormat16bppGray"); + IF_GUID_EQUAL_RETURN(guid,0x6fddc324,0x4e03,0x4bfe,0xb1,0x85,0x3d,0x77,0x76,0x8d,0xc9,0x13,"GUID_WICPixelFormat16bppGrayFixedPoint"); + IF_GUID_EQUAL_RETURN(guid,0x6fddc324,0x4e03,0x4bfe,0xb1,0x85,0x3d,0x77,0x76,0x8d,0xc9,0x3e,"GUID_WICPixelFormat16bppGrayHalf"); + IF_GUID_EQUAL_RETURN(guid,0x6fddc324,0x4e03,0x4bfe,0xb1,0x85,0x3d,0x77,0x76,0x8d,0xc9,0x01,"GUID_WICPixelFormat1bppIndexed"); + IF_GUID_EQUAL_RETURN(guid,0x6fddc324,0x4e03,0x4bfe,0xb1,0x85,0x3d,0x77,0x76,0x8d,0xc9,0x20,"GUID_WICPixelFormat24bpp3Channels"); + IF_GUID_EQUAL_RETURN(guid,0x6fddc324,0x4e03,0x4bfe,0xb1,0x85,0x3d,0x77,0x76,0x8d,0xc9,0x0c,"GUID_WICPixelFormat24bppBGR"); + IF_GUID_EQUAL_RETURN(guid,0x6fddc324,0x4e03,0x4bfe,0xb1,0x85,0x3d,0x77,0x76,0x8d,0xc9,0x0d,"GUID_WICPixelFormat24bppRGB"); + IF_GUID_EQUAL_RETURN(guid,0x6fddc324,0x4e03,0x4bfe,0xb1,0x85,0x3d,0x77,0x76,0x8d,0xc9,0x06,"GUID_WICPixelFormat2bppGray"); + IF_GUID_EQUAL_RETURN(guid,0x6fddc324,0x4e03,0x4bfe,0xb1,0x85,0x3d,0x77,0x76,0x8d,0xc9,0x02,"GUID_WICPixelFormat2bppIndexed"); + IF_GUID_EQUAL_RETURN(guid,0x6fddc324,0x4e03,0x4bfe,0xb1,0x85,0x3d,0x77,0x76,0x8d,0xc9,0x2e,"GUID_WICPixelFormat32bpp3ChannelsAlpha"); + IF_GUID_EQUAL_RETURN(guid,0x6fddc324,0x4e03,0x4bfe,0xb1,0x85,0x3d,0x77,0x76,0x8d,0xc9,0x21,"GUID_WICPixelFormat32bpp4Channels"); + IF_GUID_EQUAL_RETURN(guid,0x6fddc324,0x4e03,0x4bfe,0xb1,0x85,0x3d,0x77,0x76,0x8d,0xc9,0x14,"GUID_WICPixelFormat32bppBGR101010"); + IF_GUID_EQUAL_RETURN(guid,0x6fddc324,0x4e03,0x4bfe,0xb1,0x85,0x3d,0x77,0x76,0x8d,0xc9,0x0e,"GUID_WICPixelFormat32bppBGR"); + IF_GUID_EQUAL_RETURN(guid,0x6fddc324,0x4e03,0x4bfe,0xb1,0x85,0x3d,0x77,0x76,0x8d,0xc9,0x0f,"GUID_WICPixelFormat32bppBGRA"); + IF_GUID_EQUAL_RETURN(guid,0x6fddc324,0x4e03,0x4bfe,0xb1,0x85,0x3d,0x77,0x76,0x8d,0xc9,0x1c,"GUID_WICPixelFormat32bppCMYK"); + IF_GUID_EQUAL_RETURN(guid,0x6fddc324,0x4e03,0x4bfe,0xb1,0x85,0x3d,0x77,0x76,0x8d,0xc9,0x3f,"GUID_WICPixelFormat32bppGrayFixedPoint"); + IF_GUID_EQUAL_RETURN(guid,0x6fddc324,0x4e03,0x4bfe,0xb1,0x85,0x3d,0x77,0x76,0x8d,0xc9,0x11,"GUID_WICPixelFormat32bppGrayFloat"); + IF_GUID_EQUAL_RETURN(guid,0x6fddc324,0x4e03,0x4bfe,0xb1,0x85,0x3d,0x77,0x76,0x8d,0xc9,0x10,"GUID_WICPixelFormat32bppPBGRA"); + IF_GUID_EQUAL_RETURN(guid,0x3cc4a650,0xa527,0x4d37,0xa9,0x16,0x31,0x42,0xc7,0xeb,0xed,0xba,"GUID_WICPixelFormat32bppPRGBA"); + IF_GUID_EQUAL_RETURN(guid,0xd98c6b95,0x3efe,0x47d6,0xbb,0x25,0xeb,0x17,0x48,0xab,0x0c,0xf1,"GUID_WICPixelFormat32bppRGB"); + IF_GUID_EQUAL_RETURN(guid,0x25238D72,0xFCF9,0x4522,0xb5,0x14,0x55,0x78,0xe5,0xad,0x55,0xe0,"GUID_WICPixelFormat32bppRGBA1010102"); + IF_GUID_EQUAL_RETURN(guid,0x00DE6B9A,0xC101,0x434b,0xb5,0x02,0xd0,0x16,0x5e,0xe1,0x12,0x2c,"GUID_WICPixelFormat32bppRGBA1010102XR"); + IF_GUID_EQUAL_RETURN(guid,0xf5c7ad2d,0x6a8d,0x43dd,0xa7,0xa8,0xa2,0x99,0x35,0x26,0x1a,0xe9,"GUID_WICPixelFormat32bppRGBA"); + IF_GUID_EQUAL_RETURN(guid,0x6fddc324,0x4e03,0x4bfe,0xb1,0x85,0x3d,0x77,0x76,0x8d,0xc9,0x3d,"GUID_WICPixelFormat32bppRGBE"); + IF_GUID_EQUAL_RETURN(guid,0x6fddc324,0x4e03,0x4bfe,0xb1,0x85,0x3d,0x77,0x76,0x8d,0xc9,0x2f,"GUID_WICPixelFormat40bpp4ChannelsAlpha"); + IF_GUID_EQUAL_RETURN(guid,0x6fddc324,0x4e03,0x4bfe,0xb1,0x85,0x3d,0x77,0x76,0x8d,0xc9,0x22,"GUID_WICPixelFormat40bpp5Channels"); + IF_GUID_EQUAL_RETURN(guid,0x6fddc324,0x4e03,0x4bfe,0xb1,0x85,0x3d,0x77,0x76,0x8d,0xc9,0x2c,"GUID_WICPixelFormat40bppCMYKAlpha"); + IF_GUID_EQUAL_RETURN(guid,0x6fddc324,0x4e03,0x4bfe,0xb1,0x85,0x3d,0x77,0x76,0x8d,0xc9,0x26,"GUID_WICPixelFormat48bpp3Channels"); + IF_GUID_EQUAL_RETURN(guid,0x6fddc324,0x4e03,0x4bfe,0xb1,0x85,0x3d,0x77,0x76,0x8d,0xc9,0x30,"GUID_WICPixelFormat48bpp5ChannelsAlpha"); + IF_GUID_EQUAL_RETURN(guid,0x6fddc324,0x4e03,0x4bfe,0xb1,0x85,0x3d,0x77,0x76,0x8d,0xc9,0x23,"GUID_WICPixelFormat48bpp6Channels"); + IF_GUID_EQUAL_RETURN(guid,0xe605a384,0xb468,0x46ce,0xbb,0x2e,0x36,0xf1,0x80,0xe6,0x43,0x13,"GUID_WICPixelFormat48bppBGR"); + IF_GUID_EQUAL_RETURN(guid,0x49ca140e,0xcab6,0x493b,0x9d,0xdf,0x60,0x18,0x7c,0x37,0x53,0x2a,"GUID_WICPixelFormat48bppBGRFixedPoint"); + IF_GUID_EQUAL_RETURN(guid,0x6fddc324,0x4e03,0x4bfe,0xb1,0x85,0x3d,0x77,0x76,0x8d,0xc9,0x15,"GUID_WICPixelFormat48bppRGB"); + IF_GUID_EQUAL_RETURN(guid,0x6fddc324,0x4e03,0x4bfe,0xb1,0x85,0x3d,0x77,0x76,0x8d,0xc9,0x12,"GUID_WICPixelFormat48bppRGBFixedPoint"); + IF_GUID_EQUAL_RETURN(guid,0x6fddc324,0x4e03,0x4bfe,0xb1,0x85,0x3d,0x77,0x76,0x8d,0xc9,0x3b,"GUID_WICPixelFormat48bppRGBHalf"); + IF_GUID_EQUAL_RETURN(guid,0x6fddc324,0x4e03,0x4bfe,0xb1,0x85,0x3d,0x77,0x76,0x8d,0xc9,0x07,"GUID_WICPixelFormat4bppGray"); + IF_GUID_EQUAL_RETURN(guid,0x6fddc324,0x4e03,0x4bfe,0xb1,0x85,0x3d,0x77,0x76,0x8d,0xc9,0x03,"GUID_WICPixelFormat4bppIndexed"); + IF_GUID_EQUAL_RETURN(guid,0x6fddc324,0x4e03,0x4bfe,0xb1,0x85,0x3d,0x77,0x76,0x8d,0xc9,0x31,"GUID_WICPixelFormat56bpp6ChannelsAlpha"); + IF_GUID_EQUAL_RETURN(guid,0x6fddc324,0x4e03,0x4bfe,0xb1,0x85,0x3d,0x77,0x76,0x8d,0xc9,0x24,"GUID_WICPixelFormat56bpp7Channels"); + IF_GUID_EQUAL_RETURN(guid,0x6fddc324,0x4e03,0x4bfe,0xb1,0x85,0x3d,0x77,0x76,0x8d,0xc9,0x34,"GUID_WICPixelFormat64bpp3ChannelsAlpha"); + IF_GUID_EQUAL_RETURN(guid,0x6fddc324,0x4e03,0x4bfe,0xb1,0x85,0x3d,0x77,0x76,0x8d,0xc9,0x27,"GUID_WICPixelFormat64bpp4Channels"); + IF_GUID_EQUAL_RETURN(guid,0x6fddc324,0x4e03,0x4bfe,0xb1,0x85,0x3d,0x77,0x76,0x8d,0xc9,0x32,"GUID_WICPixelFormat64bpp7ChannelsAlpha"); + IF_GUID_EQUAL_RETURN(guid,0x6fddc324,0x4e03,0x4bfe,0xb1,0x85,0x3d,0x77,0x76,0x8d,0xc9,0x25,"GUID_WICPixelFormat64bpp8Channels"); + IF_GUID_EQUAL_RETURN(guid,0x1562ff7c,0xd352,0x46f9,0x97,0x9e,0x42,0x97,0x6b,0x79,0x22,0x46,"GUID_WICPixelFormat64bppBGRA"); + IF_GUID_EQUAL_RETURN(guid,0x356de33c,0x54d2,0x4a23,0xbb,0x4,0x9b,0x7b,0xf9,0xb1,0xd4,0x2d,"GUID_WICPixelFormat64bppBGRAFixedPoint"); + IF_GUID_EQUAL_RETURN(guid,0x6fddc324,0x4e03,0x4bfe,0xb1,0x85,0x3d,0x77,0x76,0x8d,0xc9,0x1f,"GUID_WICPixelFormat64bppCMYK"); + IF_GUID_EQUAL_RETURN(guid,0x8c518e8e,0xa4ec,0x468b,0xae,0x70,0xc9,0xa3,0x5a,0x9c,0x55,0x30,"GUID_WICPixelFormat64bppPBGRA"); + IF_GUID_EQUAL_RETURN(guid,0x6fddc324,0x4e03,0x4bfe,0xb1,0x85,0x3d,0x77,0x76,0x8d,0xc9,0x17,"GUID_WICPixelFormat64bppPRGBA"); + IF_GUID_EQUAL_RETURN(guid,0x58ad26c2,0xc623,0x4d9d,0xb3,0x20,0x38,0x7e,0x49,0xf8,0xc4,0x42,"GUID_WICPixelFormat64bppPRGBAHalf"); + IF_GUID_EQUAL_RETURN(guid,0xa1182111,0x186d,0x4d42,0xbc,0x6a,0x9c,0x83,0x03,0xa8,0xdf,0xf9,"GUID_WICPixelFormat64bppRGB"); + IF_GUID_EQUAL_RETURN(guid,0x6fddc324,0x4e03,0x4bfe,0xb1,0x85,0x3d,0x77,0x76,0x8d,0xc9,0x16,"GUID_WICPixelFormat64bppRGBA"); + IF_GUID_EQUAL_RETURN(guid,0x6fddc324,0x4e03,0x4bfe,0xb1,0x85,0x3d,0x77,0x76,0x8d,0xc9,0x1d,"GUID_WICPixelFormat64bppRGBAFixedPoint"); + IF_GUID_EQUAL_RETURN(guid,0x6fddc324,0x4e03,0x4bfe,0xb1,0x85,0x3d,0x77,0x76,0x8d,0xc9,0x3a,"GUID_WICPixelFormat64bppRGBAHalf"); + IF_GUID_EQUAL_RETURN(guid,0x6fddc324,0x4e03,0x4bfe,0xb1,0x85,0x3d,0x77,0x76,0x8d,0xc9,0x40,"GUID_WICPixelFormat64bppRGBFixedPoint"); + IF_GUID_EQUAL_RETURN(guid,0x6fddc324,0x4e03,0x4bfe,0xb1,0x85,0x3d,0x77,0x76,0x8d,0xc9,0x42,"GUID_WICPixelFormat64bppRGBHalf"); + IF_GUID_EQUAL_RETURN(guid,0x6fddc324,0x4e03,0x4bfe,0xb1,0x85,0x3d,0x77,0x76,0x8d,0xc9,0x33,"GUID_WICPixelFormat72bpp8ChannelsAlpha"); + IF_GUID_EQUAL_RETURN(guid,0x6fddc324,0x4e03,0x4bfe,0xb1,0x85,0x3d,0x77,0x76,0x8d,0xc9,0x35,"GUID_WICPixelFormat80bpp4ChannelsAlpha"); + IF_GUID_EQUAL_RETURN(guid,0x6fddc324,0x4e03,0x4bfe,0xb1,0x85,0x3d,0x77,0x76,0x8d,0xc9,0x28,"GUID_WICPixelFormat80bpp5Channels"); + IF_GUID_EQUAL_RETURN(guid,0x6fddc324,0x4e03,0x4bfe,0xb1,0x85,0x3d,0x77,0x76,0x8d,0xc9,0x2d,"GUID_WICPixelFormat80bppCMYKAlpha"); + IF_GUID_EQUAL_RETURN(guid,0xe6cd0116,0xeeba,0x4161,0xaa,0x85,0x27,0xdd,0x9f,0xb3,0xa8,0x95,"GUID_WICPixelFormat8bppAlpha"); + IF_GUID_EQUAL_RETURN(guid,0x6fddc324,0x4e03,0x4bfe,0xb1,0x85,0x3d,0x77,0x76,0x8d,0xc9,0x08,"GUID_WICPixelFormat8bppGray"); + IF_GUID_EQUAL_RETURN(guid,0x6fddc324,0x4e03,0x4bfe,0xb1,0x85,0x3d,0x77,0x76,0x8d,0xc9,0x04,"GUID_WICPixelFormat8bppIndexed"); + IF_GUID_EQUAL_RETURN(guid,0x6fddc324,0x4e03,0x4bfe,0xb1,0x85,0x3d,0x77,0x76,0x8d,0xc9,0x36,"GUID_WICPixelFormat96bpp5ChannelsAlpha"); + IF_GUID_EQUAL_RETURN(guid,0x6fddc324,0x4e03,0x4bfe,0xb1,0x85,0x3d,0x77,0x76,0x8d,0xc9,0x29,"GUID_WICPixelFormat96bpp6Channels"); + IF_GUID_EQUAL_RETURN(guid,0x6fddc324,0x4e03,0x4bfe,0xb1,0x85,0x3d,0x77,0x76,0x8d,0xc9,0x18,"GUID_WICPixelFormat96bppRGBFixedPoint"); + IF_GUID_EQUAL_RETURN(guid,0xe3fed78f,0xe8db,0x4acf,0x84,0xc1,0xe9,0x7f,0x61,0x36,0xb3,0x27,"GUID_WICPixelFormat96bppRGBFloat"); + IF_GUID_EQUAL_RETURN(guid,0x6fddc324,0x4e03,0x4bfe,0xb1,0x85,0x3d,0x77,0x76,0x8d,0xc9,0x05,"GUID_WICPixelFormatBlackWhite"); + IF_GUID_EQUAL_RETURN(guid,0x6fddc324,0x4e03,0x4bfe,0xb1,0x85,0x3d,0x77,0x76,0x8d,0xc9,0x00,"GUID_WICPixelFormatDontCare"); + IF_GUID_EQUAL_RETURN(guid,0xA36D02E0,0xC9F3,0x11CF,0xBF,0xC7,0x44,0x45,0x53,0x54,0x00,0x00,"GUID_XAxis"); + IF_GUID_EQUAL_RETURN(guid,0xA36D02E1,0xC9F3,0x11CF,0xBF,0xC7,0x44,0x45,0x53,0x54,0x00,0x00,"GUID_YAxis"); + IF_GUID_EQUAL_RETURN(guid,0xA36D02E2,0xC9F3,0x11CF,0xBF,0xC7,0x44,0x45,0x53,0x54,0x00,0x00,"GUID_ZAxis"); + IF_GUID_EQUAL_RETURN(guid,0x93869880,0x36cf,0x11d1,0x9b,0x1b,0x0,0xaa,0x0,0xbb,0xb8,0xae,"GUID_ZPixelFormats"); + IF_GUID_EQUAL_RETURN(guid,0x583ea3f5,0x86d0,0x4b08,0xa6,0xec,0x2c,0x54,0x63,0xff,0xc1,0x09,"GridItem_ColumnSpan_Property_GUID"); + IF_GUID_EQUAL_RETURN(guid,0xc774c15c,0x62c0,0x4519,0x8b,0xdc,0x47,0xbe,0x57,0x3c,0x8a,0xd5,"GridItem_Column_Property_GUID"); + IF_GUID_EQUAL_RETURN(guid,0x9d912252,0xb97f,0x4ecc,0x85,0x10,0xea,0x0e,0x33,0x42,0x7c,0x72,"GridItem_Parent_Property_GUID"); + IF_GUID_EQUAL_RETURN(guid,0xf2d5c877,0xa462,0x4957,0xa2,0xa5,0x2c,0x96,0xb3,0x03,0xbc,0x63,"GridItem_Pattern_GUID"); + IF_GUID_EQUAL_RETURN(guid,0x4582291c,0x466b,0x4e93,0x8e,0x83,0x3d,0x17,0x15,0xec,0x0c,0x5e,"GridItem_RowSpan_Property_GUID"); + IF_GUID_EQUAL_RETURN(guid,0x6223972a,0xc945,0x4563,0x93,0x29,0xfd,0xc9,0x74,0xaf,0x25,0x53,"GridItem_Row_Property_GUID"); + IF_GUID_EQUAL_RETURN(guid,0xfe96f375,0x44aa,0x4536,0xac,0x7a,0x2a,0x75,0xd7,0x1a,0x3e,0xfc,"Grid_ColumnCount_Property_GUID"); + IF_GUID_EQUAL_RETURN(guid,0x260a2ccb,0x93a8,0x4e44,0xa4,0xc1,0x3d,0xf3,0x97,0xf2,0xb0,0x2b,"Grid_Pattern_GUID"); + IF_GUID_EQUAL_RETURN(guid,0x2a9505bf,0xc2eb,0x4fb6,0xb3,0x56,0x82,0x45,0xae,0x53,0x70,0x3e,"Grid_RowCount_Property_GUID"); + IF_GUID_EQUAL_RETURN(guid,0xad50aa1c,0xe8c8,0x4774,0xae,0x1b,0xdd,0x86,0xdf,0x0b,0x3b,0xdc,"Group_Control_GUID"); + IF_GUID_EQUAL_RETURN(guid,0xcf8afd39,0x3f46,0x4800,0x96,0x56,0xb2,0xbf,0x12,0x52,0x99,0x05,"HasKeyboardFocus_Property_GUID"); + IF_GUID_EQUAL_RETURN(guid,0xe6bc12cb,0x7c8e,0x49cf,0xb1,0x68,0x4a,0x93,0xa3,0x2b,0xeb,0xb0,"HeaderItem_Control_GUID"); + IF_GUID_EQUAL_RETURN(guid,0x5b90cbce,0x78fb,0x4614,0x82,0xb6,0x55,0x4d,0x74,0x71,0x8e,0x67,"Header_Control_GUID"); + IF_GUID_EQUAL_RETURN(guid,0x08555685,0x0977,0x45c7,0xa7,0xa6,0xab,0xaf,0x56,0x84,0x12,0x1a,"HelpText_Property_GUID"); + IF_GUID_EQUAL_RETURN(guid,0xe6bdb03e,0x0921,0x4ec5,0x8d,0xcf,0xea,0xe8,0x77,0xb0,0x42,0x6b,"HostedFragmentRootsInvalidated_Event_GUID"); + IF_GUID_EQUAL_RETURN(guid,0x8a56022c,0xb00d,0x4d15,0x8f,0xf0,0x5b,0x6b,0x26,0x6e,0x5e,0x02,"Hyperlink_Control_GUID"); + IF_GUID_EQUAL_RETURN(guid,0x9cae40a8,0xded1,0x41c9,0xa9,0xfd,0xd7,0x35,0xef,0x33,0xae,0xda,"ID_DOCUMENTPACKAGETARGET_MSXPS"); + IF_GUID_EQUAL_RETURN(guid,0x0056bb72,0x8c9c,0x4612,0xbd,0x0f,0x93,0x01,0x2a,0x87,0x09,0x9d,"ID_DOCUMENTPACKAGETARGET_OPENXPS"); + IF_GUID_EQUAL_RETURN(guid,0xa9e69613,0xb80d,0x11d0,0xb9,0xb9,0x00,0xa0,0xc9,0x22,0xe7,0x50,"IID_AsyncIMSAdminBaseSink_W"); + IF_GUID_EQUAL_RETURN(guid,0x4434FF80,0xEF4C,0x11CE,0xAE,0x65,0x08,0x00,0x2B,0x2E,0x12,0x62,"IID_CDefView"); + IF_GUID_EQUAL_RETURN(guid,0xe4a36723,0xfdfe,0x4b22,0xb1,0x46,0x3c,0x4,0xc0,0x7f,0x4c,0xc8,"IID_HelperName"); + IF_GUID_EQUAL_RETURN(guid,0x470141a0L,0x5186,0x11d2,0xbb,0xb6,0x00,0x60,0x97,0x7b,0x46,0x4c,"IID_IACList2"); + IF_GUID_EQUAL_RETURN(guid,0x77A130B0L,0x94FD,0x11D0,0xA5,0x44,0x00,0xC0,0x4F,0xD7,0xd0,0x62,"IID_IACList"); + IF_GUID_EQUAL_RETURN(guid,0x51dfe970,0xf6f2,0x11d0,0xb9,0xbd,0x0,0xa0,0xc9,0x22,0xe7,0x50,"IID_IADMEXT"); + IF_GUID_EQUAL_RETURN(guid,0xb22754e2,0x4574,0x11d1,0x98,0x88,0x0,0x60,0x97,0xde,0xac,0xf9,"IID_IADesktopP2"); + IF_GUID_EQUAL_RETURN(guid,0x56a868b9,0x0ad4,0x11ce,0xb0,0x3a,0x00,0x20,0xaf,0x0b,0xa7,0x70,"IID_IAMCollection"); + IF_GUID_EQUAL_RETURN(guid,0x546f4260,0xd53e,0x11cf,0xb3,0xf0,0x0,0xaa,0x0,0x37,0x61,0xc5,"IID_IAMDirectSound"); + IF_GUID_EQUAL_RETURN(guid,0x6e8d4a21,0x310c,0x11d0,0xb7,0x9a,0x0,0xaa,0x0,0x37,0x67,0xa7,"IID_IAMLine21Decoder"); + IF_GUID_EQUAL_RETURN(guid,0x56a868fe,0x0ad4,0x11ce,0xb0,0xa3,0x0,0x20,0xaf,0x0b,0xa7,0x70,"IID_IAMPlayList"); + IF_GUID_EQUAL_RETURN(guid,0x56a868ff,0x0ad4,0x11ce,0xb0,0xa3,0x0,0x20,0xaf,0x0b,0xa7,0x70,"IID_IAMPlayListItem"); + IF_GUID_EQUAL_RETURN(guid,0x2ef04dd,0x7580,0x11d1,0xbe,0xce,0x0,0xc0,0x4f,0xb6,0xe9,0x37,"IID_IAMRebuild"); + IF_GUID_EQUAL_RETURN(guid,0xbc9bcf80,0xdcd2,0x11d2,0xab,0xf6,0x00,0xa0,0xc9,0x05,0xf3,0x75,"IID_IAMStats"); + IF_GUID_EQUAL_RETURN(guid,0x6dd816d7,0xe740,0x4123,0x9e,0x24,0x24,0x44,0x41,0x26,0x44,0xd8,"IID_IAMWMBufferPass"); + IF_GUID_EQUAL_RETURN(guid,0xb25b8372,0xd2d2,0x44b2,0x86,0x53,0x1b,0x8d,0xae,0x33,0x24,0x89,"IID_IAMWMBufferPassCallback"); + IF_GUID_EQUAL_RETURN(guid,0xc056de21,0x75c2,0x11d3,0xa1,0x84,0x0,0x10,0x5a,0xef,0x9f,0x33,"IID_IAMWstDecoder"); + IF_GUID_EQUAL_RETURN(guid,0xF5A6893E,0xA0F5,0x11d1,0x8C,0x4B,0x00,0xC0,0x4F,0xC3,0x24,0xA4,"IID_IASPError"); + IF_GUID_EQUAL_RETURN(guid,0x00020024,0,0,0xC0,0,0,0,0,0,0,0x46,"IID_IAVIEditStream"); + IF_GUID_EQUAL_RETURN(guid,0x00020020,0,0,0xC0,0,0,0,0,0,0,0x46,"IID_IAVIFile"); + IF_GUID_EQUAL_RETURN(guid,0x00020025,0,0,0xC0,0,0,0,0,0,0,0x46,"IID_IAVIPersistFile"); + IF_GUID_EQUAL_RETURN(guid,0x00020021,0,0,0xC0,0,0,0,0,0,0,0x46,"IID_IAVIStream"); + IF_GUID_EQUAL_RETURN(guid,0x00020022,0,0,0xC0,0,0,0,0,0,0,0x46,"IID_IAVIStreaming"); + IF_GUID_EQUAL_RETURN(guid,0x4C896039,0x7B6D,0x49e6,0xA8,0xC1,0x45,0x11,0x6A,0x98,0x29,0x2B,"IID_IAccClientDocMgr"); + IF_GUID_EQUAL_RETURN(guid,0x1DC4CB5F,0xD737,0x474d,0xAD,0xE9,0x5C,0xCF,0xC9,0xBC,0x1C,0xC9,"IID_IAccDictionary"); + IF_GUID_EQUAL_RETURN(guid,0x7852b78d,0x1cfd,0x41c1,0xa6,0x15,0x9c,0x0c,0x85,0x96,0x0b,0x5f,"IID_IAccIdentity"); + IF_GUID_EQUAL_RETURN(guid,0x2bd370a9,0x3e7f,0x4edd,0x8a,0x85,0xf8,0xfe,0xd1,0xf8,0xe5,0x1f,"IID_IAccPropMgrInternal"); + IF_GUID_EQUAL_RETURN(guid,0x76c0dbbb,0x15e0,0x4e7b,0xb6,0x1b,0x20,0xee,0xea,0x20,0x01,0xe0,"IID_IAccPropServer"); + IF_GUID_EQUAL_RETURN(guid,0x6e26e776,0x04f0,0x495d,0x80,0xe4,0x33,0x30,0x35,0x2e,0x31,0x69,"IID_IAccPropServices"); + IF_GUID_EQUAL_RETURN(guid,0xAD7C73CF,0x6DD5,0x4855,0xAB,0xC2,0xB0,0x4B,0xAD,0x5B,0x91,0x53,"IID_IAccServerDocMgr"); + IF_GUID_EQUAL_RETURN(guid,0xE2CD4A63,0x2B72,0x4D48,0xB7,0x39,0x95,0xE4,0x76,0x51,0x95,0xBA,"IID_IAccStore"); + IF_GUID_EQUAL_RETURN(guid,0x618736e0,0x3c3d,0x11cf,0x81,0x0c,0x00,0xaa,0x00,0x38,0x9b,0x71,"IID_IAccessible"); + IF_GUID_EQUAL_RETURN(guid,0x03022430,0xABC4,0x11d0,0xBD,0xE2,0x00,0xAA,0x00,0x1A,0x19,0x53,"IID_IAccessibleHandler"); + IF_GUID_EQUAL_RETURN(guid,0x607BE24B,0xD91B,0x4E28,0xA2,0x42,0x61,0x87,0x1C,0xE5,0x6E,0x35,"IID_IActionOnCLREvent"); + IF_GUID_EQUAL_RETURN(guid,0xF490EB00L,0x1240,0x11D1,0x98,0x88,0x00,0x60,0x97,0xDE,0xAC,0xF9,"IID_IActiveDesktop"); + IF_GUID_EQUAL_RETURN(guid,0x52502EE0L,0xEC80,0x11D0,0x89,0xAB,0x00,0xC0,0x4F,0xC2,0x97,0x2D,"IID_IActiveDesktopP"); + IF_GUID_EQUAL_RETURN(guid,0xbb1a2ae1,0xa4f9,0x11cf,0x8f,0x20,0x00,0x80,0x5f,0x2c,0xd0,0x64,"IID_IActiveScript"); + IF_GUID_EQUAL_RETURN(guid,0x9c109da0,0x7006,0x11d1,0xb3,0x6c,0x00,0xa0,0xc9,0x11,0xe8,0xb2,"IID_IActiveScriptAuthor"); + IF_GUID_EQUAL_RETURN(guid,0x7e2d4b70,0xbd9a,0x11d0,0x93,0x36,0x0,0xa0,0xc9,0xd,0xca,0xa9,"IID_IActiveScriptAuthorProcedure"); + IF_GUID_EQUAL_RETURN(guid,0xbb1a2ae3,0xa4f9,0x11cf,0x8f,0x20,0x00,0x80,0x5f,0x2c,0xd0,0x64,"IID_IActiveScriptEncode"); + IF_GUID_EQUAL_RETURN(guid,0xb21fb2a1,0x5b8f,0x4963,0x8c,0x21,0x21,0x45,0x0f,0x84,0xed,0x7f,"IID_IActiveScriptError64"); + IF_GUID_EQUAL_RETURN(guid,0xeae1ba61,0xa4ed,0x11cf,0x8f,0x20,0x00,0x80,0x5f,0x2c,0xd0,0x64,"IID_IActiveScriptError"); + IF_GUID_EQUAL_RETURN(guid,0x6aa2c4a0,0x2b53,0x11d4,0xa2,0xa0,0x00,0x10,0x4b,0xd3,0x50,0x90,"IID_IActiveScriptGarbageCollector"); + IF_GUID_EQUAL_RETURN(guid,0xbee9b76e,0xcfe3,0x11d1,0xb7,0x47,0x00,0xc0,0x4f,0xc2,0xb0,0x85,"IID_IActiveScriptHostEncode"); + IF_GUID_EQUAL_RETURN(guid,0xbb1a2ae2,0xa4f9,0x11cf,0x8f,0x20,0x00,0x80,0x5f,0x2c,0xd0,0x64,"IID_IActiveScriptParse32"); + IF_GUID_EQUAL_RETURN(guid,0xc7ef7658,0xe1ee,0x480e,0x97,0xea,0xd5,0x2c,0xb4,0xd7,0x6d,0x17,"IID_IActiveScriptParse64"); + IF_GUID_EQUAL_RETURN(guid,0x71ee5b20,0xfb04,0x11d1,0xb3,0xa8,0x00,0xa0,0xc9,0x11,0xe8,0xb2,"IID_IActiveScriptParseProcedure2_32"); + IF_GUID_EQUAL_RETURN(guid,0xfe7c4271,0x210c,0x448d,0x9f,0x54,0x76,0xda,0xb7,0x04,0x7b,0x28,"IID_IActiveScriptParseProcedure2_64"); + IF_GUID_EQUAL_RETURN(guid,0xaa5b6a80,0xb834,0x11d0,0x93,0x2f,0x00,0xa0,0xc9,0x0d,0xca,0xa9,"IID_IActiveScriptParseProcedure32"); + IF_GUID_EQUAL_RETURN(guid,0xc64713b6,0xe029,0x4cc5,0x92,0x00,0x43,0x8b,0x72,0x89,0x0b,0x6a,"IID_IActiveScriptParseProcedure64"); + IF_GUID_EQUAL_RETURN(guid,0x1cff0050,0x6fdd,0x11d0,0x93,0x28,0x00,0xa0,0xc9,0x0d,0xca,0xa9,"IID_IActiveScriptParseProcedureOld32"); + IF_GUID_EQUAL_RETURN(guid,0x21f57128,0x08c9,0x4638,0xba,0x12,0x22,0xd1,0x5d,0x88,0xdc,0x5c,"IID_IActiveScriptParseProcedureOld64"); + IF_GUID_EQUAL_RETURN(guid,0xb403015,0xf381,0x4023,0xa5,0xd0,0x6f,0xed,0x7,0x6d,0xe7,0x16,"IID_IActiveScriptProfilerControl3"); + IF_GUID_EQUAL_RETURN(guid,0x32e4694e,0xd37,0x419b,0xb9,0x3d,0xfa,0x20,0xde,0xd6,0xe8,0xea,"IID_IActiveScriptProfilerHeapEnum"); + IF_GUID_EQUAL_RETURN(guid,0x4954E0D0,0xFBC7,0x11D1,0x84,0x10,0x00,0x60,0x08,0xC3,0xFB,0xFC,"IID_IActiveScriptProperty"); + IF_GUID_EQUAL_RETURN(guid,0x764651d0,0x38de,0x11d4,0xa2,0xa3,0x00,0x10,0x4b,0xd3,0x50,0x90,"IID_IActiveScriptSIPInfo"); + IF_GUID_EQUAL_RETURN(guid,0xdb01a1e3,0xa42b,0x11cf,0x8f,0x20,0x00,0x80,0x5f,0x2c,0xd0,0x64,"IID_IActiveScriptSite"); + IF_GUID_EQUAL_RETURN(guid,0x539698a0,0xcdca,0x11cf,0xa5,0xeb,0x00,0xaa,0x00,0x47,0xa0,0x63,"IID_IActiveScriptSiteInterruptPoll"); + IF_GUID_EQUAL_RETURN(guid,0x4b7272ae,0x1955,0x4bfe,0x98,0xb0,0x78,0x6,0x21,0x88,0x85,0x69,"IID_IActiveScriptSiteTraceInfo"); + IF_GUID_EQUAL_RETURN(guid,0xaedae97e,0xd7ee,0x4796,0xb9,0x60,0x7f,0x9,0x2a,0xe8,0x44,0xab,"IID_IActiveScriptSiteUIControl"); + IF_GUID_EQUAL_RETURN(guid,0xd10f6761,0x83e9,0x11cf,0x8f,0x20,0x00,0x80,0x5f,0x2c,0xd0,0x64,"IID_IActiveScriptSiteWindow"); + IF_GUID_EQUAL_RETURN(guid,0xb8da6310,0xe19b,0x11d0,0x93,0x3c,0x00,0xa0,0xc9,0x0d,0xca,0xa9,"IID_IActiveScriptStats"); + IF_GUID_EQUAL_RETURN(guid,0x58562769,0xED52,0x42f7,0x84,0x03,0x49,0x63,0x51,0x4E,0x1F,0x11,"IID_IActiveScriptStringCompare"); + IF_GUID_EQUAL_RETURN(guid,0xC35456E7,0xBEBF,0x4a1b,0x86,0xA9,0x24,0xD5,0x6B,0xE8,0xB3,0x69,"IID_IActiveScriptTraceInfo"); + IF_GUID_EQUAL_RETURN(guid,0x0feb7e34,0x5a60,0x4356,0x8e,0xf7,0xab,0xde,0xc2,0xff,0x7c,0xf8,"IID_IAnchor"); + IF_GUID_EQUAL_RETURN(guid,0x178e5337,0x1528,0x4591,0xb1,0xc9,0x1c,0x6e,0x48,0x46,0x86,0xd8,"IID_IApartmentCallback"); + IF_GUID_EQUAL_RETURN(guid,0xD97A6DA0,0xA866,0x11cf,0x83,0xAE,0x10,0xA0,0xC9,0x0C,0x2B,0xD8,"IID_IApplicationObject"); + IF_GUID_EQUAL_RETURN(guid,0xE707DCDE,0xD1CD,0x11D2,0xBA,0xB9,0x00,0xC0,0x4F,0x8E,0xCE,0xAE,"IID_IAssemblyCache"); + IF_GUID_EQUAL_RETURN(guid,0x9e3aaeb4,0xd1cd,0x11d2,0xba,0xb9,0x00,0xc0,0x4f,0x8e,0xce,0xae,"IID_IAssemblyCacheItem"); + IF_GUID_EQUAL_RETURN(guid,0x21B8916C,0xF28E,0x11D2,0xA4,0x73,0x00,0xC0,0x4F,0x8E,0xF4,0x48,"IID_IAssemblyEnum"); + IF_GUID_EQUAL_RETURN(guid,0xCD193BC0,0xB4BC,0x11d2,0x98,0x33,0x00,0xC0,0x4F,0xC3,0x1D,0x2E,"IID_IAssemblyName"); + IF_GUID_EQUAL_RETURN(guid,0xf5f2893a,0xba9e,0x11d0,0xab,0xb9,0x0,0xc0,0x4f,0xc2,0x9f,0x8f,"IID_IAsyncAllowed"); + IF_GUID_EQUAL_RETURN(guid,0x4A2f5C31,0xCFD9,0x410E,0xB7,0xFB,0x29,0xA6,0x53,0x97,0x3A,0xF,"IID_IAutomaticUpdates2"); + IF_GUID_EQUAL_RETURN(guid,0x673425bf,0xc082,0x4c7c,0xbd,0xfd,0x56,0x94,0x64,0xb8,0xe0,0xce,"IID_IAutomaticUpdates"); + IF_GUID_EQUAL_RETURN(guid,0xe7a4d634,0x7942,0x4DD9,0xA1,0x11,0x82,0x22,0x8b,0xa3,0x39,0x1,"IID_IAutomaticUpdatesResults"); + IF_GUID_EQUAL_RETURN(guid,0x6abc136a,0xc3ca,0x4384,0x81,0x71,0xcb,0x2b,0x1e,0x59,0xb8,0xdc,"IID_IAutomaticUpdatesSettings2"); + IF_GUID_EQUAL_RETURN(guid,0xb587f5c3,0xf57e,0x485f,0xbb,0xf5,0x0d,0x18,0x1c,0x5c,0xd0,0xdc,"IID_IAutomaticUpdatesSettings3"); + IF_GUID_EQUAL_RETURN(guid,0x2ee48f22,0xaf3c,0x405f,0x89,0x70,0xf7,0x1b,0xe1,0x2e,0xe9,0xa2,"IID_IAutomaticUpdatesSettings"); + IF_GUID_EQUAL_RETURN(guid,0x181c845e,0x7196,0x4a7d,0xac,0x2e,0x02,0x0c,0x0b,0xb7,0xa3,0x03,"IID_IAzApplication3"); + IF_GUID_EQUAL_RETURN(guid,0xb11e5584,0xd577,0x4273,0xb6,0xc5,0x9,0x73,0xe0,0xf8,0xe8,0xd,"IID_IAzAuthorizationStore2"); + IF_GUID_EQUAL_RETURN(guid,0xabc08425,0x0c86,0x4fa0,0x9b,0xe3,0x71,0x89,0x95,0x6c,0x92,0x6e,"IID_IAzAuthorizationStore3"); + IF_GUID_EQUAL_RETURN(guid,0xedbd9ca9,0x9b82,0x4f6a,0x9e,0x8b,0x98,0x30,0x1e,0x45,0x0f,0x14,"IID_IAzAuthorizationStore"); + IF_GUID_EQUAL_RETURN(guid,0xe192f17d,0xd59f,0x455e,0xa1,0x52,0x94,0x03,0x16,0xcd,0x77,0xb2,"IID_IAzBizRuleContext"); + IF_GUID_EQUAL_RETURN(guid,0x504d0f15,0x73e2,0x43df,0xa8,0x70,0xa6,0x4f,0x40,0x71,0x4f,0x53,"IID_IAzNameResolver"); + IF_GUID_EQUAL_RETURN(guid,0x63130a48,0x699a,0x42d8,0xbf,0x01,0xc6,0x2a,0xc3,0xfb,0x79,0xf9,"IID_IAzObjectPicker"); + IF_GUID_EQUAL_RETURN(guid,0xe5c3507d,0xad6a,0x4992,0x9c,0x7f,0x74,0xab,0x48,0x0b,0x44,0xcc,"IID_IAzPrincipalLocator"); + IF_GUID_EQUAL_RETURN(guid,0x596a9a94,0x13e,0x11d1,0x8d,0x34,0x0,0xa0,0xc9,0xf,0x27,0x19,"IID_IBanneredBar"); + IF_GUID_EQUAL_RETURN(guid,0x61ded640,0xe912,0x11ce,0xa0,0x99,0x00,0xaa,0x00,0x47,0x9a,0x58,"IID_IBaseVideoMixer"); + IF_GUID_EQUAL_RETURN(guid,0x56a868b3,0x0ad4,0x11ce,0xb0,0x3a,0x00,0x20,0xaf,0x0b,0xa7,0x70,"IID_IBasicAudio"); + IF_GUID_EQUAL_RETURN(guid,0x329bb360,0xf6ea,0x11d1,0x90,0x38,0x00,0xa0,0xc9,0x69,0x72,0x98,"IID_IBasicVideo2"); + IF_GUID_EQUAL_RETURN(guid,0x56a868b5,0x0ad4,0x11ce,0xb0,0x3a,0x00,0x20,0xaf,0x0b,0xa7,0x70,"IID_IBasicVideo"); + IF_GUID_EQUAL_RETURN(guid,0x63cdbcb0,0xc1b1,0x11d0,0x93,0x36,0x00,0xa0,0xc9,0x0d,0xca,0xa9,"IID_IBindEventHandler"); + IF_GUID_EQUAL_RETURN(guid,0x1e00486a,0x78dd,0x11d2,0x8d,0xd3,0x0,0x60,0x97,0xc9,0xa2,0xb2,"IID_IBufferingTime"); + IF_GUID_EQUAL_RETURN(guid,0XC62DE18C,0X2E23,0X4AEA,0X84,0X23,0XB4,0X0C,0X1F,0XC5,0X9E,0XAE,"IID_ICLRAppDomainResourceMonitor"); + IF_GUID_EQUAL_RETURN(guid,0x15f0a9da,0x3ff6,0x4393,0x9d,0xa9,0xfd,0xfd,0x28,0x4e,0x69,0x72,"IID_ICLRAssemblyIdentityManager"); + IF_GUID_EQUAL_RETURN(guid,0x1b2c9750,0x2e66,0x4bda,0x8b,0x44,0x0a,0x64,0x2c,0x5c,0xd7,0x33,"IID_ICLRAssemblyReferenceList"); + IF_GUID_EQUAL_RETURN(guid,0x9065597E,0xD1A1,0x4fb2,0xB6,0xBA,0x7E,0x1F,0xCE,0x23,0x0F,0x61,"IID_ICLRControl"); + IF_GUID_EQUAL_RETURN(guid,0xdcaec6,0x2ac0,0x43a9,0xac,0xf9,0x1e,0x36,0xc1,0x39,0xb1,0xd,"IID_ICLRDebugManager"); + IF_GUID_EQUAL_RETURN(guid,0xd28f3c5a,0x9634,0x4206,0xa5,0x9,0x47,0x75,0x52,0xee,0xfb,0x10,"IID_ICLRDebugging"); + IF_GUID_EQUAL_RETURN(guid,0x3151c08d,0x4d09,0x4f9b,0x88,0x38,0x28,0x80,0xbf,0x18,0xfe,0x51,"IID_ICLRDebuggingLibraryProvider"); + IF_GUID_EQUAL_RETURN(guid,0x270d00a2,0x8e15,0x4d0b,0xad,0xeb,0x37,0xbc,0x3e,0x47,0xdf,0x77,"IID_ICLRDomainManager"); + IF_GUID_EQUAL_RETURN(guid,0x980d2f1a,0xbf79,0x4c08,0x81,0x2a,0xbb,0x97,0x78,0x92,0x8f,0x78,"IID_ICLRErrorReportingManager"); + IF_GUID_EQUAL_RETURN(guid,0x0603B793,0xA97A,0x4712,0x9C,0xB4,0x0C,0xD1,0xC7,0x4C,0x0F,0x7C,"IID_ICLRGCManager2"); + IF_GUID_EQUAL_RETURN(guid,0x54D9007E,0xA8E2,0x4885,0xB7,0xBF,0xF9,0x98,0xDE,0xEE,0x4F,0x2A,"IID_ICLRGCManager"); + IF_GUID_EQUAL_RETURN(guid,0x4b3545e7,0x1856,0x48c9,0xa8,0xba,0x24,0xb2,0x1a,0x75,0x3c,0x09,"IID_ICLRHostBindingPolicyManager"); + IF_GUID_EQUAL_RETURN(guid,0x89f25f5c,0xceef,0x43e1,0x9c,0xfa,0xa6,0x8c,0xe8,0x63,0xaa,0xac,"IID_ICLRHostProtectionManager"); + IF_GUID_EQUAL_RETURN(guid,0x2D74CE86,0xB8D6,0x4C84,0xB3,0xA7,0x97,0x68,0x93,0x3B,0x3C,0x12,"IID_ICLRIoCompletionManager"); + IF_GUID_EQUAL_RETURN(guid,0x47EB8E57,0x0846,0x4546,0xAF,0x76,0x6F,0x42,0xFC,0xFC,0x26,0x49,"IID_ICLRMemoryNotificationCallback"); + IF_GUID_EQUAL_RETURN(guid,0xD332DB9E,0xB9B3,0x4125,0x82,0x07,0xA1,0x48,0x84,0xF5,0x32,0x16,"IID_ICLRMetaHost"); + IF_GUID_EQUAL_RETURN(guid,0xE2190695,0x77B2,0x492e,0x8E,0x14,0xC4,0xB3,0xA7,0xFD,0xD5,0x93,"IID_ICLRMetaHostPolicy"); + IF_GUID_EQUAL_RETURN(guid,0x1D0E0132,0xE64F,0x493D,0x92,0x60,0x02,0x5C,0x0E,0x32,0xC1,0x75,"IID_ICLROnEventManager"); + IF_GUID_EQUAL_RETURN(guid,0x7D290010,0xD781,0x45da,0xA6,0xF8,0xAA,0x5D,0x71,0x1A,0x73,0x0E,"IID_ICLRPolicyManager"); + IF_GUID_EQUAL_RETURN(guid,0xd0c5fb1f,0x416b,0x4f97,0x81,0xf4,0x7a,0xc7,0xdc,0x24,0xdd,0x5d,"IID_ICLRProbingAssemblyEnum"); + IF_GUID_EQUAL_RETURN(guid,0xb349abe3,0xb56f,0x4689,0xbf,0xcd,0x76,0xbf,0x39,0xd8,0x88,0xea,"IID_ICLRProfiling"); + IF_GUID_EQUAL_RETURN(guid,0xd509cb5d,0xcf32,0x4876,0xae,0x61,0x67,0x77,0x0c,0xf9,0x19,0x73,"IID_ICLRReferenceAssemblyEnum"); + IF_GUID_EQUAL_RETURN(guid,0x90F1A06C,0x7712,0x4762,0x86,0xB5,0x7A,0x5E,0xBA,0x6B,0xDB,0x02,"IID_ICLRRuntimeHost"); + IF_GUID_EQUAL_RETURN(guid,0xBD39D1D2,0xBA2F,0x486a,0x89,0xB0,0xB4,0xB0,0xCB,0x46,0x68,0x91,"IID_ICLRRuntimeInfo"); + IF_GUID_EQUAL_RETURN(guid,0xC22ED5C5,0x4B59,0x4975,0x90,0xEB,0x85,0xEA,0x55,0xC0,0x06,0x9B,"IID_ICLRStrongName2"); + IF_GUID_EQUAL_RETURN(guid,0x9FD93CCF,0x3280,0x4391,0xB3,0xA9,0x96,0xE1,0xCD,0xE7,0x7C,0x8D,"IID_ICLRStrongName"); + IF_GUID_EQUAL_RETURN(guid,0x55FF199D,0xAD21,0x48f9,0xa1,0x6c,0xf2,0x4e,0xbb,0xb8,0x72,0x7d,"IID_ICLRSyncManager"); + IF_GUID_EQUAL_RETURN(guid,0x28E66A4A,0x9906,0x4225,0xB2,0x31,0x91,0x87,0xc3,0xeb,0x86,0x12,"IID_ICLRTask2"); + IF_GUID_EQUAL_RETURN(guid,0x28E66A4A,0x9906,0x4225,0xB2,0x31,0x91,0x87,0xc3,0xeb,0x86,0x11,"IID_ICLRTask"); + IF_GUID_EQUAL_RETURN(guid,0x4862efbe,0x3ae5,0x44f8,0x8F,0xEB,0x34,0x61,0x90,0xeE,0x8A,0x34,"IID_ICLRTaskManager"); + IF_GUID_EQUAL_RETURN(guid,0xc5598e60,0xb307,0x11d1,0xb2,0x7d,0x0,0x60,0x08,0xc3,0xfb,0xfb,"IID_ICanHandleException"); + IF_GUID_EQUAL_RETURN(guid,0x04c6be1e,0x1db1,0x4058,0xab,0x7a,0x70,0x0c,0xcc,0xfb,0xf2,0x54,"IID_ICatalogServices"); + IF_GUID_EQUAL_RETURN(guid,0x81ddc1b8,0x9d35,0x47a6,0xb4,0x71,0x5b,0x80,0xf5,0x19,0x22,0x3b,"IID_ICategory"); + IF_GUID_EQUAL_RETURN(guid,0x3a56bfb8,0x576c,0x43f7,0x93,0x35,0xfe,0x48,0x38,0xfd,0x7e,0x37,"IID_ICategoryCollection"); + IF_GUID_EQUAL_RETURN(guid,0x7ed1bdff,0x8e36,0x11d2,0x9c,0x56,0x0,0xa0,0xc9,0xb7,0xcc,0x45,"IID_ICeeGen"); + IF_GUID_EQUAL_RETURN(guid,0xB33E75FF,0xE84C,0x4dca,0xA2,0x5C,0x33,0xB8,0xDC,0x00,0x33,0x74,"IID_IClonableWrapper"); + IF_GUID_EQUAL_RETURN(guid,0x03DE00AA,0xF272,0x41e3,0x99,0xCB,0x03,0xC5,0xE8,0x11,0x4E,0xA0,"IID_ICoCreateLocally"); + IF_GUID_EQUAL_RETURN(guid,0x0A53EB6C,0x1908,0x4742,0x8C,0xFF,0x2C,0xEE,0x2E,0x93,0xF9,0x4C,"IID_ICoCreatedLocally"); + IF_GUID_EQUAL_RETURN(guid,0xe8025004,0x1c42,0x11d2,0xbe,0x2c,0x0,0xa0,0xc9,0xa8,0x3d,0xa1,"IID_IColumnProvider"); + IF_GUID_EQUAL_RETURN(guid,0x7989ccaa,0x53f0,0x44f0,0x88,0x4a,0xf3,0xb0,0x3f,0x6a,0xe0,0x66,"IID_IConfigAsfWriter2"); + IF_GUID_EQUAL_RETURN(guid,0x45086030,0xF7E4,0x486a,0xB5,0x04,0x82,0x6B,0xB5,0x79,0x2A,0x3B,"IID_IConfigAsfWriter"); + IF_GUID_EQUAL_RETURN(guid,0x5c2b07a5,0x1e98,0x11d3,0x87,0x2f,0x00,0xc0,0x4f,0x79,0xed,0x0d,"IID_ICorConfiguration"); + IF_GUID_EQUAL_RETURN(guid,0xcb2f6722,0xab3a,0x11d2,0x9c,0x40,0x00,0xc0,0x4f,0xa3,0x0a,0x3e,"IID_ICorRuntimeHost"); + IF_GUID_EQUAL_RETURN(guid,0x84680D3A,0xB2C1,0x46e8,0xAC,0xC2,0xDB,0xC0,0xA3,0x59,0x15,0x9A,"IID_ICorThreadpool"); + IF_GUID_EQUAL_RETURN(guid,0xeefcd4e1,0xea1c,0x4435,0xb7,0xf4,0xe3,0x41,0xba,0x03,0xb4,0xf9,"IID_ICounterItem2"); + IF_GUID_EQUAL_RETURN(guid,0x771A9520,0xEE28,0x11ce,0x94,0x1E,0x00,0x80,0x29,0x00,0x43,0x47,"IID_ICounterItem"); + IF_GUID_EQUAL_RETURN(guid,0x79167962,0x28FC,0x11cf,0x94,0x2F,0x00,0x80,0x29,0x00,0x43,0x47,"IID_ICounters"); + IF_GUID_EQUAL_RETURN(guid,0x91956d21L,0x9276,0x11d1,0x92,0x1a,0x00,0x60,0x97,0xdf,0x5b,0xd4,"IID_ICurrentWorkingDirectory"); + IF_GUID_EQUAL_RETURN(guid,0x9B7E4C0D,0x342C,0x4106,0xA1,0x9F,0x4F,0x27,0x04,0xF6,0x89,0xF0,"IID_ID3D10Asynchronous"); + IF_GUID_EQUAL_RETURN(guid,0xEDAD8D99,0x8A35,0x4d6d,0x85,0x66,0x2E,0xA2,0x76,0xCD,0xE1,0x61,"IID_ID3D10BlendState1"); + IF_GUID_EQUAL_RETURN(guid,0xEDAD8D19,0x8A35,0x4d6d,0x85,0x66,0x2E,0xA2,0x76,0xCD,0xE1,0x61,"IID_ID3D10BlendState"); + IF_GUID_EQUAL_RETURN(guid,0x8ba5fb08,0x5195,0x40e2,0xac,0x58,0xd,0x98,0x9c,0x3a,0x1,0x2,"IID_ID3D10Blob"); + IF_GUID_EQUAL_RETURN(guid,0x9B7E4C02,0x342C,0x4106,0xA1,0x9F,0x4F,0x27,0x04,0xF6,0x89,0xF0,"IID_ID3D10Buffer"); + IF_GUID_EQUAL_RETURN(guid,0x9B7E4C11,0x342C,0x4106,0xA1,0x9F,0x4F,0x27,0x04,0xF6,0x89,0xF0,"IID_ID3D10Counter"); + IF_GUID_EQUAL_RETURN(guid,0x9B7E4E01,0x342C,0x4106,0xA1,0x9F,0x4F,0x27,0x04,0xF6,0x89,0xF0,"IID_ID3D10Debug"); + IF_GUID_EQUAL_RETURN(guid,0x2B4B1CC8,0xA4AD,0x41f8,0x83,0x22,0xCA,0x86,0xFC,0x3E,0xC6,0x75,"IID_ID3D10DepthStencilState"); + IF_GUID_EQUAL_RETURN(guid,0x9B7E4C09,0x342C,0x4106,0xA1,0x9F,0x4F,0x27,0x04,0xF6,0x89,0xF0,"IID_ID3D10DepthStencilView"); + IF_GUID_EQUAL_RETURN(guid,0x9B7E4C8F,0x342C,0x4106,0xA1,0x9F,0x4F,0x27,0x04,0xF6,0x89,0xF0,"IID_ID3D10Device1"); + IF_GUID_EQUAL_RETURN(guid,0x9B7E4C0F,0x342C,0x4106,0xA1,0x9F,0x4F,0x27,0x04,0xF6,0x89,0xF0,"IID_ID3D10Device"); + IF_GUID_EQUAL_RETURN(guid,0x9B7E4C00,0x342C,0x4106,0xA1,0x9F,0x4F,0x27,0x04,0xF6,0x89,0xF0,"IID_ID3D10DeviceChild"); + IF_GUID_EQUAL_RETURN(guid,0x51b0ca8b,0xec0b,0x4519,0x87,0xd,0x8e,0xe1,0xcb,0x50,0x17,0xc7,"IID_ID3D10Effect"); + IF_GUID_EQUAL_RETURN(guid,0x1fcd2294,0xdf6d,0x4eae,0x86,0xb3,0xe,0x91,0x60,0xcf,0xb0,0x7b,"IID_ID3D10EffectBlendVariable"); + IF_GUID_EQUAL_RETURN(guid,0x56648f4d,0xcc8b,0x4444,0xa5,0xad,0xb5,0xa3,0xd7,0x6e,0x91,0xb3,"IID_ID3D10EffectConstantBuffer"); + IF_GUID_EQUAL_RETURN(guid,0xaf482368,0x330a,0x46a5,0x9a,0x5c,0x1,0xc7,0x1a,0xf2,0x4c,0x8d,"IID_ID3D10EffectDepthStencilVariable"); + IF_GUID_EQUAL_RETURN(guid,0x3e02c918,0xcc79,0x4985,0xb6,0x22,0x2d,0x92,0xad,0x70,0x16,0x23,"IID_ID3D10EffectDepthStencilViewVariable"); + IF_GUID_EQUAL_RETURN(guid,0x50666c24,0xb82f,0x4eed,0xa1,0x72,0x5b,0x6e,0x7e,0x85,0x22,0xe0,"IID_ID3D10EffectMatrixVariable"); + IF_GUID_EQUAL_RETURN(guid,0x5cfbeb89,0x1a06,0x46e0,0xb2,0x82,0xe3,0xf9,0xbf,0xa3,0x6a,0x54,"IID_ID3D10EffectPass"); + IF_GUID_EQUAL_RETURN(guid,0x9537ab04,0x3250,0x412e,0x82,0x13,0xfc,0xd2,0xf8,0x67,0x79,0x33,"IID_ID3D10EffectPool"); + IF_GUID_EQUAL_RETURN(guid,0x21af9f0e,0x4d94,0x4ea9,0x97,0x85,0x2c,0xb7,0x6b,0x8c,0xb,0x34,"IID_ID3D10EffectRasterizerVariable"); + IF_GUID_EQUAL_RETURN(guid,0x28ca0cc3,0xc2c9,0x40bb,0xb5,0x7f,0x67,0xb7,0x37,0x12,0x2b,0x17,"IID_ID3D10EffectRenderTargetViewVariable"); + IF_GUID_EQUAL_RETURN(guid,0x6530d5c7,0x7e9,0x4271,0xa4,0x18,0xe7,0xce,0x4b,0xd1,0xe4,0x80,"IID_ID3D10EffectSamplerVariable"); + IF_GUID_EQUAL_RETURN(guid,0xe48f7b,0xd2c8,0x49e8,0xa8,0x6c,0x2,0x2d,0xee,0x53,0x43,0x1f,"IID_ID3D10EffectScalarVariable"); + IF_GUID_EQUAL_RETURN(guid,0xc0a7157b,0xd872,0x4b1d,0x80,0x73,0xef,0xc2,0xac,0xd4,0xb1,0xfc,"IID_ID3D10EffectShaderResourceVariable"); + IF_GUID_EQUAL_RETURN(guid,0x80849279,0xc799,0x4797,0x8c,0x33,0x4,0x7,0xa0,0x7d,0x9e,0x6,"IID_ID3D10EffectShaderVariable"); + IF_GUID_EQUAL_RETURN(guid,0x71417501,0x8df9,0x4e0a,0xa7,0x8a,0x25,0x5f,0x97,0x56,0xba,0xff,"IID_ID3D10EffectStringVariable"); + IF_GUID_EQUAL_RETURN(guid,0xdb122ce8,0xd1c9,0x4292,0xb2,0x37,0x24,0xed,0x3d,0xe8,0xb1,0x75,"IID_ID3D10EffectTechnique"); + IF_GUID_EQUAL_RETURN(guid,0x4e9e1ddc,0xcd9d,0x4772,0xa8,0x37,0x0,0x18,0xb,0x9b,0x88,0xfd,"IID_ID3D10EffectType"); + IF_GUID_EQUAL_RETURN(guid,0xae897105,0xe6,0x45bf,0xbb,0x8e,0x28,0x1d,0xd6,0xdb,0x8e,0x1b,"IID_ID3D10EffectVariable"); + IF_GUID_EQUAL_RETURN(guid,0x62b98c44,0x1f82,0x4c67,0xbc,0xd0,0x72,0xcf,0x8f,0x21,0x7e,0x81,"IID_ID3D10EffectVectorVariable"); + IF_GUID_EQUAL_RETURN(guid,0x6316BE88,0x54CD,0x4040,0xAB,0x44,0x20,0x46,0x1B,0xC8,0x1F,0x68,"IID_ID3D10GeometryShader"); + IF_GUID_EQUAL_RETURN(guid,0x1b940b17,0x2642,0x4d1f,0xab,0x1f,0xb9,0x9b,0xad,0x0c,0x39,0x5f,"IID_ID3D10InfoQueue"); + IF_GUID_EQUAL_RETURN(guid,0x9B7E4C0B,0x342C,0x4106,0xA1,0x9F,0x4F,0x27,0x04,0xF6,0x89,0xF0,"IID_ID3D10InputLayout"); + IF_GUID_EQUAL_RETURN(guid,0x9B7E4E00,0x342C,0x4106,0xA1,0x9F,0x4F,0x27,0x04,0xF6,0x89,0xF0,"IID_ID3D10Multithread"); + IF_GUID_EQUAL_RETURN(guid,0x4968B601,0x9D00,0x4cde,0x83,0x46,0x8E,0x7F,0x67,0x58,0x19,0xB6,"IID_ID3D10PixelShader"); + IF_GUID_EQUAL_RETURN(guid,0x9B7E4C10,0x342C,0x4106,0xA1,0x9F,0x4F,0x27,0x04,0xF6,0x89,0xF0,"IID_ID3D10Predicate"); + IF_GUID_EQUAL_RETURN(guid,0x9B7E4C0E,0x342C,0x4106,0xA1,0x9F,0x4F,0x27,0x04,0xF6,0x89,0xF0,"IID_ID3D10Query"); + IF_GUID_EQUAL_RETURN(guid,0xA2A07292,0x89AF,0x4345,0xBE,0x2E,0xC5,0x3D,0x9F,0xBB,0x6E,0x9F,"IID_ID3D10RasterizerState"); + IF_GUID_EQUAL_RETURN(guid,0x9B7E4C08,0x342C,0x4106,0xA1,0x9F,0x4F,0x27,0x04,0xF6,0x89,0xF0,"IID_ID3D10RenderTargetView"); + IF_GUID_EQUAL_RETURN(guid,0x9B7E4C01,0x342C,0x4106,0xA1,0x9F,0x4F,0x27,0x04,0xF6,0x89,0xF0,"IID_ID3D10Resource"); + IF_GUID_EQUAL_RETURN(guid,0x9B7E4C0C,0x342C,0x4106,0xA1,0x9F,0x4F,0x27,0x04,0xF6,0x89,0xF0,"IID_ID3D10SamplerState"); + IF_GUID_EQUAL_RETURN(guid,0xc3457783,0xa846,0x47ce,0x95,0x20,0xce,0xa6,0xf6,0x6e,0x74,0x47,"IID_ID3D10ShaderReflection1"); + IF_GUID_EQUAL_RETURN(guid,0xd40e20b6,0xf8f7,0x42ad,0xab,0x20,0x4b,0xaf,0x8f,0x15,0xdf,0xaa,"IID_ID3D10ShaderReflection"); + IF_GUID_EQUAL_RETURN(guid,0x66c66a94,0xdddd,0x4b62,0xa6,0x6a,0xf0,0xda,0x33,0xc2,0xb4,0xd0,"IID_ID3D10ShaderReflectionConstantBuffer"); + IF_GUID_EQUAL_RETURN(guid,0xc530ad7d,0x9b16,0x4395,0xa9,0x79,0xba,0x2e,0xcf,0xf8,0x3a,0xdd,"IID_ID3D10ShaderReflectionType"); + IF_GUID_EQUAL_RETURN(guid,0x1bf63c95,0x2650,0x405d,0x99,0xc1,0x36,0x36,0xbd,0x1d,0xa0,0xa1,"IID_ID3D10ShaderReflectionVariable"); + IF_GUID_EQUAL_RETURN(guid,0x9B7E4C87,0x342C,0x4106,0xA1,0x9F,0x4F,0x27,0x04,0xF6,0x89,0xF0,"IID_ID3D10ShaderResourceView1"); + IF_GUID_EQUAL_RETURN(guid,0x9B7E4C07,0x342C,0x4106,0xA1,0x9F,0x4F,0x27,0x04,0xF6,0x89,0xF0,"IID_ID3D10ShaderResourceView"); + IF_GUID_EQUAL_RETURN(guid,0x803425a,0x57f5,0x4dd6,0x94,0x65,0xa8,0x75,0x70,0x83,0x4a,0x8,"IID_ID3D10StateBlock"); + IF_GUID_EQUAL_RETURN(guid,0x9B7E4E02,0x342C,0x4106,0xA1,0x9F,0x4F,0x27,0x04,0xF6,0x89,0xF0,"IID_ID3D10SwitchToRef"); + IF_GUID_EQUAL_RETURN(guid,0x9B7E4C03,0x342C,0x4106,0xA1,0x9F,0x4F,0x27,0x04,0xF6,0x89,0xF0,"IID_ID3D10Texture1D"); + IF_GUID_EQUAL_RETURN(guid,0x9B7E4C04,0x342C,0x4106,0xA1,0x9F,0x4F,0x27,0x04,0xF6,0x89,0xF0,"IID_ID3D10Texture2D"); + IF_GUID_EQUAL_RETURN(guid,0x9B7E4C05,0x342C,0x4106,0xA1,0x9F,0x4F,0x27,0x04,0xF6,0x89,0xF0,"IID_ID3D10Texture3D"); + IF_GUID_EQUAL_RETURN(guid,0x9B7E4C0A,0x342C,0x4106,0xA1,0x9F,0x4F,0x27,0x04,0xF6,0x89,0xF0,"IID_ID3D10VertexShader"); + IF_GUID_EQUAL_RETURN(guid,0xC902B03F,0x60A7,0x49BA,0x99,0x36,0x2A,0x3A,0xB3,0x7A,0x7E,0x33,"IID_ID3D10View"); + IF_GUID_EQUAL_RETURN(guid,0x4b35d0cd,0x1e15,0x4258,0x9c,0x98,0x1b,0x13,0x33,0xf6,0xdd,0x3b,"IID_ID3D11Asynchronous"); + IF_GUID_EQUAL_RETURN(guid,0x3015A308,0xDCBD,0x47aa,0xA7,0x47,0x19,0x24,0x86,0xD1,0x4D,0x4A,"IID_ID3D11AuthenticatedChannel"); + IF_GUID_EQUAL_RETURN(guid,0xcc86fabe,0xda55,0x401d,0x85,0xe7,0xe3,0xc9,0xde,0x28,0x77,0xe9,"IID_ID3D11BlendState1"); + IF_GUID_EQUAL_RETURN(guid,0x75b68faa,0x347d,0x4159,0x8f,0x45,0xa0,0x64,0x0f,0x01,0xcd,0x9a,"IID_ID3D11BlendState"); + IF_GUID_EQUAL_RETURN(guid,0x48570b85,0xd1ee,0x4fcd,0xa2,0x50,0xeb,0x35,0x07,0x22,0xb0,0x37,"IID_ID3D11Buffer"); + IF_GUID_EQUAL_RETURN(guid,0xa6cd7faa,0xb0b7,0x4a2f,0x94,0x36,0x86,0x62,0xa6,0x57,0x97,0xcb,"IID_ID3D11ClassInstance"); + IF_GUID_EQUAL_RETURN(guid,0xddf57cba,0x9543,0x46e4,0xa1,0x2b,0xf2,0x07,0xa0,0xfe,0x7f,0xed,"IID_ID3D11ClassLinkage"); + IF_GUID_EQUAL_RETURN(guid,0xa24bc4d1,0x769e,0x43f7,0x80,0x13,0x98,0xff,0x56,0x6c,0x18,0xe2,"IID_ID3D11CommandList"); + IF_GUID_EQUAL_RETURN(guid,0x4f5b196e,0xc2bd,0x495e,0xbd,0x01,0x1f,0xde,0xd3,0x8e,0x49,0x69,"IID_ID3D11ComputeShader"); + IF_GUID_EQUAL_RETURN(guid,0x6e8c49fb,0xa371,0x4770,0xb4,0x40,0x29,0x08,0x60,0x22,0xb7,0x41,"IID_ID3D11Counter"); + IF_GUID_EQUAL_RETURN(guid,0x9B32F9AD,0xBDCC,0x40a6,0xA3,0x9D,0xD5,0xC8,0x65,0x84,0x57,0x20,"IID_ID3D11CryptoSession"); + IF_GUID_EQUAL_RETURN(guid,0x79cf2233,0x7536,0x4948,0x9d,0x36,0x1e,0x46,0x92,0xdc,0x57,0x60,"IID_ID3D11Debug"); + IF_GUID_EQUAL_RETURN(guid,0x03823efb,0x8d8f,0x4e1c,0x9a,0xa2,0xf6,0x4b,0xb2,0xcb,0xfd,0xf1,"IID_ID3D11DepthStencilState"); + IF_GUID_EQUAL_RETURN(guid,0x9fdac92a,0x1876,0x48c3,0xaf,0xad,0x25,0xb9,0x4f,0x84,0xa9,0xb6,"IID_ID3D11DepthStencilView"); + IF_GUID_EQUAL_RETURN(guid,0xa04bfb29,0x08ef,0x43d6,0xa4,0x9c,0xa9,0xbd,0xbd,0xcb,0xe6,0x86,"IID_ID3D11Device1"); + IF_GUID_EQUAL_RETURN(guid,0xdb6f6ddb,0xac77,0x4e88,0x82,0x53,0x81,0x9d,0xf9,0xbb,0xf1,0x40,"IID_ID3D11Device"); + IF_GUID_EQUAL_RETURN(guid,0x1841e5c8,0x16b0,0x489b,0xbc,0xc8,0x44,0xcf,0xb0,0xd5,0xde,0xae,"IID_ID3D11DeviceChild"); + IF_GUID_EQUAL_RETURN(guid,0xbb2c6faa,0xb5fb,0x4082,0x8e,0x6b,0x38,0x8b,0x8c,0xfa,0x90,0xe1,"IID_ID3D11DeviceContext1"); + IF_GUID_EQUAL_RETURN(guid,0xc0bfa96c,0xe089,0x44fb,0x8e,0xaf,0x26,0xf8,0x79,0x61,0x90,0xda,"IID_ID3D11DeviceContext"); + IF_GUID_EQUAL_RETURN(guid,0xf582c508,0x0f36,0x490c,0x99,0x77,0x31,0xee,0xce,0x26,0x8c,0xfa,"IID_ID3D11DomainShader"); + IF_GUID_EQUAL_RETURN(guid,0x38325b96,0xeffb,0x4022,0xba,0x02,0x2e,0x79,0x5b,0x70,0x27,0x5c,"IID_ID3D11GeometryShader"); + IF_GUID_EQUAL_RETURN(guid,0x8e5c6061,0x628a,0x4c8e,0x82,0x64,0xbb,0xe4,0x5c,0xb3,0xd5,0xdd,"IID_ID3D11HullShader"); + IF_GUID_EQUAL_RETURN(guid,0x6543dbb6,0x1b48,0x42f5,0xab,0x82,0xe9,0x7e,0xc7,0x43,0x26,0xf6,"IID_ID3D11InfoQueue"); + IF_GUID_EQUAL_RETURN(guid,0xe4819ddc,0x4cf0,0x4025,0xbd,0x26,0x5d,0xe8,0x2a,0x3e,0x07,0xb7,"IID_ID3D11InputLayout"); + IF_GUID_EQUAL_RETURN(guid,0xea82e40d,0x51dc,0x4f33,0x93,0xd4,0xdb,0x7c,0x91,0x25,0xae,0x8c,"IID_ID3D11PixelShader"); + IF_GUID_EQUAL_RETURN(guid,0x9eb576dd,0x9f77,0x4d86,0x81,0xaa,0x8b,0xab,0x5f,0xe4,0x90,0xe2,"IID_ID3D11Predicate"); + IF_GUID_EQUAL_RETURN(guid,0xd6c00747,0x87b7,0x425e,0xb8,0x4d,0x44,0xd1,0x08,0x56,0x0a,0xfd,"IID_ID3D11Query"); + IF_GUID_EQUAL_RETURN(guid,0x1217d7a6,0x5039,0x418c,0xb0,0x42,0x9c,0xbe,0x25,0x6a,0xfd,0x6e,"IID_ID3D11RasterizerState1"); + IF_GUID_EQUAL_RETURN(guid,0x9bb4ab81,0xab1a,0x4d8f,0xb5,0x06,0xfc,0x04,0x20,0x0b,0x6e,0xe7,"IID_ID3D11RasterizerState"); + IF_GUID_EQUAL_RETURN(guid,0x03916615,0xc644,0x418c,0x9b,0xf4,0x75,0xdb,0x5b,0xe6,0x3c,0xa0,"IID_ID3D11RefDefaultTrackingOptions"); + IF_GUID_EQUAL_RETURN(guid,0x193dacdf,0x0db2,0x4c05,0xa5,0x5c,0xef,0x06,0xca,0xc5,0x6f,0xd9,"IID_ID3D11RefTrackingOptions"); + IF_GUID_EQUAL_RETURN(guid,0xdfdba067,0x0b8d,0x4865,0x87,0x5b,0xd7,0xb4,0x51,0x6c,0xc1,0x64,"IID_ID3D11RenderTargetView"); + IF_GUID_EQUAL_RETURN(guid,0xdc8e63f3,0xd12b,0x4952,0xb4,0x7b,0x5e,0x45,0x02,0x6a,0x86,0x2d,"IID_ID3D11Resource"); + IF_GUID_EQUAL_RETURN(guid,0xda6fea51,0x564c,0x4487,0x98,0x10,0xf0,0xd0,0xf9,0xb4,0xe3,0xa5,"IID_ID3D11SamplerState"); + IF_GUID_EQUAL_RETURN(guid,0x8d536ca1,0x0cca,0x4956,0xa8,0x37,0x78,0x69,0x63,0x75,0x55,0x84,"IID_ID3D11ShaderReflection"); + IF_GUID_EQUAL_RETURN(guid,0xeb62d63d,0x93dd,0x4318,0x8a,0xe8,0xc6,0xf8,0x3a,0xd3,0x71,0xb8,"IID_ID3D11ShaderReflectionConstantBuffer"); + IF_GUID_EQUAL_RETURN(guid,0x6e6ffa6a,0x9bae,0x4613,0xa5,0x1e,0x91,0x65,0x2d,0x50,0x8c,0x21,"IID_ID3D11ShaderReflectionType"); + IF_GUID_EQUAL_RETURN(guid,0x51f23923,0xf3e5,0x4bd1,0x91,0xcb,0x60,0x61,0x77,0xd8,0xdb,0x4c,"IID_ID3D11ShaderReflectionVariable"); + IF_GUID_EQUAL_RETURN(guid,0xb0e06fe0,0x8192,0x4e1a,0xb1,0xca,0x36,0xd7,0x41,0x47,0x10,0xb2,"IID_ID3D11ShaderResourceView"); + IF_GUID_EQUAL_RETURN(guid,0x1ef337e3,0x58e7,0x4f83,0xa6,0x92,0xdb,0x22,0x1f,0x5e,0xd4,0x7e,"IID_ID3D11SwitchToRef"); + IF_GUID_EQUAL_RETURN(guid,0xf8fb5c27,0xc6b3,0x4f75,0xa4,0xc8,0x43,0x9a,0xf2,0xef,0x56,0x4c,"IID_ID3D11Texture1D"); + IF_GUID_EQUAL_RETURN(guid,0x6f15aaf2,0xd208,0x4e89,0x9a,0xb4,0x48,0x95,0x35,0xd3,0x4f,0x9c,"IID_ID3D11Texture2D"); + IF_GUID_EQUAL_RETURN(guid,0x037e866e,0xf56d,0x4357,0xa8,0xaf,0x9d,0xab,0xbe,0x6e,0x25,0x0e,"IID_ID3D11Texture3D"); + IF_GUID_EQUAL_RETURN(guid,0x1911c771,0x1587,0x413e,0xa7,0xe0,0xfb,0x26,0xc3,0xde,0x02,0x68,"IID_ID3D11TracingDevice"); + IF_GUID_EQUAL_RETURN(guid,0x28acf509,0x7f5c,0x48f6,0x86,0x11,0xf3,0x16,0x01,0x0a,0x63,0x80,"IID_ID3D11UnorderedAccessView"); + IF_GUID_EQUAL_RETURN(guid,0x3b301d64,0xd678,0x4289,0x88,0x97,0x22,0xf8,0x92,0x8b,0x72,0xf3,"IID_ID3D11VertexShader"); + IF_GUID_EQUAL_RETURN(guid,0x61F21C45,0x3C0E,0x4a74,0x9C,0xEA,0x67,0x10,0x0D,0x9A,0xD5,0xE4,"IID_ID3D11VideoContext"); + IF_GUID_EQUAL_RETURN(guid,0x3C9C5B51,0x995D,0x48d1,0x9B,0x8D,0xFA,0x5C,0xAE,0xDE,0xD6,0x5C,"IID_ID3D11VideoDecoder"); + IF_GUID_EQUAL_RETURN(guid,0xC2931AEA,0x2A85,0x4f20,0x86,0x0F,0xFB,0xA1,0xFD,0x25,0x6E,0x18,"IID_ID3D11VideoDecoderOutputView"); + IF_GUID_EQUAL_RETURN(guid,0x10EC4D5B,0x975A,0x4689,0xB9,0xE4,0xD0,0xAA,0xC3,0x0F,0xE3,0x33,"IID_ID3D11VideoDevice"); + IF_GUID_EQUAL_RETURN(guid,0x1D7B0652,0x185F,0x41c6,0x85,0xCE,0x0C,0x5B,0xE3,0xD4,0xAE,0x6C,"IID_ID3D11VideoProcessor"); + IF_GUID_EQUAL_RETURN(guid,0x31627037,0x53AB,0x4200,0x90,0x61,0x05,0xFA,0xA9,0xAB,0x45,0xF9,"IID_ID3D11VideoProcessorEnumerator"); + IF_GUID_EQUAL_RETURN(guid,0x11EC5A5F,0x51DC,0x4945,0xAB,0x34,0x6E,0x8C,0x21,0x30,0x0E,0xA5,"IID_ID3D11VideoProcessorInputView"); + IF_GUID_EQUAL_RETURN(guid,0xA048285E,0x25A9,0x4527,0xBD,0x93,0xD6,0x8B,0x68,0xC4,0x42,0x54,"IID_ID3D11VideoProcessorOutputView"); + IF_GUID_EQUAL_RETURN(guid,0x839d1216,0xbb2e,0x412b,0xb7,0xf4,0xa9,0xdb,0xeb,0xe0,0x8e,0xd1,"IID_ID3D11View"); + IF_GUID_EQUAL_RETURN(guid,0x5c1e0d8a,0x7c23,0x48f9,0x8c,0x59,0xa9,0x29,0x58,0xce,0xff,0x11,"IID_ID3DDeviceContextState"); + IF_GUID_EQUAL_RETURN(guid,0xb2daad8b,0x03d4,0x4dbf,0x95,0xeb,0x32,0xab,0x4b,0x63,0xd0,0xab,"IID_ID3DUserDefinedAnnotation"); + IF_GUID_EQUAL_RETURN(guid,0xb3f7a938,0x4c93,0x4310,0xa6,0x75,0xb3,0x0d,0x6d,0xe5,0x05,0x53,"IID_ID3DX11FFT"); + IF_GUID_EQUAL_RETURN(guid,0x5089b68f,0xe71d,0x4d38,0xbe,0x8e,0xf3,0x63,0xb9,0x5a,0x94,0x05,"IID_ID3DX11Scan"); + IF_GUID_EQUAL_RETURN(guid,0xa915128c,0xd954,0x4c79,0xbf,0xe1,0x64,0xdb,0x92,0x31,0x94,0xd6,"IID_ID3DX11SegmentedScan"); + IF_GUID_EQUAL_RETURN(guid,0x0c733a9cL,0x2a1c,0x11ce,0xad,0xe5,0x00,0xaa,0x00,0x44,0x77,0x3d,"IID_IDCInfo"); + IF_GUID_EQUAL_RETURN(guid,0x6C142760,0xA733,0x11CE,0xA5,0x21,0x00,0x20,0xAF,0x0B,0xE5,0x60,"IID_IDDVideoPortContainer"); + IF_GUID_EQUAL_RETURN(guid,0x29038f61,0x3839,0x4626,0x91,0xfd,0x08,0x68,0x79,0x01,0x1a,0x05,"IID_IDXGIAdapter1"); + IF_GUID_EQUAL_RETURN(guid,0x0AA1AE0A,0xFA0E,0x4B84,0x86,0x44,0xE0,0x5F,0xF8,0xE5,0xAC,0xB5,"IID_IDXGIAdapter2"); + IF_GUID_EQUAL_RETURN(guid,0x2411e7e1,0x12ac,0x4ccf,0xbd,0x14,0x97,0x98,0xe8,0x53,0x4d,0xc0,"IID_IDXGIAdapter"); + IF_GUID_EQUAL_RETURN(guid,0x119E7452,0xDE9E,0x40fe,0x88,0x06,0x88,0xF9,0x0C,0x12,0xB4,0x41,"IID_IDXGIDebug"); + IF_GUID_EQUAL_RETURN(guid,0x77db970f,0x6276,0x48ba,0xba,0x28,0x07,0x01,0x43,0xb4,0x39,0x2c,"IID_IDXGIDevice1"); + IF_GUID_EQUAL_RETURN(guid,0x05008617,0xfbfd,0x4051,0xa7,0x90,0x14,0x48,0x84,0xb4,0xf6,0xa9,"IID_IDXGIDevice2"); + IF_GUID_EQUAL_RETURN(guid,0x54ec77fa,0x1377,0x44e6,0x8c,0x32,0x88,0xfd,0x5f,0x44,0xc8,0x4c,"IID_IDXGIDevice"); + IF_GUID_EQUAL_RETURN(guid,0x3d3e0379,0xf9de,0x4d58,0xbb,0x6c,0x18,0xd6,0x29,0x92,0xf1,0xa6,"IID_IDXGIDeviceSubObject"); + IF_GUID_EQUAL_RETURN(guid,0xea9dbf1a,0xc88e,0x4486,0x85,0x4a,0x98,0xaa,0x01,0x38,0xf3,0x0c,"IID_IDXGIDisplayControl"); + IF_GUID_EQUAL_RETURN(guid,0x770aae78,0xf26f,0x4dba,0xa8,0x29,0x25,0x3c,0x83,0xd1,0xb3,0x87,"IID_IDXGIFactory1"); + IF_GUID_EQUAL_RETURN(guid,0x50c83a1c,0xe072,0x4c48,0x87,0xb0,0x36,0x30,0xfa,0x36,0xa6,0xd0,"IID_IDXGIFactory2"); + IF_GUID_EQUAL_RETURN(guid,0x7b7166ec,0x21c7,0x44ae,0xb2,0x1a,0xc9,0xae,0x32,0x1a,0xe3,0x69,"IID_IDXGIFactory"); + IF_GUID_EQUAL_RETURN(guid,0xD67441C7,0x672A,0x476f,0x9E,0x82,0xCD,0x55,0xB4,0x49,0x49,0xCE,"IID_IDXGIInfoQueue"); + IF_GUID_EQUAL_RETURN(guid,0x9d8e1289,0xd7b3,0x465f,0x81,0x26,0x25,0x0e,0x34,0x9a,0xf8,0x5d,"IID_IDXGIKeyedMutex"); + IF_GUID_EQUAL_RETURN(guid,0xaec22fb8,0x76f3,0x4639,0x9b,0xe0,0x28,0xeb,0x43,0xa6,0x7a,0x2e,"IID_IDXGIObject"); + IF_GUID_EQUAL_RETURN(guid,0x00cddea8,0x939b,0x4b83,0xa3,0x40,0xa6,0x85,0x22,0x66,0x66,0xcc,"IID_IDXGIOutput1"); + IF_GUID_EQUAL_RETURN(guid,0xae02eedb,0xc735,0x4690,0x8d,0x52,0x5a,0x8d,0xc2,0x02,0x13,0xaa,"IID_IDXGIOutput"); + IF_GUID_EQUAL_RETURN(guid,0x191cfac3,0xa341,0x470d,0xb2,0x6e,0xa8,0x64,0xf4,0x28,0x31,0x9c,"IID_IDXGIOutputDuplication"); + IF_GUID_EQUAL_RETURN(guid,0x30961379,0x4609,0x4a41,0x99,0x8e,0x54,0xfe,0x56,0x7e,0xe0,0xc1,"IID_IDXGIResource1"); + IF_GUID_EQUAL_RETURN(guid,0x035f3ab4,0x482e,0x4e50,0xb4,0x1f,0x8a,0x7f,0x8b,0xd8,0x96,0x0b,"IID_IDXGIResource"); + IF_GUID_EQUAL_RETURN(guid,0x4AE63092,0x6327,0x4c1b,0x80,0xAE,0xBF,0xE1,0x2E,0xA3,0x2B,0x86,"IID_IDXGISurface1"); + IF_GUID_EQUAL_RETURN(guid,0xaba496dd,0xb617,0x4cb8,0xa8,0x66,0xbc,0x44,0xd7,0xeb,0x1f,0xa2,"IID_IDXGISurface2"); + IF_GUID_EQUAL_RETURN(guid,0xcafcb56c,0x6ac3,0x4889,0xbf,0x47,0x9e,0x23,0xbb,0xd2,0x60,0xec,"IID_IDXGISurface"); + IF_GUID_EQUAL_RETURN(guid,0x790a45f7,0x0d42,0x4876,0x98,0x3a,0x0a,0x55,0xcf,0xe6,0xf4,0xaa,"IID_IDXGISwapChain1"); + IF_GUID_EQUAL_RETURN(guid,0x310d36a0,0xd2e7,0x4c0a,0xaa,0x04,0x6a,0x9d,0x23,0xb8,0x88,0x6a,"IID_IDXGISwapChain"); + IF_GUID_EQUAL_RETURN(guid,0x95f12dfd,0xd77e,0x49be,0x81,0x5f,0x57,0xd5,0x79,0x63,0x4d,0x6d,"IID_IDXVAHD_Device"); + IF_GUID_EQUAL_RETURN(guid,0x95f4edf4,0x6e03,0x4cd7,0xbe,0x1b,0x30,0x75,0xd6,0x65,0xaa,0x52,"IID_IDXVAHD_VideoProcessor"); + IF_GUID_EQUAL_RETURN(guid,0x0c733a8dL,0x2a1c,0x11ce,0xad,0xe5,0x00,0xaa,0x00,0x44,0x77,0x3d,"IID_IDataConvert"); + IF_GUID_EQUAL_RETURN(guid,0x716d14c9,0x119b,0x4ba5,0xaf,0x1f,0x08,0x90,0xe6,0x72,0x41,0x6a,"IID_IDebugAdvanced2"); + IF_GUID_EQUAL_RETURN(guid,0xcba4abb4,0x84c4,0x444d,0x87,0xca,0xa0,0x4e,0x13,0x28,0x67,0x39,"IID_IDebugAdvanced3"); + IF_GUID_EQUAL_RETURN(guid,0xf2df5f53,0x071f,0x47bd,0x9d,0xe6,0x57,0x34,0xc3,0xfe,0xd6,0x89,"IID_IDebugAdvanced"); + IF_GUID_EQUAL_RETURN(guid,0x1b278d20,0x79f2,0x426e,0xa3,0xf9,0xc1,0xdd,0xf3,0x75,0xd4,0x8e,"IID_IDebugBreakpoint2"); + IF_GUID_EQUAL_RETURN(guid,0x38f5c249,0xb448,0x43bb,0x98,0x35,0x57,0x9d,0x4e,0xc0,0x22,0x49,"IID_IDebugBreakpoint3"); + IF_GUID_EQUAL_RETURN(guid,0x5bd9d474,0x5975,0x423a,0xb8,0x8b,0x65,0xa8,0xe7,0x11,0x0e,0x65,"IID_IDebugBreakpoint"); + IF_GUID_EQUAL_RETURN(guid,0xedbed635,0x372e,0x4dab,0xbb,0xfe,0xed,0x0d,0x2f,0x63,0xbe,0x81,"IID_IDebugClient2"); + IF_GUID_EQUAL_RETURN(guid,0xdd492d7f,0x71b8,0x4ad6,0xa8,0xdc,0x1c,0x88,0x74,0x79,0xff,0x91,"IID_IDebugClient3"); + IF_GUID_EQUAL_RETURN(guid,0xca83c3de,0x5089,0x4cf8,0x93,0xc8,0xd8,0x92,0x38,0x7f,0x2a,0x5e,"IID_IDebugClient4"); + IF_GUID_EQUAL_RETURN(guid,0xe3acb9d7,0x7ec2,0x4f0c,0xa0,0xda,0xe8,0x1e,0x0c,0xbb,0xe6,0x28,"IID_IDebugClient5"); + IF_GUID_EQUAL_RETURN(guid,0xfd28b4c5,0xc498,0x4686,0xa2,0x8e,0x62,0xca,0xd2,0x15,0x4e,0xb3,"IID_IDebugClient6"); + IF_GUID_EQUAL_RETURN(guid,0x13586be3,0x542e,0x481e,0xb1,0xf2,0x84,0x97,0xba,0x74,0xf9,0xa9,"IID_IDebugClient7"); + IF_GUID_EQUAL_RETURN(guid,0x27fe5639,0x8407,0x4f47,0x83,0x64,0xee,0x11,0x8f,0xb0,0x8a,0xc8,"IID_IDebugClient"); + IF_GUID_EQUAL_RETURN(guid,0xd4366723,0x44df,0x4bed,0x8c,0x7e,0x4c,0x05,0x42,0x4f,0x45,0x88,"IID_IDebugControl2"); + IF_GUID_EQUAL_RETURN(guid,0x7df74a86,0xb03f,0x407f,0x90,0xab,0xa2,0x0d,0xad,0xce,0xad,0x08,"IID_IDebugControl3"); + IF_GUID_EQUAL_RETURN(guid,0x94e60ce9,0x9b41,0x4b19,0x9f,0xc0,0x6d,0x9e,0xb3,0x52,0x72,0xb3,"IID_IDebugControl4"); + IF_GUID_EQUAL_RETURN(guid,0xb2ffe162,0x2412,0x429f,0x8d,0x1d,0x5b,0xf6,0xdd,0x82,0x46,0x96,"IID_IDebugControl5"); + IF_GUID_EQUAL_RETURN(guid,0xbc0d583f,0x126d,0x43a1,0x9c,0xc4,0xa8,0x60,0xab,0x1d,0x53,0x7b,"IID_IDebugControl6"); + IF_GUID_EQUAL_RETURN(guid,0xb86fb3b1,0x80d4,0x475b,0xae,0xa3,0xcf,0x06,0x53,0x9c,0xf6,0x3a,"IID_IDebugControl7"); + IF_GUID_EQUAL_RETURN(guid,0x5182e668,0x105e,0x416e,0xad,0x92,0x24,0xef,0x80,0x04,0x24,0xba,"IID_IDebugControl"); + IF_GUID_EQUAL_RETURN(guid,0x7a5e852f,0x96e9,0x468f,0xac,0x1b,0x0b,0x3a,0xdd,0xc4,0xa0,0x49,"IID_IDebugDataSpaces2"); + IF_GUID_EQUAL_RETURN(guid,0x23f79d6c,0x8aaf,0x4f7c,0xa6,0x07,0x99,0x95,0xf5,0x40,0x7e,0x63,"IID_IDebugDataSpaces3"); + IF_GUID_EQUAL_RETURN(guid,0xd98ada1f,0x29e9,0x4ef5,0xa6,0xc0,0xe5,0x33,0x49,0x88,0x32,0x12,"IID_IDebugDataSpaces4"); + IF_GUID_EQUAL_RETURN(guid,0x88f7dfab,0x3ea7,0x4c3a,0xae,0xfb,0xc4,0xe8,0x10,0x61,0x73,0xaa,"IID_IDebugDataSpaces"); + IF_GUID_EQUAL_RETURN(guid,0x337be28b,0x5036,0x4d72,0xb6,0xbf,0xc4,0x5f,0xbb,0x9f,0x2e,0xaa,"IID_IDebugEventCallbacks"); + IF_GUID_EQUAL_RETURN(guid,0x0690e046,0x9c23,0x45ac,0xa0,0x4f,0x98,0x7a,0xc2,0x9a,0xd0,0xd3,"IID_IDebugEventCallbacksWide"); + IF_GUID_EQUAL_RETURN(guid,0x61a4905b,0x23f9,0x4247,0xb3,0xc5,0x53,0xd0,0x87,0x52,0x9a,0xb7,"IID_IDebugEventContextCallbacks"); + IF_GUID_EQUAL_RETURN(guid,0x9f50e42c,0xf136,0x499e,0x9a,0x97,0x73,0x03,0x6c,0x94,0xed,0x2d,"IID_IDebugInputCallbacks"); + IF_GUID_EQUAL_RETURN(guid,0x67721fe9,0x56d2,0x4a44,0xa3,0x25,0x2b,0x65,0x51,0x3c,0xe6,0xeb,"IID_IDebugOutputCallbacks2"); + IF_GUID_EQUAL_RETURN(guid,0x4bf58045,0xd654,0x4c40,0xb0,0xaf,0x68,0x30,0x90,0xf3,0x56,0xdc,"IID_IDebugOutputCallbacks"); + IF_GUID_EQUAL_RETURN(guid,0x4c7fd663,0xc394,0x4e26,0x8e,0xf1,0x34,0xad,0x5e,0xd3,0x76,0x4c,"IID_IDebugOutputCallbacksWide"); + IF_GUID_EQUAL_RETURN(guid,0x1656afa9,0x19c6,0x4e3a,0x97,0xe7,0x5d,0xc9,0x16,0x0c,0xf9,0xc4,"IID_IDebugRegisters2"); + IF_GUID_EQUAL_RETURN(guid,0xce289126,0x9e84,0x45a7,0x93,0x7e,0x67,0xbb,0x18,0x69,0x14,0x93,"IID_IDebugRegisters"); + IF_GUID_EQUAL_RETURN(guid,0x6a7ccc5f,0xfb5e,0x4dcc,0xb4,0x1c,0x6c,0x20,0x30,0x7b,0xcc,0xc7,"IID_IDebugSymbolGroup2"); + IF_GUID_EQUAL_RETURN(guid,0xf2528316,0x0f1a,0x4431,0xae,0xed,0x11,0xd0,0x96,0xe1,0xe2,0xab,"IID_IDebugSymbolGroup"); + IF_GUID_EQUAL_RETURN(guid,0x3a707211,0xafdd,0x4495,0xad,0x4f,0x56,0xfe,0xcd,0xf8,0x16,0x3f,"IID_IDebugSymbols2"); + IF_GUID_EQUAL_RETURN(guid,0xf02fbecc,0x50ac,0x4f36,0x9a,0xd9,0xc9,0x75,0xe8,0xf3,0x2f,0xf8,"IID_IDebugSymbols3"); + IF_GUID_EQUAL_RETURN(guid,0xe391bbd8,0x9d8c,0x4418,0x84,0x0b,0xc0,0x06,0x59,0x2a,0x17,0x52,"IID_IDebugSymbols4"); + IF_GUID_EQUAL_RETURN(guid,0xc65fa83e,0x1e69,0x475e,0x8e,0x0e,0xb5,0xd7,0x9e,0x9c,0xc1,0x7e,"IID_IDebugSymbols5"); + IF_GUID_EQUAL_RETURN(guid,0x8c31e98c,0x983a,0x48a5,0x90,0x16,0x6f,0xe5,0xd6,0x67,0xa9,0x50,"IID_IDebugSymbols"); + IF_GUID_EQUAL_RETURN(guid,0x0ae9f5ff,0x1852,0x4679,0xb0,0x55,0x49,0x4b,0xee,0x64,0x07,0xee,"IID_IDebugSystemObjects2"); + IF_GUID_EQUAL_RETURN(guid,0xe9676e2f,0xe286,0x4ea3,0xb0,0xf9,0xdf,0xe5,0xd9,0xfc,0x33,0x0e,"IID_IDebugSystemObjects3"); + IF_GUID_EQUAL_RETURN(guid,0x489468e6,0x7d0f,0x4af5,0x87,0xab,0x25,0x20,0x74,0x54,0xd5,0x53,"IID_IDebugSystemObjects4"); + IF_GUID_EQUAL_RETURN(guid,0x6b86fe2c,0x2c4f,0x4f0c,0x9d,0xa2,0x17,0x43,0x11,0xac,0xc3,0x27,"IID_IDebugSystemObjects"); + IF_GUID_EQUAL_RETURN(guid,0xbf24142d,0xa47d,0x4d24,0xa6,0x6d,0x8c,0x21,0x41,0x94,0x4e,0x44,"IID_IDebuggerInfo"); + IF_GUID_EQUAL_RETURN(guid,0x23d86786,0x0bb5,0x4774,0x8f,0xb5,0xe3,0x52,0x2a,0xdd,0x62,0x46,"IID_IDebuggerThreadControl"); + IF_GUID_EQUAL_RETURN(guid,0x56a868b8,0x0ad4,0x11ce,0xb0,0x3a,0x00,0x20,0xaf,0x0b,0xa7,0x70,"IID_IDeferredCommand"); + IF_GUID_EQUAL_RETURN(guid,0x6aae1ec1,0x662a,0x11d0,0x88,0x9d,0x00,0xaa,0x00,0xbb,0xb7,0x6a,"IID_IDirect3D2"); + IF_GUID_EQUAL_RETURN(guid,0xbb223240,0xe72b,0x11d0,0xa9,0xb4,0x00,0xaa,0x00,0xc0,0x99,0x3e,"IID_IDirect3D3"); + IF_GUID_EQUAL_RETURN(guid,0xf5049e77,0x4861,0x11d2,0xa4,0x7,0x0,0xa0,0xc9,0x6,0x29,0xa8,"IID_IDirect3D7"); + IF_GUID_EQUAL_RETURN(guid,0x81bdcbca,0x64d4,0x426d,0xae,0x8d,0xad,0x1,0x47,0xf4,0x27,0x5c,"IID_IDirect3D9"); + IF_GUID_EQUAL_RETURN(guid,0x02177241,0x69FC,0x400C,0x8F,0xF1,0x93,0xA4,0x4D,0xF6,0x86,0x1D,"IID_IDirect3D9Ex"); + IF_GUID_EQUAL_RETURN(guid,0x187aeb13,0xaaf5,0x4c59,0x87,0x6d,0xe0,0x59,0x8,0x8c,0xd,0xf8,"IID_IDirect3D9ExOverlayExtension"); + IF_GUID_EQUAL_RETURN(guid,0x3BBA0080,0x2421,0x11CF,0xA3,0x1A,0x00,0xAA,0x00,0xB9,0x33,0x56,"IID_IDirect3D"); + IF_GUID_EQUAL_RETURN(guid,0xff24beee,0xda21,0x4beb,0x98,0xb5,0xd2,0xf8,0x99,0xf9,0x8a,0xf9,"IID_IDirect3DAuthenticatedChannel9"); + IF_GUID_EQUAL_RETURN(guid,0x580ca87e,0x1d3c,0x4d54,0x99,0x1d,0xb7,0xd3,0xe3,0xc2,0x98,0xce,"IID_IDirect3DBaseTexture9"); + IF_GUID_EQUAL_RETURN(guid,0xfa0ab799,0x7a9c,0x48ca,0x8c,0x5b,0x23,0x7e,0x71,0xa5,0x44,0x34,"IID_IDirect3DCryptoSession9"); + IF_GUID_EQUAL_RETURN(guid,0xfff32f81,0xd953,0x473a,0x92,0x23,0x93,0xd6,0x52,0xab,0xa9,0x3f,"IID_IDirect3DCubeTexture9"); + IF_GUID_EQUAL_RETURN(guid,0x93281501,0x8cf8,0x11d0,0x89,0xab,0x0,0xa0,0xc9,0x5,0x41,0x29,"IID_IDirect3DDevice2"); + IF_GUID_EQUAL_RETURN(guid,0xb0ab3b60,0x33d7,0x11d1,0xa9,0x81,0x0,0xc0,0x4f,0xd7,0xb1,0x74,"IID_IDirect3DDevice3"); + IF_GUID_EQUAL_RETURN(guid,0xf5049e79,0x4861,0x11d2,0xa4,0x7,0x0,0xa0,0xc9,0x6,0x29,0xa8,"IID_IDirect3DDevice7"); + IF_GUID_EQUAL_RETURN(guid,0xd0223b96,0xbf7a,0x43fd,0x92,0xbd,0xa4,0x3b,0xd,0x82,0xb9,0xeb,"IID_IDirect3DDevice9"); + IF_GUID_EQUAL_RETURN(guid,0xb18b10ce,0x2649,0x405a,0x87,0xf,0x95,0xf7,0x77,0xd4,0x31,0x3a,"IID_IDirect3DDevice9Ex"); + IF_GUID_EQUAL_RETURN(guid,0x26dc4561,0xa1ee,0x4ae7,0x96,0xda,0x11,0x8a,0x36,0xc0,0xec,0x95,"IID_IDirect3DDevice9Video"); + IF_GUID_EQUAL_RETURN(guid,0x64108800,0x957d,0X11d0,0x89,0xab,0x00,0xa0,0xc9,0x05,0x41,0x29,"IID_IDirect3DDevice"); + IF_GUID_EQUAL_RETURN(guid,0xa0cade0f,0x06d5,0x4cf4,0xa1,0xc7,0xf3,0xcd,0xd7,0x25,0xaa,0x75,"IID_IDirect3DDeviceManager9"); + IF_GUID_EQUAL_RETURN(guid,0x4417C145,0x33AD,0x11CF,0x81,0x6F,0x00,0x00,0xC0,0x20,0x15,0x6E,"IID_IDirect3DExecuteBuffer"); + IF_GUID_EQUAL_RETURN(guid,0x84E63dE0,0x46AA,0x11CF,0x81,0x6F,0x00,0x00,0xC0,0x20,0x15,0x6E,"IID_IDirect3DHALDevice"); + IF_GUID_EQUAL_RETURN(guid,0x7c9dd65e,0xd3f7,0x4529,0xac,0xee,0x78,0x58,0x30,0xac,0xde,0x35,"IID_IDirect3DIndexBuffer9"); + IF_GUID_EQUAL_RETURN(guid,0x4417C142,0x33AD,0x11CF,0x81,0x6F,0x00,0x00,0xC0,0x20,0x15,0x6E,"IID_IDirect3DLight"); + IF_GUID_EQUAL_RETURN(guid,0x881949a1,0xd6f3,0x11d0,0x89,0xab,0x00,0xa0,0xc9,0x05,0x41,0x29,"IID_IDirect3DMMXDevice"); + IF_GUID_EQUAL_RETURN(guid,0x93281503,0x8cf8,0x11d0,0x89,0xab,0x0,0xa0,0xc9,0x5,0x41,0x29,"IID_IDirect3DMaterial2"); + IF_GUID_EQUAL_RETURN(guid,0xca9c46f4,0xd3c5,0x11d1,0xb7,0x5a,0x0,0x60,0x8,0x52,0xb3,0x12,"IID_IDirect3DMaterial3"); + IF_GUID_EQUAL_RETURN(guid,0x4417C144,0x33AD,0x11CF,0x81,0x6F,0x00,0x00,0xC0,0x20,0x15,0x6E,"IID_IDirect3DMaterial"); + IF_GUID_EQUAL_RETURN(guid,0x8767df22,0xbacc,0x11d1,0x89,0x69,0x0,0xa0,0xc9,0x6,0x29,0xa8,"IID_IDirect3DNullDevice"); + IF_GUID_EQUAL_RETURN(guid,0x6d3bdbdc,0x5b02,0x4415,0xb8,0x52,0xce,0x5e,0x8b,0xcc,0xb2,0x89,"IID_IDirect3DPixelShader9"); + IF_GUID_EQUAL_RETURN(guid,0xd9771460,0xa695,0x4f26,0xbb,0xd3,0x27,0xb8,0x40,0xb5,0x41,0xcc,"IID_IDirect3DQuery9"); + IF_GUID_EQUAL_RETURN(guid,0xA4665C60,0x2673,0x11CF,0xA3,0x1A,0x00,0xAA,0x00,0xB9,0x33,0x56,"IID_IDirect3DRGBDevice"); + IF_GUID_EQUAL_RETURN(guid,0xF2086B20,0x259F,0x11CF,0xA3,0x1A,0x00,0xAA,0x00,0xB9,0x33,0x56,"IID_IDirect3DRampDevice"); + IF_GUID_EQUAL_RETURN(guid,0x50936643,0x13e9,0x11d1,0x89,0xaa,0x0,0xa0,0xc9,0x5,0x41,0x29,"IID_IDirect3DRefDevice"); + IF_GUID_EQUAL_RETURN(guid,0x5eec05d,0x8f7d,0x4362,0xb9,0x99,0xd1,0xba,0xf3,0x57,0xc7,0x4,"IID_IDirect3DResource9"); + IF_GUID_EQUAL_RETURN(guid,0xb07c4fe5,0x310d,0x4ba8,0xa2,0x3c,0x4f,0xf,0x20,0x6f,0x21,0x8b,"IID_IDirect3DStateBlock9"); + IF_GUID_EQUAL_RETURN(guid,0xcfbaf3a,0x9ff6,0x429a,0x99,0xb3,0xa2,0x79,0x6a,0xf8,0xb8,0x9b,"IID_IDirect3DSurface9"); + IF_GUID_EQUAL_RETURN(guid,0x794950f2,0xadfc,0x458a,0x90,0x5e,0x10,0xa1,0xb,0xb,0x50,0x3b,"IID_IDirect3DSwapChain9"); + IF_GUID_EQUAL_RETURN(guid,0x91886caf,0x1c3d,0x4d2e,0xa0,0xab,0x3e,0x4c,0x7d,0x8d,0x33,0x3,"IID_IDirect3DSwapChain9Ex"); + IF_GUID_EQUAL_RETURN(guid,0x93281502,0x8cf8,0x11d0,0x89,0xab,0x0,0xa0,0xc9,0x5,0x41,0x29,"IID_IDirect3DTexture2"); + IF_GUID_EQUAL_RETURN(guid,0x85c31227,0x3de5,0x4f00,0x9b,0x3a,0xf1,0x1a,0xc3,0x8c,0x18,0xb5,"IID_IDirect3DTexture9"); + IF_GUID_EQUAL_RETURN(guid,0x2CDCD9E0,0x25A0,0x11CF,0xA3,0x1A,0x00,0xAA,0x00,0xB9,0x33,0x56,"IID_IDirect3DTexture"); + IF_GUID_EQUAL_RETURN(guid,0xf5049e78,0x4861,0x11d2,0xa4,0x7,0x0,0xa0,0xc9,0x6,0x29,0xa8,"IID_IDirect3DTnLHalDevice"); + IF_GUID_EQUAL_RETURN(guid,0xf5049e7d,0x4861,0x11d2,0xa4,0x7,0x0,0xa0,0xc9,0x6,0x29,0xa8,"IID_IDirect3DVertexBuffer7"); + IF_GUID_EQUAL_RETURN(guid,0xb64bb1b5,0xfd70,0x4df6,0xbf,0x91,0x19,0xd0,0xa1,0x24,0x55,0xe3,"IID_IDirect3DVertexBuffer9"); + IF_GUID_EQUAL_RETURN(guid,0x7a503555,0x4a83,0x11d1,0xa5,0xdb,0x0,0xa0,0xc9,0x3,0x67,0xf8,"IID_IDirect3DVertexBuffer"); + IF_GUID_EQUAL_RETURN(guid,0xdd13c59c,0x36fa,0x4098,0xa8,0xfb,0xc7,0xed,0x39,0xdc,0x85,0x46,"IID_IDirect3DVertexDeclaration9"); + IF_GUID_EQUAL_RETURN(guid,0xefc5557e,0x6265,0x4613,0x8a,0x94,0x43,0x85,0x78,0x89,0xeb,0x36,"IID_IDirect3DVertexShader9"); + IF_GUID_EQUAL_RETURN(guid,0x93281500,0x8cf8,0x11d0,0x89,0xab,0x0,0xa0,0xc9,0x5,0x41,0x29,"IID_IDirect3DViewport2"); + IF_GUID_EQUAL_RETURN(guid,0xb0ab3b61,0x33d7,0x11d1,0xa9,0x81,0x0,0xc0,0x4f,0xd7,0xb1,0x74,"IID_IDirect3DViewport3"); + IF_GUID_EQUAL_RETURN(guid,0x4417C146,0x33AD,0x11CF,0x81,0x6F,0x00,0x00,0xC0,0x20,0x15,0x6E,"IID_IDirect3DViewport"); + IF_GUID_EQUAL_RETURN(guid,0x24f416e6,0x1f67,0x4aa7,0xb8,0x8e,0xd3,0x3f,0x6f,0x31,0x28,0xa1,"IID_IDirect3DVolume9"); + IF_GUID_EQUAL_RETURN(guid,0x2518526c,0xe789,0x4111,0xa7,0xb9,0x47,0xef,0x32,0x8d,0x13,0xe6,"IID_IDirect3DVolumeTexture9"); + IF_GUID_EQUAL_RETURN(guid,0xB3A6F3E0,0x2B43,0x11CF,0xA2,0xDE,0x00,0xAA,0x00,0xB9,0x33,0x56,"IID_IDirectDraw2"); + IF_GUID_EQUAL_RETURN(guid,0x9c59509a,0x39bd,0x11d1,0x8c,0x4a,0x00,0xc0,0x4f,0xd9,0x30,0xc5,"IID_IDirectDraw4"); + IF_GUID_EQUAL_RETURN(guid,0x15e65ec0,0x3b9c,0x11d2,0xb9,0x2f,0x00,0x60,0x97,0x97,0xea,0x5b,"IID_IDirectDraw7"); + IF_GUID_EQUAL_RETURN(guid,0x6C14DB80,0xA733,0x11CE,0xA5,0x21,0x00,0x20,0xAF,0x0B,0xE5,0x60,"IID_IDirectDraw"); + IF_GUID_EQUAL_RETURN(guid,0x6C14DB85,0xA733,0x11CE,0xA5,0x21,0x00,0x20,0xAF,0x0B,0xE5,0x60,"IID_IDirectDrawClipper"); + IF_GUID_EQUAL_RETURN(guid,0x4B9F0EE0,0x0D7E,0x11D0,0x9B,0x06,0x00,0xA0,0xC9,0x03,0xA3,0xB8,"IID_IDirectDrawColorControl"); + IF_GUID_EQUAL_RETURN(guid,0x69C11C3E,0xB46B,0x11D1,0xAD,0x7A,0x00,0xC0,0x4F,0xC2,0x9B,0x4E,"IID_IDirectDrawGammaControl"); + IF_GUID_EQUAL_RETURN(guid,0x8D56C120,0x6A08,0x11D0,0x9B,0x06,0x00,0xA0,0xC9,0x03,0xA3,0xB8,"IID_IDirectDrawKernel"); + IF_GUID_EQUAL_RETURN(guid,0x6C14DB84,0xA733,0x11CE,0xA5,0x21,0x00,0x20,0xAF,0x0B,0xE5,0x60,"IID_IDirectDrawPalette"); + IF_GUID_EQUAL_RETURN(guid,0x57805885,0x6eec,0x11cf,0x94,0x41,0xa8,0x23,0x03,0xc1,0x0e,0x27,"IID_IDirectDrawSurface2"); + IF_GUID_EQUAL_RETURN(guid,0xDA044E00,0x69B2,0x11D0,0xA1,0xD5,0x00,0xAA,0x00,0xB8,0xDF,0xBB,"IID_IDirectDrawSurface3"); + IF_GUID_EQUAL_RETURN(guid,0x0B2B8630,0xAD35,0x11D0,0x8E,0xA6,0x00,0x60,0x97,0x97,0xEA,0x5B,"IID_IDirectDrawSurface4"); + IF_GUID_EQUAL_RETURN(guid,0x06675a80,0x3b9b,0x11d2,0xb9,0x2f,0x00,0x60,0x97,0x97,0xea,0x5b,"IID_IDirectDrawSurface7"); + IF_GUID_EQUAL_RETURN(guid,0x6C14DB81,0xA733,0x11CE,0xA5,0x21,0x00,0x20,0xAF,0x0B,0xE5,0x60,"IID_IDirectDrawSurface"); + IF_GUID_EQUAL_RETURN(guid,0x60755DA0,0x6A40,0x11D0,0x9B,0x06,0x00,0xA0,0xC9,0x03,0xA3,0xB8,"IID_IDirectDrawSurfaceKernel"); + IF_GUID_EQUAL_RETURN(guid,0x36d39eb0,0xdd75,0x11ce,0xbf,0x0e,0x00,0xaa,0x00,0x55,0x59,0x5a,"IID_IDirectDrawVideo"); + IF_GUID_EQUAL_RETURN(guid,0xB36D93E0,0x2B43,0x11CF,0xA2,0xDE,0x00,0xAA,0x00,0xB9,0x33,0x56,"IID_IDirectDrawVideoPort"); + IF_GUID_EQUAL_RETURN(guid,0xA655FB94,0x0589,0x4E57,0xB3,0x33,0x56,0x7A,0x89,0x46,0x8C,0x88,"IID_IDirectDrawVideoPortNotify"); + IF_GUID_EQUAL_RETURN(guid,0x5944E662,0xAA8A,0x11CF,0xBF,0xC7,0x44,0x45,0x53,0x54,0x00,0x00,"IID_IDirectInput2A"); + IF_GUID_EQUAL_RETURN(guid,0x5944E663,0xAA8A,0x11CF,0xBF,0xC7,0x44,0x45,0x53,0x54,0x00,0x00,"IID_IDirectInput2W"); + IF_GUID_EQUAL_RETURN(guid,0x9A4CB684,0x236D,0x11D3,0x8E,0x9D,0x00,0xC0,0x4F,0x68,0x44,0xAE,"IID_IDirectInput7A"); + IF_GUID_EQUAL_RETURN(guid,0x9A4CB685,0x236D,0x11D3,0x8E,0x9D,0x00,0xC0,0x4F,0x68,0x44,0xAE,"IID_IDirectInput7W"); + IF_GUID_EQUAL_RETURN(guid,0xBF798030,0x483A,0x4DA2,0xAA,0x99,0x5D,0x64,0xED,0x36,0x97,0x00,"IID_IDirectInput8A"); + IF_GUID_EQUAL_RETURN(guid,0xBF798031,0x483A,0x4DA2,0xAA,0x99,0x5D,0x64,0xED,0x36,0x97,0x00,"IID_IDirectInput8W"); + IF_GUID_EQUAL_RETURN(guid,0x89521360,0xAA8A,0x11CF,0xBF,0xC7,0x44,0x45,0x53,0x54,0x00,0x00,"IID_IDirectInputA"); + IF_GUID_EQUAL_RETURN(guid,0x5944E682,0xC92E,0x11CF,0xBF,0xC7,0x44,0x45,0x53,0x54,0x00,0x00,"IID_IDirectInputDevice2A"); + IF_GUID_EQUAL_RETURN(guid,0x5944E683,0xC92E,0x11CF,0xBF,0xC7,0x44,0x45,0x53,0x54,0x00,0x00,"IID_IDirectInputDevice2W"); + IF_GUID_EQUAL_RETURN(guid,0x57D7C6BC,0x2356,0x11D3,0x8E,0x9D,0x00,0xC0,0x4F,0x68,0x44,0xAE,"IID_IDirectInputDevice7A"); + IF_GUID_EQUAL_RETURN(guid,0x57D7C6BD,0x2356,0x11D3,0x8E,0x9D,0x00,0xC0,0x4F,0x68,0x44,0xAE,"IID_IDirectInputDevice7W"); + IF_GUID_EQUAL_RETURN(guid,0x54D41080,0xDC15,0x4833,0xA4,0x1B,0x74,0x8F,0x73,0xA3,0x81,0x79,"IID_IDirectInputDevice8A"); + IF_GUID_EQUAL_RETURN(guid,0x54D41081,0xDC15,0x4833,0xA4,0x1B,0x74,0x8F,0x73,0xA3,0x81,0x79,"IID_IDirectInputDevice8W"); + IF_GUID_EQUAL_RETURN(guid,0x5944E680,0xC92E,0x11CF,0xBF,0xC7,0x44,0x45,0x53,0x54,0x00,0x00,"IID_IDirectInputDeviceA"); + IF_GUID_EQUAL_RETURN(guid,0x5944E681,0xC92E,0x11CF,0xBF,0xC7,0x44,0x45,0x53,0x54,0x00,0x00,"IID_IDirectInputDeviceW"); + IF_GUID_EQUAL_RETURN(guid,0xE7E1F7C0,0x88D2,0x11D0,0x9A,0xD0,0x00,0xA0,0xC9,0xA0,0x6E,0x35,"IID_IDirectInputEffect"); + IF_GUID_EQUAL_RETURN(guid,0x89521361,0xAA8A,0x11CF,0xBF,0xC7,0x44,0x45,0x53,0x54,0x00,0x00,"IID_IDirectInputW"); + IF_GUID_EQUAL_RETURN(guid,0x6fc2cae1,0xbc78,0x11d2,0xaf,0xa6,0x0,0xaa,0x0,0x24,0xd8,0xb6,"IID_IDirectMusic2"); + IF_GUID_EQUAL_RETURN(guid,0x2d3629f7,0x813d,0x4939,0x85,0x08,0xf0,0x5c,0x6b,0x75,0xfd,0x97,"IID_IDirectMusic8"); + IF_GUID_EQUAL_RETURN(guid,0x6536115a,0x7b2d,0x11d2,0xba,0x18,0x00,0x00,0xf8,0x75,0xac,0x12,"IID_IDirectMusic"); + IF_GUID_EQUAL_RETURN(guid,0xd2ac2878,0xb39b,0x11d1,0x87,0x4,0x0,0x60,0x8,0x93,0xb1,0xbd,"IID_IDirectMusicBuffer"); + IF_GUID_EQUAL_RETURN(guid,0xd2ac287c,0xb39b,0x11d1,0x87,0x4,0x0,0x60,0x8,0x93,0xb1,0xbd,"IID_IDirectMusicCollection"); + IF_GUID_EQUAL_RETURN(guid,0xd2ac287b,0xb39b,0x11d1,0x87,0x4,0x0,0x60,0x8,0x93,0xb1,0xbd,"IID_IDirectMusicDownload"); + IF_GUID_EQUAL_RETURN(guid,0xd2ac287e,0xb39b,0x11d1,0x87,0x4,0x0,0x60,0x8,0x93,0xb1,0xbd,"IID_IDirectMusicDownloadedInstrument"); + IF_GUID_EQUAL_RETURN(guid,0xd2ac287d,0xb39b,0x11d1,0x87,0x4,0x0,0x60,0x8,0x93,0xb1,0xbd,"IID_IDirectMusicInstrument"); + IF_GUID_EQUAL_RETURN(guid,0x08f2d8c9,0x37c2,0x11d2,0xb9,0xf9,0x00,0x00,0xf8,0x75,0xac,0x12,"IID_IDirectMusicPort"); + IF_GUID_EQUAL_RETURN(guid,0xd2ac287a,0xb39b,0x11d1,0x87,0x4,0x0,0x60,0x8,0x93,0xb1,0xbd,"IID_IDirectMusicPortDownload"); + IF_GUID_EQUAL_RETURN(guid,0x53cab625,0x2711,0x4c9f,0x9d,0xe7,0x1b,0x7f,0x92,0x5f,0x6f,0xc8,"IID_IDirectMusicSynth8"); + IF_GUID_EQUAL_RETURN(guid,0x9823661,0x5c85,0x11d2,0xaf,0xa6,0x0,0xaa,0x0,0x24,0xd8,0xb6,"IID_IDirectMusicSynth"); + IF_GUID_EQUAL_RETURN(guid,0x9823663,0x5c85,0x11d2,0xaf,0xa6,0x0,0xaa,0x0,0x24,0xd8,0xb6,"IID_IDirectMusicSynthSink"); + IF_GUID_EQUAL_RETURN(guid,0xced153e7,0x3606,0x11d2,0xb9,0xf9,0x00,0x00,0xf8,0x75,0xac,0x12,"IID_IDirectMusicThru"); + IF_GUID_EQUAL_RETURN(guid,0x279AFA86,0x4981,0x11CE,0xA5,0x21,0x00,0x20,0xAF,0x0B,0xE5,0x60,"IID_IDirectSound3DBuffer"); + IF_GUID_EQUAL_RETURN(guid,0x279AFA84,0x4981,0x11CE,0xA5,0x21,0x00,0x20,0xAF,0x0B,0xE5,0x60,"IID_IDirectSound3DListener"); + IF_GUID_EQUAL_RETURN(guid,0xC50A7E93,0xF395,0x4834,0x9E,0xF6,0x7F,0xA9,0x9D,0xE5,0x09,0x66,"IID_IDirectSound8"); + IF_GUID_EQUAL_RETURN(guid,0x279AFA83,0x4981,0x11CE,0xA5,0x21,0x00,0x20,0xAF,0x0B,0xE5,0x60,"IID_IDirectSound"); + IF_GUID_EQUAL_RETURN(guid,0x6825a449,0x7524,0x4d82,0x92,0x0f,0x50,0xe3,0x6a,0xb3,0xab,0x1e,"IID_IDirectSoundBuffer8"); + IF_GUID_EQUAL_RETURN(guid,0x279AFA85,0x4981,0x11CE,0xA5,0x21,0x00,0x20,0xAF,0x0B,0xE5,0x60,"IID_IDirectSoundBuffer"); + IF_GUID_EQUAL_RETURN(guid,0xb0210781,0x89cd,0x11d0,0xaf,0x8,0x0,0xa0,0xc9,0x25,0xcd,0x16,"IID_IDirectSoundCapture"); + IF_GUID_EQUAL_RETURN(guid,0x990df4,0xdbb,0x4872,0x83,0x3e,0x6d,0x30,0x3e,0x80,0xae,0xb6,"IID_IDirectSoundCaptureBuffer8"); + IF_GUID_EQUAL_RETURN(guid,0xb0210782,0x89cd,0x11d0,0xaf,0x8,0x0,0xa0,0xc9,0x25,0xcd,0x16,"IID_IDirectSoundCaptureBuffer"); + IF_GUID_EQUAL_RETURN(guid,0xad74143d,0x903d,0x4ab7,0x80,0x66,0x28,0xd3,0x63,0x03,0x6d,0x65,"IID_IDirectSoundCaptureFXAec"); + IF_GUID_EQUAL_RETURN(guid,0xed311e41,0xfbae,0x4175,0x96,0x25,0xcd,0x8,0x54,0xf6,0x93,0xca,"IID_IDirectSoundCaptureFXNoiseSuppress"); + IF_GUID_EQUAL_RETURN(guid,0x880842e3,0x145f,0x43e6,0xa9,0x34,0xa7,0x18,0x06,0xe5,0x05,0x47,"IID_IDirectSoundFXChorus"); + IF_GUID_EQUAL_RETURN(guid,0x4bbd1154,0x62f6,0x4e2c,0xa1,0x5c,0xd3,0xb6,0xc4,0x17,0xf7,0xa0,"IID_IDirectSoundFXCompressor"); + IF_GUID_EQUAL_RETURN(guid,0x8ecf4326,0x455f,0x4d8b,0xbd,0xa9,0x8d,0x5d,0x3e,0x9e,0x3e,0x0b,"IID_IDirectSoundFXDistortion"); + IF_GUID_EQUAL_RETURN(guid,0x8bd28edf,0x50db,0x4e92,0xa2,0xbd,0x44,0x54,0x88,0xd1,0xed,0x42,"IID_IDirectSoundFXEcho"); + IF_GUID_EQUAL_RETURN(guid,0x903e9878,0x2c92,0x4072,0x9b,0x2c,0xea,0x68,0xf5,0x39,0x67,0x83,"IID_IDirectSoundFXFlanger"); + IF_GUID_EQUAL_RETURN(guid,0xd616f352,0xd622,0x11ce,0xaa,0xc5,0x00,0x20,0xaf,0x0b,0x99,0xa3,"IID_IDirectSoundFXGargle"); + IF_GUID_EQUAL_RETURN(guid,0x4b166a6a,0x0d66,0x43f3,0x80,0xe3,0xee,0x62,0x80,0xde,0xe1,0xa4,"IID_IDirectSoundFXI3DL2Reverb"); + IF_GUID_EQUAL_RETURN(guid,0xc03ca9fe,0xfe90,0x4204,0x80,0x78,0x82,0x33,0x4c,0xd1,0x77,0xda,"IID_IDirectSoundFXParamEq"); + IF_GUID_EQUAL_RETURN(guid,0x46858c3a,0x0dc6,0x45e3,0xb7,0x60,0xd4,0xee,0xf1,0x6c,0xb3,0x25,"IID_IDirectSoundFXWavesReverb"); + IF_GUID_EQUAL_RETURN(guid,0xedcb4c7a,0xdaab,0x4216,0xa4,0x2e,0x6c,0x50,0x59,0x6d,0xdc,0x1d,"IID_IDirectSoundFullDuplex"); + IF_GUID_EQUAL_RETURN(guid,0xb0210783,0x89cd,0x11d0,0xaf,0x8,0x0,0xa0,0xc9,0x25,0xcd,0x16,"IID_IDirectSoundNotify"); + IF_GUID_EQUAL_RETURN(guid,0xfc51a550,0xd5e7,0x11d9,0xaf,0x55,0x00,0x05,0x4e,0x43,0xff,0x02,"IID_IDirectXVideoAccelerationService"); + IF_GUID_EQUAL_RETURN(guid,0xf2b0810a,0xfd00,0x43c9,0x91,0x8c,0xdf,0x94,0xe2,0xd8,0xef,0x7d,"IID_IDirectXVideoDecoder"); + IF_GUID_EQUAL_RETURN(guid,0xfc51a551,0xd5e7,0x11d9,0xaf,0x55,0x00,0x05,0x4e,0x43,0xff,0x02,"IID_IDirectXVideoDecoderService"); + IF_GUID_EQUAL_RETURN(guid,0xb7f916dd,0xdb3b,0x49c1,0x84,0xd7,0xe4,0x5e,0xf9,0x9e,0xc7,0x26,"IID_IDirectXVideoMemoryConfiguration"); + IF_GUID_EQUAL_RETURN(guid,0x8c3a39f0,0x916e,0x4690,0x80,0x4f,0x4c,0x80,0x01,0x35,0x5d,0x25,"IID_IDirectXVideoProcessor"); + IF_GUID_EQUAL_RETURN(guid,0xfc51a552,0xd5e7,0x11d9,0xaf,0x55,0x00,0x05,0x4e,0x43,0xff,0x02,"IID_IDirectXVideoProcessorService"); + IF_GUID_EQUAL_RETURN(guid,0x7988b572,0xec89,0x11cf,0x9c,0x0,0x0,0xaa,0x0,0xa1,0x4f,0x56,"IID_IDiskQuotaControl"); + IF_GUID_EQUAL_RETURN(guid,0x7988b579,0xec89,0x11cf,0x9c,0x0,0x0,0xaa,0x0,0xa1,0x4f,0x56,"IID_IDiskQuotaEvents"); + IF_GUID_EQUAL_RETURN(guid,0x7988b574,0xec89,0x11cf,0x9c,0x0,0x0,0xaa,0x0,0xa1,0x4f,0x56,"IID_IDiskQuotaUser"); + IF_GUID_EQUAL_RETURN(guid,0x7988b576,0xec89,0x11cf,0x9c,0x0,0x0,0xaa,0x0,0xa1,0x4f,0x56,"IID_IDiskQuotaUserBatch"); + IF_GUID_EQUAL_RETURN(guid,0xa6ef9861,0xc720,0x11d0,0x93,0x37,0x0,0xa0,0xc9,0xd,0xca,0xa9,"IID_IDispError"); + IF_GUID_EQUAL_RETURN(guid,0xa6ef9860,0xc720,0x11d0,0x93,0x37,0x0,0xa0,0xc9,0xd,0xca,0xa9,"IID_IDispatchEx"); + IF_GUID_EQUAL_RETURN(guid,0x87D605E0,0xC511,0x11CF,0x89,0xA9,0x00,0xA0,0xC9,0x05,0x41,0x29,"IID_IDocViewSite"); + IF_GUID_EQUAL_RETURN(guid,0xDCD285FE,0x0BE0,0x43BD,0x99,0xC9,0xAA,0xAE,0xC5,0x13,0xC5,0x55,"IID_IDocWrap"); + IF_GUID_EQUAL_RETURN(guid,0x77254866,0x9f5b,0x4c8e,0xb9,0xe2,0xc7,0x7a,0x85,0x30,0xd6,0x4b,"IID_IDownloadCompletedCallback"); + IF_GUID_EQUAL_RETURN(guid,0xfa565b23,0x498c,0x47a0,0x97,0x9d,0xe7,0xd5,0xb1,0x81,0x33,0x60,"IID_IDownloadCompletedCallbackArgs"); + IF_GUID_EQUAL_RETURN(guid,0xc574de85,0x7358,0x43f6,0xaa,0xe8,0x86,0x97,0xe6,0x2d,0x8b,0xa7,"IID_IDownloadJob"); + IF_GUID_EQUAL_RETURN(guid,0x988934a4,0x064b,0x11d3,0xbb,0x80,0x0,0x10,0x4b,0x35,0xe7,0xf9,"IID_IDownloadManager"); + IF_GUID_EQUAL_RETURN(guid,0xd31a5bac,0xf719,0x4178,0x9d,0xbb,0x5e,0x2c,0xb4,0x7f,0xd1,0x8a,"IID_IDownloadProgress"); + IF_GUID_EQUAL_RETURN(guid,0x8c3f1cdd,0x6173,0x4591,0xae,0xbd,0xa5,0x6a,0x53,0xca,0x77,0xc1,"IID_IDownloadProgressChangedCallback"); + IF_GUID_EQUAL_RETURN(guid,0x324ff2c6,0x4981,0x4b04,0x94,0x12,0x57,0x48,0x17,0x45,0xab,0x24,"IID_IDownloadProgressChangedCallbackArgs"); + IF_GUID_EQUAL_RETURN(guid,0xdaa4fdd0,0x4727,0x4dbe,0xa1,0xe7,0x74,0x5d,0xca,0x31,0x71,0x44,"IID_IDownloadResult"); + IF_GUID_EQUAL_RETURN(guid,0x0c87e64e,0x3b7a,0x11d2,0xb9,0xe0,0x00,0xc0,0x4f,0xd8,0xdb,0xf7,"IID_IDsObjectPicker"); + IF_GUID_EQUAL_RETURN(guid,0xe2d3ec9b,0xd041,0x445a,0x8f,0x16,0x47,0x48,0xde,0x8f,0xb1,0xcf,"IID_IDsObjectPickerCredentials"); + IF_GUID_EQUAL_RETURN(guid,0x4131E760,0x1AEA,0x11d0,0x94,0x4B,0x00,0xA0,0xC9,0x05,0x41,0x6E,"IID_IDtcLuConfigure"); + IF_GUID_EQUAL_RETURN(guid,0xac2b8ad2,0xd6f0,0x11d0,0xb3,0x86,0x0,0xa0,0xc9,0x8,0x33,0x65,"IID_IDtcLuRecovery"); + IF_GUID_EQUAL_RETURN(guid,0x4131E762,0x1AEA,0x11d0,0x94,0x4B,0x00,0xA0,0xC9,0x05,0x41,0x6E,"IID_IDtcLuRecoveryFactory"); + IF_GUID_EQUAL_RETURN(guid,0x4131E764,0x1AEA,0x11d0,0x94,0x4B,0x00,0xA0,0xC9,0x05,0x41,0x6E,"IID_IDtcLuRecoveryInitiatedByDtc"); + IF_GUID_EQUAL_RETURN(guid,0x4131E766,0x1AEA,0x11d0,0x94,0x4B,0x00,0xA0,0xC9,0x05,0x41,0x6E,"IID_IDtcLuRecoveryInitiatedByDtcStatusWork"); + IF_GUID_EQUAL_RETURN(guid,0x4131E765,0x1AEA,0x11d0,0x94,0x4B,0x00,0xA0,0xC9,0x05,0x41,0x6E,"IID_IDtcLuRecoveryInitiatedByDtcTransWork"); + IF_GUID_EQUAL_RETURN(guid,0x4131E768,0x1AEA,0x11d0,0x94,0x4B,0x00,0xA0,0xC9,0x05,0x41,0x6E,"IID_IDtcLuRecoveryInitiatedByLu"); + IF_GUID_EQUAL_RETURN(guid,0xac2b8ad1,0xd6f0,0x11d0,0xb3,0x86,0x0,0xa0,0xc9,0x8,0x33,0x65,"IID_IDtcLuRecoveryInitiatedByLuWork"); + IF_GUID_EQUAL_RETURN(guid,0x4131E769,0x1AEA,0x11d0,0x94,0x4B,0x00,0xA0,0xC9,0x05,0x41,0x6E,"IID_IDtcLuRmEnlistment"); + IF_GUID_EQUAL_RETURN(guid,0x4131E771,0x1AEA,0x11d0,0x94,0x4B,0x00,0xA0,0xC9,0x05,0x41,0x6E,"IID_IDtcLuRmEnlistmentFactory"); + IF_GUID_EQUAL_RETURN(guid,0x4131E770,0x1AEA,0x11d0,0x94,0x4B,0x00,0xA0,0xC9,0x05,0x41,0x6E,"IID_IDtcLuRmEnlistmentSink"); + IF_GUID_EQUAL_RETURN(guid,0x4131E773,0x1AEA,0x11d0,0x94,0x4B,0x00,0xA0,0xC9,0x05,0x41,0x6E,"IID_IDtcLuSubordinateDtc"); + IF_GUID_EQUAL_RETURN(guid,0x4131E775,0x1AEA,0x11d0,0x94,0x4B,0x00,0xA0,0xC9,0x05,0x41,0x6E,"IID_IDtcLuSubordinateDtcFactory"); + IF_GUID_EQUAL_RETURN(guid,0x4131E774,0x1AEA,0x11d0,0x94,0x4B,0x00,0xA0,0xC9,0x05,0x41,0x6E,"IID_IDtcLuSubordinateDtcSink"); + IF_GUID_EQUAL_RETURN(guid,0xa7aa013b,0xeb7d,0x4f42,0xb4,0x1c,0xb2,0xde,0xc0,0x9a,0xe0,0x34,"IID_IDtcNetworkAccessConfig2"); + IF_GUID_EQUAL_RETURN(guid,0x9797c15d,0xa428,0x4291,0x87,0xb6,0x9,0x95,0x3,0x1a,0x67,0x8d,"IID_IDtcNetworkAccessConfig"); + IF_GUID_EQUAL_RETURN(guid,0xadefc46b,0xcb1d,0x11d0,0xb1,0x35,0x00,0xc0,0x4f,0xc2,0xf3,0xef,"IID_IDtcToXaHelper"); + IF_GUID_EQUAL_RETURN(guid,0xadefc46a,0xcb1d,0x11d0,0xb1,0x35,0x00,0xc0,0x4f,0xc2,0xf3,0xef,"IID_IDtcToXaHelperFactory"); + IF_GUID_EQUAL_RETURN(guid,0x47ED4971,0x53B3,0x11d1,0xBB,0xB9,0x00,0xC0,0x4F,0xD6,0x58,0xF6,"IID_IDtcToXaHelperSinglePipe"); + IF_GUID_EQUAL_RETURN(guid,0x64FFABE0,0x7CE9,0x11d0,0x8C,0xE6,0x00,0xC0,0x4F,0xDC,0x87,0x7E,"IID_IDtcToXaMapper"); + IF_GUID_EQUAL_RETURN(guid,0x7D0F462F,0x4064,0x4862,0xBC,0x7F,0x93,0x3E,0x50,0x58,0xC1,0x0F,"IID_IDxDiagContainer"); + IF_GUID_EQUAL_RETURN(guid,0x9C6B4CB0,0x23F8,0x49CC,0xA3,0xED,0x45,0xA5,0x50,0x00,0xA6,0xD2,"IID_IDxDiagProvider"); + IF_GUID_EQUAL_RETURN(guid,0x941fabca,0xdd47,0x4fca,0x90,0xbb,0xb0,0xe1,0x2,0x55,0xf2,0xd,"IID_IEffectivePermission2"); + IF_GUID_EQUAL_RETURN(guid,0x3853dc76,0x9f35,0x407c,0x88,0xa1,0xd1,0x93,0x44,0x36,0x5f,0xbc,"IID_IEffectivePermission"); + IF_GUID_EQUAL_RETURN(guid,0x7988b577,0xec89,0x11cf,0x9c,0x0,0x0,0xaa,0x0,0xa1,0x4f,0x56,"IID_IEnumDiskQuotaUsers"); + IF_GUID_EQUAL_RETURN(guid,0xe700be1,0x9db6,0x11d1,0xa1,0xce,0x0,0xc0,0x4f,0xd7,0x5d,0x13,"IID_IEnumExtraSearch"); + IF_GUID_EQUAL_RETURN(guid,0x0ADDA82C,0x2C26,0x11D2,0xAD,0x65,0x00,0xA0,0xC9,0xAF,0x11,0xA6,"IID_IEnumMsmDependency"); + IF_GUID_EQUAL_RETURN(guid,0x0ADDA829,0x2C26,0x11D2,0xAD,0x65,0x00,0xA0,0xC9,0xAF,0x11,0xA6,"IID_IEnumMsmError"); + IF_GUID_EQUAL_RETURN(guid,0x0ADDA826,0x2C26,0x11D2,0xAD,0x65,0x00,0xA0,0xC9,0xAF,0x11,0xA6,"IID_IEnumMsmString"); + IF_GUID_EQUAL_RETURN(guid,0x148BD528L,0xA2AB,0x11CE,0xB1,0x1F,0x00,0xAA,0x00,0x53,0x05,0x03,"IID_IEnumWorkItems"); + IF_GUID_EQUAL_RETURN(guid,0x19f7151,0xe6db,0x11d0,0x83,0xc3,0x0,0xc0,0x4f,0xdd,0xb8,0x2e,"IID_IFECommon"); + IF_GUID_EQUAL_RETURN(guid,0x19f7153,0xe6db,0x11d0,0x83,0xc3,0x0,0xc0,0x4f,0xdd,0xb8,0x2e,"IID_IFEDictionary"); + IF_GUID_EQUAL_RETURN(guid,0x21164102,0xc24a,0x11d1,0x85,0x1a,0x0,0xc0,0x4f,0xcc,0x6b,0x14,"IID_IFELanguage2"); + IF_GUID_EQUAL_RETURN(guid,0x19f7152,0xe6db,0x11d0,0x83,0xc3,0x0,0xc0,0x4f,0xdd,0xb8,0x2e,"IID_IFELanguage"); + IF_GUID_EQUAL_RETURN(guid,0x1e18d10,0x4d8b,0x11d2,0x85,0x5d,0x0,0x60,0x8,0x5,0x93,0x67,"IID_IFileSystemBindData"); + IF_GUID_EQUAL_RETURN(guid,0x56a868ba,0x0ad4,0x11ce,0xb0,0x3a,0x00,0x20,0xaf,0x0b,0xa7,0x70,"IID_IFilterInfo"); + IF_GUID_EQUAL_RETURN(guid,0xdd1d7110,0x7836,0x11cf,0xbf,0x47,0x00,0xaa,0x00,0x55,0x59,0x5a,"IID_IFullScreenVideo"); + IF_GUID_EQUAL_RETURN(guid,0x53479470,0xf1dd,0x11cf,0xbc,0x42,0x00,0xaa,0x00,0xac,0x74,0xf6,"IID_IFullScreenVideoEx"); + IF_GUID_EQUAL_RETURN(guid,0xc23cc370,0x87ef,0x11ce,0x80,0x81,0x00,0x80,0xc7,0x58,0x52,0x7e,"IID_IGetDispenser"); + IF_GUID_EQUAL_RETURN(guid,0x00020023,0,0,0xC0,0,0,0,0,0,0,0x46,"IID_IGetFrame"); + IF_GUID_EQUAL_RETURN(guid,0x8A701DA0L,0x4FEB,0x101B,0xA8,0x2E,0x08,0x00,0x2B,0x2B,0x23,0x37,"IID_IGetOleObject"); + IF_GUID_EQUAL_RETURN(guid,0x91733A60L,0x3F4C,0x101B,0xA3,0xF6,0x00,0xAA,0x00,0x34,0xE4,0xE9,"IID_IGetVBAObject"); + IF_GUID_EQUAL_RETURN(guid,0x613dabd7,0x62b2,0x493e,0x9e,0x65,0xc1,0xe3,0x2a,0x1e,0x0c,0x5e,"IID_IHostAssemblyManager"); + IF_GUID_EQUAL_RETURN(guid,0x7b102a88,0x3f7f,0x496d,0x8f,0xa2,0xc3,0x53,0x74,0xe0,0x1a,0xf3,"IID_IHostAssemblyStore"); + IF_GUID_EQUAL_RETURN(guid,0x50B0CFCE,0x4063,0x4278,0x96,0x73,0xe5,0xcb,0x4e,0xd0,0xbd,0xb8,"IID_IHostAutoEvent"); + IF_GUID_EQUAL_RETURN(guid,0x02CA073C,0x7079,0x4860,0x88,0x0A,0xC2,0xF7,0xA4,0x49,0xC9,0x91,"IID_IHostControl"); + IF_GUID_EQUAL_RETURN(guid,0x6DF710A6,0x26A4,0x4a65,0x8c,0xd5,0x72,0x37,0xb8,0xbd,0xa8,0xdc,"IID_IHostCrst"); + IF_GUID_EQUAL_RETURN(guid,0xd0e80dd3,0x12d4,0x11d3,0xb3,0x9d,0x0,0xc0,0x4f,0xf8,0x17,0x95,"IID_IHostFilter"); + IF_GUID_EQUAL_RETURN(guid,0x5D4EC34E,0xF248,0x457B,0xB6,0x03,0x25,0x5F,0xAA,0xBA,0x0D,0x21,"IID_IHostGCManager"); + IF_GUID_EQUAL_RETURN(guid,0x8BDE9D80,0xEC06,0x41D6,0x83,0xE6,0x22,0x58,0x0E,0xFF,0xCC,0x20,"IID_IHostIoCompletionManager"); + IF_GUID_EQUAL_RETURN(guid,0x1831991C,0xCC53,0x4A31,0xB2,0x18,0x04,0xE9,0x10,0x44,0x64,0x79,"IID_IHostMalloc"); + IF_GUID_EQUAL_RETURN(guid,0x1BF4EC38,0xAFFE,0x4fb9,0x85,0xa6,0x52,0x52,0x68,0xf1,0x5b,0x54,"IID_IHostManualEvent"); + IF_GUID_EQUAL_RETURN(guid,0x7BC698D1,0xF9E3,0x4460,0x9C,0xDE,0xD0,0x42,0x48,0xE9,0xFA,0x25,"IID_IHostMemoryManager"); + IF_GUID_EQUAL_RETURN(guid,0x47EB8E57,0x0846,0x4546,0xAF,0x76,0x6F,0x42,0xFC,0xFC,0x26,0x49,"IID_IHostMemoryNeededCallback"); + IF_GUID_EQUAL_RETURN(guid,0x7AE49844,0xB1E3,0x4683,0xBA,0x7C,0x1E,0x82,0x12,0xEA,0x3B,0x79,"IID_IHostPolicyManager"); + IF_GUID_EQUAL_RETURN(guid,0x7e573ce4,0x343,0x4423,0x98,0xd7,0x63,0x18,0x34,0x8a,0x1d,0x3c,"IID_IHostSecurityContext"); + IF_GUID_EQUAL_RETURN(guid,0x75ad2468,0xa349,0x4d02,0xa7,0x64,0x76,0xa6,0x8a,0xee,0x0c,0x4f,"IID_IHostSecurityManager"); + IF_GUID_EQUAL_RETURN(guid,0x855efd47,0xcc09,0x463a,0xa9,0x7d,0x16,0xac,0xab,0x88,0x26,0x61,"IID_IHostSemaphore"); + IF_GUID_EQUAL_RETURN(guid,0x234330c7,0x5f10,0x4f20,0x96,0x15,0x51,0x22,0xda,0xb7,0xa0,0xac,"IID_IHostSyncManager"); + IF_GUID_EQUAL_RETURN(guid,0xC2275828,0xC4B1,0x4B55,0x82,0xC9,0x92,0x13,0x5F,0x74,0xDF,0x1A,"IID_IHostTask"); + IF_GUID_EQUAL_RETURN(guid,0x997FF24C,0x43B7,0x4352,0x86,0x67,0x0D,0xC0,0x4F,0xAF,0xD3,0x54,"IID_IHostTaskManager"); + IF_GUID_EQUAL_RETURN(guid,0x983D50E2,0xCB15,0x466B,0x80,0xFC,0x84,0x5D,0xC6,0xE8,0xC5,0xFD,"IID_IHostThreadpoolManager"); + IF_GUID_EQUAL_RETURN(guid,0xd643717a,0xfc87,0x4260,0x88,0xac,0x6c,0xe3,0x5f,0x0e,0xc1,0x4e,"IID_IIISApplicationAdmin2"); + IF_GUID_EQUAL_RETURN(guid,0x7C4E1804,0xE342,0x483D,0xA4,0x3E,0xA8,0x50,0xCF,0xCC,0x8D,0x18,"IID_IIISApplicationAdmin"); + IF_GUID_EQUAL_RETURN(guid,0xE8FB8620,0x588F,0x11d2,0x9d,0x61,0x0,0xc0,0x4f,0x79,0xc5,0xfe,"IID_IIisServiceControl"); + IF_GUID_EQUAL_RETURN(guid,0x7c907864,0x346c,0x4aeb,0x8f,0x3f,0x57,0xda,0x28,0x9f,0x96,0x9f,"IID_IImageInformation"); + IF_GUID_EQUAL_RETURN(guid,0x5d8e643a,0xc3a9,0x11d1,0xaf,0xef,0x0,0x80,0x5f,0xc,0x8b,0x6d,"IID_IImePad"); + IF_GUID_EQUAL_RETURN(guid,0x5d8e643b,0xc3a9,0x11d1,0xaf,0xef,0x0,0x80,0x5f,0xc,0x8b,0x6d,"IID_IImePadApplet"); + IF_GUID_EQUAL_RETURN(guid,0x5d8e643c,0xc3a9,0x11d1,0xaf,0xef,0x0,0x80,0x5f,0xc,0x8b,0x6d,"IID_IImeSpecifyApplets"); + IF_GUID_EQUAL_RETURN(guid,0x56b1a988,0x7c0c,0x4aa2,0x86,0x39,0xc3,0xeb,0x5a,0x90,0x22,0x6f,"IID_IInstallReferenceEnum"); + IF_GUID_EQUAL_RETURN(guid,0x582dac66,0xe678,0x449f,0xab,0xa6,0x6f,0xaa,0xec,0x8a,0x93,0x94,"IID_IInstallReferenceItem"); + IF_GUID_EQUAL_RETURN(guid,0x925CBC18,0xA2EA,0x4648,0xBF,0x1C,0xEC,0x8B,0xAD,0xCF,0xE2,0x0A,"IID_IInstallationAgent"); + IF_GUID_EQUAL_RETURN(guid,0xd9a59339,0xe245,0x4dbd,0x96,0x86,0x4d,0x57,0x63,0xe3,0x96,0x24,"IID_IInstallationBehavior"); + IF_GUID_EQUAL_RETURN(guid,0x45f4f6f3,0xd602,0x4f98,0x9a,0x8a,0x3e,0xfa,0x15,0x2a,0xd2,0xd3,"IID_IInstallationCompletedCallback"); + IF_GUID_EQUAL_RETURN(guid,0x250e2106,0x8efb,0x4705,0x96,0x53,0xef,0x13,0xc5,0x81,0xb6,0xa1,"IID_IInstallationCompletedCallbackArgs"); + IF_GUID_EQUAL_RETURN(guid,0x5c209f0b,0xbad5,0x432a,0x95,0x56,0x46,0x99,0xbe,0xd2,0x63,0x8a,"IID_IInstallationJob"); + IF_GUID_EQUAL_RETURN(guid,0x345c8244,0x43a3,0x4e32,0xa3,0x68,0x65,0xf0,0x73,0xb7,0x6f,0x36,"IID_IInstallationProgress"); + IF_GUID_EQUAL_RETURN(guid,0xe01402d5,0xf8da,0x43ba,0xa0,0x12,0x38,0x89,0x4b,0xd0,0x48,0xf1,"IID_IInstallationProgressChangedCallback"); + IF_GUID_EQUAL_RETURN(guid,0xe4f14e1e,0x689d,0x4218,0xa0,0xb9,0xbc,0x18,0x9c,0x48,0x4a,0x01,"IID_IInstallationProgressChangedCallbackArgs"); + IF_GUID_EQUAL_RETURN(guid,0xa43c56d6,0x7451,0x48d4,0xaf,0x96,0xb6,0xcd,0x2d,0x0d,0x9b,0x7a,"IID_IInstallationResult"); + IF_GUID_EQUAL_RETURN(guid,0xE1AA6466,0x9DB4,0x40ba,0xBE,0x03,0x77,0xC3,0x8E,0x8E,0x60,0xB2,"IID_IInternalDocWrap"); + IF_GUID_EQUAL_RETURN(guid,0xa37d00f5,0x7bb0,0x4953,0xb4,0x14,0xf9,0xe9,0x83,0x26,0xf2,0xe8,"IID_IInvalidProductLicenseException"); + IF_GUID_EQUAL_RETURN(guid,0x79427a2b,0xf895,0x40e0,0xbe,0x79,0xb5,0x7d,0xc8,0x2e,0xd2,0x31,"IID_IKernelTransaction"); + IF_GUID_EQUAL_RETURN(guid,0x28F54685,0x06FD,0x11D2,0xB2,0x7A,0x00,0xA0,0xC9,0x22,0x31,0x96,"IID_IKsControl"); + IF_GUID_EQUAL_RETURN(guid,0x28F54685L,0x06FD,0x11D2,0xB2,0x7A,0x00,0xA0,0xC9,0x22,0x31,0x96,"IID_IKsControl"); + IF_GUID_EQUAL_RETURN(guid,0x5FFBAA02L,0x49A3,0x11D0,0x9F,0x36,0x00,0xAA,0x00,0xA2,0x16,0xA1,"IID_IKsDataTypeHandler"); + IF_GUID_EQUAL_RETURN(guid,0xD3ABC7E0L,0x9A61,0x11D0,0xA4,0x0D,0x00,0xA0,0xC9,0x22,0x31,0x96,"IID_IKsInterfaceHandler"); + IF_GUID_EQUAL_RETURN(guid,0xb61178d1L,0xa2d9,0x11cf,0x9e,0x53,0x00,0xaa,0x00,0xa2,0x16,0xa1,"IID_IKsPin"); + IF_GUID_EQUAL_RETURN(guid,0xCD5EBE6BL,0x8B6E,0x11D1,0x8A,0xE0,0x00,0xA0,0xC9,0x22,0x31,0x96,"IID_IKsPinFactory"); + IF_GUID_EQUAL_RETURN(guid,0x31efac30,0x515c,0x11d0,0xa9,0xaa,0x00,0xaa,0x00,0x61,0xbe,0x93,"IID_IKsPropertySet"); + IF_GUID_EQUAL_RETURN(guid,0x4d964ad4,0x5b33,0x11d3,0x8a,0x91,0x00,0xc0,0x4f,0x79,0xeb,0x6d,"IID_ILastResourceManager"); + IF_GUID_EQUAL_RETURN(guid,0xD6B518DD,0x05C7,0x418a,0x89,0xE6,0x4F,0x9C,0xE8,0xC6,0x84,0x1E,"IID_ILogFileItem"); + IF_GUID_EQUAL_RETURN(guid,0x6A2A97E6,0x6851,0x41ea,0x87,0xAD,0x2A,0x82,0x25,0x33,0x58,0x65,"IID_ILogFiles"); + IF_GUID_EQUAL_RETURN(guid,0x8298d101,0xf992,0x43b7,0x8e,0xca,0x50,0x52,0xd8,0x85,0xb9,0x95,"IID_IMSAdminBase2_W"); + IF_GUID_EQUAL_RETURN(guid,0xf612954d,0x3b0b,0x4c56,0x95,0x63,0x22,0x7b,0x7b,0xe6,0x24,0xb4,"IID_IMSAdminBase3_W"); + IF_GUID_EQUAL_RETURN(guid,0xa9e69612,0xb80d,0x11d0,0xb9,0xb9,0x00,0xa0,0xc9,0x22,0xe7,0x50,"IID_IMSAdminBaseSink_W"); + IF_GUID_EQUAL_RETURN(guid,0x70b51430,0xb6ca,0x11d0,0xb9,0xb9,0x00,0xa0,0xc9,0x22,0xe7,0x50,"IID_IMSAdminBase_W"); + IF_GUID_EQUAL_RETURN(guid,0x29ff67ff,0x8050,0x480f,0x9f,0x30,0xcc,0x41,0x63,0x5f,0x2f,0x9d,"IID_IMSImpExpHelp_W"); + IF_GUID_EQUAL_RETURN(guid,0xc3fcc19e,0xa970,0x11d2,0x8b,0x5a,0x00,0xa0,0xc9,0xb7,0xc9,0xc4,"IID_IManagedObject"); + IF_GUID_EQUAL_RETURN(guid,0x6a3ea8b,0x225,0x11d1,0xbf,0x72,0x0,0xc0,0x4f,0xc3,0x1e,0x12,"IID_IMapToken"); + IF_GUID_EQUAL_RETURN(guid,0x56a868b1,0x0ad4,0x11ce,0xb0,0x3a,0x00,0x20,0xaf,0x0b,0xa7,0x70,"IID_IMediaControl"); + IF_GUID_EQUAL_RETURN(guid,0x56a868b6,0x0ad4,0x11ce,0xb0,0x3a,0x00,0x20,0xaf,0x0b,0xa7,0x70,"IID_IMediaEvent"); + IF_GUID_EQUAL_RETURN(guid,0x56a868c0,0x0ad4,0x11ce,0xb0,0x3a,0x00,0x20,0xaf,0x0b,0xa7,0x70,"IID_IMediaEventEx"); + IF_GUID_EQUAL_RETURN(guid,0x56a868b2,0x0ad4,0x11ce,0xb0,0x3a,0x00,0x20,0xaf,0x0b,0xa7,0x70,"IID_IMediaPosition"); + IF_GUID_EQUAL_RETURN(guid,0x56a868bc,0x0ad4,0x11ce,0xb0,0x3a,0x00,0x20,0xaf,0x0b,0xa7,0x70,"IID_IMediaTypeInfo"); + IF_GUID_EQUAL_RETURN(guid,0x211ef15b,0x5317,0x4438,0xb1,0x96,0xde,0xc8,0x7b,0x88,0x76,0x93,"IID_IMetaDataAssemblyEmit"); + IF_GUID_EQUAL_RETURN(guid,0xee62470b,0xe94b,0x424e,0x9b,0x7c,0x2f,0x0,0xc9,0x24,0x9f,0x93,"IID_IMetaDataAssemblyImport"); + IF_GUID_EQUAL_RETURN(guid,0x809c652e,0x7396,0x11d2,0x97,0x71,0x00,0xa0,0xc9,0xb4,0xd5,0x0c,"IID_IMetaDataDispenser"); + IF_GUID_EQUAL_RETURN(guid,0x31bcfce2,0xdafb,0x11d2,0x9f,0x81,0x0,0xc0,0x4f,0x79,0xa0,0xa3,"IID_IMetaDataDispenserEx"); + IF_GUID_EQUAL_RETURN(guid,0xf5dd9950,0xf693,0x42e6,0x83,0xe,0x7b,0x83,0x3e,0x81,0x46,0xa9,"IID_IMetaDataEmit2"); + IF_GUID_EQUAL_RETURN(guid,0xba3fee4c,0xecb9,0x4e41,0x83,0xb7,0x18,0x3f,0xa4,0x1c,0xd8,0x59,"IID_IMetaDataEmit"); + IF_GUID_EQUAL_RETURN(guid,0xb81ff171,0x20f3,0x11d2,0x8d,0xcc,0x0,0xa0,0xc9,0xb0,0x9c,0x19,"IID_IMetaDataError"); + IF_GUID_EQUAL_RETURN(guid,0xd0e80dd1,0x12d4,0x11d3,0xb3,0x9d,0x0,0xc0,0x4f,0xf8,0x17,0x95,"IID_IMetaDataFilter"); + IF_GUID_EQUAL_RETURN(guid,0xfce5efa0,0x8bba,0x4f8e,0xa0,0x36,0x8f,0x20,0x22,0xb0,0x84,0x66,"IID_IMetaDataImport2"); + IF_GUID_EQUAL_RETURN(guid,0x7dac8207,0xd3ae,0x4c75,0x9b,0x67,0x92,0x80,0x1a,0x49,0x7d,0x44,"IID_IMetaDataImport"); + IF_GUID_EQUAL_RETURN(guid,0x7998EA64,0x7F95,0x48B8,0x86,0xFC,0x17,0xCA,0xF4,0x8B,0xF5,0xCB,"IID_IMetaDataInfo"); + IF_GUID_EQUAL_RETURN(guid,0xbadb5f70,0x58da,0x43a9,0xa1,0xc6,0xd7,0x48,0x19,0xf1,0x9b,0x15,"IID_IMetaDataTables2"); + IF_GUID_EQUAL_RETURN(guid,0xd8f579ab,0x402d,0x4b8e,0x82,0xd9,0x5d,0x63,0xb1,0x6,0x5c,0x68,"IID_IMetaDataTables"); + IF_GUID_EQUAL_RETURN(guid,0x4709c9c6,0x81ff,0x11d3,0x9f,0xc7,0x0,0xc0,0x4f,0x79,0xa0,0xa3,"IID_IMetaDataValidate"); + IF_GUID_EQUAL_RETURN(guid,0xebf47182,0x8764,0x11d1,0x9e,0x69,0x0,0xc0,0x4f,0xd7,0xc1,0x5b,"IID_IMixerPinConfig2"); + IF_GUID_EQUAL_RETURN(guid,0x593cdde1,0x759,0x11d1,0x9e,0x69,0x0,0xc0,0x4f,0xd7,0xc1,0x5b,"IID_IMixerPinConfig"); + IF_GUID_EQUAL_RETURN(guid,0xb45dd570,0x3c77,0x11d1,0xab,0xe1,0x00,0xa0,0xc9,0x05,0xf3,0x75,"IID_IMpegAudioDecoder"); + IF_GUID_EQUAL_RETURN(guid,0x0ADDA82D,0x2C26,0x11D2,0xAD,0x65,0x00,0xA0,0xC9,0xAF,0x11,0xA6,"IID_IMsmDependencies"); + IF_GUID_EQUAL_RETURN(guid,0x0ADDA82B,0x2C26,0x11D2,0xAD,0x65,0x00,0xA0,0xC9,0xAF,0x11,0xA6,"IID_IMsmDependency"); + IF_GUID_EQUAL_RETURN(guid,0x0ADDA828,0x2C26,0x11D2,0xAD,0x65,0x00,0xA0,0xC9,0xAF,0x11,0xA6,"IID_IMsmError"); + IF_GUID_EQUAL_RETURN(guid,0x0ADDA82A,0x2C26,0x11D2,0xAD,0x65,0x00,0xA0,0xC9,0xAF,0x11,0xA6,"IID_IMsmErrors"); + IF_GUID_EQUAL_RETURN(guid,0x7041ae26,0x2d78,0x11d2,0x88,0x8a,0x0,0xa0,0xc9,0x81,0xb0,0x15,"IID_IMsmGetFiles"); + IF_GUID_EQUAL_RETURN(guid,0x0ADDA82E,0x2C26,0x11D2,0xAD,0x65,0x00,0xA0,0xC9,0xAF,0x11,0xA6,"IID_IMsmMerge"); + IF_GUID_EQUAL_RETURN(guid,0x0ADDA827,0x2C26,0x11D2,0xAD,0x65,0x00,0xA0,0xC9,0xAF,0x11,0xA6,"IID_IMsmStrings"); + IF_GUID_EQUAL_RETURN(guid,0x0C0E4080,0x9081,0x11d2,0xBE,0xEC,0x00,0x60,0x08,0x2F,0x20,0x54,"IID_INSNetSourceCreator"); + IF_GUID_EQUAL_RETURN(guid,0x4f528693,0x1035,0x43fe,0xb4,0x28,0x75,0x75,0x61,0xad,0x3a,0x68,"IID_INSSBuffer2"); + IF_GUID_EQUAL_RETURN(guid,0xc87ceaaf,0x75be,0x4bc4,0x84,0xeb,0xac,0x27,0x98,0x50,0x76,0x72,"IID_INSSBuffer3"); + IF_GUID_EQUAL_RETURN(guid,0xb6b8fd5a,0x32e2,0x49d4,0xa9,0x10,0xc2,0x6c,0xc8,0x54,0x65,0xed,"IID_INSSBuffer4"); + IF_GUID_EQUAL_RETURN(guid,0xE1CD3524,0x03D7,0x11d2,0x9E,0xED,0x00,0x60,0x97,0xD2,0xD7,0xCF,"IID_INSSBuffer"); + IF_GUID_EQUAL_RETURN(guid,0xfb700430,0x952c,0x11d1,0x94,0x6f,0x0,0x0,0x0,0x0,0x0,0x0,"IID_INamedPropertyBag"); + IF_GUID_EQUAL_RETURN(guid,0x0A15159D,0x41C7,0x4456,0x93,0xE1,0x28,0x4C,0xD6,0x1D,0x4E,0x8D,"IID_IOPMVideoOutput"); + IF_GUID_EQUAL_RETURN(guid,0x00BB2761L,0x6A77,0x11D0,0xA5,0x35,0x00,0xC0,0x4F,0xD7,0xD0,0x62,"IID_IObjMgr"); + IF_GUID_EQUAL_RETURN(guid,0xc460e2b4,0xe199,0x412a,0x84,0x56,0x84,0xdc,0x3e,0x48,0x38,0xc3,"IID_IObjectHandle"); + IF_GUID_EQUAL_RETURN(guid,0xca04b7e6,0xd21,0x11d1,0x8c,0xc5,0x0,0xc0,0x4f,0xc2,0xb0,0x85,"IID_IObjectIdentity"); + IF_GUID_EQUAL_RETURN(guid,0xcb5bdc81,0x93c1,0x11cf,0x8f,0x20,0x0,0x80,0x5f,0x2c,0xd0,0x64,"IID_IObjectSafety"); + IF_GUID_EQUAL_RETURN(guid,0x56a868bd,0x0ad4,0x11ce,0xb0,0x3a,0x00,0x20,0xaf,0x0b,0xa7,0x70,"IID_IPinInfo"); + IF_GUID_EQUAL_RETURN(guid,0x5FAB2547,0x9779,0x11d1,0xB8,0x86,0x00,0xC0,0x4F,0xB9,0x61,0x8A,"IID_IPrepareInfo2"); + IF_GUID_EQUAL_RETURN(guid,0x80c7bfd0,0x87ee,0x11ce,0x80,0x81,0x00,0x80,0xc7,0x58,0x52,0x7e,"IID_IPrepareInfo"); + IF_GUID_EQUAL_RETURN(guid,0x7def34c1,0x9d92,0x4c99,0xb3,0xb3,0xdb,0x94,0xa9,0xd4,0x19,0x1b,"IID_IPrintAsyncNotifyCallback"); + IF_GUID_EQUAL_RETURN(guid,0x4a5031b1,0x1f3f,0x4db0,0xa4,0x62,0x45,0x30,0xed,0x8b,0x04,0x51,"IID_IPrintAsyncNotifyChannel"); + IF_GUID_EQUAL_RETURN(guid,0x77cf513e,0x5d49,0x4789,0x9f,0x30,0xd0,0x82,0x2b,0x33,0x5c,0x0d,"IID_IPrintAsyncNotifyDataObject"); + IF_GUID_EQUAL_RETURN(guid,0x5852a2c3,0x6530,0x11d1,0xb6,0xa3,0x0,0x0,0xf8,0x75,0x7b,0xf9,"IID_IPrintDialogCallback"); + IF_GUID_EQUAL_RETURN(guid,0x509aaeda,0x5639,0x11d1,0xb6,0xa1,0x0,0x0,0xf8,0x75,0x7b,0xf9,"IID_IPrintDialogServices"); + IF_GUID_EQUAL_RETURN(guid,0xebbc7c04,0x315e,0x11d2,0xb6,0x2f,0x0,0x60,0x97,0xdf,0x5b,0xd4,"IID_IProgressDialog"); + IF_GUID_EQUAL_RETURN(guid,0x10e2414a,0xec59,0x49d2,0xbc,0x51,0x5a,0xdd,0x2c,0x36,0xfe,0xbc,"IID_IProvideRuntimeContext"); + IF_GUID_EQUAL_RETURN(guid,0x4086658aL,0xcbbb,0x11cf,0xb6,0x04,0x00,0xc0,0x4f,0xd8,0xd5,0x65,"IID_IProvideTaskPage"); + IF_GUID_EQUAL_RETURN(guid,0x1bd0ecb0,0xf8e2,0x11ce,0xaa,0xc6,0x00,0x20,0xaf,0x0b,0x99,0xa3,"IID_IQualProp"); + IF_GUID_EQUAL_RETURN(guid,0xc46ca590,0x3c3f,0x11d2,0xbe,0xe6,0x00,0x00,0xf8,0x05,0xca,0x57,"IID_IQueryAssociations"); + IF_GUID_EQUAL_RETURN(guid,0x56a868b7,0x0ad4,0x11ce,0xb0,0x3a,0x00,0x20,0xaf,0x0b,0xa7,0x70,"IID_IQueueCommand"); + IF_GUID_EQUAL_RETURN(guid,0xE793F6D1,0xF53D,0x11cf,0xA6,0x0D,0x00,0xA0,0xC9,0x05,0x41,0x6E,"IID_IRMHelper"); + IF_GUID_EQUAL_RETURN(guid,0x71EAF260,0x0CE0,0x11D0,0xA5,0x3E,0x00,0xA0,0xC9,0x0C,0x20,0x91,"IID_IReadCookie"); + IF_GUID_EQUAL_RETURN(guid,0x56a86897,0x0ad4,0x11ce,0xb0,0x3a,0x00,0x20,0xaf,0x0b,0xa7,0x70,"IID_IReferenceClock"); + IF_GUID_EQUAL_RETURN(guid,0x56a868bb,0x0ad4,0x11ce,0xb0,0x3a,0x00,0x20,0xaf,0x0b,0xa7,0x70,"IID_IRegFilterInfo"); + IF_GUID_EQUAL_RETURN(guid,0xD97A6DA0,0xA861,0x11cf,0x93,0xAE,0x00,0xA0,0xC9,0x0C,0x2B,0xD8,"IID_IRequest"); + IF_GUID_EQUAL_RETURN(guid,0xD97A6DA0,0xA85F,0x11df,0x83,0xAE,0x00,0xA0,0xC9,0x0C,0x2B,0xD8,"IID_IRequestDictionary"); + IF_GUID_EQUAL_RETURN(guid,0xd136c69a,0xf749,0x11d1,0x8f,0x47,0x0,0xc0,0x4f,0x8e,0xe5,0x7d,"IID_IResourceManager2"); + IF_GUID_EQUAL_RETURN(guid,0x3741d21,0x87eb,0x11ce,0x80,0x81,0x00,0x80,0xc7,0x58,0x52,0x7e,"IID_IResourceManager"); + IF_GUID_EQUAL_RETURN(guid,0x6b369c21,0xfbd2,0x11d1,0x8f,0x47,0x0,0xc0,0x4f,0x8e,0xe5,0x7d,"IID_IResourceManagerFactory2"); + IF_GUID_EQUAL_RETURN(guid,0x13741d20,0x87eb,0x11ce,0x80,0x81,0x00,0x80,0xc7,0x58,0x52,0x7e,"IID_IResourceManagerFactory"); + IF_GUID_EQUAL_RETURN(guid,0x0D563181,0xDEFB,0x11ce,0xAE,0xD1,0x00,0xAA,0x00,0x51,0xE2,0xC4,"IID_IResourceManagerSink"); + IF_GUID_EQUAL_RETURN(guid,0xD97A6DA0,0xA864,0x11cf,0x83,0xBE,0x00,0xA0,0xC9,0x0C,0x2B,0xD8,"IID_IResponse"); + IF_GUID_EQUAL_RETURN(guid,0xF17324c4,0x68E0,0x11D0,0xAD,0x45,0x00,0xC0,0x4F,0xC2,0x98,0x63,"IID_IRowsetADCExtensions"); + IF_GUID_EQUAL_RETURN(guid,0x0C733A8FL,0x2A1C,0x11CE,0xAD,0xE5,0x00,0xAA,0x00,0x44,0x77,0x3D,"IID_IRowsetChangeExtInfo"); + IF_GUID_EQUAL_RETURN(guid,0x5cf4ca13,0xef21,0x11d0,0x97,0xe7,0x0,0xc0,0x4f,0xc2,0xad,0x98,"IID_IRowsetFastLoad"); + IF_GUID_EQUAL_RETURN(guid,0x1e837070,0xbcfc,0x11d1,0x9a,0x2c,0x0,0xa0,0xc9,0x3,0xaa,0x45,"IID_IRowsetProperties"); + IF_GUID_EQUAL_RETURN(guid,0x1be41e60,0x807a,0x11d1,0x9a,0x14,0x0,0xa0,0xc9,0x3,0xaa,0x45,"IID_IRowsetSynchronize"); + IF_GUID_EQUAL_RETURN(guid,0x228972f1,0xb5ff,0x11d0,0x8a,0x80,0x0,0xc0,0x4f,0xd6,0x11,0xcd,"IID_ISQLGetDiagField"); + IF_GUID_EQUAL_RETURN(guid,0x228972f0,0xb5ff,0x11d0,0x8a,0x80,0x0,0xc0,0x4f,0xd6,0x11,0xcd,"IID_ISQLRequestDiagFields"); + IF_GUID_EQUAL_RETURN(guid,0x5cf4ca12,0xef21,0x11d0,0x97,0xe7,0x0,0xc0,0x4f,0xc2,0xad,0x98,"IID_ISQLServerErrorInfo"); + IF_GUID_EQUAL_RETURN(guid,0xd22a7678L,0xf860,0x40cd,0xa5,0x67,0x15,0x63,0xde,0xb4,0x6d,0x49,"IID_ISQLXMLHelper"); + IF_GUID_EQUAL_RETURN(guid,0xa6b952f0L,0xa4b1,0x11d0,0x99,0x7d,0x00,0xaa,0x00,0x68,0x87,0xec,"IID_IScheduledWorkItem"); + IF_GUID_EQUAL_RETURN(guid,0x4c2389fb,0x2511,0x11d4,0xb2,0x58,0x0,0xc0,0x4f,0x79,0x71,0xce,"IID_ISchemaLock"); + IF_GUID_EQUAL_RETURN(guid,0xaee2a95,0xbcbb,0x11d0,0x8c,0x72,0x0,0xc0,0x4f,0xc2,0xb0,0x85,"IID_IScriptEntry"); + IF_GUID_EQUAL_RETURN(guid,0xaee2a94,0xbcbb,0x11d0,0x8c,0x72,0x0,0xc0,0x4f,0xc2,0xb0,0x85,"IID_IScriptNode"); + IF_GUID_EQUAL_RETURN(guid,0xaee2a96,0xbcbb,0x11d0,0x8c,0x72,0x0,0xc0,0x4f,0xc2,0xb0,0x85,"IID_IScriptScriptlet"); + IF_GUID_EQUAL_RETURN(guid,0xD97A6DA0,0xA868,0x11cf,0x83,0xAE,0x00,0xB0,0xC9,0x0C,0x2B,0xD8,"IID_IScriptingContext"); + IF_GUID_EQUAL_RETURN(guid,0x88aee058,0xd4b0,0x4725,0xa2,0xf1,0x81,0x4a,0x67,0xae,0x96,0x4c,"IID_ISearchCompletedCallback"); + IF_GUID_EQUAL_RETURN(guid,0xa700a634,0x2850,0x4c47,0x93,0x8a,0x9e,0x4b,0x6e,0x5a,0xf9,0xa6,"IID_ISearchCompletedCallbackArgs"); + IF_GUID_EQUAL_RETURN(guid,0x7366ea16,0x7a1a,0x4ea2,0xb0,0x42,0x97,0x3d,0x3e,0x9c,0xd9,0x9b,"IID_ISearchJob"); + IF_GUID_EQUAL_RETURN(guid,0xd40cff62,0xe08c,0x4498,0x94,0x1a,0x01,0xe2,0x5f,0x0f,0xd3,0x3c,"IID_ISearchResult"); + IF_GUID_EQUAL_RETURN(guid,0xc3ccfdb4,0x6f88,0x11d2,0xa3,0xce,0x0,0xc0,0x4f,0xb1,0x78,0x2a,"IID_ISecurityInformation2"); + IF_GUID_EQUAL_RETURN(guid,0xe2cdc9cc,0x31bd,0x4f8f,0x8c,0x8b,0xb6,0x41,0xaf,0x51,0x6a,0x1a,"IID_ISecurityInformation3"); + IF_GUID_EQUAL_RETURN(guid,0xea961070,0xcd14,0x4621,0xac,0xe4,0xf6,0x3c,0x3,0xe5,0x83,0xe4,"IID_ISecurityInformation4"); + IF_GUID_EQUAL_RETURN(guid,0x965fc360,0x16ff,0x11d0,0x91,0xcb,0x0,0xaa,0x0,0xbb,0xb7,0x23,"IID_ISecurityInformation"); + IF_GUID_EQUAL_RETURN(guid,0xfc3066eb,0x79ef,0x444b,0x91,0x11,0xd1,0x8a,0x75,0xeb,0xf2,0xfa,"IID_ISecurityObjectTypeInfo"); + IF_GUID_EQUAL_RETURN(guid,0xD97A6DA0,0xA867,0x11cf,0x83,0xAE,0x01,0xA0,0xC9,0x0C,0x2B,0xD8,"IID_IServer"); + IF_GUID_EQUAL_RETURN(guid,0xD97A6DA0,0xA865,0x11cf,0x83,0xAF,0x00,0xA0,0xC9,0x0C,0x2B,0xD8,"IID_ISessionObject"); + IF_GUID_EQUAL_RETURN(guid,0x93f2f68c,0x1d1b,0x11d3,0xa3,0xe,0x0,0xc0,0x4f,0x79,0xab,0xd1,"IID_IShellFolder2"); + IF_GUID_EQUAL_RETURN(guid,0x4c437b91,0x6e9e,0x11d1,0xa7,0x4,0x0,0x60,0x97,0xc4,0xe4,0x76,"IID_ISpecifyParticularPages"); + IF_GUID_EQUAL_RETURN(guid,0x6CFA5A80L,0x2DC8,0x11D0,0x90,0xEA,0x00,0xAA,0x00,0x60,0xF8,0x6C,"IID_IStiDevice"); + IF_GUID_EQUAL_RETURN(guid,0x128A9860L,0x52DC,0x11D0,0x9E,0xDF,0x44,0x45,0x53,0x54,0x00,0x00,"IID_IStiDeviceControl"); + IF_GUID_EQUAL_RETURN(guid,0x0C9BB460L,0x51AC,0x11D0,0x90,0xEA,0x00,0xAA,0x00,0x60,0xF8,0x6C,"IID_IStiUSD"); + IF_GUID_EQUAL_RETURN(guid,0x641BD880L,0x2DC8,0x11D0,0x90,0xEA,0x00,0xAA,0x00,0x60,0xF8,0x6C,"IID_IStillImageW"); + IF_GUID_EQUAL_RETURN(guid,0xeff90582,0x2ddc,0x480f,0xa0,0x6d,0x60,0xf3,0xfb,0xc3,0x62,0xc3,"IID_IStringCollection"); + IF_GUID_EQUAL_RETURN(guid,0xD97A6DA0,0xA85D,0x11cf,0x83,0xAE,0x00,0xA0,0xC9,0x0C,0x2B,0xD8,"IID_IStringList"); + IF_GUID_EQUAL_RETURN(guid,0x74c26041,0x70d1,0x11d1,0xb7,0x5a,0x0,0xa0,0xc9,0x5,0x64,0xfe,"IID_ISynchronizedCallBack"); + IF_GUID_EQUAL_RETURN(guid,0xade87bf7,0x7b56,0x4275,0x8f,0xab,0xb9,0xb0,0xe5,0x91,0x84,0x4b,"IID_ISystemInformation"); + IF_GUID_EQUAL_RETURN(guid,0x08e3206a,0x5fd2,0x4fde,0xa8,0xa5,0x8c,0xb3,0xb6,0x3d,0x26,0x77,"IID_ISystemMonitor2"); + IF_GUID_EQUAL_RETURN(guid,0x194EB241,0xC32C,0x11cf,0x93,0x98,0x00,0xAA,0x00,0xA3,0xDD,0xEA,"IID_ISystemMonitor"); + IF_GUID_EQUAL_RETURN(guid,0xEE660EA0,0x4ABD,0x11cf,0x94,0x3A,0x00,0x80,0x29,0x00,0x43,0x47,"IID_ISystemMonitorEvents"); + IF_GUID_EQUAL_RETURN(guid,0x148BD524L,0xA2AB,0x11CE,0xB1,0x1F,0x00,0xAA,0x00,0x53,0x05,0x03,"IID_ITask"); + IF_GUID_EQUAL_RETURN(guid,0x148BD527L,0xA2AB,0x11CE,0xB1,0x1F,0x00,0xAA,0x00,0x53,0x05,0x03,"IID_ITaskScheduler"); + IF_GUID_EQUAL_RETURN(guid,0x148BD52BL,0xA2AB,0x11CE,0xB1,0x1F,0x00,0xAA,0x00,0x53,0x05,0x03,"IID_ITaskTrigger"); + IF_GUID_EQUAL_RETURN(guid,0x28888fe3,0xc2a0,0x483a,0xa3,0xea,0x8c,0xb1,0xce,0x51,0xff,0x3d,"IID_ITextStoreACP"); + IF_GUID_EQUAL_RETURN(guid,0xA2DE3BC2,0x3D8E,0x11d3,0x81,0xA9,0xF7,0x53,0xFB,0xE6,0x1A,0x00,"IID_ITextStoreACPEx"); + IF_GUID_EQUAL_RETURN(guid,0x22d44c94,0xa419,0x4542,0xa2,0x72,0xae,0x26,0x09,0x3e,0xce,0xcf,"IID_ITextStoreACPSink"); + IF_GUID_EQUAL_RETURN(guid,0x2bdf9464,0x41e2,0x43e3,0x95,0x0c,0xa6,0x86,0x5b,0xa2,0x5c,0xd4,"IID_ITextStoreACPSinkEx"); + IF_GUID_EQUAL_RETURN(guid,0x9b2077b0,0x5f18,0x4dec,0xbe,0xe9,0x3c,0xc7,0x22,0xf5,0xdf,0xe0,"IID_ITextStoreAnchor"); + IF_GUID_EQUAL_RETURN(guid,0xA2DE3BC1,0x3D8E,0x11d3,0x81,0xA9,0xF7,0x53,0xFB,0xE6,0x1A,0x00,"IID_ITextStoreAnchorEx"); + IF_GUID_EQUAL_RETURN(guid,0xaa80e905,0x2021,0x11d2,0x93,0xe0,0x00,0x60,0xb0,0x67,0xb8,0x6e,"IID_ITextStoreAnchorSink"); + IF_GUID_EQUAL_RETURN(guid,0x25642426,0x028d,0x4474,0x97,0x7b,0x11,0x1b,0xb1,0x14,0xfe,0x3e,"IID_ITextStoreSinkAnchorEx"); + IF_GUID_EQUAL_RETURN(guid,0x5731eaa0,0x6bc2,0x4681,0xa5,0x32,0x92,0xfb,0xb7,0x4d,0x7c,0x41,"IID_ITfInputScope2"); + IF_GUID_EQUAL_RETURN(guid,0xfde1eaee,0x6924,0x4cdf,0x91,0xe7,0xda,0x38,0xcf,0xf5,0x55,0x9d,"IID_ITfInputScope"); + IF_GUID_EQUAL_RETURN(guid,0xb5f8fb3b,0x393f,0x4f7c,0x84,0xcb,0x50,0x49,0x24,0xc2,0x70,0x5a,"IID_ITfMSAAControl"); + IF_GUID_EQUAL_RETURN(guid,0x90e9a944,0x9244,0x489f,0xa7,0x8f,0xde,0x67,0xaf,0xc0,0x13,0xa7,"IID_ITfSpeechUIServer"); + IF_GUID_EQUAL_RETURN(guid,0x17cf72d1,0xbac5,0x11d1,0xb1,0xbf,0x0,0xc0,0x4f,0xc2,0xf3,0xef,"IID_ITipHelper"); + IF_GUID_EQUAL_RETURN(guid,0x17cf72d2,0xbac5,0x11d1,0xb1,0xbf,0x0,0xc0,0x4f,0xc2,0xf3,0xef,"IID_ITipPullSink"); + IF_GUID_EQUAL_RETURN(guid,0x17cf72d0,0xbac5,0x11d1,0xb1,0xbf,0x0,0xc0,0x4f,0xc2,0xf3,0xef,"IID_ITipTransaction"); + IF_GUID_EQUAL_RETURN(guid,0x30274F88,0x6EE4,0x474e,0x9B,0x95,0x78,0x07,0xBC,0x9E,0xF8,0xCF,"IID_ITmNodeName"); + IF_GUID_EQUAL_RETURN(guid,0x34021548,0x0065,0x11d3,0xba,0xc1,0x00,0xc0,0x4f,0x79,0x7b,0xe2,"IID_ITransaction2"); + IF_GUID_EQUAL_RETURN(guid,0x0fb15084,0xaf41,0x11ce,0xbd,0x2b,0x20,0x4c,0x4f,0x4f,0x50,0x20,"IID_ITransaction"); + IF_GUID_EQUAL_RETURN(guid,0x02656950,0x2152,0x11d0,0x94,0x4C,0x00,0xA0,0xC9,0x05,0x41,0x6E,"IID_ITransactionCloner"); + IF_GUID_EQUAL_RETURN(guid,0x3A6AD9E1,0x23B9,0x11cf,0xAD,0x60,0x00,0xAA,0x00,0xA7,0x4C,0xCD,"IID_ITransactionDispenser"); + IF_GUID_EQUAL_RETURN(guid,0x0fb15081,0xaf41,0x11ce,0xbd,0x2b,0x20,0x4c,0x4f,0x4f,0x50,0x20,"IID_ITransactionEnlistmentAsync"); + IF_GUID_EQUAL_RETURN(guid,0x0141fda5,0x8fc0,0x11ce,0xbd,0x18,0x20,0x4c,0x4f,0x4f,0x50,0x20,"IID_ITransactionExport"); + IF_GUID_EQUAL_RETURN(guid,0xE1CF9B53,0x8745,0x11ce,0xA9,0xBA,0x00,0xAA,0x00,0x6C,0x37,0x06,"IID_ITransactionExportFactory"); + IF_GUID_EQUAL_RETURN(guid,0xE1CF9B5A,0x8745,0x11ce,0xA9,0xBA,0x00,0xAA,0x00,0x6C,0x37,0x06,"IID_ITransactionImport"); + IF_GUID_EQUAL_RETURN(guid,0x0141fda4,0x8fc0,0x11ce,0xbd,0x18,0x20,0x4c,0x4f,0x4f,0x50,0x20,"IID_ITransactionImportWhereabouts"); + IF_GUID_EQUAL_RETURN(guid,0xC82BD533,0x5B30,0x11D3,0x8A,0x91,0x00,0xC0,0x4F,0x79,0xEB,0x6D,"IID_ITransactionLastEnlistmentAsync"); + IF_GUID_EQUAL_RETURN(guid,0xC82BD532,0x5B30,0x11D3,0x8A,0x91,0x00,0xC0,0x4F,0x79,0xEB,0x6D,"IID_ITransactionLastResourceAsync"); + IF_GUID_EQUAL_RETURN(guid,0x3A6AD9E0,0x23B9,0x11cf,0xAD,0x60,0x00,0xAA,0x00,0xA7,0x4C,0xCD,"IID_ITransactionOptions"); + IF_GUID_EQUAL_RETURN(guid,0x3A6AD9E2,0x23B9,0x11cf,0xAD,0x60,0x00,0xAA,0x00,0xA7,0x4C,0xCD,"IID_ITransactionOutcomeEvents"); + IF_GUID_EQUAL_RETURN(guid,0x82DC88E1,0xA954,0x11d1,0x8F,0x88,0x00,0x60,0x08,0x95,0xE7,0xD5,"IID_ITransactionPhase0EnlistmentAsync"); + IF_GUID_EQUAL_RETURN(guid,0x82DC88E0,0xA954,0x11d1,0x8F,0x88,0x00,0x60,0x08,0x95,0xE7,0xD5,"IID_ITransactionPhase0Factory"); + IF_GUID_EQUAL_RETURN(guid,0xEF081809,0x0C76,0x11d2,0x87,0xA6,0x00,0xC0,0x4F,0x99,0x0F,0x34,"IID_ITransactionPhase0NotifyAsync"); + IF_GUID_EQUAL_RETURN(guid,0x59313E03,0xB36C,0x11cf,0xA5,0x39,0x00,0xAA,0x00,0x68,0x87,0xC3,"IID_ITransactionReceiver"); + IF_GUID_EQUAL_RETURN(guid,0x59313E02,0xB36C,0x11cf,0xA5,0x39,0x00,0xAA,0x00,0x68,0x87,0xC3,"IID_ITransactionReceiverFactory"); + IF_GUID_EQUAL_RETURN(guid,0xEE5FF7B3,0x4572,0x11d0,0x94,0x52,0x00,0xA0,0xC9,0x05,0x41,0x6E,"IID_ITransactionResource"); + IF_GUID_EQUAL_RETURN(guid,0x69E971F0,0x23CE,0x11cf,0xAD,0x60,0x00,0xAA,0x00,0xA7,0x4C,0xCD,"IID_ITransactionResourceAsync"); + IF_GUID_EQUAL_RETURN(guid,0x59313E01,0xB36C,0x11cf,0xA5,0x39,0x00,0xAA,0x00,0x68,0x87,0xC3,"IID_ITransactionTransmitter"); + IF_GUID_EQUAL_RETURN(guid,0x59313E00,0xB36C,0x11cf,0xA5,0x39,0x00,0xAA,0x00,0x68,0x87,0xC3,"IID_ITransactionTransmitterFactory"); + IF_GUID_EQUAL_RETURN(guid,0x5433376c,0x414d,0x11d3,0xb2,0x6,0x0,0xc0,0x4f,0xc2,0xf3,0xef,"IID_ITransactionVoterBallotAsync2"); + IF_GUID_EQUAL_RETURN(guid,0x5433376a,0x414d,0x11d3,0xb2,0x6,0x0,0xc0,0x4f,0xc2,0xf3,0xef,"IID_ITransactionVoterFactory2"); + IF_GUID_EQUAL_RETURN(guid,0x5433376b,0x414d,0x11d3,0xb2,0x6,0x0,0xc0,0x4f,0xc2,0xf3,0xef,"IID_ITransactionVoterNotifyAsync2"); + IF_GUID_EQUAL_RETURN(guid,0x1dc9ca50,0x6ef,0x11d2,0x84,0x15,0x00,0x60,0x08,0xc3,0xfb,0xfc,"IID_ITridentEventSink"); + IF_GUID_EQUAL_RETURN(guid,0x8F026EDB,0x785E,0x4470,0xA8,0xE1,0xB4,0xE8,0x4E,0x9D,0x17,0x79,"IID_ITypeLibResolver"); + IF_GUID_EQUAL_RETURN(guid,0xB81FF171,0x20F3,0x11d2,0x8d,0xcc,0x00,0xa0,0xc9,0xb0,0x05,0x22,"IID_ITypeName"); + IF_GUID_EQUAL_RETURN(guid,0xB81FF171,0x20F3,0x11d2,0x8d,0xcc,0x00,0xa0,0xc9,0xb0,0x05,0x23,"IID_ITypeNameBuilder"); + IF_GUID_EQUAL_RETURN(guid,0xB81FF171,0x20F3,0x11d2,0x8d,0xcc,0x00,0xa0,0xc9,0xb0,0x05,0x21,"IID_ITypeNameFactory"); + IF_GUID_EQUAL_RETURN(guid,0x5cf4ca14,0xef21,0x11d0,0x97,0xe7,0x0,0xc0,0x4f,0xc2,0xad,0x98,"IID_IUMSInitialize"); + IF_GUID_EQUAL_RETURN(guid,0x144fe9b0,0xd23d,0x4a8b,0x86,0x34,0xfb,0x44,0x57,0x53,0x3b,0x7a,"IID_IUpdate2"); + IF_GUID_EQUAL_RETURN(guid,0x112EDA6B,0x95B3,0x476F,0x9D,0x90,0xAE,0xE8,0x2C,0x6B,0x81,0x81,"IID_IUpdate3"); + IF_GUID_EQUAL_RETURN(guid,0x27e94b0d,0x5139,0x49a2,0x9a,0x61,0x93,0x52,0x2d,0xc5,0x46,0x52,"IID_IUpdate4"); + IF_GUID_EQUAL_RETURN(guid,0xc1c2f21a,0xd2f4,0x4902,0xb5,0xc6,0x8a,0x08,0x1c,0x19,0xa8,0x90,"IID_IUpdate5"); + IF_GUID_EQUAL_RETURN(guid,0x6a92b07a,0xd821,0x4682,0xb4,0x23,0x5c,0x80,0x50,0x22,0xcc,0x4d,"IID_IUpdate"); + IF_GUID_EQUAL_RETURN(guid,0x07f7438c,0x7709,0x4ca5,0xb5,0x18,0x91,0x27,0x92,0x88,0x13,0x4e,"IID_IUpdateCollection"); + IF_GUID_EQUAL_RETURN(guid,0xc97ad11b,0xf257,0x420b,0x9d,0x9f,0x37,0x7f,0x73,0x3f,0x6f,0x68,"IID_IUpdateDownloadContent2"); + IF_GUID_EQUAL_RETURN(guid,0x54a2cb2d,0x9a0c,0x48b6,0x8a,0x50,0x9a,0xbb,0x69,0xee,0x2d,0x02,"IID_IUpdateDownloadContent"); + IF_GUID_EQUAL_RETURN(guid,0xbc5513c8,0xb3b8,0x4bf7,0xa4,0xd4,0x36,0x1c,0x0d,0x8c,0x88,0xba,"IID_IUpdateDownloadContentCollection"); + IF_GUID_EQUAL_RETURN(guid,0xbf99af76,0xb575,0x42ad,0x8a,0xa4,0x33,0xcb,0xb5,0x47,0x7a,0xf1,"IID_IUpdateDownloadResult"); + IF_GUID_EQUAL_RETURN(guid,0x68f1c6f9,0x7ecc,0x4666,0xa4,0x64,0x24,0x7f,0xe1,0x24,0x96,0xc3,"IID_IUpdateDownloader"); + IF_GUID_EQUAL_RETURN(guid,0xa376dd5e,0x09d4,0x427f,0xaf,0x7c,0xfe,0xd5,0xb6,0xe1,0xc1,0xd6,"IID_IUpdateException"); + IF_GUID_EQUAL_RETURN(guid,0x503626a3,0x8e14,0x4729,0x93,0x55,0x0f,0xe6,0x64,0xbd,0x23,0x21,"IID_IUpdateExceptionCollection"); + IF_GUID_EQUAL_RETURN(guid,0xc2bfb780,0x4539,0x4132,0xab,0x8c,0x0a,0x87,0x72,0x01,0x3a,0xb6,"IID_IUpdateHistoryEntry2"); + IF_GUID_EQUAL_RETURN(guid,0xbe56a644,0xaf0e,0x4e0e,0xa3,0x11,0xc1,0xd8,0xe6,0x95,0xcb,0xff,"IID_IUpdateHistoryEntry"); + IF_GUID_EQUAL_RETURN(guid,0xa7f04f3c,0xa290,0x435b,0xaa,0xdf,0xa1,0x16,0xc3,0x35,0x7a,0x5c,"IID_IUpdateHistoryEntryCollection"); + IF_GUID_EQUAL_RETURN(guid,0x46297823,0x9940,0x4c09,0xae,0xd9,0xcd,0x3e,0xa6,0xd0,0x59,0x68,"IID_IUpdateIdentity"); + IF_GUID_EQUAL_RETURN(guid,0xa0385420,0x62b8,0x11d1,0x9a,0x6,0x0,0xa0,0xc9,0x3,0xaa,0x45,"IID_IUpdateInfo"); + IF_GUID_EQUAL_RETURN(guid,0xd940f0f8,0x3cbb,0x4fd0,0x99,0x3f,0x47,0x1e,0x7f,0x23,0x28,0xad,"IID_IUpdateInstallationResult"); + IF_GUID_EQUAL_RETURN(guid,0x3442d4fe,0x224d,0x4cee,0x98,0xcf,0x30,0xe0,0xc4,0xd2,0x29,0xe6,"IID_IUpdateInstaller2"); + IF_GUID_EQUAL_RETURN(guid,0x7b929c68,0xccdc,0x4226,0x96,0xb1,0x87,0x24,0x60,0x0b,0x54,0xc2,"IID_IUpdateInstaller"); + IF_GUID_EQUAL_RETURN(guid,0xa976c28d,0x75a1,0x42aa,0x94,0xae,0x8a,0xf8,0xb8,0x72,0x08,0x9a,"IID_IUpdateLockdown"); + IF_GUID_EQUAL_RETURN(guid,0x4cbdcb2d,0x1589,0x4beb,0xbd,0x1c,0x3e,0x58,0x2f,0xf0,0xad,0xd0,"IID_IUpdateSearcher2"); + IF_GUID_EQUAL_RETURN(guid,0x4c6895d,0xeaf2,0x4034,0x97,0xf3,0x31,0x1d,0xe9,0xbe,0x41,0x3a,"IID_IUpdateSearcher3"); + IF_GUID_EQUAL_RETURN(guid,0x8f45abf1,0xf9ae,0x4b95,0xa9,0x33,0xf0,0xf6,0x6e,0x50,0x56,0xea,"IID_IUpdateSearcher"); + IF_GUID_EQUAL_RETURN(guid,0x1518b460,0x6518,0x4172,0x94,0x0f,0xc7,0x58,0x83,0xb2,0x4c,0xeb,"IID_IUpdateService2"); + IF_GUID_EQUAL_RETURN(guid,0x76b3b17e,0xaed6,0x4da5,0x85,0xf0,0x83,0x58,0x7f,0x81,0xab,0xe3,"IID_IUpdateService"); + IF_GUID_EQUAL_RETURN(guid,0x9b0353aa,0x0e52,0x44ff,0xb8,0xb0,0x1f,0x7f,0xa0,0x43,0x7f,0x88,"IID_IUpdateServiceCollection"); + IF_GUID_EQUAL_RETURN(guid,0x0BB8531D,0x7E8D,0x424F,0x98,0x6C,0xA0,0xB8,0xF6,0x0A,0x3E,0x7B,"IID_IUpdateServiceManager2"); + IF_GUID_EQUAL_RETURN(guid,0x23857E3C,0x02BA,0x44A3,0x94,0x23,0xB1,0xC9,0x00,0x80,0x5F,0x37,"IID_IUpdateServiceManager"); + IF_GUID_EQUAL_RETURN(guid,0xdde02280,0x12b3,0x4e0b,0x93,0x7b,0x67,0x47,0xf6,0xac,0xb2,0x86,"IID_IUpdateServiceRegistration"); + IF_GUID_EQUAL_RETURN(guid,0x91caf7b0,0xeb23,0x49ed,0x99,0x37,0xc5,0x2d,0x81,0x7f,0x46,0xf7,"IID_IUpdateSession2"); + IF_GUID_EQUAL_RETURN(guid,0x918efd1e,0xb5d8,0x4c90,0x85,0x40,0xae,0xb9,0xbd,0xc5,0x6f,0x9d,"IID_IUpdateSession3"); + IF_GUID_EQUAL_RETURN(guid,0x816858a4,0x260d,0x4260,0x93,0x3a,0x25,0x85,0xf1,0xab,0xc7,0x6b,"IID_IUpdateSession"); + IF_GUID_EQUAL_RETURN(guid,0x9849FD60L,0x3768,0x101B,0x8D,0x72,0xAE,0x61,0x64,0xFF,0xE3,0xCF,"IID_IVBFormat"); + IF_GUID_EQUAL_RETURN(guid,0x40A050A0L,0x3C31,0x101B,0xA8,0x2E,0x08,0x00,0x2B,0x2B,0x23,0x37,"IID_IVBGetControl"); + IF_GUID_EQUAL_RETURN(guid,0xbc29a660,0x30e3,0x11d0,0x9e,0x69,0x0,0xc0,0x4f,0xd7,0xc1,0x5b,"IID_IVPConfig"); + IF_GUID_EQUAL_RETURN(guid,0x25df12c1,0x3de0,0x11d1,0x9e,0x69,0x0,0xc0,0x4f,0xd7,0xc1,0x5b,"IID_IVPControl"); + IF_GUID_EQUAL_RETURN(guid,0xebf47183,0x8764,0x11d1,0x9e,0x69,0x0,0xc0,0x4f,0xd7,0xc1,0x5b,"IID_IVPNotify2"); + IF_GUID_EQUAL_RETURN(guid,0xc76794a1,0xd6c5,0x11d0,0x9e,0x69,0x0,0xc0,0x4f,0xd7,0xc1,0x5b,"IID_IVPNotify"); + IF_GUID_EQUAL_RETURN(guid,0xce292862,0xfc88,0x11d0,0x9e,0x69,0x0,0xc0,0x4f,0xd7,0xc1,0x5b,"IID_IVPObject"); + IF_GUID_EQUAL_RETURN(guid,0xec529b00,0x1a1f,0x11d1,0xba,0xd9,0x0,0x60,0x97,0x44,0x11,0x1a,"IID_IVPVBIConfig"); + IF_GUID_EQUAL_RETURN(guid,0xec529b01,0x1a1f,0x11d1,0xba,0xd9,0x0,0x60,0x97,0x44,0x11,0x1a,"IID_IVPVBINotify"); + IF_GUID_EQUAL_RETURN(guid,0x814b9802,0x1c88,0x11d1,0xba,0xd9,0x0,0x60,0x97,0x44,0x11,0x1a,"IID_IVPVBIObject"); + IF_GUID_EQUAL_RETURN(guid,0xe482e5c6,0xe31e,0x4143,0xa2,0xe6,0xdb,0xc3,0xd8,0xe4,0xb8,0xd3,"IID_IValidate"); + IF_GUID_EQUAL_RETURN(guid,0xa6ef9862,0xc720,0x11d0,0x93,0x37,0x0,0xa0,0xc9,0xd,0xca,0xa9,"IID_IVariantChangeType"); + IF_GUID_EQUAL_RETURN(guid,0x4a7deb90,0xb069,0x11d0,0xb3,0x73,0x00,0xa0,0xc9,0x0c,0x2b,0xd8,"IID_IVariantDictionary"); + IF_GUID_EQUAL_RETURN(guid,0x401518EC,0xDB00,0x4611,0x9B,0x29,0x2A,0x0E,0x4B,0x9A,0xFA,0x85,"IID_IVersionInfo"); + IF_GUID_EQUAL_RETURN(guid,0x56a868b4,0x0ad4,0x11ce,0xb0,0x3a,0x00,0x20,0xaf,0x0b,0xa7,0x70,"IID_IVideoWindow"); + IF_GUID_EQUAL_RETURN(guid,0x65a83fc2,0x3e98,0x4d4d,0x81,0xb5,0x2a,0x74,0x28,0x86,0xb3,0x3d,"IID_IWMAddressAccess2"); + IF_GUID_EQUAL_RETURN(guid,0xBB3C6389,0x1633,0x4e92,0xAF,0x14,0x9F,0x31,0x73,0xBA,0x39,0xD0,"IID_IWMAddressAccess"); + IF_GUID_EQUAL_RETURN(guid,0xd9b67d36,0xa9ad,0x4eb4,0xba,0xef,0xdb,0x28,0x4e,0xf5,0x50,0x4c,"IID_IWMAuthorizer"); + IF_GUID_EQUAL_RETURN(guid,0x3C8E0DA6,0x996F,0x4ff3,0xA1,0xAF,0x48,0x38,0xF9,0x37,0x7e,0x2e,"IID_IWMBackupRestoreProps"); + IF_GUID_EQUAL_RETURN(guid,0xad694af1,0xf8d9,0x42f8,0xbc,0x47,0x70,0x31,0x1b,0x0c,0x4f,0x9e,"IID_IWMBandwidthSharing"); + IF_GUID_EQUAL_RETURN(guid,0x4091571e,0x4701,0x4593,0xbb,0x3d,0xd5,0xf5,0xf0,0xc7,0x42,0x46,"IID_IWMClientConnections2"); + IF_GUID_EQUAL_RETURN(guid,0x73c66010,0xa299,0x41df,0xb1,0xf0,0xcc,0xf0,0x3b,0x09,0xc1,0xc6,"IID_IWMClientConnections"); + IF_GUID_EQUAL_RETURN(guid,0xd98ee251,0x34e0,0x4a2d,0x93,0x12,0x9b,0x4c,0x78,0x8d,0x9f,0xa1,"IID_IWMCodecAMVideoAccelerator"); + IF_GUID_EQUAL_RETURN(guid,0xaa65e273,0xb686,0x4056,0x91,0xec,0xdd,0x76,0x8d,0x4d,0xf7,0x10,"IID_IWMCodecInfo2"); + IF_GUID_EQUAL_RETURN(guid,0x7e51f487,0x4d93,0x4f98,0x8a,0xb4,0x27,0xd0,0x56,0x5a,0xdc,0x51,"IID_IWMCodecInfo3"); + IF_GUID_EQUAL_RETURN(guid,0xa970f41e,0x34de,0x4a98,0xb3,0xba,0xe4,0xb3,0xca,0x75,0x28,0xf0,"IID_IWMCodecInfo"); + IF_GUID_EQUAL_RETURN(guid,0x990641b0,0x739f,0x4e94,0xa8,0x08,0x98,0x88,0xda,0x8f,0x75,0xaf,"IID_IWMCodecVideoAccelerator"); + IF_GUID_EQUAL_RETURN(guid,0x342e0eb7,0xe651,0x450c,0x97,0x5b,0x2a,0xce,0x2c,0x90,0xc4,0x8e,"IID_IWMCredentialCallback"); + IF_GUID_EQUAL_RETURN(guid,0xFF130EBC,0xA6C3,0x42A6,0xB4,0x01,0xC3,0x38,0x2C,0x3E,0x08,0xB3,"IID_IWMDRMEditor"); + IF_GUID_EQUAL_RETURN(guid,0xa73a0072,0x25a0,0x4c99,0xb4,0xa5,0xed,0xe8,0x10,0x1a,0x6c,0x39,"IID_IWMDRMMessageParser"); + IF_GUID_EQUAL_RETURN(guid,0xbefe7a75,0x9f1d,0x4075,0xb9,0xd9,0xa3,0xc3,0x7b,0xda,0x49,0xa0,"IID_IWMDRMReader2"); + IF_GUID_EQUAL_RETURN(guid,0xe08672de,0xf1e7,0x4ff4,0xa0,0xa3,0xfc,0x4b,0x08,0xe4,0xca,0xf8,"IID_IWMDRMReader3"); + IF_GUID_EQUAL_RETURN(guid,0xd2827540,0x3ee7,0x432c,0xb1,0x4c,0xdc,0x17,0xf0,0x85,0xd3,0xb3,"IID_IWMDRMReader"); + IF_GUID_EQUAL_RETURN(guid,0xb1a887b2,0xa4f0,0x407a,0xb0,0x2e,0xef,0xbd,0x23,0xbb,0xec,0xdf,"IID_IWMDRMTranscryptionManager"); + IF_GUID_EQUAL_RETURN(guid,0xe0da439f,0xd331,0x496a,0xbe,0xce,0x18,0xe5,0xba,0xc5,0xdd,0x23,"IID_IWMDRMTranscryptor2"); + IF_GUID_EQUAL_RETURN(guid,0x69059850,0x6e6f,0x4bb2,0x80,0x6f,0x71,0x86,0x3d,0xdf,0xc4,0x71,"IID_IWMDRMTranscryptor"); + IF_GUID_EQUAL_RETURN(guid,0x38ee7a94,0x40e2,0x4e10,0xaa,0x3f,0x33,0xfd,0x32,0x10,0xed,0x5b,"IID_IWMDRMWriter2"); + IF_GUID_EQUAL_RETURN(guid,0xa7184082,0xa4aa,0x4dde,0xac,0x9c,0xe7,0x5d,0xbd,0x11,0x17,0xce,"IID_IWMDRMWriter3"); + IF_GUID_EQUAL_RETURN(guid,0xd6ea5dd0,0x12a0,0x43f4,0x90,0xab,0xa3,0xfd,0x45,0x1e,0x6a,0x07,"IID_IWMDRMWriter"); + IF_GUID_EQUAL_RETURN(guid,0xf6211f03,0x8d21,0x4e94,0x93,0xe6,0x85,0x10,0x80,0x5f,0x2d,0x99,"IID_IWMDeviceRegistration"); + IF_GUID_EQUAL_RETURN(guid,0x94bc0598,0xc3d2,0x11d3,0xbe,0xdf,0x00,0xc0,0x4f,0x61,0x29,0x86,"IID_IWMGetSecureChannel"); + IF_GUID_EQUAL_RETURN(guid,0x15cf9781,0x454e,0x482e,0xb3,0x93,0x85,0xfa,0xe4,0x87,0xa8,0x10,"IID_IWMHeaderInfo2"); + IF_GUID_EQUAL_RETURN(guid,0x15CC68E3,0x27CC,0x4ecd,0xB2,0x22,0x3F,0x5D,0x02,0xD8,0x0B,0xD5,"IID_IWMHeaderInfo3"); + IF_GUID_EQUAL_RETURN(guid,0x96406bda,0x2b2b,0x11d3,0xb3,0x6b,0x00,0xc0,0x4f,0x61,0x08,0xff,"IID_IWMHeaderInfo"); + IF_GUID_EQUAL_RETURN(guid,0x6816dad3,0x2b4b,0x4c8e,0x81,0x49,0x87,0x4c,0x34,0x83,0xa7,0x53,"IID_IWMIStreamProps"); + IF_GUID_EQUAL_RETURN(guid,0x9f0aa3b6,0x7267,0x4d89,0x88,0xf2,0xba,0x91,0x5a,0xa5,0xc4,0xc6,"IID_IWMImageInfo"); + IF_GUID_EQUAL_RETURN(guid,0xb70f1e42,0x6255,0x4df0,0xa6,0xb9,0x02,0xb2,0x12,0xd9,0xe2,0xbb,"IID_IWMIndexer2"); + IF_GUID_EQUAL_RETURN(guid,0x6d7cdc71,0x9888,0x11d3,0x8e,0xdc,0x00,0xc0,0x4f,0x61,0x09,0xcf,"IID_IWMIndexer"); + IF_GUID_EQUAL_RETURN(guid,0x96406bd5,0x2b2b,0x11d3,0xb3,0x6b,0x00,0xc0,0x4f,0x61,0x08,0xff,"IID_IWMInputMediaProps"); + IF_GUID_EQUAL_RETURN(guid,0xdf683f00,0x2d49,0x4d8e,0x92,0xb7,0xfb,0x19,0xf6,0xa0,0xdc,0x57,"IID_IWMLanguageList"); + IF_GUID_EQUAL_RETURN(guid,0x05E5AC9F,0x3FB6,0x4508,0xBB,0x43,0xA4,0x06,0x7B,0xA1,0xEB,0xE8,"IID_IWMLicenseBackup"); + IF_GUID_EQUAL_RETURN(guid,0xC70B6334,0xa22e,0x4efb,0xA2,0x45,0x15,0xE6,0x5A,0x00,0x4A,0x13,"IID_IWMLicenseRestore"); + IF_GUID_EQUAL_RETURN(guid,0x6967f2c9,0x4e26,0x4b57,0x88,0x94,0x79,0x98,0x80,0xf7,0xac,0x7b,"IID_IWMLicenseRevocationAgent"); + IF_GUID_EQUAL_RETURN(guid,0x96406bce,0x2b2b,0x11d3,0xb3,0x6b,0x00,0xc0,0x4f,0x61,0x08,0xff,"IID_IWMMediaProps"); + IF_GUID_EQUAL_RETURN(guid,0x203cffe3,0x2e18,0x4fdf,0xb5,0x9d,0x6e,0x71,0x53,0x05,0x34,0xcf,"IID_IWMMetadataEditor2"); + IF_GUID_EQUAL_RETURN(guid,0x96406bd9,0x2b2b,0x11d3,0xb3,0x6b,0x00,0xc0,0x4f,0x61,0x08,0xff,"IID_IWMMetadataEditor"); + IF_GUID_EQUAL_RETURN(guid,0x302b57d,0x89d1,0x4ba2,0x85,0xc9,0x16,0x6f,0x2c,0x53,0xeb,0x91,"IID_IWMMutualExclusion2"); + IF_GUID_EQUAL_RETURN(guid,0x96406bde,0x2b2b,0x11d3,0xb3,0x6b,0x00,0xc0,0x4f,0x61,0x08,0xff,"IID_IWMMutualExclusion"); + IF_GUID_EQUAL_RETURN(guid,0x96406bd7,0x2b2b,0x11d3,0xb3,0x6b,0x00,0xc0,0x4f,0x61,0x08,0xff,"IID_IWMOutputMediaProps"); + IF_GUID_EQUAL_RETURN(guid,0x8bfc2b9e,0xb646,0x4233,0xa8,0x77,0x1c,0x6a,0x7,0x96,0x69,0xdc,"IID_IWMPacketSize2"); + IF_GUID_EQUAL_RETURN(guid,0xcdfb97ab,0x188f,0x40b3,0xb6,0x43,0x5b,0x79,0x03,0x97,0x5c,0x59,"IID_IWMPacketSize"); + IF_GUID_EQUAL_RETURN(guid,0xe5b7ca9a,0x0f1c,0x4f66,0x90,0x02,0x74,0xec,0x50,0xd8,0xb3,0x04,"IID_IWMPlayerHook"); + IF_GUID_EQUAL_RETURN(guid,0x28580dda,0xd98e,0x48d0,0xb7,0xae,0x69,0xe4,0x73,0xa0,0x28,0x25,"IID_IWMPlayerTimestampHook"); + IF_GUID_EQUAL_RETURN(guid,0x07e72d33,0xd94e,0x4be7,0x88,0x43,0x60,0xae,0x5f,0xf7,0xe5,0xf5,"IID_IWMProfile2"); + IF_GUID_EQUAL_RETURN(guid,0x00ef96cc,0xa461,0x4546,0x8b,0xcd,0xc9,0xa2,0x8f,0x0e,0x06,0xf5,"IID_IWMProfile3"); + IF_GUID_EQUAL_RETURN(guid,0x96406bdb,0x2b2b,0x11d3,0xb3,0x6b,0x00,0xc0,0x4f,0x61,0x08,0xff,"IID_IWMProfile"); + IF_GUID_EQUAL_RETURN(guid,0x7a924e51,0x73c1,0x494d,0x80,0x19,0x23,0xd3,0x7e,0xd9,0xb8,0x9a,"IID_IWMProfileManager2"); + IF_GUID_EQUAL_RETURN(guid,0xd16679f2,0x6ca0,0x472d,0x8d,0x31,0x2f,0x5d,0x55,0xae,0xe1,0x55,"IID_IWMProfileManager"); + IF_GUID_EQUAL_RETURN(guid,0xba4dcc78,0x7ee0,0x4ab8,0xb2,0x7a,0xdb,0xce,0x8b,0xc5,0x14,0x54,"IID_IWMProfileManagerLanguage"); + IF_GUID_EQUAL_RETURN(guid,0x72995A79,0x5090,0x42a4,0x9C,0x8C,0xD9,0xD0,0xB6,0xD3,0x4B,0xE5,"IID_IWMPropertyVault"); + IF_GUID_EQUAL_RETURN(guid,0x6A9FD8EE,0xB651,0x4bf0,0xB8,0x49,0x7D,0x4E,0xCE,0x79,0xA2,0xB1,"IID_IWMProximityDetection"); + IF_GUID_EQUAL_RETURN(guid,0x96406bd6,0x2b2b,0x11d3,0xb3,0x6b,0x00,0xc0,0x4f,0x61,0x08,0xff,"IID_IWMReader"); + IF_GUID_EQUAL_RETURN(guid,0xbddc4d08,0x944d,0x4d52,0xa6,0x12,0x46,0xc3,0xfd,0xa0,0x7d,0xd4,"IID_IWMReaderAccelerator"); + IF_GUID_EQUAL_RETURN(guid,0xae14a945,0xb90c,0x4d0d,0x91,0x27,0x80,0xd6,0x65,0xf7,0xd7,0x3e,"IID_IWMReaderAdvanced2"); + IF_GUID_EQUAL_RETURN(guid,0x5dc0674b,0xf04b,0x4a4e,0x9f,0x2a,0xb1,0xaf,0xde,0x2c,0x81,0x00,"IID_IWMReaderAdvanced3"); + IF_GUID_EQUAL_RETURN(guid,0x945a76a2,0x12ae,0x4d48,0xbd,0x3c,0xcd,0x1d,0x90,0x39,0x9b,0x85,"IID_IWMReaderAdvanced4"); + IF_GUID_EQUAL_RETURN(guid,0x24c44db0,0x55d1,0x49ae,0xa5,0xcc,0xf1,0x38,0x15,0xe3,0x63,0x63,"IID_IWMReaderAdvanced5"); + IF_GUID_EQUAL_RETURN(guid,0x18a2e7f8,0x428f,0x4acd,0x8a,0x00,0xe6,0x46,0x39,0xbc,0x93,0xde,"IID_IWMReaderAdvanced6"); + IF_GUID_EQUAL_RETURN(guid,0x96406bea,0x2b2b,0x11d3,0xb3,0x6b,0x00,0xc0,0x4f,0x61,0x08,0xff,"IID_IWMReaderAdvanced"); + IF_GUID_EQUAL_RETURN(guid,0x9f762fa7,0xa22e,0x428d,0x93,0xc9,0xac,0x82,0xf3,0xaa,0xfe,0x5a,"IID_IWMReaderAllocatorEx"); + IF_GUID_EQUAL_RETURN(guid,0x96406bd8,0x2b2b,0x11d3,0xb3,0x6b,0x00,0xc0,0x4f,0x61,0x08,0xff,"IID_IWMReaderCallback"); + IF_GUID_EQUAL_RETURN(guid,0x96406beb,0x2b2b,0x11d3,0xb3,0x6b,0x00,0xc0,0x4f,0x61,0x08,0xff,"IID_IWMReaderCallbackAdvanced"); + IF_GUID_EQUAL_RETURN(guid,0xd979a853,0x042b,0x4050,0x83,0x87,0xc9,0x39,0xdb,0x22,0x01,0x3f,"IID_IWMReaderNetworkConfig2"); + IF_GUID_EQUAL_RETURN(guid,0x96406bec,0x2b2b,0x11d3,0xb3,0x6b,0x00,0xc0,0x4f,0x61,0x08,0xff,"IID_IWMReaderNetworkConfig"); + IF_GUID_EQUAL_RETURN(guid,0xf28c0300,0x9baa,0x4477,0xa8,0x46,0x17,0x44,0xd9,0xcb,0xf5,0x33,"IID_IWMReaderPlaylistBurn"); + IF_GUID_EQUAL_RETURN(guid,0x96406bed,0x2b2b,0x11d3,0xb3,0x6b,0x00,0xc0,0x4f,0x61,0x08,0xff,"IID_IWMReaderStreamClock"); + IF_GUID_EQUAL_RETURN(guid,0xf369e2f0,0xe081,0x4fe6,0x84,0x50,0xb8,0x10,0xb2,0xf4,0x10,0xd1,"IID_IWMReaderTimecode"); + IF_GUID_EQUAL_RETURN(guid,0xfdbe5592,0x81a1,0x41ea,0x93,0xbd,0x73,0x5c,0xad,0x1a,0xdc,0x5,"IID_IWMReaderTypeNegotiation"); + IF_GUID_EQUAL_RETURN(guid,0xcf4b1f99,0x4de2,0x4e49,0xa3,0x63,0x25,0x27,0x40,0xd9,0x9b,0xc1,"IID_IWMRegisterCallback"); + IF_GUID_EQUAL_RETURN(guid,0xa4503bec,0x5508,0x4148,0x97,0xac,0xbf,0xa7,0x57,0x60,0xa7,0x0d,"IID_IWMRegisteredDevice"); + IF_GUID_EQUAL_RETURN(guid,0xE1CD3524,0x03D7,0x11d2,0x9E,0xED,0x00,0x60,0x97,0xD2,0xD7,0xCF,"IID_IWMSBuffer"); + IF_GUID_EQUAL_RETURN(guid,0x61103CA4,0x2033,0x11d2,0x9E,0xF1,0x00,0x60,0x97,0xD2,0xD7,0xCF,"IID_IWMSBufferAllocator"); + IF_GUID_EQUAL_RETURN(guid,0xE74D58C3,0xCF77,0x4b51,0xAF,0x17,0x74,0x46,0x87,0xC4,0x3E,0xAE,"IID_IWMSInternalAdminNetSource2"); + IF_GUID_EQUAL_RETURN(guid,0x6b63d08e,0x4590,0x44af,0x9e,0xb3,0x57,0xff,0x1e,0x73,0xbf,0x80,"IID_IWMSInternalAdminNetSource3"); + IF_GUID_EQUAL_RETURN(guid,0x8BB23E5F,0xD127,0x4afb,0x8D,0x02,0xAE,0x5B,0x66,0xD5,0x4C,0x78,"IID_IWMSInternalAdminNetSource"); + IF_GUID_EQUAL_RETURN(guid,0x2720598a,0xd0f2,0x4189,0xbd,0x10,0x91,0xc4,0x6e,0xf0,0x93,0x6f,"IID_IWMSecureChannel"); + IF_GUID_EQUAL_RETURN(guid,0x6d7cdc70,0x9888,0x11d3,0x8e,0xdc,0x00,0xc0,0x4f,0x61,0x09,0xcf,"IID_IWMStatusCallback"); + IF_GUID_EQUAL_RETURN(guid,0x7688d8cb,0xfc0d,0x43bd,0x94,0x59,0x5a,0x8d,0xec,0x20,0x0c,0xfa,"IID_IWMStreamConfig2"); + IF_GUID_EQUAL_RETURN(guid,0xcb164104,0x3aa9,0x45a7,0x9a,0xc9,0x4d,0xae,0xe1,0x31,0xd6,0xe1,"IID_IWMStreamConfig3"); + IF_GUID_EQUAL_RETURN(guid,0x96406bdc,0x2b2b,0x11d3,0xb3,0x6b,0x00,0xc0,0x4f,0x61,0x08,0xff,"IID_IWMStreamConfig"); + IF_GUID_EQUAL_RETURN(guid,0x96406bdd,0x2b2b,0x11d3,0xb3,0x6b,0x00,0xc0,0x4f,0x61,0x08,0xff,"IID_IWMStreamList"); + IF_GUID_EQUAL_RETURN(guid,0x8c1c6090,0xf9a8,0x4748,0x8e,0xc3,0xdd,0x11,0x08,0xba,0x1e,0x77,"IID_IWMStreamPrioritization"); + IF_GUID_EQUAL_RETURN(guid,0xfaed3d21,0x1b6b,0x4af7,0x8c,0xb6,0x3e,0x18,0x9b,0xbc,0x18,0x7b,"IID_IWMSyncReader2"); + IF_GUID_EQUAL_RETURN(guid,0x9397f121,0x7705,0x4dc9,0xb0,0x49,0x98,0xb6,0x98,0x18,0x84,0x14,"IID_IWMSyncReader"); + IF_GUID_EQUAL_RETURN(guid,0x96406bcf,0x2b2b,0x11d3,0xb3,0x6b,0x00,0xc0,0x4f,0x61,0x08,0xff,"IID_IWMVideoMediaProps"); + IF_GUID_EQUAL_RETURN(guid,0x6f497062,0xf2e2,0x4624,0x8e,0xa7,0x9d,0xd4,0x0d,0x81,0xfc,0x8d,"IID_IWMWatermarkInfo"); + IF_GUID_EQUAL_RETURN(guid,0x96406bd4,0x2b2b,0x11d3,0xb3,0x6b,0x00,0xc0,0x4f,0x61,0x08,0xff,"IID_IWMWriter"); + IF_GUID_EQUAL_RETURN(guid,0x962dc1ec,0xc046,0x4db8,0x9c,0xc7,0x26,0xce,0xae,0x50,0x08,0x17,"IID_IWMWriterAdvanced2"); + IF_GUID_EQUAL_RETURN(guid,0x2cd6492d,0x7c37,0x4e76,0x9d,0x3b,0x59,0x26,0x11,0x83,0xa2,0x2e,"IID_IWMWriterAdvanced3"); + IF_GUID_EQUAL_RETURN(guid,0x96406be3,0x2b2b,0x11d3,0xb3,0x6b,0x00,0xc0,0x4f,0x61,0x08,0xff,"IID_IWMWriterAdvanced"); + IF_GUID_EQUAL_RETURN(guid,0x14282ba7,0x4aef,0x4205,0x8c,0xe5,0xc2,0x29,0x03,0x5a,0x05,0xbc,"IID_IWMWriterFileSink2"); + IF_GUID_EQUAL_RETURN(guid,0x3fea4feb,0x2945,0x47a7,0xa1,0xdd,0xc5,0x3a,0x8f,0xc4,0xc4,0x5c,"IID_IWMWriterFileSink3"); + IF_GUID_EQUAL_RETURN(guid,0x96406be5,0x2b2b,0x11d3,0xb3,0x6b,0x00,0xc0,0x4f,0x61,0x08,0xff,"IID_IWMWriterFileSink"); + IF_GUID_EQUAL_RETURN(guid,0x96406be7,0x2b2b,0x11d3,0xb3,0x6b,0x00,0xc0,0x4f,0x61,0x08,0xff,"IID_IWMWriterNetworkSink"); + IF_GUID_EQUAL_RETURN(guid,0x81e20ce4,0x75ef,0x491a,0x80,0x04,0xfc,0x53,0xc4,0x5b,0xdc,0x3e,"IID_IWMWriterPostView"); + IF_GUID_EQUAL_RETURN(guid,0xd9d6549d,0xa193,0x4f24,0xb3,0x08,0x03,0x12,0x3d,0x9b,0x7f,0x8d,"IID_IWMWriterPostViewCallback"); + IF_GUID_EQUAL_RETURN(guid,0xfc54a285,0x38c4,0x45b5,0xaa,0x23,0x85,0xb9,0xf7,0xcb,0x42,0x4b,"IID_IWMWriterPreprocess"); + IF_GUID_EQUAL_RETURN(guid,0xdc10e6a5,0x072c,0x467d,0xbf,0x57,0x63,0x30,0xa9,0xdd,0xe1,0x2a,"IID_IWMWriterPushSink"); + IF_GUID_EQUAL_RETURN(guid,0x96406be4,0x2b2b,0x11d3,0xb3,0x6b,0x00,0xc0,0x4f,0x61,0x08,0xff,"IID_IWMWriterSink"); + IF_GUID_EQUAL_RETURN(guid,0x29822AB8,0xF302,0x11D0,0x99,0x53,0x00,0xC0,0x4F,0xD9,0x19,0xC1,"IID_IWamAdmin2"); + IF_GUID_EQUAL_RETURN(guid,0x29822AB7,0xF302,0x11D0,0x99,0x53,0x00,0xC0,0x4F,0xD9,0x19,0xC1,"IID_IWamAdmin"); + IF_GUID_EQUAL_RETURN(guid,0x174c81fe,0xaecd,0x4dae,0xb8,0xa0,0x2c,0x63,0x18,0xdd,0x86,0xa8,"IID_IWebProxy"); + IF_GUID_EQUAL_RETURN(guid,0x615c4269,0x7a48,0x43bd,0x96,0xb7,0xbf,0x6c,0xa2,0x7d,0x6c,0x3e,"IID_IWindowsDriverUpdate2"); + IF_GUID_EQUAL_RETURN(guid,0x49EBD502,0x4A96,0x41BD,0x9E,0x3E,0x4C,0x50,0x57,0xF4,0x25,0x0C,"IID_IWindowsDriverUpdate3"); + IF_GUID_EQUAL_RETURN(guid,0x004C6A2B,0x0C19,0x4c69,0x9F,0x5C,0xA2,0x69,0xB2,0x56,0x0D,0xB9,"IID_IWindowsDriverUpdate4"); + IF_GUID_EQUAL_RETURN(guid,0x70CF5C82,0x8642,0x42bb,0x9d,0xbc,0x0c,0xfd,0x26,0x3c,0x6c,0x4f,"IID_IWindowsDriverUpdate5"); + IF_GUID_EQUAL_RETURN(guid,0xb383cd1a,0x5ce9,0x4504,0x9f,0x63,0x76,0x4b,0x12,0x36,0xf1,0x91,"IID_IWindowsDriverUpdate"); + IF_GUID_EQUAL_RETURN(guid,0xED8BFE40,0xA60B,0x42ea,0x96,0x52,0x81,0x7D,0xFC,0xFA,0x23,0xEC,"IID_IWindowsDriverUpdateEntry"); + IF_GUID_EQUAL_RETURN(guid,0x0D521700,0xA372,0x4bef,0x82,0x8B,0x3D,0x00,0xC1,0x0A,0xDE,0xBD,"IID_IWindowsDriverUpdateEntryCollection"); + IF_GUID_EQUAL_RETURN(guid,0x85713FA1,0x7796,0x4FA2,0xBE,0x3B,0xE2,0xD6,0x12,0x4D,0xD3,0x73,"IID_IWindowsUpdateAgentInfo"); + IF_GUID_EQUAL_RETURN(guid,0xD97A6DA0,0xA862,0x11cf,0x84,0xAE,0x00,0xA0,0xC9,0x0C,0x2B,0xD8,"IID_IWriteCookie"); + IF_GUID_EQUAL_RETURN(guid,0xC8A6E3A1,0x9A8C,0x11cf,0xA3,0x08,0x00,0xA0,0xC9,0x05,0x41,0x6E,"IID_IXAConfig"); + IF_GUID_EQUAL_RETURN(guid,0xE793F6D2,0xF53D,0x11cf,0xA6,0x0D,0x00,0xA0,0xC9,0x05,0x41,0x6E,"IID_IXAObtainRMInfo"); + IF_GUID_EQUAL_RETURN(guid,0x4131E751,0x1AEA,0x11d0,0x94,0x4B,0x00,0xA0,0xC9,0x05,0x41,0x6E,"IID_IXAResourceManager"); + IF_GUID_EQUAL_RETURN(guid,0x4131E750,0x1AEA,0x11d0,0x94,0x4B,0x00,0xA0,0xC9,0x05,0x41,0x6E,"IID_IXAResourceManagerFactory"); + IF_GUID_EQUAL_RETURN(guid,0xbf193c85,0xd1a,0x4290,0xb8,0x8f,0xd2,0xcb,0x88,0x73,0xd1,0xe7,"IID_IXATransLookup2"); + IF_GUID_EQUAL_RETURN(guid,0xF3B1F131,0xEEDA,0x11ce,0xAE,0xD4,0x00,0xAA,0x00,0x51,0xE2,0xC4,"IID_IXATransLookup"); + IF_GUID_EQUAL_RETURN(guid,0x4131E752,0x1AEA,0x11d0,0x94,0x4B,0x00,0xA0,0xC9,0x05,0x41,0x6E,"IID_IXATransaction"); + IF_GUID_EQUAL_RETURN(guid,0xde1a6b74,0x9182,0x4c41,0x8e,0x2c,0x24,0xc2,0xcd,0x30,0xee,0x83,"IID__ICounterItemUnion"); + IF_GUID_EQUAL_RETURN(guid,0xc8a77338,0x265f,0x4de5,0xaa,0x25,0xc7,0xda,0x1c,0xe5,0xa8,0xf4,"IID__ISystemMonitorUnion"); + IF_GUID_EQUAL_RETURN(guid,0x38c682a6,0x9731,0x43f2,0x9f,0xae,0xe9,0x01,0xe6,0x41,0xb1,0x01,"IIS_ControlAccessible"); + IF_GUID_EQUAL_RETURN(guid,0x902697fa,0x80e4,0x4560,0x80,0x2a,0xa1,0x3f,0x22,0xa6,0x47,0x09,"IIS_IsOleaccProxy"); + IF_GUID_EQUAL_RETURN(guid,0xA198529B,0x730F,0x4089,0xB6,0x46,0xA1,0x25,0x57,0xF5,0x66,0x5E,"Identity_LocalUserProvider"); + IF_GUID_EQUAL_RETURN(guid,0x2d3736e4,0x6b16,0x4c57,0xa9,0x62,0xf9,0x32,0x60,0xa7,0x52,0x43,"Image_Control_GUID"); + IF_GUID_EQUAL_RETURN(guid,0x7f36c367,0x7b18,0x417c,0x97,0xe3,0x9d,0x58,0xdd,0xc9,0x44,0xab,"InputDiscarded_Event_GUID"); + IF_GUID_EQUAL_RETURN(guid,0xed201d8a,0x4e6c,0x415e,0xa8,0x74,0x24,0x60,0xc9,0xb6,0x6b,0xa8,"InputReachedOtherElement_Event_GUID"); + IF_GUID_EQUAL_RETURN(guid,0x93ed549a,0x0549,0x40f0,0xbe,0xdb,0x28,0xe4,0x4f,0x7d,0xe2,0xa3,"InputReachedTarget_Event_GUID"); + IF_GUID_EQUAL_RETURN(guid,0xdfd699f0,0xc915,0x49dd,0xb4,0x22,0xdd,0xe7,0x85,0xc3,0xd2,0x4b,"Invoke_Invoked_Event_GUID"); + IF_GUID_EQUAL_RETURN(guid,0xd976c2fc,0x66ea,0x4a6e,0xb2,0x8f,0xc2,0x4c,0x75,0x46,0xad,0x37,"Invoke_Pattern_GUID"); + IF_GUID_EQUAL_RETURN(guid,0x0b5b3238,0x6d5c,0x41b6,0xbc,0xc4,0x5e,0x80,0x7f,0x65,0x51,0xc4,"IsAnnotationPatternAvailable_Property_GUID"); + IF_GUID_EQUAL_RETURN(guid,0x4bda64a8,0xf5d8,0x480b,0x81,0x55,0xef,0x2e,0x89,0xad,0xb6,0x72,"IsContentElement_Property_GUID"); + IF_GUID_EQUAL_RETURN(guid,0x95f35085,0xabcc,0x4afd,0xa5,0xf4,0xdb,0xb4,0x6c,0x23,0x0f,0xdb,"IsControlElement_Property_GUID"); + IF_GUID_EQUAL_RETURN(guid,0x445ac684,0xc3fc,0x4dd9,0xac,0xf8,0x84,0x5a,0x57,0x92,0x96,0xba,"IsDataValidForForm_Property_GUID"); + IF_GUID_EQUAL_RETURN(guid,0x2600a4c4,0x2ff8,0x4c96,0xae,0x31,0x8f,0xe6,0x19,0xa1,0x3c,0x6c,"IsDockPatternAvailable_Property_GUID"); + IF_GUID_EQUAL_RETURN(guid,0xe997a7b7,0x1d39,0x4ca7,0xbe,0xf,0x27,0x7f,0xcf,0x56,0x5,0xcc,"IsDragPatternAvailable_Property_GUID"); + IF_GUID_EQUAL_RETURN(guid,0x686b62e,0x8e19,0x4aaf,0x87,0x3d,0x38,0x4f,0x6d,0x3b,0x92,0xbe,"IsDropTargetPatternAvailable_Property_GUID"); + IF_GUID_EQUAL_RETURN(guid,0x2109427f,0xda60,0x4fed,0xbf,0x1b,0x26,0x4b,0xdc,0xe6,0xeb,0x3a,"IsEnabled_Property_GUID"); + IF_GUID_EQUAL_RETURN(guid,0x929d3806,0x5287,0x4725,0xaa,0x16,0x22,0x2a,0xfc,0x63,0xd5,0x95,"IsExpandCollapsePatternAvailable_Property_GUID"); + IF_GUID_EQUAL_RETURN(guid,0x5a43e524,0xf9a2,0x4b12,0x84,0xc8,0xb4,0x8a,0x3e,0xfe,0xdd,0x34,"IsGridItemPatternAvailable_Property_GUID"); + IF_GUID_EQUAL_RETURN(guid,0x5622c26c,0xf0ef,0x4f3b,0x97,0xcb,0x71,0x4c,0x08,0x68,0x58,0x8b,"IsGridPatternAvailable_Property_GUID"); + IF_GUID_EQUAL_RETURN(guid,0x4e725738,0x8364,0x4679,0xaa,0x6c,0xf3,0xf4,0x19,0x31,0xf7,0x50,"IsInvokePatternAvailable_Property_GUID"); + IF_GUID_EQUAL_RETURN(guid,0x624b5ca7,0xfe40,0x4957,0xa0,0x19,0x20,0xc4,0xcf,0x11,0x92,0x0f,"IsItemContainerPatternAvailable_Property_GUID"); + IF_GUID_EQUAL_RETURN(guid,0xf7b8552a,0x0859,0x4b37,0xb9,0xcb,0x51,0xe7,0x20,0x92,0xf2,0x9f,"IsKeyboardFocusable_Property_GUID"); + IF_GUID_EQUAL_RETURN(guid,0xd8ebd0c7,0x929a,0x4ee7,0x8d,0x3a,0xd3,0xd9,0x44,0x13,0x02,0x7b,"IsLegacyIAccessiblePatternAvailable_Property_GUID"); + IF_GUID_EQUAL_RETURN(guid,0xff0a31eb,0x8e25,0x469d,0x8d,0x6e,0xe7,0x71,0xa2,0x7c,0x1b,0x90,"IsMultipleViewPatternAvailable_Property_GUID"); + IF_GUID_EQUAL_RETURN(guid,0x6b21d89b,0x2841,0x412f,0x8e,0xf2,0x15,0xca,0x95,0x23,0x18,0xba,"IsObjectModelPatternAvailable_Property_GUID"); + IF_GUID_EQUAL_RETURN(guid,0x03c3d160,0xdb79,0x42db,0xa2,0xef,0x1c,0x23,0x1e,0xed,0xe5,0x07,"IsOffscreen_Property_GUID"); + IF_GUID_EQUAL_RETURN(guid,0xe8482eb1,0x687c,0x497b,0xbe,0xbc,0x03,0xbe,0x53,0xec,0x14,0x54,"IsPassword_Property_GUID"); + IF_GUID_EQUAL_RETURN(guid,0xfda4244a,0xeb4d,0x43ff,0xb5,0xad,0xed,0x36,0xd3,0x73,0xec,0x4c,"IsRangeValuePatternAvailable_Property_GUID"); + IF_GUID_EQUAL_RETURN(guid,0x4f5f43cf,0x59fb,0x4bde,0xa2,0x70,0x60,0x2e,0x5e,0x11,0x41,0xe9,"IsRequiredForForm_Property_GUID"); + IF_GUID_EQUAL_RETURN(guid,0x1cad1a05,0x0927,0x4b76,0x97,0xe1,0x0f,0xcd,0xb2,0x09,0xb9,0x8a,"IsScrollItemPatternAvailable_Property_GUID"); + IF_GUID_EQUAL_RETURN(guid,0x3ebb7b4a,0x828a,0x4b57,0x9d,0x22,0x2f,0xea,0x16,0x32,0xed,0x0d,"IsScrollPatternAvailable_Property_GUID"); + IF_GUID_EQUAL_RETURN(guid,0x8becd62d,0x0bc3,0x4109,0xbe,0xe2,0x8e,0x67,0x15,0x29,0x0e,0x68,"IsSelectionItemPatternAvailable_Property_GUID"); + IF_GUID_EQUAL_RETURN(guid,0xf588acbe,0xc769,0x4838,0x9a,0x60,0x26,0x86,0xdc,0x11,0x88,0xc4,"IsSelectionPatternAvailable_Property_GUID"); + IF_GUID_EQUAL_RETURN(guid,0x9fe79b2a,0x2f94,0x43fd,0x99,0x6b,0x54,0x9e,0x31,0x6f,0x4a,0xcd,"IsSpreadsheetItemPatternAvailable_Property_GUID"); + IF_GUID_EQUAL_RETURN(guid,0x6ff43732,0xe4b4,0x4555,0x97,0xbc,0xec,0xdb,0xbc,0x4d,0x18,0x88,"IsSpreadsheetPatternAvailable_Property_GUID"); + IF_GUID_EQUAL_RETURN(guid,0x27f353d3,0x459c,0x4b59,0xa4,0x90,0x50,0x61,0x1d,0xac,0xaf,0xb5,"IsStylesPatternAvailable_Property_GUID"); + IF_GUID_EQUAL_RETURN(guid,0x75d69cc5,0xd2bf,0x4943,0x87,0x6e,0xb4,0x5b,0x62,0xa6,0xcc,0x66,"IsSynchronizedInputPatternAvailable_Property_GUID"); + IF_GUID_EQUAL_RETURN(guid,0xeb36b40d,0x8ea4,0x489b,0xa0,0x13,0xe6,0x0d,0x59,0x51,0xfe,0x34,"IsTableItemPatternAvailable_Property_GUID"); + IF_GUID_EQUAL_RETURN(guid,0xcb83575f,0x45c2,0x4048,0x9c,0x76,0x15,0x97,0x15,0xa1,0x39,0xdf,"IsTablePatternAvailable_Property_GUID"); + IF_GUID_EQUAL_RETURN(guid,0x559e65df,0x30ff,0x43b5,0xb5,0xed,0x5b,0x28,0x3b,0x80,0xc7,0xe9,"IsTextChildPatternAvailable_Property_GUID"); + IF_GUID_EQUAL_RETURN(guid,0x41cf921d,0xe3f1,0x4b22,0x9c,0x81,0xe1,0xc3,0xed,0x33,0x1c,0x22,"IsTextPattern2Available_Property_GUID"); + IF_GUID_EQUAL_RETURN(guid,0xfbe2d69d,0xaff6,0x4a45,0x82,0xe2,0xfc,0x92,0xa8,0x2f,0x59,0x17,"IsTextPatternAvailable_Property_GUID"); + IF_GUID_EQUAL_RETURN(guid,0x78686d53,0xfcd0,0x4b83,0x9b,0x78,0x58,0x32,0xce,0x63,0xbb,0x5b,"IsTogglePatternAvailable_Property_GUID"); + IF_GUID_EQUAL_RETURN(guid,0x25980b4b,0xbe04,0x4710,0xab,0x4a,0xfd,0xa3,0x1d,0xbd,0x28,0x95,"IsTransformPattern2Available_Property_GUID"); + IF_GUID_EQUAL_RETURN(guid,0xa7f78804,0xd68b,0x4077,0xa5,0xc6,0x7a,0x5e,0xa1,0xac,0x31,0xc5,"IsTransformPatternAvailable_Property_GUID"); + IF_GUID_EQUAL_RETURN(guid,0x0b5020a7,0x2119,0x473b,0xbe,0x37,0x5c,0xeb,0x98,0xbb,0xfb,0x22,"IsValuePatternAvailable_Property_GUID"); + IF_GUID_EQUAL_RETURN(guid,0x302cb151,0x2ac8,0x45d6,0x97,0x7b,0xd2,0xb3,0xa5,0xa5,0x3f,0x20,"IsVirtualizedItemPatternAvailable_Property_GUID"); + IF_GUID_EQUAL_RETURN(guid,0xe7a57bb1,0x5888,0x4155,0x98,0xdc,0xb4,0x22,0xfd,0x57,0xf2,0xbc,"IsWindowPatternAvailable_Property_GUID"); + IF_GUID_EQUAL_RETURN(guid,0x3d13da0f,0x8b9a,0x4a99,0x85,0xfa,0xc5,0xc9,0xa6,0x9f,0x1e,0xd4,"ItemContainer_Pattern_GUID"); + IF_GUID_EQUAL_RETURN(guid,0xabbf5c45,0x5ccc,0x47b7,0xbb,0x4e,0x87,0xcb,0x87,0xbb,0xd1,0x62,"ItemCount_Property_GUID"); + IF_GUID_EQUAL_RETURN(guid,0x92a053da,0x2969,0x4021,0xbf,0x27,0x51,0x4c,0xfc,0x2e,0x4a,0x69,"ItemIndex_Property_GUID"); + IF_GUID_EQUAL_RETURN(guid,0x51de0321,0x3973,0x43e7,0x89,0x13,0x0b,0x08,0xe8,0x13,0xc3,0x7f,"ItemStatus_Property_GUID"); + IF_GUID_EQUAL_RETURN(guid,0xcdda434d,0x6222,0x413b,0xa6,0x8a,0x32,0x5d,0xd1,0xd4,0x0f,0x39,"ItemType_Property_GUID"); + IF_GUID_EQUAL_RETURN(guid,0x1a82f8bc,0x3f8b,0x11d2,0xb7,0x74,0x00,0x60,0x08,0x33,0x16,0xc1,"KSDATAFORMAT_SUBTYPE_DIRECTMUSIC"); + IF_GUID_EQUAL_RETURN(guid,0x1D262760L,0xE957,0x11CF,0xA5,0xD6,0x28,0xDB,0x04,0xC1,0x00,0x00,"KSDATAFORMAT_SUBTYPE_MIDI"); + IF_GUID_EQUAL_RETURN(guid,0xD97A6DA0,0xA85C,0x11cf,0x83,0xAE,0x00,0xA0,0xC9,0x0C,0x2B,0xD8,"LIBID_ASPTypeLibrary"); + IF_GUID_EQUAL_RETURN(guid,0x1ea4dbf0,0x3c3b,0x11cf,0x81,0x0c,0x00,0xaa,0x00,0x38,0x9b,0x71,"LIBID_Accessibility"); + IF_GUID_EQUAL_RETURN(guid,0xbed7f4ea,0x1a96,0x11d2,0x8f,0x8,0x0,0xa0,0xc9,0xa6,0x18,0x6d,"LIBID_ComPlusRuntime"); + IF_GUID_EQUAL_RETURN(guid,0xE8FB8614,0x588F,0x11d2,0x9d,0x61,0x0,0xc0,0x4f,0x79,0xc5,0xfe,"LIBID_IISRSTALib"); + IF_GUID_EQUAL_RETURN(guid,0x150E2D7A,0xDAC1,0x4582,0x94,0x7D,0x2A,0x8F,0xD7,0x8B,0x82,0xCD,"LIBID_MSAATEXTLib"); + IF_GUID_EQUAL_RETURN(guid,0x0ADDA82F,0x2C26,0x11D2,0xAD,0x65,0x00,0xA0,0xC9,0xAF,0x11,0xA6,"LIBID_MsmMergeTypeLib"); + IF_GUID_EQUAL_RETURN(guid,0x56a868b0,0x0ad4,0x11ce,0xb0,0x3a,0x00,0x20,0xaf,0x0b,0xa7,0x70,"LIBID_QuartzTypeLib"); + IF_GUID_EQUAL_RETURN(guid,0x1B773E42,0x2509,0x11cf,0x94,0x2F,0x00,0x80,0x29,0x00,0x43,0x47,"LIBID_SystemMonitor"); + IF_GUID_EQUAL_RETURN(guid,0x942f35c2,0xe83b,0x45ef,0xb0,0x85,0xac,0x29,0x5d,0xd6,0x3d,0x5b,"LIBID_UIRibbon"); + IF_GUID_EQUAL_RETURN(guid,0x29822AA8,0xF302,0x11D0,0x99,0x53,0x00,0xC0,0x4F,0xD9,0x19,0xC1,"LIBID_WAMREGLib"); + IF_GUID_EQUAL_RETURN(guid,0xB596CC9F,0x56E5,0x419E,0xA6,0x22,0xE0,0x1B,0xB4,0x57,0x43,0x1E,"LIBID_WUApiLib"); + IF_GUID_EQUAL_RETURN(guid,0x5477469e,0x83b1,0x11d2,0x8b,0x49,0x00,0xa0,0xc9,0xb7,0xc9,0xc4,"LIBID_mscoree"); + IF_GUID_EQUAL_RETURN(guid,0xac798be1,0x98e3,0x11d1,0xb3,0xf1,0x0,0xaa,0x0,0x37,0x61,0xc5,"LOOK_DOWNSTREAM_ONLY"); + IF_GUID_EQUAL_RETURN(guid,0xac798be0,0x98e3,0x11d1,0xb3,0xf1,0x0,0xaa,0x0,0x37,0x61,0xc5,"LOOK_UPSTREAM_ONLY"); + IF_GUID_EQUAL_RETURN(guid,0xe5b8924b,0xfc8a,0x4a35,0x80,0x31,0xcf,0x78,0xac,0x43,0xe5,0x5e,"LabeledBy_Property_GUID"); + IF_GUID_EQUAL_RETURN(guid,0xed7d6544,0xa6bd,0x4595,0x9b,0xae,0x3d,0x28,0x94,0x6c,0xc7,0x15,"LayoutInvalidated_Event_GUID"); + IF_GUID_EQUAL_RETURN(guid,0x9a191b5d,0x9ef2,0x4787,0xa4,0x59,0xdc,0xde,0x88,0x5d,0xd4,0xe8,"LegacyIAccessible_ChildId_Property_GUID"); + IF_GUID_EQUAL_RETURN(guid,0x3b331729,0xeaad,0x4502,0xb8,0x5f,0x92,0x61,0x56,0x22,0x91,0x3c,"LegacyIAccessible_DefaultAction_Property_GUID"); + IF_GUID_EQUAL_RETURN(guid,0x46448418,0x7d70,0x4ea9,0x9d,0x27,0xb7,0xe7,0x75,0xcf,0x2a,0xd7,"LegacyIAccessible_Description_Property_GUID"); + IF_GUID_EQUAL_RETURN(guid,0x94402352,0x161c,0x4b77,0xa9,0x8d,0xa8,0x72,0xcc,0x33,0x94,0x7a,"LegacyIAccessible_Help_Property_GUID"); + IF_GUID_EQUAL_RETURN(guid,0x8f6909ac,0x00b8,0x4259,0xa4,0x1c,0x96,0x62,0x66,0xd4,0x3a,0x8a,"LegacyIAccessible_KeyboardShortcut_Property_GUID"); + IF_GUID_EQUAL_RETURN(guid,0xcaeb063d,0x40ae,0x4869,0xaa,0x5a,0x1b,0x8e,0x5d,0x66,0x67,0x39,"LegacyIAccessible_Name_Property_GUID"); + IF_GUID_EQUAL_RETURN(guid,0x54cc0a9f,0x3395,0x48af,0xba,0x8d,0x73,0xf8,0x56,0x90,0xf3,0xe0,"LegacyIAccessible_Pattern_GUID"); + IF_GUID_EQUAL_RETURN(guid,0x6856e59f,0xcbaf,0x4e31,0x93,0xe8,0xbc,0xbf,0x6f,0x7e,0x49,0x1c,"LegacyIAccessible_Role_Property_GUID"); + IF_GUID_EQUAL_RETURN(guid,0x8aa8b1e0,0x0891,0x40cc,0x8b,0x06,0x90,0xd7,0xd4,0x16,0x62,0x19,"LegacyIAccessible_Selection_Property_GUID"); + IF_GUID_EQUAL_RETURN(guid,0xdf985854,0x2281,0x4340,0xab,0x9c,0xc6,0x0e,0x2c,0x58,0x03,0xf6,"LegacyIAccessible_State_Property_GUID"); + IF_GUID_EQUAL_RETURN(guid,0xb5c5b0b6,0x8217,0x4a77,0x97,0xa5,0x19,0x0a,0x85,0xed,0x01,0x56,"LegacyIAccessible_Value_Property_GUID"); + IF_GUID_EQUAL_RETURN(guid,0x7b3717f2,0x44d1,0x4a58,0x98,0xa8,0xf1,0x2a,0x9b,0x8f,0x78,0xe2,"ListItem_Control_GUID"); + IF_GUID_EQUAL_RETURN(guid,0x9b149ee1,0x7cca,0x4cfc,0x9a,0xf1,0xca,0xc7,0xbd,0xdd,0x30,0x31,"List_Control_GUID"); + IF_GUID_EQUAL_RETURN(guid,0x102d5e90,0xe6a9,0x41b6,0xb1,0xc5,0xa9,0xb1,0x92,0x9d,0x95,0x10,"LiveRegionChanged_Event_GUID"); + IF_GUID_EQUAL_RETURN(guid,0xc12bcd8e,0x2a8e,0x4950,0x8a,0xe7,0x36,0x25,0x11,0x1d,0x58,0xeb,"LiveSetting_Property_GUID"); + IF_GUID_EQUAL_RETURN(guid,0x8763404f,0xa1bd,0x452a,0x89,0xc4,0x3f,0x01,0xd3,0x83,0x38,0x06,"LocalizedControlType_Property_GUID"); + IF_GUID_EQUAL_RETURN(guid,0x659FCAE6,0x5BDB,0x4DA9,0xB1,0xFF,0xCA,0x2A,0x17,0x8D,0x46,0xE0,"MACHINE_POLICY_PRESENT_GUID"); + IF_GUID_EQUAL_RETURN(guid,0x4F303234,0x0000,0x0010,0x80,0x00,0x00,0xaa,0x00,0x38,0x9b,0x71,"MEDIASUBTYPE_420O"); + IF_GUID_EQUAL_RETURN(guid,0xaf414bc,0x4ed2,0x445e,0x98,0x39,0x8f,0x9,0x55,0x68,0xab,0x3c,"MEDIASUBTYPE_708_608Data"); + IF_GUID_EQUAL_RETURN(guid,0x576f7893,0xbdf6,0x48c4,0x87,0x5f,0xae,0x7b,0x81,0x83,0x45,0x67,"MEDIASUBTYPE_A2B10G10R10"); + IF_GUID_EQUAL_RETURN(guid,0x2f8bb76d,0xb644,0x4550,0xac,0xf3,0xd3,0x0c,0xaa,0x65,0xd5,0xc5,"MEDIASUBTYPE_A2R10G10B10"); + IF_GUID_EQUAL_RETURN(guid,0x34344941,0x0000,0x0010,0x80,0x00,0x00,0xaa,0x00,0x38,0x9b,0x71,"MEDIASUBTYPE_AI44"); + IF_GUID_EQUAL_RETURN(guid,0xe436eb8d,0x524f,0x11ce,0x9f,0x53,0x00,0x20,0xaf,0x0b,0xa7,0x70,"MEDIASUBTYPE_AIFF"); + IF_GUID_EQUAL_RETURN(guid,0x297c55af,0xe209,0x4cb3,0xb7,0x57,0xc7,0x6d,0x6b,0x9c,0x88,0xa8,"MEDIASUBTYPE_ARGB1555"); + IF_GUID_EQUAL_RETURN(guid,0x35314137,0x0000,0x0010,0x80,0x00,0x00,0xaa,0x00,0x38,0x9b,0x71,"MEDIASUBTYPE_ARGB1555_D3D_DX7_RT"); + IF_GUID_EQUAL_RETURN(guid,0x35314139,0x0000,0x0010,0x80,0x00,0x00,0xaa,0x00,0x38,0x9b,0x71,"MEDIASUBTYPE_ARGB1555_D3D_DX9_RT"); + IF_GUID_EQUAL_RETURN(guid,0x773c9ac0,0x3274,0x11d0,0xb7,0x24,0x0,0xaa,0x0,0x6c,0x1a,0x1,"MEDIASUBTYPE_ARGB32"); + IF_GUID_EQUAL_RETURN(guid,0x38384137,0x0000,0x0010,0x80,0x00,0x00,0xaa,0x00,0x38,0x9b,0x71,"MEDIASUBTYPE_ARGB32_D3D_DX7_RT"); + IF_GUID_EQUAL_RETURN(guid,0x38384139,0x0000,0x0010,0x80,0x00,0x00,0xaa,0x00,0x38,0x9b,0x71,"MEDIASUBTYPE_ARGB32_D3D_DX9_RT"); + IF_GUID_EQUAL_RETURN(guid,0x6e6415e6,0x5c24,0x425f,0x93,0xcd,0x80,0x10,0x2b,0x3d,0x1c,0xca,"MEDIASUBTYPE_ARGB4444"); + IF_GUID_EQUAL_RETURN(guid,0x34344137,0x0000,0x0010,0x80,0x00,0x00,0xaa,0x00,0x38,0x9b,0x71,"MEDIASUBTYPE_ARGB4444_D3D_DX7_RT"); + IF_GUID_EQUAL_RETURN(guid,0x34344139,0x0000,0x0010,0x80,0x00,0x00,0xaa,0x00,0x38,0x9b,0x71,"MEDIASUBTYPE_ARGB4444_D3D_DX9_RT"); + IF_GUID_EQUAL_RETURN(guid,0xb3c7397c,0xd303,0x414d,0xb3,0x3c,0x4e,0xd2,0xc9,0xd2,0x97,0x33,"MEDIASUBTYPE_ATSC_SI"); + IF_GUID_EQUAL_RETURN(guid,0xe436eb8c,0x524f,0x11ce,0x9f,0x53,0x00,0x20,0xaf,0x0b,0xa7,0x70,"MEDIASUBTYPE_AU"); + IF_GUID_EQUAL_RETURN(guid,0x31435641,0x0000,0x0010,0x80,0x00,0x00,0xaa,0x00,0x38,0x9b,0x71,"MEDIASUBTYPE_AVC1"); + IF_GUID_EQUAL_RETURN(guid,0x56555941,0x0000,0x0010,0x80,0x00,0x00,0xaa,0x00,0x38,0x9b,0x71,"MEDIASUBTYPE_AYUV"); + IF_GUID_EQUAL_RETURN(guid,0x482dde2,0x7817,0x11cf,0x8a,0x3,0x0,0xaa,0x0,0x6e,0xcb,0x65,"MEDIASUBTYPE_AnalogVideo_NTSC_M"); + IF_GUID_EQUAL_RETURN(guid,0x482dde5,0x7817,0x11cf,0x8a,0x3,0x0,0xaa,0x0,0x6e,0xcb,0x65,"MEDIASUBTYPE_AnalogVideo_PAL_B"); + IF_GUID_EQUAL_RETURN(guid,0x482dde6,0x7817,0x11cf,0x8a,0x3,0x0,0xaa,0x0,0x6e,0xcb,0x65,"MEDIASUBTYPE_AnalogVideo_PAL_D"); + IF_GUID_EQUAL_RETURN(guid,0x482dde7,0x7817,0x11cf,0x8a,0x3,0x0,0xaa,0x0,0x6e,0xcb,0x65,"MEDIASUBTYPE_AnalogVideo_PAL_G"); + IF_GUID_EQUAL_RETURN(guid,0x482dde8,0x7817,0x11cf,0x8a,0x3,0x0,0xaa,0x0,0x6e,0xcb,0x65,"MEDIASUBTYPE_AnalogVideo_PAL_H"); + IF_GUID_EQUAL_RETURN(guid,0x482dde9,0x7817,0x11cf,0x8a,0x3,0x0,0xaa,0x0,0x6e,0xcb,0x65,"MEDIASUBTYPE_AnalogVideo_PAL_I"); + IF_GUID_EQUAL_RETURN(guid,0x482ddea,0x7817,0x11cf,0x8a,0x3,0x0,0xaa,0x0,0x6e,0xcb,0x65,"MEDIASUBTYPE_AnalogVideo_PAL_M"); + IF_GUID_EQUAL_RETURN(guid,0x482ddeb,0x7817,0x11cf,0x8a,0x3,0x0,0xaa,0x0,0x6e,0xcb,0x65,"MEDIASUBTYPE_AnalogVideo_PAL_N"); + IF_GUID_EQUAL_RETURN(guid,0x482ddec,0x7817,0x11cf,0x8a,0x3,0x0,0xaa,0x0,0x6e,0xcb,0x65,"MEDIASUBTYPE_AnalogVideo_PAL_N_COMBO"); + IF_GUID_EQUAL_RETURN(guid,0x482ddf0,0x7817,0x11cf,0x8a,0x3,0x0,0xaa,0x0,0x6e,0xcb,0x65,"MEDIASUBTYPE_AnalogVideo_SECAM_B"); + IF_GUID_EQUAL_RETURN(guid,0x482ddf1,0x7817,0x11cf,0x8a,0x3,0x0,0xaa,0x0,0x6e,0xcb,0x65,"MEDIASUBTYPE_AnalogVideo_SECAM_D"); + IF_GUID_EQUAL_RETURN(guid,0x482ddf2,0x7817,0x11cf,0x8a,0x3,0x0,0xaa,0x0,0x6e,0xcb,0x65,"MEDIASUBTYPE_AnalogVideo_SECAM_G"); + IF_GUID_EQUAL_RETURN(guid,0x482ddf3,0x7817,0x11cf,0x8a,0x3,0x0,0xaa,0x0,0x6e,0xcb,0x65,"MEDIASUBTYPE_AnalogVideo_SECAM_H"); + IF_GUID_EQUAL_RETURN(guid,0x482ddf5,0x7817,0x11cf,0x8a,0x3,0x0,0xaa,0x0,0x6e,0xcb,0x65,"MEDIASUBTYPE_AnalogVideo_SECAM_K1"); + IF_GUID_EQUAL_RETURN(guid,0x482ddf4,0x7817,0x11cf,0x8a,0x3,0x0,0xaa,0x0,0x6e,0xcb,0x65,"MEDIASUBTYPE_AnalogVideo_SECAM_K"); + IF_GUID_EQUAL_RETURN(guid,0x482ddf6,0x7817,0x11cf,0x8a,0x3,0x0,0xaa,0x0,0x6e,0xcb,0x65,"MEDIASUBTYPE_AnalogVideo_SECAM_L"); + IF_GUID_EQUAL_RETURN(guid,0x3db80f90,0x9412,0x11d1,0xad,0xed,0x0,0x0,0xf8,0x75,0x4b,0x99,"MEDIASUBTYPE_Asf"); + IF_GUID_EQUAL_RETURN(guid,0xe436eb88,0x524f,0x11ce,0x9f,0x53,0x00,0x20,0xaf,0x0b,0xa7,0x70,"MEDIASUBTYPE_Avi"); + IF_GUID_EQUAL_RETURN(guid,0x7ea626db,0x54da,0x437b,0xbe,0x9f,0xf7,0x30,0x73,0xad,0xfa,0x3c,"MEDIASUBTYPE_CC_CONTAINER"); + IF_GUID_EQUAL_RETURN(guid,0x43434643,0x0000,0x0010,0x80,0x00,0x00,0xaa,0x00,0x38,0x9b,0x71,"MEDIASUBTYPE_CFCC"); + IF_GUID_EQUAL_RETURN(guid,0x524a4c43,0x0000,0x0010,0x80,0x00,0x00,0xaa,0x00,0x38,0x9b,0x71,"MEDIASUBTYPE_CLJR"); + IF_GUID_EQUAL_RETURN(guid,0x4C504C43,0x0000,0x0010,0x80,0x00,0x00,0xaa,0x00,0x38,0x9b,0x71,"MEDIASUBTYPE_CLPL"); + IF_GUID_EQUAL_RETURN(guid,0x46adbd28,0x6fd0,0x4796,0x93,0xb2,0x15,0x5c,0x51,0xdc,0x4,0x8d,"MEDIASUBTYPE_CPFilters_Processed"); + IF_GUID_EQUAL_RETURN(guid,0x414c5043,0x0000,0x0010,0x80,0x00,0x00,0xaa,0x00,0x38,0x9b,0x71,"MEDIASUBTYPE_CPLA"); + IF_GUID_EQUAL_RETURN(guid,0xe06d802c,0xdb46,0x11cf,0xb4,0xd1,0x00,0x80,0x05f,0x6c,0xbb,0xea,"MEDIASUBTYPE_DOLBY_AC3"); + IF_GUID_EQUAL_RETURN(guid,0x00000092,0x0000,0x0010,0x80,0x00,0x00,0xaa,0x00,0x38,0x9b,0x71,"MEDIASUBTYPE_DOLBY_AC3_SPDIF"); + IF_GUID_EQUAL_RETURN(guid,0xa7fb87af,0x2d02,0x42fb,0xa4,0xd4,0x5,0xcd,0x93,0x84,0x3b,0xdd,"MEDIASUBTYPE_DOLBY_DDPLUS"); + IF_GUID_EQUAL_RETURN(guid,0xeb27cec4,0x163e,0x4ca3,0x8b,0x74,0x8e,0x25,0xf9,0x1b,0x51,0x7e,"MEDIASUBTYPE_DOLBY_TRUEHD"); + IF_GUID_EQUAL_RETURN(guid,0x00000009,0x0000,0x0010,0x80,0x00,0x00,0xaa,0x00,0x38,0x9b,0x71,"MEDIASUBTYPE_DRM_Audio"); + IF_GUID_EQUAL_RETURN(guid,0x00002001,0x0000,0x0010,0x80,0x00,0x00,0xaa,0x00,0x38,0x9b,0x71,"MEDIASUBTYPE_DTS2"); + IF_GUID_EQUAL_RETURN(guid,0xe06d8033,0xdb46,0x11cf,0xb4,0xd1,0x00,0x80,0x05f,0x6c,0xbb,0xea,"MEDIASUBTYPE_DTS"); + IF_GUID_EQUAL_RETURN(guid,0xa2e58eb7,0xfa9,0x48bb,0xa4,0xc,0xfa,0xe,0x15,0x6d,0x6,0x45,"MEDIASUBTYPE_DTS_HD"); + IF_GUID_EQUAL_RETURN(guid,0xe9dd31a3,0x221d,0x4adb,0x85,0x32,0x9a,0xf3,0x9,0xc1,0xa4,0x8,"MEDIASUBTYPE_DVB_SI"); + IF_GUID_EQUAL_RETURN(guid,0x34FFCBC3,0xD5B3,0x4171,0x90,0x02,0xD4,0xC6,0x03,0x01,0x69,0x7F,"MEDIASUBTYPE_DVB_SUBTITLES"); + IF_GUID_EQUAL_RETURN(guid,0x53435644,0x0000,0x0010,0x80,0x00,0x00,0xaa,0x00,0x38,0x9b,0x71,"MEDIASUBTYPE_DVCS"); + IF_GUID_EQUAL_RETURN(guid,0xe06d8032,0xdb46,0x11cf,0xb4,0xd1,0x00,0x80,0x05f,0x6c,0xbb,0xea,"MEDIASUBTYPE_DVD_LPCM_AUDIO"); + IF_GUID_EQUAL_RETURN(guid,0xe06d8030,0xdb46,0x11cf,0xb4,0xd1,0x00,0x80,0x05f,0x6c,0xbb,0xea,"MEDIASUBTYPE_DVD_NAVIGATION_DSI"); + IF_GUID_EQUAL_RETURN(guid,0xe06d802f,0xdb46,0x11cf,0xb4,0xd1,0x00,0x80,0x05f,0x6c,0xbb,0xea,"MEDIASUBTYPE_DVD_NAVIGATION_PCI"); + IF_GUID_EQUAL_RETURN(guid,0xe06d8031,0xdb46,0x11cf,0xb4,0xd1,0x00,0x80,0x05f,0x6c,0xbb,0xea,"MEDIASUBTYPE_DVD_NAVIGATION_PROVIDER"); + IF_GUID_EQUAL_RETURN(guid,0xe06d802d,0xdb46,0x11cf,0xb4,0xd1,0x00,0x80,0x05f,0x6c,0xbb,0xea,"MEDIASUBTYPE_DVD_SUBPICTURE"); + IF_GUID_EQUAL_RETURN(guid,0x00002000,0x0000,0x0010,0x80,0x00,0x00,0xaa,0x00,0x38,0x9b,0x71,"MEDIASUBTYPE_DVM"); + IF_GUID_EQUAL_RETURN(guid,0x44535644,0x0000,0x0010,0x80,0x00,0x00,0xaa,0x00,0x38,0x9b,0x71,"MEDIASUBTYPE_DVSD"); + IF_GUID_EQUAL_RETURN(guid,0xa0af4f82,0xe163,0x11d0,0xba,0xd9,0x0,0x60,0x97,0x44,0x11,0x1a,"MEDIASUBTYPE_DssAudio"); + IF_GUID_EQUAL_RETURN(guid,0xa0af4f81,0xe163,0x11d0,0xba,0xd9,0x0,0x60,0x97,0x44,0x11,0x1a,"MEDIASUBTYPE_DssVideo"); + IF_GUID_EQUAL_RETURN(guid,0xF52ADDAA,0x36F0,0x43F5,0x95,0xEA,0x6D,0x86,0x64,0x84,0x26,0x2A,"MEDIASUBTYPE_DtvCcData"); + IF_GUID_EQUAL_RETURN(guid,0xC4C4C4D0,0x0049,0x4E2B,0x98,0xFB,0x95,0x37,0xF6,0xCE,0x51,0x6D,"MEDIASUBTYPE_ETDTFilter_Tagged"); + IF_GUID_EQUAL_RETURN(guid,0x34363248,0x0000,0x0010,0x80,0x00,0x00,0xaa,0x00,0x38,0x9b,0x71,"MEDIASUBTYPE_H264"); + IF_GUID_EQUAL_RETURN(guid,0x30323449,0x0000,0x0010,0x80,0x00,0x00,0xaa,0x00,0x38,0x9b,0x71,"MEDIASUBTYPE_I420"); + IF_GUID_EQUAL_RETURN(guid,0x34344149,0x0000,0x0010,0x80,0x00,0x00,0xaa,0x00,0x38,0x9b,0x71,"MEDIASUBTYPE_IA44"); + IF_GUID_EQUAL_RETURN(guid,0x00000003,0x0000,0x0010,0x80,0x00,0x00,0xaa,0x00,0x38,0x9b,0x71,"MEDIASUBTYPE_IEEE_FLOAT"); + IF_GUID_EQUAL_RETURN(guid,0x39304649,0x0000,0x0010,0x80,0x00,0x00,0xaa,0x00,0x38,0x9b,0x71,"MEDIASUBTYPE_IF09"); + IF_GUID_EQUAL_RETURN(guid,0x47504A49,0x0000,0x0010,0x80,0x00,0x00,0xaa,0x00,0x38,0x9b,0x71,"MEDIASUBTYPE_IJPG"); + IF_GUID_EQUAL_RETURN(guid,0x31434D49,0x0000,0x0010,0x80,0x00,0x00,0xaa,0x00,0x38,0x9b,0x71,"MEDIASUBTYPE_IMC1"); + IF_GUID_EQUAL_RETURN(guid,0x32434D49,0x0000,0x0010,0x80,0x00,0x00,0xaa,0x00,0x38,0x9b,0x71,"MEDIASUBTYPE_IMC2"); + IF_GUID_EQUAL_RETURN(guid,0x33434D49,0x0000,0x0010,0x80,0x00,0x00,0xaa,0x00,0x38,0x9b,0x71,"MEDIASUBTYPE_IMC3"); + IF_GUID_EQUAL_RETURN(guid,0x34434D49,0x0000,0x0010,0x80,0x00,0x00,0xaa,0x00,0x38,0x9b,0x71,"MEDIASUBTYPE_IMC4"); + IF_GUID_EQUAL_RETURN(guid,0x059dd67d,0x2e55,0x4d41,0x8d,0x1b,0x01,0xf5,0xe4,0xf5,0x06,0x07,"MEDIASUBTYPE_ISDB_CAPTIONS"); + IF_GUID_EQUAL_RETURN(guid,0xe89ad298,0x3601,0x4b06,0xaa,0xec,0x9d,0xde,0xed,0xcc,0x5b,0xd0,"MEDIASUBTYPE_ISDB_SI"); + IF_GUID_EQUAL_RETURN(guid,0x36dc6d28,0xf1a6,0x4216,0x90,0x48,0x9c,0xfc,0xef,0xeb,0x5e,0xba,"MEDIASUBTYPE_ISDB_SUPERIMPOSE"); + IF_GUID_EQUAL_RETURN(guid,0x56555949,0x0000,0x0010,0x80,0x00,0x00,0xaa,0x00,0x38,0x9b,0x71,"MEDIASUBTYPE_IYUV"); + IF_GUID_EQUAL_RETURN(guid,0x6e8d4a22,0x310c,0x11d0,0xb7,0x9a,0x0,0xaa,0x0,0x37,0x67,0xa7,"MEDIASUBTYPE_Line21_BytePair"); + IF_GUID_EQUAL_RETURN(guid,0x6e8d4a23,0x310c,0x11d0,0xb7,0x9a,0x0,0xaa,0x0,0x37,0x67,0xa7,"MEDIASUBTYPE_Line21_GOPPacket"); + IF_GUID_EQUAL_RETURN(guid,0x6e8d4a24,0x310c,0x11d0,0xb7,0x9a,0x0,0xaa,0x0,0x37,0x67,0xa7,"MEDIASUBTYPE_Line21_VBIRawData"); + IF_GUID_EQUAL_RETURN(guid,0x3253344D,0x0000,0x0010,0x80,0x00,0x00,0xaa,0x00,0x38,0x9b,0x71,"MEDIASUBTYPE_M4S2"); + IF_GUID_EQUAL_RETURN(guid,0x4656444D,0x0000,0x0010,0x80,0x00,0x00,0xaa,0x00,0x38,0x9b,0x71,"MEDIASUBTYPE_MDVF"); + IF_GUID_EQUAL_RETURN(guid,0x47504A4D,0x0000,0x0010,0x80,0x00,0x00,0xaa,0x00,0x38,0x9b,0x71,"MEDIASUBTYPE_MJPG"); + IF_GUID_EQUAL_RETURN(guid,0x3234504D,0x0000,0x0010,0x80,0x00,0x00,0xaa,0x00,0x38,0x9b,0x71,"MEDIASUBTYPE_MP42"); + IF_GUID_EQUAL_RETURN(guid,0x3334504D,0x0000,0x0010,0x80,0x00,0x00,0xaa,0x00,0x38,0x9b,0x71,"MEDIASUBTYPE_MP43"); + IF_GUID_EQUAL_RETURN(guid,0x5334504D,0x0000,0x0010,0x80,0x00,0x00,0xaa,0x00,0x38,0x9b,0x71,"MEDIASUBTYPE_MP4S"); + IF_GUID_EQUAL_RETURN(guid,0xe436eb87,0x524f,0x11ce,0x9f,0x53,0x00,0x20,0xaf,0x0b,0xa7,0x70,"MEDIASUBTYPE_MPEG1Audio"); + IF_GUID_EQUAL_RETURN(guid,0x00000050,0x0000,0x0010,0x80,0x00,0x00,0xAA,0x00,0x38,0x9B,0x71,"MEDIASUBTYPE_MPEG1AudioPayload"); + IF_GUID_EQUAL_RETURN(guid,0xe436eb80,0x524f,0x11ce,0x9f,0x53,0x00,0x20,0xaf,0x0b,0xa7,0x70,"MEDIASUBTYPE_MPEG1Packet"); + IF_GUID_EQUAL_RETURN(guid,0xe436eb81,0x524f,0x11ce,0x9f,0x53,0x00,0x20,0xaf,0x0b,0xa7,0x70,"MEDIASUBTYPE_MPEG1Payload"); + IF_GUID_EQUAL_RETURN(guid,0xe436eb84,0x524f,0x11ce,0x9f,0x53,0x00,0x20,0xaf,0x0b,0xa7,0x70,"MEDIASUBTYPE_MPEG1System"); + IF_GUID_EQUAL_RETURN(guid,0xe436eb86,0x524f,0x11ce,0x9f,0x53,0x00,0x20,0xaf,0x0b,0xa7,0x70,"MEDIASUBTYPE_MPEG1Video"); + IF_GUID_EQUAL_RETURN(guid,0xe436eb85,0x524f,0x11ce,0x9f,0x53,0x00,0x20,0xaf,0x0b,0xa7,0x70,"MEDIASUBTYPE_MPEG1VideoCD"); + IF_GUID_EQUAL_RETURN(guid,0xc892e55b,0x252d,0x42b5,0xa3,0x16,0xd9,0x97,0xe7,0xa5,0xd9,0x95,"MEDIASUBTYPE_MPEG2DATA"); + IF_GUID_EQUAL_RETURN(guid,0xe06d802b,0xdb46,0x11cf,0xb4,0xd1,0x00,0x80,0x05f,0x6c,0xbb,0xea,"MEDIASUBTYPE_MPEG2_AUDIO"); + IF_GUID_EQUAL_RETURN(guid,0xaf748dd4,0xd80,0x11db,0x97,0x5,0x0,0x50,0x56,0xc0,0x0,0x8,"MEDIASUBTYPE_MPEG2_PBDA_TRANSPORT_PROCESSED"); + IF_GUID_EQUAL_RETURN(guid,0x0d7aed42,0xcb9a,0x11db,0x97,0x5,0x0,0x50,0x56,0xc0,0x0,0x8,"MEDIASUBTYPE_MPEG2_PBDA_TRANSPORT_RAW"); + IF_GUID_EQUAL_RETURN(guid,0xe06d8022,0xdb46,0x11cf,0xb4,0xd1,0x00,0x80,0x05f,0x6c,0xbb,0xea,"MEDIASUBTYPE_MPEG2_PROGRAM"); + IF_GUID_EQUAL_RETURN(guid,0xe06d8023,0xdb46,0x11cf,0xb4,0xd1,0x00,0x80,0x05f,0x6c,0xbb,0xea,"MEDIASUBTYPE_MPEG2_TRANSPORT"); + IF_GUID_EQUAL_RETURN(guid,0x138aa9a4,0x1ee2,0x4c5b,0x98,0x8e,0x19,0xab,0xfd,0xbc,0x8a,0x11,"MEDIASUBTYPE_MPEG2_TRANSPORT_STRIDE"); + IF_GUID_EQUAL_RETURN(guid,0x18BEC4EA,0x4676,0x450e,0xB4,0x78,0x0C,0xD8,0x4C,0x54,0xB3,0x27,"MEDIASUBTYPE_MPEG2_UDCR_TRANSPORT"); + IF_GUID_EQUAL_RETURN(guid,0x1ed988b0,0x3ffc,0x4523,0x87,0x25,0x34,0x7b,0xee,0xc1,0xa8,0xa0,"MEDIASUBTYPE_MPEG2_VERSIONED_TABLES"); + IF_GUID_EQUAL_RETURN(guid,0xe06d8026,0xdb46,0x11cf,0xb4,0xd1,0x00,0x80,0x5f,0x6c,0xbb,0xea,"MEDIASUBTYPE_MPEG2_VIDEO"); + IF_GUID_EQUAL_RETURN(guid,0x18BEC4EA,0x4676,0x450e,0xB4,0x78,0x0C,0xD8,0x4C,0x54,0xB3,0x27,"MEDIASUBTYPE_MPEG2_WMDRM_TRANSPORT"); + IF_GUID_EQUAL_RETURN(guid,0x00001600,0x0000,0x0010,0x80,0x00,0x00,0xaa,0x00,0x38,0x9b,0x71,"MEDIASUBTYPE_MPEG_ADTS_AAC"); + IF_GUID_EQUAL_RETURN(guid,0x00001610,0x0000,0x0010,0x80,0x00,0x00,0xaa,0x00,0x38,0x9b,0x71,"MEDIASUBTYPE_MPEG_HEAAC"); + IF_GUID_EQUAL_RETURN(guid,0x00001602,0x0000,0x0010,0x80,0x00,0x00,0xaa,0x00,0x38,0x9b,0x71,"MEDIASUBTYPE_MPEG_LOAS"); + IF_GUID_EQUAL_RETURN(guid,0x00001601,0x0000,0x0010,0x80,0x00,0x00,0xaa,0x00,0x38,0x9b,0x71,"MEDIASUBTYPE_MPEG_RAW_AAC"); + IF_GUID_EQUAL_RETURN(guid,0x3447504D,0x0000,0x0010,0x80,0x00,0x00,0xaa,0x00,0x38,0x9b,0x71,"MEDIASUBTYPE_MPG4"); + IF_GUID_EQUAL_RETURN(guid,0x00000160,0x0000,0x0010,0x80,0x00,0x00,0xaa,0x00,0x38,0x9b,0x71,"MEDIASUBTYPE_MSAUDIO1"); + IF_GUID_EQUAL_RETURN(guid,0x3153534D,0x0000,0x0010,0x80,0x00,0x00,0xaa,0x00,0x38,0x9b,0x71,"MEDIASUBTYPE_MSS1"); + IF_GUID_EQUAL_RETURN(guid,0x3253534D,0x0000,0x0010,0x80,0x00,0x00,0xaa,0x00,0x38,0x9b,0x71,"MEDIASUBTYPE_MSS2"); + IF_GUID_EQUAL_RETURN(guid,0x00001608,0x0000,0x0010,0x80,0x00,0x00,0xaa,0x00,0x38,0x9b,0x71,"MEDIASUBTYPE_NOKIA_MPEG_ADTS_AAC"); + IF_GUID_EQUAL_RETURN(guid,0x00001609,0x0000,0x0010,0x80,0x00,0x00,0xaa,0x00,0x38,0x9b,0x71,"MEDIASUBTYPE_NOKIA_MPEG_RAW_AAC"); + IF_GUID_EQUAL_RETURN(guid,0x3131564E,0x0000,0x0010,0x80,0x00,0x00,0xaa,0x00,0x38,0x9b,0x71,"MEDIASUBTYPE_NV11"); + IF_GUID_EQUAL_RETURN(guid,0x3231564E,0x0000,0x0010,0x80,0x00,0x00,0xaa,0x00,0x38,0x9b,0x71,"MEDIASUBTYPE_NV12"); + IF_GUID_EQUAL_RETURN(guid,0x3432564E,0x0000,0x0010,0x80,0x00,0x00,0xaa,0x00,0x38,0x9b,0x71,"MEDIASUBTYPE_NV24"); + IF_GUID_EQUAL_RETURN(guid,0xe436eb8e,0x524f,0x11ce,0x9f,0x53,0x00,0x20,0xaf,0x0b,0xa7,0x70,"MEDIASUBTYPE_None"); + IF_GUID_EQUAL_RETURN(guid,0xe436eb7f,0x524f,0x11ce,0x9f,0x53,0x00,0x20,0xaf,0x0b,0xa7,0x70,"MEDIASUBTYPE_Overlay"); + IF_GUID_EQUAL_RETURN(guid,'010P',0x0000,0x0010,0x80,0x00,0x00,0xaa,0x00,0x38,0x9b,0x71,"MEDIASUBTYPE_P010"); + IF_GUID_EQUAL_RETURN(guid,'610P',0x0000,0x0010,0x80,0x00,0x00,0xaa,0x00,0x38,0x9b,0x71,"MEDIASUBTYPE_P016"); + IF_GUID_EQUAL_RETURN(guid,'802P',0x0000,0x0010,0x80,0x00,0x00,0xaa,0x00,0x38,0x9b,0x71,"MEDIASUBTYPE_P208"); + IF_GUID_EQUAL_RETURN(guid,'012P',0x0000,0x0010,0x80,0x00,0x00,0xaa,0x00,0x38,0x9b,0x71,"MEDIASUBTYPE_P210"); + IF_GUID_EQUAL_RETURN(guid,'612P',0x0000,0x0010,0x80,0x00,0x00,0xaa,0x00,0x38,0x9b,0x71,"MEDIASUBTYPE_P216"); + IF_GUID_EQUAL_RETURN(guid,'804P',0x0000,0x0010,0x80,0x00,0x00,0xaa,0x00,0x38,0x9b,0x71,"MEDIASUBTYPE_P408"); + IF_GUID_EQUAL_RETURN(guid,0x00000001,0x0000,0x0010,0x80,0x00,0x00,0xAA,0x00,0x38,0x9B,0x71,"MEDIASUBTYPE_PCM"); + IF_GUID_EQUAL_RETURN(guid,0xe436eb8a,0x524f,0x11ce,0x9f,0x53,0x00,0x20,0xaf,0x0b,0xa7,0x70,"MEDIASUBTYPE_PCMAudio_Obsolete"); + IF_GUID_EQUAL_RETURN(guid,0x6D756C50,0x0000,0x0010,0x80,0x00,0x00,0xaa,0x00,0x38,0x9b,0x71,"MEDIASUBTYPE_Plum"); + IF_GUID_EQUAL_RETURN(guid,0x6765706a,0x0000,0x0010,0x80,0x00,0x00,0xaa,0x00,0x38,0x9b,0x71,"MEDIASUBTYPE_QTJpeg"); + IF_GUID_EQUAL_RETURN(guid,0xe436eb89,0x524f,0x11ce,0x9f,0x53,0x00,0x20,0xaf,0x0b,0xa7,0x70,"MEDIASUBTYPE_QTMovie"); + IF_GUID_EQUAL_RETURN(guid,0x20656c72,0x0000,0x0010,0x80,0x00,0x00,0xaa,0x00,0x38,0x9b,0x71,"MEDIASUBTYPE_QTRle"); + IF_GUID_EQUAL_RETURN(guid,0x617a7072,0x0000,0x0010,0x80,0x00,0x00,0xaa,0x00,0x38,0x9b,0x71,"MEDIASUBTYPE_QTRpza"); + IF_GUID_EQUAL_RETURN(guid,0x20636d73,0x0000,0x0010,0x80,0x00,0x00,0xaa,0x00,0x38,0x9b,0x71,"MEDIASUBTYPE_QTSmc"); + IF_GUID_EQUAL_RETURN(guid,0x000000FF,0x0000,0x0010,0x80,0x00,0x00,0xaa,0x00,0x38,0x9b,0x71,"MEDIASUBTYPE_RAW_AAC1"); + IF_GUID_EQUAL_RETURN(guid,0x00000240,0x0000,0x0010,0x80,0x00,0x00,0xaa,0x00,0x38,0x9b,0x71,"MEDIASUBTYPE_RAW_SPORT"); + IF_GUID_EQUAL_RETURN(guid,0x36315237,0x0000,0x0010,0x80,0x00,0x00,0xaa,0x00,0x38,0x9b,0x71,"MEDIASUBTYPE_RGB16_D3D_DX7_RT"); + IF_GUID_EQUAL_RETURN(guid,0x36315239,0x0000,0x0010,0x80,0x00,0x00,0xaa,0x00,0x38,0x9b,0x71,"MEDIASUBTYPE_RGB16_D3D_DX9_RT"); + IF_GUID_EQUAL_RETURN(guid,0xe436eb78,0x524f,0x11ce,0x9f,0x53,0x00,0x20,0xaf,0x0b,0xa7,0x70,"MEDIASUBTYPE_RGB1"); + IF_GUID_EQUAL_RETURN(guid,0xe436eb7d,0x524f,0x11ce,0x9f,0x53,0x00,0x20,0xaf,0x0b,0xa7,0x70,"MEDIASUBTYPE_RGB24"); + IF_GUID_EQUAL_RETURN(guid,0xe436eb7e,0x524f,0x11ce,0x9f,0x53,0x00,0x20,0xaf,0x0b,0xa7,0x70,"MEDIASUBTYPE_RGB32"); + IF_GUID_EQUAL_RETURN(guid,0x32335237,0x0000,0x0010,0x80,0x00,0x00,0xaa,0x00,0x38,0x9b,0x71,"MEDIASUBTYPE_RGB32_D3D_DX7_RT"); + IF_GUID_EQUAL_RETURN(guid,0x32335239,0x0000,0x0010,0x80,0x00,0x00,0xaa,0x00,0x38,0x9b,0x71,"MEDIASUBTYPE_RGB32_D3D_DX9_RT"); + IF_GUID_EQUAL_RETURN(guid,0xe436eb79,0x524f,0x11ce,0x9f,0x53,0x00,0x20,0xaf,0x0b,0xa7,0x70,"MEDIASUBTYPE_RGB4"); + IF_GUID_EQUAL_RETURN(guid,0xe436eb7c,0x524f,0x11ce,0x9f,0x53,0x00,0x20,0xaf,0x0b,0xa7,0x70,"MEDIASUBTYPE_RGB555"); + IF_GUID_EQUAL_RETURN(guid,0xe436eb7b,0x524f,0x11ce,0x9f,0x53,0x00,0x20,0xaf,0x0b,0xa7,0x70,"MEDIASUBTYPE_RGB565"); + IF_GUID_EQUAL_RETURN(guid,0xe436eb7a,0x524f,0x11ce,0x9f,0x53,0x00,0x20,0xaf,0x0b,0xa7,0x70,"MEDIASUBTYPE_RGB8"); + IF_GUID_EQUAL_RETURN(guid,0x30343353,0x0000,0x0010,0x80,0x00,0x00,0xaa,0x00,0x38,0x9b,0x71,"MEDIASUBTYPE_S340"); + IF_GUID_EQUAL_RETURN(guid,0x32343353,0x0000,0x0010,0x80,0x00,0x00,0xaa,0x00,0x38,0x9b,0x71,"MEDIASUBTYPE_S342"); + IF_GUID_EQUAL_RETURN(guid,0xe06d8034,0xdb46,0x11cf,0xb4,0xd1,0x00,0x80,0x05f,0x6c,0xbb,0xea,"MEDIASUBTYPE_SDDS"); + IF_GUID_EQUAL_RETURN(guid,0x00000241,0x0000,0x0010,0x80,0x00,0x00,0xaa,0x00,0x38,0x9b,0x71,"MEDIASUBTYPE_SPDIF_TAG_241h"); + IF_GUID_EQUAL_RETURN(guid,0xf72a76e3,0xeb0a,0x11d0,0xac,0xe4,0x00,0x00,0xc0,0xcc,0x16,0xba,"MEDIASUBTYPE_TELETEXT"); + IF_GUID_EQUAL_RETURN(guid,0xec232eb2,0xcb96,0x4191,0xb2,0x26,0xe,0xa1,0x29,0xf3,0x82,0x50,"MEDIASUBTYPE_TIF_SI"); + IF_GUID_EQUAL_RETURN(guid,0x4A4D5654,0x0000,0x0010,0x80,0x00,0x00,0xaa,0x00,0x38,0x9b,0x71,"MEDIASUBTYPE_TVMJ"); + IF_GUID_EQUAL_RETURN(guid,0x59565955,0x0000,0x0010,0x80,0x00,0x00,0xaa,0x00,0x38,0x9b,0x71,"MEDIASUBTYPE_UYVY"); + IF_GUID_EQUAL_RETURN(guid,0x36313256,0x0000,0x0010,0x80,0x00,0x00,0xaa,0x00,0x38,0x9b,0x71,"MEDIASUBTYPE_V216"); + IF_GUID_EQUAL_RETURN(guid,0x30313456,0x0000,0x0010,0x80,0x00,0x00,0xaa,0x00,0x38,0x9b,0x71,"MEDIASUBTYPE_V410"); + IF_GUID_EQUAL_RETURN(guid,0x663da43c,0x3e8,0x4e9a,0x9c,0xd5,0xbf,0x11,0xed,0xd,0xef,0x76,"MEDIASUBTYPE_VBI"); + IF_GUID_EQUAL_RETURN(guid,0x0000160A,0x0000,0x0010,0x80,0x00,0x00,0xaa,0x00,0x38,0x9b,0x71,"MEDIASUBTYPE_VODAFONE_MPEG_ADTS_AAC"); + IF_GUID_EQUAL_RETURN(guid,0x0000160B,0x0000,0x0010,0x80,0x00,0x00,0xaa,0x00,0x38,0x9b,0x71,"MEDIASUBTYPE_VODAFONE_MPEG_RAW_AAC"); + IF_GUID_EQUAL_RETURN(guid,0xa1b3f620,0x9792,0x4d8d,0x81,0xa4,0x86,0xaf,0x25,0x77,0x20,0x90,"MEDIASUBTYPE_VPS"); + IF_GUID_EQUAL_RETURN(guid,0x5a9b6a41,0x1a22,0x11d1,0xba,0xd9,0x0,0x60,0x97,0x44,0x11,0x1a,"MEDIASUBTYPE_VPVBI"); + IF_GUID_EQUAL_RETURN(guid,0x5a9b6a40,0x1a22,0x11d1,0xba,0xd9,0x0,0x60,0x97,0x44,0x11,0x1a,"MEDIASUBTYPE_VPVideo"); + IF_GUID_EQUAL_RETURN(guid,0x454B4157,0x0000,0x0010,0x80,0x00,0x00,0xaa,0x00,0x38,0x9b,0x71,"MEDIASUBTYPE_WAKE"); + IF_GUID_EQUAL_RETURN(guid,0xe436eb8b,0x524f,0x11ce,0x9f,0x53,0x00,0x20,0xaf,0x0b,0xa7,0x70,"MEDIASUBTYPE_WAVE"); + IF_GUID_EQUAL_RETURN(guid,0x00000164,0x0000,0x0010,0x80,0x00,0x00,0xaa,0x00,0x38,0x9b,0x71,"MEDIASUBTYPE_WMASPDIF"); + IF_GUID_EQUAL_RETURN(guid,0x00000161,0x0000,0x0010,0x80,0x00,0x00,0xaa,0x00,0x38,0x9b,0x71,"MEDIASUBTYPE_WMAUDIO2"); + IF_GUID_EQUAL_RETURN(guid,0x00000162,0x0000,0x0010,0x80,0x00,0x00,0xaa,0x00,0x38,0x9b,0x71,"MEDIASUBTYPE_WMAUDIO3"); + IF_GUID_EQUAL_RETURN(guid,0x00000168,0x0000,0x0010,0x80,0x00,0x00,0xaa,0x00,0x38,0x9b,0x71,"MEDIASUBTYPE_WMAUDIO4"); + IF_GUID_EQUAL_RETURN(guid,0x00000163,0x0000,0x0010,0x80,0x00,0x00,0xaa,0x00,0x38,0x9b,0x71,"MEDIASUBTYPE_WMAUDIO_LOSSLESS"); + IF_GUID_EQUAL_RETURN(guid,0x31564D57,0x0000,0x0010,0x80,0x00,0x00,0xaa,0x00,0x38,0x9b,0x71,"MEDIASUBTYPE_WMV1"); + IF_GUID_EQUAL_RETURN(guid,0x32564D57,0x0000,0x0010,0x80,0x00,0x00,0xaa,0x00,0x38,0x9b,0x71,"MEDIASUBTYPE_WMV2"); + IF_GUID_EQUAL_RETURN(guid,0x33564D57,0x0000,0x0010,0x80,0x00,0x00,0xaa,0x00,0x38,0x9b,0x71,"MEDIASUBTYPE_WMV3"); + IF_GUID_EQUAL_RETURN(guid,0x41564D57,0x0000,0x0010,0x80,0x00,0x00,0xaa,0x00,0x38,0x9b,0x71,"MEDIASUBTYPE_WMVA"); + IF_GUID_EQUAL_RETURN(guid,0x42564D57,0x0000,0x0010,0x80,0x00,0x00,0xaa,0x00,0x38,0x9b,0x71,"MEDIASUBTYPE_WMVB"); + IF_GUID_EQUAL_RETURN(guid,0x50564D57,0x0000,0x0010,0x80,0x00,0x00,0xaa,0x00,0x38,0x9b,0x71,"MEDIASUBTYPE_WMVP"); + IF_GUID_EQUAL_RETURN(guid,0x52564D57,0x0000,0x0010,0x80,0x00,0x00,0xaa,0x00,0x38,0x9b,0x71,"MEDIASUBTYPE_WMVR"); + IF_GUID_EQUAL_RETURN(guid,0x2791D576,0x8E7A,0x466F,0x9E,0x90,0x5D,0x3F,0x30,0x83,0x73,0x8B,"MEDIASUBTYPE_WSS"); + IF_GUID_EQUAL_RETURN(guid,0x31435657,0x0000,0x0010,0x80,0x00,0x00,0xaa,0x00,0x38,0x9b,0x71,"MEDIASUBTYPE_WVC1"); + IF_GUID_EQUAL_RETURN(guid,0x32505657,0x0000,0x0010,0x80,0x00,0x00,0xaa,0x00,0x38,0x9b,0x71,"MEDIASUBTYPE_WVP2"); + IF_GUID_EQUAL_RETURN(guid,0x34363258,0x0000,0x0010,0x80,0x00,0x00,0xaa,0x00,0x38,0x9b,0x71,"MEDIASUBTYPE_X264"); + IF_GUID_EQUAL_RETURN(guid,0x1ca73e3,0xdce6,0x4575,0xaf,0xe1,0x2b,0xf1,0xc9,0x2,0xca,0xf3,"MEDIASUBTYPE_XDS"); + IF_GUID_EQUAL_RETURN(guid,'012Y',0x0000,0x0010,0x80,0x00,0x00,0xaa,0x00,0x38,0x9b,0x71,"MEDIASUBTYPE_Y210"); + IF_GUID_EQUAL_RETURN(guid,0x31313259,0x0000,0x0010,0x80,0x00,0x00,0xaa,0x00,0x38,0x9b,0x71,"MEDIASUBTYPE_Y211"); + IF_GUID_EQUAL_RETURN(guid,'612Y',0x0000,0x0010,0x80,0x00,0x00,0xaa,0x00,0x38,0x9b,0x71,"MEDIASUBTYPE_Y216"); + IF_GUID_EQUAL_RETURN(guid,0x31313459,0x0000,0x0010,0x80,0x00,0x00,0xaa,0x00,0x38,0x9b,0x71,"MEDIASUBTYPE_Y411"); + IF_GUID_EQUAL_RETURN(guid,0x50313459,0x0000,0x0010,0x80,0x00,0x00,0xaa,0x00,0x38,0x9b,0x71,"MEDIASUBTYPE_Y41P"); + IF_GUID_EQUAL_RETURN(guid,0x54313459,0x0000,0x0010,0x80,0x00,0x00,0xaa,0x00,0x38,0x9b,0x71,"MEDIASUBTYPE_Y41T"); + IF_GUID_EQUAL_RETURN(guid,0x54323459,0x0000,0x0010,0x80,0x00,0x00,0xaa,0x00,0x38,0x9b,0x71,"MEDIASUBTYPE_Y42T"); + IF_GUID_EQUAL_RETURN(guid,0x32595559,0x0000,0x0010,0x80,0x00,0x00,0xaa,0x00,0x38,0x9b,0x71,"MEDIASUBTYPE_YUY2"); + IF_GUID_EQUAL_RETURN(guid,0x56595559,0x0000,0x0010,0x80,0x00,0x00,0xaa,0x00,0x38,0x9b,0x71,"MEDIASUBTYPE_YUYV"); + IF_GUID_EQUAL_RETURN(guid,0x32315659,0x0000,0x0010,0x80,0x00,0x00,0xaa,0x00,0x38,0x9b,0x71,"MEDIASUBTYPE_YV12"); + IF_GUID_EQUAL_RETURN(guid,0x39555659,0x0000,0x0010,0x80,0x00,0x00,0xaa,0x00,0x38,0x9b,0x71,"MEDIASUBTYPE_YVU9"); + IF_GUID_EQUAL_RETURN(guid,0x55595659,0x0000,0x0010,0x80,0x00,0x00,0xaa,0x00,0x38,0x9b,0x71,"MEDIASUBTYPE_YVYU"); + IF_GUID_EQUAL_RETURN(guid,0x35327664,0x0000,0x0010,0x80,0x00,0x00,0xaa,0x00,0x38,0x9b,0x71,"MEDIASUBTYPE_dv25"); + IF_GUID_EQUAL_RETURN(guid,0x30357664,0x0000,0x0010,0x80,0x00,0x00,0xaa,0x00,0x38,0x9b,0x71,"MEDIASUBTYPE_dv50"); + IF_GUID_EQUAL_RETURN(guid,0x31687664,0x0000,0x0010,0x80,0x00,0x00,0xaa,0x00,0x38,0x9b,0x71,"MEDIASUBTYPE_dvh1"); + IF_GUID_EQUAL_RETURN(guid,0x64687664,0x0000,0x0010,0x80,0x00,0x00,0xaa,0x00,0x38,0x9b,0x71,"MEDIASUBTYPE_dvhd"); + IF_GUID_EQUAL_RETURN(guid,0x64737664,0x0000,0x0010,0x80,0x00,0x00,0xaa,0x00,0x38,0x9b,0x71,"MEDIASUBTYPE_dvsd"); + IF_GUID_EQUAL_RETURN(guid,0x6c737664,0x0000,0x0010,0x80,0x00,0x00,0xaa,0x00,0x38,0x9b,0x71,"MEDIASUBTYPE_dvsl"); + IF_GUID_EQUAL_RETURN(guid,0x34363268,0x0000,0x0010,0x80,0x00,0x00,0xaa,0x00,0x38,0x9b,0x71,"MEDIASUBTYPE_h264"); + IF_GUID_EQUAL_RETURN(guid,0x3273346D,0x0000,0x0010,0x80,0x00,0x00,0xaa,0x00,0x38,0x9b,0x71,"MEDIASUBTYPE_m4s2"); + IF_GUID_EQUAL_RETURN(guid,0x3234706D,0x0000,0x0010,0x80,0x00,0x00,0xaa,0x00,0x38,0x9b,0x71,"MEDIASUBTYPE_mp42"); + IF_GUID_EQUAL_RETURN(guid,0x3334706D,0x0000,0x0010,0x80,0x00,0x00,0xaa,0x00,0x38,0x9b,0x71,"MEDIASUBTYPE_mp43"); + IF_GUID_EQUAL_RETURN(guid,0x7334706D,0x0000,0x0010,0x80,0x00,0x00,0xaa,0x00,0x38,0x9b,0x71,"MEDIASUBTYPE_mp4s"); + IF_GUID_EQUAL_RETURN(guid,0x3467706D,0x0000,0x0010,0x80,0x00,0x00,0xaa,0x00,0x38,0x9b,0x71,"MEDIASUBTYPE_mpg4"); + IF_GUID_EQUAL_RETURN(guid,0x30313276,0x0000,0x0010,0x80,0x00,0x00,0xaa,0x00,0x38,0x9b,0x71,"MEDIASUBTYPE_v210"); + IF_GUID_EQUAL_RETURN(guid,0x31766D77,0x0000,0x0010,0x80,0x00,0x00,0xaa,0x00,0x38,0x9b,0x71,"MEDIASUBTYPE_wmv1"); + IF_GUID_EQUAL_RETURN(guid,0x32766D77,0x0000,0x0010,0x80,0x00,0x00,0xaa,0x00,0x38,0x9b,0x71,"MEDIASUBTYPE_wmv2"); + IF_GUID_EQUAL_RETURN(guid,0x33766D77,0x0000,0x0010,0x80,0x00,0x00,0xaa,0x00,0x38,0x9b,0x71,"MEDIASUBTYPE_wmv3"); + IF_GUID_EQUAL_RETURN(guid,0x61766D77,0x0000,0x0010,0x80,0x00,0x00,0xaa,0x00,0x38,0x9b,0x71,"MEDIASUBTYPE_wmva"); + IF_GUID_EQUAL_RETURN(guid,0x62766D77,0x0000,0x0010,0x80,0x00,0x00,0xaa,0x00,0x38,0x9b,0x71,"MEDIASUBTYPE_wmvb"); + IF_GUID_EQUAL_RETURN(guid,0x70766D77,0x0000,0x0010,0x80,0x00,0x00,0xaa,0x00,0x38,0x9b,0x71,"MEDIASUBTYPE_wmvp"); + IF_GUID_EQUAL_RETURN(guid,0x72766D77,0x0000,0x0010,0x80,0x00,0x00,0xaa,0x00,0x38,0x9b,0x71,"MEDIASUBTYPE_wmvr"); + IF_GUID_EQUAL_RETURN(guid,0x31637677,0x0000,0x0010,0x80,0x00,0x00,0xaa,0x00,0x38,0x9b,0x71,"MEDIASUBTYPE_wvc1"); + IF_GUID_EQUAL_RETURN(guid,0x32707677,0x0000,0x0010,0x80,0x00,0x00,0xaa,0x00,0x38,0x9b,0x71,"MEDIASUBTYPE_wvp2"); + IF_GUID_EQUAL_RETURN(guid,0x34363278,0x0000,0x0010,0x80,0x00,0x00,0xaa,0x00,0x38,0x9b,0x71,"MEDIASUBTYPE_x264"); + IF_GUID_EQUAL_RETURN(guid,0x670aea80,0x3a82,0x11d0,0xb7,0x9b,0x0,0xaa,0x0,0x37,0x67,0xa7,"MEDIATYPE_AUXLine21Data"); + IF_GUID_EQUAL_RETURN(guid,0x11264acb,0x37de,0x4eba,0x8c,0x35,0x7f,0x4,0xa1,0xa6,0x83,0x32,"MEDIATYPE_AUXTeletextPage"); + IF_GUID_EQUAL_RETURN(guid,0x482dee1,0x7817,0x11cf,0x8a,0x3,0x0,0xaa,0x0,0x6e,0xcb,0x65,"MEDIATYPE_AnalogAudio"); + IF_GUID_EQUAL_RETURN(guid,0x482dde1,0x7817,0x11cf,0x8a,0x3,0x0,0xaa,0x0,0x6e,0xcb,0x65,"MEDIATYPE_AnalogVideo"); + IF_GUID_EQUAL_RETURN(guid,0x73647561,0x0000,0x0010,0x80,0x00,0x00,0xaa,0x00,0x38,0x9b,0x71,"MEDIATYPE_Audio"); + IF_GUID_EQUAL_RETURN(guid,0xaeb312e9,0x3357,0x43ca,0xb7,0x1,0x97,0xec,0x19,0x8e,0x2b,0x62,"MEDIATYPE_CC_CONTAINER"); + IF_GUID_EQUAL_RETURN(guid,0xfb77e152,0x53b2,0x499c,0xb4,0x6b,0x50,0x9f,0xc3,0x3e,0xdf,0xd7,"MEDIATYPE_DTVCCData"); + IF_GUID_EQUAL_RETURN(guid,0xed0b916a,0x044d,0x11d1,0xaa,0x78,0x00,0xc0,0x04f,0xc3,0x1d,0x60,"MEDIATYPE_DVD_ENCRYPTED_PACK"); + IF_GUID_EQUAL_RETURN(guid,0xe06d802e,0xdb46,0x11cf,0xb4,0xd1,0x00,0x80,0x05f,0x6c,0xbb,0xea,"MEDIATYPE_DVD_NAVIGATION"); + IF_GUID_EQUAL_RETURN(guid,0x656c6966,0x0000,0x0010,0x80,0x00,0x00,0xaa,0x00,0x38,0x9b,0x71,"MEDIATYPE_File"); + IF_GUID_EQUAL_RETURN(guid,0x73766169,0x0000,0x0010,0x80,0x00,0x00,0xaa,0x00,0x38,0x9b,0x71,"MEDIATYPE_Interleaved"); + IF_GUID_EQUAL_RETURN(guid,0x74726c6d,0x0000,0x0010,0x80,0x00,0x00,0xaa,0x00,0x38,0x9b,0x71,"MEDIATYPE_LMRT"); + IF_GUID_EQUAL_RETURN(guid,0xe436eb82,0x524f,0x11ce,0x9f,0x53,0x00,0x20,0xaf,0x0b,0xa7,0x70,"MEDIATYPE_MPEG1SystemStream"); + IF_GUID_EQUAL_RETURN(guid,0x36523B13,0x8EE5,0x11d1,0x8C,0xA3,0x00,0x60,0xB0,0x57,0x66,0x4A,"MEDIATYPE_MPEG2_PACK"); + IF_GUID_EQUAL_RETURN(guid,0xe06d8020,0xdb46,0x11cf,0xb4,0xd1,0x00,0x80,0x5f,0x6c,0xbb,0xea,"MEDIATYPE_MPEG2_PES"); + IF_GUID_EQUAL_RETURN(guid,0x455f176c,0x4b06,0x47ce,0x9a,0xef,0x8c,0xae,0xf7,0x3d,0xf7,0xb5,"MEDIATYPE_MPEG2_SECTIONS"); + IF_GUID_EQUAL_RETURN(guid,0xB88B8A89,0xB049,0x4C80,0xAD,0xCF,0x58,0x98,0x98,0x5E,0x22,0xC1,"MEDIATYPE_MSTVCaption"); + IF_GUID_EQUAL_RETURN(guid,0x7364696D,0x0000,0x0010,0x80,0x00,0x00,0xaa,0x00,0x38,0x9b,0x71,"MEDIATYPE_Midi"); + IF_GUID_EQUAL_RETURN(guid,0x73636d64,0x0000,0x0010,0x80,0x00,0x00,0xaa,0x00,0x38,0x9b,0x71,"MEDIATYPE_ScriptCommand"); + IF_GUID_EQUAL_RETURN(guid,0xe436eb83,0x524f,0x11ce,0x9f,0x53,0x00,0x20,0xaf,0x0b,0xa7,0x70,"MEDIATYPE_Stream"); + IF_GUID_EQUAL_RETURN(guid,0x73747874,0x0000,0x0010,0x80,0x00,0x00,0xaa,0x00,0x38,0x9b,0x71,"MEDIATYPE_Text"); + IF_GUID_EQUAL_RETURN(guid,0x482dee3,0x7817,0x11cf,0x8a,0x3,0x0,0xaa,0x0,0x6e,0xcb,0x65,"MEDIATYPE_Timecode"); + IF_GUID_EQUAL_RETURN(guid,0x736c7275,0x0000,0x0010,0x80,0x00,0x00,0xaa,0x00,0x38,0x9b,0x71,"MEDIATYPE_URL_STREAM"); + IF_GUID_EQUAL_RETURN(guid,0xf72a76e1,0xeb0a,0x11d0,0xac,0xe4,0x00,0x00,0xc0,0xcc,0x16,0xba,"MEDIATYPE_VBI"); + IF_GUID_EQUAL_RETURN(guid,0x73646976,0x0000,0x0010,0x80,0x00,0x00,0xaa,0x00,0x38,0x9b,0x71,"MEDIATYPE_Video"); + IF_GUID_EQUAL_RETURN(guid,0x49815231,0x6bad,0x44fd,0x81,0xa,0x3f,0x60,0x98,0x4e,0xc7,0xfd,"MFASFINDEXER_TYPE_TIMECODE"); + IF_GUID_EQUAL_RETURN(guid,0x72178C2C,0xE45B,0x11D5,0xBC,0x2A,0x00,0xB0,0xD0,0xF3,0xF4,0xAB,"MFASFMutexType_Bitrate"); + IF_GUID_EQUAL_RETURN(guid,0x72178C2B,0xE45B,0x11D5,0xBC,0x2A,0x00,0xB0,0xD0,0xF3,0xF4,0xAB,"MFASFMutexType_Language"); + IF_GUID_EQUAL_RETURN(guid,0x72178C2D,0xE45B,0x11D5,0xBC,0x2A,0x00,0xB0,0xD0,0xF3,0xF4,0xAB,"MFASFMutexType_Presentation"); + IF_GUID_EQUAL_RETURN(guid,0x72178C2E,0xE45B,0x11D5,0xBC,0x2A,0x00,0xB0,0xD0,0xF3,0xF4,0xAB,"MFASFMutexType_Unknown"); + IF_GUID_EQUAL_RETURN(guid,0xfe584a05,0xe8d6,0x42e3,0xb1,0x76,0xf1,0x21,0x17,0x5,0xfb,0x6f,"MFASFSPLITTER_PACKET_BOUNDARY"); + IF_GUID_EQUAL_RETURN(guid,0xd590dc20,0x07bc,0x436c,0x9c,0xf7,0xf3,0xbb,0xfb,0xf1,0xa4,0xdc,"MFASFSampleExtension_ContentType"); + IF_GUID_EQUAL_RETURN(guid,0x76376591,0x795f,0x4da1,0x86,0xed,0x9d,0x46,0xec,0xa1,0x09,0xa9,"MFASFSampleExtension_Encryption_KeyID"); + IF_GUID_EQUAL_RETURN(guid,0x6698B84E,0x0AFA,0x4330,0xAE,0xB2,0x1C,0x0A,0x98,0xD7,0xA4,0x4D,"MFASFSampleExtension_Encryption_SampleID"); + IF_GUID_EQUAL_RETURN(guid,0xe165ec0e,0x19ed,0x45d7,0xb4,0xa7,0x25,0xcb,0xd1,0xe2,0x8e,0x9b,"MFASFSampleExtension_FileName"); + IF_GUID_EQUAL_RETURN(guid,0xf72a3c6f,0x6eb4,0x4ebc,0xb1,0x92,0x9,0xad,0x97,0x59,0xe8,0x28,"MFASFSampleExtension_OutputCleanPoint"); + IF_GUID_EQUAL_RETURN(guid,0x1b1ee554,0xf9ea,0x4bc8,0x82,0x1a,0x37,0x6b,0x74,0xe4,0xc4,0xb8,"MFASFSampleExtension_PixelAspectRatio"); + IF_GUID_EQUAL_RETURN(guid,0x399595ec,0x8667,0x4e2d,0x8f,0xdb,0x98,0x81,0x4c,0xe7,0x6c,0x1e,"MFASFSampleExtension_SMPTE"); + IF_GUID_EQUAL_RETURN(guid,0xc6bd9450,0x867f,0x4907,0x83,0xa3,0xc7,0x79,0x21,0xb7,0x33,0xad,"MFASFSampleExtension_SampleDuration"); + IF_GUID_EQUAL_RETURN(guid,0x1610,0x0000,0x0010,0x80,0x00,0x00,0xaa,0x00,0x38,0x9b,0x71,"MFAudioFormat_AAC");; + IF_GUID_EQUAL_RETURN(guid,0x1600,0x0000,0x0010,0x80,0x00,0x00,0xaa,0x00,0x38,0x9b,0x71,"MFAudioFormat_ADTS");; + IF_GUID_EQUAL_RETURN(guid,0x00000000,0x0000,0x0010,0x80,0x00,0x00,0xaa,0x00,0x38,0x9b,0x71,"MFAudioFormat_Base");; + IF_GUID_EQUAL_RETURN(guid,0x0009,0x0000,0x0010,0x80,0x00,0x00,0xaa,0x00,0x38,0x9b,0x71,"MFAudioFormat_DRM");; + IF_GUID_EQUAL_RETURN(guid,0x0008,0x0000,0x0010,0x80,0x00,0x00,0xaa,0x00,0x38,0x9b,0x71,"MFAudioFormat_DTS");; + IF_GUID_EQUAL_RETURN(guid,0xe06d802c,0xdb46,0x11cf,0xb4,0xd1,0x00,0x80,0x05f,0x6c,0xbb,0xea,"MFAudioFormat_Dolby_AC3"); + IF_GUID_EQUAL_RETURN(guid,0x0092,0x0000,0x0010,0x80,0x00,0x00,0xaa,0x00,0x38,0x9b,0x71,"MFAudioFormat_Dolby_AC3_SPDIF");; + IF_GUID_EQUAL_RETURN(guid,0xa7fb87af,0x2d02,0x42fb,0xa4,0xd4,0x5,0xcd,0x93,0x84,0x3b,0xdd,"MFAudioFormat_Dolby_DDPlus"); + IF_GUID_EQUAL_RETURN(guid,0x0003,0x0000,0x0010,0x80,0x00,0x00,0xaa,0x00,0x38,0x9b,0x71,"MFAudioFormat_Float");; + IF_GUID_EQUAL_RETURN(guid,0x0055,0x0000,0x0010,0x80,0x00,0x00,0xaa,0x00,0x38,0x9b,0x71,"MFAudioFormat_MP3");; + IF_GUID_EQUAL_RETURN(guid,0x0050,0x0000,0x0010,0x80,0x00,0x00,0xaa,0x00,0x38,0x9b,0x71,"MFAudioFormat_MPEG");; + IF_GUID_EQUAL_RETURN(guid,0x000A,0x0000,0x0010,0x80,0x00,0x00,0xaa,0x00,0x38,0x9b,0x71,"MFAudioFormat_MSP1");; + IF_GUID_EQUAL_RETURN(guid,1,0x0000,0x0010,0x80,0x00,0x00,0xaa,0x00,0x38,0x9b,0x71,"MFAudioFormat_PCM");; + IF_GUID_EQUAL_RETURN(guid,0x0164,0x0000,0x0010,0x80,0x00,0x00,0xaa,0x00,0x38,0x9b,0x71,"MFAudioFormat_WMASPDIF");; + IF_GUID_EQUAL_RETURN(guid,0x0161,0x0000,0x0010,0x80,0x00,0x00,0xaa,0x00,0x38,0x9b,0x71,"MFAudioFormat_WMAudioV8");; + IF_GUID_EQUAL_RETURN(guid,0x0162,0x0000,0x0010,0x80,0x00,0x00,0xaa,0x00,0x38,0x9b,0x71,"MFAudioFormat_WMAudioV9");; + IF_GUID_EQUAL_RETURN(guid,0x0163,0x0000,0x0010,0x80,0x00,0x00,0xaa,0x00,0x38,0x9b,0x71,"MFAudioFormat_WMAudio_Lossless");; + IF_GUID_EQUAL_RETURN(guid,0xac3aef60,0xce43,0x11d9,0x92,0xdb,0x00,0x0b,0xdb,0x28,0xff,0x98,"MFCONNECTOR_AGP"); + IF_GUID_EQUAL_RETURN(guid,0x57cd596b,0xce47,0x11d9,0x92,0xdb,0x00,0x0b,0xdb,0x28,0xff,0x98,"MFCONNECTOR_COMPONENT"); + IF_GUID_EQUAL_RETURN(guid,0x57cd596a,0xce47,0x11d9,0x92,0xdb,0x00,0x0b,0xdb,0x28,0xff,0x98,"MFCONNECTOR_COMPOSITE"); + IF_GUID_EQUAL_RETURN(guid,0x57cd5973,0xce47,0x11d9,0x92,0xdb,0x00,0x0b,0xdb,0x28,0xff,0x98,"MFCONNECTOR_DISPLAYPORT_EMBEDDED"); + IF_GUID_EQUAL_RETURN(guid,0x57cd5972,0xce47,0x11d9,0x92,0xdb,0x00,0x0b,0xdb,0x28,0xff,0x98,"MFCONNECTOR_DISPLAYPORT_EXTERNAL"); + IF_GUID_EQUAL_RETURN(guid,0x57cd596c,0xce47,0x11d9,0x92,0xdb,0x00,0x0b,0xdb,0x28,0xff,0x98,"MFCONNECTOR_DVI"); + IF_GUID_EQUAL_RETURN(guid,0x57cd5970,0xce47,0x11d9,0x92,0xdb,0x00,0x0b,0xdb,0x28,0xff,0x98,"MFCONNECTOR_D_JPN"); + IF_GUID_EQUAL_RETURN(guid,0x57cd596d,0xce47,0x11d9,0x92,0xdb,0x00,0x0b,0xdb,0x28,0xff,0x98,"MFCONNECTOR_HDMI"); + IF_GUID_EQUAL_RETURN(guid,0x57cd596e,0xce47,0x11d9,0x92,0xdb,0x00,0x0b,0xdb,0x28,0xff,0x98,"MFCONNECTOR_LVDS"); + IF_GUID_EQUAL_RETURN(guid,0xac3aef5d,0xce43,0x11d9,0x92,0xdb,0x00,0x0b,0xdb,0x28,0xff,0x98,"MFCONNECTOR_PCI"); + IF_GUID_EQUAL_RETURN(guid,0xac3aef5e,0xce43,0x11d9,0x92,0xdb,0x00,0x0b,0xdb,0x28,0xff,0x98,"MFCONNECTOR_PCIX"); + IF_GUID_EQUAL_RETURN(guid,0xac3aef5f,0xce43,0x11d9,0x92,0xdb,0x00,0x0b,0xdb,0x28,0xff,0x98,"MFCONNECTOR_PCI_Express"); + IF_GUID_EQUAL_RETURN(guid,0x57cd5971,0xce47,0x11d9,0x92,0xdb,0x00,0x0b,0xdb,0x28,0xff,0x98,"MFCONNECTOR_SDI"); + IF_GUID_EQUAL_RETURN(guid,0xb94a712,0xad3e,0x4cee,0x83,0xce,0xce,0x32,0xe3,0xdb,0x65,0x22,"MFCONNECTOR_SPDIF"); + IF_GUID_EQUAL_RETURN(guid,0x57cd5969,0xce47,0x11d9,0x92,0xdb,0x00,0x0b,0xdb,0x28,0xff,0x98,"MFCONNECTOR_SVIDEO"); + IF_GUID_EQUAL_RETURN(guid,0x57cd5975,0xce47,0x11d9,0x92,0xdb,0x00,0x0b,0xdb,0x28,0xff,0x98,"MFCONNECTOR_UDI_EMBEDDED"); + IF_GUID_EQUAL_RETURN(guid,0x57cd5974,0xce47,0x11d9,0x92,0xdb,0x00,0x0b,0xdb,0x28,0xff,0x98,"MFCONNECTOR_UDI_EXTERNAL"); + IF_GUID_EQUAL_RETURN(guid,0xac3aef5c,0xce43,0x11d9,0x92,0xdb,0x00,0x0b,0xdb,0x28,0xff,0x98,"MFCONNECTOR_UNKNOWN"); + IF_GUID_EQUAL_RETURN(guid,0x57cd5968,0xce47,0x11d9,0x92,0xdb,0x00,0x0b,0xdb,0x28,0xff,0x98,"MFCONNECTOR_VGA"); + IF_GUID_EQUAL_RETURN(guid,0x6d4d3d4b,0x0ece,0x4652,0x8b,0x3a,0xf2,0xd2,0x42,0x60,0xd8,0x87,"MFENABLETYPE_MF_RebootRequired"); + IF_GUID_EQUAL_RETURN(guid,0xe558b0b5,0xb3c4,0x44a0,0x92,0x4c,0x50,0xd1,0x78,0x93,0x23,0x85,"MFENABLETYPE_MF_UpdateRevocationInformation"); + IF_GUID_EQUAL_RETURN(guid,0x9879f3d6,0xcee2,0x48e6,0xb5,0x73,0x97,0x67,0xab,0x17,0x2f,0x16,"MFENABLETYPE_MF_UpdateUntrustedComponent"); + IF_GUID_EQUAL_RETURN(guid,0x4ff6eeaf,0xb43,0x4797,0x9b,0x85,0xab,0xf3,0x18,0x15,0xe7,0xb0,"MFENABLETYPE_WMDRMV1_LicenseAcquisition"); + IF_GUID_EQUAL_RETURN(guid,0xacd2c84a,0xb303,0x4f65,0xbc,0x2c,0x2c,0x84,0x8d,0x1,0xa9,0x89,"MFENABLETYPE_WMDRMV7_Individualization"); + IF_GUID_EQUAL_RETURN(guid,0x3306df,0x4a06,0x4884,0xa0,0x97,0xef,0x6d,0x22,0xec,0x84,0xa3,"MFENABLETYPE_WMDRMV7_LicenseAcquisition"); + IF_GUID_EQUAL_RETURN(guid,0x19e4a5aa,0x5662,0x4fc5,0xa0,0xc0,0x17,0x58,0x02,0x8e,0x10,0x57,"MFImageFormat_JPEG"); + IF_GUID_EQUAL_RETURN(guid,0x00000016,0x0000,0x0010,0x80,0x00,0x00,0xaa,0x00,0x38,0x9b,0x71,"MFImageFormat_RGB32"); + IF_GUID_EQUAL_RETURN(guid,0x00000000,0x767a,0x494d,0xb4,0x78,0xf2,0x9d,0x25,0xdc,0x90,0x37,"MFMPEG4Format_Base"); + IF_GUID_EQUAL_RETURN(guid,0x73647561,0x0000,0x0010,0x80,0x00,0x00,0xAA,0x00,0x38,0x9B,0x71,"MFMediaType_Audio"); + IF_GUID_EQUAL_RETURN(guid,0x72178C25,0xE45B,0x11D5,0xBC,0x2A,0x00,0xB0,0xD0,0xF3,0xF4,0xAB,"MFMediaType_Binary"); + IF_GUID_EQUAL_RETURN(guid,0x81A412E6,0x8103,0x4B06,0x85,0x7F,0x18,0x62,0x78,0x10,0x24,0xAC,"MFMediaType_Default"); + IF_GUID_EQUAL_RETURN(guid,0x72178C26,0xE45B,0x11D5,0xBC,0x2A,0x00,0xB0,0xD0,0xF3,0xF4,0xAB,"MFMediaType_FileTransfer"); + IF_GUID_EQUAL_RETURN(guid,0x72178C24,0xE45B,0x11D5,0xBC,0x2A,0x00,0xB0,0xD0,0xF3,0xF4,0xAB,"MFMediaType_HTML"); + IF_GUID_EQUAL_RETURN(guid,0x72178C23,0xE45B,0x11D5,0xBC,0x2A,0x00,0xB0,0xD0,0xF3,0xF4,0xAB,"MFMediaType_Image"); + IF_GUID_EQUAL_RETURN(guid,0x7b4b6fe6,0x9d04,0x4494,0xbe,0x14,0x7e,0x0b,0xd0,0x76,0xc8,0xe4,"MFMediaType_Protected"); + IF_GUID_EQUAL_RETURN(guid,0xe69669a0,0x3dcd,0x40cb,0x9e,0x2e,0x37,0x08,0x38,0x7c,0x06,0x16,"MFMediaType_SAMI"); + IF_GUID_EQUAL_RETURN(guid,0x72178C22,0xE45B,0x11D5,0xBC,0x2A,0x00,0xB0,0xD0,0xF3,0xF4,0xAB,"MFMediaType_Script"); + IF_GUID_EQUAL_RETURN(guid,0xe436eb83,0x524f,0x11ce,0x9f,0x53,0x00,0x20,0xaf,0x0b,0xa7,0x70,"MFMediaType_Stream"); + IF_GUID_EQUAL_RETURN(guid,0x73646976,0x0000,0x0010,0x80,0x00,0x00,0xAA,0x00,0x38,0x9B,0x71,"MFMediaType_Video"); + IF_GUID_EQUAL_RETURN(guid,0x3cb1f277,0x0505,0x4c5d,0xae,0x71,0x0a,0x55,0x63,0x44,0xef,0xa1,"MFNETSOURCE_ACCELERATEDSTREAMINGDURATION"); + IF_GUID_EQUAL_RETURN(guid,0x3cb1f27a,0x0505,0x4c5d,0xae,0x71,0x0a,0x55,0x63,0x44,0xef,0xa1,"MFNETSOURCE_AUTORECONNECTLIMIT"); + IF_GUID_EQUAL_RETURN(guid,0x3cb1f282,0x0505,0x4c5d,0xae,0x71,0x0a,0x55,0x63,0x44,0xef,0xa1,"MFNETSOURCE_AUTORECONNECTPROGRESS"); + IF_GUID_EQUAL_RETURN(guid,0x3cb1f28b,0x0505,0x4c5d,0xae,0x71,0x0a,0x55,0x63,0x44,0xef,0xa1,"MFNETSOURCE_BROWSERUSERAGENT"); + IF_GUID_EQUAL_RETURN(guid,0x3cb1f28c,0x0505,0x4c5d,0xae,0x71,0x0a,0x55,0x63,0x44,0xef,0xa1,"MFNETSOURCE_BROWSERWEBPAGE"); + IF_GUID_EQUAL_RETURN(guid,0x3cb1f276,0x0505,0x4c5d,0xae,0x71,0x0a,0x55,0x63,0x44,0xef,0xa1,"MFNETSOURCE_BUFFERINGTIME"); + IF_GUID_EQUAL_RETURN(guid,0x3cb1f279,0x0505,0x4c5d,0xae,0x71,0x0a,0x55,0x63,0x44,0xef,0xa1,"MFNETSOURCE_CACHEENABLED"); + IF_GUID_EQUAL_RETURN(guid,0x60a2c4a6,0xf197,0x4c14,0xa5,0xbf,0x88,0x83,0xd,0x24,0x58,0xaf,"MFNETSOURCE_CLIENTGUID"); + IF_GUID_EQUAL_RETURN(guid,0x3cb1f278,0x0505,0x4c5d,0xae,0x71,0x0a,0x55,0x63,0x44,0xef,0xa1,"MFNETSOURCE_CONNECTIONBANDWIDTH"); + IF_GUID_EQUAL_RETURN(guid,0x3cb1f280,0x0505,0x4c5d,0xae,0x71,0x0a,0x55,0x63,0x44,0xef,0xa1,"MFNETSOURCE_CREDENTIAL_MANAGER"); + IF_GUID_EQUAL_RETURN(guid,0x47eae1bd,0xbdfe,0x42e2,0x82,0xf3,0x54,0xa4,0x8c,0x17,0x96,0x2d,"MFNETSOURCE_DRMNET_LICENSE_REPRESENTATION"); + IF_GUID_EQUAL_RETURN(guid,0x3cb1f29d,0x0505,0x4c5d,0xae,0x71,0x0a,0x55,0x63,0x44,0xef,0xa1,"MFNETSOURCE_ENABLE_DOWNLOAD"); + IF_GUID_EQUAL_RETURN(guid,0x3cb1f299,0x0505,0x4c5d,0xae,0x71,0x0a,0x55,0x63,0x44,0xef,0xa1,"MFNETSOURCE_ENABLE_HTTP"); + IF_GUID_EQUAL_RETURN(guid,0x3cb1f296,0x0505,0x4c5d,0xae,0x71,0x0a,0x55,0x63,0x44,0xef,0xa1,"MFNETSOURCE_ENABLE_MSB"); + IF_GUID_EQUAL_RETURN(guid,0x824779d8,0xf18b,0x4405,0x8c,0xf1,0x46,0x4f,0xb5,0xaa,0x8f,0x71,"MFNETSOURCE_ENABLE_PRIVATEMODE"); + IF_GUID_EQUAL_RETURN(guid,0x3cb1f298,0x0505,0x4c5d,0xae,0x71,0x0a,0x55,0x63,0x44,0xef,0xa1,"MFNETSOURCE_ENABLE_RTSP"); + IF_GUID_EQUAL_RETURN(guid,0x3cb1f29c,0x0505,0x4c5d,0xae,0x71,0x0a,0x55,0x63,0x44,0xef,0xa1,"MFNETSOURCE_ENABLE_STREAMING"); + IF_GUID_EQUAL_RETURN(guid,0x3cb1f295,0x0505,0x4c5d,0xae,0x71,0x0a,0x55,0x63,0x44,0xef,0xa1,"MFNETSOURCE_ENABLE_TCP"); + IF_GUID_EQUAL_RETURN(guid,0x3cb1f294,0x0505,0x4c5d,0xae,0x71,0x0a,0x55,0x63,0x44,0xef,0xa1,"MFNETSOURCE_ENABLE_UDP"); + IF_GUID_EQUAL_RETURN(guid,0x5b2a7757,0xbc6b,0x447e,0xaa,0x06,0x0d,0xda,0x1c,0x64,0x6e,0x2f,"MFNETSOURCE_FRIENDLYNAME"); + IF_GUID_EQUAL_RETURN(guid,0x3cb1f28f,0x0505,0x4c5d,0xae,0x71,0x0a,0x55,0x63,0x44,0xef,0xa1,"MFNETSOURCE_HOSTEXE"); + IF_GUID_EQUAL_RETURN(guid,0x3cb1f291,0x0505,0x4c5d,0xae,0x71,0x0a,0x55,0x63,0x44,0xef,0xa1,"MFNETSOURCE_HOSTVERSION"); + IF_GUID_EQUAL_RETURN(guid,0x64936ae8,0x9418,0x453a,0x8c,0xda,0x3e,0xa,0x66,0x8b,0x35,0x3b,"MFNETSOURCE_LOGPARAMS"); + IF_GUID_EQUAL_RETURN(guid,0x3cb1f293,0x0505,0x4c5d,0xae,0x71,0x0a,0x55,0x63,0x44,0xef,0xa1,"MFNETSOURCE_LOGURL"); + IF_GUID_EQUAL_RETURN(guid,0x408b24e6,0x4038,0x4401,0xb5,0xb2,0xfe,0x70,0x1a,0x9e,0xbf,0x10,"MFNETSOURCE_MAXBUFFERTIMEMS"); + IF_GUID_EQUAL_RETURN(guid,0x4aab2879,0xbbe1,0x4994,0x9f,0xf0,0x54,0x95,0xbd,0x25,0x1,0x29,"MFNETSOURCE_MAXUDPACCELERATEDSTREAMINGDURATION"); + IF_GUID_EQUAL_RETURN(guid,0x48b29adb,0xfebf,0x45ee,0xa9,0xbf,0xef,0xb8,0x1c,0x49,0x2e,0xfc,"MFNETSOURCE_PEERMANAGER"); + IF_GUID_EQUAL_RETURN(guid,0x3cb1f28e,0x0505,0x4c5d,0xae,0x71,0x0a,0x55,0x63,0x44,0xef,0xa1,"MFNETSOURCE_PLAYERID"); + IF_GUID_EQUAL_RETURN(guid,0x3cb1f292,0x0505,0x4c5d,0xae,0x71,0x0a,0x55,0x63,0x44,0xef,0xa1,"MFNETSOURCE_PLAYERUSERAGENT"); + IF_GUID_EQUAL_RETURN(guid,0x3cb1f28d,0x0505,0x4c5d,0xae,0x71,0x0a,0x55,0x63,0x44,0xef,0xa1,"MFNETSOURCE_PLAYERVERSION"); + IF_GUID_EQUAL_RETURN(guid,0x3cb1f281,0x0505,0x4c5d,0xae,0x71,0x0a,0x55,0x63,0x44,0xef,0xa1,"MFNETSOURCE_PPBANDWIDTH"); + IF_GUID_EQUAL_RETURN(guid,0x3cb1f27f,0x0505,0x4c5d,0xae,0x71,0x0a,0x55,0x63,0x44,0xef,0xa1,"MFNETSOURCE_PREVIEWMODEENABLED"); + IF_GUID_EQUAL_RETURN(guid,0x3cb1f27d,0x0505,0x4c5d,0xae,0x71,0x0a,0x55,0x63,0x44,0xef,0xa1,"MFNETSOURCE_PROTOCOL"); + IF_GUID_EQUAL_RETURN(guid,0x3cb1f286,0x0505,0x4c5d,0xae,0x71,0x0a,0x55,0x63,0x44,0xef,0xa1,"MFNETSOURCE_PROXYBYPASSFORLOCAL"); + IF_GUID_EQUAL_RETURN(guid,0x3cb1f285,0x0505,0x4c5d,0xae,0x71,0x0a,0x55,0x63,0x44,0xef,0xa1,"MFNETSOURCE_PROXYEXCEPTIONLIST"); + IF_GUID_EQUAL_RETURN(guid,0x3cb1f284,0x0505,0x4c5d,0xae,0x71,0x0a,0x55,0x63,0x44,0xef,0xa1,"MFNETSOURCE_PROXYHOSTNAME"); + IF_GUID_EQUAL_RETURN(guid,0x3cb1f29b,0x0505,0x4c5d,0xae,0x71,0x0a,0x55,0x63,0x44,0xef,0xa1,"MFNETSOURCE_PROXYINFO"); + IF_GUID_EQUAL_RETURN(guid,0x3cb1f283,0x0505,0x4c5d,0xae,0x71,0x0a,0x55,0x63,0x44,0xef,0xa1,"MFNETSOURCE_PROXYLOCATORFACTORY"); + IF_GUID_EQUAL_RETURN(guid,0x3cb1f288,0x0505,0x4c5d,0xae,0x71,0x0a,0x55,0x63,0x44,0xef,0xa1,"MFNETSOURCE_PROXYPORT"); + IF_GUID_EQUAL_RETURN(guid,0x3cb1f289,0x0505,0x4c5d,0xae,0x71,0x0a,0x55,0x63,0x44,0xef,0xa1,"MFNETSOURCE_PROXYRERUNAUTODETECTION"); + IF_GUID_EQUAL_RETURN(guid,0x3cb1f287,0x0505,0x4c5d,0xae,0x71,0x0a,0x55,0x63,0x44,0xef,0xa1,"MFNETSOURCE_PROXYSETTINGS"); + IF_GUID_EQUAL_RETURN(guid,0x3cb1f27b,0x0505,0x4c5d,0xae,0x71,0x0a,0x55,0x63,0x44,0xef,0xa1,"MFNETSOURCE_RESENDSENABLED"); + IF_GUID_EQUAL_RETURN(guid,0x815d0ff6,0x265a,0x4477,0x9e,0x46,0x7b,0x80,0xad,0x80,0xb5,0xfb,"MFNETSOURCE_RESOURCE_FILTER"); + IF_GUID_EQUAL_RETURN(guid,0x55e6cb27,0xe69b,0x4267,0x94,0x0c,0x2d,0x7e,0xc5,0xbb,0x8a,0x0f,"MFNETSOURCE_SSLCERTIFICATE_MANAGER"); + IF_GUID_EQUAL_RETURN(guid,0x3cb1f274,0x0505,0x4c5d,0xae,0x71,0x0a,0x55,0x63,0x44,0xef,0xa1,"MFNETSOURCE_STATISTICS"); + IF_GUID_EQUAL_RETURN(guid,0x3cb1f275,0x0505,0x4c5d,0xae,0x71,0x0a,0x55,0x63,0x44,0xef,0xa1,"MFNETSOURCE_STATISTICS_SERVICE"); + IF_GUID_EQUAL_RETURN(guid,0x9ab44318,0xf7cd,0x4f2d,0x8d,0x6d,0xfa,0x35,0xb4,0x92,0xce,0xcb,"MFNETSOURCE_STREAM_LANGUAGE"); + IF_GUID_EQUAL_RETURN(guid,0x3cb1f27c,0x0505,0x4c5d,0xae,0x71,0x0a,0x55,0x63,0x44,0xef,0xa1,"MFNETSOURCE_THINNINGENABLED"); + IF_GUID_EQUAL_RETURN(guid,0x3cb1f27e,0x0505,0x4c5d,0xae,0x71,0x0a,0x55,0x63,0x44,0xef,0xa1,"MFNETSOURCE_TRANSPORT"); + IF_GUID_EQUAL_RETURN(guid,0x3cb1f29a,0x0505,0x4c5d,0xae,0x71,0x0a,0x55,0x63,0x44,0xef,0xa1,"MFNETSOURCE_UDP_PORT_RANGE"); + IF_GUID_EQUAL_RETURN(guid,0xb85a587f,0x3d02,0x4e52,0x95,0x65,0x55,0xd3,0xec,0x1e,0x7f,0xf7,"MFNET_SAVEJOB_SERVICE"); + IF_GUID_EQUAL_RETURN(guid,0xc8e06331,0x75f0,0x4ec1,0x8e,0x77,0x17,0x57,0x8f,0x77,0x3b,0x46,"MFPROTECTIONATTRIBUTE_BEST_EFFORT"); + IF_GUID_EQUAL_RETURN(guid,0x8476fc,0x4b58,0x4d80,0xa7,0x90,0xe7,0x29,0x76,0x73,0x16,0x1d,"MFPROTECTIONATTRIBUTE_CONSTRICTVIDEO_IMAGESIZE"); + IF_GUID_EQUAL_RETURN(guid,0x8536abc5,0x38f1,0x4151,0x9c,0xce,0xf5,0x5d,0x94,0x12,0x29,0xac,"MFPROTECTIONATTRIBUTE_FAIL_OVER"); + IF_GUID_EQUAL_RETURN(guid,0x6f302107,0x3477,0x4468,0x8a,0x8,0xee,0xf9,0xdb,0x10,0xe2,0xf,"MFPROTECTIONATTRIBUTE_HDCP_SRM"); + IF_GUID_EQUAL_RETURN(guid,0xc3fd11c6,0xf8b7,0x4d20,0xb0,0x08,0x1d,0xb1,0x7d,0x61,0xf2,0xda,"MFPROTECTION_ACP"); + IF_GUID_EQUAL_RETURN(guid,0xE57E69E9,0x226B,0x4d31,0xB4,0xE3,0xD3,0xDB,0x00,0x87,0x36,0xDD,"MFPROTECTION_CGMSA"); + IF_GUID_EQUAL_RETURN(guid,0xffc99b44,0xdf48,0x4e16,0x8e,0x66,0x09,0x68,0x92,0xc1,0x57,0x8a,"MFPROTECTION_CONSTRICTAUDIO"); + IF_GUID_EQUAL_RETURN(guid,0x193370ce,0xc5e4,0x4c3a,0x8a,0x66,0x69,0x59,0xb4,0xda,0x44,0x42,"MFPROTECTION_CONSTRICTVIDEO"); + IF_GUID_EQUAL_RETURN(guid,0x8cc6d81b,0xfec6,0x4d8f,0x96,0x4b,0xcf,0xba,0x0b,0x0d,0xad,0x0d,"MFPROTECTION_DISABLE"); + IF_GUID_EQUAL_RETURN(guid,0xa21179a4,0xb7cd,0x40d8,0x96,0x14,0x8e,0xf2,0x37,0x1b,0xa7,0x8d,"MFPROTECTION_DISABLE_SCREEN_SCRAPE"); + IF_GUID_EQUAL_RETURN(guid,0x462a56b2,0x2866,0x4bb6,0x98,0x0d,0x6d,0x8d,0x9e,0xdb,0x1a,0x8c,"MFPROTECTION_FFT"); + IF_GUID_EQUAL_RETURN(guid,0xc873de64,0xd8a5,0x49e6,0x88,0xbb,0xfb,0x96,0x3f,0xd3,0xd4,0xce,"MFPROTECTION_GRAPHICS_TRANSFER_AES_ENCRYPTION"); + IF_GUID_EQUAL_RETURN(guid,0xAE7CC03D,0xC828,0x4021,0xac,0xb7,0xd5,0x78,0xd2,0x7a,0xaf,0x13,"MFPROTECTION_HDCP"); + IF_GUID_EQUAL_RETURN(guid,0x4f5d9566,0xe742,0x4a25,0x8d,0x1f,0xd2,0x87,0xb5,0xfa,0x0a,0xde,"MFPROTECTION_PROTECTED_SURFACE"); + IF_GUID_EQUAL_RETURN(guid,0x65bdf3d2,0x0168,0x4816,0xa5,0x33,0x55,0xd4,0x7b,0x02,0x71,0x01,"MFPROTECTION_TRUSTEDAUDIODRIVERS"); + IF_GUID_EQUAL_RETURN(guid,0x36a59cbc,0x7401,0x4a8c,0xbc,0x20,0x46,0xa7,0xc9,0xe5,0x97,0xf0,"MFPROTECTION_VIDEO_FRAMES"); + IF_GUID_EQUAL_RETURN(guid,0xa267a6a1,0x362e,0x47d0,0x88,0x05,0x46,0x28,0x59,0x8a,0x23,0xe4,"MFPROTECTION_WMDRMOTA"); + IF_GUID_EQUAL_RETURN(guid,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,"MFP_POSITIONTYPE_100NS"); + IF_GUID_EQUAL_RETURN(guid,0xf86f97a4,0xdd54,0x4e2e,0x9a,0x5e,0x55,0xfc,0x2d,0x74,0xa0,0x05,"MFSampleExtension_3DVideo"); + IF_GUID_EQUAL_RETURN(guid,0x8671772,0xe36f,0x4cff,0x97,0xb3,0xd7,0x2e,0x20,0x98,0x7a,0x48,"MFSampleExtension_3DVideo_SampleFormat"); + IF_GUID_EQUAL_RETURN(guid,0x941ce0a3,0x6ae3,0x4dda,0x9a,0x08,0xa6,0x42,0x98,0x34,0x06,0x17,"MFSampleExtension_BottomFieldFirst"); + IF_GUID_EQUAL_RETURN(guid,0x9cdf01d8,0xa0f0,0x43ba,0xb0,0x77,0xea,0xa0,0x6c,0xbd,0x72,0x8a,"MFSampleExtension_CleanPoint"); + IF_GUID_EQUAL_RETURN(guid,0x73a954d4,0x9e2,0x4861,0xbe,0xfc,0x94,0xbd,0x97,0xc0,0x8e,0x6e,"MFSampleExtension_DecodeTimestamp"); + IF_GUID_EQUAL_RETURN(guid,0x6852465a,0xae1c,0x4553,0x8e,0x9b,0xc3,0x42,0x0f,0xcb,0x16,0x37,"MFSampleExtension_DerivedFromTopField"); + IF_GUID_EQUAL_RETURN(guid,0x43483be6,0x4903,0x4314,0xb0,0x32,0x29,0x51,0x36,0x59,0x36,0xfc,"MFSampleExtension_DescrambleData"); + IF_GUID_EQUAL_RETURN(guid,0x8f3e35e7,0x2dcd,0x4887,0x86,0x22,0x2a,0x58,0xba,0xa6,0x52,0xb0,"MFSampleExtension_DeviceTimestamp"); + IF_GUID_EQUAL_RETURN(guid,0x9cdf01d9,0xa0f0,0x43ba,0xb0,0x77,0xea,0xa0,0x6c,0xbd,0x72,0x8a,"MFSampleExtension_Discontinuity"); + IF_GUID_EQUAL_RETURN(guid,0x76376591,0x795f,0x4da1,0x86,0xed,0x9d,0x46,0xec,0xa1,0x09,0xa9,"MFSampleExtension_Encryption_KeyID"); + IF_GUID_EQUAL_RETURN(guid,0x6698b84e,0x0afa,0x4330,0xae,0xb2,0x1c,0x0a,0x98,0xd7,0xa4,0x4d,"MFSampleExtension_Encryption_SampleID"); + IF_GUID_EQUAL_RETURN(guid,0xb4dd4a8c,0xbeb,0x44c4,0x8b,0x75,0xb0,0x2b,0x91,0x3b,0x4,0xf0,"MFSampleExtension_FrameCorruption"); + IF_GUID_EQUAL_RETURN(guid,0x188120cb,0xd7da,0x4b59,0x9b,0x3e,0x92,0x52,0xfd,0x37,0x30,0x1c,"MFSampleExtension_GenKeyCtx"); + IF_GUID_EQUAL_RETURN(guid,0x441ca1ee,0x6b1f,0x4501,0x90,0x3a,0xde,0x87,0xdf,0x42,0xf6,0xed,"MFSampleExtension_GenKeyFunc"); + IF_GUID_EQUAL_RETURN(guid,0xb1d5830a,0xdeb8,0x40e3,0x90,0xfa,0x38,0x99,0x43,0x71,0x64,0x61,"MFSampleExtension_Interlaced"); + IF_GUID_EQUAL_RETURN(guid,0x2789671d,0x389f,0x40bb,0x90,0xd9,0xc2,0x82,0xf7,0x7f,0x9a,0xbd,"MFSampleExtension_PacketCrossOffsets"); + IF_GUID_EQUAL_RETURN(guid,0x304d257c,0x7493,0x4fbd,0xb1,0x49,0x92,0x28,0xde,0x8d,0x9a,0x99,"MFSampleExtension_RepeatFirstField"); + IF_GUID_EQUAL_RETURN(guid,0x9ed713c8,0x9b87,0x4b26,0x82,0x97,0xa9,0x3b,0x0c,0x5a,0x8a,0xcc,"MFSampleExtension_SampleKeyID"); + IF_GUID_EQUAL_RETURN(guid,0x9d85f816,0x658b,0x455a,0xbd,0xe0,0x9f,0xa7,0xe1,0x5a,0xb8,0xf9,"MFSampleExtension_SingleField"); + IF_GUID_EQUAL_RETURN(guid,0x8294da66,0xf328,0x4805,0xb5,0x51,0x00,0xde,0xb4,0xc5,0x7a,0x61,"MFSampleExtension_Token"); + IF_GUID_EQUAL_RETURN(guid,0xc12d55cb,0xd7d9,0x476d,0x81,0xf3,0x69,0x11,0x7f,0x16,0x3e,0xa0,"MFSampleExtension_VideoDSPMode"); + IF_GUID_EQUAL_RETURN(guid,0x973704e6,0xcd14,0x483c,0x8f,0x20,0xc9,0xfc,0x9,0x28,0xba,0xd5,"MFSampleExtension_VideoEncodePictureType"); + IF_GUID_EQUAL_RETURN(guid,0xb2efe478,0xf979,0x4c66,0xb9,0x5e,0xee,0x2b,0x82,0xc8,0x2f,0x36,"MFSampleExtension_VideoEncodeQP"); + IF_GUID_EQUAL_RETURN(guid,0x263067d1,0xd330,0x45dc,0xb6,0x69,0x34,0xd9,0x86,0xe4,0xe3,0xe1,"MFStreamFormat_MPEG2Program"); + IF_GUID_EQUAL_RETURN(guid,0xe06d8023,0xdb46,0x11cf,0xb4,0xd1,0x00,0x80,0x5f,0x6c,0xbb,0xea,"MFStreamFormat_MPEG2Transport"); + IF_GUID_EQUAL_RETURN(guid,0x9ea73fb4,0xef7a,0x4559,0x8d,0x5d,0x71,0x9d,0x8f,0x04,0x26,0xc7,"MFT_CATEGORY_AUDIO_DECODER"); + IF_GUID_EQUAL_RETURN(guid,0x11064c48,0x3648,0x4ed0,0x93,0x2e,0x05,0xce,0x8a,0xc8,0x11,0xb7,"MFT_CATEGORY_AUDIO_EFFECT"); + IF_GUID_EQUAL_RETURN(guid,0x91c64bd0,0xf91e,0x4d8c,0x92,0x76,0xdb,0x24,0x82,0x79,0xd9,0x75,"MFT_CATEGORY_AUDIO_ENCODER"); + IF_GUID_EQUAL_RETURN(guid,0xa8700a7a,0x939b,0x44c5,0x99,0xd7,0x76,0x22,0x6b,0x23,0xb3,0xf1,"MFT_CATEGORY_DEMULTIPLEXER"); + IF_GUID_EQUAL_RETURN(guid,0x059c561e,0x05ae,0x4b61,0xb6,0x9d,0x55,0xb6,0x1e,0xe5,0x4a,0x7b,"MFT_CATEGORY_MULTIPLEXER"); + IF_GUID_EQUAL_RETURN(guid,0x90175d57,0xb7ea,0x4901,0xae,0xb3,0x93,0x3a,0x87,0x47,0x75,0x6f,"MFT_CATEGORY_OTHER"); + IF_GUID_EQUAL_RETURN(guid,0xd6c02d4b,0x6833,0x45b4,0x97,0x1a,0x05,0xa4,0xb0,0x4b,0xab,0x91,"MFT_CATEGORY_VIDEO_DECODER"); + IF_GUID_EQUAL_RETURN(guid,0x12e17c21,0x532c,0x4a6e,0x8a,0x1c,0x40,0x82,0x5a,0x73,0x63,0x97,"MFT_CATEGORY_VIDEO_EFFECT"); + IF_GUID_EQUAL_RETURN(guid,0xf79eac7d,0xe545,0x4387,0xbd,0xee,0xd6,0x47,0xd7,0xbd,0xe4,0x2a,"MFT_CATEGORY_VIDEO_ENCODER"); + IF_GUID_EQUAL_RETURN(guid,0x302ea3fc,0xaa5f,0x47f9,0x9f,0x7a,0xc2,0x18,0x8b,0xb1,0x63,0x2,"MFT_CATEGORY_VIDEO_PROCESSOR"); + IF_GUID_EQUAL_RETURN(guid,0x88a7cb15,0x7b07,0x4a34,0x91,0x28,0xe6,0x4c,0x67,0x3,0xc4,0xd3,"MFT_CODEC_MERIT_Attribute"); + IF_GUID_EQUAL_RETURN(guid,0x71eeb820,0xa59f,0x4de2,0xbc,0xec,0x38,0xdb,0x1d,0xd6,0x11,0xa4,"MFT_CONNECTED_STREAM_ATTRIBUTE"); + IF_GUID_EQUAL_RETURN(guid,0x34e6e728,0x6d6,0x4491,0xa5,0x53,0x47,0x95,0x65,0xd,0xb9,0x12,"MFT_CONNECTED_TO_HW_STREAM"); + IF_GUID_EQUAL_RETURN(guid,0xef80833f,0xf8fa,0x44d9,0x80,0xd8,0x41,0xed,0x62,0x32,0x67,0xc,"MFT_DECODER_EXPOSE_OUTPUT_TYPES_IN_NATIVE_ORDER"); + IF_GUID_EQUAL_RETURN(guid,0xdc2f8496,0x15c4,0x407a,0xb6,0xf0,0x1b,0x66,0xab,0x5f,0xbf,0x53,"MFT_DECODER_FINAL_VIDEO_RESOLUTION_HINT"); + IF_GUID_EQUAL_RETURN(guid,0x2fb866ac,0xb078,0x4942,0xab,0x6c,0x0,0x3d,0x5,0xcd,0xa6,0x74,"MFT_ENUM_HARDWARE_URL_Attribute"); + IF_GUID_EQUAL_RETURN(guid,0x3aecb0cc,0x35b,0x4bcc,0x81,0x85,0x2b,0x8d,0x55,0x1e,0xf3,0xaf,"MFT_ENUM_HARDWARE_VENDOR_ID_Attribute"); + IF_GUID_EQUAL_RETURN(guid,0x111ea8cd,0xb62a,0x4bdb,0x89,0xf6,0x67,0xff,0xcd,0xc2,0x45,0x8b,"MFT_ENUM_TRANSCODE_ONLY_ATTRIBUTE"); + IF_GUID_EQUAL_RETURN(guid,0x8ec2e9fd,0x9148,0x410d,0x83,0x1e,0x70,0x24,0x39,0x46,0x1a,0x8e,"MFT_FIELDOFUSE_UNLOCK_Attribute"); + IF_GUID_EQUAL_RETURN(guid,0x314ffbae,0x5b41,0x4c95,0x9c,0x19,0x4e,0x7d,0x58,0x6f,0xac,0xe3,"MFT_FRIENDLY_NAME_Attribute"); + IF_GUID_EQUAL_RETURN(guid,0x8d030fb8,0xcc43,0x4258,0xa2,0x2e,0x92,0x10,0xbe,0xf8,0x9b,0xe4,"MFT_HW_TIMESTAMP_WITH_QPC_Attribute"); + IF_GUID_EQUAL_RETURN(guid,0x4276c9b1,0x759d,0x4bf3,0x9c,0xd0,0xd,0x72,0x3d,0x13,0x8f,0x96,"MFT_INPUT_TYPES_Attributes"); + IF_GUID_EQUAL_RETURN(guid,0x8eae8cf3,0xa44f,0x4306,0xba,0x5c,0xbf,0x5d,0xda,0x24,0x28,0x18,"MFT_OUTPUT_TYPES_Attributes"); + IF_GUID_EQUAL_RETURN(guid,0x53004909,0x1ef5,0x46d7,0xa1,0x8e,0x5a,0x75,0xf8,0xb5,0x90,0x5f,"MFT_PREFERRED_ENCODER_PROFILE"); + IF_GUID_EQUAL_RETURN(guid,0x7e700499,0x396a,0x49ee,0xb1,0xb4,0xf6,0x28,0x2,0x1e,0x8c,0x9d,"MFT_PREFERRED_OUTPUTTYPE_Attribute"); + IF_GUID_EQUAL_RETURN(guid,0x543186e4,0x4649,0x4e65,0xb5,0x88,0x4a,0xa3,0x52,0xaf,0xf3,0x79,"MFT_PROCESS_LOCAL_Attribute"); + IF_GUID_EQUAL_RETURN(guid,0x93f81b1,0x4f2e,0x4631,0x81,0x68,0x79,0x34,0x3,0x2a,0x1,0xd3,"MFT_SUPPORT_3DVIDEO"); + IF_GUID_EQUAL_RETURN(guid,0x53476a11,0x3f13,0x49fb,0xac,0x42,0xee,0x27,0x33,0xc9,0x67,0x41,"MFT_SUPPORT_DYNAMIC_FORMAT_CHANGE"); + IF_GUID_EQUAL_RETURN(guid,0x6821c42b,0x65a4,0x4e82,0x99,0xbc,0x9a,0x88,0x20,0x5e,0xcd,0xc,"MFT_TRANSFORM_CLSID_Attribute"); + IF_GUID_EQUAL_RETURN(guid,0x34c50167,0x4472,0x4f34,0x9e,0xa0,0xc4,0x9f,0xba,0xcf,0x03,0x7d,"MFTranscodeContainerType_3GP"); + IF_GUID_EQUAL_RETURN(guid,0x6d8d91c3,0x8c91,0x4ed1,0x87,0x42,0x8c,0x34,0x7d,0x5b,0x44,0xd0,"MFTranscodeContainerType_AC3"); + IF_GUID_EQUAL_RETURN(guid,0x132fd27d,0x0f02,0x43de,0xa3,0x01,0x38,0xfb,0xbb,0xb3,0x83,0x4e,"MFTranscodeContainerType_ADTS"); + IF_GUID_EQUAL_RETURN(guid,0x430f6f6e,0xb6bf,0x4fc1,0xa0,0xbd,0x9e,0xe4,0x6e,0xee,0x2a,0xfb,"MFTranscodeContainerType_ASF"); + IF_GUID_EQUAL_RETURN(guid,0x9ba876f1,0x419f,0x4b77,0xa1,0xe0,0x35,0x95,0x9d,0x9d,0x40,0x4,"MFTranscodeContainerType_FMPEG4"); + IF_GUID_EQUAL_RETURN(guid,0xe438b912,0x83f1,0x4de6,0x9e,0x3a,0x9f,0xfb,0xc6,0xdd,0x24,0xd1,"MFTranscodeContainerType_MP3"); + IF_GUID_EQUAL_RETURN(guid,0xbfc2dbf9,0x7bb4,0x4f8f,0xaf,0xde,0xe1,0x12,0xc4,0x4b,0xa8,0x82,"MFTranscodeContainerType_MPEG2"); + IF_GUID_EQUAL_RETURN(guid,0xdc6cd05d,0xb9d0,0x40ef,0xbd,0x35,0xfa,0x62,0x2c,0x1a,0xb2,0x8a,"MFTranscodeContainerType_MPEG4"); + IF_GUID_EQUAL_RETURN(guid,((((DWORD)('420O')&0xFF)<<24)|(((DWORD)('420O')&0xFF00)<<8)|(((DWORD)('420O')&0xFF0000)>>8)|(((DWORD)('420O')&0xFF000000)>>24)),0x0000,0x0010,0x80,0x00,0x00,0xaa,0x00,0x38,0x9b,0x71,"MFVideoFormat_420O");; + IF_GUID_EQUAL_RETURN(guid,((((DWORD)('AI44')&0xFF)<<24)|(((DWORD)('AI44')&0xFF00)<<8)|(((DWORD)('AI44')&0xFF0000)>>8)|(((DWORD)('AI44')&0xFF000000)>>24)),0x0000,0x0010,0x80,0x00,0x00,0xaa,0x00,0x38,0x9b,0x71,"MFVideoFormat_AI44");; + IF_GUID_EQUAL_RETURN(guid,21,0x0000,0x0010,0x80,0x00,0x00,0xaa,0x00,0x38,0x9b,0x71,"MFVideoFormat_ARGB32");; + IF_GUID_EQUAL_RETURN(guid,((((DWORD)('AYUV')&0xFF)<<24)|(((DWORD)('AYUV')&0xFF00)<<8)|(((DWORD)('AYUV')&0xFF0000)>>8)|(((DWORD)('AYUV')&0xFF000000)>>24)),0x0000,0x0010,0x80,0x00,0x00,0xaa,0x00,0x38,0x9b,0x71,"MFVideoFormat_AYUV");; + IF_GUID_EQUAL_RETURN(guid,0x00000000,0x0000,0x0010,0x80,0x00,0x00,0xaa,0x00,0x38,0x9b,0x71,"MFVideoFormat_Base");; + IF_GUID_EQUAL_RETURN(guid,((((DWORD)('dv25')&0xFF)<<24)|(((DWORD)('dv25')&0xFF00)<<8)|(((DWORD)('dv25')&0xFF0000)>>8)|(((DWORD)('dv25')&0xFF000000)>>24)),0x0000,0x0010,0x80,0x00,0x00,0xaa,0x00,0x38,0x9b,0x71,"MFVideoFormat_DV25");; + IF_GUID_EQUAL_RETURN(guid,((((DWORD)('dv50')&0xFF)<<24)|(((DWORD)('dv50')&0xFF00)<<8)|(((DWORD)('dv50')&0xFF0000)>>8)|(((DWORD)('dv50')&0xFF000000)>>24)),0x0000,0x0010,0x80,0x00,0x00,0xaa,0x00,0x38,0x9b,0x71,"MFVideoFormat_DV50");; + IF_GUID_EQUAL_RETURN(guid,((((DWORD)('dvc')&0xFF)<<24)|(((DWORD)('dvc')&0xFF00)<<8)|(((DWORD)('dvc')&0xFF0000)>>8)|(((DWORD)('dvc')&0xFF000000)>>24)),0x0000,0x0010,0x80,0x00,0x00,0xaa,0x00,0x38,0x9b,0x71,"MFVideoFormat_DVC");; + IF_GUID_EQUAL_RETURN(guid,((((DWORD)('dvh1')&0xFF)<<24)|(((DWORD)('dvh1')&0xFF00)<<8)|(((DWORD)('dvh1')&0xFF0000)>>8)|(((DWORD)('dvh1')&0xFF000000)>>24)),0x0000,0x0010,0x80,0x00,0x00,0xaa,0x00,0x38,0x9b,0x71,"MFVideoFormat_DVH1");; + IF_GUID_EQUAL_RETURN(guid,((((DWORD)('dvhd')&0xFF)<<24)|(((DWORD)('dvhd')&0xFF00)<<8)|(((DWORD)('dvhd')&0xFF0000)>>8)|(((DWORD)('dvhd')&0xFF000000)>>24)),0x0000,0x0010,0x80,0x00,0x00,0xaa,0x00,0x38,0x9b,0x71,"MFVideoFormat_DVHD");; + IF_GUID_EQUAL_RETURN(guid,((((DWORD)('dvsd')&0xFF)<<24)|(((DWORD)('dvsd')&0xFF00)<<8)|(((DWORD)('dvsd')&0xFF0000)>>8)|(((DWORD)('dvsd')&0xFF000000)>>24)),0x0000,0x0010,0x80,0x00,0x00,0xaa,0x00,0x38,0x9b,0x71,"MFVideoFormat_DVSD");; + IF_GUID_EQUAL_RETURN(guid,((((DWORD)('dvsl')&0xFF)<<24)|(((DWORD)('dvsl')&0xFF00)<<8)|(((DWORD)('dvsl')&0xFF0000)>>8)|(((DWORD)('dvsl')&0xFF000000)>>24)),0x0000,0x0010,0x80,0x00,0x00,0xaa,0x00,0x38,0x9b,0x71,"MFVideoFormat_DVSL");; + IF_GUID_EQUAL_RETURN(guid,((((DWORD)('H263')&0xFF)<<24)|(((DWORD)('H263')&0xFF00)<<8)|(((DWORD)('H263')&0xFF0000)>>8)|(((DWORD)('H263')&0xFF000000)>>24)),0x0000,0x0010,0x80,0x00,0x00,0xaa,0x00,0x38,0x9b,0x71,"MFVideoFormat_H263");; + IF_GUID_EQUAL_RETURN(guid,((((DWORD)('H264')&0xFF)<<24)|(((DWORD)('H264')&0xFF00)<<8)|(((DWORD)('H264')&0xFF0000)>>8)|(((DWORD)('H264')&0xFF000000)>>24)),0x0000,0x0010,0x80,0x00,0x00,0xaa,0x00,0x38,0x9b,0x71,"MFVideoFormat_H264");; + IF_GUID_EQUAL_RETURN(guid,0x3f40f4f0,0x5622,0x4ff8,0xb6,0xd8,0xa1,0x7a,0x58,0x4b,0xee,0x5e,"MFVideoFormat_H264_ES"); + IF_GUID_EQUAL_RETURN(guid,((((DWORD)('I420')&0xFF)<<24)|(((DWORD)('I420')&0xFF00)<<8)|(((DWORD)('I420')&0xFF0000)>>8)|(((DWORD)('I420')&0xFF000000)>>24)),0x0000,0x0010,0x80,0x00,0x00,0xaa,0x00,0x38,0x9b,0x71,"MFVideoFormat_I420");; + IF_GUID_EQUAL_RETURN(guid,((((DWORD)('IYUV')&0xFF)<<24)|(((DWORD)('IYUV')&0xFF00)<<8)|(((DWORD)('IYUV')&0xFF0000)>>8)|(((DWORD)('IYUV')&0xFF000000)>>24)),0x0000,0x0010,0x80,0x00,0x00,0xaa,0x00,0x38,0x9b,0x71,"MFVideoFormat_IYUV");; + IF_GUID_EQUAL_RETURN(guid,((((DWORD)('M4S2')&0xFF)<<24)|(((DWORD)('M4S2')&0xFF00)<<8)|(((DWORD)('M4S2')&0xFF0000)>>8)|(((DWORD)('M4S2')&0xFF000000)>>24)),0x0000,0x0010,0x80,0x00,0x00,0xaa,0x00,0x38,0x9b,0x71,"MFVideoFormat_M4S2");; + IF_GUID_EQUAL_RETURN(guid,((((DWORD)('MJPG')&0xFF)<<24)|(((DWORD)('MJPG')&0xFF00)<<8)|(((DWORD)('MJPG')&0xFF0000)>>8)|(((DWORD)('MJPG')&0xFF000000)>>24)),0x0000,0x0010,0x80,0x00,0x00,0xaa,0x00,0x38,0x9b,0x71,"MFVideoFormat_MJPG");; + IF_GUID_EQUAL_RETURN(guid,((((DWORD)('MP43')&0xFF)<<24)|(((DWORD)('MP43')&0xFF00)<<8)|(((DWORD)('MP43')&0xFF0000)>>8)|(((DWORD)('MP43')&0xFF000000)>>24)),0x0000,0x0010,0x80,0x00,0x00,0xaa,0x00,0x38,0x9b,0x71,"MFVideoFormat_MP43");; + IF_GUID_EQUAL_RETURN(guid,((((DWORD)('MP4S')&0xFF)<<24)|(((DWORD)('MP4S')&0xFF00)<<8)|(((DWORD)('MP4S')&0xFF0000)>>8)|(((DWORD)('MP4S')&0xFF000000)>>24)),0x0000,0x0010,0x80,0x00,0x00,0xaa,0x00,0x38,0x9b,0x71,"MFVideoFormat_MP4S");; + IF_GUID_EQUAL_RETURN(guid,((((DWORD)('MP4V')&0xFF)<<24)|(((DWORD)('MP4V')&0xFF00)<<8)|(((DWORD)('MP4V')&0xFF0000)>>8)|(((DWORD)('MP4V')&0xFF000000)>>24)),0x0000,0x0010,0x80,0x00,0x00,0xaa,0x00,0x38,0x9b,0x71,"MFVideoFormat_MP4V");; + IF_GUID_EQUAL_RETURN(guid,0xe06d8026,0xdb46,0x11cf,0xb4,0xd1,0x00,0x80,0x5f,0x6c,0xbb,0xea,"MFVideoFormat_MPEG2"); + IF_GUID_EQUAL_RETURN(guid,((((DWORD)('MPG1')&0xFF)<<24)|(((DWORD)('MPG1')&0xFF00)<<8)|(((DWORD)('MPG1')&0xFF0000)>>8)|(((DWORD)('MPG1')&0xFF000000)>>24)),0x0000,0x0010,0x80,0x00,0x00,0xaa,0x00,0x38,0x9b,0x71,"MFVideoFormat_MPG1");; + IF_GUID_EQUAL_RETURN(guid,((((DWORD)('MSS1')&0xFF)<<24)|(((DWORD)('MSS1')&0xFF00)<<8)|(((DWORD)('MSS1')&0xFF0000)>>8)|(((DWORD)('MSS1')&0xFF000000)>>24)),0x0000,0x0010,0x80,0x00,0x00,0xaa,0x00,0x38,0x9b,0x71,"MFVideoFormat_MSS1");; + IF_GUID_EQUAL_RETURN(guid,((((DWORD)('MSS2')&0xFF)<<24)|(((DWORD)('MSS2')&0xFF00)<<8)|(((DWORD)('MSS2')&0xFF0000)>>8)|(((DWORD)('MSS2')&0xFF000000)>>24)),0x0000,0x0010,0x80,0x00,0x00,0xaa,0x00,0x38,0x9b,0x71,"MFVideoFormat_MSS2");; + IF_GUID_EQUAL_RETURN(guid,((((DWORD)('NV11')&0xFF)<<24)|(((DWORD)('NV11')&0xFF00)<<8)|(((DWORD)('NV11')&0xFF0000)>>8)|(((DWORD)('NV11')&0xFF000000)>>24)),0x0000,0x0010,0x80,0x00,0x00,0xaa,0x00,0x38,0x9b,0x71,"MFVideoFormat_NV11");; + IF_GUID_EQUAL_RETURN(guid,((((DWORD)('NV12')&0xFF)<<24)|(((DWORD)('NV12')&0xFF00)<<8)|(((DWORD)('NV12')&0xFF0000)>>8)|(((DWORD)('NV12')&0xFF000000)>>24)),0x0000,0x0010,0x80,0x00,0x00,0xaa,0x00,0x38,0x9b,0x71,"MFVideoFormat_NV12");; + IF_GUID_EQUAL_RETURN(guid,((((DWORD)('P010')&0xFF)<<24)|(((DWORD)('P010')&0xFF00)<<8)|(((DWORD)('P010')&0xFF0000)>>8)|(((DWORD)('P010')&0xFF000000)>>24)),0x0000,0x0010,0x80,0x00,0x00,0xaa,0x00,0x38,0x9b,0x71,"MFVideoFormat_P010");; + IF_GUID_EQUAL_RETURN(guid,((((DWORD)('P016')&0xFF)<<24)|(((DWORD)('P016')&0xFF00)<<8)|(((DWORD)('P016')&0xFF0000)>>8)|(((DWORD)('P016')&0xFF000000)>>24)),0x0000,0x0010,0x80,0x00,0x00,0xaa,0x00,0x38,0x9b,0x71,"MFVideoFormat_P016");; + IF_GUID_EQUAL_RETURN(guid,((((DWORD)('P210')&0xFF)<<24)|(((DWORD)('P210')&0xFF00)<<8)|(((DWORD)('P210')&0xFF0000)>>8)|(((DWORD)('P210')&0xFF000000)>>24)),0x0000,0x0010,0x80,0x00,0x00,0xaa,0x00,0x38,0x9b,0x71,"MFVideoFormat_P210");; + IF_GUID_EQUAL_RETURN(guid,((((DWORD)('P216')&0xFF)<<24)|(((DWORD)('P216')&0xFF00)<<8)|(((DWORD)('P216')&0xFF0000)>>8)|(((DWORD)('P216')&0xFF000000)>>24)),0x0000,0x0010,0x80,0x00,0x00,0xaa,0x00,0x38,0x9b,0x71,"MFVideoFormat_P216");; + IF_GUID_EQUAL_RETURN(guid,20,0x0000,0x0010,0x80,0x00,0x00,0xaa,0x00,0x38,0x9b,0x71,"MFVideoFormat_RGB24");; + IF_GUID_EQUAL_RETURN(guid,22,0x0000,0x0010,0x80,0x00,0x00,0xaa,0x00,0x38,0x9b,0x71,"MFVideoFormat_RGB32");; + IF_GUID_EQUAL_RETURN(guid,24,0x0000,0x0010,0x80,0x00,0x00,0xaa,0x00,0x38,0x9b,0x71,"MFVideoFormat_RGB555");; + IF_GUID_EQUAL_RETURN(guid,23,0x0000,0x0010,0x80,0x00,0x00,0xaa,0x00,0x38,0x9b,0x71,"MFVideoFormat_RGB565");; + IF_GUID_EQUAL_RETURN(guid,41,0x0000,0x0010,0x80,0x00,0x00,0xaa,0x00,0x38,0x9b,0x71,"MFVideoFormat_RGB8");; + IF_GUID_EQUAL_RETURN(guid,((((DWORD)('UYVY')&0xFF)<<24)|(((DWORD)('UYVY')&0xFF00)<<8)|(((DWORD)('UYVY')&0xFF0000)>>8)|(((DWORD)('UYVY')&0xFF000000)>>24)),0x0000,0x0010,0x80,0x00,0x00,0xaa,0x00,0x38,0x9b,0x71,"MFVideoFormat_UYVY");; + IF_GUID_EQUAL_RETURN(guid,((((DWORD)('WMV1')&0xFF)<<24)|(((DWORD)('WMV1')&0xFF00)<<8)|(((DWORD)('WMV1')&0xFF0000)>>8)|(((DWORD)('WMV1')&0xFF000000)>>24)),0x0000,0x0010,0x80,0x00,0x00,0xaa,0x00,0x38,0x9b,0x71,"MFVideoFormat_WMV1");; + IF_GUID_EQUAL_RETURN(guid,((((DWORD)('WMV2')&0xFF)<<24)|(((DWORD)('WMV2')&0xFF00)<<8)|(((DWORD)('WMV2')&0xFF0000)>>8)|(((DWORD)('WMV2')&0xFF000000)>>24)),0x0000,0x0010,0x80,0x00,0x00,0xaa,0x00,0x38,0x9b,0x71,"MFVideoFormat_WMV2");; + IF_GUID_EQUAL_RETURN(guid,((((DWORD)('WMV3')&0xFF)<<24)|(((DWORD)('WMV3')&0xFF00)<<8)|(((DWORD)('WMV3')&0xFF0000)>>8)|(((DWORD)('WMV3')&0xFF000000)>>24)),0x0000,0x0010,0x80,0x00,0x00,0xaa,0x00,0x38,0x9b,0x71,"MFVideoFormat_WMV3");; + IF_GUID_EQUAL_RETURN(guid,((((DWORD)('WVC1')&0xFF)<<24)|(((DWORD)('WVC1')&0xFF00)<<8)|(((DWORD)('WVC1')&0xFF0000)>>8)|(((DWORD)('WVC1')&0xFF000000)>>24)),0x0000,0x0010,0x80,0x00,0x00,0xaa,0x00,0x38,0x9b,0x71,"MFVideoFormat_WVC1");; + IF_GUID_EQUAL_RETURN(guid,((((DWORD)('Y210')&0xFF)<<24)|(((DWORD)('Y210')&0xFF00)<<8)|(((DWORD)('Y210')&0xFF0000)>>8)|(((DWORD)('Y210')&0xFF000000)>>24)),0x0000,0x0010,0x80,0x00,0x00,0xaa,0x00,0x38,0x9b,0x71,"MFVideoFormat_Y210");; + IF_GUID_EQUAL_RETURN(guid,((((DWORD)('Y216')&0xFF)<<24)|(((DWORD)('Y216')&0xFF00)<<8)|(((DWORD)('Y216')&0xFF0000)>>8)|(((DWORD)('Y216')&0xFF000000)>>24)),0x0000,0x0010,0x80,0x00,0x00,0xaa,0x00,0x38,0x9b,0x71,"MFVideoFormat_Y216");; + IF_GUID_EQUAL_RETURN(guid,((((DWORD)('Y410')&0xFF)<<24)|(((DWORD)('Y410')&0xFF00)<<8)|(((DWORD)('Y410')&0xFF0000)>>8)|(((DWORD)('Y410')&0xFF000000)>>24)),0x0000,0x0010,0x80,0x00,0x00,0xaa,0x00,0x38,0x9b,0x71,"MFVideoFormat_Y410");; + IF_GUID_EQUAL_RETURN(guid,((((DWORD)('Y416')&0xFF)<<24)|(((DWORD)('Y416')&0xFF00)<<8)|(((DWORD)('Y416')&0xFF0000)>>8)|(((DWORD)('Y416')&0xFF000000)>>24)),0x0000,0x0010,0x80,0x00,0x00,0xaa,0x00,0x38,0x9b,0x71,"MFVideoFormat_Y416");; + IF_GUID_EQUAL_RETURN(guid,((((DWORD)('Y41P')&0xFF)<<24)|(((DWORD)('Y41P')&0xFF00)<<8)|(((DWORD)('Y41P')&0xFF0000)>>8)|(((DWORD)('Y41P')&0xFF000000)>>24)),0x0000,0x0010,0x80,0x00,0x00,0xaa,0x00,0x38,0x9b,0x71,"MFVideoFormat_Y41P");; + IF_GUID_EQUAL_RETURN(guid,((((DWORD)('Y41T')&0xFF)<<24)|(((DWORD)('Y41T')&0xFF00)<<8)|(((DWORD)('Y41T')&0xFF0000)>>8)|(((DWORD)('Y41T')&0xFF000000)>>24)),0x0000,0x0010,0x80,0x00,0x00,0xaa,0x00,0x38,0x9b,0x71,"MFVideoFormat_Y41T");; + IF_GUID_EQUAL_RETURN(guid,((((DWORD)('Y42T')&0xFF)<<24)|(((DWORD)('Y42T')&0xFF00)<<8)|(((DWORD)('Y42T')&0xFF0000)>>8)|(((DWORD)('Y42T')&0xFF000000)>>24)),0x0000,0x0010,0x80,0x00,0x00,0xaa,0x00,0x38,0x9b,0x71,"MFVideoFormat_Y42T");; + IF_GUID_EQUAL_RETURN(guid,((((DWORD)('YUY2')&0xFF)<<24)|(((DWORD)('YUY2')&0xFF00)<<8)|(((DWORD)('YUY2')&0xFF0000)>>8)|(((DWORD)('YUY2')&0xFF000000)>>24)),0x0000,0x0010,0x80,0x00,0x00,0xaa,0x00,0x38,0x9b,0x71,"MFVideoFormat_YUY2");; + IF_GUID_EQUAL_RETURN(guid,((((DWORD)('YV12')&0xFF)<<24)|(((DWORD)('YV12')&0xFF00)<<8)|(((DWORD)('YV12')&0xFF0000)>>8)|(((DWORD)('YV12')&0xFF000000)>>24)),0x0000,0x0010,0x80,0x00,0x00,0xaa,0x00,0x38,0x9b,0x71,"MFVideoFormat_YV12");; + IF_GUID_EQUAL_RETURN(guid,((((DWORD)('YVU9')&0xFF)<<24)|(((DWORD)('YVU9')&0xFF00)<<8)|(((DWORD)('YVU9')&0xFF0000)>>8)|(((DWORD)('YVU9')&0xFF000000)>>24)),0x0000,0x0010,0x80,0x00,0x00,0xaa,0x00,0x38,0x9b,0x71,"MFVideoFormat_YVU9");; + IF_GUID_EQUAL_RETURN(guid,((((DWORD)('YVYU')&0xFF)<<24)|(((DWORD)('YVYU')&0xFF00)<<8)|(((DWORD)('YVYU')&0xFF0000)>>8)|(((DWORD)('YVYU')&0xFF000000)>>24)),0x0000,0x0010,0x80,0x00,0x00,0xaa,0x00,0x38,0x9b,0x71,"MFVideoFormat_YVYU");; + IF_GUID_EQUAL_RETURN(guid,((((DWORD)('v210')&0xFF)<<24)|(((DWORD)('v210')&0xFF00)<<8)|(((DWORD)('v210')&0xFF0000)>>8)|(((DWORD)('v210')&0xFF000000)>>24)),0x0000,0x0010,0x80,0x00,0x00,0xaa,0x00,0x38,0x9b,0x71,"MFVideoFormat_v210");; + IF_GUID_EQUAL_RETURN(guid,((((DWORD)('v216')&0xFF)<<24)|(((DWORD)('v216')&0xFF00)<<8)|(((DWORD)('v216')&0xFF0000)>>8)|(((DWORD)('v216')&0xFF000000)>>24)),0x0000,0x0010,0x80,0x00,0x00,0xaa,0x00,0x38,0x9b,0x71,"MFVideoFormat_v216");; + IF_GUID_EQUAL_RETURN(guid,((((DWORD)('v410')&0xFF)<<24)|(((DWORD)('v410')&0xFF00)<<8)|(((DWORD)('v410')&0xFF0000)>>8)|(((DWORD)('v410')&0xFF000000)>>24)),0x0000,0x0010,0x80,0x00,0x00,0xaa,0x00,0x38,0x9b,0x71,"MFVideoFormat_v410");; + IF_GUID_EQUAL_RETURN(guid,0xba491361,0xbe50,0x451e,0x95,0xab,0x6d,0x4a,0xcc,0xc7,0xda,0xd8,"MF_ACTIVATE_CUSTOM_VIDEO_MIXER_ACTIVATE"); + IF_GUID_EQUAL_RETURN(guid,0xba491360,0xbe50,0x451e,0x95,0xab,0x6d,0x4a,0xcc,0xc7,0xda,0xd8,"MF_ACTIVATE_CUSTOM_VIDEO_MIXER_CLSID"); + IF_GUID_EQUAL_RETURN(guid,0xba491362,0xbe50,0x451e,0x95,0xab,0x6d,0x4a,0xcc,0xc7,0xda,0xd8,"MF_ACTIVATE_CUSTOM_VIDEO_MIXER_FLAGS"); + IF_GUID_EQUAL_RETURN(guid,0xba491365,0xbe50,0x451e,0x95,0xab,0x6d,0x4a,0xcc,0xc7,0xda,0xd8,"MF_ACTIVATE_CUSTOM_VIDEO_PRESENTER_ACTIVATE"); + IF_GUID_EQUAL_RETURN(guid,0xba491364,0xbe50,0x451e,0x95,0xab,0x6d,0x4a,0xcc,0xc7,0xda,0xd8,"MF_ACTIVATE_CUSTOM_VIDEO_PRESENTER_CLSID"); + IF_GUID_EQUAL_RETURN(guid,0xba491366,0xbe50,0x451e,0x95,0xab,0x6d,0x4a,0xcc,0xc7,0xda,0xd8,"MF_ACTIVATE_CUSTOM_VIDEO_PRESENTER_FLAGS"); + IF_GUID_EQUAL_RETURN(guid,0xc1f6093c,0x7f65,0x4fbd,0x9e,0x39,0x5f,0xae,0xc3,0xc4,0xfb,0xd7,"MF_ACTIVATE_MFT_LOCKED"); + IF_GUID_EQUAL_RETURN(guid,0x9a2dbbdd,0xf57e,0x4162,0x82,0xb9,0x68,0x31,0x37,0x76,0x82,0xd3,"MF_ACTIVATE_VIDEO_WINDOW"); + IF_GUID_EQUAL_RETURN(guid,0x22587627,0x47de,0x4168,0x87,0xf5,0xb5,0xaa,0x9b,0x12,0xa8,0xf0,"MF_ASFPROFILE_MAXPACKETSIZE"); + IF_GUID_EQUAL_RETURN(guid,0x22587626,0x47de,0x4168,0x87,0xf5,0xb5,0xaa,0x9b,0x12,0xa8,0xf0,"MF_ASFPROFILE_MINPACKETSIZE"); + IF_GUID_EQUAL_RETURN(guid,0xc69b5901,0xea1a,0x4c9b,0xb6,0x92,0xe2,0xa0,0xd2,0x9a,0x8a,0xdd,"MF_ASFSTREAMCONFIG_LEAKYBUCKET1"); + IF_GUID_EQUAL_RETURN(guid,0xc69b5902,0xea1a,0x4c9b,0xb6,0x92,0xe2,0xa0,0xd2,0x9a,0x8a,0xdd,"MF_ASFSTREAMCONFIG_LEAKYBUCKET2"); + IF_GUID_EQUAL_RETURN(guid,0xb10aaec3,0xef71,0x4cc3,0xb8,0x73,0x5,0xa9,0xa0,0x8b,0x9f,0x8e,"MF_AUDIO_RENDERER_ATTRIBUTE_ENDPOINT_ID"); + IF_GUID_EQUAL_RETURN(guid,0x6ba644ff,0x27c5,0x4d02,0x98,0x87,0xc2,0x86,0x19,0xfd,0xb9,0x1b,"MF_AUDIO_RENDERER_ATTRIBUTE_ENDPOINT_ROLE"); + IF_GUID_EQUAL_RETURN(guid,0xede4b5e0,0xf805,0x4d6c,0x99,0xb3,0xdb,0x01,0xbf,0x95,0xdf,0xab,"MF_AUDIO_RENDERER_ATTRIBUTE_FLAGS"); + IF_GUID_EQUAL_RETURN(guid,0xede4b5e3,0xf805,0x4d6c,0x99,0xb3,0xdb,0x01,0xbf,0x95,0xdf,0xab,"MF_AUDIO_RENDERER_ATTRIBUTE_SESSION_ID"); + IF_GUID_EQUAL_RETURN(guid,0xa9770471,0x92ec,0x4df4,0x94,0xfe,0x81,0xc3,0x6f,0xc,0x3a,0x7a,"MF_AUDIO_RENDERER_ATTRIBUTE_STREAM_CATEGORY"); + IF_GUID_EQUAL_RETURN(guid,0xa6e1f733,0x3001,0x4915,0x81,0x50,0x15,0x58,0xa2,0x18,0xe,0xc8,"MF_BYTESTREAMHANDLER_ACCEPTS_SHARE_WRITE"); + IF_GUID_EQUAL_RETURN(guid,0xfc358289,0x3cb6,0x460c,0xa4,0x24,0xb6,0x68,0x12,0x60,0x37,0x5a,"MF_BYTESTREAM_CONTENT_TYPE"); + IF_GUID_EQUAL_RETURN(guid,0xfc35828d,0x3cb6,0x460c,0xa4,0x24,0xb6,0x68,0x12,0x60,0x37,0x5a,"MF_BYTESTREAM_DLNA_PROFILE_ID"); + IF_GUID_EQUAL_RETURN(guid,0xfc35828a,0x3cb6,0x460c,0xa4,0x24,0xb6,0x68,0x12,0x60,0x37,0x5a,"MF_BYTESTREAM_DURATION"); + IF_GUID_EQUAL_RETURN(guid,0x9afa0209,0x89d1,0x42af,0x84,0x56,0x1d,0xe6,0xb5,0x62,0xd6,0x91,"MF_BYTESTREAM_EFFECTIVE_URL"); + IF_GUID_EQUAL_RETURN(guid,0xfc35828c,0x3cb6,0x460c,0xa4,0x24,0xb6,0x68,0x12,0x60,0x37,0x5a,"MF_BYTESTREAM_IFO_FILE_URI"); + IF_GUID_EQUAL_RETURN(guid,0xfc35828b,0x3cb6,0x460c,0xa4,0x24,0xb6,0x68,0x12,0x60,0x37,0x5a,"MF_BYTESTREAM_LAST_MODIFIED_TIME"); + IF_GUID_EQUAL_RETURN(guid,0xfc358288,0x3cb6,0x460c,0xa4,0x24,0xb6,0x68,0x12,0x60,0x37,0x5a,"MF_BYTESTREAM_ORIGIN_NAME"); + IF_GUID_EQUAL_RETURN(guid,0xab025e2b,0x16d9,0x4180,0xa1,0x27,0xba,0x6c,0x70,0x15,0x61,0x61,"MF_BYTESTREAM_SERVICE"); + IF_GUID_EQUAL_RETURN(guid,0xb6c5c282,0x4dc9,0x4db9,0xab,0x48,0xcf,0x3b,0x6d,0x8b,0xc5,0xe0,"MF_BYTESTREAM_TRANSCODED"); + IF_GUID_EQUAL_RETURN(guid,0xfded7521,0x8ed8,0x431a,0xa9,0x6b,0xf3,0xe2,0x56,0x5e,0x98,0x1c,"MF_CAPTURE_ENGINE_ALL_EFFECTS_REMOVED"); + IF_GUID_EQUAL_RETURN(guid,0x76e25e7b,0xd595,0x4283,0x96,0x2c,0xc5,0x94,0xaf,0xd7,0x8d,0xdf,"MF_CAPTURE_ENGINE_D3D_MANAGER"); + IF_GUID_EQUAL_RETURN(guid,0x2b8ad2e8,0x7acb,0x4321,0xa6,0x06,0x32,0x5c,0x42,0x49,0xf4,0xfc,"MF_CAPTURE_ENGINE_DECODER_MFT_FIELDOFUSE_UNLOCK_Attribute"); + IF_GUID_EQUAL_RETURN(guid,0xf9818862,0x179d,0x433f,0xa3,0x2f,0x74,0xcb,0xcf,0x74,0x46,0x6d,"MF_CAPTURE_ENGINE_DISABLE_DXVA"); + IF_GUID_EQUAL_RETURN(guid,0xb7c42a6b,0x3207,0x4495,0xb4,0xe7,0x81,0xf9,0xc3,0x5d,0x59,0x91,"MF_CAPTURE_ENGINE_DISABLE_HARDWARE_TRANSFORMS"); + IF_GUID_EQUAL_RETURN(guid,0xaa8dc7b5,0xa048,0x4e13,0x8e,0xbe,0xf2,0x3c,0x46,0xc8,0x30,0xc1,"MF_CAPTURE_ENGINE_EFFECT_ADDED"); + IF_GUID_EQUAL_RETURN(guid,0xc6e8db07,0xfb09,0x4a48,0x89,0xc6,0xbf,0x92,0xa0,0x42,0x22,0xc9,"MF_CAPTURE_ENGINE_EFFECT_REMOVED"); + IF_GUID_EQUAL_RETURN(guid,0x54c63a00,0x78d5,0x422f,0xaa,0x3e,0x5e,0x99,0xac,0x64,0x92,0x69,"MF_CAPTURE_ENGINE_ENCODER_MFT_FIELDOFUSE_UNLOCK_Attribute"); + IF_GUID_EQUAL_RETURN(guid,0x46b89fc6,0x33cc,0x4399,0x9d,0xad,0x78,0x4d,0xe7,0x7d,0x58,0x7c,"MF_CAPTURE_ENGINE_ERROR"); + IF_GUID_EQUAL_RETURN(guid,0xabfa8ad5,0xfc6d,0x4911,0x87,0xe0,0x96,0x19,0x45,0xf8,0xf7,0xce,"MF_CAPTURE_ENGINE_EVENT_GENERATOR_GUID"); + IF_GUID_EQUAL_RETURN(guid,0x82697f44,0xb1cf,0x42eb,0x97,0x53,0xf8,0x6d,0x64,0x9c,0x88,0x65,"MF_CAPTURE_ENGINE_EVENT_STREAM_INDEX"); + IF_GUID_EQUAL_RETURN(guid,0x219992bc,0xcf92,0x4531,0xa1,0xae,0x96,0xe1,0xe8,0x86,0xc8,0xf1,"MF_CAPTURE_ENGINE_INITIALIZED"); + IF_GUID_EQUAL_RETURN(guid,0xbc6989d2,0x0fc1,0x46e1,0xa7,0x4f,0xef,0xd3,0x6b,0xc7,0x88,0xde,"MF_CAPTURE_ENGINE_MEDIASOURCE_CONFIG"); + IF_GUID_EQUAL_RETURN(guid,0x3c50c445,0x7304,0x48eb,0x86,0x5d,0xbb,0xa1,0x9b,0xa3,0xaf,0x5c,"MF_CAPTURE_ENGINE_PHOTO_TAKEN"); + IF_GUID_EQUAL_RETURN(guid,0xa416df21,0xf9d3,0x4a74,0x99,0x1b,0xb8,0x17,0x29,0x89,0x52,0xc4,"MF_CAPTURE_ENGINE_PREVIEW_STARTED"); + IF_GUID_EQUAL_RETURN(guid,0x13d5143c,0x1edd,0x4e50,0xa2,0xef,0x35,0x0a,0x47,0x67,0x80,0x60,"MF_CAPTURE_ENGINE_PREVIEW_STOPPED"); + IF_GUID_EQUAL_RETURN(guid,0xe7b4a49e,0x382c,0x4aef,0xa9,0x46,0xae,0xd5,0x49,0xb,0x71,0x11,"MF_CAPTURE_ENGINE_RECORD_SINK_AUDIO_MAX_PROCESSED_SAMPLES"); + IF_GUID_EQUAL_RETURN(guid,0x1cddb141,0xa7f4,0x4d58,0x98,0x96,0x4d,0x15,0xa5,0x3c,0x4e,0xfe,"MF_CAPTURE_ENGINE_RECORD_SINK_AUDIO_MAX_UNPROCESSED_SAMPLES"); + IF_GUID_EQUAL_RETURN(guid,0xe7b4a49e,0x382c,0x4aef,0xa9,0x46,0xae,0xd5,0x49,0xb,0x71,0x11,"MF_CAPTURE_ENGINE_RECORD_SINK_VIDEO_MAX_PROCESSED_SAMPLES"); + IF_GUID_EQUAL_RETURN(guid,0xb467f705,0x7913,0x4894,0x9d,0x42,0xa2,0x15,0xfe,0xa2,0x3d,0xa9,"MF_CAPTURE_ENGINE_RECORD_SINK_VIDEO_MAX_UNPROCESSED_SAMPLES"); + IF_GUID_EQUAL_RETURN(guid,0xac2b027b,0xddf9,0x48a0,0x89,0xbe,0x38,0xab,0x35,0xef,0x45,0xc0,"MF_CAPTURE_ENGINE_RECORD_STARTED"); + IF_GUID_EQUAL_RETURN(guid,0x55e5200a,0xf98f,0x4c0d,0xa9,0xec,0x9e,0xb2,0x5e,0xd3,0xd7,0x73,"MF_CAPTURE_ENGINE_RECORD_STOPPED"); + IF_GUID_EQUAL_RETURN(guid,0x1c8077da,0x8466,0x4dc4,0x8b,0x8e,0x27,0x6b,0x3f,0x85,0x92,0x3b,"MF_CAPTURE_ENGINE_USE_AUDIO_DEVICE_ONLY"); + IF_GUID_EQUAL_RETURN(guid,0x7e025171,0xcf32,0x4f2e,0x8f,0x19,0x41,0x5,0x77,0xb7,0x3a,0x66,"MF_CAPTURE_ENGINE_USE_VIDEO_DEVICE_ONLY"); + IF_GUID_EQUAL_RETURN(guid,0x7BFCE257,0x12B1,0x4409,0x8C,0x34,0xD4,0x45,0xDA,0xAB,0x75,0x78,"MF_CAPTURE_SINK_PREPARED"); + IF_GUID_EQUAL_RETURN(guid,0xe7e75e4c,0x039c,0x4410,0x81,0x5b,0x87,0x41,0x30,0x7b,0x63,0xaa,"MF_CAPTURE_SOURCE_CURRENT_DEVICE_MEDIA_TYPE_SET"); + IF_GUID_EQUAL_RETURN(guid,0x048e6558,0x60c4,0x4173,0xbd,0x5b,0x6a,0x3c,0xa2,0x89,0x6a,0xee,"MF_DEVICESTREAM_EXTENSION_PLUGIN_CLSID"); + IF_GUID_EQUAL_RETURN(guid,0x37f9375c,0xe664,0x4ea4,0xaa,0xe4,0xcb,0x6d,0x1d,0xac,0xa1,0xf4,"MF_DEVICESTREAM_EXTENSION_PLUGIN_CONNECTION_POINT"); + IF_GUID_EQUAL_RETURN(guid,0xa7ffb865,0xe7b2,0x43b0,0x9f,0x6f,0x9a,0xf2,0xa0,0xe5,0xf,0xc0,"MF_DEVICESTREAM_IMAGE_STREAM"); + IF_GUID_EQUAL_RETURN(guid,0x3eeec7e,0xd605,0x4576,0x8b,0x29,0x65,0x80,0xb4,0x90,0xd7,0xd3,"MF_DEVICESTREAM_INDEPENDENT_IMAGE_STREAM"); + IF_GUID_EQUAL_RETURN(guid,0x1684cebe,0x3175,0x4985,0x88,0x2c,0x0e,0xfd,0x3e,0x8a,0xc1,0x1e,"MF_DEVICESTREAM_MAX_FRAME_BUFFERS"); + IF_GUID_EQUAL_RETURN(guid,0x2939e7b8,0xa62e,0x4579,0xb6,0x74,0xd4,0x7,0x3d,0xfa,0xbb,0xba,"MF_DEVICESTREAM_STREAM_CATEGORY"); + IF_GUID_EQUAL_RETURN(guid,0x11bd5120,0xd124,0x446b,0x88,0xe6,0x17,0x6,0x2,0x57,0xff,0xf9,"MF_DEVICESTREAM_STREAM_ID"); + IF_GUID_EQUAL_RETURN(guid,0x1d180e34,0x538c,0x4fbb,0xa7,0x5a,0x85,0x9a,0xf7,0xd2,0x61,0xa6,"MF_DEVICESTREAM_TAKEPHOTO_TRIGGER"); + IF_GUID_EQUAL_RETURN(guid,0xe63937b7,0xdaaf,0x4d49,0x81,0x5f,0xd8,0x26,0xf8,0xad,0x31,0xe7,"MF_DEVICESTREAM_TRANSFORM_STREAM_ID"); + IF_GUID_EQUAL_RETURN(guid,0x60d0e559,0x52f8,0x4fa2,0xbb,0xce,0xac,0xdb,0x34,0xa8,0xec,0x1,"MF_DEVSOURCE_ATTRIBUTE_FRIENDLY_NAME"); + IF_GUID_EQUAL_RETURN(guid,0x56a819ca,0xc78,0x4de4,0xa0,0xa7,0x3d,0xda,0xba,0xf,0x24,0xd4,"MF_DEVSOURCE_ATTRIBUTE_MEDIA_TYPE"); + IF_GUID_EQUAL_RETURN(guid,0xc60ac5fe,0x252a,0x478f,0xa0,0xef,0xbc,0x8f,0xa5,0xf7,0xca,0xd3,"MF_DEVSOURCE_ATTRIBUTE_SOURCE_TYPE"); + IF_GUID_EQUAL_RETURN(guid,0x30da9258,0xfeb9,0x47a7,0xa4,0x53,0x76,0x3a,0x7a,0x8e,0x1c,0x5f,"MF_DEVSOURCE_ATTRIBUTE_SOURCE_TYPE_AUDCAP_ENDPOINT_ID"); + IF_GUID_EQUAL_RETURN(guid,0x14dd9a1c,0x7cff,0x41be,0xb1,0xb9,0xba,0x1a,0xc6,0xec,0xb5,0x71,"MF_DEVSOURCE_ATTRIBUTE_SOURCE_TYPE_AUDCAP_GUID"); + IF_GUID_EQUAL_RETURN(guid,0xbc9d118e,0x8c67,0x4a18,0x85,0xd4,0x12,0xd3,0x0,0x40,0x5,0x52,"MF_DEVSOURCE_ATTRIBUTE_SOURCE_TYPE_AUDCAP_ROLE"); + IF_GUID_EQUAL_RETURN(guid,0x98d24b5e,0x5930,0x4614,0xb5,0xa1,0xf6,0x0,0xf9,0x35,0x5a,0x78,"MF_DEVSOURCE_ATTRIBUTE_SOURCE_TYPE_AUDCAP_SYMBOLIC_LINK"); + IF_GUID_EQUAL_RETURN(guid,0x77f0ae69,0xc3bd,0x4509,0x94,0x1d,0x46,0x7e,0x4d,0x24,0x89,0x9e,"MF_DEVSOURCE_ATTRIBUTE_SOURCE_TYPE_VIDCAP_CATEGORY"); + IF_GUID_EQUAL_RETURN(guid,0x8ac3587a,0x4ae7,0x42d8,0x99,0xe0,0x0a,0x60,0x13,0xee,0xf9,0x0f,"MF_DEVSOURCE_ATTRIBUTE_SOURCE_TYPE_VIDCAP_GUID"); + IF_GUID_EQUAL_RETURN(guid,0xde7046ba,0x54d6,0x4487,0xa2,0xa4,0xec,0x7c,0xd,0x1b,0xd1,0x63,"MF_DEVSOURCE_ATTRIBUTE_SOURCE_TYPE_VIDCAP_HW_SOURCE"); + IF_GUID_EQUAL_RETURN(guid,0x7dd9b730,0x4f2d,0x41d5,0x8f,0x95,0xc,0xc9,0xa9,0x12,0xba,0x26,"MF_DEVSOURCE_ATTRIBUTE_SOURCE_TYPE_VIDCAP_MAX_BUFFERS"); + IF_GUID_EQUAL_RETURN(guid,0x58f0aad8,0x22bf,0x4f8a,0xbb,0x3d,0xd2,0xc4,0x97,0x8c,0x6e,0x2f,"MF_DEVSOURCE_ATTRIBUTE_SOURCE_TYPE_VIDCAP_SYMBOLIC_LINK"); + IF_GUID_EQUAL_RETURN(guid,0x66b16da9,0xadd4,0x47e0,0xa1,0x6b,0x5a,0xf1,0xfb,0x48,0x36,0x34,"MF_DISABLE_LOCALLY_REGISTERED_PLUGINS"); + IF_GUID_EQUAL_RETURN(guid,0xbdad7bca,0xe5f,0x4b10,0xab,0x16,0x26,0xde,0x38,0x1b,0x62,0x93,"MF_ENABLE_3DVIDEO_OUTPUT"); + IF_GUID_EQUAL_RETURN(guid,0x321ea6fb,0xdad9,0x46e4,0xb3,0x1d,0xd2,0xea,0xe7,0x9,0xe,0x30,"MF_EVENT_DO_THINNING"); + IF_GUID_EQUAL_RETURN(guid,0xb26fbdfd,0xc32c,0x41fe,0x9c,0xf0,0x8,0x3c,0xd5,0xc7,0xf8,0xa4,"MF_EVENT_FORMAT_CHANGE_REQUEST_SOURCE_SAR"); + IF_GUID_EQUAL_RETURN(guid,0xb7cd31f1,0x899e,0x4b41,0x80,0xc9,0x26,0xa8,0x96,0xd3,0x29,0x77,"MF_EVENT_MFT_CONTEXT"); + IF_GUID_EQUAL_RETURN(guid,0xf29c2cca,0x7ae6,0x42d2,0xb2,0x84,0xbf,0x83,0x7c,0xc8,0x74,0xe2,"MF_EVENT_MFT_INPUT_STREAM_ID"); + IF_GUID_EQUAL_RETURN(guid,0x830f1a8b,0xc060,0x46dd,0xa8,0x01,0x1c,0x95,0xde,0xc9,0xb1,0x07,"MF_EVENT_OUTPUT_NODE"); + IF_GUID_EQUAL_RETURN(guid,0x5ad914d1,0x9b45,0x4a8d,0xa2,0xc0,0x81,0xd1,0xe5,0xb,0xfb,0x7,"MF_EVENT_PRESENTATION_TIME_OFFSET"); + IF_GUID_EQUAL_RETURN(guid,0x9ac712b3,0xdcb8,0x44d5,0x8d,0xc,0x37,0x45,0x5a,0x27,0x82,0xe3,"MF_EVENT_SCRUBSAMPLE_TIME"); + IF_GUID_EQUAL_RETURN(guid,0x7e5ebcd0,0x11b8,0x4abe,0xaf,0xad,0x10,0xf6,0x59,0x9a,0x7f,0x42,"MF_EVENT_SESSIONCAPS"); + IF_GUID_EQUAL_RETURN(guid,0x7e5ebcd1,0x11b8,0x4abe,0xaf,0xad,0x10,0xf6,0x59,0x9a,0x7f,0x42,"MF_EVENT_SESSIONCAPS_DELTA"); + IF_GUID_EQUAL_RETURN(guid,0xa8cc55a9,0x6b31,0x419f,0x84,0x5d,0xff,0xb3,0x51,0xa2,0x43,0x4b,"MF_EVENT_SOURCE_ACTUAL_START"); + IF_GUID_EQUAL_RETURN(guid,0x47db8490,0x8b22,0x4f52,0xaf,0xda,0x9c,0xe1,0xb2,0xd3,0xcf,0xa8,"MF_EVENT_SOURCE_CHARACTERISTICS"); + IF_GUID_EQUAL_RETURN(guid,0x47db8491,0x8b22,0x4f52,0xaf,0xda,0x9c,0xe1,0xb2,0xd3,0xcf,0xa8,"MF_EVENT_SOURCE_CHARACTERISTICS_OLD"); + IF_GUID_EQUAL_RETURN(guid,0xa8cc55a7,0x6b31,0x419f,0x84,0x5d,0xff,0xb3,0x51,0xa2,0x43,0x4b,"MF_EVENT_SOURCE_FAKE_START"); + IF_GUID_EQUAL_RETURN(guid,0xa8cc55a8,0x6b31,0x419f,0x84,0x5d,0xff,0xb3,0x51,0xa2,0x43,0x4b,"MF_EVENT_SOURCE_PROJECTSTART"); + IF_GUID_EQUAL_RETURN(guid,0xdb62f650,0x9a5e,0x4704,0xac,0xf3,0x56,0x3b,0xc6,0xa7,0x33,0x64,"MF_EVENT_SOURCE_TOPOLOGY_CANCELED"); + IF_GUID_EQUAL_RETURN(guid,0x5ad914d0,0x9b45,0x4a8d,0xa2,0xc0,0x81,0xd1,0xe5,0xb,0xfb,0x7,"MF_EVENT_START_PRESENTATION_TIME"); + IF_GUID_EQUAL_RETURN(guid,0x5ad914d2,0x9b45,0x4a8d,0xa2,0xc0,0x81,0xd1,0xe5,0xb,0xfb,0x7,"MF_EVENT_START_PRESENTATION_TIME_AT_OUTPUT"); + IF_GUID_EQUAL_RETURN(guid,0x30c5018d,0x9a53,0x454b,0xad,0x9e,0x6d,0x5f,0x8f,0xa7,0xc4,0x3b,"MF_EVENT_TOPOLOGY_STATUS"); + IF_GUID_EQUAL_RETURN(guid,0xddf5cf9c,0x4506,0x45aa,0xab,0xf0,0x6d,0x5d,0x94,0xdd,0x1b,0x4a,"MF_LOCAL_MFT_REGISTRATION_SERVICE"); + IF_GUID_EQUAL_RETURN(guid,0xd91b0085,0xc86d,0x4f81,0x88,0x22,0x8c,0x68,0xe1,0xd7,0xfa,0x04,"MF_LOCAL_PLUGIN_CONTROL_POLICY"); + IF_GUID_EQUAL_RETURN(guid,0x9c27891a,0xed7a,0x40e1,0x88,0xe8,0xb2,0x27,0x27,0xa0,0x24,0xee,"MF_LOW_LATENCY"); + IF_GUID_EQUAL_RETURN(guid,0xc8d4c51d,0x350e,0x41f2,0xba,0x46,0xfa,0xeb,0xbb,0x08,0x57,0xf6,"MF_MEDIA_ENGINE_AUDIO_CATEGORY"); + IF_GUID_EQUAL_RETURN(guid,0xd2cb93d1,0x116a,0x44f2,0x93,0x85,0xf7,0xd0,0xfd,0xa2,0xfb,0x46,"MF_MEDIA_ENGINE_AUDIO_ENDPOINT_ROLE"); + IF_GUID_EQUAL_RETURN(guid,0x4e0212e2,0xe18f,0x41e1,0x95,0xe5,0xc0,0xe7,0xe9,0x23,0x5b,0xc3,"MF_MEDIA_ENGINE_BROWSER_COMPATIBILITY_MODE"); + IF_GUID_EQUAL_RETURN(guid,0x11a47afd,0x6589,0x4124,0xb3,0x12,0x61,0x58,0xec,0x51,0x7f,0xc3,"MF_MEDIA_ENGINE_BROWSER_COMPATIBILITY_MODE_IE10"); + IF_GUID_EQUAL_RETURN(guid,0x052c2d39,0x40c0,0x4188,0xab,0x86,0xf8,0x28,0x27,0x3b,0x75,0x22,"MF_MEDIA_ENGINE_BROWSER_COMPATIBILITY_MODE_IE9"); + IF_GUID_EQUAL_RETURN(guid,0xc60381b8,0x83a4,0x41f8,0xa3,0xd0,0xde,0x05,0x07,0x68,0x49,0xa9,"MF_MEDIA_ENGINE_CALLBACK"); + IF_GUID_EQUAL_RETURN(guid,0xe0350223,0x5aaf,0x4d76,0xa7,0xc3,0x06,0xde,0x70,0x89,0x4d,0xb4,"MF_MEDIA_ENGINE_CONTENT_PROTECTION_FLAGS"); + IF_GUID_EQUAL_RETURN(guid,0xfdd6dfaa,0xbd85,0x4af3,0x9e,0x0f,0xa0,0x1d,0x53,0x9d,0x87,0x6a,"MF_MEDIA_ENGINE_CONTENT_PROTECTION_MANAGER"); + IF_GUID_EQUAL_RETURN(guid,0xfccae4dc,0x0b7f,0x41c2,0x9f,0x96,0x46,0x59,0x94,0x8a,0xcd,0xdc,"MF_MEDIA_ENGINE_COREWINDOW"); + IF_GUID_EQUAL_RETURN(guid,0x065702da,0x1094,0x486d,0x86,0x17,0xee,0x7c,0xc4,0xee,0x46,0x48,"MF_MEDIA_ENGINE_DXGI_MANAGER"); + IF_GUID_EQUAL_RETURN(guid,0x3109fd46,0x060d,0x4b62,0x8d,0xcf,0xfa,0xff,0x81,0x13,0x18,0xd2,"MF_MEDIA_ENGINE_EXTENSION"); + IF_GUID_EQUAL_RETURN(guid,0xa0be8ee7,0x0572,0x4f2c,0xa8,0x01,0x2a,0x15,0x1b,0xd3,0xe7,0x26,"MF_MEDIA_ENGINE_OPM_HWND"); + IF_GUID_EQUAL_RETURN(guid,0xd988879b,0x67c9,0x4d92,0xba,0xa7,0x6e,0xad,0xd4,0x46,0x03,0x9d,"MF_MEDIA_ENGINE_PLAYBACK_HWND"); + IF_GUID_EQUAL_RETURN(guid,0x6debd26f,0x6ab9,0x4d7e,0xb0,0xee,0xc6,0x1a,0x73,0xff,0xad,0x15,"MF_MEDIA_ENGINE_PLAYBACK_VISUAL"); + IF_GUID_EQUAL_RETURN(guid,0x0ac0c497,0xb3c4,0x48c9,0x9c,0xde,0xbb,0x8c,0xa2,0x44,0x2c,0xa3,"MF_MEDIA_ENGINE_SOURCE_RESOLVER_CONFIG_STORE"); + IF_GUID_EQUAL_RETURN(guid,0x5cbfaf44,0xd2b2,0x4cfb,0x80,0xa7,0xd4,0x29,0xc7,0x4c,0x78,0x9d,"MF_MEDIA_ENGINE_STREAM_CONTAINS_ALPHA_CHANNEL"); + IF_GUID_EQUAL_RETURN(guid,0x5066893c,0x8cf9,0x42bc,0x8b,0x8a,0x47,0x22,0x12,0xe5,0x27,0x26,"MF_MEDIA_ENGINE_VIDEO_OUTPUT_FORMAT"); + IF_GUID_EQUAL_RETURN(guid,0xb461c58a,0x7a08,0x4b98,0x99,0xa8,0x70,0xfd,0x5f,0x3b,0xad,0xfd,"MF_MEDIA_SHARING_ENGINE_DEVICE"); + IF_GUID_EQUAL_RETURN(guid,0x771e05d1,0x862f,0x4299,0x95,0xac,0xae,0x81,0xfd,0x14,0xf3,0xe7,"MF_MEDIA_SHARING_ENGINE_DEVICE_NAME"); + IF_GUID_EQUAL_RETURN(guid,0x6f3497f5,0xd528,0x4a4f,0x8d,0xd7,0xdb,0x36,0x65,0x7e,0xc4,0xc9,"MF_MEDIA_SHARING_ENGINE_INITIAL_SEEK_TIME"); + IF_GUID_EQUAL_RETURN(guid,0xdb214084,0x58a4,0x4d2e,0xb8,0x4f,0x6f,0x75,0x5b,0x2f,0x7a,0xd,"MF_METADATA_PROVIDER_SERVICE"); + IF_GUID_EQUAL_RETURN(guid,0x2d1c070e,0x2b5f,0x4ab3,0xa7,0xe6,0x8d,0x94,0x3b,0xa8,0xd0,0x0a,"MF_MP2DLNA_AUDIO_BIT_RATE"); + IF_GUID_EQUAL_RETURN(guid,0xb52379d7,0x1d46,0x4fb6,0xa3,0x17,0xa4,0xa5,0xf6,0x09,0x59,0xf8,"MF_MP2DLNA_ENCODE_QUALITY"); + IF_GUID_EQUAL_RETURN(guid,0x75e488a3,0xd5ad,0x4898,0x85,0xe0,0xbc,0xce,0x24,0xa7,0x22,0xd7,"MF_MP2DLNA_STATISTICS"); + IF_GUID_EQUAL_RETURN(guid,0x54f3e2ee,0xa2a2,0x497d,0x98,0x34,0x97,0x3a,0xfd,0xe5,0x21,0xeb,"MF_MP2DLNA_USE_MMCSS"); + IF_GUID_EQUAL_RETURN(guid,0xe88548de,0x73b4,0x42d7,0x9c,0x75,0xad,0xfa,0xa,0x2a,0x6e,0x4c,"MF_MP2DLNA_VIDEO_BIT_RATE"); + IF_GUID_EQUAL_RETURN(guid,0xf672e3ac,0xe1e6,0x4f10,0xb5,0xec,0x5f,0x3b,0x30,0x82,0x88,0x16,"MF_MPEG4SINK_MOOV_BEFORE_MDAT"); + IF_GUID_EQUAL_RETURN(guid,0x5601a134,0x2005,0x4ad2,0xb3,0x7d,0x22,0xa6,0xc5,0x54,0xde,0xb2,"MF_MPEG4SINK_SPSPPS_PASSTHROUGH"); + IF_GUID_EQUAL_RETURN(guid,0x7632f0e6,0x9538,0x4d61,0xac,0xda,0xea,0x29,0xc8,0xc1,0x44,0x56,"MF_MT_AAC_AUDIO_PROFILE_LEVEL_INDICATION"); + IF_GUID_EQUAL_RETURN(guid,0xbfbabe79,0x7434,0x4d1c,0x94,0xf0,0x72,0xa3,0xb9,0xe1,0x71,0x88,"MF_MT_AAC_PAYLOAD_TYPE"); + IF_GUID_EQUAL_RETURN(guid,0xc9173739,0x5e56,0x461c,0xb7,0x13,0x46,0xfb,0x99,0x5c,0xb9,0x5f,"MF_MT_ALL_SAMPLES_INDEPENDENT"); + IF_GUID_EQUAL_RETURN(guid,0x73d1072d,0x1870,0x4174,0xa0,0x63,0x29,0xff,0x4f,0xf6,0xc1,0x1e,"MF_MT_AM_FORMAT_TYPE"); + IF_GUID_EQUAL_RETURN(guid,0x5a75b249,0xd7d,0x49a1,0xa1,0xc3,0xe0,0xd8,0x7f,0xc,0xad,0xe5,"MF_MT_ARBITRARY_FORMAT"); + IF_GUID_EQUAL_RETURN(guid,0x9e6bd6f5,0x109,0x4f95,0x84,0xac,0x93,0x9,0x15,0x3a,0x19,0xfc,"MF_MT_ARBITRARY_HEADER"); + IF_GUID_EQUAL_RETURN(guid,0x1aab75c8,0xcfef,0x451c,0xab,0x95,0xac,0x03,0x4b,0x8e,0x17,0x31,"MF_MT_AUDIO_AVG_BYTES_PER_SECOND"); + IF_GUID_EQUAL_RETURN(guid,0xf2deb57f,0x40fa,0x4764,0xaa,0x33,0xed,0x4f,0x2d,0x1f,0xf6,0x69,"MF_MT_AUDIO_BITS_PER_SAMPLE"); + IF_GUID_EQUAL_RETURN(guid,0x322de230,0x9eeb,0x43bd,0xab,0x7a,0xff,0x41,0x22,0x51,0x54,0x1d,"MF_MT_AUDIO_BLOCK_ALIGNMENT"); + IF_GUID_EQUAL_RETURN(guid,0x55fb5765,0x644a,0x4caf,0x84,0x79,0x93,0x89,0x83,0xbb,0x15,0x88,"MF_MT_AUDIO_CHANNEL_MASK"); + IF_GUID_EQUAL_RETURN(guid,0xfb3b724a,0xcfb5,0x4319,0xae,0xfe,0x6e,0x42,0xb2,0x40,0x61,0x32,"MF_MT_AUDIO_FLOAT_SAMPLES_PER_SECOND"); + IF_GUID_EQUAL_RETURN(guid,0x9d62927c,0x36be,0x4cf2,0xb5,0xc4,0xa3,0x92,0x6e,0x3e,0x87,0x11,"MF_MT_AUDIO_FOLDDOWN_MATRIX"); + IF_GUID_EQUAL_RETURN(guid,0x37e48bf5,0x645e,0x4c5b,0x89,0xde,0xad,0xa9,0xe2,0x9b,0x69,0x6a,"MF_MT_AUDIO_NUM_CHANNELS"); + IF_GUID_EQUAL_RETURN(guid,0xa901aaba,0xe037,0x458a,0xbd,0xf6,0x54,0x5b,0xe2,0x07,0x40,0x42,"MF_MT_AUDIO_PREFER_WAVEFORMATEX"); + IF_GUID_EQUAL_RETURN(guid,0xaab15aac,0xe13a,0x4995,0x92,0x22,0x50,0x1e,0xa1,0x5c,0x68,0x77,"MF_MT_AUDIO_SAMPLES_PER_BLOCK"); + IF_GUID_EQUAL_RETURN(guid,0x5faeeae7,0x0290,0x4c31,0x9e,0x8a,0xc5,0x34,0xf6,0x8d,0x9d,0xba,"MF_MT_AUDIO_SAMPLES_PER_SECOND"); + IF_GUID_EQUAL_RETURN(guid,0xd9bf8d6a,0x9530,0x4b7c,0x9d,0xdf,0xff,0x6f,0xd5,0x8b,0xbd,0x06,"MF_MT_AUDIO_VALID_BITS_PER_SAMPLE"); + IF_GUID_EQUAL_RETURN(guid,0x9d62927f,0x36be,0x4cf2,0xb5,0xc4,0xa3,0x92,0x6e,0x3e,0x87,0x11,"MF_MT_AUDIO_WMADRC_AVGREF"); + IF_GUID_EQUAL_RETURN(guid,0x9d629280,0x36be,0x4cf2,0xb5,0xc4,0xa3,0x92,0x6e,0x3e,0x87,0x11,"MF_MT_AUDIO_WMADRC_AVGTARGET"); + IF_GUID_EQUAL_RETURN(guid,0x9d62927d,0x36be,0x4cf2,0xb5,0xc4,0xa3,0x92,0x6e,0x3e,0x87,0x11,"MF_MT_AUDIO_WMADRC_PEAKREF"); + IF_GUID_EQUAL_RETURN(guid,0x9d62927e,0x36be,0x4cf2,0xb5,0xc4,0xa3,0x92,0x6e,0x3e,0x87,0x11,"MF_MT_AUDIO_WMADRC_PEAKTARGET"); + IF_GUID_EQUAL_RETURN(guid,0x20332624,0xfb0d,0x4d9e,0xbd,0x0d,0xcb,0xf6,0x78,0x6c,0x10,0x2e,"MF_MT_AVG_BITRATE"); + IF_GUID_EQUAL_RETURN(guid,0x799cabd6,0x3508,0x4db4,0xa3,0xc7,0x56,0x9c,0xd5,0x33,0xde,0xb1,"MF_MT_AVG_BIT_ERROR_RATE"); + IF_GUID_EQUAL_RETURN(guid,0x3afd0cee,0x18f2,0x4ba5,0xa1,0x10,0x8b,0xea,0x50,0x2e,0x1f,0x92,"MF_MT_COMPRESSED"); + IF_GUID_EQUAL_RETURN(guid,0x47537213,0x8cfb,0x4722,0xaa,0x34,0xfb,0xc9,0xe2,0x4d,0x77,0xb8,"MF_MT_CUSTOM_VIDEO_PRIMARIES"); + IF_GUID_EQUAL_RETURN(guid,0x644b4e48,0x1e02,0x4516,0xb0,0xeb,0xc0,0x1c,0xa9,0xd4,0x9a,0xc6,"MF_MT_DEFAULT_STRIDE"); + IF_GUID_EQUAL_RETURN(guid,0x8772f323,0x355a,0x4cc7,0xbb,0x78,0x6d,0x61,0xa0,0x48,0xae,0x82,"MF_MT_DRM_FLAGS"); + IF_GUID_EQUAL_RETURN(guid,0xf731004e,0x1dd1,0x4515,0xaa,0xbe,0xf0,0xc0,0x6a,0xa5,0x36,0xac,"MF_MT_DV_AAUX_CTRL_PACK_0"); + IF_GUID_EQUAL_RETURN(guid,0xcd1f470d,0x1f04,0x4fe0,0xbf,0xb9,0xd0,0x7a,0xe0,0x38,0x6a,0xd8,"MF_MT_DV_AAUX_CTRL_PACK_1"); + IF_GUID_EQUAL_RETURN(guid,0x84bd5d88,0x0fb8,0x4ac8,0xbe,0x4b,0xa8,0x84,0x8b,0xef,0x98,0xf3,"MF_MT_DV_AAUX_SRC_PACK_0"); + IF_GUID_EQUAL_RETURN(guid,0x720e6544,0x0225,0x4003,0xa6,0x51,0x01,0x96,0x56,0x3a,0x95,0x8e,"MF_MT_DV_AAUX_SRC_PACK_1"); + IF_GUID_EQUAL_RETURN(guid,0x2f84e1c4,0x0da1,0x4788,0x93,0x8e,0x0d,0xfb,0xfb,0xb3,0x4b,0x48,"MF_MT_DV_VAUX_CTRL_PACK"); + IF_GUID_EQUAL_RETURN(guid,0x41402d9d,0x7b57,0x43c6,0xb1,0x29,0x2c,0xb9,0x97,0xf1,0x50,0x09,"MF_MT_DV_VAUX_SRC_PACK"); + IF_GUID_EQUAL_RETURN(guid,0xb8ebefaf,0xb718,0x4e04,0xb0,0xa9,0x11,0x67,0x75,0xe3,0x32,0x1b,"MF_MT_FIXED_SIZE_SAMPLES"); + IF_GUID_EQUAL_RETURN(guid,0xc459a2e8,0x3d2c,0x4e44,0xb1,0x32,0xfe,0xe5,0x15,0x6c,0x7b,0xb0,"MF_MT_FRAME_RATE"); + IF_GUID_EQUAL_RETURN(guid,0xe3371d41,0xb4cf,0x4a05,0xbd,0x4e,0x20,0xb8,0x8b,0xb2,0xc4,0xd6,"MF_MT_FRAME_RATE_RANGE_MAX"); + IF_GUID_EQUAL_RETURN(guid,0xd2e7558c,0xdc1f,0x403f,0x9a,0x72,0xd2,0x8b,0xb1,0xeb,0x3b,0x5e,"MF_MT_FRAME_RATE_RANGE_MIN"); + IF_GUID_EQUAL_RETURN(guid,0x1652c33d,0xd6b2,0x4012,0xb8,0x34,0x72,0x03,0x08,0x49,0xa3,0x7d,"MF_MT_FRAME_SIZE"); + IF_GUID_EQUAL_RETURN(guid,0x66758743,0x7e5f,0x400d,0x98,0x0a,0xaa,0x85,0x96,0xc8,0x56,0x96,"MF_MT_GEOMETRIC_APERTURE"); + IF_GUID_EQUAL_RETURN(guid,0xbb3bd508,0x490a,0x11e0,0x99,0xe4,0x13,0x16,0xdf,0xd7,0x20,0x85,"MF_MT_H264_CAPABILITIES"); + IF_GUID_EQUAL_RETURN(guid,0x85e299b2,0x90e3,0x4fe8,0xb2,0xf5,0xc0,0x67,0xe0,0xbf,0xe5,0x7a,"MF_MT_H264_LAYOUT_PER_STREAM"); + IF_GUID_EQUAL_RETURN(guid,0xf5929986,0x4c45,0x4fbb,0xbb,0x49,0x6c,0xc5,0x34,0xd0,0x5b,0x9b,"MF_MT_H264_MAX_CODEC_CONFIG_DELAY"); + IF_GUID_EQUAL_RETURN(guid,0x45256d30,0x7215,0x4576,0x93,0x36,0xb0,0xf1,0xbc,0xd5,0x9b,0xb2,"MF_MT_H264_MAX_MB_PER_SEC"); + IF_GUID_EQUAL_RETURN(guid,0x705177d8,0x45cb,0x11e0,0xac,0x7d,0xb9,0x1c,0xe0,0xd7,0x20,0x85,"MF_MT_H264_RATE_CONTROL_MODES"); + IF_GUID_EQUAL_RETURN(guid,0xe3854272,0xf715,0x4757,0xba,0x90,0x1b,0x69,0x6c,0x77,0x34,0x57,"MF_MT_H264_RESOLUTION_SCALING"); + IF_GUID_EQUAL_RETURN(guid,0x9ea2d63d,0x53f0,0x4a34,0xb9,0x4e,0x9d,0xe4,0x9a,0x7,0x8c,0xb3,"MF_MT_H264_SIMULCAST_SUPPORT"); + IF_GUID_EQUAL_RETURN(guid,0x6a8ac47e,0x519c,0x4f18,0x9b,0xb3,0x7e,0xea,0xae,0xa5,0x59,0x4d,"MF_MT_H264_SUPPORTED_RATE_CONTROL_MODES"); + IF_GUID_EQUAL_RETURN(guid,0xc8be1937,0x4d64,0x4549,0x83,0x43,0xa8,0x8,0x6c,0xb,0xfd,0xa5,"MF_MT_H264_SUPPORTED_SLICE_MODES"); + IF_GUID_EQUAL_RETURN(guid,0x89a52c01,0xf282,0x48d2,0xb5,0x22,0x22,0xe6,0xae,0x63,0x31,0x99,"MF_MT_H264_SUPPORTED_SYNC_FRAME_TYPES"); + IF_GUID_EQUAL_RETURN(guid,0x60b1a998,0xdc01,0x40ce,0x97,0x36,0xab,0xa8,0x45,0xa2,0xdb,0xdc,"MF_MT_H264_SUPPORTED_USAGES"); + IF_GUID_EQUAL_RETURN(guid,0xf8993abe,0xd937,0x4a8f,0xbb,0xca,0x69,0x66,0xfe,0x9e,0x11,0x52,"MF_MT_H264_SVC_CAPABILITIES"); + IF_GUID_EQUAL_RETURN(guid,0x359ce3a5,0xaf00,0x49ca,0xa2,0xf4,0x2a,0xc9,0x4c,0xa8,0x2b,0x61,"MF_MT_H264_USAGE"); + IF_GUID_EQUAL_RETURN(guid,0xed062cf4,0xe34e,0x4922,0xbe,0x99,0x93,0x40,0x32,0x13,0x3d,0x7c,"MF_MT_IMAGE_LOSS_TOLERANT"); + IF_GUID_EQUAL_RETURN(guid,0xe2724bb8,0xe676,0x4806,0xb4,0xb2,0xa8,0xd6,0xef,0xb4,0x4c,0xcd,"MF_MT_INTERLACE_MODE"); + IF_GUID_EQUAL_RETURN(guid,0x48eba18e,0xf8c9,0x4687,0xbf,0x11,0x0a,0x74,0xc9,0xf9,0x6a,0x8f,"MF_MT_MAJOR_TYPE"); + IF_GUID_EQUAL_RETURN(guid,0xc16eb52b,0x73a1,0x476f,0x8d,0x62,0x83,0x9d,0x6a,0x02,0x06,0x52,"MF_MT_MAX_KEYFRAME_SPACING"); + IF_GUID_EQUAL_RETURN(guid,0xd7388766,0x18fe,0x48c6,0xa1,0x77,0xee,0x89,0x48,0x67,0xc8,0xc4,"MF_MT_MINIMUM_DISPLAY_APERTURE"); + IF_GUID_EQUAL_RETURN(guid,0x825d55e4,0x4f12,0x4197,0x9e,0xb3,0x59,0xb6,0xe4,0x71,0xf,0x6,"MF_MT_MPEG2_CONTENT_PACKET"); + IF_GUID_EQUAL_RETURN(guid,0x31e3991d,0xf701,0x4b2f,0xb4,0x26,0x8a,0xe3,0xbd,0xa9,0xe0,0x4b,"MF_MT_MPEG2_FLAGS"); + IF_GUID_EQUAL_RETURN(guid,0x96f66574,0x11c5,0x4015,0x86,0x66,0xbf,0xf5,0x16,0x43,0x6d,0xa7,"MF_MT_MPEG2_LEVEL"); + IF_GUID_EQUAL_RETURN(guid,0xad76a80b,0x2d5c,0x4e0b,0xb3,0x75,0x64,0xe5,0x20,0x13,0x70,0x36,"MF_MT_MPEG2_PROFILE"); + IF_GUID_EQUAL_RETURN(guid,0xa20af9e8,0x928a,0x4b26,0xaa,0xa9,0xf0,0x5c,0x74,0xca,0xc4,0x7c,"MF_MT_MPEG2_STANDARD"); + IF_GUID_EQUAL_RETURN(guid,0x5229ba10,0xe29d,0x4f80,0xa5,0x9c,0xdf,0x4f,0x18,0x2,0x7,0xd2,"MF_MT_MPEG2_TIMECODE"); + IF_GUID_EQUAL_RETURN(guid,0x9aa7e155,0xb64a,0x4c1d,0xa5,0x00,0x45,0x5d,0x60,0x0b,0x65,0x60,"MF_MT_MPEG4_CURRENT_SAMPLE_ENTRY"); + IF_GUID_EQUAL_RETURN(guid,0x261e9d83,0x9529,0x4b8f,0xa1,0x11,0x8b,0x9c,0x95,0x0a,0x81,0xa9,"MF_MT_MPEG4_SAMPLE_DESCRIPTION"); + IF_GUID_EQUAL_RETURN(guid,0x3c036de7,0x3ad0,0x4c9e,0x92,0x16,0xee,0x6d,0x6a,0xc2,0x1c,0xb3,"MF_MT_MPEG_SEQUENCE_HEADER"); + IF_GUID_EQUAL_RETURN(guid,0x91f67885,0x4333,0x4280,0x97,0xcd,0xbd,0x5a,0x6c,0x03,0xa0,0x6e,"MF_MT_MPEG_START_TIME_CODE"); + IF_GUID_EQUAL_RETURN(guid,0xd7be3fe0,0x2bc7,0x492d,0xb8,0x43,0x61,0xa1,0x91,0x9b,0x70,0xc3,"MF_MT_ORIGINAL_4CC"); + IF_GUID_EQUAL_RETURN(guid,0x8cbbc843,0x9fd9,0x49c2,0x88,0x2f,0xa7,0x25,0x86,0xc4,0x08,0xad,"MF_MT_ORIGINAL_WAVE_FORMAT_TAG"); + IF_GUID_EQUAL_RETURN(guid,0x4d0e73e5,0x80ea,0x4354,0xa9,0xd0,0x11,0x76,0xce,0xb0,0x28,0xea,"MF_MT_PAD_CONTROL_FLAGS"); + IF_GUID_EQUAL_RETURN(guid,0x6d283f42,0x9846,0x4410,0xaf,0xd9,0x65,0x4d,0x50,0x3b,0x1a,0x54,"MF_MT_PALETTE"); + IF_GUID_EQUAL_RETURN(guid,0x79614dde,0x9187,0x48fb,0xb8,0xc7,0x4d,0x52,0x68,0x9d,0xe6,0x49,"MF_MT_PAN_SCAN_APERTURE"); + IF_GUID_EQUAL_RETURN(guid,0x4b7f6bc3,0x8b13,0x40b2,0xa9,0x93,0xab,0xf6,0x30,0xb8,0x20,0x4e,"MF_MT_PAN_SCAN_ENABLED"); + IF_GUID_EQUAL_RETURN(guid,0xc6376a1e,0x8d0a,0x4027,0xbe,0x45,0x6d,0x9a,0x0a,0xd3,0x9b,0xb6,"MF_MT_PIXEL_ASPECT_RATIO"); + IF_GUID_EQUAL_RETURN(guid,0xdad3ab78,0x1990,0x408b,0xbc,0xe2,0xeb,0xa6,0x73,0xda,0xcc,0x10,"MF_MT_SAMPLE_SIZE"); + IF_GUID_EQUAL_RETURN(guid,0x68aca3cc,0x22d0,0x44e6,0x85,0xf8,0x28,0x16,0x71,0x97,0xfa,0x38,"MF_MT_SOURCE_CONTENT_HINT"); + IF_GUID_EQUAL_RETURN(guid,0xf7e34c9a,0x42e8,0x4714,0xb7,0x4b,0xcb,0x29,0xd7,0x2c,0x35,0xe5,"MF_MT_SUBTYPE"); + IF_GUID_EQUAL_RETURN(guid,0x24974215,0x1b7b,0x41e4,0x86,0x25,0xac,0x46,0x9f,0x2d,0xed,0xaa,"MF_MT_TIMESTAMP_CAN_BE_DTS"); + IF_GUID_EQUAL_RETURN(guid,0x5fb0fce9,0xbe5c,0x4935,0xa8,0x11,0xec,0x83,0x8f,0x8e,0xed,0x93,"MF_MT_TRANSFER_FUNCTION"); + IF_GUID_EQUAL_RETURN(guid,0xb6bc765f,0x4c3b,0x40a4,0xbd,0x51,0x25,0x35,0xb6,0x6f,0xe0,0x9d,"MF_MT_USER_DATA"); + IF_GUID_EQUAL_RETURN(guid,0xcb5e88cf,0x7b5b,0x476b,0x85,0xaa,0x1c,0xa5,0xae,0x18,0x75,0x55,"MF_MT_VIDEO_3D"); + IF_GUID_EQUAL_RETURN(guid,0xec298493,0xada,0x4ea1,0xa4,0xfe,0xcb,0xbd,0x36,0xce,0x93,0x31,"MF_MT_VIDEO_3D_FIRST_IS_LEFT"); + IF_GUID_EQUAL_RETURN(guid,0x5315d8a0,0x87c5,0x4697,0xb7,0x93,0x66,0x6,0xc6,0x7c,0x4,0x9b,"MF_MT_VIDEO_3D_FORMAT"); + IF_GUID_EQUAL_RETURN(guid,0x6d4b7bff,0x5629,0x4404,0x94,0x8c,0xc6,0x34,0xf4,0xce,0x26,0xd4,"MF_MT_VIDEO_3D_LEFT_IS_BASE"); + IF_GUID_EQUAL_RETURN(guid,0xbb077e8a,0xdcbf,0x42eb,0xaf,0x60,0x41,0x8d,0xf9,0x8a,0xa4,0x95,"MF_MT_VIDEO_3D_NUM_VIEWS"); + IF_GUID_EQUAL_RETURN(guid,0x65df2370,0xc773,0x4c33,0xaa,0x64,0x84,0x3e,0x06,0x8e,0xfb,0x0c,"MF_MT_VIDEO_CHROMA_SITING"); + IF_GUID_EQUAL_RETURN(guid,0x53a0529c,0x890b,0x4216,0x8b,0xf9,0x59,0x93,0x67,0xad,0x6d,0x20,"MF_MT_VIDEO_LIGHTING"); + IF_GUID_EQUAL_RETURN(guid,0xc21b8ee5,0xb956,0x4071,0x8d,0xaf,0x32,0x5e,0xdf,0x5c,0xab,0x11,"MF_MT_VIDEO_NOMINAL_RANGE"); + IF_GUID_EQUAL_RETURN(guid,0xdbfbe4d7,0x0740,0x4ee0,0x81,0x92,0x85,0x0a,0xb0,0xe2,0x19,0x35,"MF_MT_VIDEO_PRIMARIES"); + IF_GUID_EQUAL_RETURN(guid,0xc380465d,0x2271,0x428c,0x9b,0x83,0xec,0xea,0x3b,0x4a,0x85,0xc1,"MF_MT_VIDEO_ROTATION"); + IF_GUID_EQUAL_RETURN(guid,0x4d3f7b23,0xd02f,0x4e6c,0x9b,0xee,0xe4,0xbf,0x2c,0x6c,0x69,0x5d,"MF_MT_WRAPPED_TYPE"); + IF_GUID_EQUAL_RETURN(guid,0x3e23d450,0x2c75,0x4d25,0xa0,0x0e,0xb9,0x16,0x70,0xd1,0x23,0x27,"MF_MT_YUV_MATRIX"); + IF_GUID_EQUAL_RETURN(guid,0x19124E7C,0xAD4B,0x465F,0xBB,0x18,0x20,0x18,0x62,0x87,0xB6,0xAF,"MF_NALU_LENGTH_INFORMATION"); + IF_GUID_EQUAL_RETURN(guid,0xA7911D53,0x12A4,0x4965,0xAE,0x70,0x6E,0xAD,0xD6,0xFF,0x05,0x51,"MF_NALU_LENGTH_SET"); + IF_GUID_EQUAL_RETURN(guid,0x6c990d32,0xbb8e,0x477a,0x85,0x98,0xd,0x5d,0x96,0xfc,0xd8,0x8a,"MF_PD_APP_CONTEXT"); + IF_GUID_EQUAL_RETURN(guid,0xe4bb3509,0xc18d,0x4df1,0xbb,0x99,0x7a,0x36,0xb3,0xcc,0x41,0x19,"MF_PD_ASF_CODECLIST"); + IF_GUID_EQUAL_RETURN(guid,0x62508be5,0xecdf,0x4924,0xa3,0x59,0x72,0xba,0xb3,0x39,0x7b,0x9d,"MF_PD_ASF_CONTENTENCRYPTIONEX_ENCRYPTION_DATA"); + IF_GUID_EQUAL_RETURN(guid,0x8520fe3e,0x277e,0x46ea,0x99,0xe4,0xe3,0xa,0x86,0xdb,0x12,0xbe,"MF_PD_ASF_CONTENTENCRYPTION_KEYID"); + IF_GUID_EQUAL_RETURN(guid,0x8520fe40,0x277e,0x46ea,0x99,0xe4,0xe3,0xa,0x86,0xdb,0x12,0xbe,"MF_PD_ASF_CONTENTENCRYPTION_LICENSE_URL"); + IF_GUID_EQUAL_RETURN(guid,0x8520fe3f,0x277e,0x46ea,0x99,0xe4,0xe3,0xa,0x86,0xdb,0x12,0xbe,"MF_PD_ASF_CONTENTENCRYPTION_SECRET_DATA"); + IF_GUID_EQUAL_RETURN(guid,0x8520fe3d,0x277e,0x46ea,0x99,0xe4,0xe3,0xa,0x86,0xdb,0x12,0xbe,"MF_PD_ASF_CONTENTENCRYPTION_TYPE"); + IF_GUID_EQUAL_RETURN(guid,0xe7d5b3e8,0x1f29,0x45d3,0x88,0x22,0x3e,0x78,0xfa,0xe2,0x72,0xed,"MF_PD_ASF_DATA_LENGTH"); + IF_GUID_EQUAL_RETURN(guid,0xe7d5b3e7,0x1f29,0x45d3,0x88,0x22,0x3e,0x78,0xfa,0xe2,0x72,0xed,"MF_PD_ASF_DATA_START_OFFSET"); + IF_GUID_EQUAL_RETURN(guid,0x3de649b6,0xd76d,0x4e66,0x9e,0xc9,0x78,0x12,0xf,0xb4,0xc7,0xe3,"MF_PD_ASF_FILEPROPERTIES_CREATION_TIME"); + IF_GUID_EQUAL_RETURN(guid,0x3de649b4,0xd76d,0x4e66,0x9e,0xc9,0x78,0x12,0xf,0xb4,0xc7,0xe3,"MF_PD_ASF_FILEPROPERTIES_FILE_ID"); + IF_GUID_EQUAL_RETURN(guid,0x3de649bb,0xd76d,0x4e66,0x9e,0xc9,0x78,0x12,0xf,0xb4,0xc7,0xe3,"MF_PD_ASF_FILEPROPERTIES_FLAGS"); + IF_GUID_EQUAL_RETURN(guid,0x3de649be,0xd76d,0x4e66,0x9e,0xc9,0x78,0x12,0xf,0xb4,0xc7,0xe3,"MF_PD_ASF_FILEPROPERTIES_MAX_BITRATE"); + IF_GUID_EQUAL_RETURN(guid,0x3de649bd,0xd76d,0x4e66,0x9e,0xc9,0x78,0x12,0xf,0xb4,0xc7,0xe3,"MF_PD_ASF_FILEPROPERTIES_MAX_PACKET_SIZE"); + IF_GUID_EQUAL_RETURN(guid,0x3de649bc,0xd76d,0x4e66,0x9e,0xc9,0x78,0x12,0xf,0xb4,0xc7,0xe3,"MF_PD_ASF_FILEPROPERTIES_MIN_PACKET_SIZE"); + IF_GUID_EQUAL_RETURN(guid,0x3de649b7,0xd76d,0x4e66,0x9e,0xc9,0x78,0x12,0xf,0xb4,0xc7,0xe3,"MF_PD_ASF_FILEPROPERTIES_PACKETS"); + IF_GUID_EQUAL_RETURN(guid,0x3de649b8,0xd76d,0x4e66,0x9e,0xc9,0x78,0x12,0xf,0xb4,0xc7,0xe3,"MF_PD_ASF_FILEPROPERTIES_PLAY_DURATION"); + IF_GUID_EQUAL_RETURN(guid,0x3de649ba,0xd76d,0x4e66,0x9e,0xc9,0x78,0x12,0xf,0xb4,0xc7,0xe3,"MF_PD_ASF_FILEPROPERTIES_PREROLL"); + IF_GUID_EQUAL_RETURN(guid,0x3de649b9,0xd76d,0x4e66,0x9e,0xc9,0x78,0x12,0xf,0xb4,0xc7,0xe3,"MF_PD_ASF_FILEPROPERTIES_SEND_DURATION"); + IF_GUID_EQUAL_RETURN(guid,0x80e62295,0x2296,0x4a44,0xb3,0x1c,0xd1,0x3,0xc6,0xfe,0xd2,0x3c,"MF_PD_ASF_INFO_HAS_AUDIO"); + IF_GUID_EQUAL_RETURN(guid,0x80e62297,0x2296,0x4a44,0xb3,0x1c,0xd1,0x3,0xc6,0xfe,0xd2,0x3c,"MF_PD_ASF_INFO_HAS_NON_AUDIO_VIDEO"); + IF_GUID_EQUAL_RETURN(guid,0x80e62296,0x2296,0x4a44,0xb3,0x1c,0xd1,0x3,0xc6,0xfe,0xd2,0x3c,"MF_PD_ASF_INFO_HAS_VIDEO"); + IF_GUID_EQUAL_RETURN(guid,0xf23de43c,0x9977,0x460d,0xa6,0xec,0x32,0x93,0x7f,0x16,0xf,0x7d,"MF_PD_ASF_LANGLIST"); + IF_GUID_EQUAL_RETURN(guid,0xf23de43d,0x9977,0x460d,0xa6,0xec,0x32,0x93,0x7f,0x16,0xf,0x7d,"MF_PD_ASF_LANGLIST_LEGACYORDER"); + IF_GUID_EQUAL_RETURN(guid,0x5134330e,0x83a6,0x475e,0xa9,0xd5,0x4f,0xb8,0x75,0xfb,0x2e,0x31,"MF_PD_ASF_MARKER"); + IF_GUID_EQUAL_RETURN(guid,0x5fc6947a,0xef60,0x445d,0xb4,0x49,0x44,0x2e,0xcc,0x78,0xb4,0xc1,"MF_PD_ASF_METADATA_IS_VBR"); + IF_GUID_EQUAL_RETURN(guid,0x5fc6947d,0xef60,0x445d,0xb4,0x49,0x44,0x2e,0xcc,0x78,0xb4,0xc1,"MF_PD_ASF_METADATA_LEAKY_BUCKET_PAIRS"); + IF_GUID_EQUAL_RETURN(guid,0x5fc6947c,0xef60,0x445d,0xb4,0x49,0x44,0x2e,0xcc,0x78,0xb4,0xc1,"MF_PD_ASF_METADATA_V8_BUFFERAVERAGE"); + IF_GUID_EQUAL_RETURN(guid,0x5fc6947b,0xef60,0x445d,0xb4,0x49,0x44,0x2e,0xcc,0x78,0xb4,0xc1,"MF_PD_ASF_METADATA_V8_VBRPEAK"); + IF_GUID_EQUAL_RETURN(guid,0xe29cd0d7,0xd602,0x4923,0xa7,0xfe,0x73,0xfd,0x97,0xec,0xc6,0x50,"MF_PD_ASF_SCRIPT"); + IF_GUID_EQUAL_RETURN(guid,0x6c990d35,0xbb8e,0x477a,0x85,0x98,0xd,0x5d,0x96,0xfc,0xd8,0x8a,"MF_PD_AUDIO_ENCODING_BITRATE"); + IF_GUID_EQUAL_RETURN(guid,0x33026ee0,0xe387,0x4582,0xae,0x0a,0x34,0xa2,0xad,0x3b,0xaa,0x18,"MF_PD_AUDIO_ISVARIABLEBITRATE"); + IF_GUID_EQUAL_RETURN(guid,0x6c990d33,0xbb8e,0x477a,0x85,0x98,0xd,0x5d,0x96,0xfc,0xd8,0x8a,"MF_PD_DURATION"); + IF_GUID_EQUAL_RETURN(guid,0x6c990d38,0xbb8e,0x477a,0x85,0x98,0xd,0x5d,0x96,0xfc,0xd8,0x8a,"MF_PD_LAST_MODIFIED_TIME"); + IF_GUID_EQUAL_RETURN(guid,0x6c990d37,0xbb8e,0x477a,0x85,0x98,0xd,0x5d,0x96,0xfc,0xd8,0x8a,"MF_PD_MIME_TYPE"); + IF_GUID_EQUAL_RETURN(guid,0x6c990d3b,0xbb8e,0x477a,0x85,0x98,0xd,0x5d,0x96,0xfc,0xd8,0x8a,"MF_PD_PLAYBACK_BOUNDARY_TIME"); + IF_GUID_EQUAL_RETURN(guid,0x6c990d39,0xbb8e,0x477a,0x85,0x98,0xd,0x5d,0x96,0xfc,0xd8,0x8a,"MF_PD_PLAYBACK_ELEMENT_ID"); + IF_GUID_EQUAL_RETURN(guid,0x6c990d31,0xbb8e,0x477a,0x85,0x98,0xd,0x5d,0x96,0xfc,0xd8,0x8a,"MF_PD_PMPHOST_CONTEXT"); + IF_GUID_EQUAL_RETURN(guid,0x6c990d3A,0xbb8e,0x477a,0x85,0x98,0xd,0x5d,0x96,0xfc,0xd8,0x8a,"MF_PD_PREFERRED_LANGUAGE"); + IF_GUID_EQUAL_RETURN(guid,0xe0b73c7f,0x486d,0x484e,0x98,0x72,0x4d,0xe5,0x19,0x2a,0x7b,0xf8,"MF_PD_SAMI_STYLELIST"); + IF_GUID_EQUAL_RETURN(guid,0x6c990d34,0xbb8e,0x477a,0x85,0x98,0xd,0x5d,0x96,0xfc,0xd8,0x8a,"MF_PD_TOTAL_FILE_SIZE"); + IF_GUID_EQUAL_RETURN(guid,0x6c990d36,0xbb8e,0x477a,0x85,0x98,0xd,0x5d,0x96,0xfc,0xd8,0x8a,"MF_PD_VIDEO_ENCODING_BITRATE"); + IF_GUID_EQUAL_RETURN(guid,0x2f00c910,0xd2cf,0x4278,0x8b,0x6a,0xd0,0x77,0xfa,0xc3,0xa2,0x5f,"MF_PMP_SERVER_CONTEXT"); + IF_GUID_EQUAL_RETURN(guid,0x8F020EEA,0x1508,0x471F,0x9D,0xA6,0x50,0x7D,0x7C,0xFA,0x40,0xDB,"MF_PROGRESSIVE_CODING_CONTENT"); + IF_GUID_EQUAL_RETURN(guid,0xa3face02,0x32b8,0x41dd,0x90,0xe7,0x5f,0xef,0x7c,0x89,0x91,0xb5,"MF_PROPERTY_HANDLER_SERVICE"); + IF_GUID_EQUAL_RETURN(guid,0xf6b44af8,0x604d,0x46fe,0xa9,0x5d,0x45,0x47,0x9b,0x10,0xc9,0xbc,"MF_QUALITY_NOTIFY_PROCESSING_LATENCY"); + IF_GUID_EQUAL_RETURN(guid,0x30d15206,0xed2a,0x4760,0xbe,0x17,0xeb,0x4a,0x9f,0x12,0x29,0x5c,"MF_QUALITY_NOTIFY_SAMPLE_LAG"); + IF_GUID_EQUAL_RETURN(guid,0xb7e2be11,0x2f96,0x4640,0xb5,0x2c,0x28,0x23,0x65,0xbd,0xf1,0x6c,"MF_QUALITY_SERVICES"); + IF_GUID_EQUAL_RETURN(guid,0x866fa297,0xb802,0x4bf8,0x9d,0xc9,0x5e,0x3b,0x6a,0x9f,0x53,0xc9,"MF_RATE_CONTROL_SERVICE"); + IF_GUID_EQUAL_RETURN(guid,0x216479d9,0x3071,0x42ca,0xbb,0x6c,0x4c,0x22,0x10,0x2e,0x1d,0x18,"MF_READWRITE_D3D_OPTIONAL"); + IF_GUID_EQUAL_RETURN(guid,0x98d5b065,0x1374,0x4847,0x8d,0x5d,0x31,0x52,0x0f,0xee,0x71,0x56,"MF_READWRITE_DISABLE_CONVERTERS"); + IF_GUID_EQUAL_RETURN(guid,0xa634a91c,0x822b,0x41b9,0xa4,0x94,0x4d,0xe4,0x64,0x36,0x12,0xb0,"MF_READWRITE_ENABLE_HARDWARE_TRANSFORMS"); + IF_GUID_EQUAL_RETURN(guid,0x39384300,0xd0eb,0x40b1,0x87,0xa0,0x33,0x18,0x87,0x1b,0x5a,0x53,"MF_READWRITE_MMCSS_CLASS"); + IF_GUID_EQUAL_RETURN(guid,0x430847da,0x0890,0x4b0e,0x93,0x8c,0x05,0x43,0x32,0xc5,0x47,0xe1,"MF_READWRITE_MMCSS_CLASS_AUDIO"); + IF_GUID_EQUAL_RETURN(guid,0x43ad19ce,0xf33f,0x4ba9,0xa5,0x80,0xe4,0xcd,0x12,0xf2,0xd1,0x44,"MF_READWRITE_MMCSS_PRIORITY"); + IF_GUID_EQUAL_RETURN(guid,0x273db885,0x2de2,0x4db2,0xa6,0xa7,0xfd,0xb6,0x6f,0xb4,0x0b,0x61,"MF_READWRITE_MMCSS_PRIORITY_AUDIO"); + IF_GUID_EQUAL_RETURN(guid,0x2f00c90e,0xd2cf,0x4278,0x8b,0x6a,0xd0,0x77,0xfa,0xc3,0xa2,0x5f,"MF_REMOTE_PROXY"); + IF_GUID_EQUAL_RETURN(guid,0x49a89ae7,0xb4d9,0x4ef2,0xaa,0x5c,0xf6,0x5a,0x3e,0x5,0xae,0x4e,"MF_SAMI_SERVICE"); + IF_GUID_EQUAL_RETURN(guid,0x0efda2c0,0x2b69,0x4e2e,0xab,0x8d,0x46,0xdc,0xbf,0xf7,0xd2,0x5d,"MF_SAMPLEGRABBERSINK_IGNORE_CLOCK"); + IF_GUID_EQUAL_RETURN(guid,0x62e3d776,0x8100,0x4e03,0xa6,0xe8,0xbd,0x38,0x57,0xac,0x9c,0x47,"MF_SAMPLEGRABBERSINK_SAMPLE_TIME_OFFSET"); + IF_GUID_EQUAL_RETURN(guid,0x873c5171,0x1e3d,0x4e25,0x98,0x8d,0xb4,0x33,0xce,0x04,0x19,0x83,"MF_SA_BUFFERS_PER_SAMPLE"); + IF_GUID_EQUAL_RETURN(guid,0x206b4fc8,0xfcf9,0x4c51,0xaf,0xe3,0x97,0x64,0x36,0x9e,0x33,0xa0,"MF_SA_D3D11_AWARE"); + IF_GUID_EQUAL_RETURN(guid,0xeacf97ad,0x065c,0x4408,0xbe,0xe3,0xfd,0xcb,0xfd,0x12,0x8b,0xe2,"MF_SA_D3D11_BINDFLAGS"); + IF_GUID_EQUAL_RETURN(guid,0x7b8f32c3,0x6d96,0x4b89,0x92,0x3,0xdd,0x38,0xb6,0x14,0x14,0xf3,"MF_SA_D3D11_SHARED"); + IF_GUID_EQUAL_RETURN(guid,0x39dbd44d,0x2e44,0x4931,0xa4,0xc8,0x35,0x2d,0x3d,0xc4,0x21,0x15,"MF_SA_D3D11_SHARED_WITHOUT_MUTEX"); + IF_GUID_EQUAL_RETURN(guid,0xe85fe442,0x2ca3,0x486e,0xa9,0xc7,0x10,0x9d,0xda,0x60,0x98,0x80,"MF_SA_D3D11_USAGE"); + IF_GUID_EQUAL_RETURN(guid,0xeaa35c29,0x775e,0x488e,0x9b,0x61,0xb3,0x28,0x3e,0x49,0x58,0x3b,"MF_SA_D3D_AWARE"); + IF_GUID_EQUAL_RETURN(guid,0x851745d5,0xc3d6,0x476d,0x95,0x27,0x49,0x8e,0xf2,0xd1,0xd,0x18,"MF_SA_MINIMUM_OUTPUT_SAMPLE_COUNT"); + IF_GUID_EQUAL_RETURN(guid,0xf5523a5,0x1cb2,0x47c5,0xa5,0x50,0x2e,0xeb,0x84,0xb4,0xd1,0x4a,"MF_SA_MINIMUM_OUTPUT_SAMPLE_COUNT_PROGRESSIVE"); + IF_GUID_EQUAL_RETURN(guid,0x18802c61,0x324b,0x4952,0xab,0xd0,0x17,0x6f,0xf5,0xc6,0x96,0xff,"MF_SA_REQUIRED_SAMPLE_COUNT"); + IF_GUID_EQUAL_RETURN(guid,0xb172d58e,0xfa77,0x4e48,0x8d,0x2a,0x1d,0xf2,0xd8,0x50,0xea,0xc2,"MF_SA_REQUIRED_SAMPLE_COUNT_PROGRESSIVE"); + IF_GUID_EQUAL_RETURN(guid,0x48f8a524,0x305d,0x422d,0x85,0x24,0x25,0x2,0xdd,0xa3,0x36,0x80,"MF_SD_ASF_EXTSTRMPROP_AVG_BUFFERSIZE"); + IF_GUID_EQUAL_RETURN(guid,0x48f8a523,0x305d,0x422d,0x85,0x24,0x25,0x2,0xdd,0xa3,0x36,0x80,"MF_SD_ASF_EXTSTRMPROP_AVG_DATA_BITRATE"); + IF_GUID_EQUAL_RETURN(guid,0x48f8a522,0x305d,0x422d,0x85,0x24,0x25,0x2,0xdd,0xa3,0x36,0x80,"MF_SD_ASF_EXTSTRMPROP_LANGUAGE_ID_INDEX"); + IF_GUID_EQUAL_RETURN(guid,0x48f8a526,0x305d,0x422d,0x85,0x24,0x25,0x2,0xdd,0xa3,0x36,0x80,"MF_SD_ASF_EXTSTRMPROP_MAX_BUFFERSIZE"); + IF_GUID_EQUAL_RETURN(guid,0x48f8a525,0x305d,0x422d,0x85,0x24,0x25,0x2,0xdd,0xa3,0x36,0x80,"MF_SD_ASF_EXTSTRMPROP_MAX_DATA_BITRATE"); + IF_GUID_EQUAL_RETURN(guid,0x245e929d,0xc44e,0x4f7e,0xbb,0x3c,0x77,0xd4,0xdf,0xd2,0x7f,0x8a,"MF_SD_ASF_METADATA_DEVICE_CONFORMANCE_TEMPLATE"); + IF_GUID_EQUAL_RETURN(guid,0xa8e182ed,0xafc8,0x43d0,0xb0,0xd1,0xf6,0x5b,0xad,0x9d,0xa5,0x58,"MF_SD_ASF_STREAMBITRATES_BITRATE"); + IF_GUID_EQUAL_RETURN(guid,0xaf2180,0xbdc2,0x423c,0xab,0xca,0xf5,0x3,0x59,0x3b,0xc1,0x21,"MF_SD_LANGUAGE"); + IF_GUID_EQUAL_RETURN(guid,0x23ef79c,0x388d,0x487f,0xac,0x17,0x69,0x6c,0xd6,0xe3,0xc6,0xf5,"MF_SD_MUTUALLY_EXCLUSIVE"); + IF_GUID_EQUAL_RETURN(guid,0xaf2181,0xbdc2,0x423c,0xab,0xca,0xf5,0x3,0x59,0x3b,0xc1,0x21,"MF_SD_PROTECTED"); + IF_GUID_EQUAL_RETURN(guid,0x36fcb98a,0x6cd0,0x44cb,0xac,0xb9,0xa8,0xf5,0x60,0xd,0xd0,0xbb,"MF_SD_SAMI_LANGUAGE"); + IF_GUID_EQUAL_RETURN(guid,0x4f1b099d,0xd314,0x41e5,0xa7,0x81,0x7f,0xef,0xaa,0x4c,0x50,0x1f,"MF_SD_STREAM_NAME"); + IF_GUID_EQUAL_RETURN(guid,0x190e852f,0x6238,0x42d1,0xb5,0xaf,0x69,0xea,0x33,0x8e,0xf8,0x50,"MF_SESSION_APPROX_EVENT_OCCURRENCE_TIME"); + IF_GUID_EQUAL_RETURN(guid,0x1e83d482,0x1f1c,0x4571,0x84,0x5,0x88,0xf4,0xb2,0x18,0x1f,0x74,"MF_SESSION_CONTENT_PROTECTION_MANAGER"); + IF_GUID_EQUAL_RETURN(guid,0x1e83d482,0x1f1c,0x4571,0x84,0x5,0x88,0xf4,0xb2,0x18,0x1f,0x72,"MF_SESSION_GLOBAL_TIME"); + IF_GUID_EQUAL_RETURN(guid,0x1e83d482,0x1f1c,0x4571,0x84,0x5,0x88,0xf4,0xb2,0x18,0x1f,0x73,"MF_SESSION_QUALITY_MANAGER"); + IF_GUID_EQUAL_RETURN(guid,0xf4033ef4,0x9bb3,0x4378,0x94,0x1f,0x85,0xa0,0x85,0x6b,0xc2,0x44,"MF_SESSION_REMOTE_SOURCE_MODE"); + IF_GUID_EQUAL_RETURN(guid,0xafe5b291,0x50fa,0x46e8,0xb9,0xbe,0xc,0xc,0x3c,0xe4,0xb3,0xa5,"MF_SESSION_SERVER_CONTEXT"); + IF_GUID_EQUAL_RETURN(guid,0x1e83d482,0x1f1c,0x4571,0x84,0x5,0x88,0xf4,0xb2,0x18,0x1f,0x71,"MF_SESSION_TOPOLOADER"); + IF_GUID_EQUAL_RETURN(guid,0x48cb183e,0x7b0b,0x46f4,0x82,0x2e,0x5e,0x1d,0x2d,0xda,0x43,0x54,"MF_SINK_WRITER_ASYNC_CALLBACK"); + IF_GUID_EQUAL_RETURN(guid,0xec822da2,0xe1e9,0x4b29,0xa0,0xd8,0x56,0x3c,0x71,0x9f,0x52,0x69,"MF_SINK_WRITER_D3D_MANAGER"); + IF_GUID_EQUAL_RETURN(guid,0x08b845d8,0x2b74,0x4afe,0x9d,0x53,0xbe,0x16,0xd2,0xd5,0xae,0x4f,"MF_SINK_WRITER_DISABLE_THROTTLING"); + IF_GUID_EQUAL_RETURN(guid,0xad91cd04,0xa7cc,0x4ac7,0x99,0xb6,0xa5,0x7b,0x9a,0x4a,0x7c,0x70,"MF_SINK_WRITER_ENCODER_CONFIG"); + IF_GUID_EQUAL_RETURN(guid,0xe002aadc,0xf4af,0x4ee5,0x98,0x47,0x05,0x3e,0xdf,0x84,0x04,0x26,"MF_SOURCE_PRESENTATION_PROVIDER_SERVICE"); + IF_GUID_EQUAL_RETURN(guid,0x1e3dbeac,0xbb43,0x4c35,0xb5,0x07,0xcd,0x64,0x44,0x64,0xc9,0x65,"MF_SOURCE_READER_ASYNC_CALLBACK"); + IF_GUID_EQUAL_RETURN(guid,0xec822da2,0xe1e9,0x4b29,0xa0,0xd8,0x56,0x3c,0x71,0x9f,0x52,0x69,"MF_SOURCE_READER_D3D_MANAGER"); + IF_GUID_EQUAL_RETURN(guid,0x9d3365dd,0x58f,0x4cfb,0x9f,0x97,0xb3,0x14,0xcc,0x99,0xc8,0xad,"MF_SOURCE_READER_DISABLE_CAMERA_PLUGINS"); + IF_GUID_EQUAL_RETURN(guid,0xaa456cfd,0x3943,0x4a1e,0xa7,0x7d,0x18,0x38,0xc0,0xea,0x2e,0x35,"MF_SOURCE_READER_DISABLE_DXVA"); + IF_GUID_EQUAL_RETURN(guid,0x56b67165,0x219e,0x456d,0xa2,0x2e,0x2d,0x30,0x04,0xc7,0xfe,0x56,"MF_SOURCE_READER_DISCONNECT_MEDIASOURCE_ON_SHUTDOWN"); + IF_GUID_EQUAL_RETURN(guid,0xf81da2c,0xb537,0x4672,0xa8,0xb2,0xa6,0x81,0xb1,0x73,0x7,0xa3,"MF_SOURCE_READER_ENABLE_ADVANCED_VIDEO_PROCESSING"); + IF_GUID_EQUAL_RETURN(guid,0xdfd4f008,0xb5fd,0x4e78,0xae,0x44,0x62,0xa1,0xe6,0x7b,0xbe,0x27,"MF_SOURCE_READER_ENABLE_TRANSCODE_ONLY_TRANSFORMS"); + IF_GUID_EQUAL_RETURN(guid,0xfb394f3d,0xccf1,0x42ee,0xbb,0xb3,0xf9,0xb8,0x45,0xd5,0x68,0x1d,"MF_SOURCE_READER_ENABLE_VIDEO_PROCESSING"); + IF_GUID_EQUAL_RETURN(guid,0x6d23f5c8,0xc5d7,0x4a9b,0x99,0x71,0x5d,0x11,0xf8,0xbc,0xa8,0x80,"MF_SOURCE_READER_MEDIASOURCE_CHARACTERISTICS"); + IF_GUID_EQUAL_RETURN(guid,0x9085abeb,0x0354,0x48f9,0xab,0xb5,0x20,0x0d,0xf8,0x38,0xc6,0x8e,"MF_SOURCE_READER_MEDIASOURCE_CONFIG"); + IF_GUID_EQUAL_RETURN(guid,0xa38253aa,0x6314,0x42fd,0xa3,0xce,0xbb,0x27,0xb6,0x85,0x99,0x46,"MF_SOURCE_STREAM_SUPPORTS_HW_CONNECTION"); + IF_GUID_EQUAL_RETURN(guid,0x9b465cbf,0x597,0x4f9e,0x9f,0x3c,0xb9,0x7e,0xee,0xf9,0x3,0x59,"MF_STREAM_SINK_SUPPORTS_HW_CONNECTION"); + IF_GUID_EQUAL_RETURN(guid,0xb3e96280,0xbd05,0x41a5,0x97,0xad,0x8a,0x7f,0xee,0x24,0xb9,0x12,"MF_STREAM_SINK_SUPPORTS_ROTATION"); + IF_GUID_EQUAL_RETURN(guid,0x5403deee,0xb9ee,0x438f,0xaa,0x83,0x38,0x4,0x99,0x7e,0x56,0x9d,"MF_SampleProtectionSalt"); + IF_GUID_EQUAL_RETURN(guid,0xa0d502a7,0x0eb3,0x4885,0xb1,0xb9,0x9f,0xeb,0x0d,0x08,0x34,0x54,"MF_TIMECODE_SERVICE"); + IF_GUID_EQUAL_RETURN(guid,0x4399f178,0x46d3,0x4504,0xaf,0xda,0x20,0xd3,0x2e,0x9b,0xa3,0x60,"MF_TIME_FORMAT_ENTRY_RELATIVE"); + IF_GUID_EQUAL_RETURN(guid,0xc8b8be77,0x869c,0x431d,0x81,0x2e,0x16,0x96,0x93,0xf6,0x5a,0x39,"MF_TIME_FORMAT_SEGMENT_OFFSET"); + IF_GUID_EQUAL_RETURN(guid,0x1e8d34f6,0xf5ab,0x4e23,0xbb,0x88,0x87,0x4a,0xa3,0xa1,0xa7,0x4d,"MF_TOPOLOGY_DXVA_MODE"); + IF_GUID_EQUAL_RETURN(guid,0xd529950b,0xd484,0x4527,0xa9,0xcd,0xb1,0x90,0x95,0x32,0xb5,0xb0,"MF_TOPOLOGY_DYNAMIC_CHANGE_NOT_ALLOWED"); + IF_GUID_EQUAL_RETURN(guid,0x1967731f,0xcd78,0x42fc,0xb0,0x26,0x9,0x92,0xa5,0x6e,0x56,0x93,"MF_TOPOLOGY_ENABLE_XVP_FOR_PLAYBACK"); + IF_GUID_EQUAL_RETURN(guid,0x6248c36d,0x5d0b,0x4f40,0xa0,0xbb,0xb0,0xb3,0x05,0xf7,0x76,0x98,"MF_TOPOLOGY_ENUMERATE_SOURCE_TYPES"); + IF_GUID_EQUAL_RETURN(guid,0xd2d362fd,0x4e4f,0x4191,0xa5,0x79,0xc6,0x18,0xb6,0x67,0x6,0xaf,"MF_TOPOLOGY_HARDWARE_MODE"); + IF_GUID_EQUAL_RETURN(guid,0x7ed3f804,0x86bb,0x4b3f,0xb7,0xe4,0x7c,0xb4,0x3a,0xfd,0x4b,0x80,"MF_TOPOLOGY_NO_MARKIN_MARKOUT"); + IF_GUID_EQUAL_RETURN(guid,0xc164737a,0xc2b1,0x4553,0x83,0xbb,0x5a,0x52,0x60,0x72,0x44,0x8f,"MF_TOPOLOGY_PLAYBACK_FRAMERATE"); + IF_GUID_EQUAL_RETURN(guid,0x5715cf19,0x5768,0x44aa,0xad,0x6e,0x87,0x21,0xf1,0xb0,0xf9,0xbb,"MF_TOPOLOGY_PLAYBACK_MAX_DIMS"); + IF_GUID_EQUAL_RETURN(guid,0x7ed3f802,0x86bb,0x4b3f,0xb7,0xe4,0x7c,0xb4,0x3a,0xfd,0x4b,0x80,"MF_TOPOLOGY_PROJECTSTART"); + IF_GUID_EQUAL_RETURN(guid,0x7ed3f803,0x86bb,0x4b3f,0xb7,0xe4,0x7c,0xb4,0x3a,0xfd,0x4b,0x80,"MF_TOPOLOGY_PROJECTSTOP"); + IF_GUID_EQUAL_RETURN(guid,0x494bbcde,0xb031,0x4e38,0x97,0xc4,0xd5,0x42,0x2d,0xd6,0x18,0xdc,"MF_TOPOLOGY_RESOLUTION_STATUS"); + IF_GUID_EQUAL_RETURN(guid,0xc8cc113f,0x7951,0x4548,0xaa,0xd6,0x9e,0xd6,0x20,0x2e,0x62,0xb3,"MF_TOPOLOGY_START_TIME_ON_PRESENTATION_SWITCH"); + IF_GUID_EQUAL_RETURN(guid,0xb86cac42,0x41a6,0x4b79,0x89,0x7a,0x1a,0xb0,0xe5,0x2b,0x4a,0x1b,"MF_TOPOLOGY_STATIC_PLAYBACK_OPTIMIZATIONS"); + IF_GUID_EQUAL_RETURN(guid,0x65656e1a,0x077f,0x4472,0x83,0xef,0x31,0x6f,0x11,0xd5,0x08,0x7a,"MF_TOPONODE_ATTRIBUTE_EDITOR_SERVICE"); + IF_GUID_EQUAL_RETURN(guid,0x494bbcf1,0xb031,0x4e38,0x97,0xc4,0xd5,0x42,0x2d,0xd6,0x18,0xdc,"MF_TOPONODE_CONNECT_METHOD"); + IF_GUID_EQUAL_RETURN(guid,0x494bbced,0xb031,0x4e38,0x97,0xc4,0xd5,0x42,0x2d,0xd6,0x18,0xdc,"MF_TOPONODE_D3DAWARE"); + IF_GUID_EQUAL_RETURN(guid,0x494bbd02,0xb031,0x4e38,0x97,0xc4,0xd5,0x42,0x2d,0xd6,0x18,0xdc,"MF_TOPONODE_DECODER"); + IF_GUID_EQUAL_RETURN(guid,0x494bbcfa,0xb031,0x4e38,0x97,0xc4,0xd5,0x42,0x2d,0xd6,0x18,0xdc,"MF_TOPONODE_DECRYPTOR"); + IF_GUID_EQUAL_RETURN(guid,0x14932f9e,0x9087,0x4bb4,0x84,0x12,0x51,0x67,0x14,0x5c,0xbe,0x04,"MF_TOPONODE_DISABLE_PREROLL"); + IF_GUID_EQUAL_RETURN(guid,0x494bbcfb,0xb031,0x4e38,0x97,0xc4,0xd5,0x42,0x2d,0xd6,0x18,0xdc,"MF_TOPONODE_DISCARDABLE"); + IF_GUID_EQUAL_RETURN(guid,0x494bbce9,0xb031,0x4e38,0x97,0xc4,0xd5,0x42,0x2d,0xd6,0x18,0xdc,"MF_TOPONODE_DRAIN"); + IF_GUID_EQUAL_RETURN(guid,0x494bbcee,0xb031,0x4e38,0x97,0xc4,0xd5,0x42,0x2d,0xd6,0x18,0xdc,"MF_TOPONODE_ERRORCODE"); + IF_GUID_EQUAL_RETURN(guid,0x494bbcfd,0xb031,0x4e38,0x97,0xc4,0xd5,0x42,0x2d,0xd6,0x18,0xdc,"MF_TOPONODE_ERROR_MAJORTYPE"); + IF_GUID_EQUAL_RETURN(guid,0x494bbcfe,0xb031,0x4e38,0x97,0xc4,0xd5,0x42,0x2d,0xd6,0x18,0xdc,"MF_TOPONODE_ERROR_SUBTYPE"); + IF_GUID_EQUAL_RETURN(guid,0x494bbce8,0xb031,0x4e38,0x97,0xc4,0xd5,0x42,0x2d,0xd6,0x18,0xdc,"MF_TOPONODE_FLUSH"); + IF_GUID_EQUAL_RETURN(guid,0x494bbcf7,0xb031,0x4e38,0x97,0xc4,0xd5,0x42,0x2d,0xd6,0x18,0xdc,"MF_TOPONODE_LOCKED"); + IF_GUID_EQUAL_RETURN(guid,0x494bbd00,0xb031,0x4e38,0x97,0xc4,0xd5,0x42,0x2d,0xd6,0x18,0xdc,"MF_TOPONODE_MARKIN_HERE"); + IF_GUID_EQUAL_RETURN(guid,0x494bbd01,0xb031,0x4e38,0x97,0xc4,0xd5,0x42,0x2d,0xd6,0x18,0xdc,"MF_TOPONODE_MARKOUT_HERE"); + IF_GUID_EQUAL_RETURN(guid,0x835c58ea,0xe075,0x4bc7,0xbc,0xba,0x4d,0xe0,0x00,0xdf,0x9a,0xe6,"MF_TOPONODE_MEDIASTART"); + IF_GUID_EQUAL_RETURN(guid,0x835c58eb,0xe075,0x4bc7,0xbc,0xba,0x4d,0xe0,0x00,0xdf,0x9a,0xe6,"MF_TOPONODE_MEDIASTOP"); + IF_GUID_EQUAL_RETURN(guid,0x14932f9c,0x9087,0x4bb4,0x84,0x12,0x51,0x67,0x14,0x5c,0xbe,0x04,"MF_TOPONODE_NOSHUTDOWN_ON_REMOVE"); + IF_GUID_EQUAL_RETURN(guid,0x835c58ed,0xe075,0x4bc7,0xbc,0xba,0x4d,0xe0,0x00,0xdf,0x9a,0xe6,"MF_TOPONODE_PRESENTATION_DESCRIPTOR"); + IF_GUID_EQUAL_RETURN(guid,0x6304ef99,0x16b2,0x4ebe,0x9d,0x67,0xe4,0xc5,0x39,0xb3,0xa2,0x59,"MF_TOPONODE_PRIMARYOUTPUT"); + IF_GUID_EQUAL_RETURN(guid,0x14932f9d,0x9087,0x4bb4,0x84,0x12,0x51,0x67,0x14,0x5c,0xbe,0x04,"MF_TOPONODE_RATELESS"); + IF_GUID_EQUAL_RETURN(guid,0x835c58ef,0xe075,0x4bc7,0xbc,0xba,0x4d,0xe0,0x00,0xdf,0x9a,0xe6,"MF_TOPONODE_SEQUENCE_ELEMENTID"); + IF_GUID_EQUAL_RETURN(guid,0x835c58ec,0xe075,0x4bc7,0xbc,0xba,0x4d,0xe0,0x00,0xdf,0x9a,0xe6,"MF_TOPONODE_SOURCE"); + IF_GUID_EQUAL_RETURN(guid,0x14932f9b,0x9087,0x4bb4,0x84,0x12,0x51,0x67,0x14,0x5c,0xbe,0x04,"MF_TOPONODE_STREAMID"); + IF_GUID_EQUAL_RETURN(guid,0x835c58ee,0xe075,0x4bc7,0xbc,0xba,0x4d,0xe0,0x00,0xdf,0x9a,0xe6,"MF_TOPONODE_STREAM_DESCRIPTOR"); + IF_GUID_EQUAL_RETURN(guid,0x88dcc0c9,0x293e,0x4e8b,0x9a,0xeb,0xa,0xd6,0x4c,0xc0,0x16,0xb0,"MF_TOPONODE_TRANSFORM_OBJECTID"); + IF_GUID_EQUAL_RETURN(guid,0x494bbcf8,0xb031,0x4e38,0x97,0xc4,0xd5,0x42,0x2d,0xd6,0x18,0xdc,"MF_TOPONODE_WORKQUEUE_ID"); + IF_GUID_EQUAL_RETURN(guid,0xa1ff99be,0x5e97,0x4a53,0xb4,0x94,0x56,0x8c,0x64,0x2c,0x0f,0xf3,"MF_TOPONODE_WORKQUEUE_ITEM_PRIORITY"); + IF_GUID_EQUAL_RETURN(guid,0x494bbcf9,0xb031,0x4e38,0x97,0xc4,0xd5,0x42,0x2d,0xd6,0x18,0xdc,"MF_TOPONODE_WORKQUEUE_MMCSS_CLASS"); + IF_GUID_EQUAL_RETURN(guid,0x5001f840,0x2816,0x48f4,0x93,0x64,0xad,0x1e,0xf6,0x61,0xa1,0x23,"MF_TOPONODE_WORKQUEUE_MMCSS_PRIORITY"); + IF_GUID_EQUAL_RETURN(guid,0x494bbcff,0xb031,0x4e38,0x97,0xc4,0xd5,0x42,0x2d,0xd6,0x18,0xdc,"MF_TOPONODE_WORKQUEUE_MMCSS_TASKID"); + IF_GUID_EQUAL_RETURN(guid,0x9c37c21b,0x60f,0x487c,0xa6,0x90,0x80,0xd7,0xf5,0xd,0x1c,0x72,"MF_TRANSCODE_ADJUST_PROFILE"); + IF_GUID_EQUAL_RETURN(guid,0x150ff23f,0x4abc,0x478b,0xac,0x4f,0xe1,0x91,0x6f,0xba,0x1c,0xca,"MF_TRANSCODE_CONTAINERTYPE"); + IF_GUID_EQUAL_RETURN(guid,0xf45aa7ce,0xab24,0x4012,0xa1,0x1b,0xdc,0x82,0x20,0x20,0x14,0x10,"MF_TRANSCODE_DONOT_INSERT_ENCODER"); + IF_GUID_EQUAL_RETURN(guid,0x6947787c,0xf508,0x4ea9,0xb1,0xe9,0xa1,0xfe,0x3a,0x49,0xfb,0xc9,"MF_TRANSCODE_ENCODINGPROFILE"); + IF_GUID_EQUAL_RETURN(guid,0x98332df8,0x03cd,0x476b,0x89,0xfa,0x3f,0x9e,0x44,0x2d,0xec,0x9f,"MF_TRANSCODE_QUALITYVSSPEED"); + IF_GUID_EQUAL_RETURN(guid,0x4e4469ef,0xb571,0x4959,0x8f,0x83,0x3d,0xcf,0xba,0x33,0xa3,0x93,"MF_TRANSCODE_SKIP_METADATA_TRANSFER"); + IF_GUID_EQUAL_RETURN(guid,0x3e3df610,0x394a,0x40b2,0x9d,0xea,0x3b,0xab,0x65,0xb,0xeb,0xf2,"MF_TRANSCODE_TOPOLOGYMODE"); + IF_GUID_EQUAL_RETURN(guid,0xf81a699a,0x649a,0x497d,0x8c,0x73,0x29,0xf8,0xfe,0xd6,0xad,0x7a,"MF_TRANSFORM_ASYNC"); + IF_GUID_EQUAL_RETURN(guid,0xe5666d6b,0x3422,0x4eb6,0xa4,0x21,0xda,0x7d,0xb1,0xf8,0xe2,0x7,"MF_TRANSFORM_ASYNC_UNLOCK"); + IF_GUID_EQUAL_RETURN(guid,0xceabba49,0x506d,0x4757,0xa6,0xff,0x66,0xc1,0x84,0x98,0x7e,0x4e,"MF_TRANSFORM_CATEGORY_Attribute"); + IF_GUID_EQUAL_RETURN(guid,0x9359bb7e,0x6275,0x46c4,0xa0,0x25,0x1c,0x1,0xe4,0x5f,0x1a,0x86,"MF_TRANSFORM_FLAGS_Attribute"); + IF_GUID_EQUAL_RETURN(guid,0xd1d4985d,0xdc92,0x457a,0xb3,0xa0,0x65,0x1a,0x33,0xa3,0x10,0x47,"MF_USER_DATA_PAYLOAD"); + IF_GUID_EQUAL_RETURN(guid,0x16d720f0,0x768c,0x11de,0x8a,0x39,0x08,0x00,0x20,0x0c,0x9a,0x66,"MF_VIDEODSP_MODE"); + IF_GUID_EQUAL_RETURN(guid,0x8e37d489,0x41e0,0x413a,0x90,0x68,0x28,0x7c,0x88,0x6d,0x8d,0xda,"MF_WORKQUEUE_SERVICES"); + IF_GUID_EQUAL_RETURN(guid,0x2b182c4c,0xd6ac,0x49f4,0x89,0x15,0xf7,0x18,0x87,0xdb,0x70,0xcd,"MF_WRAPPED_OBJECT"); + IF_GUID_EQUAL_RETURN(guid,0x67EC2559,0x0F2F,0x4420,0xA4,0xDD,0x2F,0x8E,0xE7,0xA5,0x73,0x8B,"MF_WVC1_PROG_SINGLE_SLICE_CONTENT"); + IF_GUID_EQUAL_RETURN(guid,0x2c0afa19,0x7a97,0x4d5a,0x9e,0xe8,0x16,0xd4,0xfc,0x51,0x8d,0x8c,"MF_XVP_DISABLE_FRC"); + IF_GUID_EQUAL_RETURN(guid,0x911fd737,0x6775,0x4ab0,0xa6,0x14,0x29,0x78,0x62,0xfd,0xac,0x88,"MR_AUDIO_POLICY_SERVICE"); + IF_GUID_EQUAL_RETURN(guid,0xa562248c,0x9ac6,0x4ffc,0x9f,0xba,0x3a,0xf8,0xf8,0xad,0x1a,0x4d,"MR_BUFFER_SERVICE"); + IF_GUID_EQUAL_RETURN(guid,0x24030acd,0x107a,0x4265,0x97,0x5c,0x41,0x4e,0x33,0xe6,0x5f,0x2a,"MR_CAPTURE_POLICY_VOLUME_SERVICE"); + IF_GUID_EQUAL_RETURN(guid,0x1abaa2ac,0x9d3b,0x47c6,0xab,0x48,0xc5,0x95,0x6,0xde,0x78,0x4d,"MR_POLICY_VOLUME_SERVICE"); + IF_GUID_EQUAL_RETURN(guid,0xf8b5fa2f,0x32ef,0x46f5,0xb1,0x72,0x13,0x21,0x21,0x2f,0xb2,0xc4,"MR_STREAM_VOLUME_SERVICE"); + IF_GUID_EQUAL_RETURN(guid,0xefef5175,0x5c7d,0x4ce2,0xbb,0xbd,0x34,0xff,0x8b,0xca,0x65,0x54,"MR_VIDEO_ACCELERATION_SERVICE"); + IF_GUID_EQUAL_RETURN(guid,0x73cd2fc,0x6cf4,0x40b7,0x88,0x59,0xe8,0x95,0x52,0xc8,0x41,0xf8,"MR_VIDEO_MIXER_SERVICE"); + IF_GUID_EQUAL_RETURN(guid,0x1092a86c,0xab1a,0x459a,0xa3,0x36,0x83,0x1f,0xbc,0x4d,0x11,0xff,"MR_VIDEO_RENDER_SERVICE"); + IF_GUID_EQUAL_RETURN(guid,0xa35ff56b,0x9fda,0x11d0,0x8f,0xdf,0x0,0xc0,0x4f,0xd9,0x18,0x9d,"MSPID_PrimaryAudio"); + IF_GUID_EQUAL_RETURN(guid,0xa35ff56a,0x9fda,0x11d0,0x8f,0xdf,0x0,0xc0,0x4f,0xd9,0x18,0x9d,"MSPID_PrimaryVideo"); + IF_GUID_EQUAL_RETURN(guid,0xcc384250,0x0e7b,0x4ae8,0x95,0xae,0xa0,0x8f,0x26,0x1b,0x52,0xee,"MenuBar_Control_GUID"); + IF_GUID_EQUAL_RETURN(guid,0x3cf1266e,0x1582,0x4041,0xac,0xd7,0x88,0xa3,0x5a,0x96,0x52,0x97,"MenuClosed_Event_GUID"); + IF_GUID_EQUAL_RETURN(guid,0xf45225d3,0xd0a0,0x49d8,0x98,0x34,0x9a,0x00,0x0d,0x2a,0xed,0xdc,"MenuItem_Control_GUID"); + IF_GUID_EQUAL_RETURN(guid,0x9ecd4c9f,0x80dd,0x47b8,0x82,0x67,0x5a,0xec,0x06,0xbb,0x2c,0xff,"MenuModeEnd_Event_GUID"); + IF_GUID_EQUAL_RETURN(guid,0x18d7c631,0x166a,0x4ac9,0xae,0x3b,0xef,0x4b,0x54,0x20,0xe6,0x81,"MenuModeStart_Event_GUID"); + IF_GUID_EQUAL_RETURN(guid,0xebe2e945,0x66ca,0x4ed1,0x9f,0xf8,0x2a,0xd7,0xdf,0x0a,0x1b,0x08,"MenuOpened_Event_GUID"); + IF_GUID_EQUAL_RETURN(guid,0x2e9b1440,0x0ea8,0x41fd,0xb3,0x74,0xc1,0xea,0x6f,0x50,0x3c,0xd1,"Menu_Control_GUID"); + IF_GUID_EQUAL_RETURN(guid,0x30fe7be8,0xd7d9,0x11d2,0x9f,0x80,0x0,0xc0,0x4f,0x79,0xa0,0xa3,"MetaDataCheckDuplicatesFor"); + IF_GUID_EQUAL_RETURN(guid,0x1547872d,0xdc03,0x11d2,0x94,0x20,0x0,0x0,0xf8,0x8,0x34,0x60,"MetaDataErrorIfEmitOutOfOrder"); + IF_GUID_EQUAL_RETURN(guid,0xdcc9de90,0x4151,0x11d3,0x88,0xd6,0x0,0x90,0x27,0x54,0xc4,0x3a,"MetaDataGenerateTCEAdapters"); + IF_GUID_EQUAL_RETURN(guid,0x79700f36,0x4aac,0x11d3,0x84,0xc3,0x0,0x90,0x27,0x86,0x8c,0xb1,"MetaDataImportOption"); + IF_GUID_EQUAL_RETURN(guid,0x47e099b6,0xae7c,0x4797,0x83,0x17,0xb4,0x8a,0xa6,0x45,0xb8,0xf9,"MetaDataLinkerOptions"); + IF_GUID_EQUAL_RETURN(guid,0x132d3a6e,0xb35d,0x464e,0x95,0x1a,0x42,0xef,0xb9,0xfb,0x66,0x1,"MetaDataMergerOptions"); + IF_GUID_EQUAL_RETURN(guid,0xe5d71a4c,0xd7da,0x11d2,0x9f,0x80,0x0,0xc0,0x4f,0x79,0xa0,0xa3,"MetaDataNotificationForTokenMovement"); + IF_GUID_EQUAL_RETURN(guid,0xa55c0354,0xe91b,0x468b,0x86,0x48,0x7c,0xc3,0x10,0x35,0xd5,0x33,"MetaDataPreserveLocalRefs"); + IF_GUID_EQUAL_RETURN(guid,0xde3856f8,0xd7d9,0x11d2,0x9f,0x80,0x0,0xc0,0x4f,0x79,0xa0,0xa3,"MetaDataRefToDefCheck"); + IF_GUID_EQUAL_RETURN(guid,0x47e099b7,0xae7c,0x4797,0x83,0x17,0xb4,0x8a,0xa6,0x45,0xb8,0xf9,"MetaDataRuntimeVersion"); + IF_GUID_EQUAL_RETURN(guid,0x2eee315c,0xd7db,0x11d2,0x9f,0x80,0x0,0xc0,0x4f,0x79,0xa0,0xa3,"MetaDataSetUpdate"); + IF_GUID_EQUAL_RETURN(guid,0xf7559806,0xf266,0x42ea,0x8c,0x63,0xa,0xdb,0x45,0xe8,0xb2,0x34,"MetaDataThreadSafetyOptions"); + IF_GUID_EQUAL_RETURN(guid,0xf17ff889,0x5a63,0x11d3,0x9f,0xf2,0x0,0xc0,0x4f,0xf7,0x43,0x1a,"MetaDataTypeLibImportNamespace"); + IF_GUID_EQUAL_RETURN(guid,0x7a81a67a,0xb94f,0x4875,0x91,0x8b,0x65,0xc8,0xd2,0xf9,0x98,0xe5,"MultipleView_CurrentView_Property_GUID"); + IF_GUID_EQUAL_RETURN(guid,0x547a6ae4,0x113f,0x47c4,0x85,0x0f,0xdb,0x4d,0xfa,0x46,0x6b,0x1d,"MultipleView_Pattern_GUID"); + IF_GUID_EQUAL_RETURN(guid,0x8d5db9fd,0xce3c,0x4ae7,0xb7,0x88,0x40,0x0a,0x3c,0x64,0x55,0x47,"MultipleView_SupportedViews_Property_GUID"); + IF_GUID_EQUAL_RETURN(guid,0x1f81d131,0x3fac,0x4537,0x9e,0x0c,0x7e,0x7b,0x0c,0x2f,0x4b,0x55,"NAMED_PIPE_EVENT_GUID"); + IF_GUID_EQUAL_RETURN(guid,0x4f27f2de,0x14e2,0x430b,0xa5,0x49,0x7c,0xd4,0x8c,0xbc,0x82,0x45,"NETWORK_MANAGER_FIRST_IP_ADDRESS_ARRIVAL_GUID"); + IF_GUID_EQUAL_RETURN(guid,0xcc4ba62a,0x162e,0x4648,0x84,0x7a,0xb6,0xbd,0xf9,0x93,0xe3,0x35,"NETWORK_MANAGER_LAST_IP_ADDRESS_REMOVAL_GUID"); + IF_GUID_EQUAL_RETURN(guid,0xba9a5027,0xa70e,0x4ae7,0x9b,0x7d,0xeb,0x3e,0x06,0xad,0x41,0x57,"NOTIFICATION_RELEASE"); + IF_GUID_EQUAL_RETURN(guid,0xFEA3413E,0x7E05,0x4911,0x9A,0x71,0x70,0x03,0x31,0xF1,0xC2,0x94,"NO_SUBGROUP_GUID"); + IF_GUID_EQUAL_RETURN(guid,0x03fe89ce,0x766d,0x4976,0xb9,0xc1,0xbb,0x9b,0xc4,0x2c,0x7b,0x4d,"NS_PROVIDER_PNRPCLOUD"); + IF_GUID_EQUAL_RETURN(guid,0x03fe89cd,0x766d,0x4976,0xb9,0xc1,0xbb,0x9b,0xc4,0x2c,0x7b,0x4d,"NS_PROVIDER_PNRPNAME"); + IF_GUID_EQUAL_RETURN(guid,0xc3a6921b,0x4a99,0x44f1,0xbc,0xa6,0x61,0x18,0x70,0x52,0xc4,0x31,"Name_Property_GUID"); + IF_GUID_EQUAL_RETURN(guid,0x5196b33b,0x380a,0x4982,0x95,0xe1,0x91,0xf3,0xef,0x60,0xe0,0x24,"NewNativeWindowHandle_Property_GUID"); + IF_GUID_EQUAL_RETURN(guid,0x6c9e010,0x38ce,0x11d4,0xa2,0xa3,0x00,0x10,0x4b,0xd3,0x50,0x90,"OID_JSSIP"); + IF_GUID_EQUAL_RETURN(guid,0x98c5a3dd,0xdb68,0x4f1a,0x8d,0x2b,0x90,0x79,0xcd,0xfe,0xaf,0x61,"OID_OAssociatedIdentityProviderObject"); + IF_GUID_EQUAL_RETURN(guid,0x1629f04e,0x2799,0x4db5,0x8f,0xe5,0xac,0xe1,0x0f,0x17,0xeb,0xab,"OID_VBSSIP"); + IF_GUID_EQUAL_RETURN(guid,0x1a610570,0x38ce,0x11d4,0xa2,0xa3,0x00,0x10,0x4b,0xd3,0x50,0x90,"OID_WSFSIP"); + IF_GUID_EQUAL_RETURN(guid,0x6629a591,0x3b79,0x4cf3,0x92,0x4a,0x11,0xe8,0xe7,0x81,0x16,0x71,"OPM_GET_ACP_AND_CGMSA_SIGNALING"); + IF_GUID_EQUAL_RETURN(guid,0xd7bf1ba3,0xad13,0x4f8e,0xaf,0x98,0x0d,0xcb,0x3c,0xa2,0x04,0xcc,"OPM_GET_ACTUAL_OUTPUT_FORMAT"); + IF_GUID_EQUAL_RETURN(guid,0x1957210a,0x7766,0x452a,0xb9,0x9a,0xd2,0x7a,0xed,0x54,0xf0,0x3a,"OPM_GET_ACTUAL_PROTECTION_LEVEL"); + IF_GUID_EQUAL_RETURN(guid,0xc6f4d673,0x6174,0x4184,0x8e,0x35,0xf6,0xdb,0x52,0x0,0xbc,0xba,"OPM_GET_ADAPTER_BUS_TYPE"); + IF_GUID_EQUAL_RETURN(guid,0x4f374491,0x8f5f,0x4445,0x9d,0xba,0x95,0x58,0x8f,0x6b,0x58,0xb4,"OPM_GET_CODEC_INFO"); + IF_GUID_EQUAL_RETURN(guid,0x0db59d74,0xa992,0x492e,0xa0,0xbd,0xc2,0x3f,0xda,0x56,0x4e,0x00,"OPM_GET_CONNECTED_HDCP_DEVICE_INFORMATION"); + IF_GUID_EQUAL_RETURN(guid,0x81d0bfd5,0x6afe,0x48c2,0x99,0xc0,0x95,0xa0,0x8f,0x97,0xc5,0xda,"OPM_GET_CONNECTOR_TYPE"); + IF_GUID_EQUAL_RETURN(guid,0x99c5ceff,0x5f1d,0x4879,0x81,0xc1,0xc5,0x24,0x43,0xc9,0x48,0x2b,"OPM_GET_CURRENT_HDCP_SRM_VERSION"); + IF_GUID_EQUAL_RETURN(guid,0xa470b3bb,0x5dd7,0x4172,0x83,0x9c,0x3d,0x37,0x76,0xe0,0xeb,0xf5,"OPM_GET_DVI_CHARACTERISTICS"); + IF_GUID_EQUAL_RETURN(guid,0x72cb6df3,0x244f,0x40ce,0xb0,0x9e,0x20,0x50,0x6a,0xf6,0x30,0x2f,"OPM_GET_OUTPUT_ID"); + IF_GUID_EQUAL_RETURN(guid,0x38f2a801,0x9a6c,0x48bb,0x91,0x07,0xb6,0x69,0x6e,0x6f,0x17,0x97,"OPM_GET_SUPPORTED_PROTECTION_TYPES"); + IF_GUID_EQUAL_RETURN(guid,0xb2075857,0x3eda,0x4d5d,0x88,0xdb,0x74,0x8f,0x8c,0x1a,0x05,0x49,"OPM_GET_VIRTUAL_PROTECTION_LEVEL"); + IF_GUID_EQUAL_RETURN(guid,0x09a631a5,0xd684,0x4c60,0x8e,0x4d,0xd3,0xbb,0x0f,0x0b,0xe3,0xee,"OPM_SET_ACP_AND_CGMSA_SIGNALING"); + IF_GUID_EQUAL_RETURN(guid,0x8b5ef5d1,0xc30d,0x44ff,0x84,0xa5,0xea,0x71,0xdc,0xe7,0x8f,0x13,"OPM_SET_HDCP_SRM"); + IF_GUID_EQUAL_RETURN(guid,0x9bb9327c,0x4eb5,0x4727,0x9f,0x00,0xb4,0x2b,0x09,0x19,0xc0,0xda,"OPM_SET_PROTECTION_LEVEL"); + IF_GUID_EQUAL_RETURN(guid,0x39ce333e,0x4cc0,0x44ae,0xbf,0xcc,0xda,0x50,0xb5,0xf8,0x2e,0x72,"OPM_SET_PROTECTION_LEVEL_ACCORDING_TO_CSS_DVD"); + IF_GUID_EQUAL_RETURN(guid,0x3e04acfe,0x08fc,0x47ec,0x96,0xbc,0x35,0x3f,0xa3,0xb3,0x4a,0xa7,"ObjectModel_Pattern_GUID"); + IF_GUID_EQUAL_RETURN(guid,0x6a852250,0xc75a,0x4e5d,0xb8,0x58,0xe3,0x81,0xb0,0xf7,0x88,0x61,"OptimizeForVisualContent_Property_GUID"); + IF_GUID_EQUAL_RETURN(guid,0xa01eee62,0x3884,0x4415,0x88,0x7e,0x67,0x8e,0xc2,0x1e,0x39,0xba,"Orientation_Property_GUID"); + IF_GUID_EQUAL_RETURN(guid,0xf6298b4c,0xc725,0x4d42,0x84,0x9b,0x41,0x0b,0xbb,0x14,0xea,0x62,"PBDA_AUX_CONNECTOR_TYPE_Composite"); + IF_GUID_EQUAL_RETURN(guid,0xa0e905f4,0x24c9,0x4a54,0xb7,0x61,0x21,0x33,0x55,0xef,0xc1,0x3A,"PBDA_AUX_CONNECTOR_TYPE_SVideo"); + IF_GUID_EQUAL_RETURN(guid,0xdd15f41f,0xfc4e,0x4922,0xb0,0x35,0x4c,0x06,0xa7,0x54,0xd0,0x1d,"PEER_COLLAB_OBJECTID_USER_PICTURE"); + IF_GUID_EQUAL_RETURN(guid,0x04387127,0xaa56,0x450a,0x8c,0xe5,0x4f,0x56,0x5c,0x67,0x90,0xf4,"PEER_GROUP_ROLE_ADMIN"); + IF_GUID_EQUAL_RETURN(guid,0x4370fd89,0xdc18,0x4cfb,0x8d,0xbf,0x98,0x53,0xa8,0xa9,0xf9,0x05,"PEER_GROUP_ROLE_INVITING_MEMBER"); + IF_GUID_EQUAL_RETURN(guid,0xf12dc4c7,0x0857,0x4ca0,0x93,0xfc,0xb1,0xbb,0x19,0xa3,0xd8,0xc2,"PEER_GROUP_ROLE_MEMBER"); + IF_GUID_EQUAL_RETURN(guid,0xfb6c4283,0x0353,0x11d1,0x90,0x5f,0x00,0x00,0xc0,0xcc,0x16,0xba,"PIN_CATEGORY_ANALOGVIDEOIN"); + IF_GUID_EQUAL_RETURN(guid,0xfb6c4281,0x0353,0x11d1,0x90,0x5f,0x00,0x00,0xc0,0xcc,0x16,0xba,"PIN_CATEGORY_CAPTURE"); + IF_GUID_EQUAL_RETURN(guid,0xfb6c4289,0x0353,0x11d1,0x90,0x5f,0x00,0x00,0xc0,0xcc,0x16,0xba,"PIN_CATEGORY_CC"); + IF_GUID_EQUAL_RETURN(guid,0xfb6c4287,0x0353,0x11d1,0x90,0x5f,0x00,0x00,0xc0,0xcc,0x16,0xba,"PIN_CATEGORY_EDS"); + IF_GUID_EQUAL_RETURN(guid,0xfb6c4286,0x0353,0x11d1,0x90,0x5f,0x00,0x00,0xc0,0xcc,0x16,0xba,"PIN_CATEGORY_NABTS"); + IF_GUID_EQUAL_RETURN(guid,0xfb6c4282,0x0353,0x11d1,0x90,0x5f,0x00,0x00,0xc0,0xcc,0x16,0xba,"PIN_CATEGORY_PREVIEW"); + IF_GUID_EQUAL_RETURN(guid,0xfb6c428a,0x0353,0x11d1,0x90,0x5f,0x00,0x00,0xc0,0xcc,0x16,0xba,"PIN_CATEGORY_STILL"); + IF_GUID_EQUAL_RETURN(guid,0xfb6c4288,0x0353,0x11d1,0x90,0x5f,0x00,0x00,0xc0,0xcc,0x16,0xba,"PIN_CATEGORY_TELETEXT"); + IF_GUID_EQUAL_RETURN(guid,0xfb6c428b,0x0353,0x11d1,0x90,0x5f,0x00,0x00,0xc0,0xcc,0x16,0xba,"PIN_CATEGORY_TIMECODE"); + IF_GUID_EQUAL_RETURN(guid,0xfb6c4284,0x0353,0x11d1,0x90,0x5f,0x00,0x00,0xc0,0xcc,0x16,0xba,"PIN_CATEGORY_VBI"); + IF_GUID_EQUAL_RETURN(guid,0xfb6c4285,0x0353,0x11d1,0x90,0x5f,0x00,0x00,0xc0,0xcc,0x16,0xba,"PIN_CATEGORY_VIDEOPORT"); + IF_GUID_EQUAL_RETURN(guid,0xfb6c428c,0x0353,0x11d1,0x90,0x5f,0x00,0x00,0xc0,0xcc,0x16,0xba,"PIN_CATEGORY_VIDEOPORT_VBI"); + IF_GUID_EQUAL_RETURN(guid,0xba138e10,0xe250,0x4ad7,0x86,0x16,0xcf,0x1a,0x7a,0xd4,0x10,0xe7,"PPM_IDLESTATES_DATA_GUID"); + IF_GUID_EQUAL_RETURN(guid,0x4838fe4f,0xf71c,0x4e51,0x9e,0xcc,0x84,0x30,0xa7,0xac,0x4c,0x6c,"PPM_IDLESTATE_CHANGE_GUID"); + IF_GUID_EQUAL_RETURN(guid,0xd67abd39,0x81f8,0x4a5e,0x81,0x52,0x72,0xe3,0x1e,0xc9,0x12,0xee,"PPM_IDLE_ACCOUNTING_EX_GUID"); + IF_GUID_EQUAL_RETURN(guid,0xe2a26f78,0xae07,0x4ee0,0xa3,0x0f,0xce,0x54,0xf5,0x5a,0x94,0xcd,"PPM_IDLE_ACCOUNTING_GUID"); + IF_GUID_EQUAL_RETURN(guid,0x7fd18652,0xcfe,0x40d2,0xb0,0xa1,0xb,0x6,0x6a,0x87,0x75,0x9e,"PPM_PERFMON_PERFSTATE_GUID"); + IF_GUID_EQUAL_RETURN(guid,0x5708cc20,0x7d40,0x4bf4,0xb4,0xaa,0x2b,0x01,0x33,0x8d,0x01,0x26,"PPM_PERFSTATES_DATA_GUID"); + IF_GUID_EQUAL_RETURN(guid,0xa5b32ddd,0x7f39,0x4abc,0xb8,0x92,0x90,0xe,0x43,0xb5,0x9e,0xbb,"PPM_PERFSTATE_CHANGE_GUID"); + IF_GUID_EQUAL_RETURN(guid,0x995e6b7f,0xd653,0x497a,0xb9,0x78,0x36,0xa3,0xc,0x29,0xbf,0x1,"PPM_PERFSTATE_DOMAIN_CHANGE_GUID"); + IF_GUID_EQUAL_RETURN(guid,0xa852c2c8,0x1a4c,0x423b,0x8c,0x2c,0xf3,0x0d,0x82,0x93,0x1a,0x88,"PPM_THERMALCONSTRAINT_GUID"); + IF_GUID_EQUAL_RETURN(guid,0x48f377b8,0x6880,0x4c7b,0x8b,0xdc,0x38,0x1,0x76,0xc6,0x65,0x4d,"PPM_THERMAL_POLICY_CHANGE_GUID"); + IF_GUID_EQUAL_RETURN(guid,0x5d5a1704,0xdfd1,0x4181,0x8e,0xee,0x81,0x5c,0x86,0xed,0xad,0x31,"PRINTER_EXTENSION_DETAILEDREASON_PRINTER_STATUS"); + IF_GUID_EQUAL_RETURN(guid,0x23bb1328,0x63de,0x4293,0x91,0x5b,0xa6,0xa2,0x3d,0x92,0x9a,0xcb,"PRINTER_EXTENSION_REASON_DRIVER_EVENT"); + IF_GUID_EQUAL_RETURN(guid,0xec8f261f,0x267c,0x469f,0xb5,0xd6,0x39,0x33,0x02,0x3c,0x29,0xcc,"PRINTER_EXTENSION_REASON_PRINT_PREFERENCES"); + IF_GUID_EQUAL_RETURN(guid,0x2ABAD223,0xB994,0x4aca,0x82,0xFC,0x45,0x71,0xB1,0xB5,0x85,0xAC,"PRINT_APP_BIDI_NOTIFY_CHANNEL"); + IF_GUID_EQUAL_RETURN(guid,0x25df3b0e,0x74a9,0x47f5,0x80,0xce,0x79,0xb4,0xb1,0xeb,0x5c,0x58,"PRINT_PORT_MONITOR_NOTIFY_CHANNEL"); + IF_GUID_EQUAL_RETURN(guid,0x180c072b,0xc27f,0x43c7,0x99,0x22,0xf6,0x35,0x62,0xa4,0x63,0x2b,"PROPID_ACC_DEFAULTACTION"); + IF_GUID_EQUAL_RETURN(guid,0x4d48dfe4,0xbd3f,0x491f,0xa6,0x48,0x49,0x2d,0x6f,0x20,0xc5,0x88,"PROPID_ACC_DESCRIPTION"); + IF_GUID_EQUAL_RETURN(guid,0x1ff1435f,0x8a14,0x477b,0xb2,0x26,0xa0,0xab,0xe2,0x79,0x97,0x5d,"PROPID_ACC_DESCRIPTIONMAP"); + IF_GUID_EQUAL_RETURN(guid,0x1ba09523,0x2e3b,0x49a6,0xa0,0x59,0x59,0x68,0x2a,0x3c,0x48,0xfd,"PROPID_ACC_DODEFAULTACTION"); + IF_GUID_EQUAL_RETURN(guid,0x6eb335df,0x1c29,0x4127,0xb1,0x2c,0xde,0xe9,0xfd,0x15,0x7f,0x2b,"PROPID_ACC_FOCUS"); + IF_GUID_EQUAL_RETURN(guid,0xc831e11f,0x44db,0x4a99,0x97,0x68,0xcb,0x8f,0x97,0x8b,0x72,0x31,"PROPID_ACC_HELP"); + IF_GUID_EQUAL_RETURN(guid,0x787d1379,0x8ede,0x440b,0x8a,0xec,0x11,0xf7,0xbf,0x90,0x30,0xb3,"PROPID_ACC_HELPTOPIC"); + IF_GUID_EQUAL_RETURN(guid,0x7d9bceee,0x7d1e,0x4979,0x93,0x82,0x51,0x80,0xf4,0x17,0x2c,0x34,"PROPID_ACC_KEYBOARDSHORTCUT"); + IF_GUID_EQUAL_RETURN(guid,0x608d3df8,0x8128,0x4aa7,0xa4,0x28,0xf5,0x5e,0x49,0x26,0x72,0x91,"PROPID_ACC_NAME"); + IF_GUID_EQUAL_RETURN(guid,0x031670ed,0x3cdf,0x48d2,0x96,0x13,0x13,0x8f,0x2d,0xd8,0xa6,0x68,"PROPID_ACC_NAV_DOWN"); + IF_GUID_EQUAL_RETURN(guid,0xcfd02558,0x557b,0x4c67,0x84,0xf9,0x2a,0x09,0xfc,0xe4,0x07,0x49,"PROPID_ACC_NAV_FIRSTCHILD"); + IF_GUID_EQUAL_RETURN(guid,0x302ecaa5,0x48d5,0x4f8d,0xb6,0x71,0x1a,0x8d,0x20,0xa7,0x78,0x32,"PROPID_ACC_NAV_LASTCHILD"); + IF_GUID_EQUAL_RETURN(guid,0x228086cb,0x82f1,0x4a39,0x87,0x05,0xdc,0xdc,0x0f,0xff,0x92,0xf5,"PROPID_ACC_NAV_LEFT"); + IF_GUID_EQUAL_RETURN(guid,0x1cdc5455,0x8cd9,0x4c92,0xa3,0x71,0x39,0x39,0xa2,0xfe,0x3e,0xee,"PROPID_ACC_NAV_NEXT"); + IF_GUID_EQUAL_RETURN(guid,0x776d3891,0xc73b,0x4480,0xb3,0xf6,0x07,0x6a,0x16,0xa1,0x5a,0xf6,"PROPID_ACC_NAV_PREV"); + IF_GUID_EQUAL_RETURN(guid,0xcd211d9f,0xe1cb,0x4fe5,0xa7,0x7c,0x92,0x0b,0x88,0x4d,0x09,0x5b,"PROPID_ACC_NAV_RIGHT"); + IF_GUID_EQUAL_RETURN(guid,0x016e1a2b,0x1a4e,0x4767,0x86,0x12,0x33,0x86,0xf6,0x69,0x35,0xec,"PROPID_ACC_NAV_UP"); + IF_GUID_EQUAL_RETURN(guid,0x474c22b6,0xffc2,0x467a,0xb1,0xb5,0xe9,0x58,0xb4,0x65,0x73,0x30,"PROPID_ACC_PARENT"); + IF_GUID_EQUAL_RETURN(guid,0xcb905ff2,0x7bd1,0x4c05,0xb3,0xc8,0xe6,0xc2,0x41,0x36,0x4d,0x70,"PROPID_ACC_ROLE"); + IF_GUID_EQUAL_RETURN(guid,0xf79acda2,0x140d,0x4fe6,0x89,0x14,0x20,0x84,0x76,0x32,0x82,0x69,"PROPID_ACC_ROLEMAP"); + IF_GUID_EQUAL_RETURN(guid,0xb99d073c,0xd731,0x405b,0x90,0x61,0xd9,0x5e,0x8f,0x84,0x29,0x84,"PROPID_ACC_SELECTION"); + IF_GUID_EQUAL_RETURN(guid,0xa8d4d5b0,0x0a21,0x42d0,0xa5,0xc0,0x51,0x4e,0x98,0x4f,0x45,0x7b,"PROPID_ACC_STATE"); + IF_GUID_EQUAL_RETURN(guid,0x43946c5e,0x0ac0,0x4042,0xb5,0x25,0x07,0xbb,0xdb,0xe1,0x7f,0xa7,"PROPID_ACC_STATEMAP"); + IF_GUID_EQUAL_RETURN(guid,0x123fe443,0x211a,0x4615,0x95,0x27,0xc4,0x5a,0x7e,0x93,0x71,0x7a,"PROPID_ACC_VALUE"); + IF_GUID_EQUAL_RETURN(guid,0xda1c3d79,0xfc5c,0x420e,0xb3,0x99,0x9d,0x15,0x33,0x54,0x9e,0x75,"PROPID_ACC_VALUEMAP"); + IF_GUID_EQUAL_RETURN(guid,0x5c2b3f5b,0x9182,0x42a3,0x8d,0xec,0x8c,0x04,0xc1,0xee,0x63,0x4d,"Pane_Control_GUID"); + IF_GUID_EQUAL_RETURN(guid,0x40499998,0x9c31,0x4245,0xa4,0x03,0x87,0x32,0x0e,0x59,0xea,0xf6,"ProcessId_Property_GUID"); + IF_GUID_EQUAL_RETURN(guid,0x228c9f86,0xc36c,0x47bb,0x9f,0xb6,0xa5,0x83,0x4b,0xfc,0x53,0xa4,"ProgressBar_Control_GUID"); + IF_GUID_EQUAL_RETURN(guid,0xdca5708a,0xc16b,0x4cd9,0xb8,0x89,0xbe,0xb1,0x6a,0x80,0x49,0x04,"ProviderDescription_Property_GUID"); + IF_GUID_EQUAL_RETURN(guid,0xe4cc08cb,0x942e,0x4b19,0x85,0x4,0xbd,0x5a,0x89,0xa7,0x47,0xf5,"RDCLIENT_BITMAP_RENDER_SERVICE"); + IF_GUID_EQUAL_RETURN(guid,0x6b59819a,0x5cae,0x492d,0xa9,0x01,0x2a,0x3c,0x2c,0x50,0x16,0x4f,"REAL_TIME_NOTIFICATION_CAPABILITY"); + IF_GUID_EQUAL_RETURN(guid,0xbc90d167,0x9470,0x4139,0xa9,0xba,0xbe,0x0b,0xbb,0xf5,0xb7,0x4d,"RPC_INTERFACE_EVENT_GUID"); + IF_GUID_EQUAL_RETURN(guid,0x3bdb49db,0xfe2c,0x4483,0xb3,0xe1,0xe5,0x7f,0x21,0x94,0x40,0xc6,"RadioButton_Control_GUID"); + IF_GUID_EQUAL_RETURN(guid,0x25fa1055,0xdebf,0x4373,0xa7,0x9e,0x1f,0x1a,0x19,0x08,0xd3,0xc4,"RangeValue_IsReadOnly_Property_GUID"); + IF_GUID_EQUAL_RETURN(guid,0xa1f96325,0x3a3d,0x4b44,0x8e,0x1f,0x4a,0x46,0xd9,0x84,0x40,0x19,"RangeValue_LargeChange_Property_GUID"); + IF_GUID_EQUAL_RETURN(guid,0x19319914,0xf979,0x4b35,0xa1,0xa6,0xd3,0x7e,0x05,0x43,0x34,0x73,"RangeValue_Maximum_Property_GUID"); + IF_GUID_EQUAL_RETURN(guid,0x78cbd3b2,0x684d,0x4860,0xaf,0x93,0xd1,0xf9,0x5c,0xb0,0x22,0xfd,"RangeValue_Minimum_Property_GUID"); + IF_GUID_EQUAL_RETURN(guid,0x18b00d87,0xb1c9,0x476a,0xbf,0xbd,0x5f,0x0b,0xdb,0x92,0x6f,0x63,"RangeValue_Pattern_GUID"); + IF_GUID_EQUAL_RETURN(guid,0x81c2c457,0x3941,0x4107,0x99,0x75,0x13,0x97,0x60,0xf7,0xc0,0x72,"RangeValue_SmallChange_Property_GUID"); + IF_GUID_EQUAL_RETURN(guid,0x131f5d98,0xc50c,0x489d,0xab,0xe5,0xae,0x22,0x08,0x98,0xc5,0xf7,"RangeValue_Value_Property_GUID"); + IF_GUID_EQUAL_RETURN(guid,0xa39eebfa,0x7fba,0x4c89,0xb4,0xd4,0xb9,0x9e,0x2d,0xe7,0xd1,0x60,"RuntimeId_Property_GUID"); + IF_GUID_EQUAL_RETURN(guid,0x2313a4ed,0xbf2d,0x454f,0xad,0x8a,0xd9,0x5b,0xa7,0xf9,0x1f,0xee,"SBE2_STREAM_DESC_EVENT"); + IF_GUID_EQUAL_RETURN(guid,0xfcf09,0x97f5,0x46ac,0x97,0x69,0x7a,0x83,0xb3,0x53,0x84,0xfb,"SBE2_V1_STREAMS_CREATION_EVENT"); + IF_GUID_EQUAL_RETURN(guid,0xa72530a3,0x344,0x4cab,0xa2,0xd0,0xfe,0x93,0x7d,0xbd,0xca,0xb3,"SBE2_V2_STREAMS_CREATION_EVENT"); + IF_GUID_EQUAL_RETURN(guid,0x86248cc9,0x4a59,0x43e2,0x91,0x46,0x48,0xa7,0xf3,0xf4,0x14,0xc,"SCP_EVENTID_ACQSECURECLOCK"); + IF_GUID_EQUAL_RETURN(guid,0x213dd287,0x41d2,0x432b,0x9e,0x3f,0x3b,0x4f,0x7b,0x35,0x81,0xdd,"SCP_EVENTID_DRMINFO"); + IF_GUID_EQUAL_RETURN(guid,0x87a507c7,0xb469,0x4386,0xb9,0x76,0xd5,0xd1,0xce,0x53,0x8a,0x6f,"SCP_EVENTID_NEEDTOINDIV"); + IF_GUID_EQUAL_RETURN(guid,0x41d0155d,0x7cc7,0x4217,0xad,0xa9,0x00,0x50,0x74,0x62,0x4d,0xa4,"SCP_PARAMID_DRMVERSION"); + IF_GUID_EQUAL_RETURN(guid,0xf4791d68,0xe254,0x4ba3,0x9a,0x53,0x26,0xa5,0xc5,0x49,0x79,0x46,"SID_ControlElementProvider"); + IF_GUID_EQUAL_RETURN(guid,0xfaadfc40,0xb777,0x4b69,0xaa,0x81,0x77,0x03,0x5e,0xf0,0xe6,0xe8,"SID_CtxQueryAssociations"); + IF_GUID_EQUAL_RETURN(guid,0xC4C4C4C4,0x0049,0x4E2B,0x98,0xFB,0x95,0x37,0xF6,0xCE,0x51,0x6D,"SID_DRMSecureServiceChannel"); + IF_GUID_EQUAL_RETURN(guid,0xf59aa553,0x8309,0x46ca,0x97,0x36,0x1a,0xc3,0xc6,0x2d,0x60,0x31,"SID_DeviceDisplayStatusManager"); + IF_GUID_EQUAL_RETURN(guid,0x13e0e9e2,0xc3fa,0x4e3c,0x90,0x6e,0x64,0x50,0x2f,0xa4,0xdc,0x95,"SID_EnumDeviceFunction"); + IF_GUID_EQUAL_RETURN(guid,0x40eab0b9,0x4d7f,0x4b53,0xa3,0x34,0x15,0x81,0xdd,0x90,0x41,0xf4,"SID_EnumInterface"); + IF_GUID_EQUAL_RETURN(guid,0x383b69fa,0x5486,0x49da,0x91,0xf5,0xd6,0x3c,0x24,0xc8,0xe9,0xd0,"SID_FDPairingHandler"); + IF_GUID_EQUAL_RETURN(guid,0x2b4cbdc9,0x31c4,0x40d4,0xa6,0x2d,0x77,0x2a,0xa1,0x74,0xed,0x52,"SID_FunctionDiscoveryProviderRefresh"); + IF_GUID_EQUAL_RETURN(guid,0x4717cc40,0xbcb9,0x11d0,0x93,0x36,0x0,0xa0,0xc9,0xd,0xca,0xa9,"SID_GetCaller"); + IF_GUID_EQUAL_RETURN(guid,0xb96fdb85,0x7204,0x4724,0x84,0x2b,0xc7,0x05,0x9d,0xed,0xb9,0xd0,"SID_IsUIAutomationObject"); + IF_GUID_EQUAL_RETURN(guid,0xcf9a88f4,0xabcf,0x4ed8,0x9b,0x74,0x7d,0xb3,0x34,0x45,0x45,0x9e,"SID_MSVidCtl_CurrentAudioEndpoint"); + IF_GUID_EQUAL_RETURN(guid,0xa6c17eb4,0x2d65,0x11d2,0x83,0x8f,0x0,0xc0,0x4f,0xd9,0x18,0xd0,"SID_MenuShellFolder"); + IF_GUID_EQUAL_RETURN(guid,0xcee8ccc9,0x4f6b,0x4469,0xa2,0x35,0x5a,0x22,0x86,0x9e,0xef,0x03,"SID_PNPXAssociation"); + IF_GUID_EQUAL_RETURN(guid,0xa86530b1,0x542f,0x439f,0xB7,0x1c,0xb0,0x75,0x6b,0x13,0x67,0x7a,"SID_PNPXPropertyStore"); + IF_GUID_EQUAL_RETURN(guid,0x439e80ee,0xa217,0x4712,0x9f,0xa6,0xde,0xab,0xd9,0xc2,0xa7,0x27,"SID_PNPXServiceCollection"); + IF_GUID_EQUAL_RETURN(guid,0x8101368e,0xcabb,0x4426,0xac,0xff,0x96,0xc4,0x10,0x81,0x20,0x00,"SID_PnpProvider"); + IF_GUID_EQUAL_RETURN(guid,0x74a5040c,0xdd0c,0x48f0,0xac,0x85,0x19,0x4c,0x32,0x59,0x18,0xa,"SID_ProvideRuntimeContext"); + IF_GUID_EQUAL_RETURN(guid,0x80f30233,0xb7df,0x11d2,0xa3,0x3b,0x0,0x60,0x97,0xdf,0x5b,0xd4,"SID_SCommDlgBrowser"); + IF_GUID_EQUAL_RETURN(guid,0xB99EAA5C,0x3850,0x4400,0xBC,0x33,0x2C,0xE5,0x34,0x04,0x8B,0xF8,"SID_SCommandBarState"); + IF_GUID_EQUAL_RETURN(guid,0x3050f4b5,0x98b5,0x11cf,0xbb,0x82,0x00,0xaa,0x00,0xbd,0xce,0x0b,"SID_SEditCommandTarget"); + IF_GUID_EQUAL_RETURN(guid,0x889A935D,0x971E,0x4B12,0xB9,0x0C,0x24,0xDF,0xC9,0xE1,0xE5,0xE8,"SID_SGetViewFromViewDual"); + IF_GUID_EQUAL_RETURN(guid,0x3050f6a0,0x98b5,0x11cf,0xbb,0x82,0x00,0xaa,0x00,0xbd,0xce,0x0b,"SID_SHTMLEditHost"); + IF_GUID_EQUAL_RETURN(guid,0x3050f7f9,0x98b5,0x11cf,0xbb,0x82,0x00,0xaa,0x00,0xbd,0xce,0x0b,"SID_SHTMLEditServices"); + IF_GUID_EQUAL_RETURN(guid,0x164bbd86,0x1d0d,0x4de0,0x9a,0x3b,0xd9,0x72,0x96,0x47,0xc2,0xb8,"SID_SMenuBandBKContextMenu"); + IF_GUID_EQUAL_RETURN(guid,0x743ca664,0xdeb,0x11d1,0x98,0x25,0x0,0xc0,0x4f,0xd9,0x19,0x72,"SID_SMenuBandBottom"); + IF_GUID_EQUAL_RETURN(guid,0x165ebaf4,0x6d51,0x11d2,0x83,0xad,0x0,0xc0,0x4f,0xd9,0x18,0xd0,"SID_SMenuBandBottomSelected"); + IF_GUID_EQUAL_RETURN(guid,0xed9cc020,0x8b9,0x11d1,0x98,0x23,0x0,0xc0,0x4f,0xd9,0x19,0x72,"SID_SMenuBandChild"); + IF_GUID_EQUAL_RETURN(guid,0x39545874,0x7162,0x465e,0xb7,0x83,0x2a,0xa1,0x87,0x4f,0xef,0x81,"SID_SMenuBandContextMenuModifier"); + IF_GUID_EQUAL_RETURN(guid,0x8c278eec,0x3eab,0x11d1,0x8c,0xb0,0x0,0xc0,0x4f,0xd9,0x18,0xd0,"SID_SMenuBandParent"); + IF_GUID_EQUAL_RETURN(guid,0x9493a810,0xec38,0x11d0,0xbc,0x46,0x0,0xaa,0x0,0x6c,0xe2,0xf5,"SID_SMenuBandTop"); + IF_GUID_EQUAL_RETURN(guid,0xD1E7AFEB,0x6A2E,0x11d0,0x8C,0x78,0x0,0xC0,0x4F,0xD9,0x18,0xB4,"SID_SMenuPopup"); + IF_GUID_EQUAL_RETURN(guid,0x4C96BE40L,0x915C,0x11CF,0x99,0xD3,0x00,0xAA,0x00,0x4A,0xE8,0x37,"SID_STopLevelBrowser"); + IF_GUID_EQUAL_RETURN(guid,0x49e1b500,0x4636,0x11d3,0x97,0xf7,0x0,0xc0,0x4f,0x45,0xd0,0xb3,"SID_STopWindow"); + IF_GUID_EQUAL_RETURN(guid,0xeb84ada2,0x00ff,0x4992,0x83,0x24,0xed,0x5c,0xe0,0x61,0xcb,0x29,"SID_ShellExecuteNamedPropertyStore"); + IF_GUID_EQUAL_RETURN(guid,0x0D0D66EB,0xCF74,0x4164,0xB5,0x2F,0x08,0x34,0x46,0x72,0xDD,0x46,"SID_UPnPActivator"); + IF_GUID_EQUAL_RETURN(guid,0xc920566e,0x5671,0x4496,0x80,0x25,0xbf,0x0b,0x89,0xbd,0x44,0xcd,"SID_UninstallDeviceFunction"); + IF_GUID_EQUAL_RETURN(guid,0x89A502FC,0x857B,0x4698,0xA0,0xB7,0x02,0x71,0x92,0x00,0x2F,0x9E,"SID_UnpairProvider"); + IF_GUID_EQUAL_RETURN(guid,0x1f101481,0xbccd,0x11d0,0x93,0x36,0x0,0xa0,0xc9,0xd,0xca,0xa9,"SID_VariantConversion"); + IF_GUID_EQUAL_RETURN(guid,0xaec2ef9c,0x3a4d,0x4d3e,0x88,0x42,0x23,0x99,0x42,0xe3,0x9a,0x47,"SOCKET_DEFAULT2_QM_POLICY"); + IF_GUID_EQUAL_RETURN(guid,0x4c437b92,0x6e9e,0x11d1,0xa7,0x4,0x0,0x60,0x97,0xc4,0xe4,0x76,"SPECIFYPAGES_STATISTICS"); + IF_GUID_EQUAL_RETURN(guid,0xc2239ce6,0x00c0,0x4fbf,0xba,0xd6,0x18,0x13,0x93,0x85,0xa4,0x9a,"SVCID_PNRPCLOUD"); + IF_GUID_EQUAL_RETURN(guid,0xc2239ce5,0x00c0,0x4fbf,0xba,0xd6,0x18,0x13,0x93,0x85,0xa4,0x9a,"SVCID_PNRPNAME_V1"); + IF_GUID_EQUAL_RETURN(guid,0xc2239ce7,0x00c0,0x4fbf,0xba,0xd6,0x18,0x13,0x93,0x85,0xa4,0x9a,"SVCID_PNRPNAME_V2"); + IF_GUID_EQUAL_RETURN(guid,0x57cbb584,0xe9b4,0x47ae,0xa1,0x20,0xc4,0xdf,0x33,0x35,0xde,0xe2,"SYNCMGR_OBJECTID_BrowseContent"); + IF_GUID_EQUAL_RETURN(guid,0xd78181f4,0x2389,0x47e4,0xa9,0x60,0x60,0xbc,0xc2,0xed,0x93,0xb,"SYNCMGR_OBJECTID_ConflictStore"); + IF_GUID_EQUAL_RETURN(guid,0x2203bdc1,0x1af1,0x4082,0x8c,0x30,0x28,0x39,0x9f,0x41,0x38,0x4c,"SYNCMGR_OBJECTID_EventLinkClick"); + IF_GUID_EQUAL_RETURN(guid,0x4bef34b9,0xa786,0x4075,0xba,0x88,0xc,0x2b,0x9d,0x89,0xa9,0x8f,"SYNCMGR_OBJECTID_EventStore"); + IF_GUID_EQUAL_RETURN(guid,0x6dbc85c3,0x5d07,0x4c72,0xa7,0x77,0x7f,0xec,0x78,0x7,0x2c,0x6,"SYNCMGR_OBJECTID_Icon"); + IF_GUID_EQUAL_RETURN(guid,0xd882d80b,0xe7aa,0x49ed,0x86,0xb7,0xe6,0xe1,0xf7,0x14,0xcd,0xfe,"SYNCMGR_OBJECTID_QueryBeforeActivate"); + IF_GUID_EQUAL_RETURN(guid,0xa0efc282,0x60e0,0x460e,0x93,0x74,0xea,0x88,0x51,0x3c,0xfc,0x80,"SYNCMGR_OBJECTID_QueryBeforeDeactivate"); + IF_GUID_EQUAL_RETURN(guid,0xf76c3397,0xafb3,0x45d7,0xa5,0x9f,0x5a,0x49,0xe9,0x5,0x43,0x7e,"SYNCMGR_OBJECTID_QueryBeforeDelete"); + IF_GUID_EQUAL_RETURN(guid,0xbb5f64aa,0xf004,0x4eb5,0x8e,0x4d,0x26,0x75,0x19,0x66,0x34,0x4c,"SYNCMGR_OBJECTID_QueryBeforeDisable"); + IF_GUID_EQUAL_RETURN(guid,0x4cbf7f0,0x5beb,0x4de1,0xbc,0x90,0x90,0x83,0x45,0xc4,0x80,0xf6,"SYNCMGR_OBJECTID_QueryBeforeEnable"); + IF_GUID_EQUAL_RETURN(guid,0xedc6f3e3,0x8441,0x4109,0xad,0xf3,0x6c,0x1c,0xa0,0xb7,0xde,0x47,"SYNCMGR_OBJECTID_ShowSchedule"); + IF_GUID_EQUAL_RETURN(guid,0xdaf34b36,0x5065,0x4946,0xb2,0x2f,0x92,0x59,0x5f,0xc0,0x75,0x1a,"ScrollBar_Control_GUID"); + IF_GUID_EQUAL_RETURN(guid,0x4591d005,0xa803,0x4d5c,0xb4,0xd5,0x8d,0x28,0x00,0xf9,0x06,0xa7,"ScrollItem_Pattern_GUID"); + IF_GUID_EQUAL_RETURN(guid,0xc7c13c0e,0xeb21,0x47ff,0xac,0xc4,0xb5,0xa3,0x35,0x0f,0x51,0x91,"Scroll_HorizontalScrollPercent_Property_GUID"); + IF_GUID_EQUAL_RETURN(guid,0x70c2e5d4,0xfcb0,0x4713,0xa9,0xaa,0xaf,0x92,0xff,0x79,0xe4,0xcd,"Scroll_HorizontalViewSize_Property_GUID"); + IF_GUID_EQUAL_RETURN(guid,0x8b925147,0x28cd,0x49ae,0xbd,0x63,0xf4,0x41,0x18,0xd2,0xe7,0x19,"Scroll_HorizontallyScrollable_Property_GUID"); + IF_GUID_EQUAL_RETURN(guid,0x895fa4b4,0x759d,0x4c50,0x8e,0x15,0x03,0x46,0x06,0x72,0x00,0x3c,"Scroll_Pattern_GUID"); + IF_GUID_EQUAL_RETURN(guid,0x6c8d7099,0xb2a8,0x4948,0xbf,0xf7,0x3c,0xf9,0x05,0x8b,0xfe,0xfb,"Scroll_VerticalScrollPercent_Property_GUID"); + IF_GUID_EQUAL_RETURN(guid,0xde6a2e22,0xd8c7,0x40c5,0x83,0xba,0xe5,0xf6,0x81,0xd5,0x31,0x08,"Scroll_VerticalViewSize_Property_GUID"); + IF_GUID_EQUAL_RETURN(guid,0x89164798,0x0068,0x4315,0xb8,0x9a,0x1e,0x7c,0xfb,0xbc,0x3d,0xfc,"Scroll_VerticallyScrollable_Property_GUID"); + IF_GUID_EQUAL_RETURN(guid,0x8fe316d2,0xe52,0x460a,0x9c,0x1e,0x48,0xf2,0x73,0xd4,0x70,0xa3,"SelectedItemCount_Property_GUID"); + IF_GUID_EQUAL_RETURN(guid,0x3c822dd1,0xc407,0x4dba,0x91,0xdd,0x79,0xd4,0xae,0xd0,0xae,0xc6,"SelectionItem_ElementAddedToSelectionEvent_Event_GUID"); + IF_GUID_EQUAL_RETURN(guid,0x097fa8a9,0x7079,0x41af,0x8b,0x9c,0x09,0x34,0xd8,0x30,0x5e,0x5c,"SelectionItem_ElementRemovedFromSelectionEvent_Event_GUID"); + IF_GUID_EQUAL_RETURN(guid,0xb9c7dbfb,0x4ebe,0x4532,0xaa,0xf4,0x00,0x8c,0xf6,0x47,0x23,0x3c,"SelectionItem_ElementSelectedEvent_Event_GUID"); + IF_GUID_EQUAL_RETURN(guid,0xf122835f,0xcd5f,0x43df,0xb7,0x9d,0x4b,0x84,0x9e,0x9e,0x60,0x20,"SelectionItem_IsSelected_Property_GUID"); + IF_GUID_EQUAL_RETURN(guid,0x9bc64eeb,0x87c7,0x4b28,0x94,0xbb,0x4d,0x9f,0xa4,0x37,0xb6,0xef,"SelectionItem_Pattern_GUID"); + IF_GUID_EQUAL_RETURN(guid,0xa4365b6e,0x9c1e,0x4b63,0x8b,0x53,0xc2,0x42,0x1d,0xd1,0xe8,0xfb,"SelectionItem_SelectionContainer_Property_GUID"); + IF_GUID_EQUAL_RETURN(guid,0x49d73da5,0xc883,0x4500,0x88,0x3d,0x8f,0xcf,0x8d,0xaf,0x6c,0xbe,"Selection_CanSelectMultiple_Property_GUID"); + IF_GUID_EQUAL_RETURN(guid,0xcac14904,0x16b4,0x4b53,0x8e,0x47,0x4c,0xb1,0xdf,0x26,0x7b,0xb7,"Selection_InvalidatedEvent_Event_GUID"); + IF_GUID_EQUAL_RETURN(guid,0xb1ae4422,0x63fe,0x44e7,0xa5,0xa5,0xa7,0x38,0xc8,0x29,0xb1,0x9a,"Selection_IsSelectionRequired_Property_GUID"); + IF_GUID_EQUAL_RETURN(guid,0x66e3b7e8,0xd821,0x4d25,0x87,0x61,0x43,0x5d,0x2c,0x8b,0x25,0x3f,"Selection_Pattern_GUID"); + IF_GUID_EQUAL_RETURN(guid,0xaa6dc2a2,0x0e2b,0x4d38,0x96,0xd5,0x34,0xe4,0x70,0xb8,0x18,0x53,"Selection_Selection_Property_GUID"); + IF_GUID_EQUAL_RETURN(guid,0x5fd34a43,0x061e,0x42c8,0xb5,0x89,0x9d,0xcc,0xf7,0x4b,0xc4,0x3a,"SemanticZoom_Control_GUID"); + IF_GUID_EQUAL_RETURN(guid,0x8767eba3,0x2a63,0x4ab0,0xac,0x8d,0xaa,0x50,0xe2,0x3d,0xe9,0x78,"Separator_Control_GUID"); + IF_GUID_EQUAL_RETURN(guid,0xb033c24b,0x3b35,0x4cea,0xb6,0x09,0x76,0x36,0x82,0xfa,0x66,0x0b,"Slider_Control_GUID"); + IF_GUID_EQUAL_RETURN(guid,0x60cc4b38,0x3cb1,0x4161,0xb4,0x42,0xc6,0xb7,0x26,0xc1,0x78,0x25,"Spinner_Control_GUID"); + IF_GUID_EQUAL_RETURN(guid,0x7011f01f,0x4ace,0x4901,0xb4,0x61,0x92,0x0a,0x6f,0x1c,0xa6,0x50,"SplitButton_Control_GUID"); + IF_GUID_EQUAL_RETURN(guid,0xa3194c38,0xc9bc,0x4604,0x93,0x96,0xae,0x3f,0x9f,0x45,0x7f,0x7b,"SpreadsheetItem_AnnotationObjects_Property_GUID"); + IF_GUID_EQUAL_RETURN(guid,0xc70c51d0,0xd602,0x4b45,0xaf,0xbc,0xb4,0x71,0x2b,0x96,0xd7,0x2b,"SpreadsheetItem_AnnotationTypes_Property_GUID"); + IF_GUID_EQUAL_RETURN(guid,0xe602e47d,0x1b47,0x4bea,0x87,0xcf,0x3b,0x0b,0x0b,0x5c,0x15,0xb6,"SpreadsheetItem_Formula_Property_GUID"); + IF_GUID_EQUAL_RETURN(guid,0x32cf83ff,0xf1a8,0x4a8c,0x86,0x58,0xd4,0x7b,0xa7,0x4e,0x20,0xba,"SpreadsheetItem_Pattern_GUID"); + IF_GUID_EQUAL_RETURN(guid,0x6a5b24c9,0x9d1e,0x4b85,0x9e,0x44,0xc0,0x2e,0x31,0x69,0xb1,0x0b,"Spreadsheet_Pattern_GUID"); + IF_GUID_EQUAL_RETURN(guid,0xd45e7d1b,0x5873,0x475f,0x95,0xa4,0x04,0x33,0xe1,0xf1,0xb0,0x0a,"StatusBar_Control_GUID"); + IF_GUID_EQUAL_RETURN(guid,0x59977961,0x3edd,0x4b11,0xb1,0x3b,0x67,0x6b,0x2a,0x2a,0x6c,0xa9,"StructureChanged_Event_GUID"); + IF_GUID_EQUAL_RETURN(guid,0xf451cda0,0xba0a,0x4681,0xb0,0xb0,0x0d,0xbd,0xb5,0x3e,0x58,0xf3,"Styles_ExtendedProperties_Property_GUID"); + IF_GUID_EQUAL_RETURN(guid,0x63eff97a,0xa1c5,0x4b1d,0x84,0xeb,0xb7,0x65,0xf2,0xed,0xd6,0x32,"Styles_FillColor_Property_GUID"); + IF_GUID_EQUAL_RETURN(guid,0x939a59fe,0x8fbd,0x4e75,0xa2,0x71,0xac,0x45,0x95,0x19,0x51,0x63,"Styles_FillPatternColor_Property_GUID"); + IF_GUID_EQUAL_RETURN(guid,0x81cf651f,0x482b,0x4451,0xa3,0x0a,0xe1,0x54,0x5e,0x55,0x4f,0xb8,"Styles_FillPatternStyle_Property_GUID"); + IF_GUID_EQUAL_RETURN(guid,0x1ae62655,0xda72,0x4d60,0xa1,0x53,0xe5,0xaa,0x69,0x88,0xe3,0xbf,"Styles_Pattern_GUID"); + IF_GUID_EQUAL_RETURN(guid,0xc71a23f8,0x778c,0x400d,0x84,0x58,0x3b,0x54,0x3e,0x52,0x69,0x84,"Styles_Shape_Property_GUID"); + IF_GUID_EQUAL_RETURN(guid,0xda82852f,0x3817,0x4233,0x82,0xaf,0x02,0x27,0x9e,0x72,0xcc,0x77,"Styles_StyleId_Property_GUID"); + IF_GUID_EQUAL_RETURN(guid,0x1c12b035,0x05d1,0x4f55,0x9e,0x8e,0x14,0x89,0xf3,0xff,0x55,0x0d,"Styles_StyleName_Property_GUID"); + IF_GUID_EQUAL_RETURN(guid,0x05c288a6,0xc47b,0x488b,0xb6,0x53,0x33,0x97,0x7a,0x55,0x1b,0x8b,"SynchronizedInput_Pattern_GUID"); + IF_GUID_EQUAL_RETURN(guid,0xd271545d,0x7a3a,0x47a7,0x84,0x74,0x81,0xd2,0x9a,0x24,0x51,0xc9,"SystemAlert_Event_GUID"); + IF_GUID_EQUAL_RETURN(guid,0xD38EFF65,0xAA46,0x4FD5,0x91,0xA7,0x67,0x84,0x5F,0xB0,0x2F,0x5B,"TF_PROFILE_ARRAY"); + IF_GUID_EQUAL_RETURN(guid,0x0AEC109C,0x7E96,0x11D4,0xB2,0xEF,0x00,0x80,0xC8,0x82,0x68,0x7E,"TF_PROFILE_CANTONESE"); + IF_GUID_EQUAL_RETURN(guid,0x4BDF9F03,0xC7D3,0x11D4,0xB2,0xAB,0x00,0x80,0xC8,0x82,0x68,0x7E,"TF_PROFILE_CHANGJIE"); + IF_GUID_EQUAL_RETURN(guid,0x037B2C25,0x480C,0x4D7F,0xB0,0x27,0xD6,0xCA,0x6B,0x69,0x78,0x8A,"TF_PROFILE_DAYI"); + IF_GUID_EQUAL_RETURN(guid,0xF3BA907A,0x6C7E,0x11D4,0x97,0xFA,0x00,0x80,0xC8,0x82,0x68,0x7E,"TF_PROFILE_NEWCHANGJIE"); + IF_GUID_EQUAL_RETURN(guid,0xB2F9C502,0x1742,0x11D4,0x97,0x90,0x00,0x80,0xC8,0x82,0x68,0x7E,"TF_PROFILE_NEWPHONETIC"); + IF_GUID_EQUAL_RETURN(guid,0x0B883BA0,0xC1C7,0x11D4,0x87,0xF9,0x00,0x80,0xC8,0x82,0x68,0x7E,"TF_PROFILE_NEWQUICK"); + IF_GUID_EQUAL_RETURN(guid,0x761309DE,0x317A,0x11D4,0x9B,0x5D,0x00,0x80,0xC8,0x82,0x68,0x7E,"TF_PROFILE_PHONETIC"); + IF_GUID_EQUAL_RETURN(guid,0xF3BA9077,0x6C7E,0x11D4,0x97,0xFA,0x00,0x80,0xC8,0x82,0x68,0x7E,"TF_PROFILE_PINYIN"); + IF_GUID_EQUAL_RETURN(guid,0x6024B45F,0x5C54,0x11D4,0xB9,0x21,0x00,0x80,0xC8,0x82,0x68,0x7E,"TF_PROFILE_QUICK"); + IF_GUID_EQUAL_RETURN(guid,0xFA550B04,0x5AD7,0x411F,0xA5,0xAC,0xCA,0x03,0x8E,0xC5,0x15,0xD7,"TF_PROFILE_SIMPLEFAST"); + IF_GUID_EQUAL_RETURN(guid,0x3CAB88B7,0xCC3E,0x46A6,0x97,0x65,0xB7,0x72,0xAD,0x77,0x61,0xFF,"TF_PROFILE_TIGRINYA"); + IF_GUID_EQUAL_RETURN(guid,0x409C8376,0x007B,0x4357,0xAE,0x8E,0x26,0x31,0x6E,0xE3,0xFB,0x0D,"TF_PROFILE_YI"); + IF_GUID_EQUAL_RETURN(guid,0x7b785571,0x8c82,0x11cf,0xbc,0xc,0x0,0xaa,0x0,0xac,0x74,0xf6,"TIME_FORMAT_BYTE"); + IF_GUID_EQUAL_RETURN(guid,0x7b785573,0x8c82,0x11cf,0xbc,0xc,0x0,0xaa,0x0,0xac,0x74,0xf6,"TIME_FORMAT_FIELD"); + IF_GUID_EQUAL_RETURN(guid,0x7b785570,0x8c82,0x11cf,0xbc,0xc,0x0,0xaa,0x0,0xac,0x74,0xf6,"TIME_FORMAT_FRAME"); + IF_GUID_EQUAL_RETURN(guid,0x7b785574,0x8c82,0x11cf,0xbc,0xc,0x0,0xaa,0x0,0xac,0x74,0xf6,"TIME_FORMAT_MEDIA_TIME"); + IF_GUID_EQUAL_RETURN(guid,0L,0,0,0,0,0,0,0,0,0,0,"TIME_FORMAT_NONE"); + IF_GUID_EQUAL_RETURN(guid,0x7b785572,0x8c82,0x11cf,0xbc,0xc,0x0,0xaa,0x0,0xac,0x74,0xf6,"TIME_FORMAT_SAMPLE"); + IF_GUID_EQUAL_RETURN(guid,0x2c6a634f,0x921b,0x4e6e,0xb2,0x6e,0x08,0xfc,0xb0,0x79,0x8f,0x4c,"TabItem_Control_GUID"); + IF_GUID_EQUAL_RETURN(guid,0x38cd1f2d,0x337a,0x4bd2,0xa5,0xe3,0xad,0xb4,0x69,0xe3,0x0b,0xd3,"Tab_Control_GUID"); + IF_GUID_EQUAL_RETURN(guid,0x967a56a3,0x74b6,0x431e,0x8d,0xe6,0x99,0xc4,0x11,0x03,0x1c,0x58,"TableItem_ColumnHeaderItems_Property_GUID"); + IF_GUID_EQUAL_RETURN(guid,0xdf1343bd,0x1888,0x4a29,0xa5,0x0c,0xb9,0x2e,0x6d,0xe3,0x7f,0x6f,"TableItem_Pattern_GUID"); + IF_GUID_EQUAL_RETURN(guid,0xb3f853a0,0x0574,0x4cd8,0xbc,0xd7,0xed,0x59,0x23,0x57,0x2d,0x97,"TableItem_RowHeaderItems_Property_GUID"); + IF_GUID_EQUAL_RETURN(guid,0xaff1d72b,0x968d,0x42b1,0xb4,0x59,0x15,0x0b,0x29,0x9d,0xa6,0x64,"Table_ColumnHeaders_Property_GUID"); + IF_GUID_EQUAL_RETURN(guid,0x773bfa0e,0x5bc4,0x4deb,0x92,0x1b,0xde,0x7b,0x32,0x06,0x22,0x9e,"Table_Control_GUID"); + IF_GUID_EQUAL_RETURN(guid,0xc415218e,0xa028,0x461e,0xaa,0x92,0x8f,0x92,0x5c,0xf7,0x93,0x51,"Table_Pattern_GUID"); + IF_GUID_EQUAL_RETURN(guid,0xd9e35b87,0x6eb8,0x4562,0xaa,0xc6,0xa8,0xa9,0x07,0x52,0x36,0xa8,"Table_RowHeaders_Property_GUID"); + IF_GUID_EQUAL_RETURN(guid,0x83be75c3,0x29fe,0x4a30,0x85,0xe1,0x2a,0x62,0x77,0xfd,0x10,0x6e,"Table_RowOrColumnMajor_Property_GUID"); + IF_GUID_EQUAL_RETURN(guid,0x7533cab7,0x3bfe,0x41ef,0x9e,0x85,0xe2,0x63,0x8c,0xbe,0x16,0x9e,"TextChild_Pattern_GUID"); + IF_GUID_EQUAL_RETURN(guid,0x628209f0,0x7c9a,0x4d57,0xbe,0x64,0x1f,0x18,0x36,0x57,0x1f,0xf5,"Text_AnimationStyle_Attribute_GUID"); + IF_GUID_EQUAL_RETURN(guid,0xff41cf68,0xe7ab,0x40b9,0x8c,0x72,0x72,0xa8,0xed,0x94,0x01,0x7d,"Text_AnnotationObjects_Attribute_GUID"); + IF_GUID_EQUAL_RETURN(guid,0xad2eb431,0xee4e,0x4be1,0xa7,0xba,0x55,0x59,0x15,0x5a,0x73,0xef,"Text_AnnotationTypes_Attribute_GUID"); + IF_GUID_EQUAL_RETURN(guid,0xfdc49a07,0x583d,0x4f17,0xad,0x27,0x77,0xfc,0x83,0x2a,0x3c,0x0b,"Text_BackgroundColor_Attribute_GUID"); + IF_GUID_EQUAL_RETURN(guid,0xc1097c90,0xd5c4,0x4237,0x97,0x81,0x3b,0xec,0x8b,0xa5,0x4e,0x48,"Text_BulletStyle_Attribute_GUID"); + IF_GUID_EQUAL_RETURN(guid,0xfb059c50,0x92cc,0x49a5,0xba,0x8f,0x0a,0xa8,0x72,0xbb,0xa2,0xf3,"Text_CapStyle_Attribute_GUID"); + IF_GUID_EQUAL_RETURN(guid,0x929ee7a6,0x51d3,0x4715,0x96,0xdc,0xb6,0x94,0xfa,0x24,0xa1,0x68,"Text_CaretBidiMode_Attribute_GUID"); + IF_GUID_EQUAL_RETURN(guid,0xb227b131,0x9889,0x4752,0xa9,0x1b,0x73,0x3e,0xfd,0xc5,0xc5,0xa0,"Text_CaretPosition_Attribute_GUID"); + IF_GUID_EQUAL_RETURN(guid,0xae9772dc,0xd331,0x4f09,0xbe,0x20,0x7e,0x6d,0xfa,0xf0,0x7b,0x0a,"Text_Control_GUID"); + IF_GUID_EQUAL_RETURN(guid,0xc2025af9,0xa42d,0x4ced,0xa1,0xfb,0xc6,0x74,0x63,0x15,0x22,0x2e,"Text_Culture_Attribute_GUID"); + IF_GUID_EQUAL_RETURN(guid,0x64e63ba8,0xf2e5,0x476e,0xa4,0x77,0x17,0x34,0xfe,0xaa,0xf7,0x26,"Text_FontName_Attribute_GUID"); + IF_GUID_EQUAL_RETURN(guid,0xdc5eeeff,0x0506,0x4673,0x93,0xf2,0x37,0x7e,0x4a,0x8e,0x01,0xf1,"Text_FontSize_Attribute_GUID"); + IF_GUID_EQUAL_RETURN(guid,0x6fc02359,0xb316,0x4f5f,0xb4,0x01,0xf1,0xce,0x55,0x74,0x18,0x53,"Text_FontWeight_Attribute_GUID"); + IF_GUID_EQUAL_RETURN(guid,0x72d1c95d,0x5e60,0x471a,0x96,0xb1,0x6c,0x1b,0x3b,0x77,0xa4,0x36,"Text_ForegroundColor_Attribute_GUID"); + IF_GUID_EQUAL_RETURN(guid,0x04ea6161,0xfba3,0x477a,0x95,0x2a,0xbb,0x32,0x6d,0x02,0x6a,0x5b,"Text_HorizontalTextAlignment_Attribute_GUID"); + IF_GUID_EQUAL_RETURN(guid,0x206f9ad5,0xc1d3,0x424a,0x81,0x82,0x6d,0xa9,0xa7,0xf3,0xd6,0x32,"Text_IndentationFirstLine_Attribute_GUID"); + IF_GUID_EQUAL_RETURN(guid,0x5cf66bac,0x2d45,0x4a4b,0xb6,0xc9,0xf7,0x22,0x1d,0x28,0x15,0xb0,"Text_IndentationLeading_Attribute_GUID"); + IF_GUID_EQUAL_RETURN(guid,0x97ff6c0f,0x1ce4,0x408a,0xb6,0x7b,0x94,0xd8,0x3e,0xb6,0x9b,0xf2,"Text_IndentationTrailing_Attribute_GUID"); + IF_GUID_EQUAL_RETURN(guid,0xf5a4e533,0xe1b8,0x436b,0x93,0x5d,0xb5,0x7a,0xa3,0xf5,0x58,0xc4,"Text_IsActive_Attribute_GUID"); + IF_GUID_EQUAL_RETURN(guid,0x360182fb,0xbdd7,0x47f6,0xab,0x69,0x19,0xe3,0x3f,0x8a,0x33,0x44,"Text_IsHidden_Attribute_GUID"); + IF_GUID_EQUAL_RETURN(guid,0xfce12a56,0x1336,0x4a34,0x96,0x63,0x1b,0xab,0x47,0x23,0x93,0x20,"Text_IsItalic_Attribute_GUID"); + IF_GUID_EQUAL_RETURN(guid,0xa738156b,0xca3e,0x495e,0x95,0x14,0x83,0x3c,0x44,0x0f,0xeb,0x11,"Text_IsReadOnly_Attribute_GUID"); + IF_GUID_EQUAL_RETURN(guid,0xf0ead858,0x8f53,0x413c,0x87,0x3f,0x1a,0x7d,0x7f,0x5e,0x0d,0xe4,"Text_IsSubscript_Attribute_GUID"); + IF_GUID_EQUAL_RETURN(guid,0xda706ee4,0xb3aa,0x4645,0xa4,0x1f,0xcd,0x25,0x15,0x7d,0xea,0x76,"Text_IsSuperscript_Attribute_GUID"); + IF_GUID_EQUAL_RETURN(guid,0xb38ef51d,0x9e8d,0x4e46,0x91,0x44,0x56,0xeb,0xe1,0x77,0x32,0x9b,"Text_Link_Attribute_GUID"); + IF_GUID_EQUAL_RETURN(guid,0x7ee593c4,0x72b4,0x4cac,0x92,0x71,0x3e,0xd2,0x4b,0x0e,0x4d,0x42,"Text_MarginBottom_Attribute_GUID"); + IF_GUID_EQUAL_RETURN(guid,0x9e9242d0,0x5ed0,0x4900,0x8e,0x8a,0xee,0xcc,0x03,0x83,0x5a,0xfc,"Text_MarginLeading_Attribute_GUID"); + IF_GUID_EQUAL_RETURN(guid,0x683d936f,0xc9b9,0x4a9a,0xb3,0xd9,0xd2,0x0d,0x33,0x31,0x1e,0x2a,"Text_MarginTop_Attribute_GUID"); + IF_GUID_EQUAL_RETURN(guid,0xaf522f98,0x999d,0x40af,0xa5,0xb2,0x01,0x69,0xd0,0x34,0x20,0x02,"Text_MarginTrailing_Attribute_GUID"); + IF_GUID_EQUAL_RETURN(guid,0x5b675b27,0xdb89,0x46fe,0x97,0x0c,0x61,0x4d,0x52,0x3b,0xb9,0x7d,"Text_OutlineStyles_Attribute_GUID"); + IF_GUID_EQUAL_RETURN(guid,0x83ab383a,0xfd43,0x40da,0xab,0x3e,0xec,0xf8,0x16,0x5c,0xbb,0x6d,"Text_OverlineColor_Attribute_GUID"); + IF_GUID_EQUAL_RETURN(guid,0x0a234d66,0x617e,0x427f,0x87,0x1d,0xe1,0xff,0x1e,0x0c,0x21,0x3f,"Text_OverlineStyle_Attribute_GUID"); + IF_GUID_EQUAL_RETURN(guid,0x498479a2,0x5b22,0x448d,0xb6,0xe4,0x64,0x74,0x90,0x86,0x06,0x98,"Text_Pattern2_GUID"); + IF_GUID_EQUAL_RETURN(guid,0x8615f05d,0x7de5,0x44fd,0xa6,0x79,0x2c,0xa4,0xb4,0x60,0x33,0xa8,"Text_Pattern_GUID"); + IF_GUID_EQUAL_RETURN(guid,0x1f668cc3,0x9bbf,0x416b,0xb0,0xa2,0xf8,0x9f,0x86,0xf6,0x61,0x2c,"Text_SelectionActiveEnd_Attribute_GUID"); + IF_GUID_EQUAL_RETURN(guid,0xbfe15a18,0x8c41,0x4c5a,0x9a,0x0b,0x04,0xaf,0x0e,0x07,0xf4,0x87,"Text_StrikethroughColor_Attribute_GUID"); + IF_GUID_EQUAL_RETURN(guid,0x72913ef1,0xda00,0x4f01,0x89,0x9c,0xac,0x5a,0x85,0x77,0xa3,0x07,"Text_StrikethroughStyle_Attribute_GUID"); + IF_GUID_EQUAL_RETURN(guid,0x14c300de,0xc32b,0x449b,0xab,0x7c,0xb0,0xe0,0x78,0x9a,0xea,0x5d,"Text_StyleId_Attribute_GUID"); + IF_GUID_EQUAL_RETURN(guid,0x22c9e091,0x4d66,0x45d8,0xa8,0x28,0x73,0x7b,0xab,0x4c,0x98,0xa7,"Text_StyleName_Attribute_GUID"); + IF_GUID_EQUAL_RETURN(guid,0x2e68d00b,0x92fe,0x42d8,0x89,0x9a,0xa7,0x84,0xaa,0x44,0x54,0xa1,"Text_Tabs_Attribute_GUID"); + IF_GUID_EQUAL_RETURN(guid,0x4a342082,0xf483,0x48c4,0xac,0x11,0xa8,0x4b,0x43,0x5e,0x2a,0x84,"Text_TextChangedEvent_Event_GUID"); + IF_GUID_EQUAL_RETURN(guid,0x8bdf8739,0xf420,0x423e,0xaf,0x77,0x20,0xa5,0xd9,0x73,0xa9,0x07,"Text_TextFlowDirections_Attribute_GUID"); + IF_GUID_EQUAL_RETURN(guid,0x918edaa1,0x71b3,0x49ae,0x97,0x41,0x79,0xbe,0xb8,0xd3,0x58,0xf3,"Text_TextSelectionChangedEvent_Event_GUID"); + IF_GUID_EQUAL_RETURN(guid,0xbfa12c73,0xfde2,0x4473,0xbf,0x64,0x10,0x36,0xd6,0xaa,0x0f,0x45,"Text_UnderlineColor_Attribute_GUID"); + IF_GUID_EQUAL_RETURN(guid,0x5f3b21c0,0xede4,0x44bd,0x9c,0x36,0x38,0x53,0x03,0x8c,0xbf,0xeb,"Text_UnderlineStyle_Attribute_GUID"); + IF_GUID_EQUAL_RETURN(guid,0x701ca877,0xe310,0x4dd6,0xb6,0x44,0x79,0x7e,0x4f,0xae,0xa2,0x13,"Thumb_Control_GUID"); + IF_GUID_EQUAL_RETURN(guid,0x98aa55bf,0x3bb0,0x4b65,0x83,0x6e,0x2e,0xa3,0x0d,0xbc,0x17,0x1f,"TitleBar_Control_GUID"); + IF_GUID_EQUAL_RETURN(guid,0x0b419760,0xe2f4,0x43ff,0x8c,0x5f,0x94,0x57,0xc8,0x2b,0x56,0xe9,"Toggle_Pattern_GUID"); + IF_GUID_EQUAL_RETURN(guid,0xb23cdc52,0x22c2,0x4c6c,0x9d,0xed,0xf5,0xc4,0x22,0x47,0x9e,0xde,"Toggle_ToggleState_Property_GUID"); + IF_GUID_EQUAL_RETURN(guid,0x8f06b751,0xe182,0x4e98,0x88,0x93,0x22,0x84,0x54,0x3a,0x7d,0xce,"ToolBar_Control_GUID"); + IF_GUID_EQUAL_RETURN(guid,0x276d71ef,0x24a9,0x49b6,0x8e,0x97,0xda,0x98,0xb4,0x01,0xbb,0xcd,"ToolTipClosed_Event_GUID"); + IF_GUID_EQUAL_RETURN(guid,0x3f4b97ff,0x2edc,0x451d,0xbc,0xa4,0x95,0xa3,0x18,0x8d,0x5b,0x03,"ToolTipOpened_Event_GUID"); + IF_GUID_EQUAL_RETURN(guid,0x05ddc6d1,0x2137,0x4768,0x98,0xea,0x73,0xf5,0x2f,0x71,0x34,0xf3,"ToolTip_Control_GUID"); + IF_GUID_EQUAL_RETURN(guid,0x8afcfd07,0xa369,0x44de,0x98,0x8b,0x2f,0x7f,0xf4,0x9f,0xb8,0xa8,"Tranform_Pattern2_GUID"); + IF_GUID_EQUAL_RETURN(guid,0xf357e890,0xa756,0x4359,0x9c,0xa6,0x86,0x70,0x2b,0xf8,0xf3,0x81,"Transform2_CanZoom_Property_GUID"); + IF_GUID_EQUAL_RETURN(guid,0xeee29f1a,0xf4a2,0x4b5b,0xac,0x65,0x95,0xcf,0x93,0x28,0x33,0x87,"Transform2_ZoomLevel_Property_GUID"); + IF_GUID_EQUAL_RETURN(guid,0x42ab6b77,0xceb0,0x4eca,0xb8,0x2a,0x6c,0xfa,0x5f,0xa1,0xfc,0x08,"Transform2_ZoomMaximum_Property_GUID"); + IF_GUID_EQUAL_RETURN(guid,0x742ccc16,0x4ad1,0x4e07,0x96,0xfe,0xb1,0x22,0xc6,0xe6,0xb2,0x2b,"Transform2_ZoomMinimum_Property_GUID"); + IF_GUID_EQUAL_RETURN(guid,0x1b75824d,0x208b,0x4fdf,0xbc,0xcd,0xf1,0xf4,0xe5,0x74,0x1f,0x4f,"Transform_CanMove_Property_GUID"); + IF_GUID_EQUAL_RETURN(guid,0xbb98dca5,0x4c1a,0x41d4,0xa4,0xf6,0xeb,0xc1,0x28,0x64,0x41,0x80,"Transform_CanResize_Property_GUID"); + IF_GUID_EQUAL_RETURN(guid,0x10079b48,0x3849,0x476f,0xac,0x96,0x44,0xa9,0x5c,0x84,0x40,0xd9,"Transform_CanRotate_Property_GUID"); + IF_GUID_EQUAL_RETURN(guid,0x24b46fdb,0x587e,0x49f1,0x9c,0x4a,0xd8,0xe9,0x8b,0x66,0x4b,0x7b,"Transform_Pattern_GUID"); + IF_GUID_EQUAL_RETURN(guid,0x62c9feb9,0x8ffc,0x4878,0xa3,0xa4,0x96,0xb0,0x30,0x31,0x5c,0x18,"TreeItem_Control_GUID"); + IF_GUID_EQUAL_RETURN(guid,0x7561349c,0xd241,0x43f4,0x99,0x08,0xb5,0xf0,0x91,0xbe,0xe6,0x11,"Tree_Control_GUID"); + IF_GUID_EQUAL_RETURN(guid,0x54FB46C8,0xF089,0x464C,0xB1,0xFD,0x59,0xD1,0xB6,0x2C,0x3B,0x50,"USER_POLICY_PRESENT_GUID"); + IF_GUID_EQUAL_RETURN(guid,0xe1b98d74,0x9778,0x4878,0xb6,0x64,0xeb,0x20,0x20,0x36,0x4d,0x88,"UUID_UdriTagTables"); + IF_GUID_EQUAL_RETURN(guid,0x5DCD1101,0x9263,0x45bb,0xa4,0xd5,0xc4,0x15,0xab,0x8c,0x58,0x9c,"UUID_WMDRMTagTables"); + IF_GUID_EQUAL_RETURN(guid,0x7aaa1638,0x1b7f,0x4c93,0xbd,0x89,0x5b,0x9c,0x9f,0xb6,0xfc,0xf0,"VIDEO_ZOOM_RECT"); + IF_GUID_EQUAL_RETURN(guid,0xec984aec,0xa0f9,0x47e9,0x90,0x1f,0x71,0x41,0x5a,0x66,0x34,0x5b,"VIRTUAL_STORAGE_TYPE_VENDOR_MICROSOFT"); + IF_GUID_EQUAL_RETURN(guid,0x00000000,0x0000,0x0000,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,"VIRTUAL_STORAGE_TYPE_VENDOR_UNKNOWN"); + IF_GUID_EQUAL_RETURN(guid,0xeb090f30,0xe24c,0x4799,0xa7,0x05,0x0d,0x24,0x7b,0xc0,0x37,0xf8,"Value_IsReadOnly_Property_GUID"); + IF_GUID_EQUAL_RETURN(guid,0x17faad9e,0xc877,0x475b,0xb9,0x33,0x77,0x33,0x27,0x79,0xb6,0x37,"Value_Pattern_GUID"); + IF_GUID_EQUAL_RETURN(guid,0xe95f5e64,0x269f,0x4a85,0xba,0x99,0x40,0x92,0xc3,0xea,0x29,0x86,"Value_Value_Property_GUID"); + IF_GUID_EQUAL_RETURN(guid,0xf510173e,0x2e71,0x45e9,0xa6,0xe5,0x62,0xf6,0xed,0x82,0x89,0xd5,"VirtualizedItem_Pattern_GUID"); + IF_GUID_EQUAL_RETURN(guid,0xdefe5fd8,0x6c97,0x4dde,0xb1,0x1e,0xcb,0x50,0x9b,0x27,0x0e,0x11,"WIA_CATEGORY_AUTO"); + IF_GUID_EQUAL_RETURN(guid,0x36e178a0,0x473f,0x494b,0xaf,0x8f,0x6c,0x3f,0x6d,0x74,0x86,0xfc,"WIA_CATEGORY_BARCODE_READER"); + IF_GUID_EQUAL_RETURN(guid,0x47102cc3,0x127f,0x4771,0xad,0xfc,0x99,0x1a,0xb8,0xee,0x1e,0x97,"WIA_CATEGORY_ENDORSER"); + IF_GUID_EQUAL_RETURN(guid,0xfe131934,0xf84c,0x42ad,0x8d,0xa4,0x61,0x29,0xcd,0xdd,0x72,0x88,"WIA_CATEGORY_FEEDER"); + IF_GUID_EQUAL_RETURN(guid,0x61ca74d4,0x39db,0x42aa,0x89,0xb1,0x8c,0x19,0xc9,0xcd,0x4c,0x23,"WIA_CATEGORY_FEEDER_BACK"); + IF_GUID_EQUAL_RETURN(guid,0x4823175c,0x3b28,0x487b,0xa7,0xe6,0xee,0xbc,0x17,0x61,0x4f,0xd1,"WIA_CATEGORY_FEEDER_FRONT"); + IF_GUID_EQUAL_RETURN(guid,0xfcf65be7,0x3ce3,0x4473,0xaf,0x85,0xf5,0xd3,0x7d,0x21,0xb6,0x8a,"WIA_CATEGORY_FILM"); + IF_GUID_EQUAL_RETURN(guid,0xff2b77ca,0xcf84,0x432b,0xa7,0x35,0x3a,0x13,0x0d,0xde,0x2a,0x88,"WIA_CATEGORY_FINISHED_FILE"); + IF_GUID_EQUAL_RETURN(guid,0xfb607b1f,0x43f3,0x488b,0x85,0x5b,0xfb,0x70,0x3e,0xc3,0x42,0xa6,"WIA_CATEGORY_FLATBED"); + IF_GUID_EQUAL_RETURN(guid,0xc692a446,0x6f5a,0x481d,0x85,0xbb,0x92,0xe2,0xe8,0x6f,0xd3,0xa,"WIA_CATEGORY_FOLDER"); + IF_GUID_EQUAL_RETURN(guid,0xfc65016d,0x9202,0x43dd,0x91,0xa7,0x64,0xc2,0x95,0x4c,0xfb,0x8b,"WIA_CATEGORY_IMPRINTER"); + IF_GUID_EQUAL_RETURN(guid,0x3b86c1ec,0x71bc,0x4645,0xb4,0xd5,0x1b,0x19,0xda,0x2b,0xe9,0x78,"WIA_CATEGORY_MICR_READER"); + IF_GUID_EQUAL_RETURN(guid,0x8faa1a6d,0x9c8a,0x42cd,0x98,0xb3,0xee,0x97,0x00,0xcb,0xc7,0x4f,"WIA_CATEGORY_PATCH_CODE_READER"); + IF_GUID_EQUAL_RETURN(guid,0xf193526f,0x59b8,0x4a26,0x98,0x88,0xe1,0x6e,0x4f,0x97,0xce,0x10,"WIA_CATEGORY_ROOT"); + IF_GUID_EQUAL_RETURN(guid,0x9cba5ce0,0xdbea,0x11d2,0x84,0x16,0x00,0xc0,0x4f,0xa3,0x61,0x45,"WIA_CMD_BUILD_DEVICE_TREE"); + IF_GUID_EQUAL_RETURN(guid,0x04e725b0,0xacae,0x11d2,0xa0,0x93,0x00,0xc0,0x4f,0x72,0xdc,0x3c,"WIA_CMD_CHANGE_DOCUMENT"); + IF_GUID_EQUAL_RETURN(guid,0xe208c170,0xacad,0x11d2,0xa0,0x93,0x00,0xc0,0x4f,0x72,0xdc,0x3c,"WIA_CMD_DELETE_ALL_ITEMS"); + IF_GUID_EQUAL_RETURN(guid,0x73815942,0xdbea,0x11d2,0x84,0x16,0x00,0xc0,0x4f,0xa3,0x61,0x45,"WIA_CMD_DELETE_DEVICE_TREE"); + IF_GUID_EQUAL_RETURN(guid,0x10ff52f5,0xde04,0x4cf0,0xa5,0xad,0x69,0x1f,0x8d,0xce,0x01,0x41,"WIA_CMD_DIAGNOSTIC"); + IF_GUID_EQUAL_RETURN(guid,0xc3a693aa,0xf788,0x4d34,0xa5,0xb0,0xbe,0x71,0x90,0x75,0x9a,0x24,"WIA_CMD_FORMAT"); + IF_GUID_EQUAL_RETURN(guid,0x50985e4d,0xa5b2,0x4b71,0x9c,0x95,0x6d,0x7d,0x7c,0x46,0x9a,0x43,"WIA_CMD_PAUSE_FEEDER"); + IF_GUID_EQUAL_RETURN(guid,0x5a9df6c9,0x5f2d,0x4a39,0x9d,0x6c,0x00,0x45,0x6d,0x04,0x7f,0x00,"WIA_CMD_START_FEEDER"); + IF_GUID_EQUAL_RETURN(guid,0xd847b06d,0x3905,0x459c,0x95,0x09,0x9b,0x29,0xcd,0xb6,0x91,0xe7,"WIA_CMD_STOP_FEEDER"); + IF_GUID_EQUAL_RETURN(guid,0x9b26b7b2,0xacad,0x11d2,0xa0,0x93,0x00,0xc0,0x4f,0x72,0xdc,0x3c,"WIA_CMD_SYNCHRONIZE"); + IF_GUID_EQUAL_RETURN(guid,0xaf933cac,0xacad,0x11d2,0xa0,0x93,0x00,0xc0,0x4f,0x72,0xdc,0x3c,"WIA_CMD_TAKE_PICTURE"); + IF_GUID_EQUAL_RETURN(guid,0x1f3b3d8e,0xacae,0x11d2,0xa0,0x93,0x00,0xc0,0x4f,0x72,0xdc,0x3c,"WIA_CMD_UNLOAD_DOCUMENT"); + IF_GUID_EQUAL_RETURN(guid,0xc860f7b8,0x9ccd,0x41ea,0xbb,0xbf,0x4d,0xd0,0x9c,0x5b,0x17,0x95,"WIA_EVENT_CANCEL_IO"); + IF_GUID_EQUAL_RETURN(guid,0x6714a1e6,0xe285,0x468c,0x9b,0x8c,0xda,0x7d,0xc4,0xcb,0xaa,0x05,"WIA_EVENT_COVER_CLOSED"); + IF_GUID_EQUAL_RETURN(guid,0x19a12136,0xfa1c,0x4f66,0x90,0x0f,0x8f,0x91,0x4e,0xc7,0x4e,0xc9,"WIA_EVENT_COVER_OPEN"); + IF_GUID_EQUAL_RETURN(guid,0xa28bbade,0x64b6,0x11d2,0xa2,0x31,0x00,0xc0,0x4f,0xa3,0x18,0x09,"WIA_EVENT_DEVICE_CONNECTED"); + IF_GUID_EQUAL_RETURN(guid,0x143e4e83,0x6497,0x11d2,0xa2,0x31,0x00,0xc0,0x4f,0xa3,0x18,0x09,"WIA_EVENT_DEVICE_DISCONNECTED"); + IF_GUID_EQUAL_RETURN(guid,0xd8962d7e,0xe4dc,0x4b4d,0xba,0x29,0x66,0x8a,0x87,0xf4,0x2e,0x6f,"WIA_EVENT_DEVICE_NOT_READY"); + IF_GUID_EQUAL_RETURN(guid,0x7523ec6c,0x988b,0x419e,0x9a,0x0a,0x42,0x5a,0xc3,0x1b,0x37,0xdc,"WIA_EVENT_DEVICE_READY"); + IF_GUID_EQUAL_RETURN(guid,0xe70b4b82,0x6dda,0x46bb,0x8f,0xf9,0x53,0xce,0xb1,0xa0,0x3e,0x35,"WIA_EVENT_FEEDER_EMPTIED"); + IF_GUID_EQUAL_RETURN(guid,0xcc8d701e,0x9aba,0x481d,0xbf,0x74,0x78,0xf7,0x63,0xdc,0x34,0x2a,"WIA_EVENT_FEEDER_LOADED"); + IF_GUID_EQUAL_RETURN(guid,0xf879af0f,0x9b29,0x4283,0xad,0x95,0xd4,0x12,0x16,0x4d,0x39,0xa9,"WIA_EVENT_FLATBED_LID_CLOSED"); + IF_GUID_EQUAL_RETURN(guid,0xba0a0623,0x437d,0x4f03,0xa9,0x7d,0x77,0x93,0xb1,0x23,0x11,0x3c,"WIA_EVENT_FLATBED_LID_OPEN"); + IF_GUID_EQUAL_RETURN(guid,0xe0372b7d,0xe115,0x4525,0xbc,0x55,0xb6,0x29,0xe6,0x8c,0x74,0x5a,"WIA_EVENT_HANDLER_NO_ACTION"); + IF_GUID_EQUAL_RETURN(guid,0x5f4baad0,0x4d59,0x4fcd,0xb2,0x13,0x78,0x3c,0xe7,0xa9,0x2f,0x22,"WIA_EVENT_HANDLER_PROMPT"); + IF_GUID_EQUAL_RETURN(guid,0x4c8f4ef5,0xe14f,0x11d2,0xb3,0x26,0x00,0xc0,0x4f,0x68,0xce,0x61,"WIA_EVENT_ITEM_CREATED"); + IF_GUID_EQUAL_RETURN(guid,0x1d22a559,0xe14f,0x11d2,0xb3,0x26,0x00,0xc0,0x4f,0x68,0xce,0x61,"WIA_EVENT_ITEM_DELETED"); + IF_GUID_EQUAL_RETURN(guid,0x618f153e,0xf686,0x4350,0x96,0x34,0x41,0x15,0xa3,0x04,0x83,0x0c,"WIA_EVENT_POWER_RESUME"); + IF_GUID_EQUAL_RETURN(guid,0xa0922ff9,0xc3b4,0x411c,0x9e,0x29,0x03,0xa6,0x69,0x93,0xd2,0xbe,"WIA_EVENT_POWER_SUSPEND"); + IF_GUID_EQUAL_RETURN(guid,0xc686dcee,0x54f2,0x419e,0x9a,0x27,0x2f,0xc7,0xf2,0xe9,0x8f,0x9e,"WIA_EVENT_SCAN_EMAIL_IMAGE"); + IF_GUID_EQUAL_RETURN(guid,0xc00eb793,0x8c6e,0x11d2,0x97,0x7a,0x00,0x00,0xf8,0x7a,0x92,0x6f,"WIA_EVENT_SCAN_FAX_IMAGE"); + IF_GUID_EQUAL_RETURN(guid,0x9b2b662c,0x6185,0x438c,0xb6,0x8b,0xe3,0x9e,0xe2,0x5e,0x71,0xcb,"WIA_EVENT_SCAN_FILM_IMAGE"); + IF_GUID_EQUAL_RETURN(guid,0xfc4767c1,0xc8b3,0x48a2,0x9c,0xfa,0x2e,0x90,0xcb,0x3d,0x35,0x90,"WIA_EVENT_SCAN_IMAGE2"); + IF_GUID_EQUAL_RETURN(guid,0x154e27be,0xb617,0x4653,0xac,0xc5,0x0f,0xd7,0xbd,0x4c,0x65,0xce,"WIA_EVENT_SCAN_IMAGE3"); + IF_GUID_EQUAL_RETURN(guid,0xa65b704a,0x7f3c,0x4447,0xa7,0x5d,0x8a,0x26,0xdf,0xca,0x1f,0xdf,"WIA_EVENT_SCAN_IMAGE4"); + IF_GUID_EQUAL_RETURN(guid,0xa6c5a715,0x8c6e,0x11d2,0x97,0x7a,0x00,0x00,0xf8,0x7a,0x92,0x6f,"WIA_EVENT_SCAN_IMAGE"); + IF_GUID_EQUAL_RETURN(guid,0x9d095b89,0x37d6,0x4877,0xaf,0xed,0x62,0xa2,0x97,0xdc,0x6d,0xbe,"WIA_EVENT_SCAN_OCR_IMAGE"); + IF_GUID_EQUAL_RETURN(guid,0xb441f425,0x8c6e,0x11d2,0x97,0x7a,0x00,0x00,0xf8,0x7a,0x92,0x6f,"WIA_EVENT_SCAN_PRINT_IMAGE"); + IF_GUID_EQUAL_RETURN(guid,0xd711f81f,0x1f0d,0x422d,0x86,0x41,0x92,0x7d,0x1b,0x93,0xe5,0xe5,"WIA_EVENT_STI_PROXY"); + IF_GUID_EQUAL_RETURN(guid,0x353308b2,0xfe73,0x46c8,0x89,0x5e,0xfa,0x45,0x51,0xcc,0xc8,0x5a,"WIA_EVENT_STORAGE_CREATED"); + IF_GUID_EQUAL_RETURN(guid,0x5e41e75e,0x9390,0x44c5,0x9a,0x51,0xe4,0x70,0x19,0xe3,0x90,0xcf,"WIA_EVENT_STORAGE_DELETED"); + IF_GUID_EQUAL_RETURN(guid,0xc9859b91,0x4ab2,0x4cd6,0xa1,0xfc,0x58,0x2e,0xec,0x55,0xe5,0x85,"WIA_EVENT_TREE_UPDATED"); + IF_GUID_EQUAL_RETURN(guid,0x9638bbfd,0xd1bd,0x11d2,0xb3,0x1f,0x00,0xc0,0x4f,0x68,0xce,0x61,"WIA_EVENT_VOLUME_INSERT"); + IF_GUID_EQUAL_RETURN(guid,0x429b8c22,0x9188,0x4b0c,0x87,0x42,0xac,0xb0,0xbf,0x85,0xc2,0x00,"WKPDID_D3DDebugObjectName"); + IF_GUID_EQUAL_RETURN(guid,0xa4d2c26c,0xa881,0x44bb,0xbd,0x5d,0x1f,0x70,0x3c,0x71,0xf7,0xa9,"WMDM_DEVICE_PROTOCOL_MSC"); + IF_GUID_EQUAL_RETURN(guid,0x979e54e5,0xafc,0x4604,0x8d,0x93,0xdc,0x79,0x8a,0x4b,0xcf,0x45,"WMDM_DEVICE_PROTOCOL_MTP"); + IF_GUID_EQUAL_RETURN(guid,0x2a11ed91,0x8c8f,0x41e4,0x82,0xd1,0x83,0x86,0xe0,0x3,0x56,0x1c,"WMDM_DEVICE_PROTOCOL_RAPI"); + IF_GUID_EQUAL_RETURN(guid,0x7de8686d,0x78ee,0x43ea,0xa4,0x96,0xc6,0x25,0xac,0x91,0xcc,0x5d,"WMDM_SERVICE_PROVIDER_VENDOR_MICROSOFT"); + IF_GUID_EQUAL_RETURN(guid,0xc3fd11c6,0xf8b7,0x4d20,0xB0,0x08,0x1d,0xb1,0x7d,0x61,0xf2,0xda,"WMDRM_PROTECTION_SCHEME_ACP"); + IF_GUID_EQUAL_RETURN(guid,0x8f81a453,0x998c,0x4596,0xb1,0x50,0xf8,0x48,0x6d,0xf6,0xf2,0xe6,"WMDRM_PROTECTION_SCHEME_DOWNSAMPLE_REQUIRED"); + IF_GUID_EQUAL_RETURN(guid,0x811c5110,0x46c8,0x4c6e,0x81,0x63,0xc0,0x48,0x2a,0x15,0xd4,0x7e,"WMDRM_PROTECTION_SCHEME_MAX_COMPONENT_RESOLUTION"); + IF_GUID_EQUAL_RETURN(guid,0xec3a1c03,0xdd4e,0x47f7,0xbf,0xe5,0xae,0xe7,0x53,0x48,0x66,0x71,"WMDRM_PROTECTION_SCHEME_MAX_COMPONENT_RESOLUTION_1"); + IF_GUID_EQUAL_RETURN(guid,0x327803ca,0xd914,0x4da3,0x97,0x28,0xe1,0x9e,0x82,0xbe,0x8c,0x25,"WMDRM_PROTECTION_SCHEME_MAX_COMPONENT_RESOLUTION_2"); + IF_GUID_EQUAL_RETURN(guid,0x36d9c83f,0xaf07,0x4727,0xab,0x74,0xca,0x69,0x31,0xba,0x69,0xf3,"WMDRM_PROTECTION_SCHEME_MAX_COMPONENT_RESOLUTION_3"); + IF_GUID_EQUAL_RETURN(guid,0x9443d876,0x1d46,0x40cb,0xbd,0xe5,0x9c,0xc1,0x46,0x4c,0x9b,0xaf,"WMDRM_PROTECTION_SCHEME_MAX_COMPONENT_RESOLUTION_4"); + IF_GUID_EQUAL_RETURN(guid,0xd783a191,0xe083,0x4baf,0xb2,0xda,0xe6,0x9f,0x91,0x0b,0x37,0x72,"WMDRM_PROTECTION_SCHEME_MAX_VGA_RESOLUTION"); + IF_GUID_EQUAL_RETURN(guid,0xd9619433,0xec9f,0x489e,0x9e,0x07,0x77,0x0d,0xed,0xd8,0xbd,0x04,"WMDRM_PROTECTION_SCHEME_MAX_VGA_RESOLUTION_1"); + IF_GUID_EQUAL_RETURN(guid,0xa24f0a24,0x5c92,0x4737,0x9b,0x21,0xa2,0x3e,0x4f,0xed,0x32,0x2e,"WMDRM_PROTECTION_SCHEME_MAX_VGA_RESOLUTION_2"); + IF_GUID_EQUAL_RETURN(guid,0xc4db4310,0xa1ae,0x422e,0xb7,0xa7,0x21,0xbc,0x34,0x73,0xda,0x77,"WMDRM_PROTECTION_SCHEME_MAX_VGA_RESOLUTION_3"); + IF_GUID_EQUAL_RETURN(guid,0xe84e4d21,0x3b1c,0x44bc,0xa2,0xec,0xc4,0x81,0x08,0x58,0x7c,0xad,"WMDRM_PROTECTION_SCHEME_MAX_VGA_RESOLUTION_4"); + IF_GUID_EQUAL_RETURN(guid,0x90A37313,0x0ECF,0x4CAA,0xA9,0x06,0xB1,0x88,0xF6,0x12,0x93,0x00,"WMDRM_REVOCATIONTYPE_APP"); + IF_GUID_EQUAL_RETURN(guid,0xCD75E604,0x543D,0x4A9C,0x9F,0x09,0xFE,0x6D,0x24,0xE8,0xBF,0x90,"WMDRM_REVOCATIONTYPE_CARDEA"); + IF_GUID_EQUAL_RETURN(guid,0x3129E375,0xCEB0,0x47D5,0x9C,0xCA,0x9D,0xB7,0x4C,0xFD,0x43,0x32,"WMDRM_REVOCATIONTYPE_DEVICE"); + IF_GUID_EQUAL_RETURN(guid,0xa2190240,0xb2ca,0x40b3,0xb4,0x8d,0x9b,0xc4,0xc2,0xdc,0x42,0x8d,"WMDRM_REVOCATIONTYPE_GRL"); + IF_GUID_EQUAL_RETURN(guid,0xe627553a,0x820f,0x40fd,0xb4,0x65,0xa4,0x28,0x30,0xa5,0x74,0xc9,"WMDRM_REVOCATIONTYPE_HDCP"); + IF_GUID_EQUAL_RETURN(guid,0xCCDE5A55,0xA688,0x4405,0xA8,0x8B,0xD1,0x3F,0x90,0xD5,0xBA,0x3E,"WMDRM_REVOCATIONTYPE_REVINFO"); + IF_GUID_EQUAL_RETURN(guid,0xe06d80e3,0xdb46,0x11cf,0xb4,0xd1,0x00,0x80,0x05f,0x6c,0xbb,0xea,"WMFORMAT_MPEG2Video"); + IF_GUID_EQUAL_RETURN(guid,0x5c8510f2,0xdebe,0x4ca7,0xbb,0xa5,0xf0,0x7a,0x10,0x4f,0x8d,0xff,"WMFORMAT_Script"); + IF_GUID_EQUAL_RETURN(guid,0x05589f80,0xc356,0x11ce,0xbf,0x01,0x00,0xaa,0x00,0x55,0x59,0x5a,"WMFORMAT_VideoInfo"); + IF_GUID_EQUAL_RETURN(guid,0x05589f81,0xc356,0x11ce,0xbf,0x01,0x00,0xaa,0x00,0x55,0x59,0x5a,"WMFORMAT_WaveFormatEx"); + IF_GUID_EQUAL_RETURN(guid,0xda1e6b13,0x8359,0x4050,0xb3,0x98,0x38,0x8e,0x96,0x5b,0xf0,0x0c,"WMFORMAT_WebStream"); + IF_GUID_EQUAL_RETURN(guid,0x00000130,0x0000,0x0010,0x80,0x00,0x00,0xAA,0x00,0x38,0x9B,0x71,"WMMEDIASUBTYPE_ACELPnet"); + IF_GUID_EQUAL_RETURN(guid,0x00000000,0x0000,0x0010,0x80,0x00,0x00,0xAA,0x00,0x38,0x9B,0x71,"WMMEDIASUBTYPE_Base"); + IF_GUID_EQUAL_RETURN(guid,0x00000009,0x0000,0x0010,0x80,0x00,0x00,0xAA,0x00,0x38,0x9B,0x71,"WMMEDIASUBTYPE_DRM"); + IF_GUID_EQUAL_RETURN(guid,0x30323449,0x0000,0x0010,0x80,0x00,0x00,0xaa,0x00,0x38,0x9b,0x71,"WMMEDIASUBTYPE_I420"); + IF_GUID_EQUAL_RETURN(guid,0x56555949,0x0000,0x0010,0x80,0x00,0x00,0xaa,0x00,0x38,0x9b,0x71,"WMMEDIASUBTYPE_IYUV"); + IF_GUID_EQUAL_RETURN(guid,0x3253344D,0x0000,0x0010,0x80,0x00,0x00,0xAA,0x00,0x38,0x9B,0x71,"WMMEDIASUBTYPE_M4S2"); + IF_GUID_EQUAL_RETURN(guid,0x00000055,0x0000,0x0010,0x80,0x00,0x00,0xAA,0x00,0x38,0x9B,0x71,"WMMEDIASUBTYPE_MP3"); + IF_GUID_EQUAL_RETURN(guid,0x3334504D,0x0000,0x0010,0x80,0x00,0x00,0xAA,0x00,0x38,0x9B,0x71,"WMMEDIASUBTYPE_MP43"); + IF_GUID_EQUAL_RETURN(guid,0x5334504D,0x0000,0x0010,0x80,0x00,0x00,0xAA,0x00,0x38,0x9B,0x71,"WMMEDIASUBTYPE_MP4S"); + IF_GUID_EQUAL_RETURN(guid,0xe06d8026,0xdb46,0x11cf,0xb4,0xd1,0x00,0x80,0x5f,0x6c,0xbb,0xea,"WMMEDIASUBTYPE_MPEG2_VIDEO"); + IF_GUID_EQUAL_RETURN(guid,0x3153534D,0x0000,0x0010,0x80,0x00,0x00,0xAA,0x00,0x38,0x9B,0x71,"WMMEDIASUBTYPE_MSS1"); + IF_GUID_EQUAL_RETURN(guid,0x3253534D,0x0000,0x0010,0x80,0x00,0x00,0xAA,0x00,0x38,0x9B,0x71,"WMMEDIASUBTYPE_MSS2"); + IF_GUID_EQUAL_RETURN(guid,0x32323450,0x0000,0x0010,0x80,0x00,0x00,0xaa,0x00,0x38,0x9b,0x71,"WMMEDIASUBTYPE_P422"); + IF_GUID_EQUAL_RETURN(guid,0x00000001,0x0000,0x0010,0x80,0x00,0x00,0xAA,0x00,0x38,0x9B,0x71,"WMMEDIASUBTYPE_PCM"); + IF_GUID_EQUAL_RETURN(guid,0xe436eb78,0x524f,0x11ce,0x9f,0x53,0x00,0x20,0xaf,0x0b,0xa7,0x70,"WMMEDIASUBTYPE_RGB1"); + IF_GUID_EQUAL_RETURN(guid,0xe436eb7d,0x524f,0x11ce,0x9f,0x53,0x00,0x20,0xaf,0x0b,0xa7,0x70,"WMMEDIASUBTYPE_RGB24"); + IF_GUID_EQUAL_RETURN(guid,0xe436eb7e,0x524f,0x11ce,0x9f,0x53,0x00,0x20,0xaf,0x0b,0xa7,0x70,"WMMEDIASUBTYPE_RGB32"); + IF_GUID_EQUAL_RETURN(guid,0xe436eb79,0x524f,0x11ce,0x9f,0x53,0x00,0x20,0xaf,0x0b,0xa7,0x70,"WMMEDIASUBTYPE_RGB4"); + IF_GUID_EQUAL_RETURN(guid,0xe436eb7c,0x524f,0x11ce,0x9f,0x53,0x00,0x20,0xaf,0x0b,0xa7,0x70,"WMMEDIASUBTYPE_RGB555"); + IF_GUID_EQUAL_RETURN(guid,0xe436eb7b,0x524f,0x11ce,0x9f,0x53,0x00,0x20,0xaf,0x0b,0xa7,0x70,"WMMEDIASUBTYPE_RGB565"); + IF_GUID_EQUAL_RETURN(guid,0xe436eb7a,0x524f,0x11ce,0x9f,0x53,0x00,0x20,0xaf,0x0b,0xa7,0x70,"WMMEDIASUBTYPE_RGB8"); + IF_GUID_EQUAL_RETURN(guid,0x59565955,0x0000,0x0010,0x80,0x00,0x00,0xaa,0x00,0x38,0x9b,0x71,"WMMEDIASUBTYPE_UYVY"); + IF_GUID_EQUAL_RETURN(guid,0x1d4a45f2,0xe5f6,0x4b44,0x83,0x88,0xf0,0xae,0x5c,0x0e,0x0c,0x37,"WMMEDIASUBTYPE_VIDEOIMAGE"); + IF_GUID_EQUAL_RETURN(guid,0x00000161,0x0000,0x0010,0x80,0x00,0x00,0xAA,0x00,0x38,0x9B,0x71,"WMMEDIASUBTYPE_WMAudioV2"); + IF_GUID_EQUAL_RETURN(guid,0x00000161,0x0000,0x0010,0x80,0x00,0x00,0xAA,0x00,0x38,0x9B,0x71,"WMMEDIASUBTYPE_WMAudioV7"); + IF_GUID_EQUAL_RETURN(guid,0x00000161,0x0000,0x0010,0x80,0x00,0x00,0xAA,0x00,0x38,0x9B,0x71,"WMMEDIASUBTYPE_WMAudioV8"); + IF_GUID_EQUAL_RETURN(guid,0x00000162,0x0000,0x0010,0x80,0x00,0x00,0xAA,0x00,0x38,0x9B,0x71,"WMMEDIASUBTYPE_WMAudioV9"); + IF_GUID_EQUAL_RETURN(guid,0x00000163,0x0000,0x0010,0x80,0x00,0x00,0xAA,0x00,0x38,0x9B,0x71,"WMMEDIASUBTYPE_WMAudio_Lossless"); + IF_GUID_EQUAL_RETURN(guid,0x0000000A,0x0000,0x0010,0x80,0x00,0x00,0xAA,0x00,0x38,0x9B,0x71,"WMMEDIASUBTYPE_WMSP1"); + IF_GUID_EQUAL_RETURN(guid,0x0000000B,0x0000,0x0010,0x80,0x00,0x00,0xAA,0x00,0x38,0x9B,0x71,"WMMEDIASUBTYPE_WMSP2"); + IF_GUID_EQUAL_RETURN(guid,0x31564D57,0x0000,0x0010,0x80,0x00,0x00,0xAA,0x00,0x38,0x9B,0x71,"WMMEDIASUBTYPE_WMV1"); + IF_GUID_EQUAL_RETURN(guid,0x32564D57,0x0000,0x0010,0x80,0x00,0x00,0xAA,0x00,0x38,0x9B,0x71,"WMMEDIASUBTYPE_WMV2"); + IF_GUID_EQUAL_RETURN(guid,0x33564D57,0x0000,0x0010,0x80,0x00,0x00,0xAA,0x00,0x38,0x9B,0x71,"WMMEDIASUBTYPE_WMV3"); + IF_GUID_EQUAL_RETURN(guid,0x41564D57,0x0000,0x0010,0x80,0x00,0x00,0xAA,0x00,0x38,0x9B,0x71,"WMMEDIASUBTYPE_WMVA"); + IF_GUID_EQUAL_RETURN(guid,0x50564D57,0x0000,0x0010,0x80,0x00,0x00,0xAA,0x00,0x38,0x9B,0x71,"WMMEDIASUBTYPE_WMVP"); + IF_GUID_EQUAL_RETURN(guid,0x31435657,0x0000,0x0010,0x80,0x00,0x00,0xAA,0x00,0x38,0x9B,0x71,"WMMEDIASUBTYPE_WVC1"); + IF_GUID_EQUAL_RETURN(guid,0x32505657,0x0000,0x0010,0x80,0x00,0x00,0xAA,0x00,0x38,0x9B,0x71,"WMMEDIASUBTYPE_WVP2"); + IF_GUID_EQUAL_RETURN(guid,0x776257d4,0xc627,0x41cb,0x8f,0x81,0x7a,0xc7,0xff,0x1c,0x40,0xcc,"WMMEDIASUBTYPE_WebStream"); + IF_GUID_EQUAL_RETURN(guid,0x32595559,0x0000,0x0010,0x80,0x00,0x00,0xaa,0x00,0x38,0x9b,0x71,"WMMEDIASUBTYPE_YUY2"); + IF_GUID_EQUAL_RETURN(guid,0x32315659,0x0000,0x0010,0x80,0x00,0x00,0xaa,0x00,0x38,0x9b,0x71,"WMMEDIASUBTYPE_YV12"); + IF_GUID_EQUAL_RETURN(guid,0x39555659,0x0000,0x0010,0x80,0x00,0x00,0xaa,0x00,0x38,0x9b,0x71,"WMMEDIASUBTYPE_YVU9"); + IF_GUID_EQUAL_RETURN(guid,0x55595659,0x0000,0x0010,0x80,0x00,0x00,0xaa,0x00,0x38,0x9b,0x71,"WMMEDIASUBTYPE_YVYU"); + IF_GUID_EQUAL_RETURN(guid,0x73647561,0x0000,0x0010,0x80,0x00,0x00,0xaa,0x00,0x38,0x9b,0x71,"WMMEDIATYPE_Audio"); + IF_GUID_EQUAL_RETURN(guid,0xd9e47579,0x930e,0x4427,0xad,0xfc,0xad,0x80,0xf2,0x90,0xe4,0x70,"WMMEDIATYPE_FileTransfer"); + IF_GUID_EQUAL_RETURN(guid,0x34a50fd8,0x8aa5,0x4386,0x81,0xfe,0xa0,0xef,0xe0,0x48,0x8e,0x31,"WMMEDIATYPE_Image"); + IF_GUID_EQUAL_RETURN(guid,0x73636d64,0x0000,0x0010,0x80,0x00,0x00,0xaa,0x00,0x38,0x9b,0x71,"WMMEDIATYPE_Script"); + IF_GUID_EQUAL_RETURN(guid,0x9bba1ea7,0x5ab2,0x4829,0xba,0x57,0x9,0x40,0x20,0x9b,0xcf,0x3e,"WMMEDIATYPE_Text"); + IF_GUID_EQUAL_RETURN(guid,0x73646976,0x0000,0x0010,0x80,0x00,0x00,0xaa,0x00,0x38,0x9b,0x71,"WMMEDIATYPE_Video"); + IF_GUID_EQUAL_RETURN(guid,0x6434baea,0x4954,0x498d,0xab,0xd5,0x2b,0x7,0x12,0x3e,0x1f,0x4,"WMP_PLUGINTYPE_DSP"); + IF_GUID_EQUAL_RETURN(guid,0xef29b174,0xc347,0x44cc,0x9a,0x4f,0x23,0x99,0x11,0x8f,0xf3,0x8c,"WMP_PLUGINTYPE_DSP_OUTOFPROC"); + IF_GUID_EQUAL_RETURN(guid,0xa8554541,0x115d,0x406a,0xa4,0xc7,0x51,0x11,0x1c,0x33,0x1,0x83,"WMP_PLUGINTYPE_RENDERING"); + IF_GUID_EQUAL_RETURN(guid,0x82f38a70,0xc29f,0x11d1,0x97,0xad,0x00,0xa0,0xc9,0x5e,0xa8,0x50,"WMSCRIPTTYPE_TwoStrings"); + IF_GUID_EQUAL_RETURN(guid,0x65221c5a,0xfa75,0x4b39,0xb5,0x0c,0x06,0xc3,0x36,0xb6,0xa3,0xef,"WMT_DMOCATEGORY_AUDIO_WATERMARK"); + IF_GUID_EQUAL_RETURN(guid,0x187cc922,0x8efc,0x4404,0x9d,0xaf,0x63,0xf4,0x83,0x0d,0xf1,0xbc,"WMT_DMOCATEGORY_VIDEO_WATERMARK"); + IF_GUID_EQUAL_RETURN(guid,0x4c5acca0,0x9276,0x4b2c,0x9e,0x4c,0xa0,0xed,0xef,0xdd,0x21,0x7e,"WM_SampleExtensionGUID_ChromaLocation"); + IF_GUID_EQUAL_RETURN(guid,0xf79ada56,0x30eb,0x4f2b,0x9f,0x7a,0xf2,0x4b,0x13,0x9a,0x11,0x57,"WM_SampleExtensionGUID_ColorSpaceInfo"); + IF_GUID_EQUAL_RETURN(guid,0xd590dc20,0x07bc,0x436c,0x9c,0xf7,0xf3,0xbb,0xfb,0xf1,0xa4,0xdc,"WM_SampleExtensionGUID_ContentType"); + IF_GUID_EQUAL_RETURN(guid,0xe165ec0e,0x19ed,0x45d7,0xb4,0xa7,0x25,0xcb,0xd1,0xe2,0x8e,0x9b,"WM_SampleExtensionGUID_FileName"); + IF_GUID_EQUAL_RETURN(guid,0xf72a3c6f,0x6eb4,0x4ebc,0xb1,0x92,0x9,0xad,0x97,0x59,0xe8,0x28,"WM_SampleExtensionGUID_OutputCleanPoint"); + IF_GUID_EQUAL_RETURN(guid,0x1b1ee554,0xf9ea,0x4bc8,0x82,0x1a,0x37,0x6b,0x74,0xe4,0xc4,0xb8,"WM_SampleExtensionGUID_PixelAspectRatio"); + IF_GUID_EQUAL_RETURN(guid,0xc6bd9450,0x867f,0x4907,0x83,0xa3,0xc7,0x79,0x21,0xb7,0x33,0xad,"WM_SampleExtensionGUID_SampleDuration"); + IF_GUID_EQUAL_RETURN(guid,0x5403deee,0xb9ee,0x438f,0xaa,0x83,0x38,0x4,0x99,0x7e,0x56,0x9d,"WM_SampleExtensionGUID_SampleProtectionSalt"); + IF_GUID_EQUAL_RETURN(guid,0x399595ec,0x8667,0x4e2d,0x8f,0xdb,0x98,0x81,0x4c,0xe7,0x6c,0x1e,"WM_SampleExtensionGUID_Timecode"); + IF_GUID_EQUAL_RETURN(guid,0x732bb4fa,0x78be,0x4549,0x99,0xbd,0x2,0xdb,0x1a,0x55,0xb7,0xa8,"WM_SampleExtensionGUID_UserDataInfo"); + IF_GUID_EQUAL_RETURN(guid,0x91248166,0xb832,0x4ad4,0xba,0xa4,0x7c,0xa0,0xb6,0xb2,0x79,0x8c,"WPD_CATEGORY_ENHANCED_STORAGE"); + IF_GUID_EQUAL_RETURN(guid,0x66e2bf4f,0xb6fc,0x443f,0x94,0xc8,0x2f,0x33,0xc8,0xa6,0x5a,0xaf,"WiaAudFmt_AIFF"); + IF_GUID_EQUAL_RETURN(guid,0x0fbc71fb,0x43bf,0x49f2,0x91,0x90,0xe6,0xfe,0xcf,0xf3,0x7e,0x54,"WiaAudFmt_MP3"); + IF_GUID_EQUAL_RETURN(guid,0xf818e146,0x07af,0x40ff,0xae,0x55,0xbe,0x8f,0x2c,0x06,0x5d,0xbe,"WiaAudFmt_WAV"); + IF_GUID_EQUAL_RETURN(guid,0xd61d6413,0x8bc2,0x438f,0x93,0xad,0x21,0xbd,0x48,0x4d,0xb6,0xa1,"WiaAudFmt_WMA"); + IF_GUID_EQUAL_RETURN(guid,0x8d948ee9,0xd0aa,0x4a12,0x9d,0x9a,0x9c,0xc5,0xde,0x36,0x19,0x9b,"WiaImgFmt_ASF"); + IF_GUID_EQUAL_RETURN(guid,0x32f8ca14,0x087c,0x4908,0xb7,0xc4,0x67,0x57,0xfe,0x7e,0x90,0xab,"WiaImgFmt_AVI"); + IF_GUID_EQUAL_RETURN(guid,0xb96b3cab,0x0728,0x11d3,0x9d,0x7b,0x00,0x00,0xf8,0x1e,0xf3,0x2e,"WiaImgFmt_BMP"); + IF_GUID_EQUAL_RETURN(guid,0x9821a8ab,0x3a7e,0x4215,0x94,0xe0,0xd2,0x7a,0x46,0x0c,0x03,0xb2,"WiaImgFmt_CIFF"); + IF_GUID_EQUAL_RETURN(guid,0x355bda24,0x5a9f,0x4494,0x80,0xdc,0xbe,0x75,0x2c,0xec,0xbc,0x8c,"WiaImgFmt_CSV"); + IF_GUID_EQUAL_RETURN(guid,0x369eeeab,0xa0e8,0x45ca,0x86,0xa6,0xa8,0x3c,0xe5,0x69,0x7e,0x28,"WiaImgFmt_DPOF"); + IF_GUID_EQUAL_RETURN(guid,0xb96b3cac,0x0728,0x11d3,0x9d,0x7b,0x00,0x00,0xf8,0x1e,0xf3,0x2e,"WiaImgFmt_EMF"); + IF_GUID_EQUAL_RETURN(guid,0x485da097,0x141e,0x4aa5,0xbb,0x3b,0xa5,0x61,0x8d,0x95,0xd0,0x2b,"WiaImgFmt_EXEC"); + IF_GUID_EQUAL_RETURN(guid,0xb96b3cb2,0x0728,0x11d3,0x9d,0x7b,0x00,0x00,0xf8,0x1e,0xf3,0x2e,"WiaImgFmt_EXIF"); + IF_GUID_EQUAL_RETURN(guid,0xb96b3cb4,0x0728,0x11d3,0x9d,0x7b,0x00,0x00,0xf8,0x1e,0xf3,0x2e,"WiaImgFmt_FLASHPIX"); + IF_GUID_EQUAL_RETURN(guid,0xb96b3cb0,0x0728,0x11d3,0x9d,0x7b,0x00,0x00,0xf8,0x1e,0xf3,0x2e,"WiaImgFmt_GIF"); + IF_GUID_EQUAL_RETURN(guid,0xc99a4e62,0x99de,0x4a94,0xac,0xca,0x71,0x95,0x6a,0xc2,0x97,0x7d,"WiaImgFmt_HTML"); + IF_GUID_EQUAL_RETURN(guid,0xb96b3cb5,0x0728,0x11d3,0x9d,0x7b,0x00,0x00,0xf8,0x1e,0xf3,0x2e,"WiaImgFmt_ICO"); + IF_GUID_EQUAL_RETURN(guid,0xbb8e7e67,0x283c,0x4235,0x9e,0x59,0x0b,0x9b,0xf9,0x4c,0xa6,0x87,"WiaImgFmt_JBIG2"); + IF_GUID_EQUAL_RETURN(guid,0x41e8dd92,0x2f0a,0x43d4,0x86,0x36,0xf1,0x61,0x4b,0xa1,0x1e,0x46,"WiaImgFmt_JBIG"); + IF_GUID_EQUAL_RETURN(guid,0x344ee2b2,0x39db,0x4dde,0x81,0x73,0xc4,0xb7,0x5f,0x8f,0x1e,0x49,"WiaImgFmt_JPEG2K"); + IF_GUID_EQUAL_RETURN(guid,0x43e14614,0xc80a,0x4850,0xba,0xf3,0x4b,0x15,0x2d,0xc8,0xda,0x27,"WiaImgFmt_JPEG2KX"); + IF_GUID_EQUAL_RETURN(guid,0xb96b3cae,0x0728,0x11d3,0x9d,0x7b,0x00,0x00,0xf8,0x1e,0xf3,0x2e,"WiaImgFmt_JPEG"); + IF_GUID_EQUAL_RETURN(guid,0xb96b3caa,0x0728,0x11d3,0x9d,0x7b,0x00,0x00,0xf8,0x1e,0xf3,0x2e,"WiaImgFmt_MEMORYBMP"); + IF_GUID_EQUAL_RETURN(guid,0xecd757e4,0xd2ec,0x4f57,0x95,0x5d,0xbc,0xf8,0xa9,0x7c,0x4e,0x52,"WiaImgFmt_MPG"); + IF_GUID_EQUAL_RETURN(guid,0x9980bd5b,0x3463,0x43c7,0xbd,0xca,0x3c,0xaa,0x14,0x6f,0x22,0x9f,"WiaImgFmt_PDFA"); + IF_GUID_EQUAL_RETURN(guid,0xb96b3cb3,0x0728,0x11d3,0x9d,0x7b,0x00,0x00,0xf8,0x1e,0xf3,0x2e,"WiaImgFmt_PHOTOCD"); + IF_GUID_EQUAL_RETURN(guid,0xa6bc85d8,0x6b3e,0x40ee,0xa9,0x5c,0x25,0xd4,0x82,0xe4,0x1a,0xdc,"WiaImgFmt_PICT"); + IF_GUID_EQUAL_RETURN(guid,0xb96b3caf,0x0728,0x11d3,0x9d,0x7b,0x00,0x00,0xf8,0x1e,0xf3,0x2e,"WiaImgFmt_PNG"); + IF_GUID_EQUAL_RETURN(guid,0x6f120719,0xf1a8,0x4e07,0x9a,0xde,0x9b,0x64,0xc6,0x3a,0x3d,0xcc,"WiaImgFmt_RAW"); + IF_GUID_EQUAL_RETURN(guid,0xda63f833,0xd26e,0x451e,0x90,0xd2,0xea,0x55,0xa1,0x36,0x5d,0x62,"WiaImgFmt_RAWBAR"); + IF_GUID_EQUAL_RETURN(guid,0x22c4f058,0x0d88,0x409c,0xac,0x1c,0xee,0xc1,0x2b,0x0e,0xa6,0x80,"WiaImgFmt_RAWMIC"); + IF_GUID_EQUAL_RETURN(guid,0x7760507c,0x5064,0x400c,0x9a,0x17,0x57,0x56,0x24,0xd8,0x82,0x4b,"WiaImgFmt_RAWPAT"); + IF_GUID_EQUAL_RETURN(guid,0xbca48b55,0xf272,0x4371,0xb0,0xf1,0x4a,0x15,0x0d,0x05,0x7b,0xb4,"WiaImgFmt_RAWRGB"); + IF_GUID_EQUAL_RETURN(guid,0x573dd6a3,0x4834,0x432d,0xa9,0xb5,0xe1,0x98,0xdd,0x9e,0x89,0x0d,"WiaImgFmt_RTF"); + IF_GUID_EQUAL_RETURN(guid,0xfe7d6c53,0x2dac,0x446a,0xb0,0xbd,0xd7,0x3e,0x21,0xe9,0x24,0xc9,"WiaImgFmt_SCRIPT"); + IF_GUID_EQUAL_RETURN(guid,0xb96b3cb1,0x0728,0x11d3,0x9d,0x7b,0x00,0x00,0xf8,0x1e,0xf3,0x2e,"WiaImgFmt_TIFF"); + IF_GUID_EQUAL_RETURN(guid,0xfafd4d82,0x723f,0x421f,0x93,0x18,0x30,0x50,0x1a,0xc4,0x4b,0x59,"WiaImgFmt_TXT"); + IF_GUID_EQUAL_RETURN(guid,0xb96b3ca9,0x0728,0x11d3,0x9d,0x7b,0x00,0x00,0xf8,0x1e,0xf3,0x2e,"WiaImgFmt_UNDEFINED"); + IF_GUID_EQUAL_RETURN(guid,0x1b7639b6,0x6357,0x47d1,0x9a,0x07,0x12,0x45,0x2d,0xc0,0x73,0xe9,"WiaImgFmt_UNICODE16"); + IF_GUID_EQUAL_RETURN(guid,0xb96b3cad,0x0728,0x11d3,0x9d,0x7b,0x00,0x00,0xf8,0x1e,0xf3,0x2e,"WiaImgFmt_WMF"); + IF_GUID_EQUAL_RETURN(guid,0xb9171457,0xdac8,0x4884,0xb3,0x93,0x15,0xb4,0x71,0xd5,0xf0,0x7e,"WiaImgFmt_XML"); + IF_GUID_EQUAL_RETURN(guid,0x6235701c,0x3a98,0x484c,0xb2,0xa8,0xfd,0xff,0xd8,0x7e,0x6b,0x16,"WiaImgFmt_XMLBAR"); + IF_GUID_EQUAL_RETURN(guid,0x2d164c61,0xb9ae,0x4b23,0x89,0x73,0xc7,0x06,0x7e,0x1f,0xbd,0x31,"WiaImgFmt_XMLMIC"); + IF_GUID_EQUAL_RETURN(guid,0xf8986f55,0xf052,0x460d,0x95,0x23,0x3a,0x7d,0xfe,0xdb,0xb3,0x3c,"WiaImgFmt_XMLPAT"); + IF_GUID_EQUAL_RETURN(guid,0x700b4a0f,0x2011,0x411c,0xb4,0x30,0xd1,0xe0,0xb2,0xe1,0x0b,0x28,"WiaImgFmt_XPS"); + IF_GUID_EQUAL_RETURN(guid,0xda812bff,0x12c3,0x46a2,0x8e,0x2b,0xdb,0xd3,0xb7,0x83,0x4c,0x43,"WinUSB_TestGuid"); + IF_GUID_EQUAL_RETURN(guid,0x64fff53f,0x635d,0x41c1,0x95,0x0c,0xcb,0x5a,0xdf,0xbe,0x28,0xe3,"Window_CanMaximize_Property_GUID"); + IF_GUID_EQUAL_RETURN(guid,0xb73b4625,0x5988,0x4b97,0xb4,0xc2,0xa6,0xfe,0x6e,0x78,0xc8,0xc6,"Window_CanMinimize_Property_GUID"); + IF_GUID_EQUAL_RETURN(guid,0xe13a7242,0xf462,0x4f4d,0xae,0xc1,0x53,0xb2,0x8d,0x6c,0x32,0x90,"Window_Control_GUID"); + IF_GUID_EQUAL_RETURN(guid,0xff4e6892,0x37b9,0x4fca,0x85,0x32,0xff,0xe6,0x74,0xec,0xfe,0xed,"Window_IsModal_Property_GUID"); + IF_GUID_EQUAL_RETURN(guid,0xef7d85d3,0x0937,0x4962,0x92,0x41,0xb6,0x23,0x45,0xf2,0x40,0x41,"Window_IsTopmost_Property_GUID"); + IF_GUID_EQUAL_RETURN(guid,0x27901735,0xc760,0x4994,0xad,0x11,0x59,0x19,0xe6,0x06,0xb1,0x10,"Window_Pattern_GUID"); + IF_GUID_EQUAL_RETURN(guid,0xedf141f8,0xfa67,0x4e22,0xbb,0xf7,0x94,0x4e,0x05,0x73,0x5e,0xe2,"Window_WindowClosed_Event_GUID"); + IF_GUID_EQUAL_RETURN(guid,0x4fed26a4,0x0455,0x4fa2,0xb2,0x1c,0xc4,0xda,0x2d,0xb1,0xff,0x9c,"Window_WindowInteractionState_Property_GUID"); + IF_GUID_EQUAL_RETURN(guid,0xd3e81d06,0xde45,0x4f2f,0x96,0x33,0xde,0x9e,0x02,0xfb,0x65,0xaf,"Window_WindowOpened_Event_GUID"); + IF_GUID_EQUAL_RETURN(guid,0x4ab7905f,0xe860,0x453e,0xa3,0x0a,0xf6,0x43,0x1e,0x5d,0xaa,0xd5,"Window_WindowVisualState_Property_GUID"); + return ret; +} + +std::string GetGUIDName(const GUID& guid) { + std::string ret = GetGUIDNameConst(guid); + if (!ret.empty()) + return ret; + else { + comet::task_ptr pStr; + StringFromCLSID(guid, pStr.out()); + return comet::bstr_t(pStr.in()).s_str(); + } +} \ No newline at end of file diff --git a/EyeTab_SP2/ReadMe.txt b/EyeTab_SP2/ReadMe.txt new file mode 100644 index 0000000..fa30a87 --- /dev/null +++ b/EyeTab_SP2/ReadMe.txt @@ -0,0 +1,40 @@ +======================================================================== + CONSOLE APPLICATION : EyeTab_SP2 Project Overview +======================================================================== + +AppWizard has created this EyeTab_SP2 application for you. + +This file contains a summary of what you will find in each of the files that +make up your EyeTab_SP2 application. + + +EyeTab_SP2.vcxproj + This is the main project file for VC++ projects generated using an Application Wizard. + It contains information about the version of Visual C++ that generated the file, and + information about the platforms, configurations, and project features selected with the + Application Wizard. + +EyeTab_SP2.vcxproj.filters + This is the filters file for VC++ projects generated using an Application Wizard. + It contains information about the association between the files in your project + and the filters. This association is used in the IDE to show grouping of files with + similar extensions under a specific node (for e.g. ".cpp" files are associated with the + "Source Files" filter). + +EyeTab_SP2.cpp + This is the main application source file. + +///////////////////////////////////////////////////////////////////////////// +Other standard files: + +StdAfx.h, StdAfx.cpp + These files are used to build a precompiled header (PCH) file + named EyeTab_SP2.pch and a precompiled types file named StdAfx.obj. + +///////////////////////////////////////////////////////////////////////////// +Other notes: + +AppWizard uses "TODO:" comments to indicate parts of the source code you +should add to or customize. + +///////////////////////////////////////////////////////////////////////////// diff --git a/EyeTab_SP2/comet/array.h b/EyeTab_SP2/comet/array.h new file mode 100644 index 0000000..f305f74 --- /dev/null +++ b/EyeTab_SP2/comet/array.h @@ -0,0 +1,150 @@ +/** \file +* Array wrapper. +*/ +/* +* Copyright © 2001 Sofus Mortensen +* +* This material is provided "as is", with absolutely no warranty +* expressed or implied. Any use is at your own risk. Permission to +* use or copy this software for any purpose is hereby granted without +* fee, provided the above notices are retained on all copies. +* Permission to modify the code and to distribute modified code is +* granted, provided the above notices are retained, and a notice that +* the code was modified is included with the above copyright notice. +* +* This header is part of Comet version 2. +* https://github.com/alamaison/comet +* +*/ + +/* +* comet::array_t is adapted from class array by Nicolai M. Josuttis +* +* (C) Copyright Nicolai M. Josuttis 2001. +* Permission to copy, use, modify, sell and distribute this software +* is granted provided this copyright notice appears in all copies. +* This software is provided "as is" without express or implied +* warranty, and with no claim as to its suitability for any purpose. +* +*/ + +#ifndef COMET_ARRAY_H +#define COMET_ARRAY_H + +#include +#include +#include +#include +#include + +namespace comet { + +#pragma pack(push) +#pragma pack(1) + + /*!\addtogroup Misc + */ + //@{ + + template class array_t + { + T a_[SZ]; + public: + typedef T value_type; + typedef typename std::vector::iterator iterator; + typedef typename std::vector::const_iterator const_iterator; + + typedef typename std::vector::reverse_iterator reverse_iterator; + typedef typename std::vector::const_reverse_iterator const_reverse_iterator; + + typedef typename std::vector::size_type size_type; + typedef typename std::vector::difference_type difference_type; + + typedef T& reference; + typedef const T& const_reference; + + // reference operator[](size_type i) { return a_[i]; } + // const_reference operator[](size_type i) const { return a_[i]; } + + iterator begin() { return iterator(a_); } + iterator end() { return iterator(a_ + SZ); } + const_iterator begin() const { return const_iterator(a_); } + const_iterator end() const { return const_iterator(a_ + SZ); } + + reverse_iterator rbegin() { return reverse_iterator(a_); } + reverse_iterator rend() { return reverse_iterator(a_ + SZ); } + const_reverse_iterator rbegin() const { return const_reverse_iterator(a_); } + const_reverse_iterator rend() const { return const_reverse_iterator(a_ + SZ); } + + operator const T*() const { return a_; } + operator T*() { return a_; } + + static size_type size() { return SZ; } + static bool empty() { return false; } + static size_type max_size() { return SZ; } + enum { static_size = SZ }; + + reference front() { return a_[0]; } + const_reference front() const { return a_[0]; } + reference back() { return a_[SZ-1]; }; + const_reference back() const { return a_[SZ-1]; } + + // swap (note: linear complexity) + void swap (array_t& y) { + std::swap_ranges(begin(),end(),y.begin()); + } + + // assignment with type conversion + template + array_t& operator= (const array_t& rhs) { + std::copy(rhs.begin(),rhs.end(), begin()); + return *this; + } + + // assign one value to all elements + void assign (const T& value) + { + std::fill_n(begin(),size(),value); + } + + reference at(size_type i) { rangecheck(i); return a_[i]; } + const_reference at(size_type i) const { rangecheck(i); return a_[i]; } + + private: + // check range (may be private because it is static) + static void rangecheck (size_type i) { + if (i >= size()) { throw std::range_error("array"); } + } + + }; + //@} +#pragma pack(pop) + + // comparisons + template + bool operator== (const array_t& x, const array_t& y) { + return std::equal(x.begin(), x.end(), y.begin()); + } + template + bool operator< (const array_t& x, const array_t& y) { + return std::lexicographical_compare(x.begin(),x.end(),y.begin(),y.end()); + } + template + bool operator!= (const array_t& x, const array_t& y) { + return !(x==y); + } + template + bool operator> (const array_t& x, const array_t& y) { + return y + bool operator<= (const array_t& x, const array_t& y) { + return !(y + bool operator>= (const array_t& x, const array_t& y) { + return !(x + +# if defined(COMET_ASSERT_THROWS) || defined(COMET_ASSERT_THROWS_ALWAYS) +# if defined(COMET_ASSERT_THROWS_ALWAYS) || !defined(NDEBUG) +namespace comet +{ + /*! \defgroup ErrorHandling Error handling. + */ + //@{ +//! Indicates a comet assertion failed. +/** This is enabled for debug builds if COMET_ASSERT_THROWS is defined and + * enabled for both debug and release if COMET_ASSERT_THROWS_ALWAYS is defined. + */ +struct assert_failed : std::runtime_error +{ + assert_failed( const char *val) : runtime_error(val) {} +}; + //@} +} +# define COMET_ASSERT(x_) if (x_) ; else throw comet::assert_failed("Assert Failed: " #x_ ); +# define COMET_THROWS_ASSERT throw( comet::assert_failed) +# else +# define COMET_ASSERT(x_) ; +# endif + +# else +# define COMET_THROWS_ASSERT throw() +# ifndef __CYGWIN__ + +# include +# define COMET_ASSERT _ASSERTE + +# else + +# include +# define COMET_ASSERT assert +# endif +# endif +/*! \addtogroup ErrorHandling + */ +//@{ +/** \def COMET_ASSERT Assertion in commet. + * \sa COMET_THROWS_ASSERT COMET_ASSERT_THROWS_ALWAYS + */ + //@} + +#endif diff --git a/EyeTab_SP2/comet/atl_module.h b/EyeTab_SP2/comet/atl_module.h new file mode 100644 index 0000000..5c37bdc --- /dev/null +++ b/EyeTab_SP2/comet/atl_module.h @@ -0,0 +1,121 @@ +/** \file + * ATL Module Compatability wrapper. + */ +/* + * Copyright © 2000, 2001 Paul Hollingsworth, Michael Geddes + * Copyright © 2013 Alexander Lamaison + * + * This material is provided "as is", with absolutely no warranty + * expressed or implied. Any use is at your own risk. Permission to + * use or copy this software for any purpose is hereby granted without + * fee, provided the above notices are retained on all copies. + * Permission to modify the code and to distribute modified code is + * granted, provided the above notices are retained, and a notice that + * the code was modified is included with the above copyright notice. + * + * This header is part of Comet version 2. + * https://github.com/alamaison/comet + */ + +#ifndef COMET_ATL_MODULE_H +#define COMET_ATL_MODULE_H + +#include + +#include + +namespace comet { + /*! \defgroup ATL ATL conversion. + */ + //@{ + + /** \struct declspec_comtype atl_module.h comet/atl_module.h + * Helper to create a 'comtype' for a non-comet interface. + * \code + * namespace comet{ + * template<> struct comtype : + * declspec_comtype + * { }; + * }; + * \endcode + * + */ + template struct declspec_comtype + { + static const uuid_t& uuid() { return uuid_t::create_const_reference(__uuidof(ITF)); } + typedef BASE base; + }; + + + /// Placeholder for an empty comet typelibrary. + struct empty_typelib + { + typedef nil coclasses; + }; + + template + class atl_module_ex : public ATL_MODULE + { + // ATL will take the responsibility of registering the embedded type library. + public: + HRESULT Init(_ATL_OBJMAP_ENTRY* p, HINSTANCE h, const GUID* plibid = NULL) + { + module().instance(h); + return ATL_MODULE::Init(p, h, plibid); + } + + HRESULT RegisterServer(BOOL bRegTypeLib = FALSE, const CLSID* pCLSID = NULL) + { + HRESULT hr = ATL_MODULE::RegisterServer(bRegTypeLib, pCLSID); + if(SUCCEEDED(hr)) + hr = COM_SERVER::DllRegisterServer(); + return hr; + } + + HRESULT UnregisterServer(BOOL bUnRegTypeLib, const CLSID* pCLSID = NULL) + { + COM_SERVER::DllUnregisterServer(); + return ATL_MODULE::UnregisterServer(bUnRegTypeLib, pCLSID); + } + + HRESULT GetClassObject(REFCLSID rclsid, REFIID riid, LPVOID* ppv) + { + HRESULT hr = COM_SERVER::DllGetClassObject( rclsid, riid, ppv); + if( hr == CLASS_E_CLASSNOTAVAILABLE ) + { + hr = ATL_MODULE::GetClassObject(rclsid, riid,ppv); + } + return hr; + } + + LONG GetLockCount() + { + return module().rc() + ATL_MODULE::GetLockCount(); + } + }; + + /** Wraps an ATL::CComModule to provide co-existing ATL/Comet co-classes. + * ATL will take responsibility for registering the embedded type-library. + * + * Here is an example of how to use it: + * \code + * struct typelib_subset + * { + * typedef COMET_STRICT_TYPENAME comet::typelist::make_list< CoClass1, CoClass2 > coclasses; + * }; + * comet::atl_module _Module; + * \endcode + * And in std.h: + * \code + * struct typelib_subset; + * extern comet::atl_module _Module; + * \endcode + */ + template + class atl_module : public atl_module_ex< com_server >, ATL_MODULE > + { + }; + //@} +} // namespace comet + +#endif diff --git a/EyeTab_SP2/comet/auto_buffer.h b/EyeTab_SP2/comet/auto_buffer.h new file mode 100644 index 0000000..0a304bd --- /dev/null +++ b/EyeTab_SP2/comet/auto_buffer.h @@ -0,0 +1,99 @@ +/** \file + * Simple uncopyable buffer class. + */ + /* + * Copyright © 2004, Michael Geddes, Lijun Qin. + * + * This material is provided "as is", with absolutely no warranty + * expressed or implied. Any use is at your own risk. Permission to + * use or copy this software for any purpose is hereby granted without + * fee, provided the above notices are retained on all copies. + * Permission to modify the code and to distribute modified code is + * granted, provided the above notices are retained, and a notice that + * the code was modified is included with the above copyright notice. + * + * This header is part of Comet version 2. + * https://github.com/alamaison/comet + */ + +#ifndef INCLUDE_COMET_AUTO_BUFFER_H +#define INCLUDE_COMET_AUTO_BUFFER_H + +#ifdef _SHOW_INC +#pragma message(" #Include " __FILE__) +#endif + +namespace comet +{ + /*!\addtogroup Misc + */ + //@{ + + /** \class auto_buffer_t auto_buffer.h comet/auto_buffer.h + * Simle auto-deleting buffer class. + * Non-copyable /returnable. + */ + template + class auto_buffer_t + { + public: + typedef size_t size_type; + /** Create a buffer of the given size. + * This is the only valid constructor. + */ + explicit auto_buffer_t(size_type size) + { + begin_ = new T[size]; + } + /// Auto-delete the buffer. + ~auto_buffer_t() throw() { delete[] begin_; } + + /// Clear the buffer. + void clear() throw() + { + delete[] begin_; + begin_ = 0; + } + /// Is the buffer empty. + bool empty() const throw() + { + return begin_ != NULL; + } + /// Resize the buffer. + void resize( size_type newSize) throw() + { + delete[] begin_; + begin_ = new T[newSize]; + } + + /// Return a reference to the specifed element. + T & at( size_type t) throw() { return begin_[t]; } + T & operator[]( size_type t) throw() { return begin_[t]; } + /// Return a const reference to the specifed element. + const T & at( size_type t) const throw() { return begin_[t]; } + const T & operator[]( size_type t) const throw() { return begin_[t]; } + + /// Detatch the memory. + T *detach() + { + T *val = begin_; + begin_ = NULL; + return val; + } + /// Return the memory. + T *get() { return begin_; } + const T *get()const { return begin_; } + + private: + /// Can't assign. + auto_buffer_t &operator=(const auto_buffer_t &); + /// can't copy. + auto_buffer_t(const auto_buffer_t&); + + /// Pointer to memory. + T *begin_; + }; + //@} +} + +#endif /* INCLUDE_COMET_AUTO_BUFFER_H */ diff --git a/EyeTab_SP2/comet/bstr.h b/EyeTab_SP2/comet/bstr.h new file mode 100644 index 0000000..23fd332 --- /dev/null +++ b/EyeTab_SP2/comet/bstr.h @@ -0,0 +1,948 @@ +/** \file + * BSTR wrapper classes. + */ +/* + * Copyright © 2000-2004 Sofus Mortensen, Michael Geddes + * Copyright © 2012 Alexander Lamaison + * + * This material is provided "as is", with absolutely no warranty + * expressed or implied. Any use is at your own risk. Permission to + * use or copy this software for any purpose is hereby granted without + * fee, provided the above notices are retained on all copies. + * Permission to modify the code and to distribute modified code is + * granted, provided the above notices are retained, and a notice that + * the code was modified is included with the above copyright notice. + * + * This header is part of Comet version 2. + * https://github.com/alamaison/comet + */ + +#ifndef COMET_BSTR_H +#define COMET_BSTR_H + +#include + +#ifdef COMET_BROKEN_WTYPES +#include +#endif // COMET_BROKEN_WTYPES +#include +#include +#include +#ifndef COMET_GCC_HEADERS +#include +#endif // COMET_GCC_HEADERS + +#include +#include +#undef max +#include + +#include +#include +#include +#include +#include +#include +#include + +#pragma warning(push) +#pragma warning(disable : 4522 4521) + +#pragma comment( lib, "oleaut32" ) + +namespace comet { + +#ifndef NORM_IGNOREKASHIDA +#define NORM_IGNOREKASHIDA 0x00040000 +#endif // NORM_IGNOREKASHIDA + /*! \addtogroup COMType + */ + //@{ + //! Comparsion flags. + /*! Can be used with \link comet::bstr_t::cmp cmp \endlink or the comparsion functors. + \sa cmp + less + less_equal + greater + greater_equal + equal_to + not_equal_to + */ + + enum compare_flags_t + { + cf_ignore_case = NORM_IGNORECASE, //!< Ignore case. + cf_ingore_nonspace = NORM_IGNORENONSPACE, //!< Ignore nonspacing chars. + cf_ignore_symbols = NORM_IGNORESYMBOLS, //!< Ignore symbols. + cf_ignore_width = NORM_IGNOREWIDTH, //!< Ignore string width. + cf_ignore_kanatype = NORM_IGNOREKANATYPE, //!< Ignore Kana type. + cf_ignore_kashida = NORM_IGNOREKASHIDA //!< Ignore Arabic kashida characters. + }; + //@} + + namespace impl { + + inline const wchar_t* null_to_empty(const wchar_t* s) + { return s ? s : L""; } + + } // namespace + + + /*! \addtogroup COMType + */ + //@{ + + /*! \class bstr_t bstr.h comet/bstr.h + * BSTR Wrapper. + * \sa bstr_t + */ + class bstr_t { + public: + typedef wchar_t value_type; +#if !(defined(_STLP_DEBUG) || (defined(_HAS_ITERATOR_DEBUGGING)) && _MSC_VER >= 1400) + typedef std::wstring::iterator iterator; + typedef std::wstring::const_iterator const_iterator; + + typedef std::wstring::reverse_iterator reverse_iterator; + typedef std::wstring::const_reverse_iterator const_reverse_iterator; +#else // _STLP_DEBUG + typedef wchar_t *iterator; + typedef const wchar_t *const_iterator; +#if defined(COMET_STD_ITERATOR) + typedef std::reverse_iterator reverse_iterator; + typedef std::reverse_iterator const_reverse_iterator; +#else + // workaround for broken reverse_iterator implementations due to no partial specialisation + typedef std::reverse_iterator reverse_iterator; + typedef std::reverse_iterator const_reverse_iterator; +#endif +#endif // _STLP_DEBUG + + typedef std::wstring::size_type size_type; + typedef std::wstring::difference_type difference_type; + + typedef wchar_t& reference; + typedef const wchar_t const_reference; + + private: + BSTR str_; + + void construct() { str_ = 0; } + void construct(BSTR s, bool copy) throw(std::bad_alloc) + { if (copy) str_ = copy_str(s); else str_ = s; } + + void construct(const wchar_t* s) throw(std::bad_alloc) + { str_ = copy_str(s); } + + void construct(const wchar_t* s, size_t len) throw(std::bad_alloc) + { str_ = copy_str(s, len); } + + void construct(const char* s) throw(std::bad_alloc, std::runtime_error) { + convert_str(s, -1); + } + + void construct(const char* s, size_t len) + { + if (len >= static_cast(std::numeric_limits::max())) + throw std::length_error( + "String exceeded maximum length for conversion"); + + convert_str(s, static_cast(len+1)); + } + + void construct(const uuid_t& u, bool braces) + { + str_ = impl::bad_alloc_check(::SysAllocStringLen(0, braces?38:36)); + u.copy_to_str(str_+(braces?1:0)); + if (braces) + { + str_[0]=L'{'; + str_[37]=L'}'; + } + } + + void construct(const wchar_t* s1, size_t l1, const wchar_t* s2, size_t l2) throw(std::bad_alloc) + { + str_ = impl::bad_alloc_check(::SysAllocStringLen(NULL, UINT(l1+l2))); + if (l1) memcpy(str_, s1, sizeof(wchar_t)*(l1)); + if (l2) memcpy(str_+l1, s2, sizeof(wchar_t)*(1+l2)); + } + + void destroy() throw() + { if (str_) ::SysFreeString(str_); } + + bool is_regular() const throw() + { return !str_ || length() == wcslen(str_); } + + static BSTR copy_str(const wchar_t* src) throw(std::bad_alloc) + { return src ? impl::bad_alloc_check(::SysAllocString(src)) : 0; } + + static BSTR copy_str(const wchar_t* src, size_t len) throw(std::bad_alloc) + { return src ? impl::bad_alloc_check(::SysAllocStringLen(src, UINT(len))) : 0; } + + static BSTR copy_str(BSTR src) throw(std::bad_alloc) + { return src ? impl::bad_alloc_check(::SysAllocStringLen(src, ::SysStringLen(src))) : 0; } + + void convert_str(const char* s, int l) throw(std::bad_alloc, std::runtime_error) + { + if (s != 0) { +#if defined(_MBCS) || !defined(COMET_NO_MBCS) + int wl = ::MultiByteToWideChar(CP_ACP, 0, s, l, NULL,0); +#else + int wl = ((l>=0)?l: (1+strlen(s))); + COMET_ASSERT( wl == ::MultiByteToWideChar( CP_ACP, 0, s, l, NULL,0)); +#endif + str_ = impl::bad_alloc_check(::SysAllocStringLen(0, wl - 1)); + if (::MultiByteToWideChar(CP_ACP, 0, s, l, str_, wl) == 0) + { + destroy(); + throw std::runtime_error("MultiByteToWideChar has failed"); + } + } else str_ = 0; + } + + public: + /*! Default constructor + Constructs a null string. + */ + bstr_t() throw() + { + construct(); + } + + //! Copy constructor + /*! + \param s + String initialise bstr_t from. + + \exception std::bad_alloc + On memory exhaustion std::bad_alloc is thrown. + */ + bstr_t(const bstr_t& s) throw(std::bad_alloc) + { + construct(s.str_, true); + } + + //! Construct string from const wchar_t* + /*! + \param s + String to initialise bstr_t from. + + \exception std::bad_alloc + On memory exhaustion std::bad_alloc is thrown. + */ + bstr_t(const wchar_t* s) throw(std::bad_alloc) + { + construct(s); + } + + bstr_t(const wchar_t* s, size_t len) throw(std::bad_alloc) + { + construct(s, len); + } + + //! Construct string from const char* + /*! + \param s + String to initialise bstr_t from. + + \exception std::bad_alloc + On memory exhaustion std::bad_alloc is thrown. + \exception std::runtime_error + Should string conversion fail, std::runtime_error will be thrown. + */ + bstr_t(const char* s) throw(std::runtime_error) + { + construct(s); + } + + bstr_t(const char* s, size_t len) throw(std::bad_alloc) + { + construct(s, len); + } + + //! Construct string from const std::string& + /*! + \param s + String to initialise bstr_t from. + + \exception std::bad_alloc + On memory exhaustion std::bad_alloc is thrown. + \exception std::length_error + If this given string is too long to be converted, + std::length_error is thrown. + \exception std::runtime_error + Should string conversion fail, std::runtime_error is thrown. + */ + bstr_t(const std::string& s) + { + construct(s.c_str(), s.length()); + } + + //! Construct string from BSTR + /*! + Takes ownership of specified BSTR. To prevent misuse the BSTR must be wrapped using auto_attach. + + \code + bstr_t bs( auto_attach( myBSTR ) ); + \endcode + + \param s + String to initialise bstr_t from. + */ + bstr_t(const impl::auto_attach_t& s) throw() + { + construct(s.get(), false); + } + + + //! Construct string from const std::wstring& + /*! + \param s + String to initialise bstr_t from. + + \exception std::bad_alloc + On memory exhaustion std::bad_alloc is thrown. + */ + bstr_t(const std::wstring& s) throw(std::bad_alloc) + { + construct(s.c_str(), s.length()); + } + + explicit bstr_t(size_type sz, wchar_t c) throw(std::bad_alloc) + { + str_ = impl::bad_alloc_check(::SysAllocStringLen(0, UINT(sz))); + std::fill(begin(), end(), c); + } + + explicit bstr_t(size_type sz) throw(std::bad_alloc) + { + str_ = impl::bad_alloc_check(::SysAllocStringLen(0, UINT(sz))); + } + + template + explicit bstr_t(IT first, IT last) + { + str_ = 0; + assign(first, last); + } + + explicit bstr_t(const uuid_t& u, bool braces = false) + { + construct(u, braces); + } + + private: + bstr_t(const wchar_t* s1, size_t l1, const wchar_t* s2, size_t l2) throw(std::bad_alloc) + { + construct(s1, l1, s2, l2); + } + + public: + //! Destructor + /*! + Deletes the wrapped BSTR. + */ + ~bstr_t() throw() + { + destroy(); + } + + //! Swap + void swap(bstr_t& x) throw() + { + std::swap(str_, x.str_); + } + + //! Explicit conversion to const wchar_t* + const wchar_t* c_str() const throw() + { return impl::null_to_empty(str_); } + + //! Explicit conversion to std::wstring + std::wstring w_str() const throw() + { return impl::null_to_empty(str_); } + +#ifdef _MBCS +#ifndef COMET_NO_MBCS_WARNING +#pragma message( "Warning: _MBCS is defined. bstr_t::s_str may return an std::string containing multibyte characters" ) +#endif +#endif + + //! Explicit conversion to std::string + std::string s_str() const + { + if (is_empty()) return std::string(); + + if (length() > static_cast(std::numeric_limits::max())) + throw std::length_error("String is too large to be converted"); + + int ol = static_cast(length()); + +#if defined(_MBCS) || !defined(COMET_NO_MBCS) + // Calculate the required length of the buffer + int l = WideCharToMultiByte(CP_ACP, 0, str_, ol, NULL, 0, NULL, NULL); +#else // _MBCS + int l = ol; + COMET_ASSERT( l == WideCharToMultiByte(CP_ACP, 0, str_, ol, NULL, 0, NULL, NULL)); +#endif // _MBCS + + // Create the buffer + std::string rv(l, std::string::value_type()); + // Do the conversion. + if (0 == WideCharToMultiByte( + CP_ACP, 0, str_, ol, &rv[0], l, NULL, NULL)) + { + DWORD err = GetLastError(); + raise_exception(HRESULT_FROM_WIN32(err)); + } + + return rv; + } + + //! Explicit conversion to "tstring". +#ifdef _UNICODE + std::wstring t_str() const + { + return w_str(); + } +#else + std::string t_str() const + { + return s_str(); + } +#endif + + //! Implicit conversion to std::wstring + operator std::wstring() const { return w_str(); } + + //! Implicit conversion to std::string + operator std::string() const { return s_str(); } + + //! Returns true if and only if wrapped str is null + bool is_null() const throw() + { return str_ == 0; } + + /** Returns true if and only if wrapped str has zero length. + */ + bool is_empty() const throw() { return length() == 0; } + + //! Returns true if and only if wrapped str has zero length. + bool empty() const throw() { return length() == 0; } + + //! Returns length of wrapped string. + size_t length() const throw() + { return is_null() ? 0 : ::SysStringLen(str_); } + + size_t size() const throw() + { return length(); } + + /*! \internal */ + BSTR get_raw() const + { return str_; } + + friend + std::basic_ostream &operator<<(std::basic_ostream &os, const bstr_t &val) + { os << val.s_str(); return os; } + + friend + std::basic_ostream &operator<<(std::basic_ostream &os, const bstr_t &val) + { os << val.w_str(); return os; } + + /// \name Boolean operators + //@{ + + bool operator==(const wchar_t* s) const + { return 0 == wcscmp(c_str(), impl::null_to_empty(s) ) && is_regular(); } + + bool operator!=(const wchar_t* s) const + { return !operator==(s); } + + bool operator<(const wchar_t* s) const + { return wcscmp(c_str(), impl::null_to_empty(s)) < 0 && is_regular(); } + + bool operator>(const wchar_t* s) const + { return wcscmp(c_str(), impl::null_to_empty(s)) > 0 && !is_regular(); } + + bool operator>=(const wchar_t* s) const + { return !operator<(s); } + + bool operator<=(const wchar_t* s) const + { return !operator>(s); } + + bool operator==(const std::wstring& s) const + { + size_t l = length(); + if (l != s.length()) return false; + return 0 == memcmp(str_, s.c_str(), sizeof(wchar_t)*l); + } + + bool operator!=(const std::wstring& s) const + { return !operator==(s); } + + bool operator<(const std::wstring& s) const + { return std::lexicographical_compare(str_, str_+length(), s.begin(), s.end()); } + + bool operator>(const std::wstring& s) const + { return std::lexicographical_compare(str_, str_+length(), s.begin(), s.end(), std::greater()); } + + bool operator>=(const std::wstring& s) const + { return !operator<(s); } + + bool operator<=(const std::wstring& s) const + { return !operator>(s); } + + bool operator==(const bstr_t& s) const + { + if (str_ == 0 && s.str_ == 0) return true; + return ::VarBstrCmp(str_, s.str_, ::GetThreadLocale(), 0) == VARCMP_EQ; + } + + bool operator!=(const bstr_t& s) const + { return !operator==(s); } + + bool operator<(const bstr_t& s) const + { + if (str_ == 0) { + return s.str_ != 0; + } + + if (s.str_ == 0) return false; + + return ::VarBstrCmp(str_, s.str_, ::GetThreadLocale(), 0) == VARCMP_LT; + } + + bool operator>(const bstr_t& s) const + { + if (str_ == 0) { + return s.str_ != 0; + } + + if (s.str_ == 0) return false; + + return ::VarBstrCmp(str_, s.str_, ::GetThreadLocale(), 0) == VARCMP_GT; + } + + bool operator>=(const bstr_t& s) const + { return !operator<(s); } + + bool operator<=(const bstr_t& s) const + { return !operator>(s); } + //@} + + //! String comparsion function. + /*! \param s String to compare + \param flags Comparison Flags + \retval <0 if less + \retval 0 if Equal + \retval >0 if greater + */ + int cmp(const bstr_t& s, compare_flags_t flags = compare_flags_t(0)) const + { + HRESULT res = ::VarBstrCmp(str_, s.str_, ::GetThreadLocale(), flags); + switch(res) + { + case VARCMP_EQ: return 0; + case VARCMP_GT: return 1; + case VARCMP_LT: return -1; + case VARCMP_NULL: + return ((str_==0)?0:1) - ((s.str_==0)?0:1); + } + if (str_==0 || s.str_ ==0) + return ((str_==0)?0:1) - ((s.str_==0)?0:1); + raise_exception(res); return 0; + } + + //!\name Comparison Functors + //@{ + //! Less Functor. + /*! Useful for STL containers. + \code + typedef stl::map < comet::bstr_t, long, bstr_t::less > string_long_map; + \endcode + \param CF comparison flags. + \relates bstr_t + */ + template + struct less : std::binary_function< bstr_t,bstr_t,bool>{ + /// Functor. + bool operator()(const bstr_t& l, const bstr_t& r) const + { return l.cmp(r, CF) <0; } + }; + + //! less or equal functor. + /*! \relates bstr_t */ + template + struct less_equal : std::binary_function< bstr_t,bstr_t,bool> { + /// Functor. + bool operator()(const bstr_t& l, const bstr_t& r) const + { return l.cmp(r, CF) <=0; } + }; + + //! greater functor. + /*! \relates bstr_t */ + template + struct greater : std::binary_function< bstr_t,bstr_t,bool> { + /// Functor. + bool operator()(const bstr_t& l, const bstr_t& r) const + { return l.cmp(r, CF) > 0; } + }; + + //! greater or equal functor. + /*! \relates bstr_t */ + template + struct greater_equal : std::binary_function< bstr_t,bstr_t,bool> { + /// Functor. + bool operator()(const bstr_t& l, const bstr_t& r) const + { return l.cmp(r, CF) >=0; } + }; + + //! equality functor. + template + struct equal_to : std::binary_function< bstr_t,bstr_t,bool> { + bool operator()(const bstr_t& l, const bstr_t& r) const + { return l.cmp(r, CF) == 0; } + }; + + //! Inequality functor. + /*! \relates bstr_t */ + template + struct not_equal_to : std::binary_function< bstr_t,bstr_t,bool>{ + /// Functor. + bool operator()(const bstr_t& l, const bstr_t& r) const + { return l.cmp(r, CF) != 0; } + }; + //@} + + iterator begin() { return iterator(str_); } + iterator end() { return iterator(str_ + length()); } + const_iterator begin() const { return const_iterator(str_); } + const_iterator end() const { return const_iterator(str_ + length()); } + + reverse_iterator rbegin() { return reverse_iterator(str_); } + reverse_iterator rend() { return reverse_iterator(str_ + length()); } + const_reverse_iterator rbegin() const { return const_reverse_iterator(str_); } + const_reverse_iterator rend() const { return const_reverse_iterator(str_ + length()); } + + reference at(size_type i) { rangecheck(i); return str_[i]; } + const_reference at(size_type i) const { rangecheck(i); return str_[i]; } + + private: + // check range (may be private because it is static) + void rangecheck (size_type i) const { + if (i >= length()) { throw std::range_error("bstr_t"); } + } + + public: + const_reference operator[](size_type idx) const + { return str_[idx]; } + + reference operator[](size_type idx) + { return str_[idx]; } + + //! Assign string to be \p sz of character \p c . + void assign(size_type sz, wchar_t c) throw(std::bad_alloc) + { + bstr_t t(sz, c); + swap(t); + } + + //! Assign string from two iterators. + template + void assign(IT first, IT last) + { + bstr_t t( std::distance(first, last) ); + +#pragma warning(push) +#pragma warning(disable:4996) + std::copy(first, last, t.begin()); +#pragma warning(pop) + + swap(t); + } + + + //! Assignment operator from any (non integer) constructable. + template + bstr_t& operator=(const T& x) + { + COMET_STATIC_ASSERT( type_traits::is_integer::result == false ); + bstr_t t(x); + swap(t); + return *this; + } + + //! Default assignment. + bstr_t& operator=(const bstr_t& x) throw(std::bad_alloc) + { + bstr_t t(x); + swap(t); + return *this; + } + + //! Concat operation + bstr_t operator+(const bstr_t& s) const throw(std::bad_alloc) + { + return bstr_t(str_, length(), s.str_, s.length()); + } + + //! Concat with const wchar_t* + bstr_t operator+(const wchar_t* s) const throw(std::bad_alloc) + { + return bstr_t(str_, length(), s, wcslen(s)); + } + + //! Concat with std::wstring + bstr_t operator+(const std::wstring& s) const throw(std::bad_alloc) + { + return bstr_t(str_, length(), s.c_str(), s.length()); + } + + //! Concat assignment + bstr_t& operator+=(const bstr_t& s) throw(std::bad_alloc) + { + bstr_t t(str_, length(), s.str_, s.length()); + swap(t); + return *this; + } + + //! Concat assignment with const wchar_t* + bstr_t& operator+=(const wchar_t* s) throw(std::bad_alloc) + { + bstr_t t(str_, length(), s, wcslen(s)); + swap(t); + return *this; + } + + //! Concat assignment with std::wstring + bstr_t& operator+=(const std::wstring& s) throw(std::bad_alloc) + { + bstr_t t(str_, length(), s.c_str(), s.length()); + swap(t); + return *this; + } + + // Detach a raw BSTR from it's wrapper - detach function is dangerous. + BSTR detach() + { + BSTR s(str_); + str_ = 0; + return s; + } + + public: + + //!\name Create a reference to a BSTR + /*! + Creates a bstr_t that is a reference to the BSTR. + It will not be reference counted and will not be deleted when the bstr_t goes out of scope. + + This is used by the interface wrappers for [in] BSTR's. Typically clients do not need create_reference. + */ + //@{ + static const bstr_t& create_const_reference(const BSTR& s) throw() + { return *reinterpret_cast(&s); } + + static bstr_t& create_reference(BSTR& s) throw() + { return *reinterpret_cast(&s); } + //@} + + //! Detaches specified bstr + static BSTR detach(bstr_t& s) + { + return s.detach(); + } + + /*! \internal */ + template + static BSTR detach(const T& s) + { + return bstr_t(s).detach(); + } + + /*! \internal */ + BSTR* get_ptr_to_raw() const + { + return const_cast(&str_); + } + + //! [in] adapter. + /*! + Used when calling raw interfaces that require an [in] BSTR argument. + + \code + bstr_t bs; + HRESULT hr = pRawInterface->raw_Method(bs.in()); + \endcode + + Only use this wrapper when forced to deal with raw interface. + */ + BSTR in() const throw() + { + return str_; + } + + //! [in] adapter. + /*! + Used when calling raw interfaces that require an [in] BSTR* argument. + + \code + bstr_t bs; + HRESULT hr = pRawInterface->raw_Method(bs.in_ptr()); + \endcode + + Only use this wrapper when forced to deal with raw interface. + */ + BSTR* in_ptr() const throw() + { + return const_cast(&str_); + } + + //! [out] adapter. + /*! + Used when calling raw interfaces that require an [out] BSTR * argument. + + \code + bstr_t bs; + HRESULT hr = pRawInterface->raw_MethodThatReturnsBSTR(bs.out()); + \endcode + + Only use this wrapper when forced to deal with raw interface. + */ + BSTR* out() throw() + { + destroy(); + return &str_; + } + + //! [in, out] adapter. + /*! + Used when calling raw interfaces that require an [in, out] BSTR * argument. + + \code + bstr_t bs; + HRESULT hr = pRawInterface->raw_MethodThatChangesBSTR(bs.inout()); + \endcode + + Only use this wrapper when forced to deal with raw interface. + + \note If the wrapped BSTR is shared. The bstr_t is copied so that only this version is modified. + + \exception std::bad_alloc + Throws std::bad_alloc if the bstr_t is being copied and memory is exhausted. + */ + BSTR* inout() throw(std::bad_alloc) + { + return &str_; + } + + friend bstr_t operator+(const std::wstring& s, const bstr_t& t) throw(std::bad_alloc); + friend bstr_t operator+(const wchar_t* s, const bstr_t& t) throw(std::bad_alloc); + }; + + //! Concat operation + inline bstr_t operator+(const std::wstring& s, const bstr_t& t) throw(std::bad_alloc) + { + return bstr_t(s.c_str(), s.length(), t.str_, t.length()); + } + + //! Concat operation + inline bstr_t operator+(const wchar_t* s, const bstr_t& t) throw(std::bad_alloc) + { + return bstr_t(s, wcslen(s), t.str_, t.length()); + } + //@} + + /*! \name Boolean Operators on String + * \relates bstr_t + */ + //@{ + inline bool operator==(const wchar_t* s1, const bstr_t& s2) throw() + { + return s2 == s1; + } + + inline bool operator!=(const wchar_t* s1, const bstr_t& s2) throw() + { + return s2 != s1; + } + + inline bool operator<(const wchar_t* s1, const bstr_t& s2) throw() + { + return s2 > s1; + } + + inline bool operator>(const wchar_t* s1, const bstr_t& s2) throw() + { + return s2 < s1; + } + + inline bool operator<=(const wchar_t* s1, const bstr_t& s2) throw() + { + return s2 >= s1; + } + + inline bool operator>=(const wchar_t* s1, const bstr_t& s2) throw() + { + return s2 <= s1; + } + + inline bool operator==(const std::wstring& s1, const bstr_t& s2) throw() + { + return s2 == s1; + } + + inline bool operator!=(const std::wstring& s1, const bstr_t& s2) throw() + { + return s2 != s1; + } + + inline bool operator<(const std::wstring& s1, const bstr_t& s2) throw() + { + return s2 > s1; + } + + inline bool operator>(const std::wstring& s1, const bstr_t& s2) throw() + { + return s2 < s1; + } + + inline bool operator<=(const std::wstring& s1, const bstr_t& s2) throw() + { + return s2 >= s1; + } + + inline bool operator>=(const std::wstring& s1, const bstr_t& s2) throw() + { + return s2 <= s1; + } + //@} + + + // Implementation of uuid_t construct from bstr. + inline uuid_t::uuid_t(const bstr_t& bs) + { + if (init_from_str(bs.c_str(), bs.length()) == false) throw std::runtime_error(err_msg()); + } + + inline currency_t& currency_t::parse( const bstr_t &str, LCID locale ) + { + VarCyFromStr( str.in(), locale, 0, &cy_ ) | raise_exception; + return *this; + } + +} // namespace + +namespace { + COMET_STATIC_ASSERT( sizeof(comet::bstr_t) == sizeof(BSTR) ); + COMET_STATIC_ASSERT( sizeof(comet::bstr_t) == sizeof(BSTR) ); +} + +namespace std { + template<> inline void swap( comet::bstr_t& x, comet::bstr_t& y) COMET_STD_SWAP_NOTHROW { x.swap(y); } +} + +#include + +#pragma warning(pop) + +#endif /* COMET_BSTR_H */ diff --git a/EyeTab_SP2/comet/calllog.h b/EyeTab_SP2/comet/calllog.h new file mode 100644 index 0000000..0193f9b --- /dev/null +++ b/EyeTab_SP2/comet/calllog.h @@ -0,0 +1,628 @@ +/** \file + * Provide logging for calls. + */ +/* + * Copyright © 2003 Michael Geddes + * + * This material is provided "as is", with absolutely no warranty + * expressed or implied. Any use is at your own risk. Permission to + * use or copy this software for any purpose is hereby granted without + * fee, provided the above notices are retained on all copies. + * Permission to modify the code and to distribute modified code is + * granted, provided the above notices are retained, and a notice that + * the code was modified is included with the above copyright notice. + * + * This header is part of Comet version 2. + * https://github.com/alamaison/comet + */ + +#ifndef COMET_CALLLOG_H +#define COMET_CALLLOG_H + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +/** \page cometcalllogging Call Logging + This is a feature of the comet interfaces that allows the server to log all + calls to any of the interface methods. It logs parameter values, and also allows + logging of errors (see \ref comethandleexception ). + + Call logging in comet is enabled by using tlb2h -L (see \ref tlb2husage). + + To enable logging to a specified file, define COMET_LOGFILE and define + COMET_LOGFILE_DEFAULT to be the required logfile (see comet::stream_call_logger_t). + + To override logging, specialise comet::call_logger_ and implement all the interfaces + defined by the default comet::call_logger_. + + How various parameter types are output can be modified by specialising the + function comet::comet_log. + */ + +/** \defgroup CallLog Call-logging + *@{ + */ +#ifdef COMET_DOXYGEN // Only for doxygen +/** \def COMET_LOGFILE + * Define to get simple interface logfiles. + * Must use tlb2h -L to enable interface logging. See \ref tlb2husage. + * \sa comet_log comet_log_interface comet_log_array stream_call_logger_t tofstream_comet + */ + +#define COMET_LOGFILE + +/** \def COMET_LOGFILE_DEFAULT + * If COMET_LOGFILE is defined, define to set the default logfile name. + * \code + #define COMET_LOGFILE_DEFAULT "C:\\log\\comet.log" + * \endcode + * \relates call_logger_ + */ +#define COMET_LOGFILE_DEFAULT "C:\\log\\comet.log" +#endif // COMET_DOXYGEN + + //@} + +namespace comet +{ +/*!\addtogroup CallLog + */ +//@{ + /** \struct call_logger_ calllog.h comet/calllog.h + * Default NULL logger and description of 'call logger' concept. + * Specialise to \b true to override. + * \code + template<> + struct call_logger_ : stream_call_logger_t + { + }; + * \endcode + * \sa stream_call_logger_t tofstream_comet + */ + template + struct call_logger_ + { + /** Should the call be logged? + * \return Return true to allow call to be logged. + */ + static inline bool can_log_call() { return false; } + /** Should the return values be logged? + * \return Return true to allow call return values to be logged. + */ + static inline bool can_log_return() { return false; } + + /** Called by interfaces to provide call logging. + */ + static inline void log_call( const tstring &iface, const tstring &funcname, const tstring &log){} + + /// Called by interfaces to provide call return logging. + static inline void log_return( const tstring &iface, const tstring &funcname, const tstring &log, const tstring &retval){} + + + ///\name Exception handling redirection. + //@{ + + /** Should the error be logged? + * \return Return true to allow error to be logged. + */ + static inline bool can_log_exception() { return false; } + + /// Called by exception handlers to provide logging for errors. + static inline void log_exception(const tstring &type, const tstring &desc, const source_info_t &errorSource ,const source_info_t &callSource ){} + //@} + }; + + /** \struct stream_call_logger_t calllog.h comet/calllog.h + * Log calls to a tostream. + * A class/struct that subscribes to and implements the 'call logger' concept for a steam. + * Template paramter is expected to be a class that has a method that creates a tostream + * instance as follows: + * \code + * static tostream *create() + * \endcode + * \param CREATESTREAM Class with a static function \p create() that returns a tostream * + * \sa tofstream_comet call_logger_ + */ + template + struct stream_call_logger_t +#ifdef COMET_DOXYGEN // For documentation + : call_logger_ +#endif + { + static inline bool can_log_call() + { + tostream *ofs = logger(); + return ofs != NULL && ofs->good(); + } + static inline bool can_log_return() { return can_log_call(); } + static inline bool can_log_exception() { return can_log_call(); } + + static inline void log_call( const tstring &iface, const tstring &funcname, const tstring &log) + { + log_( false, iface, funcname, log, tstring()); + } + static inline void log_return( const tstring &iface, const tstring &funcname, const tstring &log, const tstring &retval) + { + log_( true, iface, funcname, log, retval); + } + static inline void log_exception(const tstring &type, const tstring &desc, const source_info_t &errorSource ,const source_info_t &callSource ) + { + COMET_NOTUSED(errorSource); + tostream *ofs= logger(); + if (ofs==NULL) return; // Should never be NULL, as can_log_call() should have been obeyed before calling. + *ofs << _T("Err ") << callSource.source().t_str(); + if ( !desc.empty() ) + { + *ofs << type << _T(": ") << desc ; + } + *ofs << std::endl; + } + + protected: + // Log a function call/return. + static void log_( bool return_val, const tstring &iface, const tstring &funcname, const tstring &log, const tstring &retval) + { + tostream *ofs= logger(); + if (ofs==NULL) return; // Should never be NULL, as can_log_call() should have been obeyed before calling. + + *ofs << (return_val?_T("Out "):_T("In ")) << iface << _T("::") << funcname; + if (!return_val || !log.empty()) + *ofs << _T("(") << log << _T(")"); + + if (return_val && !retval.empty()) + *ofs << _T(" returned ") << retval; + *ofs << std::endl; + + } + // Access to the static logger instance without needing to initialise a + // member. + static tostream *logger() + { + static tostream *ofs_= NULL; + if (ofs_ ==NULL) + { + ofs_ = CREATESTREAM::create(); + if (ofs_ != NULL) + { + // Safely clean up static pointer on module destruct + module().add_object_to_dispose( create_pointer_deleter( ofs_ ) ); + } + } + return ofs_; + } + }; + + namespace impl + { + /** Redirect default logging to calllog. + * \internal + */ + template<> + struct call_logger_redirect_ + { + // This trick allows the user to be able to still override the call logging. + // Without this, log_exception has to call + // call_logger_::log_exception which causes the template to be + // instantiated, and the user is no longer able to specialise + // call_logger_ + template + struct exe + { + static inline void log_exception(const tstring &type, const tstring &desc, const source_info_t &errorSource, const source_info_t &callSource ) + { + call_logger_::log_exception(type,desc,errorSource, callSource); + } + static inline bool can_log_exception() + { + return call_logger_::can_log_exception(); + } + }; + }; + } + +#ifdef COMET_LOGFILE +#ifndef COMET_LOGFILE_DEFAULT +#define COMET_LOGFILE_DEFAULT NULL +#endif +#include + /** \class tofstream_comet calllog.h comet/calllog.h + * Provides a filestream creator as well as the implementation of an output filestream logger. + * Allows overriding of file name. + */ + class tofstream_comet : public tofstream + { + static const char *&filename_() + { + static const char *default_filename= COMET_LOGFILE_DEFAULT; + return default_filename; + } + public: + /// Get the default filename. + static const char *get_default_filename() { return filename_(); } + /// Set the default filename to a new value. + void set_default_filename( const char *filename) { filename_() = filename; } + + tofstream_comet( const char *fname) : tofstream(fname) {} + + /** Create an instance of the logger. + * Returns NULL if the file doesn't exist. + */ + static tostream *create() + { + const char *fname = filename_(); + if (fname == NULL) + return NULL; + return new tofstream_comet(fname); + } + private: + tofstream_comet(const tofstream_comet &); + tofstream_comet &operator=(const tofstream_comet &); + + }; + + /** Override specialisation of the call_logger_. + * \relates call_logger_ + */ + template<> + struct call_logger_ : public stream_call_logger_t + { + }; + +#endif // FILE_LOG + + /** Default interface (com_ptr) logging. + * Specialise to provide custom logging for com_ptr. + \code + template<> + void comet_log_interface(tostream &os, const com_ptr &iface) + { + os << iface->GetName(); + } + \endcode + Specialisations for IUnknown and IDispatch are used by the variant loggers. + * \sa comet_log comet_log_array + * \relates call_logger_ + */ + template< typename IFACE> + void comet_log_interface(tostream &os, const com_ptr &iface) + { + os << _T("0x") << std::hex << reinterpret_cast(iface.get()) << std::dec; + } + + // Forward declarations. + template void comet_log(tostream &os, const T &value); + + namespace impl + { + // Forward declarations. + template inline void default_comet_log(tostream &os, const T &value); + static void comet_log_array_raw(tostream &os, SAFEARRAY *value); + + // The default variant handler. + template< bool B> + static inline void default_comet_log_variant(tostream &os, const variant_t &value, bool out_type) + { + VARTYPE vt = value.get_vt(); + if ((vt & VT_ARRAY) != 0) + { + comet_log_array_raw(os, value.get().parray); + } + else + { + VARIANT varcopy=value.in(); + if (vt == (VT_BYREF | VT_VARIANT)) // Dereference variant by reference + varcopy = *V_VARIANTREF(&varcopy); + const VARIANT *var=&varcopy; + +#define __VARIANT_LOGPOINTER_TYPE_CAST(vartype,cast) \ + case VT_##vartype:\ + if(out_type) os << _T("VT_")_T(#vartype)_T(":");\ + comet_log_interface(os, cast(V_##vartype(var))); \ + break + +#define __VARIANT_LOGPOINTER_REFTYPE_CAST(vartype,cast) \ + case VT_BYREF|VT_##vartype:\ + if(out_type) os << _T("BYREF VT_")_T(#vartype)_T(":");\ + comet_log_interface(os, cast(*V_##vartype##REF(var)));\ + break +#define __VARIANT_LOG_TYPE_CAST(vartype,cast) \ + case VT_##vartype: \ + if(out_type) os << _T("VT_")_T(#vartype)_T(":"); \ + comet_log(os, cast(V_##vartype(var))); \ + break + +#define __VARIANT_LOG_REFTYPE_CAST(vartype,cast)\ + case VT_BYREF|VT_##vartype:\ + if(out_type) os << _T("BYREF VT_")_T(#vartype)_T(":");\ + comet_log(os, cast(*V_##vartype##REF(var)));\ + break + +#define __VARIANT_LOG_TYPE(vartype) \ + case VT_##vartype: \ + if(out_type) os << _T("VT_")_T(#vartype)_T(":");\ + comet_log(os, V_##vartype(var));\ + break + +#define __VARIANT_LOG_REFTYPE(vartype)\ + case VT_BYREF|VT_##vartype: \ + if(out_type) os << _T("BYREF VT_")_T(#vartype)_T(":"); \ + comet_log(os, *V_##vartype##REF(var)); \ + break + + switch (vt) + { + __VARIANT_LOG_TYPE(UI1); + __VARIANT_LOG_TYPE(UI2); + __VARIANT_LOG_TYPE(UINT); + __VARIANT_LOG_TYPE(UI4); + __VARIANT_LOG_TYPE(I1); + __VARIANT_LOG_TYPE(I2); + __VARIANT_LOG_TYPE(INT); + __VARIANT_LOG_TYPE(I4); + __VARIANT_LOG_TYPE(R4); + __VARIANT_LOG_TYPE(R8); + __VARIANT_LOG_REFTYPE(UI1); + __VARIANT_LOG_REFTYPE(UI2); + __VARIANT_LOG_REFTYPE(UINT); + __VARIANT_LOG_REFTYPE(UI4); + __VARIANT_LOG_REFTYPE(I1); + __VARIANT_LOG_REFTYPE(I2); + __VARIANT_LOG_REFTYPE(INT); + __VARIANT_LOG_REFTYPE(I4); + __VARIANT_LOG_REFTYPE(R4); + __VARIANT_LOG_REFTYPE(R8); + + case VT_BOOL: + if(out_type) os << _T("VT_BOOL:"); + os << (V_BOOL(var)==VARIANT_FALSE)?_T("true"):_T("false"); + break; + case VT_BYREF|VT_BOOL: + if(out_type) os << _T("BYREF VT_BOOL:"); + os << (V_BOOL(var)==VARIANT_FALSE)?_T("true"):_T("false"); + break; + __VARIANT_LOG_TYPE_CAST( CY, currency_t::create_const_reference); + __VARIANT_LOG_REFTYPE_CAST( CY, currency_t::create_const_reference); + __VARIANT_LOG_TYPE_CAST( DATE, datetime_t::create_const_reference); + __VARIANT_LOG_REFTYPE_CAST( DATE, datetime_t::create_const_reference); + __VARIANT_LOG_TYPE_CAST( BSTR, bstr_t::create_const_reference); + __VARIANT_LOG_REFTYPE_CAST( BSTR, bstr_t::create_const_reference); + + __VARIANT_LOGPOINTER_TYPE_CAST( UNKNOWN, com_ptr::create_const_reference); + __VARIANT_LOGPOINTER_TYPE_CAST( DISPATCH, com_ptr::create_const_reference); + __VARIANT_LOGPOINTER_REFTYPE_CAST( UNKNOWN, com_ptr::create_const_reference); + __VARIANT_LOGPOINTER_REFTYPE_CAST( DISPATCH, com_ptr::create_const_reference); + + case VT_DECIMAL: + if(out_type) os << _T("BYREF VT_DECIMAL:"); + os << _T("?"); + break; + case VT_ERROR: + if(out_type) os << _T("VT_ERROR:"); + os <<_T("0x") << std::hex << V_ERROR(var) << std::dec; + break; + case VT_BYREF|VT_ERROR: + if(out_type) os << _T("BYREF VT_ERROR:"); + os <<_T("0x") << std::hex << *V_ERRORREF(var) << std::dec; + break; + default: + os << _T("???"); + } +#undef __VARIANT_LOG_TYPE_CAST +#undef __VARIANT_LOG_REFTYPE_CAST +#undef __VARIANT_LOG_TYPE +#undef __VARIANT_LOG_REFTYPE +#undef __VARIANT_LOGPOINTER_TYPE_CAST +#undef __VARIANT_LOGPOINTER_REFTYPE_CAST + } + } + + /* Logging for raw safearrays. + * For vector arrays of size <= 16, this fakes a variant and then uses the default variant logging to log the elements + */ + static void comet_log_array_raw(tostream &os, SAFEARRAY *value) + { + UINT dims = SafeArrayGetDim(value); + VARTYPE vt ; + if( FAILED(SafeArrayGetVartype(value, &vt ) ) ) + { + os << "???"; + return; + } + + long ubound=-1,lbound=0; // Outside so it can be used for the '1' case below. + for (UINT d = 1; d<= dims ; ++d) + { + if( SUCCEEDED(SafeArrayGetUBound( value, d, &ubound) ) && SUCCEEDED(SafeArrayGetLBound(value, d, &lbound) )) + { + if( lbound == 0) + os << _T("[") << ubound+1 << _T("]"); + else + os << _T("(") << lbound << _T("..") << ubound << _T(")"); + } + + } + if (dims == 1 ) + { + long size = 1+ubound-lbound; + if (size ==0) + { + os << _T("{}"); + } + else if( size > 0 && size <= 15) + { + // For small arrays, print out the elements. + os << _T("{"); + VARIANT v; + void *var; + bool first=true, is_variant= (vt==VT_VARIANT); + if ( is_variant) + var = (void *)&v; + else + { + V_VT(&v) = vt; + var = (void *)&V_UI1(&v); + } + + for (long i = lbound; i <= ubound; ++i ) + { + if(first) + first = false; + else + os << _T(","); + if( SUCCEEDED( SafeArrayGetElement( value, &i, var ) )) + default_comet_log_variant( os, variant_t(auto_attach(v)), first | is_variant); + } + os << _T("}"); + } + } + } + + // Default logging: stream the value. + template + inline void default_comet_log(tostream &os, const T &value) + { + // ERRORS: If a compiler error occurs here, you may need to + // specialise comet_log<> to the type T here. + os << value; + } + // Default logging for bstr_t + template<> + inline void default_comet_log(tostream &os, const bstr_t &value) + { + // Put quotes round the string - simplistic, don't worry about + // non-printables or escaping for the moment. + os << _T("'") << value << _T("'"); + } + + // Deafult logging for variants. + template<> + static inline void default_comet_log(tostream &os, const variant_t &value) + { + default_comet_log_variant( os, value, true); + } + } + + /** Type specific logger. + * The default is to use internal logging. This can be specialised to + * provide type-specific logging. + * \sa comet_log_array comet_log_interface + * \relates call_logger_ + */ + template + void comet_log(tostream &os, const T &value) + { + impl::default_comet_log(os,value); + } + + namespace impl + { + // trick to work out whether it is a safearray or com_ptr type (required because of no + // partial specialisation). Needed to handle the special circumstances + template + struct check_log_type_ + { + static long check(...); + + template + static char check(const safearray_t &); + + template + static short check( const com_ptr &); + + static T createT(); + enum { is = sizeof( check( createT() ) ) }; + + }; + template < int TYPE> struct choose_logger; + + // Default safearray_t logger where we know the type T. + // + template + inline void default_comet_log_array(tostream &os, const safearray_t &value) + { + safearray_t::index_type lbound=value.lower_bound(), size = value.size(); + if (lbound == 0) + os << _T("[") << size << _T("]"); + else + os << _T("(") << lbound << _T("..") << (lbound + size -1) << _T(")"); + + if( value.size() <= 15) + { + os << _T("{"); + bool first = true; + for (safearray_t::const_iterator it = value.begin(); it != value.end(); ++it) + { + choose_logger::is >::do_comet_log(os, *it); + if (first) + first=false; + else + os << _T(","); + } + os << _T("}"); + } + } + } + /** Typed safearray_t logger. + * The default is to use internal logging. This can be specialised to + * provide type-specific logging. + * \sa comet_log comet_log_interface + * \relates call_logger_ + */ + template + void comet_log_array(tostream &os, const safearray_t &value) + { + impl::default_comet_log_array(os,value); + } + + namespace impl + { + // choose the standard logger + template < int TYPE> + struct choose_logger + { + template + static inline void do_comet_log(tostream &os, const T &value) + { + comet_log(os,value); + } + }; + // Choose the array logger + template<> + struct choose_logger + { + template + static inline void do_comet_log(tostream &os, const safearray_t &value) + { + comet_log_array(os, value); + } + }; + // Choose the interface logger + template<> + struct choose_logger + { + template + static inline void do_comet_log(tostream &os, const com_ptr &value) + { + comet_log_interface(os, value); + } + }; + + // Choose which of the comet_loggers to use. + template + static inline tostream &do_comet_log(tostream &os, const T &value) + { + choose_logger::is >::do_comet_log(os, value); + return os; + } + } + //@} +} + +#endif /* COMET_CALLLOG_H */ diff --git a/EyeTab_SP2/comet/cmd_line_parser.h b/EyeTab_SP2/comet/cmd_line_parser.h new file mode 100644 index 0000000..65c4178 --- /dev/null +++ b/EyeTab_SP2/comet/cmd_line_parser.h @@ -0,0 +1,101 @@ +/** \file + * Command line parser. + */ +/* + * Copyright © 2002 Mikael Lindgren + * + * This material is provided "as is", with absolutely no warranty + * expressed or implied. Any use is at your own risk. Permission to + * use or copy this software for any purpose is hereby granted without + * fee, provided the above notices are retained on all copies. + * Permission to modify the code and to distribute modified code is + * granted, provided the above notices are retained, and a notice that + * the code was modified is included with the above copyright notice. + * + * This header is part of Comet version 2. + * https://github.com/alamaison/comet + */ + +#ifndef COMET_COMMAND_LINE_PARSER_H +#define COMET_COMMAND_LINE_PARSER_H + +#include + +namespace comet { + + /*! \addtogroup Misc + */ + //@{ + class cmd_line_parser + { + public: + enum kind_t { + Name, // Name type token, has no leading / or - + Option, // Option type token. Leading / or - skipped by token + Value, // Value for name or option. Leading : or = skipped by token + Done // No more tokens + }; + + explicit cmd_line_parser(const TCHAR* cmd_line): cmd_line_(cmd_line) + { + reset(); + } + + kind_t get_next_token(tstring& result) + { + static const TCHAR terminators[] = _T("=/- \t"); + static const TCHAR white_space[] = _T(" \t"); + + kind_t kind; + + token_ = next_token_ + _tcsspn(next_token_, white_space); // Skip leading whitespace + switch (*token_) + { + case 0: + return Done; + case _T('-'): + case _T('/'): + kind = Option; + ++token_; + break; + case _T('='): + kind = Value; + ++token_; + break; + default: + kind = Name; + break; + } + if (kind == Option || kind == Value) + token_ += _tcsspn(token_, white_space); // Skip any more whitespace + if (*token_ == _T('"')) + { + const TCHAR* next = _tcschr(token_+1, _T('"')); + if ( next ) + { + result.assign( token_+1, next ); + next_token_ = next+1; + return kind; + } + } + next_token_ = token_ + _tcscspn(token_, terminators); + result.assign(token_, next_token_); + return kind; + } + + void reset() + { + token_ = 0; + next_token_ = cmd_line_; + } + + private: + const TCHAR* cmd_line_; + const TCHAR* token_; + const TCHAR* next_token_; + }; + //@} + +} + +#endif diff --git a/EyeTab_SP2/comet/comet.h b/EyeTab_SP2/comet/comet.h new file mode 100644 index 0000000..b2ad70f --- /dev/null +++ b/EyeTab_SP2/comet/comet.h @@ -0,0 +1,776 @@ +/** \file + * Load basic comet libraries. + */ +/* + * Copyright © 2000, 2001 Sofus Mortensen, Michael Geddes + * + * This material is provided "as is", with absolutely no warranty + * expressed or implied. Any use is at your own risk. Permission to + * use or copy this software for any purpose is hereby granted without + * fee, provided the above notices are retained on all copies. + * Permission to modify the code and to distribute modified code is + * granted, provided the above notices are retained, and a notice that + * the code was modified is included with the above copyright notice. + * + * This header is part of Comet version 2. + * https://github.com/alamaison/comet + */ + +#ifndef COMET_COMET_H +#define COMET_COMET_H + +#include + +/** + @mainpage Comet + + See https://github.com/alamaison/comet + + See \ref comethistory. + + \section cometinfocontents Information Pages +
    +
  • \ref tlb2husage
    • +
  • \ref tlb2handidl
    • +
  • \ref cometcomptr
    • +
  • \ref cometrawcomaccess
    • +
  • \ref cometconnectionpoints
    • +
      +
    • \ref cometconnectionpointssource
      • +
    • \ref cometconnectionpointsink
      • +
    +
  • \ref comettstring
    • +
  • \ref cometdefineconfiguration
    • +
  • \ref cometcatchallexception
    • +
  • \ref cometclassfactory
    • +
  • \link custom_registration Custom Registration\endlink
    • +
  • \ref comethandleexception
    • +
  • \ref cometcalllogging
    • +
  • \ref cometautoexp
    • +
    • \ref cometautoexpusage
    +
+ */ + +/** + * \page cometrawcomaccess Raw COM Acces + * The designers of Comet have tried to avoid making the wrappers do too much + * implicitly, prefering discrete but explicit ways of triggering functionality. + * + * In order to provide interaction of Comet classes with their COM counterparts, + * a standard set of methods have been used, effectively providing a COM wrapper + * concept. + * + *
    + *
  • in(): Return a pointer suitable for [in] parameters,
    • + *
  • out(): Return a pointer suitable for [out] parameters, first freeing memory allocated,
    • + *
  • inout(): Return a pointer suitable for [in,out] parameters.
    • + *
  • detach(): Detach and return the internal pointer from the object
    • + *
  • in_ptr(): {optional} Return a pointer suitable for [out] parameter where a pointer is required, first freeing memory allocated
    • + *
  • get(): {optional} Returns a pointer to the internal pointer (same as STL pointers)
    • + *
  • auto_attach( RAW_TYPE ): Cause an assignment to attach the object to the specified raw COM type.
    • + *
  • create_reference( RAW_TYPE ): Static method to create a propper wrapper reference to the specified raw object.
    • + *
  • create_const_reference( RAW_TYPE ): Static method to create a const wrapper reference to the specified raw object.
    • + *
+ */ + +/** \page cometcatchallexception Exception Catching Policy +In an ideal world, Microsoft would have adhered to the C++ standard, and made +catch(...) not catch system exceptions like 'Access Violation', +however this is not the case. + +To make it worse, not only do system exceptions get caught by catch(...), +they also bypass the stack unwinding. This is quite problematic in an +environment where this mechanism is relied upon for resource management, commonly +'only' memory, but also including multithreading acces control mechanisms. + +One of the big problems with Access Violations is that it is an unplanned +exception, and in many situations will leave data structures incomplete, +resources locked or other equally vicious artifacts. Essentially, it breaks +invariants. One viable take on this is that if you don't know where an +exception came from, you shouldn't be catching it. + +A big advantage of letting access violations and it's ilk (or any other +unplanned exception) through is that these will then get caught by the JIT (Just +In Time) handlers such as Dr. Watson and Compiler environments that allow +immediate or post-mortem debugging of the problem. A lot of projects (like +Mozilla) have their own bug-reporting which can intercept the bugs at the top +level and generate their own crash dumps, and catching these exceptions is +actually going to bypass a very useful mechanism. + +All this is to say that we have made a shift away from exception handling +policies that cause system expeptions to be caught, however in order to +allow as much flexibility as possible, an improved exception handling mechanism +has been added to the interface implementations and to the server implementation +that uses catch and rethrow to allow logging and custom handling of all exceptions. + +The default action of the mechanisms will be to finally rethrow unknown +exceptions. The good thing about this is that the rethrow behaves to a JIT handler +as if the expeption had never been caught. + +*/ + +/** \page cometautoexp Comet AutoExp.Dat Support +There is a largely undocumented feature is Visual Studio 6 and 7 that allows +you to create a dll 'ADDIN' that provides custom formatting for variables in the +debugger. CometAutoExp.dll allows you to view simple automation types in more +detail than currently provided internally by the debugger. + +By enabling this, you will get to see real date/times when you view datetime_t, you +get to see SAFEARRAY types (including IIDs), and possibly their contents, you +will see full VARIANT types, including SAFEARRAYs. + +The file in comet/src/cometautoexp/AutoExp.dat shows the entries that will +be needed to included in your own AutoExp.dat for this to work. (Usually +found at "c:\Program Files\Microsoft Visual Studio\Common\MSDev98\Bin\AUTOEXP.DAT") + +See \ref cometautoexpusage for more information on how to use this. + */ + +/** \page cometdefineconfiguration Comet Configuation + While Comet barely uses macros for the import work of creating a COM library, + there are a number of preprocessor switches that are used to alter certain + behaviours and select code. While most of these refer to the compiler being used, + there are a few that are intended to be used as external switches. + +
  • COMET_ALLOW_DECLSPEC_PROPERTY : Wrapper headers include declspec + properties, allowing interface properties to be assigned-to and read as + properties.
  • COMET_ASSERT_THROWS : Comet throws + comet::assert_failed when internal assertions fail in debug builds.
    • +
  • COMET_ASSERT_THROWS_ALWAYS : Comet throws comet::assert_failed when + internal assertions fail in both debug and release builds.
    • +
  • COMET_LOGFILE : See \ref cometcalllogging.
    • +
  • COMET_LOGFILE_DEFAULT : See \ref cometcalllogging.
    • +
  • COMET_NO_MBCS : Disable comet multi-byte-character-set conversion handling.
    • +
  • COMET_NO_MBCS_WARNING : Turn off the warning indicating that sdt::string is not compatible with MBCS.
    • +
  • COMET_USE_RAW_WRAPPERS : Tells com_ptr not to use the comet wrappers but to return raw interface pointers.
    • +
+ + There are also a number of macros that are either utitlity macros, reflect compiler differences + or Comet version differences that may be convenient to use within your own code. + +
    +
  • COMET_ASSERT(expression) : Run-time assert.
    • +
  • COMET_STATIC_ASSERT(static-expression) : Compile-time assert.
    • +
  • COMET_NOTUSED(info) : Specify unused argument.
    • +
  • COMET_FORCEINLINE : Use before a method to apply force-inline if available.
    • +
  • COMET_VARIANT_TRUE,COMET_VARIANT_FALSE : Use in place of VARIANT_TRUE,VARIANT_FALSE to avoid type warnings.
    • +
  • COMET_MAJOR_VER : Major comet version
    • +
  • COMET_MINOR_VER : Minor comet version
    • +
  • COMET_BUILD : Comet version to compare against (yyyymmdd of distribution)
    • +
  • COMET_STRICT_TYPENAME : Used for when stricter compilers require 'typename' keyword and VC6 has an error.
    • +
  • COMET_CONST_TYPE(vartype, varname, value) : Define a typed constant for a class/struct (or use enum if not supported)
    • +
+ + */ + +/** \page comethistory Comet History +\par Version 1 gamma 32 ( ) +\li Support for VC++2005 (Sofus Mortensen) +\li Numerous bug fixes and better support for Intel C++ (Richard Crossley) +\li Fixed off-by-one bug regarding array sizes (Yunusov Bulat) + +\par Version 1 beta 31 ( ) +\li safearray.h - Fix a few omissions/bugs (Lijun Qin) +\li comet_lint.lnt - Add pclint options file. (Michael Geddes) +\li server.h - Fix singlton_autorelease class (Ralf Jürgensen) +\li datetime.h - Fix bug in century non-leap-years. (Michael Geddes) +\li datetime.h - Use julian date conversions from boost - to drastically improve split/join efficiency (Michael Geddes) +\li datetime.h - Make invalid() rather than valid() the default (Michael Geddes) +\li date.h - Make use of above improvements in datetime_t (Michael Geddes) +\li datetime.h/date.h - Add ability to construct/assign invalid/null dates from dt_null, dt_invalid (Michael Geddes) +\li datetime.h - Fixed bug in to_unixtime (Lijun Qin) +\li array.h - Fixed typename problem (Sofus Mortensen) +\li safearray.h - Fixed problem with sa_debug_iterator and MSVC 7.1 (Sofus Mortensen) +\li uuid_fwd.h - Fixed bug in !operator (Sofus Mortensen) + +\par Version 1 beta 30 (2004-3-5) +\li Support for VC7.1 partial specialisation. (Lijun Qin) +\li datetime.h - Bugfix in datetime_t conversion (Gordon Donaldson) +\li safearray.h - Separate safearray_t::resize into resize and resize_bound to avoid ambiguous conversions. (Michael Geddes) +\li safearray.h - Fix bug in safearray_t:resize_bound using an incorrect copy. (Michael Geddes) +\li safearray.h - Add safearray_t debug iterator for debug builds. (Michael Geddes) +\li safearray.h - Add more comments for safearray_t (Michael Geddes) +\li safearray.h - Support more container-type methods (erase,push_front,push_back,pop_front,pop_back) (Michael Geddes) +\li server.h - Add auto-release singleton (Michael Geddes) +\li uuid.h - uuid_t::operator! no longer reversed (Lijun Qin) +\li uuid.h - fix ambiguous ++ operator usage. (Lijun Qin, Bulat Raditch, Michael Geddes) +\li handle.h - Extension of handles for GDI objects for cometw (Michael Geddes/Vladimir Voinkov/Lindgren Mikael) +\li bstr.h - Throw comparison errors if they occur. (Michael Geddes) +\li cp.h - add 'is_connected' method to connection points. (Lijun Qin) +\li common.h - Support for pclint (Michael Geddes, Gabriel Barta) +\li datetime.h - Support for timezones (Michael Geddes) +\li datetime.h - Fix up buffer handling (Michael Geddes, Lijun Qin) +\li variant.h - Support for strings with embedded nulls (Michael Geddes) +\li tlb2h - Support for bool in structs and in safearrays (Michael Geddes) +\li tlb2h - Support for wrapper renaming of specific methods on specific interfaces/struct/unions. (Michael Geddes) +\li tlb2h - Dual interfaces inherited from an interface in a different type-library now works when called by dispatch (Michael Geddes) +\li tlb2h - Output of HTML now better restricted to only required interfaces. (Michael Geddes) +\li tlb2h - Obey COM rules that require [out] pointers to be initialised on failure (Michael Geddes) +\li tlb2h - Support implementation of an interface that inherits from an interface from a different typelibrary (Michael Geddes) +\li cometautoexp - Support for more types, and better handling of strings. (std::basic_string, COLEDateTime) (Michael Geddes) +\li date.h - Added dateonly_t class. (Michael Geddes) +\li uuid.h - Make the strings accessors consistant (Michael Geddes, Lijun Qin) + +\par Version 1 beta 29 (2003-12-30) +\li Added loads of documentation, reduced doxygen warnings to 1(Michael Geddes) +\li Added CometAutoExp.dll extended support for AutoExp.dat +\li Remove unnecessary catch(...) - use specific catches (Michael Geddes) +\li Support create_const_reference in all wrapper classes. (Michael Geddes) +\li tlb2h - Enhance support for error information (interface/coclass name) (Michael Geddes) +\li tlb2h - Add support for logging calls & exceptions. (Michael Geddes) +\li tlb2h - Support for special characters in help strings. (Michael Geddes) +\li tlb2h - Few tweaks to get correct output. (Michael Geddes) +\li tlb2h - Option to show version (Michael Geddes) +\li bstr.h - Work with _STLP_DEBUG wrappers (Michael Geddes) +\li bstr.h - Constructor works with MBCS (Michael Geddes) +\li bstr.h - Support for {} round uuid_t (Michael Geddes) +\li cp.h - Add convenience methods. (Michael Geddes) +\li datetime.h - Constructor to supply date and time (Michael Geddes) +\li datetime.h - Support output streams. (Michael Geddes) +\li error.h - Support for source, iid and helpfile in errors. (Michael Geddes) +\li interface.h - Provide extra comtype definitions. (Michael Geddes) +\li interface.h - Provide convenience macro to define extra comtype with IID_ instances. (Michael Geddes) +\li ptr.h - Add identity_ptr class that references an identity IUnknown. All other comparisons QI on both pointers. (Michael Geddes) +\li server.h - Add support for singelton classes. (Michael Geddes) +\li tlbinfo.h - Fix up reference counting on struct wrappers. (Michael Geddes) +\li tlbinfo.h - Support ITypeInfo2 (Michael Geddes) +\li variant.h - Added explicit converts (as_uchar(), as_uint(), as_double() etc) (Michael Geddes) +\li variant.h - Added is_empty(), is_null() and is_nothing() (Michael Geddes) + +\par Version 1 beta 28 (2003-6-18) +\li Support for Visual Studio 2003 + +\par Version 1 beta 27 (2003-3-5) +\li tlb2h - bug fix variant_t members of dispinterfaces (Michael Geddes) +\li tlb2h - support for safearrays of interfaces (Michael Geddes) + +\par Version 1 beta 26 (2003-2-1) +\li tlb2h - major update. See http://groups.yahoo.com/group/tlb2h/message/706 (Michael Geddes) +\li Enum.h - allow copy policies with members (Michael Geddes) +\li datetime.h - fixed bug in timeperiod_t::split (Michael Geddes) + +\par Version 1 beta 25 (2002-11-28) +\li Connection point implementation is now customisable via traits. See http://groups.yahoo.com/group/tlb2h/message/688 (Michael Geddes) +\li Fixed bug in str_formattime in datetime.h (Sofus Mortensen). +\li Fixed bug in add_months in datetime.h (Michael Geddes). + +\par Version 1 beta 24 (2002-11-13) +\li Major update of tlb2h. See http://groups.yahoo.com/group/tlb2h/message/659 and http://groups.yahoo.com/group/tlb2h/message/661. (Michael Geddes) +\li Fixed problem with variant_t::operator==. (Kyle Alons) +\li Fixed bug in bstr_t::s_str(), bstr_t::is_empty(), bstr_t::length() (Mikael Lindgren, Michael Geddes) +\li safearray_t: 1. Changed the constructor that takes two iterators to not have a default lowerbound (to be consistant with the other constructor) +2. Changed resize to allow specifying a lower-bound. +3. Changed the default lb to be 0 in the case where none is specified and where the safearray is NULL. (Michael Geddes) + +\par Version 1 beta 23 (2002-9-1) +\li Bug fixes to namespace handling. (Michael Geddes) +\li Added friendly error message for missing tlbinf32.dll. (Sofus Mortensen) +\li Worked around MSVC6 internal compiler error when contructing an enum. (Michael Geddes) +\li Bug fixes to currency.h (Michael Geddes) +\li Bug fixes to datetime.h (Michael Geddes) + +\par Version 1 beta 22 (2002-8-19) +\li Update of tlb2h - better handling of namespace mangling, and support for +unwrapping the type of aliases without unwrapping the name of the aliases (Michael Geddes). +\li Fixed bug in uuid_fwd. (John Harrison) +\li Added oleidl_comtypes.h. (Gabriel Barta) +\li Restored old functionality of try_cast - will no longer throw when casting a null pointer. (Sofus Mortensen) +\li New auto-locking implementation of safearray_t::create_reference and safearray_t::create_const_reference. (Michael Geddes, Sofus Mortensen) +\li Included first drop (pre-alpha version) of cometw. (Vladimir Voinkov) + +\par Version 1 beta 21 (2002-6-21) +\li Fixed null pointer bug in com_error::what(). (Kyle Alons) +\li Fixed bug to do with the unloading of typelibraries when refcount reaches zero. (Michael Geddes) +\li Added support for MBCS to std::string and const char* conversions for bstr_t. Only active when _MBCS is defined. (Michael Geddes) +\li Fixed locking/unlocking bug. (Vladimir Voinkov, Sofus Mortensen) +\li Fixed bug in safearray_t::create_reference(variant_t&). (Michael Geddes) +\li Various fixes to datetime and currency. (Michael Geddes) +\li Added constants COMET_VARIANT_TRUE and COMET_VARIANT_FALSE in order to avoid warnings. (Michael Geddes, Sofus Mortensen) +\li registry::value has been extended with overload for method str and dword, where a default value can be supplied if the key/value does not exist. (Sofus Mortensen) +\li Various patches for BCC. (Michael Geddes) +\li Solved problem with vtables gaps when inheriting from those interfaces. (Michael Geddes) +\li Removed a few level 4 warnings. (Michael Geddes) +\li Added experimental HTML generation to tlb2h. (Sofus Mortensen) + +\par Version 1 beta 20 (2002-4-9) +\li tlb2h will fall back to using raw structs for structs with types that cannot be wrapped. (Sofus Mortensen) +\li Added application wizard for MSVC.NET. See tlb2h/src/Comet. (Sofus Mortensen) +\li Eliminated a few warnings. (Sofus Mortensen) + +\par Version 1 beta 19 (2002-3-26) +\li Added caching of IRecordInfo to sa_traits for wrapped structs and ITypeInfo to IDispatch implementations. (Sofus Mortensen) +\li Fixed problem with safearray_t iterators on MSVC7. (Sofus Mortensen) +\li Fixed bug regarding range checking for safearray_t::at being off by one. (Sofus Mortensen) +\li Added range checking assertion (debug only) to safearray_t::operator[]. (Sofus Mortensen) +\li Changed safearray_t constructor, so that lower bound of one is no longer assumed. Instead lower bound must be specified. (Sofus Mortensen) + +\par Version 1 beta 18 (2002-3-25) +\li Major revision of bstr_t. (Sofus Mortensen) +\li Added experimental support for wrapped structs to tlb2h and safearray. (Sofus Mortensen) +\li Fixed problem with having a coclass as a connection point sink. (Sofus Mortensen) +\li Revised treatment of [in, out] parameters in tlb2h. The old implementation could cause double deletion of [in. out] parameters when an exception was thrown. (Sofus Mortensen) +\li Revised all wrapper classes, in order for create_reference to create a mutable reference and create_const_reference an immutable reference. (Sofus Mortensen) +\li Revised locking in safearray_t. safearray_t::create_reference and safearray_t::create_const_reference is no longer doing automatic locking. (Sofus Mortensen) +\li tlb2h now generates #import alike smart pointer typedef. Ie. interface IFoo will be matched with a typedef com_ptr IFooPtr. (Sofus Mortensen) +\li Added support for datetime_t and currency_t to safearray_t. (Sofus Mortensen) +\li Added t_str() to bstr_t for converting to tstring. (Sofus Mortensen) + +\par Version 1 beta 17 (2002-2-18) +\li Fixed bug in atl_module. (Michael Geddes) +\li Documentation update for bstr.h. (Michael Geddes) +\li bstr_t now supports strings with embedded nulls. Thanks to Eric Friedman for reporting this. (Sofus Mortensen) +\li Removed use of _alloca in bstr.h. (Sofus Mortensen) + +\par Version 1 beta 16 (2002-2-12) +\li Fixed bug in functors bstr::less, bstr::less_equal, bstr::greater, bstr::greater_equal, bstr::equal_to and bstr::not_equal_to. (Michael Geddes) +\li tlb2h: switched ResolveAliases off per request from Michael Geddes. +\li tlb2h: Removed dummy wrapper methods (see http://groups.yahoo.com/group/tlb2h/message/476). (Sofus Mortensen) + +\par Version 1 beta 15 (2002-2-1) +\li Added lw_lock class based on Brad Wilson's LightweightLock (see http://www.quality.nu/dotnetguy/archive/fog0000000007.aspx). Many thanks to Brad for making LightweightLock open source. (Sofus Mortensen) +\li Comet now works with MSVC7. (Sofus Mortensen) +\li Removed functor.h. (Sofus Mortensen) +\li Fixed serious bug in bstr_base - causing memory corruption when concat'ing bstr's. (Michael Geddes) +\li Fixed obvious typo in locking_ptr. (Vladimir Voinkov) +\li Removed unnecessary include dependency from scope_guard.h. (Vladimir Voinkov) +\li Fixed compatibility problem with STLport for bstr comparison functors. (Michael Geddes) +\li Removed level 4 warnings from currency.h. (Michael Geddes). +\li Fixed problem with the -c option in tlb2h. (Michael Geddes). +\li Fixed bug in ATL_module.h. (Michael Geddes) +\li impl_dispatch is now lazy loading TypeInfo. Better performance for dual interfaces where client is not using IDispatch. (Sofus Mortensen) +\li Fixed various bugs in tlb2h. (Sofus Mortensen) + +\par Version 1 beta 14 (2002-1-17) + +\li Fixed problem with dispinterfaces and [in, out] enum parameters. (Sofus Mortensen) +\li Added simple system to prevent compiling out-of-date tlb2h generated headers. (Sofus Mortensen) +\li Fixed bug in impl_dispatch. (Michael Geddes, Sofus Mortensen) + +\par Version 1 beta 13 take 4 (2002-1-11) + +\li Fixed problem with dispinterfaces and enum parameters reported by Kyle Alons. (Sofus Mortensen) +\li Fixed serious bug in iterators for safearray_t reported by Steve Broeffle. The bug was caused by a MSVC compiler bug. (Sofus Mortensen) +\li Fixed bug operator in operator[] in iterators for safearray_t. (Sofus Mortensen) + +\par Version 1 beta 13 take 3 (2002-1-9) + +\li Fixed bug in uuid_t introduced in beta 13 take 2. (Sofus Mortensen) + +\par Version 1 beta 13 take 2 (2002-1-7) + +\li Beta 13 couldn't compile with _UNICODE defined. Fixed now. (Sofus Mortensen) + +\par Version 1 beta 13 (2002-1-7) + +\li Added basic support for writing exe servers in Comet. (Mikael Lindgren, Sofus Mortensen) +\li Added simple command line parser class to new header comet/cmd_line_parser.h (Mikael Lindgren) +\li Added new header comet/tstring.h. Defines tstring, tistream, tostream, etc, etc. (Sofus Mortensen) +\li Fixed various bugs in uuid_t. (Sofus Mortensen) + +\par Version 1 beta 12 (2001-12-20) + +\li Revision of embedded_object. embedded_object now takes parent type as first argument, arguments 2, 3, 4, .. denotes interfaces to implement. + embedded_object_1 has been removed. embedded_object2 has been added, extends embedded_object with functionality to + disconnect a child object from its parent. (Sofus Mortensen with help from Kyle Alons). +\li Added new file dispatch.h with specialisation of wrap_t with similar (but superior) functionality as CComDispatchDriver. +\li Added new class dynamic_dispatch to dispatch.h. Use dynamic_dispatch to dynamically implement IDispatch - adding methods and properties at runtime. (Sofus Mortensen) +\li Changed interface of sink_impl so that unadvise no longer takes an argument. Additionally the destructor will unadvise if necessary. (Sofus Mortensen) +\li Added new file uuid.h with GUID/UUID/CLSID wrapper called uuid_t. (Sofus Mortensen) +\li Changed tlb2h to support new wrapper uuid_t. (Sofus Mortensen) +\li Fixed potential thread safety problem regarding class factories. (Sofus Mortensen, Paul Hollingsworth) + +\par Version 1 beta 11 (2001-11-16) + +\li Major fix to tlb2h. tlb2h now supports properties in dispinterfaces. (Sofus Mortensen) +\li Module constants are now static. (Sofus Mortensen) +\li tlb2h now skips non-COM interfaces that do not derive (directly or transitively) from IUnknown. (Sofus Mortensen) +\li Fixed problem with error messages ending up as garbage in tlb2h. (Kyle Alons) +\li Various fixes regarding safearray_t. (Michael Geddes and Sofus Mortensen) +\li Various other minor fixes. (Sofus Mortensen) + +\par Version 1 beta 10 (2001-10-17) + +\li class coclass changed so that the 3, 4, ... template parameters specifify additional interfaces to implement. + Example: + \code + template<> coclass_implementation : public coclass + \endcode + (Sofus Mortensen) +\li Aggregating another component is now done by adding class aggregates to the type list of interfaces. First template argument of class aggregates is the coclass + to aggregating. The 2, 4, ... template arguments specify which interfaces to aggregate. If no interfaces have been specified, all interfaces will be aggregated. + Example: + \code + template<> coclass_implementation : public coclass > + \endcode + (Sofus Mortensen) +\li Added cmp method to bstr_base which a.o.t. can be configured for case insensitive comparision. (Michael Geddes) +\li Added comparison functors based on cmp to bstr_base, less, less_equal, equal_to, etc. Example of usage: + \code + std::set > mySet; + \endcode + (Sofus Mortensen) +\li Fixed bugs in assignment operators for datetime_t. (Sofus Mortensen, Mikael Lindgren) +\li In ptr.h changed COMET_ALLOW_DECLSPEC_PROPERTY to COMET_USE_RAW_WRAPPERS. (Michael Geddes) +\li In common.h added workaround for VARIANT_TRUE resulting in a level 4 warning. (Michael Geddes) +\li Changed server.h, so that a compiler error will occur if there are unimplemented coclasses. In case you deliberately want + unimplemented coclass define COMET_ALLOW_UNIMPLEMENTED_COCLASSES in std.h. (Sofus Mortensen) +\li Added various helper functions to util.h. (Sofus Mortensen) +\li Added support for aggregating the free threaded marshaler. Example: + \code + template<> coclass_implementation : public coclass + \endcode + (Sofus Mortensen) +\li Various bug fixes and changes. (Sofus Mortensen) + +\par Version 1 beta 9 (2001-9-23) + +\li Now wrapper properties and methods are only available through com_ptr::operator->. (Sofus Mortensen) +\li Added ostream<> outputting facility to both variant_t and bstr_t. (Sofus Mortensen) +\li Added std::string conversions to variant_t. (Sofus Mortensen) +\li Fixed various bugs in tlb2h regarding dispinterfaces. (Sofus Mortensen). +\li Fixed bug in com_ptr - try_cast'ing from variant_t to com_ptr did not throw an exception on error. (Sofus Mortensen) +\li Made com_ptr constructor from variant_t and assignment from variant_t private in com_ptr to prevent misuse. Use com_cast or try_cast. (Sofus Mortensen) + +\par Version 1 beta 8 (2001-9-19) + +\li Fixed bugs in tlb2h regarding datetime_t. (Sofus Mortensen) +\li Wrapper properties are now only available when accessing an interface through com_ptr::operator->. (Sofus Mortensen) +\li Classes currency_t and datetime_t are now exception safe. (Sofus Mortensen) +\li Added conversions for variant_t from/to currency_t and datetime_t. (Sofus Mortensen) +\li Added conversions for std::wstring to variant_t, solving various ambiguity problems. (Sofus Mortensen) +\li Re-arranged various header files, solving include problems. (Sofus Mortensen) + +\par Version 1 beta 7 (2001-9-7) + +\li Added support for locking to safearray_t. (Michael Geddes) +\li Improved support in tlb2h for methods taking arrays as argument. (Sofus Mortensen) +\li Fixed bug in tlb2h regarding methods that were the parameters were wrongly given a default value. (Sofus Mortensen) +\li Fixed bug in tlb2h regarding type "void *". (Sofus Mortensen) +\li Fixed various bugs in datetime.h. (Michael Geddes) +\li Added COMET_ASSERT - a replacement for _ASSERTE. (Sofus Mortensen) + +\par Version 1 beta 6 take 2 (2001-8-20) + +\li Fixed dumb, dumb _ASSERTE bug in tlb2h (Sofus Mortensen). + +\par Version 1 beta 6 (2001-8-19) + +\li Changed distribution package - now including scripts for generating docs and the source for both tlb2h and the Comet App. wizard (Sofus Mortensen). +\li Wrapped string constant in server.h with _T( ) for UNICODE compatibility (Sofus Mortensen). +\li Tlb2h.exe now generates vtable fillers to cater for interfaces with gaps in the vtable. Such are typically produced by VB (Michael Geddes and Sofus Mortensen). +\li Bug fixes to date_t (Michael Geddes). +\li Elimination of compiler warnings in safearray_t and registry.h (Michael Geddes). + +\par Version 1 beta 5 (2001-8-14) + +\li tlb2h.exe now generates corrects defaults for [optional] VARIANT. variant_t has been updated in order to support this (Sofus Mortensen). +\li Fixed problem in tlb2h.exe with using COMET_ALLOW_DECLSPEC_PROPERTY when importing msado20.tlb (Sofus Mortensen). +\li Fixed problem in tlb2h.exe with aliases being treated as records (Michael Geddes). +\li Several bug fixes to nutshell generation (Michael Geddes). +\li Changed tlb2h, so that the generated headers only #include the headers needed (Michael Geddes). + +\par Version 1 beta 4 (2001-7-25) + +\li datetime_t has been updated and support for datetime_t has been added to tlb2h.exe (Michael Geddes). +\li typelist::index_of bug fix (Michael Geddes, Sofus Mortensen, thanks to Eric Friedman for reporting this). +\li typelist::type_at bug fix (Michael Geddes). +\li create_reference added to safearray_t (Michael Geddes). +\li Experimental attach_from / attach_to added to safearray_t (Michael Geddes). +\li Bug fix in variant.h (Sofus Mortensen). + +\par Version 1 beta 3 (2001-7-14) + +\li MSVC7 beta 2 compatibility fixes (Sofus Mortensen). +\li Various bug fixes in tlb2h (Sofus Mortensen). +\li Added wizard option to tlb2h for generating skeleton implementation of coclasses (Michael Geddes). +\li Various bug fixes to safearray.h (Michael Geddes). +\li variant_t now supports converion to/from saferray_t (Michael Geddes, Sofus Mortensen) +\li com_ptr can now be used to wrap a pointer to coclass_implementation (Michael Geddes). +\li enum.h and cp.h has been updated to support the changes to com_ptr (Michael Geddes). +\li Preliminary version of datetime_t has been added (Michael Geddes). + +\par Version 1 beta 2 (2001-7-04) + +\li Major documentation update (Michael Geddes). +\li Bug fix in tlb2h.cpp (Michael Geddes). +\li Replaced operator bool in com_ptr with a more bullet proof alternative (Sofus Mortensen). +\li Updated functor.h to make use of partial specialisation for compilers that support it (Michael Geddes). + +\par Version 1 beta 1 (2001-6-29) + +\li Added currency support to variant_t (Michael Geddes). +\li Documentation update for server.h (Michael Geddes). +\li Various bug fixes to do with agg-objects (Michael Geddes). +\li Added GetClassObject implementation to atl_module (Michael Geddes). + + +\par Version 1 alpha 10 (2001-6-26): + +\li CURRENCY wrapper updated by Michael Geddes. +\li tlb2h has been updated by Michael Geddes (again!). This time with options to specify which namespace to put wrappers in, and an options to emit symbols only for faster compilation. +\li atl_module.h documentation updated by Michael Geddes. + +\par Version 1 alpha 9 (2001-6-21): + +\li CURRENCY wrapper added by Michael Geddes. +\li Nutshell wrappers didn't work in alpha 8. Now fixed. +\li tlb2h has been updated by Michael Geddes for better command line handling. It now supports multiple files including wildcards, and support for specifying an output directory. +\li Server implementation updated by Michael Geddes to support loading type libraries that has not yet been registered. +\li try_cast no longer throws on null pointers, and comet::com_ptr::operator->() now throws on null pointers. (Michael Geddes) + +\par Version 1 alpha 8 (2001-6-10): + +\li Compatibility patches for GCC/MINGW submitted by Michael Geddes. +\li Updated com_error with methods for accessing wrapped HRESULT value and IErrorInfo (source, helpfile, etc). +\li Various minor bug fixes. + +\par Version 1 alpha 7 take 3 (2001-3-31): + +\li Added converters for CURRENCY to variant_t.. +\li Updated functor.h. + +\par Version 1 alpha 7 take 2 (2001-3-28): + +\li Fixed bug concerning using com_cast and try_cast with raw interface pointers. +\li Fixed bug in bstr.h +\li Fixed dependency on comet/stl.h in comet/enum.h + + +\par Version 1 alpha 7 take 1 (2001-3-26): + +\li Support for dispinterfaces has been added by Michael Geddes and Mikael Lindgren. +\li BCC compatibility patches contributed by Michael Geddes. +\li Support for multiple connection points added by Michael Geddes. +\li Added generalised functor library that works with MSVC (Not really COM related) +\li comet::make_list\<\> has changed behaviour. Instead of writing make_list\, you have to write \link comet::make_list make_list\::result \endlink. This has been done in order to shorten error messages relating typelists. +\li Added several helper classes to comet/typelist.h for manipulation of typelists. +\li Fixed various "ambiguous conversion" errors + + +\par Version 1 alpha 6 (2001-3-7): + +\li Fixed disastrous bug in comet::com_ptr. +\li Re-organisation of header files. +\li Support for Intel C++ 5.0 added. +\li Fixed bug in regkey. +\li Various bugs fixes. + + +\par Version 1 alpha 5 take 2 (2001-1-26): + +\li Fixed bug in ptr.h + + +\par Version 1 alpha 5 (2001-1-16): + +\li Support for implementing aggregateable components. (Michael Geddes) +\li comet::com_ptr is no longer using common base class. +\li Various bug fixes. + + +\par Version 1 alpha 4.2 (2000-12-17): + +\li Fixed bug in critical_section. + + +\par Version 1 alpha 4.1 (2000-12-14): + +\li Fixed bug in variant.h +\li Added support for DATE and CURRENCY to tlb2h. (We might need wrapper classes for those). +\li Fixed missing inline in common.h. + + +\par Version 1 alpha 4 (2000-12-12): + +\li Generated wrappers, interfaces, etc are now placed in namespace corresponding to typelibrary name by tlb2h. +\li Fixed bugs in variant.h +\li The generated wrappers are no longer using .get_raw() and .get_raw_ptr(). Instead the wrapper methods .in(), .in_ptr(), .inout() and .out() are being used. +\li Support for constants placed in type library modules. (See Joav Kohn's posting on ATL discuss). +\li Support for version numbering for ProgID's. (Thanks to Mikael Lindgren). +\li Updated the wizard. + + +\par Version 1 alpha 3 (2000-11-29): + +\li Added sanity checking to safearray_t to capture type mismatches. +\li Added in() method to all wrapper classes for use when calling raw interfaces. +\li The generated header files are now using a normal include guard instead of #pragma once. +\li Various minor fixes. + + +\par Version 1 alpha 2 (2000-11-20): + +\li Nutshell generation added to tlb2h.exe. +\li Added STL compatible SAFEARRAY wrapper called comet::safearray_t. +\li Updated registry class. +\li New BSTR wrapper, comet::bstr with optional reference counting. +\li comet::bstr_t is now a typedef of comet::bstr. +\li ATL support added. + + +\par Version 1 alpha 1 (2000-10-29): + +\li First alpha release of Comet. + + +\par Version 0.9.7 (2000-10-19): + +\li typedef bug fix in tlb2h.exe +\li Bug fixes in comet::variant_t + + +\par Version 0.9.6 (2000-10-19): + +\li Documentation updates. +\li Misc. bug fixes. + + +\par Version 0.9.5 (2000-10-5): + +\li Documentation updates. +\li Paul Hollingsworth has been busy minimising include dependencies in the header files. +\li Added [out] and [in, out] adapters for dealing with raw interfaces. + + +\par Version 0.9.4 (2000-10-4): + +\li Fixed more bugs in comet::com_ptr. +\li Added documentation on comet::com_ptr. + + +\par Version 0.9.3 (2000-9-26): + +\li Fixed various bugs in comet::com_ptr. + + +\par Version 0.9.2 (2000-9-25): + +\li Updated tlb2h to use const where appropiate. +\li Added support for unions. +\li Added support for one-dimensional arrays in structs. + + +\par Version 0.9.1 (2000-9-21): + +\li Experimental support in tlb2h.exe for optional method arguments (ie. attribue optional or defaultvalue). + + +\par Version 0.9.0 (2000-9-19): + +\li Paul Hollingsworth has contributed automatic implementation of IProvideClassInfo. +\li Better support for [in, out] parameters. +\li Fixed bugs in tlb2h's generation of connection point wrapper. +\li Removed progid from template parameters, instead override function get_progid(). +\li Added version metadata to coclass and typelibrary wrappers. +\li Fixed bug in variant_t::variant_t(const comet::bstr_t&). + + +\par Version 0.8.3 (2000-9-12): + +\li Removed DLL dependency for tlb2h.exe. + + +\par Version 0.8.2 (2000-9-7): + +\li com_error / raise_exception_t has been revised. +\li Fixed bug in com_ptr::operator=(int) +\li Rearranged header inclusion introducing error_fwd.h. +\li Added misc. utility classes not necessarily related to tlb2h to tlb2h/utility.h. +\li Updated tlb2h.exe with more types. + + +\par Version 0.8.1 (2000-9-3): + +\li Type conversions to/from bstr_t has been changed/tweaked. +\li bstr_t now supports concatenation through operator+ and operator+=. + + +\par Version 0.8.0 (2000-8-31): + +\li Fixed several bugs in tlb2h.exe. +\li Added misc. utility classes not necessarily related to tlb2h to tlb2h/utility.h. + + +\par Version 0.7.10 (2000-8-25): + +\li Updated AppWizard to generate uuid for type library. +\li Added trait class to com_server for servers with no embedded type library. + + +\par Version 0.7.9 (2000-8-21): + +\li bstr_t is now capable of converting to std::string as well. +\li Rearranged util.h into list.h, common.h and util.h. + + +\par Version 0.7.8 (2000-8-18): + +\li Added simple AppWizard for creating DLL projects. +\li Removed untie. Instead embedded_object now has a release_from_owner method. +\li structs defined in type libraries now automatically use CoTaskMem when using new/delete. + + +\par Version 0.7.7 (2000-8-15): + +\li Changes to lifetime of embedded_object. Introducing tlb2h::untie, breaks tie between owner and embedded_object, so that the embedded_object can be destroyed before the owner. + + +\par Version 0.7.6 (2000-8-15): + +\li Various changes to comet::bstr_t. + + +\par Version 0.7.5 (2000-8-13): + +\li Interface inheritance problems solved. +\li Problem with [in] VARIANT arguments solved. +\li create_enum now works with embedded_objects. +\li comet::make_list now handles up to 40 elements. +\li Problem with IUnknown interfaces in coclasses solved. +\li Workaround for bug in Visual Studio editor causing VS to crash when editing certain template code. + + +\par Version 0.7.4 (2000-8-8): + +\li Conversion from comet::com_ptr to comet::variant_t improved. +\li Updated example to demonstrate now working COM enumeration implementation on STL containers. + + +\par Version 0.7.3 (2000-8-8): + +\li Nasty connection point bug fixed. +\li Added trivial VB client example program demonstrating connection point. +\li Added com_cast and try_cast for casting interface pointers. Implicit casting no longer allowed. +\li comet::com_error::what() is now working. +\li Misc. minor bug fixes/tweaks. + + +\par Version 0.7.2 (2000-8-3): + +\li Updated the example with registration custom build. +\li Misc. bug fixes. + +*/ +//! Primary namespace for comet. Includes source and libraries. +namespace comet { +//! Namespace for comet implementation details. +/*! \internal + */ +namespace impl { +} +} +/** \defgroup Misc Miscelaneous utility classes. + *@{ + */ +//@} +/** \defgroup COMType Com type wrappers. + *@{ + */ +//@} +/*!\defgroup WinUtil Windows utility classes. + *@{ + */ +//@} + + +#endif diff --git a/EyeTab_SP2/comet/common.h b/EyeTab_SP2/comet/common.h new file mode 100644 index 0000000..af06fd5 --- /dev/null +++ b/EyeTab_SP2/comet/common.h @@ -0,0 +1,316 @@ +/** \file + * Common utility classes wrappers. + */ +/* + * Copyright © 2000, 2001 Sofus Mortensen + * + * This material is provided "as is", with absolutely no warranty + * expressed or implied. Any use is at your own risk. Permission to + * use or copy this software for any purpose is hereby granted without + * fee, provided the above notices are retained on all copies. + * Permission to modify the code and to distribute modified code is + * granted, provided the above notices are retained, and a notice that + * the code was modified is included with the above copyright notice. + * + * This header is part of Comet version 2. + * https://github.com/alamaison/comet + */ + +#ifndef COMET_COMMON_H +#define COMET_COMMON_H + +#include +#include +#include + +namespace comet { + + class uuid_t; + templateclass com_ptr; + namespace impl { + template T* bad_alloc_check(T* x) + { + if (!x) throw std::bad_alloc(); + return x; + } + + /** Implementation struct for auto_attach. + * \internal + */ + template class auto_attach_t + { + public: + explicit auto_attach_t(const T& v) : val_(v) {}; + const T& get() const { return val_; } + private: + const T& val_; + auto_attach_t& operator=(const auto_attach_t&); + }; + + // Forward declare all these - only used if we actually WANT a + // safearray. + /** Safearray traits for the given type. + * \internal + */ + template struct sa_traits; + /** Safearray iterator for the given type. + * \internal + */ + template class sa_iterator; + /** Safearray const traits for the given type. + * \internal + */ + template struct const_traits; + /** Safearray non-const traits for the given type. + * \internal + */ + template struct nonconst_traits; + + enum sa_traits_check_type { stct_features_ok, stct_vt_ok, stct_iid_ok }; + enum sa_traits_extras_type { stet_null, stet_record, stet_iid }; + + // Interface traits are needed by all interfaces so that we can create + // safearrays of the types. + template + struct interface_sa_traits + { + enum { vt = VT }; + enum { check_type = stct_iid_ok }; + enum { extras_type = stet_iid }; + + typedef INTERFACE* raw; + typedef com_ptr value_type; + typedef com_ptr & reference; + typedef const com_ptr & const_reference; + + static reference create_reference(raw& x) { return *reinterpret_cast*>(&x); } + static const_reference create_const_reference(raw& x) { return *reinterpret_cast*>(&x); } + typedef nonconst_traits > nct; + typedef sa_iterator, nct > iterator; + typedef sa_iterator, const_traits > > const_iterator; + + static bool are_features_ok(unsigned short f) { return (f & FEATURE_FLAG) != 0 && (f & FADF_HAVEIID) != 0; } + static const uuid_t& iid() { return uuidof(); } + }; + + /** Basic safearray traits - used by enums. + * \internal + */ + template struct basic_sa_traits + { + enum { vt = VT }; + enum { check_type = stct_vt_ok }; + enum { extras_type = stet_null }; + + typedef T raw; + typedef T value_type; + typedef T& reference; + typedef const T& const_reference; + + static reference create_reference(T& x) { return x; } + static const_reference create_const_reference(T& x) { return x; } + + typedef T* iterator; + typedef const T* const_iterator; + + static bool are_features_ok(unsigned short) { return true; } + }; + } + + /*! \addtogroup COMType + */ + //@{ + /// Used to attach a raw parameter to a wrapper. + template impl::auto_attach_t auto_attach(const T& t) { return impl::auto_attach_t(t); } + + +// template inline T up_cast(const U& u, T* = 0) { return u; } + + + /*! VARIANT_BOOL to bool [in] converter. + * This is used by the generated wrappers. + */ + inline VARIANT_BOOL bool_in(bool x) { return x ? COMET_VARIANT_TRUE : COMET_VARIANT_FALSE; } + + /** \class bool_out common.h comet/common.h + * VARIANT_BOOL to bool [out] converter. + * This is used by the generated wrappers. + */ + class bool_out { + public: + operator VARIANT_BOOL*() { return &vb_; } + bool_out(bool& b) : b_(b) {} + ~bool_out() { b_ = vb_ ? true : false; } + private: + bool_out &operator=( const bool_out &); + VARIANT_BOOL vb_; + bool& b_; + }; + + namespace impl { + class bool_adapter_t { + public: + bool_adapter_t(VARIANT_BOOL* p) : pb_(p) { b_ = *pb_ ? true : false; } + ~bool_adapter_t() { *pb_ = b_ ? COMET_VARIANT_TRUE : COMET_VARIANT_FALSE; } + + bool& ref() { return b_; } + private: + bool_adapter_t(const bool_adapter_t&); + bool_adapter_t& operator=(const bool_adapter_t&); + + VARIANT_BOOL* pb_; + bool b_; + }; + } + + /** \class bool_inout common.h comet/common.h + * VARIANT_BOOL to bool [in,out] converter. + * This is used by the generated wrappers. + */ + class bool_inout { + public: + operator VARIANT_BOOL*() { return &vb_; } + bool_inout(bool& b) : b_(b), vb_(b ? COMET_VARIANT_TRUE : COMET_VARIANT_FALSE) {} + ~bool_inout() { b_ = vb_ ? true : false; } + private: + bool_inout &operator=(const bool_inout &); + VARIANT_BOOL vb_; + bool& b_; + }; + + /** \class variant_bool_t common.h comet/common.h + * VARIANT_BOOL wrapper for structs. + * Stands in place of a VARIANT_BOOL in a struct, and behaves like a bool. + * This is imporant as sizeof(VARIANT_BOOL) != sizeof(bool). + */ + class variant_bool_t + { + VARIANT_BOOL vb_; + public: + /// \name Constructors. + //@{ + variant_bool_t(): vb_(COMET_VARIANT_FALSE) {} + variant_bool_t(const impl::auto_attach_t &b) : vb_(b.get()) {} + variant_bool_t(bool b) : vb_(b?COMET_VARIANT_TRUE:COMET_VARIANT_FALSE) {} + //@} + + /// \name Assignment operators. + //@{ + variant_bool_t &operator=( bool b) { vb_ = b?COMET_VARIANT_TRUE:COMET_VARIANT_FALSE; return *this;} + variant_bool_t &operator=( const impl::auto_attach_t &b) { vb_ = b.get(); return *this; } + //@} + + /// \name Boolean operators. + //@{ + operator bool() const{ return vb_!= COMET_VARIANT_FALSE; } + bool operator !() const { return vb_== COMET_VARIANT_FALSE; } + bool operator==( variant_bool_t vb) const { return vb.vb_ == vb_; } + bool operator!=( variant_bool_t vb) const { return vb.vb_ != vb_; } + //@} + + /// \name Bitwise operators + //@{ + variant_bool_t operator~() const { variant_bool_t temp(*this); temp.vb_ = (VARIANT_BOOL)~(temp.vb_); return temp; } + variant_bool_t &operator&=( const variant_bool_t &b) { vb_ &= b.vb_; return *this; } + variant_bool_t &operator|=( const variant_bool_t &b) { vb_ |= b.vb_; return *this; } + variant_bool_t &operator^=( const variant_bool_t &b) { vb_ ^= b.vb_; return *this; } + variant_bool_t operator&( const variant_bool_t &b)const { variant_bool_t temp(*this); temp.vb_ &= b.vb_; return temp; } + variant_bool_t operator|( const variant_bool_t &b)const { variant_bool_t temp(*this); temp.vb_ |= b.vb_; return temp; } + variant_bool_t operator^( const variant_bool_t &b)const { variant_bool_t temp(*this); temp.vb_ ^= b.vb_; return temp; } + //@} + /// \name bool operators + //@{ + bool operator&( bool b)const { return b & operator bool(); } + bool operator|( bool b)const { return b | operator bool(); } + bool operator^( bool b)const { return b ^ operator bool(); } + //@} + + static const variant_bool_t &create_const_reference(const VARIANT_BOOL &vb) { return reinterpret_cast(vb); } + static variant_bool_t &create_reference(VARIANT_BOOL &vb) { return reinterpret_cast(vb); } + + ///\name Raw accessors + //@{ + VARIANT_BOOL in() { return vb_; } + VARIANT_BOOL *out() { return &vb_; } + VARIANT_BOOL *inout() { return &vb_; } + //@} + + + /** Allow treating of class as a bool *. + * \sa bool_ptr() + */ + class bool_pointer_t + { + friend class variant_bool_t; + protected: + bool_pointer_t( VARIANT_BOOL &vb) : vb_(vb), b_( vb != COMET_VARIANT_FALSE) {} + public: + ~bool_pointer_t() { vb_ = b_ ? COMET_VARIANT_TRUE: COMET_VARIANT_FALSE; } + operator bool*(){ return &b_; } + operator const bool*()const{ return &b_; } + private: + bool_pointer_t &operator=(const bool_pointer_t &); + bool b_; + VARIANT_BOOL &vb_; + }; + /** Return a class that stands in for a bool *. + Should be used in place of operator & for passing in to a bool * function. + \code + variant_bool_t vb; + SomeFunc(vb.bool_ptr()); + \endcode + */ + bool_pointer_t bool_ptr() + { + return bool_pointer_t(vb_); + } + const bool_pointer_t bool_ptr() const + { + return bool_pointer_t(const_cast(vb_)); + } + + friend class bool_reference_t; + /** Allow efficient choosing between a bool& and a variant_bool&. + */ + class bool_reference_chooser_t + { + friend class variant_bool_t; + variant_bool_t &vbt_; + protected: + bool_reference_chooser_t(variant_bool_t &vbt):vbt_(vbt) {} + private: + bool_reference_chooser_t &operator=(const bool_reference_chooser_t &); + public: + inline operator variant_bool_t&() { return vbt_;} + inline operator const variant_bool_t&()const { return vbt_;} + }; + /** Allow treating of a class as a bool &. + * \sa bool_ref() + */ + class bool_reference_t : protected bool_pointer_t + { + public: + bool_reference_t( bool_reference_chooser_t &brc ) + : bool_pointer_t(*static_cast(brc).inout()) + {} + operator bool &(){ return tmp; /*return * (bool_pointer_t::operator bool*());*/ } + operator const bool &()const { return *(bool_pointer_t::operator const bool*()); } + bool tmp; + }; + + /** Return a class that stands in for a bool & or a variant_bool_t &. + */ + bool_reference_chooser_t bool_ref() + { + return bool_reference_chooser_t(*this); + } + const bool_reference_chooser_t bool_ref() const + { + return bool_reference_chooser_t(const_cast(*this)); + } + }; + //@} + +} // namespace + +#endif diff --git a/EyeTab_SP2/comet/config.h b/EyeTab_SP2/comet/config.h new file mode 100644 index 0000000..58b9dd3 --- /dev/null +++ b/EyeTab_SP2/comet/config.h @@ -0,0 +1,243 @@ +/** \file + * Included by all comet headers to provide compiler-specific + * configuration. + */ +/* + * Copyright © 2000-2002 Sofus Mortensen + * Copyright (C) 2013 Alexander Lamaison + * + * This material is provided "as is", with absolutely no warranty + * expressed or implied. Any use is at your own risk. Permission to + * use or copy this software for any purpose is hereby granted without + * fee, provided the above notices are retained on all copies. + * Permission to modify the code and to distribute modified code is + * granted, provided the above notices are retained, and a notice that + * the code was modified is included with the above copyright notice. + * + * This header is part of Comet version 2. + * https://github.com/alamaison/comet + */ + +#ifndef COMET_CONFIG_H +#define COMET_CONFIG_H + +#define COMET_MAJOR_VER 2 +#define COMET_BUILDTYPE gamma +#define COMET_MINOR_VER 1 +#define COMET_BUILD 20131017 + +#ifndef COMET_BUILD_VERSION_ONLY + +#ifndef COMET_NO_DECLSPEC_PROPERTY +#define COMET_ALLOW_DECLSPEC_PROPERTY +#endif // COMET_NO_DECLSPEC_PROPERTY + +#pragma warning(disable : 4786) +#pragma warning(disable : 4042) +#pragma warning(disable : 4290) +#pragma warning(disable : 4710) + +#ifdef _lint // PC/Lint has a few problems with comet. +# if !defined(_MSC_VER) || _MSC_VER >= 1300 +#define COMET_PARTIAL_SPECIALISATION +#else + +#endif +#define COMET_NESTED_TEMPLATES +#define COMET_GOOD_RECURSIVE_STRUCT +#define COMET_CONST_MEMBER_INIT +#define COMET_GUID_BASE GUID +#define COMET_STD_ITERATOR +#define COMET_NO_POINTER_CHECKING +#define COMET_STD_SWAP_NOTHROW throw() +#define COMET_TL_TRUNC +#else +//VC 7.1 support partial specialization +#ifdef _MSC_VER +#endif + +#ifdef __ICL +# define COMET_PARTIAL_SPECIALISATION +# define COMET_NESTED_TEMPLATES +#else +# ifdef _MSC_VER +# if _MSC_VER < 1300 +// Versions less than VC7 can't handle the rethrow & catch exception trick. +# define COMET_DISABLE_EXCEPTION_RETHROW_CATCH +# else // _MSC_VER >= 1300 +# define COMET_GOOD_RECURSIVE_STRUCT +# define COMET_CONST_MEMBER_INIT +# if _MSC_VER >= 1310 +# define COMET_PARTIAL_SPECIALISATION +# define COMET_NESTED_TEMPLATES +# endif +# endif + +# endif +#if defined(_UNICODE) && !defined(UNICODE) + #define UNICODE +#endif +#endif + +#ifdef __BORLANDC__ +#pragma warning(disable: 8027) +#pragma warning(disable: 8026) +#define COMET_PARTIAL_SPECIALISATION +#define COMET_NESTED_TEMPLATES +#define COMET_BROKEN_WTYPES +#define COMET_STD_ITERATOR +#define COMET_STD_SWAP_NOTHROW + +#define COMET_GUID_BASE _GUID +#else +#define COMET_STD_SWAP_NOTHROW throw() +#define COMET_GUID_BASE GUID +#endif + +#ifdef __CYGWIN__ +#define COMET_PARTIAL_SPECIALISATION +#define COMET_NESTED_TEMPLATES +#define COMET_GCC_HEADERS +#define COMET_STD_ITERATOR +#define COMET_TL_TRUNC +#define _T(x) x + +// This is not a good idea +// Routines that use _alloca has to be rewritten for __MINGW32__ targets. +// #define _alloca malloc + +// WIN32 defines for GCC +#define NONAMELESSUNION +#define NOCOMATTRIBUTE +#endif +#endif + + +// Use COMET_STRICT_TYPENAME only where MSVC barfs on stricter typename usage +// required by GCC. +#ifdef _MSC_VER +#if _MSC_VER <= 1300 +#define COMET_STRICT_TYPENAME +#else +#define COMET_STRICT_TYPENAME typename +#endif +#else +#define COMET_STRICT_TYPENAME typename +#endif + +// PRH Feb 26 2001 +// Try and determine which version of std::iterator we have. +// The ANSI/ISO compliant one seems to require a compiler +// that supports partial specialisation, as well as an +// ANSI/ISO compliant implementation of the library. + +// Unfortunately, there is no __ANSI_STL #define. +// So we guess: +// If we have partial specialisation, and we're using STLPort, then +// its the ANSI/ISO std::iterator, otherwise it is the MSVC 6.0 +// iterator. + +// If you're using some other decent STL other than STLPort, +// then you'll need to reflect this by ensuring that COMET_STD_ITERATOR +// is defined. + +#if _MSC_VER >= 1300 || defined(_CPPLIB_VER) +#define COMET_STD_ITERATOR +#else +#include +#ifdef COMET_PARTIAL_SPECIALISATION +// this code to "detect" STLport is stolen from +//#if __SGI_STL_PORT >= 0x400 || __SGI_STL_PORT >= 0x321 && defined(__STL_USE_NAMESPACES) +#ifdef __SGI_STL +#define COMET_STD_ITERATOR +#else +#ifdef __MINGW32__ +__STL_BEGIN_NAMESPACE +template struct iterator: bidirectional_iterator<_Tp,_Distance>{}; +__STL_END_NAMESPACE +#endif // __MINGW32__ +#endif +#else +#ifdef _CPPLIB_VER +#define COMET_STD_ITERATOR +#endif +#endif /* COMET_PARTIAL_SPECIALISATION */ +#endif + +#ifndef ATL_NO_VTABLE +#if _MSC_VER >= 1200 +#define ATL_NO_VTABLE __declspec(novtable) +#else +#define ATL_NO_VTABLE +#endif +#endif + +#if _MSC_VER <= 1200 +//#define COMET_DO_NOT_SPECIALISE_SWAP_IN_STD +#endif + +// Intel compiler version 500 sets _MSC_VER to 1200, +// but doesn't seem to like __forceinline +#if _MSC_VER >= 1200 && !defined(__ICL) +#define COMET_FORCEINLINE __forceinline +#else +#define COMET_FORCEINLINE inline +#endif + +#ifdef _UNICODE +#ifndef UNICODE +#define UNICODE // UNICODE is used by Windows headers +#endif +#endif + +#ifdef UNICODE +#ifndef _UNICODE +#define _UNICODE // _UNICODE is used by C-runtime/MFC headers +#endif +#endif + +// Remove Microsoft's C++ macros +#undef variant_t +#undef bstr_t +#undef com_cast + +// Stop subsequent includes of from #defining variant_t or bstr_t +#ifndef _USE_RAW +#define _USE_RAW +#endif + +#ifndef UUID_DEFINED +#define UUID_DEFINED +#endif + +#ifndef UUID +#define UUID GUID +#endif + +#ifdef uuid_t +#undef uuid_t +#endif + +#define COMET_DECLARE_SWAP(TYPE) template<> inline void swap(TYPE &x, TYPE &y)\ + {\ + x.swap(y);\ + } + +const unsigned short COMET_VARIANT_TRUE = (unsigned short)(0xffff); +const unsigned short COMET_VARIANT_FALSE = 0; + +#define COMET_NOTUSED(x) x +#ifndef COMET_CONST_MEMBER_INIT +# define COMET_CONST_TYPE(vartype, varname,value) enum { varname = value }; +# define COMET_CONST_GROUP enum { +# define COMET_CONST_ENTRY(vartype, varname,value) varname = value, +# define COMET_CONST_GROUP_END }; +#else +# define COMET_CONST_TYPE(vartype, varname,value) static const vartype varname = value; +# define COMET_CONST_ENTRY(vartype, varname,value) COMET_CONST_TYPE(vartype, varname, value); +# define COMET_CONST_GROUP +# define COMET_CONST_GROUP_END +#endif +#endif // COMET_BUILD_VERSION_ONLY +#endif + diff --git a/EyeTab_SP2/comet/cp.h b/EyeTab_SP2/comet/cp.h new file mode 100644 index 0000000..1c9a9e8 --- /dev/null +++ b/EyeTab_SP2/comet/cp.h @@ -0,0 +1,436 @@ +/** \file + * Connection-point implementations. + * The thought behind the current implementation was to try and maintain + * connections points accessible from the coclass through the member + * connection_point. + * + * Where multiple connection-points are defined, the member is accessed thus: + * \code + * connection_point_for::connection_point + * \endcode + * The default connection point wrapper implementations have a prefix of + * \b Fire_ before the event name. + */ +/* + * Copyright © 2000 Sofus Mortensen + * + * This material is provided "as is", with absolutely no warranty + * expressed or implied. Any use is at your own risk. Permission to + * use or copy this software for any purpose is hereby granted without + * fee, provided the above notices are retained on all copies. + * Permission to modify the code and to distribute modified code is + * granted, provided the above notices are retained, and a notice that + * the code was modified is included with the above copyright notice. + * + * This header is part of Comet version 2. + * https://github.com/alamaison/comet + */ + +#ifndef COMET_CP_H +#define COMET_CP_H + +#include + +#include + +#include +#include + +#pragma warning( push ) +#pragma warning( disable : 4355 ) + +/** \page cometconnectionpoints Connection Points. +\section cometconnectionpointssource Connction Point Source +Connection points provide events for comet, and rely on tlb2h (see \ref tlb2husage) to generate +the implementation for each method on the interface. + +Then comet::implement_cpc is used to provide IConnectionPointContainer +(which provides the method for finding a particular connection point. + +The default implementation of a coclass will inherit of this method by +default, however they can be explicitly referenced to provide +alternate implementations. + +The class comet::implement_cpc is templated to an interface list, which +can be constructed with comet::make_list. + +\code + class my_class : public simple_object< IFooImpl, implement_cpc< make_list::result > > +\endcode + +This causes each of the interface in the list of interfaces to be wrapped by a +comet::connection_point_for class which provides the access syntax. + +\code + connection_point_for::connection_point.Fire_FooMethod( args ); +\endcode + +Note that \b Fire_ is prepended to each method name. + +If there is only one connection point in the list, then the +connection_point_for namespace segregator is not required. + +If there is no connection point implementation for the interface, then you should make +sure that it is referenced with a [source] tag by a coclass definition +in the library you are including, and that you are generating server +implementations or forcing it by prepending '*' in a symbol file, see +the \ref wrappergensymbolformat. + +\section cometconnectionpointsink Connction Point Sink + +In order to prevent the circular references inherent in connection points, the +reference loop must be broken somehow. This is best done by using a contained +member that calls back on the parent class. + +The class sink_impl is best used in this circumstance as it contains code for calling +Advise and Unadvise. It inherits from static_object which is designed to be embedded in +a class, and does reference counting on the module and does not destruct itself. + +This class is templated to the interface implementation desired, which will +mostly be the 'Impl' class for the interface, but might be a raw COM interface. + +In this example we have a class 'MyCoclass' that is sinking the event interface IMyEventImpl which +has a single 'EventHappened' method. +\code + class coclass_MyCoclass : public coclass + { + // Private Embedded sink implementation. + struct sink_t : sink_impl + { + sink_t(coclass_MyCoclass *Parent) :m_parent(Parent) {} + inline void EventHappened( long param_Here ) { m_parent->sink_EventHappened(param_Here); } + coclass_MyCoclass *m_parent; // Non-addref reference. + } m_sink; + public: + coclass_MyCoclass() : m_sink(this) {} + + // Set the event source. + void SetEventSource( const com_ptr &unknown) + { + if (m_sink.is_advised()) + m_sink.unadvise(); + m_sink.advise( unknown ); + } + + inline void sink_EventHappened( long param_Here ) + { + // Event code goes here + } + }; +\endcode + +*/ + +namespace comet { + + template class connection_point; + + /*! \addtogroup Interfaces + */ + //@{ + /** \class simple_cpc cp.h comet/cp.h + * Implement a simple connection-point container with a single + * connection-point. + * \param Itf The single connection-point interface. + * \sa implement_cpc + */ + template class ATL_NO_VTABLE simple_cpc : public IConnectionPointContainer + { + public: + typedef IConnectionPointContainer interface_is; + + protected: + /// \name IConnectionPointContainer interface + //@{ + STDMETHOD(EnumConnectionPoints)(IEnumConnectionPoints**) + { + return E_NOTIMPL; + } + + STDMETHOD(FindConnectionPoint)(REFIID riid, IConnectionPoint** ppCP) + { + if (!ppCP) return E_POINTER; + if (riid == uuidof()) { + *ppCP = &connection_point; + (*ppCP)->AddRef(); + return S_OK; + } + return CONNECT_E_NOCONNECTION; + } + //@} + + protected: + simple_cpc() : connection_point(this) {} + + connection_point connection_point; + }; + + + /** \class connection_point_for cp.h comet/cp.h + * Provide access to implementation for a connection point. + * \relates implement_cpc + */ + template class connection_point_for + { + public: + connection_point_for(::IUnknown *self) : connection_point(self) {} + connection_point connection_point; + }; + + + namespace impl { + + /** Find a connection point implementation for a given iid. + * \internal + */ + template struct connection_point_finder + { + template COMET_FORCEINLINE static ::IConnectionPoint* find_connection_point(T* This, const IID& iid) + { + typedef find_compatibility< COMET_STRICT_TYPENAME ITF_LIST::head > compatible; + if (iid == uuidof()) + return &((static_cast *>(This))->connection_point) ; + else return connection_point_finder::find_connection_point(This, iid); + } + }; + template<> struct connection_point_finder + { + template COMET_FORCEINLINE static ::IConnectionPoint* find_connection_point(T*, const IID&) + { + return 0; + } + }; + + } + + namespace impl { + + + template struct ATL_NO_VTABLE inherit_all_ex_unknown; + +#ifdef COMET_GOOD_RECURSIVE_STRUCT + // Remove level of indirection. PC-lint cannot handle it, and MSVC7 + // should be ale to. + template struct ATL_NO_VTABLE inherit_all_ex_unknown + : public ITF_LIST::head, public inherit_all_ex_unknown + { + inherit_all_ex_unknown( ::IUnknown *initParam) + : ITF_LIST::head(initParam), inherit_all_ex_unknown< COMET_STRICT_TYPENAME ITF_LIST::tail >(initParam) + {} + }; + template<> struct inherit_all_ex_unknown { inherit_all_ex_unknown(::IUnknown *) {} }; + +#else // COMET_GOOD_RECURSIVE_STRUCT + template struct ATL_NO_VTABLE inherit_all_ex_aux_unknown + : public HEAD, public inherit_all_ex_unknown + { + inherit_all_ex_aux_unknown( ::IUnknown *initParam) + : HEAD(initParam), inherit_all_ex_unknown(initParam) + {} + }; + +// COMET_CONFIG_H is always defined! This is just a trick to get Doxygen to ignore the following declaration that +// otherwise seems to be cause an exception in Doxygen 1.2.8 +#ifdef COMET_CONFIG_H + template struct ATL_NO_VTABLE inherit_all_ex_unknown + : public inherit_all_ex_aux_unknown + { + inherit_all_ex_unknown( ::IUnknown *initParam) + :inherit_all_ex_aux_unknown< COMET_STRICT_TYPENAME ITF_LIST::head, COMET_STRICT_TYPENAME ITF_LIST::tail >(initParam) + { + } + }; + template<> struct inherit_all_ex_unknown { inherit_all_ex_unknown(::IUnknown *) {} }; +#endif // COMET_CONFIG_H +#endif // COMET_GOOD_RECURSIVE_STRUCT + + + + } + + + COMET_WRAP_EACH_DECLARE( connection_point_for) + + + /** \struct implement_cpc cp.h comet/cp.h + * Implement a connection point container that can handle multiple + * connection points. + * This should be added to the \link comet::make_list list \endlink of implemented interfaces for a coclass as it + * implements IConnectionPointContainer (which will be required for a qi). + * + * The class is used by the default coclass implementation to provide \ref cometconnectionpoints. + * + * \param ITF_LST \link comet::make_list List \endlink of connection points interfaces to implement. + */ + template< typename ITF_LST> struct ATL_NO_VTABLE implement_cpc : public IConnectionPointContainer + , public impl::inherit_all_ex_unknown< COMET_WRAP_EACH(connection_point_for, ITF_LST) > + { + typedef IConnectionPointContainer interface_is; + public: + implement_cpc() + : impl::inherit_all_ex_unknown< COMET_WRAP_EACH(comet::connection_point_for, ITF_LST) >((::IUnknown *)this) + {} + + protected: + friend struct impl::connection_point_finder; + /// \name IConnectionPointContainer interface + //@{ + STDMETHOD(EnumConnectionPoints)(IEnumConnectionPoints**) + { + return E_NOTIMPL; + } + + STDMETHOD(FindConnectionPoint)(REFIID riid, IConnectionPoint** ppCP) + { + if (!ppCP) return E_POINTER; + + const IID& iid = riid; + + *ppCP = impl::connection_point_finder::find_connection_point(this, iid); + + if ( *ppCP !=NULL) + { + (*ppCP)->AddRef(); + return S_OK; + } + return CONNECT_E_NOCONNECTION; + } + //@} + }; + + + /** \class connection_point_impl cp.h comet/cp.h + * Implements a connection point. + * \param Itf Interface of connection point. + */ + template class ATL_NO_VTABLE connection_point_impl : public embedded_object< IUnknown, IConnectionPoint > + { + public: + bool is_connected() const + { return !connections_.empty(); } + protected: + connection_point_impl(::IUnknown* pUnk) : next_cookie_(1), embedded_object< IUnknown, IConnectionPoint >(pUnk) {} + + /// \name IConnectionPoint interface + //@{ + STDMETHOD(GetConnectionInterface)(IID* pIID) + { + *pIID = uuidof(); + return S_OK; + } + + STDMETHOD(GetConnectionPointContainer)(IConnectionPointContainer** ppCPC) { + com_ptr p; + p = try_cast(com_ptr< ::IUnknown >(get_parent())); + *ppCPC = com_ptr::detach( p ); + return S_OK; + } + + STDMETHOD(Advise)(::IUnknown* pUnkSink, DWORD* pdwCookie) + { + try { + connections_[next_cookie_] = try_cast( com_ptr< ::IUnknown >(pUnkSink) ); + } + catch (...) { + return CONNECT_E_CANNOTCONNECT; + } + *pdwCookie = next_cookie_++; + return S_OK; + } + STDMETHOD(Unadvise)(DWORD dwCookie) + { + CONNECTIONS::iterator it = connections_.find(dwCookie); + if (it == connections_.end()) return CONNECT_E_NOCONNECTION; + connections_.erase(it); + return S_OK; + } + + STDMETHOD(EnumConnections)(IEnumConnections** ppEnum) + { + try { + *ppEnum = com_ptr::detach( stl_enumeration::create(connections_, get_unknown()) ); + } catch (...) { + return E_FAIL; + } + return S_OK; + } + //@} + + typedef std::map > CONNECTIONS; + CONNECTIONS connections_; + private: + UINT next_cookie_; + }; + + /** \class sink_impl cp.h comet/cp.h + * Implement a sink for a connection pointer. + * \param Itf interface to implement. + */ + template class ATL_NO_VTABLE sink_impl : public static_object + { + public: + /** Advise this object as sinking connections from \p t. + */ + void advise(const com_ptr< ::IUnknown>& t) + { + if (ptr_) throw std::runtime_error("Cannot double advise."); + com_ptr cpc( try_cast(t) ); + IConnectionPoint* cp; + cpc->FindConnectionPoint( uuidof(), &cp) | raise_exception; + + HRESULT hr = cp->Advise(static_cast< ::IUnknown* >(static_cast(this)), &cookie_); + + cp->Release(); + + hr | raise_exception; + + ptr_ = t; + } + + /** Unadvise this interface from object \p t. + */ + void unadvise() + { + if (ptr_) { + com_ptr cpc( try_cast(ptr_) ); + IConnectionPoint* cp; + cpc->FindConnectionPoint( uuidof(), &cp) | raise_exception; + + HRESULT hr = cp->Unadvise(cookie_); + cookie_ = 0; + ptr_ = 0; + + cp->Release(); + + hr | raise_exception; + } + } + + /** Get event object. + */ + com_ptr< ::IUnknown> object() + { + return ptr_; + } + + /** Return true if advised. + */ + bool is_advised() + { + return !ptr_.is_null(); + } + + protected: + sink_impl() : cookie_(0) {} + ~sink_impl() { unadvise(); } + private: + DWORD cookie_; + com_ptr< ::IUnknown> ptr_; + }; + //@} + +} + +#pragma warning( pop ) + +#endif diff --git a/EyeTab_SP2/comet/cptraits.h b/EyeTab_SP2/comet/cptraits.h new file mode 100644 index 0000000..539b4e8 --- /dev/null +++ b/EyeTab_SP2/comet/cptraits.h @@ -0,0 +1,118 @@ +/** \file + * Connection-point traits. + */ + +/* Copyright © 2002 Michael Geddes + * Copyright © 2013 Alexander Lamaison + * + * This material is provided "as is", with absolutely no warranty + * expressed or implied. Any use is at your own risk. Permission to + * use or copy this software for any purpose is hereby granted without + * fee, provided the above notices are retained on all copies. + * Permission to modify the code and to distribute modified code is + * granted, provided the above notices are retained, and a notice that + * the code was modified is included with the above copyright notice. + * + * This header is part of Comet version 2. + * https://github.com/alamaison/comet + */ + +#ifndef INCLUDE_COMET_CPTRAITS_H +#define INCLUDE_COMET_CPTRAITS_H + +#ifdef _SHOW_INC +#pragma message(" #Include " __FILE__) +#endif + +#include +#include // raise_exception + +#include // HRESULT + +namespace comet +{ + /*! \struct cp_throw cptraits.h comet/cptraits.h + * Default 'throw' traits for connection-points. + * \code Usage + * connection_point_for::connection_point.Fire_MyEvent( arg1, comet::cp_throw()); + * \endcode + */ + struct cp_throw + { + + /// Constructor - called before iterating over the connection-points. + cp_throw() : _hr_(S_OK) { } + + /// Destructor - called after iterating over all the connection-points. + ~cp_throw() { _hr_ | raise_exception ; } + + /*! Called when a connection point fails. + * Can also be used to remember the hresult for the destructor. + * + * \retval true Cause the on_fail method to be called. + * \retval false Ignore the failure. + */ + bool check_fail(HRESULT hr) + { + if( FAILED(hr) ) + _hr_ = hr; + return false; + } + + /*! Called when check_fail returns true. + * \param par_connects Reference to the STL container containing the connection-points. + * \param par_it The iterator of the failed connection-point. + */ + template + static bool on_fail(CONNECTIONS &par_connects, const typename CONNECTIONS::iterator & par_it) + { + COMET_NOTUSED(par_it); + COMET_NOTUSED(par_connects); + return false; + } + + protected: + HRESULT _hr_; + + }; + + /*! \struct cp_nothrow_remove cptraits.h comet/cptraits.h + * Traits for connection-points, errors cause the connection-point to auto-remove. + * \code + * connection_point_for::connection_point.Fire_MyEvent( arg1, comet::cp_nothrow_remove()); + * \endcode + * \sa cp_throw + */ + struct cp_nothrow_remove + { + //! Called when a connection point fails. + bool check_fail( HRESULT _hr_) throw() { return FAILED(_hr_); } + + //! Called when check_fail returns true. + template + static bool on_fail(CONNECTIONS &par_connects, const typename CONNECTIONS::iterator &par_it ) throw() + { + try{ par_connects.erase(par_it); }catch(...) {} + return false; + } + }; + + + /*! \struct cp_nothrow cptraits.h comet/cptraits.h + * Tratis for connection-points, errors are ignored. + * \code + * connection_point_for::connection_point.Fire_MyEvent( arg1, comet::cp_nothrow()); + * \endcode + * \sa cp_throw + */ + struct cp_nothrow + { + //! Called when a connection point fails. + bool check_fail( HRESULT _hr_) throw() { return FAILED(_hr_); } + + //! Called when check_fail returns true. + template + static bool on_fail(CONNECTIONS &par_connects, const typename CONNECTIONS::iterator &par_it ) throw() { return false; } + }; +} +#endif /* INCLUDE_COMET_CPTRAITS_H */ diff --git a/EyeTab_SP2/comet/currency.h b/EyeTab_SP2/comet/currency.h new file mode 100644 index 0000000..567f93d --- /dev/null +++ b/EyeTab_SP2/comet/currency.h @@ -0,0 +1,474 @@ +/** \file + * Currency wrapper. + */ +/* Copyright © 2001 Michael Geddes, Sofus Mortensen + * + * This material is provided "as is", with absolutely no warranty + * expressed or implied. Any use is at your own risk. Permission to + * use or copy this software for any purpose is hereby granted without + * fee, provided the above notices are retained on all copies. + * Permission to modify the code and to distribute modified code is + * granted, provided the above notices are retained, and a notice that + * the code was modified is included with the above copyright notice. + * + * This header is part of Comet version 2. + * https://github.com/alamaison/comet + */ + +#ifndef COMET_CURRENCY_H +#define COMET_CURRENCY_H + +#include + +#include +#include + +#include + +#include +#include + +namespace comet +{ + + class bstr_t; + + // currency_t + /////////////// + + /*! \addtogroup COMType + */ + //@{ + + /** Wrapper for CURRENCY type. + * CURRENCY is a fixed point (to 4 decimal places) 64 bit value. + */ + + class currency_t + { + public: + /// Default Constructor + currency_t() throw() { cy_.int64 = 0; } + + /// CY constructor. + currency_t(const CY &cy): cy_(cy) { } + + /// Double Conversion constructor. + explicit currency_t(double val) + { + VarCyFromR8(val,&cy_) | raise_exception; + } + +#if 0 +// //! Construct currency from CY/CURRENCY. +// /*! +// Takes ownership of specified CY value. To prevent misuse the CY must be wrapped using auto_attach. +// +// \code +// currency_t cy( auto_attach( myCY ) ); +// \endcode +// +// \param cyVal +// Value to initialise currency_t from. +// */ +// currency_t( const impl::auto_attach_t &cyVal) throw() : cy_(cyVal.get()) +// {} +#endif //0 + + /// Long Conversion constructor. + currency_t( long val ) + { + VarCyFromI4(val,&cy_) | raise_exception; + } + + currency_t( int val ) + { + VarCyFromI4(val,&cy_) | raise_exception; + } + + void swap(currency_t& c) throw() + { + std::swap(cy_, c.cy_); + } + + static const currency_t& create_const_reference(const CY& s) throw() + { return *reinterpret_cast(&s); } + + static currency_t& create_reference(CY& s) throw() + { return *reinterpret_cast(&s); } + + //! \name Assignment Operators + //@{ + currency_t &operator=(double newVal) + { + currency_t c( newVal ); + swap(c); + return *this; + } + currency_t &operator=(long newVal) + { + currency_t c( newVal ); + swap(c); + return *this; + } + currency_t &operator=(int newVal) + { + currency_t c( newVal ); + swap(c); + return *this; + } + currency_t &operator=(const tagCY &newVal) throw() + { + cy_ = newVal; + return *this; + } + //@} + + /// \name Mathematical Operators + //@{ + currency_t &operator+=(const currency_t &cy) + { + currency_t c( *this + cy ); + swap(c); + return *this; + } + currency_t &operator-=(const currency_t &cy) + { + currency_t c( *this - cy ); + swap(c); + return *this; + } + currency_t &operator*=(const currency_t &cy) + { + currency_t c( *this * cy ); + swap(c); + return *this; + } + currency_t &operator*=(long cy) + { + currency_t c( *this * cy ); + swap(c); + return *this; + } + currency_t &operator*=(int val) + { + return operator*=((long)val); + } + currency_t &operator*=(double val) + { + cy_.int64 = (LONGLONG)(cy_.int64 * val); + return *this; + } + + currency_t &operator/=(int val) const + { + return operator/=((long)val); + } + currency_t &operator/=(long val) + { + + if(!valid()) + { + // Check for invalid number + return *this; + } + + // Check for divide by 0 + if (val == 0) + { + // Set to maximum negative value + cy_.Hi = 0x80000000; + cy_.Lo = 0x00000000; + + return *this; + } + cy_.int64/=val; + + return *this; + } + + currency_t operator+(const currency_t &cy)const + { + currency_t rv; + VarCyAdd(cy_,cy.cy_,&rv.cy_) | raise_exception ; + return rv; + } + currency_t operator-(const currency_t &cy)const + { + currency_t rv; + VarCySub(cy_,cy.cy_,&rv.cy_) | raise_exception ; + return rv; + } + currency_t operator*(const currency_t &cy)const + { + currency_t rv; + VarCyMul(cy_,cy.cy_,&rv.cy_) | raise_exception ; + return rv; + } + currency_t operator*(long cy)const + { + currency_t rv; + VarCyMulI4(cy_,cy,&rv.cy_) | raise_exception; + return rv; + } + currency_t operator*(int cy)const + { + return operator *((long)cy); + } + + currency_t operator*(double cy) const + { + currency_t val(*this); + val *=cy; + return val; + } + + + /// Calculate approximate ratio. + double operator/(const currency_t &cy)const + { + return ((double)cy_.int64 /(double)cy.cy_.int64); + } + + /// Divide by int. + currency_t operator/(int val) const + { + return operator/((long)val); + } + /// Divide by long. + currency_t operator/(long val) const + { + currency_t tmp(cy_); + tmp/=val; + return tmp; + } + + /// Divide by double + double operator/(double val) const + { + if(!valid()) + { + // Check for invalid number + throw std::invalid_argument("Invalid divide"); + } + + // Check for divide by 0 + if (val == 0) + { + throw std::overflow_error("Divide by 0"); + } + return cy_.int64/(val*10000); + } + + /// Unary negate. + currency_t operator-()const + { + currency_t cy; + VarCyNeg(cy_,&(cy.cy_)) | raise_exception; + return cy; + } + + //@} + + /** Rounds the value to specified number of decimal places. + * \param decimals Number of places to round to. + */ + currency_t &round_to(int decimals) + { + VarCyRound(cy_,decimals,&cy_) | raise_exception; + return *this; + } + + /// \name Logical Operators + //@{ + + bool operator!=(const currency_t &cy) const { return cmp(cy)!=0; } + bool operator!=(double val) const{ return cmp(val)!=0; } + bool operator==(const currency_t &cy) const { return cmp(cy)==0; } + bool operator==(double val) const{ return cmp(val)==0; } + bool operator<=(const currency_t &cy) const{ return cmp(cy)<=0; } + bool operator<=(double val) const{ return cmp(val)<=0; } + bool operator>=(const currency_t &cy) const{ return cmp(cy)>=0; } + bool operator>=(double val) const{ return cmp(val)>=0; } + bool operator<(const currency_t &cy) const{ return cmp(cy)<0; } + bool operator<(double val) const{ return cmp(val)<0; } + bool operator>(const currency_t &cy) const{ return cmp(cy)>0; } + bool operator>(double val) const{ return cmp(val)>0; } + + //@} + + /** Compares the value like strcmp. + * \param cy Number to be compared. + */ + int cmp(const currency_t &cy) const + { + return _cmpResult(VarCyCmp(cy_,cy.cy_)); + + } + + /** Compares the value like strcmp. + * \param cy Number to be compared. + */ + int cmp(double cy) const + { + return _cmpResult(VarCyCmpR8(cy_,cy)); + } + + + //! \name Access converters + //@{ + tagCY get() const { return cy_;} + tagCY in() const { return cy_;} + tagCY *in_ptr() const { return const_cast(&cy_);} + tagCY *out() { return &cy_;} + tagCY *inout() { return &cy_;} + //@} + + +#if 0 + friend std::ostream &operator <<(std::ostream &str, const currency_t &val) + { + std::string strval=val.format( 1, str.precision(), str.width() ); + return str<< strval.c_str(); + } +#endif + + + + friend + std::basic_ostream &operator<<(std::basic_ostream &str, const currency_t &val) + { + std::basic_string strval; + val.do_format(strval, 1, str.precision(), str.width() ); + return str << strval.c_str(); + } + + friend + std::basic_ostream &operator<<(std::basic_ostream &str, const currency_t &val) + { + std::basic_string strval; + val.do_format(strval, 1, str.precision(), str.width() ); + return str << strval.c_str(); + } + + //! Format the string with the given digits, precision and width. + std::basic_string format( + std::streamsize mindigits=0, std::streamsize minprecision=0, + std::streamsize width=0) const + { + std::basic_string strval; + do_format(strval, mindigits, minprecision, width); + return strval; + } + + //! Parse the string to a currency. + currency_t &parse( const bstr_t &str, LCID locale =::GetThreadLocale() ); +/* { + VarCyFromStr( str.in(), locale, 0, &cy_ ) | raise_exception; + return *this; + }*/ + + protected: + /** Return a string representation of the value. + * \param val output string (return values can't automatically detect template arguments) + * \param mindigits Minimum number before decimal point. + * \param minprecision Minimum number after decimal point. + * \todo Obey ostream formats for: fillchar(), ios_base::left, ios_base::internal, ios_base::showpos + */ + template + void do_format( + std::basic_string& val, std::streamsize mindigits, + std::streamsize minprecision, std::streamsize /*width*/) const + { + COMET_ASSERT(mindigits>=0 && minprecision >=0 ); + if(minprecision> 4) minprecision =4; + + // Add in the 4 fixed decimal points + std::streamsize pr = + ((0 <= minprecision && minprecision <=4) ? + (4-minprecision) : 0); + mindigits+=4; + + val.erase(); + val.reserve(22); + LONGLONG value=cy_.int64; + bool neg=value<0; + if(neg) + { + value=-value; + } + // Put in the digits backwards + std::streamsize digit=0; + bool output=false; + while(value !=0 || digit < mindigits) + { + CH dig=CH(value%10); + if(output || true==(output= (dig >0 || digit>=pr))) // Once 'output' is set - output everything. + { + val+=(CH('0'+dig)); + } + if(++digit == 4) + { + val+=CH('.'); + output=true; + } + value/=10; + } + if(neg) + { + val+=CH('-'); + } + + // Now reverse the digits + std::reverse(val.begin(), val.end()); + } + public: + + /// Returns true if this is a valid number + bool valid() const throw() + { return !(cy_.Hi==(long)0x80000000 && cy_.Lo==0);} + + /// Detaches the CY value. Provided for consistancy. + CY detach() throw() + { + CY val = cy_; + cy_.int64 = 0; + return val; + } + + /// Detaches the CY value. Provided for consistancy. + static CY detach(currency_t& cy) throw() + { + return cy.detach(); + } + + private: + CY cy_; + + static int _cmpResult(HRESULT hr) + { + if(SUCCEEDED(hr)) + { + switch(hr) + { + case VARCMP_LT: + return -1; + case VARCMP_EQ : + return 0; + case VARCMP_GT: + return 1; + case VARCMP_NULL: + COMET_ASSERT(!"What do we do with this?"); + } + } + else + { + hr | raise_exception; + } + return 0; // shut the compiler up + } + }; + //@} +} + +#endif // COMET_CURRENCY_H diff --git a/EyeTab_SP2/comet/date.h b/EyeTab_SP2/comet/date.h new file mode 100644 index 0000000..e577cac --- /dev/null +++ b/EyeTab_SP2/comet/date.h @@ -0,0 +1,396 @@ +/** \file + * Date wrapper (part of datetime). + */ +/* +* Copyright © 2004 Michael Geddes +* +* This material is provided "as is", with absolutely no warranty +* expressed or implied. Any use is at your own risk. Permission to +* use or copy this software for any purpose is hereby granted without +* fee, provided the above notices are retained on all copies. +* Permission to modify the code and to distribute modified code is +* granted, provided the above notices are retained, and a notice that +* the code was modified is included with the above copyright notice. +* +* This header is part of Comet version 2. +* https://github.com/alamaison/comet +*/ + +#ifndef INCLUDE_COMET_DATE_H +#define INCLUDE_COMET_DATE_H + +#ifdef _SHOW_INC +#pragma message(" #Include " __FILE__) +#endif +#include + +namespace comet +{ + /*! \addtogroup Misc + */ + //@{ + + //! Wrapper for a date only class. + /**This is based on an integer version of DATE, except that it is an + * absolute offset from 1/1/0. + */ + struct dateonly_t : protected impl::datetime_base + { + + /// constructor + dateonly_t() { dt_ = 0; } + + /// Construct from a datetime_t. + explicit dateonly_t( const datetime_t &dt) + { + if (dt == dt_invalid ) + dt_ = dt_invalid_; + else if (dt == dt_null) + dt_ = dt_null_; + else + dt_ = split_oledate_as_absdate_( dt.get()); + } + + /// Attach from a long. + dateonly_t( const impl::auto_attach_t &dateval) + { + dt_ = dateval.get(); + } + + /// Get the raw 'long' value. + long get() const { return dt_; } + dateonly_t &operator=(const impl::auto_attach_t & dateval) + { + dt_ = dateval.get(); + return *this; + } + + /// Initialise as invalid. + dateonly_t( dt_invalid_t ) { dt_ = dt_invalid_; } + /// Initialise as null. + dateonly_t( dt_null_t ) { dt_ = dt_null_; } + /// Initialise as zero. + dateonly_t( dt_zero_t) { dt_ = 0; } + + + /// Construct from year/month/day. + dateonly_t( int year, int month, int day ) + { + if (!absdate_from_date_( &dt_, year, month, day)) + set_invalid_(); + } + + /// Get a 'NULL' datetime. + static dateonly_t get_null() { return dateonly_t( dt_null_ ); } + /// Get a 'zero' datetime. + static dateonly_t get_zero() { return dateonly_t( 0 ); } + + /// Return today. + static dateonly_t today() + { + return dateonly_t(datetime_t::now()); + } + /// Return today (UTC). + static dateonly_t today_utc() + { + return dateonly_t(datetime_t::now_utc()); + } + + /// Return year/month/day values. + void split(int *year, int *month, int *day) const + { + if(!good() || ! date_from_absdate_( dt_, year, month, day)) + throw datetime_exception("Invalid Date"); + } + + /** Set date part as year/month/day. + * \param year Year (from year 0 - as in 2000). + * \param month Month of year (1-based). + * \param day Day of month (1-based). + * \retval true Successfully set date. + * \retval false Conversion unsuccessful - date not set. + */ + bool set_date( int year, int month, int day) + { + return absdate_from_date_( &dt_, year, month, day); + } + + /// Convert to datetime. + operator datetime_t() const + { + if (!good()) return datetime_t((DATE)dt_); + return datetime_t(join_absdate_as_oledate_( dt_, 0)); + } + + /// \name Access date parts. + //@{ + /// Year. + int year() const + { + int year; + split(&year,NULL,NULL); + return year; + } + /// Month of year (1-based) + int month() const + { + int year,month,day; + split(&year,&month,&day); + return month; + } + /// Day of month (1-based) + int day() const + { + int year,month,day; + split(&year,&month,&day); + return day; + } + /// The day of week. + datetime_t::day_of_week dow() const + { + int wday; + if(!good() || ! dow_from_absdate_( dt_, &wday)) + throw datetime_exception("Invalid Date"); + return datetime_t::day_of_week(wday); + } + /// Day of the year (0 -based) + int year_day() const + { + if (good()) + { + int y,m,d; + date_from_absdate_(dt_, &y,&m,&d); + long firstday; + if ( absdate_from_date_(&firstday, y, 1, 1)) + return 1 + ( dt_ - firstday); + } + throw datetime_exception("Invalid Date"); + } + /// Days in the month. + int days_in_month() const + { + int year,month,day; + split(&year,&month,&day); + return days_in_month(year,month); + } + + //@} + + /** Add specified number of months. + * If the day is not valid, force to the last day in the month. + */ + dateonly_t &add_months(int inc_months) + { + int year,month,day; + split(&year,&month,&day); + long months = (month-1)+(year*12)+inc_months; + + long quot,rem; + quot = months/12; + rem = months%12; + set_date( quot, rem+1, day); + return *this; + } + + /// Add specified number of years. + dateonly_t &add_years(int inc_years) + { + int year,month,day; + split(&year,&month,&day); + set_date( year+inc_years, month, day); + return *this; + } + + ///\name Comparison operators + //@{ + bool operator==(const dateonly_t& date) const { return date.dt_ == dt_; } + bool operator!=(const dateonly_t& date) const{ return date.dt_ != dt_; } + bool operator<(const dateonly_t& date) const + { + COMET_ASSERT( good() ); + COMET_ASSERT( date.good() ); + return dt_ < date.dt_; + } + bool operator>(const dateonly_t& date) const + { + COMET_ASSERT( good() ); + COMET_ASSERT( date.good() ); + return dt_ > date.dt_; + } + bool operator<=(const dateonly_t& date) const + { + COMET_ASSERT( good() ); + COMET_ASSERT( date.good() ); + return dt_ <= date.dt_; + } + bool operator>=(const dateonly_t& date) const + { + COMET_ASSERT( good() ); + COMET_ASSERT( date.good() ); + return dt_ >= date.dt_; + } + bool operator==(dt_invalid_t) const { return invalid(); } + bool operator!=(dt_invalid_t) const { return !invalid(); } + bool operator==(dt_zero_t) const { return dt_==0; } + bool operator!=(dt_zero_t) const { return dt_!=0; } + bool operator==(dt_null_t) const { return null(); } + bool operator!=(dt_null_t) const { return !null(); } + //@} + + ///\name Arithmetic operators + //@{ + dateonly_t operator+(long dateSpan) const + { + dateonly_t dt(*this); + dt+=dateSpan; + return dt; + } + dateonly_t operator-(long dateSpan) const + { + dateonly_t dt(*this); + dt-=dateSpan; + return dt; + } + dateonly_t& operator+=(long dateSpan) + { + COMET_ASSERT( good() ); + dt_ += dateSpan; + return *this; + } + dateonly_t& operator-=(long dateSpan) + { + COMET_ASSERT( good() ); + dt_ -= dateSpan; + return *this; + } + long operator-(const dateonly_t& date) const + { + COMET_ASSERT( good() ); + COMET_ASSERT( date.good() ); + return dt_ - date.dt_; + } + dateonly_t &operator++() + { + COMET_ASSERT( good() ); + ++dt_; + return *this; + } + dateonly_t operator++(int) + { + COMET_ASSERT( good() ); + dateonly_t t(*this); + ++dt_; + return t; + } + dateonly_t &operator--() + { + COMET_ASSERT( good() ); + --dt_; + return *this; + } + dateonly_t operator--(int) + { + COMET_ASSERT( good() ); + dateonly_t t(*this); + --dt_; + return t; + } + //@} + + /// return true if the date is marked 'invalid'. + inline bool invalid() const { return dt_ == ( dt_invalid_); } + /// Return true if the date is marked 'null' + inline bool null() const { return dt_ == ( dt_null_); } + + /// return true if date is zero + inline bool zero() const { return dt_ == 0; } + + /// Return true if the date is usable. + inline bool good() const + { + switch (dt_) + { + case 0: case dt_invalid_: case dt_null_: return false; + default: return true; + } + } + + /** Format as bstr. + * \param flags Format (can be or-ed). All format_flags are valid. + * \param locale Locale ID (default to User Default. + */ + bstr_t format( datetime_t::format_flags flags = datetime_t::ff_default , LCID locale = LOCALE_USER_DEFAULT) const + { + flags = datetime_t::format_flags((flags | datetime_t::ff_date_only) & ~datetime_t::ff_time_only); + bstr_t strDate; + if (null() || invalid()) + return strDate; + + DATE dt = join_absdate_as_oledate_( dt_, 0); + VarBstrFromDate(dt, locale, flags, strDate.out()) | raise_exception; + return strDate; + } + + /** Parse bstring to a datetime_t. + * \param val String to parse. + * \param flags valid format_flags are: ff_default, ff_system_locale, ff_hijri, ff_time_only, ff_date_only + * \param locale Locale to use. Default \p locale is the user default. + */ + dateonly_t &parse( const bstr_t &val, datetime_t::format_flags flags = datetime_t::ff_default, LCID locale = LOCALE_USER_DEFAULT) + { + flags = datetime_t::format_flags((flags | datetime_t::ff_date_only) & ~datetime_t::ff_time_only); + DATE dt; + VarDateFromStr( val.in(), locale, flags, &dt) | raise_exception; + dt_ = split_oledate_as_absdate_( dt); + + return *this; + } + + /** Format as basic_string. + * \param fmt See system documentation for strftime for details. + */ + template + std::basic_string format( const std::basic_string &fmt ) const + { + return format(fmt.c_str()); + } + + /** Format as basic_string. + * \param fmt See system documentation for strftime for details. + */ + template + std::basic_string format( const CHAR *fmt ) const + { + // Just use datetime_t to handle this. + datetime_t dt(*this); + return dt.format(fmt); + } + + /// Stream operator. + friend + std::basic_ostream &operator<<(std::basic_ostream &os, const dateonly_t &val) + { + os << val.format(); + return os; + } + + /// Stream operator. + friend + std::basic_ostream &operator<<(std::basic_ostream &os, const dateonly_t &val) + { + os << val.format(); + return os; + } + + static inline int days_in_month(int year, int month) + { + return impl::datetime_base::days_in_month(year,month); + } + + protected: + explicit dateonly_t(long l) { dt_ = l; } + }; + //@} +}; + +#endif /* INCLUDE_COMET_DATE_H */ diff --git a/EyeTab_SP2/comet/datetime.h b/EyeTab_SP2/comet/datetime.h new file mode 100644 index 0000000..351a9d1 --- /dev/null +++ b/EyeTab_SP2/comet/datetime.h @@ -0,0 +1,1943 @@ +/** \file + * Wrappers for DATE. + */ + +/* Copyright © 2001 Michael Geddes + * + * This class was originally based on ATL/MFC code, however the original + * implementations have almost entirely been replaced with more efficient code. + * The core date algorithms are from boost. + * + * This material is provided "as is", with absolutely no warranty + * expressed or implied. Any use is at your own risk. Permission to + * use or copy this software for any purpose is hereby granted without + * fee, provided the above notices are retained on all copies. + * Permission to modify the code and to distribute modified code is + * granted, provided the above notices are retained, and a notice that + * the code was modified is included with the above copyright notice. + * + * This header is part of Comet version 2. + * https://github.com/alamaison/comet + */ +#ifndef COMET_DATETIME_H +#define COMET_DATETIME_H + +#include +#include +#include + +#include +#include + +// The Platform SDK does not define VAR_FOURDIGITYEARS +#ifndef VAR_FOURDIGITYEARS +#define VAR_FOURDIGITYEARS ((DWORD)0x00000040) +#endif + +namespace comet +{ + +#define COMET_DIVMOD_( quot,rem, val1, val2) quot = (val1)/(val2); rem = (val1)%(val2); + + +/*! \addtogroup ErrorHandling + */ +//@{ +//! Exception for datetimes. +class datetime_exception : public std::exception +{ +public: + datetime_exception( const char *desc) : desc_(desc) + {} + + const char* what() const throw() + { + return desc_.c_str(); + } + +private: + std::string desc_; +}; + +//@} + +/*! \addtogroup COMType + */ +//@{ +/// Initialise date/time value as invalid. +static struct dt_invalid_t {} dt_invalid; +/// Initialise date/time value as null. +static struct dt_null_t {} dt_null; +/// Initialise date/time value as zero. +static struct dt_zero_t { + operator double() const { return 0.;} + operator long() const { return 0;} +} dt_zero; + +// timeperiod_t +///////////////// + +/** \class timeperiod_t datetime.h comet/datetime.h + * Time-period. Used with datetime_t math. + */ +class timeperiod_t +{ + enum { + dt_invalid_ = 2147483647L, + }; + /// Days. + double pd_; +public: + /// Default Constructor. + timeperiod_t() : pd_(0.){} + + /// Construct invalid + timeperiod_t( dt_invalid_t ) : pd_(dt_invalid_) {} + /// Construct zero + timeperiod_t( dt_zero_t) : pd_(0.) {} + + timeperiod_t( double period) :pd_(period){} + timeperiod_t( float period) :pd_(period){} + timeperiod_t( long period) :pd_(period){} + timeperiod_t( int period) :pd_(period){} + timeperiod_t( short period) :pd_(period){} + timeperiod_t( unsigned long period) :pd_(period){} + timeperiod_t( unsigned int period) :pd_(period){} + timeperiod_t( unsigned short period) :pd_(period){} + + timeperiod_t( long days, long hours) + : pd_(days + hours/24){} + timeperiod_t( long days, long hours, long minutes) + : pd_(days + (hours*60+minutes)/(24.*60.)){} + timeperiod_t( long days, long hours, long minutes, long seconds, long milliseconds=0 ) + : pd_(days + ((hours*3600000L) + (minutes*60000L)+ (seconds*1000L)+ milliseconds)/86400000.){} + + /// \name Assignment operators + //@{ + timeperiod_t &operator =( const double &period){pd_=period; return *this;} + timeperiod_t &operator =( float period){pd_=period; return *this;} + timeperiod_t &operator =( long period){pd_=period; return *this;} + timeperiod_t &operator =( int period){pd_=period; return *this;} + timeperiod_t &operator =( short period){pd_=period; return *this;} + //@} + + /// Return time-period as a double (days). + operator double() const{return pd_;} + + /// \name Comparison operators. + //@{ + bool operator ==(const timeperiod_t &prd) const { return pd_ == prd.pd_; } + bool operator !=(const timeperiod_t &prd) const { return pd_ != prd.pd_; } + bool operator < (const timeperiod_t &prd) const { return pd_ < prd.pd_; } + bool operator > (const timeperiod_t &prd) const { return pd_ > prd.pd_; } + bool operator <=(const timeperiod_t &prd) const { return pd_ <= prd.pd_; } + bool operator >=(const timeperiod_t &prd) const { return pd_ >= prd.pd_; } + bool operator ==(dt_invalid_t) const { return pd_ == dt_invalid_; } + bool operator !=(dt_invalid_t) const { return pd_ != dt_invalid_; } + + // These shouldn't be needed. + template bool operator < (T prd) const { return pd_ < double(prd); } + template bool operator <= (T prd) const { return pd_ <= double(prd); } + template bool operator > (T prd) const { return pd_ > double(prd); } + template bool operator >= (T prd) const { return pd_ >= double(prd); } + template bool operator == (T prd) const { return pd_ == double(prd); } + template bool operator != (T prd) const { return pd_ != double(prd); } + + //@} + /// \name Simple math operators. + //@{ + timeperiod_t operator+(const timeperiod_t &prd) const { return pd_ + prd.pd_; } + timeperiod_t operator-(const timeperiod_t &prd) const { return pd_ - prd.pd_; } + timeperiod_t &operator+=(const timeperiod_t &prd) { pd_ += prd.pd_; return *this; } + timeperiod_t &operator-=(const timeperiod_t &prd) { pd_ -= prd.pd_; return *this; } + timeperiod_t operator-() const { return -pd_; } + //@} + + /// \name Conversion functions + //@{ + double as_days() { return pd_; } + void as_days(double prd) { pd_=prd; } + double as_hours() { return pd_*24; } + void as_hours(double prd) { pd_= prd/24; } + double as_minutes() { return pd_*24*60; } + void as_minutes(double prd) { pd_= prd/(24*60); } + double as_seconds() { return pd_*24*60*60; } + void as_seconds(double prd) { pd_= prd/(24*60*60); } + //@} + + /// Split up the time period into days/hours/minutes/seconds. + /** Backwards compatible. + * \deprecated + */ + void split( long& days, long& hours, long& minutes, long& seconds ) + { + split(&days,&hours,&minutes,&seconds); + } + /// Split up the time period into days/hours/minutes/seconds. + void split( long *days, long *hours, long *minutes, long *seconds, long *milliseconds = 0) + { + // Split into days and milliseconds. + double int_part; + long mspart = long(modf(pd_, &int_part) * 86400000); + *days = long(int_part); + // Optimise for integer. + if (mspart == 0 ) + { + *days = *hours = *minutes = *seconds = 0; + if (milliseconds!=NULL) *milliseconds =0; + return; + } + // Split up parts. + long ms, quot, quot2; + COMET_DIVMOD_(quot, ms, mspart, 1000); + COMET_DIVMOD_(quot2, *seconds, quot, 60); + COMET_DIVMOD_( *hours, *minutes, quot2, 60); + if( milliseconds != NULL) + *milliseconds = ms; + } + + /// Set as days/hours/minutes/seconds. + void set_period( long days, long hours, long minutes, long seconds, long milliseconds=0 ) + { + pd_ = days + ((hours*3600000L) + (minutes*60000L)+ (seconds*1000L)+ milliseconds)/86400000.; + } + + /// Return true if the period is invalid. + bool invalid() const + { + return pd_ == (double)(dt_invalid_); + } + /// Return true if the period is not invalid. + bool good() const + { + return !invalid(); + } + /** return true if the period is valid. + * \deprecated + */ + bool valid() const { return !invalid(); } + + /// Return an invalid period. + static timeperiod_t invalid_period() { return timeperiod_t( (double)(dt_invalid_)); } + +}; + + +/// A wrapper for choosing strftime/wcsftime based on char type. +template< typename CHAR > +inline size_t str_formattime( CHAR *strDest, size_t maxsize, const CHAR *format, const struct tm *timeptr ) +{ + return -1; +} +/// @if Internal +template<> +inline size_t str_formattime( char *strDest, size_t maxsize, const char *format, const struct tm *timeptr ) +{ + return strftime( strDest, maxsize, format, timeptr ); +} + +template<> +inline size_t str_formattime( wchar_t *strDest, size_t maxsize, const wchar_t *format, const struct tm *timeptr ) +{ + return wcsftime( strDest, maxsize, format, timeptr ); +} + +namespace impl { +// Internally used to group div/mod so optimiser is likely to pick it up. + + const double half_millisecond = 1.0/172800000.0; + + template + struct datetime_base + { + T dt_; + + enum convert_mode { + cmBoth, + cmOnlyTime, + cmOnlyDate + }; + + + /*! Convert absolute date to date-parts. + */ + static bool date_from_absdate_( long daysAbsolute, int *tm_year, int *tm_mon, int *tm_mday ); + + /*! Convert absolute date to day-of-week. + */ + static bool dow_from_absdate_( long daysAbsolute, int *tm_wday) + { + // Calculate the day of week (sun=0, mon=1...) + // -1 because 1/1/0 is Sat. + *tm_wday = (int)((daysAbsolute + 1) % 7L); + return true; + } + + /*! Convert date parts to absolute date. + */ + static bool absdate_from_date_( long *daysAbsolute, int tm_year, int tm_mon, int tm_mday); + + /*! Convert time in milliseconds to time of day parts. + */ + static bool time_from_milliseconds_( long milliseconds, int *tm_hour, int *tm_min, int *tm_sec, int *tm_ms); + /*! Convert time-of-day parts to milliseconds. + */ + static bool milliseconds_from_time_( long *milliseconds, unsigned short tm_hour, unsigned short tm_min, unsigned short tm_sec, unsigned short tm_ms); + + /*! Convert ole date to datetime-parts. + */ + static bool datetime_from_oledate_( DATE date, int *tm_year, int *tm_mon, int *tm_mday, int *tm_dow, int *tm_hour, int *tm_min, int *tm_sec, int *tm_ms, convert_mode mode); + + /*! Get date part of oledate. + */ + static inline long split_oledate_as_absdate_( DATE date ) + { + double val = to_double(date)+ (693959 + 1721060) + half_millisecond; // Add days from 1/1/0 to 12/30/1899 + return long(floor(val)); + } + /*! Split oledate into date/milliseconds. + */ + static inline long split_oledate_as_absdate_( DATE date, long *ms_part,bool need_ms_part ) + { + double val = to_double(date)+ (693959 + 1721060) + half_millisecond; // Add days from 1/1/0 to 12/30/1899 + if (!need_ms_part) return long(floor(val)); + *ms_part = long(modf(val, &val) * 86400000); + return long(val); + } + + /*! Join oledate. + */ + static inline DATE join_absdate_as_oledate_( long absDate, long ms_part) + { + return to_date( (double(absDate) + (ms_part / 86400000.)) - 693959 - 1721060 ); + } + + + /*! Convert datetime-parts to ole date. + */ + static bool oledate_from_datetime_( DATE *date, unsigned short tm_year, unsigned short tm_mon, unsigned short tm_mday, unsigned short tm_hour, unsigned short tm_min, unsigned short tm_sec, unsigned short tm_ms, convert_mode mode); + + /*! Convert TM to OLE date. + * Sets the date to invalid if unsuccessful. + * \retval true Successful conversion. + */ + static bool from_tm_( const struct tm &src, DATE *dt, convert_mode mode); + + /*! Convert OLE date to TM. + * \retval true Successful conversion. + */ + static bool to_tm_( DATE dt, struct tm *dest, int *ms); + + void set_invalid_() { dt_ = ((T) dt_invalid_); } + void set_null_() { dt_ = ((T) dt_null_); } + + /// Convert offset from 0 to DATE type. + static DATE to_date( double dbl) + { + if(dbl>0) return dbl; + double t=floor(dbl); + return t+(t-dbl); + } + /// Convert DATE type to offset from 0. + static double to_double( DATE dt) + { + if(dt>=0) return dt; + double t = ceil(dt); + return t-(dt-t); + } + + /// Set to value \a dt and check the range. + bool set_check_range_( T dt) + { + bool result = (dt <= dt_max && dt >= dt_min); + if (result) + dt_ = dt; + return result; + } + /// Set the value to \a dt and set 'invalid' if out of range. + void set_invalid_check_range_(T dt) + { + if (!set_check_range_(dt) ) + set_invalid_(); + } + + /// Return true if \a year is a leap-year. + static bool is_leap_year( long year) + { + if ((year & 0x3) != 0) return false; + // && ((year % 100) != 0 || (year % 400) == 0); + long quot,rem; + COMET_DIVMOD_(quot,rem, year, 100); + if (rem != 0) return true; + return ((quot & 0x3) == 0); + } + + enum { + dt_max = 2958465L, // about year 9999 + dt_null_ = 2147483648L, + dt_invalid_ = 2147483647L, + dt_min = (-657434L) // about year 100 + }; + + + static int days_in_month(int year, int month) + { + switch (month) + { + case 2: return (is_leap_year(year)?29:28); + case 4: case 6: case 9: case 11: + return 30; + default:return 31; + }; + } + + }; + //! @endif + + + // Convert TM to OLE date + template + bool + datetime_base::from_tm_( const struct tm &src, DATE *dt, convert_mode mode) + { + return oledate_from_datetime_( dt, unsigned short(src.tm_year + 1900),unsigned short( src.tm_mon+1),unsigned short( src.tm_mday),unsigned short( src.tm_hour),unsigned short( src.tm_min),unsigned short( src.tm_sec), 0U, mode); + } + + // Convert OLE date to TM. \retval true Successful conversion. + template + bool + datetime_base::to_tm_( DATE dt, struct tm *dest, int *ms) + { + int y,m,d; + if ( !datetime_from_oledate_( dt, &y, &m, &d, &dest->tm_wday, &dest->tm_hour, &dest->tm_min, &dest->tm_sec, NULL, cmBoth) ) + return false; + dest->tm_year = y; + dest->tm_mon = m; + dest->tm_mday = d; + + + if (dest->tm_year != 0) + { + long firstday, thisday; + absdate_from_date_( &thisday, y,m,d); + absdate_from_date_(&firstday, y, 1, 1); + dest->tm_yday = 1+ ( thisday - firstday); + // Convert afx internal tm to format expected by runtimes (_tcsftime, etc) + dest->tm_year -= 1900; // year is based on 1900 + dest->tm_mon -= 1; // month of year is 0-based + dest->tm_isdst = -1; // Don't know DST status. + } + else + dest->tm_yday = 0; + return true; + } + + // Convert OLE date to date-parts. + template + bool + datetime_base::date_from_absdate_(long daysAbsolute , int *tm_year, int *tm_mon, int *tm_mday) + { + // These algorithms are taken from the gregorian_calendar + // calculations in boost. + typedef long date_int_type; + typedef int year_type; + date_int_type dayNumber = daysAbsolute; + date_int_type a = dayNumber + 32044 ; + date_int_type b = (4*a + 3)/146097; + date_int_type c = a-((146097*b)/4); + date_int_type d = (4*c + 3)/1461; + date_int_type e = c - (1461*d)/4; + date_int_type m = (5*e + 2)/153; + *tm_mday = static_cast(e - ((153*m + 2)/5) + 1); + *tm_mon = static_cast(m + 3 - 12 * (m/10)); + *tm_year = static_cast(100*b + d - 4800 + (m/10)); + return true; + } + + // Convert date parts to absolute date. + template + bool + datetime_base::absdate_from_date_( long *daysAbsolute, int tm_year, int tm_month, int tm_mday) + { + // These algorithms are taken from the gregorian_calendar + // calculations in boost. + unsigned short a = static_cast((14-tm_month)/12); + unsigned short y = static_cast(tm_year + 4800 - a); + unsigned short m = static_cast(tm_month + 12*a - 3); + unsigned long d = tm_mday + ((153*m + 2)/5) + 365*y + (y/4) - (y/100) + (y/400) - 32045; + + *daysAbsolute = d; + + return true; + } + + // Convert OLE time to time of day parts. + template + bool + datetime_base::time_from_milliseconds_( long milliseconds, int *tm_hour, int *tm_min, int *tm_sec, int *tm_ms) + { + if (milliseconds == 0 ) + { + *tm_hour = *tm_min = *tm_sec = 0; + if (tm_ms!=NULL) *tm_ms =0; + return true; + } + long ms, quot, quot2; + COMET_DIVMOD_(quot, ms, milliseconds, 1000); + COMET_DIVMOD_(quot2, *tm_sec, quot, 60); + COMET_DIVMOD_( *tm_hour, *tm_min, quot2, 60); + if( tm_ms != NULL) + *tm_ms = ms; + return true; + } + + // Convert time-of-day parts to milliseconds. + template + bool + datetime_base::milliseconds_from_time_( long *milliseconds, unsigned short tm_hour, unsigned short tm_min, unsigned short tm_sec, unsigned short tm_ms) + { + if ( tm_hour > 23 || tm_min > 59 || tm_sec> 59) return false; + + *milliseconds = (tm_hour* 3600000L) + (tm_min*60000L)+ (tm_sec*1000)+ tm_ms; + return true; + } + + // + template + bool + datetime_base::datetime_from_oledate_( DATE date, int *tm_year, int *tm_mon, int *tm_mday, int *tm_wday, int *tm_hour, int *tm_min, int *tm_sec, int *tm_ms, convert_mode mode) + { + long datePart, msPart; + datePart = split_oledate_as_absdate_(date, &msPart, mode != cmOnlyDate); + if ( mode != cmOnlyDate && !time_from_milliseconds_( msPart, tm_hour, tm_min, tm_sec, tm_ms)) + return false; + return (mode == cmOnlyTime) || (date_from_absdate_( datePart, tm_year, tm_mon, tm_mday)) && ( (tm_wday==NULL) || dow_from_absdate_(datePart, tm_wday)); + } + + // Convert datetime-parts to ole date. + template + bool + datetime_base::oledate_from_datetime_( DATE *date, unsigned short tm_year, unsigned short tm_mon, unsigned short tm_mday, unsigned short tm_hour, unsigned short tm_min, unsigned short tm_sec, unsigned short tm_ms, convert_mode mode) + { + long datePart = 0, timePart = 0; + if (mode != cmOnlyDate && !milliseconds_from_time_( &timePart, tm_hour, tm_min, tm_sec, tm_ms)) + return false; + if (mode != cmOnlyTime && !absdate_from_date_( &datePart, tm_year, tm_mon, tm_mday)) + return false; + *date = join_absdate_as_oledate_(datePart, timePart); + return true; + } +} + + +/** \class datetime_t datetime.h comet\datetime.h + * Wrapper for DATE. + * DATE/TIME Represented as days + fraction of days. + */ +class datetime_t : private impl::datetime_base +{ +public: + + /// UTC/Local conversion mode. + struct utc_convert_mode + { + enum type + { + none, ///< No conversion. + local_to_utc, ///< Convert from local to utc. + utc_to_local ///< Convert from utc to local. + }; + }; + + /// Describe how to get the timezone bias. + struct timezone_bias_mode + { + enum type + { + standard, ///< Standard timezone offset + daylight_saving ///< Summer timezone offset + }; + }; + + /// Root which a time uses as an offset. + struct locality + { + enum type + { + utc, ///< A local timezone date/time. + local ///< A UTC date/time. + }; + }; + + /** \name Constructors. + * Attach to various system date/time types. + */ + //@{ + /// Constructor + datetime_t() { dt_ = 0.;} + + /// Constructor from raw DATE type. + explicit datetime_t(DATE date) + { + dt_ = date; + } + + //! Construct from date/time components. + /** If conversion fails, an valid() will return false. + */ + explicit datetime_t(int year, int month, int day, int hours=-1, int minutes=0, int seconds=0, int milliseconds=0) + { + if (!oledate_from_datetime_( &dt_, (unsigned short)year, (unsigned short)month, + (unsigned short)day, (unsigned short)hours, (unsigned short)minutes, (unsigned short)seconds, (unsigned short) milliseconds, + (hours < 0)?cmOnlyDate:cmBoth )) + set_invalid_(); + } + + /// Initialise as invalid. + datetime_t( dt_invalid_t) { dt_ = dt_invalid_; } + /// Initialise as null. + datetime_t( dt_null_t) { dt_ = dt_null_; } + /// Initialise as zero. + datetime_t( dt_zero_t) { dt_ = 0.; } + + /// Get a 'NULL' datetime. + static datetime_t get_null() { return datetime_t( DATE(dt_null_) ); } + /// Get a 'zero' datetime. + static datetime_t get_zero() { return datetime_t( DATE(0) ); } + + + //! Construct from a SYSTEMTIME. + /** Defaults to no conversion! + * \sa from_systemtime to_systemtime + */ + explicit datetime_t(const SYSTEMTIME& systimeSrc) + { + if (!from_systemtime(systimeSrc)) + set_invalid_(); + } + + /** + * Construct from a @e SYSTEMTIME. + * + * @param source + * @e SYSTEMTIME being converted. + * @param utc_mode + * Timezone conversion mode. + * @param conversion_time + * Optional override date to use for calculating daylight/standard time. + * @param utc_or_local + * Specify whether the override time is a UTC or local date. + */ + explicit datetime_t( + const SYSTEMTIME& source, utc_convert_mode::type utc_mode, + const datetime_t& conversion_time=datetime_t(dt_invalid), + locality::type utc_or_local=locality::local) + { + if (!from_systemtime(source, utc_mode, conversion_time, utc_or_local)) + set_invalid_(); + } + + /** + * Construct from a @e SYSTEMTIME. + * + * @param source + * @e SYSTEMTIME being converted. + * @param utc_mode + * Timezone conversion mode. + * @param bias_mode + * Specify whether the local time is daylight/standard time. + */ + explicit datetime_t( + const SYSTEMTIME& source, utc_convert_mode::type utc_mode, + timezone_bias_mode::type bias_mode) + { + if (!from_systemtime(source, utc_mode, bias_mode)) + set_invalid_(); + } + + /** + * Construct from a @e FILETIME. + * + * Defaults to no timezone conversion. FILETIME values are a tricky beast. + * FILETIMEs on FAT are local, as are ZIP files (mostly). On shares and + * NTFS, they are UTC. + * + * @param source + * @e FILETIME being converted. + * @param utc_mode + * Timezone conversion mode. + * @param conversion_time + * Optional override date to use for calculating daylight/standard time. + * @param utc_or_local + * Specify whether the override time is a UTC or local date. + * + * @sa from_filetime to_filetime + */ + explicit datetime_t( + const FILETIME& source, + utc_convert_mode::type utc_mode=utc_convert_mode::none, + const datetime_t& conversion_time=datetime_t(dt_invalid), + locality::type utc_or_local=locality::local) + { + if (!from_filetime(source, utc_mode, conversion_time, utc_or_local)) + set_invalid_(); + } + + /** + * Construct from a @e FILETIME. + * + * Defaults to no timezone conversion. FILETIME values are a tricky beast. + * FILETIMEs on FAT are local, as are ZIP files (mostly). On shares and + * NTFS, they are UTC. + * + * @param source + * @e FILETIME being converted. + * @param utc_mode + * Timezone conversion mode. + * @param bias_mode + * Specify whether the local time is daylight/standard time. + * + * @sa from_filetime to_filetime + */ + explicit datetime_t( + const FILETIME& source, utc_convert_mode::type utc_mode, + timezone_bias_mode::type bias_mode) + { + if (!from_filetime(source, utc_mode, bias_mode)) + set_invalid_(); + } + + /** + * Construct from a Unix time. + * + * Defaults to conversion from utc to local time as time_t is in UTC. + * + * @param source + * Unix time being converted. + * @param utc_mode + * Timezone conversion mode. + * @param conversion_time + * Optional override date to use for calculating daylight/standard time. + * @param utc_or_local + * Specify whether the override time is a UTC or local date. + * + * @sa from_unixtime to_unixtime + */ + explicit datetime_t( + time_t source, + utc_convert_mode::type utc_mode=utc_convert_mode::utc_to_local, + const datetime_t& conversion_time=datetime_t(dt_invalid), + locality::type utc_or_local=locality::local) + { + if (!from_unixtime(source, utc_mode, conversion_time, utc_or_local)) + set_invalid_(); + } + + /** + * Construct from a Unix time. + * + * Defaults to conversion from utc to local time as time_t is in UTC. + * + * @param source + * Unix time being converted. + * @param utc_mode + * Timezone conversion mode. + * @param bias_mode + * Specify whether the local time is daylight/standard time. + * + * @sa from_unixtime to_unixtime + */ + explicit datetime_t( + time_t source, utc_convert_mode::type utc_mode, + timezone_bias_mode::type bias_mode) + { + if (!from_unixtime(source, utc_mode, bias_mode)) + set_invalid_(); + } + + //! Copy constructor. + datetime_t(const datetime_t& date) + { + dt_ = date.dt_; + } + + //@} + + /// Create a const reference. + static const datetime_t& create_const_reference(const DATE& s) throw() + { return *reinterpret_cast(&s); } + /// Create a non-const reference. + static datetime_t& create_reference(DATE& s) throw() + { return *reinterpret_cast(&s); } + + /// Day-of-week enumeration. + enum day_of_week { + dow_sun=0, dow_mon, dow_tue, dow_wed, dow_thu, dow_fri, dow_sat + }; + + /// Return the current time. + static datetime_t now() + { + SYSTEMTIME lt; + ::GetLocalTime(<); + return datetime_t(lt); + } + /// Return the current utc time. + static datetime_t now_utc() + { + SYSTEMTIME lt; + ::GetSystemTime(<); + return datetime_t(lt); + } + + /** Add specified number of months. + * If the day is not valid (ie 1 month from 31 December) + * an exception will be thrown. + * \todo Add an enum to be more smart about this. + */ + datetime_t &add_months(int inc_months) + { + int year,month,day; + + split_date(&year,&month,&day); + long months = (month-1)+(year*12)+inc_months; + + long quot,rem; + COMET_DIVMOD_(quot, rem, months, 12); + if(!set_date( quot, rem+1, day)) + throw datetime_exception("Invalid Date"); + + return *this; + } + + /// Add specified number of years. + datetime_t &add_years(int inc_years) + { + int year,month,day; + split_date(&year,&month,&day); + if(!set_date( year+inc_years, month, day)) + throw datetime_exception("Invalid Date"); + return *this; + } + + /// Return year/month/day values. + void split_date(int *year, int *month, int *day) const + { + if (good()) + { + long datePart = split_oledate_as_absdate_(dt_); + if (date_from_absdate_( datePart, year, month, day) ) + return; + } + throw datetime_exception("Invalid Date"); + } + + /// Return hours/minutes/second values. + void split_time( int *hours, int *minutes, int *seconds, int *milliseconds=NULL) const + { + if(!good() || !datetime_from_oledate_(dt_, NULL, NULL, NULL, NULL, hours, minutes, seconds, milliseconds, cmOnlyTime)) + throw datetime_exception("Invalid DateTime"); + } + /// Return date/time split up. + void split(int *year, int *month, int *day, int *hours, int *minutes, int *seconds, int *milliseconds=NULL) + { + if(!good() || !datetime_from_oledate_(dt_, year, month, day, NULL, hours, minutes, seconds, milliseconds, cmBoth)) + throw datetime_exception("Invalid DateTime"); + } + + + /// \name Access date/time parts. + //@{ + /// Year. + int year() const + { + int year,month,day; + split_date(&year,&month,&day); + return year; + } + /// Month of year (1-based) + int month() const + { + int year,month,day; + split_date(&year,&month,&day); + return month; + } + /// Day of month (1-based) + int day() const + { + int year,month,day; + split_date(&year,&month,&day); + return day; + } + /// Hour part of time (0-based) ??? + int hour() const + { + int hours,minutes,seconds; + split_time(&hours,&minutes,&seconds); + return hours; + } + /// Minute part of time (0-based) + int minute() const + { + int hours,minutes,seconds; + split_time(&hours,&minutes,&seconds); + return minutes; + } + /// Second + int second() const + { + int hours,minutes,seconds; + split_time(&hours,&minutes,&seconds); + return seconds; + } + /// Milliseconds + int millisecond() const + { + int hours,minutes,seconds,ms; + split_time(&hours,&minutes,&seconds,&ms); + return ms; + } + + /// The day of week. + day_of_week dow() const + { + long datePart; + datePart = split_oledate_as_absdate_(dt_); + int wday; + if(!good() || !dow_from_absdate_(datePart, &wday)) + throw datetime_exception("Invalid Date"); + return day_of_week(wday); + } + /// Day of the year (0 -based) + int year_day() const + { + if (good()) + { + long datepart = split_oledate_as_absdate_(dt_); + int y,m,d; + date_from_absdate_(datepart, &y,&m,&d); + long firstday; + if ( absdate_from_date_(&firstday, y, 1, 1)) + return 1+ ( datepart - firstday); + } + throw datetime_exception("Invalid Date"); + } + /// Days in the month; + int days_in_month() + { + int year,month,day; + split_date(&year,&month,&day); + return impl::datetime_base::days_in_month(year,month); + } + //@} + static inline int days_in_month(int year, int month) + { + return impl::datetime_base::days_in_month(year,month); + } + + /// \name Assignment operators + //@{ + + datetime_t &operator=( const datetime_t& date) + { + dt_ = date.dt_; + return *this; + } + + datetime_t &operator=( DATE date ) + { + set_invalid_check_range_(date); + return *this; + } + //@} + + ///\name Comparison operators + //@{ + bool operator==(const datetime_t& date) const{ return date.dt_==dt_; } + bool operator!=(const datetime_t& date) const{ return date.dt_!=dt_; } + bool operator<(const datetime_t& date) const { return to_double(dt_)(const datetime_t& date) const{ return to_double(dt_)>to_double(date.dt_); } + bool operator<=(const datetime_t& date) const{ return to_double(dt_)<=to_double(date.dt_); } + bool operator>=(const datetime_t& date) const{ return to_double(dt_)>=to_double(date.dt_); } + bool operator==(dt_invalid_t) const { return invalid(); } + bool operator!=(dt_invalid_t) const { return !invalid(); } + bool operator==(dt_zero_t) const { return dt_==0.; } + bool operator!=(dt_zero_t) const { return dt_!=0.; } + bool operator==(dt_null_t) const { return null(); } + bool operator!=(dt_null_t) const { return !null(); } + //@} + + ///\name Arithmetic operators + //@{ + datetime_t operator+(const timeperiod_t& dateSpan) const + { + datetime_t dt(*this); + dt+=dateSpan; + return dt; + } + datetime_t operator-(const timeperiod_t& dateSpan) const + { + datetime_t dt(*this); + dt-=dateSpan; + return dt; + } + datetime_t& operator+=(const timeperiod_t &dateSpan) + { + COMET_ASSERT( good() ); + if(!good()) + set_invalid_(); + else + set_invalid_check_range_(to_date( to_double(dt_) + (double)dateSpan )); + + return *this; + } + datetime_t& operator-=(const timeperiod_t &dateSpan) + { + COMET_ASSERT( good() ); + if(!good()) + set_invalid_(); + else + set_invalid_check_range_(to_date( to_double(dt_) - (double)dateSpan )); + return *this; + } + timeperiod_t operator-(const datetime_t& date) const + { + COMET_ASSERT( good() && date.good() ); + if( !good() || ! date.good()) + return timeperiod_t::invalid_period(); + return to_double(dt_) - to_double(date.dt_); + } + datetime_t &operator++() + { + (*this)+=1; + return *this; + } + datetime_t operator++(int) + { + datetime_t t(*this); (*this)+=1; return t; + } + datetime_t &operator--() + { + (*this)-=1; return *this; + } + + datetime_t operator--(int) + { + datetime_t t(*this); (*this)-=1; return t; + } + //@} + + /// return true if the date is marked 'invalid'. + inline bool invalid() const { return dt_ == ((double) dt_invalid_); } + /// return true if the date is marked 'null' + inline bool null() const { return dt_ == ((double) dt_null_); } + + /// return true if date is zero + inline bool zero() const { return dt_ == 0; } + + /** return true if the date is not marked 'invalid'. + * \deprecated + */ + inline bool valid() const { return !invalid(); } + + /// Return true if the date is usable. + inline bool good() const + { + switch ((long)dt_) + { + case dt_invalid_: case dt_null_: return false; + default: return true; + } + } + + ///\name Accessor methods + //@{ + DATE get() const { if(invalid()) throw("Invalid Date"); return null()?0:dt_;} + DATE in() const { return get(); } + DATE *in_ptr() const { return const_cast(&dt_);} + DATE *out() { return &dt_;} + DATE *inout() { return &dt_;} + //@} + /** Set date part as year/month/day. + * \param year Year (from year 0 - as in 2000). + * \param month Month of year (1-based). + * \param day Day of month (1-based). + * \retval true Successfully set date. + * \retval false Conversion unsuccessful - date not set. + */ + bool set_date( int year, int month, int day) + { + long datePart, timePart; + datePart = split_oledate_as_absdate_(dt_, &timePart, true); + if (!absdate_from_date_(&datePart, year,month, day)) + return false; + dt_ = join_absdate_as_oledate_( datePart, timePart); + return true; + } + + /** Set time part as hours/minutes/seconds. + * \param hours As in a 24-hour clock. + * \param minutes Minutes past the hour. + * \param seconds Seconds past the minute. + * \param milliseconds Milliseconds past the second. + * \retval true Successfully set time. + * \retval false Conversion unsuccessful - time not set. + */ + bool set_time( int hours, int minutes, int seconds, int milliseconds =0) + { + long datePart, timePart; + datePart = split_oledate_as_absdate_(dt_, &timePart, true); + if (!milliseconds_from_time_(&timePart, (unsigned short)hours, (unsigned short)minutes, (unsigned short)seconds, (unsigned short)milliseconds)) + return false; + dt_ = join_absdate_as_oledate_( datePart, timePart); + return true; + } + /** Set both date and time. + * \param year Year (from year 0 - as in 2000). + * \param month Month of year (1-based). + * \param day Day of month (1-based). + * \param hours As in a 24-hour clock. + * \param minutes Minutes past the hour. + * \param seconds Seconds past the minute. + * \param milliseconds Milliseconds past the second. + * \retval true Successfully set date/time. + * \retval false Conversion unsuccessful - date/time not set. + */ + bool set_date_time(int year, int month, int day, int hours, int minutes, int seconds, int milliseconds = 0 ) + { + return oledate_from_datetime_(&dt_, (unsigned short)year, (unsigned short)month, (unsigned short)day, (unsigned short)hours, (unsigned short)minutes, (unsigned short)seconds, (unsigned short)milliseconds, cmBoth); + } + + /// Flags for formatting. + enum format_flags{ + ff_default = 0, ///< Default formatting. + ff_system_locale = LOCALE_NOUSEROVERRIDE, ///< Use system locale + ff_hijri = VAR_CALENDAR_HIJRI, ///< Use HIJRI calendar. + ff_thai = 0x10, /* VAR_CALENDAR_THAI, */ ///< Use thai calendar. + ff_gregorian = 0x20, /*VAR_CALENDAR_GREGORIAN*/ ///< Use gregorian calendar. + ff_four_digits = VAR_FOURDIGITYEARS, ///< Four digits for years + ff_time_only = VAR_TIMEVALUEONLY, ///< Only output time. + ff_date_only = VAR_DATEVALUEONLY ///< Only output date. + }; + /** Parse bstring to a datetime_t. + * \param val String to parse. + * \param flags valid format_flags are: ff_default, ff_system_locale, ff_hijri, ff_time_only, ff_date_only + * \param locale Locale to use. Default \p locale is the user default. + */ + datetime_t &parse( const bstr_t &val, format_flags flags = ff_default, LCID locale = LOCALE_USER_DEFAULT) + { + VarDateFromStr( val.in(), locale, flags, &dt_) | raise_exception; + return *this; + } + + /** Return a double that is sortable / can be subtracted. + * Dates before 12/30/1899 will not sort propperly. + */ + double as_sortable_double() const { COMET_ASSERT( good() ); return to_double(dt_); } + +public: + + /** + * Convert a local time to UTC. + * + * Takes a local time (like that inside a ZIP file, or on a FAT file + * system) and converts it to UTC, using the timezone rules in effect as + * of the date specified. Typically the "as of" date is specified as the + * modification or creation date of the ZIP file, or left missing to + * default to the given local date. It is also possible to specify if the + * "as of" date is in UTC or not. If missing, it defaults to false. + */ + + /** + * Create UTC version of this local time. + * + * Assuming this datetime is a local time (like that inside a ZIP file or + * on a FAT file system) this creates a new version of it as a UTC datetime. + * By default, the adjustment is made based on the timezone rules that + * would have been in effect at the UTC date this object represents. + * However, the time can also be converted as though it were on another + * date by passing another date as an argument. + * + * Typically the "as of" date is specified as the current time or possibly + * the modification or creation date of an enclosing ZIP file. + * + * @param as_of_date + * Optional alternative date on which to base the timezone conversion. + * @param utc_or_local + * Whether `as_of_date` is a local or UTC date. Defaults to UTC. + */ + datetime_t local_to_utc( + datetime_t as_of_date=datetime_t(dt_invalid), + locality::type utc_or_local=locality::local) const + { + // if they didn't specify an AS OF date, use the current date which + // will be local + if (as_of_date.invalid()) + { + utc_or_local = locality::local; // no break + as_of_date = *this; + } + + double timezone_bias = + local_timezone_bias(as_of_date, utc_or_local) / (24.*60.); + double local_date_continuous = to_double(dt_); + DATE utc_date = to_date(local_date_continuous + timezone_bias); + + return datetime_t(utc_date); + } + + /** + * Create a UTC version of this local time, explicitly using standard + * time or daylight savings. + * + * Assuming this datetime is a local time (like that inside a ZIP file or + * on a FAT file system) this creates a new version of it as a UTC datetime. + * Depending on the argument passed, the adjustment is made as though + * daylight savings were in operation in the local timezone or not. + * + * @param bias_mode + * Whether to assume daylight savings is in effect. + * + * - standard: create local time as though it were not + * daylight savings time + * - daylight_savings: create local time as though it were daylight + * savings time + */ + datetime_t local_to_utc(timezone_bias_mode::type bias_mode) const + { + double timezone_bias = local_timezone_bias(bias_mode) / (24.*60.); + double local_date_continuous = to_double(dt_); + DATE utc_date = to_date(local_date_continuous + timezone_bias); + + return datetime_t(utc_date); + } + + /** + * Create local time version of this UTC time. + * + * Assuming this datetime is a UTC time (like that on an NTFS file system) + * this creates a new version of it in the local timezone. By default, + * the adjustment is made based on the timezone rules that would have been + * in effect at the UTC date this object represents. However, the time can + * also be converted as though it were on another date by passing another + * date as an argument. + * + * Typically the "as of" date is specified as the current time or possibly + * the modification or creation date of an enclosing ZIP file. + * + * @param as_of_date + * Optional alternative date on which to base the timezone conversion. + * @param utc_or_local + * Whether `as_of_date` is a local or UTC date. Defaults to UTC. + */ + datetime_t utc_to_local( + datetime_t as_of_date=datetime_t(dt_invalid), + locality::type utc_or_local=locality::utc) const + { + // if they didn't specify an AS OF date, use the current date which + // will be UTC + if (as_of_date.invalid()) + { + as_of_date = *this; + utc_or_local = locality::utc; + } + + long timezone_bias = local_timezone_bias(as_of_date, utc_or_local); + double timezone_bias_days = timezone_bias / (24.*60.); + double utc_date_continuous = to_double(dt_); + DATE local_date = to_date(utc_date_continuous - timezone_bias_days); + + return datetime_t(local_date); + } + + /** + * Create local time version of this UTC time, explicitly using standard + * time or daylight savings. + * + * Assuming this datetime is a UTC time (like that on an NTFS file system) + * this creates a new version of it in the local timezone. Depending on + * the argument passed, the adjustment is made as though daylight savings + * were in operation in the timezone or not. + * + * @param bias_mode + * Whether to assume daylight savings. + * + * - standard: create local time as though it were not + * daylight savings time + * - daylight_savings: create local time as though it were daylight + * savings time + */ + datetime_t utc_to_local(timezone_bias_mode::type bias_mode) const + { + long timezone_bias = local_timezone_bias(bias_mode); + double timezone_bias_days = timezone_bias / (24.*60.); + double utc_date_continuous = to_double(dt_); + DATE local_date = to_date(utc_date_continuous - timezone_bias_days); + + return datetime_t(local_date); + } + + /** Convert to SYSTEMTIME struct. + */ + bool to_systemtime( SYSTEMTIME *sysTime) const + { + int year,month,day,dow,hour,minute,second,ms; + if (!datetime_from_oledate_( dt_, &year, &month, &day, &dow, &hour, &minute, &second, &ms, cmBoth)) + return false; + sysTime->wYear = (short)year; + sysTime->wMonth = (short)month; + sysTime->wDay = (short)day; + sysTime->wDayOfWeek = (short)dow; // Sunday=0 + sysTime->wHour = (short)hour; + sysTime->wMinute = (short)minute; + sysTime->wSecond = (short)second; + sysTime->wMilliseconds = (short)ms; + return true; + } + + /** Convert from a \e SYSTEMTIME struct. + */ + bool from_systemtime(const SYSTEMTIME& src) + { + return oledate_from_datetime_( &dt_, src.wYear, src.wMonth, src.wDay, src.wHour, src.wMinute, src.wSecond, src.wMilliseconds, cmBoth); + } + + /** + * Convert from a @e SYSTEMTIME struct. + * + * @param source + * @e SYSTEMTIME being converted. + * @param utc_mode + * Timezone conversion mode. + * @param conversion_time + * Optional override date to use for calculating daylight/standard time. + * @param utc_or_local + * Specify whether the override time is a UTC or local date. + */ + bool from_systemtime( + const SYSTEMTIME& source, utc_convert_mode::type utc_mode, + const datetime_t& conversion_time=datetime_t(dt_invalid), + locality::type utc_or_local=locality::local) + { + if (!from_systemtime(source)) + return false; + + switch(utc_mode) + { + case utc_convert_mode::none: + break; + case utc_convert_mode::local_to_utc: + *this = local_to_utc(conversion_time, utc_or_local); + break; + case utc_convert_mode::utc_to_local: + *this = utc_to_local(conversion_time, utc_or_local); + break; + } + return true; + } + + /** + * Convert from a @e SYSTEMTIME struct. + * + * @param source + * @e SYSTEMTIME being converted. + * @param utc_mode + * Timezone conversion mode. + * @param bias_mode + * Specify whether the local time is daylight/standard time. + */ + bool from_systemtime( + const SYSTEMTIME& source, utc_convert_mode::type utc_mode, + timezone_bias_mode::type bias_mode) + { + if (!from_systemtime(source)) + return false; + + switch(utc_mode) + { + case utc_convert_mode::none: + break; + case utc_convert_mode::local_to_utc: + *this = local_to_utc(bias_mode); + break; + case utc_convert_mode::utc_to_local: + *this = utc_to_local(bias_mode); + break; + } + return true; + } + + /** Convert from a \e FILETIME struct. + */ + bool from_filetime(const FILETIME& src) + { + double ftd = (((__int64(src.dwHighDateTime) << 32 | src.dwLowDateTime)/(36000000000.)) - 2620920.)/24; + return set_check_range_( to_date(ftd)); + } + + /** + * Convert from a @e FILETIME struct. + * + * @param source + * @e FILETIME being converted. + * @param utc_mode + * Timezone conversion mode. + * @param conversion_time + * Optional override date to use for calculating daylight/standard time. + * @param utc_or_local + * Specify whether the override time is a UTC or local date. + */ + bool from_filetime( + const FILETIME& source, utc_convert_mode::type utc_mode, + const datetime_t& conversion_time=datetime_t(dt_invalid), + locality::type utc_or_local=locality::local) + { + if (!from_filetime(source)) + return false; + + switch(utc_mode) + { + case utc_convert_mode::none: + break; + case utc_convert_mode::local_to_utc: + *this = local_to_utc(conversion_time, utc_or_local); + break; + case utc_convert_mode::utc_to_local: + *this = utc_to_local(conversion_time, utc_or_local); + break; + } + return true; + } + + /** + * Convert from a @e FILETIME struct. + * + * @param source + * @e FILETIME being converted. + * @param utc_mode + * Timezone conversion mode. + * @param bias_mode + * Specify whether the local time is daylight/standard time. + */ + bool from_filetime( + const FILETIME& source, utc_convert_mode::type utc_mode, + timezone_bias_mode::type bias_mode) + { + if (!from_filetime(source)) + return false; + + switch(utc_mode) + { + case utc_convert_mode::none: + break; + case utc_convert_mode::local_to_utc: + *this = local_to_utc(bias_mode); + break; + case utc_convert_mode::utc_to_local: + *this = utc_to_local(bias_mode); + break; + } + return true; + } + + /** Convert to a \e FILETIME struct. + */ + bool to_filetime( FILETIME *filetime) const + { + double val = ((to_double(dt_) * 24.) + 2620920.)*(36000000000.) ; + + __int64 llval = __int64(val); + filetime->dwHighDateTime = long (llval >> 32); + filetime->dwLowDateTime = long (llval); + return val > 0; + } + + /** Convert from a \e tm struct. + */ + bool from_tm(const struct tm &tm_time) + { + return from_tm_( tm_time, &dt_, cmBoth); + } + + /** + * Convert from a @e tm struct. + * @param tm_time + * @e tm struct being converted. + * @param utc_mode + * Timezone conversion mode. + * @param conversion_time + * Optional override date to use for calculating daylight/standard time. + * Only used if the information cannot be derived from the @e tm struct. + * @param utc_or_local + * Whether the optional conversion date is UTC or local. + */ + bool from_tm( + const struct tm &tm_time, utc_convert_mode::type utc_mode, + datetime_t conversion_time=datetime_t(dt_invalid), + locality::type utc_or_local=locality::local) + { + if(!from_tm(tm_time)) + return false; + + switch(utc_mode) + { + case utc_convert_mode::none: + break; + case utc_convert_mode::local_to_utc: + // Take advantage of tm_isdst to work out dst mode! + // + // XXX: This doesn't use the conversion_time at all. No, I don't + // know why we have this behaviour + if (tm_time.tm_isdst == 0) + { + *this = local_to_utc(timezone_bias_mode::standard); + } + else if (tm_time.tm_isdst > 0) + { + *this = local_to_utc(timezone_bias_mode::daylight_saving); + } + else + { + *this = local_to_utc(conversion_time, utc_or_local); + } + break; + case utc_convert_mode::utc_to_local: + *this = utc_to_local(conversion_time, utc_or_local); + break; + } + + return true; + } + + /** + * Convert from a @e tm struct. + * + * @param tm_time + * @e 'tm' struct being converted. + * @param utc_mode + * Timezone conversion mode. + * @param daylight_hint + * Strategy to use for daylight savings time if it cannot be derived + * from the @e tm struct. + */ + bool from_tm( + const struct tm &tm_time, utc_convert_mode::type utc_mode, + timezone_bias_mode::type daylight_hint) + { + if(!from_tm(tm_time)) + return false; + + switch(utc_mode) + { + case utc_convert_mode::none: + break; + case utc_convert_mode::local_to_utc: + // Take advantage of tm_isdst to work out dst mode! + // + // XXX: This overrides the specified conversion. No, I don't + // know why we have this behaviour + if (tm_time.tm_isdst == 0) + { + *this = local_to_utc(timezone_bias_mode::standard); + } + else if (tm_time.tm_isdst > 0) + { + *this = local_to_utc(timezone_bias_mode::daylight_saving); + } + else + { + *this = local_to_utc(daylight_hint); + } + break; + case utc_convert_mode::utc_to_local: + *this = utc_to_local(daylight_hint); + break; + } + + return true; + } + + + /** + * Convert from a @e time_t value. + * + * @param source + * Unix time to convert. + * @param utc_mode + * Timezone conversion mode. By default converts a UTC time_t into + * a local datetime. + * @param conversion_time + * Optional override date to use for calculating daylight/standard time. + * @param utc_or_local + * Specify whether the override time is a UTC or local date. + */ + bool from_unixtime( + time_t source, + utc_convert_mode::type utc_mode=utc_convert_mode::utc_to_local, + const datetime_t& conversion_time=datetime_t(dt_invalid), + locality::type utc_or_local=locality::local) + { + FILETIME ft; + __int64 ll = (__int64(source) * 10000000L) + 116444736000000000L; + ft.dwLowDateTime = (DWORD) ll; + ft.dwHighDateTime = (DWORD)(ll >>32); + return from_filetime(ft, utc_mode, conversion_time, utc_or_local); + } + + /** + * Convert from a @e time_t value. + * + * @param source + * Unix time being converted. + * @param utc_mode + * Timezone conversion mode. + * @param bias_mode + * Specify whether the local time is daylight/standard time. + */ + bool from_unixtime( + time_t source, utc_convert_mode::type utc_mode, + timezone_bias_mode::type bias_mode) + { + FILETIME ft; + __int64 ll = (__int64(source) * 10000000L) + 116444736000000000L; + ft.dwLowDateTime = (DWORD) ll; + ft.dwHighDateTime = (DWORD)(ll >>32); + return from_filetime(ft, utc_mode, bias_mode); + } + + /** + * Convert to a @e time_t value. + * + * @param unix_time_out + * Destination of conversion result. + * @param utc_mode + * Timezone conversion mode. + * @param conversion_time + * Optional override date to use for calculating daylight/standard time. + * @param utc_or_local + * Specify whether the override time is a UTC or local date. + */ + bool to_unixtime( + time_t* unix_time_out, + utc_convert_mode::type utc_mode=utc_convert_mode::local_to_utc, + const datetime_t& conversion_time=datetime_t(dt_invalid), + locality::type utc_or_local=locality::local) const + { + datetime_t dtval; + + switch(utc_mode) + { + case utc_convert_mode::none: + dtval = *this; + break; + case utc_convert_mode::local_to_utc: + dtval = local_to_utc(conversion_time, utc_or_local); + break; + case utc_convert_mode::utc_to_local: + dtval = utc_to_local(conversion_time, utc_or_local); + break; + } + + FILETIME ft; + if (!dtval.to_filetime(&ft)) + return false; + + *unix_time_out = + time_t(((__int64(ft.dwHighDateTime) << 32 | ft.dwLowDateTime) - + 116444736000000000L)/10000000L); + return true; + } + + /** + * Convert to a @e time_t value. + * + * @param unix_time_out + * Destination of conversion result. + * @param utc_mode + * Timezone conversion mode. + * @param conversion_time + * Optional override date to use for calculating daylight/standard time. + * @param utc_or_local + * Specify whether the override time is a UTC or local date. + */ + bool to_unixtime( + time_t* unix_time_out, utc_convert_mode::type utc_mode, + timezone_bias_mode::type bias_mode) const + { + datetime_t dtval; + + switch(utc_mode) + { + case utc_convert_mode::none: + dtval = *this; + break; + case utc_convert_mode::local_to_utc: + dtval = local_to_utc(bias_mode); + break; + case utc_convert_mode::utc_to_local: + dtval = utc_to_local(bias_mode); + break; + } + + FILETIME ft; + if (!dtval.to_filetime(&ft)) + return false; + + *unix_time_out = + time_t(((__int64(ft.dwHighDateTime) << 32 | ft.dwLowDateTime) - + 116444736000000000L)/10000000L); + return true; + } + + /** + * Calculate the local timezone's offset from UTC on the given date, in + * minutes. + * + * This offset is called the bias and is the number of minutes to subtract + * from a UTC time to make a local one. + * + * @param dt + * The date and time for which to calculate the bias. + * @param is_utc + * Whether to interpret the date as UTC or local. + * + * @todo A better way might be to make UTCness a fundamental property of + * times at construction so they know whether they are URL or local + * themselves. + */ + static long local_timezone_bias(datetime_t dt, locality::type utc_or_local) + { + TIME_ZONE_INFORMATION tzi; + ::GetTimeZoneInformation(&tzi); + + long baseBias = tzi.Bias; + + // if we've even got both time zones set, we have to choose which is + // active... + if ((tzi.DaylightDate.wMonth != 0) && (tzi.StandardDate.wMonth != 0)) + { + // all local standard time/daylight savings time rules are based on + // local-time, so add the base bias FIRST + if (utc_or_local == locality::utc) + dt -= (baseBias / (24.*60.)); + + SYSTEMTIME sysTime; + if (!dt.to_systemtime(&sysTime)) + throw datetime_exception("Invalid Date"); + + bool DSTbeforeLST = + tzi.DaylightDate.wMonth < tzi.StandardDate.wMonth; + + bool afterDaylightStarts = + tz_on_or_after_in_year(sysTime, tzi.DaylightDate); + bool afterStandardStarts = + tz_on_or_after_in_year(sysTime, tzi.StandardDate); + + if (((afterDaylightStarts== afterStandardStarts)!= DSTbeforeLST)) + return baseBias + tzi.DaylightBias; + } + + return baseBias + tzi.StandardBias; + } + + /** + * Calculate the local timezone's offset from UTC in minutes. + * + * The value depends on the argument to the function which specifies + * whether to assume daylight savings is in operation in the local timezone. * occuring outside of daylight savings time. + */ + static long local_timezone_bias(timezone_bias_mode::type dst_state) + { + TIME_ZONE_INFORMATION tzi; + ::GetTimeZoneInformation(&tzi); + + switch (dst_state) + { + case timezone_bias_mode::standard: + return tzi.Bias + tzi.StandardBias; + case timezone_bias_mode::daylight_saving: + return tzi.Bias + tzi.DaylightBias; + default: + COMET_ASSERT(!"Invalid timezone daylight savings state"); + } + } + +protected: + + /** Compares two SYSTEMTIME values to decide if the second is after (or on) the + * first. + * If the year is supplied, the two dates are assumed static, otherwise it + * computes the proper day-of-week instance (like last Sunday in October) for + * the specified test year. See the encoding rules documented with + * TIME_ZONE_INFORMATION + */ + static bool tz_on_or_after_in_year(SYSTEMTIME testST, SYSTEMTIME tziST) + { + // assume month check first... + long cmp = testST.wMonth - tziST.wMonth; + if (cmp!=0) + return cmp > 0; + + SYSTEMTIME absST; + + // if year is given, then the specified date is already exact... + if (tziST.wYear != 0) + { + // first test the year... + cmp = testST.wYear - tziST.wYear; + if (cmp !=0) + return cmp > 0; + // carry on with the exact day known + absST = tziST; + } + else + { + // compute the appropriate day from the specified instance of the set day-of-week + // use the testST's year for the year in the calculation + tz_convert_relative_dow_to_absolute(testST, tziST, &absST); + } + + // month same... check day/hour/minute/second/millisecond + if ((cmp = testST.wDay - absST.wDay)==0) + if ((cmp = testST.wHour - absST.wHour)==0) + if ((cmp = testST.wMinute - absST.wMinute)==0) + if ((cmp = testST.wSecond - absST.wSecond)==0) + cmp = testST.wMilliseconds - absST.wMilliseconds; + return cmp >= 0; + } + + // Computes the proper day-of-week instance (like last Sunday in October) for the + // specified test year. See the encoding rules documented with TIME_ZONE_INFORMATION. + // This ASSUMES that testST.wMonth == tziST.wMonth + static void tz_convert_relative_dow_to_absolute(const SYSTEMTIME &testST , const SYSTEMTIME &tziST, SYSTEMTIME *absST) + { + COMET_ASSERT(testST.wMonth == tziST.wMonth); + + // Set up the absolute date except for wDay, which we must find + absST->wYear = testST.wYear; // year is only valid in the testST + int month = absST->wMonth = tziST.wMonth; + absST->wDayOfWeek = tziST.wDayOfWeek; + + absST->wHour = tziST.wHour; + absST->wMinute = tziST.wMinute; + absST->wSecond = tziST.wSecond; + absST->wMilliseconds = tziST.wMilliseconds; + + // Find a day of the month that falls on the same day of the week as + // the transition. + + // If test day is the 29th of the month (testST.wDay = 29) and today + // is a Tuesday (testST.wDayOfWeek = 2) and the transition occurs on + // Sunday (testST.wDayOfWeek = 0) we compute absDay = 29 + 0 + 7 - + // 2, giving the 34th + + // then adjust that to a day of month adjustment + long absDay = ((testST.wDay + tziST.wDayOfWeek + (7-1) - testST.wDayOfWeek) % 7) +1; + + // now multiply this time the "which DOW" setting from the TZI + // (1 = first, 5 = last) + // add the requisite number of weeks to the base point + absDay += (7 * (tziST.wDay - 1)); + + // and if we exceeded the number of days in the month, back up by a + // week (this handles the 5=last situation) + + int daysInMonth = days_in_month( absST->wYear, month); + + if (absDay > daysInMonth) + absDay -= 7; + + absST->wDay = (unsigned short)absDay; + } + +public: + + /** Format datetime_t as bstr. + * \param flags Format (can be or-ed). All format_flags are valid. + * \param locale Locale ID (default to User Default. + */ + bstr_t format( format_flags flags = ff_default , LCID locale = LOCALE_USER_DEFAULT) const + { + bstr_t strDate; + if (!good()) + { + return strDate; + } + VarBstrFromDate(dt_, locale, flags, strDate.out()) | raise_exception; + return strDate; + } + + /** Format datetime_t as basic_string. + * \param fmt See system documentation for strftime for details. + */ + template + std::basic_string format( const std::basic_string &fmt ) const + { + return format(fmt.c_str()); + } + + /** Format datetime_t as basic_string. + * \param fmt See system documentation for strftime for details. + */ + template + std::basic_string format( const CHAR *fmt ) const + { + if (!good()) + { + return std::basic_string(); + } + struct tm src; + if(!to_tm_( dt_, &src, NULL)) + throw datetime_exception("Invalid Date"); + + typename auto_buffer_t::size_type capacity = 50; + auto_buffer_t buf(capacity); + size_t ret; + while( (ret = str_formattime( buf.get() , capacity, fmt, &src ))==0 && capacity < 1024) + { + capacity += 50; + buf.resize(capacity); + } + if(ret == 0) + buf.at(0)='\0'; + + return std::basic_string(buf.get(), ret); + } + + /// Detach the raw date from the class. + DATE detach() + { + DATE val = dt_; + dt_ = 0.; + return val; + } + + /// Detach the raw date from the class. + static DATE detach( datetime_t &dt) + { + return dt.detach(); + } + + /// Stream operator. + friend + std::basic_ostream &operator<<(std::basic_ostream &os, const datetime_t &val) + { + os << val.format(); + return os; + } + + /// Stream operator. + friend + std::basic_ostream &operator<<(std::basic_ostream &os, const datetime_t &val) + { + os << val.format(); + return os; + } + +private: +}; +#undef COMET_DIVMOD_ +//@} + +} +#endif diff --git a/EyeTab_SP2/comet/dispatch.h b/EyeTab_SP2/comet/dispatch.h new file mode 100644 index 0000000..c631a71 --- /dev/null +++ b/EyeTab_SP2/comet/dispatch.h @@ -0,0 +1,675 @@ +/** \file + * Provides dispatch driver via wrap_t< ::IDispatch> + * Provides dynamic implementation of IDispatch via dynamic_dispatch. + */ +/* + * Copyright © 2001 Sofus Mortensen + * + * This material is provided "as is", with absolutely no warranty + * expressed or implied. Any use is at your own risk. Permission to + * use or copy this software for any purpose is hereby granted without + * fee, provided the above notices are retained on all copies. + * Permission to modify the code and to distribute modified code is + * granted, provided the above notices are retained, and a notice that + * the code was modified is included with the above copyright notice. + * + * This header is part of Comet version 2. + * https://github.com/alamaison/comet + */ + +#ifndef COMET_DISPATCH_H +#define COMET_DISPATCH_H + +#include + +#include + +namespace comet { + /*! \addtogroup Interfaces + */ + //@{ + + /** Specialisation of wrap_t for IDispatch. + * Implements wrappers for the call-by name and call-by dispid for IDispatch methods + * and properties. The wrapper supports properties with up to 3 arguments and methods + * with up to 4 arguments. + * \code + com_ptr disp( my_dual_interface); + variant_t val = disp->get(L"Name"); + * \endcode + * See \ref cometcomptrsmartwrapper for details on wrap_t. + */ + template<> struct wrap_t< ::IDispatch> + { + /** Get property by dispid. + */ + variant_t get(DISPID id) + { + VARIANT result; + VARIANT* vars = 0; + DISPPARAMS disp = { vars, 0, 0, 0 }; + HRESULT hr = raw(this)->Invoke(id, IID_NULL, LOCALE_USER_DEFAULT, DISPATCH_PROPERTYGET, &disp, &result, 0, 0); + if (FAILED(hr)) throw_com_error(raw(this), hr); + return auto_attach(result); + } + + /** Get property by name. + */ + variant_t get(const wchar_t* name) + { + DISPID id; + HRESULT hr = raw(this)->GetIDsOfNames(IID_NULL, const_cast(&name), 1, LOCALE_USER_DEFAULT, &id); + if (FAILED(hr)) throw_com_error(raw(this), hr); + return get(id); + } + + /** Get property by dispid with 1 argument. + */ + variant_t get(DISPID id, const variant_t& a0) + { + VARIANT result; + VARIANT vars[1]; vars[0] = a0.in(); + DISPPARAMS disp = { vars, 0, 1, 0 }; + HRESULT hr = raw(this)->Invoke(id, IID_NULL, LOCALE_USER_DEFAULT, DISPATCH_PROPERTYGET, &disp, &result, 0, 0); + if (FAILED(hr)) throw_com_error(raw(this), hr); + return auto_attach(result); + } + + /** Get property by name with 1 argument. + */ + variant_t get(const wchar_t* name, const variant_t& a0) + { + DISPID id; + HRESULT hr = raw(this)->GetIDsOfNames(IID_NULL, const_cast(&name), 1, LOCALE_USER_DEFAULT, &id); + if (FAILED(hr)) throw_com_error(raw(this), hr); + return get(id, a0); + } + + /** Get property by dispid with 2 arguments. + */ + variant_t get(DISPID id, const variant_t& a1, const variant_t& a0) + { + VARIANT result; + VARIANT vars[2]; vars[0] = a0.in(); vars[1] = a1.in(); + DISPPARAMS disp = { vars, 0, 2, 0 }; + HRESULT hr = raw(this)->Invoke(id, IID_NULL, LOCALE_USER_DEFAULT, DISPATCH_PROPERTYGET, &disp, &result, 0, 0); + if (FAILED(hr)) throw_com_error(raw(this), hr); + return auto_attach(result); + } + + /** Get property by name with 2 arguments. + */ + variant_t get(const wchar_t* name, const variant_t& a1, const variant_t& a0) + { + DISPID id; + HRESULT hr = raw(this)->GetIDsOfNames(IID_NULL, const_cast(&name), 1, LOCALE_USER_DEFAULT, &id); + if (FAILED(hr)) throw_com_error(raw(this), hr); + return get(id, a1, a0); + } + + /** Get property by dispid with 3 arguments. + */ + variant_t get(DISPID id, const variant_t& a2, const variant_t& a1, const variant_t& a0) + { + VARIANT result; + VARIANT vars[3]; vars[0] = a0.in(); vars[1] = a1.in(); vars[2] = a2.in(); + DISPPARAMS disp = { vars, 0, 3, 0 }; + HRESULT hr = raw(this)->Invoke(id, IID_NULL, LOCALE_USER_DEFAULT, DISPATCH_PROPERTYGET, &disp, &result, 0, 0); + if (FAILED(hr)) throw_com_error(raw(this), hr); + return auto_attach(result); + } + + /** Get property by name with 3 arguments. + */ + variant_t get(const wchar_t* name, const variant_t& a2, const variant_t& a1, const variant_t& a0) + { + DISPID id; + HRESULT hr = raw(this)->GetIDsOfNames(IID_NULL, const_cast(&name), 1, LOCALE_USER_DEFAULT, &id); + if (FAILED(hr)) throw_com_error(raw(this), hr); + return get(id, a2, a1, a0); + } + + /** Put property by dispid. + */ + void put(DISPID id, const variant_t& val) + { + VARIANT vars[1]; vars[0] = val.in(); + DISPID did = DISPID_PROPERTYPUT; + DISPPARAMS disp = { vars, &did, 1, 1 }; + HRESULT hr = raw(this)->Invoke(id, IID_NULL, LOCALE_USER_DEFAULT, DISPATCH_PROPERTYPUT, &disp, 0, 0, 0); + if (FAILED(hr)) throw_com_error(raw(this), hr); + } + + /** Put property by name. + */ + void put(const wchar_t* name, const variant_t& val) + { + DISPID id; + HRESULT hr = raw(this)->GetIDsOfNames(IID_NULL, const_cast(&name), 1, LOCALE_USER_DEFAULT, &id); + if (FAILED(hr)) throw_com_error(raw(this), hr); + put(id, val); + } + + /** Put property with 1 argument by dispid. + */ + void put(DISPID id, const variant_t& a1, const variant_t& val) + { + VARIANT vars[2]; vars[0] = val.in(); vars[1] = a1.in(); + DISPID did = DISPID_PROPERTYPUT; + DISPPARAMS disp = { vars, &did, 2, 1 }; + HRESULT hr = raw(this)->Invoke(id, IID_NULL, LOCALE_USER_DEFAULT, DISPATCH_PROPERTYPUT, &disp, 0, 0, 0); + if (FAILED(hr)) throw_com_error(raw(this), hr); + } + + /** Put property with 1 argument by name. + */ + void put(const wchar_t* name, const variant_t& a1, const variant_t& val) + { + DISPID id; + HRESULT hr = raw(this)->GetIDsOfNames(IID_NULL, const_cast(&name), 1, LOCALE_USER_DEFAULT, &id); + if (FAILED(hr)) throw_com_error(raw(this), hr); + put(id, a1, val); + } + + + /** Put property with 2 arguments by dispid. + */ + void put(DISPID id, const variant_t& a2, const variant_t& a1, const variant_t& val) + { + VARIANT vars[3]; vars[0] = val.in(); vars[1] = a1.in(); vars[2] = a2.in(); + DISPID did = DISPID_PROPERTYPUT; + DISPPARAMS disp = { vars, &did, 3, 1 }; + HRESULT hr = raw(this)->Invoke(id, IID_NULL, LOCALE_USER_DEFAULT, DISPATCH_PROPERTYPUT, &disp, 0, 0, 0); + if (FAILED(hr)) throw_com_error(raw(this), hr); + } + + /** Put property with 2 arguments by name. + */ + void put(const wchar_t* name, const variant_t& a2, const variant_t& a1, const variant_t& val) + { + DISPID id; + HRESULT hr = raw(this)->GetIDsOfNames(IID_NULL, const_cast(&name), 1, LOCALE_USER_DEFAULT, &id); + if (FAILED(hr)) throw_com_error(raw(this), hr); + put(id, a2, a1, val); + } + + /** Put property with 3 arguments by dispid. + */ + void put(DISPID id, const variant_t& a3, const variant_t& a2, const variant_t& a1, const variant_t& val) + { + VARIANT vars[4]; vars[0] = val.in(); vars[1] = a1.in(); vars[2] = a2.in(); vars[3] = a3.in(); + DISPID did = DISPID_PROPERTYPUT; + DISPPARAMS disp = { vars, &did, 4, 1 }; + HRESULT hr = raw(this)->Invoke(id, IID_NULL, LOCALE_USER_DEFAULT, DISPATCH_PROPERTYPUT, &disp, 0, 0, 0); + if (FAILED(hr)) throw_com_error(raw(this), hr); + } + + /** Put property with 3 arguments by name. + */ + void put(const wchar_t* name, const variant_t& a3, const variant_t& a2, const variant_t& a1, const variant_t& val) + { + DISPID id; + HRESULT hr = raw(this)->GetIDsOfNames(IID_NULL, const_cast(&name), 1, LOCALE_USER_DEFAULT, &id); + if (FAILED(hr)) throw_com_error(raw(this), hr); + put(id, a3, a2, a1, val); + } + + /** Put property by reference by dispid. + */ + void putref(DISPID id, const variant_t& val) + { + VARIANT vars[1]; vars[0] = val.in(); + DISPID did = DISPID_PROPERTYPUT; + DISPPARAMS disp = { vars, &did, 1, 1 }; + HRESULT hr = raw(this)->Invoke(id, IID_NULL, LOCALE_USER_DEFAULT, DISPATCH_PROPERTYPUTREF, &disp, 0, 0, 0); + if (FAILED(hr)) throw_com_error(raw(this), hr); + } + + /** Put property by reference by name. + */ + void putref(const wchar_t* name, const variant_t& val) + { + DISPID id; + HRESULT hr = raw(this)->GetIDsOfNames(IID_NULL, const_cast(&name), 1, LOCALE_USER_DEFAULT, &id); + if (FAILED(hr)) throw_com_error(raw(this), hr); + putref(id, val); + } + + void putref(DISPID id, const variant_t& a1, const variant_t& val) + { + VARIANT vars[2]; vars[0] = val.in(); vars[1] = a1.in(); + DISPID did = DISPID_PROPERTYPUT; + DISPPARAMS disp = { vars, &did, 2, 1 }; + HRESULT hr = raw(this)->Invoke(id, IID_NULL, LOCALE_USER_DEFAULT, DISPATCH_PROPERTYPUTREF, &disp, 0, 0, 0); + if (FAILED(hr)) throw_com_error(raw(this), hr); + } + + void putref(const wchar_t* name, const variant_t& a1, const variant_t& val) + { + DISPID id; + HRESULT hr = raw(this)->GetIDsOfNames(IID_NULL, const_cast(&name), 1, LOCALE_USER_DEFAULT, &id); + if (FAILED(hr)) throw_com_error(raw(this), hr); + putref(id, a1, val); + } + + void putref(DISPID id, const variant_t& a2, const variant_t& a1, const variant_t& val) + { + VARIANT vars[3]; vars[0] = val.in(); vars[1] = a1.in(); vars[2] = a2.in(); + DISPID did = DISPID_PROPERTYPUT; + DISPPARAMS disp = { vars, &did, 3, 1 }; + HRESULT hr = raw(this)->Invoke(id, IID_NULL, LOCALE_USER_DEFAULT, DISPATCH_PROPERTYPUTREF, &disp, 0, 0, 0); + if (FAILED(hr)) throw_com_error(raw(this), hr); + } + + void putref(const wchar_t* name, const variant_t& a2, const variant_t& a1, const variant_t& val) + { + DISPID id; + HRESULT hr = raw(this)->GetIDsOfNames(IID_NULL, const_cast(&name), 1, LOCALE_USER_DEFAULT, &id); + if (FAILED(hr)) throw_com_error(raw(this), hr); + putref(id, a2, a1, val); + } + + void putref(DISPID id, const variant_t& a3, const variant_t& a2, const variant_t& a1, const variant_t& val) + { + VARIANT vars[4]; vars[0] = val.in(); vars[1] = a1.in(); vars[2] = a2.in(); vars[3] = a3.in(); + DISPID did = DISPID_PROPERTYPUT; + DISPPARAMS disp = { vars, &did, 4, 1 }; + HRESULT hr = raw(this)->Invoke(id, IID_NULL, LOCALE_USER_DEFAULT, DISPATCH_PROPERTYPUTREF, &disp, 0, 0, 0); + if (FAILED(hr)) throw_com_error(raw(this), hr); + } + + void putref(const wchar_t* name, const variant_t& a3, const variant_t& a2, const variant_t& a1, const variant_t& val) + { + DISPID id; + HRESULT hr = raw(this)->GetIDsOfNames(IID_NULL, const_cast(&name), 1, LOCALE_USER_DEFAULT, &id); + if (FAILED(hr)) throw_com_error(raw(this), hr); + putref(id, a3, a2, a1, val); + } + + /** Call method by dispid. + */ + variant_t call(DISPID id) + { + VARIANT result; + VARIANT* vars = 0; + DISPPARAMS disp = { vars, 0, 0, 0 }; + HRESULT hr = raw(this)->Invoke(id, IID_NULL, LOCALE_USER_DEFAULT, DISPATCH_METHOD, &disp, &result, 0, 0); + if (FAILED(hr)) throw_com_error(raw(this), hr); + return auto_attach(result); + } + + /** Call method by name. + */ + variant_t call(const wchar_t* name) + { + DISPID id; + HRESULT hr = raw(this)->GetIDsOfNames(IID_NULL, const_cast(&name), 1, LOCALE_USER_DEFAULT, &id); + if (FAILED(hr)) throw_com_error(raw(this), hr); + return call(id); + } + + variant_t call(DISPID id, const variant_t& a0) + { + VARIANT result; + VARIANT vars[1]; vars[0] = a0.in(); + DISPPARAMS disp = { vars, 0, 1, 0 }; + HRESULT hr = raw(this)->Invoke(id, IID_NULL, LOCALE_USER_DEFAULT, DISPATCH_METHOD, &disp, &result, 0, 0); + if (FAILED(hr)) throw_com_error(raw(this), hr); + return auto_attach(result); + } + + variant_t call(const wchar_t* name, const variant_t& a0) + { + DISPID id; + HRESULT hr = raw(this)->GetIDsOfNames(IID_NULL, const_cast(&name), 1, LOCALE_USER_DEFAULT, &id); + if (FAILED(hr)) throw_com_error(raw(this), hr); + return call(id, a0); + } + + variant_t call(DISPID id, const variant_t& a1, const variant_t& a0) + { + VARIANT result; + VARIANT vars[2]; vars[0] = a0.in(); vars[1] = a1.in(); + DISPPARAMS disp = { vars, 0, 2, 0 }; + HRESULT hr = raw(this)->Invoke(id, IID_NULL, LOCALE_USER_DEFAULT, DISPATCH_METHOD, &disp, &result, 0, 0); + if (FAILED(hr)) throw_com_error(raw(this), hr); + return auto_attach(result); + } + + variant_t call(const wchar_t* name, const variant_t& a1, const variant_t& a0) + { + DISPID id; + HRESULT hr = raw(this)->GetIDsOfNames(IID_NULL, const_cast(&name), 1, LOCALE_USER_DEFAULT, &id); + if (FAILED(hr)) throw_com_error(raw(this), hr); + return call(id, a1, a0); + } + + variant_t call(DISPID id, const variant_t& a2, const variant_t& a1, const variant_t& a0) + { + VARIANT result; + VARIANT vars[3]; vars[0] = a0.in(); vars[1] = a1.in(); vars[2] = a2.in(); + DISPPARAMS disp = { vars, 0, 3, 0 }; + HRESULT hr = raw(this)->Invoke(id, IID_NULL, LOCALE_USER_DEFAULT, DISPATCH_METHOD, &disp, &result, 0, 0); + if (FAILED(hr)) throw_com_error(raw(this), hr); + return auto_attach(result); + } + + variant_t call(const wchar_t* name, const variant_t& a2, const variant_t& a1, const variant_t& a0) + { + DISPID id; + HRESULT hr = raw(this)->GetIDsOfNames(IID_NULL, const_cast(&name), 1, LOCALE_USER_DEFAULT, &id); + if (FAILED(hr)) throw_com_error(raw(this), hr); + return call(id, a2, a1, a0); + } + + variant_t call(DISPID id, const variant_t& a3, const variant_t& a2, const variant_t& a1, const variant_t& a0) + { + VARIANT result; + VARIANT vars[4]; vars[0] = a0.in(); vars[1] = a1.in(); vars[2] = a2.in(); vars[3] = a3.in(); + DISPPARAMS disp = { vars, 0, 4, 0 }; + HRESULT hr = raw(this)->Invoke(id, IID_NULL, LOCALE_USER_DEFAULT, DISPATCH_METHOD, &disp, &result, 0, 0); + if (FAILED(hr)) throw_com_error(raw(this), hr); + return auto_attach(result); + } + + variant_t call(const wchar_t* name, const variant_t& a3, const variant_t& a2, const variant_t& a1, const variant_t& a0) + { + DISPID id; + HRESULT hr = raw(this)->GetIDsOfNames(IID_NULL, const_cast(&name), 1, LOCALE_USER_DEFAULT, &id); + if (FAILED(hr)) throw_com_error(raw(this), hr); + return call(id, a3, a2, a1, a0); + } + variant_t call(DISPID id, const variant_t& a4, const variant_t& a3, const variant_t& a2, const variant_t& a1, const variant_t& a0) + { + VARIANT result; + VARIANT vars[5]; vars[0] = a0.in(); vars[1] = a1.in(); vars[2] = a2.in(); vars[3] = a3.in(); vars[4] = a4.in(); + DISPPARAMS disp = { vars, 0, 5, 0 }; + HRESULT hr = raw(this)->Invoke(id, IID_NULL, LOCALE_USER_DEFAULT, DISPATCH_METHOD, &disp, &result, 0, 0); + if (FAILED(hr)) throw_com_error(raw(this), hr); + return auto_attach(result); + } + variant_t call(const wchar_t* name, const variant_t& a4, const variant_t& a3, const variant_t& a2, const variant_t& a1, const variant_t& a0) + { + DISPID id; + HRESULT hr = raw(this)->GetIDsOfNames(IID_NULL, const_cast(&name), 1, LOCALE_USER_DEFAULT, &id); + if (FAILED(hr)) throw_com_error(raw(this), hr); + return call(id, a4, a3, a2, a1, a0); + } + }; + /** \class dynamic_dispatch dispatch.h comet/dispatch.h + * Implementation of a dynamic IDispatch, allowing methods to be added to + * an IDispatch implementation. + * The class needs to be inherited from to be able to add methods. + * Each method can have up to 4 parameters. + */ + +template class ATL_NO_VTABLE dynamic_dispatch : public ::IDispatch { + + struct method_ptr { + bool has_retval; + union { + void (BASE::*pm00)(); + void (BASE::*pm01)(const variant_t&); + void (BASE::*pm02)(const variant_t&, const variant_t&); + void (BASE::*pm03)(const variant_t&, const variant_t&, const variant_t&); + void (BASE::*pm04)(const variant_t&, const variant_t&, const variant_t&, const variant_t&); + + variant_t (BASE::*pm10)(); + variant_t (BASE::*pm11)(const variant_t&); + variant_t (BASE::*pm12)(const variant_t&, const variant_t&); + variant_t (BASE::*pm13)(const variant_t&, const variant_t&, const variant_t&); + variant_t (BASE::*pm14)(const variant_t&, const variant_t&, const variant_t&, const variant_t&); + }; + }; + + typedef std::map NAMEMAP; + NAMEMAP name_map_; + + // Workaround VC internal compiler error + struct wrap_map_t { + std::map m; + }; + typedef std::map MAP; + MAP map_; + + void add_method(const wchar_t* name, method_ptr p, DISPID id, int type) + { + if (id == flag_value) + { + NAMEMAP::const_iterator it = name_map_.find(name); + if (it == name_map_.end()) + { + id = 100000 + map_.size(); + while (map_.find(id) != map_.end()) ++id; + } + else + { + id = it->second; + } + } + + name_map_[name] = id; + map_[id].m[type] = p; + } + enum { flag_value = MINLONG }; + public: + typedef ::IDispatch interface_is; + + protected: + + void remove(const wchar_t* name) + { + NAMEMAP::iterator it = name_map_.find(name); + if (it != name_map_.end()) { + DISPID id = it->second; + name_map_.erase(it); + + map_.erase(id); + } + } + + void add_method(const wchar_t* name, void (BASE::*pm)(), DISPID id = flag_value) + { method_ptr p; p.has_retval = false; p.pm00 = pm; add_method( name, p, id, 0 << 16 | DISPATCH_METHOD ); } + + void add_method(const wchar_t* name, void (BASE::*pm)(const variant_t&), DISPID id = flag_value) + { method_ptr p; p.has_retval = false; p.pm01 = pm; add_method( name, p, id, 1 << 16 | DISPATCH_METHOD ); } + + void add_method(const wchar_t* name, void (BASE::*pm)(const variant_t&, const variant_t&), DISPID id = flag_value) + { method_ptr p; p.has_retval = false; p.pm02 = pm; add_method( name, p, id, 2 << 16 | DISPATCH_METHOD ); } + + void add_method(const wchar_t* name, void (BASE::*pm)(const variant_t&, const variant_t&, const variant_t&), DISPID id = flag_value) + { method_ptr p; p.has_retval = false; p.pm03 = pm; add_method( name, p, id, 3 << 16 | DISPATCH_METHOD ); } + + void add_method(const wchar_t* name, void (BASE::*pm)(const variant_t&, const variant_t&, const variant_t&, const variant_t&), DISPID id = flag_value) + { method_ptr p; p.has_retval = false; p.pm04 = pm; add_method( name, p, id, 4 << 16 | DISPATCH_METHOD ); } + + void add_method(const wchar_t* name, variant_t (BASE::*pm)(), DISPID id = flag_value) + { method_ptr p; p.has_retval = true; p.pm10 = pm; add_method( name, p, id, 0 << 16 | DISPATCH_METHOD ); } + + void add_method(const wchar_t* name, variant_t (BASE::*pm)(const variant_t&), DISPID id = flag_value) + { method_ptr p; p.has_retval = true; p.pm11 = pm; add_method( name, p, id, 1 << 16 | DISPATCH_METHOD ); } + + void add_method(const wchar_t* name, variant_t (BASE::*pm)(const variant_t&, const variant_t&), DISPID id = flag_value) + { method_ptr p; p.has_retval = true; p.pm12 = pm; add_method( name, p, id, 2 << 16 | DISPATCH_METHOD ); } + + void add_method(const wchar_t* name, variant_t (BASE::*pm)(const variant_t&, const variant_t&, const variant_t&), DISPID id = flag_value) + { method_ptr p; p.has_retval = true; p.pm13 = pm; add_method( name, p, id, 3 << 16 | DISPATCH_METHOD ); } + + void add_method(const wchar_t* name, variant_t (BASE::*pm)(const variant_t&, const variant_t&, const variant_t&, const variant_t&), DISPID id = flag_value) + { method_ptr p; p.has_retval = true; p.pm14 = pm; add_method( name, p, id, 4 << 16 | DISPATCH_METHOD ); } + + void add_put_property(const wchar_t* name, void (BASE::*pm)(const variant_t&), DISPID id = flag_value) + { method_ptr p; p.has_retval = false; p.pm01 = pm; add_method( name, p, id, 1 << 16 | DISPATCH_PROPERTYPUT ); } + + void add_put_property(const wchar_t* name, void (BASE::*pm)(const variant_t&, const variant_t&), DISPID id = flag_value) + { method_ptr p; p.has_retval = false; p.pm02 = pm; add_method( name, p, id, 2 << 16 | DISPATCH_PROPERTYPUT ); } + + void add_put_property(const wchar_t* name, void (BASE::*pm)(const variant_t&, const variant_t&, const variant_t&), DISPID id = flag_value) + { method_ptr p; p.has_retval = false; p.pm03 = pm; add_method( name, p, id, 3 << 16 | DISPATCH_PROPERTYPUT ); } + + void add_put_property(const wchar_t* name, void (BASE::*pm)(const variant_t&, const variant_t&, const variant_t&, const variant_t&), DISPID id = flag_value) + { method_ptr p; p.has_retval = false; p.pm04 = pm; add_method( name, p, id, 4 << 16 | DISPATCH_PROPERTYPUT ); } + + void add_putref_property(const wchar_t* name, void (BASE::*pm)(const variant_t&), DISPID id = flag_value) + { method_ptr p; p.has_retval = false; p.pm01 = pm; add_method( name, p, id, 1 << 16 | DISPATCH_PROPERTYPUTREF ); } + + void add_putref_property(const wchar_t* name, void (BASE::*pm)(const variant_t&, const variant_t&), DISPID id = flag_value) + { method_ptr p; p.has_retval = false; p.pm02 = pm; add_method( name, p, id, 2 << 16 | DISPATCH_PROPERTYPUTREF ); } + + void add_putref_property(const wchar_t* name, void (BASE::*pm)(const variant_t&, const variant_t&, const variant_t&), DISPID id = flag_value) + { method_ptr p; p.has_retval = false; p.pm03 = pm; add_method( name, p, id, 3 << 16 | DISPATCH_PROPERTYPUTREF ); } + + void add_putref_property(const wchar_t* name, void (BASE::*pm)(const variant_t&, const variant_t&, const variant_t&, const variant_t&), DISPID id = flag_value) + { method_ptr p; p.has_retval = false; p.pm04 = pm; add_method( name, p, id, 4 << 16 | DISPATCH_PROPERTYPUTREF ); } + + void add_get_property(const wchar_t* name, variant_t (BASE::*pm)(), DISPID id = flag_value) + { method_ptr p; p.has_retval = true; p.pm10 = pm; add_method( name, p, id, 0 << 16 | DISPATCH_PROPERTYGET ); } + + void add_get_property(const wchar_t* name, variant_t (BASE::*pm)(const variant_t&), DISPID id = flag_value) + { method_ptr p; p.has_retval = true; p.pm11 = pm; add_method( name, p, id, 1 << 16 | DISPATCH_PROPERTYGET ); } + + void add_get_property(const wchar_t* name, variant_t (BASE::*pm)(const variant_t&, const variant_t&), DISPID id = flag_value) + { method_ptr p; p.has_retval = true; p.pm12 = pm; add_method( name, p, id, 2 << 16 | DISPATCH_PROPERTYGET ); } + + void add_get_property(const wchar_t* name, variant_t (BASE::*pm)(const variant_t&, const variant_t&, const variant_t&), DISPID id = flag_value) + { method_ptr p; p.has_retval = true; p.pm13 = pm; add_method( name, p, id, 3 << 16 | DISPATCH_PROPERTYGET ); } + + void add_get_property(const wchar_t* name, variant_t (BASE::*pm)(const variant_t&, const variant_t&, const variant_t&, const variant_t&), DISPID id = flag_value) + { method_ptr p; p.has_retval = true; p.pm14 = pm; add_method( name, p, id, 4 << 16 | DISPATCH_PROPERTYGET ); } + + private: + STDMETHOD(Invoke)(DISPID id, REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pd, VARIANT* pVarResult, EXCEPINFO* pe, UINT* pu) + { + unsigned type = pd->cArgs << 16 | (wFlags & 15); + typename MAP::const_iterator it2 = map_.find(id); + if (it2 == map_.end()) return DISP_E_MEMBERNOTFOUND; + + typename std::map::const_iterator it = it2->second.m.find(type); + if (it == it2->second.m.end()) return DISP_E_BADPARAMCOUNT; + + try { + + if (pd->cNamedArgs > 1) return DISP_E_NONAMEDARGS; + + if (pd->cNamedArgs == 1) { + + if ((wFlags & 15) != DISPATCH_PROPERTYPUT && (wFlags & 15) != DISPATCH_PROPERTYPUTREF) return DISP_E_NONAMEDARGS; + if (pd->rgdispidNamedArgs[0] != DISPID_PROPERTYPUT) return DISP_E_NONAMEDARGS; + + switch (pd->cArgs) + { + case 1: + (static_cast(this)->*it->second.pm01)(variant_t::create_reference(pd->rgvarg[0])); + break; + case 2: + (static_cast(this)->*it->second.pm02)(variant_t::create_reference(pd->rgvarg[1]), variant_t::create_reference(pd->rgvarg[0])); + break; + case 3: + (static_cast(this)->*it->second.pm03)(variant_t::create_reference(pd->rgvarg[2]), variant_t::create_reference(pd->rgvarg[1]), variant_t::create_reference(pd->rgvarg[0])); + break; + case 4: + (static_cast(this)->*it->second.pm04)(variant_t::create_reference(pd->rgvarg[3]), variant_t::create_reference(pd->rgvarg[2]), variant_t::create_reference(pd->rgvarg[1]), variant_t::create_reference(pd->rgvarg[0])); + break; + default: + return DISP_E_MEMBERNOTFOUND; + } + + } + else + { + + variant_t rv; + if (it->second.has_retval) + { + switch (pd->cArgs) + { + case 0: + rv = (static_cast(this)->*it->second.pm10)(); + break; + case 1: + rv = (static_cast(this)->*it->second.pm11)(variant_t::create_reference(pd->rgvarg[0])); + break; + case 2: + rv = (static_cast(this)->*it->second.pm12)(variant_t::create_reference(pd->rgvarg[1]), variant_t::create_reference(pd->rgvarg[0])); + break; + case 3: + rv = (static_cast(this)->*it->second.pm13)(variant_t::create_reference(pd->rgvarg[2]), variant_t::create_reference(pd->rgvarg[1]), variant_t::create_reference(pd->rgvarg[1])); + break; + case 4: + rv = (static_cast(this)->*it->second.pm14)(variant_t::create_reference(pd->rgvarg[3]), variant_t::create_reference(pd->rgvarg[1]), variant_t::create_reference(pd->rgvarg[2]), variant_t::create_reference(pd->rgvarg[0])); + break; + default: + return DISP_E_MEMBERNOTFOUND; + } + } + else + { + switch (pd->cArgs) + { + case 0: + (static_cast(this)->*it->second.pm00)(); + break; + case 1: + (static_cast(this)->*it->second.pm01)(variant_t::create_reference(pd->rgvarg[0])); + break; + case 2: + (static_cast(this)->*it->second.pm02)(variant_t::create_reference(pd->rgvarg[1]), variant_t::create_reference(pd->rgvarg[0])); + break; + case 3: + (static_cast(this)->*it->second.pm03)(variant_t::create_reference(pd->rgvarg[2]), variant_t::create_reference(pd->rgvarg[1]), variant_t::create_reference(pd->rgvarg[0])); + break; + case 4: + (static_cast(this)->*it->second.pm04)(variant_t::create_reference(pd->rgvarg[3]), variant_t::create_reference(pd->rgvarg[2]), variant_t::create_reference(pd->rgvarg[1]), variant_t::create_reference(pd->rgvarg[0])); + break; + default: + return DISP_E_MEMBERNOTFOUND; + } + } + if (pVarResult) *pVarResult = rv.detach(); + } + + + } catch (com_error& err) { + return impl::return_com_error(err); + } catch (const std::exception& err) { + return impl::return_com_error(err); + } catch (HRESULT hr) { + return hr; + } catch (...) { + return E_FAIL; + } + + return S_OK; + + } + + STDMETHOD(GetIDsOfNames)(REFIID, WCHAR** names, unsigned int c, LCID, DISPID* dispid) + { + bool failed = false; + for (size_t i=0; isecond; + } + } + return failed ? DISP_E_UNKNOWNNAME : S_OK; + } + + STDMETHOD(GetTypeInfo)(UINT, LCID, ITypeInfo**) + { return E_NOTIMPL; } + + STDMETHOD(GetTypeInfoCount)(UINT *it) + { *it = 0; return S_OK; } + + }; +//@} +} + +#endif diff --git a/EyeTab_SP2/comet/enum.h b/EyeTab_SP2/comet/enum.h new file mode 100644 index 0000000..9d3c6d8 --- /dev/null +++ b/EyeTab_SP2/comet/enum.h @@ -0,0 +1,29 @@ +/** \file + * Legacy header for enum-related implementations and iterators. + * + * This exists for backward compatibility only. Include specific headers + * instead. + */ +/* + * Copyright © 2000 Sofus Mortensen + * + * This material is provided "as is", with absolutely no warranty + * expressed or implied. Any use is at your own risk. Permission to + * use or copy this software for any purpose is hereby granted without + * fee, provided the above notices are retained on all copies. + * Permission to modify the code and to distribute modified code is + * granted, provided the above notices are retained, and a notice that + * the code was modified is included with the above copyright notice. + * + * This header is part of Comet version 2. + * https://github.com/alamaison/comet + */ + +#ifndef COMET_ENUM_H +#define COMET_ENUM_H + +#include +#include +#include + +#endif diff --git a/EyeTab_SP2/comet/enum_common.h b/EyeTab_SP2/comet/enum_common.h new file mode 100644 index 0000000..b1d1bcd --- /dev/null +++ b/EyeTab_SP2/comet/enum_common.h @@ -0,0 +1,187 @@ +/** \file + * Code common to enumerator implementations. + */ +/* + * Copyright © 2000 Sofus Mortensen + * + * This material is provided "as is", with absolutely no warranty + * expressed or implied. Any use is at your own risk. Permission to + * use or copy this software for any purpose is hereby granted without + * fee, provided the above notices are retained on all copies. + * Permission to modify the code and to distribute modified code is + * granted, provided the above notices are retained, and a notice that + * the code was modified is included with the above copyright notice. + * + * This header is part of Comet version 2. + * https://github.com/alamaison/comet + */ + +#ifndef COMET_ENUM_IMPL_H +#define COMET_ENUM_IMPL_H + +#include + +#include +#include +#include + +namespace comet { + + namespace impl { + + template struct type_policy; + + template<> struct type_policy + { + template + static void init(VARIANT& t, const S& s) + { ::VariantInit(&t); t = variant_t::detach( variant_t(s) ); } + + static void clear(VARIANT& t) { ::VariantClear(&t); } + }; + + template<> struct type_policy + { + template + static void init(CONNECTDATA& t, const S& s) + { + t.dwCookie = s.first; + t.pUnk = + com_ptr::detach(com_ptr(s.second)); + } + + static void clear(CONNECTDATA& t) { t.pUnk->Release(); } + }; + + template< + typename Itf, typename T, typename CONVERTER, typename Source> + class enumeration : public simple_object + { + typedef type_policy policy; + public: + /// \name Interface \p Itf + //@{ + STDMETHOD(Next)(ULONG celt, T *rgelt, ULONG* pceltFetched) + { + if (pceltFetched) + *pceltFetched = 0; + if (!rgelt) + return E_POINTER; + + UINT i = 0; + typename Source::const_iterator backup_it_ = source_.current(); + try + { + while (i < celt && source_.current() != source_.end()) + { + policy::init(rgelt[i], converter_(*source_.current())); + ++i; + ++source_.current(); + } + if (pceltFetched) + *pceltFetched = i; + } + catch (...) + { + source_.current() = backup_it_; + for (size_t j = 0; j <= i; ++j) + policy::clear(rgelt[j]); + return E_FAIL; + } + + return i == celt ? S_OK : S_FALSE; + } + + STDMETHOD(Reset)() + { + try + { + source_.current() = source_.begin(); + } + catch (...) { return E_FAIL; } + return S_OK; + } + + STDMETHOD(Skip)(ULONG celt) + { + try + { + while (celt--) source_.current()++; + } + catch (...) { return E_FAIL; } + return S_OK; + } + + STDMETHOD(Clone)(Itf** ppenum) + { + try + { + enumeration* new_enum = + new enumeration(source_, converter_); + new_enum->AddRef(); + *ppenum = new_enum; + } + catch (...) { return E_FAIL; } + return S_OK; + } + //@} + + enumeration( + typename Source source, const CONVERTER& converter) + : source_(source), converter_(converter) {} + + Source source_; + CONVERTER converter_; + + private: + enumeration(const enumeration&); + enumeration& operator=(const enumeration&); + }; + + } + + /** \struct enumerated_type_of enum.h comet/enum.h + * Traits wrapper mapping COM Enumeration interface to element. + */ + template struct enumerated_type_of; + + template<> struct enumerated_type_of + { typedef VARIANT is; }; + + template<> struct enumerated_type_of + { typedef IConnectionPoint* is; }; + + template<> struct enumerated_type_of + { typedef CONNECTDATA is; }; + + /** \struct ptr_converter enum.h comet/enum.h + * IUnknown Converter for containers containing Comet objects. + * \relates stl_enumeration + */ + template struct ptr_converter : std::unary_function< com_ptr, T> + { + com_ptr operator()(const T& x) { return impl::cast_to_unknown(x); } + }; + + /** \struct ptr_converter_select1st enum.h comet/enum.h + * IUnknown Converter for containers containing Comet objects as the first + * elment of a pair. + * \relates stl_enumeration + */ + template struct ptr_converter_select1st : std::unary_function< com_ptr, T> + { + com_ptr operator()(const T& x) { return impl::cast_to_unknown(x.first); } + }; + + /** \struct ptr_converter_select2nd enum.h comet/enum.h + * IUnknown Converter for containers containing Comet objects as the second + * elment of a pair. + * \relates stl_enumeration + */ + template struct ptr_converter_select2nd : std::unary_function< com_ptr, T> + { + com_ptr operator()(const T& x) { return impl::cast_to_unknown(x.second); } + }; +} + +#endif diff --git a/EyeTab_SP2/comet/enum_iterator.h b/EyeTab_SP2/comet/enum_iterator.h new file mode 100644 index 0000000..c95a018 --- /dev/null +++ b/EyeTab_SP2/comet/enum_iterator.h @@ -0,0 +1,179 @@ +/** \file + * Standard C++ iterators wrapping any COM enumerator + */ +/* + * Copyright © 2000 Sofus Mortensen + * Copyright © 2011 Alexander Lamaison + * + * This material is provided "as is", with absolutely no warranty + * expressed or implied. Any use is at your own risk. Permission to + * use or copy this software for any purpose is hereby granted without + * fee, provided the above notices are retained on all copies. + * Permission to modify the code and to distribute modified code is + * granted, provided the above notices are retained, and a notice that + * the code was modified is included with the above copyright notice. + * + * This header is part of Comet version 2. + * https://github.com/alamaison/comet + */ + +#ifndef COMET_ENUM_ITERATOR_H +#define COMET_ENUM_ITERATOR_H + +#include + +#include +#include + +#include + +namespace comet { + + /** + * STL style iterator for COM enumerator interfaces + */ + template::is> + class enum_iterator : public std::iterator + { + typedef E enumerator_type; + typedef typename enumerated_type_of::is element_type; + typedef impl::type_policy policy; + + com_ptr enum_; + + static value_type policy_init(const element_type& element) + { + value_type out; + policy::init(out, element); + return out; + } + + static value_type copy_value_from_other(const enum_iterator& other) + { + if (other.is_value_set_) + { + value_type v; + policy::init(v, other.value_); + return v; + } + else + { + return value_type(); + } + } + + value_type value_; + + /** + * Flag that ensures the value only gets cleared if it's been set. + * + * Clearing an uninitialised value could be disastrous as it could + * contain any random bits which the clearing code could interpret as + * pointers. + * + * This could happen in the situation where the enumerator has no + * items so the value never gets set. + */ + bool is_value_set_; + + public: + enum_iterator(const com_ptr& e) : + enum_(e), is_value_set_(false) + { + next(); + } + + enum_iterator() : is_value_set_(false) {} + + enum_iterator(const enum_iterator& other) : + enum_(other.enum_), value_(copy_value_from_other(other)), + is_value_set_(other.is_value_set_) {} + + enum_iterator& operator=(const enum_iterator& other) + { + enum_iterator copy(other); + swap(copy); + return *this; + } + + void swap(enum_iterator& other) + { + enum_.swap(other.enum_); + std::swap(value_, other.value_); + } + + /** Move to next element. */ + enum_iterator& operator++() + { + next(); + return *this; + } + + /** Move to next element (post increment). */ + enum_iterator operator++(int) + { + enum_iterator t(*this); + operator++(); + return t; + } + + /** + * Compare against end. + * Comparisons against a non-end iterator throw an exception. + * \todo Look into doing element comparisons. + */ + bool operator!=(const enum_iterator& other) + { + if (enum_ && other.enum_) + throw std::logic_error( + "enum_iterator comparison does not work"); + + return enum_ || other.enum_; + } + + /** Current element. */ + value_type& operator*() + { + return value_; + } + + value_type* operator->() + { + return &value_; + } + + private: + + void next() + { + if (enum_) + { + unsigned long fetched = 0; + element_type pod; + + enum_->Next(1, &pod, &fetched) | raise_exception; + if (fetched == 0) + { + enum_ = NULL; + return; + } + + try + { + if (is_value_set_) + policy::clear(value_); + value_ = policy_init(pod); + is_value_set_ = true; + } + catch (...) + { + policy::clear(pod); + throw; + } + policy::clear(pod); + } + } + }; +} + +#endif diff --git a/EyeTab_SP2/comet/error.h b/EyeTab_SP2/comet/error.h new file mode 100644 index 0000000..b0c86f7 --- /dev/null +++ b/EyeTab_SP2/comet/error.h @@ -0,0 +1,429 @@ +/** \file + * Provide COM Error support. + */ +/* + * Copyright © 2000, 2001 Sofus Mortensen + * + * This material is provided "as is", with absolutely no warranty + * expressed or implied. Any use is at your own risk. Permission to + * use or copy this software for any purpose is hereby granted without + * fee, provided the above notices are retained on all copies. + * Permission to modify the code and to distribute modified code is + * granted, provided the above notices are retained, and a notice that + * the code was modified is included with the above copyright notice. + * + * This header is part of Comet version 2. + * https://github.com/alamaison/comet + */ + +#ifndef COMET_ERROR_H +#define COMET_ERROR_H + +#include + +#include +#include + +#include +#include +#include +#include + +#pragma warning(push) +#pragma warning(disable : 4290) + +namespace comet { + + namespace impl { + + inline com_ptr GetErrorInfo() throw() + { + IErrorInfo* ei = 0; + ::GetErrorInfo(0, &ei); + return com_ptr(auto_attach(ei)); + } + + inline com_ptr CreateErrorInfo() throw() + { + ICreateErrorInfo* cei = 0; + ::CreateErrorInfo(&cei); + return com_ptr(auto_attach(cei)); + } + + template inline bool supports_ErrorInfo(Itf* p) + { + com_ptr q = com_cast(com_ptr(p)); + if (q == 0) return false; + return S_OK == q->InterfaceSupportsErrorInfo(uuidof()); + } + + } + + + /** \class com_error error.h comet/error.h + * COM error. + */ + class com_error : public std::runtime_error + { + public: + //! Construct com_error from HRESULT. + /*! + \param hr + HRESULT value of error. + */ + explicit com_error(HRESULT hr) : hr_(hr), std::runtime_error("") + {} + + //! Construct com_error from HRESULT and textual description. + /*! + \param msg + Description of error. + \param hr + HRESULT value of error. + */ + explicit com_error(const bstr_t& msg, HRESULT hr = E_FAIL) : hr_(hr), std::runtime_error("") + { + com_ptr cei(impl::CreateErrorInfo()); + if ( !cei.is_null() ) { + try { + cei->SetDescription(msg.in()); + ei_ = com_ptr( com_cast(cei)) ; + } catch (std::bad_alloc&) + {} + } + } + //! Construct com_error from HRESULT, textual description, source, iid, help. + /*! + \param msg Description of error. + \param hr HRESULT value of error. + \param src Description of source line + \param iid Interface the error was on + \param helpFile Name of help file + \param helpContext Name of help Context + */ + explicit com_error(const bstr_t &msg, HRESULT hr, const bstr_t &src, const uuid_t &iid = uuid_t(), + const bstr_t &helpFile=bstr_t(), DWORD helpContext = -1) + : hr_(hr), std::runtime_error("") + { + com_ptr cei(impl::CreateErrorInfo()); + if ( ! cei.is_null() ) + { + try { + cei->SetDescription(msg.in()); + if (!src.is_null() ) + cei->SetSource( src.in() ); + if (iid != uuid_t()) + cei->SetGUID( iid ); + if (!helpFile.is_null()) + { + cei->SetHelpFile( helpFile.in() ); + cei->SetHelpContext( helpContext ); + } + ei_ = com_ptr( com_cast(cei)) ; + } catch (std::bad_alloc&) + {} + } + } + + /// Construct with an error-info and hresult. + explicit com_error(HRESULT hr, const com_ptr& ei) + : hr_(hr), ei_(ei), std::runtime_error("") + {} + + public: + //! Return a string with a description of the error + /*! + what() uses Description from IErrorInfo if such is present, otherwise FormatMessage is used + to create a description of the HRESULT error value. + + \retval + A const char* string with a textual description of the error. + */ + const char* what() const throw() + { + try { + if (what_.empty()) { + what_ = s_str(); + } + } catch (std::bad_alloc&) { + return 0; + } + + return what_.c_str(); + } + /// Returns a std::string with a description of the error. + std::string s_str() const + { + std::string ret; + get_str(ret); + return ret; + } + /// Returns a std::wstring with a description of the error. + std::wstring w_str() const + { + std::wstring ret; + get_str(ret); + return ret; + } + /// Returns a tstring with a description of the error. + tstring t_str() const + { + tstring ret; + get_str(ret); + return ret; + } + + private: + void get_str(std::string& ret) const + { + if (ei_.is_null() == false) + { + bstr_t bs; + if (SUCCEEDED(ei_->GetDescription(bs.out())) && !bs.is_empty()) + { + ret= bs.s_str(); + return; + } + } + + char* lpMsgBuf; + if (FormatMessageA( + FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM | + FORMAT_MESSAGE_IGNORE_INSERTS, NULL, hr_, + MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), // Default language + reinterpret_cast(&lpMsgBuf), 0, NULL)) + { + char* lpEnd = lpMsgBuf; + while (*lpEnd != '\0') + lpEnd++; + + while (lpEnd > lpMsgBuf && // Trim trailing newlines + (*(lpEnd - 1) == '\n' || *(lpEnd - 1) == '\r')) + lpEnd--; + + ret.assign(lpMsgBuf, lpEnd - lpMsgBuf); + LocalFree(lpMsgBuf); + } + } + + void get_str(std::wstring& ret) const + { + if (ei_.is_null() == false) + { + bstr_t bs; + if (SUCCEEDED(ei_->GetDescription(bs.out())) && !bs.is_empty()) + { + ret = bs.w_str(); + return; + } + } + + wchar_t* lpMsgBuf; + if (FormatMessageW( + FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM | + FORMAT_MESSAGE_IGNORE_INSERTS, NULL, hr_, + MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), // Default language + reinterpret_cast(&lpMsgBuf), 0, NULL)) + { + wchar_t* lpEnd = lpMsgBuf; + while (*lpEnd != L'\0') + lpEnd++; + + while (lpEnd > lpMsgBuf && // Trim trailing newlines + (*(lpEnd - 1) == L'\n' || *(lpEnd - 1) == L'\r')) + lpEnd--; + + ret.assign(lpMsgBuf, lpEnd - lpMsgBuf); + LocalFree(lpMsgBuf); + } + } + + public: + + /** Return the HRESULT for the error. + */ + HRESULT hr() const throw() + { + return hr_; + } + + /// \name wrappers for IErrorInfo + //@{ + + /// Description of the error. + bstr_t description() const + { + bstr_t rv; + if (!ei_.is_null()) ei_->GetDescription( rv.out() ) | raise_exception; + return rv; + } + + /// The error source description. + bstr_t source() const + { + bstr_t rv; + if (!ei_.is_null()) ei_->GetSource( rv.out() ) | raise_exception; + return rv; + } + + /// Interface IID. + GUID guid() const + { + GUID rv; + if (!ei_.is_null()) ei_->GetGUID( &rv ) | raise_exception; + else ZeroMemory(&rv, sizeof(rv)); + return rv; + } + + /// Helpfile name. + bstr_t help_file() const + { + bstr_t rv; + if (!ei_.is_null()) ei_->GetHelpFile( rv.out() ) | raise_exception; + return rv; + } + + + /// Help conext. + DWORD help_context() const + { + DWORD rv = 0; + if (!ei_.is_null()) ei_->GetHelpContext( &rv ) | raise_exception; + return rv; + } + //@} + + /// Return the error-info object. + com_ptr get_ei() const + { + return ei_; + } + + private: + mutable std::string what_; + com_ptr ei_; + HRESULT hr_; + }; + + + namespace impl { + + inline HRESULT return_com_error(HRESULT hr, const bstr_t &desc, const bstr_t &src = auto_attach(BSTR(NULL)), + const uuid_t &iid=CLSID_NULL, const bstr_t &helpFile=bstr_t(), DWORD helpContext = -1) + { + com_ptr cei(impl::CreateErrorInfo()); + if (cei.is_null() == false) { + try { + cei->SetDescription(desc.in()); + if (!src.is_null() ) + cei->SetSource( src.in() ); + if (iid != uuid_t()) + cei->SetGUID( iid ); + if (!helpFile.is_null()) + { + cei->SetHelpFile( helpFile.in() ); + cei->SetHelpContext( helpContext ); + } + com_ptr ei = com_cast(cei); + ::SetErrorInfo(0, ei.in()); + } catch (std::bad_alloc&) + {} + } + return hr; + } + inline HRESULT return_com_error(const std::exception& err, const bstr_t &src = auto_attach(BSTR(NULL)), + const uuid_t &iid=CLSID_NULL, const bstr_t &helpFile=bstr_t(), DWORD helpContext = -1) + { + return return_com_error( E_FAIL, bstr_t(err.what()),src,iid,helpFile, helpContext ); + } + inline HRESULT return_com_error(const com_error& err, const bstr_t &src = bstr_t(), const uuid_t &iid = CLSID_NULL) throw() + { + const bstr_t &cursrc =err.source(); + const uuid_t &curiid =err.guid(); + // Return error info with more info. + return return_com_error( err.hr(), err.description(), cursrc.is_null()?src:cursrc, + curiid.is_null()?iid:curiid, err.help_file(), err.help_context()); + } + + + inline void throw_com_error_(HRESULT hr, const com_ptr& ei) + { + throw_error_handler::throw_error(hr, ei); + } + + // Raising an HRESULT with a message + inline void raise_exception_t::operator()(const bstr_t& msg, HRESULT hr/* = E_FAIL*/) const + { + throw com_error(msg, hr); + } + + // Raising an HRESULT + inline void raise_exception_t::operator()(HRESULT hr) const + { + throw com_error(hr); + } + + } // namespace impl + + /*! \addtogroup ErrorHandling + */ + //@{ + + /** Throw COM error using com_error, using HRESULT and IErrorInfo. + */ + template inline void throw_com_error(Itf* p, HRESULT hr) + { + if (impl::supports_ErrorInfo(p)) + { + com_ptr ei = impl::GetErrorInfo(); + if (ei.is_null() == false) impl::throw_com_error_(hr, ei); + } + throw com_error(hr); + } + + template + inline void throw_error_handler::throw_error(HRESULT hr, const com_ptr &ei) + { + throw com_error(hr, ei); + } + + /** + * Construct exception for a method called on a raw COM interface. + * + * This method aims to imbue the com_error with as much information about + * the failure as possible: + * - If the interface supports IErrorInfo, the information is taken from + * the last ErrorInfo set on the current thread. + * - If not, the HRESULT alone determines the message. + * + * Use this constructor immediately after an interface returns a + * failure code before any other code can call SetErrorInfo and + * overwrite the error. + * + * \param failure_source Interface operator method returned a failure code. + * \param hr HRESULT value of error. + * + * \todo Can we add an optional user-defined message to this? + */ + template + com_error com_error_from_interface(Itf* failure_source, HRESULT hr) + { + if (impl::supports_ErrorInfo(failure_source)) + return com_error(hr, impl::GetErrorInfo()); + else + return com_error(hr); + } + + template + com_error com_error_from_interface( + com_ptr failure_source, HRESULT hr) + { + return com_error_from_interface(failure_source.get(), hr); + } + + //@} +} + +#pragma warning(pop) + +#endif diff --git a/EyeTab_SP2/comet/error_fwd.h b/EyeTab_SP2/comet/error_fwd.h new file mode 100644 index 0000000..9a71c8c --- /dev/null +++ b/EyeTab_SP2/comet/error_fwd.h @@ -0,0 +1,119 @@ +/** \file + * Error forwarding - using operator|. + */ +/* + * Copyright © 2000, 2001 Sofus Mortensen + * + * This material is provided "as is", with absolutely no warranty + * expressed or implied. Any use is at your own risk. Permission to + * use or copy this software for any purpose is hereby granted without + * fee, provided the above notices are retained on all copies. + * Permission to modify the code and to distribute modified code is + * granted, provided the above notices are retained, and a notice that + * the code was modified is included with the above copyright notice. + * + * This header is part of Comet version 2. + * https://github.com/alamaison/comet + */ + +#ifndef COMET_ERROR_FWD_H +#define COMET_ERROR_FWD_H + +#include + +#include +#include + +#include + +#pragma warning(push) +#pragma warning(disable : 4290) + +namespace comet { + template class com_ptr; + class bstr_t; + + class com_error; + /*! \addtogroup ErrorHandling + */ + //@{ + namespace impl { + class raise_exception_t + { + public: + // Raising a std::exception + // inline void operator()(const std::exception& err) const; + + // Raising an HRESULT with a message + inline void operator()(const bstr_t& msg, HRESULT hr = E_FAIL) const; + + // Raising an HRESULT + inline void operator()(HRESULT hr) const; + }; + + } + + //! Raise exception "function" + /*! + raise_exception can by used in two different ways: + + First example. The 'do or die' paradigm using overloaded operator|. + Here try() is a function that returns an HRESULT. If try fails an exception will be raised. + \code + try() | raise_exception; + \endcode + + Second example. Using raise_exception as an exception throwing function. + \code + raise_exception(E_POINTER); + raise_exception(L"Ran out of toilet paper!", E_FAIL); + \endcode + + */ + static impl::raise_exception_t raise_exception; + + //! Overload for the 'do or die' useage of raise_exception. + /*! + \code + try() | raise_exception; + \endcode + */ + + namespace impl{ + inline HRESULT operator|(HRESULT hr, const impl::raise_exception_t&) + {if (FAILED(hr)) raise_exception(hr); return hr; } + } + using impl::operator|; + + /**! \struct throw_error_handler error_fwd.h comet\error_fwd.h + * Overridable error info handling. + * To override the error handling, use code like this, making sure + * that you define the handler before including comet/error.h. + \code + #include + template<> struct throw_error_handler + { + static inline void throw_error(HRESULT hr, const com_ptr &ei); + }; + #include + // #include + template<> + inline void throw_error_handler::throw_error(HRESULT hr, const com_ptr &ei) + { + .... Override here .... + } + \endcode + */ + + template + struct throw_error_handler + { + /// Called to throw the error. + static inline void throw_error(HRESULT hr, const com_ptr &ei); + }; + //@} +} + +#pragma warning(pop) + +#endif diff --git a/EyeTab_SP2/comet/exe_server.h b/EyeTab_SP2/comet/exe_server.h new file mode 100644 index 0000000..5d53fae --- /dev/null +++ b/EyeTab_SP2/comet/exe_server.h @@ -0,0 +1,292 @@ +/** \file + * exe-server classes. + */ +/* + * Copyright © 2001, 2002 Mikael Lindgren, Sofus Mortensen + * + * This material is provided "as is", with absolutely no warranty + * expressed or implied. Any use is at your own risk. Permission to + * use or copy this software for any purpose is hereby granted without + * fee, provided the above notices are retained on all copies. + * Permission to modify the code and to distribute modified code is + * granted, provided the above notices are retained, and a notice that + * the code was modified is included with the above copyright notice. + * + * This header is part of Comet version 2. + * https://github.com/alamaison/comet + */ + +#ifndef COMET_EXE_SERVER_H +#define COMET_EXE_SERVER_H + +#include +#include + +namespace comet { + + namespace impl { + template struct register_class_entry + { + typedef COMET_STRICT_TYPENAME CLS_LIST::head CLASS; + typedef COMET_STRICT_TYPENAME CLS_LIST::tail NEXT; + + template struct register_info + { + DWORD id; + }; + + static register_info& get_register_info() + { + static register_info info; + return info; + } + COMET_FORCEINLINE static HRESULT register_class_object(DWORD context, DWORD flags) + { + const IID& clsid = comtype::uuid(); + ::IUnknown* p = impl::coclass_table_entry::factory::get(clsid); + if (p) + { + HRESULT hr = ::CoRegisterClassObject(clsid, p, context, flags, &get_register_info().id); + p->Release(); + if (hr != S_OK) + return hr; + } + return register_class_entry::register_class_object(context, flags); + } + + COMET_FORCEINLINE static void revoke_class_object() + { + ::CoRevokeClassObject(get_register_info().id); + register_class_entry::revoke_class_object(); + } + }; + + template <> struct register_class_entry + { + COMET_FORCEINLINE static HRESULT register_class_object(DWORD context, DWORD flags) + { + COMET_NOTUSED(context); + COMET_NOTUSED(flags); + return S_OK; + } + + COMET_FORCEINLINE static void revoke_class_object() + { + } + }; + }; + + /*! \addtogroup Server + */ + //@{ + + //! Define an EXE server + template > class exe_server : private thread + { +#if !(_WIN32_WINNT >= 0x0400 ) && !defined(_WIN32_DCOM) + // Implementing a free threaded exe server requires NT 4.0 or better. + COMET_STATIC_ASSERT(FREE_THREADED == false); +#endif + + typedef coclass_table COCLASS_TABLE; + + enum { terminate_pause = 1000, idle_shutdown_time = 5000 }; + + public: + exe_server(HINSTANCE instance); + exe_server(HINSTANCE instance, const GUID& appid, const tstring& appid_descr); + ~exe_server(); + + HRESULT run(); + + HRESULT register_server(); + HRESULT unregister_server(); + HRESULT register_class_objects(DWORD context, DWORD flags); + void revoke_class_objects(); + + private: + event shutdown_event_; + DWORD main_thread_id_; + const GUID* appid_; + tstring appid_descr_; + + virtual DWORD thread_main(); + }; + //@} + + template + exe_server::exe_server(HINSTANCE instance): + main_thread_id_(::GetCurrentThreadId()), + appid_(0) + { + module_t& m = module(); + + m.instance(instance); + m.set_shutdown_event(shutdown_event_); + + // initialize static variables in factory::get to avoid potential thread safety problem. + ::IUnknown* cf = COCLASS_TABLE::find(IID_NULL); + } + + template + exe_server::exe_server(HINSTANCE instance, const GUID& appid, const tstring& appid_descr): + main_thread_id_(::GetCurrentThreadId()), + appid_(&appid), appid_descr_(appid_descr) + { + module_t& m = module(); + + m.instance(instance); + m.set_shutdown_event(shutdown_event_); + + // initialize static variables in factory::get to avoid potential thread safety problem. + ::IUnknown* cf = COCLASS_TABLE::find(IID_NULL); + } + + template + exe_server::~exe_server() + { + module().clear_shutdown_event(); + } + + template + HRESULT exe_server::run() + { + thread::start(); + + HRESULT hr; +#if (_WIN32_WINNT >= 0x0400 ) || defined(_WIN32_DCOM) // DCOM + if (FREE_THREADED) + { + hr = register_class_objects(CLSCTX_LOCAL_SERVER, REGCLS_MULTIPLEUSE|REGCLS_SUSPENDED); + if (SUCCEEDED(hr)) + hr = ::CoResumeClassObjects(); + } + else +#endif + hr = register_class_objects(CLSCTX_LOCAL_SERVER, REGCLS_MULTIPLEUSE); + + if (SUCCEEDED(hr)) + { + MSG msg; + while (::GetMessage(&msg, 0, 0, 0)) + ::DispatchMessage(&msg); + } + else if (thread::running()) + { + shutdown_event_.set(); + thread::wait(0); + } + + revoke_class_objects(); + Sleep(terminate_pause); //wait for any threads to finish + + module().shutdown(); + + return hr; + } + + template + HRESULT exe_server::register_server() + { + TCHAR filename[MAX_PATH]; + + GetModuleFileName(module().instance(), filename, MAX_PATH); + + { + HRESULT hr = impl::typelibrary_registration::perform(filename, false); + if(FAILED(hr)) return SELFREG_E_TYPELIB; + } + + try { + if (appid_) + { + tstring key(_T("AppID\\{") + uuid_t(*appid_).str() + _T("}")); + + regkey rkey(HKEY_CLASSES_ROOT); + rkey.create(key)[_T("")] = appid_descr_; + } + COCLASS_TABLE::registration(filename, false, false, appid_); + } + catch (const com_error &e) + { + unregister_server(); + return impl::return_com_error(e); + } + catch (const std::exception &e) + { + unregister_server(); + ::OutputDebugStringA(e.what()); + return E_FAIL; + } + + return S_OK; + } + + template + HRESULT exe_server::unregister_server() + { + TCHAR filename[MAX_PATH]; + GetModuleFileName(module().instance(), filename, MAX_PATH); + + impl::typelibrary_registration::perform(filename, true); + + if (appid_) + { + tstring key(_T("AppID\\{") + uuid_t(*appid_).str() + _T("}")); + + regkey rkey(HKEY_CLASSES_ROOT); + rkey.delete_subkey_nothrow(key); + } + COCLASS_TABLE::registration(filename, true, false, appid_); + return S_OK; + } + + template + HRESULT exe_server::register_class_objects(DWORD context, DWORD flags) + { + return impl::register_class_entry::register_class_object(context, flags); + } + + template + void exe_server::revoke_class_objects() + { + impl::register_class_entry::revoke_class_object(); + } + + template + DWORD exe_server::thread_main() + { + module_t& m = module(); + + while (1) + { + shutdown_event_.wait(); + do + { + m.reset_activity_flag(); + } while (shutdown_event_.wait(idle_shutdown_time)); + // timed out + + if (!m.has_activity()) // if no activity let's really bail + { +#if (_WIN32_WINNT >= 0x0400 ) || defined(_WIN32_DCOM) // DCOM + if (FREE_THREADED) + { + ::CoSuspendClassObjects(); + if (!m.has_activity()) + break; + } + else + break; +#else + break; +#endif + } + } + ::PostThreadMessage(main_thread_id_, WM_QUIT, 0, 0); + return 0; + } +}; + + +#endif diff --git a/EyeTab_SP2/comet/functor.h b/EyeTab_SP2/comet/functor.h new file mode 100644 index 0000000..56a36f3 --- /dev/null +++ b/EyeTab_SP2/comet/functor.h @@ -0,0 +1,1341 @@ +/** \file + * Functor implementation. + * + * functor.h is based on the functor library presented in Chapter 5 of + * "Modern C++ Design" by Andrei Alexandrescu. + * + */ + +/* + * Copyright © 2001 Sofus Mortensen, Michael Geddes + * + * This material is provided "as is", with absolutely no warranty + * expressed or implied. Any use is at your own risk. Permission to + * use or copy this software for any purpose is hereby granted without + * fee, provided the above notices are retained on all copies. + * Permission to modify the code and to distribute modified code is + * granted, provided the above notices are retained, and a notice that + * the code was modified is included with the above copyright notice. + * + * This header is part of Comet version 2. + * https://github.com/alamaison/comet + */ + +#ifndef COMET_FUNCTOR_H +#define COMET_FUNCTOR_H + +#include +#include +#include +#include + +namespace comet { + /*! \addtogroup Misc + */ + //@{ + +#ifdef COMET_PARTIAL_SPECIALISATION + +namespace detail { + + template struct parameter_type_aux + { + typedef const T& result; + }; + + template struct parameter_type_aux + { + typedef T result; + }; + +}; + +/** \struct parameter_type functor.h comet/functor.h + * Gives us a reference to a type. If the type is already a reference, then + * just returns the type. + */ +template struct parameter_type +{ + enum { is_ref = type_traits::is_reference::value }; + /// A reference to \p T or \p T if it is already a reference. + typedef typename detail::parameter_type_aux< (is_ref!=0) ,T >::result result; +}; +#else // COMET_PARTIAL_SPECIALISATION +namespace detail { + + template struct parameter_type_aux + { + template struct X + { + typedef const T& result; + }; + }; + + template<> struct parameter_type_aux + { + template struct X + { + typedef T result; + }; + }; + +}; + +template struct parameter_type +{ + enum { is_ref = type_traits::is_reference::value }; + typedef detail::parameter_type_aux< (is_ref!=0) >::X::result result; +}; +#endif // COMET_PARTIAL_SPECIALISATION + +#ifndef COMET_PARTIAL_SPECIALISATION + +#define COMET_PARTIAL_NAME( name ) X +#define COMET_PARTIAL_NS_1(A) >::X +#define COMET_PARTIAL_NS_2(A,B) >::X +#define COMET_PARTIAL_NS_3(A,B,C) >::X + +#define COMET_DEFINE_PARTIAL( X1, X2 , name) \ +template < X1 > struct name\ +{ \ + template < X2 > class X + +#define COMET_SPECIALISE_PARTIAL( SX1, X2 , name) \ +template <> struct name\ +{ \ + template < X2 > class X + +#define COMET_DEFINE_PARTIAL2( X1, X2, X3 , name) \ +template < X1 > struct name\ +{ \ + template < X2, X3 > class X + +#define COMET_SPECIALISE_PARTIAL2( SX1, X2, X3 , name) \ +template <> struct name\ +{ \ + template < X2, X3 > class X + +#define COMET_DEFINE_PARTIAL3( X1, X2, X3, X4 , name) \ +template < X1 > struct name\ +{ \ + template < X2, X3, X4 > class X + +#define COMET_SPECIALISE_PARTIAL3( SX1, X2, X3, X4 , name) \ +template <> struct name\ +{ \ + template < X2, X3, X4 > class X + + +#define COMET_CLOSE_PARTIAL() }; + +#else + +#define COMET_PARTIAL_NAME( name ) name +#define COMET_PARTIAL_NS_1(A) ,A> +#define COMET_PARTIAL_NS_2(A,B) ,A,B> +#define COMET_PARTIAL_NS_3(A,B,C) ,A,B,C> + +#define COMET_CLOSE_PARTIAL() + +#define COMET_PARTIAL_CONSTRUCTOR( name ) name + +#define COMET_DEFINE_PARTIAL(TN1, X1, TN2, X2 , name) \ +template class name + +#define COMET_SPECIALISE_PARTIAL( SX1, TN2,X2 , name) \ +template < TN2 X2 > class name + +#define COMET_DEFINE_PARTIAL2( TN1,X1,TN2,X2,TN3,X3 , name) \ +template class name + +#define COMET_SPECIALISE_PARTIAL2( SX1, TN2,X2, TN3,X3 , name) \ +template < TN2 X2, TN3 X3 > class name + +#define COMET_DEFINE_PARTIAL3(TN1,X1, TN2,X2, TN3,X3, TN4,X4 , name) \ +template < TN1 X1, TN2 X2, TN3 X3,TN4 X4 > class name + +#define COMET_SPECIALISE_PARTIAL3( SX1, TN2,X2, TN3,X3, TN4,X4 , name) \ +template < TN2 X2, TN3 X3, TN4 X4 > class name + +#endif + +/** \struct parameter_types functor.h comet/functor.h + * Gives the parameter type of parameters 1 thru 16. + * This gaurantees the arguments pass by reference, without breaking if it is already a + * reference. + * \sa parameter_type + */ +template struct parameter_types +{ + typedef typename parameter_type< typename typelist::type_at::result >::result PARM_1; + typedef typename parameter_type< typename typelist::type_at::result >::result PARM_2; + typedef typename parameter_type< typename typelist::type_at::result >::result PARM_3; + typedef typename parameter_type< typename typelist::type_at::result >::result PARM_4; + typedef typename parameter_type< typename typelist::type_at::result >::result PARM_5; + typedef typename parameter_type< typename typelist::type_at::result >::result PARM_6; + typedef typename parameter_type< typename typelist::type_at::result >::result PARM_7; + typedef typename parameter_type< typename typelist::type_at::result >::result PARM_8; + typedef typename parameter_type< typename typelist::type_at::result >::result PARM_9; + typedef typename parameter_type< typename typelist::type_at::result >::result PARM_10; + typedef typename parameter_type< typename typelist::type_at::result >::result PARM_11; + typedef typename parameter_type< typename typelist::type_at::result >::result PARM_12; + typedef typename parameter_type< typename typelist::type_at::result >::result PARM_13; + typedef typename parameter_type< typename typelist::type_at::result >::result PARM_14; + typedef typename parameter_type< typename typelist::type_at::result >::result PARM_15; + typedef typename parameter_type< typename typelist::type_at::result >::result PARM_16; +}; + +template class functor_impl; + + +/** \struct functor_impl_aux functor.h comet/functor.h + * Virtual interface for functor implementation. + * Provide partial specialisation of functor_impl to parameter type. + * \param L number of arguments. + * \param R Return type. + * \param LIST Argument list. + */ +COMET_DEFINE_PARTIAL2( int,L,typename,R,typename,LIST,functor_impl_aux) : public parameter_types +{ + /** Virtual override to call the function. + * \param arguments Whatever arguments provided by \a LIST + * \return Return type is \a R + */ + virtual R operator()( nil arguments ) = 0; + + /** Clone the functor. (easiest way of managing memory - should only be + * a light implementation anyway). + */ + virtual functor_impl* clone() const = 0; + /** Provide virtual destruction. + */ + virtual ~COMET_PARTIAL_NAME(functor_impl_aux)() {} +}; +COMET_CLOSE_PARTIAL() + + +COMET_SPECIALISE_PARTIAL2( 0, typename,R, typename,LIST, functor_impl_aux) : public parameter_types +{ +public: + virtual R operator()( ) = 0; + virtual functor_impl* clone() const = 0; + virtual ~COMET_PARTIAL_NAME(functor_impl_aux)() {} +}; +COMET_CLOSE_PARTIAL() + +COMET_SPECIALISE_PARTIAL2(1, typename,R, typename,LIST, functor_impl_aux) : public parameter_types +{ +public: + virtual R operator()( PARM_1 ) = 0; + virtual functor_impl* clone() const = 0; + virtual ~COMET_PARTIAL_NAME(functor_impl_aux)() {} +}; +COMET_CLOSE_PARTIAL() + +COMET_SPECIALISE_PARTIAL2(2, typename,R, typename,LIST, functor_impl_aux) : public parameter_types +{ +public: + virtual R operator()( PARM_1, PARM_2 ) = 0; + virtual functor_impl* clone() const = 0; + virtual ~COMET_PARTIAL_NAME(functor_impl_aux)() {} +}; +COMET_CLOSE_PARTIAL() + +COMET_SPECIALISE_PARTIAL2(3, typename,R, typename,LIST, functor_impl_aux) : public parameter_types +{ +public: + virtual R operator()( PARM_1, PARM_2, PARM_3 ) = 0; + virtual functor_impl* clone() const = 0; + virtual ~COMET_PARTIAL_NAME(functor_impl_aux)() {} +}; +COMET_CLOSE_PARTIAL() + +COMET_SPECIALISE_PARTIAL2(4, typename,R, typename,LIST,functor_impl_aux) : public parameter_types +{ +public: + virtual R operator()( PARM_1, PARM_2, PARM_3, PARM_4 ) = 0; + virtual functor_impl* clone() const = 0; + virtual ~COMET_PARTIAL_NAME(functor_impl_aux)() {} +}; +COMET_CLOSE_PARTIAL() + +COMET_SPECIALISE_PARTIAL2(5,typename,R, typename,LIST,functor_impl_aux) : public parameter_types +{ +public: + virtual R operator()( PARM_1, PARM_2, PARM_3, PARM_4, PARM_5 ) = 0; + virtual functor_impl* clone() const = 0; + virtual ~COMET_PARTIAL_NAME(functor_impl_aux)() {} +}; +COMET_CLOSE_PARTIAL() + +COMET_SPECIALISE_PARTIAL2(6, typename,R, typename,LIST, functor_impl_aux) : public parameter_types +{ +public: + virtual R operator()( PARM_1, PARM_2, PARM_3, PARM_4, PARM_5, PARM_6 ) = 0; + virtual functor_impl* clone() const = 0; + virtual ~COMET_PARTIAL_NAME(functor_impl_aux)() {} +}; +COMET_CLOSE_PARTIAL() + +COMET_SPECIALISE_PARTIAL2(7, typename,R, typename,LIST, functor_impl_aux) : public parameter_types +{ +public: + virtual R operator()( PARM_1, PARM_2, PARM_3, PARM_4, PARM_5, PARM_6, PARM_7 ) = 0; + virtual functor_impl* clone() const = 0; + virtual ~COMET_PARTIAL_NAME(functor_impl_aux)() {} +}; +COMET_CLOSE_PARTIAL() + +COMET_SPECIALISE_PARTIAL2(8, typename,R, typename,LIST, functor_impl_aux) : public parameter_types +{ +public: + virtual R operator()( PARM_1, PARM_2, PARM_3, PARM_4, PARM_5, PARM_6, PARM_7, PARM_8 ) = 0; + virtual functor_impl* clone() const = 0; + virtual ~COMET_PARTIAL_NAME(functor_impl_aux)() {} +}; +COMET_CLOSE_PARTIAL() + +COMET_SPECIALISE_PARTIAL2(9, typename,R, typename,LIST, functor_impl_aux) : public parameter_types +{ +public: + virtual R operator()( PARM_1, PARM_2, PARM_3, PARM_4, PARM_5, PARM_6, PARM_7, PARM_8, PARM_9 ) = 0; + virtual functor_impl* clone() const = 0; + virtual ~COMET_PARTIAL_NAME(functor_impl_aux)() {} +}; +COMET_CLOSE_PARTIAL() + +COMET_SPECIALISE_PARTIAL2(10, typename,R, typename,LIST, functor_impl_aux) : public parameter_types +{ +public: + virtual R operator()( PARM_1, PARM_2, PARM_3, PARM_4, PARM_5, PARM_6, PARM_7, PARM_8, PARM_9, PARM_10 ) = 0; + virtual functor_impl* clone() const = 0; + virtual ~COMET_PARTIAL_NAME(functor_impl_aux)() {} +}; +COMET_CLOSE_PARTIAL() + +COMET_SPECIALISE_PARTIAL2(11, typename,R, typename,LIST, functor_impl_aux) : public parameter_types +{ +public: + virtual R operator()( PARM_1, PARM_2, PARM_3, PARM_4, PARM_5, PARM_6, PARM_7, PARM_8, PARM_9, PARM_10, PARM_11 ) = 0; + virtual functor_impl* clone() const = 0; + virtual ~COMET_PARTIAL_NAME(functor_impl_aux)() {} +}; +COMET_CLOSE_PARTIAL() + +COMET_SPECIALISE_PARTIAL2(12, typename,R, typename,LIST, functor_impl_aux) : public parameter_types +{ +public: + virtual R operator()( PARM_1, PARM_2, PARM_3, PARM_4, PARM_5, PARM_6, PARM_7, PARM_8, PARM_9, PARM_10, PARM_11, PARM_12 ) = 0; + virtual functor_impl* clone() const = 0; + virtual ~COMET_PARTIAL_NAME(functor_impl_aux)() {} +}; +COMET_CLOSE_PARTIAL() + +COMET_SPECIALISE_PARTIAL2(13, typename,R, typename,LIST, functor_impl_aux) : public parameter_types +{ +public: + virtual R operator()( PARM_1, PARM_2, PARM_3, PARM_4, PARM_5, PARM_6, PARM_7, PARM_8, PARM_9, PARM_10, PARM_11, PARM_12, PARM_13 ) = 0; + virtual functor_impl* clone() const = 0; + virtual ~COMET_PARTIAL_NAME(functor_impl_aux)() {} +}; +COMET_CLOSE_PARTIAL() + +COMET_SPECIALISE_PARTIAL2(14, typename,R, typename,LIST, functor_impl_aux) : public parameter_types +{ +public: + virtual R operator()( PARM_1, PARM_2, PARM_3, PARM_4, PARM_5, PARM_6, PARM_7, PARM_8, PARM_9, PARM_10, PARM_11, PARM_12, PARM_13, PARM_14 ) = 0; + virtual functor_impl* clone() const = 0; + virtual ~COMET_PARTIAL_NAME(functor_impl_aux)() {} +}; +COMET_CLOSE_PARTIAL() + +COMET_SPECIALISE_PARTIAL2(15, typename,R, typename,LIST, functor_impl_aux) : public parameter_types +{ +public: + virtual R operator()( PARM_1, PARM_2, PARM_3, PARM_4, PARM_5, PARM_6, PARM_7, PARM_8, PARM_9, PARM_10, PARM_11, PARM_12, PARM_13, PARM_14, PARM_15 ) = 0; + virtual functor_impl* clone() const = 0; + virtual ~COMET_PARTIAL_NAME(functor_impl_aux)() {} +}; +COMET_CLOSE_PARTIAL() + +COMET_SPECIALISE_PARTIAL2(16, typename,R, typename,LIST, functor_impl_aux) : public parameter_types +{ +public: + virtual R operator()( PARM_1, PARM_2, PARM_3, PARM_4, PARM_5, PARM_6, PARM_7, PARM_8, PARM_9, PARM_10, PARM_11, PARM_12, PARM_13, PARM_14, PARM_15, PARM_16 ) = 0; + virtual functor_impl* clone() const = 0; + virtual ~COMET_PARTIAL_NAME(functor_impl_aux)() {} +}; +COMET_CLOSE_PARTIAL() + + +/** \struct functor_handler functor.h comet/functor.h + * Provide implementation of functor_impl virtual type for functions. + * The implementation is effectively 'partially specialised' to return type. + */ +COMET_DEFINE_PARTIAL2(typename,RT, typename,PF, typename,FUN, functor_handler) + : public functor_impl< typename PF::result_type, typename PF::parm_list > +{ +public: + typedef typename PF::result_type result_type; + + COMET_PARTIAL_NAME(functor_handler)(const FUN& fun) : fun_(fun) {} + functor_impl< typename PF::result_type, typename PF::parm_list >* clone() const + { return new COMET_PARTIAL_NAME(functor_handler)(*this); } + + result_type operator()( ) + { return fun_( ); } + + result_type operator()( typename PF::PARM_1 p1 ) + { return fun_( p1 ); } + + result_type operator()( typename PF::PARM_1 p1, typename PF::PARM_2 p2 ) + { return fun_( p1, p2 ); } + + result_type operator()( typename PF::PARM_1 p1, typename PF::PARM_2 p2, typename PF::PARM_3 p3 ) + { return fun_( p1, p2, p3 ); } + + result_type operator()( typename PF::PARM_1 p1, typename PF::PARM_2 p2, typename PF::PARM_3 p3, typename PF::PARM_4 p4 ) + { return fun_( p1, p2, p3, p4 ); } + + result_type operator()( typename PF::PARM_1 p1, typename PF::PARM_2 p2, typename PF::PARM_3 p3, typename PF::PARM_4 p4, typename PF::PARM_5 p5 ) + { return fun_( p1, p2, p3, p4, p5 ); } + + result_type operator()( typename PF::PARM_1 p1, typename PF::PARM_2 p2, typename PF::PARM_3 p3, typename PF::PARM_4 p4, typename PF::PARM_5 p5, typename PF::PARM_6 p6 ) + { return fun_( p1, p2, p3, p4, p5, p6 ); } + + result_type operator()( typename PF::PARM_1 p1, typename PF::PARM_2 p2, typename PF::PARM_3 p3, typename PF::PARM_4 p4, typename PF::PARM_5 p5, typename PF::PARM_6 p6, typename PF::PARM_7 p7 ) + { return fun_( p1, p2, p3, p4, p5, p6, p7 ); } + + result_type operator()( typename PF::PARM_1 p1, typename PF::PARM_2 p2, typename PF::PARM_3 p3, typename PF::PARM_4 p4, typename PF::PARM_5 p5, typename PF::PARM_6 p6, typename PF::PARM_7 p7, typename PF::PARM_8 p8 ) + { return fun_( p1, p2, p3, p4, p5, p6, p7, p8 ); } + + result_type operator()( typename PF::PARM_1 p1, typename PF::PARM_2 p2, typename PF::PARM_3 p3, typename PF::PARM_4 p4, typename PF::PARM_5 p5, typename PF::PARM_6 p6, typename PF::PARM_7 p7, typename PF::PARM_8 p8, typename PF::PARM_9 p9 ) + { return fun_( p1, p2, p3, p4, p5, p6, p7, p8, p9 ); } + + result_type operator()( typename PF::PARM_1 p1, typename PF::PARM_2 p2, typename PF::PARM_3 p3, typename PF::PARM_4 p4, typename PF::PARM_5 p5, typename PF::PARM_6 p6, typename PF::PARM_7 p7, typename PF::PARM_8 p8, typename PF::PARM_9 p9, typename PF::PARM_10 p10 ) + { return fun_( p1, p2, p3, p4, p5, p6, p7, p8, p9, p10 ); } + + result_type operator()( typename PF::PARM_1 p1, typename PF::PARM_2 p2, typename PF::PARM_3 p3, typename PF::PARM_4 p4, typename PF::PARM_5 p5, typename PF::PARM_6 p6, typename PF::PARM_7 p7, typename PF::PARM_8 p8, typename PF::PARM_9 p9, typename PF::PARM_10 p10, typename PF::PARM_11 p11 ) + { return fun_( p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11 ); } + + result_type operator()( typename PF::PARM_1 p1, typename PF::PARM_2 p2, typename PF::PARM_3 p3, typename PF::PARM_4 p4, typename PF::PARM_5 p5, typename PF::PARM_6 p6, typename PF::PARM_7 p7, typename PF::PARM_8 p8, typename PF::PARM_9 p9, typename PF::PARM_10 p10, typename PF::PARM_11 p11, typename PF::PARM_12 p12 ) + { return fun_( p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12 ); } + + result_type operator()( typename PF::PARM_1 p1, typename PF::PARM_2 p2, typename PF::PARM_3 p3, typename PF::PARM_4 p4, typename PF::PARM_5 p5, typename PF::PARM_6 p6, typename PF::PARM_7 p7, typename PF::PARM_8 p8, typename PF::PARM_9 p9, typename PF::PARM_10 p10, typename PF::PARM_11 p11, typename PF::PARM_12 p12, typename PF::PARM_13 p13 ) + { return fun_( p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13 ); } + + result_type operator()( typename PF::PARM_1 p1, typename PF::PARM_2 p2, typename PF::PARM_3 p3, typename PF::PARM_4 p4, typename PF::PARM_5 p5, typename PF::PARM_6 p6, typename PF::PARM_7 p7, typename PF::PARM_8 p8, typename PF::PARM_9 p9, typename PF::PARM_10 p10, typename PF::PARM_11 p11, typename PF::PARM_12 p12, typename PF::PARM_13 p13, typename PF::PARM_14 p14 ) + { return fun_( p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14 ); } + + result_type operator()( typename PF::PARM_1 p1, typename PF::PARM_2 p2, typename PF::PARM_3 p3, typename PF::PARM_4 p4, typename PF::PARM_5 p5, typename PF::PARM_6 p6, typename PF::PARM_7 p7, typename PF::PARM_8 p8, typename PF::PARM_9 p9, typename PF::PARM_10 p10, typename PF::PARM_11 p11, typename PF::PARM_12 p12, typename PF::PARM_13 p13, typename PF::PARM_14 p14, typename PF::PARM_15 p15 ) + { return fun_( p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15 ); } + + result_type operator()( typename PF::PARM_1 p1, typename PF::PARM_2 p2, typename PF::PARM_3 p3, typename PF::PARM_4 p4, typename PF::PARM_5 p5, typename PF::PARM_6 p6, typename PF::PARM_7 p7, typename PF::PARM_8 p8, typename PF::PARM_9 p9, typename PF::PARM_10 p10, typename PF::PARM_11 p11, typename PF::PARM_12 p12, typename PF::PARM_13 p13, typename PF::PARM_14 p14, typename PF::PARM_15 p15, typename PF::PARM_16 p16 ) + { return fun_( p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16 ); } + +private: + FUN fun_; + +}; +COMET_CLOSE_PARTIAL() + +COMET_SPECIALISE_PARTIAL2( void, typename,PF, typename,FUN , functor_handler) + : public functor_impl< typename PF::result_type, typename PF::parm_list > +{ +public: + typedef typename PF::result_type result_type; + + COMET_PARTIAL_NAME(functor_handler)(const FUN& fun) : fun_(fun) {} + + functor_impl< typename PF::result_type, typename PF::parm_list >* clone() const + { return new COMET_PARTIAL_NAME(functor_handler)(*this); } + result_type operator()( ) + { fun_( ); } + + result_type operator()( typename PF::PARM_1 p1 ) + { fun_( p1 ); } + + result_type operator()( typename PF::PARM_1 p1, typename PF::PARM_2 p2 ) + { fun_( p1, p2 ); } + + result_type operator()( typename PF::PARM_1 p1, typename PF::PARM_2 p2, typename PF::PARM_3 p3 ) + { fun_( p1, p2, p3 ); } + + result_type operator()( typename PF::PARM_1 p1, typename PF::PARM_2 p2, typename PF::PARM_3 p3, typename PF::PARM_4 p4 ) + { fun_( p1, p2, p3, p4 ); } + + result_type operator()( typename PF::PARM_1 p1, typename PF::PARM_2 p2, typename PF::PARM_3 p3, typename PF::PARM_4 p4, typename PF::PARM_5 p5 ) + { fun_( p1, p2, p3, p4, p5 ); } + + result_type operator()( typename PF::PARM_1 p1, typename PF::PARM_2 p2, typename PF::PARM_3 p3, typename PF::PARM_4 p4, typename PF::PARM_5 p5, typename PF::PARM_6 p6 ) + { fun_( p1, p2, p3, p4, p5, p6 ); } + + result_type operator()( typename PF::PARM_1 p1, typename PF::PARM_2 p2, typename PF::PARM_3 p3, typename PF::PARM_4 p4, typename PF::PARM_5 p5, typename PF::PARM_6 p6, typename PF::PARM_7 p7 ) + { fun_( p1, p2, p3, p4, p5, p6, p7 ); } + + result_type operator()( typename PF::PARM_1 p1, typename PF::PARM_2 p2, typename PF::PARM_3 p3, typename PF::PARM_4 p4, typename PF::PARM_5 p5, typename PF::PARM_6 p6, typename PF::PARM_7 p7, typename PF::PARM_8 p8 ) + { fun_( p1, p2, p3, p4, p5, p6, p7, p8 ); } + + result_type operator()( typename PF::PARM_1 p1, typename PF::PARM_2 p2, typename PF::PARM_3 p3, typename PF::PARM_4 p4, typename PF::PARM_5 p5, typename PF::PARM_6 p6, typename PF::PARM_7 p7, typename PF::PARM_8 p8, typename PF::PARM_9 p9 ) + { fun_( p1, p2, p3, p4, p5, p6, p7, p8, p9 ); } + + result_type operator()( typename PF::PARM_1 p1, typename PF::PARM_2 p2, typename PF::PARM_3 p3, typename PF::PARM_4 p4, typename PF::PARM_5 p5, typename PF::PARM_6 p6, typename PF::PARM_7 p7, typename PF::PARM_8 p8, typename PF::PARM_9 p9, typename PF::PARM_10 p10 ) + { fun_( p1, p2, p3, p4, p5, p6, p7, p8, p9, p10 ); } + + result_type operator()( typename PF::PARM_1 p1, typename PF::PARM_2 p2, typename PF::PARM_3 p3, typename PF::PARM_4 p4, typename PF::PARM_5 p5, typename PF::PARM_6 p6, typename PF::PARM_7 p7, typename PF::PARM_8 p8, typename PF::PARM_9 p9, typename PF::PARM_10 p10, typename PF::PARM_11 p11 ) + { fun_( p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11 ); } + + result_type operator()( typename PF::PARM_1 p1, typename PF::PARM_2 p2, typename PF::PARM_3 p3, typename PF::PARM_4 p4, typename PF::PARM_5 p5, typename PF::PARM_6 p6, typename PF::PARM_7 p7, typename PF::PARM_8 p8, typename PF::PARM_9 p9, typename PF::PARM_10 p10, typename PF::PARM_11 p11, typename PF::PARM_12 p12 ) + { fun_( p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12 ); } + + result_type operator()( typename PF::PARM_1 p1, typename PF::PARM_2 p2, typename PF::PARM_3 p3, typename PF::PARM_4 p4, typename PF::PARM_5 p5, typename PF::PARM_6 p6, typename PF::PARM_7 p7, typename PF::PARM_8 p8, typename PF::PARM_9 p9, typename PF::PARM_10 p10, typename PF::PARM_11 p11, typename PF::PARM_12 p12, typename PF::PARM_13 p13 ) + { fun_( p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13 ); } + + result_type operator()( typename PF::PARM_1 p1, typename PF::PARM_2 p2, typename PF::PARM_3 p3, typename PF::PARM_4 p4, typename PF::PARM_5 p5, typename PF::PARM_6 p6, typename PF::PARM_7 p7, typename PF::PARM_8 p8, typename PF::PARM_9 p9, typename PF::PARM_10 p10, typename PF::PARM_11 p11, typename PF::PARM_12 p12, typename PF::PARM_13 p13, typename PF::PARM_14 p14 ) + { fun_( p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14 ); } + + result_type operator()( typename PF::PARM_1 p1, typename PF::PARM_2 p2, typename PF::PARM_3 p3, typename PF::PARM_4 p4, typename PF::PARM_5 p5, typename PF::PARM_6 p6, typename PF::PARM_7 p7, typename PF::PARM_8 p8, typename PF::PARM_9 p9, typename PF::PARM_10 p10, typename PF::PARM_11 p11, typename PF::PARM_12 p12, typename PF::PARM_13 p13, typename PF::PARM_14 p14, typename PF::PARM_15 p15 ) + { fun_( p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15 ); } + + result_type operator()( typename PF::PARM_1 p1, typename PF::PARM_2 p2, typename PF::PARM_3 p3, typename PF::PARM_4 p4, typename PF::PARM_5 p5, typename PF::PARM_6 p6, typename PF::PARM_7 p7, typename PF::PARM_8 p8, typename PF::PARM_9 p9, typename PF::PARM_10 p10, typename PF::PARM_11 p11, typename PF::PARM_12 p12, typename PF::PARM_13 p13, typename PF::PARM_14 p14, typename PF::PARM_15 p15, typename PF::PARM_16 p16 ) + { fun_( p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16 ); } + + +private: + FUN fun_; + +}; +COMET_CLOSE_PARTIAL() + +/** \struct memfun_handler functor.h comet/functor.h + * Provide implementation of functor_impl virtual type for calling a member on + * an object. + * The implementation is effectively 'partially specialised' to return type. + * \param RT Return type + * \param PF Parameter types + * \param OBJ_PTR Object pointer type + * \param MEMFN_PTR Function pointer type + */ +COMET_DEFINE_PARTIAL3(typename,RT,typename,PF, typename,OBJ_PTR, typename,MEMFN_PTR , memfun_handler) + : public functor_impl +{ +private: + OBJ_PTR obj_; + MEMFN_PTR memfn_; + +public: + typedef typename PF::result_type result_type; + + COMET_PARTIAL_NAME(memfun_handler)(const OBJ_PTR& obj, MEMFN_PTR memfn) : obj_(obj), memfn_(memfn) {} + + functor_impl* clone() const + { return new COMET_PARTIAL_NAME(memfun_handler)(*this); } + + result_type operator()( ) + { return ((*obj_).*memfn_)( ); } + + result_type operator()( typename PF::PARM_1 p1 ) + { return ((*obj_).*memfn_)( p1 ); } + + result_type operator()( typename PF::PARM_1 p1, typename PF::PARM_2 p2 ) + { return ((*obj_).*memfn_)( p1, p2 ); } + + result_type operator()( typename PF::PARM_1 p1, typename PF::PARM_2 p2, typename PF::PARM_3 p3 ) + { return ((*obj_).*memfn_)( p1, p2, p3 ); } + + result_type operator()( typename PF::PARM_1 p1, typename PF::PARM_2 p2, typename PF::PARM_3 p3, typename PF::PARM_4 p4 ) + { return ((*obj_).*memfn_)( p1, p2, p3, p4 ); } + + result_type operator()( typename PF::PARM_1 p1, typename PF::PARM_2 p2, typename PF::PARM_3 p3, typename PF::PARM_4 p4, typename PF::PARM_5 p5 ) + { return ((*obj_).*memfn_)( p1, p2, p3, p4, p5 ); } + + result_type operator()( typename PF::PARM_1 p1, typename PF::PARM_2 p2, typename PF::PARM_3 p3, typename PF::PARM_4 p4, typename PF::PARM_5 p5, typename PF::PARM_6 p6 ) + { return ((*obj_).*memfn_)( p1, p2, p3, p4, p5, p6 ); } + + result_type operator()( typename PF::PARM_1 p1, typename PF::PARM_2 p2, typename PF::PARM_3 p3, typename PF::PARM_4 p4, typename PF::PARM_5 p5, typename PF::PARM_6 p6, typename PF::PARM_7 p7 ) + { return ((*obj_).*memfn_)( p1, p2, p3, p4, p5, p6, p7 ); } + + result_type operator()( typename PF::PARM_1 p1, typename PF::PARM_2 p2, typename PF::PARM_3 p3, typename PF::PARM_4 p4, typename PF::PARM_5 p5, typename PF::PARM_6 p6, typename PF::PARM_7 p7, typename PF::PARM_8 p8 ) + { return ((*obj_).*memfn_)( p1, p2, p3, p4, p5, p6, p7, p8 ); } + + result_type operator()( typename PF::PARM_1 p1, typename PF::PARM_2 p2, typename PF::PARM_3 p3, typename PF::PARM_4 p4, typename PF::PARM_5 p5, typename PF::PARM_6 p6, typename PF::PARM_7 p7, typename PF::PARM_8 p8, typename PF::PARM_9 p9 ) + { return ((*obj_).*memfn_)( p1, p2, p3, p4, p5, p6, p7, p8, p9 ); } + + result_type operator()( typename PF::PARM_1 p1, typename PF::PARM_2 p2, typename PF::PARM_3 p3, typename PF::PARM_4 p4, typename PF::PARM_5 p5, typename PF::PARM_6 p6, typename PF::PARM_7 p7, typename PF::PARM_8 p8, typename PF::PARM_9 p9, typename PF::PARM_10 p10 ) + { return ((*obj_).*memfn_)( p1, p2, p3, p4, p5, p6, p7, p8, p9, p10 ); } + + result_type operator()( typename PF::PARM_1 p1, typename PF::PARM_2 p2, typename PF::PARM_3 p3, typename PF::PARM_4 p4, typename PF::PARM_5 p5, typename PF::PARM_6 p6, typename PF::PARM_7 p7, typename PF::PARM_8 p8, typename PF::PARM_9 p9, typename PF::PARM_10 p10, typename PF::PARM_11 p11 ) + { return ((*obj_).*memfn_)( p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11 ); } + + result_type operator()( typename PF::PARM_1 p1, typename PF::PARM_2 p2, typename PF::PARM_3 p3, typename PF::PARM_4 p4, typename PF::PARM_5 p5, typename PF::PARM_6 p6, typename PF::PARM_7 p7, typename PF::PARM_8 p8, typename PF::PARM_9 p9, typename PF::PARM_10 p10, typename PF::PARM_11 p11, typename PF::PARM_12 p12 ) + { return ((*obj_).*memfn_)( p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12 ); } + + result_type operator()( typename PF::PARM_1 p1, typename PF::PARM_2 p2, typename PF::PARM_3 p3, typename PF::PARM_4 p4, typename PF::PARM_5 p5, typename PF::PARM_6 p6, typename PF::PARM_7 p7, typename PF::PARM_8 p8, typename PF::PARM_9 p9, typename PF::PARM_10 p10, typename PF::PARM_11 p11, typename PF::PARM_12 p12, typename PF::PARM_13 p13 ) + { return ((*obj_).*memfn_)( p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13 ); } + + result_type operator()( typename PF::PARM_1 p1, typename PF::PARM_2 p2, typename PF::PARM_3 p3, typename PF::PARM_4 p4, typename PF::PARM_5 p5, typename PF::PARM_6 p6, typename PF::PARM_7 p7, typename PF::PARM_8 p8, typename PF::PARM_9 p9, typename PF::PARM_10 p10, typename PF::PARM_11 p11, typename PF::PARM_12 p12, typename PF::PARM_13 p13, typename PF::PARM_14 p14 ) + { return ((*obj_).*memfn_)( p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14 ); } + + result_type operator()( typename PF::PARM_1 p1, typename PF::PARM_2 p2, typename PF::PARM_3 p3, typename PF::PARM_4 p4, typename PF::PARM_5 p5, typename PF::PARM_6 p6, typename PF::PARM_7 p7, typename PF::PARM_8 p8, typename PF::PARM_9 p9, typename PF::PARM_10 p10, typename PF::PARM_11 p11, typename PF::PARM_12 p12, typename PF::PARM_13 p13, typename PF::PARM_14 p14, typename PF::PARM_15 p15 ) + { return ((*obj_).*memfn_)( p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15 ); } + + result_type operator()( typename PF::PARM_1 p1, typename PF::PARM_2 p2, typename PF::PARM_3 p3, typename PF::PARM_4 p4, typename PF::PARM_5 p5, typename PF::PARM_6 p6, typename PF::PARM_7 p7, typename PF::PARM_8 p8, typename PF::PARM_9 p9, typename PF::PARM_10 p10, typename PF::PARM_11 p11, typename PF::PARM_12 p12, typename PF::PARM_13 p13, typename PF::PARM_14 p14, typename PF::PARM_15 p15, typename PF::PARM_16 p16 ) + { return ((*obj_).*memfn_)( p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16 ); } + +}; +COMET_CLOSE_PARTIAL() + +COMET_SPECIALISE_PARTIAL3( void, typename,PF, typename,OBJ_PTR, typename,MEMFN_PTR , memfun_handler) + : public functor_impl +{ +public: + typedef typename PF::result_type result_type; + + COMET_PARTIAL_NAME(memfun_handler)(const OBJ_PTR& obj, MEMFN_PTR memfn) : obj_(obj), memfn_(memfn) {} + + functor_impl* clone() const + { return new COMET_PARTIAL_NAME(memfun_handler)(*this); } + + result_type operator()( ) + { ((*obj_).*memfn_)( ); } + + result_type operator()( typename PF::PARM_1 p1 ) + { ((*obj_).*memfn_)( p1 ); } + + result_type operator()( typename PF::PARM_1 p1, typename PF::PARM_2 p2 ) + { ((*obj_).*memfn_)( p1, p2 ); } + + result_type operator()( typename PF::PARM_1 p1, typename PF::PARM_2 p2, typename PF::PARM_3 p3 ) + { ((*obj_).*memfn_)( p1, p2, p3 ); } + + result_type operator()( typename PF::PARM_1 p1, typename PF::PARM_2 p2, typename PF::PARM_3 p3, typename PF::PARM_4 p4 ) + { ((*obj_).*memfn_)( p1, p2, p3, p4 ); } + + result_type operator()( typename PF::PARM_1 p1, typename PF::PARM_2 p2, typename PF::PARM_3 p3, typename PF::PARM_4 p4, typename PF::PARM_5 p5 ) + { ((*obj_).*memfn_)( p1, p2, p3, p4, p5 ); } + + result_type operator()( typename PF::PARM_1 p1, typename PF::PARM_2 p2, typename PF::PARM_3 p3, typename PF::PARM_4 p4, typename PF::PARM_5 p5, typename PF::PARM_6 p6 ) + { ((*obj_).*memfn_)( p1, p2, p3, p4, p5, p6 ); } + + result_type operator()( typename PF::PARM_1 p1, typename PF::PARM_2 p2, typename PF::PARM_3 p3, typename PF::PARM_4 p4, typename PF::PARM_5 p5, typename PF::PARM_6 p6, typename PF::PARM_7 p7 ) + { ((*obj_).*memfn_)( p1, p2, p3, p4, p5, p6, p7 ); } + + result_type operator()( typename PF::PARM_1 p1, typename PF::PARM_2 p2, typename PF::PARM_3 p3, typename PF::PARM_4 p4, typename PF::PARM_5 p5, typename PF::PARM_6 p6, typename PF::PARM_7 p7, typename PF::PARM_8 p8 ) + { ((*obj_).*memfn_)( p1, p2, p3, p4, p5, p6, p7, p8 ); } + + result_type operator()( typename PF::PARM_1 p1, typename PF::PARM_2 p2, typename PF::PARM_3 p3, typename PF::PARM_4 p4, typename PF::PARM_5 p5, typename PF::PARM_6 p6, typename PF::PARM_7 p7, typename PF::PARM_8 p8, typename PF::PARM_9 p9 ) + { ((*obj_).*memfn_)( p1, p2, p3, p4, p5, p6, p7, p8, p9 ); } + + result_type operator()( typename PF::PARM_1 p1, typename PF::PARM_2 p2, typename PF::PARM_3 p3, typename PF::PARM_4 p4, typename PF::PARM_5 p5, typename PF::PARM_6 p6, typename PF::PARM_7 p7, typename PF::PARM_8 p8, typename PF::PARM_9 p9, typename PF::PARM_10 p10 ) + { ((*obj_).*memfn_)( p1, p2, p3, p4, p5, p6, p7, p8, p9, p10 ); } + + result_type operator()( typename PF::PARM_1 p1, typename PF::PARM_2 p2, typename PF::PARM_3 p3, typename PF::PARM_4 p4, typename PF::PARM_5 p5, typename PF::PARM_6 p6, typename PF::PARM_7 p7, typename PF::PARM_8 p8, typename PF::PARM_9 p9, typename PF::PARM_10 p10, typename PF::PARM_11 p11 ) + { ((*obj_).*memfn_)( p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11 ); } + + result_type operator()( typename PF::PARM_1 p1, typename PF::PARM_2 p2, typename PF::PARM_3 p3, typename PF::PARM_4 p4, typename PF::PARM_5 p5, typename PF::PARM_6 p6, typename PF::PARM_7 p7, typename PF::PARM_8 p8, typename PF::PARM_9 p9, typename PF::PARM_10 p10, typename PF::PARM_11 p11, typename PF::PARM_12 p12 ) + { ((*obj_).*memfn_)( p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12 ); } + + result_type operator()( typename PF::PARM_1 p1, typename PF::PARM_2 p2, typename PF::PARM_3 p3, typename PF::PARM_4 p4, typename PF::PARM_5 p5, typename PF::PARM_6 p6, typename PF::PARM_7 p7, typename PF::PARM_8 p8, typename PF::PARM_9 p9, typename PF::PARM_10 p10, typename PF::PARM_11 p11, typename PF::PARM_12 p12, typename PF::PARM_13 p13 ) + { ((*obj_).*memfn_)( p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13 ); } + + result_type operator()( typename PF::PARM_1 p1, typename PF::PARM_2 p2, typename PF::PARM_3 p3, typename PF::PARM_4 p4, typename PF::PARM_5 p5, typename PF::PARM_6 p6, typename PF::PARM_7 p7, typename PF::PARM_8 p8, typename PF::PARM_9 p9, typename PF::PARM_10 p10, typename PF::PARM_11 p11, typename PF::PARM_12 p12, typename PF::PARM_13 p13, typename PF::PARM_14 p14 ) + { ((*obj_).*memfn_)( p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14 ); } + + result_type operator()( typename PF::PARM_1 p1, typename PF::PARM_2 p2, typename PF::PARM_3 p3, typename PF::PARM_4 p4, typename PF::PARM_5 p5, typename PF::PARM_6 p6, typename PF::PARM_7 p7, typename PF::PARM_8 p8, typename PF::PARM_9 p9, typename PF::PARM_10 p10, typename PF::PARM_11 p11, typename PF::PARM_12 p12, typename PF::PARM_13 p13, typename PF::PARM_14 p14, typename PF::PARM_15 p15 ) + { ((*obj_).*memfn_)( p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15 ); } + + result_type operator()( typename PF::PARM_1 p1, typename PF::PARM_2 p2, typename PF::PARM_3 p3, typename PF::PARM_4 p4, typename PF::PARM_5 p5, typename PF::PARM_6 p6, typename PF::PARM_7 p7, typename PF::PARM_8 p8, typename PF::PARM_9 p9, typename PF::PARM_10 p10, typename PF::PARM_11 p11, typename PF::PARM_12 p12, typename PF::PARM_13 p13, typename PF::PARM_14 p14, typename PF::PARM_15 p15, typename PF::PARM_16 p16 ) + { ((*obj_).*memfn_)( p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16 ); } + +private: + OBJ_PTR obj_; + MEMFN_PTR memfn_; +}; +COMET_CLOSE_PARTIAL() + +/** \class functor_impl functor.h comet/functor.h + * Implementation of a functor. + * \param R Return type. + * \param LIST List of argument types. + */ +template +class ATL_NO_VTABLE functor_impl : public functor_impl_aux< typelist::length::value COMET_PARTIAL_NS_2(R,LIST) +{}; + +template class functor; + +/** Provide various operator() versions to call the virtual functor. + * This is Effectively paritally specialised to return type (for void + * implementation). + * \param R Return type. + * \param LIST argument list. + */ +COMET_DEFINE_PARTIAL( typename,R,typename,LIST, functor_operators ) : public parameter_types +{ + typedef functor BASE; +public: + R operator()( ) + { return (*(static_cast(this)->impl()))( ); } + + R operator()( PARM_1 p1 ) + { return (*(static_cast(this)->impl()))( p1 ); } + + R operator()( PARM_1 p1, PARM_2 p2 ) + { return (*(static_cast(this)->impl()))( p1, p2 ); } + + R operator()( PARM_1 p1, PARM_2 p2, PARM_3 p3 ) + { return (*(static_cast(this)->impl()))( p1, p2, p3 ); } + + R operator()( PARM_1 p1, PARM_2 p2, PARM_3 p3, PARM_4 p4 ) + { return (*(static_cast(this)->impl()))( p1, p2, p3, p4 ); } + + R operator()( PARM_1 p1, PARM_2 p2, PARM_3 p3, PARM_4 p4, PARM_5 p5 ) + { return (*(static_cast(this)->impl()))( p1, p2, p3, p4, p5 ); } + + R operator()( PARM_1 p1, PARM_2 p2, PARM_3 p3, PARM_4 p4, PARM_5 p5, PARM_6 p6 ) + { return (*(static_cast(this)->impl()))( p1, p2, p3, p4, p5, p6 ); } + + R operator()( PARM_1 p1, PARM_2 p2, PARM_3 p3, PARM_4 p4, PARM_5 p5, PARM_6 p6, PARM_7 p7 ) + { return (*(static_cast(this)->impl()))( p1, p2, p3, p4, p5, p6, p7 ); } + + R operator()( PARM_1 p1, PARM_2 p2, PARM_3 p3, PARM_4 p4, PARM_5 p5, PARM_6 p6, PARM_7 p7, PARM_8 p8 ) + { return (*(static_cast(this)->impl()))( p1, p2, p3, p4, p5, p6, p7, p8 ); } + + R operator()( PARM_1 p1, PARM_2 p2, PARM_3 p3, PARM_4 p4, PARM_5 p5, PARM_6 p6, PARM_7 p7, PARM_8 p8, PARM_9 p9 ) + { return (*(static_cast(this)->impl()))( p1, p2, p3, p4, p5, p6, p7, p8, p9 ); } + + R operator()( PARM_1 p1, PARM_2 p2, PARM_3 p3, PARM_4 p4, PARM_5 p5, PARM_6 p6, PARM_7 p7, PARM_8 p8, PARM_9 p9, PARM_10 p10 ) + { return (*(static_cast(this)->impl()))( p1, p2, p3, p4, p5, p6, p7, p8, p9, p10 ); } + + R operator()( PARM_1 p1, PARM_2 p2, PARM_3 p3, PARM_4 p4, PARM_5 p5, PARM_6 p6, PARM_7 p7, PARM_8 p8, PARM_9 p9, PARM_10 p10, PARM_11 p11 ) + { return (*(static_cast(this)->impl()))( p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11 ); } + + R operator()( PARM_1 p1, PARM_2 p2, PARM_3 p3, PARM_4 p4, PARM_5 p5, PARM_6 p6, PARM_7 p7, PARM_8 p8, PARM_9 p9, PARM_10 p10, PARM_11 p11, PARM_12 p12 ) + { return (*(static_cast(this)->impl()))( p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12 ); } + + R operator()( PARM_1 p1, PARM_2 p2, PARM_3 p3, PARM_4 p4, PARM_5 p5, PARM_6 p6, PARM_7 p7, PARM_8 p8, PARM_9 p9, PARM_10 p10, PARM_11 p11, PARM_12 p12, PARM_13 p13 ) + { return (*(static_cast(this)->impl()))( p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13 ); } + + R operator()( PARM_1 p1, PARM_2 p2, PARM_3 p3, PARM_4 p4, PARM_5 p5, PARM_6 p6, PARM_7 p7, PARM_8 p8, PARM_9 p9, PARM_10 p10, PARM_11 p11, PARM_12 p12, PARM_13 p13, PARM_14 p14 ) + { return (*(static_cast(this)->impl()))( p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14 ); } + + R operator()( PARM_1 p1, PARM_2 p2, PARM_3 p3, PARM_4 p4, PARM_5 p5, PARM_6 p6, PARM_7 p7, PARM_8 p8, PARM_9 p9, PARM_10 p10, PARM_11 p11, PARM_12 p12, PARM_13 p13, PARM_14 p14, PARM_15 p15 ) + { return (*(static_cast(this)->impl()))( p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15 ); } + + R operator()( PARM_1 p1, PARM_2 p2, PARM_3 p3, PARM_4 p4, PARM_5 p5, PARM_6 p6, PARM_7 p7, PARM_8 p8, PARM_9 p9, PARM_10 p10, PARM_11 p11, PARM_12 p12, PARM_13 p13, PARM_14 p14, PARM_15 p15, PARM_16 p16 ) + { return (*(static_cast(this)->impl()))( p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16 ); } + +}; +COMET_CLOSE_PARTIAL() + +COMET_SPECIALISE_PARTIAL( void,typename,LIST , functor_operators) + : public parameter_types +{ + typedef functor BASE; +public: + + void operator()( ) + { (*(static_cast(this)->impl()))( ); } + + void operator()( PARM_1 p1 ) + { (*(static_cast(this)->impl()))( p1 ); } + + void operator()( PARM_1 p1, PARM_2 p2 ) + { (*(static_cast(this)->impl()))( p1, p2 ); } + + void operator()( PARM_1 p1, PARM_2 p2, PARM_3 p3 ) + { (*(static_cast(this)->impl()))( p1, p2, p3 ); } + + void operator()( PARM_1 p1, PARM_2 p2, PARM_3 p3, PARM_4 p4 ) + { (*(static_cast(this)->impl()))( p1, p2, p3, p4 ); } + + void operator()( PARM_1 p1, PARM_2 p2, PARM_3 p3, PARM_4 p4, PARM_5 p5 ) + { (*(static_cast(this)->impl()))( p1, p2, p3, p4, p5 ); } + + void operator()( PARM_1 p1, PARM_2 p2, PARM_3 p3, PARM_4 p4, PARM_5 p5, PARM_6 p6 ) + { (*(static_cast(this)->impl()))( p1, p2, p3, p4, p5, p6 ); } + + void operator()( PARM_1 p1, PARM_2 p2, PARM_3 p3, PARM_4 p4, PARM_5 p5, PARM_6 p6, PARM_7 p7 ) + { (*(static_cast(this)->impl()))( p1, p2, p3, p4, p5, p6, p7 ); } + + void operator()( PARM_1 p1, PARM_2 p2, PARM_3 p3, PARM_4 p4, PARM_5 p5, PARM_6 p6, PARM_7 p7, PARM_8 p8 ) + { (*(static_cast(this)->impl()))( p1, p2, p3, p4, p5, p6, p7, p8 ); } + + void operator()( PARM_1 p1, PARM_2 p2, PARM_3 p3, PARM_4 p4, PARM_5 p5, PARM_6 p6, PARM_7 p7, PARM_8 p8, PARM_9 p9 ) + { (*(static_cast(this)->impl()))( p1, p2, p3, p4, p5, p6, p7, p8, p9 ); } + + void operator()( PARM_1 p1, PARM_2 p2, PARM_3 p3, PARM_4 p4, PARM_5 p5, PARM_6 p6, PARM_7 p7, PARM_8 p8, PARM_9 p9, PARM_10 p10 ) + { (*(static_cast(this)->impl()))( p1, p2, p3, p4, p5, p6, p7, p8, p9, p10 ); } + + void operator()( PARM_1 p1, PARM_2 p2, PARM_3 p3, PARM_4 p4, PARM_5 p5, PARM_6 p6, PARM_7 p7, PARM_8 p8, PARM_9 p9, PARM_10 p10, PARM_11 p11 ) + { (*(static_cast(this)->impl()))( p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11 ); } + + void operator()( PARM_1 p1, PARM_2 p2, PARM_3 p3, PARM_4 p4, PARM_5 p5, PARM_6 p6, PARM_7 p7, PARM_8 p8, PARM_9 p9, PARM_10 p10, PARM_11 p11, PARM_12 p12 ) + { (*(static_cast(this)->impl()))( p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12 ); } + + void operator()( PARM_1 p1, PARM_2 p2, PARM_3 p3, PARM_4 p4, PARM_5 p5, PARM_6 p6, PARM_7 p7, PARM_8 p8, PARM_9 p9, PARM_10 p10, PARM_11 p11, PARM_12 p12, PARM_13 p13 ) + { (*(static_cast(this)->impl()))( p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13 ); } + + void operator()( PARM_1 p1, PARM_2 p2, PARM_3 p3, PARM_4 p4, PARM_5 p5, PARM_6 p6, PARM_7 p7, PARM_8 p8, PARM_9 p9, PARM_10 p10, PARM_11 p11, PARM_12 p12, PARM_13 p13, PARM_14 p14 ) + { (*(static_cast(this)->impl()))( p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14 ); } + + void operator()( PARM_1 p1, PARM_2 p2, PARM_3 p3, PARM_4 p4, PARM_5 p5, PARM_6 p6, PARM_7 p7, PARM_8 p8, PARM_9 p9, PARM_10 p10, PARM_11 p11, PARM_12 p12, PARM_13 p13, PARM_14 p14, PARM_15 p15 ) + { (*(static_cast(this)->impl()))( p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15 ); } + + void operator()( PARM_1 p1, PARM_2 p2, PARM_3 p3, PARM_4 p4, PARM_5 p5, PARM_6 p6, PARM_7 p7, PARM_8 p8, PARM_9 p9, PARM_10 p10, PARM_11 p11, PARM_12 p12, PARM_13 p13, PARM_14 p14, PARM_15 p15, PARM_16 p16 ) + { (*(static_cast(this)->impl()))( p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16 ); } + +}; +COMET_CLOSE_PARTIAL() + +/** \class functor functor.h comet/functor.h + * Functor pointer class and implementation factory. This provides the interface to the functor library. + * \param R Return type + * \param LIST List of types using \link make_list comet::make_list \endlink + */ +template class functor : public functor_operators IMPL; + + typedef R result_type; + typedef LIST parm_list; + + functor() {}; + functor(const functor& f) : impl_((f.impl_.get()== NULL) ? NULL: f.impl_->clone()) {} + explicit functor(std::auto_ptr< IMPL > impl) : impl_(impl) {} + + template explicit functor(int, FUN fun) : impl_(new functor_handler), FUN)(fun)) + {} + + template functor(int, const OBJ_PTR& obj, MEMFN_PTR memfn) + : impl_(new memfun_handlerCOMET_PARTIAL_NS, OBJ_PTR, MEMFN_PTR>(obj, memfn)) + {} + + functor& operator=(const functor& rhs) + { + std::auto_ptr tmp((rhs.impl_.get() == NULL)? NULL: rhs.impl_->clone()); + impl_ = tmp; + return *this; + } + + std::auto_ptr &impl(){return impl_;} + + bool is_null() const { return impl_.get() == NULL; } +protected: + std::auto_ptr impl_; +}; + +/** \class chainer functor.h comet/functor.h + * Implements a functor that chains one functor to another functor. + * \param R Return type + * \param LIST Typelist of arguments + * \sa chain + */ +COMET_DEFINE_PARTIAL(typename,R, typename,LIST, chainer) : public functor_impl +{ +private: +typedef functor FUN; + +FUN fun1_; +FUN fun2_; + + +public: +COMET_PARTIAL_NAME(chainer)(const FUN& fun1, const FUN& fun2) : fun1_(fun1), fun2_(fun2) +{} + +COMET_PARTIAL_NAME(chainer)(const COMET_PARTIAL_NAME(chainer)& x) : fun1_(x.fun1_), fun2_(x.fun2_) +{} + +functor_impl* clone() const +{ return new COMET_PARTIAL_NAME(chainer)(*this); } + + R operator()( ) + { + fun1_( ); + return fun2_( ); + } + + R operator()( typename FUN::PARM_1 p1 ) + { + fun1_( p1 ); + return fun2_( p1 ); + } + + R operator()( typename FUN::PARM_1 p1, typename FUN::PARM_2 p2 ) + { + fun1_( p1, p2 ); + return fun2_( p1, p2 ); + } + + R operator()( typename FUN::PARM_1 p1, typename FUN::PARM_2 p2, typename FUN::PARM_3 p3 ) + { + fun1_( p1, p2, p3 ); + return fun2_( p1, p2, p3 ); + } + + R operator()( typename FUN::PARM_1 p1, typename FUN::PARM_2 p2, typename FUN::PARM_3 p3, typename FUN::PARM_4 p4 ) + { + fun1_( p1, p2, p3, p4 ); + return fun2_( p1, p2, p3, p4 ); + } + + R operator()( typename FUN::PARM_1 p1, typename FUN::PARM_2 p2, typename FUN::PARM_3 p3, typename FUN::PARM_4 p4, typename FUN::PARM_5 p5 ) + { + fun1_( p1, p2, p3, p4, p5 ); + return fun2_( p1, p2, p3, p4, p5 ); + } + + R operator()( typename FUN::PARM_1 p1, typename FUN::PARM_2 p2, typename FUN::PARM_3 p3, typename FUN::PARM_4 p4, typename FUN::PARM_5 p5, typename FUN::PARM_6 p6 ) + { + fun1_( p1, p2, p3, p4, p5, p6 ); + return fun2_( p1, p2, p3, p4, p5, p6 ); + } + + R operator()( typename FUN::PARM_1 p1, typename FUN::PARM_2 p2, typename FUN::PARM_3 p3, typename FUN::PARM_4 p4, typename FUN::PARM_5 p5, typename FUN::PARM_6 p6, typename FUN::PARM_7 p7 ) + { + fun1_( p1, p2, p3, p4, p5, p6, p7 ); + return fun2_( p1, p2, p3, p4, p5, p6, p7 ); + } + + R operator()( typename FUN::PARM_1 p1, typename FUN::PARM_2 p2, typename FUN::PARM_3 p3, typename FUN::PARM_4 p4, typename FUN::PARM_5 p5, typename FUN::PARM_6 p6, typename FUN::PARM_7 p7, typename FUN::PARM_8 p8 ) + { + fun1_( p1, p2, p3, p4, p5, p6, p7, p8 ); + return fun2_( p1, p2, p3, p4, p5, p6, p7, p8 ); + } + + R operator()( typename FUN::PARM_1 p1, typename FUN::PARM_2 p2, typename FUN::PARM_3 p3, typename FUN::PARM_4 p4, typename FUN::PARM_5 p5, typename FUN::PARM_6 p6, typename FUN::PARM_7 p7, typename FUN::PARM_8 p8, typename FUN::PARM_9 p9 ) + { + fun1_( p1, p2, p3, p4, p5, p6, p7, p8, p9 ); + return fun2_( p1, p2, p3, p4, p5, p6, p7, p8, p9 ); + } + + R operator()( typename FUN::PARM_1 p1, typename FUN::PARM_2 p2, typename FUN::PARM_3 p3, typename FUN::PARM_4 p4, typename FUN::PARM_5 p5, typename FUN::PARM_6 p6, typename FUN::PARM_7 p7, typename FUN::PARM_8 p8, typename FUN::PARM_9 p9, typename FUN::PARM_10 p10 ) + { + fun1_( p1, p2, p3, p4, p5, p6, p7, p8, p9, p10 ); + return fun2_( p1, p2, p3, p4, p5, p6, p7, p8, p9, p10 ); + } + + R operator()( typename FUN::PARM_1 p1, typename FUN::PARM_2 p2, typename FUN::PARM_3 p3, typename FUN::PARM_4 p4, typename FUN::PARM_5 p5, typename FUN::PARM_6 p6, typename FUN::PARM_7 p7, typename FUN::PARM_8 p8, typename FUN::PARM_9 p9, typename FUN::PARM_10 p10, typename FUN::PARM_11 p11 ) + { + fun1_( p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11 ); + return fun2_( p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11 ); + } + + R operator()( typename FUN::PARM_1 p1, typename FUN::PARM_2 p2, typename FUN::PARM_3 p3, typename FUN::PARM_4 p4, typename FUN::PARM_5 p5, typename FUN::PARM_6 p6, typename FUN::PARM_7 p7, typename FUN::PARM_8 p8, typename FUN::PARM_9 p9, typename FUN::PARM_10 p10, typename FUN::PARM_11 p11, typename FUN::PARM_12 p12 ) + { + fun1_( p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12 ); + return fun2_( p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12 ); + } + + R operator()( typename FUN::PARM_1 p1, typename FUN::PARM_2 p2, typename FUN::PARM_3 p3, typename FUN::PARM_4 p4, typename FUN::PARM_5 p5, typename FUN::PARM_6 p6, typename FUN::PARM_7 p7, typename FUN::PARM_8 p8, typename FUN::PARM_9 p9, typename FUN::PARM_10 p10, typename FUN::PARM_11 p11, typename FUN::PARM_12 p12, typename FUN::PARM_13 p13 ) + { + fun1_( p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13 ); + return fun2_( p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13 ); + } + + R operator()( typename FUN::PARM_1 p1, typename FUN::PARM_2 p2, typename FUN::PARM_3 p3, typename FUN::PARM_4 p4, typename FUN::PARM_5 p5, typename FUN::PARM_6 p6, typename FUN::PARM_7 p7, typename FUN::PARM_8 p8, typename FUN::PARM_9 p9, typename FUN::PARM_10 p10, typename FUN::PARM_11 p11, typename FUN::PARM_12 p12, typename FUN::PARM_13 p13, typename FUN::PARM_14 p14 ) + { + fun1_( p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14 ); + return fun2_( p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14 ); + } + + R operator()( typename FUN::PARM_1 p1, typename FUN::PARM_2 p2, typename FUN::PARM_3 p3, typename FUN::PARM_4 p4, typename FUN::PARM_5 p5, typename FUN::PARM_6 p6, typename FUN::PARM_7 p7, typename FUN::PARM_8 p8, typename FUN::PARM_9 p9, typename FUN::PARM_10 p10, typename FUN::PARM_11 p11, typename FUN::PARM_12 p12, typename FUN::PARM_13 p13, typename FUN::PARM_14 p14, typename FUN::PARM_15 p15 ) + { + fun1_( p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15 ); + return fun2_( p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15 ); + } + + R operator()( typename FUN::PARM_1 p1, typename FUN::PARM_2 p2, typename FUN::PARM_3 p3, typename FUN::PARM_4 p4, typename FUN::PARM_5 p5, typename FUN::PARM_6 p6, typename FUN::PARM_7 p7, typename FUN::PARM_8 p8, typename FUN::PARM_9 p9, typename FUN::PARM_10 p10, typename FUN::PARM_11 p11, typename FUN::PARM_12 p12, typename FUN::PARM_13 p13, typename FUN::PARM_14 p14, typename FUN::PARM_15 p15, typename FUN::PARM_16 p16 ) + { + fun1_( p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16 ); + return fun2_( p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16 ); + } + + +}; +COMET_CLOSE_PARTIAL() + +/** Specialisation for void. + */ +COMET_SPECIALISE_PARTIAL( void, typename,LIST , chainer ) + : public functor_impl +{ +private: + typedef functor FUN; + + FUN fun1_; + FUN fun2_; + + +public: + COMET_PARTIAL_NAME(chainer)(const FUN& fun1, const FUN& fun2) : fun1_(fun1), fun2_(fun2) + {} + + COMET_PARTIAL_NAME(chainer)(const COMET_PARTIAL_NAME(chainer)& x) : fun1_(x.fun1_), fun2_(x.fun2_) + {} + + functor_impl* clone() const + { return new COMET_PARTIAL_NAME(chainer)(*this); } + + void operator()( ) + { + fun1_( ); + fun2_( ); + } + + void operator()( typename FUN::PARM_1 p1 ) + { + fun1_( p1 ); + fun2_( p1 ); + } + + void operator()( typename FUN::PARM_1 p1, typename FUN::PARM_2 p2 ) + { + fun1_( p1, p2 ); + fun2_( p1, p2 ); + } + + void operator()( typename FUN::PARM_1 p1, typename FUN::PARM_2 p2, typename FUN::PARM_3 p3 ) + { + fun1_( p1, p2, p3 ); + fun2_( p1, p2, p3 ); + } + + void operator()( typename FUN::PARM_1 p1, typename FUN::PARM_2 p2, typename FUN::PARM_3 p3, typename FUN::PARM_4 p4 ) + { + fun1_( p1, p2, p3, p4 ); + fun2_( p1, p2, p3, p4 ); + } + + void operator()( typename FUN::PARM_1 p1, typename FUN::PARM_2 p2, typename FUN::PARM_3 p3, typename FUN::PARM_4 p4, typename FUN::PARM_5 p5 ) + { + fun1_( p1, p2, p3, p4, p5 ); + fun2_( p1, p2, p3, p4, p5 ); + } + + void operator()( typename FUN::PARM_1 p1, typename FUN::PARM_2 p2, typename FUN::PARM_3 p3, typename FUN::PARM_4 p4, typename FUN::PARM_5 p5, typename FUN::PARM_6 p6 ) + { + fun1_( p1, p2, p3, p4, p5, p6 ); + fun2_( p1, p2, p3, p4, p5, p6 ); + } + + void operator()( typename FUN::PARM_1 p1, typename FUN::PARM_2 p2, typename FUN::PARM_3 p3, typename FUN::PARM_4 p4, typename FUN::PARM_5 p5, typename FUN::PARM_6 p6, typename FUN::PARM_7 p7 ) + { + fun1_( p1, p2, p3, p4, p5, p6, p7 ); + fun2_( p1, p2, p3, p4, p5, p6, p7 ); + } + + void operator()( typename FUN::PARM_1 p1, typename FUN::PARM_2 p2, typename FUN::PARM_3 p3, typename FUN::PARM_4 p4, typename FUN::PARM_5 p5, typename FUN::PARM_6 p6, typename FUN::PARM_7 p7, typename FUN::PARM_8 p8 ) + { + fun1_( p1, p2, p3, p4, p5, p6, p7, p8 ); + fun2_( p1, p2, p3, p4, p5, p6, p7, p8 ); + } + + void operator()( typename FUN::PARM_1 p1, typename FUN::PARM_2 p2, typename FUN::PARM_3 p3, typename FUN::PARM_4 p4, typename FUN::PARM_5 p5, typename FUN::PARM_6 p6, typename FUN::PARM_7 p7, typename FUN::PARM_8 p8, typename FUN::PARM_9 p9 ) + { + fun1_( p1, p2, p3, p4, p5, p6, p7, p8, p9 ); + fun2_( p1, p2, p3, p4, p5, p6, p7, p8, p9 ); + } + + void operator()( typename FUN::PARM_1 p1, typename FUN::PARM_2 p2, typename FUN::PARM_3 p3, typename FUN::PARM_4 p4, typename FUN::PARM_5 p5, typename FUN::PARM_6 p6, typename FUN::PARM_7 p7, typename FUN::PARM_8 p8, typename FUN::PARM_9 p9, typename FUN::PARM_10 p10 ) + { + fun1_( p1, p2, p3, p4, p5, p6, p7, p8, p9, p10 ); + fun2_( p1, p2, p3, p4, p5, p6, p7, p8, p9, p10 ); + } + + void operator()( typename FUN::PARM_1 p1, typename FUN::PARM_2 p2, typename FUN::PARM_3 p3, typename FUN::PARM_4 p4, typename FUN::PARM_5 p5, typename FUN::PARM_6 p6, typename FUN::PARM_7 p7, typename FUN::PARM_8 p8, typename FUN::PARM_9 p9, typename FUN::PARM_10 p10, typename FUN::PARM_11 p11 ) + { + fun1_( p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11 ); + fun2_( p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11 ); + } + + void operator()( typename FUN::PARM_1 p1, typename FUN::PARM_2 p2, typename FUN::PARM_3 p3, typename FUN::PARM_4 p4, typename FUN::PARM_5 p5, typename FUN::PARM_6 p6, typename FUN::PARM_7 p7, typename FUN::PARM_8 p8, typename FUN::PARM_9 p9, typename FUN::PARM_10 p10, typename FUN::PARM_11 p11, typename FUN::PARM_12 p12 ) + { + fun1_( p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12 ); + fun2_( p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12 ); + } + + void operator()( typename FUN::PARM_1 p1, typename FUN::PARM_2 p2, typename FUN::PARM_3 p3, typename FUN::PARM_4 p4, typename FUN::PARM_5 p5, typename FUN::PARM_6 p6, typename FUN::PARM_7 p7, typename FUN::PARM_8 p8, typename FUN::PARM_9 p9, typename FUN::PARM_10 p10, typename FUN::PARM_11 p11, typename FUN::PARM_12 p12, typename FUN::PARM_13 p13 ) + { + fun1_( p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13 ); + fun2_( p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13 ); + } + + void operator()( typename FUN::PARM_1 p1, typename FUN::PARM_2 p2, typename FUN::PARM_3 p3, typename FUN::PARM_4 p4, typename FUN::PARM_5 p5, typename FUN::PARM_6 p6, typename FUN::PARM_7 p7, typename FUN::PARM_8 p8, typename FUN::PARM_9 p9, typename FUN::PARM_10 p10, typename FUN::PARM_11 p11, typename FUN::PARM_12 p12, typename FUN::PARM_13 p13, typename FUN::PARM_14 p14 ) + { + fun1_( p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14 ); + fun2_( p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14 ); + } + + void operator()( typename FUN::PARM_1 p1, typename FUN::PARM_2 p2, typename FUN::PARM_3 p3, typename FUN::PARM_4 p4, typename FUN::PARM_5 p5, typename FUN::PARM_6 p6, typename FUN::PARM_7 p7, typename FUN::PARM_8 p8, typename FUN::PARM_9 p9, typename FUN::PARM_10 p10, typename FUN::PARM_11 p11, typename FUN::PARM_12 p12, typename FUN::PARM_13 p13, typename FUN::PARM_14 p14, typename FUN::PARM_15 p15 ) + { + fun1_( p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15 ); + fun2_( p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15 ); + } + + void operator()( typename FUN::PARM_1 p1, typename FUN::PARM_2 p2, typename FUN::PARM_3 p3, typename FUN::PARM_4 p4, typename FUN::PARM_5 p5, typename FUN::PARM_6 p6, typename FUN::PARM_7 p7, typename FUN::PARM_8 p8, typename FUN::PARM_9 p9, typename FUN::PARM_10 p10, typename FUN::PARM_11 p11, typename FUN::PARM_12 p12, typename FUN::PARM_13 p13, typename FUN::PARM_14 p14, typename FUN::PARM_15 p15, typename FUN::PARM_16 p16 ) + { + fun1_( p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16 ); + fun2_( p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16 ); + } + +}; +COMET_CLOSE_PARTIAL() + +/** \class binder_first functor.h comet/functor.h + * Implements a functor that calls the first parameter bound to a specified + * type. The functor type implemented is effectively functor. + * \sa bind_first + */ +COMET_DEFINE_PARTIAL( typename,R, typename,LIST, binder_first) + : public functor_impl +{ + public: + typedef functor outgoing_type; + typedef typename functor::PARM_1 bound_type; + typedef R result_type; + + private: + functor fun_; + bound_type bound_; + public: + COMET_PARTIAL_NAME(binder_first)(const functor& fun, bound_type bound) : bound_(bound) + { + fun_ = fun; + } + + COMET_PARTIAL_NAME(binder_first)(const COMET_PARTIAL_NAME(binder_first)& x) : bound_(x.bound_) + { + fun_ = x.fun_; + } + + functor_impl* clone() const + { return new COMET_PARTIAL_NAME(binder_first)(*this); } + + result_type operator()() + { + return fun_(bound_ ); + } + + result_type operator()( typename outgoing_type::PARM_1 p1) + { + return fun_(bound_, p1); + } + + result_type operator()( typename outgoing_type::PARM_1 p1, typename outgoing_type::PARM_2 p2) + { + return fun_(bound_, p1, p2); + } + + result_type operator()( typename outgoing_type::PARM_1 p1, typename outgoing_type::PARM_2 p2, typename outgoing_type::PARM_3 p3) + { + return fun_(bound_, p1, p2, p3); + } + + result_type operator()( typename outgoing_type::PARM_1 p1, typename outgoing_type::PARM_2 p2, typename outgoing_type::PARM_3 p3, typename outgoing_type::PARM_4 p4) + { + return fun_(bound_, p1, p2, p3, p4); + } + + result_type operator()( typename outgoing_type::PARM_1 p1, typename outgoing_type::PARM_2 p2, typename outgoing_type::PARM_3 p3, typename outgoing_type::PARM_4 p4, typename outgoing_type::PARM_5 p5) + { + return fun_(bound_, p1, p2, p3, p4, p5); + } + + result_type operator()( typename outgoing_type::PARM_1 p1, typename outgoing_type::PARM_2 p2, typename outgoing_type::PARM_3 p3, typename outgoing_type::PARM_4 p4, typename outgoing_type::PARM_5 p5, typename outgoing_type::PARM_6 p6) + { + return fun_(bound_, p1, p2, p3, p4, p5, p6); + } + + result_type operator()( typename outgoing_type::PARM_1 p1, typename outgoing_type::PARM_2 p2, typename outgoing_type::PARM_3 p3, typename outgoing_type::PARM_4 p4, typename outgoing_type::PARM_5 p5, typename outgoing_type::PARM_6 p6, typename outgoing_type::PARM_7 p7) + { + return fun_(bound_, p1, p2, p3, p4, p5, p6, p7); + } + + result_type operator()( typename outgoing_type::PARM_1 p1, typename outgoing_type::PARM_2 p2, typename outgoing_type::PARM_3 p3, typename outgoing_type::PARM_4 p4, typename outgoing_type::PARM_5 p5, typename outgoing_type::PARM_6 p6, typename outgoing_type::PARM_7 p7, typename outgoing_type::PARM_8 p8) + { + return fun_(bound_, p1, p2, p3, p4, p5, p6, p7, p8); + } + + result_type operator()( typename outgoing_type::PARM_1 p1, typename outgoing_type::PARM_2 p2, typename outgoing_type::PARM_3 p3, typename outgoing_type::PARM_4 p4, typename outgoing_type::PARM_5 p5, typename outgoing_type::PARM_6 p6, typename outgoing_type::PARM_7 p7, typename outgoing_type::PARM_8 p8, typename outgoing_type::PARM_9 p9) + { + return fun_(bound_, p1, p2, p3, p4, p5, p6, p7, p8, p9); + } + + result_type operator()( typename outgoing_type::PARM_1 p1, typename outgoing_type::PARM_2 p2, typename outgoing_type::PARM_3 p3, typename outgoing_type::PARM_4 p4, typename outgoing_type::PARM_5 p5, typename outgoing_type::PARM_6 p6, typename outgoing_type::PARM_7 p7, typename outgoing_type::PARM_8 p8, typename outgoing_type::PARM_9 p9, typename outgoing_type::PARM_10 p10) + { + return fun_(bound_, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10); + } + + result_type operator()( typename outgoing_type::PARM_1 p1, typename outgoing_type::PARM_2 p2, typename outgoing_type::PARM_3 p3, typename outgoing_type::PARM_4 p4, typename outgoing_type::PARM_5 p5, typename outgoing_type::PARM_6 p6, typename outgoing_type::PARM_7 p7, typename outgoing_type::PARM_8 p8, typename outgoing_type::PARM_9 p9, typename outgoing_type::PARM_10 p10, typename outgoing_type::PARM_11 p11) + { + return fun_(bound_, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11); + } + + result_type operator()( typename outgoing_type::PARM_1 p1, typename outgoing_type::PARM_2 p2, typename outgoing_type::PARM_3 p3, typename outgoing_type::PARM_4 p4, typename outgoing_type::PARM_5 p5, typename outgoing_type::PARM_6 p6, typename outgoing_type::PARM_7 p7, typename outgoing_type::PARM_8 p8, typename outgoing_type::PARM_9 p9, typename outgoing_type::PARM_10 p10, typename outgoing_type::PARM_11 p11, typename outgoing_type::PARM_12 p12) + { + return fun_(bound_, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12); + } + + result_type operator()( typename outgoing_type::PARM_1 p1, typename outgoing_type::PARM_2 p2, typename outgoing_type::PARM_3 p3, typename outgoing_type::PARM_4 p4, typename outgoing_type::PARM_5 p5, typename outgoing_type::PARM_6 p6, typename outgoing_type::PARM_7 p7, typename outgoing_type::PARM_8 p8, typename outgoing_type::PARM_9 p9, typename outgoing_type::PARM_10 p10, typename outgoing_type::PARM_11 p11, typename outgoing_type::PARM_12 p12, typename outgoing_type::PARM_13 p13) + { + return fun_(bound_, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13); + } + + result_type operator()( typename outgoing_type::PARM_1 p1, typename outgoing_type::PARM_2 p2, typename outgoing_type::PARM_3 p3, typename outgoing_type::PARM_4 p4, typename outgoing_type::PARM_5 p5, typename outgoing_type::PARM_6 p6, typename outgoing_type::PARM_7 p7, typename outgoing_type::PARM_8 p8, typename outgoing_type::PARM_9 p9, typename outgoing_type::PARM_10 p10, typename outgoing_type::PARM_11 p11, typename outgoing_type::PARM_12 p12, typename outgoing_type::PARM_13 p13, typename outgoing_type::PARM_14 p14) + { + return fun_(bound_, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14); + } + + result_type operator()( typename outgoing_type::PARM_1 p1, typename outgoing_type::PARM_2 p2, typename outgoing_type::PARM_3 p3, typename outgoing_type::PARM_4 p4, typename outgoing_type::PARM_5 p5, typename outgoing_type::PARM_6 p6, typename outgoing_type::PARM_7 p7, typename outgoing_type::PARM_8 p8, typename outgoing_type::PARM_9 p9, typename outgoing_type::PARM_10 p10, typename outgoing_type::PARM_11 p11, typename outgoing_type::PARM_12 p12, typename outgoing_type::PARM_13 p13, typename outgoing_type::PARM_14 p14, typename outgoing_type::PARM_15 p15) + { + return fun_(bound_, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15); + } + + result_type operator()( typename outgoing_type::PARM_1 p1, typename outgoing_type::PARM_2 p2, typename outgoing_type::PARM_3 p3, typename outgoing_type::PARM_4 p4, typename outgoing_type::PARM_5 p5, typename outgoing_type::PARM_6 p6, typename outgoing_type::PARM_7 p7, typename outgoing_type::PARM_8 p8, typename outgoing_type::PARM_9 p9, typename outgoing_type::PARM_10 p10, typename outgoing_type::PARM_11 p11, typename outgoing_type::PARM_12 p12, typename outgoing_type::PARM_13 p13, typename outgoing_type::PARM_14 p14, typename outgoing_type::PARM_15 p15, typename outgoing_type::PARM_16 p16) + { + return fun_(bound_, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16); + } + + +}; +COMET_CLOSE_PARTIAL() + +COMET_SPECIALISE_PARTIAL( void, typename,LIST , binder_first) + : public functor_impl +{ +public: +typedef functor outgoing_type; +typedef typename functor::PARM_1 bound_type; +typedef void result_type; + +private: +functor fun_; +bound_type bound_; +public: +COMET_PARTIAL_NAME(binder_first)(const functor& fun, bound_type bound) : bound_(bound) +{ + fun_ = fun; +} + +COMET_PARTIAL_NAME(binder_first)(const COMET_PARTIAL_NAME(binder_first)& x) : bound_(x.bound_) +{ + fun_ = x.fun_; +} + +functor_impl* clone() const +{ return new COMET_PARTIAL_NAME(binder_first)(*this); } + +result_type operator()() +{ + fun_(bound_ ); +} + +result_type operator()( typename outgoing_type::PARM_1 p1) +{ + fun_(bound_, p1); +} + +result_type operator()( typename outgoing_type::PARM_1 p1, typename outgoing_type::PARM_2 p2) +{ + fun_(bound_, p1, p2); +} + +result_type operator()( typename outgoing_type::PARM_1 p1, typename outgoing_type::PARM_2 p2, typename outgoing_type::PARM_3 p3) +{ + fun_(bound_, p1, p2, p3); +} + +result_type operator()( typename outgoing_type::PARM_1 p1, typename outgoing_type::PARM_2 p2, typename outgoing_type::PARM_3 p3, typename outgoing_type::PARM_4 p4) +{ + fun_(bound_, p1, p2, p3, p4); +} + +result_type operator()( typename outgoing_type::PARM_1 p1, typename outgoing_type::PARM_2 p2, typename outgoing_type::PARM_3 p3, typename outgoing_type::PARM_4 p4, typename outgoing_type::PARM_5 p5) +{ + fun_(bound_, p1, p2, p3, p4, p5); +} + +result_type operator()( typename outgoing_type::PARM_1 p1, typename outgoing_type::PARM_2 p2, typename outgoing_type::PARM_3 p3, typename outgoing_type::PARM_4 p4, typename outgoing_type::PARM_5 p5, typename outgoing_type::PARM_6 p6) +{ + fun_(bound_, p1, p2, p3, p4, p5, p6); +} + +result_type operator()( typename outgoing_type::PARM_1 p1, typename outgoing_type::PARM_2 p2, typename outgoing_type::PARM_3 p3, typename outgoing_type::PARM_4 p4, typename outgoing_type::PARM_5 p5, typename outgoing_type::PARM_6 p6, typename outgoing_type::PARM_7 p7) +{ + fun_(bound_, p1, p2, p3, p4, p5, p6, p7); +} + +result_type operator()( typename outgoing_type::PARM_1 p1, typename outgoing_type::PARM_2 p2, typename outgoing_type::PARM_3 p3, typename outgoing_type::PARM_4 p4, typename outgoing_type::PARM_5 p5, typename outgoing_type::PARM_6 p6, typename outgoing_type::PARM_7 p7, typename outgoing_type::PARM_8 p8) +{ + fun_(bound_, p1, p2, p3, p4, p5, p6, p7, p8); +} + +result_type operator()( typename outgoing_type::PARM_1 p1, typename outgoing_type::PARM_2 p2, typename outgoing_type::PARM_3 p3, typename outgoing_type::PARM_4 p4, typename outgoing_type::PARM_5 p5, typename outgoing_type::PARM_6 p6, typename outgoing_type::PARM_7 p7, typename outgoing_type::PARM_8 p8, typename outgoing_type::PARM_9 p9) +{ + fun_(bound_, p1, p2, p3, p4, p5, p6, p7, p8, p9); +} + +result_type operator()( typename outgoing_type::PARM_1 p1, typename outgoing_type::PARM_2 p2, typename outgoing_type::PARM_3 p3, typename outgoing_type::PARM_4 p4, typename outgoing_type::PARM_5 p5, typename outgoing_type::PARM_6 p6, typename outgoing_type::PARM_7 p7, typename outgoing_type::PARM_8 p8, typename outgoing_type::PARM_9 p9, typename outgoing_type::PARM_10 p10) +{ + fun_(bound_, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10); +} + +result_type operator()( typename outgoing_type::PARM_1 p1, typename outgoing_type::PARM_2 p2, typename outgoing_type::PARM_3 p3, typename outgoing_type::PARM_4 p4, typename outgoing_type::PARM_5 p5, typename outgoing_type::PARM_6 p6, typename outgoing_type::PARM_7 p7, typename outgoing_type::PARM_8 p8, typename outgoing_type::PARM_9 p9, typename outgoing_type::PARM_10 p10, typename outgoing_type::PARM_11 p11) +{ + fun_(bound_, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11); +} + +result_type operator()( typename outgoing_type::PARM_1 p1, typename outgoing_type::PARM_2 p2, typename outgoing_type::PARM_3 p3, typename outgoing_type::PARM_4 p4, typename outgoing_type::PARM_5 p5, typename outgoing_type::PARM_6 p6, typename outgoing_type::PARM_7 p7, typename outgoing_type::PARM_8 p8, typename outgoing_type::PARM_9 p9, typename outgoing_type::PARM_10 p10, typename outgoing_type::PARM_11 p11, typename outgoing_type::PARM_12 p12) +{ + fun_(bound_, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12); +} + +result_type operator()( typename outgoing_type::PARM_1 p1, typename outgoing_type::PARM_2 p2, typename outgoing_type::PARM_3 p3, typename outgoing_type::PARM_4 p4, typename outgoing_type::PARM_5 p5, typename outgoing_type::PARM_6 p6, typename outgoing_type::PARM_7 p7, typename outgoing_type::PARM_8 p8, typename outgoing_type::PARM_9 p9, typename outgoing_type::PARM_10 p10, typename outgoing_type::PARM_11 p11, typename outgoing_type::PARM_12 p12, typename outgoing_type::PARM_13 p13) +{ + fun_(bound_, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13); +} + +result_type operator()( typename outgoing_type::PARM_1 p1, typename outgoing_type::PARM_2 p2, typename outgoing_type::PARM_3 p3, typename outgoing_type::PARM_4 p4, typename outgoing_type::PARM_5 p5, typename outgoing_type::PARM_6 p6, typename outgoing_type::PARM_7 p7, typename outgoing_type::PARM_8 p8, typename outgoing_type::PARM_9 p9, typename outgoing_type::PARM_10 p10, typename outgoing_type::PARM_11 p11, typename outgoing_type::PARM_12 p12, typename outgoing_type::PARM_13 p13, typename outgoing_type::PARM_14 p14) +{ + fun_(bound_, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14); +} + +result_type operator()( typename outgoing_type::PARM_1 p1, typename outgoing_type::PARM_2 p2, typename outgoing_type::PARM_3 p3, typename outgoing_type::PARM_4 p4, typename outgoing_type::PARM_5 p5, typename outgoing_type::PARM_6 p6, typename outgoing_type::PARM_7 p7, typename outgoing_type::PARM_8 p8, typename outgoing_type::PARM_9 p9, typename outgoing_type::PARM_10 p10, typename outgoing_type::PARM_11 p11, typename outgoing_type::PARM_12 p12, typename outgoing_type::PARM_13 p13, typename outgoing_type::PARM_14 p14, typename outgoing_type::PARM_15 p15) +{ + fun_(bound_, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15); +} + +result_type operator()( typename outgoing_type::PARM_1 p1, typename outgoing_type::PARM_2 p2, typename outgoing_type::PARM_3 p3, typename outgoing_type::PARM_4 p4, typename outgoing_type::PARM_5 p5, typename outgoing_type::PARM_6 p6, typename outgoing_type::PARM_7 p7, typename outgoing_type::PARM_8 p8, typename outgoing_type::PARM_9 p9, typename outgoing_type::PARM_10 p10, typename outgoing_type::PARM_11 p11, typename outgoing_type::PARM_12 p12, typename outgoing_type::PARM_13 p13, typename outgoing_type::PARM_14 p14, typename outgoing_type::PARM_15 p15, typename outgoing_type::PARM_16 p16) +{ + fun_(bound_, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16); +} + +}; +COMET_CLOSE_PARTIAL() + +/** Constructs a functor that calls a function with an extra parameter (at the + * beginning) of type \p T. This gets called with the value \p bound. + * \relates binder + */ +template +functor bind_first( const functor& fun, const T& bound) +{ + return functor(std::auto_ptr< functor::IMPL >(new binder_firstCOMET_PARTIAL_NS(fun, bound))); +} + +/** Chains \p fun1 to \p fun2. + * \return functor chaining \p fun1 to \p fun2 + * \relates chainer + */ +template +functor chain( const functor& fun1, const functor& fun2) +{ + return functor(std::auto_ptr< functor::IMPL >(new chainer + +#include + +namespace comet { + /*! \addtogroup COMType + */ + //@{ + + class GIT; + + /// Type-safe GIT Cookie. + template class GIT_cookie + { + friend class GIT; + public: + GIT_cookie(const GIT_cookie& c) : cookie_(c.cookie_) {} + explicit GIT_cookie(DWORD c) : cookie_(c) {} + GIT_cookie() : cookie_(0) {} + + DWORD get_cookie() const { return cookie_; } + private: + DWORD cookie_; + }; + + /// Global Interface Table wrapper. + class GIT { + public: + GIT() : git_(CLSID_StdGlobalInterfaceTable) + {} + + /** Register Interface in the GIT. + * \param ptr Interface to register. + * \return Type-safe cookie. + */ + template + GIT_cookie register_interface(com_ptr const & ptr) + { + DWORD cookie; + git_->RegisterInterfaceInGlobal(ptr.get(), uuidof(), &cookie) | raise_exception; + return GIT_cookie(cookie); + } + + /** Retrieve Interface in the GIT. + * \param c Cookie + * \return Marshalled interface. + */ + template + com_ptr get_interface(GIT_cookie const& c) + { + Itf* itf; + git_->GetInterfaceFromGlobal(c.get_cookie(), uuidof(), reinterpret_cast(&itf)) | raise_exception; + return auto_attach(itf); + } + + /** Revoke the cookie from the GIT. + * \param c Cookie. + */ + template + void revoke_interface(GIT_cookie const& c) + { + HRESULT hr = git_->RevokeInterfaceFromGlobal(c.get_cookie()); + hr; + assert(SUCCEEDED(hr)); + } + + private: + com_ptr< ::IGlobalInterfaceTable> git_; + }; + //@} + +} // namespace comet + +#endif diff --git a/EyeTab_SP2/comet/handle.h b/EyeTab_SP2/comet/handle.h new file mode 100644 index 0000000..085bb19 --- /dev/null +++ b/EyeTab_SP2/comet/handle.h @@ -0,0 +1,363 @@ +/** \file +* Wrapper for Win32 API HANDLE. +*/ +/* +* Copyright © 2001,2004 Sofus Mortensen, Michael Geddes +* +* This material is provided "as is", with absolutely no warranty +* expressed or implied. Any use is at your own risk. Permission to +* use or copy this software for any purpose is hereby granted without +* fee, provided the above notices are retained on all copies. +* Permission to modify the code and to distribute modified code is +* granted, provided the above notices are retained, and a notice that +* the code was modified is included with the above copyright notice. +* +* This header is part of Comet version 2. +* https://github.com/alamaison/comet +*/ + +#ifndef COMET_HANDLE_H +#define COMET_HANDLE_H + +#include +#include +#include +#include +#include + +#include + +namespace comet { + + /*! \addtogroup COMType + */ + //@{ + + /** Base and policy class for auto_handle_wrap_t type. + * This provides the destroy/detach operations for auto_handle_wrap_t as well as + * providing a base class to contain the handle and to add functions to + * that are specific to the handle type. + * \relates auto_handle_wrap_t + * \sa auto_handle_wrap_t + */ + template< typename H, long INVALID_HANDLE_ > + class handle_policy_base_t + { + public: + /// Default constructor. + handle_policy_base_t() : handle_(reinterpret_cast(INVALID_HANDLE_)) {} + + explicit handle_policy_base_t( H handle) : handle_(handle) {} + + typedef H value_type; + + //! Implicit conversion to HANDLE + operator H() const throw() + { + // This function seemed not to work with returning a namespaced + // type. + return handle_; + } + static inline H invalid_handle() { return reinterpret_cast(INVALID_HANDLE_) ;} + + /// Is the handle valid? + bool valid() const + { + return handle_ != invalid_handle(); + } + + /// Detach a raw handle + H detach_handle() + { + return swap_handle(invalid_handle()); + } + + //! Detaches currently held handle without closing it. + static inline value_type detach( handle_policy_base_t &handle )throw() + { + return handle.detach_handle(); + } + + protected: + /// Destructor to prevent one of these from being created by itself. + ~handle_policy_base_t() + { } + + /// Detach the contained handle to the passed in. + void detach_to(handle_policy_base_t &rhs) throw() + { + value_type handle(handle_); + handle_= invalid_handle(); + rhs.handle_ = handle; + } + + H get_handle() const { return handle_; } + H *get_handle_ptr() { return &handle_;} + + H swap_handle(H new_handle) + { + H old = handle_; + handle_ = new_handle; + return old; + } + + private: + H handle_; + }; + + /** \class handle_nothrow_error_policy_t handle.h comet/handle.h + * Nothrow Error policy. + * \relates auto_handle_wrap_t + */ + struct handle_nothrow_error_policy_t + { + static void on_error() + { } + }; + + /** \class handle_throw_error_policy_t handle.h comet/handle.h + * Throwing Error policy. + * \relates auto_handle_wrap_t + */ + struct handle_throw_error_policy_t + { + static void on_error() + { + DWORD err = GetLastError(); + raise_exception(HRESULT_FROM_WIN32(err)); + } + }; + + /** \class auto_handle_wrap_t handle.h comet/handle.h + * Wrapper for a Win32 API/GDI HANDLE. + * Behaves similarly to an auto_ptr in that it implements single-reference, + * reference counting, with reference-transferring assignment and + * copy-construction. + */ + + template + class auto_handle_wrap_t : public handle_policy_base_t + { + typedef typename handle_policy_base_t::value_type value_type; + protected: + + /// Call destroy_handle + static inline bool destroy_( value_type h) + { + return C_::destroy_handle(h); + } + + /// Destroy the handle passed in. + /** Must be implemented by the parent class. + */ + static bool destroy_handle(value_type h); + + typedef handle_policy_base_t policy_base ; + + void set_handle( value_type h ) throw() + { + destroy_(this->swap_handle( h)); + } + + static bool expect_nonzero( BOOL value) + { + bool is_ok = (value != FALSE); + if (!is_ok) + ERROR_POLICY::on_error(); + return is_ok; + } + public: + + /// default constructor. + auto_handle_wrap_t() throw() + {} + + /// A reference to a handle. + typedef const C_ &ref; + + /** Assign by auto_attach. + */ + auto_handle_wrap_t( const impl::auto_attach_t &handle ) throw() + : policy_base(handle.get()) + {} + + /** Non-const copy constructor - takes control of the reference. + * \param rhs Handle to detach from. + */ + auto_handle_wrap_t( auto_handle_wrap_t &rhs) throw() + { + rhs.detach_to(*this); + } + + /** Non-const copy constructor - takes control of the reference. + * \param rhs Handle to detach from. + */ + auto_handle_wrap_t( policy_base &rhs) throw() + { + rhs.detach_to(*this); + } + + /** Destructor - closes the handle. + */ + ~auto_handle_wrap_t() throw() + { + destroy_(get()); + } + + + //! Assignment from similar handles. + /** Typically, there might be a different error policy. + */ + template + auto_handle_wrap_t & operator=(auto_handle_wrap_t& rhs) throw() + { + close_handle(); + rhs.detach_to(*this); + return *this; + } + + //! Assign by auto_attach + C_ &operator=(const impl::auto_attach_t &handle ) + { + close_handle(); + set_handle(handle.get()); + return *static_cast(this); + } + + //! Closes the currently held handle (if any). + bool close() throw() + { + return destroy_(policy_base::detach(*this)); + } + + //! \name Accessor methods + //@{ + + //! Fitter method. + /*! + Used when calling a function that take a HANDLE* argument. + + \code + auto_handle read_pipe, write_pipe; + + CreatePipe(read_pipe.out(), write_pipe.out(), 0, 0)); + \endcode + */ + typename policy_base::value_type* out() throw() + { + close_handle(); + return this->get_handle_ptr(); + } + + typename policy_base::value_type get() const throw() + { return this->get_handle(); } + typename policy_base::value_type in() const throw() + { return this->get_handle(); } + typename policy_base::value_type *inout() throw() + { return this->get_handle_ptr(); } + //@} + + static inline const C_ &create_const_reference(const value_type &val) + { return *reinterpret_cast(&val); } + + static inline C_ &create_reference(value_type &val) + { return *reinterpret_cast(&val); } + + /// Destroy a reference. + static bool destroy_reference(value_type h) + { + return true; + } + + private: + + //! Closes the currently held handle (if any). + inline void close_handle() + { + if (!close()) + ERROR_POLICY::on_error(); + } + }; + + namespace impl + { + /** \internal + */ + class THIS_IS_NOT_ALLOWED + { + ~THIS_IS_NOT_ALLOWED() {} + }; + } + + /// Disallow closing of a const handle. + template< typename H, long INVALID_HANDLE_ > + inline impl::THIS_IS_NOT_ALLOWED CloseHandle(const handle_policy_base_t&); + + /// Make sure closing of an auto_handle_wrap_t detaches first. + /** \return true if CloseHandle was successful. + */ + template< typename H, long INVALID_HANDLE_ > + bool CloseHandle(handle_policy_base_t &rhs) + { + return rhs.close(); + } + + /// Wrapper for HANDLE type + template< typename ERROR_POLICY = handle_nothrow_error_policy_t > + struct auto_handle_t : auto_handle_wrap_t< auto_handle_t, HANDLE, 0, ERROR_POLICY > + { + typedef auto_handle_wrap_t< auto_handle_t, HANDLE, 0, ERROR_POLICY > handle_base; + + /// Default constructor. + auto_handle_t() {} + /// Copy constructor. + auto_handle_t( auto_handle_t &rhs) + : auto_handle_wrap_t< auto_handle_t, HANDLE, 0, ERROR_POLICY >(rhs) + {} + + /// Auto_attach constructor. + auto_handle_t( const impl::auto_attach_t< HANDLE > &rhs ) + : auto_handle_wrap_t< auto_handle_t, HANDLE, 0, ERROR_POLICY >(rhs) + { } + /// Default assignment. + auto_handle_t &operator=(auto_handle_t &rhs) + { + handle_base::operator=(rhs); + return *this; + } + auto_handle_t &operator=( const impl::auto_attach_t &rhs) + { + handle_base::operator=(rhs); + return *this; + } + + /// Destroy a handle + static bool destroy_handle( HANDLE h) + { + return ::CloseHandle(h) != FALSE; + } + + }; + + /// Auto handle - wrapper for HANLDE. + typedef auto_handle_t<> auto_handle; + /// Auto handle - throwing wrapper for HANDLE. + typedef auto_handle_t< handle_throw_error_policy_t > auto_handle_throw; + + /// Create a reference object to a handle that doesn't destroy it's contents. + template + struct auto_reference_t : T + { + auto_reference_t( const comet::impl::auto_attach_t &rhs ) : T(rhs) + {} + ~auto_reference_t() + { + destroy_reference(this->detach_handle()); + } + }; + //@} +} + +using comet::CloseHandle; + +#endif diff --git a/EyeTab_SP2/comet/handle_except.h b/EyeTab_SP2/comet/handle_except.h new file mode 100644 index 0000000..f5bf6b1 --- /dev/null +++ b/EyeTab_SP2/comet/handle_except.h @@ -0,0 +1,363 @@ +/** \file + * Handle Comet exceptions. + */ +/* + * Copyright 2003 Atex Media Command. All rights reserved. + * Copyright (C) 2013 Alexander Lamaison + * + * This material is provided "as is", with absolutely no warranty + * expressed or implied. Any use is at your own risk. Permission to + * use or copy this software for any purpose is hereby granted without + * fee, provided the above notices are retained on all copies. + * Permission to modify the code and to distribute modified code is + * granted, provided the above notices are retained, and a notice that + * the code was modified is included with the above copyright notice. + * + * This header is part of Comet version 2. + * https://github.com/alamaison/comet + */ +#ifndef COMET_HANDLE_EXCEPT_H +#define COMET_HANDLE_EXCEPT_H + +#ifdef _SHOW_INC +#pragma message(" #Include " __FILE__) +#endif + +#include + +/** \page comethandleexception Custom Exception Handling + This allows the user to define how exception handling happens for a particular library. + + Unfortunately due to a compiler bug in MSVC 6 (fixed in 7), some of the + functionality won't be available for that compiler (this has also limited + the customisability originally designed for). + + To override the default behavior, specialise the struct + comet::comet_exception_handler and implement the functions defined + in the default implementation comet::comet_exception_handler. + \code + comet { + template<> + struct comet_exception_handler : comet_exception_handler + { + static inline HRESULT catcher_all( const source_info_t &info) + { + throw; + } + }; + } + \endcode + + With a suitable compiler, the method comet::comet_exception_handler::rethrow can be + overridden to provide support for custom exceptions. + + Don't try putting a try catch round a throw in \p catcher_all as the resulting destruct-twice + of the exception when using MSV6 will cause very hard to trace bugs. + */ + +#ifdef COMET_DISABLE_EXCEPTION_RETHROW_CATCH +#define COMET_CATCH_CLASS_EX(funcName,iid) \ + catch ( const com_error &err) { \ + return comet_exception_handler::catcher_com_error(err, impl::do_get_source_info_t<_B>::exec( static_cast<_B*>(this), source_info_t(funcName, iid))); \ + } catch ( const std::exception &err) { \ + return comet_exception_handler::catcher_exception(err, impl::do_get_source_info_t<_B>::exec( static_cast<_B*>(this), source_info_t(funcName, iid))); \ + } catch ( HRESULT hr ) { \ + return comet_exception_handler::catcher_hr(hr, impl::do_get_source_info_t<_B>::exec( static_cast<_B*>(this), source_info_t(funcName, iid))); \ + } catch (...) { \ + return comet_exception_handler::catcher_all( impl::do_get_source_info_t<_B>::exec( static_cast<_B*>(this), source_info_t(funcName, iid))); \ + } + +#define COMET_CATCH_UNKNOWN(funcName, iid, clsname) \ + catch ( const com_error &err) { \ + comet_exception_handler::catcher_com_error(err, source_info_t(funcName, iid, clsname)); \ + } catch ( const std::exception &err) { \ + comet_exception_handler::catcher_exception(err, source_info_t(funcName, iid, clsname)); \ + } catch ( HRESULT hr ) { \ + comet_exception_handler::catcher_hr(hr, source_info_t(funcName, iid, clsname)); \ + } catch (...) { \ + comet_exception_handler::catcher_all( source_info_t(funcName, iid, clsname)); \ + } + + +#else // COMET_DISABLE_EXCEPTION_RETHROW_CATCH + +#define COMET_CATCH_CLASS_EX( funcName, iid) \ + catch ( ... ) { \ + return comet_exception_handler::rethrow( impl::do_get_source_info_t<_B>::exec( static_cast<_B*>(this), source_info_t(funcName, iid))); \ + } + +#define COMET_CATCH_UNKNOWN(funcName, iid, clsname) \ + catch ( ... ) { \ + comet_exception_handler::rethrow( source_info_t(funcName, iid, clsname)); \ + } + +#endif + +/** Macro used in implementation wrappers to hide a bug with catching rethrown + * classes. + */ + +#define COMET_CATCH_CLASS(funcName) COMET_CATCH_CLASS_EX(funcName, comtype::uuid()) + +// We define these new catch macros because the ones above don't seem to work. +// They use a mystery _B to get the class name. It may have been part of the +// old code-generation mechanism which we don't support any more. +#define COMET_CATCH_INTERFACE_BOUNDARY(funcName) \ + catch ( ... ) { \ + return ::comet::comet_exception_handler::rethrow( \ + ::comet::source_info_t( \ + funcName, ::comet::comtype::uuid())); \ + } + +#define COMET_CATCH_CLASS_INTERFACE_BOUNDARY(funcName, clsName) \ + catch ( ... ) { \ + return ::comet::comet_exception_handler::rethrow( \ + ::comet::source_info_t( \ + funcName, ::comet::comtype::uuid(), clsName)); \ + } + +namespace comet { + + /*! \addtogroup ErrorHandling + */ + //@{ + /// Specifies the source of an exception. + struct source_info_t + { + /// Default Constructor + source_info_t() {} + /// Constructor to fill in a few elements. + source_info_t(const bstr_t &par_function, const uuid_t &par_interface_uuid = uuid_t(), const bstr_t &par_coclass_name = bstr_t() ) + : function_name(par_function), interface_uuid(par_interface_uuid), coclass_name(par_coclass_name) {} + + bstr_t function_name; ///< Name of the function being called. + bstr_t coclass_name; ///< Coclass the method belongs to. + uuid_t coclass_uuid; ///< CLSID of the coclass. + uuid_t interface_uuid; ///< IID of the interface + + bstr_t source_override; ///< Used to override the source description. + + /** Returns the 'source' description, either 'source_overrride' or the + * concatenation of the coclass and function_name. + */ + bstr_t source() const + { + if ( !source_override.is_empty()) + { + return source_override; + } + if (coclass_name.is_empty()) + { + return function_name; + } + if (function_name.is_empty()) + { + return coclass_name; + } + return coclass_name + L"." + function_name; + } + + }; + + namespace impl + { + /** Redirect logging to calllog if enabled. + * Used so that if call-logging is loaded, the default action is to + * redirect the logging to the call-logger. + * \internal + */ + template + struct call_logger_redirect_ + { + template + struct exe + { + static inline void log_exception( + const tstring& /*type*/, const tstring& /*desc*/, + const source_info_t& /*errorSource*/, + const source_info_t& /*callSource*/) + { } + static inline bool can_log_exception() + { return false; } + }; + }; + } + + /** \struct error_logger_ handle_except.h comet/handle_except.h + * Default to NULL logger - and description of 'error logger' concept. + * Specialise to \b true to override. + */ + template + struct error_logger_ + { + /** Should the error be logged? + * \return Return true to allow error to be logged. + */ + static inline bool can_log_exception() + { + return impl::call_logger_redirect_::template exe::can_log_exception(); + } + + /// Called by exception handlers to provide logging for errors. + static inline void log_exception(const tstring &type, const tstring &desc, const source_info_t &errorSource ,const source_info_t &callSource ) + { + impl::call_logger_redirect_::template exe::log_exception(type,desc,errorSource, callSource); + } + + }; + + /** Common exception handler for comet. + * Specialize to \c true to overide the behaviour. It is usually convenient + * to inherit the comet_exception_handler from + * comet_exception_handler. + */ + template< bool OVERRIDE> + struct comet_exception_handler + { +#ifndef COMET_DISABLE_EXCEPTION_RETHROW_CATCH + /** Override to modify which exceptions are caught. + * Note that due to a severe bug in MSVC 6, this will not be called in that + * case. + */ + static inline HRESULT rethrow(const source_info_t &info) + { + try { + throw; + } catch ( const com_error &err) + { + return catcher_com_error( err, info); + } + catch ( const std::exception &err) + { + return catcher_exception( err, info); + } + catch ( HRESULT hr ) + { + return catcher_hr( hr, info ); + } + catch (...) + { + return catcher_all(info); + } + + } +#endif // COMET_DISABLE_EXCEPTION_RETHROW_CATCH + + /// Override to modify handling of com_error + static inline HRESULT catcher_com_error( const com_error &err,const source_info_t &info) + { + if ( error_logger_::can_log_exception() ) + { + source_info_t errorInfo; + errorInfo.interface_uuid = err.guid(); + errorInfo.source_override = err.source(); + error_logger_::log_exception( _T("comet::com_error"), err.t_str(), errorInfo, info); + } + return impl::return_com_error(err, info.source(), info.interface_uuid); + } + /// Override to modify handling of std::exception + static inline HRESULT catcher_exception(const std::exception& err,const source_info_t &info) + { + if ( error_logger_::can_log_exception() ) + { + error_logger_::log_exception( _T("std::exception"), + bstr_t(err.what()).t_str(), + source_info_t(), info); + } + return impl::return_com_error(err, info.source(), info.interface_uuid); + } + /// Override to modify handling of HRESULT + static inline HRESULT catcher_hr( HRESULT hr,const source_info_t &info) + { + return impl::return_com_error(hr, bstr_t(), info.source(), info.interface_uuid); + } + /// This can be overridden to provide handling of other exceptions. + static inline HRESULT catcher_all( const source_info_t &info) + { + COMET_NOTUSED(info); + throw; + } + }; + + + namespace impl + { + /** Marker for using the coclass information. + * \relates handle_exception_default + */ + struct handle_exception_default_marker {}; + + /** Call the coclasses exception handler if it is marked. + * \relates handle_exception_default + */ + template + struct do_get_source_info_t + { + /** Call the classes exception handler. + * \relates handle_exception_default + */ + template + struct execute_handle + { + inline static void get_source_info(O * pThis, source_info_t &info) + { + pThis->get_source_info_( info ); + } + }; + /** Call the default global exception handler. + * \relates handle_exception_default + */ + template <> + struct execute_handle + { + inline static void get_source_info(O *pThis, const source_info_t &info ) + { + COMET_NOTUSED(pThis); + COMET_NOTUSED(info); + // return impl::do_handle_exception(src); + } + }; + + /** Called by the interface wrappers to call the exception handlers. + * \relates handle_exception_default + */ + inline static source_info_t exec( O *pThis, source_info_t info) + { + // Either call the coclass exception handler, or the project default. + execute_handle::exists>::get_source_info( pThis, info); + /* ERRORS: If the conversion is ambiguous here, then there are probably two ways of + * getting to handle_exception_default_marker, usually via handle_exception_default, + * which is already provided by by IProvideClassInfoImpl. + */ + return info; + } + }; + } + + /** \struct handle_exception_default server.h comet/server.h + * Used by the exception handler to provide source information for the specified CoClass. + * Inherit from this class or IProvideClassInfoImpl to make sure that the + * coclass name is known about for custom coclasses. + */ + template + struct handle_exception_default + : impl::handle_exception_default_marker // Required to mark the class as being able to handle exceptions with coclass information + { + void get_source_info_( source_info_t &info) + { + info.coclass_name = COCLASS::name(); + info.coclass_uuid = comtype::uuid(); + } + }; + // Handles the case where there is no coclass, and therefore no coclass name. + template<> + struct handle_exception_default : impl::handle_exception_default_marker + { + void get_source_info_( source_info_t &info) + { + COMET_NOTUSED(info); + } + }; + //@} +} +#endif /* COMET_HANDLE_EXCEPT_H */ diff --git a/EyeTab_SP2/comet/impqi.h b/EyeTab_SP2/comet/impqi.h new file mode 100644 index 0000000..67e1f07 --- /dev/null +++ b/EyeTab_SP2/comet/impqi.h @@ -0,0 +1,546 @@ +/** \file + * Implementation of QueryInterface. + */ +/* + * Copyright © 2000-2002 Sofus Mortensen, Michael Geddes + * + * This material is provided "as is", with absolutely no warranty + * expressed or implied. Any use is at your own risk. Permission to + * use or copy this software for any purpose is hereby granted without + * fee, provided the above notices are retained on all copies. + * Permission to modify the code and to distribute modified code is + * granted, provided the above notices are retained, and a notice that + * the code was modified is included with the above copyright notice. + * + * This header is part of Comet version 2. + * https://github.com/alamaison/comet + */ + +#ifndef COMET_IMPQI_H +#define COMET_IMPQI_H + +#include + +#include + +#include +#include +#include +#include +#include +#include +#include + +namespace comet { + /*! \addtogroup Interfaces + */ + //@{ + + + + namespace impl { + + /** Base class for recognising qi hook. + * \internal + */ + class qi_hook_itf_tag {}; + + } + + class qi_hook {}; + + template class qi_hook_itf : public impl::qi_hook_itf_tag{ + public: + typedef Itf exposes; + virtual com_ptr get_interface_ptr(const com_ptr< ::IUnknown>&) throw() = 0; + }; + + namespace impl { + + template COMET_FORCEINLINE bool is_interface_compatible(const uuid_t& iid, Itf*) + { + if (iid == uuidof()) return true; + else return is_interface_compatible::base>(iid, 0); + } + + template<> COMET_FORCEINLINE bool is_interface_compatible< ::IUnknown >(const uuid_t&, ::IUnknown*) + { + return false; + } + + template<> COMET_FORCEINLINE bool is_interface_compatible(const uuid_t&, nil*) + { + return false; + } + enum use_cast_t {uc_false=0, uc_static, uc_static_op, uc_qi_hook_itf, uc_qi_hook }; + + + // remove enum for VC2005B2 + template + struct find_compatibility_aux + { + template + struct with + { + enum { is = false }; + + template inline static bool qi(P *, const uuid_t& , com_ptr< ::IUnknown>& ) + { + return false; + } + }; + }; + + template<> + struct find_compatibility_aux + { + template struct with { + template static bool qi(T *This, const uuid_t& iid, com_ptr< ::IUnknown>& unk) + { + if (is_interface_compatible(iid, 0)) + { + unk = static_cast< ::IUnknown* >(static_cast(This)); + return true; + } + return false; + } + }; + }; + + template<> + struct find_compatibility_aux + { + template struct with { + template static bool qi(T *This, const uuid_t& iid, com_ptr< ::IUnknown>& unk) + { + if (is_interface_compatible(iid,0)) { + unk = static_cast*>(This)->get_interface_ptr( cast_to_unknown(This) ); + return true; + } + return false; + } + }; + }; + + template<> + struct find_compatibility_aux + { + template struct with { + template static bool qi(T *This, const uuid_t& iid, com_ptr< ::IUnknown>& unk) + { + if ( static_cast(This)->qi(This, iid, unk) ) + return true; + else + return false; + } + }; + }; + +/* template<> + struct find_compatibility_aux + { + template + struct with + { + static bool is( const uuid_t &iid){ return is_interface_compatible(iid,0);} + template + static com_ptr< ::IUnknown> cast_from(T *This) + { +#ifndef NDEBUG + try { +#endif + return static_cast*>(This)->get_interface_ptr( cast_to_unknown(This) ); +#ifndef NDEBUG + } catch (...) { + // get_interface_ptr is not allowed to throw. Return null pointer on failure + COMET_ASSERT(0); + return 0; + } +#endif + } + }; + }; + + template<> + struct find_compatibility_aux + { + template + struct with + { + static bool is( const uuid_t &iid){ return true; } + + template + static com_ptr< ::IUnknown> cast_from(T *This) + { + Itf:: + } + }; + };*/ + + template< typename Itf> + struct use_cast_aux + { + enum { is_static = (type_traits::conversion::exists) }; + enum { is_static_op =(type_traits::is_cast_operator_compatible::is)}; + enum { is_qi_hook_itf = (type_traits::conversion::exists) }; + enum { is_qi_hook = (type_traits::conversion::exists) }; + // GCC Doesn't handle evaluation of ?: opeators in templates yet. +// enum { is = (int)( is_static ? uc_static: ( is_static_op ? uc_static_op : uc_false)) + enum { is = is_static * uc_static + + is_qi_hook_itf * uc_qi_hook_itf + + is_qi_hook * uc_qi_hook + + is_static_op * uc_static_op }; + }; + + template + struct find_compatibility + { + enum { needs_cast_ = use_cast_aux::is }; + typedef find_compatibility_aux< (use_cast_t)needs_cast_ > compatible; + + COMET_FORCEINLINE static bool with(const uuid_t &iid) + { return compatible::template with::is(iid); }; + template + COMET_FORCEINLINE static com_ptr< ::IUnknown> cast_from( T *This) + { return compatible::template with::cast_from(This); } + }; + + template struct interface_finder + { + template COMET_FORCEINLINE static bool find_interface(T* This, const uuid_t& iid, com_ptr< ::IUnknown>& rv) + { + typedef typename find_compatibility_aux< (use_cast_t)use_cast_aux< COMET_STRICT_TYPENAME ITF_LIST::head >::is >::template with fc; + if ( fc::qi(This, iid, rv) ) + return true; + else + return interface_finder< COMET_STRICT_TYPENAME ITF_LIST::tail>::find_interface(This, iid, rv); + } + + COMET_FORCEINLINE static bool find_interface_2(const uuid_t& iid) + { + if (is_interface_compatible(iid, 0)) return true; + return interface_finder< COMET_STRICT_TYPENAME ITF_LIST::tail>::find_interface_2(iid); + } + }; + + template<> struct interface_finder + { + template COMET_FORCEINLINE static bool find_interface(T*, const uuid_t&, com_ptr< ::IUnknown>&) + { return false; } + + COMET_FORCEINLINE static bool find_interface_2(const uuid_t&) + { + return false; + } + }; + +/* template<> struct interface_finder > + { + template COMET_FORCEINLINE static ::IUnknown* find_interface(T*, const uuid_t&) + { + return 0; + } + };*/ + + } + + /** \struct typelibrary_loader impqi.h comet/impqi.h + * Type Library Loader. + * Allow provision for different means of loading a type-library. + * \param TL A \e Comet type-library. + */ + template + struct typelibrary_loader + { + //! Load the type-library. + /** Create a different template instantiation of this to load + * type-libraries from a different source (example - from a second + * resource in the dll). + */ + static inline HRESULT load( ITypeLib **pTypeLib) + { return LoadRegTypeLib(uuidof(), TL::major_version, TL::minor_version, LANG_NEUTRAL, pTypeLib); } + }; + + /** \struct implement_qi impqi.h comet/impqi.h + * Implementation of QueryInterface. Inherits from all the types defined + * in \p ITF_LIST. + * \param ITF_LIST interface implementation list. + */ + template class ATL_NO_VTABLE implement_qi : public typelist::inherit_all + { + private: + // Hide qi + void qi(); + public: + /** Get at the unknown for this class. Is here for compatibility when using + * implement_internal_qi via aggregateable_coclass for getting at a + * pointer from which to QueryInterface from. + */ + ::IUnknown* get_unknown()const + { return static_cast< typename ITF_LIST::head * >(const_cast *>(this)); } + + STDMETHOD(QueryInterface)(REFIID riid, void** ppv) + { + const uuid_t& iid = uuid_t::create_const_reference(riid); + com_ptr< ::IUnknown> p; + + impl::interface_finder::find_interface(this, iid, p); + + if (!p) { + if (riid != IID_IUnknown) { + *ppv = 0; + return E_NOINTERFACE; + } + p = get_unknown(); +// p = static_cast< ::IUnknown* >(static_cast< typename ITF_LIST::head * >(this)); + } + + *ppv = reinterpret_cast(p.detach()); + + return S_OK; + } + }; + + /** \struct implement_internal_qi impqi.h comet/impqi.h + * Implementation of QueryInterfaceInternal. Inherits from all the types defined + * in \p ITF_LIST. This implementation is used in aggregation. + * \param ITF_LIST interface implementation list. + */ + template class ATL_NO_VTABLE implement_internal_qi : public typelist::inherit_all + { + private: + void qi(); + public: + /** Get at the unknown for this class. Is especially useful using + * aggregateable_coclass in getting at a pointer from which to + * QueryInterface from. + */ + ::IUnknown* get_unknown()const + { return static_cast< typename ITF_LIST::head * >( const_cast *>(this)); } + + HRESULT QueryInterfaceInternal(REFIID riid, void** ppv) + { + const IID& iid = riid; + com_ptr< ::IUnknown> p; + + impl::interface_finder::find_interface(this, iid, p); + + if (!p) { + if (riid != IID_IUnknown) { + *ppv = 0; + return E_NOINTERFACE; + } +// p = cast_to_unknown(this); + p = static_cast< ::IUnknown* >(static_cast(this)); + } + + *ppv = reinterpret_cast(p.detach()); + + return S_OK; + } + }; + + namespace impl { + template ::IUnknown* cast_to_unknown(implement_qi* iq) + { return static_cast< typename ITF_LIST::head*>(iq); } + } + + /** \class impl_dispatch impqi.h comet/impqi.h + * Implement IDispatch via type-library. + */ + template class ATL_NO_VTABLE impl_dispatch : public BASE + { + protected: + /// \name IDispatch Interface + //@{ + STDMETHOD(GetTypeInfo)(UINT, LCID, ITypeInfo** ti) + { + *ti = get_ti(); + if (*ti) + { + (*ti)->AddRef(); + return S_OK; + } + return E_NOTIMPL; + } + + STDMETHOD(GetTypeInfoCount)(UINT *it) + { *it = 1; return S_OK; } + + STDMETHOD(GetIDsOfNames)(REFIID, OLECHAR** pNames, UINT cNames, LCID, DISPID* pdispids) + { + ITypeInfo* ti = get_ti(); + if (ti) + return ti->GetIDsOfNames(pNames, cNames, pdispids); + else + return E_NOTIMPL; + } + + STDMETHOD(Invoke)(DISPID id, REFIID, LCID, WORD wFlags, DISPPARAMS *pd, VARIANT* pVarResult, EXCEPINFO* pe, UINT* pu) + { + ITypeInfo* ti = get_ti(); + if (ti) + { + void* pThis = static_cast(this); + return ti->Invoke(pThis, id, wFlags, pd, pVarResult, pe, pu); + } + else + return E_NOTIMPL; + } + //@} + private: + ITypeInfo* get_ti() + { + static ITypeInfo* ti_; + if (ti_ == 0) + { + auto_cs lock(module().cs()); + if (ti_ == 0) + { + com_ptr ptl; + + typelibrary_loader::load(ptl.out()); + if (ptl) ptl->GetTypeInfoOfGuid(uuidof(), &ti_); + + if (ti_ != 0) module().add_object_to_dispose( impl::create_itf_releaser(ti_) ); + } + } + return ti_; + } + +// static ITypeInfo* ti_; + }; + + template class com_ptr; + +#if 0 + /** \class aggregates_interface impqi.h comet/impqi.h + * Used as an implementation for an interface to Aggregate the required + * interface. + */ + template< typename Itf > + class aggregates_interface + { + public: + /** Set the inner-unknown returned from the call to CoCreateInstance. + */ + void set_aggregate(const com_ptr< ::IUnknown>& aggobj) { ag_object_ = com_cast(aggobj); } + /** Used by QueryInteface algorithms to work out the interface + * exposed by this class. + */ + typedef Itf exposes; + + operator Itf*() throw() + { + com_ptr< ::IUnknown> test = ag_object_; + return ag_object_.in(); +// return com_ptr( com_cast(ag_object_) ); + } + protected: + com_ptr ag_object_; + + }; +#endif + + + + + + +/* class FTM : public qi_hook_itf + { + private: + com_ptr get_interface_ptr(const com_ptr< ::IUnknown>& This) throw() + { + ::IUnknown* ftm = 0; + CoCreateFreeThreadedMarshaler(This.in(), &ftm); + return com_cast(ftm); + } + };*/ + + /** \struct FTM impqi.h comet/impqi.h + * Aggregate the Free Threaded Marshaller. + * \code + class coclass_implementation + : public coclass + { + ... + }; + \endcode + */ + struct FTM : public qi_hook + { + template + bool qi(T *This, const uuid_t& iid, com_ptr< ::IUnknown>& unk) + { + if (iid != uuidof()) return false; + ::IUnknown* ftm = 0; + CoCreateFreeThreadedMarshaler(impl::cast_to_unknown(This), &ftm); + unk = com_ptr< ::IMarshal>( com_cast(ftm) ); + return unk != 0; + } + }; + + /** \struct aggregates impqi.h comet/impqi.h + * Aggregate an interface. + * \code + class coclass_implementation + : public coclass > + { + coclass_implementation() + { + aggregatescreate_aggregate::create_aggregate(this, CLSCTX_ALL); + } + }; + \endcode + + \sa coclass + */ + template class aggregates : public qi_hook + { + com_ptr< ::IUnknown> inner_; + public: + template bool qi(T *This, const uuid_t& iid, com_ptr< ::IUnknown>& unk) + { + typedef typename make_list::result TL; + if (typelist::length::value > 0) { + if (impl::interface_finder::find_interface_2(iid) == false) return false; + } + if (inner_ == 0) return false; + ::IUnknown* p; + if (SUCCEEDED(inner_.raw()->QueryInterface(iid, reinterpret_cast(&p)))) + { + unk = auto_attach(p); + return true; + } + return false; + } + protected: + template void create_aggregate(T *This, DWORD dwClsContext = CLSCTX_ALL) + { ::IUnknown* unk_this = impl::cast_to_unknown(This); inner_ = com_ptr< ::IUnknown>(uuidof(), com_ptr< ::IUnknown>::create_reference(unk_this), dwClsContext); } + }; + +/* template class aggregates_interface : public qi_hook_itf + { + private: + com_ptr< ::IUnknown> inner_; + com_ptr get_interface_ptr(const com_ptr< ::IUnknown>&) + { return com_cast(inner_); } + protected: + template void create_aggregate(const CLSID& clsid, implement_qi* This, DWORD dwClsContext = CLSCTX_ALL) + { + ::IUnknown* unk_this = static_cast< typename ITF_LIST::head*>(This); + inner_ = com_ptr< ::IUnknown>(clsid, com_ptr< ::IUnknown>::create_reference(unk_this), dwClsContext); + } + + template void create_aggregate(const wchar_t* progid, implement_qi* This, DWORD dwClsContext = CLSCTX_ALL) + { + ::IUnknown* unk_this = static_cast< typename ITF_LIST::head*>(This); + inner_ = com_ptr< ::IUnknown>(progid, com_ptr< ::IUnknown>::create_reference(unk_this), dwClsContext); + } + };*/ + + //@} +} + +#endif diff --git a/EyeTab_SP2/comet/interface.h b/EyeTab_SP2/comet/interface.h new file mode 100644 index 0000000..cfaefb4 --- /dev/null +++ b/EyeTab_SP2/comet/interface.h @@ -0,0 +1,256 @@ +/** \file + * Provide comtype which supplies information about UUIDs & inheritance, + * potentially from Interfaces not defined using a COMET type-library. Also + * defines specialisations for some such standard interfaces. + */ +/* + * Copyright © 2000, 2001 Sofus Mortensen + * + * This material is provided "as is", with absolutely no warranty + * expressed or implied. Any use is at your own risk. Permission to + * use or copy this software for any purpose is hereby granted without + * fee, provided the above notices are retained on all copies. + * Permission to modify the code and to distribute modified code is + * granted, provided the above notices are retained, and a notice that + * the code was modified is included with the above copyright notice. + * + * This header is part of Comet version 2. + * https://github.com/alamaison/comet + */ + +#ifndef COMET_INTERFACE_H +#define COMET_INTERFACE_H + +#include + +#include +#include +#include + +#include +#include +#include + +#pragma warning(push, 4) +// NB: coclass_implementation _must_ have no data members. +// The comet framework uses the test +// sizeof coclass_implementation == sizeof coclass_implementation +// in order to determine whether the user has specialized based on T or not. +// The logic here is that any real implementation will have a size that is at least +// sizeof IUnknown, because any real coclass_implementation must at least derive +// off IUnknown and have a "vtable" pointer. +/** \class coclass_implementation interface.h comet/interface.h + * Utility class to make the implementation of a coclass accessible from the + * servers. Implementations of coclasses defined in the type library should + * all be specialisations of this class if they are to be exposed by the + * comet server. + */ +template class coclass_implementation {}; + +#pragma warning(pop) + +namespace comet { + + /** Provide a means for defining new comtype definitions. + */ + template struct uuid_comtype + { + static const uuid_t& uuid() { return uuid_t::create_const_reference(*ItfID); } + typedef BASE base; + }; + + + /** Provide access to uuid and base type of objects. + * Specializations allow access to information relevant to non-comet + * defined interfaces. + */ + template struct comtype { + static const IID& uuid() throw() { return comtype::uuid(); } + typedef typename comtype::base base; + }; + + template<> struct comtype { +// static const IID& uuid() throw() { throw std::logic_error("interface.h:35"); return IID_NULL; } + typedef nil base; + }; + + template<> struct comtype< ::IUnknown > + { + static const IID& uuid() { return IID_IUnknown; } + typedef nil base; + }; + + template<> struct comtype + { + static const IID& uuid() { return IID_IConnectionPoint; } + typedef ::IUnknown base; + }; + + template<> struct comtype + { + static const IID& uuid() { return IID_IConnectionPointContainer; } + typedef ::IUnknown base; + }; + + template<> struct comtype + { + static const IID& uuid() { return IID_IEnumConnections; } + typedef ::IUnknown base; + }; + + template<> struct comtype + { + static const IID& uuid() { return IID_IDispatch; } + typedef ::IUnknown base; + }; + + template<> struct comtype + { + static const IID& uuid() { return IID_IEnumVARIANT; } + typedef ::IUnknown base; + }; + + template<> struct comtype + { + static const IID& uuid() { return IID_ISupportErrorInfo; } + typedef ::IUnknown base; + }; + + template<> struct comtype + { + static const IID& uuid() { return IID_IErrorInfo; } + typedef ::IUnknown base; + }; + + template<> struct comtype + { + static const IID& uuid() throw() { return IID_IProvideClassInfo; } + typedef ::IUnknown base; + }; + + template<> struct comtype + { + static const IID& uuid() throw() { return IID_IPersist; } + typedef ::IUnknown base; + }; + + template<> struct comtype + { + static const IID& uuid() throw() { return IID_IPersistFile; } + typedef ::IPersist base; + }; + + template<> struct comtype + { + static const IID& uuid() throw() { return IID_IPersistStream; } + typedef ::IPersist base; + }; + + template<> struct comtype + { + static const IID& uuid() throw() { return IID_IPersistStreamInit; } + typedef ::IPersist base; + }; + + template<> struct comtype + { + static const IID& uuid() throw() { return IID_IMessageFilter; } + typedef ::IUnknown base; + }; + + template<> struct comtype + { + static const IID& uuid() throw() { return IID_IProvideClassInfo2; } + typedef ::IUnknown base; + }; + + template<> struct comtype + { + static const IID& uuid() throw() { return IID_IMarshal; } + typedef ::IUnknown base; + }; + + template<> struct comtype + { + static const IID& uuid() throw() { return IID_IFontDisp; } + typedef ::IDispatch base; + }; + + template<> struct comtype + { + static const IID& uuid() throw() { return IID_IPictureDisp; } + typedef ::IDispatch base; + }; + template<> struct comtype + { + static const IID& uuid() throw() { return IID_IGlobalInterfaceTable; } + typedef ::IUnknown base; + }; + + template<> struct comtype + { + static const IID& uuid() throw() { return IID_IClassFactory; } + typedef ::IUnknown base; + }; + + template<> struct comtype + { + static const IID& uuid() throw() { return IID_IStream; } + typedef ::IUnknown base; + }; + + template<> struct comtype + { + static const IID& uuid() throw() { return IID_ISequentialStream; } + typedef ::IUnknown base; + }; + + + + //! C++ replacement of VC's __uuidof() + /*! + Use this function to an IID to an interface or coclass. + */ + template inline const uuid_t& uuidof(Itf * = 0) throw() + { return uuid_t::create_const_reference(comtype::uuid()); } + + namespace impl { + + template struct interface_lookup + { + static bool supports(const uuid_t& iid) + { + if (iid == uuidof()) + return true; + else + return interface_lookup< typename comtype::base >::supports(); + } + + template static Itf* cast(T* t) + { + return static_cast(t); + } + }; + + template<> struct interface_lookup + { + static bool supports(const uuid_t&) + { + return false; + } + + }; + +/* template<> struct interface_lookup > + { + static bool supports(const uuid_t&) + { + return false; + } + + };*/ + } + +} // namespace + +#endif diff --git a/EyeTab_SP2/comet/invariant_lock.h b/EyeTab_SP2/comet/invariant_lock.h new file mode 100644 index 0000000..25215c7 --- /dev/null +++ b/EyeTab_SP2/comet/invariant_lock.h @@ -0,0 +1,126 @@ +/** \file + * Implementation of invariant_lock asserts. + */ +/* + * Copyright © 2000, 2001 Sofus Mortensen, Paul Hollingsworth + * + * This material is provided "as is", with absolutely no warranty + * expressed or implied. Any use is at your own risk. Permission to + * use or copy this software for any purpose is hereby granted without + * fee, provided the above notices are retained on all copies. + * Permission to modify the code and to distribute modified code is + * granted, provided the above notices are retained, and a notice that + * the code was modified is included with the above copyright notice. + * + * This header is part of Comet version 2. + * https://github.com/alamaison/comet + */ + +#ifndef COMET_UTIL_H +#define COMET_UTIL_H + +#include + +#include + +#include + +namespace comet { + /*! \addtogroup Misc + */ + //@{ + + /** Contains implementation of invariant_lock asserts. + */ + namespace invariant_lock_impl { + + /** Provides base class for invariant_locks. + * \sa create_invariant_lock enforcer simple_enforcer + */ + class invariant_lock + { + protected: + invariant_lock() {} + invariant_lock(const invariant_lock& /*rhs*/) {} + }; + + /** A version of invariant_lock able to call any void member of a class. + * The member should provide an assertable condition that gets asserted + * on creation and destruction of the lock. + * \sa create_invariant_lock + */ + template struct enforcer : public invariant_lock + { + void (CLASS::*m_passert) () const; + const CLASS *m_pobj; + + enforcer(const CLASS *pobj, void (CLASS::*passert) () const + ) : m_pobj(pobj), m_passert(passert) + { + (m_pobj->*m_passert)(); + } + ~enforcer() + { + (m_pobj->*m_passert)(); + } + }; + + /** A version of invariant_lock that calls public method \b assert_valid on + * construction and destruction of the lock. + * \sa create_invariant_lock + */ + template struct simple_enforcer : public invariant_lock + { + const CLASS *m_pobj; + simple_enforcer(const CLASS *pobj) : m_pobj(pobj) + { + m_pobj->assert_valid(); + } + + ~simple_enforcer() + { + m_pobj->assert_valid(); + } + }; + } // namespace invariant_lock_impl + + /*! Create an invariant_lock. + * \param pobj The class with the invariant assert + * \param assert_member The void member to call on construct & destruct + * \author Paul Hollingsworth (Paul@PaulHollingsworth.com) + * \relates invariant_lock_impl::invariant_lock + * \sa enforcer + */ + template + invariant_lock_impl::enforcer create_invariant_lock(const CLASS *pobj, void (CLASS::*assert_member) () const) + { + return invariant_lock_impl::enforcer(pobj, assert_member); + } + + /*! Create a simple invariant lock. + * This lock will expect assert_valid to be publicly defined on the object + * provided. + * \param pobj The class with the invariant assert. + * \relates invariant_lock_impl::invariant_lock + * \sa simple_enforcer + * \author Paul Hollingsworth (Paul@PaulHollingsworth.com) + */ + template + invariant_lock_impl::simple_enforcer create_invariant_lock(const CLASS *pobj) + { + return pobj; + } + + /*! Pointer class to an invariant_lock. + * Assigning a temporary to a const reference will cause the object to be + * kept for the scope of the const reference. + * \relates invariant_lock_impl::invariant_lock + * \sa create_invariant_lock + * \author Paul Hollingsworth (Paul@PaulHollingsworth.com) + */ + typedef invariant_lock_impl::invariant_lock &invariant_lock; + //@} + +} // namespace + +#endif diff --git a/EyeTab_SP2/comet/lw_lock.h b/EyeTab_SP2/comet/lw_lock.h new file mode 100644 index 0000000..c5752f1 --- /dev/null +++ b/EyeTab_SP2/comet/lw_lock.h @@ -0,0 +1,228 @@ +/** \file + * Lightweight Multiple Reader Single Writer lock. + * + * See \ref cometlwlock. + * + * The lw_lock class is heavily based on class LightweightLock written by Brad Wilson. + * see http://www.quality.nu/dotnetguy/archive/fog0000000007.aspx + * \author Brad Wilson + * \author Sofus Mortensen + */ + +// Copyright (C) 1995-2002 Brad Wilson +// +// This material is provided "as is", with absolutely no warranty +// expressed or implied. Any use is at your own risk. Permission to +// use or copy this software for any purpose is hereby granted without +// fee, provided the above notices are retained on all copies. +// Permission to modify the code and to distribute modified code is +// granted, provided the above notices are retained, and a notice that +// the code was modified is included with the above copyright notice. +// +//////////////////////////////////////////////////////////////////////// + +/** \page cometlwlock Lightweight Lock + This lightweight lock class was adapted from samples and ideas that + were put across the ATL mailing list. It is a non-starving, kernel- + free lock that does not order writer requests. It is optimized for + use with resources that can take multiple simultaneous reads, + particularly when writing is only an occasional task. + + Multiple readers may acquire the lock without any interference with + one another. As soon as a writer requests the lock, additional + readers will spin. When the pre-writer readers have all given up + control of the lock, the writer will obtain it. After the writer + has rescinded control, the additional readers will gain access + to the locked resource. + + This class is very lightweight. It does not use any kernel objects. + It is designed for rapid access to resources without requiring + code to undergo process and ring changes. Because the "spin" + method for this lock is "Sleep(0)", it is a good idea to keep + the lock only long enough for short operations; otherwise, CPU + will be wasted spinning for the lock. You can change the spin + mechanism by #define'ing COMET_LW_LOCK_SPIN before including this + header file. + + VERY VERY IMPORTANT: If you have a lock open with read access and + attempt to get write access as well, you will deadlock! Always + rescind your read access before requesting write access (and, + of course, don't rely on any read information across this). + + This lock works in a single process only. It cannot be used, as is, + for cross-process synchronization. To do that, you should convert + this lock to using a semaphore and mutex, or use shared memory to + avoid kernel objects. + */ + +/* + * Copyright © 2002 Sofus Mortensen + * + * This material is provided "as is", with absolutely no warranty + * expressed or implied. Any use is at your own risk. Permission to + * use or copy this software for any purpose is hereby granted without + * fee, provided the above notices are retained on all copies. + * Permission to modify the code and to distribute modified code is + * granted, provided the above notices are retained, and a notice that + * the code was modified is included with the above copyright notice. + * + * This header is part of Comet version 2. + * https://github.com/alamaison/comet + */ + +#include +#include + +#include + +namespace comet { + +#ifndef COMET_LW_LOCK_SPIN +#define COMET_LW_LOCK_SPIN Sleep(0) +#endif + /*! \addtogroup Misc + */ + //@{ + + /** Provide a lightweight lock imlementation. + * See \ref cometlwlock for more information and warnings. + * \sa auto_reader_lock auto_writer_lock + */ + class lw_lock + { + // Interface + + public: + /// Constructor + lw_lock() + { + reader_count_ = 0; + writer_count_ = 0; + } + + /// Destructor + ~lw_lock() + { + COMET_ASSERT( reader_count_ == 0 ); + COMET_ASSERT( writer_count_ == 0 ); + } + + /// Reader lock acquisition + void enter_reader() const + { + for (;;) + { + // If there's a writer already, spin without unnecessarily + // interlocking the CPUs + + if( writer_count_ != 0 ) + { + COMET_LW_LOCK_SPIN; + continue; + } + + // Add to the readers list + + InterlockedIncrement((long *)&reader_count_ ); + + // Check for writers again (we may have been pre-empted). If + // there are no writers writing or waiting, then we're done. + + if( writer_count_ == 0 ) + break; + + // Remove from the readers list, spin, try again + + InterlockedDecrement((long *)&reader_count_ ); + COMET_LW_LOCK_SPIN; + } + } + + /// Reader lock release + void leave_reader() const + { + InterlockedDecrement((long *)&reader_count_ ); + } + + /// Writer lock acquisition + void enter_writer() + { + // See if we can become the writer (expensive, because it inter- + // locks the CPUs, so writing should be an infrequent process) + + while( InterlockedExchange((long *)&writer_count_, 1 ) == 1 ) + { + COMET_LW_LOCK_SPIN; + } + + // Now we're the writer, but there may be outstanding readers. + // Spin until there aren't any more; new readers will wait now + // that we're the writer. + + while( reader_count_ != 0 ) + { + COMET_LW_LOCK_SPIN; + } + } + + /// Writer lock release + void leave_writer() + { + writer_count_ = 0; + } + + // Implementation + + private: + mutable long volatile reader_count_; + mutable long volatile writer_count_; + + // Declare class non-copyable + lw_lock(const lw_lock&); + lw_lock& operator=(const lw_lock&); + }; + + /** \class auto_reader_lock lw_lock.h comet/lw_lock.h + * Auto-release locking class for lw_lock Read acces. + * \sa lw_lock auto_writer_lock + */ + class auto_reader_lock { + public: + explicit auto_reader_lock(const lw_lock& cs) : cs_(cs) { + cs_.enter_reader(); + } + + ~auto_reader_lock() { + cs_.leave_reader(); + } + + private: + auto_reader_lock& operator=(const auto_reader_lock&); + auto_reader_lock(const auto_reader_lock&); + + const lw_lock& cs_; + }; + + /** \class auto_writer_lock lw_lock.h comet/lw_lock.h + * Auto-release locking class for lw_lock write acces. + * \sa lw_lock auto_reader_lock + */ + class auto_writer_lock { + public: + explicit auto_writer_lock(lw_lock& cs) : cs_(cs) { + cs_.enter_writer(); + } + + ~auto_writer_lock() { + cs_.leave_writer(); + } + + private: + auto_writer_lock& operator=(const auto_writer_lock&); + auto_writer_lock(const auto_writer_lock&); + + lw_lock& cs_; + }; + //@} + +} diff --git a/EyeTab_SP2/comet/module.h b/EyeTab_SP2/comet/module.h new file mode 100644 index 0000000..2bfb8c6 --- /dev/null +++ b/EyeTab_SP2/comet/module.h @@ -0,0 +1,274 @@ +/** \file + * Main functionality for providing a COM module. + */ +/* + * Copyright © 2000-2002 Sofus Mortensen, Paul Hollingsworth, Michael Geddes, Mikael Lindgren + * + * This material is provided "as is", with absolutely no warranty + * expressed or implied. Any use is at your own risk. Permission to + * use or copy this software for any purpose is hereby granted without + * fee, provided the above notices are retained on all copies. + * Permission to modify the code and to distribute modified code is + * granted, provided the above notices are retained, and a notice that + * the code was modified is included with the above copyright notice. + * + * This header is part of Comet version 2. + * https://github.com/alamaison/comet + */ + +#ifndef COMET_MODULE_H +#define COMET_MODULE_H + +#include +#include +#include +#include + +namespace comet { + + /*!\addtogroup Server + */ + //@{ + namespace impl { + /** \internal + * 'Command' base class. + */ + struct cmd_t + { + virtual void cmd() = 0; + cmd_t() {} + private: + cmd_t(const cmd_t&); + cmd_t& operator=(const cmd_t&); + }; + + /** \internal + * 'Command' to delete a pointer. + * + */ + template + struct itf_releaser_t : public cmd_t + { + void cmd() { IUnknown *p = p_; p_=NULL; p->Release(); } + itf_releaser_t(T *&p) :p_(p) { } + private: + T *&p_; + itf_releaser_t(const itf_releaser_t&); + itf_releaser_t& operator=(const itf_releaser_t&); + }; + + template + cmd_t *create_itf_releaser( T *&p) + { + return new itf_releaser_t(p); + } + + /** 'Command' to Call object_dispose on an object. + * \internal + */ + template + struct pointer_deleter_t : public cmd_t + { + void cmd() { T *p = p_; p_=NULL; delete p;} + pointer_deleter_t(T *&p) :p_(p) { } + private: + T *&p_; + pointer_deleter_t(const pointer_deleter_t&); + pointer_deleter_t& operator=(const pointer_deleter_t&); + }; + + /** 'Command' to Call object_dispose on an object. + * \internal + */ + template + struct object_disposer_t : public cmd_t + { + void cmd() { p_->object_dispose(); } + object_disposer_t( T*p) : p_(p) {} + private: + T *p_; + object_disposer_t(const object_disposer_t &); + object_disposer_t &operator=(const object_disposer_t &); + }; + } + //! Create a pointer deleter command. + /** A command to delete pointers, commonly used for shutdown. + * \code + module().add_object_to_dispose(create_pointer_deleter(new my_class_t())); + * \endcode + * \sa module_t::add_object_to_dispose + */ + template + impl::cmd_t *create_pointer_deleter( T *&p) + { + return new impl::pointer_deleter_t(p); + } + //! Create an interface releaser command. + /** A command to release COM objects, commonly used for shutdown. + * Used for singletons. + * \code + module().add_object_to_dispose(create_interface_releaser(new my_coclass())); + * \endcode + * \sa module_t::add_object_to_dispose + */ + template + impl::cmd_t *create_interface_releaser( T *&p) + { + return new impl::itf_releaser_t(p); + } + + //! Create a more generic object 'disposer'. + /** Creates a Command that calls a static object_dispose(p) method. + * \code + class my_class_t + { + object_dispose( my_class_t *val) + { + val->destroy_myself(); + } + }; + module().add_object_to_dispose(create_object_disposer(new my_class_t())); + * \endcode + * \sa module_t::add_object_to_dispose + */ + template + impl::cmd_t *create_object_disposer( T *p ) + { + return new impl::object_disposer_t(p); + } + + /// COM module. + struct module_t + { + //! \name Attributes + //@{ + /// Return current reference count. + long rc() + { + return rc_; + } + /// Retun the HINSTANCE of the module. + HINSTANCE instance() const + { + return instance_; + } + + /// Set the hinstance of the module. + void instance(HINSTANCE h) + { + instance_ = h; + } + + /// Return the module's critical_section. + /** \code + auto_cs lock( module().cs() ); + \endcode + */ + const critical_section& cs() const + { + return cs_; + } + + //@} + + //! \name Operations + //@{ + + /// Add to the module locks. + void lock() + { + if (InterlockedIncrement(&rc_) == 1 && shutdown_event_ != 0) + { + auto_cs lock(cs_); + if ( shutdown_event_->is_set()) + shutdown_event_->reset(); + } + } + + /// Decrement the module lock. + void unlock() + { + if(InterlockedDecrement(&rc_)==0) + { + activity_ = true; + if (shutdown_event_ != 0) + { + auto_cs lock(cs_); + shutdown_event_->set(); + } + } + } + + /// Shutdown the server. + void shutdown() + { + for (std::vector::iterator it = objects_to_dispose_.begin(); it != objects_to_dispose_.end(); ++it) + { + (*it)->cmd(); + delete *it; + } + objects_to_dispose_.clear(); + } + + /// Set an event for shutdown. + void set_shutdown_event(event& shutdown_event) + { + shutdown_event_ = &shutdown_event; + } + + /// Remove the event for on shutdown. + void clear_shutdown_event() + { + shutdown_event_ = 0; + } + + /// Returns if there has been activity on the module since last reset. + bool has_activity() const + { + return rc_ != 0 || activity_; + } + + /// Reset the activity marker. + void reset_activity_flag() + { + activity_ = false; + } + + /// Add an objet to be disposed on shutdown. + void add_object_to_dispose(impl::cmd_t* p) + { + auto_cs lock(cs_); + objects_to_dispose_.push_back(p); + } + //@} + + private: + long rc_; + bool activity_; + event* shutdown_event_; + HINSTANCE instance_; + critical_section cs_; + + module_t() : rc_(0), activity_(false), + shutdown_event_(0), instance_(0) + {} + + std::vector objects_to_dispose_; + + friend module_t& module(); + + // declare non-copyable + module_t(const module_t&); + module_t& operator=(const module_t&); + }; + + //! global module object + inline module_t& module() + { + static module_t m; + return m; + } + //@} +} + +#endif diff --git a/EyeTab_SP2/comet/oleidl_comtypes.h b/EyeTab_SP2/comet/oleidl_comtypes.h new file mode 100644 index 0000000..79eec24 --- /dev/null +++ b/EyeTab_SP2/comet/oleidl_comtypes.h @@ -0,0 +1,72 @@ +/** \file + * comtype<> definitions for interfaces in the COM header file OLEIDL.H. + * \author Gabriel Barta + */ +/* + * Copyright © 2002 Gabriel Barta + * + * This material is provided "as is", with absolutely no warranty + * expressed or implied. Any use is at your own risk. Permission to + * use or copy this software for any purpose is hereby granted without + * fee, provided the above notices are retained on all copies. + * Permission to modify the code and to distribute modified code is + * granted, provided the above notices are retained, and a notice that + * the code was modified is included with the above copyright notice. + * + * This header is part of Comet version 2. + * https://github.com/alamaison/comet + */ + +#ifndef COMET_OLEIDL_COMTYPES_H +#define COMET_OLEIDL_COMTYPES_H + +#include + +namespace comet { + template<> struct comtype< ::IOleAdviseHolder> + : public uuid_comtype< ::IOleAdviseHolder,&IID_IOleAdviseHolder, ::IUnknown> {} ; + template<> struct comtype< ::IOleCache> + : public uuid_comtype< ::IOleCache,&IID_IOleCache, ::IUnknown> {} ; + template<> struct comtype< ::IOleCache2> + : public uuid_comtype< ::IOleCache2,&IID_IOleCache2, ::IOleCache> {} ; + template<> struct comtype< ::IOleCacheControl> + : public uuid_comtype< ::IOleCacheControl,&IID_IOleCacheControl, ::IUnknown> {} ; + template<> struct comtype< ::IParseDisplayName> + : public uuid_comtype< ::IParseDisplayName,&IID_IParseDisplayName, ::IUnknown> {} ; + template<> struct comtype< ::IOleContainer> + : public uuid_comtype< ::IOleContainer,&IID_IOleContainer, ::IParseDisplayName> {} ; + template<> struct comtype< ::IOleClientSite> + : public uuid_comtype< ::IOleClientSite,&IID_IOleClientSite, ::IUnknown> {} ; + template<> struct comtype< ::IOleObject> + : public uuid_comtype< ::IOleObject,&IID_IOleObject, ::IUnknown> {} ; + template<> struct comtype< ::IOleWindow> + : public uuid_comtype< ::IOleWindow,&IID_IOleWindow, ::IUnknown> {} ; + template<> struct comtype< ::IOleLink> + : public uuid_comtype< ::IOleLink,&IID_IOleLink, ::IUnknown> {} ; + template<> struct comtype< ::IOleItemContainer> + : public uuid_comtype< ::IOleItemContainer,&IID_IOleItemContainer, ::IOleContainer> {} ; + template<> struct comtype< ::IOleInPlaceUIWindow> + : public uuid_comtype< ::IOleInPlaceUIWindow,&IID_IOleInPlaceUIWindow, ::IOleWindow> {} ; + template<> struct comtype< ::IOleInPlaceActiveObject> + : public uuid_comtype< ::IOleInPlaceActiveObject,&IID_IOleInPlaceActiveObject, ::IOleWindow> {} ; + template<> struct comtype< ::IOleInPlaceFrame> + : public uuid_comtype< ::IOleInPlaceFrame,&IID_IOleInPlaceFrame, ::IOleInPlaceUIWindow> {} ; + template<> struct comtype< ::IOleInPlaceObject> + : public uuid_comtype< ::IOleInPlaceObject,&IID_IOleInPlaceObject, ::IOleWindow> {} ; + template<> struct comtype< ::IOleInPlaceSite> + : public uuid_comtype< ::IOleInPlaceSite,&IID_IOleInPlaceSite, ::IOleWindow> {} ; + template<> struct comtype< ::IContinue> + : public uuid_comtype< ::IContinue,&IID_IContinue, ::IUnknown> {} ; + template<> struct comtype< ::IViewObject> + : public uuid_comtype< ::IViewObject,&IID_IViewObject, ::IUnknown> {} ; + template<> struct comtype< ::IViewObject2> + : public uuid_comtype< ::IViewObject2,&IID_IViewObject2, ::IViewObject> {} ; + template<> struct comtype< ::IDropSource> + : public uuid_comtype< ::IDropSource,&IID_IDropSource, ::IUnknown> {} ; + template<> struct comtype< ::IDropTarget> + : public uuid_comtype< ::IDropTarget,&IID_IDropTarget, ::IUnknown> {} ; + template<> struct comtype< ::IEnumOLEVERB> + : public uuid_comtype< ::IEnumOLEVERB,&IID_IEnumOLEVERB, ::IUnknown> {} ; +}; + +#endif //COMET_OLEIDL_COMTYPES_H diff --git a/EyeTab_SP2/comet/ptr.h b/EyeTab_SP2/comet/ptr.h new file mode 100644 index 0000000..3e101a6 --- /dev/null +++ b/EyeTab_SP2/comet/ptr.h @@ -0,0 +1,1261 @@ +/** \file + * Provides the com_ptr type. + */ +/* + * Copyright © 2000-2002 Sofus Mortensen, Michael Geddes + * + * This material is provided "as is", with absolutely no warranty + * expressed or implied. Any use is at your own risk. Permission to + * use or copy this software for any purpose is hereby granted without + * fee, provided the above notices are retained on all copies. + * Permission to modify the code and to distribute modified code is + * granted, provided the above notices are retained, and a notice that + * the code was modified is included with the above copyright notice. + * + * This header is part of Comet version 2. + * https://github.com/alamaison/comet + */ +/*! \addtogroup COMType + */ +//@{ + +/** \page cometcomptr Comet com_ptr + * \section cometcomptroverview Overview + * The \link comet::com_ptr com_ptr \endlink type is essentially a reference + * counting wrapper for objects that support AddRef / Release in a way that + * is STL container compatible. + * + * It also provides a mechanism for doing casting (QueryInterface) assignments + * as well as for doing assignment-compatible assignments and for providing + * smart wrappers for the interfaces. + * + * \section cometcomptrwrapping What Can Be Wrapped? + * + * The com_ptr has been designed to allow most classes to be wrapped, specifically + * it allows for wrapping ::IUnknown based interfaces, and also coclass implementations. + * + * It should be noted that some coclasses can have two implementations of + * ::IUnknown (aggregateable coclasses being a prime example). These classes + * support \link comet::implement_qi::get_unknown get_unknown() \endlink which allows + * the com_ptr to get a the unknown responsible for the lifetime management of + * the object. + * + * \section cometcomptrassign Assigning Pointers + * + * There are three ways of assigning and constructing com_ptr objects, depending on your + * objective; direct assignment and the two cast operators com_cast and try_cast. + * + * \subsection cometcomptrassigndirect Direct Assignment + + * The first way is trivial, but quite important and is the simple + * assignment of one com_ptr to another. This is done in such a way as to make + * it possible to assign assignment compatible interfaces (eg an ::IUnknown pointer can be + * assigned from an ::IDispatch pointer). A compile-time error will occur if + * the pointers are not compatible. + * + * Unfortunately there are certain circumstances that MSVC6 compiler does not + * provide a complete enough template instantiation backtrace in order to be + * able to directly work out an offending assignment. Our appologies, but a + * decent compiler would be more accomodating! + * + * \subsection cometcomptrassignquery Casting Assignment + * + * To cause a COM cast or ::QueryInterface to happen, you need to use the + * wrapper functions com_cast and try_cast. The cause a QueryInterface on + * both assignment and construction, allowing you the choice between having + * an exception thrown on failure (try_cast) or to silently fail leaving the + * object NULL (com_cast). + * + * \code + + com_ptr viewobj = com_cast( obj ); // <-- non-throwing query-interface + if (viewobj.is_null()) + { + com_ptr viewobj2 = try_cast( obj ); // <-- throwing query-interface + viewobj = viewobj2; // <-- Assignment between assignment compatible types. + } + * \endcode + + * This shows the three different ways of assigning. The first uses com_cast + * that causes the assignment to do a QueryInterface, but does not throw an + * error. The second uses try_cast that again causes the assignment to + * do a QueryInterface, but causes errors to be thrown. The third assignment is + * for assignment compatible objects only, and will cause a compiler-error + * unless (in this case) IViewObject2 inherits off IViewObject (which it does).

+ * + * \subsection cometcomptrassignvariant Assignment From a variant_t + * + * Assignment to a com_ptr from a variant_t must be done by either com_cast or + * try_cast, as any assignment from a variant is effectively a cast. + * + * \section cometcomptrsmartwrapper Smart Wrappers + * + * The com_ptr \link comet::com_ptr::operator-> operator-> \endlink provides wrapped + * access to the methods on the interface. For interfaces that have been + * generated by tlb2h, the interface returned is a wrapper that allows access + * only to the wrapped methods, otherwise, access to the raw interface is + * default. + * + * The design of the wrappers allows for system interfaces to be wrapped as + * well. There is an \link comet::com_ptr< ::IDispatch> IDispatch wrapper \endlink + * defined in comet/dispatch.h that provides methods to call functions and + * property accessors by name or by dispatch id. + * + * There is also a wrapper for the API TypeLibrary information interfaces + * defined in comet/tlbinfo.h. In addition to providing some simple wrappers + * to hide the raw COM types, it also provides accessor wrappers to the structs + * that are allocated/deallocated by the interfaces. + * + * \subsection cometcomptrsmartwrapperdetail Implementation + * It is not necessary to know how the wrappers are implemented in order + * to use them, however the technique is quite interesting. + * + * They key to the wrappers is template specialisation. The operator-> + * returns the 'this' pointer with a reinterpret_cast to a wrap_t + * struct instantiated to the interface contained by the com_ptr. The default + * wrap_t template definition is to inherit from the interface, thus giving + * direct access to methods. + * + * The tlb2h generated headers (as well as comet/tlbinfo.h and + * a0omet/dispatch.h) provide alternate specialisations for wrap_t that wrap the + * arguments and call the real methods (which would be Invoke if it is an dispinterface) + * by using reinterpret_cast to cast back to the original interface. + * + * \section cometcomptraccess Raw COM Access + * Whether calling raw COM interfaces, or trying to understand how the wrappers + * work, you will come across the \ref cometrawcomaccess methods. These are standard + * across the types (see \ref cometrawcomaccess), however com_ptr classes also + * have a raw() method that is equivalent to get() and proivdes access to the + * raw COM methods. + */ + //@} + +#ifndef COMET_PTR_H +#define COMET_PTR_H + +#include + +#include + +#include +#include +#include +#include +#include + +// Primary namespace for comet +namespace comet { + class uuid_t; + + template struct wrap_t : public Itf {}; + + template<> struct wrap_t< ::IUnknown> {}; + + template Itf* raw( wrap_t* p ) { return reinterpret_cast(p); } + +// template struct prop_wrapper : public Itf {}; + + // Forward declaration + class variant_t; + template class com_ptr; + class identity_ptr; + namespace thread_model{ + enum thread_model_t; + } + template struct coclass; + template struct aggregate_inner_unknown ; + + // comet implementation details + namespace impl { + + template class com_cast_t { + public: + explicit com_cast_t(Itf* p) : ptr_(p) {}; + Itf* get() const { return ptr_; } + private: + Itf* ptr_; + com_cast_t& operator=(const com_cast_t&); + }; + + template<> class com_cast_t { + public: + explicit com_cast_t(const variant_t& v) : val_(v) {}; + const variant_t& get() const { return val_; } + private: + const variant_t& val_; + com_cast_t& operator=(const com_cast_t&); + }; + + /** Allow calling specific, known ambiguous IUnknown implementations. + * \param B \b true Call via get_unknown. \b false Call directly + */ + template + struct IUnknown_caller + { + template< typename T > static inline long AddRef( T *y) + { return y->AddRef(); } + template static inline long Release( T *y) + { return y->Release(); } + template static inline HRESULT QueryInterface( T *y, REFIID iid, void **NewIface) + { return y->QueryInterface(iid, (void **)NewIface); } + }; + + template <> + struct IUnknown_caller + { + template static inline long AddRef( T *y) + { return y->get_unknown()->AddRef(); } + template< typename T> static inline long Release( T *y) + { return y->get_unknown()->Release(); } + template static inline HRESULT QueryInterface( T *y, REFIID iid, void **NewIface) + { return y->get_unknown()->QueryInterface(iid, NewIface); } + }; +// template struct implement_internal_qi; + + /** Namespace for dummy functions for allowing IUnknown choice to be + * deferred to the get_unknown() function. + */ + namespace unknown_choice + { +// template long dummy_( coclass *); +// template long dummy_(implement_internal_qi *); + template long dummy_(aggregate_inner_unknown *); + char dummy_( ... ); + } + + /** \internal + */ + template + struct iunknown_chooser + { + + enum { matches = (sizeof( unknown_choice::dummy_( static_cast< C *>(0) ))==sizeof(long)) }; + }; + + } + /*! \addtogroup COMType + */ + //@{ + + //! Cast com_ptr. + /*! Allows QueryInterface when casting to different com_ptr type. + \code + com_ptr foo; + com_ptr bar; + bar = com_cast(foo); + if (!bar.is_null()) { + // Cast is ok. + bar->DoTheThing(); + } + \endcode + * \param t com_ptr to cast + * \relates com_ptr + */ + template inline impl::com_cast_t com_cast(const com_ptr& t) { return impl::com_cast_t(t.get()); } + template inline impl::com_cast_t com_cast(Itf* t) { return impl::com_cast_t(t); } + inline impl::com_cast_t com_cast(const variant_t& v) { return impl::com_cast_t(v); } + + namespace impl { + template class try_cast_t { + public: + explicit try_cast_t(Itf* p) : ptr_(p) {}; + Itf* get() const { return ptr_; } + private: + Itf* ptr_; + try_cast_t& operator=(const try_cast_t&); + }; + + template<> class try_cast_t { + public: + explicit try_cast_t(const variant_t& v) : val_(v) {}; + const variant_t& get() const { return val_; } + private: + const variant_t& val_; + try_cast_t& operator=(const try_cast_t&); + }; + } + + + namespace impl { + + //! IUnknown wrapper. + /** Hides the members of IUnknown. + * \relates com_ptr + */ + template class safe_interface : public Itf { + private: + HRESULT __stdcall QueryInterface(REFIID, void**); + ULONG __stdcall AddRef(); + ULONG __stdcall Release(); + }; + + } + + //! Represents the identity Unknown of an object. + /** Is the only really efficient and safe way of representing an object for + * comparisons. + */ + class identity_ptr + { + public: + //! Default constructor. + /** Initialises the pointer to Null. + */ + identity_ptr() throw() : ptr_(NULL){} + //! Destructor. + /** Releases the pointer. + */ + ~identity_ptr() throw() { release();} + + //! Copy constructor. + /*! Simple pointer copy. They are both already identity unknowns. + */ + identity_ptr( const identity_ptr &rhs) : ptr_(rhs.ptr_) {addref();} + + //! Constructor from Try Cast. + /*! Used for construction from any Interface pointer. Always QIs to + * guarantee this is the identity. + */ + template + explicit identity_ptr( const impl::try_cast_t &x ) throw(com_error) + : ptr_(NULL) + { + IUnknown *p=static_cast(x.get()); + if (p != NULL) + p->QueryInterface(uuidof< ::IUnknown >(), reinterpret_cast(&ptr_)) | raise_exception; + } + + //! Constructor from variant_t Try Cast. + /*! Used for construction from a variant. Always QIs to + * guarantee this is the identity. + */ + inline explicit identity_ptr(const impl::try_cast_t& v) throw(com_error); + + //! Constructor from Com Cast. + /*! Used for construction from any Interface pointer. Always QIs to + * guarantee this is the identity. + */ + template + explicit identity_ptr( const impl::com_cast_t &x ) throw(com_error) + : ptr_(NULL) + { + IUnknown *p=static_cast(x.get()); + if (p != NULL) + p->QueryInterface(uuidof< ::IUnknown >(), reinterpret_cast(&ptr_)); + } + //! Constructor from variant_t com_cast. + /*! Used for construction from a variant. Always QIs to + * guarantee this is the identity. + */ + inline explicit identity_ptr(const impl::com_cast_t& v) throw(com_error); + + //! Constructions of null pointer + /*! + \param null + Only 0 is valid. Any other value will cause E_POINTER to be thrown. + + \exception com_error + Throws E_POINTER if a non-zero value is specified. + */ + explicit identity_ptr(int null) throw(com_error) + : ptr_(NULL) + { if(null != 0) raise_exception(E_POINTER); } + + //! Copy assignment. + /*! Don't QI as this is definitely identity already. + */ + identity_ptr &operator =( const identity_ptr &rhs) throw() + { + identity_ptr tmp(rhs); + swap(tmp); + return *this; + } + + //! Other assignment. + /*! Always QIs. Handles other assignments that have + * available constructors. + */ + template + identity_ptr &operator =(const T &rhs) throw(com_error) + { + identity_ptr tmp(rhs); + swap(tmp); + return *this; + } + //! Null assignment + /*! + Only null is allowed as argument. Attempting to assign a non-zero value will result in E_POINTER (wrapped in com_error) being thrown. + + \exception com_error + Throw E_POINTER if a non-zero value is specified. + */ + identity_ptr& operator=(int null) throw(com_error) + { if(null != 0) raise_exception(E_POINTER); release(); return *this; } + + /// Get at the raw pointer. + IUnknown *get() const throw() { return ptr_; } + /// Pass to an [in] parameter. + IUnknown *in() const throw() { return ptr_; } + /// Get at raw interface. + IUnknown *raw() const throw() { return ptr_; } + + //! Returns true if the wrapped pointer is null. + bool is_null() const throw() + { return (ptr_ ==NULL); } + + //! Null comparison + /*! + Only comparison with a value of zero is allowed. Non-zero values will result + in E_POINTER (wrapped in com_error) being thrown. + + \exception com_error + */ + bool operator==(int null) const + { if (null != 0) raise_exception(E_POINTER); return is_null(); } + //! Null comparison + /*! + Only comparison with a value of zero is allowed. Non-zero values will result + in E_POINTER (wrapped in com_error) being thrown. + + \exception com_error + */ + bool operator!=(int null) const + { if (null != 0) raise_exception(E_POINTER); return !is_null(); } + + /**! \name Pointer Comparison + */ + //@{ + bool operator<(const identity_ptr& x) const throw() + { return ptr_ < x.ptr_; } + + bool operator>(const identity_ptr& x) const throw() + { return ptr_ > x.ptr_; } + + + bool operator<=(const identity_ptr& x) const throw() + { return ptr_ <= x.ptr_; } + + bool operator>=(const identity_ptr& x) const throw() + { return ptr_ >= x.ptr_; } + + bool operator==(const identity_ptr& x) const throw() + { return (ptr_ == x.ptr_); } + + bool operator!=(const identity_ptr& x) const throw() + { return ptr_ != x.ptr_; } + //@} + + protected: + IUnknown *ptr_; + + void swap(identity_ptr& x) throw() + { std::swap(ptr_, x.ptr_); } + + void addref() const throw() + { if (ptr_ != NULL) ptr_->AddRef(); } + + void release() throw() + { if (ptr_ != NULL) { ptr_->Release(); ptr_ = NULL; } } + + private: + // Can't use an identity_ptr for out, inout, use com_ptr + IUnknown **inout(); + IUnknown *out(); + + }; + + //! Interface smart pointer + /*! \note All members are exception safe. + * \sa cometcomptr + */ + template class com_ptr + { + public: + const uuid_t& iid() const throw() + { return uuidof(); } + + private: + enum{ chooser_matches_= impl::iunknown_chooser::matches }; + typedef typename impl::IUnknown_caller< chooser_matches_ > Unknown_caller_; + + void addref() const throw() + { if (ptr_) Unknown_caller_::AddRef(ptr_); } + + void release() throw() + { if (ptr_) { Unknown_caller_::Release(ptr_); ptr_ = 0; } } + + public: + //! Type of pointer to wrapped interface + typedef Itf* interface_pointer; + + //! Safe interface pointer. + /*! + Interface pointer where the methods from IUnknown have been hidden. + */ +#ifndef COMET_USE_RAW_WRAPPERS + typedef wrap_t* safe_interface_pointer; +#else + typedef impl::safe_interface< Itf >* safe_interface_pointer; +#endif + + private: + interface_pointer ptr_; + + public: + //! Default constructor + /*! + Initialises the wrapped pointer to null. + */ + com_ptr() throw() : ptr_(NULL) {} + + //! Destructor + /*! + Calls Release() on pointer if necessary. + */ + ~com_ptr() throw() + { release(); } + + //! Upcasting constructor + /*! + Used for upcasting interface pointer without invocation of QueryInterface. + + This contructor only allows com_ptr upcasts. + + \param x + com_ptr to cast. + */ + + // If you are getting: + // error C2440: '=' : cannot convert from 'struct ... + // + // Use either try_cast or com_cast to cast from one interface to another + // example: + // + // com_ptr p = try_cast( q ); + // + // or + // + // com_ptr p = com_cast( q ); + template com_ptr(const com_ptr& x) throw() + { ptr_ = (Itf2*)x.get(); addref(); } + + //! QueryInterface construction + /*! + Uses QueryInterface to query for interface of type Itf. If the pointer is incompatible, the pointer will be initialised to null. + + \code + com_ptr foo; + com_ptr bar( com_cast(foo) ); + \endcode + + \param x + com_ptr to cast + */ + template com_ptr(const impl::com_cast_t& x) throw() + { ptr_ = NULL; Itf2* p = x.get(); if (p != NULL) Unknown_caller_::QueryInterface(p, iid(), reinterpret_cast(&ptr_)); } + // ^ Note: no error checking!!! + + //! QueryInterface construction + /*! + Uses QueryInterface to query for interface of type Itf. Should the pointer be incompatible, com_error will be thrown. + + \code + com_ptr foo = Foo::create(); + com_ptr bar( try_cast(foo) ); + \endcode + + \param x + com_ptr to cast + + \exception com_error + Throws E_NOINTERFACE if cast fails. + Throws E_POINTER if pointer is zero. + */ + template com_ptr(const impl::try_cast_t& x) throw(com_error) + : ptr_(NULL) + { + Itf2* p = x.get(); if (p == NULL) return; + Unknown_caller_::QueryInterface(p, iid(), reinterpret_cast(&ptr_)) | raise_exception; + if (ptr_ == NULL) raise_exception(E_NOINTERFACE); + } + + //! Copy constructor + /*! + \param x com_ptr to copy. + */ + com_ptr(const com_ptr& x) throw() + : ptr_(x.ptr_) + { addref(); } + + //! Copy from identity_unknown class. + /** Itf must be IUnknown for this to work. Otherwise use try_cast or + * com_cast. + */ + com_ptr( const identity_ptr &x) throw() + : ptr_(x.ptr_) + { addref(); } + + private: + // If you are getting: + // error C2248: '=' : cannot access private member ... + // + // Use either try_cast or com_cast to convert a variant_t to a com_ptr. + // example: + // + // com_ptr p = try_cast( v ); + // + // or + // + // com_ptr p = com_cast( v ); + com_ptr(const variant_t&); + com_ptr& operator=(const variant_t&); + + public: + + //! Construction from variant_t + /*! + This constructor does not throw. The wrapped pointer is initialised to null if the variant is incompatible. + + \param v + Wrapped com_variant to construct com_ptr from + */ + com_ptr(const impl::com_cast_t& v) throw() + { create_nothrow(v.get()); } + + //! Construction from variant_t + /*! + Throws com_error should the variant be incompatible. + + \param v + Wrapped com_variant to construct com_ptr from + + \exception com_error + Throws E_NOINTERFACE if cast fails. + */ + com_ptr(const impl::try_cast_t& v) throw(com_error) + { create(v.get()); } + + //! Construction from a raw interface pointer + /*! + Calls AddRef, and thus does \em not take ownership of the pointer. + + \param p + Interface pointer to construct com_ptr from. + */ + com_ptr(interface_pointer p) throw() + : ptr_(p) + { addref(); } + + //! Attach construction of raw interface pointer + /*! + An attachment construction does not AddRef on the interface, and is said + to take ownership of the interface pointer. + + \param p + auto_attach wrapped pointer to construct com_ptr from. + */ + com_ptr(const impl::auto_attach_t& p) throw() + : ptr_( p.get() ) + {} + + //! Construction from CLSID + /*! + \param clsid + Class ID of coclass. + \param dwClsContext + Class context to create object in. + + \exception com_error + */ + explicit com_ptr(const uuid_t& clsid, DWORD dwClsContext = CLSCTX_ALL) throw(com_error) + { create(clsid, NULL, dwClsContext); } + + //! Construction of aggregated object from CLSID + /*! + \param clsid + Class ID of coclass. + \param outer + Pointer to outer object. + \param dwClsContext + Class context to create object in. + + \exception com_error + */ + /*template*/ com_ptr(const uuid_t& clsid, const com_ptr< ::IUnknown>& outer, DWORD dwClsContext = CLSCTX_ALL) throw(com_error) + { create(clsid, outer, dwClsContext); } + + //! Constructions of null pointer + /*! + \param null + Only 0 is valid. Any other value will cause E_POINTER to be thrown. + + \exception com_error + Throws E_POINTER if a non-zero value is specified. + */ + explicit com_ptr(int null) throw(com_error) + : ptr_(NULL) + { if(null != 0) raise_exception(E_POINTER); } + + //! Construction from ProgID + /*! + \param progid + ProgID of class. + \param dwClsContext + Class context to create object in. + + \exception com_error + */ + explicit com_ptr(const wchar_t* progid, DWORD dwClsContext = CLSCTX_ALL) throw(com_error) + { create(progid, 0, dwClsContext); } + + //! Construction from ProgID + /*! + \param progid + ProgID of class. + \param outer + Pointer to outer object. + \param dwClsContext + Class context to create object in. + + \exception com_error + */ + /*template */com_ptr(const wchar_t* progid, const com_ptr< ::IUnknown>& outer, DWORD dwClsContext = CLSCTX_ALL) throw(com_error) + { create(progid, outer, dwClsContext); } + + //! Construction using CoGetObject + explicit com_ptr(const wchar_t* name, BIND_OPTS& bind_opts) + { create(name, bind_opts); } + + //! Arrow operator + /*! + Used to access methods and properties of the wrapped interface. + + \note The methods of IUnknown are deliberately hidden. + */ + safe_interface_pointer operator->() const throw(com_error) + { if( ptr_ == NULL) raise_exception(E_POINTER); return get_safe_ptr(); } + + //! Assignment of raw interface pointer + com_ptr& operator=(interface_pointer x) throw() + { com_ptr t(x); swap(t); return *this; } + + //! QueryInterface assignment + /*! + In order to cast unrelated interfaces you must use either com_cast or try_cast. + + A com_cast that fails results in a null pointer assignment. + + \code + com_ptr foo; + com_ptr bar; + bar = com_cast(foo); + if (!bar.is_null()) { + // Cast is ok. + bar->DoTheThing(); + } + \endcode + */ + template com_ptr& operator=(const impl::com_cast_t& x) throw() + { com_ptr t(x); swap(t); return *this; } + + //! QueryInterface assignment + /*! + In order to cast unrelated interfaces you must use either com_cast or try_cast. + + A try_cast that fails will throw E_NOINTERFACE wrapped in com_error. + + \code + com_ptr foo; + com_ptr bar; + try { + bar = try_cast(foo); + bar->DoTheThing(); + } catch (com_error&) { + // Cast didn't work. + } + \endcode + + \exception com_error + Throws E_NOINTERFACE if cast fails. + */ + template com_ptr& operator=(const impl::try_cast_t& x) throw(com_error) + { com_ptr t(x); swap(t); return *this; } + + template + com_ptr& operator=(const com_ptr& x) throw() + { com_ptr t(x); swap(t); return *this; } + + //! Default assigment operator. + com_ptr& operator=(const com_ptr& x) throw() + { com_ptr t(x); swap(t); return *this; } + + //! Null assignment + /*! + Only null is allowed as argument. Attempting to assign a non-zero value will result in E_POINTER (wrapped in com_error) being thrown. + + \exception com_error + Throw E_POINTER if a non-zero value is specified. + */ + com_ptr& operator=(int null) throw(com_error) + { if(null != 0) raise_exception(E_POINTER); release(); return *this; } + + //! Attaching assignment + /*! + Attaches a raw interface pointer to the com_ptr. + + \code + com_ptr foo; + foo = auto_attach( raw_foo_pointer ); + \endcode + */ + com_ptr& operator=(const impl::auto_attach_t& p) throw() + { release(); ptr_ = p.get(); return *this; } + + private: + template + int compare_unknown(const com_ptr& x) const throw(com_error) + { + if ( (void *)ptr_ == (void *)x.get()) return 0; + ::IUnknown* p1 = 0; + ::IUnknown* p2 = 0; + + if (ptr_ != NULL) { + Unknown_caller_::QueryInterface(ptr_,uuidof< ::IUnknown >(), reinterpret_cast(&p1)) | raise_exception; + p1->Release(); + } + + if (x.get()) { + Unknown_caller_::QueryInterface(x.get(), uuidof< ::IUnknown >(), reinterpret_cast(&p2)) | raise_exception; + p2->Release(); + } + + return p1 - p2; + } + int compare_unknown(const identity_ptr& x) const throw(com_error) + { + if (ptr_ == x.get()) return 0; + ::IUnknown* p1 = 0; + ::IUnknown* p2 = 0; + + if (ptr_ != NULL) { + Unknown_caller_::QueryInterface(x.get(), uuidof< ::IUnknown >(), reinterpret_cast(&p2)) | raise_exception; + p2->Release(); + } + + return p1 - p2; + } + public: + /**! \name Pointer Comparison + */ + //@{ + template bool operator<(const T& x) const throw(com_error) + { return compare_unknown(x) < 0; } + + template bool operator>(const T& x) const throw(com_error) + { return compare_unknown(x) > 0; } + + template bool operator<=(const T& x) const throw(com_error) + { return compare_unknown(x) <= 0; } + + template bool operator>=(const T& x) const throw(com_error) + { return compare_unknown(x) >= 0; } + + /** Object equality. + */ + template bool operator==(const com_ptr& x) const throw(com_error) + { return compare_unknown(x) == 0; } + + template bool operator!=(const com_ptr& x) const throw(com_error) + { return compare_unknown(x) != 0; } + + //@} + + //! Returns true if the wrapped pointer is null. + bool is_null() const throw() + { return (ptr_ ==NULL); } + + //! Returns true if the wrapped pointer is null. + bool operator!() const throw() + { return is_null(); } + + //! Null comparison + /*! + Only comparison with a value of zero is allowed. Non-zero values will result + in E_POINTER (wrapped in com_error) being thrown. + + \exception com_error + */ + bool operator==(int null) const + { if (null != 0) raise_exception(E_POINTER); return is_null(); } + + //! Null comparison + /*! + Only comparison with a value of zero is allowed. Non-zero values will result + in E_POINTER (wrapped in com_error) being thrown. + + \exception com_error + */ + bool operator!=(int null) const + { if (null != 0) raise_exception(E_POINTER); return !is_null(); } + + //! Pointer comparison + /*! + Returns true if the two pointers are the same. + */ + template inline bool same_pointer( const com_ptr &x) const throw(com_error) + { return (IUnknown *) ptr_ == (IUnknown *)x.ptr_; } + + //! Swap operation + /*! + This method is very fast, since it does not call AddRef or Release. + */ + void swap(com_ptr& x) throw() + { std::swap(ptr_, x.ptr_); } + + //! Detaches ownership. + /*! + Detaches the pointer from the wrapper and returns it as raw pointer. + + This method is primarily for use by the interface wrapper code. You should very seldomly find use for it. + */ + interface_pointer detach() throw() + { interface_pointer t = ptr_; ptr_ = 0; return t; } + + //! Detaches ownership + /*! + */ + static interface_pointer detach(com_ptr& x) throw() + { return x.detach(); } + + /**! Create a const reference to a pointer without invoking reference-counting. + * Since neither constructor or destructor get called. + */ + static const com_ptr& create_const_reference(const interface_pointer& x) + { return *reinterpret_cast(&x); } + + /**! Create a reference to a pointer without invoking reference-counting. + * Since neither constructor or destructor get called. + */ + static com_ptr& create_reference(interface_pointer& x) + { return *reinterpret_cast(&x); } + + //! \name Adapter methods. + //@{ + + //! [in] adapter + /*! + Used when calling raw interfaces that require an [in] IXXX * argument. + + \code + com_ptr foo; + HRESULT hr = pRawInterface->raw_Method(foo.in()); + \endcode + + Only use this wrapper when forced to deal with raw interface. + */ + interface_pointer in() const throw() + { return ptr_; } + + interface_pointer raw() const throw() + { return ptr_; } + + interface_pointer get() const throw() + { return ptr_; } + + //! [out] adapter. + /*! + Used when calling raw interfaces that require an [out] IXXX ** argument. + + \code + com_ptr foo; + HRESULT hr = pRawInterface->raw_MethodThatReturnsPtr(foo.out()); + \endcode + + Only use this wrapper when forced to deal with raw interface. + */ + interface_pointer* out() throw() + { release(); return &ptr_; } + + //! [in, out] adapter. + /*! + Used when calling raw interfaces that require an [in, out] IXXX ** argument. + + \code + com_ptr foo; + HRESULT hr = pRawInterface->raw_MethodThatChangesPtr(foo.inout()); + \endcode + + Only use this wrapper when forced to deal with raw interface. + */ + interface_pointer* inout() throw() + { return &ptr_; } + + //@} + + private: + class bool_tester + { void operator delete(void*); }; + + public: + operator bool_tester*() const throw() + { if (is_null()) return 0; static bool_tester test; return &test; } + + private: + safe_interface_pointer get_safe_ptr() const throw() + { return reinterpret_cast(ptr_); } + + inline void create_nothrow(const variant_t& v) throw(); + + inline void create(const variant_t& v) throw(com_error); + + void create(const uuid_t& clsid, const com_ptr< ::IUnknown>& outer, DWORD dwClsContext = CLSCTX_ALL) throw(com_error) + { CoCreateInstance(clsid, outer.in(), dwClsContext, iid(), reinterpret_cast(&ptr_)) | raise_exception; } + + void create(const wchar_t* clsidString, const com_ptr< ::IUnknown>& outer, DWORD dwClsContext = CLSCTX_ALL) throw(com_error) + { + if (clsidString == NULL) raise_exception(E_INVALIDARG); + + CLSID clsid; + + if (clsidString[0] == '{') + CLSIDFromString(const_cast(clsidString), &clsid) | raise_exception; + else + CLSIDFromProgID(clsidString, &clsid) | raise_exception; + + create(clsid, outer, dwClsContext);; + } + + void create(const wchar_t* name, BIND_OPTS& bind_opts) throw(com_error) + { CoGetObject(name, &bind_opts, iid(), reinterpret_cast(&ptr_)) | raise_exception; } + }; // class + + //! Comparison with null + /*! + Only comparison with a value of zero is allowed. Non-zero values will result in E_POINTER (wrapped in com_error) being thrown. + + \relates com_ptr + \exception com_error + Throws E_POINTER if a non-zero value is specified. + */ + template inline bool operator==(int null, const com_ptr& x) throw(com_error) + { if(null != 0) raise_exception(E_POINTER); return x.is_null(); } + + //! Comparison with null + /*! + Only comparison with a value of zero is allowed. Non-zero values will result in E_POINTER (wrapped in com_error) being thrown. + + \relates identity_ptr + \exception com_error + Throws E_POINTER if a non-zero value is specified. + */ + static inline bool operator==(int null, const identity_ptr& x) throw(com_error) + { if(null != 0) raise_exception(E_POINTER); return x.is_null(); } + + //! Comparison with null + /*! + Only comparison with a value of zero is allowed. Non-zero values will result in E_POINTER (wrapped in com_error) being thrown. + + \relates com_ptr + \exception com_error + Throws E_POINTER if a non-zero value is specified. + */ + template inline bool operator!=(int null, const com_ptr& x) throw(com_error) + { return x != null; } + + //! Comparison with null + /*! + Only comparison with a value of zero is allowed. Non-zero values will result in E_POINTER (wrapped in com_error) being thrown. + + \relates com_ptr + \exception com_error + Throws E_POINTER if a non-zero value is specified. + */ + inline static bool operator!=(int null, const identity_ptr& x) throw(com_error) + { if(null != 0) raise_exception(E_POINTER); return !x.is_null(); } + + namespace impl { + template + class try_caster_t + { + com_ptr ptr_; + public: + template + try_caster_t( const com_ptr &ptr2) + : ptr_(try_cast(ptr2)) + {} + + const com_ptr &get() const { return ptr_; } + + }; + } + /*! Version of try_cast more to the style of \b dynamic_cast. + This is aimed at being used for casts that get used once in an environment with many interfaces. + \code + com_ptr session; + com_ptr = try_cast( try_cast_ptr(session)->User() ); + \endcode + The impl::try_caster_t is implementation only - let the compiler do the + cast from com_ptr to impl::try_caster_t. Note that try_cast would still + be the preferred method for most casts. + \sa try_cast + \relates com_ptr + */ + template inline com_ptr try_cast_ptr( const impl::try_caster_t &caster) + { return (com_ptr)caster.get(); } + + //! Cast com_ptr. + /*! + Allows QueryInterface when casting to different com_ptr type. + + \code + com_ptr foo; + com_ptr bar; + try { + bar = try_cast(foo); + bar->DoTheThing(); + } catch (com_error&) { + // Cast didn't work. + } + \endcode + + */ + template inline impl::try_cast_t try_cast(const com_ptr& t) { return impl::try_cast_t(t.get()); } + static inline impl::try_cast_t< ::IUnknown> try_cast(const identity_ptr& t) { return impl::try_cast_t< ::IUnknown>(t.get()); } + template inline impl::try_cast_t try_cast(Itf* t) { return impl::try_cast_t(t); } + inline impl::try_cast_t try_cast(const variant_t& v) { return impl::try_cast_t(v); } + //@} + +} // namespace + +#include +#include + +namespace comet { + template + inline void com_ptr::create_nothrow(const variant_t& v) throw() + { + ptr_ = 0; + ::IUnknown *pUnk; + switch (v.get_vt()) { + case VT_DISPATCH: + pUnk = V_DISPATCH(&v.get()); + break; + case VT_UNKNOWN: + pUnk = V_UNKNOWN(&v.get()); + break; + case VT_DISPATCH|VT_BYREF: + pUnk = *V_DISPATCHREF(&v.get()); + break; + case VT_UNKNOWN|VT_BYREF: + pUnk = *V_UNKNOWNREF(&v.get()); + break; + default: + // don't try anything fancy. + return; + } + if( pUnk ==NULL) return; + Unknown_caller_::QueryInterface(pUnk,iid(), reinterpret_cast(&ptr_)); + } + template + inline void com_ptr::create(const variant_t& v) throw(com_error) + { + ptr_ = 0; + ::IUnknown *pUnk; + switch (v.get_vt()) { + case VT_DISPATCH: + pUnk = V_DISPATCH(&v.get()); + break; + case VT_UNKNOWN: + pUnk = V_UNKNOWN(&v.get()); + break; + case VT_DISPATCH|VT_BYREF: + pUnk = *V_DISPATCHREF(&v.get()); + break; + case VT_UNKNOWN|VT_BYREF: + pUnk = *V_UNKNOWNREF(&v.get()); + break; + case VT_EMPTY: + case VT_NULL: + pUnk = NULL; + break; + default: + // don't try anything fancy. + raise_exception( E_INVALIDARG ); + } + if( pUnk ==NULL) return; + Unknown_caller_::QueryInterface(pUnk,iid(), reinterpret_cast(&ptr_)) | raise_exception; + } + + inline identity_ptr::identity_ptr(const impl::try_cast_t& v) throw(com_error) + : ptr_(NULL) + { + VARIANT vv = v.get().get(); + ::IUnknown *pUnk; + switch (V_VT(&vv)) { + case VT_DISPATCH: + pUnk = V_DISPATCH(&vv); + break; + case VT_UNKNOWN: + pUnk = V_UNKNOWN(&vv); + break; + case VT_DISPATCH|VT_BYREF: + pUnk = *V_DISPATCHREF(&vv); + break; + case VT_UNKNOWN|VT_BYREF: + pUnk = *V_UNKNOWNREF(&vv); + break; + case VT_EMPTY: + case VT_NULL: + pUnk = NULL; + break; + default: + // don't try anything fancy. + raise_exception( E_INVALIDARG ); + } + if( pUnk ==NULL) return; + pUnk->QueryInterface( IID_IUnknown, reinterpret_cast(&ptr_)) | raise_exception; + } + + inline identity_ptr::identity_ptr(const impl::com_cast_t& v) throw(com_error) + : ptr_(NULL) + { + VARIANT vv = v.get().get(); + ::IUnknown *pUnk; + switch (V_VT(&vv)) { + case VT_DISPATCH: + pUnk = V_DISPATCH(&vv); + break; + case VT_UNKNOWN: + pUnk = V_UNKNOWN(&vv); + break; + case VT_DISPATCH|VT_BYREF: + pUnk = *V_DISPATCHREF(&vv); + break; + case VT_UNKNOWN|VT_BYREF: + pUnk = *V_UNKNOWNREF(&vv); + break; + default: + // don't try anything fancy. + return; + } + if( pUnk ==NULL) return; + pUnk->QueryInterface( IID_IUnknown, reinterpret_cast(&ptr_)); + } +} + +namespace boost { + template inline Itf* get_pointer(const comet::com_ptr& sp) + { + return sp.raw(); + } + static inline IUnknown* get_pointer(const comet::identity_ptr &sp) + { + return sp.raw(); + } +} + +//! Macro that specialises std::swap for com_ptr. +#define COMET_SPECIALISE_STD_SWAP_ITF(Itf) namespace std { inline void swap(comet::com_ptr& x, comet::com_ptr& y) {x.swap(y); } } + +#endif + diff --git a/EyeTab_SP2/comet/reference_count.h b/EyeTab_SP2/comet/reference_count.h new file mode 100644 index 0000000..020ad36 --- /dev/null +++ b/EyeTab_SP2/comet/reference_count.h @@ -0,0 +1,100 @@ +/** \file + * Implements a class that maintains a reference count. + */ +/* + * Copyright © 2000, 2001 Sofus Mortensen, Paul Hollingsworth + * + * This material is provided "as is", with absolutely no warranty + * expressed or implied. Any use is at your own risk. Permission to + * use or copy this software for any purpose is hereby granted without + * fee, provided the above notices are retained on all copies. + * Permission to modify the code and to distribute modified code is + * granted, provided the above notices are retained, and a notice that + * the code was modified is included with the above copyright notice. + * + * This header is part of Comet version 2. + * https://github.com/alamaison/comet + */ + +#ifndef COMET_REFERENCE_COUNT_H +#define COMET_REFERENCE_COUNT_H + +#include +#include + +namespace comet { + /*! \addtogroup Misc + */ + //@{ + /// Simple reference counter. + class reference_count + { + public: + reference_count() : rc_(0) {}; + explicit reference_count(size_t x) : rc_(reinterpret_cast(x)) {}; + + reference_count(const reference_count& x) : rc_(x.rc_) {}; + + enum { FLAGVALUE = 1 }; + bool is_flag() const { + return reinterpret_cast(rc_) == 1; + } + + // is_null + /** Implies that the there are currently no outstanding references + * to this object. + */ + bool is_null() const { + return rc_ == 0; + } + + /// Increment count. + size_t operator++() { + if (!rc_) { + rc_ = new size_t(1); + } + return ++*rc_; + } + + /// Decrement count. + size_t operator--() { + if (rc_) { + if (--*rc_ == 0) { + delete rc_; + rc_ = 0; + return 0; + } + return *rc_; + } + return 0; + } + + void clear() { + rc_ = 0; + } + + void swap(reference_count &rhs) throw() { + std::swap(rc_, rhs.rc_); + } + + reference_count& operator=(reference_count& x) + { + rc_ = x.rc_; + return *this; + } + + private: + size_t* rc_; + }; // class reference_count + //@} +} // namespace comet + +namespace std { + //! Specialisation of std::swap for reference_count. + template<> inline void swap(comet::reference_count &lhs, comet::reference_count &rhs) COMET_STD_SWAP_NOTHROW + { + lhs.swap(rhs); + } +} + +#endif diff --git a/EyeTab_SP2/comet/registry.h b/EyeTab_SP2/comet/registry.h new file mode 100644 index 0000000..3c2d787 --- /dev/null +++ b/EyeTab_SP2/comet/registry.h @@ -0,0 +1,1302 @@ +/** \file + * Windows Registry iteration and manipulation functions. + */ +/* + * Copyright © 2000, 2001 Paul Hollingsworth + * + * This material is provided "as is", with absolutely no warranty + * expressed or implied. Any use is at your own risk. Permission to + * use or copy this software for any purpose is hereby granted without + * fee, provided the above notices are retained on all copies. + * Permission to modify the code and to distribute modified code is + * granted, provided the above notices are retained, and a notice that + * the code was modified is included with the above copyright notice. + * + * This header is part of Comet version 2. + * https://github.com/alamaison/comet + */ + +#ifndef COMET_REGISTRY_H +#define COMET_REGISTRY_H + +#include + +#include +#include +#include + +#ifdef __BORLANDC__ + #define COMET_ITERATOR_VOID(tag) std::iterator +#else + #ifndef __SGI_STL + #ifdef __MINGW32__ + #define COMET_ITERATOR_VOID(tag) std::forward_iterator + #else + #ifdef _CPPLIB_VER + #define COMET_ITERATOR_VOID(tag) std::iterator + #else + #define COMET_ITERATOR_VOID(tag) std::iterator + #endif + #endif + #else + #define COMET_ITERATOR_VOID(tag) std::iterator + #endif +#endif + +namespace comet { + /** Contains implementation of registry classes. + */ + namespace registry { + /// Unicode compatible string class used in registry operations. +// typedef std::basic_string tstring; + + namespace impl { + // Only when an iterator is dereferenced + // do we want to go about reading the value + // from the registry. This requires us to create + // a temporary object. But in order to overload + // operator->, our temporary object must overload + // operator-> - and often it doesn't. + // Proxy is here to effectively overload operator-> for the temporary + // object. + template + class proxy + { + T t_; + public: + proxy(const T &t) : t_(t) {} + T *operator->() + { + return &t_; + } + + const T *operator->() const + { + return &t_; + } + }; + + class key_base + { + HKEY key_; + mutable reference_count rc_; + + static bool valid_key_(HKEY key) { + return key != 0; + } + + void close_() { + if(valid_key_(key_) && (--rc_ == 0)) { + LONG errcode = ::RegCloseKey(key_); + COMET_ASSERT(ERROR_SUCCESS == errcode); + /* C4189 */ errcode; + } + key_ = 0; // invalidate key handle + } + public: + key_base(const key_base &rhs) + : key_(rhs.key_) { + if(valid_key_(key_)) + ++rhs.rc_; + rc_ = rhs.rc_; + } + + key_base(HKEY key = 0) : key_(key) { + } + + ~key_base() throw() { + close_(); + } + + key_base &operator=(const key_base &rhs) + { + key_base tmp(rhs); + swap(tmp); + return *this; + } + + void swap(key_base &rhs) throw() { + std::swap(key_, rhs.key_); + std::swap(rc_, rhs.rc_); + } + + LONG open(const tstring &subkey, + REGSAM sam_desired, + HKEY *childkey) const { + *childkey = 0; + return ::RegOpenKeyEx(key_, + subkey.c_str(), + 0, + sam_desired, + childkey); + } + + HKEY open_nothrow(const tstring &subkey, + REGSAM sam_desired, + LONG *errcode) const { + HKEY childkey_ = 0; + LONG errcode_ = open(subkey, + sam_desired, + &childkey_); + if(errcode) *errcode = errcode_; + return childkey_; + } + + LONG create(const tstring &subkey, + DWORD options, + REGSAM sam_desired, + LPSECURITY_ATTRIBUTES security_attributes, + LPDWORD disposition, + HKEY *childkey) const { + return ::RegCreateKeyEx(key_, + subkey.c_str(), + 0, + REG_NONE, + options, + sam_desired, + security_attributes, + childkey, + disposition); + } + + HKEY create_nothrow(const tstring &subkey, + DWORD options, + REGSAM sam_desired, + LPSECURITY_ATTRIBUTES security_attributes, + LPDWORD disposition, + LONG *errcode) const { + HKEY childkey = 0; + LONG errcode_ = create(subkey, + options, + sam_desired, + security_attributes, + disposition, + &childkey); + if(errcode) *errcode = errcode_; + return childkey; + } + + LONG flush_nothrow() const { + return ::RegFlushKey(key_); + } + + LONG delete_subkey_nothrow(const tstring &subkey) const { + return ::RegDeleteKey(key_, subkey.c_str()); + } + + LONG delete_value_nothrow(const tstring &value_name) const { + return ::RegDeleteValue(key_, value_name.c_str()); + } + + void close() { + close_(); + } + + HKEY get() const { + return key_; + } + + bool is_valid() const throw() + { + return key_ ? true : false; + } + + operator const void *() const throw() + { + return is_valid() ? this : 0; + } + }; // class key_base + + // Enumerating through keys or values is + // very similar. These two class encapsulate + // all that is different between the two algorithms. + struct next_value + { + static LONG perform(HKEY key, + DWORD dwIndex, + LPTSTR lpName, + LPDWORD lpcName) + { + return ::RegEnumValue(key, dwIndex, lpName, lpcName, 0, 0, 0, 0); + } + }; + + struct next_key + { + static LONG perform(HKEY key, + DWORD dwIndex, + LPTSTR lpName, + LPDWORD lpcName) + { + return ::RegEnumKeyEx(key, dwIndex, lpName, lpcName, 0, 0, 0, 0); + } + }; + } // namespace impl + + + /** \struct name_iterator registry.h comet/registry.h + * Iterates through a list of names. The names might be either key + * names or value names, depending on get_next. + */ + template + struct name_iterator : public COMET_ITERATOR_VOID(std::forward_iterator_tag) + { + // key_ is the only assignment that can fail. So + // we make it the first member, so that + // default assignment is exception safe. + impl::key_base key_; + DWORD index_; + DWORD buf_size_; + DWORD num_values_; + + static void check_exception_(LONG errcode) + { + if(ERROR_SUCCESS != errcode) + error_policy::on_error(errcode); + } + + // Is this iterator an end iterator? + bool is_end() const + { + return key_ ? false : true; + } + + // Make this iterator an end + // iterator + void make_end() + { + key_.close(); + } + + public: + typedef tstring value_type; + name_iterator(const impl::key_base &key, + DWORD num_values, + DWORD buf_size) + : key_(key), + num_values_(num_values), + buf_size_(buf_size), + index_(0) + { + if(0 == num_values) + make_end(); + } + + void swap(name_iterator &rhs) + { + key_.swap(rhs.key_); + std::swap(index_, rhs.index_); + std::swap(buf_size_, rhs.buf_size_); + std::swap(num_values_, rhs.num_values_); + } + + name_iterator &operator=(const name_iterator &rhs) + { + key_ = rhs.key_; + index_ = rhs.index_; + buf_size_ = rhs.buf_size_; + num_values_ = rhs.num_values_; + return *this; + } + + impl::key_base key() const + { + return key_; + } + + name_iterator() + { + make_end(); + } + + value_type operator*() const + { + tstring::value_type *buf = static_cast(_alloca(buf_size_)); + DWORD dummy = buf_size_; + check_exception_(get_next::perform(key_.get(), + index_, + buf, + &dummy)); + return buf; + } + + impl::proxy operator->() const + { + return **this; + } + + name_iterator &operator++() + { + ++index_; + if(index_ == num_values_) + make_end(); + return *this; + } + + name_iterator operator++(int) const + { + name_iterator retval = *this; + ++(*this); + return retval; + } + + bool operator==(const name_iterator &rhs) const + { + if(is_end()) return rhs.is_end(); + if(rhs.is_end()) return is_end(); + return index_ == rhs.index_; + } + + bool operator!=(const name_iterator &rhs) const + { + return !(*this == rhs); + } + }; + + /** \class value registry.h comet/registry.h + * A pseudo-reference to a value in the registry. + * Assign to instances of this object to make changes to the corresponding registry value + * Read from this object to read values from the registry. + */ + template + class value + { + impl::key_base key_; + tstring value_name_; + static void check_exception_(LONG errcode) + { + if(ERROR_SUCCESS != errcode) + error_policy::on_error(errcode); + } + static void type_mismatch() + { + error_policy::on_typemismatch(); + } + + LONG get_value_(DWORD *type, + BYTE *buffer, + DWORD *number_bytes) const + { + return ::RegQueryValueEx(key_.get(), + value_name_.c_str(), + 0, + type, + buffer, + number_bytes); + } + + void get_value(DWORD *type, + BYTE *buffer, + DWORD *number_bytes) const { + check_exception_( + get_value_(type, + buffer, + number_bytes) + ); + } + + LONG set_value_(DWORD type, + const BYTE *data, + DWORD number_bytes) + { + return ::RegSetValueEx(key_.get(), + value_name_.c_str(), + 0, + type, + data, + number_bytes); + } + + void set_value(DWORD type, + const BYTE *data, + DWORD number_bytes) + { + check_exception_( + set_value_(type, + data, + number_bytes)); + } + + tstring name() const + { + return value_name_; + } + public: + + //! This can be used to query if a value exists. + /*! + For example: + \code + string get_thread_model(const regkey &clsid_key) + { + regkey::value_type t = clsid_key.open("InprocServer32", KEY_READ)["ThreadingModel"]; + if(t.exists()) + return t.str(); + else + return "Single"; + } + \endcode + */ + bool exists() const + { + return ERROR_SUCCESS == get_value_(0, 0, 0); + } + + value(const impl::key_base &key, + const tstring &value_name) + : key_(key), + value_name_(value_name) + { + } + + //! Non throwing swap + /*! This is for efficiency only. + operator= is overloaded to have a different + meaning (copying one part of the + registry to another part of the registry). + */ + void swap(value &rhs) + { + key_.swap(rhs.key_); + value_name_.swap(rhs.value_name_); + } + + + //! Get a value of any type. The arguments are passed directly to RegQueryValueEx + /*! + \param type Pointer to the type - can be 0 + \param buffer Pointer to a buffer - can be 0 + \param number_bytes Indicates size of the buffer - can be 0 if buffer is 0 + */ + void get(DWORD *type, + BYTE *buffer, + DWORD *number_bytes) const + { + get_value(type, + buffer, + number_bytes); + } + + //! Get a value - return errcode + /*! + \param type Pointer to the type - can be 0 + \param buffer Pointer to a buffer - can be 0 + \param number_bytes Indicates size of the buffer - can be 0 if buffer is 0 + */ + LONG get_nothrow(DWORD *type, + BYTE *buffer, + DWORD *number_bytes) const + { + return get_value_(type, buffer, number_bytes); + } + + //! Set a value arbitrarily. The arguments are passed directly to RegSetValueEx + /*! + \param type Type to set it to (e.g. REG_SZ) + \param buffer Pointer to a buffer + \param number_bytes Indicates size of the buffer + */ + void set(DWORD type, + const BYTE *buffer, + DWORD number_bytes) + { + set_value(type, + buffer, + number_bytes); + } + + //! Set a value - return errcode + /*! + \param type Type to set it to (e.g. REG_SZ) + \param buffer Pointer to a buffer + \param number_bytes Indicates size of the buffer + */ + LONG set_nothrow(DWORD type, + const BYTE *buffer, + DWORD number_bytes) + { + return set_value_(type, buffer, number_bytes); + } + + //! Interpret value as a string + /*! + \exception com_error If the type is not REG_SZ or REG_EXPAND_SZ (using standard error_policy) + */ + tstring str() const + { + DWORD number_bytes = 0; + DWORD type; + get_value(&type, + 0, + &number_bytes); + if( (REG_SZ != type) && (REG_EXPAND_SZ != type)) + type_mismatch(); + BYTE *buffer = static_cast(_alloca(number_bytes)); + get_value(0, + buffer, + &number_bytes); + return tstring(reinterpret_cast(buffer), + (number_bytes/sizeof(tstring::value_type)) - 1); + } + + tstring str(const tstring& default_val) const + { + DWORD number_bytes = 0; + DWORD type; + if (get_value_(&type, + 0, + &number_bytes) != ERROR_SUCCESS) return default_val; + if( (REG_SZ != type) && (REG_EXPAND_SZ != type)) + type_mismatch(); + BYTE *buffer = static_cast(_alloca(number_bytes)); + get_value(0, + buffer, + &number_bytes); + return tstring(reinterpret_cast(buffer), + (number_bytes/sizeof(tstring::value_type)) - 1); + } + + //! Implicit conversion to string. + operator tstring() const + { + return str(); + } + + //! Implicit conversion to unsigned int + operator DWORD() const + { + return dword(); + } + + //! Interpret value as a DWORD + /*! + \exception com_error If the type is not REG_DWORD or REG_DWORD_LITTLE_ENDIAN (using standard error_policy) + */ + DWORD dword() const + { + DWORD number_bytes = sizeof( DWORD ); + DWORD type; + DWORD retval; + get_value(&type, + reinterpret_cast(&retval), + &number_bytes); + if( (REG_DWORD != type) && (REG_DWORD_LITTLE_ENDIAN != type) ) + type_mismatch(); + return retval; + } + + DWORD dword(DWORD default_val) const + { + DWORD number_bytes = sizeof( DWORD ); + DWORD type; + DWORD retval; + if (get_value_(&type, + reinterpret_cast(&retval), + &number_bytes) != ERROR_SUCCESS) return default_val; + if( (REG_DWORD != type) && (REG_DWORD_LITTLE_ENDIAN != type) ) + type_mismatch(); + return retval; + } + + // These two operators are currently useless + // because VC++ 6.0 appears to have a bug - + // it claims that no conversion to pair + // exists even though it clearly does here. + // However, it's possible these would be + // useful on other compilers (or future compilers). + operator std::pair() const + { + return std::make_pair(name(), str()); + } + + operator std::pair() const + { + return std::make_pair(name(), dword()); + } + + //! Assign a string value and set the type to REG_SZ + value &operator=(const tstring &rhs) + { + set_value(REG_SZ, + reinterpret_cast(rhs.c_str()), + (rhs.length() + 1) * sizeof ( tstring::value_type)); + return *this; + } + + //! Assign a DWORD value and set the type to REG_DWORD + value &operator=(const DWORD &rhs) + { + set_value(REG_DWORD, + reinterpret_cast(&rhs), + sizeof (DWORD) ); + return *this; + } + + //! Assign an integer value - sets type to REG_DWORD + value &operator=(int rhs) + { + return *this = DWORD(rhs); + } + + //! Assign value from another registry value + /*! + Because value objects always refer to a part of the registry, + this effectively copies a registry value + from somewhere else in the registry. + */ + value &operator=(const value &rhs) + { + DWORD type; + DWORD size; + rhs.get_value(&type, + 0, + &size); + BYTE *buffer = static_cast(_alloca(size)); + rhs.get_value_(0, + buffer, + &size); + set_value(type, + buffer, + size); + return *this; + } + }; // class value + + /** \class const_value_iterator registry.h comet/registry.h + * Forward const iterator over registry values. + */ + template + class const_value_iterator : public COMET_ITERATOR_VOID(std::forward_iterator_tag) + { + typedef const value second_type; + typedef std::pair value_type_; + + value_type_ get_value() const + { + tstring name = *index_; + return std::make_pair(name, second_type(index_.key(), name) ); + } + protected: + name_iterator index_; + public: + typedef value_type_ value_type; + + const_value_iterator(const impl::key_base &key, + DWORD num_values, + DWORD buf_size) + : index_(key, num_values, buf_size) + { + } + + const_value_iterator() {} + + void swap(const_value_iterator &rhs) + { + index_.swap(rhs.index_); + } + + value_type operator*() const + { + return get_value(); + } + + const_value_iterator &operator++() + { + ++index_; + return *this; + } + + const_value_iterator operator++(int) + { + const_value_iterator retval(*this); + ++(*this); + return retval; + } + + impl::proxy operator->() + { + return **this; + } + + bool operator==(const const_value_iterator &rhs) const + { + return index_ == rhs.index_; + } + + bool operator!=(const const_value_iterator &rhs) const + { + return index_ != rhs.index_; + } + }; + + /** \class value_iterator registry.h comet/registry.h + * Forward iterator over registry values. + */ + template + class value_iterator : public const_value_iterator + { + typedef value second_type; + typedef std::pair value_type_; + typedef const_value_iterator base; + value_type_ get_value() const + { + tstring name = *this->index_; + return std::make_pair(name, second_type(this->index_.key(), name) ); + } + + public: + typedef value_type_ value_type; + value_iterator(const impl::key_base &key, + DWORD num_values, + DWORD buf_size) + : base(key, num_values, buf_size) {} + + value_iterator() {} + + value_type operator*() const + { + return get_value(); + } + + value_iterator &operator++() + { + base::operator++(); + return *this; + } + + value_iterator operator++(int) + { + value_iterator retval(*this); + ++(*this); + return retval; + } + + impl::proxy operator->() + { + return get_value(); + } + + bool operator==(const value_iterator &rhs) const + { + return this->index_ == rhs.index_; + } + + bool operator!=(const value_iterator &rhs) const + { + return this->index_ != rhs.index_; + } + }; + + /** \struct collection registry.h comet/registry.h + * STL style container class for various types of registry based + * aggregations. + */ + template + struct collection + { + impl::key_base key_; + DWORD num_values_; + DWORD buf_size_; + + public: + collection(const impl::key_base &key, + DWORD num_values, + DWORD buf_size) + : key_(key), + num_values_(num_values), + buf_size_(buf_size) + { + } + + typedef iterator_ iterator; + typedef const_iterator_ const_iterator; + typedef typename iterator_::value_type value_type; + typedef size_t size_type; + + //! Number of elements in the collection + size_type size() const { return num_values_; } + + //! Exception safe swap + void swap(collection &rhs) + { + key_.swap(rhs.key_); + std::swap(num_values_, rhs.num_values_); + std::swap(buf_size_, rhs.buf_size_); + } + + //! Get the first iterator + iterator begin() + { + return iterator(key_, num_values_, buf_size_); + } + + //! Signature iterator marking the end of the sequence + iterator end() + { + return iterator(); + } + + const_iterator begin() const + { + return const_iterator(key_, num_values_, buf_size_); + } + + const_iterator end() const + { + return const_iterator(); + } + }; + + /** \class info registry.h comet/registry.h + * Structure returned by regkey.enumerate() + */ + template + class info + { + // Make key_ the first member - this + // ensures exception safe assignment. + impl::key_base key_; + + // Number of values + DWORD num_values_; + + // Maximum length of a value name + DWORD value_name_tchars_; + + // Number of sub keys + DWORD num_subkeys_; + + // Maximum length of a sub key name + DWORD subkey_name_tchars_; + + static void check_exception_(LONG errcode) + { + if(ERROR_SUCCESS != errcode) + error_policy::on_error(errcode); + } + + static DWORD bytes(DWORD tchars) + { + return (tchars + 1) * sizeof( tstring::value_type); + } + public: + info(const impl::key_base &key) + : key_(key) + { + check_exception_(::RegQueryInfoKey(key_.get(), + 0, // lpClass - reserved + 0, // lpcClass - reserved + 0, // lpReserved + &num_subkeys_, + &subkey_name_tchars_, + 0, // lpcMaxClassLen - I think this is also reserved + &num_values_, + &value_name_tchars_, + 0, // lpcMaxValueLen - not necessary for us + 0, // lpcbSecurityDescriptor + 0)); // lpftLastWriteTime + } + + //! Exception safe swap + void swap(info &rhs) + { + key_.swap(rhs.key_); + std::swap(num_subkeys_, rhs.num_subkeys_); + std::swap(subkey_name_tchars_, rhs.subkey_name_tchars_); + std::swap(value_name_tchars_, rhs.value_name_tchars_); + std::swap(num_values_, rhs.num_values_); + } + + //! Type returned by values() + typedef collection, const_value_iterator > values_type; + + //! Type returned by value_names() + typedef collection > value_names_type; + + //! Type returned by subkeys() + typedef collection > subkeys_type; + + //! Number of values under this key (excluding the default value) + size_t num_values() const + { + return num_values_; + } + + //! Number of subkeys under this key + size_t num_subkeys() const + { + return num_subkeys_; + } + + //! Length of the longest value_name under this key (in TCHARs) + size_t max_value_name() const + { + return value_name_tchars_; + } + + //! Length of the longest subkey name under this key (in TCHARs) + size_t max_subkey_name() const + { + return subkey_name_tchars_; + } + + //! Return the collection of values + /*! + The value_type of the collection is std::pair, regkey::mapped_type> + regkey::mapped_type has implicit conversions to unsigned int and std::basic_string however. + Example - copy all value-name/value pairs into a map + \code + typedef std::basic_string tstring; + regkey::info_type info(regkey(HKEY_LOCAL_MACHINE).enumerate()); + map values_map; + copy(info.values().begin(), info.values().end(), inserter(values_map, values_map.end())); + \endcode + Example - copy all value-name/value pairs into a string map - exception will + be thrown if a non string value is encountered. + \code + typedef std::basic_string tstring; + regkey::info_type info(regkey(HKEY_LOCAL_MACHINE).enumerate()); + map values_map; + copy(info.values().begin(), info.values().end(), inserter(values_map, values_map.end())); + \endcode + Example - copy all value-name/value pairs into a string/int map - exception will + be thrown if a non string value is encountered. + \code + typedef std::basic_string tstring; + regkey::info_type info(regkey(HKEY_LOCAL_MACHINE).enumerate()); + map values_map; + copy(info.values().begin(), info.values().end(), inserter(values_map, values_map.end())); + \endcode + */ + values_type values() const + { + return values_type(key_, num_values_, bytes(value_name_tchars_)); + } + + //! Returns the collection of value names + /*! The value_type of the collection is std::basic_string. + Example - copy all value names of HKEY_LOCAL_MACHINE into a list + \code + regkey::info_type info(regkey(HKEY_LOCAL_MACHINE).enumerate()); + vector value_names; + copy(info.value_names().begin(), info.value_names().end(), back_inserter(value_names)); + \endcode + */ + value_names_type value_names() const + { + return value_names_type(key_, num_values_, bytes(value_name_tchars_)); + } + + //! Returns the collection of subkey names + /*! The value_type of the collection is std::basic_string. + Example - copy all subkeys of HKEY_LOCAL_MACHINE into a list + \code + regkey::info_type info(regkey(HKEY_LOCAL_MACHINE).enumerate()); + vector subkey_names; + copy(info.subkeys().begin(), info.subkeys().end(), back_inserter(subkey_names)); + \endcode + */ + subkeys_type subkeys() const + { + return subkeys_type(key_, num_subkeys_, bytes(subkey_name_tchars_)); + } + }; + +#ifdef __BORLANDC__ + using impl::key_base; +#endif + + /** \class key registry.h comet/registry.h + * Registry key wrapper. + Because an HKEY cannot be duplicated in a platform independent way, + reference counting is used to enable copying of key objects. + + Methods with the _nothrow suffix do not throw exceptions other than + std::bad_alloc. + + Key instances can be used as output iterators for std::pair + assignments. The second argument of each pair must be assignable to + an instance of regkey::mapped_type. Currently, this means that the + second member of each pair must be convertable to either an int, + unsigned int, or std::basic_string. + Example: + \code + regkey the_key = regkey(HKEY_LOCAL_MACHINE).open("Software\\Comet"); + map names; + names["one"] = "one"; + names["two"] = "two"; + copy(names.begin(), names.end(), the_key); + map values; + values["three"] = 3; + values["four"] = 4; + copy(values.begin(), values.end(), the_key); + \endcode + */ + template + class key : private impl::key_base { + private: + static void check_exception_(LONG errcode) + { + if(ERROR_SUCCESS != errcode) + error_policy::on_error(errcode); + } + public: + key(HKEY key_handle = 0) : key_base(key_handle) {} + + //! Copy a key. + /*! In reality this + only increments a reference count. + We have to use reference counting + because ::DuplicateHandle does not + work for registry keys on windows 95/98. + */ + + key(const key &rhs) + : key_base(rhs) { + } + //! Copy a key. + /*! This is useful for attaching to keys from a name iterator. + */ + key( const impl::key_base &rhs) + : key_base(rhs) { + } + + void swap(key &rhs) + { + key_base::swap(rhs); + } + + //! Operator overload to allow you to put key instances in a conditional. + /*! This operator allows you to write code like this: + \code + if(subkey = key(HKEY_LOCAL_MACHINE).open_nothrow(_T("Software"))) + { + ... + }; + \endcode + const void * is used instead of the more obvious "bool" to disable + implicit conversions to int and the like. + Example: + \code + int success = key(HKEY_LOCAL_MACHINE).open_nothrow(_T("Software")); // Won't compile fortunately!! + \endcode + */ + operator const void *() const throw() + { + return is_valid() ? this : 0; + } + + + //! Open a subkey + key open(const tstring &subkey, + REGSAM sam_desired = KEY_ALL_ACCESS) const { + HKEY childkey_ = 0; + check_exception_( + key_base::open(subkey, + sam_desired, + &childkey_) + ); + return childkey_; + } + + //! Open a subkey, no exceptions + key open_nothrow(const tstring &subkey, + REGSAM sam_desired = KEY_ALL_ACCESS, + LONG *errcode = 0) const { + return key_base::open_nothrow(subkey, + sam_desired, errcode); + } + + //! Create a subkey + key create(const tstring &subkey, + DWORD options = REG_OPTION_NON_VOLATILE, + REGSAM sam_desired = KEY_ALL_ACCESS, + LPSECURITY_ATTRIBUTES security_attributes = 0, + LPDWORD disposition = 0) const { + HKEY childkey_ = 0; + check_exception_( + key_base::create(subkey, + options, + sam_desired, + security_attributes, + disposition, + &childkey_) + ); + return childkey_; + } + + //! Create a subkey - no exceptions + key create_nothrow(const tstring &subkey, + DWORD options = REG_OPTION_NON_VOLATILE, + REGSAM sam_desired = KEY_ALL_ACCESS, + LPSECURITY_ATTRIBUTES security_attributes = 0, + LPDWORD disposition = 0, + LONG *errcode = 0) const { + return key_base::create_nothrow(subkey, + options, + sam_desired, + security_attributes, + disposition, + errcode); + } + + //! Call RegFlushKey with the contained key + void flush() const { + check_exception_( + flush_nothrow() + ); + } + + //! Call RegFlushKey with the contained key - no exceptions + LONG flush_nothrow() const { + return key_base::flush_nothrow(); + } + + //! Delete the subkey + /*! Warning - the behaviour is different + between WinNT and Win95/98 if + sub keys are present. + See documentation for ::RegDeleteKey for + more information. + */ + void delete_subkey(const tstring &subkey) const { + check_exception_( + delete_subkey_nothrow(subkey.c_str()) + ); + } + + //! Delete the subkey + /*! Warning - the behaviour is different + between WinNT and Win95/98 if + sub keys are present. + See documentation for ::RegDeleteKey for + more information. + */ + LONG delete_subkey_nothrow(const tstring &subkey) const { + return key_base::delete_subkey_nothrow(subkey); + } + + //! delete a value + void delete_value(const tstring &value_name) const { + check_exception_( + delete_value_nothrow(value_name) + ); + } + + //! delete a value - no exceptions + LONG delete_value_nothrow(const tstring &value_name) const { + return key_base::delete_value_nothrow(value_name); + } + + //! Release reference to the key. + /*! Note that this will only call ::RegCloseKey + if this was the last reference to the outstanding key. + This method is implicitly called by the destructor. + */ + void close() { + key_base::close(); + } + + //! Get access to the raw key without releasing ownership + HKEY get() const { + return key_base::get(); + } + + typedef value mapped_type; + + // All of these methods are const because I figured + // it was more useful. It allows you to create + // temporary regkey objects for the purposes of + // updating. + + //! Get a reference to a value in the registry. + /*! The returned value can be used on both sides of an assignment. Example: + \code + key.get_value("Name") = "Paul"; + string name = key.get_value("Name"); + cout << key.get_value("Name").str() << endl; + \endcode + */ + mapped_type get_value(const tstring &value_name = _T("")) const + { + return mapped_type(*this, value_name); + } + + //! Subscript operator overload - syntactic sugar for get_value(). + /*! Example: + \code + key["Name"] = "Paul"; + string name = key["Name"]; + cout << key["Name"].str() << endl; + \endcode + */ + mapped_type operator[](const tstring &value_name) const + { + return get_value(value_name); + } + + //! Type returned by enumerate() + typedef info info_type; + //! Type returned by enumerate().subkeys() + typedef typename info_type::subkeys_type subkeys_type; + //! Type returned by enumerate().values() + typedef typename info_type::values_type values_type; + //! Type returned by enumerate().value_names() + typedef typename info_type::value_names_type value_names_type; + + //! Enumerate the subkeys, values or value_names, or obtain other information about the key. See also info. + /*! + The enumerate() method effectively calls RegQueryInfoKey, so you should + minimize the number of calls to enumerate() if efficiency is + a concern. e.g. + The following + \code + regkey::info_type info = key.enumerate(); + copy(info.values().begin(), info.values().end(), inserter(value_map, value_map.end())); + \endcode + is more efficient than + \code + copy(key.enumerate().values().begin(), key.enumerate().values().end(), inserter(value_map, value_map.end())); + \endcode + The second version will end up calling RegQueryInfoKey twice. + */ + info_type enumerate() const + { + return info_type(*this); + } + + //! Part of making key into an output iterator + key &operator*() + { + return *this; + } + + //! Assignment. This is designed to work with 'std::pair's - the value type of map classes + template + key &operator=(const T &val) + { + get_value(val.first) = val.second; + return *this; + } + + //! Exception safe assignment operator. + //! Can still throw std::bad_alloc due + //! to reference counting. + //template<> + key &operator=(const key &rhs) + { + key_base::operator=(rhs); + return *this; + } + + //! Noop increment + key &operator++() { return *this; } + //! Noop decrement + key &operator++(int) { return *this; } + }; // class key + } // namespace registry +} // namespace comet + +#endif // COMET_REGISTRY_H diff --git a/EyeTab_SP2/comet/regkey.h b/EyeTab_SP2/comet/regkey.h new file mode 100644 index 0000000..882dcd2 --- /dev/null +++ b/EyeTab_SP2/comet/regkey.h @@ -0,0 +1,65 @@ +/** \file + * Base regkey type and error-policy definition. + */ +/* + * Copyright © 2000, 2001 Paul Hollingsworth + * + * This material is provided "as is", with absolutely no warranty + * expressed or implied. Any use is at your own risk. Permission to + * use or copy this software for any purpose is hereby granted without + * fee, provided the above notices are retained on all copies. + * Permission to modify the code and to distribute modified code is + * granted, provided the above notices are retained, and a notice that + * the code was modified is included with the above copyright notice. + * + * This header is part of Comet version 2. + * https://github.com/alamaison/comet + */ + +#ifndef COMET_REGKEY_H +#define COMET_REGKEY_H + +#include + +#include +#include + +namespace comet +{ + /** \struct reg_error regkey.h comet/regkey.h + * Standard error policy, mainly for use by registry functions. + */ + struct reg_error + { + static void on_error(LONG errcode) + { + throw com_error(HRESULT_FROM_WIN32(errcode)); + } + + static void on_typemismatch() + { + throw com_error(HRESULT_FROM_WIN32(ERROR_INVALID_DATATYPE)); + } + }; + + /** Standard type for use when dealing with registry keys. + */ + typedef registry::key regkey; + +} + +namespace std { + + COMET_DECLARE_SWAP(comet::regkey) + COMET_DECLARE_SWAP(comet::regkey::info_type) + COMET_DECLARE_SWAP(comet::regkey::mapped_type) + COMET_DECLARE_SWAP(comet::regkey::values_type) + COMET_DECLARE_SWAP(comet::regkey::subkeys_type) + COMET_DECLARE_SWAP(comet::regkey::value_names_type) + COMET_DECLARE_SWAP(comet::regkey::values_type::iterator) + COMET_DECLARE_SWAP(comet::regkey::values_type::const_iterator) + COMET_DECLARE_SWAP(comet::regkey::subkeys_type::iterator) + COMET_DECLARE_SWAP(comet::regkey::value_names_type::iterator) +} + +#endif diff --git a/EyeTab_SP2/comet/safearray.h b/EyeTab_SP2/comet/safearray.h new file mode 100644 index 0000000..6851e9b --- /dev/null +++ b/EyeTab_SP2/comet/safearray.h @@ -0,0 +1,1498 @@ +/** \file + * SafeArray wrapper implementation. + */ +/* + * Copyright © 2000, 2001, 2002 Sofus Mortensen, Michael Geddes + * Copyright © 2012 Alexander Lamaison + * + * This material is provided "as is", with absolutely no warranty + * expressed or implied. Any use is at your own risk. Permission to + * use or copy this software for any purpose is hereby granted without + * fee, provided the above notices are retained on all copies. + * Permission to modify the code and to distribute modified code is + * granted, provided the above notices are retained, and a notice that + * the code was modified is included with the above copyright notice. + * + * This header is part of Comet version 2. + * https://github.com/alamaison/comet + */ + +#ifndef COMET_SAFEARRAY_H +#define COMET_SAFEARRAY_H + +#include +#include +#include +#include +#include +//#include +#include +#include +#include + +#include +#include +#include + +#ifndef NDEBUG +#define COMET_ITERATOR_DEBUG +#endif + +namespace comet { + + + namespace impl { + + template + struct access_operator + { + // Has operator -> + template + struct base + { + T *operator->() + { + return &(static_cast(this)->operator*()); + } + }; + }; + // Doesn't have operator-> + template<> + struct access_operator + { + template + struct base + { + }; + }; + + template struct sa_traits; //Moved to common.h + + template class sa_iterator; + + template struct const_traits { + typedef T value_type; + typedef typename sa_traits::const_reference reference; + typedef const T* pointer; + }; + + template struct nonconst_traits { + typedef T value_type; + typedef typename sa_traits::reference reference; + typedef T* pointer; + }; + + + template<> struct sa_traits : public basic_sa_traits {}; + template<> struct sa_traits : public basic_sa_traits {}; + + template<> struct sa_traits : public basic_sa_traits {}; + template<> struct sa_traits : public basic_sa_traits {}; + + template<> struct sa_traits : public basic_sa_traits {}; + template<> struct sa_traits : public basic_sa_traits {}; + template<> struct sa_traits : public basic_sa_traits {}; + + template<> struct sa_traits : public basic_sa_traits {}; + template<> struct sa_traits : public basic_sa_traits {}; + + template<> struct sa_traits + { + typedef VARIANT raw; + + enum { vt = VT_VARIANT }; + enum { check_type = impl::stct_features_ok }; + enum { extras_type = stet_null }; + + typedef variant_t value_type; + typedef variant_t& reference; + typedef const variant_t& const_reference; + + static reference create_reference(raw& x) { return *reinterpret_cast(&x); } + static const_reference create_const_reference(raw& x) { return *reinterpret_cast(&x); } + + typedef sa_iterator > iterator; + typedef sa_iterator > const_iterator; + + static bool are_features_ok(unsigned short f) { return (f & FADF_VARIANT) != 0; } + static com_ptr get_record_info() { return 0; } + }; + + template<> struct sa_traits + { + enum { vt = VT_BSTR }; + enum { check_type = impl::stct_vt_ok }; + enum { extras_type = stet_null }; + + typedef BSTR raw; + typedef bstr_t value_type; + typedef bstr_t& reference; + typedef const bstr_t& const_reference; + + static reference create_reference(raw& x) { return *reinterpret_cast(&x); } + static const_reference create_const_reference(raw& x) { return *reinterpret_cast(&x); } + + typedef sa_iterator > iterator; + typedef sa_iterator > const_iterator; + + static bool are_features_ok(unsigned short f) { return (f & FADF_BSTR) != 0; } + static com_ptr get_record_info() { return 0; } + }; + + template<> struct sa_traits + { + enum { vt = VT_CY }; + enum { check_type = impl::stct_vt_ok }; + enum { extras_type = impl::stet_null }; + + typedef CY raw; + typedef currency_t value_type; + typedef currency_t& reference; + typedef const currency_t& const_reference; + + static reference create_reference(raw& x) { return *reinterpret_cast(&x); } + static const_reference create_const_reference(raw& x) { return *reinterpret_cast(&x); } + + typedef sa_iterator > iterator; + typedef sa_iterator > const_iterator; + + static bool are_features_ok(unsigned short) { return true; } + static com_ptr get_record_info() { return 0; } + }; + + template<> struct sa_traits + { + enum { vt = VT_DATE }; + enum { check_type = impl::stct_vt_ok }; + enum { extras_type = impl::stet_null }; + + typedef DATE raw; + typedef datetime_t value_type; + typedef datetime_t& reference; + typedef const datetime_t& const_reference; + + static reference create_reference(raw& x) { return *reinterpret_cast(&x); } + static const_reference create_const_reference(raw& x) { return *reinterpret_cast(&x); } + + typedef sa_iterator > iterator; + typedef sa_iterator > const_iterator; + + static bool are_features_ok(unsigned short) { return true; } + static com_ptr get_record_info() { return 0; } + }; + + template<> struct sa_traits + { + enum { vt = VT_BOOL }; + enum { check_type = impl::stct_vt_ok }; + enum { extras_type = impl::stet_null }; + + typedef VARIANT_BOOL raw; + typedef variant_bool_t value_type; + typedef variant_bool_t& reference; + typedef const variant_bool_t& const_reference; + + static reference create_reference(raw& x) { return *reinterpret_cast(&x); } + static const_reference create_const_reference(raw& x) { return *reinterpret_cast(&x); } + + typedef sa_iterator > iterator; + typedef sa_iterator > const_iterator; + + static bool are_features_ok(unsigned short) { return true; } + static com_ptr get_record_info() { return 0; } + }; + + template<> struct sa_traits: sa_traits + { + }; + + template<> struct sa_traits< com_ptr< ::IUnknown> > + { + enum { vt = VT_UNKNOWN }; + enum { check_type = impl::stct_vt_ok }; + enum { extras_type = impl::stet_iid }; + + typedef IUnknown* raw; + typedef com_ptr< ::IUnknown> value_type; + typedef com_ptr< ::IUnknown>& reference; + typedef const com_ptr< ::IUnknown>& const_reference; + + static reference create_reference(raw& x) { return *reinterpret_cast*>(&x); } + static const_reference create_const_reference(raw& x) { return *reinterpret_cast*>(&x); } + + typedef sa_iterator, nonconst_traits > > iterator; + typedef sa_iterator, const_traits > > const_iterator; + + static bool are_features_ok(unsigned short f) { return (f & (FADF_UNKNOWN|FADF_DISPATCH)) != 0; } + static com_ptr get_record_info() { return 0; } + static const uuid_t& iid() { return uuid_t::create_const_reference(IID_IUnknown); } + }; + + template<> struct sa_traits< com_ptr< ::IDispatch> > + { + enum { vt = VT_DISPATCH }; + enum { check_type = impl::stct_vt_ok }; + enum { extras_type = impl::stet_iid }; + + typedef IDispatch* raw; + typedef com_ptr< ::IDispatch> value_type; + typedef com_ptr< ::IDispatch>& reference; + typedef const com_ptr< ::IDispatch>& const_reference; + + static reference create_reference(raw& x) { return *reinterpret_cast*>(&x); } + static const_reference create_const_reference(raw& x) { return *reinterpret_cast*>(&x); } + + typedef sa_iterator, nonconst_traits > > iterator; + typedef sa_iterator, const_traits > > const_iterator; + + static bool are_features_ok(unsigned short f) { return (f & FADF_DISPATCH) != 0; } + static com_ptr get_record_info() { return 0; } + + static const uuid_t& iid() { return uuid_t::create_const_reference(IID_IDispatch); } + }; + +#ifdef COMET_ITERATOR_DEBUG +#define COMET_SAIT_THIS ,this +#define COMET_SAIT_ITER(CONT_, IT_, TRAITS_) impl::sa_debug_iterator + + template + struct sa_debug_traits + { + typedef TRAITS traits; + typedef typename TRAITS::value_type value_type; + typedef typename TRAITS::raw raw; + typedef typename TRAITS::reference reference; + typedef typename TRAITS::iterator nonconst_iterator; + typedef typename TRAITS::iterator iterator; + typedef typename TRAITS::const_iterator const_iterator; + }; + template + struct sa_const_debug_traits + { + typedef TRAITS traits; + typedef typename TRAITS::value_type value_type; + typedef typename TRAITS::raw raw; + typedef typename TRAITS::const_reference reference; + typedef typename TRAITS::iterator nonconst_iterator; + typedef typename TRAITS::const_iterator iterator; + typedef typename TRAITS::const_iterator const_iterator; + }; + + template< typename CONT, typename TRAITS> + class sa_debug_iterator : public std::iterator, + public access_operator::result>::template base > + { + public: + const CONT *cont_; + typename TRAITS::iterator iter_; + + template + sa_debug_iterator(IT ptr, const CONT *cont) : iter_(ptr), cont_(cont) {} + + sa_debug_iterator( const sa_debug_iterator > &nc_it ) : iter_(nc_it.iter_), cont_(nc_it.cont_) {} + + sa_debug_iterator(): cont_(NULL) {} + + typename TRAITS::iterator get_raw()const { return iter_; } + typename TRAITS::const_iterator get_const_raw()const { return iter_; } + + + sa_debug_iterator operator++(int) { + COMET_ASSERT( cont_!=NULL); + COMET_ASSERT( get_const_raw() < cont_->end().get_raw() ); + sa_debug_iterator t(*this); + ++iter_; + return t; + } + + sa_debug_iterator& operator++() { + COMET_ASSERT( cont_!=NULL); + COMET_ASSERT( get_const_raw() < cont_->end().get_raw() ); + ++iter_; + return *this; + } + + sa_debug_iterator operator--(int) { + COMET_ASSERT( cont_!=NULL); + COMET_ASSERT( get_const_raw() > cont_->begin().get_raw() ); + sa_debug_iterator t(*this); + --iter_; + return t; + } + + sa_debug_iterator& operator--() { + COMET_ASSERT( cont_!=NULL); + COMET_ASSERT( get_const_raw() > cont_->begin().get_raw() ); + --iter_; + return *this; + } + + typename TRAITS::reference operator[](size_t n) { + COMET_ASSERT( cont_!=NULL); + COMET_ASSERT( (get_const_raw()+ n) >= cont_->begin().get_raw()); + COMET_ASSERT( (get_const_raw()+n) < cont_->end().get_raw() ); + return iter_[n]; + } + + sa_debug_iterator& operator+=(size_t n) { + COMET_ASSERT(cont_!=NULL); + COMET_ASSERT((get_const_raw()+ n) >= cont_->begin().get_raw()); + COMET_ASSERT((get_const_raw()+n) <= cont_->end().get_raw() ); + iter_ += n; + return *this; + } + + sa_debug_iterator& operator-=(size_t n) { + COMET_ASSERT( cont_!=NULL); + COMET_ASSERT( (get_const_raw()- n) >= cont_->begin().get_raw()); + COMET_ASSERT( (get_const_raw()- n) <= cont_->end().get_raw() ); + iter_ -= n; + return *this; + } + + ptrdiff_t operator-(const sa_debug_iterator& it) const { + COMET_ASSERT( cont_!=NULL); + COMET_ASSERT( cont_ == it.cont_); + return iter_ - it.iter_; + } + + bool operator<(const sa_debug_iterator& it) const { + COMET_ASSERT( cont_!=NULL); + COMET_ASSERT( cont_ == it.cont_); + return iter_ < it.iter_; + } + + bool operator>(const sa_debug_iterator& it) const { + COMET_ASSERT( cont_!=NULL); + COMET_ASSERT( cont_ == it.cont_); + return iter_ > it.iter_; + } + + bool operator<=(const sa_debug_iterator& it) const { + COMET_ASSERT( cont_!=NULL); + COMET_ASSERT( cont_ == it.cont_); + return iter_ <= it.iter_; + } + + bool operator>=(const sa_debug_iterator& it) const { + COMET_ASSERT( cont_!=NULL); + COMET_ASSERT( cont_ == it.cont_); + return iter_ >= it.iter_; + } + + bool operator==(const sa_debug_iterator& it) const { + COMET_ASSERT( cont_!=NULL); + COMET_ASSERT( cont_ == it.cont_); + return iter_ == it.iter_; + } + + bool operator!=(const sa_debug_iterator& it) const { + COMET_ASSERT( cont_!=NULL); + COMET_ASSERT( cont_ == it.cont_); + return iter_ != it.iter_; + } + + sa_debug_iterator operator+(size_t n) const { + COMET_ASSERT( cont_!=NULL); + COMET_ASSERT( (get_const_raw() + n) >= cont_->begin().get_raw()); + COMET_ASSERT( (get_const_raw() + n) <= cont_->end().get_raw() ); + return sa_debug_iterator( iter_+n, cont_); + } + + sa_debug_iterator operator-(size_t n) const { + COMET_ASSERT( cont_!=NULL); + COMET_ASSERT( (get_const_raw() - n) >= cont_->begin().get_raw()); + COMET_ASSERT( (get_const_raw() - n) <= cont_->end().get_raw() ); + return sa_debug_iterator( iter_-n, cont_); + } + + typename TRAITS::reference operator*() { + COMET_ASSERT( cont_ != NULL); + COMET_ASSERT( (get_const_raw()) >= cont_->begin().get_raw()); + COMET_ASSERT( (get_const_raw()) < cont_->end().get_raw() ); + return *iter_; + } + }; + + +#else // COMET_ITERATOR_DEBUG +#define COMET_IT_DBG__(x) +#define COMET_SAIT_THIS +#define COMET_SAIT_ITER(CONT_, IT_, TRAITS_) IT_ +#endif // COMET_ITERATOR_DEBUG + + + /** \internal + */ + template class sa_iterator : public std::iterator, + public access_operator::result>::template base< T, sa_iterator > + + { + typedef sa_iterator > nonconst_self; + public: + typedef sa_traits traits; + typename traits::raw* ptr_; + + typedef typename TR::pointer pointer; + typedef typename TR::reference reference; + typedef ptrdiff_t difference_type; + + sa_iterator(const nonconst_self& it ) + : ptr_(it.get_raw()) + {} + + explicit sa_iterator(typename traits::raw* ptr) : ptr_(ptr) {} + + sa_iterator() {} + + typename traits::raw* get_raw() const + { + return ptr_; + } + + sa_iterator operator++(int) { + sa_iterator t(*this); + ++ptr_; + return t; + } + + sa_iterator& operator++() { + ++ptr_; + return *this; + } + + sa_iterator operator--(int) { + sa_iterator t(*this); + --ptr_; + return t; + } + + sa_iterator& operator--() { + --ptr_; + return *this; + } + + reference operator[](size_t n) { + return traits::create_reference(ptr_[n]); + } + + sa_iterator& operator+=(size_t n) { + ptr_ += n; + return *this; + } + + sa_iterator& operator-=(size_t n) { + ptr_ -= n; + return *this; + } + + difference_type operator-(const sa_iterator& it) const { + return ptr_ - it.ptr_; + } + + bool operator<(const sa_iterator& it) const { + return ptr_ < it.ptr_; + } + + bool operator>(const sa_iterator& it) const { + return ptr_ > it.ptr_; + } + + bool operator<=(const sa_iterator& it) const { + return ptr_ <= it.ptr_; + } + + bool operator>=(const sa_iterator& it) const { + return ptr_ >= it.ptr_; + } + + bool operator==(const sa_iterator& it) const { + return ptr_ == it.ptr_; + } + + bool operator!=(const sa_iterator& it) const { + return ptr_ != it.ptr_; + } + + sa_iterator operator+(size_t n) const { + return sa_iterator(ptr_ + n); + } + + sa_iterator operator-(size_t n) const { + return sa_iterator(ptr_ - n); + } + + template friend sa_iterator operator+(size_t n, const sa_iterator& it); + // friend sa_iterator operator+(size_t n, const sa_iterator&); + + reference operator*() { return traits::create_reference(*ptr_); } + }; + + } + + namespace impl + { + template + class safearray_auto_ref_t; + + template + class safearray_auto_const_ref_t; + }; + + /*! \addtogroup COMType + */ + //@{ + /**STL container compatible wrapper for a safearray. + * Provides forwards and reverse iterators. + */ +#ifdef COMET_PARTIAL_SPECIALISATION + + template + struct get_extras + { + static void *extras(){ return 0; } + }; + template + struct get_extras + { + static void *extras(){ return impl::sa_traits::get_record_info().in(); } + }; + template + struct get_extras + { + static void *extras(){ return impl::sa_traits::iid().in_ptr(); } + }; + + template + struct traits_sanity_check + { static inline void check( const SAFEARRAY *psa) { } }; + template + struct traits_sanity_check + { + static void check(SAFEARRAY *psa) { + if ((psa->fFeatures & FADF_HAVEVARTYPE)!=0) + { + VARTYPE vt; + ::SafeArrayGetVartype(psa, &vt) | raise_exception ; + if(vt != impl::sa_traits::vt) + throw std::runtime_error("safearray_t: VarType mismatch"); + } + } + }; + template + struct traits_sanity_check { + static void check(SAFEARRAY *psa) + { + uuid_t iid; + ::SafeArrayGetIID(psa, &iid) | raise_exception; + if( iid != impl::sa_traits::iid() ) + throw std::runtime_error("safearray_t: IID mismatch"); + } + }; +#endif + template class safearray_t + { + public: + typedef impl::sa_traits traits; + typedef size_t size_type; ///< type for sizes (bounds etc). + typedef long index_type; ///< Type for indexing into the array + typedef ptrdiff_t difference_type; ///< Type for pointer differences + typedef typename traits::value_type value_type; ///< The type of the contained value . + typedef typename traits::reference reference; ///< Safearray reference type + typedef typename traits::const_reference const_reference; ///< Safearray const reference type + + typedef typename COMET_SAIT_ITER( safearray_t, traits::iterator, impl::sa_debug_traits ) + iterator; ///< Iterator type + typedef typename COMET_SAIT_ITER( safearray_t, traits::const_iterator, impl::sa_const_debug_traits) + const_iterator; ///< Const iterator type + +#if defined(COMET_STD_ITERATOR) + typedef std::reverse_iterator reverse_iterator; + typedef std::reverse_iterator const_reverse_iterator; +#else + // workaround for broken reverse_iterator implementations due to no partial specialisation + typedef std::reverse_iterator reverse_iterator; + typedef std::reverse_iterator const_reverse_iterator; +#endif + + //! \name Iterator functions + //@{ + iterator begin() { + return iterator(get_array() COMET_SAIT_THIS ); + } + + iterator end() { + return iterator(get_array() + size() COMET_SAIT_THIS ); + } + + const_iterator begin() const { + return const_iterator(get_array() COMET_SAIT_THIS) ; + } + + const_iterator end() const { + return const_iterator(get_array() + size() COMET_SAIT_THIS ); + } + + reverse_iterator rbegin() { + return reverse_iterator(end()); + } + + reverse_iterator rend() { + return reverse_iterator(begin()); + } + + const_reverse_iterator rbegin() const { + return const_reverse_iterator(end()); + } + + const_reverse_iterator rend() const { + return const_reverse_iterator(begin()); + } + //@} + + /// The number of elements in the array. + size_type size() const { + return psa_ ? psa_->rgsabound[0].cElements : 0; + } + + /// Returns whether the array is empty. + bool is_empty() const { + return size() == 0; + } + + /// Returns element n relative to lower_bound() + reference operator[](index_type n) { + COMET_ASSERT( (size_type)(n - lower_bound()) < size() ); + return traits::create_reference(get_element(n)); + } + + /// Returns const element n relative to lower_bound() + const_reference operator[](index_type n) const { + COMET_ASSERT( (size_type)(n - lower_bound()) < size() ); + return traits::create_reference(get_element(n)); + } + + //! Returns element n relative to lower_bound(). + /*! \throw out_of_range The index is out of range. + */ + reference at(index_type n) { + range_check(n); + return traits::create_reference(get_element(n)); + } + + //! Returns const element n relative to lower_bound(). + /*! \throw out_of_range The index is out of range. + */ + const_reference at(index_type n) const { + range_check(n); + return traits::create_reference(get_element(n)); + } + + //! The front element. + reference front() { return *begin(); } + //! The front element - const. + const_reference front() const { return *begin(); } + //! The back element. + reference back() { return *(end() - 1); } + //! The back element - const. + const_reference back() const { return *(end() - 1); } + + private: +#ifndef COMET_PARTIAL_SPECIALISATION + template + struct get_extras + { + static void *extras(){ return 0; } + }; + template<> + struct get_extras + { + static void *extras(){ return impl::sa_traits::get_record_info().in(); } + }; + template<> + struct get_extras + { + static void *extras(){ return impl::sa_traits::iid().in_ptr(); } + }; +#endif + public: + + /// \name Constructors + //@{ + /// Construct a null array. + safearray_t() : psa_(0) + {} + + /*! Attach to (and take ownership of) an existing array. + \code + SAFEARRAY *psa = SafeArrayCreateVectorEx(VT_BSTR, 0, 5, NULL); + safearray_t sa(auto_attach(psa)); + \endcode + */ + safearray_t(const impl::auto_attach_t& psa) : psa_(psa.get()) + { + sanity_check(psa_); + + if (psa_) try { + ::SafeArrayLock(psa_) | raise_exception; + } catch (...) + { + ::SafeArrayDestroy(psa_); + throw; + } + } + + /// Copy from a variant, making converting if necessary. + safearray_t(const variant_t& var) + { + if(var.get_vt() == (VT_ARRAY|traits::vt)) + { + SafeArrayCopy(var.in().parray, &psa_) | raise_exception; + } else { + variant_t v2(var, VT_ARRAY|traits::vt); + SafeArrayCopy(v2.in().parray, &psa_) | raise_exception; + } + + if (psa_) try { + ::SafeArrayLock(psa_) | raise_exception; + } catch (...) + { + ::SafeArrayDestroy(psa_); + throw; + } + + } + + /// Copy construction + safearray_t(const safearray_t& sa) + { + ::SafeArrayCopy(sa.psa_, &psa_) | raise_exception; + + if (psa_) try { + ::SafeArrayLock(psa_) | raise_exception; + } catch (...) + { + ::SafeArrayDestroy(psa_); + throw; + } + } + + /// Construct a new safearray vector. + /*! \param sz Size of the vector. + * \param lb Lower bound for the vector. + */ + explicit safearray_t(size_type sz, index_type lb) + { + if (sz > (std::numeric_limits::max)() || + sz < (std::numeric_limits::min)()) + throw std::overflow_error( + "Cannot create array of requested size"); + +#ifndef COMET_PARTIAL_SPECIALISATION + psa_ = ::SafeArrayCreateVectorEx( + traits::vt, lb, static_cast(sz), + get_extras::extras()); +#else + psa_ = ::SafeArrayCreateVectorEx( + traits::vt, lb, static_cast(sz), + get_extras::extras()); +#endif + if (psa_ == 0) throw std::bad_alloc(); + + try { + ::SafeArrayLock(psa_) | raise_exception; + } catch (...) + { + ::SafeArrayDestroy(psa_); + throw; + } + } + + /// Construct a new safearray vector. + /*! \param sz Size of the vector. + * \param lb Lower bound for the vector. + * \param val Initial value for the elements. + */ + safearray_t(size_type sz, index_type lb, const T& val) + { +#ifndef COMET_PARTIAL_SPECIALISATION + psa_ = ::SafeArrayCreateVectorEx(traits::vt, lb, sz, get_extras::extras()); +#else + psa_ = ::SafeArrayCreateVectorEx(traits::vt, lb, sz, get_extras::extras()); +#endif // COMET_PARTIAL_SPECIALISATION + if (psa_ == 0) throw std::bad_alloc(); + + try { + ::SafeArrayLock(psa_) | raise_exception; + + for (iterator it = begin(); it != end(); ++it) *it = val; + } catch (...) { + ::SafeArrayUnlock(psa_); + ::SafeArrayDestroy(psa_); + throw; + } + } + + /// Construct a safearray from an iterator, specifying the lower bound. + /** \param first First element of the container. + * \param last Beyond the last element of the container. + * \param lb Lower bound of the new safearray_t. + */ + template safearray_t(InputIterator first, InputIterator last, index_type lb) + { + initialise_aux(first, last, lb, type_traits::int_holder< type_traits::is_integer::result >()); + } + //@} + +private: + template void initialise_aux(InputIterator first, InputIterator last, index_type lb, type_traits::int_holder) + { + size_type sz = std::distance(first, last); +#ifndef COMET_PARTIAL_SPECIALISATION + psa_ = ::SafeArrayCreateVectorEx(traits::vt, lb, sz,get_extras::extras()); +#else + psa_ = ::SafeArrayCreateVectorEx(traits::vt, lb, sz,get_extras::extras()); +#endif //COMET_PARTIAL_SPECIALISATION + + if (psa_ == 0) throw std::bad_alloc(); + + try { + ::SafeArrayLock(psa_) | raise_exception; + + for (iterator it = begin(); first != last; ++first, ++it) { + *it = *first; + } + } catch (...) { + ::SafeArrayUnlock(psa_); + ::SafeArrayDestroy(psa_); + throw; + } + } + + template void initialise_aux(Integer sz, Integer lb, index_type dummy, type_traits::int_holder) + { +#ifndef COMET_PARTIAL_SPECIALISATION + psa_ = ::SafeArrayCreateVectorEx(traits::vt, lb, sz,get_extras::extras()); +#else + psa_ = ::SafeArrayCreateVectorEx(traits::vt, lb, sz,get_extras::extras()); +#endif // COMET_PARTIAL_SPECIALISATION + + if (psa_ == 0) throw std::bad_alloc(); + + ::SafeArrayLock(psa_) | raise_exception; + } + +public: + /// Resize the array, preserving lower_bound + /** If the array is null, uses 0. + */ + void resize(size_type n) + { + resize_bound(n, (psa_==NULL)?0:lower_bound()); + } + /// Resize the array, specifying the lower_bound + // This has been renamed to prevent ambiguous functions when T = size_type + void resize_bound(size_type n, size_type lb) + { + safearray_t t(n, lb); + + iterator i1 = begin(); + iterator i2 = t.begin(); + + for (;i1 != end() && i2 != t.end(); ++i1, ++i2) { + std::swap(*i1, *i2); + } + + swap(t); + } + + /** Resize the array, preserving lower_bound and specifying an initial + * value for uninitialised values. + */ + void resize( size_type n, const T& val) { + resize_bound(n,(psa_==NULL)?0:lower_bound(),val); + } + /** Resize the array, specifying lower_bound and specifying an initial + * value for uninitialised values. + */ + void resize_bound(size_type n, size_type lb, const T& val) { + safearray_t t(n, lb); + + iterator i1 = begin(); + iterator i2 = t.begin(); + + for (;i1 != end() && i2 != t.end(); ++i1, ++i2) { + std::swap(*i1, *i2); + } + + for (;i2 != t.end(); ++i2) *i2 = val; + + swap(t); + } + + /// Assign the safearray to be \p v elements of \p val. + void assign(size_type n, const T& val) { + safearray_t t(n, lower_bound(), val); + swap(t); + } + + /// Assign the safearray from a f \p first and \p last iterators. + template void assign(InputIterator first, InputIterator last) { + assign_aux(first, last, type_traits::int_holder< type_traits::is_integer::result >()); + } + + /** Return the IRecordInfo struct for the array for VT_RECORD. + */ + com_ptr get_record_info() + { + com_ptr rec_info; + ::SafeArrayGetRecordInfo(psa_, rec_info.out()) | raise_exception; + return rec_info; + } + /** Get the Variant Type of the members of the array. + */ + VARTYPE get_vt() + { + // Something appears broken in SafeArrayGetVartype - returning VT_UNKNOWN when it has FADF_DISPATCH set. + if (psa_->fFeatures & FADF_DISPATCH) return VT_DISPATCH; + if (psa_->fFeatures & FADF_UNKNOWN) return VT_UNKNOWN; + VARTYPE retval; + ::SafeArrayGetVartype(psa_, &retval) | raise_exception; + return retval; + } + + /** Return interface-id of the members of the array. + */ + uuid_t get_iid() + { + uuid_t iid; + ::SafeArrayGetIID(psa_, &iid) | raise_exception; + return iid; + } + +private: + template void assign_aux(InputIterator first, InputIterator last, type_traits::int_holder) + { + safearray_t t( first, last, lower_bound() ); + swap(t); + } + + template void assign_aux(Integer sz, const T& val, type_traits::int_holder) + { + safearray_t t(sz, lower_bound(), val); + swap(t); + } +public: + + /// Insert \p n elements of \p val at position \p pos. + void insert(iterator pos, size_type n, const T& val) { + safearray_t t(n+size(), lower_bound()); + iterator i1 = t.begin(); + iterator i2 = begin(); + + for (;i2 != pos; ++i1, ++i2) *i1 = *i2; + for (;n>0;--n, ++i1) *i1 = val; + for (;i2 != end(); ++i1, ++i2) *i1 = *i2; + + swap(t); + } + + + /// Insert elements coppied from iterator \p first to \p last at position pos. + template void insert(iterator pos, InputIterator first, InputIterator last) { + insert_aux(pos, first, last, type_traits::int_holder::result >()); + } + + /// Push an element to the back of the list (ensure lower-bound); + void push_back( const T& val, index_type lb ) + { + safearray_t t(size()+1, lb); + + iterator i1 = begin(), i2 = t.begin(); + + for (;i1 != end() ; ++i1, ++i2) + std::swap(*i1, *i2); + + *i2 = val; + + swap(t); + } + + /// Push an element to the back of the list. + inline void push_back( const T& val) + { + push_back(val, lower_bound()); + } + + /// Pop an element from the back of the list. + inline void pop_back() + { + size_type lastone = size(); + if (lastone > 0) + erase(begin()+(lastone-1)); + } + + /// Push an element to the front of the list (ensure lower-bound). + void push_front( const T &val, index_type lb) + { + safearray_t t(size()+1, lb); + + iterator i1 = begin(), i2 = t.begin(); + + *i2 = val; + + for (++i2; i1 != end(); ++i1, ++i2) + std::swap(*i1, *i2); + + swap(t); + } + /// Push an element to the front of the list. + inline void push_front( const T &val) + { + push_front(val, lower_bound()); + } + /// Pop an element from the front of the list. + inline void pop_front() + { + erase(begin()); + } + + /// Erase a specified item. + /** \param it Item to erase + * \return Item beyond erased item. + */ + iterator erase(iterator it) + { + if (it == end()) + return end(); + size_type where= it-begin(); + + safearray_t t(size()-1, lower_bound()); + iterator ret = t.end(); + iterator i1 = begin(), i2 = t.begin(); + // Copy up to iterator + for (; i1 != end() && i1 != it; ++i1, ++i2) + std::swap(*i1,*i2); + ++i1;// Skip this one + for (; i1 != end(); ++i1, ++i2) + std::swap(*i1,*i2); + + swap(t); + return begin()+where; + } + + /// Erase a range of items. + /** \param first Item to erase from + * \param second Item after range to be erased. + * \return Item beyond erased range. + */ + iterator erase(iterator first, iterator second) + { + safearray_t t(size()-(second-first), lower_bound()); + size_type where= first-begin(); + iterator i1 = begin(), i2 = t.begin(); + // Copy up to first. + for (; i1 != end() && i1 != first; ++i1, ++i2) + std::swap(*i1,*i2); + // Skip up to second + for( ; i1 != second; ++i1) + ; + // skip to end. + for (; i1 != end(); ++i1, ++i2) + std::swap(*i1,*i2); + + swap(t); + return begin()+where; + } + + + private: + template void insert_aux(iterator pos, InputIterator first, InputIterator last, type_traits::int_holder) { + size_type n = std::distance(first, last); + + safearray_t t(n+size(), lower_bound()); + iterator i1 = t.begin(); + iterator i2 = begin(); + + for (;i2 != pos; ++i1, ++i2) *i1 = *i2; + for (;first != last; ++i1, ++first) *i1 = *first; + for (;i2 != end(); ++i1, ++i2) *i1 = *i2; + + swap(t); + } + + template void insert_aux(iterator pos, Integer n, const T& val, type_traits::int_holder) { + safearray_t t(n+size(), lower_bound()); + iterator i1 = t.begin(); + iterator i2 = begin(); + + for (;i2 != pos; ++i1, ++i2) *i1 = *i2; + for (;n>0;--n, ++i1) *i1 = val; + for (;i2 != end(); ++i1, ++i2) *i1 = *i2; + + swap(t); + } + public: + + //! \name Assignment Operators + //@{ + safearray_t& operator=(const safearray_t& sa) + { + safearray_t t(sa); + swap(t); + return *this; + } + + safearray_t& operator=(const variant_t& v) + { + safearray_t t(v); + swap(t); + return *this; + } + + safearray_t& operator=(const impl::auto_attach_t& sa) + { + safearray_t t(sa); + swap(t); + return *this; + } + //@} + + private: + void destroy() { + if (psa_ != 0) { + COMET_ASSERT(psa_->cLocks == 1); + ::SafeArrayUnlock(psa_); + ::SafeArrayDestroy(psa_); + psa_ = 0; + } + } + + public: + + ~safearray_t() { + destroy(); + } + + /// Unlock and detach a raw SAFEARRAY. + SAFEARRAY* detach() { + if (psa_) { + ::SafeArrayUnlock(psa_); + } + SAFEARRAY* rv = psa_; + psa_ = 0; + return rv; + } + + /*! Detach the safearray to the variant \p var. + The safearray becomes invalid after this point. + \code + safe_array_t ints(2,0); + variant_t var; + ints.detach_to(var); + \endcode + */ + void detach_to( variant_t &var) + { + COMET_ASSERT(psa_->cLocks == 1); + if (psa_) ::SafeArrayUnlock(psa_) | raise_exception; + var = auto_attach( psa_ ); + psa_= 0; + } + + /*! Detach a safearray from the variant \p var. + An attempt is made to cast the type of the variant before attaching. + */ + void detach_from( variant_t &var) + { + if(var.get_vt()!=(VT_ARRAY|traits::vt)) + { + var.change_type(VT_ARRAY|traits::vt); + } + safearray_t t(auto_attach(var.detach().parray)); + swap(t); + } + + /// The lower bound of the array. + /** \sa get_at + */ + index_type lower_bound() const { + return psa_ ? psa_->rgsabound[0].lLbound : 0; + } + + /// Change the lower_bound of the array. + void lower_bound(index_type lb) { + psa_->rgsabound[0].lLbound = lb; + } + + private: + class sa_auto_lock_t + { + SAFEARRAY** ppsa_; + + // These are not available + sa_auto_lock_t(); + sa_auto_lock_t(const sa_auto_lock_t&); + sa_auto_lock_t& operator=(const sa_auto_lock_t&); + public: + operator SAFEARRAY**() throw() { return ppsa_; } + + sa_auto_lock_t(SAFEARRAY** ppsa) : ppsa_(ppsa) {} + + ~sa_auto_lock_t() + { + if (*ppsa_) { + HRESULT hr = ::SafeArrayLock(*ppsa_); + COMET_ASSERT( SUCCEEDED(hr) ); + hr; + } + } + }; + + public: + //! \name Access converters + //@{ + SAFEARRAY* in() const throw() { + return const_cast(psa_); + } + SAFEARRAY** in_ptr() const throw() { + return const_cast(&psa_); + } + sa_auto_lock_t inout() throw() { + if (psa_) { + ::SafeArrayUnlock(psa_); + } + return &psa_; + } + sa_auto_lock_t out() throw() { + destroy(); + return &psa_; + } + //@} + /*! Detach a raw SAFEARRAY pointer from a safearray_t. + */ + static SAFEARRAY* detach(safearray_t& sa) + { + return sa.detach(); + } + + /** Create a reference to a safearray from a raw SAFEARRAY pointer. + * Mainly used by the implementation wrappers. + */ + static const impl::safearray_auto_const_ref_t create_const_reference(SAFEARRAY* const & sa); + static impl::safearray_auto_ref_t create_reference(SAFEARRAY* & sa); + + /** Create a reference to a safearray from a variant. + \code + function( const variant_t &var) + { + const safe_array &stringarray = safe_array::create_reference( var ); + } + \endcode + */ + static const impl::safearray_auto_const_ref_t create_const_reference(const variant_t &var); + /** Create c const reference to a safearray from a variant. + */ + static impl::safearray_auto_ref_t create_reference(variant_t &var); + + void swap(safearray_t& sa) throw() + { + std::swap(psa_, sa.psa_); + } + + private: + + void range_check(index_type n) const { + size_type m = (size_type)(n - lower_bound()); + if (/*m < 0 || */ m >= size()) throw std::out_of_range("safearray_t"); + } + + typename traits::raw* get_array() const { + if (psa_) { + COMET_ASSERT(psa_->cLocks != 0); + return static_cast(psa_->pvData); + } + return NULL; + } + + typename traits::raw& get_element(size_type n) const { + return get_array()[n - lower_bound()]; + } + + protected: + SAFEARRAY* psa_; + +#ifndef COMET_PARTIAL_SPECIALISATION + + template< enum impl::sa_traits_check_type STCT > + struct traits_sanity_check + { static inline void check( const SAFEARRAY *psa) { } }; + template<> + struct traits_sanity_check + { + static void check(SAFEARRAY *psa) { + if ((psa->fFeatures & FADF_HAVEVARTYPE)!=0) + { + VARTYPE vt; + ::SafeArrayGetVartype(psa, &vt) | raise_exception ; + if(vt != impl::sa_traits::vt) + throw std::runtime_error("safearray_t: VarType mismatch"); + } + } + }; + template<> + struct traits_sanity_check { + static void check(SAFEARRAY *psa) + { + uuid_t iid; + ::SafeArrayGetIID(psa, &iid) | raise_exception; + if( iid != impl::sa_traits::iid() ) + throw std::runtime_error("safearray_t: IID mismatch"); + } + }; +#endif + /// Make sure the passed in safearray agrees with the type of the safearray_t + static void sanity_check(SAFEARRAY* psa) { + if (psa == 0) return; + if (psa->cDims != 1) throw std::runtime_error("safearray_t: Invalid dimension"); + if (!traits::are_features_ok( psa->fFeatures )) throw std::runtime_error("safearray_t: fFeatures is invalid"); +#ifndef COMET_PARTIAL_SPECIALISATION + traits_sanity_check< impl::sa_traits_check_type(traits::check_type)>::check(psa); +#else + traits_sanity_check::check(psa); +#endif + if (sizeof(T) != psa->cbElements) throw std::runtime_error("safearray_t: cbElements mismatch"); + } + + }; + //@} + + namespace impl { + + template< typename T> + class safearray_auto_ref_t : public safearray_t + { + // Don't allow any of these. + safearray_auto_ref_t(); + safearray_auto_ref_t &operator=(const safearray_auto_ref_t &); + safearray_auto_ref_t &operator=(const safearray_t &); + safearray_t& operator=(const impl::auto_attach_t &); + void swap(safearray_t& sa); + + // Remember where we got the original for a non-const reference + SAFEARRAY *& psa_; + + public: + safearray_auto_ref_t(const safearray_auto_ref_t &sa) + : safearray_t(auto_attach(sa.psa_)), psa_(sa.psa_) + { + COMET_STATIC_ASSERT(false); + } + + explicit safearray_auto_ref_t(SAFEARRAY *& psa) + : safearray_t(auto_attach(psa)), psa_(psa) + { + } + + ~safearray_auto_ref_t() + { + psa_ = this->detach(); + } + }; + + template< typename T> + class safearray_auto_const_ref_t : public safearray_t + { + // Don't allow any of these. + safearray_auto_const_ref_t(); + safearray_auto_const_ref_t &operator=(const safearray_auto_const_ref_t &); + safearray_auto_const_ref_t &operator=(const safearray_t &); + safearray_t& operator=(const impl::auto_attach_t &); + void swap(safearray_t& sa); + + public: + safearray_auto_const_ref_t(const safearray_auto_const_ref_t &sa) + : safearray_t(auto_attach(sa.psa_)) + { + COMET_STATIC_ASSERT(false); + } + + explicit safearray_auto_const_ref_t(SAFEARRAY *psa) + : safearray_t(auto_attach(psa)) + { + } + + ~safearray_auto_const_ref_t() + { + this->detach(); + } + }; + + } + + template + const impl::safearray_auto_const_ref_t safearray_t::create_const_reference(SAFEARRAY* const & sa) + { + return impl::safearray_auto_const_ref_t(sa); + } + template + impl::safearray_auto_ref_t safearray_t::create_reference(SAFEARRAY* & sa) + { + return impl::safearray_auto_ref_t(sa); + } + template + const impl::safearray_auto_const_ref_t safearray_t::create_const_reference(const variant_t &var) + { + if(var.get_vt()!=(VT_ARRAY|traits::vt)) + throw std::exception("unexepected array type"); + + SAFEARRAY *sa = var.get().parray; + return impl::safearray_auto_const_ref_t(sa); + } + template + impl::safearray_auto_ref_t safearray_t::create_reference(variant_t &var) + { + if(var.get_vt()!=(VT_ARRAY|traits::vt)) + throw std::exception("unexepected array type"); + + SAFEARRAY *sa = var.get().parray; + return impl::safearray_auto_ref_t(sa); + } + + + + template inline comet::impl::sa_iterator operator+(size_t n, const comet::impl::sa_iterator& it) { + return it + n; + } + +} // namespace comet + +namespace { + COMET_STATIC_ASSERT( sizeof(SAFEARRAY*) == sizeof(comet::safearray_t) ); +} + +namespace std { + template<> inline void swap( comet::safearray_t& x, comet::safearray_t& y) COMET_STD_SWAP_NOTHROW; + template<> inline void swap( comet::safearray_t& x, comet::safearray_t& y) COMET_STD_SWAP_NOTHROW; + template<> inline void swap( comet::safearray_t& x, comet::safearray_t& y) COMET_STD_SWAP_NOTHROW; + template<> inline void swap( comet::safearray_t& x, comet::safearray_t& y) COMET_STD_SWAP_NOTHROW; + template<> inline void swap( comet::safearray_t& x, comet::safearray_t& y) COMET_STD_SWAP_NOTHROW; + template<> inline void swap( comet::safearray_t& x, comet::safearray_t& y) COMET_STD_SWAP_NOTHROW; + template<> inline void swap( comet::safearray_t& x, comet::safearray_t& y) COMET_STD_SWAP_NOTHROW; + template<> inline void swap( comet::safearray_t& x, comet::safearray_t& y) COMET_STD_SWAP_NOTHROW; + template<> inline void swap( comet::safearray_t >& x, comet::safearray_t >& y) COMET_STD_SWAP_NOTHROW; + template<> inline void swap( comet::safearray_t >& x, comet::safearray_t >& y) COMET_STD_SWAP_NOTHROW; +} + +template<> inline void std::swap( comet::safearray_t& x, comet::safearray_t& y) COMET_STD_SWAP_NOTHROW { x.swap(y); } +template<> inline void std::swap( comet::safearray_t& x, comet::safearray_t& y) COMET_STD_SWAP_NOTHROW { x.swap(y); } +template<> inline void std::swap( comet::safearray_t& x, comet::safearray_t& y) COMET_STD_SWAP_NOTHROW { x.swap(y); } +template<> inline void std::swap( comet::safearray_t& x, comet::safearray_t& y) COMET_STD_SWAP_NOTHROW { x.swap(y); } +template<> inline void std::swap( comet::safearray_t& x, comet::safearray_t& y) COMET_STD_SWAP_NOTHROW { x.swap(y); } +template<> inline void std::swap( comet::safearray_t& x, comet::safearray_t& y) COMET_STD_SWAP_NOTHROW { x.swap(y); } +template<> inline void std::swap( comet::safearray_t& x, comet::safearray_t& y) COMET_STD_SWAP_NOTHROW { x.swap(y); } +template<> inline void std::swap( comet::safearray_t& x, comet::safearray_t& y) COMET_STD_SWAP_NOTHROW { x.swap(y); } +template<> inline void std::swap( comet::safearray_t >& x, comet::safearray_t >& y) COMET_STD_SWAP_NOTHROW { x.swap(y); } +template<> inline void std::swap( comet::safearray_t >& x, comet::safearray_t >& y) COMET_STD_SWAP_NOTHROW { x.swap(y); } + +#endif diff --git a/EyeTab_SP2/comet/scope_guard.h b/EyeTab_SP2/comet/scope_guard.h new file mode 100644 index 0000000..cdb1387 --- /dev/null +++ b/EyeTab_SP2/comet/scope_guard.h @@ -0,0 +1,363 @@ +/** \file + * Scope-guards can be used to proivde transactional integrity. + * + * scope_guard and friends are adopted from source by Andrei Alexandrescu and Petru Marginean. + * + * See the article. + */ +/* + * Copyright © 2001 Sofus Mortensen + * + * This material is provided "as is", with absolutely no warranty + * expressed or implied. Any use is at your own risk. Permission to + * use or copy this software for any purpose is hereby granted without + * fee, provided the above notices are retained on all copies. + * Permission to modify the code and to distribute modified code is + * granted, provided the above notices are retained, and a notice that + * the code was modified is included with the above copyright notice. + * + * This header is part of Comet version 2. + * https://github.com/alamaison/comet + */ + + +#ifndef COMET_SCOPE_GUARD_H +#define COMET_SCOPE_GUARD_H + +#include + +namespace comet { + + /*! \addtogroup Misc + */ + //@{ + namespace impl { + + /** Base class providing dismission and safe execution primitives. + */ + class scope_guard_impl_base + { + scope_guard_impl_base& operator =(const scope_guard_impl_base&); + protected: + ~scope_guard_impl_base() + { + } + scope_guard_impl_base(const scope_guard_impl_base& other) throw() + : dismissed_(other.dismissed_) + { + other.dismiss(); + } + template static void safe_execute(J& j) throw() + { + if (!j.dismissed_) + try + { + j.execute(); + } + catch(...) + { + } + } + + mutable bool dismissed_; + public: + scope_guard_impl_base() throw() : dismissed_(false) + { + } + void dismiss() const throw() + { + dismissed_ = true; + } + }; + + /** 0 parameter scope guard. + * \internal + */ + template class scope_guard_impl_0 : public scope_guard_impl_base + { + public: + ~scope_guard_impl_0() throw() + { + safe_execute(*this); + } + + void execute() + { + fun_(); + } + + scope_guard_impl_0(F fun) : fun_(fun) + {} + + private: + F fun_; + }; + + /** 1 parameter scope guard. + * \internal + */ + template class scope_guard_impl_1 : public scope_guard_impl_base + { + public: + ~scope_guard_impl_1() throw() + { + safe_execute(*this); + } + + void execute() + { + fun_(p1_); + } + + scope_guard_impl_1(F fun, P1 p1) : fun_(fun), p1_(p1) + {} + + private: + F fun_; + const P1 p1_; + }; + + /** 2 parameter scope guard. + * \internal + */ + template class scope_guard_impl_2: public scope_guard_impl_base + { + public: + ~scope_guard_impl_2() throw() + { + safe_execute(*this); + } + + void execute() + { + fun_(p1_, p2_); + } + + scope_guard_impl_2(F fun, P1 p1, P2 p2) : fun_(fun), p1_(p1), p2_(p2) + {} + + private: + F fun_; + const P1 p1_; + const P2 p2_; + }; + + /** 3 parameter scope guard. + * \internal + */ + template class scope_guard_impl_3 : public scope_guard_impl_base + { + public: + ~scope_guard_impl_3() throw() + { + safe_execute(*this); + } + + void execute() + { + fun_(p1_, p2_, p3_); + } + + scope_guard_impl_3(F fun, P1 p1, P2 p2, P3 p3) : fun_(fun), p1_(p1), p2_(p2), p3_(p3) + {} + + private: + F fun_; + const P1 p1_; + const P2 p2_; + const P3 p3_; + }; + + /** 0 parameter object scope guard. + * \internal + */ + template class obj_scope_guard_impl_0 : public scope_guard_impl_base + { + public: + ~obj_scope_guard_impl_0() throw() + { + safe_execute(*this); + } + + void execute() + { + (obj_.*memFun_)(); + } + + obj_scope_guard_impl_0(Obj& obj, MemFun memFun) + : obj_(obj), memFun_(memFun) {} + + private: + Obj& obj_; + MemFun memFun_; + }; + + /** 1 parameter object scope guard. + * \internal + */ + template class obj_scope_guard_impl_1 : public scope_guard_impl_base + { + public: + ~obj_scope_guard_impl_1() throw() + { + safe_execute(*this); + } + + void execute() + { + (obj_.*memFun_)(p1_); + } + + obj_scope_guard_impl_1(Obj& obj, MemFun memFun, P1 p1) + : obj_(obj), memFun_(memFun), p1_(p1) {} + + private: + Obj& obj_; + MemFun memFun_; + const P1 p1_; + }; + + /** 2 parameter object scope guard. + * \internal + */ + template class obj_scope_guard_impl_2 : public scope_guard_impl_base + { + public: + ~obj_scope_guard_impl_2() throw() + { + safe_execute(*this); + } + + void execute() + { + (obj_.*memFun_)(p1_, p2_); + } + + obj_scope_guard_impl_2(Obj& obj, MemFun memFun, P1 p1, P2 p2) + : obj_(obj), memFun_(memFun), p1_(p1), p2_(p2) {} + + private: + Obj& obj_; + MemFun memFun_; + const P1 p1_; + const P2 p2_; + }; + + /** Implementation to allow argument to be passed by reference. + * \internal + * \sa make_guard + */ + template class ref_holder + { + T& ref_; + public: + ref_holder(T& ref) : ref_(ref) {} + operator T& () const + { + return ref_; + } + private: + // Disable assignment - not implemented + ref_holder& operator=(const ref_holder&); + }; + + } + + /** Allow an argument to be passed by reference. + * \code + * scope_guard guard = make_guard( fun, by_ref(long) ); + * \endcode + * \relates comet::scope_guard + * \internal + */ + template inline impl::ref_holder by_ref(T& t) + { + return impl::ref_holder(t); + } + + /** Implements a scope guard with 0 parameters. + * \param fun Function or \link functor comet::functor \endlink + * \relates comet::scope_guard + * \internal + */ + template inline impl::scope_guard_impl_0 make_guard(F fun) + { + return impl::scope_guard_impl_0(fun); + } + + /** Implements a scope guard with 1 parameter. + * \param fun Function or \link functor comet::functor \endlink + * \relates comet::scope_guard + * \sa by_ref + * \internal + */ + template inline impl::scope_guard_impl_1 make_guard(F fun, P1 p1) + { + return impl::scope_guard_impl_1(fun, p1); + } + + /** Implements a scope guard with 2 parameters. + * \param fun Function or \link functor comet::functor \endlink + * \relates comet::scope_guard + * \sa by_ref + * \internal + */ + template inline impl::scope_guard_impl_2 make_guard(F fun, P1 p1, P2 p2) + { + return impl::scope_guard_impl_2(fun, p1, p2); + } + + /** Implements a scope guard with 3 parameters. + * \param fun Function or \link functor comet::functor \endlink + * \relates comet::scope_guard + * \sa by_ref + * \internal + */ + template inline impl::scope_guard_impl_3 make_guard(F fun, P1 p1, P2 p2, P3 p3) + { + return impl::scope_guard_impl_3(fun, p1, p2, p3); + } + + /** Implements a scope guard with 0 parameters, calling a memeber function on an object. + * \param fun Function or \link functor comet::functor \endlink + * \relates comet::scope_guard + */ + template inline impl::obj_scope_guard_impl_0 make_obj_guard(Obj& obj, MemFun memFun) + { + return impl::obj_scope_guard_impl_0(obj, memFun); + } + + /** Implements a scope guard with 1 parameter, calling a memeber function on an object. + * \param fun Function or \link functor comet::functor \endlink + * \relates comet::scope_guard + * \sa by_ref + * \internal + */ + template inline impl::obj_scope_guard_impl_1 make_obj_guard(Obj& obj, MemFun memFun, P1 p1) + { + return impl::obj_scope_guard_impl_1(obj, memFun, p1); + } + + /** Implements a scope guard with 2 parameters, calling a memeber function on an object. + * \param fun Function or \link functor comet::functor \endlink + * \relates comet::scope_guard + * \sa by_ref + * \internal + */ + template inline impl::obj_scope_guard_impl_2 make_obj_guard(Obj& obj, MemFun memFun, P1 p1, P2 p2) + { + return impl::obj_scope_guard_impl_2(obj, memFun, p1, p2); + } + + /** Pointer to a scope guard. + * Relies on const references holding on to an assigned stack object for + * the scope of the reference. + * \sa scope_guard_impl_0 obj_scope_guard_impl_0 scope_guard_impl_1 obj_scope_guard_impl_1 scope_guard_impl_2 obj_scope_guard_impl_2 + */ + typedef const impl::scope_guard_impl_base& scope_guard; + + //@} + +} // namespace + +#endif diff --git a/EyeTab_SP2/comet/server.h b/EyeTab_SP2/comet/server.h new file mode 100644 index 0000000..3d87786 --- /dev/null +++ b/EyeTab_SP2/comet/server.h @@ -0,0 +1,1588 @@ +/** \file + * Main functionality for providing a COM server dll. + */ +/* + * Copyright © 2000-2002 Sofus Mortensen, Paul Hollingsworth, Michael Geddes, Mikael Lindgren + * + * This material is provided "as is", with absolutely no warranty + * expressed or implied. Any use is at your own risk. Permission to + * use or copy this software for any purpose is hereby granted without + * fee, provided the above notices are retained on all copies. + * Permission to modify the code and to distribute modified code is + * granted, provided the above notices are retained, and a notice that + * the code was modified is included with the above copyright notice. + * + * This header is part of Comet version 2. + * https://github.com/alamaison/comet + */ + +#ifndef COMET_SERVER_H +#define COMET_SERVER_H + +#include +#ifdef COMET_GCC_HEADERS +#include +#else // COMET_GCC_HEADERS +#include +#endif // COMET_GCC_HEADERS + +#include +#include +#include + +#include +#include +#include +#include +#include +#include +#include + +/** \page cometclassfactory Comet Class Factories + * Comet currently has support for \ref cometclassfactorystandard (non-aggregating), \ref cometclassfactoryaggregating and + * \ref cometclassfactorysingleton class factories. As there has been no demand for custom + * class factories yet, there is currently no support for them. + * + * The different class-factories are enabled by specialising the + * coclass_implementation to inherit off different classes. + * + * \section cometclassfactorystandard Standard + * + * The trigger classes for standard class-factory are either comet::coclass, or + * comet::simple_object. + * + * There is nothing much more noteworthy about this form except that it will + * return CLASS_E_NOAGGREGATION if aggregation is specified. + * + * \section cometclassfactoryaggregating Aggregating + * + * The trigger classes for the aggregating class-factory are comet::aggregateable_coclass or + * comet::aggregateable_object. + * + * The implementation of aggregation in comet is similar to the + * poly-aggregateable implementations found in ATL; there is no + * aggregation-only coclass implementation. + * + * The aggregating class factory will hook up aggegation if an IUnknown is + * supplied. + * + * \section cometclassfactorysingleton Singleton + * + * The trigger classes for the singleton class-factory are + * comet::singleton_coclass or comet::singleton_object. + * + * The singleton class-factory will cause all CreateObject calls for this class to + * return the same object. The life-time of the object is from first call till + * just before the dll/exe is unloaded. + * + * More complex requirements are anticipated, however they have not been + * implemented. + */ + /*! \defgroup Server Server implementation details. + */ + //@{ + +/** Template class for specifying your own custom registration. + + The default template does nothing - define a specialization of ::custom_registration + for each Coclass that you wish to have custom registration. + + on_register is called \em after the standard registration. + on_unregister is called \em before the standard unregistration. + + Common initialization and cleanup code for both registration and unregistration + can be put in the constructor and destructor. + + All exceptions thrown by on_unregister are caught and discarded. + + Example usage: + \code + class custom_registration + { + comet::regkey key_; + public: + custom_registration() + { + key_ = comet::regkey(HKEY_LOCAL_MACHINE).open(_T("Software\\AcmeCorp\\AcmePayroll")); + }; + void on_register(const TCHAR *filename) + { + key_.create(_T("Bill Bloggs")); + } + void on_unregister(const TCHAR *filename) + { + key_.delete_subkey(_T("Bill Bloggs")); + } + }; + \endcode +*/ +template +class custom_registration +{ +public: + void on_register(const TCHAR *) {} + void on_unregister(const TCHAR *) {} +}; +//@} + +namespace comet { + + + namespace impl { + + enum factory_type_t { ft_standard, ft_aggregateable, ft_singleton }; + + inline void create_record_info( const IID& lib_guid, const IID& rec_guid, unsigned short major_version, unsigned short minor_version, IRecordInfo*& ri ) + { + auto_cs lock( module().cs() ); + + if (!ri) { + com_ptr tl; + LoadRegTypeLib(lib_guid, + major_version, + minor_version, + GetUserDefaultLCID(), + tl.out()) | raise_exception; + com_ptr ti; + tl->GetTypeInfoOfGuid(rec_guid, ti.out()) | raise_exception; + GetRecordInfoFromTypeInfo(ti.in(), &ri) | raise_exception; + module().add_object_to_dispose( impl::create_itf_releaser( ri ) ); + } + } + + template struct interface_wrapper : public T + { + typedef T interface_is; + }; + + template class ATL_NO_VTABLE simple_object_aux : + public implement_qi< typelist::append< T, + make_list >::result > > + { + public: +// enum { factory_type = ft_standard }; + + STDMETHOD_(ULONG, AddRef)() + { + LONG rc = InterlockedIncrement(&rc_); + if (rc_ == 1) module().lock(); + return rc; + } + + STDMETHOD_(ULONG, Release)() + { + LONG rc = InterlockedDecrement(&rc_); + if (rc == 0) { + try { + delete this; + } COMET_CATCH_UNKNOWN( L"Release", IID_IUnknown, bstr_t()); + module().unlock(); + } + return rc; + } + + STDMETHOD(InterfaceSupportsErrorInfo)(REFIID) + { + return S_OK; + } + + void so_internal_addref() { ++rc_; } + void so_internal_release() { --rc_; } + + protected: + simple_object_aux() : rc_(0) {} + virtual ~simple_object_aux() {} + private: + long rc_; + + // non-copyable + simple_object_aux(const simple_object_aux&); + simple_object_aux& operator=(const simple_object_aux&); + }; + + } + /*!\defgroup Objects Classes used as bases for COM objects. + */ + //@{ + /** Provide an inner unknown for aggregation. + * This is the unknown that handles lifetime of an aggregateable object. + */ + template + struct aggregate_inner_unknown : IUnknown + { + aggregate_inner_unknown() : rc_(0) {} + + STDMETHOD_(ULONG, AddRef)() + { + if (rc_ == 0) module().lock(); + return InterlockedIncrement(&rc_); + } + + STDMETHOD_(ULONG, Release)() + { + size_t rc = InterlockedDecrement(&rc_); + if (rc == 0) { + try { + delete static_cast(this); + } + COMET_CATCH_UNKNOWN( L"Release", IID_IUnknown, bstr_t()); + module().unlock(); + } + return rc; + } + + STDMETHOD(QueryInterface)(REFIID riid, void **pv) + { + if(riid == IID_IUnknown) + { + *pv=get_inner(); + AddRef(); + return S_OK; + } + return static_cast(this)->QueryInterfaceInternal(riid, pv); + } + + IUnknown *get_inner() { return static_cast(this); } + + private: + long rc_; + }; + + /** Provides the outer-unknown for aggregation. + * This unkonwn points to the agregating unknown if aggregation occured, or + * to the aggregate_inner_unknown class if it didn't. + * This also implements the interfaces and QueryInterface. + */ + template + class aggregate_outer_unknown : public implement_internal_qi< + typelist::append >::result > + > + { + public: + aggregate_outer_unknown(): outer_(NULL) {} + + STDMETHOD_(ULONG, AddRef)() + { + //assert(outer_!=NULL); + return outer_->AddRef(); + } + + STDMETHOD_(ULONG, Release)() + { + //assert(outer_!=NULL); + return outer_->Release(); + } + STDMETHOD(QueryInterface)(REFIID riid, void** ppv) + { + //assert(outer_!=NULL); + return outer_->QueryInterface(riid, ppv); + } + STDMETHOD(InterfaceSupportsErrorInfo)(REFIID) + { + return S_OK; + } + void set_outer_(IUnknown *outer){ outer_ = outer;} + + + private: + IUnknown *outer_; + }; + //@} + + namespace impl { + + template class ATL_NO_VTABLE aggregateable_object_aux : public aggregate_outer_unknown, public aggregate_inner_unknown > + { + public: + aggregateable_object_aux() + { + set_outer_(static_cast(static_cast< aggregate_inner_unknown > *>(this))); + } + + protected: + virtual ~aggregateable_object_aux() {} + friend struct aggregate_inner_unknown >; + private: + // non-copyable + aggregateable_object_aux(const aggregateable_object_aux&); + aggregateable_object_aux& operator=(const aggregateable_object_aux&); + }; + + } + + /*!\addtogroup Objects + */ + //@{ + /*! \class aggregateable_object server.h comet/server.h + Implement a user aggregateable object. + \code + class my_class : public aggregateable_object< IFooImpl, IBarImpl > + { + ... + }; + \endcode + \sa handle_exception_default IProvideClassInfoImpl simple_object + */ + template class ATL_NO_VTABLE aggregateable_object : public impl::aggregateable_object_aux< typename make_list::result > + { + public: + enum { factory_type = impl::ft_aggregateable }; + }; + + /*! \class simple_object server.h comet/server.h + A simple reference counted COM object. + \code + class my_class : public simple_object< IFooImpl, IBarImpl > + { + ... + }; + \endcode + \sa handle_exception_default IProvideClassInfoImpl aggregateable_object + */ + template class ATL_NO_VTABLE simple_object : public impl::simple_object_aux< typename make_list::result > + { + public: + enum { factory_type = impl::ft_standard }; + }; + //@} + + namespace impl { + + + + template class ATL_NO_VTABLE static_object_aux : + public implement_qi< typelist::append< T, make_list >::result > > + { + public: + STDMETHOD_(ULONG, AddRef)() + { + module().lock(); + return 2; + } + + STDMETHOD_(ULONG, Release)() + { + module().unlock(); + return 1; + } + + STDMETHOD(InterfaceSupportsErrorInfo)(REFIID) + { + return S_OK; + } + protected: + static_object_aux() {} + virtual ~static_object_aux() {} + }; + + } + + /*!\addtogroup Objects + */ + //@{ + /*! \class static_object server.h comet/server.h + A simple static allocated COM object. + \code + class my_class : public static_object< IFooImpl, IBarImpl > + { + ... + }; + \endcode + * \sa handle_exception_default IProvideClassInfoImpl + */ + template class ATL_NO_VTABLE static_object : public impl::static_object_aux< typename make_list::result > + { + }; + + /*! \class singleton_object server.h comet/server.h + A simple singleton allocated COM object. + \code + class my_class : public singleton_object< IFooImpl, IBarImpl > + { + ... + }; + \endcode + * \sa handle_exception_default IProvideClassInfoImpl + */ + template class ATL_NO_VTABLE singleton_object : public impl::static_object_aux< typename make_list::result > + { + public: + enum { factory_type = impl::ft_singleton }; + void set_dispose_command_( impl::cmd_t *) { } + }; + + + /*! \class embedded_object server.h comet/server.h + * + * \sa handle_exception_default IProvideClassInfoImpl + * \todo documentation + */ + template class ATL_NO_VTABLE embedded_object : + public implement_qi< typelist::append< typename make_list::result, typename make_list >::result > > + { + public: + STDMETHOD_(ULONG, AddRef)() + { + return parent_->AddRef(); + } + + STDMETHOD_(ULONG, Release)() + { + return parent_->Release(); + } + + STDMETHOD(InterfaceSupportsErrorInfo)(REFIID) + { + return S_OK; + } + + protected: + explicit embedded_object(PARENT* parent) : parent_(parent) {} + + PARENT* get_parent() const { return parent_; } + + typedef embedded_object base_class; + private: + PARENT* parent_; + + // non-copyable + embedded_object(const embedded_object&); + embedded_object& operator=(const embedded_object&); + }; + + /*! \class embedded_object2 server.h comet/server.h + * + * \sa handle_exception_default IProvideClassInfoImpl + * \todo documentation + */ + template class ATL_NO_VTABLE embedded_object2 : + public implement_qi< typelist::append< typename make_list::result, make_list >::result > > + { + public: + STDMETHOD_(ULONG, AddRef)() + { + if (rc_ == 0) module().lock(); + long r = InterlockedIncrement(&rc_); + if (is_connected_) return parent_->AddRef(); + return r; + } + + STDMETHOD_(ULONG, Release)() + { + size_t rc = InterlockedDecrement(&rc_); + + if (is_connected_) return parent_->Release(); + + if (rc == 0) { + try { + delete this; + } + COMET_CATCH_UNKNOWN( L"Release", IID_IUnknown, bstr_t()); + module().unlock(); + } + return rc; + } + + STDMETHOD(InterfaceSupportsErrorInfo)(REFIID) + { + return S_OK; + } + + void disconnect() + { + // todo make thread safe! + + if (is_connected_) { + is_connected_ = false; + + for (long i=0; iRelease(); + + // Provoke destruction if necessary. + AddRef(); + Release(); + } + } + + protected: + explicit embedded_object2(PARENT* parent) : parent_(parent), rc_(0), is_connected_(true) {} + + virtual ~embedded_object2() {} + + PARENT* get_parent() const { return parent_; } + + typedef embedded_object2 base_class; + private: + PARENT* parent_; + bool is_connected_; + long rc_; + + // non-copyable + embedded_object2(const embedded_object2&); + embedded_object2& operator=(const embedded_object2&); + }; + //@} + + /// Base class for class factories. + template class class_factory_base : public IClassFactory + { + public: + STDMETHOD_(ULONG, AddRef)() + { + if (LOCK_MODULE) module().lock(); + return 2; + } + + STDMETHOD_(ULONG, Release)() + { + if (LOCK_MODULE) module().unlock(); + return 1; + } + + STDMETHOD(QueryInterface)(REFIID riid, void **pv) + { + if (!pv) return E_POINTER; + *pv = 0; + if (riid == IID_IClassFactory) *pv = static_cast(this); + if (riid == IID_IUnknown) *pv = this; + + if (*pv == NULL) return E_NOINTERFACE; + + AddRef(); + return S_OK; + } + + STDMETHOD(LockServer)(BOOL bLock) + { + if (bLock) + module().lock(); + else + module().unlock(); + return S_OK; + } + protected: + HRESULT handle_exception( const bstr_t &src ) + { +#ifndef COMET_DISABLE_EXCEPTION_RETHROW_CATCH + return comet_exception_handler::rethrow( source_info_t( src, IID_IUnknown, L"ClassFactory") ); +#else // COMET_DISABLE_EXCEPTION_RETHROW_CATCH + return comet_exception_handler::catcher_hr(E_FAIL, source_info_t(src, IID_IUnknown, L"ClassFactory") ); +#endif // COMET_DISABLE_EXCEPTION_RETHROW_CATCH + } + }; + + //! Basic class-factory. + template class class_factory : public class_factory_base + { + public: + STDMETHOD(CreateInstance)(::IUnknown *pUnkOuter, REFIID riid, void **ppv) + { + if (pUnkOuter) return CLASS_E_NOAGGREGATION; + *ppv = 0; + + if (!LOCK_MODULE) module().lock(); + + T::coclass_type* t; + try { + t = new T; + } + catch (...) + { + if (!LOCK_MODULE) module().unlock(); + return handle_exception( bstr_t(L"CreateInstance(") + bstr_t(uuid_t::create_const_reference(riid),true ) + ")" ); + } + + t->AddRef(); + HRESULT hr = t->QueryInterface(riid, ppv); + t->Release(); + + if (!LOCK_MODULE) module().unlock(); + + return hr; + } + + }; + + //! Class factory for aggregateable objects. + template class class_factory_agg : public class_factory_base + { + STDMETHOD(CreateInstance)(::IUnknown *pUnkOuter, REFIID riid, void **ppv) + { + *ppv = 0; + + if (!LOCK_MODULE) module().lock(); + + T* t; + try { + t = new T; + } + catch (...) + { + if (!LOCK_MODULE) module().unlock(); + return handle_exception( bstr_t(L"CreateInstance(") + bstr_t(uuid_t::create_const_reference(riid),true ) + ")" ); + } + if(pUnkOuter!=NULL) + { + if(riid!=IID_IUnknown) + { + if (!LOCK_MODULE) module().unlock(); + return CLASS_E_NOAGGREGATION; + } + t->set_outer_(pUnkOuter); + } + + t->get_inner()->AddRef(); + HRESULT hr = t->get_inner()->QueryInterface(riid, ppv); + t->get_inner()->Release(); + + if (!LOCK_MODULE) module().unlock(); + + return hr; + } + }; + + /// Class factory for singletons. + template class class_factory_singleton : public class_factory_base + { + public: + class_factory_singleton() : obj_(NULL), primed_(0) + { } + + STDMETHOD(CreateInstance)(::IUnknown *pUnkOuter, REFIID riid, void **ppv) + { + *ppv = 0; + if(pUnkOuter!=NULL) + return CLASS_E_NOAGGREGATION; + + if (!LOCK_MODULE) module().lock(); + + // Add this to the list to get the object disposed on + // moudle terminate. + if (0==InterlockedExchange(&primed_, 1)) + { + module().add_object_to_dispose( create_object_disposer(this) ); + } + + if (obj_ == NULL ) + { + + try { + // Create a new instance, but make sure only one is + // used if there is contention. + T *newVal = new T; + newVal->set_dispose_command_( create_object_disposer(this)); +#ifndef InterlockedCompareExchangePointer + InterlockedCompareExchange( &(void *&)obj_, newVal, 0); +#else + InterlockedCompareExchangePointer( &(void *&)obj_, newVal, 0); +#endif + } + catch (...) + { + if (!LOCK_MODULE) module().unlock(); + return handle_exception( bstr_t(L"CreateInstance(") + bstr_t(uuid_t::create_const_reference(riid),true ) + ")" ); + } + } + + HRESULT hr = obj_->QueryInterface(riid, ppv); + + if (!LOCK_MODULE) module().unlock(); + + return hr; + } + + // Called by object_disposer on module terminate. + void object_dispose() + { + if (obj_ != NULL) + { + T *t= obj_; + obj_ = NULL; + CoDisconnectObject(t->get_unknown(), 0); + delete t; + } + } + + T *obj_; + long primed_; + private: + }; + + + /*!\addtogroup Objects + */ + //@{ + /** Enumerate thread_model. + */ + namespace thread_model { + /** Enumerate thread_model. + */ + enum thread_model_t { + Apartment = 0, ///< Apartment threaded. + Free = 1, ///< Free threaded. + Both = 2, ///< Both threaded (either apartment or free) + Neutral = 3 ///< Netural threaded. + }; + } + //@} + + //! Provide static string description of thread models. + template + struct tm_properties; + + template<> struct tm_properties + { + COMET_FORCEINLINE static const TCHAR *string() { return _T("Apartment"); } + }; + + template<> struct tm_properties + { + COMET_FORCEINLINE static const TCHAR *string() { return _T("Free"); } + }; + + template<> struct tm_properties + { + COMET_FORCEINLINE static const TCHAR *string() { return _T("Both"); } + }; + + template<> struct tm_properties + { + COMET_FORCEINLINE static const TCHAR *string() { return _T("Neutral"); } + }; + + /*! \defgroup Interfaces Interface implementations. + */ + //@{ + /*! \class IProvideClassInfoImpl server.h comet/server.h + * This class provides IProvideClassInfo interfaces for simple, static, embeded or + * other custom classes. + * IProvideClassInfoImpl is used by coclass and aggregateable_coclass by + * default. + * This class also provides class name information to the exception + * handler. + * \sa default_exception_handler_traits + */ + template class IProvideClassInfoImpl : public IProvideClassInfo, public handle_exception_default + { + public: + typedef IProvideClassInfo interface_is; + STDMETHOD(GetClassInfo)(ITypeInfo **ppTypeInfo) throw() + { + if(!ppTypeInfo) return E_POINTER; + *ppTypeInfo = 0; + ITypeLib *pTypeLib; + typedef typename COCLASS::type_library COCLASS_typelib; + HRESULT hr = typelibrary_loader::load(&pTypeLib); + + if(FAILED(hr)) return hr; + hr = pTypeLib->GetTypeInfoOfGuid(uuidof(), ppTypeInfo); + pTypeLib->Release(); + return hr; + } + }; + /** \struct coclass server.h comet/server.h + * Implement a standard coclass with interfaces defined in TypeLibrary and + * implemented within the class \p T and thread model \p TM, followed by a + * list of extra interfaces to implement. + * Provides IProvideClassInfo and ISupportErrorInfo as standard. + * \code + template<> + class coclass_implementation : public coclass + { + // ... + }; + * \endcode + * The thread model can be specified for the coclass, and as well, extra + * interfaces can be implemented by specifying them at the end. + * \code + template<> + class coclass_implementation : public coclass + { + // ... + }; + * \endcode + * \sa FTM aggregates thread_model::thread_model_t + */ + +/* template struct ATL_NO_VTABLE coclass : public impl::simple_object_aux< typelist::append >::result > > { + enum { thread_model = TM }; + static const TCHAR* get_progid() { return 0; } + };*/ + //@} + + /*!\addtogroup Objects + */ + //@{ + template struct ATL_NO_VTABLE coclass : public impl::simple_object_aux< typelist::append< typelist::append< typename T::interface_impls, typename make_list::result>, typename make_list >::result > > { + typedef coclass coclass_type; + enum { factory_type = impl::ft_standard }; + enum { thread_model = TM }; + static const TCHAR* get_progid() { return 0; } + }; + //@} + +// COMET_WRAP_EACH_DECLARE(aggregates_interface); + + namespace impl { + template + struct append3 + { + typedef typelist::append first_two; + typedef typelist::append list; + }; + } +#ifdef NOTNOW + /** \struct coclass_aggregates server.h comet/server.h + * Implement a coclass with interfaces defined in TypeLibrary and + * implemented by the class, as well as supporting specified aggregated interfaces. + * Provides IProvideClassInfo and ISupportErrorInfo as standard. + * \code + * template<> + * class coclass_implementation + * : public coclass_aggregates::result> + * { + * public: + * coclass_implementation() + * { + * aggregates_interface::set_aggregate(com_ptr(CoClassForAggIFace,com_cast(this))); + * } + * // ... + * }; + * \endcode + * \note This should provide IProvideMultipleClassInfo. + */ + +/* template + struct ATL_NO_VTABLE coclass_aggregates : public impl::simple_object_aux >::result > > + { + enum { thread_model = TM }; + static const TCHAR* get_progid() { return 0; } + };*/ +#endif //0 + + /*!\addtogroup Objects + */ + //@{ + /** \struct aggregateable_coclass server.h comet/server.h + * Implement an aggregateable coclass with interfaces defined in TypeLibrary and + * implemented within the class T. + * Provides IProvideClassInfo and ISupportErrorInfo as standard. + * \code + * template<> + * class coclass_implementation + * : public aggregateable_coclass + * { + * // .... + * }; + * \endcode + */ + + template + struct ATL_NO_VTABLE aggregateable_coclass : public impl::aggregateable_object_aux< typelist::append< typename T::interface_impls, typename make_list >::result > > + { + typedef aggregateable_coclass coclass_type; + enum { thread_model = TM }; + enum { factory_type = impl::ft_aggregateable }; + static const TCHAR* get_progid() { return 0; } + aggregateable_coclass() {} + protected: + ~aggregateable_coclass() {} + private: + aggregateable_coclass(const aggregateable_coclass&); + aggregateable_coclass& operator=(const aggregateable_coclass&); + }; + + /** \class singleton_coclass server.h comet/server.h + * Implement a singleton coclass within interfaces defined in TypeLibrary + * and implemented with the class T. + * Gets cleaned up when dll unloads. + * Provides IProvideClassInfo and ISupportErrorInfo as standard. + \code + class coclass_implementation + : public singleton_coclass + { + // .... + }; + \endcode + */ + template< typename T, enum thread_model::thread_model_t TM = thread_model::Apartment> + struct ATL_NO_VTABLE singleton_coclass : public impl::static_object_aux< + typelist::append< typename T::interface_impls, typename make_list >::result > + > + { + typedef singleton_coclass coclass_type; + enum { thread_model = TM }; + enum { factory_type = impl::ft_singleton }; + void set_dispose_command_( impl::cmd_t *) { } + static const TCHAR* get_progid() { return 0; } + singleton_coclass() {} + ~singleton_coclass() {} + + private: + singleton_coclass(const singleton_coclass&); + singleton_coclass& operator=(const singleton_coclass&); + }; + + template< typename T, enum thread_model::thread_model_t TM = thread_model::Apartment> + struct ATL_NO_VTABLE singleton_autorelease_coclass : public impl::static_object_aux< + typelist::append< typename T::interface_impls, typename make_list >::result > + > + { + singleton_autorelease_coclass() : rc_(0), dispose_(0) {} + ~singleton_autorelease_coclass() + { delete dispose_; } + + STDMETHOD_(ULONG, AddRef)() + { + if (rc_ == 0) module().lock(); + return InterlockedIncrement(&rc_); + } + + STDMETHOD_(ULONG, Release)() + { + LONG rc = InterlockedDecrement(&rc_); + if (rc == 0) { + try { + if (dispose_!=NULL) + dispose_->cmd(); + + } COMET_CATCH_UNKNOWN( L"Release", IID_IUnknown, bstr_t()); + module().unlock(); + } + return rc; + } + + typedef singleton_autorelease_coclass coclass_type; + enum { thread_model = TM }; + enum { factory_type = impl::ft_singleton }; + static const TCHAR* get_progid() { return 0; } + + void set_dispose_command_( impl::cmd_t *p) + { + delete dispose_; + dispose_ = p; + } + + private: + singleton_autorelease_coclass(const singleton_autorelease_coclass&); + singleton_autorelease_coclass& operator=(const singleton_autorelease_coclass&); + long rc_; + impl::cmd_t *dispose_; + }; + //@} + + + namespace impl { + template + class reghelper_t + { + // convert_string is overloaded to select the correct + // behaviour based on argument type. + // dest_size is the number of bytes, not the number of characters. + COMET_FORCEINLINE static void convert_string(wchar_t *dest, size_t dest_size, const wchar_t *src) + { + ::memcpy(dest, src, dest_size); + } + + COMET_FORCEINLINE static void convert_string(char *dest, size_t dest_size, const wchar_t *src) + { + ::WideCharToMultiByte(CP_ACP, 0, src, -1, dest, dest_size, 0, 0); + } + + static void removekey(const tstring& key); + static void addkey(const tstring& key, const tstring& valueName, const tstring& value); + static void addkey(const tstring& key, const tstring& value); + static tstring StringFromUUID(REFCLSID rclsid); + static void updatekey(bool unregister, const tstring &key, const tstring &valueName, const tstring &value); + static void updatekey(bool unregister, const tstring &key, const tstring &value); + public: + static void update_coclass(bool unregister, + const CLSID &rclsid, + const TCHAR *filename, + const TCHAR *thread_model, + const TCHAR *coclass_name, + const TCHAR *progid, + unsigned long version, + const GUID &rlibid, + bool inproc_server, + const GUID* appid); + }; // reghelper_t + + template + void reghelper_t::removekey(const tstring& key) + { + regkey rkey(HKEY_CLASSES_ROOT); + rkey.delete_subkey_nothrow(key); + } + + template + void reghelper_t::addkey(const tstring& key, const tstring& valueName, const tstring& value) + { + regkey rkey(HKEY_CLASSES_ROOT); + rkey.create(key)[valueName] = value; + } + + template + void reghelper_t::addkey(const tstring& key, const tstring& value) + { + regkey rkey(HKEY_CLASSES_ROOT); + rkey.create(key)[_T("")] = value; + } + + template + tstring reghelper_t::StringFromUUID(REFCLSID rclsid) + { + wchar_t *ws; + ::StringFromCLSID(rclsid, &ws); + size_t num_chars = wcslen(ws) + 1; + size_t bytes = num_chars * sizeof (TCHAR); + TCHAR *s = static_cast(_alloca(bytes)); + convert_string(s, bytes, ws); + CoTaskMemFree(ws); + return s; + } + + template + void reghelper_t::updatekey(bool unregister, const tstring &key, const tstring &valueName, const tstring &value) + { + if(unregister) + removekey(key); + else + addkey(key, valueName, value); + } + + template + void reghelper_t::updatekey(bool unregister, const tstring &key, const tstring &value) + { + if(unregister) + removekey(key); + else + addkey(key, value); + } + + template + void reghelper_t::update_coclass(bool unregister, + const CLSID &rclsid, + const TCHAR *filename, + const TCHAR *thread_model, + const TCHAR *coclass_name, + const TCHAR *progid, + unsigned long version, + const GUID &rlibid, + bool inproc_server, + const GUID* /*appid*/) + { + tstring clsid = StringFromUUID(rclsid); + tstring name = _T("CLSID\\") + clsid; + tstring typelib = StringFromUUID(rlibid); + // On WinNT/Win2000, subkeys must be deleted before parent keys. + // Therefore, be sure to specify changes to subkeys before + // changes to parent keys - otherwise the server will not + // cleanly remove all keys when it is unregistered. + if (inproc_server) + { + updatekey(unregister, name + _T("\\InprocServer32"), filename); + updatekey(unregister, name + _T("\\InprocServer32"), _T("ThreadingModel"), thread_model); + } + else + { + updatekey(unregister, name + _T("\\LocalServer32"), filename); + updatekey(unregister, name + _T("\\Programmable"), _T("")); + } + updatekey(unregister, name + _T("\\TypeLib"), typelib); +// updatekey(unregister, name, coclass_name); + + if (progid != 0) + { + tstring prgid(progid); + + if (version != 0) + { + TCHAR buffer[35]; +#if _MSC_VER >= 1400 + _ultot_s(version, buffer, 35, 10); + tstring prgid_ver(prgid + _T(".") + buffer); +#else + tstring prgid_ver(prgid + _T(".") + _ultot(version, buffer, 10)); +#endif + + updatekey(unregister, name + _T("\\ProgID"), prgid_ver); + updatekey(unregister, prgid + _T("\\CurVer"), prgid_ver); + updatekey(unregister, prgid_ver + _T("\\CLSID"), clsid); + updatekey(unregister, prgid_ver, coclass_name); + } + else + { + updatekey(unregister, name + _T("\\ProgID"), prgid); + } + + updatekey(unregister, prgid + _T("\\CLSID"), clsid); + updatekey(unregister, prgid, coclass_name); + } + + updatekey(unregister, name, coclass_name); + +// if (progid != 0) { +// updatekey(unregister, name + _T("\\ProgID"), progid); +// updatekey(unregister, tstring(progid) + _T("\\CLSID"), clsid); +// updatekey(unregister, progid, coclass_name); +// } + } + + typedef reghelper_t reghelper; + +#ifndef COMET_PARTIAL_SPECIALISATION + + template + struct entry_builder; + + template struct THE_FOLLOWING_COCLASS_HAS_NOT_BEEN_IMPLEMENTED; + template<> struct THE_FOLLOWING_COCLASS_HAS_NOT_BEEN_IMPLEMENTED {}; + + template<> struct entry_builder + { + template + struct registration + { + COMET_FORCEINLINE static void perform(const TCHAR*, bool, bool, const GUID* ) + { +#ifndef COMET_ALLOW_UNIMPLEMENTED_COCLASSES + THE_FOLLOWING_COCLASS_HAS_NOT_BEEN_IMPLEMENTED x; +#endif + } + }; + + template + struct factory + { + COMET_FORCEINLINE static ::IUnknown* get(const CLSID&) + { + return 0; + } + }; + }; // entry_builder + + template<> struct entry_builder + { + template + struct registration + { + static void perform(const TCHAR *filename, bool unregister, bool inproc_server, const GUID* appid) + { + if(unregister) { + try { + custom_registration().on_unregister(filename); + } + catch(...) + { + + } + } + + reghelper::update_coclass(unregister, + uuidof(), + filename, + tm_properties::thread_model>::string(), + CLASS::name(), + coclass_implementation::get_progid(), + CLASS::major_version, + uuidof(), + inproc_server, + appid); + + if(!unregister) + custom_registration().on_register(filename); + } // perform + }; // registration + + + template + struct factory_builder { }; + + template<> struct factory_builder + { + template + struct factory + { + typedef class_factory is_factory; + }; + }; + template<> struct factory_builder + { + template + struct factory + { + typedef class_factory_agg is_factory; + }; + }; + template<> struct factory_builder + { + template + struct factory + { + typedef class_factory_singleton is_factory; + }; + }; + + template + struct factory_type + { + typedef COMET_STRICT_TYPENAME factory_builder< CLASS::factory_type >::factory::is_factory factory; + }; + template + struct factory + { + typedef typename factory_type< coclass_implementation, LOCK_MODULE >::factory CLASS_FACTORY; + + COMET_FORCEINLINE static ::IUnknown* get(const CLSID& clsid) + { + static CLASS_FACTORY class_factory_; + + // NB: This might cause problems if CLASS_FACTORY + // implemented more than one interface. If so, this logic will + // have to be changed to inline the QueryInterface call instead. + if (clsid == uuidof()) + return &class_factory_; + return 0; + } // get + }; // factory + }; // entry_builder + + template + struct coclass_table_entry + { + // We use sizeof here to determine if there is a specialization of coclass_implementation. + // It is relying on the fact that any real implementation of coclass_implementation + // must be at least sizeof IUnknown, whereas the default sizeof implementation + // is always just a dummy class. + enum { is_undefined = sizeof (coclass_implementation) == sizeof( coclass_implementation) }; + + typedef typename entry_builder::factory factory; + typedef typename entry_builder::registration registration; + }; + +#else // COMET_PARTIAL_SPECIALISATION + template + struct entry_builder + { + typedef nil factory; + typedef nil registration; + }; + + template struct entry_builder + { + struct registration + { + COMET_FORCEINLINE static void perform(const TCHAR*, bool, bool, const GUID* ) {} + }; + + struct factory + { + COMET_FORCEINLINE static ::IUnknown* get(const CLSID&) + { + return 0; + } + }; + }; // entry_builder + + template + struct factory_builder_aux { }; + + template struct factory_builder_aux + { + typedef class_factory is_factory; + }; + template struct factory_builder_aux + { + typedef class_factory_agg is_factory; + }; + template struct factory_builder_aux + { + typedef class_factory_singleton is_factory; + }; + + + template struct entry_builder + { + struct registration + { + static void perform(const TCHAR *filename, bool unregister, bool inproc_server, const GUID* appid) + { + if(unregister) { + try { + custom_registration().on_unregister(filename); + } catch(...) {} + } + + reghelper::update_coclass(unregister, + uuidof(), + filename, + tm_properties::thread_model>::string(), + CLASS::name(), + coclass_implementation::get_progid(), + CLASS::major_version, + uuidof(), + inproc_server, + appid); + + if(!unregister) + custom_registration().on_register(filename); + } // perform + }; // registration + + struct factory_type + { + enum {type_ = coclass_implementation::factory_type }; + typedef typename factory_builder_aux< type_, coclass_implementation, FACTORY_LOCK_MODULE >::is_factory factory; + }; + struct factory + { + typedef typename factory_type::factory CLASS_FACTORY; + + COMET_FORCEINLINE static ::IUnknown* get(const CLSID& clsid) + { + static CLASS_FACTORY class_factory_; + + // NB: This might cause problems if CLASS_FACTORY + // implemented more than one interface. If so, this logic will + // have to be changed to inline the QueryInterface call instead. + if (clsid == uuidof()) + return &class_factory_; + return 0; + } // get + }; // factory + }; // entry_builder + + template + struct coclass_table_entry + { + // We use sizeof here to determine if there is a specialization of coclass_implementation. + // It is relying on the fact that any real implementation of coclass_implementation + // must be at least sizeof IUnknown, whereas the default sizeof implementation + // is always just a dummy class. + enum { is_undefined = (sizeof(coclass_implementation) == sizeof(coclass_implementation)) }; + + typedef typename entry_builder::factory factory; + typedef typename entry_builder::registration registration; + }; +#endif // COMET_PARTIAL_SPECIALISATION + + } // namespace impl + + /*! \addtogroup Server + */ + //@{ + template + class coclass_table + { + public: + COMET_FORCEINLINE static ::IUnknown* find(const CLSID& clsid) + { + ::IUnknown *ret = impl::coclass_table_entry::factory::get(clsid); + return ret ? ret : coclass_table::find(clsid); + } + + COMET_FORCEINLINE static void registration(const TCHAR* filename, bool unregister, bool inproc_server = true, const GUID* appid = 0) + { + impl::coclass_table_entry::registration::perform(filename, unregister, inproc_server, appid); + coclass_table::registration(filename, unregister, inproc_server, appid); + } + }; + + struct coclass_term + { + COMET_FORCEINLINE static ::IUnknown* find(const IID&) + { + return 0; + } + COMET_FORCEINLINE static void registration(const TCHAR*, bool, bool = true, const GUID* = 0) {} + }; + +// template<> class coclass_table > : public coclass_term {}; + template<> class coclass_table : public coclass_term {}; + template<> class coclass_table : public coclass_term {}; + + enum { NO_EMBEDDED_TLB = 1}; + + template + struct com_server_traits { + enum { flags = FL }; + enum { embedded_tlb = !(flags & NO_EMBEDDED_TLB) }; + }; + /** Main COM DLL module implementation. + * Called my the COMET_DECLARE_DLL_FUNCTIONS macro - provides implementation + * for the DLL entry points. + * \sa COMET_DECLARE_DLL_FUNCTIONS + */ + template > class com_server + { + typedef coclass_table COCLASS_TABLE; + public: + static BOOL WINAPI DllMain(HINSTANCE hInstance, DWORD dwReason, LPVOID); + static HRESULT DllCanUnloadNow(); + static HRESULT DllGetClassObject(REFCLSID rclsid, REFIID riid, LPVOID* ppv); + static HRESULT DllRegisterServer(); + static HRESULT DllUnregisterServer(); + }; + //@} + template + BOOL WINAPI com_server::DllMain(HINSTANCE hInstance, DWORD dwReason, LPVOID) + { + if (dwReason == DLL_PROCESS_ATTACH) + { + module().instance(hInstance); + DisableThreadLibraryCalls(hInstance); + + // initialize static variables in factory::get to avoid potential thread safety problem. + ::IUnknown* cf = COCLASS_TABLE::find(IID_NULL); + /* prevent warning */ cf; + } + else if (dwReason == DLL_PROCESS_DETACH) + { + module().shutdown(); + } + return TRUE; + } + + template + HRESULT com_server::DllCanUnloadNow() + { + return module().rc() == 0 ? S_OK : S_FALSE; + } + + template + HRESULT com_server::DllGetClassObject(REFCLSID rclsid, REFIID riid, LPVOID* ppv) + { + ::IUnknown* cf = COCLASS_TABLE::find(rclsid); + if (cf == 0) return CLASS_E_CLASSNOTAVAILABLE; + + return cf->QueryInterface(riid, ppv); + } + + namespace impl { + template + struct typelibrary_registration + { + static void convert(wchar_t *dest, const char *src) + { + size_t cs = 0; +#if _MSC_VER >=1400 + ::mbstowcs_s(&cs, dest, MAX_PATH, src, MAX_PATH); +#else + cs = ::mbstowcs(dest,src, MAX_PATH); +#endif + } + static void convert(wchar_t *dest, const wchar_t *src) + { +#if _MSC_VER >= 1400 + ::wcscpy_s(dest, MAX_PATH, src); +#else + ::wcscpy(dest, src); +#endif + } + static HRESULT perform(const TCHAR *filename, bool unregister) throw() + { + wchar_t wfilename[MAX_PATH]; + convert(wfilename, filename); + ITypeLib* tl; + HRESULT hr = LoadTypeLib(wfilename, &tl); + if (SUCCEEDED(hr)) { + if(unregister) { + TLIBATTR *tla = 0; + hr = tl->GetLibAttr(&tla); + if (SUCCEEDED(hr)) { + hr = UnRegisterTypeLib(tla->guid, tla->wMajorVerNum, tla->wMinorVerNum, tla->lcid, tla->syskind); + tl->ReleaseTLibAttr(tla); + } + } + else + hr = RegisterTypeLib(tl, wfilename, 0); + tl->Release(); + } + return hr; + } + }; + + template<> struct typelibrary_registration<0> + { + COMET_FORCEINLINE static HRESULT perform(const TCHAR *, bool) + { + return S_OK; + } + }; + } // namespace impl + + template + HRESULT com_server::DllRegisterServer() + { + TCHAR filename[MAX_PATH]; + + GetModuleFileName(module().instance(), filename, MAX_PATH); + + { + HRESULT hr = impl::typelibrary_registration::perform(filename, false); + if(FAILED(hr)) return SELFREG_E_TYPELIB; + } + + try { + COCLASS_TABLE::registration(filename, false); + } + catch (const com_error &e) + { + DllUnregisterServer(); + return impl::return_com_error(e); + } + catch (const std::exception &e) + { + DllUnregisterServer(); + ::OutputDebugStringA(e.what()); + return E_FAIL; + } + + return S_OK; + } + + template + HRESULT com_server::DllUnregisterServer() + { + TCHAR filename[MAX_PATH]; + GetModuleFileName(module().instance(), filename, MAX_PATH); + + impl::typelibrary_registration::perform(filename, true); + + COCLASS_TABLE::registration(filename, true); + return S_OK; + } +/** Declares the DLL Functions and passes them through to \a SERVER static + * functions. + * \sa com_server + */ + +#define COMET_DECLARE_DLL_FUNCTIONS(SERVER) \ +extern "C" BOOL WINAPI DllMain(HINSTANCE hInstance, DWORD dwReason, LPVOID) \ +{ \ + return SERVER::DllMain(hInstance, dwReason, 0); \ +} \ + \ +STDAPI DllCanUnloadNow() \ +{ \ + return SERVER::DllCanUnloadNow(); \ +} \ + \ +STDAPI DllGetClassObject(REFCLSID rclsid, REFIID riid, LPVOID* ppv) \ +{ \ + return SERVER::DllGetClassObject(rclsid, riid, ppv); \ +} \ + \ +STDAPI DllRegisterServer() \ +{ \ + return SERVER::DllRegisterServer(); \ +} \ + \ +STDAPI DllUnregisterServer() \ +{ \ + return SERVER::DllUnregisterServer(); \ +} + +} + +#endif diff --git a/EyeTab_SP2/comet/smart_enum.h b/EyeTab_SP2/comet/smart_enum.h new file mode 100644 index 0000000..c45f53b --- /dev/null +++ b/EyeTab_SP2/comet/smart_enum.h @@ -0,0 +1,139 @@ +/** \file + * _NewEnum style COM enumerator backed by a smart pointer to items. + */ +/* + * Copyright © 2010 Alexander Lamaison + * + * This material is provided "as is", with absolutely no warranty + * expressed or implied. Any use is at your own risk. Permission to + * use or copy this software for any purpose is hereby granted without + * fee, provided the above notices are retained on all copies. + * Permission to modify the code and to distribute modified code is + * granted, provided the above notices are retained, and a notice that + * the code was modified is included with the above copyright notice. + * + * This header is part of Comet version 2. + * https://github.com/alamaison/comet + */ + +#ifndef COMET_SMART_ENUM_H +#define COMET_SMART_ENUM_H + +#include + +#include +#include + +namespace comet { + + namespace impl { + + template + class smart_enum_source + { + public: + typedef typename SmartPtr::element_type::const_iterator + const_iterator; + + explicit smart_enum_source(SmartPtr source) + : source_(source), it_(begin()) {} + + const_iterator begin() + { + return source_->begin(); + } + + const_iterator end() + { + return source_->end(); + } + + const_iterator& current() + { + return it_; + } + + private: + SmartPtr source_; + const_iterator it_; + }; + + } + + /** + * Implements _NewEnum style COM object on top of smart pointer to + * a collection. + * \param Itf Enumeration Interface. + * \param C STL Style container. + * \param T Iteration Element type + * \param CONVERTER Converts container element to \p T type. (std::identity) + * \sa stl_enumeration create_enum + */ + template< + typename Itf, typename SmartPtr, typename T, + typename CONVERTER=std::identity< + COMET_STRICT_TYPENAME SmartPtr::element_type::value_type> > + class smart_enumeration : + public impl::enumeration< + Itf, T, CONVERTER, impl::smart_enum_source > + { + public: + smart_enumeration( + SmartPtr container, const CONVERTER& converter=CONVERTER()) + : enumeration( + impl::smart_enum_source(container), converter) {} + + private: + smart_enumeration(const smart_enumeration&); + smart_enumeration& operator=(const smart_enumeration&); + }; + + /** + * Smart Enumeration creation helper. + * + * Creates the enumeration with the element type specified by the + * enumerated_type_of policy. To specify the element type explicitly, use + * smart_enumeration directly. + * + * \tparam ET Enumeration Type e.g. IEnumUnknown. + * \tparam SmartPtr Smart pointer (inferred from @a container parameter). + * + * \param container Smart pointer to an STL collection + * e.g. auto_ptr. + */ + template + inline com_ptr make_smart_enumeration(SmartPtr container) + { + typedef typename enumerated_type_of::is T; + typedef std::identity< + COMET_STRICT_TYPENAME SmartPtr::element_type::value_type> + CONVERTER; + return new smart_enumeration(container); + } + + /** + * Smart Enumeration creation helper with custom converter. + * + * Creates the enumeration with the element type specified by the + * enumerated_type_of policy. To specify the element type explicitly, use + * smart_enumeration directly. + * + * \tparam ET Enumeration Type e.g. IEnumUnknown. + * \tparam SmartPtr Smart pointer (inferred from @a container parameter). + * \tparam CONVERTER Converter type (inferred from @a converter). + * + * \param container Smart pointer to an STL collection + * e.g. auto_ptr. + * \param converter Custom converter. + */ + template + inline com_ptr make_smart_enumeration( + SmartPtr container, const CONVERTER& converter) + { + typedef typename enumerated_type_of::is T; + return new smart_enumeration( + container, converter); + } +} + +#endif diff --git a/EyeTab_SP2/comet/static_assert.h b/EyeTab_SP2/comet/static_assert.h new file mode 100644 index 0000000..b0bfe44 --- /dev/null +++ b/EyeTab_SP2/comet/static_assert.h @@ -0,0 +1,54 @@ +/** \file + Provide compile-time asserts. + See www.boost.org for most recent version including documentation. + \author John Maddock + */ +/* + * Copyright © 2000, 2001 Sofus Mortensen + * + * This material is provided "as is", with absolutely no warranty + * expressed or implied. Any use is at your own risk. Permission to + * use or copy this software for any purpose is hereby granted without + * fee, provided the above notices are retained on all copies. + * Permission to modify the code and to distribute modified code is + * granted, provided the above notices are retained, and a notice that + * the code was modified is included with the above copyright notice. + * + * This header is part of Comet version 2. + * https://github.com/alamaison/comet + */ + +#ifndef COMET_STATIC_ASSERT_H +#define COMET_STATIC_ASSERT_H + +#include + +// (C) Copyright John Maddock 2000. +// Permission to copy, use, modify, sell and +// distribute this software is granted provided this copyright notice appears +// in all copies. This software is provided "as is" without express or implied +// warranty, and with no claim as to its suitability for any purpose. + +// See http://www.boost.org for most recent version including documentation. + +/* + Revision history: + 02 August 2000 + Initial version. +*/ + +namespace comet { + namespace impl { + + template struct COMPILE_TIME_ASSERTION_FAILURE; + + template <> struct COMPILE_TIME_ASSERTION_FAILURE{}; + + template struct ct_assert_test{}; + + } +} + +#define COMET_STATIC_ASSERT( B ) typedef ::comet::impl::ct_assert_test)> comet_static_assert_typedef_ + +#endif diff --git a/EyeTab_SP2/comet/stl.h b/EyeTab_SP2/comet/stl.h new file mode 100644 index 0000000..a6ac7c0 --- /dev/null +++ b/EyeTab_SP2/comet/stl.h @@ -0,0 +1,69 @@ +/** \file + Provide STL extensions. + */ +/* + * Copyright © 2001 Sofus Mortensen + * Copyright © 2013 Alexander Lamaison + * + * This material is provided "as is", with absolutely no warranty + * expressed or implied. Any use is at your own risk. Permission to + * use or copy this software for any purpose is hereby granted without + * fee, provided the above notices are retained on all copies. + * Permission to modify the code and to distribute modified code is + * granted, provided the above notices are retained, and a notice that + * the code was modified is included with the above copyright notice. + * + * This header is part of Comet version 2. + * https://github.com/alamaison/comet + */ + +#ifndef COMET_STL_H +#define COMET_STL_H + +#include + +#include + +// add identity, select1st, and select2nd. +#if !defined(__SGI_STL_PORT) && !defined(__MINGW32__) +namespace std { + /** \internal + */ + template struct identity : public unary_function { + T operator()(const T& t) { return t; } + }; + + /** \internal + */ + template struct select1st : public unary_function { + typename T::first_type operator()(const T& t) { return t.first; } + }; + + /** \internal + */ + template struct select2nd : public unary_function { + typename T::second_type operator()(const T& t) { return t.second; } + }; +} +#else +#include +#endif + +template class delete_fun : public std::unary_function { + public: + void operator()(T& x) { delete x; } +}; + +template class delete2nd_fun : public std::unary_function { + public: + void operator()(T& x) { delete x.second; } +}; + +template class delete1st_fun : public std::unary_function { + public: + void operator()(T& x) { delete x.first; } +}; + + + +#endif diff --git a/EyeTab_SP2/comet/stl_enum.h b/EyeTab_SP2/comet/stl_enum.h new file mode 100644 index 0000000..7537b2d --- /dev/null +++ b/EyeTab_SP2/comet/stl_enum.h @@ -0,0 +1,188 @@ +/** \file + * Implement _NewEnum style classes and iterators. + */ +/* + * Copyright © 2000 Sofus Mortensen + * + * This material is provided "as is", with absolutely no warranty + * expressed or implied. Any use is at your own risk. Permission to + * use or copy this software for any purpose is hereby granted without + * fee, provided the above notices are retained on all copies. + * Permission to modify the code and to distribute modified code is + * granted, provided the above notices are retained, and a notice that + * the code was modified is included with the above copyright notice. + * + * This header is part of Comet version 2. + * https://github.com/alamaison/comet + */ + +#ifndef COMET_STL_ENUM_H +#define COMET_STL_ENUM_H + +#include + +#include +#include +#include +#include + +namespace comet { + + namespace impl { + + template + class stl_enum_source + { + public: + typedef typename Collection::const_iterator const_iterator; + + explicit stl_enum_source( + const Collection& container, com_ptr outer) + : outer_(outer), container_(container), it_(begin()) {} + + const_iterator begin() + { + return container_.begin(); + } + + const_iterator end() + { + return container_.end(); + } + + const_iterator& current() + { + return it_; + } + + private: + + // Not copy-assignable + stl_enum_source& operator=(const stl_enum_source&); + + com_ptr outer_; + const Collection& container_; + const_iterator it_; + }; + + } + + /** \class stl_enumeration_t enum.h comet/enum.h + * Implements _NewEnum style COM object. + * \param Itf Enumeration Interface. + * \param C STL Style container. + * \param T Iteration Element type (VARIANT) + * \param CONVERTER Converts container element to \p T type. (std::identity) + * \sa stl_enumeration create_enum + */ + template< + typename Itf, typename C, typename T=VARIANT, + typename CONVERTER=std::identity, + typename TH=::IUnknown> + class stl_enumeration_t : + public impl::enumeration< + Itf, T, CONVERTER, impl::stl_enum_source > + { + public: + + stl_enumeration_t( + const C& container, TH* outer=0, + const CONVERTER& converter=CONVERTER()) + : enumeration( + impl::stl_enum_source(container, outer), converter) {} + + private: + stl_enumeration_t(const stl_enumeration_t&); + stl_enumeration_t& operator=(const stl_enumeration_t&); + }; + + /** + * STL Enumeration creation helper. + * + * Creates the enumeration with the element type specified by the + * enumerated_type_of policy. To specify the element type directly, use + * stl_enumeration_t. + * + * \param ET Enumeration Type e.g. IEnumUnknown. + */ + template + struct stl_enumeration + { + + /** Auto-Create a _NewEnum enumerator from an STL container. + * No contained object. + * \param container STL Container. + */ + template + static com_ptr create(const C& container) + { + typedef typename enumerated_type_of::is T; + typedef std::identity + CONVERTER; + return new stl_enumeration_t( + container, 0); + } + + /** Auto-Create a _NewEnum enumerator from an STL container. + * \param container STL Container. + * \param th Outer or \e this pointer. + */ + template + static com_ptr create(const C& container, TH* th) + { + typedef typename enumerated_type_of::is T; + typedef std::identity + CONVERTER; + return new stl_enumeration_t( + container, th); + } + + /** Auto-Create a _NewEnum enumerator from an STL container, specifying + * a converter. + * \param container STL Container. + * \param th Outer or \e this pointer. + * \param converter Converter type (convert Container element to + * iterator interface element types). + */ + template + static com_ptr create( + const C& container, TH* th, const CONVERTER& converter) + { + typedef typename enumerated_type_of::is T; + return new stl_enumeration_t( + container, th, converter); + } + }; + + /*! Creates IEnumVARIANT enumeration of a STL container. + * \param container STL Container. + * \param th Outer or \e this pointer. + \code + com_ptr get__NewEnum() { + return create_enum( collection_, this ); + } + \endcode + * \relates stl_enumeration + */ + template + com_ptr create_enum(const C& container, TH* th = 0) + { + return stl_enumeration::create(container, th); + } + + //! Creates IEnumVARIANT enumeration of a STL container with a converter. + /*! \param container STL Container. + * \param th Outer or \e this pointer. + * \param converter Converter type (convert Container element to VARIANT) + * \sa ptr_converter ptr_converter_select1st ptr_converter_select2nd + * \relates stl_enumeration + */ + template + com_ptr create_enum(const C& container, TH* th, CONVERTER converter) + { + return stl_enumeration::create(container, th, converter); + } + +} + +#endif diff --git a/EyeTab_SP2/comet/stream.h b/EyeTab_SP2/comet/stream.h new file mode 100644 index 0000000..7d91c43 --- /dev/null +++ b/EyeTab_SP2/comet/stream.h @@ -0,0 +1,1566 @@ +/** \file + * IStream adapters. + */ +/* + * Copyright (C) 2013 Alexander Lamaison + * + * This material is provided "as is", with absolutely no warranty + * expressed or implied. Any use is at your own risk. Permission to + * use or copy this software for any purpose is hereby granted without + * fee, provided the above notices are retained on all copies. + * Permission to modify the code and to distribute modified code is + * granted, provided the above notices are retained, and a notice that + * the code was modified is included with the above copyright notice. + * + * This header is part of Comet version 2. + * https://github.com/alamaison/comet + */ + +#ifndef COMET_STREAM_H +#define COMET_STREAM_H + +#include + +#include // bstr_t +#include // com_error +#include // COMET_CATCH_CLASS_INTERFACE_BOUNDARY +#include // simple_object + +#include // assert +#include +#include // numeric_limits +#include + +#include // StringCbCopyW + +namespace comet { + +namespace impl { + + static const size_t COPY_CHUNK_SIZE = 512; + + /** + * Used to clear stream failure on exiting a scope. + * + * Useful when trying an operation and converting any failure to an + * exception. In that case there is no need for the stream object to + * also retain evidence of the failure. + * + * Note, only clears `failbit`. `eofbit` is left alone as it is a + * valid consequence of operations performed by the wrapper. `badbit` is + * also left as these errors are unrecoverable and therefore the + * stream is as good as dead; a caller of the unwrapped stream needs + * to know that. + */ + template + class stream_failure_cleanser + { + public: + explicit stream_failure_cleanser(Stream& stream) + : m_stream(stream) + {} + + ~stream_failure_cleanser() throw() + { + try + { + m_stream.clear(m_stream.rdstate() & ~std::ios_base::failbit); + } + catch (const std::exception&) + {} + } + + private: + stream_failure_cleanser(const stream_failure_cleanser&); + stream_failure_cleanser& operator=(const stream_failure_cleanser&); + + Stream& m_stream; + }; + + // These do_read/write helper functions dispatch the stream-type specific code + // so that we only need one class to implement all the stream adapters + + inline void do_istream_read( + std::istream& stream, void* buffer, ULONG buffer_size_in_bytes, + ULONG& bytes_read_out) + { + typedef std::istream stream_type; + + // + // IMPORTANT: The bytes_read_out count must be correct even in the + // error case, EVEN if that error is an exception, because the caller + // can treat an error as EOF (see Read method docs). + // + // However, in the error case it is acceptable to make the read count + // smaller than the actual number of bytes read (e.g. 0) because the + // caller is losing the unread part of the stream anyway. Losing a few + // extra bytes that are already in the buffer but not declared valid + // by the byte count will not make the situation worse. + + bytes_read_out = 0U; + + stream.read( + reinterpret_cast(buffer), + buffer_size_in_bytes / sizeof(std::istream::char_type)); + + // Any failure not caused by eof is a failure. + // Badbit is always a failure because, even if we are at eof, the stream + // encountered a problem that needs reporting. + if (stream.bad() || (stream.fail() && !stream.eof())) + { + throw std::runtime_error("Reading from stream failed"); + } + else + { + if (stream.gcount() >= 0 && + // temp conversion to unsigned larger than ULONG to catch + // values larger than ULONG + static_cast(stream.gcount()) < + (std::numeric_limits::max)() / + sizeof(std::istream::char_type)) + { + bytes_read_out = static_cast( + stream.gcount() * sizeof(std::istream::char_type)); + } + + assert(stream.eof() || bytes_read_out == buffer_size_in_bytes); + } + } + + inline void do_ostream_write( + std::ostream& stream, const void* buffer, ULONG buffer_size_in_bytes, + ULONG& bytes_written_out) + { + // If there is an error we cannot get a reliable write count, even + // if we were to use stream.rdbuf()->sputn, because the failure + // might well happen during the flush operation which doesn't let + // us find out how much was flushed before failing. + + typedef std::ostream stream_type; + + bytes_written_out = 0U; + + stream.write( + reinterpret_cast(buffer), + buffer_size_in_bytes / sizeof(std::ostream::char_type)); + + try + { + stream.flush(); + } + catch (const std::exception& e) + { + throw com_error(e.what(), STG_E_MEDIUMFULL); + } + + if (stream.good()) + { + bytes_written_out = buffer_size_in_bytes; + } + else + { + throw com_error("Writing to stream failed", STG_E_MEDIUMFULL); + } + } + + /** Ensure read position updated even in case of exception */ + template + class read_position_finaliser + { + public: + read_position_finaliser( + Stream& stream, std::streampos& new_position_out) + : m_stream(stream), m_new_position_out(new_position_out) + {} + + ~read_position_finaliser() throw() + { + try + { + // we still want the read position if previous op failed + m_stream.clear(); + + std::streampos new_position = m_stream.tellg(); + if (m_stream) + { + m_new_position_out = new_position; + } + else + { + m_new_position_out = std::streampos(); + } + } + catch (...) + { + // We tried. Nothing else we can do + // + // We likely ended up here in the exception unwinding of a + // failed seek because a non-seekable stream chose to let us + // know by throwing an exception from the streambuf + // (e.g. Boost.IOStream). Non-seekable is also non-tellable so + // telgp does the same thing. + // + // We have prevent this exception propagating else we get an + // thrown while unwinding another exception causing terminate() + m_new_position_out = std::streampos(-1); + } + } + + private: + + read_position_finaliser(const read_position_finaliser&); + read_position_finaliser& operator=(const read_position_finaliser&); + + Stream& m_stream; + std::streampos& m_new_position_out; + }; + + /** Ensure write position updated even in case of exception */ + template + class write_position_finaliser + { + public: + write_position_finaliser( + Stream& stream, std::streampos& new_position_out) + : m_stream(stream), m_new_position_out(new_position_out) + {} + + ~write_position_finaliser() throw() + { + try + { + // we still want the write position if previous op failed + m_stream.clear(); + + std::streampos new_position = m_stream.tellp(); + if (m_stream) + { + m_new_position_out = new_position; + } + else + { + m_new_position_out = std::streampos(); + } + } + catch (...) + { + // We tried. Nothing else we can do + // + // We likely ended up here in the exception unwinding of a + // failed seek because a non-seekable stream chose to let us + // know by throwing an exception from the streambuf + // (e.g. Boost.IOStream). Non-seekable is also non-tellable so + // tellp does the same thing. + // + // We have prevent this exception propagating else we get an + // thrown while unwinding another exception causing terminate() + m_new_position_out = std::streampos(-1); + } + } + + private: + write_position_finaliser(const write_position_finaliser&); + write_position_finaliser& operator=(const write_position_finaliser&); + + Stream& m_stream; + std::streampos& m_new_position_out; + }; + + /** + * Copies `streampos` out-parameter to ULARGE_INTEGER out parameter + * in the face of exceptions. + * + * Using this class means you can concentrate on keeping the `streampos` + * variable updated, confident in the knowledge the the COM-interface + * ULARGE_INTEGER parameter will eventually be updated to match it, + * no matter what. + * + * Assumes that the source out parameter is guaranteed to be valid at + * all times. Valid doesn't necessarily mean correct but that it always + * contains the value we want to set the out parameter to, even if that is + * wrong (for instance failure while calculating correct position). + */ + class position_out_converter + { + public: + + position_out_converter( + std::streampos& source_out_parameter, + ULARGE_INTEGER* destination_out_parameter) + : + m_source(source_out_parameter), + m_destination(destination_out_parameter) {} + + ~position_out_converter() + { + if (m_destination) + { + try + { + // Convert to streamoff because streampos may not + // be an integer. streamoff is guaranteed to be. + std::streamoff offset_from_beginning = m_source; + if (offset_from_beginning < 0) + { + // Invalid offset, for example seeking not supported + // The error itself is dealt with right after seeking + // so this class just has to convert it to something + // reasonable for an unsigned value + m_destination->QuadPart = 0U; + } + else + { + m_destination->QuadPart = offset_from_beginning; + } + } + catch(const std::exception&) + { + // Only way this can happen is if streampos refuses to + // convert to streamoff in which case we really are screwed. + m_destination->QuadPart = 0U; + } + } + } + + private: + position_out_converter(const position_out_converter&); + position_out_converter& operator=(const position_out_converter&); + + std::streampos& m_source; + ULARGE_INTEGER* m_destination; + }; + + /** + * Increments a total counter with an increment are end of scope, + * regardless of how that scope is ended. + * + * Assumes the increment parameter is valid at all times. + */ + class byte_count_incrementer + { + public: + byte_count_incrementer( + ULARGE_INTEGER* total, ULONG& increment) + : m_total(total), m_increment(increment) {} + + ~byte_count_incrementer() + { + if (m_total) + { + m_total->QuadPart += m_increment; + } + } + + private: + + byte_count_incrementer(const byte_count_incrementer&); + byte_count_incrementer& operator=(const byte_count_incrementer&); + + ULARGE_INTEGER* m_total; + ULONG& m_increment; + }; + + template + class position_resetter + { + public: + position_resetter(StreamTraits& traits, std::streampos position) + : + m_traits(traits), m_position(position) {} + + ~position_resetter() + { + try + { + std::streampos new_position; + m_traits.do_seek( + m_position, std::ios_base::beg, new_position); + + assert(new_position == m_position); + } + catch (const std::exception&) + {} + } + + private: + position_resetter(const position_resetter&); + position_resetter& operator=(const position_resetter&); + + StreamTraits& m_traits; + std::streampos m_position; + }; + + /** + * Calculate offset of end of stream from start. + */ + template + inline std::streamoff stream_size(StreamTraits& traits) + { + position_resetter(traits, traits.do_tell()); + + std::streampos new_position; + traits.do_seek(0, std::ios_base::end, new_position); + + return new_position; + } + + template + class stream_traits; + + template + class stream_traits + { + public: + explicit stream_traits(Stream& stream) : m_stream(stream) {} + + void do_read( + void* buffer, ULONG buffer_size_in_bytes, + ULONG& bytes_read_out) + { + do_istream_read( + m_stream, buffer, buffer_size_in_bytes, bytes_read_out); + } + + void do_write( + const void* /*buffer*/, + ULONG /*buffer_size_in_bytes*/, ULONG& bytes_written_out) + { + bytes_written_out = 0U; + throw com_error( + "std::istream does not support writing", STG_E_ACCESSDENIED); + } + + void do_seek( + std::streamoff offset, std::ios_base::seekdir way, + std::streampos& new_position_out) + { + read_position_finaliser position_out_updater( + m_stream, new_position_out); + + if (!m_stream.seekg(offset, way)) + { + throw std::runtime_error("Unable to change read position"); + } + } + + std::streampos do_tell() + { + std::streampos pos = m_stream.tellg(); + if (!m_stream) + { + throw std::runtime_error("Stream position unavailable"); + } + + return pos; + } + + void do_flush() + { + throw com_error( + "std::istream does not support committing data", + STG_E_ACCESSDENIED); + } + + private: + stream_traits(const stream_traits&); + stream_traits& operator=(const stream_traits&); + + Stream& m_stream; + }; + + template + class stream_traits + { + public: + explicit stream_traits(Stream& stream) : m_stream(stream) {} + + void do_read( + void* /*buffer*/, + ULONG /*buffer_size_in_bytes*/, ULONG& bytes_read_out) + { + bytes_read_out = 0U; + throw com_error( + "std::ostream does not support reading", STG_E_ACCESSDENIED); + } + + void do_write( + const void* buffer, + ULONG buffer_size_in_bytes, ULONG& bytes_written_out) + { + do_ostream_write( + m_stream, buffer, buffer_size_in_bytes, bytes_written_out); + } + + void do_seek( + std::streamoff offset, std::ios_base::seekdir way, + std::streampos& new_position_out) + { + write_position_finaliser position_out_updater( + m_stream, new_position_out); + + if (!m_stream.seekp(offset, way)) + { + throw std::runtime_error("Unable to change write position"); + } + } + + std::streampos do_tell() + { + std::streampos pos = m_stream.tellp(); + if (!m_stream) + { + throw std::runtime_error("Stream position unavailable"); + } + + return pos; + } + + void do_flush() + { + if (!m_stream.flush()) + { + throw std::runtime_error( + "Unable to flush buffer to output sequence"); + } + } + + private: + stream_traits(const stream_traits&); + stream_traits& operator=(const stream_traits&); + + Stream& m_stream; + }; + + template + class stream_traits + { + private: + + enum last_stream_operation + { + read, + write + }; + + public: + explicit stream_traits(Stream& stream) + : m_stream(stream), m_last_op(read) {} + + void do_read( + void* buffer, ULONG buffer_size_in_bytes, ULONG& bytes_read_out) + { + bytes_read_out = 0U; + + // sync reading position with writing position, which was the last + // one used and is allowed to be different in C++ streams but + // not COM IStreams + if (m_last_op == write) + { + m_stream.seekg(m_stream.tellp()); + // We ignore errors syncing the positions as even iostreams may + // not be seekable at all + + m_last_op = read; + } + assert(m_last_op == read); + + do_istream_read( + m_stream, buffer, buffer_size_in_bytes, bytes_read_out); + } + + void do_write( + const void* buffer, ULONG buffer_size_in_bytes, + ULONG& bytes_written_out) + { + bytes_written_out = 0U; + + // sync writing position with reading position, which was the last + // one used and is allowed to be different in C++ streams but + // not COM IStreams + if (m_last_op == read) + { + m_stream.seekp(m_stream.tellg()); + // We ignore errors syncing the positions as even iostreams may + // not be seekable at all + + m_last_op = write; + } + assert(m_last_op == write); + + do_ostream_write( + m_stream, buffer, buffer_size_in_bytes, bytes_written_out); + } + + void do_seek( + std::streamoff offset, std::ios_base::seekdir way, + std::streampos& new_position_out) + { + + // Unlike with do_read/do_write, we do not ignore errors when + // trying to sync the read/write positions as, if the + // first seek succeeded, we know the stream supports + // seeking. Therefore a later error is really an error. + + if (m_last_op == read) + { + read_position_finaliser position_out_updater( + m_stream, new_position_out); + + if (!m_stream.seekg(offset, way)) + { + throw std::runtime_error("Unable to change read position"); + } + else + { + if (!m_stream.seekp(m_stream.tellg())) + { + throw std::runtime_error( + "Unable to synchronise write position"); + } + } + } + else + { + write_position_finaliser position_out_updater( + m_stream, new_position_out); + + if (!m_stream.seekp(offset, way)) + { + throw std::runtime_error("Unable to change write position"); + } + else + { + if (!m_stream.seekg(m_stream.tellp())) + { + throw std::runtime_error( + "Unable to synchronise read position"); + } + } + } + } + + std::streampos do_tell() + { + std::streampos pos; + if (m_last_op == read) + { + pos = m_stream.tellg(); + } + else + { + pos = m_stream.tellp(); + } + + if (!m_stream) + { + throw std::runtime_error("Stream position unavailable"); + } + + return pos; + } + + void do_flush() + { + if (!m_stream.flush()) + { + throw std::runtime_error( + "Unable to flush buffer to output sequence"); + } + } + + private: + stream_traits(const stream_traits&); + stream_traits& operator=(const stream_traits&); + + Stream& m_stream; + last_stream_operation m_last_op; + }; + + /** + * Wrap COM IStream interface around C++ IOStream. + * + * Unlike C++ streams which may have separate read and write positions that + * move independently, COM IStreams assume a single combined read/write head. + * Therefore this wrapper always starts the next read or write operation + * from the where the last operation finished, regardless of whether that + * operation was a call to `Read` or `Write`. + * + * @note This only applies for as long as the read/write positions are + * modified only via this wrapper. If the positions are modified by + * directly on the underlying IOStream, it is undefined whether the + * starting point for the next call to `Read`/`Write` is syncronised + * with the end of the previous operation. + * + * If operations on the inner stream results in failure (the `failbit` + * is set), this is communicated via the COM-interface return code. The + * `failbit` is cleared before the call returns. This allows further + * wrapper methods to be called without having the clear the bit directly + * on the underlying stream. Fatal errors (`badbit`) and end-of-file + * (`eofbit`) are left unchanged and remain visible in the underlying + * stream. + */ + template + class adapted_stream : public simple_object + { + private: + + typedef impl::stream_traits< + Stream, + type_traits::super_sub_class::result, + type_traits::super_sub_class::result + > stream_traits_type; + + public: + + adapted_stream(Stream& stream, const bstr_t& optional_name) + : m_stream(stream), m_traits(stream), + m_optional_name(optional_name) {} + + /** + * Fill the given buffer with data read from the wrapped C++ stream. + * + * @param [in] buffer + * Destination of bytes to be read. + * + * @param [in] buffer_size + * Size of `buffer` and, therefore, the maximum number of bytes + * this method will read. The method may read fewer than this + * number of bytes if the request cannot be fulfilled + * (e.g. end-of-file, error), in which case only the portion of + * `buffer` up to `*read_count_out` bytes from the start + * may be considered valid. + * + * @param [out] read_count_out + * Number of bytes actually read into `buffer`. In other words, + * the extent of the valid bytes in `buffer` once this method + * returns. This value is correct whether the method returns + * success or an error code. + * + * @returns + * Error code indicating the success or failure of the method. + * @retval `S_OK` + * If `buffer` was completely filled. + * @retval `S_FALSE` if EOF reached before `buffer` was filled. + * `*read_count_out` gives the number of bytes that were read. + * @retval a COM error code + * If there was a read error. + * + * Error behaviour rationale + * ------------------------- + * + * MSDN says that, if `read_count_out` < `buffer_size`, callers + * should treat both error codes and success codes as meaning + * the end-of-file was reached. However, doing so means they will be + * unable to distinguish EOF from a genuine read error. Therefore, + * we make the stronger guarantee that only `S_FALSE` means EOF + * while an error code always indicates a read error. + * To accommodate callers who follow the documentation on MSDN, + * we ensure that the read-count out-variable is correct even if the + * wrapped stream encountered an error (`failbit`, `badbit`) or + * threw an exception, because the caller may use the byte-count to + * decide which bytes of the partial read are valid. + * + * In the error case, `*read_count_out` may be less than the number + * of bytes actually read from the wrapped stream. This is for + * performance reasons: unless we read from the wrapped stream one + * byte at a time, there is no way to calculate the the exact number + * of bytes read if an exception is thrown part way through reading. + * Byte-by-byte reading is hopelessly slow for some applications, such + * as an unbuffered stream over a network, so our behaviour is a + * pragmatic compromise. We believe it is within the (vaguely) + * documented behaviour of `IStream` to treat the out-count in this way + * for error cases as the count still delimits a valid region of bytes. + */ + virtual HRESULT STDMETHODCALLTYPE Read( + void* buffer, ULONG buffer_size, ULONG* read_count_out) + { + impl::stream_failure_cleanser state_resetter(m_stream); + + if (read_count_out) + { + *read_count_out = 0U; + } + + try + { + if (!buffer) + { + throw com_error("No buffer given", STG_E_INVALIDPOINTER); + } + + // We use a dummy read count location if one is not given so + // that do_read can keep it updated correctly even if + // do_read throws an exception. + ULONG dummy_read_count = 0U; + if (!read_count_out) + { + read_count_out = &dummy_read_count; + } + + m_traits.do_read(buffer, buffer_size, *read_count_out); + + if (*read_count_out < buffer_size) + { + assert(m_stream.eof()); + + return S_FALSE; + } + else + { + assert(*read_count_out == buffer_size); + assert(m_stream.good()); + return S_OK; + } + } + COMET_CATCH_CLASS_INTERFACE_BOUNDARY("Read", "adapted_stream"); + } + + /** + * Write the given data to the wrapped C++ stream's controlled sequence. + * + * The wrapped stream is flushed before this method returns to ensure + * the data is written to the controlled sequence (and any associated + * errors are detected) rather than just to the stream's buffer. + * Therefore, best performance is obtained if this method is called with + * as much data as possible for the fewest number of flushes. + * + * @param [in] data + * Bytes to write to the controlled sequence. + * + * @param [in] data_size + * Size of `data` and the number of bytes to write. + * + * @param [out] written_count_out + * Number of bytes guaranteed to be written to the controlled + * sequence. This will be `data_size` if writing succeeded. If + * an error occurred, this may be fewer than the actual number of + * bytes written to the sequence. + * + * @returns + * Error code indicating the success or failure of the method. + * @retval `S_OK` + * If `data` was completely written to the wrapped stream's + * controlled sequence. + * @retval a COM error code + * If there was a write error. + * + * Error behaviour rationale + * ------------------------- + * + * If writing succeeds, `*written_count_out` equals `data_size`. If + * writing encountered an error `*written_count_out` will be set to zero, + * even if some bytes were written out. We do this for performance + * reasons: unless we write the data one byte at a time to the wrapped + * stream _and flush the stream after each byte_, the C++ streams don't + * provide a way to count the exact number of bytes written to the + * stream's controlled sequence. Byte-by-byte writing is hopelessly + * slow for some applications, such as a stream over a network, so our + * behaviour is a pragmatic compromise. + * We believe it is within the (vaguely) documented behaviour of + * `IStream` to treat the out-count in this way for error cases. + * It may seem strange that this method even has an out-count if it + * was no intended to be meaningful in the error case (the count would + * be equal to `data_size` in the success case), however we believe + * it was only intended to be meaningful for non-blocking writes to + * asynchronous stream (`E_PENDING` would be returned) which this + * wrapper is not (see http://bit.ly/1hZGy1L). + */ + virtual HRESULT STDMETHODCALLTYPE Write( + const void* data, ULONG data_size, ULONG* written_count_out) + { + stream_failure_cleanser state_resetter(m_stream); + + if (written_count_out) + { + *written_count_out = 0U; + } + + try + { + if (!data) + { + throw com_error("Buffer not given", STG_E_INVALIDPOINTER); + } + + // We use a dummy written count out location if one is not + // given so that do_write can keep it updated correctly even if + // do_write throws an exception. + ULONG dummy_written_count = 0U; + if (!written_count_out) + { + written_count_out = &dummy_written_count; + } + + m_traits.do_write(data, data_size, *written_count_out); + + if (*written_count_out < data_size) + { + throw com_error( + "Unable to complete write operation", STG_E_MEDIUMFULL); + } + else + { + assert(*written_count_out == data_size); + return S_OK; + } + } + COMET_CATCH_CLASS_INTERFACE_BOUNDARY("Write", "adapted_stream"); + } + + virtual HRESULT STDMETHODCALLTYPE Seek( + LARGE_INTEGER offset, DWORD origin, + ULARGE_INTEGER* new_position_out) + { + stream_failure_cleanser state_resetter(m_stream); + + std::streampos new_stream_position_out = std::streampos(); + impl::position_out_converter out_param_guard( + new_stream_position_out, new_position_out); + + try + { + std::ios_base::seekdir way; + if (origin == STREAM_SEEK_CUR) + { + way = std::ios_base::cur; + } + else if (origin == STREAM_SEEK_SET) + { + way = std::ios_base::beg; + } + else if (origin == STREAM_SEEK_END) + { + way = std::ios_base::end; + } + else + { + throw com_error( + "Unrecognised stream seek origin", + STG_E_INVALIDFUNCTION); + } + + if (offset.QuadPart > + (std::numeric_limits::max)()) + { + throw com_error( + "Seek offset too large", STG_E_INVALIDFUNCTION); + } + else if (offset.QuadPart < + (std::numeric_limits::min)()) + { + throw com_error( + "Seek offset too small", STG_E_INVALIDFUNCTION); + } + else + { + try + { + m_traits.do_seek( + static_cast(offset.QuadPart), + way, new_stream_position_out); + } + // Translate logic_errors (and subtypes) as they + // correspond (very roughly) to the kinds of errors + // for which IStream::Seek is documented to return + // STG_E_INVALIDFUNCTION + catch(const std::logic_error& e) + { + throw com_error(e.what(), STG_E_INVALIDFUNCTION); + } + + return S_OK; + } + } + COMET_CATCH_CLASS_INTERFACE_BOUNDARY("Seek", "adapted_stream"); + } + + /** + * Expand stream to given size. + * + * The will only increase a stream's size if it is smaller than the + * given size. If the stream size is already equal or bigger, it + * remains unchanged. + * + * Not all streams support changing size. In particular, `istream`s + * do not support this method. + */ + virtual HRESULT STDMETHODCALLTYPE SetSize(ULARGE_INTEGER new_size) + { + try + { + stream_failure_cleanser state_resetter(m_stream); + + position_resetter resetter( + m_traits, m_traits.do_tell()); + + if (new_size.QuadPart > 0) + { + ULARGE_INTEGER new_end_position; + new_end_position.QuadPart = new_size.QuadPart - 1; + + std::streamoff new_offset; + if ((std::numeric_limits::max)() < 0) + { + assert(!"Purely negative number!"); + throw com_error( + "Seek offset too large", STG_E_INVALIDFUNCTION); + } + else if (new_end_position.QuadPart > + static_cast( + (std::numeric_limits::max)())) + { + throw com_error( + "Seek offset too large", STG_E_INVALIDFUNCTION); + } + else + { + new_offset = static_cast( + new_end_position.QuadPart); + } + + std::streamoff existing_end = stream_size(m_traits); + + if (new_offset > existing_end) + { + std::streampos new_position; + m_traits.do_seek( + new_offset, std::ios_base::beg, new_position); + + assert(std::streamoff(new_position) == new_offset); + + // Force the stream to expand by writing NUL at + // new extent + ULONG bytes_written; + m_traits.do_write("\0", 1, bytes_written); + assert(bytes_written == 1); + } + } + + return S_OK; + } + COMET_CATCH_CLASS_INTERFACE_BOUNDARY("SetSize", "adapted_stream"); + } + + virtual HRESULT STDMETHODCALLTYPE CopyTo( + IStream* destination, ULARGE_INTEGER amount, + ULARGE_INTEGER* bytes_read_out, ULARGE_INTEGER* bytes_written_out) + { + stream_failure_cleanser state_resetter(m_stream); + + ULARGE_INTEGER dummy_read_out; + if (!bytes_read_out) + { + bytes_read_out = &dummy_read_out; + } + bytes_read_out->QuadPart = 0U; + + ULARGE_INTEGER dummy_written_out; + if (!bytes_written_out) + { + bytes_written_out = &dummy_written_out; + } + bytes_written_out->QuadPart = 0U; + + try + { + + if (!destination) + { + throw com_error( + "Destination stream not given", STG_E_INVALIDPOINTER); + } + + std::vector buffer(COPY_CHUNK_SIZE); + + // Perform copy operation in chunks COPY_CHUNK bytes big + // The chunk must be less than the biggest ULONG in size + // because of the limits of the Read/Write API. Of course + // it will be in any case as it would be insane to use more + // memory than that, but we make sure anyway using the first + // min comparison + do { + ULONG next_chunk_size = + static_cast( + min( + (std::numeric_limits::max)(), + min( + amount.QuadPart - bytes_read_out->QuadPart, + buffer.size()))); + + ULONG read_this_round = 0U; + ULONG written_this_round = 0U; + + // These two take care of updating the total on each pass + // round the loop as well as on termination, exception or + // natural. + // + // The means the out counts are valid even in the failure + // case. MSDN says they don't have to be but, as we can, + // we might as well + impl::byte_count_incrementer read_incrementer( + bytes_read_out, read_this_round); + + impl::byte_count_incrementer write_incrementer( + bytes_written_out, written_this_round); + + m_traits.do_read( + &buffer[0], next_chunk_size, read_this_round); + HRESULT hr = destination->Write( + &buffer[0], read_this_round, &written_this_round); + if (FAILED(hr)) + { + com_error_from_interface(destination, hr); + } + + if (read_this_round < next_chunk_size) + { + // EOF + break; + } + + } while (amount.QuadPart > bytes_read_out->QuadPart); + + return S_OK; + } + COMET_CATCH_CLASS_INTERFACE_BOUNDARY("CopyTo", "adapted_stream"); + } + + /** + * Flush data in the buffer to the controlled output sequence. + * + * This implementation doesn't support transactions so ignores + * the commit flags. + * + * Fails if called with an istream. + */ + virtual HRESULT STDMETHODCALLTYPE Commit(DWORD /*commit_flags*/) + { + stream_failure_cleanser state_resetter(m_stream); + + try + { + m_traits.do_flush(); + return S_OK; + } + COMET_CATCH_CLASS_INTERFACE_BOUNDARY("Commit", "adapted_stream"); + } + + virtual HRESULT STDMETHODCALLTYPE Revert() + { + try + { + throw com_error("Transactions not supported", E_NOTIMPL); + } + COMET_CATCH_CLASS_INTERFACE_BOUNDARY("Revert", "adapted_stream"); + } + + virtual HRESULT STDMETHODCALLTYPE LockRegion( + ULARGE_INTEGER /*offset*/, ULARGE_INTEGER /*extent*/, + DWORD /*lock_type*/) + { + try + { + throw com_error( + "Locking not supported", STG_E_INVALIDFUNCTION); + } + COMET_CATCH_CLASS_INTERFACE_BOUNDARY("LockRegion", "adapted_stream"); + } + + virtual HRESULT STDMETHODCALLTYPE UnlockRegion( + ULARGE_INTEGER /*offset*/, ULARGE_INTEGER /*extent*/, + DWORD /*lock_type*/) + { + try + { + throw com_error( + "Locking not supported", STG_E_INVALIDFUNCTION); + } + COMET_CATCH_CLASS_INTERFACE_BOUNDARY("UnlockRegion", "adapted_stream"); + } + + /** + * Get some metadata about the stream. + * + * The name returned (if requested) is the name optionally given + * in the constructor. If not given in the constructor, an + * empty string is returned. + * + * Some fields, such as the date fields, are not valid as that data + * is not available for IOStreams. + */ + virtual HRESULT STDMETHODCALLTYPE Stat( + STATSTG* attributes_out, DWORD stat_flag) + { + try + { + if (!attributes_out) + { + throw com_error("STATSTG not given", STG_E_INVALIDPOINTER); + } + + *attributes_out = STATSTG(); + + attributes_out->type = STGTY_STREAM; + + try + { + attributes_out->cbSize.QuadPart = + impl::stream_size(m_traits); + } + catch (const std::exception&) + { + // Swallow non-bad errors as many stream are not seekable and + // therefore not sizeable + if (m_stream.bad()) + throw; + } + + // Must be last as, after we detach, any failure will leak + // memory + if (!(stat_flag & STATFLAG_NONAME)) + { + // pwcsName is NOT a BSTR. It's a null-terminated OLESTR + // managed by the COM memory allocator + + size_t buffer_size = m_optional_name.size() + 1; + size_t buffer_size_in_bytes = + buffer_size * sizeof(wchar_t); + + attributes_out->pwcsName = static_cast( + ::CoTaskMemAlloc(buffer_size_in_bytes)); + if (!attributes_out->pwcsName) + { + throw com_error( + "Unable to allocate memory for stream name", + STG_E_INSUFFICIENTMEMORY); + } + + try + { + HRESULT hr = ::StringCbCopyW( + attributes_out->pwcsName, buffer_size_in_bytes, + m_optional_name.c_str()); + if (FAILED(hr)) + { + throw com_error( + "Unable to copy stream name to STATSTG", hr); + } + } + catch(...) + { + ::CoTaskMemFree(attributes_out->pwcsName); + throw; + } + } + + return S_OK; + } + COMET_CATCH_CLASS_INTERFACE_BOUNDARY("Stat", "adapted_stream"); + } + + /** + * Cloning not supported for IOStreams as they are not copyable. + */ + virtual HRESULT STDMETHODCALLTYPE Clone(IStream** stream_out) + { + if (stream_out) + { + *stream_out = NULL; + } + + try + { + throw com_error( + "Cloning not supported", STG_E_INVALIDFUNCTION); + } + COMET_CATCH_CLASS_INTERFACE_BOUNDARY("Clone", "adapted_stream"); + } + + private: + + Stream& m_stream; + stream_traits_type m_traits; + bstr_t m_optional_name; + }; + + template + class adapted_stream_pointer : public simple_object + { + public: + + adapted_stream_pointer(StreamPtr stream, const bstr_t& optional_name) + : m_stream(stream), m_inner(adapt_stream(*m_stream, optional_name)) + {} + + // The forwarded methods must return their HRESULT by throwing and + // catching in order to propagate the IErrorInfo upwards. + + virtual HRESULT STDMETHODCALLTYPE Read( + void* buffer, ULONG buffer_size, ULONG* read_count_out) + { + if (read_count_out) + { + *read_count_out = 0U; + } + + try + { + HRESULT hr = m_inner->Read(buffer, buffer_size, read_count_out); + if (FAILED(hr)) + throw com_error_from_interface(m_inner, hr); + + return hr; + } + COMET_CATCH_CLASS_INTERFACE_BOUNDARY( + "Read", "adapted_stream_pointer"); + } + + virtual HRESULT STDMETHODCALLTYPE Write( + const void* buffer, ULONG buffer_size, ULONG* written_count_out) + { + if (written_count_out) + { + *written_count_out = 0U; + } + + try + { + HRESULT hr = m_inner->Write( + buffer, buffer_size, written_count_out); + if (FAILED(hr)) + throw com_error_from_interface(m_inner, hr); + + return hr; + } + COMET_CATCH_CLASS_INTERFACE_BOUNDARY( + "Write", "adapted_stream_pointer"); + } + + virtual HRESULT STDMETHODCALLTYPE Seek( + LARGE_INTEGER offset, DWORD origin, + ULARGE_INTEGER* new_position_out) + { + if (new_position_out) + { + new_position_out->QuadPart = 0U; + } + + try + { + HRESULT hr = m_inner->Seek(offset, origin, new_position_out); + if (FAILED(hr)) + throw com_error_from_interface(m_inner, hr); + + return hr; + } + COMET_CATCH_CLASS_INTERFACE_BOUNDARY( + "Seek", "adapted_stream_pointer"); + } + + virtual HRESULT STDMETHODCALLTYPE SetSize(ULARGE_INTEGER new_size) + { + try + { + HRESULT hr = m_inner->SetSize(new_size); + if (FAILED(hr)) + throw com_error_from_interface(m_inner, hr); + + return hr; + } + COMET_CATCH_CLASS_INTERFACE_BOUNDARY( + "SetSize", "adapted_stream_pointer"); + } + + virtual HRESULT STDMETHODCALLTYPE CopyTo( + IStream* destination, ULARGE_INTEGER amount, + ULARGE_INTEGER* bytes_read_out, ULARGE_INTEGER* bytes_written_out) + { + if (bytes_read_out) + { + bytes_read_out->QuadPart = 0U; + } + + if (bytes_written_out) + { + bytes_written_out->QuadPart = 0U; + } + + try + { + HRESULT hr = m_inner->CopyTo( + destination, amount, bytes_read_out, bytes_written_out); + if (FAILED(hr)) + throw com_error_from_interface(m_inner, hr); + + return hr; + } + COMET_CATCH_CLASS_INTERFACE_BOUNDARY( + "CopyTo", "adapted_stream_pointer"); + } + + virtual HRESULT STDMETHODCALLTYPE Commit(DWORD commit_flags) + { + try + { + HRESULT hr = m_inner->Commit(commit_flags); + if (FAILED(hr)) + throw com_error_from_interface(m_inner, hr); + + return hr; + } + COMET_CATCH_CLASS_INTERFACE_BOUNDARY( + "Commit", "adapted_stream_pointer"); + } + + virtual HRESULT STDMETHODCALLTYPE Revert() + { + try + { + HRESULT hr = m_inner->Revert(); + if (FAILED(hr)) + throw com_error_from_interface(m_inner, hr); + + return hr; + } + COMET_CATCH_CLASS_INTERFACE_BOUNDARY( + "Revert", "adapted_stream_pointer"); + } + + virtual HRESULT STDMETHODCALLTYPE LockRegion( + ULARGE_INTEGER offset, ULARGE_INTEGER extent, DWORD lock_type) + { + try + { + HRESULT hr = m_inner->LockRegion(offset, extent, lock_type); + if (FAILED(hr)) + throw com_error_from_interface(m_inner, hr); + + return hr; + } + COMET_CATCH_CLASS_INTERFACE_BOUNDARY( + "LockRegion", "adapted_stream_pointer"); + } + + virtual HRESULT STDMETHODCALLTYPE UnlockRegion( + ULARGE_INTEGER offset, ULARGE_INTEGER extent, DWORD lock_type) + { + try + { + HRESULT hr = m_inner->UnlockRegion(offset, extent, lock_type); + if (FAILED(hr)) + throw com_error_from_interface(m_inner, hr); + + return hr; + } + COMET_CATCH_CLASS_INTERFACE_BOUNDARY( + "UnlockRegion", "adapted_stream_pointer"); + } + + virtual HRESULT STDMETHODCALLTYPE Stat( + STATSTG* attributes_out, DWORD stat_flag) + { + if (attributes_out) + { + *attributes_out = STATSTG(); + } + + try + { + HRESULT hr = m_inner->Stat(attributes_out, stat_flag); + if (FAILED(hr)) + throw com_error_from_interface(m_inner, hr); + + return hr; + } + COMET_CATCH_CLASS_INTERFACE_BOUNDARY( + "Stat", "adapted_stream_pointer"); + } + + virtual HRESULT STDMETHODCALLTYPE Clone(IStream** stream_out) + { + if (stream_out) + { + *stream_out = NULL; + } + + try + { + HRESULT hr = m_inner->Clone(stream_out); + if (FAILED(hr)) + throw com_error_from_interface(m_inner, hr); + + return hr; + } + COMET_CATCH_CLASS_INTERFACE_BOUNDARY( + "Clone", "adapted_stream_pointer"); + } + + private: + + StreamPtr m_stream; + com_ptr m_inner; + }; + +} + +/** + * Wrap COM IStream interface around C++ IOStream. + * + * The caller must ensure that the C++ IOStream remains valid until the + * last reference to the returned wrapper is released. + * + * Unlike C++ streams which may have separate read and write positions that + * move independently, COM IStreams assume a single combined read/write head. + * Therefore this wrapper always starts the next read or write operation + * from the where the last operation finished, regardless of whether that + * operation was a call to `Read` or `Write`. + * + * @note This only applies for as long as the read/write positions are + * modified only via this wrapper. If the positions are modified by + * directly on the underlying IOStream, it is undefined whether the + * starting point for the next call to `Read`/`Write` is syncronised + * with the end of the previous operation. + * + * If operations on the inner stream results in failure (the `failbit` + * is set), this is communicated via the COM-interface return code. The + * `failbit` is cleared before the call returns. This allows further + * wrapper methods to be called without having the clear the bit directly + * on the underlying stream. Fatal errors (`badbit`) and end-of-file + * (`eofbit`) are left unchanged and remain visible in the underlying + * stream. + */ +template +inline com_ptr adapt_stream( + Stream& stream, const bstr_t& optional_name=bstr_t()) +{ + return new impl::adapted_stream(stream, optional_name); +} + +/** + * Wrap COM IStream interface around pointer (usually smart) to C++ IOStream. + * + * If the pointer type is a smart pointer, the caller need not must ensure + * the lifetime of the C++ IOStream exceeds that of the adapter; the smart + * pointer takes care of ensuring this. + * + * The main reason for having this function in addition to `adapt_stream` is + * support the common case where a COM stream is intended to be the sole owner + * of the C++ stream with which it is created. This allows the caller to + * create the IStream and forget about the C++ stream. Using `adapt_stream` + * they would have to manage the lifetime of both. + * + * When we support movable types (C++11 or Boost.Move emulation), this method + * would become unnecessary for this purpose as the C++ stream could simply + * be moved into the adapter + */ +template +inline com_ptr adapt_stream_pointer( + StreamPtr stream_pointer, const bstr_t& optional_name=bstr_t()) +{ + return new impl::adapted_stream_pointer( + stream_pointer, optional_name); +} + +} + +#endif diff --git a/EyeTab_SP2/comet/threading.h b/EyeTab_SP2/comet/threading.h new file mode 100644 index 0000000..a4a79ab --- /dev/null +++ b/EyeTab_SP2/comet/threading.h @@ -0,0 +1,228 @@ +/** \file + * Threading support. + */ +/* + * Copyright © 2001-2002 Sofus Mortensen, Mikael Lindgren + * + * This material is provided "as is", with absolutely no warranty + * expressed or implied. Any use is at your own risk. Permission to + * use or copy this software for any purpose is hereby granted without + * fee, provided the above notices are retained on all copies. + * Permission to modify the code and to distribute modified code is + * granted, provided the above notices are retained, and a notice that + * the code was modified is included with the above copyright notice. + * + * This header is part of Comet version 2. + * https://github.com/alamaison/comet + */ + +#ifndef COMET_THREADING_H +#define COMET_THREADING_H + +#include +#include + +#include + +namespace comet { + +/** \class critical_section threading.h comet/threading.h + * wrapper for Win32 CRITICAL_SECTION. + */ +class critical_section { +public: + critical_section() { + ::InitializeCriticalSection(&cs_); + } + + ~critical_section() { + ::DeleteCriticalSection(&cs_); + } + + void enter() const { + ::EnterCriticalSection(&cs_); + } + + void leave() const { + ::LeaveCriticalSection(&cs_); + } + +private: + critical_section(const critical_section&); + critical_section& operator=(const critical_section&); + + mutable CRITICAL_SECTION cs_; +}; + +/** \class auto_cs threading.h comet/threading.h + * Stack based critical-section resource obtaining and releasing. + */ +class auto_cs { +public: + explicit auto_cs(const critical_section& cs) : cs_(cs) { + cs_.enter(); + } + + ~auto_cs() { + cs_.leave(); + } + +private: + auto_cs& operator=(const auto_cs&); + auto_cs(const auto_cs&); + + const critical_section& cs_; +}; + +/** \class locking_ptr threading.h comet/threading.h + Locking pointer. + Based on an article on the volatile keyword by Andrei Alexandrescu + See article. + */ +template class locking_ptr { +public: + locking_ptr(volatile T& obj, critical_section& cs) : + pointer_(const_cast(&obj)), + cs_(cs) + { + cs_.enter(); + } + + ~locking_ptr() + { + cs_.leave(); + } + + T& operator*() + { + return *pointer_; + } + + T* operator->() + { + return pointer_; + } + +private: + T* pointer_; + critical_section& cs_; + + locking_ptr(const locking_ptr&); + locking_ptr& operator=(const locking_ptr&); +}; + +class thread +{ +private: + DWORD id_; + auto_handle handle_; + + // declare non-copyable + thread(thread const& ); + thread& operator=(thread const& ); +public: + thread() : id_(0) + {} + + const auto_handle& start() + { + handle_ = auto_attach(::CreateThread(0, 0, &thread::start_proc, this, 0, &id_)); + return handle_; + } + + const auto_handle& handle() const + { + return handle_; + } + + void exit(DWORD exit_code) + { + ::ExitThread(exit_code); + } + + void suspend() + { + ::SuspendThread(handle_); + } + + void resume() + { + ::ResumeThread(handle_); + } + + bool running() + { + DWORD code; + return handle_ && + ::GetExitCodeThread(handle_, &code) && + code == STILL_ACTIVE; + } + + bool wait(DWORD timeout = INFINITE) + { + return ::WaitForSingleObject(handle_, timeout) == WAIT_OBJECT_0; + } + +private: + static DWORD _stdcall start_proc(void* param) + { + return static_cast(param)->thread_main(); + } + + virtual DWORD thread_main() = 0; +}; + +class event +{ +private: + auto_handle handle_; + + // declare non-copyable + event(event const& ); + event& operator=(event const& ); +public: + explicit event(bool initial_state = false) + { + handle_ = auto_attach(::CreateEvent(0, false, initial_state, 0)); + } + + explicit event(const TCHAR* name, bool initial_state = false) + { + handle_ = auto_attach(::CreateEvent(0, false, initial_state, name)); + } + + void set() + { + if (0 == ::SetEvent(handle_)) + { + DWORD err = GetLastError(); + raise_exception(HRESULT_FROM_WIN32(err)); + } + } + + void reset() + { + if (0==::ResetEvent(handle_) ) + { + DWORD err = GetLastError(); + raise_exception(HRESULT_FROM_WIN32(err)); + } + } + + bool wait(DWORD timeout = INFINITE) + { + return ::WaitForSingleObject(handle_, timeout) == WAIT_OBJECT_0; + } + + bool is_set() + { + return ::WaitForSingleObject(handle_, 0) == WAIT_OBJECT_0; + } + + operator HANDLE() const + { return handle_; } +}; + +} + +#endif diff --git a/EyeTab_SP2/comet/tlbinfo.h b/EyeTab_SP2/comet/tlbinfo.h new file mode 100644 index 0000000..38a4900 --- /dev/null +++ b/EyeTab_SP2/comet/tlbinfo.h @@ -0,0 +1,451 @@ +/** \file + * Wrappers for ITypeLibInfo. + */ +/* + * Copyright © 2002 Michael Geddes. + * + * This material is provided "as is", with absolutely no warranty + * expressed or implied. Any use is at your own risk. Permission to + * use or copy this software for any purpose is hereby granted without + * fee, provided the above notices are retained on all copies. + * Permission to modify the code and to distribute modified code is + * granted, provided the above notices are retained, and a notice that + * the code was modified is included with the above copyright notice. + * + * This header is part of Comet version 2. + * https://github.com/alamaison/comet + */ + +#ifndef COMET_TLIBINFO_H +#define COMET_TLIBINFO_H + +#ifdef _SHOW_INC +#pragma message(" #Include " __FILE__) +#endif + +#include +#include +#include + +namespace comet +{ + template<> struct comtype + { + static const IID& uuid() throw() { return IID_IPictureDisp; } + typedef ::IUnknown base; + }; + template<> struct comtype + { + static const IID& uuid() throw() { return IID_ITypeInfo; } + typedef ::IUnknown base; + }; + template<> struct comtype + { + static const IID& uuid() throw() { return IID_ITypeInfo2; } + typedef ::ITypeInfo base; + }; + /*! \addtogroup Interfaces + */ + //@{ + namespace impl + { + /// A class to handle the auto-releaseing of structs returned by by the Typeinfo interfaces. + template< typename B, typename T> + struct tlib_info + { + typedef void (__stdcall B::*RelFunc)(T*); + template< RelFunc RELEASE> + struct typeinfo_attr_base + { + public: + typeinfo_attr_base() : info_(NULL), attrib_(NULL), rc_(NULL) {} + typeinfo_attr_base( const com_ptr &info, T *attrib ) : info_(info),attrib_(attrib),rc_(NULL) + { + if (attrib != NULL) + { + rc_ = new long; + (*rc_)=1; + } + } + typeinfo_attr_base( const typeinfo_attr_base &base) + : info_(base.info_), attrib_(base.attrib_), rc_(base.rc_) + { + ++*rc_; + } + ~typeinfo_attr_base() + { + release(); + } + typeinfo_attr_base &operator =( const typeinfo_attr_base &base) + { + release(); + info_= base.info_; + attrib_= base.attrib_; + rc_ = base.rc_; + ++*rc_; + return *this; + } + void release() + { + if(attrib_ != NULL && rc_ != NULL ) + { + if (0 == --*rc_) + { + (info_.raw()->*RELEASE)( attrib_); + delete rc_; + } + rc_ = NULL; + attrib_ = NULL; + info_ = NULL; + } + } + + + T *operator->() const + { + if( attrib_ ==NULL ) throw com_error(E_POINTER); + return attrib_; + } + bool is_null() const { return attrib_ == NULL; } + protected: + long *rc_; + T *attrib_; + com_ptr info_; + }; + }; + }; + + /// Auto-release wrapper for TYPEATTR. + typedef impl::tlib_info::typeinfo_attr_base< &ITypeInfo::ReleaseTypeAttr > type_attr_t; + /// Auto-release wrapper for FUNCDESC. + typedef impl::tlib_info::typeinfo_attr_base< &ITypeInfo::ReleaseFuncDesc > func_desc_t; + /// Auto-release wrapper for VARDESC. + typedef impl::tlib_info::typeinfo_attr_base< &ITypeInfo::ReleaseVarDesc > var_desc_t; + + /// Auto-release wrapper for TLIBATTR. + typedef impl::tlib_info::typeinfo_attr_base< &ITypeLib::ReleaseTLibAttr > tlibattr_t; + + + /** Flags for GetImplTypeFlags. + * \sa IMPLTYPEFLAGS + */ + enum impl_type_flag + { + eft_default=0x1, ///< The interface or dispinterface represents the default for the source or sink. + eft_source =0x2, ///< This member of a coclass is called rather than implemented. + eft_restricted=0x4, ///< The member should not be displayed or programmable by users. + eft_defaultvtable=0x8 ///< Sinks receive events through the VTBL. + }; + + /** Specialisation wrapper for ITypeInfo. + * \struct wrap_t tlbinfo.h comet/tlbinfo.h + * Wrapper for ITypeInfo typelib information. + * \sa ITypeInfo + */ + template<> + struct wrap_t + { + private: + inline ITypeInfo *raw_(){ return reinterpret_cast(this); } + public: + + /** Returns a wrapped Type Attributes struct. + * \sa TYPEATTR + */ + type_attr_t GetTypeAttr() + { + TYPEATTR *pTypeAttr; + raw_()->GetTypeAttr( &pTypeAttr) | raise_exception ; + return type_attr_t( raw_(), pTypeAttr); + } + + /// Returns an ITypeComp interface. + com_ptr GetTypeComp() + { + com_ptr ppTComp; + raw_()->GetTypeComp( ppTComp.out()) | raise_exception; + return ppTComp; + } + + /** Get the function description struct. + * \sa FUNCDESC + */ + func_desc_t GetFuncDesc( unsigned int index) + { + FUNCDESC *pFuncDesc ; + raw_()->GetFuncDesc(index, &pFuncDesc) | raise_exception ; + return func_desc_t( raw_(), pFuncDesc); + } + + /** Get the Variable/Constant/Datamember description. + * \sa VARDESC + */ + var_desc_t GetVarDesc( unsigned int index ) + { + VARDESC *pVarDesc; + raw_()->GetVarDesc( index,&pVarDesc) | raise_exception; + return var_desc_t(raw_(), pVarDesc); + } + + +#ifdef NOT_YET + std::list GetNames( MEMBERID memid ) + { + /* [local] */ HRESULT GetNames( /* [in] */ MEMBERID memid, /* [length_is][size_is][out] */ BSTR *rgBstrNames, + /* [in] */ UINT cMaxNames, /* [out] */ UINT *pcNames) ; + } +#endif // + + /// Retrieves the type description of implemented interface types. + HREFTYPE GetRefTypeOfImplType( unsigned int index) + { + HREFTYPE reftype; + raw_()->GetRefTypeOfImplType(index, &reftype) | raise_exception; + return reftype; + } + + /// Retrieves the type description of implemented interface types. + long GetImplTypeFlags( int index) + { + INT implTypeFlags; + raw_()->GetImplTypeFlags( index, &implTypeFlags) |raise_exception; + return implTypeFlags; + } + +#ifdef NOT_YET + std::vector GetIDsOfNames( const std::vector &rgsNames); + { + /* [local] */ HRESULT GetIDsOfNames( + /* [size_is][in] */ LPOLESTR *rgszNames, + /* [in] */ UINT cNames, + /* [size_is][out] */ MEMBERID *pMemId) ; + } + + /* [local] */ HRESULT Invoke( + /* [in] */ PVOID pvInstance, + /* [in] */ MEMBERID memid, + /* [in] */ WORD wFlags, + /* [out][in] */ DISPPARAMS *pDispParams, + /* [out] */ VARIANT *pVarResult, + /* [out] */ EXCEPINFO *pExcepInfo, + /* [out] */ UINT *puArgErr) ; +#endif // NOT_YET + /// Raw wrapper to make sure comet still works/compiles. + HRESULT GetIDsOfNames( LPOLESTR *rgszNames, UINT cNames, + MEMBERID *pMemId) + { + return raw_()->GetIDsOfNames( rgszNames, cNames, pMemId); + } + + /// Raw wrapper to make sure comet still works/compiles. + HRESULT Invoke( PVOID pvInstance, MEMBERID memid, WORD wFlags, + DISPPARAMS *pDispParams, VARIANT *pVarResult, EXCEPINFO *pExcepInfo, + UINT *puArgErr) + { + return raw_()->Invoke( pvInstance, memid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr); + } + + bool GetIDOfName( const wchar_t *name, MEMBERID *id) + { + wchar_t *ucname = const_cast(name); + return SUCCEEDED(raw_()->GetIDsOfNames( &ucname, 1, id)); + } + + + /// Get the documentation for the specified MEMBERID. + void GetDocumentation(MEMBERID memid, bstr_t *name, bstr_t *docString, DWORD *helpcontext, bstr_t *helpfile) + { + raw_()->GetDocumentation(memid, name?name->out():NULL, docString?docString->out():NULL, + helpcontext, helpfile? helpfile->out():NULL) | raise_exception; + } + /** Get the member name for the specified MEMBERID. + * This is a shortcut for GetDocumentation. + */ + + bstr_t GetMemberName(MEMBERID memid) + { + bstr_t name; + raw_()->GetDocumentation(memid, name.out(), NULL, NULL, NULL) | raise_exception; + return name; + } + bstr_t GetName() + { + return GetMemberName(-1); + } + +#if NOT_YET + /* [local] */ HRESULT GetDllEntry( + /* [in] */ MEMBERID memid, + /* [in] */ INVOKEKIND invKind, + /* [out] */ BSTR *pBstrDllName, + /* [out] */ BSTR *pBstrName, + /* [out] */ WORD *pwOrdinal) ; +#endif // NOT_YET + + /** Get the referenced Type information. + */ + com_ptr GetRefTypeInfo( HREFTYPE refType) + { + com_ptr refinfo; + raw_()->GetRefTypeInfo( refType, refinfo.out()) | raise_exception; + return refinfo; + } + +#if NOT_YET + /* [local] */ HRESULT AddressOfMember( /* [in] */ MEMBERID memid, /* [in] */ INVOKEKIND invKind, + /* [out] */ PVOID *ppv) ; + + /* [local] */ HRESULT CreateInstance( /* [in] */ IUnknown *pUnkOuter, /* [in] */ REFIID riid, + /* [iid_is][out] */ PVOID *ppvObj) ; + + HRESULT GetMops( /* [in] */ MEMBERID memid, /* [out] */ BSTR *pBstrMops) ; +#endif // NOT_YET + + /** Get the typelib containing this definition. + * \return A pair containing the typelibrary and the index of the type description within the type library. + */ + std::pair< com_ptr, UINT > GetContainingTypeLib() + { + std::pair< com_ptr, UINT> result; + raw_()->GetContainingTypeLib( result.first.out(), &(result.second) ) | raise_exception; + return result; + } + }; + //@} + + template<> + struct wrap_t : wrap_t + { + TYPEKIND GetTypeKind() + { + TYPEKIND tkind; + raw_()->GetTypeKind(&tkind) | raise_exception; + return tkind; + } + private: + inline ITypeInfo2 *raw_(){ return reinterpret_cast(this); } + }; + + + /*! \addtogroup Interfaces + */ + //@{ + + /// Specialisation to handle TypeLibrary API. + template<> + struct wrap_t + { + inline ITypeLib *raw_(){ return reinterpret_cast(this); } + unsigned int GetTypeInfoCount() + { + return raw_()->GetTypeInfoCount(); + } + + /// Get typeinfo at specified index. + com_ptr GetTypeInfo( UINT index) + { + com_ptr tinfo; + raw_()->GetTypeInfo( index, tinfo.out()) | raise_exception; + return tinfo; + } + + /// Get type of information at specified index. + TYPEKIND GetTypeInfoType( UINT index) + { + TYPEKIND retval; + raw_()->GetTypeInfoType( index, &retval) | raise_exception; + return retval; + } + + /// Get typeinfo given GUID. + com_ptr GetTypeInfoOfGuid( const uuid_t &guid ) + { + com_ptr tinfo; + raw_()->GetTypeInfoOfGuid( guid, tinfo.out()) | raise_exception; + return tinfo; + } + /// Get Raw Typeinfo of guid. + HRESULT GetTypeInfoOfGuid( REFGUID guid, ITypeInfo **ppTinfo) + { + return raw_()->GetTypeInfoOfGuid( guid,ppTinfo); + } + + /// Get attributes of the typelibrary. + tlibattr_t GetLibAttr() + { + TLIBATTR *attr; + raw_()->GetLibAttr( &attr) | raise_exception; + return tlibattr_t( raw_(), attr); + } + + com_ptr GetTypeComp() + { + com_ptr typecomp; + raw_()->GetTypeComp( typecomp.out() ) | raise_exception; + return typecomp; + } + + void GetDocumentation(int index, bstr_t *name, bstr_t *docString, DWORD *helpcontext, bstr_t *helpfile) + { + raw_()->GetDocumentation(index, name?name->out():NULL, docString?docString->out():NULL, + helpcontext, helpfile? helpfile->out():NULL) | raise_exception; + } + bstr_t GetItemName(int index) + { + bstr_t name; + raw_()->GetDocumentation(index, name.out(), NULL, NULL, NULL) | raise_exception; + return name; + } + bstr_t GetName() + { + return GetItemName(-1); + } + + bool IsName( const bstr_t &name, unsigned long hashval ) + { + BOOL ret; + raw_()->IsName( name.in(), hashval, &ret) | raise_exception; + return ret!=0; + } + + std::pair, MEMBERID> FindName( const bstr_t &name) + { + std::pair, MEMBERID> result; + USHORT tofind = 1; + raw_()->FindName(name.in(), 0, result.first.out(), &result.second, &tofind) | raise_exception; + return result; + } +#ifdef NOT_YET + std::list, MEMBERID> >FindName( const bstr_t &name, int max) + {} + [local] + HRESULT FindName( + [in, out] LPOLESTR szNameBuf, + [in] ULONG lHashVal, + [out,size_is(*pcFound),length_is(*pcFound)] ITypeInfo **ppTInfo, + [out,size_is(*pcFound),length_is(*pcFound)] MEMBERID * rgMemId, + [in, out] USHORT * pcFound + ); +#endif // LATER + + + }; + + /// Load typeinfo from a file. + namespace typeinfo + { + /** Whether to register the typelibrary on load. + * \relates typeinfo::LoadTypeLib + */ + enum regkind_t { reg_default = REGKIND_DEFAULT, reg_register = REGKIND_REGISTER, reg_none = REGKIND_NONE } ; + /// Load typeinfo from a file. + static inline com_ptr LoadTypeLib( const bstr_t &filename, regkind_t regkind= reg_default) + { + com_ptr tlib; + LoadTypeLibEx(filename.in(), (REGKIND)(regkind), tlib.out()) | raise_exception; + return tlib; + } + } + //@} +} // namespace comet +#endif /* COMET_TLIBINFO_H */ diff --git a/EyeTab_SP2/comet/tstring.h b/EyeTab_SP2/comet/tstring.h new file mode 100644 index 0000000..6520524 --- /dev/null +++ b/EyeTab_SP2/comet/tstring.h @@ -0,0 +1,124 @@ +/** \file + * C++ Std. lib TCHAR mappings. + */ +/* + * Copyright © 2002 Sofus Mortensen + * + * This material is provided "as is", with absolutely no warranty + * expressed or implied. Any use is at your own risk. Permission to + * use or copy this software for any purpose is hereby granted without + * fee, provided the above notices are retained on all copies. + * Permission to modify the code and to distribute modified code is + * granted, provided the above notices are retained, and a notice that + * the code was modified is included with the above copyright notice. + * + * This header is part of Comet version 2. + * https://github.com/alamaison/comet + */ + +#ifndef COMET_TSTRING_H +#define COMET_TSTRING_H + +#include +#include +#include + +namespace comet { + + /*! \addtogroup WinUtil + */ + //@{ + +#if defined(_MBCS) && !defined(_UNICODE) && !defined(COMET_NO_MBCS_WARNING) +#pragma message( "Warning: _MBCS is defined. Be aware that tstring does not support multi-byte character strings" ) +#endif + /** \page comettstring Comet tstring type. + * In order for comet projects to more easily support unicode via the + * windows file "tchar.h", many comet classes support the type #comet::tstring which is + * a convenience typedef to basic_string. Associated with + * \link comet::tstring tstring \endlink are all or most of the other STL + * classes that have a \p char argument to the templates. + * + * In addition to being used by comet, this is a generally useful series + * of typedefs to be used when combining STL types with tchar.h compatible + * projects. + * + * There are two area to be particularly wary of with STL and tchar.h. + * + * The first is that the filename argument for file streams are always + * narrow char *. I would suggest using a #comet::bstr_t which will + * convert for you, especially in UNICODE (actually UCS2 little-endien) projects. + * + * The second is that tstring support for multi-byte character strings is + * very minimal. Embedded NULLs in the stream are not a problem for + * copying around, however none of the parsing/searching/comparison + * methods cope with multi-byte character sets. + * + * I believe that part of the reason for this is the platform specific + * nature of multi-byte, and the internal support for a variety of + * different MBCS implementations by Microsoft. + */ + + /** TCHAR version of std::basic_string. + * See \ref comettstring + */ + typedef std::basic_string< TCHAR > tstring; + + /** TCHAR version of std::basic_ios. + * \relates tstring + */ + typedef std::basic_ios > tios; + /** TCHAR version of std::basic_streambuf. + * \relates tstring + */ + typedef std::basic_streambuf > tstreambuf; + /** TCHAR version of std::basic_istream. + * \relates tstring + */ + typedef std::basic_istream > tistream; + /** TCHAR version of std::basic_ostream. + * \relates tstring + */ + typedef std::basic_ostream > tostream; + /** TCHAR version of std::basic_iostream. + * \relates tstring + */ + typedef std::basic_iostream > tiostream; + /** TCHAR version of std::basic_stringbuf. + * \relates tstring + */ + typedef std::basic_stringbuf, std::allocator > tstringbuf; + /** TCHAR version of std::basic_istringstream. + * \relates tstring + */ + typedef std::basic_istringstream, std::allocator > tistringstream; + /** TCHAR version of std::basic_ostringstream. + * \relates tstring + */ + typedef std::basic_ostringstream, std::allocator > tostringstream; + /** TCHAR version of std::basic_stringstream. + * \relates tstring + */ + typedef std::basic_stringstream, std::allocator > tstringstream; + /** TCHAR version of std::basic_filebuf. + * \relates tstring + */ + typedef std::basic_filebuf > tfilebuf; + /** TCHAR version of std::basic_ifstream. + * \relates tstring + */ + typedef std::basic_ifstream > tifstream; + /** TCHAR version of std::basic_ofstream. + * \relates tstring + */ + typedef std::basic_ofstream > tofstream; + /** TCHAR version of std::basic_fstream. + * \relates tstring + */ + typedef std::basic_fstream > tfstream; + + //@} +} + + +#endif diff --git a/EyeTab_SP2/comet/type_traits.h b/EyeTab_SP2/comet/type_traits.h new file mode 100644 index 0000000..45f7c3a --- /dev/null +++ b/EyeTab_SP2/comet/type_traits.h @@ -0,0 +1,262 @@ +/** \file + * Interrogate traits of template types. + */ +/* + * Copyright © 2000, 2001 Sofus Mortensen, Paul Hollingsworth + * + * This material is provided "as is", with absolutely no warranty + * expressed or implied. Any use is at your own risk. Permission to + * use or copy this software for any purpose is hereby granted without + * fee, provided the above notices are retained on all copies. + * Permission to modify the code and to distribute modified code is + * granted, provided the above notices are retained, and a notice that + * the code was modified is included with the above copyright notice. + * + * This header is part of Comet version 2. + * https://github.com/alamaison/comet + */ + +/* + * Partial copyright for is_const, is_volatile and is_reference. + * + * (C) Copyright Steve Cleary, Beman Dawes, Howard Hinnant & John Maddock 2000. + * Permission to copy, use, modify, sell and + * distribute this software is granted provided this copyright notice appears + * in all copies. This software is provided "as is" without express or implied + * warranty, and with no claim as to its suitability for any purpose. + */ + +#ifndef COMET_TYPE_TRAITS_H +#define COMET_TYPE_TRAITS_H + +namespace comet { + + /** Provides structs to interrogate traits of template types. + */ + namespace type_traits { + + ////////////////////////////////////////////////////////////////////////// + // From www.boost.org + + //* is a type T declared const - is_const + namespace detail{ + typedef char yes_result; + typedef char (&no_result)[8]; + yes_result is_const_helper(const volatile void*); + no_result is_const_helper(volatile void *); + yes_result is_volatile_helper(const volatile void*); + no_result is_volatile_helper(const void *); + + template struct helper { T t; }; + } + + template struct is_const + { + enum{ result = (sizeof(detail::yes_result) == sizeof( detail::is_const_helper( + & ((reinterpret_cast *>(0))->t)) + )) + }; + }; + + template struct is_volatile + { + enum{ result = (sizeof(detail::yes_result) == sizeof(detail::is_volatile_helper( + & ((reinterpret_cast *>(0))->t)) + )) + }; + }; + +# pragma warning(push) +# pragma warning(disable: 4181) + + //* is a type T a reference type - is_reference + template struct is_reference + { + private: + typedef T const volatile cv_t; + public: + enum // dwa 10/27/00 - VC6.4 seems to choke on short-circuit (&&,||) + { // evaluations in constant expressions + value = !is_const::result | !is_volatile::result + }; + }; + + template <> struct is_reference + { + enum{ value = false }; + }; + +# pragma warning(pop) + + + ////////////////////////////////////////////////////////////////////////// + + template struct is_integer { enum { result = false }; }; + template<> struct is_integer { enum { result = true }; }; + template<> struct is_integer { enum { result = true }; }; + template<> struct is_integer { enum { result = true }; }; + template<> struct is_integer { enum { result = true }; }; +// template<> struct is_integer { enum { result = true }; }; + template<> struct is_integer { enum { result = true }; }; + template<> struct is_integer { enum { result = true }; }; + template<> struct is_integer { enum { result = true }; }; + template<> struct is_integer { enum { result = true }; }; + template<> struct is_integer { enum { result = true }; }; + template<> struct is_integer { enum { result = true }; }; + + //! @if Internal + /** Taken from STLPort. + * \internal + */ + struct _PointerShim { + // Since the compiler only allows at most one non-trivial + // implicit conversion we can make use of a shim class to + // be sure that IsPtr below doesn't accept classes with + // implicit pointer conversion operators + _PointerShim(const volatile void*); // no implementation + }; + //! @endif + + // These are the discriminating functions + static char __cdecl _IsP(bool, _PointerShim); // no implementation is required + static char* __cdecl _IsP(bool, ...); // no implementation is required + + template + struct is_pointer { + // This template meta function takes a type T + // and returns true exactly when T is a pointer. + // One can imagine meta-functions discriminating on + // other criteria. + static _Tp& __null_rep(); + enum { result = (sizeof(_IsP(false,__null_rep())) == sizeof(char)) }; + }; + + // Work out whether the Type is something we can use operator-> on + // (hopefully). If we fail, the worst we get is a level 3 warinng. + template + struct is_class_pointer + { + enum { result = (is_pointer<_Tp>::result && ! is_integer<_Tp>::result) }; + }; + + template struct int_holder + { + enum { result = x }; + }; + + template struct type_holder + { + typedef T result; + }; + +/* template class is_static_compatible + { + class yes { }; + class no {char a[10]; }; + + static yes test( U * ); + static no test( ... ); + + public: + enum { is = sizeof(test(static_cast(0))) == sizeof(yes) ? true : false }; + };*/ + + template class is_cast_operator_compatible + { + protected: + class yes { }; + class no {char a[10]; }; + + static yes test( U* ); + static no test( ... ); + + public: + enum { is = sizeof(test(*static_cast(0))) == sizeof(yes) /*? 1 : 0 */}; + }; + +#ifndef COMET_PARTIAL_SPECIALISATION + template struct conversion_aux + { + template class X + { + protected: + class yes { }; + class no {char a[10]; }; + static T makeT(); + + static yes test(U); + static no test(...); + public: + enum { exists = sizeof(test(makeT())) == sizeof(yes) }; + enum { same_type = false }; + }; + + + template<> class X + { + public: + enum { exists = true }; + enum { same_type = true }; + }; + + }; + template struct conversion + { + enum { exists = conversion_aux::X::exists }; + enum { same_type = conversion_aux::X::same_type }; + enum { exists_two_way = exists && conversion_aux::X::exists }; + }; +#else + template struct conversion + { + protected: + class yes { }; + class no {char a[10]; }; + static T makeT(); + + static yes test(U); + static no test(...); + public: + enum { exists = sizeof(test(makeT())) == sizeof(yes) }; + enum { same_type = false }; + enum { exists_two_way = conversion::exists}; + + }; + template struct conversion + { + + enum { exists = true }; + enum { same_type = true }; + enum { exists_two_way = true}; + }; + +#endif // COMET_PARTIAL_SPECIALISATION + + template struct super_sub_class + { + enum { result = conversion::exists && !conversion::same_type }; + }; + + inline bool is_null_vtable_entry(void *p,short n) + { + return ((n<0)?true:(0==(*reinterpret_cast(reinterpret_cast(*(reinterpret_cast(p)))+n)))); + } + + } + + namespace impl { + + // used by NutshellImpl's + struct false_type {}; + struct true_type {}; + + template struct is_one { typedef false_type val; }; + template<> struct is_one<1> { typedef true_type val; }; + + } + + +} + + +#endif diff --git a/EyeTab_SP2/comet/typelist.h b/EyeTab_SP2/comet/typelist.h new file mode 100644 index 0000000..8af6ab8 --- /dev/null +++ b/EyeTab_SP2/comet/typelist.h @@ -0,0 +1,450 @@ +/** \file + * Implementation of Lists of types. + * Type lists are rather integral to the operation of Comet, and provide us + * with many of the mechanisms that allow us to all but remove the need for + * \#define macros in code. + */ +/* + * Copyright © 2000-2002 Sofus Mortensen, Michael Geddes + * + * This material is provided "as is", with absolutely no warranty + * expressed or implied. Any use is at your own risk. Permission to + * use or copy this software for any purpose is hereby granted without + * fee, provided the above notices are retained on all copies. + * Permission to modify the code and to distribute modified code is + * granted, provided the above notices are retained, and a notice that + * the code was modified is included with the above copyright notice. + * + * This header is part of Comet version 2. + * https://github.com/alamaison/comet + */ + +#ifndef COMET_TYPELIST_H +#define COMET_TYPELIST_H + +#include + +namespace comet { + + /** \struct nil typelist.h comet/typelist.h + * End of list type. + */ + struct nil {}; + + template + struct tl_t { + typedef T head; + typedef U tail; + }; + +#ifndef COMET_TL_TRUNC +#ifndef __BORLANDC__ +#define COMET_TL_LIST( X01,X02,X03,X04,X05,X06,X07,X08,X09, \ + X10,X11,X12,X13,X14,X15,X16,X17,X18,X19, \ + X20,X21,X22,X23,X24,X25,X26,X27,X28,X29, \ + X30,X31,X32,X33,X34,X35,X36,X37,X38,X39) \ + X01,X02,X03,X04,X05,X06,X07,X08,X09, \ + X10,X11,X12,X13,X14,X15,X16,X17,X18,X19, \ + X20,X21,X22,X23,X24,X25,X26,X27,X28,X29, \ + X30,X31,X32,X33,X34,X35,X36,X37,X38,X39 +#else +#define COMET_TL_LIST( X01,X02,X03,X04,X05,X06,X07,X08,X09, \ + X10,X11,X12,X13,X14,X15,X16,X17,X18,X19, \ + X20,X21,X22,X23,X24,X25,X26,X27,X28,X29, \ + X30,X31,X32,X33,X34,X35,X36,X37,X38,X39) \ + X01,X02,X03,X04,X05,X06,X07,X08,X09, \ + X10,X11,X12,X13,X14,X15,X16,X17,X18,X19, \ + X20,X21,X22,X23,X24,X25,X26,X27,X28,X29 +#endif +#else +#define COMET_TL_LIST( X01,X02,X03,X04,X05,X06,X07,X08,X09, \ + X10,X11,X12,X13,X14,X15,X16,X17,X18,X19, \ + X20,X21,X22,X23,X24,X25,X26,X27,X28,X29, \ + X30,X31,X32,X33,X34,X35,X36,X37,X38,X39) \ + X01,X02,X03,X04,X05,X06,X07,X08,X09,X10 +#endif + + + +#define COMET_LIST_TEMPLATE \ + typename X00=comet::nil, COMET_TL_LIST( typename X01=comet::nil, typename X02=comet::nil, typename X03=comet::nil, typename X04=comet::nil, \ + typename X05=comet::nil, typename X06=comet::nil, typename X07=comet::nil, typename X08=comet::nil, typename X09=comet::nil, \ + typename X10=comet::nil, typename X11=comet::nil, typename X12=comet::nil, typename X13=comet::nil, typename X14=comet::nil, \ + typename X15=comet::nil, typename X16=comet::nil, typename X17=comet::nil, typename X18=comet::nil, typename X19=comet::nil, \ + typename X20=comet::nil, typename X21=comet::nil, typename X22=comet::nil, typename X23=comet::nil, typename X24=comet::nil, \ + typename X25=comet::nil, typename X26=comet::nil, typename X27=comet::nil, typename X28=comet::nil, typename X29=comet::nil, \ + typename X30=comet::nil, typename X31=comet::nil, typename X32=comet::nil, typename X33=comet::nil, typename X34=comet::nil, \ + typename X35=comet::nil, typename X36=comet::nil, typename X37=comet::nil, typename X38=comet::nil, typename X39=comet::nil) + +#define COMET_LIST_TEMPLATE_0 typename X00, COMET_TL_LIST(\ + typename X01, typename X02, typename X03, typename X04, \ + typename X05, typename X06, typename X07, typename X08, typename X09, \ + typename X10, typename X11, typename X12, typename X13, typename X14, \ + typename X15, typename X16, typename X17, typename X18, typename X19, \ + typename X20, typename X21, typename X22, typename X23, typename X24, \ + typename X25, typename X26, typename X27, typename X28, typename X29, \ + typename X30, typename X31, typename X32, typename X33, typename X34, \ + typename X35, typename X36, typename X37, typename X38, typename X39) + +#define COMET_LIST_ARG_1 X00, COMET_TL_LIST(\ + X01,X02,X03,X04,X05,X06,X07,X08,X09, \ + X10,X11,X12,X13,X14,X15,X16,X17,X18,X19, \ + X20,X21,X22,X23,X24,X25,X26,X27,X28,X29, \ + X30,X31,X32,X33,X34,X35,X36,X37,X38,X39) + +#define COMET_LIST_ARG_0 COMET_TL_LIST(\ + X01,X02,X03,X04,X05,X06,X07,X08,X09, \ + X10,X11,X12,X13,X14,X15,X16,X17,X18,X19, \ + X20,X21,X22,X23,X24,X25,X26,X27,X28,X29, \ + X30,X31,X32,X33,X34,X35,X36,X37,X38,X39) + +#define COMET_LIST_NIL comet::nil, COMET_TL_LIST(\ + comet::nil,comet::nil,comet::nil,comet::nil,comet::nil,comet::nil,comet::nil,comet::nil,comet::nil, \ + comet::nil,comet::nil,comet::nil,comet::nil,comet::nil,comet::nil,comet::nil,comet::nil,comet::nil,comet::nil, \ + comet::nil,comet::nil,comet::nil,comet::nil,comet::nil,comet::nil,comet::nil,comet::nil,comet::nil,comet::nil, \ + comet::nil,comet::nil,comet::nil,comet::nil,comet::nil,comet::nil,comet::nil,comet::nil,comet::nil,comet::nil) + + /** \struct make_list typelist.h comet/typelist.h + * Construct a 'type list' of up to 40 types. + * A list is a 'head-tail' list terminated by a 'nil' tail struct. + * It is most easily constructe by using make_list: + \code + comet::make_list< FooType,BarType>::result + \endcode + + * The \e concept of a type-list is that it is either \link comet::nil nil \endlink + * or a struct containing a \e typedef of \p head to the first element in the + * list and a typedef of \p tail to a type-list that contains the rest of + * the list. + * + * This means that for a type-list \e LST + * \code + LST::head + \endcode + * is the first element in the list (assuming it is not + * \link comet::nil nil \endlink) and + * \code + LST::head::tail::head + \endcode + would be the second element in the list (assuming LST::head::tail is not + \link comet::nil nil \endlink), and so on. + + * Two type lists can be appended together with typelist::append. + + \sa typelist::append + */ + template struct make_list + { + typedef tl_t::result> result; + }; + + template<> struct make_list + { + typedef nil result; + }; + + namespace typelist { + + template struct length + { + enum { value = 1 + length< typename L::tail>::value }; + }; + + template<> struct length + { + enum { value = 0 }; + }; + +#ifdef COMET_PARTIAL_SPECIALISATION + //! Find the type at the specified index. + /** \param L Type List + * \param idx Index + */ + template struct type_at + { + typedef typename type_at::result result; + }; + template struct type_at + { + typedef typename L::head result; + }; + template< unsigned idx> struct type_at + { + typedef nil result; + }; + template<> struct type_at + { + typedef nil result; + }; + + + /** \internal + */ + template struct index_of_aux + { + enum { value = 1+(index_of_aux::value) }; + }; + template< typename L, typename T> struct index_of_aux + { + enum { value = 0 }; + }; + /** Find the index of the type \a T in the type-list \a L. + * The result is in index_of::value. + */ + template struct index_of + { + enum { value = index_of_aux::value }; + }; + + +#else + template struct type_at; + + template struct type_at_aux + { + template struct X + { + typedef typename type_at::result result; +// typedef type_at_aux::X::result result; + }; + + template<> struct X<0> + { + typedef typename L::head result; + }; + }; + + template<> struct type_at_aux + { + template struct X + { + typedef nil result; + }; + }; + + +/* template<> struct type_at_aux< make_list<> > + { + template struct X + { + typedef nil result; + }; + };*/ + + template struct type_at + { + typedef typename type_at_aux::X::result result; + }; + + template struct index_of; + + template struct index_of_aux + { + template struct X1 + { + template struct X2 + { + enum { value = 1 + index_of::value }; + }; + + template<> struct X2 + { + enum { value = 0 }; + }; + }; + }; + + template struct index_of + { + enum { value = index_of_aux::X1::X2::value }; + }; +#endif // COMET_PARTIAL_SPECIALISATION + +#undef COMET_LIST_ARG + +#ifdef COMET_PARTIAL_SPECIALISATION + + /** \struct append typelist.h comet/typelist.h + * Appends two type-lists together. + * Example: + * \code + comet::typelist::append< + comet::make_list< Type1, Type2 >::result, + comet::make_list< Type3, Type4 >::result + > + \endcode + \sa make_list + */ + template struct append + { + typedef typename L1::head head; + typedef append tail; + }; + + template struct append + { + typedef typename L2::head head; + typedef typename L2::tail tail; + }; + template struct append,L2> + { + typedef typename L2::head head; + typedef typename L2::tail tail; + }; + template<> struct append + { + typedef nil head; + typedef nil tail; + }; + template struct append_element + { + typedef typename append::result>::head head; + typedef typename append::result>::tail tail; + }; +#else // COMET_PARTIAL_SPECIALISATION + + template struct append; + + namespace impl { + + template struct append_aux + { + template struct with + { + typedef typename L1::head head; + typedef typename append tail; +// typedef typename append_aux::with tail; + }; + + template<> struct with + { + typedef typename L1::head head; + typedef typename L1::tail tail; + }; + }; + + template<> struct append_aux + { + template struct with + { + typedef typename L2::head head; + typedef typename L2::tail tail; + }; + }; + +/* template<> struct append_aux > + { + template struct with + { + typedef typename L2::head head; + typedef typename L2::tail tail; + }; + };*/ + + } + + template struct append + { + typedef typename impl::append_aux::with::head head; + typedef typename impl::append_aux::with::tail tail; + }; + + template struct append_element + { + typedef typename impl::append_aux::with< typename make_list::result >::head head; + typedef typename impl::append_aux::with< typename make_list::result >::tail tail; + }; +#endif // COMET_PARTIAL_SPECIALISATION + + +#ifdef COMET_NESTED_TEMPLATES + /** \struct wrap_each typelist.h comet/typelist.h + * Wrap each of the elements of a list in the specified template class. + * Due to lack of support for template parameter to templates by Microsoft, + * macros have been defined as a necessary evil to get arround this. + * The macros are #COMET_WRAP_EACH_DECLARE and #COMET_WRAP_EACH. + * There is a propper implementation for compilers that support nested + * interfaces, which will be selected by the macro as appropriate. + * \sa COMET_WRAP_EACH_DECLARE COMET_WRAP_EACH + */ + template< template< typename > class T, typename L1> struct wrap_each; + namespace impl + { + template< template< typename > class T, typename L1> struct wrap_each_aux + { + typedef wrap_each x; + }; + template< template< typename > class T> struct wrap_each_aux< T, nil> + { + typedef nil x; + }; + } + + template< template< typename > class T, typename L1> struct wrap_each + { + typedef T head; + typedef typename impl::wrap_each_aux::x tail; + }; + + template< template< typename > class T> struct wrap_each< T, ::comet::nil > + { + }; + /** \def COMET_WRAP_EACH_DECLARE(T) + * Declare a template for wrapping each element in the specified type. + * \relates wrap_each + */ +#define COMET_WRAP_EACH_DECLARE(T) +// MSVC7.1 doesn't like this: +// template< template< typename > class T1, typename L1> struct wrap_each; + + /** \def COMET_WRAP_EACH(T, L1) + * Produce a list L2 that consists of each member of list L1 wrapped in type T. + * This is very much a Lambda calculus concept for those who care. + * \relates wrap_each + */ +#define COMET_WRAP_EACH(T, L1) typelist::wrap_each + +#else // COMET_NESTED_TEMPLATES +#define COMET_WRAP_EACH_DECLARE(T) \ + template< typename L1 > struct wrap_each_aux##T; \ + namespace impl \ + { \ + template< typename L1> struct p_wrap_each_aux##T \ + { \ + typedef wrap_each_aux##T x; \ + }; \ + template<> struct p_wrap_each_aux##T < ::comet::nil> \ + { \ + typedef ::comet::nil x; \ + }; \ + }; \ + template< typename L1> struct wrap_each_aux##T \ + { \ + typedef T head; \ + typedef typename impl::p_wrap_each_aux##T < typename L1::tail>::x tail;\ + }; \ + template<> struct wrap_each_aux##T< ::comet::nil> { }; + +#define COMET_WRAP_EACH(T, L1) wrap_each_aux##T + +#endif // COMET_NESTED_TEMPLATES + + template struct ATL_NO_VTABLE inherit_all + : public ITF_LIST::head, public inherit_all + {}; + + template<> struct inherit_all {}; +// template<> struct inherit_all > {}; + + } + +/* MSVC7 chokes on this one - not actually used anywhere + + template struct select + { + typedef typelist::type_at< make_list::result, idx>::result result; + };*/ + +} // namespace + +#endif diff --git a/EyeTab_SP2/comet/unittest.h b/EyeTab_SP2/comet/unittest.h new file mode 100644 index 0000000..d53821a --- /dev/null +++ b/EyeTab_SP2/comet/unittest.h @@ -0,0 +1,86 @@ +/** \file + * Unit-test wrapper. + */ +/* + * Copyright © 2000, 2001 Paul Hollingsworth + * + * This material is provided "as is", with absolutely no warranty + * expressed or implied. Any use is at your own risk. Permission to + * use or copy this software for any purpose is hereby granted without + * fee, provided the above notices are retained on all copies. + * Permission to modify the code and to distribute modified code is + * granted, provided the above notices are retained, and a notice that + * the code was modified is included with the above copyright notice. + * + * This header is part of Comet version 2. + * https://github.com/alamaison/comet + */ + +#ifndef COMET_UNITTEST_H +#define COMET_UNITTEST_H + +#include +#include + +namespace comet { + //! Define a unit test \a n. + template + struct test + { + void run() {} + }; + + int current_test = 0; + + //! Run \a n tests. + /** \sa test + */ + template + struct tester + { + inline static void runtests() + { + tester::runtests(); + current_test = n; + test().run(); + } + }; + + template<> + struct tester<0> + { + static void runtests() {} + }; +} // namespace comet + +//! Implement Main function for testing. +template +struct main_t +{ + /// Call to run tests. + static int call(int argc, const char * const argv[]) + { + using std::cout; + using std::cerr; + using std::endl; + try { + comet::tester<64>::runtests(); + } catch (const std::exception &e) { + std::cerr << "Test #" << comet::current_test << " failed - error message: <" << e.what() << ">" << endl; + return 1; + } + catch(...) { + std::cerr << "Test #" << comet::current_test << " failed with an unrecognized exception" << endl; + return 2; + } + std::cout << "Ran all tests successfully" <::call(argc,argv);\ +} + +#endif diff --git a/EyeTab_SP2/comet/util.h b/EyeTab_SP2/comet/util.h new file mode 100644 index 0000000..0e514e0 --- /dev/null +++ b/EyeTab_SP2/comet/util.h @@ -0,0 +1,125 @@ +/** \file + * Various utilities. + */ +/* + * Copyright © 2000, 2001 Sofus Mortensen + * + * This material is provided "as is", with absolutely no warranty + * expressed or implied. Any use is at your own risk. Permission to + * use or copy this software for any purpose is hereby granted without + * fee, provided the above notices are retained on all copies. + * Permission to modify the code and to distribute modified code is + * granted, provided the above notices are retained, and a notice that + * the code was modified is included with the above copyright notice. + * + * This header is part of Comet version 2. + * https://github.com/alamaison/comet + */ + +#ifndef COMET_UTIL_H +#define COMET_UTIL_H + +#include + +#include + +#include +#include + +namespace comet { + + /*! \addtogroup WinUtil + */ + //@{ + //! Automatic handling of CoInitialize / CoUninitialize. + class auto_coinit { + public: +#if (_WIN32_WINNT >= 0x0400 ) || defined(_WIN32_DCOM) // DCOM + explicit auto_coinit(COINIT ci) { + ::CoInitializeEx(0, ci) | raise_exception; + } +#endif + + auto_coinit() { ::CoInitialize(0) | raise_exception; } + + ~auto_coinit() { ::CoUninitialize(); } + + private: + auto_coinit& operator=(const auto_coinit&); + auto_coinit(const auto_coinit&); + }; + + // For backward compatibility. + typedef auto_coinit auto_CoInitialize; + + /// Returns the class id of the free threaded marshaler + inline CLSID get_clsid_of_ftm() + { + CLSID rv; + class Dummy : public static_object<> {} dummy; + + IUnknown* pUnk = 0; + ::CoCreateFreeThreadedMarshaler(&dummy, &pUnk) | raise_exception; + + com_ptr marshal = try_cast(pUnk); + + marshal.raw()->GetUnmarshalClass(IID_IUnknown, &dummy, MSHCTX_INPROC,0,MSHLFLAGS_NORMAL, &rv) | raise_exception; + return rv; + } + + /** + * Returns true if and only if object is aggregating the free threaded marshaler. + */ + inline bool is_object_aggregating_ftm(const com_ptr& p) + { + com_ptr marshal = com_cast(p); + if (marshal == 0) return false; + + class Dummy : public static_object<> {} dummy; + + CLSID clsid = CLSID_NULL; + marshal.raw()->GetUnmarshalClass(IID_IUnknown, &dummy, MSHCTX_INPROC,0,MSHLFLAGS_NORMAL, &clsid); + + CLSID ftm_clsid = get_clsid_of_ftm(); + return clsid == ftm_clsid ? true : false; + } + +#if (_WIN32_WINNT >= 0x0400 ) || defined(_WIN32_DCOM) // DCOM + /** + * Returns true if and only if current apartment is the MTA. + */ + inline bool is_mta() + { + if (SUCCEEDED(::CoInitializeEx(0, COINIT_MULTITHREADED))) + { + ::CoUninitialize(); + return true; + } + return false; + } +#endif + /** + * Returns true if and only if current apartment is an STA. + */ + inline bool is_sta() + { + if (SUCCEEDED(::CoInitialize(0))) + { + ::CoUninitialize(); + return true; + } + return false; + } + + /** + * Returns true if and only if specified ptr is a standard proxy. + */ + inline bool is_std_proxy(const com_ptr& unk) + { + com_ptr pm; + return SUCCEEDED(unk.raw()->QueryInterface(IID_IProxyManager, reinterpret_cast(pm.out()))); + } + +} // namespace + +#endif diff --git a/EyeTab_SP2/comet/uuid.h b/EyeTab_SP2/comet/uuid.h new file mode 100644 index 0000000..ffd9802 --- /dev/null +++ b/EyeTab_SP2/comet/uuid.h @@ -0,0 +1,88 @@ +/** \file + * uuid wrapper class. + */ +/* + * Copyright © 2001, 2002 Sofus Mortensen + * + * This material is provided "as is", with absolutely no warranty + * expressed or implied. Any use is at your own risk. Permission to + * use or copy this software for any purpose is hereby granted without + * fee, provided the above notices are retained on all copies. + * Permission to modify the code and to distribute modified code is + * granted, provided the above notices are retained, and a notice that + * the code was modified is included with the above copyright notice. + * + * This header is part of Comet version 2. + * https://github.com/alamaison/comet + */ + +#ifndef COMET_UUID_H +#define COMET_UUID_H + +#include +#include +#include + +#pragma comment( lib, "Rpcrt4" ) + +namespace comet { + + template + void uuid_t::copy_to_str(C s[36]) const throw() + { + const unsigned char *p = reinterpret_cast(this); + + for (int i=0; i<20; ++i) + { + int j = uuid_table()[i]; + if (j >= 0) + { + const unsigned char byt = p[j]; + *s = hex_table()[byt >> 4]; + ++s; + *s = hex_table()[byt & 0xf]; + } + else *s = L'-'; + ++s; + } + } + + template + bool uuid_t::init_from_str(const C s[], size_t len) throw() + { + unsigned char *p = reinterpret_cast(this); + + bool has_brace; + switch (len) + { + default: return false; + case 36: has_brace = false; break; + case 38: + if (*s != C('{')) + return false; + has_brace = true; + ++s; + break; + } + + int i; + for (i=0; i<20; ++i) + { + int j = uuid_table()[i]; + if (j >= 0) + { + int a = parse_nibble(*s); + ++s; + int b = parse_nibble(*s); + p[j] = unsigned char(a << 4 | b); + } + else if (*s != C('-')) + return false; + ++s; + } + return (! has_brace) || (*s == C('}')); + } + +} + +#endif diff --git a/EyeTab_SP2/comet/uuid_fwd.h b/EyeTab_SP2/comet/uuid_fwd.h new file mode 100644 index 0000000..316178f --- /dev/null +++ b/EyeTab_SP2/comet/uuid_fwd.h @@ -0,0 +1,441 @@ +/** \file + * uuid wrapper class. + */ +/* + * Copyright © 2001, 2002 Sofus Mortensen + * Copyright © 2013 Alexander Lamaison + * + * This material is provided "as is", with absolutely no warranty + * expressed or implied. Any use is at your own risk. Permission to + * use or copy this software for any purpose is hereby granted without + * fee, provided the above notices are retained on all copies. + * Permission to modify the code and to distribute modified code is + * granted, provided the above notices are retained, and a notice that + * the code was modified is included with the above copyright notice. + * + * This header is part of Comet version 2. + * https://github.com/alamaison/comet + */ + +#ifndef COMET_UUID_FWD_H +#define COMET_UUID_FWD_H + +#include +#include + +#include +#include +#include +#include +#include + +namespace comet{ + + +/*! \addtogroup COMType + */ +//@{ + +/// UUID wrapper. +class uuid_t : public COMET_GUID_BASE +{ + struct unitialized_t {}; + uuid_t(unitialized_t) {} + + friend class bstr_t; + +public: + /// Default constructor - constructs a nil uuid. + uuid_t() + { + UuidCreateNil(this); + } + + /// Copy constructor + uuid_t(const COMET_GUID_BASE& u) + { + memcpy(this, &u, sizeof(COMET_GUID_BASE)); + } + + /// Assignment operator + uuid_t& operator=(const COMET_GUID_BASE& u) + { + memcpy(this, &u, sizeof(COMET_GUID_BASE)); + return *this; + } + + /// \name Construct uuid from string + //@{ + explicit uuid_t(const std::string& s) + { + if (!init_from_str(s.c_str(), s.length())) + throw std::runtime_error(err_msg()); + } + + explicit uuid_t(const char* s) + { + if (!init_from_str(s, strlen(s))) + throw std::runtime_error(err_msg()); + } + + explicit uuid_t(const std::wstring& s) + { + if (!init_from_str(s.c_str(), s.length())) + throw std::runtime_error(err_msg()); + } + + explicit uuid_t(const wchar_t* s) + { + if (!init_from_str(s, wcslen(s))) + throw std::runtime_error(err_msg()); + } + + explicit uuid_t(const bstr_t& bs); + //@} + + //! Generate new guid. + static uuid_t create() + { + unitialized_t x; + uuid_t g(x); + UuidCreate(&g); + return g; + } + + //! Set to nil uuid. + void clear() + { + UuidCreateNil(this); + } + + //! Returns hash of uuid + unsigned short hash() const + { + RPC_STATUS status; + unsigned short r = UuidHash(const_cast(this), &status); + if (status != RPC_S_OK) + throw std::runtime_error("uuid_t::hash - UuidHash failed."); + return r; + } + + //! Convert uuid to string + //@{ + /// Return a std::string version of the uuid. + std::string str() const + { + std::string r; + r.resize(36); + copy_to_str(&r[0]); + return r; + } + /// Return a std::string version of the uuid. + inline std::string s_str() const + { + return str(); + } + + /// Return a std::wstring version of the uuid. + std::wstring w_str() const + { + std::wstring r; + r.resize(36); + copy_to_str(&r[0]); + return r; + } + + /// Return a tstring (templated to TCHAR) version of the uuid. + tstring t_str() const + { + tstring r; + r.resize(36); + copy_to_str(&r[0]); + return r; + } + //@} + + /// Returns true if and only if uuid is nil. + bool is_null() const throw() + { + return ((PLONG) this)[0] == 0 && + ((PLONG) this)[1] == 0 && + ((PLONG) this)[2] == 0 && + ((PLONG) this)[3] == 0; + } + + //! Returns true if and only if uuid is nil + bool operator!() const throw() + { + return is_null(); + } + + /// Output to an ostream. + template + friend inline std::basic_ostream& operator<<(std::basic_ostream& os, const uuid_t& u); + + /// Input from an ostream + template + friend inline std::basic_istream& operator>>(std::basic_istream& is, uuid_t& u); + + /** \internal + */ + class bool_tester + { void operator delete(void*); }; + + /// Copy the uuid_t to a string/container. + template void copy_to_str(C s[]) const throw(); + /// Initialise the uuid_t from a string/container. + template bool init_from_str(const C s[], size_t len) throw(); + + static const int* uuid_table() + { + static const int table[] = { 3, 2, 1, 0, -1, 5, 4, -1, 7, 6, -1, 8, 9, -1, 10, 11, 12, 13, 14, 15 }; + return table; + } + + static const char* hex_table() + { + static const char hex[] = "0123456789abcdef"; + return hex; + } + + static const char* err_msg() + { + static const char msg[] = "uuid_t: invalid format"; + return msg; + } + + static int parse_nibble(int c) + { + return c >= 'A' ? (c|0x20) - 'a' + 10 : c - '0'; + } + + /// Compare two guids. + inline long cmp(const comet::uuid_t &rhs) const + { + long i; // The code below may be a bit dense, but it is compact and works. + if((i = (Data1 - rhs.Data1)) == 0 && (i = (Data2 - rhs.Data2)) == 0 && (i = (Data3 - rhs.Data3)) == 0) + (i = ::memcmp(Data4, rhs.Data4, 8)); + return i; + } + + /// Compare two guids for equality. + inline bool is_equal( const comet::uuid_t &rhs) const + { + // From ATL + return ((PLONG) this)[0] == ((PLONG) &rhs)[0] && + ((PLONG) this)[1] == ((PLONG) &rhs)[1] && + ((PLONG) this)[2] == ((PLONG) &rhs)[2] && + ((PLONG) this)[3] == ((PLONG) &rhs)[3]; + } + +public: + /**\internal + */ + operator bool_tester*() const throw() + { if (is_null()) return 0; static bool_tester test; return &test; } + + /// Construct const reference to uuid from a raw GUID + static const uuid_t& create_const_reference(const COMET_GUID_BASE& x) + { + return *reinterpret_cast(&x); + } + + /// Construct reference to uuid from a raw GUID + static uuid_t& create_reference(COMET_GUID_BASE& x) + { + return *reinterpret_cast(&x); + } + + //! \name Methods for converting uuid to raw GUID when calling raw COM functions or legacy code. + //@{ + COMET_GUID_BASE* out() { return this; } + COMET_GUID_BASE* inout() { return this; } + COMET_GUID_BASE in() const { return *this; } + COMET_GUID_BASE* in_ptr() const { return const_cast(static_cast(this)); } + //@} +}; +//@} + +/// \name comparison operators +//@{ +/** Equals operator. + * \relates uuid_t + */ +inline bool operator==(const comet::uuid_t& lhs, const comet::uuid_t& rhs) +{ + return lhs.is_equal(rhs); +} + +/** Inequality operator. + * \relates uuid_t + */ +inline bool operator!=(const comet::uuid_t& lhs, const comet::uuid_t& rhs) +{ + return !lhs.is_equal(rhs); +} + +/** Equals operator. + * \relates uuid_t + */ +inline bool operator==(const comet::uuid_t& lhs, const COMET_GUID_BASE& rhs) +{ + return lhs.is_equal( comet::uuid_t::create_const_reference(rhs) ); +} + +/** Inequality operator. + * \relates uuid_t + */ +inline bool operator!=(const comet::uuid_t& lhs, const COMET_GUID_BASE& rhs) +{ + return !lhs.is_equal( comet::uuid_t::create_const_reference(rhs) ); +} + +/** Equals operator. + * \relates uuid_t + */ +inline bool operator==(const COMET_GUID_BASE& lhs, const comet::uuid_t& rhs) +{ + return comet::uuid_t::create_const_reference(lhs).is_equal(rhs); +} + +/** Inequality operator. + * \relates uuid_t + */ +inline bool operator!=(const COMET_GUID_BASE& lhs, const comet::uuid_t& rhs) +{ + return !comet::uuid_t::create_const_reference(lhs).is_equal(rhs); +} + +/** Less-than operator. + * \relates uuid_t + */ +inline bool operator<(const comet::uuid_t& lhs, const comet::uuid_t& rhs) +{ + return lhs.cmp(rhs)<0; +} + +/** Less-than operator. + * \relates uuid_t + */ +inline bool operator<(const comet::uuid_t& lhs, const COMET_GUID_BASE& rhs) +{ + return lhs.cmp(comet::uuid_t::create_const_reference(rhs))<0; +} + +/** Less-than operator. + * \relates uuid_t + */ +inline bool operator<(const COMET_GUID_BASE& lhs, const comet::uuid_t& rhs) +{ + return comet::uuid_t::create_const_reference(lhs).cmp(rhs)<0; +} + +/** Greater-than-equals operator. + * \relates uuid_t + */ +inline bool operator>=(const comet::uuid_t& lhs, const comet::uuid_t& rhs) +{ + return lhs.cmp(rhs)>=0; +} + +/** Greater-than-equals operator. + * \relates uuid_t + */ +inline bool operator>=(const comet::uuid_t& lhs, const COMET_GUID_BASE& rhs) +{ + return lhs.cmp(comet::uuid_t::create_const_reference(rhs))>=0; +} + +/** Greater-than-equals operator. + * \relates uuid_t + */ +inline bool operator>=(const COMET_GUID_BASE& lhs, const comet::uuid_t& rhs) +{ + return comet::uuid_t::create_const_reference(lhs).cmp(rhs)>=0; +} + +/** Greater-than operator. + * \relates uuid_t + */ +inline bool operator>(const comet::uuid_t& lhs, const comet::uuid_t& rhs) +{ + return lhs.cmp(rhs)>0; +} + +/** Greater-than operator. + * \relates uuid_t + */ +inline bool operator>(const comet::uuid_t& lhs, const COMET_GUID_BASE& rhs) +{ + return lhs.cmp(comet::uuid_t::create_const_reference(rhs))>0; +} + +/** Greater-than operator. + * \relates uuid_t + */ +inline bool operator>(const COMET_GUID_BASE& lhs, const comet::uuid_t& rhs) +{ + return comet::uuid_t::create_const_reference(lhs).cmp(rhs)>0; +} + +/** Less-than-equals operator. + * \relates uuid_t + */ +inline bool operator<=(const comet::uuid_t& lhs, const comet::uuid_t& rhs) +{ + return lhs.cmp(rhs)<=0; +} + +/** Less-than-equals operator. + * \relates uuid_t + */ +inline bool operator<=(const comet::uuid_t& lhs, const COMET_GUID_BASE& rhs) +{ + return lhs.cmp(comet::uuid_t::create_const_reference(rhs))<=0; +} + +/** Less-than-equals operator. + * \relates uuid_t + */ +inline bool operator<=(const COMET_GUID_BASE& lhs, const comet::uuid_t& rhs) +{ + return comet::uuid_t::create_const_reference(lhs).cmp(rhs)<=0; +} +//@} + +/// \name overloads for output/input to/from streams +/// @{ + +/** Output to an ostream. + * \relates uuid_t + */ +template +inline std::basic_ostream& operator<<(std::basic_ostream& os, const comet::uuid_t& u) +{ + E buf[36]; + u.copy_to_str(buf); + os.write(buf, 36); + return os; +} + +/** Input from an istream. + * \relates uuid_t + */ +template +inline std::basic_istream& operator>>(std::basic_istream& is, comet::uuid_t& u) +{ + typename std::basic_istream::sentry se(is); + if (se) + { + E buf[36]; + is.read(buf, 36); + if (!u.init_from_str(buf, is.gcount())) + is.setstate(std::ios::badbit); + } + return is; +} +//@} + +} // namespace comet + +#endif diff --git a/EyeTab_SP2/comet/variant.h b/EyeTab_SP2/comet/variant.h new file mode 100644 index 0000000..95129e2 --- /dev/null +++ b/EyeTab_SP2/comet/variant.h @@ -0,0 +1,1054 @@ +/** \file + * Wrapper for VARIANT. + */ +/* + * Copyright © 2000, 2001 Sofus Mortensen, Michael Geddes + * + * This material is provided "as is", with absolutely no warranty + * expressed or implied. Any use is at your own risk. Permission to + * use or copy this software for any purpose is hereby granted without + * fee, provided the above notices are retained on all copies. + * Permission to modify the code and to distribute modified code is + * granted, provided the above notices are retained, and a notice that + * the code was modified is included with the above copyright notice. + * + * This header is part of Comet version 2. + * https://github.com/alamaison/comet + */ + +#ifndef COMET_VARIANT_H +#define COMET_VARIANT_H + +#include +#include +#include +#include +#include +#include +#include + +#include + +#pragma warning(push) +#pragma warning(disable : 4127) + +#define COMET_VARIANT_OPERATOR(op, name) \ + variant_t operator##op(const variant_t& x) const \ + { \ + VARIANT t; \ + Var##name(const_cast(get_var()), const_cast(x.get_var()), &t) | raise_exception; \ + return auto_attach(t); \ + } \ + \ + variant_t& operator##op##=(const variant_t& x) \ + { \ + return operator=(operator##op(x)); \ + } + +#define COMET_VARIANT_CONVERTERS_EX_(type, vartype, func) \ + variant_t(type x) throw() \ + { \ + V_##vartype(this) = x; V_VT(this) = VT_##vartype; \ + } \ + \ + func() const \ + { \ + if (V_VT(this) == VT_##vartype) return V_##vartype(this); \ + variant_t v(*this, VT_##vartype); \ + return V_##vartype(v.get_var()); \ + } \ + \ + variant_t& operator=(type x) throw() \ + { \ + clear(); \ + V_##vartype(this) = x; V_VT(this) = VT_##vartype; \ + return *this; \ + } + +#define COMET_VARIANT_CONVERTERS_EXPLICIT(type, vartype, funcname) COMET_VARIANT_CONVERTERS_EX_(type,vartype, type funcname) +#define COMET_VARIANT_CONVERTERS(type, vartype) COMET_VARIANT_CONVERTERS_EX_(type,vartype, operator type ) + +#define COMET_VARIANT_FRIENDS(type) \ + inline bool operator!=(type x, const variant_t& y) { return y != x; } \ + inline bool operator==(type x, const variant_t& y) { return y == x; } \ + inline bool operator<(type x, const variant_t& y) { return y > x; } \ + inline bool operator<=(type x, const variant_t& y) { return y >= x; } \ + inline bool operator>(type x, const variant_t& y) { return y < x; } \ + inline bool operator>=(type x, const variant_t& y) { return y <= x; } + +namespace comet { + + template class safearray_t; + + namespace impl { + + template + inline HRESULT compare(const T& operand1, const T& operand2) + { + if (operand1 == operand2) + return VARCMP_EQ; + else if (operand1 < operand2) + return VARCMP_LT; + else + return VARCMP_GT; + } + + /** + * Comparison workaround for broken VarCmp. + * + * VarCmp() doesn't work for several of the numeric types + * (VT_I1, VT_INT, VT_UI2, VT_UI4, VT_UINT or VT_UI8) so we have + * to do these ourselves. + * + * @see http://source.winehq.org/WineAPI/VarCmp.html + */ + inline HRESULT var_cmp( + VARIANT* lhs, VARIANT* rhs, LCID lcid, ULONG flags) + { + switch (V_VT(lhs)) + { + case VT_I1: + return compare(V_I1(lhs), V_I1(rhs)); + case VT_INT: + return compare(V_INT(lhs), V_INT(rhs)); + case VT_UI2: + return compare(V_UI2(lhs), V_UI2(rhs)); + case VT_UI4: + return compare(V_UI4(lhs), V_UI4(rhs)); + case VT_UINT: + return compare(V_UINT(lhs), V_UINT(rhs)); + case VT_UI8: + return compare(V_UI8(lhs), V_UI8(rhs)); + default: + return ::VarCmp(lhs, rhs, lcid, flags); + } + } + + }; + + template class com_ptr; + + + /*! \addtogroup COMType + */ + //@{ + + //! Wrapper for VARIANT type. + /** variant_t is exception safe (basic and strong guarantee). + */ + class variant_t : private ::tagVARIANT + { + private: + void init() throw() + { + //::VariantInit(this); + tagVARIANT * x = this; + V_VT(x)= VT_EMPTY; + } + + void create(const VARIANT& v) throw(com_error) + { + HRESULT hr = ::VariantCopy(this, const_cast(&v)); + if (FAILED(hr)) { + ::VariantClear(this); + raise_exception(hr); + } + } + + public: + //! Default constructor + variant_t() throw() + { + init(); + } + + private: + struct tagMissing {}; + + variant_t(const tagMissing&) throw() + { + init(); + vt = VT_ERROR; + scode = DISP_E_PARAMNOTFOUND; + } + + struct tagNothing {}; + + variant_t(const tagNothing&) throw() + { + init(); + vt = VT_DISPATCH; + pdispVal = 0; + } + + struct tagNull {}; + + variant_t(const tagNull&) throw() + { + init(); + vt = VT_NULL; + } + + public: + //! Return a variant constructed as missing. + /** (VT_ERROR with code DISP_E_PARAMNOTFOUND ) + */ + static const variant_t& missing() + { + static tagMissing t; + static variant_t v(t); + return v; + } + + //! Return a variant contructed as nothing. + /** (VT_DISPATCH with value 0) + */ + static const variant_t& nothing() + { + static tagNothing t; + static variant_t v(t); + return v; + } + + //! Return a variant constructed as null (VT_NULL). + static const variant_t& null() + { + static tagNull t; + static variant_t v(t); + return v; + } + + //! Copy constructor + /*! + \exception com_error + Thrown if underlying VariantCopy fails. + */ + variant_t(const variant_t& v) throw(com_error) + { + init(); + create(v); + } + + public: + + //! VariantChangeType Constructor + /*! + Copies variant and changes to specified type. + + \note Unlike the _variant_t of VC, variant_t uses Thread Locale for type changes instead of the user setting. + + \par v + Variant to copy from + \par vartype + Type to change to. + + \exception com_error + Thrown if underlying VariantChangeTypeEx fails. + */ + variant_t(const variant_t& v, VARTYPE vartype) throw(com_error) + { + init(); + if (vartype != V_VT(&v)) + ::VariantChangeTypeEx(get_var(), + const_cast(v.get_var()), + GetThreadLocale(), + 0, vartype) | raise_exception; + else + ::VariantCopy(this, const_cast(v.get_var())); + } + + variant_t(const variant_t& v, VARTYPE vartype, std::nothrow_t) throw(com_error) + { + init(); + if (vartype != V_VT(&v)) + ::VariantChangeTypeEx(get_var(), + const_cast(v.get_var()), + GetThreadLocale(), + 0, vartype); + else + ::VariantCopy(this, const_cast(v.get_var())); + } + + //! Constructor + /*! + \exception com_error + Thrown if underlying VariantCopy fails. + */ + explicit variant_t(const VARIANT& v) throw(com_error) + { + init(); + create(v); + } + + //! Attaching constructor + /*! + Takes ownership of specified VARIANT. + + \param v + auto_attach wrapper variant to attach to the variant_t + */ + variant_t(const impl::auto_attach_t& v) throw() + { + memcpy(this, &const_cast(v.get()), sizeof(VARIANT)); + } + + private: + void clear() COMET_THROWS_ASSERT + { + HRESULT hr = ::VariantClear(this); + COMET_ASSERT(SUCCEEDED(hr)); + /* Avoid C4189 */ hr; + } + + public: + + //! Destructor + /*! + \note Be aware that the underlying call to VariantClear may fail. + But since we are not allowed to throw any exceptions (Otherwise STL containers cannot guarantee exception safety) + from within a + destructor, a failing VariantClear will be ignored. + Instead we assert for success in debug and ignore in release. + */ + ~variant_t() throw() + { + clear(); + } + + /// \name com_ptr conversion. + //@{ + private: + template inline void create(const com_ptr& x) throw(); + + + public: + template variant_t(const com_ptr& x) throw() + { + init(); + create(x); + } + + template + variant_t& operator=(const com_ptr& x) throw() + { + clear(); create(x); return *this; + } + + //@} + + + //!\name bool Conversion + //@{ + variant_t(bool x) throw() { + init(); + V_VT(this) = VT_BOOL; + V_BOOL(this) = x ? COMET_VARIANT_TRUE : COMET_VARIANT_FALSE; + } + + operator bool() const throw() + { + if (V_VT(this) == VT_BOOL) return (V_BOOL(this) != COMET_VARIANT_FALSE); + variant_t v(*this, VT_BOOL); + return (V_BOOL(&v) != COMET_VARIANT_FALSE); + } + + variant_t& operator=(bool x) throw() + { + clear(); + V_VT(this) = VT_BOOL; + V_BOOL(this) = x ? COMET_VARIANT_TRUE : COMET_VARIANT_FALSE; + return *this; + } + + //@} + + //!\name string Conversion + //@{ + variant_t(const bstr_t& s) throw(std::bad_alloc) + { + init(); + bstr_t t(s); + V_BSTR(this) = bstr_t::detach(t); + V_VT(this) = VT_BSTR; + } + + variant_t(const wchar_t* s) throw(std::bad_alloc) + { + init(); + bstr_t t(s); + V_BSTR(this) = bstr_t::detach(t); + V_VT(this) = VT_BSTR; + } + + variant_t(const std::wstring& s) throw(std::bad_alloc) + { + init(); + bstr_t t(s); + V_BSTR(this) = bstr_t::detach(t); + V_VT(this) = VT_BSTR; + } + + variant_t(const std::string& s) throw(std::bad_alloc) + { + init(); + bstr_t bs(s); + V_BSTR(this) = bstr_t::detach(bs); + V_VT(this) = VT_BSTR; + } + + variant_t(const char* x) + { + init(); + V_BSTR(this) = bstr_t::detach(x); + V_VT(this) = VT_BSTR; + } + + /** Attach a BSTR to a variant. + * \code + bstr_t val = L"A large string"; + variant_t(auto_attach(val.detach())); + \endcode + */ + variant_t( const impl::auto_attach_t &bstrVal) + { + V_BSTR(this) = bstrVal.get(); + V_VT(this) = VT_BSTR; + } + +/* operator bstr_t() const + { + if (V_VT(this) == VT_BSTR) return V_BSTR(this); + variant_t v(*this, VT_BSTR); + VARIANT t = v.detach(); + return auto_attach(V_BSTR(&t)); + }*/ + + bstr_t str() const + { + if (V_VT(this) == VT_BSTR) return V_BSTR(this); + if (V_VT(this) == (VT_BSTR | VT_BYREF)) return *V_BSTRREF(this); + if (V_VT(this) == VT_NULL) return bstr_t(); + variant_t v(*this, VT_BSTR); + VARIANT t = v.detach(); + return auto_attach(V_BSTR(&t)); + } + + operator bstr_t() const + { + return str(); + } + + operator std::wstring() const + { + if (V_VT(this) == VT_BSTR) return V_BSTR(this); + if (V_VT(this) == (VT_BSTR | VT_BYREF)) return *V_BSTRREF(this); + if (V_VT(this) == VT_NULL) return std::wstring(); + variant_t v(*this, VT_BSTR); + return V_BSTR(&v) ? std::wstring(V_BSTR(&v)) : std::wstring(); + } + + operator std::string() const + { + return str().s_str(); + } + + variant_t& operator=(const bstr_t& s) + { + variant_t t(s); + swap(t); + return *this; + } + + variant_t& operator=(const wchar_t* s) + { + variant_t t(s); + swap(t); + return *this; + } + + variant_t& operator=(const char* s) + { + variant_t t(s); + swap(t); + return *this; + } + + variant_t& operator=(const std::wstring& s) + { + variant_t t(s); + swap(t); + return *this; + } + + variant_t& operator=(const std::string& s) + { + variant_t t(s); + swap(t); + return *this; + } + + //@} + + //! \name safearray Conversions + //@{ + template + variant_t(const safearray_t &x) + { + safearray_t sa( x ); + V_ARRAY(this) = sa.detach(); + V_VT(this) = (VT_ARRAY | safearray_t::traits::vt); + } + + template + variant_t& operator=(const safearray_t &x) throw() + { + variant_t t(x); + swap(t); + return *this; + } + + /** Allow attaching a SAFEARRAY to a variant. + * \code + * safearray_t array; + * variant_t(auto_attach(array.detach())); + * \endcode + */ + variant_t( const impl::auto_attach_t &psa) + { + V_ARRAY(this) = psa.get(); + VARTYPE vt; + SafeArrayGetVartype( psa.get(), &vt) | raise_exception; + V_VT(this) = VARTYPE(VT_ARRAY | vt) ; + } + + + //@} + + //! \name Numeric Conversions + //@{ + + COMET_VARIANT_CONVERTERS_EXPLICIT(short, I2, as_short); + inline operator short() const { return as_short(); } + COMET_VARIANT_CONVERTERS_EXPLICIT(int, I4, as_int); // Do not use VT_INT, because VariantChangeTypeEx does not support VT_INT. + inline operator int() const { return as_int(); } + COMET_VARIANT_CONVERTERS_EXPLICIT(long, I4, as_long); + inline operator long() const { return as_long(); } + COMET_VARIANT_CONVERTERS_EXPLICIT(LONGLONG, I8, as_longlong); + inline operator LONGLONG() const { return as_longlong(); } + COMET_VARIANT_CONVERTERS_EXPLICIT(float, R4, as_float); + inline operator float() const { return as_float(); } + COMET_VARIANT_CONVERTERS_EXPLICIT(double, R8, as_double); + inline operator double() const { return as_double(); } + // These can't have implicit conversions as they cause confusion when + // assigning some common objects from variant_ts. + COMET_VARIANT_CONVERTERS_EXPLICIT(char, I1, as_char); + COMET_VARIANT_CONVERTERS_EXPLICIT(unsigned char, UI1, as_uchar); + COMET_VARIANT_CONVERTERS_EXPLICIT(unsigned short, UI2, as_ushort); + COMET_VARIANT_CONVERTERS_EXPLICIT(unsigned int, UI4, as_uint); + COMET_VARIANT_CONVERTERS_EXPLICIT(unsigned long, UI4, as_ulong); + COMET_VARIANT_CONVERTERS_EXPLICIT(ULONGLONG, UI8, as_ulonglong); + COMET_VARIANT_CONVERTERS_EXPLICIT(DECIMAL, DECIMAL, as_decimal); + + wchar_t as_wchar_t() const { return as_ushort(); } + //@} + // CONVERTERS(DATE, DATE); + + //! \name Currency Conversions + //@{ + + variant_t(const currency_t &x) throw() + { + V_CY(this) = x.get(); + V_VT(this) = VT_CY; + } + + operator currency_t() const + { + return as_curency(); + } + currency_t as_curency() const + { + if (V_VT(this) == VT_CY) return V_CY(this); + variant_t v(*this, VT_CY); + return V_CY(v.get_var()); + } + + variant_t& operator=(const currency_t &x) throw() + { + clear(); + V_CY(this) = x.get(); + V_VT(this) = VT_CY; + return *this; + } + + //@} + + //! \name Date Conversions + //@{ + + variant_t(const datetime_t &x) throw() + { + V_DATE(this) = x.get(); + V_VT(this) = VT_DATE; + } + + operator datetime_t() const + { + if (V_VT(this) == VT_DATE) return datetime_t(V_DATE(this)); + variant_t v(*this, VT_DATE); + return datetime_t(V_DATE(v.get_var())); + } + + variant_t& operator=(const datetime_t &x) throw() + { + clear(); + V_DATE(this) = x.get(); + V_VT(this) = VT_DATE; + return *this; + } + + //@} + /// swap routine, fast with nothrow guarantee + void swap(variant_t& x) throw() + { + ::tagVARIANT t; + memcpy(&t, this, sizeof(VARIANT)); + memcpy(this, &x, sizeof(VARIANT)); + memcpy(&x, &t, sizeof(VARIANT)); + } + + /// Assignment operator + variant_t& operator=(const variant_t& x) throw(com_error) + { + variant_t t(x); + swap(t); + return *this; + } + + //! \name Comparison operators + //@{ + template + bool operator==(const T& x) const throw(com_error) + { + return operator==( variant_t(x) ); + } + + bool operator==(const variant_t& x) const throw(com_error) + { + if (V_VT(&x) != V_VT(this)) { + if (V_VT(this) == VT_EMPTY || V_VT(&x) == VT_EMPTY) return false; + variant_t tmp(x, V_VT(this), std::nothrow); + if (V_VT(&tmp) != V_VT(this)) return false; + return VARCMP_EQ == (impl::var_cmp(const_cast(get_var()), const_cast(tmp.get_var()), GetThreadLocale(), 0) | raise_exception) ; + } else { + switch (impl::var_cmp(const_cast(get_var()), const_cast(x.get_var()), GetThreadLocale(), 0)) + { + case VARCMP_EQ: + case VARCMP_NULL: + return true; + default: + return false; + } + } + } + + template + bool operator!=(const T& x) const throw(com_error) + { + return !operator==(variant_t(x)); + } + + bool operator!=(const variant_t& x) const throw(com_error) + { + return !operator==(x); + } + + template + bool operator<(const T& x) const throw(com_error) + { + return operator<(variant_t(x)); + } + + bool operator<(const variant_t& x) const throw(com_error) + { + if (V_VT(&x) != V_VT(this)) { + return VARCMP_LT == (impl::var_cmp(const_cast(get_var()), const_cast(variant_t(x, V_VT(this)).get_var()), GetThreadLocale(), 0) | raise_exception); + } else { + return VARCMP_LT == (impl::var_cmp(const_cast(get_var()), const_cast(x.get_var()), GetThreadLocale(), 0) | raise_exception); + } + } + + template + bool operator<=(const T& x) const throw(com_error) + { + return operator<=(variant_t(x)); + } + + template + bool operator>(const T& x) const throw(com_error) + { + return operator>(variant_t(x)); + } + + bool operator>(const variant_t& x) const throw(com_error) + { + if (V_VT(&x) != V_VT(this)) { + return VARCMP_GT == (impl::var_cmp(const_cast(get_var()), const_cast(variant_t(x, V_VT(this)).get_var()), GetThreadLocale(), 0) | raise_exception); + } else { + return VARCMP_GT == (impl::var_cmp(const_cast(get_var()), const_cast(x.get_var()), GetThreadLocale(), 0) | raise_exception); + } + } + + bool operator<=(const variant_t& x) const throw(com_error) + { + return !operator>(x); + } + + template + bool operator>=(const T& x) const throw(com_error) + { + return operator>=(variant_t(x)); + } + + bool operator>=(const variant_t& x) const throw(com_error) + { + return !operator<(x); + } + + //@} + + //! \name Mathematical operators + //@{ + COMET_VARIANT_OPERATOR(+,Add); + COMET_VARIANT_OPERATOR(-,Sub); + COMET_VARIANT_OPERATOR(*,Mul); + COMET_VARIANT_OPERATOR(/,Div); + COMET_VARIANT_OPERATOR(&,And); + COMET_VARIANT_OPERATOR(|,Or); + COMET_VARIANT_OPERATOR(^,Xor); + COMET_VARIANT_OPERATOR(%,Mod); + + variant_t operator-() const + { + VARIANT t; + VarNeg(const_cast(get_var()), &t) | raise_exception; + return auto_attach(t); + } + + void change_type(VARTYPE vartype) throw(com_error) + { + if (vartype != V_VT(this)) + ::VariantChangeTypeEx(get_var(), + get_var(), + GetThreadLocale(), + 0, vartype) | raise_exception; + } + + //@} + + //! Is variant a BSTR + bool is_string() const + { + return VT_BSTR == get_vt(true); + } + + //! Is variant an IDispatch or IUnknown pointer? + bool is_object() const + { + return VT_UNKNOWN == get_vt(true) || VT_DISPATCH == get_vt(true); + } + + /*! Is variant empty. + * This compares strictly to VT_EMPTY. + */ + bool is_empty() const throw() + { + return VT_EMPTY == get_vt(); + } + /*! Is variant 'NULL'. + * This compares strictly to VT_NULL. + */ + bool is_null() const throw() + { + return VT_NULL == get_vt(); + } + + /**! Is variant Nothing. + * Is this a NULL pointer, empty, or null. + * This returns true if the value would cleanly try_cast to a NULL + * com_ptr. + */ + bool is_nothing() const throw() + { + switch (get_vt()) { + case VT_DISPATCH: return NULL == V_DISPATCH(&get()); + case VT_UNKNOWN: return NULL == V_UNKNOWN(&get()); + case VT_DISPATCH|VT_BYREF: return NULL == *V_DISPATCHREF(&get()); + case VT_UNKNOWN|VT_BYREF: return NULL == *V_UNKNOWNREF(&get()); + case VT_EMPTY: + case VT_NULL: return true; + } + return false; + } + + + //! \name Accessor Functions + //@{ + const VARIANT& get() const throw() + { + return *get_var(); + } + + VARTYPE get_vt() const throw() + { + return VARTYPE(V_VT(this)); + } + + VARTYPE get_vt(bool ignore_byref) const throw() + { + return ignore_byref ? VARTYPE(V_VT(this) & ~VT_BYREF) : VARTYPE(V_VT(this)); + } + + static VARIANT detach(variant_t& v) throw() + { + return v.detach(); + } + + VARIANT detach() throw() + { + VARIANT r = *get_var(); + V_VT(this) = VT_EMPTY; + return r; + } + + static const variant_t& create_const_reference(const VARIANT& x) + { + return *reinterpret_cast(&x); + } + + static variant_t& create_reference(VARIANT& x) + { + return *reinterpret_cast(&x); + } + + //! [in] adapter. + /*! + Used when calling raw interfaces that require an [in] VARIANT argument. + + \code + variant_t v; + HRESULT hr = pRawInterface->raw_Method(v.in()); + \endcode + + Only use this wrapper when forced to deal with raw interface. + */ + VARIANT in() const throw() + { + return *get_var(); + } + + //! [in] adapter. + /*! + Used when calling raw interfaces that require an [in] VARIANT* argument. + + \code + variant_t v; + HRESULT hr = pRawInterface->raw_Method(v.in_ptr()); + \endcode + + Only use this wrapper when forced to deal with raw interface. + */ + VARIANT* in_ptr() const throw() + { + return const_cast(get_var()); + } + + //! [out] adapter. + /*! + Used when calling raw interfaces that require an [out] VARIANT * argument. + + \code + variant_t v; + HRESULT hr = pRawInterface->raw_MethodThatReturnsVariant(v.out()); + \endcode + + Only use this wrapper when forced to deal with raw interface. + */ + VARIANT* out() throw() + { + clear(); + new (this) variant_t(); + return get_var(); + } + + //! [in, out] adapter. + /*! + Used when calling raw interfaces that require an [in, out] VARIANT * argument. + + \code + variant_t v; + HRESULT hr = pRawInterface->raw_MethodThatChangesVariant(v.inout()); + \endcode + + Only use this wrapper when forced to deal with raw interface. + */ + VARIANT* inout() throw() + { + return get_var(); + } + //@} + + private: +#define __COMET_VARAIANT_OUT(vartype) case VT_##vartype: os << V_##vartype(this); break +#define __COMET_VARAIANT_OUT_CAST(vartype,cast) case VT_##vartype: os << cast(V_##vartype(this)); break + template + std::basic_ostream &output(std::basic_ostream &os) const + { + switch (V_VT(this)) + { + __COMET_VARAIANT_OUT_CAST(I1, short); + __COMET_VARAIANT_OUT(I2); + __COMET_VARAIANT_OUT(I4); + __COMET_VARAIANT_OUT(INT); + __COMET_VARAIANT_OUT_CAST(UI1, (unsigned short)); + __COMET_VARAIANT_OUT(UI2); + __COMET_VARAIANT_OUT(UI4); + __COMET_VARAIANT_OUT(UINT); + __COMET_VARAIANT_OUT(R4); + __COMET_VARAIANT_OUT(R8); +// __COMET_VARAIANT_OUT_CAST(CY, currency_t::create_const_reference); +// __COMET_VARAIANT_OUT_CAST(DATE, datetime_t::create_const_reference); + default: + os << std::basic_string(*this); + break; + } + return os; + } +#undef __COMET_VARAIANT_OUT + public: + friend + std::basic_ostream &operator<<(std::basic_ostream &os, const variant_t &val) + { + return val.output(os); + } + + friend + std::basic_ostream &operator<<(std::basic_ostream &os, const variant_t &val) + { + return val.output(os); + } + + private: + const VARIANT* get_var() const throw() + { +#ifndef __BORLANDC__ + return static_cast(this); +#else + return reinterpret_cast(this); +#endif + } + + VARIANT* get_var() throw() + { +#ifdef __BORLANDC__ +#if __BORLANDC__ >= 0x0551 + return reinterpret_cast(this); +#else + return static_cast(this); +#endif +#else + return reinterpret_cast(this); +#endif + } + }; + //@} + + COMET_VARIANT_FRIENDS(short); + COMET_VARIANT_FRIENDS(int); + COMET_VARIANT_FRIENDS(long); + COMET_VARIANT_FRIENDS(float); + COMET_VARIANT_FRIENDS(double); + + COMET_VARIANT_FRIENDS(const char*); + COMET_VARIANT_FRIENDS(const wchar_t*); + + COMET_VARIANT_FRIENDS(const std::wstring&); + COMET_VARIANT_FRIENDS(const std::string&); + + COMET_VARIANT_FRIENDS(const DECIMAL&); + +} // namespace + +#include +#include + +namespace comet{ + template inline void variant_t::create(const com_ptr& x) throw() + { + com_ptr< ::IDispatch > p( com_cast(x) ); + if (p != 0) { + V_VT(this) = VT_DISPATCH; + V_DISPATCH(this) = p.detach(); + } else { + V_VT(this) = VT_UNKNOWN; +// VTT_(punkVal) = static_cast<::IUnknown*>(com_ptr(x).detach()); + com_ptr< ::IUnknown > p( com_cast(x) ); + V_UNKNOWN(this) = p.detach(); + } + } + +} + +namespace std { + template<> inline void swap(comet::variant_t& x, comet::variant_t& y) COMET_STD_SWAP_NOTHROW + { + x.swap(y); + } +} + +#undef COMET_VARIANT_CONVERTERS +#undef COMET_VARIANT_CONVERTERS_EX_ +#undef COMET_VARIANT_CONVERTERS_EXPLICIT +#undef COMET_VARIANT_OPERATOR +#undef COMET_VARIANT_FRIENDS + +namespace comet { + /*! \addtogroup COMType + */ + //@{ + + inline bool operator!=(const bstr_t& b, const variant_t& v) + { + return v != b; + } + + inline bool operator==(const bstr_t& b, const variant_t& v) + { + return v == b; + } + + inline bool operator<(const bstr_t& b, const variant_t& v) + { + return v > b; + } + + inline bool operator>(const bstr_t& b, const variant_t& v) + { + return v < b; + } + + inline bool operator<=(const bstr_t& b, const variant_t& v) + { + return v >= b; + } + + inline bool operator>=(const bstr_t& b, const variant_t& v) + { + return v <= b; + } + //@} +} + +#pragma warning(pop) + +#endif diff --git a/EyeTab_SP2/comet/variant_iterator.h b/EyeTab_SP2/comet/variant_iterator.h new file mode 100644 index 0000000..618df94 --- /dev/null +++ b/EyeTab_SP2/comet/variant_iterator.h @@ -0,0 +1,149 @@ +/** \file + * Standard C++ iterators wrapping IEnumVARIANT objects. + */ +/* + * Copyright © 2000 Sofus Mortensen + * + * This material is provided "as is", with absolutely no warranty + * expressed or implied. Any use is at your own risk. Permission to + * use or copy this software for any purpose is hereby granted without + * fee, provided the above notices are retained on all copies. + * Permission to modify the code and to distribute modified code is + * granted, provided the above notices are retained, and a notice that + * the code was modified is included with the above copyright notice. + * + * This header is part of Comet version 2. + * https://github.com/alamaison/comet + */ + +#ifndef COMET_VARIANT_ITERATOR_H +#define COMET_VARIANT_ITERATOR_H + +#include + +#include +#include + +#include + +namespace comet { + + /** \class variant_iterator enum.h comet/enum.h + * STL style iterator for IEnumVariant interface. + */ + class variant_iterator + { + com_ptr enum_; + variant_t ce_; + public: + /** Constructor. + */ + variant_iterator( const com_ptr& e ) : enum_(e) { + next(); + } + + variant_iterator() {} + + /** Move to next element. + */ + variant_iterator& operator++() { + next(); + return *this; + } + + bool operator!=(const variant_iterator& v) { + if (!v.enum_.is_null()) + throw std::logic_error( + "variant_iterator comparison does not work"); + + return !enum_.is_null(); + } + + /** Move to next element (post increment). + */ + variant_iterator operator++(int) { + variant_iterator t(*this); + operator++(); + return t; + } + + /** Current element. + */ + variant_t& operator*() { + return ce_; + } + private: + void next() { + if (enum_) { + unsigned long x = 0; + enum_->Next(1, ce_.out(), &x) | raise_exception; + if (x == 0) enum_ = 0; + } + } + }; + + /** \class itf_iterator enum.h comet/enum.h + * STL style Iterator for IEnumVARIANT interface returning a contained + * interface pointer. + */ + template class itf_iterator + { + com_ptr enum_; + com_ptr p_; + public: + /** Constructor. + */ + itf_iterator( const com_ptr& e ) : enum_(e) { + next(); + } + + itf_iterator() {} + + /** Move to next element. + */ + itf_iterator& operator++() { + next(); + return *this; + } + + bool operator!=(const itf_iterator& v) { + if (v.enum_) + throw std::logic_error( + "itf_iterator comparison does not work"); + + return enum_ != 0; + } + + /** Move to next element. + */ + itf_iterator operator++(int) { + itf_iterator t(*this); + operator++(); + return t; + } + + /** Access element. + */ + com_ptr& operator*() { + return p_; + } + private: + void next() { + if (enum_) { + unsigned long x = 0; + variant_t v; + enum_->Next(1, v.out(), &x) | raise_exception; + if (x == 0) { + enum_ = 0; + p_ = 0; + } + else { + p_ = try_cast(v); + } + } + } + }; + +} + +#endif diff --git a/EyeTab_SP2/comet_task_ptr.h b/EyeTab_SP2/comet_task_ptr.h new file mode 100644 index 0000000..62fe384 --- /dev/null +++ b/EyeTab_SP2/comet_task_ptr.h @@ -0,0 +1,78 @@ +#ifndef comet_task_ptr_h__ +#define comet_task_ptr_h__ + +#include + +namespace comet { + template + class task_ptr { + public: + task_ptr() : _ptr(0) {} + task_ptr(T* ptr) : _ptr(ptr) {} + + task_ptr( const task_ptr& other ); // non construction-copyable + task_ptr( task_ptr&& other ); // non construction-movable + task_ptr& operator=( const task_ptr& ); // non copyable + task_ptr& operator=( task_ptr&& ); // non movable + + ~task_ptr() { + free(); + } + + void free() { + if (_ptr) { + CoTaskMemFree(_ptr); + } + _ptr = 0; + } + + bool alloc(size_t size) { + free(); + _ptr = ::CoTaskMemAlloc(size); + return _ptr != NULL; + } + + bool realloc(size_t size) { + _ptr = ::CoTaskMemRealloc(_ptr, size); + return _ptr != NULL; + } + + T* in() { + return _ptr; + } + + T** inout() { + return &_ptr; + } + + T** out() { + free(); + return &_ptr; + } + + typedef task_ptr _Myt; + _TYPEDEF_BOOL_TYPE; + _OPERATOR_BOOL() const _NOEXCEPT + { // test for non-null pointer + return (_ptr != 0 ? _CONVERTIBLE_TO_TRUE : 0); + } + + T& operator[](size_t i) { + return _ptr[i]; + } + const T& operator[](size_t i) const { + return _ptr[i]; + } + T* operator->() { + return _ptr; + } + T operator*() { + return _ptr; + } + + private: + T* _ptr; + }; +} + +#endif // comet_task_ptr_h__ diff --git a/EyeTab_SP2/format.cc b/EyeTab_SP2/format.cc new file mode 100644 index 0000000..8bb7c6b --- /dev/null +++ b/EyeTab_SP2/format.cc @@ -0,0 +1,733 @@ +/* + String formatting library for C++ + + Copyright (c) 2012, Victor Zverovich + All rights reserved. + + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, this + list of conditions and the following disclaimer. + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR + ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +// Disable useless MSVC warnings. +#undef _CRT_SECURE_NO_WARNINGS +#define _CRT_SECURE_NO_WARNINGS +#undef _SCL_SECURE_NO_WARNINGS +#define _SCL_SECURE_NO_WARNINGS + +#include "format.h" + +#include +#include +#include + +using fmt::ULongLong; + +namespace { + +#ifndef _MSC_VER + +inline int SignBit(double value) { + // When compiled in C++11 mode signbit is no longer a macro but a function + // defined in namespace std and the macro is undefined. + using namespace std; + return signbit(value); +} + +inline int IsInf(double x) { +#ifdef isinf + return isinf(x); +#else + return std::isinf(x); +#endif +} + +#define FMT_SNPRINTF snprintf + +#else // _MSC_VER + +inline int SignBit(double value) { + if (value < 0) return 1; + if (value == value) return 0; + int dec = 0, sign = 0; + char buffer[2]; // The buffer size must be >= 2 or _ecvt_s will fail. + _ecvt_s(buffer, sizeof(buffer), value, 0, &dec, &sign); + return sign; +} + +inline int IsInf(double x) { return !_finite(x); } + +inline int FMT_SNPRINTF(char *buffer, size_t size, const char *format, ...) { + va_list args; + va_start(args, format); + int result = vsnprintf_s(buffer, size, _TRUNCATE, format, args); + va_end(args); + return result; +} + +#endif // _MSC_VER + +const char RESET_COLOR[] = "\x1b[0m"; +} + +template +int fmt::internal::CharTraits::FormatFloat( + char *buffer, std::size_t size, const char *format, + unsigned width, int precision, T value) { + if (width == 0) { + return precision < 0 ? + FMT_SNPRINTF(buffer, size, format, value) : + FMT_SNPRINTF(buffer, size, format, precision, value); + } + return precision < 0 ? + FMT_SNPRINTF(buffer, size, format, width, value) : + FMT_SNPRINTF(buffer, size, format, width, precision, value); +} + +template +int fmt::internal::CharTraits::FormatFloat( + wchar_t *buffer, std::size_t size, const wchar_t *format, + unsigned width, int precision, T value) { + if (width == 0) { + return precision < 0 ? + swprintf(buffer, size, format, value) : + swprintf(buffer, size, format, precision, value); + } + return precision < 0 ? + swprintf(buffer, size, format, width, value) : + swprintf(buffer, size, format, width, precision, value); +} + +const char fmt::internal::DIGITS[] = + "0001020304050607080910111213141516171819" + "2021222324252627282930313233343536373839" + "4041424344454647484950515253545556575859" + "6061626364656667686970717273747576777879" + "8081828384858687888990919293949596979899"; + +#define FMT_POWERS_OF_10(factor) \ + factor * 10, \ + factor * 100, \ + factor * 1000, \ + factor * 10000, \ + factor * 100000, \ + factor * 1000000, \ + factor * 10000000, \ + factor * 100000000, \ + factor * 1000000000 + +const uint32_t fmt::internal::POWERS_OF_10_32[] = {0, FMT_POWERS_OF_10(1)}; +const uint64_t fmt::internal::POWERS_OF_10_64[] = { + 0, + FMT_POWERS_OF_10(1), + FMT_POWERS_OF_10(ULongLong(1000000000)), + // Multiply several constants instead of using a single long long constants + // to avoid warnings about C++98 not supporting long long. + ULongLong(1000000000) * ULongLong(1000000000) * 10 +}; + +void fmt::internal::ReportUnknownType(char code, const char *type) { + if (std::isprint(static_cast(code))) { + throw fmt::FormatError(fmt::str( + fmt::Format("unknown format code '{}' for {}") << code << type)); + } + throw fmt::FormatError( + fmt::str(fmt::Format("unknown format code '\\x{:02x}' for {}") + << static_cast(code) << type)); +} + + +// Fills the padding around the content and returns the pointer to the +// content area. +template +typename fmt::BasicWriter::CharPtr + fmt::BasicWriter::FillPadding(CharPtr buffer, + unsigned total_size, std::size_t content_size, wchar_t fill) { + std::size_t padding = total_size - content_size; + std::size_t left_padding = padding / 2; + Char fill_char = static_cast(fill); + std::fill_n(buffer, left_padding, fill_char); + buffer += left_padding; + CharPtr content = buffer; + std::fill_n(buffer + content_size, padding - left_padding, fill_char); + return content; +} + +template +typename fmt::BasicWriter::CharPtr + fmt::BasicWriter::PrepareFilledBuffer( + unsigned size, const AlignSpec &spec, char sign) { + unsigned width = spec.width(); + if (width <= size) { + CharPtr p = GrowBuffer(size); + *p = sign; + return p + size - 1; + } + CharPtr p = GrowBuffer(width); + CharPtr end = p + width; + Alignment align = spec.align(); + // TODO: error if fill is not convertible to Char + Char fill = static_cast(spec.fill()); + if (align == ALIGN_LEFT) { + *p = sign; + p += size; + std::fill(p, end, fill); + } else if (align == ALIGN_CENTER) { + p = FillPadding(p, width, size, fill); + *p = sign; + p += size; + } else { + if (align == ALIGN_NUMERIC) { + if (sign) { + *p++ = sign; + --size; + } + } else { + *(end - size) = sign; + } + std::fill(p, end - size, fill); + p = end; + } + return p - 1; +} + +template +template +void fmt::BasicWriter::FormatDouble( + T value, const FormatSpec &spec, int precision) { + // Check type. + char type = spec.type(); + bool upper = false; + switch (type) { + case 0: + type = 'g'; + break; + case 'e': case 'f': case 'g': + break; + case 'F': +#ifdef _MSC_VER + // MSVC's printf doesn't support 'F'. + type = 'f'; +#endif + // Fall through. + case 'E': case 'G': + upper = true; + break; + default: + internal::ReportUnknownType(type, "double"); + break; + } + + char sign = 0; + // Use SignBit instead of value < 0 because the latter is always + // false for NaN. + if (SignBit(value)) { + sign = '-'; + value = -value; + } else if (spec.sign_flag()) { + sign = spec.plus_flag() ? '+' : ' '; + } + + if (value != value) { + // Format NaN ourselves because sprintf's output is not consistent + // across platforms. + std::size_t size = 4; + const char *nan = upper ? " NAN" : " nan"; + if (!sign) { + --size; + ++nan; + } + CharPtr out = FormatString(nan, size, spec); + if (sign) + *out = sign; + return; + } + + if (IsInf(value)) { + // Format infinity ourselves because sprintf's output is not consistent + // across platforms. + std::size_t size = 4; + const char *inf = upper ? " INF" : " inf"; + if (!sign) { + --size; + ++inf; + } + CharPtr out = FormatString(inf, size, spec); + if (sign) + *out = sign; + return; + } + + std::size_t offset = buffer_.size(); + unsigned width = spec.width(); + if (sign) { + buffer_.reserve(buffer_.size() + (std::max)(width, 1u)); + if (width > 0) + --width; + ++offset; + } + + // Build format string. + enum { MAX_FORMAT_SIZE = 10}; // longest format: %#-*.*Lg + Char format[MAX_FORMAT_SIZE]; + Char *format_ptr = format; + *format_ptr++ = '%'; + unsigned width_for_sprintf = width; + if (spec.hash_flag()) + *format_ptr++ = '#'; + if (spec.align() == ALIGN_CENTER) { + width_for_sprintf = 0; + } else { + if (spec.align() == ALIGN_LEFT) + *format_ptr++ = '-'; + if (width != 0) + *format_ptr++ = '*'; + } + if (precision >= 0) { + *format_ptr++ = '.'; + *format_ptr++ = '*'; + } + if (internal::IsLongDouble::VALUE) + *format_ptr++ = 'L'; + *format_ptr++ = type; + *format_ptr = '\0'; + + // Format using snprintf. + Char fill = static_cast(spec.fill()); + for (;;) { + std::size_t size = buffer_.capacity() - offset; + Char *start = &buffer_[offset]; + int n = internal::CharTraits::FormatFloat( + start, size, format, width_for_sprintf, precision, value); + if (n >= 0 && offset + n < buffer_.capacity()) { + if (sign) { + if ((spec.align() != ALIGN_RIGHT && spec.align() != ALIGN_DEFAULT) || + *start != ' ') { + *(start - 1) = sign; + sign = 0; + } else { + *(start - 1) = fill; + } + ++n; + } + if (spec.align() == ALIGN_CENTER && + spec.width() > static_cast(n)) { + unsigned width = spec.width(); + CharPtr p = GrowBuffer(width); + std::copy(p, p + n, p + (width - n) / 2); + FillPadding(p, spec.width(), n, fill); + return; + } + if (spec.fill() != ' ' || sign) { + while (*start == ' ') + *start++ = fill; + if (sign) + *(start - 1) = sign; + } + GrowBuffer(n); + return; + } + buffer_.reserve(n >= 0 ? offset + n + 1 : 2 * buffer_.capacity()); + } +} + +// Throws Exception(message) if format contains '}', otherwise throws +// FormatError reporting unmatched '{'. The idea is that unmatched '{' +// should override other errors. +template +void fmt::BasicFormatter::ReportError( + const Char *s, StringRef message) const { + for (int num_open_braces = num_open_braces_; *s; ++s) { + if (*s == '{') { + ++num_open_braces; + } else if (*s == '}') { + if (--num_open_braces == 0) + throw fmt::FormatError(message); + } + } + throw fmt::FormatError("unmatched '{' in format"); +} + +// Parses an unsigned integer advancing s to the end of the parsed input. +// This function assumes that the first character of s is a digit. +template +unsigned fmt::BasicFormatter::ParseUInt(const Char *&s) const { + assert('0' <= *s && *s <= '9'); + unsigned value = 0; + do { + unsigned new_value = value * 10 + (*s++ - '0'); + if (new_value < value) // Check if value wrapped around. + ReportError(s, "number is too big in format"); + value = new_value; + } while ('0' <= *s && *s <= '9'); + return value; +} + +template +inline const typename fmt::BasicFormatter::Arg + &fmt::BasicFormatter::ParseArgIndex(const Char *&s) { + unsigned arg_index = 0; + if (*s < '0' || *s > '9') { + if (*s != '}' && *s != ':') + ReportError(s, "invalid argument index in format string"); + if (next_arg_index_ < 0) { + ReportError(s, + "cannot switch from manual to automatic argument indexing"); + } + arg_index = next_arg_index_++; + } else { + if (next_arg_index_ > 0) { + ReportError(s, + "cannot switch from automatic to manual argument indexing"); + } + next_arg_index_ = -1; + arg_index = ParseUInt(s); + } + if (arg_index >= args_.size()) + ReportError(s, "argument index is out of range in format"); + return *args_[arg_index]; +} + +template +void fmt::BasicFormatter::CheckSign(const Char *&s, const Arg &arg) { + char sign = static_cast(*s); + if (arg.type > LAST_NUMERIC_TYPE) { + ReportError(s, + Format("format specifier '{}' requires numeric argument") << sign); + } + if (arg.type == UINT || arg.type == ULONG || arg.type == ULONG_LONG) { + ReportError(s, + Format("format specifier '{}' requires signed argument") << sign); + } + ++s; +} + +template +void fmt::BasicFormatter::DoFormat() { + const Char *start = format_; + format_ = 0; + next_arg_index_ = 0; + const Char *s = start; + BasicWriter &writer = *writer_; + while (*s) { + Char c = *s++; + if (c != '{' && c != '}') continue; + if (*s == c) { + writer.buffer_.append(start, s); + start = ++s; + continue; + } + if (c == '}') + throw FormatError("unmatched '}' in format"); + num_open_braces_= 1; + writer.buffer_.append(start, s - 1); + + const Arg &arg = ParseArgIndex(s); + + FormatSpec spec; + int precision = -1; + if (*s == ':') { + ++s; + + // Parse fill and alignment. + if (Char c = *s) { + const Char *p = s + 1; + spec.align_ = ALIGN_DEFAULT; + do { + switch (*p) { + case '<': + spec.align_ = ALIGN_LEFT; + break; + case '>': + spec.align_ = ALIGN_RIGHT; + break; + case '=': + spec.align_ = ALIGN_NUMERIC; + break; + case '^': + spec.align_ = ALIGN_CENTER; + break; + } + if (spec.align_ != ALIGN_DEFAULT) { + if (p != s) { + if (c == '}') break; + if (c == '{') + ReportError(s, "invalid fill character '{'"); + s += 2; + spec.fill_ = c; + } else ++s; + if (spec.align_ == ALIGN_NUMERIC && arg.type > LAST_NUMERIC_TYPE) + ReportError(s, "format specifier '=' requires numeric argument"); + break; + } + } while (--p >= s); + } + + // Parse sign. + switch (*s) { + case '+': + CheckSign(s, arg); + spec.flags_ |= SIGN_FLAG | PLUS_FLAG; + break; + case '-': + CheckSign(s, arg); + break; + case ' ': + CheckSign(s, arg); + spec.flags_ |= SIGN_FLAG; + break; + } + + if (*s == '#') { + if (arg.type > LAST_NUMERIC_TYPE) + ReportError(s, "format specifier '#' requires numeric argument"); + spec.flags_ |= HASH_FLAG; + ++s; + } + + // Parse width and zero flag. + if ('0' <= *s && *s <= '9') { + if (*s == '0') { + if (arg.type > LAST_NUMERIC_TYPE) + ReportError(s, "format specifier '0' requires numeric argument"); + spec.align_ = ALIGN_NUMERIC; + spec.fill_ = '0'; + } + // Zero may be parsed again as a part of the width, but it is simpler + // and more efficient than checking if the next char is a digit. + unsigned value = ParseUInt(s); + if (value > INT_MAX) + ReportError(s, "number is too big in format"); + spec.width_ = value; + } + + // Parse precision. + if (*s == '.') { + ++s; + precision = 0; + if ('0' <= *s && *s <= '9') { + unsigned value = ParseUInt(s); + if (value > INT_MAX) + ReportError(s, "number is too big in format"); + precision = value; + } else if (*s == '{') { + ++s; + ++num_open_braces_; + const Arg &precision_arg = ParseArgIndex(s); + ULongLong value = 0; + switch (precision_arg.type) { + case INT: + if (precision_arg.int_value < 0) + ReportError(s, "negative precision in format"); + value = precision_arg.int_value; + break; + case UINT: + value = precision_arg.uint_value; + break; + case LONG: + if (precision_arg.long_value < 0) + ReportError(s, "negative precision in format"); + value = precision_arg.long_value; + break; + case ULONG: + value = precision_arg.ulong_value; + break; + case LONG_LONG: + if (precision_arg.long_long_value < 0) + ReportError(s, "negative precision in format"); + value = precision_arg.long_long_value; + break; + case ULONG_LONG: + value = precision_arg.ulong_long_value; + break; + default: + ReportError(s, "precision is not integer"); + } + if (value > INT_MAX) + ReportError(s, "number is too big in format"); + precision = static_cast(value); + if (*s++ != '}') + throw FormatError("unmatched '{' in format"); + --num_open_braces_; + } else { + ReportError(s, "missing precision in format"); + } + if (arg.type != DOUBLE && arg.type != LONG_DOUBLE) { + ReportError(s, + "precision specifier requires floating-point argument"); + } + } + + // Parse type. + if (*s != '}' && *s) + spec.type_ = static_cast(*s++); + } + + if (*s++ != '}') + throw FormatError("unmatched '{' in format"); + start = s; + + // Format argument. + switch (arg.type) { + case INT: + FormatInt(arg.int_value, spec); + break; + case UINT: + FormatInt(arg.uint_value, spec); + break; + case LONG: + FormatInt(arg.long_value, spec); + break; + case ULONG: + FormatInt(arg.ulong_value, spec); + break; + case LONG_LONG: + FormatInt(arg.long_long_value, spec); + break; + case ULONG_LONG: + FormatInt(arg.ulong_long_value, spec); + break; + case DOUBLE: + writer.FormatDouble(arg.double_value, spec, precision); + break; + case LONG_DOUBLE: + writer.FormatDouble(arg.long_double_value, spec, precision); + break; + case CHAR: { + if (spec.type_ && spec.type_ != 'c') + internal::ReportUnknownType(spec.type_, "char"); + typedef typename BasicWriter::CharPtr CharPtr; + CharPtr out = CharPtr(); + if (spec.width_ > 1) { + Char fill = static_cast(spec.fill()); + out = writer.GrowBuffer(spec.width_); + if (spec.align_ == ALIGN_RIGHT) { + std::fill_n(out, spec.width_ - 1, fill); + out += spec.width_ - 1; + } else if (spec.align_ == ALIGN_CENTER) { + out = writer.FillPadding(out, spec.width_, 1, fill); + } else { + std::fill_n(out + 1, spec.width_ - 1, fill); + } + } else { + out = writer.GrowBuffer(1); + } + *out = arg.int_value; + break; + } + case STRING: { + if (spec.type_ && spec.type_ != 's') + internal::ReportUnknownType(spec.type_, "string"); + const Char *str = arg.string.value; + std::size_t size = arg.string.size; + if (size == 0) { + if (!str) + throw FormatError("string pointer is null"); + if (*str) + size = std::char_traits::length(str); + } + writer.FormatString(str, size, spec); + break; + } + case POINTER: + if (spec.type_ && spec.type_ != 'p') + internal::ReportUnknownType(spec.type_, "pointer"); + spec.flags_= HASH_FLAG; + spec.type_ = 'x'; + FormatInt(reinterpret_cast(arg.pointer_value), spec); + break; + case CUSTOM: + if (spec.type_) + internal::ReportUnknownType(spec.type_, "object"); + arg.custom.format(writer, arg.custom.value, spec); + break; + default: + assert(false); + break; + } + } + writer.buffer_.append(start, s); +} + +void fmt::ColorWriter::operator()(const fmt::BasicWriter &w) const { + char escape[] = "\x1b[30m"; + escape[3] = '0' + color_; + std::fputs(escape, stdout); + std::fwrite(w.data(), 1, w.size(), stdout); + std::fputs(RESET_COLOR, stdout); +} + +// Explicit instantiations for char. + +template void fmt::BasicWriter::FormatDouble( + double value, const FormatSpec &spec, int precision); + +template void fmt::BasicWriter::FormatDouble( + long double value, const FormatSpec &spec, int precision); + +template fmt::BasicWriter::CharPtr + fmt::BasicWriter::FillPadding(CharPtr buffer, + unsigned total_size, std::size_t content_size, wchar_t fill); + +template fmt::BasicWriter::CharPtr + fmt::BasicWriter::PrepareFilledBuffer( + unsigned size, const AlignSpec &spec, char sign); + +template void fmt::BasicFormatter::ReportError( + const char *s, StringRef message) const; + +template unsigned fmt::BasicFormatter::ParseUInt(const char *&s) const; + +template const fmt::BasicFormatter::Arg + &fmt::BasicFormatter::ParseArgIndex(const char *&s); + +template void fmt::BasicFormatter::CheckSign( + const char *&s, const Arg &arg); + +template void fmt::BasicFormatter::DoFormat(); + +// Explicit instantiations for wchar_t. + +template void fmt::BasicWriter::FormatDouble( + double value, const FormatSpec &spec, int precision); + +template void fmt::BasicWriter::FormatDouble( + long double value, const FormatSpec &spec, int precision); + +template fmt::BasicWriter::CharPtr + fmt::BasicWriter::FillPadding(CharPtr buffer, + unsigned total_size, std::size_t content_size, wchar_t fill); + +template fmt::BasicWriter::CharPtr + fmt::BasicWriter::PrepareFilledBuffer( + unsigned size, const AlignSpec &spec, char sign); + +template void fmt::BasicFormatter::ReportError( + const wchar_t *s, StringRef message) const; + +template unsigned fmt::BasicFormatter::ParseUInt( + const wchar_t *&s) const; + +template const fmt::BasicFormatter::Arg + &fmt::BasicFormatter::ParseArgIndex(const wchar_t *&s); + +template void fmt::BasicFormatter::CheckSign( + const wchar_t *&s, const Arg &arg); + +template void fmt::BasicFormatter::DoFormat(); diff --git a/EyeTab_SP2/format.h b/EyeTab_SP2/format.h new file mode 100644 index 0000000..c4b91bc --- /dev/null +++ b/EyeTab_SP2/format.h @@ -0,0 +1,1500 @@ +/* + String formatting library for C++ + + Copyright (c) 2012, Victor Zverovich + All rights reserved. + + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, this + list of conditions and the following disclaimer. + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR + ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef FORMAT_H_ +#define FORMAT_H_ + +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#ifdef __GNUC__ +# define FMT_GCC_VERSION (__GNUC__ * 100 + __GNUC_MINOR__) +# define FMT_GCC_EXTENSION __extension__ +#else +# define FMT_GCC_EXTENSION +#endif + +// Compatibility with compilers other than clang. +#ifndef __has_feature +# define __has_feature(x) 0 +# define __has_builtin(x) 0 +#endif + +#ifndef FMT_USE_INITIALIZER_LIST +# define FMT_USE_INITIALIZER_LIST \ + (__has_feature(cxx_generalized_initializers) || \ + (FMT_GCC_VERSION >= 404 && __cplusplus >= 201103) || _MSC_VER >= 1800) +#endif + +#if FMT_USE_INITIALIZER_LIST +# include +#endif + +// Define FMT_USE_NOEXCEPT to make format use noexcept (C++11 feature). +#if FMT_USE_NOEXCEPT || __has_feature(cxx_noexcept) || \ + (FMT_GCC_VERSION >= 408 && __cplusplus >= 201103) +# define FMT_NOEXCEPT(expr) noexcept(expr) +#else +# define FMT_NOEXCEPT(expr) +#endif + +#if _MSC_VER +# pragma warning(push) +# pragma warning(disable: 4521) +#endif + +namespace fmt { + +// Fix the warning about long long on older versions of GCC +// that don't support the diagnostic pragma. +FMT_GCC_EXTENSION typedef long long LongLong; +FMT_GCC_EXTENSION typedef unsigned long long ULongLong; + +namespace internal { + +#if _SECURE_SCL +template +inline stdext::checked_array_iterator CheckPtr(T *ptr, std::size_t size) { + return stdext::checked_array_iterator(ptr, size); +} +#else +template +inline T *CheckPtr(T *ptr, std::size_t) { return ptr; } +#endif + +// A simple array for POD types with the first SIZE elements stored in +// the object itself. It supports a subset of std::vector's operations. +template +class Array { + private: + std::size_t size_; + std::size_t capacity_; + T *ptr_; + T data_[SIZE]; + + void Grow(std::size_t size); + + // Do not implement! + Array(const Array &); + void operator=(const Array &); + + public: + Array() : size_(0), capacity_(SIZE), ptr_(data_) {} + ~Array() { + if (ptr_ != data_) delete [] ptr_; + } + + // Returns the size of this array. + std::size_t size() const { return size_; } + + // Returns the capacity of this array. + std::size_t capacity() const { return capacity_; } + + // Resizes the array. If T is a POD type new elements are not initialized. + void resize(std::size_t new_size) { + if (new_size > capacity_) + Grow(new_size); + size_ = new_size; + } + + void reserve(std::size_t capacity) { + if (capacity > capacity_) + Grow(capacity); + } + + void clear() { size_ = 0; } + + void push_back(const T &value) { + if (size_ == capacity_) + Grow(size_ + 1); + ptr_[size_++] = value; + } + + // Appends data to the end of the array. + void append(const T *begin, const T *end); + + T &operator[](std::size_t index) { return ptr_[index]; } + const T &operator[](std::size_t index) const { return ptr_[index]; } +}; + +template +void Array::Grow(std::size_t size) { + capacity_ = (std::max)(size, capacity_ + capacity_ / 2); + T *p = new T[capacity_]; + std::copy(ptr_, ptr_ + size_, CheckPtr(p, capacity_)); + if (ptr_ != data_) + delete [] ptr_; + ptr_ = p; +} + +template +void Array::append(const T *begin, const T *end) { + std::ptrdiff_t num_elements = end - begin; + if (size_ + num_elements > capacity_) + Grow(num_elements); + std::copy(begin, end, CheckPtr(ptr_, capacity_) + size_); + size_ += num_elements; +} + +template +class CharTraits; + +template +class BasicCharTraits { + public: +#if _SECURE_SCL + typedef stdext::checked_array_iterator CharPtr; +#else + typedef Char *CharPtr; +#endif +}; + +template <> +class CharTraits : public BasicCharTraits { + private: + // Conversion from wchar_t to char is not supported. + static char ConvertChar(wchar_t); + + public: + typedef const wchar_t *UnsupportedStrType; + + static char ConvertChar(char value) { return value; } + + template + static int FormatFloat(char *buffer, std::size_t size, + const char *format, unsigned width, int precision, T value); +}; + +template <> +class CharTraits : public BasicCharTraits { + public: + typedef const char *UnsupportedStrType; + + static wchar_t ConvertChar(char value) { return value; } + static wchar_t ConvertChar(wchar_t value) { return value; } + + template + static int FormatFloat(wchar_t *buffer, std::size_t size, + const wchar_t *format, unsigned width, int precision, T value); +}; + +// Selects uint32_t if FitsIn32Bits is true, uint64_t otherwise. +template +struct TypeSelector { typedef uint32_t Type; }; + +template <> +struct TypeSelector { typedef uint64_t Type; }; + +// Checks if a number is negative - used to avoid warnings. +template +struct SignChecker { + template + static bool IsNegative(T) { return false; } +}; + +template <> +struct SignChecker { + template + static bool IsNegative(T value) { return value < 0; } +}; + +// Returns true if value is negative, false otherwise. +// Same as (value < 0) but doesn't produce warnings if T is an unsigned type. +template +inline bool IsNegative(T value) { + return SignChecker::is_signed>::IsNegative(value); +} + +template +struct IntTraits { + // Smallest of uint32_t and uint64_t that is large enough to represent + // all values of T. + typedef typename + TypeSelector::digits <= 32>::Type MainType; +}; + +template +struct IsLongDouble { enum {VALUE = 0}; }; + +template <> +struct IsLongDouble { enum {VALUE = 1}; }; + +void ReportUnknownType(char code, const char *type); + +extern const uint32_t POWERS_OF_10_32[]; +extern const uint64_t POWERS_OF_10_64[]; + +#if FMT_GCC_VERSION >= 400 || __has_builtin(__builtin_clzll) +// Returns the number of decimal digits in n. Leading zeros are not counted +// except for n == 0 in which case CountDigits returns 1. +inline unsigned CountDigits(uint64_t n) { + // Based on http://graphics.stanford.edu/~seander/bithacks.html#IntegerLog10 + // and the benchmark https://github.com/localvoid/cxx-benchmark-count-digits. + uint64_t t = (64 - __builtin_clzll(n | 1)) * 1233 >> 12; + return t - (n < POWERS_OF_10_64[t]) + 1; +} +# if FMT_GCC_VERSION >= 400 || __has_builtin(__builtin_clz) +// Optional version of CountDigits for better performance on 32-bit platforms. +inline unsigned CountDigits(uint32_t n) { + uint32_t t = (32 - __builtin_clz(n | 1)) * 1233 >> 12; + return t - (n < POWERS_OF_10_32[t]) + 1; +} +# endif +#else +// Slower version of CountDigits used when __builtin_clz is not available. +inline unsigned CountDigits(uint64_t n) { + unsigned count = 1; + for (;;) { + // Integer division is slow so do it for a group of four digits instead + // of for every digit. The idea comes from the talk by Alexandrescu + // "Three Optimization Tips for C++". See speed-test for a comparison. + if (n < 10) return count; + if (n < 100) return count + 1; + if (n < 1000) return count + 2; + if (n < 10000) return count + 3; + n /= 10000u; + count += 4; + } +} +#endif + +extern const char DIGITS[]; + +template +class FormatterProxy; + +// Formats a decimal unsigned integer value writing into buffer. +template +void FormatDecimal(Char *buffer, UInt value, unsigned num_digits) { + --num_digits; + while (value >= 100) { + // Integer division is slow so do it for a group of two digits instead + // of for every digit. The idea comes from the talk by Alexandrescu + // "Three Optimization Tips for C++". See speed-test for a comparison. + unsigned index = (value % 100) * 2; + value /= 100; + buffer[num_digits] = internal::DIGITS[index + 1]; + buffer[num_digits - 1] = internal::DIGITS[index]; + num_digits -= 2; + } + if (value < 10) { + *buffer = static_cast('0' + value); + return; + } + unsigned index = static_cast(value * 2); + buffer[1] = internal::DIGITS[index + 1]; + buffer[0] = internal::DIGITS[index]; +} +} + +/** + \rst + A string reference. It can be constructed from a C string, ``std::string`` + or as a result of a formatting operation. It is most useful as a parameter + type to allow passing different types of strings in a function, for example:: + + Formatter<> Format(StringRef format); + + Format("{}") << 42; + Format(std::string("{}")) << 42; + Format(Format("{{}}")) << 42; + \endrst + */ +template +class BasicStringRef { + private: + const Char *data_; + mutable std::size_t size_; + + public: + /** + Constructs a string reference object from a C string and a size. + If *size* is zero, which is the default, the size is computed with + `strlen`. + */ + BasicStringRef(const Char *s, std::size_t size = 0) : data_(s), size_(size) {} + + /** + Constructs a string reference from an `std::string` object. + */ + BasicStringRef(const std::basic_string &s) + : data_(s.c_str()), size_(s.size()) {} + + /** + Converts a string reference to an `std::string` object. + */ + operator std::basic_string() const { + return std::basic_string(data_, size()); + } + + /** + Returns the pointer to a C string. + */ + const Char *c_str() const { return data_; } + + /** + Returns the string size. + */ + std::size_t size() const { + if (size_ == 0) size_ = std::char_traits::length(data_); + return size_; + } +}; + +typedef BasicStringRef StringRef; +typedef BasicStringRef WStringRef; + +class FormatError : public std::runtime_error { + public: + explicit FormatError(const std::string &message) + : std::runtime_error(message) {} +}; + +enum Alignment { + ALIGN_DEFAULT, ALIGN_LEFT, ALIGN_RIGHT, ALIGN_CENTER, ALIGN_NUMERIC +}; + +// Flags. +enum { SIGN_FLAG = 1, PLUS_FLAG = 2, HASH_FLAG = 4 }; + +// An empty format specifier. +struct EmptySpec {}; + +// A type specifier. +template +struct TypeSpec : EmptySpec { + Alignment align() const { return ALIGN_DEFAULT; } + unsigned width() const { return 0; } + + bool sign_flag() const { return false; } + bool plus_flag() const { return false; } + bool hash_flag() const { return false; } + + char type() const { return TYPE; } + char fill() const { return ' '; } +}; + +// A width specifier. +struct WidthSpec { + unsigned width_; + // Fill is always wchar_t and cast to char if necessary to avoid having + // two specialization of WidthSpec and its subclasses. + wchar_t fill_; + + WidthSpec(unsigned width, wchar_t fill) : width_(width), fill_(fill) {} + + unsigned width() const { return width_; } + wchar_t fill() const { return fill_; } +}; + +// An alignment specifier. +struct AlignSpec : WidthSpec { + Alignment align_; + + AlignSpec(unsigned width, wchar_t fill, Alignment align = ALIGN_DEFAULT) + : WidthSpec(width, fill), align_(align) {} + + Alignment align() const { return align_; } +}; + +// An alignment and type specifier. +template +struct AlignTypeSpec : AlignSpec { + AlignTypeSpec(unsigned width, wchar_t fill) : AlignSpec(width, fill) {} + + bool sign_flag() const { return false; } + bool plus_flag() const { return false; } + bool hash_flag() const { return false; } + + char type() const { return TYPE; } +}; + +// A full format specifier. +struct FormatSpec : AlignSpec { + unsigned flags_; + char type_; + + FormatSpec(unsigned width = 0, char type = 0, wchar_t fill = ' ') + : AlignSpec(width, fill), flags_(0), type_(type) {} + + bool sign_flag() const { return (flags_ & SIGN_FLAG) != 0; } + bool plus_flag() const { return (flags_ & PLUS_FLAG) != 0; } + bool hash_flag() const { return (flags_ & HASH_FLAG) != 0; } + + char type() const { return type_; } +}; + +// An integer format specifier. +template , typename Char = char> +class IntFormatSpec : public SpecT { + private: + T value_; + + public: + IntFormatSpec(T value, const SpecT &spec = SpecT()) + : SpecT(spec), value_(value) {} + + T value() const { return value_; } +}; + +// A string format specifier. +template +class StrFormatSpec : public AlignSpec { + private: + const T *str_; + + public: + StrFormatSpec(const T *str, unsigned width, wchar_t fill) + : AlignSpec(width, fill), str_(str) {} + + const T *str() const { return str_; } +}; + +/** + Returns an integer format specifier to format the value in base 2. + */ +IntFormatSpec > bin(int value); + +/** + Returns an integer format specifier to format the value in base 8. + */ +IntFormatSpec > oct(int value); + +/** + Returns an integer format specifier to format the value in base 16 using + lower-case letters for the digits above 9. + */ +IntFormatSpec > hex(int value); + +/** + Returns an integer formatter format specifier to format in base 16 using + upper-case letters for the digits above 9. + */ +IntFormatSpec > hexu(int value); + +/** + \rst + Returns an integer format specifier to pad the formatted argument with the + fill character to the specified width using the default (right) numeric + alignment. + + **Example**:: + + std::string s = str(Writer() << pad(hex(0xcafe), 8, '0')); + // s == "0000cafe" + + \endrst + */ +template +IntFormatSpec, Char> pad( + int value, unsigned width, Char fill = ' '); + +#define DEFINE_INT_FORMATTERS(TYPE) \ +inline IntFormatSpec > bin(TYPE value) { \ + return IntFormatSpec >(value, TypeSpec<'b'>()); \ +} \ + \ +inline IntFormatSpec > oct(TYPE value) { \ + return IntFormatSpec >(value, TypeSpec<'o'>()); \ +} \ + \ +inline IntFormatSpec > hex(TYPE value) { \ + return IntFormatSpec >(value, TypeSpec<'x'>()); \ +} \ + \ +inline IntFormatSpec > hexu(TYPE value) { \ + return IntFormatSpec >(value, TypeSpec<'X'>()); \ +} \ + \ +template \ +inline IntFormatSpec > pad( \ + IntFormatSpec > f, unsigned width) { \ + return IntFormatSpec >( \ + f.value(), AlignTypeSpec(width, ' ')); \ +} \ + \ +/* For compatibility with older compilers we provide two overloads for pad, */ \ +/* one that takes a fill character and one that doesn't. In the future this */ \ +/* can be replaced with one overload making the template argument Char */ \ +/* default to char (C++11). */ \ +template \ +inline IntFormatSpec, Char> pad( \ + IntFormatSpec, Char> f, \ + unsigned width, Char fill) { \ + return IntFormatSpec, Char>( \ + f.value(), AlignTypeSpec(width, fill)); \ +} \ + \ +inline IntFormatSpec > pad( \ + TYPE value, unsigned width) { \ + return IntFormatSpec >( \ + value, AlignTypeSpec<0>(width, ' ')); \ +} \ + \ +template \ +inline IntFormatSpec, Char> pad( \ + TYPE value, unsigned width, Char fill) { \ + return IntFormatSpec, Char>( \ + value, AlignTypeSpec<0>(width, fill)); \ +} + +DEFINE_INT_FORMATTERS(int) +DEFINE_INT_FORMATTERS(long) +DEFINE_INT_FORMATTERS(unsigned) +DEFINE_INT_FORMATTERS(unsigned long) +DEFINE_INT_FORMATTERS(LongLong) +DEFINE_INT_FORMATTERS(ULongLong) + +/** + \rst + Returns a string formatter that pads the formatted argument with the fill + character to the specified width using the default (left) string alignment. + + **Example**:: + + std::string s = str(Writer() << pad("abc", 8)); + // s == "abc " + + \endrst + */ +template +inline StrFormatSpec pad( + const Char *str, unsigned width, Char fill = ' ') { + return StrFormatSpec(str, width, fill); +} + +inline StrFormatSpec pad( + const wchar_t *str, unsigned width, char fill = ' ') { + return StrFormatSpec(str, width, fill); +} + +template +class BasicFormatter; + +/** + \rst + This template provides operations for formatting and writing data into + a character stream. The output is stored in a memory buffer that grows + dynamically. + + You can use one of the following typedefs for common character types: + + +---------+----------------------+ + | Type | Definition | + +=========+======================+ + | Writer | BasicWriter | + +---------+----------------------+ + | WWriter | BasicWriter | + +---------+----------------------+ + + **Example**:: + + Writer out; + out << "The answer is " << 42 << "\n"; + out.Format("({:+f}, {:+f})") << -3.14 << 3.14; + + This will write the following output to the ``out`` object: + + .. code-block:: none + + The answer is 42 + (-3.140000, +3.140000) + + The output can be converted to an ``std::string`` with ``out.str()`` or + accessed as a C string with ``out.c_str()``. + \endrst + */ +template +class BasicWriter { + private: + enum { INLINE_BUFFER_SIZE = 500 }; + mutable internal::Array buffer_; // Output buffer. + + friend class BasicFormatter; + + typedef typename internal::CharTraits::CharPtr CharPtr; + +#if _SECURE_SCL + static Char *GetBase(CharPtr p) { return p.base(); } +#else + static Char *GetBase(Char *p) { return p; } +#endif + + static CharPtr FillPadding(CharPtr buffer, + unsigned total_size, std::size_t content_size, wchar_t fill); + + // Grows the buffer by n characters and returns a pointer to the newly + // allocated area. + CharPtr GrowBuffer(std::size_t n) { + std::size_t size = buffer_.size(); + buffer_.resize(size + n); + return internal::CheckPtr(&buffer_[size], n); + } + + CharPtr PrepareFilledBuffer(unsigned size, const EmptySpec &, char sign) { + CharPtr p = GrowBuffer(size); + *p = sign; + return p + size - 1; + } + + CharPtr PrepareFilledBuffer(unsigned size, const AlignSpec &spec, char sign); + + // Formats an integer. + template + void FormatInt(T value, const Spec &spec); + + // Formats a floating-point number (double or long double). + template + void FormatDouble(T value, const FormatSpec &spec, int precision); + + // Formats a string. + template + CharPtr FormatString( + const StringChar *s, std::size_t size, const AlignSpec &spec); + + // This method is private to disallow writing a wide string to a + // char stream and vice versa. If you want to print a wide string + // as a pointer as std::ostream does, cast it to const void*. + // Do not implement! + void operator<<(typename internal::CharTraits::UnsupportedStrType); + + public: + /** + Returns the number of characters written to the output buffer. + */ + std::size_t size() const { return buffer_.size(); } + + /** + Returns a pointer to the output buffer content. No terminating null + character is appended. + */ + const Char *data() const { return &buffer_[0]; } + + /** + Returns a pointer to the output buffer content with terminating null + character appended. + */ + const Char *c_str() const { + std::size_t size = buffer_.size(); + buffer_.reserve(size + 1); + buffer_[size] = '\0'; + return &buffer_[0]; + } + + /** + Returns the content of the output buffer as an `std::string`. + */ + std::basic_string str() const { + return std::basic_string(&buffer_[0], buffer_.size()); + } + + /** + \rst + Formats a string sending the output to the writer. Arguments are + accepted through the returned ``BasicFormatter`` object using inserter + operator ``<<``. + + **Example**:: + + Writer out; + out.Format("Current point:\n"); + out.Format("({:+f}, {:+f})") << -3.14 << 3.14; + + This will write the following output to the ``out`` object: + + .. code-block:: none + + Current point: + (-3.140000, +3.140000) + + The output can be accessed using :meth:`data` or :meth:`c_str`. + + See also `Format String Syntax`_. + \endrst + */ + BasicFormatter Format(StringRef format); + + BasicWriter &operator<<(int value) { + return *this << IntFormatSpec(value); + } + BasicWriter &operator<<(unsigned value) { + return *this << IntFormatSpec(value); + } + BasicWriter &operator<<(long value) { + return *this << IntFormatSpec(value); + } + BasicWriter &operator<<(unsigned long value) { + return *this << IntFormatSpec(value); + } + BasicWriter &operator<<(LongLong value) { + return *this << IntFormatSpec(value); + } + + /** + Formats *value* and writes it to the stream. + */ + BasicWriter &operator<<(ULongLong value) { + return *this << IntFormatSpec(value); + } + + BasicWriter &operator<<(double value) { + FormatDouble(value, FormatSpec(), -1); + return *this; + } + + /** + Formats *value* using the general format for floating-point numbers + (``'g'``) and writes it to the stream. + */ + BasicWriter &operator<<(long double value) { + FormatDouble(value, FormatSpec(), -1); + return *this; + } + + /** + * Writes a character to the stream. + */ + BasicWriter &operator<<(char value) { + *GrowBuffer(1) = value; + return *this; + } + + BasicWriter &operator<<(wchar_t value) { + *GrowBuffer(1) = internal::CharTraits::ConvertChar(value); + return *this; + } + + /** + Writes *value* to the stream. + */ + BasicWriter &operator<<(const fmt::BasicStringRef value) { + const Char *str = value.c_str(); + std::size_t size = value.size(); + std::copy(str, str + size, GrowBuffer(size)); + return *this; + } + + template + BasicWriter &operator<<(const IntFormatSpec &spec) { + internal::CharTraits::ConvertChar(FillChar()); + FormatInt(spec.value(), spec); + return *this; + } + + template + BasicWriter &operator<<(const StrFormatSpec &spec) { + const StringChar *s = spec.str(); + FormatString(s, std::char_traits::length(s), spec); + return *this; + } + + void Write(const std::basic_string &s, const FormatSpec &spec) { + FormatString(s.data(), s.size(), spec); + } + + void Clear() { + buffer_.clear(); + } +}; + +template +template +typename BasicWriter::CharPtr BasicWriter::FormatString( + const StringChar *s, std::size_t size, const AlignSpec &spec) { + CharPtr out = CharPtr(); + if (spec.width() > size) { + out = GrowBuffer(spec.width()); + Char fill = static_cast(spec.fill()); + if (spec.align() == ALIGN_RIGHT) { + std::fill_n(out, spec.width() - size, fill); + out += spec.width() - size; + } else if (spec.align() == ALIGN_CENTER) { + out = FillPadding(out, spec.width(), size, fill); + } else { + std::fill_n(out + size, spec.width() - size, fill); + } + } else { + out = GrowBuffer(size); + } + std::copy(s, s + size, out); + return out; +} + +template +template +void BasicWriter::FormatInt(T value, const Spec &spec) { + unsigned size = 0; + char sign = 0; + typedef typename internal::IntTraits::MainType UnsignedType; + UnsignedType abs_value = value; + if (internal::IsNegative(value)) { + sign = '-'; + ++size; + abs_value = 0 - abs_value; + } else if (spec.sign_flag()) { + sign = spec.plus_flag() ? '+' : ' '; + ++size; + } + switch (spec.type()) { + case 0: case 'd': { + unsigned num_digits = internal::CountDigits(abs_value); + CharPtr p = + PrepareFilledBuffer(size + num_digits, spec, sign) + 1 - num_digits; + internal::FormatDecimal(GetBase(p), abs_value, num_digits); + break; + } + case 'x': case 'X': { + UnsignedType n = abs_value; + bool print_prefix = spec.hash_flag(); + if (print_prefix) size += 2; + do { + ++size; + } while ((n >>= 4) != 0); + Char *p = GetBase(PrepareFilledBuffer(size, spec, sign)); + n = abs_value; + const char *digits = spec.type() == 'x' ? + "0123456789abcdef" : "0123456789ABCDEF"; + do { + *p-- = digits[n & 0xf]; + } while ((n >>= 4) != 0); + if (print_prefix) { + *p-- = spec.type(); + *p = '0'; + } + break; + } + case 'b': case 'B': { + UnsignedType n = abs_value; + bool print_prefix = spec.hash_flag(); + if (print_prefix) size += 2; + do { + ++size; + } while ((n >>= 1) != 0); + Char *p = GetBase(PrepareFilledBuffer(size, spec, sign)); + n = abs_value; + do { + *p-- = '0' + (n & 1); + } while ((n >>= 1) != 0); + if (print_prefix) { + *p-- = spec.type(); + *p = '0'; + } + break; + } + case 'o': { + UnsignedType n = abs_value; + bool print_prefix = spec.hash_flag(); + if (print_prefix) ++size; + do { + ++size; + } while ((n >>= 3) != 0); + Char *p = GetBase(PrepareFilledBuffer(size, spec, sign)); + n = abs_value; + do { + *p-- = '0' + (n & 7); + } while ((n >>= 3) != 0); + if (print_prefix) + *p = '0'; + break; + } + default: + internal::ReportUnknownType(spec.type(), "integer"); + break; + } +} + +template +BasicFormatter BasicWriter::Format(StringRef format) { + BasicFormatter f(*this, format.c_str()); + return f; +} + +typedef BasicWriter Writer; +typedef BasicWriter WWriter; + +// The default formatting function. +template +void Format(BasicWriter &w, const FormatSpec &spec, const T &value) { + std::basic_ostringstream os; + os << value; + w.Write(os.str(), spec); +} + +namespace internal { +// Formats an argument of a custom type, such as a user-defined class. +template +void FormatCustomArg( + BasicWriter &w, const void *arg, const FormatSpec &spec) { + Format(w, spec, *static_cast(arg)); +} +} + +/** + \rst + The :cpp:class:`fmt::BasicFormatter` template provides string formatting + functionality similar to Python's `str.format + `__. + The class provides operator<< for feeding formatting arguments and all + the output is sent to a :cpp:class:`fmt::Writer` object. + \endrst + */ +template +class BasicFormatter { + private: + BasicWriter *writer_; + + enum Type { + // Numeric types should go first. + INT, UINT, LONG, ULONG, LONG_LONG, ULONG_LONG, DOUBLE, LONG_DOUBLE, + LAST_NUMERIC_TYPE = LONG_DOUBLE, + CHAR, STRING, WSTRING, POINTER, CUSTOM + }; + + typedef void (*FormatFunc)( + BasicWriter &w, const void *arg, const FormatSpec &spec); + + // A format argument. + class Arg { + private: + // This method is private to disallow formatting of arbitrary pointers. + // If you want to output a pointer cast it to const void*. Do not implement! + template + Arg(const T *value); + + // This method is private to disallow formatting of arbitrary pointers. + // If you want to output a pointer cast it to void*. Do not implement! + template + Arg(T *value); + + struct StringValue { + const Char *value; + std::size_t size; + }; + + struct CustomValue { + const void *value; + FormatFunc format; + }; + + public: + Type type; + union { + int int_value; + unsigned uint_value; + double double_value; + long long_value; + unsigned long ulong_value; + LongLong long_long_value; + ULongLong ulong_long_value; + long double long_double_value; + const void *pointer_value; + StringValue string; + CustomValue custom; + }; + mutable BasicFormatter *formatter; + + Arg(short value) : type(INT), int_value(value), formatter(0) {} + Arg(unsigned short value) : type(UINT), int_value(value), formatter(0) {} + Arg(int value) : type(INT), int_value(value), formatter(0) {} + Arg(unsigned value) : type(UINT), uint_value(value), formatter(0) {} + Arg(long value) : type(LONG), long_value(value), formatter(0) {} + Arg(unsigned long value) : type(ULONG), ulong_value(value), formatter(0) {} + Arg(LongLong value) + : type(LONG_LONG), long_long_value(value), formatter(0) {} + Arg(ULongLong value) + : type(ULONG_LONG), ulong_long_value(value), formatter(0) {} + Arg(float value) : type(DOUBLE), double_value(value), formatter(0) {} + Arg(double value) : type(DOUBLE), double_value(value), formatter(0) {} + Arg(long double value) + : type(LONG_DOUBLE), long_double_value(value), formatter(0) {} + Arg(char value) : type(CHAR), int_value(value), formatter(0) {} + Arg(wchar_t value) + : type(CHAR), int_value(internal::CharTraits::ConvertChar(value)), + formatter(0) {} + + Arg(const Char *value) : type(STRING), formatter(0) { + string.value = value; + string.size = 0; + } + + Arg(Char *value) : type(STRING), formatter(0) { + string.value = value; + string.size = 0; + } + + Arg(const void *value) + : type(POINTER), pointer_value(value), formatter(0) {} + + Arg(void *value) : type(POINTER), pointer_value(value), formatter(0) {} + + Arg(const std::string &value) : type(STRING), formatter(0) { + string.value = value.c_str(); + string.size = value.size(); + } + + Arg(StringRef value) : type(STRING), formatter(0) { + string.value = value.c_str(); + string.size = value.size(); + } + + template + Arg(const T &value) : type(CUSTOM), formatter(0) { + custom.value = &value; + custom.format = &internal::FormatCustomArg; + } + + ~Arg() FMT_NOEXCEPT(false) { + // Format is called here to make sure that a referred object is + // still alive, for example: + // + // Print("{0}") << std::string("test"); + // + // Here an Arg object refers to a temporary std::string which is + // destroyed at the end of the statement. Since the string object is + // constructed before the Arg object, it will be destroyed after, + // so it will be alive in the Arg's destructor where Format is called. + // Note that the string object will not necessarily be alive when + // the destructor of BasicFormatter is called. + if (formatter) + formatter->CompleteFormatting(); + } + }; + + enum { NUM_INLINE_ARGS = 10 }; + internal::Array args_; // Format arguments. + + const Char *format_; // Format string. + int num_open_braces_; + int next_arg_index_; + + friend class internal::FormatterProxy; + + // Forbid copying from a temporary as in the following example: + // fmt::Formatter<> f = Format("test"); // not allowed + // This is done because BasicFormatter objects should normally exist + // only as temporaries returned by one of the formatting functions. + // Do not implement. + BasicFormatter(const BasicFormatter &); + BasicFormatter& operator=(const BasicFormatter &); + + void ReportError(const Char *s, StringRef message) const; + + unsigned ParseUInt(const Char *&s) const; + + // Parses argument index and returns an argument with this index. + const Arg &ParseArgIndex(const Char *&s); + + void CheckSign(const Char *&s, const Arg &arg); + + // Parses the format string and performs the actual formatting, + // writing the output to writer_. + void DoFormat(); + + // Formats an integer. + // TODO: remove + template + void FormatInt(T value, const FormatSpec &spec) { + *writer_ << IntFormatSpec(value, spec); + } + + struct Proxy { + BasicWriter *writer; + const Char *format; + + Proxy(BasicWriter *w, const Char *fmt) : writer(w), format(fmt) {} + }; + + protected: + const Char *TakeFormatString() { + const Char *format = this->format_; + this->format_ = 0; + return format; + } + + void CompleteFormatting() { + if (!format_) return; + DoFormat(); + } + + public: + // Constructs a formatter with a writer to be used for output and a format + // string. + BasicFormatter(BasicWriter &w, const Char *format = 0) + : writer_(&w), format_(format) {} + +#if FMT_USE_INITIALIZER_LIST + // Constructs a formatter with formatting arguments. + BasicFormatter(BasicWriter &w, + const Char *format, std::initializer_list args) + : writer_(&w), format_(format) { + // TODO: don't copy arguments + args_.reserve(args.size()); + for (const Arg &arg: args) + args_.push_back(&arg); + } +#endif + + // Performs formatting if the format string is non-null. The format string + // can be null if its ownership has been transferred to another formatter. + ~BasicFormatter() { + CompleteFormatting(); + } + + BasicFormatter(BasicFormatter &f) : writer_(f.writer_), format_(f.format_) { + f.format_ = 0; + } + + // Feeds an argument to a formatter. + BasicFormatter &operator<<(const Arg &arg) { + arg.formatter = this; + args_.push_back(&arg); + return *this; + } + + operator internal::FormatterProxy() { + return internal::FormatterProxy(this); + } + + operator StringRef() { + CompleteFormatting(); + return StringRef(writer_->c_str(), writer_->size()); + } +}; + +template +inline std::basic_string str(const BasicWriter &f) { + return f.str(); +} + +template +inline const Char *c_str(const BasicWriter &f) { return f.c_str(); } + +namespace internal { + +template +class FormatterProxy { + private: + BasicFormatter *formatter_; + + public: + explicit FormatterProxy(BasicFormatter *f) : formatter_(f) {} + + BasicWriter *Format() { + formatter_->CompleteFormatting(); + return formatter_->writer_; + } +}; +} + +/** + Returns the content of the output buffer as an `std::string`. + */ +inline std::string str(internal::FormatterProxy p) { + return p.Format()->str(); +} + +/** + Returns a pointer to the output buffer content with terminating null + character appended. + */ +inline const char *c_str(internal::FormatterProxy p) { + return p.Format()->c_str(); +} + +inline std::wstring str(internal::FormatterProxy p) { + return p.Format()->str(); +} + +inline const wchar_t *c_str(internal::FormatterProxy p) { + return p.Format()->c_str(); +} + +/** + A formatting action that does nothing. + */ +class NoAction { + public: + /** Does nothing. */ + template + void operator()(const BasicWriter &) const {} +}; + +/** + \rst + A formatter with an action performed when formatting is complete. + Objects of this class normally exist only as temporaries returned + by one of the formatting functions. You can use this class to create + your own functions similar to :cpp:func:`fmt::Format()`. + + **Example**:: + + struct PrintError { + void operator()(const fmt::Writer &w) const { + fmt::Print("Error: {}\n") << w.str(); + } + }; + + // Formats an error message and prints it to stdout. + fmt::Formatter ReportError(const char *format) { + fmt::Formatter f(format); + return f; + } + + ReportError("File not found: {}") << path; + \endrst + */ +template +class Formatter : private Action, public BasicFormatter { + private: + BasicWriter writer_; + bool inactive_; + + // Forbid copying other than from a temporary. Do not implement. + Formatter(const Formatter &); + Formatter& operator=(const Formatter &); + + public: + /** + \rst + Constructs a formatter with a format string and an action. + The action should be an unary function object that takes a const + reference to :cpp:class:`fmt::BasicWriter` as an argument. + See :cpp:class:`fmt::NoAction` and :cpp:class:`fmt::Write` for + examples of action classes. + \endrst + */ + explicit Formatter(BasicStringRef format, Action a = Action()) + : Action(a), BasicFormatter(writer_, format.c_str()), + inactive_(false) { + } + + Formatter(Formatter &f) + : Action(f), BasicFormatter(writer_, f.TakeFormatString()), + inactive_(false) { + f.inactive_ = true; + } + + /** + Performs the actual formatting, invokes the action and destroys the object. + */ + ~Formatter() FMT_NOEXCEPT(false) { + if (!inactive_) { + this->CompleteFormatting(); + (*this)(writer_); + } + } +}; + +/** + Fast integer formatter. + */ +class FormatInt { + private: + // Buffer should be large enough to hold all digits (digits10 + 1), + // a sign and a null character. + enum {BUFFER_SIZE = std::numeric_limits::digits10 + 3}; + mutable char buffer_[BUFFER_SIZE]; + char *str_; + + // Formats value in reverse and returns the number of digits. + char *FormatDecimal(ULongLong value) { + char *buffer_end = buffer_ + BUFFER_SIZE - 1; + while (value >= 100) { + // Integer division is slow so do it for a group of two digits instead + // of for every digit. The idea comes from the talk by Alexandrescu + // "Three Optimization Tips for C++". See speed-test for a comparison. + unsigned index = (value % 100) * 2; + value /= 100; + *--buffer_end = internal::DIGITS[index + 1]; + *--buffer_end = internal::DIGITS[index]; + } + if (value < 10) { + *--buffer_end = static_cast('0' + value); + return buffer_end; + } + unsigned index = static_cast(value * 2); + *--buffer_end = internal::DIGITS[index + 1]; + *--buffer_end = internal::DIGITS[index]; + return buffer_end; + } + + void FormatSigned(LongLong value) { + ULongLong abs_value = value; + bool negative = value < 0; + if (negative) + abs_value = 0 - value; + str_ = FormatDecimal(abs_value); + if (negative) + *--str_ = '-'; + } + + public: + explicit FormatInt(int value) { FormatSigned(value); } + explicit FormatInt(long value) { FormatSigned(value); } + explicit FormatInt(LongLong value) { FormatSigned(value); } + explicit FormatInt(unsigned value) : str_(FormatDecimal(value)) {} + explicit FormatInt(unsigned long value) : str_(FormatDecimal(value)) {} + explicit FormatInt(ULongLong value) : str_(FormatDecimal(value)) {} + + /** + Returns the number of characters written to the output buffer. + */ + std::size_t size() const { return buffer_ - str_ + BUFFER_SIZE - 1; } + + /** + Returns a pointer to the output buffer content. No terminating null + character is appended. + */ + const char *data() const { return str_; } + + /** + Returns a pointer to the output buffer content with terminating null + character appended. + */ + const char *c_str() const { + buffer_[BUFFER_SIZE - 1] = '\0'; + return str_; + } + + /** + Returns the content of the output buffer as an `std::string`. + */ + std::string str() const { return std::string(str_, size()); } +}; + +// Formats a decimal integer value writing into buffer and returns +// a pointer to the end of the formatted string. This function doesn't +// write a terminating null character. +template +inline void FormatDec(char *&buffer, T value) { + typename internal::IntTraits::MainType abs_value = value; + if (internal::IsNegative(value)) { + *buffer++ = '-'; + abs_value = 0 - abs_value; + } + if (abs_value < 100) { + if (abs_value < 10) { + *buffer++ = static_cast('0' + abs_value); + return; + } + unsigned index = static_cast(abs_value * 2); + *buffer++ = internal::DIGITS[index]; + *buffer++ = internal::DIGITS[index + 1]; + return; + } + unsigned num_digits = internal::CountDigits(abs_value); + internal::FormatDecimal(buffer, abs_value, num_digits); + buffer += num_digits; +} + +/** + \rst + Formats a string similarly to Python's `str.format + `__. + Returns a temporary formatter object that accepts arguments via + operator ``<<``. + + *format* is a format string that contains literal text and replacement + fields surrounded by braces ``{}``. The formatter object replaces the + fields with formatted arguments and stores the output in a memory buffer. + The content of the buffer can be converted to ``std::string`` with + :cpp:func:`fmt::str()` or accessed as a C string with + :cpp:func:`fmt::c_str()`. + + **Example**:: + + std::string message = str(Format("The answer is {}") << 42); + + See also `Format String Syntax`_. + \endrst +*/ +inline Formatter<> Format(StringRef format) { + Formatter<> f(format); + return f; +} + +inline Formatter Format(WStringRef format) { + Formatter f(format); + return f; +} + +/** A formatting action that writes formatted output to stdout. */ +class Write { + public: + /** Writes the output to stdout. */ + void operator()(const BasicWriter &w) const { + std::fwrite(w.data(), 1, w.size(), stdout); + } +}; + +// Formats a string and prints it to stdout. +// Example: +// Print("Elapsed time: {0:.2f} seconds") << 1.23; +inline Formatter Print(StringRef format) { + Formatter f(format); + return f; +} + +enum Color {BLACK, RED, GREEN, YELLOW, BLUE, MAGENTA, CYAN, WHITE}; + +/** A formatting action that writes colored output to stdout. */ +class ColorWriter { + private: + Color color_; + + public: + explicit ColorWriter(Color c) : color_(c) {} + + /** Writes the colored output to stdout. */ + void operator()(const BasicWriter &w) const; +}; + +// Formats a string and prints it to stdout with the given color. +// Example: +// PrintColored(fmt::RED, "Elapsed time: {0:.2f} seconds") << 1.23; +inline Formatter PrintColored(Color c, StringRef format) { + Formatter f(format, ColorWriter(c)); + return f; +} +} + +#if _MSC_VER +# pragma warning(pop) +#endif + +#endif // FORMAT_H_