/**************************************************************
 * 
 * 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_svtools.hxx"

// include ---------------------------------------------------------------

#include <svtools/unitconv.hxx>

// -----------------------------------------------------------------------

void SetFieldUnit( MetricField& rField, FieldUnit eUnit, sal_Bool bAll )
{
	sal_Int64 nFirst	= rField.Denormalize( rField.GetFirst( FUNIT_TWIP ) );
	sal_Int64 nLast = rField.Denormalize( rField.GetLast( FUNIT_TWIP ) );
	sal_Int64 nMin = rField.Denormalize( rField.GetMin( FUNIT_TWIP ) );
	sal_Int64 nMax = rField.Denormalize( rField.GetMax( FUNIT_TWIP ) );

	if ( !bAll )
	{
		switch ( eUnit )
		{
			case FUNIT_M:
			case FUNIT_KM:
				eUnit = FUNIT_CM;
				break;

			case FUNIT_FOOT:
			case FUNIT_MILE:
				eUnit = FUNIT_INCH;
				break;
            default: ;//prevent warning
		}
	}
	rField.SetUnit( eUnit );
	switch( eUnit )
	{
		case FUNIT_MM:
			rField.SetSpinSize( 50 );
			break;

		case FUNIT_INCH:
			rField.SetSpinSize( 2 );
			break;

		default:
			rField.SetSpinSize( 10 );
	}

	if ( FUNIT_POINT == eUnit )
    {
        if( rField.GetDecimalDigits() > 1 )
		    rField.SetDecimalDigits( 1 );
    }
	else
		rField.SetDecimalDigits( 2 );

	if ( !bAll )
	{
		rField.SetFirst( rField.Normalize( nFirst ), FUNIT_TWIP );
		rField.SetLast( rField.Normalize( nLast ), FUNIT_TWIP );
		rField.SetMin( rField.Normalize( nMin ), FUNIT_TWIP );
		rField.SetMax( rField.Normalize( nMax ), FUNIT_TWIP );
	}
}

// -----------------------------------------------------------------------

void SetFieldUnit( MetricBox& rBox, FieldUnit eUnit, sal_Bool bAll )
{
	sal_Int64 nMin = rBox.Denormalize( rBox.GetMin( FUNIT_TWIP ) );
	sal_Int64 nMax = rBox.Denormalize( rBox.GetMax( FUNIT_TWIP ) );

	if ( !bAll )
	{
		switch ( eUnit )
		{
			case FUNIT_M:
			case FUNIT_KM:
				eUnit = FUNIT_CM;
				break;

			case FUNIT_FOOT:
			case FUNIT_MILE:
				eUnit = FUNIT_INCH;
				break;
            default: ;//prevent warning
        }
	}
	rBox.SetUnit( eUnit );

	if ( FUNIT_POINT == eUnit && rBox.GetDecimalDigits() > 1 )
		rBox.SetDecimalDigits( 1 );
	else
		rBox.SetDecimalDigits( 2 );

	if ( !bAll )
	{
		rBox.SetMin( rBox.Normalize( nMin ), FUNIT_TWIP );
		rBox.SetMax( rBox.Normalize( nMax ), FUNIT_TWIP );
	}
}

// -----------------------------------------------------------------------
void SetMetricValue( MetricField& rField, long nCoreValue, SfxMapUnit eUnit )
{
	sal_Int64 nVal = OutputDevice::LogicToLogic( nCoreValue, (MapUnit)eUnit, MAP_100TH_MM );
	nVal = rField.Normalize( nVal );
	rField.SetValue( nVal, FUNIT_100TH_MM );

}

// -----------------------------------------------------------------------

long GetCoreValue( const MetricField& rField, SfxMapUnit eUnit )
{
	sal_Int64 nVal = rField.GetValue( FUNIT_100TH_MM );
    // avoid rounding issues
    const sal_Int64 nSizeMask = 0xffffffffff000000LL;
    bool bRoundBefore = true;
    if( nVal >= 0 )
    {
        if( (nVal & nSizeMask) == 0 )
            bRoundBefore = false;
    }
    else
    {
        if( ((-nVal) & nSizeMask ) == 0 )
            bRoundBefore = false;
    }
    if( bRoundBefore )
        nVal = rField.Denormalize( nVal );
	sal_Int64 nUnitVal = OutputDevice::LogicToLogic( static_cast<long>(nVal), MAP_100TH_MM, (MapUnit)eUnit );
    if( ! bRoundBefore )
        nUnitVal = rField.Denormalize( nUnitVal );
	return static_cast<long>(nUnitVal);
}

// -----------------------------------------------------------------------

long CalcToUnit( float nIn, SfxMapUnit eUnit )
{
	// nIn ist in Points

	DBG_ASSERT( eUnit == SFX_MAPUNIT_TWIP 		||
				eUnit == SFX_MAPUNIT_100TH_MM 	||
				eUnit == SFX_MAPUNIT_10TH_MM 	||
				eUnit == SFX_MAPUNIT_MM 		||
				eUnit == SFX_MAPUNIT_CM, "this unit is not implemented" );

	float nTmp = nIn;

	if ( SFX_MAPUNIT_TWIP != eUnit )
		nTmp = nIn * 10 / 567;

	switch ( eUnit )
	{
		case SFX_MAPUNIT_100TH_MM:	nTmp *= 100; break;
		case SFX_MAPUNIT_10TH_MM:	nTmp *= 10;	 break;
		case SFX_MAPUNIT_MM:					 break;
		case SFX_MAPUNIT_CM:		nTmp /= 10;	 break;
        default: ;//prevent warning
    }

	nTmp *= 20;
	long nRet = (long)nTmp;
	return nRet;
//!	return (long)(nTmp * 20);
}

// -----------------------------------------------------------------------

long ItemToControl( long nIn, SfxMapUnit eItem, SfxFieldUnit eCtrl )
{
	long nOut = 0;

	switch ( eItem )
	{
		case SFX_MAPUNIT_100TH_MM:
		case SFX_MAPUNIT_10TH_MM:
		case SFX_MAPUNIT_MM:
		{
			if ( eItem == SFX_MAPUNIT_10TH_MM )
				nIn /= 10;
			else if ( eItem == SFX_MAPUNIT_100TH_MM )
				nIn /= 100;
			nOut = TransformMetric( nIn, FUNIT_MM, (FieldUnit)eCtrl );
		}
		break;

		case SFX_MAPUNIT_CM:
		{
			nOut = TransformMetric( nIn, FUNIT_CM, (FieldUnit)eCtrl );
		}
		break;

		case SFX_MAPUNIT_1000TH_INCH:
		case SFX_MAPUNIT_100TH_INCH:
		case SFX_MAPUNIT_10TH_INCH:
		case SFX_MAPUNIT_INCH:
		{
			if ( eItem == SFX_MAPUNIT_10TH_INCH )
				nIn /= 10;
			else if ( eItem == SFX_MAPUNIT_100TH_INCH )
				nIn /= 100;
			else if ( eItem == SFX_MAPUNIT_1000TH_INCH )
				nIn /= 1000;
			nOut = TransformMetric( nIn, FUNIT_INCH, (FieldUnit)eCtrl );
		}
		break;

		case SFX_MAPUNIT_POINT:
		{
			nOut = TransformMetric( nIn, FUNIT_POINT, (FieldUnit)eCtrl );
		}
		break;

		case SFX_MAPUNIT_TWIP:
		{
			nOut = TransformMetric( nIn, FUNIT_TWIP, (FieldUnit)eCtrl );
		}
		break;
        default: ;//prevent warning
    }
	return nOut;
}

// -----------------------------------------------------------------------

long ControlToItem( long nIn, SfxFieldUnit eCtrl, SfxMapUnit eItem )
{
	return ItemToControl( nIn, eItem, eCtrl );
}

// -----------------------------------------------------------------------

FieldUnit MapToFieldUnit( const SfxMapUnit eUnit )
{
	switch ( eUnit )
	{
		case SFX_MAPUNIT_100TH_MM:
		case SFX_MAPUNIT_10TH_MM:
		case SFX_MAPUNIT_MM:
			return FUNIT_MM;

		case SFX_MAPUNIT_CM:
			return FUNIT_CM;

		case SFX_MAPUNIT_1000TH_INCH:
		case SFX_MAPUNIT_100TH_INCH:
		case SFX_MAPUNIT_10TH_INCH:
		case SFX_MAPUNIT_INCH:
			return FUNIT_INCH;

		case SFX_MAPUNIT_POINT:
			return FUNIT_POINT;

		case SFX_MAPUNIT_TWIP:
			return FUNIT_TWIP;
        default: ;//prevent warning
    }
	return FUNIT_NONE;
}

// -----------------------------------------------------------------------

MapUnit FieldToMapUnit( const SfxFieldUnit /*eUnit*/ )
{
	return MAP_APPFONT;
}

