/*

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

* CTextLayout implementation using the TAGMA text formatting system.

*

*/

#include <txtlaydc.h>

#include "FRMTLAY.H"

#include "FRMCONST.H"

#include "FORMUTIL.H"

#ifdef SYMBIAN_ENABLE_SPLIT_HEADERS

#include "FRMCONST_INTERNAL.H"

#include "FRMCONST_PARTNER.H"

#include "TAGMA_INTERNAL.H"

#include "FRMTLAY_INTERNAL.H"

#endif

const TInt KMaxExtraLines = 10; // maximum number of lines to format after the current and following lines

								// before using background formatting

// during page down/up, the number of lines that should remain visible after

// the scroll, counting from the first line that is not completely visible.

// i.e. setting this to 0 means always scroll KMaxProportionOfScreenToScroll.

// setting it to 1 means make sure that no lines are ever both partially off the

// top/bottom before the scroll and partially visible off the bottom/top after

// the scroll.

// setting it to any number higher means keep that number -1 lines completely

// visible before and after the scroll.

const TInt KNumberOfLinesToKeepVisibleDuringScroll = 2;

/** maximum scroll proportions in thousandths. This overrides

 the KNumberOfLinesToKeepVisibleDuringScroll constant.*/

const TInt KMaxProportionOfScreenToScroll = 1000;

/** minimum scroll proportions in thousandths. This overrides

 the KNumberOfLinesToKeepVisibleDuringScroll constant.*/

const TInt KMinProportionOfScreenToScroll = 600;

/**

Constructs an iterator over the text referenced by aSource.

@param aSource The source of the text to be iterated over.

*/

CTextLayout::TUtf32SourceCache::TUtf32SourceCache(const MTmSource& aSource)

	: iSource(&aSource), iCurrentViewIndex(-1)

	{

	}

/**

Constructs an iterator over the text formatted by aLayout.

@param aLayout The formatter of the text to be iterated over.

*/

CTextLayout::TUtf32SourceCache::TUtf32SourceCache(const CTextLayout& aLayout)

	: iSource(aLayout.iSource), iCurrentViewIndex(-1)

	{

	}

/**

Gets the specified character without uniting surrogate pairs.

@param aIndex The document position to retrieve.

@pre 0 <= aIndex && aIndex < {document length}

*/

TText CTextLayout::TUtf32SourceCache::GetUtf16(TInt aIndex)

	{

	TTmCharFormat dummy;

	if (aIndex < iCurrentViewIndex)

		{

		iCurrentViewIndex = 0;

		iSource->GetText(iCurrentViewIndex, iCurrentView, dummy);

		}

	TInt currentViewEnd = iCurrentViewIndex + iCurrentView.Length();

	while (currentViewEnd <= aIndex)

		{

		TInt difference = aIndex - iCurrentViewIndex;

		TInt newIndex = aIndex - (difference >> 1);

		iCurrentViewIndex = newIndex < currentViewEnd?

			currentViewEnd : newIndex;

		iSource->GetText(iCurrentViewIndex, iCurrentView, dummy);

		currentViewEnd = iCurrentViewIndex + iCurrentView.Length();

		}

	return iCurrentView[aIndex - iCurrentViewIndex];

	}

/**

Gets the specified character, uniting surrogate pairs if appropriate.

@param aIndex

	The document position to retrive.

@return

	The character at position aIndex. If aIndex is at the first code of a

	surrogate pair, the full character is returned. If it is the second of a

	valid surrogate pair or an unpaired surrogate, the surrogate is returned.

*/

TChar CTextLayout::TUtf32SourceCache::GetUtf32(TInt aIndex)

	{

	TText code = GetUtf16(aIndex);

	if (TChar::IsHighSurrogate(code) && iSource->DocumentLength() < aIndex + 1)

		{

		TText code2 = GetUtf16(aIndex + 1);

		if (TChar::IsLowSurrogate(code2))

			return TChar::JoinSurrogate(code, code2);

		}

	return code;

	}

/** Allocates and constructs a CTextLayout object. By default, the formatting

is set to the entire document (EFFormatAllText).

The text needs to be reformatted after a call to this function.

@param aDoc Pointer to the MLayDoc implementation that is the source of the

text and formatting information. Must not be NULL or a panic occurs.

@param aWrapWidth The wrapping width in pixels.

@return Pointer to the new CTextLayout object. */

EXPORT_C CTextLayout *CTextLayout::NewL(MLayDoc *aLayDoc,TInt aWrapWidth)

	{

	CTextLayout* t = new(ELeave) CTextLayout;

	CleanupStack::PushL(t);

	t->ConstructL(aLayDoc,aWrapWidth);

	CleanupStack::Pop();

	return t;

	}

