From d9f9e69ce1bdd6f898ee21cb2f14607bd90fa07b Mon Sep 17 00:00:00 2001 From: Peter Penz Date: Fri, 30 Sep 2011 23:22:56 +0200 Subject: [PATCH] Implement smooth-scrolling for horizontal and vertical scrollbars Currently only a smoothscrolling was provided into the scroll-direction, but not in case of the details-view where a horizontal scrollbar might be shown too. Some minor adjustments of the private KItemListSmoothScroller interface will be done later... --- src/CMakeLists.txt | 1 + src/kitemviews/kitemlistcontainer.cpp | 261 ++++++++------------- src/kitemviews/kitemlistcontainer.h | 10 +- src/kitemviews/kitemlistsmoothscroller.cpp | 201 ++++++++++++++++ src/kitemviews/kitemlistsmoothscroller_p.h | 103 ++++++++ src/kitemviews/kitemlistview.cpp | 10 + src/kitemviews/kitemlistview.h | 2 + src/views/dolphinview.cpp | 4 +- 8 files changed, 420 insertions(+), 172 deletions(-) create mode 100644 src/kitemviews/kitemlistsmoothscroller.cpp create mode 100644 src/kitemviews/kitemlistsmoothscroller_p.h diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt index 0eedece947..93225c5c85 100644 --- a/src/CMakeLists.txt +++ b/src/CMakeLists.txt @@ -30,6 +30,7 @@ set(dolphinprivate_LIB_SRCS kitemviews/kitemlistrubberband.cpp kitemviews/kitemlistselectionmanager.cpp kitemviews/kitemlistsizehintresolver.cpp + kitemviews/kitemlistsmoothscroller.cpp kitemviews/kitemliststyleoption.cpp kitemviews/kitemlistview.cpp kitemviews/kitemlistviewanimation.cpp diff --git a/src/kitemviews/kitemlistcontainer.cpp b/src/kitemviews/kitemlistcontainer.cpp index 45db700c51..926e13bf27 100644 --- a/src/kitemviews/kitemlistcontainer.cpp +++ b/src/kitemviews/kitemlistcontainer.cpp @@ -23,6 +23,7 @@ #include "kitemlistcontainer.h" #include "kitemlistcontroller.h" +#include "kitemlistsmoothscroller_p.h" #include "kitemlistview.h" #include "kitemmodelbase.h" @@ -35,33 +36,42 @@ #include +/** + * Replaces the default viewport of KItemListContainer by a + * non-scrollable viewport. The scrolling is done in an optimized + * way by KItemListView internally. + */ class KItemListContainerViewport : public QGraphicsView { public: - KItemListContainerViewport(QGraphicsScene* scene, QWidget* parent) - : QGraphicsView(scene, parent) - { - setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff); - setVerticalScrollBarPolicy(Qt::ScrollBarAlwaysOff); - setViewportMargins(0, 0, 0, 0); - setFrameShape(QFrame::NoFrame); - } - - void scrollContentsBy(int dx, int dy) - { - Q_UNUSED(dx); - Q_UNUSED(dy); - // Do nothing. This prevents that e.g. the wheel-event - // results in a moving of the scene items. - } + KItemListContainerViewport(QGraphicsScene* scene, QWidget* parent); +protected: + virtual void wheelEvent(QWheelEvent* event); }; +KItemListContainerViewport::KItemListContainerViewport(QGraphicsScene* scene, QWidget* parent) : + QGraphicsView(scene, parent) +{ + setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff); + setVerticalScrollBarPolicy(Qt::ScrollBarAlwaysOff); + setViewportMargins(0, 0, 0, 0); + setFrameShape(QFrame::NoFrame); +} + +void KItemListContainerViewport::wheelEvent(QWheelEvent* event) +{ + // Assure that the wheel-event gets forwarded to the parent + // and not handled at all by QGraphicsView. + event->ignore(); +} + + + KItemListContainer::KItemListContainer(KItemListController* controller, QWidget* parent) : QAbstractScrollArea(parent), m_controller(controller), - m_scrollBarPressed(false), - m_smoothScrolling(false), - m_smoothScrollingAnimation(0) + m_horizontalSmoothScroller(0), + m_verticalSmoothScroller(0) { Q_ASSERT(controller); controller->setParent(this); @@ -71,9 +81,8 @@ KItemListContainer::KItemListContainer(KItemListController* controller, QWidget* KItemListContainer::KItemListContainer(QWidget* parent) : QAbstractScrollArea(parent), m_controller(0), - m_scrollBarPressed(false), - m_smoothScrolling(false), - m_smoothScrollingAnimation(0) + m_horizontalSmoothScroller(0), + m_verticalSmoothScroller(0) { initialize(); } @@ -115,86 +124,8 @@ void KItemListContainer::resizeEvent(QResizeEvent* event) void KItemListContainer::scrollContentsBy(int dx, int dy) { - KItemListView* view = m_controller->view(); - if (!view) { - return; - } - - const QScrollBar* scrollBar = (view->scrollOrientation() == Qt::Vertical) - ? verticalScrollBar() : horizontalScrollBar(); - const qreal currentOffset = view->scrollOffset(); - if (static_cast(currentOffset) == scrollBar->value()) { - // The current offset is already synchronous to the scrollbar - return; - } - - qreal offsetDiff = (view->scrollOrientation() == Qt::Vertical) ? dy : dx; - - const bool animRunning = (m_smoothScrollingAnimation->state() == QAbstractAnimation::Running); - if (animRunning) { - // Stopping a running animation means skipping the range from the current offset - // until the target offset. To prevent skipping of the range the difference - // is added to the new target offset. - const qreal oldEndOffset = m_smoothScrollingAnimation->endValue().toReal(); - offsetDiff += (currentOffset - oldEndOffset); - } - - const qreal endOffset = currentOffset - offsetDiff; - - if (m_smoothScrolling || animRunning) { - qreal startOffset = currentOffset; - if (animRunning) { - // If the animation was running and has been interrupted by assigning a new end-offset - // one frame must be added to the start-offset to keep the animation smooth. This also - // assures that animation proceeds even in cases where new end-offset are triggered - // within a very short timeslots. - startOffset += (endOffset - currentOffset) * 1000 / (m_smoothScrollingAnimation->duration() * 60); - } - - m_smoothScrollingAnimation->stop(); - m_smoothScrollingAnimation->setStartValue(startOffset); - m_smoothScrollingAnimation->setEndValue(endOffset); - m_smoothScrollingAnimation->setEasingCurve(animRunning ? QEasingCurve::OutQuad : QEasingCurve::InOutQuad); - m_smoothScrollingAnimation->start(); - view->setScrollOffset(startOffset); - } else { - view->setScrollOffset(endOffset); - } -} - -bool KItemListContainer::eventFilter(QObject* obj, QEvent* event) -{ - Q_ASSERT(obj == horizontalScrollBar() || obj == verticalScrollBar()); - - // Check whether the scrollbar has been adjusted by a mouse-event - // triggered by the user and remember this in m_scrollBarPressed. - // The smooth scrolling will only get active if m_scrollBarPressed - // is true (see scrollContentsBy()). - const bool scrollVertical = (m_controller->view()->scrollOrientation() == Qt::Vertical); - const bool checkEvent = ( scrollVertical && obj == verticalScrollBar()) || - (!scrollVertical && obj == horizontalScrollBar()); - if (checkEvent) { - switch (event->type()) { - case QEvent::MouseButtonPress: - m_scrollBarPressed = true; - m_smoothScrolling = true; - break; - - case QEvent::MouseButtonRelease: - m_scrollBarPressed = false; - m_smoothScrolling = false; - break; - - case QEvent::Wheel: - wheelEvent(static_cast(event)); - break; - - default: - break; - } - } - - return QAbstractScrollArea::eventFilter(obj, event); + m_horizontalSmoothScroller->scrollContentsBy(dx); + m_verticalSmoothScroller->scrollContentsBy(dy); } void KItemListContainer::wheelEvent(QWheelEvent* event) @@ -205,28 +136,31 @@ void KItemListContainer::wheelEvent(QWheelEvent* event) } KItemListView* view = m_controller->view(); - - if (!view || event->orientation() != view->scrollOrientation()) { + if (!view) { + event->ignore(); return; } + const bool scrollHorizontally = (event->orientation() == Qt::Horizontal) || + (event->orientation() == Qt::Vertical && !verticalScrollBar()->isVisible()); + KItemListSmoothScroller* smoothScroller = scrollHorizontally ? + m_horizontalSmoothScroller : m_verticalSmoothScroller; + const int numDegrees = event->delta() / 8; const int numSteps = numDegrees / 15; - const bool previous = m_smoothScrolling; - m_smoothScrolling = true; - if (view->scrollOrientation() == Qt::Vertical) { - const int value = verticalScrollBar()->value(); - verticalScrollBar()->setValue(value - numSteps * view->size().height()); - } else { - const int value = horizontalScrollBar()->value(); - horizontalScrollBar()->setValue(value - numSteps * view->size().width()); - } - m_smoothScrolling = previous; + const QScrollBar* scrollBar = smoothScroller->scrollBar(); + smoothScroller->scrollTo(scrollBar->value() - numSteps * scrollBar->pageStep()); event->accept(); } +void KItemListContainer::slotScrollOrientationChanged(Qt::Orientation current, Qt::Orientation previous) +{ + Q_UNUSED(previous); + updateSmoothScrollers(current); +} + void KItemListContainer::slotModelChanged(KItemModelBase* current, KItemModelBase* previous) { Q_UNUSED(current); @@ -238,45 +172,39 @@ void KItemListContainer::slotViewChanged(KItemListView* current, KItemListView* QGraphicsScene* scene = static_cast(viewport())->scene(); if (previous) { scene->removeItem(previous); + disconnect(current, SIGNAL(scrollOrientationChanged(Qt::Orientation,Qt::Orientation)), this, SLOT(slotScrollOrientationChanged(Qt::Orientation,Qt::Orientation))); disconnect(previous, SIGNAL(scrollOffsetChanged(qreal,qreal)), this, SLOT(updateScrollOffsetScrollBar())); disconnect(previous, SIGNAL(maximumScrollOffsetChanged(qreal,qreal)), this, SLOT(updateScrollOffsetScrollBar())); disconnect(previous, SIGNAL(itemOffsetChanged(qreal,qreal)), this, SLOT(updateItemOffsetScrollBar())); disconnect(previous, SIGNAL(maximumItemOffsetChanged(qreal,qreal)), this, SLOT(updateItemOffsetScrollBar())); disconnect(previous, SIGNAL(scrollTo(qreal)), this, SLOT(scrollTo(qreal))); - m_smoothScrollingAnimation->setTargetObject(0); + m_horizontalSmoothScroller->setTargetObject(0); + m_verticalSmoothScroller->setTargetObject(0); } if (current) { scene->addItem(current); + connect(current, SIGNAL(scrollOrientationChanged(Qt::Orientation,Qt::Orientation)), this, SLOT(slotScrollOrientationChanged(Qt::Orientation,Qt::Orientation))); connect(current, SIGNAL(scrollOffsetChanged(qreal,qreal)), this, SLOT(updateScrollOffsetScrollBar())); connect(current, SIGNAL(maximumScrollOffsetChanged(qreal,qreal)), this, SLOT(updateScrollOffsetScrollBar())); connect(current, SIGNAL(itemOffsetChanged(qreal,qreal)), this, SLOT(updateItemOffsetScrollBar())); connect(current, SIGNAL(maximumItemOffsetChanged(qreal,qreal)), this, SLOT(updateItemOffsetScrollBar())); connect(current, SIGNAL(scrollTo(qreal)), this, SLOT(scrollTo(qreal))); - m_smoothScrollingAnimation->setTargetObject(current); + m_horizontalSmoothScroller->setTargetObject(current); + m_verticalSmoothScroller->setTargetObject(current); + updateSmoothScrollers(current->scrollOrientation()); } } -void KItemListContainer::slotAnimationStateChanged(QAbstractAnimation::State newState, - QAbstractAnimation::State oldState) -{ - Q_UNUSED(oldState); - if (newState == QAbstractAnimation::Stopped && m_smoothScrolling && !m_scrollBarPressed) { - m_smoothScrolling = false; - } -} - - void KItemListContainer::scrollTo(qreal offset) { const KItemListView* view = m_controller->view(); - if (!view) { - return; + if (view) { + if (view->scrollOrientation() == Qt::Vertical) { + m_verticalSmoothScroller->scrollTo(offset); + } else { + m_horizontalSmoothScroller->scrollTo(offset); + } } - - m_smoothScrolling = true; - QScrollBar* scrollBar = (view->scrollOrientation() == Qt::Vertical) - ? verticalScrollBar() : horizontalScrollBar(); - scrollBar->setValue(offset); } void KItemListContainer::updateScrollOffsetScrollBar() @@ -286,14 +214,17 @@ void KItemListContainer::updateScrollOffsetScrollBar() return; } + KItemListSmoothScroller* smoothScroller = 0; QScrollBar* scrollOffsetScrollBar = 0; int singleStep = 0; int pageStep = 0; if (view->scrollOrientation() == Qt::Vertical) { + smoothScroller = m_verticalSmoothScroller; scrollOffsetScrollBar = verticalScrollBar(); singleStep = view->itemSize().height(); pageStep = view->size().height(); } else { + smoothScroller = m_horizontalSmoothScroller; scrollOffsetScrollBar = horizontalScrollBar(); singleStep = view->itemSize().width(); pageStep = view->size().width(); @@ -301,25 +232,13 @@ void KItemListContainer::updateScrollOffsetScrollBar() const int value = view->scrollOffset(); const int maximum = qMax(0, int(view->maximumScrollOffset() - pageStep)); - if (m_smoothScrollingAnimation->state() == QAbstractAnimation::Running) { - if (maximum == scrollOffsetScrollBar->maximum()) { - // The value has been changed by the animation, no update - // of the scrollbars is required as their target state will be - // reached with the end of the animation. - return; - } - - // The maximum has been changed which indicates that the content - // of the view has been changed. Stop the animation in any case and - // update the scrollbars immediately. - m_smoothScrollingAnimation->stop(); + if (smoothScroller->requestScrollBarUpdate(maximum)) { + scrollOffsetScrollBar->setSingleStep(singleStep); + scrollOffsetScrollBar->setPageStep(pageStep); + scrollOffsetScrollBar->setMinimum(0); + scrollOffsetScrollBar->setMaximum(maximum); + scrollOffsetScrollBar->setValue(value); } - - scrollOffsetScrollBar->setSingleStep(singleStep); - scrollOffsetScrollBar->setPageStep(pageStep); - scrollOffsetScrollBar->setMinimum(0); - scrollOffsetScrollBar->setMaximum(maximum); - scrollOffsetScrollBar->setValue(value); } void KItemListContainer::updateItemOffsetScrollBar() @@ -329,27 +248,31 @@ void KItemListContainer::updateItemOffsetScrollBar() return; } + KItemListSmoothScroller* smoothScroller = 0; QScrollBar* itemOffsetScrollBar = 0; int singleStep = 0; int pageStep = 0; if (view->scrollOrientation() == Qt::Vertical) { + smoothScroller = m_horizontalSmoothScroller; itemOffsetScrollBar = horizontalScrollBar(); - singleStep = view->itemSize().width() / 10; + singleStep = view->size().width() / 10; pageStep = view->size().width(); } else { + smoothScroller = m_verticalSmoothScroller; itemOffsetScrollBar = verticalScrollBar(); - singleStep = view->itemSize().height() / 10; + singleStep = view->size().height() / 10; pageStep = view->size().height(); } const int value = view->itemOffset(); const int maximum = qMax(0, int(view->maximumItemOffset()) - pageStep); - - itemOffsetScrollBar->setSingleStep(singleStep); - itemOffsetScrollBar->setPageStep(pageStep); - itemOffsetScrollBar->setMinimum(0); - itemOffsetScrollBar->setMaximum(maximum); - itemOffsetScrollBar->setValue(value); + if (smoothScroller->requestScrollBarUpdate(maximum)) { + itemOffsetScrollBar->setSingleStep(singleStep); + itemOffsetScrollBar->setPageStep(pageStep); + itemOffsetScrollBar->setMinimum(0); + itemOffsetScrollBar->setMaximum(maximum); + itemOffsetScrollBar->setValue(value); + } } void KItemListContainer::updateGeometries() @@ -378,6 +301,17 @@ void KItemListContainer::updateGeometries() } } +void KItemListContainer::updateSmoothScrollers(Qt::Orientation orientation) +{ + if (orientation == Qt::Vertical) { + m_verticalSmoothScroller->setPropertyName("scrollOffset"); + m_horizontalSmoothScroller->setPropertyName("itemOffset"); + } else { + m_horizontalSmoothScroller->setPropertyName("scrollOffset"); + m_verticalSmoothScroller->setPropertyName("itemOffset"); + } +} + void KItemListContainer::initialize() { if (!m_controller) { @@ -392,13 +326,8 @@ void KItemListContainer::initialize() QGraphicsView* graphicsView = new KItemListContainerViewport(new QGraphicsScene(this), this); setViewport(graphicsView); - m_smoothScrollingAnimation = new QPropertyAnimation(this, "scrollOffset"); - m_smoothScrollingAnimation->setDuration(300); - connect(m_smoothScrollingAnimation, SIGNAL(stateChanged(QAbstractAnimation::State,QAbstractAnimation::State)), - this, SLOT(slotAnimationStateChanged(QAbstractAnimation::State,QAbstractAnimation::State))); - - horizontalScrollBar()->installEventFilter(this); - verticalScrollBar()->installEventFilter(this); + m_horizontalSmoothScroller = new KItemListSmoothScroller(horizontalScrollBar(), this); + m_verticalSmoothScroller = new KItemListSmoothScroller(verticalScrollBar(), this); } #include "kitemlistcontainer.moc" diff --git a/src/kitemviews/kitemlistcontainer.h b/src/kitemviews/kitemlistcontainer.h index 36ac9753e9..4d6eadbbbd 100644 --- a/src/kitemviews/kitemlistcontainer.h +++ b/src/kitemviews/kitemlistcontainer.h @@ -29,6 +29,7 @@ #include class KItemListController; +class KItemListSmoothScroller; class KItemListView; class KItemModelBase; class QPropertyAnimation; @@ -54,13 +55,12 @@ protected: virtual void showEvent(QShowEvent* event); virtual void resizeEvent(QResizeEvent* event); virtual void scrollContentsBy(int dx, int dy); - virtual bool eventFilter(QObject* obj, QEvent* event); virtual void wheelEvent(QWheelEvent* event); private slots: + void slotScrollOrientationChanged(Qt::Orientation current, Qt::Orientation previous); void slotModelChanged(KItemModelBase* current, KItemModelBase* previous); void slotViewChanged(KItemListView* current, KItemListView* previous); - void slotAnimationStateChanged(QAbstractAnimation::State newState, QAbstractAnimation::State oldState); void scrollTo(qreal offset); void updateScrollOffsetScrollBar(); void updateItemOffsetScrollBar(); @@ -68,13 +68,13 @@ private slots: private: void initialize(); void updateGeometries(); + void updateSmoothScrollers(Qt::Orientation orientation); private: KItemListController* m_controller; - bool m_scrollBarPressed; - bool m_smoothScrolling; - QPropertyAnimation* m_smoothScrollingAnimation; + KItemListSmoothScroller* m_horizontalSmoothScroller; + KItemListSmoothScroller* m_verticalSmoothScroller; }; #endif diff --git a/src/kitemviews/kitemlistsmoothscroller.cpp b/src/kitemviews/kitemlistsmoothscroller.cpp new file mode 100644 index 0000000000..5c1bf3c5a3 --- /dev/null +++ b/src/kitemviews/kitemlistsmoothscroller.cpp @@ -0,0 +1,201 @@ +/*************************************************************************** + * Copyright (C) 2011 by Peter Penz * + * * + * This program is free software; you can redistribute it and/or modify * + * it under the terms of the GNU General Public License as published by * + * the Free Software Foundation; either version 2 of the License, or * + * (at your option) any later version. * + * * + * This program is distributed in the hope that it will be useful, * + * but WITHOUT ANY WARRANTY; without even the implied warranty of * + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * + * GNU General Public License for more details. * + * * + * You should have received a copy of the GNU General Public License * + * along with this program; if not, write to the * + * Free Software Foundation, Inc., * + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA * + ***************************************************************************/ + +#include "kitemlistsmoothscroller_p.h" + +#include +#include +#include +#include + +#include + +KItemListSmoothScroller::KItemListSmoothScroller(QScrollBar* scrollBar, + QObject* parent) : + QObject(parent), + m_scrollBarPressed(false), + m_smoothScrolling(true), + m_scrollBar(scrollBar), + m_animation(0) +{ + m_animation = new QPropertyAnimation(this); + m_animation->setDuration(300); + connect(m_animation, SIGNAL(stateChanged(QAbstractAnimation::State,QAbstractAnimation::State)), + this, SLOT(slotAnimationStateChanged(QAbstractAnimation::State,QAbstractAnimation::State))); + + m_scrollBar->installEventFilter(this); +} + +KItemListSmoothScroller::~KItemListSmoothScroller() +{ +} + +void KItemListSmoothScroller::setScrollBar(QScrollBar *scrollBar) +{ + m_scrollBar = scrollBar; +} + +QScrollBar* KItemListSmoothScroller::scrollBar() const +{ + return m_scrollBar; +} + +void KItemListSmoothScroller::setTargetObject(QObject* target) +{ + m_animation->setTargetObject(target); +} + +QObject* KItemListSmoothScroller::targetObject() const +{ + return m_animation->targetObject(); +} + +void KItemListSmoothScroller::setPropertyName(const QByteArray& propertyName) +{ + m_animation->setPropertyName(propertyName); +} + +QByteArray KItemListSmoothScroller::propertyName() const +{ + return m_animation->propertyName(); +} + +void KItemListSmoothScroller::scrollContentsBy(qreal distance) +{ + QObject* target = targetObject(); + if (!target) { + return; + } + + const QByteArray name = propertyName(); + const qreal currentOffset = target->property(name).toReal(); + if (static_cast(currentOffset) == m_scrollBar->value()) { + // The current offset is already synchronous to the scrollbar + return; + } + + const bool animRunning = (m_animation->state() == QAbstractAnimation::Running); + if (animRunning) { + // Stopping a running animation means skipping the range from the current offset + // until the target offset. To prevent skipping of the range the difference + // is added to the new target offset. + const qreal oldEndOffset = m_animation->endValue().toReal(); + distance += (currentOffset - oldEndOffset); + } + + const qreal endOffset = currentOffset - distance; + + if (m_smoothScrolling || animRunning) { + qreal startOffset = currentOffset; + if (animRunning) { + // If the animation was running and has been interrupted by assigning a new end-offset + // one frame must be added to the start-offset to keep the animation smooth. This also + // assures that animation proceeds even in cases where new end-offset are triggered + // within a very short timeslots. + startOffset += (endOffset - currentOffset) * 1000 / (m_animation->duration() * 60); + } + + m_animation->stop(); + m_animation->setStartValue(startOffset); + m_animation->setEndValue(endOffset); + m_animation->setEasingCurve(animRunning ? QEasingCurve::OutQuad : QEasingCurve::InOutQuad); + m_animation->start(); + target->setProperty(name, startOffset); + } else { + target->setProperty(name, endOffset); + } +} + +void KItemListSmoothScroller::scrollTo(qreal position) +{ + m_smoothScrolling = true; + m_scrollBar->setValue(position); +} + +bool KItemListSmoothScroller::requestScrollBarUpdate(int newMaximum) +{ + if (m_animation->state() == QAbstractAnimation::Running) { + if (newMaximum == m_scrollBar->maximum()) { + // The value has been changed by the animation, no update + // of the scrollbars is required as their target state will be + // reached with the end of the animation. + return false; + } + + // The maximum has been changed which indicates that the content + // of the view has been changed. Stop the animation in any case and + // update the scrollbars immediately. + m_animation->stop(); + } + return true; +} + +bool KItemListSmoothScroller::eventFilter(QObject* obj, QEvent* event) +{ + Q_ASSERT(obj == m_scrollBar); + + switch (event->type()) { + case QEvent::MouseButtonPress: + m_scrollBarPressed = true; + m_smoothScrolling = true; + break; + + case QEvent::MouseButtonRelease: + m_scrollBarPressed = false; + m_smoothScrolling = false; + break; + + case QEvent::Wheel: + handleWheelEvent(static_cast(event)); + break; + + default: + break; + } + + return QObject::eventFilter(obj, event); +} + +void KItemListSmoothScroller::slotAnimationStateChanged(QAbstractAnimation::State newState, + QAbstractAnimation::State oldState) +{ + Q_UNUSED(oldState); + if (newState == QAbstractAnimation::Stopped && m_smoothScrolling && !m_scrollBarPressed) { + m_smoothScrolling = false; + } +} + +void KItemListSmoothScroller::handleWheelEvent(QWheelEvent* event) +{ + const int numDegrees = event->delta() / 8; + const int numSteps = numDegrees / 15; + + const bool previous = m_smoothScrolling; + + m_smoothScrolling = true; + const int value = m_scrollBar->value(); + const int pageStep = m_scrollBar->pageStep(); + m_scrollBar->setValue(value - numSteps * pageStep); + + m_smoothScrolling = previous; + + event->accept(); +} + +#include "kitemlistsmoothscroller_p.moc" diff --git a/src/kitemviews/kitemlistsmoothscroller_p.h b/src/kitemviews/kitemlistsmoothscroller_p.h new file mode 100644 index 0000000000..252c966c7a --- /dev/null +++ b/src/kitemviews/kitemlistsmoothscroller_p.h @@ -0,0 +1,103 @@ +/*************************************************************************** + * Copyright (C) 2011 by Peter Penz * + * * + * This program is free software; you can redistribute it and/or modify * + * it under the terms of the GNU General Public License as published by * + * the Free Software Foundation; either version 2 of the License, or * + * (at your option) any later version. * + * * + * This program is distributed in the hope that it will be useful, * + * but WITHOUT ANY WARRANTY; without even the implied warranty of * + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * + * GNU General Public License for more details. * + * * + * You should have received a copy of the GNU General Public License * + * along with this program; if not, write to the * + * Free Software Foundation, Inc., * + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA * + ***************************************************************************/ + +#ifndef KITEMLISTSMOOTHSCROLLER_H +#define KITEMLISTSMOOTHSCROLLER_H + +#include + +#include +#include + +class QPropertyAnimation; +class QScrollBar; +class QWheelEvent; + +/** + * @brief Helper class for KItemListContainer to have a smooth + * scrolling when adjusting the scrollbars. + */ +class LIBDOLPHINPRIVATE_EXPORT KItemListSmoothScroller : public QObject +{ + Q_OBJECT + +public: + KItemListSmoothScroller(QScrollBar* scrollBar, + QObject* parent = 0); + virtual ~KItemListSmoothScroller(); + + void setScrollBar(QScrollBar* scrollBar); + QScrollBar* scrollBar() const; + + void setTargetObject(QObject* target); + QObject* targetObject() const; + + void setPropertyName(const QByteArray& propertyName); + QByteArray propertyName() const; + + /** + * Adjusts the position of the target by \p distance + * pixels. Is invoked in the context of QAbstractScrollArea::scrollContentsBy() + * where the scrollbars already have the new position but the content + * has not been scrolled yet. + */ + void scrollContentsBy(qreal distance); + + /** + * Does a smooth-scrolling to the position \p position + * on the target and also adjusts the corresponding scrollbar + * to the new position. + */ + void scrollTo(qreal position); + + /** + * Must be invoked before the scrollbar should get updated to have a new + * maximum. True is returned if the new maximum can be applied. If false + * is returned the maximum has already been reached and the value will + * be reached at the end of the animation. + */ + // TODO: This interface is tricky to understand. Try to make this more + // generic/readable if the corresponding code in KItemListContainer got + // stable. + bool requestScrollBarUpdate(int newMaximum); + +protected: + virtual bool eventFilter(QObject* obj, QEvent* event); + +private slots: + void slotAnimationStateChanged(QAbstractAnimation::State newState, + QAbstractAnimation::State oldState); + +private: + /** + * Results into a smooth-scrolling of the target dependent on the direction + * of the wheel event. + */ + void handleWheelEvent(QWheelEvent* event); + +private: + bool m_scrollBarPressed; + bool m_smoothScrolling; + QScrollBar* m_scrollBar; + QPropertyAnimation* m_animation; +}; + +#endif + + diff --git a/src/kitemviews/kitemlistview.cpp b/src/kitemviews/kitemlistview.cpp index 63315b6658..f9c2fca181 100644 --- a/src/kitemviews/kitemlistview.cpp +++ b/src/kitemviews/kitemlistview.cpp @@ -119,7 +119,9 @@ void KItemListView::setScrollOrientation(Qt::Orientation orientation) m_animation->setScrollOrientation(orientation); m_sizeHintResolver->clearCache(); updateLayout(); + onScrollOrientationChanged(orientation, previousOrientation); + emit scrollOrientationChanged(orientation, previousOrientation); } Qt::Orientation KItemListView::scrollOrientation() const @@ -189,6 +191,13 @@ qreal KItemListView::maximumScrollOffset() const void KItemListView::setItemOffset(qreal offset) { m_layouter->setItemOffset(offset); + if (m_header) { + m_header->setPos(-offset, 0); + } + if (!m_layoutTimer->isActive()) { + doLayout(NoAnimation, 0, 0); + update(); + } } qreal KItemListView::itemOffset() const @@ -1505,6 +1514,7 @@ void KItemListView::updateStretchedVisibleRolesSizes() if (m_header) { m_header->setVisibleRolesWidths(headerRolesWidths()); + m_header->resize(dynamicItemSize.width(), m_header->size().height()); } // Update the role sizes for all visible widgets diff --git a/src/kitemviews/kitemlistview.h b/src/kitemviews/kitemlistview.h index e49dbe48d6..3ddfabde66 100644 --- a/src/kitemviews/kitemlistview.h +++ b/src/kitemviews/kitemlistview.h @@ -66,6 +66,7 @@ class LIBDOLPHINPRIVATE_EXPORT KItemListView : public QGraphicsWidget Q_OBJECT Q_PROPERTY(qreal scrollOffset READ scrollOffset WRITE setScrollOffset) + Q_PROPERTY(qreal itemOffset READ itemOffset WRITE setItemOffset) public: KItemListView(QGraphicsWidget* parent = 0); @@ -199,6 +200,7 @@ public: virtual void paint(QPainter* painter, const QStyleOptionGraphicsItem* option, QWidget* widget = 0); signals: + void scrollOrientationChanged(Qt::Orientation current, Qt::Orientation previous); void scrollOffsetChanged(qreal current, qreal previous); void maximumScrollOffsetChanged(qreal current, qreal previous); void itemOffsetChanged(qreal current, qreal previous); diff --git a/src/views/dolphinview.cpp b/src/views/dolphinview.cpp index fe45541e35..a82008d259 100644 --- a/src/views/dolphinview.cpp +++ b/src/views/dolphinview.cpp @@ -719,8 +719,10 @@ void DolphinView::wheelEvent(QWheelEvent* event) const int numSteps = numDegrees / 15; setZoomLevel(zoomLevel() + numSteps); + event->accept(); + } else { + event->ignore(); } - event->accept(); } void DolphinView::activate()