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

// ---------------------------------------------------------------------------
// 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();
	
	iStatuspaneHeight = aRect.iTl.iY;
	iUndo = EFalse;
	iRedo = EFalse;
	iCanRedo = EFalse;
	//  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();
	
	iCustomComponetClick = EFalse;
	TRect rect = Rect();
	//judge the current screen status.
	if (rect.Width() < rect.Height())
		{
		InitializeMainMenu(EMainMenuVertical);
		}
	else if (rect.Width() > rect.Height())
		{
		InitializeMainMenu(EMainMenuHorizontal);
		}

	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();

	}
// ---------------------------------------------------------------------------
// CImageEditorDrawControl::InitializeMainMenu£¨£©
// initialize tool bar component.
// ---------------------------------------------------------------------------
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 == EMainMenuVertical)
		{
		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::ELabelVertical);
			label->SetHandlePointerObserver(this);
			iLabels.Append(label);
			}
		}
	else if (iMainMenuLayout ==EMainMenuHorizontal )
		{
		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::ELabelHorizontal);
			label->SetHandlePointerObserver(this);
			iLabels.Append(label);
			}
		}

	iLabels[0]->SetImage(svgFile, EMbmIcons_doodlePen);
	iLabels[0]->SetTooltip(_L("Pensize"));

	iLabels[1]->SetImage(svgFile, EMbmIcons_doodlePalette_colored);
	iLabels[1]->SetTooltip(_L("Palette"));

	iLabels[2]->SetImage(svgFile, EMbmIcons_doodleUndo);
	iLabels[2]->SetTooltip(_L("Undo"));

	iLabels[3]->SetImage(svgFile, EMbmIcons_doodleRedo);
	iLabels[3]->SetTooltip(_L("Redo"));
	
	iLabels[4]->SetImage(svgFile, EMbmIcons_doodleSave1);
	iLabels[4]->SetTooltip(_L("Save"));

	iLabels[5]->SetImage(svgFile, EMbmIcons_doodleInfo);
	iLabels[5]->SetTooltip(_L("About"));

	iLabels[6]->SetImage(svgFile, EMbmIcons_doodleSave2);
	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;
	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 == EMainMenuVertical)
			{
			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 ==EMainMenuHorizontal )
			{
			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();
		}
	}
// ---------------------------------------------------------------------------
// CImageEditorDrawControl::SetToolBarStatus()
// Set and get current status : display or hidden.
// ---------------------------------------------------------------------------
//
void CImageEditorDrawControl::SetToolBarStatus()
	{
	if (iFlagDragToolBar)
		{
		iDisplayTool = ETrue;
		iFlagDragToolBar = EFalse;
		}
	if (iMainMenuLayout == EMainMenuVertical)
		{
		TInt leftX = iLabels[0]->Rect().iTl.iX;
		TInt rightX = iLabels[iTotalComponent - 1]->Rect().iBr.iX;
		if (leftX == 0)
			iDisplayTool = ETrue;
		else if (rightX == 0)
			iDisplayTool = EFalse;
		}
	else if (iMainMenuLayout ==EMainMenuHorizontal )
		{
		TInt topY = iLabels[0]->Rect().iTl.iY;
		TInt bottomY = iLabels[iTotalComponent - 1]->Rect().iBr.iY;
		if (topY == 0)
			iDisplayTool = ETrue;
		else if (bottomY == 0)
			iDisplayTool = EFalse;

		}

	}
// ---------------------------------------------------------------------------
// GetParam
// ---------------------------------------------------------------------------
//
TDesC& CImageEditorDrawControl::GetParam()
	{
		LOG(KDrawPluginLogFile, "CImageEditorDrawControl::GetParam()");
		LOGDES(KDrawPluginLogFile, iParam);
	return iParam;
	}

// ---------------------------------------------------------------------------
// SetSystemParameters
// ---------------------------------------------------------------------------
//
void CImageEditorDrawControl::SetSystemParameters(
		const CSystemParameters* aPars)
	{
		LOG(KDrawPluginLogFile, "CImageEditorDrawControl::SetSystemParameters()");
	ASSERT(aPars);
	iSysPars = aPars;
	}

