AOO410/main/basic/source/sbx/sbxdate.cxx - openoffice - Git at Google

 /**************************************************************
  *
  * 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.
  *
  *************************************************************/


 // MARKER(update_precomp.py): autogen include statement, do not remove
 #include "precompiled_basic.hxx"
 #include <vcl/svapp.hxx>
 #include <svl/zforlist.hxx>
 #include <tools/errcode.hxx>
 #include <tools/color.hxx>
 #include <i18npool/lang.h>
 #include <basic/sbx.hxx>
 #include "sbxconv.hxx"
 #include "math.h"
 #include <comphelper/processfactory.hxx>


 double ImpGetDate( const SbxValues* p )
 {
 	double nRes;
 	switch( +p->eType )
 	{
 		case SbxNULL:
 			SbxBase::SetError( SbxERR_CONVERSION );
 		case SbxEMPTY:
 			nRes = 0; break;
 		case SbxCHAR:
 			nRes = p->nChar; break;
 		case SbxBYTE:
 			nRes = p->nByte; break;
 		case SbxINTEGER:
 		case SbxBOOL:
 			nRes = p->nInteger; break;
 		case SbxERROR:
 		case SbxUSHORT:
 			nRes = p->nUShort; break;
 		case SbxLONG:
 			nRes = (double) p->nLong; break;
 		case SbxULONG:
 			nRes = (double) p->nULong; break;
 		case SbxSINGLE:
 			nRes = p->nSingle; break;
 		case SbxDATE:
 		case SbxDOUBLE:
 			nRes = p->nDouble; break;
 		case SbxULONG64:
 			nRes = ImpUINT64ToDouble( p->nULong64 ); break;
 		case SbxLONG64:
 			nRes = ImpINT64ToDouble( p->nLong64 ); break;
 		case SbxCURRENCY:
 			nRes = ImpCurrencyToDouble( p->nLong64 ); break;
 		case SbxSALINT64:
             nRes = static_cast< double >(p->nInt64); break;
 		case SbxSALUINT64:
             nRes = ImpSalUInt64ToDouble( p->uInt64 ); break;
 		case SbxDECIMAL:
 		case SbxBYREF | SbxDECIMAL:
 			if( p->pDecimal )
 				p->pDecimal->getDouble( nRes );
 			else
 				nRes = 0.0;
 			break;
 		case SbxBYREF | SbxSTRING:
 		case SbxSTRING:
 		case SbxLPSTR:
 			if( !p->pOUString )
 				nRes = 0;
 			else
 			{
                 LanguageType eLangType = GetpApp()->GetSettings().GetLanguage();

 				SvNumberFormatter* pFormatter;
 				com::sun::star::uno::Reference< com::sun::star::lang::XMultiServiceFactory >
 					xFactory = comphelper::getProcessServiceFactory();
 				pFormatter = new SvNumberFormatter( xFactory, eLangType );

 				sal_uInt32 nIndex;
 				xub_StrLen nCheckPos = 0;
 				short nType = 127;

 				// Standard-Vorlagen des Formatters haben nur zweistellige
 				// Jahreszahl. Deshalb eigenes Format registrieren

 				// HACK, da der Numberformatter in PutandConvertEntry die Platzhalter
 				// fuer Monat, Tag, Jahr nicht entsprechend der Systemeinstellung
 				// austauscht. Problem: Print Year(Date) unter engl. BS
 				// siehe auch basic\source\runtime\runtime.cxx

                 SvtSysLocale aSysLocale;
                 DateFormat eDate = aSysLocale.GetLocaleData().getDateFormat();
 				String aDateStr;
 				switch( eDate )
 				{
 					case MDY: aDateStr.AssignAscii( "MM.TT.JJJJ" ); break;
 					case DMY: aDateStr.AssignAscii( "TT.MM.JJJJ" ); break;
 					case YMD: aDateStr.AssignAscii( "JJJJ.MM.TT" ); break;
 					default:  aDateStr.AssignAscii( "MM.TT.JJJJ" );
 				}

 				String aStr( aDateStr );
 				aStr.AppendAscii( " HH:MM:SS" );

 				pFormatter->PutandConvertEntry( aStr, nCheckPos,	nType,
 					nIndex, LANGUAGE_GERMAN, eLangType );
 				sal_Bool bSuccess = pFormatter->IsNumberFormat( *p->pOUString, nIndex, nRes );
 				if ( bSuccess )
 				{
 					short nType_ = pFormatter->GetType( nIndex );
 					if(!(nType_ & (	NUMBERFORMAT_DATETIME | NUMBERFORMAT_DATE |
 									NUMBERFORMAT_TIME | NUMBERFORMAT_DEFINED )))
 						bSuccess = sal_False;
 				}

 				if ( !bSuccess )
 				{
 					SbxBase::SetError( SbxERR_CONVERSION ); nRes = 0;
 				}

 				delete pFormatter;
 			}
 			break;
 		case SbxOBJECT:
 		{
 			SbxValue* pVal = PTR_CAST(SbxValue,p->pObj);
 			if( pVal )
 				nRes = pVal->GetDate();
 			else
 			{
 				SbxBase::SetError( SbxERR_NO_OBJECT ); nRes = 0;
 			}
 			break;
 		}

 		case SbxBYREF | SbxCHAR:
 			nRes = *p->pChar; break;
 		case SbxBYREF | SbxBYTE:
 			nRes = *p->pByte; break;
 		case SbxBYREF | SbxINTEGER:
 		case SbxBYREF | SbxBOOL:
 			nRes = *p->pInteger; break;
 		case SbxBYREF | SbxLONG:
 			nRes = *p->pLong; break;
 		case SbxBYREF | SbxULONG:
 			nRes = *p->pULong; break;
 		case SbxBYREF | SbxERROR:
 		case SbxBYREF | SbxUSHORT:
 			nRes = *p->pUShort; break;
 		case SbxBYREF | SbxSINGLE:
 			nRes = *p->pSingle; break;
 		case SbxBYREF | SbxDATE:
 		case SbxBYREF | SbxDOUBLE:
 			nRes = *p->pDouble; break;
 		case SbxBYREF | SbxULONG64:
 			nRes = ImpUINT64ToDouble( *p->pULong64 ); break;
 		case SbxBYREF | SbxLONG64:
 			nRes = ImpINT64ToDouble( *p->pLong64 ); break;
 		case SbxBYREF | SbxCURRENCY:
 			nRes = ImpCurrencyToDouble( *p->pLong64 ); break;
 		case SbxBYREF | SbxSALINT64:
             nRes = static_cast< double >(*p->pnInt64); break;
 		case SbxBYREF | SbxSALUINT64:
             nRes = ImpSalUInt64ToDouble( *p->puInt64 ); break;

 		default:
 			SbxBase::SetError( SbxERR_CONVERSION ); nRes = 0;
 	}
 	return nRes;
 }

 void ImpPutDate( SbxValues* p, double n )
 {
 	SbxValues aTmp;

 start:
 	switch( +p->eType )
 	{
 		case SbxDATE:
 		case SbxDOUBLE:
 			p->nDouble = n; break;

 		// ab hier wird getestet
 		case SbxCHAR:
 			aTmp.pChar = &p->nChar; goto direct;
 		case SbxBYTE:
 			aTmp.pByte = &p->nByte; goto direct;
 		case SbxINTEGER:
 		case SbxBOOL:
 			aTmp.pInteger = &p->nInteger; goto direct;
 		case SbxLONG:
 			aTmp.pLong = &p->nLong; goto direct;
 		case SbxULONG:
 			aTmp.pULong = &p->nULong; goto direct;
 		case SbxERROR:
 		case SbxUSHORT:
 			aTmp.pUShort = &p->nUShort; goto direct;
 		case SbxSINGLE:
 			aTmp.pSingle = &p->nSingle; goto direct;
 		case SbxULONG64:
 			aTmp.pULong64 = &p->nULong64; goto direct;
 		case SbxLONG64:
 		case SbxCURRENCY:
 			aTmp.pLong64 = &p->nLong64; goto direct;
 		case SbxSALINT64:
 			aTmp.pnInt64 = &p->nInt64; goto direct;
 		case SbxSALUINT64:
 			aTmp.puInt64 = &p->uInt64; goto direct;
 		case SbxDECIMAL:
 		case SbxBYREF | SbxDECIMAL:
 			{
 			SbxDecimal* pDec = ImpCreateDecimal( p );
 			if( !pDec->setDouble( n ) )
 				SbxBase::SetError( SbxERR_OVERFLOW );
 			break;
 			}
 		direct:
 			aTmp.eType = SbxDataType( p->eType | SbxBYREF );
 			p = &aTmp; goto start;

 		case SbxBYREF | SbxSTRING:
 		case SbxSTRING:
 		case SbxLPSTR:
 		{
 			if( !p->pOUString )
 				p->pOUString = new ::rtl::OUString;
 			Color* pColor;

             LanguageType eLangType = GetpApp()->GetSettings().GetLanguage();
 			SvNumberFormatter* pFormatter;
 			com::sun::star::uno::Reference< com::sun::star::lang::XMultiServiceFactory >
 				xFactory = comphelper::getProcessServiceFactory();
 			pFormatter = new SvNumberFormatter( xFactory, eLangType );

 			sal_uInt32 nIndex;
 			xub_StrLen nCheckPos = 0;
 			short nType;

             SvtSysLocale aSysLocale;
             DateFormat eDate = aSysLocale.GetLocaleData().getDateFormat();
 			String aStr;
 			// ist der ganzzahlige Teil 0, wollen wir kein Jahr!
 			if( n <= -1.0 || n >= 1.0 )
 			{
 				// Time only if != 00:00:00
 				if( floor( n ) == n )
                 {
 				    switch( eDate )
 				    {
 					    case MDY: aStr.AssignAscii( "MM.TT.JJJJ" ); break;
 					    case DMY: aStr.AssignAscii( "TT.MM.JJJJ" ); break;
 					    case YMD: aStr.AssignAscii( "JJJJ.MM.TT" ); break;
 					    default:  aStr.AssignAscii( "MM.TT.JJJJ" );
 				    }
                 }
 				else
                 {
 				    switch( eDate )
 				    {
 					    case MDY: aStr.AssignAscii( "MM.TT.JJJJ HH:MM:SS" ); break;
 					    case DMY: aStr.AssignAscii( "TT.MM.JJJJ HH:MM:SS" ); break;
 					    case YMD: aStr.AssignAscii( "JJJJ.MM.TT HH:MM:SS" ); break;
 					    default:  aStr.AssignAscii( "MM.TT.JJJJ HH:MM:SS" );
 				    }
                 }
 			}
 			else
 				aStr.AppendAscii( "HH:MM:SS" );

 			pFormatter->PutandConvertEntry( aStr,
 				nCheckPos,
 				nType,
 				nIndex,
 				LANGUAGE_GERMAN,
 				eLangType );
             String aTmpString;
 			pFormatter->GetOutputString( n, nIndex, aTmpString, &pColor );
             *p->pOUString = aTmpString;
 			delete pFormatter;
 			break;
 		}
 		case SbxOBJECT:
 		{
 			SbxValue* pVal = PTR_CAST(SbxValue,p->pObj);
 			if( pVal )
 				pVal->PutDate( n );
 			else
 				SbxBase::SetError( SbxERR_NO_OBJECT );
 			break;
 		}
 		case SbxBYREF | SbxCHAR:
 			if( n > SbxMAXCHAR )
 			{
 				SbxBase::SetError( SbxERR_OVERFLOW ); n = SbxMAXCHAR;
 			}
 			else if( n < SbxMINCHAR )
 			{
 				SbxBase::SetError( SbxERR_OVERFLOW ); n = SbxMINCHAR;
 			}
 			*p->pChar = (xub_Unicode) n; break;
 		case SbxBYREF | SbxBYTE:
 			if( n > SbxMAXBYTE )
 			{
 				SbxBase::SetError( SbxERR_OVERFLOW ); n = SbxMAXBYTE;
 			}
 			else if( n < 0 )
 			{
 				SbxBase::SetError( SbxERR_OVERFLOW ); n = 0;
 			}
 			*p->pByte = (sal_uInt8) n; break;
 		case SbxBYREF | SbxINTEGER:
 		case SbxBYREF | SbxBOOL:
 			if( n > SbxMAXINT )
 			{
 				SbxBase::SetError( SbxERR_OVERFLOW ); n = SbxMAXINT;
 			}
 			else if( n < SbxMININT )
 			{
 				SbxBase::SetError( SbxERR_OVERFLOW ); n = SbxMININT;
 			}
 			*p->pInteger = (sal_Int16) n; break;
 		case SbxBYREF | SbxERROR:
 		case SbxBYREF | SbxUSHORT:
 			if( n > SbxMAXUINT )
 			{
 				SbxBase::SetError( SbxERR_OVERFLOW ); n = SbxMAXUINT;
 			}
 			else if( n < 0 )
 			{
 				SbxBase::SetError( SbxERR_OVERFLOW ); n = 0;
 			}
 			*p->pUShort = (sal_uInt16) n; break;
 		case SbxBYREF | SbxLONG:
 			if( n > SbxMAXLNG )
 			{
 				SbxBase::SetError( SbxERR_OVERFLOW ); n = SbxMAXLNG;
 			}
 			else if( n < SbxMINLNG )
 			{
 				SbxBase::SetError( SbxERR_OVERFLOW ); n = SbxMINLNG;
 			}
 			*p->pLong = (sal_Int32) n; break;
 		case SbxBYREF | SbxULONG:
 			if( n > SbxMAXULNG )
 			{
 				SbxBase::SetError( SbxERR_OVERFLOW ); n = SbxMAXULNG;
 			}
 			else if( n < 0 )
 			{
 				SbxBase::SetError( SbxERR_OVERFLOW ); n = 0;
 			}
 			*p->pULong = (sal_uInt32) n; break;
 		case SbxBYREF | SbxSINGLE:
 			if( n > SbxMAXSNG )
 			{
 				SbxBase::SetError( SbxERR_OVERFLOW ); n = SbxMAXSNG;
 			}
 			else if( n < SbxMINSNG )
 			{
 				SbxBase::SetError( SbxERR_OVERFLOW ); n = SbxMINSNG;
 			}
 			*p->pSingle = (float) n; break;
 		case SbxBYREF | SbxSALINT64:
             *p->pnInt64 = ImpDoubleToSalInt64( n ); break;
 		case SbxBYREF | SbxSALUINT64:
 			*p->puInt64 = ImpDoubleToSalUInt64( n ); break;
 		case SbxBYREF | SbxDATE:
 		case SbxBYREF | SbxDOUBLE:
 			*p->pDouble = (double) n; break;
 		case SbxBYREF | SbxCURRENCY:
 			if( n > SbxMAXCURR )
 			{
 				SbxBase::SetError( SbxERR_OVERFLOW ); n = SbxMAXCURR;
 			}
 			else if( n < SbxMINCURR )
 			{
 				SbxBase::SetError( SbxERR_OVERFLOW ); n = SbxMINCURR;
 			}
 			*p->pLong64 = ImpDoubleToCurrency( n ); break;

 		default:
 			SbxBase::SetError( SbxERR_CONVERSION );
 	}
 }
	/**************************************************************
	*
	* 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.
	*
	*************************************************************/



	// MARKER(update_precomp.py): autogen include statement, do not remove
	#include "precompiled_basic.hxx"
	#include <vcl/svapp.hxx>
	#include <svl/zforlist.hxx>
	#include <tools/errcode.hxx>
	#include <tools/color.hxx>
	#include <i18npool/lang.h>
	#include <basic/sbx.hxx>
	#include "sbxconv.hxx"
	#include "math.h"
	#include <comphelper/processfactory.hxx>


	double ImpGetDate( const SbxValues* p )
	{
	double nRes;
	switch( +p->eType )
	{
	case SbxNULL:
	SbxBase::SetError( SbxERR_CONVERSION );
	case SbxEMPTY:
	nRes = 0; break;
	case SbxCHAR:
	nRes = p->nChar; break;
	case SbxBYTE:
	nRes = p->nByte; break;
	case SbxINTEGER:
	case SbxBOOL:
	nRes = p->nInteger; break;
	case SbxERROR:
	case SbxUSHORT:
	nRes = p->nUShort; break;
	case SbxLONG:
	nRes = (double) p->nLong; break;
	case SbxULONG:
	nRes = (double) p->nULong; break;
	case SbxSINGLE:
	nRes = p->nSingle; break;
	case SbxDATE:
	case SbxDOUBLE:
	nRes = p->nDouble; break;
	case SbxULONG64:
	nRes = ImpUINT64ToDouble( p->nULong64 ); break;
	case SbxLONG64:
	nRes = ImpINT64ToDouble( p->nLong64 ); break;
	case SbxCURRENCY:
	nRes = ImpCurrencyToDouble( p->nLong64 ); break;
	case SbxSALINT64:
	nRes = static_cast< double >(p->nInt64); break;
	case SbxSALUINT64:
	nRes = ImpSalUInt64ToDouble( p->uInt64 ); break;
	case SbxDECIMAL:
	case SbxBYREF \| SbxDECIMAL:
	if( p->pDecimal )
	p->pDecimal->getDouble( nRes );
	else
	nRes = 0.0;
	break;
	case SbxBYREF \| SbxSTRING:
	case SbxSTRING:
	case SbxLPSTR:
	if( !p->pOUString )
	nRes = 0;
	else
	{
	LanguageType eLangType = GetpApp()->GetSettings().GetLanguage();

	SvNumberFormatter* pFormatter;
	com::sun::star::uno::Reference< com::sun::star::lang::XMultiServiceFactory >
	xFactory = comphelper::getProcessServiceFactory();
	pFormatter = new SvNumberFormatter( xFactory, eLangType );

	sal_uInt32 nIndex;
	xub_StrLen nCheckPos = 0;
	short nType = 127;

	// Standard-Vorlagen des Formatters haben nur zweistellige
	// Jahreszahl. Deshalb eigenes Format registrieren

	// HACK, da der Numberformatter in PutandConvertEntry die Platzhalter
	// fuer Monat, Tag, Jahr nicht entsprechend der Systemeinstellung
	// austauscht. Problem: Print Year(Date) unter engl. BS
	// siehe auch basic\source\runtime\runtime.cxx

	SvtSysLocale aSysLocale;
	DateFormat eDate = aSysLocale.GetLocaleData().getDateFormat();
	String aDateStr;
	switch( eDate )
	{
	case MDY: aDateStr.AssignAscii( "MM.TT.JJJJ" ); break;
	case DMY: aDateStr.AssignAscii( "TT.MM.JJJJ" ); break;
	case YMD: aDateStr.AssignAscii( "JJJJ.MM.TT" ); break;
	default: aDateStr.AssignAscii( "MM.TT.JJJJ" );
	}

	String aStr( aDateStr );
	aStr.AppendAscii( " HH:MM:SS" );

	pFormatter->PutandConvertEntry( aStr, nCheckPos, nType,
	nIndex, LANGUAGE_GERMAN, eLangType );
	sal_Bool bSuccess = pFormatter->IsNumberFormat( *p->pOUString, nIndex, nRes );
	if ( bSuccess )
	{
	short nType_ = pFormatter->GetType( nIndex );
	if(!(nType_ & ( NUMBERFORMAT_DATETIME \| NUMBERFORMAT_DATE \|
	NUMBERFORMAT_TIME \| NUMBERFORMAT_DEFINED )))
	bSuccess = sal_False;
	}

	if ( !bSuccess )
	{
	SbxBase::SetError( SbxERR_CONVERSION ); nRes = 0;
	}

	delete pFormatter;
	}
	break;
	case SbxOBJECT:
	{
	SbxValue* pVal = PTR_CAST(SbxValue,p->pObj);
	if( pVal )
	nRes = pVal->GetDate();
	else
	{
	SbxBase::SetError( SbxERR_NO_OBJECT ); nRes = 0;
	}
	break;
	}

	case SbxBYREF \| SbxCHAR:
	nRes = *p->pChar; break;
	case SbxBYREF \| SbxBYTE:
	nRes = *p->pByte; break;
	case SbxBYREF \| SbxINTEGER:
	case SbxBYREF \| SbxBOOL:
	nRes = *p->pInteger; break;
	case SbxBYREF \| SbxLONG:
	nRes = *p->pLong; break;
	case SbxBYREF \| SbxULONG:
	nRes = *p->pULong; break;
	case SbxBYREF \| SbxERROR:
	case SbxBYREF \| SbxUSHORT:
	nRes = *p->pUShort; break;
	case SbxBYREF \| SbxSINGLE:
	nRes = *p->pSingle; break;
	case SbxBYREF \| SbxDATE:
	case SbxBYREF \| SbxDOUBLE:
	nRes = *p->pDouble; break;
	case SbxBYREF \| SbxULONG64:
	nRes = ImpUINT64ToDouble( *p->pULong64 ); break;
	case SbxBYREF \| SbxLONG64:
	nRes = ImpINT64ToDouble( *p->pLong64 ); break;
	case SbxBYREF \| SbxCURRENCY:
	nRes = ImpCurrencyToDouble( *p->pLong64 ); break;
	case SbxBYREF \| SbxSALINT64:
	nRes = static_cast< double >(*p->pnInt64); break;
	case SbxBYREF \| SbxSALUINT64:
	nRes = ImpSalUInt64ToDouble( *p->puInt64 ); break;

	default:
	SbxBase::SetError( SbxERR_CONVERSION ); nRes = 0;
	}
	return nRes;
	}

	void ImpPutDate( SbxValues* p, double n )
	{
	SbxValues aTmp;

	start:
	switch( +p->eType )
	{
	case SbxDATE:
	case SbxDOUBLE:
	p->nDouble = n; break;

	// ab hier wird getestet
	case SbxCHAR:
	aTmp.pChar = &p->nChar; goto direct;
	case SbxBYTE:
	aTmp.pByte = &p->nByte; goto direct;
	case SbxINTEGER:
	case SbxBOOL:
	aTmp.pInteger = &p->nInteger; goto direct;
	case SbxLONG:
	aTmp.pLong = &p->nLong; goto direct;
	case SbxULONG:
	aTmp.pULong = &p->nULong; goto direct;
	case SbxERROR:
	case SbxUSHORT:
	aTmp.pUShort = &p->nUShort; goto direct;
	case SbxSINGLE:
	aTmp.pSingle = &p->nSingle; goto direct;
	case SbxULONG64:
	aTmp.pULong64 = &p->nULong64; goto direct;
	case SbxLONG64:
	case SbxCURRENCY:
	aTmp.pLong64 = &p->nLong64; goto direct;
	case SbxSALINT64:
	aTmp.pnInt64 = &p->nInt64; goto direct;
	case SbxSALUINT64:
	aTmp.puInt64 = &p->uInt64; goto direct;
	case SbxDECIMAL:
	case SbxBYREF \| SbxDECIMAL:
	{
	SbxDecimal* pDec = ImpCreateDecimal( p );
	if( !pDec->setDouble( n ) )
	SbxBase::SetError( SbxERR_OVERFLOW );
	break;
	}
	direct:
	aTmp.eType = SbxDataType( p->eType \| SbxBYREF );
	p = &aTmp; goto start;

	case SbxBYREF \| SbxSTRING:
	case SbxSTRING:
	case SbxLPSTR:
	{
	if( !p->pOUString )
	p->pOUString = new ::rtl::OUString;
	Color* pColor;

	LanguageType eLangType = GetpApp()->GetSettings().GetLanguage();
	SvNumberFormatter* pFormatter;
	com::sun::star::uno::Reference< com::sun::star::lang::XMultiServiceFactory >
	xFactory = comphelper::getProcessServiceFactory();
	pFormatter = new SvNumberFormatter( xFactory, eLangType );

	sal_uInt32 nIndex;
	xub_StrLen nCheckPos = 0;
	short nType;

	SvtSysLocale aSysLocale;
	DateFormat eDate = aSysLocale.GetLocaleData().getDateFormat();
	String aStr;
	// ist der ganzzahlige Teil 0, wollen wir kein Jahr!
	if( n <= -1.0 \|\| n >= 1.0 )
	{
	// Time only if != 00:00:00
	if( floor( n ) == n )
	{
	switch( eDate )
	{
	case MDY: aStr.AssignAscii( "MM.TT.JJJJ" ); break;
	case DMY: aStr.AssignAscii( "TT.MM.JJJJ" ); break;
	case YMD: aStr.AssignAscii( "JJJJ.MM.TT" ); break;
	default: aStr.AssignAscii( "MM.TT.JJJJ" );
	}
	}
	else
	{
	switch( eDate )
	{
	case MDY: aStr.AssignAscii( "MM.TT.JJJJ HH:MM:SS" ); break;
	case DMY: aStr.AssignAscii( "TT.MM.JJJJ HH:MM:SS" ); break;
	case YMD: aStr.AssignAscii( "JJJJ.MM.TT HH:MM:SS" ); break;
	default: aStr.AssignAscii( "MM.TT.JJJJ HH:MM:SS" );
	}
	}
	}
	else
	aStr.AppendAscii( "HH:MM:SS" );

	pFormatter->PutandConvertEntry( aStr,
	nCheckPos,
	nType,
	nIndex,
	LANGUAGE_GERMAN,
	eLangType );
	String aTmpString;
	pFormatter->GetOutputString( n, nIndex, aTmpString, &pColor );
	*p->pOUString = aTmpString;
	delete pFormatter;
	break;
	}
	case SbxOBJECT:
	{
	SbxValue* pVal = PTR_CAST(SbxValue,p->pObj);
	if( pVal )
	pVal->PutDate( n );
	else
	SbxBase::SetError( SbxERR_NO_OBJECT );
	break;
	}
	case SbxBYREF \| SbxCHAR:
	if( n > SbxMAXCHAR )
	{
	SbxBase::SetError( SbxERR_OVERFLOW ); n = SbxMAXCHAR;
	}
	else if( n < SbxMINCHAR )
	{
	SbxBase::SetError( SbxERR_OVERFLOW ); n = SbxMINCHAR;
	}
	*p->pChar = (xub_Unicode) n; break;
	case SbxBYREF \| SbxBYTE:
	if( n > SbxMAXBYTE )
	{
	SbxBase::SetError( SbxERR_OVERFLOW ); n = SbxMAXBYTE;
	}
	else if( n < 0 )
	{
	SbxBase::SetError( SbxERR_OVERFLOW ); n = 0;
	}
	*p->pByte = (sal_uInt8) n; break;
	case SbxBYREF \| SbxINTEGER:
	case SbxBYREF \| SbxBOOL:
	if( n > SbxMAXINT )
	{
	SbxBase::SetError( SbxERR_OVERFLOW ); n = SbxMAXINT;
	}
	else if( n < SbxMININT )
	{
	SbxBase::SetError( SbxERR_OVERFLOW ); n = SbxMININT;
	}
	*p->pInteger = (sal_Int16) n; break;
	case SbxBYREF \| SbxERROR:
	case SbxBYREF \| SbxUSHORT:
	if( n > SbxMAXUINT )
	{
	SbxBase::SetError( SbxERR_OVERFLOW ); n = SbxMAXUINT;
	}
	else if( n < 0 )
	{
	SbxBase::SetError( SbxERR_OVERFLOW ); n = 0;
	}
	*p->pUShort = (sal_uInt16) n; break;
	case SbxBYREF \| SbxLONG:
	if( n > SbxMAXLNG )
	{
	SbxBase::SetError( SbxERR_OVERFLOW ); n = SbxMAXLNG;
	}
	else if( n < SbxMINLNG )
	{
	SbxBase::SetError( SbxERR_OVERFLOW ); n = SbxMINLNG;
	}
	*p->pLong = (sal_Int32) n; break;
	case SbxBYREF \| SbxULONG:
	if( n > SbxMAXULNG )
	{
	SbxBase::SetError( SbxERR_OVERFLOW ); n = SbxMAXULNG;
	}
	else if( n < 0 )
	{
	SbxBase::SetError( SbxERR_OVERFLOW ); n = 0;
	}
	*p->pULong = (sal_uInt32) n; break;
	case SbxBYREF \| SbxSINGLE:
	if( n > SbxMAXSNG )
	{
	SbxBase::SetError( SbxERR_OVERFLOW ); n = SbxMAXSNG;
	}
	else if( n < SbxMINSNG )
	{
	SbxBase::SetError( SbxERR_OVERFLOW ); n = SbxMINSNG;
	}
	*p->pSingle = (float) n; break;
	case SbxBYREF \| SbxSALINT64:
	*p->pnInt64 = ImpDoubleToSalInt64( n ); break;
	case SbxBYREF \| SbxSALUINT64:
	*p->puInt64 = ImpDoubleToSalUInt64( n ); break;
	case SbxBYREF \| SbxDATE:
	case SbxBYREF \| SbxDOUBLE:
	*p->pDouble = (double) n; break;
	case SbxBYREF \| SbxCURRENCY:
	if( n > SbxMAXCURR )
	{
	SbxBase::SetError( SbxERR_OVERFLOW ); n = SbxMAXCURR;
	}
	else if( n < SbxMINCURR )
	{
	SbxBase::SetError( SbxERR_OVERFLOW ); n = SbxMINCURR;
	}
	*p->pLong64 = ImpDoubleToCurrency( n ); break;

	default:
	SbxBase::SetError( SbxERR_CONVERSION );
	}
	}