rubyuno 0.3.0
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.
- data/.gitignore +20 -0
- data/CHANGES +16 -0
- data/Gemfile +4 -0
- data/LICENSE +202 -0
- data/README +46 -0
- data/Rakefile +603 -0
- data/ext/rubyuno/adapter.cxx +271 -0
- data/ext/rubyuno/extconf.rb +125 -0
- data/ext/rubyuno/libruno.def +26 -0
- data/ext/rubyuno/loader.cxx +184 -0
- data/ext/rubyuno/module.cxx +1263 -0
- data/ext/rubyuno/rubyuno.hxx +263 -0
- data/ext/rubyuno/runo.def +2 -0
- data/ext/rubyuno/runtime.cxx +524 -0
- data/ext/rubyuno/string.cxx +252 -0
- data/ext/rubyuno/type.cxx +358 -0
- data/lib/rubyloader.rb +302 -0
- data/lib/rubyscriptprovider.rb +1025 -0
- data/lib/rubyuno.rb +20 -0
- data/lib/rubyuno/uno.rb +105 -0
- data/lib/rubyuno/uno/connector.rb +97 -0
- data/lib/rubyuno/version.rb +3 -0
- data/rubyuno.gemspec +17 -0
- data/sample/calc-chart.rb +66 -0
- data/sample/dialog_listener.rb +70 -0
- data/sample/filter-names.rb +123 -0
- data/sample/inputbox.rb +74 -0
- data/sample/mri.rb +17 -0
- data/sample/open-doc1.rb +20 -0
- metadata +89 -0
@@ -0,0 +1,1263 @@
|
|
1
|
+
|
2
|
+
#include "rubyuno.hxx"
|
3
|
+
|
4
|
+
#include <cppuhelper/bootstrap.hxx>
|
5
|
+
#include <osl/file.hxx>
|
6
|
+
#include <osl/thread.h>
|
7
|
+
#include <rtl/textenc.h>
|
8
|
+
#include <rtl/ustrbuf.hxx>
|
9
|
+
#include <rtl/uuid.h>
|
10
|
+
#include <typelib/typedescription.hxx>
|
11
|
+
|
12
|
+
#include <com/sun/star/beans/PropertyAttribute.hpp>
|
13
|
+
#include <com/sun/star/beans/XMaterialHolder.hpp>
|
14
|
+
#include <com/sun/star/lang/WrappedTargetException.hpp>
|
15
|
+
#include <com/sun/star/reflection/XConstantsTypeDescription.hpp>
|
16
|
+
#include <com/sun/star/reflection/XConstantTypeDescription.hpp>
|
17
|
+
#include <com/sun/star/reflection/XEnumTypeDescription.hpp>
|
18
|
+
#include <com/sun/star/reflection/XIdlClass.hpp>
|
19
|
+
#include <com/sun/star/script/InvocationInfo.hpp>
|
20
|
+
#include <com/sun/star/script/MemberType.hpp>
|
21
|
+
#include <com/sun/star/uno/Type.hxx>
|
22
|
+
|
23
|
+
using com::sun::star::beans::XMaterialHolder;
|
24
|
+
using com::sun::star::lang::WrappedTargetException;
|
25
|
+
using com::sun::star::reflection::XConstantsTypeDescription;
|
26
|
+
using com::sun::star::reflection::XConstantTypeDescription;
|
27
|
+
using com::sun::star::reflection::XEnumTypeDescription;
|
28
|
+
using com::sun::star::reflection::XIdlClass;
|
29
|
+
using com::sun::star::reflection::XTypeDescription;
|
30
|
+
using com::sun::star::script::InvocationInfo;
|
31
|
+
using com::sun::star::script::MemberType;
|
32
|
+
using com::sun::star::script::XInvocation2;
|
33
|
+
using com::sun::star::uno::Any;
|
34
|
+
using com::sun::star::uno::Reference;
|
35
|
+
using com::sun::star::uno::Type;
|
36
|
+
using com::sun::star::uno::TypeDescription;
|
37
|
+
using com::sun::star::uno::XComponentContext;
|
38
|
+
using com::sun::star::uno::UNO_QUERY;
|
39
|
+
|
40
|
+
using namespace cppu;
|
41
|
+
using namespace rtl;
|
42
|
+
|
43
|
+
using namespace com::sun::star::uno;
|
44
|
+
using namespace com::sun::star::beans;
|
45
|
+
using namespace com::sun::star::script;
|
46
|
+
|
47
|
+
using rtl::OUString;
|
48
|
+
using rtl::OUStringBuffer;
|
49
|
+
using rtl::OUStringToOString;
|
50
|
+
|
51
|
+
using namespace rubyuno;
|
52
|
+
|
53
|
+
namespace
|
54
|
+
{
|
55
|
+
|
56
|
+
/*
|
57
|
+
* Make URL absolute from URL and relative path.
|
58
|
+
* p Rubyuno.absolutize("file:///home/ruby/Desktop", "../")
|
59
|
+
* #=> "file:///home/ruby/"
|
60
|
+
*/
|
61
|
+
static VALUE
|
62
|
+
rubyuno_absolutize(VALUE self, VALUE base_url, VALUE rel_path)
|
63
|
+
{
|
64
|
+
rb_secure(2);
|
65
|
+
OUString baseUrl = rbString2OUString(base_url);
|
66
|
+
OUString relativePath = rbString2OUString(rel_path);
|
67
|
+
OUString absUrl;
|
68
|
+
|
69
|
+
osl::FileBase::RC e = osl::FileBase::getAbsoluteFileURL(baseUrl, relativePath, absUrl);
|
70
|
+
if (e != osl::FileBase::E_None)
|
71
|
+
{
|
72
|
+
rb_raise(rb_eArgError, "invalid url (%s) or invalid relative path (%s)", RSTRING_PTR(base_url), RSTRING_PTR(rel_path));
|
73
|
+
}
|
74
|
+
return ustring2RString(absUrl);
|
75
|
+
}
|
76
|
+
|
77
|
+
/*
|
78
|
+
* Convert system path to file URL. Multi-byte characters are escaped.
|
79
|
+
* p Rubyuno.system_path_to_file_url("/home/ruby/Desktop")
|
80
|
+
* #=> "file:///home/ruby/Desktop"
|
81
|
+
*/
|
82
|
+
static VALUE
|
83
|
+
rubyuno_getSystemPathFromFileURL(VALUE self, VALUE file_url)
|
84
|
+
{
|
85
|
+
rb_secure(2);
|
86
|
+
OUString url = rbString2OUString(file_url);
|
87
|
+
OUString sysPath;
|
88
|
+
osl::FileBase::RC e = osl::FileBase::getSystemPathFromFileURL(url, sysPath);
|
89
|
+
if (e != osl::FileBase::E_None)
|
90
|
+
{
|
91
|
+
rb_raise(rb_eArgError, "invalid url (%s)", RSTRING_PTR(file_url));
|
92
|
+
}
|
93
|
+
return ustring2RString(sysPath);
|
94
|
+
}
|
95
|
+
|
96
|
+
/*
|
97
|
+
* Convert file URL to system path.
|
98
|
+
* p Rubyuno.file_url_to_system_path("file:///home/ruby/Desktop)
|
99
|
+
* #=> "/home/ruby/Desktop"
|
100
|
+
*/
|
101
|
+
static VALUE
|
102
|
+
rubyuno_getFileURLFromSystemPath(VALUE self, VALUE path)
|
103
|
+
{
|
104
|
+
rb_secure(2);
|
105
|
+
OUString sysPath = rbString2OUString(path);
|
106
|
+
OUString url;
|
107
|
+
osl::FileBase::RC e = osl::FileBase::getFileURLFromSystemPath(sysPath, url);
|
108
|
+
if (e != osl::FileBase::E_None)
|
109
|
+
{
|
110
|
+
rb_raise(rb_eArgError, "invalid path (%s)", RSTRING_PTR(path));
|
111
|
+
}
|
112
|
+
return ustring2RString(url);
|
113
|
+
}
|
114
|
+
|
115
|
+
/*
|
116
|
+
* Generate UUID version 4
|
117
|
+
*/
|
118
|
+
static VALUE
|
119
|
+
rubyuno_create_uuid(VALUE self)
|
120
|
+
{
|
121
|
+
Sequence< sal_Int8 > seq(16);
|
122
|
+
rtl_createUuid((sal_uInt8*)seq.getArray(), 0, sal_False);
|
123
|
+
VALUE ret;
|
124
|
+
try
|
125
|
+
{
|
126
|
+
Runtime runtime;
|
127
|
+
ret = runtime.any_to_VALUE(makeAny(seq));
|
128
|
+
}
|
129
|
+
catch (RuntimeException &e)
|
130
|
+
{
|
131
|
+
rb_raise(rb_eRuntimeError, "failed to create UUID.");
|
132
|
+
}
|
133
|
+
return ret;
|
134
|
+
}
|
135
|
+
|
136
|
+
/*
|
137
|
+
* Returns component contex and initialize bridge.
|
138
|
+
* ctx = Rubyuno.get_component_context
|
139
|
+
*/
|
140
|
+
static VALUE
|
141
|
+
rubyuno_getComponentContext(VALUE self)
|
142
|
+
{
|
143
|
+
rb_secure(2);
|
144
|
+
Reference< XComponentContext > ctx;
|
145
|
+
|
146
|
+
if (Runtime::isInitialized())
|
147
|
+
{
|
148
|
+
Runtime r;
|
149
|
+
ctx = r.getImpl()->xComponentContext;
|
150
|
+
}
|
151
|
+
else
|
152
|
+
{
|
153
|
+
ctx = defaultBootstrap_InitialComponentContext();
|
154
|
+
if (ctx.is())
|
155
|
+
{
|
156
|
+
try
|
157
|
+
{
|
158
|
+
Runtime::initialize(ctx);
|
159
|
+
}
|
160
|
+
catch (RuntimeException &e)
|
161
|
+
{
|
162
|
+
rb_raise(rb_eTypeError, "wrong value in @rubyuno_runtime variable.");
|
163
|
+
}
|
164
|
+
}
|
165
|
+
else
|
166
|
+
{
|
167
|
+
rb_raise(rb_eRuntimeError, "failed to bootstrap.");
|
168
|
+
}
|
169
|
+
}
|
170
|
+
if (ctx.is()) {
|
171
|
+
Runtime runtime;
|
172
|
+
return runtime.any_to_VALUE(makeAny(ctx));
|
173
|
+
}
|
174
|
+
return Qnil;
|
175
|
+
}
|
176
|
+
|
177
|
+
|
178
|
+
/*
|
179
|
+
* Load UNO value.
|
180
|
+
*/
|
181
|
+
static VALUE
|
182
|
+
rubyuno_uno_require(VALUE self, VALUE name)
|
183
|
+
{
|
184
|
+
VALUE ret = Qnil;
|
185
|
+
try
|
186
|
+
{
|
187
|
+
OUString typeName = rbString2OUString(name);
|
188
|
+
Runtime runtime;
|
189
|
+
Any a = runtime.getImpl()->xTypeDescription->getByHierarchicalName(typeName);
|
190
|
+
if (a.getValueTypeClass() == TypeClass_INTERFACE)
|
191
|
+
{
|
192
|
+
Reference< XTypeDescription > xTd(a, UNO_QUERY);
|
193
|
+
if (!xTd.is())
|
194
|
+
rb_raise(rb_eArgError, "unknown type (%s)", RSTRING_PTR(name));
|
195
|
+
|
196
|
+
// typeName is checked by the TypeDescriptionManager
|
197
|
+
VALUE module, klass;
|
198
|
+
ID id;
|
199
|
+
sal_Int32 ends;
|
200
|
+
OUString tmpName, moduleName;
|
201
|
+
char *className;
|
202
|
+
OUStringBuffer buf;
|
203
|
+
|
204
|
+
ends = typeName.lastIndexOfAsciiL(".", 1);
|
205
|
+
tmpName = typeName.copy(ends + 1);
|
206
|
+
|
207
|
+
module = create_module(typeName);
|
208
|
+
|
209
|
+
buf.append(tmpName.copy(0, 1).toAsciiUpperCase()).append(tmpName.copy(1));
|
210
|
+
className = (char*) OUStringToOString(buf.makeStringAndClear(), RTL_TEXTENCODING_ASCII_US ).getStr();
|
211
|
+
id = rb_intern(className);
|
212
|
+
|
213
|
+
if (xTd->getTypeClass() == TypeClass_STRUCT || xTd->getTypeClass() == TypeClass_EXCEPTION)
|
214
|
+
{
|
215
|
+
Any aStruct;
|
216
|
+
Reference< XIdlClass > xIdlClass(runtime.getImpl()->xCoreReflection->forName(typeName), UNO_QUERY);
|
217
|
+
if (xIdlClass.is())
|
218
|
+
{
|
219
|
+
// forName method breaks className
|
220
|
+
buf.append(tmpName.copy(0, 1).toAsciiUpperCase()).append(tmpName.copy(1));
|
221
|
+
className = (char*) OUStringToOString(
|
222
|
+
buf.makeStringAndClear(), RTL_TEXTENCODING_ASCII_US).getStr();
|
223
|
+
if (rb_const_defined(module, id))
|
224
|
+
{
|
225
|
+
klass = rb_const_get(module, id);
|
226
|
+
}
|
227
|
+
else
|
228
|
+
{
|
229
|
+
if (xTd->getTypeClass() == TypeClass_STRUCT)
|
230
|
+
klass = rb_define_class_under(module, className, get_struct_class());
|
231
|
+
else
|
232
|
+
klass = rb_define_class_under(module, className, get_exception_class());
|
233
|
+
|
234
|
+
VALUE type_name = rb_str_new2(RSTRING_PTR(name));
|
235
|
+
rb_define_const(klass, "TYPENAME", type_name);
|
236
|
+
}
|
237
|
+
return klass;
|
238
|
+
}
|
239
|
+
rb_raise(rb_eArgError, "unknown type (%s)", RSTRING_PTR(name));
|
240
|
+
}
|
241
|
+
else if (xTd->getTypeClass() == TypeClass_CONSTANTS)
|
242
|
+
{
|
243
|
+
if (rb_const_defined(module, id))
|
244
|
+
klass = rb_const_get(module, id);
|
245
|
+
else
|
246
|
+
klass = rb_define_module_under(module, className);
|
247
|
+
|
248
|
+
VALUE value;
|
249
|
+
Reference< XConstantsTypeDescription > xDesc(a, UNO_QUERY);
|
250
|
+
Sequence< Reference< XConstantTypeDescription > > constants(xDesc->getConstants());
|
251
|
+
sal_Int32 nStart = typeName.getLength() + 1;
|
252
|
+
for (sal_Int32 i = 0; i < constants.getLength(); i++)
|
253
|
+
{
|
254
|
+
value = runtime.any_to_VALUE(constants[i]->getConstantValue());
|
255
|
+
rb_iv_set(klass, OUStringToOString(
|
256
|
+
constants[i]->getName().copy(nStart), RTL_TEXTENCODING_ASCII_US ), value);
|
257
|
+
}
|
258
|
+
return klass;
|
259
|
+
}
|
260
|
+
else if (xTd->getTypeClass() == TypeClass_ENUM)
|
261
|
+
{
|
262
|
+
// as module and module constants
|
263
|
+
if (rb_const_defined(module, id))
|
264
|
+
{
|
265
|
+
klass = rb_const_get(module, id);
|
266
|
+
}
|
267
|
+
else
|
268
|
+
{
|
269
|
+
klass = rb_define_module_under(module, className);
|
270
|
+
}
|
271
|
+
Reference< XEnumTypeDescription > xEnumDesc(a, UNO_QUERY);
|
272
|
+
Sequence< OUString > names(xEnumDesc->getEnumNames());
|
273
|
+
|
274
|
+
VALUE enum_class = get_enum_class();
|
275
|
+
VALUE obj;
|
276
|
+
VALUE type_name = ustring2RString(typeName);
|
277
|
+
OUString valueName;
|
278
|
+
|
279
|
+
TypeDescription desc(typeName);
|
280
|
+
if (!desc.is())
|
281
|
+
{
|
282
|
+
rb_raise(rb_eArgError, "unknown type name (%s)", RSTRING_PTR(type_name));
|
283
|
+
}
|
284
|
+
if (desc.get()->eTypeClass != typelib_TypeClass_ENUM)
|
285
|
+
{
|
286
|
+
rb_raise(rb_eArgError, "wrong type name (%s)", RSTRING_PTR(type_name));
|
287
|
+
}
|
288
|
+
desc.makeComplete();
|
289
|
+
|
290
|
+
typelib_EnumTypeDescription *pEnumDesc = (typelib_EnumTypeDescription*) desc.get();
|
291
|
+
int i = 0;
|
292
|
+
for (i = 0; i < pEnumDesc->nEnumValues; i++)
|
293
|
+
{
|
294
|
+
Any a = Any(&pEnumDesc->pEnumValues[i], desc.get()->pWeakRef);
|
295
|
+
RubyunoValue *ptr;
|
296
|
+
ptr = new RubyunoValue();
|
297
|
+
obj = rb_obj_alloc(enum_class);
|
298
|
+
DATA_PTR(obj) = ptr;
|
299
|
+
ptr->value = a;
|
300
|
+
|
301
|
+
valueName = (*((OUString*)&pEnumDesc->ppEnumNames[i]));
|
302
|
+
rb_iv_set(obj, "@type_name", type_name);
|
303
|
+
rb_iv_set(obj, "@value", ustring2RString(valueName));
|
304
|
+
|
305
|
+
rb_iv_set(klass, OUStringToOString(
|
306
|
+
valueName, RTL_TEXTENCODING_ASCII_US ).getStr(), obj);
|
307
|
+
}
|
308
|
+
return klass;
|
309
|
+
}
|
310
|
+
else if (xTd->getTypeClass() == TypeClass_INTERFACE)
|
311
|
+
{
|
312
|
+
VALUE klass;
|
313
|
+
klass = find_interface(xTd);
|
314
|
+
if (NIL_P(klass))
|
315
|
+
rb_raise(rb_eArgError, "unknown type name (%s)", RSTRING_PTR(name));
|
316
|
+
return klass;
|
317
|
+
}
|
318
|
+
else
|
319
|
+
{
|
320
|
+
rb_raise(rb_eRuntimeError, "unsupported type (%s)", RSTRING_PTR(name));
|
321
|
+
}
|
322
|
+
}
|
323
|
+
// direct values like enums and constants
|
324
|
+
OUString tmpTypeName, valueName;
|
325
|
+
sal_Int32 ends;
|
326
|
+
ends = typeName.lastIndexOfAsciiL(".", 1);
|
327
|
+
tmpTypeName = typeName.copy(0, ends);
|
328
|
+
valueName = typeName.copy(ends + 1);
|
329
|
+
|
330
|
+
Any desc = runtime.getImpl()->xTypeDescription->getByHierarchicalName(tmpTypeName);
|
331
|
+
if (desc.getValueTypeClass() == TypeClass_INTERFACE)
|
332
|
+
{
|
333
|
+
// constants group is not processed here
|
334
|
+
Reference< XTypeDescription > xTdm(desc, UNO_QUERY);
|
335
|
+
if (xTdm.is() && xTdm->getTypeClass() == TypeClass_ENUM)
|
336
|
+
{
|
337
|
+
return rb_funcall(get_enum_class(), rb_intern("new"), 2, ustring2RString(tmpTypeName), ustring2RString(valueName));
|
338
|
+
}
|
339
|
+
}
|
340
|
+
ret = runtime.any_to_VALUE(a);
|
341
|
+
}
|
342
|
+
catch (com::sun::star::container::NoSuchElementException &e)
|
343
|
+
{
|
344
|
+
rb_raise(rb_eArgError, "unknown value (%s)", RSTRING_PTR(name));
|
345
|
+
}
|
346
|
+
catch (com::sun::star::script::CannotConvertException &e)
|
347
|
+
{
|
348
|
+
rb_raise(rb_eRuntimeError, "failed to convert type for (%s)", RSTRING_PTR(name));
|
349
|
+
}
|
350
|
+
catch (com::sun::star::uno::RuntimeException &e)
|
351
|
+
{
|
352
|
+
rb_raise(rb_eArgError, "invalid name for value (%s)", RSTRING_PTR(name));
|
353
|
+
}
|
354
|
+
return ret;
|
355
|
+
}
|
356
|
+
|
357
|
+
/*
|
358
|
+
* Import somethings with a call.
|
359
|
+
* if argc == 1, value is returned and if multiple arguments are passed,
|
360
|
+
* returnes as Array.
|
361
|
+
*/
|
362
|
+
static VALUE
|
363
|
+
rubyuno_uno_multiple_require(int argc, VALUE *argv, VALUE self)
|
364
|
+
{
|
365
|
+
if (argc == 0)
|
366
|
+
return Qnil;
|
367
|
+
VALUE args;
|
368
|
+
rb_scan_args(argc, argv, "*", &args);
|
369
|
+
|
370
|
+
if (argc == 1)
|
371
|
+
return rubyuno_uno_require(self, rb_ary_entry(args, 0));
|
372
|
+
|
373
|
+
VALUE ret = rb_ary_new2(argc);
|
374
|
+
for (int i = 0; i < argc; i++)
|
375
|
+
{
|
376
|
+
rb_ary_push(ret, rubyuno_uno_require(self, rb_ary_entry(args, i)));
|
377
|
+
}
|
378
|
+
return ret;
|
379
|
+
}
|
380
|
+
|
381
|
+
|
382
|
+
static void
|
383
|
+
rubyuno_proxy_free(RubyunoInternal *rubyuno)
|
384
|
+
{
|
385
|
+
if (rubyuno)
|
386
|
+
{
|
387
|
+
rubyuno->wrapped.clear();
|
388
|
+
//rubyuno->invocation.clear();
|
389
|
+
delete rubyuno;
|
390
|
+
}
|
391
|
+
}
|
392
|
+
|
393
|
+
|
394
|
+
static VALUE
|
395
|
+
rubyuno_proxy_alloc(VALUE klass)
|
396
|
+
{
|
397
|
+
return Data_Wrap_Struct(klass, 0, rubyuno_proxy_free, 0);
|
398
|
+
}
|
399
|
+
|
400
|
+
|
401
|
+
VALUE
|
402
|
+
proxy_attr(const VALUE *self, RubyunoInternal *rubyuno, VALUE *name, OUString propertyName, VALUE &args, int mode)
|
403
|
+
{
|
404
|
+
VALUE ret = Qnil;
|
405
|
+
Runtime r;
|
406
|
+
Any a;
|
407
|
+
try
|
408
|
+
{
|
409
|
+
if (!mode)
|
410
|
+
{
|
411
|
+
a = rubyuno->invocation->getValue(propertyName);
|
412
|
+
ret = r.any_to_VALUE(a);
|
413
|
+
}
|
414
|
+
else
|
415
|
+
{
|
416
|
+
a = r.value_to_any(rb_ary_entry(args, 0));
|
417
|
+
rubyuno->invocation->setValue(propertyName, a);
|
418
|
+
ret = Qnil;
|
419
|
+
}
|
420
|
+
}
|
421
|
+
catch (com::sun::star::beans::UnknownPropertyException &e)
|
422
|
+
{
|
423
|
+
raise_rb_exception(makeAny(e));
|
424
|
+
}
|
425
|
+
catch (com::sun::star::script::CannotConvertException &e)
|
426
|
+
{
|
427
|
+
raise_rb_exception(makeAny(e));
|
428
|
+
}
|
429
|
+
catch (com::sun::star::reflection::InvocationTargetException &e)
|
430
|
+
{
|
431
|
+
com::sun::star::uno::Exception ex;
|
432
|
+
e.TargetException >>= ex;
|
433
|
+
raise_rb_exception(e.TargetException);
|
434
|
+
}
|
435
|
+
catch (RuntimeException &e)
|
436
|
+
{
|
437
|
+
raise_rb_exception(makeAny(e));
|
438
|
+
}
|
439
|
+
return ret;
|
440
|
+
}
|
441
|
+
|
442
|
+
|
443
|
+
VALUE
|
444
|
+
proxy_call_method(VALUE *self, RubyunoInternal *rubyuno, VALUE *name, OUString methodName, VALUE &args)
|
445
|
+
{
|
446
|
+
VALUE ret;
|
447
|
+
Sequence< short > aOutParamIndex;
|
448
|
+
Sequence< Any > aParams;
|
449
|
+
Sequence< Any > aOutParams;
|
450
|
+
Sequence< Type > aParamTypes;
|
451
|
+
Any anyParams;
|
452
|
+
Any outParams;
|
453
|
+
Any retValue;
|
454
|
+
try
|
455
|
+
{
|
456
|
+
Runtime runtime;
|
457
|
+
anyParams = runtime.value_to_any(args);
|
458
|
+
if (anyParams.getValueTypeClass() == com::sun::star::uno::TypeClass_SEQUENCE)
|
459
|
+
{
|
460
|
+
anyParams >>= aParams;
|
461
|
+
}
|
462
|
+
else
|
463
|
+
{
|
464
|
+
aParams.realloc(1);
|
465
|
+
aParams[0] <<= anyParams;
|
466
|
+
}
|
467
|
+
retValue = rubyuno->invocation->invoke(methodName, aParams, aOutParamIndex, aOutParams);
|
468
|
+
|
469
|
+
VALUE tmp = runtime.any_to_VALUE(retValue);
|
470
|
+
if (aOutParams.getLength())
|
471
|
+
{
|
472
|
+
VALUE ret_array = rb_ary_new2(aOutParams.getLength() +1);
|
473
|
+
rb_ary_push(ret_array, tmp);
|
474
|
+
for (int i = 0; i < aOutParams.getLength(); i++)
|
475
|
+
{
|
476
|
+
rb_ary_push(ret_array, runtime.any_to_VALUE(aOutParams[i]));
|
477
|
+
}
|
478
|
+
ret = ret_array;
|
479
|
+
} else {
|
480
|
+
ret = tmp;
|
481
|
+
}
|
482
|
+
return ret;
|
483
|
+
}
|
484
|
+
catch (com::sun::star::reflection::InvocationTargetException &e)
|
485
|
+
{
|
486
|
+
com::sun::star::uno::Exception ex;
|
487
|
+
e.TargetException >>= ex;
|
488
|
+
raise_rb_exception(e.TargetException);
|
489
|
+
}
|
490
|
+
catch (com::sun::star::lang::IllegalArgumentException &e)
|
491
|
+
{
|
492
|
+
raise_rb_exception(makeAny(e));
|
493
|
+
}
|
494
|
+
catch (com::sun::star::script::CannotConvertException &e)
|
495
|
+
{
|
496
|
+
raise_rb_exception(makeAny(e));
|
497
|
+
}
|
498
|
+
catch (RuntimeException &e)
|
499
|
+
{
|
500
|
+
raise_rb_exception(makeAny(e));
|
501
|
+
}
|
502
|
+
return Qnil;
|
503
|
+
}
|
504
|
+
|
505
|
+
|
506
|
+
static VALUE
|
507
|
+
proxy_method_call(VALUE name_symbol, VALUE *args, VALUE self)
|
508
|
+
{
|
509
|
+
VALUE name;
|
510
|
+
OUString methodName;
|
511
|
+
Check_Type(name_symbol, T_SYMBOL);
|
512
|
+
#ifdef RUBY_RUBY_H
|
513
|
+
name = rb_id2str(rb_to_id(name_symbol));
|
514
|
+
#else
|
515
|
+
name = rb_str_new2(rb_id2name(rb_to_id(name_symbol)));
|
516
|
+
#endif
|
517
|
+
methodName = asciiVALUE2OUString(name);
|
518
|
+
|
519
|
+
RubyunoInternal *rubyuno;
|
520
|
+
Data_Get_Struct(self, RubyunoInternal, rubyuno);
|
521
|
+
|
522
|
+
if (methodName.endsWithAsciiL("=", 1))
|
523
|
+
{
|
524
|
+
OUString propertyName(methodName.copy(0, methodName.getLength() - 1));
|
525
|
+
if (rubyuno->invocation->hasProperty(propertyName))
|
526
|
+
return proxy_attr(&self, rubyuno, &name, propertyName, *args, 1);
|
527
|
+
}
|
528
|
+
else
|
529
|
+
{
|
530
|
+
if (rubyuno->invocation->hasMethod(methodName))
|
531
|
+
{
|
532
|
+
return proxy_call_method(&self, rubyuno, &name, methodName, *args);
|
533
|
+
}
|
534
|
+
else if (rubyuno->invocation->hasProperty(methodName))
|
535
|
+
{
|
536
|
+
return proxy_attr(&self, rubyuno, &name, methodName, *args, 0);
|
537
|
+
}
|
538
|
+
}
|
539
|
+
rb_raise(rb_eNameError, "unknown method `%s'", RSTRING_PTR(name));
|
540
|
+
return Qnil;
|
541
|
+
}
|
542
|
+
|
543
|
+
|
544
|
+
static VALUE
|
545
|
+
rubyuno_proxy_method_missing(int argc, VALUE *argv, VALUE self)
|
546
|
+
{
|
547
|
+
if (argc >= 1)
|
548
|
+
{
|
549
|
+
rb_secure(2);
|
550
|
+
|
551
|
+
VALUE name_symbol, args;
|
552
|
+
// get method symbol
|
553
|
+
rb_scan_args(argc, argv, "1*", &name_symbol, &args);
|
554
|
+
|
555
|
+
return proxy_method_call(name_symbol, &args, self);
|
556
|
+
}
|
557
|
+
rb_raise(rb_eRuntimeError, "unknown error");
|
558
|
+
return Qnil;
|
559
|
+
}
|
560
|
+
|
561
|
+
#ifdef HAVE_RUBY_RUBY_H
|
562
|
+
static VALUE
|
563
|
+
to_symbol(VALUE str, ID intern, int argc, VALUE *argv)
|
564
|
+
{
|
565
|
+
return rb_funcall(str, intern, 0);
|
566
|
+
}
|
567
|
+
#endif
|
568
|
+
|
569
|
+
static VALUE
|
570
|
+
rubyuno_uno_methods(VALUE self)
|
571
|
+
{
|
572
|
+
RubyunoInternal *rubyuno;
|
573
|
+
Data_Get_Struct(self, RubyunoInternal, rubyuno);
|
574
|
+
if (!rubyuno)
|
575
|
+
rb_raise(rb_eRuntimeError, "illegal instance (%s)", rb_obj_classname(self));
|
576
|
+
|
577
|
+
VALUE names, assignment;
|
578
|
+
assignment = rb_str_new("=", 1);
|
579
|
+
Reference< XInvocation2 > xInv = rubyuno->invocation;
|
580
|
+
Sequence< InvocationInfo > infos = xInv->getInfo();
|
581
|
+
|
582
|
+
names = rb_ary_new2((int)infos.getLength());
|
583
|
+
|
584
|
+
for (int i = 0; i < (int)infos.getLength(); i++)
|
585
|
+
{
|
586
|
+
if (infos[i].eMemberType == MemberType_METHOD)
|
587
|
+
{
|
588
|
+
rb_ary_push(names, asciiOUString2VALUE(infos[i].aName));
|
589
|
+
}
|
590
|
+
else if (infos[i].eMemberType == MemberType_PROPERTY)
|
591
|
+
{
|
592
|
+
if (infos[i].PropertyAttribute & PropertyAttribute::READONLY)
|
593
|
+
{
|
594
|
+
rb_ary_push(names, asciiOUString2VALUE(infos[i].aName));
|
595
|
+
}
|
596
|
+
else
|
597
|
+
{
|
598
|
+
rb_ary_push(names, asciiOUString2VALUE(infos[i].aName));
|
599
|
+
rb_ary_push(names, rb_str_cat(asciiOUString2VALUE(infos[i].aName), "=", 1));
|
600
|
+
}
|
601
|
+
}
|
602
|
+
else
|
603
|
+
{
|
604
|
+
rb_ary_push(names, asciiOUString2VALUE(infos[i].aName));
|
605
|
+
}
|
606
|
+
}
|
607
|
+
#ifdef HAVE_RUBY_RUBY_H
|
608
|
+
ID intern = rb_intern("intern");
|
609
|
+
rb_block_call(names, rb_intern("map!"), 0, 0, (VALUE(*)(...))to_symbol, intern);
|
610
|
+
return names;
|
611
|
+
#else
|
612
|
+
return names;
|
613
|
+
#endif
|
614
|
+
}
|
615
|
+
|
616
|
+
|
617
|
+
static VALUE
|
618
|
+
rubyuno_proxy_equal(VALUE self, VALUE object)
|
619
|
+
{
|
620
|
+
if (CLASS_OF(object) != get_proxy_class())
|
621
|
+
return Qfalse;
|
622
|
+
|
623
|
+
RubyunoInternal *self_rubyuno, *object_rubyuno;
|
624
|
+
Data_Get_Struct(self, RubyunoInternal, self_rubyuno);
|
625
|
+
Data_Get_Struct(object, RubyunoInternal, object_rubyuno);
|
626
|
+
|
627
|
+
if (self_rubyuno && object_rubyuno)
|
628
|
+
{
|
629
|
+
if (self_rubyuno->wrapped == object_rubyuno->wrapped)
|
630
|
+
return Qtrue;
|
631
|
+
}
|
632
|
+
return Qfalse;
|
633
|
+
}
|
634
|
+
|
635
|
+
static VALUE
|
636
|
+
rubyuno_proxy_inspect(VALUE self)
|
637
|
+
{
|
638
|
+
RubyunoInternal *rubyuno;
|
639
|
+
Data_Get_Struct(self, RubyunoInternal, rubyuno);
|
640
|
+
if (rubyuno)
|
641
|
+
{
|
642
|
+
OUStringBuffer buf;
|
643
|
+
buf.appendAscii(RTL_CONSTASCII_STRINGPARAM("#<Rubyuno::RubyunoProxy:"));
|
644
|
+
buf.append(rubyuno->wrapped.getValueType().getTypeName());
|
645
|
+
buf.appendAscii(RTL_CONSTASCII_STRINGPARAM(":"));
|
646
|
+
VALUE str;
|
647
|
+
#ifdef RUBY_RUBY_H
|
648
|
+
str = rb_sprintf("%p", (void*)self);
|
649
|
+
#else
|
650
|
+
size_t len;
|
651
|
+
len = 16;
|
652
|
+
str = rb_str_new(0, len);
|
653
|
+
snprintf(RSTRING_PTR(str), len, "0x%lx", self);
|
654
|
+
#endif
|
655
|
+
buf.append(rbString2OUString(str));
|
656
|
+
buf.appendAscii(RTL_CONSTASCII_STRINGPARAM(">"));
|
657
|
+
return ustring2RString(buf.makeStringAndClear());
|
658
|
+
}
|
659
|
+
rb_raise(rb_eRuntimeError, "uninitializezd RubyunoProxy.");
|
660
|
+
return Qnil;
|
661
|
+
}
|
662
|
+
|
663
|
+
/*
|
664
|
+
* Check the UNO object implements specific interface.
|
665
|
+
*/
|
666
|
+
static VALUE
|
667
|
+
rubyuno_proxy_has_interface(VALUE self, VALUE name)
|
668
|
+
{
|
669
|
+
StringValue(name);
|
670
|
+
|
671
|
+
RubyunoInternal *rubyuno;
|
672
|
+
Data_Get_Struct(self, RubyunoInternal, rubyuno);
|
673
|
+
if (rubyuno)
|
674
|
+
{
|
675
|
+
Runtime runtime;
|
676
|
+
OUString typeName;
|
677
|
+
|
678
|
+
typeName = rbString2OUString(name);
|
679
|
+
Reference < XInterface > xInterface = *(Reference < XInterface >*) rubyuno->wrapped.getValue();
|
680
|
+
Reference< XIdlClass > xIdlClass = runtime.getImpl()->xCoreReflection->forName(typeName);
|
681
|
+
|
682
|
+
if (xIdlClass.is())
|
683
|
+
{
|
684
|
+
OUString className = xIdlClass->getName();
|
685
|
+
Type classType(xIdlClass->getTypeClass(), className.getStr());
|
686
|
+
|
687
|
+
if (xInterface->queryInterface(classType).hasValue())
|
688
|
+
return Qtrue;
|
689
|
+
}
|
690
|
+
}
|
691
|
+
return Qfalse;
|
692
|
+
}
|
693
|
+
|
694
|
+
/*
|
695
|
+
* Call method of the object with arguments.
|
696
|
+
*
|
697
|
+
*/
|
698
|
+
static VALUE
|
699
|
+
rubyuno_invoke(VALUE self, VALUE object, VALUE name, VALUE args)
|
700
|
+
{
|
701
|
+
if (! (rb_obj_is_kind_of(object, get_proxy_class()) ||
|
702
|
+
rb_obj_is_kind_of(object, get_struct_class()) ||
|
703
|
+
rb_obj_is_kind_of(object, get_exception_class())) )
|
704
|
+
rb_raise(rb_eArgError, "invalid object for source to invoke the function");
|
705
|
+
|
706
|
+
Check_Type(name, T_STRING);
|
707
|
+
Check_Type(args, T_ARRAY);
|
708
|
+
#ifdef HAVE_RUBY_RUBY_H
|
709
|
+
return proxy_method_call(ID2SYM(rb_intern_str(name)), &args, object);
|
710
|
+
#else
|
711
|
+
return proxy_method_call(ID2SYM(rb_intern(RSTRING_PTR(name))), &args, object);
|
712
|
+
#endif
|
713
|
+
}
|
714
|
+
|
715
|
+
|
716
|
+
static VALUE
|
717
|
+
rubyuno_struct_alloc(VALUE klass)
|
718
|
+
{
|
719
|
+
RubyunoInternal *rubyuno;
|
720
|
+
rubyuno = new RubyunoInternal();
|
721
|
+
return Data_Wrap_Struct(klass, 0, rubyuno_proxy_free, rubyuno);
|
722
|
+
}
|
723
|
+
|
724
|
+
|
725
|
+
/*
|
726
|
+
* Fill struct fields according to initial value.
|
727
|
+
*/
|
728
|
+
sal_Int32 fill_struct(const typelib_CompoundTypeDescription *pCompType, VALUE *args, Reference< XInvocation2 > xInvocation, Runtime &runtime)
|
729
|
+
{
|
730
|
+
sal_Int32 nIndex = 0;
|
731
|
+
if (pCompType->pBaseTypeDescription)
|
732
|
+
nIndex = fill_struct(pCompType->pBaseTypeDescription, args, xInvocation, runtime);
|
733
|
+
|
734
|
+
sal_Int32 nLength = RARRAY_LEN(*args);
|
735
|
+
|
736
|
+
int i;
|
737
|
+
for (i = 0; i < pCompType->nMembers; i++)
|
738
|
+
{
|
739
|
+
if (i + nIndex >= nLength)
|
740
|
+
{
|
741
|
+
rb_raise(rb_eArgError, "too few arguments (%d for %d)", (int)nLength, (int)(nIndex + pCompType->nMembers));
|
742
|
+
}
|
743
|
+
VALUE item = rb_ary_entry(*args, i);
|
744
|
+
Any a = runtime.value_to_any(item);
|
745
|
+
xInvocation->setValue(pCompType->ppMemberNames[i], a);
|
746
|
+
}
|
747
|
+
|
748
|
+
return i + nIndex;
|
749
|
+
}
|
750
|
+
|
751
|
+
/*
|
752
|
+
* for structs inherits RubyunoStruct.
|
753
|
+
*/
|
754
|
+
static VALUE
|
755
|
+
rubyuno_struct_initialize(int argc, VALUE *argv, VALUE self)
|
756
|
+
{
|
757
|
+
VALUE klass, type_name;
|
758
|
+
ID id = rb_intern("TYPENAME");
|
759
|
+
klass = CLASS_OF(self);
|
760
|
+
if (!rb_const_defined(klass, id))
|
761
|
+
rb_raise(rb_eRuntimeError, "wrongly initialized class `%s', type_name is not specified", rb_obj_classname(klass));
|
762
|
+
type_name = rb_const_get(klass, id);
|
763
|
+
|
764
|
+
Runtime runtime;
|
765
|
+
Any aStruct;
|
766
|
+
OUString typeName = rbString2OUString(type_name);
|
767
|
+
Reference< XIdlClass > idlClass(runtime.getImpl()->xCoreReflection->forName(typeName), UNO_QUERY);
|
768
|
+
if (!idlClass.is())
|
769
|
+
rb_raise(rb_eRuntimeError, "unknown type name (%s)", RSTRING_PTR(type_name));
|
770
|
+
idlClass->createObject(aStruct);
|
771
|
+
|
772
|
+
set_rubyuno_struct(aStruct, runtime.getImpl()->xInvocation, self);
|
773
|
+
|
774
|
+
// set initial values
|
775
|
+
if (argc > 1)
|
776
|
+
{
|
777
|
+
VALUE args;
|
778
|
+
rb_scan_args(argc, argv, "*", &args);
|
779
|
+
|
780
|
+
TypeDescription desc(typeName);
|
781
|
+
if (desc.is())
|
782
|
+
{
|
783
|
+
typelib_CompoundTypeDescription *pCompType = (typelib_CompoundTypeDescription *) desc.get();
|
784
|
+
|
785
|
+
RubyunoInternal *rubyuno;
|
786
|
+
Data_Get_Struct(self, RubyunoInternal, rubyuno);
|
787
|
+
fill_struct(pCompType, &args, rubyuno->invocation, runtime);
|
788
|
+
}
|
789
|
+
}
|
790
|
+
return self;
|
791
|
+
}
|
792
|
+
|
793
|
+
static VALUE
|
794
|
+
rubyuno_struct_equal(VALUE self, VALUE object)
|
795
|
+
{
|
796
|
+
if (! (rb_obj_is_kind_of(object, get_struct_class()) ||
|
797
|
+
rb_obj_is_kind_of(object, get_enum_class()) ) )
|
798
|
+
return Qfalse;
|
799
|
+
|
800
|
+
RubyunoInternal *rubyuno_self, *rubyuno_object;
|
801
|
+
Data_Get_Struct(self, RubyunoInternal, rubyuno_self);
|
802
|
+
Data_Get_Struct(object, RubyunoInternal, rubyuno_object);
|
803
|
+
|
804
|
+
Reference< XMaterialHolder > selfMaterial(rubyuno_self->invocation, UNO_QUERY);
|
805
|
+
Reference< XMaterialHolder > objectMaterial(rubyuno_object->invocation, UNO_QUERY);
|
806
|
+
|
807
|
+
if (selfMaterial->getMaterial() == objectMaterial->getMaterial())
|
808
|
+
return Qtrue;
|
809
|
+
return Qfalse;
|
810
|
+
}
|
811
|
+
/*
|
812
|
+
static VALUE
|
813
|
+
rubyuno_exception_alloc(VALUE klass)
|
814
|
+
{
|
815
|
+
return Data_Wrap_Struct(klass, 0, rubyuno_proxy_free, 0);
|
816
|
+
}
|
817
|
+
*/
|
818
|
+
static VALUE
|
819
|
+
rubyuno_exception_initialize(VALUE self, VALUE message)
|
820
|
+
{
|
821
|
+
/*
|
822
|
+
VALUE klass, type_name;
|
823
|
+
ID id = rb_intern("TYPENAME");
|
824
|
+
klass = CLASS_OF(self);
|
825
|
+
if (!rb_const_defined(klass, id))
|
826
|
+
rb_raise(rb_eRuntimeError, "wrongly initialized class `%s', type_name is not specified", rb_obj_classname(klass));
|
827
|
+
|
828
|
+
type_name = rb_const_get(klass, id);
|
829
|
+
Runtime runtime;
|
830
|
+
Any aStruct;
|
831
|
+
OUString typeName = rbString2OUString(type_name);
|
832
|
+
Reference< XIdlClass > idlClass(runtime.getImpl()->xCoreReflection->forName(typeName), UNO_QUERY);
|
833
|
+
|
834
|
+
if (!idlClass.is())
|
835
|
+
rb_raise(rb_eRuntimeError, "unknown type name (%s)", RSTRING_PTR(type_name));
|
836
|
+
idlClass->createObject(aStruct);
|
837
|
+
set_rubyuno_struct(aStruct, runtime.getImpl()->xInvocation, self);
|
838
|
+
|
839
|
+
rb_iv_set(self, "mesg", message);
|
840
|
+
rb_iv_set(self, "bt", Qnil);
|
841
|
+
*/
|
842
|
+
rb_call_super(1, &message);
|
843
|
+
return self;
|
844
|
+
}
|
845
|
+
|
846
|
+
/*
|
847
|
+
* Rubyuno::Enum class
|
848
|
+
*/
|
849
|
+
static VALUE
|
850
|
+
rubyuno_enum_initialize(VALUE self, VALUE type_name, VALUE value)
|
851
|
+
{
|
852
|
+
// check args
|
853
|
+
Check_Type(type_name, T_STRING);
|
854
|
+
Check_Type(value, T_STRING);
|
855
|
+
|
856
|
+
OUString typeName = rbString2OUString(type_name);
|
857
|
+
char *strValue = RSTRING_PTR(value);
|
858
|
+
|
859
|
+
TypeDescription desc(typeName);
|
860
|
+
if (desc.is())
|
861
|
+
{
|
862
|
+
if (desc.get()->eTypeClass != typelib_TypeClass_ENUM)
|
863
|
+
rb_raise(rb_eArgError, "wrong type name (%s)", RSTRING_PTR(type_name));
|
864
|
+
|
865
|
+
desc.makeComplete();
|
866
|
+
|
867
|
+
typelib_EnumTypeDescription *pEnumDesc = (typelib_EnumTypeDescription*) desc.get();
|
868
|
+
int i = 0;
|
869
|
+
for (i = 0; i < pEnumDesc->nEnumValues; i++)
|
870
|
+
{
|
871
|
+
if ((*((OUString*)&pEnumDesc->ppEnumNames[i])).compareToAscii(strValue) == 0)
|
872
|
+
{
|
873
|
+
break;
|
874
|
+
}
|
875
|
+
}
|
876
|
+
if (i == pEnumDesc->nEnumValues)
|
877
|
+
rb_raise(rb_eArgError, "wrong value (%s)", strValue);
|
878
|
+
|
879
|
+
Any a = Any(&pEnumDesc->pEnumValues[i], desc.get()->pWeakRef);
|
880
|
+
RubyunoValue *ptr;
|
881
|
+
Data_Get_Struct(self, RubyunoValue, ptr);
|
882
|
+
ptr->value = a;
|
883
|
+
}
|
884
|
+
else
|
885
|
+
{
|
886
|
+
rb_raise(rb_eArgError, "unknown type name (%s)", RSTRING_PTR(type_name));
|
887
|
+
}
|
888
|
+
|
889
|
+
rb_iv_set(self, "@type_name", type_name);
|
890
|
+
rb_iv_set(self, "@value", value);
|
891
|
+
return self;
|
892
|
+
}
|
893
|
+
|
894
|
+
static VALUE
|
895
|
+
rubyuno_enum_equal(VALUE self, VALUE object)
|
896
|
+
{
|
897
|
+
if (! object == CLASS_OF(get_enum_class()))
|
898
|
+
return Qfalse;
|
899
|
+
ID id = rb_intern("==");
|
900
|
+
VALUE self_type_name, self_value;
|
901
|
+
|
902
|
+
self_type_name = rb_iv_get(self, "@type_name");
|
903
|
+
self_value = rb_iv_get(self, "@value");
|
904
|
+
if (rb_funcall(self_type_name, id, 1, rb_iv_get(object, "@type_name")) &&
|
905
|
+
rb_funcall(self_value, id, 1, rb_iv_get(object, "@value")))
|
906
|
+
return Qtrue;
|
907
|
+
return Qfalse;
|
908
|
+
}
|
909
|
+
|
910
|
+
static VALUE
|
911
|
+
rubyuno_enum_inspect(VALUE self)
|
912
|
+
{
|
913
|
+
VALUE desc, type_name, value;
|
914
|
+
type_name = rb_iv_get(self, "@type_name");
|
915
|
+
value = rb_iv_get(self, "@value");
|
916
|
+
Check_Type(type_name, T_STRING);
|
917
|
+
Check_Type(value, T_STRING);
|
918
|
+
|
919
|
+
desc = rb_tainted_str_new("#<Rubyuno::Enum:", 13);
|
920
|
+
rb_str_cat(desc, RSTRING_PTR(type_name), RSTRING_LEN(type_name));
|
921
|
+
rb_str_cat(desc, ".", 1);
|
922
|
+
rb_str_cat(desc, RSTRING_PTR(value), RSTRING_LEN(value));
|
923
|
+
rb_str_cat(desc, ">", 1);
|
924
|
+
return desc;
|
925
|
+
}
|
926
|
+
|
927
|
+
|
928
|
+
/*
|
929
|
+
* Rubyuno::Type class
|
930
|
+
*/
|
931
|
+
static VALUE
|
932
|
+
rubyuno_type_initialize(int argc, VALUE *argv, VALUE self)
|
933
|
+
{
|
934
|
+
VALUE type_name, type_class;
|
935
|
+
TypeDescription desc;
|
936
|
+
|
937
|
+
if (argc == 1)
|
938
|
+
{
|
939
|
+
VALUE value;
|
940
|
+
rb_scan_args(argc, argv, "1", &value);
|
941
|
+
|
942
|
+
if (TYPE(value) == T_STRING)
|
943
|
+
{
|
944
|
+
type_name = value;
|
945
|
+
|
946
|
+
OUString typeName = rbString2OUString(type_name);
|
947
|
+
desc = TypeDescription(typeName);
|
948
|
+
if (!desc.is())
|
949
|
+
rb_raise(rb_eArgError, "wrong type name (%s)", RSTRING_PTR(type_name));
|
950
|
+
|
951
|
+
Runtime runtime;
|
952
|
+
type_class = runtime.any_to_VALUE(Any((com::sun::star::uno::TypeClass)desc.get()->eTypeClass));
|
953
|
+
}
|
954
|
+
else if (CLASS_OF(value) == get_enum_class())
|
955
|
+
{
|
956
|
+
type_class = value;
|
957
|
+
VALUE enum_type_name = rb_iv_get(type_class, "@type_name");
|
958
|
+
|
959
|
+
if (strcmp(RSTRING_PTR(enum_type_name), "com.sun.star.uno.TypeClass"))
|
960
|
+
rb_raise(rb_eArgError, "invalid enum (%s)", RSTRING_PTR(value));
|
961
|
+
|
962
|
+
type_name = rb_iv_get(type_class, "@value");
|
963
|
+
OUString typeName = rbString2OUString(type_name);
|
964
|
+
desc = TypeDescription(typeName.toAsciiLowerCase());
|
965
|
+
if (!desc.is())
|
966
|
+
rb_raise(rb_eRuntimeError, "wrong enum value (%s)", RSTRING_PTR(type_name));
|
967
|
+
}
|
968
|
+
else
|
969
|
+
rb_raise(rb_eArgError, "wrong type (%s for String or Rubyuno::Enum)", rb_obj_classname(value));
|
970
|
+
}
|
971
|
+
else if (argc == 2)
|
972
|
+
{
|
973
|
+
rb_scan_args(argc, argv, "11", &type_name, &type_class);
|
974
|
+
|
975
|
+
Check_Type(type_name, T_STRING);
|
976
|
+
if (! CLASS_OF(type_class) == get_enum_class())
|
977
|
+
rb_raise(rb_eArgError, "Rubyuno::Enum is desired for 2nd argument.");
|
978
|
+
|
979
|
+
RubyunoValue *value;
|
980
|
+
Data_Get_Struct(type_class, RubyunoValue, value);
|
981
|
+
Any enumValue = value->value;
|
982
|
+
OUString typeName = rbString2OUString(type_name);
|
983
|
+
desc = TypeDescription(typeName);
|
984
|
+
if (!desc.is())
|
985
|
+
rb_raise(rb_eArgError, "wrong type name (%s)", RSTRING_PTR(type_name));
|
986
|
+
if (desc.get()->eTypeClass != (typelib_TypeClass)* (sal_Int32*)enumValue.getValue())
|
987
|
+
rb_raise(rb_eArgError, "nomatch with type name (%s)", RSTRING_PTR(type_name));
|
988
|
+
}
|
989
|
+
else
|
990
|
+
rb_raise(rb_eArgError, "too much arguments (%d for maximum 2)", argc);
|
991
|
+
|
992
|
+
|
993
|
+
Type t = desc.get()->pWeakRef;
|
994
|
+
Any a;
|
995
|
+
a <<= t;
|
996
|
+
RubyunoValue *rubyuno;
|
997
|
+
Data_Get_Struct(self, RubyunoValue, rubyuno);
|
998
|
+
rubyuno->value = a;
|
999
|
+
|
1000
|
+
rb_iv_set(self, "@type_name", type_name);
|
1001
|
+
rb_iv_set(self, "@type_class", type_class);
|
1002
|
+
return self;
|
1003
|
+
}
|
1004
|
+
|
1005
|
+
static VALUE
|
1006
|
+
rubyuno_type_equal(VALUE self, VALUE object)
|
1007
|
+
{
|
1008
|
+
if (! object == CLASS_OF(get_type_class()))
|
1009
|
+
return Qfalse;
|
1010
|
+
|
1011
|
+
ID id = rb_intern("==");
|
1012
|
+
VALUE type_name, type_class;
|
1013
|
+
type_name = rb_iv_get(self, "@type_name");
|
1014
|
+
type_class = rb_iv_get(self, "@type_class");
|
1015
|
+
if (rb_funcall(self, id, 1, rb_iv_get(object, "@type_name")) &&
|
1016
|
+
rb_funcall(self, id, 1, rb_iv_get(object, "@type_class")))
|
1017
|
+
return Qtrue;
|
1018
|
+
|
1019
|
+
return Qfalse;
|
1020
|
+
}
|
1021
|
+
|
1022
|
+
static VALUE
|
1023
|
+
rubyuno_type_inspect(VALUE self)
|
1024
|
+
{
|
1025
|
+
VALUE desc, type_name, type_class, value;
|
1026
|
+
type_name = rb_iv_get(self, "@type_name");
|
1027
|
+
type_class = rb_iv_get(self, "@type_class");
|
1028
|
+
Check_Type(type_name, T_STRING);
|
1029
|
+
if (!CLASS_OF(type_class) == get_enum_class())
|
1030
|
+
{
|
1031
|
+
rb_raise(rb_eRuntimeError, "unknown value for type_class (%s for Rubyuno::RubyunoEnum)", rb_obj_classname(type_class));
|
1032
|
+
}
|
1033
|
+
value = rb_iv_get(type_class, "@value");
|
1034
|
+
|
1035
|
+
desc = rb_tainted_str_new("#<Rubyuno::Type:", 13);
|
1036
|
+
rb_str_cat(desc, RSTRING_PTR(type_name), RSTRING_LEN(type_name));
|
1037
|
+
rb_str_cat(desc, "(", 1);
|
1038
|
+
rb_str_cat(desc, RSTRING_PTR(value), RSTRING_LEN(value));
|
1039
|
+
rb_str_cat(desc, ")>", 2);
|
1040
|
+
return desc;
|
1041
|
+
}
|
1042
|
+
|
1043
|
+
/*
|
1044
|
+
* Rubyuno::Char class
|
1045
|
+
*/
|
1046
|
+
static VALUE
|
1047
|
+
rubyuno_char_initialize(VALUE self, VALUE char_value)
|
1048
|
+
{
|
1049
|
+
Check_Type(char_value, T_STRING);
|
1050
|
+
if (RSTRING_LEN(char_value) != 1)
|
1051
|
+
{
|
1052
|
+
rb_raise(rb_eArgError, "wrong length (%ld for 1)", RSTRING_LEN(char_value));
|
1053
|
+
}
|
1054
|
+
sal_Unicode c = rbString2OUString(char_value).toChar();
|
1055
|
+
Any a;
|
1056
|
+
a.setValue(&c, getCharCppuType());
|
1057
|
+
RubyunoValue *rubyuno;
|
1058
|
+
Data_Get_Struct(self, RubyunoValue, rubyuno);
|
1059
|
+
rubyuno->value = a;
|
1060
|
+
|
1061
|
+
rb_iv_set(self, "@value", char_value);
|
1062
|
+
return self;
|
1063
|
+
}
|
1064
|
+
|
1065
|
+
static VALUE
|
1066
|
+
rubyuno_char_equal(VALUE self, VALUE object)
|
1067
|
+
{
|
1068
|
+
if (!(CLASS_OF(object) == get_char_class() ||
|
1069
|
+
TYPE(object) == T_STRING))
|
1070
|
+
return Qfalse;
|
1071
|
+
|
1072
|
+
ID id = rb_intern("==");
|
1073
|
+
if (rb_funcall(object, id, 1, rb_iv_get(self, "@value")))
|
1074
|
+
return Qtrue;
|
1075
|
+
|
1076
|
+
return Qfalse;
|
1077
|
+
}
|
1078
|
+
|
1079
|
+
static VALUE
|
1080
|
+
rubyuno_char_inspect(VALUE self)
|
1081
|
+
{
|
1082
|
+
VALUE desc, value;
|
1083
|
+
value = rb_iv_get(self, "@value");
|
1084
|
+
Check_Type(value, T_STRING);
|
1085
|
+
|
1086
|
+
desc = rb_tainted_str_new("#<Rubyuno::Char:", 13);
|
1087
|
+
rb_str_cat(desc, RSTRING_PTR(value), RSTRING_LEN(value));
|
1088
|
+
rb_str_cat(desc, ">", 1);
|
1089
|
+
return desc;
|
1090
|
+
}
|
1091
|
+
|
1092
|
+
|
1093
|
+
static VALUE
|
1094
|
+
rubyuno_any_alloc(VALUE klass)
|
1095
|
+
{
|
1096
|
+
return Data_Wrap_Struct(klass, 0, 0, 0);
|
1097
|
+
}
|
1098
|
+
|
1099
|
+
/*
|
1100
|
+
* Rubyuno::Any class
|
1101
|
+
* Any class is not well processed at the constructing time.
|
1102
|
+
*/
|
1103
|
+
static VALUE
|
1104
|
+
rubyuno_any_initialize(VALUE self, VALUE type, VALUE value)
|
1105
|
+
{
|
1106
|
+
if (rb_obj_is_kind_of(type, get_type_class()))
|
1107
|
+
{
|
1108
|
+
rb_iv_set(self, "@type", type);
|
1109
|
+
}
|
1110
|
+
else if (TYPE(type) == T_STRING)
|
1111
|
+
{
|
1112
|
+
VALUE type_value;
|
1113
|
+
type_value = rb_funcall(get_type_class(), rb_intern("new"), 1, type);
|
1114
|
+
rb_iv_set(self, "@type", type_value);
|
1115
|
+
}
|
1116
|
+
else
|
1117
|
+
{
|
1118
|
+
rb_raise(rb_eArgError, "invalid type for type.");
|
1119
|
+
}
|
1120
|
+
rb_iv_set(self, "@value", value);
|
1121
|
+
|
1122
|
+
return self;
|
1123
|
+
}
|
1124
|
+
|
1125
|
+
static VALUE
|
1126
|
+
rubyuno_any_equal(VALUE self, VALUE object)
|
1127
|
+
{
|
1128
|
+
if (! CLASS_OF(self) == get_any_class())
|
1129
|
+
return Qfalse;
|
1130
|
+
|
1131
|
+
ID id = rb_intern("==");
|
1132
|
+
VALUE type, value;
|
1133
|
+
type = rb_iv_get(self, "@type");
|
1134
|
+
value = rb_iv_get(self, "@value");
|
1135
|
+
|
1136
|
+
if (rb_funcall(type, id, 1, rb_iv_get(object, "@type")) &&
|
1137
|
+
rb_funcall(value, id, 1, rb_iv_get(object, "@value")))
|
1138
|
+
return Qtrue;
|
1139
|
+
|
1140
|
+
return Qfalse;
|
1141
|
+
}
|
1142
|
+
|
1143
|
+
|
1144
|
+
static void
|
1145
|
+
rubyuno_value_free(RubyunoValue *rubyuno)
|
1146
|
+
{
|
1147
|
+
if (rubyuno)
|
1148
|
+
{
|
1149
|
+
rubyuno->value.clear();
|
1150
|
+
delete rubyuno;
|
1151
|
+
}
|
1152
|
+
}
|
1153
|
+
|
1154
|
+
static VALUE
|
1155
|
+
rubyuno_value_alloc(VALUE klass)
|
1156
|
+
{
|
1157
|
+
RubyunoValue *ptr;
|
1158
|
+
ptr = new RubyunoValue();
|
1159
|
+
return Data_Wrap_Struct(klass, 0, rubyuno_value_free, ptr);
|
1160
|
+
}
|
1161
|
+
|
1162
|
+
}
|
1163
|
+
|
1164
|
+
extern "C"
|
1165
|
+
{
|
1166
|
+
void
|
1167
|
+
Init_rubyuno(void)
|
1168
|
+
{
|
1169
|
+
VALUE Rubyuno;
|
1170
|
+
Rubyuno = rb_define_module("Rubyuno");
|
1171
|
+
rb_define_module_function(Rubyuno, "get_component_context", (VALUE(*)(...))rubyuno_getComponentContext, 0);
|
1172
|
+
rb_define_module_function(Rubyuno, "system_path_to_file_url", (VALUE(*)(...))rubyuno_getFileURLFromSystemPath, 1);
|
1173
|
+
rb_define_module_function(Rubyuno, "file_url_to_system_path", (VALUE(*)(...))rubyuno_getSystemPathFromFileURL, 1);
|
1174
|
+
rb_define_module_function(Rubyuno, "absolutize", (VALUE(*)(...))rubyuno_absolutize, 2);
|
1175
|
+
rb_define_module_function(Rubyuno, "uuid", (VALUE(*)(...))rubyuno_create_uuid, 0);
|
1176
|
+
rb_define_module_function(Rubyuno, "uno_require", (VALUE(*)(...))rubyuno_uno_multiple_require, -1);
|
1177
|
+
rb_define_module_function(Rubyuno, "invoke", (VALUE(*)(...))rubyuno_invoke, 3);
|
1178
|
+
|
1179
|
+
VALUE RubyunoProxy;
|
1180
|
+
RubyunoProxy = rb_define_class_under(Rubyuno, "RubyunoProxy", rb_cData);
|
1181
|
+
rb_define_alloc_func(RubyunoProxy, rubyuno_proxy_alloc);
|
1182
|
+
rb_define_method(RubyunoProxy, "method_missing", (VALUE(*)(...))rubyuno_proxy_method_missing, -1);
|
1183
|
+
rb_define_method(RubyunoProxy, "inspect", (VALUE(*)(...))rubyuno_proxy_inspect, 0);
|
1184
|
+
rb_define_method(RubyunoProxy, "==", (VALUE(*)(...))rubyuno_proxy_equal, 1);
|
1185
|
+
rb_define_method(RubyunoProxy, "uno_methods", (VALUE(*)(...))rubyuno_uno_methods, 0);
|
1186
|
+
rb_define_method(RubyunoProxy, "has_interface?", (VALUE(*)(...))rubyuno_proxy_has_interface, 1);
|
1187
|
+
|
1188
|
+
VALUE RubyunoEnum;
|
1189
|
+
RubyunoEnum = rb_define_class_under(Rubyuno, "Enum", rb_cObject);
|
1190
|
+
rb_define_alloc_func(RubyunoEnum, rubyuno_value_alloc);
|
1191
|
+
rb_define_method(RubyunoEnum, "initialize", (VALUE(*)(...))rubyuno_enum_initialize, 2);
|
1192
|
+
rb_define_method(RubyunoEnum, "==", (VALUE(*)(...))rubyuno_enum_equal, 1);
|
1193
|
+
rb_define_attr(RubyunoEnum, "type_name", 1, 0);
|
1194
|
+
rb_define_attr(RubyunoEnum, "value", 1, 0);
|
1195
|
+
rb_define_method(RubyunoEnum, "inspect", (VALUE(*)(...))rubyuno_enum_inspect, 0);
|
1196
|
+
|
1197
|
+
VALUE RubyunoType;
|
1198
|
+
RubyunoType = rb_define_class_under(Rubyuno, "Type", rb_cObject);
|
1199
|
+
rb_define_alloc_func(RubyunoType, rubyuno_value_alloc);
|
1200
|
+
rb_define_method(RubyunoType, "initialize", (VALUE(*)(...))rubyuno_type_initialize, -1);
|
1201
|
+
rb_define_method(RubyunoType, "==", (VALUE(*)(...))rubyuno_type_equal, 1);
|
1202
|
+
rb_define_attr(RubyunoType, "type_name", 1, 0);
|
1203
|
+
rb_define_attr(RubyunoType, "type_class", 1, 0);
|
1204
|
+
rb_define_method(RubyunoType, "inspect", (VALUE(*)(...))rubyuno_type_inspect, 0);
|
1205
|
+
|
1206
|
+
VALUE RubyunoChar;
|
1207
|
+
RubyunoChar = rb_define_class_under(Rubyuno, "Char", rb_cObject);
|
1208
|
+
rb_define_alloc_func(RubyunoChar, rubyuno_value_alloc);
|
1209
|
+
rb_define_method(RubyunoChar, "initialize", (VALUE(*)(...))rubyuno_char_initialize, 1);
|
1210
|
+
rb_define_method(RubyunoChar, "==", (VALUE(*)(...))rubyuno_char_equal, 1);
|
1211
|
+
rb_define_attr(RubyunoChar, "value", 1, 0);
|
1212
|
+
rb_define_method(RubyunoChar, "inspect", (VALUE(*)(...))rubyuno_char_inspect, 0);
|
1213
|
+
|
1214
|
+
VALUE RubyunoAny;
|
1215
|
+
RubyunoAny = rb_define_class_under(Rubyuno, "Any", rb_cObject);
|
1216
|
+
rb_define_alloc_func(RubyunoAny, rubyuno_any_alloc);
|
1217
|
+
rb_define_method(RubyunoAny, "initialize", (VALUE(*)(...))rubyuno_any_initialize, 2);
|
1218
|
+
rb_define_method(RubyunoAny, "==", (VALUE(*)(...))rubyuno_any_equal, 1);
|
1219
|
+
rb_define_attr(RubyunoAny, "type", 1, 1);
|
1220
|
+
rb_define_attr(RubyunoAny, "value", 1, 1);
|
1221
|
+
|
1222
|
+
VALUE RubyunoByteSequence;
|
1223
|
+
RubyunoByteSequence = rb_define_class_under(Rubyuno, "ByteSequence", rb_cString);
|
1224
|
+
|
1225
|
+
VALUE RubyunoStruct;
|
1226
|
+
RubyunoStruct = rb_define_class_under(Rubyuno, "RubyunoStruct", rb_cObject);
|
1227
|
+
rb_define_alloc_func(RubyunoStruct, rubyuno_struct_alloc);
|
1228
|
+
rb_define_method(RubyunoStruct, "initialize", (VALUE(*)(...))rubyuno_struct_initialize, -1);
|
1229
|
+
rb_define_method(RubyunoStruct, "method_missing", (VALUE(*)(...))rubyuno_proxy_method_missing, -1);
|
1230
|
+
rb_define_method(RubyunoStruct, "==", (VALUE(*)(...))rubyuno_struct_equal, 1);
|
1231
|
+
rb_define_method(RubyunoStruct, "uno_methods", (VALUE(*)(...))rubyuno_uno_methods, 0);
|
1232
|
+
|
1233
|
+
VALUE Com, Sun, Star, Uno;
|
1234
|
+
Com = rb_define_module_under(Rubyuno, "Com");
|
1235
|
+
Sun = rb_define_module_under(Com, "Sun");
|
1236
|
+
Star = rb_define_module_under(Sun, "Star");
|
1237
|
+
|
1238
|
+
Uno = rb_define_module_under(Star, "Uno");
|
1239
|
+
|
1240
|
+
VALUE RubyunoException;
|
1241
|
+
RubyunoException = rb_define_class_under(Uno, "Exception", rb_eStandardError);
|
1242
|
+
//rb_define_alloc_func(RubyunoException, rubyuno_struct_alloc);
|
1243
|
+
rb_define_method(RubyunoException, "initialize", (VALUE(*)(...))rubyuno_exception_initialize, 1);
|
1244
|
+
rb_define_method(RubyunoException, "method_missing", (VALUE(*)(...))rubyuno_proxy_method_missing, -1);
|
1245
|
+
rb_define_method(RubyunoException, "==", (VALUE(*)(...))rubyuno_struct_equal, 1);
|
1246
|
+
//rb_define_method(RubyunoException, "uno_methods", (VALUE(*)(...))rubyuno_uno_methods, 0);
|
1247
|
+
//rb_define_attr(RubyunoException, "uno", 1, 1);
|
1248
|
+
|
1249
|
+
/*
|
1250
|
+
VALUE RubyunoException2;
|
1251
|
+
RubyunoException2 = rb_define_class_under(Rubyuno, "Exception", rb_eStandardError);
|
1252
|
+
rb_define_alloc_func(RubyunoException2, rubyuno_struct_alloc);
|
1253
|
+
rb_define_method(RubyunoException2, "initialize", (VALUE(*)(...))rubyuno_exception2_initialize, 1);
|
1254
|
+
*/
|
1255
|
+
|
1256
|
+
VALUE XInterface;
|
1257
|
+
XInterface = rb_define_module_under(Uno, "XInterface");
|
1258
|
+
rb_define_const(XInterface, "TYPENAME", rb_str_new("com.sun.star.uno.XInterface", 27));
|
1259
|
+
|
1260
|
+
init_external_encoding();
|
1261
|
+
}
|
1262
|
+
}
|
1263
|
+
|