// Copyright (c) 1997-2009 Nokia Corporation and/or its subsidiary(-ies).

// All rights reserved.

// This component and the accompanying materials are made available

// under the terms of "Eclipse Public License v1.0"

// which accompanies this distribution, and is available

// at the URL "http://www.eclipse.org/legal/epl-v10.html".

//

// Initial Contributors:

// Nokia Corporation - initial contribution.

//

// Contributors:

//

// Description:

//

#include <s32file.h>

#include <s32std.h>

#include <badesca.h>

#include <barsread.h>

#include <bautils.h>

#include <gdi.h>

#include <w32std.h>

#include <gulutil.h>

#include <gulcolor.h>

#include "GULSTD.H"

#include "GULLU.H"

#include <gulfont.hrh>

#include <gulftflg.hrh>

#include <numberconversion.h>

//

// TMargins8

//

EXPORT_C TMargins8::TMargins8()

/** The constructor initialises all four margins to zero. */

	{

	iLeft=iRight=iTop=iBottom=(TInt8)0;

	}

/**

Constructor setting the left, top, right, and bottom margins.

@param aLeft Left margin (between -128 and +127)

@param aTop Top margin (between -128 and +127)

@param aRight Right margin (between -128 and +127)

@param aBottom Bottom margin (between -128 and +127)

*/

EXPORT_C TMargins8::TMargins8(TInt8 aLeft, TInt8 aTop, TInt8 aRight, TInt8 aBottom) 

 : iLeft(aLeft), iRight(aRight), iTop(aTop), iBottom(aBottom)

	{

	}

EXPORT_C void TMargins8::SetAllValuesTo(TInt aCommonValue)

/** Sets all four margins to a common value (between -128 and +127).

@param aCommonValue The new value for all margins. */

	{

	iLeft=iRight=iTop=iBottom=(TInt8)aCommonValue;

	}

EXPORT_C TRect TMargins8::InnerRect(const TRect& aOuterRect) const

/** Calculates and returns an inner rectangle by applying the margins 

to the specified outer rectangle.

@param aOuterRect The coordinates of the outer rectangle from which 

the inner rectangle is calculated.

@return Inner rectangle. */

	{

    TRect inner=aOuterRect;

    inner.iTl.iX+=iLeft;

    inner.iTl.iY+=iTop;

    inner.iBr.iX-=iRight;

    inner.iBr.iY-=iBottom;

    return inner;

	}

EXPORT_C TRect TMargins8::OuterRect(const TRect& aInnerRect) const

/** Calculates and returns an outer rectangle by applying the margins 

to the specified inner rectangle.

@param aInnerRect The coordinates of the inner rectangle from which 

the outer rectangle is calculated.

@return Outer rectangle. */

	{

    TRect outer=aInnerRect;

    outer.iTl.iX-=iLeft;

    outer.iTl.iY-=iTop;

    outer.iBr.iX+=iRight;

    outer.iBr.iY+=iBottom;

    return outer;

	}

EXPORT_C TSize TMargins8::SizeDelta() const

/** Calculates and returns the difference in size between the outer 

and inner rectangles.

@return Size difference between outer and inner rectangles. */

	{

	return TSize(iLeft+iRight,iTop+iBottom);

	}

//

// class DrawUtils

//

EXPORT_C void DrawUtils::DrawText(CGraphicsContext& aGc,const TDesC& aString,const TRect& aBox,TInt aBaseLineOffset,

									 CGraphicsContext::TTextAlign aHoriz,TInt aMargin,const CFont* aFont)

/** Draws text inside a rectangle. 

@param aGc The graphics context.

@param aString The text string to draw. 

@param aBox The rectangle to draw the text in. 

@param aBaseLineOffset An offset from the top of the box to the text baseline. 

@param aHoriz The horizontal text alignment.

@param aMargin The margin around the text.

@param aFont The font to use. */

	{ // static

	if (aHoriz!=CGraphicsContext::ELeft)

        {

		const TInt extraWidth=aBox.Width()-aFont->TextWidthInPixels(aString)-aMargin;

        if (aHoriz==CGraphicsContext::ECenter)

            aMargin+=extraWidth/2;

		else

			aMargin=extraWidth;

        }

	aGc.DrawText(aString,aBox,aBaseLineOffset,CGraphicsContext::ELeft,aMargin);

	}

