/****************************************************************************

**

** Copyright (C) 2008-2010 Nokia Corporation and/or its subsidiary(-ies).

** All rights reserved.

** Contact: Nokia Corporation (developer.feedback@nokia.com)

**

** This file is part of the HbWidgets module of the UI Extensions for Mobile.

**

** GNU Lesser General Public License Usage

** This file may be used under the terms of the GNU Lesser General Public

** License version 2.1 as published by the Free Software Foundation and

** appearing in the file LICENSE.LGPL included in the packaging of this file.

** Please review the following information to ensure the GNU Lesser General

** Public License version 2.1 requirements will be met:

** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.

**

** In addition, as a special exception, Nokia gives you certain additional

** rights.  These rights are described in the Nokia Qt LGPL Exception

** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.

**

** If you have questions regarding the use of this file, please contact

** Nokia at developer.feedback@nokia.com.

**

****************************************************************************/

#include "hbslider.h"

#include "hbslider_p.h"

#include "hbslidercontrol_p.h"

#include "hbslidercontrol_p_p.h"

#include "hbnamespace_p.h"

#include "hbsliderhandle_p.h"

#include "hbstyleoptionslider_p.h"

#include "hbslidertickmarks_p.h"

#include "hbslidertickmarkslabel_p.h"

#include "hbabstractbutton.h"

#include <hbwidgetfeedback.h>

#include <QGraphicsItem>

#include <QGraphicsSceneEvent>

#include <QGraphicsScene>

#include <QDebug>

#ifdef HB_EFFECTS

#include "hbeffect.h"

#include "hbeffectinternal_p.h"

#define HB_SLIDER_TYPE "HB_SLIDER"

#endif

/*!

    @beta

    @hbwidgets

    \class HbSlider

    \brief HbSlider widget provides a generic vertical or horizontal slider.

    HbSlider is a classic widget for controlling a bounded value.

    It lets the user move a slider handle along a horizontal or vertical

    track and translates the handle's position into an integer value

    within the legal range.

    \image html hbslider.png A horizontal slider.

    The most important functions are setValue( ) to set the slider directly

    to some value; and setMinimum( ) and setMaximum( ) to define the range

    of the slider.

    HbSlider consists of elements. The available slider elements are

    defined by the HbSlider::SliderElement enumeration. A set of elements

    can be set by setSliderElements( ) and currently existing elements can be

    queried by sliderElements( ).All elements are optional

    Example usage:

    \code

    HbSlider *slider = new HbSlider( );

    QList<QVariant> elements;

    elements << QVariant (HbSlider::IncreaseElement)

        << QVariant (HbSlider::TrackElement)

        << QVariant (HbSlider::DecreaseElement)

        << QVariant (HbSlider::IconElement)

        << QVariant (HbSlider::TextElement);

    slider->setSliderElements( elements );

    QMap<QString , QVariant> map;

    // Icon path should be valid

    map.insert(QString("IncreaseElement") , QVariant(":/unittest_hbslider/star_on.png"));

    map.insert(QString("DecreaseElement") , QVariant(":/unittest_hbslider/star_on2.png"));

    map.insert(QString("IconElement") , QVariant(":/unittest_hbslider/star_on3.png"));

    slider->setElementIcons( map );

    \endcode

    \image html verticalslider.png A Custom vertical slider with all elements.

    HbSlider provides methods for controlling tickmarks.  You can use

    setTickPosition( ) to indicate where you want the tickmarks to be,

    setMajorTickInterval( ) and setMinorTickInterval( ) to indicate how

    many of them you want. The current set tick position and intervals

    can be queried using the tickPosition( ), majorTickInterval( ) and

    minorTickInterval( ) functions, respectively.

    HbSlider provides only integer ranges. Note that although

    HbSlider handles very large numbers, it becomes difficult for users

    to use a slider accurately for very large ranges.

    HbSlider also provide functionality of filling groove ( like progress )

    of slider. However this functionality is configurable and can be changed by

    setTrackFilled(), By Default this will be enabled

    The slider handles keys in the following way:

    \li Left/Right moves a horizontal slider by one single step.

    \li Up/Down moves a vertical slider by one single step.

    Example usage:

    \dontinclude slider/main.cpp

    \skip Start of snippet 1

    \until End of snippet 1

    \sa HbZoomSlider, HbVolumeSlider

*/

/*!

    \fn void HbSlider::valueChanged( int value )

    This signal is emitted when the slider value has changed.

    \sa hasTracking( )

*/

/*!

    \fn void HbSlider::sliderPressed( )

    This signal is emitted when the slider thumb has been pressed.

*/

