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

**

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

#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");

    // 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);

    if(touchItem) {

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

            Q_UNUSED(touchArea);

               touchArea->grabGesture(Qt::PanGesture);

               touchArea->grabGesture(Qt::TapGesture);

        }

    }

#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);

    }

	mHandleItem->setFlag(QGraphicsItem::ItemIsMovable,true);//required as the press has to be accepted to filter move events.

}

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 doesnt 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);

		}

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

			mouseReleaseEvent((QGraphicsSceneMouseEvent *) event);

		}

	} 

	return false;

}

/*!

  reimp

*/

void HbSliderHandle::mousePressEvent(QGraphicsSceneMouseEvent *event)

{

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

}

/*!

  reimp

*/

void HbSliderHandle::mouseReleaseEvent(QGraphicsSceneMouseEvent *event)

{

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

}

/*!

  reimp

*/

void HbSliderHandle::mouseMoveEvent(QGraphicsSceneMouseEvent *event)

{

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

}

/*!

  reimp

*/

void HbSliderHandle::gestureEvent(QGestureEvent *event)

{

    Q_UNUSED(event);

    // HbWidgetBase::gestureEvent() ignores, overriding to accept

}

/*!

  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;

    }

 }