/*

* Copyright (c) 1999-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: 

* Base class functions for TAGMA's text source interface classes.

*

*/

#include <txtfrmat.h>

#include <txtetext.h>

#include "TAGMA.H"

#include "TMSTD.H"

#include <linebreak.h>

inline TBool IsSurrogate(TText a) { return 0xD800 == (a & 0xF800); }

/**

Convert a system colour index to a system colour, using or modifying the supplied default colour if desired.

*/

EXPORT_C TRgb MTmCustom::SystemColor(TUint /*aColorIndex*/,TRgb aDefaultColor) const

	{

	return aDefaultColor;

	}

/**

Return the level of stretchability; the relative desirability of inserting space after a character

when fully justifying. A value of zero means that the character cannot be stretched. Higher values

mean greater stretchability.

*/

EXPORT_C TInt MTmCustom::Stretch(TUint aChar) const

	{

	// Ordinary spaces and non-break spaces are most stretchable.

	if (aChar == 0x0020 || aChar == 0x00A0)

		return 3;

	// Nothing else in General Scripts, Symbols, Surrogates, Private Use, Compatibility, and Specials is stretchable.

	if (aChar < 0x3000 || aChar >= 0xD800)

		return 0;

	// Ideographs, Hangul, Bopomofo, Kanbun, etc., are stretchable if nothing else is available.

	if (aChar <= 0x303F || aChar >= 0x3100)

		return 1;

	// Katakana and hiragana are more stretchable than ideographs but less so than ordinary spaces.

	return 2;

	}

/**

The default function to map a character to the character drawn, or to 0xFFFF if the character is not to be drawn.

*/

EXPORT_C TUint MTmCustom::Map(TUint aChar) const

	{

	// Deal with some easy cases without calling TChar::GetCategory.

	if (aChar >= 0x0020 && aChar <= 0x007E) // ascii

		return aChar;

	if (aChar >= 0x00A1 && aChar <= 0x021F) // latin supplement & contiguous latin extended

		{

		if (aChar == CEditableText::EPotentialHyphen) //0x00AD

			return '-'; //0x002D

		return aChar;

		}

	if (aChar >= 0xE000 && aChar <= 0xF8FF) // private use area

		return aChar;

	// All special hyphens are represented as an ordinary  hyphen.

	if (aChar == CEditableText::ENonBreakingHyphen)

		return '-';

	// Picture characters are turned into 0x25A3 (black square inside white square).

	if (aChar == CEditableText::EPictureCharacter)

		return 0x25A3;

	// Zero-width space not drawn

	if (aChar == 0x200B)

		return 0xFFFF;

	// Hard space rendered as normal space

	if (aChar == 0xA0)

		return 0x20;

	// don't show corrupt surrogate

	if (IsSurrogate(aChar))

		{

		//This is an informationl message. Commented out to avoid annoyance

		//RDebug::Print(_L("Error: Do not show corrupt surrogate %X."), aChar);

		return 0xFFFF;

		}

	TChar::TCategory cat = TChar(aChar).GetCategory();

	// Control characters and unassigned characters are usually not understood

	// by CFont::DrawText. Some are and must be present to get the correct

	// result.

	if (cat > TChar::EZsCategory

		&& aChar != KZeroWidthJoiner

		&& aChar != KZeroWidthNonJoiner)

		return 0xFFFF;

	// Other characters are left alone.

	return aChar;

	}

/** 

The default function to set the line height.

*/