// ---------------------------------------------------------------------------
// HandlePluginCommandL
// ---------------------------------------------------------------------------
//
void CImageEditorDrawControl::HandlePluginCommandL(const TInt aCommand)
	{
		LOG(KDrawPluginLogFile, "CImageEditorDrawControl::HandlePluginCommandL()");

	switch (aCommand)
		{
		case EImageEditorFocusLost:
			{
			if (iTimer)
				{
				iTimer->Cancel();
				}
			break;
			}
		case EPgnSoftkeyIdOk:
			{
			iPopupController->HideInfoPopupNote();
			break;
			}
		case EPgnSoftkeyIdCancel:
			{
			iPopupController->HideInfoPopupNote();
			iEditorView->HandleCommandL(EImageEditorCancelPlugin);
			break;
			}
		case EPgnSoftkeyIdDone:
			// FALLTROUHG
		case EDrawPgnMenuCmdDone:
			{
			iPopupController->HideInfoPopupNote();
			StoreParameters(EFalse, ETrue);
			iEditorView->HandleCommandL(EImageEditorCmdRender);//results Draw call
			iEditorView->HandleCommandL(EImageEditorApplyPlugin);
			break;
			}
		case EDrawPgnMenuCmdResize:
			{
			StoreParameters(ETrue, ETrue);
			iEditorView->HandleCommandL(EImageEditorCmdRender);//results Draw call
			SelectSizeL();
			break;
			}
		case EDrawPgnMenuCmdColor:
			{
			StoreParameters(ETrue, ETrue);
			iEditorView->HandleCommandL(EImageEditorCmdRender);//results Draw call            
			SDrawUtils::LaunchColorSelectionPopupL(iPreview, Rect(), iRgb);
			break;
			}
		case EDrawPgnMenuCmdCancel:
			{
			iReadyToRender = EFalse;
			iEditorView->HandleCommandL(EImageEditorCancelPlugin);
			break;
			}

		case EImageEditorGlobalZoomChanged:
			// FALLTROUGHT
		case EImageEditorGlobalPanChanged:
			{
			RestorePosAndScaleRelScreen();
			StoreTempParams();
			iEditorView->HandleCommandL(EImageEditorCmdRender);
			break;
			}

		case EImageEditorPreScreenModeChange:
			{
			StorePosAndScaleRelImage();
			break;
			}

		case EImageEditorPostScreenModeChange:
			{
			RestorePosAndScaleRelImage();
			ClipPosition();
			StoreTempParams();
			iEditorView->HandleCommandL(EImageEditorCmdRender);
			break;
			}
		default:
			{
			break;
			}
		}
	}

// ---------------------------------------------------------------------------
// GetSoftkeyIndexL
// ---------------------------------------------------------------------------
//
TInt CImageEditorDrawControl::GetSoftkeyIndexL()
	{
		LOG(KDrawPluginLogFile, "CImageEditorDrawControl::GetSoftkeyIndexL()");
	// : Check needed states
	TInt state(2);
	return state;
	}

// ---------------------------------------------------------------------------
// GetContextMenuResourceId
// ---------------------------------------------------------------------------
//
TInt CImageEditorDrawControl::GetContextMenuResourceId()
	{
	return R_TEXT_CONTEXT_MENUBAR;
	}

// ---------------------------------------------------------------------------
// GetDimmedMenuItems
// ---------------------------------------------------------------------------
//
TBitField CImageEditorDrawControl::GetDimmedMenuItems()
	{
		LOG(KDrawPluginLogFile, "CImageEditorDrawControl::GetDimmedMenuItems()");

	TBitField dimmedMenuItems;
	TInt count = iItem->MenuItems().Count();

	if (iDisplayingOkOptionsMenu)
		{
		// Dim the command EImageEditorCancelPlugin
		for (TInt i = 0; i < count; i++)
			{
			// get the menu item id
			TInt menuItem = iItem->MenuItems().At(i).iCommandId;
			if (menuItem == EDrawPgnMenuCmdCancel)
				{
				dimmedMenuItems.SetBit(i);
				}
			}
		iDisplayingOkOptionsMenu = EFalse;
		}

	for (TInt i = 0; i < count; i++)
		{
		// get the menu item id
		TInt menuItem = iItem->MenuItems().At(i).iCommandId;
		if (menuItem == EDrawPgnMenuCmdMax)
			{
			dimmedMenuItems.SetBit(i);
			}
		}
	return dimmedMenuItems;
	}

// ---------------------------------------------------------------------------
// GetNaviPaneTextL
// ---------------------------------------------------------------------------
//
TPtrC CImageEditorDrawControl::GetNaviPaneTextL(
		TBool& aLeftNaviPaneScrollButtonVisibile,
		TBool& aRightNaviPaneScrollButtonVisible)
	{
		LOG(KDrawPluginLogFile, "CImageEditorDrawControl::GetNaviPaneTextL()");

	aLeftNaviPaneScrollButtonVisibile = EFalse;
	aRightNaviPaneScrollButtonVisible = EFalse;
	return *iNaviPaneText;
	}

// ---------------------------------------------------------------------------
// Draw
// ---------------------------------------------------------------------------
//
void CImageEditorDrawControl::Draw(const TRect& aRect) const
	{
	CWindowGc & gc = SystemGc();
	gc.SetBrushColor(KRgbBlack);
	gc.Clear(aRect);

	TRect ImageRect(iSysPars->VisibleImageRectPrev());
	CPreviewControlBase::DrawPreviewImage(aRect);
	gc.SetClippingRect(TRect(TPoint(ImageRect.iTl.iX, ImageRect.iTl.iY
			+ iStatuspaneHeight), ImageRect.Size()));

	if (iPaths.Count() > 0)
		{
		//        ASSERT( iSysPars ); 
		TInt count = iPaths.Count();
		for (TInt i(0); i < iPaths.Count(); ++i)
			{
			CDrawPath* path = iPaths[i];
			CArrayFix<TPoint>* pathPoints = path->ItemArray();
			gc.SetPenStyle(CGraphicsContext::ESolidPen);
			gc.SetPenColor(path->Color());
			gc.SetPenSize(ScaledLineSize(path->Size()));
			gc.DrawPolyLine(pathPoints);
			}
		}
	}