EXPORT_C void DrawUtils::ClearBetweenRects(CGraphicsContext& aGc,const TRect& aOuterRect,const TRect& aInnerRect)

/** Clears between two rectangles, using a solid brush style and no pen.

@param aGc The graphics context.

@param aOuterRect The outer rectangle.

@param aInnerRect The inner rectangle. */

    { // static

    aGc.SetPenStyle(CGraphicsContext::ENullPen);

    aGc.SetBrushStyle(CGraphicsContext::ESolidBrush);

    DrawBetweenRects(aGc,aOuterRect,aInnerRect);

    aGc.SetPenStyle(CGraphicsContext::ESolidPen);

    aGc.SetBrushStyle(CGraphicsContext::ENullBrush);

    }

EXPORT_C void DrawUtils::DrawBetweenRects(CGraphicsContext& aGc,const TRect& aOuterRect,const TRect& aInnerRect)

/** Draws between two rectangles.

The pen and brush settings are used as specified in the graphics context.

@param aGc The graphics context.

@param aOuterRect The outer rectangle to be drawn.

@param aInnerRect The inner rectangle to be drawn. */

    { // static

    TRect rect=aOuterRect;

    rect.iBr.iY=aInnerRect.iTl.iY;

    aGc.DrawRect(rect);

    rect.iBr.iY=aOuterRect.iBr.iY;

    rect.iTl.iY=aInnerRect.iBr.iY;

    aGc.DrawRect(rect);

    rect=aInnerRect;

    rect.iTl.iX=aOuterRect.iTl.iX;

    rect.iBr.iX=aInnerRect.iTl.iX;

    aGc.DrawRect(rect);

    rect.iTl.iX=aInnerRect.iBr.iX;

    rect.iBr.iX=aOuterRect.iBr.iX;

    aGc.DrawRect(rect);

    }

//

// class TextUtils

//	

EXPORT_C void TextUtils::ClipToFit(TDes& aBuffer,const CFont& aFont,TInt aMaxWidthInPixels,TChar aAlternativeEnd)

/** Clips text to fit into a maximum width.

If the text is too wide to fit in the width when displayed in aFont, 

it is truncated and the specified character (by default, 

a horizontal ellipsis) is appended to it.

@param aBuffer A buffer containing the text to clip.

@param aFont The font.

@param aMaxWidthInPixels The maximum width in pixels.

@param aAlternativeEnd The Unicode character to append to the buffer if truncated. 

By default, this is the horizontal ellipsis. */

	{

	TInt textWidth=aFont.TextWidthInPixels(aBuffer);

	if (textWidth<=aMaxWidthInPixels)

		return;

	TBuf<1> ellipse;

	ellipse.Append(aAlternativeEnd);

	TInt extraWidth=aFont.TextWidthInPixels(ellipse);

	TInt cutOff=aFont.TextCount(aBuffer,aMaxWidthInPixels-extraWidth);

	aBuffer.SetLength(cutOff);

	aBuffer.Append(ellipse);

	}

EXPORT_C TInt TextUtils::ColumnText(TPtrC& aColumnText,TInt aColumn,const TDesC* aSourceText,TChar aColumnSeparator)

/** Gets a portion of text from a descriptor, corresponding to a requested column.

@param aColumnText On return, set to the portion of aSourceText that corresponds 

to the column aColumn.

@param aColumn The column to extract. The first column is numbered zero.

@param aSourceText The source text string that contains one or more column 

separators.

@param aColumnSeparator The character used in aSourceText to separate the columns. 

By default, a tab character.

@return KErrNotFound if the column number is invalid, otherwise KErrNone. */

	{

	aColumnText.Set(TPtrC());

	TInt end=0;

	TInt column=0;

	TPtrC text;

	if (aSourceText)

		text.Set(*aSourceText);

	while (text.Length())

		{

		end=text.Locate(aColumnSeparator);

		if (end==KErrNotFound)

			end=text.Length();

		if (column==aColumn)

			{

			aColumnText.Set(text.Left(end));

			return(KErrNone);

			}

		else if (++column>aColumn)

			break;

		if (end<text.Length())

			++end;

		text.Set(text.Mid(end));

		}

	return(KErrNotFound);

	}

