// Copyright (c) 2004-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 <coetextdrawer.h>

//

// class XCoeTextDrawer

//

const TInt KDefaultLineGap = 1;	

//

// class CCoeTextDrawerBaseExt 

//

/**

This extension block is used to to avoid BC breaks in adding to the

main data structures.

@internalComponent

*/

NONSHARABLE_CLASS(CCoeTextDrawerBaseExt) : public CBase

	{

public:

	static CCoeTextDrawerBaseExt* New();

	~CCoeTextDrawerBaseExt();	

	void SetAppLanguage(TLanguage aAppLang);

	TBidiText::TDirectionality DirectionalityToConsider(const TCoeTextTypeAdaptor& aText) const;

private:

	CCoeTextDrawerBaseExt();

	TInt	 Construct();	

private:

	enum TScriptDirectionality

		{

		EScriptDirUndefined,

		EScriptDirLeftToRight,

		EScriptDirRightToLeft

		};	

private:	

	TScriptDirectionality iAppScriptDirectionality;

	};

/**

Create a CCoeTextDrawerBaseExt object.

*/

CCoeTextDrawerBaseExt* CCoeTextDrawerBaseExt::New()

	{

	CCoeTextDrawerBaseExt* self = new CCoeTextDrawerBaseExt();

	if(self->Construct() != KErrNone)

		{

		delete self;

		self = NULL;

		}

	return self;

	}

/**

Constructor.

*/

CCoeTextDrawerBaseExt::CCoeTextDrawerBaseExt()

	{}

/**

Destructor.

*/

CCoeTextDrawerBaseExt::~CCoeTextDrawerBaseExt()

	{}

/**

Second-phase object construction.

*/	

TInt CCoeTextDrawerBaseExt::Construct()

//lint --e{1762} Suppress member function could be made const

	{

	return KErrNone;

	}

/**

Set the application language directionality based on the TLanguage passed as argument.

Passing ELangNone will set the application language directionality to "undefined".

*/	

void CCoeTextDrawerBaseExt::SetAppLanguage(TLanguage aAppLang)

	{

	if(aAppLang == ELangNone)

		iAppScriptDirectionality = EScriptDirUndefined;

	else if (TBidiText::ScriptDirectionality(aAppLang) == TBidiText::ELeftToRight)

		iAppScriptDirectionality = EScriptDirLeftToRight;

	else

		iAppScriptDirectionality = EScriptDirRightToLeft;

	}

/**

Return the language directionality to consider when deciding whether to swap left and right alignment

(for non-absolute horizontal alignment, left and right shall be swapped for scrips with RightToLeft 

directionality, such as Arabic).

If the application language has been set using SetAppLanguage(), the directionality of the languange that the

application is currently running in will be used. If not, the directionality of the actual text being printed

at the moment will be used.

*/	

TBidiText::TDirectionality CCoeTextDrawerBaseExt::DirectionalityToConsider(const TCoeTextTypeAdaptor& aText) const

	{		

	TBidiText::TDirectionality textDirectionality = TBidiText::ELeftToRight;

	if(iAppScriptDirectionality == EScriptDirRightToLeft)

		textDirectionality = TBidiText::ERightToLeft;

	else if(iAppScriptDirectionality == EScriptDirUndefined)

		textDirectionality = (aText.HasRightToLeftDirectionality() ? TBidiText::ERightToLeft : TBidiText::ELeftToRight);

	return textDirectionality;

	}

//

// Class XCoeTextDrawer

//

/**

Use this constructor to create a XCoeTextDrawer object on the stack, inside your control's

Draw() method. The XCoeTextDrawer object will work as a smart-pointer to the CCoeTextDrawerBase

object, managing its life. Get the CCoeTextDrawerBase-derived object to use by calling 

CCoeControl::TextDrawer(). Do not create a new CCoeTextDrawerBase-derived object inside the

Draw() method. If you want to change the text drawer used by the control or any of the control's

children, override the CCoeControl::GetTextDrawer() method. Inside it you can create a new 

CCoeTextDrawerBase object or change the properties of the CCoeTextDrawerBase object passed to it.

*/