// ---------------------------------------------------------------------------
// NaviDown
// ---------------------------------------------------------------------------
//
void CImageEditorDrawControl::NaviDown()
	{
		LOG(KDrawPluginLogFile, "CImageEditorDrawControl::NaviDown()");
	}

// ---------------------------------------------------------------------------
// NaviUp
// ---------------------------------------------------------------------------
//
void CImageEditorDrawControl::NaviUp()
	{
		LOG(KDrawPluginLogFile, "CImageEditorDrawControl::NaviUp()");
	}

// ---------------------------------------------------------------------------
// NaviRight
// ---------------------------------------------------------------------------
//
void CImageEditorDrawControl::NaviRight()
	{
		LOG(KDrawPluginLogFile, "CImageEditorDrawControl::NaviRight()");
	}

// ---------------------------------------------------------------------------
// NaviLeft
// ---------------------------------------------------------------------------
//
void CImageEditorDrawControl::NaviLeft()
	{
		LOG(KDrawPluginLogFile, "CImageEditorDrawControl::NaviLeft()");
	}

// ---------------------------------------------------------------------------
// SelectSizeL
// ---------------------------------------------------------------------------
//
void CImageEditorDrawControl::SelectSizeL()
	{
		LOG(KDrawPluginLogFile, "CImageEditorDrawControl::SelectSizeL()");
	// Symmetric line width / height
	TInt size(iSize.iWidth);
	CSelectionDialog::RunDlgLD(iPreview, Rect(), size, iRgb,
			iSysPars->VisibleImageRectPrev());
	iSize = TSize(size, size);
	}

// ---------------------------------------------------------------------------
// StoreTempParams
// ---------------------------------------------------------------------------
//
void CImageEditorDrawControl::StoreTempParams()
	{
		LOG(KDrawPluginLogFile, "CImageEditorDrawControl::StoreTempParams("
				""
				")");
	}

// ---------------------------------------------------------------------------
// RestoreTempParams
// ---------------------------------------------------------------------------
//
void CImageEditorDrawControl::RestoreTempParams()
	{
		LOG(KDrawPluginLogFile, "CImageEditorDrawControl::RestoreTempParams()");
	}

// ---------------------------------------------------------------------------
// GetHelpContext
// ---------------------------------------------------------------------------
//
void CImageEditorDrawControl::GetHelpContext(TCoeHelpContext& aContext) const
	{
		LOG(KDrawPluginLogFile, "CImageEditorDrawControl::GetHelpContext()");

	aContext.iMajor = TUid::Uid(UID_IMAGE_EDITOR);
	aContext.iContext = KSIE_HLP_EDIT_DRAW;
	}

// ---------------------------------------------------------------------------
// PrepareL
// ---------------------------------------------------------------------------
//
void CImageEditorDrawControl::PrepareL()
	{
		LOG(KDrawPluginLogFile, "CImageEditorDrawControl::PrepareL()");

	//	Get current view port
	TRect rect = iSysPars->VisibleImageRectPrev();

	iReadyToRender = ETrue;

	iEditorView->HandleCommandL(EImageEditorCmdRender);
	}

// ---------------------------------------------------------------------------
// LoadIndicatorL
// ---------------------------------------------------------------------------
//
void CImageEditorDrawControl::LoadIndicatorL(TInt aBitmapInd, TInt aMaskInd)
	{
		LOG(KDrawPluginLogFile, "CImageEditorDrawControl::LoadIndicatorL()");

	//  Delete old indicator
	delete iIndicator;
	iIndicator = 0;
	delete iIndicatorMask;
	iIndicatorMask = 0;

	//  Load new indicator
	SDrawUtils::GetIndicatorBitmapL(iIndicator, iIndicatorMask, aBitmapInd,
			aMaskInd);
	}

// ---------------------------------------------------------------------------
// ComputeIndicatorPosition
// ---------------------------------------------------------------------------
//
TPoint CImageEditorDrawControl::ComputeIndicatorPosition() const
	{
	TRect vprect = iSysPars->VisibleImageRect();
	TRect vpprect = iSysPars->VisibleImageRectPrev();

	TInt x(0);
	TInt y(0);
	// check if there is no indicator
	if (!iIndicator)
		{
		return TPoint(x, y);
		}

	y = ((iY - vprect.iTl.iY) * vpprect.Height()) / vprect.Height();
	y += vpprect.iTl.iY;

	x = ((iX - vprect.iTl.iX) * vpprect.Width()) / vprect.Width();
	x += vpprect.iTl.iX;

	return TPoint(x, y);
	}

// ---------------------------------------------------------------------------
// IsReadyToRender
// ---------------------------------------------------------------------------
//
TBool CImageEditorDrawControl::IsReadyToRender() const
	{
		LOG(KDrawPluginLogFile, "CImageEditorDrawControl::IsReadyToRender()");
	return iReadyToRender;
	}