EXPORT_C void MTmCustom::SetLineHeight(const TLineHeightParam& aParam,TInt& aAscent,TInt& aDescent) const

	{

	// Set the ascent and descent to the maximum font ascent and descent.

	aAscent = aParam.iFontMaxAscent;

	aDescent = aParam.iFontMaxDescent;

	// Adjust to take account of desired line height.

	if (aAscent + aDescent < aParam.iDesiredLineHeight)

		aDescent = aParam.iDesiredLineHeight - aAscent;

	else if (aAscent + aDescent > aParam.iDesiredLineHeight && aParam.iExactLineHeight)

		{

		aDescent = Max(0,(aParam.iDesiredLineHeight - aAscent));

		aAscent = aParam.iDesiredLineHeight - aDescent;

		}

	/*

	Try to accommodate the maximum font height by increasing the ascent and reducing the descent by the same amount.

	Using the maximum font height rather than the maximum character height preserves line spacing where possible.

	*/

	int excess = Max(0,aParam.iFontMaxCharHeight - aAscent);

	int descent_available = Max(0,aDescent - aParam.iFontMaxCharDepth);

	int ascent_increase = Min(excess,descent_available);

	aAscent += ascent_increase;

	aDescent -= ascent_increase;

	/*

	If that is not possible, adjust the height and depth to accommodate the highest and deepest characters

	and the tallest vertically floating picture. Don't do this, of course, if the line spacing was specified

	as an exact requirement.

	*/

	if (!aParam.iExactLineHeight)

		{

		if (aParam.iMaxCharHeight > aAscent)

			aAscent = aParam.iMaxCharHeight;

		if (aParam.iMaxCharDepth > aDescent)

			aDescent = aParam.iMaxCharDepth;

		/*

		If there are only top-aligned overheight pictures any excess goes into the descent,

		and if there are only bottom-aligned overheight pictures any excess goes into the ascent,

		otherwise any excess is distributed evenly between ascent and descent.

		*/

		int top_excess = aParam.iMaxTopPictureHeight - (aAscent + aDescent);

		int bottom_excess = aParam.iMaxBottomPictureHeight - (aAscent + aDescent);

		int centre_excess = aParam.iMaxCenterPictureHeight - (aAscent + aDescent);

		if (top_excess > 0 && bottom_excess <= 0 && centre_excess <= 0)

			aDescent += top_excess;

		else if (top_excess <= 0 && bottom_excess > 0 && centre_excess <= 0)

			aAscent += bottom_excess;

		else

			{

			centre_excess = Max(centre_excess,top_excess);

			centre_excess = Max(centre_excess,bottom_excess);

			if (centre_excess > 0)

				{

				aAscent += centre_excess / 2;

				aDescent += centre_excess - centre_excess / 2;

				}

			}

		}

	}

/**

The default function to drawn the background. It fills the supplied rectangle with the background colour.

*/

EXPORT_C void MTmCustom::DrawBackground(CGraphicsContext& aGc,const TPoint& /*aTextLayoutTopLeft*/,const TRect& aRect,

										const TLogicalRgb& aBackground,TRect& aRectDrawn) const

	{

	aGc.SetBrushStyle(CGraphicsContext::ESolidBrush);

	SetBrushColor(aGc,aBackground);

	aGc.SetPenStyle(CGraphicsContext::ENullPen);

	aGc.DrawRect(aRect);

	aRectDrawn = aRect;

	}

/**

By default no line graphics are drawn.

*/

EXPORT_C void MTmCustom::DrawLineGraphics(CGraphicsContext& /*aGc*/,const TPoint& /*aTextLayoutTopLeft*/,

										  const TRect& /*aRect*/,const TTmLineInfo& /*aLineInfo*/) const

	{

	}

/**

Draw text and its highlit background if any. The text should be drawn with its origin

at aTextOrigin after optionally drawing the background in aRect; and the text should be expanded

in width by aExtraPixels, normally by using letterspacing. The default function

draws the text with no special effects and supports standard and rounded highlighting only.

The font, colour, and text style, which are specified in aFormat, have already been selected into the graphics context.

*/

EXPORT_C void MTmCustom::DrawText(CGraphicsContext& aGc,const TPoint& aTextLayoutTopLeft,const TRect& aRect,

								  const TTmLineInfo& aLineInfo,const TTmCharFormat& aFormat,

								  const TDesC& aText,const TPoint& aTextOrigin,TInt aExtraPixels) const

	{

	MTmCustomExtension c;

	c.DrawText(aGc,aTextLayoutTopLeft,aRect,aLineInfo,aFormat,aText,-1,-1,aTextOrigin,aExtraPixels);

	}

