PageRenderTime 87ms CodeModel.GetById 34ms RepoModel.GetById 0ms app.codeStats 1ms

/ext/win32ole/win32ole.c

https://github.com/fizx/ruby
C | 9286 lines | 9080 code | 172 blank | 34 comment | 364 complexity | 028bd14eb46730c2a57351be02ccded8 MD5 | raw file
Possible License(s): LGPL-2.1, AGPL-3.0, GPL-2.0, BSD-3-Clause 
    

  1. /*
    2. 

  2.  *  (c) 1995 Microsoft Corporation. All rights reserved.
    3. 

  3.  *  Developed by ActiveWare Internet Corp., http://www.ActiveWare.com
    4. 

  4.  *
    5. 

  5.  *  Other modifications Copyright (c) 1997, 1998 by Gurusamy Sarathy
    6. 

  6.  *  <gsar@umich.edu> and Jan Dubois <jan.dubois@ibm.net>
    7. 

  7.  *
    8. 

  8.  *  You may distribute under the terms of either the GNU General Public
    9. 

  9.  *  License or the Artistic License, as specified in the README file
    10. 

  10.  *  of the Perl distribution.
    11. 

  11.  *
    12. 

  12.  */
    13. 

  13. 

  14. /*
    15. 

  15.   modified for win32ole (ruby) by Masaki.Suketa <masaki.suketa@nifty.ne.jp>
    16. 

  16.  */
    17. 

  17. 

  18. #include "ruby/ruby.h"
    19. 

  19. #include "ruby/st.h"
    20. 

  20. #include "ruby/encoding.h"
    21. 

  21. #include <ctype.h>
    22. 

  22. #include <windows.h>
    23. 

  23. #include <ocidl.h>
    24. 

  24. #include <olectl.h>
    25. 

  25. #include <ole2.h>
    26. 

  26. #if defined(HAVE_TYPE_IMULTILANGUAGE2) || defined(HAVE_TYPE_IMULTILANGUAGE)
    27. 

  27. #include <mlang.h>
    28. 

  28. #endif
    29. 

  29. #include <stdlib.h>
    30. 

  30. #include <math.h>
    31. 

  31. #ifdef HAVE_STDARG_PROTOTYPES
    32. 

  32. #include <stdarg.h>
    33. 

  33. #define va_init_list(a,b) va_start(a,b)
    34. 

  34. #else
    35. 

  35. #include <varargs.h>
    36. 

  36. #define va_init_list(a,b) va_start(a)
    37. 

  37. #endif
    38. 

  38. #include <objidl.h>
    39. 

  39. 

  40. #define DOUT fprintf(stderr,"[%d]\n",__LINE__)
    41. 

  41. #define DOUTS(x) fprintf(stderr,"[%d]:" #x "=%s\n",__LINE__,x)
    42. 

  42. #define DOUTMSG(x) fprintf(stderr, "[%d]:" #x "\n",__LINE__)
    43. 

  43. #define DOUTI(x) fprintf(stderr, "[%ld]:" #x "=%d\n",__LINE__,x)
    44. 

  44. #define DOUTD(x) fprintf(stderr, "[%d]:" #x "=%f\n",__LINE__,x)
    45. 

  45. 

  46. #if defined NONAMELESSUNION && __GNUC__
    47. 

  47. #define V_UNION1(X, Y) ((X)->u.Y)
    48. 

  48. #else
    49. 

  49. #define V_UNION1(X, Y) ((X)->Y)
    50. 

  50. #endif
    51. 

  51. 

  52. #if defined NONAMELESSUNION && __GNUC__
    53. 

  53. #undef V_UNION
    54. 

  54. #define V_UNION(X,Y) ((X)->n1.n2.n3.Y)
    55. 

  55. 

  56. #undef V_VT
    57. 

  57. #define V_VT(X) ((X)->n1.n2.vt)
    58. 

  58. 

  59. #undef V_BOOL
    60. 

  60. #define V_BOOL(X) V_UNION(X,boolVal)
    61. 

  61. #endif
    62. 

  62. 

  63. #ifndef V_I1REF
    64. 

  64. #define V_I1REF(X) V_UNION(X, pcVal)
    65. 

  65. #endif
    66. 

  66. 

  67. #ifndef U_UI2REF
    68. 

  68. #define V_UI2REF(X) V_UNION(X, puiVal)
    69. 

  69. #endif
    70. 

  70. 

  71. #ifndef V_INT
    72. 

  72. #define V_INT(X) V_UNION(X, intVal)
    73. 

  73. #endif
    74. 

  74. 

  75. #ifndef V_INTREF
    76. 

  76. #define V_INTREF(X) V_UNION(X, pintVal)
    77. 

  77. #endif
    78. 

  78. 

  79. #ifndef V_UINT
    80. 

  80. #define V_UINT(X) V_UNION(X, uintVal)
    81. 

  81. #endif
    82. 

  82. 

  83. #ifndef V_UINTREF
    84. 

  84. #define V_UINTREF(X) V_UNION(X, puintVal)
    85. 

  85. #endif
    86. 

  86. 

  87. /*
    88. 

  88.  * unfortunately IID_IMultiLanguage2 is not included in any libXXX.a 
    89. 

  89.  * in Cygwin(mingw32).
    90. 

  90.  */
    91. 

  91. #if defined(__CYGWIN__) ||  defined(__MINGW32__)
    92. 

  92. #undef IID_IMultiLanguage2
    93. 

  93. const IID IID_IMultiLanguage2 = {0xDCCFC164, 0x2B38, 0x11d2, {0xB7, 0xEC, 0x00, 0xC0, 0x4F, 0x8F, 0x5D, 0x9A}};
    94. 

  94. #endif
    95. 

  95. 

  96. #define OLE_RELEASE(X) (X) ? ((X)->lpVtbl->Release(X)) : 0
    97. 

  97. 

  98. #define OLE_ADDREF(X) (X) ? ((X)->lpVtbl->AddRef(X)) : 0
    99. 

  99. 

  100. #define OLE_GET_TYPEATTR(X, Y) ((X)->lpVtbl->GetTypeAttr((X), (Y)))
    101. 

  101. #define OLE_RELEASE_TYPEATTR(X, Y) ((X)->lpVtbl->ReleaseTypeAttr((X), (Y)))
    102. 

  102. 

  103. #define OLE_FREE(x) {\
    104. 

  104.     if(g_ole_initialized == TRUE) {\
    105. 

  105.         if(x) {\
    106. 

  106.             OLE_RELEASE(x);\
    107. 

  107.             (x) = 0;\
    108. 

  108.         }\
    109. 

  109.     }\
    110. 

  110. }
    111. 

  111. 

  112. #define OLEData_Get_Struct(obj, pole) {\
    113. 

  113.     Data_Get_Struct(obj, struct oledata, pole);\
    114. 

  114.     if(!pole->pDispatch) {\
    115. 

  115.         rb_raise(rb_eRuntimeError, "failed to get Dispatch Interface");\
    116. 

  116.     }\
    117. 

  117. }
    118. 

  118. 

  119. #ifdef HAVE_LONG_LONG
    120. 

  120. #define I8_2_NUM LL2NUM
    121. 

  121. #define UI8_2_NUM ULL2NUM
    122. 

  122. #define NUM2I8  NUM2LL
    123. 

  123. #define NUM2UI8 NUM2ULL
    124. 

  124. #else
    125. 

  125. #define I8_2_NUM INT2NUM
    126. 

  126. #define UI8_2_NUM UINT2NUM
    127. 

  127. #define NUM2I8  NUM2INT
    128. 

  128. #define NUM2UI8 NUM2UINT
    129. 

  129. #endif
    130. 

  130. 

  131. #define WC2VSTR(x) ole_wc2vstr((x), TRUE)
    132. 

  132. 

  133. #define WIN32OLE_VERSION "1.4.7"
    134. 

  134. 

  135. typedef HRESULT (STDAPICALLTYPE FNCOCREATEINSTANCEEX)
    136. 

  136.     (REFCLSID, IUnknown*, DWORD, COSERVERINFO*, DWORD, MULTI_QI*);
    137. 

  137. 

  138. typedef HWND (WINAPI FNHTMLHELP)(HWND hwndCaller, LPCSTR pszFile,
    139. 

  139.                                  UINT uCommand, DWORD dwData);
    140. 

  140. typedef BOOL (FNENUMSYSEMCODEPAGES) (CODEPAGE_ENUMPROC, DWORD);
    141. 

  141. typedef struct {
    142. 

  142.     struct IEventSinkVtbl * lpVtbl;
    143. 

  143. } IEventSink, *PEVENTSINK;
    144. 

  144. 

  145. typedef struct IEventSinkVtbl IEventSinkVtbl;
    146. 

  146. 

  147. struct IEventSinkVtbl {
    148. 

  148.     STDMETHOD(QueryInterface)(
    149. 

  149.         PEVENTSINK,
    150. 

  150.         REFIID,
    151. 

  151.         LPVOID *);
    152. 

  152.     STDMETHOD_(ULONG, AddRef)(PEVENTSINK);
    153. 

  153.     STDMETHOD_(ULONG, Release)(PEVENTSINK);
    154. 

  154. 

  155.     STDMETHOD(GetTypeInfoCount)(
    156. 

  156.         PEVENTSINK,
    157. 

  157.         UINT *);
    158. 

  158.     STDMETHOD(GetTypeInfo)(
    159. 

  159.         PEVENTSINK,
    160. 

  160.         UINT,
    161. 

  161.         LCID,
    162. 

  162.         ITypeInfo **);
    163. 

  163.     STDMETHOD(GetIDsOfNames)(
    164. 

  164.         PEVENTSINK,
    165. 

  165.         REFIID,
    166. 

  166.         OLECHAR **,
    167. 

  167.         UINT,
    168. 

  168.         LCID,
    169. 

  169.         DISPID *);
    170. 

  170.     STDMETHOD(Invoke)(
    171. 

  171.         PEVENTSINK,
    172. 

  172.         DISPID,
    173. 

  173.         REFIID,
    174. 

  174.         LCID,
    175. 

  175.         WORD,
    176. 

  176.         DISPPARAMS *,
    177. 

  177.         VARIANT *,
    178. 

  178.         EXCEPINFO *,
    179. 

  179.         UINT *);
    180. 

  180. };
    181. 

  181. 

  182. typedef struct tagIEVENTSINKOBJ {
    183. 

  183.     IEventSinkVtbl *lpVtbl;
    184. 

  184.     DWORD m_cRef;
    185. 

  185.     IID m_iid;
    186. 

  186.     int m_event_id;
    187. 

  187.     ITypeInfo *pTypeInfo;
    188. 

  188. }IEVENTSINKOBJ, *PIEVENTSINKOBJ;
    189. 

  189. 

  190. VALUE cWIN32OLE;
    191. 

  191. VALUE cWIN32OLE_TYPELIB;
    192. 

  192. VALUE cWIN32OLE_TYPE;
    193. 

  193. VALUE cWIN32OLE_VARIABLE;
    194. 

  194. VALUE cWIN32OLE_METHOD;
    195. 

  195. VALUE cWIN32OLE_PARAM;
    196. 

  196. VALUE cWIN32OLE_EVENT;
    197. 

  197. VALUE cWIN32OLE_VARIANT;
    198. 

  198. VALUE eWIN32OLERuntimeError;
    199. 

  199. VALUE mWIN32OLE_VARIANT;
    200. 

  200. VALUE cWIN32OLE_PROPERTY;
    201. 

  201. 

  202. static VALUE ary_ole_event;
    203. 

  203. static ID id_events;
    204. 

  204. static BOOL g_ole_initialized = FALSE;
    205. 

  205. static BOOL g_cp_installed = FALSE;
    206. 

  206. static BOOL g_lcid_installed = FALSE;
    207. 

  207. static HINSTANCE ghhctrl = NULL;
    208. 

  208. static HINSTANCE gole32 = NULL;
    209. 

  209. static FNCOCREATEINSTANCEEX *gCoCreateInstanceEx = NULL;
    210. 

  210. static VALUE com_hash;
    211. 

  211. static IDispatchVtbl com_vtbl;
    212. 

  212. static UINT cWIN32OLE_cp = CP_ACP;
    213. 

  213. static LCID cWIN32OLE_lcid = LOCALE_SYSTEM_DEFAULT;
    214. 

  214. static rb_encoding *cWIN32OLE_enc;
    215. 

  215. static UINT g_cp_to_check = CP_ACP;
    216. 

  216. static char g_lcid_to_check[8 + 1];
    217. 

  217. static VARTYPE g_nil_to = VT_ERROR;
    218. 

  218. static st_table *enc2cp_table;
    219. 

  219. static IMessageFilterVtbl message_filter;
    220. 

  220. static IMessageFilter imessage_filter = { &message_filter };
    221. 

  221. static IMessageFilter* previous_filter;
    222. 

  222. 

  223. #if defined(HAVE_TYPE_IMULTILANGUAGE2)
    224. 

  224. static IMultiLanguage2 *pIMultiLanguage = NULL;
    225. 

  225. #elif defined(HAVE_TYPE_IMULTILANGUAGE)
    226. 

  226. static IMultiLanguage *pIMultiLanguage = NULL;
    227. 

  227. #else
    228. 

  228. #define pIMultiLanguage NULL /* dummy */
    229. 

  229. #endif
    230. 

  230. 

  231. struct oledata {
    232. 

  232.     IDispatch *pDispatch;
    233. 

  233. };
    234. 

  234. 

  235. struct oletypelibdata {
    236. 

  236.     ITypeLib *pTypeLib;
    237. 

  237. };
    238. 

  238. 

  239. struct oletypedata {
    240. 

  240.     ITypeInfo *pTypeInfo;
    241. 

  241. };
    242. 

  242. 

  243. struct olemethoddata {
    244. 

  244.     ITypeInfo *pOwnerTypeInfo;
    245. 

  245.     ITypeInfo *pTypeInfo;
    246. 

  246.     UINT index;
    247. 

  247. };
    248. 

  248. 

  249. struct olevariabledata {
    250. 

  250.     ITypeInfo *pTypeInfo;
    251. 

  251.     UINT index;
    252. 

  252. };
    253. 

  253. 

  254. struct oleparamdata {
    255. 

  255.     ITypeInfo *pTypeInfo;
    256. 

  256.     UINT method_index;
    257. 

  257.     UINT index;
    258. 

  258. };
    259. 

  259. 

  260. struct oleeventdata {
    261. 

  261.     DWORD dwCookie;
    262. 

  262.     IConnectionPoint *pConnectionPoint;
    263. 

  263.     long event_id;
    264. 

  264. };
    265. 

  265. 

  266. struct oleparam {
    267. 

  267.     DISPPARAMS dp;
    268. 

  268.     OLECHAR** pNamedArgs;
    269. 

  269. };
    270. 

  270. 

  271. struct olevariantdata {
    272. 

  272.     VARIANT realvar;
    273. 

  273.     VARIANT var;
    274. 

  274. };
    275. 

  275. 

  276. 

  277. static HRESULT ( STDMETHODCALLTYPE QueryInterface )(IDispatch __RPC_FAR *, REFIID riid, void __RPC_FAR *__RPC_FAR *ppvObject);
    278. 

  278. static ULONG ( STDMETHODCALLTYPE AddRef )(IDispatch __RPC_FAR * This);
    279. 

  279. static ULONG ( STDMETHODCALLTYPE Release )(IDispatch __RPC_FAR * This);
    280. 

  280. static HRESULT ( STDMETHODCALLTYPE GetTypeInfoCount )(IDispatch __RPC_FAR * This, UINT __RPC_FAR *pctinfo);
    281. 

  281. static HRESULT ( STDMETHODCALLTYPE GetTypeInfo )(IDispatch __RPC_FAR * This, UINT iTInfo, LCID lcid, ITypeInfo __RPC_FAR *__RPC_FAR *ppTInfo);
    282. 

  282. static HRESULT ( STDMETHODCALLTYPE GetIDsOfNames )(IDispatch __RPC_FAR * This, REFIID riid, LPOLESTR __RPC_FAR *rgszNames, UINT cNames, LCID lcid, DISPID __RPC_FAR *rgDispId);
    283. 

  283. static HRESULT ( STDMETHODCALLTYPE Invoke )( IDispatch __RPC_FAR * This, DISPID dispIdMember, REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS __RPC_FAR *pDispParams, VARIANT __RPC_FAR *pVarResult, EXCEPINFO __RPC_FAR *pExcepInfo, UINT __RPC_FAR *puArgErr);
    284. 

  284. static IDispatch* val2dispatch(VALUE val);
    285. 

  285. static double rbtime2vtdate(VALUE tmobj);
    286. 

  286. static VALUE vtdate2rbtime(double date);
    287. 

  287. static rb_encoding *ole_cp2encoding(UINT cp);
    288. 

  288. static UINT ole_encoding2cp(rb_encoding *enc);
    289. 

  289. NORETURN(static void failed_load_conv51932(void));
    290. 

  290. #ifndef pIMultiLanguage
    291. 

  291. static void load_conv_function51932(void);
    292. 

  292. #endif
    293. 

  293. static UINT ole_init_cp(void);
    294. 

  294. static char *ole_wc2mb(LPWSTR pw);
    295. 

  295. static VALUE ole_hresult2msg(HRESULT hr);
    296. 

  296. static void ole_freeexceptinfo(EXCEPINFO *pExInfo);
    297. 

  297. static VALUE ole_excepinfo2msg(EXCEPINFO *pExInfo);
    298. 

  298. static void ole_raise(HRESULT hr, VALUE ecs, const char *fmt, ...);
    299. 

  299. static void ole_initialize();
    300. 

  300. static void ole_msg_loop();
    301. 

  301. static void ole_free(struct oledata *pole);
    302. 

  302. static void oletypelib_free(struct oletypelibdata *poletypelib);
    303. 

  303. static void oletype_free(struct oletypedata *poletype);
    304. 

  304. static void olemethod_free(struct olemethoddata *polemethod);
    305. 

  305. static void olevariable_free(struct olevariabledata *polevar);
    306. 

  306. static void oleparam_free(struct oleparamdata *pole);
    307. 

  307. static LPWSTR ole_vstr2wc(VALUE vstr);
    308. 

  308. static LPWSTR ole_mb2wc(char *pm, int len);
    309. 

  309. static VALUE ole_wc2vstr(LPWSTR pw, BOOL isfree);
    310. 

  310. static VALUE ole_ary_m_entry(VALUE val, long *pid);
    311. 

  311. static void * get_ptr_of_variant(VARIANT *pvar);
    312. 

  312. static VALUE is_all_index_under(long *pid, long *pub, long dim);
    313. 

  313. static void ole_set_safe_array(long n, SAFEARRAY *psa, long *pid, long *pub, VALUE val, long dim,  VARTYPE vt);
    314. 

  314. static long dimension(VALUE val);
    315. 

  315. static long ary_len_of_dim(VALUE ary, long dim);
    316. 

  316. static HRESULT ole_val_ary2variant_ary(VALUE val, VARIANT *var, VARTYPE vt);
    317. 

  317. static void ole_val2variant(VALUE val, VARIANT *var);
    318. 

  318. static void ole_val2variant_ex(VALUE val, VARIANT *var, VARTYPE vt);
    319. 

  319. static void ole_val2ptr_variant(VALUE val, VARIANT *var);
    320. 

  320. static void ole_set_byref(VARIANT *realvar, VARIANT *var,  VARTYPE vt);
    321. 

  321. static void ole_val2olevariantdata(VALUE val, VARTYPE vt, struct olevariantdata *pvar);
    322. 

  322. static void ole_val2variant2(VALUE val, VARIANT *var);
    323. 

  323. static VALUE make_inspect(const char *class_name, VALUE detail);
    324. 

  324. static VALUE default_inspect(VALUE self, const char *class_name);
    325. 

  325. static VALUE ole_set_member(VALUE self, IDispatch *dispatch);
    326. 

  326. static VALUE fole_s_allocate(VALUE klass);
    327. 

  327. static VALUE create_win32ole_object(VALUE klass, IDispatch *pDispatch, int argc, VALUE *argv);
    328. 

  328. static VALUE ary_new_dim(VALUE myary, long *pid, long *plb, long dim);
    329. 

  329. static void ary_store_dim(VALUE myary, long *pid, long *plb, long dim, VALUE val);
    330. 

  330. static VALUE ole_variant2val(VARIANT *pvar);
    331. 

  331. static LONG reg_open_key(HKEY hkey, const char *name, HKEY *phkey);
    332. 

  332. static LONG reg_open_vkey(HKEY hkey, VALUE key, HKEY *phkey);
    333. 

  333. static VALUE reg_enum_key(HKEY hkey, DWORD i);
    334. 

  334. static VALUE reg_get_val(HKEY hkey, const char *subkey);
    335. 

  335. static VALUE reg_get_typelib_file_path(HKEY hkey);
    336. 

  336. static VALUE typelib_file_from_clsid(VALUE ole);
    337. 

  337. static VALUE typelib_file_from_typelib(VALUE ole);
    338. 

  338. static VALUE typelib_file(VALUE ole);
    339. 

  339. static void ole_const_load(ITypeLib *pTypeLib, VALUE klass, VALUE self);
    340. 

  340. static HRESULT clsid_from_remote(VALUE host, VALUE com, CLSID *pclsid);
    341. 

  341. static VALUE ole_create_dcom(int argc, VALUE *argv, VALUE self);
    342. 

  342. static VALUE ole_bind_obj(VALUE moniker, int argc, VALUE *argv, VALUE self);
    343. 

  343. static VALUE fole_s_connect(int argc, VALUE *argv, VALUE self);
    344. 

  344. static VALUE fole_s_const_load(int argc, VALUE *argv, VALUE self);
    345. 

  345. static VALUE ole_types_from_typelib(ITypeLib *pTypeLib, VALUE classes);
    346. 

  346. static ULONG reference_count(struct oledata * pole);
    347. 

  347. static VALUE fole_s_reference_count(VALUE self, VALUE obj);
    348. 

  348. static VALUE fole_s_free(VALUE self, VALUE obj);
    349. 

  349. static HWND ole_show_help(VALUE helpfile, VALUE helpcontext);
    350. 

  350. static VALUE fole_s_show_help(int argc, VALUE *argv, VALUE self);
    351. 

  351. static VALUE fole_s_get_code_page(VALUE self);
    352. 

  352. static BOOL CALLBACK installed_code_page_proc(LPTSTR str);
    353. 

  353. static BOOL code_page_installed(UINT cp);
    354. 

  354. static VALUE fole_s_set_code_page(VALUE self, VALUE vcp);
    355. 

  355. static VALUE fole_s_get_locale(VALUE self);
    356. 

  356. static BOOL CALLBACK installed_lcid_proc(LPTSTR str);
    357. 

  357. static BOOL lcid_installed(LCID lcid);
    358. 

  358. static VALUE fole_s_set_locale(VALUE self, VALUE vlcid);
    359. 

  359. static VALUE fole_s_create_guid(VALUE self);
    360. 

  360. static void  ole_pure_initialize();
    361. 

  361. static VALUE fole_s_ole_initialize(VALUE self);
    362. 

  362. static void  ole_pure_uninitialize();
    363. 

  363. static VALUE fole_s_ole_uninitialize(VALUE self);
    364. 

  364. static VALUE fole_initialize(int argc, VALUE *argv, VALUE self);
    365. 

  365. static VALUE hash2named_arg(VALUE pair, struct oleparam* pOp);
    366. 

  366. static VALUE set_argv(VARIANTARG* realargs, unsigned int beg, unsigned int end);
    367. 

  367. static VALUE ole_invoke(int argc, VALUE *argv, VALUE self, USHORT wFlags, BOOL is_bracket);
    368. 

  368. static VALUE fole_invoke(int argc, VALUE *argv, VALUE self);
    369. 

  369. static VALUE ole_invoke2(VALUE self, VALUE dispid, VALUE args, VALUE types, USHORT dispkind);
    370. 

  370. static VALUE fole_invoke2(VALUE self, VALUE dispid, VALUE args, VALUE types);
    371. 

  371. static VALUE fole_getproperty2(VALUE self, VALUE dispid, VALUE args, VALUE types);
    372. 

  372. static VALUE fole_setproperty2(VALUE self, VALUE dispid, VALUE args, VALUE types);
    373. 

  373. static VALUE fole_setproperty_with_bracket(int argc, VALUE *argv, VALUE self);
    374. 

  374. static VALUE fole_setproperty(int argc, VALUE *argv, VALUE self);
    375. 

  375. static VALUE fole_getproperty_with_bracket(int argc, VALUE *argv, VALUE self);
    376. 

  376. static VALUE ole_propertyput(VALUE self, VALUE property, VALUE value);
    377. 

  377. static VALUE fole_free(VALUE self);
    378. 

  378. static VALUE ole_each_sub(VALUE pEnumV);
    379. 

  379. static VALUE ole_ienum_free(VALUE pEnumV);
    380. 

  380. static VALUE fole_each(VALUE self);
    381. 

  381. static VALUE fole_missing(int argc, VALUE *argv, VALUE self);
    382. 

  382. static VALUE ole_method_sub(VALUE self, ITypeInfo *pOwnerTypeInfo, ITypeInfo *pTypeInfo, VALUE name);
    383. 

  383. static VALUE olemethod_from_typeinfo(VALUE self, ITypeInfo *pTypeInfo, VALUE name);
    384. 

  384. static VALUE ole_methods_sub(ITypeInfo *pOwnerTypeInfo, ITypeInfo *pTypeInfo, VALUE methods, int mask);
    385. 

  385. static VALUE ole_methods_from_typeinfo(ITypeInfo *pTypeInfo, int mask);
    386. 

  386. static HRESULT typeinfo_from_ole(struct oledata *pole, ITypeInfo **ppti);
    387. 

  387. static VALUE ole_methods(VALUE self, int mask);
    388. 

  388. static VALUE fole_methods(VALUE self);
    389. 

  389. static VALUE fole_get_methods(VALUE self);
    390. 

  390. static VALUE fole_put_methods(VALUE self);
    391. 

  391. static VALUE fole_func_methods(VALUE self);
    392. 

  392. static VALUE ole_type_from_itypeinfo(ITypeInfo *pTypeInfo);
    393. 

  393. static VALUE fole_type(VALUE self);
    394. 

  394. static VALUE ole_typelib_from_itypeinfo(ITypeInfo *pTypeInfo);
    395. 

  395. static VALUE fole_typelib(VALUE self);
    396. 

  396. static VALUE fole_query_interface(VALUE self, VALUE str_iid);
    397. 

  397. static VALUE fole_respond_to(VALUE self, VALUE method);
    398. 

  398. static HRESULT ole_docinfo_from_type(ITypeInfo *pTypeInfo, BSTR *name, BSTR *helpstr, DWORD *helpcontext, BSTR *helpfile);
    399. 

  399. static VALUE ole_usertype2val(ITypeInfo *pTypeInfo, TYPEDESC *pTypeDesc, VALUE typedetails);
    400. 

  400. static VALUE ole_ptrtype2val(ITypeInfo *pTypeInfo, TYPEDESC *pTypeDesc, VALUE typedetails);
    401. 

  401. static VALUE ole_typedesc2val(ITypeInfo *pTypeInfo, TYPEDESC *pTypeDesc, VALUE typedetails);
    402. 

  402. static VALUE fole_method_help(VALUE self, VALUE cmdname);
    403. 

  403. static VALUE fole_activex_initialize(VALUE self);
    404. 

  404. static VALUE foletype_s_ole_classes(VALUE self, VALUE typelib);
    405. 

  405. static VALUE foletype_s_typelibs(VALUE self);
    406. 

  406. static VALUE foletype_s_progids(VALUE self);
    407. 

  407. static VALUE foletype_s_allocate(VALUE klass);
    408. 

  408. static VALUE oletype_set_member(VALUE self, ITypeInfo *pTypeInfo, VALUE name);
    409. 

  409. static VALUE oleclass_from_typelib(VALUE self, ITypeLib *pTypeLib, VALUE oleclass);
    410. 

  410. static VALUE oletypelib_set_member(VALUE self, ITypeLib *pTypeLib);
    411. 

  411. static ITypeLib * oletypelib_get_typelib(VALUE self);
    412. 

  412. static void oletypelib_get_libattr(ITypeLib *pTypeLib, TLIBATTR **ppTLibAttr);
    413. 

  413. static VALUE foletypelib_s_typelibs(VALUE self);
    414. 

  414. static VALUE make_version_str(VALUE major, VALUE minor);
    415. 

  415. static VALUE oletypelib_search_registry2(VALUE self, VALUE args);
    416. 

  416. static VALUE oletypelib_search_registry(VALUE self, VALUE typelib);
    417. 

  417. static VALUE foletypelib_s_allocate(VALUE klass);
    418. 

  418. static VALUE foletypelib_initialize(VALUE self, VALUE args);
    419. 

  419. static VALUE foletypelib_guid(VALUE self);
    420. 

  420. static VALUE foletypelib_name(VALUE self);
    421. 

  421. static VALUE foletypelib_version(VALUE self);
    422. 

  422. static VALUE foletypelib_major_version(VALUE self);
    423. 

  423. static VALUE foletypelib_minor_version(VALUE self);
    424. 

  424. static VALUE oletypelib_path(VALUE guid, VALUE version);
    425. 

  425. static HRESULT oletypelib_from_guid(VALUE guid, VALUE version, ITypeLib **ppTypeLib);
    426. 

  426. static VALUE foletypelib_path(VALUE self);
    427. 

  427. static VALUE foletypelib_visible(VALUE self);
    428. 

  428. static VALUE foletypelib_library_name(VALUE self);
    429. 

  429. static VALUE foletypelib_ole_types(VALUE self);
    430. 

  430. static VALUE foletypelib_inspect(VALUE self);
    431. 

  431. static VALUE foletype_initialize(VALUE self, VALUE typelib, VALUE oleclass);
    432. 

  432. static VALUE foletype_name(VALUE self);
    433. 

  433. static VALUE ole_ole_type(ITypeInfo *pTypeInfo);
    434. 

  434. static VALUE foletype_ole_type(VALUE self);
    435. 

  435. static VALUE ole_type_guid(ITypeInfo *pTypeInfo);
    436. 

  436. static VALUE foletype_guid(VALUE self);
    437. 

  437. static VALUE ole_type_progid(ITypeInfo *pTypeInfo);
    438. 

  438. static VALUE foletype_progid(VALUE self);
    439. 

  439. static VALUE ole_type_visible(ITypeInfo *pTypeInfo);
    440. 

  440. static VALUE foletype_visible(VALUE self);
    441. 

  441. static VALUE ole_type_major_version(ITypeInfo *pTypeInfo);
    442. 

  442. static VALUE foletype_major_version(VALUE self);
    443. 

  443. static VALUE ole_type_minor_version(ITypeInfo *pTypeInfo);
    444. 

  444. static VALUE foletype_minor_version(VALUE self);
    445. 

  445. static VALUE ole_type_typekind(ITypeInfo *pTypeInfo);
    446. 

  446. static VALUE foletype_typekind(VALUE self);
    447. 

  447. static VALUE ole_type_helpstring(ITypeInfo *pTypeInfo);
    448. 

  448. static VALUE foletype_helpstring(VALUE self);
    449. 

  449. static VALUE ole_type_src_type(ITypeInfo *pTypeInfo);
    450. 

  450. static VALUE foletype_src_type(VALUE self);
    451. 

  451. static VALUE ole_type_helpfile(ITypeInfo *pTypeInfo);
    452. 

  452. static VALUE foletype_helpfile(VALUE self);
    453. 

  453. static VALUE ole_type_helpcontext(ITypeInfo *pTypeInfo);
    454. 

  454. static VALUE foletype_helpcontext(VALUE self);
    455. 

  455. static VALUE foletype_ole_typelib(VALUE self);
    456. 

  456. static VALUE ole_type_impl_ole_types(ITypeInfo *pTypeInfo, int implflags);
    457. 

  457. static VALUE foletype_impl_ole_types(VALUE self);
    458. 

  458. static VALUE foletype_source_ole_types(VALUE self);
    459. 

  459. static VALUE foletype_default_event_sources(VALUE self);
    460. 

  460. static VALUE foletype_default_ole_types(VALUE self);
    461. 

  461. static VALUE foletype_inspect(VALUE self);
    462. 

  462. static VALUE ole_variables(ITypeInfo *pTypeInfo);
    463. 

  463. static VALUE foletype_variables(VALUE self);
    464. 

  464. static VALUE foletype_methods(VALUE self);
    465. 

  465. static VALUE folevariable_name(VALUE self);
    466. 

  466. static VALUE ole_variable_ole_type(ITypeInfo *pTypeInfo, UINT var_index);
    467. 

  467. static VALUE folevariable_ole_type(VALUE self);
    468. 

  468. static VALUE ole_variable_ole_type_detail(ITypeInfo *pTypeInfo, UINT var_index);
    469. 

  469. static VALUE folevariable_ole_type_detail(VALUE self);
    470. 

  470. static VALUE ole_variable_value(ITypeInfo *pTypeInfo, UINT var_index);
    471. 

  471. static VALUE folevariable_value(VALUE self);
    472. 

  472. static VALUE ole_variable_visible(ITypeInfo *pTypeInfo, UINT var_index);
    473. 

  473. static VALUE folevariable_visible(VALUE self);
    474. 

  474. static VALUE ole_variable_kind(ITypeInfo *pTypeInfo, UINT var_index);
    475. 

  475. static VALUE folevariable_variable_kind(VALUE self);
    476. 

  476. static VALUE ole_variable_varkind(ITypeInfo *pTypeInfo, UINT var_index);
    477. 

  477. static VALUE folevariable_varkind(VALUE self);
    478. 

  478. static VALUE folevariable_inspect(VALUE self);
    479. 

  479. static VALUE olemethod_set_member(VALUE self, ITypeInfo *pTypeInfo, ITypeInfo *pOwnerTypeInfo, int index, VALUE name);
    480. 

  480. static VALUE folemethod_s_allocate(VALUE klass);
    481. 

  481. static VALUE folemethod_initialize(VALUE self, VALUE oletype, VALUE method);
    482. 

  482. static VALUE folemethod_name(VALUE self);
    483. 

  483. static VALUE ole_method_return_type(ITypeInfo *pTypeInfo, UINT method_index);
    484. 

  484. static VALUE folemethod_return_type(VALUE self);
    485. 

  485. static VALUE ole_method_return_vtype(ITypeInfo *pTypeInfo, UINT method_index);
    486. 

  486. static VALUE folemethod_return_vtype(VALUE self);
    487. 

  487. static VALUE ole_method_return_type_detail(ITypeInfo *pTypeInfo, UINT method_index);
    488. 

  488. static VALUE folemethod_return_type_detail(VALUE self);
    489. 

  489. static VALUE ole_method_invkind(ITypeInfo *pTypeInfo, UINT method_index);
    490. 

  490. static VALUE ole_method_invoke_kind(ITypeInfo *pTypeInfo, UINT method_index);
    491. 

  491. static VALUE folemethod_invkind(VALUE self);
    492. 

  492. static VALUE folemethod_invoke_kind(VALUE self);
    493. 

  493. static VALUE ole_method_visible(ITypeInfo *pTypeInfo, UINT method_index);
    494. 

  494. static VALUE folemethod_visible(VALUE self);
    495. 

  495. static VALUE ole_method_event(ITypeInfo *pTypeInfo, UINT method_index, VALUE method_name);
    496. 

  496. static VALUE folemethod_event(VALUE self);
    497. 

  497. static VALUE folemethod_event_interface(VALUE self);
    498. 

  498. static VALUE ole_method_docinfo_from_type(ITypeInfo *pTypeInfo, UINT method_index, BSTR *name, BSTR *helpstr, DWORD *helpcontext, BSTR *helpfile);
    499. 

  499. static VALUE ole_method_helpstring(ITypeInfo *pTypeInfo, UINT method_index);
    500. 

  500. static VALUE folemethod_helpstring(VALUE self);
    501. 

  501. static VALUE ole_method_helpfile(ITypeInfo *pTypeInfo, UINT method_index);
    502. 

  502. static VALUE folemethod_helpfile(VALUE self);
    503. 

  503. static VALUE ole_method_helpcontext(ITypeInfo *pTypeInfo, UINT method_index);
    504. 

  504. static VALUE folemethod_helpcontext(VALUE self);
    505. 

  505. static VALUE ole_method_dispid(ITypeInfo *pTypeInfo, UINT method_index);
    506. 

  506. static VALUE folemethod_dispid(VALUE self);
    507. 

  507. static VALUE ole_method_offset_vtbl(ITypeInfo *pTypeInfo, UINT method_index);
    508. 

  508. static VALUE folemethod_offset_vtbl(VALUE self);
    509. 

  509. static VALUE ole_method_size_params(ITypeInfo *pTypeInfo, UINT method_index);
    510. 

  510. static VALUE folemethod_size_params(VALUE self);
    511. 

  511. static VALUE ole_method_size_opt_params(ITypeInfo *pTypeInfo, UINT method_index);
    512. 

  512. static VALUE folemethod_size_opt_params(VALUE self);
    513. 

  513. static VALUE ole_method_params(ITypeInfo *pTypeInfo, UINT method_index);
    514. 

  514. static VALUE folemethod_params(VALUE self);
    515. 

  515. static VALUE folemethod_inspect(VALUE self);
    516. 

  516. static VALUE foleparam_s_allocate(VALUE klass);
    517. 

  517. static VALUE oleparam_ole_param_from_index(VALUE self, ITypeInfo *pTypeInfo, UINT method_index, int param_index);
    518. 

  518. static VALUE oleparam_ole_param(VALUE self, VALUE olemethod, int n);
    519. 

  519. static VALUE foleparam_initialize(VALUE self, VALUE olemethod, VALUE n);
    520. 

  520. static VALUE foleparam_name(VALUE self);
    521. 

  521. static VALUE ole_param_ole_type(ITypeInfo *pTypeInfo, UINT method_index, UINT index);
    522. 

  522. static VALUE foleparam_ole_type(VALUE self);
    523. 

  523. static VALUE ole_param_ole_type_detail(ITypeInfo *pTypeInfo, UINT method_index, UINT index);
    524. 

  524. static VALUE foleparam_ole_type_detail(VALUE self);
    525. 

  525. static VALUE ole_param_flag_mask(ITypeInfo *pTypeInfo, UINT method_index, UINT index, USHORT mask);
    526. 

  526. static VALUE foleparam_input(VALUE self);
    527. 

  527. static VALUE foleparam_output(VALUE self);
    528. 

  528. static VALUE foleparam_optional(VALUE self);
    529. 

  529. static VALUE foleparam_retval(VALUE self);
    530. 

  530. static VALUE ole_param_default(ITypeInfo *pTypeInfo, UINT method_index, UINT index);
    531. 

  531. static VALUE foleparam_default(VALUE self);
    532. 

  532. static VALUE foleparam_inspect(VALUE self);
    533. 

  533. static long ole_search_event_at(VALUE ary, VALUE ev);
    534. 

  534. static VALUE ole_search_event(VALUE ary, VALUE ev, BOOL  *is_default);
    535. 

  535. static VALUE ole_search_handler_method(VALUE handler, VALUE ev, BOOL *is_default_handler);
    536. 

  536. static void ole_delete_event(VALUE ary, VALUE ev);
    537. 

  537. static void hash2ptr_dispparams(VALUE hash, ITypeInfo *pTypeInfo, DISPID dispid, DISPPARAMS *pdispparams);
    538. 

  538. static VALUE hash2result(VALUE hash);
    539. 

  539. static void ary2ptr_dispparams(VALUE ary, DISPPARAMS *pdispparams);
    540. 

  540. static VALUE exec_callback(VALUE arg);
    541. 

  541. static VALUE rescue_callback(VALUE arg);
    542. 

  542. static HRESULT find_iid(VALUE ole, char *pitf, IID *piid, ITypeInfo **ppTypeInfo);
    543. 

  543. static HRESULT find_coclass(ITypeInfo *pTypeInfo, TYPEATTR *pTypeAttr, ITypeInfo **pTypeInfo2, TYPEATTR **pTypeAttr2);
    544. 

  544. static HRESULT find_default_source_from_typeinfo(ITypeInfo *pTypeInfo, TYPEATTR *pTypeAttr, ITypeInfo **ppTypeInfo);
    545. 

  545. static HRESULT find_default_source(VALUE ole, IID *piid, ITypeInfo **ppTypeInfo);
    546. 

  546. static void ole_event_free(struct oleeventdata *poleev);
    547. 

  547. static VALUE fev_s_allocate(VALUE klass);
    548. 

  548. static VALUE ev_advise(int argc, VALUE *argv, VALUE self);
    549. 

  549. static VALUE fev_initialize(int argc, VALUE *argv, VALUE self);
    550. 

  550. static VALUE fev_s_msg_loop(VALUE klass);
    551. 

  551. static void add_event_call_back(VALUE obj, VALUE event, VALUE data);
    552. 

  552. static VALUE ev_on_event(int argc, VALUE *argv, VALUE self, VALUE is_ary_arg);
    553. 

  553. static VALUE fev_on_event(int argc, VALUE *argv, VALUE self);
    554. 

  554. static VALUE fev_on_event_with_outargs(int argc, VALUE *argv, VALUE self);
    555. 

  555. static VALUE fev_off_event(int argc, VALUE *argv, VALUE self);
    556. 

  556. static VALUE fev_unadvise(VALUE self);
    557. 

  557. static VALUE fev_set_handler(VALUE self, VALUE val);
    558. 

  558. static VALUE fev_get_handler(VALUE self);
    559. 

  559. static VALUE evs_push(VALUE ev);
    560. 

  560. static VALUE evs_delete(long i);
    561. 

  561. static VALUE evs_entry(long i);
    562. 

  562. static VALUE evs_length();
    563. 

  563. static void  olevariant_free(struct olevariantdata *pvar);
    564. 

  564. static VALUE folevariant_s_allocate(VALUE klass);
    565. 

  565. static VALUE folevariant_s_array(VALUE klass, VALUE dims, VALUE vvt);
    566. 

  566. static VALUE folevariant_initialize(VALUE self, VALUE args);
    567. 

  567. static long *ary2safe_array_index(int ary_size, VALUE *ary, SAFEARRAY *psa);
    568. 

  568. static void unlock_safe_array(SAFEARRAY *psa);
    569. 

  569. static SAFEARRAY *get_locked_safe_array(VALUE val);
    570. 

  570. static VALUE folevariant_ary_aref(int argc, VALUE *argv, VALUE self);
    571. 

  571. static VOID * val2variant_ptr(VALUE val, VARIANT *var, VARTYPE vt);
    572. 

  572. static VALUE folevariant_ary_aset(int argc, VALUE *argv, VALUE self);
    573. 

  573. static VALUE folevariant_value(VALUE self);
    574. 

  574. static VALUE folevariant_vartype(VALUE self);
    575. 

  575. static VALUE folevariant_set_value(VALUE self, VALUE val);
    576. 

  576. static void init_enc2cp();
    577. 

  577. static void free_enc2cp();
    578. 

  578.   
    579. 

  579. static HRESULT (STDMETHODCALLTYPE mf_QueryInterface)(
    580. 

  580.     IMessageFilter __RPC_FAR * This,
    581. 

  581.     /* [in] */ REFIID riid,
    582. 

  582.     /* [iid_is][out] */ void __RPC_FAR *__RPC_FAR *ppvObject)
    583. 

  583. {
    584. 

  584.     if (MEMCMP(riid, &IID_IUnknown, GUID, 1) == 0
    585. 

  585.         || MEMCMP(riid, &IID_IMessageFilter, GUID, 1) == 0)
    586. 

  586.     {
    587. 

  587.         *ppvObject = &message_filter;
    588. 

  588.         return S_OK;
    589. 

  589.     }
    590. 

  590.     return E_NOINTERFACE;
    591. 

  591. }
    592. 

  592. 

  593. static ULONG (STDMETHODCALLTYPE mf_AddRef)( 
    594. 

  594.     IMessageFilter __RPC_FAR * This)
    595. 

  595. {
    596. 

  596.     return 1;
    597. 

  597. }
    598. 

  598.         
    599. 

  599. static ULONG (STDMETHODCALLTYPE mf_Release)( 
    600. 

  600.     IMessageFilter __RPC_FAR * This)
    601. 

  601. {
    602. 

  602.     return 1;
    603. 

  603. }
    604. 

  604. 

  605. static DWORD (STDMETHODCALLTYPE mf_HandleInComingCall)(
    606. 

  606.     IMessageFilter __RPC_FAR * pThis,
    607. 

  607.     DWORD dwCallType,      //Type of incoming call
    608. 

  608.     HTASK threadIDCaller,  //Task handle calling this task
    609. 

  609.     DWORD dwTickCount,     //Elapsed tick count
    610. 

  610.     LPINTERFACEINFO lpInterfaceInfo //Pointer to INTERFACEINFO structure
    611. 

  611.     )
    612. 

  612. {
    613. 

  613. #ifdef DEBUG_MESSAGEFILTER
    614. 

  614.     printf("incoming %08X, %08X, %d\n", dwCallType, threadIDCaller, dwTickCount);
    615. 

  615.     fflush(stdout);
    616. 

  616. #endif
    617. 

  617.     switch (dwCallType)
    618. 

  618.     {
    619. 

  619.     case CALLTYPE_ASYNC:
    620. 

  620.     case CALLTYPE_TOPLEVEL_CALLPENDING:
    621. 

  621.     case CALLTYPE_ASYNC_CALLPENDING:
    622. 

  622.         if (rb_during_gc()) {
    623. 

  623.             return SERVERCALL_RETRYLATER;
    624. 

  624.         }
    625. 

  625.         break;
    626. 

  626.     default:
    627. 

  627.         break;
    628. 

  628.     }
    629. 

  629.     if (previous_filter) {
    630. 

  630.         return previous_filter->lpVtbl->HandleInComingCall(previous_filter,
    631. 

  631.                                                    dwCallType,
    632. 

  632.                                                    threadIDCaller,
    633. 

  633.                                                    dwTickCount,
    634. 

  634.                                                    lpInterfaceInfo);
    635. 

  635.     }
    636. 

  636.     return SERVERCALL_ISHANDLED;
    637. 

  637. }
    638. 

  638. 

  639. static DWORD (STDMETHODCALLTYPE mf_RetryRejectedCall)(
    640. 

  640.     IMessageFilter* pThis,
    641. 

  641.     HTASK threadIDCallee,  //Server task handle
    642. 

  642.     DWORD dwTickCount,     //Elapsed tick count
    643. 

  643.     DWORD dwRejectType     //Returned rejection message
    644. 

  644.     )
    645. 

  645. {
    646. 

  646.     if (previous_filter) {
    647. 

  647.         return previous_filter->lpVtbl->RetryRejectedCall(previous_filter,
    648. 

  648.                                                   threadIDCallee,
    649. 

  649.                                                   dwTickCount,
    650. 

  650.                                                   dwRejectType);
    651. 

  651.     }
    652. 

  652.     return 1000;
    653. 

  653. }
    654. 

  654. 

  655. static DWORD (STDMETHODCALLTYPE mf_MessagePending)(
    656. 

  656.     IMessageFilter* pThis,
    657. 

  657.     HTASK threadIDCallee,  //Called applications task handle
    658. 

  658.     DWORD dwTickCount,     //Elapsed tick count
    659. 

  659.     DWORD dwPendingType    //Call type
    660. 

  660.     )
    661. 

  661. {
    662. 

  662.     if (rb_during_gc()) {
    663. 

  663.         return PENDINGMSG_WAITNOPROCESS;
    664. 

  664.     }
    665. 

  665.     if (previous_filter) {
    666. 

  666.         return previous_filter->lpVtbl->MessagePending(previous_filter,
    667. 

  667.                                                threadIDCallee,
    668. 

  668.                                                dwTickCount,
    669. 

  669.                                                dwPendingType);
    670. 

  670.     }
    671. 

  671.     return PENDINGMSG_WAITNOPROCESS;
    672. 

  672. }
    673. 

  673.     
    674. 

  674. typedef struct _Win32OLEIDispatch
    675. 

  675. {
    676. 

  676.     IDispatch dispatch;
    677. 

  677.     ULONG refcount;
    678. 

  678.     VALUE obj;
    679. 

  679. } Win32OLEIDispatch;
    680. 

  680. 

  681. static HRESULT ( STDMETHODCALLTYPE QueryInterface )( 
    682. 

  682.     IDispatch __RPC_FAR * This,
    683. 

  683.     /* [in] */ REFIID riid,
    684. 

  684.     /* [iid_is][out] */ void __RPC_FAR *__RPC_FAR *ppvObject)
    685. 

  685. {
    686. 

  686.     if (MEMCMP(riid, &IID_IUnknown, GUID, 1) == 0
    687. 

  687.         || MEMCMP(riid, &IID_IDispatch, GUID, 1) == 0)
    688. 

  688.     {
    689. 

  689.         Win32OLEIDispatch* p = (Win32OLEIDispatch*)This;
    690. 

  690.         p->refcount++;
    691. 

  691.         *ppvObject = This;
    692. 

  692.         return S_OK;
    693. 

  693.     }
    694. 

  694.     return E_NOINTERFACE;
    695. 

  695. }
    696. 

  696.         
    697. 

  697. static ULONG ( STDMETHODCALLTYPE AddRef )( 
    698. 

  698.     IDispatch __RPC_FAR * This)
    699. 

  699. {
    700. 

  700.     Win32OLEIDispatch* p = (Win32OLEIDispatch*)This;
    701. 

  701.     return ++(p->refcount);
    702. 

  702. }
    703. 

  703.         
    704. 

  704. static ULONG ( STDMETHODCALLTYPE Release )( 
    705. 

  705.     IDispatch __RPC_FAR * This)
    706. 

  706. {
    707. 

  707.     Win32OLEIDispatch* p = (Win32OLEIDispatch*)This;
    708. 

  708.     ULONG u = --(p->refcount);
    709. 

  709.     if (u == 0) {
    710. 

  710.         st_data_t key = p->obj;
    711. 

  711.         st_delete(DATA_PTR(com_hash), &key, 0);
    712. 

  712.         free(p);
    713. 

  713.     }
    714. 

  714.     return u;
    715. 

  715. }
    716. 

  716.         
    717. 

  717. static HRESULT ( STDMETHODCALLTYPE GetTypeInfoCount )( 
    718. 

  718.     IDispatch __RPC_FAR * This,
    719. 

  719.     /* [out] */ UINT __RPC_FAR *pctinfo)
    720. 

  720. {
    721. 

  721.     return E_NOTIMPL;
    722. 

  722. }
    723. 

  723.         
    724. 

  724. static HRESULT ( STDMETHODCALLTYPE GetTypeInfo )( 
    725. 

  725.     IDispatch __RPC_FAR * This,
    726. 

  726.     /* [in] */ UINT iTInfo,
    727. 

  727.     /* [in] */ LCID lcid,
    728. 

  728.     /* [out] */ ITypeInfo __RPC_FAR *__RPC_FAR *ppTInfo)
    729. 

  729. {
    730. 

  730.     return E_NOTIMPL;
    731. 

  731. }
    732. 

  732. 

  733.         
    734. 

  734. static HRESULT ( STDMETHODCALLTYPE GetIDsOfNames )( 
    735. 

  735.     IDispatch __RPC_FAR * This,
    736. 

  736.     /* [in] */ REFIID riid,
    737. 

  737.     /* [size_is][in] */ LPOLESTR __RPC_FAR *rgszNames,
    738. 

  738.     /* [in] */ UINT cNames,
    739. 

  739.     /* [in] */ LCID lcid,
    740. 

  740.     /* [size_is][out] */ DISPID __RPC_FAR *rgDispId)
    741. 

  741. {
    742. 

  742.     /*
    743. 

  743.     Win32OLEIDispatch* p = (Win32OLEIDispatch*)This;
    744. 

  744.     */
    745. 

  745.     char* psz = ole_wc2mb(*rgszNames); // support only one method
    746. 

  746.     *rgDispId = rb_intern(psz);
    747. 

  747.     free(psz);
    748. 

  748.     return S_OK;
    749. 

  749. }
    750. 

  750.         
    751. 

  751. static /* [local] */ HRESULT ( STDMETHODCALLTYPE Invoke )( 
    752. 

  752.     IDispatch __RPC_FAR * This,
    753. 

  753.     /* [in] */ DISPID dispIdMember,
    754. 

  754.     /* [in] */ REFIID riid,
    755. 

  755.     /* [in] */ LCID lcid,
    756. 

  756.     /* [in] */ WORD wFlags,
    757. 

  757.     /* [out][in] */ DISPPARAMS __RPC_FAR *pDispParams,
    758. 

  758.     /* [out] */ VARIANT __RPC_FAR *pVarResult,
    759. 

  759.     /* [out] */ EXCEPINFO __RPC_FAR *pExcepInfo,
    760. 

  760.     /* [out] */ UINT __RPC_FAR *puArgErr)
    761. 

  761. {
    762. 

  762.     VALUE v;
    763. 

  763.     int i;
    764. 

  764.     int args = pDispParams->cArgs;
    765. 

  765.     Win32OLEIDispatch* p = (Win32OLEIDispatch*)This;
    766. 

  766.     VALUE* parg = ALLOCA_N(VALUE, args);
    767. 

  767.     for (i = 0; i < args; i++) {
    768. 

  768.         *(parg + i) = ole_variant2val(&pDispParams->rgvarg[args - i - 1]);
    769. 

  769.     }
    770. 

  770.     if (dispIdMember == DISPID_VALUE) {
    771. 

  771.         if (wFlags == DISPATCH_METHOD) {
    772. 

  772.             dispIdMember = rb_intern("call");
    773. 

  773.         } else if (wFlags & DISPATCH_PROPERTYGET) {
    774. 

  774.             dispIdMember = rb_intern("value");
    775. 

  775.         }
    776. 

  776.     }
    777. 

  777.     v = rb_funcall2(p->obj, dispIdMember, args, parg);
    778. 

  778.     ole_val2variant(v, pVarResult);
    779. 

  779.     return S_OK;
    780. 

  780. }
    781. 

  781. 

  782. static IDispatch*
    783. 

  783. val2dispatch(VALUE val)
    784. 

  784. {
    785. 

  785.     struct st_table *tbl = DATA_PTR(com_hash);
    786. 

  786.     Win32OLEIDispatch* pdisp;
    787. 

  787.     st_data_t data;
    788. 

  788. 

  789.     if (st_lookup(tbl, val, &data)) {
    790. 

  790.         pdisp = (Win32OLEIDispatch *)(data & ~FIXNUM_FLAG);
    791. 

  791.         pdisp->refcount++;
    792. 

  792.     }
    793. 

  793.     else {
    794. 

  794.         pdisp = ALLOC(Win32OLEIDispatch);
    795. 

  795.         pdisp->dispatch.lpVtbl = &com_vtbl;
    796. 

  796.         pdisp->refcount = 1;
    797. 

  797.         pdisp->obj = val;
    798. 

  798.         st_insert(tbl, val, (VALUE)pdisp | FIXNUM_FLAG);
    799. 

  799.     }
    800. 

  800.     return &pdisp->dispatch;
    801. 

  801. }
    802. 

  802. 

  803. static double
    804. 

  804. rbtime2vtdate(VALUE tmobj)
    805. 

  805. {
    806. 

  806.     SYSTEMTIME st;
    807. 

  807.     double t = 0;
    808. 

  808.     memset(&st, 0, sizeof(SYSTEMTIME));
    809. 

  809.     st.wYear = FIX2INT(rb_funcall(tmobj, rb_intern("year"), 0));
    810. 

  810.     st.wMonth = FIX2INT(rb_funcall(tmobj, rb_intern("month"), 0));
    811. 

  811.     st.wDay = FIX2INT(rb_funcall(tmobj, rb_intern("mday"), 0));
    812. 

  812.     st.wHour = FIX2INT(rb_funcall(tmobj, rb_intern("hour"), 0));
    813. 

  813.     st.wMinute = FIX2INT(rb_funcall(tmobj, rb_intern("min"), 0));
    814. 

  814.     st.wSecond = FIX2INT(rb_funcall(tmobj, rb_intern("sec"), 0));
    815. 

  815.     st.wMilliseconds = FIX2INT(rb_funcall(tmobj, rb_intern("nsec"), 0)) / 1000000;
    816. 

  816.     SystemTimeToVariantTime(&st, &t);
    817. 

  817.     return t;
    818. 

  818. }
    819. 

  819. 

  820. static VALUE
    821. 

  821. vtdate2rbtime(double date)
    822. 

  822. {
    823. 

  823.     SYSTEMTIME st;
    824. 

  824.     VALUE v;
    825. 

  825.     VariantTimeToSystemTime(date, &st);
    826. 

  826. 

  827.     v = rb_funcall(rb_cTime, rb_intern("new"), 6,
    828. 

  828. 		      INT2FIX(st.wYear),
    829. 

  829. 		      INT2FIX(st.wMonth),
    830. 

  830. 		      INT2FIX(st.wDay),
    831. 

  831. 		      INT2FIX(st.wHour),
    832. 

  832. 		      INT2FIX(st.wMinute),
    833. 

  833. 		      INT2FIX(st.wSecond));
    834. 

  834.     if (st.wMilliseconds > 0) {
    835. 

  835. 	return rb_funcall(v, rb_intern("+"), 1, rb_float_new((double)(st.wMilliseconds / 1000.0)));
    836. 

  836.     }
    837. 

  837.     return v;
    838. 

  838. }
    839. 

  839. 

  840. #define ENC_MACHING_CP(enc,encname,cp) if(strcasecmp(rb_enc_name((enc)),(encname)) == 0) return cp
    841. 

  841. 

  842. static UINT ole_encoding2cp(rb_encoding *enc)
    843. 

  843. {
    844. 

  844.     /*
    845. 

  845.      * Is there any better solution to convert 
    846. 

  846.      * Ruby encoding to Windows codepage???
    847. 

  847.      */
    848. 

  848.     ENC_MACHING_CP(enc, "Big5", 950);
    849. 

  849.     ENC_MACHING_CP(enc, "CP51932", 51932);
    850. 

  850.     ENC_MACHING_CP(enc, "CP850", 850);
    851. 

  851.     ENC_MACHING_CP(enc, "CP852", 852);
    852. 

  852.     ENC_MACHING_CP(enc, "CP855", 855);
    853. 

  853.     ENC_MACHING_CP(enc, "CP949", 949);
    854. 

  854.     ENC_MACHING_CP(enc, "EUC-JP", 20932); 
    855. 

  855.     ENC_MACHING_CP(enc, "EUC-KR", 51949);
    856. 

  856.     ENC_MACHING_CP(enc, "EUC-TW", 51950);
    857. 

  857.     ENC_MACHING_CP(enc, "GB18030", 54936);
    858. 

  858.     ENC_MACHING_CP(enc, "GB2312", 51936);
    859. 

  859.     ENC_MACHING_CP(enc, "GBK", 936);
    860. 

  860.     ENC_MACHING_CP(enc, "IBM437", 437);
    861. 

  861.     ENC_MACHING_CP(enc, "IBM737", 737);
    862. 

  862.     ENC_MACHING_CP(enc, "IBM775", 775);
    863. 

  863.     ENC_MACHING_CP(enc, "IBM852", 852);
    864. 

  864.     ENC_MACHING_CP(enc, "IBM855", 855);
    865. 

  865.     ENC_MACHING_CP(enc, "IBM857", 857);
    866. 

  866.     ENC_MACHING_CP(enc, "IBM860", 860);
    867. 

  867.     ENC_MACHING_CP(enc, "IBM861", 861);
    868. 

  868.     ENC_MACHING_CP(enc, "IBM862", 862);
    869. 

  869.     ENC_MACHING_CP(enc, "IBM863", 863);
    870. 

  870.     ENC_MACHING_CP(enc, "IBM864", 864);
    871. 

  871.     ENC_MACHING_CP(enc, "IBM865", 865);
    872. 

  872.     ENC_MACHING_CP(enc, "IBM866", 866);
    873. 

  873.     ENC_MACHING_CP(enc, "IBM869", 869);
    874. 

  874.     ENC_MACHING_CP(enc, "ISO-2022-JP", 50220);
    875. 

  875.     ENC_MACHING_CP(enc, "ISO-8859-1", 28591);
    876. 

  876.     ENC_MACHING_CP(enc, "ISO-8859-15", 28605);
    877. 

  877.     ENC_MACHING_CP(enc, "ISO-8859-2", 28592);
    878. 

  878.     ENC_MACHING_CP(enc, "ISO-8859-3", 28593);
    879. 

  879.     ENC_MACHING_CP(enc, "ISO-8859-4", 28594);
    880. 

  880.     ENC_MACHING_CP(enc, "ISO-8859-5", 28595);
    881. 

  881.     ENC_MACHING_CP(enc, "ISO-8859-6", 28596);
    882. 

  882.     ENC_MACHING_CP(enc, "ISO-8859-7", 28597);
    883. 

  883.     ENC_MACHING_CP(enc, "ISO-8859-8", 28598);
    884. 

  884.     ENC_MACHING_CP(enc, "ISO-8859-9", 28599);
    885. 

  885.     ENC_MACHING_CP(enc, "KOI8-R", 20866);
    886. 

  886.     ENC_MACHING_CP(enc, "KOI8-U", 21866);
    887. 

  887.     ENC_MACHING_CP(enc, "Shift_JIS", 932);
    888. 

  888.     ENC_MACHING_CP(enc, "UTF-16BE", 1201);
    889. 

  889.     ENC_MACHING_CP(enc, "UTF-16LE", 1200);
    890. 

  890.     ENC_MACHING_CP(enc, "UTF-7", 65000);
    891. 

  891.     ENC_MACHING_CP(enc, "UTF-8", 65001);
    892. 

  892.     ENC_MACHING_CP(enc, "Windows-1250", 1250);
    893. 

  893.     ENC_MACHING_CP(enc, "Windows-1251", 1251);
    894. 

  894.     ENC_MACHING_CP(enc, "Windows-1252", 1252);
    895. 

  895.     ENC_MACHING_CP(enc, "Windows-1253", 1253);
    896. 

  896.     ENC_MACHING_CP(enc, "Windows-1254", 1254);
    897. 

  897.     ENC_MACHING_CP(enc, "Windows-1255", 1255);
    898. 

  898.     ENC_MACHING_CP(enc, "Windows-1256", 1256);
    899. 

  899.     ENC_MACHING_CP(enc, "Windows-1257", 1257);
    900. 

  900.     ENC_MACHING_CP(enc, "Windows-1258", 1258);
    901. 

  901.     ENC_MACHING_CP(enc, "Windows-31J", 932);
    902. 

  902.     ENC_MACHING_CP(enc, "Windows-874", 874);
    903. 

  903.     ENC_MACHING_CP(enc, "eucJP-ms", 20932);
    904. 

  904.     return CP_ACP;
    905. 

  905. }
    906. 

  906. 

  907. static void
    908. 

  908. failed_load_conv51932(void)
    909. 

  909. {
    910. 

  910.     rb_raise(eWIN32OLERuntimeError, "fail to load convert function for CP51932");
    911. 

  911. }
    912. 

  912. 

  913. #ifndef pIMultiLanguage
    914. 

  914. static void
    915. 

  915. load_conv_function51932(void)
    916. 

  916. {
    917. 

  917.     HRESULT hr = E_NOINTERFACE;
    918. 

  918.     void *p;
    919. 

  919.     if (!pIMultiLanguage) {
    920. 

  920. #if defined(HAVE_TYPE_IMULTILANGUAGE2)
    921. 

  921. 	hr = CoCreateInstance(&CLSID_CMultiLanguage, NULL, CLSCTX_INPROC_SERVER,
    922. 

  922. 		              &IID_IMultiLanguage2, &p);
    923. 

  923. #elif defined(HAVE_TYPE_IMULTILANGUAGE)
    924. 

  924. 	hr = CoCreateInstance(&CLSID_CMultiLanguage, NULL, CLSCTX_INPROC_SERVER,
    925. 

  925. 		              &IID_IMultiLanguage, &p);
    926. 

  926. #endif
    927. 

  927. 	if (FAILED(hr)) {
    928. 

  928. 	    failed_load_conv51932();
    929. 

  929. 	}
    930. 

  930. 	pIMultiLanguage = p;
    931. 

  931.     }
    932. 

  932. }
    933. 

  933. #else
    934. 

  934. #define load_conv_function51932() failed_load_conv51932()
    935. 

  935. #endif
    936. 

  936. 

  937. #define conv_51932(cp) ((cp) == 51932 && (load_conv_function51932(), 1))
    938. 

  938. 

  939. static void
    940. 

  940. set_ole_codepage(UINT cp)
    941. 

  941. {
    942. 

  942.     if (code_page_installed(cp)) {
    943. 

  943.         cWIN32OLE_cp = cp;
    944. 

  944.     } else {
    945. 

  945.         switch(cp) {
    946. 

  946.         case CP_ACP:
    947. 

  947.         case CP_OEMCP:
    948. 

  948.         case CP_MACCP:
    949. 

  949.         case CP_THREAD_ACP:
    950. 

  950.         case CP_SYMBOL:
    951. 

  951.         case CP_UTF7:
    952. 

  952.         case CP_UTF8:
    953. 

  953.             cWIN32OLE_cp = cp;
    954. 

  954.             break;
    955. 

  955.         case 51932:
    956. 

  956.             cWIN32OLE_cp = cp;
    957. 

  957.             load_conv_function51932();
    958. 

  958.             break;
    959. 

  959.         default:
    960. 

  960.             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.");
    961. 

  961.             break;
    962. 

  962.         }
    963. 

  963.     }
    964. 

  964.     cWIN32OLE_enc = ole_cp2encoding(cWIN32OLE_cp);
    965. 

  965. }
    966. 

  966. 

  967. 

  968. static UINT
    969. 

  969. ole_init_cp(void)
    970. 

  970. {
    971. 

  971.     UINT cp;
    972. 

  972.     rb_encoding *encdef;
    973. 

  973.     encdef = rb_default_internal_encoding();
    974. 

  974.     if (!encdef) {
    975. 

  975. 	encdef = rb_default_external_encoding();
    976. 

  976.     }
    977. 

  977.     cp = ole_encoding2cp(encdef);
    978. 

  978.     set_ole_codepage(cp);
    979. 

  979.     return cp;
    980. 

  980. }
    981. 

  981. 

  982. struct myCPINFOEX {
    983. 

  983.   UINT MaxCharSize;
    984. 

  984.   BYTE DefaultChar[2];
    985. 

  985.   BYTE LeadByte[12];
    986. 

  986.   WCHAR UnicodeDefaultChar;
    987. 

  987.   UINT CodePage;
    988. 

  988.   char CodePageName[MAX_PATH];
    989. 

  989. };
    990. 

  990. 

  991. static rb_encoding *
    992. 

  992. ole_cp2encoding(UINT cp)
    993. 

  993. {
    994. 

  994.     static BOOL (*pGetCPInfoEx)(UINT, DWORD, struct myCPINFOEX *) = NULL;
    995. 

  995.     struct myCPINFOEX* buf;
    996. 

  996.     VALUE enc_name;
    997. 

  997.     char *enc_cstr;
    998. 

  998.     int idx;
    999. 

  999. 

  1000.     if (!code_page_installed(cp)) {
    1001. 

  1001. 	switch(cp) {
    1002. 

  1002. 	  case CP_ACP:
    1003. 

  1003. 	    cp = GetACP();
    1004. 

  1004. 	    break;
    1005. 

  1005. 	  case CP_OEMCP:
    1006. 

  1006. 	    cp = GetOEMCP();
    1007. 

  1007. 	    break;
    1008. 

  1008. 	  case CP_MACCP:
    1009. 

  1009. 	  case CP_THREAD_ACP:
    1010. 

  1010. 	    if (!pGetCPInfoEx) {
    1011. 

  1011. 		pGetCPInfoEx = (BOOL (*)(UINT, DWORD, struct myCPINFOEX *))
    1012. 

  1012. 		    GetProcAddress(GetModuleHandle("kernel32"), "GetCPInfoEx");
    1013. 

  1013. 		if (!pGetCPInfoEx) {
    1014. 

  1014. 		    pGetCPInfoEx = (void*)-1;
    1015. 

  1015. 		}
    1016. 

  1016. 	    }
    1017. 

  1017. 	    buf = ALLOCA_N(struct myCPINFOEX, 1);
    1018. 

  1018. 	    ZeroMemory(buf, sizeof(struct myCPINFOEX));
    1019. 

  1019. 	    if (pGetCPInfoEx == (void*)-1 || !pGetCPInfoEx(cp, 0, buf)) {
    1020. 

  1020. 		rb_raise(eWIN32OLERuntimeError, "cannot map codepage to encoding.");
    1021. 

  1021. 		break;	/* never reach here */
    1022. 

  1022. 	    }
    1023. 

  1023. 	    cp = buf->CodePage;
    1024. 

  1024. 	    break;
    1025. 

  1025. 	  case CP_SYMBOL:
    1026. 

  1026. 	  case CP_UTF7:
    1027. 

  1027. 	  case CP_UTF8:
    1028. 

  1028. 	    break;
    1029. 

  1029. 	  case 51932:  
    1030. 

  1030. 	    load_conv_function51932();
    1031. 

  1031. 	    break;
    1032. 

  1032. 	  default:
    1033. 

  1033.             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.");
    1034. 

  1034.             break;
    1035. 

  1035.         }
    1036. 

  1036.     }
    1037. 

  1037. 

  1038.     enc_name = rb_sprintf("CP%d", cp);
    1039. 

  1039.     idx = rb_enc_find_index(enc_cstr = StringValueCStr(enc_name));
    1040. 

  1040.     if (idx < 0)
    1041. 

  1041. 	idx = rb_define_dummy_encoding(enc_cstr);
    1042. 

  1042.     return rb_enc_from_index(idx);
    1043. 

  1043. }
    1044. 

  1044. 

  1045. static char *
    1046. 

  1046. ole_wc2mb(LPWSTR pw)
    1047. 

  1047. {
    1048. 

  1048.     LPSTR pm;
    1049. 

  1049.     int size = 0;
    1050. 

  1050.     if (conv_51932(cWIN32OLE_cp)) {
    1051. 

  1051. #ifndef pIMultiLanguage
    1052. 

  1052. 	DWORD dw = 0;
    1053. 

  1053. 	HRESULT hr = pIMultiLanguage->lpVtbl->ConvertStringFromUnicode(pIMultiLanguage,
    1054. 

  1054. 		&dw, cWIN32OLE_cp, pw, NULL, NULL, &size);
    1055. 

  1055. 	if (FAILED(hr)) {
    1056. 

  1056.             ole_raise(hr, eWIN32OLERuntimeError, "fail to convert Unicode to CP%d", cWIN32OLE_cp);
    1057. 

  1057. 	}
    1058. 

  1058. 	pm = ALLOC_N(char, size + 1);
    1059. 

  1059. 	hr = pIMultiLanguage->lpVtbl->ConvertStringFromUnicode(pIMultiLanguage,
    1060. 

  1060. 		&dw, cWIN32OLE_cp, pw, NULL, pm, &size);
    1061. 

  1061. 	if (FAILED(hr)) {
    1062. 

  1062.             ole_raise(hr, eWIN32OLERuntimeError, "fail to convert Unicode to CP%d", cWIN32OLE_cp);
    1063. 

  1063. 	}
    1064. 

  1064. 	pm[size] = '\0';
    1065. 

  1065. #endif
    1066. 

  1066.         return pm;
    1067. 

  1067.     }
    1068. 

  1068.     size = WideCharToMultiByte(cWIN32OLE_cp, 0, pw, -1, NULL, 0, NULL, NULL);
    1069. 

  1069.     if (size) {
    1070. 

  1070.         pm = ALLOC_N(char, size + 1);    
    1071. 

  1071.         WideCharToMultiByte(cWIN32OLE_cp, 0, pw, -1, pm, size, NULL, NULL);
    1072. 

  1072.         pm[size] = '\0';
    1073. 

  1073.     }
    1074. 

  1074.     else {
    1075. 

  1075.         pm = ALLOC_N(char, 1);
    1076. 

  1076.         *pm = '\0';
    1077. 

  1077.     }
    1078. 

  1078.     return pm;
    1079. 

  1079. } 
    1080. 

  1080. 

  1081. static VALUE
    1082. 

  1082. ole_hresult2msg(HRESULT hr)
    1083. 

  1083. {
    1084. 

  1084.     VALUE msg = Qnil;
    1085. 

  1085.     char *p_msg = NULL;
    1086. 

  1086.     char *term = NULL;
    1087. 

  1087.     DWORD dwCount;
    1088. 

  1088. 

  1089.     char strhr[100];
    1090. 

  1090.     sprintf(strhr, "    HRESULT error code:0x%08x\n      ", (unsigned)hr);
    1091. 

  1091.     msg = rb_str_new2(strhr);
    1092. 

  1092. 

  1093.     dwCount = FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER |
    1094. 

  1094.                             FORMAT_MESSAGE_FROM_SYSTEM |
    1095. 

  1095.                             FORMAT_MESSAGE_IGNORE_INSERTS,
    1096. 

  1096.                             NULL, hr, cWIN32OLE_lcid,
    1097. 

  1097.                             (LPTSTR)&p_msg, 0, NULL);
    1098. 

  1098.     if (dwCount > 0) {
    1099. 

  1099. 	term = p_msg + strlen(p_msg);
    1100. 

  1100. 	while (p_msg < term) {
    1101. 

  1101. 	    term--;
    1102. 

  1102. 	    if (*term == '\r' || *term == '\n')
    1103. 

  1103. 	        *term = '\0';
    1104. 

  1104. 	    else break;
    1105. 

  1105. 	}
    1106. 

  1106.         if (p_msg[0] != '\0') {
    1107. 

  1107.             rb_str_cat2(msg, p_msg);
    1108. 

  1108.         }
    1109. 

  1109.     }
    1110. 

  1110.     LocalFree(p_msg);
    1111. 

  1111.     return msg;
    1112. 

  1112. }
    1113. 

  1113. 

  1114. static void
    1115. 

  1115. ole_freeexceptinfo(EXCEPINFO *pExInfo)
    1116. 

  1116. {
    1117. 

  1117.     SysFreeString(pExInfo->bstrDescription);
    1118. 

  1118.     SysFreeString(pExInfo->bstrSource);
    1119. 

  1119.     SysFreeString(pExInfo->bstrHelpFile);
    1120. 

  1120. }
    1121. 

  1121. 

  1122. static VALUE
    1123. 

  1123. ole_excepinfo2msg(EXCEPINFO *pExInfo)
    1124. 

  1124. {
    1125. 

  1125.     char error_code[40];
    1126. 

  1126.     char *pSource = NULL;
    1127. 

  1127.     char *pDescription = NULL;
    1128. 

  1128.     VALUE error_msg;
    1129. 

  1129.     if(pExInfo->pfnDeferredFillIn != NULL) {
    1130. 

  1130.         (*pExInfo->pfnDeferredFillIn)(pExInfo);
    1131. 

  1131.     }
    1132. 

  1132.     if (pExInfo->bstrSource != NULL) {
    1133. 

  1133.         pSource = ole_wc2mb(pExInfo->bstrSource);
    1134. 

  1134.     }
    1135. 

  1135.     if (pExInfo->bstrDescription != NULL) {
    1136. 

  1136.         pDescription = ole_wc2mb(pExInfo->bstrDescription);
    1137. 

  1137.     }
    1138. 

  1138.     if(pExInfo->wCode == 0) {
    1139. 

  1139.         sprintf(error_code, "\n    OLE error code:%lX in ", pExInfo->scode);
    1140. 

  1140.     }
    1141. 

  1141.     else{
    1142. 

  1142.         sprintf(error_code, "\n    OLE error code:%u in ", pExInfo->wCode);
    1143. 

  1143.     }
    1144. 

  1144.     error_msg = rb_str_new2(error_code);
    1145. 

  1145.     if(pSource != NULL) {
    1146. 

  1146.         rb_str_cat(error_msg, pSource, strlen(pSource));
    1147. 

  1147.     }
    1148. 

  1148.     else {
    1149. 

  1149.         rb_str_cat(error_msg, "<Unknown>", 9);
    1150. 

  1150.     }
    1151. 

  1151.     rb_str_cat2(error_msg, "\n      ");
    1152. 

  1152.     if(pDescription != NULL) {
    1153. 

  1153.         rb_str_cat2(error_msg, pDescription);
    1154. 

  1154.     }
    1155. 

  1155.     else {
    1156. 

  1156.         rb_str_cat2(error_msg, "<No Description>");
    1157. 

  1157.     }
    1158. 

  1158.     if(pSource) free(pSource);
    1159. 

  1159.     if(pDescription) free(pDescription);
    1160. 

  1160.     ole_freeexceptinfo(pExInfo);
    1161. 

  1161.     return error_msg;
    1162. 

  1162. }
    1163. 

  1163. 

  1164. static void
    1165. 

  1165. ole_raise(HRESULT hr, VALUE ecs, const char *fmt, ...)
    1166. 

  1166. {
    1167. 

  1167.     va_list args;
    1168. 

  1168.     char buf[BUFSIZ];
    1169. 

  1169.     VALUE err_msg;
    1170. 

  1170.     va_init_list(args, fmt);
    1171. 

  1171.     vsnprintf(buf, BUFSIZ, fmt, args);
    1172. 

  1172.     va_end(args);
    1173. 

  1173. 

  1174.     err_msg = ole_hresult2msg(hr);
    1175. 

  1175.     if(err_msg != Qnil) {
    1176. 

  1176.         rb_raise(ecs, "%s\n%s", buf, StringValuePtr(err_msg));
    1177. 

  1177.     }
    1178. 

  1178.     else {
    1179. 

  1179.         rb_raise(ecs, "%s", buf);
    1180. 

  1180.     }
    1181. 

  1181. }
    1182. 

  1182. 

  1183. void
    1184. 

  1184. ole_uninitialize()
    1185. 

  1185. {
    1186. 

  1186.     OleUninitialize();
    1187. 

  1187.     g_ole_initialized = FALSE;
    1188. 

  1188. }
    1189. 

  1189. 

  1190. static void
    1191. 

  1191. ole_initialize() 
    1192. 

  1192. {
    1193. 

  1193.     HRESULT hr;
    1194. 

  1194.     
    1195. 

  1195.     if(g_ole_initialized == FALSE) {
    1196. 

  1196.         hr = OleInitialize(NULL);
    1197. 

  1197.         if(FAILED(hr)) {
    1198. 

  1198.             ole_raise(hr, rb_eRuntimeError, "fail: OLE initialize");
    1199. 

  1199.         }
    1200. 

  1200.         g_ole_initialized = TRUE;
    1201. 

  1201.         /*
    1202. 

  1202.          * In some situation, OleUninitialize does not work fine. ;-<
    1203. 

  1203.          */
    1204. 

  1204.         /*
    1205. 

  1205.         atexit((void (*)(void))ole_uninitialize);
    1206. 

  1206.         */
    1207. 

  1207.         hr = CoRegisterMessageFilter(&imessage_filter, &previous_filter);
    1208. 

  1208.         if(FAILED(hr)) {
    1209. 

  1209.             previous_filter = NULL;
    1210. 

  1210.             ole_raise(hr, rb_eRuntimeError, "fail: install OLE MessageFilter");
    1211. 

  1211.         }
    1212. 

  1212.     }
    1213. 

  1213. }
    1214. 

  1214. 

  1215. static void
    1216. 

  1216. ole_msg_loop() {
    1217. 

  1217.     MSG msg;
    1218. 

  1218.     while(PeekMessage(&msg,NULL,0,0,PM_REMOVE)) {
    1219. 

  1219.         TranslateMessage(&msg);
    1220. 

  1220.         DispatchMessage(&msg);
    1221. 

  1221.     }
    1222. 

  1222. }
    1223. 

  1223. 

  1224. static void
    1225. 

  1225. ole_free(struct oledata *pole)
    1226. 

  1226. {
    1227. 

  1227.     OLE_FREE(pole->pDispatch);
    1228. 

  1228.     free(pole);
    1229. 

  1229. }
    1230. 

  1230. 

  1231. static void
    1232. 

  1232. oletypelib_free(struct oletypelibdata *poletypelib)
    1233. 

  1233. {
    1234. 

  1234.     OLE_FREE(poletypelib->pTypeLib);
    1235. 

  1235.     free(poletypelib);
    1236. 

  1236. }
    1237. 

  1237. 

  1238. static void
    1239. 

  1239. oletype_free(struct oletypedata *poletype)
    1240. 

  1240. {
    1241. 

  1241.     OLE_FREE(poletype->pTypeInfo);
    1242. 

  1242.     free(poletype);
    1243. 

  1243. }
    1244. 

  1244. 

  1245. static void
    1246. 

  1246. olemethod_free(struct olemethoddata *polemethod)
    1247. 

  1247. {
    1248. 

  1248.     OLE_FREE(polemethod->pTypeInfo);
    1249. 

  1249.     OLE_FREE(polemethod->pOwnerTypeInfo);
    1250. 

  1250.     free(polemethod);
    1251. 

  1251. }
    1252. 

  1252. 

  1253. static void
    1254. 

  1254. olevariable_free(struct olevariabledata *polevar)
    1255. 

  1255. {
    1256. 

  1256.     OLE_FREE(polevar->pTypeInfo);
    1257. 

  1257.     free(polevar);
    1258. 

  1258. }
    1259. 

  1259. 

  1260. static void
    1261. 

  1261. oleparam_free(struct oleparamdata *pole)
    1262. 

  1262. {
    1263. 

  1263.     OLE_FREE(pole->pTypeInfo);
    1264. 

  1264.     free(pole);
    1265. 

  1265. }
    1266. 

  1266. 

  1267. 

  1268. static LPWSTR
    1269. 

  1269. ole_vstr2wc(VALUE vstr)
    1270. 

  1270. {
    1271. 

  1271.     rb_encoding *enc;
    1272. 

  1272.     int cp;
    1273. 

  1273.     int size = 0;
    1274. 

  1274.     LPWSTR pw;
    1275. 

  1275.     st_data_t data;
    1276. 

  1276.     enc = rb_enc_get(vstr);
    1277. 

  1277. 

  1278.     if (st_lookup(enc2cp_table, (st_data_t)enc, &data)) {
    1279. 

  1279.         cp = data;
    1280. 

  1280.     } else {
    1281. 

  1281.         cp = ole_encoding2cp(enc);
    1282. 

  1282.         if (code_page_installed(cp) ||
    1283. 

  1283.             cp == CP_ACP ||
    1284. 

  1284.             cp == CP_OEMCP ||
    1285. 

  1285.             cp == CP_MACCP ||
    1286. 

  1286.             cp == CP_THREAD_ACP ||
    1287. 

  1287.             cp == CP_SYMBOL ||
    1288. 

  1288.             cp == CP_UTF7 ||
    1289. 

  1289.             cp == CP_UTF8 ||
    1290. 

  1290.             cp == 51932) {
    1291. 

  1291.             st_insert(enc2cp_table, (st_data_t)enc, (st_data_t)cp);
    1292. 

  1292.         } else {
    1293. 

  1293.             rb_raise(eWIN32OLERuntimeError, "not installed Windows codepage(%d) according to `%s'", cp, rb_enc_name(enc));
    1294. 

  1294.         }
    1295. 

  1295.     }
    1296. 

  1296.     if (conv_51932(cp)) {
    1297. 

  1297. #ifndef pIMultiLanguage
    1298. 

  1298. 	DWORD dw = 0;
    1299. 

  1299. 	int len = RSTRING_LEN(vstr);
    1300. 

  1300. 	HRESULT hr = pIMultiLanguage->lpVtbl->ConvertStringToUnicode(pIMultiLanguage,
    1301. 

  1301. 		&dw, cp, RSTRING_PTR(vstr), &len, NULL, &size);
    1302. 

  1302. 	if (FAILED(hr)) {
    1303. 

  1303.             ole_raise(hr, eWIN32OLERuntimeError, "fail to convert CP%d to Unicode", cp);
    1304. 

  1304. 	}
    1305. 

  1305. 	pw = SysAllocStringLen(NULL, size);
    1306. 

  1306. 	len = RSTRING_LEN(vstr);
    1307. 

  1307. 	hr = pIMultiLanguage->lpVtbl->ConvertStringToUnicode(pIMultiLanguage,
    1308. 

  1308. 		&dw, cp, RSTRING_PTR(vstr), &len, pw, &size);
    1309. 

  1309. 	if (FAILED(hr)) {
    1310. 

  1310.             ole_raise(hr, eWIN32OLERuntimeError, "fail to convert CP%d to Unicode", cp);
    1311. 

  1311. 	}
    1312. 

  1312. #endif
    1313. 

  1313. 	return pw;
    1314. 

  1314.     }
    1315. 

  1315.     size = MultiByteToWideChar(cp, 0, RSTRING_PTR(vstr), RSTRING_LEN(vstr), NULL, 0);
    1316. 

  1316.     pw = SysAllocStringLen(NULL, size);
    1317. 

  1317.     MultiByteToWideChar(cp, 0, RSTRING_PTR(vstr), RSTRING_LEN(vstr), pw, size);
    1318. 

  1318.     return pw;
    1319. 

  1319. }
    1320. 

  1320. 

  1321. static LPWSTR
    1322. 

  1322. ole_mb2wc(char *pm, int len)
    1323. 

  1323. {
    1324. 

  1324.     int size = 0;
    1325. 

  1325.     LPWSTR pw;
    1326. 

  1326. 

  1327.     if (conv_51932(cWIN32OLE_cp)) {
    1328. 

  1328. #ifndef pIMultiLanguage
    1329. 

  1329. 	DWORD dw = 0;
    1330. 

  1330. 	int n = len;
    1331. 

  1331. 	HRESULT hr = pIMultiLanguage->lpVtbl->ConvertStringToUnicode(pIMultiLanguage,
    1332. 

  1332. 		&dw, cWIN32OLE_cp, pm, &n, NULL, &size);
    1333. 

  1333. 	if (FAILED(hr)) {
    1334. 

  1334.             ole_raise(hr, eWIN32OLERuntimeError, "fail to convert CP%d to Unicode", cWIN32OLE_cp);
    1335. 

  1335. 	}
    1336. 

  1336. 	pw = SysAllocStringLen(NULL, size);
    1337. 

  1337. 	hr = pIMultiLanguage->lpVtbl->ConvertStringToUnicode(pIMultiLanguage,
    1338. 

  1338. 		&dw, cWIN32OLE_cp, pm, &n, pw, &size);
    1339. 

  1339. 	if (FAILED(hr)) {
    1340. 

  1340.             ole_raise(hr, eWIN32OLERuntimeError, "fail to convert CP%d to Unicode", cWIN32OLE_cp);
    1341. 

  1341. 	}
    1342. 

  1342. #endif
    1343. 

  1343. 	return pw;
    1344. 

  1344.     }
    1345. 

  1345.     size = MultiByteToWideChar(cWIN32OLE_cp, 0, pm, len, NULL, 0);
    1346. 

  1346.     pw = SysAllocStringLen(NULL, size - 1);
    1347. 

  1347.     MultiByteToWideChar(cWIN32OLE_cp, 0, pm, len, pw, size);
    1348. 

  1348.     return pw;
    1349. 

  1349. }
    1350. 

  1350. 

  1351. static VALUE
    1352. 

  1352. ole_wc2vstr(LPWSTR pw, BOOL isfree)
    1353. 

  1353. {
    1354. 

  1354.     char *p = ole_wc2mb(pw);
    1355. 

  1355.     VALUE vstr = rb_enc_str_new(p, strlen(p), cWIN32OLE_enc);
    1356. 

  1356.     if(isfree)
    1357. 

  1357.         SysFreeString(pw);
    1358. 

  1358.     free(p);
    1359. 

  1359.     return vstr;
    1360. 

  1360. }
    1361. 

  1361. 

  1362. static VALUE
    1363. 

  1363. ole_ary_m_entry(VALUE val, long *pid)
    1364. 

  1364. {
    1365. 

  1365.     VALUE obj = Qnil;
    1366. 

  1366.     int i = 0;
    1367. 

  1367.     obj = val;
    1368. 

  1368.     while(TYPE(obj) == T_ARRAY) {
    1369. 

  1369.         obj = rb_ary_entry(obj, pid[i]);
    1370. 

  1370.         i++;
    1371. 

  1371.     }
    1372. 

  1372.     return obj;
    1373. 

  1373. }
    1374. 

  1374. 

  1375. static void *
    1376. 

  1376. get_ptr_of_variant(VARIANT *pvar)
    1377. 

  1377. {
    1378. 

  1378.     switch(V_VT(pvar)) {
    1379. 

  1379.     case VT_UI1:
    1380. 

  1380.         return &V_UI1(pvar);
    1381. 

  1381.         break;
    1382. 

  1382.     case VT_I2:
    1383. 

  1383.         return &V_I2(pvar);
    1384. 

  1384.         break;
    1385. 

  1385.     case VT_UI2:
    1386. 

  1386.         return &V_UI2(pvar);
    1387. 

  1387.         break;
    1388. 

  1388.     case VT_I4:
    1389. 

  1389.         return &V_I4(pvar);
    1390. 

  1390.         break;
    1391. 

  1391.     case VT_UI4:
    1392. 

  1392.         return &V_UI4(pvar);
    1393. 

  1393.         break;
    1394. 

  1394.     case VT_R4:
    1395. 

  1395.         return &V_R4(pvar);
    1396. 

  1396.         break;
    1397. 

  1397.     case VT_R8:
    1398. 

  1398.         return &V_R8(pvar);
    1399. 

  1399.         break;
    1400. 

  1400. #if (_MSC_VER >= 1300) || defined(__CYGWIN__) || defined(__MINGW32__)
    1401. 

  1401.     case VT_I8:
    1402. 

  1402.         return &V_I8(pvar);
    1403. 

  1403.         break;
    1404. 

  1404.     case VT_UI8:
    1405. 

  1405.         return &V_UI8(pvar);
    1406. 

  1406.         break;
    1407. 

  1407. #endif
    1408. 

  1408.     case VT_INT:
    1409. 

  1409.         return &V_INT(pvar);
    1410. 

  1410.         break;
    1411. 

  1411.     case VT_UINT:
    1412. 

  1412.         return &V_UINT(pvar);
    1413. 

  1413.         break;
    1414. 

  1414.     case VT_CY:
    1415. 

  1415.         return &V_CY(pvar);
    1416. 

  1416.         break;
    1417. 

  1417.     case VT_DATE:
    1418. 

  1418.         return &V_DATE(pvar);
    1419. 

  1419.         break;
    1420. 

  1420.     case VT_BSTR:
    1421. 

  1421.         return V_BSTR(pvar);
    1422. 

  1422.         break;
    1423. 

  1423.     case VT_DISPATCH:
    1424. 

  1424.         return V_DISPATCH(pvar);
    1425. 

  1425.         break;
    1426. 

  1426.     case VT_ERROR:
    1427. 

  1427.         return &V_ERROR(pvar);
    1428. 

  1428.         break;
    1429. 

  1429.     case VT_BOOL:
    1430. 

  1430.         return &V_BOOL(pvar);
    1431. 

  1431.         break;
    1432. 

  1432.     case VT_UNKNOWN:
    1433. 

  1433.         return V_UNKNOWN(pvar);
    1434. 

  1434.         break;
    1435. 

  1435.     case VT_ARRAY:
    1436. 

  1436.         return &V_ARRAY(pvar);
    1437. 

  1437.         break;
    1438. 

  1438.     default:
    1439. 

  1439.         return NULL;
    1440. 

  1440.         break;
    1441. 

  1441.     }
    1442. 

  1442. }
    1443. 

  1443. 

  1444. static VALUE
    1445. 

  1445. is_all_index_under(long *pid, long *pub, long dim) 
    1446. 

  1446. {
    1447. 

  1447.   long i = 0;
    1448. 

  1448.   for (i = 0; i < dim; i++) {
    1449. 

  1449.     if (pid[i] > pub[i]) {
    1450. 

  1450.       return Qfalse;
    1451. 

  1451.     }
    1452. 

  1452.   }
    1453. 

  1453.   return Qtrue;
    1454. 

  1454. }
    1455. 

  1455. 

  1456. static void
    1457. 

  1457. ole_set_safe_array(long n, SAFEARRAY *psa, long *pid, long *pub, VALUE val, long dim,  VARTYPE vt)
    1458. 

  1458. {
    1459. 

  1459.     VALUE val1;
    1460. 

  1460.     HRESULT hr = S_OK;
    1461. 

  1461.     VARIANT var;
    1462. 

  1462.     VOID *p = NULL;
    1463. 

  1463.     long i = n;
    1464. 

  1464.     while(i >= 0) {
    1465. 

  1465.         val1 = ole_ary_m_entry(val, pid);
    1466. 

  1466.         VariantInit(&var);
    1467. 

  1467.         p = val2variant_ptr(val1, &var, vt);
    1468. 

  1468.         if (is_all_index_under(pid, pub, dim) == Qtrue) {
    1469. 

  1469.             if ((V_VT(&var) == VT_DISPATCH && V_DISPATCH(&var) == NULL) ||
    1470. 

  1470.                 (V_VT(&var) == VT_UNKNOWN && V_UNKNOWN(&var) == NULL)) {
    1471. 

  1471.                 rb_raise(eWIN32OLERuntimeError, "element of array does not have IDispatch or IUnknown Interface");
    1472. 

  1472.             }
    1473. 

  1473.             hr = SafeArrayPutElement(psa, pid, p);
    1474. 

  1474.         }
    1475. 

  1475.         if (FAILED(hr)) {
    1476. 

  1476.             ole_raise(hr, rb_eRuntimeError, "failed to SafeArrayPutElement");
    1477. 

  1477.         }
    1478. 

  1478.         pid[i] += 1;
    1479. 

  1479.         if (pid[i] > pub[i]) {
    1480. 

  1480.             pid[i] = 0;
    1481. 

  1481.             i -= 1;
    1482. 

  1482.         } else {
    1483. 

  1483.             i = dim - 1;
    1484. 

  1484.         }
    1485. 

  1485.     }
    1486. 

  1486. }
    1487. 

  1487. 

  1488. static long
    1489. 

  1489. dimension(VALUE val) {
    1490. 

  1490.     long dim = 0;
    1491. 

  1491.     long dim1 = 0;
    1492. 

  1492.     long len = 0;
    1493. 

  1493.     long i = 0;
    1494. 

  1494.     if (TYPE(val) == T_ARRAY) {
    1495. 

  1495.         len = RARRAY_LEN(val);
    1496. 

  1496.         for (i = 0; i < len; i++) {
    1497. 

  1497.             dim1 = dimension(rb_ary_entry(val, i));
    1498. 

  1498.             if (dim < dim1) {
    1499. 

  1499.                 dim = dim1;
    1500. 

  1500.             }
    1501. 

  1501.         }
    1502. 

  1502.         dim += 1;
    1503. 

  1503.     }
    1504. 

  1504.     return dim;
    1505. 

  1505. }
    1506. 

  1506. 

  1507. static long 
    1508. 

  1508. ary_len_of_dim(VALUE ary, long dim) {
    1509. 

  1509.     long ary_len = 0;
    1510. 

  1510.     long ary_len1 = 0;
    1511. 

  1511.     long len = 0;
    1512. 

  1512.     long i = 0;
    1513. 

  1513.     VALUE val;
    1514. 

  1514.     if (dim == 0) {
    1515. 

  1515.         if (TYPE(ary) == T_ARRAY) {
    1516. 

  1516.             ary_len = RARRAY_LEN(ary);
    1517. 

  1517.         }
    1518. 

  1518.     } else {
    1519. 

  1519.         if (TYPE(ary) == T_ARRAY) {
    1520. 

  1520.             len = RARRAY_LEN(ary);
    1521. 

  1521.             for (i = 0; i < len; i++) {
    1522. 

  1522.                 val = rb_ary_entry(ary, i);
    1523. 

  1523.                 ary_len1 = ary_len_of_dim(val, dim-1);
    1524. 

  1524.                 if (ary_len < ary_len1) {
    1525. 

  1525.                     ary_len = ary_len1;
    1526. 

  1526.                 }
    1527. 

  1527.             }
    1528. 

  1528.         }
    1529. 

  1529.     }
    1530. 

  1530.     return ary_len;
    1531. 

  1531. }
    1532. 

  1532. 

  1533. static HRESULT
    1534. 

  1534. ole_val_ary2variant_ary(VALUE val, VARIANT *var, VARTYPE vt)
    1535. 

  1535. {
    1536. 

  1536.     long dim = 0;
    1537. 

  1537.     int  i = 0;
    1538. 

  1538.     HRESULT hr = S_OK;
    1539. 

  1539. 

  1540.     SAFEARRAYBOUND *psab = NULL;
    1541. 

  1541.     SAFEARRAY *psa = NULL;
    1542. 

  1542.     long      *pub, *pid;
    1543. 

  1543. 

  1544.     Check_Type(val, T_ARRAY);
    1545. 

  1545. 

  1546.     dim = dimension(val);
    1547. 

  1547. 

  1548.     psab = ALLOC_N(SAFEARRAYBOUND, dim);
    1549. 

  1549.     pub  = ALLOC_N(long, dim);
    1550. 

  1550.     pid  = ALLOC_N(long, dim);
    1551. 

  1551. 

  1552.     if(!psab || !pub || !pid) {
    1553. 

  1553.         if(pub) free(pub);
    1554. 

  1554.         if(psab) free(psab);
    1555. 

  1555.         if(pid) free(pid);
    1556. 

  1556.         rb_raise(rb_eRuntimeError, "memory allocation error");
    1557. 

  1557.     }
    1558. 

  1558. 

  1559.     for (i = 0; i < dim; i++) {
    1560. 

  1560.         psab[i].cElements = ary_len_of_dim(val, i);
    1561. 

  1561.         psab[i].lLbound = 0;
    1562. 

  1562.         pub[i] = psab[i].cElements - 1;
    1563. 

  1563.         pid[i] = 0;
    1564. 

  1564.     }
    1565. 

  1565.     /* Create and fill VARIANT array */
    1566. 

  1566.     if ((vt & ~VT_BYREF) == VT_ARRAY) {
    1567. 

  1567.         vt = (vt | VT_VARIANT);
    1568. 

  1568.     }
    1569. 

  1569.     psa = SafeArrayCreate((VARTYPE)(vt & VT_TYPEMASK), dim, psab);
    1570. 

  1570.     if (psa == NULL)
    1571. 

  1571.         hr = E_OUTOFMEMORY;
    1572. 

  1572.     else
    1573. 

  1573.         hr = SafeArrayLock(psa);
    1574. 

  1574.     if (SUCCEEDED(hr)) {
    1575. 

  1575.         ole_set_safe_array(dim-1, psa, pid, pub, val, dim, (VARTYPE)(vt & VT_TYPEMASK));
    1576. 

  1576.         hr = SafeArrayUnlock(psa);
    1577. 

  1577.     }
    1578. 

  1578. 

  1579.     if(pub) free(pub);
    1580. 

  1580.     if(psab) free(psab);
    1581. 

  1581.     if(pid) free(pid);
    1582. 

  1582. 

  1583.     if (SUCCEEDED(hr)) {
    1584. 

  1584.         V_VT(var) = vt;
    1585. 

  1585.         V_ARRAY(var) = psa;
    1586. 

  1586.     }
    1587. 

  1587.     else {
    1588. 

  1588.         if (psa != NULL)
    1589. 

  1589.             SafeArrayDestroy(psa);
    1590. 

  1590.     }
    1591. 

  1591.     return hr;
    1592. 

  1592. }
    1593. 

  1593. 

  1594. static void
    1595. 

  1595. ole_val2variant(VALUE val, VARIANT *var)
    1596. 

  1596. {
    1597. 

  1597.     struct oledata *pole;
    1598. 

  1598.     struct olevariantdata *pvar;
    1599. 

  1599.     if(rb_obj_is_kind_of(val, cWIN32OLE)) {
    1600. 

  1600.         Data_Get_Struct(val, struct oledata, pole);
    1601. 

  1601.         OLE_ADDREF(pole->pDispatch);
    1602. 

  1602.         V_VT(var) = VT_DISPATCH;
    1603. 

  1603.         V_DISPATCH(var) = pole->pDispatch;
    1604. 

  1604.         return;
    1605. 

  1605.     }
    1606. 

  1606.     if (rb_obj_is_kind_of(val, cWIN32OLE_VARIANT)) {
    1607. 

  1607.         Data_Get_Struct(val, struct olevariantdata, pvar);
    1608. 

  1608.         VariantCopy(var, &(pvar->var));
    1609. 

  1609.         return;
    1610. 

  1610.     }
    1611. 

  1611. 

  1612.     if (rb_obj_is_kind_of(val, rb_cTime)) {
    1613. 

  1613.         V_VT(var) = VT_DATE;
    1614. 

  1614.         V_DATE(var) = rbtime2vtdate(val);
    1615. 

  1615.         return;
    1616. 

  1616.     }
    1617. 

  1617.     switch (TYPE(val)) {
    1618. 

  1618.     case T_ARRAY:
    1619. 

  1619.         ole_val_ary2variant_ary(val, var, VT_VARIANT|VT_ARRAY);
    1620. 

  1620.         break;
    1621. 

  1621.     case T_STRING:
    1622. 

  1622.         V_VT(var) = VT_BSTR;
    1623. 

  1623.         V_BSTR(var) = ole_vstr2wc(val);
    1624. 

  1624.         break;
    1625. 

  1625.     case T_FIXNUM:
    1626. 

  1626.         V_VT(var) = VT_I4;
    1627. 

  1627.         V_I4(var) = NUM2INT(val);
    1628. 

  1628.         break;
    1629. 

  1629.     case T_BIGNUM:
    1630. 

  1630.         V_VT(var) = VT_R8;
    1631. 

  1631.         V_R8(var) = rb_big2dbl(val);
    1632. 

  1632.         break;
    1633. 

  1633.     case T_FLOAT:
    1634. 

  1634.         V_VT(var) = VT_R8;
    1635. 

  1635.         V_R8(var) = NUM2DBL(val);
    1636. 

  1636.         break;
    1637. 

  1637.     case T_TRUE:
    1638. 

  1638.         V_VT(var) = VT_BOOL;
    1639. 

  1639.         V_BOOL(var) = VARIANT_TRUE;
    1640. 

  1640.         break;
    1641. 

  1641.     case T_FALSE:
    1642. 

  1642.         V_VT(var) = VT_BOOL;
    1643. 

  1643.         V_BOOL(var) = VARIANT_FALSE;
    1644. 

  1644.         break;
    1645. 

  1645.     case T_NIL:
    1646. 

  1646.         if (g_nil_to == VT_ERROR) {
    1647. 

  1647.             V_VT(var) = VT_ERROR;
    1648. 

  1648.             V_ERROR(var) = DISP_E_PARAMNOTFOUND;
    1649. 

  1649.         }else {
    1650. 

  1650.             V_VT(var) = VT_EMPTY;
    1651. 

  1651.         }
    1652. 

  1652.         break;
    1653. 

  1653.     default:
    1654. 

  1654.         V_VT(var) = VT_DISPATCH;
    1655. 

  1655.         V_DISPATCH(var) = val2dispatch(val);
    1656. 

  1656.         break;
    1657. 

  1657.     }
    1658. 

  1658. }
    1659. 

  1659. 

  1660. static void
    1661. 

  1661. ole_val2variant_ex(VALUE val, VARIANT *var, VARTYPE vt)
    1662. 

  1662. {
    1663. 

  1663.     if (val == Qnil) {
    1664. 

  1664.         if (vt == VT_VARIANT) {
    1665. 

  1665.             ole_val2variant2(val, var);
    1666. 

  1666.         } else {
    1667. 

  1667.             V_VT(var) = (vt & ~VT_BYREF);
    1668. 

  1668.             if (V_VT(var) == VT_DISPATCH) {
    1669. 

  1669.                 V_DISPATCH(var) = NULL;
    1670. 

  1670.             } else if (V_VT(var) == VT_UNKNOWN) {
    1671. 

  1671.                 V_UNKNOWN(var) = NULL;
    1672. 

  1672.             }
    1673. 

  1673.         }
    1674. 

  1674.         return;
    1675. 

  1675.     }
    1676. 

  1676. #if (_MSC_VER >= 1300) || defined(__CYGWIN__) || defined(__MINGW32__)
    1677. 

  1677.     switch(vt & ~VT_BYREF) {
    1678. 

  1678.     case VT_I8:
    1679. 

  1679.         V_VT(var) = VT_I8;
    1680. 

  1680.         V_I8(var) = NUM2I8 (val);
    1681. 

  1681.         break;
    1682. 

  1682.     case VT_UI8:
    1683. 

  1683.         V_VT(var) = VT_UI8;
    1684. 

  1684.         V_UI8(var) = NUM2UI8(val);
    1685. 

  1685.         break;
    1686. 

  1686.     default:
    1687. 

  1687.         ole_val2variant2(val, var);
    1688. 

  1688.         break;
    1689. 

  1689.     }
    1690. 

  1690. #else  /* (_MSC_VER >= 1300) || defined(__CYGWIN__) || defined(__MINGW32__) */
    1691. 

  1691.     ole_val2variant2(val, var);
    1692. 

  1692. #endif
    1693. 

  1693. }
    1694. 

  1694. 

  1695. static void
    1696. 

  1696. ole_val2ptr_variant(VALUE val, VARIANT *var)
    1697. 

  1697. {
    1698. 

  1698.     switch (TYPE(val)) {
    1699. 

  1699.     case T_STRING:
    1700. 

  1700.         if (V_VT(var) == (VT_BSTR | VT_BYREF)) {
    1701. 

  1701.             *V_BSTRREF(var) = ole_vstr2wc(val);
    1702. 

  1702.         }
    1703. 

  1703.         break;
    1704. 

  1704.     case T_FIXNUM:
    1705. 

  1705.         switch(V_VT(var)) {
    1706. 

  1706.         case (VT_UI1 | VT_BYREF) :
    1707. 

  1707.             *V_UI1REF(var) = NUM2CHR(val);
    1708. 

  1708.             break;
    1709. 

  1709.         case (VT_I2 | VT_BYREF) :
    1710. 

  1710.             *V_I2REF(var) = (short)NUM2INT(val);
    1711. 

  1711.             break;
    1712. 

  1712.         case (VT_I4 | VT_BYREF) :
    1713. 

  1713.             *V_I4REF(var) = NUM2INT(val);
    1714. 

  1714.             break;
    1715. 

  1715.         case (VT_R4 | VT_BYREF) :
    1716. 

  1716.             *V_R4REF(var) = (float)NUM2INT(val);
    1717. 

  1717.             break;
    1718. 

  1718.         case (VT_R8 | VT_BYREF) :
    1719. 

  1719.             *V_R8REF(var) = NUM2INT(val);
    1720. 

  1720.             break;
    1721. 

  1721.         default:
    1722. 

  1722.             break;
    1723. 

  1723.         }
    1724. 

  1724.         break;
    1725. 

  1725.     case T_FLOAT:
    1726. 

  1726.         switch(V_VT(var)) {
    1727. 

  1727.         case (VT_I2 | VT_BYREF) :
    1728. 

  1728.             *V_I2REF(var) = (short)NUM2INT(val);
    1729. 

  1729.             break;
    1730. 

  1730.         case (VT_I4 | VT_BYREF) :
    1731. 

  1731.             *V_I4REF(var) = NUM2INT(val);
    1732. 

  1732.             break;
    1733. 

  1733.         case (VT_R4 | VT_BYREF) :
    1734. 

  1734.             *V_R4REF(var) = (float)NUM2DBL(val);
    1735. 

  1735.             break;
    1736. 

  1736.         case (VT_R8 | VT_BYREF) :
    1737. 

  1737.             *V_R8REF(var) = NUM2DBL(val);
    1738. 

  1738.             break;
    1739. 

  1739.         default:
    1740. 

  1740.             break;
    1741. 

  1741.         }
    1742. 

  1742.         break;
    1743. 

  1743.     case T_BIGNUM:
    1744. 

  1744.         if (V_VT(var) == (VT_R8 | VT_BYREF)) {
    1745. 

  1745.             *V_R8REF(var) = rb_big2dbl(val);
    1746. 

  1746.         }
    1747. 

  1747.         break;
    1748. 

  1748.     case T_TRUE:
    1749. 

  1749.         if (V_VT(var) == (VT_BOOL | VT_BYREF)) {
    1750. 

  1750.             *V_BOOLREF(var) = VARIANT_TRUE;
    1751. 

  1751.         }
    1752. 

  1752.         break;
    1753. 

  1753.     case T_FALSE:
    1754. 

  1754.         if (V_VT(var) == (VT_BOOL | VT_BYREF)) {
    1755. 

  1755.             *V_BOOLREF(var) = VARIANT_FALSE;
    1756. 

  1756.         }
    1757. 

  1757.         break;
    1758. 

  1758.     default:
    1759. 

  1759.         break;
    1760. 

  1760.     }
    1761. 

  1761. }
    1762. 

  1762. 

  1763. static void
    1764. 

  1764. ole_set_byref(VARIANT *realvar, VARIANT *var,  VARTYPE vt)
    1765. 

  1765. {
    1766. 

  1766.     V_VT(var) = vt;
    1767. 

  1767.     if (vt == (VT_VARIANT|VT_BYREF)) {
    1768. 

  1768.         V_VARIANTREF(var) = realvar;
    1769. 

  1769.     } else {
    1770. 

  1770.         if (V_VT(realvar) != (vt & ~VT_BYREF)) {
    1771. 

  1771.             rb_raise(eWIN32OLERuntimeError, "variant type mismatch");
    1772. 

  1772.         }
    1773. 

  1773.         switch(vt & ~VT_BYREF) {
    1774. 

  1774.         case VT_I1:
    1775. 

  1775.             V_I1REF(var) = &V_I1(realvar);
    1776. 

  1776.             break;
    1777. 

  1777.         case VT_UI1:
    1778. 

  1778.             V_UI1REF(var) = &V_UI1(realvar);
    1779. 

  1779.             break;
    1780. 

  1780.         case VT_I2:
    1781. 

  1781.             V_I2REF(var) = &V_I2(realvar);
    1782. 

  1782.             break;
    1783. 

  1783.         case VT_UI2:
    1784. 

  1784.             V_UI2REF(var) = &V_UI2(realvar);
    1785. 

  1785.             break;
    1786. 

  1786.         case VT_I4:
    1787. 

  1787.             V_I4REF(var) = &V_I4(realvar);
    1788. 

  1788.             break;
    1789. 

  1789.         case VT_UI4:
    1790. 

  1790.             V_UI4REF(var) = &V_UI4(realvar);
    1791. 

  1791.             break;
    1792. 

  1792.         case VT_R4:
    1793. 

  1793.             V_R4REF(var) = &V_R4(realvar);
    1794. 

  1794.             break;
    1795. 

  1795.         case VT_R8:
    1796. 

  1796.             V_R8REF(var) = &V_R8(realvar);
    1797. 

  1797.             break;
    1798. 

  1798. 

  1799. #if (_MSC_VER >= 1300)
    1800. 

  1800.         case VT_I8:
    1801. 

  1801.             V_I8REF(var) = &V_I8(realvar);
    1802. 

  1802.             break;
    1803. 

  1803.         case VT_UI8:
    1804. 

  1804.             V_UI8REF(var) = &V_UI8(realvar);
    1805. 

  1805.             break;
    1806. 

  1806. #endif
    1807. 

  1807.         case VT_INT:
    1808. 

  1808.             V_INTREF(var) = &V_INT(realvar);
    1809. 

  1809.             break;
    1810. 

  1810. 

  1811.         case VT_UINT:
    1812. 

  1812.             V_UINTREF(var) = &V_UINT(realvar);
    1813. 

  1813.             break;
    1814. 

  1814. 

  1815.         case VT_CY:
    1816. 

  1816.             V_CYREF(var) = &V_CY(realvar);
    1817. 

  1817.             break;
    1818. 

  1818.         case VT_DATE:
    1819. 

  1819.             V_DATEREF(var) = &V_DATE(realvar);
    1820. 

  1820.             break;
    1821. 

  1821.         case VT_BSTR:
    1822. 

  1822.             V_BSTRREF(var) = &V_BSTR(realvar);
    1823. 

  1823.             break;
    1824. 

  1824.         case VT_DISPATCH:
    1825. 

  1825.             V_DISPATCHREF(var) = &V_DISPATCH(realvar);
    1826. 

  1826.             break;
    1827. 

  1827.         case VT_ERROR:
    1828. 

  1828.             V_ERRORREF(var) = &V_ERROR(realvar);
    1829. 

  1829.             break;
    1830. 

  1830.         case VT_BOOL:
    1831. 

  1831.             V_BOOLREF(var) = &V_BOOL(realvar);
    1832. 

  1832.             break;
    1833. 

  1833.         case VT_UNKNOWN:
    1834. 

  1834.             V_UNKNOWNREF(var) = &V_UNKNOWN(realvar);
    1835. 

  1835.             break;
    1836. 

  1836.         case VT_ARRAY:
    1837. 

  1837.             V_ARRAYREF(var) = &V_ARRAY(realvar);
    1838. 

  1838.             break;
    1839. 

  1839.         default:
    1840. 

  1840.             rb_raise(eWIN32OLERuntimeError, "unknown type specified(setting BYREF):%d", vt);
    1841. 

  1841.             break;
    1842. 

  1842.         }
    1843. 

  1843.     }
    1844. 

  1844. }
    1845. 

  1845. 

  1846. static void
    1847. 

  1847. ole_val2olevariantdata(VALUE val, VARTYPE vt, struct olevariantdata *pvar)
    1848. 

  1848. {
    1849. 

  1849.     HRESULT hr = S_OK;
    1850. 

  1850. 

  1851.     if (((vt & ~VT_BYREF) ==  (VT_ARRAY | VT_UI1)) && TYPE(val) == T_STRING) {
    1852. 

  1852.         long len = RSTRING_LEN(val);
    1853. 

  1853.         void *pdest = NULL;
    1854. 

  1854.         SAFEARRAY *p = NULL;
    1855. 

  1855.         SAFEARRAY *psa = SafeArrayCreateVector(VT_UI1, 0, len);
    1856. 

  1856.         if (!psa) {
    1857. 

  1857.             rb_raise(rb_eRuntimeError, "fail to SafeArrayCreateVector");
    1858. 

  1858.         }
    1859. 

  1859.         hr = SafeArrayAccessData(psa, &pdest);
    1860. 

  1860.         if (SUCCEEDED(hr)) {
    1861. 

  1861.             memcpy(pdest, RSTRING_PTR(val), len);
    1862. 

  1862.             SafeArrayUnaccessData(psa);
    1863. 

  1863.             V_VT(&(pvar->realvar)) = (vt & ~VT_BYREF);
    1864. 

  1864.             p = V_ARRAY(&(pvar->realvar));
    1865. 

  1865.             if (p != NULL) {
    1866. 

  1866.                 SafeArrayDestroy(p);
    1867. 

  1867.             }
    1868. 

  1868.             V_ARRAY(&(pvar->realvar)) = psa;
    1869. 

  1869.             if (vt & VT_BYREF) {
    1870. 

  1870.                 V_VT(&(pvar->var)) = vt;
    1871. 

  1871.                 V_ARRAYREF(&(pvar->var)) = &(V_ARRAY(&(pvar->realvar)));
    1872. 

  1872.             } else {
    1873. 

  1873.                 hr = VariantCopy(&(pvar->var), &(pvar->realvar));
    1874. 

  1874.             }
    1875. 

  1875.         } else {
    1876. 

  1876.             if (psa) 
    1877. 

  1877.                 SafeArrayDestroy(psa);
    1878. 

  1878.         }
    1879. 

  1879.     } else if (vt & VT_ARRAY) {
    1880. 

  1880.         if (val == Qnil) {
    1881. 

  1881.             V_VT(&(pvar->var)) = vt;
    1882. 

  1882.             if (vt & VT_BYREF) {
    1883. 

  1883.                 V_ARRAYREF(&(pvar->var)) = &(V_ARRAY(&(pvar->realvar)));
    1884. 

  1884.             }
    1885. 

  1885.         } else {
    1886. 

  1886.             hr = ole_val_ary2variant_ary(val, &(pvar->realvar), (VARTYPE)(vt & ~VT_BYREF));
    1887. 

  1887.             if (SUCCEEDED(hr)) {
    1888. 

  1888.                 if (vt & VT_BYREF) {
    1889. 

  1889.                     V_VT(&(pvar->var)) = vt;
    1890. 

  1890.                     V_ARRAYREF(&(pvar->var)) = &(V_ARRAY(&(pvar->realvar)));
    1891. 

  1891.                 } else {
    1892. 

  1892.                     hr = VariantCopy(&(pvar->var), &(pvar->realvar));
    1893. 

  1893.                 }
    1894. 

  1894.             }
    1895. 

  1895.         }
    1896. 

  1896. #if (_MSC_VER >= 1300) || defined(__CYGWIN__) || defined(__MINGW32__)
    1897. 

  1897.     } else if ( (vt & ~VT_BYREF) == VT_I8 || (vt & ~VT_BYREF) == VT_UI8) {
    1898. 

  1898.         ole_val2variant_ex(val, &(pvar->realvar), (vt & ~VT_BYREF));
    1899. 

  1899.         ole_val2variant_ex(val, &(pvar->var), (vt & ~VT_BYREF));
    1900. 

  1900.         V_VT(&(pvar->var)) = vt;
    1901. 

  1901.         if (vt & VT_BYREF) {
    1902. 

  1902.             ole_set_byref(&(pvar->realvar), &(pvar->var), vt);
    1903. 

  1903.         }
    1904. 

  1904. #endif
    1905. 

  1905.     } else {
    1906. 

  1906.         if (val == Qnil) {
    1907. 

  1907.             V_VT(&(pvar->var)) = vt;
    1908. 

  1908.             if (vt == (VT_BYREF | VT_VARIANT)) {
    1909. 

  1909.                 ole_set_byref(&(pvar->realvar), &(pvar->var), vt);
    1910. 

  1910.             } else {
    1911. 

  1911.                 V_VT(&(pvar->realvar)) = vt & ~VT_BYREF;
    1912. 

  1912.                 if (vt & VT_BYREF) {
    1913. 

  1913.                     ole_set_byref(&(pvar->realvar), &(pvar->var), vt);
    1914. 

  1914.                 }
    1915. 

  1915.             }
    1916. 

  1916.         } else {
    1917. 

  1917.             ole_val2variant_ex(val, &(pvar->realvar), (VARTYPE)(vt & ~VT_BYREF));
    1918. 

  1918.             if (vt == (VT_BYREF | VT_VARIANT)) {
    1919. 

  1919.                 ole_set_byref(&(pvar->realvar), &(pvar->var), vt);
    1920. 

  1920.             } else if (vt & VT_BYREF) {
    1921. 

  1921.                 if ( (vt & ~VT_BYREF) != V_VT(&(pvar->realvar))) {
    1922. 

  1922.                     hr = VariantChangeTypeEx(&(pvar->realvar), &(pvar->realvar), 
    1923. 

  1923.                             cWIN32OLE_lcid, 0, (VARTYPE)(vt & ~VT_BYREF));
    1924. 

  1924.                 }
    1925. 

  1925.                 if (SUCCEEDED(hr)) {
    1926. 

  1926.                     ole_set_byref(&(pvar->realvar), &(pvar->var), vt);
    1927. 

  1927.                 }
    1928. 

  1928.             } else {
    1929. 

  1929.                 if (vt == V_VT(&(pvar->realvar))) {
    1930. 

  1930.                     hr = VariantCopy(&(pvar->var), &(pvar->realvar));
    1931. 

  1931.                 } else {
    1932. 

  1932.                     hr = VariantChangeTypeEx(&(pvar->var), &(pvar->realvar), 
    1933. 

  1933.                             cWIN32OLE_lcid, 0, vt);
    1934. 

  1934.                 }
    1935. 

  1935.             }
    1936. 

  1936.         }
    1937. 

  1937.     }
    1938. 

  1938.     if (FAILED(hr)) {
    1939. 

  1939.         ole_raise(hr, eWIN32OLERuntimeError, "failed to change type");
    1940. 

  1940.     }
    1941. 

  1941. }
    1942. 

  1942. 

  1943. static void
    1944. 

  1944. ole_val2variant2(VALUE val, VARIANT *var)
    1945. 

  1945. {
    1946. 

  1946.     g_nil_to = VT_EMPTY;
    1947. 

  1947.     ole_val2variant(val, var);
    1948. 

  1948.     g_nil_to = VT_ERROR;
    1949. 

  1949. }
    1950. 

  1950. 

  1951. static VALUE
    1952. 

  1952. make_inspect(const char *class_name, VALUE detail) 
    1953. 

  1953. {
    1954. 

  1954.     VALUE str;
    1955. 

  1955.     str = rb_str_new2("#<");
    1956. 

  1956.     rb_str_cat2(str, class_name);
    1957. 

  1957.     rb_str_cat2(str, ":");
    1958. 

  1958.     rb_str_concat(str, detail);
    1959. 

  1959.     rb_str_cat2(str, ">");
    1960. 

  1960.     return str;
    1961. 

  1961. }
    1962. 

  1962. 

  1963. static VALUE
    1964. 

  1964. default_inspect(VALUE self, const char *class_name) 
    1965. 

  1965. {
    1966. 

  1966.     VALUE detail = rb_funcall(self, rb_intern("to_s"), 0);
    1967. 

  1967.     return make_inspect(class_name, detail);
    1968. 

  1968. }
    1969. 

  1969. 

  1970. static VALUE
    1971. 

  1971. ole_set_member(VALUE self, IDispatch *dispatch)
    1972. 

  1972. {
    1973. 

  1973.     struct oledata *pole;
    1974. 

  1974.     Data_Get_Struct(self, struct oledata, pole);
    1975. 

  1975.     if (pole->pDispatch) {
    1976. 

  1976.         OLE_RELEASE(pole->pDispatch);
    1977. 

  1977.         pole->pDispatch = NULL;
    1978. 

  1978.     }
    1979. 

  1979.     pole->pDispatch = dispatch;
    1980. 

  1980.     return self;
    1981. 

  1981. }
    1982. 

  1982. 

  1983. 

  1984. static VALUE
    1985. 

  1985. fole_s_allocate(VALUE klass)
    1986. 

  1986. {
    1987. 

  1987.     struct oledata *pole;
    1988. 

  1988.     VALUE obj;
    1989. 

  1989.     ole_initialize();
    1990. 

  1990.     obj = Data_Make_Struct(klass,struct oledata,0,ole_free,pole);
    1991. 

  1991.     pole->pDispatch = NULL;
    1992. 

  1992.     return obj;
    1993. 

  1993. }
    1994. 

  1994. 

  1995. static VALUE
    1996. 

  1996. create_win32ole_object(VALUE klass, IDispatch *pDispatch, int argc, VALUE *argv)
    1997. 

  1997. {
    1998. 

  1998.     VALUE obj = fole_s_allocate(klass);
    1999. 

  1999.     ole_set_member(obj, pDispatch);
    2000. 

  2000.     return obj;
    2001. 

  2001. }
    2002. 

  2002. 

  2003. static VALUE
    2004. 

  2004. ary_new_dim(VALUE myary, long *pid, long *plb, long dim) {
    2005. 

  2005.     long i;
    2006. 

  2006.     VALUE obj = Qnil;
    2007. 

  2007.     VALUE pobj = Qnil;
    2008. 

  2008.     long *ids = ALLOC_N(long, dim);
    2009. 

  2009.     if (!ids) {
    2010. 

  2010.         rb_raise(rb_eRuntimeError, "memory allocation error");
    2011. 

  2011.     }
    2012. 

  2012.     for(i = 0; i < dim; i++) {
    2013. 

  2013.         ids[i] = pid[i] - plb[i];
    2014. 

  2014.     }
    2015. 

  2015.     obj = myary;
    2016. 

  2016.     pobj = myary;
    2017. 

  2017.     for(i = 0; i < dim-1; i++) {
    2018. 

  2018.         obj = rb_ary_entry(pobj, ids[i]);
    2019. 

  2019.         if (obj == Qnil) {
    2020. 

  2020.             rb_ary_store(pobj, ids[i], rb_ary_new());
    2021. 

  2021.         }
    2022. 

  2022.         obj = rb_ary_entry(pobj, ids[i]);
    2023. 

  2023.         pobj = obj;
    2024. 

  2024.     }
    2025. 

  2025.     if (ids) free(ids);
    2026. 

  2026.     return obj;
    2027. 

  2027. }
    2028. 

  2028. 

  2029. static void
    2030. 

  2030. ary_store_dim(VALUE myary, long *pid, long *plb, long dim, VALUE val) {
    2031. 

  2031.     long id = pid[dim - 1] - plb[dim - 1];
    2032. 

  2032.     VALUE obj = ary_new_dim(myary, pid, plb, dim);
    2033. 

  2033.     rb_ary_store(obj, id, val);
    2034. 

  2034. }
    2035. 

  2035. 

  2036. static VALUE
    2037. 

  2037. ole_variant2val(VARIANT *pvar)
    2038. 

  2038. {
    2039. 

  2039.     VALUE obj = Qnil;
    2040. 

  2040.     HRESULT hr;
    2041. 

  2041.     while ( V_VT(pvar) == (VT_BYREF | VT_VARIANT) )
    2042. 

  2042.         pvar = V_VARIANTREF(pvar);
    2043. 

  2043. 

  2044.     if(V_ISARRAY(pvar)) {
    2045. 

  2045.         SAFEARRAY *psa = V_ISBYREF(pvar) ? *V_ARRAYREF(pvar) : V_ARRAY(pvar);
    2046. 

  2046.         UINT i = 0;
    2047. 

  2047.         long *pid, *plb, *pub;
    2048. 

  2048.         VARIANT variant;
    2049. 

  2049.         VALUE val;
    2050. 

  2050.         UINT dim = 0;
    2051. 

  2051.         if (!psa) {
    2052. 

  2052.             return obj;
    2053. 

  2053.         }
    2054. 

  2054.         dim = SafeArrayGetDim(psa);
    2055. 

  2055.         VariantInit(&variant);
    2056. 

  2056.         V_VT(&variant) = (V_VT(pvar) & ~VT_ARRAY) | VT_BYREF;
    2057. 

  2057. 

  2058.         pid = ALLOC_N(long, dim);
    2059. 

  2059.         plb = ALLOC_N(long, dim);
    2060. 

  2060.         pub = ALLOC_N(long, dim);
    2061. 

  2061. 

  2062.         if(!pid || !plb || !pub) {
    2063. 

  2063.             if(pid) free(pid);
    2064. 

  2064.             if(plb) free(plb);
    2065. 

  2065.             if(pub) free(pub);
    2066. 

  2066.             rb_raise(rb_eRuntimeError, "memory allocation error");
    2067. 

  2067.         }
    2068. 

  2068. 

  2069.         for(i = 0; i < dim; ++i) {
    2070. 

  2070.             SafeArrayGetLBound(psa, i+1, &plb[i]);
    2071. 

  2071.             SafeArrayGetLBound(psa, i+1, &pid[i]);
    2072. 

  2072.             SafeArrayGetUBound(psa, i+1, &pub[i]);
    2073. 

  2073.         }
    2074. 

  2074.         hr = SafeArrayLock(psa);
    2075. 

  2075.         if (SUCCEEDED(hr)) {
    2076. 

  2076.             obj = rb_ary_new();
    2077. 

  2077.             i = 0;
    2078. 

  2078.             while (i < dim) {
    2079. 

  2079.                 ary_new_dim(obj, pid, plb, dim);
    2080. 

  2080.                 hr = SafeArrayPtrOfIndex(psa, pid, &V_BYREF(&variant));
    2081. 

  2081.                 if (SUCCEEDED(hr)) {
    2082. 

  2082.                     val = ole_variant2val(&variant);
    2083. 

  2083.                     ary_store_dim(obj, pid, plb, dim, val);
    2084. 

  2084.                 }
    2085. 

  2085.                 for (i = 0; i < dim; ++i) {
    2086. 

  2086.                     if (++pid[i] <= pub[i])
    2087. 

  2087.                         break;
    2088. 

  2088.                     pid[i] = plb[i];
    2089. 

  2089.                 }
    2090. 

  2090.             }
    2091. 

  2091.             SafeArrayUnlock(psa);
    2092. 

  2092.         }
    2093. 

  2093.         if(pid) free(pid);
    2094. 

  2094.         if(plb) free(plb);
    2095. 

  2095.         if(pub) free(pub);
    2096. 

  2096.         return obj;
    2097. 

  2097.     }
    2098. 

  2098.     switch(V_VT(pvar) & ~VT_BYREF){
    2099. 

  2099.     case VT_EMPTY:
    2100. 

  2100.         break;
    2101. 

  2101.     case VT_NULL:
    2102. 

  2102.         break;
    2103. 

  2103.     case VT_I1:
    2104. 

  2104.         if(V_ISBYREF(pvar)) 
    2105. 

  2105.             obj = INT2NUM((long)*V_I1REF(pvar));
    2106. 

  2106.         else 
    2107. 

  2107.             obj = INT2NUM((long)V_I1(pvar));
    2108. 

  2108.         break;
    2109. 

  2109. 

  2110.     case VT_UI1:
    2111. 

  2111.         if(V_ISBYREF(pvar)) 
    2112. 

  2112.             obj = INT2NUM((long)*V_UI1REF(pvar));
    2113. 

  2113.         else 
    2114. 

  2114.             obj = INT2NUM((long)V_UI1(pvar));
    2115. 

  2115.         break;
    2116. 

  2116. 

  2117.     case VT_I2:
    2118. 

  2118.         if(V_ISBYREF(pvar))
    2119. 

  2119.             obj = INT2NUM((long)*V_I2REF(pvar));
    2120. 

  2120.         else 
    2121. 

  2121.             obj = INT2NUM((long)V_I2(pvar));
    2122. 

  2122.         break;
    2123. 

  2123. 

  2124.     case VT_UI2:
    2125. 

  2125.         if(V_ISBYREF(pvar))
    2126. 

  2126.             obj = INT2NUM((long)*V_UI2REF(pvar));
    2127. 

  2127.         else 
    2128. 

  2128.             obj = INT2NUM((long)V_UI2(pvar));
    2129. 

  2129.         break;
    2130. 

  2130. 

  2131.     case VT_I4:
    2132. 

  2132.         if(V_ISBYREF(pvar))
    2133. 

  2133.             obj = INT2NUM((long)*V_I4REF(pvar));
    2134. 

  2134.         else 
    2135. 

  2135.             obj = INT2NUM((long)V_I4(pvar));
    2136. 

  2136.         break;
    2137. 

  2137. 

  2138.     case VT_UI4:
    2139. 

  2139.         if(V_ISBYREF(pvar))
    2140. 

  2140.             obj = INT2NUM((long)*V_UI4REF(pvar));
    2141. 

  2141.         else 
    2142. 

  2142.             obj = INT2NUM((long)V_UI4(pvar));
    2143. 

  2143.         break;
    2144. 

  2144. 

  2145.     case VT_INT:
    2146. 

  2146.         if(V_ISBYREF(pvar))
    2147. 

  2147.             obj = INT2NUM((long)*V_INTREF(pvar));
    2148. 

  2148.         else 
    2149. 

  2149.             obj = INT2NUM((long)V_INT(pvar));
    2150. 

  2150.         break;
    2151. 

  2151. 

  2152.     case VT_UINT:
    2153. 

  2153.         if(V_ISBYREF(pvar))
    2154. 

  2154.             obj = INT2NUM((long)*V_UINTREF(pvar));
    2155. 

  2155.         else 
    2156. 

  2156.             obj = INT2NUM((long)V_UINT(pvar));
    2157. 

  2157.         break;
    2158. 

  2158. 

  2159. #if (_MSC_VER >= 1300) || defined(__CYGWIN__) || defined(__MINGW32__)
    2160. 

  2160.     case VT_I8:
    2161. 

  2161.         if(V_ISBYREF(pvar))
    2162. 

  2162. #if (_MSC_VER >= 1300)
    2163. 

  2163.             obj = I8_2_NUM(*V_I8REF(pvar));
    2164. 

  2164. #else 
    2165. 

  2165.             obj = Qnil;
    2166. 

  2166. #endif
    2167. 

  2167.         else
    2168. 

  2168.             obj = I8_2_NUM(V_I8(pvar));
    2169. 

  2169.         break;
    2170. 

  2170.     case VT_UI8:
    2171. 

  2171.         if(V_ISBYREF(pvar))
    2172. 

  2172. #if (_MSC_VER >= 1300)
    2173. 

  2173.             obj = UI8_2_NUM(*V_UI8REF(pvar));
    2174. 

  2174. #else
    2175. 

  2175.             obj = Qnil;
    2176. 

  2176. #endif
    2177. 

  2177.         else
    2178. 

  2178.             obj = UI8_2_NUM(V_UI8(pvar));
    2179. 

  2179.         break;
    2180. 

  2180. #endif  /* (_MSC_VER >= 1300) || defined(__CYGWIN__) || defined(__MINGW32__) */
    2181. 

  2181. 

  2182.     case VT_R4:
    2183. 

  2183.         if(V_ISBYREF(pvar))
    2184. 

  2184.             obj = rb_float_new(*V_R4REF(pvar));
    2185. 

  2185.         else
    2186. 

  2186.             obj = rb_float_new(V_R4(pvar));
    2187. 

  2187.         break;
    2188. 

  2188. 

  2189.     case VT_R8:
    2190. 

  2190.         if(V_ISBYREF(pvar))
    2191. 

  2191.             obj = rb_float_new(*V_R8REF(pvar));
    2192. 

  2192.         else
    2193. 

  2193.             obj = rb_float_new(V_R8(pvar));
    2194. 

  2194.         break;
    2195. 

  2195. 

  2196.     case VT_BSTR:
    2197. 

  2197.     {
    2198. 

  2198.         if(V_ISBYREF(pvar))
    2199. 

  2199.             obj = ole_wc2vstr(*V_BSTRREF(pvar), FALSE);
    2200. 

  2200.         else
    2201. 

  2201.             obj = ole_wc2vstr(V_BSTR(pvar), FALSE);
    2202. 

  2202.         break;
    2203. 

  2203.     }
    2204. 

  2204. 

  2205.     case VT_ERROR:
    2206. 

  2206.         if(V_ISBYREF(pvar))
    2207. 

  2207.             obj = INT2NUM(*V_ERRORREF(pvar));
    2208. 

  2208.         else
    2209. 

  2209.             obj = INT2NUM(V_ERROR(pvar));
    2210. 

  2210.         break;
    2211. 

  2211. 

  2212.     case VT_BOOL:
    2213. 

  2213.         if (V_ISBYREF(pvar))
    2214. 

  2214.             obj = (*V_BOOLREF(pvar) ? Qtrue : Qfalse);
    2215. 

  2215.         else
    2216. 

  2216.             obj = (V_BOOL(pvar) ? Qtrue : Qfalse);
    2217. 

  2217.         break;
    2218. 

  2218. 

  2219.     case VT_DISPATCH:
    2220. 

  2220.     {
    2221. 

  2221.         IDispatch *pDispatch;
    2222. 

  2222. 

  2223.         if (V_ISBYREF(pvar))
    2224. 

  2224.             pDispatch = *V_DISPATCHREF(pvar);
    2225. 

  2225.         else
    2226. 

  2226.             pDispatch = V_DISPATCH(pvar);
    2227. 

  2227. 

  2228.         if (pDispatch != NULL ) {
    2229. 

  2229.             OLE_ADDREF(pDispatch);
    2230. 

  2230.             obj = create_win32ole_object(cWIN32OLE, pDispatch, 0, 0);
    2231. 

  2231.         }
    2232. 

  2232.         break;
    2233. 

  2233.     }
    2234. 

  2234. 

  2235.     case VT_UNKNOWN:
    2236. 

  2236.     {
    2237. 

  2237.         /* get IDispatch interface from IUnknown interface */
    2238. 

  2238.         IUnknown *punk;
    2239. 

  2239.         IDispatch *pDispatch;
    2240. 

  2240.         void *p;
    2241. 

  2241.         HRESULT hr;
    2242. 

  2242. 

  2243.         if (V_ISBYREF(pvar))
    2244. 

  2244.             punk = *V_UNKNOWNREF(pvar);
    2245. 

  2245.         else
    2246. 

  2246.             punk = V_UNKNOWN(pvar);
    2247. 

  2247. 

  2248.         if(punk != NULL) {
    2249. 

  2249.            hr = punk->lpVtbl->QueryInterface(punk, &IID_IDispatch, &p);
    2250. 

  2250.            if(SUCCEEDED(hr)) {
    2251. 

  2251.                pDispatch = p;
    2252. 

  2252.                obj = create_win32ole_object(cWIN32OLE, pDispatch, 0, 0);
    2253. 

  2253.            }
    2254. 

  2254.         }
    2255. 

  2255.         break;
    2256. 

  2256.     }
    2257. 

  2257. 

  2258.     case VT_DATE:
    2259. 

  2259.     {
    2260. 

  2260.         DATE date;
    2261. 

  2261.         if(V_ISBYREF(pvar))
    2262. 

  2262.             date = *V_DATEREF(pvar);
    2263. 

  2263.         else
    2264. 

  2264.             date = V_DATE(pvar);
    2265. 

  2265. 

  2266.         obj =  vtdate2rbtime(date);
    2267. 

  2267.         break;
    2268. 

  2268.     }
    2269. 

  2269.     case VT_CY:
    2270. 

  2270.     default:
    2271. 

  2271.         {
    2272. 

  2272.         HRESULT hr;
    2273. 

  2273.         VARIANT variant;
    2274. 

  2274.         VariantInit(&variant);
    2275. 

  2275.         hr = VariantChangeTypeEx(&variant, pvar, 
    2276. 

  2276.                                   cWIN32OLE_lcid, 0, VT_BSTR);
    2277. 

  2277.         if (SUCCEEDED(hr) && V_VT(&variant) == VT_BSTR) {
    2278. 

  2278.             obj = ole_wc2vstr(V_BSTR(&variant), FALSE);
    2279. 

  2279.         }
    2280. 

  2280.         VariantClear(&variant);
    2281. 

  2281.         break;
    2282. 

  2282.         }
    2283. 

  2283.     }
    2284. 

  2284.     return obj;
    2285. 

  2285. }
    2286. 

  2286. 

  2287. static LONG
    2288. 

  2288. reg_open_key(HKEY hkey, const char *name, HKEY *phkey)
    2289. 

  2289. {
    2290. 

  2290.     return RegOpenKeyEx(hkey, name, 0, KEY_READ, phkey);
    2291. 

  2291. }
    2292. 

  2292. 

  2293. static LONG
    2294. 

  2294. reg_open_vkey(HKEY hkey, VALUE key, HKEY *phkey)
    2295. 

  2295. {
    2296. 

  2296.     return reg_open_key(hkey, StringValuePtr(key), phkey);
    2297. 

  2297. }
    2298. 

  2298. 

  2299. static VALUE
    2300. 

  2300. reg_enum_key(HKEY hkey, DWORD i)
    2301. 

  2301. {
    2302. 

  2302.     char buf[BUFSIZ + 1];
    2303. 

  2303.     DWORD size_buf = sizeof(buf);
    2304. 

  2304.     FILETIME ft;
    2305. 

  2305.     LONG err = RegEnumKeyEx(hkey, i, buf, &size_buf,
    2306. 

  2306.                             NULL, NULL, NULL, &ft);
    2307. 

  2307.     if(err == ERROR_SUCCESS) {
    2308. 

  2308.         buf[BUFSIZ] = '\0';
    2309. 

  2309.         return rb_str_new2(buf);
    2310. 

  2310.     }
    2311. 

  2311.     return Qnil;
    2312. 

  2312. }
    2313. 

  2313. 

  2314. static VALUE
    2315. 

  2315. reg_get_val(HKEY hkey, const char *subkey)
    2316. 

  2316. {
    2317. 

  2317.     char *pbuf;
    2318. 

  2318.     DWORD dwtype = 0;
    2319. 

  2319.     LONG size = 0;
    2320. 

  2320.     VALUE val = Qnil;
    2321. 

  2321.     LONG err = RegQueryValueEx(hkey, subkey, NULL, &dwtype, NULL, &size); 
    2322. 

  2322. 

  2323.     if (err == ERROR_SUCCESS) {
    2324. 

  2324.         pbuf = ALLOC_N(char, size + 1);
    2325. 

  2325.         err = RegQueryValueEx(hkey, subkey, NULL, &dwtype, pbuf, &size);
    2326. 

  2326.         if (err == ERROR_SUCCESS) {
    2327. 

  2327.             pbuf[size] = '\0';
    2328. 

  2328.             val = rb_str_new2(pbuf);
    2329. 

  2329.         }
    2330. 

  2330.         free(pbuf);
    2331. 

  2331.     }
    2332. 

  2332.     return val;
    2333. 

  2333. }
    2334. 

  2334. 

  2335. static VALUE
    2336. 

  2336. reg_get_val2(HKEY hkey, const char *subkey)
    2337. 

  2337. {
    2338. 

  2338.     HKEY hsubkey;
    2339. 

  2339.     LONG err;
    2340. 

  2340.     VALUE val = Qnil;
    2341. 

  2341.     err = RegOpenKeyEx(hkey, subkey, 0, KEY_READ, &hsubkey);
    2342. 

  2342.     if (err == ERROR_SUCCESS) {
    2343. 

  2343.         val = reg_get_val(hsubkey, NULL);
    2344. 

  2344.         RegCloseKey(hsubkey);
    2345. 

  2345.     }
    2346. 

  2346.     if (val == Qnil) {
    2347. 

  2347.         val = reg_get_val(hkey, subkey);
    2348. 

  2348.     }
    2349. 

  2349.     return val;
    2350. 

  2350. }
    2351. 

  2351. 

  2352. static VALUE
    2353. 

  2353. reg_get_typelib_file_path(HKEY hkey)
    2354. 

  2354. {
    2355. 

  2355.     VALUE path = Qnil;
    2356. 

  2356.     path = reg_get_val2(hkey, "win32");
    2357. 

  2357.     if (path == Qnil) {
    2358. 

  2358.         path = reg_get_val2(hkey, "win16");
    2359. 

  2359.     }
    2360. 

  2360.     return path;
    2361. 

  2361. }
    2362. 

  2362. 

  2363. static VALUE
    2364. 

  2364. typelib_file_from_clsid(VALUE ole)
    2365. 

  2365. {
    2366. 

  2366.     HKEY hroot, hclsid;
    2367. 

  2367.     LONG err;
    2368. 

  2368.     VALUE typelib;
    2369. 

  2369.     char path[MAX_PATH + 1];
    2370. 

  2370. 

  2371.     err = reg_open_key(HKEY_CLASSES_ROOT, "CLSID", &hroot);
    2372. 

  2372.     if (err != ERROR_SUCCESS) {
    2373. 

  2373.         return Qnil;
    2374. 

  2374.     }
    2375. 

  2375.     err = reg_open_key(hroot, StringValuePtr(ole), &hclsid);
    2376. 

  2376.     if (err != ERROR_SUCCESS) {
    2377. 

  2377.         RegCloseKey(hroot);
    2378. 

  2378.         return Qnil;
    2379. 

  2379.     }
    2380. 

  2380.     typelib = reg_get_val2(hclsid, "InprocServer32");
    2381. 

  2381.     RegCloseKey(hroot);
    2382. 

  2382.     RegCloseKey(hclsid);
    2383. 

  2383.     if (typelib != Qnil) {
    2384. 

  2384.         ExpandEnvironmentStrings(StringValuePtr(typelib), path, sizeof(path));
    2385. 

  2385.         path[MAX_PATH] = '\0';
    2386. 

  2386.         typelib = rb_str_new2(path);
    2387. 

  2387.     }
    2388. 

  2388.     return typelib;
    2389. 

  2389. }
    2390. 

  2390. 

  2391. static VALUE
    2392. 

  2392. typelib_file_from_typelib(VALUE ole)
    2393. 

  2393. {
    2394. 

  2394.     HKEY htypelib, hclsid, hversion, hlang;
    2395. 

  2395.     double fver;
    2396. 

  2396.     DWORD i, j, k;
    2397. 

  2397.     LONG err;
    2398. 

  2398.     BOOL found = FALSE;
    2399. 

  2399.     VALUE typelib;
    2400. 

  2400.     VALUE file = Qnil;
    2401. 

  2401.     VALUE clsid;
    2402. 

  2402.     VALUE ver;
    2403. 

  2403.     VALUE lang;
    2404. 

  2404. 

  2405.     err = reg_open_key(HKEY_CLASSES_ROOT, "TypeLib", &htypelib);
    2406. 

  2406.     if(err != ERROR_SUCCESS) {
    2407. 

  2407.         return Qnil;
    2408. 

  2408.     }
    2409. 

  2409.     for(i = 0; !found; i++) {
    2410. 

  2410.         clsid = reg_enum_key(htypelib, i);
    2411. 

  2411.         if (clsid == Qnil)
    2412. 

  2412.             break;
    2413. 

  2413.         err = reg_open_vkey(htypelib, clsid, &hclsid);
    2414. 

  2414.         if (err != ERROR_SUCCESS)
    2415. 

  2415.             continue;
    2416. 

  2416.         fver = 0;
    2417. 

  2417.         for(j = 0; !found; j++) {
    2418. 

  2418.             ver = reg_enum_key(hclsid, j);
    2419. 

  2419.             if (ver == Qnil)
    2420. 

  2420.                 break;
    2421. 

  2421.             err = reg_open_vkey(hclsid, ver, &hversion);
    2422. 

  2422. 			if (err != ERROR_SUCCESS || fver > atof(StringValuePtr(ver)))
    2423. 

  2423.                 continue;
    2424. 

  2424.             fver = atof(StringValuePtr(ver));
    2425. 

  2425.             typelib = reg_get_val(hversion, NULL);
    2426. 

  2426.             if (typelib == Qnil)
    2427. 

  2427.                 continue;
    2428. 

  2428.             if (rb_str_cmp(typelib, ole) == 0) {
    2429. 

  2429.                 for(k = 0; !found; k++) {
    2430. 

  2430.                     lang = reg_enum_key(hversion, k);
    2431. 

  2431.                     if (lang == Qnil)
    2432. 

  2432.                         break;
    2433. 

  2433.                     err = reg_open_vkey(hversion, lang, &hlang);
    2434. 

  2434.                     if (err == ERROR_SUCCESS) {
    2435. 

  2435.                         if ((file = reg_get_typelib_file_path(hlang)) != Qnil) 
    2436. 

  2436.                             found = TRUE;
    2437. 

  2437.                         RegCloseKey(hlang);
    2438. 

  2438.                     }
    2439. 

  2439.                 }
    2440. 

  2440.             }
    2441. 

  2441.             RegCloseKey(hversion);
    2442. 

  2442.         }
    2443. 

  2443.         RegCloseKey(hclsid);
    2444. 

  2444.     }
    2445. 

  2445.     RegCloseKey(htypelib);
    2446. 

  2446.     return  file;
    2447. 

  2447. }
    2448. 

  2448. 

  2449. static VALUE
    2450. 

  2450. typelib_file(VALUE ole)
    2451. 

  2451. {
    2452. 

  2452.     VALUE file = typelib_file_from_clsid(ole);
    2453. 

  2453.     if (file != Qnil) {
    2454. 

  2454.         return file;
    2455. 

  2455.     }
    2456. 

  2456.     return typelib_file_from_typelib(ole);
    2457. 

  2457. }
    2458. 

  2458. 

  2459. static void
    2460. 

  2460. ole_const_load(ITypeLib *pTypeLib, VALUE klass, VALUE self)
    2461. 

  2461. {
    2462. 

  2462.     unsigned int count;
    2463. 

  2463.     unsigned int index;
    2464. 

  2464.     int iVar;
    2465. 

  2465.     ITypeInfo *pTypeInfo;
    2466. 

  2466.     TYPEATTR  *pTypeAttr;
    2467. 

  2467.     VARDESC   *pVarDesc;
    2468. 

  2468.     HRESULT hr;
    2469. 

  2469.     unsigned int len;
    2470. 

  2470.     BSTR bstr;
    2471. 

  2471.     char *pName = NULL;
    2472. 

  2472.     VALUE val;
    2473. 

  2473.     VALUE constant;
    2474. 

  2474.     ID id;
    2475. 

  2475.     constant = rb_hash_new();
    2476. 

  2476.     count = pTypeLib->lpVtbl->GetTypeInfoCount(pTypeLib);
    2477. 

  2477.     for (index = 0; index < count; index++) {
    2478. 

  2478.         hr = pTypeLib->lpVtbl->GetTypeInfo(pTypeLib, index, &pTypeInfo);
    2479. 

  2479.         if (FAILED(hr))
    2480. 

  2480.             continue;
    2481. 

  2481.         hr = OLE_GET_TYPEATTR(pTypeInfo, &pTypeAttr);
    2482. 

  2482.         if(FAILED(hr)) {
    2483. 

  2483.             OLE_RELEASE(pTypeInfo);
    2484. 

  2484.             continue;
    2485. 

  2485.         }
    2486. 

  2486.         for(iVar = 0; iVar < pTypeAttr->cVars; iVar++) {
    2487. 

  2487.             hr = pTypeInfo->lpVtbl->GetVarDesc(pTypeInfo, iVar, &pVarDesc);
    2488. 

  2488.             if(FAILED(hr))
    2489. 

  2489.                 continue;
    2490. 

  2490.             if(pVarDesc->varkind == VAR_CONST &&
    2491. 

  2491.                !(pVarDesc->wVarFlags & (VARFLAG_FHIDDEN |
    2492. 

  2492.                                         VARFLAG_FRESTRICTED |
    2493. 

  2493.                                         VARFLAG_FNONBROWSABLE))) {
    2494. 

  2494.                 hr = pTypeInfo->lpVtbl->GetNames(pTypeInfo, pVarDesc->memid, &bstr,
    2495. 

  2495.                                                  1, &len);
    2496. 

  2496.                 if(FAILED(hr) || len == 0 || !bstr)
    2497. 

  2497.                     continue;
    2498. 

  2498.                 pName = ole_wc2mb(bstr);
    2499. 

  2499.                 val = ole_variant2val(V_UNION1(pVarDesc, lpvarValue));
    2500. 

  2500.                 *pName = toupper((int)*pName);
    2501. 

  2501.                 id = rb_intern(pName);
    2502. 

  2502.                 if (rb_is_const_id(id)) {
    2503. 

  2503.                     rb_define_const(klass, pName, val);
    2504. 

  2504.                 }
    2505. 

  2505.                 else {
    2506. 

  2506.                     rb_hash_aset(constant, rb_str_new2(pName), val);
    2507. 

  2507.                 }
    2508. 

  2508.                 SysFreeString(bstr);
    2509. 

  2509.                 if(pName) {
    2510. 

  2510.                     free(pName);
    2511. 

  2511.                     pName = NULL;
    2512. 

  2512.                 }
    2513. 

  2513.             }
    2514. 

  2514.             pTypeInfo->lpVtbl->ReleaseVarDesc(pTypeInfo, pVarDesc);
    2515. 

  2515.         }
    2516. 

  2516.         pTypeInfo->lpVtbl->ReleaseTypeAttr(pTypeInfo, pTypeAttr);
    2517. 

  2517.         OLE_RELEASE(pTypeInfo);
    2518. 

  2518.     }
    2519. 

  2519.     rb_define_const(klass, "CONSTANTS", constant);
    2520. 

  2520. }
    2521. 

  2521. 

  2522. static HRESULT
    2523. 

  2523. clsid_from_remote(VALUE host, VALUE com, CLSID *pclsid)
    2524. 

  2524. {
    2525. 

  2525.     HKEY hlm;
    2526. 

  2526.     HKEY hpid;
    2527. 

  2527.     VALUE subkey;
    2528. 

  2528.     LONG err;
    2529. 

  2529.     char clsid[100];
    2530. 

  2530.     OLECHAR *pbuf;
    2531. 

  2531.     DWORD len;
    2532. 

  2532.     DWORD dwtype;
    2533. 

  2533.     HRESULT hr = S_OK;
    2534. 

  2534.     err = RegConnectRegistry(StringValuePtr(host), HKEY_LOCAL_MACHINE, &hlm);
    2535. 

  2535.     if (err != ERROR_SUCCESS)
    2536. 

  2536.         return HRESULT_FROM_WIN32(err);
    2537. 

  2537.     subkey = rb_str_new2("SOFTWARE\\Classes\\");
    2538. 

  2538.     rb_str_concat(subkey, com);
    2539. 

  2539.     rb_str_cat2(subkey, "\\CLSID");
    2540. 

  2540.     err = RegOpenKeyEx(hlm, StringValuePtr(subkey), 0, KEY_READ, &hpid);
    2541. 

  2541.     if (err != ERROR_SUCCESS)
    2542. 

  2542.         hr = HRESULT_FROM_WIN32(err);
    2543. 

  2543.     else {
    2544. 

  2544.         len = sizeof(clsid);
    2545. 

  2545.         err = RegQueryValueEx(hpid, (LPBYTE)"", NULL, &dwtype, clsid, &len);
    2546. 

  2546.         if (err == ERROR_SUCCESS && dwtype == REG_SZ) {
    2547. 

  2547.             pbuf  = ole_mb2wc(clsid, -1);
    2548. 

  2548.             hr = CLSIDFromString(pbuf, pclsid);
    2549. 

  2549.             SysFreeString(pbuf);
    2550. 

  2550.         }
    2551. 

  2551.         else {
    2552. 

  2552.             hr = HRESULT_FROM_WIN32(err);
    2553. 

  2553.         }
    2554. 

  2554.         RegCloseKey(hpid);
    2555. 

  2555.     }
    2556. 

  2556.     RegCloseKey(hlm);
    2557. 

  2557.     return hr;
    2558. 

  2558. }
    2559. 

  2559. 

  2560. static VALUE
    2561. 

  2561. ole_create_dcom(int argc, VALUE *argv, VALUE self)
    2562. 

  2562. {
    2563. 

  2563.     VALUE ole, host, others;
    2564. 

  2564.     HRESULT hr;
    2565. 

  2565.     CLSID   clsid;
    2566. 

  2566.     OLECHAR *pbuf;
    2567. 

  2567. 

  2568.     COSERVERINFO serverinfo;
    2569. 

  2569.     MULTI_QI multi_qi;
    2570. 

  2570.     DWORD clsctx = CLSCTX_REMOTE_SERVER;
    2571. 

  2571. 

  2572.     if (!gole32)
    2573. 

  2573.         gole32 = LoadLibrary("OLE32");
    2574. 

  2574.     if (!gole32)
    2575. 

  2575.         rb_raise(rb_eRuntimeError, "failed to load OLE32");
    2576. 

  2576.     if (!gCoCreateInstanceEx)
    2577. 

  2577.         gCoCreateInstanceEx = (FNCOCREATEINSTANCEEX*)
    2578. 

  2578.             GetProcAddress(gole32, "CoCreateInstanceEx");
    2579. 

  2579.     if (!gCoCreateInstanceEx)
    2580. 

  2580.         rb_raise(rb_eRuntimeError, "CoCreateInstanceEx is not supported in this environment");
    2581. 

  2581.     rb_scan_args(argc, argv, "2*", &ole, &host, &others);
    2582. 

  2582. 

  2583.     pbuf  = ole_vstr2wc(ole);
    2584. 

  2584.     hr = CLSIDFromProgID(pbuf, &clsid);
    2585. 

  2585.     if (FAILED(hr))
    2586. 

  2586.         hr = clsid_from_remote(host, ole, &clsid);
    2587. 

  2587.     if (FAILED(hr))
    2588. 

  2588.         hr = CLSIDFromString(pbuf, &clsid);
    2589. 

  2589.     SysFreeString(pbuf);
    2590. 

  2590.     if (FAILED(hr))
    2591. 

  2591.         ole_raise(hr, eWIN32OLERuntimeError, 
    2592. 

  2592.                   "unknown OLE server: `%s'",
    2593. 

  2593.                   StringValuePtr(ole));
    2594. 

  2594.     memset(&serverinfo, 0, sizeof(COSERVERINFO));    
    2595. 

  2595.     serverinfo.pwszName = ole_vstr2wc(host);
    2596. 

  2596.     memset(&multi_qi, 0, sizeof(MULTI_QI));
    2597. 

  2597.     multi_qi.pIID = &IID_IDispatch;
    2598. 

  2598.     hr = gCoCreateInstanceEx(&clsid, NULL, clsctx, &serverinfo, 1, &multi_qi);
    2599. 

  2599.     SysFreeString(serverinfo.pwszName);
    2600. 

  2600.     if (FAILED(hr))
    2601. 

  2601.         ole_raise(hr, eWIN32OLERuntimeError, 
    2602. 

  2602.                   "failed to create DCOM server `%s' in `%s'",
    2603. 

  2603.                   StringValuePtr(ole),
    2604. 

  2604.                   StringValuePtr(host));
    2605. 

  2605. 

  2606.     ole_set_member(self, (IDispatch*)multi_qi.pItf);
    2607. 

  2607.     return self;
    2608. 

  2608. }
    2609. 

  2609. 

  2610. static VALUE
    2611. 

  2611. ole_bind_obj(VALUE moniker, int argc, VALUE *argv, VALUE self)
    2612. 

  2612. {
    2613. 

  2613.     IBindCtx *pBindCtx;
    2614. 

  2614.     IMoniker *pMoniker;
    2615. 

  2615.     IDispatch *pDispatch;
    2616. 

  2616.     void *p;
    2617. 

  2617.     HRESULT hr;
    2618. 

  2618.     OLECHAR *pbuf;
    2619. 

  2619.     ULONG eaten = 0;
    2620. 

  2620.     
    2621. 

  2621.     ole_initialize();
    2622. 

  2622. 

  2623.     hr = CreateBindCtx(0, &pBindCtx);
    2624. 

  2624.     if(FAILED(hr)) {
    2625. 

  2625.         ole_raise(hr, eWIN32OLERuntimeError, 
    2626. 

  2626.                   "failed to create bind context");
    2627. 

  2627.     }
    2628. 

  2628. 

  2629.     pbuf  = ole_vstr2wc(moniker);
    2630. 

  2630.     hr = MkParseDisplayName(pBindCtx, pbuf, &eaten, &pMoniker);
    2631. 

  2631.     SysFreeString(pbuf);
    2632. 

  2632.     if(FAILED(hr)) {
    2633. 

  2633.         OLE_RELEASE(pBindCtx);
    2634. 

  2634.         ole_raise(hr, eWIN32OLERuntimeError,
    2635. 

  2635.                   "failed to parse display name of moniker `%s'",
    2636. 

  2636.                   StringValuePtr(moniker));
    2637. 

  2637.     }
    2638. 

  2638.     hr = pMoniker->lpVtbl->BindToObject(pMoniker, pBindCtx, NULL, 
    2639. 

  2639.                                         &IID_IDispatch, &p);
    2640. 

  2640.     pDispatch = p;
    2641. 

  2641.     OLE_RELEASE(pMoniker);
    2642. 

  2642.     OLE_RELEASE(pBindCtx);
    2643. 

  2643. 

  2644.     if(FAILED(hr)) {
    2645. 

  2645.         ole_raise(hr, eWIN32OLERuntimeError,
    2646. 

  2646.                   "failed to bind moniker `%s'",
    2647. 

  2647.                   StringValuePtr(moniker));
    2648. 

  2648.     }
    2649. 

  2649.     return create_win32ole_object(self, pDispatch, argc, argv);
    2650. 

  2650. }
    2651. 

  2651. 

  2652. /*
    2653. 

  2653.  *  call-seq:
    2654. 

  2654.  *     WIN32OLE.connect( ole ) --> aWIN32OLE
    2655. 

  2655.  * 
    2656. 

  2656.  *  Returns running OLE Automation object or WIN32OLE object from moniker.
    2657. 

  2657.  *  1st argument should be OLE program id or class id or moniker.
    2658. 

  2658.  *     
    2659. 

  2659.  *     WIN32OLE.connect('Excel.Application') # => WIN32OLE object which represents running Excel.
    2660. 

  2660.  */
    2661. 

  2661. static VALUE
    2662. 

  2662. fole_s_connect(int argc, VALUE *argv, VALUE self)
    2663. 

  2663. {
    2664. 

  2664.     VALUE svr_name;
    2665. 

  2665.     VALUE others;
    2666. 

  2666.     HRESULT hr;
    2667. 

  2667.     CLSID   clsid;
    2668. 

  2668.     OLECHAR *pBuf;
    2669. 

  2669.     IDispatch *pDispatch;
    2670. 

  2670.     void *p;
    2671. 

  2671.     IUnknown *pUnknown;
    2672. 

  2672. 

  2673.     rb_secure(4);
    2674. 

  2674.     /* initialize to use OLE */
    2675. 

  2675.     ole_initialize();
    2676. 

  2676. 

  2677.     rb_scan_args(argc, argv, "1*", &svr_name, &others);
    2678. 

  2678.     SafeStringValue(svr_name);
    2679. 

  2679.     if (rb_safe_level() > 0 && OBJ_TAINTED(svr_name)) {
    2680. 

  2680.         rb_raise(rb_eSecurityError, "Insecure Object Connection - %s", 
    2681. 

  2681. 		 StringValuePtr(svr_name));
    2682. 

  2682.     }
    2683. 

  2683. 

  2684.     /* get CLSID from OLE server name */
    2685. 

  2685.     pBuf = ole_vstr2wc(svr_name);
    2686. 

  2686.     hr = CLSIDFromProgID(pBuf, &clsid);
    2687. 

  2687.     if(FAILED(hr)) {
    2688. 

  2688.         hr = CLSIDFromString(pBuf, &clsid);
    2689. 

  2689.     }
    2690. 

  2690.     SysFreeString(pBuf);
    2691. 

  2691.     if(FAILED(hr)) {
    2692. 

  2692.         return ole_bind_obj(svr_name, argc, argv, self);
    2693. 

  2693.     }
    2694. 

  2694. 

  2695.     hr = GetActiveObject(&clsid, 0, &pUnknown);
    2696. 

  2696.     if (FAILED(hr)) {
    2697. 

  2697.         ole_raise(hr, eWIN32OLERuntimeError, 
    2698. 

  2698.                   "OLE server `%s' not running", StringValuePtr(svr_name));
    2699. 

  2699.     }
    2700. 

  2700.     hr = pUnknown->lpVtbl->QueryInterface(pUnknown, &IID_IDispatch, &p);
    2701. 

  2701.     pDispatch = p;
    2702. 

  2702.     if(FAILED(hr)) {
    2703. 

  2703.         OLE_RELEASE(pUnknown);
    2704. 

  2704.         ole_raise(hr, eWIN32OLERuntimeError, 
    2705. 

  2705.                   "failed to create WIN32OLE server `%s'", 
    2706. 

  2706.                   StringValuePtr(svr_name));
    2707. 

  2707.     }
    2708. 

  2708. 

  2709.     OLE_RELEASE(pUnknown);
    2710. 

  2710. 

  2711.     return create_win32ole_object(self, pDispatch, argc, argv);
    2712. 

  2712. }
    2713. 

  2713. 

  2714. /* 
    2715. 

  2715.  *  call-seq:
    2716. 

  2716.  *     WIN32OLE.const_load( ole, mod = WIN32OLE)
    2717. 

  2717.  * 
    2718. 

  2718.  *  Defines the constants of OLE Automation server as mod's constants.
    2719. 

  2719.  *  The first argument is WIN32OLE object or type library name.
    2720. 

  2720.  *  If 2nd argument is omitted, the default is WIN32OLE.
    2721. 

  2721.  *  The first letter of Ruby's constant variable name is upper case,
    2722. 

  2722.  *  so constant variable name of WIN32OLE object is capitalized.
    2723. 

  2723.  *  For example, the 'xlTop' constant of Excel is changed to 'XlTop' 
    2724. 

  2724.  *  in WIN32OLE.
    2725. 

  2725.  *  If the first letter of constant variabl is not [A-Z], then
    2726. 

  2726.  *  the constant is defined as CONSTANTS hash element.
    2727. 

  2727.  *
    2728. 

  2728.  *     module EXCEL_CONST
    2729. 

  2729.  *     end
    2730. 

  2730.  *     excel = WIN32OLE.new('Excel.Application')
    2731. 

  2731.  *     WIN32OLE.const_load(excel, EXCEL_CONST)
    2732. 

  2732.  *     puts EXCEL_CONST::XlTop # => -4160
    2733. 

  2733.  *     puts EXCEL_CONST::CONSTANTS['_xlDialogChartSourceData'] # => 541
    2734. 

  2734.  *     
    2735. 

  2735.  *     WIN32OLE.const_load(excel)
    2736. 

  2736.  *     puts WIN32OLE::XlTop # => -4160
    2737. 

  2737.  *
    2738. 

  2738.  *     module MSO
    2739. 

  2739.  *     end
    2740. 

  2740.  *     WIN32OLE.const_load('Microsoft Office 9.0 Object Library', MSO)
    2741. 

  2741.  *     puts MSO::MsoLineSingle # => 1
    2742. 

  2742.  */
    2743. 

  2743. static VALUE
    2744. 

  2744. fole_s_const_load(int argc, VALUE *argv, VALUE self)
    2745. 

  2745. {
    2746. 

  2746.     VALUE ole;
    2747. 

  2747.     VALUE klass;
    2748. 

  2748.     struct oledata *pole;
    2749. 

  2749.     ITypeInfo *pTypeInfo;
    2750. 

  2750.     ITypeLib *pTypeLib;
    2751. 

  2751.     unsigned int index;
    2752. 

  2752.     HRESULT hr;
    2753. 

  2753.     OLECHAR *pBuf;
    2754. 

  2754.     VALUE file;
    2755. 

  2755.     LCID    lcid = cWIN32OLE_lcid;
    2756. 

  2756.     
    2757. 

  2757.     rb_secure(4);
    2758. 

  2758.     rb_scan_args(argc, argv, "11", &ole, &klass);
    2759. 

  2759.     if (TYPE(klass) != T_CLASS &&
    2760. 

  2760.         TYPE(klass) != T_MODULE &&
    2761. 

  2761.         TYPE(klass) != T_NIL) {
    2762. 

  2762.         rb_raise(rb_eTypeError, "2nd parameter must be Class or Module");
    2763. 

  2763.     }
    2764. 

  2764.     if (rb_obj_is_kind_of(ole, cWIN32OLE)) {
    2765. 

  2765.         OLEData_Get_Struct(ole, pole);
    2766. 

  2766.         hr = pole->pDispatch->lpVtbl->GetTypeInfo(pole->pDispatch,
    2767. 

  2767.                                                   0, lcid, &pTypeInfo);
    2768. 

  2768.         if(FAILED(hr)) {
    2769. 

  2769.             ole_raise(hr, rb_eRuntimeError, "failed to GetTypeInfo");
    2770. 

  2770.         }
    2771. 

  2771.         hr = pTypeInfo->lpVtbl->GetContainingTypeLib(pTypeInfo, &pTypeLib, &index);
    2772. 

  2772.         if(FAILED(hr)) {
    2773. 

  2773.             OLE_RELEASE(pTypeInfo);
    2774. 

  2774.             ole_raise(hr, rb_eRuntimeError, "failed to GetContainingTypeLib");
    2775. 

  2775.         }
    2776. 

  2776.         OLE_RELEASE(pTypeInfo);
    2777. 

  2777.         if(TYPE(klass) != T_NIL) {
    2778. 

  2778.             ole_const_load(pTypeLib, klass, self);
    2779. 

  2779.         }
    2780. 

  2780.         else {
    2781. 

  2781.             ole_const_load(pTypeLib, cWIN32OLE, self);
    2782. 

  2782.         }
    2783. 

  2783.         OLE_RELEASE(pTypeLib);
    2784. 

  2784.     }
    2785. 

  2785.     else if(TYPE(ole) == T_STRING) {
    2786. 

  2786.         file = typelib_file(ole);
    2787. 

  2787.         if (file == Qnil) {
    2788. 

  2788.             file = ole;
    2789. 

  2789.         }
    2790. 

  2790.         pBuf = ole_vstr2wc(file);
    2791. 

  2791.         hr = LoadTypeLibEx(pBuf, REGKIND_NONE, &pTypeLib);
    2792. 

  2792.         SysFreeString(pBuf);
    2793. 

  2793.         if (FAILED(hr))
    2794. 

  2794.           ole_raise(hr, eWIN32OLERuntimeError, "failed to LoadTypeLibEx");
    2795. 

  2795.         if(TYPE(klass) != T_NIL) {
    2796. 

  2796.             ole_const_load(pTypeLib, klass, self);
    2797. 

  2797.         }
    2798. 

  2798.         else {
    2799. 

  2799.             ole_const_load(pTypeLib, cWIN32OLE, self);
    2800. 

  2800.         }
    2801. 

  2801.         OLE_RELEASE(pTypeLib);
    2802. 

  2802.     }
    2803. 

  2803.     else {
    2804. 

  2804.         rb_raise(rb_eTypeError, "1st parameter must be WIN32OLE instance");
    2805. 

  2805.     }
    2806. 

  2806.     return Qnil;
    2807. 

  2807. }
    2808. 

  2808. 

  2809. static VALUE
    2810. 

  2810. ole_types_from_typelib(ITypeLib *pTypeLib, VALUE classes)
    2811. 

  2811. {
    2812. 

  2812.     
    2813. 

  2813.     long count;
    2814. 

  2814.     int i;
    2815. 

  2815.     HRESULT hr;
    2816. 

  2816.     BSTR bstr;
    2817. 

  2817.     ITypeInfo *pTypeInfo;
    2818. 

  2818.     VALUE type;
    2819. 

  2819.   
    2820. 

  2820.     rb_secure(4);
    2821. 

  2821.     count = pTypeLib->lpVtbl->GetTypeInfoCount(pTypeLib);
    2822. 

  2822.     for (i = 0; i < count; i++) {
    2823. 

  2823.         hr = pTypeLib->lpVtbl->GetDocumentation(pTypeLib, i,
    2824. 

  2824.                                                 &bstr, NULL, NULL, NULL);
    2825. 

  2825.         if (FAILED(hr)) 
    2826. 

  2826.             continue;
    2827. 

  2827. 

  2828.         hr = pTypeLib->lpVtbl->GetTypeInfo(pTypeLib, i, &pTypeInfo);
    2829. 

  2829.         if (FAILED(hr))
    2830. 

  2830.             continue;
    2831. 

  2831. 

  2832.         type = foletype_s_allocate(cWIN32OLE_TYPE);
    2833. 

  2833.         oletype_set_member(type, pTypeInfo, WC2VSTR(bstr));
    2834. 

  2834. 

  2835.         rb_ary_push(classes, type);
    2836. 

  2836.         OLE_RELEASE(pTypeInfo);
    2837. 

  2837.     }
    2838. 

  2838.     return classes;
    2839. 

  2839. }
    2840. 

  2840. 

  2841. static ULONG
    2842. 

  2842. reference_count(struct oledata * pole)
    2843. 

  2843. {
    2844. 

  2844.     ULONG n = 0;
    2845. 

  2845.     if(pole->pDispatch) {
    2846. 

  2846.         OLE_ADDREF(pole->pDispatch);
    2847. 

  2847.         n = OLE_RELEASE(pole->pDispatch);
    2848. 

  2848.     }
    2849. 

  2849.     return n;
    2850. 

  2850. }
    2851. 

  2851. 

  2852. /*
    2853. 

  2853.  *  call-seq:
    2854. 

  2854.  *     WIN32OLE.ole_reference_count(aWIN32OLE) --> number
    2855. 

  2855.  * 
    2856. 

  2856.  *  Returns reference counter of Dispatch interface of WIN32OLE object. 
    2857. 

  2857.  *  You should not use this method because this method
    2858. 

  2858.  *  exists only for debugging WIN32OLE.
    2859. 

  2859.  */
    2860. 

  2860. static VALUE
    2861. 

  2861. fole_s_reference_count(VALUE self, VALUE obj)
    2862. 

  2862. {
    2863. 

  2863.     struct oledata * pole;
    2864. 

  2864.     OLEData_Get_Struct(obj, pole);
    2865. 

  2865.     return INT2NUM(reference_count(pole));
    2866. 

  2866. }
    2867. 

  2867. 

  2868. /*
    2869. 

  2869.  *  call-seq:
    2870. 

  2870.  *     WIN32OLE.ole_free(aWIN32OLE) --> number
    2871. 

  2871.  * 
    2872. 

  2872.  *  Invokes Release method of Dispatch interface of WIN32OLE object. 
    2873. 

  2873.  *  You should not use this method because this method
    2874. 

  2874.  *  exists only for debugging WIN32OLE.
    2875. 

  2875.  *  The return value is reference counter of OLE object.
    2876. 

  2876.  */
    2877. 

  2877. static VALUE
    2878. 

  2878. fole_s_free(VALUE self, VALUE obj)
    2879. 

  2879. {
    2880. 

  2880.     ULONG n = 0;
    2881. 

  2881.     struct oledata * pole;
    2882. 

  2882.     OLEData_Get_Struct(obj, pole);
    2883. 

  2883.     if(pole->pDispatch) {
    2884. 

  2884.         if (reference_count(pole) > 0) {
    2885. 

  2885.             n = OLE_RELEASE(pole->pDispatch);
    2886. 

  2886.         }
    2887. 

  2887.     }
    2888. 

  2888.     return INT2NUM(n);
    2889. 

  2889. }
    2890. 

  2890. 

  2891. static HWND
    2892. 

  2892. ole_show_help(VALUE helpfile, VALUE helpcontext)
    2893. 

  2893. {
    2894. 

  2894.     FNHTMLHELP *pfnHtmlHelp;
    2895. 

  2895.     HWND hwnd = 0;
    2896. 

  2896. 

  2897.     if(!ghhctrl)
    2898. 

  2898.         ghhctrl = LoadLibrary("HHCTRL.OCX");
    2899. 

  2899.     if (!ghhctrl)
    2900. 

  2900.         return hwnd;
    2901. 

  2901.     pfnHtmlHelp = (FNHTMLHELP*)GetProcAddress(ghhctrl, "HtmlHelpA");
    2902. 

  2902.     if (!pfnHtmlHelp)
    2903. 

  2903.         return hwnd;
    2904. 

  2904.     hwnd = pfnHtmlHelp(GetDesktopWindow(), StringValuePtr(helpfile), 
    2905. 

  2905.                     0x0f, NUM2INT(helpcontext));
    2906. 

  2906.     if (hwnd == 0)
    2907. 

  2907.         hwnd = pfnHtmlHelp(GetDesktopWindow(), StringValuePtr(helpfile), 
    2908. 

  2908.                  0,  NUM2INT(helpcontext));
    2909. 

  2909.     return hwnd;
    2910. 

  2910. }
    2911. 

  2911. 

  2912. /*
    2913. 

  2913.  *  call-seq:
    2914. 

  2914.  *     WIN32OLE.ole_show_help(obj [,helpcontext])
    2915. 

  2915.  * 
    2916. 

  2916.  *  Displays helpfile. The 1st argument specifies WIN32OLE_TYPE
    2917. 

  2917.  *  object or WIN32OLE_METHOD object or helpfile.
    2918. 

  2918.  *
    2919. 

  2919.  *     excel = WIN32OLE.new('Excel.Application')
    2920. 

  2920.  *     typeobj = excel.ole_type
    2921. 

  2921.  *     WIN32OLE.ole_show_help(typeobj)
    2922. 

  2922.  */
    2923. 

  2923. static VALUE
    2924. 

  2924. fole_s_show_help(int argc, VALUE *argv, VALUE self)
    2925. 

  2925. {
    2926. 

  2926.     VALUE target;
    2927. 

  2927.     VALUE helpcontext;
    2928. 

  2928.     VALUE helpfile;
    2929. 

  2929.     VALUE name;
    2930. 

  2930.     HWND  hwnd;
    2931. 

  2931.     rb_scan_args(argc, argv, "11", &target, &helpcontext);
    2932. 

  2932.     if (rb_obj_is_kind_of(target, cWIN32OLE_TYPE) ||
    2933. 

  2933.         rb_obj_is_kind_of(target, cWIN32OLE_METHOD)) {
    2934. 

  2934.         helpfile = rb_funcall(target, rb_intern("helpfile"), 0);
    2935. 

  2935.         if(strlen(StringValuePtr(helpfile)) == 0) {
    2936. 

  2936.             name = rb_ivar_get(target, rb_intern("name"));
    2937. 

  2937.             rb_raise(rb_eRuntimeError, "no helpfile of `%s'",
    2938. 

  2938.                      StringValuePtr(name));
    2939. 

  2939.         }
    2940. 

  2940.         helpcontext = rb_funcall(target, rb_intern("helpcontext"), 0);
    2941. 

  2941.     } else {
    2942. 

  2942.         helpfile = target;
    2943. 

  2943.     }
    2944. 

  2944.     if (TYPE(helpfile) != T_STRING) {
    2945. 

  2945.         rb_raise(rb_eTypeError, "1st parameter must be (String|WIN32OLE_TYPE|WIN32OLE_METHOD)");
    2946. 

  2946.     }
    2947. 

  2947.     hwnd = ole_show_help(helpfile, helpcontext);
    2948. 

  2948.     if(hwnd == 0) {
    2949. 

  2949.         rb_raise(rb_eRuntimeError, "failed to open help file `%s'",
    2950. 

  2950.                  StringValuePtr(helpfile));
    2951. 

  2951.     }
    2952. 

  2952.     return Qnil;
    2953. 

  2953. }
    2954. 

  2954. 

  2955. /* 
    2956. 

  2956.  *  call-seq:
    2957. 

  2957.  *     WIN32OLE.codepage
    2958. 

  2958.  * 
    2959. 

  2959.  *  Returns current codepage.
    2960. 

  2960.  *     WIN32OLE.codepage # => WIN32OLE::CP_ACP
    2961. 

  2961.  */
    2962. 

  2962. static VALUE
    2963. 

  2963. fole_s_get_code_page(VALUE self)
    2964. 

  2964. {
    2965. 

  2965.     return INT2FIX(cWIN32OLE_cp);
    2966. 

  2966. }
    2967. 

  2967. 

  2968. static BOOL CALLBACK 
    2969. 

  2969. installed_code_page_proc(LPTSTR str) {
    2970. 

  2970.     if (strtoul(str, NULL, 10) == g_cp_to_check) {
    2971. 

  2971.         g_cp_installed = TRUE;
    2972. 

  2972.         return FALSE;
    2973. 

  2973.     }
    2974. 

  2974.     return TRUE;
    2975. 

  2975. }
    2976. 

  2976. 

  2977. static BOOL 
    2978. 

  2978. code_page_installed(UINT cp)
    2979. 

  2979. {
    2980. 

  2980.     g_cp_installed = FALSE;
    2981. 

  2981.     g_cp_to_check = cp;
    2982. 

  2982.     EnumSystemCodePages(installed_code_page_proc, CP_INSTALLED);
    2983. 

  2983.     return g_cp_installed;
    2984. 

  2984. }
    2985. 

  2985. 

  2986. /* 
    2987. 

  2987.  *  call-seq:
    2988. 

  2988.  *     WIN32OLE.codepage = CP
    2989. 

  2989.  * 
    2990. 

  2990.  *  Sets current codepage. 
    2991. 

  2991.  *  The WIN32OLE.codepage is initialized according to 
    2992. 

  2992.  *  Encoding.default_internal.
    2993. 

  2993.  *  If Encoding.default_internal is nil then WIN32OLE.codepage
    2994. 

  2994.  *  is initialized according to Encoding.default_external.
    2995. 

  2995.  *
    2996. 

  2996.  *     WIN32OLE.codepage = WIN32OLE::CP_UTF8
    2997. 

  2997.  *     WIN32OLE.codepage = 65001
    2998. 

  2998.  */
    2999. 

  2999. static VALUE
    3000. 

  3000. fole_s_set_code_page(VALUE self, VALUE vcp)
    3001. 

  3001. {
    3002. 

  3002.     UINT cp = FIX2INT(vcp);
    3003. 

  3003.     set_ole_codepage(cp);
    3004. 

  3004.     /*
    3005. 

  3005.      * Should this method return old codepage?
    3006. 

  3006.      */
    3007. 

  3007.     return Qnil;
    3008. 

  3008. }
    3009. 

  3009. 

  3010. /*
    3011. 

  3011.  *  call-seq:
    3012. 

  3012.  *     WIN32OLE.locale -> locale id.
    3013. 

  3013.  *
    3014. 

  3014.  *  Returns current locale id (lcid). The default locale is
    3015. 

  3015.  *  LOCALE_SYSTEM_DEFAULT.
    3016. 

  3016.  *
    3017. 

  3017.  *     lcid = WIN32OLE.locale
    3018. 

  3018.  */
    3019. 

  3019. static VALUE 
    3020. 

  3020. fole_s_get_locale(VALUE self)
    3021. 

  3021. {
    3022. 

  3022.     return INT2FIX(cWIN32OLE_lcid);
    3023. 

  3023. }
    3024. 

  3024. 

  3025. static BOOL
    3026. 

  3026. CALLBACK installed_lcid_proc(LPTSTR str)
    3027. 

  3027. {
    3028. 

  3028.     if (strcmp(str, g_lcid_to_check) == 0) {
    3029. 

  3029.         g_lcid_installed = TRUE;
    3030. 

  3030.         return FALSE;
    3031. 

  3031.     }
    3032. 

  3032.     return TRUE;
    3033. 

  3033. }
    3034. 

  3034. 

  3035. static BOOL
    3036. 

  3036. lcid_installed(LCID lcid)
    3037. 

  3037. {
    3038. 

  3038.     g_lcid_installed = FALSE;
    3039. 

  3039.     snprintf(g_lcid_to_check, sizeof(g_lcid_to_check), "%08lx", lcid);
    3040. 

  3040.     EnumSystemLocales(installed_lcid_proc, LCID_INSTALLED);
    3041. 

  3041.     return g_lcid_installed;
    3042. 

  3042. }
    3043. 

  3043. 

  3044. /*
    3045. 

  3045.  *  call-seq:
    3046. 

  3046.  *     WIN32OLE.locale = lcid
    3047. 

  3047.  *
    3048. 

  3048.  *  Sets current locale id (lcid).
    3049. 

  3049.  *
    3050. 

  3050.  *     WIN32OLE.locale = 1033 # set locale English(U.S)
    3051. 

  3051.  *     obj = WIN32OLE_VARIANT.new("$100,000", WIN32OLE::VARIANT::VT_CY)
    3052. 

  3052.  *
    3053. 

  3053.  */
    3054. 

  3054. static VALUE 
    3055. 

  3055. fole_s_set_locale(VALUE self, VALUE vlcid)
    3056. 

  3056. {
    3057. 

  3057.     LCID lcid = FIX2INT(vlcid);
    3058. 

  3058.     if (lcid_installed(lcid)) {
    3059. 

  3059.         cWIN32OLE_lcid = lcid;
    3060. 

  3060.     } else {
    3061. 

  3061.         switch (lcid) {
    3062. 

  3062.         case LOCALE_SYSTEM_DEFAULT:
    3063. 

  3063.         case LOCALE_USER_DEFAULT:
    3064. 

  3064.             cWIN32OLE_lcid = lcid;
    3065. 

  3065.             break;
    3066. 

  3066.         default:
    3067. 

  3067.             rb_raise(eWIN32OLERuntimeError, "not installed locale: %u", (unsigned int)lcid);
    3068. 

  3068.         }
    3069. 

  3069.     }
    3070. 

  3070.     return Qnil;
    3071. 

  3071. }
    3072. 

  3072. 

  3073. /* 
    3074. 

  3074.  *  call-seq:
    3075. 

  3075.  *     WIN32OLE.create_guid
    3076. 

  3076.  * 
    3077. 

  3077.  *  Creates GUID.
    3078. 

  3078.  *     WIN32OLE.create_guid # => {1CB530F1-F6B1-404D-BCE6-1959BF91F4A8} 
    3079. 

  3079.  */
    3080. 

  3080. static VALUE
    3081. 

  3081. fole_s_create_guid(VALUE self)
    3082. 

  3082. {
    3083. 

  3083.     GUID guid;
    3084. 

  3084.     HRESULT hr;
    3085. 

  3085.     OLECHAR bstr[80];
    3086. 

  3086.     int len = 0;
    3087. 

  3087.     hr = CoCreateGuid(&guid);
    3088. 

  3088.     if (FAILED(hr)) {
    3089. 

  3089.         ole_raise(hr, eWIN32OLERuntimeError, "failed to create GUID");
    3090. 

  3090.     }
    3091. 

  3091.     len = StringFromGUID2(&guid, bstr, sizeof(bstr)/sizeof(OLECHAR));
    3092. 

  3092.     if (len == 0) {
    3093. 

  3093.         rb_raise(rb_eRuntimeError, "failed to create GUID(buffer over)");
    3094. 

  3094.     }
    3095. 

  3095.     return ole_wc2vstr(bstr, FALSE);
    3096. 

  3096. }
    3097. 

  3097. 

  3098. /*
    3099. 

  3099.  * WIN32OLE.ole_initialize and WIN32OLE.ole_uninitialize
    3100. 

  3100.  * are used in win32ole.rb to fix the issue bug #2618 (ruby-core:27634).
    3101. 

  3101.  * You must not use thease method.
    3102. 

  3102.  */
    3103. 

  3103. 

  3104. static void  ole_pure_initialize()
    3105. 

  3105. {
    3106. 

  3106.     HRESULT hr;
    3107. 

  3107.     hr = OleInitialize(NULL);
    3108. 

  3108.     if(FAILED(hr)) {
    3109. 

  3109.         ole_raise(hr, rb_eRuntimeError, "fail: OLE initialize");
    3110. 

  3110.     }
    3111. 

  3111. }
    3112. 

  3112. 

  3113. static void  ole_pure_uninitialize()
    3114. 

  3114. {
    3115. 

  3115.     OleUninitialize();
    3116. 

  3116. }
    3117. 

  3117. 

  3118. /* :nodoc */
    3119. 

  3119. static VALUE 
    3120. 

  3120. fole_s_ole_initialize(VALUE self)
    3121. 

  3121. {
    3122. 

  3122.     ole_pure_initialize();
    3123. 

  3123.     return Qnil;
    3124. 

  3124. }
    3125. 

  3125. 

  3126. /* :nodoc */
    3127. 

  3127. static VALUE 
    3128. 

  3128. fole_s_ole_uninitialize(VALUE self)
    3129. 

  3129. {
    3130. 

  3130.     ole_pure_uninitialize();
    3131. 

  3131.     return Qnil;
    3132. 

  3132. }
    3133. 

  3133. 

  3134. /*
    3135. 

  3135.  * Document-class: WIN32OLE
    3136. 

  3136.  *
    3137. 

  3137.  *   <code>WIN32OLE</code> objects represent OLE Automation object in Ruby.
    3138. 

  3138.  *
    3139. 

  3139.  *   By using WIN32OLE, you can access OLE server like VBScript.
    3140. 

  3140.  *   
    3141. 

  3141.  *   Here is sample script.
    3142. 

  3142.  *
    3143. 

  3143.  *     require 'win32ole'
    3144. 

  3144.  *     
    3145. 

  3145.  *     excel = WIN32OLE.new('Excel.Application')
    3146. 

  3146.  *     excel.visible = true
    3147. 

  3147.  *     workbook = excel.Workbooks.Add();
    3148. 

  3148.  *     worksheet = workbook.Worksheets(1);
    3149. 

  3149.  *     worksheet.Range("A1:D1").value = ["North","South","East","West"];
    3150. 

  3150.  *     worksheet.Range("A2:B2").value = [5.2, 10];
    3151. 

  3151.  *     worksheet.Range("C2").value = 8;
    3152. 

  3152.  *     worksheet.Range("D2").value = 20;
    3153. 

  3153.  *     
    3154. 

  3154.  *     range = worksheet.Range("A1:D2");
    3155. 

  3155.  *     range.select
    3156. 

  3156.  *     chart = workbook.Charts.Add;
    3157. 

  3157.  *     
    3158. 

  3158.  *     workbook.saved = true;
    3159. 

  3159.  *     
    3160. 

  3160.  *     excel.ActiveWorkbook.Close(0);
    3161. 

  3161.  *     excel.Quit();
    3162. 

  3162.  *
    3163. 

  3163.  *  Unfortunately, Win32OLE doesn't support the argument passed by 
    3164. 

  3164.  *  reference directly.
    3165. 

  3165.  *  Instead, Win32OLE provides WIN32OLE::ARGV.
    3166. 

  3166.  *  If you want to get the result value of argument passed by reference,
    3167. 

  3167.  *  you can use WIN32OLE::ARGV.
    3168. 

  3168.  *
    3169. 

  3169.  *     oleobj.method(arg1, arg2, refargv3)
    3170. 

  3170.  *     puts WIN32OLE::ARGV[2]   # the value of refargv3 after called oleobj.method
    3171. 

  3171.  *     
    3172. 

  3172.  */
    3173. 

  3173. 

  3174. /*
    3175. 

  3175.  *  call-seq:
    3176. 

  3176.  *     WIN32OLE.new(server, [host]) -> WIN32OLE object
    3177. 

  3177.  * 
    3178. 

  3178.  *  Returns a new WIN32OLE object(OLE Automation object).
    3179. 

  3179.  *  The first argument server specifies OLE Automation server.
    3180. 

  3180.  *  The first argument should be CLSID or PROGID.
    3181. 

  3181.  *  If second argument host specified, then returns OLE Automation 
    3182. 

  3182.  *  object on host. 
    3183. 

  3183.  *
    3184. 

  3184.  *      WIN32OLE.new('Excel.Application') # => Excel OLE Automation WIN32OLE object.
    3185. 

  3185.  *      WIN32OLE.new('{00024500-0000-0000-C000-000000000046}') # => Excel OLE Automation WIN32OLE object.
    3186. 

  3186.  */
    3187. 

  3187. static VALUE
    3188. 

  3188. fole_initialize(int argc, VALUE *argv, VALUE self)
    3189. 

  3189. {
    3190. 

  3190.     VALUE svr_name;
    3191. 

  3191.     VALUE host;
    3192. 

  3192.     VALUE others;
    3193. 

  3193.     HRESULT hr;
    3194. 

  3194.     CLSID   clsid;
    3195. 

  3195.     OLECHAR *pBuf;
    3196. 

  3196.     IDispatch *pDispatch;
    3197. 

  3197.     void *p;
    3198. 

  3198.     rb_secure(4);
    3199. 

  3199.     rb_call_super(0, 0);
    3200. 

  3200.     rb_scan_args(argc, argv, "11*", &svr_name, &host, &others);
    3201. 

  3201. 

  3202.     SafeStringValue(svr_name);
    3203. 

  3203.     if (rb_safe_level() > 0 && OBJ_TAINTED(svr_name)) {
    3204. 

  3204.         rb_raise(rb_eSecurityError, "Insecure Object Creation - %s",
    3205. 

  3205.                  StringValuePtr(svr_name));
    3206. 

  3206.     }
    3207. 

  3207.     if (!NIL_P(host)) {
    3208. 

  3208. 	SafeStringValue(host);
    3209. 

  3209.         if (rb_safe_level() > 0 && OBJ_TAINTED(host)) {
    3210. 

  3210.             rb_raise(rb_eSecurityError, "Insecure Object Creation - %s",
    3211. 

  3211.                      StringValuePtr(svr_name));
    3212. 

  3212.         }
    3213. 

  3213.         return ole_create_dcom(argc, argv, self);
    3214. 

  3214.     }
    3215. 

  3215. 

  3216.     /* get CLSID from OLE server name */
    3217. 

  3217.     pBuf  = ole_vstr2wc(svr_name);
    3218. 

  3218.     hr = CLSIDFromProgID(pBuf, &clsid);
    3219. 

  3219.     if(FAILED(hr)) {
    3220. 

  3220.         hr = CLSIDFromString(pBuf, &clsid);
    3221. 

  3221.     }
    3222. 

  3222.     SysFreeString(pBuf);
    3223. 

  3223.     if(FAILED(hr)) {
    3224. 

  3224.         ole_raise(hr, eWIN32OLERuntimeError, 
    3225. 

  3225.                   "unknown OLE server: `%s'",
    3226. 

  3226.                   StringValuePtr(svr_name));
    3227. 

  3227.     }
    3228. 

  3228. 

  3229.     /* get IDispatch interface */
    3230. 

  3230.     hr = CoCreateInstance(&clsid, NULL, CLSCTX_INPROC_SERVER | CLSCTX_LOCAL_SERVER,
    3231. 

  3231.                           &IID_IDispatch, &p);
    3232. 

  3232.     pDispatch = p;
    3233. 

  3233.     if(FAILED(hr)) {
    3234. 

  3234.         ole_raise(hr, eWIN32OLERuntimeError,
    3235. 

  3235.                   "failed to create WIN32OLE object from `%s'",
    3236. 

  3236.                   StringValuePtr(svr_name));
    3237. 

  3237.     }
    3238. 

  3238. 

  3239.     ole_set_member(self, pDispatch);
    3240. 

  3240.     return self;
    3241. 

  3241. }
    3242. 

  3242. 

  3243. static VALUE
    3244. 

  3244. hash2named_arg(VALUE pair, struct oleparam* pOp)
    3245. 

  3245. {
    3246. 

  3246.     unsigned int index, i;
    3247. 

  3247.     VALUE key, value;
    3248. 

  3248.     index = pOp->dp.cNamedArgs;
    3249. 

  3249. 

  3250.     /*---------------------------------------------
    3251. 

  3251.       the data-type of key must be String or Symbol
    3252. 

  3252.     -----------------------------------------------*/
    3253. 

  3253.     key = rb_ary_entry(pair, 0);
    3254. 

  3254.     if(TYPE(key) != T_STRING && TYPE(key) != T_SYMBOL) {
    3255. 

  3255.         /* clear name of dispatch parameters */
    3256. 

  3256.         for(i = 1; i < index + 1; i++) {
    3257. 

  3257.             SysFreeString(pOp->pNamedArgs[i]);
    3258. 

  3258.         }
    3259. 

  3259.         /* clear dispatch parameters */
    3260. 

  3260.         for(i = 0; i < index; i++ ) {
    3261. 

  3261.             VariantClear(&(pOp->dp.rgvarg[i]));
    3262. 

  3262.         }
    3263. 

  3263.         /* raise an exception */
    3264. 

  3264.         rb_raise(rb_eTypeError, "wrong argument type (expected String or Symbol)");
    3265. 

  3265.     }
    3266. 

  3266.     if (TYPE(key) == T_SYMBOL) {
    3267. 

  3267. 	key = rb_sym_to_s(key);
    3268. 

  3268.     }
    3269. 

  3269. 

  3270.     /* pNamedArgs[0] is <method name>, so "index + 1" */
    3271. 

  3271.     pOp->pNamedArgs[index + 1] = ole_vstr2wc(key);
    3272. 

  3272. 

  3273.     value = rb_ary_entry(pair, 1);
    3274. 

  3274.     VariantInit(&(pOp->dp.rgvarg[index]));
    3275. 

  3275.     ole_val2variant(value, &(pOp->dp.rgvarg[index]));
    3276. 

  3276. 

  3277.     pOp->dp.cNamedArgs += 1;
    3278. 

  3278.     return Qnil;
    3279. 

  3279. }
    3280. 

  3280. 

  3281. static VALUE
    3282. 

  3282. set_argv(VARIANTARG* realargs, unsigned int beg, unsigned int end)
    3283. 

  3283. {
    3284. 

  3284.     VALUE argv = rb_const_get(cWIN32OLE, rb_intern("ARGV"));
    3285. 

  3285. 

  3286.     Check_Type(argv, T_ARRAY);
    3287. 

  3287.     rb_ary_clear(argv);
    3288. 

  3288.     while (end-- > beg) {
    3289. 

  3289.         rb_ary_push(argv, ole_variant2val(&realargs[end]));
    3290. 

  3290.         VariantClear(&realargs[end]);
    3291. 

  3291.     }
    3292. 

  3292.     return argv;
    3293. 

  3293. }
    3294. 

  3294. 

  3295. static VALUE
    3296. 

  3296. ole_invoke(int argc, VALUE *argv, VALUE self, USHORT wFlags, BOOL is_bracket)
    3297. 

  3297. {
    3298. 

  3298.     LCID    lcid = cWIN32OLE_lcid;
    3299. 

  3299.     struct oledata *pole;
    3300. 

  3300.     HRESULT hr;
    3301. 

  3301.     VALUE cmd;
    3302. 

  3302.     VALUE paramS;
    3303. 

  3303.     VALUE param;
    3304. 

  3304.     VALUE obj;
    3305. 

  3305.     VALUE v;
    3306. 

  3306. 

  3307.     BSTR wcmdname;
    3308. 

  3308. 

  3309.     DISPID DispID;
    3310. 

  3310.     DISPID* pDispID;
    3311. 

  3311.     EXCEPINFO excepinfo;
    3312. 

  3312.     VARIANT result;
    3313. 

  3313.     VARIANTARG* realargs = NULL;
    3314. 

  3314.     unsigned int argErr = 0;
    3315. 

  3315.     unsigned int i;
    3316. 

  3316.     unsigned int cNamedArgs;
    3317. 

  3317.     int n;
    3318. 

  3318.     struct oleparam op;
    3319. 

  3319.     struct olevariantdata *pvar;
    3320. 

  3320.     memset(&excepinfo, 0, sizeof(EXCEPINFO));
    3321. 

  3321. 

  3322.     VariantInit(&result);
    3323. 

  3323. 

  3324.     op.dp.rgvarg = NULL;
    3325. 

  3325.     op.dp.rgdispidNamedArgs = NULL;
    3326. 

  3326.     op.dp.cNamedArgs = 0;
    3327. 

  3327.     op.dp.cArgs = 0;
    3328. 

  3328. 

  3329.     rb_scan_args(argc, argv, "1*", &cmd, &paramS);
    3330. 

  3330.     if(TYPE(cmd) != T_STRING && TYPE(cmd) != T_SYMBOL && !is_bracket) {
    3331. 

  3331. 	rb_raise(rb_eTypeError, "method is wrong type (expected String or Symbol)");
    3332. 

  3332.     }
    3333. 

  3333.     if (TYPE(cmd) == T_SYMBOL) {
    3334. 

  3334. 	cmd = rb_sym_to_s(cmd);
    3335. 

  3335.     }
    3336. 

  3336.     OLEData_Get_Struct(self, pole);
    3337. 

  3337.     if(!pole->pDispatch) {
    3338. 

  3338.         rb_raise(rb_eRuntimeError, "failed to get dispatch interface");
    3339. 

  3339.     }
    3340. 

  3340.     if (is_bracket) {
    3341. 

  3341.         DispID = DISPID_VALUE;
    3342. 

  3342.         argc += 1;
    3343. 

  3343. 	rb_ary_unshift(paramS, cmd);
    3344. 

  3344.     } else {
    3345. 

  3345.         wcmdname = ole_vstr2wc(cmd);
    3346. 

  3346.         hr = pole->pDispatch->lpVtbl->GetIDsOfNames( pole->pDispatch, &IID_NULL,
    3347. 

  3347.                 &wcmdname, 1, lcid, &DispID);
    3348. 

  3348.         SysFreeString(wcmdname);
    3349. 

  3349.         if(FAILED(hr)) {
    3350. 

  3350.             ole_raise(hr, eWIN32OLERuntimeError, 
    3351. 

  3351.                     "unknown property or method: `%s'",
    3352. 

  3352.                     StringValuePtr(cmd));
    3353. 

  3353.         }
    3354. 

  3354.     }
    3355. 

  3355. 

  3356.     /* pick up last argument of method */
    3357. 

  3357.     param = rb_ary_entry(paramS, argc-2);
    3358. 

  3358. 

  3359.     op.dp.cNamedArgs = 0;
    3360. 

  3360. 

  3361.     /* if last arg is hash object */
    3362. 

  3362.     if(TYPE(param) == T_HASH) {
    3363. 

  3363.         /*------------------------------------------ 
    3364. 

  3364.           hash object ==> named dispatch parameters 
    3365. 

  3365.         --------------------------------------------*/
    3366. 

  3366.         cNamedArgs = NUM2INT(rb_funcall(param, rb_intern("length"), 0));
    3367. 

  3367.         op.dp.cArgs = cNamedArgs + argc - 2;
    3368. 

  3368.         op.pNamedArgs = ALLOCA_N(OLECHAR*, cNamedArgs + 1);
    3369. 

  3369.         op.dp.rgvarg = ALLOCA_N(VARIANTARG, op.dp.cArgs);
    3370. 

  3370.         rb_block_call(param, rb_intern("each"), 0, 0, hash2named_arg, (VALUE)&op);
    3371. 

  3371. 

  3372.         pDispID = ALLOCA_N(DISPID, cNamedArgs + 1);
    3373. 

  3373.         op.pNamedArgs[0] = ole_vstr2wc(cmd);
    3374. 

  3374.         hr = pole->pDispatch->lpVtbl->GetIDsOfNames(pole->pDispatch,
    3375. 

  3375.                                                     &IID_NULL,
    3376. 

  3376.                                                     op.pNamedArgs,
    3377. 

  3377.                                                     op.dp.cNamedArgs + 1,
    3378. 

  3378.                                                     lcid, pDispID);
    3379. 

  3379.         for(i = 0; i < op.dp.cNamedArgs + 1; i++) {
    3380. 

  3380.             SysFreeString(op.pNamedArgs[i]);
    3381. 

  3381.             op.pNamedArgs[i] = NULL;
    3382. 

  3382.         }
    3383. 

  3383.         if(FAILED(hr)) {
    3384. 

  3384.             /* clear dispatch parameters */
    3385. 

  3385.             for(i = 0; i < op.dp.cArgs; i++ ) {
    3386. 

  3386.                 VariantClear(&op.dp.rgvarg[i]);
    3387. 

  3387.             }
    3388. 

  3388.             ole_raise(hr, eWIN32OLERuntimeError, 
    3389. 

  3389.                       "failed to get named argument info: `%s'",
    3390. 

  3390.                       StringValuePtr(cmd));
    3391. 

  3391.         }
    3392. 

  3392.         op.dp.rgdispidNamedArgs = &(pDispID[1]);
    3393. 

  3393.     }
    3394. 

  3394.     else {
    3395. 

  3395.         cNamedArgs = 0;
    3396. 

  3396.         op.dp.cArgs = argc - 1;
    3397. 

  3397.         op.pNamedArgs = ALLOCA_N(OLECHAR*, cNamedArgs + 1);
    3398. 

  3398.         if (op.dp.cArgs > 0) {
    3399. 

  3399.             op.dp.rgvarg  = ALLOCA_N(VARIANTARG, op.dp.cArgs);
    3400. 

  3400.         }
    3401. 

  3401.     }
    3402. 

  3402.     /*--------------------------------------
    3403. 

  3403.       non hash args ==> dispatch parameters 
    3404. 

  3404.      ----------------------------------------*/
    3405. 

  3405.     if(op.dp.cArgs > cNamedArgs) {
    3406. 

  3406.         realargs = ALLOCA_N(VARIANTARG, op.dp.cArgs-cNamedArgs+1);
    3407. 

  3407.         for(i = cNamedArgs; i < op.dp.cArgs; i++) {
    3408. 

  3408.             n = op.dp.cArgs - i + cNamedArgs - 1;
    3409. 

  3409.             VariantInit(&realargs[n]);
    3410. 

  3410.             VariantInit(&op.dp.rgvarg[n]);
    3411. 

  3411.             param = rb_ary_entry(paramS, i-cNamedArgs);
    3412. 

  3412.             if (rb_obj_is_kind_of(param, cWIN32OLE_VARIANT)) {
    3413. 

  3413.                 Data_Get_Struct(param, struct olevariantdata, pvar);
    3414. 

  3414.                 VariantCopy(&op.dp.rgvarg[n], &(pvar->var));
    3415. 

  3415.             } else {
    3416. 

  3416.                 ole_val2variant(param, &realargs[n]);
    3417. 

  3417.                 V_VT(&op.dp.rgvarg[n]) = VT_VARIANT | VT_BYREF;
    3418. 

  3418.                 V_VARIANTREF(&op.dp.rgvarg[n]) = &realargs[n];
    3419. 

  3419.             }
    3420. 

  3420.         }
    3421. 

  3421.     }
    3422. 

  3422.     /* apparent you need to call propput, you need this */
    3423. 

  3423.     if (wFlags & DISPATCH_PROPERTYPUT) {
    3424. 

  3424.         if (op.dp.cArgs == 0)
    3425. 

  3425.             ole_raise(ResultFromScode(E_INVALIDARG), eWIN32OLERuntimeError, "argument error");
    3426. 

  3426. 

  3427.         op.dp.cNamedArgs = 1;
    3428. 

  3428.         op.dp.rgdispidNamedArgs = ALLOCA_N( DISPID, 1 );
    3429. 

  3429.         op.dp.rgdispidNamedArgs[0] = DISPID_PROPERTYPUT;
    3430. 

  3430.     }
    3431. 

  3431.     
    3432. 

  3432.     hr = pole->pDispatch->lpVtbl->Invoke(pole->pDispatch, DispID, 
    3433. 

  3433.                                          &IID_NULL, lcid, wFlags, &op.dp, 
    3434. 

  3434.                                          &result, &excepinfo, &argErr);
    3435. 

  3435. 

  3436.     if (FAILED(hr)) {
    3437. 

  3437.         /* retry to call args by value */
    3438. 

  3438.         if(op.dp.cArgs >= cNamedArgs) {
    3439. 

  3439.             for(i = cNamedArgs; i < op.dp.cArgs; i++) {
    3440. 

  3440.                 n = op.dp.cArgs - i + cNamedArgs - 1;
    3441. 

  3441.                 param = rb_ary_entry(paramS, i-cNamedArgs);
    3442. 

  3442.                 ole_val2variant(param, &op.dp.rgvarg[n]);
    3443. 

  3443.             }
    3444. 

  3444.             if (hr == DISP_E_EXCEPTION) {
    3445. 

  3445.                 ole_freeexceptinfo(&excepinfo);
    3446. 

  3446.             }
    3447. 

  3447.             memset(&excepinfo, 0, sizeof(EXCEPINFO));
    3448. 

  3448.             VariantInit(&result);
    3449. 

  3449.             hr = pole->pDispatch->lpVtbl->Invoke(pole->pDispatch, DispID, 
    3450. 

  3450.                                                  &IID_NULL, lcid, wFlags,
    3451. 

  3451.                                                  &op.dp, &result,
    3452. 

  3452.                                                  &excepinfo, &argErr);
    3453. 

  3453. 

  3454.             /* mega kludge. if a method in WORD is called and we ask
    3455. 

  3455.              * for a result when one is not returned then
    3456. 

  3456.              * hResult == DISP_E_EXCEPTION. this only happens on
    3457. 

  3457.              * functions whose DISPID > 0x8000 */
    3458. 

  3458.             if ((hr == DISP_E_EXCEPTION || hr == DISP_E_MEMBERNOTFOUND) && DispID > 0x8000) {
    3459. 

  3459.                 if (hr == DISP_E_EXCEPTION) {
    3460. 

  3460.                     ole_freeexceptinfo(&excepinfo);
    3461. 

  3461.                 }
    3462. 

  3462.                 memset(&excepinfo, 0, sizeof(EXCEPINFO));
    3463. 

  3463.                 hr = pole->pDispatch->lpVtbl->Invoke(pole->pDispatch, DispID, 
    3464. 

  3464.                         &IID_NULL, lcid, wFlags,
    3465. 

  3465.                         &op.dp, NULL,
    3466. 

  3466.                         &excepinfo, &argErr);
    3467. 

  3467. 

  3468.             }
    3469. 

  3469.             for(i = cNamedArgs; i < op.dp.cArgs; i++) {
    3470. 

  3470.                 n = op.dp.cArgs - i + cNamedArgs - 1;
    3471. 

  3471.                 VariantClear(&op.dp.rgvarg[n]);
    3472. 

  3472.             }
    3473. 

  3473.         }
    3474. 

  3474. 

  3475.         if (FAILED(hr)) {
    3476. 

  3476.             /* retry after converting nil to VT_EMPTY */
    3477. 

  3477.             if (op.dp.cArgs > cNamedArgs) {
    3478. 

  3478.                 for(i = cNamedArgs; i < op.dp.cArgs; i++) {
    3479. 

  3479.                     n = op.dp.cArgs - i + cNamedArgs - 1;
    3480. 

  3480.                     param = rb_ary_entry(paramS, i-cNamedArgs);
    3481. 

  3481.                     ole_val2variant2(param, &op.dp.rgvarg[n]);
    3482. 

  3482.                 }
    3483. 

  3483.                 if (hr == DISP_E_EXCEPTION) {
    3484. 

  3484.                     ole_freeexceptinfo(&excepinfo);
    3485. 

  3485.                 }
    3486. 

  3486.                 memset(&excepinfo, 0, sizeof(EXCEPINFO));
    3487. 

  3487.                 VariantInit(&result);
    3488. 

  3488.                 hr = pole->pDispatch->lpVtbl->Invoke(pole->pDispatch, DispID, 
    3489. 

  3489.                         &IID_NULL, lcid, wFlags,
    3490. 

  3490.                         &op.dp, &result,
    3491. 

  3491.                         &excepinfo, &argErr);
    3492. 

  3492.                 for(i = cNamedArgs; i < op.dp.cArgs; i++) {
    3493. 

  3493.                     n = op.dp.cArgs - i + cNamedArgs - 1;
    3494. 

  3494.                     VariantClear(&op.dp.rgvarg[n]);
    3495. 

  3495.                 }
    3496. 

  3496.             }
    3497. 

  3497.         }
    3498. 

  3498. 

  3499.     }
    3500. 

  3500.     /* clear dispatch parameter */
    3501. 

  3501.     if(op.dp.cArgs > cNamedArgs) {
    3502. 

  3502.         for(i = cNamedArgs; i < op.dp.cArgs; i++) {
    3503. 

  3503.             n = op.dp.cArgs - i + cNamedArgs - 1;
    3504. 

  3504.             param = rb_ary_entry(paramS, i-cNamedArgs);
    3505. 

  3505.             if (rb_obj_is_kind_of(param, cWIN32OLE_VARIANT)) {
    3506. 

  3506.                 ole_val2variant(param, &realargs[n]);
    3507. 

  3507.             }
    3508. 

  3508.         }
    3509. 

  3509.         set_argv(realargs, cNamedArgs, op.dp.cArgs);
    3510. 

  3510.     }
    3511. 

  3511.     else {
    3512. 

  3512.         for(i = 0; i < op.dp.cArgs; i++) {
    3513. 

  3513.             VariantClear(&op.dp.rgvarg[i]);
    3514. 

  3514.         }
    3515. 

  3515.     }
    3516. 

  3516. 

  3517.     if (FAILED(hr)) {
    3518. 

  3518.         v = ole_excepinfo2msg(&excepinfo);
    3519. 

  3519.         ole_raise(hr, eWIN32OLERuntimeError, "(in OLE method `%s': )%s",
    3520. 

  3520.                   StringValuePtr(cmd),
    3521. 

  3521.                   StringValuePtr(v));
    3522. 

  3522.     }
    3523. 

  3523.     obj = ole_variant2val(&result);
    3524. 

  3524.     VariantClear(&result);
    3525. 

  3525.     return obj;
    3526. 

  3526. }
    3527. 

  3527. 

  3528. /*
    3529. 

  3529.  *  call-seq:
    3530. 

  3530.  *     WIN32OLE#invoke(method, [arg1,...])  => return value of method.
    3531. 

  3531.  *
    3532. 

  3532.  *  Runs OLE method. 
    3533. 

  3533.  *  The first argument specifies the method name of OLE Automation object.
    3534. 

  3534.  *  The others specify argument of the <i>method</i>.
    3535. 

  3535.  *  If you can not execute <i>method</i> directly, then use this method instead.
    3536. 

  3536.  *
    3537. 

  3537.  *    excel = WIN32OLE.new('Excel.Application')
    3538. 

  3538.  *    excel.invoke('Quit')  # => same as excel.Quit
    3539. 

  3539.  *
    3540. 

  3540.  */
    3541. 

  3541. static VALUE
    3542. 

  3542. fole_invoke(int argc, VALUE *argv, VALUE self)
    3543. 

  3543. {
    3544. 

  3544.     return ole_invoke(argc, argv, self, DISPATCH_METHOD|DISPATCH_PROPERTYGET, FALSE);
    3545. 

  3545. }
    3546. 

  3546. 

  3547. static VALUE
    3548. 

  3548. ole_invoke2(VALUE self, VALUE dispid, VALUE args, VALUE types, USHORT dispkind)
    3549. 

  3549. {
    3550. 

  3550.     HRESULT hr;
    3551. 

  3551.     struct oledata *pole;
    3552. 

  3552.     unsigned int argErr = 0;
    3553. 

  3553.     EXCEPINFO excepinfo;
    3554. 

  3554.     VARIANT result;
    3555. 

  3555.     DISPPARAMS dispParams;
    3556. 

  3556.     VARIANTARG* realargs = NULL;
    3557. 

  3557.     int i, j;
    3558. 

  3558.     VALUE obj = Qnil;
    3559. 

  3559.     VALUE tp, param;
    3560. 

  3560.     VALUE v;
    3561. 

  3561.     VARTYPE vt;
    3562. 

  3562. 

  3563.     Check_Type(args, T_ARRAY);
    3564. 

  3564.     Check_Type(types, T_ARRAY);
    3565. 

  3565.     
    3566. 

  3566.     memset(&excepinfo, 0, sizeof(EXCEPINFO));
    3567. 

  3567.     memset(&dispParams, 0, sizeof(DISPPARAMS));
    3568. 

  3568.     VariantInit(&result);
    3569. 

  3569.     OLEData_Get_Struct(self, pole);
    3570. 

  3570. 

  3571.     dispParams.cArgs = RARRAY_LEN(args);
    3572. 

  3572.     dispParams.rgvarg = ALLOCA_N(VARIANTARG, dispParams.cArgs);
    3573. 

  3573.     realargs = ALLOCA_N(VARIANTARG, dispParams.cArgs);
    3574. 

  3574.     for (i = 0, j = dispParams.cArgs - 1; i < (int)dispParams.cArgs; i++, j--)
    3575. 

  3575.     {
    3576. 

  3576.         VariantInit(&realargs[i]);
    3577. 

  3577.         VariantInit(&dispParams.rgvarg[i]);
    3578. 

  3578.         tp = rb_ary_entry(types, j);
    3579. 

  3579.         vt = (VARTYPE)FIX2INT(tp);
    3580. 

  3580.         V_VT(&dispParams.rgvarg[i]) = vt;
    3581. 

  3581.         param = rb_ary_entry(args, j);
    3582. 

  3582.         if (param == Qnil)
    3583. 

  3583.         {
    3584. 

  3584. 

  3585.             V_VT(&dispParams.rgvarg[i]) = V_VT(&realargs[i]) = VT_ERROR;
    3586. 

  3586.             V_ERROR(&dispParams.rgvarg[i]) = V_ERROR(&realargs[i]) = DISP_E_PARAMNOTFOUND;
    3587. 

  3587.         }
    3588. 

  3588.         else
    3589. 

  3589.         {
    3590. 

  3590.             if (vt & VT_ARRAY)
    3591. 

  3591.             {
    3592. 

  3592.                 int ent;
    3593. 

  3593.                 LPBYTE pb;
    3594. 

  3594.                 short* ps;
    3595. 

  3595.                 LPLONG pl;
    3596. 

  3596.                 VARIANT* pv;
    3597. 

  3597.                 CY *py;
    3598. 

  3598.                 VARTYPE v;
    3599. 

  3599.                 SAFEARRAYBOUND rgsabound[1];
    3600. 

  3600.                 Check_Type(param, T_ARRAY);
    3601. 

  3601.                 rgsabound[0].lLbound = 0;
    3602. 

  3602.                 rgsabound[0].cElements = RARRAY_LEN(param);
    3603. 

  3603.                 v = vt & ~(VT_ARRAY | VT_BYREF);
    3604. 

  3604.                 V_ARRAY(&realargs[i]) = SafeArrayCreate(v, 1, rgsabound);
    3605. 

  3605.                 V_VT(&realargs[i]) = VT_ARRAY | v;
    3606. 

  3606.                 SafeArrayLock(V_ARRAY(&realargs[i]));
    3607. 

  3607.                 pb = V_ARRAY(&realargs[i])->pvData;
    3608. 

  3608.                 ps = V_ARRAY(&realargs[i])->pvData;
    3609. 

  3609.                 pl = V_ARRAY(&realargs[i])->pvData;
    3610. 

  3610.                 py = V_ARRAY(&realargs[i])->pvData;
    3611. 

  3611.                 pv = V_ARRAY(&realargs[i])->pvData;
    3612. 

  3612.                 for (ent = 0; ent < (int)rgsabound[0].cElements; ent++)
    3613. 

  3613.                 {
    3614. 

  3614.                     VARIANT velem;
    3615. 

  3615.                     VALUE elem = rb_ary_entry(param, ent);
    3616. 

  3616.                     ole_val2variant(elem, &velem);
    3617. 

  3617.                     if (v != VT_VARIANT)
    3618. 

  3618.                     {
    3619. 

  3619.                         VariantChangeTypeEx(&velem, &velem,
    3620. 

  3620.                             cWIN32OLE_lcid, 0, v);
    3621. 

  3621.                     }
    3622. 

  3622.                     switch (v)
    3623. 

  3623.                     {
    3624. 

  3624.                     /* 128 bits */
    3625. 

  3625.                     case VT_VARIANT:
    3626. 

  3626.                         *pv++ = velem;
    3627. 

  3627.                         break;
    3628. 

  3628.                     /* 64 bits */
    3629. 

  3629.                     case VT_R8:
    3630. 

  3630.                     case VT_CY:
    3631. 

  3631.                     case VT_DATE:
    3632. 

  3632.                         *py++ = V_CY(&velem);
    3633. 

  3633.                         break;
    3634. 

  3634.                     /* 16 bits */
    3635. 

  3635.                     case VT_BOOL:
    3636. 

  3636.                     case VT_I2:
    3637. 

  3637.                     case VT_UI2:
    3638. 

  3638.                         *ps++ = V_I2(&velem);
    3639. 

  3639.                         break;
    3640. 

  3640.                     /* 8 bites */
    3641. 

  3641.                     case VT_UI1:
    3642. 

  3642.                     case VT_I1:
    3643. 

  3643.                         *pb++ = V_UI1(&velem);
    3644. 

  3644.                         break;
    3645. 

  3645.                     /* 32 bits */
    3646. 

  3646.                     default:
    3647. 

  3647.                         *pl++ = V_I4(&velem);
    3648. 

  3648.                         break;
    3649. 

  3649.                     }
    3650. 

  3650.                 }
    3651. 

  3651.                 SafeArrayUnlock(V_ARRAY(&realargs[i]));
    3652. 

  3652.             }
    3653. 

  3653.             else
    3654. 

  3654.             {
    3655. 

  3655.                 ole_val2variant(param, &realargs[i]);
    3656. 

  3656.                 if ((vt & (~VT_BYREF)) != VT_VARIANT)
    3657. 

  3657.                 {
    3658. 

  3658.                     hr = VariantChangeTypeEx(&realargs[i], &realargs[i],
    3659. 

  3659.                                              cWIN32OLE_lcid, 0,
    3660. 

  3660.                                              (VARTYPE)(vt & (~VT_BYREF)));
    3661. 

  3661.                     if (hr != S_OK)
    3662. 

  3662.                     {
    3663. 

  3663.                         rb_raise(rb_eTypeError, "not valid value");
    3664. 

  3664.                     }
    3665. 

  3665.                 }
    3666. 

  3666.             }
    3667. 

  3667.             if ((vt & VT_BYREF) || vt == VT_VARIANT)
    3668. 

  3668.             {
    3669. 

  3669.                 if (vt == VT_VARIANT)
    3670. 

  3670.                     V_VT(&dispParams.rgvarg[i]) = VT_VARIANT | VT_BYREF;
    3671. 

  3671.                 switch (vt & (~VT_BYREF))
    3672. 

  3672.                 {
    3673. 

  3673.                 /* 128 bits */
    3674. 

  3674.                 case VT_VARIANT:
    3675. 

  3675.                     V_VARIANTREF(&dispParams.rgvarg[i]) = &realargs[i];
    3676. 

  3676.                     break;
    3677. 

  3677.                 /* 64 bits */
    3678. 

  3678.                 case VT_R8:
    3679. 

  3679.                 case VT_CY:
    3680. 

  3680.                 case VT_DATE:
    3681. 

  3681.                     V_CYREF(&dispParams.rgvarg[i]) = &V_CY(&realargs[i]);
    3682. 

  3682.                     break;
    3683. 

  3683.                 /* 16 bits */
    3684. 

  3684.                 case VT_BOOL:
    3685. 

  3685.                 case VT_I2:
    3686. 

  3686.                 case VT_UI2:
    3687. 

  3687.                     V_I2REF(&dispParams.rgvarg[i]) = &V_I2(&realargs[i]);
    3688. 

  3688.                     break;
    3689. 

  3689.                 /* 8 bites */
    3690. 

  3690.                 case VT_UI1:
    3691. 

  3691.                 case VT_I1:
    3692. 

  3692.                     V_UI1REF(&dispParams.rgvarg[i]) = &V_UI1(&realargs[i]);
    3693. 

  3693.                     break;
    3694. 

  3694.                 /* 32 bits */
    3695. 

  3695.                 default:
    3696. 

  3696.                     V_I4REF(&dispParams.rgvarg[i]) = &V_I4(&realargs[i]);
    3697. 

  3697.                     break;
    3698. 

  3698.                 }
    3699. 

  3699.             }
    3700. 

  3700.             else
    3701. 

  3701.             {
    3702. 

  3702.                 /* copy 64 bits of data */
    3703. 

  3703.                 V_CY(&dispParams.rgvarg[i]) = V_CY(&realargs[i]);
    3704. 

  3704.             }
    3705. 

  3705.         }
    3706. 

  3706.     }
    3707. 

  3707. 

  3708.     if (dispkind & DISPATCH_PROPERTYPUT) {
    3709. 

  3709.         dispParams.cNamedArgs = 1;
    3710. 

  3710.         dispParams.rgdispidNamedArgs = ALLOCA_N( DISPID, 1 );
    3711. 

  3711.         dispParams.rgdispidNamedArgs[0] = DISPID_PROPERTYPUT;
    3712. 

  3712.     }
    3713. 

  3713. 

  3714.     hr = pole->pDispatch->lpVtbl->Invoke(pole->pDispatch, NUM2INT(dispid),
    3715. 

  3715.                                          &IID_NULL, cWIN32OLE_lcid,
    3716. 

  3716.                                          dispkind,
    3717. 

  3717.                                          &dispParams, &result,
    3718. 

  3718.                                          &excepinfo, &argErr);
    3719. 

  3719. 

  3720.     if (FAILED(hr)) {
    3721. 

  3721.         v = ole_excepinfo2msg(&excepinfo);
    3722. 

  3722.         ole_raise(hr, eWIN32OLERuntimeError, "(in OLE method `<dispatch id:%d>': )%s",
    3723. 

  3723.                   NUM2INT(dispid),
    3724. 

  3724.                   StringValuePtr(v));
    3725. 

  3725.     }
    3726. 

  3726. 

  3727.     /* clear dispatch parameter */
    3728. 

  3728.     if(dispParams.cArgs > 0) {
    3729. 

  3729.         set_argv(realargs, 0, dispParams.cArgs);
    3730. 

  3730.     }
    3731. 

  3731. 

  3732.     obj = ole_variant2val(&result);
    3733. 

  3733.     VariantClear(&result);
    3734. 

  3734.     return obj;
    3735. 

  3735. }
    3736. 

  3736. 

  3737. /*
    3738. 

  3738.  *   call-seq:
    3739. 

  3739.  *      WIN32OLE#_invoke(dispid, args, types)
    3740. 

  3740.  * 
    3741. 

  3741.  *   Runs the early binding method.
    3742. 

  3742.  *   The 1st argument specifies dispatch ID, 
    3743. 

  3743.  *   the 2nd argument specifies the array of arguments,
    3744. 

  3744.  *   the 3rd argument specifies the array of the type of arguments.
    3745. 

  3745.  *
    3746. 

  3746.  *      excel = WIN32OLE.new('Excel.Application')
    3747. 

  3747.  *      excel._invoke(302, [], []) #  same effect as excel.Quit
    3748. 

  3748.  */
    3749. 

  3749. static VALUE
    3750. 

  3750. fole_invoke2(VALUE self, VALUE dispid, VALUE args, VALUE types)
    3751. 

  3751. {
    3752. 

  3752.     return ole_invoke2(self, dispid, args, types, DISPATCH_METHOD);
    3753. 

  3753. }
    3754. 

  3754. 

  3755. /*
    3756. 

  3756.  *  call-seq:
    3757. 

  3757.  *     WIN32OLE#_getproperty(dispid, args, types)
    3758. 

  3758.  * 
    3759. 

  3759.  *  Runs the early binding method to get property.
    3760. 

  3760.  *  The 1st argument specifies dispatch ID, 
    3761. 

  3761.  *  the 2nd argument specifies the array of arguments,
    3762. 

  3762.  *  the 3rd argument specifies the array of the type of arguments.
    3763. 

  3763.  *
    3764. 

  3764.  *     excel = WIN32OLE.new('Excel.Application')
    3765. 

  3765.  *     puts excel._getproperty(558, [], []) # same effect as puts excel.visible
    3766. 

  3766.  */
    3767. 

  3767. static VALUE
    3768. 

  3768. fole_getproperty2(VALUE self, VALUE dispid, VALUE args, VALUE types)
    3769. 

  3769. {
    3770. 

  3770.     return ole_invoke2(self, dispid, args, types, DISPATCH_PROPERTYGET);
    3771. 

  3771. }
    3772. 

  3772. 

  3773. /*
    3774. 

  3774.  *   call-seq:
    3775. 

  3775.  *      WIN32OLE#_setproperty(dispid, args, types)
    3776. 

  3776.  * 
    3777. 

  3777.  *   Runs the early binding method to set property.
    3778. 

  3778.  *   The 1st argument specifies dispatch ID, 
    3779. 

  3779.  *   the 2nd argument specifies the array of arguments,
    3780. 

  3780.  *   the 3rd argument specifies the array of the type of arguments.
    3781. 

  3781.  *
    3782. 

  3782.  *      excel = WIN32OLE.new('Excel.Application')
    3783. 

  3783.  *      excel._setproperty(558, [true], [WIN32OLE::VARIANT::VT_BOOL]) # same effect as excel.visible = true
    3784. 

  3784.  */
    3785. 

  3785. static VALUE
    3786. 

  3786. fole_setproperty2(VALUE self, VALUE dispid, VALUE args, VALUE types)
    3787. 

  3787. {
    3788. 

  3788.     return ole_invoke2(self, dispid, args, types, DISPATCH_PROPERTYPUT);
    3789. 

  3789. }
    3790. 

  3790. 

  3791. /*
    3792. 

  3792.  *  call-seq:
    3793. 

  3793.  *     WIN32OLE[a1, a2, ...]=val 
    3794. 

  3794.  * 
    3795. 

  3795.  *  Sets the value to WIN32OLE object specified by a1, a2, ...
    3796. 

  3796.  *     
    3797. 

  3797.  *     dict = WIN32OLE.new('Scripting.Dictionary')
    3798. 

  3798.  *     dict.add('ruby', 'RUBY')
    3799. 

  3799.  *     dict['ruby'] = 'Ruby' 
    3800. 

  3800.  *     puts dict['ruby'] # => 'Ruby'
    3801. 

  3801.  *
    3802. 

  3802.  *  Remark: You can not use this method to set the property value.
    3803. 

  3803.  *
    3804. 

  3804.  *     excel = WIN32OLE.new('Excel.Application')
    3805. 

  3805.  *     # excel['Visible'] = true # This is error !!!
    3806. 

  3806.  *     excel.Visible = true # You should to use this style to set the property.
    3807. 

  3807.  *
    3808. 

  3808.  */
    3809. 

  3809. static VALUE
    3810. 

  3810. fole_setproperty_with_bracket(int argc, VALUE *argv, VALUE self)
    3811. 

  3811. {
    3812. 

  3812.     return ole_invoke(argc, argv, self, DISPATCH_PROPERTYPUT, TRUE);
    3813. 

  3813. }
    3814. 

  3814. 

  3815. /*
    3816. 

  3816.  *  call-seq:
    3817. 

  3817.  *     WIN32OLE.setproperty('property', [arg1, arg2,...] val)
    3818. 

  3818.  * 
    3819. 

  3819.  *  Sets property of OLE object.
    3820. 

  3820.  *  When you want to set property with argument, you can use this method.
    3821. 

  3821.  *
    3822. 

  3822.  *     excel = WIN32OLE.new('Excel.Application')
    3823. 

  3823.  *     excel.Visible = true
    3824. 

  3824.  *     book = excel.workbooks.add
    3825. 

  3825.  *     sheet = book.worksheets(1)
    3826. 

  3826.  *     sheet.setproperty('Cells', 1, 2, 10) # => The B1 cell value is 10.
    3827. 

  3827.  */
    3828. 

  3828. static VALUE
    3829. 

  3829. fole_setproperty(int argc, VALUE *argv, VALUE self)
    3830. 

  3830. {
    3831. 

  3831.     return ole_invoke(argc, argv, self, DISPATCH_PROPERTYPUT, FALSE);
    3832. 

  3832. }
    3833. 

  3833. 

  3834. /*
    3835. 

  3835.  *  call-seq:
    3836. 

  3836.  *     WIN32OLE[a1,a2,...] 
    3837. 

  3837.  * 
    3838. 

  3838.  *  Returns the value of Collection specified by a1, a2,....
    3839. 

  3839.  *
    3840. 

  3840.  *     dict = WIN32OLE.new('Scripting.Dictionary')
    3841. 

  3841.  *     dict.add('ruby', 'Ruby')
    3842. 

  3842.  *     puts dict['ruby'] # => 'Ruby' (same as `puts dict.item('ruby')')
    3843. 

  3843.  *    
    3844. 

  3844.  *  Remark: You can not use this method to get the property.
    3845. 

  3845.  *     excel = WIN32OLE.new('Excel.Application')
    3846. 

  3846.  *     # puts excel['Visible']  This is error !!!
    3847. 

  3847.  *     puts excel.Visible # You should to use this style to get the property.
    3848. 

  3848.  *
    3849. 

  3849.  */
    3850. 

  3850. static VALUE
    3851. 

  3851. fole_getproperty_with_bracket(int argc, VALUE *argv, VALUE self)
    3852. 

  3852. {
    3853. 

  3853.     return ole_invoke(argc, argv, self, DISPATCH_PROPERTYGET, TRUE);
    3854. 

  3854. }
    3855. 

  3855. 

  3856. static VALUE
    3857. 

  3857. ole_propertyput(VALUE self, VALUE property, VALUE value)
    3858. 

  3858. {
    3859. 

  3859.     struct oledata *pole;
    3860. 

  3860.     unsigned argErr;
    3861. 

  3861.     unsigned int index;
    3862. 

  3862.     HRESULT hr;
    3863. 

  3863.     EXCEPINFO excepinfo;
    3864. 

  3864.     DISPID dispID = DISPID_VALUE;
    3865. 

  3865.     DISPID dispIDParam = DISPID_PROPERTYPUT;
    3866. 

  3866.     USHORT wFlags = DISPATCH_PROPERTYPUT|DISPATCH_PROPERTYPUTREF;
    3867. 

  3867.     DISPPARAMS dispParams;
    3868. 

  3868.     VARIANTARG propertyValue[2];
    3869. 

  3869.     OLECHAR* pBuf[1];
    3870. 

  3870.     VALUE v;
    3871. 

  3871.     LCID    lcid = cWIN32OLE_lcid;
    3872. 

  3872.     dispParams.rgdispidNamedArgs = &dispIDParam;
    3873. 

  3873.     dispParams.rgvarg = propertyValue;
    3874. 

  3874.     dispParams.cNamedArgs = 1;
    3875. 

  3875.     dispParams.cArgs = 1;
    3876. 

  3876. 

  3877.     VariantInit(&propertyValue[0]);
    3878. 

  3878.     VariantInit(&propertyValue[1]);
    3879. 

  3879.     memset(&excepinfo, 0, sizeof(excepinfo));
    3880. 

  3880. 

  3881.     OLEData_Get_Struct(self, pole);
    3882. 

  3882. 

  3883.     /* get ID from property name */
    3884. 

  3884.     pBuf[0]  = ole_vstr2wc(property);
    3885. 

  3885.     hr = pole->pDispatch->lpVtbl->GetIDsOfNames(pole->pDispatch, &IID_NULL,
    3886. 

  3886.                                                 pBuf, 1, lcid, &dispID);
    3887. 

  3887.     SysFreeString(pBuf[0]);
    3888. 

  3888.     pBuf[0] = NULL;
    3889. 

  3889. 

  3890.     if(FAILED(hr)) {
    3891. 

  3891.         ole_raise(hr, eWIN32OLERuntimeError, 
    3892. 

  3892.                   "unknown property or method: `%s'",
    3893. 

  3893.                   StringValuePtr(property));
    3894. 

  3894.     }
    3895. 

  3895.     /* set property value */
    3896. 

  3896.     ole_val2variant(value, &propertyValue[0]);
    3897. 

  3897.     hr = pole->pDispatch->lpVtbl->Invoke(pole->pDispatch, dispID, &IID_NULL, 
    3898. 

  3898.                                          lcid, wFlags, &dispParams,
    3899. 

  3899.                                          NULL, &excepinfo, &argErr);
    3900. 

  3900. 

  3901.     for(index = 0; index < dispParams.cArgs; ++index) {
    3902. 

  3902.         VariantClear(&propertyValue[index]);
    3903. 

  3903.     }
    3904. 

  3904.     if (FAILED(hr)) {
    3905. 

  3905.         v = ole_excepinfo2msg(&excepinfo);
    3906. 

  3906.         ole_raise(hr, eWIN32OLERuntimeError, "(in setting property `%s': )%s",
    3907. 

  3907.                   StringValuePtr(property),
    3908. 

  3908.                   StringValuePtr(v));
    3909. 

  3909.     }
    3910. 

  3910.     return Qnil;
    3911. 

  3911. }
    3912. 

  3912. 

  3913. /*
    3914. 

  3914.  *  call-seq:
    3915. 

  3915.  *     WIN32OLE#ole_free
    3916. 

  3916.  *
    3917. 

  3917.  *  invokes Release method of Dispatch interface of WIN32OLE object.
    3918. 

  3918.  *  Usually, you do not need to call this method because Release method
    3919. 

  3919.  *  called automatically when WIN32OLE object garbaged.
    3920. 

  3920.  *
    3921. 

  3921.  */
    3922. 

  3922. static VALUE
    3923. 

  3923. fole_free(VALUE self)
    3924. 

  3924. {
    3925. 

  3925.     struct oledata *pole;
    3926. 

  3926.     rb_secure(4);
    3927. 

  3927.     OLEData_Get_Struct(self, pole);
    3928. 

  3928.     OLE_FREE(pole->pDispatch);
    3929. 

  3929.     pole->pDispatch = NULL;
    3930. 

  3930.     return Qnil;
    3931. 

  3931. }
    3932. 

  3932. 

  3933. static VALUE
    3934. 

  3934. ole_each_sub(VALUE pEnumV)
    3935. 

  3935. {
    3936. 

  3936.     VARIANT variant;
    3937. 

  3937.     VALUE obj = Qnil;
    3938. 

  3938.     IEnumVARIANT *pEnum = (IEnumVARIANT *)pEnumV;
    3939. 

  3939.     VariantInit(&variant);
    3940. 

  3940.     while(pEnum->lpVtbl->Next(pEnum, 1, &variant, NULL) == S_OK) {
    3941. 

  3941.         obj = ole_variant2val(&variant);
    3942. 

  3942.         VariantClear(&variant);
    3943. 

  3943.         VariantInit(&variant);
    3944. 

  3944.         rb_yield(obj);
    3945. 

  3945.     }
    3946. 

  3946.     return Qnil;
    3947. 

  3947. }
    3948. 

  3948. 

  3949. static VALUE
    3950. 

  3950. ole_ienum_free(VALUE pEnumV)
    3951. 

  3951. {
    3952. 

  3952.     IEnumVARIANT *pEnum = (IEnumVARIANT *)pEnumV;
    3953. 

  3953.     OLE_RELEASE(pEnum);
    3954. 

  3954.     return Qnil;
    3955. 

  3955. }
    3956. 

  3956. 

  3957. /*
    3958. 

  3958.  *  call-seq:
    3959. 

  3959.  *     WIN32OLE#each {|i|...}
    3960. 

  3960.  * 
    3961. 

  3961.  *  Iterates over each item of OLE collection which has IEnumVARIANT interface.
    3962. 

  3962.  *
    3963. 

  3963.  *     excel = WIN32OLE.new('Excel.Application')
    3964. 

  3964.  *     book = excel.workbooks.add
    3965. 

  3965.  *     sheets = book.worksheets(1)
    3966. 

  3966.  *     cells = sheets.cells("A1:A5")
    3967. 

  3967.  *     cells.each do |cell|
    3968. 

  3968.  *       cell.value = 10
    3969. 

  3969.  *     end
    3970. 

  3970.  */
    3971. 

  3971. static VALUE
    3972. 

  3972. fole_each(VALUE self)
    3973. 

  3973. {
    3974. 

  3974.     LCID    lcid = cWIN32OLE_lcid;
    3975. 

  3975. 

  3976.     struct oledata *pole;
    3977. 

  3977. 

  3978.     unsigned int argErr;
    3979. 

  3979.     EXCEPINFO excepinfo;
    3980. 

  3980.     DISPPARAMS dispParams;
    3981. 

  3981.     VARIANT result;
    3982. 

  3982.     HRESULT hr;
    3983. 

  3983.     IEnumVARIANT *pEnum = NULL;
    3984. 

  3984.     void *p;
    3985. 

  3985. 

  3986.     RETURN_ENUMERATOR(self, 0, 0);
    3987. 

  3987. 

  3988.     VariantInit(&result);
    3989. 

  3989.     dispParams.rgvarg = NULL;
    3990. 

  3990.     dispParams.rgdispidNamedArgs = NULL;
    3991. 

  3991.     dispParams.cNamedArgs = 0;
    3992. 

  3992.     dispParams.cArgs = 0;
    3993. 

  3993.     memset(&excepinfo, 0, sizeof(excepinfo));
    3994. 

  3994.     
    3995. 

  3995.     OLEData_Get_Struct(self, pole);
    3996. 

  3996.     hr = pole->pDispatch->lpVtbl->Invoke(pole->pDispatch, DISPID_NEWENUM,
    3997. 

  3997.                                          &IID_NULL, lcid,
    3998. 

  3998.                                          DISPATCH_METHOD | DISPATCH_PROPERTYGET,
    3999. 

  3999.                                          &dispParams, &result,
    4000. 

  4000.                                          &excepinfo, &argErr);
    4001. 

  4001. 

  4002.     if (FAILED(hr)) {
    4003. 

  4003.         VariantClear(&result);
    4004. 

  4004.         ole_raise(hr, eWIN32OLERuntimeError, "failed to get IEnum Interface");
    4005. 

  4005.     }
    4006. 

  4006. 

  4007.     if (V_VT(&result) == VT_UNKNOWN) {
    4008. 

  4008.         hr = V_UNKNOWN(&result)->lpVtbl->QueryInterface(V_UNKNOWN(&result),
    4009. 

  4009.                                                         &IID_IEnumVARIANT,
    4010. 

  4010.                                                         &p);
    4011. 

  4011.         pEnum = p;
    4012. 

  4012.     } else if (V_VT(&result) == VT_DISPATCH) {
    4013. 

  4013.         hr = V_DISPATCH(&result)->lpVtbl->QueryInterface(V_DISPATCH(&result),
    4014. 

  4014.                                                          &IID_IEnumVARIANT,
    4015. 

  4015.                                                          &p);
    4016. 

  4016.         pEnum = p;
    4017. 

  4017.     }
    4018. 

  4018.     if (FAILED(hr) || !pEnum) {
    4019. 

  4019.         VariantClear(&result);
    4020. 

  4020.         ole_raise(hr, rb_eRuntimeError, "failed to get IEnum Interface");
    4021. 

  4021.     }
    4022. 

  4022. 

  4023.     VariantClear(&result);
    4024. 

  4024.     rb_ensure(ole_each_sub, (VALUE)pEnum, ole_ienum_free, (VALUE)pEnum);
    4025. 

  4025.     return Qnil;
    4026. 

  4026. }
    4027. 

  4027. 

  4028. /*
    4029. 

  4029.  *  call-seq:
    4030. 

  4030.  *     WIN32OLE#method_missing(id [,arg1, arg2, ...])
    4031. 

  4031.  * 
    4032. 

  4032.  *  Calls WIN32OLE#invoke method.
    4033. 

  4033.  */
    4034. 

  4034. static VALUE
    4035. 

  4035. fole_missing(int argc, VALUE *argv, VALUE self)
    4036. 

  4036. {
    4037. 

  4037.     ID id;
    4038. 

  4038.     const char* mname;
    4039. 

  4039.     int n;
    4040. 

  4040.     id = rb_to_id(argv[0]);
    4041. 

  4041.     mname = rb_id2name(id);
    4042. 

  4042.     if(!mname) {
    4043. 

  4043.         rb_raise(rb_eRuntimeError, "fail: unknown method or property");
    4044. 

  4044.     }
    4045. 

  4045.     n = strlen(mname);
    4046. 

  4046.     if(mname[n-1] == '=') {
    4047. 

  4047.         argv[0] = rb_enc_str_new(mname, n-1, cWIN32OLE_enc);
    4048. 

  4048. 

  4049.         return ole_propertyput(self, argv[0], argv[1]);
    4050. 

  4050.     }
    4051. 

  4051.     else {
    4052. 

  4052.         argv[0] = rb_enc_str_new(mname, n, cWIN32OLE_enc);
    4053. 

  4053.         return ole_invoke(argc, argv, self, DISPATCH_METHOD|DISPATCH_PROPERTYGET, FALSE);
    4054. 

  4054.     }
    4055. 

  4055. }
    4056. 

  4056. 

  4057. static VALUE
    4058. 

  4058. ole_method_sub(VALUE self, ITypeInfo *pOwnerTypeInfo, ITypeInfo *pTypeInfo, VALUE name)
    4059. 

  4059. {
    4060. 

  4060.     HRESULT hr;
    4061. 

  4061.     TYPEATTR *pTypeAttr;
    4062. 

  4062.     BSTR bstr;
    4063. 

  4063.     FUNCDESC *pFuncDesc;
    4064. 

  4064.     WORD i;
    4065. 

  4065.     VALUE fname;
    4066. 

  4066.     VALUE method = Qnil;
    4067. 

  4067.     hr = OLE_GET_TYPEATTR(pTypeInfo, &pTypeAttr);
    4068. 

  4068.     if (FAILED(hr)) {
    4069. 

  4069.         ole_raise(hr, eWIN32OLERuntimeError, "failed to GetTypeAttr");
    4070. 

  4070.     }
    4071. 

  4071.     for(i = 0; i < pTypeAttr->cFuncs && method == Qnil; i++) {
    4072. 

  4072.         hr = pTypeInfo->lpVtbl->GetFuncDesc(pTypeInfo, i, &pFuncDesc);
    4073. 

  4073.         if (FAILED(hr))
    4074. 

  4074.              continue;
    4075. 

  4075. 

  4076.         hr = pTypeInfo->lpVtbl->GetDocumentation(pTypeInfo, pFuncDesc->memid,
    4077. 

  4077.                                                  &bstr, NULL, NULL, NULL);
    4078. 

  4078.         if (FAILED(hr)) {
    4079. 

  4079.             pTypeInfo->lpVtbl->ReleaseFuncDesc(pTypeInfo, pFuncDesc);
    4080. 

  4080.             continue;
    4081. 

  4081.         }
    4082. 

  4082.         fname = WC2VSTR(bstr);
    4083. 

  4083.         if (strcasecmp(StringValuePtr(name), StringValuePtr(fname)) == 0) {
    4084. 

  4084.             olemethod_set_member(self, pTypeInfo, pOwnerTypeInfo, i, fname);
    4085. 

  4085.             method = self;
    4086. 

  4086.         }
    4087. 

  4087.         pTypeInfo->lpVtbl->ReleaseFuncDesc(pTypeInfo, pFuncDesc);
    4088. 

  4088.         pFuncDesc=NULL;
    4089. 

  4089.     }
    4090. 

  4090.     OLE_RELEASE_TYPEATTR(pTypeInfo, pTypeAttr);
    4091. 

  4091.     return method;
    4092. 

  4092. }
    4093. 

  4093. 

  4094. static VALUE
    4095. 

  4095. olemethod_from_typeinfo(VALUE self, ITypeInfo *pTypeInfo, VALUE name)
    4096. 

  4096. {
    4097. 

  4097.     HRESULT hr;
    4098. 

  4098.     TYPEATTR *pTypeAttr;
    4099. 

  4099.     WORD i;
    4100. 

  4100.     HREFTYPE href;
    4101. 

  4101.     ITypeInfo *pRefTypeInfo;
    4102. 

  4102.     VALUE method = Qnil;
    4103. 

  4103.     hr = OLE_GET_TYPEATTR(pTypeInfo, &pTypeAttr);
    4104. 

  4104.     if (FAILED(hr)) {
    4105. 

  4105.         ole_raise(hr, eWIN32OLERuntimeError, "failed to GetTypeAttr");
    4106. 

  4106.     }
    4107. 

  4107.     method = ole_method_sub(self, 0, pTypeInfo, name);
    4108. 

  4108.     if (method != Qnil) {
    4109. 

  4109.        return method;
    4110. 

  4110.     }
    4111. 

  4111.     for(i=0; i < pTypeAttr->cImplTypes && method == Qnil; i++){
    4112. 

  4112.        hr = pTypeInfo->lpVtbl->GetRefTypeOfImplType(pTypeInfo, i, &href);
    4113. 

  4113.        if(FAILED(hr))
    4114. 

  4114.            continue;
    4115. 

  4115.        hr = pTypeInfo->lpVtbl->GetRefTypeInfo(pTypeInfo, href, &pRefTypeInfo);
    4116. 

  4116.        if (FAILED(hr))
    4117. 

  4117.            continue;
    4118. 

  4118.        method = ole_method_sub(self, pTypeInfo, pRefTypeInfo, name);
    4119. 

  4119.        OLE_RELEASE(pRefTypeInfo);
    4120. 

  4120.     }
    4121. 

  4121.     OLE_RELEASE_TYPEATTR(pTypeInfo, pTypeAttr);
    4122. 

  4122.     return method;
    4123. 

  4123. }
    4124. 

  4124. 

  4125. static VALUE
    4126. 

  4126. ole_methods_sub(ITypeInfo *pOwnerTypeInfo, ITypeInfo *pTypeInfo, VALUE methods, int mask)
    4127. 

  4127. {
    4128. 

  4128.     HRESULT hr;
    4129. 

  4129.     TYPEATTR *pTypeAttr;
    4130. 

  4130.     BSTR bstr;
    4131. 

  4131.     char *pstr;
    4132. 

  4132.     FUNCDESC *pFuncDesc;
    4133. 

  4133.     VALUE method;
    4134. 

  4134.     WORD i;
    4135. 

  4135.     hr = OLE_GET_TYPEATTR(pTypeInfo, &pTypeAttr);
    4136. 

  4136.     if (FAILED(hr)) {
    4137. 

  4137.         ole_raise(hr, eWIN32OLERuntimeError, "failed to GetTypeAttr");
    4138. 

  4138.     }
    4139. 

  4139.     for(i = 0; i < pTypeAttr->cFuncs; i++) {
    4140. 

  4140.         pstr = NULL;
    4141. 

  4141.         hr = pTypeInfo->lpVtbl->GetFuncDesc(pTypeInfo, i, &pFuncDesc);
    4142. 

  4142.         if (FAILED(hr))
    4143. 

  4143.              continue;
    4144. 

  4144.                  
    4145. 

  4145.         hr = pTypeInfo->lpVtbl->GetDocumentation(pTypeInfo, pFuncDesc->memid,
    4146. 

  4146.                                                  &bstr, NULL, NULL, NULL);
    4147. 

  4147.         if (FAILED(hr)) {
    4148. 

  4148.             pTypeInfo->lpVtbl->ReleaseFuncDesc(pTypeInfo, pFuncDesc);
    4149. 

  4149.             continue;
    4150. 

  4150.         }
    4151. 

  4151.         if(pFuncDesc->invkind & mask) {
    4152. 

  4152.             method = folemethod_s_allocate(cWIN32OLE_METHOD);
    4153. 

  4153.             olemethod_set_member(method, pTypeInfo, pOwnerTypeInfo, 
    4154. 

  4154.                                  i, WC2VSTR(bstr));
    4155. 

  4155.             rb_ary_push(methods, method);
    4156. 

  4156.         }
    4157. 

  4157.         pTypeInfo->lpVtbl->ReleaseFuncDesc(pTypeInfo, pFuncDesc);
    4158. 

  4158.         pFuncDesc=NULL;
    4159. 

  4159.     }
    4160. 

  4160.     OLE_RELEASE_TYPEATTR(pTypeInfo, pTypeAttr);
    4161. 

  4161. 

  4162.     return methods;
    4163. 

  4163. }
    4164. 

  4164. 

  4165. static VALUE
    4166. 

  4166. ole_methods_from_typeinfo(ITypeInfo *pTypeInfo, int mask)
    4167. 

  4167. {
    4168. 

  4168.     HRESULT hr;
    4169. 

  4169.     TYPEATTR *pTypeAttr;
    4170. 

  4170.     WORD i;
    4171. 

  4171.     HREFTYPE href;
    4172. 

  4172.     ITypeInfo *pRefTypeInfo;
    4173. 

  4173.     VALUE methods = rb_ary_new();
    4174. 

  4174.     hr = OLE_GET_TYPEATTR(pTypeInfo, &pTypeAttr);
    4175. 

  4175.     if (FAILED(hr)) {
    4176. 

  4176.         ole_raise(hr, eWIN32OLERuntimeError, "failed to GetTypeAttr");
    4177. 

  4177.     }
    4178. 

  4178. 

  4179.     ole_methods_sub(0, pTypeInfo, methods, mask);
    4180. 

  4180.     for(i=0; i < pTypeAttr->cImplTypes; i++){
    4181. 

  4181.        hr = pTypeInfo->lpVtbl->GetRefTypeOfImplType(pTypeInfo, i, &href);
    4182. 

  4182.        if(FAILED(hr))
    4183. 

  4183.            continue;
    4184. 

  4184.        hr = pTypeInfo->lpVtbl->GetRefTypeInfo(pTypeInfo, href, &pRefTypeInfo);
    4185. 

  4185.        if (FAILED(hr))
    4186. 

  4186.            continue;
    4187. 

  4187.        ole_methods_sub(pTypeInfo, pRefTypeInfo, methods, mask);
    4188. 

  4188.        OLE_RELEASE(pRefTypeInfo);
    4189. 

  4189.     }
    4190. 

  4190.     OLE_RELEASE_TYPEATTR(pTypeInfo, pTypeAttr);
    4191. 

  4191.     return methods;
    4192. 

  4192. }
    4193. 

  4193. 

  4194. static HRESULT
    4195. 

  4195. typeinfo_from_ole(struct oledata *pole, ITypeInfo **ppti)
    4196. 

  4196. {
    4197. 

  4197.     ITypeInfo *pTypeInfo;
    4198. 

  4198.     ITypeLib *pTypeLib;
    4199. 

  4199.     BSTR bstr;
    4200. 

  4200.     VALUE type;
    4201. 

  4201.     UINT i;
    4202. 

  4202.     UINT count;
    4203. 

  4203.     LCID    lcid = cWIN32OLE_lcid;
    4204. 

  4204.     HRESULT hr = pole->pDispatch->lpVtbl->GetTypeInfo(pole->pDispatch,
    4205. 

  4205.                                                       0, lcid, &pTypeInfo);
    4206. 

  4206.     if(FAILED(hr)) {
    4207. 

  4207.         ole_raise(hr, rb_eRuntimeError, "failed to GetTypeInfo");
    4208. 

  4208.     }
    4209. 

  4209.     hr = pTypeInfo->lpVtbl->GetDocumentation(pTypeInfo,
    4210. 

  4210.                                              -1,
    4211. 

  4211.                                              &bstr,
    4212. 

  4212.                                              NULL, NULL, NULL);
    4213. 

  4213.     type = WC2VSTR(bstr);
    4214. 

  4214.     hr = pTypeInfo->lpVtbl->GetContainingTypeLib(pTypeInfo, &pTypeLib, &i);
    4215. 

  4215.     OLE_RELEASE(pTypeInfo);
    4216. 

  4216.     if (FAILED(hr)) {
    4217. 

  4217.         ole_raise(hr, rb_eRuntimeError, "failed to GetContainingTypeLib");
    4218. 

  4218.     }
    4219. 

  4219.     count = pTypeLib->lpVtbl->GetTypeInfoCount(pTypeLib);
    4220. 

  4220.     for (i = 0; i < count; i++) {
    4221. 

  4221.         hr = pTypeLib->lpVtbl->GetDocumentation(pTypeLib, i,
    4222. 

  4222.                                                 &bstr, NULL, NULL, NULL);
    4223. 

  4223.         if (SUCCEEDED(hr) && rb_str_cmp(WC2VSTR(bstr), type) == 0) {
    4224. 

  4224.             hr = pTypeLib->lpVtbl->GetTypeInfo(pTypeLib, i, &pTypeInfo);
    4225. 

  4225.             if (SUCCEEDED(hr)) {
    4226. 

  4226.                 *ppti = pTypeInfo;
    4227. 

  4227.                 break;
    4228. 

  4228.             }
    4229. 

  4229.         }
    4230. 

  4230.     }
    4231. 

  4231.     OLE_RELEASE(pTypeLib);
    4232. 

  4232.     return hr;
    4233. 

  4233. }
    4234. 

  4234. 

  4235. static VALUE
    4236. 

  4236. ole_methods(VALUE self, int mask)
    4237. 

  4237. {
    4238. 

  4238.     ITypeInfo *pTypeInfo;
    4239. 

  4239.     HRESULT hr;
    4240. 

  4240.     VALUE methods;
    4241. 

  4241.     struct oledata *pole;
    4242. 

  4242. 

  4243.     OLEData_Get_Struct(self, pole);
    4244. 

  4244.     methods = rb_ary_new();
    4245. 

  4245. 

  4246.     hr = typeinfo_from_ole(pole, &pTypeInfo);
    4247. 

  4247.     if(FAILED(hr))
    4248. 

  4248.         return methods;
    4249. 

  4249.     rb_ary_concat(methods, ole_methods_from_typeinfo(pTypeInfo, mask));
    4250. 

  4250.     OLE_RELEASE(pTypeInfo);
    4251. 

  4251.     return methods;
    4252. 

  4252. }
    4253. 

  4253. 

  4254. /*
    4255. 

  4255.  *  call-seq:
    4256. 

  4256.  *     WIN32OLE#ole_methods
    4257. 

  4257.  * 
    4258. 

  4258.  *  Returns the array of WIN32OLE_METHOD object. 
    4259. 

  4259.  *  The element is OLE method of WIN32OLE object.
    4260. 

  4260.  *
    4261. 

  4261.  *     excel = WIN32OLE.new('Excel.Application')
    4262. 

  4262.  *     methods = excel.ole_methods
    4263. 

  4263.  *     
    4264. 

  4264.  */
    4265. 

  4265. static VALUE
    4266. 

  4266. fole_methods(VALUE self)
    4267. 

  4267. {
    4268. 

  4268.     return ole_methods( self, INVOKE_FUNC | INVOKE_PROPERTYGET | INVOKE_PROPERTYPUT | INVOKE_PROPERTYPUTREF);
    4269. 

  4269. }
    4270. 

  4270. 

  4271. /*
    4272. 

  4272.  *  call-seq:
    4273. 

  4273.  *     WIN32OLE#ole_get_methods
    4274. 

  4274.  * 
    4275. 

  4275.  *  Returns the array of WIN32OLE_METHOD object .
    4276. 

  4276.  *  The element of the array is property (gettable) of WIN32OLE object.
    4277. 

  4277.  *
    4278. 

  4278.  *     excel = WIN32OLE.new('Excel.Application')
    4279. 

  4279.  *     properties = excel.ole_get_methods
    4280. 

  4280.  */
    4281. 

  4281. static VALUE
    4282. 

  4282. fole_get_methods(VALUE self)
    4283. 

  4283. {
    4284. 

  4284.     return ole_methods( self, INVOKE_PROPERTYGET);
    4285. 

  4285. }
    4286. 

  4286. 

  4287. /*
    4288. 

  4288.  *  call-seq:
    4289. 

  4289.  *     WIN32OLE#ole_put_methods
    4290. 

  4290.  * 
    4291. 

  4291.  *  Returns the array of WIN32OLE_METHOD object .
    4292. 

  4292.  *  The element of the array is property (settable) of WIN32OLE object.
    4293. 

  4293.  *
    4294. 

  4294.  *     excel = WIN32OLE.new('Excel.Application')
    4295. 

  4295.  *     properties = excel.ole_put_methods
    4296. 

  4296.  */
    4297. 

  4297. static VALUE
    4298. 

  4298. fole_put_methods(VALUE self)
    4299. 

  4299. {
    4300. 

  4300.     return ole_methods( self, INVOKE_PROPERTYPUT|INVOKE_PROPERTYPUTREF);
    4301. 

  4301. }
    4302. 

  4302. 

  4303. /*
    4304. 

  4304.  *  call-seq:
    4305. 

  4305.  *     WIN32OLE#ole_func_methods
    4306. 

  4306.  * 
    4307. 

  4307.  *  Returns the array of WIN32OLE_METHOD object .
    4308. 

  4308.  *  The element of the array is property (settable) of WIN32OLE object.
    4309. 

  4309.  *
    4310. 

  4310.  *     excel = WIN32OLE.new('Excel.Application')
    4311. 

  4311.  *     properties = excel.ole_func_methods
    4312. 

  4312.  *
    4313. 

  4313.  */
    4314. 

  4314. static VALUE
    4315. 

  4315. fole_func_methods(VALUE self)
    4316. 

  4316. {
    4317. 

  4317.     return ole_methods( self, INVOKE_FUNC);
    4318. 

  4318. }
    4319. 

  4319. 

  4320. static VALUE
    4321. 

  4321. ole_type_from_itypeinfo(ITypeInfo *pTypeInfo)
    4322. 

  4322. {
    4323. 

  4323.     ITypeLib *pTypeLib;
    4324. 

  4324.     VALUE type = Qnil;
    4325. 

  4325.     HRESULT hr;
    4326. 

  4326.     unsigned int index;
    4327. 

  4327.     BSTR bstr;
    4328. 

  4328. 

  4329.     hr = pTypeInfo->lpVtbl->GetContainingTypeLib( pTypeInfo, &pTypeLib, &index );
    4330. 

  4330.     if(FAILED(hr)) {
    4331. 

  4331.         return Qnil;
    4332. 

  4332.     }
    4333. 

  4333.     hr = pTypeLib->lpVtbl->GetDocumentation( pTypeLib, index,
    4334. 

  4334.                                              &bstr, NULL, NULL, NULL);
    4335. 

  4335.     OLE_RELEASE(pTypeLib);
    4336. 

  4336.     if (FAILED(hr)) {
    4337. 

  4337.         return Qnil;
    4338. 

  4338.     }
    4339. 

  4339.     type = foletype_s_allocate(cWIN32OLE_TYPE);
    4340. 

  4340.     oletype_set_member(type, pTypeInfo, WC2VSTR(bstr));
    4341. 

  4341.     return type;
    4342. 

  4342. }
    4343. 

  4343. 

  4344. /*
    4345. 

  4345.  *   call-seq:
    4346. 

  4346.  *      WIN32OLE#ole_type
    4347. 

  4347.  * 
    4348. 

  4348.  *   Returns WIN32OLE_TYPE object.
    4349. 

  4349.  *
    4350. 

  4350.  *      excel = WIN32OLE.new('Excel.Application')
    4351. 

  4351.  *      tobj = excel.ole_type
    4352. 

  4352.  */
    4353. 

  4353. static VALUE
    4354. 

  4354. fole_type(VALUE self)
    4355. 

  4355. {
    4356. 

  4356.     ITypeInfo *pTypeInfo;
    4357. 

  4357.     HRESULT hr;
    4358. 

  4358.     struct oledata *pole;
    4359. 

  4359.     LCID  lcid = cWIN32OLE_lcid;
    4360. 

  4360.     VALUE type = Qnil;
    4361. 

  4361. 

  4362.     OLEData_Get_Struct(self, pole);
    4363. 

  4363. 

  4364.     hr = pole->pDispatch->lpVtbl->GetTypeInfo( pole->pDispatch, 0, lcid, &pTypeInfo );
    4365. 

  4365.     if(FAILED(hr)) {
    4366. 

  4366.         ole_raise(hr, rb_eRuntimeError, "failed to GetTypeInfo");
    4367. 

  4367.     }
    4368. 

  4368.     type = ole_type_from_itypeinfo(pTypeInfo);
    4369. 

  4369.     OLE_RELEASE(pTypeInfo);
    4370. 

  4370.     if (type == Qnil) {
    4371. 

  4371.         rb_raise(rb_eRuntimeError, "failed to create WIN32OLE_TYPE obj from ITypeInfo");
    4372. 

  4372.     }
    4373. 

  4373.     return type;
    4374. 

  4374. }
    4375. 

  4375. 

  4376. static VALUE
    4377. 

  4377. ole_typelib_from_itypeinfo(ITypeInfo *pTypeInfo)
    4378. 

  4378. {
    4379. 

  4379.     HRESULT hr;
    4380. 

  4380.     ITypeLib *pTypeLib;
    4381. 

  4381.     unsigned int index;
    4382. 

  4382.     VALUE retval = Qnil;
    4383. 

  4383. 

  4384.     hr = pTypeInfo->lpVtbl->GetContainingTypeLib(pTypeInfo, &pTypeLib, &index);
    4385. 

  4385.     if(FAILED(hr)) {
    4386. 

  4386.         return Qnil;
    4387. 

  4387.     }
    4388. 

  4388.     retval = rb_funcall(cWIN32OLE_TYPELIB, rb_intern("allocate"), 0);
    4389. 

  4389.     oletypelib_set_member(retval, pTypeLib);
    4390. 

  4390.     return retval;
    4391. 

  4391. }
    4392. 

  4392. 

  4393. /*
    4394. 

  4394.  *  call-seq:
    4395. 

  4395.  *     WIN32OLE#ole_typelib -> The WIN32OLE_TYPELIB object 
    4396. 

  4396.  *
    4397. 

  4397.  *  Returns the WIN32OLE_TYPELIB object. The object represents the
    4398. 

  4398.  *  type library which contains the WIN32OLE object.
    4399. 

  4399.  *
    4400. 

  4400.  *     excel = WIN32OLE.new('Excel.Application')
    4401. 

  4401.  *     tlib = excel.ole_typelib
    4402. 

  4402.  *     puts tlib.name  # -> 'Microsoft Excel 9.0 Object Library'
    4403. 

  4403.  */
    4404. 

  4404. static VALUE
    4405. 

  4405. fole_typelib(VALUE self)
    4406. 

  4406. {
    4407. 

  4407.     struct oledata *pole;
    4408. 

  4408.     HRESULT hr;
    4409. 

  4409.     ITypeInfo *pTypeInfo;
    4410. 

  4410.     LCID  lcid = cWIN32OLE_lcid;
    4411. 

  4411.     VALUE vtlib = Qnil;
    4412. 

  4412. 

  4413.     OLEData_Get_Struct(self, pole);
    4414. 

  4414.     hr = pole->pDispatch->lpVtbl->GetTypeInfo(pole->pDispatch,
    4415. 

  4415.                                               0, lcid, &pTypeInfo);
    4416. 

  4416.     if(FAILED(hr)) {
    4417. 

  4417.         ole_raise(hr, rb_eRuntimeError, "failed to GetTypeInfo");
    4418. 

  4418.     }
    4419. 

  4419.     vtlib = ole_typelib_from_itypeinfo(pTypeInfo);
    4420. 

  4420.     OLE_RELEASE(pTypeInfo);
    4421. 

  4421.     if (vtlib == Qnil) {
    4422. 

  4422.         rb_raise(rb_eRuntimeError, "failed to get type library info.");
    4423. 

  4423.     }
    4424. 

  4424.     return vtlib;
    4425. 

  4425. }
    4426. 

  4426. 

  4427. /*
    4428. 

  4428.  *  call-seq:
    4429. 

  4429.  *     WIN32OLE#ole_query_interface(iid) -> WIN32OLE object
    4430. 

  4430.  * 
    4431. 

  4431.  *  Returns WIN32OLE object for a specific dispatch or dual
    4432. 

  4432.  *  interface specified by iid.
    4433. 

  4433.  *
    4434. 

  4434.  *      ie = WIN32OLE.new('InternetExplorer.Application')
    4435. 

  4435.  *      ie_web_app = ie.ole_query_interface('{0002DF05-0000-0000-C000-000000000046}') # => WIN32OLE object for dispinterface IWebBrowserApp 
    4436. 

  4436.  */
    4437. 

  4437. static VALUE
    4438. 

  4438. fole_query_interface(VALUE self, VALUE str_iid)
    4439. 

  4439. {
    4440. 

  4440.     HRESULT hr;
    4441. 

  4441.     OLECHAR *pBuf;
    4442. 

  4442.     IID iid;
    4443. 

  4443.     struct oledata *pole;
    4444. 

  4444.     IDispatch *pDispatch;
    4445. 

  4445.     void *p;
    4446. 

  4446.          
    4447. 

  4447.     pBuf  = ole_vstr2wc(str_iid);
    4448. 

  4448.     hr = CLSIDFromString(pBuf, &iid);
    4449. 

  4449.     SysFreeString(pBuf);
    4450. 

  4450.     if(FAILED(hr)) {
    4451. 

  4451.         ole_raise(hr, eWIN32OLERuntimeError, 
    4452. 

  4452.                   "invalid iid: `%s'",
    4453. 

  4453.                   StringValuePtr(str_iid));
    4454. 

  4454.     }
    4455. 

  4455. 

  4456.     OLEData_Get_Struct(self, pole);
    4457. 

  4457.     if(!pole->pDispatch) {
    4458. 

  4458.         rb_raise(rb_eRuntimeError, "failed to get dispatch interface");
    4459. 

  4459.     }
    4460. 

  4460. 

  4461.     hr = pole->pDispatch->lpVtbl->QueryInterface(pole->pDispatch, &iid,
    4462. 

  4462.                                                  &p);
    4463. 

  4463.     if(FAILED(hr)) {
    4464. 

  4464.         ole_raise(hr, eWIN32OLERuntimeError, 
    4465. 

  4465.                   "failed to get interface `%s'", 
    4466. 

  4466.                   StringValuePtr(str_iid));
    4467. 

  4467.     }
    4468. 

  4468. 

  4469.     pDispatch = p;
    4470. 

  4470.     return create_win32ole_object(cWIN32OLE, pDispatch, 0, 0);
    4471. 

  4471. }
    4472. 

  4472. 

  4473. /*
    4474. 

  4474.  *  call-seq:
    4475. 

  4475.  *     WIN32OLE#ole_respond_to?(method) -> true or false
    4476. 

  4476.  * 
    4477. 

  4477.  *  Returns true when OLE object has OLE method, otherwise returns false.
    4478. 

  4478.  *
    4479. 

  4479.  *      ie = WIN32OLE.new('InternetExplorer.Application')
    4480. 

  4480.  *      ie.ole_respond_to?("gohome") => true
    4481. 

  4481.  */
    4482. 

  4482. static VALUE
    4483. 

  4483. fole_respond_to(VALUE self, VALUE method)
    4484. 

  4484. {
    4485. 

  4485.     struct oledata *pole;
    4486. 

  4486.     BSTR wcmdname;
    4487. 

  4487.     DISPID DispID;
    4488. 

  4488.     HRESULT hr;
    4489. 

  4489.     rb_secure(4);
    4490. 

  4490.     if(TYPE(method) != T_STRING && TYPE(method) != T_SYMBOL) {
    4491. 

  4491. 	rb_raise(rb_eTypeError, "wrong argument type (expected String or Symbol)");
    4492. 

  4492.     }
    4493. 

  4493.     if (TYPE(method) == T_SYMBOL) {
    4494. 

  4494. 	method = rb_sym_to_s(method);
    4495. 

  4495.     }
    4496. 

  4496.     OLEData_Get_Struct(self, pole);
    4497. 

  4497.     wcmdname = ole_vstr2wc(method);
    4498. 

  4498.     hr = pole->pDispatch->lpVtbl->GetIDsOfNames( pole->pDispatch, &IID_NULL,
    4499. 

  4499. 	    &wcmdname, 1, cWIN32OLE_lcid, &DispID);
    4500. 

  4500.     SysFreeString(wcmdname);
    4501. 

  4501.     return SUCCEEDED(hr) ? Qtrue : Qfalse;
    4502. 

  4502. }
    4503. 

  4503. 

  4504. static HRESULT
    4505. 

  4505. ole_docinfo_from_type(ITypeInfo *pTypeInfo, BSTR *name, BSTR *helpstr, DWORD *helpcontext, BSTR *helpfile)
    4506. 

  4506. {
    4507. 

  4507.     HRESULT hr;
    4508. 

  4508.     ITypeLib *pTypeLib;
    4509. 

  4509.     UINT i;
    4510. 

  4510. 

  4511.     hr = pTypeInfo->lpVtbl->GetContainingTypeLib(pTypeInfo, &pTypeLib, &i);
    4512. 

  4512.     if (FAILED(hr)) {
    4513. 

  4513.         return hr;
    4514. 

  4514.     }
    4515. 

  4515.     
    4516. 

  4516.     hr = pTypeLib->lpVtbl->GetDocumentation(pTypeLib, i,
    4517. 

  4517.                                             name, helpstr, 
    4518. 

  4518.                                             helpcontext, helpfile);
    4519. 

  4519.     if (FAILED(hr)) {
    4520. 

  4520.         OLE_RELEASE(pTypeLib);
    4521. 

  4521.         return hr;
    4522. 

  4522.     }
    4523. 

  4523.     OLE_RELEASE(pTypeLib);
    4524. 

  4524.     return hr;
    4525. 

  4525. }
    4526. 

  4526. 

  4527. static VALUE
    4528. 

  4528. ole_usertype2val(ITypeInfo *pTypeInfo, TYPEDESC *pTypeDesc, VALUE typedetails)
    4529. 

  4529. {
    4530. 

  4530.     HRESULT hr;
    4531. 

  4531.     BSTR bstr;
    4532. 

  4532.     ITypeInfo *pRefTypeInfo;
    4533. 

  4533.     VALUE type = Qnil;
    4534. 

  4534. 

  4535.     hr = pTypeInfo->lpVtbl->GetRefTypeInfo(pTypeInfo, 
    4536. 

  4536.                                            V_UNION1(pTypeDesc, hreftype),
    4537. 

  4537.                                            &pRefTypeInfo);
    4538. 

  4538.     if(FAILED(hr))
    4539. 

  4539.         return Qnil;
    4540. 

  4540.     hr = ole_docinfo_from_type(pRefTypeInfo, &bstr, NULL, NULL, NULL);
    4541. 

  4541.     if(FAILED(hr)) {
    4542. 

  4542.         OLE_RELEASE(pRefTypeInfo);
    4543. 

  4543.         return Qnil;
    4544. 

  4544.     }
    4545. 

  4545.     OLE_RELEASE(pRefTypeInfo);
    4546. 

  4546.     type = WC2VSTR(bstr);
    4547. 

  4547.     if(typedetails != Qnil)
    4548. 

  4548.         rb_ary_push(typedetails, type);
    4549. 

  4549.     return type;
    4550. 

  4550. }
    4551. 

  4551. 

  4552. static VALUE
    4553. 

  4553. ole_ptrtype2val(ITypeInfo *pTypeInfo, TYPEDESC *pTypeDesc, VALUE typedetails)
    4554. 

  4554. {    
    4555. 

  4555.     TYPEDESC *p = pTypeDesc;
    4556. 

  4556.     VALUE type = rb_str_new2("");
    4557. 

  4557. 

  4558.     if (p->vt == VT_PTR || p->vt == VT_SAFEARRAY) {
    4559. 

  4559.         p = V_UNION1(p, lptdesc);
    4560. 

  4560.         type = ole_typedesc2val(pTypeInfo, p, typedetails);
    4561. 

  4561.     }
    4562. 

  4562.     return type;
    4563. 

  4563. }
    4564. 

  4564. 

  4565. static VALUE
    4566. 

  4566. ole_typedesc2val(ITypeInfo *pTypeInfo, TYPEDESC *pTypeDesc, VALUE typedetails)
    4567. 

  4567. {
    4568. 

  4568.     VALUE str;
    4569. 

  4569.     VALUE typestr = Qnil;
    4570. 

  4570.     switch(pTypeDesc->vt) {
    4571. 

  4571.     case VT_I2:
    4572. 

  4572.         typestr = rb_str_new2("I2");
    4573. 

  4573.         break;
    4574. 

  4574.     case VT_I4:
    4575. 

  4575.         typestr = rb_str_new2("I4");
    4576. 

  4576.         break;
    4577. 

  4577.     case VT_R4:
    4578. 

  4578.         typestr = rb_str_new2("R4");
    4579. 

  4579.         break;
    4580. 

  4580.     case VT_R8:
    4581. 

  4581.         typestr = rb_str_new2("R8");
    4582. 

  4582.         break;
    4583. 

  4583.     case VT_CY:
    4584. 

  4584.         typestr = rb_str_new2("CY");
    4585. 

  4585.         break;
    4586. 

  4586.     case VT_DATE:
    4587. 

  4587.         typestr = rb_str_new2("DATE");
    4588. 

  4588.         break;
    4589. 

  4589.     case VT_BSTR:
    4590. 

  4590.         typestr = rb_str_new2("BSTR");
    4591. 

  4591.         break;
    4592. 

  4592.     case VT_BOOL:
    4593. 

  4593.         typestr = rb_str_new2("BOOL");
    4594. 

  4594.         break;
    4595. 

  4595.     case VT_VARIANT:
    4596. 

  4596.         typestr = rb_str_new2("VARIANT");
    4597. 

  4597.         break;
    4598. 

  4598.     case VT_DECIMAL:
    4599. 

  4599.         typestr = rb_str_new2("DECIMAL");
    4600. 

  4600.         break;
    4601. 

  4601.     case VT_I1:
    4602. 

  4602.         typestr = rb_str_new2("I1");
    4603. 

  4603.         break;
    4604. 

  4604.     case VT_UI1:
    4605. 

  4605.         typestr = rb_str_new2("UI1");
    4606. 

  4606.         break;
    4607. 

  4607.     case VT_UI2:
    4608. 

  4608.         typestr = rb_str_new2("UI2");
    4609. 

  4609.         break;
    4610. 

  4610.     case VT_UI4:
    4611. 

  4611.         typestr = rb_str_new2("UI4");
    4612. 

  4612.         break;
    4613. 

  4613. #if (_MSC_VER >= 1300) || defined(__CYGWIN__) || defined(__MINGW32__)
    4614. 

  4614.     case VT_I8:
    4615. 

  4615.         typestr = rb_str_new2("I8");
    4616. 

  4616.         break;
    4617. 

  4617.     case VT_UI8:
    4618. 

  4618.         typestr = rb_str_new2("UI8");
    4619. 

  4619.         break;
    4620. 

  4620. #endif
    4621. 

  4621.     case VT_INT:
    4622. 

  4622.         typestr = rb_str_new2("INT");
    4623. 

  4623.         break;
    4624. 

  4624.     case VT_UINT:
    4625. 

  4625.         typestr = rb_str_new2("UINT");
    4626. 

  4626.         break;
    4627. 

  4627.     case VT_VOID:
    4628. 

  4628.         typestr = rb_str_new2("VOID");
    4629. 

  4629.         break;
    4630. 

  4630.     case VT_HRESULT:
    4631. 

  4631.         typestr = rb_str_new2("HRESULT");
    4632. 

  4632.         break;
    4633. 

  4633.     case VT_PTR:
    4634. 

  4634.         typestr = rb_str_new2("PTR");
    4635. 

  4635.         if(typedetails != Qnil)
    4636. 

  4636.             rb_ary_push(typedetails, typestr);
    4637. 

  4637.         return ole_ptrtype2val(pTypeInfo, pTypeDesc, typedetails);
    4638. 

  4638.     case VT_SAFEARRAY:
    4639. 

  4639.         typestr = rb_str_new2("SAFEARRAY");
    4640. 

  4640.         if(typedetails != Qnil)
    4641. 

  4641.             rb_ary_push(typedetails, typestr);
    4642. 

  4642.         return ole_ptrtype2val(pTypeInfo, pTypeDesc, typedetails);
    4643. 

  4643.     case VT_CARRAY:
    4644. 

  4644.         typestr = rb_str_new2("CARRAY");
    4645. 

  4645.         break;
    4646. 

  4646.     case VT_USERDEFINED:
    4647. 

  4647.         typestr = rb_str_new2("USERDEFINED");
    4648. 

  4648.         if (typedetails != Qnil) 
    4649. 

  4649.             rb_ary_push(typedetails, typestr);
    4650. 

  4650.         str = ole_usertype2val(pTypeInfo, pTypeDesc, typedetails);
    4651. 

  4651.         if (str != Qnil) {
    4652. 

  4652.             return str;
    4653. 

  4653.         }
    4654. 

  4654.         return typestr;
    4655. 

  4655.     case VT_UNKNOWN:
    4656. 

  4656.         typestr = rb_str_new2("UNKNOWN");
    4657. 

  4657.         break;
    4658. 

  4658.     case VT_DISPATCH:
    4659. 

  4659.         typestr = rb_str_new2("DISPATCH");
    4660. 

  4660.         break;
    4661. 

  4661.     case VT_ERROR:
    4662. 

  4662.         typestr = rb_str_new2("ERROR");
    4663. 

  4663.         break;
    4664. 

  4664.     case VT_LPWSTR:
    4665. 

  4665.         typestr = rb_str_new2("LPWSTR");
    4666. 

  4666.         break;
    4667. 

  4667.     case VT_LPSTR:
    4668. 

  4668.         typestr = rb_str_new2("LPSTR");
    4669. 

  4669.         break;
    4670. 

  4670.     default:
    4671. 

  4671.         typestr = rb_str_new2("Unknown Type ");
    4672. 

  4672.         rb_str_concat(typestr, rb_fix2str(INT2FIX(pTypeDesc->vt), 10));
    4673. 

  4673.         break;
    4674. 

  4674.     }
    4675. 

  4675.     if (typedetails != Qnil)
    4676. 

  4676.         rb_ary_push(typedetails, typestr);
    4677. 

  4677.     return typestr;
    4678. 

  4678. }
    4679. 

  4679. 

  4680. /*
    4681. 

  4681.  *   call-seq:
    4682. 

  4682.  *      WIN32OLE#ole_method_help(method)
    4683. 

  4683.  * 
    4684. 

  4684.  *   Returns WIN32OLE_METHOD object corresponding with method 
    4685. 

  4685.  *   specified by 1st argument.
    4686. 

  4686.  *
    4687. 

  4687.  *      excel = WIN32OLE.new('Excel.Application')
    4688. 

  4688.  *      method = excel.ole_method_help('Quit')
    4689. 

  4689.  *
    4690. 

  4690.  */
    4691. 

  4691. static VALUE
    4692. 

  4692. fole_method_help(VALUE self, VALUE cmdname)
    4693. 

  4693. {
    4694. 

  4694.     ITypeInfo *pTypeInfo;
    4695. 

  4695.     HRESULT hr;
    4696. 

  4696.     struct oledata *pole;
    4697. 

  4697.     VALUE method, obj;
    4698. 

  4698. 

  4699.     SafeStringValue(cmdname);
    4700. 

  4700.     OLEData_Get_Struct(self, pole);
    4701. 

  4701.     hr = typeinfo_from_ole(pole, &pTypeInfo);
    4702. 

  4702.     if(FAILED(hr))
    4703. 

  4703.         ole_raise(hr, rb_eRuntimeError, "failed to get ITypeInfo");
    4704. 

  4704.     method = folemethod_s_allocate(cWIN32OLE_METHOD);
    4705. 

  4705.     obj = olemethod_from_typeinfo(method, pTypeInfo, cmdname);
    4706. 

  4706.     OLE_RELEASE(pTypeInfo);
    4707. 

  4707.     if (obj == Qnil)
    4708. 

  4708.         rb_raise(eWIN32OLERuntimeError, "not found %s",
    4709. 

  4709.                  StringValuePtr(cmdname));
    4710. 

  4710.     return obj;
    4711. 

  4711. }
    4712. 

  4712. 

  4713. /*
    4714. 

  4714.  *  call-seq:
    4715. 

  4715.  *     WIN32OLE#ole_activex_initialize() -> Qnil
    4716. 

  4716.  *
    4717. 

  4717.  *  Initialize WIN32OLE object(ActiveX Control) by calling 
    4718. 

  4718.  *  IPersistMemory::InitNew.
    4719. 

  4719.  *
    4720. 

  4720.  *  Before calling OLE method, some kind of the ActiveX controls 
    4721. 

  4721.  *  created with MFC should be initialized by calling 
    4722. 

  4722.  *  IPersistXXX::InitNew.
    4723. 

  4723.  *
    4724. 

  4724.  *  If and only if you received the exception "HRESULT error code:
    4725. 

  4725.  *  0x8000ffff catastrophic failure", try this method before
    4726. 

  4726.  *  invoking any ole_method.
    4727. 

  4727.  *
    4728. 

  4728.  *     obj = WIN32OLE.new("ProgID_or_GUID_of_ActiveX_Control")
    4729. 

  4729.  *     obj.ole_activex_initialize
    4730. 

  4730.  *     obj.method(...)
    4731. 

  4731.  *  
    4732. 

  4732.  */ 
    4733. 

  4733. static VALUE
    4734. 

  4734. fole_activex_initialize(VALUE self) 
    4735. 

  4735. {
    4736. 

  4736.     struct oledata *pole;
    4737. 

  4737.     IPersistMemory *pPersistMemory;
    4738. 

  4738.     void *p;
    4739. 

  4739. 

  4740.     HRESULT hr = S_OK;
    4741. 

  4741. 

  4742.     OLEData_Get_Struct(self, pole);
    4743. 

  4743. 

  4744.     hr = pole->pDispatch->lpVtbl->QueryInterface(pole->pDispatch, &IID_IPersistMemory, &p);
    4745. 

  4745.     pPersistMemory = p;
    4746. 

  4746.     if (SUCCEEDED(hr)) {
    4747. 

  4747.         hr = pPersistMemory->lpVtbl->InitNew(pPersistMemory);
    4748. 

  4748.         OLE_RELEASE(pPersistMemory);
    4749. 

  4749.         if (SUCCEEDED(hr)) {
    4750. 

  4750.             return Qnil;
    4751. 

  4751.         }
    4752. 

  4752.     }
    4753. 

  4753. 

  4754.     if (FAILED(hr)) {
    4755. 

  4755.         ole_raise(hr, eWIN32OLERuntimeError, "fail to initialize ActiveX control");
    4756. 

  4756.     }
    4757. 

  4757. 

  4758.     return Qnil;
    4759. 

  4759. }
    4760. 

  4760. 

  4761. /*
    4762. 

  4762.  *   call-seq:
    4763. 

  4763.  *      WIN32OLE_TYPE.ole_classes(typelib)
    4764. 

  4764.  * 
    4765. 

  4765.  *   Returns array of WIN32OLE_TYPE objects defined by the <i>typelib</i> type library.
    4766. 

  4766.  *   This method will be OBSOLETE. Use WIN32OLE_TYPELIB.new(typelib).ole_classes instead.
    4767. 

  4767.  */
    4768. 

  4768. static VALUE
    4769. 

  4769. foletype_s_ole_classes(VALUE self, VALUE typelib)
    4770. 

  4770. {
    4771. 

  4771.     VALUE obj;
    4772. 

  4772. 

  4773.     /*
    4774. 

  4774.     rb_warn("%s is obsolete; use %s instead.",
    4775. 

  4775.             "WIN32OLE_TYPE.ole_classes",
    4776. 

  4776.             "WIN32OLE_TYPELIB.new(typelib).ole_types");
    4777. 

  4777.     */
    4778. 

  4778.     obj = rb_funcall(cWIN32OLE_TYPELIB, rb_intern("new"), 1, typelib);
    4779. 

  4779.     return rb_funcall(obj, rb_intern("ole_types"), 0);
    4780. 

  4780. }
    4781. 

  4781. 

  4782. /*
    4783. 

  4783.  *  call-seq:
    4784. 

  4784.  *     WIN32OLE_TYPE.typelibs
    4785. 

  4785.  * 
    4786. 

  4786.  *  Returns array of type libraries.
    4787. 

  4787.  *  This method will be OBSOLETE. Use WIN32OLE_TYPELIB.typelibs.collect{|t| t.name} instead.
    4788. 

  4788.  *
    4789. 

  4789.  */
    4790. 

  4790. static VALUE
    4791. 

  4791. foletype_s_typelibs(VALUE self)
    4792. 

  4792. {
    4793. 

  4793.     /*
    4794. 

  4794.     rb_warn("%s is obsolete. use %s instead.",
    4795. 

  4795.             "WIN32OLE_TYPE.typelibs",
    4796. 

  4796.             "WIN32OLE_TYPELIB.typelibs.collect{t|t.name}");
    4797. 

  4797.     */
    4798. 

  4798.     return rb_eval_string("WIN32OLE_TYPELIB.typelibs.collect{|t|t.name}");
    4799. 

  4799. }
    4800. 

  4800. 

  4801. /*
    4802. 

  4802.  *  call-seq:
    4803. 

  4803.  *     WIN32OLE_TYPE.progids
    4804. 

  4804.  * 
    4805. 

  4805.  *  Returns array of ProgID.
    4806. 

  4806.  */
    4807. 

  4807. static VALUE
    4808. 

  4808. foletype_s_progids(VALUE self)
    4809. 

  4809. {
    4810. 

  4810.     HKEY hclsids, hclsid;
    4811. 

  4811.     DWORD i;
    4812. 

  4812.     LONG err;
    4813. 

  4813.     VALUE clsid;
    4814. 

  4814.     VALUE v = rb_str_new2("");
    4815. 

  4815.     VALUE progids = rb_ary_new();
    4816. 

  4816. 

  4817.     err = reg_open_key(HKEY_CLASSES_ROOT, "CLSID", &hclsids);
    4818. 

  4818.     if(err != ERROR_SUCCESS) {
    4819. 

  4819.         return progids;
    4820. 

  4820.     }
    4821. 

  4821.     for(i = 0; ; i++) {
    4822. 

  4822.         clsid = reg_enum_key(hclsids, i);
    4823. 

  4823.         if (clsid == Qnil)
    4824. 

  4824.             break;
    4825. 

  4825.         err = reg_open_vkey(hclsids, clsid, &hclsid);
    4826. 

  4826.         if (err != ERROR_SUCCESS)
    4827. 

  4827.             continue;
    4828. 

  4828.         if ((v = reg_get_val2(hclsid, "ProgID")) != Qnil) 
    4829. 

  4829.             rb_ary_push(progids, v);
    4830. 

  4830.         if ((v = reg_get_val2(hclsid, "VersionIndependentProgID")) != Qnil)
    4831. 

  4831.             rb_ary_push(progids, v);
    4832. 

  4832.         RegCloseKey(hclsid);
    4833. 

  4833.     }
    4834. 

  4834.     RegCloseKey(hclsids);
    4835. 

  4835.     return progids;
    4836. 

  4836. }
    4837. 

  4837. 

  4838. static VALUE
    4839. 

  4839. foletype_s_allocate(VALUE klass)
    4840. 

  4840. {
    4841. 

  4841.     struct oletypedata *poletype;
    4842. 

  4842.     VALUE obj;
    4843. 

  4843.     ole_initialize();
    4844. 

  4844.     obj = Data_Make_Struct(klass,struct oletypedata,0,oletype_free,poletype);
    4845. 

  4845.     poletype->pTypeInfo = NULL;
    4846. 

  4846.     return obj;
    4847. 

  4847. }
    4848. 

  4848. 

  4849. static VALUE
    4850. 

  4850. oletype_set_member(VALUE self, ITypeInfo *pTypeInfo, VALUE name)
    4851. 

  4851. {
    4852. 

  4852.     struct oletypedata *ptype;
    4853. 

  4853.     Data_Get_Struct(self, struct oletypedata, ptype);
    4854. 

  4854.     rb_ivar_set(self, rb_intern("name"), name);
    4855. 

  4855.     ptype->pTypeInfo = pTypeInfo;
    4856. 

  4856.     if(pTypeInfo) OLE_ADDREF(pTypeInfo);
    4857. 

  4857.     return self;
    4858. 

  4858. }
    4859. 

  4859. 

  4860. static VALUE
    4861. 

  4861. oleclass_from_typelib(VALUE self, ITypeLib *pTypeLib, VALUE oleclass)
    4862. 

  4862. {
    4863. 

  4863.     
    4864. 

  4864.     long count;
    4865. 

  4865.     int i;
    4866. 

  4866.     HRESULT hr;
    4867. 

  4867.     BSTR bstr;
    4868. 

  4868.     VALUE typelib;
    4869. 

  4869.     ITypeInfo *pTypeInfo;
    4870. 

  4870. 

  4871.     VALUE found = Qfalse;
    4872. 

  4872.   
    4873. 

  4873.     count = pTypeLib->lpVtbl->GetTypeInfoCount(pTypeLib);
    4874. 

  4874.     for (i = 0; i < count && found == Qfalse; i++) {
    4875. 

  4875.         hr = pTypeLib->lpVtbl->GetTypeInfo(pTypeLib, i, &pTypeInfo);
    4876. 

  4876.         if (FAILED(hr))
    4877. 

  4877.             continue;
    4878. 

  4878.         hr = pTypeLib->lpVtbl->GetDocumentation(pTypeLib, i,
    4879. 

  4879.                                                 &bstr, NULL, NULL, NULL);
    4880. 

  4880.         if (FAILED(hr)) 
    4881. 

  4881.             continue;
    4882. 

  4882.         typelib = WC2VSTR(bstr);
    4883. 

  4883.         if (rb_str_cmp(oleclass, typelib) == 0) {
    4884. 

  4884.             oletype_set_member(self, pTypeInfo, typelib);
    4885. 

  4885.             found = Qtrue;
    4886. 

  4886.         }
    4887. 

  4887.         OLE_RELEASE(pTypeInfo);
    4888. 

  4888.     }
    4889. 

  4889.     return found;
    4890. 

  4890. }
    4891. 

  4891. 

  4892. /*
    4893. 

  4893.  * Document-class: WIN32OLE_TYPELIB
    4894. 

  4894.  *
    4895. 

  4895.  *   <code>WIN32OLE_TYPELIB</code> objects represent OLE tyblib information.
    4896. 

  4896.  */
    4897. 

  4897. 

  4898. static VALUE
    4899. 

  4899. oletypelib_set_member(VALUE self, ITypeLib *pTypeLib)
    4900. 

  4900. {
    4901. 

  4901.     struct oletypelibdata *ptlib;
    4902. 

  4902.     Data_Get_Struct(self, struct oletypelibdata, ptlib);
    4903. 

  4903.     ptlib->pTypeLib = pTypeLib;
    4904. 

  4904.     return self;
    4905. 

  4905. }
    4906. 

  4906. 

  4907. static ITypeLib *
    4908. 

  4908. oletypelib_get_typelib(VALUE self)
    4909. 

  4909. {
    4910. 

  4910.     struct oletypelibdata *ptlib;
    4911. 

  4911.     Data_Get_Struct(self, struct oletypelibdata, ptlib);
    4912. 

  4912.     return ptlib->pTypeLib;
    4913. 

  4913. }
    4914. 

  4914. 

  4915. static void
    4916. 

  4916. oletypelib_get_libattr(ITypeLib *pTypeLib, TLIBATTR **ppTLibAttr)
    4917. 

  4917. {
    4918. 

  4918.     HRESULT hr;
    4919. 

  4919.     hr = pTypeLib->lpVtbl->GetLibAttr(pTypeLib, ppTLibAttr);
    4920. 

  4920.     if (FAILED(hr)) {
    4921. 

  4921.         ole_raise(hr, eWIN32OLERuntimeError, 
    4922. 

  4922. 		  "failed to get library attribute(TLIBATTR) from ITypeLib");
    4923. 

  4923.     }
    4924. 

  4924. }
    4925. 

  4925. 

  4926. /*
    4927. 

  4927.  *  call-seq:
    4928. 

  4928.  *
    4929. 

  4929.  *     WIN32OLE_TYPELIB.typelibs
    4930. 

  4930.  *
    4931. 

  4931.  *  Returns the array of WIN32OLE_TYPELIB object.
    4932. 

  4932.  *
    4933. 

  4933.  *     tlibs = WIN32OLE_TYPELIB.typelibs
    4934. 

  4934.  *
    4935. 

  4935.  */
    4936. 

  4936. static VALUE
    4937. 

  4937. foletypelib_s_typelibs(VALUE self)
    4938. 

  4938. {
    4939. 

  4939.     HKEY htypelib, hguid;
    4940. 

  4940.     DWORD i, j;
    4941. 

  4941.     LONG err;
    4942. 

  4942.     VALUE guid;
    4943. 

  4943.     VALUE version;
    4944. 

  4944.     VALUE name = Qnil;
    4945. 

  4945.     VALUE typelibs = rb_ary_new();
    4946. 

  4946.     VALUE typelib = Qnil;
    4947. 

  4947.     HRESULT hr;
    4948. 

  4948.     ITypeLib *pTypeLib;
    4949. 

  4949. 

  4950.     err = reg_open_key(HKEY_CLASSES_ROOT, "TypeLib", &htypelib);
    4951. 

  4951.     if(err != ERROR_SUCCESS) {
    4952. 

  4952.         return typelibs;
    4953. 

  4953.     }
    4954. 

  4954.     for(i = 0; ; i++) {
    4955. 

  4955.         guid = reg_enum_key(htypelib, i);
    4956. 

  4956.         if (guid == Qnil)
    4957. 

  4957.             break;
    4958. 

  4958.         err = reg_open_vkey(htypelib, guid, &hguid);
    4959. 

  4959.         if (err != ERROR_SUCCESS)
    4960. 

  4960.             continue;
    4961. 

  4961.         for(j = 0; ; j++) {
    4962. 

  4962.             version = reg_enum_key(hguid, j);
    4963. 

  4963.             if (version == Qnil)
    4964. 

  4964.                 break;
    4965. 

  4965.             if ( (name = reg_get_val2(hguid, StringValuePtr(version))) != Qnil ) {
    4966. 

  4966. 		hr = oletypelib_from_guid(guid, version, &pTypeLib);
    4967. 

  4967. 		if (SUCCEEDED(hr)) {
    4968. 

  4968. 		    typelib = rb_funcall(cWIN32OLE_TYPELIB, rb_intern("allocate"), 0);
    4969. 

  4969. 		    oletypelib_set_member(typelib, pTypeLib);
    4970. 

  4970. 		    rb_ary_push(typelibs, typelib);
    4971. 

  4971. 		}
    4972. 

  4972.             }
    4973. 

  4973.         }
    4974. 

  4974.         RegCloseKey(hguid);
    4975. 

  4975.     }
    4976. 

  4976.     RegCloseKey(htypelib);
    4977. 

  4977.     return typelibs;
    4978. 

  4978. }
    4979. 

  4979. 

  4980. static VALUE
    4981. 

  4981. make_version_str(VALUE major, VALUE minor)
    4982. 

  4982. {
    4983. 

  4983.     VALUE version_str = Qnil;
    4984. 

  4984.     VALUE minor_str = Qnil;
    4985. 

  4985.     if (major == Qnil) {
    4986. 

  4986.         return Qnil;
    4987. 

  4987.     }
    4988. 

  4988.     version_str = rb_String(major);
    4989. 

  4989.     if (minor != Qnil) {
    4990. 

  4990.         minor_str = rb_String(minor);
    4991. 

  4991.         rb_str_cat2(version_str, ".");
    4992. 

  4992.         rb_str_append(version_str, minor_str);
    4993. 

  4993.     }
    4994. 

  4994.     return version_str;
    4995. 

  4995. }
    4996. 

  4996. 

  4997. static VALUE
    4998. 

  4998. oletypelib_search_registry2(VALUE self, VALUE args)
    4999. 

  4999. {
    5000. 

  5000.     HKEY htypelib, hguid, hversion;
    5001. 

  5001.     double fver;
    5002. 

  5002.     DWORD j;
    5003. 

  5003.     LONG err;
    5004. 

  5004.     VALUE found = Qfalse;
    5005. 

  5005.     VALUE tlib;
    5006. 

  5006.     VALUE ver;
    5007. 

  5007.     VALUE version_str;
    5008. 

  5008.     VALUE version = Qnil;
    5009. 

  5009.     VALUE typelib = Qnil;
    5010. 

  5010.     HRESULT hr;
    5011. 

  5011.     ITypeLib *pTypeLib;
    5012. 

  5012. 

  5013.     VALUE guid = rb_ary_entry(args, 0);
    5014. 

  5014.     version_str = make_version_str(rb_ary_entry(args, 1), rb_ary_entry(args, 2));
    5015. 

  5015. 

  5016.     err = reg_open_key(HKEY_CLASSES_ROOT, "TypeLib", &htypelib);
    5017. 

  5017.     if(err != ERROR_SUCCESS) {
    5018. 

  5018.         return Qfalse;
    5019. 

  5019.     }
    5020. 

  5020.     err = reg_open_vkey(htypelib, guid, &hguid);
    5021. 

  5021.     if (err != ERROR_SUCCESS) {
    5022. 

  5022.         RegCloseKey(htypelib);
    5023. 

  5023.         return Qfalse;
    5024. 

  5024.     }
    5025. 

  5025.     if (version_str != Qnil) {
    5026. 

  5026.         err = reg_open_vkey(hguid, version_str, &hversion);
    5027. 

  5027.         if (err == ERROR_SUCCESS) {
    5028. 

  5028.             tlib = reg_get_val(hversion, NULL);
    5029. 

  5029.             if (tlib != Qnil) {
    5030. 

  5030.                 typelib = tlib;
    5031. 

  5031.                 version = version_str;
    5032. 

  5032.             }
    5033. 

  5033.         }
    5034. 

  5034.         RegCloseKey(hversion);
    5035. 

  5035.     } else {
    5036. 

  5036.         fver = 0.0;
    5037. 

  5037. 	    for(j = 0; ;j++) {
    5038. 

  5038. 	        ver = reg_enum_key(hguid, j);
    5039. 

  5039. 	        if (ver == Qnil)
    5040. 

  5040. 	            break;
    5041. 

  5041. 	        err = reg_open_vkey(hguid, ver, &hversion);
    5042. 

  5042. 	        if (err != ERROR_SUCCESS) 
    5043. 

  5043. 	            continue;
    5044. 

  5044. 	        tlib = reg_get_val(hversion, NULL);
    5045. 

  5045. 	        if (tlib == Qnil) {
    5046. 

  5046. 	             RegCloseKey(hversion);
    5047. 

  5047. 	             continue;
    5048. 

  5048. 	        }
    5049. 

  5049. 	        if (fver < atof(StringValuePtr(ver))) {
    5050. 

  5050. 	            fver = atof(StringValuePtr(ver));
    5051. 

  5051. 	            version = ver;
    5052. 

  5052. 	            typelib = tlib;
    5053. 

  5053. 	        }
    5054. 

  5054. 	        RegCloseKey(hversion);
    5055. 

  5055. 	    }
    5056. 

  5056.     }
    5057. 

  5057.     RegCloseKey(hguid);
    5058. 

  5058.     RegCloseKey(htypelib);
    5059. 

  5059.     if (typelib != Qnil) {
    5060. 

  5060. 	hr = oletypelib_from_guid(guid, version, &pTypeLib);
    5061. 

  5061. 	if (SUCCEEDED(hr)) {
    5062. 

  5062. 	    found = Qtrue;
    5063. 

  5063. 	    oletypelib_set_member(self, pTypeLib);
    5064. 

  5064. 	}
    5065. 

  5065.     }
    5066. 

  5066.     return found;
    5067. 

  5067. }
    5068. 

  5068. 

  5069. static VALUE
    5070. 

  5070. oletypelib_search_registry(VALUE self, VALUE typelib)
    5071. 

  5071. {
    5072. 

  5072.     HKEY htypelib, hguid, hversion;
    5073. 

  5073.     DWORD i, j;
    5074. 

  5074.     LONG err;
    5075. 

  5075.     VALUE found = Qfalse;
    5076. 

  5076.     VALUE tlib;
    5077. 

  5077.     VALUE guid;
    5078. 

  5078.     VALUE ver;
    5079. 

  5079.     HRESULT hr;
    5080. 

  5080.     ITypeLib *pTypeLib;
    5081. 

  5081. 

  5082.     err = reg_open_key(HKEY_CLASSES_ROOT, "TypeLib", &htypelib);
    5083. 

  5083.     if(err != ERROR_SUCCESS) {
    5084. 

  5084.         return Qfalse;
    5085. 

  5085.     }
    5086. 

  5086.     for(i = 0; !found; i++) {
    5087. 

  5087.         guid = reg_enum_key(htypelib, i);
    5088. 

  5088.         if (guid == Qnil)
    5089. 

  5089.             break;
    5090. 

  5090.         err = reg_open_vkey(htypelib, guid, &hguid);
    5091. 

  5091.         if (err != ERROR_SUCCESS)
    5092. 

  5092.             continue;
    5093. 

  5093.         for(j = 0; found == Qfalse; j++) {
    5094. 

  5094.             ver = reg_enum_key(hguid, j);
    5095. 

  5095.             if (ver == Qnil)
    5096. 

  5096.                 break;
    5097. 

  5097.             err = reg_open_vkey(hguid, ver, &hversion);
    5098. 

  5098.             if (err != ERROR_SUCCESS) 
    5099. 

  5099.                 continue;
    5100. 

  5100.             tlib = reg_get_val(hversion, NULL);
    5101. 

  5101.             if (tlib == Qnil) {
    5102. 

  5102.                 RegCloseKey(hversion);
    5103. 

  5103.                 continue;
    5104. 

  5104.             }
    5105. 

  5105.             if (rb_str_cmp(typelib, tlib) == 0) {
    5106. 

  5106. 		hr = oletypelib_from_guid(guid, ver, &pTypeLib);
    5107. 

  5107. 		if (SUCCEEDED(hr)) {
    5108. 

  5108. 		    oletypelib_set_member(self, pTypeLib);
    5109. 

  5109. 		    found = Qtrue;
    5110. 

  5110. 		}
    5111. 

  5111.             }
    5112. 

  5112.             RegCloseKey(hversion);
    5113. 

  5113.         }
    5114. 

  5114.         RegCloseKey(hguid);
    5115. 

  5115.     }
    5116. 

  5116.     RegCloseKey(htypelib);
    5117. 

  5117.     return  found;
    5118. 

  5118. }
    5119. 

  5119. 

  5120. static VALUE
    5121. 

  5121. foletypelib_s_allocate(VALUE klass)
    5122. 

  5122. {
    5123. 

  5123.     struct oletypelibdata *poletypelib;
    5124. 

  5124.     VALUE obj;
    5125. 

  5125.     ole_initialize();
    5126. 

  5126.     obj = Data_Make_Struct(klass, struct oletypelibdata, 0, oletypelib_free, poletypelib);
    5127. 

  5127.     poletypelib->pTypeLib = NULL;
    5128. 

  5128.     return obj;
    5129. 

  5129. }
    5130. 

  5130. 

  5131. /*
    5132. 

  5132.  * call-seq:
    5133. 

  5133.  *    WIN32OLE_TYPELIB.new(typelib [, version1, version2]) -> WIN32OLE_TYPELIB object
    5134. 

  5134.  *
    5135. 

  5135.  * Returns a new WIN32OLE_TYPELIB object.
    5136. 

  5136.  *
    5137. 

  5137.  * The first argument <i>typelib</i>  specifies OLE type library name or GUID or 
    5138. 

  5138.  * OLE library file.
    5139. 

  5139.  * The second argument is major version or version of the type library.
    5140. 

  5140.  * The third argument is minor version.
    5141. 

  5141.  * The second argument and third argument are optional.
    5142. 

  5142.  * If the first argument is type library name, then the second and third argument
    5143. 

  5143.  * are ignored.
    5144. 

  5144.  *
    5145. 

  5145.  *     tlib1 = WIN32OLE_TYPELIB.new('Microsoft Excel 9.0 Object Library') 
    5146. 

  5146.  *     tlib2 = WIN32OLE_TYPELIB.new('{00020813-0000-0000-C000-000000000046}')
    5147. 

  5147.  *     tlib3 = WIN32OLE_TYPELIB.new('{00020813-0000-0000-C000-000000000046}', 1.3)
    5148. 

  5148.  *     tlib4 = WIN32OLE_TYPELIB.new('{00020813-0000-0000-C000-000000000046}', 1, 3)
    5149. 

  5149.  *     tlib5 = WIN32OLE_TYPELIB.new("C:\\WINNT\\SYSTEM32\\SHELL32.DLL")
    5150. 

  5150.  *     puts tlib1.name  # -> 'Microsoft Excel 9.0 Object Library'
    5151. 

  5151.  *     puts tlib2.name  # -> 'Microsoft Excel 9.0 Object Library'
    5152. 

  5152.  *     puts tlib3.name  # -> 'Microsoft Excel 9.0 Object Library'
    5153. 

  5153.  *     puts tlib4.name  # -> 'Microsoft Excel 9.0 Object Library'
    5154. 

  5154.  *     puts tlib5.name  # -> 'Microsoft Shell Controls And Automation'
    5155. 

  5155.  *
    5156. 

  5156.  */
    5157. 

  5157. static VALUE
    5158. 

  5158. foletypelib_initialize(VALUE self, VALUE args)
    5159. 

  5159. {
    5160. 

  5160.     VALUE found = Qfalse;
    5161. 

  5161.     VALUE typelib = Qnil;
    5162. 

  5162.     int len = 0;
    5163. 

  5163.     OLECHAR * pbuf;
    5164. 

  5164.     ITypeLib *pTypeLib;
    5165. 

  5165.     HRESULT hr = S_OK;
    5166. 

  5166. 

  5167.     len = RARRAY_LEN(args);
    5168. 

  5168.     if (len < 1 || len > 3) {
    5169. 

  5169.         rb_raise(rb_eArgError, "wrong number of arguments (%d for 1..3)", len);
    5170. 

  5170.     }
    5171. 

  5171. 

  5172.     typelib = rb_ary_entry(args, 0);
    5173. 

  5173. 

  5174.     SafeStringValue(typelib);
    5175. 

  5175. 

  5176.     found = oletypelib_search_registry(self, typelib);
    5177. 

  5177.     if (found == Qfalse) {
    5178. 

  5178.         found = oletypelib_search_registry2(self, args);
    5179. 

  5179.     }
    5180. 

  5180.     if (found == Qfalse) {
    5181. 

  5181.         pbuf = ole_vstr2wc(typelib);
    5182. 

  5182.         hr = LoadTypeLibEx(pbuf, REGKIND_NONE, &pTypeLib);
    5183. 

  5183.         SysFreeString(pbuf);
    5184. 

  5184.         if (SUCCEEDED(hr)) {
    5185. 

  5185. 	    found = Qtrue;
    5186. 

  5186. 	    oletypelib_set_member(self, pTypeLib);
    5187. 

  5187.         }
    5188. 

  5188.     }
    5189. 

  5189. 

  5190.     if (found == Qfalse) {
    5191. 

  5191.         rb_raise(eWIN32OLERuntimeError, "not found type library `%s`",
    5192. 

  5192.                  StringValuePtr(typelib));
    5193. 

  5193.     }
    5194. 

  5194.     return self;
    5195. 

  5195. }
    5196. 

  5196. 

  5197. /*
    5198. 

  5198.  *  call-seq:
    5199. 

  5199.  *     WIN32OLE_TYPELIB#guid -> The guid string.
    5200. 

  5200.  *
    5201. 

  5201.  *  Returns guid string which specifies type library.
    5202. 

  5202.  *
    5203. 

  5203.  *     tlib = WIN32OLE_TYPELIB.new('Microsoft Excel 9.0 Object Library')
    5204. 

  5204.  *     guid = tlib.guid # -> '{00020813-0000-0000-C000-000000000046}'
    5205. 

  5205.  */
    5206. 

  5206. static VALUE
    5207. 

  5207. foletypelib_guid(VALUE self)
    5208. 

  5208. {
    5209. 

  5209.     ITypeLib *pTypeLib;
    5210. 

  5210.     OLECHAR bstr[80];
    5211. 

  5211.     VALUE guid = Qnil;
    5212. 

  5212.     int len;
    5213. 

  5213.     TLIBATTR *pTLibAttr;
    5214. 

  5214. 

  5215.     pTypeLib = oletypelib_get_typelib(self);
    5216. 

  5216.     oletypelib_get_libattr(pTypeLib, &pTLibAttr);
    5217. 

  5217.     len = StringFromGUID2(&pTLibAttr->guid, bstr, sizeof(bstr)/sizeof(OLECHAR));
    5218. 

  5218.     if (len > 3) {
    5219. 

  5219.         guid = ole_wc2vstr(bstr, FALSE);
    5220. 

  5220.     }
    5221. 

  5221.     pTypeLib->lpVtbl->ReleaseTLibAttr(pTypeLib, pTLibAttr);
    5222. 

  5222.     return guid;
    5223. 

  5223. }
    5224. 

  5224. 

  5225. /*
    5226. 

  5226.  *  call-seq:
    5227. 

  5227.  *     WIN32OLE_TYPELIB#name -> The type library name
    5228. 

  5228.  *
    5229. 

  5229.  *  Returns the type library name.
    5230. 

  5230.  *
    5231. 

  5231.  *     tlib = WIN32OLE_TYPELIB.new('Microsoft Excel 9.0 Object Library')
    5232. 

  5232.  *     name = tlib.name # -> 'Microsoft Excel 9.0 Object Library'
    5233. 

  5233.  */
    5234. 

  5234. static VALUE
    5235. 

  5235. foletypelib_name(VALUE self)
    5236. 

  5236. {
    5237. 

  5237.     ITypeLib *pTypeLib;
    5238. 

  5238.     HRESULT hr;
    5239. 

  5239.     BSTR bstr;
    5240. 

  5240.     VALUE name;
    5241. 

  5241.     pTypeLib = oletypelib_get_typelib(self);
    5242. 

  5242.     hr = pTypeLib->lpVtbl->GetDocumentation(pTypeLib, -1,
    5243. 

  5243.                                             NULL, &bstr, NULL, NULL);
    5244. 

  5244.     
    5245. 

  5245.     if (FAILED(hr)) {
    5246. 

  5246.         ole_raise(hr, eWIN32OLERuntimeError, "failed to get name from ITypeLib");
    5247. 

  5247.     }
    5248. 

  5248.     name = WC2VSTR(bstr);
    5249. 

  5249.     return rb_enc_str_new(StringValuePtr(name), strlen(StringValuePtr(name)), cWIN32OLE_enc);
    5250. 

  5250. }
    5251. 

  5251. 

  5252. /*
    5253. 

  5253.  *  call-seq:
    5254. 

  5254.  *     WIN32OLE_TYPELIB#version -> The type library version. 
    5255. 

  5255.  *
    5256. 

  5256.  *  Returns the type library version.
    5257. 

  5257.  *
    5258. 

  5258.  *     tlib = WIN32OLE_TYPELIB.new('Microsoft Excel 9.0 Object Library')
    5259. 

  5259.  *     puts tlib.version #-> 1.3
    5260. 

  5260.  */
    5261. 

  5261. static VALUE
    5262. 

  5262. foletypelib_version(VALUE self)
    5263. 

  5263. {
    5264. 

  5264.     TLIBATTR *pTLibAttr;
    5265. 

  5265.     VALUE major;
    5266. 

  5266.     VALUE minor;
    5267. 

  5267.     ITypeLib *pTypeLib;
    5268. 

  5268. 

  5269.     pTypeLib = oletypelib_get_typelib(self);
    5270. 

  5270.     oletypelib_get_libattr(pTypeLib, &pTLibAttr);
    5271. 

  5271.     major = INT2NUM(pTLibAttr->wMajorVerNum);
    5272. 

  5272.     minor = INT2NUM(pTLibAttr->wMinorVerNum);
    5273. 

  5273.     pTypeLib->lpVtbl->ReleaseTLibAttr(pTypeLib, pTLibAttr);
    5274. 

  5274.     return rb_Float(make_version_str(major, minor));
    5275. 

  5275. }
    5276. 

  5276. 

  5277. /*
    5278. 

  5278.  *  call-seq:
    5279. 

  5279.  *     WIN32OLE_TYPELIB#major_version -> The type library major version. 
    5280. 

  5280.  *
    5281. 

  5281.  *  Returns the type library major version.
    5282. 

  5282.  *
    5283. 

  5283.  *     tlib = WIN32OLE_TYPELIB.new('Microsoft Excel 9.0 Object Library')
    5284. 

  5284.  *     puts tlib.major_version # -> 1
    5285. 

  5285.  */
    5286. 

  5286. static VALUE
    5287. 

  5287. foletypelib_major_version(VALUE self)
    5288. 

  5288. {
    5289. 

  5289.     TLIBATTR *pTLibAttr;
    5290. 

  5290.     VALUE major;
    5291. 

  5291.     ITypeLib *pTypeLib;
    5292. 

  5292.     pTypeLib = oletypelib_get_typelib(self);
    5293. 

  5293.     oletypelib_get_libattr(pTypeLib, &pTLibAttr);
    5294. 

  5294. 

  5295.     major =  INT2NUM(pTLibAttr->wMajorVerNum);
    5296. 

  5296.     pTypeLib->lpVtbl->ReleaseTLibAttr(pTypeLib, pTLibAttr);
    5297. 

  5297.     return major;
    5298. 

  5298. }
    5299. 

  5299. 

  5300. /*
    5301. 

  5301.  *  call-seq:
    5302. 

  5302.  *     WIN32OLE_TYPELIB#minor_version -> The type library minor version. 
    5303. 

  5303.  *
    5304. 

  5304.  *  Returns the type library minor version.
    5305. 

  5305.  *
    5306. 

  5306.  *     tlib = WIN32OLE_TYPELIB.new('Microsoft Excel 9.0 Object Library')
    5307. 

  5307.  *     puts tlib.minor_version # -> 3
    5308. 

  5308.  */
    5309. 

  5309. static VALUE
    5310. 

  5310. foletypelib_minor_version(VALUE self)
    5311. 

  5311. {
    5312. 

  5312.     TLIBATTR *pTLibAttr;
    5313. 

  5313.     VALUE minor;
    5314. 

  5314.     ITypeLib *pTypeLib;
    5315. 

  5315.     pTypeLib = oletypelib_get_typelib(self);
    5316. 

  5316.     oletypelib_get_libattr(pTypeLib, &pTLibAttr);
    5317. 

  5317.     minor =  INT2NUM(pTLibAttr->wMinorVerNum);
    5318. 

  5318.     pTypeLib->lpVtbl->ReleaseTLibAttr(pTypeLib, pTLibAttr);
    5319. 

  5319.     return minor;
    5320. 

  5320. }
    5321. 

  5321. 

  5322. static VALUE
    5323. 

  5323. oletypelib_path(VALUE guid, VALUE version)
    5324. 

  5324. {
    5325. 

  5325.     int k;
    5326. 

  5326.     LONG err;
    5327. 

  5327.     HKEY hkey;
    5328. 

  5328.     HKEY hlang;
    5329. 

  5329.     VALUE lang;
    5330. 

  5330.     VALUE path = Qnil;
    5331. 

  5331. 

  5332.     VALUE key = rb_str_new2("TypeLib\\");
    5333. 

  5333.     rb_str_concat(key, guid);
    5334. 

  5334.     rb_str_cat2(key, "\\");
    5335. 

  5335.     rb_str_concat(key, version);
    5336. 

  5336. 

  5337.     err = reg_open_vkey(HKEY_CLASSES_ROOT, key, &hkey);
    5338. 

  5338.     if (err != ERROR_SUCCESS) {
    5339. 

  5339.         return Qnil;
    5340. 

  5340.     }
    5341. 

  5341.     for(k = 0; path == Qnil; k++) {
    5342. 

  5342.         lang = reg_enum_key(hkey, k);
    5343. 

  5343.         if (lang == Qnil)
    5344. 

  5344.             break;
    5345. 

  5345.         err = reg_open_vkey(hkey, lang, &hlang);
    5346. 

  5346.         if (err == ERROR_SUCCESS) {
    5347. 

  5347.             path = reg_get_typelib_file_path(hlang);
    5348. 

  5348.             RegCloseKey(hlang);
    5349. 

  5349.         }
    5350. 

  5350.     }
    5351. 

  5351.     RegCloseKey(hkey);
    5352. 

  5352.     return path;
    5353. 

  5353. }
    5354. 

  5354. 

  5355. static HRESULT 
    5356. 

  5356. oletypelib_from_guid(VALUE guid, VALUE version, ITypeLib **ppTypeLib)
    5357. 

  5357. {
    5358. 

  5358.     VALUE path;
    5359. 

  5359.     OLECHAR *pBuf;
    5360. 

  5360.     HRESULT hr;
    5361. 

  5361.     path = oletypelib_path(guid, version);
    5362. 

  5362.     if (path == Qnil) {
    5363. 

  5363. 	return E_UNEXPECTED;
    5364. 

  5364.     }
    5365. 

  5365.     pBuf = ole_vstr2wc(path);
    5366. 

  5366.     hr = LoadTypeLibEx(pBuf, REGKIND_NONE, ppTypeLib);
    5367. 

  5367.     SysFreeString(pBuf);
    5368. 

  5368.     return hr;
    5369. 

  5369. }
    5370. 

  5370. 

  5371. /*
    5372. 

  5372.  *  call-seq:
    5373. 

  5373.  *     WIN32OLE_TYPELIB#path -> The type library file path. 
    5374. 

  5374.  *
    5375. 

  5375.  *  Returns the type library file path.
    5376. 

  5376.  *
    5377. 

  5377.  *     tlib = WIN32OLE_TYPELIB.new('Microsoft Excel 9.0 Object Library')
    5378. 

  5378.  *     puts tlib.path #-> 'C:\...\EXCEL9.OLB'
    5379. 

  5379.  */
    5380. 

  5380. static VALUE
    5381. 

  5381. foletypelib_path(VALUE self)
    5382. 

  5382. {
    5383. 

  5383.     TLIBATTR *pTLibAttr;
    5384. 

  5384.     HRESULT hr = S_OK; 
    5385. 

  5385.     BSTR bstr;
    5386. 

  5386.     LCID lcid = cWIN32OLE_lcid;
    5387. 

  5387.     VALUE path;
    5388. 

  5388.     ITypeLib *pTypeLib;
    5389. 

  5389. 

  5390.     pTypeLib = oletypelib_get_typelib(self);
    5391. 

  5391.     oletypelib_get_libattr(pTypeLib, &pTLibAttr);
    5392. 

  5392.     hr = QueryPathOfRegTypeLib(&pTLibAttr->guid, 
    5393. 

  5393. 	                       pTLibAttr->wMajorVerNum,
    5394. 

  5394. 			       pTLibAttr->wMinorVerNum,
    5395. 

  5395. 			       lcid,
    5396. 

  5396. 			       &bstr);
    5397. 

  5397.     if (FAILED(hr)) {
    5398. 

  5398. 	pTypeLib->lpVtbl->ReleaseTLibAttr(pTypeLib, pTLibAttr);
    5399. 

  5399. 	ole_raise(hr, eWIN32OLERuntimeError, "failed to QueryPathOfRegTypeTypeLib");
    5400. 

  5400.     }
    5401. 

  5401. 

  5402.     pTypeLib->lpVtbl->ReleaseTLibAttr(pTypeLib, pTLibAttr);
    5403. 

  5403.     path = WC2VSTR(bstr);
    5404. 

  5404.     return rb_enc_str_new(StringValuePtr(path), strlen(StringValuePtr(path)), cWIN32OLE_enc);
    5405. 

  5405. }
    5406. 

  5406. 

  5407. /*
    5408. 

  5408.  *  call-seq:
    5409. 

  5409.  *     WIN32OLE_TYPELIB#visible? 
    5410. 

  5410.  *
    5411. 

  5411.  *  Returns true if the type library information is not hidden.
    5412. 

  5412.  *  If wLibFlags of TLIBATTR is 0 or LIBFLAG_FRESTRICTED or LIBFLAG_FHIDDEN,
    5413. 

  5413.  *  the method returns false, otherwise, returns true.
    5414. 

  5414.  *  If the method fails to access the TLIBATTR information, then
    5415. 

  5415.  *  WIN32OLERuntimeError is raised.
    5416. 

  5416.  *
    5417. 

  5417.  *     tlib = WIN32OLE_TYPELIB.new('Microsoft Excel 9.0 Object Library')
    5418. 

  5418.  *     tlib.visible? # => true
    5419. 

  5419.  */
    5420. 

  5420. static VALUE
    5421. 

  5421. foletypelib_visible(VALUE self)
    5422. 

  5422. {
    5423. 

  5423.     ITypeLib *pTypeLib = NULL;
    5424. 

  5424.     VALUE visible = Qtrue;
    5425. 

  5425.     TLIBATTR *pTLibAttr;
    5426. 

  5426. 

  5427.     pTypeLib = oletypelib_get_typelib(self);
    5428. 

  5428.     oletypelib_get_libattr(pTypeLib, &pTLibAttr);
    5429. 

  5429. 

  5430.     if ((pTLibAttr->wLibFlags == 0) ||
    5431. 

  5431.         (pTLibAttr->wLibFlags & LIBFLAG_FRESTRICTED) ||
    5432. 

  5432.         (pTLibAttr->wLibFlags & LIBFLAG_FHIDDEN)) {
    5433. 

  5433.         visible = Qfalse;
    5434. 

  5434.     }
    5435. 

  5435.     pTypeLib->lpVtbl->ReleaseTLibAttr(pTypeLib, pTLibAttr);
    5436. 

  5436.     return visible;
    5437. 

  5437. }
    5438. 

  5438. 

  5439. /*
    5440. 

  5440.  *  call-seq:
    5441. 

  5441.  *     WIN32OLE_TYPELIB#library_name 
    5442. 

  5442.  *
    5443. 

  5443.  *  Returns library name.
    5444. 

  5444.  *  If the method fails to access library name, WIN32OLERuntimeError is raised.
    5445. 

  5445.  *
    5446. 

  5446.  *     tlib = WIN32OLE_TYPELIB.new('Microsoft Excel 9.0 Object Library')
    5447. 

  5447.  *     tlib.library_name # => Excel
    5448. 

  5448.  */
    5449. 

  5449. static VALUE
    5450. 

  5450. foletypelib_library_name(VALUE self)
    5451. 

  5451. {
    5452. 

  5452.     HRESULT hr;
    5453. 

  5453.     ITypeLib *pTypeLib = NULL;
    5454. 

  5454.     VALUE libname = Qnil;
    5455. 

  5455.     BSTR bstr;
    5456. 

  5456. 

  5457.     pTypeLib = oletypelib_get_typelib(self);
    5458. 

  5458.     hr = pTypeLib->lpVtbl->GetDocumentation(pTypeLib, -1,
    5459. 

  5459.                                             &bstr, NULL, NULL, NULL);
    5460. 

  5460.     if (FAILED(hr)) {
    5461. 

  5461.         ole_raise(hr, eWIN32OLERuntimeError, "failed to get library name");
    5462. 

  5462.     }
    5463. 

  5463.     libname = WC2VSTR(bstr);
    5464. 

  5464.     return libname;
    5465. 

  5465. }
    5466. 

  5466. 

  5467. 

  5468. /*
    5469. 

  5469.  *  call-seq:
    5470. 

  5470.  *     WIN32OLE_TYPELIB#ole_types -> The array of WIN32OLE_TYPE object included the type library.
    5471. 

  5471.  *
    5472. 

  5472.  *  Returns the type library file path.
    5473. 

  5473.  *
    5474. 

  5474.  *     tlib = WIN32OLE_TYPELIB.new('Microsoft Excel 9.0 Object Library')
    5475. 

  5475.  *     classes = tlib.ole_types.collect{|k| k.name} # -> ['AddIn', 'AddIns' ...] 
    5476. 

  5476.  */
    5477. 

  5477. static VALUE
    5478. 

  5478. foletypelib_ole_types(VALUE self)
    5479. 

  5479. {
    5480. 

  5480.     ITypeLib *pTypeLib = NULL;
    5481. 

  5481.     VALUE classes = rb_ary_new();
    5482. 

  5482.     pTypeLib = oletypelib_get_typelib(self);
    5483. 

  5483.     ole_types_from_typelib(pTypeLib, classes);
    5484. 

  5484.     return classes;
    5485. 

  5485. }
    5486. 

  5486. 

  5487. /*
    5488. 

  5488.  *  call-seq:
    5489. 

  5489.  *     WIN32OLE_TYPELIB#inspect -> String
    5490. 

  5490.  *
    5491. 

  5491.  *  Returns the type library name with class name.
    5492. 

  5492.  *
    5493. 

  5493.  *     tlib = WIN32OLE_TYPELIB.new('Microsoft Excel 9.0 Object Library')
    5494. 

  5494.  *     tlib.inspect # => "<#WIN32OLE_TYPELIB:Microsoft Excel 9.0 Object Library>"
    5495. 

  5495.  */
    5496. 

  5496. static VALUE
    5497. 

  5497. foletypelib_inspect(VALUE self)
    5498. 

  5498. {
    5499. 

  5499.     return default_inspect(self, "WIN32OLE_TYPELIB");
    5500. 

  5500. }
    5501. 

  5501. 

  5502. /*
    5503. 

  5503.  * Document-class: WIN32OLE_TYPE
    5504. 

  5504.  *
    5505. 

  5505.  *   <code>WIN32OLE_TYPE</code> objects represent OLE type libarary information.
    5506. 

  5506.  */
    5507. 

  5507. 

  5508. /*
    5509. 

  5509.  *  call-seq:
    5510. 

  5510.  *     WIN32OLE_TYPE.new(typelib, ole_class) -> WIN32OLE_TYPE object
    5511. 

  5511.  *
    5512. 

  5512.  *  Returns a new WIN32OLE_TYPE object.
    5513. 

  5513.  *  The first argument <i>typelib</i> specifies OLE type library name.
    5514. 

  5514.  *  The second argument specifies OLE class name.
    5515. 

  5515.  *
    5516. 

  5516.  *      WIN32OLE_TYPE.new('Microsoft Excel 9.0 Object Library', 'Application') 
    5517. 

  5517.  *          # => WIN32OLE_TYPE object of Application class of Excel. 
    5518. 

  5518.  */
    5519. 

  5519. static VALUE
    5520. 

  5520. foletype_initialize(VALUE self, VALUE typelib, VALUE oleclass)
    5521. 

  5521. {
    5522. 

  5522.     VALUE file;
    5523. 

  5523.     OLECHAR * pbuf;
    5524. 

  5524.     ITypeLib *pTypeLib;
    5525. 

  5525.     HRESULT hr;
    5526. 

  5526. 

  5527.     SafeStringValue(oleclass);
    5528. 

  5528.     SafeStringValue(typelib);
    5529. 

  5529.     file = typelib_file(typelib);
    5530. 

  5530.     if (file == Qnil) {
    5531. 

  5531.         file = typelib;
    5532. 

  5532.     }
    5533. 

  5533.     pbuf = ole_vstr2wc(file);
    5534. 

  5534.     hr = LoadTypeLibEx(pbuf, REGKIND_NONE, &pTypeLib);
    5535. 

  5535.     if (FAILED(hr))
    5536. 

  5536.         ole_raise(hr, eWIN32OLERuntimeError, "failed to LoadTypeLibEx");
    5537. 

  5537.     SysFreeString(pbuf);
    5538. 

  5538.     if (oleclass_from_typelib(self, pTypeLib, oleclass) == Qfalse) {
    5539. 

  5539.         OLE_RELEASE(pTypeLib);
    5540. 

  5540.         rb_raise(eWIN32OLERuntimeError, "not found `%s` in `%s`",
    5541. 

  5541.                  StringValuePtr(oleclass), StringValuePtr(typelib));
    5542. 

  5542.     }
    5543. 

  5543.     OLE_RELEASE(pTypeLib);
    5544. 

  5544.     return self;
    5545. 

  5545. }
    5546. 

  5546. 

  5547. /*
    5548. 

  5548.  * call-seq:
    5549. 

  5549.  *    WIN32OLE_TYPE#name #=> OLE type name
    5550. 

  5550.  *
    5551. 

  5551.  * Returns OLE type name.
    5552. 

  5552.  *    tobj = WIN32OLE_TYPE.new('Microsoft Excel 9.0 Object Library', 'Application') 
    5553. 

  5553.  *    puts tobj.name  # => Application
    5554. 

  5554.  */
    5555. 

  5555. static VALUE
    5556. 

  5556. foletype_name(VALUE self)
    5557. 

  5557. {
    5558. 

  5558.     return rb_ivar_get(self, rb_intern("name"));
    5559. 

  5559. }
    5560. 

  5560. 

  5561. static VALUE
    5562. 

  5562. ole_ole_type(ITypeInfo *pTypeInfo)
    5563. 

  5563. {
    5564. 

  5564.     HRESULT hr;
    5565. 

  5565.     TYPEATTR *pTypeAttr;
    5566. 

  5566.     VALUE type = Qnil;
    5567. 

  5567.     hr = OLE_GET_TYPEATTR(pTypeInfo, &pTypeAttr);
    5568. 

  5568.     if(FAILED(hr)){
    5569. 

  5569.         return type;
    5570. 

  5570.     }
    5571. 

  5571.     switch(pTypeAttr->typekind) {
    5572. 

  5572.     case TKIND_ENUM:
    5573. 

  5573.         type = rb_str_new2("Enum");
    5574. 

  5574.         break;
    5575. 

  5575.     case TKIND_RECORD:
    5576. 

  5576.         type = rb_str_new2("Record");
    5577. 

  5577.         break;
    5578. 

  5578.     case TKIND_MODULE:
    5579. 

  5579.         type = rb_str_new2("Module");
    5580. 

  5580.         break;
    5581. 

  5581.     case TKIND_INTERFACE:
    5582. 

  5582.         type = rb_str_new2("Interface");
    5583. 

  5583.         break;
    5584. 

  5584.     case TKIND_DISPATCH:
    5585. 

  5585.         type = rb_str_new2("Dispatch");
    5586. 

  5586.         break;
    5587. 

  5587.     case TKIND_COCLASS:
    5588. 

  5588.         type = rb_str_new2("Class");
    5589. 

  5589.         break;
    5590. 

  5590.     case TKIND_ALIAS:
    5591. 

  5591.         type = rb_str_new2("Alias");
    5592. 

  5592.         break;
    5593. 

  5593.     case TKIND_UNION:
    5594. 

  5594.         type = rb_str_new2("Union");
    5595. 

  5595.         break;
    5596. 

  5596.     case TKIND_MAX:
    5597. 

  5597.         type = rb_str_new2("Max");
    5598. 

  5598.         break;
    5599. 

  5599.     default:
    5600. 

  5600.         type = Qnil;
    5601. 

  5601.         break;
    5602. 

  5602.     }
    5603. 

  5603.     OLE_RELEASE_TYPEATTR(pTypeInfo, pTypeAttr);
    5604. 

  5604.     return type;
    5605. 

  5605. }
    5606. 

  5606. 

  5607. /*
    5608. 

  5608.  *  call-seq:
    5609. 

  5609.  *     WIN32OLE_TYPE#ole_type #=> OLE type string.
    5610. 

  5610.  * 
    5611. 

  5611.  *  returns type of OLE class.
    5612. 

  5612.  *    tobj = WIN32OLE_TYPE.new('Microsoft Excel 9.0 Object Library', 'Application') 
    5613. 

  5613.  *    puts tobj.ole_type  # => Class
    5614. 

  5614.  */
    5615. 

  5615. static VALUE
    5616. 

  5616. foletype_ole_type(VALUE self)
    5617. 

  5617. {
    5618. 

  5618.     struct oletypedata *ptype;
    5619. 

  5619.     Data_Get_Struct(self, struct oletypedata, ptype);
    5620. 

  5620.     return ole_ole_type(ptype->pTypeInfo);
    5621. 

  5621. }
    5622. 

  5622. 

  5623. static VALUE
    5624. 

  5624. ole_type_guid(ITypeInfo *pTypeInfo)
    5625. 

  5625. {
    5626. 

  5626.     HRESULT hr;
    5627. 

  5627.     TYPEATTR *pTypeAttr;
    5628. 

  5628.     int len;
    5629. 

  5629.     OLECHAR bstr[80];
    5630. 

  5630.     VALUE guid = Qnil;
    5631. 

  5631.     hr = OLE_GET_TYPEATTR(pTypeInfo, &pTypeAttr);
    5632. 

  5632.     if (FAILED(hr)) 
    5633. 

  5633.         return guid;
    5634. 

  5634.     len = StringFromGUID2(&pTypeAttr->guid, bstr, sizeof(bstr)/sizeof(OLECHAR));
    5635. 

  5635.     if (len > 3) {
    5636. 

  5636.         guid = ole_wc2vstr(bstr, FALSE);
    5637. 

  5637.     }
    5638. 

  5638.     OLE_RELEASE_TYPEATTR(pTypeInfo, pTypeAttr);
    5639. 

  5639.     return guid;
    5640. 

  5640. }
    5641. 

  5641. 

  5642. /*
    5643. 

  5643.  *  call-seq:
    5644. 

  5644.  *     WIN32OLE_TYPE#guid  #=> GUID
    5645. 

  5645.  * 
    5646. 

  5646.  *  Returns GUID.
    5647. 

  5647.  *    tobj = WIN32OLE_TYPE.new('Microsoft Excel 9.0 Object Library', 'Application') 
    5648. 

  5648.  *    puts tobj.guid  # => {00024500-0000-0000-C000-000000000046}
    5649. 

  5649.  */
    5650. 

  5650. static VALUE
    5651. 

  5651. foletype_guid(VALUE self)
    5652. 

  5652. {
    5653. 

  5653.     struct oletypedata *ptype;
    5654. 

  5654.     Data_Get_Struct(self, struct oletypedata, ptype);
    5655. 

  5655.     return ole_type_guid(ptype->pTypeInfo);
    5656. 

  5656. }
    5657. 

  5657. 

  5658. static VALUE
    5659. 

  5659. ole_type_progid(ITypeInfo *pTypeInfo)
    5660. 

  5660. {
    5661. 

  5661.     HRESULT hr;
    5662. 

  5662.     TYPEATTR *pTypeAttr;
    5663. 

  5663.     OLECHAR *pbuf;
    5664. 

  5664.     VALUE progid = Qnil;
    5665. 

  5665.     hr = OLE_GET_TYPEATTR(pTypeInfo, &pTypeAttr);
    5666. 

  5666.     if (FAILED(hr)) 
    5667. 

  5667.         return progid;
    5668. 

  5668.     hr = ProgIDFromCLSID(&pTypeAttr->guid, &pbuf);
    5669. 

  5669.     if (SUCCEEDED(hr)) {
    5670. 

  5670.         progid = ole_wc2vstr(pbuf, FALSE);
    5671. 

  5671.         CoTaskMemFree(pbuf);
    5672. 

  5672.     }
    5673. 

  5673.     OLE_RELEASE_TYPEATTR(pTypeInfo, pTypeAttr);
    5674. 

  5674.     return progid;
    5675. 

  5675. }
    5676. 

  5676. 

  5677. /*
    5678. 

  5678.  * call-seq:
    5679. 

  5679.  *    WIN32OLE_TYPE#progid  #=> ProgID
    5680. 

  5680.  * 
    5681. 

  5681.  * Returns ProgID if it exists. If not found, then returns nil.
    5682. 

  5682.  *    tobj = WIN32OLE_TYPE.new('Microsoft Excel 9.0 Object Library', 'Application')
    5683. 

  5683.  *    puts tobj.progid  # =>   Excel.Application.9
    5684. 

  5684.  */
    5685. 

  5685. static VALUE
    5686. 

  5686. foletype_progid(VALUE self)
    5687. 

  5687. {
    5688. 

  5688.     struct oletypedata *ptype;
    5689. 

  5689.     Data_Get_Struct(self, struct oletypedata, ptype);
    5690. 

  5690.     return ole_type_progid(ptype->pTypeInfo);
    5691. 

  5691. }
    5692. 

  5692. 

  5693. 

  5694. static VALUE
    5695. 

  5695. ole_type_visible(ITypeInfo *pTypeInfo)
    5696. 

  5696. {
    5697. 

  5697.     HRESULT hr;
    5698. 

  5698.     TYPEATTR *pTypeAttr;
    5699. 

  5699.     VALUE visible;
    5700. 

  5700.     hr = OLE_GET_TYPEATTR(pTypeInfo, &pTypeAttr);
    5701. 

  5701.     if (FAILED(hr)) 
    5702. 

  5702.         return Qtrue;
    5703. 

  5703.     if (pTypeAttr->wTypeFlags & (TYPEFLAG_FHIDDEN | TYPEFLAG_FRESTRICTED)) {
    5704. 

  5704.         visible = Qfalse;
    5705. 

  5705.     } else {
    5706. 

  5706.         visible = Qtrue;
    5707. 

  5707.     }
    5708. 

  5708.     OLE_RELEASE_TYPEATTR(pTypeInfo, pTypeAttr);
    5709. 

  5709.     return visible;
    5710. 

  5710. }
    5711. 

  5711. 

  5712. /*
    5713. 

  5713.  *  call-seq:
    5714. 

  5714.  *    WIN32OLE_TYPE#visible  #=> true or false
    5715. 

  5715.  * 
    5716. 

  5716.  *  Returns true if the OLE class is public.
    5717. 

  5717.  *    tobj = WIN32OLE_TYPE.new('Microsoft Excel 9.0 Object Library', 'Application')
    5718. 

  5718.  *    puts tobj.visible  # => true
    5719. 

  5719.  */
    5720. 

  5720. static VALUE
    5721. 

  5721. foletype_visible(VALUE self)
    5722. 

  5722. {
    5723. 

  5723.     struct oletypedata *ptype;
    5724. 

  5724.     Data_Get_Struct(self, struct oletypedata, ptype);
    5725. 

  5725.     return ole_type_visible(ptype->pTypeInfo);
    5726. 

  5726. }
    5727. 

  5727. 

  5728. static VALUE
    5729. 

  5729. ole_type_major_version(ITypeInfo *pTypeInfo)
    5730. 

  5730. {
    5731. 

  5731.     VALUE ver;
    5732. 

  5732.     TYPEATTR *pTypeAttr;
    5733. 

  5733.     HRESULT hr;
    5734. 

  5734.     hr = OLE_GET_TYPEATTR(pTypeInfo, &pTypeAttr);
    5735. 

  5735.     if (FAILED(hr))
    5736. 

  5736.         ole_raise(hr, eWIN32OLERuntimeError, "failed to GetTypeAttr");
    5737. 

  5737.     ver = INT2FIX(pTypeAttr->wMajorVerNum);
    5738. 

  5738.     OLE_RELEASE_TYPEATTR(pTypeInfo, pTypeAttr);
    5739. 

  5739.     return ver;
    5740. 

  5740. }
    5741. 

  5741. 

  5742. /*
    5743. 

  5743.  *  call-seq:
    5744. 

  5744.  *     WIN32OLE_TYPE#major_version
    5745. 

  5745.  * 
    5746. 

  5746.  *  Returns major version.
    5747. 

  5747.  *     tobj = WIN32OLE_TYPE.new('Microsoft Word 10.0 Object Library', 'Documents')
    5748. 

  5748.  *     puts tobj.major_version # => 8
    5749. 

  5749.  */
    5750. 

  5750. static VALUE
    5751. 

  5751. foletype_major_version(VALUE self)
    5752. 

  5752. {
    5753. 

  5753.     struct oletypedata *ptype;
    5754. 

  5754.     Data_Get_Struct(self, struct oletypedata, ptype);
    5755. 

  5755.     return ole_type_major_version(ptype->pTypeInfo);
    5756. 

  5756. }
    5757. 

  5757. 

  5758. static VALUE
    5759. 

  5759. ole_type_minor_version(ITypeInfo *pTypeInfo)
    5760. 

  5760. {
    5761. 

  5761.     VALUE ver;
    5762. 

  5762.     TYPEATTR *pTypeAttr;
    5763. 

  5763.     HRESULT hr;
    5764. 

  5764.     hr = OLE_GET_TYPEATTR(pTypeInfo, &pTypeAttr);
    5765. 

  5765.     if (FAILED(hr))
    5766. 

  5766.         ole_raise(hr, eWIN32OLERuntimeError, "failed to GetTypeAttr");
    5767. 

  5767.     ver = INT2FIX(pTypeAttr->wMinorVerNum);
    5768. 

  5768.     OLE_RELEASE_TYPEATTR(pTypeInfo, pTypeAttr);
    5769. 

  5769.     return ver;
    5770. 

  5770. }
    5771. 

  5771. 

  5772. /*
    5773. 

  5773.  *  call-seq:
    5774. 

  5774.  *    WIN32OLE_TYPE#minor_version #=> OLE minor version
    5775. 

  5775.  * 
    5776. 

  5776.  *  Returns minor version.
    5777. 

  5777.  *     tobj = WIN32OLE_TYPE.new('Microsoft Word 10.0 Object Library', 'Documents')
    5778. 

  5778.  *     puts tobj.minor_version # => 2
    5779. 

  5779.  */
    5780. 

  5780. static VALUE
    5781. 

  5781. foletype_minor_version(VALUE self)
    5782. 

  5782. {
    5783. 

  5783.     struct oletypedata *ptype;
    5784. 

  5784.     Data_Get_Struct(self, struct oletypedata, ptype);
    5785. 

  5785.     return ole_type_minor_version(ptype->pTypeInfo);
    5786. 

  5786. }
    5787. 

  5787. 

  5788. static VALUE
    5789. 

  5789. ole_type_typekind(ITypeInfo *pTypeInfo)
    5790. 

  5790. {
    5791. 

  5791.     VALUE typekind;
    5792. 

  5792.     TYPEATTR *pTypeAttr;
    5793. 

  5793.     HRESULT hr;
    5794. 

  5794.     hr = OLE_GET_TYPEATTR(pTypeInfo, &pTypeAttr);
    5795. 

  5795.     if (FAILED(hr))
    5796. 

  5796.         ole_raise(hr, eWIN32OLERuntimeError, "failed to GetTypeAttr");
    5797. 

  5797.     typekind = INT2FIX(pTypeAttr->typekind);
    5798. 

  5798.     OLE_RELEASE_TYPEATTR(pTypeInfo, pTypeAttr);
    5799. 

  5799.     return typekind;
    5800. 

  5800. }
    5801. 

  5801. 

  5802. /*
    5803. 

  5803.  *  call-seq:
    5804. 

  5804.  *    WIN32OLE_TYPE#typekind #=> number of type.
    5805. 

  5805.  * 
    5806. 

  5806.  *  Returns number which represents type.
    5807. 

  5807.  *    tobj = WIN32OLE_TYPE.new('Microsoft Word 10.0 Object Library', 'Documents')
    5808. 

  5808.  *    puts tobj.typekind # => 4
    5809. 

  5809.  *
    5810. 

  5810.  */
    5811. 

  5811. static VALUE 
    5812. 

  5812. foletype_typekind(VALUE self)
    5813. 

  5813. {
    5814. 

  5814.     struct oletypedata *ptype;
    5815. 

  5815.     Data_Get_Struct(self, struct oletypedata, ptype);
    5816. 

  5816.     return ole_type_typekind(ptype->pTypeInfo);
    5817. 

  5817. }
    5818. 

  5818. 

  5819. static VALUE
    5820. 

  5820. ole_type_helpstring(ITypeInfo *pTypeInfo)
    5821. 

  5821. {
    5822. 

  5822.     HRESULT hr;
    5823. 

  5823.     BSTR bhelpstr;
    5824. 

  5824.     hr = ole_docinfo_from_type(pTypeInfo, NULL, &bhelpstr, NULL, NULL);
    5825. 

  5825.     if(FAILED(hr)) {
    5826. 

  5826.         return Qnil;
    5827. 

  5827.     }
    5828. 

  5828.     return WC2VSTR(bhelpstr);
    5829. 

  5829. }
    5830. 

  5830. 

  5831. /*
    5832. 

  5832.  *  call-seq:
    5833. 

  5833.  *    WIN32OLE_TYPE#helpstring #=> help string.
    5834. 

  5834.  * 
    5835. 

  5835.  *  Returns help string.
    5836. 

  5836.  *    tobj = WIN32OLE_TYPE.new('Microsoft Internet Controls', 'IWebBrowser')
    5837. 

  5837.  *    puts tobj.helpstring # => Web Browser interface
    5838. 

  5838.  */
    5839. 

  5839. static VALUE 
    5840. 

  5840. foletype_helpstring(VALUE self)
    5841. 

  5841. {
    5842. 

  5842.     struct oletypedata *ptype;
    5843. 

  5843.     Data_Get_Struct(self, struct oletypedata, ptype);
    5844. 

  5844.     return ole_type_helpstring(ptype->pTypeInfo);
    5845. 

  5845. }
    5846. 

  5846. 

  5847. static VALUE
    5848. 

  5848. ole_type_src_type(ITypeInfo *pTypeInfo)
    5849. 

  5849. {
    5850. 

  5850.     HRESULT hr;
    5851. 

  5851.     TYPEATTR *pTypeAttr;
    5852. 

  5852.     VALUE alias = Qnil;
    5853. 

  5853.     hr = OLE_GET_TYPEATTR(pTypeInfo, &pTypeAttr);
    5854. 

  5854.     if (FAILED(hr))
    5855. 

  5855.         return alias;
    5856. 

  5856.     if(pTypeAttr->typekind != TKIND_ALIAS) {
    5857. 

  5857.         OLE_RELEASE_TYPEATTR(pTypeInfo, pTypeAttr);
    5858. 

  5858.         return alias;
    5859. 

  5859.     }
    5860. 

  5860.     alias = ole_typedesc2val(pTypeInfo, &(pTypeAttr->tdescAlias), Qnil);
    5861. 

  5861.     OLE_RELEASE_TYPEATTR(pTypeInfo, pTypeAttr);
    5862. 

  5862.     return alias;
    5863. 

  5863. }
    5864. 

  5864. 

  5865. /*
    5866. 

  5866.  *  call-seq:
    5867. 

  5867.  *     WIN32OLE_TYPE#src_type #=> OLE source class
    5868. 

  5868.  * 
    5869. 

  5869.  *  Returns source class when the OLE class is 'Alias'.
    5870. 

  5870.  *     tobj =  WIN32OLE_TYPE.new('Microsoft Office 9.0 Object Library', 'MsoRGBType')
    5871. 

  5871.  *     puts tobj.src_type # => I4
    5872. 

  5872.  *
    5873. 

  5873.  */
    5874. 

  5874. static VALUE
    5875. 

  5875. foletype_src_type(VALUE self)
    5876. 

  5876. {
    5877. 

  5877.     struct oletypedata *ptype;
    5878. 

  5878.     Data_Get_Struct(self, struct oletypedata, ptype);
    5879. 

  5879.     return ole_type_src_type(ptype->pTypeInfo);
    5880. 

  5880. }
    5881. 

  5881. 

  5882. static VALUE
    5883. 

  5883. ole_type_helpfile(ITypeInfo *pTypeInfo)
    5884. 

  5884. {
    5885. 

  5885.     HRESULT hr;
    5886. 

  5886.     BSTR bhelpfile;
    5887. 

  5887.     hr = ole_docinfo_from_type(pTypeInfo, NULL, NULL, NULL, &bhelpfile);
    5888. 

  5888.     if(FAILED(hr)) {
    5889. 

  5889.         return Qnil;
    5890. 

  5890.     }
    5891. 

  5891.     return WC2VSTR(bhelpfile);
    5892. 

  5892. }
    5893. 

  5893. 

  5894. /*
    5895. 

  5895.  *  call-seq:
    5896. 

  5896.  *     WIN32OLE_TYPE#helpfile
    5897. 

  5897.  * 
    5898. 

  5898.  *  Returns helpfile path. If helpfile is not found, then returns nil.
    5899. 

  5899.  *     tobj = WIN32OLE_TYPE.new('Microsoft Excel 9.0 Object Library', 'Worksheet')
    5900. 

  5900.  *     puts tobj.helpfile # => C:\...\VBAXL9.CHM
    5901. 

  5901.  *
    5902. 

  5902.  */
    5903. 

  5903. static VALUE
    5904. 

  5904. foletype_helpfile(VALUE self)
    5905. 

  5905. {
    5906. 

  5906.     struct oletypedata *ptype;
    5907. 

  5907.     Data_Get_Struct(self, struct oletypedata, ptype);
    5908. 

  5908.     return ole_type_helpfile(ptype->pTypeInfo);
    5909. 

  5909. }
    5910. 

  5910. 

  5911. static VALUE
    5912. 

  5912. ole_type_helpcontext(ITypeInfo *pTypeInfo)
    5913. 

  5913. {
    5914. 

  5914.     HRESULT hr;
    5915. 

  5915.     DWORD helpcontext;
    5916. 

  5916.     hr = ole_docinfo_from_type(pTypeInfo, NULL, NULL, 
    5917. 

  5917.                                &helpcontext, NULL);
    5918. 

  5918.     if(FAILED(hr))
    5919. 

  5919.         return Qnil;
    5920. 

  5920.     return INT2FIX(helpcontext);
    5921. 

  5921. }
    5922. 

  5922. 

  5923. /*
    5924. 

  5924.  *  call-seq:
    5925. 

  5925.  *     WIN32OLE_TYPE#helpcontext
    5926. 

  5926.  * 
    5927. 

  5927.  *  Returns helpcontext. If helpcontext is not found, then returns nil.
    5928. 

  5928.  *     tobj = WIN32OLE_TYPE.new('Microsoft Excel 9.0 Object Library', 'Worksheet')
    5929. 

  5929.  *     puts tobj.helpfile # => 131185
    5930. 

  5930.  */
    5931. 

  5931. static VALUE
    5932. 

  5932. foletype_helpcontext(VALUE self)
    5933. 

  5933. {
    5934. 

  5934.     struct oletypedata *ptype;
    5935. 

  5935.     Data_Get_Struct(self, struct oletypedata, ptype);
    5936. 

  5936.     return ole_type_helpcontext(ptype->pTypeInfo);
    5937. 

  5937. }
    5938. 

  5938. 

  5939. /*
    5940. 

  5940.  *  call-seq:
    5941. 

  5941.  *     WIN32OLE_TYPE#ole_typelib
    5942. 

  5942.  * 
    5943. 

  5943.  *  Returns the WIN32OLE_TYPELIB object which is including the WIN32OLE_TYPE 
    5944. 

  5944.  *  object. If it is not found, then returns nil.
    5945. 

  5945.  *     tobj = WIN32OLE_TYPE.new('Microsoft Excel 9.0 Object Library', 'Worksheet')
    5946. 

  5946.  *     puts tobj.ole_typelib # => 'Microsoft Excel 9.0 Object Library'
    5947. 

  5947.  */
    5948. 

  5948. static VALUE
    5949. 

  5949. foletype_ole_typelib(VALUE self)
    5950. 

  5950. {
    5951. 

  5951.     struct oletypedata *ptype;
    5952. 

  5952.     Data_Get_Struct(self, struct oletypedata, ptype);
    5953. 

  5953.     return ole_typelib_from_itypeinfo(ptype->pTypeInfo);
    5954. 

  5954. }
    5955. 

  5955. 

  5956. static VALUE
    5957. 

  5957. ole_type_impl_ole_types(ITypeInfo *pTypeInfo, int implflags)
    5958. 

  5958. {
    5959. 

  5959.     HRESULT hr;
    5960. 

  5960.     ITypeInfo *pRefTypeInfo;
    5961. 

  5961.     HREFTYPE href;
    5962. 

  5962.     WORD i;
    5963. 

  5963.     VALUE type;
    5964. 

  5964.     TYPEATTR *pTypeAttr;
    5965. 

  5965.     int flags;
    5966. 

  5966. 

  5967.     VALUE types = rb_ary_new();
    5968. 

  5968.     hr = OLE_GET_TYPEATTR(pTypeInfo, &pTypeAttr);
    5969. 

  5969.     if (FAILED(hr)) {
    5970. 

  5970.         return types;
    5971. 

  5971.     }
    5972. 

  5972.     for (i = 0; i < pTypeAttr->cImplTypes; i++) {
    5973. 

  5973.         hr = pTypeInfo->lpVtbl->GetImplTypeFlags(pTypeInfo, i, &flags);
    5974. 

  5974.         if (FAILED(hr))
    5975. 

  5975.             continue;
    5976. 

  5976. 

  5977.         hr = pTypeInfo->lpVtbl->GetRefTypeOfImplType(pTypeInfo, i, &href);
    5978. 

  5978.         if (FAILED(hr))
    5979. 

  5979.             continue;
    5980. 

  5980.         hr = pTypeInfo->lpVtbl->GetRefTypeInfo(pTypeInfo, href, &pRefTypeInfo);
    5981. 

  5981.         if (FAILED(hr)) 
    5982. 

  5982.             continue;
    5983. 

  5983. 

  5984.         if ((flags & implflags) == implflags) {
    5985. 

  5985.             type = ole_type_from_itypeinfo(pRefTypeInfo);
    5986. 

  5986.             if (type != Qnil) {
    5987. 

  5987.                 rb_ary_push(types, type);
    5988. 

  5988.             }
    5989. 

  5989.         }
    5990. 

  5990. 

  5991.         OLE_RELEASE(pRefTypeInfo);
    5992. 

  5992.     }
    5993. 

  5993.     OLE_RELEASE_TYPEATTR(pTypeInfo, pTypeAttr);
    5994. 

  5994.     return types;
    5995. 

  5995. }
    5996. 

  5996. 

  5997. /*
    5998. 

  5998.  *  call-seq:
    5999. 

  5999.  *     WIN32OLE_TYPE#implemented_ole_types
    6000. 

  6000.  * 
    6001. 

  6001.  *  Returns the array of WIN32OLE_TYPE object which is implemented by the WIN32OLE_TYPE 
    6002. 

  6002.  *  object. 
    6003. 

  6003.  *     tobj = WIN32OLE_TYPE.new('Microsoft Excel 9.0 Object Library', 'Worksheet')
    6004. 

  6004.  *     p tobj.implemented_ole_types # => [_Worksheet, DocEvents]
    6005. 

  6005.  */
    6006. 

  6006. static VALUE
    6007. 

  6007. foletype_impl_ole_types(VALUE self)
    6008. 

  6008. {
    6009. 

  6009.     struct oletypedata *ptype;
    6010. 

  6010.     Data_Get_Struct(self, struct oletypedata, ptype);
    6011. 

  6011.     return ole_type_impl_ole_types(ptype->pTypeInfo, 0);
    6012. 

  6012. }
    6013. 

  6013. 

  6014. /*
    6015. 

  6015.  *  call-seq:
    6016. 

  6016.  *     WIN32OLE_TYPE#source_ole_types
    6017. 

  6017.  * 
    6018. 

  6018.  *  Returns the array of WIN32OLE_TYPE object which is implemented by the WIN32OLE_TYPE 
    6019. 

  6019.  *  object and having IMPLTYPEFLAG_FSOURCE. 
    6020. 

  6020.  *     tobj = WIN32OLE_TYPE.new('Microsoft Internet Controls', "InternetExplorer") 
    6021. 

  6021.  *     p tobj.source_ole_types
    6022. 

  6022.  *     # => [#<WIN32OLE_TYPE:DWebBrowserEvents2>, #<WIN32OLE_TYPE:DWebBrowserEvents>]
    6023. 

  6023.  */
    6024. 

  6024. static VALUE
    6025. 

  6025. foletype_source_ole_types(VALUE self)
    6026. 

  6026. {
    6027. 

  6027.     struct oletypedata *ptype;
    6028. 

  6028.     Data_Get_Struct(self, struct oletypedata, ptype);
    6029. 

  6029.     return ole_type_impl_ole_types(ptype->pTypeInfo, IMPLTYPEFLAG_FSOURCE);
    6030. 

  6030. }
    6031. 

  6031. 

  6032. /*
    6033. 

  6033.  *  call-seq:
    6034. 

  6034.  *     WIN32OLE_TYPE#default_event_sources
    6035. 

  6035.  * 
    6036. 

  6036.  *  Returns the array of WIN32OLE_TYPE object which is implemented by the WIN32OLE_TYPE 
    6037. 

  6037.  *  object and having IMPLTYPEFLAG_FSOURCE and IMPLTYPEFLAG_FDEFAULT. 
    6038. 

  6038.  *     tobj = WIN32OLE_TYPE.new('Microsoft Internet Controls', "InternetExplorer") 
    6039. 

  6039.  *     p tobj.default_event_sources  # => [#<WIN32OLE_TYPE:DWebBrowserEvents2>]
    6040. 

  6040.  */
    6041. 

  6041. static VALUE
    6042. 

  6042. foletype_default_event_sources(VALUE self)
    6043. 

  6043. {
    6044. 

  6044.     struct oletypedata *ptype;
    6045. 

  6045.     Data_Get_Struct(self, struct oletypedata, ptype);
    6046. 

  6046.     return ole_type_impl_ole_types(ptype->pTypeInfo, IMPLTYPEFLAG_FSOURCE|IMPLTYPEFLAG_FDEFAULT);
    6047. 

  6047. }
    6048. 

  6048. 

  6049. /*
    6050. 

  6050.  *  call-seq:
    6051. 

  6051.  *     WIN32OLE_TYPE#default_ole_types
    6052. 

  6052.  * 
    6053. 

  6053.  *  Returns the array of WIN32OLE_TYPE object which is implemented by the WIN32OLE_TYPE 
    6054. 

  6054.  *  object and having IMPLTYPEFLAG_FDEFAULT.
    6055. 

  6055.  *     tobj = WIN32OLE_TYPE.new('Microsoft Internet Controls', "InternetExplorer") 
    6056. 

  6056.  *     p tobj.default_ole_types
    6057. 

  6057.  *     # => [#<WIN32OLE_TYPE:IWebBrowser2>, #<WIN32OLE_TYPE:DWebBrowserEvents2>]
    6058. 

  6058.  */
    6059. 

  6059. static VALUE
    6060. 

  6060. foletype_default_ole_types(VALUE self)
    6061. 

  6061. {
    6062. 

  6062.     struct oletypedata *ptype;
    6063. 

  6063.     Data_Get_Struct(self, struct oletypedata, ptype);
    6064. 

  6064.     return ole_type_impl_ole_types(ptype->pTypeInfo, IMPLTYPEFLAG_FDEFAULT);
    6065. 

  6065. }
    6066. 

  6066. 

  6067. /*
    6068. 

  6068.  *  call-seq:
    6069. 

  6069.  *     WIN32OLE_TYPE#inspect -> String
    6070. 

  6070.  *
    6071. 

  6071.  *  Returns the type name with class name.
    6072. 

  6072.  *
    6073. 

  6073.  *     ie = WIN32OLE.new('InternetExplorer.Application')
    6074. 

  6074.  *     ie.ole_type.inspect => #<WIN32OLE_TYPE:IWebBrowser2>
    6075. 

  6075.  */
    6076. 

  6076. static VALUE
    6077. 

  6077. foletype_inspect(VALUE self)
    6078. 

  6078. {
    6079. 

  6079.     return default_inspect(self, "WIN32OLE_TYPE");
    6080. 

  6080. }
    6081. 

  6081. 

  6082. static VALUE
    6083. 

  6083. ole_variables(ITypeInfo *pTypeInfo)
    6084. 

  6084. {
    6085. 

  6085.     HRESULT hr;
    6086. 

  6086.     TYPEATTR *pTypeAttr;
    6087. 

  6087.     WORD i;
    6088. 

  6088.     UINT len;
    6089. 

  6089.     BSTR bstr;
    6090. 

  6090.     char *pstr;
    6091. 

  6091.     VARDESC *pVarDesc;
    6092. 

  6092.     struct olevariabledata *pvar;
    6093. 

  6093.     VALUE var;
    6094. 

  6094.     VALUE variables = rb_ary_new();
    6095. 

  6095.     hr = OLE_GET_TYPEATTR(pTypeInfo, &pTypeAttr);
    6096. 

  6096.     if (FAILED(hr)) {
    6097. 

  6097.         ole_raise(hr, eWIN32OLERuntimeError, "failed to GetTypeAttr");
    6098. 

  6098.     }
    6099. 

  6099.     
    6100. 

  6100.     for(i = 0; i < pTypeAttr->cVars; i++) {
    6101. 

  6101.         hr = pTypeInfo->lpVtbl->GetVarDesc(pTypeInfo, i, &pVarDesc);
    6102. 

  6102.         if(FAILED(hr))
    6103. 

  6103.             continue;
    6104. 

  6104.         len = 0;
    6105. 

  6105.         pstr = NULL;
    6106. 

  6106.         hr = pTypeInfo->lpVtbl->GetNames(pTypeInfo, pVarDesc->memid, &bstr,
    6107. 

  6107.                                          1, &len);
    6108. 

  6108.         if(FAILED(hr) || len == 0 || !bstr)
    6109. 

  6109.             continue;
    6110. 

  6110. 

  6111.         var = Data_Make_Struct(cWIN32OLE_VARIABLE, struct olevariabledata,
    6112. 

  6112.                                0,olevariable_free,pvar);
    6113. 

  6113.         pvar->pTypeInfo = pTypeInfo;
    6114. 

  6114.         OLE_ADDREF(pTypeInfo);
    6115. 

  6115.         pvar->index = i;
    6116. 

  6116.         rb_ivar_set(var, rb_intern("name"), WC2VSTR(bstr));
    6117. 

  6117.         rb_ary_push(variables, var);
    6118. 

  6118. 

  6119.         pTypeInfo->lpVtbl->ReleaseVarDesc(pTypeInfo, pVarDesc);
    6120. 

  6120.         pVarDesc = NULL;
    6121. 

  6121.     }
    6122. 

  6122.     OLE_RELEASE_TYPEATTR(pTypeInfo, pTypeAttr);
    6123. 

  6123.     return variables;
    6124. 

  6124. }
    6125. 

  6125. 

  6126. /*
    6127. 

  6127.  *  call-seq:
    6128. 

  6128.  *     WIN32OLE_TYPE#variables
    6129. 

  6129.  * 
    6130. 

  6130.  *  Returns array of WIN32OLE_VARIABLE objects which represent variables 
    6131. 

  6131.  *  defined in OLE class.
    6132. 

  6132.  *     tobj = WIN32OLE_TYPE.new('Microsoft Excel 9.0 Object Library', 'XlSheetType')
    6133. 

  6133.  *     vars = tobj.variables
    6134. 

  6134.  *     vars.each do |v|
    6135. 

  6135.  *       puts "#{v.name} = #{v.value}"
    6136. 

  6136.  *     end
    6137. 

  6137.  *     
    6138. 

  6138.  *     The result of above sample script is follows:
    6139. 

  6139.  *       xlChart = -4109
    6140. 

  6140.  *       xlDialogSheet = -4116
    6141. 

  6141.  *       xlExcel4IntlMacroSheet = 4
    6142. 

  6142.  *       xlExcel4MacroSheet = 3
    6143. 

  6143.  *       xlWorksheet = -4167
    6144. 

  6144.  *
    6145. 

  6145.  */
    6146. 

  6146. static VALUE
    6147. 

  6147. foletype_variables(VALUE self)
    6148. 

  6148. {
    6149. 

  6149.     struct oletypedata *ptype;
    6150. 

  6150.     Data_Get_Struct(self, struct oletypedata, ptype);
    6151. 

  6151.     return ole_variables(ptype->pTypeInfo);
    6152. 

  6152. }
    6153. 

  6153. 

  6154. /*
    6155. 

  6155.  *  call-seq:
    6156. 

  6156.  *     WIN32OLE_TYPE#ole_methods # the array of WIN32OLE_METHOD objects.
    6157. 

  6157.  * 
    6158. 

  6158.  *  Returns array of WIN32OLE_METHOD objects which represent OLE method defined in 
    6159. 

  6159.  *  OLE type library.
    6160. 

  6160.  *    tobj = WIN32OLE_TYPE.new('Microsoft Excel 9.0 Object Library', 'Worksheet')
    6161. 

  6161.  *    methods = tobj.ole_methods.collect{|m|
    6162. 

  6162.  *      m.name
    6163. 

  6163.  *    }                                       
    6164. 

  6164.  *    # => ['Activate', 'Copy', 'Delete',....]
    6165. 

  6165.  */
    6166. 

  6166. static VALUE
    6167. 

  6167. foletype_methods(VALUE self)
    6168. 

  6168. {
    6169. 

  6169.     struct oletypedata *ptype;
    6170. 

  6170.     Data_Get_Struct(self, struct oletypedata, ptype);
    6171. 

  6171.     return ole_methods_from_typeinfo(ptype->pTypeInfo, INVOKE_FUNC | INVOKE_PROPERTYGET | INVOKE_PROPERTYPUT | INVOKE_PROPERTYPUTREF);
    6172. 

  6172. }
    6173. 

  6173. 

  6174. /*
    6175. 

  6175.  * Document-class: WIN32OLE_VARIABLE
    6176. 

  6176.  *
    6177. 

  6177.  *   <code>WIN32OLE_VARIABLE</code> objects represent OLE variable information.
    6178. 

  6178.  */
    6179. 

  6179. 

  6180. /*
    6181. 

  6181.  *  call-seq:
    6182. 

  6182.  *     WIN32OLE_VARIABLE#name
    6183. 

  6183.  * 
    6184. 

  6184.  *  Returns the name of variable.
    6185. 

  6185.  *
    6186. 

  6186.  *     tobj = WIN32OLE_TYPE.new('Microsoft Excel 9.0 Object Library', 'XlSheetType')
    6187. 

  6187.  *     variables = tobj.variables
    6188. 

  6188.  *     variables.each do |variable|
    6189. 

  6189.  *       puts "#{variable.name}"
    6190. 

  6190.  *     end
    6191. 

  6191.  *
    6192. 

  6192.  *     The result of above script is following:
    6193. 

  6193.  *       xlChart
    6194. 

  6194.  *       xlDialogSheet
    6195. 

  6195.  *       xlExcel4IntlMacroSheet
    6196. 

  6196.  *       xlExcel4MacroSheet
    6197. 

  6197.  *       xlWorksheet
    6198. 

  6198.  *
    6199. 

  6199.  */
    6200. 

  6200. static VALUE
    6201. 

  6201. folevariable_name(VALUE self)
    6202. 

  6202. {
    6203. 

  6203.     return rb_ivar_get(self, rb_intern("name"));
    6204. 

  6204. }
    6205. 

  6205. 

  6206. static VALUE
    6207. 

  6207. ole_variable_ole_type(ITypeInfo *pTypeInfo, UINT var_index)
    6208. 

  6208. {
    6209. 

  6209.     VARDESC *pVarDesc;
    6210. 

  6210.     HRESULT hr;
    6211. 

  6211.     VALUE type;
    6212. 

  6212.     hr = pTypeInfo->lpVtbl->GetVarDesc(pTypeInfo, var_index, &pVarDesc);
    6213. 

  6213.     if (FAILED(hr))
    6214. 

  6214.         ole_raise(hr, eWIN32OLERuntimeError, "failed to GetVarDesc");
    6215. 

  6215.     type = ole_typedesc2val(pTypeInfo, &(pVarDesc->elemdescVar.tdesc), Qnil);
    6216. 

  6216.     pTypeInfo->lpVtbl->ReleaseVarDesc(pTypeInfo, pVarDesc);
    6217. 

  6217.     return type;
    6218. 

  6218. }
    6219. 

  6219. 

  6220. /*
    6221. 

  6221.  *   call-seq:
    6222. 

  6222.  *      WIN32OLE_VARIABLE#ole_type
    6223. 

  6223.  * 
    6224. 

  6224.  *   Returns OLE type string.
    6225. 

  6225.  *
    6226. 

  6226.  *     tobj = WIN32OLE_TYPE.new('Microsoft Excel 9.0 Object Library', 'XlSheetType')
    6227. 

  6227.  *     variables = tobj.variables
    6228. 

  6228.  *     variables.each do |variable|
    6229. 

  6229.  *       puts "#{variable.ole_type} #{variable.name}"
    6230. 

  6230.  *     end
    6231. 

  6231.  *
    6232. 

  6232.  *     The result of above script is following:
    6233. 

  6233.  *       INT xlChart
    6234. 

  6234.  *       INT xlDialogSheet
    6235. 

  6235.  *       INT xlExcel4IntlMacroSheet
    6236. 

  6236.  *       INT xlExcel4MacroSheet
    6237. 

  6237.  *       INT xlWorksheet
    6238. 

  6238.  *
    6239. 

  6239.  */
    6240. 

  6240. static VALUE
    6241. 

  6241. folevariable_ole_type(VALUE self)
    6242. 

  6242. {
    6243. 

  6243.     struct olevariabledata *pvar;
    6244. 

  6244.     Data_Get_Struct(self, struct olevariabledata, pvar);
    6245. 

  6245.     return ole_variable_ole_type(pvar->pTypeInfo, pvar->index);
    6246. 

  6246. }
    6247. 

  6247. 

  6248. static VALUE
    6249. 

  6249. ole_variable_ole_type_detail(ITypeInfo *pTypeInfo, UINT var_index)
    6250. 

  6250. {
    6251. 

  6251.     VARDESC *pVarDesc;
    6252. 

  6252.     HRESULT hr;
    6253. 

  6253.     VALUE type = rb_ary_new();
    6254. 

  6254.     hr = pTypeInfo->lpVtbl->GetVarDesc(pTypeInfo, var_index, &pVarDesc);
    6255. 

  6255.     if (FAILED(hr))
    6256. 

  6256.         ole_raise(hr, eWIN32OLERuntimeError, "failed to GetVarDesc");
    6257. 

  6257.     ole_typedesc2val(pTypeInfo, &(pVarDesc->elemdescVar.tdesc), type);
    6258. 

  6258.     pTypeInfo->lpVtbl->ReleaseVarDesc(pTypeInfo, pVarDesc);
    6259. 

  6259.     return type;
    6260. 

  6260. }
    6261. 

  6261. 

  6262. /*
    6263. 

  6263.  *  call-seq:
    6264. 

  6264.  *     WIN32OLE_VARIABLE#ole_type_detail
    6265. 

  6265.  * 
    6266. 

  6266.  *  Returns detail information of type. The information is array of type.
    6267. 

  6267.  *
    6268. 

  6268.  *     tobj = WIN32OLE_TYPE.new('DirectX 7 for Visual Basic Type Library', 'D3DCLIPSTATUS')
    6269. 

  6269.  *     variable = tobj.variables.find {|variable| variable.name == 'lFlags'}
    6270. 

  6270.  *     tdetail  = variable.ole_type_detail
    6271. 

  6271.  *     p tdetail # => ["USERDEFINED", "CONST_D3DCLIPSTATUSFLAGS"]
    6272. 

  6272.  *
    6273. 

  6273.  */
    6274. 

  6274. static VALUE
    6275. 

  6275. folevariable_ole_type_detail(VALUE self)
    6276. 

  6276. {
    6277. 

  6277.     struct olevariabledata *pvar;
    6278. 

  6278.     Data_Get_Struct(self, struct olevariabledata, pvar);
    6279. 

  6279.     return ole_variable_ole_type_detail(pvar->pTypeInfo, pvar->index);
    6280. 

  6280. }
    6281. 

  6281. 

  6282. static VALUE
    6283. 

  6283. ole_variable_value(ITypeInfo *pTypeInfo, UINT var_index)
    6284. 

  6284. {
    6285. 

  6285.     VARDESC *pVarDesc;
    6286. 

  6286.     HRESULT hr;
    6287. 

  6287.     VALUE val = Qnil;
    6288. 

  6288.     hr = pTypeInfo->lpVtbl->GetVarDesc(pTypeInfo, var_index, &pVarDesc);
    6289. 

  6289.     if (FAILED(hr))
    6290. 

  6290.         return Qnil;
    6291. 

  6291.     if(pVarDesc->varkind == VAR_CONST)
    6292. 

  6292.         val = ole_variant2val(V_UNION1(pVarDesc, lpvarValue));
    6293. 

  6293.     pTypeInfo->lpVtbl->ReleaseVarDesc(pTypeInfo, pVarDesc);
    6294. 

  6294.     return val;
    6295. 

  6295. }
    6296. 

  6296. 

  6297. /*
    6298. 

  6298.  *  call-seq:
    6299. 

  6299.  *     WIN32OLE_VARIABLE#value
    6300. 

  6300.  * 
    6301. 

  6301.  *  Returns value if value is exists. If the value does not exist, 
    6302. 

  6302.  *  this method returns nil.
    6303. 

  6303.  *
    6304. 

  6304.  *     tobj = WIN32OLE_TYPE.new('Microsoft Excel 9.0 Object Library', 'XlSheetType')
    6305. 

  6305.  *     variables = tobj.variables
    6306. 

  6306.  *     variables.each do |variable|
    6307. 

  6307.  *       puts "#{variable.name} #{variable.value}"
    6308. 

  6308.  *     end
    6309. 

  6309.  *
    6310. 

  6310.  *     The result of above script is following:
    6311. 

  6311.  *       xlChart = -4109
    6312. 

  6312.  *       xlDialogSheet = -4116
    6313. 

  6313.  *       xlExcel4IntlMacroSheet = 4
    6314. 

  6314.  *       xlExcel4MacroSheet = 3
    6315. 

  6315.  *       xlWorksheet = -4167
    6316. 

  6316.  *
    6317. 

  6317.  */    
    6318. 

  6318. static VALUE
    6319. 

  6319. folevariable_value(VALUE self)
    6320. 

  6320. {
    6321. 

  6321.     struct olevariabledata *pvar;
    6322. 

  6322.     Data_Get_Struct(self, struct olevariabledata, pvar);
    6323. 

  6323.     return ole_variable_value(pvar->pTypeInfo, pvar->index);
    6324. 

  6324. }
    6325. 

  6325. 

  6326. static VALUE
    6327. 

  6327. ole_variable_visible(ITypeInfo *pTypeInfo, UINT var_index)
    6328. 

  6328. {
    6329. 

  6329.     VARDESC *pVarDesc;
    6330. 

  6330.     HRESULT hr;
    6331. 

  6331.     VALUE visible = Qfalse;
    6332. 

  6332.     hr = pTypeInfo->lpVtbl->GetVarDesc(pTypeInfo, var_index, &pVarDesc);
    6333. 

  6333.     if (FAILED(hr))
    6334. 

  6334.         return visible;
    6335. 

  6335.     if (!(pVarDesc->wVarFlags & (VARFLAG_FHIDDEN |
    6336. 

  6336.                                  VARFLAG_FRESTRICTED |
    6337. 

  6337.                                  VARFLAG_FNONBROWSABLE))) {
    6338. 

  6338.         visible = Qtrue;
    6339. 

  6339.     }
    6340. 

  6340.     pTypeInfo->lpVtbl->ReleaseVarDesc(pTypeInfo, pVarDesc);
    6341. 

  6341.     return visible;
    6342. 

  6342. }
    6343. 

  6343. 

  6344. /*
    6345. 

  6345.  *  call-seq:
    6346. 

  6346.  *     WIN32OLE_VARIABLE#visible?
    6347. 

  6347.  * 
    6348. 

  6348.  *  Returns true if the variable is public.
    6349. 

  6349.  *
    6350. 

  6350.  *     tobj = WIN32OLE_TYPE.new('Microsoft Excel 9.0 Object Library', 'XlSheetType')
    6351. 

  6351.  *     variables = tobj.variables
    6352. 

  6352.  *     variables.each do |variable|
    6353. 

  6353.  *       puts "#{variable.name} #{variable.visible?}"
    6354. 

  6354.  *     end
    6355. 

  6355.  *
    6356. 

  6356.  *     The result of above script is following:
    6357. 

  6357.  *       xlChart true
    6358. 

  6358.  *       xlDialogSheet true
    6359. 

  6359.  *       xlExcel4IntlMacroSheet true
    6360. 

  6360.  *       xlExcel4MacroSheet true
    6361. 

  6361.  *       xlWorksheet true
    6362. 

  6362.  *       
    6363. 

  6363.  */
    6364. 

  6364. static VALUE
    6365. 

  6365. folevariable_visible(VALUE self)
    6366. 

  6366. {
    6367. 

  6367.     struct olevariabledata *pvar;
    6368. 

  6368.     Data_Get_Struct(self, struct olevariabledata, pvar);
    6369. 

  6369.     return ole_variable_visible(pvar->pTypeInfo, pvar->index);
    6370. 

  6370. }
    6371. 

  6371. 

  6372. static VALUE
    6373. 

  6373. ole_variable_kind(ITypeInfo *pTypeInfo, UINT var_index)
    6374. 

  6374. {
    6375. 

  6375.     VARDESC *pVarDesc;
    6376. 

  6376.     HRESULT hr;
    6377. 

  6377.     VALUE kind = rb_str_new2("UNKNOWN");
    6378. 

  6378.     hr = pTypeInfo->lpVtbl->GetVarDesc(pTypeInfo, var_index, &pVarDesc);
    6379. 

  6379.     if (FAILED(hr))
    6380. 

  6380.         return kind;
    6381. 

  6381.     switch(pVarDesc->varkind) {
    6382. 

  6382.     case VAR_PERINSTANCE:
    6383. 

  6383.         kind = rb_str_new2("PERINSTANCE");
    6384. 

  6384.         break;
    6385. 

  6385.     case VAR_STATIC:
    6386. 

  6386.         kind = rb_str_new2("STATIC");
    6387. 

  6387.         break;
    6388. 

  6388.     case VAR_CONST:
    6389. 

  6389.         kind = rb_str_new2("CONSTANT");
    6390. 

  6390.         break;
    6391. 

  6391.     case VAR_DISPATCH:
    6392. 

  6392.         kind = rb_str_new2("DISPATCH");
    6393. 

  6393.         break;
    6394. 

  6394.     default:
    6395. 

  6395.         break;
    6396. 

  6396.     }
    6397. 

  6397.     pTypeInfo->lpVtbl->ReleaseVarDesc(pTypeInfo, pVarDesc);
    6398. 

  6398.     return kind;
    6399. 

  6399. }
    6400. 

  6400. 

  6401. /*
    6402. 

  6402.  * call-seq:
    6403. 

  6403.  *   WIN32OLE_VARIABLE#variable_kind
    6404. 

  6404.  * 
    6405. 

  6405.  * Returns variable kind string.
    6406. 

  6406.  *
    6407. 

  6407.  *    tobj = WIN32OLE_TYPE.new('Microsoft Excel 9.0 Object Library', 'XlSheetType')
    6408. 

  6408.  *    variables = tobj.variables
    6409. 

  6409.  *    variables.each do |variable|
    6410. 

  6410.  *      puts "#{variable.name} #{variable.variable_kind}"
    6411. 

  6411.  *    end
    6412. 

  6412.  *
    6413. 

  6413.  *    The result of above script is following:
    6414. 

  6414.  *      xlChart CONSTANT
    6415. 

  6415.  *      xlDialogSheet CONSTANT
    6416. 

  6416.  *      xlExcel4IntlMacroSheet CONSTANT
    6417. 

  6417.  *      xlExcel4MacroSheet CONSTANT
    6418. 

  6418.  *      xlWorksheet CONSTANT
    6419. 

  6419.  */
    6420. 

  6420. static VALUE
    6421. 

  6421. folevariable_variable_kind(VALUE self)
    6422. 

  6422. {
    6423. 

  6423.     struct olevariabledata *pvar;
    6424. 

  6424.     Data_Get_Struct(self, struct olevariabledata, pvar);
    6425. 

  6425.     return ole_variable_kind(pvar->pTypeInfo, pvar->index);
    6426. 

  6426. }
    6427. 

  6427. 

  6428. static VALUE
    6429. 

  6429. ole_variable_varkind(ITypeInfo *pTypeInfo, UINT var_index)
    6430. 

  6430. {
    6431. 

  6431.     VARDESC *pVarDesc;
    6432. 

  6432.     HRESULT hr;
    6433. 

  6433.     VALUE kind = Qnil;
    6434. 

  6434.     hr = pTypeInfo->lpVtbl->GetVarDesc(pTypeInfo, var_index, &pVarDesc);
    6435. 

  6435.     if (FAILED(hr))
    6436. 

  6436.         return kind;
    6437. 

  6437.     pTypeInfo->lpVtbl->ReleaseVarDesc(pTypeInfo, pVarDesc);
    6438. 

  6438.     kind = INT2FIX(pVarDesc->varkind);    
    6439. 

  6439.     return kind;
    6440. 

  6440. }
    6441. 

  6441. 

  6442. /*
    6443. 

  6443.  *  call-seq:
    6444. 

  6444.  *     WIN32OLE_VARIABLE#varkind
    6445. 

  6445.  * 
    6446. 

  6446.  *  Returns the number which represents variable kind.
    6447. 

  6447.  *    tobj = WIN32OLE_TYPE.new('Microsoft Excel 9.0 Object Library', 'XlSheetType')
    6448. 

  6448.  *    variables = tobj.variables
    6449. 

  6449.  *    variables.each do |variable|
    6450. 

  6450.  *      puts "#{variable.name} #{variable.varkind}"
    6451. 

  6451.  *    end
    6452. 

  6452.  *
    6453. 

  6453.  *    The result of above script is following:
    6454. 

  6454.  *       xlChart 2
    6455. 

  6455.  *       xlDialogSheet 2
    6456. 

  6456.  *       xlExcel4IntlMacroSheet 2
    6457. 

  6457.  *       xlExcel4MacroSheet 2
    6458. 

  6458.  *       xlWorksheet 2
    6459. 

  6459.  */
    6460. 

  6460. static VALUE
    6461. 

  6461. folevariable_varkind(VALUE self)
    6462. 

  6462. {
    6463. 

  6463.     struct olevariabledata *pvar;
    6464. 

  6464.     Data_Get_Struct(self, struct olevariabledata, pvar);
    6465. 

  6465.     return ole_variable_varkind(pvar->pTypeInfo, pvar->index);
    6466. 

  6466. }
    6467. 

  6467. 

  6468. /*
    6469. 

  6469.  *  call-seq:
    6470. 

  6470.  *     WIN32OLE_VARIABLE#inspect -> String
    6471. 

  6471.  *
    6472. 

  6472.  *  Returns the OLE variable name and the value with class name. 
    6473. 

  6473.  *
    6474. 

  6474.  */
    6475. 

  6475. static VALUE
    6476. 

  6476. folevariable_inspect(VALUE self)
    6477. 

  6477. {
    6478. 

  6478.     VALUE detail = rb_funcall(self, rb_intern("to_s"), 0);
    6479. 

  6479.     rb_str_cat2(detail, "=");
    6480. 

  6480.     rb_str_concat(detail, rb_funcall(rb_funcall(self, rb_intern("value"), 0), rb_intern("inspect"), 0));
    6481. 

  6481.     return make_inspect("WIN32OLE_VARIABLE", detail);
    6482. 

  6482. }
    6483. 

  6483. 

  6484. /*
    6485. 

  6485.  * Document-class: WIN32OLE_METHOD
    6486. 

  6486.  *
    6487. 

  6487.  *   <code>WIN32OLE_METHOD</code> objects represent OLE method information.
    6488. 

  6488.  */
    6489. 

  6489. 

  6490. static VALUE
    6491. 

  6491. olemethod_set_member(VALUE self, ITypeInfo *pTypeInfo, ITypeInfo *pOwnerTypeInfo, int index, VALUE name)
    6492. 

  6492. {
    6493. 

  6493.     struct olemethoddata *pmethod;
    6494. 

  6494.     Data_Get_Struct(self, struct olemethoddata, pmethod);
    6495. 

  6495.     pmethod->pTypeInfo = pTypeInfo;
    6496. 

  6496.     OLE_ADDREF(pTypeInfo);
    6497. 

  6497.     pmethod->pOwnerTypeInfo = pOwnerTypeInfo;
    6498. 

  6498.     if(pOwnerTypeInfo) OLE_ADDREF(pOwnerTypeInfo);
    6499. 

  6499.     pmethod->index = index;
    6500. 

  6500.     rb_ivar_set(self, rb_intern("name"), name);
    6501. 

  6501.     return self;
    6502. 

  6502. }
    6503. 

  6503. 

  6504. static VALUE
    6505. 

  6505. folemethod_s_allocate(VALUE klass)
    6506. 

  6506. {
    6507. 

  6507.     struct olemethoddata *pmethod;
    6508. 

  6508.     VALUE obj;
    6509. 

  6509.     obj = Data_Make_Struct(klass, 
    6510. 

  6510.                            struct olemethoddata,
    6511. 

  6511.                            0, olemethod_free, pmethod);
    6512. 

  6512.     pmethod->pTypeInfo = NULL;
    6513. 

  6513.     pmethod->pOwnerTypeInfo = NULL;
    6514. 

  6514.     pmethod->index = 0;
    6515. 

  6515.     return obj;
    6516. 

  6516. }
    6517. 

  6517. 

  6518. /*
    6519. 

  6519.  *  call-seq:
    6520. 

  6520.  *     WIN32OLE_METHOD.new(ole_type,  method) -> WIN32OLE_METHOD object
    6521. 

  6521.  * 
    6522. 

  6522.  *  Returns a new WIN32OLE_METHOD object which represents the information
    6523. 

  6523.  *  about OLE method.
    6524. 

  6524.  *  The first argument <i>ole_type</i> specifies WIN32OLE_TYPE object.
    6525. 

  6525.  *  The second argument <i>method</i> specifies OLE method name defined OLE class
    6526. 

  6526.  *  which represents WIN32OLE_TYPE object.
    6527. 

  6527.  *
    6528. 

  6528.  *     tobj = WIN32OLE_TYPE.new('Microsoft Excel 9.0 Object Library', 'Workbook')
    6529. 

  6529.  *     method = WIN32OLE_METHOD.new(tobj, 'SaveAs')
    6530. 

  6530.  */
    6531. 

  6531. static VALUE
    6532. 

  6532. folemethod_initialize(VALUE self, VALUE oletype, VALUE method)
    6533. 

  6533. {
    6534. 

  6534.     struct oletypedata *ptype;
    6535. 

  6535.     VALUE obj = Qnil;
    6536. 

  6536.     if (rb_obj_is_kind_of(oletype, cWIN32OLE_TYPE)) {
    6537. 

  6537.         SafeStringValue(method);
    6538. 

  6538.         Data_Get_Struct(oletype, struct oletypedata, ptype);
    6539. 

  6539.         obj = olemethod_from_typeinfo(self, ptype->pTypeInfo, method);
    6540. 

  6540.         if (obj == Qnil) {
    6541. 

  6541.             rb_raise(eWIN32OLERuntimeError, "not found %s",
    6542. 

  6542.                      StringValuePtr(method));
    6543. 

  6543.         }
    6544. 

  6544.     }
    6545. 

  6545.     else {
    6546. 

  6546.         rb_raise(rb_eTypeError, "1st argument should be WIN32OLE_TYPE object");
    6547. 

  6547.     }
    6548. 

  6548.     return obj;
    6549. 

  6549. }
    6550. 

  6550. 

  6551. /*
    6552. 

  6552.  *  call-seq
    6553. 

  6553.  *     WIN32OLE_METHOD#name
    6554. 

  6554.  *
    6555. 

  6555.  *  Returns the name of the method.
    6556. 

  6556.  *
    6557. 

  6557.  *     tobj = WIN32OLE_TYPE.new('Microsoft Excel 9.0 Object Library', 'Workbook')
    6558. 

  6558.  *     method = WIN32OLE_METHOD.new(tobj, 'SaveAs')
    6559. 

  6559.  *     puts method.name # => SaveAs
    6560. 

  6560.  *     
    6561. 

  6561.  */
    6562. 

  6562. static VALUE
    6563. 

  6563. folemethod_name(VALUE self)
    6564. 

  6564. {
    6565. 

  6565.     return rb_ivar_get(self, rb_intern("name"));
    6566. 

  6566. }
    6567. 

  6567. 

  6568. static VALUE
    6569. 

  6569. ole_method_return_type(ITypeInfo *pTypeInfo, UINT method_index)
    6570. 

  6570. {
    6571. 

  6571.     FUNCDESC *pFuncDesc;
    6572. 

  6572.     HRESULT hr;
    6573. 

  6573.     VALUE type;
    6574. 

  6574. 

  6575.     hr = pTypeInfo->lpVtbl->GetFuncDesc(pTypeInfo, method_index, &pFuncDesc);
    6576. 

  6576.     if (FAILED(hr)) 
    6577. 

  6577.         ole_raise(hr, eWIN32OLERuntimeError, "failed to GetFuncDesc");
    6578. 

  6578.     
    6579. 

  6579.     type = ole_typedesc2val(pTypeInfo, &(pFuncDesc->elemdescFunc.tdesc), Qnil);
    6580. 

  6580.     pTypeInfo->lpVtbl->ReleaseFuncDesc(pTypeInfo, pFuncDesc);
    6581. 

  6581.     return type;
    6582. 

  6582. }
    6583. 

  6583. 

  6584. /*
    6585. 

  6585.  *  call-seq:
    6586. 

  6586.  *     WIN32OLE_METHOD#return_type
    6587. 

  6587.  * 
    6588. 

  6588.  *  Returns string of return value type of method.
    6589. 

  6589.  *     tobj = WIN32OLE_TYPE.new('Microsoft Excel 9.0 Object Library', 'Workbooks')
    6590. 

  6590.  *     method = WIN32OLE_METHOD.new(tobj, 'Add')
    6591. 

  6591.  *     puts method.return_type # => Workbook
    6592. 

  6592.  *
    6593. 

  6593.  */
    6594. 

  6594. static VALUE
    6595. 

  6595. folemethod_return_type(VALUE self)
    6596. 

  6596. {
    6597. 

  6597.     struct olemethoddata *pmethod;
    6598. 

  6598.     Data_Get_Struct(self, struct olemethoddata, pmethod);
    6599. 

  6599.     return ole_method_return_type(pmethod->pTypeInfo, pmethod->index);
    6600. 

  6600. }
    6601. 

  6601. 

  6602. static VALUE
    6603. 

  6603. ole_method_return_vtype(ITypeInfo *pTypeInfo, UINT method_index)
    6604. 

  6604. {
    6605. 

  6605.     FUNCDESC *pFuncDesc;
    6606. 

  6606.     HRESULT hr;
    6607. 

  6607.     VALUE vvt;
    6608. 

  6608. 

  6609.     hr = pTypeInfo->lpVtbl->GetFuncDesc(pTypeInfo, method_index, &pFuncDesc);
    6610. 

  6610.     if (FAILED(hr)) 
    6611. 

  6611.         ole_raise(hr, eWIN32OLERuntimeError, "failed to GetFuncDesc");
    6612. 

  6612.     
    6613. 

  6613.     vvt = INT2FIX(pFuncDesc->elemdescFunc.tdesc.vt);
    6614. 

  6614.     pTypeInfo->lpVtbl->ReleaseFuncDesc(pTypeInfo, pFuncDesc);
    6615. 

  6615.     return vvt;
    6616. 

  6616. }
    6617. 

  6617. 

  6618. /*
    6619. 

  6619.  *  call-seq:
    6620. 

  6620.  *     WIN32OLE_METHOD#return_vtype
    6621. 

  6621.  * 
    6622. 

  6622.  *  Returns number of return value type of method.
    6623. 

  6623.  *     tobj = WIN32OLE_TYPE.new('Microsoft Excel 9.0 Object Library', 'Workbooks')
    6624. 

  6624.  *     method = WIN32OLE_METHOD.new(tobj, 'Add')
    6625. 

  6625.  *     puts method.return_vtype # => 26
    6626. 

  6626.  *
    6627. 

  6627.  */
    6628. 

  6628. static VALUE
    6629. 

  6629. folemethod_return_vtype(VALUE self)
    6630. 

  6630. {
    6631. 

  6631.     struct olemethoddata *pmethod;
    6632. 

  6632.     Data_Get_Struct(self, struct olemethoddata, pmethod);
    6633. 

  6633.     return ole_method_return_vtype(pmethod->pTypeInfo, pmethod->index);
    6634. 

  6634. }
    6635. 

  6635. 

  6636. static VALUE
    6637. 

  6637. ole_method_return_type_detail(ITypeInfo *pTypeInfo, UINT method_index)
    6638. 

  6638. {
    6639. 

  6639.     FUNCDESC *pFuncDesc;
    6640. 

  6640.     HRESULT hr;
    6641. 

  6641.     VALUE type = rb_ary_new();
    6642. 

  6642. 

  6643.     hr = pTypeInfo->lpVtbl->GetFuncDesc(pTypeInfo, method_index, &pFuncDesc);
    6644. 

  6644.     if (FAILED(hr)) 
    6645. 

  6645.         return type;
    6646. 

  6646.     
    6647. 

  6647.     ole_typedesc2val(pTypeInfo, &(pFuncDesc->elemdescFunc.tdesc), type);
    6648. 

  6648.     pTypeInfo->lpVtbl->ReleaseFuncDesc(pTypeInfo, pFuncDesc);
    6649. 

  6649.     return type;
    6650. 

  6650. }
    6651. 

  6651. 

  6652. /*
    6653. 

  6653.  *  call-seq:
    6654. 

  6654.  *     WIN32OLE_METHOD#return_type_detail
    6655. 

  6655.  * 
    6656. 

  6656.  *  Returns detail information of return value type of method.
    6657. 

  6657.  *  The information is array.
    6658. 

  6658.  *     tobj = WIN32OLE_TYPE.new('Microsoft Excel 9.0 Object Library', 'Workbooks')
    6659. 

  6659.  *     method = WIN32OLE_METHOD.new(tobj, 'Add')
    6660. 

  6660.  *     p method.return_type_detail # => ["PTR", "USERDEFINED", "Workbook"]
    6661. 

  6661.  */
    6662. 

  6662. static VALUE
    6663. 

  6663. folemethod_return_type_detail(VALUE self)
    6664. 

  6664. {
    6665. 

  6665.     struct olemethoddata *pmethod;
    6666. 

  6666.     Data_Get_Struct(self, struct olemethoddata, pmethod);
    6667. 

  6667.     return ole_method_return_type_detail(pmethod->pTypeInfo, pmethod->index);
    6668. 

  6668. }
    6669. 

  6669. 

  6670. static VALUE
    6671. 

  6671. ole_method_invkind(ITypeInfo *pTypeInfo, UINT method_index)
    6672. 

  6672. {
    6673. 

  6673.     FUNCDESC *pFuncDesc;
    6674. 

  6674.     HRESULT hr;
    6675. 

  6675.     VALUE invkind;
    6676. 

  6676.     hr = pTypeInfo->lpVtbl->GetFuncDesc(pTypeInfo, method_index, &pFuncDesc);
    6677. 

  6677.     if(FAILED(hr)) 
    6678. 

  6678.         ole_raise(hr, eWIN32OLERuntimeError, "failed to GetFuncDesc");
    6679. 

  6679.     invkind = INT2FIX(pFuncDesc->invkind);
    6680. 

  6680.     pTypeInfo->lpVtbl->ReleaseFuncDesc(pTypeInfo, pFuncDesc);
    6681. 

  6681.     return invkind;
    6682. 

  6682. }
    6683. 

  6683. 

  6684. static VALUE
    6685. 

  6685. ole_method_invoke_kind(ITypeInfo *pTypeInfo, UINT method_index)
    6686. 

  6686. {
    6687. 

  6687.     VALUE type = rb_str_new2("UNKNOWN");
    6688. 

  6688.     VALUE invkind = ole_method_invkind(pTypeInfo, method_index);
    6689. 

  6689.     if((FIX2INT(invkind) & INVOKE_PROPERTYGET) &&
    6690. 

  6690.        (FIX2INT(invkind) & INVOKE_PROPERTYPUT) ) {
    6691. 

  6691.         type = rb_str_new2("PROPERTY");
    6692. 

  6692.     } else if(FIX2INT(invkind) & INVOKE_PROPERTYGET) {
    6693. 

  6693.         type =  rb_str_new2("PROPERTYGET");
    6694. 

  6694.     } else if(FIX2INT(invkind) & INVOKE_PROPERTYPUT) {
    6695. 

  6695.         type = rb_str_new2("PROPERTYPUT");
    6696. 

  6696.     } else if(FIX2INT(invkind) & INVOKE_PROPERTYPUTREF) {
    6697. 

  6697.         type = rb_str_new2("PROPERTYPUTREF");
    6698. 

  6698.     } else if(FIX2INT(invkind) & INVOKE_FUNC) {
    6699. 

  6699.         type = rb_str_new2("FUNC");
    6700. 

  6700.     }
    6701. 

  6701.     return type;
    6702. 

  6702. }
    6703. 

  6703. 

  6704. /*
    6705. 

  6705.  *   call-seq:
    6706. 

  6706.  *      WIN32OLE_MTHOD#invkind
    6707. 

  6707.  * 
    6708. 

  6708.  *   Returns the method invoke kind. 
    6709. 

  6709.  *     tobj = WIN32OLE_TYPE.new('Microsoft Excel 9.0 Object Library', 'Workbooks')
    6710. 

  6710.  *     method = WIN32OLE_METHOD.new(tobj, 'Add')
    6711. 

  6711.  *     puts method.invkind # => 1
    6712. 

  6712.  *
    6713. 

  6713.  */
    6714. 

  6714. static VALUE
    6715. 

  6715. folemethod_invkind(VALUE self)
    6716. 

  6716. {
    6717. 

  6717.     struct olemethoddata *pmethod;
    6718. 

  6718.     Data_Get_Struct(self, struct olemethoddata, pmethod);
    6719. 

  6719.     return ole_method_invkind(pmethod->pTypeInfo, pmethod->index);
    6720. 

  6720. }
    6721. 

  6721. 

  6722. /*
    6723. 

  6723.  *  call-seq:
    6724. 

  6724.  *     WIN32OLE_METHOD#invoke_kind
    6725. 

  6725.  * 
    6726. 

  6726.  *  Returns the method kind string. The string is "UNKNOWN" or "PROPERTY" 
    6727. 

  6727.  *  or "PROPERTY" or "PROPERTYGET" or "PROPERTYPUT" or "PROPERTYPPUTREF" 
    6728. 

  6728.  *  or "FUNC".
    6729. 

  6729.  *     tobj = WIN32OLE_TYPE.new('Microsoft Excel 9.0 Object Library', 'Workbooks')
    6730. 

  6730.  *     method = WIN32OLE_METHOD.new(tobj, 'Add')
    6731. 

  6731.  *     puts method.invoke_kind # => "FUNC"
    6732. 

  6732.  */
    6733. 

  6733. static VALUE
    6734. 

  6734. folemethod_invoke_kind(VALUE self)
    6735. 

  6735. {
    6736. 

  6736.     struct olemethoddata *pmethod;
    6737. 

  6737.     Data_Get_Struct(self, struct olemethoddata, pmethod);
    6738. 

  6738.     return ole_method_invoke_kind(pmethod->pTypeInfo, pmethod->index);
    6739. 

  6739. }
    6740. 

  6740. 

  6741. static VALUE
    6742. 

  6742. ole_method_visible(ITypeInfo *pTypeInfo, UINT method_index)
    6743. 

  6743. {
    6744. 

  6744.     FUNCDESC *pFuncDesc;
    6745. 

  6745.     HRESULT hr;
    6746. 

  6746.     VALUE visible;
    6747. 

  6747.     hr = pTypeInfo->lpVtbl->GetFuncDesc(pTypeInfo, method_index, &pFuncDesc);
    6748. 

  6748.     if(FAILED(hr))
    6749. 

  6749.         return Qfalse;
    6750. 

  6750.     if (pFuncDesc->wFuncFlags & (FUNCFLAG_FRESTRICTED |
    6751. 

  6751.                                  FUNCFLAG_FHIDDEN |
    6752. 

  6752.                                  FUNCFLAG_FNONBROWSABLE)) {
    6753. 

  6753.         visible = Qfalse;
    6754. 

  6754.     } else {
    6755. 

  6755.         visible = Qtrue;
    6756. 

  6756.     }
    6757. 

  6757.     pTypeInfo->lpVtbl->ReleaseFuncDesc(pTypeInfo, pFuncDesc);
    6758. 

  6758.     return visible;
    6759. 

  6759. }
    6760. 

  6760. 

  6761. /*
    6762. 

  6762.  *  call-seq:
    6763. 

  6763.  *     WIN32OLE_METHOD#visible?
    6764. 

  6764.  * 
    6765. 

  6765.  *  Returns true if the method is public.
    6766. 

  6766.  *     tobj = WIN32OLE_TYPE.new('Microsoft Excel 9.0 Object Library', 'Workbooks')
    6767. 

  6767.  *     method = WIN32OLE_METHOD.new(tobj, 'Add')
    6768. 

  6768.  *     puts method.visible? # => true
    6769. 

  6769.  */
    6770. 

  6770. static VALUE
    6771. 

  6771. folemethod_visible(VALUE self)
    6772. 

  6772. {
    6773. 

  6773.     struct olemethoddata *pmethod;
    6774. 

  6774.     Data_Get_Struct(self, struct olemethoddata, pmethod);
    6775. 

  6775.     return ole_method_visible(pmethod->pTypeInfo, pmethod->index);
    6776. 

  6776. }
    6777. 

  6777. 

  6778. static VALUE
    6779. 

  6779. ole_method_event(ITypeInfo *pTypeInfo, UINT method_index, VALUE method_name)
    6780. 

  6780. {
    6781. 

  6781.     TYPEATTR *pTypeAttr;
    6782. 

  6782.     HRESULT hr;
    6783. 

  6783.     WORD i;
    6784. 

  6784.     int flags;
    6785. 

  6785.     HREFTYPE href;
    6786. 

  6786.     ITypeInfo *pRefTypeInfo;
    6787. 

  6787.     FUNCDESC *pFuncDesc;
    6788. 

  6788.     BSTR bstr;
    6789. 

  6789.     VALUE name;
    6790. 

  6790.     VALUE event = Qfalse;
    6791. 

  6791.     
    6792. 

  6792.     hr = OLE_GET_TYPEATTR(pTypeInfo, &pTypeAttr);
    6793. 

  6793.     if (FAILED(hr)) 
    6794. 

  6794.         return event;
    6795. 

  6795.     if(pTypeAttr->typekind != TKIND_COCLASS) {
    6796. 

  6796.         pTypeInfo->lpVtbl->ReleaseTypeAttr(pTypeInfo, pTypeAttr);
    6797. 

  6797.         return event;
    6798. 

  6798.     }
    6799. 

  6799.     for (i = 0; i < pTypeAttr->cImplTypes; i++) {
    6800. 

  6800.         hr = pTypeInfo->lpVtbl->GetImplTypeFlags(pTypeInfo, i, &flags);
    6801. 

  6801.         if (FAILED(hr))
    6802. 

  6802.             continue;
    6803. 

  6803. 

  6804.         if (flags & IMPLTYPEFLAG_FSOURCE) {
    6805. 

  6805.             hr = pTypeInfo->lpVtbl->GetRefTypeOfImplType(pTypeInfo,
    6806. 

  6806.                                                          i, &href);
    6807. 

  6807.             if (FAILED(hr))
    6808. 

  6808.                 continue;
    6809. 

  6809.             hr = pTypeInfo->lpVtbl->GetRefTypeInfo(pTypeInfo,
    6810. 

  6810.                                                    href, &pRefTypeInfo);
    6811. 

  6811.             if (FAILED(hr))
    6812. 

  6812.                 continue;
    6813. 

  6813.             hr = pRefTypeInfo->lpVtbl->GetFuncDesc(pRefTypeInfo, method_index, 
    6814. 

  6814.                                                    &pFuncDesc);
    6815. 

  6815.             if (FAILED(hr)) {
    6816. 

  6816.                 OLE_RELEASE(pRefTypeInfo);
    6817. 

  6817.                 continue;
    6818. 

  6818.             }
    6819. 

  6819. 

  6820.             hr = pRefTypeInfo->lpVtbl->GetDocumentation(pRefTypeInfo, 
    6821. 

  6821.                                                         pFuncDesc->memid,
    6822. 

  6822.                                                         &bstr, NULL, NULL, NULL);
    6823. 

  6823.             if (FAILED(hr)) {
    6824. 

  6824.                 pRefTypeInfo->lpVtbl->ReleaseFuncDesc(pRefTypeInfo, pFuncDesc);
    6825. 

  6825.                 OLE_RELEASE(pRefTypeInfo);
    6826. 

  6826.                 continue;
    6827. 

  6827.             }
    6828. 

  6828. 

  6829.             name = WC2VSTR(bstr);
    6830. 

  6830.             pRefTypeInfo->lpVtbl->ReleaseFuncDesc(pRefTypeInfo, pFuncDesc);
    6831. 

  6831.             OLE_RELEASE(pRefTypeInfo);
    6832. 

  6832.             if (rb_str_cmp(method_name, name) == 0) {
    6833. 

  6833.                 event = Qtrue;
    6834. 

  6834.                 break;
    6835. 

  6835.             }
    6836. 

  6836.         }
    6837. 

  6837.     }
    6838. 

  6838.     OLE_RELEASE_TYPEATTR(pTypeInfo, pTypeAttr);
    6839. 

  6839.     return event;
    6840. 

  6840. }
    6841. 

  6841. 

  6842. /*
    6843. 

  6843.  *  call-seq:
    6844. 

  6844.  *     WIN32OLE_METHOD#event?
    6845. 

  6845.  * 
    6846. 

  6846.  *  Returns true if the method is event.
    6847. 

  6847.  *     tobj = WIN32OLE_TYPE.new('Microsoft Excel 9.0 Object Library', 'Workbook')
    6848. 

  6848.  *     method = WIN32OLE_METHOD.new(tobj, 'SheetActivate')
    6849. 

  6849.  *     puts method.event? # => true
    6850. 

  6850.  *
    6851. 

  6851.  */
    6852. 

  6852. static VALUE
    6853. 

  6853. folemethod_event(VALUE self)
    6854. 

  6854. {
    6855. 

  6855.     struct olemethoddata *pmethod;
    6856. 

  6856.     Data_Get_Struct(self, struct olemethoddata, pmethod);
    6857. 

  6857.     if (!pmethod->pOwnerTypeInfo)
    6858. 

  6858.         return Qfalse;
    6859. 

  6859.     return ole_method_event(pmethod->pOwnerTypeInfo, 
    6860. 

  6860.                             pmethod->index,
    6861. 

  6861.                             rb_ivar_get(self, rb_intern("name")));
    6862. 

  6862. }
    6863. 

  6863. 

  6864. /*
    6865. 

  6865.  *  call-seq:
    6866. 

  6866.  *     WIN32OLE_METHOD#event_interface
    6867. 

  6867.  *
    6868. 

  6868.  *  Returns event interface name if the method is event.
    6869. 

  6869.  *    tobj = WIN32OLE_TYPE.new('Microsoft Excel 9.0 Object Library', 'Workbook')
    6870. 

  6870.  *    method = WIN32OLE_METHOD.new(tobj, 'SheetActivate')
    6871. 

  6871.  *    puts method.event_interface # =>  WorkbookEvents
    6872. 

  6872.  */
    6873. 

  6873. static VALUE
    6874. 

  6874. folemethod_event_interface(VALUE self)
    6875. 

  6875. {
    6876. 

  6876.     BSTR name;
    6877. 

  6877.     struct olemethoddata *pmethod;
    6878. 

  6878.     HRESULT hr;
    6879. 

  6879.     Data_Get_Struct(self, struct olemethoddata, pmethod);
    6880. 

  6880.     if(folemethod_event(self) == Qtrue) {
    6881. 

  6881.         hr = ole_docinfo_from_type(pmethod->pTypeInfo, &name, NULL, NULL, NULL);
    6882. 

  6882.         if(SUCCEEDED(hr))
    6883. 

  6883.             return WC2VSTR(name);
    6884. 

  6884.     }
    6885. 

  6885.     return Qnil;
    6886. 

  6886. }
    6887. 

  6887. 

  6888. static VALUE
    6889. 

  6889. ole_method_docinfo_from_type(
    6890. 

  6890.     ITypeInfo *pTypeInfo,
    6891. 

  6891.     UINT method_index,
    6892. 

  6892.     BSTR *name,
    6893. 

  6893.     BSTR *helpstr,
    6894. 

  6894.     DWORD *helpcontext,
    6895. 

  6895.     BSTR *helpfile
    6896. 

  6896.     )
    6897. 

  6897. {
    6898. 

  6898.     FUNCDESC *pFuncDesc;
    6899. 

  6899.     HRESULT hr;
    6900. 

  6900.     hr = pTypeInfo->lpVtbl->GetFuncDesc(pTypeInfo, method_index, &pFuncDesc);
    6901. 

  6901.     if (FAILED(hr))
    6902. 

  6902.         return hr;
    6903. 

  6903.     hr = pTypeInfo->lpVtbl->GetDocumentation(pTypeInfo, pFuncDesc->memid,
    6904. 

  6904.                                              name, helpstr,
    6905. 

  6905.                                              helpcontext, helpfile);
    6906. 

  6906.     pTypeInfo->lpVtbl->ReleaseFuncDesc(pTypeInfo, pFuncDesc);
    6907. 

  6907.     return hr;
    6908. 

  6908. }
    6909. 

  6909. 

  6910. static VALUE
    6911. 

  6911. ole_method_helpstring(ITypeInfo *pTypeInfo, UINT method_index)
    6912. 

  6912. {
    6913. 

  6913.     HRESULT hr;
    6914. 

  6914.     BSTR bhelpstring;
    6915. 

  6915.     hr = ole_method_docinfo_from_type(pTypeInfo, method_index, NULL, &bhelpstring,
    6916. 

  6916.                                       NULL, NULL); 
    6917. 

  6917.     if (FAILED(hr))
    6918. 

  6918.         return Qnil;
    6919. 

  6919.     return WC2VSTR(bhelpstring);
    6920. 

  6920. }
    6921. 

  6921. 

  6922. /*
    6923. 

  6923.  *  call-seq:
    6924. 

  6924.  *     WIN32OLE_METHOD#helpstring
    6925. 

  6925.  *
    6926. 

  6926.  *  Returns help string of OLE method. If the help string is not found, 
    6927. 

  6927.  *  then the method returns nil.
    6928. 

  6928.  *     tobj = WIN32OLE_TYPE.new('Microsoft Internet Controls', 'IWebBrowser')
    6929. 

  6929.  *     method = WIN32OLE_METHOD.new(tobj, 'Navigate')
    6930. 

  6930.  *     puts method.helpstring # => Navigates to a URL or file.
    6931. 

  6931.  *
    6932. 

  6932.  */
    6933. 

  6933. static VALUE
    6934. 

  6934. folemethod_helpstring(VALUE self)
    6935. 

  6935. {
    6936. 

  6936.     struct olemethoddata *pmethod;
    6937. 

  6937.     Data_Get_Struct(self, struct olemethoddata, pmethod);
    6938. 

  6938.     return ole_method_helpstring(pmethod->pTypeInfo, pmethod->index);
    6939. 

  6939. }
    6940. 

  6940. 

  6941. static VALUE
    6942. 

  6942. ole_method_helpfile(ITypeInfo *pTypeInfo, UINT method_index)
    6943. 

  6943. {
    6944. 

  6944.     HRESULT hr;
    6945. 

  6945.     BSTR bhelpfile;
    6946. 

  6946.     hr = ole_method_docinfo_from_type(pTypeInfo, method_index, NULL, NULL,
    6947. 

  6947.                                       NULL, &bhelpfile); 
    6948. 

  6948.     if (FAILED(hr))
    6949. 

  6949.         return Qnil;
    6950. 

  6950.     return WC2VSTR(bhelpfile);
    6951. 

  6951. }
    6952. 

  6952. 

  6953. /*
    6954. 

  6954.  *  call-seq:
    6955. 

  6955.  *     WIN32OLE_METHOD#helpfile
    6956. 

  6956.  * 
    6957. 

  6957.  *  Returns help file. If help file is not found, then 
    6958. 

  6958.  *  the method returns nil.
    6959. 

  6959.  *     tobj = WIN32OLE_TYPE.new('Microsoft Excel 9.0 Object Library', 'Workbooks')
    6960. 

  6960.  *     method = WIN32OLE_METHOD.new(tobj, 'Add')
    6961. 

  6961.  *     puts method.helpfile # => C:\...\VBAXL9.CHM
    6962. 

  6962.  */
    6963. 

  6963. static VALUE
    6964. 

  6964. folemethod_helpfile(VALUE self)
    6965. 

  6965. {
    6966. 

  6966.     struct olemethoddata *pmethod;
    6967. 

  6967.     Data_Get_Struct(self, struct olemethoddata, pmethod);
    6968. 

  6968. 

  6969.     return ole_method_helpfile(pmethod->pTypeInfo, pmethod->index);
    6970. 

  6970. }
    6971. 

  6971. 

  6972. static VALUE
    6973. 

  6973. ole_method_helpcontext(ITypeInfo *pTypeInfo, UINT method_index)
    6974. 

  6974. {
    6975. 

  6975.     HRESULT hr;
    6976. 

  6976.     DWORD helpcontext = 0;
    6977. 

  6977.     hr = ole_method_docinfo_from_type(pTypeInfo, method_index, NULL, NULL,
    6978. 

  6978.                                       &helpcontext, NULL); 
    6979. 

  6979.     if (FAILED(hr))
    6980. 

  6980.         return Qnil;
    6981. 

  6981.     return INT2FIX(helpcontext);
    6982. 

  6982. }
    6983. 

  6983. 

  6984. /* 
    6985. 

  6985.  *  call-seq:
    6986. 

  6986.  *     WIN32OLE_METHOD#helpcontext
    6987. 

  6987.  * 
    6988. 

  6988.  *  Returns help context.
    6989. 

  6989.  *     tobj = WIN32OLE_TYPE.new('Microsoft Excel 9.0 Object Library', 'Workbooks')
    6990. 

  6990.  *     method = WIN32OLE_METHOD.new(tobj, 'Add')
    6991. 

  6991.  *     puts method.helpcontext # => 65717
    6992. 

  6992.  */
    6993. 

  6993. static VALUE
    6994. 

  6994. folemethod_helpcontext(VALUE self)
    6995. 

  6995. {
    6996. 

  6996.     struct olemethoddata *pmethod;
    6997. 

  6997.     Data_Get_Struct(self, struct olemethoddata, pmethod);
    6998. 

  6998.     return ole_method_helpcontext(pmethod->pTypeInfo, pmethod->index);
    6999. 

  6999. }
    7000. 

  7000. 

  7001. static VALUE
    7002. 

  7002. ole_method_dispid(ITypeInfo *pTypeInfo, UINT method_index)
    7003. 

  7003. {
    7004. 

  7004.     FUNCDESC *pFuncDesc;
    7005. 

  7005.     HRESULT hr;
    7006. 

  7006.     VALUE dispid = Qnil;
    7007. 

  7007.     hr = pTypeInfo->lpVtbl->GetFuncDesc(pTypeInfo, method_index, &pFuncDesc);
    7008. 

  7008.     if (FAILED(hr))
    7009. 

  7009.         return dispid;
    7010. 

  7010.     dispid = INT2NUM(pFuncDesc->memid); 
    7011. 

  7011.     pTypeInfo->lpVtbl->ReleaseFuncDesc(pTypeInfo, pFuncDesc);
    7012. 

  7012.     return dispid;
    7013. 

  7013. }
    7014. 

  7014. 

  7015. /*
    7016. 

  7016.  *  call-seq:
    7017. 

  7017.  *     WIN32OLE_METHOD#dispid
    7018. 

  7018.  * 
    7019. 

  7019.  *  Returns dispatch ID.
    7020. 

  7020.  *     tobj = WIN32OLE_TYPE.new('Microsoft Excel 9.0 Object Library', 'Workbooks')
    7021. 

  7021.  *     method = WIN32OLE_METHOD.new(tobj, 'Add')
    7022. 

  7022.  *     puts method.dispid # => 181
    7023. 

  7023.  */
    7024. 

  7024. static VALUE
    7025. 

  7025. folemethod_dispid(VALUE self)
    7026. 

  7026. {
    7027. 

  7027.     struct olemethoddata *pmethod;
    7028. 

  7028.     Data_Get_Struct(self, struct olemethoddata, pmethod);
    7029. 

  7029.     return ole_method_dispid(pmethod->pTypeInfo, pmethod->index);
    7030. 

  7030. }
    7031. 

  7031. 

  7032. static VALUE
    7033. 

  7033. ole_method_offset_vtbl(ITypeInfo *pTypeInfo, UINT method_index)
    7034. 

  7034. {
    7035. 

  7035.     FUNCDESC *pFuncDesc;
    7036. 

  7036.     HRESULT hr;
    7037. 

  7037.     VALUE offset_vtbl = Qnil;
    7038. 

  7038.     hr = pTypeInfo->lpVtbl->GetFuncDesc(pTypeInfo, method_index, &pFuncDesc);
    7039. 

  7039.     if (FAILED(hr))
    7040. 

  7040.         return offset_vtbl;
    7041. 

  7041.     offset_vtbl = INT2FIX(pFuncDesc->oVft); 
    7042. 

  7042.     pTypeInfo->lpVtbl->ReleaseFuncDesc(pTypeInfo, pFuncDesc);
    7043. 

  7043.     return offset_vtbl;
    7044. 

  7044. }
    7045. 

  7045. 

  7046. /*
    7047. 

  7047.  *  call-seq:
    7048. 

  7048.  *     WIN32OLE_METHOD#offset_vtbl
    7049. 

  7049.  * 
    7050. 

  7050.  *  Returns the offset ov VTBL.
    7051. 

  7051.  *     tobj = WIN32OLE_TYPE.new('Microsoft Excel 9.0 Object Library', 'Workbooks')
    7052. 

  7052.  *     method = WIN32OLE_METHOD.new(tobj, 'Add')
    7053. 

  7053.  *     puts method.offset_vtbl # => 40
    7054. 

  7054.  */
    7055. 

  7055. static VALUE
    7056. 

  7056. folemethod_offset_vtbl(VALUE self)
    7057. 

  7057. {
    7058. 

  7058.     struct olemethoddata *pmethod;
    7059. 

  7059.     Data_Get_Struct(self, struct olemethoddata, pmethod);
    7060. 

  7060.     return ole_method_offset_vtbl(pmethod->pTypeInfo, pmethod->index);
    7061. 

  7061. }
    7062. 

  7062. 

  7063. static VALUE
    7064. 

  7064. ole_method_size_params(ITypeInfo *pTypeInfo, UINT method_index)
    7065. 

  7065. {
    7066. 

  7066.     FUNCDESC *pFuncDesc;
    7067. 

  7067.     HRESULT hr;
    7068. 

  7068.     VALUE size_params = Qnil;
    7069. 

  7069.     hr = pTypeInfo->lpVtbl->GetFuncDesc(pTypeInfo, method_index, &pFuncDesc);
    7070. 

  7070.     if (FAILED(hr))
    7071. 

  7071.         return size_params;
    7072. 

  7072.     size_params = INT2FIX(pFuncDesc->cParams);
    7073. 

  7073.     pTypeInfo->lpVtbl->ReleaseFuncDesc(pTypeInfo, pFuncDesc);
    7074. 

  7074.     return size_params;
    7075. 

  7075. }
    7076. 

  7076. 

  7077. /*
    7078. 

  7078.  *  call-seq:
    7079. 

  7079.  *     WIN32OLE_METHOD#size_params
    7080. 

  7080.  * 
    7081. 

  7081.  *  Returns the size of arguments of the method.
    7082. 

  7082.  *     tobj = WIN32OLE_TYPE.new('Microsoft Excel 9.0 Object Library', 'Workbook')
    7083. 

  7083.  *     method = WIN32OLE_METHOD.new(tobj, 'SaveAs')
    7084. 

  7084.  *     puts method.size_params # => 11
    7085. 

  7085.  *  
    7086. 

  7086.  */
    7087. 

  7087. static VALUE
    7088. 

  7088. folemethod_size_params(VALUE self)
    7089. 

  7089. {
    7090. 

  7090.     struct olemethoddata *pmethod;
    7091. 

  7091.     Data_Get_Struct(self, struct olemethoddata, pmethod);
    7092. 

  7092.     return ole_method_size_params(pmethod->pTypeInfo, pmethod->index);
    7093. 

  7093. }
    7094. 

  7094. 

  7095. static VALUE
    7096. 

  7096. ole_method_size_opt_params(ITypeInfo *pTypeInfo, UINT method_index)
    7097. 

  7097. {
    7098. 

  7098.     FUNCDESC *pFuncDesc;
    7099. 

  7099.     HRESULT hr;
    7100. 

  7100.     VALUE size_opt_params = Qnil;
    7101. 

  7101.     hr = pTypeInfo->lpVtbl->GetFuncDesc(pTypeInfo, method_index, &pFuncDesc);
    7102. 

  7102.     if (FAILED(hr))
    7103. 

  7103.         return size_opt_params;
    7104. 

  7104.     size_opt_params = INT2FIX(pFuncDesc->cParamsOpt);
    7105. 

  7105.     pTypeInfo->lpVtbl->ReleaseFuncDesc(pTypeInfo, pFuncDesc);
    7106. 

  7106.     return size_opt_params;
    7107. 

  7107. }
    7108. 

  7108. 

  7109. /*
    7110. 

  7110.  *  call-seq:
    7111. 

  7111.  *     WIN32OLE_METHOD#size_opt_params
    7112. 

  7112.  * 
    7113. 

  7113.  *  Returns the size of optional parameters.
    7114. 

  7114.  *     tobj = WIN32OLE_TYPE.new('Microsoft Excel 9.0 Object Library', 'Workbook')
    7115. 

  7115.  *     method = WIN32OLE_METHOD.new(tobj, 'SaveAs')
    7116. 

  7116.  *     puts method.size_opt_params # => 4
    7117. 

  7117.  */
    7118. 

  7118. static VALUE
    7119. 

  7119. folemethod_size_opt_params(VALUE self)
    7120. 

  7120. {
    7121. 

  7121.     struct olemethoddata *pmethod;
    7122. 

  7122.     Data_Get_Struct(self, struct olemethoddata, pmethod);
    7123. 

  7123.     return ole_method_size_opt_params(pmethod->pTypeInfo, pmethod->index);
    7124. 

  7124. }
    7125. 

  7125. 

  7126. static VALUE
    7127. 

  7127. ole_method_params(ITypeInfo *pTypeInfo, UINT method_index)
    7128. 

  7128. {
    7129. 

  7129.     FUNCDESC *pFuncDesc;
    7130. 

  7130.     HRESULT hr;
    7131. 

  7131.     BSTR *bstrs;
    7132. 

  7132.     UINT len, i;
    7133. 

  7133.     struct oleparamdata *pparam;
    7134. 

  7134.     VALUE param;
    7135. 

  7135.     VALUE params = rb_ary_new();
    7136. 

  7136.     hr = pTypeInfo->lpVtbl->GetFuncDesc(pTypeInfo, method_index, &pFuncDesc);
    7137. 

  7137.     if (FAILED(hr)) 
    7138. 

  7138.         return params;
    7139. 

  7139. 

  7140.     len = 0;
    7141. 

  7141.     bstrs = ALLOCA_N(BSTR, pFuncDesc->cParams + 1);
    7142. 

  7142.     hr = pTypeInfo->lpVtbl->GetNames(pTypeInfo, pFuncDesc->memid, 
    7143. 

  7143.                                      bstrs, pFuncDesc->cParams + 1,
    7144. 

  7144.                                      &len);
    7145. 

  7145.     if (FAILED(hr)) {
    7146. 

  7146.         pTypeInfo->lpVtbl->ReleaseFuncDesc(pTypeInfo, pFuncDesc);
    7147. 

  7147.         return params;
    7148. 

  7148.     }
    7149. 

  7149.     SysFreeString(bstrs[0]);
    7150. 

  7150.     if (pFuncDesc->cParams > 0) {
    7151. 

  7151.         for(i = 1; i < len; i++) {
    7152. 

  7152.             param = Data_Make_Struct(cWIN32OLE_PARAM, struct oleparamdata, 0,
    7153. 

  7153.                                      oleparam_free, pparam);
    7154. 

  7154.             pparam->pTypeInfo = pTypeInfo;
    7155. 

  7155.             OLE_ADDREF(pTypeInfo);
    7156. 

  7156.             pparam->method_index = method_index;
    7157. 

  7157.             pparam->index = i - 1;
    7158. 

  7158.             rb_ivar_set(param, rb_intern("name"), WC2VSTR(bstrs[i]));
    7159. 

  7159.             rb_ary_push(params, param);
    7160. 

  7160.          }
    7161. 

  7161.      }
    7162. 

  7162.      pTypeInfo->lpVtbl->ReleaseFuncDesc(pTypeInfo, pFuncDesc);
    7163. 

  7163.      return params;
    7164. 

  7164. }
    7165. 

  7165. 

  7166. 

  7167. /*
    7168. 

  7168.  *  call-seq:
    7169. 

  7169.  *     WIN32OLE_METHOD#params
    7170. 

  7170.  * 
    7171. 

  7171.  *  returns array of WIN32OLE_PARAM object corresponding with method parameters.
    7172. 

  7172.  *     tobj = WIN32OLE_TYPE.new('Microsoft Excel 9.0 Object Library', 'Workbook')
    7173. 

  7173.  *     method = WIN32OLE_METHOD.new(tobj, 'SaveAs')
    7174. 

  7174.  *     p method.params # => [Filename, FileFormat, Password, WriteResPassword, 
    7175. 

  7175.  *                           ReadOnlyRecommended, CreateBackup, AccessMode, 
    7176. 

  7176.  *                           ConflictResolution, AddToMru, TextCodepage, 
    7177. 

  7177.  *                           TextVisualLayout]
    7178. 

  7178.  */
    7179. 

  7179. static VALUE
    7180. 

  7180. folemethod_params(VALUE self)
    7181. 

  7181. {
    7182. 

  7182.     struct olemethoddata *pmethod;
    7183. 

  7183.     Data_Get_Struct(self, struct olemethoddata, pmethod);
    7184. 

  7184.     return ole_method_params(pmethod->pTypeInfo, pmethod->index);
    7185. 

  7185. }
    7186. 

  7186. 

  7187. /*
    7188. 

  7188.  *  call-seq:
    7189. 

  7189.  *     WIN32OLE_METHOD#inspect -> String
    7190. 

  7190.  *
    7191. 

  7191.  *  Returns the method name with class name.
    7192. 

  7192.  *
    7193. 

  7193.  */
    7194. 

  7194. static VALUE
    7195. 

  7195. folemethod_inspect(VALUE self)
    7196. 

  7196. {
    7197. 

  7197.     return default_inspect(self, "WIN32OLE_METHOD");
    7198. 

  7198. }
    7199. 

  7199. 

  7200. /*
    7201. 

  7201.  * Document-class: WIN32OLE_PARAM
    7202. 

  7202.  *
    7203. 

  7203.  *   <code>WIN32OLE_PARAM</code> objects represent param information of 
    7204. 

  7204.  *   the OLE method.
    7205. 

  7205.  */
    7206. 

  7206. static VALUE foleparam_s_allocate(VALUE klass)
    7207. 

  7207. {
    7208. 

  7208.     struct oleparamdata *pparam;
    7209. 

  7209.     VALUE obj;
    7210. 

  7210.     obj = Data_Make_Struct(klass, 
    7211. 

  7211.                            struct oleparamdata,
    7212. 

  7212.                            0, oleparam_free, pparam);
    7213. 

  7213.     pparam->pTypeInfo = NULL;
    7214. 

  7214.     pparam->method_index = 0;
    7215. 

  7215.     pparam->index = 0;
    7216. 

  7216.     return obj;
    7217. 

  7217. }
    7218. 

  7218. 

  7219. static VALUE 
    7220. 

  7220. oleparam_ole_param_from_index(VALUE self, ITypeInfo *pTypeInfo, UINT method_index, int param_index)
    7221. 

  7221. {
    7222. 

  7222.     FUNCDESC *pFuncDesc;
    7223. 

  7223.     HRESULT hr;
    7224. 

  7224.     BSTR *bstrs;
    7225. 

  7225.     UINT len;
    7226. 

  7226.     struct oleparamdata *pparam;
    7227. 

  7227.     hr = pTypeInfo->lpVtbl->GetFuncDesc(pTypeInfo, method_index, &pFuncDesc);
    7228. 

  7228.     if (FAILED(hr)) 
    7229. 

  7229.         ole_raise(hr, rb_eRuntimeError, "fail to ITypeInfo::GetFuncDesc");
    7230. 

  7230. 

  7231.     len = 0;
    7232. 

  7232.     bstrs = ALLOCA_N(BSTR, pFuncDesc->cParams + 1);
    7233. 

  7233.     hr = pTypeInfo->lpVtbl->GetNames(pTypeInfo, pFuncDesc->memid, 
    7234. 

  7234.                                      bstrs, pFuncDesc->cParams + 1,
    7235. 

  7235.                                      &len);
    7236. 

  7236.     if (FAILED(hr)) {
    7237. 

  7237.         pTypeInfo->lpVtbl->ReleaseFuncDesc(pTypeInfo, pFuncDesc);
    7238. 

  7238.         ole_raise(hr, rb_eRuntimeError, "fail to ITypeInfo::GetNames");
    7239. 

  7239.     }
    7240. 

  7240.     SysFreeString(bstrs[0]);
    7241. 

  7241.     if (param_index < 1 || len <= (UINT)param_index)
    7242. 

  7242.     {
    7243. 

  7243.         pTypeInfo->lpVtbl->ReleaseFuncDesc(pTypeInfo, pFuncDesc);
    7244. 

  7244.         rb_raise(rb_eIndexError, "index of param must be in 1..%d", len);
    7245. 

  7245.     }
    7246. 

  7246. 

  7247.     Data_Get_Struct(self, struct oleparamdata, pparam);
    7248. 

  7248.     pparam->pTypeInfo = pTypeInfo;
    7249. 

  7249.     OLE_ADDREF(pTypeInfo);
    7250. 

  7250.     pparam->method_index = method_index;
    7251. 

  7251.     pparam->index = param_index - 1;
    7252. 

  7252.     rb_ivar_set(self, rb_intern("name"), WC2VSTR(bstrs[param_index]));
    7253. 

  7253. 

  7254.     pTypeInfo->lpVtbl->ReleaseFuncDesc(pTypeInfo, pFuncDesc);
    7255. 

  7255.     return self;
    7256. 

  7256. }
    7257. 

  7257. 

  7258. static VALUE oleparam_ole_param(VALUE self, VALUE olemethod, int n)
    7259. 

  7259. {
    7260. 

  7260.     struct olemethoddata *pmethod;
    7261. 

  7261.     Data_Get_Struct(olemethod, struct olemethoddata, pmethod);
    7262. 

  7262.     return oleparam_ole_param_from_index(self, pmethod->pTypeInfo, pmethod->index, n);
    7263. 

  7263. }
    7264. 

  7264. 

  7265. static VALUE foleparam_initialize(VALUE self, VALUE olemethod, VALUE n)
    7266. 

  7266. {
    7267. 

  7267.     int idx;
    7268. 

  7268.     if (!rb_obj_is_kind_of(olemethod, cWIN32OLE_METHOD)) {
    7269. 

  7269.         rb_raise(rb_eTypeError, "1st parameter must be WIN32OLE_METHOD object");
    7270. 

  7270.     }
    7271. 

  7271.     idx = FIX2INT(n);
    7272. 

  7272.     return oleparam_ole_param(self, olemethod, idx);
    7273. 

  7273. }
    7274. 

  7274. 

  7275. /*
    7276. 

  7276.  *  call-seq:
    7277. 

  7277.  *     WIN32OLE_PARAM#name
    7278. 

  7278.  * 
    7279. 

  7279.  *  Returns name.
    7280. 

  7280.  *     tobj = WIN32OLE_TYPE.new('Microsoft Excel 9.0 Object Library', 'Workbook')
    7281. 

  7281.  *     method = WIN32OLE_METHOD.new(tobj, 'SaveAs')
    7282. 

  7282.  *     param1 = method.params[0]
    7283. 

  7283.  *     puts param1.name # => Filename
    7284. 

  7284.  */
    7285. 

  7285. static VALUE
    7286. 

  7286. foleparam_name(VALUE self)
    7287. 

  7287. {
    7288. 

  7288.     return rb_ivar_get(self, rb_intern("name"));
    7289. 

  7289. }
    7290. 

  7290. 

  7291. static VALUE
    7292. 

  7292. ole_param_ole_type(ITypeInfo *pTypeInfo, UINT method_index, UINT index)
    7293. 

  7293. {
    7294. 

  7294.     FUNCDESC *pFuncDesc;
    7295. 

  7295.     HRESULT hr;
    7296. 

  7296.     VALUE type = rb_str_new2("unknown type");
    7297. 

  7297.     hr = pTypeInfo->lpVtbl->GetFuncDesc(pTypeInfo, method_index, &pFuncDesc);
    7298. 

  7298.     if (FAILED(hr))
    7299. 

  7299.         return type;
    7300. 

  7300.     type = ole_typedesc2val(pTypeInfo, 
    7301. 

  7301.                             &(pFuncDesc->lprgelemdescParam[index].tdesc), Qnil);
    7302. 

  7302.     pTypeInfo->lpVtbl->ReleaseFuncDesc(pTypeInfo, pFuncDesc);
    7303. 

  7303.     return type;
    7304. 

  7304. }
    7305. 

  7305. 

  7306. /*
    7307. 

  7307.  *  call-seq:
    7308. 

  7308.  *     WIN32OLE_PARAM#ole_type
    7309. 

  7309.  *
    7310. 

  7310.  *  Returns OLE type of WIN32OLE_PARAM object(parameter of OLE method).
    7311. 

  7311.  *     tobj = WIN32OLE_TYPE.new('Microsoft Excel 9.0 Object Library', 'Workbook')
    7312. 

  7312.  *     method = WIN32OLE_METHOD.new(tobj, 'SaveAs')
    7313. 

  7313.  *     param1 = method.params[0]
    7314. 

  7314.  *     puts param1.ole_type # => VARIANT
    7315. 

  7315.  */
    7316. 

  7316. static VALUE 
    7317. 

  7317. foleparam_ole_type(VALUE self)
    7318. 

  7318. {
    7319. 

  7319.     struct oleparamdata *pparam;
    7320. 

  7320.     Data_Get_Struct(self, struct oleparamdata, pparam);
    7321. 

  7321.     return ole_param_ole_type(pparam->pTypeInfo, pparam->method_index, 
    7322. 

  7322.                               pparam->index);
    7323. 

  7323. }
    7324. 

  7324. 

  7325. static VALUE
    7326. 

  7326. ole_param_ole_type_detail(ITypeInfo *pTypeInfo, UINT method_index, UINT index)
    7327. 

  7327. {
    7328. 

  7328.     FUNCDESC *pFuncDesc;
    7329. 

  7329.     HRESULT hr;
    7330. 

  7330.     VALUE typedetail = rb_ary_new();
    7331. 

  7331.     hr = pTypeInfo->lpVtbl->GetFuncDesc(pTypeInfo, method_index, &pFuncDesc);
    7332. 

  7332.     if (FAILED(hr))
    7333. 

  7333.         return typedetail;
    7334. 

  7334.     ole_typedesc2val(pTypeInfo, 
    7335. 

  7335.                      &(pFuncDesc->lprgelemdescParam[index].tdesc), typedetail);
    7336. 

  7336.     pTypeInfo->lpVtbl->ReleaseFuncDesc(pTypeInfo, pFuncDesc);
    7337. 

  7337.     return typedetail;
    7338. 

  7338. }
    7339. 

  7339. 

  7340. /*
    7341. 

  7341.  *  call-seq:
    7342. 

  7342.  *     WIN32OLE_PARAM#ole_type_detail
    7343. 

  7343.  *
    7344. 

  7344.  *  Returns detail information of type of argument.
    7345. 

  7345.  *     tobj = WIN32OLE_TYPE.new('Microsoft Excel 9.0 Object Library', 'IWorksheetFunction')
    7346. 

  7346.  *     method = WIN32OLE_METHOD.new(tobj, 'SumIf')
    7347. 

  7347.  *     param1 = method.params[0]
    7348. 

  7348.  *     p param1.ole_type_detail # => ["PTR", "USERDEFINED", "Range"]
    7349. 

  7349.  */
    7350. 

  7350. static VALUE 
    7351. 

  7351. foleparam_ole_type_detail(VALUE self)
    7352. 

  7352. {
    7353. 

  7353.     struct oleparamdata *pparam;
    7354. 

  7354.     Data_Get_Struct(self, struct oleparamdata, pparam);
    7355. 

  7355.     return ole_param_ole_type_detail(pparam->pTypeInfo, pparam->method_index, 
    7356. 

  7356.                                      pparam->index);
    7357. 

  7357. }
    7358. 

  7358. 

  7359. static VALUE
    7360. 

  7360. ole_param_flag_mask(ITypeInfo *pTypeInfo, UINT method_index, UINT index, USHORT mask)
    7361. 

  7361. {
    7362. 

  7362.     FUNCDESC *pFuncDesc;
    7363. 

  7363.     HRESULT hr;
    7364. 

  7364.     VALUE ret = Qfalse;
    7365. 

  7365.     hr = pTypeInfo->lpVtbl->GetFuncDesc(pTypeInfo, method_index, &pFuncDesc);
    7366. 

  7366.     if(FAILED(hr)) 
    7367. 

  7367.         return ret;
    7368. 

  7368.     if (V_UNION1((&(pFuncDesc->lprgelemdescParam[index])), paramdesc).wParamFlags &mask) 
    7369. 

  7369.         ret = Qtrue;
    7370. 

  7370.     pTypeInfo->lpVtbl->ReleaseFuncDesc(pTypeInfo, pFuncDesc);
    7371. 

  7371.     return ret;
    7372. 

  7372. }
    7373. 

  7373. 

  7374. /*
    7375. 

  7375.  *  call-seq:
    7376. 

  7376.  *     WIN32OLE_PARAM#input?
    7377. 

  7377.  * 
    7378. 

  7378.  *  Returns true if the parameter is input.
    7379. 

  7379.  *     tobj = WIN32OLE_TYPE.new('Microsoft Excel 9.0 Object Library', 'Workbook')
    7380. 

  7380.  *     method = WIN32OLE_METHOD.new(tobj, 'SaveAs')
    7381. 

  7381.  *     param1 = method.params[0]
    7382. 

  7382.  *     puts param1.input? # => true
    7383. 

  7383.  */
    7384. 

  7384. static VALUE foleparam_input(VALUE self)
    7385. 

  7385. {
    7386. 

  7386.     struct oleparamdata *pparam;
    7387. 

  7387.     Data_Get_Struct(self, struct oleparamdata, pparam);
    7388. 

  7388.     return ole_param_flag_mask(pparam->pTypeInfo, pparam->method_index, 
    7389. 

  7389.                                pparam->index, PARAMFLAG_FIN);
    7390. 

  7390. }
    7391. 

  7391. 

  7392. /*
    7393. 

  7393.  *  call-seq:
    7394. 

  7394.  *     WIN32OLE#output?
    7395. 

  7395.  * 
    7396. 

  7396.  *  Returns true if argument is output.
    7397. 

  7397.  *     tobj = WIN32OLE_TYPE.new('Microsoft Internet Controls', 'DWebBrowserEvents')
    7398. 

  7398.  *     method = WIN32OLE_METHOD.new(tobj, 'NewWindow')
    7399. 

  7399.  *     method.params.each do |param|
    7400. 

  7400.  *       puts "#{param.name} #{param.output?}"
    7401. 

  7401.  *     end
    7402. 

  7402.  *
    7403. 

  7403.  *     The result of above script is following:
    7404. 

  7404.  *       URL false
    7405. 

  7405.  *       Flags false
    7406. 

  7406.  *       TargetFrameName false
    7407. 

  7407.  *       PostData false
    7408. 

  7408.  *       Headers false
    7409. 

  7409.  *       Processed true
    7410. 

  7410.  */
    7411. 

  7411. static VALUE foleparam_output(VALUE self)
    7412. 

  7412. {
    7413. 

  7413.     struct oleparamdata *pparam;
    7414. 

  7414.     Data_Get_Struct(self, struct oleparamdata, pparam);
    7415. 

  7415.     return ole_param_flag_mask(pparam->pTypeInfo, pparam->method_index, 
    7416. 

  7416.                                pparam->index, PARAMFLAG_FOUT);
    7417. 

  7417. }
    7418. 

  7418. 

  7419. /*
    7420. 

  7420.  *  call-seq:
    7421. 

  7421.  *     WIN32OLE_PARAM#optional?
    7422. 

  7422.  * 
    7423. 

  7423.  *  Returns true if argument is optional.
    7424. 

  7424.  *     tobj = WIN32OLE_TYPE.new('Microsoft Excel 9.0 Object Library', 'Workbook')
    7425. 

  7425.  *     method = WIN32OLE_METHOD.new(tobj, 'SaveAs')
    7426. 

  7426.  *     param1 = method.params[0]
    7427. 

  7427.  *     puts "#{param1.name} #{param1.optional?}" # => Filename true
    7428. 

  7428.  */
    7429. 

  7429. static VALUE foleparam_optional(VALUE self)
    7430. 

  7430. {
    7431. 

  7431.     struct oleparamdata *pparam;
    7432. 

  7432.     Data_Get_Struct(self, struct oleparamdata, pparam);
    7433. 

  7433.     return ole_param_flag_mask(pparam->pTypeInfo, pparam->method_index, 
    7434. 

  7434.                                pparam->index, PARAMFLAG_FOPT);
    7435. 

  7435. }
    7436. 

  7436. 

  7437. /*
    7438. 

  7438.  *  call-seq:
    7439. 

  7439.  *     WIN32OLE_PARAM#retval?
    7440. 

  7440.  *
    7441. 

  7441.  *  Returns true if argument is return value.
    7442. 

  7442.  *     tobj = WIN32OLE_TYPE.new('DirectX 7 for Visual Basic Type Library', 
    7443. 

  7443.  *                              'DirectPlayLobbyConnection')
    7444. 

  7444.  *     method = WIN32OLE_METHOD.new(tobj, 'GetPlayerShortName')
    7445. 

  7445.  *     param = method.params[0]
    7446. 

  7446.  *     puts "#{param.name} #{param.retval?}"  # => name true
    7447. 

  7447.  */
    7448. 

  7448. static VALUE foleparam_retval(VALUE self)
    7449. 

  7449. {
    7450. 

  7450.     struct oleparamdata *pparam;
    7451. 

  7451.     Data_Get_Struct(self, struct oleparamdata, pparam);
    7452. 

  7452.     return ole_param_flag_mask(pparam->pTypeInfo, pparam->method_index, 
    7453. 

  7453.                                pparam->index, PARAMFLAG_FRETVAL);
    7454. 

  7454. }
    7455. 

  7455. 

  7456. static VALUE
    7457. 

  7457. ole_param_default(ITypeInfo *pTypeInfo, UINT method_index, UINT index)
    7458. 

  7458. {
    7459. 

  7459.     FUNCDESC *pFuncDesc;
    7460. 

  7460.     ELEMDESC *pElemDesc;
    7461. 

  7461.     PARAMDESCEX * pParamDescEx;
    7462. 

  7462.     HRESULT hr;
    7463. 

  7463.     USHORT wParamFlags;
    7464. 

  7464.     USHORT mask = PARAMFLAG_FOPT|PARAMFLAG_FHASDEFAULT;
    7465. 

  7465.     VALUE defval = Qnil;
    7466. 

  7466.     hr = pTypeInfo->lpVtbl->GetFuncDesc(pTypeInfo, method_index, &pFuncDesc);
    7467. 

  7467.     if (FAILED(hr))
    7468. 

  7468.         return defval;
    7469. 

  7469.     pElemDesc = &pFuncDesc->lprgelemdescParam[index]; 
    7470. 

  7470.     wParamFlags = V_UNION1(pElemDesc, paramdesc).wParamFlags;
    7471. 

  7471.     if ((wParamFlags & mask) == mask) {
    7472. 

  7472.          pParamDescEx = V_UNION1(pElemDesc, paramdesc).pparamdescex;
    7473. 

  7473.          defval = ole_variant2val(&pParamDescEx->varDefaultValue);
    7474. 

  7474.     }
    7475. 

  7475.     pTypeInfo->lpVtbl->ReleaseFuncDesc(pTypeInfo, pFuncDesc);
    7476. 

  7476.     return defval;
    7477. 

  7477. }
    7478. 

  7478. 

  7479. /*
    7480. 

  7480.  *  call-seq:
    7481. 

  7481.  *     WIN32OLE_PARAM#default
    7482. 

  7482.  * 
    7483. 

  7483.  *  Returns default value. If the default value does not exist, 
    7484. 

  7484.  *  this method returns nil.
    7485. 

  7485.  *     tobj = WIN32OLE_TYPE.new('Microsoft Excel 9.0 Object Library', 'Workbook')
    7486. 

  7486.  *     method = WIN32OLE_METHOD.new(tobj, 'SaveAs')
    7487. 

  7487.  *     method.params.each do |param|
    7488. 

  7488.  *       if param.default
    7489. 

  7489.  *         puts "#{param.name} (= #{param.default})"
    7490. 

  7490.  *       else
    7491. 

  7491.  *         puts "#{param}"
    7492. 

  7492.  *       end
    7493. 

  7493.  *     end
    7494. 

  7494.  *
    7495. 

  7495.  *     The above script result is following:
    7496. 

  7496.  *         Filename
    7497. 

  7497.  *         FileFormat
    7498. 

  7498.  *         Password
    7499. 

  7499.  *         WriteResPassword
    7500. 

  7500.  *         ReadOnlyRecommended
    7501. 

  7501.  *         CreateBackup
    7502. 

  7502.  *         AccessMode (= 1)
    7503. 

  7503.  *         ConflictResolution
    7504. 

  7504.  *         AddToMru
    7505. 

  7505.  *         TextCodepage
    7506. 

  7506.  *         TextVisualLayout
    7507. 

  7507.  */
    7508. 

  7508. static VALUE foleparam_default(VALUE self)
    7509. 

  7509. {
    7510. 

  7510.     struct oleparamdata *pparam;
    7511. 

  7511.     Data_Get_Struct(self, struct oleparamdata, pparam);
    7512. 

  7512.     return ole_param_default(pparam->pTypeInfo, pparam->method_index,
    7513. 

  7513.                              pparam->index);
    7514. 

  7514. }
    7515. 

  7515. 

  7516. /*
    7517. 

  7517.  *  call-seq:
    7518. 

  7518.  *     WIN32OLE_PARAM#inspect -> String
    7519. 

  7519.  *
    7520. 

  7520.  *  Returns the parameter name with class name. If the parameter has default value,
    7521. 

  7521.  *  then returns name=value string with class name.
    7522. 

  7522.  *
    7523. 

  7523.  */
    7524. 

  7524. static VALUE
    7525. 

  7525. foleparam_inspect(VALUE self)
    7526. 

  7526. {
    7527. 

  7527.     VALUE detail = foleparam_name(self);
    7528. 

  7528.     VALUE defval = foleparam_default(self);
    7529. 

  7529.     if (defval != Qnil) {
    7530. 

  7530.         rb_str_cat2(detail, "=");
    7531. 

  7531.         rb_str_concat(detail, rb_funcall(defval, rb_intern("inspect"), 0));
    7532. 

  7532.     }
    7533. 

  7533.     return make_inspect("WIN32OLE_PARAM", detail);
    7534. 

  7534. }
    7535. 

  7535.   
    7536. 

  7536. /*
    7537. 

  7537.  * Document-class: WIN32OLE_EVENT
    7538. 

  7538.  *
    7539. 

  7539.  *   <code>WIN32OLE_EVENT</code> objects controls OLE event.
    7540. 

  7540.  */
    7541. 

  7541. 

  7542. static IEventSinkVtbl vtEventSink;
    7543. 

  7543. static BOOL g_IsEventSinkVtblInitialized = FALSE;
    7544. 

  7544. 

  7545. void EVENTSINK_Destructor(PIEVENTSINKOBJ);
    7546. 

  7546. 

  7547. STDMETHODIMP
    7548. 

  7548. EVENTSINK_QueryInterface(
    7549. 

  7549.     PEVENTSINK pEV,
    7550. 

  7550.     REFIID     iid,
    7551. 

  7551.     LPVOID*    ppv
    7552. 

  7552.     ) {
    7553. 

  7553.     if (IsEqualIID(iid, &IID_IUnknown) ||
    7554. 

  7554.         IsEqualIID(iid, &IID_IDispatch) ||
    7555. 

  7555.         IsEqualIID(iid, &((PIEVENTSINKOBJ)pEV)->m_iid)) {
    7556. 

  7556.         *ppv = pEV;
    7557. 

  7557.     }
    7558. 

  7558.     else {
    7559. 

  7559.         *ppv = NULL;
    7560. 

  7560.         return E_NOINTERFACE;
    7561. 

  7561.     }
    7562. 

  7562.     ((LPUNKNOWN)*ppv)->lpVtbl->AddRef((LPUNKNOWN)*ppv);
    7563. 

  7563.     return NOERROR;
    7564. 

  7564. }
    7565. 

  7565. 

  7566. STDMETHODIMP_(ULONG)
    7567. 

  7567. EVENTSINK_AddRef(
    7568. 

  7568.     PEVENTSINK pEV
    7569. 

  7569.     ){
    7570. 

  7570.     PIEVENTSINKOBJ pEVObj = (PIEVENTSINKOBJ)pEV;
    7571. 

  7571.     return ++pEVObj->m_cRef;
    7572. 

  7572. }
    7573. 

  7573. 

  7574. STDMETHODIMP_(ULONG) EVENTSINK_Release(
    7575. 

  7575.     PEVENTSINK pEV
    7576. 

  7576.     ) {
    7577. 

  7577.     PIEVENTSINKOBJ pEVObj = (PIEVENTSINKOBJ)pEV;
    7578. 

  7578.     --pEVObj->m_cRef;
    7579. 

  7579.     if(pEVObj->m_cRef != 0)
    7580. 

  7580.         return pEVObj->m_cRef;
    7581. 

  7581.     EVENTSINK_Destructor(pEVObj);
    7582. 

  7582.     return 0;
    7583. 

  7583. }
    7584. 

  7584. 

  7585. STDMETHODIMP EVENTSINK_GetTypeInfoCount(
    7586. 

  7586.     PEVENTSINK pEV,
    7587. 

  7587.     UINT *pct
    7588. 

  7588.     ) {
    7589. 

  7589.     *pct = 0;
    7590. 

  7590.     return NOERROR;
    7591. 

  7591. }
    7592. 

  7592. 

  7593. STDMETHODIMP EVENTSINK_GetTypeInfo(
    7594. 

  7594.     PEVENTSINK pEV,
    7595. 

  7595.     UINT info,
    7596. 

  7596.     LCID lcid,
    7597. 

  7597.     ITypeInfo **pInfo
    7598. 

  7598.     ) {
    7599. 

  7599.     *pInfo = NULL;
    7600. 

  7600.     return DISP_E_BADINDEX;
    7601. 

  7601. }
    7602. 

  7602. 

  7603. STDMETHODIMP EVENTSINK_GetIDsOfNames(
    7604. 

  7604.     PEVENTSINK pEventSink,
    7605. 

  7605.     REFIID riid,
    7606. 

  7606.     OLECHAR **szNames,
    7607. 

  7607.     UINT cNames,
    7608. 

  7608.     LCID lcid,
    7609. 

  7609.     DISPID *pDispID
    7610. 

  7610.     ) {
    7611. 

  7611.     ITypeInfo *pTypeInfo;
    7612. 

  7612.     PIEVENTSINKOBJ pEV = (PIEVENTSINKOBJ)pEventSink;
    7613. 

  7613.     pTypeInfo = pEV->pTypeInfo;
    7614. 

  7614.     if (pTypeInfo) {
    7615. 

  7615. 	return pTypeInfo->lpVtbl->GetIDsOfNames(pTypeInfo, szNames, cNames, pDispID);
    7616. 

  7616.     }
    7617. 

  7617.     return DISP_E_UNKNOWNNAME;
    7618. 

  7618. }
    7619. 

  7619. 

  7620. static long
    7621. 

  7621. ole_search_event_at(VALUE ary, VALUE ev)
    7622. 

  7622. {
    7623. 

  7623.     VALUE event;
    7624. 

  7624.     VALUE def_event;
    7625. 

  7625.     VALUE event_name;
    7626. 

  7626.     long i, len; 
    7627. 

  7627.     long ret = -1;
    7628. 

  7628.     def_event = Qnil;
    7629. 

  7629.     len = RARRAY_LEN(ary);
    7630. 

  7630.     for(i = 0; i < len; i++) {
    7631. 

  7631.         event = rb_ary_entry(ary, i);
    7632. 

  7632.         event_name = rb_ary_entry(event, 1);
    7633. 

  7633.         if(NIL_P(event_name) && NIL_P(ev)) {
    7634. 

  7634.             ret = i;
    7635. 

  7635.             break;
    7636. 

  7636.         }
    7637. 

  7637.         else if (TYPE(ev) == T_STRING &&
    7638. 

  7638.                  TYPE(event_name) == T_STRING &&
    7639. 

  7639.                  rb_str_cmp(ev, event_name) == 0) {
    7640. 

  7640.             ret = i;
    7641. 

  7641.             break;
    7642. 

  7642.         }
    7643. 

  7643.     }
    7644. 

  7644.     return ret;
    7645. 

  7645. }
    7646. 

  7646. 

  7647. static VALUE
    7648. 

  7648. ole_search_event(VALUE ary, VALUE ev, BOOL  *is_default)
    7649. 

  7649. {
    7650. 

  7650.     VALUE event;
    7651. 

  7651.     VALUE def_event;
    7652. 

  7652.     VALUE event_name;
    7653. 

  7653.     int i, len;
    7654. 

  7654.     *is_default = FALSE;
    7655. 

  7655.     def_event = Qnil;
    7656. 

  7656.     len = RARRAY_LEN(ary);
    7657. 

  7657.     for(i = 0; i < len; i++) {
    7658. 

  7658.         event = rb_ary_entry(ary, i);
    7659. 

  7659.         event_name = rb_ary_entry(event, 1);
    7660. 

  7660.         if(NIL_P(event_name)) {
    7661. 

  7661.             *is_default = TRUE;
    7662. 

  7662.             def_event = event;
    7663. 

  7663.         }
    7664. 

  7664.         else if (rb_str_cmp(ev, event_name) == 0) {
    7665. 

  7665.             *is_default = FALSE;
    7666. 

  7666.             return event;
    7667. 

  7667.         }
    7668. 

  7668.     }
    7669. 

  7669.     return def_event;
    7670. 

  7670. }
    7671. 

  7671. static VALUE
    7672. 

  7672. ole_search_handler_method(VALUE handler, VALUE ev, BOOL *is_default_handler)
    7673. 

  7673. {
    7674. 

  7674.     VALUE mid;
    7675. 

  7675. 

  7676.     *is_default_handler = FALSE;
    7677. 

  7677.     mid = rb_to_id(rb_sprintf("on%s", StringValuePtr(ev)));
    7678. 

  7678.     if (rb_respond_to(handler, mid)) {
    7679. 

  7679. 	return mid;
    7680. 

  7680.     }
    7681. 

  7681.     mid = rb_intern("method_missing");
    7682. 

  7682.     if (rb_respond_to(handler, mid)) {
    7683. 

  7683. 	*is_default_handler = TRUE;
    7684. 

  7684. 	return mid;
    7685. 

  7685.     }
    7686. 

  7686.     return Qnil;
    7687. 

  7687. }
    7688. 

  7688. 

  7689. static void
    7690. 

  7690. ole_delete_event(VALUE ary, VALUE ev)
    7691. 

  7691. {
    7692. 

  7692.     long at = -1;
    7693. 

  7693.     at = ole_search_event_at(ary, ev);
    7694. 

  7694.     if (at >= 0) {
    7695. 

  7695.         rb_ary_delete_at(ary, at);
    7696. 

  7696.     }
    7697. 

  7697. }
    7698. 

  7698. 

  7699. static void 
    7700. 

  7700. hash2ptr_dispparams(VALUE hash, ITypeInfo *pTypeInfo, DISPID dispid, DISPPARAMS *pdispparams)
    7701. 

  7701. {
    7702. 

  7702.     BSTR *bstrs;
    7703. 

  7703.     HRESULT hr;
    7704. 

  7704.     UINT len, i;
    7705. 

  7705.     VARIANT *pvar;
    7706. 

  7706.     VALUE val;
    7707. 

  7707.     VALUE key;
    7708. 

  7708.     len = 0;
    7709. 

  7709.     bstrs = ALLOCA_N(BSTR, pdispparams->cArgs + 1);
    7710. 

  7710.     hr = pTypeInfo->lpVtbl->GetNames(pTypeInfo, dispid, 
    7711. 

  7711.                                      bstrs, pdispparams->cArgs + 1,
    7712. 

  7712.                                      &len);
    7713. 

  7713.     if (FAILED(hr))
    7714. 

  7714. 	return;
    7715. 

  7715. 

  7716.     for (i = 0; i < len - 1; i++) {
    7717. 

  7717. 	key = WC2VSTR(bstrs[i + 1]);
    7718. 

  7718.         val = rb_hash_aref(hash, INT2FIX(i));
    7719. 

  7719. 	if (val == Qnil) 
    7720. 

  7720. 	    val = rb_hash_aref(hash, key);
    7721. 

  7721. 	if (val == Qnil)
    7722. 

  7722. 	    val = rb_hash_aref(hash, rb_str_intern(key));
    7723. 

  7723.         pvar = &pdispparams->rgvarg[pdispparams->cArgs-i-1];
    7724. 

  7724.         ole_val2ptr_variant(val, pvar);
    7725. 

  7725.     }
    7726. 

  7726. }
    7727. 

  7727. 

  7728. static VALUE 
    7729. 

  7729. hash2result(VALUE hash)
    7730. 

  7730. {
    7731. 

  7731.     VALUE ret = Qnil;
    7732. 

  7732.     ret = rb_hash_aref(hash, rb_str_new2("return"));
    7733. 

  7733.     if (ret == Qnil)
    7734. 

  7734. 	ret = rb_hash_aref(hash, rb_str_intern(rb_str_new2("return")));
    7735. 

  7735.     return ret;
    7736. 

  7736. }
    7737. 

  7737. 

  7738. static void
    7739. 

  7739. ary2ptr_dispparams(VALUE ary, DISPPARAMS *pdispparams)
    7740. 

  7740. {
    7741. 

  7741.     int i;
    7742. 

  7742.     VALUE v;
    7743. 

  7743.     VARIANT *pvar;
    7744. 

  7744.     for(i = 0; i < RARRAY_LEN(ary) && (unsigned int) i < pdispparams->cArgs; i++) {
    7745. 

  7745.         v = rb_ary_entry(ary, i);
    7746. 

  7746.         pvar = &pdispparams->rgvarg[pdispparams->cArgs-i-1];
    7747. 

  7747.         ole_val2ptr_variant(v, pvar);
    7748. 

  7748.     }
    7749. 

  7749. }
    7750. 

  7750. 

  7751. static VALUE
    7752. 

  7752. exec_callback(VALUE arg)
    7753. 

  7753. {
    7754. 

  7754.     VALUE *parg = (VALUE *)arg;
    7755. 

  7755.     VALUE handler = parg[0];
    7756. 

  7756.     VALUE mid = parg[1];
    7757. 

  7757.     VALUE args = parg[2];
    7758. 

  7758.     return rb_apply(handler, mid, args);
    7759. 

  7759. }
    7760. 

  7760. 

  7761. static VALUE
    7762. 

  7762. rescue_callback(VALUE arg)
    7763. 

  7763. {
    7764. 

  7764.     
    7765. 

  7765.     VALUE error;
    7766. 

  7766.     VALUE e = rb_errinfo();
    7767. 

  7767.     VALUE bt = rb_funcall(e, rb_intern("backtrace"), 0);
    7768. 

  7768.     VALUE msg = rb_funcall(e, rb_intern("message"), 0);
    7769. 

  7769.     bt = rb_ary_entry(bt, 0);
    7770. 

  7770.     error = rb_sprintf("%s: %s (%s)\n", StringValuePtr(bt), StringValuePtr(msg), rb_obj_classname(e));
    7771. 

  7771.     rb_write_error(StringValuePtr(error));
    7772. 

  7772.     rb_backtrace();
    7773. 

  7773.     ruby_finalize();
    7774. 

  7774.     exit(-1);
    7775. 

  7775.     
    7776. 

  7776.     return Qnil;
    7777. 

  7777. }
    7778. 

  7778. 

  7779. STDMETHODIMP EVENTSINK_Invoke(
    7780. 

  7780.     PEVENTSINK pEventSink,
    7781. 

  7781.     DISPID dispid,
    7782. 

  7782.     REFIID riid,
    7783. 

  7783.     LCID lcid,
    7784. 

  7784.     WORD wFlags,
    7785. 

  7785.     DISPPARAMS *pdispparams,
    7786. 

  7786.     VARIANT *pvarResult,
    7787. 

  7787.     EXCEPINFO *pexcepinfo,
    7788. 

  7788.     UINT *puArgErr
    7789. 

  7789.     ) {
    7790. 

  7790. 

  7791.     HRESULT hr;
    7792. 

  7792.     BSTR bstr;
    7793. 

  7793.     unsigned int count;
    7794. 

  7794.     unsigned int i;
    7795. 

  7795.     ITypeInfo *pTypeInfo;
    7796. 

  7796.     VARIANT *pvar;
    7797. 

  7797.     VALUE ary, obj, event, args, outargv, ev, result;
    7798. 

  7798.     VALUE handler = Qnil;
    7799. 

  7799.     VALUE arg[3];
    7800. 

  7800.     VALUE mid;
    7801. 

  7801.     VALUE is_outarg = Qfalse;
    7802. 

  7802.     BOOL is_default_handler = FALSE;
    7803. 

  7803.     int state;
    7804. 

  7804. 

  7805.     PIEVENTSINKOBJ pEV = (PIEVENTSINKOBJ)pEventSink;
    7806. 

  7806.     pTypeInfo = pEV->pTypeInfo;
    7807. 

  7807.     obj = evs_entry(pEV->m_event_id);
    7808. 

  7808.     if (!rb_obj_is_kind_of(obj, cWIN32OLE_EVENT)) {
    7809. 

  7809.         return NOERROR;
    7810. 

  7810.     }
    7811. 

  7811. 

  7812.     ary = rb_ivar_get(obj, id_events);
    7813. 

  7813.     if (NIL_P(ary) || TYPE(ary) != T_ARRAY) {
    7814. 

  7814.         return NOERROR;
    7815. 

  7815.     }
    7816. 

  7816.     hr = pTypeInfo->lpVtbl->GetNames(pTypeInfo, dispid,
    7817. 

  7817.                                      &bstr, 1, &count);
    7818. 

  7818.     if (FAILED(hr)) {
    7819. 

  7819.         return NOERROR;
    7820. 

  7820.     }
    7821. 

  7821.     ev = WC2VSTR(bstr);
    7822. 

  7822.     event = ole_search_event(ary, ev, &is_default_handler);
    7823. 

  7823.     if (TYPE(event) == T_ARRAY) {
    7824. 

  7824. 	handler = rb_ary_entry(event, 0);
    7825. 

  7825. 	mid = rb_intern("call");
    7826. 

  7826. 	is_outarg = rb_ary_entry(event, 3);
    7827. 

  7827.     } else {
    7828. 

  7828. 	handler = rb_ivar_get(obj, rb_intern("handler"));
    7829. 

  7829. 	if (handler == Qnil) {
    7830. 

  7830. 	    return NOERROR;
    7831. 

  7831. 	}
    7832. 

  7832. 	mid = ole_search_handler_method(handler, ev, &is_default_handler);
    7833. 

  7833.     }
    7834. 

  7834.     if (handler == Qnil || mid == Qnil) {
    7835. 

  7835. 	return NOERROR;
    7836. 

  7836.     }
    7837. 

  7837. 

  7838.     args = rb_ary_new();
    7839. 

  7839.     if (is_default_handler) {
    7840. 

  7840.         rb_ary_push(args, ev);
    7841. 

  7841.     }
    7842. 

  7842. 

  7843.     /* make argument of event handler */
    7844. 

  7844.     for (i = 0; i < pdispparams->cArgs; ++i) {
    7845. 

  7845.         pvar = &pdispparams->rgvarg[pdispparams->cArgs-i-1];
    7846. 

  7846.         rb_ary_push(args, ole_variant2val(pvar));
    7847. 

  7847.     }
    7848. 

  7848.     outargv = Qnil;
    7849. 

  7849.     if (is_outarg == Qtrue) {
    7850. 

  7850. 	outargv = rb_ary_new();
    7851. 

  7851.         rb_ary_push(args, outargv);
    7852. 

  7852.     }
    7853. 

  7853. 

  7854.     /*
    7855. 

  7855.      * if exception raised in event callback,
    7856. 

  7856.      * then you receive cfp consistency error. 
    7857. 

  7857.      * to avoid this error we use begin rescue end.
    7858. 

  7858.      * and the exception raised then error message print
    7859. 

  7859.      * and exit ruby process by Win32OLE itself.
    7860. 

  7860.      */
    7861. 

  7861.     arg[0] = handler;
    7862. 

  7862.     arg[1] = mid;
    7863. 

  7863.     arg[2] = args;
    7864. 

  7864.     result = rb_protect(exec_callback, (VALUE)arg, &state);
    7865. 

  7865.     if (state != 0) {
    7866. 

  7866. 	rescue_callback(Qnil);
    7867. 

  7867.     }
    7868. 

  7868.     if(TYPE(result) == T_HASH) {
    7869. 

  7869. 	hash2ptr_dispparams(result, pTypeInfo, dispid, pdispparams);
    7870. 

  7870. 	result = hash2result(result);
    7871. 

  7871.     }else if (is_outarg == Qtrue && TYPE(outargv) == T_ARRAY) {
    7872. 

  7872. 	ary2ptr_dispparams(outargv, pdispparams);
    7873. 

  7873.     }
    7874. 

  7874. 

  7875.     if (pvarResult) {
    7876. 

  7876. 	VariantInit(pvarResult);
    7877. 

  7877.         ole_val2variant(result, pvarResult);
    7878. 

  7878.     }
    7879. 

  7879.     
    7880. 

  7880.     return NOERROR;
    7881. 

  7881. }
    7882. 

  7882. 

  7883. PIEVENTSINKOBJ
    7884. 

  7884. EVENTSINK_Constructor() {
    7885. 

  7885.     PIEVENTSINKOBJ pEv;
    7886. 

  7886.     if (!g_IsEventSinkVtblInitialized) {
    7887. 

  7887.         vtEventSink.QueryInterface=EVENTSINK_QueryInterface;
    7888. 

  7888.         vtEventSink.AddRef = EVENTSINK_AddRef;
    7889. 

  7889.         vtEventSink.Release = EVENTSINK_Release;
    7890. 

  7890.         vtEventSink.Invoke = EVENTSINK_Invoke;
    7891. 

  7891.         vtEventSink.GetIDsOfNames = EVENTSINK_GetIDsOfNames;
    7892. 

  7892.         vtEventSink.GetTypeInfoCount = EVENTSINK_GetTypeInfoCount;
    7893. 

  7893.         vtEventSink.GetTypeInfo = EVENTSINK_GetTypeInfo;
    7894. 

  7894. 

  7895.         g_IsEventSinkVtblInitialized = TRUE;
    7896. 

  7896.     }
    7897. 

  7897.     pEv = ALLOC_N(IEVENTSINKOBJ, 1);
    7898. 

  7898.     if(pEv == NULL) return NULL;
    7899. 

  7899.     pEv->lpVtbl = &vtEventSink;
    7900. 

  7900.     pEv->m_cRef = 0;
    7901. 

  7901.     pEv->m_event_id = 0;
    7902. 

  7902.     pEv->pTypeInfo = NULL;
    7903. 

  7903.     return pEv;
    7904. 

  7904. }
    7905. 

  7905. 

  7906. void EVENTSINK_Destructor(
    7907. 

  7907.     PIEVENTSINKOBJ pEVObj
    7908. 

  7908.     ) {
    7909. 

  7909.     if(pEVObj != NULL) {
    7910. 

  7910.         OLE_RELEASE(pEVObj->pTypeInfo);
    7911. 

  7911.         free(pEVObj);
    7912. 

  7912.         pEVObj = NULL;
    7913. 

  7913.     }
    7914. 

  7914. }
    7915. 

  7915. 

  7916. static HRESULT
    7917. 

  7917. find_iid(VALUE ole, char *pitf, IID *piid, ITypeInfo **ppTypeInfo)
    7918. 

  7918. {
    7919. 

  7919.     HRESULT hr;
    7920. 

  7920.     IDispatch *pDispatch;
    7921. 

  7921.     ITypeInfo *pTypeInfo;
    7922. 

  7922.     ITypeLib *pTypeLib;
    7923. 

  7923.     TYPEATTR *pTypeAttr;
    7924. 

  7924.     HREFTYPE RefType;
    7925. 

  7925.     ITypeInfo *pImplTypeInfo;
    7926. 

  7926.     TYPEATTR *pImplTypeAttr;
    7927. 

  7927. 

  7928.     struct oledata *pole;
    7929. 

  7929.     unsigned int index;
    7930. 

  7930.     unsigned int count;
    7931. 

  7931.     int type;
    7932. 

  7932.     BSTR bstr;
    7933. 

  7933.     char *pstr;
    7934. 

  7934. 

  7935.     BOOL is_found = FALSE;
    7936. 

  7936.     LCID    lcid = cWIN32OLE_lcid;
    7937. 

  7937. 

  7938.     OLEData_Get_Struct(ole, pole);
    7939. 

  7939. 

  7940.     pDispatch = pole->pDispatch;
    7941. 

  7941. 

  7942.     hr = pDispatch->lpVtbl->GetTypeInfo(pDispatch, 0, lcid, &pTypeInfo);
    7943. 

  7943.     if (FAILED(hr))
    7944. 

  7944.         return hr;
    7945. 

  7945. 

  7946.     hr = pTypeInfo->lpVtbl->GetContainingTypeLib(pTypeInfo,
    7947. 

  7947.                                                  &pTypeLib,
    7948. 

  7948.                                                  &index);
    7949. 

  7949.     OLE_RELEASE(pTypeInfo);
    7950. 

  7950.     if (FAILED(hr))
    7951. 

  7951.         return hr;
    7952. 

  7952. 

  7953.     if (!pitf) {
    7954. 

  7954.         hr = pTypeLib->lpVtbl->GetTypeInfoOfGuid(pTypeLib,
    7955. 

  7955.                                                  piid,
    7956. 

  7956.                                                  ppTypeInfo);
    7957. 

  7957.         OLE_RELEASE(pTypeLib);
    7958. 

  7958.         return hr;
    7959. 

  7959.     }
    7960. 

  7960.     count = pTypeLib->lpVtbl->GetTypeInfoCount(pTypeLib);
    7961. 

  7961.     for (index = 0; index < count; index++) {
    7962. 

  7962.         hr = pTypeLib->lpVtbl->GetTypeInfo(pTypeLib,
    7963. 

  7963.                                            index,
    7964. 

  7964.                                            &pTypeInfo);
    7965. 

  7965.         if (FAILED(hr))
    7966. 

  7966.             break;
    7967. 

  7967.         hr = OLE_GET_TYPEATTR(pTypeInfo, &pTypeAttr);
    7968. 

  7968. 

  7969.         if(FAILED(hr)) {
    7970. 

  7970.             OLE_RELEASE(pTypeInfo);
    7971. 

  7971.             break;
    7972. 

  7972.         }
    7973. 

  7973.         if(pTypeAttr->typekind == TKIND_COCLASS) {
    7974. 

  7974.             for (type = 0; type < pTypeAttr->cImplTypes; type++) {
    7975. 

  7975.                 hr = pTypeInfo->lpVtbl->GetRefTypeOfImplType(pTypeInfo,
    7976. 

  7976.                                                              type,
    7977. 

  7977.                                                              &RefType);
    7978. 

  7978.                 if (FAILED(hr))
    7979. 

  7979.                     break;
    7980. 

  7980.                 hr = pTypeInfo->lpVtbl->GetRefTypeInfo(pTypeInfo,
    7981. 

  7981.                                                        RefType,
    7982. 

  7982.                                                        &pImplTypeInfo);
    7983. 

  7983.                 if (FAILED(hr))
    7984. 

  7984.                     break;
    7985. 

  7985. 

  7986.                 hr = pImplTypeInfo->lpVtbl->GetDocumentation(pImplTypeInfo,
    7987. 

  7987.                                                              -1,
    7988. 

  7988.                                                              &bstr,
    7989. 

  7989.                                                              NULL, NULL, NULL);
    7990. 

  7990.                 if (FAILED(hr)) {
    7991. 

  7991.                     OLE_RELEASE(pImplTypeInfo);
    7992. 

  7992.                     break;
    7993. 

  7993.                 }
    7994. 

  7994.                 pstr = ole_wc2mb(bstr);
    7995. 

  7995.                 if (strcmp(pitf, pstr) == 0) {
    7996. 

  7996.                     hr = pImplTypeInfo->lpVtbl->GetTypeAttr(pImplTypeInfo,
    7997. 

  7997.                                                             &pImplTypeAttr);
    7998. 

  7998.                     if (SUCCEEDED(hr)) {
    7999. 

  7999.                         is_found = TRUE;
    8000. 

  8000.                         *piid = pImplTypeAttr->guid;
    8001. 

  8001.                         if (ppTypeInfo) {
    8002. 

  8002.                             *ppTypeInfo = pImplTypeInfo;
    8003. 

  8003.                             (*ppTypeInfo)->lpVtbl->AddRef((*ppTypeInfo));
    8004. 

  8004.                         }
    8005. 

  8005.                         pImplTypeInfo->lpVtbl->ReleaseTypeAttr(pImplTypeInfo,
    8006. 

  8006.                                                                pImplTypeAttr);
    8007. 

  8007.                     }
    8008. 

  8008.                 }
    8009. 

  8009.                 free(pstr);
    8010. 

  8010.                 OLE_RELEASE(pImplTypeInfo);
    8011. 

  8011.                 if (is_found || FAILED(hr))
    8012. 

  8012.                     break;
    8013. 

  8013.             }
    8014. 

  8014.         }
    8015. 

  8015. 

  8016.         OLE_RELEASE_TYPEATTR(pTypeInfo, pTypeAttr);
    8017. 

  8017.         OLE_RELEASE(pTypeInfo);
    8018. 

  8018.         if (is_found || FAILED(hr))
    8019. 

  8019.             break;
    8020. 

  8020.     }
    8021. 

  8021.     OLE_RELEASE(pTypeLib);
    8022. 

  8022.     if(!is_found)
    8023. 

  8023.         return E_NOINTERFACE;
    8024. 

  8024.     return hr;
    8025. 

  8025. }
    8026. 

  8026. 

  8027. static HRESULT 
    8028. 

  8028. find_coclass(
    8029. 

  8029.     ITypeInfo *pTypeInfo, 
    8030. 

  8030.     TYPEATTR *pTypeAttr, 
    8031. 

  8031.     ITypeInfo **pCOTypeInfo, 
    8032. 

  8032.     TYPEATTR **pCOTypeAttr)
    8033. 

  8033. {
    8034. 

  8034.     HRESULT hr = E_NOINTERFACE;
    8035. 

  8035.     ITypeLib *pTypeLib;
    8036. 

  8036.     int count;
    8037. 

  8037.     BOOL found = FALSE;
    8038. 

  8038.     ITypeInfo *pTypeInfo2;
    8039. 

  8039.     TYPEATTR *pTypeAttr2;
    8040. 

  8040.     int flags;
    8041. 

  8041.     int i,j;
    8042. 

  8042.     HREFTYPE href;
    8043. 

  8043.     ITypeInfo *pRefTypeInfo;
    8044. 

  8044.     TYPEATTR *pRefTypeAttr;
    8045. 

  8045. 

  8046.     hr = pTypeInfo->lpVtbl->GetContainingTypeLib(pTypeInfo, &pTypeLib, NULL);
    8047. 

  8047.     if (FAILED(hr)) {
    8048. 

  8048. 	return hr;
    8049. 

  8049.     }
    8050. 

  8050.     count = pTypeLib->lpVtbl->GetTypeInfoCount(pTypeLib);
    8051. 

  8051.     for (i = 0; i < count && !found; i++) {
    8052. 

  8052. 	hr = pTypeLib->lpVtbl->GetTypeInfo(pTypeLib, i, &pTypeInfo2);
    8053. 

  8053. 	if (FAILED(hr))
    8054. 

  8054. 	    continue;
    8055. 

  8055. 	hr = OLE_GET_TYPEATTR(pTypeInfo2, &pTypeAttr2);
    8056. 

  8056. 	if (FAILED(hr)) {
    8057. 

  8057. 	    OLE_RELEASE(pTypeInfo2);
    8058. 

  8058. 	    continue;
    8059. 

  8059. 	}
    8060. 

  8060. 	if (pTypeAttr2->typekind != TKIND_COCLASS) {
    8061. 

  8061. 	    OLE_RELEASE_TYPEATTR(pTypeInfo2, pTypeAttr2);
    8062. 

  8062. 	    OLE_RELEASE(pTypeInfo2);
    8063. 

  8063. 	    continue;
    8064. 

  8064. 	}
    8065. 

  8065. 	for (j = 0; j < pTypeAttr2->cImplTypes && !found; j++) {
    8066. 

  8066. 	    hr = pTypeInfo2->lpVtbl->GetImplTypeFlags(pTypeInfo2, j, &flags);
    8067. 

  8067. 	    if (FAILED(hr))
    8068. 

  8068. 		continue;
    8069. 

  8069. 	    if (!(flags & IMPLTYPEFLAG_FDEFAULT)) 
    8070. 

  8070. 		continue;
    8071. 

  8071. 	    hr = pTypeInfo2->lpVtbl->GetRefTypeOfImplType(pTypeInfo2, j, &href);
    8072. 

  8072. 	    if (FAILED(hr))
    8073. 

  8073. 		continue;
    8074. 

  8074. 	    hr = pTypeInfo2->lpVtbl->GetRefTypeInfo(pTypeInfo2, href, &pRefTypeInfo);
    8075. 

  8075. 	    if (FAILED(hr)) 
    8076. 

  8076. 		continue;
    8077. 

  8077. 	    hr = OLE_GET_TYPEATTR(pRefTypeInfo, &pRefTypeAttr);
    8078. 

  8078. 	    if (FAILED(hr))  {
    8079. 

  8079. 		OLE_RELEASE(pRefTypeInfo);
    8080. 

  8080. 		continue;
    8081. 

  8081. 	    }
    8082. 

  8082. 	    if (IsEqualGUID(&(pTypeAttr->guid), &(pRefTypeAttr->guid))) {
    8083. 

  8083. 		found = TRUE;
    8084. 

  8084. 	    }
    8085. 

  8085. 	}
    8086. 

  8086. 	if (!found) {
    8087. 

  8087. 	    OLE_RELEASE_TYPEATTR(pTypeInfo2, pTypeAttr2);
    8088. 

  8088. 	    OLE_RELEASE(pTypeInfo2);
    8089. 

  8089. 	}
    8090. 

  8090.     }
    8091. 

  8091.     OLE_RELEASE(pTypeLib);
    8092. 

  8092.     if (found) {
    8093. 

  8093. 	*pCOTypeInfo = pTypeInfo2;
    8094. 

  8094. 	*pCOTypeAttr = pTypeAttr2;
    8095. 

  8095. 	hr = S_OK;
    8096. 

  8096.     } else {
    8097. 

  8097. 	hr = E_NOINTERFACE;
    8098. 

  8098.     }
    8099. 

  8099.     return hr;
    8100. 

  8100. }
    8101. 

  8101. 

  8102. static HRESULT
    8103. 

  8103. find_default_source_from_typeinfo(
    8104. 

  8104.     ITypeInfo *pTypeInfo, 
    8105. 

  8105.     TYPEATTR *pTypeAttr, 
    8106. 

  8106.     ITypeInfo **ppTypeInfo)
    8107. 

  8107. {
    8108. 

  8108.     int i = 0;
    8109. 

  8109.     HRESULT hr = E_NOINTERFACE;
    8110. 

  8110.     int flags;
    8111. 

  8111.     HREFTYPE hRefType;
    8112. 

  8112.     /* Enumerate all implemented types of the COCLASS */
    8113. 

  8113.     for (i = 0; i < pTypeAttr->cImplTypes; i++) {
    8114. 

  8114.         hr = pTypeInfo->lpVtbl->GetImplTypeFlags(pTypeInfo, i, &flags);
    8115. 

  8115.         if (FAILED(hr))
    8116. 

  8116.             continue;
    8117. 

  8117. 

  8118.         /*
    8119. 

  8119.            looking for the [default] [source]
    8120. 

  8120.            we just hope that it is a dispinterface :-)
    8121. 

  8121.         */
    8122. 

  8122.         if ((flags & IMPLTYPEFLAG_FDEFAULT) &&
    8123. 

  8123.             (flags & IMPLTYPEFLAG_FSOURCE)) {
    8124. 

  8124. 

  8125.             hr = pTypeInfo->lpVtbl->GetRefTypeOfImplType(pTypeInfo,
    8126. 

  8126.                                                          i, &hRefType);
    8127. 

  8127.             if (FAILED(hr))
    8128. 

  8128.                 continue;
    8129. 

  8129.             hr = pTypeInfo->lpVtbl->GetRefTypeInfo(pTypeInfo,
    8130. 

  8130.                                                    hRefType, ppTypeInfo);
    8131. 

  8131.             if (SUCCEEDED(hr))
    8132. 

  8132.                 break;
    8133. 

  8133.         }
    8134. 

  8134.     }
    8135. 

  8135.     return hr;
    8136. 

  8136. }
    8137. 

  8137. 

  8138. static HRESULT
    8139. 

  8139. find_default_source(VALUE ole, IID *piid, ITypeInfo **ppTypeInfo)
    8140. 

  8140. {
    8141. 

  8141.     HRESULT hr;
    8142. 

  8142.     IProvideClassInfo2 *pProvideClassInfo2;
    8143. 

  8143.     IProvideClassInfo *pProvideClassInfo;
    8144. 

  8144.     void *p;
    8145. 

  8145. 

  8146.     IDispatch *pDispatch;
    8147. 

  8147.     ITypeInfo *pTypeInfo;
    8148. 

  8148.     ITypeInfo *pTypeInfo2 = NULL;
    8149. 

  8149.     TYPEATTR *pTypeAttr;
    8150. 

  8150.     TYPEATTR *pTypeAttr2 = NULL;
    8151. 

  8151. 

  8152.     struct oledata *pole;
    8153. 

  8153. 

  8154.     OLEData_Get_Struct(ole, pole);
    8155. 

  8155.     pDispatch = pole->pDispatch;
    8156. 

  8156.     hr = pDispatch->lpVtbl->QueryInterface(pDispatch,
    8157. 

  8157.                                            &IID_IProvideClassInfo2,
    8158. 

  8158.                                            &p);
    8159. 

  8159.     if (SUCCEEDED(hr)) {
    8160. 

  8160.         pProvideClassInfo2 = p;
    8161. 

  8161.         hr = pProvideClassInfo2->lpVtbl->GetGUID(pProvideClassInfo2,
    8162. 

  8162.                                                  GUIDKIND_DEFAULT_SOURCE_DISP_IID,
    8163. 

  8163.                                                  piid);
    8164. 

  8164.         OLE_RELEASE(pProvideClassInfo2);
    8165. 

  8165.         if (SUCCEEDED(hr)) {
    8166. 

  8166.             hr = find_iid(ole, NULL, piid, ppTypeInfo);
    8167. 

  8167.         }
    8168. 

  8168.     }
    8169. 

  8169.     if (SUCCEEDED(hr)) {
    8170. 

  8170.         return hr;
    8171. 

  8171.     }
    8172. 

  8172.     hr = pDispatch->lpVtbl->QueryInterface(pDispatch,
    8173. 

  8173.                                            &IID_IProvideClassInfo,
    8174. 

  8174. 					   &p);
    8175. 

  8175.     if (SUCCEEDED(hr)) {
    8176. 

  8176.         pProvideClassInfo = p;
    8177. 

  8177.         hr = pProvideClassInfo->lpVtbl->GetClassInfo(pProvideClassInfo,
    8178. 

  8178.                                                      &pTypeInfo);
    8179. 

  8179.         OLE_RELEASE(pProvideClassInfo);
    8180. 

  8180.     }
    8181. 

  8181.     if (FAILED(hr)) {
    8182. 

  8182.         hr = pDispatch->lpVtbl->GetTypeInfo(pDispatch, 0, cWIN32OLE_lcid, &pTypeInfo );
    8183. 

  8183.     }
    8184. 

  8184.     if (FAILED(hr))
    8185. 

  8185.         return hr;
    8186. 

  8186.     hr = OLE_GET_TYPEATTR(pTypeInfo, &pTypeAttr);
    8187. 

  8187.     if (FAILED(hr)) {
    8188. 

  8188.         OLE_RELEASE(pTypeInfo);
    8189. 

  8189.         return hr;
    8190. 

  8190.     }
    8191. 

  8191. 

  8192.     *ppTypeInfo = 0;
    8193. 

  8193.     hr = find_default_source_from_typeinfo(pTypeInfo, pTypeAttr, ppTypeInfo);
    8194. 

  8194.     if (!*ppTypeInfo) {
    8195. 

  8195. 	hr = find_coclass(pTypeInfo, pTypeAttr, &pTypeInfo2, &pTypeAttr2);
    8196. 

  8196. 	if (SUCCEEDED(hr)) {
    8197. 

  8197. 	    hr = find_default_source_from_typeinfo(pTypeInfo2, pTypeAttr2, ppTypeInfo);
    8198. 

  8198. 	    OLE_RELEASE_TYPEATTR(pTypeInfo2, pTypeAttr2);
    8199. 

  8199. 	    OLE_RELEASE(pTypeInfo2);
    8200. 

  8200. 	}
    8201. 

  8201.     }
    8202. 

  8202.     OLE_RELEASE_TYPEATTR(pTypeInfo, pTypeAttr);
    8203. 

  8203.     OLE_RELEASE(pTypeInfo);
    8204. 

  8204.     /* Now that would be a bad surprise, if we didn't find it, wouldn't it? */
    8205. 

  8205.     if (!*ppTypeInfo) {
    8206. 

  8206.         if (SUCCEEDED(hr))
    8207. 

  8207.             hr = E_UNEXPECTED;
    8208. 

  8208.         return hr;
    8209. 

  8209.     }
    8210. 

  8210. 

  8211.     /* Determine IID of default source interface */
    8212. 

  8212.     hr = (*ppTypeInfo)->lpVtbl->GetTypeAttr(*ppTypeInfo, &pTypeAttr);
    8213. 

  8213.     if (SUCCEEDED(hr)) {
    8214. 

  8214.         *piid = pTypeAttr->guid;
    8215. 

  8215.         (*ppTypeInfo)->lpVtbl->ReleaseTypeAttr(*ppTypeInfo, pTypeAttr);
    8216. 

  8216.     }
    8217. 

  8217.     else
    8218. 

  8218.         OLE_RELEASE(*ppTypeInfo);
    8219. 

  8219. 

  8220.     return hr;
    8221. 

  8221. 

  8222. }
    8223. 

  8223. 

  8224. static void
    8225. 

  8225. ole_event_free(struct oleeventdata *poleev)
    8226. 

  8226. {
    8227. 

  8227.     if (poleev->pConnectionPoint) {
    8228. 

  8228.         poleev->pConnectionPoint->lpVtbl->Unadvise(poleev->pConnectionPoint, poleev->dwCookie);
    8229. 

  8229.         OLE_RELEASE(poleev->pConnectionPoint);
    8230. 

  8230.         poleev->pConnectionPoint = NULL;
    8231. 

  8231.     }
    8232. 

  8232.     free(poleev);
    8233. 

  8233. }
    8234. 

  8234. 

  8235. static VALUE
    8236. 

  8236. fev_s_allocate(VALUE klass)
    8237. 

  8237. {
    8238. 

  8238.     VALUE obj;
    8239. 

  8239.     struct oleeventdata *poleev;
    8240. 

  8240.     obj = Data_Make_Struct(klass,struct oleeventdata,0,ole_event_free,poleev);
    8241. 

  8241.     poleev->dwCookie = 0;
    8242. 

  8242.     poleev->pConnectionPoint = NULL;
    8243. 

  8243.     poleev->event_id = 0;
    8244. 

  8244.     return obj;
    8245. 

  8245. }
    8246. 

  8246. 

  8247. static VALUE
    8248. 

  8248. ev_advise(int argc, VALUE *argv, VALUE self)
    8249. 

  8249. {
    8250. 

  8250. 

  8251.     VALUE ole, itf;
    8252. 

  8252.     struct oledata *pole;
    8253. 

  8253.     char *pitf;
    8254. 

  8254.     HRESULT hr;
    8255. 

  8255.     IID iid;
    8256. 

  8256.     ITypeInfo *pTypeInfo = 0;
    8257. 

  8257.     IDispatch *pDispatch;
    8258. 

  8258.     IConnectionPointContainer *pContainer;
    8259. 

  8259.     IConnectionPoint *pConnectionPoint;
    8260. 

  8260.     IEVENTSINKOBJ *pIEV;
    8261. 

  8261.     DWORD dwCookie;
    8262. 

  8262.     struct oleeventdata *poleev;
    8263. 

  8263.     void *p;
    8264. 

  8264. 

  8265.     rb_secure(4);
    8266. 

  8266.     rb_scan_args(argc, argv, "11", &ole, &itf);
    8267. 

  8267. 

  8268.     if (!rb_obj_is_kind_of(ole, cWIN32OLE)) {
    8269. 

  8269.         rb_raise(rb_eTypeError, "1st parameter must be WIN32OLE object");
    8270. 

  8270.     }
    8271. 

  8271. 

  8272.     if(TYPE(itf) != T_NIL) {
    8273. 

  8273.         if (rb_safe_level() > 0 && OBJ_TAINTED(itf)) {
    8274. 

  8274.             rb_raise(rb_eSecurityError, "Insecure Event Creation - %s",
    8275. 

  8275.                      StringValuePtr(itf));
    8276. 

  8276.         }
    8277. 

  8277.         SafeStringValue(itf);
    8278. 

  8278.         pitf = StringValuePtr(itf);
    8279. 

  8279.         hr = find_iid(ole, pitf, &iid, &pTypeInfo);
    8280. 

  8280.     }
    8281. 

  8281.     else {
    8282. 

  8282.         hr = find_default_source(ole, &iid, &pTypeInfo);
    8283. 

  8283.     }
    8284. 

  8284.     if (FAILED(hr)) {
    8285. 

  8285.         ole_raise(hr, rb_eRuntimeError, "interface not found");
    8286. 

  8286.     }
    8287. 

  8287. 

  8288.     OLEData_Get_Struct(ole, pole);
    8289. 

  8289.     pDispatch = pole->pDispatch;
    8290. 

  8290.     hr = pDispatch->lpVtbl->QueryInterface(pDispatch,
    8291. 

  8291.                                            &IID_IConnectionPointContainer,
    8292. 

  8292.                                            &p);
    8293. 

  8293.     if (FAILED(hr)) {
    8294. 

  8294.         OLE_RELEASE(pTypeInfo);
    8295. 

  8295.         ole_raise(hr, rb_eRuntimeError,
    8296. 

  8296.                   "failed to query IConnectionPointContainer");
    8297. 

  8297.     }
    8298. 

  8298.     pContainer = p;
    8299. 

  8299. 

  8300.     hr = pContainer->lpVtbl->FindConnectionPoint(pContainer,
    8301. 

  8301.                                                  &iid,
    8302. 

  8302.                                                  &pConnectionPoint);
    8303. 

  8303.     OLE_RELEASE(pContainer);
    8304. 

  8304.     if (FAILED(hr)) {
    8305. 

  8305.         OLE_RELEASE(pTypeInfo);
    8306. 

  8306.         ole_raise(hr, rb_eRuntimeError, "failed to query IConnectionPoint");
    8307. 

  8307.     }
    8308. 

  8308.     pIEV = EVENTSINK_Constructor();
    8309. 

  8309.     pIEV->m_iid = iid;
    8310. 

  8310.     hr = pConnectionPoint->lpVtbl->Advise(pConnectionPoint,
    8311. 

  8311.                                           (IUnknown*)pIEV,
    8312. 

  8312.                                           &dwCookie);
    8313. 

  8313.     if (FAILED(hr)) {
    8314. 

  8314.         ole_raise(hr, rb_eRuntimeError, "Advise Error");
    8315. 

  8315.     }
    8316. 

  8316. 

  8317.     Data_Get_Struct(self, struct oleeventdata, poleev);
    8318. 

  8318.     pIEV->m_event_id
    8319. 

  8319.         = NUM2INT(evs_length());
    8320. 

  8320.     pIEV->pTypeInfo = pTypeInfo;
    8321. 

  8321.     poleev->dwCookie = dwCookie;
    8322. 

  8322.     poleev->pConnectionPoint = pConnectionPoint;
    8323. 

  8323.     poleev->event_id = pIEV->m_event_id;
    8324. 

  8324. 

  8325.     return self;
    8326. 

  8326. }
    8327. 

  8327. 

  8328. /*
    8329. 

  8329.  *  call-seq:
    8330. 

  8330.  *     WIN32OLE_EVENT.new(ole, event) #=> WIN32OLE_EVENT object.
    8331. 

  8331.  *
    8332. 

  8332.  *  Returns OLE event object.
    8333. 

  8333.  *  The first argument specifies WIN32OLE object.
    8334. 

  8334.  *  The second argument specifies OLE event name.
    8335. 

  8335.  *     ie = WIN32OLE.new('InternetExplorer.Application')
    8336. 

  8336.  *     ev = WIN32OLE_EVENT.new(ie, 'DWebBrowserEvents')
    8337. 

  8337.  */     
    8338. 

  8338. static VALUE
    8339. 

  8339. fev_initialize(int argc, VALUE *argv, VALUE self)
    8340. 

  8340. {
    8341. 

  8341.     ev_advise(argc, argv, self);
    8342. 

  8342.     evs_push(self);
    8343. 

  8343.     rb_ivar_set(self, id_events, rb_ary_new());
    8344. 

  8344.     fev_set_handler(self, Qnil);
    8345. 

  8345.     return self;
    8346. 

  8346. }
    8347. 

  8347. 

  8348. /*
    8349. 

  8349.  *  call-seq:
    8350. 

  8350.  *     WIN32OLE_EVENT.message_loop
    8351. 

  8351.  * 
    8352. 

  8352.  *  Translates and dispatches Windows message.
    8353. 

  8353.  */
    8354. 

  8354. static VALUE
    8355. 

  8355. fev_s_msg_loop(VALUE klass)
    8356. 

  8356. {
    8357. 

  8357.     ole_msg_loop();
    8358. 

  8358.     return Qnil;
    8359. 

  8359. }
    8360. 

  8360. 

  8361. 

  8362. static void
    8363. 

  8363. add_event_call_back(VALUE obj, VALUE event, VALUE data)
    8364. 

  8364. {
    8365. 

  8365.     VALUE events = rb_ivar_get(obj, id_events);
    8366. 

  8366.     if (NIL_P(events) || TYPE(events) != T_ARRAY) {
    8367. 

  8367.         events = rb_ary_new();
    8368. 

  8368.         rb_ivar_set(obj, id_events, events);
    8369. 

  8369.     }
    8370. 

  8370.     ole_delete_event(events, event);
    8371. 

  8371.     rb_ary_push(events, data);
    8372. 

  8372. }
    8373. 

  8373. 

  8374. static VALUE
    8375. 

  8375. ev_on_event(int argc, VALUE *argv, VALUE self, VALUE is_ary_arg)
    8376. 

  8376. {
    8377. 

  8377.     struct oleeventdata *poleev;
    8378. 

  8378.     VALUE event, args, data;
    8379. 

  8379.     Data_Get_Struct(self, struct oleeventdata, poleev);
    8380. 

  8380.     if (poleev->pConnectionPoint == NULL) {
    8381. 

  8381.         rb_raise(eWIN32OLERuntimeError, "IConnectionPoint not found. You must call advise at first.");
    8382. 

  8382.     }
    8383. 

  8383.     rb_scan_args(argc, argv, "01*", &event, &args);
    8384. 

  8384.     if(!NIL_P(event)) {
    8385. 

  8385. 	if(TYPE(event) != T_STRING && TYPE(event) != T_SYMBOL) {
    8386. 

  8386. 	    rb_raise(rb_eTypeError, "wrong argument type (expected String or Symbol)");
    8387. 

  8387. 	}
    8388. 

  8388. 	if (TYPE(event) == T_SYMBOL) {
    8389. 

  8389. 	    event = rb_sym_to_s(event);
    8390. 

  8390. 	}
    8391. 

  8391.     }
    8392. 

  8392.     data = rb_ary_new3(4, rb_block_proc(), event, args, is_ary_arg);
    8393. 

  8393.     add_event_call_back(self, event, data);
    8394. 

  8394.     return Qnil;
    8395. 

  8395. }
    8396. 

  8396. 

  8397. /*
    8398. 

  8398.  *  call-seq:
    8399. 

  8399.  *     WIN32OLE_EVENT#on_event([event]){...}
    8400. 

  8400.  * 
    8401. 

  8401.  *  Defines the callback event.
    8402. 

  8402.  *  If argument is omitted, this method defines the callback of all events.
    8403. 

  8403.  *  If you want to modify reference argument in callback, return hash in
    8404. 

  8404.  *  callback. If you want to return value to OLE server as result of callback
    8405. 

  8405.  *  use `return' or :return.
    8406. 

  8406.  *
    8407. 

  8407.  *    ie = WIN32OLE.new('InternetExplorer.Application')
    8408. 

  8408.  *    ev = WIN32OLE_EVENT.new(ie)
    8409. 

  8409.  *    ev.on_event("NavigateComplete") {|url| puts url}
    8410. 

  8410.  *    ev.on_event() {|ev, *args| puts "#{ev} fired"} 
    8411. 

  8411.  *
    8412. 

  8412.  *    ev.on_event("BeforeNavigate2") {|*args| 
    8413. 

  8413.  *      ...
    8414. 

  8414.  *      # set true to BeforeNavigate reference argument `Cancel'.
    8415. 

  8415.  *      # Cancel is 7-th argument of BeforeNavigate,
    8416. 

  8416.  *      # so you can use 6 as key of hash instead of 'Cancel'.
    8417. 

  8417.  *      # The argument is counted from 0. 
    8418. 

  8418.  *      # The hash key of 0 means first argument.)
    8419. 

  8419.  *      {:Cancel => true}  # or {'Cancel' => true} or {6 => true}
    8420. 

  8420.  *    }
    8421. 

  8421.  *
    8422. 

  8422.  *    ev.on_event(...) {|*args|
    8423. 

  8423.  *      {:return => 1, :xxx => yyy}
    8424. 

  8424.  *    }
    8425. 

  8425.  */
    8426. 

  8426. static VALUE
    8427. 

  8427. fev_on_event(int argc, VALUE *argv, VALUE self)
    8428. 

  8428. {
    8429. 

  8429.     return ev_on_event(argc, argv, self, Qfalse);
    8430. 

  8430. }
    8431. 

  8431. 

  8432. /*
    8433. 

  8433.  *  call-seq:
    8434. 

  8434.  *     WIN32OLE_EVENT#on_event_with_outargs([event]){...}
    8435. 

  8435.  * 
    8436. 

  8436.  *  Defines the callback of event.
    8437. 

  8437.  *  If you want modify argument in callback, 
    8438. 

  8438.  *  you could use this method instead of WIN32OLE_EVENT#on_event.
    8439. 

  8439.  *
    8440. 

  8440.  *    ie = WIN32OLE.new('InternetExplorer.Application')
    8441. 

  8441.  *    ev = WIN32OLE_EVENT.new(ie)
    8442. 

  8442.  *    ev.on_event_with_outargs('BeforeNavigate2') {|*args|
    8443. 

  8443.  *      args.last[6] = true
    8444. 

  8444.  *    }
    8445. 

  8445.  */
    8446. 

  8446. static VALUE
    8447. 

  8447. fev_on_event_with_outargs(int argc, VALUE *argv, VALUE self)
    8448. 

  8448. {
    8449. 

  8449.     return ev_on_event(argc, argv, self, Qtrue);
    8450. 

  8450. }
    8451. 

  8451. 

  8452. /*
    8453. 

  8453.  *  call-seq:
    8454. 

  8454.  *     WIN32OLE_EVENT#off_event([event])
    8455. 

  8455.  * 
    8456. 

  8456.  *  removes the callback of event.
    8457. 

  8457.  *
    8458. 

  8458.  *    ie = WIN32OLE.new('InternetExplorer.Application')
    8459. 

  8459.  *    ev = WIN32OLE_EVENT.new(ie)
    8460. 

  8460.  *    ev.on_event('BeforeNavigate2') {|*args|
    8461. 

  8461.  *      args.last[6] = true
    8462. 

  8462.  *    }
    8463. 

  8463.  *      ...
    8464. 

  8464.  *    ev.off_event('BeforeNavigate2')
    8465. 

  8465.  *      ...
    8466. 

  8466.  */
    8467. 

  8467. static VALUE
    8468. 

  8468. fev_off_event(int argc, VALUE *argv, VALUE self)
    8469. 

  8469. {
    8470. 

  8470.     VALUE event = Qnil;
    8471. 

  8471.     VALUE events;
    8472. 

  8472. 

  8473.     rb_secure(4);
    8474. 

  8474.     rb_scan_args(argc, argv, "01", &event);
    8475. 

  8475.     if(!NIL_P(event)) {
    8476. 

  8476. 	if(TYPE(event) != T_STRING && TYPE(event) != T_SYMBOL) {
    8477. 

  8477. 	    rb_raise(rb_eTypeError, "wrong argument type (expected String or Symbol)");
    8478. 

  8478. 	}
    8479. 

  8479. 	if (TYPE(event) == T_SYMBOL) {
    8480. 

  8480. 	    event = rb_sym_to_s(event);
    8481. 

  8481. 	}
    8482. 

  8482.     }
    8483. 

  8483.     events = rb_ivar_get(self, id_events);
    8484. 

  8484.     if (NIL_P(events)) {
    8485. 

  8485. 	return Qnil;
    8486. 

  8486.     }
    8487. 

  8487.     ole_delete_event(events, event);
    8488. 

  8488.     return Qnil;
    8489. 

  8489. }
    8490. 

  8490. 

  8491. /*
    8492. 

  8492.  *  call-seq:
    8493. 

  8493.  *     WIN32OLE_EVENT#unadvise -> nil
    8494. 

  8494.  *
    8495. 

  8495.  *  disconnects OLE server. If this method called, then the WIN32OLE_EVENT object
    8496. 

  8496.  *  does not receive the OLE server event any more.
    8497. 

  8497.  *  This method is trial implementation.
    8498. 

  8498.  *
    8499. 

  8499.  *      ie = WIN32OLE.new('InternetExplorer.Application')
    8500. 

  8500.  *      ev = WIN32OLE_EVENT.new(ie)
    8501. 

  8501.  *      ev.on_event() {...}
    8502. 

  8502.  *         ...
    8503. 

  8503.  *      ev.unadvise
    8504. 

  8504.  *
    8505. 

  8505.  */
    8506. 

  8506. static VALUE 
    8507. 

  8507. fev_unadvise(VALUE self)
    8508. 

  8508. {
    8509. 

  8509.     struct oleeventdata *poleev;
    8510. 

  8510.     Data_Get_Struct(self, struct oleeventdata, poleev);
    8511. 

  8511.     if (poleev->pConnectionPoint) {
    8512. 

  8512.         ole_msg_loop();
    8513. 

  8513.         evs_delete(poleev->event_id);
    8514. 

  8514.         poleev->pConnectionPoint->lpVtbl->Unadvise(poleev->pConnectionPoint, poleev->dwCookie);
    8515. 

  8515.         OLE_RELEASE(poleev->pConnectionPoint);
    8516. 

  8516.         poleev->pConnectionPoint = NULL;
    8517. 

  8517.     }
    8518. 

  8518.     return Qnil;
    8519. 

  8519. }
    8520. 

  8520. 

  8521. static VALUE 
    8522. 

  8522. evs_push(VALUE ev)
    8523. 

  8523. {
    8524. 

  8524.     return rb_ary_push(ary_ole_event, ev);
    8525. 

  8525. }
    8526. 

  8526. 

  8527. static VALUE
    8528. 

  8528. evs_delete(long i)
    8529. 

  8529. {
    8530. 

  8530.     rb_ary_store(ary_ole_event, i, Qnil);
    8531. 

  8531.     return Qnil;
    8532. 

  8532. }
    8533. 

  8533. 

  8534. static VALUE 
    8535. 

  8535. evs_entry(long i)
    8536. 

  8536. {
    8537. 

  8537.     return rb_ary_entry(ary_ole_event, i);
    8538. 

  8538. }
    8539. 

  8539. 

  8540. static VALUE 
    8541. 

  8541. evs_length()
    8542. 

  8542. {
    8543. 

  8543.     return rb_funcall(ary_ole_event, rb_intern("length"), 0);
    8544. 

  8544. }
    8545. 

  8545. 

  8546. /*
    8547. 

  8547.  *  call-seq:
    8548. 

  8548.  *     WIN32OLE_EVENT#handler=
    8549. 

  8549.  *
    8550. 

  8550.  *  sets event handler object. If handler object has onXXX
    8551. 

  8551.  *  method according to XXX event, then onXXX method is called 
    8552. 

  8552.  *  when XXX event occurs.
    8553. 

  8553.  *  
    8554. 

  8554.  *  If handler object has method_missing and there is no
    8555. 

  8555.  *  method according to the event, then method_missing
    8556. 

  8556.  *  called and 1-st argument is event name.
    8557. 

  8557.  *
    8558. 

  8558.  *  If handler object has onXXX method and there is block
    8559. 

  8559.  *  defined by WIN32OLE_EVENT#on_event('XXX'){},
    8560. 

  8560.  *  then block is executed but handler object method is not called
    8561. 

  8561.  *  when XXX event occurs.
    8562. 

  8562.  *
    8563. 

  8563.  *      class Handler
    8564. 

  8564.  *        def onStatusTextChange(text)
    8565. 

  8565.  *          puts "StatusTextChanged"
    8566. 

  8566.  *        end
    8567. 

  8567.  *        def onPropertyChange(prop)
    8568. 

  8568.  *          puts "PropertyChanged"
    8569. 

  8569.  *        end
    8570. 

  8570.  *        def method_missing(ev, *arg)
    8571. 

  8571.  *          puts "other event #{ev}"
    8572. 

  8572.  *        end
    8573. 

  8573.  *      end
    8574. 

  8574.  *      
    8575. 

  8575.  *      handler = Handler.new
    8576. 

  8576.  *      ie = WIN32OLE.new('InternetExplorer.Application')
    8577. 

  8577.  *      ev = WIN32OLE_EVENT.new(ie)
    8578. 

  8578.  *      ev.on_event("StatusTextChange") {|*args|
    8579. 

  8579.  *        puts "this block executed."
    8580. 

  8580.  *        puts "handler.onStatusTextChange method is not called."
    8581. 

  8581.  *      }
    8582. 

  8582.  *      ev.handler = handler
    8583. 

  8583.  *
    8584. 

  8584.  */
    8585. 

  8585. static VALUE
    8586. 

  8586. fev_set_handler(VALUE self, VALUE val)
    8587. 

  8587. {
    8588. 

  8588.     return rb_ivar_set(self, rb_intern("handler"), val);
    8589. 

  8589. }
    8590. 

  8590. 

  8591. /*
    8592. 

  8592.  *  call-seq:
    8593. 

  8593.  *     WIN32OLE_EVENT#handler
    8594. 

  8594.  *
    8595. 

  8595.  *  returns handler object. 
    8596. 

  8596.  *  
    8597. 

  8597.  */
    8598. 

  8598. static VALUE
    8599. 

  8599. fev_get_handler(VALUE self)
    8600. 

  8600. {
    8601. 

  8601.     return rb_ivar_get(self, rb_intern("handler"));
    8602. 

  8602. }
    8603. 

  8603. 

  8604. static void 
    8605. 

  8605. olevariant_free(struct olevariantdata *pvar)
    8606. 

  8606. {
    8607. 

  8607.     VariantClear(&(pvar->realvar));
    8608. 

  8608.     VariantClear(&(pvar->var));
    8609. 

  8609.     free(pvar);
    8610. 

  8610. }
    8611. 

  8611. 

  8612. static VALUE
    8613. 

  8613. folevariant_s_allocate(VALUE klass)
    8614. 

  8614. {
    8615. 

  8615.     struct olevariantdata *pvar;
    8616. 

  8616.     VALUE obj;
    8617. 

  8617.     ole_initialize();
    8618. 

  8618.     obj = Data_Make_Struct(klass,struct olevariantdata,0,olevariant_free,pvar);
    8619. 

  8619.     VariantInit(&(pvar->var));
    8620. 

  8620.     VariantInit(&(pvar->realvar));
    8621. 

  8621.     return obj;
    8622. 

  8622. }
    8623. 

  8623. 

  8624. /*
    8625. 

  8625.  *  call-seq:
    8626. 

  8626.  *     WIN32OLE_VARIANT.array(ary, vt)
    8627. 

  8627.  *
    8628. 

  8628.  *  Returns Ruby object wrapping OLE variant whose variant type is VT_ARRAY.
    8629. 

  8629.  *  The first argument should be Array object which specifies dimensions 
    8630. 

  8630.  *  and each size of dimensions of OLE array.  
    8631. 

  8631.  *  The second argument specifies variant type of the element of OLE array.
    8632. 

  8632.  *
    8633. 

  8633.  *  The following create 2 dimensions OLE array. The first dimensions size
    8634. 

  8634.  *  is 3, and the second is 4.
    8635. 

  8635.  *
    8636. 

  8636.  *     ole_ary = WIN32OLE_VARIANT.array([3,4], VT_I4)
    8637. 

  8637.  *     ruby_ary = ole_ary.value # => [[0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0]]
    8638. 

  8638.  *
    8639. 

  8639.  */     
    8640. 

  8640. static VALUE
    8641. 

  8641. folevariant_s_array(VALUE klass, VALUE elems, VALUE vvt)
    8642. 

  8642. {
    8643. 

  8643.     VALUE obj = Qnil;
    8644. 

  8644.     VARTYPE vt;
    8645. 

  8645.     struct olevariantdata *pvar;
    8646. 

  8646.     SAFEARRAYBOUND *psab = NULL;
    8647. 

  8647.     SAFEARRAY *psa = NULL;
    8648. 

  8648.     UINT dim = 0;
    8649. 

  8649.     UINT i = 0;
    8650. 

  8650. 

  8651.     ole_initialize();
    8652. 

  8652. 

  8653.     vt = NUM2UINT(vvt);
    8654. 

  8654.     vt = (vt | VT_ARRAY);
    8655. 

  8655.     Check_Type(elems, T_ARRAY);
    8656. 

  8656.     obj = folevariant_s_allocate(klass);
    8657. 

  8657. 

  8658.     Data_Get_Struct(obj, struct olevariantdata, pvar);
    8659. 

  8659.     dim = RARRAY_LEN(elems);
    8660. 

  8660. 

  8661.     psab = ALLOC_N(SAFEARRAYBOUND, dim);
    8662. 

  8662. 

  8663.     if(!psab) {
    8664. 

  8664.         rb_raise(rb_eRuntimeError, "memory allocation error");
    8665. 

  8665.     }
    8666. 

  8666. 

  8667.     for (i = 0; i < dim; i++) {
    8668. 

  8668.         psab[i].cElements = FIX2INT(rb_ary_entry(elems, i));
    8669. 

  8669.         psab[i].lLbound = 0;
    8670. 

  8670.     }
    8671. 

  8671. 

  8672.     psa = SafeArrayCreate((VARTYPE)(vt & VT_TYPEMASK), dim, psab);
    8673. 

  8673.     if (psa == NULL) {
    8674. 

  8674.         if (psab) free(psab);
    8675. 

  8675.         rb_raise(rb_eRuntimeError, "memory allocation error(SafeArrayCreate)");
    8676. 

  8676.     }
    8677. 

  8677. 

  8678.     V_VT(&(pvar->var)) = vt;
    8679. 

  8679.     if (vt & VT_BYREF) {
    8680. 

  8680.         V_VT(&(pvar->realvar)) = (vt & ~VT_BYREF);
    8681. 

  8681.         V_ARRAY(&(pvar->realvar)) = psa;
    8682. 

  8682.         V_ARRAYREF(&(pvar->var)) = &(V_ARRAY(&(pvar->realvar)));
    8683. 

  8683.     } else {
    8684. 

  8684.         V_ARRAY(&(pvar->var)) = psa;
    8685. 

  8685.     }
    8686. 

  8686.     if (psab) free(psab);
    8687. 

  8687.     return obj;
    8688. 

  8688. }
    8689. 

  8689. 

  8690. /*
    8691. 

  8691.  *  call-seq:
    8692. 

  8692.  *     WIN32OLE_VARIANT.new(val, vartype) #=> WIN32OLE_VARIANT object.
    8693. 

  8693.  *
    8694. 

  8694.  *  Returns Ruby object wrapping OLE variant.
    8695. 

  8695.  *  The first argument specifies Ruby object to convert OLE variant variable.
    8696. 

  8696.  *  The second argument specifies VARIANT type. 
    8697. 

  8697.  *  In some situation, you need the WIN32OLE_VARIANT object to pass OLE method
    8698. 

  8698.  *
    8699. 

  8699.  *     shell = WIN32OLE.new("Shell.Application")
    8700. 

  8700.  *     folder = shell.NameSpace("C:\\Windows")
    8701. 

  8701.  *     item = folder.ParseName("tmp.txt")
    8702. 

  8702.  *     # You can't use Ruby String object to call FolderItem.InvokeVerb.
    8703. 

  8703.  *     # Instead, you have to use WIN32OLE_VARIANT object to call the method.
    8704. 

  8704.  *     shortcut = WIN32OLE_VARIANT.new("Create Shortcut(\&S)")
    8705. 

  8705.  *     item.invokeVerb(shortcut)
    8706. 

  8706.  *
    8707. 

  8707.  */     
    8708. 

  8708. static VALUE
    8709. 

  8709. folevariant_initialize(VALUE self, VALUE args)
    8710. 

  8710. {
    8711. 

  8711.     int len = 0;
    8712. 

  8712.     VARIANT var;
    8713. 

  8713.     VALUE val;
    8714. 

  8714.     VALUE vvt;
    8715. 

  8715.     VARTYPE vt;
    8716. 

  8716.     struct olevariantdata *pvar;
    8717. 

  8717. 

  8718.     len = RARRAY_LEN(args);
    8719. 

  8719.     if (len < 1 || len > 3) {
    8720. 

  8720.         rb_raise(rb_eArgError, "wrong number of arguments (%d for 1..3)", len);
    8721. 

  8721.     }
    8722. 

  8722.     VariantInit(&var);
    8723. 

  8723.     val = rb_ary_entry(args, 0);
    8724. 

  8724. 

  8725.     if(!rb_obj_is_kind_of(val, cWIN32OLE) && 
    8726. 

  8726.        !rb_obj_is_kind_of(val, cWIN32OLE_VARIANT) &&
    8727. 

  8727.        !rb_obj_is_kind_of(val, rb_cTime)) {
    8728. 

  8728. 	switch (TYPE(val)) {
    8729. 

  8729. 	case T_ARRAY:
    8730. 

  8730. 	case T_STRING:
    8731. 

  8731. 	case T_FIXNUM:
    8732. 

  8732. 	case T_BIGNUM:
    8733. 

  8733. 	case T_FLOAT:
    8734. 

  8734. 	case T_TRUE:
    8735. 

  8735. 	case T_FALSE:
    8736. 

  8736. 	case T_NIL:
    8737. 

  8737. 	    break;
    8738. 

  8738. 	default:
    8739. 

  8739. 	    rb_raise(rb_eTypeError, "can not convert WIN32OLE_VARIANT from type %s",
    8740. 

  8740. 		     rb_obj_classname(val));
    8741. 

  8741. 	}
    8742. 

  8742.     }
    8743. 

  8743. 

  8744.     Data_Get_Struct(self, struct olevariantdata, pvar);
    8745. 

  8745.     if (len == 1) {
    8746. 

  8746.         ole_val2variant(val, &(pvar->var));
    8747. 

  8747.     } else {
    8748. 

  8748.         vvt = rb_ary_entry(args, 1);
    8749. 

  8749.         vt = NUM2INT(vvt);
    8750. 

  8750.         ole_val2olevariantdata(val, vt, pvar);
    8751. 

  8751.     }
    8752. 

  8752.     vt = V_VT(&pvar->var);
    8753. 

  8753.     return self;
    8754. 

  8754. }
    8755. 

  8755. 

  8756. static SAFEARRAY * 
    8757. 

  8757. get_locked_safe_array(VALUE val)
    8758. 

  8758. {
    8759. 

  8759.     struct olevariantdata *pvar;
    8760. 

  8760.     SAFEARRAY *psa = NULL;
    8761. 

  8761.     HRESULT hr;
    8762. 

  8762.     Data_Get_Struct(val, struct olevariantdata, pvar);
    8763. 

  8763.     if (!(V_VT(&(pvar->var)) & VT_ARRAY)) {
    8764. 

  8764.         rb_raise(rb_eTypeError, "variant type is not VT_ARRAY.");
    8765. 

  8765.     }
    8766. 

  8766.     psa = V_ISBYREF(&(pvar->var)) ? *V_ARRAYREF(&(pvar->var)) : V_ARRAY(&(pvar->var));
    8767. 

  8767.     if (psa == NULL) {
    8768. 

  8768.         return psa;
    8769. 

  8769.     }
    8770. 

  8770.     hr = SafeArrayLock(psa);
    8771. 

  8771.     if (FAILED(hr)) {
    8772. 

  8772.         ole_raise(hr, rb_eRuntimeError, "failed to SafeArrayLock");
    8773. 

  8773.     }
    8774. 

  8774.     return psa;
    8775. 

  8775. }
    8776. 

  8776. 

  8777. static long *
    8778. 

  8778. ary2safe_array_index(int ary_size, VALUE *ary, SAFEARRAY *psa)
    8779. 

  8779. {
    8780. 

  8780.     long dim;
    8781. 

  8781.     long *pid;
    8782. 

  8782.     long i;
    8783. 

  8783.     dim = SafeArrayGetDim(psa);
    8784. 

  8784.     if (dim != ary_size) {
    8785. 

  8785.         rb_raise(rb_eArgError, "unmatch number of indices");
    8786. 

  8786.     }
    8787. 

  8787.     pid = ALLOC_N(long, dim);
    8788. 

  8788.     if (pid == NULL) {
    8789. 

  8789.         rb_raise(rb_eRuntimeError, "failed to allocate memory for indices");
    8790. 

  8790.     }
    8791. 

  8791.     for (i = 0; i < dim; i++) {
    8792. 

  8792.         pid[i] = NUM2INT(ary[i]);
    8793. 

  8793.     }
    8794. 

  8794.     return pid;
    8795. 

  8795. }
    8796. 

  8796. 

  8797. static void
    8798. 

  8798. unlock_safe_array(SAFEARRAY *psa) 
    8799. 

  8799. {
    8800. 

  8800.     HRESULT hr;
    8801. 

  8801.     hr = SafeArrayUnlock(psa);
    8802. 

  8802.     if (FAILED(hr)) {
    8803. 

  8803.         ole_raise(hr, rb_eRuntimeError, "failed to SafeArrayUnlock");
    8804. 

  8804.     }
    8805. 

  8805. }
    8806. 

  8806. 

  8807. /*
    8808. 

  8808.  *  call-seq:
    8809. 

  8809.  *     WIN32OLE_VARIANT[i,j,...] #=> element of OLE array.
    8810. 

  8810.  *
    8811. 

  8811.  *  Returns the element of WIN32OLE_VARIANT object(OLE array).
    8812. 

  8812.  *  This method is available only when the variant type of 
    8813. 

  8813.  *  WIN32OLE_VARIANT object is VT_ARRAY.
    8814. 

  8814.  *
    8815. 

  8815.  *  REMARK: 
    8816. 

  8816.  *     The all indicies should be 0 or natural number and 
    8817. 

  8817.  *     lower than or equal to max indicies.
    8818. 

  8818.  *     (This point is different with Ruby Array indicies.)
    8819. 

  8819.  *
    8820. 

  8820.  *     obj = WIN32OLE_VARIANT.new([[1,2,3],[4,5,6]])
    8821. 

  8821.  *     p obj[0,0] # => 1
    8822. 

  8822.  *     p obj[1,0] # => 4
    8823. 

  8823.  *     p obj[2,0] # => WIN32OLERuntimeError
    8824. 

  8824.  *     p obj[0, -1] # => WIN32OLERuntimeError
    8825. 

  8825.  *
    8826. 

  8826.  */     
    8827. 

  8827. static VALUE
    8828. 

  8828. folevariant_ary_aref(int argc, VALUE *argv, VALUE self)
    8829. 

  8829. {
    8830. 

  8830.     struct olevariantdata *pvar;
    8831. 

  8831.     SAFEARRAY *psa;
    8832. 

  8832.     VALUE val = Qnil;
    8833. 

  8833.     VARIANT variant;
    8834. 

  8834.     long *pid;
    8835. 

  8835.     HRESULT hr;
    8836. 

  8836. 

  8837.     Data_Get_Struct(self, struct olevariantdata, pvar);
    8838. 

  8838.     if (!V_ISARRAY(&(pvar->var))) {
    8839. 

  8839.         rb_raise(eWIN32OLERuntimeError, 
    8840. 

  8840.                  "`[]' is not available for this variant type object");
    8841. 

  8841.     }
    8842. 

  8842.     psa = get_locked_safe_array(self);
    8843. 

  8843.     if (psa == NULL) {
    8844. 

  8844.         return val;
    8845. 

  8845.     }
    8846. 

  8846. 

  8847.     pid = ary2safe_array_index(argc, argv, psa);
    8848. 

  8848. 

  8849.     VariantInit(&variant);
    8850. 

  8850.     V_VT(&variant) = (V_VT(&(pvar->var)) & ~VT_ARRAY) | VT_BYREF;
    8851. 

  8851.     hr = SafeArrayPtrOfIndex(psa, pid, &V_BYREF(&variant));
    8852. 

  8852.     if (FAILED(hr)) {
    8853. 

  8853.         ole_raise(hr, eWIN32OLERuntimeError, "failed to SafeArrayPtrOfIndex");
    8854. 

  8854.     }
    8855. 

  8855.     val = ole_variant2val(&variant);
    8856. 

  8856. 

  8857.     unlock_safe_array(psa);
    8858. 

  8858.     if (pid) free(pid);
    8859. 

  8859.     return val;
    8860. 

  8860. }
    8861. 

  8861. 

  8862. static VOID *
    8863. 

  8863. val2variant_ptr(VALUE val, VARIANT *var, VARTYPE vt)
    8864. 

  8864. {
    8865. 

  8865.     VOID *p = NULL;
    8866. 

  8866.     HRESULT hr = S_OK;
    8867. 

  8867.     ole_val2variant_ex(val, var, vt);
    8868. 

  8868.     if ((vt & ~VT_BYREF) == VT_VARIANT) {
    8869. 

  8869.         p = var;
    8870. 

  8870.     } else {
    8871. 

  8871.         if ( (vt & ~VT_BYREF) != V_VT(var)) {
    8872. 

  8872.             hr = VariantChangeTypeEx(var, var, 
    8873. 

  8873.                     cWIN32OLE_lcid, 0, (VARTYPE)(vt & ~VT_BYREF));
    8874. 

  8874.             if (FAILED(hr)) {
    8875. 

  8875.                 ole_raise(hr, rb_eRuntimeError, "failed to change type");
    8876. 

  8876.             }
    8877. 

  8877.         }
    8878. 

  8878.         p = get_ptr_of_variant(var);
    8879. 

  8879.     }
    8880. 

  8880.     if (p == NULL) {
    8881. 

  8881.         rb_raise(rb_eRuntimeError, "failed to get pointer of variant");
    8882. 

  8882.     }
    8883. 

  8883.     return p;
    8884. 

  8884. }
    8885. 

  8885. 

  8886. /*
    8887. 

  8887.  *  call-seq:
    8888. 

  8888.  *     WIN32OLE_VARIANT[i,j,...] = val #=> set the element of OLE array
    8889. 

  8889.  *
    8890. 

  8890.  *  Set the element of WIN32OLE_VARIANT object(OLE array) to val.
    8891. 

  8891.  *  This method is available only when the variant type of 
    8892. 

  8892.  *  WIN32OLE_VARIANT object is VT_ARRAY.
    8893. 

  8893.  *
    8894. 

  8894.  *  REMARK: 
    8895. 

  8895.  *     The all indicies should be 0 or natural number and
    8896. 

  8896.  *     lower than or equal to max indicies.
    8897. 

  8897.  *     (This point is different with Ruby Array indicies.)
    8898. 

  8898.  *
    8899. 

  8899.  *     obj = WIN32OLE_VARIANT.new([[1,2,3],[4,5,6]])
    8900. 

  8900.  *     obj[0,0] = 7
    8901. 

  8901.  *     obj[1,0] = 8
    8902. 

  8902.  *     p obj.value # => [[7,2,3], [8,5,6]]
    8903. 

  8903.  *     obj[2,0] = 9 # => WIN32OLERuntimeError
    8904. 

  8904.  *     obj[0, -1] = 9 # => WIN32OLERuntimeError
    8905. 

  8905.  *
    8906. 

  8906.  */     
    8907. 

  8907. static VALUE
    8908. 

  8908. folevariant_ary_aset(int argc, VALUE *argv, VALUE self)
    8909. 

  8909. {
    8910. 

  8910.     struct olevariantdata *pvar;
    8911. 

  8911.     SAFEARRAY *psa;
    8912. 

  8912.     VARIANT var;
    8913. 

  8913.     VARTYPE vt;
    8914. 

  8914.     long *pid;
    8915. 

  8915.     HRESULT hr;
    8916. 

  8916.     VOID *p = NULL;
    8917. 

  8917. 

  8918.     Data_Get_Struct(self, struct olevariantdata, pvar);
    8919. 

  8919.     if (!V_ISARRAY(&(pvar->var))) {
    8920. 

  8920.         rb_raise(eWIN32OLERuntimeError, 
    8921. 

  8921.                  "`[]' is not available for this variant type object");
    8922. 

  8922.     }
    8923. 

  8923.     psa = get_locked_safe_array(self);
    8924. 

  8924.     if (psa == NULL) {
    8925. 

  8925.         rb_raise(rb_eRuntimeError, "failed to get SafeArray pointer");
    8926. 

  8926.     }
    8927. 

  8927. 

  8928.     pid = ary2safe_array_index(argc-1, argv, psa);
    8929. 

  8929. 

  8930.     VariantInit(&var);
    8931. 

  8931.     vt = (V_VT(&(pvar->var)) & ~VT_ARRAY);
    8932. 

  8932.     p = val2variant_ptr(argv[argc-1], &var, vt);
    8933. 

  8933.     if ((V_VT(&var) == VT_DISPATCH && V_DISPATCH(&var) == NULL) ||
    8934. 

  8934.         (V_VT(&var) == VT_UNKNOWN && V_UNKNOWN(&var) == NULL)) {
    8935. 

  8935.         rb_raise(eWIN32OLERuntimeError, "argument does not have IDispatch or IUnknown Interface");
    8936. 

  8936.     }
    8937. 

  8937.     hr = SafeArrayPutElement(psa, pid, p);
    8938. 

  8938.     if (FAILED(hr)) {
    8939. 

  8939.         ole_raise(hr, eWIN32OLERuntimeError, "failed to SafeArrayPutElement");
    8940. 

  8940.     }
    8941. 

  8941. 

  8942.     unlock_safe_array(psa);
    8943. 

  8943.     if (pid) free(pid);
    8944. 

  8944.     return argv[argc-1];
    8945. 

  8945. }
    8946. 

  8946. 

  8947. /*
    8948. 

  8948.  *  call-seq:
    8949. 

  8949.  *     WIN32OLE_VARIANT.value #=> Ruby object.
    8950. 

  8950.  *
    8951. 

  8951.  *  Returns Ruby object value from OLE variant.
    8952. 

  8952.  *     obj = WIN32OLE_VARIANT.new(1, WIN32OLE::VARIANT::VT_BSTR)
    8953. 

  8953.  *     obj.value # => "1" (not Fixnum object, but String object "1")
    8954. 

  8954.  *
    8955. 

  8955.  */     
    8956. 

  8956. static VALUE
    8957. 

  8957. folevariant_value(VALUE self)
    8958. 

  8958. {
    8959. 

  8959.     struct olevariantdata *pvar;
    8960. 

  8960.     VALUE val = Qnil;
    8961. 

  8961.     VARTYPE vt;
    8962. 

  8962.     int dim;
    8963. 

  8963.     SAFEARRAY *psa;
    8964. 

  8964.     Data_Get_Struct(self, struct olevariantdata, pvar);
    8965. 

  8965. 

  8966.     val = ole_variant2val(&(pvar->var));
    8967. 

  8967.     vt = V_VT(&(pvar->var));
    8968. 

  8968. 

  8969.     if ((vt & ~VT_BYREF) == (VT_UI1|VT_ARRAY)) {
    8970. 

  8970.         if (vt & VT_BYREF) {
    8971. 

  8971.             psa = *V_ARRAYREF(&(pvar->var));
    8972. 

  8972.         } else {
    8973. 

  8973.             psa  = V_ARRAY(&(pvar->var));
    8974. 

  8974.         }
    8975. 

  8975.         if (!psa) {
    8976. 

  8976.             return val;
    8977. 

  8977.         }
    8978. 

  8978.         dim = SafeArrayGetDim(psa);
    8979. 

  8979.         if (dim == 1) {
    8980. 

  8980.             val = rb_funcall(val, rb_intern("pack"), 1, rb_str_new2("C*"));
    8981. 

  8981.         }
    8982. 

  8982.     }
    8983. 

  8983.     return val;
    8984. 

  8984. }
    8985. 

  8985. 

  8986. /*
    8987. 

  8987.  *  call-seq:
    8988. 

  8988.  *     WIN32OLE_VARIANT.vartype #=> OLE variant type.
    8989. 

  8989.  *
    8990. 

  8990.  *  Returns OLE variant type.
    8991. 

  8991.  *     obj = WIN32OLE_VARIANT.new("string")
    8992. 

  8992.  *     obj.vartype # => WIN32OLE::VARIANT::VT_BSTR 
    8993. 

  8993.  *
    8994. 

  8994.  */     
    8995. 

  8995. static VALUE
    8996. 

  8996. folevariant_vartype(VALUE self)
    8997. 

  8997. {
    8998. 

  8998.     struct olevariantdata *pvar;
    8999. 

  8999.     Data_Get_Struct(self, struct olevariantdata, pvar);
    9000. 

  9000.     return INT2FIX(V_VT(&pvar->var));
    9001. 

  9001. }
    9002. 

  9002. 

  9003. /*
    9004. 

  9004.  *  call-seq:
    9005. 

  9005.  *     WIN32OLE_VARIANT.value = val #=> set WIN32OLE_VARIANT value to val.
    9006. 

  9006.  *
    9007. 

  9007.  *  Sets variant value to val. If the val type does not match variant value 
    9008. 

  9008.  *  type(vartype), then val is changed to match variant value type(vartype) 
    9009. 

  9009.  *  before setting val.
    9010. 

  9010.  *  Thie method is not available when vartype is VT_ARRAY(except VT_UI1|VT_ARRAY).
    9011. 

  9011.  *  If the vartype is VT_UI1|VT_ARRAY, the val should be String object.
    9012. 

  9012.  *
    9013. 

  9013.  *     obj = WIN32OLE_VARIANT.new(1) # obj.vartype is WIN32OLE::VARIANT::VT_I4
    9014. 

  9014.  *     obj.value = 3.2 # 3.2 is changed to 3 when setting value.
    9015. 

  9015.  *     p obj.value # => 3 
    9016. 

  9016.  */     
    9017. 

  9017. static VALUE
    9018. 

  9018. folevariant_set_value(VALUE self, VALUE val)
    9019. 

  9019. {
    9020. 

  9020.     struct olevariantdata *pvar;
    9021. 

  9021.     VARTYPE vt;
    9022. 

  9022.     Data_Get_Struct(self, struct olevariantdata, pvar);
    9023. 

  9023.     vt = V_VT(&(pvar->var));
    9024. 

  9024.     if (V_ISARRAY(&(pvar->var)) && ((vt & ~VT_BYREF) != (VT_UI1|VT_ARRAY) || TYPE(val) != T_STRING)) {
    9025. 

  9025.         rb_raise(eWIN32OLERuntimeError, 
    9026. 

  9026.                  "`value=' is not available for this variant type object");
    9027. 

  9027.     }
    9028. 

  9028.     ole_val2olevariantdata(val, vt, pvar);
    9029. 

  9029.     return Qnil;
    9030. 

  9030. }
    9031. 

  9031. 

  9032. static void 
    9033. 

  9033. init_enc2cp()
    9034. 

  9034. {
    9035. 

  9035.     enc2cp_table = st_init_numtable();
    9036. 

  9036. }
    9037. 

  9037. 

  9038. static void
    9039. 

  9039. free_enc2cp()
    9040. 

  9040. {
    9041. 

  9041.     st_free_table(enc2cp_table);
    9042. 

  9042. }
    9043. 

  9043. 

  9044. void
    9045. 

  9045. Init_win32ole()
    9046. 

  9046. {
    9047. 

  9047.     ary_ole_event = rb_ary_new();
    9048. 

  9048.     rb_gc_register_mark_object(ary_ole_event);
    9049. 

  9049.     id_events = rb_intern("events");
    9050. 

  9050. 

  9051.     com_vtbl.QueryInterface = QueryInterface;
    9052. 

  9052.     com_vtbl.AddRef = AddRef;
    9053. 

  9053.     com_vtbl.Release = Release;
    9054. 

  9054.     com_vtbl.GetTypeInfoCount = GetTypeInfoCount;
    9055. 

  9055.     com_vtbl.GetTypeInfo = GetTypeInfo;
    9056. 

  9056.     com_vtbl.GetIDsOfNames = GetIDsOfNames;
    9057. 

  9057.     com_vtbl.Invoke = Invoke;
    9058. 

  9058. 

  9059.     message_filter.QueryInterface = mf_QueryInterface;
    9060. 

  9060.     message_filter.AddRef = mf_AddRef;
    9061. 

  9061.     message_filter.Release = mf_Release;
    9062. 

  9062.     message_filter.HandleInComingCall = mf_HandleInComingCall;
    9063. 

  9063.     message_filter.RetryRejectedCall = mf_RetryRejectedCall;
    9064. 

  9064.     message_filter.MessagePending = mf_MessagePending;
    9065. 

  9065.  
    9066. 

  9066.     com_hash = Data_Wrap_Struct(rb_cData, rb_mark_hash, st_free_table, st_init_numtable());
    9067. 

  9067.     rb_gc_register_mark_object(com_hash);
    9068. 

  9068. 

  9069.     cWIN32OLE = rb_define_class("WIN32OLE", rb_cObject);
    9070. 

  9070. 

  9071.     rb_define_alloc_func(cWIN32OLE, fole_s_allocate);
    9072. 

  9072. 

  9073.     rb_define_method(cWIN32OLE, "initialize", fole_initialize, -1);
    9074. 

  9074. 

  9075.     rb_define_singleton_method(cWIN32OLE, "connect", fole_s_connect, -1);
    9076. 

  9076.     rb_define_singleton_method(cWIN32OLE, "const_load", fole_s_const_load, -1);
    9077. 

  9077. 

  9078.     rb_define_singleton_method(cWIN32OLE, "ole_free", fole_s_free, 1);
    9079. 

  9079.     rb_define_singleton_method(cWIN32OLE, "ole_reference_count", fole_s_reference_count, 1);
    9080. 

  9080.     rb_define_singleton_method(cWIN32OLE, "ole_show_help", fole_s_show_help, -1);
    9081. 

  9081.     rb_define_singleton_method(cWIN32OLE, "codepage", fole_s_get_code_page, 0);
    9082. 

  9082.     rb_define_singleton_method(cWIN32OLE, "codepage=", fole_s_set_code_page, 1);
    9083. 

  9083.     rb_define_singleton_method(cWIN32OLE, "locale", fole_s_get_locale, 0);
    9084. 

  9084.     rb_define_singleton_method(cWIN32OLE, "locale=", fole_s_set_locale, 1);
    9085. 

  9085.     rb_define_singleton_method(cWIN32OLE, "create_guid", fole_s_create_guid, 0);
    9086. 

  9086.     rb_define_singleton_method(cWIN32OLE, "ole_initialize", fole_s_ole_initialize, 0);
    9087. 

  9087.     rb_define_singleton_method(cWIN32OLE, "ole_uninitialize", fole_s_ole_uninitialize, 0);
    9088. 

  9088. 

  9089.     rb_define_method(cWIN32OLE, "invoke", fole_invoke, -1);
    9090. 

  9090.     rb_define_method(cWIN32OLE, "[]", fole_getproperty_with_bracket, -1);
    9091. 

  9091.     rb_define_method(cWIN32OLE, "_invoke", fole_invoke2, 3);
    9092. 

  9092.     rb_define_method(cWIN32OLE, "_getproperty", fole_getproperty2, 3);
    9093. 

  9093.     rb_define_method(cWIN32OLE, "_setproperty", fole_setproperty2, 3);
    9094. 

  9094. 

  9095.     /* support propput method that takes an argument */
    9096. 

  9096.     rb_define_method(cWIN32OLE, "[]=", fole_setproperty_with_bracket, -1); 
    9097. 

  9097. 

  9098.     rb_define_method(cWIN32OLE, "ole_free", fole_free, 0);
    9099. 

  9099. 

  9100.     rb_define_method(cWIN32OLE, "each", fole_each, 0);
    9101. 

  9101.     rb_define_method(cWIN32OLE, "method_missing", fole_missing, -1);
    9102. 

  9102. 

  9103.     /* support setproperty method much like Perl ;-) */
    9104. 

  9104.     rb_define_method(cWIN32OLE, "setproperty", fole_setproperty, -1);
    9105. 

  9105. 

  9106.     rb_define_method(cWIN32OLE, "ole_methods", fole_methods, 0);
    9107. 

  9107.     rb_define_method(cWIN32OLE, "ole_get_methods", fole_get_methods, 0);
    9108. 

  9108.     rb_define_method(cWIN32OLE, "ole_put_methods", fole_put_methods, 0);
    9109. 

  9109.     rb_define_method(cWIN32OLE, "ole_func_methods", fole_func_methods, 0);
    9110. 

  9110. 

  9111.     rb_define_method(cWIN32OLE, "ole_method", fole_method_help, 1);
    9112. 

  9112.     rb_define_alias(cWIN32OLE, "ole_method_help", "ole_method");
    9113. 

  9113.     rb_define_method(cWIN32OLE, "ole_activex_initialize", fole_activex_initialize, 0);
    9114. 

  9114.     rb_define_method(cWIN32OLE, "ole_type", fole_type, 0);
    9115. 

  9115.     rb_define_alias(cWIN32OLE, "ole_obj_help", "ole_type");
    9116. 

  9116.     rb_define_method(cWIN32OLE, "ole_typelib", fole_typelib, 0);
    9117. 

  9117.     rb_define_method(cWIN32OLE, "ole_query_interface", fole_query_interface, 1);
    9118. 

  9118.     rb_define_method(cWIN32OLE, "ole_respond_to?", fole_respond_to, 1);
    9119. 

  9119. 

  9120.     rb_define_const(cWIN32OLE, "VERSION", rb_str_new2(WIN32OLE_VERSION));
    9121. 

  9121.     rb_define_const(cWIN32OLE, "ARGV", rb_ary_new());
    9122. 

  9122. 

  9123.     rb_define_const(cWIN32OLE, "CP_ACP", INT2FIX(CP_ACP));
    9124. 

  9124.     rb_define_const(cWIN32OLE, "CP_OEMCP", INT2FIX(CP_OEMCP));
    9125. 

  9125.     rb_define_const(cWIN32OLE, "CP_MACCP", INT2FIX(CP_MACCP));
    9126. 

  9126.     rb_define_const(cWIN32OLE, "CP_THREAD_ACP", INT2FIX(CP_THREAD_ACP));
    9127. 

  9127.     rb_define_const(cWIN32OLE, "CP_SYMBOL", INT2FIX(CP_SYMBOL));
    9128. 

  9128.     rb_define_const(cWIN32OLE, "CP_UTF7", INT2FIX(CP_UTF7));
    9129. 

  9129.     rb_define_const(cWIN32OLE, "CP_UTF8", INT2FIX(CP_UTF8));
    9130. 

  9130. 

  9131.     rb_define_const(cWIN32OLE, "LOCALE_SYSTEM_DEFAULT", INT2FIX(LOCALE_SYSTEM_DEFAULT));
    9132. 

  9132.     rb_define_const(cWIN32OLE, "LOCALE_USER_DEFAULT", INT2FIX(LOCALE_USER_DEFAULT));
    9133. 

  9133. 

  9134.     mWIN32OLE_VARIANT = rb_define_module_under(cWIN32OLE, "VARIANT");
    9135. 

  9135.     rb_define_const(mWIN32OLE_VARIANT, "VT_EMPTY", INT2FIX(VT_EMPTY));
    9136. 

  9136.     rb_define_const(mWIN32OLE_VARIANT, "VT_NULL", INT2FIX(VT_NULL));
    9137. 

  9137.     rb_define_const(mWIN32OLE_VARIANT, "VT_I2", INT2FIX(VT_I2));
    9138. 

  9138.     rb_define_const(mWIN32OLE_VARIANT, "VT_I4", INT2FIX(VT_I4));
    9139. 

  9139.     rb_define_const(mWIN32OLE_VARIANT, "VT_R4", INT2FIX(VT_R4));
    9140. 

  9140.     rb_define_const(mWIN32OLE_VARIANT, "VT_R8", INT2FIX(VT_R8));
    9141. 

  9141.     rb_define_const(mWIN32OLE_VARIANT, "VT_CY", INT2FIX(VT_CY));
    9142. 

  9142.     rb_define_const(mWIN32OLE_VARIANT, "VT_DATE", INT2FIX(VT_DATE));
    9143. 

  9143.     rb_define_const(mWIN32OLE_VARIANT, "VT_BSTR", INT2FIX(VT_BSTR));
    9144. 

  9144.     rb_define_const(mWIN32OLE_VARIANT, "VT_USERDEFINED", INT2FIX(VT_USERDEFINED));
    9145. 

  9145.     rb_define_const(mWIN32OLE_VARIANT, "VT_PTR", INT2FIX(VT_PTR));
    9146. 

  9146.     rb_define_const(mWIN32OLE_VARIANT, "VT_DISPATCH", INT2FIX(VT_DISPATCH));
    9147. 

  9147.     rb_define_const(mWIN32OLE_VARIANT, "VT_ERROR", INT2FIX(VT_ERROR));
    9148. 

  9148.     rb_define_const(mWIN32OLE_VARIANT, "VT_BOOL", INT2FIX(VT_BOOL));
    9149. 

  9149.     rb_define_const(mWIN32OLE_VARIANT, "VT_VARIANT", INT2FIX(VT_VARIANT));
    9150. 

  9150.     rb_define_const(mWIN32OLE_VARIANT, "VT_UNKNOWN", INT2FIX(VT_UNKNOWN));
    9151. 

  9151.     rb_define_const(mWIN32OLE_VARIANT, "VT_I1", INT2FIX(VT_I1));
    9152. 

  9152.     rb_define_const(mWIN32OLE_VARIANT, "VT_UI1", INT2FIX(VT_UI1));
    9153. 

  9153.     rb_define_const(mWIN32OLE_VARIANT, "VT_UI2", INT2FIX(VT_UI2));
    9154. 

  9154.     rb_define_const(mWIN32OLE_VARIANT, "VT_UI4", INT2FIX(VT_UI4));
    9155. 

  9155. #if (_MSC_VER >= 1300) || defined(__CYGWIN__) || defined(__MINGW32__)
    9156. 

  9156.     rb_define_const(mWIN32OLE_VARIANT, "VT_I8", INT2FIX(VT_I8));
    9157. 

  9157.     rb_define_const(mWIN32OLE_VARIANT, "VT_UI8", INT2FIX(VT_UI8));
    9158. 

  9158. #endif
    9159. 

  9159.     rb_define_const(mWIN32OLE_VARIANT, "VT_INT", INT2FIX(VT_INT));
    9160. 

  9160.     rb_define_const(mWIN32OLE_VARIANT, "VT_UINT", INT2FIX(VT_UINT));
    9161. 

  9161.     rb_define_const(mWIN32OLE_VARIANT, "VT_ARRAY", INT2FIX(VT_ARRAY));
    9162. 

  9162.     rb_define_const(mWIN32OLE_VARIANT, "VT_BYREF", INT2FIX(VT_BYREF));
    9163. 

  9163. 

  9164.     cWIN32OLE_TYPELIB = rb_define_class("WIN32OLE_TYPELIB", rb_cObject);
    9165. 

  9165.     rb_define_singleton_method(cWIN32OLE_TYPELIB, "typelibs", foletypelib_s_typelibs, 0);
    9166. 

  9166.     rb_define_alloc_func(cWIN32OLE_TYPELIB, foletypelib_s_allocate);
    9167. 

  9167.     rb_define_method(cWIN32OLE_TYPELIB, "initialize", foletypelib_initialize, -2);
    9168. 

  9168.     rb_define_method(cWIN32OLE_TYPELIB, "guid", foletypelib_guid, 0);
    9169. 

  9169.     rb_define_method(cWIN32OLE_TYPELIB, "name", foletypelib_name, 0);
    9170. 

  9170.     rb_define_method(cWIN32OLE_TYPELIB, "version", foletypelib_version, 0);
    9171. 

  9171.     rb_define_method(cWIN32OLE_TYPELIB, "major_version", foletypelib_major_version, 0);
    9172. 

  9172.     rb_define_method(cWIN32OLE_TYPELIB, "minor_version", foletypelib_minor_version, 0);
    9173. 

  9173.     rb_define_method(cWIN32OLE_TYPELIB, "path", foletypelib_path, 0);
    9174. 

  9174.     rb_define_method(cWIN32OLE_TYPELIB, "ole_types", foletypelib_ole_types, 0);
    9175. 

  9175.     rb_define_alias(cWIN32OLE_TYPELIB, "ole_classes", "ole_types");
    9176. 

  9176.     rb_define_method(cWIN32OLE_TYPELIB, "visible?", foletypelib_visible, 0);
    9177. 

  9177.     rb_define_method(cWIN32OLE_TYPELIB, "library_name", foletypelib_library_name, 0);
    9178. 

  9178.     rb_define_alias(cWIN32OLE_TYPELIB, "to_s", "name");
    9179. 

  9179.     rb_define_method(cWIN32OLE_TYPELIB, "inspect", foletypelib_inspect, 0);
    9180. 

  9180.     
    9181. 

  9181.     cWIN32OLE_TYPE = rb_define_class("WIN32OLE_TYPE", rb_cObject);
    9182. 

  9182.     rb_define_singleton_method(cWIN32OLE_TYPE, "ole_classes", foletype_s_ole_classes, 1);
    9183. 

  9183.     rb_define_singleton_method(cWIN32OLE_TYPE, "typelibs", foletype_s_typelibs, 0);
    9184. 

  9184.     rb_define_singleton_method(cWIN32OLE_TYPE, "progids", foletype_s_progids, 0);
    9185. 

  9185.     rb_define_alloc_func(cWIN32OLE_TYPE, foletype_s_allocate);
    9186. 

  9186.     rb_define_method(cWIN32OLE_TYPE, "initialize", foletype_initialize, 2);
    9187. 

  9187.     rb_define_method(cWIN32OLE_TYPE, "name", foletype_name, 0);
    9188. 

  9188.     rb_define_method(cWIN32OLE_TYPE, "ole_type", foletype_ole_type, 0);
    9189. 

  9189.     rb_define_method(cWIN32OLE_TYPE, "guid", foletype_guid, 0);
    9190. 

  9190.     rb_define_method(cWIN32OLE_TYPE, "progid", foletype_progid, 0);
    9191. 

  9191.     rb_define_method(cWIN32OLE_TYPE, "visible?", foletype_visible, 0);
    9192. 

  9192.     rb_define_alias(cWIN32OLE_TYPE, "to_s", "name");
    9193. 

  9193.     rb_define_method(cWIN32OLE_TYPE, "major_version", foletype_major_version, 0);
    9194. 

  9194.     rb_define_method(cWIN32OLE_TYPE, "minor_version", foletype_minor_version, 0);
    9195. 

  9195.     rb_define_method(cWIN32OLE_TYPE, "typekind", foletype_typekind, 0);
    9196. 

  9196.     rb_define_method(cWIN32OLE_TYPE, "helpstring", foletype_helpstring, 0);
    9197. 

  9197.     rb_define_method(cWIN32OLE_TYPE, "src_type", foletype_src_type, 0);
    9198. 

  9198.     rb_define_method(cWIN32OLE_TYPE, "helpfile", foletype_helpfile, 0);
    9199. 

  9199.     rb_define_method(cWIN32OLE_TYPE, "helpcontext", foletype_helpcontext, 0);
    9200. 

  9200.     rb_define_method(cWIN32OLE_TYPE, "variables", foletype_variables, 0);
    9201. 

  9201.     rb_define_method(cWIN32OLE_TYPE, "ole_methods", foletype_methods, 0);
    9202. 

  9202.     rb_define_method(cWIN32OLE_TYPE, "ole_typelib", foletype_ole_typelib, 0);
    9203. 

  9203.     rb_define_method(cWIN32OLE_TYPE, "implemented_ole_types", foletype_impl_ole_types, 0);
    9204. 

  9204.     rb_define_method(cWIN32OLE_TYPE, "source_ole_types", foletype_source_ole_types, 0);
    9205. 

  9205.     rb_define_method(cWIN32OLE_TYPE, "default_event_sources", foletype_default_event_sources, 0);
    9206. 

  9206.     rb_define_method(cWIN32OLE_TYPE, "default_ole_types", foletype_default_ole_types, 0);
    9207. 

  9207.     rb_define_method(cWIN32OLE_TYPE, "inspect", foletype_inspect, 0);
    9208. 

  9208. 

  9209.     cWIN32OLE_VARIABLE = rb_define_class("WIN32OLE_VARIABLE", rb_cObject);
    9210. 

  9210.     rb_define_method(cWIN32OLE_VARIABLE, "name", folevariable_name, 0);
    9211. 

  9211.     rb_define_method(cWIN32OLE_VARIABLE, "ole_type", folevariable_ole_type, 0);
    9212. 

  9212.     rb_define_method(cWIN32OLE_VARIABLE, "ole_type_detail", folevariable_ole_type_detail, 0);
    9213. 

  9213.     rb_define_method(cWIN32OLE_VARIABLE, "value", folevariable_value, 0);
    9214. 

  9214.     rb_define_method(cWIN32OLE_VARIABLE, "visible?", folevariable_visible, 0);
    9215. 

  9215.     rb_define_method(cWIN32OLE_VARIABLE, "variable_kind", folevariable_variable_kind, 0);
    9216. 

  9216.     rb_define_method(cWIN32OLE_VARIABLE, "varkind", folevariable_varkind, 0);
    9217. 

  9217.     rb_define_method(cWIN32OLE_VARIABLE, "inspect", folevariable_inspect, 0);
    9218. 

  9218.     rb_define_alias(cWIN32OLE_VARIABLE, "to_s", "name");
    9219. 

  9219. 

  9220.     cWIN32OLE_METHOD = rb_define_class("WIN32OLE_METHOD", rb_cObject);
    9221. 

  9221.     rb_define_alloc_func(cWIN32OLE_METHOD, folemethod_s_allocate);
    9222. 

  9222.     rb_define_method(cWIN32OLE_METHOD, "initialize", folemethod_initialize, 2);
    9223. 

  9223.     rb_define_method(cWIN32OLE_METHOD, "name", folemethod_name, 0);
    9224. 

  9224.     rb_define_method(cWIN32OLE_METHOD, "return_type", folemethod_return_type, 0);
    9225. 

  9225.     rb_define_method(cWIN32OLE_METHOD, "return_vtype", folemethod_return_vtype, 0);
    9226. 

  9226.     rb_define_method(cWIN32OLE_METHOD, "return_type_detail", folemethod_return_type_detail, 0);
    9227. 

  9227.     rb_define_method(cWIN32OLE_METHOD, "invoke_kind", folemethod_invoke_kind, 0);
    9228. 

  9228.     rb_define_method(cWIN32OLE_METHOD, "invkind", folemethod_invkind, 0);
    9229. 

  9229.     rb_define_method(cWIN32OLE_METHOD, "visible?", folemethod_visible, 0);
    9230. 

  9230.     rb_define_method(cWIN32OLE_METHOD, "event?", folemethod_event, 0);
    9231. 

  9231.     rb_define_method(cWIN32OLE_METHOD, "event_interface", folemethod_event_interface, 0);
    9232. 

  9232.     rb_define_method(cWIN32OLE_METHOD, "helpstring", folemethod_helpstring, 0);
    9233. 

  9233.     rb_define_method(cWIN32OLE_METHOD, "helpfile", folemethod_helpfile, 0);
    9234. 

  9234.     rb_define_method(cWIN32OLE_METHOD, "helpcontext", folemethod_helpcontext, 0);
    9235. 

  9235.     rb_define_method(cWIN32OLE_METHOD, "dispid", folemethod_dispid, 0);
    9236. 

  9236.     rb_define_method(cWIN32OLE_METHOD, "offset_vtbl", folemethod_offset_vtbl, 0);
    9237. 

  9237.     rb_define_method(cWIN32OLE_METHOD, "size_params", folemethod_size_params, 0);
    9238. 

  9238.     rb_define_method(cWIN32OLE_METHOD, "size_opt_params", folemethod_size_opt_params, 0);
    9239. 

  9239.     rb_define_method(cWIN32OLE_METHOD, "params", folemethod_params, 0);
    9240. 

  9240.     rb_define_alias(cWIN32OLE_METHOD, "to_s", "name");
    9241. 

  9241.     rb_define_method(cWIN32OLE_METHOD, "inspect", folemethod_inspect, 0);
    9242. 

  9242. 

  9243.     cWIN32OLE_PARAM = rb_define_class("WIN32OLE_PARAM", rb_cObject);
    9244. 

  9244.     rb_define_alloc_func(cWIN32OLE_PARAM, foleparam_s_allocate);
    9245. 

  9245.     rb_define_method(cWIN32OLE_PARAM, "initialize", foleparam_initialize, 2);
    9246. 

  9246.     rb_define_method(cWIN32OLE_PARAM, "name", foleparam_name, 0);
    9247. 

  9247.     rb_define_method(cWIN32OLE_PARAM, "ole_type", foleparam_ole_type, 0);
    9248. 

  9248.     rb_define_method(cWIN32OLE_PARAM, "ole_type_detail", foleparam_ole_type_detail, 0);
    9249. 

  9249.     rb_define_method(cWIN32OLE_PARAM, "input?", foleparam_input, 0);
    9250. 

  9250.     rb_define_method(cWIN32OLE_PARAM, "output?", foleparam_output, 0);
    9251. 

  9251.     rb_define_method(cWIN32OLE_PARAM, "optional?", foleparam_optional, 0);
    9252. 

  9252.     rb_define_method(cWIN32OLE_PARAM, "retval?", foleparam_retval, 0);
    9253. 

  9253.     rb_define_method(cWIN32OLE_PARAM, "default", foleparam_default, 0);
    9254. 

  9254.     rb_define_alias(cWIN32OLE_PARAM, "to_s", "name");
    9255. 

  9255.     rb_define_method(cWIN32OLE_PARAM, "inspect", foleparam_inspect, 0);
    9256. 

  9256.  
    9257. 

  9257.     cWIN32OLE_EVENT = rb_define_class("WIN32OLE_EVENT", rb_cObject);
    9258. 

  9258.     rb_define_singleton_method(cWIN32OLE_EVENT, "message_loop", fev_s_msg_loop, 0);
    9259. 

  9259.     rb_define_alloc_func(cWIN32OLE_EVENT, fev_s_allocate);
    9260. 

  9260.     rb_define_method(cWIN32OLE_EVENT, "initialize", fev_initialize, -1);
    9261. 

  9261.     rb_define_method(cWIN32OLE_EVENT, "on_event", fev_on_event, -1);
    9262. 

  9262.     rb_define_method(cWIN32OLE_EVENT, "on_event_with_outargs", fev_on_event_with_outargs, -1);
    9263. 

  9263.     rb_define_method(cWIN32OLE_EVENT, "off_event", fev_off_event, -1);
    9264. 

  9264.     rb_define_method(cWIN32OLE_EVENT, "unadvise", fev_unadvise, 0);
    9265. 

  9265.     rb_define_method(cWIN32OLE_EVENT, "handler=", fev_set_handler, 1);
    9266. 

  9266.     rb_define_method(cWIN32OLE_EVENT, "handler", fev_get_handler, 0);
    9267. 

  9267. 

  9268.     cWIN32OLE_VARIANT = rb_define_class("WIN32OLE_VARIANT", rb_cObject);
    9269. 

  9269.     rb_define_alloc_func(cWIN32OLE_VARIANT, folevariant_s_allocate);
    9270. 

  9270.     rb_define_singleton_method(cWIN32OLE_VARIANT, "array", folevariant_s_array, 2);
    9271. 

  9271.     rb_define_method(cWIN32OLE_VARIANT, "initialize", folevariant_initialize, -2);
    9272. 

  9272.     rb_define_method(cWIN32OLE_VARIANT, "value", folevariant_value, 0);
    9273. 

  9273.     rb_define_method(cWIN32OLE_VARIANT, "value=", folevariant_set_value, 1);
    9274. 

  9274.     rb_define_method(cWIN32OLE_VARIANT, "vartype", folevariant_vartype, 0);
    9275. 

  9275.     rb_define_method(cWIN32OLE_VARIANT, "[]", folevariant_ary_aref, -1);
    9276. 

  9276.     rb_define_method(cWIN32OLE_VARIANT, "[]=", folevariant_ary_aset, -1);
    9277. 

  9277.     rb_define_const(cWIN32OLE_VARIANT, "Empty", rb_funcall(cWIN32OLE_VARIANT, rb_intern("new"), 2, Qnil, INT2FIX(VT_EMPTY)));
    9278. 

  9278.     rb_define_const(cWIN32OLE_VARIANT, "Null", rb_funcall(cWIN32OLE_VARIANT, rb_intern("new"), 2, Qnil, INT2FIX(VT_NULL)));
    9279. 

  9279.     rb_define_const(cWIN32OLE_VARIANT, "Nothing", rb_funcall(cWIN32OLE_VARIANT, rb_intern("new"), 2, Qnil, INT2FIX(VT_DISPATCH)));
    9280. 

  9280. 

  9281.     eWIN32OLERuntimeError = rb_define_class("WIN32OLERuntimeError", rb_eRuntimeError);
    9282. 

  9282. 

  9283.     init_enc2cp();
    9284. 

  9284.     atexit((void (*)(void))free_enc2cp);
    9285. 

  9285.     ole_init_cp();
    9286. 

  9286. }
    9287. 

  9287.