-------------------------------------- 2006-07-24 ---------------------------------- - UNO.CLS: - made UNO_CONSTANTS.encode() a little bit more flexible (now an arbitrary mix of constant-field-names and decimal values) -------------------------------------- 2006-07-19 ---------------------------------- - UNO.CLS: - added/changed class UNO_DIRLIKE, UNO_ENUM and UNO_CONSTANTS, which can be treated as directories, if retrieving field-names or their numeric values; UNO_CONSTANTS has in addition the methods ENCODE(blank-delimited-field-names) returning the encoded decimal number; DECODE(decimal number) returning a blank-delimited-filed-names -------------------------------------- 2006-07-17 ---------------------------------- - UNO.CLS: - added UNO.WRAPARRAY which determines whether to wrap up a BSF_ARRAY object as an UNO_ARRAY_PROXY -------------------------------------- 2006-07-16 ---------------------------------- - UNO.CLS: - added UNO_ARRAY_PROXY class; the public routine UNO.CreateArray() which uses BSF.CreateArray(), but wraps it up as an UNO_ARRAY_PROXY (making sure that its elements are wrapped up as UNO_PROXY objects) -------------------------------------- 2006-07-12 ---------------------------------- - UNO.CLS: - uno.setCell() now allows letter-number-coordinates; added routine uno.getCell(xSheet, colNr0, rowNr0) or uno.getCell(xSheet, LetterNumber) returning a XCell object [you can use {g|s}etValue(), {g|s}etFormula(), getError() or getType() with it] -------------------------------------- 2006-07-10 ---------------------------------- - UNO.CLS: - changed "uno.getScriptContext()" and "uno.connect()" to now explicitly supply their XComponentContext to org.oorexx.uno.RgfReflectUNO, which will inhibit that class to use UNO bootstrapping (which would hang the scripting framework); activated fall-back code to use reflection at runtime to query correct interface class -------------------------------------- 2006-06-04 ---------------------------------- - UNO.CLS: fixed a bug in querying an interface object, if unqualified class name is used more than once -------------------------------------- 2006-02-03 ---------------------------------- - changed UNO.CLS to not use RgfReflectUNO as a means of last resort, as at the moment the Java scripting framework of OOo would hang (pertains to versions 1.1.x and 2.0.x); cf. - hint: to easily get at the UNO constant and enumeration values, just wrap up the respective Java class using the new BSF.CLS routine named "bsf.wrapStaticFields(stringJavaClassName)"; just send the names of the constants/enumeration values to the resulting directory object -------------------------------------- 2006-01-24 ---------------------------------- - changed ScriptingFrameword ooRexx support to show Rexx execution errors in a dialog window, considerably easying development of OOo macros -------------------------------------- 2006-01-24 ---------------------------------- - removed the UNO reflection support from the extension jar; created for it "oorexx-uno.jar", which will get copied to OOo/program/classes -------------------------------------- 2006-01-06 ---------------------------------- - removed the public routines pp() and iif(), as they now are made available via the required module "BSF.CLS" - added the public routines uno.getScriptContext() and uno.getScriptContextVersion(); the ooRexx macro "template.rex" adapted (note the change in getting access to the scriptContext compared to earlier beta-versions!): /* Hello World in ooRexx, cf. http://www.ooRexx.org, version: 2006-01-06 */ xScriptContext=uno.getScriptContext() -- get the xScriptContext object oDoc=xScriptContext~getDocument -- get the document service (an XModel object) -- oDesktop=xScriptContext~getDesktop -- get the desktop (an XDesktop object) -- oContext=xScriptContext~getComponentContext -- get the context(an XComponentContext object) xTextDoc=oDoc~XTextDocument -- get the XTextDocument interface from the document hello="Hello World (in ooRexx) " -- define text to add xTextDoc~getText~getEnd~setString(hello) -- add text at the end of the text document ::requires UNO.CLS -- load UNO support for OpenOffice.org -------------------------------------- 2006-01-04 ---------------------------------- - routine - uno.areSame(object1, object2) ... returns true if both objects refer to the same object (passthrough for UnoRuntime.areSame() - additional method for "UNO_PROXY" objects: - uno.isSameO(o) ... returns true if this UNO_PROXY object refers to the same object as the argument object "o" -------------------------------------- 2006-01-03 ---------------------------------- - module "OOO.CLS" was renamed to "UNO.CLS" to reflect that it generically supports the UNO (Universal Network Object) component model on which OOo is built; the definition of UNO objects is carried out in "UNOIDL" (UNO Interface Description Language) and is usually stored in a type repository that is available at runtime for reflection - routines - iif(test, if_true, if_false) ... VBasic like function: if "test" yields .true, then "if_true" is returned, otherwise "if_false" - pp(string) ... returns the string enquoted with square brackets - ppd(string) ... simple "pretty-print for debug": supply any of the UNOIDL blank delimited strings to dump them on stdout in a slightly better ledgible form (breaks the string on the blanks and indents them starting with the second line using a TAB character) - convertToUrl(string) ... converts the fully qualified path to its URL representation as expected by OOo (takes differences between Linux and Windows transparently into account) - convertFromUrl(string) ... converts the URL encoding of a file to a fully qualified path (takes differences between Linux and Windows transparently into account) - encodeURL(string) ... encodes a URL such that non-ASCII-characters are represented with their hex values (led in by percent sign) - decodeURL(string) ... decodes a URL which represents non-ASCII-characters as hex values (led in by percent sign) - uno.wrap(object) ... if possible, the object will be wrapped up as a "UNO_PROXY" which activates the special support for UNO objects (e.g. sending merely the name of an interface in order to get the interface object, etc.) - uno.loadClass(java_class_name[, short_name]) ... imports the UNO Java class "java_class_name" (as an UNO_PROXY) and stores it under the name "short_name" in the directory ".uno"; if "short_name is omitted then the unqualified class name (after the last dot) is used instead - uno.connect(url_string) ... allows connecting to a remote OOo by using the URL according to the OOo documentation; returns a reference to the remote object that you denoted in the "url_string" - uno.createDesktop([context]) ... creates and returns the reference to the OOo desktop object of the supplied "context" (could be any OOo server); if "context" is omitted, then the local OOo is used (ie. OOo installed on the machine the program runs on; no need to define ports explicitly) - uno.setCell(xSheet, x, y, value) ... simple utility routine: inserts "value" (number, text or formula) at the 0-based co-ordinates "x" and "y" in the spreadsheet-object "xSheet" - additional methods for "UNO_PROXY" objects: - uno.findInterfaceWithMember(name, [bReturnString [, howMany]]) ... returns the interface that contains a method or attribute by the given "name"; if "bReturnString" is .true (default), then the fully qualified UNOIDL string of the interface is returned, otherwise the interface object itself; "howMany" determines how many matches should be attempted, if a negative number, then all matching interfaces with all matching members are returned - uno.getDefinition ... returns a blank delimited string containing all UNOIDL members of the object - uno.getInterfaceNamesViaReflection ... returns a blank delimited string containing all interfaces defined in the repository (if available) for this object - uno.getProperties ... returns a blank delimited string denoting all properties of this object - uno.getServiceNamesViaReflection ... returns a blank delimited string containing all services defined in the repository (if available) for this object - uno.getTypeName ... returns a string denominating the type of the object - uno.getXTypeProviderTypeNames ... returns a blank delimited string containing all interfaces the object reports - uno.queryInterfaceName(name) ... returns a string denominating the fully qualified UNOIDL name of the interface for this object; "name" may be partially given - uno.queryInterfaceObjectByName(name) ... returns the interface object (or .nil if not available) of the interface that ends with "name" - uno.queryServiceName(name) ... returns a string denominating the fully qualified UNOIDL name of the service this object implements; "name" may be partially given - additional routines for analyzing OOo definitions, the first argument (named "o" below) can be OOO proxy objects or strings that fully qualify definition objects in the OOo type repository; as there functionality is exactly the same as the methods above, only the signatures are given: - uno.findInterfaceWithMember public(o, name[, bReturnString [, howMany]]) - uno.getDefinition(o) - uno.getInterfaceNamesViaReflection(o) - uno.getProperties(o) - uno.getServiceNamesViaReflection(o) - uno.getTypeName(o) - uno.getXTypeProviderTypeNames(o) - uno.queryInterfaceName(o, name) - uno.queryInterfaceObjectByName(o, name) - uno.queryServiceName(o, name) ---rgf