/** Draw the picture onto the graphics context.

@param aGc The graphics context.

@param aTopLeft Coordinates of the top left corner pixel of the picture.

@param aRect A clipping rectangle that defines the area to draw the picture.

@param aDevice The device map for the graphics device. It provides

the scaling to apply to the picture.

@param aPicture The drawable object.

@see CPicture::Draw

*/

EXPORT_C void MTmCustom::DrawPicture(CGraphicsContext& aGc,

	const TPoint& aTopLeft, const TRect& aRect,

	MGraphicsDeviceMap& aDevice, const CPicture& aPicture) const

	{

	aGc.SetClippingRect(aRect);

	aPicture.Draw(aGc, aTopLeft, aRect, &aDevice);

	}

/** This function translates logical colours specified in FORM objects into

real colours.

It extracts the logical colour index stored in TLogicalRgb and invokes

<code>MtmCustom::SystemColor(TUint, TRgb)</code> to convert the logical colour to

real colour.

@param aColor The logical colour to translate.

@return The real colour represesented by the logical colour.

*/

EXPORT_C TRgb MTmCustom::SystemColor(TLogicalRgb aColor) const

	{

	MTmCustomExtension c;

	return c.SystemColor(aColor);

	}

/** Sets the pen colour.

The pen is used to draw lines, the outlines of filled shapes, and text.

@param aColor The logical colour for the pen. 

@see CGraphicsContext::SetPenColor()

*/

EXPORT_C void MTmCustom::SetPenColor(CGraphicsContext& aGc,TLogicalRgb aColor) const

	{	

	MTmCustomExtension c;

	c.SetPenColor(aGc,aColor);

	}

/** Sets the brush colour.

The brush is used for filling shapes and the background of text boxes. The 

brush has colour, style, pattern and pattern origin parameters.

If no brush colour has been set, it defaults to white. However the default 

brush style is null, so when drawing to a window the default appears to be 

the window's background colour.

@param aColor The logical colour for the brush. 

@see CGraphicsContext::SetDrawMode()

*/

EXPORT_C void MTmCustom::SetBrushColor(CGraphicsContext& aGc,TLogicalRgb aColor) const

	{

	MTmCustomExtension c;

	c.SetBrushColor(aGc,aColor);

	}

/**************************MTmCustomExtension*************************************************/

/**

Convert a system colour index to a system colour, using or modifying the supplied default colour if desired.

*/

EXPORT_C TRgb MTmCustomExtension::SystemColor(TUint /*aColorIndex*/,TRgb aDefaultColor) const

	{

	return aDefaultColor;

	}

/**

Draw text and its highlit background if any. The text should be drawn with its origin

at aTextOrigin after optionally drawing the background in aRect; and the text should be expanded

in width by aExtraPixels, normally by using letterspacing. The default function

draws the text with no special effects and supports standard and rounded highlighting only.

The font, colour, and text style, which are specified in aFormat, have already been selected into the graphics context.

*/

