/*

* Copyright (c) 2010 Kanrikogaku Kenkyusho, Ltd.

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of the License "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:

* Kanrikogaku Kenkyusho, Ltd. - Initial contribution

*

* Contributors:

*

* Description:

*

*/

// INCLUDE FILES

#include <coemain.h>

#include <barsread.h>

#include <DirectPrintApp.rsg>

#include <prninf.h>

#include <prnsetup.h>

#include <gdi.h>

#include <prnprev.h>

#include <eikenv.h>

#include <gulbordr.h>					// TGulBorder

#include <e32cmn.h>

#include "directprintapp.pan"

#include "directprintapp.hrh"

#include "directprintpreviewcontrol.h"

const TInt KFirstPage=0;

const TInt KDraggingAccepted = 10;

// -----------------------------------------------------------------------------

// CDirectPrintPreviewControl::NewL()

// Two-phased constructor.

// -----------------------------------------------------------------------------

//

CDirectPrintPreviewControl* CDirectPrintPreviewControl::NewL(const CCoeControl* aParent)

	{

	CDirectPrintPreviewControl* self = CDirectPrintPreviewControl::NewLC(aParent);

	CleanupStack::Pop(self);

	return self;

	}

// -----------------------------------------------------------------------------

// CDirectPrintPreviewControl::NewLC()

// Two-phased constructor.

// -----------------------------------------------------------------------------

//

CDirectPrintPreviewControl* CDirectPrintPreviewControl::NewLC(const CCoeControl* aParent)

	{

	CDirectPrintPreviewControl* self = new(ELeave) CDirectPrintPreviewControl();

	CleanupStack::PushL(self);

	self->ConstructL(aParent);

	return self;

	}

// -----------------------------------------------------------------------------

// CDirectPrintPreviewControl::CDirectPrintPreviewControl()

// C++ default constructor can NOT contain any code, that might leave.

// -----------------------------------------------------------------------------

//

CDirectPrintPreviewControl::CDirectPrintPreviewControl()

	{

	}

// -----------------------------------------------------------------------------

// CDirectPrintPreviewControl::~CDirectPrintPreviewControl()

// C++ default constructor can NOT contain any code, that might leave.

// -----------------------------------------------------------------------------

//

CDirectPrintPreviewControl::~CDirectPrintPreviewControl()

	{

	Window().SetPointerGrab(EFalse);

	delete iPreview;

	}

// -----------------------------------------------------------------------------

// CDirectPrintPreviewControl::ConstructL()

// Symbian 2nd phase constructor can leave.

// -----------------------------------------------------------------------------

//

void CDirectPrintPreviewControl::ConstructL(const CCoeControl* aParent)

	{

	// Create a window for this application view

	if (aParent)

		{

		CreateBackedUpWindowL(*aParent->DrawableWindow(), EGray4);

		}

	else

		{

		CreateBackedUpWindowL((RWindowTreeNode&)iCoeEnv->RootWin(), EGray4);

		}

	EnableDragEvents();

	Window().SetPointerGrab(ETrue);

	}

// -----------------------------------------------------------------------------

// CDirectPrintPreviewControl::SetPreviewImageObserver()

//

// -----------------------------------------------------------------------------

//

void CDirectPrintPreviewControl::SetPreviewImageObserver(MPrintProcessObserver* aObserver)

	{

	__ASSERT_DEBUG(iPreview,Panic(EDirectPrintNullPointer));

	iPreview->SetObserver(*aObserver);

	}

// -----------------------------------------------------------------------------

// CDirectPrintPreviewControl::CountComponentControls()

// Called by framework

// -----------------------------------------------------------------------------

//

TInt CDirectPrintPreviewControl::CountComponentControls() const

	{

//	return(2);

	return(0);

	}

// -----------------------------------------------------------------------------

// CDirectPrintPreviewControl::ComponentControl()

// Called by framework

// -----------------------------------------------------------------------------

//

CCoeControl* CDirectPrintPreviewControl::ComponentControl( TInt aIndex ) const

	{

	CCoeControl* control=NULL;

	switch (aIndex)

		{

	case 0:

//		control=iButton[0];

		break;

	case 1:

//		control=iButton[1];

		break;

		}

	return(control);

	}

// -----------------------------------------------------------------------------

// CDirectPrintPreviewControl::WriteInternalStateL()

//

// -----------------------------------------------------------------------------

//

#ifndef _DEBUG

void CDirectPrintPreviewControl::WriteInternalStateL(RWriteStream& /*aWriteStream*/) const

	{

	}

#else

