win32ole 1.8.8

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (47) hide show
  1. checksums.yaml +7 -0
  2. data/.gitignore +8 -0
  3. data/.travis.yml +6 -0
  4. data/Gemfile +7 -0
  5. data/LICENSE.txt +22 -0
  6. data/README.md +56 -0
  7. data/Rakefile +10 -0
  8. data/bin/console +14 -0
  9. data/bin/setup +8 -0
  10. data/ext/win32ole/depend +12 -0
  11. data/ext/win32ole/extconf.rb +45 -0
  12. data/ext/win32ole/sample/excel1.rb +37 -0
  13. data/ext/win32ole/sample/excel2.rb +31 -0
  14. data/ext/win32ole/sample/excel3.rb +21 -0
  15. data/ext/win32ole/sample/ie.rb +12 -0
  16. data/ext/win32ole/sample/ieconst.rb +33 -0
  17. data/ext/win32ole/sample/ienavi.rb +41 -0
  18. data/ext/win32ole/sample/ienavi2.rb +41 -0
  19. data/ext/win32ole/sample/oledirs.rb +24 -0
  20. data/ext/win32ole/sample/olegen.rb +348 -0
  21. data/ext/win32ole/sample/xml.rb +7307 -0
  22. data/ext/win32ole/win32ole.c +4140 -0
  23. data/ext/win32ole/win32ole.h +155 -0
  24. data/ext/win32ole/win32ole_error.c +84 -0
  25. data/ext/win32ole/win32ole_error.h +9 -0
  26. data/ext/win32ole/win32ole_event.c +1277 -0
  27. data/ext/win32ole/win32ole_event.h +6 -0
  28. data/ext/win32ole/win32ole_method.c +950 -0
  29. data/ext/win32ole/win32ole_method.h +16 -0
  30. data/ext/win32ole/win32ole_param.c +438 -0
  31. data/ext/win32ole/win32ole_param.h +8 -0
  32. data/ext/win32ole/win32ole_record.c +604 -0
  33. data/ext/win32ole/win32ole_record.h +10 -0
  34. data/ext/win32ole/win32ole_type.c +915 -0
  35. data/ext/win32ole/win32ole_type.h +8 -0
  36. data/ext/win32ole/win32ole_typelib.c +844 -0
  37. data/ext/win32ole/win32ole_typelib.h +11 -0
  38. data/ext/win32ole/win32ole_variable.c +380 -0
  39. data/ext/win32ole/win32ole_variable.h +8 -0
  40. data/ext/win32ole/win32ole_variant.c +733 -0
  41. data/ext/win32ole/win32ole_variant.h +9 -0
  42. data/ext/win32ole/win32ole_variant_m.c +149 -0
  43. data/ext/win32ole/win32ole_variant_m.h +7 -0
  44. data/lib/win32ole.rb +33 -0
  45. data/lib/win32ole/property.rb +17 -0
  46. data/win32ole.gemspec +22 -0
  47. metadata +91 -0