// -----------------------------------------------------------------------

long ConvertValueToMap( long nVal, SfxMapUnit eUnit )
{
	long nNew = nVal;

	switch ( eUnit )
	{
		case SFX_MAPUNIT_10TH_MM:
		case SFX_MAPUNIT_10TH_INCH:
			nNew *= 10;
			break;

		case SFX_MAPUNIT_100TH_MM:
		case SFX_MAPUNIT_100TH_INCH:
			nNew *= 100;
			break;

		case SFX_MAPUNIT_1000TH_INCH:
			nNew *= 1000;
        default: ;//prevent warning
    }
	return nNew;
}

// -----------------------------------------------------------------------

long ConvertValueToUnit( long nVal, SfxMapUnit eUnit )
{
	long nNew = nVal;

	switch ( eUnit )
	{
		case SFX_MAPUNIT_10TH_MM:
		case SFX_MAPUNIT_10TH_INCH:
			nNew /= 10;
			break;

		case SFX_MAPUNIT_100TH_MM:
		case SFX_MAPUNIT_100TH_INCH:
			nNew /= 100;
			break;

		case SFX_MAPUNIT_1000TH_INCH:
			nNew /= 1000;
        break;
        default: ;//prevent warning
	}
	return nNew;
}

// -----------------------------------------------------------------------

