FCL/sf/mw/hb: comparison src/hbcore/gui/hbscrollarea.cpp

equal deleted inserted replaced

-:f7ac710697a9
+:06ff229162e9
 #include <QGesture>
 #include <QDebug>
 /*!
-*  @beta
+@beta
-*  @hbcore
+@hbcore
-*  \class HbScrollArea
+\class HbScrollArea
-*  \brief HbScrollArea provides a finger-touch enabled scrollable container class.
+\brief HbScrollArea provides a finger-touch enabled scrollable container class.
-*
-*  HbScrollArea handles the events need to scroll the contents placed inside it.  It also
+HbScrollArea handles the events need to scroll the contents placed inside it.  It also
-*  handles the display of scrollbar while scrolling is occurring.
+handles the display of scrollbar while scrolling is occurring.
-*
-*  HbScrollArea is used by constructing a QGraphicsWidget that contains the content to be
+HbScrollArea is used by constructing a QGraphicsWidget that contains the content to be
-*  displayed, then calling the setContentWidget() method.  The content widget must have its size
+displayed, then calling the setContentWidget() method.  The content widget must have its size
-*  set appropriately either by associating a layout with the widget or by explicitly setting
+set appropriately either by associating a layout with the widget or by explicitly setting
-*  the size (e.g. by calling QGraphicsWidget::setGeometry()).
+the size (e.g. by calling QGraphicsWidget::setGeometry()).
-*
-*  The class can be used by itself to provide default scrolling behavior or can be
+The class can be used by itself to provide default scrolling behavior or can be
-*  subclassed to add touch feedback, selection feedback, etc.
+subclassed to add touch feedback, selection feedback, etc.
-*
-*  By default, the class provides dragging, flicking with animated follow-on, a
+By default, the class provides dragging, flicking with animated follow-on, a
-*  simple inertia algorithm for slowing the animated follow-on scrolling and
+simple inertia algorithm for slowing the animated follow-on scrolling and
-*  a bounce-back algorithm for animating the content back to its bounding
+a bounce-back algorithm for animating the content back to its bounding
-*  limits at the end of a drag or flick action.
+limits at the end of a drag or flick action.
 */
 /*!
 Here are the main properties of the class:
 This is the default behavior.
 */
 /*!
-* Constructor
+Constructor
-*
-* \sa HbScrollArea::HbScrollArea
+\sa HbScrollArea::HbScrollArea
 */
 HbScrollArea::HbScrollArea(QGraphicsItem* parent) :
 HbWidget( *new HbScrollAreaPrivate, parent )
 {
 Q_D( HbScrollArea );
 d->q_ptr = this;
 d->init();
 }
 /*!
-* Destructor
+Destructor
-*
-* \sa HbScrollArea::~HbScrollArea
+\sa HbScrollArea::~HbScrollArea
 */
 HbScrollArea::~HbScrollArea()
 {
 Q_D( HbScrollArea );
 if (d && d->mContents) {
 d->mContents->setParentLayoutItem(0);
 }
 }
 /*!
-* Returns a pointer to the QGraphicsWidget,which is the content of scrollable area.
+Returns a pointer to the QGraphicsWidget,which is the content of scrollable area.
-*
-* \sa HbScrollArea::setContentWidget()
+\sa HbScrollArea::setContentWidget()
 */
 QGraphicsWidget* HbScrollArea::contentWidget() const
 {
 Q_D( const HbScrollArea );
 return d->mContents;
 }
 /*!
-* Assigns the QGraphicsWidget that is to be scrolled.  The HbScrollArea widget takes ownership of
+Assigns the QGraphicsWidget that is to be scrolled.  The HbScrollArea widget takes ownership of
-* the QGraphicsWidget.
+the QGraphicsWidget.
-*
-* \sa HbScrollArea::contentWidget()
+\sa HbScrollArea::contentWidget()
 */
 void HbScrollArea::setContentWidget(QGraphicsWidget* contents)
 {
 Q_D( HbScrollArea );
 d->hideChildComponents();
 return content;
 }
 /*!
-* Returns the value of the clampingStyle property
+Returns the value of the clampingStyle property
-*
-* \sa HbScrollArea::setClampingStyle()
+\sa HbScrollArea::setClampingStyle()
 */
 HbScrollArea::ClampingStyle HbScrollArea::clampingStyle() const
 {
 Q_D( const HbScrollArea );
 return d->mClampingStyle;
 }
 /*!
-* Sets the clampingStyle property that controls how the scrolling is constrained
+Sets the clampingStyle property that controls how the scrolling is constrained
-* relative to the contents of the scrolling area.
+relative to the contents of the scrolling area.
-*
-* Possible values for the clamping style include:
+Possible values for the clamping style include:
-*
-*		StrictClamping - scrolling is limited to the bounding rectangle of the content item
+	StrictClamping - scrolling is limited to the bounding rectangle of the content item
-*		BounceBackClamping - scrolling can go beyond the bounding rectangle of the content item, but bounces back to the
+	BounceBackClamping - scrolling can go beyond the bounding rectangle of the content item, but bounces back to the
-*						limits of the bounding rectangle when released or when inertia scrolling stops
+					limits of the bounding rectangle when released or when inertia scrolling stops
-*		NoClamping - scrolling is completely unclamped (this is usually used when the subclass implements its own
+	NoClamping - scrolling is completely unclamped (this is usually used when the subclass implements its own
-*						custom clamping behavior)
+					custom clamping behavior)
-*
-* The default value is BounceBackClamping.
+The default value is BounceBackClamping.
-*
-* \sa HbScrollArea::clampingStyle()
+\sa HbScrollArea::clampingStyle()
 */
 void HbScrollArea::setClampingStyle(ClampingStyle value)
 {
 Q_D( HbScrollArea );
 d->mClampingStyle = value;
 }
 /*!
-* Returns the value of the scrollingStyle property
+Returns the value of the scrollingStyle property
-*
-* \sa HbScrollArea::setScrollingStyle()
+\sa HbScrollArea::setScrollingStyle()
 */
 HbScrollArea::ScrollingStyle HbScrollArea::scrollingStyle() const
 {
 Q_D( const HbScrollArea );
 provided by the widget
 Possible values for the clamping style include:
 		Pan - dragging motion pans the view with no follow-on scrolling animation
 \deprecated PanOrFlick
 is deprecated.
 		PanWithFollowOn - dragging motion pans the view, velocity at end of drag motion triggers follow-on animated scrolling
 The default value is PanWithFollowOn.
 d->mScrollingStyle = value;
 }
 }
 /*!
-* Returns the value of the scrollDirections property.
+Returns the value of the scrollDirections property.
-*
-* \sa HbScrollArea::setScrollDirections()
+\sa HbScrollArea::setScrollDirections()
 */
 Qt::Orientations HbScrollArea::scrollDirections() const
 {
 Q_D( const HbScrollArea );
 return d->mScrollDirections;
 }
 /*!
-* Sets the value of the scrollDirections property.  This value is of
+Sets the value of the scrollDirections property.  This value is of
-* type Qt::Orientations and can set to either Qt::Horizontal to enable horizontal scrolling,
+type Qt::Orientations and can set to either Qt::Horizontal to enable horizontal scrolling,
-* Qt::Vertical to enable vertical scrolling or (Qt::Horizontal | Qt::Vertical) to enable
+Qt::Vertical to enable vertical scrolling or (Qt::Horizontal | Qt::Vertical) to enable
-* scrolling in both directions.
+scrolling in both directions.
-*
-* The default value is Qt::Vertical.
+The default value is Qt::Vertical.
-*
-* \sa HbScrollArea::scrollDirections()
+\sa HbScrollArea::scrollDirections()
 */
 void HbScrollArea::setScrollDirections(Qt::Orientations value)
 {
 Q_D( HbScrollArea );
 emit scrollDirectionsChanged( value );
 }
 }
 /*!
-* Returns true if the inertia scrolling effect is enabled, false otherwise.
+Returns true if the inertia scrolling effect is enabled, false otherwise.
-*
-* \sa HbScrollArea::setFrictionEnabled()
+\sa HbScrollArea::setFrictionEnabled()
 */
 bool HbScrollArea::frictionEnabled() const
 {
 Q_D( const HbScrollArea );
 return d->mFrictionEnabled;
 }
 /*!
-* Enables/disables the inertia scrolling effect.
+Enables/disables the inertia scrolling effect.
-* By default, the inertia effect is enabled.
+By default, the inertia effect is enabled.
-*
-* \sa HbScrollArea::frictionEnabled()
+\sa HbScrollArea::frictionEnabled()
 */
 void HbScrollArea::setFrictionEnabled(bool value)
 {
 Q_D( HbScrollArea );
 HB_DEPRECATED("HbScrollArea::setLongPressEnabled(bool) is deprecated");
 Q_UNUSED(value);
 }
 /*
-* \reimp
+\reimp
 */
 QVariant HbScrollArea::itemChange(GraphicsItemChange change, const QVariant &value)
 {
 Q_D( HbScrollArea );
 {
 Q_UNUSED (event);
 }
 /*!
-* Returns true if a scrolling action is in progress, false otherwise.
+Returns true if a scrolling action is in progress, false otherwise.
 */
 bool HbScrollArea::isScrolling() const
 {
 Q_D( const HbScrollArea );
 return d->mIsScrolling;
 }
 /*!
-* Returns true if the scrolling is due to dragging as opposed to follow-on scrolling
+Returns true if the scrolling is due to dragging as opposed to follow-on scrolling
 */
 bool HbScrollArea::isDragging() const
 {
 Q_D( const HbScrollArea );
 return (d->mIsScrolling && !d->mIsAnimating);
 }
 /*!
-* Scrolls the view by the amount indicated by "delta".
+Scrolls the view by the amount indicated by "delta".
-*
-* The function returns TRUE if the view was able to scroll, FALSE otherwise.
+The function returns TRUE if the view was able to scroll, FALSE otherwise.
-*
-* The function is virtual so subclasses can override it to customize the behavior by, for example,
+The function is virtual so subclasses can override it to customize the behavior by, for example,
-* clamping the position so that at least one item in the view remains visible.
+clamping the position so that at least one item in the view remains visible.
 */
 bool HbScrollArea::scrollByAmount(const QPointF& delta)
 {
 Q_D( HbScrollArea );
 if(event) {
 value = HbWidget::event(event);
 if(event->type() == QEvent::ApplicationLayoutDirectionChange
 || event->type() == QEvent::LayoutDirectionChange) {
 d->changeLayoutDirection(layoutDirection());
-} else if (event->type() == QEvent::GraphicsSceneResize) {
+} else if (event->type() == HbEvent::ChildFocusOut) {
-if (isVisible() && d->mContents) {
-if ( d->mIsAnimating ) {
-d->stopAnimating();
-}
-d->adjustContent();
-}
-}  else if (event->type() == HbEvent::ChildFocusOut) {
 //qDebug() << "focusout";
 if ( !d->positionOutOfBounds() ) {
 d->stopAnimating();
 }
 } else if( event->type() == QEvent::GestureOverride ) {
 QSizeF newSize = d->mContents->size();
 QSizePolicy contentPolicy = d->mContents->sizePolicy();
 if (d->mScrollDirections & Qt::Vertical) {
-if (contentPolicy.verticalPolicy() != QSizePolicy::Ignored) {
+if ((contentPolicy.verticalPolicy() & QSizePolicy::ExpandFlag) &&
+(d->mContents->preferredHeight() < size().height())) {
+newSize.setHeight(size().height());
+} else if (contentPolicy.verticalPolicy() != QSizePolicy::Ignored) {
 newSize.setHeight(d->mContents->preferredHeight());
 }
 } else {
 newSize.setHeight(size().height());
 }
 if (d->mScrollDirections & Qt::Horizontal) {
-if (contentPolicy.horizontalPolicy() != QSizePolicy::Ignored) {
+if ((contentPolicy.horizontalPolicy() & QSizePolicy::ExpandFlag) &&
+(d->mContents->preferredWidth() < size().width())) {
+newSize.setWidth(size().width());
+} else if (contentPolicy.horizontalPolicy() != QSizePolicy::Ignored) {
 newSize.setWidth(d->mContents->preferredWidth());
 }
 } else {
 newSize.setWidth(size().width());
 }
 d->mContents->resize(newSize);
 }
 } else if (event->type() == QEvent::GraphicsSceneResize) {
 if (d->mContents) {
+if ( d->mIsAnimating ) {
+d->stopAnimating();
+}
 QSizeF newSize = d->mContents->size();
+bool sizeChanged = false;
 if (!(d->mScrollDirections & Qt::Vertical)) {
 newSize.setHeight(size().height());
+sizeChanged = true;
 }
 if (!(d->mScrollDirections & Qt::Horizontal)) {
 newSize.setWidth(size().width());
+sizeChanged = true;
 }
+if (sizeChanged) {
 d->mContents->resize(newSize);
+} else {
+d->adjustContent();
+}
 }
 }
 }
 return value;
 }
 }
 }
 /*
-* \reimp
+\reimp
 */
 void HbScrollArea::polish(HbStyleParameters& params)
 {
 Q_D(HbScrollArea);

changeset 2	06ff229162e9
parent 1	f7ac710697a9
child 3	11d3954df52a