INTEGRATION: CWS sdkinspector3 (1.3.6); FILE MERGED

2007/02/22 16:45:21 bc 1.3.6.4: #i74649#methodNode.isinvoked() method embedded
2007/02/20 11:17:56 bc 1.3.6.3: #i74649#several changes
2007/02/19 11:22:24 bc 1.3.6.2: #i74649# Sourcecode generation of Basic improved
2007/02/19 09:43:46 bc 1.3.6.1: #i74649#SourceCode generation improved

1 files changed, 1085 insertions, 120 deletions

diff --git a/odk/examples/java/Inspector/SourceCodeGenerator.java b/odk/examples/java/Inspector/SourceCodeGenerator.java
index b2895be3a18a..9fcf33cb6458 100644
--- a/odk/examples/java/Inspector/SourceCodeGenerator.java
+++ b/odk/examples/java/Inspector/SourceCodeGenerator.java
@@ -2,9 +2,9 @@
  *
  *  $RCSfile: SourceCodeGenerator.java,v $
  *
- *  $Revision: 1.3 $
+ *  $Revision: 1.4 $
  *
- *  last change: $Author: rt $ $Date: 2007-01-30 08:12:16 $
+ *  last change: $Author: rt $ $Date: 2007-04-04 09:20:37 $
  *
  *  The Contents of this file are made available subject to the terms of
  *  the BSD license.
@@ -38,7 +38,11 @@
  *
  *************************************************************************/
 
+import com.sun.star.beans.UnknownPropertyException;
+import com.sun.star.beans.XPropertySet;
 import com.sun.star.container.XNameAccess;
+import com.sun.star.lang.Locale;
+import com.sun.star.lang.WrappedTargetException;
 import com.sun.star.lang.XServiceInfo;
 import com.sun.star.reflection.ParamInfo;
 import com.sun.star.reflection.XIdlClass;