long CalcToPoint( long nIn, SfxMapUnit eUnit, sal_uInt16 nFaktor )
{
	DBG_ASSERT( eUnit == SFX_MAPUNIT_TWIP 		||
				eUnit == SFX_MAPUNIT_100TH_MM 	||
				eUnit == SFX_MAPUNIT_10TH_MM 	||
				eUnit == SFX_MAPUNIT_MM 		||
				eUnit == SFX_MAPUNIT_CM, "this unit is not implemented" );

	long nRet = 0;

	if ( SFX_MAPUNIT_TWIP == eUnit )
		nRet = nIn;
	else
		nRet = nIn * 567;

	switch ( eUnit )
	{
		case SFX_MAPUNIT_100TH_MM:	nRet /= 100; break;
		case SFX_MAPUNIT_10TH_MM:	nRet /= 10;	 break;
		case SFX_MAPUNIT_MM:					 break;
		case SFX_MAPUNIT_CM:		nRet *= 10;	 break;
        default: ;//prevent warning
    }

	// ggf. aufrunden
	if ( SFX_MAPUNIT_TWIP != eUnit )
	{
		long nMod = 10;
		long nTmp = nRet % nMod;

		if ( nTmp >= 4 )
			nRet += 10 - nTmp;
		nRet /= 10;
	}
	return nRet * nFaktor / 20;
}

// -----------------------------------------------------------------------

long CMToTwips( long nIn )
{
	long nRet = 0;

	if ( nIn <= ( LONG_MAX / 567 ) && nIn >= ( LONG_MIN / 567 ) )
		nRet = nIn * 567;
	return nRet;
}

// -----------------------------------------------------------------------

long MMToTwips( long nIn )
{
	long nRet = 0;

	if ( nIn <= ( LONG_MAX / 567 ) && nIn >= ( LONG_MIN / 567 ) )
		nRet = nIn * 567 / 10;
	return nRet;
}

// -----------------------------------------------------------------------

long InchToTwips( long nIn )
{
	long nRet = 0;

	if ( nIn <= ( LONG_MAX / 1440 ) && nIn >= ( LONG_MIN / 1440 ) )
		nRet = nIn * 1440;
	return nRet;
}

// -----------------------------------------------------------------------

long PointToTwips( long nIn )
{
	long nRet = 0;

	if ( nIn <= ( LONG_MAX / 20 ) && nIn >= ( LONG_MIN / 20 ) )
		nRet = nIn * 20;
	return nRet;
}

// -----------------------------------------------------------------------