EXPORT_C CTextLayout::CTextLayout():

	iText(NULL),

	iExcessHeightRequired(0),

	iWnd(NULL),

	iBeginRedrawCount(0),

	iRedrawRect(),

	iTextViewCursorPos(NULL),

	iIsWndInExternalRedraw(EFalse),

	iUnformattedStart(KMaxTInt),

	iHighlightExtensions(NULL),

	iSource(NULL)

	{

	}

/** Constructs an object with a text source of aLayDoc and a wrap width of

aWrapWidth, with wrapping turned on.

*/

EXPORT_C void CTextLayout::ConstructL(MLayDoc *aLayDoc,TInt aWrapWidth)

	{

	iHighlightExtensions = new(ELeave) TTmHighlightExtensions;

	CleanupStack::PushL(iHighlightExtensions);

	iHighlightExtensions->SetAll(0);

	iText = new(ELeave) CTmTextLayout;

	CleanupStack::PushL(iHighlightExtensions);

	iSource = new(ELeave) TLayDocTextSource;

	iSource->iLayDoc = aLayDoc;

	SetWrapWidth(aWrapWidth);

	SetAmountToFormat(EFFormatAllText);

	CleanupStack::Pop(2);

	}

EXPORT_C CTextLayout::~CTextLayout()

	{

	delete iHighlightExtensions;

	iHighlightExtensions = NULL;

	delete iText;

	iText = NULL;

	delete iSource;

	iSource = NULL;

	}

void CTextLayout::SetWindow(RWindow* aWnd)

	{

	iWnd = aWnd;

	}

void CTextLayout::SetReadyToRedraw()

	{

	iReadyToRedraw = ETrue;

	}

void CTextLayout::BeginRedraw(const TRect& aRect)

	{

	if(!iReadyToRedraw)

		return;

	if (0 == iBeginRedrawCount++)

		{

		iRedrawRect = aRect;

		if (NULL != iWnd)

			{

			if (iWnd->GetDrawRect() == TRect::EUninitialized)

				{

				iWnd->Invalidate(aRect);

				iWnd->BeginRedraw(aRect);

				}

				else

					iIsWndInExternalRedraw = ETrue;

			}

		}

	}

void CTextLayout::EndRedraw()

	{

	if(!iReadyToRedraw)

		return;

	__ASSERT_ALWAYS(iBeginRedrawCount > 0, Panic(EInvalidRedraw));

	if (0 == --iBeginRedrawCount)

		{

		if (NULL != iWnd)

			{

			if (!iIsWndInExternalRedraw)

				{

				iWnd->EndRedraw();

				iRedrawRect = TRect();

				}

				else

					iIsWndInExternalRedraw = EFalse;

			}

		}

	}

void CTextLayout::SetExternalDraw(const TRect& aRect)

	{

	__ASSERT_ALWAYS(0 == iBeginRedrawCount, Panic(EInvalidRedraw));

	iBeginRedrawCount++;

	iRedrawRect = aRect;

	}

void CTextLayout::ResetExternalDraw()

	{

	__ASSERT_ALWAYS(1 == iBeginRedrawCount, Panic(EInvalidRedraw));

	iBeginRedrawCount--;

	iRedrawRect = TRect();

	}

TBool CTextLayout::BeginRedrawCalled() const

	{

	return iBeginRedrawCount > 0;

	}

/** Discards all formatting information. This function is used by the CTextView

and the printing classes, but should be called by higher-level classes that

need to clean up after any CTextLayout function has caused an out-of-memory

exception. */

EXPORT_C void CTextLayout::DiscardFormat()

	{

	iText->Clear();

	iBandTop = 0;

	}

TInt CTextLayout::SetBandTop()

	{

	TInt originalBandTop = iBandTop;

	if (iScrollFlags & EFScrollOnlyToTopsOfLines)

		{

		TTmLineInfo line;

		if (iText->YPosToLine(iBandTop, line))

			iBandTop = line.iOuterRect.iTl.iY;

		}

	return originalBandTop - iBandTop;

	}

/** Sets the layout object's source text to aDoc.

The text needs to be reformatted after a call to this function.

@param aDoc Pointer to the MLayDoc implementation that is the source of the

text and formatting information. Must not be NULL or a panic occurs. */

EXPORT_C void CTextLayout::SetLayDoc(MLayDoc *aLayDoc)

	{

	iSource->iLayDoc = aLayDoc;

	}

