/*

* Copyright (c) 1996-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 "FRMPAGE.H"

#include "FRMTLAY.H"

#include "FRMCONST.H"

#include <txtlaydc.h>

#include "OstTraceDefinitions.h"

#ifdef OST_TRACE_COMPILER_IN_USE

#include "FRMPAGETraces.h"

#endif

#ifdef SYMBIAN_ENABLE_SPLIT_HEADERS

#include "FRMCONST_INTERNAL.H"

#include "FRMCONST_PARTNER.H"

#endif

/** Allocates and constructs a CTextPaginator object with a page list, the

printer device for which the document is to be paginated and an active object

priority.

@param aPrinterDevice Pointer to the printer device for which the document is

to be paginated. This must be provided.

@param aCharsPerPage The page list. This is a client-provided array into which

characters-per-page values are written. Ownership of the array remains with the

client.

@param aPriority Integer specifying the active object priority. A number of

standard priorities are specified in CActive::TPriority.

@return Pointer to the new paginator object. */

EXPORT_C CTextPaginator* CTextPaginator::NewL(CPrinterDevice* aPrinterDevice,CArrayFix<TInt>* aPageList,TInt aPriority)

	{

	CTextPaginator* self=new(ELeave) CTextPaginator(aPriority); 

	CleanupStack::PushL(self);

	self->ConstructL(aPrinterDevice,aPageList);

	CleanupStack::Pop();

	return self;

	}

/** Destructor. Cancels the active object, if any. */

EXPORT_C CTextPaginator::~CTextPaginator()

	{

	Cancel();

	delete iLayout;

	delete iPageLineArray;

	delete iTempPageList;

	}

/** Sets a pagination observer (an instance of a class inherited from

MPaginateObserver). The use of an observer is optional.

An observer may be used when paginating a complete document in the background

using the function PaginateCompleteDocumentL(). The observer notifies

completion of pages, cancellation, errors, and on completion of multiple

pagination.

@param aObserver Observer object inherited from MPaginateObserver. */

EXPORT_C void CTextPaginator::SetObserver(MPaginateObserver* aObserver)

	{

	iObserver=aObserver;

	}

/** Sets a pointer to the document which is to be paginated.

@param aLayDoc The document to paginate. */

EXPORT_C void CTextPaginator::SetDocumentL(MLayDoc* aLayDoc)

	{

	SetOrReplaceDocumentL(aLayDoc);

	iPaginator.Reset();

	iDocPos=0;

	SetLayoutDimensions();

	}

/** Sets a pointer to the printer device for which the document is to be

paginated.

Note: This function must be called, and SetDocumentL() must have been called

beforehand.

@param aPrinterDevice The printer device. */

EXPORT_C void CTextPaginator::SetPrinterDevice(CPrinterDevice* aPrinterDevice)

	{

	if (!iLayout)

	    {

	    OstTrace0( TRACE_FATAL, CTEXTPAGINATOR_SETPRINTERDEVICE, "EFDocumentToPaginateNotSet" );

	    }

 	__ASSERT_ALWAYS(iLayout,FormPanic(EFDocumentToPaginateNotSet));

	iPrinterDevice=aPrinterDevice;

	iLayout->SetImageDeviceMap(aPrinterDevice);

	iPageSizeInTwips=aPrinterDevice->CurrentPageSpecInTwips().OrientedPageSize();

 	SetLayoutDimensions();

	}

/** Sets the page width and height in twips, overriding the current values

specified in the printer device.

@param aPageSpec Contains the new page dimensions. */

EXPORT_C void CTextPaginator::SetPageSpecInTwips(const TPageSpec& aPageSpec)

	{

	iPageSizeInTwips=aPageSpec.OrientedPageSize();

 	SetLayoutDimensions();

	}

/** Sets the widths of the page margins in twips.

The page margin exists on all four sides of the page. It does not include the

line cursor or labels margins. The labels and line cursor margins are set using

SetTextMarginWidthsInTwips().

@param aPageMargins The page margin widths. */

EXPORT_C void CTextPaginator::SetPageMarginsInTwips(const TMargins& aPageMargins)

	{

	iPageMarginsInTwips=aPageMargins;

 	SetLayoutDimensions();

	}

 /** Sets the widths in twips of:

the labels margin the area within which paragraph labels are displayed,

the gutter margin (also known as the line cursor margin) exists between the

labels margin and the text area.

@param aLabelMarginWidth The labels margin width.

@param aGutterMarginWidth The gutter margin width. */

