/*

* Copyright (c) 2008-2008 Nokia Corporation and/or its subsidiary(-ies). 

* All rights reserved.

* This component and the accompanying materials are made available

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

*

* Description:   Implementation of member functions of 

*                AlfExAnalogDialerControl.

*

*/

#include <coemain.h>

// Visuals

#include <alf/alfgridlayout.h>

#include <alf/alftextvisual.h>

#include <alf/alfimagevisual.h>

#include <alf/alflinevisual.h>

// Layouts

#include <alf/alfdecklayout.h>

#include <alf/alfcurvepath.h>

#include <alf/alfcurvepathlayout.h>

// Brushes

#include <alf/alfborderbrush.h>

#include <alf/alfbrusharray.h>

#include <alf/alfimagebrush.h>

#include <alf/alfimage.h>

#include <alf/alfshadowborderbrush.h>

#include <alf/alfgradientbrush.h>

// Unsorted

#include <aknutils.h>

#include <alf/alftransformation.h>

#include <alf/alfevent.h>

#include <alf/alfdisplay.h>

#include <alf/alfenv.h>

#include <alf/alfmappingfunctions.h>

#include <alf/alfroster.h>

#include <e32math.h>

#include "alfexanalogdialercontrol.h"

#include "alfexanalogdialerfeedback.h"

// Image names

_LIT(KImageAnalogDialerBackground, "background.png");

_LIT(KImageAnalogDialerNumbers, "numbers.png");

_LIT(KImageAnalogDialerPlate, "plate.png");

_LIT(KImageAnalogDialerStopper, "stopper.png");

#define RADTODEG(Rad) ((180.0 * Rad) / KPi)

// font color 

const TRgb KFontColor = TRgb(192,192,192);

// dimension of grid

const TInt KDimensionsOfGrid = 2;

// Tags for visuals which have always same appearance. 

// TTagAnalogDialerVisual is used for indexing

const char* KTagArray[] =

    {

    "root-layout",

    "display-deck",

    "display-visual",

    "plate-deck",

    "numbers-visual",

    "plate-visaul",

    "stopper-visual"

    };     

// Dimensions of grid. iLayoutMode is used for indexing

const TInt KRowsAndColumnsOfGrid[][KDimensionsOfGrid] =

    {

    { 1, 2 },   // columns, rows

    { 2, 1 }  

    };

// Template for displaying number

_LIT(KNumberDisplayTemplate, "%d");

// Radius of Clear area of plate. Per cents from radius of plate.

const TInt KPlateClearRadius = 25;

// Unit speed of returning plate to idle position. Degrees per second. 

const TInt KPlateReturnSpeed = 65;

// As dragging events occur very often, redrawing plate is optimised that

// it is not drawn after every dragging event. 

// Plate is redrawn when angle of the plate has changed KPlateDraggingDelta clockwise.

const TInt KPlateDraggingDelta = 2;

// position of stopper in degrees. Angle is 43 clockwise down from the X-axis

const TInt KStopperAngle = 360-43;

// angle of arch on which numbers (or holes) are distributed

const TInt KPlateNumbersDistributionAngle = 290;

// minimum rotation of plate that a number becomes selected. If plate has been dialed

// less than or equal to KPlateMinimumRotateAngle degrees, number is not selected.

const TInt KPlateMinimumRotateAngle=43;

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

// NewL

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

//

CAlfExAnalogDialerControl* CAlfExAnalogDialerControl::NewL(CAlfEnv& aEnv)

    {

    CAlfExAnalogDialerControl* self = CAlfExAnalogDialerControl::NewLC(aEnv);

    CleanupStack::Pop(self);

    return self;

    }

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

// NewLC

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

//

CAlfExAnalogDialerControl* CAlfExAnalogDialerControl::NewLC(CAlfEnv& aEnv)

    {

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

    CleanupStack::PushL(self);

    self->ConstructL(aEnv);

    return self;

    }

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

// ~CAlfExAnalogDialerControl

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

//

CAlfExAnalogDialerControl::~CAlfExAnalogDialerControl()

    {

    // Remove observer is still there

    if (iFlags & EAnalogDialerControlFlagLongTapRegistered)

        {

        Display()->Roster().RemovePointerEventObserver(EAlfPointerEventReportLongTap, *this);

        }

    Env().CancelCommands(this);

    delete iFeedback;

    }

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

// CAlfExAnalogDialerControl

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

//

CAlfExAnalogDialerControl::CAlfExAnalogDialerControl()

        : CAlfControl()

    {

    }

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

