FCL/sf/mw/hb: comparison src/hbwidgets/sliders/hbslidercontrol.cpp

equal deleted inserted replaced

-:7516d6d86cf5
+:ed14f46c0e55
 #include "hbslidercontrol_p_p.h"
 #include "hbabstractslidercontrol_p.h"
 #include "hbsliderhandle_p.h"
 #include "hbstyleoptionslider_p.h"
 #include "hbslidertickmarkslabel_p.h"
+#include "hbstyle_p.h"
 #include <hbstyle.h>
 #include <hbinstance.h>
 #include <hbtheme.h>
 #include <hbtooltip.h>
 #include <hbwidgetfeedback.h>
 #include <hbgraphicsscene.h>
+#include <hbtoucharea.h>
+#include <hbslider.h>
 #include <QGraphicsItem>
 #include <QGraphicsSceneMouseEvent>
 #ifdef HB_GESTURE_FW
 #include "hbtapgesture.h"
 #include "hbpangesture.h"
+#include "hbtapandholdgesture.h"
 #endif
 #ifdef HB_EFFECTS
 #include "hbeffect.h"
 #include "hbeffectinternal_p.h"
 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
+toolTipAlignment( Qt::AlignTop ), // 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 )
+userDefinedTooltipAlign ( false ),
+tooltipArea(0),
+tooltipBorderHeight( 0 )
 {
 majorLabel.clear();
 minorLabel.clear();
 q->enableTrackEventHandling( true );
 // creating handle
 handle = createHandle();
-if(handle) {
+if (handle) {
 HbStyle::setItemName( handle, "handle" );
 }
 #if defined( QT_KEYPAD_NAVIGATION ) && !defined( Q_OS_SYMBIAN )
 q->setFocusPolicy( Qt::FocusPolicy( ( qApp->style( ) )->styleHint( QStyle::SH_Button_FocusPolicy ) ) );
 #endif
 groove = createGroove();
-if(groove) {
+if (groove) {
 HbStyle::setItemName( groove, "groove" );
 }
 #ifdef HB_GESTURE_FW
 q->setFiltersChildEvents(true) ;
 #endif
 //filled item top of groove
 if ( enableProgressTrack ) {
 progressGroove = createProgressGroove();
-if(progressGroove) {
+if (progressGroove) {
 HbStyle::setItemName( progressGroove, "progressgroove");
 }
 }
+tooltipArea = new HbTouchArea(q);
 q->connect( hbInstance->theme( ), SIGNAL( changed( ) ), q, SLOT( updateTheme( ) ) );
-q->connect( q , SIGNAL( actionTriggered( int ) ), q , SLOT( showToolTip( ) ) );
+//   q->connect( q , SIGNAL( actionTriggered( int ) ), q , SLOT( showToolTip( ) ) );
 q->connect( q , SIGNAL( sliderReleased( ) ), q , SLOT( hideToolTip( ) ) );
 #if defined( QT_KEYPAD_NAVIGATION ) && !defined( Q_OS_SYMBIAN )
 q->setFlags( QGraphicsItem::ItemIsFocusable );
 #endif
 }
+int HbSliderControlPrivate::calculateSliderPosition(QPointF relativePos)
+{
+Q_Q (HbSliderControl);
+qreal span = 0;
+qreal handlePos = 0;
+QRectF bounds = q->boundingRect( );
+QRectF handleBounds = handle->boundingRect( );
+bounds.adjust( 0, 0, -handleBounds.width( ), -handleBounds.height( ) );
+// calculate handle position and span
+switch ( q->orientation( ) ) {
+case Qt::Horizontal:
+handlePos = relativePos.x( ) - handleBounds.width( ) / 2;
+span = bounds.width( );
+break;
+case Qt::Vertical:
+handlePos = relativePos.y( ) - handleBounds.height( ) / 2;
+span = bounds.height( );
+break;
+default:
+break;
+}
+HbStyleOptionSlider opt;
+q->initStyleOption( &opt );
+int pressValue = QStyle::sliderValueFromPosition( opt.minimum, opt.maximum,
+static_cast<int>( handlePos ),static_cast<int>( span ),opt.upsideDown );
+return pressValue;
+}
 /*!
 \internal
 This is used to create the handle, it is virtual and can be overridden to create different handle.
 */
 This is used to create the groove.It can be overrideen by derived class
 */
 QGraphicsItem *HbSliderControlPrivate::createGroove()
 {
 Q_Q( HbSliderControl );
-QGraphicsItem *groove = qgraphicsitem_cast<QGraphicsItem*>( q->style( )->createPrimitive(
+QGraphicsItem *groove = qgraphicsitem_cast<QGraphicsItem*>( HbStylePrivate::createPrimitive(
-HbStyle::P_Slider_groove, q ) );
+HbStylePrivate::P_Slider_groove, q ) );
 return groove;
 }
 /*!
 \internal
 This is used to create the masked progress groove.This can be overrideen by derived class
 */
 QGraphicsItem *HbSliderControlPrivate::createProgressGroove()
 {
 Q_Q( HbSliderControl );
-QGraphicsItem *proggroove = qgraphicsitem_cast<QGraphicsItem*>( q->style( )->createPrimitive(
+QGraphicsItem *proggroove = qgraphicsitem_cast<QGraphicsItem*>( HbStylePrivate::createPrimitive(
-HbStyle::P_Slider_progressgroove, q ) );//comes on top of groove
+HbStylePrivate::P_Slider_progressgroove, q ) );//comes on top of groove
 return proggroove;
 }
 /*!
 This api adjust the handle within slider area
 }
 //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 );
+HbStylePrivate::updatePrimitive( progressGroove, HbStylePrivate::P_Slider_progressgroove, &opt );
 }
 }
 /*!
 This api returns true if pos in on handle boundingRect
 /*!
 Protected constructor for initialization from derived ctor.
 */
 HbSliderControl::HbSliderControl(HbSliderControlPrivate &dd,QGraphicsItem *parent)
-	:HbAbstractSliderControl(dd,parent)
+:HbAbstractSliderControl(dd,parent)
 {
 }
 /*!
 When theme is changed this is called.
 */
 void HbSliderControl::showToolTip( )
 {
 Q_D( HbSliderControl );
-if ( isSliderDown( ) && d->displayCurrValueToolTip ) {
+if ( d->displayCurrValueToolTip ) {
-HbToolTip::showText( toolTip( ) , d->handle->primitive(HbStyle::P_SliderElement_touchhandle) , d->toolTipAlignment );
+QRectF handleRect=d->handle->boundingRect();
-}
+QRectF tooltipRect = handleRect;
+tooltipRect.setHeight ( d->tooltipBorderHeight);
+tooltipRect.moveBottom( d->handle->pos().ry());
+tooltipRect.moveLeft (d->handle->pos().rx());
+d->tooltipArea->setGeometry(tooltipRect);
+//d->tooltipArea->update();*/
+HbToolTip::showText( toolTip( ) , d->tooltipArea, d->toolTipAlignment );
+}
 }
 /*!
 reimp
 if ( !eventRect.contains( event->scenePos( ) ) ) {
 event->ignore( );
 return;
 }
 event->accept( );
-if( d->onHandle( event->scenePos( ) ) ) {
+if ( d->onHandle( event->scenePos( ) ) ) {
 HbWidgetFeedback::triggered( this, Hb::InstantPressed, Hb::ModifierSliderHandle );
 setSliderDown( true );
 d->handle->updatePrimitives( );
 d->handleMoving = true;
 }
 else {
 // effect
 #ifdef HB_EFFECTS
-if( d->grooveTouchArea->sceneBoundingRect( ).contains( event->scenePos( ) ) ) {
+if ( d->grooveTouchArea->sceneBoundingRect( ).contains( event->scenePos( ) ) ) {
-if( orientation( ) == Qt::Horizontal ) {
+if ( orientation( ) == Qt::Horizontal ) {
 // effect for horizontal track press
 HbEffectInternal::add( HB_SLIDERCONTROL_TYPE,"slider_h_trackpress", "h_trackpress" );
 HbEffect::start( d->groove, HB_SLIDERCONTROL_TYPE, "h_trackrpress" );
 }
 else {
 initStyleOption( &opt );
 // calculate pixel value for event position
 int pressValue = QStyle::sliderValueFromPosition( opt.minimum, opt.maximum,
 static_cast<int>( handlePos ),static_cast<int>( span ),opt.upsideDown );
 //update the groove and touch item
-style( )->updatePrimitive( d->groove, HbStyle::P_Slider_groove, &opt );
+HbStylePrivate::updatePrimitive( d->groove, HbStylePrivate::P_Slider_groove, &opt );
 // if default is set then do not increment or decrement slider value
 // just set default value to slider
 if ( d->setDefault ) {
 setValue( d->previousValue );
 if ( pressValue > value( ) ) {
 #endif
 HbStyleOptionSlider opt;
 d->groovePressed = false;
 initStyleOption( &opt );
 // update primitive from press to normal
-style( )->updatePrimitive( d->groove, HbStyle::P_Slider_groove, &opt );
+HbStylePrivate::updatePrimitive( d->groove, HbStylePrivate::P_Slider_groove, &opt );
 }
 if ( event->buttons( ) ) {
 event->ignore( );
 return;
 }
 */
 #ifdef HB_GESTURE_FW
 void HbSliderControl::gestureEvent(QGestureEvent *event)
 {
 Q_D(HbSliderControl);
-if(HbTapGesture *tap = qobject_cast<HbTapGesture *>(event->gesture(Qt::TapGesture))) {
+if ( HbTapAndHoldGesture *tapandHold = qobject_cast<HbTapAndHoldGesture *> ( event->gesture( Qt::TapAndHoldGesture ) ) ) {
-if( d->onHandle( event->mapToGraphicsScene(tap->position( ) ) ) ){
+if (tapandHold->state() == Qt::GestureStarted) {
+QPointF relativePos = mapFromScene( event->mapToGraphicsScene(tapandHold->position( ) ) );
+int pressValue = d->calculateSliderPosition( relativePos );
+setToolTip(QString::number( pressValue ) );
+QRectF handleRect=d->handle->boundingRect();
+QRectF tooltipRect =  handleRect;
+QRectF touchPointRect=handleRect;
+if (orientation() == Qt::Horizontal) {
+touchPointRect.moveCenter(QPointF( boundingRect().width()/2,boundingRect( ).height()/2 ) );
+touchPointRect.moveLeft(relativePos.rx() - touchPointRect.width( )/2);
+} else {
+touchPointRect.moveCenter(QPointF( boundingRect().width()/2,boundingRect( ).height()/2 ) );
+touchPointRect.moveTop( relativePos.ry() - touchPointRect.height()/2 );
+}
+tooltipRect.setHeight ( d->tooltipBorderHeight);
+tooltipRect.moveBottom( touchPointRect.top() );
+tooltipRect.moveLeft (touchPointRect.left( ) );
+d->tooltipArea->setGeometry(tooltipRect);
+d->tooltipArea->setGeometry(tooltipRect);
+d->tooltipArea->update();
+if ( d->displayCurrValueToolTip ) {
+HbToolTip::showText( toolTip( ) , d->tooltipArea, d->toolTipAlignment );
+}
+return;
+}
+}
+if ( HbTapGesture *tap = qobject_cast<HbTapGesture *> (event->gesture( Qt::TapGesture ) )) {
+if ( d->onHandle( event->mapToGraphicsScene(tap->position( ) ) ) ) {
 event->ignore();
 return;
 }
-switch(tap->state()) {
+switch( tap->state( ) ) {
 case Qt::GestureStarted: {
 QRectF eventRect = d->grooveTouchArea->sceneBoundingRect( );
 if ( !d->trackHandlingEnable  || maximum( ) == minimum( ) ||
-!eventRect.contains( event->mapToGraphicsScene(tap->position( ) ) ) ){
+!eventRect.contains( event->mapToGraphicsScene(tap->position( ) ) ) ) {
 event->ignore( );
 return;
 }
 #if defined( QT_KEYPAD_NAVIGATION ) && !defined( Q_OS_SYMBIAN )
 }
 #endif
 event->accept( );
 // effect
 #ifdef HB_EFFECTS
-if( orientation( ) == Qt::Horizontal ) {
+if ( orientation( ) == Qt::Horizontal ) {
 // effect for horizontal track press
 HbEffectInternal::add( HB_SLIDERCONTROL_TYPE,"slider_h_trackpress", "h_trackpress" );
 HbEffect::start( d->groove, HB_SLIDERCONTROL_TYPE, "h_trackrpress" );
-}
+} else {
-else {
 HbEffectInternal::add( HB_SLIDERCONTROL_TYPE,"slider_v_trackpress", "v_trackpress" );
 HbEffect::start( d->groove, HB_SLIDERCONTROL_TYPE, "v_trackpress" );
 }
 #endif
 HbStyleOptionSlider opt;
 d->groovePressed = true;
 initStyleOption( &opt );
-style( )->updatePrimitive( d->groove, HbStyle::P_Slider_groove, &opt );
+HbStylePrivate::updatePrimitive( d->groove, HbStylePrivate::P_Slider_groove, &opt );
 HbWidgetFeedback::triggered( this, Hb::InstantPressed );
 }
 break;
 case Qt::GestureFinished:{
 if ( !d->trackHandlingEnable ) {
 event->ignore( );
 return;
 }
-qreal handlePos = 0;
-qreal span = 0;
-QRectF bounds = boundingRect( );
-QRectF handleBounds = d->handle->boundingRect( );
-bounds.adjust( 0, 0, -handleBounds.width( ), -handleBounds.height( ) );
 QPointF relativePos = mapFromScene( event->mapToGraphicsScene(tap->position( ) ) );
-// calculate handle position and span
+int pressValue = d->calculateSliderPosition (relativePos);
-switch ( orientation( ) ) {
-case Qt::Horizontal:
-handlePos = relativePos.x( ) - handleBounds.width( ) / 2;
-span = bounds.width( );
-break;
-case Qt::Vertical:
-handlePos = relativePos.y( ) - handleBounds.height( ) / 2;
-span = bounds.height( );
-break;
-default:
-break;
-}
-HbStyleOptionSlider opt;
-initStyleOption( &opt );
-int pressValue = QStyle::sliderValueFromPosition( opt.minimum, opt.maximum,
-static_cast<int>( handlePos ),static_cast<int>( span ),opt.upsideDown );
 // if default is set then don't increment or decrement slider value
 // just set default value to slider
 setSliderPosition( pressValue );
 triggerAction( SliderMove );
 setRepeatAction( SliderNoAction, pressValue );
 HbWidgetFeedback::triggered( this, Hb::InstantReleased );
 if ( d->groovePressed ) {
 #ifdef HB_EFFECTS
-if( orientation( ) == Qt::Horizontal ) {
+if ( orientation( ) == Qt::Horizontal ) {
 HbEffectInternal::add( HB_SLIDERCONTROL_TYPE,"slider_h_trackrelease", "h_trackrelease" );
 HbEffect::start( d->groove, HB_SLIDERCONTROL_TYPE, "h_trackrelease" );
 }  else {
 HbEffectInternal::add( HB_SLIDERCONTROL_TYPE,"slider_v_trackrelease", "v_trackrelease" );
 HbEffect::start( d->groove, HB_SLIDERCONTROL_TYPE, "v_trackrelease" );
 #endif
 HbStyleOptionSlider opt;
 d->groovePressed = false;
 initStyleOption( &opt );
 // update primitive from press to normal
-style( )->updatePrimitive( d->groove, HbStyle::P_Slider_groove, &opt );
+HbStylePrivate::updatePrimitive( d->groove, HbStylePrivate::P_Slider_groove, &opt );
 }
 }
 break;
 case Qt::GestureCanceled: {
 if ( d->groovePressed ) {
 #ifdef HB_EFFECTS
-if( orientation( ) == Qt::Horizontal ) {
+if ( orientation( ) == Qt::Horizontal ) {
 HbEffectInternal::add( HB_SLIDERCONTROL_TYPE,"slider_h_trackrelease", "h_trackrelease" );
 HbEffect::start( d->groove, HB_SLIDERCONTROL_TYPE, "h_trackrelease" );
 }  else {
 HbEffectInternal::add( HB_SLIDERCONTROL_TYPE,"slider_v_trackrelease", "v_trackrelease" );
 HbEffect::start( d->groove, HB_SLIDERCONTROL_TYPE, "v_trackrelease" );
 #endif
 HbStyleOptionSlider opt;
 d->groovePressed = false;
 initStyleOption( &opt );
 // update primitive from press to normal
-style( )->updatePrimitive( d->groove, HbStyle::P_Slider_groove, &opt );
+HbStylePrivate::updatePrimitive( d->groove, HbStylePrivate::P_Slider_groove, &opt );
 }
 }
 break;
 default:
 break;
 }
 }
-if (HbPanGesture *panGesture = qobject_cast<HbPanGesture*>(event->gesture(Qt::PanGesture))) {
+if ( HbPanGesture *panGesture = qobject_cast<HbPanGesture*> (event->gesture(Qt::PanGesture) ) ) {
-switch(panGesture->state( )) {
+switch(panGesture->state( ) ) {
 case Qt::GestureStarted:
 case Qt::GestureUpdated:{
 QPointF startPoint = event->mapToGraphicsScene(panGesture->offset()+panGesture->startPos( ) );
-				//if the position is on thumb , then start moving the thumb
+//if the position is on thumb , then start moving the thumb
-if( ( d->onHandle( startPoint) && d->grooveTouchArea->sceneBoundingRect( ).contains( startPoint))||isSliderDown( ) ) {
+if ( ( d->onHandle( startPoint) && d->grooveTouchArea->sceneBoundingRect( ).contains( startPoint) )||isSliderDown( ) ) {
-qreal handlePos = 0;
+QPointF relativePos = mapFromScene( event->mapToGraphicsScene(panGesture->startPos( ) + panGesture->offset() ) );
-qreal span = 0;
+int pressValue = d->calculateSliderPosition (relativePos);
-QRectF bounds = boundingRect( );
-QRectF handleBounds = d->handle->boundingRect( );
-bounds.adjust( 0, 0, -handleBounds.width( ), -handleBounds.height( ) );
-QPointF relativePos = mapFromScene( event->mapToGraphicsScene(panGesture->startPos( ) + panGesture->offset()) );
-// calculate handle position and span
-switch ( orientation( ) ) {
-case Qt::Horizontal:
-handlePos = relativePos.x( ) - handleBounds.width( ) / 2;
-span = bounds.width( );
-break;
-case Qt::Vertical:
-handlePos = relativePos.y( ) - handleBounds.height( ) / 2;
-span = bounds.height( );
-break;
-default:
-break;
-}
-HbStyleOptionSlider opt;
-initStyleOption( &opt );
-int pressValue = QStyle::sliderValueFromPosition( opt.minimum, opt.maximum,
-static_cast<int>( handlePos ),static_cast<int>( span ),opt.upsideDown );
 setRepeatAction( SliderNoAction,static_cast<int>( pressValue ) );
 setSliderDown( true );
 setSliderPosition( pressValue );
+setToolTip( QString::number( pressValue ) );
 showToolTip( );
 d->groovePressed = false;
 updatePrimitives();
 d->handleMoving = true ;
 break;
-} else if(d->grooveTouchArea->sceneBoundingRect().contains(startPoint) ){
+} else if (d->grooveTouchArea->sceneBoundingRect().contains(startPoint) ) {
+QPointF relativePos = mapFromScene( event->mapToGraphicsScene(panGesture->startPos( ) + panGesture->offset() ) );
+int pressValue = d->calculateSliderPosition (relativePos);
+setToolTip( QString::number( pressValue ) );
+QRectF handleRect=d->handle->boundingRect();
+QRectF tooltipRect =  handleRect;
+QRectF touchPointRect=handleRect;
+if (orientation() == Qt::Horizontal) {
+touchPointRect.moveCenter(QPointF( boundingRect().width()/2,boundingRect( ).height()/2 ) );
+touchPointRect.moveLeft(relativePos.rx() - touchPointRect.width( )/2);
+} else {
+touchPointRect.moveCenter(QPointF( boundingRect().width()/2,boundingRect( ).height()/2 ) );
+touchPointRect.moveTop( relativePos.ry() - touchPointRect.height()/2 );
+}
+tooltipRect.setHeight ( d->tooltipBorderHeight);
+tooltipRect.moveBottom( touchPointRect.top() );
+tooltipRect.moveLeft (touchPointRect.left( ) );
+d->tooltipArea->setGeometry(tooltipRect);
+d->tooltipArea->setGeometry(tooltipRect);
+d->tooltipArea->update();
+if ( d->displayCurrValueToolTip ) {
+HbToolTip::showText( toolTip( ) , d->tooltipArea, d->toolTipAlignment );
+}
+d->groovePressed = true;
 HbStyleOptionSlider opt;
-d->groovePressed = true;
 initStyleOption( &opt );
-style( )->updatePrimitive( d->groove, HbStyle::P_Slider_groove, &opt );
+HbStylePrivate::updatePrimitive( d->groove, HbStylePrivate::P_Slider_groove, &opt );
-HbWidgetFeedback::triggered( this, Hb::InstantPressed );
 event->ignore();
+QPointF diffOffset = panGesture->offset() - panGesture->lastOffset();
+if (orientation() == Qt::Horizontal) {
+if (qAbs(diffOffset.x() ) < qAbs(diffOffset.y())) {
+HbAbstractSliderControl::gestureEvent(event);
+}
+} else {
+if (qAbs(diffOffset.y() ) < qAbs(diffOffset.x())) {
+HbAbstractSliderControl::gestureEvent(event);
+}
+}
 break;
 } else {
 setSliderDown( false );
 d->groovePressed = false;
 updatePrimitives( );
 }
 break;
 case Qt::GestureFinished:
 case Qt::GestureCanceled: {
+QPointF startPoint = event->mapToGraphicsScene(panGesture->offset()+panGesture->startPos( ) );
 setSliderDown( false );
 d->groovePressed = false;
 updatePrimitives( );
 d->handle->updatePrimitives();
-d->handleMoving = false;
+if( d->handleMoving ) {
-				int pressValue = sliderPosition();
+HbWidgetFeedback::triggered(this, Hb::InstantReleased, Hb::ModifierSliderHandle);
-setRepeatAction( SliderNoAction,static_cast<int>( pressValue ) );
+d->handleMoving = false;
+}
+if (d->grooveTouchArea->sceneBoundingRect().contains(startPoint) ) {
+QPointF relativePos = mapFromScene( event->mapToGraphicsScene(panGesture->startPos( ) + panGesture->offset() ) );
+int pressValue = d->calculateSliderPosition (relativePos);
+setRepeatAction( SliderNoAction,static_cast<int>( pressValue ) );
+setSliderPosition( pressValue );
+setToolTip( QString::number( pressValue ) );
+showToolTip( );
+HbWidgetFeedback::triggered( this, Hb::InstantReleased );
+}
 event->ignore();
 HbAbstractSliderControl::gestureEvent(event);
 }
 break;
 default:
 Q_D(HbSliderControl);
 if( obj == d->grooveTouchArea  ) {
 if (!isEnabled() ) {
 return false;
 }
-	    if (event->type() == QEvent::Gesture){
+if (event->type() == QEvent::Gesture){
 gestureEvent( (QGestureEvent *) (event));
 return true;
 }
 }
 else if ( obj == d->handle) {
 event->ignore();
-	    if (event->type() == QEvent::Gesture){
+if (event->type() == QEvent::Gesture){
 QGestureEvent *gestureEvent = static_cast<QGestureEvent *> (event);
 foreach(QGesture *g, gestureEvent->gestures()) {
 gestureEvent->ignore(g);
 }
 }
 }
-	return false;
+return false;
 }
 /*!
 */
 void HbSliderControl::resizeEvent( QGraphicsSceneResizeEvent *event )
 {
 Q_D( HbSliderControl );
 QGraphicsWidget::resizeEvent( event );
-// for Bug Fix::Ticks are not getting updated after
-// element is added to slider
 updatePrimitives( );
-repolish();
 d->adjustHandle( );
 }
 /*!
 reimp
 */
 void HbSliderControl::polish( HbStyleParameters& params )
 {
 Q_D( HbSliderControl );
+params.addParameter("tooltip-border-height");
 HbStyleOptionSlider option;
 initStyleOption( &option );
 HbAbstractSliderControl::polish( params );
 d->adjustHandle( );
 updatePrimitives( );
+d->tooltipBorderHeight = params.value("tooltip-border-height").toReal();
 }
 /*!
 */
 }
 QGraphicsItem* HbSliderControl::handleItem( ) const
 {
 Q_D( const HbSliderControl );
-	if(d->handle) {
+if(d->handle) {
-		return d->handle->handleItem();
+return d->handle->handleItem();
-	}
+}
-	return NULL;
+return NULL;
 }
 void HbSliderControl::setHandleVisible(bool isVisible)
 {
 Q_D( HbSliderControl );
-	if(isVisible) {
+if(isVisible) {
-		d->handle->setVisible(true);
+d->handle->setVisible(true);
-	} else {
+} else {
-		d->handle->setVisible(false);
+d->handle->setVisible(false);
-	}
+}
 }
 bool HbSliderControl::handleVisible( ) const
 {
 Q_D( const HbSliderControl );
-	return d->handle->isVisible();
+return d->handle->isVisible();
 }
 /*!
 adjust the handle
 */
 {
 Q_D( HbSliderControl );
 HbAbstractSliderControl::sliderChange( change );
 d->adjustHandle( );
 if ( change == SliderOrientationChange ) {
-//Layout is not mirrored in vertical orientation with absolute ticks
-if(d->orientation ==Qt::Horizontal) {
-if (!d->userDefinedTooltipAlign) {
-d->toolTipAlignment = ( Qt::AlignTop|Qt::AlignHCenter );
-}
-} else {
-if (!d->userDefinedTooltipAlign) {
-// Bug in tooltip, cannot align it with top right
-d->toolTipAlignment = ( Qt::AlignTop|Qt::AlignHCenter );
-}
-}
 repolish( );
 }
 }
 */
 QGraphicsItem * HbSliderControl::primitive( HbStyle::Primitive primitive ) const
 {
 Q_D( const HbSliderControl );
 switch( primitive ){
-case HbStyle::P_Slider_groove:
+case HbStylePrivate::P_Slider_groove:
 return ( d->groove );
-case HbStyle::P_Slider_thumb:
+case HbStylePrivate::P_Slider_thumb:
 return ( d->handle );
-case HbStyle::P_Slider_progressgroove:
+case HbStylePrivate::P_Slider_progressgroove:
 return ( d->progressGroove );
 default:return( NULL );
 }
 }
 updatePrimitives( );
 if ( d->handle ) {
 d->handle->updatePrimitives( );
 }
 d->groovePressed = false;
-} else {
-repolish();
 }
 break;
 case ItemSceneHasChanged: {
 updatePrimitives();
 }
 opt.state |= QStyle::State_Enabled;
 } else {
 opt.state &= ~QStyle::State_Enabled;
 }
 if ( d->groove ) {
-style( )->updatePrimitive( d->groove, HbStyle::P_Slider_groove, &opt );
+HbStylePrivate::updatePrimitive( d->groove, HbStylePrivate::P_Slider_groove, &opt );
 }
 if( d->progressGroove ) {
-style( )->updatePrimitive( d->progressGroove, HbStyle::P_Slider_progressgroove, &opt );
+HbStylePrivate::updatePrimitive( d->progressGroove, HbStylePrivate::P_Slider_progressgroove, &opt );
 }
 }
 /*!
 if ( d->trackHandlingEnable == enable ) {
 return;
 }
 if ( enable ) {
 //creating groove touch area
-d->grooveTouchArea =  qgraphicsitem_cast<QGraphicsItem*>( style( )->createPrimitive(
+d->grooveTouchArea =  qgraphicsitem_cast<QGraphicsItem*>( HbStylePrivate::createPrimitive(
-HbStyle::P_SliderElement_touchgroove, this ) );
+HbStylePrivate::P_SliderElement_touchgroove, this ) );
 if ( d->grooveTouchArea ) {
 HbStyle::setItemName( d->grooveTouchArea, "groovetoucharea" );
 }
 if(QGraphicsObject *touchArea = d->grooveTouchArea->toGraphicsObject()) {
 #ifdef HB_GESTURE_FW
 ungrabGesture(Qt::TapGesture);
 ungrabGesture(Qt::PanGesture);
+ungrabGesture(Qt::TapAndHoldGesture);
 touchArea->grabGesture(Qt::TapGesture);
+touchArea->grabGesture(Qt::TapAndHoldGesture);
 touchArea->grabGesture(Qt::PanGesture);
 #endif
 }
 }
 d->trackHandlingEnable = enable ;

changeset 34	ed14f46c0e55
parent 7	923ff622b8b9