/*

* 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 <osn/alfptrvector.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 

    int mTrackTopTextureId ;// to store the auto generated texture id's

    int mTrackBottomTextureId;

    int mTrackMiddleTextureId;

    int mMarkerTextureId;

    int mZoomInTextureId;

    int mZoomOutTextureId;

    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;

        mTrackTopTextureId = 0;

        mTrackBottomTextureId = 0;

        mTrackMiddleTextureId = 0;

        mMarkerTextureId = 0;

        mZoomInTextureId = 0;

        mZoomOutTextureId = 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)

        {

        (&control().Env())->TextureManager().UnloadTexture(mData->mTrackTopTextureId);

        (&control().Env())->TextureManager().UnloadTexture(mData->mTrackBottomTextureId);

        (&control().Env())->TextureManager().UnloadTexture(mData->mTrackTopTextureId);

        (&control().Env())->TextureManager().UnloadTexture(mData->mMarkerTextureId);

        (&control().Env())->TextureManager().UnloadTexture(mData->mZoomInTextureId);

        (&control().Env())->TextureManager().UnloadTexture(mData->mZoomOutTextureId);

        delete 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            

    layoutRect = MulSliderUtils::GetComponentRect(

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

    //get the lct rect for mImageMinus and set it            

    // aid_touch_size_slider_min(2) 

    layoutRect = MulSliderUtils::GetComponentRect(

            EVSliderMinus,mData->mBaseSliderLayout,KVariety2);

    mData->mImageMinus->SetRect(

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

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

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

    //get the lct rect for mImagePlus and set it            

    // aid_touch_size_slider_max(1) 

    layoutRect = MulSliderUtils::GetComponentRect(

            EVSliderPlus,

            mData->mBaseSliderLayout,

            KVariety1);

    mData->mImagePlus->SetRect(

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

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

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

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

    //get the lct rect for mSliderCentre and set it     

    //aaslider_bg_pane_cp001(6)

    layoutRect = MulSliderUtils::GetComponentRect(

            EVSliderBgPane,

            mData->mBaseSliderLayout,

            KVariety6);

    mData->mSliderCentre->SetRect(

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

                    layoutRect.Rect().iTl.iY),

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

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

    //get the lct rect for mTrackTopImage and set it     

    //aaslider_bg_pane_cp001_g1(0)

    layoutRect = MulSliderUtils::GetComponentRect(

            EVSliderTop,

            mData->mSliderCentre,

            KVariety0);

    mData->mTrackTopImage->SetRect(

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

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

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

    //get the lct rect for mTrackMiddleImage and set it     

    //aaslider_bg_pane_cp001_g3(0)

    layoutRect = MulSliderUtils::GetComponentRect(

            EVSliderMiddle,

            mData->mSliderCentre,

            KVariety0);

    mData->mTrackMiddleImage->SetRect(

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

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

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

    //get the lct rect for mTrackEndImage and set it     

    //aaslider_bg_pane_cp001_g2(0)

    layoutRect = MulSliderUtils::GetComponentRect(

            EVSliderEnd,

            mData->mSliderCentre,

            KVariety0);

    mData->mTrackEndImage->SetRect(

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

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

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

    if(mData->mTrackTopImage && 

                    mData->mTrackMiddleImage && 

                    mData->mTrackEndImage)

                {

                setTrackImage();

                }

    if(mData->mSliderHandle)

        {

        mData->mImageTextureId = KAlfMarkerTextureId;

        // Create the texture from bitmap provider

        mData->mTexture = &((ctrl->Env()).TextureManager().CreateTextureL(

                KAlfAutoGeneratedTextureId/*KAlfMarkerTextureId*/,

                (MAlfBitmapProvider *)this,

                (TAlfTextureFlags)(EAlfTextureFlagRetainResolution|

                                   EAlfTextureFlagSkinContent)));

        TAlfImage aImage(*mData->mTexture );                                                

        mData->mSliderHandle->SetImage(aImage);

        }

    if(mData->mImagePlus)

        {

        mData->mImageTextureId = KAlfZoomInTextureId;

        // Create the texture from bitmap provider

        mData->mTexture = &((ctrl->Env()).TextureManager().CreateTextureL(

                KAlfAutoGeneratedTextureId/*KAlfZoomInTextureId*/,

                (MAlfBitmapProvider *)this,

                (TAlfTextureFlags)(EAlfTextureFlagRetainResolution|EAlfTextureFlagSkinContent)));

        TAlfImage aImage(*mData->mTexture );

        mData->mImagePlus->SetImage(aImage);

        }

    if(mData->mImageMinus)

        {

        mData->mImageTextureId = KAlfZoomOutTextureId;

        // Create the texture from bitmap provider

        mData->mTexture = &((ctrl->Env()).TextureManager().CreateTextureL(

                KAlfAutoGeneratedTextureId/*KAlfZoomOutTextureId*/,

                (MAlfBitmapProvider *)this,

                (TAlfTextureFlags)(EAlfTextureFlagRetainResolution|EAlfTextureFlagSkinContent)));

        TAlfImage aImage(*mData->mTexture );

        mData->mImageMinus->SetImage(aImage);

        }

    }

    }

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

