Class: WIN32OLE
- Inherits:
-
Object
- Object
- WIN32OLE
- Defined in:
- 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.
If you want to get the result value of argument passed by reference,
you can use WIN32OLE::ARGV.
oleobj.method(arg1, arg2, refargv3)
puts WIN32OLE::ARGV[2] # the value of refargv3 after called oleobj.method
Defined Under Namespace
Modules: VARIANT
Constant Summary collapse
- VERSION =
rb_str_new2(WIN32OLE_VERSION)
- ARGV =
rb_ary_new()
- CP_ACP =
INT2FIX(CP_ACP)
- CP_OEMCP =
INT2FIX(CP_OEMCP)
- CP_MACCP =
INT2FIX(CP_MACCP)
- CP_THREAD_ACP =
INT2FIX(CP_THREAD_ACP)
- CP_SYMBOL =
INT2FIX(CP_SYMBOL)
- CP_UTF7 =
INT2FIX(CP_UTF7)
- CP_UTF8 =
INT2FIX(CP_UTF8)
- LOCALE_SYSTEM_DEFAULT =
INT2FIX(LOCALE_SYSTEM_DEFAULT)
- LOCALE_USER_DEFAULT =
INT2FIX(LOCALE_USER_DEFAULT)
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.
-
#new(server, [host]) ⇒ WIN32OLE 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.
-
#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
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.
WIN32OLE.new('Excel.Application') # => Excel OLE Automation WIN32OLE object.
WIN32OLE.new('{00024500-0000-0000-C000-000000000046}') # => Excel OLE Automation WIN32OLE object.
3249 3250 3251 3252 3253 3254 3255 3256 3257 3258 3259 3260 3261 3262 3263 3264 3265 3266 3267 3268 3269 3270 3271 3272 3273 3274 3275 3276 3277 3278 3279 3280 3281 3282 3283 3284 3285 3286 3287 3288 3289 3290 3291 3292 3293 3294 3295 3296 3297 3298 3299 3300 3301 3302 |
# File 'win32ole.c', line 3249
static VALUE
fole_initialize(int argc, VALUE *argv, VALUE self)
{
VALUE svr_name;
VALUE host;
VALUE others;
HRESULT hr;
CLSID clsid;
OLECHAR *pBuf;
IDispatch *pDispatch;
void *p;
rb_call_super(0, 0);
rb_scan_args(argc, argv, "11*", &svr_name, &host, &others);
SafeStringValue(svr_name);
if (rb_safe_level() > 0 && OBJ_TAINTED(svr_name)) {
rb_raise(rb_eSecurityError, "Insecure Object Creation - %s",
StringValuePtr(svr_name));
}
if (!NIL_P(host)) {
SafeStringValue(host);
if (rb_safe_level() > 0 && OBJ_TAINTED(host)) {
rb_raise(rb_eSecurityError, "Insecure Object Creation - %s",
StringValuePtr(svr_name));
}
return ole_create_dcom(argc, argv, self);
}
/* 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));
}
/* get IDispatch interface */
hr = CoCreateInstance(&clsid, NULL, CLSCTX_INPROC_SERVER | CLSCTX_LOCAL_SERVER,
&IID_IDispatch, &p);
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.
4095 4096 4097 4098 4099 4100 4101 4102 4103 4104 4105 4106 4107 4108 4109 4110 4111 4112 4113 4114 4115 4116 4117 4118 4119 4120 4121 4122 4123 |
# File 'win32ole.c', line 4095
static VALUE
fole_missing(int argc, VALUE *argv, VALUE self)
{
ID id;
const char* mname;
size_t n;
rb_check_arity(argc, 1, UNLIMITED_ARGUMENTS);
id = rb_to_id(argv[0]);
mname = rb_id2name(id);
if(!mname) {
rb_raise(rb_eRuntimeError, "fail: unknown method or property");
}
n = strlen(mname);
#if SIZEOF_SIZE_T > SIZEOF_LONG
if (n >= LONG_MAX) {
rb_raise(rb_eRuntimeError, "too long method or property name");
}
#endif
if(mname[n-1] == '=') {
rb_check_arity(argc, 2, 2);
argv[0] = rb_enc_str_new(mname, (long)(n-1), cWIN32OLE_enc);
return ole_propertyput(self, argv[0], argv[1]);
}
else {
argv[0] = rb_enc_str_new(mname, (long)n, cWIN32OLE_enc);
return ole_invoke(argc, argv, self, DISPATCH_METHOD|DISPATCH_PROPERTYGET, FALSE);
}
}
|
Class Method Details
.codepage ⇒ Object
Returns current codepage.
WIN32OLE.codepage # => WIN32OLE::CP_ACP
3038 3039 3040 3041 3042 |
# File 'win32ole.c', line 3038
static VALUE
fole_s_get_code_page(VALUE self)
{
return INT2FIX(cWIN32OLE_cp);
}
|
.codepage=(CP) ⇒ Object
3075 3076 3077 3078 3079 3080 3081 3082 3083 3084 |
# File 'win32ole.c', line 3075
static VALUE
fole_s_set_code_page(VALUE self, VALUE vcp)
{
UINT cp = 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.
2740 2741 2742 2743 2744 2745 2746 2747 2748 2749 2750 2751 2752 2753 2754 2755 2756 2757 2758 2759 2760 2761 2762 2763 2764 2765 2766 2767 2768 2769 2770 2771 2772 2773 2774 2775 2776 2777 2778 2779 2780 2781 2782 2783 2784 2785 2786 2787 2788 2789 2790 |
# File 'win32ole.c', line 2740
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);
SafeStringValue(svr_name);
if (rb_safe_level() > 0 && OBJ_TAINTED(svr_name)) {
rb_raise(rb_eSecurityError, "Insecure Object Connection - %s",
StringValuePtr(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 variabl 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
2821 2822 2823 2824 2825 2826 2827 2828 2829 2830 2831 2832 2833 2834 2835 2836 2837 2838 2839 2840 2841 2842 2843 2844 2845 2846 2847 2848 2849 2850 2851 2852 2853 2854 2855 2856 2857 2858 2859 2860 2861 2862 2863 2864 2865 2866 2867 2868 2869 2870 2871 2872 2873 2874 2875 2876 2877 2878 2879 2880 2881 2882 2883 2884 |
# File 'win32ole.c', line 2821
static VALUE
fole_s_const_load(int argc, VALUE *argv, VALUE self)
{
VALUE ole;
VALUE klass;
struct oledata *pole;
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 (TYPE(klass) != T_CLASS &&
TYPE(klass) != T_MODULE &&
TYPE(klass) != T_NIL) {
rb_raise(rb_eTypeError, "2nd parameter must be Class or Module");
}
if (rb_obj_is_kind_of(ole, cWIN32OLE)) {
OLEData_Get_Struct(ole, pole);
hr = pole->pDispatch->lpVtbl->GetTypeInfo(pole->pDispatch,
0, lcid, &pTypeInfo);
if(FAILED(hr)) {
ole_raise(hr, rb_eRuntimeError, "failed to GetTypeInfo");
}
hr = pTypeInfo->lpVtbl->GetContainingTypeLib(pTypeInfo, &pTypeLib, &index);
if(FAILED(hr)) {
OLE_RELEASE(pTypeInfo);
ole_raise(hr, rb_eRuntimeError, "failed to GetContainingTypeLib");
}
OLE_RELEASE(pTypeInfo);
if(TYPE(klass) != T_NIL) {
ole_const_load(pTypeLib, klass, self);
}
else {
ole_const_load(pTypeLib, cWIN32OLE, self);
}
OLE_RELEASE(pTypeLib);
}
else if(TYPE(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(TYPE(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}
3156 3157 3158 3159 3160 3161 3162 3163 3164 3165 3166 3167 3168 3169 3170 3171 3172 |
# File 'win32ole.c', line 3156
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 LOCALE_SYSTEM_DEFAULT.
lcid = WIN32OLE.locale
3095 3096 3097 3098 3099 |
# File 'win32ole.c', line 3095
static VALUE
fole_s_get_locale(VALUE self)
{
return INT2FIX(cWIN32OLE_lcid);
}
|
.locale=(lcid) ⇒ Object
3130 3131 3132 3133 3134 3135 3136 3137 3138 3139 3140 3141 3142 3143 3144 3145 3146 3147 |
# File 'win32ole.c', line 3130
static VALUE
fole_s_set_locale(VALUE self, VALUE vlcid)
{
LCID lcid = 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.
2953 2954 2955 2956 2957 2958 2959 2960 2961 2962 2963 2964 2965 |
# File 'win32ole.c', line 2953
static VALUE
fole_s_free(VALUE self, VALUE obj)
{
ULONG n = 0;
struct oledata * pole;
OLEData_Get_Struct(obj, pole);
if(pole->pDispatch) {
if (reference_count(pole) > 0) {
n = OLE_RELEASE(pole->pDispatch);
}
}
return INT2NUM(n);
}
|
.ole_initialize ⇒ Object
:nodoc
3181 3182 3183 3184 3185 3186 |
# File 'win32ole.c', line 3181
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.
2936 2937 2938 2939 2940 2941 2942 |
# File 'win32ole.c', line 2936
static VALUE
fole_s_reference_count(VALUE self, VALUE obj)
{
struct oledata * pole;
OLEData_Get_Struct(obj, pole);
return INT2NUM(reference_count(pole));
}
|
.ole_show_help(obj[,helpcontext]) ⇒ Object
2999 3000 3001 3002 3003 3004 3005 3006 3007 3008 3009 3010 3011 3012 3013 3014 3015 3016 3017 3018 3019 3020 3021 3022 3023 3024 3025 3026 3027 3028 3029 |
# File 'win32ole.c', line 2999
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 (TYPE(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
3189 3190 3191 3192 3193 3194 |
# File 'win32ole.c', line 3189
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.
3912 3913 3914 3915 3916 |
# File 'win32ole.c', line 3912
static VALUE
fole_getproperty_with_bracket(int argc, VALUE *argv, VALUE self)
{
return ole_invoke(argc, argv, self, DISPATCH_PROPERTYGET, TRUE);
}
|
#[]=(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.
3871 3872 3873 3874 3875 |
# File 'win32ole.c', line 3871
static VALUE
fole_setproperty_with_bracket(int argc, VALUE *argv, VALUE self)
{
return ole_invoke(argc, argv, self, DISPATCH_PROPERTYPUT, TRUE);
}
|
#_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
3829 3830 3831 3832 3833 |
# File 'win32ole.c', line 3829
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
3811 3812 3813 3814 3815 |
# File 'win32ole.c', line 3811
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
3847 3848 3849 3850 3851 |
# File 'win32ole.c', line 3847
static VALUE
fole_setproperty2(VALUE self, VALUE dispid, VALUE args, VALUE types)
{
return ole_invoke2(self, dispid, args, types, DISPATCH_PROPERTYPUT);
}
|
#each {|i| ... } ⇒ Object
4032 4033 4034 4035 4036 4037 4038 4039 4040 4041 4042 4043 4044 4045 4046 4047 4048 4049 4050 4051 4052 4053 4054 4055 4056 4057 4058 4059 4060 4061 4062 4063 4064 4065 4066 4067 4068 4069 4070 4071 4072 4073 4074 4075 4076 4077 4078 4079 4080 4081 4082 4083 4084 4085 4086 4087 |
# File 'win32ole.c', line 4032
static VALUE
fole_each(VALUE self)
{
LCID lcid = cWIN32OLE_lcid;
struct oledata *pole;
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));
OLEData_Get_Struct(self, pole);
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, eWIN32OLERuntimeError, "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, rb_eRuntimeError, "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
3603 3604 3605 3606 3607 |
# File 'win32ole.c', line 3603
static VALUE
fole_invoke(int argc, VALUE *argv, VALUE self)
{
return ole_invoke(argc, argv, self, DISPATCH_METHOD|DISPATCH_PROPERTYGET, FALSE);
}
|
#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(...)
4798 4799 4800 4801 4802 4803 4804 4805 4806 4807 4808 4809 4810 4811 4812 4813 4814 4815 4816 4817 4818 4819 4820 4821 4822 4823 4824 |
# File 'win32ole.c', line 4798
static VALUE
fole_activex_initialize(VALUE self)
{
struct oledata *pole;
IPersistMemory *pPersistMemory;
void *p;
HRESULT hr = S_OK;
OLEData_Get_Struct(self, pole);
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.
3984 3985 3986 3987 3988 3989 3990 3991 3992 |
# File 'win32ole.c', line 3984
static VALUE
fole_free(VALUE self)
{
struct oledata *pole;
OLEData_Get_Struct(self, pole);
OLE_FREE(pole->pDispatch);
pole->pDispatch = NULL;
return Qnil;
}
|
#ole_func_methods ⇒ Object
4380 4381 4382 4383 4384 |
# File 'win32ole.c', line 4380
static VALUE
fole_func_methods(VALUE self)
{
return ole_methods( self, INVOKE_FUNC);
}
|
#ole_get_methods ⇒ Object
4347 4348 4349 4350 4351 |
# File 'win32ole.c', line 4347
static VALUE
fole_get_methods(VALUE self)
{
return ole_methods( self, INVOKE_PROPERTYGET);
}
|
#ole_method_help(method) ⇒ Object Also known as: ole_method_help
4756 4757 4758 4759 4760 4761 4762 4763 4764 4765 4766 4767 4768 4769 4770 4771 4772 4773 4774 4775 4776 |
# File 'win32ole.c', line 4756
static VALUE
fole_method_help(VALUE self, VALUE cmdname)
{
ITypeInfo *pTypeInfo;
HRESULT hr;
struct oledata *pole;
VALUE method, obj;
SafeStringValue(cmdname);
OLEData_Get_Struct(self, pole);
hr = typeinfo_from_ole(pole, &pTypeInfo);
if(FAILED(hr))
ole_raise(hr, rb_eRuntimeError, "failed to get ITypeInfo");
method = folemethod_s_allocate(cWIN32OLE_METHOD);
obj = olemethod_from_typeinfo(method, pTypeInfo, cmdname);
OLE_RELEASE(pTypeInfo);
if (obj == Qnil)
rb_raise(eWIN32OLERuntimeError, "not found %s",
StringValuePtr(cmdname));
return obj;
}
|
#ole_methods ⇒ Object
4331 4332 4333 4334 4335 |
# File 'win32ole.c', line 4331
static VALUE
fole_methods(VALUE self)
{
return ole_methods( self, INVOKE_FUNC | INVOKE_PROPERTYGET | INVOKE_PROPERTYPUT | INVOKE_PROPERTYPUTREF);
}
|
#ole_put_methods ⇒ Object
4363 4364 4365 4366 4367 |
# File 'win32ole.c', line 4363
static VALUE
fole_put_methods(VALUE self)
{
return ole_methods( self, INVOKE_PROPERTYPUT|INVOKE_PROPERTYPUTREF);
}
|
#ole_query_interface(iid) ⇒ WIN32OLE object
4503 4504 4505 4506 4507 4508 4509 4510 4511 4512 4513 4514 4515 4516 4517 4518 4519 4520 4521 4522 4523 4524 4525 4526 4527 4528 4529 4530 4531 4532 4533 4534 4535 4536 4537 |
# File 'win32ole.c', line 4503
static VALUE
fole_query_interface(VALUE self, VALUE str_iid)
{
HRESULT hr;
OLECHAR *pBuf;
IID iid;
struct oledata *pole;
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));
}
OLEData_Get_Struct(self, pole);
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, eWIN32OLERuntimeError,
"failed to get interface `%s'",
StringValuePtr(str_iid));
}
pDispatch = p;
return create_win32ole_object(cWIN32OLE, pDispatch, 0, 0);
}
|
#ole_respond_to?(method) ⇒ Boolean
4548 4549 4550 4551 4552 4553 4554 4555 4556 4557 4558 4559 4560 4561 4562 4563 4564 4565 4566 4567 |
# File 'win32ole.c', line 4548
static VALUE
fole_respond_to(VALUE self, VALUE method)
{
struct oledata *pole;
BSTR wcmdname;
DISPID DispID;
HRESULT hr;
if(TYPE(method) != T_STRING && TYPE(method) != T_SYMBOL) {
rb_raise(rb_eTypeError, "wrong argument type (expected String or Symbol)");
}
if (TYPE(method) == T_SYMBOL) {
method = rb_sym_to_s(method);
}
OLEData_Get_Struct(self, pole);
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
4419 4420 4421 4422 4423 4424 4425 4426 4427 4428 4429 4430 4431 4432 4433 4434 4435 4436 4437 4438 4439 4440 |
# File 'win32ole.c', line 4419
static VALUE
fole_type(VALUE self)
{
ITypeInfo *pTypeInfo;
HRESULT hr;
struct oledata *pole;
LCID lcid = cWIN32OLE_lcid;
VALUE type = Qnil;
OLEData_Get_Struct(self, pole);
hr = pole->pDispatch->lpVtbl->GetTypeInfo( pole->pDispatch, 0, lcid, &pTypeInfo );
if(FAILED(hr)) {
ole_raise(hr, rb_eRuntimeError, "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
4470 4471 4472 4473 4474 4475 4476 4477 4478 4479 4480 4481 4482 4483 4484 4485 4486 4487 4488 4489 4490 4491 |
# File 'win32ole.c', line 4470
static VALUE
fole_typelib(VALUE self)
{
struct oledata *pole;
HRESULT hr;
ITypeInfo *pTypeInfo;
LCID lcid = cWIN32OLE_lcid;
VALUE vtlib = Qnil;
OLEData_Get_Struct(self, pole);
hr = pole->pDispatch->lpVtbl->GetTypeInfo(pole->pDispatch,
0, lcid, &pTypeInfo);
if(FAILED(hr)) {
ole_raise(hr, rb_eRuntimeError, "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
3890 3891 3892 3893 3894 |
# File 'win32ole.c', line 3890
static VALUE
fole_setproperty(int argc, VALUE *argv, VALUE self)
{
return ole_invoke(argc, argv, self, DISPATCH_PROPERTYPUT, FALSE);
}
|