42  @beta

    44     @beta

    43  @hbcore

    45     @hbcore

    44  \class HbScrollArea

    46     \class HbScrollArea

    45  \brief HbScrollArea provides a finger-touch enabled scrollable container class.  

    47     \brief The HbScrollArea class provides a touch-enabled scrolling view onto another

    46  

    48     widget.

    47  HbScrollArea handles the events need to scroll the contents placed inside it.  It also

    49 

    48  handles the display of scrollbar while scrolling is occurring.

    50     A scroll area displays the contents of another widget within a frame. If the size of

    49  

    51     this widget exceeds the size of the frame, the user can scroll so that the entire

    50  HbScrollArea is used by constructing a QGraphicsWidget that contains the content to be

    52     contents can be viewed. The user scrolls through the contents by using a dragging

    51  displayed, then calling the setContentWidget() method.  The content widget must have its size

    53     gesture. If scroll bars are enabled and the scroll bar is interactive, the user can

    52  set appropriately either by associating a layout with the widget or by explicitly setting

    54     also scroll through the contents using the scroll bar (HbScrollBar class).

    53  the size (e.g. by calling QGraphicsWidget::setGeometry()).

    55 

    54  

    56     %HbScrollArea is a concrete class that you can use directly in your applications to

    55  The class can be used by itself to provide default scrolling behavior or can be

    57     provide default scrolling behavior. %HbScrollArea is also a base class for

    56  subclassed to add touch feedback, selection feedback, etc.

    58     HbAbstractItemView and the item view classes that derive from it. If necessary, you

    57  

    59     can subclass %HbScrollArea to add additional features, such as touch and selection

    58  By default, the class provides dragging, flicking with animated follow-on, a

    60     feedback.

    59  simple inertia algorithm for slowing the animated follow-on scrolling and

    61 

    60  a bounce-back algorithm for animating the content back to its bounding

    62     \image html hbscrollarea.png A scroll area containing a large image and showing scrollbars

    61  limits at the end of a drag or flick action.

    63 

    62  */

    64     %HbScrollArea provides properties that you can use to customize the following aspects

    63 

    65     of the scroll area:

    64 /*!

    66 

    65  Here are the main properties of the class:

    67     - <b>Scrolling style</b>. The user scrolls through the contents by using a dragging

    66 

    68          movement. This property controls what happens when the user releases the pressure.

    67  \li HbScrollArea::scrollDirections     : 

    69          The default is that a follow-on animation continues the scrolling if the dragging

    68  \li HbScrollArea::clampingStyle        : 

    70          was fast. Alternatively, the scrolling can stop as soon as the user releases the

    69  \li HbScrollArea::scrollingStyle       : 

    71          pressure, regardless of the dragging speed. Call setScrollingStyle() to set this

    70  \li HbScrollArea::showScrollBars       : 

    72          property.

    71  \li HbScrollArea::scrollBarWidth       :  

    73 

    72  \li HbScrollArea::scrollBarMargin      : 

    74     - <b>Friction effect</b>. This property controls the speed of the follow-on scrolling

    73  \li HbScrollArea::frictionEnabled      :

    75          animation. When the friction effect is enabled, it slows the animation and causes

    74  \li HbScrollArea::handleLongPress      :  

    76          it to stop more quickly than when the effect is not enabled. Call setFrictionEnabled()

    75  */

    77          to set this property.

    76 

    78 

    77 /*!

    79     - <b>Clamping style</b>. This property controls how scrolling is constrained relative

    78     \property HbScrollArea::showScrollBars

    80          to the contents of the scrolling area. Scrolling can be limited to the bounding

    79     \brief

    81          rectangle of the contents or it can go beyond the bounding rectangle and bounce

    80 */

    82          back to its limits (this is the default). Call setClampingStyle() to set this

    81 

    83          property.

    82 /*!

    84 

    83     \property HbScrollArea::scrollBarWidth

    85     - <b>Scroll direction</b>. This property controls the scrolling direction. The default is

    84     \brief

    86          vertical scrolling, but this can be changed to horizontal or bi-directional scrolling.

    85 */

    87          Call setScrollDirections() to set this property.

    86 

    88 

    87 /*!

    89     - <b>Scrollbar policy</b>. There is a separate scrollbar policy property for both scrollbars.

    88     \property HbScrollArea::scrollBarMargin

    90          You can set these so that the scrollbar is always shown, never shown, only shown when

    89     \brief

    91          needed or for short periods (autohide), which is the default behavior. Call

    90 */

    92          setVerticalScrollBarPolicy() and setHorizontalScrollBarPolicy() to set these properties.

    91 

    93 

    92 /*!

    94     - <b>Continuation indicators</b>. This property controls whether visual feedback is provided

    93     \property HbScrollArea::scrollDirections

    95          to indicate when scrolling is possible. The default value is false. Call

    94     \brief 

    96          setContinuationIndicators() to set this property.

    95 */

    97 

    96 

    98     The contents widget must be an object of a class derived from QGraphicsWidget. After

    97 /*!

    99     constructing this widget, you set it into the scroll area by calling setContentWidget().

    98     \property HbScrollArea::clampingStyle

   100     The scroll area uses QGraphicsWidget::sizeHint() to resize the content widget to fit,

    99     \brief 

   101     taking into account the scroll direction. For example, when the scrolling direction is

   100 */

   102     vertical, the scroll area resizes the contents widget to fit the width of the scroll area.

   101 

   103 

   102 /*!

   104     \section _usecases_hbscrollarea Using the HbScrollArea class

   103     \property HbScrollArea::scrollingStyle

   105 

   104     \brief 

   106     This example creates an HbScrollArea widget and sets a large photo as its contents.

   105 */

   107 

   106 

   108     \code

   107 /*!

   109 int main(int argc, char *argv[])

   108     \property HbScrollArea::frictionEnabled

   110 {

   109     \brief

   111     HbApplication app(argc, argv);

   110 */

   112     app.setApplicationName( "Scroll Area" );

   111 

   113 

   112 /*!

   114     HbMainWindow window;

   113     \property HbScrollArea::handleLongPress

   115     HbView* view = new HbView();

   114     \brief 

   116 

   115 */

   117     // Create the scroll area object.

   116 

   118     HbScrollArea* scrollArea = new HbScrollArea();

   117 /*!

   119 

   118     \property HbScrollArea::verticalScrollBarPolicy

   120     // Create the content widget.

   119     \brief

   121     QGraphicsWidget* content = new QGraphicsWidget();

   120 */

   122 

   121 

   123     // Create a pixmap as a child of the content widget.

   122 /*!

   124     QString string(":/gfx/beach.jpg");

   123     \property HbScrollArea::horizontalScrollBarPolicy

   125     QGraphicsPixmapItem* pixmapItem = new QGraphicsPixmapItem(string, content);

   124     \brief

   126 

   125 */

   127     // Set the preferred size of the content widget to match the full size of the photo.

   128     content->setPreferredSize(pixmapItem->boundingRect().size());

   129 

   130     // Load the content widget into the scrolling area.

   131     scrollArea->setContentWidget(content);

   132 

   133     // Set the scroll area to scroll in both directions.

   134     scrollArea->setScrollDirections(Qt::Vertical | Qt::Horizontal);

   135 

   136     view->setWidget(scrollArea);

   137     window.addView(view);

   138     window.show();

   139     return app.exec();

   140 }

   141     \endcode

   142 

   143     \sa HbScrollBar

   144  */

   130     This signal is emitted when scrolling direction is changed.

   149     This signal is emitted when the scrolling direction changes.

   136     This signal is emitted whenever a scrolling action begins.

   155     This signal is emitted when a scrolling action begins.

   142     This signal is emitted whenever a scrolling action ends.

   161     This signal is emitted when a scrolling action ends.

   143 */

   162 */

   144 

   163 

   145 /*!

   164 /*!

   146     \fn void HbScrollArea::scrollPositionChanged(QPointF newposition)

   165     \fn void HbScrollArea::scrollPositionChanged(const QPointF &newPosition)

   147     This signal is emitted when scroll position is changed and someone is connected to the signal.

   166 

   167     This signal is emitted when the scroll position is changed, but only if this signal

   168     is connected to a slot.

   153     Clamping styles supported by HbScrollArea.

   174     Defines the clamping styles supported by HbScrollArea. The clamping style

   154 

   175     controls the behavior when scrolling to the edge of the contents of the scrolling

   155     This enum describes how scrolling is behaving when reaching boundaries of the content item.

   176     area.

   156 */

   177 

   178     \sa setClampingStyle(), clampingStyle()

   179 */

   180 

   159 

   183     Scrolling is limited to the bounding rectangle of the contents.

   160     Scrolling is limited to the bounding rectangle of the content item.

   184 */

   161 */

   185 

   164 

   188     Scrolling can go beyond the bounding rectangle of the contents, but bounces

   165     Scrolling can go beyond the bounding rectangle of the content item, but bounces back to the

   189     back to the limits of the bounding rectangle when released or when the follow-on

   166     limits of the bounding rectangle when released or when inertia scrolling stops.

   190     scrolling animation stops. This is the default clamping style.

   167 */

   191 */

   192 

   170 

   195     Scrolling is unclamped. Typically you use this only in a subclass that implements

   171     Scrolling is completely unclamped (this is usually used when the subclass implements its own).

   196     its own custom clamping behavior.

   172 */

   197 */

   198 

   176     Different scrolling styles supported by HbScrollArea.

   202     Defines the scrolling styles supported by HbScrollArea. The scrolling style

   177 

   203     controls which gestures the user can use to scroll the contents and how the scrolling

   178     This enum describes how scroll area can be scrolled.

   204     responds to those gestures.

   179 */

   205 

   206     \sa setScrollingStyle(), scrollingStyle()

   207 */

   208 

   183     Dragging motion pans the view with no follow-on scrolling animation.

   212     The user can scroll through the contents by using a dragging motion. The scrolling

   184 */

   213     stops as soon as the user stops the dragging motion.

   214 */

   215 

   188     Dragging motion pans the view with no follow-on scrolling animation,

   219     \deprecated

   189     quick flicking motion triggers scrolling animation.

   220     The user can scroll through the contents by using a dragging motion and a quick

   190 */

   221     flicking motion triggers a follow-on scrolling animation.

   222 */

   223 

   194     Dragging motion pans the view, velocity at end of drag motion triggers follow-on animated scrolling.

   227     The user can scroll through the contents by using a dragging motion. In addition

   228     a fast dragging motion triggers a follow-on scrolling animation when the user

   229     stops dragging and releases the pressure. This is the default scrolling style.

   200     This enum type describes the various visibility modes of HbScrollArea's scroll bars.

   235     Defines the scroll bar visibility modes supported by  HbScrollArea.

   236 

   237     \sa setVerticalScrollBarPolicy(), verticalScrollBarPolicy(),

   238     setHorizontalScrollBarPolicy(), horizontalScrollBarPolicy()

   206     HbScrollArea shows a scroll bar when the content is too large to fit and not otherwise.

   244     Show the scroll bar only when the contents are too large to fit.

   211     HbScrollArea never shows a scroll bar.

   249     Never show the scroll bar.

   216     HbScrollArea always shows a scroll bar.

   254     Always show the scroll bar.

   221     HbScrollArea shows scroll bar for short period of time when the content is displayed or scrolled. Scroll bar is not shown if not needed.

   259     Show the scroll bar for a short period when the contents are first displayed or

   222 

   260     when the user scrolls the contents. This is the default behavior.

   223     This is the default behavior.

   235   Constructor

   272     Constructs an HbScrollArea object with the given \a parent.

   236  

   273  */

   237   \sa HbScrollArea::HbScrollArea

   274 HbScrollArea::HbScrollArea(QGraphicsItem* parent) :

   238  */

   239 HbScrollArea::HbScrollArea(QGraphicsItem* parent) : 

   248   Protected constructor.

   283     Protected constructor.

   259  Destructor

   294     Destructor

   260  

   261  \sa HbScrollArea::~HbScrollArea

   272  Returns a pointer to the QGraphicsWidget,which is the content of scrollable area.

   305     Returns a pointer to the widget that is contained within the scroll area

   273  

   306     and that defines the contents to be scrolled.

   274  \sa HbScrollArea::setContentWidget()

   307 

   308     \sa setContentWidget()

   284  Assigns the QGraphicsWidget that is to be scrolled.  The HbScrollArea widget takes ownership of

   318    Assigns a widget (QGraphicsWidget object) to the scroll area. This widget defines

   285  the QGraphicsWidget.

   319    the contents of the scroll area. The HbScrollArea object takes ownership of the

   286  

   320    contents widget.

   287  \sa HbScrollArea::contentWidget()

   321 

   322    \sa contentWidget()

   319 Removes the content widget, which is set to the scrollarea and returns it.

   354     Removes the scroll area's content widget from the scroll area, returns it, and

   320 The ownership of the \a QGraphicsWidget is transferred to the caller.

   355     transfers ownership of the content widget to the caller. This is useful when you

   321 

   356     need to switch the contents without deleting previous contents.

   322 \note This function is particularly useful if one wants to switch between

   323 different contents without deleting previous content.

   326 */

   359  */

   345  Returns the value of the clampingStyle property

   378     Returns the value of the \c clampingStyle property.

   346  

   379 

   347  \sa HbScrollArea::setClampingStyle()

   380     \sa setClampingStyle(), HbScrollArea::ClampingStyle

   357  Sets the clampingStyle property that controls how the scrolling is constrained

   390     Sets the \c clampingStyle property, which controls how scrolling is constrained

   358  relative to the contents of the scrolling area.

   391     relative to the contents of the scrolling area. The possible values are defined

   359  

   392     by the HbScrollArea::ClampingStyle enum. The default is

   360  Possible values for the clamping style include:

   393     HbScrollArea::BounceBackClamping.

   361  

   394 

   362  	StrictClamping - scrolling is limited to the bounding rectangle of the content item

   395     \sa clampingStyle()

   363  	BounceBackClamping - scrolling can go beyond the bounding rectangle of the content item, but bounces back to the

   364  					limits of the bounding rectangle when released or when inertia scrolling stops

   365  	NoClamping - scrolling is completely unclamped (this is usually used when the subclass implements its own

   366  					custom clamping behavior)

   367  

   368  The default value is BounceBackClamping.

   369  

   370  \sa HbScrollArea::clampingStyle()

   380   Returns the value of the scrollingStyle property

   405     Returns the value of the \c scrollingStyle property.

   381  

   406 

   382   \sa HbScrollArea::setScrollingStyle()

   407     \sa setScrollingStyle()

   392   Sets the scrollingStyle property that controls how the style of scrolling interaction

   417     Sets the \c scrollingStyle property, which controls which gestures the user can

   393   provided by the widget

   418     use to scroll the contents and how the scrolling responds to those gestures. The

   394  

   419     possible values are defined by the HbScrollArea::ScrollingStyle enum. The default

   395   Possible values for the clamping style include:

   420     value is HbScrollArea::PanWithFollowOn.

   396  

   421 

   397  		Pan - dragging motion pans the view with no follow-on scrolling animation

   422     \sa scrollingStyle()

   398                \deprecated PanOrFlick

   399                     is deprecated.

   400  		PanWithFollowOn - dragging motion pans the view, velocity at end of drag motion triggers follow-on animated scrolling

   401  

   402   The default value is PanWithFollowOn.

   403  

   404   \sa HbScrollArea::scrollingStyle()

   419   Returns the value of the scrollDirections property.

   437     Returns the value of the \c scrollDirections property.

   421   \sa HbScrollArea::setScrollDirections()

   439     \sa setScrollDirections()

   431   Sets the value of the scrollDirections property.  This value is of

   449     Sets the \c scrollDirections property, which controls the scrolling direction. The

   432   type Qt::Orientations and can set to either Qt::Horizontal to enable horizontal scrolling,

   450     possible values are defined by the Qt::Orientations enum, as shown in the following

   433   Qt::Vertical to enable vertical scrolling or (Qt::Horizontal | Qt::Vertical) to enable

   451     table. The default value is Qt::Vertical.

   434   scrolling in both directions.

   452 

   435  

   453     <table border="1" style="border-collapse: collapse; border: solid;">

   436   The default value is Qt::Vertical.

   454     <tr><th>To enable:</th><th>Set to:</th></tr>

   437  

   455     <tr><td>Horizontal scrolling</td><td>Qt::Horizontal</td></tr>

   438   \sa HbScrollArea::scrollDirections()

   456     <tr><td>Vertical scrolling</td><td>Qt::Vertical</td></tr>

   457     <tr><td>Scrolling in both directions</td><td>Qt::Horizontal | Qt::Vertical</td></tr>

   458     </table>

   459 

   460     \sa scrollDirections()

   460   Returns true if the inertia scrolling effect is enabled, false otherwise.

   482     Returns true if the friction effect is enabled, false otherwise.

   462   \sa HbScrollArea::setFrictionEnabled()

   484     \sa setFrictionEnabled()

   472   Enables/disables the inertia scrolling effect.

   494     Sets the \c frictionEnabled property. The default value is true, which

   473   By default, the inertia effect is enabled.

   495     indicates that the friction effect is enabled.

   474  

   496 

   475   \sa HbScrollArea::frictionEnabled()

   497     When the HbScrollArea::PanWithFollowOn scrolling style is in use, the

   498     \c frictionEnabled property controls the speed of the follow-on scrolling

   499     animation. When the friction effect is enabled (the default), it slows the

   500     animation and causes it to stop earlier than when the friction effect is not

   501     in use.

   502 

   503     \sa frictionEnabled()

   485   Returns true if the scroll area handles

   513     Returns true if the scroll area handles long press gestures, false otherwise.

   486   long press gestures, false otherwise

   514 

   487  

   515     \deprecated This function is deprecated.

   488   \deprecated HbScrollArea::longPressEnabled()

   489       is deprecated.

   490  

   491   \sa HbScrollArea::setHandleLongPress()

   500   Sets the value of the handleLongPress property.  This value is set

   524     Sets the value of the \c handleLongPress property. Set \a value to true if

   501   to true if the widget is to respond to long press gestures, false otherwise.

   525     the widget responds to long press gestures. Otherwise set it to false.

   502  

   526     The default value is false.

   503   The default value is false.

   527 

   504  

   528     \deprecated This function is deprecated.

   505   \deprecated HbScrollArea::setLongPressEnabled(bool)

   506         is deprecated.

   507  

   508   \sa HbScrollArea::handleLongPress()

   516 /*

   536 /*!

   517   \reimp

   537     \reimp

   533 /*! @beta

   555 /*!

   534   upGesture() is a virtual slot function that is called whenever an

   556     A virtual slot function that is called when an upwards flick gesture is detected

   535   up flick gesture is detected, if the scrollDirection is set to

   557     while vertical scrolling is enabled.

   536   enable vertical scrolling.

   558 

   537  

   559     \deprecated This function is deprecated.

   538   Derived classes can override this method to add custom handling of

   539   the gesture.  In most cases, derived classes should call up to the

   540   HbScrollArea parent method.

   541  

   542   \deprecated HbScrollArea::upGesture(int)

   543         is deprecated.

   552 /*! @beta

   568 /*!

   553   downGesture() is a virtual slot function that is called whenever an

   569     A virtual slot function that is called when a downwards flick gesture is

   554   down flick gesture is detected, if the scrollDirection is set to

   570     detected while vertical scrolling is enabled.

   555   enable vertical scrolling. 

   571 

   556  

   572     \deprecated This function is deprecated.

   557   Derived classes can override this method to add custom handling of

   558   the gesture.  In most cases, derived classes should call up to the

   559   HbScrollArea parent method.

   560  

   561   \deprecated HbScrollArea::downGesture(int)

   562         is deprecated.

   570 /*! @beta

   580 /*!

   571   leftGesture() is a virtual slot function that is called whenever an

   581     A virtual slot function that is called when a left flick gesture

   572   left flick gesture is detected, if the scrollDirection is set to

   582     is detected while horizontal scrolling is enabled.

   573   enable horizontal scrolling.

   583 

   574  

   584     \deprecated This function is deprecated.

   575   Derived classes can override this method to add custom handling of

   576   the gesture.  In most cases, derived classes should call up to the

   577   HbScrollArea parent method.

   578  

   579   \deprecated HbScrollArea::leftGesture(int)

   580             is deprecated.

   588 /*! @beta

   592 /*!

   589   rightGesture() is a virtual slot function that is called whenever an

   593     A virtual slot function that is called when a right flick gesture is detected

   590   right flick gesture is detected, if the scrollDirection is set to

   594     while horizontal scrolling is enabled.

   591   enable horizontal scrolling.

   595 

   592  

   596     \deprecated This function is deprecated.

   593   Derived classes can override this method to add custom handling of

   594   the gesture.  In most cases, derived classes should call up to the

   595   HbScrollArea parent method.

   596  

   597   \deprecated HbScrollArea::rightGesture(int)

   598         is deprecated.

   608   panGesture() is a virtual slot function that is called whenever an

   606     A virtual slot function that is called when a pan gesture is detected.

   609   pan gesture is detected.

   607 

   610  

   608     \deprecated This function is deprecated.

   611   Derived classes can override this method to add custom handling of

   612   the gesture.  In most cases, derived classes should call up to the

   613   HbScrollArea parent method.

   614  

   615   \deprecated HbScrollArea::panGesture(const QPointF&)

   616    is deprecated.

   624 /*!  @beta

   616 /*!

   625   longPressGesture() is a virtual slot function that is called whenever an

   617     A virtual slot function that is called when a long press gesture is

   626   long press gesture is detected, if the handleLongPress property is set to true.

   618     detected while the \c handleLongPress property is set to true.

   619 

   620     \deprecated This function is deprecated.

   621  */

   622 void HbScrollArea::longPressGesture(const QPointF &)

   623 {

   624     HB_DEPRECATED("HbScrollArea::longPressGesture(const QPointF &) is deprecated. Use gesture FW.");

   625 }

   626 

   627 /*!

   628     Reimplemented from QObject.

   629  */

   630 void HbScrollArea::mousePressEvent(QGraphicsSceneMouseEvent *event)

   631 {

   632     Q_UNUSED (event);

   633 }

   634 

   635 /*!

   636     Returns true if a scrolling action is in progress, false otherwise.

   637  */

   638 bool HbScrollArea::isScrolling() const

   639 {

   640     Q_D( const HbScrollArea );

   641 

   642     return d->mIsScrolling;

   643 }

   644 

   645 /*!

   646     Returns true if the scrolling is in a response to the user dragging, false if it

   647     is the follow-on scrolling animation.

   648  */

   649 bool HbScrollArea::isDragging() const

   650 {

   651     Q_D( const HbScrollArea );

   652 

   653     return (d->mIsScrolling && !d->mIsAnimating);

   654 }

   655 

   656 /*!

   657     Scrolls the view by the amount indicated by \a delta and returns true if

   658     the scroll was successful and false otherwise.

   659 

   660     This is a virtual function, which subclasses can override to customize the

   661     behavior; for example, to clamp the position so that at least one item in

   662     the view remains visible.

   663  */

   664 bool HbScrollArea::scrollByAmount(const QPointF& delta)

   665 {

   666     Q_D( HbScrollArea );

   667 

   668     return d->scrollByAmount(delta);

   669 }

   756                 if (!(d->mScrollDirections & Qt::Vertical)) {

   744                 if (!(d->mScrollDirections & Qt::Vertical) ||

   745                     ((d->mContents->sizePolicy().verticalPolicy() & QSizePolicy::ExpandFlag) &&

   746                     (newSize.height() < size().height()))) {

   761                 if (!(d->mScrollDirections & Qt::Horizontal)) {

   751                 if (!(d->mScrollDirections & Qt::Horizontal) ||

   752                     ((d->mContents->sizePolicy().horizontalPolicy() & QSizePolicy::ExpandFlag) &&

   753                      (newSize.width() < size().width()))) {

   777    \reimp

   768     Reimplemented from QObject.

   784         if (isVisible()) {            

   775         //If layoutdirection is from right to left, we expand the contentwidget to the left

   776         //instead of the right

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

   778             QGraphicsSceneResizeEvent *resizeEvent = static_cast<QGraphicsSceneResizeEvent*>(event);

   779             if (resizeEvent) {

   780                 qreal xChange = resizeEvent->newSize().width() - resizeEvent->oldSize().width();

   781                 qreal newXPos = d->mContents->pos().x() - xChange;

   782                 d->mContents->setPos(newXPos, d->mContents->pos().y());

   783             }

   784         }

   785         if (isVisible()) {

   788         if (d->mAbleToScrollX && d->mHorizontalScrollBar->isVisible()) {

   789         if (d->mAbleToScrollX && d->mHorizontalScrollBar && d->mHorizontalScrollBar->isVisible()) {

   792         if (d->mAbleToScrollY && d->mVerticalScrollBar->isVisible()) {

   793         if (d->mAbleToScrollY && d->mVerticalScrollBar && d->mVerticalScrollBar->isVisible()) {

   801     \reimp

   802     Reimplemented from QGraphicsWidget.

   802 */

   803  */

   814                 sh = d->mContents->effectiveSizeHint( which, constraint );

   815                 sh = d->mContents->effectiveSizeHint( which );

   831  \reimp

   832     \reimp

   873     Returns the scrollbar policy for vertical scrollbar

   874     Returns the display policy for the vertical scrollbar.

   876 */

   877  */

   884     Sets the policy for vertical scrollbar

   885     Sets the display policy for the vertical scrollbar. The possible values are

   885 

   886     defined by the HbScrollArea::ScrollBarPolicy enum. The default value is

   886     The default policy is HbScrollArea::ScrollBarAutoHide.

   887     HbScrollArea::ScrollBarAutoHide.

   887 

   888 

   888     \sa setHorizontalScrollBarPolicy(), verticalScrollBarPolicy()

   889     \sa setHorizontalScrollBarPolicy(), verticalScrollBarPolicy(), setVerticalScrollBar()

   897   Returns the vertical scroll bar.

   898     Returns the vertical scroll bar.

   898 

   899 

   899   \sa verticalScrollBarPolicy(), horizontalScrollBar()

   900     \sa verticalScrollBarPolicy(), horizontalScrollBar()

   908    Replaces the existing vertical scroll bar with \a scrollBar. The former

   912     Replaces the existing vertical scroll bar with \a scrollBar. The former

   909    scroll bar is deleted.

   913     scroll bar is deleted.

   910 

   914 

   911    HbScrollArea already provides vertical and horizontal scroll bars by

   915     %HbScrollArea provides provides vertical and horizontal scroll bars by default.

   912    default. You can call this function to replace the default vertical

   916     Call this function to replace the default vertical scroll bar with your own

   913    scroll bar with your own custom scroll bar.

   917     custom scroll bar, if required.

   914 

   918 

   915    \sa verticalScrollBar(), setHorizontalScrollBar()

   919     \sa verticalScrollBar(), setHorizontalScrollBar()

   916 */

   920  */

   929     \brief Returns the policy for horizontal scrollbar

   933     Returns the display policy for the horizontal scrollbar.

   932 */

   936  */

   940     \brief Sets the policy for horizontal scrollbar

   944     Sets the display policy for the horizontal scrollbar. The possible values are

   941 

   945     defined by the HbScrollArea::ScrollBarPolicy enum. The default value is

   942     The default policy is HbScrollArea::ScrollBarAutoHide.

   946     HbScrollArea::ScrollBarAutoHide.

   943 

   947 

   944     \sa setVerticalScrollBarPolicy(), horizontalScrollBarPolicy()

   948     \sa setVerticalScrollBarPolicy(), horizontalScrollBarPolicy(), setHorizontalScrollBar()

   953   Returns the horizontal scroll bar.

   957     Returns the horizontal scroll bar.

   954 

   958 

   955   \sa horizontalScrollBarPolicy(), verticalScrollBar()

   959     \sa horizontalScrollBarPolicy(), verticalScrollBar()

   967    HbScrollArea already provides vertical and horizontal scroll bars by

   974    %HbScrollArea provides vertical and horizontal scroll bars by default.

   968    default. You can call this function to replace the default horizontal

   975    Call this function to replace the default horizontal scroll bar with your

   969    scroll bar with your own custom scroll bar.

   976    own custom scroll bar, if required.

   985     \brief the alignment of the scroll area's widget    

   992     Sets the alignment of the scroll area's content widget. The possible values are

   986 

   993     defined by the Qt::Alignment enum.

   987     By default, the widget stays rooted to the top-left corner of the

   994 

   988     scroll area.

   995     The default value is \c Qt::AlignLeft | \c Qt::AlignTop, which roots the content

   989     \sa alignment

   996     widget in the top-left corner of the scroll area.

   997 

   998     \sa alignment()

  1001     \brief the alignment of the scroll area's widget

  1010     Returns the alignment of the scroll area's content widget.

  1002 

  1011 

  1003     By default, the widget stays rooted to the top-left corner of the

  1012     \sa setAlignment()

  1004     scroll area.

  1013  */

  1005     \sa setAlignment

  1006 */

  1015     \brief Contination indicators for scroll area

  1022     Sets the \c contuationIndicators property for the scroll area. Set

  1016 

  1023     \a indication to true if you want the scroll area to provide visual

  1017     By default continuation graphics are disabled. When continuation

  1024     feedback when scrolling is possible. The default value is false.

  1018     graphics are enabled, scroll area shows indications where it is

  1025 

  1019     possible to scroll.

  1026     \sa continuationIndicators()

  1020 

  1027  */

  1021     \sa continuationIndicators

  1022 */

  1023 

  1039     \brief Contination indicators for scroll area

  1043     Returns the value of the \c continuationIndicators property for the

  1040 

  1044     scroll area.

  1041     By default continuation graphics are disabled. When continuation

  1045 

  1042     graphics are enabled, scroll area shows indications where it is

  1046     \sa setContinuationIndicators()

  1043     possible to scroll.

  1044 

  1045     \sa setContinuationIndicators

  1054 /*!

  1055 

  1055     Scrolls the contents of the scroll area so that the point \a position is visible

  1056 /*!

  1056     inside the region of the scrollArea with margins specified in pixels by \a xMargin and

  1057     Scrolls the contents of the scroll area so that \a position is visible within

  1057     \a yMargin. If the specified point cannot be reached, the contents are scrolled to

  1058     the scroll area with the given margins. If the specified point cannot be shown,

  1058     the nearest valid position. The default and minimum valid value for both margins is 0 pixels.

  1059     the contents are scrolled to the nearest valid position.

  1059     Valid range for \a xMargin is between 0 and width of scrollArea, valid range for \a yMargin is

  1060 

  1060     between 0 and height of scrollArea.\a xMargin, \a yMargin, x and y values of \a position will be

  1061     \param position Defines the position within the content widget that is to be shown within

  1061     ignored depending on scrollingDirection.

  1062                the scroll area.

  1063     \param xMargin The width of the vertical margins in pixels. This can be between 0 and the

  1064                width of the scroll area. The default value is 0.

  1065 

  1066     \param yMargin The height of the horizontal margins in pixels. This can be between 0

  1067                and the height of the scroll area. The default value is 0.

  1064 */

  1070  */

  1072     Scrolls the contents of the scroll area to the \a newPosition in a given \a time.

  1078     Scrolls the contents of the scroll area to \a newPosition in the given \a time.

  1073     If the time is 0, contents is scrolled to the position instantly.

  1079     If \a time is 0, the contents are scrolled to the position immediately.

  1074 */

  1080  */

  1090   \reimp

  1099     \reimp

  1094     Q_D(HbScrollArea);

  1103     if (isVisible()) {

  1095 

  1104         Q_D(HbScrollArea);

  1096     d->doLazyInit();

  1105         d->doLazyInit();

  1097 

  1106 

  1098     // fetch scrolling parameters from css

  1107         // fetch scrolling parameters from css

  1099     const QString SpeedFactor = "speed-factor";

  1108         const QLatin1String SpeedFactor("speed-factor");

  1100     const QString IntertiaSpeedFactor = "inertia-speed-factor";

  1109         const QLatin1String IntertiaSpeedFactor("inertia-speed-factor");

  1101     const QString MaxScrollSpeed = "max-scroll-speed";

  1110         const QLatin1String MaxScrollSpeed("max-scroll-speed");

  1102     const QString SpringStrength = "spring-strength";

  1111         const QLatin1String SpringStrength("spring-strength");

  1103     const QString SpringDampingFactor = "spring-damping-factor";

  1112         const QLatin1String SpringDampingFactor("spring-damping-factor");

  1104     const QString FrictionPerMilliSecond = "friction";

  1113         const QLatin1String FrictionPerMilliSecond("friction");

  1105 

  1114 

  1106     params.addParameter(SpeedFactor);

  1115         params.addParameter(SpeedFactor);

  1107     params.addParameter(IntertiaSpeedFactor);

  1116         params.addParameter(IntertiaSpeedFactor);

  1108     params.addParameter(MaxScrollSpeed);

  1117         params.addParameter(MaxScrollSpeed);

  1109     params.addParameter(SpringStrength);

  1118         params.addParameter(SpringStrength);

  1110     params.addParameter(SpringDampingFactor);

  1119         params.addParameter(SpringDampingFactor);

  1111     params.addParameter(FrictionPerMilliSecond);

  1120         params.addParameter(FrictionPerMilliSecond);

  1112     HbWidget::polish(params);

  1121         HbWidget::polish(params);

  1113 

  1122 

  1114     if (!params.value(SpeedFactor).isNull()) {

  1123         if (!params.value(SpeedFactor).isNull()) {

  1115         d->mSpeedFactor = params.value(SpeedFactor).toDouble();

  1124             d->mSpeedFactor = params.value(SpeedFactor).toDouble();

  1116     }

  1125         }

  1117     if (!params.value(IntertiaSpeedFactor).isNull()) {

  1126         if (!params.value(IntertiaSpeedFactor).isNull()) {

  1118         d->mInertiaSpeedFactor = params.value(IntertiaSpeedFactor).toDouble();

  1127             d->mInertiaSpeedFactor = params.value(IntertiaSpeedFactor).toDouble();

  1119     }

  1128         }

  1120     if (!params.value(MaxScrollSpeed).isNull()) {

  1129         if (!params.value(MaxScrollSpeed).isNull()) {

  1121         d->mMaxScrollSpeed = params.value(MaxScrollSpeed).toDouble();

  1130             d->mMaxScrollSpeed = params.value(MaxScrollSpeed).toDouble();

  1122     }

  1131         }

  1123     if (!params.value(SpringStrength).isNull()) {

  1132         if (!params.value(SpringStrength).isNull()) {

  1124         d->mSpringStrength = params.value(SpringStrength).toDouble();

  1133             d->mSpringStrength = params.value(SpringStrength).toDouble();

  1125     }

  1134         }

  1126     if (!params.value(SpringDampingFactor).isNull()) {

  1135         if (!params.value(SpringDampingFactor).isNull()) {

  1127         d->mSpringDampingFactor = params.value(SpringDampingFactor).toDouble();

  1136             d->mSpringDampingFactor = params.value(SpringDampingFactor).toDouble();

  1128     }

  1137         }

  1129     if (!params.value(FrictionPerMilliSecond).isNull()) {

  1138         if (!params.value(FrictionPerMilliSecond).isNull()) {

  1130         d->mFrictionPerMilliSecond = params.value(FrictionPerMilliSecond).toDouble();

  1139             d->mFrictionPerMilliSecond = params.value(FrictionPerMilliSecond).toDouble();

  1131     }

  1140         }

  1132     if (d->mContinuationIndicators) {

  1141         if (d->mContinuationIndicators) {

  1133         d->updateIndicators(-d->mContents->pos());

  1142             d->updateIndicators(-d->mContents->pos());

  1134     }

  1143         }

  1135 }

  1144     } else {

  1136 

  1145         HbWidget::polish(params);

  1137 /*!

  1146     }

  1138   \reimp

  1147 }

  1139 

  1148 

  1149 /*!

  1150     Reimplemented from QObject.

  1152     \reimp

  1163     Reimplemented from QGraphicsWidget.

  1153 */

  1164  */

  1165 QPainterPath HbScrollArea::shape() const

  1166 {

  1167     Q_D(const HbScrollArea);

  1168     if ( d->mClearCachedRect){

  1169         d->reCalculateCachedValue();

  1170     }

  1171     return d->mShape;

  1172 }

  1173 

  1174 /*!

  1175     Reimplemented from QGraphicsWidget.

  1176  */

  1177 QRectF HbScrollArea::boundingRect() const

  1178 

  1179 {

  1180     Q_D(const HbScrollArea);

  1181     if (d->mClearCachedRect) {

  1182         d->reCalculateCachedValue();

  1183     }

  1184     return d->mBoundingRect;