/*

 * Copyright (c) 2010 Ixonos Plc.

 * All rights reserved.

 * This component and the accompanying materials are made available

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

 * Ixonos Plc

 *

 * Description: 

 * Image Editor plugin control class.

 *

 */

//  INCLUDES

#include "imageeditordrawcontrol.h"

#include "draw.hrh"

#include "ImageEditorUI.hrh"

#include "ImageEditorPluginBase.hrh"

#include "PluginInfo.h"

#include "JpTimer.h"

#include "ImageEditorUids.hrh"

#include "ImageEditorUiDefs.h"

#include "SystemParameters.h"

#include "drawpath.h"

#include "selectionpopup.h"

#include "iepb.h" 

// debug log

#include "imageeditordebugutils.h"

#include <fbs.h>

#include <badesca.h>

#include <gdi.h>

#include <eikenv.h>

#include <bitdev.h>

#include <aknview.h>

#include <aknutils.h>

#include <ImageEditorUI.mbg>

#include <AknInfoPopupNoteController.h> 

#include <draw.rsg> 

#include <bautils.h> 

#include <ConeResLoader.h> 

#include <gulalign.h>

#include <csxhelp/sie.hlp.hrh>

#include <Icons_doodle.mbg>

#include "CImageLabel.h"

#include <aknnotewrappers.h>

// Log file

_LIT(KDrawPluginLogFile,"drawplugin.log");

//  CONSTANTS

const TInt KWait = 1;

const TInt KMainTextIndex = 0;

//#define HORIZ TPoint(0,72),TPoint(502,360)

//#define VERTICAL TPoint(0,92),TPoint(360,579)

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

// NewL

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

//

CImageEditorDrawControl* CImageEditorDrawControl::NewL(const TRect& aRect,

		CCoeControl* aParent, RPointerArray<CDrawPath>& aPaths, TRgb& aRgb,

		TSize& aSize, TBool &aDisplayTool)

	{

	LOG(KDrawPluginLogFile, "CImageEditorDrawControl::NewL()");

	CImageEditorDrawControl * self = new (ELeave) CImageEditorDrawControl(

			aPaths, aRgb, aSize, aDisplayTool);

	CleanupStack::PushL(self);

	self->ConstructL(aRect, aParent);

	CleanupStack::Pop(); // self

	return self;

	}

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

// CImageEditorDrawControl

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

//

CImageEditorDrawControl::CImageEditorDrawControl(

		RPointerArray<CDrawPath>& aPaths, TRgb& aRgb, TSize& aSize,

		TBool& aDisplayTool) :

	iTickCount(0), iX(0), iY(0), iNaviStepMultiplier(

			KDefaultSmallNavigationStepMultiplier), iDisplayingOkOptionsMenu(

			EFalse), iReadyToRender(EFalse), iResLoader(*ControlEnv()), iPaths(

			aPaths), iRgb(aRgb), iSize(aSize), iDisplayTool(aDisplayTool)

	{

	}

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

// ~CImageEditorDrawControl()

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

//

CImageEditorDrawControl::~CImageEditorDrawControl()

	{

	LOG(KDrawPluginLogFile,

			"CImageEditorDrawControl::~CImageEditorDrawControl()");

	delete iCustomComponet;

	delete iTimer;

	delete iIndicator;

	delete iIndicatorMask;

	delete iPopupController;

	delete iTooltipResize;

	delete iRollAo;

	delete iNaviPaneText;

	delete iGc;

	delete iBitmapDev;

	delete iAnimationAO;

	iUndoPaths.ResetAndDestroy();

	iResLoader.Close();

	for (int i = 0; i < iTotalComponent; i++)

		{

		CImageLabel* &temp = iLabels[i];

		if (temp != NULL)

			{

			delete temp;

			temp = NULL;

			}

		}

	iLabels.ResetAndDestroy();

	}

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

// ConstructL

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

//

