Class: WIN32OLE
- Inherits:
-
Object
- Object
- WIN32OLE
- Defined in:
- lib/win32ole.rb,
win32ole.c,
win32ole.c
Overview
WIN32OLE
objects represent OLE Automation object in Ruby.
By using WIN32OLE, you can access OLE server like VBScript.
Here is sample script.
require 'win32ole'
excel = WIN32OLE.new('Excel.Application')
excel.visible = true
workbook = excel.Workbooks.Add();
worksheet = workbook.Worksheets(1);
worksheet.Range("A1:D1").value = ["North","South","East","West"];
worksheet.Range("A2:B2").value = [5.2, 10];
worksheet.Range("C2").value = 8;
worksheet.Range("D2").value = 20;
range = worksheet.Range("A1:D2");
range.select
chart = workbook.Charts.Add;
workbook.saved = true;
excel.ActiveWorkbook.Close(0);
excel.Quit();
Unfortunately, Win32OLE doesn't support the argument passed by
reference directly.
Instead, Win32OLE provides WIN32OLE::ARGV or WIN32OLE_VARIANT object.
If you want to get the result value of argument passed by reference,
you can use WIN32OLE::ARGV or WIN32OLE_VARIANT.
oleobj.method(arg1, arg2, refargv3)
puts WIN32OLE::ARGV[2] # the value of refargv3 after called oleobj.method
or
refargv3 = WIN32OLE_VARIANT.new(XXX,
WIN32OLE::VARIANT::VT_BYREF|WIN32OLE::VARIANT::VT_XXX)
oleobj.method(arg1, arg2, refargv3)
p refargv3.value # the value of refargv3 after called oleobj.method.
Defined Under Namespace
Modules: VARIANT
Constant Summary collapse
- VERSION =
Version string of WIN32OLE.
rb_str_new2(WIN32OLE_VERSION)
- ARGV =
void calcsum(int a, int b, out int c) {
c = a + b; }
then, the Ruby OLE(COM) client script to retrieve the value of argument c after invoking calcsum method is following:
a = 10 b = 20 c = 0 comserver.calcsum(a, b, c) p c # => 0 p WIN32OLE::ARGV # => [10, 20, 30]
You can use WIN32OLE_VARIANT object to retrieve the value of reference arguments instead of referring WIN32OLE::ARGV.
After invoking OLE methods with reference arguments, you can access the value of arguments by using ARGV. If the method of OLE(COM) server written by C#.NET is following
- CP_ACP =
ANSI code page. See WIN32OLE.codepage and WIN32OLE.codepage=.
0
- CP_OEMCP =
OEM code page. See WIN32OLE.codepage and WIN32OLE.codepage=.
1
- CP_MACCP =
2
RB_INT2FIX(CP_MACCP)
- CP_THREAD_ACP =
current thread ANSI code page. See WIN32OLE.codepage and WIN32OLE.codepage=.
3
- CP_SYMBOL =
symbol code page. See WIN32OLE.codepage and WIN32OLE.codepage=.
42
- CP_UTF7 =
UTF-7 code page. See WIN32OLE.codepage and WIN32OLE.codepage=.
65000
- CP_UTF8 =
UTF-8 code page. See WIN32OLE.codepage and WIN32OLE.codepage=.
65001
- LOCALE_SYSTEM_DEFAULT =
default locale for the operating system. See WIN32OLE.locale and WIN32OLE.locale=.
0x0800
- LOCALE_USER_DEFAULT =
default locale for the user or process. See WIN32OLE.locale and WIN32OLE.locale=.
0x0400
Class Method Summary collapse
-
.codepage ⇒ Object
Returns current codepage.
-
.codepage=(CP) ⇒ Object
Sets current codepage.
-
.connect(ole) ⇒ Object
Returns running OLE Automation object or WIN32OLE object from moniker.
-
.const_load(ole, mod = WIN32OLE) ⇒ Object
Defines the constants of OLE Automation server as mod’s constants.
-
.create_guid ⇒ Object
Creates GUID.
-
.locale ⇒ Object
Returns current locale id (lcid).
-
.locale=(lcid) ⇒ Object
Sets current locale id (lcid).
-
.ole_free(aWIN32OLE) ⇒ Object
Invokes Release method of Dispatch interface of WIN32OLE object.
-
.ole_initialize ⇒ Object
:nodoc:.
-
.ole_reference_count(aWIN32OLE) ⇒ Object
Returns reference counter of Dispatch interface of WIN32OLE object.
-
.ole_show_help(obj[,helpcontext]) ⇒ Object
Displays helpfile.
-
.ole_uninitialize ⇒ Object
:nodoc:.
Instance Method Summary collapse
-
#[](a1, a2, ...) ⇒ Object
Returns the value of Collection specified by a1, a2,.…
-
#[]=(a1, a2, ...) ⇒ Object
Sets the value to WIN32OLE object specified by a1, a2, …
-
#_getproperty(dispid, args, types) ⇒ Object
Runs the early binding method to get property.
-
#_invoke(dispid, args, types) ⇒ Object
Runs the early binding method.
-
#_setproperty(dispid, args, types) ⇒ Object
Runs the early binding method to set property.
-
#each {|i| ... } ⇒ Object
Iterates over each item of OLE collection which has IEnumVARIANT interface.
-
#initialize(*args) ⇒ Object
constructor
Returns a new WIN32OLE object(OLE Automation object).
-
#invoke(method, [arg1,...]) ⇒ Object
Runs OLE method.
-
#method_missing(id[,arg1, arg2, ...]) ⇒ Object
Calls WIN32OLE#invoke method.
-
#methods(*args) ⇒ Object
By overriding Object#methods, WIN32OLE might work well with did_you_mean gem.
-
#ole_activex_initialize ⇒ Qnil
Initialize WIN32OLE object(ActiveX Control) by calling IPersistMemory::InitNew.
-
#ole_free ⇒ Object
invokes Release method of Dispatch interface of WIN32OLE object.
-
#ole_func_methods ⇒ Object
Returns the array of WIN32OLE_METHOD object .
-
#ole_get_methods ⇒ Object
Returns the array of WIN32OLE_METHOD object .
-
#ole_method_help(method) ⇒ Object
(also: #ole_method_help)
Returns WIN32OLE_METHOD object corresponding with method specified by 1st argument.
-
#ole_methods ⇒ Object
Returns the array of WIN32OLE_METHOD object.
-
#ole_put_methods ⇒ Object
Returns the array of WIN32OLE_METHOD object .
-
#ole_query_interface(iid) ⇒ WIN32OLE object
Returns WIN32OLE object for a specific dispatch or dual interface specified by iid.
-
#ole_respond_to?(method) ⇒ Boolean
Returns true when OLE object has OLE method, otherwise returns false.
-
#ole_type ⇒ Object
(also: #ole_obj_help)
Returns WIN32OLE_TYPE object.
-
#ole_typelib ⇒ The WIN32OLE_TYPELIB object
Returns the WIN32OLE_TYPELIB object.
-
#setproperty('property', [arg1, arg2,...]) ⇒ Object
Sets property of OLE object.
Constructor Details
#new(server, [host]) ⇒ WIN32OLE object #new(server, license: 'key') ⇒ WIN32OLE object
Returns a new WIN32OLE object(OLE Automation object). The first argument server specifies OLE Automation server. The first argument should be CLSID or PROGID. If second argument host specified, then returns OLE Automation object on host. If :license keyword argument is provided, IClassFactory2::CreateInstanceLic is used to create instance of licensed server.
WIN32OLE.new('Excel.Application') # => Excel OLE Automation WIN32OLE object.
WIN32OLE.new('{00024500-0000-0000-C000-000000000046}') # => Excel OLE Automation WIN32OLE object.
2456 2457 2458 2459 2460 2461 2462 2463 2464 2465 2466 2467 2468 2469 2470 2471 2472 2473 2474 2475 2476 2477 2478 2479 2480 2481 2482 2483 2484 2485 2486 2487 2488 2489 2490 2491 2492 2493 2494 2495 2496 2497 2498 2499 2500 2501 2502 2503 2504 2505 2506 2507 2508 2509 2510 2511 2512 2513 2514 2515 2516 2517 2518 2519 2520 2521 2522 2523 2524 2525 2526 2527 2528 2529 2530 2531 2532 2533 |
# File 'win32ole.c', line 2456
static VALUE
fole_initialize(int argc, VALUE *argv, VALUE self)
{
VALUE svr_name;
VALUE host;
VALUE others;
VALUE opts;
HRESULT hr;
CLSID clsid;
OLECHAR *pBuf;
OLECHAR *key_buf;
IDispatch *pDispatch;
IClassFactory2 * pIClassFactory2;
void *p;
static ID keyword_ids[1];
VALUE kwargs[1];
rb_call_super(0, 0);
rb_scan_args(argc, argv, "11*:", &svr_name, &host, &others, &opts);
StringValue(svr_name);
if (!NIL_P(host)) {
StringValue(host);
return ole_create_dcom(self, svr_name, host, others);
}
/* get CLSID from OLE server name */
pBuf = ole_vstr2wc(svr_name);
hr = CLSIDFromProgID(pBuf, &clsid);
if(FAILED(hr)) {
hr = CLSIDFromString(pBuf, &clsid);
}
SysFreeString(pBuf);
if(FAILED(hr)) {
ole_raise(hr, eWIN32OLERuntimeError,
"unknown OLE server: `%s'",
StringValuePtr(svr_name));
}
if (!keyword_ids[0]) {
keyword_ids[0] = rb_intern_const("license");
}
rb_get_kwargs(opts, keyword_ids, 0, 1, kwargs);
if (kwargs[0] == Qundef) {
/* get IDispatch interface */
hr = CoCreateInstance(
&clsid,
NULL,
CLSCTX_INPROC_SERVER | CLSCTX_LOCAL_SERVER,
&IID_IDispatch,
&p
);
} else {
hr = CoGetClassObject(
&clsid,
CLSCTX_INPROC_SERVER | CLSCTX_LOCAL_SERVER,
NULL,
&IID_IClassFactory2,
(LPVOID)&pIClassFactory2
);
if (hr == S_OK) {
key_buf = ole_vstr2wc(kwargs[0]);
hr = pIClassFactory2->lpVtbl->CreateInstanceLic(pIClassFactory2, NULL, NULL, &IID_IDispatch, key_buf, &p);
SysFreeString(key_buf);
OLE_RELEASE(pIClassFactory2);
}
}
pDispatch = p;
if(FAILED(hr)) {
ole_raise(hr, eWIN32OLERuntimeError,
"failed to create WIN32OLE object from `%s'",
StringValuePtr(svr_name));
}
ole_set_member(self, pDispatch);
return self;
}
|
Dynamic Method Handling
This class handles dynamic methods through the method_missing method
#method_missing(id[,arg1, arg2, ...]) ⇒ Object
Calls WIN32OLE#invoke method.
3346 3347 3348 3349 3350 3351 3352 3353 3354 3355 3356 3357 3358 3359 3360 3361 3362 3363 3364 3365 3366 3367 3368 3369 3370 3371 3372 3373 3374 3375 3376 |
# File 'win32ole.c', line 3346
static VALUE
fole_missing(int argc, VALUE *argv, VALUE self)
{
VALUE mid, org_mid, sym, v;
const char* mname;
long n;
rb_check_arity(argc, 1, UNLIMITED_ARGUMENTS);
mid = org_mid = argv[0];
sym = rb_check_symbol(&mid);
if (!NIL_P(sym)) mid = rb_sym2str(sym);
mname = StringValueCStr(mid);
if(!mname) {
rb_raise(rb_eRuntimeError, "fail: unknown method or property");
}
n = RSTRING_LEN(mid);
if(mname[n-1] == '=') {
rb_check_arity(argc, 2, 2);
argv[0] = rb_enc_associate(rb_str_subseq(mid, 0, n-1), cWIN32OLE_enc);
return ole_propertyput(self, argv[0], argv[1]);
}
else {
argv[0] = rb_enc_associate(rb_str_dup(mid), cWIN32OLE_enc);
v = ole_invoke(argc, argv, self, DISPATCH_METHOD|DISPATCH_PROPERTYGET, FALSE);
if (v == rb_eNoMethodError) {
argv[0] = org_mid;
return rb_call_super(argc, argv);
}
return v;
}
}
|
Class Method Details
.codepage ⇒ Object
Returns current codepage.
WIN32OLE.codepage # => WIN32OLE::CP_ACP
2234 2235 2236 2237 2238 |
# File 'win32ole.c', line 2234
static VALUE
fole_s_get_code_page(VALUE self)
{
return RB_INT2FIX(cWIN32OLE_cp);
}
|
.codepage=(CP) ⇒ Object
2271 2272 2273 2274 2275 2276 2277 2278 2279 2280 |
# File 'win32ole.c', line 2271
static VALUE
fole_s_set_code_page(VALUE self, VALUE vcp)
{
UINT cp = RB_FIX2INT(vcp);
set_ole_codepage(cp);
/*
* Should this method return old codepage?
*/
return Qnil;
}
|
.connect(ole) ⇒ Object
Returns running OLE Automation object or WIN32OLE object from moniker. 1st argument should be OLE program id or class id or moniker.
WIN32OLE.connect('Excel.Application') # => WIN32OLE object which represents running Excel.
1971 1972 1973 1974 1975 1976 1977 1978 1979 1980 1981 1982 1983 1984 1985 1986 1987 1988 1989 1990 1991 1992 1993 1994 1995 1996 1997 1998 1999 2000 2001 2002 2003 2004 2005 2006 2007 2008 2009 2010 2011 2012 2013 2014 2015 2016 2017 |
# File 'win32ole.c', line 1971
static VALUE
fole_s_connect(int argc, VALUE *argv, VALUE self)
{
VALUE svr_name;
VALUE others;
HRESULT hr;
CLSID clsid;
OLECHAR *pBuf;
IDispatch *pDispatch;
void *p;
IUnknown *pUnknown;
/* initialize to use OLE */
ole_initialize();
rb_scan_args(argc, argv, "1*", &svr_name, &others);
StringValue(svr_name);
/* get CLSID from OLE server name */
pBuf = ole_vstr2wc(svr_name);
hr = CLSIDFromProgID(pBuf, &clsid);
if(FAILED(hr)) {
hr = CLSIDFromString(pBuf, &clsid);
}
SysFreeString(pBuf);
if(FAILED(hr)) {
return ole_bind_obj(svr_name, argc, argv, self);
}
hr = GetActiveObject(&clsid, 0, &pUnknown);
if (FAILED(hr)) {
ole_raise(hr, eWIN32OLERuntimeError,
"OLE server `%s' not running", StringValuePtr(svr_name));
}
hr = pUnknown->lpVtbl->QueryInterface(pUnknown, &IID_IDispatch, &p);
pDispatch = p;
if(FAILED(hr)) {
OLE_RELEASE(pUnknown);
ole_raise(hr, eWIN32OLERuntimeError,
"failed to create WIN32OLE server `%s'",
StringValuePtr(svr_name));
}
OLE_RELEASE(pUnknown);
return create_win32ole_object(self, pDispatch, argc, argv);
}
|
.const_load(ole, mod = WIN32OLE) ⇒ Object
Defines the constants of OLE Automation server as mod’s constants. The first argument is WIN32OLE object or type library name. If 2nd argument is omitted, the default is WIN32OLE. The first letter of Ruby’s constant variable name is upper case, so constant variable name of WIN32OLE object is capitalized. For example, the ‘xlTop’ constant of Excel is changed to ‘XlTop’ in WIN32OLE. If the first letter of constant variable is not [A-Z], then the constant is defined as CONSTANTS hash element.
module EXCEL_CONST
end
excel = WIN32OLE.new('Excel.Application')
WIN32OLE.const_load(excel, EXCEL_CONST)
puts EXCEL_CONST::XlTop # => -4160
puts EXCEL_CONST::CONSTANTS['_xlDialogChartSourceData'] # => 541
WIN32OLE.const_load(excel)
puts WIN32OLE::XlTop # => -4160
module MSO
end
WIN32OLE.const_load('Microsoft Office 9.0 Object Library', MSO)
puts MSO::MsoLineSingle # => 1
2048 2049 2050 2051 2052 2053 2054 2055 2056 2057 2058 2059 2060 2061 2062 2063 2064 2065 2066 2067 2068 2069 2070 2071 2072 2073 2074 2075 2076 2077 2078 2079 2080 2081 2082 2083 2084 2085 2086 2087 2088 2089 2090 2091 2092 2093 2094 2095 2096 2097 2098 2099 2100 2101 2102 2103 2104 2105 2106 2107 2108 2109 2110 2111 |
# File 'win32ole.c', line 2048
static VALUE
fole_s_const_load(int argc, VALUE *argv, VALUE self)
{
VALUE ole;
VALUE klass;
struct oledata *pole = NULL;
ITypeInfo *pTypeInfo;
ITypeLib *pTypeLib;
unsigned int index;
HRESULT hr;
OLECHAR *pBuf;
VALUE file;
LCID lcid = cWIN32OLE_lcid;
rb_scan_args(argc, argv, "11", &ole, &klass);
if (!RB_TYPE_P(klass, T_CLASS) &&
!RB_TYPE_P(klass, T_MODULE) &&
!RB_TYPE_P(klass, T_NIL)) {
rb_raise(rb_eTypeError, "2nd parameter must be Class or Module");
}
if (rb_obj_is_kind_of(ole, cWIN32OLE)) {
pole = oledata_get_struct(ole);
hr = pole->pDispatch->lpVtbl->GetTypeInfo(pole->pDispatch,
0, lcid, &pTypeInfo);
if(FAILED(hr)) {
ole_raise(hr, eWIN32OLEQueryInterfaceError, "failed to GetTypeInfo");
}
hr = pTypeInfo->lpVtbl->GetContainingTypeLib(pTypeInfo, &pTypeLib, &index);
if(FAILED(hr)) {
OLE_RELEASE(pTypeInfo);
ole_raise(hr, eWIN32OLEQueryInterfaceError, "failed to GetContainingTypeLib");
}
OLE_RELEASE(pTypeInfo);
if(!RB_TYPE_P(klass, T_NIL)) {
ole_const_load(pTypeLib, klass, self);
}
else {
ole_const_load(pTypeLib, cWIN32OLE, self);
}
OLE_RELEASE(pTypeLib);
}
else if(RB_TYPE_P(ole, T_STRING)) {
file = typelib_file(ole);
if (file == Qnil) {
file = ole;
}
pBuf = ole_vstr2wc(file);
hr = LoadTypeLibEx(pBuf, REGKIND_NONE, &pTypeLib);
SysFreeString(pBuf);
if (FAILED(hr))
ole_raise(hr, eWIN32OLERuntimeError, "failed to LoadTypeLibEx");
if(!RB_TYPE_P(klass, T_NIL)) {
ole_const_load(pTypeLib, klass, self);
}
else {
ole_const_load(pTypeLib, cWIN32OLE, self);
}
OLE_RELEASE(pTypeLib);
}
else {
rb_raise(rb_eTypeError, "1st parameter must be WIN32OLE instance");
}
return Qnil;
}
|
.create_guid ⇒ Object
Creates GUID.
WIN32OLE.create_guid # => {1CB530F1-F6B1-404D-BCE6-1959BF91F4A8}
2352 2353 2354 2355 2356 2357 2358 2359 2360 2361 2362 2363 2364 2365 2366 2367 2368 |
# File 'win32ole.c', line 2352
static VALUE
fole_s_create_guid(VALUE self)
{
GUID guid;
HRESULT hr;
OLECHAR bstr[80];
int len = 0;
hr = CoCreateGuid(&guid);
if (FAILED(hr)) {
ole_raise(hr, eWIN32OLERuntimeError, "failed to create GUID");
}
len = StringFromGUID2(&guid, bstr, sizeof(bstr)/sizeof(OLECHAR));
if (len == 0) {
rb_raise(rb_eRuntimeError, "failed to create GUID(buffer over)");
}
return ole_wc2vstr(bstr, FALSE);
}
|
.locale ⇒ Object
Returns current locale id (lcid). The default locale is WIN32OLE::LOCALE_SYSTEM_DEFAULT.
lcid = WIN32OLE.locale
2291 2292 2293 2294 2295 |
# File 'win32ole.c', line 2291
static VALUE
fole_s_get_locale(VALUE self)
{
return RB_INT2FIX(cWIN32OLE_lcid);
}
|
.locale=(lcid) ⇒ Object
2326 2327 2328 2329 2330 2331 2332 2333 2334 2335 2336 2337 2338 2339 2340 2341 2342 2343 |
# File 'win32ole.c', line 2326
static VALUE
fole_s_set_locale(VALUE self, VALUE vlcid)
{
LCID lcid = RB_FIX2INT(vlcid);
if (lcid_installed(lcid)) {
cWIN32OLE_lcid = lcid;
} else {
switch (lcid) {
case LOCALE_SYSTEM_DEFAULT:
case LOCALE_USER_DEFAULT:
cWIN32OLE_lcid = lcid;
break;
default:
rb_raise(eWIN32OLERuntimeError, "not installed locale: %u", (unsigned int)lcid);
}
}
return Qnil;
}
|
.ole_free(aWIN32OLE) ⇒ Object
Invokes Release method of Dispatch interface of WIN32OLE object. You should not use this method because this method exists only for debugging WIN32OLE. The return value is reference counter of OLE object.
2149 2150 2151 2152 2153 2154 2155 2156 2157 2158 2159 2160 2161 |
# File 'win32ole.c', line 2149
static VALUE
fole_s_free(VALUE self, VALUE obj)
{
ULONG n = 0;
struct oledata * pole = NULL;
pole = oledata_get_struct(obj);
if(pole->pDispatch) {
if (reference_count(pole) > 0) {
n = OLE_RELEASE(pole->pDispatch);
}
}
return RB_INT2NUM(n);
}
|
.ole_initialize ⇒ Object
:nodoc:
2377 2378 2379 2380 2381 2382 |
# File 'win32ole.c', line 2377
static VALUE
fole_s_ole_initialize(VALUE self)
{
ole_initialize();
return Qnil;
}
|
.ole_reference_count(aWIN32OLE) ⇒ Object
Returns reference counter of Dispatch interface of WIN32OLE object. You should not use this method because this method exists only for debugging WIN32OLE.
2132 2133 2134 2135 2136 2137 2138 |
# File 'win32ole.c', line 2132
static VALUE
fole_s_reference_count(VALUE self, VALUE obj)
{
struct oledata * pole = NULL;
pole = oledata_get_struct(obj);
return RB_INT2NUM(reference_count(pole));
}
|
.ole_show_help(obj[,helpcontext]) ⇒ Object
2195 2196 2197 2198 2199 2200 2201 2202 2203 2204 2205 2206 2207 2208 2209 2210 2211 2212 2213 2214 2215 2216 2217 2218 2219 2220 2221 2222 2223 2224 2225 |
# File 'win32ole.c', line 2195
static VALUE
fole_s_show_help(int argc, VALUE *argv, VALUE self)
{
VALUE target;
VALUE helpcontext;
VALUE helpfile;
VALUE name;
HWND hwnd;
rb_scan_args(argc, argv, "11", &target, &helpcontext);
if (rb_obj_is_kind_of(target, cWIN32OLE_TYPE) ||
rb_obj_is_kind_of(target, cWIN32OLE_METHOD)) {
helpfile = rb_funcall(target, rb_intern("helpfile"), 0);
if(strlen(StringValuePtr(helpfile)) == 0) {
name = rb_ivar_get(target, rb_intern("name"));
rb_raise(rb_eRuntimeError, "no helpfile of `%s'",
StringValuePtr(name));
}
helpcontext = rb_funcall(target, rb_intern("helpcontext"), 0);
} else {
helpfile = target;
}
if (!RB_TYPE_P(helpfile, T_STRING)) {
rb_raise(rb_eTypeError, "1st parameter must be (String|WIN32OLE_TYPE|WIN32OLE_METHOD)");
}
hwnd = ole_show_help(helpfile, helpcontext);
if(hwnd == 0) {
rb_raise(rb_eRuntimeError, "failed to open help file `%s'",
StringValuePtr(helpfile));
}
return Qnil;
}
|
.ole_uninitialize ⇒ Object
:nodoc:
2385 2386 2387 2388 2389 2390 |
# File 'win32ole.c', line 2385
static VALUE
fole_s_ole_uninitialize(VALUE self)
{
ole_uninitialize();
return Qnil;
}
|
Instance Method Details
#[](a1, a2, ...) ⇒ Object
Returns the value of Collection specified by a1, a2,.…
dict = WIN32OLE.new('Scripting.Dictionary')
dict.add('ruby', 'Ruby')
puts dict['ruby'] # => 'Ruby' (same as `puts dict.item('ruby')')
Remark: You can not use this method to get the property.
excel = WIN32OLE.new('Excel.Application')
# puts excel['Visible'] This is error !!!
puts excel.Visible # You should to use this style to get the property.
3159 3160 3161 3162 3163 3164 3165 3166 3167 |
# File 'win32ole.c', line 3159
static VALUE
fole_getproperty_with_bracket(int argc, VALUE *argv, VALUE self)
{
VALUE v = ole_invoke(argc, argv, self, DISPATCH_PROPERTYGET, TRUE);
if (v == rb_eNoMethodError) {
return rb_call_super(argc, argv);
}
return v;
}
|
#[]=(a1, a2, ...) ⇒ Object
Sets the value to WIN32OLE object specified by a1, a2, …
dict = WIN32OLE.new('Scripting.Dictionary')
dict.add('ruby', 'RUBY')
dict['ruby'] = 'Ruby'
puts dict['ruby'] # => 'Ruby'
Remark: You can not use this method to set the property value.
excel = WIN32OLE.new('Excel.Application')
# excel['Visible'] = true # This is error !!!
excel.Visible = true # You should to use this style to set the property.
3110 3111 3112 3113 3114 3115 3116 3117 3118 |
# File 'win32ole.c', line 3110
static VALUE
fole_setproperty_with_bracket(int argc, VALUE *argv, VALUE self)
{
VALUE v = ole_invoke(argc, argv, self, DISPATCH_PROPERTYPUT, TRUE);
if (v == rb_eNoMethodError) {
return rb_call_super(argc, argv);
}
return v;
}
|
#_getproperty(dispid, args, types) ⇒ Object
Runs the early binding method to get property. The 1st argument specifies dispatch ID, the 2nd argument specifies the array of arguments, the 3rd argument specifies the array of the type of arguments.
excel = WIN32OLE.new('Excel.Application')
puts excel._getproperty(558, [], []) # same effect as puts excel.visible
3068 3069 3070 3071 3072 |
# File 'win32ole.c', line 3068
static VALUE
fole_getproperty2(VALUE self, VALUE dispid, VALUE args, VALUE types)
{
return ole_invoke2(self, dispid, args, types, DISPATCH_PROPERTYGET);
}
|
#_invoke(dispid, args, types) ⇒ Object
3050 3051 3052 3053 3054 |
# File 'win32ole.c', line 3050
static VALUE
fole_invoke2(VALUE self, VALUE dispid, VALUE args, VALUE types)
{
return ole_invoke2(self, dispid, args, types, DISPATCH_METHOD);
}
|
#_setproperty(dispid, args, types) ⇒ Object
Runs the early binding method to set property. The 1st argument specifies dispatch ID, the 2nd argument specifies the array of arguments, the 3rd argument specifies the array of the type of arguments.
excel = WIN32OLE.new('Excel.Application')
excel._setproperty(558, [true], [WIN32OLE::VARIANT::VT_BOOL]) # same effect as excel.visible = true
3086 3087 3088 3089 3090 |
# File 'win32ole.c', line 3086
static VALUE
fole_setproperty2(VALUE self, VALUE dispid, VALUE args, VALUE types)
{
return ole_invoke2(self, dispid, args, types, DISPATCH_PROPERTYPUT);
}
|
#each {|i| ... } ⇒ Object
3283 3284 3285 3286 3287 3288 3289 3290 3291 3292 3293 3294 3295 3296 3297 3298 3299 3300 3301 3302 3303 3304 3305 3306 3307 3308 3309 3310 3311 3312 3313 3314 3315 3316 3317 3318 3319 3320 3321 3322 3323 3324 3325 3326 3327 3328 3329 3330 3331 3332 3333 3334 3335 3336 3337 3338 |
# File 'win32ole.c', line 3283
static VALUE
fole_each(VALUE self)
{
LCID lcid = cWIN32OLE_lcid;
struct oledata *pole = NULL;
unsigned int argErr;
EXCEPINFO excepinfo;
DISPPARAMS dispParams;
VARIANT result;
HRESULT hr;
IEnumVARIANT *pEnum = NULL;
void *p;
RETURN_ENUMERATOR(self, 0, 0);
VariantInit(&result);
dispParams.rgvarg = NULL;
dispParams.rgdispidNamedArgs = NULL;
dispParams.cNamedArgs = 0;
dispParams.cArgs = 0;
memset(&excepinfo, 0, sizeof(excepinfo));
pole = oledata_get_struct(self);
hr = pole->pDispatch->lpVtbl->Invoke(pole->pDispatch, DISPID_NEWENUM,
&IID_NULL, lcid,
DISPATCH_METHOD | DISPATCH_PROPERTYGET,
&dispParams, &result,
&excepinfo, &argErr);
if (FAILED(hr)) {
VariantClear(&result);
ole_raise(hr, eWIN32OLEQueryInterfaceError, "failed to get IEnum Interface");
}
if (V_VT(&result) == VT_UNKNOWN) {
hr = V_UNKNOWN(&result)->lpVtbl->QueryInterface(V_UNKNOWN(&result),
&IID_IEnumVARIANT,
&p);
pEnum = p;
} else if (V_VT(&result) == VT_DISPATCH) {
hr = V_DISPATCH(&result)->lpVtbl->QueryInterface(V_DISPATCH(&result),
&IID_IEnumVARIANT,
&p);
pEnum = p;
}
if (FAILED(hr) || !pEnum) {
VariantClear(&result);
ole_raise(hr, eWIN32OLEQueryInterfaceError, "failed to get IEnum Interface");
}
VariantClear(&result);
rb_ensure(ole_each_sub, (VALUE)pEnum, ole_ienum_free, (VALUE)pEnum);
return Qnil;
}
|
#invoke(method, [arg1,...]) ⇒ Object
2839 2840 2841 2842 2843 2844 2845 2846 2847 |
# File 'win32ole.c', line 2839
static VALUE
fole_invoke(int argc, VALUE *argv, VALUE self)
{
VALUE v = ole_invoke(argc, argv, self, DISPATCH_METHOD|DISPATCH_PROPERTYGET, FALSE);
if (v == rb_eNoMethodError) {
return rb_call_super(argc, argv);
}
return v;
}
|
#methods(*args) ⇒ Object
21 22 23 |
# File 'lib/win32ole.rb', line 21 def methods(*args) super + ole_methods_safely.map(&:name).map(&:to_sym) end |
#ole_activex_initialize ⇒ Qnil
Initialize WIN32OLE object(ActiveX Control) by calling IPersistMemory::InitNew.
Before calling OLE method, some kind of the ActiveX controls created with MFC should be initialized by calling IPersistXXX::InitNew.
If and only if you received the exception “HRESULT error code: 0x8000ffff catastrophic failure”, try this method before invoking any ole_method.
obj = WIN32OLE.new("ProgID_or_GUID_of_ActiveX_Control")
obj.ole_activex_initialize
obj.method(...)
3879 3880 3881 3882 3883 3884 3885 3886 3887 3888 3889 3890 3891 3892 3893 3894 3895 3896 3897 3898 3899 3900 3901 3902 3903 3904 3905 |
# File 'win32ole.c', line 3879
static VALUE
fole_activex_initialize(VALUE self)
{
struct oledata *pole = NULL;
IPersistMemory *pPersistMemory;
void *p;
HRESULT hr = S_OK;
pole = oledata_get_struct(self);
hr = pole->pDispatch->lpVtbl->QueryInterface(pole->pDispatch, &IID_IPersistMemory, &p);
pPersistMemory = p;
if (SUCCEEDED(hr)) {
hr = pPersistMemory->lpVtbl->InitNew(pPersistMemory);
OLE_RELEASE(pPersistMemory);
if (SUCCEEDED(hr)) {
return Qnil;
}
}
if (FAILED(hr)) {
ole_raise(hr, eWIN32OLERuntimeError, "fail to initialize ActiveX control");
}
return Qnil;
}
|
#ole_free ⇒ Object
invokes Release method of Dispatch interface of WIN32OLE object. Usually, you do not need to call this method because Release method called automatically when WIN32OLE object garbaged.
3235 3236 3237 3238 3239 3240 3241 3242 3243 |
# File 'win32ole.c', line 3235
static VALUE
fole_free(VALUE self)
{
struct oledata *pole = NULL;
pole = oledata_get_struct(self);
OLE_FREE(pole->pDispatch);
pole->pDispatch = NULL;
return Qnil;
}
|
#ole_func_methods ⇒ Object
3498 3499 3500 3501 3502 |
# File 'win32ole.c', line 3498
static VALUE
fole_func_methods(VALUE self)
{
return ole_methods( self, INVOKE_FUNC);
}
|
#ole_get_methods ⇒ Object
3465 3466 3467 3468 3469 |
# File 'win32ole.c', line 3465
static VALUE
fole_get_methods(VALUE self)
{
return ole_methods( self, INVOKE_PROPERTYGET);
}
|
#ole_method_help(method) ⇒ Object Also known as: ole_method_help
3836 3837 3838 3839 3840 3841 3842 3843 3844 3845 3846 3847 3848 3849 3850 3851 3852 3853 3854 3855 3856 3857 |
# File 'win32ole.c', line 3836
static VALUE
fole_method_help(VALUE self, VALUE cmdname)
{
ITypeInfo *pTypeInfo;
HRESULT hr;
struct oledata *pole = NULL;
VALUE obj;
SafeStringValue(cmdname);
pole = oledata_get_struct(self);
hr = typeinfo_from_ole(pole, &pTypeInfo);
if(FAILED(hr))
ole_raise(hr, eWIN32OLEQueryInterfaceError, "failed to get ITypeInfo");
obj = create_win32ole_method(pTypeInfo, cmdname);
OLE_RELEASE(pTypeInfo);
if (obj == Qnil)
rb_raise(eWIN32OLERuntimeError, "not found %s",
StringValuePtr(cmdname));
return obj;
}
|
#ole_methods ⇒ Object
3449 3450 3451 3452 3453 |
# File 'win32ole.c', line 3449
static VALUE
fole_methods(VALUE self)
{
return ole_methods( self, INVOKE_FUNC | INVOKE_PROPERTYGET | INVOKE_PROPERTYPUT | INVOKE_PROPERTYPUTREF);
}
|
#ole_put_methods ⇒ Object
3481 3482 3483 3484 3485 |
# File 'win32ole.c', line 3481
static VALUE
fole_put_methods(VALUE self)
{
return ole_methods( self, INVOKE_PROPERTYPUT|INVOKE_PROPERTYPUTREF);
}
|
#ole_query_interface(iid) ⇒ WIN32OLE object
3580 3581 3582 3583 3584 3585 3586 3587 3588 3589 3590 3591 3592 3593 3594 3595 3596 3597 3598 3599 3600 3601 3602 3603 3604 3605 3606 3607 3608 3609 3610 3611 3612 3613 3614 |
# File 'win32ole.c', line 3580
static VALUE
fole_query_interface(VALUE self, VALUE str_iid)
{
HRESULT hr;
OLECHAR *pBuf;
IID iid;
struct oledata *pole = NULL;
IDispatch *pDispatch;
void *p;
pBuf = ole_vstr2wc(str_iid);
hr = CLSIDFromString(pBuf, &iid);
SysFreeString(pBuf);
if(FAILED(hr)) {
ole_raise(hr, eWIN32OLERuntimeError,
"invalid iid: `%s'",
StringValuePtr(str_iid));
}
pole = oledata_get_struct(self);
if(!pole->pDispatch) {
rb_raise(rb_eRuntimeError, "failed to get dispatch interface");
}
hr = pole->pDispatch->lpVtbl->QueryInterface(pole->pDispatch, &iid,
&p);
if(FAILED(hr)) {
ole_raise(hr, eWIN32OLEQueryInterfaceError,
"failed to get interface `%s'",
StringValuePtr(str_iid));
}
pDispatch = p;
return create_win32ole_object(cWIN32OLE, pDispatch, 0, 0);
}
|
#ole_respond_to?(method) ⇒ Boolean
3625 3626 3627 3628 3629 3630 3631 3632 3633 3634 3635 3636 3637 3638 3639 3640 3641 3642 3643 3644 |
# File 'win32ole.c', line 3625
static VALUE
fole_respond_to(VALUE self, VALUE method)
{
struct oledata *pole = NULL;
BSTR wcmdname;
DISPID DispID;
HRESULT hr;
if(!RB_TYPE_P(method, T_STRING) && !RB_TYPE_P(method, T_SYMBOL)) {
rb_raise(rb_eTypeError, "wrong argument type (expected String or Symbol)");
}
if (RB_TYPE_P(method, T_SYMBOL)) {
method = rb_sym2str(method);
}
pole = oledata_get_struct(self);
wcmdname = ole_vstr2wc(method);
hr = pole->pDispatch->lpVtbl->GetIDsOfNames( pole->pDispatch, &IID_NULL,
&wcmdname, 1, cWIN32OLE_lcid, &DispID);
SysFreeString(wcmdname);
return SUCCEEDED(hr) ? Qtrue : Qfalse;
}
|
#ole_type ⇒ Object Also known as: ole_obj_help
3513 3514 3515 3516 3517 3518 3519 3520 3521 3522 3523 3524 3525 3526 3527 3528 3529 3530 3531 3532 3533 3534 |
# File 'win32ole.c', line 3513
static VALUE
fole_type(VALUE self)
{
ITypeInfo *pTypeInfo;
HRESULT hr;
struct oledata *pole = NULL;
LCID lcid = cWIN32OLE_lcid;
VALUE type = Qnil;
pole = oledata_get_struct(self);
hr = pole->pDispatch->lpVtbl->GetTypeInfo( pole->pDispatch, 0, lcid, &pTypeInfo );
if(FAILED(hr)) {
ole_raise(hr, eWIN32OLEQueryInterfaceError, "failed to GetTypeInfo");
}
type = ole_type_from_itypeinfo(pTypeInfo);
OLE_RELEASE(pTypeInfo);
if (type == Qnil) {
rb_raise(rb_eRuntimeError, "failed to create WIN32OLE_TYPE obj from ITypeInfo");
}
return type;
}
|
#ole_typelib ⇒ The WIN32OLE_TYPELIB object
3547 3548 3549 3550 3551 3552 3553 3554 3555 3556 3557 3558 3559 3560 3561 3562 3563 3564 3565 3566 3567 3568 |
# File 'win32ole.c', line 3547
static VALUE
fole_typelib(VALUE self)
{
struct oledata *pole = NULL;
HRESULT hr;
ITypeInfo *pTypeInfo;
LCID lcid = cWIN32OLE_lcid;
VALUE vtlib = Qnil;
pole = oledata_get_struct(self);
hr = pole->pDispatch->lpVtbl->GetTypeInfo(pole->pDispatch,
0, lcid, &pTypeInfo);
if(FAILED(hr)) {
ole_raise(hr, eWIN32OLEQueryInterfaceError, "failed to GetTypeInfo");
}
vtlib = ole_typelib_from_itypeinfo(pTypeInfo);
OLE_RELEASE(pTypeInfo);
if (vtlib == Qnil) {
rb_raise(rb_eRuntimeError, "failed to get type library info.");
}
return vtlib;
}
|
#setproperty('property', [arg1, arg2,...]) ⇒ Object
3133 3134 3135 3136 3137 3138 3139 3140 3141 |
# File 'win32ole.c', line 3133
static VALUE
fole_setproperty(int argc, VALUE *argv, VALUE self)
{
VALUE v = ole_invoke(argc, argv, self, DISPATCH_PROPERTYPUT, FALSE);
if (v == rb_eNoMethodError) {
return rb_call_super(argc, argv);
}
return v;
}
|