@@ -0,0 +1,10 @@
1
+ #ifndef WIN32OLE_RECORD_H
2
+ #define WIN32OLE_RECORD_H 1
3
+
4
+ VALUE cWIN32OLE_RECORD;
5
+ void ole_rec2variant(VALUE rec, VARIANT *var);
6
+ void olerecord_set_ivar(VALUE obj, IRecordInfo *pri, void *prec);
7
+ VALUE create_win32ole_record(IRecordInfo *pri, void *prec);
8
+ void Init_win32ole_record(void);
9
+
10
+ #endif
@@ -0,0 +1,915 @@
1
+ #include "win32ole.h"
2
+
3
+ struct oletypedata {
4
+ ITypeInfo *pTypeInfo;
5
+ };
6
+
7
+ static void oletype_free(void *ptr);
8
+ static size_t oletype_size(const void *ptr);
9
+ static VALUE foletype_s_ole_classes(VALUE self, VALUE typelib);
10
+ static VALUE foletype_s_typelibs(VALUE self);
11
+ static VALUE foletype_s_progids(VALUE self);
12
+ static VALUE oletype_set_member(VALUE self, ITypeInfo *pTypeInfo, VALUE name);
13
+ static VALUE foletype_s_allocate(VALUE klass);
14
+ static VALUE oleclass_from_typelib(VALUE self, ITypeLib *pTypeLib, VALUE oleclass);
15
+ static VALUE foletype_initialize(VALUE self, VALUE typelib, VALUE oleclass);
16
+ static VALUE foletype_name(VALUE self);
17
+ static VALUE ole_ole_type(ITypeInfo *pTypeInfo);
18
+ static VALUE foletype_ole_type(VALUE self);
19
+ static VALUE ole_type_guid(ITypeInfo *pTypeInfo);
20
+ static VALUE foletype_guid(VALUE self);
21
+ static VALUE ole_type_progid(ITypeInfo *pTypeInfo);
22
+ static VALUE foletype_progid(VALUE self);
23
+ static VALUE ole_type_visible(ITypeInfo *pTypeInfo);
24
+ static VALUE foletype_visible(VALUE self);
25
+ static VALUE ole_type_major_version(ITypeInfo *pTypeInfo);
26
+ static VALUE foletype_major_version(VALUE self);
27
+ static VALUE ole_type_minor_version(ITypeInfo *pTypeInfo);
28
+ static VALUE foletype_minor_version(VALUE self);
29
+ static VALUE ole_type_typekind(ITypeInfo *pTypeInfo);
30
+ static VALUE foletype_typekind(VALUE self);
31
+ static VALUE ole_type_helpstring(ITypeInfo *pTypeInfo);
32
+ static VALUE foletype_helpstring(VALUE self);
33
+ static VALUE ole_type_src_type(ITypeInfo *pTypeInfo);
34
+ static VALUE foletype_src_type(VALUE self);
35
+ static VALUE ole_type_helpfile(ITypeInfo *pTypeInfo);
36
+ static VALUE foletype_helpfile(VALUE self);
37
+ static VALUE ole_type_helpcontext(ITypeInfo *pTypeInfo);
38
+ static VALUE foletype_helpcontext(VALUE self);
39
+ static VALUE ole_variables(ITypeInfo *pTypeInfo);
40
+ static VALUE foletype_variables(VALUE self);
41
+ static VALUE foletype_methods(VALUE self);
42
+ static VALUE foletype_ole_typelib(VALUE self);
43
+ static VALUE ole_type_impl_ole_types(ITypeInfo *pTypeInfo, int implflags);
44
+ static VALUE foletype_impl_ole_types(VALUE self);
45
+ static VALUE foletype_source_ole_types(VALUE self);
46
+ static VALUE foletype_default_event_sources(VALUE self);
47
+ static VALUE foletype_default_ole_types(VALUE self);
48
+ static VALUE foletype_inspect(VALUE self);
49
+
50
+ static const rb_data_type_t oletype_datatype = {
51
+ "win32ole_type",
52
+ {NULL, oletype_free, oletype_size,},
53
+ 0, 0, RUBY_TYPED_FREE_IMMEDIATELY
54
+ };
55
+
56
+ /*
57
+ * Document-class: WIN32OLE_TYPE
58
+ *
59
+ * <code>WIN32OLE_TYPE</code> objects represent OLE type libarary information.
60
+ */
61
+
62
+ static void
63
+ oletype_free(void *ptr)
64
+ {
65
+ struct oletypedata *poletype = ptr;
66
+ OLE_FREE(poletype->pTypeInfo);
67
+ free(poletype);
68
+ }
69
+
70
+ static size_t
71
+ oletype_size(const void *ptr)
72
+ {
73
+ return ptr ? sizeof(struct oletypedata) : 0;
74
+ }
75
+
76
+ ITypeInfo *itypeinfo(VALUE self)
77
+ {
78
+ struct oletypedata *ptype;
79
+ TypedData_Get_Struct(self, struct oletypedata, &oletype_datatype, ptype);
80
+ return ptype->pTypeInfo;
81
+ }
82
+
83
+ VALUE
84
+ ole_type_from_itypeinfo(ITypeInfo *pTypeInfo)
85
+ {
86
+ ITypeLib *pTypeLib;
87
+ VALUE type = Qnil;
88
+ HRESULT hr;
89
+ unsigned int index;
90
+ BSTR bstr;
91
+
92
+ hr = pTypeInfo->lpVtbl->GetContainingTypeLib( pTypeInfo, &pTypeLib, &index );
93
+ if(FAILED(hr)) {
94
+ return Qnil;
95
+ }
96
+ hr = pTypeLib->lpVtbl->GetDocumentation( pTypeLib, index,
97
+ &bstr, NULL, NULL, NULL);
98
+ OLE_RELEASE(pTypeLib);
99
+ if (FAILED(hr)) {
100
+ return Qnil;
101
+ }
102
+ type = create_win32ole_type(pTypeInfo, WC2VSTR(bstr));
103
+ return type;
104
+ }
105
+
106
+
107
+ /*
108
+ * call-seq:
109
+ * WIN32OLE_TYPE.ole_classes(typelib)
110
+ *
111
+ * Returns array of WIN32OLE_TYPE objects defined by the <i>typelib</i> type library.
112
+ * This method will be OBSOLETE. Use WIN32OLE_TYPELIB.new(typelib).ole_classes instead.
113
+ */
114
+ static VALUE
115
+ foletype_s_ole_classes(VALUE self, VALUE typelib)
116
+ {
117
+ VALUE obj;
118
+
119
+ /*
120
+ rb_warn("%s is obsolete; use %s instead.",
121
+ "WIN32OLE_TYPE.ole_classes",
122
+ "WIN32OLE_TYPELIB.new(typelib).ole_types");
123
+ */
124
+ obj = rb_funcall(cWIN32OLE_TYPELIB, rb_intern("new"), 1, typelib);
125
+ return rb_funcall(obj, rb_intern("ole_types"), 0);
126
+ }
127
+
128
+ /*
129
+ * call-seq:
130
+ * WIN32OLE_TYPE.typelibs
131
+ *
132
+ * Returns array of type libraries.
133
+ * This method will be OBSOLETE. Use WIN32OLE_TYPELIB.typelibs.collect{|t| t.name} instead.
134
+ *
135
+ */
136
+ static VALUE
137
+ foletype_s_typelibs(VALUE self)
138
+ {
139
+ /*
140
+ rb_warn("%s is obsolete. use %s instead.",
141
+ "WIN32OLE_TYPE.typelibs",
142
+ "WIN32OLE_TYPELIB.typelibs.collect{t|t.name}");
143
+ */
144
+ return rb_eval_string("WIN32OLE_TYPELIB.typelibs.collect{|t|t.name}");
145
+ }
146
+
147
+ /*
148
+ * call-seq:
149
+ * WIN32OLE_TYPE.progids
150
+ *
151
+ * Returns array of ProgID.
152
+ */
153
+ static VALUE
154
+ foletype_s_progids(VALUE self)
155
+ {
156
+ HKEY hclsids, hclsid;
157
+ DWORD i;
158
+ LONG err;
159
+ VALUE clsid;
160
+ VALUE v = rb_str_new2("");
161
+ VALUE progids = rb_ary_new();
162
+
163
+ err = reg_open_key(HKEY_CLASSES_ROOT, "CLSID", &hclsids);
164
+ if(err != ERROR_SUCCESS) {
165
+ return progids;
166
+ }
167
+ for(i = 0; ; i++) {
168
+ clsid = reg_enum_key(hclsids, i);
169
+ if (clsid == Qnil)
170
+ break;
171
+ err = reg_open_vkey(hclsids, clsid, &hclsid);
172
+ if (err != ERROR_SUCCESS)
173
+ continue;
174
+ if ((v = reg_get_val2(hclsid, "ProgID")) != Qnil)
175
+ rb_ary_push(progids, v);
176
+ if ((v = reg_get_val2(hclsid, "VersionIndependentProgID")) != Qnil)
177
+ rb_ary_push(progids, v);
178
+ RegCloseKey(hclsid);
179
+ }
180
+ RegCloseKey(hclsids);
181
+ return progids;
182
+ }
183
+
184
+ static VALUE
185
+ oletype_set_member(VALUE self, ITypeInfo *pTypeInfo, VALUE name)
186
+ {
187
+ struct oletypedata *ptype;
188
+ TypedData_Get_Struct(self, struct oletypedata, &oletype_datatype, ptype);
189
+ rb_ivar_set(self, rb_intern("name"), name);
190
+ ptype->pTypeInfo = pTypeInfo;
191
+ OLE_ADDREF(pTypeInfo);
192
+ return self;
193
+ }
194
+
195
+ static VALUE
196
+ foletype_s_allocate(VALUE klass)
197
+ {
198
+ struct oletypedata *poletype;
199
+ VALUE obj;
200
+ ole_initialize();
201
+ obj = TypedData_Make_Struct(klass,struct oletypedata, &oletype_datatype, poletype);
202
+ poletype->pTypeInfo = NULL;
203
+ return obj;
204
+ }
205
+
206
+ VALUE
207
+ create_win32ole_type(ITypeInfo *pTypeInfo, VALUE name)
208
+ {
209
+ VALUE obj = foletype_s_allocate(cWIN32OLE_TYPE);
210
+ oletype_set_member(obj, pTypeInfo, name);
211
+ return obj;
212
+ }
213
+
214
+ static VALUE
215
+ oleclass_from_typelib(VALUE self, ITypeLib *pTypeLib, VALUE oleclass)
216
+ {
217
+
218
+ long count;
219
+ int i;
220
+ HRESULT hr;
221
+ BSTR bstr;
222
+ VALUE typelib;
223
+ ITypeInfo *pTypeInfo;
224
+
225
+ VALUE found = Qfalse;
226
+
227
+ count = pTypeLib->lpVtbl->GetTypeInfoCount(pTypeLib);
228
+ for (i = 0; i < count && found == Qfalse; i++) {
229
+ hr = pTypeLib->lpVtbl->GetTypeInfo(pTypeLib, i, &pTypeInfo);
230
+ if (FAILED(hr))
231
+ continue;
232
+ hr = pTypeLib->lpVtbl->GetDocumentation(pTypeLib, i,
233
+ &bstr, NULL, NULL, NULL);
234
+ if (FAILED(hr))
235
+ continue;
236
+ typelib = WC2VSTR(bstr);
237
+ if (rb_str_cmp(oleclass, typelib) == 0) {
238
+ oletype_set_member(self, pTypeInfo, typelib);
239
+ found = Qtrue;
240
+ }
241
+ OLE_RELEASE(pTypeInfo);
242
+ }
243
+ return found;
244
+ }
245
+
246
+ /*
247
+ * call-seq:
248
+ * WIN32OLE_TYPE.new(typelib, ole_class) -> WIN32OLE_TYPE object
249
+ *
250
+ * Returns a new WIN32OLE_TYPE object.
251
+ * The first argument <i>typelib</i> specifies OLE type library name.
252
+ * The second argument specifies OLE class name.
253
+ *
254
+ * WIN32OLE_TYPE.new('Microsoft Excel 9.0 Object Library', 'Application')
255
+ * # => WIN32OLE_TYPE object of Application class of Excel.
256
+ */
257
+ static VALUE
258
+ foletype_initialize(VALUE self, VALUE typelib, VALUE oleclass)
259
+ {
260
+ VALUE file;
261
+ OLECHAR * pbuf;
262
+ ITypeLib *pTypeLib;
263
+ HRESULT hr;
264
+
265
+ SafeStringValue(oleclass);
266
+ SafeStringValue(typelib);
267
+ file = typelib_file(typelib);
268
+ if (file == Qnil) {
269
+ file = typelib;
270
+ }
271
+ pbuf = ole_vstr2wc(file);
272
+ hr = LoadTypeLibEx(pbuf, REGKIND_NONE, &pTypeLib);
273
+ if (FAILED(hr))
274
+ ole_raise(hr, eWIN32OLERuntimeError, "failed to LoadTypeLibEx");
275
+ SysFreeString(pbuf);
276
+ if (oleclass_from_typelib(self, pTypeLib, oleclass) == Qfalse) {
277
+ OLE_RELEASE(pTypeLib);
278
+ rb_raise(eWIN32OLERuntimeError, "not found `%s` in `%s`",
279
+ StringValuePtr(oleclass), StringValuePtr(typelib));
280
+ }
281
+ OLE_RELEASE(pTypeLib);
282
+ return self;
283
+ }
284
+
285
+ /*
286
+ * call-seq:
287
+ * WIN32OLE_TYPE#name #=> OLE type name
288
+ *
289
+ * Returns OLE type name.
290
+ * tobj = WIN32OLE_TYPE.new('Microsoft Excel 9.0 Object Library', 'Application')
291
+ * puts tobj.name # => Application
292
+ */
293
+ static VALUE
294
+ foletype_name(VALUE self)
295
+ {
296
+ return rb_ivar_get(self, rb_intern("name"));
297
+ }
298
+
299
+ static VALUE
300
+ ole_ole_type(ITypeInfo *pTypeInfo)
301
+ {
302
+ HRESULT hr;
303
+ TYPEATTR *pTypeAttr;
304
+ VALUE type = Qnil;
305
+ hr = OLE_GET_TYPEATTR(pTypeInfo, &pTypeAttr);
306
+ if(FAILED(hr)){
307
+ return type;
308
+ }
309
+ switch(pTypeAttr->typekind) {
310
+ case TKIND_ENUM:
311
+ type = rb_str_new2("Enum");
312
+ break;
313
+ case TKIND_RECORD:
314
+ type = rb_str_new2("Record");
315
+ break;
316
+ case TKIND_MODULE:
317
+ type = rb_str_new2("Module");
318
+ break;
319
+ case TKIND_INTERFACE:
320
+ type = rb_str_new2("Interface");
321
+ break;
322
+ case TKIND_DISPATCH:
323
+ type = rb_str_new2("Dispatch");
324
+ break;
325
+ case TKIND_COCLASS:
326
+ type = rb_str_new2("Class");
327
+ break;
328
+ case TKIND_ALIAS:
329
+ type = rb_str_new2("Alias");
330
+ break;
331
+ case TKIND_UNION:
332
+ type = rb_str_new2("Union");
333
+ break;
334
+ case TKIND_MAX:
335
+ type = rb_str_new2("Max");
336
+ break;
337
+ default:
338
+ type = Qnil;
339
+ break;
340
+ }
341
+ OLE_RELEASE_TYPEATTR(pTypeInfo, pTypeAttr);
342
+ return type;
343
+ }
344
+
345
+ /*
346
+ * call-seq:
347
+ * WIN32OLE_TYPE#ole_type #=> OLE type string.
348
+ *
349
+ * returns type of OLE class.
350
+ * tobj = WIN32OLE_TYPE.new('Microsoft Excel 9.0 Object Library', 'Application')
351
+ * puts tobj.ole_type # => Class
352
+ */
353
+ static VALUE
354
+ foletype_ole_type(VALUE self)
355
+ {
356
+ ITypeInfo *pTypeInfo = itypeinfo(self);
357
+ return ole_ole_type(pTypeInfo);
358
+ }
359
+
360
+ static VALUE
361
+ ole_type_guid(ITypeInfo *pTypeInfo)
362
+ {
363
+ HRESULT hr;
364
+ TYPEATTR *pTypeAttr;
365
+ int len;
366
+ OLECHAR bstr[80];
367
+ VALUE guid = Qnil;
368
+ hr = OLE_GET_TYPEATTR(pTypeInfo, &pTypeAttr);
369
+ if (FAILED(hr))
370
+ return guid;
371
+ len = StringFromGUID2(&pTypeAttr->guid, bstr, sizeof(bstr)/sizeof(OLECHAR));
372
+ if (len > 3) {
373
+ guid = ole_wc2vstr(bstr, FALSE);
374
+ }
375
+ OLE_RELEASE_TYPEATTR(pTypeInfo, pTypeAttr);
376
+ return guid;
377
+ }
378
+
379
+ /*
380
+ * call-seq:
381
+ * WIN32OLE_TYPE#guid #=> GUID
382
+ *
383
+ * Returns GUID.
384
+ * tobj = WIN32OLE_TYPE.new('Microsoft Excel 9.0 Object Library', 'Application')
385
+ * puts tobj.guid # => {00024500-0000-0000-C000-000000000046}
386
+ */
387
+ static VALUE
388
+ foletype_guid(VALUE self)
389
+ {
390
+ ITypeInfo *pTypeInfo = itypeinfo(self);
391
+ return ole_type_guid(pTypeInfo);
392
+ }
393
+
394
+ static VALUE
395
+ ole_type_progid(ITypeInfo *pTypeInfo)
396
+ {
397
+ HRESULT hr;
398
+ TYPEATTR *pTypeAttr;
399
+ OLECHAR *pbuf;
400
+ VALUE progid = Qnil;
401
+ hr = OLE_GET_TYPEATTR(pTypeInfo, &pTypeAttr);
402
+ if (FAILED(hr))
403
+ return progid;
404
+ hr = ProgIDFromCLSID(&pTypeAttr->guid, &pbuf);
405
+ if (SUCCEEDED(hr)) {
406
+ progid = ole_wc2vstr(pbuf, FALSE);
407
+ CoTaskMemFree(pbuf);
408
+ }
409
+ OLE_RELEASE_TYPEATTR(pTypeInfo, pTypeAttr);
410
+ return progid;
411
+ }
412
+
413
+ /*
414
+ * call-seq:
415
+ * WIN32OLE_TYPE#progid #=> ProgID
416
+ *
417
+ * Returns ProgID if it exists. If not found, then returns nil.
418
+ * tobj = WIN32OLE_TYPE.new('Microsoft Excel 9.0 Object Library', 'Application')
419
+ * puts tobj.progid # => Excel.Application.9
420
+ */
421
+ static VALUE
422
+ foletype_progid(VALUE self)
423
+ {
424
+ ITypeInfo *pTypeInfo = itypeinfo(self);
425
+ return ole_type_progid(pTypeInfo);
426
+ }
427
+
428
+
429
+ static VALUE
430
+ ole_type_visible(ITypeInfo *pTypeInfo)
431
+ {
432
+ HRESULT hr;
433
+ TYPEATTR *pTypeAttr;
434
+ VALUE visible;
435
+ hr = OLE_GET_TYPEATTR(pTypeInfo, &pTypeAttr);
436
+ if (FAILED(hr))
437
+ return Qtrue;
438
+ if (pTypeAttr->wTypeFlags & (TYPEFLAG_FHIDDEN | TYPEFLAG_FRESTRICTED)) {
439
+ visible = Qfalse;
440
+ } else {
441
+ visible = Qtrue;
442
+ }
443
+ OLE_RELEASE_TYPEATTR(pTypeInfo, pTypeAttr);
444
+ return visible;
445
+ }
446
+
447
+ /*
448
+ * call-seq:
449
+ * WIN32OLE_TYPE#visible? #=> true or false
450
+ *
451
+ * Returns true if the OLE class is public.
452
+ * tobj = WIN32OLE_TYPE.new('Microsoft Excel 9.0 Object Library', 'Application')
453
+ * puts tobj.visible # => true
454
+ */
455
+ static VALUE
456
+ foletype_visible(VALUE self)
457
+ {
458
+ ITypeInfo *pTypeInfo = itypeinfo(self);
459
+ return ole_type_visible(pTypeInfo);
460
+ }
461
+
462
+ static VALUE
463
+ ole_type_major_version(ITypeInfo *pTypeInfo)
464
+ {
465
+ VALUE ver;
466
+ TYPEATTR *pTypeAttr;
467
+ HRESULT hr;
468
+ hr = OLE_GET_TYPEATTR(pTypeInfo, &pTypeAttr);
469
+ if (FAILED(hr))
470
+ ole_raise(hr, eWIN32OLERuntimeError, "failed to GetTypeAttr");
471
+ ver = RB_INT2FIX(pTypeAttr->wMajorVerNum);
472
+ OLE_RELEASE_TYPEATTR(pTypeInfo, pTypeAttr);
473
+ return ver;
474
+ }
475
+
476
+ /*
477
+ * call-seq:
478
+ * WIN32OLE_TYPE#major_version
479
+ *
480
+ * Returns major version.
481
+ * tobj = WIN32OLE_TYPE.new('Microsoft Word 10.0 Object Library', 'Documents')
482
+ * puts tobj.major_version # => 8
483
+ */
484
+ static VALUE
485
+ foletype_major_version(VALUE self)
486
+ {
487
+ ITypeInfo *pTypeInfo = itypeinfo(self);
488
+ return ole_type_major_version(pTypeInfo);
489
+ }
490
+
491
+ static VALUE
492
+ ole_type_minor_version(ITypeInfo *pTypeInfo)
493
+ {
494
+ VALUE ver;
495
+ TYPEATTR *pTypeAttr;
496
+ HRESULT hr;
497
+ hr = OLE_GET_TYPEATTR(pTypeInfo, &pTypeAttr);
498
+ if (FAILED(hr))
499
+ ole_raise(hr, eWIN32OLERuntimeError, "failed to GetTypeAttr");
500
+ ver = RB_INT2FIX(pTypeAttr->wMinorVerNum);
501
+ OLE_RELEASE_TYPEATTR(pTypeInfo, pTypeAttr);
502
+ return ver;
503
+ }
504
+
505
+ /*
506
+ * call-seq:
507
+ * WIN32OLE_TYPE#minor_version #=> OLE minor version
508
+ *
509
+ * Returns minor version.
510
+ * tobj = WIN32OLE_TYPE.new('Microsoft Word 10.0 Object Library', 'Documents')
511
+ * puts tobj.minor_version # => 2
512
+ */
513
+ static VALUE
514
+ foletype_minor_version(VALUE self)
515
+ {
516
+ ITypeInfo *pTypeInfo = itypeinfo(self);
517
+ return ole_type_minor_version(pTypeInfo);
518
+ }
519
+
520
+ static VALUE
521
+ ole_type_typekind(ITypeInfo *pTypeInfo)
522
+ {
523
+ VALUE typekind;
524
+ TYPEATTR *pTypeAttr;
525
+ HRESULT hr;
526
+ hr = OLE_GET_TYPEATTR(pTypeInfo, &pTypeAttr);
527
+ if (FAILED(hr))
528
+ ole_raise(hr, eWIN32OLERuntimeError, "failed to GetTypeAttr");
529
+ typekind = RB_INT2FIX(pTypeAttr->typekind);
530
+ OLE_RELEASE_TYPEATTR(pTypeInfo, pTypeAttr);
531
+ return typekind;
532
+ }
533
+
534
+ /*
535
+ * call-seq:
536
+ * WIN32OLE_TYPE#typekind #=> number of type.
537
+ *
538
+ * Returns number which represents type.
539
+ * tobj = WIN32OLE_TYPE.new('Microsoft Word 10.0 Object Library', 'Documents')
540
+ * puts tobj.typekind # => 4
541
+ *
542
+ */
543
+ static VALUE
544
+ foletype_typekind(VALUE self)
545
+ {
546
+ ITypeInfo *pTypeInfo = itypeinfo(self);
547
+ return ole_type_typekind(pTypeInfo);
548
+ }
549
+
550
+ static VALUE
551
+ ole_type_helpstring(ITypeInfo *pTypeInfo)
552
+ {
553
+ HRESULT hr;
554
+ BSTR bhelpstr;
555
+ hr = ole_docinfo_from_type(pTypeInfo, NULL, &bhelpstr, NULL, NULL);
556
+ if(FAILED(hr)) {
557
+ return Qnil;
558
+ }
559
+ return WC2VSTR(bhelpstr);
560
+ }
561
+
562
+ /*
563
+ * call-seq:
564
+ * WIN32OLE_TYPE#helpstring #=> help string.
565
+ *
566
+ * Returns help string.
567
+ * tobj = WIN32OLE_TYPE.new('Microsoft Internet Controls', 'IWebBrowser')
568
+ * puts tobj.helpstring # => Web Browser interface
569
+ */
570
+ static VALUE
571
+ foletype_helpstring(VALUE self)
572
+ {
573
+ ITypeInfo *pTypeInfo = itypeinfo(self);
574
+ return ole_type_helpstring(pTypeInfo);
575
+ }
576
+
577
+ static VALUE
578
+ ole_type_src_type(ITypeInfo *pTypeInfo)
579
+ {
580
+ HRESULT hr;
581
+ TYPEATTR *pTypeAttr;
582
+ VALUE alias = Qnil;
583
+ hr = OLE_GET_TYPEATTR(pTypeInfo, &pTypeAttr);
584
+ if (FAILED(hr))
585
+ return alias;
586
+ if(pTypeAttr->typekind != TKIND_ALIAS) {
587
+ OLE_RELEASE_TYPEATTR(pTypeInfo, pTypeAttr);
588
+ return alias;
589
+ }
590
+ alias = ole_typedesc2val(pTypeInfo, &(pTypeAttr->tdescAlias), Qnil);
591
+ OLE_RELEASE_TYPEATTR(pTypeInfo, pTypeAttr);
592
+ return alias;
593
+ }
594
+
595
+ /*
596
+ * call-seq:
597
+ * WIN32OLE_TYPE#src_type #=> OLE source class
598
+ *
599
+ * Returns source class when the OLE class is 'Alias'.
600
+ * tobj = WIN32OLE_TYPE.new('Microsoft Office 9.0 Object Library', 'MsoRGBType')
601
+ * puts tobj.src_type # => I4
602
+ *
603
+ */
604
+ static VALUE
605
+ foletype_src_type(VALUE self)
606
+ {
607
+ ITypeInfo *pTypeInfo = itypeinfo(self);
608
+ return ole_type_src_type(pTypeInfo);
609
+ }
610
+
611
+ static VALUE
612
+ ole_type_helpfile(ITypeInfo *pTypeInfo)
613
+ {
614
+ HRESULT hr;
615
+ BSTR bhelpfile;
616
+ hr = ole_docinfo_from_type(pTypeInfo, NULL, NULL, NULL, &bhelpfile);
617
+ if(FAILED(hr)) {
618
+ return Qnil;
619
+ }
620
+ return WC2VSTR(bhelpfile);
621
+ }
622
+
623
+ /*
624
+ * call-seq:
625
+ * WIN32OLE_TYPE#helpfile
626
+ *
627
+ * Returns helpfile path. If helpfile is not found, then returns nil.
628
+ * tobj = WIN32OLE_TYPE.new('Microsoft Excel 9.0 Object Library', 'Worksheet')
629
+ * puts tobj.helpfile # => C:\...\VBAXL9.CHM
630
+ *
631
+ */
632
+ static VALUE
633
+ foletype_helpfile(VALUE self)
634
+ {
635
+ ITypeInfo *pTypeInfo = itypeinfo(self);
636
+ return ole_type_helpfile(pTypeInfo);
637
+ }
638
+
639
+ static VALUE
640
+ ole_type_helpcontext(ITypeInfo *pTypeInfo)
641
+ {
642
+ HRESULT hr;
643
+ DWORD helpcontext;
644
+ hr = ole_docinfo_from_type(pTypeInfo, NULL, NULL,
645
+ &helpcontext, NULL);
646
+ if(FAILED(hr))
647
+ return Qnil;
648
+ return RB_INT2FIX(helpcontext);
649
+ }
650
+
651
+ /*
652
+ * call-seq:
653
+ * WIN32OLE_TYPE#helpcontext
654
+ *
655
+ * Returns helpcontext. If helpcontext is not found, then returns nil.
656
+ * tobj = WIN32OLE_TYPE.new('Microsoft Excel 9.0 Object Library', 'Worksheet')
657
+ * puts tobj.helpfile # => 131185
658
+ */
659
+ static VALUE
660
+ foletype_helpcontext(VALUE self)
661
+ {
662
+ ITypeInfo *pTypeInfo = itypeinfo(self);
663
+ return ole_type_helpcontext(pTypeInfo);
664
+ }
665
+
666
+ static VALUE
667
+ ole_variables(ITypeInfo *pTypeInfo)
668
+ {
669
+ HRESULT hr;
670
+ TYPEATTR *pTypeAttr;
671
+ WORD i;
672
+ UINT len;
673
+ BSTR bstr;
674
+ VARDESC *pVarDesc;
675
+ VALUE var;
676
+ VALUE variables = rb_ary_new();
677
+ hr = OLE_GET_TYPEATTR(pTypeInfo, &pTypeAttr);
678
+ if (FAILED(hr)) {
679
+ ole_raise(hr, eWIN32OLERuntimeError, "failed to GetTypeAttr");
680
+ }
681
+
682
+ for(i = 0; i < pTypeAttr->cVars; i++) {
683
+ hr = pTypeInfo->lpVtbl->GetVarDesc(pTypeInfo, i, &pVarDesc);
684
+ if(FAILED(hr))
685
+ continue;
686
+ len = 0;
687
+ hr = pTypeInfo->lpVtbl->GetNames(pTypeInfo, pVarDesc->memid, &bstr,
688
+ 1, &len);
689
+ if(FAILED(hr) || len == 0 || !bstr)
690
+ continue;
691
+
692
+ var = create_win32ole_variable(pTypeInfo, i, WC2VSTR(bstr));
693
+ rb_ary_push(variables, var);
694
+
695
+ pTypeInfo->lpVtbl->ReleaseVarDesc(pTypeInfo, pVarDesc);
696
+ pVarDesc = NULL;
697
+ }
698
+ OLE_RELEASE_TYPEATTR(pTypeInfo, pTypeAttr);
699
+ return variables;
700
+ }
701
+
702
+ /*
703
+ * call-seq:
704
+ * WIN32OLE_TYPE#variables
705
+ *
706
+ * Returns array of WIN32OLE_VARIABLE objects which represent variables
707
+ * defined in OLE class.
708
+ * tobj = WIN32OLE_TYPE.new('Microsoft Excel 9.0 Object Library', 'XlSheetType')
709
+ * vars = tobj.variables
710
+ * vars.each do |v|
711
+ * puts "#{v.name} = #{v.value}"
712
+ * end
713
+ *
714
+ * The result of above sample script is follows:
715
+ * xlChart = -4109
716
+ * xlDialogSheet = -4116
717
+ * xlExcel4IntlMacroSheet = 4
718
+ * xlExcel4MacroSheet = 3
719
+ * xlWorksheet = -4167
720
+ *
721
+ */
722
+ static VALUE
723
+ foletype_variables(VALUE self)
724
+ {
725
+ ITypeInfo *pTypeInfo = itypeinfo(self);
726
+ return ole_variables(pTypeInfo);
727
+ }
728
+
729
+ /*
730
+ * call-seq:
731
+ * WIN32OLE_TYPE#ole_methods # the array of WIN32OLE_METHOD objects.
732
+ *
733
+ * Returns array of WIN32OLE_METHOD objects which represent OLE method defined in
734
+ * OLE type library.
735
+ * tobj = WIN32OLE_TYPE.new('Microsoft Excel 9.0 Object Library', 'Worksheet')
736
+ * methods = tobj.ole_methods.collect{|m|
737
+ * m.name
738
+ * }
739
+ * # => ['Activate', 'Copy', 'Delete',....]
740
+ */
741
+ static VALUE
742
+ foletype_methods(VALUE self)
743
+ {
744
+ ITypeInfo *pTypeInfo = itypeinfo(self);
745
+ return ole_methods_from_typeinfo(pTypeInfo, INVOKE_FUNC | INVOKE_PROPERTYGET | INVOKE_PROPERTYPUT | INVOKE_PROPERTYPUTREF);
746
+ }
747
+
748
+ /*
749
+ * call-seq:
750
+ * WIN32OLE_TYPE#ole_typelib
751
+ *
752
+ * Returns the WIN32OLE_TYPELIB object which is including the WIN32OLE_TYPE
753
+ * object. If it is not found, then returns nil.
754
+ * tobj = WIN32OLE_TYPE.new('Microsoft Excel 9.0 Object Library', 'Worksheet')
755
+ * puts tobj.ole_typelib # => 'Microsoft Excel 9.0 Object Library'
756
+ */
757
+ static VALUE
758
+ foletype_ole_typelib(VALUE self)
759
+ {
760
+ ITypeInfo *pTypeInfo = itypeinfo(self);
761
+ return ole_typelib_from_itypeinfo(pTypeInfo);
762
+ }
763
+
764
+ static VALUE
765
+ ole_type_impl_ole_types(ITypeInfo *pTypeInfo, int implflags)
766
+ {
767
+ HRESULT hr;
768
+ ITypeInfo *pRefTypeInfo;
769
+ HREFTYPE href;
770
+ WORD i;
771
+ VALUE type;
772
+ TYPEATTR *pTypeAttr;
773
+ int flags;
774
+
775
+ VALUE types = rb_ary_new();
776
+ hr = OLE_GET_TYPEATTR(pTypeInfo, &pTypeAttr);
777
+ if (FAILED(hr)) {
778
+ return types;
779
+ }
780
+ for (i = 0; i < pTypeAttr->cImplTypes; i++) {
781
+ hr = pTypeInfo->lpVtbl->GetImplTypeFlags(pTypeInfo, i, &flags);
782
+ if (FAILED(hr))
783
+ continue;
784
+
785
+ hr = pTypeInfo->lpVtbl->GetRefTypeOfImplType(pTypeInfo, i, &href);
786
+ if (FAILED(hr))
787
+ continue;
788
+ hr = pTypeInfo->lpVtbl->GetRefTypeInfo(pTypeInfo, href, &pRefTypeInfo);
789
+ if (FAILED(hr))
790
+ continue;
791
+
792
+ if ((flags & implflags) == implflags) {
793
+ type = ole_type_from_itypeinfo(pRefTypeInfo);
794
+ if (type != Qnil) {
795
+ rb_ary_push(types, type);
796
+ }
797
+ }
798
+
799
+ OLE_RELEASE(pRefTypeInfo);
800
+ }
801
+ OLE_RELEASE_TYPEATTR(pTypeInfo, pTypeAttr);
802
+ return types;
803
+ }
804
+
805
+ /*
806
+ * call-seq:
807
+ * WIN32OLE_TYPE#implemented_ole_types
808
+ *
809
+ * Returns the array of WIN32OLE_TYPE object which is implemented by the WIN32OLE_TYPE
810
+ * object.
811
+ * tobj = WIN32OLE_TYPE.new('Microsoft Excel 9.0 Object Library', 'Worksheet')
812
+ * p tobj.implemented_ole_types # => [_Worksheet, DocEvents]
813
+ */
814
+ static VALUE
815
+ foletype_impl_ole_types(VALUE self)
816
+ {
817
+ ITypeInfo *pTypeInfo = itypeinfo(self);
818
+ return ole_type_impl_ole_types(pTypeInfo, 0);
819
+ }
820
+
821
+ /*
822
+ * call-seq:
823
+ * WIN32OLE_TYPE#source_ole_types
824
+ *
825
+ * Returns the array of WIN32OLE_TYPE object which is implemented by the WIN32OLE_TYPE
826
+ * object and having IMPLTYPEFLAG_FSOURCE.
827
+ * tobj = WIN32OLE_TYPE.new('Microsoft Internet Controls', "InternetExplorer")
828
+ * p tobj.source_ole_types
829
+ * # => [#<WIN32OLE_TYPE:DWebBrowserEvents2>, #<WIN32OLE_TYPE:DWebBrowserEvents>]
830
+ */
831
+ static VALUE
832
+ foletype_source_ole_types(VALUE self)
833
+ {
834
+ ITypeInfo *pTypeInfo = itypeinfo(self);
835
+ return ole_type_impl_ole_types(pTypeInfo, IMPLTYPEFLAG_FSOURCE);
836
+ }
837
+
838
+ /*
839
+ * call-seq:
840
+ * WIN32OLE_TYPE#default_event_sources
841
+ *
842
+ * Returns the array of WIN32OLE_TYPE object which is implemented by the WIN32OLE_TYPE
843
+ * object and having IMPLTYPEFLAG_FSOURCE and IMPLTYPEFLAG_FDEFAULT.
844
+ * tobj = WIN32OLE_TYPE.new('Microsoft Internet Controls', "InternetExplorer")
845
+ * p tobj.default_event_sources # => [#<WIN32OLE_TYPE:DWebBrowserEvents2>]
846
+ */
847
+ static VALUE
848
+ foletype_default_event_sources(VALUE self)
849
+ {
850
+ ITypeInfo *pTypeInfo = itypeinfo(self);
851
+ return ole_type_impl_ole_types(pTypeInfo, IMPLTYPEFLAG_FSOURCE|IMPLTYPEFLAG_FDEFAULT);
852
+ }
853
+
854
+ /*
855
+ * call-seq:
856
+ * WIN32OLE_TYPE#default_ole_types
857
+ *
858
+ * Returns the array of WIN32OLE_TYPE object which is implemented by the WIN32OLE_TYPE
859
+ * object and having IMPLTYPEFLAG_FDEFAULT.
860
+ * tobj = WIN32OLE_TYPE.new('Microsoft Internet Controls', "InternetExplorer")
861
+ * p tobj.default_ole_types
862
+ * # => [#<WIN32OLE_TYPE:IWebBrowser2>, #<WIN32OLE_TYPE:DWebBrowserEvents2>]
863
+ */
864
+ static VALUE
865
+ foletype_default_ole_types(VALUE self)
866
+ {
867
+ ITypeInfo *pTypeInfo = itypeinfo(self);
868
+ return ole_type_impl_ole_types(pTypeInfo, IMPLTYPEFLAG_FDEFAULT);
869
+ }
870
+
871
+ /*
872
+ * call-seq:
873
+ * WIN32OLE_TYPE#inspect -> String
874
+ *
875
+ * Returns the type name with class name.
876
+ *
877
+ * ie = WIN32OLE.new('InternetExplorer.Application')
878
+ * ie.ole_type.inspect => #<WIN32OLE_TYPE:IWebBrowser2>
879
+ */
880
+ static VALUE
881
+ foletype_inspect(VALUE self)
882
+ {
883
+ return default_inspect(self, "WIN32OLE_TYPE");
884
+ }
885
+
886
+ void Init_win32ole_type(void)
887
+ {
888
+ cWIN32OLE_TYPE = rb_define_class("WIN32OLE_TYPE", rb_cObject);
889
+ rb_define_singleton_method(cWIN32OLE_TYPE, "ole_classes", foletype_s_ole_classes, 1);
890
+ rb_define_singleton_method(cWIN32OLE_TYPE, "typelibs", foletype_s_typelibs, 0);
891
+ rb_define_singleton_method(cWIN32OLE_TYPE, "progids", foletype_s_progids, 0);
892
+ rb_define_alloc_func(cWIN32OLE_TYPE, foletype_s_allocate);
893
+ rb_define_method(cWIN32OLE_TYPE, "initialize", foletype_initialize, 2);
894
+ rb_define_method(cWIN32OLE_TYPE, "name", foletype_name, 0);
895
+ rb_define_method(cWIN32OLE_TYPE, "ole_type", foletype_ole_type, 0);
896
+ rb_define_method(cWIN32OLE_TYPE, "guid", foletype_guid, 0);
897
+ rb_define_method(cWIN32OLE_TYPE, "progid", foletype_progid, 0);
898
+ rb_define_method(cWIN32OLE_TYPE, "visible?", foletype_visible, 0);
899
+ rb_define_alias(cWIN32OLE_TYPE, "to_s", "name");
900
+ rb_define_method(cWIN32OLE_TYPE, "major_version", foletype_major_version, 0);
901
+ rb_define_method(cWIN32OLE_TYPE, "minor_version", foletype_minor_version, 0);
902
+ rb_define_method(cWIN32OLE_TYPE, "typekind", foletype_typekind, 0);
903
+ rb_define_method(cWIN32OLE_TYPE, "helpstring", foletype_helpstring, 0);
904
+ rb_define_method(cWIN32OLE_TYPE, "src_type", foletype_src_type, 0);
905
+ rb_define_method(cWIN32OLE_TYPE, "helpfile", foletype_helpfile, 0);
906
+ rb_define_method(cWIN32OLE_TYPE, "helpcontext", foletype_helpcontext, 0);
907
+ rb_define_method(cWIN32OLE_TYPE, "variables", foletype_variables, 0);
908
+ rb_define_method(cWIN32OLE_TYPE, "ole_methods", foletype_methods, 0);
909
+ rb_define_method(cWIN32OLE_TYPE, "ole_typelib", foletype_ole_typelib, 0);
910
+ rb_define_method(cWIN32OLE_TYPE, "implemented_ole_types", foletype_impl_ole_types, 0);
911
+ rb_define_method(cWIN32OLE_TYPE, "source_ole_types", foletype_source_ole_types, 0);
912
+ rb_define_method(cWIN32OLE_TYPE, "default_event_sources", foletype_default_event_sources, 0);
913
+ rb_define_method(cWIN32OLE_TYPE, "default_ole_types", foletype_default_ole_types, 0);
914
+ rb_define_method(cWIN32OLE_TYPE, "inspect", foletype_inspect, 0);
915
+ }