/*

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

*

*/

#ifndef TAGMA_INTERNAL_H_

#define TAGMA_INTERNAL_H_

#include <e32base.h>

#include <openfont.h>

#include <txtfrmat.h>

#include <txtstyle.h>

#include <tagmalayoutandsource.h>

#ifdef SYMBIAN_ENABLE_SPLIT_HEADERS

#include <tagma.h>

#endif

/** 

A tabulation position, measured from the start of the line, which will be

the left end for paragraphs with a left-to-right base direction, and vice

versa. 

@internalComponent

*/

class TTmTab

	{

public:

	/** Tab type */

	enum TType

		{

		EStandardTab,	// text is placed after the tab, in the current paragraph direction

		ECenterTab,		// text is centred around the tab

		EReverseTab		// text is placed before the tab, in the current paragraph direction

		};

	inline TTmTab();

	inline TTmTab(const TTabStop& aTab);

	IMPORT_C void operator=(const TTabStop& aTab);

	IMPORT_C void GetTTabStop(TTabStop& aTab) const;

	IMPORT_C TBool operator==(const TTmTab& aTab) const;

	inline TBool operator!=(const TTmTab& aTab) const;

	TInt iPosition;

	TType iType;

	};

/** 

A bullet or other label inserted automatically at the start of a paragraph.

As well as an actual bullet, it can be a number or a letter. 

@internalComponent

*/

class TTmBullet

	{

public:

	/** Bullet style */

	enum TStyle

		{

		EBulletStyle,

		EArabicNumberStyle,

		ESmallRomanNumberStyle,

		ECapitalRomanNumberStyle,

		ESmallLetterStyle,

		ECapitalLetterStyle

		};

	/** The alignment within the margin of bullets or other text used in TTmBullet objects */

 	enum TAlignment

		{

		/** Bullet forward aligned. */

		ELeftAlign,

		/** Bullet centre aligned. */

		ECenterAlign,

		/** Bullet reverse aligned. */

		ERightAlign

		};

	IMPORT_C TTmBullet();

	IMPORT_C void operator=(const TBullet& aBullet);

	inline TTmBullet(const TBullet& aBullet);

	IMPORT_C void GetTBullet(TBullet& aBullet) const;

	IMPORT_C TBool operator==(const TTmBullet& aBullet) const;

	inline TBool operator!=(const TTmBullet& aBullet) const;

	TChar iCharacterCode;		// the bullet or other symbol used if iStyle is EBulletStyle

	TOpenFontSpec iFontSpec;

	TBool iHangingIndent;

	TLogicalRgb iColor;

	TStyle iStyle;				// is this a bullet or a number or a letter?

	TInt iStartNumber;			// the number of the first paragraph in a run of paragraphs in this style

	TAlignment iAlignment;		// alignment of the bullet or number within the margin

	};

/** 

A specification of a paragraph border rule: that is, a line or lines drawn

above, below, to the left, or to the right of a paragraph. 

@internalComponent

*/

class TTmParBorder

	{

public:

	/** Paragraph border style */

	enum TStyle

		{

		ESolidStyle,

		EDoubleStyle,

		EDotStyle,

		EDashStyle,

		EDotDashStyle,

		EDotDotDashStyle

		};

	IMPORT_C TTmParBorder();

	IMPORT_C void operator=(const TParaBorder& aBorder);

	inline TTmParBorder(const TParaBorder& aBorder);

	IMPORT_C void GetTParaBorder(TParaBorder& aBorder) const;

	IMPORT_C TBool operator==(const TTmParBorder& aBorder) const;

	inline TBool operator!=(const TTmParBorder& aBorder) const;

	TStyle iStyle;

	TInt iWeight;

	TLogicalRgb iColor;

	TBool iAutoColor;

	};

/**

MTmTextDrawExt interface UID.

@internalComponent

*/

const TUid KTmTextDrawExtId = {0x10203665};