EXPORT_C void CTextPaginator::SetTextMarginWidthsInTwips(TInt aLabelMarginWidth

	,TInt aGutterMarginWidth) 

	{

	iLabelMarginWidthInTwips=aLabelMarginWidth;

	iGutterMarginWidthInTwips=aGutterMarginWidth;

 	SetLayoutDimensions();

	}

CTextPaginator::CTextPaginator(TInt aPriority)

	:CActive(aPriority)

	{

	}

void CTextPaginator::ConstructL(CPrinterDevice* aPrinterDevice,CArrayFix<TInt>* aPageList)

	{

	iPageLineArray=new(ELeave) CArrayFixFlat<TPageLine>(EPageLineArrayGranularity);

	iTempPageList=new(ELeave) CArrayFixFlat<TInt>(EPageListArrayGranularity);

	iPrinterDevice=aPrinterDevice;

	iPageList=aPageList;

	iPaginator.SetArray(iTempPageList);

	iPaginator.SetPageHeight(TextSizeInPixels().iHeight);

	iPageSizeInTwips=iPrinterDevice->CurrentPageSpecInTwips().OrientedPageSize();

	SetLayoutDimensions();

	ResetPaginator();

	}

/** Initiates pagination of a complete document in the background using an

active object. To start pagination, use either this function, or else

incrementally paginate with AppendTextL() do not try to use both functions

together.

Note: SetDocumentL() must have been called beforehand, or a panic occurs. */

EXPORT_C void CTextPaginator::PaginateCompleteDocumentL()

	{

	if (!iLayout)

	    {

	    OstTrace0( TRACE_FATAL, CTEXTPAGINATOR_PAGINATECOMPLETEDOCUMENTL, "EFDocumentToPaginateNotSet" );

	    }

 	__ASSERT_ALWAYS(iLayout,FormPanic(EFDocumentToPaginateNotSet));

  	if (iPageList->Count()==0)

		iPageList->AppendL(iLayDoc->LdDocumentLength());

	if (!IsAdded())

		CActiveScheduler::Add(this); // Adds itself to the active scheduler

 	iMode=EFPaginateCompleteDocument;

	ResetPaginator();

	Reque();

	}

/** Paginates incrementally as a document is being constructed (by appending

paragraphs, for example). Call this function every time text is added to the

document.

The function PaginationCompletedL() should be called at the end (in order to

complete the last entry in the characters-per-page array).

Use either this function, or else paginate in the background with

PaginateCompleteDocumentL() - do not try to use both functions together.

Note: SetDocumentL() must have been called beforehand, or a panic occurs.

@param aCumulativeDocPos The first time the function is called, this should be

given a value of zero. Returns the last document position which has been

paginated.

@return A count of the current number of pages. */

EXPORT_C TInt CTextPaginator::AppendTextL(TInt& aCumulativeDocPos)

	{

	if (!iLayout)

	    {

	    OstTrace0( TRACE_FATAL, CTEXTPAGINATOR_APPENDTEXTL, "EFDocumentToPaginateNotSet" );

	    }

	__ASSERT_ALWAYS(iLayout,FormPanic(EFDocumentToPaginateNotSet));

	if (aCumulativeDocPos>=iLayout->DocumentLength())

	    {

	    OstTrace0( TRACE_FATAL, DUP1_CTEXTPAGINATOR_APPENDTEXTL, "EFInvalidDocPos" );

	    }

 	__ASSERT_ALWAYS(aCumulativeDocPos<iLayout->DocumentLength(),FormPanic(EFInvalidDocPos));

 	iMode=EFPaginateIncrementally;

  	if (iPageList->Count()==0)

		ResetPaginator();

	TBool moreToDo=ETrue;

	while(moreToDo)

		{

		moreToDo = iDocPos<=iLayDoc->LdDocumentLength();

		if (moreToDo)

			{

			TrapPaginateParagraphL();

			}

		else

			{

			if (iMode==EFPaginateCompleteDocument)

				{

				iPaginator.FlushL(iDocPos);

				PageCompleted();

				}

			iPageLineArray->Reset();

			iPageLineArray->Compress();

			}

		}

	aCumulativeDocPos=iDocPos;

	TRAPD(err,CopyTempPageListL());

	if (err)

	    {

		LeaveL(err);

	    }

	return iPageList->Count();

	}