// ---------------------------------------------------------------------------
// StoreParameters
// ---------------------------------------------------------------------------
//
void CImageEditorDrawControl::StoreParameters(TBool aLastItem, TBool aDone)
	{
		LOG(KDrawPluginLogFile, "CImageEditorDrawControl::StoreParameters()");
	RDebug::Print(_L("CImageEditorDrawControl::StoreParameters color[%d]"),
	iRgb.Internal());

	iParam.Copy(_L("x "));
	iParam.AppendNum(iX);
	iParam.Append(_L(" y "));
	iParam.AppendNum(iY);
	if (aLastItem)
		{
		iParam.Append(_L(" size "));
		iParam.AppendNum(iSize.iHeight);
		iParam.Append(_L(" color "));
		iParam.AppendNum(iRgb.Value());
		iParam.Append(_L(" lastItem "));
		}

	if (aDone)
		{
		iParam.Zero();
		iParam.Append(_L("done"));
		}
	if (iUndo)
		{
		iParam.Zero();
		iParam.Append(_L("Undo"));
		}
	if (iRedo)
		{
		iParam.Zero();
		iParam.Append(_L("redone"));
		}
	}

// ---------------------------------------------------------------------------
// TimerCallBack
// ---------------------------------------------------------------------------
//
void CImageEditorDrawControl::TimerCallBack()
	{
		LOG(KDrawPluginLogFile, "CImageEditorDrawControl::TimerCallBack()");

	if (iTickCount > KDefaultFastKeyTimerMultiplyThresholdInTicks)
		{
		iNaviStepMultiplier = KDefaultBigNavigationStepMultiplier;
		}
	else
		{
		iTickCount++;
		}

	if (iKeyCode)
		{

		switch (iKeyCode)
			{
			case 1:
				{
				NaviUp();
				break;
				}
			case 2:
				{
				NaviDown();
				break;
				}
			case 3:
				{
				NaviLeft();
				break;
				}
			case 4:
				{
				NaviRight();
				break;
				}
			default:
				break;
			}
			//StoreParameters();
			TRAP_IGNORE(iEditorView->HandleCommandL(EImageEditorCmdRender));
		iTimer->Call(KWait);
		}
	}

// ---------------------------------------------------------------------------
// StorePosAndScaleRelScreen
// ---------------------------------------------------------------------------
//
void CImageEditorDrawControl::StorePosAndScaleRelScreen()
	{
		LOG(KDrawPluginLogFile,
				"CImageEditorClipartControl::StorePosAndScaleRelScreen()");
	iParam.Copy(_L("nop"));
	}

// ---------------------------------------------------------------------------
// ?description_if_needed
// ---------------------------------------------------------------------------
//
void CImageEditorDrawControl::RestorePosAndScaleRelScreen()
	{
		LOG(KDrawPluginLogFile,
				"CImageEditorClipartControl::RestorePosAndScaleRelScreen()");
	}

// ---------------------------------------------------------------------------
// StorePosAndScaleRelImage
// ---------------------------------------------------------------------------
//
void CImageEditorDrawControl::StorePosAndScaleRelImage()
	{
	TReal relscale = iSysPars->RelScale();
		LOGFMT(KDrawPluginLogFile,
				"CImageEditorClipartControl::StorePosAndScaleRelImage():%g",
				relscale);
	}

// ---------------------------------------------------------------------------
// RestorePosAndScaleRelImage
// ---------------------------------------------------------------------------
//
void CImageEditorDrawControl::RestorePosAndScaleRelImage()
	{
	TReal relscale = iSysPars->RelScale();
		LOGFMT(KDrawPluginLogFile,
				"CImageEditorClipartControl::RestorePosAndScaleRelImage():%g",
				relscale);
	}

// ---------------------------------------------------------------------------
// ClipPosition
// ---------------------------------------------------------------------------
//
void CImageEditorDrawControl::ClipPosition()
	{
	if (iX < iSysPars->VisibleImageRect().iTl.iX)
		{
		iX = iSysPars->VisibleImageRect().iTl.iX;
		}
	else if (iX > iSysPars->VisibleImageRect().iBr.iX)
		{
		iX = iSysPars->VisibleImageRect().iBr.iX;
		}

	if (iY < iSysPars->VisibleImageRect().iTl.iY)
		{
		iY = iSysPars->VisibleImageRect().iTl.iY;
		}
	else if (iY > iSysPars->VisibleImageRect().iBr.iY)
		{
		iY = iSysPars->VisibleImageRect().iBr.iY;
		}
	}

