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

**

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

#include "hbslidercontrol_p.h"

#include "hbslidercontrol_p_p.h"

#include <hbwidgetfeedback.h>

#include <hbstyle.h>

#include <hbstyleoptionslider_p.h>

#include <QGraphicsSceneMouseEvent>

#include <QGraphicsScene>

#ifdef HB_EFFECTS

#include "hbeffect.h"

#include "hbeffectinternal_p.h"

#define HB_SLIDERHANDLE_TYPE "HB_SLIDERHANDLE"

#endif

#ifdef HB_GESTURE_FW

#include <hbtapgesture.h>

#include <hbpangesture.h>

#include <hbtapandholdgesture.h>

#endif

/*!

    This is internal class for HbSlider

    this created slider handle

    It also has event handling for handle press/move and release

*/

/*!

    Constructs a slider handle for \a slider.

*/

HbSliderHandle::HbSliderHandle(HbSliderControl *slider)

    : HbWidget(slider),

    sliderControl(slider), 

    gItem(0) ,

    handleDragPos(0),

    touchItem(0),

    mHandleItem(0)

{

    // create handle icon item

    gItem = slider->style()->createPrimitive(HbStyle::P_Slider_thumb, this); 

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

    setFiltersChildEvents(true) ;

    // create touch area for handle

    touchItem = slider->style()->createPrimitive(HbStyle::P_SliderElement_touchhandle, this); 

    HbStyle::setItemName(touchItem , "toucharea");

    setZValue(slider->zValue() + 1);

#ifdef HB_GESTURE_FW    

    grabGesture(Qt::TapGesture);

    grabGesture(Qt::PanGesture);

    grabGesture(Qt::TapAndHoldGesture);

    if(touchItem) {

        if(QGraphicsObject *touchArea = touchItem->toGraphicsObject()) {

            touchArea->grabGesture(Qt::PanGesture);

            touchArea->grabGesture(Qt::TapGesture);

            touchArea->grabGesture(Qt::TapAndHoldGesture);

        }

    }

#endif 

#ifdef HB_EFFECTS

    // horizontal thumb press

   // HbEffectInternal::add(HB_SLIDERHANDLE_TYPE,"sliderhandle_h_press", "h_thumbpress");

    //horizonal thumb release

    //HbEffectInternal::add(HB_SLIDERHANDLE_TYPE,"sliderhandle_h_releasel", "h_thumbrelease");

    // vertical thumb press

    //HbEffectInternal::add(HB_SLIDERHANDLE_TYPE,"sliderhandle_v_press", "v_thumbpress");

    //vertical thumb release

    //HbEffectInternal::add(HB_SLIDERHANDLE_TYPE,"sliderhandle_v_release", "v_thumbrelease");

    // horizontal out of bound

    //HbEffectInternal::add(HB_SLIDERHANDLE_TYPE,"sliderhandle_h_outofbound", "h_outofbound");

    //vertical out of bound

    //HbEffectInternal::add(HB_SLIDERHANDLE_TYPE,"sliderhandle_v_outofbound", "v_outofbound");

#endif

}

/*!

    Destroys the slider handle.

*/

HbSliderHandle::~HbSliderHandle()

{

	if(mHandleItem) {

		mHandleItem->removeSceneEventFilter(this);

	}

}

/*!

  reimp

*/

/*void HbSliderHandle::polish( HbStyleParameters& params )

{

    updatePrimitives();

    HbWidget::polish(params);

}*/

/*!

  This Api set handle position and update handle icon to press ot normal

*/

void HbSliderHandle::forceSetPos(const QPointF &pos)

{

    setPos(pos);

    HbStyleOptionSlider opt;

    sliderControl->initStyleOption(&opt);

    if( scene()){

        if (true == sliderControl->isSliderDown()){

            opt.state |= QStyle::State_Sunken;

            sliderControl->style()->updatePrimitive(

                sliderControl->primitive(HbStyle::P_Slider_groove), HbStyle::P_Slider_groove, &opt);

          } else {

            opt.state &= ~QStyle::State_Sunken;

        } 

    } else {

        opt.state &= ~QStyle::State_Sunken;

    }

    opt.boundingRect=boundingRect();

    sliderControl->style()->updatePrimitive(gItem, HbStyle::P_Slider_thumb, &opt); 

}