long PicaToTwips( long nIn )
{
	long nRet = 0;

	if ( nIn <= ( LONG_MAX / 240 ) && nIn >= ( LONG_MIN / 240 ) )
		nRet = nIn * 240;
	return nRet;
}

// -----------------------------------------------------------------------

long TwipsToCM( long nIn )
{
	long nRet = nIn / 567;
	return nRet;
}

// -----------------------------------------------------------------------

long InchToCM( long nIn )
{
	long nRet = 0;

	if ( nIn <= ( LONG_MAX / 254 ) && nIn >= ( LONG_MIN / 254 ) )
		nRet = nIn * 254 / 100;
	return nRet;
}

// -----------------------------------------------------------------------

long MMToCM( long nIn )
{
	long nRet = nIn / 10;
	return nRet;
}

// -----------------------------------------------------------------------

long PointToCM( long nIn )
{
	long nRet = 0;

	if ( nIn <= ( LONG_MAX / 20 ) && nIn >= ( LONG_MIN / 20 ) )
		nRet = nIn * 20 / 567;
	return nRet;
}

// -----------------------------------------------------------------------

long PicaToCM( long nIn)
{
	long nRet = 0;

	if ( nIn <= ( LONG_MAX / 12 / 20 ) && nIn >= ( LONG_MIN / 12 / 20 ) )
		nRet = nIn * 12 * 20 / 567;
	return nRet;
}

// -----------------------------------------------------------------------

long TwipsToMM( long nIn )
{
	long nRet = 0;

	if ( nIn <= ( LONG_MAX / 10 ) && nIn >= ( LONG_MIN / 10 ) )
		nRet = nIn * 10 / 566;
	return nRet;
}

// -----------------------------------------------------------------------

long CMToMM( long nIn )
{
	long nRet = 0;

	if ( nIn <= ( LONG_MAX / 10 ) && nIn >= ( LONG_MIN / 10 ) )
		nRet = nIn * 10;
	return nRet;
}

// -----------------------------------------------------------------------

long InchToMM( long nIn )
{
	long nRet = 0;

	if ( nIn <= ( LONG_MAX / 254 ) && nIn >= ( LONG_MIN / 254 ) )
		nRet = nIn * 254 / 10;
	return nRet;
}

// -----------------------------------------------------------------------

long PointToMM( long nIn )
{
	long nRet = 0;

	if ( nIn <= ( LONG_MAX / 200 ) && nIn >= ( LONG_MIN / 200 ) )
		nRet = nIn * 200 / 567;
	return nRet;
}

// -----------------------------------------------------------------------

long PicaToMM( long nIn )
{
	long nRet = 0;

	if ( nIn <= ( LONG_MAX / 12 / 200 ) && nIn >= ( LONG_MIN / 12 / 200 ) )
		nRet = nIn * 12 * 200 / 567;
	return nRet;
}

// -----------------------------------------------------------------------

long TwipsToInch( long nIn )
{
	long nRet = nIn / 1440;
	return nRet;
}

// -----------------------------------------------------------------------

long CMToInch( long nIn )
{
	long nRet = 0;

	if ( nIn <= ( LONG_MAX / 100 ) && nIn >= ( LONG_MIN / 100 ) )
		nRet = nIn * 100 / 254;
	return nRet;
}

// -----------------------------------------------------------------------

long MMToInch( long nIn )
{
	long nRet = 0;

	if ( nIn <= ( LONG_MAX / 10 ) && nIn >= ( LONG_MIN / 10 ) )
		nRet = nIn * 10 / 254;
	return nRet;
}

// -----------------------------------------------------------------------

long PointToInch( long nIn )
{
	long nRet = nIn / 72;
	return nRet;
}

// -----------------------------------------------------------------------

long PicaToInch( long nIn )
{
	long nRet = nIn / 6;
	return nRet;
}

// -----------------------------------------------------------------------

long TwipsToPoint( long nIn )
{
	long nRet = nIn / 20;
	return nRet;
}

// -----------------------------------------------------------------------

long InchToPoint( long nIn )
{
	long nRet = 0;

	if ( nIn <= ( LONG_MAX / 72 ) && nIn >= ( LONG_MIN / 72 ) )
		nRet = nIn * 72;
	return nRet;
}

// -----------------------------------------------------------------------