// ---------------------------------------------------------------------------
// HandlePointerEventL
// ---------------------------------------------------------------------------
//
void CImageEditorDrawControl::HandlePointerEventL(
		const TPointerEvent &aPointerEvent)
	{
	SetToolBarStatus();
	RDebug::Print(_L("CImageEditorDrawControl::HandlePointerEventL pen[%d]"),
	AknLayoutUtils::PenEnabled());
	if (iRollflag)
		return;
	if (AknLayoutUtils::PenEnabled() && !Busy())
		{
		RDebug::Print(_L("CImageEditorDrawControl::iType [%d]"),
		aPointerEvent.iType);
		TBool lastItem(EFalse);
		TPoint point = aPointerEvent.iPosition;

		switch (aPointerEvent.iType)
			{
			case TPointerEvent::EButton1Down:
				{

				iButtonDownPoint = point;
				iLastPointEventType = EFalse;
				CCoeControl::HandlePointerEventL(aPointerEvent);
                 //Handle Drag tool bar event.
				if (iLoopMenuRect.Contains(point) && !iCustomComponetClick
						&& iDisplayTool)

					{
					iPointStartInLoopRect = ETrue;
					if (iDragIsStart)
						{
						iAnimationAO->Cancel();
						iDragIsStart = EFalse;
						}

					}
				//Doodle event.
				else if ((!iLoopMenuRect.Contains(point)
						&& !iCustomComponetClick && iDisplayTool)
						|| (!iDisplayTool && !iCustomComponetClick))
					{
					iPointStartInLoopRect = EFalse;
					//System dispose
					iReadyToRender = EFalse;
					CDrawPath* lastPath = CDrawPath::NewL();
					CleanupStack::PushL(lastPath);
					lastPath->SetColor(iRgb);
					lastPath->SetSize(iSize);
					SetPositionOnImage(aPointerEvent.iPosition);
					lastPath->AddItemL(aPointerEvent.iPosition);
					iPaths.AppendL(lastPath);
					CleanupStack::Pop(lastPath);
					iCanRedo = EFalse;
					iUndoPaths.ResetAndDestroy();
					}
				}
				break;
			case TPointerEvent::EButton1Up:
				{
				//		System dispose
				iReadyToRender = ETrue;
				iCustomComponetClick = EFalse;
				lastItem = ETrue;
				CCoeControl::HandlePointerEventL(aPointerEvent);
				HandleMainMenuButtonUp(point);
				DrawNow();

				}
				break;
			case TPointerEvent::EDrag:
				{
				CCoeControl::HandlePointerEventL(aPointerEvent);
			    //Mark last event use for custompoent.	
				iLastPointEventType = ETrue;

				if ((iDisplayTool && iPaths.Count() && !iCustomComponetClick
						&& !iPointStartInLoopRect) || (!iDisplayTool
						&& iPaths.Count() && !iCustomComponetClick))
					{
					iCanRedo = EFalse;
					iUndoPaths.ResetAndDestroy();
					CDrawPath* path = iPaths[iPaths.Count() - 1];
					// store current position for next round
					iPointerPosition = aPointerEvent.iPosition;
					SetPositionOnImage(aPointerEvent.iPosition);
					path->AddItemL(aPointerEvent.iPosition);
					}
				//Drag customcomponent event
				if (iCustomComponetClick)
					{
					TPoint con(aPointerEvent.iPosition.iX - 25,
							aPointerEvent.iPosition.iY - 25);
					iCustomComponet->SetExtent(con, TSize(50, 50));
					DrawNow();
					}
                //Drag tool bar event
				if (iDisplayTool && iPointStartInLoopRect)

					{
					iFlagDragToolBar = ETrue;
					HandleMainMenuButtonDrag(point);
					}
				}
				break;
			default:

				break;

			}

		//System dispose
		if ((!iPointStartInLoopRect && iDisplayTool) || !iDisplayTool)
			{
			if (!(iCustomComponet->Rect().Contains(aPointerEvent.iPosition)))
				{
				StoreParameters(lastItem, EFalse);
				iEditorView->HandleCommandL(EImageEditorCmdRender);//results Draw call
				}
			}
		}

	}

// ---------------------------------------------------------------------------
// CImageEditorDrawControl::HandleMainMenuButtonUp()
//
// ---------------------------------------------------------------------------
//
void CImageEditorDrawControl::HandleMainMenuButtonUp(TPoint aPoint)
	{
	if (iMainMenuLayout == EMainMenuVertical)
		{
		if (iDragIsStart)
			{
			//Drag event is end (Except activating animation effect).
			iDragIsStart = EFalse;

			if (Abs(iDragPrePoint.iX - aPoint.iX) > 1)
				{
				//Animation effect is activated
				iDragIsStart = ETrue;
				iStartSpeed = aPoint.iX - iDragPrePoint.iX;
				iAnimationAO->StartL(0);
				}
			}
		}
	else if (iMainMenuLayout ==EMainMenuHorizontal )
		{
		if (iDragIsStart)
			{
			//Drag event is end (Except activating animation effect).
			iDragIsStart = EFalse;

			if (Abs(iDragPrePoint.iY - aPoint.iY) > 1)
				{
				//Animation effect is activated
				iDragIsStart = ETrue;
				iStartSpeed = aPoint.iY - iDragPrePoint.iY;
				iAnimationAO->StartL(0);
				}
			}
		}
	}