/** This function should be called when incremental pagination has completed

(see AppendTextL()), to complete the final entry in the page list. If an

observer has been set, calls its NotifyCompletion() function.

@return Count of total number of pages. */

EXPORT_C TInt CTextPaginator::PaginationCompletedL()

	{

	TRAPD(err,iPaginator.FlushL(iDocPos));

	if (err)

		LeaveL(err);

	iLayout->DiscardFormat();

	TRAP(err,CopyTempPageListL());

	if (err)

		LeaveL(err);

	if (iObserver)

		iObserver->NotifyCompletion();

	return iPageList->Count();

	}

void CTextPaginator::RunL()

//

// Called by active scheduler.

// Paginates a document one paragraph at a time through succeeding    

// calls.

//

	{

	TBool moreToDo = iDocPos<=iLayDoc->LdDocumentLength();

	if (moreToDo)

		{

		TrapPaginateParagraphL();

		}

	else

		{

		if (iMode==EFPaginateCompleteDocument)

			{

			iPaginator.FlushL(iDocPos);

			PageCompleted();

			}

		iPageLineArray->Reset();

		iPageLineArray->Compress();

		}

	if (moreToDo)

		Reque();

	else

		{

		iLayout->DiscardFormat();

		TRAPD(err,CopyTempPageListL());

		if (err)

			LeaveL(err);

		if (iObserver)

			iObserver->NotifyCompletion();

		}

	}

void CTextPaginator::DoCancel()

	{

	iPaginator.Reset();

	iLayout->DiscardFormat();

	iDocPos=0;

	iPageBreakChar=EFalse;

	if (iObserver)

		iObserver->NotifyError(KErrCancel);	

	}

void CTextPaginator::SetLayoutDimensions()

	{

	iPaginator.SetPageHeight(TextSizeInPixels().iHeight);

	if (iLayout)

		iLayout->SetFormatMode(CLayoutData::EFPrintMode,TextRectInTwips().Width(),iPrinterDevice);

	}

void CTextPaginator::SetOrReplaceDocumentL(MLayDoc* aLayDoc)

	{

	iLayDoc=aLayDoc;

	if (iLayout)

		iLayout->SetLayDoc(aLayDoc);

	else

		iLayout=CTextLayout::NewL(aLayDoc,TextSizeInPixels().iWidth);

	iLayout->SetImageDeviceMap(iPrinterDevice);

	}

TRect CTextPaginator::TextRectInTwips() const

	{

	TRect textRect;

	textRect.iTl.iX=iPageMarginsInTwips.iLeft+iGutterMarginWidthInTwips+iLabelMarginWidthInTwips;

	textRect.iTl.iY=iPageMarginsInTwips.iTop;

	textRect.iBr.iX=iPageSizeInTwips.iWidth-iPageMarginsInTwips.iRight;

	textRect.iBr.iY=iPageSizeInTwips.iHeight-iPageMarginsInTwips.iBottom;

	return textRect;

	}

TSize CTextPaginator::TextSizeInPixels() const

	{

	TRect textRect=iPrinterDevice->TwipsToPixels(TextRectInTwips());

	return textRect.Size();

	}

void CTextPaginator::TrapPaginateParagraphL()

	{

	TRAPD(err,PaginateParagraphL());

	if (err)

		LeaveL(err);

	}

