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.
3228 3229 3230 3231 3232 3233 3234 3235 3236 3237 3238 3239 3240 3241 3242 3243 3244 3245 3246 3247 3248 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 |
# File 'win32ole.c', line 3228
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_secure(4);
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.
4075 4076 4077 4078 4079 4080 4081 4082 4083 4084 4085 4086 4087 4088 4089 4090 4091 4092 4093 4094 4095 4096 |
# File 'win32ole.c', line 4075
static VALUE
fole_missing(int argc, VALUE *argv, VALUE self)
{
ID id;
const char* mname;
int n;
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(mname[n-1] == '=') {
argv[0] = rb_enc_str_new(mname, n-1, cWIN32OLE_enc);
return ole_propertyput(self, argv[0], argv[1]);
}
else {
argv[0] = rb_enc_str_new(mname, 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
3017 3018 3019 3020 3021 |
# File 'win32ole.c', line 3017
static VALUE
fole_s_get_code_page(VALUE self)
{
return INT2FIX(cWIN32OLE_cp);
}
|
.codepage=(CP) ⇒ Object
3054 3055 3056 3057 3058 3059 3060 3061 3062 3063 |
# File 'win32ole.c', line 3054
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.
2716 2717 2718 2719 2720 2721 2722 2723 2724 2725 2726 2727 2728 2729 2730 2731 2732 2733 2734 2735 2736 2737 2738 2739 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 |
# File 'win32ole.c', line 2716
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;
rb_secure(4);
/* 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
2798 2799 2800 2801 2802 2803 2804 2805 2806 2807 2808 2809 2810 2811 2812 2813 2814 2815 2816 2817 2818 2819 2820 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 |
# File 'win32ole.c', line 2798
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_secure(4);
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}
3135 3136 3137 3138 3139 3140 3141 3142 3143 3144 3145 3146 3147 3148 3149 3150 3151 |
# File 'win32ole.c', line 3135
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
3074 3075 3076 3077 3078 |
# File 'win32ole.c', line 3074
static VALUE
fole_s_get_locale(VALUE self)
{
return INT2FIX(cWIN32OLE_lcid);
}
|
.locale=(lcid) ⇒ Object
3109 3110 3111 3112 3113 3114 3115 3116 3117 3118 3119 3120 3121 3122 3123 3124 3125 3126 |
# File 'win32ole.c', line 3109
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.
2932 2933 2934 2935 2936 2937 2938 2939 2940 2941 2942 2943 2944 |
# File 'win32ole.c', line 2932
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
3160 3161 3162 3163 3164 3165 |
# File 'win32ole.c', line 3160
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.
2915 2916 2917 2918 2919 2920 2921 |
# File 'win32ole.c', line 2915
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
2978 2979 2980 2981 2982 2983 2984 2985 2986 2987 2988 2989 2990 2991 2992 2993 2994 2995 2996 2997 2998 2999 3000 3001 3002 3003 3004 3005 3006 3007 3008 |
# File 'win32ole.c', line 2978
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
3168 3169 3170 3171 3172 3173 |
# File 'win32ole.c', line 3168
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.
3891 3892 3893 3894 3895 |
# File 'win32ole.c', line 3891
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.
3850 3851 3852 3853 3854 |
# File 'win32ole.c', line 3850
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
3808 3809 3810 3811 3812 |
# File 'win32ole.c', line 3808
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
3790 3791 3792 3793 3794 |
# File 'win32ole.c', line 3790
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
3826 3827 3828 3829 3830 |
# File 'win32ole.c', line 3826
static VALUE
fole_setproperty2(VALUE self, VALUE dispid, VALUE args, VALUE types)
{
return ole_invoke2(self, dispid, args, types, DISPATCH_PROPERTYPUT);
}
|
#each {|i| ... } ⇒ Object
4012 4013 4014 4015 4016 4017 4018 4019 4020 4021 4022 4023 4024 4025 4026 4027 4028 4029 4030 4031 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 |
# File 'win32ole.c', line 4012
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
3582 3583 3584 3585 3586 |
# File 'win32ole.c', line 3582
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(...)
4772 4773 4774 4775 4776 4777 4778 4779 4780 4781 4782 4783 4784 4785 4786 4787 4788 4789 4790 4791 4792 4793 4794 4795 4796 4797 4798 |
# File 'win32ole.c', line 4772
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.
3963 3964 3965 3966 3967 3968 3969 3970 3971 3972 |
# File 'win32ole.c', line 3963
static VALUE
fole_free(VALUE self)
{
struct oledata *pole;
rb_secure(4);
OLEData_Get_Struct(self, pole);
OLE_FREE(pole->pDispatch);
pole->pDispatch = NULL;
return Qnil;
}
|
#ole_func_methods ⇒ Object
4353 4354 4355 4356 4357 |
# File 'win32ole.c', line 4353
static VALUE
fole_func_methods(VALUE self)
{
return ole_methods( self, INVOKE_FUNC);
}
|
#ole_get_methods ⇒ Object
4320 4321 4322 4323 4324 |
# File 'win32ole.c', line 4320
static VALUE
fole_get_methods(VALUE self)
{
return ole_methods( self, INVOKE_PROPERTYGET);
}
|
#ole_method_help(method) ⇒ Object Also known as: ole_method_help
4730 4731 4732 4733 4734 4735 4736 4737 4738 4739 4740 4741 4742 4743 4744 4745 4746 4747 4748 4749 4750 |
# File 'win32ole.c', line 4730
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
4304 4305 4306 4307 4308 |
# File 'win32ole.c', line 4304
static VALUE
fole_methods(VALUE self)
{
return ole_methods( self, INVOKE_FUNC | INVOKE_PROPERTYGET | INVOKE_PROPERTYPUT | INVOKE_PROPERTYPUTREF);
}
|
#ole_put_methods ⇒ Object
4336 4337 4338 4339 4340 |
# File 'win32ole.c', line 4336
static VALUE
fole_put_methods(VALUE self)
{
return ole_methods( self, INVOKE_PROPERTYPUT|INVOKE_PROPERTYPUTREF);
}
|
#ole_query_interface(iid) ⇒ WIN32OLE object
4476 4477 4478 4479 4480 4481 4482 4483 4484 4485 4486 4487 4488 4489 4490 4491 4492 4493 4494 4495 4496 4497 4498 4499 4500 4501 4502 4503 4504 4505 4506 4507 4508 4509 4510 |
# File 'win32ole.c', line 4476
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
4521 4522 4523 4524 4525 4526 4527 4528 4529 4530 4531 4532 4533 4534 4535 4536 4537 4538 4539 4540 4541 |
# File 'win32ole.c', line 4521
static VALUE
fole_respond_to(VALUE self, VALUE method)
{
struct oledata *pole;
BSTR wcmdname;
DISPID DispID;
HRESULT hr;
rb_secure(4);
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
4392 4393 4394 4395 4396 4397 4398 4399 4400 4401 4402 4403 4404 4405 4406 4407 4408 4409 4410 4411 4412 4413 |
# File 'win32ole.c', line 4392
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
4443 4444 4445 4446 4447 4448 4449 4450 4451 4452 4453 4454 4455 4456 4457 4458 4459 4460 4461 4462 4463 4464 |
# File 'win32ole.c', line 4443
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
3869 3870 3871 3872 3873 |
# File 'win32ole.c', line 3869
static VALUE
fole_setproperty(int argc, VALUE *argv, VALUE self)
{
return ole_invoke(argc, argv, self, DISPATCH_PROPERTYPUT, FALSE);
}
|