long CMToPoint( long nIn )
{
	long nRet = 0;

	if ( nIn <= ( LONG_MAX / 567 ) && nIn >= ( LONG_MIN / 567 ) )
		nRet = nIn * 567 / 20;
	return nRet;
}

// -----------------------------------------------------------------------

long MMToPoint( long nIn )
{
	long nRet = 0;

	if ( nIn <= ( LONG_MAX / 567 ) && nIn >= ( LONG_MIN / 567 ) )
		nRet = nIn * 567 / 200;
	return nRet;
}

// -----------------------------------------------------------------------

long PicaToPoint( long nIn )
{
	long nRet = nIn / 12;
	return nRet;
}

// -----------------------------------------------------------------------

long TwipsToPica( long nIn )
{
	long nRet = nIn / 240;
	return nRet;
}

// -----------------------------------------------------------------------

long InchToPica( long nIn )
{
	long nRet = 0;

	if ( nIn <= ( LONG_MAX / 6 ) && nIn >= ( LONG_MIN / 6 ) )
		nRet = nIn * 6;
	return nRet;
}

// -----------------------------------------------------------------------

long PointToPica( long nIn )
{
	long nRet = 0;

	if ( nIn <= ( LONG_MAX / 12 ) && nIn >= ( LONG_MIN / 12 ) )
		nRet = nIn * 12;
	return nRet;
}

// -----------------------------------------------------------------------

long CMToPica( long nIn )
{
	long nRet = 0;

	if ( nIn <= ( LONG_MAX / 567 ) && nIn >= ( LONG_MIN / 567 ) )
		nRet = nIn * 567 / 20 / 12;
	return nRet;
}

// -----------------------------------------------------------------------

long MMToPica( long nIn )
{
	long nRet = 0;

	if ( nIn <= ( LONG_MAX / 567 ) && nIn >= ( LONG_MIN / 567 ) )
		nRet = nIn * 567 / 200 / 12;
	return nRet;
}

// -----------------------------------------------------------------------

long Nothing( long nIn )
{
	long nRet = nIn;
	return nRet;
}

FUNC_CONVERT ConvertTable[6][6] =
{
//  CM,			MM			INCH		 POINT		  PICAS=32	   TWIPS
	{ Nothing, 	CMToMM, 	CMToInch,    CMToPoint,   CMToPica,    CMToTwips },
	{ MMToCM,		Nothing,	MMToInch,	 MMToPoint,   MMToPica,    MMToTwips },
	{ InchToCM,	InchToMM,	Nothing,	 InchToPoint, InchToPica,  InchToTwips },
	{ PointToCM,	PointToMM,  PointToInch, Nothing,	  PointToPica, PointToTwips },
	{ PicaToCM,	PicaToMM,   PicaToInch,  PicaToPoint, Nothing,	   PicaToTwips },
	{ TwipsToCM,	TwipsToMM,  TwipsToInch, TwipsToPoint,TwipsToPica, Nothing }
};

// -----------------------------------------------------------------------

long TransformMetric( long nVal, FieldUnit aOld, FieldUnit aNew )
{
	if ( aOld == FUNIT_NONE	  || aNew == FUNIT_NONE ||
		 aOld == FUNIT_CUSTOM || aNew == FUNIT_CUSTOM )
	{
		return nVal;
	}

	sal_uInt16 nOld = 0;
	sal_uInt16 nNew = 0;

	switch ( aOld )
	{
		case FUNIT_CM:
			nOld = 0; break;
		case FUNIT_MM:
			nOld = 1; break;
		case FUNIT_INCH:
			nOld = 2; break;
		case FUNIT_POINT:
			nOld = 3; break;
		case FUNIT_PICA:
			nOld = 4; break;
		case FUNIT_TWIP:
			nOld = 5; break;
        default: ;//prevent warning
    }

	switch ( aNew )
	{
		case FUNIT_CM:
			nNew = 0; break;
		case FUNIT_MM:
			nNew = 1; break;
		case FUNIT_INCH:
			nNew = 2; break;
		case FUNIT_POINT:
			nNew = 3; break;
		case FUNIT_PICA:
			nNew = 4; break;
		case FUNIT_TWIP:
			nNew = 5; break;
        default: ;//prevent warning
    }
	return ConvertTable[nOld][nNew]( nVal );
}