void HbSliderHandle::setHandleItem(QGraphicsItem *item)

{

	if(!item) {

		return;

	}

	if(mHandleItem) {

		delete mHandleItem;

        mHandleItem =0;

	}

    setHandlesChildEvents(false);

    mHandleItem = item;  

	mHandleItem->setParentItem(this);

	sliderControl->style()->setItemName(mHandleItem,"widget");

    //((QGraphicsWidget*)mHandleItem)->setGeometry(gItem->geometry());//TODO:geometry from css

    if(scene()) {

        mHandleItem->removeSceneEventFilter(this);

        mHandleItem->installSceneEventFilter(this);

    }

}

QGraphicsItem *HbSliderHandle::handleItem() const

{

    return mHandleItem;

}

void HbSliderHandle::showEvent(QShowEvent *event)

{

    Q_UNUSED(event);

    if(scene()) {

        if(gItem) {

            //gItem->removeSceneEventFilter(this);

            //gItem->installSceneEventFilter(this);

        }

        if(mHandleItem && scene()) {

            mHandleItem->removeSceneEventFilter(this);

            mHandleItem->installSceneEventFilter(this);

        }

    }

}

bool HbSliderHandle::sceneEventFilter(QGraphicsItem *obj,QEvent *event)

{

    //TODO: touch area does not work with the current filtering mechanism. find better solution

	if( obj == mHandleItem) {

        if(event->type() == QEvent::GraphicsSceneMouseMove){

            mouseMoveEvent ((QGraphicsSceneMouseEvent *) event) ;

            return true;

        } else if (event->type() == QEvent::GraphicsSceneMousePress){

            mousePressEvent((QGraphicsSceneMouseEvent *) event);

            return true;

        } else if (event->type() == QEvent::GraphicsSceneMouseRelease){

            mouseReleaseEvent((QGraphicsSceneMouseEvent *) event);

            return true;

        }

	} 

    if( obj == touchItem ) {

        if (!isEnabled() ) {

            return false;

        }

	    if (event->type() == QEvent::Gesture){

            gestureEvent( (QGestureEvent *) (event));

            return true;

        }

    }

    return false;

}

/*!

  reimp

*/

void HbSliderHandle::mousePressEvent(QGraphicsSceneMouseEvent *event)

{

#ifndef HB_GESTURE_FW

    qreal span = 0;

    HbWidget::mousePressEvent(event);

    QRectF sliderBounds=sliderControl->boundingRect();

    QRectF handleBounds=boundingRect();

    sliderControl->setSliderDown(true);

    HbWidgetFeedback::triggered(sliderControl, Hb::InstantPressed, Hb::ModifierSliderHandle);

    if (scene()){

        HbStyleOptionSlider opt;

        sliderControl->initStyleOption(&opt);

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

#ifdef HB_EFFECTS

            HbEffect::start(gItem, HB_SLIDERHANDLE_TYPE, "h_thumbpress");

#endif

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

            span = sliderBounds.width();

            handleInitialPos = static_cast<int>(mapToParent(event->pos()).rx());

        } else {

#ifdef HB_EFFECTS

            HbEffect::start(gItem, HB_SLIDERHANDLE_TYPE, "v_thumbpress");

#endif

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

            span = sliderBounds.height();

            handleInitialPos = static_cast<int>(mapToParent(event->pos()).ry());

        }

        handleDragPos= QStyle::sliderPositionFromValue(opt.minimum, opt.maximum,

            sliderControl->sliderPosition(), static_cast<int>(span),opt.upsideDown);

        updatePrimitives();

    }

    event->accept();

#else

    Q_UNUSED(event)

#endif 

}

/*!

  reimp

*/

void HbSliderHandle::mouseReleaseEvent(QGraphicsSceneMouseEvent *event)

{

#ifndef HB_GESTURE_FW

    HbWidget::mouseReleaseEvent(event);

#ifdef HB_EFFECTS

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

        HbEffect::start(gItem, HB_SLIDERHANDLE_TYPE, "h_thumbrelease");

    }

    else {

        HbEffect::start(gItem, HB_SLIDERHANDLE_TYPE, "v_thumbrelease");

    }        

