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

**

** 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 "hbslidercontrol_p.h"

#include "hbslidercontrol_p_p.h"

#include "hbabstractslidercontrol_p.h"

#include "hbsliderhandle_p.h"

#include "hbstyleoptionslider_p.h"

#include "hbslidertickmarkslabel_p.h"

#include "hbslidertickmarkslabel_p.h"

#include <hbstyle.h>

#include <hbinstance.h>

#include <hbtheme.h>

#include <hbtooltip.h>

#include <hbwidgetfeedback.h>

#include <hbgraphicsscene.h>

#include <QGraphicsItem>

#include <QGraphicsSceneMouseEvent>

#ifdef HB_GESTURE_FW

#include "hbtapgesture.h"

#include "hbpangesture.h"

#endif 

#ifdef HB_EFFECTS

#include "hbeffect.h"

#include "hbeffectinternal_p.h"

#define HB_SLIDERCONTROL_TYPE "HB_SLIDERCONTROL"

#endif

/*!

    private class  

*/

HbSliderControlPrivate::HbSliderControlPrivate( ) :

    handle( 0 ), // slider handle

    tickPosition( Hb::NoSliderTicks ), // slider tick position

    snappingMode( HbSliderControl::MinorTickSnapping ), // snapping mode

    majorTickInterval( 0 ),// major tick interval

    minorTickInterval( 0 ),// minor tick interval

    groove( 0 ), //slider groove

    progressGroove( 0 ),//progress mask top of groove

    displayCurrValueToolTip( true ), // holds whether to show current value tooltip or not

    toolTipAlignment( Qt::AlignTop|Qt::AlignRight ), // tooltip alignment

    groovePressed( false ), // hold whether groove is pressed or not

    setDefault( false ), // holds whther default value for track press is set

    previousValue( 0 ),  // default value for track press

    trackHandlingEnable( false ),// this variable holds whether track will be interective or not

    handleMoving( false ),

    grooveTouchArea ( 0 ),

    enableProgressTrack ( true ),

    userDefinedTooltipAlign ( false )

{

    majorLabel.clear();

    minorLabel.clear();

}

HbSliderControlPrivate::~HbSliderControlPrivate( )

{

}

/*!

   \internal

   This api created required primitive( handle,groove, touch area )

*/

void HbSliderControlPrivate::init( )

{

    Q_Q( HbSliderControl );

    q->enableTrackEventHandling( true );

#ifdef HB_GESTURE_FW

    q->grabGesture(Qt::TapGesture);

    q->grabGesture(Qt::PanGesture,Qt::ReceivePartialGestures);

    q->setFiltersChildEvents(true) ;

#endif    

    // creating handle

    handle = createHandle();

    if(handle) {

        HbStyle::setItemName( handle, "handle" );

    }

    q->setFocusPolicy( Qt::FocusPolicy( ( qApp->style( ) )->styleHint( QStyle::SH_Button_FocusPolicy ) ) );

    //creating groove

    groove = createGroove();

    if(groove) {

        HbStyle::setItemName( groove, "groove" );

    }

    //filled item top of groove

    if ( enableProgressTrack ) {

        progressGroove = createProgressGroove();

        if(progressGroove) {

            HbStyle::setItemName( progressGroove, "progressgroove");

        }    

    }

    q->connect( hbInstance->theme( ), SIGNAL( changed( ) ), q, SLOT( updateTheme( ) ) );

    q->connect( q , SIGNAL( actionTriggered( int ) ), q , SLOT( showToolTip( ) ) );

    q->connect( q , SIGNAL( sliderReleased( ) ), q , SLOT( hideToolTip( ) ) );

    q->setFlags( QGraphicsItem::ItemIsFocusable );

}

/*!

  \internal

  This is used to create the handle, is virtual and can be overridden to create different handle.

  */

HbSliderHandle *HbSliderControlPrivate::createHandle()

