ReactOS 0.4.16-dev-753-g705a985
propvarutil.h File Reference
#include <shtypes.h>
#include <shlwapi.h>
Include dependency graph for propvarutil.h:
This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Macros

#define PSSTDAPI   DECLSPEC_IMPORT STDAPI
 
#define PSSTDAPI_(type)   DECLSPEC_IMPORT STDAPI_(type)
 

Typedefs

typedef int PROPVAR_CHANGE_FLAGS
 
typedef int PROPVAR_COMPARE_UNIT
 
typedef int PROPVAR_COMPARE_FLAGS
 

Enumerations

enum  tagPROPVAR_CHANGE_FLAGS {
  PVCHF_DEFAULT = 0x00000000 , PVCHF_NOVALUEPROP = 0x00000001 , PVCHF_ALPHABOOL = 0x00000002 , PVCHF_NOUSEROVERRIDE = 0x00000004 ,
  PVCHF_LOCALBOOL = 0x00000008 , PVCHF_NOHEXSTRING = 0x00000010
}
 
enum  tagPROPVAR_COMPARE_UNIT {
  PVCU_DEFAULT = 0x00000000 , PVCU_SECOND = 0x00000001 , PVCU_MINUTE = 0x00000002 , PVCU_HOUR = 0x00000003 ,
  PVCU_DAY = 0x00000004 , PVCU_MONTH = 0x00000005 , PVCU_YEAR = 0x00000006
}
 
enum  tagPROPVAR_COMPARE_FLAGS {
  PVCF_DEFAULT = 0x00000000 , PVCF_TREATEMPTYASGREATERTHAN = 0x00000001 , PVCF_USESTRCMP = 0x00000002 , PVCF_USESTRCMPC = 0x00000004 ,
  PVCF_USESTRCMPI = 0x00000008 , PVCF_USESTRCMPIC = 0x00000010
}
 

Functions

PSSTDAPI PropVariantChangeType (PROPVARIANT *ppropvarDest, REFPROPVARIANT propvarSrc, PROPVAR_CHANGE_FLAGS flags, VARTYPE vt)
 
PSSTDAPI InitPropVariantFromGUIDAsString (REFGUID guid, PROPVARIANT *ppropvar)
 
PSSTDAPI InitVariantFromFileTime (const FILETIME *ft, VARIANT *var)
 
PSSTDAPI InitVariantFromGUIDAsString (REFGUID guid, VARIANT *pvar)
 
PSSTDAPI InitPropVariantFromBuffer (const VOID *pv, UINT cb, PROPVARIANT *ppropvar)
 
PSSTDAPI InitPropVariantFromCLSID (REFCLSID clsid, PROPVARIANT *ppropvar)
 
PSSTDAPI InitVariantFromBuffer (const VOID *pv, UINT cb, VARIANT *pvar)
 
PSSTDAPI PropVariantToGUID (const PROPVARIANT *ppropvar, GUID *guid)
 