/**

Text drawing - an extension interface. It offfers

DrawLine(), DrawText() and DrawRect() methods.

The idea is to move out from RTm<Name>Interpreter implementations all 

CGraphicsContext::Draw<Item> calls and replace them with the corresponding 

MTmTextDrawExt::Draw<Item> calls. The implementations of MTmTextDrawExt interface can customize

drawing methods implementations - for example - including opaque drawing support.

The MTmTextDrawExt interface UID is KTmTextDrawExtId. The interface implementation can be queried

through a MTmSource::GetExtendedInterface() call.

@internalComponent

*/

class MTmTextDrawExt

	{

public:

	virtual void DrawLine(CGraphicsContext& aGc, const TPoint& aPt1, const TPoint& aPt2) const = 0;

	virtual void DrawText(CGraphicsContext& aGc, const TDesC& aText, const TPoint& aPt) const = 0;

	virtual void DrawRect(CGraphicsContext& aGc, const TRect& aRc) const = 0;

	};

/**

@internalComponent

*/

const TUid KFormLabelApiExtensionUid = { 0x101FD03C};

/**

Class used to provide label functionality within Form

as an extended interface (via the GetExtendedInterface mechanism

supplied in MTmSource). This class is entirely internal to Form.

@internalComponent

@see MTmSource::GetExtendedInterface

@since Sirocco

*/

class MFormLabelApi

	{

public:

	IMPORT_C virtual TBool LabelModeSelect(MTmSource::TLabelType aType, TInt aPos);

	IMPORT_C virtual void LabelModeCancel();

	IMPORT_C virtual void LabelMetrics(MTmSource::TLabelType aType, TSize& aLabelSize, TInt& aMarginSize) const;

	};

/**

@internalTechnology

*/

class CTmBufSeg: public CBufSeg

	{

public:

	inline CTmBufSeg(TInt aExpandSize);

	TInt MemoryUsed() const;

	};

/** 

Additional parameters used when reformatting.

@internalComponent

*/

class TTmReformatParam

	{

public:

	IMPORT_C TTmReformatParam();

	TInt iStartChar;					// start of changed text

	TInt iOldLength;					// length of text before the change

	TInt iNewLength;					// length of text after the change

	TInt iMaxExtraLines;				// maximum lines in the partial paragraph after the end of the changed text

										// to format in one go; the remainder can be handled by background formatting

	TBool iParFormatChanged;			// TRUE if the paragraph format of the changed text has changed

	TBool iParInvalid;					// format to the end of the paragraph

	};

/** 

Information returned when reformatting. 

@internalComponent

*/

class TTmReformatResult

	{

public:

	IMPORT_C TTmReformatResult();

	TRect iRedrawRect;					// rectangle to be redrawn

	TInt iHeightChange;					// change in height of the reformatted text

	TInt iUnchangedTop;					// y coordinate, before formatting, of the top of text needing no change,

										// including text in any section not yet formatted by this call

	TInt iUnformattedStart;				// start of any unformatted section; KMaxTInt if none

	};

/**

@internalComponent

*/

class TTmHighlightExtensions

	{

public:

	inline TTmHighlightExtensions();

	inline void SetAll(TInt aExtension);

	inline void SetLeftExtension(TInt aExtension);

	inline void SetRightExtension(TInt aExtension);

	inline void SetTopExtension(TInt aExtension);

	inline void SetBottomExtension(TInt aExtension);

	inline TInt LeftExtension() const;

	inline TInt RightExtension() const;

	inline TInt TopExtension() const;

	inline TInt BottomExtension() const;

	inline TBool Extends() const;

	inline TBool Shrinks() const;

	inline void ExtendRect(TRect& aRect) const;

	inline void AdjustRect(TRect& aRect) const;

	inline TBool IsNull() const;

	inline void AbsExtendRect(TRect& aRect) const;

public:

	TInt iLeftExtension;

	TInt iRightExtension;

	TInt iTopExtension;

	TInt iBottomExtension;

	};

/** 

A bit mask for selecting one or more attributes of a TTmCharFormat object. 

@internalComponent

*/

