diff -r 000000000000 -r 16d8024aca5e src/hbwidgets/sliders/hbslider.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/hbwidgets/sliders/hbslider.cpp Mon Apr 19 14:02:13 2010 +0300 @@ -0,0 +1,1776 @@ +/**************************************************************************** +** +** 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 "hbslider.h" +#include "hbslider_p.h" +#include "hbslidercontrol_p.h" +#include "hbslidercontrol_p_p.h" +#include "hbnamespace_p.h" +#include "hbsliderhandle_p.h" + +#include "hbstyleoptionslider.h" +#include "hbslidertickmarkslabel_p.h" +#include "hbabstractbutton.h" +#include +#include +#include +#include +#include + +#ifdef HB_EFFECTS +#include "hbeffect.h" +#include "hbeffectinternal_p.h" +#define HB_SLIDER_TYPE "HB_SLIDER" +#endif + + +/*! + @beta + @hbwidgets + \class HbSlider + \brief HbSlider widget provides a generic vertical or horizontal slider. + + HbSlider is a classic widget for controlling a bounded value. + It lets the user move a slider handle along a horizontal or vertical + track and translates the handle's position into an integer value + within the legal range. + + \image html hbslider.png A horizontal slider. + + The most important functions are setValue( ) to set the slider directly + to some value; and setMinimum( ) and setMaximum( ) to define the range + of the slider. + + HbSlider consists of elements. The available slider elements are + defined by the HbSlider::SliderElement enumeration. A set of elements + can be set by setSliderElements( ) and currently existing elements can be + queried by sliderElements( ).All elements are optional + Example usage: + \code + HbSlider *slider = new HbSlider( ); + QList elements; + elements << QVariant (HbSlider::IncreaseElement) + << QVariant (HbSlider::TrackElement) + << QVariant (HbSlider::DecreaseElement) + << QVariant (HbSlider::IconElement) + << QVariant (HbSlider::TextElement); + slider->setSliderElements( elements ); + QMap map; + // Icon path should be valid + map.insert(QString("IncreaseElement") , QVariant(":/unittest_hbslider/star_on.png")); + map.insert(QString("DecreaseElement") , QVariant(":/unittest_hbslider/star_on2.png")); + map.insert(QString("IconElement") , QVariant(":/unittest_hbslider/star_on3.png")); + slider->setElementIcons( map ); + \endcode + + \image html verticalslider.png A Custom vertical slider with all elements. + + order in which HbSlider::SliderElement are inserted into QList doesnt matter. + + HbSlider provides methods for controlling tickmarks. You can use + setTickPosition( ) to indicate where you want the tickmarks to be, + setMajorTickInterval( ) and setMinorTickInterval( ) to indicate how + many of them you want. The current set tick position and intervals + can be queried using the tickPosition( ), majorTickInterval( ) and + minorTickInterval( ) functions, respectively. + + HbSlider provides only integer ranges. Note that although + HbSlider handles very large numbers, it becomes difficult for users + to use a slider accurately for very large ranges. + + HbSlider also provide functionality of filling groove ( like progress ) + of slider. However this functionality is configurable and can be changed by + setTrackFilled(), By Default this will be enabled + + The slider handles keys in the following way: + \li Left/Right moves a horizontal slider by one single step. + \li Up/Down moves a vertical slider by one single step. + + Example usage: + \dontinclude slider/main.cpp + \skip Start of snippet 1 + \until End of snippet 1 + + \sa HbZoomSlider, HbVolumeSlider +*/ + +/*! + \fn void HbSlider::valueChanged( int value ) + + This signal is emitted when the slider value has changed. + + \sa hasTracking( ) +*/ + +/*! + \fn void HbSlider::sliderPressed( ) + + This signal is emitted when the slider thumb has been pressed. +*/ + +/*! + \fn void HbSlider::sliderReleased( ) + + This signal is emitted when the slider thumb has been released. +*/ + +/*! + \fn void HbSlider::sliderMoved( int value ) + + This signal is emitted when the slider position has changed. + + \sa hasTracking( ) +*/ + +/*! + \fn void HbSlider::rangeChanged( int min, int max ) + + This signal is emitted when the slider range has changed. +*/ + +/*! + \fn void HbSlider::iconPressed( ) + + This signal is emitted when the slider icon has been pressed. +*/ + +/*! + \fn void HbSlider::iconReleased( ) + + This signal is emitted when the slider icon has been released. +*/ + +/*! + \fn void HbSlider::iconClicked( ) + + This signal is emitted when the slider icon has been clicked. +*/ + +/*! + \fn void HbSlider::iconToggled( bool checked ) + + This signal is emitted when the slider icon is checkable and it has been toggled. +*/ + +/*! + \reimp + \fn int HbSlider::type( ) const + */ + +/*! + \enum HbSlider::SliderElement + + This enum defines available slider elements. + */ + +/*! + \var HbSlider::IncreaseElement + + A button to increase the slider value. Usually a plus sign. + */ + +/*! + \var HbSlider::TrackElement + + The slider track that consists of a groove, ticks and handle. + */ + +/*! + \var HbSlider::DecreaseElement + + A button to decrease the slider value. Usually a minus sign. + */ + +/*! + \var HbSlider::IconElement + + An icon element associated to the slider. + */ + +/*! + \var HbSlider::TextElement + + A text element associated to the slider. + */ + +/*! + \enum HbSlider::SnappingMode + + This enum defines available SnappingModes. + */ + +/*! + \var HbSlider::NoSnapping + + slider do not snap incase of NoSnapping but by deault it will be snapped to minrotick. + */ + +/*! + \var HbSlider::MajorTickSnapping + + slider snaps to major tick incase of drag. + */ + +/*! + \var HbSlider::MinorTickSnapping + + slider snaps to minor tick incase of drag. + */ + +HbSliderPrivate::HbSliderPrivate( ) : + sliderControl( 0 ), + orientation( Qt::Vertical ), + pressOnIncrement( false ) +{ + elementItemMap.clear(); + +} + +HbSliderPrivate::~HbSliderPrivate( ) +{ +} + + +void HbSliderPrivate::init( ) +{ + Q_Q( HbSlider ); + + sliderControl = new HbSliderControl( orientation, q ); + HbStyle::setItemName( sliderControl, "control" ); + // delegating signal of slider control to slider + q->connect( sliderControl, SIGNAL( valueChanged( int ) ), q, SIGNAL( valueChanged( int ) ) ); + q->connect( sliderControl, SIGNAL( sliderPressed( ) ), q, SIGNAL( sliderPressed( ) ) ); + q->connect( sliderControl, SIGNAL( sliderReleased( ) ), q, SIGNAL( sliderReleased( ) ) ); + q->connect( sliderControl, SIGNAL( sliderMoved( int ) ), q, SIGNAL( sliderMoved( int ) ) ); + q->connect( sliderControl, SIGNAL( rangeChanged( int, int ) ), q, SIGNAL( rangeChanged( int, int ) ) ); + setElements( QList( ) << HbSlider::TrackElement ); + HbStyle::setItemName( q,"this" ); + q->setFlags( QGraphicsItem::ItemIsFocusable ); + q->setProperty("TickLabelPresent",false); + +} + +void HbSliderPrivate::setElements( QList elementList) +{ + Q_Q( HbSlider); + bool oldElementRemoved = false; + foreach(HbSlider::SliderElement element,elements){ + if(!elementList.contains(element)&& elementItemMap.contains(element)) { + delete elementItemMap[element].item; + delete elementItemMap[element].touchItem; + elementItemMap.remove(element); + oldElementRemoved = true; + } + } + if(oldElementRemoved) { + q->repolish( ); + } + elements = elementList; + // this will delete unwanted element and create new element + updateElements( ); + // repolish call is required because new elements might be added +} + +/*! + This api creates widget for given element + */ +void HbSliderPrivate::elementWidget( HbSlider::SliderElement element ) +{ + Q_Q( HbSlider ); + switch ( element ) { + case HbSlider::IncreaseElement: + // create element only if icon is set on that + if ( icons.contains( element) && !elementItemMap.contains(element)){ + ItemPrimitive itemPrimStrct; + itemPrimStrct.type = HbStyle::P_SliderElement_increase; + itemPrimStrct.item = q->style( )->createPrimitive(HbStyle::P_SliderElement_increase,q ); + HbStyle::setItemName( itemPrimStrct.item, "increment-icon" ); + itemPrimStrct.touchItem = q->style( )->createPrimitive( HbStyle::P_SliderElement_touchincrease,q ); + HbStyle::setItemName( itemPrimStrct.touchItem, "increment-icon-toucharea" ); + HbStyleOptionSlider option; + q->initStyleOption( &option ); + q->style( )->updatePrimitive (itemPrimStrct.touchItem,HbStyle::P_SliderElement_touchincrease,&option); + elementItemMap[HbSlider::IncreaseElement]=itemPrimStrct; + q->repolish( ); + + } + break; + case HbSlider::DecreaseElement: + // element will not be created if icon is not set on that element + if ( icons.contains( element) && !elementItemMap.contains(element)) { + ItemPrimitive itemPrimStrct; + itemPrimStrct.item= q->style( )->createPrimitive(HbStyle::P_SliderElement_decrease,q ); + itemPrimStrct.type = HbStyle::P_SliderElement_decrease; + HbStyle::setItemName( itemPrimStrct.item,"decrement-icon" ); + itemPrimStrct.touchItem = q->style( )->createPrimitive( HbStyle::P_SliderElement_touchdecrease,q ); + HbStyle::setItemName( itemPrimStrct.touchItem, "decrement-icon-toucharea" ); + elementItemMap[HbSlider::DecreaseElement]=itemPrimStrct; + HbStyleOptionSlider option; + q->initStyleOption( &option ); + q->style( )->updatePrimitive (itemPrimStrct.touchItem,HbStyle::P_SliderElement_touchdecrease,&option); + q->repolish( ); + + } + break; + case HbSlider::IconElement: + if ( icons.contains( element) && !elementItemMap.contains(element) ) { + ItemPrimitive itemPrimStrct; + itemPrimStrct.item = q->style( )->createPrimitive(HbStyle::P_SliderElement_icon,q ); + itemPrimStrct.type = HbStyle::P_SliderElement_icon; + HbStyle::setItemName( itemPrimStrct.item, "icon-icon" ); + HbAbstractButton *sliderIcon = new HbAbstractButton( q ); + HbStyle::setItemName( sliderIcon, "icon" ); + itemPrimStrct.touchItem = sliderIcon; + elementItemMap [HbSlider::IconElement]=itemPrimStrct; + // delegating signal from button to slider + q->connect( sliderIcon, SIGNAL( pressed( ) ), q, SIGNAL( iconPressed( ) ) ); + q->connect( sliderIcon, SIGNAL( released( ) ), q, SIGNAL( iconReleased( ) ) ); + q->connect( sliderIcon, SIGNAL( clicked( ) ), q, SIGNAL( iconClicked( ) ) ); + q->connect( sliderIcon, SIGNAL( toggled( bool ) ), q, SIGNAL( iconToggled( bool ) ) ); +#ifdef HB_EFFECTS + q->connect( sliderIcon, SIGNAL( pressed( ) ), q, SLOT( _q_startIconPressedEffect( ) ) ); + q->connect( sliderIcon, SIGNAL( released( ) ), q,SLOT( _q_startIconReleasedEffect( ) ) ); +#endif + q->repolish( ); + + } + break; + case HbSlider::TextElement: + if( !sliderTextString.isEmpty( ) && !elementItemMap.contains(element)){ + ItemPrimitive itemPrimStrct; + itemPrimStrct.type = HbStyle::P_SliderElement_text; + itemPrimStrct.item = q->style( )->createPrimitive( HbStyle::P_SliderElement_text,q ); + HbStyle::setItemName( itemPrimStrct.item,"text_item_element" ); + HbAbstractButton *sliderTextButton = new HbAbstractButton( q ); + HbStyle::setItemName( sliderTextButton, "text_element" ); + itemPrimStrct.touchItem = sliderTextButton; + q->connect( sliderTextButton, SIGNAL( clicked( ) ), q, SIGNAL( textClicked( ) ) ); +#ifdef HB_EFFECTS + q->connect( sliderTextButton, SIGNAL( clicked( ) ), q, SLOT( _q_startTextClickEffect( ) ) ); +#endif + q->repolish(); + q->setProperty("state", "normal"); + elementItemMap[HbSlider::TextElement]=itemPrimStrct; + } + break; + default: + break; + } + + HbStyleOptionSlider option; + q->initStyleOption( &option ); + option.sliderElementIcon =icons.value(element ); + option.text = sliderTextString; + if (elementItemMap.contains(element)) { + q->style( )->updatePrimitive( elementItemMap[element].item,elementItemMap[element].type,&option ); + + } //return created; +} + + +/*! + update element will first delete element which are not required + and then create new element + */ +void HbSliderPrivate::updateElements( ) +{ + foreach ( const HbSlider::SliderElement &element, elements ) { + // create new element, this api will not create element widget + // if it is already existing + elementWidget( element ); + } +} + +/*! + This Api will start incrementing slider value by step size + till the time stopReapetAction( ) is not being called or slider + value becomes maximum( ) + */ +void HbSliderPrivate::startIncrementing( ) +{ +#ifdef HB_EFFECTS + HbEffectInternal::add( HB_SLIDER_TYPE,"slidericon_press", "increasepressed" ); + HbEffect::start( elementItemMap[HbSlider::IncreaseElement].item, HB_SLIDER_TYPE, "increasepressed" ); +#endif + // increase slider value by step size + sliderControl->triggerAction( HbAbstractSliderControl::SliderSingleStepAdd ); + // start timer to increase slider value by step + sliderControl->setRepeatAction( HbAbstractSliderControl::SliderSingleStepAdd,sliderControl->maximum( ) ); +} + +/*! + This Api will start decrementing slider value by step size + till the time stopReapetAction( ) is not being called or slider + value becomes minimum( ) + */ +void HbSliderPrivate::startDecrementing( ) +{ +#ifdef HB_EFFECTS + HbEffectInternal::add( HB_SLIDER_TYPE,"slidericon_press", "decreasepressed" ); + HbEffect::start( elementItemMap[HbSlider::DecreaseElement].item, HB_SLIDER_TYPE, "decreasepressed" ); +#endif + sliderControl->triggerAction( HbAbstractSliderControl::SliderSingleStepSub ); + sliderControl->setRepeatAction( HbAbstractSliderControl::SliderSingleStepSub,sliderControl->minimum( ) ); +} + +/*! + stops the reapeating action + reapeat action can be increase slider value by step or decrease slider value by step + */ +void HbSliderPrivate::stopRepeatAction( ) +{ + sliderControl->setRepeatAction( HbAbstractSliderControl::SliderNoAction ); +} + + +void HbSliderPrivate::setTickLabelPresentProperty( ) +{ + Q_Q ( HbSlider ); + if (q->majorTickInterval( ) > 0 && q->tickPosition( ) !=Hb::NoSliderTicks && + (q->majorTickLabels().length() > 0 || + (q->minorTickInterval() > 0 && q->minorTickLabels( ).length() > 0))) { + if(!q->property("TickLabelPresent").toBool()){ + q->setProperty("TickLabelPresent",true); + q->repolish( ); + } + } else { + if( q->property("TickLabelPresent").toBool()){ + q->setProperty("TickLabelPresent",false); + q->repolish( ); + } + } + +} + +#ifdef HB_EFFECTS + +/*! + start effect for on icon press + */ +void HbSliderPrivate::_q_startIconPressedEffect( ) +{ + HbEffectInternal::add( HB_SLIDER_TYPE,"slidericon_press", "iconpressed" ); + HbEffect::start( elementItemMap[HbSlider::IconElement].item, HB_SLIDER_TYPE, "iconpressed" ); +} + +/*! + start effect on icon release + */ +void HbSliderPrivate::_q_startIconReleasedEffect( ) +{ + HbEffectInternal::add( HB_SLIDER_TYPE,"slidericon_release", "iconrelease" ); + HbEffect::start( elementItemMap[HbSlider::IconElement].item, HB_SLIDER_TYPE, "iconrelease" ); +} + +/*! + start text click effect + */ +void HbSliderPrivate::_q_startTextClickEffect( ) +{ + HbEffectInternal::add( HB_SLIDER_TYPE,"slidertext_click", "textclick" ); + HbEffect::start( elementItemMap[HbSlider::TextElement].item, HB_SLIDER_TYPE, "textclick" ); +} +#endif + +/*! + @beta + Constructs a slider with \a parent. + + The orientation is \b Qt::Vertical and the slider contains only track( groove and handle ) element by default. + + default range for HbSlider is 0 to 100 and singleStepSize is 1 + + \sa setOrientation( ), setElements( ) +*/ +HbSlider::HbSlider( QGraphicsItem *parent ) : + HbWidget( *new HbSliderPrivate, parent ) +{ + Q_D( HbSlider ); + d->q_ptr = this; + d->init( ); +} + +/*! + @beta + Constructs a slider with a \a orientation and \a parent. + + The slider contains only track( groove and handle ) element by default. + + default range for HbSlider is 0 to 100 and singleStepSize is 1 + + \sa setElements( ) +*/ +HbSlider::HbSlider( Qt::Orientation orientation, QGraphicsItem *parent ) : + HbWidget( *new HbSliderPrivate, parent ) +{ + Q_D( HbSlider ); + d->q_ptr = this; + d->init( ); + setOrientation( orientation ); +} + +/*! + @beta + \internal + */ +HbSlider::HbSlider( HbSliderPrivate &dd, QGraphicsItem *parent ) : + HbWidget( dd, parent ) +{ + Q_D( HbSlider ); + d->init( ); + +} + +/*! + Destructs the slider. +*/ +HbSlider::~HbSlider( ) +{ +} + +/*! + \deprecated + Returns the elements of the slider. + + The slider contains only track element by default. + + \sa setElements( ) +*/ +QList HbSlider::elements( ) const +{ + qDebug("HbSlider::elements() is deprecated. Use sliderElements() instead."); + Q_D( const HbSlider ); + return d->elements; +} + +/*! + \deprecated + Sets the elements of the slider. + + \note Duplicate elements will be ignored. + + \note element order cant be changed + + \sa elements( ) +*/ +void HbSlider::setElements( const QList &elements ) +{ + qDebug("HbSlider::setElements is deprecated. Use setSliderElements instead."); + Q_D( HbSlider ); + bool oldElementRemoved = false; + foreach(HbSlider::SliderElement element,d->elements){ + if(!elements.contains(element)&&d->elementItemMap.contains(element)) { + delete d->elementItemMap[element].item; + delete d->elementItemMap[element].touchItem; + d->elementItemMap.remove(element); + oldElementRemoved = true; + } + } + if(oldElementRemoved) { + repolish( ); + } + d->elements = elements; + // this will delete unwanted element and create new element + d->updateElements( ); + // repolish call is required because new elements might be added +} + + +/*! + @proto + Returns the list of slider elements as QVariant + + \note it is safe to type-cast element to HbSlider::SliderElement. + + The slider contains only track element by default. + + \sa setSliderElements() +*/ +QList HbSlider::sliderElements() const +{ + Q_D( const HbSlider ); + QList elementList; + foreach(HbSlider::SliderElement element,d->elements){ + elementList.append ( QVariant ( element ) ); + } + return elementList; +} + +/*! + @proto + Sets the elements of the slider. + + \note Duplicate elements will be ignored. + + \note element order cant be changed + + Eg Usages: + HbSlider slider; + QList list; + list.append( QVariant( HbSlider::IncreaseElement)); + list.append( QVariant( HbSlider::DecreaseElement)); + list.append( QVariant( HbSlider::IconElement)); + slider.setElements( list); + + The available slider elements are + defined by the HbSlider::SliderElement enumeration + + \sa sliderElements() + +*/ +void HbSlider::setSliderElements(const QList &elementlist) +{ + Q_D( HbSlider ); + QList elements; + foreach ( QVariant elementVar , elementlist ) { + elements.append( static_cast(elementVar.toInt())); + } + d->setElements( elements ); +} + +/*! + @proto + Sets the icons for elements + + key of \a elements is element name and value is icon + name to set on given element + Use following string for specifying elements + "IncreaseElement" for increase element + "DecreaseElement" for decrease element + "IconElement" for icon element + + Eg Usage: + HbSlider slider; + QMap map; + map.insert(QString("IncreaseElement") , QVariant(":/unittest_hbslider/star_on.png")); + map.insert(QString("DecreaseElement") , QVariant(":/unittest_hbslider/star_on.png")); + slider.setElementIcons( map ); + + \warning Setting icon to a non-existing element has no effect. + + \sa elementIcons() setSliderElements() setElementIcon() +*/ +void HbSlider::setElementIcons(const QMap &elements) +{ + Q_D( HbSlider ); + QMapIterator i(elements); + while (i.hasNext()) { + i.next(); + HbIcon icon = HbIcon( i.value().toString()); + if ( !icon.isNull() ) { + if( !i.key().compare("IncreaseElement")) { + d->icons[HbSlider::IncreaseElement] = icon; + if ( d->elements.contains( HbSlider::IncreaseElement ) ) { + // create icon element if it was not existing + d->elementWidget( HbSlider::IncreaseElement ); + } + } + else if( !i.key().compare( "DecreaseElement")) { + d->icons[HbSlider::DecreaseElement] = icon; + if ( d->elements.contains( HbSlider::DecreaseElement ) ) { + // create icon element if it was not existing + d->elementWidget( HbSlider::DecreaseElement ); + } + } + else if( !i.key().compare( "IconElement")) { + d->icons[HbSlider::IconElement] = icon; + if ( d->elements.contains( HbSlider::IconElement ) ) { + // create icon element if it was not existing + d->elementWidget( HbSlider::IconElement ); + } + } + } + } +} + +/*! + @proto + Returns the map , which consist of element name as key and icon name as value + + returns NULL map if none of the element has icon + + \sa setElementIcons() +*/ +QMap HbSlider::elementIcons( )const +{ + Q_D( const HbSlider ); + QMap map; + QHashIterator i(d->icons); + while( i.hasNext()) { + i.next(); + QString name; + switch( i.key() ){ + case IncreaseElement: + name = QString("IncreaseElement"); + break; + case DecreaseElement: + name = QString("DecreaseElement"); + break; + case IconElement: + name = QString("IconElement"); + break; + default: + name = QString(""); + + } + map.insert( name, QVariant(i.value().iconName())); + } + return map; +} + + +/*! + @beta + Returns the slider text. + + returns empty text if text element does not exist + + \sa setText( ) +*/ +QString HbSlider::text( ) const +{ + Q_D( const HbSlider ); + return d->sliderTextString; +} + + +/*! + @beta + Sets the slider \a text for text element as well as tooltip. + + tooltip will be visible only if setTooltip( true ) is called. + + Slider will not take care of localization. + + \warning Setting text to a non-existing text element has no effect. + + \sa text( ), setToolTipVisible( ), setToolTipAlignment( ) +*/ +void HbSlider::setText( const QString &text ) +{ + Q_D( HbSlider ); + if( d->sliderTextString!= text) { + d->sliderTextString = text; + if ( d->elements.contains( HbSlider::TextElement )) { + d->elementWidget( HbSlider::TextElement ); + } + // sets text for tooltip also + d->sliderControl->setToolTip( text ); + repolish(); + } +} + +/*! + \deprecated + Returns the icon of the \a element. + + returns NULL if element does not exist or icon was not set for this element + + \sa setIcon( ) +*/ +HbIcon HbSlider::icon( SliderElement element ) const +{ + qDebug("HbSlider::icon() is deprecated. Use elementIcons() instead."); + Q_D( const HbSlider ); + return d->icons.value( element ); +} + +/*! + \deprecated + Sets the \a icon if the \a element. + + Supported elements: + \li HbSlider::IncreaseElement + \li HbSlider::DecreaseElement + \li HbSlider::IconElement + + \warning Setting icon to a non-existing element has no effect. + + \sa icon( ) setElements( ) +*/ +void HbSlider::setIcon( SliderElement element, const HbIcon &icon ) +{ + qDebug("HbSlider::setIcon() is deprecated. Use setElementIcons() instead."); + Q_D( HbSlider ); + if ( element != TextElement &&!icon.isNull()) { + d->icons[element] = icon; + if ( d->elements.contains( element ) ) { + // create icon element if it was not existing + d->elementWidget( element ); + // update icon primitive + + } + + } else { + qWarning( "HbSlider::setIcon: non-supported element or null icon passed" ); + } +} + +/*! + @beta + Returns the icon of the \a element. + + returns NULL if element does not exist or icon was not set for this element + + \sa setElementIcon( ) +*/ +HbIcon HbSlider::elementIcon( SliderElement element ) const +{ + Q_D( const HbSlider ); + return d->icons.value( element ); +} + +/*! + @beta + Sets the \a icon if the \a element. + + Supported elements: + \li HbSlider::IncreaseElement + \li HbSlider::DecreaseElement + \li HbSlider::IconElement + + \warning Setting icon to a non-existing element has no effect. + + \sa elementIcon( ) setElements( ) +*/ +void HbSlider::setElementIcon( SliderElement element, const HbIcon &icon ) +{ + Q_D( HbSlider ); + if ( element != TextElement &&!icon.isNull()) { + d->icons[element] = icon; + if ( d->elements.contains( element ) ) { + // create icon element if it was not existing + d->elementWidget( element ); + // update icon primitive + + } + + } else { + qWarning( "HbSlider::setIcon: non-supported element or null icon passed" ); + } +} + +/*! + @beta + Returns \c true whether the icon element is checkable. + + The default value is \c false. + + \sa setIconCheckable( ) +*/ +bool HbSlider::isIconCheckable( ) const +{ + Q_D( const HbSlider ); + + if ( d->elementItemMap.contains (HbSlider::IconElement ) ){ + HbAbstractButton *sliderIcon = + static_cast(d->elementItemMap[HbSlider::IconElement].touchItem); + return sliderIcon->isCheckable( ); + } + return false; +} + + +/*! + @beta + Sets whether the tooltip is visible . + + tooltip is different then current value + + tooltip text can be set by \li setText( ) api + + if \a value is true then tooltip will be display on thumb drag + + \sa isToolTipVisible( ) , setText( ) +*/ +void HbSlider::setToolTipVisible( bool value ) +{ + Q_D( const HbSlider ); + d->sliderControl->setToolTipVisible( value ); +} + + +/*! + @beta + Returns \c true if tooltip is visible. + + The default value is \c false. + + \sa setToolTipVisible( ) +*/ +bool HbSlider::isToolTipVisible( )const +{ + Q_D( const HbSlider ); + return d->sliderControl->isToolTipVisible( ); +} + + + +/*! + @beta + sets the toolTip Alignment with respect to the thumb. + + \sa toolTipAlignment( ) +*/ +void HbSlider::setToolTipAlignment( Qt::Alignment alignment ) +{ + Q_D( HbSlider ); + d->sliderControl->setToolTipAlignment( alignment ); +} + + +/*! + @beta + returns the tooltip Alignment with respect to the thumb + + \sa setToolTipAlignment( ) +*/ +Qt::Alignment HbSlider::toolTipAlignment( ) const +{ + Q_D( const HbSlider ); + return d->sliderControl->toolTipAlignment( ); +} + +/*! + @beta + Sets whether the icon element is checkable. + + checkable icon emits toggled( bool ) signal + + By default, the icon is not checkable. + + \sa isIconCheckable( ) +*/ +void HbSlider::setIconCheckable( bool checkable ) +{ + Q_D( HbSlider ); + if ( d->elementItemMap.contains (HbSlider::IconElement )) { + HbAbstractButton *sliderIcon = + static_cast(d->elementItemMap[HbSlider::IconElement].touchItem); + sliderIcon->setCheckable ( checkable ); + } +} + +/*! + @beta + Returns \c true whether the icon element is checked. + + The default value is \c false. + + \sa setIconChecked( ) +*/ +bool HbSlider::isIconChecked( ) const +{ + Q_D( const HbSlider ); + if ( d->elementItemMap.contains (HbSlider::IconElement ) ){ + HbAbstractButton *sliderIcon = + static_cast(d->elementItemMap[HbSlider::IconElement].touchItem); + return sliderIcon->isChecked( ); + } + return false; +} + +/*! + @beta + Sets whether the icon element is checked or not. + + \sa isIconChecked( ) +*/ +void HbSlider::setIconChecked( bool checked ) +{ + Q_D( HbSlider ); + if ( d->elementItemMap.contains (HbSlider::IconElement )) { + HbAbstractButton *sliderIcon = + static_cast(d->elementItemMap[HbSlider::IconElement].touchItem); + sliderIcon->setChecked ( checked ); + } +} + +/*! + @beta + Returns \c true whether the icon element is enabled. + + The default value is \c true. + + \sa setIconEnabled( ) +*/ +bool HbSlider::isIconEnabled( ) const +{ + Q_D( const HbSlider ); + if ( d->elementItemMap.contains (HbSlider::IconElement ) ) { + HbAbstractButton *sliderIcon = + static_cast(d->elementItemMap[HbSlider::IconElement].touchItem); + return sliderIcon->isEnabled( ); + } + return false; +} + +/*! + @beta + Sets whether the icon element is enabled or not. + + \sa isIconEnabled( ) +*/ +void HbSlider::setIconEnabled( bool enabled ) +{ + Q_D( HbSlider ); + if ( d->elementItemMap.contains (HbSlider::IconElement )) { + HbAbstractButton *sliderIcon = + static_cast(d->elementItemMap[HbSlider::IconElement].touchItem); + sliderIcon->setEnabled ( enabled ); + d->elementItemMap[HbSlider::IconElement].item->setEnabled( enabled ); + + } +} + +/*! + @beta + Sets the \a orientation of the slider. + + \sa orientation( ) +*/ +void HbSlider::setOrientation( Qt::Orientation orientation ) +{ + Q_D( HbSlider ); + if ( d->orientation != orientation ) { + d->orientation = orientation; + d->sliderControl->setOrientation( orientation ); + repolish(); + } +} + +/*! + @beta + Returns the orientation of the slider. + + The default value is \c Qt::Vertical. + + \sa setOrientation( ) + */ +Qt::Orientation HbSlider::orientation( ) const +{ + Q_D( const HbSlider ); + return d->orientation; +} + +/*! + @beta + Returns \c true whether the slider track is inverted. + + The default value is \c false. + + If this property is \c false, the minimum and maximum will + be shown in its classic position. If the value is \c true, + the minimum and maximum appear at their opposite location. + + \sa setInvertedAppearance( ) +*/ +bool HbSlider::invertedAppearance( ) const +{ + Q_D( const HbSlider ); + return d->sliderControl->invertedAppearance( ); +} + +/*! + @beta + Sets whether the slider track is \a inverted. + + This holds whether or not a slider shows its values inverted. + + If \a inverted. false ( the default ), the minimum and maximum will be shown in its classic position + + for the inherited widget. If the value is true, the minimum and maximum appear at + + their opposite location. + + Note: This property makes most sense for sliders. + + \sa invertedAppearance( ) + +*/ +void HbSlider::setInvertedAppearance( bool inverted ) +{ + Q_D( HbSlider ); + d->sliderControl->setInvertedAppearance( inverted ); + int dec = d->elements.indexOf( HbSlider::DecreaseElement ); + int inc = d->elements.indexOf( HbSlider::IncreaseElement ); + if ( dec != -1 && inc != -1 ) { + d->elements.swap( dec, inc ); + d->updateElements( ); + } +} + +/*! + @beta + Returns the maximum value of the slider. + + The default value is \c 100. + + \sa setMaximum( ), setRange( ) +*/ +int HbSlider::maximum( ) const +{ + Q_D( const HbSlider ); + return d->sliderControl->maximum( ); +} + +/*! + @beta + Sets the maximum value of the slider. + + \note When setting this property, the minimum is adjusted if + + necessary to ensure that the range remains valid. Also the + + slider's current value is adjusted to be within the new range. + + \sa maximum( ) +*/ +void HbSlider::setMaximum( int max ) +{ + Q_D( HbSlider ); + d->sliderControl->setMaximum( max ); +} + +/*! + @beta + Returns the minimum value of the slider. + + The default value is \c 0. + + \sa setMinimum( ) +*/ +int HbSlider::minimum( ) const +{ + Q_D( const HbSlider ); + return d->sliderControl->minimum( ); +} + +/*! + @beta + Sets the minimum value of the slider. + + \note When setting this property, the maximum is adjusted if + necessary to ensure that the range remains valid. Also the + slider's current value is adjusted to be within the new range. + + \sa minimum( ) +*/ +void HbSlider::setMinimum( int min ) +{ + Q_D( HbSlider ); + d->sliderControl->setMinimum( min ); +} + +/*! + @beta + This function is provided for convenience. + + Sets the slider's minimum to \a min and its maximum to \a max. + + If maximum is smaller than minimum, minimum becomes the only legal value. + + \sa setMinimum( ), setMaximum( ) +*/ +void HbSlider::setRange( int min, int max ) +{ + Q_D( HbSlider ); + d->sliderControl->setRange( min, max ); +} + +/*! + @beta + Returns the page step of the slider. + + The default value is \c 10. + + The larger of two natural steps that a slider provides + and typically corresponds to the user pressing PageUp or PageDown. + + \sa setPageStep( ) +*/ +int HbSlider::pageStep( ) const +{ + Q_D( const HbSlider ); + return d->sliderControl->pageStep( ); +} + +/*! + @beta + Sets the page \a step of the slider. + + \sa pageStep( ) +*/ +void HbSlider::setPageStep( int step ) +{ + Q_D( HbSlider ); + d->sliderControl->setPageStep( step ); +} + +/*! + @beta + Returns the single step of the slider. + + The default value is \c 1. + + The smaller of two natural steps that an + abstract sliders provides and typically corresponds to the user + pressing an arrow key. + + \sa setSingleStep( ) +*/ +int HbSlider::singleStep( ) const +{ + Q_D( const HbSlider ); + return d->sliderControl->singleStep( ); +} + +/*! + @beta + Sets the single \a step of the slider. + + \sa singleStep( ) +*/ +void HbSlider::setSingleStep( int step ) +{ + Q_D( HbSlider ); + d->sliderControl->setSingleStep( step ); +} + +/*! + @beta + Returns the current slider position. + + If tracking is enabled ( the default ), this is identical to the value. + + \sa setSliderPosition( ) +*/ +int HbSlider::sliderPosition( ) const +{ + Q_D( const HbSlider ); + return d->sliderControl->sliderPosition( ); +} + +/*! + @beta + Sets the current slider position. + + \sa sliderPosition( ) +*/ +void HbSlider::setSliderPosition( int pos ) +{ + Q_D( HbSlider ); + d->sliderControl->setSliderPosition( pos ); +} + +/*! + @beta + Returns \c true whether slider tracking is enabled. + + The default value is \c true. + + If tracking is enabled, the slider emits the + valueChanged( ) signal while the slider is being dragged. If + tracking is disabled, the slider emits the valueChanged( ) signal + only when the user releases the slider. + + \sa setTracking( ) +*/ +bool HbSlider::hasTracking( ) const +{ + Q_D( const HbSlider ); + return d->sliderControl->hasTracking( ); +} + +/*! + @beta + Sets whether the slider tracking is enabled. + + \sa hasTracking( ) +*/ +void HbSlider::setTracking( bool enable ) +{ + Q_D( HbSlider ); + d->sliderControl->setTracking( enable ); +} + +/*! + @beta + Returns the current value of the slider. + + The default value is \c 0. +*/ +int HbSlider::value( ) const +{ + Q_D( const HbSlider ); + return d->sliderControl->value( ); +} + +/*! + @beta + Sets the current value of the slider. + + The slider forces the value to be within the legal range: \b + minimum <= \c value <= \b maximum. + + Changing the value also changes the \b sliderPosition. + + \sa value( ) +*/ +void HbSlider::setValue( int value ) +{ + Q_D( HbSlider ); + d->sliderControl->setValue( value ); +} + +/*! + @beta + Returns the tickmark position of the slider. + + The default value is \c Hb::NoTicks. + + \sa setTickPosition( ) +*/ +Hb::SliderTickPositions HbSlider::tickPosition( ) const +{ + Q_D( const HbSlider ); + return d->sliderControl->tickPosition( ); +} + +/*! + @beta + Sets the tickmark position of the slider. + + The valid values are described by the Hb::SliderTickPositions enum. + + The default value is Hb::NoTicks. + + Note:: if major tick and minor tick interval is zero + then no ticks will be drawn + + Example usage: + \code + HbSlider *slider = new HbSlider( ); + slider->setMinorTickInterval( 10 ); + slider->setTickPosition( Hb::SliderTicksRight ) ; + \endcode + + \sa tickPosition( ), setMajorTickInterval( ) , setMinorTickInterval( ) + */ +void HbSlider::setTickPosition( Hb::SliderTickPositions position ) +{ + Q_D( HbSlider ); + d->sliderControl->setTickPosition( position ); + d->setTickLabelPresentProperty( ); +} + +/*! + @beta + Returns the SnappingMode of the slider. + + The default value is \c HbSlider::MinorTickSnapping. + + \sa setSnappingMode( ) , HbSlider::SnappingMode. +*/ +HbSlider::SnappingMode HbSlider::snappingMode( ) const +{ + Q_D( const HbSlider ); + return ( HbSlider::SnappingMode )( d->sliderControl->snappingMode( ) ); +} + +/*! + @beta + Sets the snappingMode of the slider. + + \sa snappingMode( ) +*/ +void HbSlider::setSnappingMode( SnappingMode mode ) +{ + Q_D( HbSlider ); + d->sliderControl->setSnappingMode( ( HbSliderControl::SnappingMode )mode ); +} + +/*! + @beta + Returns the interval between major tickmarks. + + The default value is \c 0. + + \sa setMajorTickInterval( ) +*/ +int HbSlider::majorTickInterval( ) const +{ + Q_D( const HbSlider ); + return d->sliderControl->majorTickInterval( ); +} + +/*! + @beta + Sets the interval between major tickmarks. + + absolute value will be taken for tick interval + + \default value is 0 + + \sa majorTickInterval( ) +*/ +void HbSlider::setMajorTickInterval( int interval ) +{ + Q_D( HbSlider ); + d->sliderControl->setMajorTickInterval( interval ); + d->setTickLabelPresentProperty( ); +} + +/*! + @beta + Returns the interval between minor tickmarks. + + The default value is \c 0. + + \sa setMinorTickInterval( ) +*/ +int HbSlider::minorTickInterval( ) const +{ + Q_D( const HbSlider ); + return d->sliderControl->minorTickInterval( ); +} + +/*! + @beta + Sets the interval between minor tickmarks. + + absolute value will be taken for tick interval + + \default value is 0 + + \sa minorTickInterval( ) +*/ +void HbSlider::setMinorTickInterval( int interval ) +{ + Q_D( HbSlider ); + d->sliderControl->setMinorTickInterval( interval ); + d->setTickLabelPresentProperty( ); +} + +/*! + @beta + sets the icon path for handle + + \sa handleIcon( ) + +*/ +void HbSlider::setHandleIcon( const QString& handlePath ) +{ + Q_D( HbSlider ); + d->sliderControl->setHandleIcon( handlePath ); +} + +/*! + @beta + returns icon of handle + + \sa handleIcosetHandleIconn( ) + +*/ +QString HbSlider::handleIcon( ) const +{ + Q_D( const HbSlider ); + return d->sliderControl->handleIcon( ); +} + + +/*! + @proto + Sets whether to display progress track or not + + \default value is true + + \sa isTrackFilled( ) +*/ +void HbSlider::setTrackFilled(bool trackVisible ) +{ + + Q_D( const HbSlider ); + return d->sliderControl->setTrackFilled( trackVisible ); + +} + +/*! + @proto + returns whether progress track is visible or not + + \sa setTrackFilled( ) + +*/ +bool HbSlider::isTrackFilled() const +{ + Q_D( const HbSlider ); + return d->sliderControl->isTrackFilled(); + +} + +/*! + @beta + Returns the major ticklabels of the slider. + + \sa setMajorTickLabels( ) +*/ +QStringList HbSlider::majorTickLabels( ) const +{ + Q_D( const HbSlider ); + return d->sliderControl->majorTickLabels( ); +} + +/*! + @beta + Sets the major ticklabels of the slider. + + Detailed description: + + Strings from the stringlist will be taken sequentially for drawing + LabelItem,there exists a one-to-one mapping between tickmarkitem & + tickmarklabelitem. + + case 1: if strings provided > tickmarks, labels are drawn for the + strings which maps the tickmarkitems.If there are extra strings + available in the list beyond 1-1 mapping, those strings will be left out. + + case 2: if strings provided < tickmarks, labels are drawn only for strings + provided.Rest of the tickmarkitems will be drawn without labelItem. + + case 3: If some tickmarkitems to be drawn without labelItem in the middle, + specify empty string ( "" ) for that item in the string list. + + case 4: if both major & minor tickinterval are same,then only majortickLabel + strings are taken into account for drawing the labelItem + + \sa majorTickLabels( ) +*/ +void HbSlider::setMajorTickLabels( const QStringList &majorTickLabels ) +{ + Q_D( HbSlider ); + d->sliderControl->setMajorTickLabels( majorTickLabels ); + d->setTickLabelPresentProperty( ); +} + +/*! + @beta + Returns the minor ticklabels of the slider. + + \sa setMinorTickLabels( ) +*/ +QStringList HbSlider::minorTickLabels( ) const +{ + Q_D( const HbSlider ); + return d->sliderControl->minorTickLabels( ); +} + +/*! + @beta + Sets the minor ticklabels of the slider. + see setMajorTickLabels for detailed description + + \sa minorTickLabels( ),setMajorTickLabels( ) +*/ +void HbSlider::setMinorTickLabels( const QStringList &minorTickLabels ) +{ + Q_D( HbSlider ); + d->sliderControl->setMinorTickLabels( minorTickLabels ); + d->setTickLabelPresentProperty( ); +} + + +/*! + \reimp + */ +QGraphicsItem *HbSlider::primitive( HbStyle::Primitive primitive ) const +{ + Q_D( const HbSlider ); + switch ( primitive ) { + case HbStyle::P_Slider_thumb: + return HbSliderControlPrivate::d_ptr( d->sliderControl )->handle->primitive( + HbStyle::P_Slider_thumb ); + case HbStyle::P_SliderElement_text: + if (d->elementItemMap.contains (HbSlider::TextElement) ){ + return d->elementItemMap[HbSlider::TextElement].item; + } + break; + case HbStyle::P_SliderElement_icon: + if (d->elementItemMap.contains (HbSlider::IconElement)) { + return d->elementItemMap[HbSlider::IconElement].item; + } + break; + case HbStyle::P_SliderElement_increase: + if (d->elementItemMap.contains (HbSlider::IncreaseElement)) { + return d->elementItemMap[HbSlider::IncreaseElement].item; + } + break; + case HbStyle::P_SliderElement_decrease: + if (d->elementItemMap.contains (HbSlider::DecreaseElement)) { + return d->elementItemMap[HbSlider::DecreaseElement].item; + } + break; + case HbStyle::P_Slider_groove: + return HbSliderControlPrivate::d_ptr( d->sliderControl )->groove; + + case HbStyle::P_SliderElement_touchhandle: + return HbSliderControlPrivate::d_ptr( d->sliderControl )->handle->primitive( + HbStyle::P_SliderElement_touchhandle ); + + default: + break; + } + return 0; +} + +/*! + \reimp + */ +void HbSlider::updatePrimitives( ) +{ + HbWidget::updatePrimitives(); + Q_D( const HbSlider ); + HbStyleOptionSlider option; + initStyleOption( &option ); + + if ( d->elementItemMap.contains(HbSlider::TextElement)) { + option.text = d->sliderTextString; + style( )->updatePrimitive( d->elementItemMap[HbSlider::TextElement].item,d->elementItemMap[HbSlider::TextElement].type,&option ); + } + if ( d->elementItemMap.contains(HbSlider::IconElement)) { + option.sliderElementIcon =d->icons.value( HbSlider::IconElement ); + style( )->updatePrimitive( d->elementItemMap[HbSlider::IconElement].item,HbStyle::P_SliderElement_icon,&option ); + } + if ( d->elementItemMap.contains(HbSlider::IncreaseElement) ) { + option.sliderElementIcon =d->icons.value( HbSlider::IncreaseElement ); + style( )->updatePrimitive( d->elementItemMap[HbSlider::IncreaseElement].item,HbStyle::P_SliderElement_increase,&option ); + style( )->updatePrimitive( d->elementItemMap[HbSlider::IncreaseElement].touchItem ,HbStyle::P_SliderElement_touchincrease,&option ); + + } + if ( d->elementItemMap.contains (HbSlider::DecreaseElement) ) { + option.sliderElementIcon =d->icons.value( HbSlider::DecreaseElement ); + style( )->updatePrimitive( d->elementItemMap[HbSlider::DecreaseElement].item,HbStyle::P_SliderElement_decrease,&option ); + style( )->updatePrimitive( d->elementItemMap[HbSlider::DecreaseElement].touchItem ,HbStyle::P_SliderElement_touchdecrease,&option ); + } + if ( d->sliderControl ) { + d->sliderControl->updatePrimitives( ); + } +} + +/*! + \reimp + */ +void HbSlider::mousePressEvent( QGraphicsSceneMouseEvent *event ) +{ + Q_D( HbSlider ); + HbWidget::mousePressEvent( event ); + if( d->elementItemMap.contains (HbSlider::IncreaseElement) ) { + if ( d->elementItemMap[HbSlider::IncreaseElement].touchItem->isUnderMouse( ) ) { + // this is used for effect + d->pressOnIncrement = true; + HbWidgetFeedback::triggered( d->sliderControl, Hb::InstantPressed, Hb::ModifierSliderElement ); + event->accept( ); + // increment and start reapeat timer + d->startIncrementing( ); + return; + } + } + if( d->elementItemMap.contains(HbSlider::DecreaseElement) ) { + if ( d->elementItemMap[HbSlider::DecreaseElement].touchItem->isUnderMouse( ) ) { + d->pressOnIncrement = false; + HbWidgetFeedback::triggered( d->sliderControl, Hb::InstantPressed, Hb::ModifierSliderElement ); + event->accept( ); + //decrement and start decrement timer + d->startDecrementing( ); + return; + } + } +} + + +/*! + \reimp + + This Api start the releae effect. + */ +void HbSlider::mouseReleaseEvent( QGraphicsSceneMouseEvent *event ) +{ + Q_D( HbSlider ); + HbWidget::mouseReleaseEvent( event ); + if( d->elementItemMap.contains(HbSlider::IncreaseElement) ) { + if ( d->pressOnIncrement ) { + if( d->elementItemMap[HbSlider::IncreaseElement].touchItem->isUnderMouse( ) ) { + HbWidgetFeedback::triggered( d->sliderControl, Hb::InstantReleased, Hb::ModifierSliderElement ); + } +#ifdef HB_EFFECTS + HbEffectInternal::add( HB_SLIDER_TYPE,"slidericon_release", "increaserelease" ); + HbEffect::start( d->elementItemMap[HbSlider::IncreaseElement].item, HB_SLIDER_TYPE, "increaserelease" ); +#endif + } + } + if( d->elementItemMap.contains(HbSlider::DecreaseElement) ) { + if ( !d->pressOnIncrement ) { + if( d->elementItemMap[HbSlider::DecreaseElement].touchItem->isUnderMouse( ) ) { + HbWidgetFeedback::triggered( d->sliderControl, Hb::InstantReleased, Hb::ModifierSliderElement ); + } +#ifdef HB_EFFECTS + HbEffectInternal::add( HB_SLIDER_TYPE,"slidericon_release", "decreaserelease" ); + HbEffect::start( d->elementItemMap[HbSlider::DecreaseElement].item, HB_SLIDER_TYPE, "decreaserelease" ); +#endif + } + } + d->stopRepeatAction( ); +} + +/*! + \reimp + + This api update the primitive when ever item enable has changed + */ +QVariant HbSlider::itemChange( GraphicsItemChange change, const QVariant &value ) +{ + switch( change ) + { + case ItemEnabledHasChanged: + updatePrimitives( ); + break; + default: + break; + } + return HbWidget::itemChange( change, value ); +} + +/*! + \reimp + */ +void HbSlider::focusInEvent( QFocusEvent* event ) +{ + Q_D( HbSlider ); + HbWidget::focusInEvent( event ); + d->sliderControl->setFocus( ); +} + + +#include "moc_hbslider.cpp"