// ---------------------------------------------------------------------------
// HandleMainMenuButtonDrag
// ---------------------------------------------------------------------------
//
void CImageEditorDrawControl::HandleMainMenuButtonDrag(TPoint aPoint)
	{
	if (iMainMenuLayout == EMainMenuVertical)
		{
		if (iPointStartInLoopRect && !iDragIsStart && Abs(aPoint.iX
				- iButtonDownPoint.iX) >= DRAG_LENGTH)
			{
			iDragIsStart = ETrue;
			iDragStartPoint = aPoint;

			for (TInt i = 0; i < iTotalComponent; i++)
				{
				if (iLabels[i]->Rect().Contains(iButtonDownPoint))
					{
					iLabels[i]->LabelIsMoving();
					}
				}
			}

		if (iDragIsStart)
			{
			iDragPrePoint = iDragUpPoint;
			iDragUpPoint = aPoint;
			iDragOffset = aPoint.iX - iDragStartPoint.iX;
			iDragStartPoint = aPoint;

			CalculateEffectiveOffset();
			SizeChanged();
			}
		}
	else if (iMainMenuLayout ==EMainMenuHorizontal )
		{
		if (iPointStartInLoopRect && !iDragIsStart && Abs(aPoint.iY
				- iButtonDownPoint.iY) >= DRAG_LENGTH)
			{
			iDragIsStart = ETrue;
			iDragStartPoint = aPoint;

			for (TInt i = 0; i < iTotalComponent; i++)
				{
				if (iLabels[i]->Rect().Contains(iButtonDownPoint))
					{
					iLabels[i]->LabelIsMoving();
					}
				}
			}

		if (iDragIsStart)
			{
			iDragPrePoint = iDragUpPoint;
			iDragUpPoint = aPoint;
			iDragOffset = aPoint.iY - iDragStartPoint.iY;
			iDragStartPoint = aPoint;

			CalculateEffectiveOffset();
			SizeChanged();
			}
		}
	}

// ---------------------------------------------------------------------------
// UndoDrawPath
// ---------------------------------------------------------------------------
//   
void CImageEditorDrawControl::UndoDrawPath()
	{
	if (iPaths.Count())
		{
		iUndoPaths.Append(iPaths[iPaths.Count() - 1]);
		iPaths.Remove(iPaths.Count() - 1);
		iCanRedo = ETrue;
		}
	}

// ---------------------------------------------------------------------------
// RedoDrawPath
// ---------------------------------------------------------------------------
//
void CImageEditorDrawControl::RedoDrawPath()
	{
	if (iUndoPaths.Count())
		{
		iPaths.Append(iUndoPaths[iUndoPaths.Count() - 1]);
		iUndoPaths.Remove(iUndoPaths.Count() - 1);
		}
	}

// ---------------------------------------------------------------------------
// HandlePointerNotify
// ---------------------------------------------------------------------------
//
void CImageEditorDrawControl::HandlePointerNotify(CCoeControl* aComponent)
	{
	//pen size
	if (iLabels[0] == dynamic_cast<CImageLabel*> (aComponent))
		{
		MakeVisibleLable(EFalse);
		SelectSizeL();
		MakeVisibleLable(ETrue);
		}
	//pen color
	else if (iLabels[1] == dynamic_cast<CImageLabel*> (aComponent))
		{
		MakeVisibleLable(EFalse);
		SDrawUtils::LaunchColorSelectionPopupL(iPreview, Rect(), iRgb);
		MakeVisibleLable(ETrue);
		}
	//undo
	else if (iLabels[2] == dynamic_cast<CImageLabel*> (aComponent))
		{
		UndoDrawPath();
		iUndo = ETrue;
		StoreParameters(EFalse, EFalse);
		iEditorView->HandleCommandL(EImageEditorCmdRender);
		iUndo = EFalse;
		}
	//save and quit
	else if (iLabels[3] == dynamic_cast<CImageLabel*> (aComponent))
		{
		iRedo = ETrue;
		RedoDrawPath();
		StoreParameters(EFalse, EFalse);
		iEditorView->HandleCommandL(EImageEditorCmdRender);
		iRedo = EFalse;
		}
	else if (iLabels[4] == dynamic_cast<CImageLabel*> (aComponent))
		{
		iPopupController->HideInfoPopupNote();
		StoreParameters(EFalse, ETrue);
		iEditorView->HandleCommandL(EImageEditorApplyPlugin);
		}
	else if (iLabels[5] == dynamic_cast<CImageLabel*> (aComponent))
		{
        iEditorView->HandleCommandL(EImageEditorMenuCmdHelp);
		}
	else if (iLabels[6] == dynamic_cast<CImageLabel*> (aComponent))
		{

		}
	else if (iCustomComponet == dynamic_cast<CCustomerComponet*> (aComponent))
		{
		if (iCustomComponet->GetButtonType())
			{
			iCustomComponetClick = ETrue;
			}

		if ((!iCustomComponet->GetButtonType()) && (!iLastPointEventType))
			{
			StartTheAnimation();

			}
		}

	}