/** Sets the wrap width. If the current format mode is screen mode

(CLayoutData::EFScreenMode) aWrapWidth is in pixels, otherwise it is in twips.

The text needs to be reformatted after a call to this function.

Note:

A valid wrap width (>0) must be supplied or the expected amount of formatting will 

not take place. This could lead to panics when trying to retrieve formatting 

information that does not exist.

@param aWrapWidth The wrap width in pixels or twips. */

EXPORT_C void CTextLayout::SetWrapWidth(TInt aWrapWidth)

	{

	if (iSource->iFormatMode == CLayoutData::EFScreenMode)

		iSource->iWidth = aWrapWidth;

	else

		iSource->iWidth = iSource->iFormatDevice->HorizontalTwipsToPixels(aWrapWidth);

	}

/** Sets the height of the band in pixels or twips. This is the height of the

visible text, or the view window, and it is also the page height for the

purposes of scrolling up and down by page. If the current mode is screen mode 

(CLayoutData::EFScreenMode) or what-you-see-is-what-you-get mode 

(CLayoutData::EFWysiwygMode), aHeight is in pixels, otherwise it is in twips.

The text needs to be reformatted after a call to this function. 

Note:

A valid band height (>0) must be supplied or the expected amount of formatting will 

not take place. This could lead to panics when trying to retrieve formatting 

information that does not exist.

@param aHeight The band height in pixels or twips. */

EXPORT_C void CTextLayout::SetBandHeight(TInt aHeight)

	{

	iVisibleHeight = aHeight;

	if (iBandHeight != CLayoutData::EFHeightForFormattingAllText || aHeight < 1)

		iBandHeight = aHeight;

	}

/** Gets the height of the band in pixels or twips.

@return The height of the band in pixels or twips. */

EXPORT_C TInt CTextLayout::BandHeight() const

	{

	return VisibleHeightInPixels();

	}

/** Sets the device map used for drawing and formatting. This device map is

also used for formatting and drawing paragraph labels unless a separate label

device map has been set (see SetLabelsDeviceMap()).

The text needs to be reformatted after a call to this function.

Note:

Although the name of the function suggests that only the image device is set,

the formatting device is also set.

@param aGd The device map used for drawing and formatting. */

EXPORT_C void CTextLayout::SetImageDeviceMap(MGraphicsDeviceMap *aDeviceMap)

	{

	iSource->iImageDevice = aDeviceMap;

	iSource->iFormatDevice = aDeviceMap;

	}

/** Sets the device map used for formatting and drawing paragraph labels. If

not set, the device map used for labels will be the same as that used for the

text.

The text needs to be reformatted after a call to this function.

@param aDeviceMap The device map used for formatting and drawing paragraph

labels. */

EXPORT_C void CTextLayout::SetLabelsDeviceMap(MGraphicsDeviceMap *aDeviceMap)

	{

	iSource->iLabelsDevice = aDeviceMap;

	}

/** Sets whether to format all the text (if aAmountOfFormat is

EFFormatAllText), or just the visible band (if aAmountOfFormat is

EFFormatBand). If band formatting is selected, enough text is formatted to fill

the visible height.

The text needs to be reformatted after a call to this function.

@param aAmountOfFormat CTextLayout::EFFormatBand (the default) to format the

visible text only. CTextLayout::EFFormatAllText to format all the text in the

document. */

EXPORT_C void CTextLayout::SetAmountToFormat(TAmountFormatted aAmountOfFormat)

	{

	if (aAmountOfFormat == EFFormatBand)

		iBandHeight = iVisibleHeight;

	else

		iBandHeight = CLayoutData::EFHeightForFormattingAllText;

	}

/** Tests whether band formatting is on, as set by

CTextLayout::SetAmountToFormat().

@return ETrue if band formatting is on, EFalse if not. */

EXPORT_C TBool CTextLayout::IsFormattingBand() const

	{

	return iBandHeight != CLayoutData::EFHeightForFormattingAllText;

	}

/** Sets the format mode and wrap width and (for certain format modes only)

sets the formatting device.

The text needs to be reformatted after a call to this function.

Notes:

If aFormatMode is CLayoutData::EFWysiwygMode or

CLayoutData::EFPrintPreviewMode, the format device is set to aFormatDevice,

which must not be NULL.

If aFormatMode is CLayoutData::EFScreenMode or CLayoutData::EFPrintMode,

aFormatDevice is ignored and should be NULL; the format device is set to the

image device.

The wrap width is set in either twips or pixels using the same rule as for

SetWrapWidth().

@param aFormatMode The format mode.

@param aWrapWidth The wrap width in pixels or twips.

@param aFormatDevice The formatting device or NULL, depending on the format

mode. */

