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

**

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

    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

    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

  Updates tick and Label.

  */

void HbSliderControlPrivate::updateTickAndLabel( )

{

    if (tickmarksLeft) {

        tickmarksLeft->updateTicks();

    }

    if (tickmarksRight) {

        tickmarksRight->updateTicks();

    }

    if( tickmarkslabelLeft ) {

        tickmarkslabelLeft->updateTickLabels();

    }

    if( tickmarkslabelRight ) {

        tickmarkslabelRight->updateTickLabels( );

    }

}

/*!

  \internal

  Updates tick and Label.

  */

void HbSliderControlPrivate::deleteTickAndLabel( )

{

    if (tickmarksLeft) {

        delete tickmarksLeft;

        tickmarksLeft = 0;

    }  

    if (tickmarksRight) {

        delete tickmarksRight;

        tickmarksRight = 0;

    }

    if( tickmarkslabelLeft ) {

        delete tickmarkslabelLeft;

        tickmarkslabelLeft = 0;

    }

    if( tickmarkslabelRight ) {

        delete tickmarkslabelRight;

        tickmarkslabelRight = 0;

    }

}

/*!

  \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( ) );

}

void HbSliderControlPrivate::createSliderTicks( )

{

    Q_Q ( HbSliderControl);

    if (! tickmarksLeft) {

        tickmarksLeft =  new HbSliderTickmarks(q);

        tickmarksLeft->setTickPosition (Hb::SliderTicksLeft);

        } 

    if (!tickmarksRight) {

       tickmarksRight =  new HbSliderTickmarks(q);

       tickmarksRight->setTickPosition ( Hb::SliderTicksRight);

    }

    if ( orientation == Qt::Vertical ) {

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

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

    } else {

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

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

    }

}

void HbSliderControlPrivate::positionTickMarks( )

{

    Q_Q (HbSliderControl);

    if (!tickmarksLeft||!tickmarksRight) {

        return;

    }

      // SliderTickLeft and SliderTicksAbove value is same

    if ( tickPosition & Hb::SliderTicksLeft) {

        tickmarksLeft->createIcons(true);

    } else {

        tickmarksLeft->createIcons(false);

    }

    if ( tickPosition & Hb::SliderTicksRight ) {

        tickmarksRight->createIcons(true);

    } else {

        tickmarksRight->createIcons(false);

    }

    if ( orientation == Qt::Vertical ) {

        if ( tickPosition & Hb::SliderTicksAbsolute)  {

            q->setLayoutDirection (Qt::LeftToRight );

            }

    }

}

void HbSliderControlPrivate::createSliderTickLabels( )

{   

    Q_Q(HbSliderControl);

    if (! tickmarkslabelLeft) {

        tickmarkslabelLeft =  new HbSliderTickmarksLabel(q);

        tickmarkslabelLeft->setTickPosition (Hb::SliderTicksLeft);

     } 

    if (!tickmarkslabelRight) {

        tickmarkslabelRight =  new HbSliderTickmarksLabel(q);

        tickmarkslabelRight->setTickPosition (Hb::SliderTicksRight );

     }

    if ( orientation == Qt::Horizontal ) {

        HbStyle::setItemName( tickmarkslabelLeft, "tick-textsabove" );

        HbStyle::setItemName( tickmarkslabelRight, "tick-textsbelow" );

    } else {

        HbStyle::setItemName( tickmarkslabelLeft, "tick-textsleft" );

        HbStyle::setItemName( tickmarkslabelRight, "tick-textsright" );

    }

}

void HbSliderControlPrivate::positionTickMarksLabel( )

{

    if (!tickmarkslabelLeft||!tickmarkslabelRight) {

        return;

    }

      // SliderTickLeft and SliderTicksAbove value is same

    if ( tickPosition & Hb::SliderTicksLeft) {

        tickmarkslabelLeft->createText(true);

    } else {

        tickmarkslabelLeft->createText(false);

    }

    if ( tickPosition & Hb::SliderTicksRight ) {

        tickmarkslabelRight->createText(true);

    } else {

        tickmarkslabelRight->createText(false);

    }

}

/*!

    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;

        unsetLayoutDirection( );

        if ( position == Hb::NoSliderTicks) {

            d->deleteTickAndLabel( );

        } else {

            if ( (!d->tickmarksLeft || !d->tickmarksRight) && d->majorTickInterval > 0) {

                d->createSliderTicks( );

                d->positionTickMarks( );

                repolish( );

            }

            if ( (!d->tickmarkslabelLeft || !d->tickmarkslabelRight) && d->majorTickInterval > 0 &&

                (!d->majorLabel.isEmpty( ) || (!d->minorLabel.isEmpty( ) && d->minorTickInterval > 0) ) ) {

                d->createSliderTickLabels( );

                d->positionTickMarksLabel ( );

                repolish( );

            }

            d->positionTickMarks( );

            d->positionTickMarksLabel( );

        }

    }

}

/*!

    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( )