// ConstructL

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

//

void CAlfExAnalogDialerControl::ConstructL(CAlfEnv& aEnv)

    {

    CAlfControl::ConstructL(aEnv);

    // Id cannot be be set in constructor. Id is needed in appui to retrieve control from control group

	SetId(KAlfExAnalogDialerControlId);

    // resolve layout: portrait or landscape

    iLayoutMode = ResolveLayout(iSquareSide, iLongerSide);

    // setup visuals accroding to layout

    (iLayoutMode == ELayoutAnalogDialerPortrait) ? SetupPortraitModeL() : SetupLandscapeModeL();

    // set up vibra system

    iFeedback = CAlfExAnalogDialerFeedback::NewL();

    }   

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

// Creates layouts and visual for portrait layout

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

//

void CAlfExAnalogDialerControl::SetupPortraitModeL()

    {

    // Setup grid (root layout)

    AddGridLayoutL();

    // from top to bottom 1) display pane 2) dialer

    AddDisplayPaneL();

    AddDialerL();

    //AddEffectLayout();

    }

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

// Creates layouts and visual for portrait layout

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

//

void CAlfExAnalogDialerControl::SetupLandscapeModeL()

    {

    // Setup grid (root layout)

    AddGridLayoutL();

    // from left to right 1) dialer 2) display pane

    AddDialerL();

    AddDisplayPaneL();

    //AddEffectLayout();

    }

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

// Creates grid layout or modify existing one after layout change

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

//

void CAlfExAnalogDialerControl::AddGridLayoutL()

    {

    if (!iRootLayout)

        {

        // Fresh start of the application. Create a grid layout to act as the root layout visual.

        iRootLayout = CAlfGridLayout::AddNewL(*this, 

                                            KRowsAndColumnsOfGrid[iLayoutMode][EAlfGridColumn], 

                                            KRowsAndColumnsOfGrid[iLayoutMode][EAlfGridRow]);

        // Tag is not really needed, because root layout assigned to member variable

        iRootLayout->SetTagL(_L8(KTagArray[ETagAnalogDialerRootLayout]));   

        // Brushed must enabled before they can be used

        iRootLayout->EnableBrushesL();      

        // Background image is implemented using image brush

        CAlfTexture& backgroundTexture = Env().TextureManager().LoadTextureL( 

                                            KImageAnalogDialerBackground,

                                            EAlfTextureFlagDefault, 

                                            KAlfAutoGeneratedTextureId);        

        // Default scale mode CAlfImageVisual::EScaleFit is OK

        CAlfImageBrush* brush = CAlfImageBrush::NewLC(Env(), TAlfImage(backgroundTexture));

        // sets background image behind the visual

        brush->SetLayer(EAlfBrushLayerBackground);

        // Append brush to the layout and transfer its ownership to the visual.    

        iRootLayout->Brushes()->AppendL(brush, EAlfHasOwnership);

        CleanupStack::Pop(brush);

        }

    else

        {

        // Layout change has taken place. Modify dimensions and weights

        // Reset current dimension

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

            {

            // resetting non existing weights causes Leave

            TRAP_IGNORE(iRootLayout->RemoveWeightL(EAlfGridColumn, i));

            TRAP_IGNORE(iRootLayout->RemoveWeightL(EAlfGridRow, i));

            }

        // now set up new dimension

        iRootLayout->SetColumnsL(KRowsAndColumnsOfGrid[iLayoutMode][EAlfGridColumn]);

        iRootLayout->SetRowsL(KRowsAndColumnsOfGrid[iLayoutMode][EAlfGridRow]);

        }

    // Sets weights of grid

    SetWeightsOfGridL(*iRootLayout,

                      iLayoutMode,

                      iSquareSide,

                      iLongerSide,

                      iPlateTopOffset);

    // Set the padding of the root layout

    // TODO: Padding disabled for now. This seems to mess the angle calculations as we the calculations do not consider

    // the effect of padding.

    /*

    TRect displayRect = Env().PrimaryDisplay().VisibleArea();

    TInt pad = displayRect.Height();

    if ( iLayoutMode == ELayoutAnalogDialerLandscape )

        {

        pad = displayRect.Width();

        }   

    layout->SetInnerPadding(TPoint( 

    		pad * KPaddingExtents[iLayoutMode][EAlfGridColumn],

    		pad * KPaddingExtents[iLayoutMode][EAlfGridRow]));

    layout->SetPadding(pad * KPaddingPercentage);*/

    }

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

// Adds content into display pane of the application

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

