25 #if defined(__CYGWIN__) || defined(__MINGW32__)
26 #undef IID_IMultiLanguage2
27 const IID IID_IMultiLanguage2 = {0xDCCFC164, 0x2B38, 0x11d2, {0xB7, 0xEC, 0x00, 0xC0, 0x4F, 0x8F, 0x5D, 0x9A}};
30 #define WIN32OLE_VERSION "1.8.8"
32 typedef HRESULT (STDAPICALLTYPE FNCOCREATEINSTANCEEX)
33 (REFCLSID, IUnknown*,
DWORD, COSERVERINFO*,
DWORD, MULTI_QI*);
40 #if defined(RB_THREAD_SPECIFIC) && (defined(__CYGWIN__))
42 # define g_ole_initialized_init() ((void)0)
43 # define g_ole_initialized_set(val) (g_ole_initialized = (val))
45 static volatile DWORD g_ole_initialized_key = TLS_OUT_OF_INDEXES;
46 # define g_ole_initialized (TlsGetValue(g_ole_initialized_key)!=0)
47 # define g_ole_initialized_init() (g_ole_initialized_key = TlsAlloc())
48 # define g_ole_initialized_set(val) TlsSetValue(g_ole_initialized_key, (void*)(val))
51 static BOOL g_uninitialize_hooked =
FALSE;
52 static BOOL g_cp_installed =
FALSE;
53 static BOOL g_lcid_installed =
FALSE;
54 static BOOL g_running_nano =
FALSE;
55 static HINSTANCE ghhctrl =
NULL;
56 static HINSTANCE gole32 =
NULL;
57 static FNCOCREATEINSTANCEEX *gCoCreateInstanceEx =
NULL;
58 static VALUE com_hash;
59 static VALUE enc2cp_hash;
60 static IDispatchVtbl com_vtbl;
61 static UINT cWIN32OLE_cp = CP_ACP;
63 static UINT g_cp_to_check = CP_ACP;
64 static char g_lcid_to_check[8 + 1];
65 static VARTYPE g_nil_to = VT_ERROR;
66 static IMessageFilterVtbl message_filter;
67 static IMessageFilter imessage_filter = { &message_filter };
68 static IMessageFilter* previous_filter;
70 #if defined(HAVE_TYPE_IMULTILANGUAGE2)
72 #elif defined(HAVE_TYPE_IMULTILANGUAGE)
75 #define pIMultiLanguage NULL
83 static HRESULT ( STDMETHODCALLTYPE QueryInterface )(IDispatch __RPC_FAR *, REFIID
riid,
void __RPC_FAR *__RPC_FAR *
ppvObject);
84 static ULONG ( STDMETHODCALLTYPE AddRef )(IDispatch __RPC_FAR * This);
85 static ULONG ( STDMETHODCALLTYPE Release )(IDispatch __RPC_FAR * This);
86 static HRESULT ( STDMETHODCALLTYPE GetTypeInfoCount )(IDispatch __RPC_FAR * This, UINT __RPC_FAR *
pctinfo);
87 static HRESULT ( STDMETHODCALLTYPE GetTypeInfo )(IDispatch __RPC_FAR * This, UINT
iTInfo, LCID
lcid, ITypeInfo __RPC_FAR *__RPC_FAR *
ppTInfo);
90 static IDispatch* val2dispatch(
VALUE val);
91 static double rbtime2vtdate(
VALUE tmobj);
92 static VALUE vtdate2rbtime(
double date);
95 NORETURN(
static void failed_load_conv51932(
void));
96 #ifndef pIMultiLanguage
99 static UINT ole_init_cp(
void);
100 static void ole_freeexceptinfo(EXCEPINFO *pExInfo);
101 static VALUE ole_excepinfo2msg(EXCEPINFO *pExInfo);
102 static void ole_free(
void *
ptr);
103 static size_t ole_size(
const void *
ptr);
104 static LPWSTR ole_mb2wc(
char *pm,
int len, UINT cp);
105 static VALUE ole_ary_m_entry(
VALUE val, LONG *pid);
106 static VALUE is_all_index_under(LONG *pid,
long *pub,
long dim);
107 static void * get_ptr_of_variant(VARIANT *pvar);
108 static void ole_set_safe_array(
long n, SAFEARRAY *psa, LONG *pid,
long *pub,
VALUE val,
long dim, VARTYPE vt);
109 static long dimension(
VALUE val);
110 static long ary_len_of_dim(
VALUE ary,
long dim);
111 static VALUE ole_set_member(
VALUE self, IDispatch *dispatch);
114 static VALUE ary_new_dim(
VALUE myary, LONG *pid, LONG *plb, LONG dim);
115 static void ary_store_dim(
VALUE myary, LONG *pid, LONG *plb, LONG dim,
VALUE val);
116 static void ole_const_load(ITypeLib *pTypeLib,
VALUE klass,
VALUE self);
122 static ULONG reference_count(
struct oledata * pole);
127 static VALUE fole_s_get_code_page(
VALUE self);
128 static BOOL CALLBACK installed_code_page_proc(LPTSTR
str);
129 static BOOL code_page_installed(UINT cp);
132 static BOOL CALLBACK installed_lcid_proc(LPTSTR
str);
133 static BOOL lcid_installed(LCID
lcid);
136 static VALUE fole_s_ole_initialize(
VALUE self);
137 static VALUE fole_s_ole_uninitialize(
VALUE self);
140 static VALUE set_argv(VARIANTARG* realargs,
unsigned int beg,
unsigned int end);
156 static HRESULT typeinfo_from_ole(
struct oledata *pole, ITypeInfo **ppti);
166 static VALUE ole_usertype2val(ITypeInfo *pTypeInfo, TYPEDESC *pTypeDesc,
VALUE typedetails);
167 static VALUE ole_ptrtype2val(ITypeInfo *pTypeInfo, TYPEDESC *pTypeDesc,
VALUE typedetails);
169 static VALUE fole_activex_initialize(
VALUE self);
171 static void com_hash_free(
void *
ptr);
172 static void com_hash_mark(
void *
ptr);
173 static size_t com_hash_size(
const void *
ptr);
174 static void check_nano_server(
void);
178 {
NULL, ole_free, ole_size,},
184 {com_hash_mark, com_hash_free, com_hash_size,},
188 static HRESULT (STDMETHODCALLTYPE mf_QueryInterface)(
189 IMessageFilter __RPC_FAR * This,
194 ||
MEMCMP(
riid, &IID_IMessageFilter, GUID, 1) == 0)
199 return E_NOINTERFACE;
202 static ULONG (STDMETHODCALLTYPE mf_AddRef)(
203 IMessageFilter __RPC_FAR * This)
208 static ULONG (STDMETHODCALLTYPE mf_Release)(
209 IMessageFilter __RPC_FAR * This)
214 static DWORD (STDMETHODCALLTYPE mf_HandleInComingCall)(
215 IMessageFilter __RPC_FAR * pThis,
222 #ifdef DEBUG_MESSAGEFILTER
229 case CALLTYPE_TOPLEVEL_CALLPENDING:
230 case CALLTYPE_ASYNC_CALLPENDING:
232 return SERVERCALL_RETRYLATER;
238 if (previous_filter) {
239 return previous_filter->lpVtbl->HandleInComingCall(previous_filter,
245 return SERVERCALL_ISHANDLED;
248 static DWORD (STDMETHODCALLTYPE mf_RetryRejectedCall)(
249 IMessageFilter* pThis,
255 if (previous_filter) {
256 return previous_filter->lpVtbl->RetryRejectedCall(previous_filter,
264 static DWORD (STDMETHODCALLTYPE mf_MessagePending)(
265 IMessageFilter* pThis,
272 return PENDINGMSG_WAITNOPROCESS;
274 if (previous_filter) {
275 return previous_filter->lpVtbl->MessagePending(previous_filter,
280 return PENDINGMSG_WAITNOPROCESS;
290 static HRESULT ( STDMETHODCALLTYPE QueryInterface )(
291 IDispatch __RPC_FAR * This,
296 ||
MEMCMP(
riid, &IID_IDispatch, GUID, 1) == 0)
303 return E_NOINTERFACE;
306 static ULONG ( STDMETHODCALLTYPE AddRef )(
307 IDispatch __RPC_FAR * This)
313 static ULONG ( STDMETHODCALLTYPE Release )(
314 IDispatch __RPC_FAR * This)
326 static HRESULT ( STDMETHODCALLTYPE GetTypeInfoCount )(
327 IDispatch __RPC_FAR * This,
333 static HRESULT ( STDMETHODCALLTYPE GetTypeInfo )(
334 IDispatch __RPC_FAR * This,
337 ITypeInfo __RPC_FAR *__RPC_FAR *
ppTInfo)
343 static HRESULT ( STDMETHODCALLTYPE GetIDsOfNames )(
344 IDispatch __RPC_FAR * This,
362 static HRESULT ( STDMETHODCALLTYPE Invoke )(
363 IDispatch __RPC_FAR * This,
379 for (
i = 0;
i < args;
i++) {
383 if (
wFlags == DISPATCH_METHOD) {
385 }
else if (
wFlags & DISPATCH_PROPERTYGET) {
401 val2dispatch(
VALUE val)
421 rbtime2vtdate(
VALUE tmobj)
433 st.wMilliseconds = 0;
434 SystemTimeToVariantTime(&
st, &t);
443 nsec /= (24.0 * 3600.0);
449 vtdate2rbtime(
double date)
455 VariantTimeToSystemTime(date, &
st);
469 st.wMilliseconds = 0;
470 SystemTimeToVariantTime(&
st, &sec);
489 #define ENC_MACHING_CP(enc,encname,cp) if(strcasecmp(rb_enc_name((enc)),(encname)) == 0) return cp
557 failed_load_conv51932(
void)
562 #ifndef pIMultiLanguage
569 #if defined(HAVE_TYPE_IMULTILANGUAGE2)
570 hr = CoCreateInstance(&CLSID_CMultiLanguage,
NULL, CLSCTX_INPROC_SERVER,
571 &IID_IMultiLanguage2, &p);
572 #elif defined(HAVE_TYPE_IMULTILANGUAGE)
573 hr = CoCreateInstance(&CLSID_CMultiLanguage,
NULL, CLSCTX_INPROC_SERVER,
574 &IID_IMultiLanguage, &p);
577 failed_load_conv51932();
582 #define need_conv_function51932() (load_conv_function51932(), 1)
584 #define load_conv_function51932() failed_load_conv51932()
585 #define need_conv_function51932() (failed_load_conv51932(), 0)
588 #define conv_51932(cp) ((cp) == 51932 && need_conv_function51932())
591 set_ole_codepage(UINT cp)
593 if (code_page_installed(cp)) {
611 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.");
615 cWIN32OLE_enc = ole_cp2encoding(cWIN32OLE_cp);
628 cp = ole_encoding2cp(encdef);
629 set_ole_codepage(cp);
643 ole_cp2encoding(UINT cp)
651 if (!code_page_installed(cp)) {
663 GetProcAddress(GetModuleHandle(
"kernel32"),
"GetCPInfoEx");
665 pGetCPInfoEx = (
void*)-1;
670 if (pGetCPInfoEx == (
void*)-1 || !pGetCPInfoEx(cp, 0,
buf)) {
684 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.");
696 #ifndef pIMultiLanguage
698 ole_ml_wc2mb_conv0(LPWSTR pw, LPSTR pm, UINT *
size)
702 &dw, cWIN32OLE_cp, pw,
NULL, pm,
size);
704 #define ole_ml_wc2mb_conv(pw, pm, size, onfailure) do { \
705 HRESULT hr = ole_ml_wc2mb_conv0(pw, pm, &size); \
708 ole_raise(hr, eWIN32OLERuntimeError, "fail to convert Unicode to CP%d", cWIN32OLE_cp); \
713 #define ole_wc2mb_conv(pw, pm, size) WideCharToMultiByte(cWIN32OLE_cp, 0, (pw), -1, (pm), (size), NULL, NULL)
716 ole_wc2mb_alloc(LPWSTR pw,
char *(alloc)(UINT
size,
void *
arg),
void *
arg)
721 #ifndef pIMultiLanguage
722 ole_ml_wc2mb_conv(pw,
NULL,
size, {});
737 ole_alloc_str(UINT
size,
void *
arg)
745 return ole_wc2mb_alloc(pw, ole_alloc_str,
NULL);
749 ole_freeexceptinfo(EXCEPINFO *pExInfo)
751 SysFreeString(pExInfo->bstrDescription);
752 SysFreeString(pExInfo->bstrSource);
753 SysFreeString(pExInfo->bstrHelpFile);
757 ole_excepinfo2msg(EXCEPINFO *pExInfo)
760 char *pSource =
NULL;
761 char *pDescription =
NULL;
763 if(pExInfo->pfnDeferredFillIn !=
NULL) {
764 (*pExInfo->pfnDeferredFillIn)(pExInfo);
766 if (pExInfo->bstrSource !=
NULL) {
767 pSource =
ole_wc2mb(pExInfo->bstrSource);
769 if (pExInfo->bstrDescription !=
NULL) {
770 pDescription =
ole_wc2mb(pExInfo->bstrDescription);
772 if(pExInfo->wCode == 0) {
773 sprintf(error_code,
"\n OLE error code:%lX in ", (
unsigned long)pExInfo->scode);
776 sprintf(error_code,
"\n OLE error code:%u in ", pExInfo->wCode);
779 if(pSource !=
NULL) {
786 if(pDescription !=
NULL) {
792 if(pSource)
free(pSource);
793 if(pDescription)
free(pDescription);
794 ole_freeexceptinfo(pExInfo);
817 if(!g_uninitialize_hooked) {
819 g_uninitialize_hooked =
TRUE;
824 hr = CoInitializeEx(
NULL, COINIT_MULTITHREADED);
826 hr = OleInitialize(
NULL);
833 if (g_running_nano ==
FALSE) {
834 hr = CoRegisterMessageFilter(&imessage_filter, &previous_filter);
836 previous_filter =
NULL;
851 static size_t ole_size(
const void *
ptr)
885 cp = ole_encoding2cp(enc);
886 if (code_page_installed(cp) ||
890 cp == CP_THREAD_ACP ||
906 ole_mb2wc(
char *pm,
int len, UINT cp)
912 #ifndef pIMultiLanguage
923 &dw, cp, pm, &
n, pw, &
size);
930 size = MultiByteToWideChar(cp, 0, pm,
len,
NULL, 0);
933 MultiByteToWideChar(cp, 0, pm,
len, pw,
size);
938 ole_alloc_vstr(UINT
size,
void *
arg)
949 ole_wc2mb_alloc(pw, ole_alloc_vstr, &vstr);
957 ole_ary_m_entry(
VALUE val, LONG *pid)
970 is_all_index_under(LONG *pid,
long *pub,
long dim)
973 for (
i = 0;
i < dim;
i++) {
974 if (pid[
i] > pub[
i]) {
985 if (vt == VT_VARIANT) {
988 V_VT(var) = (vt & ~VT_BYREF);
989 if (V_VT(var) == VT_DISPATCH) {
990 V_DISPATCH(var) =
NULL;
991 }
else if (V_VT(var) == VT_UNKNOWN) {
992 V_UNKNOWN(var) =
NULL;
997 #if (_MSC_VER >= 1300) || defined(__CYGWIN__) || defined(__MINGW32__)
998 switch(vt & ~VT_BYREF) {
1001 V_I8(var) =
NUM2I8 (val);
1022 if ((vt & ~VT_BYREF) == VT_VARIANT) {
1025 if ( (vt & ~VT_BYREF) != V_VT(var)) {
1026 hr = VariantChangeTypeEx(var, var,
1032 p = get_ptr_of_variant(var);
1041 get_ptr_of_variant(VARIANT *pvar)
1043 switch(V_VT(pvar)) {
1045 return &V_UI1(pvar);
1051 return &V_UI2(pvar);
1057 return &V_UI4(pvar);
1065 #if (_MSC_VER >= 1300) || defined(__CYGWIN__) || defined(__MINGW32__)
1070 return &V_UI8(pvar);
1074 return &
V_INT(pvar);
1083 return &V_DATE(pvar);
1086 return V_BSTR(pvar);
1089 return V_DISPATCH(pvar);
1092 return &V_ERROR(pvar);
1095 return &V_BOOL(pvar);
1098 return V_UNKNOWN(pvar);
1101 return &V_ARRAY(pvar);
1110 ole_set_safe_array(
long n, SAFEARRAY *psa, LONG *pid,
long *pub,
VALUE val,
long dim, VARTYPE vt)
1118 val1 = ole_ary_m_entry(val, pid);
1121 if (is_all_index_under(pid, pub, dim) ==
Qtrue) {
1122 if ((V_VT(&var) == VT_DISPATCH && V_DISPATCH(&var) ==
NULL) ||
1123 (V_VT(&var) == VT_UNKNOWN && V_UNKNOWN(&var) ==
NULL)) {
1126 hr = SafeArrayPutElement(psa, pid, p);
1132 if (pid[
i] > pub[
i]) {
1142 dimension(
VALUE val) {
1149 for (
i = 0;
i <
len;
i++) {
1161 ary_len_of_dim(
VALUE ary,
long dim) {
1174 for (
i = 0;
i <
len;
i++) {
1176 ary_len1 = ary_len_of_dim(val, dim-1);
1177 if (ary_len < ary_len1) {
1193 SAFEARRAYBOUND *psab =
NULL;
1194 SAFEARRAY *psa =
NULL;
1200 dim = dimension(val);
1202 psab =
ALLOC_N(SAFEARRAYBOUND, dim);
1206 if(!psab || !pub || !pid) {
1208 if(psab)
free(psab);
1213 for (
i = 0;
i < dim;
i++) {
1214 psab[
i].cElements = ary_len_of_dim(val,
i);
1215 psab[
i].lLbound = 0;
1216 pub[
i] = psab[
i].cElements - 1;
1220 if ((vt & ~VT_BYREF) == VT_ARRAY) {
1221 vt = (vt | VT_VARIANT);
1223 psa = SafeArrayCreate((VARTYPE)(vt & VT_TYPEMASK), dim, psab);
1227 hr = SafeArrayLock(psa);
1228 if (SUCCEEDED(hr)) {
1229 ole_set_safe_array(dim-1, psa, pid, pub, val, dim, (VARTYPE)(vt & VT_TYPEMASK));
1230 hr = SafeArrayUnlock(psa);
1234 if(psab)
free(psab);
1237 if (SUCCEEDED(hr)) {
1243 SafeArrayDestroy(psa);
1255 V_VT(var) = VT_DISPATCH;
1268 V_VT(var) = VT_DATE;
1269 V_DATE(var) = rbtime2vtdate(val);
1272 switch (
TYPE(val)) {
1277 V_VT(var) = VT_BSTR;
1284 V_I4(var) = (LONG)
v;
1286 if (V_I4(var) !=
v) {
1302 V_VT(var) = VT_BOOL;
1303 V_BOOL(var) = VARIANT_TRUE;
1306 V_VT(var) = VT_BOOL;
1307 V_BOOL(var) = VARIANT_FALSE;
1310 if (g_nil_to == VT_ERROR) {
1311 V_VT(var) = VT_ERROR;
1312 V_ERROR(var) = DISP_E_PARAMNOTFOUND;
1314 V_VT(var) = VT_EMPTY;
1318 V_VT(var) = VT_DISPATCH;
1319 V_DISPATCH(var) = val2dispatch(val);
1327 g_nil_to = VT_EMPTY;
1329 g_nil_to = VT_ERROR;
1352 ole_set_member(
VALUE self, IDispatch *dispatch)
1385 ary_new_dim(
VALUE myary, LONG *pid, LONG *plb, LONG dim) {
1389 long *ids =
ALLOC_N(
long, dim);
1393 for(
i = 0;
i < dim;
i++) {
1394 ids[
i] = pid[
i] - plb[
i];
1398 for(
i = 0;
i < dim-1;
i++) {
1411 ary_store_dim(
VALUE myary, LONG *pid, LONG *plb, LONG dim,
VALUE val) {
1412 long id = pid[dim - 1] - plb[dim - 1];
1413 VALUE obj = ary_new_dim(myary, pid, plb, dim);
1421 VARTYPE vt = V_VT(pvar);
1423 while ( vt == (VT_BYREF | VT_VARIANT) ) {
1424 pvar = V_VARIANTREF(pvar);
1428 if(V_ISARRAY(pvar)) {
1429 VARTYPE vt_base = vt & VT_TYPEMASK;
1430 SAFEARRAY *psa = V_ISBYREF(pvar) ? *V_ARRAYREF(pvar) : V_ARRAY(pvar);
1432 LONG *pid, *plb, *pub;
1439 dim = SafeArrayGetDim(psa);
1444 if(!pid || !plb || !pub) {
1451 for(
i = 0;
i < dim; ++
i) {
1452 SafeArrayGetLBound(psa,
i+1, &plb[
i]);
1453 SafeArrayGetLBound(psa,
i+1, &pid[
i]);
1454 SafeArrayGetUBound(psa,
i+1, &pub[
i]);
1456 hr = SafeArrayLock(psa);
1457 if (SUCCEEDED(hr)) {
1460 VariantInit(&variant);
1461 V_VT(&variant) = vt_base | VT_BYREF;
1462 if (vt_base == VT_RECORD) {
1463 hr = SafeArrayGetRecordInfo(psa, &V_RECORDINFO(&variant));
1464 if (SUCCEEDED(hr)) {
1465 V_VT(&variant) = VT_RECORD;
1469 ary_new_dim(
obj, pid, plb, dim);
1470 if (vt_base == VT_RECORD)
1471 hr = SafeArrayPtrOfIndex(psa, pid, &V_RECORD(&variant));
1473 hr = SafeArrayPtrOfIndex(psa, pid, &V_BYREF(&variant));
1474 if (SUCCEEDED(hr)) {
1476 ary_store_dim(
obj, pid, plb, dim, val);
1478 for (
i = 0;
i < dim; ++
i) {
1479 if (++pid[
i] <= pub[
i])
1484 SafeArrayUnlock(psa);
1491 switch(V_VT(pvar) & ~VT_BYREF){
1552 #if (_MSC_VER >= 1300) || defined(__CYGWIN__) || defined(__MINGW32__)
1555 #if (_MSC_VER >= 1300) || defined(__CYGWIN__) || defined(__MINGW32__)
1567 #if (_MSC_VER >= 1300) || defined(__CYGWIN__) || defined(__MINGW32__)
1597 bstr = *V_BSTRREF(pvar);
1599 bstr = V_BSTR(pvar);
1600 obj = (SysStringLen(bstr) == 0)
1614 if (V_ISBYREF(pvar))
1624 if (V_ISBYREF(pvar))
1644 if (V_ISBYREF(pvar))
1645 punk = *V_UNKNOWNREF(pvar);
1647 punk = V_UNKNOWN(pvar);
1650 hr = punk->lpVtbl->QueryInterface(punk, &IID_IDispatch, &p);
1663 date = *V_DATEREF(pvar);
1665 date = V_DATE(pvar);
1667 obj = vtdate2rbtime(date);
1673 IRecordInfo *pri = V_RECORDINFO(pvar);
1674 void *prec = V_RECORD(pvar);
1684 VariantInit(&variant);
1685 hr = VariantChangeTypeEx(&variant, pvar,
1687 if (SUCCEEDED(hr) && V_VT(&variant) == VT_BSTR) {
1690 VariantClear(&variant);
1700 return RegOpenKeyEx(hkey,
name, 0, KEY_READ, phkey);
1715 LONG
err = RegEnumKeyEx(hkey,
i,
buf, &size_buf,
1717 if(
err == ERROR_SUCCESS) {
1733 if (
err == ERROR_SUCCESS) {
1735 err = RegQueryValueEx(hkey, subkey,
NULL, &dwtype, (BYTE *)pbuf, &
size);
1736 if (
err == ERROR_SUCCESS) {
1738 if (dwtype == REG_EXPAND_SZ) {
1739 char* pbuf2 = (
char *)pbuf;
1742 ExpandEnvironmentStrings(pbuf2, pbuf,
len + 1);
1758 err = RegOpenKeyEx(hkey, subkey, 0, KEY_READ, &hsubkey);
1759 if (
err == ERROR_SUCCESS) {
1761 RegCloseKey(hsubkey);
1775 ITypeInfo *pTypeInfo;
1776 TYPEATTR *pTypeAttr;
1786 count = pTypeLib->lpVtbl->GetTypeInfoCount(pTypeLib);
1788 hr = pTypeLib->lpVtbl->GetTypeInfo(pTypeLib,
index, &pTypeInfo);
1796 for(iVar = 0; iVar < pTypeAttr->cVars; iVar++) {
1797 hr = pTypeInfo->lpVtbl->GetVarDesc(pTypeInfo, iVar, &pVarDesc);
1800 if(pVarDesc->varkind == VAR_CONST &&
1801 !(pVarDesc->wVarFlags & (VARFLAG_FHIDDEN |
1802 VARFLAG_FRESTRICTED |
1803 VARFLAG_FNONBROWSABLE))) {
1804 hr = pTypeInfo->lpVtbl->GetNames(pTypeInfo, pVarDesc->memid, &bstr,
1806 if(FAILED(hr) ||
len == 0 || !bstr)
1810 *pName = toupper((
int)*pName);
1820 SysFreeString(bstr);
1826 pTypeInfo->lpVtbl->ReleaseVarDesc(pTypeInfo, pVarDesc);
1828 pTypeInfo->lpVtbl->ReleaseTypeAttr(pTypeInfo, pTypeAttr);
1835 clsid_from_remote(
VALUE host,
VALUE com, CLSID *pclsid)
1847 if (
err != ERROR_SUCCESS)
1848 return HRESULT_FROM_WIN32(
err);
1853 if (
err != ERROR_SUCCESS)
1854 hr = HRESULT_FROM_WIN32(
err);
1856 len =
sizeof(clsid);
1857 err = RegQueryValueEx(hpid,
"",
NULL, &dwtype, (BYTE *)clsid, &
len);
1858 if (
err == ERROR_SUCCESS && dwtype == REG_SZ) {
1859 pbuf = ole_mb2wc(clsid, -1, cWIN32OLE_cp);
1860 hr = CLSIDFromString(pbuf, pclsid);
1861 SysFreeString(pbuf);
1864 hr = HRESULT_FROM_WIN32(
err);
1879 COSERVERINFO serverinfo;
1881 DWORD clsctx = CLSCTX_REMOTE_SERVER;
1884 gole32 = LoadLibrary(
"OLE32");
1887 if (!gCoCreateInstanceEx)
1888 gCoCreateInstanceEx = (FNCOCREATEINSTANCEEX*)
1889 GetProcAddress(gole32,
"CoCreateInstanceEx");
1890 if (!gCoCreateInstanceEx)
1894 hr = CLSIDFromProgID(pbuf, &clsid);
1896 hr = clsid_from_remote(host, ole, &clsid);
1898 hr = CLSIDFromString(pbuf, &clsid);
1899 SysFreeString(pbuf);
1902 "unknown OLE server: `%s'",
1904 memset(&serverinfo, 0,
sizeof(COSERVERINFO));
1906 memset(&multi_qi, 0,
sizeof(MULTI_QI));
1907 multi_qi.pIID = &IID_IDispatch;
1908 hr = gCoCreateInstanceEx(&clsid,
NULL, clsctx, &serverinfo, 1, &multi_qi);
1909 SysFreeString(serverinfo.pwszName);
1912 "failed to create DCOM server `%s' in `%s'",
1916 ole_set_member(
self, (IDispatch*)multi_qi.pItf);
1933 hr = CreateBindCtx(0, &pBindCtx);
1936 "failed to create bind context");
1940 hr = MkParseDisplayName(pBindCtx, pbuf, &eaten, &pMoniker);
1941 SysFreeString(pbuf);
1945 "failed to parse display name of moniker `%s'",
1948 hr = pMoniker->lpVtbl->BindToObject(pMoniker, pBindCtx,
NULL,
1949 &IID_IDispatch, &p);
1956 "failed to bind moniker `%s'",
1991 hr = CLSIDFromProgID(pBuf, &clsid);
1993 hr = CLSIDFromString(pBuf, &clsid);
1995 SysFreeString(pBuf);
1997 return ole_bind_obj(svr_name,
argc,
argv,
self);
2000 hr = GetActiveObject(&clsid, 0, &pUnknown);
2005 hr = pUnknown->lpVtbl->QueryInterface(pUnknown, &IID_IDispatch, &p);
2010 "failed to create WIN32OLE server `%s'",
2054 ITypeInfo *pTypeInfo;
2071 0,
lcid, &pTypeInfo);
2075 hr = pTypeInfo->lpVtbl->GetContainingTypeLib(pTypeInfo, &pTypeLib, &
index);
2082 ole_const_load(pTypeLib,
klass,
self);
2085 ole_const_load(pTypeLib,
cWIN32OLE,
self);
2095 hr = LoadTypeLibEx(pBuf, REGKIND_NONE, &pTypeLib);
2096 SysFreeString(pBuf);
2100 ole_const_load(pTypeLib,
klass,
self);
2103 ole_const_load(pTypeLib,
cWIN32OLE,
self);
2114 reference_count(
struct oledata * pole)
2156 if (reference_count(pole) > 0) {
2164 ole_show_help(
VALUE helpfile,
VALUE helpcontext)
2166 FNHTMLHELP *pfnHtmlHelp;
2170 ghhctrl = LoadLibrary(
"HHCTRL.OCX");
2173 pfnHtmlHelp = (FNHTMLHELP*)GetProcAddress(ghhctrl,
"HtmlHelpA");
2219 hwnd = ole_show_help(helpfile, helpcontext);
2235 fole_s_get_code_page(
VALUE self)
2240 static BOOL CALLBACK
2241 installed_code_page_proc(LPTSTR
str) {
2243 g_cp_installed =
TRUE;
2250 code_page_installed(UINT cp)
2252 g_cp_installed =
FALSE;
2254 EnumSystemCodePages(installed_code_page_proc, CP_INSTALLED);
2255 return g_cp_installed;
2275 set_ole_codepage(cp);
2292 fole_s_get_locale(
VALUE self)
2298 CALLBACK installed_lcid_proc(LPTSTR
str)
2300 if (
strcmp(
str, g_lcid_to_check) == 0) {
2301 g_lcid_installed =
TRUE;
2308 lcid_installed(LCID
lcid)
2310 g_lcid_installed =
FALSE;
2311 snprintf(g_lcid_to_check,
sizeof(g_lcid_to_check),
"%08lx", (
unsigned long)
lcid);
2312 EnumSystemLocales(installed_lcid_proc, LCID_INSTALLED);
2313 return g_lcid_installed;
2330 if (lcid_installed(
lcid)) {
2334 case LOCALE_SYSTEM_DEFAULT:
2335 case LOCALE_USER_DEFAULT:
2353 fole_s_create_guid(
VALUE self)
2359 hr = CoCreateGuid(&guid);
2363 len = StringFromGUID2(&guid, bstr,
sizeof(bstr)/
sizeof(OLECHAR));
2378 fole_s_ole_initialize(
VALUE self)
2386 fole_s_ole_uninitialize(
VALUE self)
2468 IClassFactory2 * pIClassFactory2;
2470 static ID keyword_ids[1];
2479 return ole_create_dcom(
self, svr_name, host, others);
2484 hr = CLSIDFromProgID(pBuf, &clsid);
2486 hr = CLSIDFromString(pBuf, &clsid);
2488 SysFreeString(pBuf);
2491 "unknown OLE server: `%s'",
2495 if (!keyword_ids[0]) {
2500 if (kwargs[0] ==
Qundef) {
2502 hr = CoCreateInstance(
2505 CLSCTX_INPROC_SERVER | CLSCTX_LOCAL_SERVER,
2510 hr = CoGetClassObject(
2512 CLSCTX_INPROC_SERVER | CLSCTX_LOCAL_SERVER,
2514 &IID_IClassFactory2,
2515 (LPVOID)&pIClassFactory2
2519 hr = pIClassFactory2->lpVtbl->CreateInstanceLic(pIClassFactory2,
NULL,
NULL, &IID_IDispatch, key_buf, &p);
2520 SysFreeString(key_buf);
2527 "failed to create WIN32OLE object from `%s'",
2551 VariantClear(&(pOp->
dp.rgvarg[
i]));
2563 VariantInit(&(pOp->
dp.rgvarg[
index]));
2566 pOp->
dp.cNamedArgs += 1;
2571 set_argv(VARIANTARG* realargs,
unsigned int beg,
unsigned int end)
2577 while (end-- > beg) {
2579 if (V_VT(&realargs[end]) != VT_RECORD) {
2580 VariantClear(&realargs[end]);
2602 EXCEPINFO excepinfo;
2604 VARIANTARG* realargs =
NULL;
2605 unsigned int argErr = 0;
2607 unsigned int cNamedArgs;
2610 memset(&excepinfo, 0,
sizeof(EXCEPINFO));
2612 VariantInit(&result);
2614 op.dp.rgvarg =
NULL;
2615 op.dp.rgdispidNamedArgs =
NULL;
2616 op.dp.cNamedArgs = 0;
2631 DispID = DISPID_VALUE;
2637 &wcmdname, 1,
lcid, &DispID);
2638 SysFreeString(wcmdname);
2647 op.dp.cNamedArgs = 0;
2655 op.dp.cArgs = cNamedArgs +
argc - 2;
2656 op.pNamedArgs =
ALLOCA_N(OLECHAR*, cNamedArgs + 1);
2657 op.dp.rgvarg =
ALLOCA_N(VARIANTARG, op.dp.cArgs);
2661 pDispID =
ALLOCA_N(DISPID, cNamedArgs + 1);
2666 op.dp.cNamedArgs + 1,
2668 for(
i = 0;
i < op.dp.cNamedArgs + 1;
i++) {
2669 SysFreeString(op.pNamedArgs[
i]);
2670 op.pNamedArgs[
i] =
NULL;
2674 for(
i = 0;
i < op.dp.cArgs;
i++ ) {
2675 VariantClear(&op.dp.rgvarg[
i]);
2678 "failed to get named argument info: `%s'",
2681 op.dp.rgdispidNamedArgs = &(pDispID[1]);
2685 op.dp.cArgs =
argc - 1;
2686 op.pNamedArgs =
ALLOCA_N(OLECHAR*, cNamedArgs + 1);
2687 if (op.dp.cArgs > 0) {
2688 op.dp.rgvarg =
ALLOCA_N(VARIANTARG, op.dp.cArgs);
2694 if(op.dp.cArgs > cNamedArgs) {
2695 realargs =
ALLOCA_N(VARIANTARG, op.dp.cArgs-cNamedArgs+1);
2696 for(
i = cNamedArgs;
i < op.dp.cArgs;
i++) {
2697 n = op.dp.cArgs -
i + cNamedArgs - 1;
2698 VariantInit(&realargs[
n]);
2699 VariantInit(&op.dp.rgvarg[
n]);
2705 op.dp.rgvarg[
n] = realargs[
n];
2706 V_VT(&op.dp.rgvarg[
n]) = VT_RECORD | VT_BYREF;
2709 V_VT(&op.dp.rgvarg[
n]) = VT_VARIANT | VT_BYREF;
2710 V_VARIANTREF(&op.dp.rgvarg[
n]) = &realargs[
n];
2715 if (
wFlags & DISPATCH_PROPERTYPUT) {
2716 if (op.dp.cArgs == 0)
2719 op.dp.cNamedArgs = 1;
2720 op.dp.rgdispidNamedArgs =
ALLOCA_N( DISPID, 1 );
2721 op.dp.rgdispidNamedArgs[0] = DISPID_PROPERTYPUT;
2725 &result, &excepinfo, &argErr);
2729 if(op.dp.cArgs >= cNamedArgs) {
2730 for(
i = cNamedArgs;
i < op.dp.cArgs;
i++) {
2731 n = op.dp.cArgs -
i + cNamedArgs - 1;
2735 if (hr == DISP_E_EXCEPTION) {
2736 ole_freeexceptinfo(&excepinfo);
2738 memset(&excepinfo, 0,
sizeof(EXCEPINFO));
2739 VariantInit(&result);
2743 &excepinfo, &argErr);
2749 if ((hr == DISP_E_EXCEPTION || hr == DISP_E_MEMBERNOTFOUND) && DispID > 0x8000) {
2750 if (hr == DISP_E_EXCEPTION) {
2751 ole_freeexceptinfo(&excepinfo);
2753 memset(&excepinfo, 0,
sizeof(EXCEPINFO));
2757 &excepinfo, &argErr);
2760 for(
i = cNamedArgs;
i < op.dp.cArgs;
i++) {
2761 n = op.dp.cArgs -
i + cNamedArgs - 1;
2762 if (V_VT(&op.dp.rgvarg[
n]) != VT_RECORD) {
2763 VariantClear(&op.dp.rgvarg[
n]);
2770 if (op.dp.cArgs > cNamedArgs) {
2771 for(
i = cNamedArgs;
i < op.dp.cArgs;
i++) {
2772 n = op.dp.cArgs -
i + cNamedArgs - 1;
2776 if (hr == DISP_E_EXCEPTION) {
2777 ole_freeexceptinfo(&excepinfo);
2779 memset(&excepinfo, 0,
sizeof(EXCEPINFO));
2780 VariantInit(&result);
2784 &excepinfo, &argErr);
2785 for(
i = cNamedArgs;
i < op.dp.cArgs;
i++) {
2786 n = op.dp.cArgs -
i + cNamedArgs - 1;
2787 if (V_VT(&op.dp.rgvarg[
n]) != VT_RECORD) {
2788 VariantClear(&op.dp.rgvarg[
n]);
2796 if(op.dp.cArgs > cNamedArgs) {
2797 for(
i = cNamedArgs;
i < op.dp.cArgs;
i++) {
2798 n = op.dp.cArgs -
i + cNamedArgs - 1;
2803 V_VT(&realargs[
n]) == VT_RECORD ) {
2807 set_argv(realargs, cNamedArgs, op.dp.cArgs);
2810 for(
i = 0;
i < op.dp.cArgs;
i++) {
2811 VariantClear(&op.dp.rgvarg[
i]);
2816 v = ole_excepinfo2msg(&excepinfo);
2822 VariantClear(&result);
2854 unsigned int argErr = 0;
2855 EXCEPINFO excepinfo;
2857 DISPPARAMS dispParams;
2858 VARIANTARG* realargs =
NULL;
2867 memset(&excepinfo, 0,
sizeof(EXCEPINFO));
2868 memset(&dispParams, 0,
sizeof(DISPPARAMS));
2869 VariantInit(&result);
2873 dispParams.rgvarg =
ALLOCA_N(VARIANTARG, dispParams.cArgs);
2874 realargs =
ALLOCA_N(VARIANTARG, dispParams.cArgs);
2875 for (
i = 0, j = dispParams.cArgs - 1;
i < (
int)dispParams.cArgs;
i++, j--)
2877 VariantInit(&realargs[
i]);
2878 VariantInit(&dispParams.rgvarg[
i]);
2881 V_VT(&dispParams.rgvarg[
i]) = vt;
2886 V_VT(&dispParams.rgvarg[
i]) = V_VT(&realargs[
i]) = VT_ERROR;
2887 V_ERROR(&dispParams.rgvarg[
i]) = V_ERROR(&realargs[
i]) = DISP_E_PARAMNOTFOUND;
2900 SAFEARRAYBOUND rgsabound[1];
2902 rgsabound[0].lLbound = 0;
2904 v = vt & ~(VT_ARRAY | VT_BYREF);
2905 V_ARRAY(&realargs[
i]) = SafeArrayCreate(
v, 1, rgsabound);
2906 V_VT(&realargs[
i]) = VT_ARRAY |
v;
2907 SafeArrayLock(V_ARRAY(&realargs[
i]));
2908 pb = V_ARRAY(&realargs[
i])->pvData;
2909 ps = V_ARRAY(&realargs[
i])->pvData;
2910 pl = V_ARRAY(&realargs[
i])->pvData;
2911 py = V_ARRAY(&realargs[
i])->pvData;
2912 pv = V_ARRAY(&realargs[
i])->pvData;
2913 for (ent = 0; ent < (
int)rgsabound[0].cElements; ent++)
2918 if (
v != VT_VARIANT)
2920 VariantChangeTypeEx(&velem, &velem,
2933 *py++ = V_CY(&velem);
2939 *ps++ = V_I2(&velem);
2944 *pb++ = V_UI1(&velem);
2948 *pl++ = V_I4(&velem);
2952 SafeArrayUnlock(V_ARRAY(&realargs[
i]));
2957 if ((vt & (~VT_BYREF)) != VT_VARIANT)
2959 hr = VariantChangeTypeEx(&realargs[
i], &realargs[
i],
2961 (VARTYPE)(vt & (~VT_BYREF)));
2968 if ((vt & VT_BYREF) || vt == VT_VARIANT)
2970 if (vt == VT_VARIANT)
2971 V_VT(&dispParams.rgvarg[
i]) = VT_VARIANT | VT_BYREF;
2972 switch (vt & (~VT_BYREF))
2976 V_VARIANTREF(&dispParams.rgvarg[
i]) = &realargs[
i];
2982 V_CYREF(&dispParams.rgvarg[
i]) = &V_CY(&realargs[
i]);
2988 V_I2REF(&dispParams.rgvarg[
i]) = &V_I2(&realargs[
i]);
2993 V_UI1REF(&dispParams.rgvarg[
i]) = &V_UI1(&realargs[
i]);
2997 V_I4REF(&dispParams.rgvarg[
i]) = &V_I4(&realargs[
i]);
3004 V_CY(&dispParams.rgvarg[
i]) = V_CY(&realargs[
i]);
3009 if (dispkind & DISPATCH_PROPERTYPUT) {
3010 dispParams.cNamedArgs = 1;
3011 dispParams.rgdispidNamedArgs =
ALLOCA_N( DISPID, 1 );
3012 dispParams.rgdispidNamedArgs[0] = DISPID_PROPERTYPUT;
3018 &dispParams, &result,
3019 &excepinfo, &argErr);
3022 v = ole_excepinfo2msg(&excepinfo);
3029 if(dispParams.cArgs > 0) {
3030 set_argv(realargs, 0, dispParams.cArgs);
3034 VariantClear(&result);
3053 return ole_invoke2(
self, dispid, args,
types, DISPATCH_METHOD);
3071 return ole_invoke2(
self, dispid, args,
types, DISPATCH_PROPERTYGET);
3089 return ole_invoke2(
self, dispid, args,
types, DISPATCH_PROPERTYPUT);
3176 EXCEPINFO excepinfo;
3177 DISPID dispID = DISPID_VALUE;
3178 DISPID dispIDParam = DISPID_PROPERTYPUT;
3179 USHORT
wFlags = DISPATCH_PROPERTYPUT|DISPATCH_PROPERTYPUTREF;
3180 DISPPARAMS dispParams;
3181 VARIANTARG propertyValue[2];
3185 dispParams.rgdispidNamedArgs = &dispIDParam;
3186 dispParams.rgvarg = propertyValue;
3187 dispParams.cNamedArgs = 1;
3188 dispParams.cArgs = 1;
3190 VariantInit(&propertyValue[0]);
3191 VariantInit(&propertyValue[1]);
3192 memset(&excepinfo, 0,
sizeof(excepinfo));
3199 pBuf, 1,
lcid, &dispID);
3200 SysFreeString(pBuf[0]);
3205 "unknown property or method: `%s'",
3212 NULL, &excepinfo, &argErr);
3215 VariantClear(&propertyValue[
index]);
3218 v = ole_excepinfo2msg(&excepinfo);
3236 fole_free(
VALUE self)
3246 ole_each_sub(
VALUE pEnumV)
3250 IEnumVARIANT *pEnum = (IEnumVARIANT *)pEnumV;
3251 VariantInit(&variant);
3252 while(pEnum->lpVtbl->Next(pEnum, 1, &variant,
NULL) == S_OK) {
3254 VariantClear(&variant);
3255 VariantInit(&variant);
3262 ole_ienum_free(
VALUE pEnumV)
3264 IEnumVARIANT *pEnum = (IEnumVARIANT *)pEnumV;
3284 fole_each(
VALUE self)
3290 unsigned int argErr;
3291 EXCEPINFO excepinfo;
3292 DISPPARAMS dispParams;
3295 IEnumVARIANT *pEnum =
NULL;
3300 VariantInit(&result);
3301 dispParams.rgvarg =
NULL;
3302 dispParams.rgdispidNamedArgs =
NULL;
3303 dispParams.cNamedArgs = 0;
3304 dispParams.cArgs = 0;
3305 memset(&excepinfo, 0,
sizeof(excepinfo));
3310 DISPATCH_METHOD | DISPATCH_PROPERTYGET,
3311 &dispParams, &result,
3312 &excepinfo, &argErr);
3315 VariantClear(&result);
3319 if (V_VT(&result) == VT_UNKNOWN) {
3320 hr = V_UNKNOWN(&result)->lpVtbl->QueryInterface(V_UNKNOWN(&result),
3324 }
else if (V_VT(&result) == VT_DISPATCH) {
3325 hr = V_DISPATCH(&result)->lpVtbl->QueryInterface(V_DISPATCH(&result),
3330 if (FAILED(hr) || !pEnum) {
3331 VariantClear(&result);
3335 VariantClear(&result);
3353 mid = org_mid =
argv[0];
3361 if(mname[
n-1] ==
'=') {
3365 return ole_propertyput(
self,
argv[0],
argv[1]);
3369 v = ole_invoke(
argc,
argv,
self, DISPATCH_METHOD|DISPATCH_PROPERTYGET,
FALSE);
3379 typeinfo_from_ole(
struct oledata *pole, ITypeInfo **ppti)
3381 ITypeInfo *pTypeInfo;
3389 0,
lcid, &pTypeInfo);
3393 hr = pTypeInfo->lpVtbl->GetDocumentation(pTypeInfo,
3398 hr = pTypeInfo->lpVtbl->GetContainingTypeLib(pTypeInfo, &pTypeLib, &
i);
3403 count = pTypeLib->lpVtbl->GetTypeInfoCount(pTypeLib);
3405 hr = pTypeLib->lpVtbl->GetDocumentation(pTypeLib,
i,
3408 hr = pTypeLib->lpVtbl->GetTypeInfo(pTypeLib,
i, &pTypeInfo);
3409 if (SUCCEEDED(hr)) {
3422 ITypeInfo *pTypeInfo;
3430 hr = typeinfo_from_ole(pole, &pTypeInfo);
3450 fole_methods(
VALUE self)
3452 return ole_methods(
self, INVOKE_FUNC | INVOKE_PROPERTYGET | INVOKE_PROPERTYPUT | INVOKE_PROPERTYPUTREF);
3466 fole_get_methods(
VALUE self)
3468 return ole_methods(
self, INVOKE_PROPERTYGET);
3482 fole_put_methods(
VALUE self)
3484 return ole_methods(
self, INVOKE_PROPERTYPUT|INVOKE_PROPERTYPUTREF);
3499 fole_func_methods(
VALUE self)
3501 return ole_methods(
self, INVOKE_FUNC);
3514 fole_type(
VALUE self)
3516 ITypeInfo *pTypeInfo;
3548 fole_typelib(
VALUE self)
3552 ITypeInfo *pTypeInfo;
3558 0,
lcid, &pTypeInfo);
3564 if (vtlib ==
Qnil) {
3581 fole_query_interface(
VALUE self,
VALUE str_iid)
3591 hr = CLSIDFromString(pBuf, &iid);
3592 SysFreeString(pBuf);
3595 "invalid iid: `%s'",
3608 "failed to get interface `%s'",
3642 SysFreeString(wcmdname);
3653 hr = pTypeInfo->lpVtbl->GetContainingTypeLib(pTypeInfo, &pTypeLib, &
i);
3658 hr = pTypeLib->lpVtbl->GetDocumentation(pTypeLib,
i,
3660 helpcontext, helpfile);
3670 ole_usertype2val(ITypeInfo *pTypeInfo, TYPEDESC *pTypeDesc,
VALUE typedetails)
3674 ITypeInfo *pRefTypeInfo;
3677 hr = pTypeInfo->lpVtbl->GetRefTypeInfo(pTypeInfo,
3689 if(typedetails !=
Qnil)
3695 ole_ptrtype2val(ITypeInfo *pTypeInfo, TYPEDESC *pTypeDesc,
VALUE typedetails)
3697 TYPEDESC *p = pTypeDesc;
3700 if (p->vt == VT_PTR || p->vt == VT_SAFEARRAY) {
3712 switch(pTypeDesc->vt) {
3755 #if (_MSC_VER >= 1300) || defined(__CYGWIN__) || defined(__MINGW32__)
3777 if(typedetails !=
Qnil)
3779 return ole_ptrtype2val(pTypeInfo, pTypeDesc, typedetails);
3782 if(typedetails !=
Qnil)
3784 return ole_ptrtype2val(pTypeInfo, pTypeDesc, typedetails);
3788 case VT_USERDEFINED:
3790 if (typedetails !=
Qnil)
3792 str = ole_usertype2val(pTypeInfo, pTypeDesc, typedetails);
3820 if (typedetails !=
Qnil)
3839 ITypeInfo *pTypeInfo;
3846 hr = typeinfo_from_ole(pole, &pTypeInfo);
3880 fole_activex_initialize(
VALUE self)
3883 IPersistMemory *pPersistMemory;
3890 hr = pole->
pDispatch->lpVtbl->QueryInterface(pole->
pDispatch, &IID_IPersistMemory, &p);
3892 if (SUCCEEDED(hr)) {
3893 hr = pPersistMemory->lpVtbl->InitNew(pPersistMemory);
3895 if (SUCCEEDED(hr)) {
3914 ITypeInfo *pTypeInfo;
3917 0,
lcid, &pTypeInfo);
3921 hr = pTypeInfo->lpVtbl->GetContainingTypeLib(pTypeInfo, pTypeLib, &
index);
3927 com_hash_free(
void *
ptr)
3934 com_hash_mark(
void *
ptr)
3941 com_hash_size(
const void *
ptr)
3948 check_nano_server(
void)
3952 const char * subkey =
"SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion\\Server\\ServerLevels";
3953 const char * regval =
"NanoServer";
3955 err = RegOpenKeyEx(HKEY_LOCAL_MACHINE, subkey, 0, KEY_READ, &hsubkey);
3956 if (
err == ERROR_SUCCESS) {
3958 if (
err == ERROR_SUCCESS) {
3959 g_running_nano =
TRUE;
3961 RegCloseKey(hsubkey);
3971 check_nano_server();
3973 com_vtbl.QueryInterface = QueryInterface;
3974 com_vtbl.AddRef = AddRef;
3975 com_vtbl.Release = Release;
3976 com_vtbl.GetTypeInfoCount = GetTypeInfoCount;
3977 com_vtbl.GetTypeInfo = GetTypeInfo;
3978 com_vtbl.GetIDsOfNames = GetIDsOfNames;
3979 com_vtbl.Invoke = Invoke;
3981 message_filter.QueryInterface = mf_QueryInterface;
3982 message_filter.AddRef = mf_AddRef;
3983 message_filter.Release = mf_Release;
3984 message_filter.HandleInComingCall = mf_HandleInComingCall;
3985 message_filter.RetryRejectedCall = mf_RetryRejectedCall;
3986 message_filter.MessagePending = mf_MessagePending;