void CDirectPrintPreviewControl::WriteInternalStateL(RWriteStream& aWriteStream) const

	{

	CEikBorderedControl::WriteInternalStateL(aWriteStream);

	}

#endif

// -----------------------------------------------------------------------------

// CDirectPrintAppAppView::HandlePointerEventL()

// Called by framework to handle pointer touch events.

// Note: although this method is compatible with earlier SDKs,

// it will not be called in SDKs without Touch support.

// -----------------------------------------------------------------------------

//

void CDirectPrintPreviewControl::HandlePointerEventL(

		const TPointerEvent& aPointerEvent)

	{

	const TRect rect=Rect();

	if( !rect.Contains(aPointerEvent.iPosition) )

		{

		return;

		}

	switch ( aPointerEvent.iType )

		{

		case TPointerEvent::EButton1Down:

			{

			iPointerDownPos = aPointerEvent.iPosition;

			}

			break;

		case TPointerEvent::EButton1Up:

		case TPointerEvent::EDrag:

			{

			TInt x =  aPointerEvent.iPosition.iX - iPointerDownPos.iX;

			TInt y = aPointerEvent.iPosition.iY - iPointerDownPos.iY;

			if (Abs(x) > KDraggingAccepted || Abs(y) > KDraggingAccepted)

				{

				TPoint newPos;

				TInt maxWidth = iDisplayRect.Width() - rect.Width();

				TInt maxHeight = iDisplayRect.Height() - rect.Height();

				newPos.iX = Min(iDisplayPoint.iX + x, maxWidth);

				if (newPos.iX <= (maxWidth*-1))

					newPos.iX = (maxWidth*-1);

				newPos.iY = Min(iDisplayPoint.iY + y, maxHeight);

				if (newPos.iY <= (maxHeight*-1))

					newPos.iY = (maxHeight*-1);

				iDisplayPoint = newPos;

				iPointerDownPos = aPointerEvent.iPosition;

				DrawNow();

				}

			}

			break;

		default:

			break;

		}

	}

void CDirectPrintPreviewControl::ActivateL()

	{

	DrawButtons();

	CCoeControl::ActivateL();

	}

TCoeInputCapabilities CDirectPrintPreviewControl::InputCapabilities() const

	{

	return TCoeInputCapabilities(TCoeInputCapabilities::ENavigation);

	}

void CDirectPrintPreviewControl::InitializeFormat(

										CPrintSetup& aPrintSetup,

										MPageRegionPrinter& aBodyPrinter,

										TPrintPreviewFormat& aFormat,

										TInt& aNumPagesInDoc,

										TInt& aFirstPageToDisplay,

										TInt aNumPagesToView,

										CPrintPreviewImage::TMarginState& aMarginState)

	{

	iPrintSetup=&aPrintSetup;

	iBodyPrinter=&aBodyPrinter;

	iPrintPreviewFormat=&aFormat;

	iFirstPageToDisplay=&aFirstPageToDisplay;

	iNumPagesInDoc=aNumPagesInDoc;

	iNumPagesToView=aNumPagesToView;

	iMarginState=aMarginState;

	}

void CDirectPrintPreviewControl::SetNumBands(TInt aNumBands)

	{

	iNumBands=aNumBands;

	if (iPreview)

		{

		iPreview->SetNumBands(aNumBands);

		}

	}

// -----------------------------------------------------------------------------

// CDirectPrintPreviewControl::SizeChanged()

// Called by framework when the view size is changed.

// -----------------------------------------------------------------------------

//

void CDirectPrintPreviewControl::SizeChanged()

	// can't recover if CPrintPreviewImage::NewL() fails !!

	{

	iPreviewDraw=ETrue;

	// set zoom level 

	SetZoomLevelAndDispalyRect(EPreviewZoomLevel1);

	// create CPrintPreviewImage object

	TRAP_IGNORE(CreatePreviewImageL());

	}

// -----------------------------------------------------------------------------

// CDirectPrintPreviewControl::Draw()

// Draws the display.

// -----------------------------------------------------------------------------

//

