/**************************************************************
 * 
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 * 
 *   http://www.apache.org/licenses/LICENSE-2.0
 * 
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 * 
 *************************************************************/


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;
import com.sun.star.reflection.XIdlMethod;
import com.sun.star.reflection.XTypeDescription;
import com.sun.star.text.XTextTablesSupplier;
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 com.sun.star.uno.UnoRuntime;
import java.util.Enumeration;
import java.util.Hashtable;
import java.util.Vector;


public class SourceCodeGenerator {
    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";
    private final String SARRAYVARIABLENAME = "VariableNameList";    
    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(int _nLanguage) {
        this.setLanguage(_nLanguage);
        m_oIntrospector = Introspector.getIntrospector();
    }
    

    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 = sINITIALVARIABLENAME;
                    oInitialUnoNode = oUnoNode;
                }
                else{
                    if (oUnoNode instanceof XUnoMethodNode){
                        XUnoMethodNode oUnoMethodNode = (XUnoMethodNode) oUnoNode;
                        if (oUnoMethodNode.isInvoked()){
                            UnoObjectDefinition oUnoReturnObjectDefinition = getUnoObjectDefinition(_xTreepathProvider, oUnoMethodNode, i);
                            if (!isVariableDeclared(oUnoReturnObjectDefinition, this.generateVariableNameFromMethod(oUnoMethodNode.getXIdlMethod()))){
//                                sStatementCode += "\n";
                                sStatementCode += "\n" + getMethodStatementSourceCode(oUnoMethodNode, sVariableName, oUnoReturnObjectDefinition);
                            }
                            sVariableName = oUnoReturnObjectDefinition.getVariableName();
                        }
                    }
                    else if (oUnoNode instanceof XUnoPropertyNode){     
                        XUnoPropertyNode oUnoPropertyNode = (XUnoPropertyNode) oUnoNode;
                        Any oReturnObject = com.sun.star.uno.Any.complete(oUnoPropertyNode.getUnoReturnObject());
                        UnoObjectDefinition oUnoReturnObjectDefinition = new UnoObjectDefinition(oReturnObject);
                        if (!isVariableDeclared(oUnoReturnObjectDefinition, oUnoPropertyNode.getProperty().Name)){
//                            sStatementCode += "\n";
                            sStatementCode += "\n" + getPropertyStatementSourceCode(oUnoPropertyNode, sVariableName, oUnoReturnObjectDefinition);
                        }
                        sVariableName = oUnoReturnObjectDefinition.getVariableName();
                    }
                }
            }
        } 
        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;
        Object[] oParamObjects = null;
        XIdlClass xIdlClass = _oUnoMethodNode.getXIdlMethod().getReturnType();
        String sTypeName = xIdlClass.getName();
        TypeClass aTypeClass = xIdlClass.getTypeClass();
        if (aTypeClass.getValue() != TypeClass.VOID_value){
            if (_xTreePathProvider.getPathCount() > _nindex + 1){
                oUnoNode = _xTreePathProvider.getPathComponent(_nindex + 1);
                oUnoReturnObject = oUnoNode.getUnoObject();
            }
        }
        if (oUnoReturnObject == null){
            oUnoReturnObject = _oUnoMethodNode.getLastUnoReturnObject();
        }
        UnoObjectDefinition oUnoObjectDefinition = new UnoObjectDefinition(oUnoReturnObject, sTypeName, aTypeClass);
        if (_oUnoMethodNode.hasParameters()){
            if (oUnoNode != null){
                oParamObjects = oUnoNode.getParameterObjects();
            }
            else{
                oParamObjects = _oUnoMethodNode.getLastParameterObjects();
            }
        }
        if (oParamObjects != null){
            oUnoObjectDefinition.addParameterObjects(oParamObjects);
        }
        return oUnoObjectDefinition;
    }
    
    
    private String combineCompleteSourceCode(String _sMethodSignature, boolean _bAddHeader){
        String sCompleteCode = "";
        if (_bAddHeader){
            sMainMethodSignature = m_xLanguageSourceCodeGenerator.getMainMethodSignatureSourceCode(oInitialUnoNode, sINITIALVARIABLENAME);          
            m_xLanguageSourceCodeGenerator.assignqueryInterfaceHeaderSourceCode();
            sCompleteCode += getHeaderSourceCode();
        }
        sCompleteCode += sMainMethodSignature;
        sCompleteCode += sStatementCode;
        if (_bAddHeader){
            sCompleteCode += m_xLanguageSourceCodeGenerator.getMethodTerminationSourceCode();
            sCompleteCode += "\n" + m_xLanguageSourceCodeGenerator.getCommentSign() + "...";   
        }
        return sCompleteCode;
    }

    
    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 (!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;
    }
    
    
    public String getMethodStatementSourceCode(XUnoMethodNode _oUnoMethodNode, String _sVariableName, UnoObjectDefinition _oUnoReturnObjectDefinition){
        String sReturnObjectVariableDefinition = "";
        String sStatement = "";
        XIdlMethod xIdlMethod = _oUnoMethodNode.getXIdlMethod();
        TypeClass aReturnTypeClass = xIdlMethod.getReturnType().getTypeClass();
        UnoObjectDefinition oUnoObjectDefinition = new UnoObjectDefinition(_oUnoMethodNode.getUnoObject(), _oUnoMethodNode.getClassName());
        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);
        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(){
        Enumeration aEnumeration = aVariables.elements();
        while(aEnumeration.hasMoreElements()){
            UnoObjectDefinition oUnoObjectDefinition = (UnoObjectDefinition) aEnumeration.nextElement();
            String sCurHeaderStatement = m_xLanguageSourceCodeGenerator.getHeaderSourceCode(oUnoObjectDefinition.getUnoObject(), oUnoObjectDefinition.getTypeName(), oUnoObjectDefinition.getTypeClass());
            sHeaderStatements.add(sCurHeaderStatement);
        }
        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){
           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;
       }
        
        
       public boolean add(Object _oElement){
           if (_oElement instanceof String){
                if (!contains(_oElement)){
                    super.add(_oElement);
                    return true;
                }
           }
           return false;
       }
    }    
    
    
    private boolean isVariableDeclared(UnoObjectDefinition _oUnoObjectDefinition, String _sDefaultStemName){
        boolean bisDeclared = false;
        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)){
                bisDeclared = false;
            }
            else if (m_oIntrospector.isObjectSequence(oUnoObject)){
                bisDeclared = false;
            }
            else{
                String sCompVariableName = sVariableStemName;
                String sUnoObjectIdentity = oUnoObject.toString();
                boolean bleaveloop = false;
                int a = 2;
                while (!bleaveloop){
                    if (aVariables.containsKey(sCompVariableName)){
                        Object oUnoCompObject = ((UnoObjectDefinition) aVariables.get(sCompVariableName)).getUnoObject();
                        String sUnoCompObjectIdentity = oUnoCompObject.toString();
                        bleaveloop = sUnoCompObjectIdentity.equals(sUnoObjectIdentity);
                        bisDeclared = bleaveloop;
                        if (!bleaveloop){
                            sCompVariableName = sVariableStemName + SSUFFIXSEPARATOR + a++;
                        }
                    }
                    else{
                        bleaveloop = true;
                        bisDeclared = false;
                    }
                }
            }
        }
        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 getTypeString(String _sTypeName, TypeClass _aTypeClass, boolean _bAsHeaderSourceCode){      
        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(_bAsHeaderSourceCode);                
                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 consider mulitdimensional Arrays
                XTypeDescription xTypeDescription = Introspector.getIntrospector().getReferencedType(_sTypeName);
                if (xTypeDescription != null){
                    sTypeString = getTypeString(xTypeDescription.getName(), xTypeDescription.getTypeClass(), _bAsHeaderSourceCode);
                }
                break;                
            case TypeClass.ANY_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:
                sTypeString = m_xLanguageSourceCodeGenerator.getObjectTypeDescription(_sTypeName, _bAsHeaderSourceCode);
                break;
            default:                                                    
        }
        return sTypeString;
    }    
        
    
    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());
        }
        else{
            bIsArray = _oUnoObjectDefinition.getTypeClass().getValue() == TypeClass.SEQUENCE_value;
        }
        String sVariableName = _oUnoObjectDefinition.getVariableName(_sVariableDefaultName);
        String sTypeName = _oUnoObjectDefinition.getTypeName();
        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, boolean _bInitialize){
        String sObjectVariableDeclaration = "";
        String sVariableName = _oUnoObjectDefinition.getVariableName();
        if (isVariableDeclared(_oUnoObjectDefinition, "")){
            sObjectVariableDeclaration = sVariableName;
        }
        else{
            sObjectVariableDeclaration =  getVariableDeclaration(_oUnoObjectDefinition, _bInitialize, "");
        }
        return sObjectVariableDeclaration;
    }
    
       
    public String getVariableNameforUnoObject(String _sShortClassName){
        if (_sShortClassName.startsWith("X")){
            return  "x" + _sShortClassName.substring(1);
        }
        else{
            return _sShortClassName;
        }
    }
    
    
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);
        }
        
        
        public UnoObjectDefinition(Object _oUnoObject, String _sTypeName, TypeClass _aTypeClass){
            m_oUnoObject = _oUnoObject;
            m_sTypeName = _sTypeName;
            m_aTypeClass = _aTypeClass;
            m_sCentralVariableStemName = getCentralVariableStemName(m_aTypeClass);
        }

        
        public UnoObjectDefinition(Object _oUnoObject, String _sTypeName){
            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
         */
        public Object getUnoObject(){
            return m_oUnoObject;
        }

        
        public void setTypeClass(TypeClass _aTypeClass){
            sVariableStemName = "";
            m_aTypeClass = _aTypeClass;
        }
        
        
        public TypeClass getTypeClass(){
            return m_aTypeClass;
        }
        
        
        public void setTypeName(String _sTypeName){
            sVariableStemName = "";
            m_sTypeName = _sTypeName;
        }        
        
        
        public String getTypeName(){
            return m_sTypeName;
        }        
        
        
        public void setCentralVariableStemName(String _sCentralVariableStemName){
            m_sCentralVariableStemName = _sCentralVariableStemName;
        }
        
        
        public String getVariableStemName(){
            if (sVariableStemName.equals("")){
                sVariableStemName = getVariableStemName(m_aTypeClass);
            }
            return sVariableStemName;
        }
        
        
        public void addParameterObjects(Object[] _oParameterObjects){
            m_oParameterObjects = _oParameterObjects;
        }

        
        public Object[] getParameterObjects(){
            return m_oParameterObjects;
        }

        
        public boolean hasParameterObjects(){
            boolean breturn = false;
            if (m_oParameterObjects != null){
                breturn = m_oParameterObjects.length > 0;
            }
            return breturn;
        }
        
        
        public String getVariableStemName(TypeClass _aTypeClass){
            int nTypeClass = _aTypeClass.getValue();
            switch(nTypeClass){
                case TypeClass.BOOLEAN_value:
                    sVariableStemName = "b" + m_sCentralVariableStemName;
                    break;
                case TypeClass.DOUBLE_value:
                case TypeClass.FLOAT_value:
                    sVariableStemName = "f" + m_sCentralVariableStemName;
                    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" + m_sCentralVariableStemName;
                    break;                                
                case TypeClass.CHAR_value:
                case TypeClass.STRING_value:
                    sVariableStemName = "s" + m_sCentralVariableStemName;
                    break;                                
                case TypeClass.SEQUENCE_value:
                    //TODO consider mulitdimensional Arrays
                    XTypeDescription xTypeDescription = Introspector.getIntrospector().getReferencedType(getTypeName());
                    if (xTypeDescription != null){
                        sVariableStemName = getVariableStemName(xTypeDescription.getTypeClass());
                    }
                    break;                
                case TypeClass.TYPE_value:
                    sVariableStemName = "a" + m_sCentralVariableStemName;
                    break;
                case TypeClass.ANY_value:
                    sVariableStemName = "o" + m_sCentralVariableStemName;
                    break;
                case TypeClass.STRUCT_value:
                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:
                    String sShortClassName = m_oIntrospector.getShortClassName(getTypeName());
                    sVariableStemName = getVariableNameforUnoObject(sShortClassName);
                default:                                                    
            }            
            return sVariableStemName;
        }
        
        
        private void setVariableName(String _sVariableName){
            sVariableName = _sVariableName;
        }
        
        
        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;        
                sVariableName = getVariableStemName();
                boolean bleaveloop = false;
                while (!bleaveloop){
                    if (aVariables.containsKey(sVariableName)){
                        String sUnoObjectIdentity = ((UnoObjectDefinition) aVariables.get(sVariableName)).getUnoObject().toString();
                        if (m_oUnoObject != null){
                            if ((sUnoObjectIdentity.equals(m_oUnoObject.toString()) && (!m_oIntrospector.isPrimitive(this.getTypeClass())) && 
                                (! m_oIntrospector.isObjectSequence(m_oUnoObject)))){
                                bleaveloop = true;
                            }
                            else{
                                sVariableName = getVariableStemName() + SSUFFIXSEPARATOR + a++;
                            }
                        }
                        else{
                            bleaveloop = true;
                        }
                    }
                    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 " + _aTypeClass.getValue() + " not yet defined in 'getStringValueOfObject()'");
        }            
        return sReturn;
    }
    
    
    public String getMethodParameterValueDescription(XUnoMethodNode _oUnoMethodNode, Object[] _oParamObjects, boolean _bIncludeParameterNames){
        String sParamSourceCode = "";
        ParamInfo[] aParamInfos = _oUnoMethodNode.getXIdlMethod().getParameterInfos();
        if (_oParamObjects != null){
            for (int i = 0; i < _oParamObjects.length; i++){
                TypeClass aTypeClass = aParamInfos[i].aType.getTypeClass();
                if (_bIncludeParameterNames){
                    sParamSourceCode += aParamInfos[i].aName + "=";
                }
                String sParamDescription = getStringValueOfObject(_oParamObjects[i], aTypeClass);
                sParamDescription = this.m_xLanguageSourceCodeGenerator.castLiteral(sParamDescription, aTypeClass);
                sParamSourceCode += sParamDescription;
                
                if (i < _oParamObjects.length - 1){
                    sParamSourceCode += ", ";
                }
            }
        }
        return sParamSourceCode;
    }
    
    
    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 = "";
            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);
                    }
                }
                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
            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 _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, 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 _sClassName, boolean _bAsHeader){
            String sReturn = "";
            if (_bAsHeader){
                sReturn = _sClassName;
            }
            else{
                sReturn = m_oIntrospector.getShortClassName(_sClassName);
            }
            return sReturn;
        }
        
        
        public String getMethodTerminationSourceCode(){
            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";   
        }

        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(boolean _bAsHeaderSourceCode){
            if (_bAsHeaderSourceCode){
                return "";
            }
            else{
                return "String";                        
            }
        }

        public String gettypeTypeDescription(boolean _bAsHeaderSourceCode){
            if (_bAsHeaderSourceCode){
                return "com.sun.star.uno.Type";
            }
            else{
                return "Type";
            }
        }

        public String getanyTypeDescription(boolean _bAsHeaderSourceCode){
            if (_bAsHeaderSourceCode){
                return "";
            }
            else{
                return "Object";
            }
        }
        
        
        public String getStringValue(String _sValue){
            return _sValue;
        }
        
        
        public String getVariableDeclaration(String _sTypeString, String _sVariableName, boolean _bIsArray, TypeClass _aTypeClass, boolean _bInitialize){
            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;
        }
        
        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 "//";
        }
        
    }        
}