EXPORT_C void TextUtils::TruncateToNumChars(TDes& aBuffer, TInt numChars)

/** Truncates text to a number of characters.

If truncation is required (because aBuffer contains more than numChars 

characters), an ellipsis is added to the text as the last character.

@param aBuffer On return, contains the truncated text.

@param numChars The number of characters. */

	{

	if (aBuffer.Length() <= numChars)

		return;

	aBuffer.SetLength(numChars-1);

	aBuffer.Append(KTextUtilClipEndChar);

	}

//

// class FontUtils

//

enum { EMinFontHeight=4 };

EXPORT_C void FontUtils::GetAvailableFontsL(const CGraphicsDevice& aDevice, CDesCArray& aFontNameList,TInt aFonts)

/** Gets the list of typeface names available for the graphics device.

@param aDevice The graphics device.

@param aFontNameList On return, contains the list of typeface names.

@param aFonts Can be used to specify which sorts of typefaces are required. 

For possible values, see the flags defined in gulftflg.hrh 

beginning with EGulAllFonts. */

	{ // static

	aFontNameList.Reset();

	const TInt numTypefaces=aDevice.NumTypefaces();

	TTypefaceSupport typefaceInfo;

	for (TInt ii=0;ii<numTypefaces;ii++)

		{

		aDevice.TypefaceSupport(typefaceInfo,ii);

		if (typefaceInfo.iTypeface.IsProportional())

			{

			if (aFonts==EGulMonospaceFontsOnly)

				continue;

			}

		else if (aFonts==EGulNoMonospaceFonts || aFonts==EGulNoMonospaceOrSymbolFonts)

			continue;

		if (typefaceInfo.iTypeface.IsSymbol())

			{

			if (aFonts==EGulNoSymbolFonts || aFonts==EGulNoMonospaceOrSymbolFonts || aFonts==EGulMonospaceFontsOnly)

				continue;

			}

		else if (aFonts==EGulSymbolFontsOnly)

			continue;

		aFontNameList.AppendL(typefaceInfo.iTypeface.iName);

		}

	}

EXPORT_C TInt FontUtils::TypefaceAttributes(const CGraphicsDevice& aDevice, const TDesC& aTypefaceName)

/** Gets the attributes of a named typeface, if supported by the graphics device.

@param aDevice The graphics device.

@param aTypefaceName The name of the typeface.

@return The typeface attributes. Attributes are zero if the typeface is not 

supported by the graphics device. Attribute values are defined in TTypeface. */

	{

	const TInt numTypefaces=aDevice.NumTypefaces();

	TInt fontIndex;

	for (fontIndex=0;fontIndex<numTypefaces;fontIndex++)

		{

    	TTypefaceSupport typefaceInfo;

		aDevice.TypefaceSupport(typefaceInfo,fontIndex);

		if (typefaceInfo.iTypeface.iName==aTypefaceName)

			return(typefaceInfo.iTypeface.Attributes());

		}	

	return(0);

	}

EXPORT_C TInt FontUtils::GetAvailableHeightsInTwipsL(const CGraphicsDevice& aDevice,const TDesC& aTypefaceName,CArrayFix<TInt>& aHeightList)

