/*

* Copyright (c) 2007-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 slider model interface

 *

*/

//Class headers

#include "mulslidermodel.h"

// Alf headers

#include <alf/alfmodel.h>

#include <alf/alfutil.h>

#include <mul/mulvarianttype.h>

// Osn Headers

#include <osn/osnnew.h>  //for new(EMM)

#include <osn/ustring.h>

#include <mul/mulvisualitem.h>

#include <mul/imulsliderwidget.h>

#include <string.h>

// For Common strings

#include "mulslidervertical.h"

#include "mulsliderwidget.h"

const int KMaxrange = 100;

const int KTick = 1;

const int KSize = 50; 

namespace Alf

{

struct SliderModelDataImpl

	{

	int mSldMaxRange;// Slider Maximum Value

	int mSldMinRange;// Slider Maximum Value

	int mSldTick;//  Size of single click movement

	int mSldPrimaryTick;// Current Handle Position

	int mSldSecondaryTick;// Secondary progress position

	char* mSldLeftText;// Left text

	char* mSldRightText;// Right text

	char* mSldPercentText;// Percentage text for zoom slider

	MulSliderWidget* mSliderWidget;

    IMulSliderBaseElementInternal * mSliderElement;// Element pointer 

    sliderTemplate mTemplateId; // template ID 

	std::auto_ptr<MulVisualItem> mItem; 

	SliderModelDataImpl()

    	{

    	mItem = ( new (EMM) MulVisualItem() );	

    	mSldMaxRange = KMaxrange;

    	mSldMinRange = 0;

    	mSldTick = KTick;

    	mSldPrimaryTick = 0;

    	mSldSecondaryTick = 0;

    	mSldLeftText = NULL;

    	mSldRightText =NULL;

    	mSldPercentText = NULL;

    	mSliderWidget = NULL;

    	mSliderElement = NULL;

    	mTemplateId = ESliderTemplateNone;

    	}

	};

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

// Constructor 

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

//

MulSliderModel::MulSliderModel():

mModel ( NULL )

	{

	mSldrModelData = new(EMM)SliderModelDataImpl();

	}

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

// Destructor 

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

//

MulSliderModel::~MulSliderModel()

	{

	if(mSldrModelData)	  

	    {

	    delete mSldrModelData;

	    }

	else

	    {

	    }

	}		

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

// SetData 

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

// 

void MulSliderModel::SetData(const MulVisualItem& aSliderItem)

    {

    UString str;    

    if(aSliderItem.Attribute(mulvisualitem::KMulMaxRange))

        {

        SetMaxRange(

            aSliderItem.AttributeAsInt(mulvisualitem::KMulMaxRange));

        }

    if(aSliderItem.Attribute(mulvisualitem::KMulMinRange))

        {

        SetMinRange(

            aSliderItem.AttributeAsInt(mulvisualitem::KMulMinRange));

        }

    if(aSliderItem.Attribute(mulvisualitem::KMulTick))

           {

           SetTick(aSliderItem.

               AttributeAsInt(mulvisualitem::KMulTick));

           }    

    if(aSliderItem.Attribute(mulvisualitem::KMulPrimaryTick))

        {

        SetPrimaryValue(aSliderItem.

            AttributeAsInt(mulvisualitem::KMulPrimaryTick));

        }

    if(aSliderItem.Attribute(mulvisualitem::KMulSecondaryTick))

        {

        SetSecondaryValue(aSliderItem.

            AttributeAsInt(mulvisualitem::KMulSecondaryTick));

        }

    if(aSliderItem.Attribute(mulvisualitem::KMulPercent1))

            {

            int percentValue = aSliderItem.

                AttributeAsInt(mulvisualitem::KMulPercent1);

            _LIT8(KPercent,"");

         	TBuf8<KSize> PercentText(KPercent);

         	PercentText.AppendNum (percentValue);

         	PercentText.Append(_L("%"));

         	mSldrModelData->mSldPercentText = (char*)PercentText.PtrZ();

            }

     UpdateElement();

    }     

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

// Return MulVisual Item  

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

//

const MulVisualItem& MulSliderModel::Data() const

	{

	mSldrModelData->mItem->SetAttribute ( mulvisualitem::KMulMaxRange,

	                (int)mSldrModelData->mSldMaxRange);

	mSldrModelData->mItem->SetAttribute ( mulvisualitem::KMulMinRange, 

	                (int)mSldrModelData->mSldMinRange);

	mSldrModelData->mItem->SetAttribute ( mulvisualitem::KMulTick, 

	                (int)mSldrModelData->mSldTick);

	mSldrModelData->mItem->SetAttribute ( mulvisualitem::KMulPrimaryTick, 

	                (int)mSldrModelData->mSldPrimaryTick);

	mSldrModelData->mItem->SetAttribute ( mulvisualitem::KMulSecondaryTick, 

	                (int)mSldrModelData->mSldSecondaryTick);	

	mSldrModelData->mItem->SetAttribute ( mulvisualitem::KMulCounter1,

	                (int)mSldrModelData->mSldLeftText );

	mSldrModelData->mItem->SetAttribute ( mulvisualitem::KMulCounter2, 

	                (int)mSldrModelData->mSldRightText );

	mSldrModelData->mItem->SetAttribute ( mulvisualitem::KMulPercent1, 

	                (int)mSldrModelData->mSldPercentText );

	return *(mSldrModelData->mItem);

   }

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

// SetValue 

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

//

void MulSliderModel::SetPrimaryValue(int aValue)

    { 

	int maxRange = mSldrModelData->mSldMaxRange;	

    int minRange = mSldrModelData->mSldMinRange;	

    // Validate aValue 

    if(aValue != mSldrModelData->mSldPrimaryTick)

        {

        if( (aValue >= minRange) && (aValue <= maxRange))

    		{

    		mSldrModelData->mSldPrimaryTick = aValue;

    		}

        else if(aValue <= minRange)

            {

    		mSldrModelData->mSldPrimaryTick = minRange;

    		}

    	else if(aValue >= maxRange)

    	    {

    	    mSldrModelData->mSldPrimaryTick = maxRange;

    	    }

    	// Update the visualization	

    	if(GetElement())

    	    {

            GetElement()->updateVisualization();	

    	    }        

	    }

    }

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

// Gets the Slider Element 

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

//

IMulSliderBaseElementInternal* MulSliderModel::GetElement() 

    {

    if(mSldrModelData->mSliderWidget)

        {

        return mSldrModelData->mSliderWidget->GetSliderElement();  

        }

    else

        {

        }

    return NULL;  

    }

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

// update element visualization 

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

//

void MulSliderModel::UpdateElement() 

    {

    if(mSldrModelData->mSliderWidget)

        {

   		if(mSldrModelData->mSliderWidget->GetSliderElement())

	   		{

		    mSldrModelData->mSliderWidget->GetSliderElement()->updateVisualization();

	   		}

	    }

    }

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

// Value 

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

//

int MulSliderModel::PrimaryValue() const

    {

    return mSldrModelData->mSldPrimaryTick;

    }

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

// SetValue 

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

//

void MulSliderModel::SetSecondaryValue(int aValue)

    { 

  	int maxRange = mSldrModelData->mSldMaxRange;	

    int minRange = mSldrModelData->mSldMinRange;	

    if(mSldrModelData->mSldSecondaryTick != aValue)

        {

        // Validate aValue

        if( (aValue >= minRange) && (aValue <= maxRange))

    		{

    		mSldrModelData->mSldSecondaryTick = aValue;

    		}

    	UpdateElement();

        }

    }

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

// Value 

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

//

int MulSliderModel::SecondaryValue() const

    {

    return mSldrModelData->mSldSecondaryTick;

    }

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

// TotalTicks 

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

//

int MulSliderModel::TotalTicks() const

    {

    //MUL_LOG_INFO("CMulSliderModel::TotalTicks");

    int maxRange = mSldrModelData->mSldMaxRange;	

    int minRange = mSldrModelData->mSldMinRange;	

    int tick     = mSldrModelData->mSldTick;

    if(tick == 0)

        {

        tick = 1;

        }

    return ((maxRange-minRange)/tick);

    }

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

// SetTemplate 

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

//

void MulSliderModel::SetTemplate( sliderTemplate aTemplateId)

    {

    if(mSldrModelData->mTemplateId != aTemplateId)

        {

    	mSldrModelData->mTemplateId = aTemplateId; 

    	if(mSldrModelData->mSliderWidget)

            {

            // Change the tempate 

            mSldrModelData->mSliderWidget->changeTemplate(aTemplateId);

            }

        else 

            {

            //do nothing

            }	

        }

    }

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

// makeInterface

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

//

IAlfInterfaceBase* MulSliderModel::makeInterface( const IfId& aType)

    {

    //MUL_LOG_INFO("CMulSliderModel::makeInterface");

    IAlfInterfaceBase* ret(0);

      UString param(aType.mImplementationId);

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

          {

          ret = static_cast<IMulSliderModel*>(this);

          }

      else if(param == IAlfModel::type().mImplementationId)

          {

          ret = static_cast<IAlfModel*>(this);

          }

      return ret;      

    }

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

// SetMinRange 

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

//

void MulSliderModel::SetMinRange(int aMinRange)

	{

	// Validate aMinRange

	if(aMinRange != mSldrModelData->mSldMinRange)

	    {

	    mSldrModelData->mSldMinRange = aMinRange;

	   if(aMinRange > mSldrModelData->mSldMaxRange)

	       {

	       mSldrModelData->mSldMaxRange = aMinRange;

	       mSldrModelData->mSldTick = 0;

	       }

	   else

	       {

	       if(mSldrModelData->mSldTick > mSldrModelData->mSldMaxRange - mSldrModelData->mSldMinRange || mSldrModelData->mSldTick == 0)

              {

              mSldrModelData->mSldTick = mSldrModelData->mSldMaxRange - mSldrModelData->mSldMinRange; 

              }

	       }

	       mSldrModelData->mSldPrimaryTick = aMinRange;

        UpdateElement();	  

        }

	}

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

// SetMaxRange 

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

//

void MulSliderModel::SetMaxRange(int aMaxRange)

	{

	if(aMaxRange != mSldrModelData->mSldMaxRange)

	    {

	    mSldrModelData->mSldMaxRange = aMaxRange;

	    if(aMaxRange < mSldrModelData->mSldMinRange)

	        {

	        mSldrModelData->mSldMinRange = aMaxRange;

	        mSldrModelData->mSldTick = 0;

	        }

	    else

	        {

	        if(mSldrModelData->mSldTick > mSldrModelData->mSldMaxRange - mSldrModelData->mSldMinRange || mSldrModelData->mSldTick == 0 )

                {

                mSldrModelData->mSldTick = mSldrModelData->mSldMaxRange - mSldrModelData->mSldMinRange; 

                }

	        }

	    mSldrModelData->mSldPrimaryTick = mSldrModelData->mSldMinRange;

        UpdateElement();	    

        }

    }

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

// MinRange 

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

//

int MulSliderModel::MinRange() const

	{

	//MUL_LOG_INFO("CMulSliderModel::makeInterface");		

	return mSldrModelData->mSldMinRange;	

	}

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

// MaxRange 

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

//

int MulSliderModel::MaxRange() const

	{

	//MUL_LOG_INFO("CMulSliderModel::makeInterface");		

	return mSldrModelData->mSldMaxRange;	

	}

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

// SetTick 

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

//

void MulSliderModel::SetTick(int aTick)

	{

	//MUL_LOG_INFO("CMulSliderModel::makeInterface");

	if(aTick != mSldrModelData->mSldTick && aTick > 0) 

	    {

        if(aTick > mSldrModelData->mSldMaxRange - mSldrModelData->mSldMinRange)

    	    {

    	    mSldrModelData->mSldTick = mSldrModelData->mSldMaxRange - mSldrModelData->mSldMinRange;	

    	    }

    	else

    	    {

    	    mSldrModelData->mSldTick = aTick;

    	    }

        mSldrModelData->mSldPrimaryTick = mSldrModelData->mSldMinRange;

    	if(GetElement())

    	    {

    	    GetElement()->updateVisualization();

    	    }	    

	    }

	}

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

// Tick 

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

//

int MulSliderModel::Tick() const

	{

	//MUL_LOG_INFO("CMulSliderModel::makeInterface");		

	return mSldrModelData->mSldTick;	

	}

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

// SetRightText 

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

//

void MulSliderModel::SetRightText(char* aRightText)

	{

	if(aRightText)

	    {

	    mSldrModelData->mSldRightText = aRightText;

	    UpdateElement();

	    }

	}

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

// SetLeftText 

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

//

void MulSliderModel::SetLeftText(char* aLeftText)

	{

    if(aLeftText)

	    {

	    mSldrModelData->mSldLeftText = aLeftText;

	    UpdateElement();

	    }

	}

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

// SetPercentText 

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

//

void MulSliderModel::SetPercentText(char* aPercText)

	{

	if(aPercText)

	    {

	    mSldrModelData->mSldPercentText = aPercText;

	    if(GetElement())

	    {

	    GetElement()->updateTextVisualization();	

	    }

	    }

	}

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

// GetRightText 

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

//

const char* MulSliderModel::GetRightText()

	{

	//MUL_LOG_INFO("CMulSliderModel::makeInterface");		

	return mSldrModelData->mSldRightText;	

	}

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

// GetLeftText 

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

//

const char* MulSliderModel::GetLeftText()

	{