/*

* 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:  The implementation for presentation elements.

*

*/

#include <avkon.hrh>

#include <avkon.mbg> 

//Toolkit Includes

// Alfred Client includes

#include <alf/alfenv.h>

#include <alf/alfroster.h>

#include <alf/alfdisplay.h>

#include <alf/alfbitmapprovider.h>

#include <alf/alftexture.h> 

#include <alf/alfbrusharray.h>

#include <alf/alftextvisual.h>

#include <alf/alfevent.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 <math.h>

//slider widget includes

#include <mul/mulevent.h>

#include "mulsliderhorizontal.h"

#include "mulsliderwidget.h"

#include "mulslidercontrol.h"

#include "mulslidermodel.h"

#include "mulsliderdefinitions.h"

#include "mulsliderutils.h"

//Timer function includes

#include "mulsliderlongtaptimer.h"

namespace Alf

    {

// Structure to store data for the slider element class    

 struct MulHorizontalSliderDataImpl

     {

     bool mOperation;// Drag state	

     float mTickInPixels;// Tick size in Pixel

     bool mIsLongTapObserverSet;// Is LongTap Event observer set

     CAlfVisual * mVisual;// Stores thje current visual hit 

     TPoint mDragPoint;// Point at which drag started 

     TPoint mLongTapPos;// Point at which button down happened 

     bool mLongTapStarted;// Long tap timer started (true)

     int mDragStartStep;// Tick positon of Drag Start

     int mCurrTick;// Stores current tick

     int mTrackStartPoint;// Slider Track Start Point in pixel

     int mTick;// Stores Tick Size

     bool mLayoutMirrored;// 

     int mdirection;// 0 - nomovement,1 left movement 2 right

     int mImageTextureId; // to differtiate between textures 

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

     int mTrackBottomTextureId;

     int mTrackMiddleTextureId;

     int mMarkerTextureId;

     // Visualization Layouts

     CAlfLayout* mMainLayout;

     CAlfLayout* mBaseSliderLayout;

     CAlfLayout* mSliderCentre;

     CAlfImageVisual* mTrackLeftImage;

     CAlfImageVisual* mTrackMiddleImage;

     CAlfImageVisual* mTrackRightImage;

     CAlfLayout* mSliderCentreGhost;

     CAlfImageVisual* mSliderHandle;

     CAlfLayout* mSliderHandleGhost;

     CAlfImageVisual* mSliderProgressDownload;

     CAlfImageVisual* mSliderProgressCentre;

     CAlfTexture* mTexture;

     MulHorizontalSliderDataImpl()

         {

         mOperation = 0;	

         mTickInPixels = 0;

         mIsLongTapObserverSet = 0;

         mDragPoint.SetXY(0,0) ;

         mLongTapPos.SetXY(0,0);

         mLongTapStarted = 0;

         mDragStartStep = 0;

         mCurrTick = 0;

         mTrackStartPoint = 0;

         mImageTextureId = 0;

         mTrackTopTextureId = 0 ;

         mTrackBottomTextureId = 0;

         mTrackMiddleTextureId = 0;

         mMarkerTextureId = 0;

         mVisual = NULL;

         mMainLayout = NULL;

         mBaseSliderLayout = NULL;  

         mSliderCentre = NULL;

         mSliderHandle = NULL;

         mSliderProgressCentre = NULL;

         mBaseSliderLayout     = NULL;       

         mSliderCentreGhost = NULL;

         mSliderHandleGhost = NULL;   

         mLayoutMirrored = false;  

         mdirection = 0;

         } 

     };

 // Bitmaps for slider

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

//_LIT(KImageViewerBitmapFile,"\\resource\\apps\\ImageViewer.mif");

// Bitmap Texture ID

const TInt KAlfTrackTopTextureId = 1;

const TInt KAlfTrackBottomTextureId = 2;

const TInt KAlfTrackMiddleTextureId = 3;

const TInt KAlfMarkerTextureId = 4;

//const TInt KAlfMarkerSelectedTextureId = 5;

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

//  C++ default constructor.

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

//

MulSliderHorizontal::MulSliderHorizontal(

                                    CAlfWidgetControl& aControl,

                                    const char* aName, 

                                    AlfCustomInitDataBase* /*aCustomData*/)

    : mData(NULL)

    {

    // Base class (AlfElement) construct

    construct(aControl, aName);

    mData = new (EMM) MulHorizontalSliderDataImpl;

	mPosData.reset(new(EMM)MulSliderPos);

	// Timer for generating tap and hold repeat events  

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

    mDragVisual = NULL; 

    mSliderModel = NULL;

    mSliderWidget = NULL; 

    // Store the widget and model pointer

    initializeSliderData();  

    }

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

//  Destructor

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

//

MulSliderHorizontal::~MulSliderHorizontal()

    {

    if(mData)

        {

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

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

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

        // (&control().Env())->TextureManager().UnloadTexture(KAlfMarkerSelectedTextureId);

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

        // Visualization Data

        delete mData;

        }

    else

        {

        }

    }//End of Destructor

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

// From class MAlfInterfaceBase.

// Getter for interfaces provided by the slider widget.

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

//

IAlfInterfaceBase* MulSliderHorizontal::makeInterface(

                        const IfId& aType)

    {

    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

        {

        return AlfElement ::makeInterface(aType);

        }  

    }

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

// APIs from the IMulSliderBaseElement 

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

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

// Gets called when the parent layout is relayouted.

// resets all the anchor points and updates the visualization

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

//

void MulSliderHorizontal::baseLayoutSizeChanged()

    {

    mData->mMainLayout->ClearFlag(EAlfVisualFlagLayoutUpdateNotification); 

    if(mData->mMainLayout)

        {

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

        if(!mSliderModel->IsLandscape())

            {

            if(mSliderWidget->GetOpacity())

                {

                TAlfTimedValue opacity(1,0);

                mData->mMainLayout->SetOpacity(opacity);

                }

            }

        else

            {

            TAlfTimedValue opacity(0,0);

            mData->mMainLayout->SetOpacity(opacity);

            } 

        } 

    mData->mMainLayout->SetFlag(EAlfVisualFlagLayoutUpdateNotification);   

    }

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

// From class IAlfWidgetEventHandler.

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

//  

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

//  Destructor

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

//

void MulSliderHorizontal::setActiveStates(

    unsigned int /*aStates*/)

    {

    //do nothing

    }

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

//  initializes Model and Widget Pointer

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

//

void  MulSliderHorizontal::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());

    }

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

