/*

* 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: 

* The standard internal header for TAGMA.

*

*/

#ifndef TMSTD_H__

#define TMSTD_H__

#include "TAGMA.H"

#include <txtfrmat.h>

#include <txtetext.h>

#include <fbs.h>

#include <bidi.h>

#ifdef SYMBIAN_ENABLE_SPLIT_HEADERS

#include "TAGMA_INTERNAL.H"

#endif

static const TUint KZeroWidthJoiner = 0x200d;

static const TUint KZeroWidthNonJoiner = 0x200C;

/**

@internalComponent

*/

NONSHARABLE_CLASS(CTmBufferBase) : public CBase

	{

	public:

	~CTmBufferBase();

	void Truncate(TInt aLength);

	void Reset() { iLength = 0; }

	TInt Length() const { return iLength; }

	protected:

	CTmBufferBase(TInt aExpandSize): iExpandSize(aExpandSize) { }

	TAny* Data() const { return iData; }

	TAny* ExtendL(TInt aSizeOfData);

	void DoAppendL(const TAny* aItem,TInt aCount,TInt aSizeOfData);

	private:

	void GrowL(TInt aExtra,TInt aSizeOfData);

	TAny* iData;

	TInt iLength;

	TInt iAllocated;

	TInt iExpandSize;

	};

/**

An expandable buffer.

@internalComponent

*/

template<class T> class CTmBuffer: public CTmBufferBase

	{

	public:

	CTmBuffer(TInt aExpandSize): CTmBufferBase(aExpandSize) { }

	void AppendL(const T& aItem) { *STATIC_CAST(T*,ExtendL(sizeof(T)))=aItem; }

	void AppendL(const T* aItem,TInt aCount) { DoAppendL(aItem,aCount,sizeof(T)); }

	T* Ptr() { return (T*)Data(); }

	const T* Ptr() const { return (const T*)Data(); }

	T& operator[](TInt aIndex) { return Ptr()[aIndex]; }

	};

/**

@internalComponent

*/

enum TTmPanic

	{

	EInvariant,

	ENoSource,

	EBadArg,

	EBadLineBreak,

	EFormatNotFound,

	EBadTruncationLength,

	EBadChunkType,

	EBadCodePos,

	EZeroLengthTextSupplied,

	EBadLineBreakRangeTable,

	ETextWidthBufferOverflow,

	ETextRunNotFound,

	EInvalidTextRunLength,

	EInvalidTextRunIndex,

	EUnimplemented,

	EParagraphFormatRequired,

	EIndexOutOfRange,

	EBadReturnValue,

	EBadPtrLen,

	EBadClusterBufLen,

	ENotImplemented

	};

/**

@internalComponent

*/

static inline void TmPanic(TTmPanic aPanic)

	{

	_LIT(KTmPanic,"Tagma");

	User::Panic(KTmPanic,aPanic);

	}

/**

Maximum size for text chunks, and hence the maximum size needed for buffers when measuring or drawing text.

@internalComponent

*/

const TInt KMaxTextChunkSize = 128;

class RTmTextCache;

class CTmTextFontCache

	{

public:

	static CTmTextFontCache* New(MGraphicsDeviceMap& aDevice, CFont& aFont);

	CFont& Font();

	void Open();

	void Close();

private:

	CTmTextFontCache(MGraphicsDeviceMap& aDevice, CFont& aFont);

	~CTmTextFontCache();

	TInt iRefCount;

	MGraphicsDeviceMap& iDevice;

	CFont& iFont;

	};

/**

A class for caching text and formats extracted from a text source.

That it is an R class shows that it must be closed after use; call Close().

@internalComponent

*/