EXPORT_C XCoeTextDrawer::XCoeTextDrawer(CCoeTextDrawerBase& aTextDrawer) 

	: iTextDrawer(&aTextDrawer) 

	{

	iClipRect = TRect();	

	}

/**

Destructor. The XCoeTextDrawer object work as a smart-pointer object to the CCoeTextDrawerBase

object actually performing the text drawing. The XCoeTextDrawer object shall be allocated on

the stack (i.e. not using "new") in the CCoeControl's Draw() method. Once the XCoeTextDrawer object 

goes out of scope, this destructor will be called. It will call Reset() on the CCoeTextDrawerBase

object, if it was been set to be resuable by its owner. If not, the CCoeTextDrawerBase object

will be deleted. Note that it is up to the creator/owner of the CCoeTextDrawerBase to decide 

whether it shall be reusable or not. A user of the XCoeTextDrawer must not change the re-use'ness

of the CCoeTextDrawerBase.

*/	

EXPORT_C XCoeTextDrawer::~XCoeTextDrawer()

	{

	if(iTextDrawer && iTextDrawer->IsReusable())

		iTextDrawer->Reset();

	else

		delete iTextDrawer;

	}

/**

Assignment operator for CCoeTextDrawerBase objects.

Due to compiler defect/feature, this method may not work.

I.e. if

<code> XCoeTextDrawer textDrawer = TextDrawer(); </code>

does not compile, restate as 

<code> XCoeTextDrawer textDrawer(TextDrawer()); </code>

@param aTextDrawer A text drawer.

*/

EXPORT_C void XCoeTextDrawer::operator=(CCoeTextDrawerBase& aTextDrawer)

	{

	// The currently owned CCoeTextDrawerBase object may be reusable and should just

	// be reset rather than deleted.

	if(iTextDrawer && iTextDrawer->IsReusable())

		iTextDrawer->Reset();

	else

		delete iTextDrawer;

	iTextDrawer = &aTextDrawer;

	} 	//lint !e1539 Suppress Member 'XCoeTextDrawer::iClipRect' not assigned by assignment operator

/**

Deprecated.

*/

EXPORT_C CCoeTextDrawerBase * XCoeTextDrawer::operator ->() 

	{	

 	return iTextDrawer;

 	}

/**

An XCoeTextDrawer object should not be copied as only one handle should exist to a CCoeTextDrawer.

Therefore this copy constructor is private and just contains a panic statement.

@internalComponent

*/

XCoeTextDrawer::XCoeTextDrawer(const XCoeTextDrawer& /*aTextDrawer*/)

	{  

	ASSERT(0);

	} //lint !e1744 Suppress Member 'XCoeTextDrawer::iTextDrawer' possibly not initialized by private constructor

/**

Call this method to draw text contained i a TBidiText object. This is the 

recommended way of drawing any widget text, as it will manage both left-to-right 

scripts like English as well as right-to-left scripts such as Arabic and Hebrew.

Before calling this method, be sure to set the text alignment, margins, clip rect, 

etc using the XCoeTextDrawer methods SetAlignment(), SetMargins(), and SetClipRect().

Note that before a TBidiText text can be drawn, it has to be line-broken using 

TBidiText::WrapText() with a wrap width that match the text rect minus margins.

@param aGc 			The graphics context.

@param aText 		TBidiText reference containing the text to be drawn.

@param aTextRect 	Rectangle text will be drawn in

@param aFont 		Font to be used.

*/

EXPORT_C void XCoeTextDrawer::DrawText(CGraphicsContext& aGc, const TBidiText& aText, const TRect& aTextRect, const CFont& aFont) const

	{

	ASSERT(iTextDrawer);

	iTextDrawer->DrawText(aGc, TCoeTextTypeAdaptor(aText), aFont, aTextRect, iClipRect);	

	}

