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

equal deleted inserted replaced

-:7516d6d86cf5
+:ed14f46c0e55
 ****************************************************************************/
 #include "hbprogressslider_p.h"
 #include <hbprogressslider.h>
 #include <hbstyleoptionprogressslider_p.h>
+#include "hbprogresstrackitem_p.h"
 #include <hbtooltip.h>
 #include <hbwidgetfeedback.h>
 #include "hbglobal_p.h"
+#include <hbtoucharea.h>
 #include <QGraphicsSceneMouseEvent>
 #include <QApplication>
 #ifdef HB_EFFECTS
 #include <hbeffect.h>
 #include "hbeffectinternal_p.h"
 #define HB_PRGRESSSLIDER_ITEM_TYPE "HB_PROGRESSSLIDER"
 #endif
+#ifdef HB_GESTURE_FW
+#include <hbtapgesture.h>
+#endif
 HbProgressSliderPrivate::HbProgressSliderPrivate()
 {
 mDownState=false;
 handle = 0;
 mSliderValue = 0;
 mHandlePath.clear();
+mToolTipTextVisibleUser = false;
 }
 HbProgressSliderPrivate::~HbProgressSliderPrivate()
 {
 if (handle) {
 delete handle;
 }
 }
+bool HbProgressSliderPrivate::textVisible() const
+{
+return mToolTipTextVisibleUser;
+}
 void HbProgressSliderPrivate::setProgressValue(int value)
 {
 Q_Q(HbProgressSlider);
 if (mProgressValue == value) {
 return;
 }
 if (value >= mMaximum) {
 value = mMaximum;
 #ifdef HB_EFFECTS
-// HbEffect::start(mTrack, HB_PRGRESSSLIDER_ITEM_TYPE, "progressbar_progress_complete");
+HbEffect::start(mTrack, HB_PRGRESSSLIDER_ITEM_TYPE, "progressbar_progress_complete");
 #endif
 }
 else if (value < mMinimum) {
 value = mMinimum;
 }
 mProgressValue=value;
 //redraw track
-HbStyleOptionProgressSlider sliderOption;
+updateProgressTrack();
-q->initStyleOption(&sliderOption);
-if(mTrack) {
-q->style()->updatePrimitive(mTrack, HbStyle::P_ProgressSlider_track, &sliderOption);
-}
 emit q->valueChanged(value);
 }
 void HbProgressSliderPrivate::setEnableFlag(bool flag)
 {
 Q_Q(HbProgressSlider);
-	Q_UNUSED(flag);
+Q_UNUSED(flag);
-HbStyleOptionProgressSlider option;
-q->initStyleOption(&option);
 q->updatePrimitives();
+if(flag) {
+handle->setHandleNormalState();
+}
 }
 void HbProgressSliderPrivate::init()
 {
 Q_Q(HbProgressSlider);
-mSliderGraphicItem  = q->style()->createPrimitive(HbStyle::P_ProgressSlider_slidertrack,mFrame);
+mSliderGraphicItem = new HbProgressTrackItem(mFrame);
+HbStyle::setItemName(mSliderGraphicItem, "slider-track");
+qgraphicsitem_cast<HbProgressTrackItem*>(mSliderGraphicItem)->frameDrawer().setFillWholeRect(true);
+mSliderGraphicItem->setZValue(-1);
 // Show the touch area which is created in ProgressBar//
-mTouchAreaItem = q->style()->createPrimitive(HbStyle::P_ProgressSlider_toucharea,q);
+mTouchAreaItem =  q->style()->createPrimitive(HbStyle::PT_TouchArea, "toucharea",q);
+mTouchAreaItem->setFlag(QGraphicsItem::ItemIsFocusable);
+mTouchAreaItem->setZValue(TOUCHAREA_ZVALUE);
 mFrame->setZValue(mTouchAreaItem->zValue()+1);
 #ifdef HB_EFFECTS
 HbEffectInternal::add(HB_PRGRESSSLIDER_ITEM_TYPE,"progressslider_trackpress", "progressslider_trackpress");
 HbEffectInternal::add(HB_PRGRESSSLIDER_ITEM_TYPE,"progressslider_trackrelease", "progressslider_trackrelease");
 #endif
-q->grabGesture(Qt::TapGesture);
+#ifdef HB_GESTURE_FW
+mTouchAreaItem->grabGesture(Qt::TapGesture);
-if(QGraphicsObject *touchArea = mTouchAreaItem->toGraphicsObject()) {
+#endif
-touchArea->grabGesture(Qt::TapGesture);
-}
 }
 void HbProgressSliderPrivate::emitSliderPressed()
 {
 Q_Q(HbProgressSlider);
 }
 void HbProgressSliderPrivate::emitSliderReleased()
 {
 Q_Q(HbProgressSlider);
+if(mDownState){
+mDownState = false;
+if (mFrame) {
+HbStyleFramePrimitiveData data;
+q->initPrimitiveData(&data, mFrame);
+q->style()->updatePrimitive(mFrame, &data, q);
+}
+HbWidgetFeedback::triggered(q, Hb::InstantReleased);
+#ifdef HB_EFFECTS
+HbEffect::start(q, HB_PRGRESSSLIDER_ITEM_TYPE, "progressslider_trackrelease");
+#endif
+}
 emit q->sliderReleased();
 }
 void HbProgressSliderPrivate::emitSliderMoved(int newValue)
 {
 QRectF HbProgressSliderPrivate::boundingRect()const
 {
 return mFrame->boundingRect();
 }
-HbStyle* HbProgressSliderPrivate::style() const
-{
-Q_Q(const HbProgressSlider);
-return q->style();
-}
 QGraphicsItem* HbProgressSliderPrivate::parentGraphicsItem() const
 {
 return mFrame;
 }
 return mOrientation;
 }
 void HbProgressSliderPrivate::setRange(int minimum, int maximum)
 {
-	Q_Q(HbProgressSlider);
+Q_Q(HbProgressSlider);
 if( minimum > maximum ){
 maximum = minimum ;
 }
 mMinimum = minimum;
 mMaximum = maximum;
 if(mProgressValue > mMaximum){
 mProgressValue = mMaximum;
 }
-HbStyleOptionProgressSlider progressSliderOption;
+updateSliderTrack();
-q->initStyleOption(&progressSliderOption);
+updateProgressTrack();
+q->setSliderValue(mSliderValue);
+}
+/*
+\internal
+Update progress track primitive
+*/
+void HbProgressSliderPrivate::updateProgressTrack()
+{
+Q_Q(HbProgressSlider);
+if (mTrack) {
+HbProgressTrackItem* frameItem = qgraphicsitem_cast<HbProgressTrackItem*>(mTrack);
+if(!frameItem->isVisible()) {
+return;
+}
+frameItem->frameDrawer().setFrameType(HbFrameDrawer::ThreePiecesHorizontal);
+if(!q->isEnabled()){
+frameItem->frameDrawer().setFrameGraphicsName(QLatin1String("qtg_fr_progslider_loaded_disabled"));
+}
+else
+frameItem->frameDrawer().setFrameGraphicsName(QLatin1String("qtg_fr_progslider_loaded"));
+frameItem->setMaximum(mMaximum);
+frameItem->setMinimum(mMinimum);
+frameItem->setValue(mProgressValue);
+frameItem->setInverted(mInvertedAppearance);
+frameItem->setOrientation(mOrientation);
+frameItem->update();
+}
+}
+/*
+\internal
+Update slider track primitive
+*/
+void HbProgressSliderPrivate::updateSliderTrack()
+{
+Q_Q(HbProgressSlider);
 if (mSliderGraphicItem) {
-q->style()->updatePrimitive(mSliderGraphicItem, HbStyle::P_ProgressSlider_slidertrack, &progressSliderOption);
+HbProgressTrackItem* frameItem = qgraphicsitem_cast<HbProgressTrackItem*>(mSliderGraphicItem);
-}
+if(!frameItem->isVisible()) {
+return;
-if (mTrack) {
+}
-q->style()->updatePrimitive(mTrack, HbStyle::P_ProgressSlider_track, &progressSliderOption);
-}
+frameItem->frameDrawer().setFrameType(HbFrameDrawer::ThreePiecesHorizontal);
+if(!q->isEnabled()){
-	q->setSliderValue(mSliderValue);
+frameItem->frameDrawer().setFrameGraphicsName(QLatin1String("qtg_fr_progslider_played_disabled"));
 }
+else
+frameItem->frameDrawer().setFrameGraphicsName(QLatin1String("qtg_fr_progslider_played"));
+frameItem->setMaximum(mMaximum);
+frameItem->setMinimum(mMinimum);
+frameItem->setValue(mSliderValue);
+frameItem->setInverted(mInvertedAppearance);
+frameItem->setOrientation(mOrientation);
+frameItem->update();
+}
+}
 /*!
 @beta
 @hbwidgets
 \class HbProgressSlider
 HbProgressSlider emits below signals
 void sliderPressed();
 void sliderReleased();
 void sliderMoved(int value);
+void trackPressed();
-sliderPressed is emitted when the track is pressed.
+void trackReleased();
-sliderReleased is emitted when the track is released.
+sliderPressed is emitted when the handle is pressed.
+sliderReleased is emitted when the handle is released.
 sliderMoved is emitted when the handle is moved in any direction.
+trackPressed is emitted when the track is pressed.
+trackReleased is emitted when the track is released.
 The Application can customize the Slider behaviour by listening to the signals sliderPressed and sliderReleased.By default there
 is no behaviour defined by HbProgressSlider for these actions.
 By default the min value is 0 and max value is 100. The application can set the progressValue (buffer data) and
 d->init();
 setMinMaxTextVisible(true);
 setFocusPolicy(Qt::FocusPolicy(qApp->style()->styleHint(QStyle::SH_Button_FocusPolicy)));
 d->handle =new HbProgressSliderHandle(d);
+d->handle->setZValue(1010);
 if(!flags().testFlag(ItemIsFocusable)) {
 d->handle->setVisible(false);
 }
 if(d->mOrientation == Qt::Horizontal){
 qreal x = boundingRect().height();
 \param parent The parent of ProgressBar
 */
 HbProgressSlider::HbProgressSlider(HbProgressSliderPrivate &dd,QGraphicsItem *parent) :
 HbProgressBar( dd,parent)
 {
 Q_D( HbProgressSlider );
 d->init();
 setFocusPolicy(Qt::FocusPolicy(qApp->style()->styleHint(QStyle::SH_Button_FocusPolicy)));
 d->handle =new HbProgressSliderHandle(d);
 if (value<minimum()) {
 value = minimum();
 }
 d->mSliderValue = value;
-HbStyleOptionProgressSlider option;
+d->updateSliderTrack();
-initStyleOption(&option);
-if (d->mSliderGraphicItem) {
-style()->updatePrimitive(d->mSliderGraphicItem, HbStyle::P_ProgressSlider_slidertrack, &option);
-}
 d->handle->setHandlePosForValue(sliderValue());
 }
 /*!
 @beta
 /*!
 \reimp
 */
 void HbProgressSlider::mousePressEvent(QGraphicsSceneMouseEvent *event)
 {
+#ifndef HB_GESTURE_FW
 Q_D(HbProgressSlider);
 QRectF rect = d->mTouchAreaItem->sceneBoundingRect( );
 // return if point is outside track touch area
 if ( !rect.contains( event->scenePos( ) ) ) {
 return;
 }
 if(flags().testFlag(ItemIsFocusable)) {
 d->mDownState = true;
-HbStyleOptionProgressSlider option;
-initStyleOption(&option);
 if (d->mFrame) {
-style()->updatePrimitive(d->mFrame, HbStyle::P_ProgressSlider_frame, &option);
+HbStyleFramePrimitiveData data;
+initPrimitiveData(&data, d->mFrame);
+style()->updatePrimitive(d->mFrame, &data, this);
 }
 HbWidgetFeedback::triggered(this, Hb::InstantPressed);
+emit trackPressed();
 d->handle->handleTrackPress(event);
 event->accept();
 #ifdef HB_EFFECTS
 HbEffect::start(this, HB_PRGRESSSLIDER_ITEM_TYPE, "progressslider_trackpress");
 #endif
 } else {
 event->ignore();
 }
+#else
+Q_UNUSED(event)
+#endif
 }
 /*!
 \reimp
 */
 void HbProgressSlider::mouseReleaseEvent(QGraphicsSceneMouseEvent *event)
 {
+#ifndef HB_GESTURE_FW
 Q_D(HbProgressSlider);
 if(flags().testFlag(ItemIsFocusable)) {
 d->mDownState = false;
-HbStyleOptionProgressSlider option;
-initStyleOption(&option);
 if (d->mFrame) {
-style()->updatePrimitive(d->mFrame, HbStyle::P_ProgressSlider_frame, &option);
+HbStyleFramePrimitiveData data;
+initPrimitiveData(&data, d->mFrame);
+style()->updatePrimitive(d->mFrame, &data, this);
 }
 HbWidgetFeedback::triggered(this, Hb::InstantReleased);
 d->handle->handleTrackRelease(event);
+emit trackReleased();
 event->accept();
 #ifdef HB_EFFECTS
 HbEffect::start(this, HB_PRGRESSSLIDER_ITEM_TYPE, "progressslider_trackrelease");
 #endif
 } else {
 event->ignore();
 }
-}
+#else
+Q_UNUSED(event)
+#endif
+}
+#ifdef HB_GESTURE_FW
+void HbProgressSlider::gestureEvent(QGestureEvent *event)
+{
+Q_D (HbProgressSlider);
+if(event->gesture(Qt::TapGesture)) {
+HbTapGesture *tapGesture = static_cast<HbTapGesture *>(event->gesture(Qt::TapGesture));
+switch(tapGesture->state()) {
+case Qt::GestureStarted :{
+QRectF rect = d->mTouchAreaItem->sceneBoundingRect( );
+// return if point is outside track touch area
+if ( !rect.contains( event->mapToGraphicsScene(tapGesture->position( ) ) ) ) {
+event->ignore( );
+return;
+}
+if(flags().testFlag(ItemIsFocusable)) {
+#ifdef HB_EFFECTS
+HbEffect::start(this, HB_PRGRESSSLIDER_ITEM_TYPE, "progressslider_trackpress");
+#endif
+d->mDownState = true;
+if (d->mFrame) {
+HbStyleFramePrimitiveData data;
+initPrimitiveData(&data, d->mFrame);
+style()->updatePrimitive(d->mFrame, &data, this);
+}
+HbWidgetFeedback::triggered(this, Hb::InstantPressed);
+emit trackPressed();
+d->handle->handleTrackPress(event);
+event->accept();
+}
+else {
+event->ignore();
+}
+}
+break;
+case Qt::GestureCanceled:
+case Qt::GestureFinished:{
+if(d->mDownState) {
+if(flags().testFlag(ItemIsFocusable)) {
+#ifdef HB_EFFECTS
+HbEffect::start(this, HB_PRGRESSSLIDER_ITEM_TYPE, "progressslider_trackrelease");
+#endif
+d->mDownState = false;
+if (d->mFrame) {
+HbStyleFramePrimitiveData data;
+initPrimitiveData(&data, d->mFrame);
+style()->updatePrimitive(d->mFrame, &data, this);
+}
+HbWidgetFeedback::triggered(this, Hb::InstantReleased);
+d->handle->handleTrackRelease(event);
+emit trackReleased();
+event->accept();
+} else {
+event->ignore();
+}
+}
+}
+break;
+default:break;
+}
+}
+}
+#endif
 /*!
 \reimp
 */
 void HbProgressSlider::setGeometry(const QRectF & rect)
 {
 }
 else {
 option->disableState = true;
 }
 }