{

    Q_Q( HbSliderControl );

    HbSliderHandle *handle = new HbSliderHandle( q );

    return handle;

}

/*!

  \internal

  This is used to create the groove. can be overrideen by derived class

  */

QGraphicsItem *HbSliderControlPrivate::createGroove()

{

    Q_Q( HbSliderControl );

    QGraphicsItem *groove = qgraphicsitem_cast<QGraphicsItem*>( q->style( )->createPrimitive(

        HbStyle::P_Slider_groove, q ) );

    return groove;

}

/*!

  \internal

  This is used to create the masked progress groove. can be overrideen by derived class

  */

QGraphicsItem *HbSliderControlPrivate::createProgressGroove()

{

    Q_Q( HbSliderControl );

    QGraphicsItem *proggroove = qgraphicsitem_cast<QGraphicsItem*>( q->style( )->createPrimitive(

        HbStyle::P_Slider_progressgroove, q ) );//comes on top of groove

    return proggroove;

}

/*!

   This api adjust the handle within slider area

   and position it depending upon slider value

*/

void HbSliderControlPrivate::adjustHandle( )

{

    Q_Q( HbSliderControl );

    handle->adjustSize( );

    QRectF bounds = q->boundingRect( );

    QRectF handleBounds = handle->boundingRect( );

    qreal span = 0;

    if ( q->orientation( ) == Qt::Horizontal ) {

        bounds.adjust( 0, 0, -handleBounds.width( ), 0 );

        // calculating span

        span = bounds.width( );

    } else {

        bounds.adjust( 0, 0, 0, -handleBounds.height( ) );

        // calculating span

        span = bounds.height( );

    }

    HbStyleOptionSlider opt;

    q->initStyleOption( &opt );

    // calculating pixel position depending on slider position

    int pos = QStyle::sliderPositionFromValue( opt.minimum, opt.maximum,

        opt.sliderValue, static_cast<int>( span ), opt.upsideDown );

    // align the rect to the centre of groove

    QRect rect = QStyle::alignedRect( opt.direction, Qt::AlignCenter,

        handleBounds.size( ).toSize( ), bounds.toRect( ) );

    if ( q->orientation( ) == Qt::Horizontal ) {

        rect.moveLeft( pos );

    } else {

        rect.moveTop( pos );

    }

    //set handle position

    handle->forceSetPos( rect.topLeft( ) );

    //progress groove should be adjusted whenever handle position is changed

    if ( progressGroove ) {

        q->style( )->updatePrimitive( progressGroove, HbStyle::P_Slider_progressgroove, &opt );

    }

}

/*!

   This api returns true if pos in on handle rect

*/

bool HbSliderControlPrivate::onHandle( QPointF pos )

{

    Q_Q( HbSliderControl );

    QRectF handleRect = handle->touchItem->sceneBoundingRect( );

    bool result = false;

    switch ( q->orientation( ) ) {

        case Qt::Horizontal:

            if ( handleRect.contains( pos.x( ) , handleRect.y( ) ) ) {

                result = true;

            }

            break;

        case Qt::Vertical:

            if ( handleRect.contains( handleRect.x( ),pos.y( ) ) ) {

                result = true;

            }

            break;

    }

    return result;

}

/*!

   This api returns near by tick to the sliderPosition

*/

int HbSliderControlPrivate::getNearbyTick( )

{

    Q_Q( HbSliderControl );

    // calculating slider position with respect to minimum( )

    int correctedSliderPos = q->sliderPosition( ) - q->minimum( );

    // if snapping mode is NoSnapping then there is no need to calculate

    //near by tick

    if ( !( snappingMode & HbSliderControl::NoSnapping ) ) {

        if ( snappingMode & HbSliderControl::MinorTickSnapping  ) {

            if ( minorTickInterval > 0 ) {

                // calculating tick number

               int tickNumber = correctedSliderPos / minorTickInterval;

               // check if reminder is grater then half of 

               //tick interval then increment tick number by 1

               if ( ( correctedSliderPos % minorTickInterval ) >= qRound( minorTickInterval/2.0 ) ) {

                    if ( ( ( tickNumber+1 ) * minorTickInterval ) <= ( q->maximum( ) - q->minimum( ) ) ) {

                        tickNumber++;

                    }

               }

               // return sliderPosition of near by tick

               return ( ( tickNumber * minorTickInterval ) + q->minimum( ) );

            }

        } else {

            if ( majorTickInterval > 0 ) {

                // calculating tick number

                int tickNumber = correctedSliderPos / majorTickInterval;                

                // check if reminder is grater then half of 

               //tick interval then increment tick number by 1

                if ( ( correctedSliderPos % majorTickInterval ) >= qRound( majorTickInterval/2.0 ) ) {

                    if ( ( ( tickNumber+1 ) * majorTickInterval ) <= ( q->maximum( ) - q->minimum( ) ) ) {

                        tickNumber++;

                    }

                }

                // return sliderPosition of near by tick

                return ( ( tickNumber * majorTickInterval ) + q->minimum( ) );

            }

        }

    }

    // return sliderPosition( ) if snapping mode is NoSnapping

    return ( q->sliderPosition( ) );

}

/*!

    Constructs a slider control with \a parent.

*/

HbSliderControl::HbSliderControl( QGraphicsItem *parent )

    : HbAbstractSliderControl( *new HbSliderControlPrivate, parent )

{

    Q_D( HbSliderControl );

    d->q_ptr = this;

    d->init( );

}

/*!

    Constructs a slider control with \a orientation and \a parent.

*/

HbSliderControl::HbSliderControl( Qt::Orientation orientation, QGraphicsItem *parent )

    : HbAbstractSliderControl( *new HbSliderControlPrivate, parent )

{

    Q_D( HbSliderControl );

    d->q_ptr = this;

    d->init( );

    setOrientation( orientation );

}

/*!

  Protected constructor for initialization from derived ctor.

*/

HbSliderControl::HbSliderControl(HbSliderControlPrivate &dd,QGraphicsItem *parent)

	:HbAbstractSliderControl(dd,parent)

{

}

/*!

    When theme is changed this is called.

*/

void HbSliderControl::updateTheme( )

{

    Q_D( HbSliderControl );

    // HbSliderHandle::boundingRect( ) result depends on current theme

    d->adjustHandle( );

}

/*!

    Destroys the slider.

*/

HbSliderControl::~HbSliderControl( )

{

}

/*!

    Returns the tickmark position of the slider.

    The default value is \c Hb::NoTicks.

    \sa setTickPosition( )

*/

Hb::SliderTickPositions HbSliderControl::tickPosition( ) const

{

    Q_D( const HbSliderControl );

    return d->tickPosition;

}

/*!

    Sets the tickmark position of the slider.

    \sa tickPosition( )

 */

void HbSliderControl::setTickPosition( Hb::SliderTickPositions position )