void CImageEditorDrawControl::ConstructL(const TRect& aRect,

		CCoeControl* aParent)

	{

	LOG(KDrawPluginLogFile, "CImageEditorDrawControl::ConstructL()");

	CreateWindowL();

	EnableDragEvents();

	//iRollDirection = EFalse;

	iStatuspaneHeight = aRect.iTl.iY;

	iUndo = EFalse;

	iRedo = EFalse;

	iCanRedo = EFalse;

	//iRollDirection = ETrue;

	//  Create resource utility

	TFileName resFile;

	// resource file name

	_LIT(KResourceFile, "draw.rsc");

	resFile.Append(KPgnResourcePath);

	resFile.Append(KResourceFile);

	User::LeaveIfError(CompleteWithAppPath(resFile));

	// Implementation of RConeResourceLoader uses BaflUtils::NearestLanguageFile 

	// to search for a localised resource in proper search order

	iResLoader.OpenL(resFile);

	//	Create timer for fast key repeat

	iTimer = CJPTimer::NewL(this);

	iPopupController = CAknInfoPopupNoteController::NewL();

	iTooltipResize = ControlEnv()->AllocReadResourceL(R_TOOLTIP_TEXT_RESIZE);

	SetExtentToWholeScreen();

	//	TRect a(HORIZ);

	//	iClientRectH = a;

	//	TRect b(VERTICAL);

	//	iClientRectV = b;

	iCustomComponetClick = EFalse;

	TRect rect = Rect();

	//iDisplayTool=ETrue;

	if (rect.Width() < rect.Height())

		{

		InitializeMainMenu(EMainMenuHorizontal);

		}

	else if (rect.Width() > rect.Height())

		{

		InitializeMainMenu(EMainMenuVertical);

		}

	TRect Trect(TPoint(0, 0), TPoint(50, 50));

	iCustomComponet = CCustomerComponet::NewL(Trect, this);

	iCustomComponet->SetExtent(TPoint(40, 100), TSize(50, 50));

	iCustomComponet->SetHandlePointerObserver(this);

	iLastPointEventType = EFalse;

	//	Activate control

	ActivateL();

	}

void CImageEditorDrawControl::InitializeMainMenu(

		TMainMenuLayout aMainMenuLayout)

	{

	iMainMenuLayout = aMainMenuLayout;

	_LIT(KSvgPath, "\\resource\\apps\\icons_doodle.mif");

	TFileName svgFile(KSvgPath);

	User::LeaveIfError(CompleteWithAppPath(svgFile));

	iTotalComponent = 7;

	TRect clipRect;

	if (iMainMenuLayout == EMainMenuHorizontal)

		{

		iLoopMenuRect = TRect(TPoint(0, Rect().iBr.iY - 87), TSize(360, 87));

		for (int i = 0; i < iTotalComponent; i++)

			{

			if (iDisplayTool)

				{

				TRect

						Rect1(TPoint(i * 72, iLoopMenuRect.iTl.iY), TSize(72,

								87));

				clipRect = Rect1;

				}

			else

				{

				TRect Rect2(TPoint(i * 72 - iLoopMenuRect.Width() - 72 * 2,

						iLoopMenuRect.iTl.iY), TSize(72, 87));

				clipRect = Rect2;

				}

			CImageLabel* label = CImageLabel::NewL(this, clipRect,

					CImageLabel::ELabelHorizontal);

			label->SetHandlePointerObserver(this);

			iLabels.Append(label);

			}

		}

	else if (iMainMenuLayout == EMainMenuVertical)

		{

		iLoopMenuRect = TRect(TPoint(Rect().iBr.iX - 87, 0), TSize(87, 360));

		for (int i = 0; i < iTotalComponent; i++)

			{

			if (iDisplayTool)

				{

				TRect

						Rect1(TPoint(iLoopMenuRect.iTl.iX, i * 72), TSize(87,

								72));

				clipRect = Rect1;

				}

			else

				{

				TRect Rect2(TPoint(iLoopMenuRect.iTl.iX, i * 72

						- iLoopMenuRect.Height() - 72 * 2), TSize(87, 72));

				clipRect = Rect2;

				}

			CImageLabel* label = CImageLabel::NewL(this, clipRect,

					CImageLabel::ELabelVertical);

			label->SetHandlePointerObserver(this);

			iLabels.Append(label);

			}

		}

	iLabels[0]->SetImage(svgFile, EMbmIcons_doodlePensize);

	iLabels[0]->SetTooltip(_L("Pensize"));

	iLabels[1]->SetImage(svgFile, EMbmIcons_doodlePalette);

	iLabels[1]->SetTooltip(_L("Palette"));

	iLabels[2]->SetImage(svgFile, EMbmIcons_doodleUndo);

	iLabels[2]->SetTooltip(_L("Undo"));

	iLabels[6]->SetImage(svgFile, EMbmIcons_doodlePensize);

	iLabels[6]->SetTooltip(_L("Null"));

	iAnimationAO = CAnimationAO::NewL();

	iAnimationAO->SetObserver(this);

	iRollAo = CRollAO::NewL();

	iRollAo->SetObserver(this);

	iButtonDownPoint = TPoint(0, 0);

	iDragStartPoint = TPoint(0, 0);

	iDragPrePoint = TPoint(0, 0);

	iDragUpPoint = TPoint(0, 0);

	iPointStartInLoopRect = EFalse;

	iDragIsStart = EFalse;

	iEnableAnimationEffect = EFalse;

	iDragOffset = 0;

	}

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

// SetView

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

//

void CImageEditorDrawControl::SetView(CAknView* aView)

	{

	LOG(KDrawPluginLogFile, "CImageEditorDrawControl::SetView()");

	ASSERT(aView);

	iEditorView = aView;

	}

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

// SetSelectedUiItemL

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