EXPORT_C void MTmCustomExtension::DrawText(CGraphicsContext& aGc,const TPoint& /*aTextLayoutTopLeft*/,const TRect& aRect,

								  const TTmLineInfo& /*aLineInfo*/,const TTmCharFormat& aFormat,

								  const TDesC& aText,const TInt aStart, const TInt aEnd, const TPoint& aTextOrigin,TInt aExtraPixels) const

	{

	TUint effects = aFormat.iEffects;

	CGraphicsContext::TTextParameters contextParam;

	contextParam.iStart = aStart;

	contextParam.iEnd = aEnd;

	// Draw the highlight.

	if (effects)

		{

		if (effects & TTmCharFormat::EBackground)

			{

			// Draw the background.

			if (!(effects & TTmCharFormat::ERounded))

				{

				SetBrushColor(aGc,aFormat.iBackgroundColor);

				aGc.SetBrushStyle(CGraphicsContext::ESolidBrush);

				aGc.SetPenStyle(CGraphicsContext::ENullPen);

				aGc.DrawRect(aRect);

				aGc.SetPenStyle(CGraphicsContext::ESolidPen);

				}

			// Draw the background with rounded corners.

			else

				{

				/*

				The pen is made solid, not null, and the pen colour is set, to

				work around some bugs in DrawRoundRect: see ER5U defect EDNGASR-487K64.

				*/

				SetBrushColor(aGc,aFormat.iBackgroundColor);

				aGc.SetBrushStyle(CGraphicsContext::ESolidBrush);

				aGc.SetPenStyle(CGraphicsContext::ESolidPen);

				SetPenColor(aGc,aFormat.iBackgroundColor);

				TSize corner(Min(aRect.Height(),aRect.Width()) / 3,aRect.Height() / 3);

				aGc.DrawRoundRect(aRect,corner);

				//+ fill in flat side if needed; draw ordinary rectangle if both sides are flat.

				SetPenColor(aGc,aFormat.iTextColor);

				}

			}

		// Draw the text offset towards the bottom-right in the highlight colour before drawing in the text colour.

		else if (effects & TTmCharFormat::EShadow)

			{

			SetPenColor(aGc,aFormat.iBackgroundColor);

			if (aExtraPixels)

				aGc.SetCharJustification(aExtraPixels,aText.Length());

			TPoint p(aTextOrigin);

			p.iX += 2;

			p.iY += 2;

			if (aStart < 0 || aEnd < 0)

				aGc.DrawText(aText,p);

			else

				aGc.DrawText(aText,&contextParam,p);

			SetPenColor(aGc,aFormat.iTextColor);

			}

		}

	// Draw the text, with letterspacing if needed.

	if (aExtraPixels)

		aGc.SetCharJustification(aExtraPixels,aText.Length());

	if (aStart < 0 || aEnd < 0)

		aGc.DrawText(aText,aTextOrigin);

	else	

		aGc.DrawText(aText,&contextParam,aTextOrigin);

	}

/** This function translates logical colours specified in FORM objects into

real colours.

It extracts the logical colour index stored in TLogicalRgb and invokes

<code>MtmCustom::SystemColor(TUint, TRgb)</code> to convert the logical colour to

real colour.

@param aColor The logical colour to translate.

@return The real colour represesented by the logical colour.

*/

EXPORT_C TRgb MTmCustomExtension::SystemColor(TLogicalRgb aColor) const

	{

	TUint index = aColor.SystemColorIndex();

	if (index)

		return SystemColor(index,aColor) & 0xFFFFFF;

	return aColor;

	}

/** Sets the pen colour.

The pen is used to draw lines, the outlines of filled shapes, and text.

@param aColor The logical colour for the pen. 

@see CGraphicsContext::SetPenColor()

*/

EXPORT_C void MTmCustomExtension::SetPenColor(CGraphicsContext& aGc,TLogicalRgb aColor) const

	{

	aGc.SetPenColor(SystemColor(aColor));

	}

/** Sets the brush colour.

The brush is used for filling shapes and the background of text boxes. The 

brush has colour, style, pattern and pattern origin parameters.

If no brush colour has been set, it defaults to white. However the default 

brush style is null, so when drawing to a window the default appears to be 

the window's background colour.

@param aColor The logical colour for the brush. 

@see CGraphicsContext::SetDrawMode()

*/

EXPORT_C void MTmCustomExtension::SetBrushColor(CGraphicsContext& aGc,TLogicalRgb aColor) const

	{

	aGc.SetBrushColor(SystemColor(aColor));

	}

/***************************MTmCustomExtension End********************************************/