// ---------------------------------------------------------------------------
// SetPositionOnImage
// ---------------------------------------------------------------------------
//    
void CImageEditorDrawControl::SetPositionOnImage(TPoint aPointedPosition)
	{
	ASSERT(iSysPars);
	// Get system parameters
	TRect visibleImageRect(iSysPars->VisibleImageRect());
	TRect visibleImageRectPrev(iSysPars->VisibleImageRectPrev());

	TInt xPosFactorDivider(visibleImageRectPrev.Width());
	TInt yPosFactorDivider(visibleImageRectPrev.Height());

		LOGFMT2(KDrawPluginLogFile, "CImageEditorDrawControl::vir w:%d h:%d",
				visibleImageRect.Width(), visibleImageRect.Height());
		LOGFMT2(KDrawPluginLogFile, "CImageEditorDrawControl::virp w:%d h:%d",
				visibleImageRectPrev.Width(), visibleImageRectPrev.Height());

	// Dividing by zero will cause panic -> check
	if (xPosFactorDivider == 0 || yPosFactorDivider == 0)
		{
		//	Set default position
		iX = (visibleImageRect.iTl.iX + visibleImageRect.iBr.iX) / 2;
		iY = (visibleImageRect.iTl.iY + visibleImageRect.iBr.iY) / 2;
		}
	else
		{
		// Calculate relative position on the screen
		TReal xPositionFactor(TReal(aPointedPosition.iX
				- visibleImageRectPrev.iTl.iX) / xPosFactorDivider);
		//
		//		TReal yPositionFactor(TReal(aPointedPosition.iY - iStatuspaneHeight
		//				- visibleImageRectPrev.iTl.iY) / yPosFactorDivider);
		TReal yPositionFactor(TReal(aPointedPosition.iY
				- visibleImageRectPrev.iTl.iY) / yPosFactorDivider);
			LOGFMT2(KDrawPluginLogFile, "CImageEditorDrawControl::pfx:%g pfy:%g",
					xPositionFactor, yPositionFactor);
		// Calculate position on visible image		

		iX = visibleImageRect.iTl.iX + visibleImageRect.Width()
				* xPositionFactor + 0.5;

		iY = visibleImageRect.iTl.iY + visibleImageRect.Height()
				* yPositionFactor + 0.5;
		}

		LOGFMT4(KDrawPluginLogFile,
				"CImageEditorDrawControl::Draw x:%d iX:%d y:%d iY:%d",
				aPointedPosition.iX, iX, aPointedPosition.iY, iY);
	// Check that not out of bounds    
	//ClipPosition();          
	}

// ---------------------------------------------------------------------------
// GetPositionOnView
// ---------------------------------------------------------------------------
// 
TPoint CImageEditorDrawControl::GetPositionOnView()
	{
	ASSERT(iSysPars);
	// Get system parameters 
	TRect visibleImageRect(iSysPars->VisibleImageRect());
	TRect visibleImageRectPrev(iSysPars->VisibleImageRectPrev());

	TInt xPosFactorDivider(visibleImageRectPrev.Width());
	TInt yPosFactorDivider(visibleImageRectPrev.Height());

	// Calculate relative position on the screen
	TReal xPositionFactor(TReal(iX + visibleImageRectPrev.iTl.iX)
			/ xPosFactorDivider);

	TReal yPositionFactor(TReal(iY + visibleImageRectPrev.iTl.iY)
			/ yPosFactorDivider);

		LOGFMT2(KDrawPluginLogFile,
				"CImageEditorDrawControl::GetPositionOnView xf:%g yf:%g",
				xPositionFactor, yPositionFactor);

		LOGFMT2(KDrawPluginLogFile,
				"CImageEditorDrawControl::GetPositionOnView xf:%d yf:%d",
				xPosFactorDivider, yPosFactorDivider);

		LOGFMT2(KDrawPluginLogFile,
				"CImageEditorDrawControl::GetPositionOnView w:%d h:%d", iX, iY);

	TInt xPosition(iX + visibleImageRectPrev.iTl.iX);
	TInt yPosition(iY + visibleImageRectPrev.iTl.iY);

		LOGFMT3(KDrawPluginLogFile,
				"CImageEditorDrawControl::GetPositionOnView w:%d h:%d S:%g",
				xPosition, yPosition, iSysPars->RelScale());

	return TPoint(xPosition, yPosition);
	}

// ---------------------------------------------------------------------------
// ShowTooltip
// ---------------------------------------------------------------------------
//    
void CImageEditorDrawControl::ShowTooltip()
	{
	iPopupController->HideInfoPopupNote();

	TPoint iconPosition = ComputeIndicatorPosition();
	TRect iconRect(iconPosition.iX, iconPosition.iY, iconPosition.iX,
			iconPosition.iY);
	}

// ---------------------------------------------------------------------------
// ScaledLineSize
// ---------------------------------------------------------------------------
//    
TSize CImageEditorDrawControl::ScaledLineSize(TSize aOriginalSize) const
	{
	TInt sizew(aOriginalSize.iWidth * iSysPars->RelScale() + 0.5);
	TInt sizeh(aOriginalSize.iHeight * iSysPars->RelScale() + 0.5);
	if (sizew < 1)
		{
		sizew++;
		}
	if (sizeh < 1)
		{
		sizeh++;
		}

		LOGFMT3(KDrawPluginLogFile,
				"CImageEditorDrawControl::ScaledLineSize w:%d h:%d S:%g", sizew,
				sizeh, iSysPars->RelScale());
	return TSize(sizew, sizeh);
	}

// ---------------------------------------------------------------------------
// CountComponentControls
// ---------------------------------------------------------------------------
//  
TInt CImageEditorDrawControl::CountComponentControls() const
	{
	return iTotalComponent + 1;
	}

