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.4"
148 typedef HRESULT (STDAPICALLTYPE FNCOCREATEINSTANCEEX)
149 (REFCLSID, IUnknown*,
DWORD, COSERVERINFO*,
DWORD, MULTI_QI*);
168 STDMETHOD(GetTypeInfoCount)(
171 STDMETHOD(GetTypeInfo)(
176 STDMETHOD(GetIDsOfNames)(
217 #if defined(RB_THREAD_SPECIFIC) && (defined(__CYGWIN__) || defined(__MINGW32__))
219 # define g_ole_initialized_init() ((void)0)
220 # define g_ole_initialized_set(val) (g_ole_initialized = (val))
223 # define g_ole_initialized (BOOL)TlsGetValue(g_ole_initialized_key)
224 # define g_ole_initialized_init() (g_ole_initialized_key = TlsAlloc())
225 # define g_ole_initialized_set(val) TlsSetValue(g_ole_initialized_key, (void*)(val))
246 #if defined(HAVE_TYPE_IMULTILANGUAGE2)
248 #elif defined(HAVE_TYPE_IMULTILANGUAGE)
251 #define pIMultiLanguage NULL
300 static HRESULT ( STDMETHODCALLTYPE QueryInterface )(IDispatch __RPC_FAR *, REFIID
riid,
void __RPC_FAR *__RPC_FAR *
ppvObject);
301 static ULONG ( STDMETHODCALLTYPE AddRef )(IDispatch __RPC_FAR * This);
302 static ULONG ( STDMETHODCALLTYPE Release )(IDispatch __RPC_FAR * This);
303 static HRESULT ( STDMETHODCALLTYPE GetTypeInfoCount )(IDispatch __RPC_FAR * This, UINT __RPC_FAR *
pctinfo);
304 static HRESULT ( STDMETHODCALLTYPE GetTypeInfo )(IDispatch __RPC_FAR * This, UINT
iTInfo, LCID
lcid, ITypeInfo __RPC_FAR *__RPC_FAR *
ppTInfo);
313 #ifndef pIMultiLanguage
387 static VALUE set_argv(VARIANTARG* realargs,
unsigned int beg,
unsigned int end);
564 static HRESULT find_coclass(ITypeInfo *pTypeInfo, TYPEATTR *pTypeAttr, ITypeInfo **pTypeInfo2, TYPEATTR **pTypeAttr2);
600 static HRESULT (STDMETHODCALLTYPE mf_QueryInterface)(
601 IMessageFilter __RPC_FAR * This,
605 if (
MEMCMP(riid, &IID_IUnknown, GUID, 1) == 0
606 ||
MEMCMP(riid, &IID_IMessageFilter, GUID, 1) == 0)
611 return E_NOINTERFACE;
614 static ULONG (STDMETHODCALLTYPE mf_AddRef)(
615 IMessageFilter __RPC_FAR * This)
620 static ULONG (STDMETHODCALLTYPE mf_Release)(
621 IMessageFilter __RPC_FAR * This)
626 static DWORD (STDMETHODCALLTYPE mf_HandleInComingCall)(
627 IMessageFilter __RPC_FAR * pThis,
634 #ifdef DEBUG_MESSAGEFILTER
635 printf(
"incoming %08X, %08X, %d\n", dwCallType, threadIDCaller, dwTickCount);
641 case CALLTYPE_TOPLEVEL_CALLPENDING:
642 case CALLTYPE_ASYNC_CALLPENDING:
644 return SERVERCALL_RETRYLATER;
657 return SERVERCALL_ISHANDLED;
660 static DWORD (STDMETHODCALLTYPE mf_RetryRejectedCall)(
661 IMessageFilter* pThis,
676 static DWORD (STDMETHODCALLTYPE mf_MessagePending)(
677 IMessageFilter* pThis,
684 return PENDINGMSG_WAITNOPROCESS;
692 return PENDINGMSG_WAITNOPROCESS;
702 static HRESULT ( STDMETHODCALLTYPE QueryInterface )(
703 IDispatch __RPC_FAR * This,
707 if (
MEMCMP(riid, &IID_IUnknown, GUID, 1) == 0
708 ||
MEMCMP(riid, &IID_IDispatch, GUID, 1) == 0)
715 return E_NOINTERFACE;
718 static ULONG ( STDMETHODCALLTYPE AddRef )(
719 IDispatch __RPC_FAR * This)
725 static ULONG ( STDMETHODCALLTYPE Release )(
726 IDispatch __RPC_FAR * This)
738 static HRESULT ( STDMETHODCALLTYPE GetTypeInfoCount )(
739 IDispatch __RPC_FAR * This,
745 static HRESULT ( STDMETHODCALLTYPE GetTypeInfo )(
746 IDispatch __RPC_FAR * This,
749 ITypeInfo __RPC_FAR *__RPC_FAR *
ppTInfo)
755 static HRESULT ( STDMETHODCALLTYPE GetIDsOfNames )(
756 IDispatch __RPC_FAR * This,
772 static HRESULT ( STDMETHODCALLTYPE Invoke )(
773 IDispatch __RPC_FAR * This,
791 if (dispIdMember == DISPID_VALUE) {
792 if (wFlags == DISPATCH_METHOD) {
794 }
else if (wFlags & DISPATCH_PROPERTYGET) {
829 memset(&st, 0,
sizeof(SYSTEMTIME));
837 SystemTimeToVariantTime(&st, &t);
846 VariantTimeToSystemTime(date, &st);
855 if (st.wMilliseconds > 0) {
861 #define ENC_MACHING_CP(enc,encname,cp) if(strcasecmp(rb_enc_name((enc)),(encname)) == 0) return cp
934 #ifndef pIMultiLanguage
941 #if defined(HAVE_TYPE_IMULTILANGUAGE2)
942 hr = CoCreateInstance(&CLSID_CMultiLanguage,
NULL, CLSCTX_INPROC_SERVER,
943 &IID_IMultiLanguage2, &p);
944 #elif defined(HAVE_TYPE_IMULTILANGUAGE)
945 hr = CoCreateInstance(&CLSID_CMultiLanguage,
NULL, CLSCTX_INPROC_SERVER,
946 &IID_IMultiLanguage, &p);
955 #define load_conv_function51932() failed_load_conv51932()
958 #define conv_51932(cp) ((cp) == 51932 && (load_conv_function51932(), 1))
981 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.");
1031 if (!pGetCPInfoEx) {
1033 GetProcAddress(GetModuleHandle(
"kernel32"),
"GetCPInfoEx");
1034 if (!pGetCPInfoEx) {
1035 pGetCPInfoEx = (
void*)-1;
1040 if (pGetCPInfoEx == (
void*)-1 || !pGetCPInfoEx(cp, 0, buf)) {
1054 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.");
1072 #ifndef pIMultiLanguage
1111 sprintf(strhr,
" HRESULT error code:0x%08x\n ", (
unsigned)hr);
1113 dwCount = FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER |
1114 FORMAT_MESSAGE_FROM_SYSTEM |
1115 FORMAT_MESSAGE_IGNORE_INSERTS,
1117 MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US),
1118 (LPTSTR)&p_msg, 0,
NULL);
1120 dwCount = FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER |
1121 FORMAT_MESSAGE_FROM_SYSTEM |
1122 FORMAT_MESSAGE_IGNORE_INSERTS,
1124 (LPTSTR)&p_msg, 0,
NULL);
1127 term = p_msg +
strlen(p_msg);
1128 while (p_msg < term) {
1130 if (*term ==
'\r' || *term ==
'\n')
1134 if (p_msg[0] !=
'\0') {
1145 SysFreeString(pExInfo->bstrDescription);
1146 SysFreeString(pExInfo->bstrSource);
1147 SysFreeString(pExInfo->bstrHelpFile);
1153 char error_code[40];
1154 char *pSource =
NULL;
1155 char *pDescription =
NULL;
1157 if(pExInfo->pfnDeferredFillIn !=
NULL) {
1158 (*pExInfo->pfnDeferredFillIn)(pExInfo);
1160 if (pExInfo->bstrSource !=
NULL) {
1161 pSource =
ole_wc2mb(pExInfo->bstrSource);
1163 if (pExInfo->bstrDescription !=
NULL) {
1164 pDescription =
ole_wc2mb(pExInfo->bstrDescription);
1166 if(pExInfo->wCode == 0) {
1167 sprintf(error_code,
"\n OLE error code:%lX in ", pExInfo->scode);
1170 sprintf(error_code,
"\n OLE error code:%u in ", pExInfo->wCode);
1173 if(pSource !=
NULL) {
1180 if(pDescription !=
NULL) {
1186 if(pSource)
free(pSource);
1187 if(pDescription)
free(pDescription);
1203 if(err_msg !=
Qnil) {
1236 hr = OleInitialize(
NULL);
1253 while(PeekMessage(&msg,
NULL,0,0,PM_REMOVE)) {
1254 TranslateMessage(&msg);
1255 DispatchMessage(&msg);
1321 cp == CP_THREAD_ACP ||
1332 #ifndef pIMultiLanguage
1340 pw = SysAllocStringLen(
NULL, size);
1351 pw = SysAllocStringLen(
NULL, size);
1363 #ifndef pIMultiLanguage
1371 pw = SysAllocStringLen(
NULL, size);
1381 pw = SysAllocStringLen(
NULL, size - 1);
1382 MultiByteToWideChar(
cWIN32OLE_cp, 0, pm, len, pw, size);
1413 switch(V_VT(pvar)) {
1415 return &V_UI1(pvar);
1421 return &V_UI2(pvar);
1427 return &V_UI4(pvar);
1435 #if (_MSC_VER >= 1300) || defined(__CYGWIN__) || defined(__MINGW32__)
1440 return &V_UI8(pvar);
1444 return &
V_INT(pvar);
1453 return &V_DATE(pvar);
1456 return V_BSTR(pvar);
1459 return V_DISPATCH(pvar);
1462 return &V_ERROR(pvar);
1465 return &V_BOOL(pvar);
1468 return V_UNKNOWN(pvar);
1471 return &V_ARRAY(pvar);
1483 for (i = 0; i < dim; i++) {
1484 if (pid[i] > pub[i]) {
1504 if ((V_VT(&var) == VT_DISPATCH && V_DISPATCH(&var) ==
NULL) ||
1505 (V_VT(&var) == VT_UNKNOWN && V_UNKNOWN(&var) ==
NULL)) {
1508 hr = SafeArrayPutElement(psa, pid, p);
1514 if (pid[i] > pub[i]) {
1531 for (i = 0; i <
len; i++) {
1556 for (i = 0; i <
len; i++) {
1559 if (ary_len < ary_len1) {
1575 SAFEARRAYBOUND *psab =
NULL;
1576 SAFEARRAY *psa =
NULL;
1583 psab =
ALLOC_N(SAFEARRAYBOUND, dim);
1587 if(!psab || !pub || !pid) {
1589 if(psab)
free(psab);
1594 for (i = 0; i < dim; i++) {
1596 psab[
i].lLbound = 0;
1597 pub[
i] = psab[
i].cElements - 1;
1601 if ((vt & ~VT_BYREF) == VT_ARRAY) {
1602 vt = (vt | VT_VARIANT);
1604 psa = SafeArrayCreate((VARTYPE)(vt & VT_TYPEMASK), dim, psab);
1608 hr = SafeArrayLock(psa);
1609 if (SUCCEEDED(hr)) {
1611 hr = SafeArrayUnlock(psa);
1615 if(psab)
free(psab);
1618 if (SUCCEEDED(hr)) {
1624 SafeArrayDestroy(psa);
1637 V_VT(var) = VT_DISPATCH;
1643 VariantCopy(var, &(pvar->
var));
1648 V_VT(var) = VT_DATE;
1652 switch (
TYPE(val)) {
1657 V_VT(var) = VT_BSTR;
1673 V_VT(var) = VT_BOOL;
1674 V_BOOL(var) = VARIANT_TRUE;
1677 V_VT(var) = VT_BOOL;
1678 V_BOOL(var) = VARIANT_FALSE;
1682 V_VT(var) = VT_ERROR;
1683 V_ERROR(var) = DISP_E_PARAMNOTFOUND;
1685 V_VT(var) = VT_EMPTY;
1689 V_VT(var) = VT_DISPATCH;
1699 if (vt == VT_VARIANT) {
1702 V_VT(var) = (vt & ~VT_BYREF);
1703 if (V_VT(var) == VT_DISPATCH) {
1704 V_DISPATCH(var) =
NULL;
1705 }
else if (V_VT(var) == VT_UNKNOWN) {
1706 V_UNKNOWN(var) =
NULL;
1711 #if (_MSC_VER >= 1300) || defined(__CYGWIN__) || defined(__MINGW32__)
1712 switch(vt & ~VT_BYREF) {
1715 V_I8(var) =
NUM2I8 (val);
1733 switch (
TYPE(val)) {
1735 if (V_VT(var) == (VT_BSTR | VT_BYREF)) {
1741 case (VT_UI1 | VT_BYREF) :
1742 *V_UI1REF(var) =
NUM2CHR(val);
1744 case (VT_I2 | VT_BYREF) :
1745 *V_I2REF(var) = (short)
NUM2INT(val);
1747 case (VT_I4 | VT_BYREF) :
1750 case (VT_R4 | VT_BYREF) :
1751 *V_R4REF(var) = (float)
NUM2INT(val);
1753 case (VT_R8 | VT_BYREF) :
1762 case (VT_I2 | VT_BYREF) :
1763 *V_I2REF(var) = (short)
NUM2INT(val);
1765 case (VT_I4 | VT_BYREF) :
1768 case (VT_R4 | VT_BYREF) :
1769 *V_R4REF(var) = (float)
NUM2DBL(val);
1771 case (VT_R8 | VT_BYREF) :
1779 if (V_VT(var) == (VT_R8 | VT_BYREF)) {
1784 if (V_VT(var) == (VT_BOOL | VT_BYREF)) {
1785 *V_BOOLREF(var) = VARIANT_TRUE;
1789 if (V_VT(var) == (VT_BOOL | VT_BYREF)) {
1790 *V_BOOLREF(var) = VARIANT_FALSE;
1802 if (vt == (VT_VARIANT|VT_BYREF)) {
1805 if (V_VT(realvar) != (vt & ~VT_BYREF)) {
1808 switch(vt & ~VT_BYREF) {
1810 V_I1REF(var) = &V_I1(realvar);
1813 V_UI1REF(var) = &V_UI1(realvar);
1816 V_I2REF(var) = &V_I2(realvar);
1822 V_I4REF(var) = &V_I4(realvar);
1825 V_UI4REF(var) = &V_UI4(realvar);
1828 V_R4REF(var) = &V_R4(realvar);
1831 V_R8REF(var) = &V_R8(realvar);
1834 #if (_MSC_VER >= 1300) || defined(__CYGWIN__) || defined(__MINGW32__)
1837 V_I8REF(var) = &V_I8(realvar);
1842 V_UI8REF(var) = &V_UI8(realvar);
1855 V_CYREF(var) = &V_CY(realvar);
1858 V_DATEREF(var) = &V_DATE(realvar);
1861 V_BSTRREF(var) = &V_BSTR(realvar);
1864 V_DISPATCHREF(var) = &V_DISPATCH(realvar);
1867 V_ERRORREF(var) = &V_ERROR(realvar);
1870 V_BOOLREF(var) = &V_BOOL(realvar);
1873 V_UNKNOWNREF(var) = &V_UNKNOWN(realvar);
1876 V_ARRAYREF(var) = &V_ARRAY(realvar);
1890 if (((vt & ~VT_BYREF) == (VT_ARRAY | VT_UI1)) &&
TYPE(val) ==
T_STRING) {
1893 SAFEARRAY *p =
NULL;
1894 SAFEARRAY *psa = SafeArrayCreateVector(VT_UI1, 0, len);
1898 hr = SafeArrayAccessData(psa, &pdest);
1899 if (SUCCEEDED(hr)) {
1901 SafeArrayUnaccessData(psa);
1902 V_VT(&(pvar->
realvar)) = (vt & ~VT_BYREF);
1903 p = V_ARRAY(&(pvar->
realvar));
1905 SafeArrayDestroy(p);
1907 V_ARRAY(&(pvar->
realvar)) = psa;
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 SafeArrayDestroy(psa);
1918 }
else if (vt & VT_ARRAY) {
1920 V_VT(&(pvar->
var)) = vt;
1921 if (vt & VT_BYREF) {
1922 V_ARRAYREF(&(pvar->
var)) = &(V_ARRAY(&(pvar->
realvar)));
1926 if (SUCCEEDED(hr)) {
1927 if (vt & VT_BYREF) {
1928 V_VT(&(pvar->
var)) = vt;
1929 V_ARRAYREF(&(pvar->
var)) = &(V_ARRAY(&(pvar->
realvar)));
1931 hr = VariantCopy(&(pvar->
var), &(pvar->
realvar));
1935 #if (_MSC_VER >= 1300) || defined(__CYGWIN__) || defined(__MINGW32__)
1936 }
else if ( (vt & ~VT_BYREF) == VT_I8 || (vt & ~VT_BYREF) == VT_UI8) {
1939 V_VT(&(pvar->
var)) = vt;
1940 if (vt & VT_BYREF) {
1946 V_VT(&(pvar->
var)) = vt;
1947 if (vt == (VT_BYREF | VT_VARIANT)) {
1950 V_VT(&(pvar->
realvar)) = vt & ~VT_BYREF;
1951 if (vt & VT_BYREF) {
1957 if (vt == (VT_BYREF | VT_VARIANT)) {
1959 }
else if (vt & VT_BYREF) {
1960 if ( (vt & ~VT_BYREF) != V_VT(&(pvar->
realvar))) {
1964 if (SUCCEEDED(hr)) {
1968 if (vt == V_VT(&(pvar->
realvar))) {
1969 hr = VariantCopy(&(pvar->
var), &(pvar->
realvar));
1971 hr = VariantChangeTypeEx(&(pvar->
var), &(pvar->
realvar),
2047 long *ids =
ALLOC_N(
long, dim);
2051 for(i = 0; i < dim; i++) {
2052 ids[
i] = pid[
i] - plb[
i];
2056 for(i = 0; i < dim-1; i++) {
2070 long id = pid[dim - 1] - plb[dim - 1];
2080 while ( V_VT(pvar) == (VT_BYREF | VT_VARIANT) )
2081 pvar = V_VARIANTREF(pvar);
2083 if(V_ISARRAY(pvar)) {
2084 SAFEARRAY *psa = V_ISBYREF(pvar) ? *V_ARRAYREF(pvar) : V_ARRAY(pvar);
2086 long *pid, *plb, *pub;
2093 dim = SafeArrayGetDim(psa);
2094 VariantInit(&variant);
2095 V_VT(&variant) = (V_VT(pvar) & ~VT_ARRAY) | VT_BYREF;
2101 if(!pid || !plb || !pub) {
2108 for(i = 0; i < dim; ++
i) {
2109 SafeArrayGetLBound(psa, i+1, &plb[i]);
2110 SafeArrayGetLBound(psa, i+1, &pid[i]);
2111 SafeArrayGetUBound(psa, i+1, &pub[i]);
2113 hr = SafeArrayLock(psa);
2114 if (SUCCEEDED(hr)) {
2119 hr = SafeArrayPtrOfIndex(psa, pid, &V_BYREF(&variant));
2120 if (SUCCEEDED(hr)) {
2124 for (i = 0; i < dim; ++
i) {
2125 if (++pid[i] <= pub[i])
2130 SafeArrayUnlock(psa);
2137 switch(V_VT(pvar) & ~VT_BYREF){
2146 obj =
INT2NUM((
long)V_I1(pvar));
2151 obj =
INT2NUM((
long)*V_UI1REF(pvar));
2153 obj =
INT2NUM((
long)V_UI1(pvar));
2158 obj =
INT2NUM((
long)*V_I2REF(pvar));
2160 obj =
INT2NUM((
long)V_I2(pvar));
2167 obj =
INT2NUM((
long)V_UI2(pvar));
2172 obj =
INT2NUM((
long)*V_I4REF(pvar));
2174 obj =
INT2NUM((
long)V_I4(pvar));
2179 obj =
INT2NUM((
long)*V_UI4REF(pvar));
2181 obj =
INT2NUM((
long)V_UI4(pvar));
2198 #if (_MSC_VER >= 1300) || defined(__CYGWIN__) || defined(__MINGW32__)
2201 #if (_MSC_VER >= 1300) || defined(__CYGWIN__) || defined(__MINGW32__)
2213 #if (_MSC_VER >= 1300) || defined(__CYGWIN__) || defined(__MINGW32__)
2250 obj =
INT2NUM(*V_ERRORREF(pvar));
2256 if (V_ISBYREF(pvar))
2266 if (V_ISBYREF(pvar))
2267 pDispatch = *V_DISPATCHREF(pvar);
2269 pDispatch = V_DISPATCH(pvar);
2271 if (pDispatch !=
NULL ) {
2286 if (V_ISBYREF(pvar))
2287 punk = *V_UNKNOWNREF(pvar);
2289 punk = V_UNKNOWN(pvar);
2292 hr = punk->lpVtbl->QueryInterface(punk, &IID_IDispatch, &p);
2305 date = *V_DATEREF(pvar);
2307 date = V_DATE(pvar);
2317 VariantInit(&variant);
2318 hr = VariantChangeTypeEx(&variant, pvar,
2320 if (SUCCEEDED(hr) && V_VT(&variant) == VT_BSTR) {
2323 VariantClear(&variant);
2333 return RegOpenKeyEx(hkey, name, 0, KEY_READ, phkey);
2345 char buf[BUFSIZ + 1];
2348 LONG
err = RegEnumKeyEx(hkey, i, buf, &size_buf,
2350 if(err == ERROR_SUCCESS) {
2364 LONG
err = RegQueryValueEx(hkey, subkey,
NULL, &dwtype,
NULL, &size);
2366 if (err == ERROR_SUCCESS) {
2367 pbuf =
ALLOC_N(
char, size + 1);
2368 err = RegQueryValueEx(hkey, subkey,
NULL, &dwtype, (BYTE *)pbuf, &size);
2369 if (err == ERROR_SUCCESS) {
2371 if (dwtype == REG_EXPAND_SZ) {
2372 char* pbuf2 = (
char *)pbuf;
2374 pbuf =
ALLOC_N(
char, len + 1);
2375 ExpandEnvironmentStrings(pbuf2, pbuf, len + 1);
2391 err = RegOpenKeyEx(hkey, subkey, 0, KEY_READ, &hsubkey);
2392 if (err == ERROR_SUCCESS) {
2394 RegCloseKey(hsubkey);
2424 char path[MAX_PATH + 1];
2426 err =
reg_open_key(HKEY_CLASSES_ROOT,
"CLSID", &hroot);
2427 if (err != ERROR_SUCCESS) {
2431 if (err != ERROR_SUCCESS) {
2437 RegCloseKey(hclsid);
2438 if (typelib !=
Qnil) {
2439 ExpandEnvironmentStrings(
StringValuePtr(typelib), path,
sizeof(path));
2440 path[MAX_PATH] =
'\0';
2449 HKEY htypelib, hclsid, hversion, hlang;
2460 err =
reg_open_key(HKEY_CLASSES_ROOT,
"TypeLib", &htypelib);
2461 if(err != ERROR_SUCCESS) {
2464 for(i = 0; !found; i++) {
2469 if (err != ERROR_SUCCESS)
2472 for(j = 0; !found; j++) {
2481 if (typelib ==
Qnil)
2484 for(k = 0; !found; k++) {
2489 if (err == ERROR_SUCCESS) {
2496 RegCloseKey(hversion);
2498 RegCloseKey(hclsid);
2500 RegCloseKey(htypelib);
2520 ITypeInfo *pTypeInfo;
2521 TYPEATTR *pTypeAttr;
2531 count = pTypeLib->lpVtbl->GetTypeInfoCount(pTypeLib);
2532 for (index = 0; index <
count; index++) {
2533 hr = pTypeLib->lpVtbl->GetTypeInfo(pTypeLib, index, &pTypeInfo);
2541 for(iVar = 0; iVar < pTypeAttr->cVars; iVar++) {
2542 hr = pTypeInfo->lpVtbl->GetVarDesc(pTypeInfo, iVar, &pVarDesc);
2545 if(pVarDesc->varkind == VAR_CONST &&
2546 !(pVarDesc->wVarFlags & (VARFLAG_FHIDDEN |
2547 VARFLAG_FRESTRICTED |
2548 VARFLAG_FNONBROWSABLE))) {
2549 hr = pTypeInfo->lpVtbl->GetNames(pTypeInfo, pVarDesc->memid, &bstr,
2551 if(FAILED(hr) || len == 0 || !bstr)
2555 *pName = toupper((
int)*pName);
2563 SysFreeString(bstr);
2569 pTypeInfo->lpVtbl->ReleaseVarDesc(pTypeInfo, pVarDesc);
2571 pTypeInfo->lpVtbl->ReleaseTypeAttr(pTypeInfo, pTypeAttr);
2589 err = RegConnectRegistry(
StringValuePtr(host), HKEY_LOCAL_MACHINE, &hlm);
2590 if (err != ERROR_SUCCESS)
2591 return HRESULT_FROM_WIN32(err);
2595 err = RegOpenKeyEx(hlm,
StringValuePtr(subkey), 0, KEY_READ, &hpid);
2596 if (err != ERROR_SUCCESS)
2597 hr = HRESULT_FROM_WIN32(err);
2599 len =
sizeof(clsid);
2600 err = RegQueryValueEx(hpid,
"",
NULL, &dwtype, (BYTE *)clsid, &len);
2601 if (err == ERROR_SUCCESS && dwtype == REG_SZ) {
2603 hr = CLSIDFromString(pbuf, pclsid);
2604 SysFreeString(pbuf);
2607 hr = HRESULT_FROM_WIN32(err);
2618 VALUE ole, host, others;
2623 COSERVERINFO serverinfo;
2625 DWORD clsctx = CLSCTX_REMOTE_SERVER;
2628 gole32 = LoadLibrary(
"OLE32");
2633 GetProcAddress(
gole32,
"CoCreateInstanceEx");
2639 hr = CLSIDFromProgID(pbuf, &clsid);
2643 hr = CLSIDFromString(pbuf, &clsid);
2644 SysFreeString(pbuf);
2647 "unknown OLE server: `%s'",
2649 memset(&serverinfo, 0,
sizeof(COSERVERINFO));
2651 memset(&multi_qi, 0,
sizeof(MULTI_QI));
2652 multi_qi.pIID = &IID_IDispatch;
2654 SysFreeString(serverinfo.pwszName);
2657 "failed to create DCOM server `%s' in `%s'",
2678 hr = CreateBindCtx(0, &pBindCtx);
2681 "failed to create bind context");
2685 hr = MkParseDisplayName(pBindCtx, pbuf, &eaten, &pMoniker);
2686 SysFreeString(pbuf);
2690 "failed to parse display name of moniker `%s'",
2693 hr = pMoniker->lpVtbl->BindToObject(pMoniker, pBindCtx,
NULL,
2694 &IID_IDispatch, &p);
2701 "failed to bind moniker `%s'",
2741 hr = CLSIDFromProgID(pBuf, &clsid);
2743 hr = CLSIDFromString(pBuf, &clsid);
2745 SysFreeString(pBuf);
2750 hr = GetActiveObject(&clsid, 0, &pUnknown);
2755 hr = pUnknown->lpVtbl->QueryInterface(pUnknown, &IID_IDispatch, &p);
2760 "failed to create WIN32OLE server `%s'",
2804 ITypeInfo *pTypeInfo;
2822 0, lcid, &pTypeInfo);
2826 hr = pTypeInfo->lpVtbl->GetContainingTypeLib(pTypeInfo, &pTypeLib, &index);
2846 hr = LoadTypeLibEx(pBuf, REGKIND_NONE, &pTypeLib);
2847 SysFreeString(pBuf);
2872 ITypeInfo *pTypeInfo;
2876 count = pTypeLib->lpVtbl->GetTypeInfoCount(pTypeLib);
2877 for (i = 0; i <
count; i++) {
2878 hr = pTypeLib->lpVtbl->GetDocumentation(pTypeLib, i,
2883 hr = pTypeLib->lpVtbl->GetTypeInfo(pTypeLib, i, &pTypeInfo);
2949 FNHTMLHELP *pfnHtmlHelp;
2953 ghhctrl = LoadLibrary(
"HHCTRL.OCX");
2956 pfnHtmlHelp = (FNHTMLHELP*)GetProcAddress(
ghhctrl,
"HtmlHelpA");
3023 static BOOL CALLBACK
3117 case LOCALE_SYSTEM_DEFAULT:
3118 case LOCALE_USER_DEFAULT:
3142 hr = CoCreateGuid(&guid);
3146 len = StringFromGUID2(&guid, bstr,
sizeof(bstr)/
sizeof(OLECHAR));
3241 rb_scan_args(argc, argv,
"11*", &svr_name, &host, &others);
3259 hr = CLSIDFromProgID(pBuf, &clsid);
3261 hr = CLSIDFromString(pBuf, &clsid);
3263 SysFreeString(pBuf);
3266 "unknown OLE server: `%s'",
3271 hr = CoCreateInstance(&clsid,
NULL, CLSCTX_INPROC_SERVER | CLSCTX_LOCAL_SERVER,
3272 &IID_IDispatch, &p);
3276 "failed to create WIN32OLE object from `%s'",
3289 index = pOp->
dp.cNamedArgs;
3297 for(i = 1; i < index + 1; i++) {
3301 for(i = 0; i <
index; i++ ) {
3302 VariantClear(&(pOp->
dp.rgvarg[i]));
3315 VariantInit(&(pOp->
dp.rgvarg[index]));
3318 pOp->
dp.cNamedArgs += 1;
3329 while (end-- > beg) {
3331 VariantClear(&realargs[end]);
3352 EXCEPINFO excepinfo;
3354 VARIANTARG* realargs =
NULL;
3355 unsigned int argErr = 0;
3357 unsigned int cNamedArgs;
3361 memset(&excepinfo, 0,
sizeof(EXCEPINFO));
3363 VariantInit(&result);
3366 op.
dp.rgdispidNamedArgs =
NULL;
3367 op.
dp.cNamedArgs = 0;
3382 DispID = DISPID_VALUE;
3388 &wcmdname, 1, lcid, &DispID);
3389 SysFreeString(wcmdname);
3392 "unknown property or method: `%s'",
3400 op.
dp.cNamedArgs = 0;
3408 op.
dp.cArgs = cNamedArgs + argc - 2;
3413 pDispID =
ALLOCA_N(DISPID, cNamedArgs + 1);
3418 op.dp.cNamedArgs + 1,
3420 for(i = 0; i < op.dp.cNamedArgs + 1; i++) {
3421 SysFreeString(op.pNamedArgs[i]);
3422 op.pNamedArgs[
i] =
NULL;
3426 for(i = 0; i < op.dp.cArgs; i++ ) {
3427 VariantClear(&op.dp.rgvarg[i]);
3430 "failed to get named argument info: `%s'",
3433 op.dp.rgdispidNamedArgs = &(pDispID[1]);
3437 op.
dp.cArgs = argc - 1;
3439 if (op.
dp.cArgs > 0) {
3446 if(op.
dp.cArgs > cNamedArgs) {
3447 realargs =
ALLOCA_N(VARIANTARG, op.
dp.cArgs-cNamedArgs+1);
3448 for(i = cNamedArgs; i < op.
dp.cArgs; i++) {
3449 n = op.
dp.cArgs - i + cNamedArgs - 1;
3450 VariantInit(&realargs[n]);
3451 VariantInit(&op.
dp.rgvarg[n]);
3455 VariantCopy(&op.
dp.rgvarg[n], &(pvar->
var));
3458 V_VT(&op.
dp.rgvarg[n]) = VT_VARIANT | VT_BYREF;
3459 V_VARIANTREF(&op.
dp.rgvarg[n]) = &realargs[
n];
3464 if (wFlags & DISPATCH_PROPERTYPUT) {
3465 if (op.
dp.cArgs == 0)
3468 op.
dp.cNamedArgs = 1;
3469 op.
dp.rgdispidNamedArgs =
ALLOCA_N( DISPID, 1 );
3470 op.
dp.rgdispidNamedArgs[0] = DISPID_PROPERTYPUT;
3474 &IID_NULL, lcid, wFlags, &op.
dp,
3475 &result, &excepinfo, &argErr);
3479 if(op.
dp.cArgs >= cNamedArgs) {
3480 for(i = cNamedArgs; i < op.
dp.cArgs; i++) {
3481 n = op.
dp.cArgs - i + cNamedArgs - 1;
3485 if (hr == DISP_E_EXCEPTION) {
3488 memset(&excepinfo, 0,
sizeof(EXCEPINFO));
3489 VariantInit(&result);
3491 &IID_NULL, lcid, wFlags,
3493 &excepinfo, &argErr);
3499 if ((hr == DISP_E_EXCEPTION || hr == DISP_E_MEMBERNOTFOUND) && DispID > 0x8000) {
3500 if (hr == DISP_E_EXCEPTION) {
3503 memset(&excepinfo, 0,
sizeof(EXCEPINFO));
3505 &IID_NULL, lcid, wFlags,
3507 &excepinfo, &argErr);
3510 for(i = cNamedArgs; i < op.
dp.cArgs; i++) {
3511 n = op.
dp.cArgs - i + cNamedArgs - 1;
3512 VariantClear(&op.
dp.rgvarg[n]);
3518 if (op.
dp.cArgs > cNamedArgs) {
3519 for(i = cNamedArgs; i < op.
dp.cArgs; i++) {
3520 n = op.
dp.cArgs - i + cNamedArgs - 1;
3524 if (hr == DISP_E_EXCEPTION) {
3527 memset(&excepinfo, 0,
sizeof(EXCEPINFO));
3528 VariantInit(&result);
3530 &IID_NULL, lcid, wFlags,
3532 &excepinfo, &argErr);
3533 for(i = cNamedArgs; i < op.
dp.cArgs; i++) {
3534 n = op.
dp.cArgs - i + cNamedArgs - 1;
3535 VariantClear(&op.
dp.rgvarg[n]);
3542 if(op.
dp.cArgs > cNamedArgs) {
3543 for(i = cNamedArgs; i < op.
dp.cArgs; i++) {
3544 n = op.
dp.cArgs - i + cNamedArgs - 1;
3553 for(i = 0; i < op.
dp.cArgs; i++) {
3554 VariantClear(&op.
dp.rgvarg[i]);
3565 VariantClear(&result);
3585 return ole_invoke(argc, argv,
self, DISPATCH_METHOD|DISPATCH_PROPERTYGET,
FALSE);
3593 unsigned int argErr = 0;
3594 EXCEPINFO excepinfo;
3596 DISPPARAMS dispParams;
3597 VARIANTARG* realargs =
NULL;
3607 memset(&excepinfo, 0,
sizeof(EXCEPINFO));
3608 memset(&dispParams, 0,
sizeof(DISPPARAMS));
3609 VariantInit(&result);
3613 dispParams.rgvarg =
ALLOCA_N(VARIANTARG, dispParams.cArgs);
3614 realargs =
ALLOCA_N(VARIANTARG, dispParams.cArgs);
3615 for (i = 0, j = dispParams.cArgs - 1; i < (
int)dispParams.cArgs; i++, j--)
3617 VariantInit(&realargs[i]);
3618 VariantInit(&dispParams.rgvarg[i]);
3621 V_VT(&dispParams.rgvarg[i]) = vt;
3626 V_VT(&dispParams.rgvarg[i]) = V_VT(&realargs[i]) = VT_ERROR;
3627 V_ERROR(&dispParams.rgvarg[i]) = V_ERROR(&realargs[i]) = DISP_E_PARAMNOTFOUND;
3640 SAFEARRAYBOUND rgsabound[1];
3642 rgsabound[0].lLbound = 0;
3644 v = vt & ~(VT_ARRAY | VT_BYREF);
3645 V_ARRAY(&realargs[i]) = SafeArrayCreate(v, 1, rgsabound);
3646 V_VT(&realargs[i]) = VT_ARRAY |
v;
3647 SafeArrayLock(V_ARRAY(&realargs[i]));
3648 pb = V_ARRAY(&realargs[i])->pvData;
3649 ps = V_ARRAY(&realargs[i])->pvData;
3650 pl = V_ARRAY(&realargs[i])->pvData;
3651 py = V_ARRAY(&realargs[i])->pvData;
3652 pv = V_ARRAY(&realargs[i])->pvData;
3653 for (ent = 0; ent < (
int)rgsabound[0].cElements; ent++)
3658 if (v != VT_VARIANT)
3660 VariantChangeTypeEx(&velem, &velem,
3673 *py++ = V_CY(&velem);
3679 *ps++ = V_I2(&velem);
3684 *pb++ = V_UI1(&velem);
3688 *pl++ = V_I4(&velem);
3692 SafeArrayUnlock(V_ARRAY(&realargs[i]));
3697 if ((vt & (~VT_BYREF)) != VT_VARIANT)
3699 hr = VariantChangeTypeEx(&realargs[i], &realargs[i],
3701 (VARTYPE)(vt & (~VT_BYREF)));
3708 if ((vt & VT_BYREF) || vt == VT_VARIANT)
3710 if (vt == VT_VARIANT)
3711 V_VT(&dispParams.rgvarg[i]) = VT_VARIANT | VT_BYREF;
3712 switch (vt & (~VT_BYREF))
3716 V_VARIANTREF(&dispParams.rgvarg[i]) = &realargs[
i];
3722 V_CYREF(&dispParams.rgvarg[i]) = &V_CY(&realargs[i]);
3728 V_I2REF(&dispParams.rgvarg[i]) = &V_I2(&realargs[i]);
3733 V_UI1REF(&dispParams.rgvarg[i]) = &V_UI1(&realargs[i]);
3737 V_I4REF(&dispParams.rgvarg[i]) = &V_I4(&realargs[i]);
3744 V_CY(&dispParams.rgvarg[i]) = V_CY(&realargs[i]);
3749 if (dispkind & DISPATCH_PROPERTYPUT) {
3750 dispParams.cNamedArgs = 1;
3751 dispParams.rgdispidNamedArgs =
ALLOCA_N( DISPID, 1 );
3752 dispParams.rgdispidNamedArgs[0] = DISPID_PROPERTYPUT;
3758 &dispParams, &result,
3759 &excepinfo, &argErr);
3769 if(dispParams.cArgs > 0) {
3770 set_argv(realargs, 0, dispParams.cArgs);
3774 VariantClear(&result);
3793 return ole_invoke2(
self, dispid, args, types, DISPATCH_METHOD);
3811 return ole_invoke2(
self, dispid, args, types, DISPATCH_PROPERTYGET);
3829 return ole_invoke2(
self, dispid, args, types, DISPATCH_PROPERTYPUT);
3904 EXCEPINFO excepinfo;
3905 DISPID dispID = DISPID_VALUE;
3906 DISPID dispIDParam = DISPID_PROPERTYPUT;
3907 USHORT wFlags = DISPATCH_PROPERTYPUT|DISPATCH_PROPERTYPUTREF;
3908 DISPPARAMS dispParams;
3909 VARIANTARG propertyValue[2];
3913 dispParams.rgdispidNamedArgs = &dispIDParam;
3914 dispParams.rgvarg = propertyValue;
3915 dispParams.cNamedArgs = 1;
3916 dispParams.cArgs = 1;
3918 VariantInit(&propertyValue[0]);
3919 VariantInit(&propertyValue[1]);
3920 memset(&excepinfo, 0,
sizeof(excepinfo));
3927 pBuf, 1, lcid, &dispID);
3928 SysFreeString(pBuf[0]);
3933 "unknown property or method: `%s'",
3939 lcid, wFlags, &dispParams,
3940 NULL, &excepinfo, &argErr);
3942 for(index = 0; index < dispParams.cArgs; ++
index) {
3943 VariantClear(&propertyValue[index]);
3979 IEnumVARIANT *pEnum = (IEnumVARIANT *)pEnumV;
3980 VariantInit(&variant);
3981 while(pEnum->lpVtbl->Next(pEnum, 1, &variant,
NULL) ==
S_OK) {
3983 VariantClear(&variant);
3984 VariantInit(&variant);
3993 IEnumVARIANT *pEnum = (IEnumVARIANT *)pEnumV;
4019 unsigned int argErr;
4020 EXCEPINFO excepinfo;
4021 DISPPARAMS dispParams;
4024 IEnumVARIANT *pEnum =
NULL;
4029 VariantInit(&result);
4030 dispParams.rgvarg =
NULL;
4031 dispParams.rgdispidNamedArgs =
NULL;
4032 dispParams.cNamedArgs = 0;
4033 dispParams.cArgs = 0;
4034 memset(&excepinfo, 0,
sizeof(excepinfo));
4039 DISPATCH_METHOD | DISPATCH_PROPERTYGET,
4040 &dispParams, &result,
4041 &excepinfo, &argErr);
4044 VariantClear(&result);
4048 if (V_VT(&result) == VT_UNKNOWN) {
4049 hr = V_UNKNOWN(&result)->lpVtbl->QueryInterface(V_UNKNOWN(&result),
4053 }
else if (V_VT(&result) == VT_DISPATCH) {
4054 hr = V_DISPATCH(&result)->lpVtbl->QueryInterface(V_DISPATCH(&result),
4059 if (FAILED(hr) || !pEnum) {
4060 VariantClear(&result);
4064 VariantClear(&result);
4087 if(mname[n-1] ==
'=') {
4094 return ole_invoke(argc, argv,
self, DISPATCH_METHOD|DISPATCH_PROPERTYGET,
FALSE);
4102 TYPEATTR *pTypeAttr;
4104 FUNCDESC *pFuncDesc;
4112 for(i = 0; i < pTypeAttr->cFuncs && method ==
Qnil; i++) {
4113 hr = pTypeInfo->lpVtbl->GetFuncDesc(pTypeInfo, i, &pFuncDesc);
4117 hr = pTypeInfo->lpVtbl->GetDocumentation(pTypeInfo, pFuncDesc->memid,
4120 pTypeInfo->lpVtbl->ReleaseFuncDesc(pTypeInfo, pFuncDesc);
4128 pTypeInfo->lpVtbl->ReleaseFuncDesc(pTypeInfo, pFuncDesc);
4139 TYPEATTR *pTypeAttr;
4142 ITypeInfo *pRefTypeInfo;
4149 if (method !=
Qnil) {
4152 for(i=0; i < pTypeAttr->cImplTypes && method ==
Qnil; i++){
4153 hr = pTypeInfo->lpVtbl->GetRefTypeOfImplType(pTypeInfo, i, &href);
4156 hr = pTypeInfo->lpVtbl->GetRefTypeInfo(pTypeInfo, href, &pRefTypeInfo);
4170 TYPEATTR *pTypeAttr;
4172 FUNCDESC *pFuncDesc;
4179 for(i = 0; i < pTypeAttr->cFuncs; i++) {
4180 hr = pTypeInfo->lpVtbl->GetFuncDesc(pTypeInfo, i, &pFuncDesc);
4184 hr = pTypeInfo->lpVtbl->GetDocumentation(pTypeInfo, pFuncDesc->memid,
4187 pTypeInfo->lpVtbl->ReleaseFuncDesc(pTypeInfo, pFuncDesc);
4190 if(pFuncDesc->invkind & mask) {
4196 pTypeInfo->lpVtbl->ReleaseFuncDesc(pTypeInfo, pFuncDesc);
4208 TYPEATTR *pTypeAttr;
4211 ITypeInfo *pRefTypeInfo;
4219 for(i=0; i < pTypeAttr->cImplTypes; i++){
4220 hr = pTypeInfo->lpVtbl->GetRefTypeOfImplType(pTypeInfo, i, &href);
4223 hr = pTypeInfo->lpVtbl->GetRefTypeInfo(pTypeInfo, href, &pRefTypeInfo);
4236 ITypeInfo *pTypeInfo;
4244 0, lcid, &pTypeInfo);
4248 hr = pTypeInfo->lpVtbl->GetDocumentation(pTypeInfo,
4253 hr = pTypeInfo->lpVtbl->GetContainingTypeLib(pTypeInfo, &pTypeLib, &i);
4258 count = pTypeLib->lpVtbl->GetTypeInfoCount(pTypeLib);
4259 for (i = 0; i <
count; i++) {
4260 hr = pTypeLib->lpVtbl->GetDocumentation(pTypeLib, i,
4263 hr = pTypeLib->lpVtbl->GetTypeInfo(pTypeLib, i, &pTypeInfo);
4264 if (SUCCEEDED(hr)) {
4277 ITypeInfo *pTypeInfo;
4307 return ole_methods(
self, INVOKE_FUNC | INVOKE_PROPERTYGET | INVOKE_PROPERTYPUT | INVOKE_PROPERTYPUTREF);
4339 return ole_methods(
self, INVOKE_PROPERTYPUT|INVOKE_PROPERTYPUTREF);
4368 hr = pTypeInfo->lpVtbl->GetContainingTypeLib( pTypeInfo, &pTypeLib, &index );
4372 hr = pTypeLib->lpVtbl->GetDocumentation( pTypeLib, index,
4395 ITypeInfo *pTypeInfo;
4423 hr = pTypeInfo->lpVtbl->GetContainingTypeLib(pTypeInfo, &pTypeLib, &index);
4448 ITypeInfo *pTypeInfo;
4454 0, lcid, &pTypeInfo);
4460 if (vtlib ==
Qnil) {
4487 hr = CLSIDFromString(pBuf, &iid);
4488 SysFreeString(pBuf);
4491 "invalid iid: `%s'",
4504 "failed to get interface `%s'",
4539 SysFreeString(wcmdname);
4550 hr = pTypeInfo->lpVtbl->GetContainingTypeLib(pTypeInfo, &pTypeLib, &i);
4555 hr = pTypeLib->lpVtbl->GetDocumentation(pTypeLib, i,
4557 helpcontext, helpfile);
4571 ITypeInfo *pRefTypeInfo;
4574 hr = pTypeInfo->lpVtbl->GetRefTypeInfo(pTypeInfo,
4586 if(typedetails !=
Qnil)
4594 TYPEDESC *p = pTypeDesc;
4597 if (p->vt == VT_PTR || p->vt == VT_SAFEARRAY) {
4609 switch(pTypeDesc->vt) {
4652 #if (_MSC_VER >= 1300) || defined(__CYGWIN__) || defined(__MINGW32__)
4674 if(typedetails !=
Qnil)
4679 if(typedetails !=
Qnil)
4685 case VT_USERDEFINED:
4687 if (typedetails !=
Qnil)
4714 if (typedetails !=
Qnil)
4733 ITypeInfo *pTypeInfo;
4776 IPersistMemory *pPersistMemory;
4783 hr = pole->
pDispatch->lpVtbl->QueryInterface(pole->
pDispatch, &IID_IPersistMemory, &p);
4785 if (SUCCEEDED(hr)) {
4786 hr = pPersistMemory->lpVtbl->InitNew(pPersistMemory);
4788 if (SUCCEEDED(hr)) {
4837 return rb_eval_string(
"WIN32OLE_TYPELIB.typelibs.collect{|t|t.name}");
4849 HKEY hclsids, hclsid;
4856 err =
reg_open_key(HKEY_CLASSES_ROOT,
"CLSID", &hclsids);
4857 if(err != ERROR_SUCCESS) {
4865 if (err != ERROR_SUCCESS)
4871 RegCloseKey(hclsid);
4873 RegCloseKey(hclsids);
4912 count = pTypeLib->lpVtbl->GetTypeInfoCount(pTypeLib);
4913 for (i = 0; i < count && found ==
Qfalse; i++) {
4914 hr = pTypeLib->lpVtbl->GetTypeInfo(pTypeLib, i, &pTypeInfo);
4917 hr = pTypeLib->lpVtbl->GetDocumentation(pTypeLib, i,
4958 hr = pTypeLib->lpVtbl->GetLibAttr(pTypeLib, ppTLibAttr);
4961 "failed to get library attribute(TLIBATTR) from ITypeLib");
4978 HKEY htypelib, hguid;
4989 err =
reg_open_key(HKEY_CLASSES_ROOT,
"TypeLib", &htypelib);
4990 if(err != ERROR_SUCCESS) {
4998 if (err != ERROR_SUCCESS)
5002 if (version ==
Qnil)
5006 if (SUCCEEDED(hr)) {
5015 RegCloseKey(htypelib);
5024 if (major ==
Qnil) {
5028 if (minor !=
Qnil) {
5039 HKEY htypelib, hguid, hversion;
5055 err =
reg_open_key(HKEY_CLASSES_ROOT,
"TypeLib", &htypelib);
5056 if(err != ERROR_SUCCESS) {
5060 if (err != ERROR_SUCCESS) {
5061 RegCloseKey(htypelib);
5064 if (version_str !=
Qnil) {
5066 if (err == ERROR_SUCCESS) {
5070 version = version_str;
5073 RegCloseKey(hversion);
5081 if (err != ERROR_SUCCESS)
5085 RegCloseKey(hversion);
5093 RegCloseKey(hversion);
5097 RegCloseKey(htypelib);
5098 if (typelib !=
Qnil) {
5100 if (SUCCEEDED(hr)) {
5111 HKEY htypelib, hguid, hversion;
5121 err =
reg_open_key(HKEY_CLASSES_ROOT,
"TypeLib", &htypelib);
5122 if(err != ERROR_SUCCESS) {
5125 for(i = 0; !found; i++) {
5130 if (err != ERROR_SUCCESS)
5132 for(j = 0; found ==
Qfalse; j++) {
5137 if (err != ERROR_SUCCESS)
5141 RegCloseKey(hversion);
5146 if (SUCCEEDED(hr)) {
5151 RegCloseKey(hversion);
5155 RegCloseKey(htypelib);
5207 if (len < 1 || len > 3) {
5221 hr = LoadTypeLibEx(pbuf, REGKIND_NONE, &pTypeLib);
5222 SysFreeString(pbuf);
5223 if (SUCCEEDED(hr)) {
5252 TLIBATTR *pTLibAttr;
5256 len = StringFromGUID2(&pTLibAttr->guid, bstr,
sizeof(bstr)/
sizeof(OLECHAR));
5260 pTypeLib->lpVtbl->ReleaseTLibAttr(pTypeLib, pTLibAttr);
5281 hr = pTypeLib->lpVtbl->GetDocumentation(pTypeLib, -1,
5303 TLIBATTR *pTLibAttr;
5310 major =
INT2NUM(pTLibAttr->wMajorVerNum);
5311 minor =
INT2NUM(pTLibAttr->wMinorVerNum);
5312 pTypeLib->lpVtbl->ReleaseTLibAttr(pTypeLib, pTLibAttr);
5328 TLIBATTR *pTLibAttr;
5334 major =
INT2NUM(pTLibAttr->wMajorVerNum);
5335 pTypeLib->lpVtbl->ReleaseTLibAttr(pTypeLib, pTLibAttr);
5351 TLIBATTR *pTLibAttr;
5356 minor =
INT2NUM(pTLibAttr->wMinorVerNum);
5357 pTypeLib->lpVtbl->ReleaseTLibAttr(pTypeLib, pTLibAttr);
5377 if (err != ERROR_SUCCESS) {
5380 for(k = 0; path ==
Qnil; k++) {
5385 if (err == ERROR_SUCCESS) {
5402 return E_UNEXPECTED;
5405 hr = LoadTypeLibEx(pBuf, REGKIND_NONE, ppTypeLib);
5406 SysFreeString(pBuf);
5422 TLIBATTR *pTLibAttr;
5431 hr = QueryPathOfRegTypeLib(&pTLibAttr->guid,
5432 pTLibAttr->wMajorVerNum,
5433 pTLibAttr->wMinorVerNum,
5437 pTypeLib->lpVtbl->ReleaseTLibAttr(pTypeLib, pTLibAttr);
5441 pTypeLib->lpVtbl->ReleaseTLibAttr(pTypeLib, pTLibAttr);
5464 TLIBATTR *pTLibAttr;
5469 if ((pTLibAttr->wLibFlags == 0) ||
5470 (pTLibAttr->wLibFlags & LIBFLAG_FRESTRICTED) ||
5471 (pTLibAttr->wLibFlags & LIBFLAG_FHIDDEN)) {
5474 pTypeLib->lpVtbl->ReleaseTLibAttr(pTypeLib, pTLibAttr);
5497 hr = pTypeLib->lpVtbl->GetDocumentation(pTypeLib, -1,
5573 hr = LoadTypeLibEx(pbuf, REGKIND_NONE, &pTypeLib);
5576 SysFreeString(pbuf);
5604 TYPEATTR *pTypeAttr;
5610 switch(pTypeAttr->typekind) {
5620 case TKIND_INTERFACE:
5623 case TKIND_DISPATCH:
5666 TYPEATTR *pTypeAttr;
5673 len = StringFromGUID2(&pTypeAttr->guid, bstr,
sizeof(bstr)/
sizeof(OLECHAR));
5701 TYPEATTR *pTypeAttr;
5707 hr = ProgIDFromCLSID(&pTypeAttr->guid, &pbuf);
5708 if (SUCCEEDED(hr)) {
5710 CoTaskMemFree(pbuf);
5737 TYPEATTR *pTypeAttr;
5742 if (pTypeAttr->wTypeFlags & (TYPEFLAG_FHIDDEN | TYPEFLAG_FRESTRICTED)) {
5771 TYPEATTR *pTypeAttr;
5776 ver =
INT2FIX(pTypeAttr->wMajorVerNum);
5801 TYPEATTR *pTypeAttr;
5806 ver =
INT2FIX(pTypeAttr->wMinorVerNum);
5831 TYPEATTR *pTypeAttr;
5836 typekind =
INT2FIX(pTypeAttr->typekind);
5890 TYPEATTR *pTypeAttr;
5895 if(pTypeAttr->typekind != TKIND_ALIAS) {
5956 &helpcontext,
NULL);
5999 ITypeInfo *pRefTypeInfo;
6003 TYPEATTR *pTypeAttr;
6011 for (i = 0; i < pTypeAttr->cImplTypes; i++) {
6012 hr = pTypeInfo->lpVtbl->GetImplTypeFlags(pTypeInfo, i, &flags);
6016 hr = pTypeInfo->lpVtbl->GetRefTypeOfImplType(pTypeInfo, i, &href);
6019 hr = pTypeInfo->lpVtbl->GetRefTypeInfo(pTypeInfo, href, &pRefTypeInfo);
6023 if ((flags & implflags) == implflags) {
6125 TYPEATTR *pTypeAttr;
6138 for(i = 0; i < pTypeAttr->cVars; i++) {
6139 hr = pTypeInfo->lpVtbl->GetVarDesc(pTypeInfo, i, &pVarDesc);
6143 hr = pTypeInfo->lpVtbl->GetNames(pTypeInfo, pVarDesc->memid, &bstr,
6145 if(FAILED(hr) || len == 0 || !bstr)
6156 pTypeInfo->lpVtbl->ReleaseVarDesc(pTypeInfo, pVarDesc);
6249 hr = pTypeInfo->lpVtbl->GetVarDesc(pTypeInfo, var_index, &pVarDesc);
6253 pTypeInfo->lpVtbl->ReleaseVarDesc(pTypeInfo, pVarDesc);
6291 hr = pTypeInfo->lpVtbl->GetVarDesc(pTypeInfo, var_index, &pVarDesc);
6295 pTypeInfo->lpVtbl->ReleaseVarDesc(pTypeInfo, pVarDesc);
6325 hr = pTypeInfo->lpVtbl->GetVarDesc(pTypeInfo, var_index, &pVarDesc);
6328 if(pVarDesc->varkind == VAR_CONST)
6330 pTypeInfo->lpVtbl->ReleaseVarDesc(pTypeInfo, pVarDesc);
6369 hr = pTypeInfo->lpVtbl->GetVarDesc(pTypeInfo, var_index, &pVarDesc);
6372 if (!(pVarDesc->wVarFlags & (VARFLAG_FHIDDEN |
6373 VARFLAG_FRESTRICTED |
6374 VARFLAG_FNONBROWSABLE))) {
6377 pTypeInfo->lpVtbl->ReleaseVarDesc(pTypeInfo, pVarDesc);
6415 hr = pTypeInfo->lpVtbl->GetVarDesc(pTypeInfo, var_index, &pVarDesc);
6418 switch(pVarDesc->varkind) {
6419 case VAR_PERINSTANCE:
6434 pTypeInfo->lpVtbl->ReleaseVarDesc(pTypeInfo, pVarDesc);
6471 hr = pTypeInfo->lpVtbl->GetVarDesc(pTypeInfo, var_index, &pVarDesc);
6474 pTypeInfo->lpVtbl->ReleaseVarDesc(pTypeInfo, pVarDesc);
6475 kind =
INT2FIX(pVarDesc->varkind);
6535 if(pOwnerTypeInfo)
OLE_ADDREF(pOwnerTypeInfo);
6608 FUNCDESC *pFuncDesc;
6612 hr = pTypeInfo->lpVtbl->GetFuncDesc(pTypeInfo, method_index, &pFuncDesc);
6617 pTypeInfo->lpVtbl->ReleaseFuncDesc(pTypeInfo, pFuncDesc);
6642 FUNCDESC *pFuncDesc;
6646 hr = pTypeInfo->lpVtbl->GetFuncDesc(pTypeInfo, method_index, &pFuncDesc);
6650 vvt =
INT2FIX(pFuncDesc->elemdescFunc.tdesc.vt);
6651 pTypeInfo->lpVtbl->ReleaseFuncDesc(pTypeInfo, pFuncDesc);
6676 FUNCDESC *pFuncDesc;
6680 hr = pTypeInfo->lpVtbl->GetFuncDesc(pTypeInfo, method_index, &pFuncDesc);
6685 pTypeInfo->lpVtbl->ReleaseFuncDesc(pTypeInfo, pFuncDesc);
6710 FUNCDESC *pFuncDesc;
6713 hr = pTypeInfo->lpVtbl->GetFuncDesc(pTypeInfo, method_index, &pFuncDesc);
6716 invkind =
INT2FIX(pFuncDesc->invkind);
6717 pTypeInfo->lpVtbl->ReleaseFuncDesc(pTypeInfo, pFuncDesc);
6726 if((
FIX2INT(invkind) & INVOKE_PROPERTYGET) &&
6727 (
FIX2INT(invkind) & INVOKE_PROPERTYPUT) ) {
6729 }
else if(
FIX2INT(invkind) & INVOKE_PROPERTYGET) {
6731 }
else if(
FIX2INT(invkind) & INVOKE_PROPERTYPUT) {
6733 }
else if(
FIX2INT(invkind) & INVOKE_PROPERTYPUTREF) {
6735 }
else if(
FIX2INT(invkind) & INVOKE_FUNC) {
6781 FUNCDESC *pFuncDesc;
6784 hr = pTypeInfo->lpVtbl->GetFuncDesc(pTypeInfo, method_index, &pFuncDesc);
6787 if (pFuncDesc->wFuncFlags & (FUNCFLAG_FRESTRICTED |
6789 FUNCFLAG_FNONBROWSABLE)) {
6794 pTypeInfo->lpVtbl->ReleaseFuncDesc(pTypeInfo, pFuncDesc);
6818 TYPEATTR *pTypeAttr;
6823 ITypeInfo *pRefTypeInfo;
6824 FUNCDESC *pFuncDesc;
6832 if(pTypeAttr->typekind != TKIND_COCLASS) {
6833 pTypeInfo->lpVtbl->ReleaseTypeAttr(pTypeInfo, pTypeAttr);
6836 for (i = 0; i < pTypeAttr->cImplTypes; i++) {
6837 hr = pTypeInfo->lpVtbl->GetImplTypeFlags(pTypeInfo, i, &flags);
6841 if (flags & IMPLTYPEFLAG_FSOURCE) {
6842 hr = pTypeInfo->lpVtbl->GetRefTypeOfImplType(pTypeInfo,
6846 hr = pTypeInfo->lpVtbl->GetRefTypeInfo(pTypeInfo,
6847 href, &pRefTypeInfo);
6850 hr = pRefTypeInfo->lpVtbl->GetFuncDesc(pRefTypeInfo, method_index,
6857 hr = pRefTypeInfo->lpVtbl->GetDocumentation(pRefTypeInfo,
6861 pRefTypeInfo->lpVtbl->ReleaseFuncDesc(pRefTypeInfo, pFuncDesc);
6867 pRefTypeInfo->lpVtbl->ReleaseFuncDesc(pRefTypeInfo, pFuncDesc);
6935 FUNCDESC *pFuncDesc;
6937 hr = pTypeInfo->lpVtbl->GetFuncDesc(pTypeInfo, method_index, &pFuncDesc);
6940 hr = pTypeInfo->lpVtbl->GetDocumentation(pTypeInfo, pFuncDesc->memid,
6942 helpcontext, helpfile);
6943 pTypeInfo->lpVtbl->ReleaseFuncDesc(pTypeInfo, pFuncDesc);
7013 DWORD helpcontext = 0;
7015 &helpcontext,
NULL);
7041 FUNCDESC *pFuncDesc;
7044 hr = pTypeInfo->lpVtbl->GetFuncDesc(pTypeInfo, method_index, &pFuncDesc);
7047 dispid =
INT2NUM(pFuncDesc->memid);
7048 pTypeInfo->lpVtbl->ReleaseFuncDesc(pTypeInfo, pFuncDesc);
7072 FUNCDESC *pFuncDesc;
7075 hr = pTypeInfo->lpVtbl->GetFuncDesc(pTypeInfo, method_index, &pFuncDesc);
7078 offset_vtbl =
INT2FIX(pFuncDesc->oVft);
7079 pTypeInfo->lpVtbl->ReleaseFuncDesc(pTypeInfo, pFuncDesc);
7103 FUNCDESC *pFuncDesc;
7106 hr = pTypeInfo->lpVtbl->GetFuncDesc(pTypeInfo, method_index, &pFuncDesc);
7109 size_params =
INT2FIX(pFuncDesc->cParams);
7110 pTypeInfo->lpVtbl->ReleaseFuncDesc(pTypeInfo, pFuncDesc);
7135 FUNCDESC *pFuncDesc;
7138 hr = pTypeInfo->lpVtbl->GetFuncDesc(pTypeInfo, method_index, &pFuncDesc);
7140 return size_opt_params;
7141 size_opt_params =
INT2FIX(pFuncDesc->cParamsOpt);
7142 pTypeInfo->lpVtbl->ReleaseFuncDesc(pTypeInfo, pFuncDesc);
7143 return size_opt_params;
7166 FUNCDESC *pFuncDesc;
7173 hr = pTypeInfo->lpVtbl->GetFuncDesc(pTypeInfo, method_index, &pFuncDesc);
7178 bstrs =
ALLOCA_N(BSTR, pFuncDesc->cParams + 1);
7179 hr = pTypeInfo->lpVtbl->GetNames(pTypeInfo, pFuncDesc->memid,
7180 bstrs, pFuncDesc->cParams + 1,
7183 pTypeInfo->lpVtbl->ReleaseFuncDesc(pTypeInfo, pFuncDesc);
7186 SysFreeString(bstrs[0]);
7187 if (pFuncDesc->cParams > 0) {
7188 for(i = 1; i <
len; i++) {
7194 pparam->
index = i - 1;
7199 pTypeInfo->lpVtbl->ReleaseFuncDesc(pTypeInfo, pFuncDesc);
7259 FUNCDESC *pFuncDesc;
7264 hr = pTypeInfo->lpVtbl->GetFuncDesc(pTypeInfo, method_index, &pFuncDesc);
7269 bstrs =
ALLOCA_N(BSTR, pFuncDesc->cParams + 1);
7270 hr = pTypeInfo->lpVtbl->GetNames(pTypeInfo, pFuncDesc->memid,
7271 bstrs, pFuncDesc->cParams + 1,
7274 pTypeInfo->lpVtbl->ReleaseFuncDesc(pTypeInfo, pFuncDesc);
7277 SysFreeString(bstrs[0]);
7278 if (param_index < 1 || len <= (UINT)param_index)
7280 pTypeInfo->lpVtbl->ReleaseFuncDesc(pTypeInfo, pFuncDesc);
7288 pparam->
index = param_index - 1;
7291 pTypeInfo->lpVtbl->ReleaseFuncDesc(pTypeInfo, pFuncDesc);
7331 FUNCDESC *pFuncDesc;
7334 hr = pTypeInfo->lpVtbl->GetFuncDesc(pTypeInfo, method_index, &pFuncDesc);
7338 &(pFuncDesc->lprgelemdescParam[index].tdesc),
Qnil);
7339 pTypeInfo->lpVtbl->ReleaseFuncDesc(pTypeInfo, pFuncDesc);
7365 FUNCDESC *pFuncDesc;
7368 hr = pTypeInfo->lpVtbl->GetFuncDesc(pTypeInfo, method_index, &pFuncDesc);
7372 &(pFuncDesc->lprgelemdescParam[index].tdesc), typedetail);
7373 pTypeInfo->lpVtbl->ReleaseFuncDesc(pTypeInfo, pFuncDesc);
7399 FUNCDESC *pFuncDesc;
7402 hr = pTypeInfo->lpVtbl->GetFuncDesc(pTypeInfo, method_index, &pFuncDesc);
7405 if (
V_UNION1((&(pFuncDesc->lprgelemdescParam[index])), paramdesc).wParamFlags &mask)
7407 pTypeInfo->lpVtbl->ReleaseFuncDesc(pTypeInfo, pFuncDesc);
7426 pparam->
index, PARAMFLAG_FIN);
7453 pparam->
index, PARAMFLAG_FOUT);
7471 pparam->
index, PARAMFLAG_FOPT);
7490 pparam->
index, PARAMFLAG_FRETVAL);
7496 FUNCDESC *pFuncDesc;
7497 ELEMDESC *pElemDesc;
7498 PARAMDESCEX * pParamDescEx;
7501 USHORT mask = PARAMFLAG_FOPT|PARAMFLAG_FHASDEFAULT;
7503 hr = pTypeInfo->lpVtbl->GetFuncDesc(pTypeInfo, method_index, &pFuncDesc);
7506 pElemDesc = &pFuncDesc->lprgelemdescParam[
index];
7507 wParamFlags =
V_UNION1(pElemDesc, paramdesc).wParamFlags;
7508 if ((wParamFlags & mask) == mask) {
7509 pParamDescEx =
V_UNION1(pElemDesc, paramdesc).pparamdescex;
7512 pTypeInfo->lpVtbl->ReleaseFuncDesc(pTypeInfo, pFuncDesc);
7566 if (defval !=
Qnil) {
7590 if (IsEqualIID(iid, &IID_IUnknown) ||
7591 IsEqualIID(iid, &IID_IDispatch) ||
7592 IsEqualIID(iid, &((PIEVENTSINKOBJ)pEV)->m_iid)) {
7597 return E_NOINTERFACE;
7599 ((LPUNKNOWN)*ppv)->lpVtbl->AddRef((LPUNKNOWN)*ppv);
7637 return DISP_E_BADINDEX;
7641 PEVENTSINK pEventSink,
7652 return pTypeInfo->lpVtbl->GetIDsOfNames(pTypeInfo, szNames, cNames, pDispID);
7654 return DISP_E_UNKNOWNNAME;
7665 for(i = 0; i <
len; i++) {
7689 *is_default =
FALSE;
7692 for(i = 0; i <
len; i++) {
7695 if(
NIL_P(event_name)) {
7700 *is_default =
FALSE;
7711 *is_default_handler =
FALSE;
7718 *is_default_handler =
TRUE;
7744 bstrs =
ALLOCA_N(BSTR, pdispparams->cArgs + 1);
7745 hr = pTypeInfo->lpVtbl->GetNames(pTypeInfo, dispid,
7746 bstrs, pdispparams->cArgs + 1,
7751 for (i = 0; i < len - 1; i++) {
7758 pvar = &pdispparams->rgvarg[pdispparams->cArgs-i-1];
7779 for(i = 0; i <
RARRAY_LEN(ary) && (
unsigned int) i < pdispparams->cArgs; i++) {
7781 pvar = &pdispparams->rgvarg[pdispparams->cArgs-i-1];
7790 VALUE handler = parg[0];
7791 VALUE mid = parg[1];
7792 VALUE args = parg[2];
7793 return rb_apply(handler, mid, args);
7815 PEVENTSINK pEventSink,
7820 DISPPARAMS *pdispparams,
7821 VARIANT *pvarResult,
7822 EXCEPINFO *pexcepinfo,
7837 BOOL is_default_handler =
FALSE;
7851 hr = pTypeInfo->lpVtbl->GetNames(pTypeInfo, dispid,
7864 if (handler ==
Qnil) {
7869 if (handler ==
Qnil || mid ==
Qnil) {
7874 if (is_default_handler) {
7879 for (i = 0; i < pdispparams->cArgs; ++
i) {
7880 pvar = &pdispparams->rgvarg[pdispparams->cArgs-i-1];
7884 if (is_outarg ==
Qtrue) {
7911 VariantInit(pvarResult);
7921 if (!g_IsEventSinkVtblInitialized) {
7924 vtEventSink.Release = EVENTSINK_Release;
7930 g_IsEventSinkVtblInitialized =
TRUE;
7942 PIEVENTSINKOBJ pEVObj
7944 if(pEVObj !=
NULL) {
7955 IDispatch *pDispatch;
7958 TYPEATTR *pTypeAttr;
7960 ITypeInfo *pImplTypeInfo;
7961 TYPEATTR *pImplTypeAttr;
7970 BOOL is_found =
FALSE;
7977 hr = pDispatch->lpVtbl->GetTypeInfo(pDispatch, 0, lcid, &pTypeInfo);
7981 hr = pTypeInfo->lpVtbl->GetContainingTypeLib(pTypeInfo,
7989 hr = pTypeLib->lpVtbl->GetTypeInfoOfGuid(pTypeLib,
7995 count = pTypeLib->lpVtbl->GetTypeInfoCount(pTypeLib);
7996 for (index = 0; index <
count; index++) {
7997 hr = pTypeLib->lpVtbl->GetTypeInfo(pTypeLib,
8008 if(pTypeAttr->typekind == TKIND_COCLASS) {
8009 for (type = 0; type < pTypeAttr->cImplTypes; type++) {
8010 hr = pTypeInfo->lpVtbl->GetRefTypeOfImplType(pTypeInfo,
8015 hr = pTypeInfo->lpVtbl->GetRefTypeInfo(pTypeInfo,
8021 hr = pImplTypeInfo->lpVtbl->GetDocumentation(pImplTypeInfo,
8030 if (strcmp(pitf, pstr) == 0) {
8031 hr = pImplTypeInfo->lpVtbl->GetTypeAttr(pImplTypeInfo,
8033 if (SUCCEEDED(hr)) {
8035 *piid = pImplTypeAttr->guid;
8037 *ppTypeInfo = pImplTypeInfo;
8038 (*ppTypeInfo)->lpVtbl->AddRef((*ppTypeInfo));
8040 pImplTypeInfo->lpVtbl->ReleaseTypeAttr(pImplTypeInfo,
8046 if (is_found || FAILED(hr))
8053 if (is_found || FAILED(hr))
8058 return E_NOINTERFACE;
8064 ITypeInfo *pTypeInfo,
8065 TYPEATTR *pTypeAttr,
8066 ITypeInfo **pCOTypeInfo,
8067 TYPEATTR **pCOTypeAttr)
8073 ITypeInfo *pTypeInfo2;
8074 TYPEATTR *pTypeAttr2;
8078 ITypeInfo *pRefTypeInfo;
8079 TYPEATTR *pRefTypeAttr;
8081 hr = pTypeInfo->lpVtbl->GetContainingTypeLib(pTypeInfo, &pTypeLib,
NULL);
8085 count = pTypeLib->lpVtbl->GetTypeInfoCount(pTypeLib);
8086 for (i = 0; i < count && !found; i++) {
8087 hr = pTypeLib->lpVtbl->GetTypeInfo(pTypeLib, i, &pTypeInfo2);
8095 if (pTypeAttr2->typekind != TKIND_COCLASS) {
8100 for (j = 0; j < pTypeAttr2->cImplTypes && !found; j++) {
8101 hr = pTypeInfo2->lpVtbl->GetImplTypeFlags(pTypeInfo2, j, &flags);
8104 if (!(flags & IMPLTYPEFLAG_FDEFAULT))
8106 hr = pTypeInfo2->lpVtbl->GetRefTypeOfImplType(pTypeInfo2, j, &href);
8109 hr = pTypeInfo2->lpVtbl->GetRefTypeInfo(pTypeInfo2, href, &pRefTypeInfo);
8117 if (IsEqualGUID(&(pTypeAttr->guid), &(pRefTypeAttr->guid))) {
8128 *pCOTypeInfo = pTypeInfo2;
8129 *pCOTypeAttr = pTypeAttr2;
8139 ITypeInfo *pTypeInfo,
8140 TYPEATTR *pTypeAttr,
8141 ITypeInfo **ppTypeInfo)
8148 for (i = 0; i < pTypeAttr->cImplTypes; i++) {
8149 hr = pTypeInfo->lpVtbl->GetImplTypeFlags(pTypeInfo, i, &flags);
8157 if ((flags & IMPLTYPEFLAG_FDEFAULT) &&
8158 (flags & IMPLTYPEFLAG_FSOURCE)) {
8160 hr = pTypeInfo->lpVtbl->GetRefTypeOfImplType(pTypeInfo,
8164 hr = pTypeInfo->lpVtbl->GetRefTypeInfo(pTypeInfo,
8165 hRefType, ppTypeInfo);
8177 IProvideClassInfo2 *pProvideClassInfo2;
8178 IProvideClassInfo *pProvideClassInfo;
8182 ITypeInfo *pTypeInfo;
8183 ITypeInfo *pTypeInfo2 =
NULL;
8184 TYPEATTR *pTypeAttr;
8185 TYPEATTR *pTypeAttr2 =
NULL;
8191 hr = pDispatch->lpVtbl->QueryInterface(pDispatch,
8192 &IID_IProvideClassInfo2,
8194 if (SUCCEEDED(hr)) {
8195 pProvideClassInfo2 =
p;
8196 hr = pProvideClassInfo2->lpVtbl->GetGUID(pProvideClassInfo2,
8197 GUIDKIND_DEFAULT_SOURCE_DISP_IID,
8200 if (SUCCEEDED(hr)) {
8204 if (SUCCEEDED(hr)) {
8207 hr = pDispatch->lpVtbl->QueryInterface(pDispatch,
8208 &IID_IProvideClassInfo,
8210 if (SUCCEEDED(hr)) {
8211 pProvideClassInfo =
p;
8212 hr = pProvideClassInfo->lpVtbl->GetClassInfo(pProvideClassInfo,
8217 hr = pDispatch->lpVtbl->GetTypeInfo(pDispatch, 0,
cWIN32OLE_lcid, &pTypeInfo );
8230 hr =
find_coclass(pTypeInfo, pTypeAttr, &pTypeInfo2, &pTypeAttr2);
8231 if (SUCCEEDED(hr)) {
8247 hr = (*ppTypeInfo)->lpVtbl->GetTypeAttr(*ppTypeInfo, &pTypeAttr);
8248 if (SUCCEEDED(hr)) {
8249 *piid = pTypeAttr->guid;
8250 (*ppTypeInfo)->lpVtbl->ReleaseTypeAttr(*ppTypeInfo, pTypeAttr);
8291 ITypeInfo *pTypeInfo = 0;
8293 IConnectionPointContainer *pContainer;
8294 IConnectionPoint *pConnectionPoint;
8314 hr =
find_iid(ole, pitf, &iid, &pTypeInfo);
8325 hr = pDispatch->lpVtbl->QueryInterface(pDispatch,
8326 &IID_IConnectionPointContainer,
8331 "failed to query IConnectionPointContainer");
8335 hr = pContainer->lpVtbl->FindConnectionPoint(pContainer,
8345 hr = pConnectionPoint->lpVtbl->Advise(pConnectionPoint,
8519 if (
NIL_P(events)) {
8642 VariantClear(&(pvar->
realvar));
8643 VariantClear(&(pvar->
var));
8654 VariantInit(&(pvar->
var));
8655 VariantInit(&(pvar->
realvar));
8681 SAFEARRAYBOUND *psab =
NULL;
8682 SAFEARRAY *psa =
NULL;
8689 vt = (vt | VT_ARRAY);
8696 psab =
ALLOC_N(SAFEARRAYBOUND, dim);
8702 for (i = 0; i < dim; i++) {
8704 psab[
i].lLbound = 0;
8707 psa = SafeArrayCreate((VARTYPE)(vt & VT_TYPEMASK), dim, psab);
8709 if (psab)
free(psab);
8713 V_VT(&(pvar->
var)) = vt;
8714 if (vt & VT_BYREF) {
8715 V_VT(&(pvar->
realvar)) = (vt & ~VT_BYREF);
8716 V_ARRAY(&(pvar->
realvar)) = psa;
8717 V_ARRAYREF(&(pvar->
var)) = &(V_ARRAY(&(pvar->
realvar)));
8719 V_ARRAY(&(pvar->
var)) = psa;
8721 if (psab)
free(psab);
8754 if (len < 1 || len > 3) {
8763 switch (
TYPE(val)) {
8787 vt = V_VT(&pvar->
var);
8795 SAFEARRAY *psa =
NULL;
8798 if (!(V_VT(&(pvar->
var)) & VT_ARRAY)) {
8801 psa = V_ISBYREF(&(pvar->
var)) ? *V_ARRAYREF(&(pvar->
var)) : V_ARRAY(&(pvar->
var));
8805 hr = SafeArrayLock(psa);
8818 dim = SafeArrayGetDim(psa);
8819 if (dim != ary_size) {
8826 for (i = 0; i < dim; i++) {
8836 hr = SafeArrayUnlock(psa);
8873 if (!V_ISARRAY(&(pvar->
var))) {
8875 "`[]' is not available for this variant type object");
8884 VariantInit(&variant);
8885 V_VT(&variant) = (V_VT(&(pvar->
var)) & ~VT_ARRAY) | VT_BYREF;
8886 hr = SafeArrayPtrOfIndex(psa, pid, &V_BYREF(&variant));
8903 if ((vt & ~VT_BYREF) == VT_VARIANT) {
8906 if ( (vt & ~VT_BYREF) != V_VT(var)) {
8907 hr = VariantChangeTypeEx(var, var,
8954 if (!V_ISARRAY(&(pvar->
var))) {
8956 "`[]' is not available for this variant type object");
8966 vt = (V_VT(&(pvar->
var)) & ~VT_ARRAY);
8968 if ((V_VT(&var) == VT_DISPATCH && V_DISPATCH(&var) ==
NULL) ||
8969 (V_VT(&var) == VT_UNKNOWN && V_UNKNOWN(&var) ==
NULL)) {
8972 hr = SafeArrayPutElement(psa, pid, p);
8979 return argv[argc-1];
9002 vt = V_VT(&(pvar->
var));
9004 if ((vt & ~VT_BYREF) == (VT_UI1|VT_ARRAY)) {
9005 if (vt & VT_BYREF) {
9006 psa = *V_ARRAYREF(&(pvar->
var));
9008 psa = V_ARRAY(&(pvar->
var));
9013 dim = SafeArrayGetDim(psa);
9058 vt = V_VT(&(pvar->
var));
9059 if (V_ISARRAY(&(pvar->
var)) && ((vt & ~VT_BYREF) != (VT_UI1|VT_ARRAY) ||
TYPE(val) !=
T_STRING)) {
9061 "`value=' is not available for this variant type object");
9087 com_vtbl.QueryInterface = QueryInterface;
9090 com_vtbl.GetTypeInfoCount = GetTypeInfoCount;
9091 com_vtbl.GetTypeInfo = GetTypeInfo;
9092 com_vtbl.GetIDsOfNames = GetIDsOfNames;
9191 #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)
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
VALUE rb_ary_unshift(VALUE ary, VALUE item)
#define RUBY_EVENT_THREAD_END
static VALUE foletypelib_ole_types(VALUE self)
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)
const char * rb_obj_classname(VALUE)
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)
void ruby_finalize(void)
Runs the VM finalization processes.
static DWORD HTASK threadIDCaller
int st_lookup(st_table *, st_data_t, st_data_t *)
static VALUE foletypelib_minor_version(VALUE self)
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 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)
static VALUE oletype_set_member(VALUE self, ITypeInfo *pTypeInfo, VALUE name)
static VALUE foletype_default_event_sources(VALUE self)
st_table * st_init_numtable(void)
static VALUE ole_search_event(VALUE ary, VALUE ev, BOOL *is_default)
#define Data_Make_Struct(klass, type, mark, free, sval)
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_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 volatile DWORD g_ole_initialized_key
VALUE rb_const_get(VALUE, ID)
static VALUE fole_func_methods(VALUE self)
int rb_str_cmp(VALUE, VALUE)
static LCID cWIN32OLE_lcid
#define g_ole_initialized_set(val)
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)
RUBY_EXTERN VALUE rb_cTime
static VALUE fev_on_event(int argc, VALUE *argv, VALUE self)
static VALUE folevariable_varkind(VALUE self)
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)
void rb_define_alloc_func(VALUE, rb_alloc_func_t)
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 void init_enc2cp(void)
static VALUE ole_variant2val(VARIANT *pvar)
static VALUE fole_type(VALUE self)
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 ole_method_offset_vtbl(ITypeInfo *pTypeInfo, UINT method_index)
struct _Win32OLEIDispatch Win32OLEIDispatch
VALUE rb_enc_str_new(const char *, long, rb_encoding *)
VALUE rb_protect(VALUE(*proc)(VALUE), VALUE data, int *state)
VALUE rb_funcall(VALUE, ID, int,...)
Calls a method.
void rb_raise(VALUE exc, const char *fmt,...)
static VALUE folemethod_helpfile(VALUE self)
static VALUE foleparam_inspect(VALUE self)
void EVENTSINK_Destructor(PIEVENTSINKOBJ)
#define MEMCMP(p1, p2, type, n)
static VALUE ole_method_dispid(ITypeInfo *pTypeInfo, UINT method_index)
#define RETURN_ENUMERATOR(obj, argc, argv)
VALUE rb_ary_clear(VALUE ary)
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)
#define SafeStringValue(v)
static VALUE foletype_major_version(VALUE self)
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)
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 * get_ptr_of_variant(VARIANT *pvar)
VALUE rb_str_append(VALUE, VALUE)
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)
VALUE rb_ivar_get(VALUE, ID)
VALUE rb_str_concat(VALUE, VALUE)
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)
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)
unsigned long rb_event_flag_t
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)
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)
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 BOOL g_uninitialize_hooked
static VALUE foletype_ole_type(VALUE self)
static UINT g_cp_to_check
#define g_ole_initialized_init()
int st_delete(st_table *, st_data_t *, st_data_t *)
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)
static VALUE rb_float_new(double d)
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)
memset(y->frac+ix+1, 0,(y->Prec-(ix+1))*sizeof(BDIGIT))
static void unlock_safe_array(SAFEARRAY *psa)
VALUE rb_block_proc(void)
static VALUE ole_wc2vstr(LPWSTR pw, BOOL isfree)
return Data_Wrap_Struct(CLASS_OF(interp), 0, ip_free, slave)
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)
static void ole_initialize(void)
static BOOL g_lcid_installed
STDMETHOD() QueryInterface(PEVENTSINK, REFIID, LPVOID *)
#define StringValuePtr(v)
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)
static void ole_uninitialize_hook(rb_event_flag_t evflag, VALUE data, VALUE self, ID mid, VALUE klass)
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)
vsnprintf(buf, BUFSIZ, fmt, args)
static VALUE typelib_file(VALUE ole)
#define g_ole_initialized
static VALUE oletypelib_search_registry(VALUE self, VALUE typelib)
#define StringValueCStr(v)
static VALUE folemethod_helpcontext(VALUE self)
static void oletypelib_get_libattr(ITypeLib *pTypeLib, TLIBATTR **ppTLibAttr)
void rb_define_const(VALUE, const char *, VALUE)
static UINT __RPC_FAR * pctinfo
static VALUE ole_type_from_itypeinfo(ITypeInfo *pTypeInfo)
VALUE rb_str_cat2(VALUE, const char *)
VALUE rb_define_class(const char *name, VALUE super)
Defines a top-level class.
static IMessageFilter imessage_filter
void rb_ary_store(VALUE ary, long idx, VALUE val)
static IMessageFilterVtbl message_filter
static VALUE reg_get_val(HKEY hkey, const char *subkey)
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)
VALUE rb_call_super(int, const VALUE *)
static void ole_set_safe_array(long n, SAFEARRAY *psa, long *pid, long *pub, VALUE val, long dim, VARTYPE vt)
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)
static VALUE folemethod_initialize(VALUE self, VALUE oletype, VALUE method)
static VALUE hash2named_arg(VALUE pair, struct oleparam *pOp)
unsigned char buf[MIME_BUF_SIZE]
static VALUE folevariable_inspect(VALUE self)
static VALUE ole_methods_from_typeinfo(ITypeInfo *pTypeInfo, int mask)
static VALUE ole_type_guid(ITypeInfo *pTypeInfo)
#define ALLOCA_N(type, n)
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,...)
VALUE rb_eval_string(const char *)
Evaluates the given string in an isolated binding.
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_hash_aset(VALUE, VALUE, VALUE)
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 VALUE folevariant_s_allocate(VALUE klass)
static VALUE foletypelib_major_version(VALUE self)
static VALUE foletype_helpstring(VALUE self)
VALUE rb_sprintf(const char *format,...)
static VALUE evs_length(void)
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)
void rb_gc_register_mark_object(VALUE)
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_block_call(VALUE, ID, int, VALUE *, VALUE(*)(ANYARGS), VALUE)
static VALUE foleparam_initialize(VALUE self, VALUE olemethod, VALUE n)
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 void free_enc2cp(void)
static VALUE folemethod_size_params(VALUE self)
void ole_uninitialize(void)
#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
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)
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 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)
static void oletype_free(struct oletypedata *poletype)
static VALUE ole_each_sub(VALUE pEnumV)
VALUE rb_define_module_under(VALUE outer, const char *name)
static VALUE folemethod_offset_vtbl(VALUE self)
static VALUE folemethod_s_allocate(VALUE klass)
#define va_init_list(a, b)
VALUE rb_ivar_set(VALUE, ID, VALUE)
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)
VALUE rb_str_cat(VALUE, const char *, long)
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)
VALUE rb_obj_is_kind_of(VALUE, VALUE)
IUnknown COSERVERINFO MULTI_QI *typedef HWND(WINAPI FNHTMLHELP)(HWND hwndCaller
static VALUE fole_s_free(VALUE self, VALUE obj)
static DISPID REFIID LCID WORD DISPPARAMS __RPC_FAR * pDispParams
typedef HRESULT(STDAPICALLTYPE FNCOCREATEINSTANCEEX)(REFCLSID
static FNCOCREATEINSTANCEEX * gCoCreateInstanceEx
static VALUE folevariant_s_array(VALUE klass, VALUE dims, VALUE vvt)
RUBY_EXTERN VALUE rb_cObject
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)
#define Data_Get_Struct(obj, type, sval)
static VALUE foletypelib_inspect(VALUE self)
static VALUE fole_query_interface(VALUE self, VALUE str_iid)
int rb_respond_to(VALUE, ID)
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)
int st_insert(st_table *, st_data_t, st_data_t)
VALUE rb_apply(VALUE, ID, VALUE)
Calls a method.
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)
#define RSTRING_LENINT(str)
static VALUE ole_ienum_free(VALUE pEnumV)
void rb_write_error(const char *)
static VALUE foletypelib_version(VALUE self)
static void ole_freeexceptinfo(EXCEPINFO *pExInfo)
const char * rb_id2name(ID id)
VALUE rb_str_intern(VALUE)
static BOOL g_cp_installed
static DISPID REFIID LCID WORD DISPPARAMS __RPC_FAR VARIANT __RPC_FAR EXCEPINFO __RPC_FAR UINT __RPC_FAR * puArgErr
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)
void rb_mark_hash(struct st_table *)
static VALUE foletype_typekind(VALUE self)
VALUE rb_hash_aref(VALUE, VALUE)
VALUE rb_funcall2(VALUE, ID, int, const VALUE *)
Calls a method.
VALUE rb_fix2str(VALUE, int)
int rb_enc_find_index(const char *name)
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)
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
static VOID * val2variant_ptr(VALUE val, VARIANT *var, VARTYPE vt)
static VALUE oletypelib_path(VALUE guid, VALUE version)
RUBY_EXTERN VALUE rb_cData
void rb_add_event_hook(rb_event_hook_func_t func, rb_event_flag_t events, VALUE data)
static void ole_msg_loop(void)
static VALUE foleparam_s_allocate(VALUE klass)
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)
static ULONG(STDMETHODCALLTYPE AddRef)(IDispatch __RPC_FAR *This)
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)
void st_free_table(st_table *)
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 void unsigned char * cp
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)