1 /****************************************************************************

     2 **

     3 ** Copyright (C) 2008-2010 Nokia Corporation and/or its subsidiary(-ies).

     4 ** All rights reserved.

     5 ** Contact: Nokia Corporation (developer.feedback@nokia.com)

     6 **

     7 ** This file is part of the HbWidgets module of the UI Extensions for Mobile.

     8 **

     9 ** GNU Lesser General Public License Usage

    10 ** This file may be used under the terms of the GNU Lesser General Public

    11 ** License version 2.1 as published by the Free Software Foundation and

    12 ** appearing in the file LICENSE.LGPL included in the packaging of this file.

    13 ** Please review the following information to ensure the GNU Lesser General

    14 ** Public License version 2.1 requirements will be met:

    15 ** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.

    16 **

    17 ** In addition, as a special exception, Nokia gives you certain additional

    18 ** rights.  These rights are described in the Nokia Qt LGPL Exception

    19 ** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.

    20 **

    21 ** If you have questions regarding the use of this file, please contact

    22 ** Nokia at developer.feedback@nokia.com.

    23 **

    24 ****************************************************************************/

    25 

    26 

    27 #include <hbprogressbar.h>

    28 #include <hbstyleoptionprogressbar.h>

    29 #include "hbprogressbar_p.h"

    30 

    31 #ifdef HB_EFFECTS

    32 #include <hbeffect.h>

    33 #include "hbeffectinternal_p.h"

    34 #define HB_PRGRESSBAR_ITEM_TYPE "HB_PROGRESSBAR"

    35 #endif

    36 

    37 

    38 /*!

    39     @beta

    40     @hbwidgets

    41     \class HbProgressBar

    42 

    43     \brief HbProgressBar widget provides a vertical and horizontal progress bar.

    44     An infinite progressbar is also available.

    45 

    46     A progress bar is used to give the user an indication of the progress of an operation and to 

    47     reassure them that the application is still running.

    48 

    49     The progress bar uses the concept of steps. User can set it up by specifying the minimum and 

    50     maximum possible step values, and it will display the percentage of steps that have been completed

    51     when you later give it the current step value. 

    52     

    53     The percentage is calculated by dividing the progress (progressValue() - minimum()) divided by maximum() - minimum().

    54 

    55     User can specify the minimum and maximum number of steps with setMinimum() and setMaximum() APIs. 

    56     The current number of steps is set with setProgressValue(). 

    57 

    58     If minimum and maximum both are set to 0, the bar shows a busy indicator instead of a percentage of steps.

    59     This is useful, for example, when using ftp or http to download items when they are unable to 

    60     determine the size of the item being downloaded.

    61 

    62     ProgressBar also supports adding text . min max text pair is also supported which is commonly 

    63     used for progress indication for music.

    64     

    65     \image html hbprogressbartext.png Left Aligned Text, Min Max Text.

    66 

    67     Progress bar provides below signal.

    68 

    69     \li valueChanged(int value) Emitted when the value of the progressbar is changed.

    70 */

    71 

    72 /*!

    73     @beta

    74     \fn void HbProgressBar::valueChanged(int value)

    75     

    76     Emitted when the value of the progressbar is changed.

    77 */

    78 

    79 

    80 /*!

    81     @beta

    82     \reimp

    83     \fn int HbProgressBar::type() const

    84  */

    85 

    86 /*!

    87     @beta

    88     \enum HbProgressBar::ProgressBarType

    89 

    90     This enum defines available progress bar types.

    91 */

    92 

    93 

    94 /*

    95     HbProgressBarPrivate

    96     private class constructor     

    97 */

    98 HbProgressBarPrivate::HbProgressBarPrivate() :

    99     mFrame(0),

   100     mTrack(0),

   101     mWaitTrack(0),

   102     mMinTextItem(0),

   103     mMaxTextItem(0),

   104     mMinMaxTextVisible(false),

   105     mMaximum(100),

   106     mMinimum(0),

   107     mProgressValue(0),

   108     mInvertedAppearance(false),

   109     mMinMaxTextAlignment(Qt::AlignBottom),

   110     mMinText(QString()),

   111     mMaxText(QString()),

   112     mOrientation(Qt::Horizontal),

   113     mDelayHideInProgress(true)

   114 {

   115 }

   116 

   117 /*

   118     HbProgressBarPrivate

   119     destructor     

   120 */

   121 HbProgressBarPrivate::~HbProgressBarPrivate() 

   122 {

   123 }

   124 

   125 /*

   126     \internal

   127     initialises progressbar

   128 */

   129 void HbProgressBarPrivate::init() 

   130 {

   131     Q_Q(HbProgressBar);

   132 

   133     HbStyle *style = qobject_cast<HbStyle*>(q->style());

   134     Q_ASSERT(style);

   135 

   136     mFrame = style->createPrimitive(HbStyle::P_ProgressBar_frame,q);

   137     mTrack = style->createPrimitive(HbStyle::P_ProgressBar_track,mFrame);

   138     mWaitTrack = style->createPrimitive(HbStyle::P_ProgressBar_waittrack,mFrame);    

   139     mWaitTrack->setVisible(false);

   140 

   141     if(q->layoutDirection() == Qt::RightToLeft) {

   142         q->setInvertedAppearance(true);

   143     }

   144 

   145 #ifdef HB_EFFECTS

   146     HbEffectInternal::add(HB_PRGRESSBAR_ITEM_TYPE,"progressbar_appear", "progressbar_appear");

   147     HbEffectInternal::add(HB_PRGRESSBAR_ITEM_TYPE,"progressbar_disappear", "progressbar_disappear");

   148     HbEffectInternal::add(HB_PRGRESSBAR_ITEM_TYPE,"progressbar_progress_complete", "progressbar_progress_complete");

   149 #endif

   150 }

   151 

   152 /*

   153     createTextPrimitives

   154 */

   155 void HbProgressBarPrivate::createTextPrimitives()

   156 {

   157     Q_Q(HbProgressBar);

   158 

   159     mMinTextItem = q->style()->createPrimitive(HbStyle::P_ProgressBar_mintext,q);

   160     mMaxTextItem = q->style()->createPrimitive(HbStyle::P_ProgressBar_maxtext,q);

   161 }

   162 

   163 /*!

   164     \internal

   165     Sets the progressbar range

   166 */

   167 void HbProgressBarPrivate::setRange(int minimum, int maximum)

   168 {

   169     Q_Q(HbProgressBar);

   170     if( minimum > maximum ){

   171         maximum = minimum ;

   172     }

   173     mMinimum = minimum;

   174     mMaximum = maximum;

   175 

   176     if ( mProgressValue < mMinimum){

   177         mProgressValue = mMinimum;

   178     }

   179 

   180     if(mProgressValue > mMaximum){

   181         mProgressValue = mMaximum;

   182     }

   183 

   184     if( (mMinimum == 0) && (mMaximum == 0) && (mType != HbProgressBar::RatingProgressBar) ) {

   185         mWaitTrack->setVisible(true);

   186         mTrack->setVisible(false);

   187     } else {

   188         mWaitTrack->setVisible(false);

   189         mTrack->setVisible(true);

   190     }

   191     q->updatePrimitives();

   192 }

   193 

   194 /*!

   195     \internal

   196     Sets the progressbar orientation.

   197     Can be either vertical or Horizontal.

   198 */

   199 void HbProgressBarPrivate::setOrientation(Qt::Orientation orientation)

   200 {

   201     Q_Q(HbProgressBar);

   202     if (mOrientation != orientation) {

   203         mOrientation = orientation;

   204         q->repolish();

   205         q->updatePrimitives();

   206     }

   207 }

   208 

   209 /*!

   210     \internal

   211     Private slot which delays the hiding effect.

   212 */

   213 #ifdef HB_EFFECTS

   214 void HbProgressBarPrivate::_q_delayedHide(HbEffect::EffectStatus status)

   215 {

   216     Q_Q(HbProgressBar);

   217 

   218     if (status.reason != Hb::EffectNotStarted) {

   219         q->setVisible(false);

   220     } 

   221 }

   222 #endif

   223 

   224 /*!

   225     Constructs a progressbar of a given \a type and \a parent. The default type is SimpleProgressBar.

   226 

   227     \deprecated HbProgressBar::HbProgressBar(HbProgressBar::ProgressBarType, QGraphicsItem*)

   228         is deprecated. Please use HbProgressBar::HbProgressBar(QGraphicsItem *parent) instead.

   229 */

   230 HbProgressBar::HbProgressBar(ProgressBarType type, QGraphicsItem *parent) : 

   231     HbWidget(*new HbProgressBarPrivate, parent)

   232 {    

   233     Q_D( HbProgressBar );

   234     d->q_ptr = this;

   235     d->init();

   236     d->mType = type;

   237 }

   238 

   239 /*!

   240     @beta

   241     Constructs a progressbar of a given \a parent.

   242 */

   243 HbProgressBar::HbProgressBar(QGraphicsItem *parent) : 

   244     HbWidget(*new HbProgressBarPrivate, parent)

   245 {    

   246     Q_D( HbProgressBar );

   247     d->q_ptr = this;

   248     d->init();

   249 }

   250 

   251 /*!

   252     \deprecated HbProgressBar::HbProgressBar(HbProgressBarPrivate&, HbProgressBar::ProgressBarType, QGraphicsItem*)

   253         is deprecated. Please use HbProgressBar::HbProgressBar(HbProgressBarPrivate &dd, QGraphicsItem *parent) instead.

   254 */

   255 HbProgressBar::HbProgressBar(HbProgressBarPrivate &dd, ProgressBarType type, QGraphicsItem *parent) : 

   256     HbWidget( dd, parent)

   257 {   

   258     Q_D( HbProgressBar );

   259     d->init();

   260     d->mType = type;

   261 }

   262 

   263 

   264 HbProgressBar::HbProgressBar(HbProgressBarPrivate &dd, QGraphicsItem *parent) : 

   265     HbWidget( dd, parent)

   266 {   

   267     Q_D( HbProgressBar );

   268     d->init();

   269 }

   270 

   271 

   272 /*!

   273     @beta

   274     Destructor for the progressbar.

   275 */

   276 HbProgressBar::~HbProgressBar() 

   277 {    

   278 }

   279 

   280 /*!

   281     @beta

   282    This property holds whether or not a progress bar shows its progress inverted. The function

   283    returns the value of this property.

   284 

   285    Not implemented yet.

   286 

   287    \sa setInvertedAppearance()

   288  */

   289 bool HbProgressBar::invertedAppearance() const 

   290 {

   291     Q_D( const HbProgressBar );

   292     return d->mInvertedAppearance;

   293 }

   294 

   295 /*!

   296     @beta

   297    This property holds whether or not a progress bar shows its progress inverted. The function

   298    sets the property to the \a inverted value.

   299 

   300    Not implemented yet.

   301 

   302    \sa invertedAppearance()

   303  */

   304 void HbProgressBar::setInvertedAppearance(bool inverted)

   305 {

   306     Q_D( HbProgressBar );

   307     d->mInvertedAppearance=inverted;

   308     updatePrimitives();

   309 }

   310 

   311 /*!

   312     @beta

   313     Returns the maximum value of the progress bar.

   314 

   315     The default value is \c 100.

   316 

   317     \sa setMaximum()

   318 */

   319 int HbProgressBar::maximum() const

   320 {   

   321     Q_D( const HbProgressBar );

   322     return d->mMaximum;

   323 }

   324 

   325 /*!

   326     @beta

   327     Sets the maximum value of the progress bar.

   328     when setting this property, the minimum is adjusted to ensure

   329     that the range remains valid.

   330 

   331     \sa maximum(),minimum(),setMinimum()

   332 */

   333 void HbProgressBar::setMaximum(int maximum)

   334 {

   335     Q_D( HbProgressBar );

   336     d->setRange(qMin(d->mMinimum,maximum),maximum);

   337 }

   338 

   339 /*!

   340     @beta

   341     Returns the minimum value of the progress bar.

   342 

   343     The default value is \c 0.

   344 

   345     \sa setMinimum()

   346 */

   347 int HbProgressBar::minimum() const

   348 {

   349     Q_D( const HbProgressBar );

   350     return d->mMinimum;

   351 }

   352 

   353 /*!

   354     @beta

   355     Sets the minimum value of the progress bar.

   356     when setting this property, the maximum is adjusted to ensure

   357     that the range remains valid.

   358 

   359     \sa maximum(),minimum(),setMaximum()

   360 

   361 */

   362 void HbProgressBar::setMinimum(int minimum)

   363 {

   364     Q_D( HbProgressBar );

   365     d->setRange(minimum,qMax(d->mMaximum,minimum));

   366 }

   367 

   368 /*!

   369     @beta

   370     Returns the current value of the progress bar.

   371 

   372     The default progressValue is \c 0.

   373 */

   374 int HbProgressBar::progressValue() const

   375 {

   376     Q_D( const HbProgressBar );

   377     return d->mProgressValue;

   378 }

   379 

   380 /*!

   381     @beta

   382     Sets the current value of the progress bar.

   383 

   384     The progress bar forces the value to be within the legal range: \b

   385     minimum <= \c value <= \b maximum.

   386 

   387     \sa progressValue()

   388 */

   389 void HbProgressBar::setProgressValue(int value)

   390 {

   391     Q_D( HbProgressBar );

   392     if (d->mProgressValue == value) {

   393         return;

   394     }

   395     if (value >= d->mMaximum) {

   396         value = d->mMaximum;

   397 #ifdef HB_EFFECTS

   398         HbEffect::start(d->mTrack, HB_PRGRESSBAR_ITEM_TYPE, "progressbar_progress_complete");

   399 #endif

   400     }

   401     else if (value<d->mMinimum) {

   402         value = d->mMinimum;

   403     }

   404     d->mProgressValue=value;

   405 

   406     //redraw track

   407     HbStyleOptionProgressBar progressBarOption;

   408     initStyleOption(&progressBarOption);

   409     if(d->mTrack) {

   410         style()->updatePrimitive(d->mTrack, HbStyle::P_ProgressBar_track, &progressBarOption);

   411     }

   412 

   413     emit valueChanged(value);

   414 }

   415 

   416 /*!

   417     @beta

   418     This function is provided for convenience.

   419 

   420     Sets the progress bar's minimum to \a minimum and its maximum to \a max.

   421 

   422     If \a maximum is smaller than minimum, minimum becomes the only valid legal

   423     value.

   424 

   425     \sa setMinimum(), setMaximum()

   426 */

   427 void HbProgressBar::setRange(int minimum, int maximum) 

   428 {

   429     Q_D( HbProgressBar );

   430     d->setRange(minimum , maximum);

   431 }

   432 

   433 /*!

   434     @beta

   435     Set the \a Min text shown on the progressbar.

   436     \sa text()

   437 */

   438 void HbProgressBar::setMinText(const QString &text)

   439 {

   440     Q_D(HbProgressBar);

   441     if (d->mMinText != text) {

   442         d->mMinText = text;

   443         HbStyleOptionProgressBar progressBarOption;

   444         initStyleOption(&progressBarOption);

   445         style()->updatePrimitive(d->mMinTextItem,HbStyle::P_ProgressBar_mintext,&progressBarOption);

   446      }

   447 }

   448 

   449 /*!

   450     @beta

   451     Returns the Min Text of the progress bar.

   452 

   453     The default progressValue is \c 0.

   454 */

   455 QString HbProgressBar::minText() const

   456 {

   457     Q_D( const HbProgressBar );

   458     return d->mMinText;

   459 }

   460 

   461 /*!

   462     @beta

   463     Set the \a Max text shown on the progressbar.

   464     \sa text()

   465 */

   466 void HbProgressBar::setMaxText(const QString &text)

   467 {

   468   	Q_D(HbProgressBar);

   469     if (d->mMaxText != text) {

   470         d->mMaxText = text;

   471         HbStyleOptionProgressBar progressBarOption;

   472         initStyleOption(&progressBarOption);

   473         style()->updatePrimitive(d->mMaxTextItem,HbStyle::P_ProgressBar_maxtext,&progressBarOption);

   474     }

   475 }

   476 

   477 /*!

   478     @beta

   479     Returns the Max Text of the progress bar.

   480 

   481     The default progressValue is \c 0.

   482 */

   483 QString HbProgressBar::maxText() const

   484 {

   485     Q_D( const HbProgressBar );

   486     return d->mMaxText;

   487 }

   488 

   489 /*!

   490     @beta 

   491     Set the MinMaxtext visibility \a true for showing text,false for hiding the text.

   492     The default is \c false. Min Max text doesnt have a background and would have a transparent background.

   493     \sa isMinMaxTextVisible().

   494 */

   495 void HbProgressBar::setMinMaxTextVisible(bool visible)

   496 {

   497     Q_D(HbProgressBar);

   498     if (d->mMinMaxTextVisible != visible) {

   499         d->mMinMaxTextVisible = visible;

   500 

   501     if(d->mMinMaxTextVisible) {

   502         if(!d->mMinTextItem && !d->mMaxTextItem){

   503             d->createTextPrimitives();

   504         }

   505             d->mMinTextItem->show();

   506             d->mMaxTextItem->show();

   507     } else {

   508         if(d->mMinTextItem && d->mMaxTextItem){

   509             d->mMinTextItem->hide();

   510             d->mMaxTextItem->hide();

   511         }

   512     }

   513     repolish();

   514     updatePrimitives();

   515     }

   516 }

   517 

   518 /*!

   519     @beta

   520     This property holds whether the MinMax text should be displayed.

   521     Return the value of this property.

   522 

   523     \sa setMinMaxTextVisibile()

   524 */

   525 bool HbProgressBar::isMinMaxTextVisible() const

   526 {

   527     Q_D(const HbProgressBar);

   528     return d->mMinMaxTextVisible;

   529 }

   530 

   531 /*!

   532     @beta

   533     Sets the Min-Max text alignment

   534 	

   535 	Supportted alignments are (in both horizontal and vertical orientations)

   536 	Qt::AlignTop

   537 	Qt::AlignBottom

   538 	Qt::AlignCenter

   539 

   540     In Vertical orienatation,     

   541     AlignTop is equivalent to Left

   542     AlignBottom is equivalent to Right

   543 

   544 */

   545 void HbProgressBar::setMinMaxTextAlignment(Qt::Alignment alignment)

   546 {

   547 	Q_D(HbProgressBar);

   548 	if( (alignment != Qt::AlignBottom) && (alignment != Qt::AlignTop) && (alignment != Qt::AlignCenter) ) {

   549 		return;

   550 	}

   551 	if (d->mMinMaxTextAlignment != alignment) {

   552         d->mMinMaxTextAlignment = alignment;

   553 		if (d->mMinMaxTextVisible) {

   554             repolish();

   555         }

   556         updatePrimitives();

   557     }

   558 

   559 }

   560 /*!

   561     @beta

   562     Returns the minmax Text alignment.

   563    

   564 */

   565 Qt::Alignment HbProgressBar::minMaxTextAlignment() const

   566 {

   567 	Q_D(const HbProgressBar);

   568 	return d->mMinMaxTextAlignment;

   569 }

   570 

   571 /*!

   572     @beta

   573     sets the orientation of the progressbar.It can be vertical or horizontal.

   574 */

   575 void HbProgressBar::setOrientation(Qt::Orientation orientation)

   576 {

   577     //TODO: Add vertical slider related info.

   578     Q_D(HbProgressBar);

   579     d->setOrientation(orientation);

   580 }

   581 

   582 /*!

   583     @beta

   584     Returns the orientation of the progressbar.It can be vertical or horizontal.

   585 */

   586 Qt::Orientation HbProgressBar::orientation() const

   587 {

   588     //TODO: Add vertical slider related info.

   589     Q_D(const HbProgressBar);

   590     return d->mOrientation;    

   591 }

   592 

   593 /*!

   594     Returns the pointer for \a primitive passed.

   595     Will return NULL if \a primitive passed is invalid

   596 */

   597 QGraphicsItem* HbProgressBar::primitive(HbStyle::Primitive primitive) const

   598 {

   599     Q_D(const HbProgressBar);

   600 

   601     switch (primitive) {

   602         case HbStyle::P_ProgressBar_frame:

   603             return d->mFrame;

   604         case HbStyle::P_ProgressBar_track:

   605             return d->mTrack;  

   606         case HbStyle::P_ProgressBar_waittrack:

   607             return d->mWaitTrack;

   608         case HbStyle::P_ProgressBar_mintext:

   609             return d->mMinTextItem;

   610         case HbStyle::P_ProgressBar_maxtext:

   611             return d->mMaxTextItem;

   612         default:

   613             return 0;

   614     }

   615 }

   616 

   617 /*!

   618     \reimp

   619  */

   620 void HbProgressBar::updatePrimitives()

   621 {

   622     Q_D(HbProgressBar);

   623 

   624     if(isVisible()){

   625         HbStyleOptionProgressBar progressBarOption;

   626         initStyleOption(&progressBarOption);

   627         if (d->mFrame) {

   628             style()->updatePrimitive(d->mFrame, HbStyle::P_ProgressBar_frame, &progressBarOption);			

   629         }

   630      

   631         if (d->mTrack) {

   632                 style()->updatePrimitive(d->mTrack, HbStyle::P_ProgressBar_track, &progressBarOption);

   633         }

   634         

   635         if (d->mWaitTrack) {

   636                 style()->updatePrimitive(d->mWaitTrack, HbStyle::P_ProgressBar_waittrack, &progressBarOption);

   637         }

   638         

   639         if(d->mMinTextItem && d->mMinMaxTextVisible) {

   640             style()->updatePrimitive(d->mMinTextItem,HbStyle::P_ProgressBar_mintext,&progressBarOption);	

   641         }

   642 

   643         if(d->mMaxTextItem && d->mMinMaxTextVisible) {

   644             style()->updatePrimitive(d->mMaxTextItem,HbStyle::P_ProgressBar_maxtext,&progressBarOption);	

   645         }

   646     }

   647     HbWidget::updatePrimitives();

   648 }

   649 

   650 /*!

   651     Initializes \a option with the values from this HbProgressBar. This method 

   652     is useful for subclasses when they need a HbStyleOptionProgressBar, but don't

   653     want to fill in all the information themselves.

   654  */

   655 

   656 void HbProgressBar::initStyleOption(HbStyleOption *hboption) const

   657 {

   658     Q_D( const HbProgressBar );

   659     Q_ASSERT(hboption);

   660 

   661     HbWidget::initStyleOption(hboption);

   662     HbStyleOptionProgressBar *option = 0;

   663     if ((option = qstyleoption_cast< HbStyleOptionProgressBar *>(hboption)) != 0) {

   664         

   665         option->progressValue = d->mProgressValue;

   666         option->maximum = d->mMaximum;

   667         option->minimum = d->mMinimum;

   668         option->minText = d->mMinText;

   669         option->maxText = d->mMaxText;

   670         option->orientation = d->mOrientation;

   671         option->isSlider=d->mType == HbProgressBar::RatingProgressBar;

   672         option->inverted = d->mInvertedAppearance;

   673         option->stopWaitAnimation = false;

   674         option->minMaxTextAlignment = d->mMinMaxTextAlignment;

   675 		QRect rect(d->mFrame->boundingRect().x(),d->mFrame->boundingRect().y(),d->mFrame->boundingRect().width(),

   676 		d->mFrame->boundingRect().height());

   677 		option->rect = rect;

   678     }

   679 }

   680 

   681 /*!

   682     \reimp

   683  */

   684 void HbProgressBar::closeEvent ( QCloseEvent * event )

   685 {

   686     Q_D(HbProgressBar);

   687     HbStyleOptionProgressBar progressBarOption;

   688     initStyleOption(&progressBarOption);

   689     progressBarOption.stopWaitAnimation = true;

   690     if (d->mWaitTrack) {

   691         style()->updatePrimitive(d->mWaitTrack, HbStyle::P_ProgressBar_waittrack, &progressBarOption);

   692     }

   693     event->accept();

   694 }

   695 

   696 /*!

   697     \reimp

   698  */

   699 QVariant HbProgressBar::itemChange(GraphicsItemChange change, const QVariant &value)

   700 {

   701     if(change == ItemVisibleHasChanged && value.toBool()){

   702         updatePrimitives();

   703     }

   704 #ifdef HB_EFFECTS

   705     Q_D(HbProgressBar);

   706     if(change == QGraphicsItem::ItemVisibleChange){

   707         if(value.toBool()) {

   708 

   709             HbEffect::start(this, HB_PRGRESSBAR_ITEM_TYPE, "progressbar_appear");

   710 

   711             d->mDelayHideInProgress  = false;

   712         }

   713         else if(!d->mDelayHideInProgress) {

   714             //parentItemVisibility check is a hack . Other wise if visibility 

   715             // change happends due to view switch we should not call explicit hide on 

   716             // progress bar.

   717             if(parentItem() && parentItem()->isVisible())

   718                 if(HbEffect::start(this, HB_PRGRESSBAR_ITEM_TYPE, "progressbar_disappear",this,"_q_delayedHide")){

   719                     d->mDelayHideInProgress = true;

   720                     return true;

   721                 }

   722         }

   723     }

   724 #endif//HB_EFFECTS

   725 

   726    return HbWidget::itemChange(change,value);

   727 }

   728 

   729 /*!

   730     \reimp

   731  */

   732 void HbProgressBar::changeEvent(QEvent *event)

   733 {

   734     HbWidget::changeEvent(event);

   735     

   736     switch (event->type()) {

   737     case QEvent::LayoutDirectionChange:

   738 	    if(layoutDirection() == Qt::RightToLeft) {

   739             setInvertedAppearance(true);

   740         }

   741         else {

   742             setInvertedAppearance(false);

   743         }

   744         break;

   745     default:

   746         break;

   747     }

   748 }

   749 

   750 #include "moc_hbprogressbar.cpp"

   751