{

    Q_D( HbSliderControl );

    if ( d->tickPosition != position ) {

        d->tickPosition = position;

}

/*!

    Returns the interval between major tickmarks.

    The default value is \c 0.

    \sa setMajorTickInterval( )

*/

int HbSliderControl::majorTickInterval( ) const

{

    Q_D( const HbSliderControl );

    return d->majorTickInterval;

}

/*!

    Sets the interval between major tickmarks.

    Special values:

    \li a negative value means no major ticks will be drawn

    \li value \c 0 means that the interval is automatically calculated

    \sa majorTickInterval( )

*/

void HbSliderControl::setMajorTickInterval( int interval )

{

    Q_D( HbSliderControl );

    if ( d->majorTickInterval != interval ) {

        d->majorTickInterval = qAbs ( interval );

    }

}

/*!

    Returns the minor ticklabels of the slider.

    \sa setMinorTickLabels( )

*/

QStringList HbSliderControl::minorTickLabels( ) const

{

    Q_D( const HbSliderControl );

    return  d->minorLabel;

}

/*!

    Sets the interval between minor tickmarks.

    Special values:

    \li a negative value means no minor ticks will be drawn

    \li value \c 0 means that the interval is automatically calculated

    \sa minorTickInterval( )

*/

void HbSliderControl::setMinorTickInterval( int interval )

{

    Q_D( HbSliderControl );

    if ( d->minorTickInterval != interval ) {

        d->minorTickInterval = qAbs ( interval );

        if ( d->snappingMode == MinorTickSnapping && d->minorTickInterval > 0 && d->tickPosition!= Hb::NoSliderTicks ) {

            updateSliderPosToTick( );

        }

    }

}

/*!

    Returns the interval between minor tickmarks.

    The default value is \c 0.

    \sa setMinorTickInterval( )

*/

int HbSliderControl::minorTickInterval( ) const

{

    Q_D( const HbSliderControl );

    return d->minorTickInterval;

}

/*!

    Sets the major ticklabels of the slider.

    Detailed description:

    Strings from the stringlist will be taken sequentially for drawing

    LabelItem,there exists a one-to-one mapping between tickmarkitem &

    tickmarklabelitem.

    case 1: if strings provided > tickmarks, labels are drawn for the

    strings which maps the tickmarkitems.If there are extra strings 

    available in the list beyond 1-1 mapping, those strings will be left out.

    case 2: if strings provided < tickmarks, labels are drawn only for strings

    provided.Rest of the tickmarkitems will be drawn without labelItem.

    case 3: If some tickmarkitems to be drawn without labelItem in the middle,

    specify empty string ( "" ) for that item  in the string list.

    case 4: if both major & minor tickinterval are same,then only majortickLabel

    strings are taken into account for drawing the labelItem

    \sa majorTickLabels( )

*/

void HbSliderControl::setMajorTickLabels( const QStringList &majorTickLabels )

{

    Q_D( HbSliderControl );

    d->majorLabel = majorTickLabels;

}

/*!

    Returns the minor ticklabels of the slider.

    \sa setMinorTickLabels( )

*/

QStringList HbSliderControl::majorTickLabels( ) const

{

    Q_D( const HbSliderControl );

    return d->majorLabel;

   // return static_cast<HbSliderTickmarksLabel*>( d->tickmarkslabel )->majorTickLabels( );

}

/*!

    Sets the minor ticklabels of the slider.

    see setMajorTickLabels for detailed description

    \sa minorTickLabels( ),setMajorTickLabels( )

*/

void HbSliderControl::setMinorTickLabels( const QStringList &minorTickLabels )

{

    Q_D( HbSliderControl );

    d->minorLabel = minorTickLabels;

}

/*!

    Returns the SnappingMode of the slider.

    The default value is \c HbSliderControl::MinorTickSnapping.

    \sa setSnappingMode( )

*/

HbSliderControl::SnappingMode HbSliderControl::snappingMode( ) const

{

    Q_D( const HbSliderControl );

    return d->snappingMode;

}

/*!

    Sets the snappingMode of the slider.

    \sa snappingMode( )

*/

void HbSliderControl::setSnappingMode( SnappingMode mode )

{

    Q_D( HbSliderControl );

    if ( d->snappingMode != mode ) {

        d->snappingMode = mode;

        if ( d->snappingMode != NoSnapping ) {

            updateSliderPosToTick( );

        }

    }

}

/*!

    This will enable/disable current value diplay as tooltip

    on thumb drag

*/

 void HbSliderControl::setToolTipVisible( bool value )

 {

    Q_D( HbSliderControl );

    if ( d->displayCurrValueToolTip != value ) {

        d->displayCurrValueToolTip = value;

    }

 }

 /*!

    returns whether tooltip is Enable or disable for current value

*/