/*!

    \fn void HbSlider::sliderReleased( )

    This signal is emitted when the slider thumb has been released.

*/

/*!

    \fn void HbSlider::sliderMoved( int value )

    This signal is emitted when the slider position has changed.

    \sa hasTracking( )

*/

/*!

    \fn void HbSlider::rangeChanged( int min, int max )

    This signal is emitted when the slider range has changed.

*/

/*!

    \fn void HbSlider::iconPressed( )

    This signal is emitted when the slider icon has been pressed.

*/

/*!

    \fn void HbSlider::iconReleased( )

    This signal is emitted when the slider icon has been released.

*/

/*!

    \fn void HbSlider::iconClicked( )

    This signal is emitted when the slider icon has been clicked.

*/

/*!

    \fn void HbSlider::iconToggled( bool checked )

    This signal is emitted when the slider icon is checkable and it has been toggled.

*/

/*!

    \reimp

    \fn int HbSlider::type( ) const

 */

/*!

    \enum HbSlider::SliderElement

    This enum defines available slider elements.

 */

/*!

    \var HbSlider::IncreaseElement

    A button to increase the slider value. Usually a plus sign.

 */

/*!

    \var HbSlider::TrackElement

 */

/*!

    \var HbSlider::DecreaseElement

    A button to decrease the slider value. Usually a minus sign.

 */

/*!

    \var HbSlider::IconElement

 */

/*!

    \var HbSlider::TextElement

    A text element associated to the slider.

 */

/*!

    \enum HbSlider::SnappingMode

    This enum defines available SnappingModes.

 */

/*!

    \var HbSlider::NoSnapping

    slider do not snap incase of NoSnapping but by deault it will be snapped to minrotick.

 */

/*!

    \var HbSlider::MajorTickSnapping

    slider snaps to major tick incase of drag.

 */

/*!

    \var HbSlider::MinorTickSnapping

    slider snaps to minor tick incase of drag.

 */

HbSliderPrivate::HbSliderPrivate( ) :

    sliderControl( 0 ),

    orientation( Qt::Vertical ),

    pressOnIncrement( false ),

    tickmarksLeft( 0 ), // slider left/top tick mark item

    tickmarksRight( 0 ),// slider right/bottom tick mark item

    tickmarkslabelLeft( 0 ),// slider left/above tick mark label

    tickmarkslabelRight ( 0 )// slider right/bottom tick mark label

{

    elementItemMap.clear();

}

HbSliderPrivate::~HbSliderPrivate( )

{

}

void HbSliderPrivate::init( )

{

    Q_Q( HbSlider );

    sliderControl = new HbSliderControl( orientation, q );

    HbStyle::setItemName( sliderControl, "control" );

    // delegating signal of slider control to slider

    q->connect( sliderControl, SIGNAL( valueChanged( int ) ), q,  SIGNAL( valueChanged( int ) ) );

    q->connect( sliderControl, SIGNAL( sliderPressed( ) ), q, SIGNAL( sliderPressed( ) ) );

    q->connect( sliderControl, SIGNAL( sliderReleased( ) ), q, SIGNAL( sliderReleased( ) ) );

    q->connect( sliderControl, SIGNAL( sliderMoved( int ) ), q, SIGNAL( sliderMoved( int ) ) );

    q->connect( sliderControl, SIGNAL( rangeChanged( int, int ) ), q, SIGNAL( rangeChanged( int, int ) ) );

    setElements( QList<HbSlider::SliderElement>( ) << HbSlider::TrackElement );

    HbStyle::setItemName( q,"this" );

    q->setFlags( QGraphicsItem::ItemIsFocusable );

    q->setProperty("TickLabelPresent",false);

}

void HbSliderPrivate::setElements( QList<HbSlider::SliderElement> elementList)

{

    Q_Q( HbSlider);

    bool oldElementRemoved = false;

        if(!elementList.contains(element)&& elementItemMap.contains(element)) {

            delete elementItemMap[element].item;

            delete elementItemMap[element].touchItem;

            elementItemMap.remove(element);

            oldElementRemoved = true;

        }

    }

    if(oldElementRemoved) {

        q->repolish( );

    }

    elements = elementList;

    // this will delete unwanted element and create new element

    updateElements( );

    // repolish call is required because new elements might be added

}

QSizeF HbSliderPrivate::getHandleSize( )

{

   return sliderControl ->getHandleSize();

}

/*!

    This api creates widget for given element   

 */

void HbSliderPrivate::elementWidget( HbSlider::SliderElement element )