class RTmTextCache

	{

public:

	enum TDisplayedTextDirectionality

		{

		// For requesting left-to-right text whether logical or visual

		ELeftToRight = 0,

		// For requesting right-to-left text in visual order

		EVisualRightToLeft = 1,

		// For requesting right-to-left text in logical order

		ELogicalRightToLeft = 2

		};

	RTmTextCache(MTmSource& aSource,MGraphicsDeviceMap& aDevice):

		iSource(aSource),

		iDevice(aDevice),

		iDocumentLength(aSource.DocumentLength()),

		iText(NULL),

		iTextStart(-1),

		iTextLength(0),

		iFont(NULL),

		iContextCharPerChunk(NULL),

		iContextCharInByteCode(NULL)

		{

		}

#ifdef _DEBUG

	~RTmTextCache() { if (iFont) TmPanic(EInvariant); }

#endif

 	TInt AdvanceWidthL(TInt aStart, TInt aEnd, TBool aRightToLeft,

 		TInt aMaxWidth = KMaxTInt, CFbsFont::TMeasureTextOutput* aOutput = 0,

 		TInt aExtraChar = 0);

 	TInt TotalWidthL(TInt aStart, TInt aEnd, TBool aRightToLeft);

	MTmSource& Source() { return iSource; }

	TInt GetText(TInt aPos,TInt aMaxEndChar,TPtrC& aText,TTmCharFormat* aFormat = NULL,CTmTextFontCache** aFont = NULL);

	TInt GetTextL(TInt aPos, TInt aMaxEndChar, TPtrC& aText,

		TTmCharFormat* aFormat = 0, CTmTextFontCache** aFont = 0);

	TInt GetDisplayedText(TInt aStart, TInt aEnd,

						  TDisplayedTextDirectionality aDirectionality, TText* aBuffer,TUint aContextChar,

						  TTmCharFormat* aFormat = 0, CTmTextFontCache** aFont = NULL);

	TUint Char(TInt aPos);

	const TTmCharFormat& Format() const { return iFormat; }

	MGraphicsDeviceMap& Device() { return iDevice; }

	void ReleaseFont() { if (iFont) { iFont->Close(); iFont = NULL; } }

	void Close() { ReleaseFont(); iTextBuffer.Close(); }

	TBool static IsArabicPoint(TInt aChar);

	void SetContextChar(TUint aContextChar);

	TUint GetContextChar() const { return iContextCharPerChunk; }

	TUint GetContextForByteCode() const { return iContextCharInByteCode; }

private:

	MTmSource& iSource;				// text source

	MGraphicsDeviceMap& iDevice;	// device used for getting fonts

	TInt iDocumentLength;			// length of the document, not including final paragraph delimiter if any

	const TText* iText;				// current text

	TInt iTextStart;				// start position of current text

	TInt iTextLength;				// length of current text

	TTmCharFormat iFormat;			// current text format

	CTmTextFontCache* iFont;		// if non-null, current font

	RBuf iTextBuffer;			// buffer for GetTextL (if appropriate)

	TInt iTextBufferStart;		// start position of where iTextBuffer is copied from

	TBool iTextBufferEndsInFormatChange;

	//	Context  characters: These one character context data members are used by the rendering code in GDI

	//	to render punctuation marks based on the context. The context here represents the script in which to render the punctuation.

	TUint iContextCharPerChunk;	//	One character of context stored temporarily to pass on to 

											//	the rendering code along with the text, and back to the TmChunk 

											//	object being rendered. See TmChunk::SetL() and RTmTextCache::AdvanceWidthL()

	TUint iContextCharInByteCode;	//	One character of context stored temporarily to pass on to

											//	the TmChunk object after rendering the text with context, to be 

											//	put into the byte code. See TmChunk::SetL() and RTmTextCache::AdvanceWidthL()

	};

/**

@internalComponent

*/

