/*

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

* Crop plugin's control class.

*

*/

//  INCLUDES

#include <fbs.h>

#include <badesca.h>

#include <eikenv.h>

#include <ImageEditorUI.mbg>

#include <aknview.h>

#include <aknutils.h>

#include <AknInfoPopupNoteController.h> 

#include <crop.rsg> 

#include <bautils.h> 

#include <ConeResLoader.h> 

#include <StringLoader.h>

#include <AknIconUtils.h>

#ifdef RD_TACTILE_FEEDBACK 

#include <touchfeedback.h>

#endif /* RD_TACTILE_FEEDBACK  */

#include "ImageEditorUI.hrh"

#include "ImageEditorPluginBase.hrh"

#include "PluginInfo.h"

#include "DrawUtils.h"

#include "SystemParameters.h"

#include "JpTimer.h"

#include "ImageEditorUIDefs.h" 

#include "iepb.h"

#include "ImageEditorCropControl.h"

#include "ImageEditorError.h"

// debug log

#include "imageeditordebugutils.h"

_LIT(KCropPluginLogFile,"CropPlugin.log");

// Resource file name

_LIT (KPgnResourceFile, "crop.rsc"); 

// Separator to navi pane text

_LIT( KCropNaviTextSeparator, "x" );

//  CONSTANTS

const float KParamStep              = 0.005F;

const float KMinCropRelDistFrac     = 0.01F;

const float KCursorScalingFactor    = 0.7F;

const TInt  KMaxCropAbsoluteMin     = 75;

const TInt  KMinSourceSize          = 75;

//const TInt  KStatusPaneTextMoveIndex = 1;

const TInt  KStatusPaneTextAreaIndex = 2;

// Default value from CPreviewControlBase not used

const TInt KCropFastKeyTimerDelayInMicroseconds = 1000;

//  Used fixed point resolution for scales

//const TInt KScaleBits = 12;

//=============================================================================

CImageEditorCropControl * CImageEditorCropControl::NewL (

    const TRect& aRect,

    CCoeControl* aParent

    )

{

    LOG(KCropPluginLogFile, "CImageEditorCropControl::NewL()");

    CImageEditorCropControl * self = new (ELeave) CImageEditorCropControl;

    CleanupStack::PushL (self);

    self->ConstructL (aRect, aParent);

    CleanupStack::Pop ();   // self

    return self;

}

//=============================================================================

TInt CImageEditorCropControl::DancingAntsCallback (TAny * aPtr)

{

    ((CImageEditorCropControl *)aPtr)->OnDancingAntsCallBack();

    return KErrNone;

}

//=============================================================================

TInt CImageEditorCropControl::FastKeyCallback (TAny * aPtr)

{

    TRAPD( err, ((CImageEditorCropControl *)aPtr)->OnFastKeyCallBackL() );

    return err;

}

//=============================================================================

CImageEditorCropControl::CImageEditorCropControl () :

iState (ECropStateFirst),

iFastKeyTimerState (ETimerInactive),

iHandleEventKeys (ETrue),

iTickCount (0),

iNaviStepMultiplier (KDefaultSmallNavigationStepMultiplier),

iReadyToRender(EFalse)

{

}

//=============================================================================

CImageEditorCropControl::~CImageEditorCropControl ()

{

    iEditorView = NULL;

    iItem = NULL;

    iSysPars = NULL;

    delete iCrossHair;

    delete iCrossHairMask;

    delete iSecondaryCrossHair;

    delete iSecondaryCrossHairMask;

    if (iTimer)

    {

        iTimer->Cancel();

    }

    delete iTimer;

    delete iPopupController;

    delete iTooltipResize;

    delete iTooltipMove;

#ifdef DOUBLE_BUFFERED_CROP    

    delete iBufBitmap;

#endif // DOUBLE_BUFFERED_CROP

}

//=============================================================================

void CImageEditorCropControl::ConstructL (

    const TRect& /*aRect*/,

    CCoeControl* aParent

    )