//

void CImageEditorDrawControl::SetSelectedUiItemL(CPluginInfo* aItem)

	{

	LOG(KDrawPluginLogFile, "CImageEditorDrawControl::SetSelectedUiItemL()");

	ASSERT(aItem);

	iItem = aItem;

	delete iNaviPaneText;

	iNaviPaneText = NULL;

	iNaviPaneText = (iItem->Parameters()[KMainTextIndex]).AllocL();

	iEditorView->HandleCommandL(EImageEditorCmdRender);

	}

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

// OfferKeyEventL

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

//

TKeyResponse CImageEditorDrawControl::OfferKeyEventL(

		const TKeyEvent& aKeyEvent, TEventCode aType)

	{

	LOG(KDrawPluginLogFile, "CImageEditorDrawControl::OfferKeyEventL()");

	TKeyResponse response = EKeyWasNotConsumed;

	//  If busy, do not handle anything

	if (Busy())

		{

		response = EKeyWasConsumed;

		}

	// In main state handle the OK Options menu

	else if (aKeyEvent.iCode == EKeyOK)

		{

		iDisplayingOkOptionsMenu = ETrue;

		iEditorView->HandleCommandL(EImageEditorTryDisplayMenuBar);

		response = EKeyWasConsumed;

		}

	//  We handle only event keys

	else if (EEventKey == aType)

		{

		switch (aKeyEvent.iCode)

			{

			case EKeyDownArrow:

			case EKeyUpArrow:

			case EKeyRightArrow:

			case EKeyLeftArrow:

				{

				SetPositionOnImage(ComputeIndicatorPosition());

				StoreParameters(EFalse, EFalse);

				response = EKeyWasConsumed;

				break;

				}

			case EKeyOK:

				{

				break;

				}

			case 0x30: // 0		    		    

			case 0x32: // 2

			case 0x34: // 4

			case 0x35: // 5

			case 0x36: // 6

			case 0x38: // 8

			case EStdKeyIncVolume: // zoom in key

			case EStdKeyDecVolume: // zoom out key

				{

				StorePosAndScaleRelScreen();

				break;

				}

			default:

				{

				break;

				}

			}

		}

	//	Key pressed down, mark pressed key

	else if (aType == EEventKeyDown)

		{

		switch (aKeyEvent.iScanCode)

			{

			case EStdKeyUpArrow:

				{

				iKeyCode = 1;

				response = EKeyWasConsumed;

				break;

				}

			case EStdKeyDownArrow:

				{

				iKeyCode = 2;

				response = EKeyWasConsumed;

				break;

				}

			case EStdKeyLeftArrow:

				{

				iKeyCode = 3;

				response = EKeyWasConsumed;

				break;

				}

			case EStdKeyRightArrow:

				{

				iKeyCode = 4;

				response = EKeyWasConsumed;

				break;

				}

			}

		if (iKeyCode != 0)

			{

			iNaviStepMultiplier = KDefaultSmallNavigationStepMultiplier;

			iTickCount = 0;

			iTimer->Call(KWait);

			}

		}

	//	Key released, mark all keys to zero

	else if (aType == EEventKeyUp)

		{

		switch (aKeyEvent.iScanCode)

			{

			case EStdKeyUpArrow:

			case EStdKeyDownArrow:

			case EStdKeyLeftArrow:

			case EStdKeyRightArrow:

				{

				iKeyCode = 0;

				response = EKeyWasConsumed;

				ShowTooltip();

				break;

				}

			}

		}

	return response;

	}

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

// SizeChanged

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

//

void CImageEditorDrawControl::SizeChanged()

	{

	if (iSizeChangeFlag)

		{

		SetToolBarStatus();

		}

	else

		{

		iSizeChangeFlag = ETrue;

		}

	if (iDragIsStart)

		{

		if (iMainMenuLayout == EMainMenuHorizontal)

			{

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

				{

				if (iLabels[0]->Rect().iTl.iX <= 0)

					{

					TInt x = iLabels[i]->Rect().iTl.iX;

					iLabels[i]->SetPosition(TPoint(x + iDragOffset,

							iLoopMenuRect.iTl.iY));

					iLabels[i]->ResetControl();

					}

				}

			}

		else if (iMainMenuLayout == EMainMenuVertical)

			{

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

				{

				if (iLabels[0]->Rect().iTl.iY <= 0)

					{

					TInt y = iLabels[i]->Rect().iTl.iY;

					iLabels[i]->SetPosition(TPoint(iLoopMenuRect.iTl.iX, y

							+ iDragOffset));

					iLabels[i]->ResetControl();

					}

				}

			}

		DrawNow();

		}

	}

void CImageEditorDrawControl::SetToolBarStatus()

	{

	if (iMainMenuLayout == EMainMenuHorizontal)

		{

		TInt leftX = iLabels[0]->Rect().iTl.iX;