/*

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

*

*/

//Toolkit Includes

#include <alf/alfimagevisual.h>

#include <alf/alfevent.h>

#include <alf/alfenv.h>

#include <AknUtils.h>

//AknLayout2 includes

#include <aknlayoutscalable_uiaccel.cdl.h>

// Alfred Client includes

#include <alf/alfroster.h>

#include <alf/alfdisplay.h>

//Widget Model Includes

#include <alf/alflayout.h>

#include "alf/alfelement.h"

#include <alf/alfwidgeteventhandler.h>

#include <alf/alfwidgetenvextension.h>

#include <alf/ialfmodel.h>

//scrollbar widget includes

#include <alf/alfscrollevents.h>

#include "alfscrollbardefaultbaseelement.h"

#include "alfscrollbarwidget.h"

#include "alfscrollbarcontrol.h"

#include "alfscrollbarmodel.h"

#include "alfscrollbarlongtaptimer.h"

#include <math.h>

enum 

    {

    EReleased,

    ETrackPressed,

    EThumbPressed

    };    

// EPSILON is an small constant used to compare two real values

const float KEpsilon  = 0.000001;

namespace Alf

    {

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

//  A function to compare two real values. The difference less than aEpsilon

//  is assumed negligible.

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

//

inline int realCompare(float aReal1, float aReal2, float aEpsilon)

    {

    if (Abs(aReal1-aReal2) < aEpsilon)

        {

        return 0;

        }

    else if ((aReal1-aReal2) > 0)

        {

        return 1;

        }

    else

        {

        return -1;

        }

    };  

struct ScrollBarBaseElementData

    {

    TOperation mOperation;              // Thumb Drag

    CAlfVisual* mVisual;                // Hit visual

    TPoint mDragPoint;                  // Current pointer value

    TPoint mLongTapPos;                 // Long Tap Point

    int mDragStartStep;                 // Value of view start position when drag starts

    int mCurrentState;                  // track or thumb clicked state indicator

    bool mLongTapStarted;               // Long Tap Timer started ( true if started) 

    int mViewLength;                    // For avoiding thumb length calculation 

                                        // everytime when model data changes

                                        // Stores current viewLength

    int mTotalLength;                   // For avoiding thumb length calculation 

                                        // everytime when model data changes

                                        // Stores current spanLength

    float mWidgetOpacity;               // default value =1.0.

    float mThumbOpacity;                // default value =1.0. thumb will eventually have

                                        // opacity=iWidgetOpacity*iThumbOpacity.

    int mThumbAnimationTime;            // thumb animation time in milliseconds.

    float mThumbLength;                 // Length of scrollbar thumb

    float mThumbMinLength;              // Minimum Length of thumb

    float mThumbMaxLength;              // Maximum Length of thumb

    float mStepSize;                    // Step Size

    bool mThumbSizeChanged;             // flag to indicate whether thumbSize is Changed.

    int mExtendedTouch;                 // extended area width.

    AlfScrollBarModel* mScrollbarModel; // Pointer to scrollbar model

    CAlfLayout* mRootLayout ;           // Layouts and visuals

    CAlfLayout* mTrackLayout ;

    CAlfLayout* mExtendedTrackLayout;

    CAlfLayout* mThumbLayout ;

    CAlfLayout* mExtendedThumbLayout;

    CAlfImageVisual* mTrackTopImage ;

    CAlfImageVisual* mTrackMiddleImage ;

    CAlfImageVisual* mTrackEndImage ;

    CAlfImageVisual* mThumbTopImage ;

    CAlfImageVisual* mThumbMiddleImage ;

    CAlfImageVisual* mThumbEndImage ;

    };//End of struct ScrollBarBaseElementData

struct ScrollbarThumbLCTData

    {

    TInt left;      //used to specify left value

    TInt top;       //used to specify top value

    TInt right;     //used to specify right value

    TInt bottom;    //used to specify bottom value

    TInt height;    //used to specify height value

    TInt width;     //used to specify width value

    };

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

//  C++ default constructor.

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

//

AlfScrollBarDefaultBaseElement::AlfScrollBarDefaultBaseElement(

                                    CAlfWidgetControl& aControl,

                                    const char* aName, 

                                    DuiNode* /*mNode*/,

                                    AlfCustomInitDataBase* /*aCustomData*/)

    : mData(NULL)

    {

    try

        {

        // Base class (AlfElement) construct

        construct(aControl, aName);   

        mLongTapTimer.reset( 

            new (EMM) AlfScrollBarLongTapTimer(this));

        mIsLongTapObserverSet=EFalse;

        //For Imperative construct

        createDefaultBaseElement();

        }

    catch(AlfException& e)

        {

        aControl.removeElement(*this);

        throw;

        }

    // AlfScrollBarDefaultBaseElement is an event handler too so it 

    // should be added to the control

    aControl.addEventHandler(this);

    }

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

//  Destructor

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

//

AlfScrollBarDefaultBaseElement::~AlfScrollBarDefaultBaseElement()

    {

    if(mData)

        {

        delete mData;

        }

    else

        {

        }

    if(mLCTData)

        {

        delete mLCTData;

        }

    else

        {

        }

    }//End of Destructor

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

// APIs from the IAlfScrollBarDefaultBaseElement for controlling the 

// visualization of the scrollbar

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

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

// Sets the thumb animation time.

// @aTime     : Time in miliseconds

// @exception : for aTime less then O.0 miliseconds

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

//

void AlfScrollBarDefaultBaseElement::setThumbAnimationTime ( int aTime )

    {

    // Sanity check

    if (aTime < 0)

    	{

    	ALF_THROW(AlfException, EInvalidArgument, "AnimationTime is invalid");

    	}

    else

    	{

    	// do nothing

    	}	

    if(mData->mThumbAnimationTime != aTime)

    	{

    	mData->mThumbAnimationTime = aTime;

    	}

    }

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

// From class IAlfScrollBarWdget.

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

//

int AlfScrollBarDefaultBaseElement::getThumbAnimationTime() const

    {

    return mData->mThumbAnimationTime;

    }

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

// Sets opacity value for the Thumb.

// Thumb opacity is relative to the track.

// @param     : aOpacity float value between 0.0 to 1.0

// @exception : value of aOpacity more than 1.0 and less than 0.0

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

//

void AlfScrollBarDefaultBaseElement::setThumbOpacity (float aOpacity)

    {

    // Sanity check

   if (realCompare(aOpacity, 0.0, KEpsilon) < 0

       || realCompare(aOpacity, 1.0, KEpsilon) > 0)

       {

       ALF_THROW(AlfException, EInvalidArgument, "Opacity is invalid");

       }

   else

       {

       // do nothing

       }

    // if there is a change, update the visualization

    if (aOpacity != mData->mThumbOpacity)

        {

        mData->mThumbOpacity = aOpacity;

        const TAlfTimedValue opacity(mData->mThumbOpacity * mData->mWidgetOpacity);

        if(mData->mThumbLayout)

            {

            mData->mThumbLayout->SetOpacity(opacity);

            control().Visual(0).UpdateChildrenLayout();

            }

        }

    }//End of setThumbOpacity

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

// Returns Thumb opacity is relative to the track.

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

//

float AlfScrollBarDefaultBaseElement::getThumbOpacity() const

    {

    return mData->mThumbOpacity;

    }

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

// Sets opacity value for the widget.

// 

// @param     : aOpacity float value between 0.0 to 1.0

// @exception : value of aOpacity more than 1.0 and less than 0.0

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

//

void AlfScrollBarDefaultBaseElement::setOpacity (float aOpacity)

    {

    // Sanity check

   if (realCompare(aOpacity, 0.0, KEpsilon) < 0

       || realCompare(aOpacity, 1.0, KEpsilon) > 0)

       {

       ALF_THROW(AlfException, EInvalidArgument, "Opacity is invalid");

       }

   else

       {

       // do nothing

       }

    // if there is a change, update the visualization

    if (aOpacity != mData->mWidgetOpacity)

        {

        mData->mWidgetOpacity = aOpacity;

        const TAlfTimedValue opacity(mData->mWidgetOpacity);

        if(mData->mTrackLayout)

            {

            mData->mRootLayout->SetOpacity(opacity);

            control().Visual(0).UpdateChildrenLayout();

            }

        }

    }//End of setThumbOpacity

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

// Returns Widget opacity is relative to the track.

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

//

float AlfScrollBarDefaultBaseElement::getOpacity() const

    {

    return mData->mWidgetOpacity;

    }

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

// APIs from the IAlfScrollBarBaseElement 

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

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

// Gets called when the parent layout is relayouted.

// resets all the anchor points and updates the visualization

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

//

void AlfScrollBarDefaultBaseElement::baseLayoutSizeChanged()

    {

    initializeLayout();    

    }

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

// processPointerEvent generates custom events 

// according the focus visual .

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

//

bool AlfScrollBarDefaultBaseElement::processPointerEvent(TAlfEvent * aPntrEvent)

    {

    // retrieve pointer event (NULL check not required here)

    // Get the hit visual

    CAlfVisual *focusvisual =aPntrEvent->Visual();

    if ( aPntrEvent->IsPointerEvent()  )

        {

        if (aPntrEvent->PointerEvent().iType == TPointerEvent::EButton1Down)

            {

            bool ret = handlePointerDownEvent(aPntrEvent);	

            return ret;

            }

        else if (aPntrEvent->PointerEvent().iType == TPointerEvent::EDrag)

            {

            if(!mData->mOperation) 

                {

                // Drag during tap and hold on track 

                if(mIsLongTapObserverSet)

                    {

                    mData->mLongTapPos=aPntrEvent->PointerEvent().iParentPosition;

                    }

                else

                    {

                    //Do Nothing.

                    }    

                }

            else

                {

                // Drag on thumb

                if(mIsLongTapObserverSet &&

                   mData->mVisual && (isScrollbarThumbVisual(focusvisual)) )

                    {

                    mData->mLongTapPos= aPntrEvent->PointerEvent().iParentPosition ;

                    }

                else

                    {

                    // Do nothing

                    }

                int dist = aPntrEvent->PointerEvent().iParentPosition.iY - mData->mDragPoint.iY;

                int steps = ceil(dist / mData->mStepSize) + mData->mDragStartStep;

                // checking steps to avoid negative value, incase of max scrollbar length

                if(  steps >  mData->mScrollbarModel->getTotalLength() -  mData->mScrollbarModel->getViewLength()) 

                     {

                     steps =  mData->mScrollbarModel->getTotalLength() -  mData->mScrollbarModel->getViewLength(); 

                     }   

               else if(steps <  0 )   

                     {

                     steps =  0;

                     } 

                if(steps !=  mData->mScrollbarModel->getViewStartPosition())

                    {

                    // send tactile sensitive event

                    //control().processEvent(TAlfEvent(EEventScrollBarDrag));

                    TAlfEvent customevent(EEventDragVertical,(TInt )steps);

                    control().processEvent(customevent);

                    }

                // Tactile Feedback for Thumb drag

                AlfScrollBarControl& slbrcntrl = static_cast<AlfScrollBarControl&>(control());

                slbrcntrl.TactileEffectOnDrag(*aPntrEvent);

                }    

            }

        else if(aPntrEvent->PointerUp()  )

            {

            mData->mLongTapStarted = false;

            handlePointerUpEvent();

            }

        else

            {

            //Do Nothing.

            }

    }

    return true;

    }//End of processPointerEvent

void AlfScrollBarDefaultBaseElement::createVisualization()

    {

    initializeScrollModel();

    CAlfWidgetControl  *ctrl = &control();

    // Create Root Layout

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

    mData->mRootLayout->SetFlag(EAlfVisualFlagLayoutUpdateNotification);

    mData->mRootLayout->SetFlag( EAlfVisualFlagAutomaticLocaleMirroringEnabled );	

    // Create Track Layout

    mData->mTrackLayout = CAlfLayout::AddNewL(*((CAlfControl*)ctrl),mData->mRootLayout);

    mData->mTrackLayout->SetFlag( EAlfVisualFlagAutomaticLocaleMirroringEnabled );

    mData->mExtendedTrackLayout = CAlfLayout::AddNewL(*((CAlfControl*)ctrl),mData->mTrackLayout);

    if(mData->mTrackLayout)

        {

        mData->mTrackTopImage = CAlfImageVisual::AddNewL(

            *((CAlfControl*)ctrl),mData->mTrackLayout);

        mData->mTrackMiddleImage = CAlfImageVisual::AddNewL(

            *((CAlfControl*)ctrl),mData->mTrackLayout);

        mData->mTrackEndImage = CAlfImageVisual::AddNewL(

            *((CAlfControl*)ctrl),mData->mTrackLayout);

        if(mData->mTrackTopImage && 

           mData->mTrackMiddleImage && 

           mData->mTrackEndImage)

            {

            setTrackImage();

            }

        // Create Thumb Visuals    

        mData->mThumbLayout = CAlfLayout::AddNewL(*((CAlfControl*)ctrl),

                                                        mData->mRootLayout);

        mData->mThumbLayout->SetFlag( EAlfVisualFlagAutomaticLocaleMirroringEnabled );

        mData->mExtendedThumbLayout = CAlfLayout::AddNewL(*((CAlfControl*)ctrl),

                                                        mData->mThumbLayout);

        if(mData->mThumbLayout)

            {

            mData->mThumbTopImage = CAlfImageVisual::AddNewL(

                *((CAlfControl*)ctrl),mData->mThumbLayout);

            mData->mThumbMiddleImage = CAlfImageVisual::AddNewL(

                *((CAlfControl*)ctrl),mData->mThumbLayout);

            mData->mThumbEndImage = CAlfImageVisual::AddNewL(

                *((CAlfControl*)ctrl),mData->mThumbLayout);

            if(mData->mThumbTopImage && 

               mData->mThumbMiddleImage && 

               mData->mThumbEndImage)

                {

                setThumbImage();

                }

            }

        }

    }

void AlfScrollBarDefaultBaseElement::updateVisualization()

    {

    calculateStepSizeAndThumbLength();

    if(mData->mViewLength !=  mData->mScrollbarModel->getViewLength() || mData->mTotalLength !=  mData->mScrollbarModel->getTotalLength())

        {

        mData->mViewLength =  mData->mScrollbarModel->getViewLength();

        mData->mTotalLength =  mData->mScrollbarModel->getTotalLength();

        initializeThumbLayout();

        }

    TAlfRealPoint thumbPos;

    thumbPos.iX = mData->mThumbLayout->Pos().iX.ValueNow();        	

    thumbPos.iY = ceil(mData->mStepSize *  mData->mScrollbarModel->getViewStartPosition());

    mData->mThumbLayout->SetPos(thumbPos,mData->mThumbAnimationTime);

    }

void AlfScrollBarDefaultBaseElement::destroyVisualization()

    {

    mData->mRootLayout->RemoveAndDestroyAllD();

    delete mData;

    delete mLCTData;

    createDefaultBaseElement();

    }

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

// From class MAlfInterfaceBase.

// Getter for interfaces provided by the scrollbar widget.

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

//

IAlfInterfaceBase* AlfScrollBarDefaultBaseElement::makeInterface(

                        const IfId& aType)

    {

    UString param (aType.mImplementationId);

    if (param == 

        IAlfScrollBarDefaultBaseElement::type().mImplementationId)

        {

        return static_cast<IAlfScrollBarDefaultBaseElement*>(this);

        }

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

        {

        return static_cast<IAlfWidgetEventHandler*>(this);

        }

    else if (param == 

        IAlfScrollBarBaseElementInternal::type().mImplementationId)

        {

        return static_cast<IAlfScrollBarBaseElementInternal*>(this);

        } 

    else

        {

        //do nothing

        }

    return AlfElement::makeInterface(aType);

    }

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

//  handles the pointerDown event

// 

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

//