22 #define GNUC_OLDER_3_4_4 \
24 ((__GNUC__ <= 3) && (__GNUC_MINOR__ < 4)) || \
25 ((__GNUC__ <= 3) && (__GNUC_MINOR__ <= 4) && (__GNUC_PATCHLEVEL__ <= 4)))
27 #if (defined(__GNUC__)) && (GNUC_OLDER_3_4_4)
28 #ifndef NONAMELESSUNION
29 #define NONAMELESSUNION 1
39 #if defined(HAVE_TYPE_IMULTILANGUAGE2) || defined(HAVE_TYPE_IMULTILANGUAGE)
44 #ifdef HAVE_STDARG_PROTOTYPES
46 #define va_init_list(a,b) va_start(a,b)
49 #define va_init_list(a,b) va_start(a)
53 #define DOUT fprintf(stderr,"[%d]\n",__LINE__)
54 #define DOUTS(x) fprintf(stderr,"[%d]:" #x "=%s\n",__LINE__,x)
55 #define DOUTMSG(x) fprintf(stderr, "[%d]:" #x "\n",__LINE__)
56 #define DOUTI(x) fprintf(stderr, "[%ld]:" #x "=%d\n",__LINE__,x)
57 #define DOUTD(x) fprintf(stderr, "[%d]:" #x "=%f\n",__LINE__,x)
59 #if (defined(__GNUC__)) && (GNUC_OLDER_3_4_4)
60 #define V_UNION1(X, Y) ((X)->u.Y)
62 #define V_UNION1(X, Y) ((X)->Y)
65 #if (defined(__GNUC__)) && (GNUC_OLDER_3_4_4)
67 #define V_UNION(X,Y) ((X)->n1.n2.n3.Y)
70 #define V_VT(X) ((X)->n1.n2.vt)
73 #define V_BOOL(X) V_UNION(X,boolVal)
77 #define V_I1REF(X) V_UNION(X, pcVal)
81 #define V_UI2REF(X) V_UNION(X, puiVal)
85 #define V_INT(X) V_UNION(X, intVal)
89 #define V_INTREF(X) V_UNION(X, pintVal)
93 #define V_UINT(X) V_UNION(X, uintVal)
97 #define V_UINTREF(X) V_UNION(X, puintVal)
104 #if defined(__CYGWIN__) || defined(__MINGW32__)
105 #undef IID_IMultiLanguage2
106 const IID IID_IMultiLanguage2 = {0xDCCFC164, 0x2B38, 0x11d2, {0xB7, 0xEC, 0x00, 0xC0, 0x4F, 0x8F, 0x5D, 0x9A}};
109 #define OLE_RELEASE(X) (X) ? ((X)->lpVtbl->Release(X)) : 0
111 #define OLE_ADDREF(X) (X) ? ((X)->lpVtbl->AddRef(X)) : 0
113 #define OLE_GET_TYPEATTR(X, Y) ((X)->lpVtbl->GetTypeAttr((X), (Y)))
114 #define OLE_RELEASE_TYPEATTR(X, Y) ((X)->lpVtbl->ReleaseTypeAttr((X), (Y)))
116 #define OLE_FREE(x) {\
117 if(g_ole_initialized == TRUE) {\
125 #define OLEData_Get_Struct(obj, pole) {\
126 Data_Get_Struct(obj, struct oledata, pole);\
127 if(!pole->pDispatch) {\
128 rb_raise(rb_eRuntimeError, "failed to get Dispatch Interface");\
132 #ifdef HAVE_LONG_LONG
133 #define I8_2_NUM LL2NUM
134 #define UI8_2_NUM ULL2NUM
135 #define NUM2I8 NUM2LL
136 #define NUM2UI8 NUM2ULL
138 #define I8_2_NUM INT2NUM
139 #define UI8_2_NUM UINT2NUM
140 #define NUM2I8 NUM2INT
141 #define NUM2UI8 NUM2UINT
144 #define WC2VSTR(x) ole_wc2vstr((x), TRUE)
146 #define WIN32OLE_VERSION "1.5.3"
148 typedef HRESULT (STDAPICALLTYPE FNCOCREATEINSTANCEEX)
149 (REFCLSID, IUnknown*,
DWORD, COSERVERINFO*,
DWORD, MULTI_QI*);
168 STDMETHOD(GetTypeInfoCount)(
171 STDMETHOD(GetTypeInfo)(
176 STDMETHOD(GetIDsOfNames)(
236 #if defined(HAVE_TYPE_IMULTILANGUAGE2)
238 #elif defined(HAVE_TYPE_IMULTILANGUAGE)
241 #define pIMultiLanguage NULL
290 static HRESULT ( STDMETHODCALLTYPE QueryInterface )(IDispatch __RPC_FAR *, REFIID
riid,
void __RPC_FAR *__RPC_FAR *
ppvObject);
291 static ULONG ( STDMETHODCALLTYPE AddRef )(IDispatch __RPC_FAR * This);
292 static ULONG ( STDMETHODCALLTYPE Release )(IDispatch __RPC_FAR * This);
293 static HRESULT ( STDMETHODCALLTYPE GetTypeInfoCount )(IDispatch __RPC_FAR * This, UINT __RPC_FAR *
pctinfo);
294 static HRESULT ( STDMETHODCALLTYPE GetTypeInfo )(IDispatch __RPC_FAR * This, UINT
iTInfo, LCID
lcid, ITypeInfo __RPC_FAR *__RPC_FAR *
ppTInfo);
303 #ifndef pIMultiLanguage
333 static void ole_set_byref(VARIANT *realvar, VARIANT *var, VARTYPE vt);
379 static VALUE set_argv(VARIANTARG* realargs,
unsigned int beg,
unsigned int end);
556 static HRESULT find_coclass(ITypeInfo *pTypeInfo, TYPEATTR *pTypeAttr, ITypeInfo **pTypeInfo2, TYPEATTR **pTypeAttr2);
592 static HRESULT (STDMETHODCALLTYPE mf_QueryInterface)(
593 IMessageFilter __RPC_FAR * This,
597 if (
MEMCMP(riid, &IID_IUnknown, GUID, 1) == 0
598 ||
MEMCMP(riid, &IID_IMessageFilter, GUID, 1) == 0)
603 return E_NOINTERFACE;
606 static ULONG (STDMETHODCALLTYPE mf_AddRef)(
607 IMessageFilter __RPC_FAR * This)
612 static ULONG (STDMETHODCALLTYPE mf_Release)(
613 IMessageFilter __RPC_FAR * This)
618 static DWORD (STDMETHODCALLTYPE mf_HandleInComingCall)(
619 IMessageFilter __RPC_FAR * pThis,
626 #ifdef DEBUG_MESSAGEFILTER
627 printf(
"incoming %08X, %08X, %d\n", dwCallType, threadIDCaller, dwTickCount);
633 case CALLTYPE_TOPLEVEL_CALLPENDING:
634 case CALLTYPE_ASYNC_CALLPENDING:
636 return SERVERCALL_RETRYLATER;
649 return SERVERCALL_ISHANDLED;
652 static DWORD (STDMETHODCALLTYPE mf_RetryRejectedCall)(
653 IMessageFilter* pThis,
668 static DWORD (STDMETHODCALLTYPE mf_MessagePending)(
669 IMessageFilter* pThis,
676 return PENDINGMSG_WAITNOPROCESS;
684 return PENDINGMSG_WAITNOPROCESS;
694 static HRESULT ( STDMETHODCALLTYPE QueryInterface )(
695 IDispatch __RPC_FAR * This,
699 if (
MEMCMP(riid, &IID_IUnknown, GUID, 1) == 0
700 ||
MEMCMP(riid, &IID_IDispatch, GUID, 1) == 0)
707 return E_NOINTERFACE;
710 static ULONG ( STDMETHODCALLTYPE AddRef )(
711 IDispatch __RPC_FAR * This)
717 static ULONG ( STDMETHODCALLTYPE Release )(
718 IDispatch __RPC_FAR * This)
730 static HRESULT ( STDMETHODCALLTYPE GetTypeInfoCount )(
731 IDispatch __RPC_FAR * This,
737 static HRESULT ( STDMETHODCALLTYPE GetTypeInfo )(
738 IDispatch __RPC_FAR * This,
741 ITypeInfo __RPC_FAR *__RPC_FAR *
ppTInfo)
747 static HRESULT ( STDMETHODCALLTYPE GetIDsOfNames )(
748 IDispatch __RPC_FAR * This,
764 static HRESULT ( STDMETHODCALLTYPE Invoke )(
765 IDispatch __RPC_FAR * This,
783 if (dispIdMember == DISPID_VALUE) {
784 if (wFlags == DISPATCH_METHOD) {
786 }
else if (wFlags & DISPATCH_PROPERTYGET) {
821 memset(&st, 0,
sizeof(SYSTEMTIME));
829 SystemTimeToVariantTime(&st, &t);
838 VariantTimeToSystemTime(date, &st);
847 if (st.wMilliseconds > 0) {
853 #define ENC_MACHING_CP(enc,encname,cp) if(strcasecmp(rb_enc_name((enc)),(encname)) == 0) return cp
926 #ifndef pIMultiLanguage
933 #if defined(HAVE_TYPE_IMULTILANGUAGE2)
934 hr = CoCreateInstance(&CLSID_CMultiLanguage,
NULL, CLSCTX_INPROC_SERVER,
935 &IID_IMultiLanguage2, &p);
936 #elif defined(HAVE_TYPE_IMULTILANGUAGE)
937 hr = CoCreateInstance(&CLSID_CMultiLanguage,
NULL, CLSCTX_INPROC_SERVER,
938 &IID_IMultiLanguage, &p);
947 #define load_conv_function51932() failed_load_conv51932()
950 #define conv_51932(cp) ((cp) == 51932 && (load_conv_function51932(), 1))
973 rb_raise(
eWIN32OLERuntimeError,
"codepage should be WIN32OLE::CP_ACP, WIN32OLE::CP_OEMCP, WIN32OLE::CP_MACCP, WIN32OLE::CP_THREAD_ACP, WIN32OLE::CP_SYMBOL, WIN32OLE::CP_UTF7, WIN32OLE::CP_UTF8, or installed codepage.");
1023 if (!pGetCPInfoEx) {
1025 GetProcAddress(GetModuleHandle(
"kernel32"),
"GetCPInfoEx");
1026 if (!pGetCPInfoEx) {
1027 pGetCPInfoEx = (
void*)-1;
1032 if (pGetCPInfoEx == (
void*)-1 || !pGetCPInfoEx(cp, 0, buf)) {
1046 rb_raise(
eWIN32OLERuntimeError,
"codepage should be WIN32OLE::CP_ACP, WIN32OLE::CP_OEMCP, WIN32OLE::CP_MACCP, WIN32OLE::CP_THREAD_ACP, WIN32OLE::CP_SYMBOL, WIN32OLE::CP_UTF7, WIN32OLE::CP_UTF8, or installed codepage.");
1064 #ifndef pIMultiLanguage
1103 sprintf(strhr,
" HRESULT error code:0x%08x\n ", (
unsigned)hr);
1105 dwCount = FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER |
1106 FORMAT_MESSAGE_FROM_SYSTEM |
1107 FORMAT_MESSAGE_IGNORE_INSERTS,
1109 MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US),
1110 (LPTSTR)&p_msg, 0,
NULL);
1112 dwCount = FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER |
1113 FORMAT_MESSAGE_FROM_SYSTEM |
1114 FORMAT_MESSAGE_IGNORE_INSERTS,
1116 (LPTSTR)&p_msg, 0,
NULL);
1119 term = p_msg +
strlen(p_msg);
1120 while (p_msg < term) {
1122 if (*term ==
'\r' || *term ==
'\n')
1126 if (p_msg[0] !=
'\0') {
1137 SysFreeString(pExInfo->bstrDescription);
1138 SysFreeString(pExInfo->bstrSource);
1139 SysFreeString(pExInfo->bstrHelpFile);
1145 char error_code[40];
1146 char *pSource =
NULL;
1147 char *pDescription =
NULL;
1149 if(pExInfo->pfnDeferredFillIn !=
NULL) {
1150 (*pExInfo->pfnDeferredFillIn)(pExInfo);
1152 if (pExInfo->bstrSource !=
NULL) {
1153 pSource =
ole_wc2mb(pExInfo->bstrSource);
1155 if (pExInfo->bstrDescription !=
NULL) {
1156 pDescription =
ole_wc2mb(pExInfo->bstrDescription);
1158 if(pExInfo->wCode == 0) {
1159 sprintf(error_code,
"\n OLE error code:%lX in ", pExInfo->scode);
1162 sprintf(error_code,
"\n OLE error code:%u in ", pExInfo->wCode);
1165 if(pSource !=
NULL) {
1172 if(pDescription !=
NULL) {
1178 if(pSource)
free(pSource);
1179 if(pDescription)
free(pDescription);
1195 if(err_msg !=
Qnil) {
1216 hr = OleInitialize(
NULL);
1238 while(PeekMessage(&msg,
NULL,0,0,PM_REMOVE)) {
1239 TranslateMessage(&msg);
1240 DispatchMessage(&msg);
1306 cp == CP_THREAD_ACP ||
1317 #ifndef pIMultiLanguage
1325 pw = SysAllocStringLen(
NULL, size);
1336 pw = SysAllocStringLen(
NULL, size);
1348 #ifndef pIMultiLanguage
1356 pw = SysAllocStringLen(
NULL, size);
1366 pw = SysAllocStringLen(
NULL, size - 1);
1367 MultiByteToWideChar(
cWIN32OLE_cp, 0, pm, len, pw, size);
1398 switch(V_VT(pvar)) {
1400 return &V_UI1(pvar);
1406 return &V_UI2(pvar);
1412 return &V_UI4(pvar);
1420 #if (_MSC_VER >= 1300) || defined(__CYGWIN__) || defined(__MINGW32__)
1425 return &V_UI8(pvar);
1429 return &
V_INT(pvar);
1438 return &V_DATE(pvar);
1441 return V_BSTR(pvar);
1444 return V_DISPATCH(pvar);
1447 return &V_ERROR(pvar);
1450 return &V_BOOL(pvar);
1453 return V_UNKNOWN(pvar);
1456 return &V_ARRAY(pvar);
1468 for (i = 0; i < dim; i++) {
1469 if (pid[i] > pub[i]) {
1489 if ((V_VT(&var) == VT_DISPATCH && V_DISPATCH(&var) ==
NULL) ||
1490 (V_VT(&var) == VT_UNKNOWN && V_UNKNOWN(&var) ==
NULL)) {
1493 hr = SafeArrayPutElement(psa, pid, p);
1499 if (pid[i] > pub[i]) {
1516 for (i = 0; i <
len; i++) {
1541 for (i = 0; i <
len; i++) {
1544 if (ary_len < ary_len1) {
1560 SAFEARRAYBOUND *psab =
NULL;
1561 SAFEARRAY *psa =
NULL;
1568 psab =
ALLOC_N(SAFEARRAYBOUND, dim);
1572 if(!psab || !pub || !pid) {
1574 if(psab)
free(psab);
1579 for (i = 0; i < dim; i++) {
1581 psab[
i].lLbound = 0;
1582 pub[
i] = psab[
i].cElements - 1;
1586 if ((vt & ~VT_BYREF) == VT_ARRAY) {
1587 vt = (vt | VT_VARIANT);
1589 psa = SafeArrayCreate((VARTYPE)(vt & VT_TYPEMASK), dim, psab);
1593 hr = SafeArrayLock(psa);
1594 if (SUCCEEDED(hr)) {
1596 hr = SafeArrayUnlock(psa);
1600 if(psab)
free(psab);
1603 if (SUCCEEDED(hr)) {
1609 SafeArrayDestroy(psa);
1622 V_VT(var) = VT_DISPATCH;
1628 VariantCopy(var, &(pvar->
var));
1633 V_VT(var) = VT_DATE;
1637 switch (
TYPE(val)) {
1642 V_VT(var) = VT_BSTR;
1658 V_VT(var) = VT_BOOL;
1659 V_BOOL(var) = VARIANT_TRUE;
1662 V_VT(var) = VT_BOOL;
1663 V_BOOL(var) = VARIANT_FALSE;
1667 V_VT(var) = VT_ERROR;
1668 V_ERROR(var) = DISP_E_PARAMNOTFOUND;
1670 V_VT(var) = VT_EMPTY;
1674 V_VT(var) = VT_DISPATCH;
1684 if (vt == VT_VARIANT) {
1687 V_VT(var) = (vt & ~VT_BYREF);
1688 if (V_VT(var) == VT_DISPATCH) {
1689 V_DISPATCH(var) =
NULL;
1690 }
else if (V_VT(var) == VT_UNKNOWN) {
1691 V_UNKNOWN(var) =
NULL;
1696 #if (_MSC_VER >= 1300) || defined(__CYGWIN__) || defined(__MINGW32__)
1697 switch(vt & ~VT_BYREF) {
1700 V_I8(var) =
NUM2I8 (val);
1718 switch (
TYPE(val)) {
1720 if (V_VT(var) == (VT_BSTR | VT_BYREF)) {
1726 case (VT_UI1 | VT_BYREF) :
1727 *V_UI1REF(var) =
NUM2CHR(val);
1729 case (VT_I2 | VT_BYREF) :
1730 *V_I2REF(var) = (short)
NUM2INT(val);
1732 case (VT_I4 | VT_BYREF) :
1735 case (VT_R4 | VT_BYREF) :
1736 *V_R4REF(var) = (float)
NUM2INT(val);
1738 case (VT_R8 | VT_BYREF) :
1747 case (VT_I2 | VT_BYREF) :
1748 *V_I2REF(var) = (short)
NUM2INT(val);
1750 case (VT_I4 | VT_BYREF) :
1753 case (VT_R4 | VT_BYREF) :
1754 *V_R4REF(var) = (float)
NUM2DBL(val);
1756 case (VT_R8 | VT_BYREF) :
1764 if (V_VT(var) == (VT_R8 | VT_BYREF)) {
1769 if (V_VT(var) == (VT_BOOL | VT_BYREF)) {
1770 *V_BOOLREF(var) = VARIANT_TRUE;
1774 if (V_VT(var) == (VT_BOOL | VT_BYREF)) {
1775 *V_BOOLREF(var) = VARIANT_FALSE;
1787 if (vt == (VT_VARIANT|VT_BYREF)) {
1790 if (V_VT(realvar) != (vt & ~VT_BYREF)) {
1793 switch(vt & ~VT_BYREF) {
1795 V_I1REF(var) = &V_I1(realvar);
1798 V_UI1REF(var) = &V_UI1(realvar);
1801 V_I2REF(var) = &V_I2(realvar);
1807 V_I4REF(var) = &V_I4(realvar);
1810 V_UI4REF(var) = &V_UI4(realvar);
1813 V_R4REF(var) = &V_R4(realvar);
1816 V_R8REF(var) = &V_R8(realvar);
1819 #if (_MSC_VER >= 1300)
1821 V_I8REF(var) = &V_I8(realvar);
1824 V_UI8REF(var) = &V_UI8(realvar);
1836 V_CYREF(var) = &V_CY(realvar);
1839 V_DATEREF(var) = &V_DATE(realvar);
1842 V_BSTRREF(var) = &V_BSTR(realvar);
1845 V_DISPATCHREF(var) = &V_DISPATCH(realvar);
1848 V_ERRORREF(var) = &V_ERROR(realvar);
1851 V_BOOLREF(var) = &V_BOOL(realvar);
1854 V_UNKNOWNREF(var) = &V_UNKNOWN(realvar);
1857 V_ARRAYREF(var) = &V_ARRAY(realvar);
1871 if (((vt & ~VT_BYREF) == (VT_ARRAY | VT_UI1)) &&
TYPE(val) ==
T_STRING) {
1874 SAFEARRAY *p =
NULL;
1875 SAFEARRAY *psa = SafeArrayCreateVector(VT_UI1, 0, len);
1879 hr = SafeArrayAccessData(psa, &pdest);
1880 if (SUCCEEDED(hr)) {
1882 SafeArrayUnaccessData(psa);
1883 V_VT(&(pvar->
realvar)) = (vt & ~VT_BYREF);
1884 p = V_ARRAY(&(pvar->
realvar));
1886 SafeArrayDestroy(p);
1888 V_ARRAY(&(pvar->
realvar)) = psa;
1889 if (vt & VT_BYREF) {
1890 V_VT(&(pvar->
var)) = vt;
1891 V_ARRAYREF(&(pvar->
var)) = &(V_ARRAY(&(pvar->
realvar)));
1893 hr = VariantCopy(&(pvar->
var), &(pvar->
realvar));
1897 SafeArrayDestroy(psa);
1899 }
else if (vt & VT_ARRAY) {
1901 V_VT(&(pvar->
var)) = vt;
1902 if (vt & VT_BYREF) {
1903 V_ARRAYREF(&(pvar->
var)) = &(V_ARRAY(&(pvar->
realvar)));
1907 if (SUCCEEDED(hr)) {
1908 if (vt & VT_BYREF) {
1909 V_VT(&(pvar->
var)) = vt;
1910 V_ARRAYREF(&(pvar->
var)) = &(V_ARRAY(&(pvar->
realvar)));
1912 hr = VariantCopy(&(pvar->
var), &(pvar->
realvar));
1916 #if (_MSC_VER >= 1300) || defined(__CYGWIN__) || defined(__MINGW32__)
1917 }
else if ( (vt & ~VT_BYREF) == VT_I8 || (vt & ~VT_BYREF) == VT_UI8) {
1920 V_VT(&(pvar->
var)) = vt;
1921 if (vt & VT_BYREF) {
1927 V_VT(&(pvar->
var)) = vt;
1928 if (vt == (VT_BYREF | VT_VARIANT)) {
1931 V_VT(&(pvar->
realvar)) = vt & ~VT_BYREF;
1932 if (vt & VT_BYREF) {
1938 if (vt == (VT_BYREF | VT_VARIANT)) {
1940 }
else if (vt & VT_BYREF) {
1941 if ( (vt & ~VT_BYREF) != V_VT(&(pvar->
realvar))) {
1945 if (SUCCEEDED(hr)) {
1949 if (vt == V_VT(&(pvar->
realvar))) {
1950 hr = VariantCopy(&(pvar->
var), &(pvar->
realvar));
1952 hr = VariantChangeTypeEx(&(pvar->
var), &(pvar->
realvar),
2028 long *ids =
ALLOC_N(
long, dim);
2032 for(i = 0; i < dim; i++) {
2033 ids[
i] = pid[
i] - plb[
i];
2037 for(i = 0; i < dim-1; i++) {
2051 long id = pid[dim - 1] - plb[dim - 1];
2061 while ( V_VT(pvar) == (VT_BYREF | VT_VARIANT) )
2062 pvar = V_VARIANTREF(pvar);
2064 if(V_ISARRAY(pvar)) {
2065 SAFEARRAY *psa = V_ISBYREF(pvar) ? *V_ARRAYREF(pvar) : V_ARRAY(pvar);
2067 long *pid, *plb, *pub;
2074 dim = SafeArrayGetDim(psa);
2075 VariantInit(&variant);
2076 V_VT(&variant) = (V_VT(pvar) & ~VT_ARRAY) | VT_BYREF;
2082 if(!pid || !plb || !pub) {
2089 for(i = 0; i < dim; ++
i) {
2090 SafeArrayGetLBound(psa, i+1, &plb[i]);
2091 SafeArrayGetLBound(psa, i+1, &pid[i]);
2092 SafeArrayGetUBound(psa, i+1, &pub[i]);
2094 hr = SafeArrayLock(psa);
2095 if (SUCCEEDED(hr)) {
2100 hr = SafeArrayPtrOfIndex(psa, pid, &V_BYREF(&variant));
2101 if (SUCCEEDED(hr)) {
2105 for (i = 0; i < dim; ++
i) {
2106 if (++pid[i] <= pub[i])
2111 SafeArrayUnlock(psa);
2118 switch(V_VT(pvar) & ~VT_BYREF){
2127 obj =
INT2NUM((
long)V_I1(pvar));
2132 obj =
INT2NUM((
long)*V_UI1REF(pvar));
2134 obj =
INT2NUM((
long)V_UI1(pvar));
2139 obj =
INT2NUM((
long)*V_I2REF(pvar));
2141 obj =
INT2NUM((
long)V_I2(pvar));
2148 obj =
INT2NUM((
long)V_UI2(pvar));
2153 obj =
INT2NUM((
long)*V_I4REF(pvar));
2155 obj =
INT2NUM((
long)V_I4(pvar));
2160 obj =
INT2NUM((
long)*V_UI4REF(pvar));
2162 obj =
INT2NUM((
long)V_UI4(pvar));
2179 #if (_MSC_VER >= 1300) || defined(__CYGWIN__) || defined(__MINGW32__)
2182 #if (_MSC_VER >= 1300)
2192 #if (_MSC_VER >= 1300)
2227 obj =
INT2NUM(*V_ERRORREF(pvar));
2233 if (V_ISBYREF(pvar))
2243 if (V_ISBYREF(pvar))
2244 pDispatch = *V_DISPATCHREF(pvar);
2246 pDispatch = V_DISPATCH(pvar);
2248 if (pDispatch !=
NULL ) {
2263 if (V_ISBYREF(pvar))
2264 punk = *V_UNKNOWNREF(pvar);
2266 punk = V_UNKNOWN(pvar);
2269 hr = punk->lpVtbl->QueryInterface(punk, &IID_IDispatch, &p);
2282 date = *V_DATEREF(pvar);
2284 date = V_DATE(pvar);
2294 VariantInit(&variant);
2295 hr = VariantChangeTypeEx(&variant, pvar,
2297 if (SUCCEEDED(hr) && V_VT(&variant) == VT_BSTR) {
2300 VariantClear(&variant);
2310 return RegOpenKeyEx(hkey, name, 0, KEY_READ, phkey);
2322 char buf[BUFSIZ + 1];
2325 LONG
err = RegEnumKeyEx(hkey, i, buf, &size_buf,
2327 if(err == ERROR_SUCCESS) {
2341 LONG
err = RegQueryValueEx(hkey, subkey,
NULL, &dwtype,
NULL, &size);
2343 if (err == ERROR_SUCCESS) {
2344 pbuf =
ALLOC_N(
char, size + 1);
2345 err = RegQueryValueEx(hkey, subkey,
NULL, &dwtype, (BYTE *)pbuf, &size);
2346 if (err == ERROR_SUCCESS) {
2348 if (dwtype == REG_EXPAND_SZ) {
2349 char* pbuf2 = (
char *)pbuf;
2351 pbuf =
ALLOC_N(
char, len + 1);
2352 ExpandEnvironmentStrings(pbuf2, pbuf, len + 1);
2368 err = RegOpenKeyEx(hkey, subkey, 0, KEY_READ, &hsubkey);
2369 if (err == ERROR_SUCCESS) {
2371 RegCloseKey(hsubkey);
2401 char path[MAX_PATH + 1];
2403 err =
reg_open_key(HKEY_CLASSES_ROOT,
"CLSID", &hroot);
2404 if (err != ERROR_SUCCESS) {
2408 if (err != ERROR_SUCCESS) {
2414 RegCloseKey(hclsid);
2415 if (typelib !=
Qnil) {
2416 ExpandEnvironmentStrings(
StringValuePtr(typelib), path,
sizeof(path));
2417 path[MAX_PATH] =
'\0';
2426 HKEY htypelib, hclsid, hversion, hlang;
2437 err =
reg_open_key(HKEY_CLASSES_ROOT,
"TypeLib", &htypelib);
2438 if(err != ERROR_SUCCESS) {
2441 for(i = 0; !found; i++) {
2446 if (err != ERROR_SUCCESS)
2449 for(j = 0; !found; j++) {
2458 if (typelib ==
Qnil)
2461 for(k = 0; !found; k++) {
2466 if (err == ERROR_SUCCESS) {
2473 RegCloseKey(hversion);
2475 RegCloseKey(hclsid);
2477 RegCloseKey(htypelib);
2497 ITypeInfo *pTypeInfo;
2498 TYPEATTR *pTypeAttr;
2508 count = pTypeLib->lpVtbl->GetTypeInfoCount(pTypeLib);
2509 for (index = 0; index <
count; index++) {
2510 hr = pTypeLib->lpVtbl->GetTypeInfo(pTypeLib, index, &pTypeInfo);
2518 for(iVar = 0; iVar < pTypeAttr->cVars; iVar++) {
2519 hr = pTypeInfo->lpVtbl->GetVarDesc(pTypeInfo, iVar, &pVarDesc);
2522 if(pVarDesc->varkind == VAR_CONST &&
2523 !(pVarDesc->wVarFlags & (VARFLAG_FHIDDEN |
2524 VARFLAG_FRESTRICTED |
2525 VARFLAG_FNONBROWSABLE))) {
2526 hr = pTypeInfo->lpVtbl->GetNames(pTypeInfo, pVarDesc->memid, &bstr,
2528 if(FAILED(hr) || len == 0 || !bstr)
2532 *pName = toupper((
int)*pName);
2540 SysFreeString(bstr);
2546 pTypeInfo->lpVtbl->ReleaseVarDesc(pTypeInfo, pVarDesc);
2548 pTypeInfo->lpVtbl->ReleaseTypeAttr(pTypeInfo, pTypeAttr);
2566 err = RegConnectRegistry(
StringValuePtr(host), HKEY_LOCAL_MACHINE, &hlm);
2567 if (err != ERROR_SUCCESS)
2568 return HRESULT_FROM_WIN32(err);
2572 err = RegOpenKeyEx(hlm,
StringValuePtr(subkey), 0, KEY_READ, &hpid);
2573 if (err != ERROR_SUCCESS)
2574 hr = HRESULT_FROM_WIN32(err);
2576 len =
sizeof(clsid);
2577 err = RegQueryValueEx(hpid,
"",
NULL, &dwtype, (BYTE *)clsid, &len);
2578 if (err == ERROR_SUCCESS && dwtype == REG_SZ) {
2580 hr = CLSIDFromString(pbuf, pclsid);
2581 SysFreeString(pbuf);
2584 hr = HRESULT_FROM_WIN32(err);
2595 VALUE ole, host, others;
2600 COSERVERINFO serverinfo;
2602 DWORD clsctx = CLSCTX_REMOTE_SERVER;
2605 gole32 = LoadLibrary(
"OLE32");
2610 GetProcAddress(
gole32,
"CoCreateInstanceEx");
2616 hr = CLSIDFromProgID(pbuf, &clsid);
2620 hr = CLSIDFromString(pbuf, &clsid);
2621 SysFreeString(pbuf);
2624 "unknown OLE server: `%s'",
2626 memset(&serverinfo, 0,
sizeof(COSERVERINFO));
2628 memset(&multi_qi, 0,
sizeof(MULTI_QI));
2629 multi_qi.pIID = &IID_IDispatch;
2631 SysFreeString(serverinfo.pwszName);
2634 "failed to create DCOM server `%s' in `%s'",
2655 hr = CreateBindCtx(0, &pBindCtx);
2658 "failed to create bind context");
2662 hr = MkParseDisplayName(pBindCtx, pbuf, &eaten, &pMoniker);
2663 SysFreeString(pbuf);
2667 "failed to parse display name of moniker `%s'",
2670 hr = pMoniker->lpVtbl->BindToObject(pMoniker, pBindCtx,
NULL,
2671 &IID_IDispatch, &p);
2678 "failed to bind moniker `%s'",
2718 hr = CLSIDFromProgID(pBuf, &clsid);
2720 hr = CLSIDFromString(pBuf, &clsid);
2722 SysFreeString(pBuf);
2727 hr = GetActiveObject(&clsid, 0, &pUnknown);
2732 hr = pUnknown->lpVtbl->QueryInterface(pUnknown, &IID_IDispatch, &p);
2737 "failed to create WIN32OLE server `%s'",
2781 ITypeInfo *pTypeInfo;
2799 0, lcid, &pTypeInfo);
2803 hr = pTypeInfo->lpVtbl->GetContainingTypeLib(pTypeInfo, &pTypeLib, &index);
2823 hr = LoadTypeLibEx(pBuf, REGKIND_NONE, &pTypeLib);
2824 SysFreeString(pBuf);
2849 ITypeInfo *pTypeInfo;
2853 count = pTypeLib->lpVtbl->GetTypeInfoCount(pTypeLib);
2854 for (i = 0; i <
count; i++) {
2855 hr = pTypeLib->lpVtbl->GetDocumentation(pTypeLib, i,
2860 hr = pTypeLib->lpVtbl->GetTypeInfo(pTypeLib, i, &pTypeInfo);
2926 FNHTMLHELP *pfnHtmlHelp;
2930 ghhctrl = LoadLibrary(
"HHCTRL.OCX");
2933 pfnHtmlHelp = (FNHTMLHELP*)GetProcAddress(
ghhctrl,
"HtmlHelpA");
3000 static BOOL CALLBACK
3094 case LOCALE_SYSTEM_DEFAULT:
3095 case LOCALE_USER_DEFAULT:
3119 hr = CoCreateGuid(&guid);
3123 len = StringFromGUID2(&guid, bstr,
sizeof(bstr)/
sizeof(OLECHAR));
3139 hr = OleInitialize(
NULL);
3232 rb_scan_args(argc, argv,
"11*", &svr_name, &host, &others);
3250 hr = CLSIDFromProgID(pBuf, &clsid);
3252 hr = CLSIDFromString(pBuf, &clsid);
3254 SysFreeString(pBuf);
3257 "unknown OLE server: `%s'",
3262 hr = CoCreateInstance(&clsid,
NULL, CLSCTX_INPROC_SERVER | CLSCTX_LOCAL_SERVER,
3263 &IID_IDispatch, &p);
3267 "failed to create WIN32OLE object from `%s'",
3278 unsigned int index,
i;
3280 index = pOp->
dp.cNamedArgs;
3288 for(i = 1; i < index + 1; i++) {
3292 for(i = 0; i < index; i++ ) {
3293 VariantClear(&(pOp->
dp.rgvarg[i]));
3306 VariantInit(&(pOp->
dp.rgvarg[index]));
3309 pOp->
dp.cNamedArgs += 1;
3314 set_argv(VARIANTARG* realargs,
unsigned int beg,
unsigned int end)
3320 while (end-- > beg) {
3322 VariantClear(&realargs[end]);
3343 EXCEPINFO excepinfo;
3345 VARIANTARG* realargs =
NULL;
3346 unsigned int argErr = 0;
3348 unsigned int cNamedArgs;
3352 memset(&excepinfo, 0,
sizeof(EXCEPINFO));
3354 VariantInit(&result);
3357 op.
dp.rgdispidNamedArgs =
NULL;
3358 op.
dp.cNamedArgs = 0;
3373 DispID = DISPID_VALUE;
3379 &wcmdname, 1, lcid, &DispID);
3380 SysFreeString(wcmdname);
3383 "unknown property or method: `%s'",
3391 op.
dp.cNamedArgs = 0;
3399 op.
dp.cArgs = cNamedArgs + argc - 2;
3404 pDispID =
ALLOCA_N(DISPID, cNamedArgs + 1);
3409 op.dp.cNamedArgs + 1,
3411 for(i = 0; i < op.dp.cNamedArgs + 1; i++) {
3412 SysFreeString(op.pNamedArgs[i]);
3413 op.pNamedArgs[
i] =
NULL;
3417 for(i = 0; i < op.dp.cArgs; i++ ) {
3418 VariantClear(&op.dp.rgvarg[i]);
3421 "failed to get named argument info: `%s'",
3424 op.dp.rgdispidNamedArgs = &(pDispID[1]);
3428 op.
dp.cArgs = argc - 1;
3430 if (op.
dp.cArgs > 0) {
3437 if(op.
dp.cArgs > cNamedArgs) {
3438 realargs =
ALLOCA_N(VARIANTARG, op.
dp.cArgs-cNamedArgs+1);
3439 for(i = cNamedArgs; i < op.
dp.cArgs; i++) {
3440 n = op.
dp.cArgs - i + cNamedArgs - 1;
3441 VariantInit(&realargs[n]);
3442 VariantInit(&op.
dp.rgvarg[n]);
3446 VariantCopy(&op.
dp.rgvarg[n], &(pvar->
var));
3449 V_VT(&op.
dp.rgvarg[n]) = VT_VARIANT | VT_BYREF;
3450 V_VARIANTREF(&op.
dp.rgvarg[n]) = &realargs[n];
3455 if (wFlags & DISPATCH_PROPERTYPUT) {
3456 if (op.
dp.cArgs == 0)
3459 op.
dp.cNamedArgs = 1;
3460 op.
dp.rgdispidNamedArgs =
ALLOCA_N( DISPID, 1 );
3461 op.
dp.rgdispidNamedArgs[0] = DISPID_PROPERTYPUT;
3465 &IID_NULL, lcid, wFlags, &op.
dp,
3466 &result, &excepinfo, &argErr);
3470 if(op.
dp.cArgs >= cNamedArgs) {
3471 for(i = cNamedArgs; i < op.
dp.cArgs; i++) {
3472 n = op.
dp.cArgs - i + cNamedArgs - 1;
3476 if (hr == DISP_E_EXCEPTION) {
3479 memset(&excepinfo, 0,
sizeof(EXCEPINFO));
3480 VariantInit(&result);
3482 &IID_NULL, lcid, wFlags,
3484 &excepinfo, &argErr);
3490 if ((hr == DISP_E_EXCEPTION || hr == DISP_E_MEMBERNOTFOUND) && DispID > 0x8000) {
3491 if (hr == DISP_E_EXCEPTION) {
3494 memset(&excepinfo, 0,
sizeof(EXCEPINFO));
3496 &IID_NULL, lcid, wFlags,
3498 &excepinfo, &argErr);
3501 for(i = cNamedArgs; i < op.
dp.cArgs; i++) {
3502 n = op.
dp.cArgs - i + cNamedArgs - 1;
3503 VariantClear(&op.
dp.rgvarg[n]);
3509 if (op.
dp.cArgs > cNamedArgs) {
3510 for(i = cNamedArgs; i < op.
dp.cArgs; i++) {
3511 n = op.
dp.cArgs - i + cNamedArgs - 1;
3515 if (hr == DISP_E_EXCEPTION) {
3518 memset(&excepinfo, 0,
sizeof(EXCEPINFO));
3519 VariantInit(&result);
3521 &IID_NULL, lcid, wFlags,
3523 &excepinfo, &argErr);
3524 for(i = cNamedArgs; i < op.
dp.cArgs; i++) {
3525 n = op.
dp.cArgs - i + cNamedArgs - 1;
3526 VariantClear(&op.
dp.rgvarg[n]);
3533 if(op.
dp.cArgs > cNamedArgs) {
3534 for(i = cNamedArgs; i < op.
dp.cArgs; i++) {
3535 n = op.
dp.cArgs - i + cNamedArgs - 1;
3544 for(i = 0; i < op.
dp.cArgs; i++) {
3545 VariantClear(&op.
dp.rgvarg[i]);
3556 VariantClear(&result);
3576 return ole_invoke(argc, argv,
self, DISPATCH_METHOD|DISPATCH_PROPERTYGET,
FALSE);
3584 unsigned int argErr = 0;
3585 EXCEPINFO excepinfo;
3587 DISPPARAMS dispParams;
3588 VARIANTARG* realargs =
NULL;
3598 memset(&excepinfo, 0,
sizeof(EXCEPINFO));
3599 memset(&dispParams, 0,
sizeof(DISPPARAMS));
3600 VariantInit(&result);
3604 dispParams.rgvarg =
ALLOCA_N(VARIANTARG, dispParams.cArgs);
3605 realargs =
ALLOCA_N(VARIANTARG, dispParams.cArgs);
3606 for (i = 0, j = dispParams.cArgs - 1; i < (
int)dispParams.cArgs; i++, j--)
3608 VariantInit(&realargs[i]);
3609 VariantInit(&dispParams.rgvarg[i]);
3612 V_VT(&dispParams.rgvarg[i]) = vt;
3617 V_VT(&dispParams.rgvarg[i]) = V_VT(&realargs[i]) = VT_ERROR;
3618 V_ERROR(&dispParams.rgvarg[i]) = V_ERROR(&realargs[i]) = DISP_E_PARAMNOTFOUND;
3631 SAFEARRAYBOUND rgsabound[1];
3633 rgsabound[0].lLbound = 0;
3635 v = vt & ~(VT_ARRAY | VT_BYREF);
3636 V_ARRAY(&realargs[i]) = SafeArrayCreate(v, 1, rgsabound);
3637 V_VT(&realargs[i]) = VT_ARRAY |
v;
3638 SafeArrayLock(V_ARRAY(&realargs[i]));
3639 pb = V_ARRAY(&realargs[i])->pvData;
3640 ps = V_ARRAY(&realargs[i])->pvData;
3641 pl = V_ARRAY(&realargs[i])->pvData;
3642 py = V_ARRAY(&realargs[i])->pvData;
3643 pv = V_ARRAY(&realargs[i])->pvData;
3644 for (ent = 0; ent < (int)rgsabound[0].cElements; ent++)
3649 if (v != VT_VARIANT)
3651 VariantChangeTypeEx(&velem, &velem,
3664 *py++ = V_CY(&velem);
3670 *ps++ = V_I2(&velem);
3675 *pb++ = V_UI1(&velem);
3679 *pl++ = V_I4(&velem);
3683 SafeArrayUnlock(V_ARRAY(&realargs[i]));
3688 if ((vt & (~VT_BYREF)) != VT_VARIANT)
3690 hr = VariantChangeTypeEx(&realargs[i], &realargs[i],
3692 (VARTYPE)(vt & (~VT_BYREF)));
3699 if ((vt & VT_BYREF) || vt == VT_VARIANT)
3701 if (vt == VT_VARIANT)
3702 V_VT(&dispParams.rgvarg[i]) = VT_VARIANT | VT_BYREF;
3703 switch (vt & (~VT_BYREF))
3707 V_VARIANTREF(&dispParams.rgvarg[i]) = &realargs[
i];
3713 V_CYREF(&dispParams.rgvarg[i]) = &V_CY(&realargs[i]);
3719 V_I2REF(&dispParams.rgvarg[i]) = &V_I2(&realargs[i]);
3724 V_UI1REF(&dispParams.rgvarg[i]) = &V_UI1(&realargs[i]);
3728 V_I4REF(&dispParams.rgvarg[i]) = &V_I4(&realargs[i]);
3735 V_CY(&dispParams.rgvarg[i]) = V_CY(&realargs[i]);
3740 if (dispkind & DISPATCH_PROPERTYPUT) {
3741 dispParams.cNamedArgs = 1;
3742 dispParams.rgdispidNamedArgs =
ALLOCA_N( DISPID, 1 );
3743 dispParams.rgdispidNamedArgs[0] = DISPID_PROPERTYPUT;
3749 &dispParams, &result,
3750 &excepinfo, &argErr);
3760 if(dispParams.cArgs > 0) {
3761 set_argv(realargs, 0, dispParams.cArgs);
3765 VariantClear(&result);
3784 return ole_invoke2(
self, dispid, args, types, DISPATCH_METHOD);
3802 return ole_invoke2(
self, dispid, args, types, DISPATCH_PROPERTYGET);
3820 return ole_invoke2(
self, dispid, args, types, DISPATCH_PROPERTYPUT);
3895 EXCEPINFO excepinfo;
3896 DISPID dispID = DISPID_VALUE;
3897 DISPID dispIDParam = DISPID_PROPERTYPUT;
3898 USHORT wFlags = DISPATCH_PROPERTYPUT|DISPATCH_PROPERTYPUTREF;
3899 DISPPARAMS dispParams;
3900 VARIANTARG propertyValue[2];
3904 dispParams.rgdispidNamedArgs = &dispIDParam;
3905 dispParams.rgvarg = propertyValue;
3906 dispParams.cNamedArgs = 1;
3907 dispParams.cArgs = 1;
3909 VariantInit(&propertyValue[0]);
3910 VariantInit(&propertyValue[1]);
3911 memset(&excepinfo, 0,
sizeof(excepinfo));
3918 pBuf, 1, lcid, &dispID);
3919 SysFreeString(pBuf[0]);
3924 "unknown property or method: `%s'",
3930 lcid, wFlags, &dispParams,
3931 NULL, &excepinfo, &argErr);
3933 for(index = 0; index < dispParams.cArgs; ++index) {
3934 VariantClear(&propertyValue[index]);
3970 IEnumVARIANT *pEnum = (IEnumVARIANT *)pEnumV;
3971 VariantInit(&variant);
3972 while(pEnum->lpVtbl->Next(pEnum, 1, &variant,
NULL) ==
S_OK) {
3974 VariantClear(&variant);
3975 VariantInit(&variant);
3984 IEnumVARIANT *pEnum = (IEnumVARIANT *)pEnumV;
4010 unsigned int argErr;
4011 EXCEPINFO excepinfo;
4012 DISPPARAMS dispParams;
4015 IEnumVARIANT *pEnum =
NULL;
4020 VariantInit(&result);
4021 dispParams.rgvarg =
NULL;
4022 dispParams.rgdispidNamedArgs =
NULL;
4023 dispParams.cNamedArgs = 0;
4024 dispParams.cArgs = 0;
4025 memset(&excepinfo, 0,
sizeof(excepinfo));
4030 DISPATCH_METHOD | DISPATCH_PROPERTYGET,
4031 &dispParams, &result,
4032 &excepinfo, &argErr);
4035 VariantClear(&result);
4039 if (V_VT(&result) == VT_UNKNOWN) {
4040 hr = V_UNKNOWN(&result)->lpVtbl->QueryInterface(V_UNKNOWN(&result),
4044 }
else if (V_VT(&result) == VT_DISPATCH) {
4045 hr = V_DISPATCH(&result)->lpVtbl->QueryInterface(V_DISPATCH(&result),
4050 if (FAILED(hr) || !pEnum) {
4051 VariantClear(&result);
4055 VariantClear(&result);
4078 if(mname[n-1] ==
'=') {
4085 return ole_invoke(argc, argv,
self, DISPATCH_METHOD|DISPATCH_PROPERTYGET,
FALSE);
4093 TYPEATTR *pTypeAttr;
4095 FUNCDESC *pFuncDesc;
4103 for(i = 0; i < pTypeAttr->cFuncs && method ==
Qnil; i++) {
4104 hr = pTypeInfo->lpVtbl->GetFuncDesc(pTypeInfo, i, &pFuncDesc);
4108 hr = pTypeInfo->lpVtbl->GetDocumentation(pTypeInfo, pFuncDesc->memid,
4111 pTypeInfo->lpVtbl->ReleaseFuncDesc(pTypeInfo, pFuncDesc);
4119 pTypeInfo->lpVtbl->ReleaseFuncDesc(pTypeInfo, pFuncDesc);
4130 TYPEATTR *pTypeAttr;
4133 ITypeInfo *pRefTypeInfo;
4140 if (method !=
Qnil) {
4143 for(i=0; i < pTypeAttr->cImplTypes && method ==
Qnil; i++){
4144 hr = pTypeInfo->lpVtbl->GetRefTypeOfImplType(pTypeInfo, i, &href);
4147 hr = pTypeInfo->lpVtbl->GetRefTypeInfo(pTypeInfo, href, &pRefTypeInfo);
4161 TYPEATTR *pTypeAttr;
4164 FUNCDESC *pFuncDesc;
4171 for(i = 0; i < pTypeAttr->cFuncs; i++) {
4173 hr = pTypeInfo->lpVtbl->GetFuncDesc(pTypeInfo, i, &pFuncDesc);
4177 hr = pTypeInfo->lpVtbl->GetDocumentation(pTypeInfo, pFuncDesc->memid,
4180 pTypeInfo->lpVtbl->ReleaseFuncDesc(pTypeInfo, pFuncDesc);
4183 if(pFuncDesc->invkind & mask) {
4189 pTypeInfo->lpVtbl->ReleaseFuncDesc(pTypeInfo, pFuncDesc);
4201 TYPEATTR *pTypeAttr;
4204 ITypeInfo *pRefTypeInfo;
4212 for(i=0; i < pTypeAttr->cImplTypes; i++){
4213 hr = pTypeInfo->lpVtbl->GetRefTypeOfImplType(pTypeInfo, i, &href);
4216 hr = pTypeInfo->lpVtbl->GetRefTypeInfo(pTypeInfo, href, &pRefTypeInfo);
4229 ITypeInfo *pTypeInfo;
4237 0, lcid, &pTypeInfo);
4241 hr = pTypeInfo->lpVtbl->GetDocumentation(pTypeInfo,
4246 hr = pTypeInfo->lpVtbl->GetContainingTypeLib(pTypeInfo, &pTypeLib, &i);
4251 count = pTypeLib->lpVtbl->GetTypeInfoCount(pTypeLib);
4252 for (i = 0; i <
count; i++) {
4253 hr = pTypeLib->lpVtbl->GetDocumentation(pTypeLib, i,
4256 hr = pTypeLib->lpVtbl->GetTypeInfo(pTypeLib, i, &pTypeInfo);
4257 if (SUCCEEDED(hr)) {
4270 ITypeInfo *pTypeInfo;
4300 return ole_methods(
self, INVOKE_FUNC | INVOKE_PROPERTYGET | INVOKE_PROPERTYPUT | INVOKE_PROPERTYPUTREF);
4332 return ole_methods(
self, INVOKE_PROPERTYPUT|INVOKE_PROPERTYPUTREF);
4361 hr = pTypeInfo->lpVtbl->GetContainingTypeLib( pTypeInfo, &pTypeLib, &index );
4365 hr = pTypeLib->lpVtbl->GetDocumentation( pTypeLib, index,
4388 ITypeInfo *pTypeInfo;
4416 hr = pTypeInfo->lpVtbl->GetContainingTypeLib(pTypeInfo, &pTypeLib, &index);
4441 ITypeInfo *pTypeInfo;
4447 0, lcid, &pTypeInfo);
4453 if (vtlib ==
Qnil) {
4480 hr = CLSIDFromString(pBuf, &iid);
4481 SysFreeString(pBuf);
4484 "invalid iid: `%s'",
4497 "failed to get interface `%s'",
4532 SysFreeString(wcmdname);
4543 hr = pTypeInfo->lpVtbl->GetContainingTypeLib(pTypeInfo, &pTypeLib, &i);
4548 hr = pTypeLib->lpVtbl->GetDocumentation(pTypeLib, i,
4550 helpcontext, helpfile);
4564 ITypeInfo *pRefTypeInfo;
4567 hr = pTypeInfo->lpVtbl->GetRefTypeInfo(pTypeInfo,
4579 if(typedetails !=
Qnil)
4587 TYPEDESC *p = pTypeDesc;
4590 if (p->vt == VT_PTR || p->vt == VT_SAFEARRAY) {
4602 switch(pTypeDesc->vt) {
4645 #if (_MSC_VER >= 1300) || defined(__CYGWIN__) || defined(__MINGW32__)
4667 if(typedetails !=
Qnil)
4672 if(typedetails !=
Qnil)
4678 case VT_USERDEFINED:
4680 if (typedetails !=
Qnil)
4707 if (typedetails !=
Qnil)
4726 ITypeInfo *pTypeInfo;
4769 IPersistMemory *pPersistMemory;
4776 hr = pole->
pDispatch->lpVtbl->QueryInterface(pole->
pDispatch, &IID_IPersistMemory, &p);
4778 if (SUCCEEDED(hr)) {
4779 hr = pPersistMemory->lpVtbl->InitNew(pPersistMemory);
4781 if (SUCCEEDED(hr)) {
4830 return rb_eval_string(
"WIN32OLE_TYPELIB.typelibs.collect{|t|t.name}");
4842 HKEY hclsids, hclsid;
4849 err =
reg_open_key(HKEY_CLASSES_ROOT,
"CLSID", &hclsids);
4850 if(err != ERROR_SUCCESS) {
4858 if (err != ERROR_SUCCESS)
4864 RegCloseKey(hclsid);
4866 RegCloseKey(hclsids);
4905 count = pTypeLib->lpVtbl->GetTypeInfoCount(pTypeLib);
4906 for (i = 0; i < count && found ==
Qfalse; i++) {
4907 hr = pTypeLib->lpVtbl->GetTypeInfo(pTypeLib, i, &pTypeInfo);
4910 hr = pTypeLib->lpVtbl->GetDocumentation(pTypeLib, i,
4951 hr = pTypeLib->lpVtbl->GetLibAttr(pTypeLib, ppTLibAttr);
4954 "failed to get library attribute(TLIBATTR) from ITypeLib");
4971 HKEY htypelib, hguid;
4982 err =
reg_open_key(HKEY_CLASSES_ROOT,
"TypeLib", &htypelib);
4983 if(err != ERROR_SUCCESS) {
4991 if (err != ERROR_SUCCESS)
4995 if (version ==
Qnil)
4999 if (SUCCEEDED(hr)) {
5008 RegCloseKey(htypelib);
5017 if (major ==
Qnil) {
5021 if (minor !=
Qnil) {
5032 HKEY htypelib, hguid, hversion;
5048 err =
reg_open_key(HKEY_CLASSES_ROOT,
"TypeLib", &htypelib);
5049 if(err != ERROR_SUCCESS) {
5053 if (err != ERROR_SUCCESS) {
5054 RegCloseKey(htypelib);
5057 if (version_str !=
Qnil) {
5059 if (err == ERROR_SUCCESS) {
5063 version = version_str;
5066 RegCloseKey(hversion);
5074 if (err != ERROR_SUCCESS)
5078 RegCloseKey(hversion);
5086 RegCloseKey(hversion);
5090 RegCloseKey(htypelib);
5091 if (typelib !=
Qnil) {
5093 if (SUCCEEDED(hr)) {
5104 HKEY htypelib, hguid, hversion;
5114 err =
reg_open_key(HKEY_CLASSES_ROOT,
"TypeLib", &htypelib);
5115 if(err != ERROR_SUCCESS) {
5118 for(i = 0; !found; i++) {
5123 if (err != ERROR_SUCCESS)
5125 for(j = 0; found ==
Qfalse; j++) {
5130 if (err != ERROR_SUCCESS)
5134 RegCloseKey(hversion);
5139 if (SUCCEEDED(hr)) {
5144 RegCloseKey(hversion);
5148 RegCloseKey(htypelib);
5200 if (len < 1 || len > 3) {
5214 hr = LoadTypeLibEx(pbuf, REGKIND_NONE, &pTypeLib);
5215 SysFreeString(pbuf);
5216 if (SUCCEEDED(hr)) {
5245 TLIBATTR *pTLibAttr;
5249 len = StringFromGUID2(&pTLibAttr->guid, bstr,
sizeof(bstr)/
sizeof(OLECHAR));
5253 pTypeLib->lpVtbl->ReleaseTLibAttr(pTypeLib, pTLibAttr);
5274 hr = pTypeLib->lpVtbl->GetDocumentation(pTypeLib, -1,
5296 TLIBATTR *pTLibAttr;
5303 major =
INT2NUM(pTLibAttr->wMajorVerNum);
5304 minor =
INT2NUM(pTLibAttr->wMinorVerNum);
5305 pTypeLib->lpVtbl->ReleaseTLibAttr(pTypeLib, pTLibAttr);
5321 TLIBATTR *pTLibAttr;
5327 major =
INT2NUM(pTLibAttr->wMajorVerNum);
5328 pTypeLib->lpVtbl->ReleaseTLibAttr(pTypeLib, pTLibAttr);
5344 TLIBATTR *pTLibAttr;
5349 minor =
INT2NUM(pTLibAttr->wMinorVerNum);
5350 pTypeLib->lpVtbl->ReleaseTLibAttr(pTypeLib, pTLibAttr);
5370 if (err != ERROR_SUCCESS) {
5373 for(k = 0; path ==
Qnil; k++) {
5378 if (err == ERROR_SUCCESS) {
5395 return E_UNEXPECTED;
5398 hr = LoadTypeLibEx(pBuf, REGKIND_NONE, ppTypeLib);
5399 SysFreeString(pBuf);
5415 TLIBATTR *pTLibAttr;
5424 hr = QueryPathOfRegTypeLib(&pTLibAttr->guid,
5425 pTLibAttr->wMajorVerNum,
5426 pTLibAttr->wMinorVerNum,
5430 pTypeLib->lpVtbl->ReleaseTLibAttr(pTypeLib, pTLibAttr);
5434 pTypeLib->lpVtbl->ReleaseTLibAttr(pTypeLib, pTLibAttr);
5457 TLIBATTR *pTLibAttr;
5462 if ((pTLibAttr->wLibFlags == 0) ||
5463 (pTLibAttr->wLibFlags & LIBFLAG_FRESTRICTED) ||
5464 (pTLibAttr->wLibFlags & LIBFLAG_FHIDDEN)) {
5467 pTypeLib->lpVtbl->ReleaseTLibAttr(pTypeLib, pTLibAttr);
5490 hr = pTypeLib->lpVtbl->GetDocumentation(pTypeLib, -1,
5566 hr = LoadTypeLibEx(pbuf, REGKIND_NONE, &pTypeLib);
5569 SysFreeString(pbuf);
5597 TYPEATTR *pTypeAttr;
5603 switch(pTypeAttr->typekind) {
5613 case TKIND_INTERFACE:
5616 case TKIND_DISPATCH:
5659 TYPEATTR *pTypeAttr;
5666 len = StringFromGUID2(&pTypeAttr->guid, bstr,
sizeof(bstr)/
sizeof(OLECHAR));
5694 TYPEATTR *pTypeAttr;
5700 hr = ProgIDFromCLSID(&pTypeAttr->guid, &pbuf);
5701 if (SUCCEEDED(hr)) {
5703 CoTaskMemFree(pbuf);
5730 TYPEATTR *pTypeAttr;
5735 if (pTypeAttr->wTypeFlags & (TYPEFLAG_FHIDDEN | TYPEFLAG_FRESTRICTED)) {
5764 TYPEATTR *pTypeAttr;
5769 ver =
INT2FIX(pTypeAttr->wMajorVerNum);
5794 TYPEATTR *pTypeAttr;
5799 ver =
INT2FIX(pTypeAttr->wMinorVerNum);
5824 TYPEATTR *pTypeAttr;
5829 typekind =
INT2FIX(pTypeAttr->typekind);
5883 TYPEATTR *pTypeAttr;
5888 if(pTypeAttr->typekind != TKIND_ALIAS) {
5949 &helpcontext,
NULL);
5992 ITypeInfo *pRefTypeInfo;
5996 TYPEATTR *pTypeAttr;
6004 for (i = 0; i < pTypeAttr->cImplTypes; i++) {
6005 hr = pTypeInfo->lpVtbl->GetImplTypeFlags(pTypeInfo, i, &flags);
6009 hr = pTypeInfo->lpVtbl->GetRefTypeOfImplType(pTypeInfo, i, &href);
6012 hr = pTypeInfo->lpVtbl->GetRefTypeInfo(pTypeInfo, href, &pRefTypeInfo);
6016 if ((flags & implflags) == implflags) {
6118 TYPEATTR *pTypeAttr;
6132 for(i = 0; i < pTypeAttr->cVars; i++) {
6133 hr = pTypeInfo->lpVtbl->GetVarDesc(pTypeInfo, i, &pVarDesc);
6138 hr = pTypeInfo->lpVtbl->GetNames(pTypeInfo, pVarDesc->memid, &bstr,
6140 if(FAILED(hr) || len == 0 || !bstr)
6151 pTypeInfo->lpVtbl->ReleaseVarDesc(pTypeInfo, pVarDesc);
6244 hr = pTypeInfo->lpVtbl->GetVarDesc(pTypeInfo, var_index, &pVarDesc);
6248 pTypeInfo->lpVtbl->ReleaseVarDesc(pTypeInfo, pVarDesc);
6286 hr = pTypeInfo->lpVtbl->GetVarDesc(pTypeInfo, var_index, &pVarDesc);
6290 pTypeInfo->lpVtbl->ReleaseVarDesc(pTypeInfo, pVarDesc);
6320 hr = pTypeInfo->lpVtbl->GetVarDesc(pTypeInfo, var_index, &pVarDesc);
6323 if(pVarDesc->varkind == VAR_CONST)
6325 pTypeInfo->lpVtbl->ReleaseVarDesc(pTypeInfo, pVarDesc);
6364 hr = pTypeInfo->lpVtbl->GetVarDesc(pTypeInfo, var_index, &pVarDesc);
6367 if (!(pVarDesc->wVarFlags & (VARFLAG_FHIDDEN |
6368 VARFLAG_FRESTRICTED |
6369 VARFLAG_FNONBROWSABLE))) {
6372 pTypeInfo->lpVtbl->ReleaseVarDesc(pTypeInfo, pVarDesc);
6410 hr = pTypeInfo->lpVtbl->GetVarDesc(pTypeInfo, var_index, &pVarDesc);
6413 switch(pVarDesc->varkind) {
6414 case VAR_PERINSTANCE:
6429 pTypeInfo->lpVtbl->ReleaseVarDesc(pTypeInfo, pVarDesc);
6466 hr = pTypeInfo->lpVtbl->GetVarDesc(pTypeInfo, var_index, &pVarDesc);
6469 pTypeInfo->lpVtbl->ReleaseVarDesc(pTypeInfo, pVarDesc);
6470 kind =
INT2FIX(pVarDesc->varkind);
6530 if(pOwnerTypeInfo)
OLE_ADDREF(pOwnerTypeInfo);
6603 FUNCDESC *pFuncDesc;
6607 hr = pTypeInfo->lpVtbl->GetFuncDesc(pTypeInfo, method_index, &pFuncDesc);
6612 pTypeInfo->lpVtbl->ReleaseFuncDesc(pTypeInfo, pFuncDesc);
6637 FUNCDESC *pFuncDesc;
6641 hr = pTypeInfo->lpVtbl->GetFuncDesc(pTypeInfo, method_index, &pFuncDesc);
6645 vvt =
INT2FIX(pFuncDesc->elemdescFunc.tdesc.vt);
6646 pTypeInfo->lpVtbl->ReleaseFuncDesc(pTypeInfo, pFuncDesc);
6671 FUNCDESC *pFuncDesc;
6675 hr = pTypeInfo->lpVtbl->GetFuncDesc(pTypeInfo, method_index, &pFuncDesc);
6680 pTypeInfo->lpVtbl->ReleaseFuncDesc(pTypeInfo, pFuncDesc);
6705 FUNCDESC *pFuncDesc;
6708 hr = pTypeInfo->lpVtbl->GetFuncDesc(pTypeInfo, method_index, &pFuncDesc);
6711 invkind =
INT2FIX(pFuncDesc->invkind);
6712 pTypeInfo->lpVtbl->ReleaseFuncDesc(pTypeInfo, pFuncDesc);
6721 if((
FIX2INT(invkind) & INVOKE_PROPERTYGET) &&
6722 (
FIX2INT(invkind) & INVOKE_PROPERTYPUT) ) {
6724 }
else if(
FIX2INT(invkind) & INVOKE_PROPERTYGET) {
6726 }
else if(
FIX2INT(invkind) & INVOKE_PROPERTYPUT) {
6728 }
else if(
FIX2INT(invkind) & INVOKE_PROPERTYPUTREF) {
6730 }
else if(
FIX2INT(invkind) & INVOKE_FUNC) {
6776 FUNCDESC *pFuncDesc;
6779 hr = pTypeInfo->lpVtbl->GetFuncDesc(pTypeInfo, method_index, &pFuncDesc);
6782 if (pFuncDesc->wFuncFlags & (FUNCFLAG_FRESTRICTED |
6784 FUNCFLAG_FNONBROWSABLE)) {
6789 pTypeInfo->lpVtbl->ReleaseFuncDesc(pTypeInfo, pFuncDesc);
6813 TYPEATTR *pTypeAttr;
6818 ITypeInfo *pRefTypeInfo;
6819 FUNCDESC *pFuncDesc;
6827 if(pTypeAttr->typekind != TKIND_COCLASS) {
6828 pTypeInfo->lpVtbl->ReleaseTypeAttr(pTypeInfo, pTypeAttr);
6831 for (i = 0; i < pTypeAttr->cImplTypes; i++) {
6832 hr = pTypeInfo->lpVtbl->GetImplTypeFlags(pTypeInfo, i, &flags);
6836 if (flags & IMPLTYPEFLAG_FSOURCE) {
6837 hr = pTypeInfo->lpVtbl->GetRefTypeOfImplType(pTypeInfo,
6841 hr = pTypeInfo->lpVtbl->GetRefTypeInfo(pTypeInfo,
6842 href, &pRefTypeInfo);
6845 hr = pRefTypeInfo->lpVtbl->GetFuncDesc(pRefTypeInfo, method_index,
6852 hr = pRefTypeInfo->lpVtbl->GetDocumentation(pRefTypeInfo,
6856 pRefTypeInfo->lpVtbl->ReleaseFuncDesc(pRefTypeInfo, pFuncDesc);
6862 pRefTypeInfo->lpVtbl->ReleaseFuncDesc(pRefTypeInfo, pFuncDesc);
6930 FUNCDESC *pFuncDesc;
6932 hr = pTypeInfo->lpVtbl->GetFuncDesc(pTypeInfo, method_index, &pFuncDesc);
6935 hr = pTypeInfo->lpVtbl->GetDocumentation(pTypeInfo, pFuncDesc->memid,
6937 helpcontext, helpfile);
6938 pTypeInfo->lpVtbl->ReleaseFuncDesc(pTypeInfo, pFuncDesc);
7008 DWORD helpcontext = 0;
7010 &helpcontext,
NULL);
7036 FUNCDESC *pFuncDesc;
7039 hr = pTypeInfo->lpVtbl->GetFuncDesc(pTypeInfo, method_index, &pFuncDesc);
7042 dispid =
INT2NUM(pFuncDesc->memid);
7043 pTypeInfo->lpVtbl->ReleaseFuncDesc(pTypeInfo, pFuncDesc);
7067 FUNCDESC *pFuncDesc;
7070 hr = pTypeInfo->lpVtbl->GetFuncDesc(pTypeInfo, method_index, &pFuncDesc);
7073 offset_vtbl =
INT2FIX(pFuncDesc->oVft);
7074 pTypeInfo->lpVtbl->ReleaseFuncDesc(pTypeInfo, pFuncDesc);
7098 FUNCDESC *pFuncDesc;
7101 hr = pTypeInfo->lpVtbl->GetFuncDesc(pTypeInfo, method_index, &pFuncDesc);
7104 size_params =
INT2FIX(pFuncDesc->cParams);
7105 pTypeInfo->lpVtbl->ReleaseFuncDesc(pTypeInfo, pFuncDesc);
7130 FUNCDESC *pFuncDesc;
7133 hr = pTypeInfo->lpVtbl->GetFuncDesc(pTypeInfo, method_index, &pFuncDesc);
7135 return size_opt_params;
7136 size_opt_params =
INT2FIX(pFuncDesc->cParamsOpt);
7137 pTypeInfo->lpVtbl->ReleaseFuncDesc(pTypeInfo, pFuncDesc);
7138 return size_opt_params;
7161 FUNCDESC *pFuncDesc;
7168 hr = pTypeInfo->lpVtbl->GetFuncDesc(pTypeInfo, method_index, &pFuncDesc);
7173 bstrs =
ALLOCA_N(BSTR, pFuncDesc->cParams + 1);
7174 hr = pTypeInfo->lpVtbl->GetNames(pTypeInfo, pFuncDesc->memid,
7175 bstrs, pFuncDesc->cParams + 1,
7178 pTypeInfo->lpVtbl->ReleaseFuncDesc(pTypeInfo, pFuncDesc);
7181 SysFreeString(bstrs[0]);
7182 if (pFuncDesc->cParams > 0) {
7183 for(i = 1; i <
len; i++) {
7189 pparam->
index = i - 1;
7194 pTypeInfo->lpVtbl->ReleaseFuncDesc(pTypeInfo, pFuncDesc);
7254 FUNCDESC *pFuncDesc;
7259 hr = pTypeInfo->lpVtbl->GetFuncDesc(pTypeInfo, method_index, &pFuncDesc);
7264 bstrs =
ALLOCA_N(BSTR, pFuncDesc->cParams + 1);
7265 hr = pTypeInfo->lpVtbl->GetNames(pTypeInfo, pFuncDesc->memid,
7266 bstrs, pFuncDesc->cParams + 1,
7269 pTypeInfo->lpVtbl->ReleaseFuncDesc(pTypeInfo, pFuncDesc);
7272 SysFreeString(bstrs[0]);
7273 if (param_index < 1 || len <= (UINT)param_index)
7275 pTypeInfo->lpVtbl->ReleaseFuncDesc(pTypeInfo, pFuncDesc);
7283 pparam->
index = param_index - 1;
7286 pTypeInfo->lpVtbl->ReleaseFuncDesc(pTypeInfo, pFuncDesc);
7326 FUNCDESC *pFuncDesc;
7329 hr = pTypeInfo->lpVtbl->GetFuncDesc(pTypeInfo, method_index, &pFuncDesc);
7333 &(pFuncDesc->lprgelemdescParam[index].tdesc),
Qnil);
7334 pTypeInfo->lpVtbl->ReleaseFuncDesc(pTypeInfo, pFuncDesc);
7360 FUNCDESC *pFuncDesc;
7363 hr = pTypeInfo->lpVtbl->GetFuncDesc(pTypeInfo, method_index, &pFuncDesc);
7367 &(pFuncDesc->lprgelemdescParam[index].tdesc), typedetail);
7368 pTypeInfo->lpVtbl->ReleaseFuncDesc(pTypeInfo, pFuncDesc);
7394 FUNCDESC *pFuncDesc;
7397 hr = pTypeInfo->lpVtbl->GetFuncDesc(pTypeInfo, method_index, &pFuncDesc);
7400 if (
V_UNION1((&(pFuncDesc->lprgelemdescParam[index])), paramdesc).wParamFlags &mask)
7402 pTypeInfo->lpVtbl->ReleaseFuncDesc(pTypeInfo, pFuncDesc);
7421 pparam->
index, PARAMFLAG_FIN);
7448 pparam->
index, PARAMFLAG_FOUT);
7466 pparam->
index, PARAMFLAG_FOPT);
7485 pparam->
index, PARAMFLAG_FRETVAL);
7491 FUNCDESC *pFuncDesc;
7492 ELEMDESC *pElemDesc;
7493 PARAMDESCEX * pParamDescEx;
7496 USHORT mask = PARAMFLAG_FOPT|PARAMFLAG_FHASDEFAULT;
7498 hr = pTypeInfo->lpVtbl->GetFuncDesc(pTypeInfo, method_index, &pFuncDesc);
7501 pElemDesc = &pFuncDesc->lprgelemdescParam[
index];
7502 wParamFlags =
V_UNION1(pElemDesc, paramdesc).wParamFlags;
7503 if ((wParamFlags & mask) == mask) {
7504 pParamDescEx =
V_UNION1(pElemDesc, paramdesc).pparamdescex;
7507 pTypeInfo->lpVtbl->ReleaseFuncDesc(pTypeInfo, pFuncDesc);
7561 if (defval !=
Qnil) {
7585 if (IsEqualIID(iid, &IID_IUnknown) ||
7586 IsEqualIID(iid, &IID_IDispatch) ||
7587 IsEqualIID(iid, &((PIEVENTSINKOBJ)pEV)->m_iid)) {
7592 return E_NOINTERFACE;
7594 ((LPUNKNOWN)*ppv)->lpVtbl->AddRef((LPUNKNOWN)*ppv);
7632 return DISP_E_BADINDEX;
7636 PEVENTSINK pEventSink,
7647 return pTypeInfo->lpVtbl->GetIDsOfNames(pTypeInfo, szNames, cNames, pDispID);
7649 return DISP_E_UNKNOWNNAME;
7662 for(i = 0; i <
len; i++) {
7686 *is_default =
FALSE;
7689 for(i = 0; i <
len; i++) {
7692 if(
NIL_P(event_name)) {
7697 *is_default =
FALSE;
7708 *is_default_handler =
FALSE;
7715 *is_default_handler =
TRUE;
7741 bstrs =
ALLOCA_N(BSTR, pdispparams->cArgs + 1);
7742 hr = pTypeInfo->lpVtbl->GetNames(pTypeInfo, dispid,
7743 bstrs, pdispparams->cArgs + 1,
7748 for (i = 0; i < len - 1; i++) {
7755 pvar = &pdispparams->rgvarg[pdispparams->cArgs-i-1];
7776 for(i = 0; i <
RARRAY_LEN(ary) && (
unsigned int) i < pdispparams->cArgs; i++) {
7778 pvar = &pdispparams->rgvarg[pdispparams->cArgs-i-1];
7787 VALUE handler = parg[0];
7788 VALUE mid = parg[1];
7789 VALUE args = parg[2];
7790 return rb_apply(handler, mid, args);
7812 PEVENTSINK pEventSink,
7817 DISPPARAMS *pdispparams,
7818 VARIANT *pvarResult,
7819 EXCEPINFO *pexcepinfo,
7834 BOOL is_default_handler =
FALSE;
7848 hr = pTypeInfo->lpVtbl->GetNames(pTypeInfo, dispid,
7861 if (handler ==
Qnil) {
7866 if (handler ==
Qnil || mid ==
Qnil) {
7871 if (is_default_handler) {
7876 for (i = 0; i < pdispparams->cArgs; ++
i) {
7877 pvar = &pdispparams->rgvarg[pdispparams->cArgs-i-1];
7881 if (is_outarg ==
Qtrue) {
7908 VariantInit(pvarResult);
7918 if (!g_IsEventSinkVtblInitialized) {
7921 vtEventSink.Release = EVENTSINK_Release;
7927 g_IsEventSinkVtblInitialized =
TRUE;
7939 PIEVENTSINKOBJ pEVObj
7941 if(pEVObj !=
NULL) {
7952 IDispatch *pDispatch;
7955 TYPEATTR *pTypeAttr;
7957 ITypeInfo *pImplTypeInfo;
7958 TYPEATTR *pImplTypeAttr;
7967 BOOL is_found =
FALSE;
7974 hr = pDispatch->lpVtbl->GetTypeInfo(pDispatch, 0, lcid, &pTypeInfo);
7978 hr = pTypeInfo->lpVtbl->GetContainingTypeLib(pTypeInfo,
7986 hr = pTypeLib->lpVtbl->GetTypeInfoOfGuid(pTypeLib,
7992 count = pTypeLib->lpVtbl->GetTypeInfoCount(pTypeLib);
7993 for (index = 0; index <
count; index++) {
7994 hr = pTypeLib->lpVtbl->GetTypeInfo(pTypeLib,
8005 if(pTypeAttr->typekind == TKIND_COCLASS) {
8006 for (type = 0; type < pTypeAttr->cImplTypes; type++) {
8007 hr = pTypeInfo->lpVtbl->GetRefTypeOfImplType(pTypeInfo,
8012 hr = pTypeInfo->lpVtbl->GetRefTypeInfo(pTypeInfo,
8018 hr = pImplTypeInfo->lpVtbl->GetDocumentation(pImplTypeInfo,
8027 if (strcmp(pitf, pstr) == 0) {
8028 hr = pImplTypeInfo->lpVtbl->GetTypeAttr(pImplTypeInfo,
8030 if (SUCCEEDED(hr)) {
8032 *piid = pImplTypeAttr->guid;
8034 *ppTypeInfo = pImplTypeInfo;
8035 (*ppTypeInfo)->lpVtbl->AddRef((*ppTypeInfo));
8037 pImplTypeInfo->lpVtbl->ReleaseTypeAttr(pImplTypeInfo,
8043 if (is_found || FAILED(hr))
8050 if (is_found || FAILED(hr))
8055 return E_NOINTERFACE;
8061 ITypeInfo *pTypeInfo,
8062 TYPEATTR *pTypeAttr,
8063 ITypeInfo **pCOTypeInfo,
8064 TYPEATTR **pCOTypeAttr)
8070 ITypeInfo *pTypeInfo2;
8071 TYPEATTR *pTypeAttr2;
8075 ITypeInfo *pRefTypeInfo;
8076 TYPEATTR *pRefTypeAttr;
8078 hr = pTypeInfo->lpVtbl->GetContainingTypeLib(pTypeInfo, &pTypeLib,
NULL);
8082 count = pTypeLib->lpVtbl->GetTypeInfoCount(pTypeLib);
8083 for (i = 0; i < count && !found; i++) {
8084 hr = pTypeLib->lpVtbl->GetTypeInfo(pTypeLib, i, &pTypeInfo2);
8092 if (pTypeAttr2->typekind != TKIND_COCLASS) {
8097 for (j = 0; j < pTypeAttr2->cImplTypes && !found; j++) {
8098 hr = pTypeInfo2->lpVtbl->GetImplTypeFlags(pTypeInfo2, j, &flags);
8101 if (!(flags & IMPLTYPEFLAG_FDEFAULT))
8103 hr = pTypeInfo2->lpVtbl->GetRefTypeOfImplType(pTypeInfo2, j, &href);
8106 hr = pTypeInfo2->lpVtbl->GetRefTypeInfo(pTypeInfo2, href, &pRefTypeInfo);
8114 if (IsEqualGUID(&(pTypeAttr->guid), &(pRefTypeAttr->guid))) {
8125 *pCOTypeInfo = pTypeInfo2;
8126 *pCOTypeAttr = pTypeAttr2;
8136 ITypeInfo *pTypeInfo,
8137 TYPEATTR *pTypeAttr,
8138 ITypeInfo **ppTypeInfo)
8145 for (i = 0; i < pTypeAttr->cImplTypes; i++) {
8146 hr = pTypeInfo->lpVtbl->GetImplTypeFlags(pTypeInfo, i, &flags);
8154 if ((flags & IMPLTYPEFLAG_FDEFAULT) &&
8155 (flags & IMPLTYPEFLAG_FSOURCE)) {
8157 hr = pTypeInfo->lpVtbl->GetRefTypeOfImplType(pTypeInfo,
8161 hr = pTypeInfo->lpVtbl->GetRefTypeInfo(pTypeInfo,
8162 hRefType, ppTypeInfo);
8174 IProvideClassInfo2 *pProvideClassInfo2;
8175 IProvideClassInfo *pProvideClassInfo;
8179 ITypeInfo *pTypeInfo;
8180 ITypeInfo *pTypeInfo2 =
NULL;
8181 TYPEATTR *pTypeAttr;
8182 TYPEATTR *pTypeAttr2 =
NULL;
8188 hr = pDispatch->lpVtbl->QueryInterface(pDispatch,
8189 &IID_IProvideClassInfo2,
8191 if (SUCCEEDED(hr)) {
8192 pProvideClassInfo2 =
p;
8193 hr = pProvideClassInfo2->lpVtbl->GetGUID(pProvideClassInfo2,
8194 GUIDKIND_DEFAULT_SOURCE_DISP_IID,
8197 if (SUCCEEDED(hr)) {
8201 if (SUCCEEDED(hr)) {
8204 hr = pDispatch->lpVtbl->QueryInterface(pDispatch,
8205 &IID_IProvideClassInfo,
8207 if (SUCCEEDED(hr)) {
8208 pProvideClassInfo =
p;
8209 hr = pProvideClassInfo->lpVtbl->GetClassInfo(pProvideClassInfo,
8214 hr = pDispatch->lpVtbl->GetTypeInfo(pDispatch, 0,
cWIN32OLE_lcid, &pTypeInfo );
8227 hr =
find_coclass(pTypeInfo, pTypeAttr, &pTypeInfo2, &pTypeAttr2);
8228 if (SUCCEEDED(hr)) {
8244 hr = (*ppTypeInfo)->lpVtbl->GetTypeAttr(*ppTypeInfo, &pTypeAttr);
8245 if (SUCCEEDED(hr)) {
8246 *piid = pTypeAttr->guid;
8247 (*ppTypeInfo)->lpVtbl->ReleaseTypeAttr(*ppTypeInfo, pTypeAttr);
8288 ITypeInfo *pTypeInfo = 0;
8290 IConnectionPointContainer *pContainer;
8291 IConnectionPoint *pConnectionPoint;
8311 hr =
find_iid(ole, pitf, &iid, &pTypeInfo);
8322 hr = pDispatch->lpVtbl->QueryInterface(pDispatch,
8323 &IID_IConnectionPointContainer,
8328 "failed to query IConnectionPointContainer");
8332 hr = pContainer->lpVtbl->FindConnectionPoint(pContainer,
8342 hr = pConnectionPoint->lpVtbl->Advise(pConnectionPoint,
8516 if (
NIL_P(events)) {
8639 VariantClear(&(pvar->
realvar));
8640 VariantClear(&(pvar->
var));
8651 VariantInit(&(pvar->
var));
8652 VariantInit(&(pvar->
realvar));
8678 SAFEARRAYBOUND *psab =
NULL;
8679 SAFEARRAY *psa =
NULL;
8686 vt = (vt | VT_ARRAY);
8693 psab =
ALLOC_N(SAFEARRAYBOUND, dim);
8699 for (i = 0; i < dim; i++) {
8701 psab[
i].lLbound = 0;
8704 psa = SafeArrayCreate((VARTYPE)(vt & VT_TYPEMASK), dim, psab);
8706 if (psab)
free(psab);
8710 V_VT(&(pvar->
var)) = vt;
8711 if (vt & VT_BYREF) {
8712 V_VT(&(pvar->
realvar)) = (vt & ~VT_BYREF);
8713 V_ARRAY(&(pvar->
realvar)) = psa;
8714 V_ARRAYREF(&(pvar->
var)) = &(V_ARRAY(&(pvar->
realvar)));
8716 V_ARRAY(&(pvar->
var)) = psa;
8718 if (psab)
free(psab);
8751 if (len < 1 || len > 3) {
8760 switch (
TYPE(val)) {
8784 vt = V_VT(&pvar->
var);
8792 SAFEARRAY *psa =
NULL;
8795 if (!(V_VT(&(pvar->
var)) & VT_ARRAY)) {
8798 psa = V_ISBYREF(&(pvar->
var)) ? *V_ARRAYREF(&(pvar->
var)) : V_ARRAY(&(pvar->
var));
8802 hr = SafeArrayLock(psa);
8815 dim = SafeArrayGetDim(psa);
8816 if (dim != ary_size) {
8823 for (i = 0; i < dim; i++) {
8833 hr = SafeArrayUnlock(psa);
8870 if (!V_ISARRAY(&(pvar->
var))) {
8872 "`[]' is not available for this variant type object");
8881 VariantInit(&variant);
8882 V_VT(&variant) = (V_VT(&(pvar->
var)) & ~VT_ARRAY) | VT_BYREF;
8883 hr = SafeArrayPtrOfIndex(psa, pid, &V_BYREF(&variant));
8900 if ((vt & ~VT_BYREF) == VT_VARIANT) {
8903 if ( (vt & ~VT_BYREF) != V_VT(var)) {
8904 hr = VariantChangeTypeEx(var, var,
8951 if (!V_ISARRAY(&(pvar->
var))) {
8953 "`[]' is not available for this variant type object");
8963 vt = (V_VT(&(pvar->
var)) & ~VT_ARRAY);
8965 if ((V_VT(&var) == VT_DISPATCH && V_DISPATCH(&var) ==
NULL) ||
8966 (V_VT(&var) == VT_UNKNOWN && V_UNKNOWN(&var) ==
NULL)) {
8969 hr = SafeArrayPutElement(psa, pid, p);
8976 return argv[argc-1];
8999 vt = V_VT(&(pvar->
var));
9001 if ((vt & ~VT_BYREF) == (VT_UI1|VT_ARRAY)) {
9002 if (vt & VT_BYREF) {
9003 psa = *V_ARRAYREF(&(pvar->
var));
9005 psa = V_ARRAY(&(pvar->
var));
9010 dim = SafeArrayGetDim(psa);
9055 vt = V_VT(&(pvar->
var));
9056 if (V_ISARRAY(&(pvar->
var)) && ((vt & ~VT_BYREF) != (VT_UI1|VT_ARRAY) ||
TYPE(val) !=
T_STRING)) {
9058 "`value=' is not available for this variant type object");
9083 com_vtbl.QueryInterface = QueryInterface;
9086 com_vtbl.GetTypeInfoCount = GetTypeInfoCount;
9087 com_vtbl.GetTypeInfo = GetTypeInfo;
9088 com_vtbl.GetIDsOfNames = GetIDsOfNames;
9187 #if (_MSC_VER >= 1300) || defined(__CYGWIN__) || defined(__MINGW32__)
static void olevariant_free(struct olevariantdata *pvar)
static VALUE fole_invoke2(VALUE self, VALUE dispid, VALUE args, VALUE types)
static VALUE foletype_helpfile(VALUE self)
static HRESULT typeinfo_from_ole(struct oledata *pole, ITypeInfo **ppti)
VALUE rb_apply(VALUE, ID, VALUE)
Calls a method.
#define RSTRING_LEN(string)
static VALUE fole_s_set_locale(VALUE self, VALUE vlcid)
static DWORD HTASK DWORD LPINTERFACEINFO lpInterfaceInfo
static VALUE method_name(VALUE obj)
static VALUE foletype_minor_version(VALUE self)
static BOOL lcid_installed(LCID lcid)
#define load_conv_function51932()
static VALUE foletype_visible(VALUE self)
static IDispatchVtbl com_vtbl
#define MEMCMP(p1, p2, type, n)
VALUE rb_ary_unshift(VALUE ary, VALUE item)
static VALUE foletypelib_ole_types(VALUE self)
RUBY_EXTERN VALUE rb_cData
static VALUE fev_on_event_with_outargs(int argc, VALUE *argv, VALUE self)
static VALUE folemethod_return_type_detail(VALUE self)
static VALUE ole_variable_ole_type(ITypeInfo *pTypeInfo, UINT var_index)
STDMETHODIMP EVENTSINK_Invoke(PEVENTSINK pEventSink, DISPID dispid, REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pdispparams, VARIANT *pvarResult, EXCEPINFO *pexcepinfo, UINT *puArgErr)
static VALUE foletype_impl_ole_types(VALUE self)
static VALUE ev_on_event(int argc, VALUE *argv, VALUE self, VALUE is_ary_arg)
static VALUE ole_methods_sub(ITypeInfo *pOwnerTypeInfo, ITypeInfo *pTypeInfo, VALUE methods, int mask)
static HRESULT find_default_source(VALUE ole, IID *piid, ITypeInfo **ppTypeInfo)
VALUE rb_ary_entry(VALUE ary, long offset)
static VALUE ole_method_return_type_detail(ITypeInfo *pTypeInfo, UINT method_index)
static VALUE ole_invoke2(VALUE self, VALUE dispid, VALUE args, VALUE types, USHORT dispkind)
static VALUE foletype_guid(VALUE self)
static VALUE ole_usertype2val(ITypeInfo *pTypeInfo, TYPEDESC *pTypeDesc, VALUE typedetails)
static VALUE folemethod_dispid(VALUE self)
static HWND ole_show_help(VALUE helpfile, VALUE helpcontext)
static VALUE foletype_s_allocate(VALUE klass)
static char g_lcid_to_check[8+1]
size_t strlen(const char *)
static VALUE fev_unadvise(VALUE self)
static VALUE folemethod_size_opt_params(VALUE self)
static VALUE foleparam_input(VALUE self)
static VALUE evs_entry(long i)
static VALUE fole_setproperty_with_bracket(int argc, VALUE *argv, VALUE self)
static HRESULT clsid_from_remote(VALUE host, VALUE com, CLSID *pclsid)
static VALUE fole_s_ole_uninitialize(VALUE self)
static DWORD HTASK threadIDCaller
static VALUE foletypelib_minor_version(VALUE self)
#define Data_Get_Struct(obj, type, sval)
void rb_define_singleton_method(VALUE obj, const char *name, VALUE(*func)(ANYARGS), int argc)
Defines a singleton method for obj.
PIEVENTSINKOBJ EVENTSINK_Constructor()
EVENTSINK_AddRef(PEVENTSINK pEV)
static void free_enc2cp()
static VALUE ev_advise(int argc, VALUE *argv, VALUE self)
static VALUE fole_setproperty2(VALUE self, VALUE dispid, VALUE args, VALUE types)
static VALUE folemethod_event_interface(VALUE self)
static long ole_search_event_at(VALUE ary, VALUE ev)
STDMETHODIMP EVENTSINK_QueryInterface(PEVENTSINK pEV, REFIID iid, LPVOID *ppv)
static void ole_val2olevariantdata(VALUE val, VARTYPE vt, struct olevariantdata *pvar)
#define va_init_list(a, b)
static VALUE oletype_set_member(VALUE self, ITypeInfo *pTypeInfo, VALUE name)
static VALUE foletype_default_event_sources(VALUE self)
static VALUE ole_search_event(VALUE ary, VALUE ev, BOOL *is_default)
static VALUE ole_methods(VALUE self, int mask)
static VALUE ole_method_params(ITypeInfo *pTypeInfo, UINT method_index)
STDMETHODIMP EVENTSINK_GetIDsOfNames(PEVENTSINK pEventSink, REFIID riid, OLECHAR **szNames, UINT cNames, LCID lcid, DISPID *pDispID)
static void hash2ptr_dispparams(VALUE hash, ITypeInfo *pTypeInfo, DISPID dispid, DISPPARAMS *pdispparams)
VALUE rb_str_cat(VALUE, const char *, long)
VALUE rb_ary_delete_at(VALUE ary, long pos)
static REFIID LPOLESTR __RPC_FAR * rgszNames
static VALUE reg_get_typelib_file_path(HKEY hkey)
static VALUE evs_delete(long i)
static VALUE ole_param_ole_type_detail(ITypeInfo *pTypeInfo, UINT method_index, UINT index)
static VALUE foleparam_output(VALUE self)
static VALUE fole_func_methods(VALUE self)
static LCID cWIN32OLE_lcid
static DWORD HTASK DWORD dwTickCount
static VALUE ole_type_helpfile(ITypeInfo *pTypeInfo)
static VALUE ary_new_dim(VALUE myary, long *pid, long *plb, long dim)
static VALUE fev_on_event(int argc, VALUE *argv, VALUE self)
static VALUE folevariable_varkind(VALUE self)
#define rb_block_call(arg1, arg2, arg3, arg4, arg5, arg6)
static VALUE foletype_inspect(VALUE self)
static VALUE reg_enum_key(HKEY hkey, DWORD i)
static REFIID LPOLESTR __RPC_FAR UINT cNames
static VALUE ole_method_invoke_kind(ITypeInfo *pTypeInfo, UINT method_index)
BOOL( FNENUMSYSEMCODEPAGES)(CODEPAGE_ENUMPROC, DWORD)
static VALUE typelib_file_from_typelib(VALUE ole)
static VALUE foletype_s_progids(VALUE self)
static IEventSinkVtbl vtEventSink
static VALUE foletype_helpcontext(VALUE self)
static VALUE fole_free(VALUE self)
static rb_encoding * cWIN32OLE_enc
rb_encoding * rb_default_internal_encoding(void)
static BOOL CALLBACK installed_lcid_proc(LPTSTR str)
VALUE rb_ary_push(VALUE ary, VALUE item)
static VALUE ole_typelib_from_itypeinfo(ITypeInfo *pTypeInfo)
static VALUE make_inspect(const char *class_name, VALUE detail)
static VALUE ole_variant2val(VARIANT *pvar)
static VALUE fole_type(VALUE self)
VALUE rb_str_concat(VALUE, VALUE)
static void ole_const_load(ITypeLib *pTypeLib, VALUE klass, VALUE self)
static VALUE folevariant_initialize(VALUE self, VALUE args)
static IDispatch * val2dispatch(VALUE val)
static LPWSTR ole_mb2wc(char *pm, int len)
static VALUE ole_param_flag_mask(ITypeInfo *pTypeInfo, UINT method_index, UINT index, USHORT mask)
static void olevariable_free(struct olevariabledata *polevar)
struct tagIEVENTSINKOBJ IEVENTSINKOBJ
static VALUE INT2NUM(int v)
static VALUE ole_method_offset_vtbl(ITypeInfo *pTypeInfo, UINT method_index)
struct _Win32OLEIDispatch Win32OLEIDispatch
VALUE rb_funcall(VALUE, ID, int,...)
Calls a method.
VALUE rb_protect(VALUE(*proc)(VALUE), VALUE data, int *state)
#define RSTRING_PTR(string)
void rb_raise(VALUE exc, const char *fmt,...)
static VALUE folemethod_helpfile(VALUE self)
static VALUE foleparam_inspect(VALUE self)
VALUE rb_ivar_get(VALUE, ID)
void EVENTSINK_Destructor(PIEVENTSINKOBJ)
static VALUE ole_method_dispid(ITypeInfo *pTypeInfo, UINT method_index)
VALUE rb_ary_clear(VALUE ary)
static void ole_msg_loop()
static VALUE fole_methods(VALUE self)
#define OLEData_Get_Struct(obj, pole)
static VALUE ole_method_visible(ITypeInfo *pTypeInfo, UINT method_index)
static DISPID REFIID LCID WORD wFlags
static void ole_val2variant_ex(VALUE val, VARIANT *var, VARTYPE vt)
static VALUE is_all_index_under(long *pid, long *pub, long dim)
void rb_define_alloc_func(VALUE, rb_alloc_func_t)
VALUE rb_obj_is_kind_of(VALUE, VALUE)
static VALUE foletype_major_version(VALUE self)
#define RARRAY_LEN(ARRAY)
VALUE rb_ary_new3(long n,...)
static ITypeLib * oletypelib_get_typelib(VALUE self)
char CodePageName[MAX_PATH]
static VALUE fole_s_reference_count(VALUE self, VALUE obj)
double rb_big2dbl(VALUE x)
VALUE eWIN32OLERuntimeError
#define OLE_GET_TYPEATTR(X, Y)
int rb_str_cmp(VALUE, VALUE)
IConnectionPoint * pConnectionPoint
static VALUE fole_method_help(VALUE self, VALUE cmdname)
static VALUE folemethod_inspect(VALUE self)
static VALUE ole_set_member(VALUE self, IDispatch *dispatch)
static VALUE ole_method_event(ITypeInfo *pTypeInfo, UINT method_index, VALUE method_name)
IUnknown COSERVERINFO MULTI_QI *typedef LPCSTR UINT DWORD dwData
static VALUE folemethod_return_type(VALUE self)
static HTASK threadIDCallee
static VALUE foletype_s_typelibs(VALUE self)
static void init_enc2cp()
static void ole_pure_uninitialize()
static void * get_ptr_of_variant(VARIANT *pvar)
VALUE rb_fix2str(VALUE, int)
static VALUE oleclass_from_typelib(VALUE self, ITypeLib *pTypeLib, VALUE oleclass)
static void ary_store_dim(VALUE myary, long *pid, long *plb, long dim, VALUE val)
static VALUE fole_s_get_code_page(VALUE self)
static void olemethod_free(struct olemethoddata *polemethod)
static void ole_delete_event(VALUE ary, VALUE ev)
static void ole_val2ptr_variant(VALUE val, VARIANT *var)
const char * rb_obj_classname(VALUE)
static VALUE ole_ary_m_entry(VALUE val, long *pid)
static VALUE ole_type_visible(ITypeInfo *pTypeInfo)
static VALUE ole_type_impl_ole_types(ITypeInfo *pTypeInfo, int implflags)
static HRESULT find_default_source_from_typeinfo(ITypeInfo *pTypeInfo, TYPEATTR *pTypeAttr, ITypeInfo **ppTypeInfo)
static VALUE set_argv(VARIANTARG *realargs, unsigned int beg, unsigned int end)
static VALUE folevariant_ary_aref(int argc, VALUE *argv, VALUE self)
NORETURN(static void failed_load_conv51932(void))
static VALUE ole_ole_type(ITypeInfo *pTypeInfo)
static VALUE foleparam_ole_type_detail(VALUE self)
static void oleparam_free(struct oleparamdata *pole)
static VALUE ole_method_helpfile(ITypeInfo *pTypeInfo, UINT method_index)
#define Data_Wrap_Struct(klass, mark, free, sval)
static VALUE folemethod_invkind(VALUE self)
static void ole_val2variant(VALUE val, VARIANT *var)
static VALUE foletypelib_guid(VALUE self)
IUnknown COSERVERINFO MULTI_QI *typedef LPCSTR UINT uCommand
static VALUE foletype_ole_type(VALUE self)
static UINT g_cp_to_check
int rb_is_const_id(ID id)
static VALUE folevariable_ole_type_detail(VALUE self)
static VALUE foletype_default_ole_types(VALUE self)
struct tagIEVENTSINKOBJ * PIEVENTSINKOBJ
STDMETHODIMP EVENTSINK_GetTypeInfoCount(PEVENTSINK pEV, UINT *pct)
static HRESULT ole_docinfo_from_type(ITypeInfo *pTypeInfo, BSTR *name, BSTR *helpstr, DWORD *helpcontext, BSTR *helpfile)
struct IEventSink * PEVENTSINK
static VALUE folevariable_value(VALUE self)
void rb_write_error(const char *)
static VALUE folemethod_invoke_kind(VALUE self)
static VALUE ole_search_handler_method(VALUE handler, VALUE ev, BOOL *is_default_handler)
static VALUE ole_typedesc2val(ITypeInfo *pTypeInfo, TYPEDESC *pTypeDesc, VALUE typedetails)
static VALUE fev_initialize(int argc, VALUE *argv, VALUE self)
static VALUE oleparam_ole_param(VALUE self, VALUE olemethod, int n)
static void ole_val2variant2(VALUE val, VARIANT *var)
static VALUE create_win32ole_object(VALUE klass, IDispatch *pDispatch, int argc, VALUE *argv)
static DISPID REFIID LCID WORD DISPPARAMS __RPC_FAR VARIANT __RPC_FAR EXCEPINFO __RPC_FAR * pExcepInfo
rb_encoding * rb_default_external_encoding(void)
static VALUE ole_types_from_typelib(ITypeLib *pTypeLib, VALUE classes)
static void unlock_safe_array(SAFEARRAY *psa)
static VALUE ole_wc2vstr(LPWSTR pw, BOOL isfree)
static VALUE folemethod_event(VALUE self)
static VALUE ole_hresult2msg(HRESULT hr)
static VALUE foleparam_default(VALUE self)
static VALUE ole_variable_varkind(ITypeInfo *pTypeInfo, UINT var_index)
static VALUE ole_method_return_vtype(ITypeInfo *pTypeInfo, UINT method_index)
static VALUE ole_variable_kind(ITypeInfo *pTypeInfo, UINT var_index)
static UINT ole_encoding2cp(rb_encoding *enc)
ITypeInfo * pOwnerTypeInfo
static VALUE olemethod_set_member(VALUE self, ITypeInfo *pTypeInfo, ITypeInfo *pOwnerTypeInfo, int index, VALUE name)
static VALUE ole_variable_visible(ITypeInfo *pTypeInfo, UINT var_index)
VALUE rb_hash_aset(VALUE hash, VALUE key, VALUE val)
static BOOL g_lcid_installed
STDMETHOD() QueryInterface(PEVENTSINK, REFIID, LPVOID *)
static VALUE ole_variable_value(ITypeInfo *pTypeInfo, UINT var_index)
static VALUE foletype_src_type(VALUE self)
static LPWSTR ole_vstr2wc(VALUE vstr)
static double rbtime2vtdate(VALUE tmobj)
static VALUE ole_type_helpcontext(ITypeInfo *pTypeInfo)
RUBY_EXTERN VALUE rb_cObject
static VALUE ole_ptrtype2val(ITypeInfo *pTypeInfo, TYPEDESC *pTypeDesc, VALUE typedetails)
static VALUE foletype_s_ole_classes(VALUE self, VALUE typelib)
static void ole_set_byref(VARIANT *realvar, VARIANT *var, VARTYPE vt)
static VALUE typelib_file(VALUE ole)
static VALUE oletypelib_search_registry(VALUE self, VALUE typelib)
VALUE rb_str_cat2(VALUE, const char *)
static VALUE folemethod_helpcontext(VALUE self)
static void oletypelib_get_libattr(ITypeLib *pTypeLib, TLIBATTR **ppTLibAttr)
static UINT __RPC_FAR * pctinfo
static VALUE ole_type_from_itypeinfo(ITypeInfo *pTypeInfo)
static VALUE enc_name(VALUE self)
VALUE rb_define_class(const char *name, VALUE super)
Defines a top-level class.
static IMessageFilter imessage_filter
void rb_define_const(VALUE, const char *, VALUE)
void rb_ary_store(VALUE ary, long idx, VALUE val)
static IMessageFilterVtbl message_filter
static VALUE reg_get_val(HKEY hkey, const char *subkey)
VALUE rb_eval_string(const char *)
static VALUE fole_s_allocate(VALUE klass)
static VALUE fole_getproperty2(VALUE self, VALUE dispid, VALUE args, VALUE types)
static void oletypelib_free(struct oletypelibdata *poletypelib)
static VALUE ole_method_invkind(ITypeInfo *pTypeInfo, UINT method_index)
static VALUE fole_invoke(int argc, VALUE *argv, VALUE self)
static SAFEARRAY * get_locked_safe_array(VALUE val)
static VALUE ole_type_progid(ITypeInfo *pTypeInfo)
static BOOL code_page_installed(UINT cp)
static VALUE foletypelib_path(VALUE self)
static VALUE fole_typelib(VALUE self)
static void ole_set_safe_array(long n, SAFEARRAY *psa, long *pid, long *pub, VALUE val, long dim, VARTYPE vt)
#define ALLOCA_N(type, n)
static VALUE foletype_name(VALUE self)
static VALUE folevariant_set_value(VALUE self, VALUE val)
static char * ole_wc2mb(LPWSTR pw)
static VALUE foletypelib_name(VALUE self)
static VALUE foletypelib_visible(VALUE self)
void rb_gc_register_mark_object(VALUE obj)
static VALUE folemethod_initialize(VALUE self, VALUE oletype, VALUE method)
static VALUE hash2named_arg(VALUE pair, struct oleparam *pOp)
static VALUE folevariable_inspect(VALUE self)
static VALUE ole_methods_from_typeinfo(ITypeInfo *pTypeInfo, int mask)
static VALUE ole_type_guid(ITypeInfo *pTypeInfo)
static VALUE fole_activex_initialize(VALUE self)
static REFIID LPOLESTR __RPC_FAR UINT LCID DISPID __RPC_FAR * rgDispId
static void add_event_call_back(VALUE obj, VALUE event, VALUE data)
static VALUE folevariant_ary_aset(int argc, VALUE *argv, VALUE self)
static VALUE folemethod_name(VALUE self)
static void ole_raise(HRESULT hr, VALUE ecs, const char *fmt,...)
static void set_ole_codepage(UINT cp)
static long dimension(VALUE val)
static VALUE folevariable_variable_kind(VALUE self)
static rb_encoding * ole_cp2encoding(UINT cp)
static VALUE fole_put_methods(VALUE self)
static VALUE fole_s_set_code_page(VALUE self, VALUE vcp)
VALUE rb_const_get(VALUE, ID)
static VALUE fev_set_handler(VALUE self, VALUE val)
void rb_define_alias(VALUE klass, const char *name1, const char *name2)
Defines an alias of a method.
static VALUE ole_create_dcom(int argc, VALUE *argv, VALUE self)
static long ary_len_of_dim(VALUE ary, long dim)
static VALUE folevariant_value(VALUE self)
static VALUE fev_s_msg_loop(VALUE klass)
static BOOL g_ole_initialized
static VALUE folevariant_s_allocate(VALUE klass)
static VALUE foletypelib_major_version(VALUE self)
static VALUE foletype_helpstring(VALUE self)
VALUE rb_funcall2(VALUE, ID, int, const VALUE *)
Calls a method.
VALUE rb_sprintf(const char *format,...)
static st_table * enc2cp_table
static VALUE foleparam_retval(VALUE self)
static HRESULT ole_val_ary2variant_ary(VALUE val, VARIANT *var, VARTYPE vt)
static VALUE foletype_progid(VALUE self)
static VALUE reg_get_val2(HKEY hkey, const char *subkey)
static VALUE ole_type_major_version(ITypeInfo *pTypeInfo)
#define OLE_RELEASE_TYPEATTR(X, Y)
static VALUE ole_propertyput(VALUE self, VALUE property, VALUE value)
static VALUE fole_get_methods(VALUE self)
int rb_scan_args(int argc, const VALUE *argv, const char *fmt,...)
static VALUE typelib_file_from_clsid(VALUE ole)
VALUE rb_ivar_set(VALUE, ID, VALUE)
unsigned char buf[MIME_BUF_SIZE]
static VALUE foleparam_initialize(VALUE self, VALUE olemethod, VALUE n)
static void ole_initialize()
static VALUE oletypelib_search_registry2(VALUE self, VALUE args)
static VALUE ole_invoke(int argc, VALUE *argv, VALUE self, USHORT wFlags, BOOL is_bracket)
static VALUE ole_method_size_params(ITypeInfo *pTypeInfo, UINT method_index)
int rb_define_dummy_encoding(const char *name)
static HTASK DWORD DWORD dwPendingType
static VALUE ole_method_size_opt_params(ITypeInfo *pTypeInfo, UINT method_index)
static void failed_load_conv51932(void)
static VALUE ole_method_sub(VALUE self, ITypeInfo *pOwnerTypeInfo, ITypeInfo *pTypeInfo, VALUE name)
struct IEventSinkVtbl * lpVtbl
static VALUE vtdate2rbtime(double date)
static VALUE folemethod_size_params(VALUE self)
#define ENC_MACHING_CP(enc, encname, cp)
static VALUE fev_get_handler(VALUE self)
static VALUE foletypelib_s_allocate(VALUE klass)
static VALUE oletypelib_set_member(VALUE self, ITypeLib *pTypeLib)
static HTASK DWORD DWORD dwRejectType
register unsigned int len
static VALUE fole_s_get_locale(VALUE self)
static VALUE ole_param_default(ITypeInfo *pTypeInfo, UINT method_index, UINT index)
static VALUE folemethod_return_vtype(VALUE self)
VALUE rb_call_super(int, const VALUE *)
static VALUE ole_variable_ole_type_detail(ITypeInfo *pTypeInfo, UINT var_index)
static VALUE fole_setproperty(int argc, VALUE *argv, VALUE self)
VALUE rb_ensure(VALUE(*b_proc)(ANYARGS), VALUE data1, VALUE(*e_proc)(ANYARGS), VALUE data2)
static VALUE foleparam_name(VALUE self)
static void ole_pure_initialize()
static VALUE ole_method_helpcontext(ITypeInfo *pTypeInfo, UINT method_index)
static VALUE ole_type_helpstring(ITypeInfo *pTypeInfo)
static VALUE ole_variables(ITypeInfo *pTypeInfo)
static VALUE ole_method_docinfo_from_type(ITypeInfo *pTypeInfo, UINT method_index, BSTR *name, BSTR *helpstr, DWORD *helpcontext, BSTR *helpfile)
static VALUE foletypelib_s_typelibs(VALUE self)
static VALUE fev_s_allocate(VALUE klass)
static BOOL g_IsEventSinkVtblInitialized
static VALUE oleparam_ole_param_from_index(VALUE self, ITypeInfo *pTypeInfo, UINT method_index, int param_index)
static VALUE foletypelib_initialize(VALUE self, VALUE args)
static VALUE fole_getproperty_with_bracket(int argc, VALUE *argv, VALUE self)
static VALUE foletypelib_library_name(VALUE self)
#define Data_Make_Struct(klass, type, mark, free, sval)
int rb_respond_to(VALUE, ID)
static void oletype_free(struct oletypedata *poletype)
static VALUE ole_each_sub(VALUE pEnumV)
VALUE rb_define_module_under(VALUE outer, const char *name)
#define StringValueCStr(v)
static VALUE folemethod_offset_vtbl(VALUE self)
VALUE rb_float_new(double)
static VALUE folemethod_s_allocate(VALUE klass)
static VALUE evs_length()
static HRESULT find_coclass(ITypeInfo *pTypeInfo, TYPEATTR *pTypeAttr, ITypeInfo **pTypeInfo2, TYPEATTR **pTypeAttr2)
static VALUE foletype_initialize(VALUE self, VALUE typelib, VALUE oleclass)
static VALUE fole_each(VALUE self)
static VALUE ary_ole_event
rb_encoding * rb_enc_get(VALUE obj)
static REFIID void __RPC_FAR *__RPC_FAR * ppvObject
static VALUE folemethod_params(VALUE self)
static VALUE fole_respond_to(VALUE self, VALUE method)
IUnknown COSERVERINFO MULTI_QI *typedef HWND(WINAPI FNHTMLHELP)(HWND hwndCaller
static VALUE fole_s_free(VALUE self, VALUE obj)
VALUE rb_block_proc(void)
static DISPID REFIID LCID WORD DISPPARAMS __RPC_FAR * pDispParams
typedef HRESULT(STDAPICALLTYPE FNCOCREATEINSTANCEEX)(REFCLSID
VALUE rb_hash_aref(VALUE hash, VALUE key)
static FNCOCREATEINSTANCEEX * gCoCreateInstanceEx
static VALUE folevariant_s_array(VALUE klass, VALUE dims, VALUE vvt)
STDMETHODIMP EVENTSINK_GetTypeInfo(PEVENTSINK pEV, UINT info, LCID lcid, ITypeInfo **pInfo)
static void ary2ptr_dispparams(VALUE ary, DISPPARAMS *pdispparams)
static const unsigned char ev[]
static VALUE exec_callback(VALUE arg)
static HRESULT find_iid(VALUE ole, char *pitf, IID *piid, ITypeInfo **ppTypeInfo)
static VALUE folevariable_name(VALUE self)
static VALUE ole_bind_obj(VALUE moniker, int argc, VALUE *argv, VALUE self)
static VALUE foletypelib_inspect(VALUE self)
static VALUE fole_query_interface(VALUE self, VALUE str_iid)
static ULONG reference_count(struct oledata *pole)
static void ole_event_free(struct oleeventdata *poleev)
static VALUE foletype_ole_typelib(VALUE self)
static VALUE hash2result(VALUE hash)
static VALUE ole_method_helpstring(ITypeInfo *pTypeInfo, UINT method_index)
static VALUE rescue_callback(VALUE arg)
static VALUE folemethod_helpstring(VALUE self)
static VALUE ole_method_return_type(ITypeInfo *pTypeInfo, UINT method_index)
VALUE rb_ary_concat(VALUE x, VALUE y)
static VALUE ole_type_src_type(ITypeInfo *pTypeInfo)
static unsigned int hash(const char *str, unsigned int len)
#define RETURN_ENUMERATOR(obj, argc, argv)
#define SafeStringValue(v)
static VALUE ole_ienum_free(VALUE pEnumV)
VALUE rb_enc_str_new(const char *, long, rb_encoding *)
static VALUE foletypelib_version(VALUE self)
static void ole_freeexceptinfo(EXCEPINFO *pExInfo)
static char NUM2CHR(VALUE x)
const char * rb_id2name(ID id)
static BOOL g_cp_installed
static DISPID REFIID LCID WORD DISPPARAMS __RPC_FAR VARIANT __RPC_FAR EXCEPINFO __RPC_FAR UINT __RPC_FAR * puArgErr
#define StringValuePtr(v)
static VALUE folevariable_visible(VALUE self)
IUnknown COSERVERINFO MULTI_QI *typedef LPCSTR pszFile
static VALUE make_version_str(VALUE major, VALUE minor)
static UINT LCID ITypeInfo __RPC_FAR *__RPC_FAR * ppTInfo
static VALUE ole_type_minor_version(ITypeInfo *pTypeInfo)
static VALUE fole_initialize(int argc, VALUE *argv, VALUE self)
static HRESULT oletypelib_from_guid(VALUE guid, VALUE version, ITypeLib **ppTypeLib)
static VALUE foletype_typekind(VALUE self)
int rb_enc_find_index(const char *name)
#define RSTRING_LENINT(str)
static void ole_free(struct oledata *pole)
static VALUE folevariant_vartype(VALUE self)
static VALUE fole_s_create_guid(VALUE self)
static VALUE foletype_variables(VALUE self)
static void version(void)
VALUE rb_str_intern(VALUE)
static VALUE ole_param_ole_type(ITypeInfo *pTypeInfo, UINT method_index, UINT index)
static UINT ole_init_cp(void)
static VALUE foleparam_optional(VALUE self)
static long * ary2safe_array_index(int ary_size, VALUE *ary, SAFEARRAY *psa)
static VALUE folemethod_visible(VALUE self)
static DISPID dispIdMember
static IMessageFilter * previous_filter
void rb_mark_hash(st_table *tbl)
static VOID * val2variant_ptr(VALUE val, VARIANT *var, VARTYPE vt)
static VALUE oletypelib_path(VALUE guid, VALUE version)
static VALUE foleparam_s_allocate(VALUE klass)
RUBY_EXTERN VALUE rb_cTime
static VALUE fole_s_show_help(int argc, VALUE *argv, VALUE self)
static VALUE ole_type_typekind(ITypeInfo *pTypeInfo)
void rb_define_method(VALUE klass, const char *name, VALUE(*func)(ANYARGS), int argc)
VALUE rb_str_append(VALUE, VALUE)
static ULONG(STDMETHODCALLTYPE AddRef)(IDispatch __RPC_FAR *This)
VALUE rb_str_new2(const char *)
static VALUE olemethod_from_typeinfo(VALUE self, ITypeInfo *pTypeInfo, VALUE name)
static BOOL CALLBACK installed_code_page_proc(LPTSTR str)
static VALUE ole_excepinfo2msg(EXCEPINFO *pExInfo)
static VALUE default_inspect(VALUE self, const char *class_name)
static VALUE fev_off_event(int argc, VALUE *argv, VALUE self)
static VALUE folevariable_ole_type(VALUE self)
static VALUE foleparam_ole_type(VALUE self)
static VALUE foletype_source_ole_types(VALUE self)
static VALUE fole_s_ole_initialize(VALUE self)
static VALUE fole_missing(int argc, VALUE *argv, VALUE self)
static DISPID REFIID LCID WORD DISPPARAMS __RPC_FAR VARIANT __RPC_FAR * pVarResult
static LONG reg_open_vkey(HKEY hkey, VALUE key, HKEY *phkey)
rb_encoding * rb_enc_from_index(int index)
static VALUE fole_s_const_load(int argc, VALUE *argv, VALUE self)
static LONG reg_open_key(HKEY hkey, const char *name, HKEY *phkey)
static VALUE foletype_methods(VALUE self)
static VALUE evs_push(VALUE ev)
static VALUE fole_s_connect(int argc, VALUE *argv, VALUE self)