/**

Call this method to draw vertical text contained in a TBidiText object. This is the 

recommended way of drawing any widget text, as it will manage both left-to-right 

scripts like English as well as right-to-left scripts such as Arabic and Hebrew.

Before calling this method, be sure to set the text alignment, margins, clip rect, 

etc using the XCoeTextDrawer methods SetAlignment(), SetMargins(), and SetClipRect().

Note that before a TBidiText text can be drawn, it has to be line-broken using 

TBidiText::WrapText() with a wrap width that match the text rect minus margins.

Also note that the margines are relative to the orientation of the text.

@param aGc 	    	The graphics context.

@param aText 		TBidiText reference containing the text to be drawn.

@param aTextRect 	Rectangle text will be drawn in

@param aFont 		Font to be used.

@param aUp 			ETrue, text is rotated 90 degrees anti-clockwise; EFalse, text is rotated 90 degrees clockwise.

@see 				XCoeTextDrawer::SetClipRect

*/

EXPORT_C void XCoeTextDrawer::DrawTextVertical(CGraphicsContext& aGc, const TBidiText& aText, const TRect& aTextRect, const CFont& aFont, TBool aUp) const

	{

	ASSERT(iTextDrawer);

	iTextDrawer->DrawTextVertical(aGc, TCoeTextTypeAdaptor(aText), aFont, aTextRect, iClipRect, aUp);	

	}

/**

Low level text drawing is always performed left-to-right on the screen. This 

means that for any script with right-to-left directionality (like Arabic), 

the in-memory order of the glyphs has to be changed (reordered) from the 

logical order (start of sentence first, before end of sentence) to the 

display order (end of sentence before (i.e. left of) start of sentence). 

This operation is performed by TBidiText.

However, sometimes text is reordered through some other means than the TBidiText 

class. In these cases, this method can be used to draw the text contained in a 

descriptor object in the same order (left-to-right) as it appears in the descriptor 

memory. I.e. this method assumes that the text has already been changed into the

display order. If this is not the case, and the text is in a right-to-left script,

it will come out backwards.

@param aGc 			The graphics context.

@param aText 		TDesC reference containing the text to be drawn.

@param aTextRect 	Rectangle text will be drawn in

@param aFont 		Font to be used.

*/

EXPORT_C void XCoeTextDrawer::DrawDisplayOrderedText(CGraphicsContext& aGc, const TDesC& aText, const TRect& aTextRect, const CFont& aFont) const

	{

	ASSERT(iTextDrawer);

	iTextDrawer->DrawText(aGc, aText, aFont, aTextRect, iClipRect);	

	}

/**

Low level text drawing is always performed left-to-right on the screen. This 

means that for any script with right-to-left directionality (like Arabic), 

the in-memory order of the glyphs has to be changed (reordered) from the 

logical order (start of sentence first, before end of sentence) to the 

display order (end of sentence before (i.e. left of) start of sentence). 

This operation is performed by TBidiText.

However, sometimes text is reordered through some other means than the TBidiText 

class. In these cases, this method can be used to draw the text contained in a 

descriptor object in the same order (left-to-right) as it appears in the descriptor 

memory. I.e. this method assumes that the text has already been changed into the

display order. If this is not the case, and the text is in a right-to-left script,

it will come out backwards.

Note that the margines are relative to the orientation of the text.

@param aGc 			The graphics context.

@param aText 		TDesC reference containing the text to be drawn.

@param aTextRect 	Rectangle text will be drawn in

@param aFont 		Font to be used.

*/

