/*

* 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 main header file for TAGMA, the low-level text formatting engine for EPOC.

* 'Tm' stands for 'TAGMA' and is the standard prefix for TAGMA classes, after

* the C, T, or whatever.

*

*/

#ifndef __TAGMA_H__

#define __TAGMA_H__

#include <e32base.h>

#include <openfont.h>

#include <txtfrmat.h>

#include <txtstyle.h>

#include <linebreak.h>

// forward declarations

class TTmLineInfo;

class CTmTextImp;

class RWindow;

class RWsSession;

class RParagraphStyleInfo;

class CStyleList;

class TTmDocPosSpec;

class TTmDocPos;

class TCursorSelection;

class TTmHighlightExtensions;

class TBidirectionalContext;

class TTmLineInfo;

class CTmTextLayout;

/** 

A character format; all dimensions are in twips. A character format object

stores all text style attributes that can differ from any one character to the

next. Attributes that affect an entire paragraph only are kept in RTmParFormat

objects. 

The class should only be used internally by FORM component.

@internalComponent

*/

class TTmCharFormat

	{

public:

	/** Bit assignments for effects */

	enum

		{

		EBackground = 1,	///< Text background is drawn in the background colour

		ERounded = 2,		///< Text background (if any) has rounded corners

		EUnderline = 4,	///< Text is underlined

		EStrikethrough = 8,	///< Text is struck through with a horizontal line.

		EShadow = 16,	///< Text has a drop shadow.

		/** Bits 24-31 are reserved for styles defined by the custom drawer. */

		EUserDefinedMask = 0xFF000000,

		/** Shift TCharFormat highlight styles left by this to get the

		TTmCharFormat effects portion. */

		EUserDefinedShift = 24,

		/** For custom drawers: draw whatever is wanted for "no matches" in the FEP. */

		ENoMatchesIndicator = 0x4000000,

		/** Reset if the effect in bits 24-30 is defined defined by Symbian,

		set if it is defined externally. */

		ECustomDrawEffectIsExternallyDefined = 0x80000000

		};

	/** Picture alignment */

	enum TPictureAlignment

		{

		EPictureAlignBaseline,

		EPictureAlignTop,

		EPictureAlignBottom,

		EPictureAlignCenter

		};

	IMPORT_C TTmCharFormat();

	IMPORT_C TTmCharFormat(const TDesC& aFontName,TInt aFontHeight);

	IMPORT_C void operator=(const TCharFormat& aFormat);

	inline TTmCharFormat(const TCharFormat& aFormat);

	IMPORT_C void GetTCharFormat(TCharFormat& aFormat) const;

	IMPORT_C TBool operator==(const TTmCharFormat& aFormat) const;

	inline TBool operator!=(const TTmCharFormat& aFormat) const;

	TOpenFontSpec iFontSpec;

	TLogicalRgb iTextColor;

	TLogicalRgb iBackgroundColor;		// used only when EBackground flag is set in iEffects

	TUint iEffects;						// bit flags as defined above;

										// note that effects NEVER change character metrics and so can

										// be ignored when measuring text

	TUint iLanguage;					// language used for proofing

	TPictureAlignment iPictureAlignment;// vertical alignment of embedded objects

	TUint iTag;							// tag for use by URL parsers, etc.; a way of marking a range of

										// text without using any typographic attributes

	};

/** 

The text customization interface. You can customize the colors, word

spacing, line breaking, line height calculation, background drawing, and text

appearance, of a text object by supplying an implementation of the MTmCustom

class, either directly (as in CTmText::CustomizeL, which takes a pointer to

MTmCustom) or indirectly, making use of the fact that MTmSource is derived from

MTmCustom (as in CTmTextLayout::SetTextL, which takes a reference to

MTmSource).

@publishedAll

@released

*/

