INTEGRATION: CWS rptwizard01 (1.1.2); FILE ADDED

2008/06/24 14:57:20 kz 1.1.2.3: fixed wrong license header
2008/02/20 09:34:37 lla 1.1.2.2: #i86092# set OOo Header
2008/02/19 12:42:48 lla 1.1.2.1: #i86092# add new files

1 files changed, 1472 insertions, 0 deletions

diff --git a/wizards/com/sun/star/wizards/common/NumericalHelper.java b/wizards/com/sun/star/wizards/common/NumericalHelper.java
new file mode 100644
index 000000000000..4a29325f0108
--- /dev/null
+++ b/wizards/com/sun/star/wizards/common/NumericalHelper.java
@@ -0,0 +1,1472 @@
+/*
+ ************************************************************************
+ *
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * Copyright 2008 by Sun Microsystems, Inc.
+ *
+ * OpenOffice.org - a multi-platform office productivity suite
+ *
+ * $RCSfile: NumericalHelper.java,v $
+ *
+ * $Revision: 1.2 $
+ *
+ * This file is part of OpenOffice.org.
+ *
+ * OpenOffice.org is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License version 3
+ * only, as published by the Free Software Foundation.
+ *
+ * OpenOffice.org is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License version 3 for more details
+ * (a copy is included in the LICENSE file that accompanied this code).
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * version 3 along with OpenOffice.org.  If not, see
+ * <http://www.openoffice.org/license.html>
+ * for a copy of the LGPLv3 License.
+ *
+ ************************************************************************/
+
+
+package com.sun.star.wizards.common;
+
+// import com.sun.star.beans.XPropertySet;
+import com.sun.star.uno.AnyConverter;
+import com.sun.star.uno.TypeClass;
+
+/**
+ * A class for helping with all kinds of numerical conversions.
+ * Optional or named parameters in SO are of the Object type in Java.
+ * These objects must be converted to the right simple value type.
+ * Unfortunately, StarBasic does not know the original desired type,
+ * and a value that should be a "Float" is delivered as "Byte". This class
+ * handles the conversions of these types.<br>
+ * This class does not log warnings (or throws Exceptions) when the precision
+ * of a value is lost.
+ */
+public class NumericalHelper {
+
+    public static final int UNKNOWN_TYPE = -32768;
+    public static final int BYTE_TYPE = 0;
+    public static final int SHORT_TYPE = 1;
+    public static final int INT_TYPE = 2;
+    public static final int LONG_TYPE = 3;
+    public static final int FLOAT_TYPE = 4;
+    public static final int DOUBLE_TYPE = 5;
+    public static final int CHAR_TYPE = 6;
+    public static final int STRING_TYPE = -1;
+    public static final int BOOLEAN_TYPE = -2;
+    public static final int ARRAY_TYPE = -3;
+    public static final int SEQUENCE_TYPE = -4;
+
+    public static final int ASCII_VALUE_0 = 48;
+    public static final int ASCII_VALUE_A = 65;
+    public static final int COUNT_CHARS_IN_ALPHABET = 26;
+
+    private static final int HEX_BASE = 16;
+    private static final int DEC_BASE = 10;
+    private static final int ASCII_LETTER_A_OFFSET = 55;
+
+    /**
+     * private c'tor to prevent instantiation
+     */
+    private NumericalHelper() {
+        // private c'tor, so noone can instantiate
+    }
+
+    /**
+     * get the type of an object: returns all types that can possibly converted
+     * with this class.
+     * @param obj an object that is checked for conversion
+     * @return the type of the object
+     */
+    public static int getType(Object obj)
+    {
+        try {
+            TypeObject aTypeObject = getTypeObject(obj);
+            return aTypeObject.iType;
+        }
+        catch(com.sun.star.lang.IllegalArgumentException e) {
+            // ignore this one; just return unknown type
+        }
+        return UNKNOWN_TYPE;
+    }
+
+    /**
+     * get a byte value from the object
+     * @param aValue
+     * @return a byte
+     * @throws com.sun.star.lang.IllegalArgumentException if the object cannot be converted
+     */
+    public static byte toByte(Object aValue)
+        throws com.sun.star.lang.IllegalArgumentException {
+
+        byte retValue = 0;
+        boolean hasConversionWarning = false;
+        TypeObject aTypeObject = getTypeObject(aValue);
+        switch(aTypeObject.iType) {
+            case BYTE_TYPE:
+                retValue = getByte(aTypeObject);
+                break;
+            case CHAR_TYPE:
+                retValue = (byte)getChar(aTypeObject);
+                break;
+            case SHORT_TYPE:
+                retValue = (byte)getShort(aTypeObject);
+                break;
+            case INT_TYPE:
+                retValue = (byte)getInt(aTypeObject);
+                break;
+            case LONG_TYPE:
+                retValue = (byte)getLong(aTypeObject);
+                break;
+            case FLOAT_TYPE:
+                retValue = (byte)getFloat(aTypeObject);
+                break;
+            case DOUBLE_TYPE:
+                retValue = (byte)getDouble(aTypeObject);
+                break;
+            case STRING_TYPE:
+                try {
+                    Byte b = new Byte((String)aTypeObject.aValue);
+                    retValue = b.byteValue();
+                }
+                catch(java.lang.NumberFormatException e) {
+                    throw new com.sun.star.lang.IllegalArgumentException(
+                        "Cannot convert to byte: " + aTypeObject.aValue);
+                }
+                break;
+            case BOOLEAN_TYPE:
+                retValue = getBool(aTypeObject)?(byte)-1:(byte)0;
+                break;
+            default:
+                throw new com.sun.star.lang.IllegalArgumentException(
+                    "Cannot convert this type: " + aValue.getClass().getName());
+        }
+        return retValue;
+    }
+
+    /**
+     * get a char value from the object
+     * @param aValue
+     * @return a char
+     * @throws com.sun.star.lang.IllegalArgumentException  if the object cannot be converted
+     */
+    public static char toChar(Object aValue)
+        throws com.sun.star.lang.IllegalArgumentException {
+
+        char retValue = 0;
+        boolean hasConversionWarning = false;
+        TypeObject aTypeObject = getTypeObject(aValue);
+        switch(aTypeObject.iType) {
+            case CHAR_TYPE:
+                retValue = getChar(aTypeObject);
+                break;
+            case BYTE_TYPE:
+                retValue = (char)getByte(aTypeObject);
+                break;
+            case SHORT_TYPE:
+                retValue = (char)getShort(aTypeObject);
+                break;
+            case INT_TYPE:
+                retValue = (char)getInt(aTypeObject);
+                break;
+            case LONG_TYPE:
+                retValue = (char)getLong(aTypeObject);
+                break;
+            case FLOAT_TYPE:
+                retValue = (char)getFloat(aTypeObject);
+                break;
+            case DOUBLE_TYPE:
+                retValue = (char)getDouble(aTypeObject);
+                break;
+            case STRING_TYPE:
+                try {
+                    String s = (String)aTypeObject.aValue;
+                    if (s.length() > 0) {
+                        retValue = s.charAt(0);
+                    }
+                    else {
+                        retValue = (char)0;
+                    }
+                }
+                catch(java.lang.NumberFormatException e) {
+                    throw new com.sun.star.lang.IllegalArgumentException(
+                        "Cannot convert to char: " + aTypeObject.aValue);
+                }
+                break;
+            case BOOLEAN_TYPE:
+                retValue = getBool(aTypeObject)?(char)-1:(char)0;
+                break;
+            default:
+                throw new com.sun.star.lang.IllegalArgumentException(
+                    "Cannot convert this type: " + aValue.getClass().getName());
+        }
+        return retValue;
+    }
+
+    /**
+     * get a short value from the object
+     * @param aValue
+     * @return a short
+     * @throws com.sun.star.lang.IllegalArgumentException if the object cannot be converted
+     */
+    public static short toShort(Object aValue)
+        throws com.sun.star.lang.IllegalArgumentException {
+        short retValue = 0;
+        TypeObject aTypeObject = getTypeObject(aValue);
+        switch(aTypeObject.iType) {
+            case BYTE_TYPE:
+                retValue = (short)getByte(aTypeObject);
+                break;
+            case CHAR_TYPE:
+                retValue = (byte)getChar(aTypeObject);
+                break;
+            case SHORT_TYPE:
+                retValue = getShort(aTypeObject);
+                break;
+            case INT_TYPE:
+                retValue = (short)getInt(aTypeObject);
+                break;
+            case LONG_TYPE:
+                retValue = (short)getLong(aTypeObject);
+                break;
+            case FLOAT_TYPE:
+                retValue = (short)getFloat(aTypeObject);
+                break;
+            case DOUBLE_TYPE:
+                retValue = (short)getDouble(aTypeObject);
+                break;
+            case STRING_TYPE:
+                try {
+                    Short s = new Short((String)aTypeObject.aValue);
+                    retValue = s.shortValue();
+                }
+                catch(java.lang.NumberFormatException e) {
+                    throw new com.sun.star.lang.IllegalArgumentException(
+                        "Cannot convert to short: " + aTypeObject.aValue);
+                }
+                break;
+            case BOOLEAN_TYPE:
+                retValue = getBool(aTypeObject)?(short)-1:(short)0;
+                break;
+            default:
+                throw new com.sun.star.lang.IllegalArgumentException(
+                    "Cannot convert this type: " + aValue.getClass().getName());
+        }
+        return retValue;
+    }
+
+
+    public static boolean isValidAndNumerical(Object aValue) throws com.sun.star.lang.IllegalArgumentException{
+        if (aValue != null){
+            if (!AnyConverter.isVoid(aValue)) {
+                return (NumericalHelper.isNumerical(aValue));
+            }
+        }
+        return false;
+    }
+
+    public static boolean isValidAndBoolean(Object aValue) throws com.sun.star.lang.IllegalArgumentException{
+        if (aValue != null){
+            if (!AnyConverter.isVoid(aValue)) {
+                int nType = AnyConverter.getType(aValue).getTypeClass().getValue();
+                return (nType == TypeClass.BOOLEAN_value);
+            }
+        }
+        return false;
+    }
+
+
+    public static boolean isValid(Object aValue){
+        if (aValue != null){
+            if (!AnyConverter.isVoid(aValue)) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    /**
+       @param aValue a object this can contain anything
+       @return true, if the parameter aValue is type of real numbers
+       @deprecate, use isRealNumber() instead.
+    */
+
+    public static boolean isNumerical(Object aValue) {
+    try {
+            TypeObject aTypeObject = getTypeObject(aValue);
+            switch(aTypeObject.iType){
+                    case BYTE_TYPE:
+                    case CHAR_TYPE:
+                    case SHORT_TYPE:
+                    case INT_TYPE:
+                    case LONG_TYPE:
+                    case DOUBLE_TYPE:
+                    case FLOAT_TYPE:
+                            return true;
+                    default:
+                            return false;
+            }
+    } catch (com.sun.star.lang.IllegalArgumentException e) {
+            return false;
+    }}
+
+    /**
+       @param _aValue a object this can contain anything
+       @return true, if the parameter aValue is type of real numbers
+
+       see also http://en.wikipedia.org/wiki/Mathematics
+    */
+    public static boolean isRealNumber(Object _aValue)
+    {
+        return isNumerical(_aValue);
+    }
+
+    /**
+       @param aValue a object this can contain anything
+     * @return true, if the value is type of any integer values. double / float are not(!) integer values
+     * @throws com.sun.star.lang.IllegalArgumentException
+    */
+    public static boolean isInteger(Object aValue) throws com.sun.star.lang.IllegalArgumentException
+        {
+            TypeObject aTypeObject = getTypeObject(aValue);
+            switch(aTypeObject.iType)
+            {
+            case BYTE_TYPE:
+            case CHAR_TYPE:
+            case SHORT_TYPE:
+            case INT_TYPE:
+            case LONG_TYPE:
+                return true;
+            default:
+                return false;
+            }
+        }
+
+    /**
+     * Can a given object be converted to a String array?
+     * @param aValue the object to test
+     * @return true, if the object can be converted to a String array.
+     */
+    public static boolean isStringArray(Object aValue) {
+        try {
+            toStringArray(aValue);
+            return true;
+        }
+        catch(com.sun.star.lang.IllegalArgumentException e) {
+            // ignore
+        }
+        return false;
+    }
+
+    /**
+     * Can a given object be converted to an int array?
+     * @param aValue the object to test
+     * @return true, if the object can be converted to an Integer array.
+     */
+    public static boolean isIntegerArray(Object aValue) {
+        try {
+            toIntArray(aValue);
+            return true;
+        }
+        catch(com.sun.star.lang.IllegalArgumentException e) {
+            // ignore
+        }
+        return false;
+    }
+
+
+//    public static int toIntWithErrorMessage(Object _aValue) throws com.sun.star.script.BasicErrorException{
+//    try {
+//        return toInt(_aValue);
+//    }
+//    catch(com.sun.star.lang.IllegalArgumentException e) {
+//        DebugHelper.exception(BasicErrorCode.SbERR_CONVERSION, "");
+//        return 0;
+//    }}
+//
+//
+//    public static String toStringWithErrorMessage(Object _aValue) throws com.sun.star.script.BasicErrorException{
+//    try {
+//        return toString(_aValue);
+//    }
+//    catch(com.sun.star.lang.IllegalArgumentException e) {
+//        DebugHelper.exception(BasicErrorCode.SbERR_CONVERSION, "");
+//        return "";
+//    }}
+//
+//
+//    public static int toIntWithErrorMessage(Object _aValue, int _ndefaultValue) throws com.sun.star.script.BasicErrorException{
+//    try {
+//        return toInt(_aValue, _ndefaultValue);
+//    }
+//    catch(com.sun.star.uno.Exception e) {
+//        DebugHelper.exception(BasicErrorCode.SbERR_CONVERSION, "");
+//        return 0;
+//    }}
+//
+//    public static boolean toBooleanWithErrorMessage(Object _oObject, int _nTrueField, int _nFalseField) throws com.sun.star.script.BasicErrorException{
+//        return toBooleanWithErrorMessage(_oObject, new int[]{_nTrueField}, new int[]{_nFalseField});
+//    }
+//
+//
+//    public static boolean toBooleanWithErrorMessage(Object _oObject) throws com.sun.star.script.BasicErrorException{
+//        try{
+//            return toBoolean(_oObject);
+//        }
+//        catch (java.lang.Exception e){
+//           DebugHelper.exception(BasicErrorCode.SbERR_BAD_ARGUMENT, "");
+//           return false;
+//        }
+//    }
+//
+//
+//    public static boolean toBooleanWithErrorMessage(Object _oObject, int[] _nTrueFields, int[] _nFalseFields) throws com.sun.star.script.BasicErrorException{
+//    try{
+//        int nValue = NumericalHelper.toIntWithErrorMessage(_oObject);
+//        if (ContainerUtilities.FieldInIntTable(_nTrueFields, nValue) > -1){
+//            return true;
+//        }
+//        else if (ContainerUtilities.FieldInIntTable(_nFalseFields, nValue) > -1){
+//           return false;
+//        }
+//        else{
+//            DebugHelper.exception(BasicErrorCode.SbERR_OUT_OF_RANGE, "");
+//            return false;
+//        }
+//    }catch (java.lang.Exception e){
+//       DebugHelper.exception(BasicErrorCode.SbERR_OUT_OF_RANGE, "");
+//        return false;
+//    }}
+//
+//
+//    public static boolean toBooleanWithErrorMessage(Object _oObject, int _nTrueField, int _nFalseField, boolean _bdefaultValue) throws com.sun.star.script.BasicErrorException{
+//        return toBooleanWithErrorMessage(_oObject, new int[]{_nTrueField}, new int[]{_nFalseField}, _bdefaultValue);
+//    }
+//
+//
+//    public static boolean toBooleanWithErrorMessage(Object _oObject, int[] _nTrueFields, int[] _nFalseFields, boolean _bdefaultValue) throws com.sun.star.script.BasicErrorException{
+//    try{
+//        if ((_oObject == null) || (AnyConverter.isVoid(_oObject))){
+//            return _bdefaultValue;
+//        }
+//        else{
+//            int nValue = NumericalHelper.toIntWithErrorMessage(_oObject);
+//            if (ContainerUtilities.FieldInIntTable(_nTrueFields, nValue) > -1){
+//                return true;
+//            }
+//            else if (ContainerUtilities.FieldInIntTable(_nFalseFields, nValue) > -1){
+//               return false;
+//            }
+//            else{
+//                DebugHelper.exception(BasicErrorCode.SbERR_OUT_OF_RANGE, "");
+//                return false;
+//            }
+//        }
+//    }catch (java.lang.Exception e){
+//       DebugHelper.exception(BasicErrorCode.SbERR_OUT_OF_RANGE, "");
+//        return false;
+//    }}
+
+
+    /**
+     * get an int value from the object
+     * @param aValue
+     * @return an int
+     * @throws com.sun.star.lang.IllegalArgumentException if the object cannot be converted
+     */
+    public static int toInt(Object aValue)
+        throws com.sun.star.lang.IllegalArgumentException {
+        int retValue = 0;
+        TypeObject aTypeObject = getTypeObject(aValue);
+        switch(aTypeObject.iType) {
+            case BYTE_TYPE:
+                retValue = (int)getByte(aTypeObject);
+                break;
+            case CHAR_TYPE:
+                retValue = (int)getChar(aTypeObject);
+                break;
+            case SHORT_TYPE:
+                retValue = (int)getShort(aTypeObject);
+                break;
+            case INT_TYPE:
+                retValue = getInt(aTypeObject);
+                break;
+            case LONG_TYPE:
+                retValue = (int)getLong(aTypeObject);
+                break;
+            case FLOAT_TYPE:
+                retValue = (int)getFloat(aTypeObject);
+                break;
+            case DOUBLE_TYPE:
+                retValue = (int)getDouble(aTypeObject);
+                break;
+            case STRING_TYPE:
+                try {
+                    Integer i = new Integer((String)aTypeObject.aValue);
+                    retValue = i.intValue();
+                }
+                catch(java.lang.NumberFormatException e) {
+                    throw new com.sun.star.lang.IllegalArgumentException(
+                        "Cannot convert to int: " + aTypeObject.aValue);
+                }
+                break;
+            case BOOLEAN_TYPE:
+                retValue = getBool(aTypeObject)? -1 : 0;
+                break;
+            default:
+                throw new com.sun.star.lang.IllegalArgumentException(
+                    "Cannot convert this type: " + aValue.getClass().getName());
+        }
+        return retValue;
+    }
+
+    /**
+     * get a long value from the object
+     * @param aValue
+     * @return a long
+     * @throws com.sun.star.lang.IllegalArgumentException if the object cannot be converted
+     */
+    public static long toLong(Object aValue)
+        throws com.sun.star.lang.IllegalArgumentException {
+        long retValue = 0;
+        TypeObject aTypeObject = getTypeObject(aValue);
+        switch(aTypeObject.iType) {
+            case BYTE_TYPE:
+                retValue = (long)getByte(aTypeObject);
+                break;
+            case CHAR_TYPE:
+                retValue = (long)getChar(aTypeObject);
+                break;
+            case SHORT_TYPE:
+                retValue = (long)getShort(aTypeObject);
+                break;
+            case INT_TYPE:
+                retValue = (long)getInt(aTypeObject);
+                break;
+            case LONG_TYPE:
+                retValue = getLong(aTypeObject);
+                break;
+            case FLOAT_TYPE:
+                retValue = (long)getFloat(aTypeObject);
+                break;
+            case DOUBLE_TYPE:
+                retValue = (long)getDouble(aTypeObject);
+                break;
+            case STRING_TYPE:
+                try {
+                    Long l = new Long((String)aTypeObject.aValue);
+                    retValue = l.longValue();
+                }
+                catch(java.lang.NumberFormatException e) {
+                    throw new com.sun.star.lang.IllegalArgumentException(
+                        "Cannot convert to short: " + aTypeObject.aValue);
+                }
+                break;
+            case BOOLEAN_TYPE:
+                retValue = getBool(aTypeObject)? -1 : 0;
+                break;
+            default:
+                throw new com.sun.star.lang.IllegalArgumentException(
+                    "Cannot convert this type: " + aValue.getClass().getName());
+        }
+        return retValue;
+    }
+
+    /**
+     * get a float value from the object
+     * @param aValue
+     * @return a float
+     * @throws com.sun.star.lang.IllegalArgumentException if the object cannot be converted
+     */
+    public static float toFloat(Object aValue)
+        throws com.sun.star.lang.IllegalArgumentException {
+        float retValue = (float)0.0;
+        TypeObject aTypeObject = getTypeObject(aValue);
+        switch(aTypeObject.iType) {
+            case BYTE_TYPE:
+                retValue = (float)getByte(aTypeObject);
+                break;
+            case CHAR_TYPE:
+                retValue = (float)getChar(aTypeObject);
+                break;
+            case SHORT_TYPE:
+                retValue = (float)getShort(aTypeObject);
+                break;
+            case INT_TYPE:
+                retValue = (float)getInt(aTypeObject);
+                break;
+            case LONG_TYPE:
+                retValue = (float)getLong(aTypeObject);
+                break;
+            case FLOAT_TYPE:
+                retValue = getFloat(aTypeObject);
+                break;
+            case DOUBLE_TYPE:
+                retValue = (float)getDouble(aTypeObject);
+                break;
+            case STRING_TYPE:
+                try {
+                    Float f = new Float((String)aTypeObject.aValue);
+                    retValue = f.floatValue();
+                }
+                catch(java.lang.NumberFormatException e) {
+                    throw new com.sun.star.lang.IllegalArgumentException(
+                        "Cannot convert to short: " + aTypeObject.aValue);
+                }
+                break;
+            case BOOLEAN_TYPE:
+                retValue = getBool(aTypeObject)?(float)-1:(float)0;
+                break;
+            default:
+                throw new com.sun.star.lang.IllegalArgumentException(
+                    "Cannot convert this type: " + aValue.getClass().getName());
+        }
+        return retValue;
+    }
+
+    /**
+     * get a double value from the object
+     * @param aValue
+     * @return a double
+     * @throws com.sun.star.lang.IllegalArgumentException if the object cannot be converted
+     */
+    public static double toDouble(Object aValue)
+        throws com.sun.star.lang.IllegalArgumentException {
+        double retValue = 0.0;
+        TypeObject aTypeObject = getTypeObject(aValue);
+        switch(aTypeObject.iType) {
+            case BYTE_TYPE:
+                retValue = (double)getByte(aTypeObject);
+                break;
+            case CHAR_TYPE:
+                retValue = (double)getChar(aTypeObject);
+                break;
+            case SHORT_TYPE:
+                retValue = (double)getShort(aTypeObject);
+                break;
+            case INT_TYPE:
+                retValue = (double)getInt(aTypeObject);
+                break;
+            case LONG_TYPE:
+                retValue = (double)getLong(aTypeObject);
+                break;
+            case FLOAT_TYPE:
+                retValue = (double)getFloat(aTypeObject);
+                break;
+            case DOUBLE_TYPE:
+                retValue = getDouble(aTypeObject);
+                break;
+            case STRING_TYPE:
+                try {
+                    Float f = new Float((String)aTypeObject.aValue);
+                    retValue = f.floatValue();
+                }
+                catch(java.lang.NumberFormatException e) {
+                    throw new com.sun.star.lang.IllegalArgumentException(
+                        "Cannot convert to short: " + aTypeObject.aValue);
+                }
+                break;
+            case BOOLEAN_TYPE:
+                retValue = getBool(aTypeObject)?(double)-1:(double)0;
+                break;
+            default:
+                throw new com.sun.star.lang.IllegalArgumentException(
+                    "Cannot convert this type: " + aValue.getClass().getName());
+        }
+        return retValue;
+    }
+
+    /**
+     * get a String value from the object
+     * @param aValue
+     * @return a String
+     * @throws com.sun.star.lang.IllegalArgumentException if the object cannot be converted
+     */
+    public static String toString(Object aValue)
+        throws com.sun.star.lang.IllegalArgumentException {
+        String retValue = null;
+        TypeObject aTypeObject = getTypeObject(aValue);
+        switch(aTypeObject.iType) {
+            case BYTE_TYPE:
+                retValue = ((Byte)aTypeObject.aValue).toString();
+                break;
+            case CHAR_TYPE:
+                retValue = ((Character)aTypeObject.aValue).toString();
+                break;
+            case SHORT_TYPE:
+                retValue = ((Short)aTypeObject.aValue).toString();
+                break;
+            case INT_TYPE:
+                retValue = ((Integer)aTypeObject.aValue).toString();
+                break;
+            case LONG_TYPE:
+                retValue = ((Long)aTypeObject.aValue).toString();
+                break;
+            case FLOAT_TYPE:
+                retValue = ((Float)aTypeObject.aValue).toString();
+                break;
+            case DOUBLE_TYPE:
+                retValue = ((Double)aTypeObject.aValue).toString();
+                break;
+            case STRING_TYPE:
+                retValue = (String)aTypeObject.aValue;
+                break;
+            case BOOLEAN_TYPE:
+                retValue = ((Boolean)aTypeObject.aValue).toString();
+                break;
+            case ARRAY_TYPE:
+                retValue = new String(toByteArray((aValue)));
+                break;
+            default:
+                throw new com.sun.star.lang.IllegalArgumentException(
+                    "Cannot convert this type: " + aValue.getClass().getName());
+        }
+        return retValue;
+    }
+
+
+    /**
+     * get a boolean value from the object
+     * @param aValue
+     * @return a boolean
+     * @throws com.sun.star.lang.IllegalArgumentException if the object cannot be converted
+     */
+    public static boolean toBoolean(Object aValue)
+        throws com.sun.star.lang.IllegalArgumentException {
+        boolean retValue = true;
+        TypeObject aTypeObject = getTypeObject(aValue);
+        switch(aTypeObject.iType) {
+            case BYTE_TYPE:
+                retValue = (((Byte)aTypeObject.aValue).byteValue() != 0);
+                break;
+            case CHAR_TYPE:
+                retValue = (((Character)aTypeObject.aValue).charValue() != 0);
+                break;
+            case SHORT_TYPE:
+                retValue = (((Short)aTypeObject.aValue).shortValue() != 0);
+                break;
+            case INT_TYPE:
+                retValue = (((Integer)aTypeObject.aValue).intValue() != 0);
+                break;
+            case LONG_TYPE:
+                retValue = (((Long)aTypeObject.aValue).longValue() != 0);
+                break;
+            case FLOAT_TYPE:
+                retValue = (((Float)aTypeObject.aValue).floatValue() != 0);
+                break;
+            case DOUBLE_TYPE:
+                retValue = (((Double)aTypeObject.aValue).doubleValue() != 0);
+                break;
+            case STRING_TYPE:
+                try {
+                    Boolean b = Boolean.valueOf((String)aTypeObject.aValue);
+                    retValue = b.booleanValue();
+                }
+                catch(java.lang.NumberFormatException e) {
+                    throw new com.sun.star.lang.IllegalArgumentException(
+                        "Cannot convert to short: " + aTypeObject.aValue);
+                }
+                break;
+            case BOOLEAN_TYPE:
+                retValue = ((Boolean)aTypeObject.aValue).booleanValue();
+                break;
+            default:
+                throw new com.sun.star.lang.IllegalArgumentException(
+                    "Cannot convert this type: " + aValue.getClass().getName());
+        }
+        return retValue;
+    }
+
+    /**
+     * get an int array from an object
+     * @param anArrayValue a value that is constructed into an array
+     * @return an integer array
+     * @throws com.sun.star.lang.IllegalArgumentException
+     */
+    public static int[] toIntArray(Object anArrayValue)
+        throws com.sun.star.lang.IllegalArgumentException {
+        int[] retValue = null;
+        TypeObject aTypeObject = getTypeObject(anArrayValue);
+        if (aTypeObject.iType == SEQUENCE_TYPE) {
+            aTypeObject = convertSequenceToObjectArray(aTypeObject);
+        }
+        if (aTypeObject.iType == ARRAY_TYPE) {
+            Object[]obj = (Object[])aTypeObject.aValue;
+            retValue = new int[obj.length];
+            for (int i=0; i<obj.length; i++) {
+                retValue[i] = toInt(obj[i]);
+            }
+        }
+        else { // object is not really an array
+            retValue = new int[]{toInt(anArrayValue)};
+        }
+        return retValue;
+    }
+
+    /**
+     * get an byte array from an object
+     * @param anArrayValue a value that is constructed into an array
+     * @return a byte array
+     * @throws com.sun.star.lang.IllegalArgumentException
+     */
+    public static byte[] toByteArray(Object anArrayValue)
+        throws com.sun.star.lang.IllegalArgumentException {
+        byte[] retValue = null;
+        TypeObject aTypeObject = getTypeObject(anArrayValue);
+        if (aTypeObject.iType == SEQUENCE_TYPE) {
+            aTypeObject = convertSequenceToObjectArray(aTypeObject);
+        }
+        if (aTypeObject.iType == ARRAY_TYPE) {
+            Object[]obj = (Object[])aTypeObject.aValue;
+            retValue = new byte[obj.length];
+            for (int i=0; i<obj.length; i++) {
+                retValue[i] = toByte(obj[i]);
+            }
+        }
+        else { // object is not really an array
+            retValue = new byte[]{toByte(anArrayValue)};
+        }
+        return retValue;
+    }
+
+    /**
+     * get a short array from an object
+     * @param anArrayValue a value that is constructed into an array
+     * @return a short array
+     * @throws com.sun.star.lang.IllegalArgumentException
+     */
+    public static short[] toShortArray(Object anArrayValue)
+        throws com.sun.star.lang.IllegalArgumentException {
+        short[] retValue = null;
+        TypeObject aTypeObject = getTypeObject(anArrayValue);
+        if (aTypeObject.iType == SEQUENCE_TYPE) {
+            aTypeObject = convertSequenceToObjectArray(aTypeObject);
+        }
+        if (aTypeObject.iType == ARRAY_TYPE) {
+            Object[]obj = (Object[])aTypeObject.aValue;
+            retValue = new short[obj.length];
+            for (int i=0; i<obj.length; i++) {
+                retValue[i] = toShort(obj[i]);
+            }
+        }
+        else { // object is not really an array
+            retValue = new short[]{toShort(anArrayValue)};
+        }
+        return retValue;
+    }
+
+    /**
+     * get a string array from an object
+     * @param anArrayValue a value that is constructed into an array
+     * @return a short array
+     * @throws com.sun.star.lang.IllegalArgumentException
+     */
+    public static String[] toStringArray(Object anArrayValue)
+        throws com.sun.star.lang.IllegalArgumentException {
+        String[] retValue = null;
+        TypeObject aTypeObject = getTypeObject(anArrayValue);
+        if (aTypeObject.iType == SEQUENCE_TYPE) {
+            aTypeObject = convertSequenceToObjectArray(aTypeObject);
+        }
+        if (aTypeObject.iType == ARRAY_TYPE) {
+            Object[]obj = (Object[])aTypeObject.aValue;
+            retValue = new String[obj.length];
+            for (int i=0; i<obj.length; i++) {
+                retValue[i] = toString(obj[i]);
+            }
+        }
+        else { // object is not really an array
+            retValue = new String[]{toString(anArrayValue)};
+        }
+        return retValue;
+    }
+
+
+    /**
+     * get an int from an object
+     * @param _aValue a value that is constructed into an int
+     * @param _ndefaultValue the value that is returned, if conversion fails, or if 'aValue' is null
+     * @return an int value
+     * @throws java.lang.Exception
+     */
+    public static int toInt(Object _aValue, int _ndefaultValue) throws Exception
+    {
+        int nreturn  = _ndefaultValue;
+        try
+        {
+            if ((_aValue != null) && (!(AnyConverter.isVoid(_aValue))))
+            {
+                if (isInteger(_aValue))
+                {
+                    nreturn = toInt(_aValue);
+                }
+                else
+                {
+                    DebugHelper.exception(1/* BasicErrorCode.SbERR_CONVERSION*/, "");
+                }
+            }
+        }
+        catch (com.sun.star.uno.Exception e)
+        {
+            DebugHelper.exception(1 /*BasicErrorCode.SbERR_METHOD_FAILED*/ , "");
+        }
+        return nreturn;
+    }
+
+
+
+    /**
+     * get a long from an object
+     * @param aValue a value that is constructed into a long
+     * @param defaultValue the value that is returned, if conversion fails
+     * @return a long value
+     */
+    public static long toLong(Object aValue, long defaultValue) {
+        try {
+            return toLong(aValue);
+        }
+        catch(com.sun.star.lang.IllegalArgumentException e) {
+            // ignore exception
+        }
+        return defaultValue;
+    }
+
+    /**
+     * get a float from an object
+     * @param aValue a value that is constructed into a float
+     * @param defaultValue the value that is returned, if conversion fails
+     * @return a long value
+     */
+    public static float toFloat(Object aValue, float defaultValue) {
+        try {
+            return toFloat(aValue);
+        }
+        catch(com.sun.star.lang.IllegalArgumentException e) {
+            // ignore exception
+        }
+        return defaultValue;
+    }
+
+    /**
+     * get a double from an object
+     * @param aValue a value that is constructed into a double
+     * @param defaultValue the value that is returned, if conversion fails
+     * @return a double value
+     */
+    public static double toDouble(Object aValue, double defaultValue) {
+        try {
+            return toDouble(aValue);
+        }
+        catch(com.sun.star.lang.IllegalArgumentException e) {
+            // ignore exception
+        }
+        return defaultValue;
+    }
+
+    /**
+     * get a string from an object
+     * @param aValue a value that is constructed into a string
+     * @param defaultValue the value that is returned, if conversion fails
+     * @return a string value
+     */
+    public static String toString(Object aValue, String defaultValue) {
+        try {
+            return toString(aValue);
+        }
+        catch(com.sun.star.lang.IllegalArgumentException e) {
+            // ignore exception
+        }
+        return defaultValue;
+    }
+
+    /**
+     * get a boolean from an object
+     * @param aValue a value that is constructed into a boolean
+     * @param defaultValue the value that is returned, if conversion fails
+     * @return a boolean value
+     */
+    public static boolean toBoolean(Object aValue, boolean defaultValue) {
+        try {
+            return toBoolean(aValue);
+        }
+        catch(com.sun.star.lang.IllegalArgumentException e) {
+            // ignore exception
+        }
+        return defaultValue;
+    }
+
+    /**
+     * get a int array from an object
+     * @param anArrayValue  a value that is constructed into an int array
+     * @param defaultValue the value that is returned, if conversion fails
+     * @return an int array
+     */
+    public static int[] toIntArray(Object anArrayValue, int[] defaultValue) {
+        try {
+            return toIntArray(anArrayValue);
+        }
+        catch(com.sun.star.lang.IllegalArgumentException e) {
+            // ignore exception
+        }
+        return defaultValue;
+    }
+
+    /**
+     * get a short array from an object
+     * @param anArrayValue a value that is constructed into a short array
+     * @param defaultValue the value that is returned, if conversion fails
+     * @return a short array
+     */
+    public static short[] toShortArray(Object anArrayValue, short[] defaultValue) {
+        try {
+            return toShortArray(anArrayValue);
+        }
+        catch(com.sun.star.lang.IllegalArgumentException e) {
+            // ignore exception
+        }
+        return defaultValue;
+    }
+
+    /**
+     * get a string array from an object
+     * @param anArrayValue a value that is constructed into a string array
+     * @param defaultValue the value that is returned, if conversion fails
+     * @return a string array
+     */
+    public static String[] toStringArray(Object anArrayValue, String[] defaultValue) {
+        try {
+            return toStringArray(anArrayValue);
+        }
+        catch(com.sun.star.lang.IllegalArgumentException e) {
+            // ignore exception
+        }
+        return defaultValue;
+    }
+
+    /**
+     * get a hexadecimal representation from a number
+     * @param number the number to transform
+     * @return a String with the hex code of the number
+     */
+    public static String getHexStringFromNumber(long number) {
+        TransformNumToHex num = new TransformNumToHex(number);
+        return num.getResult();
+    }
+
+    /**
+     * Get the roman equivalent to an arabic number, e.g. 17 -> XVII.
+     * The allowed range for numbers goes from 1 to 3999. These can be
+     * converted using ASCII letters (3999 -> MMMCMXCIX).
+     * @param n the arabic number
+     * @return the roman equivalent as string
+     * @throws BasicErrorException if the number cannot be converted.
+     */
+//    public static String getRomanEquivalent(int n)
+//            throws com.sun.star.script.BasicErrorException {
+//        return RomanNumbering.getRomanEquivalent(n);
+//    }
+
+
+    /**
+     * get the type object from the given object
+     * @param aValue an object representing a (numerical) value; can also be an 'any'
+     * @return a type object: the object together with the its type information
+     * @throws com.sun.star.lang.IllegalArgumentException if the object is unknown
+     */
+    private static TypeObject getTypeObject(Object aValue)
+        throws com.sun.star.lang.IllegalArgumentException {
+        TypeObject aTypeObject = new TypeObject();
+        if (aValue == null || AnyConverter.isVoid(aValue)) {
+            throw new com.sun.star.lang.IllegalArgumentException("Cannot convert a null object.");
+        }
+        int type = AnyConverter.getType(aValue).getTypeClass().getValue();
+        switch(type) {
+            case TypeClass.CHAR_value:
+                aTypeObject.iType = CHAR_TYPE;
+                aTypeObject.aValue = new Character(AnyConverter.toChar(aValue));
+                break;
+            case TypeClass.BYTE_value:
+                aTypeObject.iType = BYTE_TYPE;
+                aTypeObject.aValue = new Byte(AnyConverter.toByte(aValue));
+                break;
+            case TypeClass.SHORT_value:
+                aTypeObject.iType = SHORT_TYPE;
+                aTypeObject.aValue = new Short(AnyConverter.toShort(aValue));
+                break;
+            case TypeClass.LONG_value:
+                aTypeObject.iType = INT_TYPE;
+                aTypeObject.aValue = new Integer(AnyConverter.toInt(aValue));
+                break;
+            case TypeClass.HYPER_value:
+                aTypeObject.iType = LONG_TYPE;
+                aTypeObject.aValue = new Long(AnyConverter.toLong(aValue));
+                break;
+            case TypeClass.FLOAT_value:
+                aTypeObject.iType = FLOAT_TYPE;
+                aTypeObject.aValue = new Float(AnyConverter.toFloat(aValue));
+                break;
+            case TypeClass.DOUBLE_value:
+                aTypeObject.iType = DOUBLE_TYPE;
+                aTypeObject.aValue = new Double(AnyConverter.toDouble(aValue));
+                break;
+            case TypeClass.STRING_value:
+                aTypeObject.iType = STRING_TYPE;
+                aTypeObject.aValue = AnyConverter.toString(aValue);
+                break;
+            case TypeClass.BOOLEAN_value:
+                aTypeObject.iType = BOOLEAN_TYPE;
+                aTypeObject.aValue = Boolean.valueOf(AnyConverter.toBoolean(aValue));
+                break;
+            case TypeClass.ARRAY_value:
+                aTypeObject.iType = ARRAY_TYPE;
+                aTypeObject.aValue = new Object[]{AnyConverter.toArray(aValue)};
+                break;
+            case TypeClass.SEQUENCE_value:
+                aTypeObject.iType = SEQUENCE_TYPE;
+                aTypeObject.aValue = aValue;
+                break;
+            default:
+                throw new com.sun.star.lang.IllegalArgumentException(
+                    "Cannot convert this type: " + aValue.getClass().getName());
+        }
+        return aTypeObject;
+    }
+
+    /**
+     * get the simple byte type
+     */
+    private static byte getByte(TypeObject typeObject)
+        throws com.sun.star.lang.IllegalArgumentException {
+        if (typeObject.iType != BYTE_TYPE) {
+            throw new com.sun.star.lang.IllegalArgumentException(
+                    "Given argument is not a byte type.");
+        }
+        return ((Byte)typeObject.aValue).byteValue();
+    }
+
+    /**
+     * get the simple char type
+     */
+    private static char getChar(TypeObject typeObject)
+        throws com.sun.star.lang.IllegalArgumentException {
+        if (typeObject.iType != CHAR_TYPE) {
+            throw new com.sun.star.lang.IllegalArgumentException(
+                    "Given argument is not a char type.");
+        }
+        return ((Character)typeObject.aValue).charValue();
+    }
+
+    /**
+     * get the simple short type
+     */
+    private static short getShort(TypeObject typeObject)
+        throws com.sun.star.lang.IllegalArgumentException {
+        if (typeObject.iType != SHORT_TYPE) {
+            throw new com.sun.star.lang.IllegalArgumentException(
+                    "Given argument is not a short type.");
+        }
+        return ((Short)typeObject.aValue).shortValue();
+    }
+
+
+    /**
+     * get the simple int type
+     * @param typeObject
+     * @return
+     * @throws com.sun.star.lang.IllegalArgumentException
+     */
+    static int getInt(TypeObject typeObject)
+        throws com.sun.star.lang.IllegalArgumentException {
+        if (typeObject.iType != INT_TYPE) {
+            throw new com.sun.star.lang.IllegalArgumentException(
+                    "Given argument is not an int type.");
+        }
+        return ((Integer)typeObject.aValue).intValue();
+    }
+
+    /**
+     * get the simple float type
+     * @throws com.sun.star.lang.IllegalArgumentException
+     */
+    static float getFloat(TypeObject typeObject)
+        throws com.sun.star.lang.IllegalArgumentException {
+        if (typeObject.iType != FLOAT_TYPE) {
+            throw new com.sun.star.lang.IllegalArgumentException(
+                    "Given argument is not a float type.");
+        }
+        return ((Float)typeObject.aValue).floatValue();
+    }
+
+    /**
+     * get the simple double type
+     */
+    private static double getDouble(TypeObject typeObject)
+        throws com.sun.star.lang.IllegalArgumentException {
+        if (typeObject.iType != DOUBLE_TYPE) {
+            throw new com.sun.star.lang.IllegalArgumentException(
+                    "Given argument is not a double type.");
+        }
+        return ((Double)typeObject.aValue).doubleValue();
+    }
+
+    /**
+     * get the simple long type
+     */
+    private static long getLong(TypeObject typeObject)
+        throws com.sun.star.lang.IllegalArgumentException {
+        if (typeObject.iType != LONG_TYPE) {
+            throw new com.sun.star.lang.IllegalArgumentException(
+                    "Given argument is not a long type.");
+        }
+        return ((Long)typeObject.aValue).longValue();
+    }
+
+    /**
+     * get the simple boolean type
+     */
+    private static boolean getBool(TypeObject typeObject)
+        throws com.sun.star.lang.IllegalArgumentException {
+        if (typeObject.iType != BOOLEAN_TYPE) {
+            throw new com.sun.star.lang.IllegalArgumentException(
+                    "Given argument is not a boolean type.");
+        }
+        return ((Boolean)typeObject.aValue).booleanValue();
+    }
+
+    /**
+     * a class to contain a type and a value for easier conversions
+     */
+    private static class TypeObject {
+        public int iType;
+        public Object aValue;
+    }
+
+    /**
+     * simple class to construct a hexadecimal value from a long number
+     */
+    private static class TransformNumToHex {
+        private StringBuffer val;
+
+        public TransformNumToHex(long number) {
+            val = new StringBuffer();
+            transform(number);
+        }
+
+        private void transform(long number) {
+            int index = (int)(number % HEX_BASE);
+            number = number / HEX_BASE;
+            if (index < DEC_BASE) {
+                val.insert(0,index);
+            }
+            else {
+                val.insert(0,(char)(ASCII_LETTER_A_OFFSET + index));
+            }
+            if (number >0) {
+                transform(number);
+            }
+        }
+
+        public String getResult() {
+            return val.toString();
+        }
+    }
+
+    private static TypeObject convertSequenceToObjectArray(
+            TypeObject sourceObject)
+            throws com.sun.star.lang.IllegalArgumentException {
+        TypeObject destObject = new TypeObject();
+        Object array = sourceObject.aValue;
+        destObject.iType = ARRAY_TYPE;
+        Class c = array.getClass();
+        Object[] aShortVal = null;
+        if (c.equals(byte[].class)) {
+            byte[] vals = (byte[])array;
+            aShortVal = new Object[vals.length];
+            for (int i=0; i<vals.length; i++) {
+                aShortVal[i] = new Byte(vals[i]);
+            }
+        }
+        else if (c.equals(short[].class)) {
+            short[] vals = (short[])array;
+            aShortVal = new Object[vals.length];
+            for (int i=0; i<vals.length; i++) {
+                aShortVal[i] = new Short(vals[i]);
+            }
+        }
+        else if (c.equals(int[].class)) {
+            int[] vals = (int[])array;
+            aShortVal = new Object[vals.length];
+            for (int i=0; i<vals.length; i++) {
+                aShortVal[i] = new Integer(vals[i]);
+            }
+        }
+        else if (c.equals(long[].class)) {
+            long[] vals = (long[])array;
+            aShortVal = new Object[vals.length];
+            for (int i=0; i<vals.length; i++) {
+                aShortVal[i] = new Long(vals[i]);
+            }
+        }
+        else if (c.equals(float[].class)) {
+            float[] vals = (float[])array;
+            aShortVal = new Object[vals.length];
+            for (int i=0; i<vals.length; i++) {
+                aShortVal[i] = new Float(vals[i]);
+            }
+        }
+        else if (c.equals(double[].class)) {
+            double[] vals = (double[])array;
+            aShortVal = new Object[vals.length];
+            for (int i=0; i<vals.length; i++) {
+                aShortVal[i] = new Double(vals[i]);
+            }
+        }
+        else if (c.equals(boolean[].class)) {
+            boolean[] vals = (boolean[])array;
+            aShortVal = new Object[vals.length];
+            for (int i=0; i<vals.length; i++) {
+                aShortVal[i] = Boolean.valueOf(vals[i]);
+            }
+        }
+        // if nothing did match, try this
+        if (aShortVal == null) {
+            try {
+                aShortVal = (Object[])array;
+            }
+            catch(java.lang.ClassCastException e) {
+                // unknown type cannot be converted
+                throw new com.sun.star.lang.IllegalArgumentException(
+                    "Cannot convert unknown type: '" + e.getMessage() + "'");
+            }
+        }
+        destObject.aValue = aShortVal;
+        return destObject;
+    }
+
+//    public static boolean isObjectNumericRepresentation(Object _oValue, NumberFormatter _oNumberFormatter, XPropertySet _xPropertySet) throws com.sun.star.script.BasicErrorException{
+//    try{
+//        int nNumberFormat = AnyConverter.toInt(_xPropertySet.getPropertyValue("NumberFormat"));
+//        if (AnyConverter.isString(_oValue)){
+//            String sCellContent = AnyConverter.toString(_oValue);
+//            try{
+//                _oNumberFormatter.convertStringToNumber(nNumberFormat, sCellContent);
+//                return true;
+//            }catch (Exception e){
+//                return false;
+//            }
+//        }
+//        else{
+//            return true;
+//        }
+//    }
+//    catch (com.sun.star.uno.Exception e){
+//        DebugHelper.exception(1 /*BasicErrorCode.SbERR_METHOD_FAILED*/, "");
+//        return false;
+//    }}
+
+
+    /**
+     * Helper class for roman numbering
+     */
+    private static class RomanNumbering {
+
+        /** the used roman lettesrs **/
+        private static final String [] ROMAN_EQUIV = new String[]{
+            "I", "V", "X", "L", "C", "D", "M"
+        };
+
+        /** max number that can be converted **/
+        private static final int MAX_NUMBER = 3999;
+        /** min number that can be converted **/
+        private static final int MIN_NUMBER = 1;
+        /** ASCII code for the number 0 **/
+        private static final int ASCII_CODE_0 = 48;
+        /** special number for the conversion algorithm **/
+        private static final int FOUR = 4;
+        /** special number for the conversion algorithm **/
+        private static final int FIVE = 5;
+        /** special number for the conversion algorithm **/
+        private static final int NINE = 9;
+
+
+        /**
+         * Get the roman equivalent to an arabic number, e.g. 17 -> XVII.
+         * The allowed range for numbers goes from 1 to 3999. These can be
+         * converted using ASCII letters (3999 -> MMMCMXCIX).
+         * @param n the arabic number
+         * @return the roman equivalent as string
+         * @throws BasicErrorException if the number cannot be converted.
+         */
+        public static String getRomanEquivalent(int n)
+                throws Exception {
+            StringBuffer romanNumber = new StringBuffer();
+            try {
+                if (n > MAX_NUMBER || n < MIN_NUMBER) {
+                    DebugHelper.exception(1 /*BasicErrorCode.SbERR_OUT_OF_RANGE*/ , "");
+                }
+                String number = NumericalHelper.toString(new Integer(n));
+                /* converison idea: every digit is written with a maximum of two
+                 * different roman symbols, using three in total, e.g. CC, CD,
+                 * DCC, CM for the hundreds (meaning 200, 400, 700 and 900).
+                 * So every digit is converted seperately with regard to the
+                 * special cases 4 and 9.
+                 */
+                int symbolIndex = 0;
+                for(int i = number.length() - 1; i >= 0; i--){
+                    StringBuffer romanDigit = new StringBuffer();
+                    int b = (int)number.charAt(i) - ASCII_CODE_0;
+                    if (b == FOUR) { // special case IV
+                        romanDigit.append(ROMAN_EQUIV[symbolIndex]);
+                        romanDigit.append(ROMAN_EQUIV[symbolIndex + 1]);
+                    }
+                    else if (b == NINE) { // special case IX
+                        romanDigit.append(ROMAN_EQUIV[symbolIndex]);
+                        romanDigit.append(ROMAN_EQUIV[symbolIndex + 2]);
+                    }
+                    else {
+                        if (b >= FIVE) { // special case V
+                            romanDigit.append(ROMAN_EQUIV[symbolIndex + 1]);
+                            b = b - FIVE;
+                        }
+                        for (int j = 0; j < b; j++) { // append I's
+                            romanDigit.append(ROMAN_EQUIV[symbolIndex]);
+                        }
+                    }
+                    // next group of three symbols
+                    symbolIndex += 2;
+                    // append in reverse: we are starting at the right
+                    romanNumber.append(romanDigit.reverse());
+                }
+            }
+            catch(com.sun.star.lang.IllegalArgumentException e) {
+                DebugHelper.exception(e);
+            }
+            // reverse again to get the number
+            return romanNumber.reverse().toString();
+        }
+    }
+
+
+    public static  boolean representsIntegerNumber(double _dblvalue){
+        double dblsecvalue = (double) ((int) _dblvalue);
+        return Double.compare(_dblvalue, dblsecvalue) == 0;
+    }
+
+
+    public static double roundDouble(Double _Dblvalue, int _ndecimals){
+        return roundDouble(_Dblvalue.doubleValue(), _ndecimals);
+    }
+
+
+    public static double roundDouble(double _dblvalue, int _ndecimals){
+        double dblfactor = java.lang.Math.pow(10.0, (double) _ndecimals);
+        double dblretvalue = ((double) ((int) (_dblvalue * dblfactor)))/dblfactor;
+        return dblretvalue;
+    }
+
+}