class TTmCodeReader

	{

	public:

	TTmCodeReader(const CTmCode& aCode,TInt aCodeStart,TInt aCodeEnd):

		iCode(aCode), iCodePos(aCodeStart), iCodeEndPos(aCodeEnd),

		iCodeSegPtr(NULL), iCodeSegEndPtr(NULL) { }

	const CTmCode& Code() const { return iCode; }

	TInt CodePos() const { return iCodePos; }

	TInt CodeEndPos() const { return iCodeEndPos; }

	TUint8 ReadByte() { if (iCodeSegPtr == iCodeSegEndPtr) SetCodePtr(); iCodePos++; return *iCodeSegPtr++; }

	TUint8 PeekByte() {	if (iCodeSegPtr == iCodeSegEndPtr) SetCodePtr(); return *iCodeSegPtr; }

	int ReadNumber();

	TRect ReadRect();

	void SetCodePos(TInt aNewCodePos);

	private:

	void SetCodePtr();

	const CTmCode& iCode;			// the bytecode

	TInt iCodePos;					// current index into the bytecode

	TInt iCodeEndPos;				// index to the end of the bytecode being interpreted

	const TUint8* iCodeSegPtr;		// pointer to the current position in the current bytecode segment

	const TUint8* iCodeSegEndPtr;	// end of the current bytecode segment

	};

/**

End-of-line information required for bidirectional reformatting.

@internalComponent

*/

class TBidirectionalEndOfLineContext

	{

public:

	TBidirectionalEndOfLineContext() { Reset(); }

	void Set(RTmTextCache& aText, TInt aStartPos);

	void Reset()

		{

		iFirstCategory = iFirstStrongCategory = TChar::EOtherNeutral;

		}

	void ExternalizeL(RWriteStream& aDest);

	void InternalizeL(RReadStream& aSource);

	TBool operator==(const TBidirectionalEndOfLineContext& aState) const

		{

		return iFirstCategory == aState.iFirstCategory

			&& iFirstStrongCategory == aState.iFirstStrongCategory;

		}

	TChar::TBdCategory FirstCategory() const { return iFirstCategory; }

	TChar::TBdCategory FirstStrongCategory() { return iFirstStrongCategory; }

private:

	TChar::TBdCategory iFirstCategory;

	TChar::TBdCategory iFirstStrongCategory;

	TInt iPositionOfLastStrongCategory;

	TInt iStartPosOfThisLine;

	};

/**

Extended TBidirectionalState for most situations in Tagma.

@internalComponent

*/

class TBidirectionalContext : public TBidirectionalState

	{

public:

	TBidirectionalContext() {}

	void Reset()

		{

		TBidirectionalState::Reset();

		iEndOfLine.Reset();

		}

	void InternalizeL(RReadStream& aSource);

	void Set(const TBidirectionalState& aState,

		const TBidirectionalEndOfLineContext& aEndOfLine)

		{

		*static_cast<TBidirectionalState*>(this) = aState;

		iEndOfLine = aEndOfLine;

		}

	TBool operator==(const TBidirectionalContext& aState) const

		{

		return *static_cast<const TBidirectionalState*>(this) == aState

			&& iEndOfLine == aState.iEndOfLine;

		}

	TBool ContextMatches(const TBidirectionalEndOfLineContext& aTest)

		{

		return aTest == iEndOfLine;

		}

private:

	TBidirectionalEndOfLineContext iEndOfLine;

	};

/**

@internalComponent

*/

void TmGetBorderWidth(const MGraphicsDeviceMap& aDevice,const RTmParFormat& aParFormat,RTmParFormat::TBorderIndex aSide,

					  TInt& aSingle,TInt& aFull);

void TmGetMarginsL(MGraphicsDeviceMap& aDevice,const RTmParFormat& aParFormat,

				   TInt& aLeftMargin,TInt& aRightMargin,

				   TInt& aFirstLineLeftMargin,TInt& aFirstLineRightMargin,

				   TInt& aBulletMargin,TInt& aBulletWidth,

				   TInt& aBulletAscent,TInt& aBulletDescent,CFont** aFont = NULL);

void SubtractRect(const TRect& aP,const TRect& aQ,TRect* aR);

#include "TMSTD.inl"

#endif // __TMSTD_H__