class TTmCharFormatMask

	{

public:

	/** Constants, that are also bit assignments, representing character format attributes */

	enum TAttrib

		{

		EFontName = 0x1,

		EFontCoverage = 0x2,

		EBold = 0x4,

		EItalic = 0x8,

		ESerif = 0x10,

		EMonoWidth = 0x20,

		EHeight = 0x40,

		EPrintPosition = 0x80,

		ETextColor = 0x100,

		EBackgroundColor = 0x200,

		EBackground = 0x400,

		EUnderline = 0x800,

		EStrikethrough = 0x1000,

		EShadow = 0x2000,

		EUserDefinedEffects = 0x4000,

		ELanguage = 0x8000,

		EPictureAlignment = 0x10000

		};

	inline TTmCharFormatMask();

	IMPORT_C TTmCharFormatMask(const TCharFormatMask& aMask);

	IMPORT_C void GetTCharFormatMask(TCharFormatMask& aMask) const;

	inline void Clear(TAttrib aAttrib);

	inline void Set(TAttrib aAttrib);

	inline TBool IsSet(TAttrib aAttrib); 

	TUint iFlags;

	};

/** 

A bit mask for selecting one or more attributes of an RTmParFormat. 

@internalComponent

*/	

class TTmParFormatMask

	{

public:

	/** Constants, that are also bit assignments, representing paragraph format attributes */

	enum TAttrib

		{

		EAlignment = 0x1,

		EDirection = 0x2,

		EKeepTogether = 0x4,

		EKeepWithNext = 0x8,

		EStartNewPage = 0x10,

		EWidowOrphan = 0x20,

		ENoWrap = 0x40,

		EExactLineSpacing = 0x80,

		EPixelLineSpacing = 0x100,

		ELeadingMargin = 0x200,

		ETrailingMargin = 0x400,

		EFirstLineIndent = 0x800,

		ELineSpacing = 0x1000,

		ESpaceAbove = 0x2000,

		ESpaceBelow = 0x4000,

		ETabSize = 0x8000,

		EBorderMargin = 0x10000,

		ETabList = 0x20000,

		EBullet = 0x40000,

		EBorder = 0x80000

		};

	inline TTmParFormatMask();

	IMPORT_C TTmParFormatMask(const TParaFormatMask& aMask);

	IMPORT_C void GetTParaFormatMask(TParaFormatMask& aMask) const;

	inline void Clear(TAttrib aAttrib);

	inline void Set(TAttrib aAttrib);

	inline TBool IsSet(TAttrib aAttrib);

	TUint iFlags;

	};

/** 

A character format layer. Unmasked attributes are transparent. 

@internalComponent

*/	

class TTmCharFormatLayer

	{

public:

	inline TTmCharFormatLayer();

	IMPORT_C TTmCharFormatLayer(const CCharFormatLayer& aFormat);

	TTmCharFormat iFormat;

	TTmCharFormatMask iMask;

	};

/** 

A paragraph format layer. Unmasked attributes are transparent. 

@internalComponent

*/

class RTmParFormatLayer

	{

public:

	inline void Close();

	IMPORT_C void CopyL(const CParaFormatLayer& aFormat);

	RTmParFormat iFormat;

	TTmParFormatMask iMask;

	};

/**

 A style. 

@internalComponent

*/

class RTmStyle

	{

public:

	enum

		{

		EMaxName = KMaxParagraphStyleName

		};

	inline void Close();

	IMPORT_C void CopyL(const RParagraphStyleInfo& aStyle);

	IMPORT_C void GetRParagraphStyleInfoL(RParagraphStyleInfo& aStyle,

		const CParaFormatLayer& aGlobalParaFormatLayer,const CCharFormatLayer& aGlobalCharFormatLayer,

		const CStyleList& aList) const;

	TBuf<KMaxName> iName;

	TBuf<KMaxName> iNextStyleName;

	TTmCharFormatLayer iCharFormat;

	RTmParFormatLayer iParFormat;

	TInt iOutlineLevel;

	};

/** 

A self-contained text object. It owns both layout and content. It is

intended for labels and the general display of small-to-medium-sized amounts of

text. 

@internalComponent

*/