EXPORT_C void XCoeTextDrawer::DrawDisplayOrderedTextVertical(CGraphicsContext& aGc, const TDesC& aText, const TRect& aTextRect, const CFont& aFont, TBool aUp) const

	{

	ASSERT(iTextDrawer);

	iTextDrawer->DrawTextVertical(aGc, aText, aFont, aTextRect, iClipRect, aUp);	

	}

/**

Return the clip rect that will be used by DrawText() and DrawDisplayOrderedText().

Any text falling outside this rectangle will not be visible. This is used to crop text.

@return The clipping rect.

*/	

EXPORT_C TRect XCoeTextDrawer::ClipRect() const

	{

	return  iClipRect;

	}

/**

Set the clip rect that will be used by DrawText() and DrawDisplayOrderedText().

Any text falling outside this rectangle will not be visible. This is used to crop text.

@param aClipRect TRect value to set iClipRect to.  

*/		

EXPORT_C void XCoeTextDrawer::SetClipRect(const TRect& aClipRect)

	{

 	iClipRect = aClipRect;

	}

//

// class CCoeTextDrawerBase

//

/**

Constructor.

*/

EXPORT_C CCoeTextDrawerBase::CCoeTextDrawerBase()  

	{

	Reset();	// N.B. This will always call local implementation, never derived overrides

 	} //lint !e1506 Supress Call to virtual function 'Reset(void)' within constructor

/**

This method is called from the destructor of the XCoeTextDrawer object managing the

life of the CCoeTextDrawerBase object, if the CCoeTextDrawerBase object has been set

to be reusable (by its owner calling SetReusable()). 

Any derived class must override this method to reset its drawing parameters to their 

defaults, so that the object is ready to be used again. Any overriding implementation 

must call the base implementation as well.

*/	

EXPORT_C void CCoeTextDrawerBase::Reset() 

	{ 

 	// Don't change iIsReusable! 

    iAlignment = EHLeftVTop; 

    iMargins = TMargins8(); 

    iLineGap = KDefaultLineGap; 

	} 

/**

Destructor.

*/	

EXPORT_C CCoeTextDrawerBase::~CCoeTextDrawerBase()  

	{ 

  	delete iExtension;

	}

/**

Second phase object construction.

Note that this method is non-leaving as it may be called indirectly from a Draw() 

method, which must not leave.

@return returns KErrNone if successful, otherwise KErrNoMemory.

*/	

EXPORT_C TInt CCoeTextDrawerBase::Construct()

	{

	// allocate extension block

	iExtension = CCoeTextDrawerBaseExt::New();

	if (!iExtension)

		return KErrNoMemory;

	else

		return KErrNone;

	} 

/**

Unless absolute horizontal aligment has been selected (see TGulAlignment), the actual 

horizontal text alignment used when drawing text depends on whether the directionality 

of the scrip is left-to-right or right-to-left. In the latter case left and right 

is swapped. By default, the directionality of the actual text being drawn will define 

whether the horizontal alignment will be swapped or not. However, if (as recommended) the 

directionality of the application's main language shall be considered instead (rather 

than the directionality of the text being printed at the moment), then call this method. 

If ELangNone is specified, the text drawer will be reset to swap horizontal alignment 

depending on the directionality of the text being printed.

@param aAppLang The application language (e.g. from CEikonEnv::ApplicationLanguage()).

*/

EXPORT_C void CCoeTextDrawerBase::SetAppLanguage(TLanguage aAppLang)

	{

	if(iExtension)

		iExtension->SetAppLanguage(aAppLang);

	}

/**

This method returns the actual (absolute) horizontal text alignment to be used 

when drawing text in any CCoeTextDrawerBase-derived DrawText() implementation. 

The actual alignment depends on the application language directionality if the 

application language has been set calling CCoeTextDrawerBase::SetAppLanguage(), 

or otherwise on the directionality of the actual text being printed. If the 

directionality is right-to-left (and the horizontal alignment has not been set 

to be absolute, using TGulAlignment::SetAbsoluteHAlignment()), left and right 

alignment (set using XCoeTextDrawer::SetAlignment()) will be swapped.

*/