// layoutVisuals

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

// 

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

    {

    // TAknLayoutRect to store the Lct rect 

    TAknLayoutRect layoutRect;

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

    //get the lct rect for mBaseSliderLayout and set it 

    //aacf_slider_pane(0)

    layoutRect = MulSliderUtils::GetComponentRect(

            EHSliderPane, 

            mData->mMainLayout,

            KVariety0);

    mData->mBaseSliderLayout->SetRect(

            TRect( TPoint( 0,0 ),

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

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

    mData->mSliderCentreGhost->SetRect(

            TRect( TPoint( 0,0 ),

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

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

    //get the lct rect for mSliderCentre and set it 

    //aaslider_bg_pane(0)

    layoutRect = MulSliderUtils::GetComponentRect(

            EHSliderCenter,

            mData->mBaseSliderLayout,

            KVariety0);

    mData->mSliderCentre->SetRect(

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

                    layoutRect.Rect().iTl.iY ),

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

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

    //TAknLayoutRect handleGostRect = layoutRect;    

    //get the lct rect for mSliderHandle and set it 

    //aacf_slider_pane_g1(0)

    layoutRect = MulSliderUtils::GetComponentRect(

            EHSliderHandle,mData->mBaseSliderLayout,KVariety1);

    // This is a correction since the handle LCT data is not correct

   /* mData->mSliderHandle->SetRect(

            TRect( TPoint(handleGostRect.Rect().iTl.iX + 

                    (handleGostRect.Rect().Size().iWidth - 

                            layoutRect.Rect().Size().iWidth)/2    ,

                            handleGostRect.Rect().iTl.iY + 

                            (handleGostRect.Rect().Size().iHeight -

                                    layoutRect.Rect().Size().iHeight)/2 ),

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

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

    mData->mSliderHandle->SetRect(

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

                        layoutRect.Rect().iTl.iY ),

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

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

    mData->mSliderHandleGhost->SetRect(

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

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

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

                               mData->mBaseSliderLayout->Size().iY.ValueNow() ))) ;

    //get the lct rect for mTrackLeftImage and set it 

    //aaslider_bg_pane_g1(0)  

    layoutRect = MulSliderUtils::GetComponentRect(

            EHSliderLeft,mData->mSliderCentre,0);

    mData->mTrackLeftImage->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 mTrackMiddleImage and set it 

    //aaslider_bg_pane_g2_copy1(0)

    layoutRect = MulSliderUtils::GetComponentRect(

            EHSliderCentre,mData->mSliderCentre,0);

    mData->mTrackMiddleImage->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 mTrackRightImage and set it 

    //aaslider_bg_pane_g2(0)

    layoutRect = MulSliderUtils::GetComponentRect(

            EHSliderRight,mData->mSliderCentre,0);

    mData->mTrackRightImage->SetRect(

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

                    layoutRect.Rect().iTl.iY ),

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

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

    if(mData->mTrackLeftImage && 

            mData->mTrackMiddleImage && 

            mData->mTrackRightImage)

        {

        setTrackImage();

        }

    if(mData->mSliderHandle)

        {

        mData->mImageTextureId = KAlfMarkerTextureId;

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

                KAlfAutoGeneratedTextureId/*KAlfMarkerTextureId*/,

                (MAlfBitmapProvider *)this,

                (TAlfTextureFlags)(EAlfTextureFlagRetainResolution|EAlfTextureFlagSkinContent)));

        TAlfImage markerImage(*mData->mTexture );

        mData->mSliderHandle->SetImage(markerImage);

        }

    }

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

// Used for setting images for the track 

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

//

void MulSliderHorizontal::setTrackImage()

    {

    TInt flags = EAlfTextureFlagSkinContent;

    flags |= EAlfTextureFlagAutoSize;

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

    //create texture for leftimage

    mData->mImageTextureId = KAlfTrackTopTextureId;

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

            KAlfAutoGeneratedTextureId/*KAlfTrackTopTextureId*/,

            (MAlfBitmapProvider *)this,

            (TAlfTextureFlags)(EAlfTextureFlagRetainResolution|

                    EAlfTextureFlagSkinContent)));

    TAlfImage trackLeftImage(*mData->mTexture );

    //create texture for middleimage

    mData->mImageTextureId = KAlfTrackMiddleTextureId;

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

            KAlfAutoGeneratedTextureId/*KAlfTrackMiddleTextureId*/,

            (MAlfBitmapProvider *)this,

            (TAlfTextureFlags)(EAlfTextureFlagRetainResolution|

                    EAlfTextureFlagSkinContent)));

    TAlfImage trackMiddleImage(*mData->mTexture );

    //create texture for right image

    mData->mImageTextureId = KAlfTrackBottomTextureId;

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

            KAlfAutoGeneratedTextureId/*KAlfTrackBottomTextureId*/,

            (MAlfBitmapProvider *)this,

            (TAlfTextureFlags)(EAlfTextureFlagRetainResolution|

                    EAlfTextureFlagSkinContent)));

    TAlfImage trackRightImage(*mData->mTexture );

    // Set Image on visuals

    if(AknLayoutUtils::LayoutMirrored())

        {

        mData->mTrackLeftImage->SetImage(trackRightImage);

        mData->mTrackRightImage->SetImage(trackLeftImage);

        }

    else

        {

        mData->mTrackLeftImage->SetImage(trackLeftImage);

        mData->mTrackRightImage->SetImage(trackRightImage);

        }

    mData->mTrackMiddleImage->SetImage(trackMiddleImage); 

    }//End of setImage

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