#endif

    HbWidgetFeedback::triggered(sliderControl, Hb::InstantReleased, Hb::ModifierSliderHandle);

    sliderControl->setSliderDown(false);

    QRectF controlRect = sliderControl->sceneBoundingRect();

    if(!controlRect.contains(event->scenePos().x() , event->scenePos().y()) ){

        sliderControl->releasedOutside(true);

    }

    if(sliderControl->singleStep() != 0) {

        HbWidgetFeedback::continuousStopped(sliderControl, Hb::ContinuousDragged);

    }

    event->accept();

    if( sliderControl->snappingMode()!= HbSliderControl::NoSnapping ){

        sliderControl->updateSliderPosToTick();

    }

    updatePrimitives();

#else

    Q_UNUSED(event)

#endif 

}

/*!

  reimp

*/

void HbSliderHandle::mouseMoveEvent(QGraphicsSceneMouseEvent *event)

{

#ifndef HB_GESTURE_FW

    qreal span = 0;

    HbWidget::mouseMoveEvent(event);

    QRectF sliderBounds=sliderControl->boundingRect();

    QRectF handleBounds=boundingRect();

    HbStyleOptionSlider opt;

    sliderControl->initStyleOption(&opt);

    int sliderPos;

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

#ifdef HB_EFFECTS

        if( sliderBounds.topLeft().x() > mapToParent(event->pos()).x() ||

            sliderBounds.bottomRight().x() < mapToParent(event->pos()).x()) {

            HbEffect::start(gItem, HB_SLIDERHANDLE_TYPE, "h_outofbound");

        }

#endif

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

        span = sliderBounds.width();

        sliderPos = static_cast<int>(

            handleDragPos+(mapToParent(event->pos()).rx()-handleInitialPos));

    } else {

#ifdef HB_EFFECTS

        if( sliderBounds.topLeft().y() > mapToParent(event->pos()).y() ||

            sliderBounds.bottomRight().y() < mapToParent(event->pos()).y()) {

            HbEffect::start(gItem, HB_SLIDERHANDLE_TYPE, "v_outofbound");

        }

#endif

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

        span = sliderBounds.height();

        sliderPos = static_cast<int>(

            handleDragPos+(mapToParent(event->pos()).ry()-handleInitialPos));

    }

    int pressValue= QStyle::sliderValueFromPosition(opt.minimum, opt.maximum,

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

    sliderControl->setSliderPosition(pressValue);

    sliderControl->showToolTip();

#else

    Q_UNUSED(event)

#endif 

}

/*!

  reimp

*/

void HbSliderHandle::gestureEvent(QGestureEvent *event)