PSSTDAPI VariantToGUID (const VARIANT *pvar, GUID *guid)
 
 PSSTDAPI_ (INT) PropVariantCompareEx(REFPROPVARIANT propvar1
 
PSSTDAPI InitPropVariantFromFileTime (const FILETIME *pftIn, PROPVARIANT *ppropvar)
 
PSSTDAPI InitPropVariantFromStringVector (PCWSTR *strs, ULONG count, PROPVARIANT *ppropvar)
 
PSSTDAPI PropVariantToDouble (REFPROPVARIANT propvarIn, double *ret)
 
PSSTDAPI PropVariantToInt16 (REFPROPVARIANT propvarIn, SHORT *ret)
 
PSSTDAPI PropVariantToInt32 (REFPROPVARIANT propvarIn, LONG *ret)
 
PSSTDAPI PropVariantToInt64 (REFPROPVARIANT propvarIn, LONGLONG *ret)
 
PSSTDAPI PropVariantToUInt16 (REFPROPVARIANT propvarIn, USHORT *ret)
 
PSSTDAPI PropVariantToUInt32 (REFPROPVARIANT propvarIn, ULONG *ret)
 
 PSSTDAPI_ (ULONG) PropVariantToUInt32WithDefault(REFPROPVARIANT propvarIn
 
PSSTDAPI PropVariantToUInt64 (REFPROPVARIANT propvarIn, ULONGLONG *ret)
 
PSSTDAPI PropVariantToBoolean (REFPROPVARIANT propvarIn, BOOL *ret)
 
PSSTDAPI PropVariantToBSTR (REFPROPVARIANT propvar, BSTR *bstr)
 
PSSTDAPI PropVariantToBuffer (REFPROPVARIANT propvarIn, void *ret, UINT cb)
 
PSSTDAPI PropVariantToString (REFPROPVARIANT propvarIn, PWSTR ret, UINT cch)
 
 PSSTDAPI_ (PCWSTR) PropVariantToStringWithDefault(REFPROPVARIANT propvarIn
 
PSSTDAPI VariantToString (REFVARIANT var, PWSTR ret, UINT cch)
 
PSSTDAPI PropVariantToStringAlloc (REFPROPVARIANT propvarIn, WCHAR **ret)
 
PSSTDAPI PropVariantToVariant (const PROPVARIANT *propvar, VARIANT *var)
 
PSSTDAPI VariantToPropVariant (const VARIANT *var, PROPVARIANT *propvar)
 
PSSTDAPI StgSerializePropVariant (const PROPVARIANT *ppropvar, SERIALIZEDPROPERTYVALUE **ppprop, ULONG *pcb)
 
PSSTDAPI StgDeserializePropVariant (const SERIALIZEDPROPERTYVALUE *pprop, ULONG cbmax, PROPVARIANT *ppropvar)
 

Variables

REFPROPVARIANT propvar2
 
REFPROPVARIANT PROPVAR_COMPARE_UNIT uint
 
REFPROPVARIANT PROPVAR_COMPARE_UNIT PROPVAR_COMPARE_FLAGS flags
 
ULONG uLDefault
 
LPCWSTR pszDefault
 

Macro Definition Documentation

◆ PSSTDAPI

#define PSSTDAPI   DECLSPEC_IMPORT STDAPI

Definition at line 30 of file propvarutil.h.

◆ PSSTDAPI_

#define PSSTDAPI_ (   type)    DECLSPEC_IMPORT STDAPI_(type)

Definition at line 31 of file propvarutil.h.

Typedef Documentation

◆ PROPVAR_CHANGE_FLAGS

Definition at line 49 of file propvarutil.h.

◆ PROPVAR_COMPARE_FLAGS

Definition at line 74 of file propvarutil.h.

◆ PROPVAR_COMPARE_UNIT

Definition at line 62 of file propvarutil.h.

Enumeration Type Documentation

◆ tagPROPVAR_CHANGE_FLAGS

Enumerator
PVCHF_DEFAULT 
PVCHF_NOVALUEPROP 
PVCHF_ALPHABOOL 
PVCHF_NOUSEROVERRIDE 
PVCHF_LOCALBOOL 
PVCHF_NOHEXSTRING 

Definition at line 39 of file propvarutil.h.

40{
41 PVCHF_DEFAULT = 0x00000000,
42 PVCHF_NOVALUEPROP = 0x00000001,
43 PVCHF_ALPHABOOL = 0x00000002,
44 PVCHF_NOUSEROVERRIDE = 0x00000004,
45 PVCHF_LOCALBOOL = 0x00000008,
46 PVCHF_NOHEXSTRING = 0x00000010,
47};
@ PVCHF_NOUSEROVERRIDE
Definition: propvarutil.h:44
@ PVCHF_DEFAULT
Definition: propvarutil.h:41
@ PVCHF_LOCALBOOL
Definition: propvarutil.h:45
@ PVCHF_ALPHABOOL
Definition: propvarutil.h:43
@ PVCHF_NOVALUEPROP
Definition: propvarutil.h:42
@ PVCHF_NOHEXSTRING
Definition: propvarutil.h:46

◆ tagPROPVAR_COMPARE_FLAGS

Enumerator
PVCF_DEFAULT 
PVCF_TREATEMPTYASGREATERTHAN 
PVCF_USESTRCMP 
PVCF_USESTRCMPC 
PVCF_USESTRCMPI 
PVCF_USESTRCMPIC 

Definition at line 64 of file propvarutil.h.

65{
66 PVCF_DEFAULT = 0x00000000,
68 PVCF_USESTRCMP = 0x00000002,
69 PVCF_USESTRCMPC = 0x00000004,
70 PVCF_USESTRCMPI = 0x00000008,
71 PVCF_USESTRCMPIC = 0x00000010,
72};
@ PVCF_USESTRCMPC
Definition: propvarutil.h:69
@ PVCF_USESTRCMPI
Definition: propvarutil.h:70
@ PVCF_USESTRCMPIC
Definition: propvarutil.h:71
@ PVCF_DEFAULT
Definition: propvarutil.h:66
@ PVCF_TREATEMPTYASGREATERTHAN
Definition: propvarutil.h:67
@ PVCF_USESTRCMP
Definition: propvarutil.h:68

◆ tagPROPVAR_COMPARE_UNIT

Enumerator
PVCU_DEFAULT 
PVCU_SECOND 
PVCU_MINUTE 
PVCU_HOUR 
PVCU_DAY 
PVCU_MONTH 
PVCU_YEAR 

Definition at line 51 of file propvarutil.h.

52{
53 PVCU_DEFAULT = 0x00000000,
54 PVCU_SECOND = 0x00000001,
55 PVCU_MINUTE = 0x00000002,
56 PVCU_HOUR = 0x00000003,
57 PVCU_DAY = 0x00000004,
58 PVCU_MONTH = 0x00000005,
59 PVCU_YEAR = 0x00000006,
60};
@ PVCU_DEFAULT
Definition: propvarutil.h:53
@ PVCU_MONTH
Definition: propvarutil.h:58
@ PVCU_HOUR
Definition: propvarutil.h:56
@ PVCU_YEAR
Definition: propvarutil.h:59
@ PVCU_MINUTE
Definition: propvarutil.h:55
@ PVCU_SECOND
Definition: propvarutil.h:54
@ PVCU_DAY
Definition: propvarutil.h:57

Function Documentation

◆ InitPropVariantFromBuffer()

PSSTDAPI InitPropVariantFromBuffer ( const VOID pv,
UINT  cb,
PROPVARIANT *  ppropvar 
)

Definition at line 723 of file propvar.c.

724{
725 TRACE("(%p %u %p)\n", pv, cb, ppropvar);
726
727 ppropvar->caub.pElems = CoTaskMemAlloc(cb);
728 if(!ppropvar->caub.pElems)
729 return E_OUTOFMEMORY;
730
731 ppropvar->vt = VT_VECTOR|VT_UI1;
732 ppropvar->caub.cElems = cb;
733 memcpy(ppropvar->caub.pElems, pv, cb);
734 return S_OK;
735}
#define E_OUTOFMEMORY
Definition: ddrawi.h:100
@ VT_VECTOR
Definition: compat.h:2340
@ VT_UI1
Definition: compat.h:2311
LPVOID WINAPI CoTaskMemAlloc(SIZE_T size)
Definition: ifs.c:426
#define S_OK
Definition: intsafe.h:52
#define memcpy(s1, s2, n)
Definition: mkisofs.h:878
static HMODULE MODULEINFO DWORD cb
Definition: module.c:33
#define TRACE(s)
Definition: solgame.cpp:4

Referenced by test_InitPropVariantFromBuffer(), and test_PropVariantToBuffer().

◆ InitPropVariantFromCLSID()

PSSTDAPI InitPropVariantFromCLSID ( REFCLSID  clsid,
PROPVARIANT *  ppropvar 
)

Definition at line 737 of file propvar.c.

738{
739 TRACE("(%s %p)\n", debugstr_guid(clsid), ppropvar);
740
741 ppropvar->puuid = CoTaskMemAlloc(sizeof(*ppropvar->puuid));
742 if(!ppropvar->puuid)
743 return E_OUTOFMEMORY;
744
745 ppropvar->vt = VT_CLSID;
746 memcpy(ppropvar->puuid, clsid, sizeof(*ppropvar->puuid));
747 return S_OK;
748}
@ VT_CLSID
Definition: compat.h:2337
#define debugstr_guid
Definition: kernel32.h:35
REFCLSID clsid
Definition: msctf.c:82

Referenced by test_InitPropVariantFromCLSID(), and test_PropVariantToGUID().

◆ InitPropVariantFromFileTime()

PSSTDAPI InitPropVariantFromFileTime ( const FILETIME pftIn,
PROPVARIANT *  ppropvar 
)

◆ InitPropVariantFromGUIDAsString()

PSSTDAPI InitPropVariantFromGUIDAsString ( REFGUID  guid,
PROPVARIANT *  ppropvar 
)

Definition at line 689 of file propvar.c.

690{
691 TRACE("(%p %p)\n", guid, ppropvar);
692
693 if(!guid)
694 return E_FAIL;
695
696 ppropvar->vt = VT_LPWSTR;
697 ppropvar->pwszVal = CoTaskMemAlloc((GUID_STR_LEN + 1) * sizeof(WCHAR));
698 if(!ppropvar->pwszVal)
699 return E_OUTOFMEMORY;
700
701 StringFromGUID2(guid, ppropvar->pwszVal, GUID_STR_LEN + 1);
702 return S_OK;
703}
#define E_FAIL
Definition: ddrawi.h:102
@ VT_LPWSTR
Definition: compat.h:2325
INT WINAPI StringFromGUID2(REFGUID id, LPOLESTR str, INT cmax)
Definition: compobj.c:2434
#define GUID_STR_LEN
Definition: propvar.c:38
const GUID * guid
__wchar_t WCHAR
Definition: xmlstorage.h:180

Referenced by test_InitPropVariantFromGUIDAsString(), and test_PropVariantToGUID().

◆ InitPropVariantFromStringVector()

PSSTDAPI InitPropVariantFromStringVector ( PCWSTR strs,
ULONG  count,
PROPVARIANT *  ppropvar 
)

Definition at line 750 of file propvar.c.

751{
752 unsigned int i;
753
754 TRACE("(%p %lu %p)\n", strs, count, ppropvar);
755
756 ppropvar->calpwstr.pElems = CoTaskMemAlloc(count * sizeof(*ppropvar->calpwstr.pElems));
757 if(!ppropvar->calpwstr.pElems)
758 return E_OUTOFMEMORY;
759
760 ppropvar->vt = VT_LPWSTR | VT_VECTOR;
761 ppropvar->calpwstr.cElems = 0;
762 if (count)
763 memset(ppropvar->calpwstr.pElems, 0, count * sizeof(*ppropvar->calpwstr.pElems));
764
765 for (i = 0; i < count; ++i)
766 {
767 if (strs[i])
768 {
769 if (!(ppropvar->calpwstr.pElems[i] = CoTaskMemAlloc((wcslen(strs[i]) + 1)*sizeof(**strs))))
770 {
771 PropVariantClear(ppropvar);
772 return E_OUTOFMEMORY;
773 }
774 }
775 wcscpy(ppropvar->calpwstr.pElems[i], strs[i]);
776 ppropvar->calpwstr.cElems++;
777 }
778
779 return S_OK;
780}
wcscpy
HRESULT WINAPI PropVariantClear(PROPVARIANT *pvar)
Definition: ole2.c:2968
GLuint GLuint GLsizei count
Definition: gl.h:1545
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
_CRTIMP size_t __cdecl wcslen(_In_z_ const wchar_t *_Str)
#define memset(x, y, z)
Definition: compat.h:39

Referenced by test_InitPropVariantFromStringVector().

◆ InitVariantFromBuffer()

PSSTDAPI InitVariantFromBuffer ( const VOID pv,
UINT  cb,
VARIANT pvar 
)
inline

Definition at line 26 of file util.h.

27{
29 if (pa)
30 {
31 CopyMemory(pa->pvData, buffer, cb);
32 V_VT(pv) = VT_UI1 | VT_ARRAY;
33 V_UNION(pv, parray) = pa;
34 return S_OK;
35 }
36 V_VT(pv) = VT_EMPTY;
37 return E_OUTOFMEMORY;
38}
@ VT_ARRAY
Definition: compat.h:2341
@ VT_EMPTY
Definition: compat.h:2295
SAFEARRAY *WINAPI SafeArrayCreateVector(VARTYPE vt, LONG lLbound, ULONG cElements)
Definition: safearray.c:677
GLuint buffer
Definition: glext.h:5915
static int ** pa
Definition: server.c:126
#define V_VT(A)
Definition: oleauto.h:211
#define V_UNION(A, B)
Definition: oleauto.h:212
#define CopyMemory
Definition: winbase.h:1735

Referenced by CCabFolder::GetDetailsEx(), and test_InitPropVariantFromBuffer().

◆ InitVariantFromFileTime()

PSSTDAPI InitVariantFromFileTime ( const FILETIME ft,
VARIANT var 
)

Definition at line 813 of file propvar.c.

814{
815 SYSTEMTIME st;
816
817 TRACE("%p, %p\n", ft, var);
818
820 if (!FileTimeToSystemTime(ft, &st))
821 return E_INVALIDARG;
823 return E_INVALIDARG;
824 V_VT(var) = VT_DATE;
825 return S_OK;
826}
#define E_INVALIDARG
Definition: ddrawi.h:101
@ VT_DATE
Definition: compat.h:2302
BOOL WINAPI FileTimeToSystemTime(IN CONST FILETIME *lpFileTime, OUT LPSYSTEMTIME lpSystemTime)
Definition: time.c:188
const char * var
Definition: shader.c:5666
#define V_DATE(A)
Definition: oleauto.h:231
void WINAPI VariantInit(VARIANTARG *pVarg)
Definition: variant.c:568
INT WINAPI SystemTimeToVariantTime(LPSYSTEMTIME lpSt, double *pDateOut)
Definition: variant.c:1286

Referenced by test_InitVariantFromFileTime().

◆ InitVariantFromGUIDAsString()

PSSTDAPI InitVariantFromGUIDAsString ( REFGUID  guid,
VARIANT pvar 
)

Definition at line 705 of file propvar.c.

706{
707 TRACE("(%p %p)\n", guid, pvar);
708
709 if(!guid) {
710 FIXME("guid == NULL\n");
711 return E_FAIL;
712 }
713
714 V_VT(pvar) = VT_BSTR;
716 if(!V_BSTR(pvar))
717 return E_OUTOFMEMORY;
718
720 return S_OK;
721}
#define FIXME(fmt,...)
Definition: precomp.h:53
#define NULL
Definition: types.h:112
@ VT_BSTR
Definition: compat.h:2303
BSTR WINAPI SysAllocStringLen(const OLECHAR *str, unsigned int len)
Definition: oleaut.c:339
#define V_BSTR(A)
Definition: oleauto.h:226

Referenced by test_InitPropVariantFromGUIDAsString(), and test_PropVariantToGUID().

◆ PropVariantChangeType()

PSSTDAPI PropVariantChangeType ( PROPVARIANT *  ppropvarDest,
REFPROPVARIANT  propvarSrc,
PROPVAR_CHANGE_FLAGS  flags,
VARTYPE  vt 
)

Definition at line 537 of file propvar.c.

539{
540 HRESULT hr;
541
542 FIXME("(%p, %p, %d, %d, %d): semi-stub!\n", ppropvarDest, propvarSrc,
543 propvarSrc->vt, flags, vt);
544
545 if (vt == propvarSrc->vt)
546 return PropVariantCopy(ppropvarDest, propvarSrc);
547
548 if (propvarSrc->vt == VT_FILETIME)
549 return PROPVAR_ConvertFILETIME(&propvarSrc->filetime, ppropvarDest, vt);
550
551 switch (vt)
552 {
553 case VT_I1:
554 {
556
558 if (SUCCEEDED(hr))
559 {
560 ppropvarDest->vt = VT_I1;
561 ppropvarDest->cVal = (char)res;
562 }
563 return hr;
564 }
565
566 case VT_UI1:
567 {
569
571 if (SUCCEEDED(hr))
572 {
573 ppropvarDest->vt = VT_UI1;
574 ppropvarDest->bVal = (UCHAR)res;
575 }
576 return hr;
577 }
578
579 case VT_I2:
580 {
581 SHORT res;
583 if (SUCCEEDED(hr))
584 {
585 ppropvarDest->vt = VT_I2;
586 ppropvarDest->iVal = res;
587 }
588 return hr;
589 }
590 case VT_UI2:
591 {
592 USHORT res;
594 if (SUCCEEDED(hr))
595 {
596 ppropvarDest->vt = VT_UI2;
597 ppropvarDest->uiVal = res;
598 }
599 return hr;
600 }
601 case VT_I4:
602 {
603 LONG res;
605 if (SUCCEEDED(hr))
606 {
607 ppropvarDest->vt = VT_I4;
608 ppropvarDest->lVal = res;
609 }
610 return hr;
611 }
612 case VT_UI4:
613 {
614 ULONG res;
616 if (SUCCEEDED(hr))
617 {
618 ppropvarDest->vt = VT_UI4;
619 ppropvarDest->ulVal = res;
620 }
621 return hr;
622 }
623 case VT_I8:
624 {
627 if (SUCCEEDED(hr))
628 {
629 ppropvarDest->vt = VT_I8;
630 ppropvarDest->hVal.QuadPart = res;
631 }
632 return hr;
633 }
634 case VT_UI8:
635 {
638 if (SUCCEEDED(hr))
639 {
640 ppropvarDest->vt = VT_UI8;
641 ppropvarDest->uhVal.QuadPart = res;
642 }
643 return hr;
644 }
645
646 case VT_LPWSTR:
647 case VT_BSTR:
648 {
649 WCHAR *res;
651 if (SUCCEEDED(hr))
652 {
653 ppropvarDest->vt = VT_LPWSTR;
654 ppropvarDest->pwszVal = res;
655 }
656 return hr;
657 }
658
659 case VT_LPSTR:
660 {
661 WCHAR *resW;
663 if (SUCCEEDED(hr))
664 {
665 char *res;
666 DWORD len;
667
668 len = WideCharToMultiByte(CP_ACP, 0, resW, -1, NULL, 0, NULL, NULL);
670 if (res)
671 {
672 WideCharToMultiByte(CP_ACP, 0, resW, -1, res, len, NULL, NULL);
673 ppropvarDest->vt = VT_LPSTR;
674 ppropvarDest->pszVal = res;
675 }
676 else
678
679 CoTaskMemFree(resW);
680 }
681 return hr;
682 }
683
684 default:
685 FIXME("Unhandled dest type: %d\n", vt);
686 return E_FAIL;
687 }
688}
#define TRUE
Definition: types.h:120
#define FALSE
Definition: types.h:117
#define CP_ACP
Definition: compat.h:109
#define WideCharToMultiByte
Definition: compat.h:111
@ VT_UI8
Definition: compat.h:2315
@ VT_LPSTR
Definition: compat.h:2324
@ VT_UI2
Definition: compat.h:2312
@ VT_I8
Definition: compat.h:2314
@ VT_I1
Definition: compat.h:2310
@ VT_I4
Definition: compat.h:2298
@ VT_FILETIME
Definition: compat.h:2329
@ VT_I2
Definition: compat.h:2297
@ VT_UI4
Definition: compat.h:2313
static REFPROPVARIANT propvarSrc
Definition: suminfo.c:90
static REFPROPVARIANT PROPVAR_CHANGE_FLAGS VARTYPE vt
Definition: suminfo.c:91
HRESULT WINAPI PropVariantCopy(PROPVARIANT *pvarDest, const PROPVARIANT *pvarSrc)
Definition: ole2.c:3086
HRESULT WINAPI PropVariantToInt32(REFPROPVARIANT propvarIn, LONG *ret)
Definition: propvar.c:208
static HRESULT PROPVAR_ConvertFILETIME(const FILETIME *ft, PROPVARIANT *ppropvarDest, VARTYPE vt)
Definition: propvar.c:59
HRESULT WINAPI PropVariantToUInt16(REFPROPVARIANT propvarIn, USHORT *ret)
Definition: propvar.c:232
HRESULT WINAPI PropVariantToStringAlloc(REFPROPVARIANT propvarIn, WCHAR **ret)
Definition: propvar.c:407
static HRESULT PROPVAR_ConvertNumber(REFPROPVARIANT pv, int dest_bits, BOOL dest_signed, LONGLONG *res)
Definition: propvar.c:86
HRESULT WINAPI PropVariantToInt64(REFPROPVARIANT propvarIn, LONGLONG *ret)
Definition: propvar.c:220
HRESULT WINAPI PropVariantToUInt64(REFPROPVARIANT propvarIn, ULONGLONG *ret)
Definition: propvar.c:270
HRESULT WINAPI PropVariantToUInt32(REFPROPVARIANT propvarIn, ULONG *ret)
Definition: propvar.c:244
HRESULT WINAPI PropVariantToInt16(REFPROPVARIANT propvarIn, SHORT *ret)
Definition: propvar.c:196
unsigned char
Definition: typeof.h:29
unsigned long DWORD
Definition: ntddk_ex.h:95
GLuint res
Definition: glext.h:9613
GLbitfield flags
Definition: glext.h:7161
GLenum GLsizei len
Definition: glext.h:6722
VOID WINAPI CoTaskMemFree(LPVOID ptr)
Definition: ifs.c:442
#define SUCCEEDED(hr)
Definition: intsafe.h:50
short SHORT
Definition: pedump.c:59
long LONG
Definition: pedump.c:60
unsigned short USHORT
Definition: pedump.c:61
HRESULT hr
Definition: shlfolder.c:183
int64_t LONGLONG
Definition: typedefs.h:68
uint32_t ULONG
Definition: typedefs.h:59
uint64_t ULONGLONG
Definition: typedefs.h:67
unsigned char UCHAR
Definition: xmlstorage.h:181

Referenced by get_token(), MimeBody_GetProp(), PropVariantCompareEx(), and test_PropVariantChangeType_LPWSTR().

◆ PropVariantToBoolean()

PSSTDAPI PropVariantToBoolean ( REFPROPVARIANT  propvarIn,
BOOL ret 
)

Definition at line 282 of file propvar.c.

283{
285 HRESULT hr;
286
287 TRACE("%p,%p\n", propvarIn, ret);
288
289 *ret = FALSE;
290
291 switch (propvarIn->vt)
292 {
293 case VT_BOOL:
294 *ret = propvarIn->boolVal == VARIANT_TRUE;
295 return S_OK;
296
297 case VT_LPWSTR:
298 case VT_BSTR:
299 if (!propvarIn->pwszVal)
300 return DISP_E_TYPEMISMATCH;
301
302 if (!lstrcmpiW(propvarIn->pwszVal, L"true") || !lstrcmpW(propvarIn->pwszVal, L"#TRUE#"))
303 {
304 *ret = TRUE;
305 return S_OK;
306 }
307
308 if (!lstrcmpiW(propvarIn->pwszVal, L"false") || !lstrcmpW(propvarIn->pwszVal, L"#FALSE#"))
309 {
310 *ret = FALSE;
311 return S_OK;
312 }
313 break;
314
315 case VT_LPSTR:
316 if (!propvarIn->pszVal)
317 return DISP_E_TYPEMISMATCH;
318
319 if (!lstrcmpiA(propvarIn->pszVal, "true") || !lstrcmpA(propvarIn->pszVal, "#TRUE#"))
320 {
321 *ret = TRUE;
322 return S_OK;
323 }
324
325 if (!lstrcmpiA(propvarIn->pszVal, "false") || !lstrcmpA(propvarIn->pszVal, "#FALSE#"))
326 {
327 *ret = FALSE;
328 return S_OK;
329 }
330 break;
331 }
332
333 hr = PROPVAR_ConvertNumber(propvarIn, 64, TRUE, &res);
334 *ret = !!res;
335 return hr;
336}
@ VT_BOOL
Definition: compat.h:2306
int WINAPI lstrcmpW(LPCWSTR str1, LPCWSTR str2)
Definition: locale.c:4243
int WINAPI lstrcmpA(LPCSTR str1, LPCSTR str2)
Definition: locale.c:4195
int WINAPI lstrcmpiW(LPCWSTR str1, LPCWSTR str2)
Definition: locale.c:4262
int WINAPI lstrcmpiA(LPCSTR str1, LPCSTR str2)
Definition: locale.c:4224
#define L(x)
Definition: ntvdm.h:50
int ret
#define DISP_E_TYPEMISMATCH
Definition: winerror.h:2514

Referenced by test_PropVariantToBoolean().

◆ PropVariantToBSTR()

PSSTDAPI PropVariantToBSTR ( REFPROPVARIANT  propvar,
BSTR bstr 
)

Definition at line 338 of file propvar.c.

339{
340 WCHAR *str;
341 HRESULT hr;
342
343 TRACE("propvar %p, propvar->vt %#x, bstr %p.\n",
344 propvar, propvar ? propvar->vt : 0, bstr);
345
346 if (FAILED(hr = PropVariantToStringAlloc(propvar, &str)))
347 return hr;
348
349 *bstr = SysAllocString(str);
351
352 if (!*bstr)
353 return E_OUTOFMEMORY;
354
355 return S_OK;
356}
#define FAILED(hr)
Definition: intsafe.h:51
BSTR WINAPI SysAllocString(LPCOLESTR str)
Definition: oleaut.c:238
const WCHAR * str

Referenced by PropVariantToVariant(), and test_PropVariantToBSTR().

◆ PropVariantToBuffer()

PSSTDAPI PropVariantToBuffer ( REFPROPVARIANT  propvarIn,
void ret,
UINT  cb 
)

Definition at line 358 of file propvar.c.

359{
360 HRESULT hr = S_OK;
361
362 TRACE("(%p, %p, %d)\n", propvarIn, ret, cb);
363
364 switch(propvarIn->vt)
365 {
366 case VT_VECTOR|VT_UI1:
367 if(cb > propvarIn->caub.cElems)
368 return E_FAIL;
369 memcpy(ret, propvarIn->caub.pElems, cb);
370 break;
371 case VT_ARRAY|VT_UI1:
372 FIXME("Unsupported type: VT_ARRAY|VT_UI1\n");
373 hr = E_NOTIMPL;
374 break;
375 default:
376 WARN("Unexpected type: %x\n", propvarIn->vt);
378 }
379
380 return hr;
381}
#define WARN(fmt,...)
Definition: precomp.h:61
#define E_NOTIMPL
Definition: ddrawi.h:99

Referenced by test_PropVariantToBuffer().

◆ PropVariantToDouble()

PSSTDAPI PropVariantToDouble ( REFPROPVARIANT  propvarIn,
double ret 
)

Definition at line 184 of file propvar.c.

185{
187 HRESULT hr;
188
189 TRACE("(%p, %p)\n", propvarIn, ret);
190
191 hr = PROPVAR_ConvertNumber(propvarIn, 64, TRUE, &res);
192 if (SUCCEEDED(hr)) *ret = (double)res;
193 return hr;
194}
static const char mbstate_t *static wchar_t const char mbstate_t *static const wchar_t int *static double
Definition: string.c:89

Referenced by test_PropVariantToDouble().

◆ PropVariantToGUID()

PSSTDAPI PropVariantToGUID ( const PROPVARIANT *  ppropvar,
GUID guid 
)

Definition at line 900 of file propvar.c.

901{
902 TRACE("%p %p)\n", ppropvar, guid);
903
904 switch(ppropvar->vt) {
905 case VT_BSTR:
906 return PROPVAR_WCHARToGUID(ppropvar->bstrVal, SysStringLen(ppropvar->bstrVal), guid);
907 case VT_LPWSTR:
908 return PROPVAR_WCHARToGUID(ppropvar->pwszVal, lstrlenW(ppropvar->pwszVal), guid);
909 case VT_CLSID:
910 memcpy(guid, ppropvar->puuid, sizeof(*ppropvar->puuid));
911 return S_OK;
912
913 default:
914 FIXME("unsupported vt: %d\n", ppropvar->vt);
915 return E_NOTIMPL;
916 }
917}
#define lstrlenW
Definition: compat.h:750
static HRESULT PROPVAR_WCHARToGUID(const WCHAR *str, int len, GUID *guid)
Definition: propvar.c:852
UINT WINAPI SysStringLen(BSTR str)
Definition: oleaut.c:196

Referenced by test_PropVariantToGUID().

◆ PropVariantToInt16()

PSSTDAPI PropVariantToInt16 ( REFPROPVARIANT  propvarIn,
SHORT ret 
)

Definition at line 196 of file propvar.c.

197{
199 HRESULT hr;
200
201 TRACE("%p,%p\n", propvarIn, ret);
202
203 hr = PROPVAR_ConvertNumber(propvarIn, 16, TRUE, &res);
204 if (SUCCEEDED(hr)) *ret = (SHORT)res;
205 return hr;
206}

Referenced by PropVariantChangeType(), and test_intconversions().

◆ PropVariantToInt32()

PSSTDAPI PropVariantToInt32 ( REFPROPVARIANT  propvarIn,
LONG ret 
)

Definition at line 208 of file propvar.c.

209{
211 HRESULT hr;
212
213 TRACE("%p,%p\n", propvarIn, ret);
214
215 hr = PROPVAR_ConvertNumber(propvarIn, 32, TRUE, &res);
216 if (SUCCEEDED(hr)) *ret = (LONG)res;
217 return hr;
218}

Referenced by PropVariantChangeType(), and test_intconversions().

◆ PropVariantToInt64()

PSSTDAPI PropVariantToInt64 ( REFPROPVARIANT  propvarIn,
LONGLONG ret 
)

Definition at line 220 of file propvar.c.

221{
223 HRESULT hr;
224
225 TRACE("%p,%p\n", propvarIn, ret);
226
227 hr = PROPVAR_ConvertNumber(propvarIn, 64, TRUE, &res);
228 if (SUCCEEDED(hr)) *ret = res;
229 return hr;
230}

Referenced by propvar_cmp(), PropVariantChangeType(), and test_intconversions().

◆ PropVariantToString()

PSSTDAPI PropVariantToString ( REFPROPVARIANT  propvarIn,
PWSTR  ret,
UINT  cch 
)

Definition at line 383 of file propvar.c.

384{
385 HRESULT hr;
386 WCHAR *stringW = NULL;
387
388 TRACE("(%p, %p, %d)\n", propvarIn, ret, cch);
389
390 ret[0] = '\0';
391
392 if(!cch)
393 return E_INVALIDARG;
394
395 hr = PropVariantToStringAlloc(propvarIn, &stringW);
396 if(SUCCEEDED(hr))
397 {
398 if(lstrlenW(stringW) >= cch)
402 }
403
404 return hr;
405}
#define lstrcpynW
Definition: compat.h:738
static const WCHAR stringW[]
Definition: engine.c:38
static DWORD DWORD void LPSTR DWORD cch
Definition: str.c:202
#define STRSAFE_E_INSUFFICIENT_BUFFER
Definition: strsafe.h:103

Referenced by test_PropVariantToString().

◆ PropVariantToStringAlloc()

PSSTDAPI PropVariantToStringAlloc ( REFPROPVARIANT  propvarIn,
WCHAR **  ret 
)

Definition at line 407 of file propvar.c.

408{
409 WCHAR *res = NULL;
410 HRESULT hr = S_OK;
411
412 TRACE("%p,%p semi-stub\n", propvarIn, ret);
413
414 switch(propvarIn->vt)
415 {
416 case VT_EMPTY:
417 case VT_NULL:
418 res = CoTaskMemAlloc(1*sizeof(WCHAR));
419 res[0] = '\0';
420 break;
421
422 case VT_LPSTR:
423 if(propvarIn->pszVal)
424 {
425 DWORD len;
426
427 len = MultiByteToWideChar(CP_ACP, 0, propvarIn->pszVal, -1, NULL, 0);
428 res = CoTaskMemAlloc(len*sizeof(WCHAR));
429 if(!res)
430 return E_OUTOFMEMORY;
431
432 MultiByteToWideChar(CP_ACP, 0, propvarIn->pszVal, -1, res, len);
433 }
434 break;
435
436 case VT_LPWSTR:
437 case VT_BSTR:
438 if (propvarIn->pwszVal)
439 {
440 DWORD size = (lstrlenW(propvarIn->pwszVal) + 1) * sizeof(WCHAR);
442 if(!res) return E_OUTOFMEMORY;
443 memcpy(res, propvarIn->pwszVal, size);
444 }
445 break;
446
447 case VT_CLSID:
448 if (propvarIn->puuid)
449 {
450 if (!(res = CoTaskMemAlloc((GUID_STR_LEN + 1) * sizeof(WCHAR))))
451 return E_OUTOFMEMORY;
452 StringFromGUID2(propvarIn->puuid, res, GUID_STR_LEN + 1);
453 }
454 break;
455
456 default:
457 FIXME("Unsupported conversion (%d)\n", propvarIn->vt);
458 hr = E_FAIL;
459 break;
460 }
461
462 *ret = res;
463
464 return hr;
465}
#define MultiByteToWideChar
Definition: compat.h:110
@ VT_NULL
Definition: compat.h:2296
GLsizeiptr size
Definition: glext.h:5919

Referenced by PropVariantChangeType(), PropVariantToBSTR(), PropVariantToString(), and test_PropVariantToStringAlloc().

◆ PropVariantToUInt16()

PSSTDAPI PropVariantToUInt16 ( REFPROPVARIANT  propvarIn,
USHORT ret 
)

Definition at line 232 of file propvar.c.

233{
235 HRESULT hr;
236
237 TRACE("%p,%p\n", propvarIn, ret);
238
239 hr = PROPVAR_ConvertNumber(propvarIn, 16, FALSE, &res);
240 if (SUCCEEDED(hr)) *ret = (USHORT)res;
241 return hr;
242}

Referenced by PropVariantChangeType(), and test_intconversions().

◆ PropVariantToUInt32()

PSSTDAPI PropVariantToUInt32 ( REFPROPVARIANT  propvarIn,
ULONG ret 
)

Definition at line 244 of file propvar.c.

245{
247 HRESULT hr;
248
249 TRACE("%p,%p\n", propvarIn, ret);
250
251 hr = PROPVAR_ConvertNumber(propvarIn, 32, FALSE, &res);
252 if (SUCCEEDED(hr)) *ret = (ULONG)res;
253 return hr;
254}

Referenced by PropVariantChangeType(), and test_intconversions().

◆ PropVariantToUInt64()

PSSTDAPI PropVariantToUInt64 ( REFPROPVARIANT  propvarIn,
ULONGLONG ret 
)

Definition at line 270 of file propvar.c.

271{
273 HRESULT hr;
274
275 TRACE("%p,%p\n", propvarIn, ret);
276
277 hr = PROPVAR_ConvertNumber(propvarIn, 64, FALSE, &res);
278 if (SUCCEEDED(hr)) *ret = (ULONGLONG)res;
279 return hr;
280}

Referenced by PropVariantChangeType(), and test_intconversions().

◆ PropVariantToVariant()

PSSTDAPI PropVariantToVariant ( const PROPVARIANT *  propvar,
VARIANT var 
)

Definition at line 1073 of file propvar.c.

1074{
1075 HRESULT hr = S_OK;
1076
1077 TRACE("propvar %p, var %p, propvar->vt %#x.\n", propvar, var, propvar ? propvar->vt : 0);
1078
1079 if (!var || !propvar)
1080 return E_INVALIDARG;
1081
1083#ifdef __REACTOS__
1084 V_VT(var) = propvar->vt;
1085#else
1086 var->vt = propvar->vt;
1087#endif
1088
1089 switch (propvar->vt)
1090 {
1091 case VT_EMPTY:
1092 case VT_NULL:
1093 break;
1094 case VT_I1:
1095 V_I1(var) = propvar->cVal;
1096 break;
1097 case VT_I2:
1098 V_I2(var) = propvar->iVal;
1099 break;
1100 case VT_I4:
1101 V_I4(var) = propvar->lVal;
1102 break;
1103 case VT_I8:
1104 V_I8(var) = propvar->hVal.QuadPart;
1105 break;
1106 case VT_UI1:
1107 V_UI1(var) = propvar->bVal;
1108 break;
1109 case VT_UI2:
1110 V_UI2(var) = propvar->uiVal;
1111 break;
1112 case VT_UI4:
1113 V_UI4(var) = propvar->ulVal;
1114 break;
1115 case VT_UI8:
1116 V_UI8(var) = propvar->uhVal.QuadPart;
1117 break;
1118 case VT_BOOL:
1119 V_BOOL(var) = propvar->boolVal;
1120 break;
1121 case VT_R4:
1122 V_R4(var) = propvar->fltVal;
1123 break;
1124 case VT_R8:
1125 V_R8(var) = propvar->dblVal;
1126 break;
1127 case VT_LPSTR:
1128 case VT_LPWSTR:
1129 case VT_BSTR:
1130 case VT_CLSID:
1131#ifdef __REACTOS__
1132 V_VT(var) = VT_BSTR;
1133#else
1134 var->vt = VT_BSTR;
1135#endif
1136 hr = PropVariantToBSTR(propvar, &V_BSTR(var));
1137 break;
1138 default:
1139 FIXME("Unsupported type %d.\n", propvar->vt);
1140 return E_INVALIDARG;
1141 }
1142
1143 return hr;
1144}
@ VT_R4
Definition: compat.h:2299
@ VT_R8
Definition: compat.h:2300
HRESULT WINAPI PropVariantToBSTR(REFPROPVARIANT propvar, BSTR *bstr)
Definition: propvar.c:338
#define V_UI1(A)
Definition: oleauto.h:266
#define V_I8(A)
Definition: oleauto.h:249
#define V_BOOL(A)
Definition: oleauto.h:224
#define V_UI2(A)
Definition: oleauto.h:268
#define V_I1(A)
Definition: oleauto.h:243
#define V_I4(A)
Definition: oleauto.h:247
#define V_R4(A)
Definition: oleauto.h:260
#define V_UI4(A)
Definition: oleauto.h:270
#define V_R8(A)
Definition: oleauto.h:262
#define V_UI8(A)
Definition: oleauto.h:272
#define V_I2(A)
Definition: oleauto.h:245

Referenced by test_PropVariantToVariant().

◆ PSSTDAPI_() [1/3]

PSSTDAPI_ ( INT  )

◆ PSSTDAPI_() [2/3]

PSSTDAPI_ ( PCWSTR  )

◆ PSSTDAPI_() [3/3]

PSSTDAPI_ ( ULONG  )

◆ StgDeserializePropVariant()

PSSTDAPI StgDeserializePropVariant ( const SERIALIZEDPROPERTYVALUE pprop,
ULONG  cbmax,
PROPVARIANT *  ppropvar 
)

◆ StgSerializePropVariant()

PSSTDAPI StgSerializePropVariant ( const PROPVARIANT *  ppropvar,
SERIALIZEDPROPERTYVALUE **  ppprop,
ULONG pcb 
)

◆ VariantToGUID()

PSSTDAPI VariantToGUID ( const VARIANT pvar,
GUID guid 
)

Definition at line 919 of file propvar.c.

920{
921 TRACE("(%p %p)\n", pvar, guid);
922
923 switch(V_VT(pvar)) {
924 case VT_BSTR: {
926 if(hres == E_INVALIDARG)
927 return E_FAIL;
928 return hres;
929 }
930
931 default:
932 FIXME("unsupported vt: %d\n", V_VT(pvar));
933 return E_NOTIMPL;
934 }
935}
HRESULT hres
Definition: protocol.c:465

Referenced by test_PropVariantToGUID().

◆ VariantToPropVariant()

PSSTDAPI VariantToPropVariant ( const VARIANT var,
PROPVARIANT *  propvar 
)

Definition at line 1146 of file propvar.c.

1147{
1148 HRESULT hr;
1149
1150 TRACE("var %p, propvar %p.\n", debugstr_variant(var), propvar);
1151
1152 if (!var || !propvar)
1153 return E_INVALIDARG;
1154
1155#ifdef __REACTOS__
1157#else
1158 if (FAILED(hr = VARIANT_ValidateType(var->vt)))
1159#endif
1160 return hr;
1161
1162 PropVariantInit(propvar);
1163
1164
1165#ifdef __REACTOS__
1166 propvar->vt = V_VT(var);
1167#else
1168 propvar->vt = var->vt;
1169#endif
1170
1171#ifdef __REACTOS__
1172 switch (V_VT(var))
1173#else
1174 switch (var->vt)
1175#endif
1176 {
1177 case VT_EMPTY:
1178 case VT_NULL:
1179 break;
1180 case VT_I1:
1181 propvar->cVal = V_I1(var);
1182 break;
1183 case VT_I2:
1184 propvar->iVal = V_I2(var);
1185 break;
1186 case VT_I4:
1187 propvar->lVal = V_I4(var);
1188 break;
1189 case VT_I8:
1190 propvar->hVal.QuadPart = V_I8(var);
1191 break;
1192 case VT_UI1:
1193 propvar->bVal = V_UI1(var);
1194 break;
1195 case VT_UI2:
1196 propvar->uiVal = V_UI2(var);
1197 break;
1198 case VT_UI4:
1199 propvar->ulVal = V_UI4(var);
1200 break;
1201 case VT_UI8:
1202 propvar->uhVal.QuadPart = V_UI8(var);
1203 break;
1204 case VT_BOOL:
1205 propvar->boolVal = V_BOOL(var);
1206 break;
1207 case VT_R4:
1208 propvar->fltVal = V_R4(var);
1209 break;
1210 case VT_R8:
1211 propvar->dblVal = V_R8(var);
1212 break;
1213 case VT_BSTR:
1214 propvar->bstrVal = SysAllocString(V_BSTR(var));
1215 break;
1216 default:
1217#ifdef __REACTOS__
1218 FIXME("Unsupported type %d.\n", V_VT(var));
1219#else
1220 FIXME("Unsupported type %d.\n", var->vt);
1221#endif
1222 return E_INVALIDARG;
1223 }
1224
1225 return S_OK;
1226}
static HRESULT VARIANT_ValidateType(VARTYPE vt)
Definition: propvar.c:39
static const char * debugstr_variant(const VARIANT *var)
Definition: container.c:46

Referenced by test_VariantToPropVariant().

◆ VariantToString()

PSSTDAPI VariantToString ( REFVARIANT  var,
PWSTR  ret,
UINT  cch 
)

Definition at line 503 of file propvar.c.

504{
505 WCHAR buffer[64], *str = buffer;
506
507 TRACE("%p, %p, %u.\n", var, ret, cch);
508
509 *ret = 0;
510
511 if (!cch)
512 return E_INVALIDARG;
513
514 switch (V_VT(var))
515 {
516 case VT_BSTR:
517 str = V_BSTR(var);
518 break;
519 case VT_I4:
521 break;
522 default:
523 FIXME("Unsupported type %d.\n", V_VT(var));
524 return E_NOTIMPL;
525 }
526
527 if (wcslen(str) > cch - 1)
529 wcscpy(ret, str);
530
531 return S_OK;
532}
#define ARRAY_SIZE(A)
Definition: main.h:20
#define swprintf
Definition: precomp.h:40

Referenced by anonymous_namespace{mstscax.cpp}::CAdvancedSettings::IMsRdpClientAdvancedSettings::put_ConnectWithEndpoint(), anonymous_namespace{mstscax.cpp}::CoClass::Invoke(), and test_VariantToString().

Variable Documentation

◆ flags

Definition at line 87 of file propvarutil.h.

◆ propvar2

REFPROPVARIANT propvar2

Definition at line 86 of file propvarutil.h.

Referenced by PropVariantCompareEx().

◆ pszDefault

LPCWSTR pszDefault

Definition at line 103 of file propvarutil.h.

Referenced by PropVariantToStringWithDefault().

◆ uint

REFPROPVARIANT PROPVAR_COMPARE_UNIT uint

Definition at line 87 of file propvarutil.h.

◆ uLDefault

ULONG uLDefault

Definition at line 97 of file propvarutil.h.