// ProvideBitmapL()

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

//

void MulSliderHorizontal::ProvideBitmapL (TInt aId, 

                                         CFbsBitmap *& aBitmap, 

                                         CFbsBitmap *& aMaskBitmap)

    {

    TAknLayoutRect layoutRect;

    TRect rect;

    TSize size;

    switch(mData->mImageTextureId)

        {

        case KAlfTrackTopTextureId:

            {

            AknIconUtils::CreateIconL(

                   aBitmap,

                   aMaskBitmap,

                   KAvkonBitmapFile,

                   EMbmAvkonQgn_graf_nslider_end_left,

                   EMbmAvkonQgn_graf_nslider_end_left_mask );

            layoutRect = MulSliderUtils::GetComponentRect(

                   EHSliderLeft,mData->mSliderCentre,KVariety0);

            AknIconUtils::SetSize( aBitmap,

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

                           layoutRect.Rect().Size().iHeight),

                           EAspectRatioNotPreserved);

            mData->mImageTextureId = 0;

            mData->mTrackTopTextureId = aId;

            }

            break;

        case KAlfTrackBottomTextureId:

            {

            AknIconUtils::CreateIconL(

                    aBitmap,

                    aMaskBitmap,

                    KAvkonBitmapFile,

                    EMbmAvkonQgn_graf_nslider_end_right,

                    EMbmAvkonQgn_graf_nslider_end_right_mask );

            layoutRect = MulSliderUtils::GetComponentRect(

                    EHSliderRight,

                    mData->mSliderCentre,

                    KVariety0);

            AknIconUtils::SetSize( aBitmap,

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

                            layoutRect.Rect().Size().iHeight),

                            EAspectRatioNotPreserved);

            mData->mImageTextureId = 0;

            mData->mTrackBottomTextureId = aId;

            }

            break;

        case KAlfTrackMiddleTextureId:

            {

            AknIconUtils::CreateIconL(

                    aBitmap,

                    aMaskBitmap,

                    KAvkonBitmapFile,

                    EMbmAvkonQgn_graf_nslider_middle,

                    EMbmAvkonQgn_graf_nslider_middle_mask );