{

    Q_Q( HbSlider );

    switch ( element ) {

        case HbSlider::IncreaseElement:

            // create element only if icon is set on that

            if ( icons.contains( element) && !elementItemMap.contains(element)){

                ItemPrimitive itemPrimStrct;

                itemPrimStrct.type = HbStyle::P_SliderElement_increase;

                itemPrimStrct.item = q->style( )->createPrimitive(HbStyle::P_SliderElement_increase,q );

                HbStyle::setItemName( itemPrimStrct.item, "increment-icon" );                    

                itemPrimStrct.touchItem = q->style( )->createPrimitive( HbStyle::P_SliderElement_touchincrease,q );

                HbStyle::setItemName( itemPrimStrct.touchItem, "increment-icon-toucharea" );

                HbStyleOptionSlider option;

                q->initStyleOption( &option );

                q->style( )->updatePrimitive (itemPrimStrct.touchItem,HbStyle::P_SliderElement_touchincrease,&option);

                elementItemMap[HbSlider::IncreaseElement]=itemPrimStrct;

                q->repolish( );

            }

            break;

        case HbSlider::DecreaseElement:

            // element will not be created if icon is not set on that element

            if ( icons.contains( element) && !elementItemMap.contains(element)) {

                ItemPrimitive itemPrimStrct;

                itemPrimStrct.item= q->style( )->createPrimitive(HbStyle::P_SliderElement_decrease,q );

                itemPrimStrct.type = HbStyle::P_SliderElement_decrease;

                HbStyle::setItemName( itemPrimStrct.item,"decrement-icon" );

                itemPrimStrct.touchItem = q->style( )->createPrimitive( HbStyle::P_SliderElement_touchdecrease,q );

                HbStyle::setItemName( itemPrimStrct.touchItem, "decrement-icon-toucharea" );

                elementItemMap[HbSlider::DecreaseElement]=itemPrimStrct;

                HbStyleOptionSlider option;

                q->initStyleOption( &option );

                q->style( )->updatePrimitive (itemPrimStrct.touchItem,HbStyle::P_SliderElement_touchdecrease,&option);

                q->repolish( );

            }

            break;

        case HbSlider::IconElement:

            if ( icons.contains( element) && !elementItemMap.contains(element) ) {

                    ItemPrimitive itemPrimStrct;

                    itemPrimStrct.item = q->style( )->createPrimitive(HbStyle::P_SliderElement_icon,q );

                    itemPrimStrct.type = HbStyle::P_SliderElement_icon;

                    HbStyle::setItemName( itemPrimStrct.item, "icon-icon" );

                    HbAbstractButton *sliderIcon = new HbAbstractButton( q );

                    HbStyle::setItemName( sliderIcon, "icon" );

                    itemPrimStrct.touchItem = sliderIcon;

                    elementItemMap [HbSlider::IconElement]=itemPrimStrct;

                    // delegating signal from button to slider

                    q->connect( sliderIcon, SIGNAL( pressed( ) ), q, SIGNAL( iconPressed( ) ) );

                    q->connect( sliderIcon, SIGNAL( released( ) ), q, SIGNAL( iconReleased( ) ) );

                    q->connect( sliderIcon, SIGNAL( clicked( ) ), q, SIGNAL( iconClicked( ) ) );

                    q->connect( sliderIcon, SIGNAL( toggled( bool ) ), q, SIGNAL( iconToggled( bool ) ) );

#ifdef HB_EFFECTS

                    q->connect( sliderIcon, SIGNAL( pressed( ) ), q, SLOT( _q_startIconPressedEffect( ) ) );

                    q->connect( sliderIcon, SIGNAL( released( ) ), q,SLOT( _q_startIconReleasedEffect( ) ) );

#endif

                    q->repolish( );

            }

            break;

        case HbSlider::TextElement:

            if( !sliderTextString.isEmpty( ) && !elementItemMap.contains(element)){

                ItemPrimitive itemPrimStrct;

                itemPrimStrct.type = HbStyle::P_SliderElement_text;

                itemPrimStrct.item = q->style( )->createPrimitive( HbStyle::P_SliderElement_text,q );

                HbStyle::setItemName( itemPrimStrct.item,"text_item_element" );

                HbAbstractButton *sliderTextButton = new HbAbstractButton( q ); 

                HbStyle::setItemName( sliderTextButton, "text_element" );

                itemPrimStrct.touchItem = sliderTextButton;   

                q->connect( sliderTextButton, SIGNAL( clicked( ) ), q, SIGNAL( textClicked( ) ) );

#ifdef HB_EFFECTS

                q->connect( sliderTextButton, SIGNAL( clicked( ) ), q, SLOT( _q_startTextClickEffect( ) ) );

#endif

                q->repolish();

                q->setProperty("state", "normal"); 

                elementItemMap[HbSlider::TextElement]=itemPrimStrct;

              }

            break;

        default:

            break;

    }

     HbStyleOptionSlider option;

     q->initStyleOption( &option );

     option.sliderElementIcon =icons.value(element ); 

     option.text = sliderTextString; 

     if (elementItemMap.contains(element)) {

         q->style( )->updatePrimitive( elementItemMap[element].item,elementItemMap[element].type,&option );

     }  //return created;

}