+/*!
+\reimp
+*/
+void HbProgressSlider::initPrimitiveData(HbStylePrimitiveData *primitiveData, const QGraphicsObject *primitive)
+{
+Q_D(HbProgressSlider);
+QString itemName = HbStyle::itemName(primitive);
+if (itemName == QLatin1String("frame")) {
+HbStyleFramePrimitiveData *data = hbstyleprimitivedata_cast<HbStyleFramePrimitiveData*>(primitiveData);
+data->frameType = HbFrameDrawer::ThreePiecesHorizontal;
+if (!isEnabled() ) {
+data->frameGraphicsName = QLatin1String("qtg_fr_progslider_frame_disabled");
+}
+else {
+if(d->mDownState) {
+data->frameGraphicsName = QLatin1String("qtg_fr_progslider_frame_pressed");
+}
+else {
+data->frameGraphicsName = QLatin1String("qtg_fr_progslider_frame_normal");
+}
+}
+}
+}
 /*!
 \reimp
 */
 void HbProgressSlider::updatePrimitives()
 {
 Q_D(HbProgressSlider);
 if(isVisible()){
 d->mWaitTrack->setVisible(false);
 d->mTrack->setVisible(true);
-HbStyleOptionProgressSlider option;
-initStyleOption(&option);
-if (d->mSliderGraphicItem) {
-style()->updatePrimitive(d->mSliderGraphicItem, HbStyle::P_ProgressSlider_slidertrack, &option);
-}
-if(d->handle)
-d->handle->setHandlePosForValue(sliderValue());
 if (d->mFrame) {
-style()->updatePrimitive(d->mFrame, HbStyle::P_ProgressSlider_frame, &option);
+HbStyleFramePrimitiveData data;
-}
+initPrimitiveData(&data, d->mFrame);
+style()->updatePrimitive(d->mFrame, &data, this);
+}
+// update progress value mask
+d->updateProgressTrack();
-if (d->mTrack) {
+// update slider value mask
-style()->updatePrimitive(d->mTrack, HbStyle::P_ProgressSlider_track, &option);
+d->updateSliderTrack();
-}
 if(d->mMinTextItem && d->mMinMaxTextVisible) {
-style()->updatePrimitive(d->mMinTextItem,HbStyle::P_ProgressBar_mintext,&option);
+HbStyleTextPrimitiveData data;
+HbProgressBar::initPrimitiveData(&data, d->mMinTextItem);
+style()->updatePrimitive(d->mMinTextItem, &data, this);
 }
 if(d->mMaxTextItem && d->mMinMaxTextVisible) {
-style()->updatePrimitive(d->mMaxTextItem,HbStyle::P_ProgressBar_maxtext,&option);
+HbStyleTextPrimitiveData data;
-}
+HbProgressBar::initPrimitiveData(&data, d->mMaxTextItem);
+style()->updatePrimitive(d->mMaxTextItem, &data, this);
+}
+if(d->handle)
+d->handle->setHandlePosForValue(sliderValue());
 }
 }
 /*!
 \reimp
 */
 return HbProgressBar::itemChange(change, value);
 }
 /*!
 \reimp
 */