class MTmCustom 

				: public MLineBreaker

	{

public:

	/**

    TLineHeightParam structure is used in MTmCustom::SetLineHeight() method to set 

    text line height related parameters such as max character height, max ascent and descent,

    height and depth of the tallest pictures (top-aligned, bottom-aligned or centered).

    @see MTmCustom::SetLineHeight()

	@publishedAll

	@released

	*/

	class TLineHeightParam

		{

	public:

		inline TLineHeightParam();

        /** Height of the highest character in the line. */

		TInt iMaxCharHeight;

        /** Depth of the deepest character in the line. */

		TInt iMaxCharDepth;

        /** Height plus depth of the tallest top-aligned picture. */

		TInt iMaxTopPictureHeight;

        /** Height plus depth of the tallest bottom-aligned picture. */

		TInt iMaxBottomPictureHeight;

        /** Height plus depth of the tallest centred picture. */

		TInt iMaxCenterPictureHeight;

        /** Height of the tallest character of any in the fonts in the line. */

		TInt iFontMaxCharHeight;

        /** Depth of the deepest character of any in the fonts in the line. */

		TInt iFontMaxCharDepth;

        /** Maximum ascent of the fonts in the line. */

		TInt iFontMaxAscent;

        /** Maximum descent of the fonts in the line. */

		TInt iFontMaxDescent;

        /** Desired precise or minimum line height. */

		TInt iDesiredLineHeight;

        /** True if the line height must be precise. */

		TBool iExactLineHeight;

		};

	/**	The Unicode line breaking classes; see Unicode Technical Report 14.

	Not a named enumerated type, so that overriding applications can add new

	line breaking classes freely.

	The description of each constant gives the name of the line-breaking

	class, an example and a brief, imprecise description of the default

	behaviour of characters of that class.

	*/

	enum

		{

		/** Opening Punctuation (e.g. '['). Breaking after prohibited. */

		EOpLineBreakClass,

		/** Closing Punctuation (e.g. ']'). Breaking before prohibited. */

		EClLineBreakClass,

		/** Ambiguous Quotes (e.g. '"'). Breaking before and after prohibited. */

		EQuLineBreakClass,

		/** Glue (e.g. Non-breaking space). Breaking before and after prohibited

		unless spaces are present. */

		EGlLineBreakClass,

		/** Non-Starter (e.g. small Japanese kana). Breaking before prohibited

		if no spaces present. */

		ENsLineBreakClass,

		/** Exclamation or Interrogation (e.g. '?'). Like closing punctuation

		except before Postfix or Non-starter. */

		EExLineBreakClass,

		/** Symbol (e.g. '/'. Like Alphabetic, but allows breaking before

		Alphabetic. */

		ESyLineBreakClass,

		/** Numeric Infix Separator (e.g. ','). Forbids breaking after any and before

		Numeric. */

		EIsLineBreakClass,

		/** Numeric Prefix (e.g. '$'). Forbids breaking before Numeric. */

		EPrLineBreakClass,

		/** Numeric Postfix (e.g. '%'). Forbids breaking after Numeric. */

		EPoLineBreakClass,

		/** Numeric (e.g. '1'). */

		ENuLineBreakClass,

		/** Alphabetic (e.g. 'a'). */

		EAlLineBreakClass,

		/** Ideographic (e.g. Japanese Kanji). Generally break before or after */

		EIdLineBreakClass,

		/** Inseparable (e.g. ellipsis). Forbid breaks between Inseparables. */

		EInLineBreakClass,

		/** Hyphen (e.g. '-'). Allows a break after except before Numeric. */

		EHyLineBreakClass,

		/** Break After. Generally allow a break after. Breaking between Break

		Afters not separated by spaces is prohibited. */

		EBaLineBreakClass,

		/** Break Before. Generally allow a break before. Breaking between Break

		Befores not separated by spaces is prohibited. */

		EBbLineBreakClass,

		/** Break Before and After. Generally allow a break before or after.

		Breaking between Break Before and Afters is prohibited, even if spaces

		are present. */

		EB2LineBreakClass,

		/** Zero-Width Space. Allow a break. */

		EZwLineBreakClass,

		/** Combining Mark. Takes on the class of its base class. */

		ECmLineBreakClass,

		/** Mandatory Break. */

		EBkLineBreakClass,

		/** Carriage Return. Break after unless part of a CRLF pair. */

		ECrLineBreakClass,

		/** Line Feed. Break after. */

		ELfLineBreakClass,

		/** Surrogate. Half of a surrogate pair. */

		ESgLineBreakClass,

		/** Contingent Break (e.g. embedded pictures). Uses external

		information */

		ECbLineBreakClass,

		/** Space. Intervening characters of class Space are indicated by

		aHaveSpaces in LineBreakPossible. */

		ESpLineBreakClass, 

		/** Complex Context (e.g. Thai). Runs of Complex Context are passed to

		GetLineBreakInContext. */

		ESaLineBreakClass,

		/** Ambiguous. Characters of ambiguous East Asian width are treated

		as Alphabetic, unless they are resolved as being "Wide", in which case

		they are treated as Ideographic. */

		EAiLineBreakClass,

		/** The Xx class is used when the class is unknown; e.g.; outside the provided context. */

		EXxLineBreakClass,

		/** The number of Unicode line break classes. */

		ELineBreakClasses

		};

	IMPORT_C virtual TRgb SystemColor(TUint aColorIndex,TRgb aDefaultColor) const;

	IMPORT_C virtual TInt Stretch(TUint aChar) const;

	IMPORT_C virtual TUint Map(TUint aChar) const;

	IMPORT_C virtual void SetLineHeight(const TLineHeightParam& aParam,TInt& aAscent,TInt& aDescent) const;

	IMPORT_C virtual void DrawBackground(CGraphicsContext& aGc,const TPoint& aTextLayoutTopLeft,const TRect& aRect,

										 const TLogicalRgb& aBackground,TRect& aRectDrawn) const;

	IMPORT_C virtual void DrawLineGraphics(CGraphicsContext& aGc,const TPoint& aTextLayoutTopLeft,const TRect& aRect,

										   const TTmLineInfo& aLineInfo) const;

	IMPORT_C virtual void DrawText(CGraphicsContext& aGc,const TPoint& aTopLeft,const TRect& aRect,

								   const TTmLineInfo& aLineInfo,const TTmCharFormat& aFormat,

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

	IMPORT_C virtual void DrawPicture(CGraphicsContext& aGc,

		const TPoint& aTextLayoutTopLeft, const TRect& aRect,

		MGraphicsDeviceMap& aDevice, const CPicture& aPicture) const;

	IMPORT_C virtual TUint LineBreakClass(TUint aCode,TUint& aRangeStart,TUint& aRangeEnd) const;

	IMPORT_C virtual TBool LineBreakPossible(TUint aPrevClass,TUint aNextClass,TBool aHaveSpaces) const;

	IMPORT_C virtual TBool GetLineBreakInContext(const TDesC& aText,TInt aMinBreakPos,TInt aMaxBreakPos,

												 TBool aForwards,TInt& aBreakPos) const;

	IMPORT_C virtual TBool IsHangingCharacter(TUint aChar) const;

	// non-virtuals

	IMPORT_C void SetPenColor(CGraphicsContext& aGc,TLogicalRgb aColor) const;

	IMPORT_C void SetBrushColor(CGraphicsContext& aGc,TLogicalRgb aColor) const;

	IMPORT_C TRgb SystemColor(TLogicalRgb aColor) const;

	};

/* MTmSource extension interface****************************************************/

const TUid KTmCustomExtensionUid = {0x10285BB5};

/** MTmSource Extension Interface abstract base class to enable further customisation of the source.

MTmSource derivers should also derive from this interface to enable drawing text in context

This interface should be returned by the overridden

MTmSource::GetExtendedInterface function when KUidMTmSourceExtension is

supplied as the UID.

@see MTmSource

@see KUidMTmSourceExtension 

@publishedAll

@released

*/

class MTmCustomExtension

	{

public:

	IMPORT_C virtual TRgb SystemColor(TUint aColorIndex,TRgb aDefaultColor) const;

	IMPORT_C virtual void DrawText(CGraphicsContext& aGc,const TPoint& aTopLeft,const TRect& aRect,

								   const TTmLineInfo& aLineInfo,const TTmCharFormat& aFormat,

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

		// non-virtuals

	IMPORT_C void SetPenColor(CGraphicsContext& aGc,TLogicalRgb aColor) const;

	IMPORT_C void SetBrushColor(CGraphicsContext& aGc,TLogicalRgb aColor) const;

	IMPORT_C TRgb SystemColor(TLogicalRgb aColor) const;

	};

/** 

A structure for returning information about a line. One of these is

returned by all hit-detection functions. Typically, after finding the position

in the document that corresponds to given x-y coordinates, you will want some

more information like the line's bounding rectangle. When you call, for

example, CTmTextLayout::FindXyPos you will receive a TTmLineInfo object that

will tell you this, and much more. 

@publishedAll

@released

*/

class TTmLineInfo

	{

public:

	// bit values for iFlags

	enum

		{

		EParStart = 1,

		EParEnd = 2,

		EParRightToLeft = 4,

 		ELineEndsInForcedLineBreak = 8,

 		EPictureButtsLowerEdge = 16,	/**< @deprecated - no effect, present for compatibility only */

 		EPictureButtsUpperEdge = 32	/**< @deprecated - no effect, present for compatibility only */

		};

	inline TTmLineInfo();

	/** Outer enclosing rectangle including margins */

	TRect iOuterRect;	

	/** Inner enclosing rectangle: the text only */

	TRect iInnerRect;

	/** y coordinate of the baseline */

	TInt iBaseline;	

	/** Start document position */

	TInt iStart;

	/** End document position */

	TInt iEnd;			

	/** Line number */

	TInt iLineNumber;

	/** Paragraph number */

	TInt iParNumber;	

	/** Line number in the paragraph */

	TInt iLineInPar;

	/** y coordinate of the top of the paragraph */

	TInt iParTop;

	/** Start of paragraph, end of paragraph, etc. */

	TUint iFlags;		

	};

/**

A structure to hold a logical document position that can be converted to a raw

document position or an x-y position.

A document position can specify a leading or trailing edge or a text

directionality so that bidirectional hit testing can use both these

distinctions.

The leading edge at position N is the position before character N in logical

order, and the trailing edge is the position after character in logical order.

Specification by directionality works differently. Character N in left-to-right

text is preceded by position N (left-to-right) and followed by position N+1

(left-to-right). Character N in right-to-left text is preceded (in display

order) by position N+1 (right-to-left) and followed by position N

(right-to-left).

@publishedAll

@released

*/

class TTmDocPosSpec

	{

public:

	/**

	The cursor type.

	*/

	enum TType

		{

		/** trailing edge */

		ETrailing,

		/** leading edge */

		ELeading,

		/** left-to-right */

		ELeftToRight,

		/** right-to-left */

		ERightToLeft

		};

	inline TTmDocPosSpec();

	inline TTmDocPosSpec(TInt aPos,TType aType);

	inline TTmDocPosSpec(const TTmDocPos& aRawDocPos);

	/** the edge position in the document; 0 ... document length */

	TInt iPos;

	/** the type as specified above */

	TType iType;	

	};

/** 

A structure for holding a raw document position that can be converted to or

from an x-y position and compared ordinally, which cannot be done with the more

abstract TTmDocPosSpec class. Leading edges are distinguished from trailing

edges so that bidirectional hit testing and cursor positioning can distinguish

between 'after character N', and 'before character N + 1', which may be some

distance apart if N and N + 1 are in runs of opposite directionality. 

@publishedAll

@released

*/

class TTmDocPos

	{

public:

	inline TTmDocPos();

	inline TTmDocPos(TInt aPos,TBool aLeadingEdge);

	IMPORT_C TBool operator==(const TTmDocPos& aPos) const;

	inline TBool operator!=(const TTmDocPos& aPos) const;

	IMPORT_C TBool operator>(const TTmDocPos& aPos) const;

	IMPORT_C TBool operator>=(const TTmDocPos& aPos) const;

	inline TBool operator<(const TTmDocPos& aPos) const;

	inline TBool operator<=(const TTmDocPos& aPos) const;

	/** the edge position in the document; 0 ... document length */

	TInt iPos;

	/** true if the position is a leading edge */

	TBool iLeadingEdge;	

	};

/** 

Holds information about a position in a document. 

@publishedAll

@released

*/	

class TTmPosInfo2

	{

public:

	/** Document position. */

	TTmDocPos iDocPos;

	/** True if the position is attatched to text flowing right-to-left. */

	TBool iRightToLeft;

	/** Intersection of the character edge with the baseline. */

	TPoint iEdge;

	};

/** 

A structure for returning information about a position in a line.

The class should only be used internally by FORM component.

@deprecated 7.0s 

@internalComponent

*/

class TTmPosInfo

	{

public:

	TTmPosInfo() {}

	TTmPosInfo(const TTmPosInfo2& a) : iDocPos(a.iDocPos), iEdge(a.iEdge) {}

	TTmDocPos iDocPos;	// the document position

	TPoint iEdge;			// intersection of the character edge at iDocPos with the baseline

	};

/** 

Cursor placement. Used as an argument to CTextView::SetCursorPlacement().

@see CTextView::SetCursorPlacement()

@publishedAll

@released

*/

enum TTmCursorPlacement

	{

	 /** The text cursor is a vertical line at the insertion position, with its height 

	and depth based on the metrics of the previous character in the paragraph 

	or if none, the next character. */

	ECursorVertical,		

	/** The text cursor is an underline below the character logically after the insertion 

	position. */

	ECursorUnderlineNext,

	/** The text cursor is an underline below the character logically before the insertion 

	position. */

	ECursorUnderlinePrev

	};

/**

A mixin class to make it easy for higher-level classes that own a CTmTextLayout

object to have enquiry functions without it being necessary to implement them

all as forwarding functions. The owner class just implements TextLayout and

overrides GetOrigin if necessary.

Non-const CTmTextLayout functions like Clear are not included because allowing

them to be called on owner classes would probably put the owner class into an

inconsistent state.

The word Layout is prefixed, suffixed or infixed to functions with names that

would usually conflict with owner class names. For example, we have DrawLayout,

not Draw, and GetMinimumLayoutSizeL, not GetMinimumSizeL.

The class should only be used internally by FORM component.

@internalComponent

*/

class MTmTextLayoutForwarder

	{

public:

	IMPORT_C void DrawLayout(CGraphicsContext& aGc,const TPoint& aTopLeft,const TRect& aClipRect,

							 const TLogicalRgb* aDocBackground,TBool aDrawParBackground) const;

	IMPORT_C void DrawBackground(CGraphicsContext& aGc,const TPoint& aTopLeft,const TRect& aClipRect,

								 const TLogicalRgb& aBackground) const;

	IMPORT_C void InvertLayout(CGraphicsContext& aGc,const TPoint& aTopLeft,TInt aStartDocPos,TInt aEndDocPos);

	IMPORT_C TBool FindDocPos(const TTmDocPosSpec& aDocPos,TTmPosInfo2& aPosInfo,TTmLineInfo& aLineInfo) const;

	IMPORT_C TBool FindXyPos(const TPoint& aXyPos,TTmPosInfo2& aPosInfo,TTmLineInfo& aLineInfo) const;

	IMPORT_C TBool FindXyPosWithDisambiguation(const TPoint& aXyPos,

		TTmPosInfo2& aPosLeft, TTmPosInfo2& aPosRight,

		TTmLineInfo& aLineInfo) const;

	IMPORT_C TBool DocPosToLine(const TTmDocPosSpec& aDocPos,TTmLineInfo& aLineInfo) const;

	IMPORT_C TBool LineNumberToLine(TInt aLineNumber,TTmLineInfo& aLineInfo) const;

	IMPORT_C TBool ParNumberToLine(TInt aParNumber,TInt aLineInPar,TTmLineInfo& aLineInfo) const;

	IMPORT_C TBool YPosToLine(TInt aYPos,TTmLineInfo& aLineInfo) const;

	IMPORT_C TInt WidthOfWidestLine(TInt aTop = 0,TInt aBottom = KMaxTInt) const;

	IMPORT_C void HorizontalExtremes(TInt &aLeft, TInt &aRight,

		TInt aTopY = 0, TInt aBottomY = KMaxTInt) const;

	IMPORT_C TBool GetNextVisualCursorPos(const TTmDocPosSpec& aDocPos,TTmPosInfo2& aInfo,TBool aToLeft) const;

	IMPORT_C TBool GetNextPosLeftWithDisambiguation(const TTmDocPosSpec& aDocPos,

		TTmPosInfo2& aPosLeft, TTmPosInfo2& aPosRight) const;

	IMPORT_C TBool GetNextPosRightWithDisambiguation(const TTmDocPosSpec& aDocPos,

		TTmPosInfo2& aPosLeft, TTmPosInfo2& aPosRight) const;

	IMPORT_C TBool GetCursor(const TTmDocPosSpec& aDocPos,TTmCursorPlacement aPlacement,

							 TTmLineInfo& aLineInfo,TPoint& aOrigin,TInt& aWidth,TInt& aAscent,TInt& aDescent) const;

	IMPORT_C TInt Lines() const;

	IMPORT_C TInt Paragraphs() const;

	IMPORT_C TBool GetDisplayedText(TInt aLineNumber,TDes& aText,TInt& aNeeded) const;

	IMPORT_C void GetMinimumLayoutSizeL(TInt aWrapWidth,TSize& aSize) const;

	IMPORT_C void GetMinimumLayoutSizeL(TInt aWrapWidth,TBool aAllowLegalLineBreaksOnly,TSize& aSize) const;

	IMPORT_C TInt StartChar() const;

	IMPORT_C TInt EndChar() const;

	IMPORT_C TInt LayoutWidth() const;

	IMPORT_C TInt LayoutHeight() const;

	// deprecated functions

	// deprecated 7.0s

	IMPORT_C TBool FindDocPos(const TTmDocPos& aDocPos,TTmPosInfo& aPosInfo,TTmLineInfo& aLineInfo) const;

	// deprecated 7.0s

	IMPORT_C TBool FindXyPos(const TPoint& aXyPos,TTmPosInfo& aPosInfo,TTmLineInfo& aLineInfo) const;

	// deprecated 7.0s

	IMPORT_C TBool DocPosToLine(const TTmDocPos& aDocPos,TTmLineInfo& aLineInfo) const;

	// deprecated 7.0s

	IMPORT_C TBool GetNextVisualCursorPos(const TTmDocPos& aDocPos,TTmPosInfo& aInfo,TBool aToLeft) const;

	// deprecated 7.0s

	IMPORT_C TBool GetCursor(const TTmDocPos& aDocPos,

		TTmCursorPlacement aPlacement, TTmLineInfo& aLineInfo,

		TPoint& aOrigin, TInt& aWidth, TInt& aAscent, TInt& aDescent) const;

private:

	/** Returns a reference to the CTmTextLayoutObject this

	MTmTextLayoutForwarder forwards inquiries to. */

	virtual const CTmTextLayout& TextLayout() const = 0;

	/** The origin is subtracted from coordinates passed in and added to those

	passed out. */

	IMPORT_C virtual void GetOrigin(TPoint& aPoint) const;

	void FixUpLineInfo(TTmLineInfo& aInfo,const TPoint* aOrigin = NULL) const;

	};

/** Constructs a TTmLineInfo object, setting all data members to 0. */

TTmLineInfo::TTmLineInfo()

	{

	Mem::FillZ(this,sizeof(*this));

	}

/** Constructs a TTmDocPos object, setting iPos to 0 and iLeadingEdge to false.

This is the lowest legal value for a TTmDocPos object. A trailing edge comes

before a leading edge because it is the trailing edge of the character before

the position, while the leading edge is that of the character after the

position. ('Leading' means the first to be encountered when traversing the

document in logical order). */

TTmDocPos::TTmDocPos():

	iPos(0),

	iLeadingEdge(FALSE)

	{

	}

/** Constructs a TTmDocPos object, setting iPos to aPos and iLeadingEdge to

aLeadingEdge.

*/

TTmDocPos::TTmDocPos(TInt aPos,TBool aLeadingEdge):

	iPos(aPos),

	iLeadingEdge(aLeadingEdge)

	{

	}

/** Constructs a TTmDocPosSpec, setting the position to 0 and the type to

trailing. */

TTmDocPosSpec::TTmDocPosSpec():

	iPos(0),

	iType(ETrailing)

	{

	}

/**

The not equal operator.

@return True if both sides have different values.

*/

TBool TTmDocPos::operator!=(const TTmDocPos& aPos) const { return !((*this)==aPos); }

/**

Smaller than operator.

@return

	True if the right side of the operator is further on in the document than

	the left hand side.

*/

TBool TTmDocPos::operator<(const TTmDocPos& aPos) const { return !((*this)>=aPos); }

/**

Smaller than or equal to operator.

@return

	True if the right side of the operator is further on in the document than

	the left hand side or if both sides are identical.

*/

TBool TTmDocPos::operator<=(const TTmDocPos& aPos) const { return !((*this)>aPos); }

/** Constructs a TTmDocPosSpec, setting the position to aPos and the type to

aType.

*/

TTmDocPosSpec::TTmDocPosSpec(TInt aPos,TType aType):

	iPos(aPos),

	iType(aType)

	{

	}

/** Constructs a TTmDocPosSpec from a TTmDocPos. */

TTmDocPosSpec::TTmDocPosSpec(const TTmDocPos& aDocPos):

	iPos(aDocPos.iPos),

	iType(aDocPos.iLeadingEdge ? ELeading : ETrailing)

	{

	}

/** Constructs a TTmCharFormat by converting the information in a TCharFormat. */

TTmCharFormat::TTmCharFormat(const TCharFormat& aFormat)

	{

	*this = aFormat;

	}

/** The inequality operator. Return TRUE if this object and aFormat differ in any way. */

TBool TTmCharFormat::operator!=(const TTmCharFormat& aFormat) const

	{

	return !operator==(aFormat);

	}

/** Constructs a line height parameter structure, setting all the data members

to zero. */

MTmCustom::TLineHeightParam::TLineHeightParam()

	{

	Mem::FillZ(this,sizeof(*this));

	}

#ifndef SYMBIAN_ENABLE_SPLIT_HEADERS

#include <tagma_internal.h>

#include <tagmalayoutandsource.h>

#endif

#endif // __TAGMA_H__