Adding upstream version 1:7.0.4.upstream/1%7.0.4upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 643 insertions, 0 deletions

diff --git a/odk/examples/java/Inspector/Introspector.java b/odk/examples/java/Inspector/Introspector.java
new file mode 100644
index 000000000..b8d3be3c0
--- /dev/null
+++ b/odk/examples/java/Inspector/Introspector.java
@@ -0,0 +1,643 @@
+/* -*- Mode: Java; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*************************************************************************
+ *
+ *  The Contents of this file are made available subject to the terms of
+ *  the BSD license.
+ *
+ *  Copyright 2000, 2010 Oracle and/or its affiliates.
+ *  All rights reserved.
+ *
+ *  Redistribution and use in source and binary forms, with or without
+ *  modification, are permitted provided that the following conditions
+ *  are met:
+ *  1. Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *  2. Redistributions in binary form must reproduce the above copyright
+ *     notice, this list of conditions and the following disclaimer in the
+ *     documentation and/or other materials provided with the distribution.
+ *  3. Neither the name of Sun Microsystems, Inc. nor the names of its
+ *     contributors may be used to endorse or promote products derived
+ *     from this software without specific prior written permission.
+ *
+ *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ *  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ *  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+ *  FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+ *  COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ *  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+ *  BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
+ *  OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ *  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
+ *  TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
+ *  USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ *************************************************************************/
+
+import java.util.ArrayList;
+import java.util.List;
+
+import com.sun.star.beans.IllegalTypeException;
+import com.sun.star.beans.MethodConcept;
+import com.sun.star.beans.Property;
+import com.sun.star.beans.XIntrospection;
+import com.sun.star.beans.XIntrospectionAccess;
+import com.sun.star.container.XEnumeration;
+import com.sun.star.container.XEnumerationAccess;
+import com.sun.star.container.XHierarchicalNameAccess;
+import com.sun.star.container.XIndexAccess;
+import com.sun.star.lang.XMultiComponentFactory;
+import com.sun.star.lang.XServiceInfo;
+import com.sun.star.lang.XTypeProvider;
+import com.sun.star.lib.uno.helper.WeakBase;
+import com.sun.star.reflection.TypeDescriptionSearchDepth;
+import com.sun.star.reflection.XConstantTypeDescription;
+import com.sun.star.reflection.XConstantsTypeDescription;
+import com.sun.star.reflection.XIdlClass;
+import com.sun.star.reflection.XIdlMethod;
+import com.sun.star.reflection.XIdlReflection;
+import com.sun.star.reflection.XIndirectTypeDescription;
+import com.sun.star.reflection.XInterfaceTypeDescription;
+import com.sun.star.reflection.XPropertyTypeDescription;
+import com.sun.star.reflection.XServiceTypeDescription;
+import com.sun.star.reflection.XTypeDescription;
+import com.sun.star.reflection.XTypeDescriptionEnumeration;
+import com.sun.star.reflection.XTypeDescriptionEnumerationAccess;
+import com.sun.star.ucb.XSimpleFileAccess;
+import com.sun.star.uno.AnyConverter;
+import com.sun.star.uno.Type;
+import com.sun.star.uno.TypeClass;
+import com.sun.star.uno.UnoRuntime;
+import com.sun.star.uno.XComponentContext;
+
+public class Introspector extends WeakBase{
+
+    private XIntrospection m_xIntrospection;
+    private XMultiComponentFactory m_xMultiComponentFactory;
+    private XComponentContext m_xComponentContext;
+    private XTypeDescriptionEnumerationAccess m_xTDEnumerationAccess;
+    private XIdlReflection mxIdlReflection;
+    private static Introspector m_oIntrospector = null;
+    private XSimpleFileAccess xSimpleFileAccess = null;
+
+
+
+    public static Introspector getIntrospector(){
+        if (m_oIntrospector == null){
+            throw new NullPointerException();
+        }
+        else{
+            return m_oIntrospector;
+        }
+    }
+
+    public static Introspector getIntrospector(XComponentContext _xComponentContext){
+        if (m_oIntrospector == null){
+            m_oIntrospector =  new Introspector(_xComponentContext);
+        }
+        return m_oIntrospector;
+    }
+
+
+    /** Creates a new instance of Introspection */
+    private Introspector(XComponentContext _xComponentContext) {
+    try{
+        m_xComponentContext = _xComponentContext;
+        m_xMultiComponentFactory = m_xComponentContext.getServiceManager();
+        Object o = m_xMultiComponentFactory.createInstanceWithContext("com.sun.star.beans.Introspection", m_xComponentContext);
+        m_xIntrospection = UnoRuntime.queryInterface(XIntrospection.class, o );
+        Object oCoreReflection = getXMultiComponentFactory().createInstanceWithContext("com.sun.star.reflection.CoreReflection", getXComponentContext());
+        mxIdlReflection = UnoRuntime.queryInterface(XIdlReflection.class, oCoreReflection);
+        initTypeDescriptionManager();
+    }
+    catch( Exception exception ) {
+        System.err.println( exception );
+    }}
+
+
+    protected XComponentContext getXComponentContext(){
+        return m_xComponentContext;
+    }
+
+
+    private XMultiComponentFactory getXMultiComponentFactory(){
+        return m_xMultiComponentFactory;
+    }
+
+
+    protected XIntrospectionAccess getXIntrospectionAccess(Object _oUnoComponent){
+        return m_xIntrospection.inspect(_oUnoComponent);
+    }
+
+
+    public boolean isContainer(Object _oUnoObject){
+    boolean bIsContainer = false;
+    try {
+        XIntrospectionAccess xIntrospectionAccessObject = getXIntrospectionAccess(_oUnoObject);
+        if (xIntrospectionAccessObject != null){
+            XEnumerationAccess xEnumerationAccess = UnoRuntime.queryInterface(XEnumerationAccess.class, xIntrospectionAccessObject.queryAdapter( new Type( XEnumerationAccess.class ) ) );
+            if (xEnumerationAccess != null){
+                XEnumeration xEnumeration = xEnumerationAccess.createEnumeration();
+                bIsContainer = xEnumeration.hasMoreElements();
+            }
+            if (!bIsContainer){
+                XIndexAccess xIndexAccess = UnoRuntime.queryInterface( XIndexAccess.class, xIntrospectionAccessObject.queryAdapter(new Type( XIndexAccess.class )));
+                if (xIndexAccess != null){
+                    bIsContainer = (xIndexAccess.getCount() > 0);
+                }
+            }
+        }
+    } catch (IllegalTypeException ex) {
+        ex.printStackTrace(System.err);
+    }
+        return bIsContainer;
+    }
+
+
+    //  add all containers for the given object to the tree under the node
+    //  parent
+    public Object[] getUnoObjectsOfContainer(Object _oUnoParentObject) {
+    Object[] oRetComponents = null;
+    try {
+        ArrayList<Object> oRetComponentsVector = new ArrayList<Object>();
+        XIntrospectionAccess xIntrospectionAccessObject = getXIntrospectionAccess(_oUnoParentObject);
+        if ( xIntrospectionAccessObject != null ) {
+            XEnumerationAccess xEnumerationAccess = UnoRuntime.queryInterface(XEnumerationAccess.class, xIntrospectionAccessObject.queryAdapter( new Type( XEnumerationAccess.class ) ) );
+            if ( xEnumerationAccess != null ) {
+                XEnumeration xEnumeration = xEnumerationAccess.createEnumeration();
+                while ( xEnumeration.hasMoreElements() ) {
+                    oRetComponentsVector.add(xEnumeration.nextElement());
+                }
+            }
+            XIndexAccess xIndexAccess = UnoRuntime.queryInterface( XIndexAccess.class, xIntrospectionAccessObject.queryAdapter(new Type( XIndexAccess.class )));
+            if ( xIndexAccess != null ) {
+                XIdlMethod mMethod = xIntrospectionAccessObject.getMethod("getByIndex", com.sun.star.beans.MethodConcept.INDEXCONTAINER);
+                for ( int i = 0; i < xIndexAccess.getCount(); i++ ) {
+                    Object[][] aParamInfo = new Object[1][1];
+                    aParamInfo[0] = new Integer[] { Integer.valueOf(i) };
+                    oRetComponentsVector.add(mMethod.invoke(_oUnoParentObject, aParamInfo));
+                }
+            }
+        }
+        if (oRetComponentsVector != null){
+            oRetComponents = new Object[oRetComponentsVector.size()];
+            oRetComponentsVector.toArray(oRetComponents);
+        }
+    }
+    catch( Exception exception ) {
+        System.err.println( exception );
+    }
+    return oRetComponents;
+    }
+
+
+    protected XIdlMethod[] getMethodsOfInterface(Type _aType){
+    try{
+        XIdlClass xIdlClass = mxIdlReflection.forName(_aType.getTypeName());
+        return xIdlClass.getMethods();
+    }
+    catch( Exception e ) {
+        System.err.println( e );
+        return null;
+    }}
+
+
+
+
+
+    public boolean hasMethods(Object _oUnoObject){
+        boolean bHasMethods = (getMethods(_oUnoObject).length > 0);
+        return bHasMethods;
+    }
+
+
+    //  add all methods for the given object to the tree under the node parent
+    public XIdlMethod[] getMethods(Object _oUnoParentObject) {
+    try {
+        XIntrospectionAccess xIntrospectionAccess = getXIntrospectionAccess(_oUnoParentObject);
+        if (xIntrospectionAccess != null){
+            XIdlMethod[] xIdlMethods = xIntrospectionAccess.getMethods(MethodConcept.ALL - MethodConcept.DANGEROUS);
+            return xIdlMethods;
+        }
+    }
+    catch( Exception e ) {
+        System.err.println( e );
+    }
+    return null;
+    }
+
+
+    public boolean hasProperties(Object _oUnoObject){
+        boolean bHasProperties = (getProperties(_oUnoObject).length > 0);
+        return bHasProperties;
+    }
+
+
+    protected Property[] getProperties( Object _oUnoParentObject){
+    try {
+        XIntrospectionAccess xIntrospectionAccess = getXIntrospectionAccess(_oUnoParentObject);
+        if (xIntrospectionAccess != null){
+            Property[] aProperties = xIntrospectionAccess.getProperties(com.sun.star.beans.PropertyConcept.ATTRIBUTES + com.sun.star.beans.PropertyConcept.PROPERTYSET);
+            return aProperties;
+        }
+    }
+    catch( Exception e ) {
+        System.err.println( e );
+    }
+        return null;
+    }
+
+
+    protected Property[] getProperties(Object _oUnoObject, String _sServiceName){
+        Property[] aProperties = getProperties(_oUnoObject);
+        List<Property> aListOfProperties = java.util.Arrays.asList(aProperties);
+        ArrayList<Property> aPropertiesVector = new ArrayList<Property>(aListOfProperties);
+        if (aProperties != null){
+            XPropertyTypeDescription[] xPropertyTypeDescriptions = getPropertyDescriptionsOfService(_sServiceName);
+            for (int i = aProperties.length - 1; i >= 0; i--){
+                if (!hasByName(xPropertyTypeDescriptions, _sServiceName + "." + aProperties[i].Name)){
+                    aPropertiesVector.remove(i);
+                }
+            }
+        }
+        Property[] aRetProperties = new Property[aPropertiesVector.size()];
+        aPropertiesVector.toArray(aRetProperties);
+        return aRetProperties;
+    }
+
+
+    protected Type[] getInterfaces(Object _oUnoObject, String _sServiceName){
+        Type[] aTypes = getInterfaces(_oUnoObject);
+        List<Type> aListOfTypes = java.util.Arrays.asList(aTypes);
+        ArrayList<Type> aTypesVector = new ArrayList<Type>(aListOfTypes);
+        if (aTypes != null){
+            XInterfaceTypeDescription[] xInterfaceTypeDescriptions = getInterfaceDescriptionsOfService(_sServiceName);
+            for (int i = aTypes.length - 1; i >= 0; i--){
+                if (!hasByName(xInterfaceTypeDescriptions, aTypes[i].getTypeName())){
+                    aTypesVector.remove(i);
+                }
+            }
+        }
+        Type[] aRetTypes = new Type[aTypesVector.size()];
+        aTypesVector.toArray(aRetTypes);
+        return aRetTypes;
+    }
+
+
+    public boolean hasInterfaces(Object _oUnoObject){
+        return (getInterfaces(_oUnoObject).length > 0);
+    }
+
+
+    protected Type[] getInterfaces(Object _oUnoParentObject){
+        Type[] aTypes = new Type[]{};
+        XTypeProvider xTypeProvider = UnoRuntime.queryInterface( XTypeProvider.class, _oUnoParentObject);
+        if ( xTypeProvider != null ) {
+            aTypes = xTypeProvider.getTypes();
+        }
+        return aTypes;
+    }
+
+
+
+    public static boolean isObjectSequence(Object _oUnoObject){
+        Type aType = AnyConverter.getType(_oUnoObject);
+        return aType.getTypeClass().getValue() == TypeClass.SEQUENCE_value;
+    }
+
+
+    public static boolean isObjectPrimitive(Object _oUnoObject){
+        boolean breturn = false;
+        if (_oUnoObject != null){
+            Type aType = AnyConverter.getType(_oUnoObject);
+            breturn = isObjectPrimitive(_oUnoObject.getClass(), aType.getTypeClass());
+        }
+        return breturn;
+    }
+
+
+    public static boolean isPrimitive(TypeClass _typeClass){
+               return (( _typeClass == TypeClass.BOOLEAN )
+                     || ( _typeClass == TypeClass.BYTE )
+                     || ( _typeClass == TypeClass.CHAR )
+                     || ( _typeClass == TypeClass.DOUBLE )
+                     || ( _typeClass == TypeClass.ENUM )
+                     || ( _typeClass == TypeClass.FLOAT )
+                     || ( _typeClass == TypeClass.HYPER )
+                     || ( _typeClass == TypeClass.LONG )
+                     || ( _typeClass == TypeClass.SHORT )
+                     || ( _typeClass == TypeClass.STRING )
+                     || ( _typeClass == TypeClass.UNSIGNED_HYPER )
+                     || ( _typeClass == TypeClass.UNSIGNED_LONG )
+                     || ( _typeClass == TypeClass.UNSIGNED_SHORT ));
+    }
+
+    public static boolean isObjectPrimitive(Class<? extends Object> _oUnoClass, TypeClass _typeClass){
+        return !( ( !_oUnoClass.isPrimitive() ) && ( _typeClass != TypeClass.ARRAY )
+                                                         && ( _typeClass != TypeClass.BOOLEAN )
+                                                         && ( _typeClass != TypeClass.BYTE )
+                                                         && ( _typeClass != TypeClass.CHAR )
+                                                         && ( _typeClass != TypeClass.DOUBLE )
+                                                         && ( _typeClass != TypeClass.ENUM )
+                                                         && ( _typeClass != TypeClass.FLOAT )
+                                                         && ( _typeClass != TypeClass.HYPER )
+                                                         && ( _typeClass != TypeClass.LONG )
+                                                         && ( _typeClass != TypeClass.SHORT )
+                                                         && ( _typeClass != TypeClass.STRING )
+                                                         && ( _typeClass != TypeClass.UNSIGNED_HYPER )
+                                                         && ( _typeClass != TypeClass.UNSIGNED_LONG )
+                                                         && ( _typeClass != TypeClass.UNSIGNED_SHORT ));
+    }
+
+
+    private void initTypeDescriptionManager() {
+    try {
+        Object oTypeDescriptionManager = getXComponentContext().getValueByName("/singletons/com.sun.star.reflection.theTypeDescriptionManager");
+        m_xTDEnumerationAccess = UnoRuntime.queryInterface(XTypeDescriptionEnumerationAccess.class, oTypeDescriptionManager);
+    } catch ( java.lang.Exception e) {
+        System.out.println(System.out);
+    }}
+
+
+    private XTypeDescriptionEnumerationAccess getXTypeDescriptionEnumerationAccess(){
+        return m_xTDEnumerationAccess;
+    }
+
+
+    protected XConstantTypeDescription[] getFieldsOfConstantGroup(String _sTypeClass){
+    XConstantTypeDescription[] xConstantTypeDescriptions = null;
+    try {
+        TypeClass[] eTypeClasses = new com.sun.star.uno.TypeClass[1];
+        eTypeClasses[0] = com.sun.star.uno.TypeClass.CONSTANTS;
+        XTypeDescriptionEnumeration xTDEnumeration = m_xTDEnumerationAccess.createTypeDescriptionEnumeration(getModuleName(_sTypeClass), eTypeClasses, TypeDescriptionSearchDepth.INFINITE);
+        while (xTDEnumeration.hasMoreElements()) {
+            XTypeDescription xTD = xTDEnumeration.nextTypeDescription();
+            if (xTD.getName().equals(_sTypeClass)){
+                XConstantsTypeDescription xConstantsTypeDescription = UnoRuntime.queryInterface(XConstantsTypeDescription.class, xTD);
+                xConstantTypeDescriptions = xConstantsTypeDescription.getConstants();
+            }
+            String sName = xTD.getName();
+        }
+        return xConstantTypeDescriptions;
+    } catch ( java.lang.Exception e) {
+        System.out.println(System.out);
+    }
+        return null;
+    }
+
+    private XServiceTypeDescription getServiceTypeDescription(String _sServiceName, TypeClass _eTypeClass){
+    try{
+        if (_sServiceName.length() > 0){
+            TypeClass[] eTypeClasses = new com.sun.star.uno.TypeClass[2];
+            eTypeClasses[0] = com.sun.star.uno.TypeClass.SERVICE;
+            eTypeClasses[1] = _eTypeClass;
+            XTypeDescriptionEnumeration xTDEnumeration = getXTypeDescriptionEnumerationAccess().createTypeDescriptionEnumeration(Introspector.getModuleName(_sServiceName), eTypeClasses, TypeDescriptionSearchDepth.INFINITE);
+            while (xTDEnumeration.hasMoreElements()) {
+                XTypeDescription xTD = xTDEnumeration.nextTypeDescription();
+                if (xTD.getName().equals(_sServiceName)){
+                    XServiceTypeDescription xServiceTypeDescription = UnoRuntime.queryInterface(XServiceTypeDescription.class, xTD);
+                    return xServiceTypeDescription;
+                }
+            }
+        }
+        return null;
+    } catch (Exception ex) {
+        ex.printStackTrace(System.err);
+        return null;
+    }}
+
+
+    public XPropertyTypeDescription[] getPropertyDescriptionsOfService(String _sServiceName){
+    try {
+        XServiceTypeDescription xServiceTypeDescription = getServiceTypeDescription(_sServiceName, com.sun.star.uno.TypeClass.PROPERTY);
+        if (xServiceTypeDescription != null){
+            XPropertyTypeDescription[] xPropertyTypeDescriptions = xServiceTypeDescription.getProperties();
+            return xPropertyTypeDescriptions;
+        }
+    } catch ( java.lang.Exception e) {
+        System.out.println(System.out);
+    }
+    return new XPropertyTypeDescription[]{};
+    }
+
+
+    public XTypeDescription getReferencedType(String _sTypeName){
+    XTypeDescription xTypeDescription = null;
+    try{
+        XHierarchicalNameAccess xHierarchicalNameAccess = UnoRuntime.queryInterface(XHierarchicalNameAccess.class, m_xTDEnumerationAccess);
+        if (xHierarchicalNameAccess != null){
+            if (xHierarchicalNameAccess.hasByHierarchicalName(_sTypeName)){
+                XIndirectTypeDescription xIndirectTypeDescription = UnoRuntime.queryInterface(XIndirectTypeDescription.class, xHierarchicalNameAccess.getByHierarchicalName(_sTypeName));
+                if (xIndirectTypeDescription != null){
+                    xTypeDescription = xIndirectTypeDescription.getReferencedType();
+                }
+            }
+        }
+    } catch (Exception ex) {
+        ex.printStackTrace(System.err);
+    }
+        return xTypeDescription;
+    }
+
+
+    private XInterfaceTypeDescription[] getInterfaceDescriptionsOfService(String _sServiceName){
+    try {
+        XServiceTypeDescription xServiceTypeDescription = getServiceTypeDescription(_sServiceName, com.sun.star.uno.TypeClass.INTERFACE);
+        if (xServiceTypeDescription != null){
+            XInterfaceTypeDescription[] xInterfaceTypeDescriptions = xServiceTypeDescription.getMandatoryInterfaces();
+            return xInterfaceTypeDescriptions;
+        }
+    } catch ( java.lang.Exception e) {
+        System.out.println(System.out);
+    }
+        return new XInterfaceTypeDescription[]{};
+    }
+
+
+    private static boolean hasByName(XTypeDescription[] _xTypeDescriptions, String _sTypeName){
+        for (int i = 0; i < _xTypeDescriptions.length; i++){
+            if (_xTypeDescriptions[i].getName().equals(_sTypeName)){
+                return true;
+            }
+        }
+        return false;
+    }
+
+
+    public static String getModuleName(String _sTypeClass){
+        int nlastindex = _sTypeClass.lastIndexOf(".");
+        if (nlastindex > -1){
+            return _sTypeClass.substring(0, nlastindex);
+        }
+        else{
+            return "";
+        }
+    }
+
+
+    public static String getShortClassName(String _sClassName){
+        String sShortClassName = _sClassName;
+        int nindex = _sClassName.lastIndexOf(".");
+        if ((nindex < _sClassName.length()) && nindex > -1){
+            sShortClassName = _sClassName.substring(nindex + 1);
+        }
+        return sShortClassName;
+    }
+
+
+
+    public static boolean isUnoTypeObject(Object _oUnoObject){
+        return isOfUnoType(_oUnoObject, "com.sun.star.uno.Type");
+    }
+
+
+    public static boolean isUnoPropertyTypeObject(Object _oUnoObject){
+        return isOfUnoType(_oUnoObject, "com.sun.star.beans.Property");
+    }
+
+
+    public static boolean isUnoPropertyValueTypeObject(Object _oUnoObject){
+        return isOfUnoType(_oUnoObject, "com.sun.star.beans.PropertyValue");
+    }
+
+
+    private static boolean isOfUnoType(Object _oUnoObject, String _sTypeName){
+        boolean bIsUnoObject = false;
+        if (_oUnoObject != null){
+            if (_oUnoObject.getClass().isArray()){
+                if (!_oUnoObject.getClass().getComponentType().isPrimitive()){
+                    Object[] oUnoArray = (Object[]) _oUnoObject;
+                    if (oUnoArray.length > 0){
+                        bIsUnoObject = ( oUnoArray[0].getClass().getName().equals(_sTypeName));
+                    }
+                }
+            }
+        }
+        else{
+            bIsUnoObject = (_oUnoObject.getClass().getName().equals(_sTypeName));
+        }
+        return bIsUnoObject;
+    }
+
+
+    public String getConstantDisplayString(int _nValue, XConstantTypeDescription[] _xConstantTypeDescription, String _sDisplayString){
+        String sPrefix = "";
+        int[] nbits = new int[_xConstantTypeDescription.length];
+        for (int i = 0; i < _xConstantTypeDescription.length; i++){
+            short nConstantValue = ((Short) _xConstantTypeDescription[i].getConstantValue()).shortValue();
+            nbits[i] = _nValue & nConstantValue;
+            if (nbits[i] > 0){
+                _sDisplayString += sPrefix + _xConstantTypeDescription[i].getName();
+                sPrefix = " + ";
+            }
+        }
+        return _sDisplayString;
+    }
+
+
+    public static boolean isValid(Object[] _oObject){
+        if (_oObject != null){
+            if (_oObject.length > 0){
+                return true;
+            }
+        }
+        return false;
+    }
+
+
+
+
+
+    public static boolean isArray(Object _oObject){
+        return _oObject.getClass().isArray();
+    }
+
+
+    public boolean hasSupportedServices(Object _oUnoObject){
+        boolean bHasSupportedServices = false;
+        XServiceInfo xServiceInfo = UnoRuntime.queryInterface( XServiceInfo.class, _oUnoObject);
+        if ( xServiceInfo != null ){
+            String[] sSupportedServiceNames = xServiceInfo.getSupportedServiceNames();
+            bHasSupportedServices = sSupportedServiceNames.length > 0;
+        }
+        return bHasSupportedServices;
+    }
+
+
+    public Object getValueOfText(TypeClass aTypeClass, String sText){
+        Object oReturn = null;
+        switch (aTypeClass.getValue()){
+            case TypeClass.CHAR_value:
+                break;
+            case TypeClass.DOUBLE_value:
+                oReturn = Double.valueOf(sText);
+                break;
+            case TypeClass.ENUM_value:
+                break;
+            case TypeClass.FLOAT_value:
+                oReturn = Float.valueOf(sText);
+                break;
+            case TypeClass.HYPER_value:
+                oReturn = Long.valueOf(sText);
+                break;
+            case TypeClass.LONG_value:
+                oReturn = Integer.valueOf(sText);
+                break;
+            case TypeClass.SHORT_value:
+                oReturn = Byte.valueOf(sText);
+                break;
+            case TypeClass.STRING_value:
+                oReturn = sText;
+                break;
+            case TypeClass.UNSIGNED_HYPER_value:
+                oReturn = Long.valueOf(sText);
+                break;
+            case TypeClass.UNSIGNED_LONG_value:
+                oReturn = Integer.valueOf(sText);
+                break;
+            case TypeClass.UNSIGNED_SHORT_value:
+                oReturn = Byte.valueOf(sText);
+                break;
+            default:
+        }
+        return oReturn;
+    }
+
+
+    public XSimpleFileAccess getXSimpleFileAccess(){
+    try {
+        if (xSimpleFileAccess == null){
+            Object oSimpleFileAccess = m_xComponentContext.getServiceManager().createInstanceWithContext("com.sun.star.ucb.SimpleFileAccess", m_xComponentContext);
+            xSimpleFileAccess = com.sun.star.uno.UnoRuntime.queryInterface(XSimpleFileAccess.class, oSimpleFileAccess);
+        }
+        return xSimpleFileAccess;
+    } catch (com.sun.star.uno.Exception ex) {
+        ex.printStackTrace(System.err);
+        return null;
+    }}
+
+
+    public boolean isValidSDKInstallationPath(String _sSDKInstallationPath){
+    boolean bIsValid = false;
+    try {
+        String sIDLFolder = Introspector.addToPath(_sSDKInstallationPath, Inspector.sIDLDOCUMENTSUBFOLDER);
+        String sIndexFile = Introspector.addToPath(_sSDKInstallationPath, "index.html");
+        if (getXSimpleFileAccess() != null){
+            bIsValid = (getXSimpleFileAccess().exists(sIDLFolder) && getXSimpleFileAccess().exists(sIndexFile));
+        }
+    } catch (com.sun.star.uno.Exception ex) {
+        ex.printStackTrace(System.err);
+    }
+        return bIsValid;
+    }
+
+
+    public static String addToPath(String _sPath, String _sSubPath){
+        if (!_sPath.endsWith("/")){
+            _sPath += "/";
+        }
+        return _sPath + _sSubPath;
+    }
+
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */