/*

* 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- progressbar.

*

*/

//Toolkit Includes

#include <alf/alfimagevisual.h>

#include <alf/alfevent.h>

// Alfred Client includes

#include <alf/alfenv.h>

#include <alf/alftexture.h> 

#include <alf/alftextvisual.h>

#include <alf/alflayout.h>

#include <aknconsts.h>

#include <avkon.mbg>

//Widget Model Includes

#include <alf/alfwidgetenvextension.h>

//Avkon Includes

#include <AknUtils.h>

#include <AknsConstants.h>

#include <utf.h>

//OpenC Includes

#include <math.h>

//slider widget includes

#include "mulprogressbarslider.h"

#include "mulutility.h"

#include "mulsliderutils.h"

#include "mulsliderwidget.h"

#include "mulslidermodel.h"

#include "mulsliderdefinitions.h"

// Textureid's used for comparison 

const TInt KAlfProgressBarTextureId = 1;

const TInt KAlfFrameLeftTextureId = 2;

const TInt KAlfFrameCentreTextureId = 3;

const TInt KAlfFrameRightTextureId = 4;

namespace Alf

    {

// Structure to store data for the progressbar element class  

struct MulSliderProgressBarImpl

	{		

	int mMaxRange; //Store Max range for progressbar from model   

    int mMinRange;  //Store Min range for progressbar from model

    int mTempMin; //Temporary stores the min range 

    int mTempMax; //Temporary stores the max range  

    int mTick;    // Store Tick value for progressbar from model 

    int mImageTextureId; // to differtiate between textures

    bool mOrientationLandScape; // check for landscape 

  	sliderTemplate mTemplateId; //slider template id

  	CAlfLayout* mMainLayout; //slider main layout 

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

  	int mFrameLeftTextureId ;

  	int mFrameCentreTextureId;

  	int mFrameRightTextureId ;

  	CAlfLayout* mBaseSliderLayout;

  	CAlfImageVisual* mSliderProgressCentre;

	CAlfImageVisual* mSliderSecProgressCentre;

    CAlfImageVisual* mFrameLeftImage;

    CAlfImageVisual* mFrameRightImage;

    CAlfImageVisual* mFrameCentreImage;

    CAlfTexture* mTexture;

    MulSliderProgressBarImpl()

    {

    mTick = 0;    

    mMaxRange = 0;

    mMinRange = 0; 

    mTempMax = 0;

    mTempMin = 0; 

    mImageTextureId = 0;

    mTemplateId = ESliderTemplateNone;

    mProgressBarTextureId = 0;

    mFrameLeftTextureId = 0;

    mFrameCentreTextureId = 0;

    mFrameRightTextureId = 0;

    mBaseSliderLayout = NULL;

    mSliderProgressCentre = NULL;

    mSliderSecProgressCentre = NULL;

    mOrientationLandScape = false;

	}	    

	};  

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

//  MulSliderProgressive default constructor.

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

//

MulSliderProgressive::MulSliderProgressive(

                                    CAlfWidgetControl& aControl,

                                    const char* aName ,

                                    AlfCustomInitDataBase* /*aCustomData*/)

    : mData(NULL)

    {

    // Base class (AlfElement) construct

    construct(aControl, aName);

    mData = new (EMM) MulSliderProgressBarImpl;

    iBitmap = new (EMM) CFbsBitmap;

    // initializes the mSlliderModel and mSliderWidget  

    initializeSliderData();

    }

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

//  Destructor

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

//

MulSliderProgressive::~MulSliderProgressive()

    {

    // Visualization Data

    if(mData)

        {

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

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

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

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

        delete mData;

        delete iBitmap;

        }

    else

        {

        }

    }//End of Destructor

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

// From class MAlfInterfaceBase.

// Getter for interfaces provided by the slider widget.

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

//

IAlfInterfaceBase* MulSliderProgressive::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);

        }        

    IAlfInterfaceBase* interface = 0;

    interface = AlfElement::makeInterface(aType);

    return interface;

    }

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

// Gets called when the parent layout is relayouted.

// resets all the anchor points and updates the visualization

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

//

void MulSliderProgressive::baseLayoutSizeChanged()

    {

	mData->mMainLayout->ClearFlag(EAlfVisualFlagLayoutUpdateNotification);

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

	// Layout the visualization w.r.t. mainlayout 

	layoutVisuals(mSliderModel->GetTemplate());

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

    updateVisualization();

    }    

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

// From class IAlfWidgetEventHandler.

// setActiveStates

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

void MulSliderProgressive::setActiveStates(

    unsigned int /*aStates*/)

    {

  		  //do nothing

    }

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

//  initializes Model and Widget Pointer

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

//

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

    }

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

//  Bitmap provider  

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

//

void MulSliderProgressive::ProvideBitmapL (TInt aId, 

                                           CFbsBitmap *& aBitmap, 

                                           CFbsBitmap *& aMaskBitmap)

    {

    TAknLayoutRect layoutRect;

    switch(mData->mImageTextureId)

        {

        case KAlfProgressBarTextureId:

            {

            AknIconUtils::CreateIconL(

                    aBitmap, aMaskBitmap, KAvkonBitmapFile,

                    EMbmAvkonQgn_graf_bar_progress,

                    EMbmAvkonQgn_graf_bar_progress_mask ); 

            TInt aHandle = aBitmap->Handle();

            iBitmap->Duplicate(aHandle);

            AknIconUtils::SetSize( aBitmap,TSize(50,14),EAspectRatioNotPreserved);  

            mData->mImageTextureId = 0;

            mData->mProgressBarTextureId = aId;

            }

            break;

        case KAlfFrameLeftTextureId:

            {

            AknIconUtils::CreateIconL( 

                    aBitmap, aMaskBitmap, KAvkonBitmapFile,

                    EMbmAvkonQgn_graf_bar_frame_side_l,

                    EMbmAvkonQgn_graf_bar_frame_side_l_mask );

            layoutRect = MulSliderUtils::GetComponentRect(

                    EPSliderLeft,

                    mData->mMainLayout,

                    KVariety0);

            AknIconUtils::SetSize( aBitmap,TSize(layoutRect.Rect().Size().iWidth,

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

                    EAspectRatioNotPreserved);

            //  AknIconUtils::SetSize( aBitmap,TSize(7,17),EAspectRatioNotPreserved);

            mData->mImageTextureId = 0;

            mData->mFrameLeftTextureId = aId;

            }

            break;

        case KAlfFrameRightTextureId:

            {

            AknIconUtils::CreateIconL( 

                            aBitmap, aMaskBitmap, KAvkonBitmapFile,

                    EMbmAvkonQgn_graf_bar_frame_side_r,

                    EMbmAvkonQgn_graf_bar_frame_side_r_mask );

            layoutRect = MulSliderUtils::GetComponentRect(

                    EPSliderRight,

                    mData->mMainLayout,

                    KVariety0);    

            AknIconUtils::SetSize( aBitmap,TSize(layoutRect.Rect().Size().iWidth,

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

                    EAspectRatioNotPreserved);

            //  AknIconUtils::SetSize( aBitmap,TSize(7,17),EAspectRatioNotPreserved);

            mData->mImageTextureId = 0;

            mData->mFrameRightTextureId = aId;

            }

            break;

        case KAlfFrameCentreTextureId:

            {

            AknIconUtils::CreateIconL( 

                   aBitmap, aMaskBitmap, KAvkonBitmapFile,

                   EMbmAvkonQgn_graf_bar_frame_center,

                   EMbmAvkonQgn_graf_bar_frame_center_mask );

           layoutRect = MulSliderUtils::GetComponentRect(

                   EPSliderCentre,

                   mData->mMainLayout,

                   KVariety0);

            AknIconUtils::SetSize( aBitmap,TSize(layoutRect.Rect().Size().iWidth,

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

                   EAspectRatioNotPreserved);

            //  AknIconUtils::SetSize( aBitmap,TSize(308,17),EAspectRatioNotPreserved);

            mData->mImageTextureId = 0;

            mData->mFrameCentreTextureId = aId;

            }

        default:

            break;

        }

    }

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

// layoutVisuals

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

void MulSliderProgressive::layoutVisuals(sliderTemplate aTemplateid)

    {

       TAknLayoutRect layoutRect;

       mData->mTemplateId = aTemplateid;

       //Get the mainlayout rect 

       int mainX = mData->mMainLayout->Pos().iX.ValueNow();

       int mainY = mData->mMainLayout->Pos().iY.ValueNow();

       int mainWidth = mData->mMainLayout->Size().iX.ValueNow();

       int mainHeight = mData->mMainLayout->Size().iY.ValueNow();

       if (mData->mTemplateId == ESliderTemplate7 ) 

           {

        mData->mBaseSliderLayout->SetRect(

                TRect( TPoint(0,0 ),

                        TSize( mainWidth, mainHeight ))) ; 

        layoutRect = MulSliderUtils::GetComponentRect(

                EPSliderLeft,

                mData->mMainLayout,

                KVariety0);	   

        mData->mSliderProgressCentre->SetRect(

                TRect( TPoint(0,0),

                        TSize( 0, layoutRect.Rect().Size().iHeight ))) ; 

        mData->mFrameLeftImage->SetRect(

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

                        layoutRect.Rect().iTl.iY ),

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

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

        layoutRect = MulSliderUtils::GetComponentRect(

                EPSliderCentre,

                mData->mMainLayout,

                KVariety0);

        mData->mFrameCentreImage->SetRect(

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

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

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

        layoutRect = MulSliderUtils::GetComponentRect(

                EPSliderRight,

                mData->mMainLayout,

                KVariety0);

        mData->mFrameRightImage->SetRect(

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

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

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

           }

    }

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

// createVisualization

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

void MulSliderProgressive::createVisualization(sliderTemplate templateid)

    {

    mData->mTemplateId = templateid;

    CAlfControl  *ctrl = &control();

    // Visual Hierarchy creation

    mData->mMainLayout = CAlfLayout::AddNewL(*ctrl,NULL);

    mData->mMainLayout->SetFlag(EAlfVisualFlagLayoutUpdateNotification);

    mData->mMainLayout->SetFlag(EAlfVisualFlagAutomaticLocaleMirroringEnabled);

    mData->mBaseSliderLayout = CAlfLayout::AddNewL(*ctrl, mData->mMainLayout);

    mData->mBaseSliderLayout->SetFlag(EAlfVisualFlagAutomaticLocaleMirroringEnabled);

    mData->mSliderProgressCentre = CAlfImageVisual::AddNewL(

            *ctrl,mData->mBaseSliderLayout);

    mData->mFrameLeftImage = CAlfImageVisual::AddNewL(*ctrl,mData->mBaseSliderLayout);

    mData->mFrameCentreImage = CAlfImageVisual::AddNewL(*ctrl,mData->mBaseSliderLayout);

    mData->mFrameRightImage = CAlfImageVisual::AddNewL(*ctrl,mData->mBaseSliderLayout);

    if(mData->mFrameLeftImage)

        {

        mData->mImageTextureId = KAlfFrameLeftTextureId;

        // Create the texture from bitmap provider

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

                KAlfAutoGeneratedTextureId/*KAlfFrameLeftTextureId*/,

                (MAlfBitmapProvider *)this,

                (TAlfTextureFlags)(EAlfTextureFlagAutoSize|

                        EAlfTextureFlagSkinContent)));

        int height = mData->mTexture->Size().iHeight;

        int width = mData->mTexture->Size().iWidth;

        TAlfImage aImageLeft(*mData->mTexture );

        mData->mFrameLeftImage->SetImage(aImageLeft);

        //mData->mFrameLeftImage->SetOpacity(0.5);

        }

    if(mData->mFrameCentreImage)

        {

        mData->mImageTextureId = KAlfFrameCentreTextureId;

        // Create the texture from bitmap provider

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

                KAlfAutoGeneratedTextureId/*KAlfFrameCentreTextureId*/,

                (MAlfBitmapProvider *)this,

                (TAlfTextureFlags)(EAlfTextureFlagAutoSize|EAlfTextureFlagSkinContent)));

        int height = mData->mTexture->Size().iHeight;

        int width = mData->mTexture->Size().iWidth;

        TAlfImage aImageCentre(*mData->mTexture );

        mData->mFrameCentreImage->SetImage(aImageCentre);

        }

    if(mData->mFrameRightImage)

        {

        mData->mImageTextureId = KAlfFrameRightTextureId;

        // Create the texture from bitmap provider

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

                KAlfAutoGeneratedTextureId/*KAlfFrameRightTextureId*/,

                (MAlfBitmapProvider *)this,

                (TAlfTextureFlags)(EAlfTextureFlagAutoSize|EAlfTextureFlagSkinContent)));

        int height = mData->mTexture->Size().iHeight;

        int width = mData->mTexture->Size().iWidth;

        TAlfImage aImageRight(*mData->mTexture );

        mData->mFrameRightImage->SetImage(aImageRight);

        }

    if(mData->mSliderProgressCentre)

        {

        mData->mImageTextureId = KAlfProgressBarTextureId;

        // Create the texture from bitmap provider

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

                KAlfAutoGeneratedTextureId/*KAlfProgressBarTextureId*/,

                (MAlfBitmapProvider *)this,

                (TAlfTextureFlags)(EAlfTextureFlagAutoSize|EAlfTextureFlagSkinContent)));

        int height = mData->mTexture->Size().iHeight;

        int width = mData->mTexture->Size().iWidth;

        TAlfImage aImage(*mData->mTexture );

        mData->mSliderProgressCentre->SetImage(aImage);

        }

    }

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

// OfferEvent

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

//

AlfEventStatus MulSliderProgressive::offerEvent( 

    CAlfWidgetControl&/* aControl*/, 

    const TAlfEvent& /*aEvent*/ )

    {	

     // progress bar doesnt have any event handling 

	 return EEventNotHandled;

    }  

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

// UpdateVisualization

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

void MulSliderProgressive::updateVisualization()

    {

    // Call to function to set relative 

	//values for ranges if min range is not zero

    NormalizeRange();

    int currTick = mSliderModel->PrimaryValue();

    // Calculating the relative currtick if the MinRange is not zero.

    if (currTick >0 )

    	{

    	currTick = currTick - mData->mTempMin;	

    	}

    // Set the new thumbimage position.

    SetTickPosition(currTick);

    }

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

// NormalizeRange

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

 void MulSliderProgressive::NormalizeRange()   

	{

	mData->mMaxRange = mSliderModel->MaxRange();

	mData->mMinRange = mSliderModel->MinRange();

	mData->mTick = mSliderModel->Tick();

	mData->mTempMax = mData->mMaxRange;

	mData->mTempMin = mData->mMinRange;

	mData->mMaxRange = mData->mMaxRange - mData->mMinRange;

	mData->mMinRange = 0;		 	

    }

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

// accept

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

// 

bool MulSliderProgressive::accept(

    CAlfWidgetControl& /*aControl*/, 

    const TAlfEvent& /*aEvent*/) const

	{

		 return false;	

	}

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

//MulSliderProgressive eventHandlerType

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

IAlfWidgetEventHandler::AlfEventHandlerType MulSliderProgressive::

    eventHandlerType()

    {

    return IAlfWidgetEventHandler::EPresentationEventHandler;

    }

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

//MulSliderProgressive eventExecutionPhase

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