/**

Return the end of the paragraph - after the paragraph separator if any.

*/

EXPORT_C TInt MTmSource::ParagraphEnd(TInt aPos) const

	{

	TInt doc_end = DocumentLength();

	TPtrC text;

	TTmCharFormat format;

	while (aPos < doc_end)

		{

		GetText(aPos,text,format);

		const TText *p = text.Ptr();

		const TText *q = p + text.Length();

		while (p < q)

			if (*p == CEditableText::EParagraphDelimiter)

				return aPos + 1;

			else

				{

				p++;

				aPos++;

				}

		}

	return doc_end + 1;

	}

/**

The default function to get a picture; override this if there are pictures in the document.

*/

EXPORT_C CPicture* MTmSource::PictureL(TInt /*aPos*/) const

	{

	return NULL;

	}

// The default function to get a picture's size; override this if there are pictures in the document.

EXPORT_C TInt MTmSource::GetPictureSizeInTwipsL(TInt /*aPos*/,TSize& /*aSize*/) const

	{

	return KErrNotFound;

	}

/**

The default function to select label mode for a paragraph containing a particular position.

If a label of the selected type exists for the paragraph, the mode is selected and the source

returns the text of the label, not the main text, until the mode is cancelled. The return value

is ETrue if a label exists, EFalse otherwise. This means that FALSE must be returned if label mode

has already been selected.

*/

EXPORT_C TBool MFormLabelApi::LabelModeSelect(MTmSource::TLabelType /*aType*/, TInt /*aPos*/)

	{

	return EFalse;

	}

/**

Cancel any label mode that has been selected.

*/

EXPORT_C void MFormLabelApi::LabelModeCancel()

	{

	}

/**

Get the size and margin size for a label. The maximum width and height for the label text

are placed in aLabelSize and the width or height of the margin containing the label in aMarginSize.

Whether the label is placed left, right, above or below the text and whether the label is

centred in the margin or placed flush with one of its edges depends on the label type.

*/

EXPORT_C void MFormLabelApi::LabelMetrics(MTmSource::TLabelType /*aType*/, TSize& aLabelSize, TInt& aMarginSize) const

	{

	aLabelSize.iWidth = 0;

	aLabelSize.iHeight = 0;

	aMarginSize = 0;

	}

EXPORT_C TAny* MTmSource::GetExtendedInterface(const TUid& /*aInterfaceId*/)

	{

	return NULL;

	}

/**

@internalAll

@released

*/

EXPORT_C void MTmSource::MTmSource_Reserved_1()

	{

	}

/**

@internalAll

@released

*/

EXPORT_C void MTmSource::MTmSource_Reserved_2()

	{

	}

/** Returns whether line break is possible between two characters.

@param aPrevClass The class before the potential line break.

@param aNextClass The class after the potential line break.

@param aHaveSpaces Whether spaces separate the characters.

@return ETrue if a line break is possible between characters with the two line

break classes, EFalse if not.

@see MLineBreaker::LineBreakPossible()

*/

EXPORT_C TBool MTmCustom::LineBreakPossible(TUint aPrevClass,TUint aNextClass,TBool aHaveSpaces) const

	{

	MLineBreaker b;

	return b.LineBreakPossible(aPrevClass, aNextClass, aHaveSpaces);

	}

/** Converts Unicode character into line breaking class.

@param aCode Input Unicode value.

@param aRangeStart Returns the start of the contiguous range of characters 

including aCode that have the returned line breaking class.

@param aRangeEnd Returns the end of the contiguous range of characters including 

aCode that have the returned line breaking class.

@return The line breaking class for aCode.

@see MLineBreaker::LineBreakClass()

*/

EXPORT_C TUint MTmCustom::LineBreakClass(TUint aCode,TUint& aRangeStart,TUint& aRangeEnd) const

	{

	MLineBreaker b;

	return b.LineBreakClass(aCode, aRangeStart, aRangeEnd);