// Used for setting images for the track 

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

//

void MulSliderVertical::setTrackImage()

    {

    //Review

    TInt flags = EAlfTextureFlagSkinContent;

    flags |= EAlfTextureFlagAutoSize;

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

    //creating texture for topimage

    mData->mImageTextureId = KAlfTrackTopTextureId;

    mData->mTexture = &((ctrl->Env()).TextureManager().CreateTextureL(

        KAlfAutoGeneratedTextureId/*KAlfTrackTopTextureId*/,

        (MAlfBitmapProvider *)this,

        (TAlfTextureFlags)(EAlfTextureFlagRetainResolution|EAlfTextureFlagSkinContent)));

    TAlfImage trackTopImage(*mData->mTexture );

    //creating texture for middleimage

    mData->mImageTextureId = KAlfTrackMiddleTextureId;

    mData->mTexture = &((ctrl->Env()).TextureManager().CreateTextureL(

        KAlfAutoGeneratedTextureId/*KAlfTrackMiddleTextureId*/,

        (MAlfBitmapProvider *)this,

        (TAlfTextureFlags)(EAlfTextureFlagRetainResolution|EAlfTextureFlagSkinContent)));

    TAlfImage trackMiddleImage(*mData->mTexture );

    //creating texture for bottom image

    mData->mImageTextureId = KAlfTrackBottomTextureId;

    mData->mTexture = &((ctrl->Env()).TextureManager().CreateTextureL(

        KAlfAutoGeneratedTextureId/*KAlfTrackBottomTextureId*/,

        (MAlfBitmapProvider *)this,

        (TAlfTextureFlags)(EAlfTextureFlagDefault)));

    TAlfImage trackEndImage(*mData->mTexture );

    // Set Image on visuals

    mData->mTrackTopImage->SetImage(trackTopImage);

    mData->mTrackMiddleImage->SetImage(trackMiddleImage);                    

    mData->mTrackEndImage->SetImage(trackEndImage);

    }//End of setImage

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

// ProvideBitmapL()

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

//

void MulSliderVertical::ProvideBitmapL (TInt aId, CFbsBitmap *& aBitmap, CFbsBitmap *& aMaskBitmap)

    {

    TAknLayoutRect layoutRect;

    switch(mData->mImageTextureId)

        {

        case KAlfTrackTopTextureId:

            {

            AknIconUtils::CreateIconL(

                   aBitmap,

                   aMaskBitmap,

                   KAvkonBitmapFile,

                   EMbmAvkonQgn_graf_nslider_vertical_top,

                   EMbmAvkonQgn_graf_nslider_vertical_top_mask );

           layoutRect = MulSliderUtils::GetComponentRect(

                   EVSliderTop,

                   mData->mSliderCentre,

                   KVariety0); 

           AknIconUtils::SetSize( aBitmap,

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