void CDirectPrintPreviewControl::Draw(const TRect& aRect) const

	{

	if (!iPreviewDraw)

		return;

//	DrawButtons();

	CWindowGc& gc=SystemGc();

	iBorder.Draw(gc,Rect());

	gc.Clear();

	gc.SetPenStyle(CGraphicsContext::ENullPen);

	gc.SetBrushColor(KRgbWhite);

	gc.SetBrushStyle(CGraphicsContext::ESolidBrush);

//	TRect rectAboveButton(TPoint(iDisplayRect.iTl.iX-KScrollButtonWidth,iDisplayRect.iTl.iY),TSize(KScrollButtonWidth,iDisplayRect.Height()-(iButton[0]->IsVisible()? KScrollButtonWidth : 0)));

//	gc.DrawRect(rectAboveButton);

//	rectAboveButton=(TPoint(iDisplayRect.iTl.iX-KScrollButtonWidth,iDisplayRect.iTl.iY),TSize(KScrollButtonWidth,iDisplayRect.Height()-(iButton[1]->IsVisible()? KScrollButtonWidth : 0)));

//	rectAboveButton.Move(iDisplayRect.Width()+KScrollButtonWidth+1,1); // why are the 1s needed???

//	gc.DrawRect(rectAboveButton);

	gc.SetPenStyle(CGraphicsContext::ESolidPen);

	CONST_CAST(CDirectPrintPreviewControl*,this)->DrawPreview(aRect);  // cast away constness

	}

void CDirectPrintPreviewControl::SetDrawFlag(TBool aDraw)

	{

	iPreviewDraw=aDraw;

	}

TBool CDirectPrintPreviewControl::DrawFlag()

	{

	return iPreviewDraw;

	}

void CDirectPrintPreviewControl::SetFormatAndDrawL(TInt& aFirstPageToDisplay,TInt& aNumPagesToView)

	{

	iPreview->FormatL(iNumPagesInDoc,aFirstPageToDisplay,aNumPagesToView);

	*iFirstPageToDisplay=aFirstPageToDisplay;

	iNumPagesToView=aNumPagesToView;

	DrawButtons();

	DrawNow();

	}

void CDirectPrintPreviewControl::SetMarginAndDrawL(CPrintPreviewImage::TMarginState aMarginState)

	{

	iPreview->SetMargins(aMarginState);

	iMarginState=aMarginState;

	DrawNow();

	}

void CDirectPrintPreviewControl::SetNumPagesInDoc(TInt aNumPagesInDoc,TInt aFirstPageToDisplay,TInt aNumPagesToView)

	{

	iNumPagesInDoc=aNumPagesInDoc;

	*iFirstPageToDisplay=aFirstPageToDisplay;

	iNumPagesToView=aNumPagesToView;

	}

void CDirectPrintPreviewControl::DrawPreview(const TRect& aRect)

	{

	TRAPD(err,iPreview->DrawL(iDisplayPoint,aRect));

	if (err)

		{

		SystemGc().Clear(iDisplayRect);

		CEikonEnv::Static()->NotifyIdleErrorWhileRedrawing(err);

		}

	}

TKeyResponse CDirectPrintPreviewControl::OfferKeyEventL(const TKeyEvent& aKeyEvent,TEventCode /*aType*/)

	{

	TInt newFirstPageToDisplay=*iFirstPageToDisplay;

	switch (aKeyEvent.iCode)

		{

	case EKeyLeftArrow:

	case EKeyPageUp:

		newFirstPageToDisplay--;

		break;

	case EKeyRightArrow:

	case EKeyPageDown:

		newFirstPageToDisplay++;

		break;

	case EKeyHome:

		newFirstPageToDisplay=KFirstPage;

		break;

	case EKeyEnd:

		newFirstPageToDisplay=iNumPagesInDoc-iNumPagesToView;

		break;

	default:

		return(EKeyWasNotConsumed);

		}

	SwitchFirstPageToDisplayL(newFirstPageToDisplay);

	return(EKeyWasConsumed);

	}

void CDirectPrintPreviewControl::SwitchFirstPageToDisplayL(TInt& aNewFirstPageToDisplay)

	{

	if (aNewFirstPageToDisplay<KFirstPage)

		aNewFirstPageToDisplay=KFirstPage;

	if (aNewFirstPageToDisplay>iNumPagesInDoc-iNumPagesToView)

		aNewFirstPageToDisplay=iNumPagesInDoc-iNumPagesToView;

	if (aNewFirstPageToDisplay!=*iFirstPageToDisplay)

		SetFormatAndDrawL(aNewFirstPageToDisplay,iNumPagesToView);

	}

void CDirectPrintPreviewControl::HandleControlEventL(CCoeControl* /*aControl*/,TCoeEvent aEventType)

	{

	if (aEventType!=EEventStateChanged)

		return;

	TInt newFirstPageToDisplay=*iFirstPageToDisplay;

//	if (aControl==iButton[0])

//		newFirstPageToDisplay--;

//	else if (aControl==iButton[1])

//		newFirstPageToDisplay++;

	SwitchFirstPageToDisplayL(newFirstPageToDisplay);

	}

