INTEGRATION: CWS sdkinspector (1.1.2); FILE ADDED

2006/12/21 16:19:10 bc 1.1.2.4: #i69688# several changes
2006/12/21 10:19:05 bc 1.1.2.3: #i69688# ecapsulating UI
2006/12/08 17:16:46 bc 1.1.2.2: #i69688# several improvements
2006/11/21 12:39:06 bc 1.1.2.1: #i69688# SourceCodeGeneration functionality added

1 files changed, 676 insertions, 0 deletions

diff --git a/odk/examples/java/Inspector/SourceCodeGenerator.java b/odk/examples/java/Inspector/SourceCodeGenerator.java
new file mode 100644
index 000000000000..e65128a22665
--- /dev/null
+++ b/odk/examples/java/Inspector/SourceCodeGenerator.java
@@ -0,0 +1,676 @@
+/*************************************************************************
+ *
+ *  $RCSfile: SourceCodeGenerator.java,v $
+ *
+ *  $Revision: 1.2 $
+ *
+ *  last change: $Author: hr $ $Date: 2007-01-02 15:00:18 $
+ *
+ *  The Contents of this file are made available subject to the terms of
+ *  the BSD license.
+ *
+ *  Copyright (c) 2003 by Sun Microsystems, Inc.
+ *  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 com.sun.star.reflection.ParamInfo;
+import com.sun.star.reflection.XIdlClass;
+import com.sun.star.reflection.XIdlMethod;
+import com.sun.star.reflection.XTypeDescription;
+import com.sun.star.uno.Any;
+import com.sun.star.uno.AnyConverter;
+import com.sun.star.uno.Type;
+import com.sun.star.uno.TypeClass;
+import java.util.Enumeration;
+import java.util.Hashtable;
+import java.util.Vector;
+
+
+
+public class SourceCodeGenerator {
+    private Vector sHeaderDescriptionVector = new Vector();
+    private XLanguageSourceCodeGenerator m_xLanguageSourceCodeGenerator;
+    private String sHeaderCode = "";
+    private String sStatementCode = "";
+    private String sMainMethodSignature = "";
+    private Hashtable aVariables = new Hashtable();
+    private final String SSUFFIXSEPARATOR = "_";
+    private final String SVARIABLENAME = "VariableName";
+    private final String SARRAYVARIABLENAME = "VariableNameList";
+    private Introspector m_oIntrospector;
+
+
+    /** Creates a new instance of SourceCodeGenerator */
+    public SourceCodeGenerator() {
+        m_xLanguageSourceCodeGenerator = new JavaCodeGenerator();
+        m_oIntrospector = Introspector.getIntrospector();
+    }
+
+
+    public String addSourceCodeOfUnoObject(XTreePathProvider _xTreepathProvider){
+        String sSourceCode = "";
+        String sVariableName = "";
+        if (_xTreepathProvider != null) {
+            for (int i = 0; i < _xTreepathProvider.getPathCount(); i++){
+                UnoNode oUnoNode = _xTreepathProvider.getPathComponent(i);
+                if (i == 0){
+                    sVariableName = "<UNOENTRYOBJECT>";
+                    sMainMethodSignature = m_xLanguageSourceCodeGenerator.getMainMethodSignatureSourceCode(oUnoNode, sVariableName);
+                }
+                else{
+                    if (oUnoNode instanceof UnoMethodNode){
+                        UnoMethodNode oUnoMethodNode = (UnoMethodNode) oUnoNode;
+                        XIdlClass xIdlClass = oUnoMethodNode.getXIdlMethod().getReturnType();
+                        String sTypeName = xIdlClass.getName();
+                        TypeClass aTypeClass = xIdlClass.getTypeClass();
+                        UnoObjectDefinition oUnoReturnObjectDefinition = new UnoObjectDefinition(oUnoMethodNode.getUnoReturnObject(), sTypeName, aTypeClass);
+                        String sNewVariableName = oUnoReturnObjectDefinition.getVariableName();
+                        if (!isVariableDeclared(oUnoReturnObjectDefinition)){
+                            sStatementCode += "\n" + getMethodStatementSourceCode(oUnoMethodNode, sVariableName, oUnoReturnObjectDefinition);
+                        }
+                        sVariableName = sNewVariableName;
+                    }
+                    else if (oUnoNode instanceof UnoPropertyNode){
+                        UnoPropertyNode oUnoPropertyNode = (UnoPropertyNode) oUnoNode;
+                        Any oReturnObject = com.sun.star.uno.Any.complete(oUnoPropertyNode.getUnoReturnObject());
+                        UnoObjectDefinition oUnoReturnObjectDefinition = new UnoObjectDefinition(oReturnObject);
+                        String sNewVariableName = oUnoReturnObjectDefinition.getVariableName();
+                        if (!isVariableDeclared(oUnoReturnObjectDefinition)){
+                            sStatementCode += "\n" + getPropertyStatementSourceCode(oUnoPropertyNode, sVariableName, oUnoReturnObjectDefinition);
+                        }
+                        sVariableName = sNewVariableName;
+                    }
+                }
+            }
+        }
+        String sCompleteCode = combineCompleteSourceCode();
+        return sCompleteCode;
+    }
+
+
+    private String combineCompleteSourceCode(){
+        String sCompleteCode = "";
+        sCompleteCode  += getHeaderSourceCode();
+        sCompleteCode += sMainMethodSignature;
+        sCompleteCode += sStatementCode;
+        sCompleteCode += m_xLanguageSourceCodeGenerator.getMethodTerminationSourceCode();
+        return sCompleteCode;
+    }
+
+
+    public String getPropertyStatementSourceCode(UnoPropertyNode _oUnoPropertyNode, String _sObjectDescription, UnoObjectDefinition _oUnoReturnObjectDefinition){
+        String sReturnObjectVariableDefinition = "";
+        String sStatement = "";
+        UnoObjectDefinition oUnoObjectDefinition = new UnoObjectDefinition(_oUnoPropertyNode.getUnoObject(), "com.sun.star.beans.XPropertySet");
+        if (!isVariableDeclared(oUnoObjectDefinition)){
+            String sObjectVariableDefinition = getVariableDeclaration(oUnoObjectDefinition);
+            sStatement += m_xLanguageSourceCodeGenerator.getqueryInterfaceSourceCode("XPropertySet", sObjectVariableDefinition, _sObjectDescription);
+        }
+        if (_oUnoReturnObjectDefinition.getTypeClass().getValue() != TypeClass.VOID_value){
+            sReturnObjectVariableDefinition = getVariableInitialization(_oUnoReturnObjectDefinition) + " = ";
+        }
+        sStatement += m_xLanguageSourceCodeGenerator.getPropertyValueGetterSourceCode(_oUnoPropertyNode.getPropertyName(), _oUnoReturnObjectDefinition.getVariableName(), oUnoObjectDefinition.getVariableName());
+        return sStatement;
+    }
+
+
+    public String getMethodStatementSourceCode(UnoMethodNode _oUnoMethodNode, String _sObjectDescription, UnoObjectDefinition _oUnoReturnObjectDefinition){
+        String sReturnObjectVariableDefinition = "";
+        XIdlMethod xIdlMethod = _oUnoMethodNode.getXIdlMethod();
+        String sStatement = "";
+        UnoObjectDefinition oUnoObjectDefinition = new UnoObjectDefinition(_oUnoMethodNode.getUnoObject(), _oUnoMethodNode.getClassName());
+        if (!isVariableDeclared(oUnoObjectDefinition)){
+            String sObjectVariableDefinition = getVariableDeclaration(oUnoObjectDefinition);
+            String sShortClassName = getShortClassName(oUnoObjectDefinition.getTypeName());
+            sStatement = m_xLanguageSourceCodeGenerator.getqueryInterfaceSourceCode(sShortClassName, sObjectVariableDefinition, _sObjectDescription);
+        }
+        _oUnoReturnObjectDefinition.setTypeName(xIdlMethod.getReturnType().getName());
+        String sParameterCode = getMethodParameterValueDescription(_oUnoMethodNode, false);
+        if (_oUnoReturnObjectDefinition.getTypeClass().getValue() != TypeClass.VOID_value){
+            sReturnObjectVariableDefinition = getVariableInitialization(_oUnoReturnObjectDefinition) + " = ";
+        }
+        sStatement += "\t" + sReturnObjectVariableDefinition + oUnoObjectDefinition.getVariableName() + "." + xIdlMethod.getName() + "(" + sParameterCode + ");";
+        return sStatement;
+    }
+
+
+    private String getRootDescription(UnoNode _oUnoNode){
+        return "_o" + _oUnoNode.toString();
+    }
+
+
+    private String getHeaderSourceCode(){
+        Vector sHeaderStatements = new HeaderStatements();
+        String sHeaderSourcecode = "";
+        Enumeration aEnumeration = aVariables.elements();
+        while(aEnumeration.hasMoreElements()){
+            UnoObjectDefinition oUnoObjectDefinition = (UnoObjectDefinition) aEnumeration.nextElement();
+            String sCurHeaderStatement = this.m_xLanguageSourceCodeGenerator.getHeaderSourceCode(oUnoObjectDefinition.getUnoObject(), oUnoObjectDefinition.getTypeName());
+            if (!sHeaderStatements.contains(sCurHeaderStatement)){
+                sHeaderSourcecode += sCurHeaderStatement;
+                sHeaderStatements.add(sCurHeaderStatement);
+            }
+        }
+        return sHeaderSourcecode +"\n";
+    }
+
+    private class HeaderStatements extends Vector{
+
+        public boolean contains(Object _oElement){
+           String sCompName = (String) _oElement;
+           for (int i = 0; i < this.size(); i++){
+               String sElement = (String) this.get(i);
+               if (sElement.equals(sCompName)){
+                   return true;
+               }
+           }
+           return false;
+       }
+
+    }
+
+
+    private boolean isVariableDeclared(UnoObjectDefinition _oUnoObjectDefinition){
+        boolean bisDeclared = false;
+        String sVariableName = _oUnoObjectDefinition.getVariableStemName();
+        bisDeclared = aVariables.containsKey(sVariableName);
+        if (bisDeclared){
+            Object oUnoObject = ((UnoObjectDefinition) aVariables.get(sVariableName)).getUnoObject();
+            String sUnoObjectIdentity = oUnoObject.toString();
+            if (m_oIntrospector.isObjectPrimitive(oUnoObject)){
+                bisDeclared = false;
+            }
+            else{
+                bisDeclared = (sUnoObjectIdentity.equals(oUnoObject.toString()));
+            }
+        }
+        return bisDeclared;
+    }
+
+
+    private String addUniqueVariableName(String _sStemVariableName, UnoObjectDefinition _oUnoObjectDefinition){
+        boolean bElementexists = true;
+        int a = 2;
+        String sCompName = _sStemVariableName;
+        while (bElementexists){
+            if (! aVariables.containsKey(sCompName)){
+                aVariables.put(sCompName, _oUnoObjectDefinition);
+                break;
+            }
+            sCompName = _sStemVariableName + SSUFFIXSEPARATOR + a++;
+        }
+        return sCompName;
+    }
+
+
+    private String getVariableDeclaration(UnoObjectDefinition _oUnoObjectDefinition){
+        TypeClass aTypeClass = _oUnoObjectDefinition.getTypeClass();
+        return getVariableDeclaration(_oUnoObjectDefinition, aTypeClass);
+    }
+
+
+
+    private String getTypeString(String _sTypeName, TypeClass _aTypeClass){
+        String sTypeString = "";
+        switch (_aTypeClass.getValue()){
+            case TypeClass.BOOLEAN_value:
+                sTypeString = m_xLanguageSourceCodeGenerator.getbooleanTypeDescription();
+                break;
+            case TypeClass.BYTE_value:
+                sTypeString = m_xLanguageSourceCodeGenerator.getbyteTypeDescription();
+                break;
+            case TypeClass.CHAR_value:
+                sTypeString = m_xLanguageSourceCodeGenerator.getcharTypeDescription();
+                break;
+            case TypeClass.DOUBLE_value:
+                sTypeString = m_xLanguageSourceCodeGenerator.getdoubleTypeDescription();
+                break;
+            case TypeClass.FLOAT_value:
+                sTypeString = m_xLanguageSourceCodeGenerator.getfloatTypeDescription();
+                break;
+            case TypeClass.HYPER_value:
+                sTypeString = m_xLanguageSourceCodeGenerator.gethyperTypeDescription();
+                break;
+            case TypeClass.LONG_value:
+                sTypeString = m_xLanguageSourceCodeGenerator.getlongTypeDescription();
+                break;
+            case TypeClass.SHORT_value:
+                sTypeString = m_xLanguageSourceCodeGenerator.getshortTypeDescription();
+                break;
+            case TypeClass.STRING_value:
+                sTypeString = m_xLanguageSourceCodeGenerator.getstringTypeDescription();
+                break;
+            case TypeClass.UNSIGNED_HYPER_value:
+                sTypeString = m_xLanguageSourceCodeGenerator.getunsignedhyperTypeDescription();
+                break;
+            case TypeClass.UNSIGNED_LONG_value:
+                sTypeString = m_xLanguageSourceCodeGenerator.getunsignedlongTypeDescription();
+                break;
+            case TypeClass.UNSIGNED_SHORT_value:
+                sTypeString = m_xLanguageSourceCodeGenerator.getdoubleTypeDescription();
+                break;
+            case TypeClass.SEQUENCE_value:
+                //TODO mehrdimensionale Arrays berücksichtigen!!!
+                XTypeDescription xTypeDescription = Introspector.getIntrospector().getReferencedType(_sTypeName);
+                sTypeString = getTypeString(xTypeDescription.getName(), xTypeDescription.getTypeClass());
+                break;
+            case TypeClass.ENUM_value:
+                System.out.println("declare Enum Variable!!!");
+                break;
+            case TypeClass.ANY_value:
+            case TypeClass.INTERFACE_ATTRIBUTE_value:
+            case TypeClass.INTERFACE_METHOD_value:
+            case TypeClass.INTERFACE_value:
+            case TypeClass.STRUCT_value:
+            case TypeClass.PROPERTY_value:
+            case TypeClass.TYPE_value:
+                String sShortClassName = getShortClassName(_sTypeName);
+                sTypeString = m_xLanguageSourceCodeGenerator.getObjectTypeDescription(sShortClassName);
+            default:
+        }
+        return sTypeString;
+    }
+
+
+    private String getVariableDeclaration(UnoObjectDefinition _oUnoObjectDefinition, TypeClass _aTypeClass){
+        boolean bIsArray = m_oIntrospector.isObjectSequence(_oUnoObjectDefinition.getUnoObject());
+        String sVariableName = _oUnoObjectDefinition.getVariableName();
+        String sTypeName = _oUnoObjectDefinition.getTypeName();
+        String sTypeString = getTypeString(sTypeName, _aTypeClass);
+        String sVariableDeclaration = m_xLanguageSourceCodeGenerator.getVariableDeclaration(sTypeString, sVariableName, bIsArray);
+        addUniqueVariableName(sVariableName, _oUnoObjectDefinition);
+        return sVariableDeclaration;
+    }
+
+
+    public String getVariableInitialization(UnoObjectDefinition _oUnoObjectDefinition){
+        String sObjectVariableDeclaration = "";
+        String sVariableStemName = _oUnoObjectDefinition.getVariableStemName();
+        if (isVariableDeclared(_oUnoObjectDefinition)){
+            sObjectVariableDeclaration = sVariableStemName;
+        }
+        else{
+            sObjectVariableDeclaration =  getVariableDeclaration(_oUnoObjectDefinition);
+        }
+        return sObjectVariableDeclaration;
+    }
+
+
+    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 String getVariableNameforUnoObject(String _sShortClassName){
+        if (_sShortClassName.startsWith("X")){
+            return  "x" + _sShortClassName.substring(1);
+        }
+        else{
+            return _sShortClassName;
+        }
+    }
+
+
+    public class UnoObjectDefinition{
+        Object m_oUnoObject = null;
+        Type aType = null;
+        String sVariableStemName = "";
+        String sVariableName = "";
+        String m_sTypeName = "";
+        TypeClass m_aTypeClass = null;
+
+        public UnoObjectDefinition(Any _oUnoObject){
+            m_sTypeName = _oUnoObject.getType().getTypeName();
+            m_aTypeClass = _oUnoObject.getType().getTypeClass();
+            m_oUnoObject = _oUnoObject;
+        }
+
+        public UnoObjectDefinition(Object _oUnoObject, String _sTypeName, TypeClass _aTypeClass){
+            m_oUnoObject = _oUnoObject;
+            m_sTypeName = _sTypeName;
+            m_aTypeClass = _aTypeClass;
+        }
+
+        public UnoObjectDefinition(Object _oUnoObject, String _sTypeName){
+            m_oUnoObject = _oUnoObject;
+            m_sTypeName = _sTypeName;
+            m_aTypeClass = AnyConverter.getType(_oUnoObject).getTypeClass();
+        }
+
+
+        public Object getUnoObject(){
+            return m_oUnoObject;
+        }
+
+
+        public TypeClass getTypeClass(){
+            return m_aTypeClass;
+        }
+
+
+        public void setTypeName(String _sTypeName){
+            m_sTypeName = _sTypeName;
+        }
+
+        public String getTypeName(){
+            return m_sTypeName;
+        }
+
+        public String getVariableStemName(){
+            if (sVariableStemName.equals("")){
+                sVariableStemName = getVariableStemName(m_aTypeClass);
+            }
+            return sVariableStemName;
+        }
+
+
+        public String getVariableStemName(TypeClass _aTypeClass){
+            int nTypeClass = _aTypeClass.getValue();
+            switch(nTypeClass){
+                case TypeClass.BOOLEAN_value:
+                    sVariableStemName = "b" + SVARIABLENAME;
+                    break;
+                case TypeClass.DOUBLE_value:
+                case TypeClass.FLOAT_value:
+                    sVariableStemName = "f" + SVARIABLENAME;
+                    break;
+                case TypeClass.BYTE_value:
+                case TypeClass.HYPER_value:
+                case TypeClass.LONG_value:
+                case TypeClass.UNSIGNED_HYPER_value:
+                case TypeClass.UNSIGNED_LONG_value:
+                case TypeClass.UNSIGNED_SHORT_value:
+                case TypeClass.SHORT_value:
+                    sVariableStemName = "n" + SVARIABLENAME;
+                    break;
+                case TypeClass.CHAR_value:
+                case TypeClass.STRING_value:
+                    sVariableStemName = "s" + SVARIABLENAME;
+                    break;
+                case TypeClass.SEQUENCE_value:
+                    //TODO mehrdimensionale Arrays berücksichtigen!!!
+                    XTypeDescription xTypeDescription = Introspector.getIntrospector().getReferencedType(getTypeName());
+                    sVariableStemName = getVariableStemName(xTypeDescription.getTypeClass());
+                    break;
+                case TypeClass.ENUM_value:
+                    System.out.println("declare Enum Variable!!!");
+                    break;
+                case TypeClass.TYPE_value:
+                    sVariableStemName = "a" + SVARIABLENAME;
+                    break;
+                case TypeClass.ANY_value:
+                case TypeClass.INTERFACE_ATTRIBUTE_value:
+                case TypeClass.INTERFACE_METHOD_value:
+                case TypeClass.INTERFACE_value:
+                case TypeClass.STRUCT_value:
+                case TypeClass.PROPERTY_value:
+                    sVariableStemName = getVariableNameforUnoObject(getShortClassName(getTypeName()));
+
+                default:
+            }
+            return sVariableStemName;
+        }
+
+
+        private String getVariableName() throws NullPointerException{
+            if (sVariableName.equals("")){
+                boolean bleaveloop = false;
+                int a = 2;
+                sVariableName = getVariableStemName();
+                while (!bleaveloop){
+                    if (aVariables.containsKey(sVariableName)){
+                        String sUnoObjectIdentity = ((UnoObjectDefinition) aVariables.get(sVariableName)).getUnoObject().toString();
+                        if (sUnoObjectIdentity.equals(m_oUnoObject.toString())){
+                            bleaveloop = true;
+                        }
+                        else{
+                            sVariableName = getVariableStemName() + SSUFFIXSEPARATOR + a++;
+                        }
+                    }
+                    else{
+                        bleaveloop = true;
+        //                throw new NullPointerException("SourceCode Variable " + _sStemVariableName + " not defined");
+                    }
+                }
+            }
+            return sVariableName;
+        }
+    }
+
+
+    public String getStringValueOfObject(Object _oUnoObject, TypeClass _aTypeClass){
+        String sReturn = "";
+        switch (_aTypeClass.getValue()){
+            case TypeClass.BOOLEAN_value:
+                boolean bbooleanValue = ((Boolean) _oUnoObject).booleanValue();
+                sReturn += Boolean.toString(bbooleanValue);
+            case TypeClass.CHAR_value:
+                break;
+            case TypeClass.DOUBLE_value:
+                double fdoubleValue = ((Double) _oUnoObject).doubleValue();
+                sReturn += Double.toString(fdoubleValue);
+                break;
+            case TypeClass.ENUM_value:
+                break;
+            case TypeClass.FLOAT_value:
+                float floatValue = ((Float) _oUnoObject).floatValue();
+                sReturn += Float.toString(floatValue);
+                break;
+            case TypeClass.HYPER_value:
+                long nlongValue = ((Long) _oUnoObject).longValue();
+                sReturn += Long.toString(nlongValue);
+                break;
+            case TypeClass.LONG_value:
+                int  nintValue = ((Integer) _oUnoObject).intValue();
+                sReturn += Integer.toString(nintValue);
+                break;
+            case TypeClass.SHORT_value:
+                short  nshortValue = ((Short) _oUnoObject).shortValue();
+                sReturn += Short.toString(nshortValue);
+                break;
+            case TypeClass.STRING_value:
+                sReturn += "\"" + (String) _oUnoObject + "\"";
+                break;
+            case TypeClass.UNSIGNED_HYPER_value:
+                nlongValue = ((Long) _oUnoObject).longValue();
+                sReturn += Long.toString(nlongValue);
+                break;
+            case TypeClass.UNSIGNED_LONG_value:
+                nintValue = ((Integer) _oUnoObject).intValue();
+                sReturn += Integer.toString(nintValue);
+                break;
+            case TypeClass.UNSIGNED_SHORT_value:
+                nshortValue = ((Short) _oUnoObject).shortValue();
+                sReturn += Short.toString(nshortValue);
+                break;
+            default:
+                System.out.println("Type not yet defined!!!");
+        }
+        return sReturn;
+    }
+
+
+    public String getMethodParameterValueDescription(UnoMethodNode _oUnoMethodNode, boolean _bIncludeParameterNames){
+        String sParamSourceCode = "";
+        Object[] oParameterObjects = _oUnoMethodNode.getParameterValues();
+        ParamInfo[] aParamInfos = _oUnoMethodNode.getXIdlMethod().getParameterInfos();
+        for (int i = 0; i < oParameterObjects.length; i++){
+            TypeClass aTypeClass = aParamInfos[i].aType.getTypeClass();
+            if (_bIncludeParameterNames){
+                sParamSourceCode += aParamInfos[i].aName + "=";
+            }
+            sParamSourceCode += getStringValueOfObject(oParameterObjects[i], aTypeClass);
+            if (i < oParameterObjects.length - 1){
+                sParamSourceCode += ", ";
+            }
+        }
+        return sParamSourceCode;
+    }
+
+
+    private class JavaCodeGenerator implements XLanguageSourceCodeGenerator{
+        String sStatementsCode = "";
+
+        public JavaCodeGenerator(){
+        }
+
+        public String getHeaderSourceCode(Object _oUnoObject, String _sClassName){
+            String sClassName = _sClassName;
+            String sHeaderStatement = "";
+            if (!m_oIntrospector.isObjectPrimitive(_oUnoObject)){
+                if (m_oIntrospector.isObjectSequence(_oUnoObject)){
+                    XTypeDescription xTypeDescription = m_oIntrospector.getReferencedType(sClassName);
+                    if (m_oIntrospector.isPrimitive(xTypeDescription.getTypeClass())){
+                        return "";
+                    }
+                    else{
+                        sClassName = getTypeString(xTypeDescription.getName(), xTypeDescription.getTypeClass());
+                    }
+                }
+                sHeaderStatement =  "import " + sClassName + ";\n";
+            }
+            return sHeaderStatement;
+        }
+
+
+        public String getMainMethodSignatureSourceCode(UnoNode _oUnoNode, String _soReturnObjectDescription){
+            //TODO try to use + _oUnoNode.getClassName() instead of the hack
+            return "public void codesnippet(" + getanyTypeDescription() + " " +  _soReturnObjectDescription + "){";
+        }
+
+
+        public String getqueryInterfaceSourceCode(String _sShortClassName, String _sReturnVariableName, String _sIncomingObjectName){
+           return "\t" + _sReturnVariableName + " =  (" + _sShortClassName + ") UnoRuntime.queryInterface(" + _sShortClassName + ".class, " + _sIncomingObjectName + ");\n";
+        }
+
+
+        public String getPropertyValueGetterSourceCode(String _sPropertyName, String _sReturnVariableName, String _sIncomingObjectName){
+           return "\t" + _sReturnVariableName + " =  " + _sIncomingObjectName + ".getPropertyValue(\"" + _sPropertyName + "\");";
+        }
+
+
+        public String getObjectTypeDescription(String sShortClassName){
+            return sShortClassName;
+        }
+
+
+        public String getMethodTerminationSourceCode(){
+            return "\n}";
+        }
+
+        public String getbooleanTypeDescription(){
+            return  "boolean";
+        }
+
+        public String getbyteTypeDescription(){
+            return "byte";
+        }
+
+        public String getshortTypeDescription(){
+            return "short";
+        }
+
+        public String getunsignedshortTypeDescription(){
+            return "short";
+        }
+
+        public String getlongTypeDescription(){
+            return "int";
+        }
+
+        public String getunsignedlongTypeDescription(){
+            return "int";
+        }
+
+        public String gethyperTypeDescription(){
+            return "long";
+        }
+
+        public String getunsignedhyperTypeDescription(){
+            return "long";
+        }
+
+        public String getfloatTypeDescription(){
+            return "float";
+        }
+
+        public String getdoubleTypeDescription(){
+            return "double";
+        }
+
+        public String getcharTypeDescription(){
+            return "char";
+        }
+
+        public String getstringTypeDescription(){
+            return "String";
+        }
+
+        public String gettypeTypeDescription(){
+            //TODO com.sun.star.uno.Type has to be added to headerTypeDescriptions
+            return "Type";
+        }
+
+        public String getanyTypeDescription(){
+            return "Object";
+        }
+
+
+        public String getVariableDeclaration(String _sTypeString, String _sVariableName, boolean bIsArray){
+            String sReturn = "";
+            if (bIsArray){
+                sReturn = _sTypeString + "[] " + _sVariableName;
+            }
+            else{
+                sReturn = _sTypeString + " " + _sVariableName;
+            }
+            return sReturn;
+        }
+
+
+        public String getArrayDeclaration(String _sVariableDeclaration){
+            String sReturn = "";
+            String[] sDeclarations = _sVariableDeclaration.split(" ");
+            for (int i = 0; i< sDeclarations.length;i++){
+                sReturn += sDeclarations[i];
+                if (i == 0){
+                    sReturn += "[]";
+                }
+                if (i < (sDeclarations.length -1)){
+                    sReturn += " ";
+                }
+            }
+            return sReturn;
+        }
+    }
+}
\ No newline at end of file