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) {
1235 hr = OleInitialize(
NULL);
1252 while(PeekMessage(&msg,
NULL,0,0,PM_REMOVE)) {
1253 TranslateMessage(&msg);
1254 DispatchMessage(&msg);
1320 cp == CP_THREAD_ACP ||
1331 #ifndef pIMultiLanguage
1339 pw = SysAllocStringLen(
NULL, size);
1350 pw = SysAllocStringLen(
NULL, size);
1362 #ifndef pIMultiLanguage
1370 pw = SysAllocStringLen(
NULL, size);
1380 pw = SysAllocStringLen(
NULL, size - 1);
1381 MultiByteToWideChar(
cWIN32OLE_cp, 0, pm, len, pw, size);
1412 switch(V_VT(pvar)) {
1414 return &V_UI1(pvar);
1420 return &V_UI2(pvar);
1426 return &V_UI4(pvar);
1434 #if (_MSC_VER >= 1300) || defined(__CYGWIN__) || defined(__MINGW32__)
1439 return &V_UI8(pvar);
1443 return &
V_INT(pvar);
1452 return &V_DATE(pvar);
1455 return V_BSTR(pvar);
1458 return V_DISPATCH(pvar);
1461 return &V_ERROR(pvar);
1464 return &V_BOOL(pvar);
1467 return V_UNKNOWN(pvar);
1470 return &V_ARRAY(pvar);
1482 for (i = 0; i < dim; i++) {
1483 if (pid[i] > pub[i]) {
1503 if ((V_VT(&var) == VT_DISPATCH && V_DISPATCH(&var) ==
NULL) ||
1504 (V_VT(&var) == VT_UNKNOWN && V_UNKNOWN(&var) ==
NULL)) {
1507 hr = SafeArrayPutElement(psa, pid, p);
1513 if (pid[i] > pub[i]) {
1530 for (i = 0; i <
len; i++) {
1555 for (i = 0; i <
len; i++) {
1558 if (ary_len < ary_len1) {
1574 SAFEARRAYBOUND *psab =
NULL;
1575 SAFEARRAY *psa =
NULL;
1582 psab =
ALLOC_N(SAFEARRAYBOUND, dim);
1586 if(!psab || !pub || !pid) {
1588 if(psab)
free(psab);
1593 for (i = 0; i < dim; i++) {
1595 psab[
i].lLbound = 0;
1596 pub[
i] = psab[
i].cElements - 1;
1600 if ((vt & ~VT_BYREF) == VT_ARRAY) {
1601 vt = (vt | VT_VARIANT);
1603 psa = SafeArrayCreate((VARTYPE)(vt & VT_TYPEMASK), dim, psab);
1607 hr = SafeArrayLock(psa);
1608 if (SUCCEEDED(hr)) {
1610 hr = SafeArrayUnlock(psa);
1614 if(psab)
free(psab);
1617 if (SUCCEEDED(hr)) {
1623 SafeArrayDestroy(psa);
1636 V_VT(var) = VT_DISPATCH;
1642 VariantCopy(var, &(pvar->
var));
1647 V_VT(var) = VT_DATE;
1651 switch (
TYPE(val)) {
1656 V_VT(var) = VT_BSTR;
1672 V_VT(var) = VT_BOOL;
1673 V_BOOL(var) = VARIANT_TRUE;
1676 V_VT(var) = VT_BOOL;
1677 V_BOOL(var) = VARIANT_FALSE;
1681 V_VT(var) = VT_ERROR;
1682 V_ERROR(var) = DISP_E_PARAMNOTFOUND;
1684 V_VT(var) = VT_EMPTY;
1688 V_VT(var) = VT_DISPATCH;
1698 if (vt == VT_VARIANT) {
1701 V_VT(var) = (vt & ~VT_BYREF);
1702 if (V_VT(var) == VT_DISPATCH) {
1703 V_DISPATCH(var) =
NULL;
1704 }
else if (V_VT(var) == VT_UNKNOWN) {
1705 V_UNKNOWN(var) =
NULL;
1710 #if (_MSC_VER >= 1300) || defined(__CYGWIN__) || defined(__MINGW32__)
1711 switch(vt & ~VT_BYREF) {
1714 V_I8(var) =
NUM2I8 (val);
1732 switch (
TYPE(val)) {
1734 if (V_VT(var) == (VT_BSTR | VT_BYREF)) {
1740 case (VT_UI1 | VT_BYREF) :
1741 *V_UI1REF(var) =
NUM2CHR(val);
1743 case (VT_I2 | VT_BYREF) :
1744 *V_I2REF(var) = (short)
NUM2INT(val);
1746 case (VT_I4 | VT_BYREF) :
1749 case (VT_R4 | VT_BYREF) :
1750 *V_R4REF(var) = (float)
NUM2INT(val);
1752 case (VT_R8 | VT_BYREF) :
1761 case (VT_I2 | VT_BYREF) :
1762 *V_I2REF(var) = (short)
NUM2INT(val);
1764 case (VT_I4 | VT_BYREF) :
1767 case (VT_R4 | VT_BYREF) :
1768 *V_R4REF(var) = (float)
NUM2DBL(val);
1770 case (VT_R8 | VT_BYREF) :
1778 if (V_VT(var) == (VT_R8 | VT_BYREF)) {
1783 if (V_VT(var) == (VT_BOOL | VT_BYREF)) {
1784 *V_BOOLREF(var) = VARIANT_TRUE;
1788 if (V_VT(var) == (VT_BOOL | VT_BYREF)) {
1789 *V_BOOLREF(var) = VARIANT_FALSE;
1801 if (vt == (VT_VARIANT|VT_BYREF)) {
1804 if (V_VT(realvar) != (vt & ~VT_BYREF)) {
1807 switch(vt & ~VT_BYREF) {
1809 V_I1REF(var) = &V_I1(realvar);
1812 V_UI1REF(var) = &V_UI1(realvar);
1815 V_I2REF(var) = &V_I2(realvar);
1821 V_I4REF(var) = &V_I4(realvar);
1824 V_UI4REF(var) = &V_UI4(realvar);
1827 V_R4REF(var) = &V_R4(realvar);
1830 V_R8REF(var) = &V_R8(realvar);
1833 #if (_MSC_VER >= 1300) || defined(__CYGWIN__) || defined(__MINGW32__)
1836 V_I8REF(var) = &V_I8(realvar);
1841 V_UI8REF(var) = &V_UI8(realvar);
1854 V_CYREF(var) = &V_CY(realvar);
1857 V_DATEREF(var) = &V_DATE(realvar);
1860 V_BSTRREF(var) = &V_BSTR(realvar);
1863 V_DISPATCHREF(var) = &V_DISPATCH(realvar);
1866 V_ERRORREF(var) = &V_ERROR(realvar);
1869 V_BOOLREF(var) = &V_BOOL(realvar);
1872 V_UNKNOWNREF(var) = &V_UNKNOWN(realvar);
1875 V_ARRAYREF(var) = &V_ARRAY(realvar);
1889 if (((vt & ~VT_BYREF) == (VT_ARRAY | VT_UI1)) &&
TYPE(val) ==
T_STRING) {
1892 SAFEARRAY *p =
NULL;
1893 SAFEARRAY *psa = SafeArrayCreateVector(VT_UI1, 0, len);
1897 hr = SafeArrayAccessData(psa, &pdest);
1898 if (SUCCEEDED(hr)) {
1900 SafeArrayUnaccessData(psa);
1901 V_VT(&(pvar->
realvar)) = (vt & ~VT_BYREF);
1902 p = V_ARRAY(&(pvar->
realvar));
1904 SafeArrayDestroy(p);
1906 V_ARRAY(&(pvar->
realvar)) = psa;
1907 if (vt & VT_BYREF) {
1908 V_VT(&(pvar->
var)) = vt;
1909 V_ARRAYREF(&(pvar->
var)) = &(V_ARRAY(&(pvar->
realvar)));
1911 hr = VariantCopy(&(pvar->
var), &(pvar->
realvar));
1915 SafeArrayDestroy(psa);
1917 }
else if (vt & VT_ARRAY) {
1919 V_VT(&(pvar->
var)) = vt;
1920 if (vt & VT_BYREF) {
1921 V_ARRAYREF(&(pvar->
var)) = &(V_ARRAY(&(pvar->
realvar)));
1925 if (SUCCEEDED(hr)) {
1926 if (vt & VT_BYREF) {
1927 V_VT(&(pvar->
var)) = vt;
1928 V_ARRAYREF(&(pvar->
var)) = &(V_ARRAY(&(pvar->
realvar)));
1930 hr = VariantCopy(&(pvar->
var), &(pvar->
realvar));
1934 #if (_MSC_VER >= 1300) || defined(__CYGWIN__) || defined(__MINGW32__)
1935 }
else if ( (vt & ~VT_BYREF) == VT_I8 || (vt & ~VT_BYREF) == VT_UI8) {
1938 V_VT(&(pvar->
var)) = vt;
1939 if (vt & VT_BYREF) {
1945 V_VT(&(pvar->
var)) = vt;
1946 if (vt == (VT_BYREF | VT_VARIANT)) {
1949 V_VT(&(pvar->
realvar)) = vt & ~VT_BYREF;
1950 if (vt & VT_BYREF) {
1956 if (vt == (VT_BYREF | VT_VARIANT)) {
1958 }
else if (vt & VT_BYREF) {
1959 if ( (vt & ~VT_BYREF) != V_VT(&(pvar->
realvar))) {
1963 if (SUCCEEDED(hr)) {
1967 if (vt == V_VT(&(pvar->
realvar))) {
1968 hr = VariantCopy(&(pvar->
var), &(pvar->
realvar));
1970 hr = VariantChangeTypeEx(&(pvar->
var), &(pvar->
realvar),
2046 long *ids =
ALLOC_N(
long, dim);
2050 for(i = 0; i < dim; i++) {
2051 ids[
i] = pid[
i] - plb[
i];
2055 for(i = 0; i < dim-1; i++) {
2069 long id = pid[dim - 1] - plb[dim - 1];
2079 while ( V_VT(pvar) == (VT_BYREF | VT_VARIANT) )
2080 pvar = V_VARIANTREF(pvar);
2082 if(V_ISARRAY(pvar)) {
2083 SAFEARRAY *psa = V_ISBYREF(pvar) ? *V_ARRAYREF(pvar) : V_ARRAY(pvar);
2085 long *pid, *plb, *pub;
2092 dim = SafeArrayGetDim(psa);
2093 VariantInit(&variant);
2094 V_VT(&variant) = (V_VT(pvar) & ~VT_ARRAY) | VT_BYREF;
2100 if(!pid || !plb || !pub) {
2107 for(i = 0; i < dim; ++
i) {
2108 SafeArrayGetLBound(psa, i+1, &plb[i]);
2109 SafeArrayGetLBound(psa, i+1, &pid[i]);
2110 SafeArrayGetUBound(psa, i+1, &pub[i]);
2112 hr = SafeArrayLock(psa);
2113 if (SUCCEEDED(hr)) {
2118 hr = SafeArrayPtrOfIndex(psa, pid, &V_BYREF(&variant));
2119 if (SUCCEEDED(hr)) {
2123 for (i = 0; i < dim; ++
i) {
2124 if (++pid[i] <= pub[i])
2129 SafeArrayUnlock(psa);
2136 switch(V_VT(pvar) & ~VT_BYREF){
2145 obj =
INT2NUM((
long)V_I1(pvar));
2150 obj =
INT2NUM((
long)*V_UI1REF(pvar));
2152 obj =
INT2NUM((
long)V_UI1(pvar));
2157 obj =
INT2NUM((
long)*V_I2REF(pvar));
2159 obj =
INT2NUM((
long)V_I2(pvar));
2166 obj =
INT2NUM((
long)V_UI2(pvar));
2171 obj =
INT2NUM((
long)*V_I4REF(pvar));
2173 obj =
INT2NUM((
long)V_I4(pvar));
2178 obj =
INT2NUM((
long)*V_UI4REF(pvar));
2180 obj =
INT2NUM((
long)V_UI4(pvar));
2197 #if (_MSC_VER >= 1300) || defined(__CYGWIN__) || defined(__MINGW32__)
2200 #if (_MSC_VER >= 1300) || defined(__CYGWIN__) || defined(__MINGW32__)
2212 #if (_MSC_VER >= 1300) || defined(__CYGWIN__) || defined(__MINGW32__)
2249 obj =
INT2NUM(*V_ERRORREF(pvar));
2255 if (V_ISBYREF(pvar))
2265 if (V_ISBYREF(pvar))
2266 pDispatch = *V_DISPATCHREF(pvar);
2268 pDispatch = V_DISPATCH(pvar);
2270 if (pDispatch !=
NULL ) {
2285 if (V_ISBYREF(pvar))
2286 punk = *V_UNKNOWNREF(pvar);
2288 punk = V_UNKNOWN(pvar);
2291 hr = punk->lpVtbl->QueryInterface(punk, &IID_IDispatch, &p);
2304 date = *V_DATEREF(pvar);
2306 date = V_DATE(pvar);
2316 VariantInit(&variant);
2317 hr = VariantChangeTypeEx(&variant, pvar,
2319 if (SUCCEEDED(hr) && V_VT(&variant) == VT_BSTR) {
2322 VariantClear(&variant);
2332 return RegOpenKeyEx(hkey, name, 0, KEY_READ, phkey);
2344 char buf[BUFSIZ + 1];
2347 LONG
err = RegEnumKeyEx(hkey, i, buf, &size_buf,
2349 if(err == ERROR_SUCCESS) {
2363 LONG
err = RegQueryValueEx(hkey, subkey,
NULL, &dwtype,
NULL, &size);
2365 if (err == ERROR_SUCCESS) {
2366 pbuf =
ALLOC_N(
char, size + 1);
2367 err = RegQueryValueEx(hkey, subkey,
NULL, &dwtype, (BYTE *)pbuf, &size);
2368 if (err == ERROR_SUCCESS) {
2370 if (dwtype == REG_EXPAND_SZ) {
2371 char* pbuf2 = (
char *)pbuf;
2373 pbuf =
ALLOC_N(
char, len + 1);
2374 ExpandEnvironmentStrings(pbuf2, pbuf, len + 1);
2390 err = RegOpenKeyEx(hkey, subkey, 0, KEY_READ, &hsubkey);
2391 if (err == ERROR_SUCCESS) {
2393 RegCloseKey(hsubkey);
2423 char path[MAX_PATH + 1];
2425 err =
reg_open_key(HKEY_CLASSES_ROOT,
"CLSID", &hroot);
2426 if (err != ERROR_SUCCESS) {
2430 if (err != ERROR_SUCCESS) {
2436 RegCloseKey(hclsid);
2437 if (typelib !=
Qnil) {
2438 ExpandEnvironmentStrings(
StringValuePtr(typelib), path,
sizeof(path));
2439 path[MAX_PATH] =
'\0';
2448 HKEY htypelib, hclsid, hversion, hlang;
2459 err =
reg_open_key(HKEY_CLASSES_ROOT,
"TypeLib", &htypelib);
2460 if(err != ERROR_SUCCESS) {
2463 for(i = 0; !found; i++) {
2468 if (err != ERROR_SUCCESS)
2471 for(j = 0; !found; j++) {
2480 if (typelib ==
Qnil)
2483 for(k = 0; !found; k++) {
2488 if (err == ERROR_SUCCESS) {
2495 RegCloseKey(hversion);
2497 RegCloseKey(hclsid);
2499 RegCloseKey(htypelib);
2519 ITypeInfo *pTypeInfo;
2520 TYPEATTR *pTypeAttr;
2530 count = pTypeLib->lpVtbl->GetTypeInfoCount(pTypeLib);
2531 for (index = 0; index <
count; index++) {
2532 hr = pTypeLib->lpVtbl->GetTypeInfo(pTypeLib, index, &pTypeInfo);
2540 for(iVar = 0; iVar < pTypeAttr->cVars; iVar++) {
2541 hr = pTypeInfo->lpVtbl->GetVarDesc(pTypeInfo, iVar, &pVarDesc);
2544 if(pVarDesc->varkind == VAR_CONST &&
2545 !(pVarDesc->wVarFlags & (VARFLAG_FHIDDEN |
2546 VARFLAG_FRESTRICTED |
2547 VARFLAG_FNONBROWSABLE))) {
2548 hr = pTypeInfo->lpVtbl->GetNames(pTypeInfo, pVarDesc->memid, &bstr,
2550 if(FAILED(hr) || len == 0 || !bstr)
2554 *pName = toupper((
int)*pName);
2562 SysFreeString(bstr);
2568 pTypeInfo->lpVtbl->ReleaseVarDesc(pTypeInfo, pVarDesc);
2570 pTypeInfo->lpVtbl->ReleaseTypeAttr(pTypeInfo, pTypeAttr);
2588 err = RegConnectRegistry(
StringValuePtr(host), HKEY_LOCAL_MACHINE, &hlm);
2589 if (err != ERROR_SUCCESS)
2590 return HRESULT_FROM_WIN32(err);
2594 err = RegOpenKeyEx(hlm,
StringValuePtr(subkey), 0, KEY_READ, &hpid);
2595 if (err != ERROR_SUCCESS)
2596 hr = HRESULT_FROM_WIN32(err);
2598 len =
sizeof(clsid);
2599 err = RegQueryValueEx(hpid,
"",
NULL, &dwtype, (BYTE *)clsid, &len);
2600 if (err == ERROR_SUCCESS && dwtype == REG_SZ) {
2602 hr = CLSIDFromString(pbuf, pclsid);
2603 SysFreeString(pbuf);
2606 hr = HRESULT_FROM_WIN32(err);
2621 COSERVERINFO serverinfo;
2623 DWORD clsctx = CLSCTX_REMOTE_SERVER;
2626 gole32 = LoadLibrary(
"OLE32");
2631 GetProcAddress(
gole32,
"CoCreateInstanceEx");
2636 hr = CLSIDFromProgID(pbuf, &clsid);
2640 hr = CLSIDFromString(pbuf, &clsid);
2641 SysFreeString(pbuf);
2644 "unknown OLE server: `%s'",
2646 memset(&serverinfo, 0,
sizeof(COSERVERINFO));
2648 memset(&multi_qi, 0,
sizeof(MULTI_QI));
2649 multi_qi.pIID = &IID_IDispatch;
2651 SysFreeString(serverinfo.pwszName);
2654 "failed to create DCOM server `%s' in `%s'",
2675 hr = CreateBindCtx(0, &pBindCtx);
2678 "failed to create bind context");
2682 hr = MkParseDisplayName(pBindCtx, pbuf, &eaten, &pMoniker);
2683 SysFreeString(pbuf);
2687 "failed to parse display name of moniker `%s'",
2690 hr = pMoniker->lpVtbl->BindToObject(pMoniker, pBindCtx,
NULL,
2691 &IID_IDispatch, &p);
2698 "failed to bind moniker `%s'",
2738 hr = CLSIDFromProgID(pBuf, &clsid);
2740 hr = CLSIDFromString(pBuf, &clsid);
2742 SysFreeString(pBuf);
2747 hr = GetActiveObject(&clsid, 0, &pUnknown);
2752 hr = pUnknown->lpVtbl->QueryInterface(pUnknown, &IID_IDispatch, &p);
2757 "failed to create WIN32OLE server `%s'",
2801 ITypeInfo *pTypeInfo;
2819 0, lcid, &pTypeInfo);
2823 hr = pTypeInfo->lpVtbl->GetContainingTypeLib(pTypeInfo, &pTypeLib, &index);
2843 hr = LoadTypeLibEx(pBuf, REGKIND_NONE, &pTypeLib);
2844 SysFreeString(pBuf);
2869 ITypeInfo *pTypeInfo;
2873 count = pTypeLib->lpVtbl->GetTypeInfoCount(pTypeLib);
2874 for (i = 0; i <
count; i++) {
2875 hr = pTypeLib->lpVtbl->GetDocumentation(pTypeLib, i,
2880 hr = pTypeLib->lpVtbl->GetTypeInfo(pTypeLib, i, &pTypeInfo);
2946 FNHTMLHELP *pfnHtmlHelp;
2950 ghhctrl = LoadLibrary(
"HHCTRL.OCX");
2953 pfnHtmlHelp = (FNHTMLHELP*)GetProcAddress(
ghhctrl,
"HtmlHelpA");
3020 static BOOL CALLBACK
3114 case LOCALE_SYSTEM_DEFAULT:
3115 case LOCALE_USER_DEFAULT:
3139 hr = CoCreateGuid(&guid);
3143 len = StringFromGUID2(&guid, bstr,
sizeof(bstr)/
sizeof(OLECHAR));
3238 rb_scan_args(argc, argv,
"11*", &svr_name, &host, &others);
3256 hr = CLSIDFromProgID(pBuf, &clsid);
3258 hr = CLSIDFromString(pBuf, &clsid);
3260 SysFreeString(pBuf);
3263 "unknown OLE server: `%s'",
3268 hr = CoCreateInstance(&clsid,
NULL, CLSCTX_INPROC_SERVER | CLSCTX_LOCAL_SERVER,
3269 &IID_IDispatch, &p);
3273 "failed to create WIN32OLE object from `%s'",
3286 index = pOp->
dp.cNamedArgs;
3294 for(i = 1; i < index + 1; i++) {
3298 for(i = 0; i <
index; i++ ) {
3299 VariantClear(&(pOp->
dp.rgvarg[i]));
3312 VariantInit(&(pOp->
dp.rgvarg[index]));
3315 pOp->
dp.cNamedArgs += 1;
3326 while (end-- > beg) {
3328 VariantClear(&realargs[end]);
3349 EXCEPINFO excepinfo;
3351 VARIANTARG* realargs =
NULL;
3352 unsigned int argErr = 0;
3354 unsigned int cNamedArgs;
3358 memset(&excepinfo, 0,
sizeof(EXCEPINFO));
3360 VariantInit(&result);
3363 op.
dp.rgdispidNamedArgs =
NULL;
3364 op.
dp.cNamedArgs = 0;
3379 DispID = DISPID_VALUE;
3385 &wcmdname, 1, lcid, &DispID);
3386 SysFreeString(wcmdname);
3389 "unknown property or method: `%s'",
3397 op.
dp.cNamedArgs = 0;
3405 op.
dp.cArgs = cNamedArgs + argc - 2;
3410 pDispID =
ALLOCA_N(DISPID, cNamedArgs + 1);
3415 op.dp.cNamedArgs + 1,
3417 for(i = 0; i < op.dp.cNamedArgs + 1; i++) {
3418 SysFreeString(op.pNamedArgs[i]);
3419 op.pNamedArgs[
i] =
NULL;
3423 for(i = 0; i < op.dp.cArgs; i++ ) {
3424 VariantClear(&op.dp.rgvarg[i]);
3427 "failed to get named argument info: `%s'",
3430 op.dp.rgdispidNamedArgs = &(pDispID[1]);
3434 op.
dp.cArgs = argc - 1;
3436 if (op.
dp.cArgs > 0) {
3443 if(op.
dp.cArgs > cNamedArgs) {
3444 realargs =
ALLOCA_N(VARIANTARG, op.
dp.cArgs-cNamedArgs+1);
3445 for(i = cNamedArgs; i < op.
dp.cArgs; i++) {
3446 n = op.
dp.cArgs - i + cNamedArgs - 1;
3447 VariantInit(&realargs[n]);
3448 VariantInit(&op.
dp.rgvarg[n]);
3452 VariantCopy(&op.
dp.rgvarg[n], &(pvar->
var));
3455 V_VT(&op.
dp.rgvarg[n]) = VT_VARIANT | VT_BYREF;
3456 V_VARIANTREF(&op.
dp.rgvarg[n]) = &realargs[
n];
3461 if (wFlags & DISPATCH_PROPERTYPUT) {
3462 if (op.
dp.cArgs == 0)
3465 op.
dp.cNamedArgs = 1;
3466 op.
dp.rgdispidNamedArgs =
ALLOCA_N( DISPID, 1 );
3467 op.
dp.rgdispidNamedArgs[0] = DISPID_PROPERTYPUT;
3471 &IID_NULL, lcid, wFlags, &op.
dp,
3472 &result, &excepinfo, &argErr);
3476 if(op.
dp.cArgs >= cNamedArgs) {
3477 for(i = cNamedArgs; i < op.
dp.cArgs; i++) {
3478 n = op.
dp.cArgs - i + cNamedArgs - 1;
3482 if (hr == DISP_E_EXCEPTION) {
3485 memset(&excepinfo, 0,
sizeof(EXCEPINFO));
3486 VariantInit(&result);
3488 &IID_NULL, lcid, wFlags,
3490 &excepinfo, &argErr);
3496 if ((hr == DISP_E_EXCEPTION || hr == DISP_E_MEMBERNOTFOUND) && DispID > 0x8000) {
3497 if (hr == DISP_E_EXCEPTION) {
3500 memset(&excepinfo, 0,
sizeof(EXCEPINFO));
3502 &IID_NULL, lcid, wFlags,
3504 &excepinfo, &argErr);
3507 for(i = cNamedArgs; i < op.
dp.cArgs; i++) {
3508 n = op.
dp.cArgs - i + cNamedArgs - 1;
3509 VariantClear(&op.
dp.rgvarg[n]);
3515 if (op.
dp.cArgs > cNamedArgs) {
3516 for(i = cNamedArgs; i < op.
dp.cArgs; i++) {
3517 n = op.
dp.cArgs - i + cNamedArgs - 1;
3521 if (hr == DISP_E_EXCEPTION) {
3524 memset(&excepinfo, 0,
sizeof(EXCEPINFO));
3525 VariantInit(&result);
3527 &IID_NULL, lcid, wFlags,
3529 &excepinfo, &argErr);
3530 for(i = cNamedArgs; i < op.
dp.cArgs; i++) {
3531 n = op.
dp.cArgs - i + cNamedArgs - 1;
3532 VariantClear(&op.
dp.rgvarg[n]);
3539 if(op.
dp.cArgs > cNamedArgs) {
3540 for(i = cNamedArgs; i < op.
dp.cArgs; i++) {
3541 n = op.
dp.cArgs - i + cNamedArgs - 1;
3550 for(i = 0; i < op.
dp.cArgs; i++) {
3551 VariantClear(&op.
dp.rgvarg[i]);
3562 VariantClear(&result);
3582 return ole_invoke(argc, argv,
self, DISPATCH_METHOD|DISPATCH_PROPERTYGET,
FALSE);
3590 unsigned int argErr = 0;
3591 EXCEPINFO excepinfo;
3593 DISPPARAMS dispParams;
3594 VARIANTARG* realargs =
NULL;
3604 memset(&excepinfo, 0,
sizeof(EXCEPINFO));
3605 memset(&dispParams, 0,
sizeof(DISPPARAMS));
3606 VariantInit(&result);
3610 dispParams.rgvarg =
ALLOCA_N(VARIANTARG, dispParams.cArgs);
3611 realargs =
ALLOCA_N(VARIANTARG, dispParams.cArgs);
3612 for (i = 0, j = dispParams.cArgs - 1; i < (
int)dispParams.cArgs; i++, j--)
3614 VariantInit(&realargs[i]);
3615 VariantInit(&dispParams.rgvarg[i]);
3618 V_VT(&dispParams.rgvarg[i]) = vt;
3623 V_VT(&dispParams.rgvarg[i]) = V_VT(&realargs[i]) = VT_ERROR;
3624 V_ERROR(&dispParams.rgvarg[i]) = V_ERROR(&realargs[i]) = DISP_E_PARAMNOTFOUND;
3637 SAFEARRAYBOUND rgsabound[1];
3639 rgsabound[0].lLbound = 0;
3641 v = vt & ~(VT_ARRAY | VT_BYREF);
3642 V_ARRAY(&realargs[i]) = SafeArrayCreate(v, 1, rgsabound);
3643 V_VT(&realargs[i]) = VT_ARRAY |
v;
3644 SafeArrayLock(V_ARRAY(&realargs[i]));
3645 pb = V_ARRAY(&realargs[i])->pvData;
3646 ps = V_ARRAY(&realargs[i])->pvData;
3647 pl = V_ARRAY(&realargs[i])->pvData;
3648 py = V_ARRAY(&realargs[i])->pvData;
3649 pv = V_ARRAY(&realargs[i])->pvData;
3650 for (ent = 0; ent < (
int)rgsabound[0].cElements; ent++)
3655 if (v != VT_VARIANT)
3657 VariantChangeTypeEx(&velem, &velem,
3670 *py++ = V_CY(&velem);
3676 *ps++ = V_I2(&velem);
3681 *pb++ = V_UI1(&velem);
3685 *pl++ = V_I4(&velem);
3689 SafeArrayUnlock(V_ARRAY(&realargs[i]));
3694 if ((vt & (~VT_BYREF)) != VT_VARIANT)
3696 hr = VariantChangeTypeEx(&realargs[i], &realargs[i],
3698 (VARTYPE)(vt & (~VT_BYREF)));
3705 if ((vt & VT_BYREF) || vt == VT_VARIANT)
3707 if (vt == VT_VARIANT)
3708 V_VT(&dispParams.rgvarg[i]) = VT_VARIANT | VT_BYREF;
3709 switch (vt & (~VT_BYREF))
3713 V_VARIANTREF(&dispParams.rgvarg[i]) = &realargs[
i];
3719 V_CYREF(&dispParams.rgvarg[i]) = &V_CY(&realargs[i]);
3725 V_I2REF(&dispParams.rgvarg[i]) = &V_I2(&realargs[i]);
3730 V_UI1REF(&dispParams.rgvarg[i]) = &V_UI1(&realargs[i]);
3734 V_I4REF(&dispParams.rgvarg[i]) = &V_I4(&realargs[i]);
3741 V_CY(&dispParams.rgvarg[i]) = V_CY(&realargs[i]);
3746 if (dispkind & DISPATCH_PROPERTYPUT) {
3747 dispParams.cNamedArgs = 1;
3748 dispParams.rgdispidNamedArgs =
ALLOCA_N( DISPID, 1 );
3749 dispParams.rgdispidNamedArgs[0] = DISPID_PROPERTYPUT;
3755 &dispParams, &result,
3756 &excepinfo, &argErr);
3766 if(dispParams.cArgs > 0) {
3767 set_argv(realargs, 0, dispParams.cArgs);
3771 VariantClear(&result);
3790 return ole_invoke2(
self, dispid, args, types, DISPATCH_METHOD);
3808 return ole_invoke2(
self, dispid, args, types, DISPATCH_PROPERTYGET);
3826 return ole_invoke2(
self, dispid, args, types, DISPATCH_PROPERTYPUT);
3901 EXCEPINFO excepinfo;
3902 DISPID dispID = DISPID_VALUE;
3903 DISPID dispIDParam = DISPID_PROPERTYPUT;
3904 USHORT wFlags = DISPATCH_PROPERTYPUT|DISPATCH_PROPERTYPUTREF;
3905 DISPPARAMS dispParams;
3906 VARIANTARG propertyValue[2];
3910 dispParams.rgdispidNamedArgs = &dispIDParam;
3911 dispParams.rgvarg = propertyValue;
3912 dispParams.cNamedArgs = 1;
3913 dispParams.cArgs = 1;
3915 VariantInit(&propertyValue[0]);
3916 VariantInit(&propertyValue[1]);
3917 memset(&excepinfo, 0,
sizeof(excepinfo));
3924 pBuf, 1, lcid, &dispID);
3925 SysFreeString(pBuf[0]);
3930 "unknown property or method: `%s'",
3936 lcid, wFlags, &dispParams,
3937 NULL, &excepinfo, &argErr);
3939 for(index = 0; index < dispParams.cArgs; ++
index) {
3940 VariantClear(&propertyValue[index]);
3976 IEnumVARIANT *pEnum = (IEnumVARIANT *)pEnumV;
3977 VariantInit(&variant);
3978 while(pEnum->lpVtbl->Next(pEnum, 1, &variant,
NULL) ==
S_OK) {
3980 VariantClear(&variant);
3981 VariantInit(&variant);
3990 IEnumVARIANT *pEnum = (IEnumVARIANT *)pEnumV;
4016 unsigned int argErr;
4017 EXCEPINFO excepinfo;
4018 DISPPARAMS dispParams;
4021 IEnumVARIANT *pEnum =
NULL;
4026 VariantInit(&result);
4027 dispParams.rgvarg =
NULL;
4028 dispParams.rgdispidNamedArgs =
NULL;
4029 dispParams.cNamedArgs = 0;
4030 dispParams.cArgs = 0;
4031 memset(&excepinfo, 0,
sizeof(excepinfo));
4036 DISPATCH_METHOD | DISPATCH_PROPERTYGET,
4037 &dispParams, &result,
4038 &excepinfo, &argErr);
4041 VariantClear(&result);
4045 if (V_VT(&result) == VT_UNKNOWN) {
4046 hr = V_UNKNOWN(&result)->lpVtbl->QueryInterface(V_UNKNOWN(&result),
4050 }
else if (V_VT(&result) == VT_DISPATCH) {
4051 hr = V_DISPATCH(&result)->lpVtbl->QueryInterface(V_DISPATCH(&result),
4056 if (FAILED(hr) || !pEnum) {
4057 VariantClear(&result);
4061 VariantClear(&result);
4084 if(mname[n-1] ==
'=') {
4091 return ole_invoke(argc, argv,
self, DISPATCH_METHOD|DISPATCH_PROPERTYGET,
FALSE);
4099 TYPEATTR *pTypeAttr;
4101 FUNCDESC *pFuncDesc;
4109 for(i = 0; i < pTypeAttr->cFuncs && method ==
Qnil; i++) {
4110 hr = pTypeInfo->lpVtbl->GetFuncDesc(pTypeInfo, i, &pFuncDesc);
4114 hr = pTypeInfo->lpVtbl->GetDocumentation(pTypeInfo, pFuncDesc->memid,
4117 pTypeInfo->lpVtbl->ReleaseFuncDesc(pTypeInfo, pFuncDesc);
4125 pTypeInfo->lpVtbl->ReleaseFuncDesc(pTypeInfo, pFuncDesc);
4136 TYPEATTR *pTypeAttr;
4139 ITypeInfo *pRefTypeInfo;
4146 if (method !=
Qnil) {
4149 for(i=0; i < pTypeAttr->cImplTypes && method ==
Qnil; i++){
4150 hr = pTypeInfo->lpVtbl->GetRefTypeOfImplType(pTypeInfo, i, &href);
4153 hr = pTypeInfo->lpVtbl->GetRefTypeInfo(pTypeInfo, href, &pRefTypeInfo);
4167 TYPEATTR *pTypeAttr;
4169 FUNCDESC *pFuncDesc;
4176 for(i = 0; i < pTypeAttr->cFuncs; i++) {
4177 hr = pTypeInfo->lpVtbl->GetFuncDesc(pTypeInfo, i, &pFuncDesc);
4181 hr = pTypeInfo->lpVtbl->GetDocumentation(pTypeInfo, pFuncDesc->memid,
4184 pTypeInfo->lpVtbl->ReleaseFuncDesc(pTypeInfo, pFuncDesc);
4187 if(pFuncDesc->invkind & mask) {
4193 pTypeInfo->lpVtbl->ReleaseFuncDesc(pTypeInfo, pFuncDesc);
4205 TYPEATTR *pTypeAttr;
4208 ITypeInfo *pRefTypeInfo;
4216 for(i=0; i < pTypeAttr->cImplTypes; i++){
4217 hr = pTypeInfo->lpVtbl->GetRefTypeOfImplType(pTypeInfo, i, &href);
4220 hr = pTypeInfo->lpVtbl->GetRefTypeInfo(pTypeInfo, href, &pRefTypeInfo);
4233 ITypeInfo *pTypeInfo;
4241 0, lcid, &pTypeInfo);
4245 hr = pTypeInfo->lpVtbl->GetDocumentation(pTypeInfo,
4250 hr = pTypeInfo->lpVtbl->GetContainingTypeLib(pTypeInfo, &pTypeLib, &i);
4255 count = pTypeLib->lpVtbl->GetTypeInfoCount(pTypeLib);
4256 for (i = 0; i <
count; i++) {
4257 hr = pTypeLib->lpVtbl->GetDocumentation(pTypeLib, i,
4260 hr = pTypeLib->lpVtbl->GetTypeInfo(pTypeLib, i, &pTypeInfo);
4261 if (SUCCEEDED(hr)) {
4274 ITypeInfo *pTypeInfo;
4304 return ole_methods(
self, INVOKE_FUNC | INVOKE_PROPERTYGET | INVOKE_PROPERTYPUT | INVOKE_PROPERTYPUTREF);
4336 return ole_methods(
self, INVOKE_PROPERTYPUT|INVOKE_PROPERTYPUTREF);
4365 hr = pTypeInfo->lpVtbl->GetContainingTypeLib( pTypeInfo, &pTypeLib, &index );
4369 hr = pTypeLib->lpVtbl->GetDocumentation( pTypeLib, index,
4392 ITypeInfo *pTypeInfo;
4420 hr = pTypeInfo->lpVtbl->GetContainingTypeLib(pTypeInfo, &pTypeLib, &index);
4445 ITypeInfo *pTypeInfo;
4451 0, lcid, &pTypeInfo);
4457 if (vtlib ==
Qnil) {
4484 hr = CLSIDFromString(pBuf, &iid);
4485 SysFreeString(pBuf);
4488 "invalid iid: `%s'",
4501 "failed to get interface `%s'",
4536 SysFreeString(wcmdname);
4547 hr = pTypeInfo->lpVtbl->GetContainingTypeLib(pTypeInfo, &pTypeLib, &i);
4552 hr = pTypeLib->lpVtbl->GetDocumentation(pTypeLib, i,
4554 helpcontext, helpfile);
4568 ITypeInfo *pRefTypeInfo;
4571 hr = pTypeInfo->lpVtbl->GetRefTypeInfo(pTypeInfo,
4583 if(typedetails !=
Qnil)
4591 TYPEDESC *p = pTypeDesc;
4594 if (p->vt == VT_PTR || p->vt == VT_SAFEARRAY) {
4606 switch(pTypeDesc->vt) {
4649 #if (_MSC_VER >= 1300) || defined(__CYGWIN__) || defined(__MINGW32__)
4671 if(typedetails !=
Qnil)
4676 if(typedetails !=
Qnil)
4682 case VT_USERDEFINED:
4684 if (typedetails !=
Qnil)
4711 if (typedetails !=
Qnil)
4730 ITypeInfo *pTypeInfo;
4773 IPersistMemory *pPersistMemory;
4780 hr = pole->
pDispatch->lpVtbl->QueryInterface(pole->
pDispatch, &IID_IPersistMemory, &p);
4782 if (SUCCEEDED(hr)) {
4783 hr = pPersistMemory->lpVtbl->InitNew(pPersistMemory);
4785 if (SUCCEEDED(hr)) {
4834 return rb_eval_string(
"WIN32OLE_TYPELIB.typelibs.collect{|t|t.name}");
4846 HKEY hclsids, hclsid;
4853 err =
reg_open_key(HKEY_CLASSES_ROOT,
"CLSID", &hclsids);
4854 if(err != ERROR_SUCCESS) {
4862 if (err != ERROR_SUCCESS)
4868 RegCloseKey(hclsid);
4870 RegCloseKey(hclsids);
4909 count = pTypeLib->lpVtbl->GetTypeInfoCount(pTypeLib);
4910 for (i = 0; i < count && found ==
Qfalse; i++) {
4911 hr = pTypeLib->lpVtbl->GetTypeInfo(pTypeLib, i, &pTypeInfo);
4914 hr = pTypeLib->lpVtbl->GetDocumentation(pTypeLib, i,
4955 hr = pTypeLib->lpVtbl->GetLibAttr(pTypeLib, ppTLibAttr);
4958 "failed to get library attribute(TLIBATTR) from ITypeLib");
4975 HKEY htypelib, hguid;
4986 err =
reg_open_key(HKEY_CLASSES_ROOT,
"TypeLib", &htypelib);
4987 if(err != ERROR_SUCCESS) {
4995 if (err != ERROR_SUCCESS)
4999 if (version ==
Qnil)
5003 if (SUCCEEDED(hr)) {
5012 RegCloseKey(htypelib);
5021 if (major ==
Qnil) {
5025 if (minor !=
Qnil) {
5036 HKEY htypelib, hguid, hversion;
5052 err =
reg_open_key(HKEY_CLASSES_ROOT,
"TypeLib", &htypelib);
5053 if(err != ERROR_SUCCESS) {
5057 if (err != ERROR_SUCCESS) {
5058 RegCloseKey(htypelib);
5061 if (version_str !=
Qnil) {
5063 if (err == ERROR_SUCCESS) {
5067 version = version_str;
5070 RegCloseKey(hversion);
5078 if (err != ERROR_SUCCESS)
5082 RegCloseKey(hversion);
5090 RegCloseKey(hversion);
5094 RegCloseKey(htypelib);
5095 if (typelib !=
Qnil) {
5097 if (SUCCEEDED(hr)) {
5108 HKEY htypelib, hguid, hversion;
5118 err =
reg_open_key(HKEY_CLASSES_ROOT,
"TypeLib", &htypelib);
5119 if(err != ERROR_SUCCESS) {
5122 for(i = 0; !found; i++) {
5127 if (err != ERROR_SUCCESS)
5129 for(j = 0; found ==
Qfalse; j++) {
5134 if (err != ERROR_SUCCESS)
5138 RegCloseKey(hversion);
5143 if (SUCCEEDED(hr)) {
5148 RegCloseKey(hversion);
5152 RegCloseKey(htypelib);
5204 if (len < 1 || len > 3) {
5218 hr = LoadTypeLibEx(pbuf, REGKIND_NONE, &pTypeLib);
5219 SysFreeString(pbuf);
5220 if (SUCCEEDED(hr)) {
5249 TLIBATTR *pTLibAttr;
5253 len = StringFromGUID2(&pTLibAttr->guid, bstr,
sizeof(bstr)/
sizeof(OLECHAR));
5257 pTypeLib->lpVtbl->ReleaseTLibAttr(pTypeLib, pTLibAttr);
5278 hr = pTypeLib->lpVtbl->GetDocumentation(pTypeLib, -1,
5300 TLIBATTR *pTLibAttr;
5307 major =
INT2NUM(pTLibAttr->wMajorVerNum);
5308 minor =
INT2NUM(pTLibAttr->wMinorVerNum);
5309 pTypeLib->lpVtbl->ReleaseTLibAttr(pTypeLib, pTLibAttr);
5325 TLIBATTR *pTLibAttr;
5331 major =
INT2NUM(pTLibAttr->wMajorVerNum);
5332 pTypeLib->lpVtbl->ReleaseTLibAttr(pTypeLib, pTLibAttr);
5348 TLIBATTR *pTLibAttr;
5353 minor =
INT2NUM(pTLibAttr->wMinorVerNum);
5354 pTypeLib->lpVtbl->ReleaseTLibAttr(pTypeLib, pTLibAttr);
5374 if (err != ERROR_SUCCESS) {
5377 for(k = 0; path ==
Qnil; k++) {
5382 if (err == ERROR_SUCCESS) {
5399 return E_UNEXPECTED;
5402 hr = LoadTypeLibEx(pBuf, REGKIND_NONE, ppTypeLib);
5403 SysFreeString(pBuf);
5419 TLIBATTR *pTLibAttr;
5428 hr = QueryPathOfRegTypeLib(&pTLibAttr->guid,
5429 pTLibAttr->wMajorVerNum,
5430 pTLibAttr->wMinorVerNum,
5434 pTypeLib->lpVtbl->ReleaseTLibAttr(pTypeLib, pTLibAttr);
5438 pTypeLib->lpVtbl->ReleaseTLibAttr(pTypeLib, pTLibAttr);
5461 TLIBATTR *pTLibAttr;
5466 if ((pTLibAttr->wLibFlags == 0) ||
5467 (pTLibAttr->wLibFlags & LIBFLAG_FRESTRICTED) ||
5468 (pTLibAttr->wLibFlags & LIBFLAG_FHIDDEN)) {
5471 pTypeLib->lpVtbl->ReleaseTLibAttr(pTypeLib, pTLibAttr);
5494 hr = pTypeLib->lpVtbl->GetDocumentation(pTypeLib, -1,
5570 hr = LoadTypeLibEx(pbuf, REGKIND_NONE, &pTypeLib);
5573 SysFreeString(pbuf);
5601 TYPEATTR *pTypeAttr;
5607 switch(pTypeAttr->typekind) {
5617 case TKIND_INTERFACE:
5620 case TKIND_DISPATCH:
5663 TYPEATTR *pTypeAttr;
5670 len = StringFromGUID2(&pTypeAttr->guid, bstr,
sizeof(bstr)/
sizeof(OLECHAR));
5698 TYPEATTR *pTypeAttr;
5704 hr = ProgIDFromCLSID(&pTypeAttr->guid, &pbuf);
5705 if (SUCCEEDED(hr)) {
5707 CoTaskMemFree(pbuf);
5734 TYPEATTR *pTypeAttr;
5739 if (pTypeAttr->wTypeFlags & (TYPEFLAG_FHIDDEN | TYPEFLAG_FRESTRICTED)) {
5768 TYPEATTR *pTypeAttr;
5773 ver =
INT2FIX(pTypeAttr->wMajorVerNum);
5798 TYPEATTR *pTypeAttr;
5803 ver =
INT2FIX(pTypeAttr->wMinorVerNum);
5828 TYPEATTR *pTypeAttr;
5833 typekind =
INT2FIX(pTypeAttr->typekind);
5887 TYPEATTR *pTypeAttr;
5892 if(pTypeAttr->typekind != TKIND_ALIAS) {
5953 &helpcontext,
NULL);
5996 ITypeInfo *pRefTypeInfo;
6000 TYPEATTR *pTypeAttr;
6008 for (i = 0; i < pTypeAttr->cImplTypes; i++) {
6009 hr = pTypeInfo->lpVtbl->GetImplTypeFlags(pTypeInfo, i, &flags);
6013 hr = pTypeInfo->lpVtbl->GetRefTypeOfImplType(pTypeInfo, i, &href);
6016 hr = pTypeInfo->lpVtbl->GetRefTypeInfo(pTypeInfo, href, &pRefTypeInfo);
6020 if ((flags & implflags) == implflags) {
6122 TYPEATTR *pTypeAttr;
6135 for(i = 0; i < pTypeAttr->cVars; i++) {
6136 hr = pTypeInfo->lpVtbl->GetVarDesc(pTypeInfo, i, &pVarDesc);
6140 hr = pTypeInfo->lpVtbl->GetNames(pTypeInfo, pVarDesc->memid, &bstr,
6142 if(FAILED(hr) || len == 0 || !bstr)
6153 pTypeInfo->lpVtbl->ReleaseVarDesc(pTypeInfo, pVarDesc);
6246 hr = pTypeInfo->lpVtbl->GetVarDesc(pTypeInfo, var_index, &pVarDesc);
6250 pTypeInfo->lpVtbl->ReleaseVarDesc(pTypeInfo, pVarDesc);
6288 hr = pTypeInfo->lpVtbl->GetVarDesc(pTypeInfo, var_index, &pVarDesc);
6292 pTypeInfo->lpVtbl->ReleaseVarDesc(pTypeInfo, pVarDesc);
6322 hr = pTypeInfo->lpVtbl->GetVarDesc(pTypeInfo, var_index, &pVarDesc);
6325 if(pVarDesc->varkind == VAR_CONST)
6327 pTypeInfo->lpVtbl->ReleaseVarDesc(pTypeInfo, pVarDesc);
6366 hr = pTypeInfo->lpVtbl->GetVarDesc(pTypeInfo, var_index, &pVarDesc);
6369 if (!(pVarDesc->wVarFlags & (VARFLAG_FHIDDEN |
6370 VARFLAG_FRESTRICTED |
6371 VARFLAG_FNONBROWSABLE))) {
6374 pTypeInfo->lpVtbl->ReleaseVarDesc(pTypeInfo, pVarDesc);
6412 hr = pTypeInfo->lpVtbl->GetVarDesc(pTypeInfo, var_index, &pVarDesc);
6415 switch(pVarDesc->varkind) {
6416 case VAR_PERINSTANCE:
6431 pTypeInfo->lpVtbl->ReleaseVarDesc(pTypeInfo, pVarDesc);
6468 hr = pTypeInfo->lpVtbl->GetVarDesc(pTypeInfo, var_index, &pVarDesc);
6471 pTypeInfo->lpVtbl->ReleaseVarDesc(pTypeInfo, pVarDesc);
6472 kind =
INT2FIX(pVarDesc->varkind);
6532 if(pOwnerTypeInfo)
OLE_ADDREF(pOwnerTypeInfo);
6605 FUNCDESC *pFuncDesc;
6609 hr = pTypeInfo->lpVtbl->GetFuncDesc(pTypeInfo, method_index, &pFuncDesc);
6614 pTypeInfo->lpVtbl->ReleaseFuncDesc(pTypeInfo, pFuncDesc);
6639 FUNCDESC *pFuncDesc;
6643 hr = pTypeInfo->lpVtbl->GetFuncDesc(pTypeInfo, method_index, &pFuncDesc);
6647 vvt =
INT2FIX(pFuncDesc->elemdescFunc.tdesc.vt);
6648 pTypeInfo->lpVtbl->ReleaseFuncDesc(pTypeInfo, pFuncDesc);
6673 FUNCDESC *pFuncDesc;
6677 hr = pTypeInfo->lpVtbl->GetFuncDesc(pTypeInfo, method_index, &pFuncDesc);
6682 pTypeInfo->lpVtbl->ReleaseFuncDesc(pTypeInfo, pFuncDesc);
6707 FUNCDESC *pFuncDesc;
6710 hr = pTypeInfo->lpVtbl->GetFuncDesc(pTypeInfo, method_index, &pFuncDesc);
6713 invkind =
INT2FIX(pFuncDesc->invkind);
6714 pTypeInfo->lpVtbl->ReleaseFuncDesc(pTypeInfo, pFuncDesc);
6723 if((
FIX2INT(invkind) & INVOKE_PROPERTYGET) &&
6724 (
FIX2INT(invkind) & INVOKE_PROPERTYPUT) ) {
6726 }
else if(
FIX2INT(invkind) & INVOKE_PROPERTYGET) {
6728 }
else if(
FIX2INT(invkind) & INVOKE_PROPERTYPUT) {
6730 }
else if(
FIX2INT(invkind) & INVOKE_PROPERTYPUTREF) {
6732 }
else if(
FIX2INT(invkind) & INVOKE_FUNC) {
6778 FUNCDESC *pFuncDesc;
6781 hr = pTypeInfo->lpVtbl->GetFuncDesc(pTypeInfo, method_index, &pFuncDesc);
6784 if (pFuncDesc->wFuncFlags & (FUNCFLAG_FRESTRICTED |
6786 FUNCFLAG_FNONBROWSABLE)) {
6791 pTypeInfo->lpVtbl->ReleaseFuncDesc(pTypeInfo, pFuncDesc);
6815 TYPEATTR *pTypeAttr;
6820 ITypeInfo *pRefTypeInfo;
6821 FUNCDESC *pFuncDesc;
6829 if(pTypeAttr->typekind != TKIND_COCLASS) {
6830 pTypeInfo->lpVtbl->ReleaseTypeAttr(pTypeInfo, pTypeAttr);
6833 for (i = 0; i < pTypeAttr->cImplTypes; i++) {
6834 hr = pTypeInfo->lpVtbl->GetImplTypeFlags(pTypeInfo, i, &flags);
6838 if (flags & IMPLTYPEFLAG_FSOURCE) {
6839 hr = pTypeInfo->lpVtbl->GetRefTypeOfImplType(pTypeInfo,
6843 hr = pTypeInfo->lpVtbl->GetRefTypeInfo(pTypeInfo,
6844 href, &pRefTypeInfo);
6847 hr = pRefTypeInfo->lpVtbl->GetFuncDesc(pRefTypeInfo, method_index,
6854 hr = pRefTypeInfo->lpVtbl->GetDocumentation(pRefTypeInfo,
6858 pRefTypeInfo->lpVtbl->ReleaseFuncDesc(pRefTypeInfo, pFuncDesc);
6864 pRefTypeInfo->lpVtbl->ReleaseFuncDesc(pRefTypeInfo, pFuncDesc);
6932 FUNCDESC *pFuncDesc;
6934 hr = pTypeInfo->lpVtbl->GetFuncDesc(pTypeInfo, method_index, &pFuncDesc);
6937 hr = pTypeInfo->lpVtbl->GetDocumentation(pTypeInfo, pFuncDesc->memid,
6939 helpcontext, helpfile);
6940 pTypeInfo->lpVtbl->ReleaseFuncDesc(pTypeInfo, pFuncDesc);
7010 DWORD helpcontext = 0;
7012 &helpcontext,
NULL);
7038 FUNCDESC *pFuncDesc;
7041 hr = pTypeInfo->lpVtbl->GetFuncDesc(pTypeInfo, method_index, &pFuncDesc);
7044 dispid =
INT2NUM(pFuncDesc->memid);
7045 pTypeInfo->lpVtbl->ReleaseFuncDesc(pTypeInfo, pFuncDesc);
7069 FUNCDESC *pFuncDesc;
7072 hr = pTypeInfo->lpVtbl->GetFuncDesc(pTypeInfo, method_index, &pFuncDesc);
7075 offset_vtbl =
INT2FIX(pFuncDesc->oVft);
7076 pTypeInfo->lpVtbl->ReleaseFuncDesc(pTypeInfo, pFuncDesc);
7100 FUNCDESC *pFuncDesc;
7103 hr = pTypeInfo->lpVtbl->GetFuncDesc(pTypeInfo, method_index, &pFuncDesc);
7106 size_params =
INT2FIX(pFuncDesc->cParams);
7107 pTypeInfo->lpVtbl->ReleaseFuncDesc(pTypeInfo, pFuncDesc);
7132 FUNCDESC *pFuncDesc;
7135 hr = pTypeInfo->lpVtbl->GetFuncDesc(pTypeInfo, method_index, &pFuncDesc);
7137 return size_opt_params;
7138 size_opt_params =
INT2FIX(pFuncDesc->cParamsOpt);
7139 pTypeInfo->lpVtbl->ReleaseFuncDesc(pTypeInfo, pFuncDesc);
7140 return size_opt_params;
7163 FUNCDESC *pFuncDesc;
7170 hr = pTypeInfo->lpVtbl->GetFuncDesc(pTypeInfo, method_index, &pFuncDesc);
7175 bstrs =
ALLOCA_N(BSTR, pFuncDesc->cParams + 1);
7176 hr = pTypeInfo->lpVtbl->GetNames(pTypeInfo, pFuncDesc->memid,
7177 bstrs, pFuncDesc->cParams + 1,
7180 pTypeInfo->lpVtbl->ReleaseFuncDesc(pTypeInfo, pFuncDesc);
7183 SysFreeString(bstrs[0]);
7184 if (pFuncDesc->cParams > 0) {
7185 for(i = 1; i <
len; i++) {
7191 pparam->
index = i - 1;
7196 pTypeInfo->lpVtbl->ReleaseFuncDesc(pTypeInfo, pFuncDesc);
7256 FUNCDESC *pFuncDesc;
7261 hr = pTypeInfo->lpVtbl->GetFuncDesc(pTypeInfo, method_index, &pFuncDesc);
7266 bstrs =
ALLOCA_N(BSTR, pFuncDesc->cParams + 1);
7267 hr = pTypeInfo->lpVtbl->GetNames(pTypeInfo, pFuncDesc->memid,
7268 bstrs, pFuncDesc->cParams + 1,
7271 pTypeInfo->lpVtbl->ReleaseFuncDesc(pTypeInfo, pFuncDesc);
7274 SysFreeString(bstrs[0]);
7275 if (param_index < 1 || len <= (UINT)param_index)
7277 pTypeInfo->lpVtbl->ReleaseFuncDesc(pTypeInfo, pFuncDesc);
7285 pparam->
index = param_index - 1;
7288 pTypeInfo->lpVtbl->ReleaseFuncDesc(pTypeInfo, pFuncDesc);
7328 FUNCDESC *pFuncDesc;
7331 hr = pTypeInfo->lpVtbl->GetFuncDesc(pTypeInfo, method_index, &pFuncDesc);
7335 &(pFuncDesc->lprgelemdescParam[index].tdesc),
Qnil);
7336 pTypeInfo->lpVtbl->ReleaseFuncDesc(pTypeInfo, pFuncDesc);
7362 FUNCDESC *pFuncDesc;
7365 hr = pTypeInfo->lpVtbl->GetFuncDesc(pTypeInfo, method_index, &pFuncDesc);
7369 &(pFuncDesc->lprgelemdescParam[index].tdesc), typedetail);
7370 pTypeInfo->lpVtbl->ReleaseFuncDesc(pTypeInfo, pFuncDesc);
7396 FUNCDESC *pFuncDesc;
7399 hr = pTypeInfo->lpVtbl->GetFuncDesc(pTypeInfo, method_index, &pFuncDesc);
7402 if (
V_UNION1((&(pFuncDesc->lprgelemdescParam[index])), paramdesc).wParamFlags &mask)
7404 pTypeInfo->lpVtbl->ReleaseFuncDesc(pTypeInfo, pFuncDesc);
7423 pparam->
index, PARAMFLAG_FIN);
7450 pparam->
index, PARAMFLAG_FOUT);
7468 pparam->
index, PARAMFLAG_FOPT);
7487 pparam->
index, PARAMFLAG_FRETVAL);
7493 FUNCDESC *pFuncDesc;
7494 ELEMDESC *pElemDesc;
7495 PARAMDESCEX * pParamDescEx;
7498 USHORT mask = PARAMFLAG_FOPT|PARAMFLAG_FHASDEFAULT;
7500 hr = pTypeInfo->lpVtbl->GetFuncDesc(pTypeInfo, method_index, &pFuncDesc);
7503 pElemDesc = &pFuncDesc->lprgelemdescParam[
index];
7504 wParamFlags =
V_UNION1(pElemDesc, paramdesc).wParamFlags;
7505 if ((wParamFlags & mask) == mask) {
7506 pParamDescEx =
V_UNION1(pElemDesc, paramdesc).pparamdescex;
7509 pTypeInfo->lpVtbl->ReleaseFuncDesc(pTypeInfo, pFuncDesc);
7563 if (defval !=
Qnil) {
7587 if (IsEqualIID(iid, &IID_IUnknown) ||
7588 IsEqualIID(iid, &IID_IDispatch) ||
7589 IsEqualIID(iid, &((PIEVENTSINKOBJ)pEV)->m_iid)) {
7594 return E_NOINTERFACE;
7596 ((LPUNKNOWN)*ppv)->lpVtbl->AddRef((LPUNKNOWN)*ppv);
7634 return DISP_E_BADINDEX;
7638 PEVENTSINK pEventSink,
7649 return pTypeInfo->lpVtbl->GetIDsOfNames(pTypeInfo, szNames, cNames, pDispID);
7651 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");
9084 com_vtbl.QueryInterface = QueryInterface;
9087 com_vtbl.GetTypeInfoCount = GetTypeInfoCount;
9088 com_vtbl.GetTypeInfo = GetTypeInfo;
9089 com_vtbl.GetIDsOfNames = GetIDsOfNames;
9188 #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
static VALUE ole_create_dcom(VALUE self, VALUE ole, VALUE host, VALUE others)
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)
void rb_exc_raise(VALUE mesg)
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)
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 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)
VALUE rb_vsprintf(const char *, va_list)
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)
VALUE rb_exc_new3(VALUE etype, VALUE str)
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)