EXPORT_C TGulHAlignment CCoeTextDrawerBase::ActualHorizontalAlignment(const TCoeTextTypeAdaptor& aText) const

	{

	if(iAlignment.HasAbsoluteHAlignment())

		return iAlignment.HAlignment();

	if(iExtension)

		{

		const TBidiText::TDirectionality directionalityToConsider = iExtension->DirectionalityToConsider(aText);

		return iAlignment.HAlignment(directionalityToConsider);

		}

	else

		return iAlignment.HAlignment();

	}

// Accessor/Set Methods

/**

Returns whether the CCoeTextDrawerBase-derived text drawer object has been set 

to be reusable or not. If reusable, the text drawer is assumed to have an owner 

that will delete it when appropriate. If not reusable, the XCoeTextDrawer will 

delete it in its destructor.

@return bool value of iIsReusable data member

*/			

EXPORT_C TBool CCoeTextDrawerBase::IsReusable() const

	{

	return iIsReusable;

	}

/**

Set whether the text drawer is reusable or not. A reusable text drawer will be

reset (through a call to Reset()) rather than deleted when the XCoeTextDrawer

referring to it is deleted. This decision has to be made by the creator of the 

CCoeTextDrawerBase object. I.e. this method must not be called by a mere user 

of the XCoeTextDrawer.

@param aIsReusable Boolean indicating whether the text drawer can be re-used.

*/	

EXPORT_C void CCoeTextDrawerBase::SetReusable(TBool aIsReusable)

	{

	iIsReusable = aIsReusable;

	}

/**

Returns the text alignment that will be used by DrawText() and DrawDisplayOrderedText().

Note that left and right alignment will be swapped for right-to-left scripts, unless

the alignment has been set to be absolute (see TGulAlignment).

A typical user of the text drawer mechanism will use the XCoeTextDrawer version of this API.

@return TGulAlignment value of iAlignment data member

*/	

EXPORT_C TGulAlignment CCoeTextDrawerBase::Alignment() const

	{

	return  iAlignment;

	}

/**

Set the text alignment that will be used by DrawText() and DrawDisplayOrderedText().

Note that left and right alignment will be swapped for right-to-left scripts, unless

the alignment has been set to be absolute (see TGulAlignment).

A typical user of the text drawer mechanism will use the XCoeTextDrawer version of this API.

@param aAlignment TGulAlignment value.  

*/		

EXPORT_C void CCoeTextDrawerBase::SetAlignment(const TGulAlignment& aAlignment)

	{

	iAlignment = aAlignment;

	}

/**

Returns the text margins that will be used by DrawText() and DrawDisplayOrderedText().

A typical user of the text drawer mechanism will use the XCoeTextDrawer version of this API.

@return The margins between the text rect and the actual text, in pixels.

*/	

EXPORT_C TMargins8 CCoeTextDrawerBase::Margins() const

	{

	return iMargins;

	}

/**

Set the text margins that will be used by DrawText() and DrawDisplayOrderedText().

A typical user of the text drawer mechanism will use the XCoeTextDrawer version of this API.

@param aMargins The margins between the text rect and the actual text, in pixels.

*/		

EXPORT_C void CCoeTextDrawerBase::SetMargins(const TMargins8& aMargins)

	{

 	iMargins = aMargins;

	}

/**

Returns the gap (in pixels) between lines of text. Default gap is 1 (one) pixel.

A typical user of the text drawer mechanism will use the XCoeTextDrawer version of this API.

@return The gap between lines of text, in pixels.

*/	

EXPORT_C TInt CCoeTextDrawerBase::LineGapInPixels() const

	{

	return iLineGap;

	}

/**

Set the gap (in pixels) between lines of text. Default gap is 1 (one) pixel.

A typical user of the text drawer mechanism will use the XCoeTextDrawer version of this API.