//

void CAlfExAnalogDialerControl::AddDisplayPaneL()

    {

    CAlfDeckLayout* displayDeck = CAlfDeckLayout::AddNewL(*this, iRootLayout);

    displayDeck->SetTagL(_L8( KTagArray[ETagAnalogDialerDisplayDeck]));

    // Add TextVisual number display

    iDisplayPane = CAlfTextVisual::AddNewL(*this, displayDeck );

    // Tag is not really needed

    iDisplayPane->SetTagL(_L8( KTagArray[ETagAnalogDialerDisplayVisual]));

    iDisplayPane->SetAlign(EAlfAlignHRight, EAlfAlignVCenter);      

    /*iDisplayPane->SetFlag(EAlfVisualFlagManualLayout);

    // Decoration

    if (iLayoutMode == ELayoutAnalogDialerPortrait)

    	{

    	iDisplayPane->SetCenteredPosAndSize(TPoint(180,100),TSize(300,50));

    	}

    else 

    	{

    	iDisplayPane->SetCenteredPosAndSize(TPoint(150,180),TSize(200,300));

    	}*/

    iDisplayPane->SetStyle(EAlfTextStyleTitle);

    iDisplayPane->SetColor(KFontColor);    

    // Enable brushed for borders etc

    iDisplayPane->EnableBrushesL();      

    // Display rectangular 

    CAlfShadowBorderBrush* brush = CAlfShadowBorderBrush::NewLC(Env(),6);

    brush->SetOpacity(.25f);

    // Append brush to the visual and transfer its ownership to the visual.    

    iDisplayPane->Brushes()->AppendL(brush, EAlfHasOwnership);

    CleanupStack::Pop(brush);    

    }

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

// Adds content into dialer pane of the application

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

//

void CAlfExAnalogDialerControl::AddDialerL()

    {

    // Dialer consists of three images on top of each other. Deck is needed to manage them

    // Parent layout is grid

    CAlfDeckLayout* dialerDeck = CAlfDeckLayout::AddNewL(*this, iRootLayout);

    dialerDeck->SetTagL(_L8(KTagArray[ETagAnalogDialerPlateDeck]));

	// Load images:    

    // 1) Image with the numbers

    CAlfTexture& numbersTexture = Env().TextureManager().LoadTextureL( KImageAnalogDialerNumbers, 

                                                                        EAlfTextureFlagDefault, 

                                                                        KAlfAutoGeneratedTextureId);

    // Parent layout is deck

	CAlfImageVisual* numbers  = CAlfImageVisual::AddNewL(*this,dialerDeck); 

    // Default scale mode CAlfImageVisual::EScaleFit is OK

	// attach texture to image visual

	numbers->SetImage(TAlfImage(numbersTexture));

	// 2) plate with holes

	CAlfTexture& plateTexture = Env().TextureManager().LoadTextureL(  KImageAnalogDialerPlate, 

	                                                            EAlfTextureFlagDefault, 

	                                                            KAlfAutoGeneratedTextureId);

    // Parent layout is deck

	iPlate = CAlfImageVisual::AddNewL(*this,dialerDeck); 

    // Default scale mode CAlfImageVisual::EScaleFit is OK

	iPlate->SetImage(TAlfImage(plateTexture));

	// 2) stopper

	CAlfTexture& stopper = Env().TextureManager().LoadTextureL( KImageAnalogDialerStopper, 

	                                                            EAlfTextureFlagDefault, 

	                                                            KAlfAutoGeneratedTextureId);

    // Parent layout is deck

	iStopper  = CAlfImageVisual::AddNewL(*this,dialerDeck); 

    // Default scale mode CAlfImageVisual::EScaleFit is OK

	iStopper->SetImage(TAlfImage(stopper));

    }

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

// Events from framework

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

//

TBool CAlfExAnalogDialerControl::OfferEventL(const TAlfEvent& aEvent)

    {

    // Ignore other events except pointer events

    if (aEvent.IsPointerEvent() && aEvent.PointerDown())

	    {

	    return HandlePointerDownEventL(aEvent);    

	    }

	else if(aEvent.IsPointerEvent() && aEvent.PointerEvent().iType == TPointerEvent::EDrag )

	    {

	    return HandleDraggingEventL(aEvent);

	    }

	else if(aEvent.IsPointerEvent() && aEvent.PointerUp())

	    {

	    return HandlePointerUpEventL(aEvent);

	    }

	else if(aEvent.IsPointerEvent() && aEvent.PointerLongTap())

	    {

	    return HandlePointerLongTapEventL(aEvent);

	    }

	return EFalse;

	}

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