/** Gets a list of all heights in twips, available for the named typeface and the 

graphics device specified.

@param aDevice The graphics device.

@param aTypefaceName The name of the typeface.

@param aHeightList On return, contains all available heights for the typeface, 

in twips. 

@return KErrNotSupported if the named typeface is not supported by the graphics 

device, otherwise KErrNone. */

	{ // static

	aHeightList.Reset();

	const TInt numTypefaces=aDevice.NumTypefaces();

	TInt fontIndex;

	for (fontIndex=0;fontIndex<numTypefaces;fontIndex++)

		{

    	TTypefaceSupport typefaceInfo;

		aDevice.TypefaceSupport(typefaceInfo,fontIndex);

		if (typefaceInfo.iTypeface.iName==aTypefaceName)

			break;

		}

	if (fontIndex>=numTypefaces)

		return KErrNotSupported;

	TTypefaceSupport typefaceInfo;

	aDevice.TypefaceSupport(typefaceInfo,fontIndex);

	const TInt numHeights=typefaceInfo.iNumHeights;

	for (TInt ii=0;ii<numHeights;ii++)

		{

		const TInt height=aDevice.FontHeightInTwips(fontIndex,ii);

		if (PointsFromTwips(height)>=EMinFontHeight)

			aHeightList.AppendL(height);

		}

	return KErrNone;

	}

EXPORT_C TInt FontUtils::GetAvailableHeightsInTwipsAndPointsL(const CGraphicsDevice& aDevice,const TDesC& aTypefaceName,CArrayFix<TInt>& aTwipsList,CDesCArray& aPointsList)

/** Gets a list of all heights in twips, available for the named typeface and the 

graphics device specified.

Also gets a list of heights in points, represented as character strings.

@param aDevice The graphics device.

@param aTypefaceName The name of the typeface.

@param aTwipsList On return, contains all available heights for the typeface, 

in twips.

@param aPointsList On return, the heights in points, represented as character 

strings.

@return KErrNotSupported if the named typeface is not supported by the graphics 

device, otherwise KErrNone. */

	{ // static

	aTwipsList.Reset();

	aPointsList.Reset();

	TInt err=GetAvailableHeightsInTwipsL(aDevice,aTypefaceName,aTwipsList);

	if (err==KErrNotSupported)

		return err;

	const TInt count=aTwipsList.Count();

	for (TInt ii=0;ii<count;ii++)

		{

		const TInt points=PointsFromTwips(aTwipsList[ii]);

		if (points<EMinFontHeight)

			continue;

		TBuf<8> num;

		num.Num(points);

		aPointsList.AppendL(num);

		}

	return KErrNone;

	}

EXPORT_C TInt FontUtils::PointsFromTwips(TInt aTwips)

/** Converts a number of twips to points. 

@param aTwips A number of twips.

@return A number of points. */

	{ // static

	//one point=20 twips

	return (aTwips+10)/20;

	}

EXPORT_C TInt FontUtils::TwipsFromPoints(TInt aPoints)

/** Converts a number of points into twips.

@param aPoints A number of points.

@return A number of twips. */

	{ // static

	//one point=20 twips

	return (aPoints*20);

	}

EXPORT_C TInt FontUtils::TwipsFromPoints(const TDesC& aPoints)

/** Converts a number of points held as text to twips.

@param aPoints A number of points as text.

@return A number of twips. */

	{ // static

	TInt digits=aPoints.Length();

	TInt num=aPoints[--digits];

	TInt count=0;

	while (digits)

		num+=aPoints[--digits]*(++count*10);

	return TwipsFromPoints(num);

	}

EXPORT_C TInt FontUtils::IndexOfNearestHeight(CArrayFix<TInt>& aTwipsList,TInt aHeight)

/** Gets the index into the supplied list of font heights of the closest  

match to the font height specified.

@param aTwipsList The twips list.

@param aHeight The requested font height. This may be generated by a call to GetAvailableHeightsInTwipsL() 

or GetAvailableHeightsInTwipsAndPointsL().

@return The index into the list of the closest font height to aHeight. */

	{ // static

	TInt pos=0;

	const TInt count=aTwipsList.Count();

	for (TInt ii=0; ii<count; ii++)

		{

		if (aTwipsList[ii]>aHeight)

			break;

		pos=ii;

		}

	return pos;

	}

//

// class ResourceUtils

//

EXPORT_C CFbsFont* ResourceUtils::CreateNamedScreenFontL(TResourceReader& aResourceReader,CWsScreenDevice& aScreenDevice)