@@ -57,11 +61,13 @@ import java.util.Vector;
 
 
 public class SourceCodeGenerator {
-    private Vector sHeaderDescriptionVector = new Vector();
+    private Vector sExceptions = new Vector();
+    Vector sHeaderStatements = new HeaderStatements();
     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";
@@ -69,31 +75,38 @@ public class SourceCodeGenerator {
     private final String SUNOOBJECTNAME = "oUnobject";
     private final String SUNOSTRUCTNAME = "aUnoStruct";
     private Introspector m_oIntrospector;
+    private Vector aTreepathProviders = new Vector();
+    private XTreePathProvider xTreepathProvider = null;
+    private boolean baddExceptionHandling = false;
+    private boolean bXPropertySetExceptionsAreAdded = false;
+    private XUnoNode oInitialUnoNode = null;
+    private final String sINITIALVARIABLENAME = "_oUnoEntryObject";
 
 
     /** Creates a new instance of SourceCodeGenerator */
-    public SourceCodeGenerator() {
-        m_xLanguageSourceCodeGenerator = new JavaCodeGenerator();
+    public SourceCodeGenerator(int _nLanguage) {
+        this.setLanguage(_nLanguage);
         m_oIntrospector = Introspector.getIntrospector();
     }
 
 
-    public String addSourceCodeOfUnoObject(XTreePathProvider _xTreepathProvider){
+    public String addSourceCodeOfUnoObject(XTreePathProvider _xTreepathProvider, boolean _brememberPath, boolean _bAddMethodSignature, boolean _baddHeader){
         String sSourceCode = "";
         String sVariableName = "";
         if (_xTreepathProvider != null) {
             for (int i = 0; i < _xTreepathProvider.getPathCount(); i++){
                 XUnoNode oUnoNode = _xTreepathProvider.getPathComponent(i);
                 if (i == 0){
-                    sVariableName = "<UNOENTRYOBJECT>";
-                    sMainMethodSignature = m_xLanguageSourceCodeGenerator.getMainMethodSignatureSourceCode(oUnoNode, sVariableName);
+                    sVariableName = sINITIALVARIABLENAME;
+                    oInitialUnoNode = oUnoNode;
                 }
                 else{
                     if (oUnoNode instanceof XUnoMethodNode){
                         XUnoMethodNode oUnoMethodNode = (XUnoMethodNode) oUnoNode;
                         if (oUnoMethodNode.isInvoked()){
                             UnoObjectDefinition oUnoReturnObjectDefinition = getUnoObjectDefinition(_xTreepathProvider, oUnoMethodNode, i);
-                            if (!isVariableDeclared(oUnoReturnObjectDefinition)){
+                            if (!isVariableDeclared(oUnoReturnObjectDefinition, this.generateVariableNameFromMethod(oUnoMethodNode.getXIdlMethod()))){
+//                                sStatementCode += "\n";
                                 sStatementCode += "\n" + getMethodStatementSourceCode(oUnoMethodNode, sVariableName, oUnoReturnObjectDefinition);
                             }
                             sVariableName = oUnoReturnObjectDefinition.getVariableName();
@@ -103,7 +116,8 @@ public class SourceCodeGenerator {
                         XUnoPropertyNode oUnoPropertyNode = (XUnoPropertyNode) oUnoNode;
                         Any oReturnObject = com.sun.star.uno.Any.complete(oUnoPropertyNode.getUnoReturnObject());
                         UnoObjectDefinition oUnoReturnObjectDefinition = new UnoObjectDefinition(oReturnObject);
-                        if (!isVariableDeclared(oUnoReturnObjectDefinition)){
+                        if (!isVariableDeclared(oUnoReturnObjectDefinition, oUnoPropertyNode.getProperty().Name)){
+//                            sStatementCode += "\n";
                             sStatementCode += "\n" + getPropertyStatementSourceCode(oUnoPropertyNode, sVariableName, oUnoReturnObjectDefinition);
                         }
                         sVariableName = oUnoReturnObjectDefinition.getVariableName();
@@ -111,11 +125,107 @@ public class SourceCodeGenerator {
                 }
             }
         }
-        String sCompleteCode = combineCompleteSourceCode();
+        String sCompleteCode = combineCompleteSourceCode(sMainMethodSignature, _baddHeader);
+        xTreepathProvider = _xTreepathProvider;
+        if (_brememberPath){
+            aTreepathProviders.add(_xTreepathProvider);
+        }
         return sCompleteCode;
     }
 
 
+    private void setLanguage(int _nLanguage){
+        XLanguageSourceCodeGenerator xLanguageSourceCodeGenerator = null;
+        switch(_nLanguage){
+            case XLanguageSourceCodeGenerator.nJAVA:
+                xLanguageSourceCodeGenerator = new JavaCodeGenerator();
+                break;
+            case XLanguageSourceCodeGenerator.nCPLUSPLUS:
+                xLanguageSourceCodeGenerator = new CPlusPlusCodeGenerator();
+                break;
+            case XLanguageSourceCodeGenerator.nBASIC:
+                xLanguageSourceCodeGenerator = new BasicCodeGenerator();
+                break;
+            default:
+                System.out.println("Unknown Sourcecode Language. Check Menus!");
+        }
+        if (xLanguageSourceCodeGenerator != null){
+            m_xLanguageSourceCodeGenerator = xLanguageSourceCodeGenerator;
+        }
+    }
+
+    private void resetSourceCodeGeneration(int _nLanguage){
+        aVariables.clear();
+        this.sHeaderStatements.clear();
+        setLanguage(_nLanguage);
+        String sHeaderCode = "";
+        sStatementCode = "";
+    }
+
+    private String generateVariableNameFromMethod(String _sMethodName, String _sPrefix, boolean _bConsiderAll){
+        String sReturn = "";
+        if (_sMethodName.startsWith(_sPrefix)){
+            int nPrefixLength = _sPrefix.length();
+            if (_sMethodName.length() > nPrefixLength){
+                String sChar = _sMethodName.substring(nPrefixLength, nPrefixLength + 1);
+                String sUpperChar = sChar.toUpperCase();
+                if (sUpperChar.equals(sChar)){
+                    if (_bConsiderAll){
+                        sReturn = _sMethodName;
+                    }
+                    else{
+                        sReturn = _sMethodName.substring(nPrefixLength, _sMethodName.length());
+                    }
+                }
+            }
+        }
+        return sReturn;
+    }
+
+
+    private String generateVariableNameFromMethod(XIdlMethod _xIdlMethod){
+        // todo: refactor this!!!
+        String sMethodName = _xIdlMethod.getName();
+        String sReturn = "";
+        sReturn = generateVariableNameFromMethod(sMethodName, "getBy", false);
+        if (sReturn.equals("")){
+            sReturn = generateVariableNameFromMethod(sMethodName, "get", false);
+        }
+        if (sReturn.equals("")){
+            sReturn = generateVariableNameFromMethod(sMethodName, "attach", false);
+        }
+        if (sReturn.equals("")){
+            sReturn = generateVariableNameFromMethod(sMethodName, "assign", false);
+        }
+        if (sReturn.equals("")){
+            sReturn = generateVariableNameFromMethod(sMethodName, "attach", false);
+        }
+        if (sReturn.equals("")){
+            sReturn = generateVariableNameFromMethod(sMethodName, "create", false);
+        }
+        if (sReturn.equals("")){
+            sReturn = generateVariableNameFromMethod(sMethodName, "is", true);
+        }
+        if (sReturn.equals("")){
+            sReturn = generateVariableNameFromMethod(sMethodName, "has", true);
+        }
+        if (sReturn.equals("")){
+            sReturn = sMethodName;
+        }
+        return sReturn;
+    }
+
+
+    public String convertAllUnoObjects(int _nLanguage){
+        String sSourceCode = "";
+        resetSourceCodeGeneration(_nLanguage);
+        int ncount = aTreepathProviders.size();
+        for (int i=0; i< ncount; i++){
+            sSourceCode = addSourceCodeOfUnoObject((XTreePathProvider) aTreepathProviders.get(i), false, (i==0), (i == (ncount-1)));
+    }
+        return sSourceCode;
+    }
+
     private UnoObjectDefinition getUnoObjectDefinition(XTreePathProvider _xTreePathProvider, XUnoMethodNode _oUnoMethodNode, int _nindex){
         XUnoNode oUnoNode = null;
         Object oUnoReturnObject = null;
@@ -148,12 +258,19 @@ public class SourceCodeGenerator {
     }
 
 
-    private String combineCompleteSourceCode(){
+    private String combineCompleteSourceCode(String _sMethodSignature, boolean _bAddHeader){
         String sCompleteCode = "";
-        sCompleteCode  += getHeaderSourceCode();
+        if (_bAddHeader){
+            sMainMethodSignature = m_xLanguageSourceCodeGenerator.getMainMethodSignatureSourceCode(oInitialUnoNode, sINITIALVARIABLENAME);
+            m_xLanguageSourceCodeGenerator.assignqueryInterfaceHeaderSourceCode();
+            sCompleteCode += getHeaderSourceCode();
+        }
         sCompleteCode += sMainMethodSignature;
         sCompleteCode += sStatementCode;
-        sCompleteCode += m_xLanguageSourceCodeGenerator.getMethodTerminationSourceCode();
+        if (_bAddHeader){
+            sCompleteCode += m_xLanguageSourceCodeGenerator.getMethodTerminationSourceCode();
+            sCompleteCode += "\n" + m_xLanguageSourceCodeGenerator.getCommentSign() + "...";
+        }
         return sCompleteCode;
     }
 
@@ -161,17 +278,23 @@ public class SourceCodeGenerator {
     public String getPropertyStatementSourceCode(XUnoPropertyNode _oUnoPropertyNode, String _sVariableName, UnoObjectDefinition _oUnoReturnObjectDefinition){
         String sReturnObjectVariableDefinition = "";
         String sStatement = "";
+        String sPropertyName = _oUnoPropertyNode.getProperty().Name;
         UnoObjectDefinition oUnoObjectDefinition = new UnoObjectDefinition(_oUnoPropertyNode.getUnoObject(), "com.sun.star.beans.XPropertySet");
-        if (!isVariableDeclared(oUnoObjectDefinition)){
-            String sObjectVariableDefinition = getVariableDeclaration(oUnoObjectDefinition);
-            String sNewVariableName = _oUnoReturnObjectDefinition.getVariableName();
-            sStatement += m_xLanguageSourceCodeGenerator.getqueryInterfaceSourceCode("XPropertySet", sObjectVariableDefinition, _sVariableName);
-        }
-        if (_oUnoReturnObjectDefinition.getTypeClass().getValue() != TypeClass.VOID_value){
-            sReturnObjectVariableDefinition = getVariableInitialization(_oUnoReturnObjectDefinition) + " = ";
-        }
-        sStatement += m_xLanguageSourceCodeGenerator.getPropertyValueGetterSourceCode(_oUnoPropertyNode.getProperty().Name, sReturnObjectVariableDefinition, oUnoObjectDefinition.getVariableName());
-        return sStatement;
+            if (!m_xLanguageSourceCodeGenerator.needsqueryInterface() || (oUnoObjectDefinition.getTypeClass().getValue() == TypeClass.STRUCT_value)){
+                oUnoObjectDefinition.setVariableName(_sVariableName);
+                if (oUnoObjectDefinition.getTypeClass().getValue() == TypeClass.STRUCT_value){
+                    sReturnObjectVariableDefinition = getVariableInitialization(_oUnoReturnObjectDefinition, false);
+                    sStatement += m_xLanguageSourceCodeGenerator.getStructSourceCode(sReturnObjectVariableDefinition, oUnoObjectDefinition.getVariableName(), sPropertyName);
+                    return sStatement;
+                }
+            }
+            sStatement += addQueryInterfaceSourceCode(oUnoObjectDefinition, _sVariableName, "com.sun.star.beans.XPropertySet");
+            if (_oUnoReturnObjectDefinition.getTypeClass().getValue() != TypeClass.VOID_value){
+                sReturnObjectVariableDefinition = getVariableInitialization(_oUnoReturnObjectDefinition, true);
+            }
+            sStatement += m_xLanguageSourceCodeGenerator.getPropertyValueGetterSourceCode(sPropertyName, sReturnObjectVariableDefinition, oUnoObjectDefinition.getVariableName(), _oUnoReturnObjectDefinition.getTypeClass(), _oUnoReturnObjectDefinition.getTypeName());
+            addXPropertySetRelatedExceptions();
+            return sStatement;
     }
 
 
@@ -181,41 +304,79 @@ public class SourceCodeGenerator {
         XIdlMethod xIdlMethod = _oUnoMethodNode.getXIdlMethod();
         TypeClass aReturnTypeClass = xIdlMethod.getReturnType().getTypeClass();
         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, _sVariableName);
+        String sVariableStemName = this.generateVariableNameFromMethod(xIdlMethod);
+        sStatement += addQueryInterfaceSourceCode(oUnoObjectDefinition, _sVariableName, oUnoObjectDefinition.getTypeName());
+        if (_oUnoReturnObjectDefinition.getTypeClass().getValue() != TypeClass.VOID_value){
+            sReturnObjectVariableDefinition = getVariableInitialization(_oUnoReturnObjectDefinition, false) + " = ";
         }
         Object[] oParamObjects = _oUnoReturnObjectDefinition.getParameterObjects();
         String sParameterCode = getMethodParameterValueDescription(_oUnoMethodNode, oParamObjects, false);
-        if (_oUnoReturnObjectDefinition.getTypeClass().getValue() != TypeClass.VOID_value){
-            sReturnObjectVariableDefinition = getVariableInitialization(_oUnoReturnObjectDefinition) + " = ";
-        }
-        sStatement += "\t" + sReturnObjectVariableDefinition + oUnoObjectDefinition.getVariableName() + "." + xIdlMethod.getName() + "(" + sParameterCode + ");";
+        String sSeparator = m_xLanguageSourceCodeGenerator.getMethodSeparator();
+        sStatement += "\t" + sReturnObjectVariableDefinition + oUnoObjectDefinition.getVariableName() + sSeparator + xIdlMethod.getName() + "(" + sParameterCode + ")";
+        sStatement += m_xLanguageSourceCodeGenerator.getStatementTerminationCharacter();
+        addExceptions(xIdlMethod);
         return sStatement;
     }
 
 
+    private String addQueryInterfaceSourceCode(UnoObjectDefinition _oUnoObjectDefinition, String _sVariableName,  String _sTypeName){
+        String sLocStatement = "";
+        if (m_xLanguageSourceCodeGenerator.needsqueryInterface()){
+            if (!isVariableDeclared(_oUnoObjectDefinition, "")){
+                String sObjectVariableDefinition = getVariableDeclaration(_oUnoObjectDefinition, false, "");
+                sLocStatement += m_xLanguageSourceCodeGenerator.getqueryInterfaceSourceCode(_sTypeName, sObjectVariableDefinition, _sVariableName);
+            }
+        }
+        else{
+            _oUnoObjectDefinition.setVariableName(_sVariableName);
+        }
+        return sLocStatement;
+    }
+
+
+    private void addXPropertySetRelatedExceptions(){
+        if (!bXPropertySetExceptionsAreAdded){
+            sExceptions.add("com.sun.star.beans.UnknownPropertyException");
+            sExceptions.add("com.sun.star.lang.WrappedTargetException");
+            sExceptions.add("com.sun.star.lang.IllegalArgumentException");
+            bXPropertySetExceptionsAreAdded = true;
+            baddExceptionHandling = true;
+        }
+    }
+
+
+    private void addExceptions(XIdlMethod _xIdlMethod){
+        XIdlClass[] xIdlClasses = _xIdlMethod.getExceptionTypes();
+        for (int i = 0; i > xIdlClasses.length; i++){
+            sExceptions.add(xIdlClasses[0].getName());
+            baddExceptionHandling = true;
+        }
+    }
+
     private String getRootDescription(XUnoNode _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(), oUnoObjectDefinition.getTypeClass());
-            if (!sHeaderStatements.contains(sCurHeaderStatement)){
-                sHeaderSourcecode += sCurHeaderStatement;
-                sHeaderStatements.add(sCurHeaderStatement);
-            }
+            String sCurHeaderStatement = m_xLanguageSourceCodeGenerator.getHeaderSourceCode(oUnoObjectDefinition.getUnoObject(), oUnoObjectDefinition.getTypeName(), oUnoObjectDefinition.getTypeClass());
+            sHeaderStatements.add(sCurHeaderStatement);
         }
-        return sHeaderSourcecode +"\n";
+        String sHeaderSourcecode = "";
+        String[] sHeaderStatementArray = new String[sHeaderStatements.size()];
+        sHeaderStatements.toArray(sHeaderStatementArray);
+        java.util.Arrays.sort(sHeaderStatementArray);
+        for (int i = 0; i < sHeaderStatementArray.length; i++){
+            sHeaderSourcecode += sHeaderStatementArray[i];
+        }
+        sHeaderSourcecode += m_xLanguageSourceCodeGenerator.getFinalHeaderStatements();
+        return sHeaderSourcecode +"\n" + m_xLanguageSourceCodeGenerator.getCommentSign() + "...\n";
     }
 
+
     private class HeaderStatements extends Vector{
 
         public boolean contains(Object _oElement){
@@ -228,13 +389,27 @@ public class SourceCodeGenerator {
            }
            return false;
        }
+
+
+       public boolean add(Object _oElement){
+           if (_oElement instanceof String){
+                if (!contains(_oElement)){
+                    super.add(_oElement);
+                    return true;
+                }
+           }
+           return false;
+       }
     }
 
 
-    private boolean isVariableDeclared(UnoObjectDefinition _oUnoObjectDefinition){
+    private boolean isVariableDeclared(UnoObjectDefinition _oUnoObjectDefinition, String _sDefaultStemName){
         boolean bisDeclared = false;
-        String sVariableName = _oUnoObjectDefinition.getVariableStemName();
-        bisDeclared = aVariables.containsKey(sVariableName);
+        if (!_sDefaultStemName.equals("")){
+            _oUnoObjectDefinition.setCentralVariableStemName(_sDefaultStemName);
+        }
+        String sVariableStemName = _oUnoObjectDefinition.getVariableStemName();
+        bisDeclared = aVariables.containsKey(sVariableStemName);
         if (bisDeclared){
             Object oUnoObject = _oUnoObjectDefinition.getUnoObject();
             if (m_oIntrospector.isObjectPrimitive(oUnoObject)){
@@ -244,7 +419,7 @@ public class SourceCodeGenerator {
                 bisDeclared = false;
             }
             else{
-                String sCompVariableName = sVariableName;
+                String sCompVariableName = sVariableStemName;
                 String sUnoObjectIdentity = oUnoObject.toString();
                 boolean bleaveloop = false;
                 int a = 2;
@@ -255,7 +430,7 @@ public class SourceCodeGenerator {
                         bleaveloop = sUnoCompObjectIdentity.equals(sUnoObjectIdentity);
                         bisDeclared = bleaveloop;
                         if (!bleaveloop){
-                            sCompVariableName = sVariableName + SSUFFIXSEPARATOR + a++;
+                            sCompVariableName = sVariableStemName + SSUFFIXSEPARATOR + a++;
                         }
                     }
                     else{
@@ -284,11 +459,6 @@ public class SourceCodeGenerator {
     }
 
 
-    private String getVariableDeclaration(UnoObjectDefinition _oUnoObjectDefinition){
-        TypeClass aTypeClass = _oUnoObjectDefinition.getTypeClass();
-        return getVariableDeclaration(_oUnoObjectDefinition, aTypeClass);
-    }
-
 
     private String getTypeString(String _sTypeName, TypeClass _aTypeClass, boolean _bAsHeaderSourceCode){
         String sTypeString = "";
@@ -332,33 +502,33 @@ public class SourceCodeGenerator {
             case TypeClass.SEQUENCE_value:
                 //TODO consider mulitdimensional Arrays
                 XTypeDescription xTypeDescription = Introspector.getIntrospector().getReferencedType(_sTypeName);
-                sTypeString = getTypeString(xTypeDescription.getName(), xTypeDescription.getTypeClass(), _bAsHeaderSourceCode);
-                break;
-            case TypeClass.ENUM_value:
-                System.out.println("declare Enum Variable!!!");
+                if (xTypeDescription != null){
+                    sTypeString = getTypeString(xTypeDescription.getName(), xTypeDescription.getTypeClass(), _bAsHeaderSourceCode);
+                }
                 break;
             case TypeClass.ANY_value:
-            case TypeClass.STRUCT_value:
                 sTypeString = m_xLanguageSourceCodeGenerator.getanyTypeDescription(_bAsHeaderSourceCode);
                 break;
+            case TypeClass.TYPE_value:
+                sTypeString = m_xLanguageSourceCodeGenerator.getObjectTypeDescription("com.sun.star.uno.Type", _bAsHeaderSourceCode);
+                break;
+            case TypeClass.ENUM_value:
+            case TypeClass.STRUCT_value:
             case TypeClass.INTERFACE_ATTRIBUTE_value:
             case TypeClass.INTERFACE_METHOD_value:
             case TypeClass.INTERFACE_value:
             case TypeClass.PROPERTY_value:
-            case TypeClass.TYPE_value:
-                if (_bAsHeaderSourceCode){
-                    sTypeString = m_xLanguageSourceCodeGenerator.getObjectTypeDescription(_sTypeName);
-                }
-                else{
-                    sTypeString = m_xLanguageSourceCodeGenerator.getObjectTypeDescription(getShortClassName(_sTypeName));
-                }
+                sTypeString = m_xLanguageSourceCodeGenerator.getObjectTypeDescription(_sTypeName, _bAsHeaderSourceCode);
+                break;
             default:
         }
         return sTypeString;
     }
 
 
-    private String getVariableDeclaration(UnoObjectDefinition _oUnoObjectDefinition, TypeClass _aTypeClass){
+    private String getVariableDeclaration(UnoObjectDefinition _oUnoObjectDefinition, boolean _bInitialize, String _sVariableDefaultName){
+        TypeClass aTypeClass = _oUnoObjectDefinition.getTypeClass();
+        TypeClass aLocTypeClass = aTypeClass;
         boolean bIsArray = false;
         if (_oUnoObjectDefinition.getUnoObject() != null){
             bIsArray = m_oIntrospector.isObjectSequence(_oUnoObjectDefinition.getUnoObject());
@@ -366,37 +536,34 @@ public class SourceCodeGenerator {
         else{
             bIsArray = _oUnoObjectDefinition.getTypeClass().getValue() == TypeClass.SEQUENCE_value;
         }
-        String sVariableName = _oUnoObjectDefinition.getVariableName();
+        String sVariableName = _oUnoObjectDefinition.getVariableName(_sVariableDefaultName);
         String sTypeName = _oUnoObjectDefinition.getTypeName();
-        String sTypeString = getTypeString(sTypeName, _aTypeClass, false);
-        String sVariableDeclaration = m_xLanguageSourceCodeGenerator.getVariableDeclaration(sTypeString, sVariableName, bIsArray);
+        String sTypeString = getTypeString(sTypeName, aLocTypeClass, false);
+        if (bIsArray){
+            XTypeDescription xTypeDescription = Introspector.getIntrospector().getReferencedType(sTypeName);
+            if (xTypeDescription != null){
+                aLocTypeClass = xTypeDescription.getTypeClass();
+            }
+        }
+        String sVariableDeclaration = m_xLanguageSourceCodeGenerator.getVariableDeclaration(sTypeString, sVariableName, bIsArray, aLocTypeClass, _bInitialize);
         addUniqueVariableName(sVariableName, _oUnoObjectDefinition);
         return sVariableDeclaration;
     }
 
 
-    public String getVariableInitialization(UnoObjectDefinition _oUnoObjectDefinition){
+    public String getVariableInitialization(UnoObjectDefinition _oUnoObjectDefinition, boolean _bInitialize){
         String sObjectVariableDeclaration = "";
-        String sVariableStemName = _oUnoObjectDefinition.getVariableStemName();
-        if (isVariableDeclared(_oUnoObjectDefinition)){
-            sObjectVariableDeclaration = sVariableStemName;
+        String sVariableName = _oUnoObjectDefinition.getVariableName();
+        if (isVariableDeclared(_oUnoObjectDefinition, "")){
+            sObjectVariableDeclaration = sVariableName;
         }
         else{
-            sObjectVariableDeclaration =  getVariableDeclaration(_oUnoObjectDefinition);
+            sObjectVariableDeclaration =  getVariableDeclaration(_oUnoObjectDefinition, _bInitialize, "");
         }
         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")){
@@ -412,15 +579,18 @@ class UnoObjectDefinition{
         Object m_oUnoObject = null;
         Type aType = null;
         String sVariableStemName = "";
+        String m_sCentralVariableStemName = "";
         String sVariableName = "";
         String m_sTypeName = "";
         TypeClass m_aTypeClass = null;
         Object[] m_oParameterObjects = null;
 
+
         public UnoObjectDefinition(Any _oUnoObject){
             m_sTypeName = _oUnoObject.getType().getTypeName();
             m_aTypeClass = _oUnoObject.getType().getTypeClass();
             m_oUnoObject = _oUnoObject;
+            m_sCentralVariableStemName = getCentralVariableStemName(m_aTypeClass);
         }
 
 
@@ -428,6 +598,7 @@ class UnoObjectDefinition{
             m_oUnoObject = _oUnoObject;
             m_sTypeName = _sTypeName;
             m_aTypeClass = _aTypeClass;
+            m_sCentralVariableStemName = getCentralVariableStemName(m_aTypeClass);
         }
 
 
@@ -435,6 +606,37 @@ class UnoObjectDefinition{
             m_oUnoObject = _oUnoObject;
             m_sTypeName = _sTypeName;
             m_aTypeClass = AnyConverter.getType(_oUnoObject).getTypeClass();
+            m_sCentralVariableStemName = getCentralVariableStemName(m_aTypeClass);
+        }
+
+
+        private String getCentralVariableStemName(TypeClass _aTypeClass){
+            String sCentralVariableStemName = "";
+            int nTypeClass = _aTypeClass.getValue();
+            switch(nTypeClass){
+                case TypeClass.SEQUENCE_value:
+                    //TODO consider mulitdimensional Arrays
+                    XTypeDescription xTypeDescription = Introspector.getIntrospector().getReferencedType(getTypeName());
+                    if (xTypeDescription != null){
+                        sCentralVariableStemName = getCentralVariableStemName(xTypeDescription.getTypeClass());
+                    }
+                    break;
+                case TypeClass.TYPE_value:
+                    sCentralVariableStemName = SVARIABLENAME;
+                    break;
+                case TypeClass.STRUCT_value:
+                    sCentralVariableStemName = Introspector.getShortClassName(getTypeName());
+                    break;
+                case TypeClass.INTERFACE_ATTRIBUTE_value:
+                case TypeClass.INTERFACE_METHOD_value:
+                case TypeClass.INTERFACE_value:
+            case TypeClass.PROPERTY_value:
+                    String sShortClassName = m_oIntrospector.getShortClassName(getTypeName());
+                    sCentralVariableStemName = getVariableNameforUnoObject(sShortClassName);
+                default:
+                    sCentralVariableStemName = SVARIABLENAME;
+            }
+            return sCentralVariableStemName;
         }
 
         /** may return null
@@ -466,6 +668,11 @@ class UnoObjectDefinition{
         }
 
 
+        public void setCentralVariableStemName(String _sCentralVariableStemName){
+            m_sCentralVariableStemName = _sCentralVariableStemName;
+        }
+
+
         public String getVariableStemName(){
             if (sVariableStemName.equals("")){
                 sVariableStemName = getVariableStemName(m_aTypeClass);
@@ -497,11 +704,11 @@ class UnoObjectDefinition{
             int nTypeClass = _aTypeClass.getValue();
             switch(nTypeClass){
                 case TypeClass.BOOLEAN_value:
-                    sVariableStemName = "b" + SVARIABLENAME;
+                    sVariableStemName = "b" + m_sCentralVariableStemName;
                     break;
                 case TypeClass.DOUBLE_value:
                 case TypeClass.FLOAT_value:
-                    sVariableStemName = "f" + SVARIABLENAME;
+                    sVariableStemName = "f" + m_sCentralVariableStemName;
                     break;
                 case TypeClass.BYTE_value:
                 case TypeClass.HYPER_value:
@@ -510,34 +717,35 @@ class UnoObjectDefinition{
                 case TypeClass.UNSIGNED_LONG_value:
                 case TypeClass.UNSIGNED_SHORT_value:
                 case TypeClass.SHORT_value:
-                    sVariableStemName = "n" + SVARIABLENAME;
+                    sVariableStemName = "n" + m_sCentralVariableStemName;
                     break;
                 case TypeClass.CHAR_value:
                 case TypeClass.STRING_value:
-                    sVariableStemName = "s" + SVARIABLENAME;
+                    sVariableStemName = "s" + m_sCentralVariableStemName;
                     break;
                 case TypeClass.SEQUENCE_value:
                     //TODO consider mulitdimensional Arrays
                     XTypeDescription xTypeDescription = Introspector.getIntrospector().getReferencedType(getTypeName());
-                    sVariableStemName = getVariableStemName(xTypeDescription.getTypeClass());
-                    break;
-                case TypeClass.ENUM_value:
-                    System.out.println("declare Enum Variable!!!");
+                    if (xTypeDescription != null){
+                        sVariableStemName = getVariableStemName(xTypeDescription.getTypeClass());
+                    }
                     break;
                 case TypeClass.TYPE_value:
-                    sVariableStemName = "a" + SVARIABLENAME;
+                    sVariableStemName = "a" + m_sCentralVariableStemName;
                     break;
                 case TypeClass.ANY_value:
-                    sVariableStemName = SUNOOBJECTNAME;
+                    sVariableStemName = "o" + m_sCentralVariableStemName;
                     break;
                 case TypeClass.STRUCT_value:
-                    sVariableStemName = SUNOSTRUCTNAME;
+                case TypeClass.ENUM_value:
+                    sVariableStemName = "a" + m_sCentralVariableStemName;
                     break;
                 case TypeClass.INTERFACE_ATTRIBUTE_value:
                 case TypeClass.INTERFACE_METHOD_value:
                 case TypeClass.INTERFACE_value:
                 case TypeClass.PROPERTY_value:
-                    sVariableStemName = getVariableNameforUnoObject(getShortClassName(getTypeName()));
+                    String sShortClassName = m_oIntrospector.getShortClassName(getTypeName());
+                    sVariableStemName = getVariableNameforUnoObject(sShortClassName);
                 default:
             }
             return sVariableStemName;
@@ -549,6 +757,14 @@ class UnoObjectDefinition{
         }
 
 
+        private String getVariableName(String _sCentralVariableStemName){
+            if (!_sCentralVariableStemName.equals("")){
+                this.m_sCentralVariableStemName = _sCentralVariableStemName;
+            }
+            return getVariableName();
+        }
+
+
         private String getVariableName() throws NullPointerException{
             if (sVariableName.equals("")){
                 int a = 2;
@@ -558,7 +774,8 @@ class UnoObjectDefinition{
                     if (aVariables.containsKey(sVariableName)){
                         String sUnoObjectIdentity = ((UnoObjectDefinition) aVariables.get(sVariableName)).getUnoObject().toString();
                         if (m_oUnoObject != null){
-                            if (sUnoObjectIdentity.equals(m_oUnoObject.toString())){
+                            if ((sUnoObjectIdentity.equals(m_oUnoObject.toString()) && (!m_oIntrospector.isPrimitive(this.getTypeClass())) &&
+                                (! m_oIntrospector.isObjectSequence(m_oUnoObject)))){
                                 bleaveloop = true;
                             }
                             else{
@@ -611,7 +828,7 @@ class UnoObjectDefinition{
                 sReturn += Short.toString(nshortValue);
                 break;
             case TypeClass.STRING_value:
-                sReturn += "\"" + (String) _oUnoObject + "\"";
+                sReturn +=  (String) _oUnoObject;
                 break;
             case TypeClass.UNSIGNED_HYPER_value:
                 nlongValue = ((Long) _oUnoObject).longValue();
@@ -626,7 +843,7 @@ class UnoObjectDefinition{
                 sReturn += Short.toString(nshortValue);
                 break;
             default:
-                System.out.println("Type not yet defined!!!");
+                System.out.println("Type " + _aTypeClass.getValue() + " not yet defined in 'getStringValueOfObject()'");
         }
         return sReturn;
     }
@@ -641,7 +858,10 @@ class UnoObjectDefinition{
                 if (_bIncludeParameterNames){
                     sParamSourceCode += aParamInfos[i].aName + "=";
                 }
-                sParamSourceCode += getStringValueOfObject(_oParamObjects[i], aTypeClass);
+                String sParamDescription = getStringValueOfObject(_oParamObjects[i], aTypeClass);
+                sParamDescription = this.m_xLanguageSourceCodeGenerator.castLiteral(sParamDescription, aTypeClass);
+                sParamSourceCode += sParamDescription;
+
                 if (i < _oParamObjects.length - 1){
                     sParamSourceCode += ", ";
                 }
@@ -651,12 +871,21 @@ class UnoObjectDefinition{
     }
 
 
-    private class JavaCodeGenerator implements XLanguageSourceCodeGenerator{
+    public class JavaCodeGenerator implements XLanguageSourceCodeGenerator{
         String sStatementsCode = "";
+        boolean bAddAnyConverter = false;
+//        boolean bAddTypeImport = false;
+        boolean bIsPropertyUnoObjectDefined = false;
 
         public JavaCodeGenerator(){
         }
 
+
+        public String getStatementTerminationCharacter(){
+            return ";";
+        }
+
+
         public String getHeaderSourceCode(Object _oUnoObject, String _sClassName, TypeClass _aTypeClass){
             String sClassName = _sClassName;
             String sHeaderStatement = "";
@@ -664,50 +893,223 @@ class UnoObjectDefinition{
                 if (!m_oIntrospector.isObjectPrimitive(_oUnoObject)){
                     if (m_oIntrospector.isObjectSequence(_oUnoObject)){
                         XTypeDescription xTypeDescription = m_oIntrospector.getReferencedType(sClassName);
-                        if (!m_oIntrospector.isPrimitive(xTypeDescription.getTypeClass())){
-                            sClassName = getTypeString(xTypeDescription.getName(), xTypeDescription.getTypeClass(), true);
-                        }
-                        // primitive Types are not supposed to turn up in the import section...
-                        else{
-                            sClassName = "";
+                        if (xTypeDescription != null){
+                            if (!m_oIntrospector.isPrimitive(xTypeDescription.getTypeClass())){
+                                sClassName = getTypeString(xTypeDescription.getName(), xTypeDescription.getTypeClass(), true);
+                            }
+                            // primitive Types are not supposed to turn up in the import section...
+                            else{
+                                sClassName = "";
+                            }
                         }
                     }
                     else{
                         sClassName = getTypeString(_sClassName, _aTypeClass, true);
                     }
-                    if (!sClassName.equals("")){
-                        sHeaderStatement =  "import " + sClassName + ";\n";
-                    }
+                }
+                else if (_aTypeClass.getValue() == TypeClass.ENUM_value){
+                    sClassName = _sClassName;
+                }
+                else{
+                    sClassName = "";
+                }
+                if (!sClassName.equals("")){
+                    sHeaderStatement =  "import " + sClassName + ";\n";
                 }
             }
             return sHeaderStatement;
         }
 
 
+        public String getFinalHeaderStatements(){
+            return "";
+        }
+
+
+        public void assignqueryInterfaceHeaderSourceCode(){
+            sHeaderStatements.add("import com.sun.star.uno.UnoRuntime;\n");
+            sHeaderStatements.add("import com.sun.star.uno.XInterface;\n");
+            if (bAddAnyConverter){
+                sHeaderStatements.add("import com.sun.star.uno.AnyConverter;\n");
+            }
+        }
+
+
+
+    public String getConvertedSourceCodeValueOfObject(String _sReturnVariableName, String _sObjectDescription, TypeClass _aTypeClass, String _sTypeName){
+        boolean bLocAddAnyConverter = true;
+        String sReturn = "";
+        switch (_aTypeClass.getValue()){
+            case TypeClass.BOOLEAN_value:
+                sReturn = _sReturnVariableName + " = AnyConverter.toBoolean(" + _sObjectDescription + ")";
+                break;
+            case TypeClass.CHAR_value:
+                sReturn = _sReturnVariableName + " = AnyConverter.toChar(" + _sObjectDescription + ")";
+                break;
+            case TypeClass.BYTE_value:
+                sReturn = _sReturnVariableName + " = AnyConverter.toByte(" + _sObjectDescription + ")";
+                break;
+            case TypeClass.DOUBLE_value:
+                sReturn = _sReturnVariableName + " = AnyConverter.toDouble(" + _sObjectDescription + ")";
+                break;
+            case TypeClass.FLOAT_value:
+                sReturn = _sReturnVariableName + " = AnyConverter.toFloat(" + _sObjectDescription + ")";
+                break;
+            case TypeClass.UNSIGNED_HYPER_value:
+                sReturn = _sReturnVariableName + " = AnyConverter.toUnsignedLong(" + _sObjectDescription + ")";
+                break;
+            case TypeClass.HYPER_value:
+                sReturn = _sReturnVariableName + " = AnyConverter.toLong(" + _sObjectDescription + ")";
+                break;
+            case TypeClass.UNSIGNED_LONG_value:
+                sReturn = _sReturnVariableName + " = AnyConverter.toUnsignedInt(" + _sObjectDescription + ")";
+                break;
+            case TypeClass.LONG_value:
+                sReturn = _sReturnVariableName + " = AnyConverter.toInt(" + _sObjectDescription + ")";
+                break;
+            case TypeClass.SHORT_value:
+                sReturn = _sReturnVariableName + " = AnyConverter.toShort(" + _sObjectDescription + ")";
+                break;
+            case TypeClass.UNSIGNED_SHORT_value:
+                sReturn = _sReturnVariableName + " = AnyConverter.toUnsignedShort(" + _sObjectDescription + ")";
+                break;
+            case TypeClass.STRING_value:
+                sReturn = _sReturnVariableName + " = AnyConverter.toString(" + _sObjectDescription + ")";
+                break;
+            default:
+                String sShortTypeName = Introspector.getShortClassName(_sTypeName);
+                if (bIsPropertyUnoObjectDefined){
+                    sReturn = "oUnoObject = " + _sObjectDescription + ";\n\t";
+                }
+                else{
+                    sReturn = "Object oUnoObject = " + _sObjectDescription + ";\n\t";
+                    bIsPropertyUnoObjectDefined = true;
+                }
+                sReturn += _sReturnVariableName + " = (" + sShortTypeName + ") AnyConverter.toObject(" + sShortTypeName + ".class, oUnoObject);";
+//                this.bAddTypeImport = true;
+                break;
+        }
+        if (!bAddAnyConverter){
+            bAddAnyConverter = bLocAddAnyConverter;
+        }
+        return sReturn;
+    }
+
+
+        public String getStructSourceCode(String _sReturnVariableDescription, String _sObjectDescription, String _sMember){
+            return  "\t" + _sReturnVariableDescription + " = " + _sObjectDescription + "." + _sMember + ";";
+        }
+
         public String getMainMethodSignatureSourceCode(XUnoNode _oUnoNode, String _soReturnObjectDescription){
             //TODO try to use + _oUnoNode.getClassName() instead of the hack
-            return "public void codesnippet(" + getanyTypeDescription(false) + " " +  _soReturnObjectDescription + "){";
+            String sReturn = "public void codesnippet(XInterface " +  _soReturnObjectDescription + "){";
+            if (baddExceptionHandling){
+                sReturn += "\ntry{";
+            }
+            return sReturn;
         }
 
+        public String getMethodSeparator(){
+            return ".";
+        }
+
+        public boolean needsqueryInterface(){
+            return true;
+        }
 
-        public String getqueryInterfaceSourceCode(String _sShortClassName, String _sReturnVariableName, String _sIncomingObjectName){
-           return "\t" + _sReturnVariableName + " =  (" + _sShortClassName + ") UnoRuntime.queryInterface(" + _sShortClassName + ".class, " + _sIncomingObjectName + ");\n";
+        public String getqueryInterfaceSourceCode(String _sClassName, String _sReturnVariableName, String _sIncomingObjectName){
+            String sShortClassName = m_oIntrospector.getShortClassName(_sClassName);
+            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 getPropertyValueGetterSourceCode(String _sPropertyName, String _sReturnVariableName, String _sIncomingObjectName, TypeClass _aTypeClass, String _sTypeName){
+            String sObjectDescription = _sIncomingObjectName + ".getPropertyValue(\"" + _sPropertyName + "\")";
+            String sReturn = getConvertedSourceCodeValueOfObject(_sReturnVariableName, sObjectDescription,  _aTypeClass, _sTypeName);
+            sReturn += ";";
+            sReturn = "\t" + sReturn;
+            return sReturn;
+//           return "\t" + _sReturnVariableName + " =  " + _sIncomingObjectName + ".getPropertyValue(\"" + _sPropertyName + "\");";
         }
 
 
-        public String getObjectTypeDescription(String sShortClassName){
-            return sShortClassName;
+        public String getObjectTypeDescription(String _sClassName, boolean _bAsHeader){
+            String sReturn = "";
+            if (_bAsHeader){
+                sReturn = _sClassName;
+            }
+            else{
+                sReturn = m_oIntrospector.getShortClassName(_sClassName);
+            }
+            return sReturn;
         }
 
 
         public String getMethodTerminationSourceCode(){
-            return "\n}";
+            String sReturn = "";
+            int nIndex = 1;
+            String sExceptionName = "e";
+            if (baddExceptionHandling){
+                for (int i = 0; i < sExceptions.size(); i++){
+                    String sCurException = (String) sExceptions.get(i);
+                    if (sReturn.indexOf(sCurException) == -1){
+                        if (nIndex > 1){
+                            sExceptionName = "e"+ nIndex;
+                        }
+                        else{
+                            sReturn +="\n}";
+                        }
+                        sReturn += "catch (" + sCurException + " " + sExceptionName + "){\n";
+                        sReturn += "\t" + sExceptionName + ".printStackTrace(System.out);\n";
+                        sReturn += "\t" + getCommentSign() + "Enter your Code here...\n}";
+                        nIndex++;
+                    }
+                }
+            }
+            sReturn += "\n}";
+            return sReturn;
+        }
+
+        public String castLiteral(String _sExpression, TypeClass _aTypeClass){
+        String sReturn = "";
+        switch (_aTypeClass.getValue()){
+            case TypeClass.BOOLEAN_value:
+                sReturn = _sExpression;
+                break;
+            case TypeClass.BYTE_value:
+                sReturn = "(byte) " + _sExpression;
+                break;
+            case TypeClass.CHAR_value:
+                sReturn = "'" + _sExpression + "'";
+                break;
+            case TypeClass.DOUBLE_value:
+                sReturn = "(double) " + _sExpression;
+                break;
+            case TypeClass.FLOAT_value:
+                sReturn = "(float) " + _sExpression;
+                break;
+            case TypeClass.UNSIGNED_SHORT_value:
+            case TypeClass.SHORT_value:
+                sReturn = "(short) " + _sExpression;
+                break;
+            case TypeClass.STRING_value:
+                sReturn = "\"" + _sExpression + "\"";
+                break;
+            case TypeClass.HYPER_value:
+            case TypeClass.UNSIGNED_HYPER_value:
+                sReturn = "(long) " + _sExpression;
+                break;
+            case TypeClass.LONG_value:
+                sReturn = _sExpression;
+                break;
+            case TypeClass.ENUM_value:
+            default:
+                sReturn = _sExpression;
+                System.out.println("Type " + _aTypeClass.getValue() + " not yet defined in 'castliteral()'");
         }
+        return sReturn;
+    }
+
 
         public String getbooleanTypeDescription(){
             return  "boolean";
@@ -762,9 +1164,13 @@ class UnoObjectDefinition{
             }
         }
 
-        public String gettypeTypeDescription(){
-            //TODO com.sun.star.uno.Type has to be added to headerTypeDescriptions
-            return "Type";
+        public String gettypeTypeDescription(boolean _bAsHeaderSourceCode){
+            if (_bAsHeaderSourceCode){
+                return "com.sun.star.uno.Type";
+            }
+            else{
+                return "Type";
+            }
         }
 
         public String getanyTypeDescription(boolean _bAsHeaderSourceCode){
@@ -777,9 +1183,14 @@ class UnoObjectDefinition{
         }
 
 
-        public String getVariableDeclaration(String _sTypeString, String _sVariableName, boolean bIsArray){
+        public String getStringValue(String _sValue){
+            return _sValue;
+        }
+
+
+        public String getVariableDeclaration(String _sTypeString, String _sVariableName, boolean _bIsArray, TypeClass _aTypeClass, boolean _bInitialize){
             String sReturn = "";
-            if (bIsArray){
+            if (_bIsArray){
                 sReturn = _sTypeString + "[] " + _sVariableName;
             }
             else{
@@ -803,5 +1214,559 @@ class UnoObjectDefinition{
             }
             return sReturn;
         }
+
+        public String getCommentSign(){
+            return "//";
+        }
+    }
+
+
+    public class BasicCodeGenerator implements XLanguageSourceCodeGenerator{
+        String sStatementsCode = "";
+
+        public BasicCodeGenerator(){
+        }
+
+        public String getHeaderSourceCode(Object _oUnoObject, String _sClassName, TypeClass _aTypeClass){
+            String sHeaderStatement = "";
+            return sHeaderStatement;
+        }
+
+        public String getFinalHeaderStatements(){
+            return "";
+        }
+
+        public String getMainMethodSignatureSourceCode(XUnoNode _oUnoNode, String _soReturnObjectDescription){
+            //TODO try to use + _oUnoNode.getClassName() instead of the hack
+            return "Sub Main(" +  _soReturnObjectDescription +  " as " +  getanyTypeDescription(false) + ")";
+        }
+
+        public boolean needsqueryInterface(){
+            return false;
+        }
+
+        public void assignqueryInterfaceHeaderSourceCode(){
+        }
+
+        public String getMethodSeparator(){
+            return ".";
+        }
+
+
+        public String getqueryInterfaceSourceCode(String _sClassName, String _sReturnVariableName, String _sIncomingObjectName){
+            return _sIncomingObjectName;
+        }
+
+
+        public String getPropertyValueGetterSourceCode(String _sPropertyName, String _sReturnVariableName, String _sIncomingObjectName, TypeClass _aTypeClass, String _sTypeName){
+           return "\t" + _sReturnVariableName + " =  " + _sIncomingObjectName + "."  + _sPropertyName;
+        }
+
+
+        public String getStructSourceCode(String _sReturnVariableDescription, String _sObjectDescription, String _sMember){
+            return getPropertyValueGetterSourceCode(_sMember, _sReturnVariableDescription, _sObjectDescription, null, "" );
+        }
+
+        public String getConvertedSourceCodeValueOfObject(String _sReturnVariableName, String _sObjectDescription, TypeClass _aTypeClass, String _sTypeName){
+            return _sReturnVariableName + " = " + _sObjectDescription;
+        }
+
+
+        public String getObjectTypeDescription(String _sClassName, boolean _bAsHeader){
+            return "Object";
+        }
+
+
+        public String getMethodTerminationSourceCode(){
+            return "\nEnd Sub\n";
+        }
+
+
+        public String castLiteral(String _sExpression, TypeClass _aTypeClass){
+        String sReturn = "";
+        switch (_aTypeClass.getValue()){
+            case TypeClass.BOOLEAN_value:
+            case TypeClass.BYTE_value:
+            case TypeClass.DOUBLE_value:
+            case TypeClass.FLOAT_value:
+            case TypeClass.UNSIGNED_SHORT_value:
+            case TypeClass.SHORT_value:
+            case TypeClass.LONG_value:
+            case TypeClass.UNSIGNED_LONG_value:
+            case TypeClass.HYPER_value:
+            case TypeClass.UNSIGNED_HYPER_value:
+                sReturn = _sExpression;
+                break;
+            case TypeClass.CHAR_value:
+            case TypeClass.STRING_value:
+                sReturn =  "\"" +_sExpression + "\"";
+                break;
+            case TypeClass.ENUM_value:
+            default:
+                sReturn = _sExpression;
+                System.out.println("Type " + _aTypeClass.getValue() + " not yet defined in 'castliteral()'");
+        }
+        return sReturn;
+    }
+
+
+
+        public String getbooleanTypeDescription(){
+            return  "Boolean";
+        }
+
+        public String getbyteTypeDescription(){
+            return "Integer";
+        }
+
+        public String getshortTypeDescription(){
+            return "Integer";
+        }
+
+        public String getunsignedshortTypeDescription(){
+            return "Integer";
+        }
+
+        public String getlongTypeDescription(){
+            return "Integer";
+        }
+
+        public String getunsignedlongTypeDescription(){
+            return "Long";
+        }
+
+        public String gethyperTypeDescription(){
+            return "Long";
+        }
+
+        public String getunsignedhyperTypeDescription(){
+            return "Long";
+        }
+
+        public String getfloatTypeDescription(){
+            return "Double";
+        }
+
+        public String getdoubleTypeDescription(){
+            return "Double";
+        }
+
+        public String getcharTypeDescription(){
+            return "String";
+        }
+
+        public String getstringTypeDescription(boolean _bAsHeaderSourceCode){
+            if (_bAsHeaderSourceCode){
+                return "";
+            }
+            else{
+                return "String";
+            }
+        }
+
+        public String gettypeTypeDescription(boolean _bAsHeaderSourceCode){
+            if (_bAsHeaderSourceCode){
+                return "";
+            }
+            else{
+                return "Object";
+            }
+        }
+
+        public String getanyTypeDescription(boolean _bAsHeaderSourceCode){
+            if (_bAsHeaderSourceCode){
+                return "";
+            }
+            else{
+                return "Object";
+            }
+        }
+
+        public String getStatementTerminationCharacter(){
+            return "";
+        }
+
+
+        public String getVariableDeclaration(String _sTypeString, String _sVariableName, boolean bIsArray, TypeClass _aTypeClass, boolean _bInitialize){
+            String sReturn = "";
+            if (bIsArray){
+                sReturn = "Dim " + _sVariableName + "() as " + _sTypeString + "\n\t" + _sVariableName;
+            }
+            else{
+                sReturn = "Dim " + _sVariableName + " as " + _sTypeString + "\n\t" + _sVariableName;
+            }
+            return sReturn;
+        }
+
+
+        public String getStringValue(String _sValue){
+            return _sValue;
+        }
+
+
+        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;
+        }
+
+        public String getCommentSign(){
+            return "'";
+        }
+
+    }
+
+    public class CPlusPlusCodeGenerator implements XLanguageSourceCodeGenerator{
+        String sStatementsCode = "";
+        boolean bIncludeStringHeader = false;
+        boolean bIncludeAny = false;
+        boolean bIncludeSequenceHeader = false;
+
+        public CPlusPlusCodeGenerator(){
+        }
+
+        private String getCSSNameSpaceString(){
+            return "css";
+        }
+
+        public String getStatementTerminationCharacter(){
+            return ";";
+        }
+
+
+        public String getHeaderSourceCode(Object _oUnoObject, String _sClassName, TypeClass _aTypeClass){
+            String sClassName = _sClassName;
+            String sHeaderStatement = "";
+            if (_oUnoObject != null){
+                if (!m_oIntrospector.isObjectPrimitive(_oUnoObject)){
+                    if (m_oIntrospector.isObjectSequence(_oUnoObject)){
+                        XTypeDescription xTypeDescription = m_oIntrospector.getReferencedType(sClassName);
+                        if (xTypeDescription != null){
+                            if (!m_oIntrospector.isPrimitive(xTypeDescription.getTypeClass())){
+                                sClassName = getTypeString(xTypeDescription.getName(), xTypeDescription.getTypeClass(), true);
+                            }
+                            // primitive Types are not supposed to turn up in the import section...
+                            else{
+                                sClassName = "";
+                            }
+                        }
+                    }
+                    else{
+                        sClassName = getTypeString(_sClassName, _aTypeClass, true);
+                    }
+                    if (!sClassName.equals("")){
+                        sHeaderStatement =  getHeaderOfClass(sClassName);
+                    }
+                }
+            }
+            return sHeaderStatement;
+        }
+
+
+
+        public String getFinalHeaderStatements(){
+            String sReturn = "";
+            sReturn += "\nnamespace " + getCSSNameSpaceString() + " = com::sun::star;\n";
+            sReturn += "using namespace rtl;\n";
+            return sReturn;
+        }
+
+
+        private String getHeaderOfClass(String _sClassName){
+            return "#include \"" + _sClassName.replace('.', '/') + ".hpp\"\n";     // #include <com/sun/star/uno/XComponentContext.hpp>
+        }
+
+
+
+        public void assignqueryInterfaceHeaderSourceCode(){
+            sHeaderStatements.add("#include \"sal/config.h\"\n");
+            sHeaderStatements.add("#include \"sal/types.h\"\n");
+            if (bIncludeStringHeader){
+                sHeaderStatements.add("#include \"rtl/ustring.hxx\"\n");
+            }
+            sHeaderStatements.add("#include \"com/sun/star/uno/Reference.hxx\"\n");
+            if (bIncludeSequenceHeader){
+                sHeaderStatements.add("#include \"com/sun/star/uno/Sequence.hxx\"\n");
+            }
+            sHeaderStatements.add(getHeaderOfClass("com.sun.star.uno.XInterface"));
+            if (bIncludeAny){
+                sHeaderStatements.add(getHeaderOfClass("com.sun.star.uno.Any"));
+            }
+        }
+
+
+        public String getMainMethodSignatureSourceCode(XUnoNode _oUnoNode, String _soReturnObjectDescription){
+            String sReturn = "";
+            sReturn = "void codesnippet(const " + getCSSNameSpaceString() + "::uno::Reference<" + getCSSNameSpaceString() + "::uno::XInterface>& "  +  _soReturnObjectDescription + " ){";
+            int a = 0;
+            if (!sExceptions.contains("com.sun.star.uno.RuntimeException")){
+                sExceptions.add("com.sun.star.uno.RuntimeException");
+            }
+            if (baddExceptionHandling){
+                sReturn += "\n//throw ";
+                for (int i = 0; i < sExceptions.size(); i++){
+                    String sCurException = (String) sExceptions.get(i);
+                    if (sReturn.indexOf(sCurException) == -1){
+                        if (a++ > 0){
+                            sReturn += ", ";
+                        }
+                        sReturn += getObjectTypeDescription(sCurException, false);
+
+                    }
+                }
+
+            }
+            sReturn += "{";
+            return sReturn;
+        }
+
+
+        public boolean needsqueryInterface(){
+            return true;
+        }
+
+
+        public String getqueryInterfaceSourceCode(String _sClassName, String _sReturnVariableName, String _sIncomingObjectName){
+            return "\t" + _sReturnVariableName + "( " + _sIncomingObjectName + ", " + getCSSNameSpaceString() + "::uno::UNO_QUERY_THROW);\n";
+        }
+
+
+        public String getPropertyValueGetterSourceCode(String _sPropertyName, String _sReturnVariableName, String _sIncomingObjectName, TypeClass _aTypeClass, String _sTypeName){
+            String sFirstLine = "\t";
+            String sReturnVariableName = _sReturnVariableName;
+            // e.g. uno::Any a = xPropSet->getPropertyValue( rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "DefaultContext" )) );
+            String[] sVarDefinition = _sReturnVariableName.split("=");
+            if (sVarDefinition.length > 0){
+                String sVariable = sVarDefinition[0];
+                String[] sVarDeclaration = sVariable.split(" ");
+                if (sVarDeclaration.length > 0){
+                    sFirstLine += sReturnVariableName + ";\n";
+                    sReturnVariableName = sVarDeclaration[sVarDeclaration.length-1];
+                }
+            }
+            String sObjectDescription = _sIncomingObjectName + "->getPropertyValue(" + getStringValue(_sPropertyName) + ")";
+            String sSecondLine = "\t" + getConvertedSourceCodeValueOfObject(sReturnVariableName, sObjectDescription,  _aTypeClass, _sTypeName) + ";";
+            return sFirstLine + sSecondLine;
+        }
+
+
+        public String getStructSourceCode(String _sReturnVariableDescription, String _sObjectDescription, String _sMember){
+            return "\t" + _sReturnVariableDescription + " = " + _sObjectDescription + "->" + _sMember + ";";
+        }
+
+
+        public String getConvertedSourceCodeValueOfObject(String _sReturnVariableName, String _sObjectDescription, TypeClass _aTypeClass, String _sTypeName){
+//            if (m_oIntrospector.isPrimitive(_aTypeClass)){
+                return _sObjectDescription + " >>= " + _sReturnVariableName;
+//            }
+//            else{
+//                return _sReturnVariableName + " = " + _sObjectDescription;
+//            }
+        }
+
+
+        public String getStringValue(String _sValue){
+            bIncludeStringHeader = true;
+            return "OUString(RTL_CONSTASCII_USTRINGPARAM(\"" + _sValue + "\"))";
+        }
+
+
+        public String getObjectTypeDescription(String _sClassName, boolean _bAsHeader){
+            String sReturn = "";
+            if (_bAsHeader){
+                sReturn = _sClassName.replace('.', '/');
+            }
+            else{
+                String sModuleName = m_oIntrospector.getModuleName(_sClassName);
+                sModuleName = m_oIntrospector.getShortClassName(sModuleName);
+                sReturn = getCSSNameSpaceString() + "::" + sModuleName + "::" + m_oIntrospector.getShortClassName(_sClassName);
+            }
+            return sReturn;
+        }
+
+
+        public String getMethodTerminationSourceCode(){
+            return "\n}";
+        }
+
+        public String getMethodSeparator(){
+            return "->";
+        }
+
+
+        public String castLiteral(String _sExpression, TypeClass _aTypeClass){
+        String sReturn = "";
+        switch (_aTypeClass.getValue()){
+            case TypeClass.BOOLEAN_value:
+            case TypeClass.BYTE_value:
+            case TypeClass.DOUBLE_value:
+            case TypeClass.FLOAT_value:
+            case TypeClass.UNSIGNED_SHORT_value:
+            case TypeClass.SHORT_value:
+            case TypeClass.LONG_value:
+            case TypeClass.UNSIGNED_LONG_value:
+            case TypeClass.HYPER_value:
+            case TypeClass.UNSIGNED_HYPER_value:
+                sReturn = _sExpression;
+                break;
+            case TypeClass.CHAR_value:
+                sReturn = "'" + _sExpression + "'";
+                break;
+            case TypeClass.STRING_value:
+                sReturn = getStringValue(_sExpression);
+                break;
+            case TypeClass.ENUM_value:
+            default:
+                sReturn = _sExpression;
+                System.out.println("Type " + _aTypeClass.getValue() + " not yet defined in 'castliteral()'");
+        }
+        return sReturn;
+    }
+
+        public String getbooleanTypeDescription(){
+            return  "sal_Bool";
+        }
+
+        public String getbyteTypeDescription(){
+            return "sal_Int8";
+        }
+
+        public String getshortTypeDescription(){
+            return "sal_Int16";
+        }
+
+        public String getunsignedshortTypeDescription(){
+            return "sal_uInt16";
+        }
+
+        public String getlongTypeDescription(){
+            return "sal_Int32";
+        }
+
+        public String getunsignedlongTypeDescription(){
+            return "sal_uInt32";
+        }
+
+        public String gethyperTypeDescription(){
+            return "sal_Int64";
+        }
+
+        public String getunsignedhyperTypeDescription(){
+            return "sal_uInt64";
+        }
+
+        public String getfloatTypeDescription(){
+            return "float";
+        }
+
+        public String getdoubleTypeDescription(){
+            return "double";
+        }
+
+        public String getcharTypeDescription(){
+            return "sal_Unicode";
+        }
+
+        public String getstringTypeDescription(boolean _bAsHeaderSourceCode){
+            bIncludeStringHeader = true;
+            if (_bAsHeaderSourceCode){
+                return "";
+            }
+            else{
+                return "OUString";
+            }
+        }
+
+        public String gettypeTypeDescription(boolean _bAsHeaderSourceCode){
+            if (_bAsHeaderSourceCode){
+                return "com/sun/star/uno/Type";
+            }
+            else{
+                return "Type";
+            }
+        }
+
+        public String getanyTypeDescription(boolean _bAsHeaderSourceCode){
+            if (_bAsHeaderSourceCode){
+                    return "com/sun/star/uno/XInterface";
+            }
+            else{
+                return "XInterface";
+            }
+        }
+
+
+        public String getVariableDeclaration(String _sTypeString, String _sVariableName, boolean bIsArray, TypeClass _aTypeClass, boolean _bInitialize){
+            boolean bIsPrimitive = m_oIntrospector.isPrimitive(_aTypeClass);
+
+            // uno::Reference< frame::XDispatch >    m_xDispatch
+            String sReturn = "";
+            if (bIsArray){
+                bIncludeSequenceHeader = true;
+                sReturn = getCSSNameSpaceString() + "::uno::Sequence<" + _sTypeString + "> " + _sVariableName;
+            }
+            else{
+                if (bIsPrimitive){
+                    sReturn = _sTypeString + " " + _sVariableName;
+                    if (_bInitialize){
+                        switch (_aTypeClass.getValue()){
+                            case TypeClass.BOOLEAN_value:
+                                sReturn = sReturn + " = false";
+                                break;
+                            case TypeClass.BYTE_value:
+                            case TypeClass.UNSIGNED_SHORT_value:
+                            case TypeClass.SHORT_value:
+                            case TypeClass.LONG_value:
+                            case TypeClass.UNSIGNED_LONG_value:
+                            case TypeClass.HYPER_value:
+                            case TypeClass.UNSIGNED_HYPER_value:
+                                sReturn = sReturn + " = 0";
+                                break;
+                            case TypeClass.DOUBLE_value:
+                            case TypeClass.FLOAT_value:
+                                sReturn = sReturn + " = 0.0";
+                                break;
+                            case TypeClass.CHAR_value:
+                                sReturn = sReturn + "'0'";
+                                break;
+                            case TypeClass.STRING_value:
+                                sReturn = _sTypeString + " " + _sVariableName;
+                                break;
+                            default:
+                                sReturn = _sTypeString + " " + _sVariableName;
+                                System.out.println("Type " + _aTypeClass.getValue() + " not yet defined in 'getVariableDeclaration()'");
+                        }
+                    }
+                }
+                else{
+                    sReturn = getCSSNameSpaceString() + "::uno::Reference<" + _sTypeString + "> "  +_sVariableName;
+                }
+            }
+            return sReturn;
+        }
+
+        public String getArrayDeclaration(String _sVariableDeclaration){
+            this.bIncludeSequenceHeader = true;
+            String sReturn = "";
+            String[] sDeclarations = _sVariableDeclaration.split(" ");
+            if (sDeclarations.length == 2){
+                sReturn = getCSSNameSpaceString() +"::uno::Sequence<" + sDeclarations[1] + ">";
+            }
+            return sReturn;
+        }
+
+        public String getCommentSign(){
+            return "//";
+        }
+
     }
-}
\ No newline at end of file
+}