{

    LOG(KCropPluginLogFile, "CImageEditorCropControl::ConstructL()");

    //    Set parent window

    SetContainerWindowL (*aParent);

    // Load MAIN CROSSHAIR image

    SDrawUtils::GetIndicatorBitmapL (

        iCrossHair, 

        iCrossHairMask,

        EMbmImageeditoruiQgn_indi_imed_cursor_super,

        EMbmImageeditoruiQgn_indi_imed_cursor_super_mask        

        );

   // Load  SECOND CROSSHAIR image

    SDrawUtils::GetIndicatorBitmapL (

        iSecondaryCrossHair, 

        iSecondaryCrossHairMask, 

        EMbmImageeditoruiQgn_indi_imed_cursor2_super,

        EMbmImageeditoruiQgn_indi_imed_cursor2_super_mask        

        );

    TSize chSize = iCrossHair->SizeInPixels();

    TSize chNewSize = TSize( ( chSize.iWidth * KCursorScalingFactor ), 

                              ( chSize.iHeight * KCursorScalingFactor ) );

    // Set secondary cursor size smaller than the main cursor

    AknIconUtils::SetSize( iSecondaryCrossHair, chNewSize );

    AknIconUtils::SetSize( iSecondaryCrossHairMask, chNewSize );

    //  Create and start timer for dancing ants and fast key events

    iTimer = CPeriodic::NewL (CActive::EPriorityStandard);

    StartDancingAntsTimer();

    iPopupController = CAknInfoPopupNoteController::NewL();    

    TFileName resourcefile;

    resourcefile.Append(KPgnResourcePath);

    resourcefile.Append(KPgnResourceFile);

    User::LeaveIfError( CompleteWithAppPath( resourcefile ) );

    //    Read tooltip resources  

    //  (RConeResourceLoader selects the language using BaflUtils::NearestLanguageFile)

    RConeResourceLoader resLoader ( *CEikonEnv::Static() );

    CleanupClosePushL ( resLoader );

    resLoader.OpenL ( resourcefile );

    iTooltipResize = CEikonEnv::Static()->AllocReadResourceL(R_TOOLTIP_CROP_RESIZE_AREA);    

    iTooltipMove = CEikonEnv::Static()->AllocReadResourceL(R_TOOLTIP_CROP_MOVE_AREA);    

#ifdef RD_TACTILE_FEEDBACK 

    iTouchFeedBack = MTouchFeedback::Instance();

#endif /* RD_TACTILE_FEEDBACK  */

    CleanupStack::PopAndDestroy(); // resLoader

    EnableDragEvents();

    //    Activate control

    ActivateL();

}

//=============================================================================

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

{

#ifndef DOUBLE_BUFFERED_CROP

    CPreviewControlBase::DrawPreviewImage (aRect);

#endif // DOUBLE_BUFFERED_CROP

    if ( iState != ECropStateMin )

    {

        //  Get graphics context

        CWindowGc & gc = SystemGc();

#ifdef DOUBLE_BUFFERED_CROP

        if ( iBufBitmap && iBufBitmap->Handle() )

        {

            gc.BitBlt(TPoint(0,0), iBufBitmap);

        }

#endif // DOUBLE_BUFFERED_CROP

        //  Compute crop rectangle inside the image area

        TRect rect = iSysPars->VisibleImageRectPrev();

        TInt w = (rect.iBr.iX - rect.iTl.iX);

        TInt h = (rect.iBr.iY - rect.iTl.iY);

        TInt ulc = (TInt) (iULC * w + 0.5) + rect.iTl.iX;

        TInt ulr = (TInt) (iULR * h + 0.5) + rect.iTl.iY;

        TInt lrc = (TInt) (iLRC * w + 0.5) + rect.iTl.iX;

        TInt lrr = (TInt) (iLRR * h + 0.5) + rect.iTl.iY;

#ifndef DOUBLE_BUFFERED_CROP

        //    Darken areas in the image that are outside crop rectangle

        gc.SetDrawMode (CGraphicsContext::EDrawModeAND);

        gc.SetPenStyle (CGraphicsContext::ENullPen);

        gc.SetPenColor (KRgbBlack);

        gc.SetBrushStyle (CGraphicsContext::EDiamondCrossHatchBrush);

        gc.SetBrushColor (KRgbWhite);

        //    Darken top

        gc.DrawRect ( TRect ( rect.iTl.iX, 0, rect.iBr.iX, ulr ) );

        //    Darken left side

        gc.DrawRect ( TRect( rect.iTl.iX, ulr, ulc, lrr ) );

        //    Darken right side

        gc.DrawRect ( TRect( lrc, ulr, rect.iBr.iX, lrr ) );

        //    Darken bottom

        gc.DrawRect ( TRect( rect.iTl.iX, lrr, rect.iBr.iX, Rect().iBr.iY ) );

#endif // DOUBLE_BUFFERED_CROP

        //  Draw crop rectangle with dancing antz

        DrawDancingAnts (aRect);

        DrawCursors( TRect( ulc, ulr, lrc, lrr ) );

    }

}

