/*

* 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 for slider widget.

 *

*/

// Alfred Client includes

#include <alf/alfenv.h>

// Widget Model includes

#include "alf/alfelement.h"

// Widget Includes

#include "imulsliderbaseelementinternal.h"

#include <mul/mulsliderproductids.h>

// Internal includes

#include "mulslidervertical.h"

#include "mulsliderwidget.h"

#include "mulslidermodel.h"

#include "mulslidercontrol.h"

#include <alf/alfwidgetenvextension.h>

using namespace mulsliderwidget;

using Alf::CommonWidgetEvent;

namespace Alf

    {

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

//  Creator Method.

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

//        

MulSliderWidget* MulSliderWidget :: create(

    CAlfEnv& aEnv, 

    IAlfContainerWidget& aContainer,

    const char* aWidgetId, 

    AlfCustomInitDataBase* aCustomData)

    {

    return (new( EMM ) MulSliderWidget(aEnv, 

        aContainer, aWidgetId,aCustomData));

    }

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

//  Destructor.

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

//        

MulSliderWidget::~MulSliderWidget()

    {

    if(mSliderModel)

        {

        delete mSliderModel;

        }

    else 

        {

        }

    }

/**

 * Get the model for widget.

 *

 * @return model of the slider widget

 */

IMulSliderModel& MulSliderWidget::SliderModel() 

    {

    return *mSliderModel;

    }

/**

 * Set the transparency for the background of the slider widget.

 *

 * @param True,  to set background as transparent

 * @param False, to set background as opaque	

 */

 void MulSliderWidget::MakeTransparent( bool aTransparent) 

    {

    mElement->MakeTransparent(aTransparent);

    }

/**

 * Enable/Disable key handling .

 *

 * @param aVal: True,  to handle keyevents by Application

 * 		 	  False, to handle keyevents as defined in the control	

 */

void MulSliderWidget::SetHandleKeyEvent( bool aVal ) 

    {

    mHandleKeyEvent = aVal;

    }

/**

 * 

 * Returns KeyEvent enable status

 *	

 */    

bool MulSliderWidget::IsKeyEnabled()

    {

    return mHandleKeyEvent;

    }

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

// From class IAlfWidget.

// Getter for the parent container. The ownership not passed.

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

//

IAlfContainerWidget* MulSliderWidget::parent() const

    {

    return mWidget->parent();

    }

// From class MAlfInterfaceBase.

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

// Getter for interfaces provided by the slider widget.

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

//

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

    {

    UString param ( aType.mImplementationId );

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

        {

        return static_cast<IMulSliderWidget*>(this);

        }

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

        {

        return static_cast<IAlfWidget*>(this);

        }

    else

        {

        //do nothing

        }

    // @todo other interfaces

    return mWidget->makeInterface(aType);

    }

// From class IAlfWidget.

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

// Getter for the control. The ownership is not passed.

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

//

CAlfWidgetControl* MulSliderWidget :: control() const

    {

    //return mSliderControl;

    return mWidget->control();

    }

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

// Setter for the control. The control is owned by the Alfred environment.

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

//    

void MulSliderWidget :: setControl( 

    CAlfWidgetControl* aControl, bool /*aDeletePreviousControl*/ )

    {

    mSliderControl = aControl;

    mWidget->setControl(aControl);

    }

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

// Getter for the model. The ownership is not passed.

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

//

IAlfModel* MulSliderWidget :: model()

    {    

    return mSliderModel;

    }

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

// Setter for the model. Ownership is passed and the old model is released.

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

//

void MulSliderWidget :: setModel( IAlfModel* aModel, bool /*aTakeOwnerShip*/)

    {

    if(aModel==NULL)

        {

        // Destroy the visualization if Model is NULL.

			if(mElement)

			{

    		// Destroy the visual tree

			mSliderControl->Visual(0).RemoveAndDestroyAllD();

    		// Removes the element from control and destroys it

            mSliderControl->removeAndDestroyElement(*((IAlfElement *)mElement));

            mElement = NULL;

			}

        delete mSliderModel;

        mSliderModel = NULL;

        }

    else 

        {

        if(mSliderModel)

            {

            delete mSliderModel;

            mSliderModel = NULL;

            }

         mSliderModel = static_cast<IMulSliderModel*>( aModel->makeInterface(

			          IMulSliderModel::type()));

        MulSliderModel* sliderModel = (MulSliderModel*)mSliderModel;

        // Store the widget pointer in model 

        sliderModel->storeWidget(this);

		if(mElement)

    		{

    		// Destroy the visual tree

    		mSliderControl->Visual(0).RemoveAndDestroyAllD();

    		// Removes the element from control and destroys it

            mSliderControl->removeAndDestroyElement(*((IAlfElement *)mElement));

            mElement = NULL;

    		}

		if(mSliderModel)

        	{

            sliderTemplate tmplateID = sliderModel->GetTemplate();

            if(tmplateID != ESliderTemplateNone)

                {

                switch(tmplateID)

                    {

                	case ESliderTemplate3:// zoom slider

                	  CreateSliderElement(KSliderVerticalElement);

                	  break;

                	case ESliderTemplate7:// progressbar

                	  CreateSliderElement(KSliderProgressbarElement);

                	  break;

                	default:// rest all tempaltes are horizonatal

                	  CreateSliderElement(KSliderHorizontalElement);

                	}

                if(mElement)

                    {

                    mElement->createVisualization(tmplateID);

                    ShowWidget(!IsHidden());

                    }

                }

            }

        }

    }// End of setModel 

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

// Get the name of the widget instance.

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

//

const char* MulSliderWidget :: widgetName() const

    {

    return mWidget->widgetName();

    } 

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

// Sets/Releases the Focus from child widget of container.

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

//

void MulSliderWidget::setChildFocus(bool /*aFocus*/)

    {

    }

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

// Creates the presentation for the widget from XML. Destroys any existing

// presentation.

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

//    

void MulSliderWidget::setPresentation(const char* /*aFilePath*/)

    {

    } 

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

// Gets the Widget Opacity

// 

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

// 

bool MulSliderWidget::GetOpacity()

    {

    return mOpacity;

    }

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

// Gets the Widget Opacity

// 

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

// 

bool MulSliderWidget::IsHidden()

    {

    return !mOpacity;

    }

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

//   Default constructor.

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

//

MulSliderWidget::MulSliderWidget(

    CAlfEnv& aEnv, IAlfContainerWidget& aContainer,

    const char* aWidgetId, 

    AlfCustomInitDataBase* /*aCustomData*/)

    { 

    // Default widget is shown 

    mOpacity = true;

    mSliderModel = NULL;

    mElement = NULL;

    mHandleKeyEvent = true;

    mWidget.reset(new(EMM) AlfWidget(aWidgetId,aContainer,aEnv));

    // Default Imperative Construction

    // Create Control

    CAlfWidgetControl* ctrl = constructDefaultControl(aEnv);

    setControl(ctrl);

    }

void MulSliderWidget::CreateSliderElement(const char* aElementId)

    {

    IAlfWidgetFactory& widgetFactory = AlfWidgetEnvExtension::widgetFactory(

                        control()->Env());

    IAlfElement * baseelement = widgetFactory.createElement<IAlfElement>

         	        (   aElementId, 

         	            baseElementName(),

         	            *control(), 

         	            NULL, 

         	            NULL );

    // Store the element pointer

    mElement = static_cast<IMulSliderBaseElementInternal*>(

    baseelement->makeInterface(

    IMulSliderBaseElementInternal::type()));     	            

    }   

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

//  Construct and returns Slider Control.

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

//

CAlfWidgetControl *MulSliderWidget::constructDefaultControl(CAlfEnv& aEnv)

    {

    return(new(EMM) MulSliderControl(aEnv) );

    } 

void MulSliderWidget::changeTemplate(int /*aTemplateId*/)

    {

	if( mSliderModel )

		{

    	if(mElement)

    		{

    		mSliderControl->Visual(0).RemoveAndDestroyAllD();

    			mSliderControl->removeAndDestroyElement(*((IAlfElement*)mElement));

    		// delete baseelement;

    		mElement = NULL;

    		}

		MulSliderModel* sliderModel = (MulSliderModel*)mSliderModel;

		sliderTemplate i = sliderModel->GetTemplate();

		switch(i)

			{

			case ESliderTemplateNone :// no template id is set

				return;

			case ESliderTemplate3:// zoom slider

			  CreateSliderElement(KSliderVerticalElement);

			  break;

    		case ESliderTemplate7:// progressbar

    		  CreateSliderElement(KSliderProgressbarElement);

    		  break;

    		default:// rest aal tempaltes are horizonatal

			  CreateSliderElement(KSliderHorizontalElement);

			}        

        mElement->createVisualization(i);

        ShowWidget(!IsHidden());

        }

    }

void MulSliderWidget::ShowWidget(bool opacity,int aTransitionTime)

    {

    mOpacity = opacity;

	if(mElement && mSliderModel)

	    {

		MulSliderModel* sliderModel = static_cast<MulSliderModel*>(mSliderModel);

		if( sliderModel->GetTemplate() == ESliderTemplate3 && !mOpacity)

			{

	        mElement->stopEvents();

			}

	    CAlfLayout *layout = mSliderControl->ContainerLayout(NULL);

	    TAlfTimedValue t1(0,aTransitionTime);

	    if(opacity)

    	    {

    	    t1.SetTarget(1,aTransitionTime);

    	    }

	    layout->SetOpacity(t1);

	    }

    }

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

// Get the root layout of slider

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

//

const CAlfLayout& MulSliderWidget ::ContainerLayout()

    {

	CAlfLayout*  layout = mSliderControl->ContainerLayout(NULL);

	return *layout;

    }

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

// AddEventHandler

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

//	    

void MulSliderWidget::AddEventHandler( IAlfWidgetEventHandler& aObserver)

	{

	control()->addEventHandler(&aObserver);

	}

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

// RemoveEventHandler

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

//

void MulSliderWidget::RemoveEventHandler( IAlfWidgetEventHandler& aObserver)

	{

	control()->removeEventHandler(aObserver);

	}

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

// RemoveEventHandler

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

//

IMulSliderBaseElementInternal* MulSliderWidget::GetSliderElement()

	{

	return mElement;

	}	    

    }//End of Alf