{ 

    if(HbTapAndHoldGesture *tapandHold= qobject_cast<HbTapAndHoldGesture *>(event->gesture(Qt::TapAndHoldGesture))) {

        if(tapandHold->state() == Qt::GestureStarted) {

            sliderControl->showToolTip();

        }

    }

    if(HbTapGesture *tap = qobject_cast<HbTapGesture *>(event->gesture(Qt::TapGesture))) {

        switch(tap->state()) {

        case Qt::GestureStarted: {

            if (!sliderControl->isSliderDown( ) ) {

                sliderControl->setSliderDown(true);

                updatePrimitives();

            }

            HbWidgetFeedback::triggered(sliderControl, Hb::InstantPressed, Hb::ModifierSliderHandle);

            if (scene()){

                HbStyleOptionSlider opt;

                sliderControl->initStyleOption(&opt);

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

#ifdef HB_EFFECTS

                    HbEffect::start(gItem, HB_SLIDERHANDLE_TYPE, "h_thumbpress");

#endif

                } else {

#ifdef HB_EFFECTS

                    HbEffect::start(gItem, HB_SLIDERHANDLE_TYPE, "v_thumbpress");

#endif

                }

                event->accept();

            }

        }

        break;

        case Qt::GestureFinished:

         {

#ifdef HB_EFFECTS

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

                HbEffect::start(gItem, HB_SLIDERHANDLE_TYPE, "h_thumbrelease");

            }  else {

                HbEffect::start(gItem, HB_SLIDERHANDLE_TYPE, "v_thumbrelease");

            }

#endif

            HbWidgetFeedback::triggered(sliderControl, Hb::InstantReleased, Hb::ModifierSliderHandle);

            sliderControl->setSliderDown(false);

            updatePrimitives();

            break;

        }

        default:

            break;

        }

    }

    if (HbPanGesture *panGesture = qobject_cast<HbPanGesture*>(event->gesture(Qt::PanGesture))) {

        switch(panGesture->state( )) {

        case Qt::GestureStarted: 

        case Qt::GestureUpdated:{

            QPointF eventScenePos =panGesture->sceneOffset( )+panGesture->sceneStartPos( );

            QPointF relativePos = mapToParent( mapFromScene(eventScenePos ));

            qreal span = 0;

            QRectF sliderBounds=sliderControl->boundingRect();

            QRectF handleBounds=boundingRect();

            HbStyleOptionSlider opt;

            sliderControl->initStyleOption(&opt);

            int sliderPos;

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

#ifdef HB_EFFECTS

                if( sliderBounds.topLeft().x() > relativePos.rx( ) ||

                    sliderBounds.bottomRight().x() < relativePos.rx()) {

                    HbEffect::start(gItem, HB_SLIDERHANDLE_TYPE, "h_outofbound");

                }

#endif

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

                span = sliderBounds.width();

                sliderPos = relativePos.rx();

                sliderPos-=handleBounds.width()/2;

            } else {

#ifdef HB_EFFECTS

                if( sliderBounds.topLeft().y() > relativePos.ry() ||

                    sliderBounds.bottomRight().y() < relativePos.ry()) {

                    HbEffect::start(gItem, HB_SLIDERHANDLE_TYPE, "v_outofbound");

                }

#endif

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

                span = sliderBounds.height();

                sliderPos = relativePos.ry();

                sliderPos -=  handleBounds.height() / 2;

            }

            int pressValue= QStyle::sliderValueFromPosition(opt.minimum, opt.maximum,

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

            sliderControl->setSliderPosition(pressValue);

            sliderControl->showToolTip();

            break;

        }

        case Qt::GestureFinished:

        case Qt::GestureCanceled: {

#ifdef HB_EFFECTS

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

                HbEffect::start(gItem, HB_SLIDERHANDLE_TYPE, "h_thumbrelease");

            }  else {

                HbEffect::start(gItem, HB_SLIDERHANDLE_TYPE, "v_thumbrelease");

            }

#endif

            HbWidgetFeedback::triggered(sliderControl, Hb::InstantReleased, Hb::ModifierSliderHandle);

            sliderControl->setSliderDown(false);

            QRectF controlRect = sliderControl->sceneBoundingRect();

            if(sliderControl->singleStep() != 0) {

                HbWidgetFeedback::continuousStopped(sliderControl, Hb::ContinuousDragged);

            }

            if( sliderControl->snappingMode()!= HbSliderControl::NoSnapping ){

                sliderControl->updateSliderPosToTick();

            }

            updatePrimitives();

            break;

            }

            default:

                break;

        }

    }

}

/*!

  reimp

*/

void HbSliderHandle::updatePrimitives()

{

    HbStyleOptionSlider opt;

    sliderControl->initStyleOption(&opt);

    if( scene()){

        if (true == sliderControl->isSliderDown()){

            opt.state |= QStyle::State_Sunken;

            sliderControl->style()->updatePrimitive(

                sliderControl->primitive(HbStyle::P_Slider_groove), HbStyle::P_Slider_groove, &opt);

        } else {

            opt.state &= ~QStyle::State_Sunken;

        } 

    } else {

        opt.state &= ~QStyle::State_Sunken;

    }

    opt.boundingRect=boundingRect();

    sliderControl->style()->updatePrimitive(gItem, HbStyle::P_Slider_thumb, &opt); 

    sliderControl->style()->updatePrimitive(touchItem , HbStyle::P_SliderElement_touchhandle ,&opt);

    sliderControl->update(boundingRect());

}

/*!

  reimp

*/

QGraphicsItem * HbSliderHandle::primitive(HbStyle::Primitive primitive) const

 {

       switch (primitive) {

        case HbStyle::P_Slider_thumb:

            return gItem;

        case HbStyle::P_SliderElement_touchhandle:

            return touchItem;

        default:

            return NULL;

    }

 }