//=============================================================================

void CImageEditorCropControl::DrawCursors (const TRect& aCropRect) const

    {

    CWindowGc & gc = SystemGc();

    CFbsBitmap* mainCrossHair;

    CFbsBitmap* mainCrossHairMask;

    if ( iState == ECropStateMove )

        {

        mainCrossHair = iSecondaryCrossHair;

        mainCrossHairMask = iSecondaryCrossHairMask;

        }

    else

        {

        mainCrossHair = iCrossHair;

        mainCrossHairMask = iCrossHairMask;

        }

    //  Draw the main cross hair

	if ( mainCrossHair && mainCrossHair )

	    {       

		TInt cx = 0;

		TInt cy = 0;

		if (iState == ECropStateFirst || iState == ECropStateMove)

		    {

			cx = aCropRect.iTl.iX;

			cy = aCropRect.iTl.iY;

	    	}

		else if (iState == ECropStateSecond)

		    {

			cx = aCropRect.iBr.iX - 1;

			cy = aCropRect.iBr.iY - 1;

	    	}

		TSize chSize = mainCrossHair->SizeInPixels();

		gc.BitBltMasked (

			TPoint(cx - (chSize.iWidth >> 1), cy - (chSize.iHeight >> 1)), 

			mainCrossHair, 

			TRect (chSize), 

			mainCrossHairMask, 

			EFalse

			);

	    }

    //  Draw the secondary cross hair

    if ( iSecondaryCrossHair && iSecondaryCrossHairMask )

        {

        TInt cx = 0;

        TInt cy = 0;

        if (iState == ECropStateFirst || iState == ECropStateMove)

            {

            cx = aCropRect.iBr.iX - 1;  

            cy = aCropRect.iBr.iY - 1;          

            }

        else if (iState == ECropStateSecond)

            {

            cx = aCropRect.iTl.iX;

            cy = aCropRect.iTl.iY;

            }        

        TSize chSize = iSecondaryCrossHair->SizeInPixels();            

        gc.BitBltMasked (

            TPoint(cx - (chSize.iWidth >> 1), cy - (chSize.iHeight >> 1)), 

            iSecondaryCrossHair, 

            TRect (chSize), 

            iSecondaryCrossHairMask, 

            EFalse

            );        

        }

    }

//=============================================================================

void CImageEditorCropControl::DrawDancingAnts (const TRect & /*aRect*/) const

{

    //  Get graphics context

    CWindowGc & gc = SystemGc();

    //  Compute crop rectangle inside the image area

    TRect rect = iSysPars->VisibleImageRectPrev();

    TInt w = (rect.iBr.iX - rect.iTl.iX);

    TInt h = (rect.iBr.iY - rect.iTl.iY);

    TInt ulc = (TInt) (iULC * w) + rect.iTl.iX;

    TInt ulr = (TInt) (iULR * h) + rect.iTl.iY;

    TInt lrc = (TInt) (iLRC * w) + rect.iTl.iX;

    TInt lrr = (TInt) (iLRR * h) + rect.iTl.iY;

    //    Crop needed rectangles

    TRect cr (ulc, ulr, lrc, lrr); 

    //  Draw the "dancing ants" rectangle

    gc.SetDrawMode (CGraphicsContext::EDrawModePEN);

    gc.SetBrushStyle (CGraphicsContext::ENullBrush);

    gc.SetBrushColor (KRgbBlack);

    //    Draw 

    gc.SetPenStyle (CGraphicsContext::ESolidPen);

    gc.SetPenColor ((iAntFlag) ? (KRgbBlack) : (KRgbWhite));

    gc.DrawRect (cr);

    //    Draw dashed line

    gc.SetPenStyle (CGraphicsContext::EDashedPen);

    gc.SetPenColor ((iAntFlag) ? (KRgbWhite) : (KRgbBlack));

    gc.DrawRect (cr);

}