-bool HbProgressSlider::sceneEventFilter(QGraphicsItem *obj,QEvent *event)
+void HbProgressSlider::mouseMoveEvent(QGraphicsSceneMouseEvent *event)
 {
-Q_D(HbProgressSlider);
+#ifndef HB_GESTURE_FW
-if( obj == d->mTouchAreaItem) {
+Q_D(HbProgressSlider);
-if (!isEnabled() ) {
+QRectF rect = d->mTouchAreaItem->sceneBoundingRect( );
-return false;
+// return if point is outside track touch area
-}
+if ( !rect.contains( event->scenePos( ) ) ) {
-if (event->type() == QEvent::GraphicsSceneMousePress){
+event->ignore( );
-mousePressEvent((QGraphicsSceneMouseEvent *) event);
+return;
-return true;
+}
-}
-else if (event->type() == QEvent::GraphicsSceneMouseRelease){
+if(flags().testFlag(ItemIsFocusable)) {
-mouseReleaseEvent((QGraphicsSceneMouseEvent *) event);
+d->handle->handleTrackPress(event);
-return true;
+event->accept();
-}
+} else {
-}
+event->ignore();
-return false;
+}
-}
+#else
+Q_UNUSED(event)
+#endif
+}
 /*!
 @beta
 Sets the tooltip for the Slider handle. By default it shows the slider value.
-The application can customize the tooltip text using this API.
+The application can customize the tooltip text using this API. setting NULL string
+will disable the tooltip.
 \param text tooltip text
 \sa sliderToolTip()
 */
 void HbProgressSlider::setSliderToolTip(const QString &text)
 {
 Q_D(HbProgressSlider);
 d->mTooltipText = text;
+d->mToolTipTextVisibleUser = true;
 }
 /*!
 @beta
 {
 Q_D(const HbProgressSlider);
 return d->mHandlePath;
 }
-/*!
+bool HbProgressSlider::sceneEventFilter(QGraphicsItem *obj,QEvent *event)
+{
-\deprecated HbProgressSlider::primitive(HbStyle::Primitive)
+Q_D(HbProgressSlider);
-is deprecated.
+bool accepted = false;
-Returns the pointer for \a primitive passed.
+if( obj == d->mTouchAreaItem)
-Will return NULL if \a primitive passed is invalid
+if (!isEnabled() ) {
-*/
+return false;
-QGraphicsItem* HbProgressSlider::primitive(HbStyle::Primitive primitive) const
+}
+if(obj == static_cast<HbTouchArea*>(d->mTouchAreaItem)) {
+if(event->type() == QEvent::Gesture ) {
+gestureEvent(static_cast<QGestureEvent *>( event ));
+}
+}
+return accepted;
+}
+QGraphicsItem *HbProgressSlider::primitive(const QString &itemName) const
 {
 Q_D(const HbProgressSlider);
-switch (primitive) {
+if(!itemName.compare(QString("slider-track"))){
-case HbStyle::P_ProgressSlider_frame:
+return d->mSliderGraphicItem;
-return d->mFrame;
+}
-case HbStyle::P_ProgressSlider_track:
+if(!itemName.compare(QString("toucharea"))){
-return d->mTrack;
+return d->mTouchAreaItem;
-case HbStyle::P_ProgressSlider_slidertrack:
+}
-return d->mSliderGraphicItem;
+if(!itemName.compare(QString("handle-icon")) ||
-case HbStyle::P_ProgressSlider_toucharea:
+!itemName.compare(QString("handle-toucharea"))){
-return d->mTouchAreaItem;
+return d->handle->primitive(itemName);
-case HbStyle::P_ProgressSliderHandle_icon:
+}
-case HbStyle::P_ProgressSliderHandle_toucharea:
-return d->handle->primitive(primitive);
+return HbProgressBar::primitive(itemName);
-default:
+}
-return 0;
-}
-}

changeset 34	ed14f46c0e55
parent 6	c3690ec91ef8