void CTextPaginator::PaginateParagraphL()

	{

	TInt lineHeight;

	TBool keepTogether;  // Prevents page break in a paragraph when ETrue.

	TBool keepWithNext;  // Prevents page break between this & next para when ETrue.

	TBool startNewPage;  // Inserts page break before this paragraph when ETrue.

	TBool widowOrphan;   // Prevents widowing/orphaning of para. lines when ETrue.

	TPageLine pageLine;

	TInt numLines;

	CParaFormat* paraFormat=NULL;

	paraFormat=CParaFormat::NewLC();

	iLayDoc->GetParagraphFormatL(paraFormat,iDocPos);

	TInt docPos=iDocPos;

	TBool startOfPara=(iLayDoc->LdToParagraphStart(docPos)==0);

	keepTogether=paraFormat->iKeepTogether;

	keepWithNext=paraFormat->iKeepWithNext;

	startNewPage=paraFormat->iStartNewPage;

	widowOrphan=paraFormat->iWidowOrphan;

	iPageLineArray->Reset();		   // Better safe than sorry at the moment ###

	iPageLineArray->Compress();

	TInt lines=0;

	TBool moreToDo = ETrue;

	do 

		{

		pageLine.iDocPos=iDocPos;

		pageLine.iStartNewPage=EFalse;

		if (iPageBreakChar)

			pageLine.iStartNewPage=ETrue;

		moreToDo=iLayout->FormatLineL(paraFormat,iDocPos,lineHeight,iPageBreakChar);

		lines++;

		pageLine.iLineHeight=lineHeight;

		if (keepTogether)

			pageLine.iKeepWithNext=ETrue;

		else

			pageLine.iKeepWithNext=EFalse;

		iPageLineArray->AppendL(pageLine);

		} while (moreToDo && lines<EFMaximumNumberLinesInBlock);

	TBool endOfPara=(!moreToDo);

	TBool penultimateLine=EFalse;

	numLines=iPageLineArray->Count();

	if (!endOfPara)

		{

		docPos=iDocPos;

		TBool pageBreakChar;

		penultimateLine=(!iLayout->FormatLineL(paraFormat,docPos,lineHeight,pageBreakChar));

		}

	if (startNewPage && startOfPara)

		(*iPageLineArray)[0].iStartNewPage=ETrue;

	if (keepTogether && endOfPara)

		(*iPageLineArray)[numLines-1].iKeepWithNext=EFalse;

	if (keepWithNext && endOfPara)

		(*iPageLineArray)[numLines-1].iKeepWithNext=ETrue;

	if (widowOrphan)

		{

		if (startOfPara)

			(*iPageLineArray)[0].iKeepWithNext=ETrue;

		if (endOfPara && numLines>=2)

			(*iPageLineArray)[numLines-2].iKeepWithNext=ETrue;

		else if (penultimateLine)

			(*iPageLineArray)[numLines-1].iKeepWithNext=ETrue;

		}

	TBool pageBreak = EFalse;

	for (TInt i=0; i<numLines; i++)

		{

		pageBreak=iPaginator.AppendLineL((*iPageLineArray)[i]);

		if (pageBreak)

			PageCompleted();

		}

	iPageLineArray->Reset();

	iPageLineArray->Compress();

	CleanupStack::PopAndDestroy();	// delete format;

	}

void CTextPaginator::PageCompleted()

	{

	if (iObserver)

		iObserver->NotifyPageCompletion(iTempPageList->Count());

	}

void CTextPaginator::Reque()

//

// Called just before Paginate Process goes to sleep to set it active 

//

	{

	TRequestStatus *pS=(&iStatus);

	User::RequestComplete(pS,0);

	SetActive();

	}

void CTextPaginator::ResetPaginator()

//

	{

	iDocPos=0;

	iPageBreakChar=EFalse;

	iPaginator.Reset();

	}

void CTextPaginator::CopyTempPageListL()

//

// Copies temp page list to one that external user sees

//

	{

	if (iTempPageList->Count()<1 && iMode!=EFPaginateIncrementally)

	    {

	    OstTrace0( TRACE_DUMP, CTEXTPAGINATOR_COPYTEMPPAGELISTL, "EFPageListEmpty" );

	    }

	__ASSERT_DEBUG(iTempPageList->Count()>=1||iMode==EFPaginateIncrementally,FormPanic(EFPageListEmpty));

	TRAPD(err,iPageList->ResizeL(iTempPageList->Count()));

	if (err)

		LeaveL(err);

	{for(TInt ii=0;ii<iTempPageList->Count();ii++)

		(*iPageList)[ii]=(*iTempPageList)[ii];

	}

	}

void CTextPaginator::LeaveL(TInt aErr)

//

// Something has left

// Reset everything.

//

	{

	iPaginator.Reset();

	iLayout->DiscardFormat();

	iDocPos=0;

	iPageLineArray->Reset();

	iPageLineArray->Compress();

	iTempPageList->Reset();

	iTempPageList->Compress();

	if (iObserver)

		iObserver->NotifyError(aErr);

	OstTrace1( TRACE_FATAL, CTEXTPAGINATOR_LEAVEL, "CTextPaginator::LeaveL;aErr=%d", aErr );

	User::Leave(aErr);

	}