EXPORT_C void CTextLayout::SetFormatMode(CLayoutData::TFormatMode aFormatMode,TInt aWrapWidth,

										 MGraphicsDeviceMap* aFormatDevice)

	{

	if (aFormatMode == CLayoutData::EFWysiwygMode || aFormatMode == CLayoutData::EFPrintPreviewMode)

		{

		__ASSERT_ALWAYS(aFormatDevice != NULL,Panic(EFormatDeviceNotSet));

		iSource->iFormatDevice = aFormatDevice;

		}

	else

		iSource->iFormatDevice = iSource->iImageDevice;

	iSource->iFormatMode = aFormatMode;

	SetWrapWidth(aWrapWidth);

	}

/** Turns wrapping on (if aNoWrapping is EFParagraphsWrappedByDefault) or off

(if aNoWrapping is EFAllParagraphsNotWrapped). Overrides the paragraph format

when wrapping is turned off -paragraphs are not broken into lines even if the

iWrap member of CParaFormat is ETrue. If wrapping is turned on,

CParaFormat::iWrap is honoured.

The text needs to be reformatted after a call to this function.

@param aNoWrapping EFAllParagraphsNotWrapped (the default) to turn wrapping

off, EFParagraphsWrappedByDefault to turn wrapping on. */

EXPORT_C void CTextLayout::ForceNoWrapping(TBool aNoWrapping)

	{

	if (aNoWrapping)

		iSource->iFlags &= ~TLayDocTextSource::EWrap;

	else

		iSource->iFlags |= TLayDocTextSource::EWrap;

	}

/** Tests whether wrapping is on or off.

@return ETrue if wrapping is on, EFalse if off. */

EXPORT_C TBool CTextLayout::IsWrapping() const

	{

	return (iSource->iFlags & TLayDocTextSource::EWrap) != 0;

	}

/** Sets the truncation mode. If truncation is on, lines that exceed the wrap

width, either because they have no legal line break, or because wrapping is

off, are truncated, and an ellipsis is inserted.

@param aOn If ETrue, lines which extend beyond the wrap width are truncated

with an ellipsis character. If EFalse, no ellipsis is used. */

EXPORT_C void CTextLayout::SetTruncating(TBool aOn)

	{

	if (aOn)

		iSource->iFlags |= TLayDocTextSource::ETruncateWithEllipsis;

	else

		iSource->iFlags &= ~TLayDocTextSource::ETruncateWithEllipsis;

	}

/** Tests whether truncation is on (as set by SetTruncating()).

@return ETrue if truncation is on, EFalse if not. */

EXPORT_C TBool CTextLayout::Truncating() const

	{

	return (iSource->iFlags & TLayDocTextSource::ETruncateWithEllipsis) != 0;

	}

/** Sets the ellipsis character to be used if truncation is on. Specify the

value 0xFFFF (the illegal Unicode character) if no ellipsis character should

be used. By default, the ellipsis character is 0x2026, the ordinary horizontal

ellipsis.

@param aEllipsis The Unicode value of the truncating ellipsis character. */

EXPORT_C void CTextLayout::SetTruncatingEllipsis(TChar aEllipsis)

	{

	iSource->iEllipsis = aEllipsis;

	}

/** Returns the ellipsis character used when truncation is on. The value 0xFFFF

(the illegal Unicode character) means that no ellipsis character is appended to

truncated text.

@return The Unicode value of the truncating ellipsis character. */

EXPORT_C TChar CTextLayout::TruncatingEllipsis() const

	{

	return iSource->iEllipsis;

	}

/** Sets the width in pixels of the margin in which labels are drawn.

The text needs to be reformatted after a call to this function.

@param aWidth The width in pixels of the labels margin. */

EXPORT_C void CTextLayout::SetLabelsMarginWidth(TInt aWidth)

	{

	iSource->iLabelsWidth = aWidth;

	}

/** Specifies which non-printing characters (e.g. space, paragraph break, etc.)

are to be drawn using symbols.

The text needs to be reformatted after a call to this function.(because

non-printing characters may differ in width from their visible

representations).

@param aVisibility Indicates which non-printing characters are drawn using

symbols. */

EXPORT_C void CTextLayout::SetNonPrintingCharsVisibility(TNonPrintingCharVisibility aVisibility)

	{

	iSource->iNonPrintingCharVisibility = aVisibility;

	}

/** Returns which non-printing characters are drawn using symbols.

@return Indicates which non-printing characters are drawn using symbols. */

EXPORT_C TNonPrintingCharVisibility CTextLayout::NonPrintingCharsVisibility() const

	{

	return iSource->iNonPrintingCharVisibility;

	}

/** Tests whether background formatting is currently taking place. Background

formatting is managed by CTextView, using an active object, when the

CTextLayout object is owned by a CTextView object.