/*

* Copyright (c) 2007 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 for presentation element - vertical.

*

*/

//Toolkit Includes

#include <avkon.mbg> 

#include <mulsliderwidget.mbg>

// Alfred Client includes

#include <alf/alfenv.h>

#include <alf/alfroster.h>

#include <alf/alfdisplay.h>

#include <alf/alfbrusharray.h>

#include <alf/alftextvisual.h>

#include <alf/alfevent.h>

#include <alf/alfframebrush.h>

//Widget Model Includes

#include <alf/alfwidgetevents.h>

#include <alf/alfwidgetenvextension.h>

#include <alf/ialfmodel.h>

//Avkon Includes

#include <AknUtils.h>

#include <AknsConstants.h>

#include <utf.h>

#include <aknlayoutscalable_uiaccel.cdl.h>

#include <avkon.hrh>

//#include <math.h>

//slider widget includes

#include "mulslidervertical.h"

#include <mul/mulevent.h>

#include "mulsliderwidget.h"

#include "mulslidercontrol.h"

#include "mulslidermodel.h"

#include "mulsliderdefinitions.h"

#include "mulsliderutils.h"

//Timer function includes

#include "mulsliderlongtaptimer.h"

#include <alf/alfgradientbrush.h>

namespace Alf

    {    

// Structure to store data for the slider element class

struct MulVerticalSliderDataImpl

    {

    bool mOperation;// Drag state

    bool mSliderHit;// button down has happened on slider visual

    float mTickInPixels;// Tick size in Pixel

    int mRangeInPixels;// Range in Pixel

    int mCurrTickInPixels;// Current Tick posion in pixels

    CAlfVisual * mVisual;// Stores the current visual hit 

    TPoint mDragPoint;// Point at which drag started 

    TPoint mLongTapPos;// Point at which button down happened 

    int mDragStartStep;// Tick positon of Drag Start

    int mCurrTick;// Stores current tick

    int mTick;// Stores Tick Size

    int mTrackStartPoint;// Slider Track Start Point in pixel

    int mHandleGhostHieghtDelta;

    bool mOrientationLandScape;

    bool mHasBackground; // for background only created once 

    int mdirection;// 0 - nomovement,1 up movement 2 down

    bool mLayoutMirrored;// RTL if True else LTR

    int mImageTextureId; // to differtiate between textures 

    CAlfLayout* mMainLayout;

    CAlfLayout* mBaseSliderLayout;// Slider Background

    CAlfTexture* mTexture;

    CAlfLayout* mSliderCentre;// Track layout

    CAlfLayout* mSliderCentreGhost;// Extended touch are for track

    CAlfImageVisual* mTrackTopImage;

    CAlfImageVisual* mTrackMiddleImage;

    CAlfImageVisual* mTrackEndImage;

    CAlfImageVisual* mSliderHandle;// Slider Handle

    CAlfLayout* mSliderHandleGhost;//Extended touch are for handle

    CAlfVisual* mSliderPercentAudio;//Visula showing percentage

    CAlfImageVisual* mImagePlus;// Zoom in

    CAlfImageVisual* mImageMinus;// Zoom out

    MulVerticalSliderDataImpl()

        {

        mOperation = false;

        mSliderHit = false;

        mTickInPixels = 0;

        mRangeInPixels = 0;

        mCurrTickInPixels = 0;

        mVisual = NULL;

        mDragPoint.SetXY(0,0);

        mLongTapPos.SetXY(0,0);

        mDragStartStep = 0;

        mCurrTick = 0;

        mTick = 0;

        mTrackStartPoint = 0;

        mImageTextureId = 0;

        mMainLayout = NULL;

        mBaseSliderLayout = NULL;

        mSliderCentre = NULL;

        mTrackTopImage = NULL;

        mTrackMiddleImage = NULL;

        mTrackEndImage = NULL;

        mSliderCentreGhost = NULL;

        mSliderHandleGhost = NULL;

        mSliderHandle = NULL;

        mSliderPercentAudio = NULL;

        mImagePlus = NULL;

        mImageMinus = NULL;

        mHandleGhostHieghtDelta = 0;   

        mOrientationLandScape = false;

        mdirection = 0;

        mLayoutMirrored = false;

        mHasBackground = false;

        } 

    };

// bitmap file path

_LIT(KAvkonBitmapFile,"\\resource\\apps\\avkon2.mbm");

_LIT(KSliderBitmapFile,"\\resource\\apps\\mulsliderwidget.mif");

const TInt KAlfTrackTopTextureId = 1;

const TInt KAlfTrackBottomTextureId = 2;

const TInt KAlfTrackMiddleTextureId = 3;

const TInt KAlfMarkerTextureId = 4;

const TInt KAlfZoomInTextureId = 5;

const TInt KAlfZoomOutTextureId = 6;

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

//  C++ default constructor.

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

//

MulSliderVertical::MulSliderVertical(

                                    CAlfWidgetControl& aControl,

                                    const char* aName, 

                                    AlfCustomInitDataBase* /*aCustomData*/)

    : mData(NULL)

        {

        // Base class (AlfElement) construct

        construct(aControl, aName);

        mSliderModel = NULL;

        mSliderWidget = NULL;

        mData = new (EMM) MulVerticalSliderDataImpl;

        mPosData.reset(new(EMM)MulSliderPos);

        // Timer for generating tap and hold repeat events  

        mLongTapTimer.reset(new (EMM) MulSliderLongTapTimer(this)); 

        initializeSliderData();

        }

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

//  Destructor

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

//

MulSliderVertical::~MulSliderVertical()

    {

    // Visualization Data

    if(mData)

        {

        }

    else

        {

        }

    }//End of Destructor

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

// From class MAlfInterfaceBase.

// Getter for interfaces provided by the slider widget.

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

//

IAlfInterfaceBase* MulSliderVertical::makeInterface(

                        const IfId& aType)

    {

    IAlfInterfaceBase* interface = 0;

    UString param (aType.mImplementationId);

    if (param == IAlfWidgetEventHandler::type().mImplementationId)

        {

        return static_cast<IAlfWidgetEventHandler*>(this);

        }

    else if (param == 

    IMulSliderBaseElementInternal::type().mImplementationId)

        {

        return static_cast<IMulSliderBaseElementInternal*>(this);

        }  

    else

        {

        interface = AlfElement::makeInterface(aType);   

        }

    return interface;

    }

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

// APIs from the IMulSliderBaseElement 

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

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

// Gets called when the parent layout is relayouted.

// resets all the anchor points and updates the visualization

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

//

void MulSliderVertical::baseLayoutSizeChanged()

    {

    mData->mMainLayout->ClearFlag(EAlfVisualFlagLayoutUpdateNotification);

    if(mData->mMainLayout)

        {

        //mData->mOrientationLandScape = mSliderModel->IsLandscape();

        // This is a hack to resolve screen refresh issue

        control().Env().RefreshCallBack(&(control().Env()));

        // Layout the visualization with correct LCT values 

        layoutVisuals(mSliderModel->GetTemplate());

        // Convert all the user defined data to pixels

        ConvertDataToPixels();

        // Set the thumb position to the current tick

        SetThumbPosition();

        mData->mMainLayout->SetOpacity(mSliderWidget->GetOpacity());

        }

    mData->mMainLayout->SetFlag(EAlfVisualFlagLayoutUpdateNotification);   

    }

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

// From class IAlfWidgetEventHandler.

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

//  

void MulSliderVertical::setActiveStates(

    unsigned int /*aStates*/)

    {

    //do nothing

    }

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

//  initializes Model and Widget Pointer

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

//

void  MulSliderVertical::initializeSliderData()

    {

    // initialize the Slider Widget Pointer;

    IAlfWidgetFactory& widgetFactory = 

        AlfWidgetEnvExtension::widgetFactory(control().Env());

    mSliderWidget = static_cast<MulSliderWidget *>(widgetFactory.findWidget(

                    control().widget()->widgetName()));

    // initialize the Slider Model Pointer;

    mSliderModel =static_cast<MulSliderModel*>(mSliderWidget->model());

    }

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

//  set the positions and images for the visual hierarchy

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

//

void MulSliderVertical::layoutVisuals( sliderTemplate /*aTemplateId*/)

    {

    bool relayout = false;

    if(mData->mLayoutMirrored != AknLayoutUtils::LayoutMirrored())

        {

        mData->mOrientationLandScape = !mSliderModel->IsLandscape();

        mData->mLayoutMirrored = AknLayoutUtils::LayoutMirrored();

        }

    if( mSliderModel->IsLandscape() != mData->mOrientationLandScape ) 

        {

        relayout = true;

        mData->mOrientationLandScape = mSliderModel->IsLandscape();

        }  

    if(relayout)

        {

    CAlfControl* ctrl = (CAlfControl*)&control();  

    TAknLayoutRect layoutRect;

    //get the lct rect for mBaseSliderLayout and set it            

    // aaslider_pane(3)

    layoutRect = MulSliderUtils::GetComponentRect(

            EVSliderPane,mData->mMainLayout,KVariety3);

    mData->mBaseSliderLayout->SetRect(

            TRect( TPoint(layoutRect.Rect().iTl.iX,layoutRect.Rect().iTl.iY  ),

                    TSize( layoutRect.Rect().Size().iWidth, 

                            layoutRect.Rect().Size().iHeight ))) ;

   if(!mData->mHasBackground)

            SetBackgroundBrush();

    // Set Position and Size for Extended touch layout for track

    mData->mSliderCentreGhost->SetRect(

            TRect( TPoint(0,0 ),

                    TSize( layoutRect.Rect().Size().iWidth, 

                            layoutRect.Rect().Size().iHeight )));

    layoutRect = MulSliderUtils::GetComponentRect(

                    TSize( layoutRect.Rect().Size().iWidth, 

    layoutRect = MulSliderUtils::GetComponentRect(

                    TSize( layoutRect.Rect().Size().iWidth, 

    //get the lct rect for mSliderHandle and set it     

    //aid_touch_size_slider_marker(5)

    layoutRect = MulSliderUtils::GetComponentRect(

            EVSliderMarker,

            mData->mBaseSliderLayout,

            KVariety5);

    mData->mSliderHandle->SetRect(

            TRect( TPoint( layoutRect.Rect().iTl.iX,layoutRect.Rect().iTl.iY ),

                    TSize( layoutRect.Rect().Size().iWidth, 

                            layoutRect.Rect().Size().iHeight ))) ;

    layoutRect = MulSliderUtils::GetComponentRect(

                EVSliderMarkerExtended,

                mData->mBaseSliderLayout,

                KVariety5);

    mData->mHandleGhostHieghtDelta = 

        (layoutRect.Rect().Size().iHeight - mData->mSliderHandle->Size().iY.ValueNow()  );

    // Set Position and Size for Extended touch layout for handle

    mData->mSliderHandleGhost->SetRect(

            TRect( TPoint( mData->mBaseSliderLayout->Pos().iX.ValueNow(),

                    mData->mSliderHandle->Pos().iY.ValueNow()- 

                    mData->mHandleGhostHieghtDelta/2),

                    TSize( mData->mBaseSliderLayout->Size().iX.ValueNow(), 

                            layoutRect.Rect().Size().iHeight)));

    if(mData->mSliderHandle)

        {

        mData->mImageTextureId = KAlfMarkerTextureId;

        // Create the texture from bitmap provider

        }

    if(mData->mImagePlus)

        {

        mData->mImageTextureId = KAlfZoomInTextureId;

        // Create the texture from bitmap provider

        }

    if(mData->mImageMinus)

        {

        mData->mImageTextureId = KAlfZoomOutTextureId;

        // Create the texture from bitmap provider

        }

    }

    }

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

// Used for setting images for the track 

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

//

void MulSliderVertical::setTrackImage()

    {