/*
* 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);
	}