class CTmText: public CBase, public MTmTextLayoutForwarder

	{

public:

	IMPORT_C static CTmText* NewL(MGraphicsDeviceMap* aDevice = NULL,const TTmFormatParamBase* aFormatParam = NULL);

	IMPORT_C static CTmText* NewL(MGraphicsDeviceMap& aDevice,const TTmFormatParamBase& aFormatParam);

	IMPORT_C static CTmText* NewL(MGraphicsDeviceMap& aDevice,TInt aWrapWidth,TInt aFlags);

	IMPORT_C ~CTmText();

	IMPORT_C void InsertL(TInt aPos,const TDesC& aText,

						  const TTmCharFormat* aCharFormat = NULL,const RTmParFormat* aParFormat = NULL,

						  TRect* aRedrawRect = NULL,TInt* aScroll = NULL);

	IMPORT_C void GetFormat(TTmFormatParamBase& aFormatParam) const;

	IMPORT_C void SetWrapWidthL(TInt aWrapWidth);

	IMPORT_C void ChangeFormatL(const TTmFormatParamBase& aFormatParam);

	IMPORT_C void Clear();

	IMPORT_C void CustomizeL(const MTmCustom* aCustom);

	IMPORT_C TInt MemoryUsed() const;

	inline void Draw(CGraphicsContext& aGc,const TPoint& aTopLeft,const TRect& aClipRect,

					 const TLogicalRgb* aDocBackground,TBool aDrawParBackground);

private:

	CTmText();

	IMPORT_C void Spare1();

	// implementations of MTmTextLayoutForwarder virtual functions

	const CTmTextLayout& TextLayout() const;

	CTmTextImp* iImp;		// the implementation

	};

// inline functions

/** Constructs a TTmCharFormatMask. Turns all the flags on. */

TTmCharFormatMask::TTmCharFormatMask(): iFlags(0xFFFFFFFF)

	{

	}

/** Clears the selected flag.*/

void TTmCharFormatMask::Clear(TAttrib aAttrib)

	{

	iFlags &= ~aAttrib;

	}

/** Sets the selected flag. */

void TTmCharFormatMask::Set(TAttrib aAttrib)

	{

	iFlags |= aAttrib;

	}

/** Returns true if the selected attribute is set. */

TBool TTmCharFormatMask::IsSet(TAttrib aAttrib)

	{

	return iFlags & aAttrib;

	}

/** Constructs a TTmParFormatMask with all the flags on. */

TTmParFormatMask::TTmParFormatMask():

	iFlags(0xFFFFFFFF)

	{

	}

/** Clears the selected flag. */

void TTmParFormatMask::Clear(TAttrib aAttrib)

	{

	iFlags &= ~aAttrib;

	}

/** Sets the selected flag. */

void TTmParFormatMask::Set(TAttrib aAttrib)

	{

	iFlags |= aAttrib;

	}

/**

Returns true if the selected flag is Set.

*/

TBool TTmParFormatMask::IsSet(TAttrib aAttrib)

	{

	return iFlags & aAttrib;

	}

/** Constructs a TTmCharFormatLayer object containing default TTmCharFormat and

TTmCharFormatMask objects. */

TTmCharFormatLayer::TTmCharFormatLayer()

	{

	}

/** Closes an RTmParFormatLayer object by freeing any objects allocated on the

heap. */

void RTmParFormatLayer::Close()

	{

	iFormat.Close();

	}

/** Closes an RTmStyle object by freeing any objects allocated on the heap.

*/

void RTmStyle::Close()

	{

	iParFormat.Close();

	}

/** Draws the formatted text. This inline function just calls

CTmText::DrawLayout and is identical to it. It is provided for coding

convenience because of the expectation that a drawing function called Draw

exists. */

void CTmText::Draw(CGraphicsContext& aGc,const TPoint& aTopLeft,const TRect& aClipRect,

				   const TLogicalRgb* aDocBackground,TBool aDrawParBackground)

	{

	DrawLayout(aGc,aTopLeft,aClipRect,aDocBackground,aDrawParBackground);

	}

/** Constructs a TTmTab and set it to a standard tab stop with a position of 0. */

TTmTab::TTmTab():

	iPosition(0),

	iType(EStandardTab)

	{

	}

/** Constructs a TTmTab by converting the information in a TTabStop. */

TTmTab::TTmTab(const TTabStop& aTab)

	{

	*this = aTab;