void CDirectPrintPreviewControl::DrawButtons() const

	{

	if (iNumPagesToView==iNumPagesInDoc)

		{

//		iButton[1]->MakeVisible(EFalse);

//		iButton[0]->MakeVisible(EFalse);

		return;

		}

//	TBool leftvisible=ETrue;

//	TBool rightvisible=ETrue;

//	if (*iFirstPageToDisplay==KFirstPage)

//		leftvisible=EFalse;

//	else

//		{

//		if (*iFirstPageToDisplay>=iNumPagesInDoc-iNumPagesToView)

//			rightvisible=EFalse;

//		}

//	iButton[0]->MakeVisible(leftvisible);

//	iButton[1]->MakeVisible(rightvisible);

////	iButton[0]->DrawNow();

////	iButton[1]->DrawNow();

	}

// for zoom

void CDirectPrintPreviewControl::SetZoomLevel(TInt /*aZoomLevel*/)

	{

	SetZoomLevelAndDispalyRect(iZoomLevel);

	}

TInt CDirectPrintPreviewControl::GetZoomLebel()

	{

	return (TInt)iZoomLevel;

	}

void CDirectPrintPreviewControl::IncrementZoomLevel()

	{

	TInt zoom = iZoomLevel + 1;

	if (zoom >= EPreviewZoomLevel1

	 && zoom < EPreviewZoomLevelMax)

		{

		SetZoomLevelAndDispalyRect(zoom);

		TRAPD(err, CreatePreviewImageL());

		if (err == KErrNone)

			{

			DrawNow();

			}

		}

	}

void CDirectPrintPreviewControl::DecrementZoomLevel()

	{

	TInt zoom = iZoomLevel - 1;

	if (zoom >= EPreviewZoomLevel1)

		{

		SetZoomLevelAndDispalyRect(zoom);

		TRAPD(err, CreatePreviewImageL());

		if (err == KErrNone)

			{

			DrawNow();

			}

		}

	}

	// set zoom level 

void CDirectPrintPreviewControl::SetZoomLevelAndDispalyRect(TInt aZoomLevel)

	{

	static const TInt KZoomPercent[EPreviewZoomLevelMax] = {100, 120, 140, 160, 180};

	TInt oldZoomLevel = iZoomLevel;

	if (aZoomLevel == EPreviewZoomLevel1)

		{

		iDisplayRect = iBorder.InnerRect(Rect());

		iDisplayPoint = iDisplayRect.iTl;

		}

	else

		{

		TRect rect(iBorder.InnerRect(Rect()));

		TSize newSize;

		newSize.iWidth = (rect.Size().iWidth * KZoomPercent[aZoomLevel] + 5) / KZoomPercent[EPreviewZoomLevel1];

		newSize.iHeight = (rect.Size().iHeight * KZoomPercent[aZoomLevel] + 5) / KZoomPercent[EPreviewZoomLevel1];

		iDisplayRect.SetSize(newSize);

		if (oldZoomLevel != EPreviewZoomLevel1)

			{

			TPoint newPos;

			newPos.iX = Max(0, ((iDisplayPoint.iX  * KZoomPercent[aZoomLevel] + 5) / KZoomPercent[EPreviewZoomLevel1]));

			newPos.iY = Max(0, ((iDisplayPoint.iY  * KZoomPercent[aZoomLevel] + 5) / KZoomPercent[EPreviewZoomLevel1]));

			iDisplayPoint = newPos;

			}

		}

	iZoomLevel = aZoomLevel;

	}

void CDirectPrintPreviewControl::CreatePreviewImageL()

	{

	if (iPreview)

		{

		delete iPreview;

		iPreview=NULL;

		}

	iPreview = CPrintPreviewImage::NewL(*iPrintSetup,

										*iBodyPrinter,

										CEikonEnv::Static()->WsSession(),

										Window(),

										iDisplayRect.Size(),

										*iPrintPreviewFormat);

	iPreview->SetNumBands(iNumBands);

	iPreview->FormatL(iNumPagesInDoc,*iFirstPageToDisplay,iNumPagesToView);

	iPreview->SetMargins(iMarginState);

//	TRect buttonRect(TPoint(iDisplayRect.iTl.iX-KScrollButtonWidth,iDisplayRect.iBr.iY-KScrollButtonWidth),

//					TSize(KScrollButtonWidth,KScrollButtonWidth));

//	iButton[0]->SetRect(buttonRect);

//	buttonRect.Move(iDisplayRect.Width()+KScrollButtonWidth,0);

//	iButton[1]->SetRect(buttonRect);

	}

// End of file