/*

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

// dimension of grid

const TInt KDimensionsOfGrid = 2;

// Tags for visuals which have always same appearance. 

// TTagAnalogDialerVisual is used for indexing

const char* KTagArrayTheRest[] =

    {

    "main",

    "display",

    "phone",

    "plate-deck",

    "plate-image",

    "stopper"

    };     

// Dimensions of grid. iLayoutMode is used for indexing

const TInt KRowsAndColumnsOfGrid[][KDimensionsOfGrid] =

    {

    { 1, 2 },   // columns, rows

    { 2, 1 }  

    };

// Templates 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

const TInt KPlateReturnSpeed = 65;

// 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.

const TInt KPlateDraggingDelta = 2;

// position of stopper in degrees. Angle is 43

const TInt KStopperAngle = 360-43;

// Angle of first number

// Numbers are on angle between KPlateNumbersStartAngle and (KPlateNumbersStartAngle + KPlateNumbersDistributionAngle)

const TInt KPlateNumbersStartAngle = 3;

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

// Numbers are on angle between KPlateNumbersStartAngle and (KPlateNumbersStartAngle + KPlateNumbersDistributionAngle)

const TInt KPlateNumbersDistributionAngle = 290;

// minimum rotation of plate that number becomes selected

const TInt KPlateMinimumRotateAngle=43;

// font color 

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

// Size of padding of the root grid layout

//const TReal32 KPaddingPercentage = .05;

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

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

    {

    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

	SetId(KAlfExAnalogDialerControlId);

    // resolve layout: portrait or landscape

    iLayoutMode = ResolveLayout(iSquareSide,

                            iLongerSide);

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

    // set up vibra system

    iFeedback = CAlfExAnalogDialerFeedback::NewL();

    }   

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

// Creates layouts and visual for portrait layout

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

//

void CAlfExAnalogDialerControl::SetupPortraitModeL()

    {

    // resolve layout: portrait or landscape

    AddGridLayoutL();

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

    AddDisplayPaneL();

    AddDialerL();

    //AddEffectLayout();

    }

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

// Creates layouts and visual for portrait layout

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

//

void CAlfExAnalogDialerControl::SetupLandscapeModeL()

    {

    // resolve layout: portrait or landscape

    AddGridLayoutL();

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

    AddDialerL();

    AddDisplayPaneL();

    //AddEffectLayout();

    }

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

// Creates grid layout and returns it

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

//

void CAlfExAnalogDialerControl::AddGridLayoutL()

    {

      // Create a grid layout to act as the root layout visual. Not owned

    if (!iRootLayout)

        {

        iRootLayout = CAlfGridLayout::AddNewL(*this, 

                                            KRowsAndColumnsOfGrid[iLayoutMode][EColumn], 

                                            KRowsAndColumnsOfGrid[iLayoutMode][ERow]);

        iRootLayout->SetTagL(_L8(KTagArrayTheRest[ETagAnalogDialerMain]));   

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

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

        CleanupStack::Pop(brush);

        }

    else

        {

        // Reset current dimensions

        // There is only one 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 new dimension

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

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

        }

    // 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][EColumn],

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

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

    }

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

// Handles pointer down events

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

//

TBool CAlfExAnalogDialerControl::HandlePointerDownEventL(const TAlfEvent& aEvent)

	{

	CAlfVisual* onVisual = aEvent.Visual();

	// Dragging may start only on top of image

	if (onVisual == iStopper)

	    {      

	    // Is plate rotating starting?

        if (IsPointerEventFollowingNumbersArcPath(aEvent))

            {

            // Plate rotation is starting

    	    // Register to receive dragging events

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

    		ResetDraggingData();

            // Start dragging

    	    iFlags |= EAnalogDialerControlDragging;

            }

        // Is clear key pressed?

        else if (IsPointerEventOnClearKey(aEvent))

            {

    		ResetClearKeyData();

    	    // Register for long tap events

            if (!(iFlags & EAnalogDialerControlFlagLongTapRegistered))

                {

                // Clear key handling needs long tap events

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

                iFlags |= EAnalogDialerControlFlagLongTapRegistered;

                }

            // Start clear key event

    	    iFlags |= EAnalogDialerControlClearKeyEvent;

            }

	    }

	return ETrue;

	}

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

// Handles events while dragging

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

//

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 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(    *iImage,

                                iDraggingData.iInitialAngle,

                                degrees,

                                iDraggingData.iIsClockWiseOverZeroReached);

                }

            // else - delta of rotation has not reached KPlateDraggingDelta

            }

        }

    return ETrue;

	}

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

// Handle pointer up event

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

//

TBool CAlfExAnalogDialerControl::HandlePointerUpEventL(const TAlfEvent& aEvent)

	{

	if (iFlags & EAnalogDialerControlDragging)

		{

		FinishDragging();

		}

    else if (iFlags & EAnalogDialerControlClearKeyEvent)

        {

        if (IsPointerEventOnClearKey(aEvent))

            {

            ClearNumberDisplay(iFlags&EAnalogDialerControlFlagLongTapPressed);

            }

        // else - lifting pointer outside Clear key area cancels clearing number

        ResetClearKeyData();

        }

    return ETrue;

	}

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

// Handle long tap event

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

//

TBool CAlfExAnalogDialerControl::HandlePointerLongTapEventL(const TAlfEvent& /*aEvent*/)

    {

    if (iFlags & EAnalogDialerControlClearKeyEvent)

        {

        iFlags |= EAnalogDialerControlFlagLongTapPressed;

        }

    return ETrue;  

    }

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

// Events from framework

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

//

TBool CAlfExAnalogDialerControl::OfferEventL(const TAlfEvent& aEvent)

    {

    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;

	}

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

// AddNumberToDisplayPaneL

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

//

void CAlfExAnalogDialerControl::AddNumberToDisplayPaneL(TInt aNumber)

	{	

    TBuf<8> number;        

    // Second parameter: number cannot be 10

    number.Format(KNumberDisplayTemplate, (aNumber+1)%10);

    if (iDisplayNumber.Length() + number.Length() <= KNumberDisplayBufferLength)

    	{

    	iDisplayNumber.Append(number);    

    	iDisplayPane->SetTextL(iDisplayNumber);

    	}

	}

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

// Adds content into display pane of the application

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

//

void CAlfExAnalogDialerControl::AddDisplayPaneL()

    {

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

    // Add TextVisual for displaying text

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

    iDisplayPane->SetTagL(_L8( KTagArrayTheRest[ETagAnalogDialerDisplay]));

    iDisplayPane->EnableBrushesL();      

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

    // Display rectangular 

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

    brush->SetOpacity(.25f);

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

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

    CleanupStack::Pop(brush);    

    }

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

// Adds content into dialer pane of the application

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

//