// ---------------------------------------------------------------------------
// ComponentControl
// ---------------------------------------------------------------------------
//  
CCoeControl* CImageEditorDrawControl::ComponentControl(TInt aIndex) const
	{
	switch (aIndex)
		{
		case 7:
			return iCustomComponet;
		case 0:
			return iLabels[0];
		case 1:
			return iLabels[1];
		case 2:
			return iLabels[2];
		case 3:
			return iLabels[3];
		case 4:
			return iLabels[4];
		case 5:
			return iLabels[5];
		case 6:
			return iLabels[6];
		default:
			return NULL;
		}
	return NULL;
	}

// ---------------------------------------------------------------------------
// Notify
// ---------------------------------------------------------------------------
//  
void CImageEditorDrawControl::Notify()
	{
	if (iStartSpeed > 0)
		{
		iStartSpeed -= 2;
		if (iStartSpeed <= 0)
			{
			iStartSpeed = 0;
			iDragIsStart = EFalse;
			iAnimationAO->Cancel();
			}
		}
	else if (iStartSpeed < 0)
		{
		iStartSpeed += 2;
		if (iStartSpeed >= 0)
			{
			iStartSpeed = 0;
			iDragIsStart = EFalse;
			iAnimationAO->Cancel();
			}
		}
	else
		{
		iDragIsStart = EFalse;
		iAnimationAO->Cancel();
		}

	iDragOffset += iStartSpeed;
	CalculateEffectiveOffset();
	SizeChanged();
	}

// ---------------------------------------------------------------------------
// Roll 
// ---------------------------------------------------------------------------
//  
void CImageEditorDrawControl::Roll()
	{
	SetToolBarStatus();

	TInt offset = 0;
	iRollflag = ETrue;
	if (iDisplayTool)
		iRollDirection = EFalse;
	else
		iRollDirection = ETrue;

	if (iRollDirection)
		{
		offset = 4;
		}
	else
		{
		offset = -4;
		}

	if (iMainMenuLayout == EMainMenuVertical)
		{
		for (TInt i = 0; i < iLabels.Count(); i++)
			{
			TInt x = iLabels[i]->Rect().iTl.iX;
			iLabels[i]->SetPosition(TPoint(x + offset, iLoopMenuRect.iTl.iY));
			iLabels[i]->ResetControl();
			}
		if (iLabels[0]->Rect().iTl.iX == 0
				|| iLabels[iLabels.Count() - 1]->Rect().iBr.iX == 0)
			iRollflag = EFalse;
		}
	else if (iMainMenuLayout == EMainMenuHorizontal)
		{
		for (TInt i = 0; i < iLabels.Count(); i++)
			{
			TInt y = iLabels[i]->Rect().iTl.iY;
			iLabels[i]->SetPosition(TPoint(iLoopMenuRect.iTl.iX, y + offset));
			iLabels[i]->ResetControl();
			}
		if (iLabels[0]->Rect().iTl.iY == 0
				|| iLabels[iLabels.Count() - 1]->Rect().iBr.iY == 0)
			iRollflag = EFalse;
		}

	DrawNow();

	if (!iRollflag)
		{
		iRollAo->Cancel();
		}
	}

// ---------------------------------------------------------------------------
// CalculateEffectiveOffset
// ---------------------------------------------------------------------------
//  
void CImageEditorDrawControl::CalculateEffectiveOffset()
	{
	if (iMainMenuLayout == EMainMenuVertical)
		{
		TInt leftX = iLabels[0]->Rect().iTl.iX;
		TInt rightX = iLabels[iTotalComponent - 1]->Rect().iBr.iX;
		TInt offset = iDragOffset;
		if (leftX + offset > 0)
			{
			iDragOffset = Abs(leftX);
			}

		if (rightX + offset < 360)
			{
			iDragOffset = -(rightX - 360);
			}
		}
	else if (iMainMenuLayout ==EMainMenuHorizontal )
		{
		TInt topY = iLabels[0]->Rect().iTl.iY;
		TInt bottomY = iLabels[iTotalComponent - 1]->Rect().iBr.iY;
		TInt offset = iDragOffset;
		if (topY + offset > 0)
			{
			iDragOffset = Abs(topY);
			}

		if (bottomY + offset < 360)
			{
			iDragOffset = -(bottomY - 360);
			}
		}
	}

// ---------------------------------------------------------------------------
// MakeVisibleLable
// ---------------------------------------------------------------------------
//  
void CImageEditorDrawControl::MakeVisibleLable(TBool aFlag)
	{
	if (aFlag)
		{
		for (int i = 0; i < iTotalComponent; i++)
			{
			iLabels[i]->MakeVisible(ETrue);
			}
		}
	else
		{
		for (int i = 0; i < iTotalComponent; i++)
			{
			iLabels[i]->MakeVisible(EFalse);
			}
		}
	}

// ---------------------------------------------------------------------------
// StartTheAnimation
// ---------------------------------------------------------------------------
//  
void CImageEditorDrawControl::StartTheAnimation()
	{
	iRollAo->StartL(0);
	}

// End of File