//=============================================================================

void CImageEditorCropControl::SetView (CAknView * aView)

{

    LOG(KCropPluginLogFile, "CImageEditorCropControl::SetView()");

    iEditorView = aView;

}

//=============================================================================

void CImageEditorCropControl::SetSelectedUiItemL (CPluginInfo * aItem)

{

    LOG(KCropPluginLogFile, "CImageEditorCropControl::SetSelectedUiItemL()");

    iItem = aItem;

}

#ifdef DOUBLE_BUFFERED_CROP

//=============================================================================

void CImageEditorCropControl::SetImageL (CFbsBitmap * aBitmap)

{

    LOG(KCropPluginLogFile, "CImageEditorCropControl::SetImageL()");

    //    Create preview bitmap

    iPrevBitmap = aBitmap;

    TSize size = iPrevBitmap->SizeInPixels();

    TDisplayMode dmode = iPrevBitmap->DisplayMode();

    delete iBufBitmap;

    iBufBitmap = 0;

    iBufBitmap = new (ELeave) CFbsBitmap;

    User::LeaveIfError ( iBufBitmap->Create(size, dmode) );

    //    Copy bitmap data

    ClonePreviewBitmapL();

    DarkenUnselectedAreaL();

    DrawNow();    

}

#endif // DOUBLE_BUFFERED_CROP

//=============================================================================

TKeyResponse CImageEditorCropControl::OfferKeyEventL (

    const TKeyEvent &   aKeyEvent,

    TEventCode          aType

    )

{

    LOG(KCropPluginLogFile, "CImageEditorCropControl::OfferKeyEventL()");

    TKeyResponse response = EKeyWasNotConsumed;

    //  If busy, do not handle anything

    if ( Busy() )

    {

        response = EKeyWasConsumed;

    }

    //  EVENTKEY

    else if (EEventKey == aType && iHandleEventKeys)

    {

        switch (aKeyEvent.iCode)

        {

            case EKeyDownArrow:

            {

                //  Adjust crop point

                NaviDownL();

                iEditorView->HandleCommandL (EImageEditorUpdateNavipane);

                DrawNow();

                response = EKeyWasConsumed;

                iPopupController->HideInfoPopupNote();

                break;

            }

            case EKeyUpArrow:

            {

                //  Adjust crop point

                NaviUpL();

                iEditorView->HandleCommandL (EImageEditorUpdateNavipane);

                DrawNow();

                response = EKeyWasConsumed;

                iPopupController->HideInfoPopupNote();

                break;

            }

            case EKeyRightArrow:

            {

                //  Adjust crop point

                NaviRightL();

                iEditorView->HandleCommandL (EImageEditorUpdateNavipane);

                DrawNow();

                response = EKeyWasConsumed;

                iPopupController->HideInfoPopupNote();

                break;

            }

            case EKeyLeftArrow:

            {

                //  Adjust crop point

                NaviLeftL();

                iEditorView->HandleCommandL (EImageEditorUpdateNavipane);

                DrawNow();

                response = EKeyWasConsumed;

                iPopupController->HideInfoPopupNote();

                break;

            }

            case EKeyOK:

            case EKeyEnter:

            {

                StartDancingAntsTimer();

                if ( iIsCropModeManual )

                {

                    if (iState == ECropStateFirst)

                    {

                        iState = ECropStateSecond;

                        iEditorView->HandleCommandL (EImageEditorUpdateSoftkeys);

                        iEditorView->HandleCommandL (EImageEditorUpdateNavipane);

                        DrawNow();

                    }

                    else if (iState == ECropStateSecond)

                    {

                        iState = ECropStateMove;

                        iEditorView->HandleCommandL (EImageEditorUpdateSoftkeys);

                        iEditorView->HandleCommandL (EImageEditorUpdateNavipane);

                        DrawNow();

                    }

                    else

                    {

                        iState = ECropStateMin;

                        iReadyToRender = ETrue;

                        iEditorView->HandleCommandL (EImageEditorResetZoom);

                        if ( iULC == 0.00 && iULR == 0.00 && iLRC == 1.00 && iLRR == 1.00)

                        {

                            iEditorView->HandleCommandL (EImageEditorCancelPlugin);    

                        }

                        else

                        {