/** Creates and returns a named screen font from a NAMED_FONT resource.

@param aResourceReader Resource reader to use to read the font information. 

@param aScreenDevice The screen device for which the font will be created. 

@return The screen font, whose size is in twips. The caller takes ownership. */

	{

	TFontSpec fontSpec;

	fontSpec.iTypeface.iName=aResourceReader.ReadTPtrC();

	fontSpec.iHeight=aResourceReader.ReadInt16();

	TUint flags=aResourceReader.ReadUint16(); // a combination of EGulFontFlagXxxxs

	fontSpec.iTypeface.SetIsProportional( !(flags&EGulFontFlagMono) );

	if (flags&EGulFontFlagBold)

		fontSpec.iFontStyle.SetStrokeWeight(EStrokeWeightBold );

	if (flags&EGulFontFlagItalic)

		fontSpec.iFontStyle.SetPosture(EPostureItalic);

	CFbsFont* font;

	User::LeaveIfError(aScreenDevice.GetNearestFontInTwips((CFont*&)font,fontSpec));

	return(font);

	}

EXPORT_C CFbsFont* ResourceUtils::CreateNamedScreenFontInPixelsL(TResourceReader& aResourceReader,CWsScreenDevice& aScreenDevice)

/** Creates a named screen font in pixels from a NAMED_FONT resource.

@param aResourceReader Resource reader to use to read the font information. 

@param aScreenDevice The screen device for which the font will be created. 

@return The screen font, whose size is in pixels. The caller takes ownership. */

	{

	TFontSpec fontSpec;

	fontSpec.iTypeface.iName=aResourceReader.ReadTPtrC();

	fontSpec.iHeight=aResourceReader.ReadInt16();

	TUint flags=aResourceReader.ReadUint16(); // a combination of EGulFontFlagXxxxs

	fontSpec.iTypeface.SetIsProportional( !(flags&EGulFontFlagMono) );

	if (flags&EGulFontFlagBold)

		fontSpec.iFontStyle.SetStrokeWeight(EStrokeWeightBold );

	if (flags&EGulFontFlagItalic)

		fontSpec.iFontStyle.SetPosture(EPostureItalic);

	CFbsFont* font;

	User::LeaveIfError(aScreenDevice.GetNearestFontInPixels((CFont*&)font,fontSpec));

	return(font);

	}

EXPORT_C CFbsFont* ResourceUtils::CreateScreenFontL(TResourceReader& aResourceReader,CWsScreenDevice& aScreenDevice)

/** Creates a screen font from a FONT resource.

@param aResourceReader Resource reader to use to read the font UID and flags. 

@param aScreenDevice The screen device for which the font will be created. 

@return The screen font. The caller takes ownership. */

	{

	TUid fontId;

	fontId.iUid=aResourceReader.ReadInt32();

	TUint flags=aResourceReader.ReadUint16(); // a combination of EGulFontFlagXxxxs

	TAlgStyle algStyle;

	algStyle.SetIsBold(flags&EGulFontFlagBold);

	algStyle.SetIsItalic(flags&EGulFontFlagItalic);

	algStyle.SetIsMono(flags&EGulFontFlagMono);

	algStyle.SetWidthFactor((flags&EGulFontFlagDoubleWidth)? 2: 1); 

	algStyle.SetHeightFactor((flags&EGulFontFlagDoubleHeight)? 2: 1);

	CFbsFont* font;

	User::LeaveIfError(aScreenDevice.GetFontById((CFont*&)font,fontId,algStyle));

	return(font);

	}

EXPORT_C TInt32 ResourceUtils::ReadResourceIntL(TResourceReader& aReader,TResourceTypeInt aSize)

//

//	Read a resource specifying a number

//

	{

	TInt32 value=0;

	switch(aSize)

		{

	case EResourceInt8:

		value=aReader.ReadInt8();

		break;

	case EResourceInt16:

		value=aReader.ReadInt16();

		break;

	case EResourceInt32:

		value=aReader.ReadInt32();

		break;

	default:

		Panic(EEgulPanicResourceInvalidNumberType);

		}

	return(value);

	}