/*!

    update element will first delete element which are not required

    and then create new element

 */

void HbSliderPrivate::updateElements( )

{

    foreach ( const HbSlider::SliderElement &element, elements ) {

        // create new element, this api will not create element widget

        // if it is already existing

        elementWidget( element );

    }

}

/*!

     This Api will start incrementing slider value by step size

     till the time stopReapetAction( ) is not being called or slider

     value becomes maximum( )

 */

void HbSliderPrivate::startIncrementing( )

{

#ifdef HB_EFFECTS

    HbEffectInternal::add( HB_SLIDER_TYPE,"slidericon_press", "increasepressed" );

    HbEffect::start( elementItemMap[HbSlider::IncreaseElement].item, HB_SLIDER_TYPE, "increasepressed" );  

#endif

    // increase slider value by step size

    sliderControl->triggerAction( HbAbstractSliderControl::SliderSingleStepAdd );

    // start timer to increase slider value by step

    sliderControl->setRepeatAction( HbAbstractSliderControl::SliderSingleStepAdd,sliderControl->maximum( ) );

}

/*!

     This Api will start decrementing slider value by step size

     till the time stopReapetAction( ) is not being called or slider

     value becomes minimum( )

 */

void HbSliderPrivate::startDecrementing( )

{

#ifdef HB_EFFECTS

    HbEffectInternal::add( HB_SLIDER_TYPE,"slidericon_press", "decreasepressed" );

    HbEffect::start( elementItemMap[HbSlider::DecreaseElement].item, HB_SLIDER_TYPE, "decreasepressed" );  

#endif

    sliderControl->triggerAction( HbAbstractSliderControl::SliderSingleStepSub );

    sliderControl->setRepeatAction( HbAbstractSliderControl::SliderSingleStepSub,sliderControl->minimum( ) );

}

/*!

    stops the reapeating action

    reapeat action can be increase slider value by step or decrease slider value by step

 */

void HbSliderPrivate::stopRepeatAction( )

{

    sliderControl->setRepeatAction( HbAbstractSliderControl::SliderNoAction ); 

}

void HbSliderPrivate::createTickMarks( )

{

    Q_Q ( HbSlider);

    bool modified = false;

    if( q->majorTickInterval( ) <= 0) {

        return;

    }

    if ( q->tickPosition( ) & Hb::SliderTicksLeft) {

        if (!tickmarksLeft) {

            tickmarksLeft =  new HbSliderTickmarks(q);

            tickmarksLeft->setZValue(sliderControl->zValue()-1);

            tickmarksLeft->setTickPosition (Hb::SliderTicksLeft);

            modified = true;

            if ( orientation == Qt::Vertical ) {

                HbStyle::setItemName( tickmarksLeft, "tick-marksleft" );

            } else {

                HbStyle::setItemName( tickmarksLeft, "tick-marksabove" );

            }

        } 

    } else if ( tickmarksLeft ) {

        delete tickmarksLeft;

        tickmarksLeft = 0;

        modified = true;

    }

    if ( q->tickPosition( ) & Hb::SliderTicksRight) {

        if (!tickmarksRight) {

            tickmarksRight =  new HbSliderTickmarks(q);

            tickmarksRight->setTickPosition (Hb::SliderTicksRight);

            tickmarksRight->setZValue(sliderControl->zValue()-1);

            modified = true;

            if ( orientation == Qt::Vertical ) {

                HbStyle::setItemName( tickmarksRight, "tick-marksright" );

            } else {

                HbStyle::setItemName( tickmarksRight, "tick-marksbelow" );

            }

        }

    } else if ( tickmarksRight ) {

        delete tickmarksRight;

        tickmarksRight = 0;

        modified = true;

    }

    if ( orientation == Qt::Vertical ) {

        if ( q->tickPosition( ) & Hb::SliderTicksAbsolute)  {

            q->setLayoutDirection (Qt::LeftToRight );

        } else {