/*

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

// Log file

_LIT(KDrawPluginLogFile,"drawplugin.log");

//  CONSTANTS

const TInt KWait			    	= 1;

const TInt KMainTextIndex           = 0;

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

// NewL

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

//

CImageEditorDrawControl* CImageEditorDrawControl::NewL(

	const TRect& aRect,

	CCoeControl* aParent )

    {

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

    CImageEditorDrawControl * self = new (ELeave) CImageEditorDrawControl;

    CleanupStack::PushL (self);

    self->ConstructL (aRect, aParent);

    CleanupStack::Pop ();   // self

    return self;

    }

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

// CImageEditorDrawControl

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

//

CImageEditorDrawControl::CImageEditorDrawControl() : 

iTickCount(0),

iNaviStepMultiplier(KDefaultSmallNavigationStepMultiplier),

iDisplayingOkOptionsMenu(EFalse),

iReadyToRender(EFalse),

iResLoader( *ControlEnv() )

{}

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

// ~CImageEditorDrawControl()

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

//

CImageEditorDrawControl::~CImageEditorDrawControl()

    {

    LOG(KDrawPluginLogFile, 

            "CImageEditorDrawControl::~CImageEditorDrawControl()");    

    delete iTimer;

    delete iIndicator;

    delete iIndicatorMask;

	delete iPopupController;

	delete iTooltipResize;

	iPaths.ResetAndDestroy();

    delete iNaviPaneText;	

	iResLoader.Close();

    }

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

// ConstructL

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

//

void CImageEditorDrawControl::ConstructL(

	const TRect& /*aRect*/, CCoeControl* aParent )

    {

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

	//	Set parent window

	SetContainerWindowL(*aParent);

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

    EnableDragEvents();

	//	Activate control

    ActivateL();

    }

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

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

    {

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

    }

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

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

			//StoreParameters();

            StoreTempParams();

	    	iEditorView->HandleCommandL (EImageEditorCmdRender);

			//DrawNow();

	        break;

            }

        case EImageEditorPreScreenModeChange:

            {

			StorePosAndScaleRelImage();

        	break;

            }

        case EImageEditorPostScreenModeChange:

            {

			RestorePosAndScaleRelImage();

			ClipPosition();

			//StoreParameters();

            StoreTempParams();

	    	iEditorView->HandleCommandL (EImageEditorCmdRender);

			//DrawNow();

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

    if( IsReadyToRender() )

        {

        CPreviewControlBase::DrawPreviewImage(aRect);

        }

    if( iPaths.Count() )

        {

        ASSERT( iSysPars ); 

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

            }

        }