// Handles pointer down events

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

//

TBool CAlfExAnalogDialerControl::HandlePointerDownEventL(const TAlfEvent& aEvent)

	{

	// Topmost image i.e. stopper image visual gets the pointer event

	CAlfVisual* onVisual = aEvent.Visual();

	if (onVisual == iStopper)

	    {      

	    // Is plate rotating starting?

        if (IsPointerEventFollowingNumbersArcPath(aEvent))

            {

    		ResetDraggingData();

            // Plate rotation is starting

    	    // Register to receive dragging events

    	    Display()->Roster().AddPointerEventObserver(EAlfPointerEventReportDrag, *this);   

            // Dragging has started

    	    iFlags |= EAnalogDialerControlDragging;

            }

        // Is clear key pressed?

        else if (IsPointerEventOnClearKey(aEvent))

            {

    		ResetClearKeyData();

            if (!(iFlags & EAnalogDialerControlFlagLongTapRegistered))

                {

                // Clear key handling needs long tap events

    	        // Register for long tap events

                Display()->Roster().AddPointerEventObserver(EAlfPointerEventReportLongTap, *this);   

                iFlags |= EAnalogDialerControlFlagLongTapRegistered;

                }

            // Clear key event has started

    	    iFlags |= EAnalogDialerControlClearKeyEvent;

            }

	    }

	return ETrue;

	}

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

// Handles dragging events

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

//

TBool CAlfExAnalogDialerControl::HandleDraggingEventL(const TAlfEvent& aEvent)

	{

    if (iFlags & EAnalogDialerControlDragging)

        {

    	TPoint plateCentricPoint;

    	ConvertEventToPlateCentricPosition(aEvent,

    	                                   iPlateTopOffset,

    	                                   iSquareSide,

    	                                   plateCentricPoint);

    	TInt plateRadius = iSquareSide / 2;

    	if (!IsPointerEventOnArcPath(plateCentricPoint,

    	                             plateRadius,

    	                             plateRadius * KPlateClearRadius / 100))

    		{

    		FinishDragging();

    		}

        else

            {

            // Pointer event is following path

            // Get angle of pointer event and do further calculation based on it

            TInt degrees = Angle(plateCentricPoint.iX, plateCentricPoint.iY);

            // Save the angle of first dragging pointer event.

            // It is used to resolve selected number.

        	if (iDraggingData.iInitialAngle == 0)

        	    {

        	    iDraggingData.iInitialAngle = degrees; 

        	    iDraggingData.iPreviousAngle = degrees;

        	    }

            // As dragging events occur very often, redrawing plate is optimised that

            // it is not drawn after every dragging event. Change of KPlateDraggingDelta degrees

            // is needed until plate is redrawn.

            if (    degrees >= iDraggingData.iPreviousAngle + KPlateDraggingDelta 

                ||  degrees <= iDraggingData.iPreviousAngle - KPlateDraggingDelta)

                {

                ResolveXAxisCrossing(degrees);                     

                iDraggingData.iPreviousAngle = degrees;

                if (    iDraggingData.iIsClockWiseOverZeroReached

                    &&  degrees < KStopperAngle)

                    {

                    if (iDraggingData.iStopperReached)

                        {

                        // do not redraw as plate cannot rotate more

                        return ETrue;

                        }

                    // stopper has been reached

                    iDraggingData.iStopperReached = ETrue;

                    }

                else if (   !iDraggingData.iIsClockWiseOverZeroReached

                        &&  degrees > iDraggingData.iInitialAngle)

                    {

                    // Rotation counter clockwise to the left of idle position is asked

                    // Plate does not rotate counterclockwise to the left of idle position

                    return ETrue;

                    }

                else if (iDraggingData.iStopperReached)

                    {                        

                    // user has dragged 360 degrees and is dragging now between idle and stopper position

                    return ETrue;

                    }

                 else

                    {

                    // rotating when angle is between idle and stopper position

                    iDraggingData.iStopperReached = EFalse;

                    }

                //DebugDraggingData(degrees);

                RotatePlate(    *iPlate,

                                iDraggingData.iInitialAngle,

                                degrees,

                                iDraggingData.iIsClockWiseOverZeroReached);

                }

            // else - delta of rotation has not reached KPlateDraggingDelta

            }

        }

    // else - it is permitted that clear key event is dragged outside clear key area. What matters is where

    // the pointer event up takes place

    return ETrue;

	}