X-Git-Url: https://cloud.milkyroute.net/gitweb/dolphin.git/blobdiff_plain/d99d5fbea76a79346761c0d8ce98a0719e5790d2..9281664e5b1e492087604264b145b390e8880e81:/src/kitemviews/kitemlistcontainer.cpp diff --git a/src/kitemviews/kitemlistcontainer.cpp b/src/kitemviews/kitemlistcontainer.cpp index 0d2637da6..3ec56e5f1 100644 --- a/src/kitemviews/kitemlistcontainer.cpp +++ b/src/kitemviews/kitemlistcontainer.cpp @@ -1,93 +1,133 @@ -/*************************************************************************** - * Copyright (C) 2011 by Peter Penz * - * * - * Based on the Itemviews NG project from Trolltech Labs: * - * http://qt.gitorious.org/qt-labs/itemviews-ng * - * * - * 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 * - ***************************************************************************/ +/* + * SPDX-FileCopyrightText: 2011 Peter Penz + * + * Based on the Itemviews NG project from Trolltech Labs + * + * SPDX-License-Identifier: GPL-2.0-or-later + */ #include "kitemlistcontainer.h" #include "kitemlistcontroller.h" #include "kitemlistview.h" -#include "kitemmodelbase.h" +#include "private/kitemlistsmoothscroller.h" +#ifndef QT_NO_ACCESSIBILITY +#include "accessibility/kitemlistviewaccessible.h" +#endif #include +#include #include #include -#include #include -#include - -#include - +#include +#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 { + Q_OBJECT + public: - KItemListContainerViewport(QGraphicsScene* scene, QWidget* parent) - : QGraphicsView(scene, parent) - { - setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff); - setVerticalScrollBarPolicy(Qt::ScrollBarAlwaysOff); - setViewportMargins(0, 0, 0, 0); - setFrameShape(QFrame::NoFrame); - } + KItemListContainerViewport(QGraphicsScene *scene, QWidget *parent); - 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. - } +protected: + void wheelEvent(QWheelEvent *event) override; }; -KItemListContainer::KItemListContainer(KItemListController* controller, QWidget* parent) : - QAbstractScrollArea(parent), - m_controller(controller), - m_scrollBarPressed(false), - m_smoothScrolling(false), - m_smoothScrollingAnimation(0) +KItemListContainerViewport::KItemListContainerViewport(QGraphicsScene *scene, QWidget *parent) + : QGraphicsView(scene, parent) { - Q_ASSERT(controller); - controller->setParent(this); - initialize(); + 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(QWidget* parent) : - QAbstractScrollArea(parent), - m_controller(0), - m_scrollBarPressed(false), - m_smoothScrolling(false), - m_smoothScrollingAnimation(0) +KItemListContainer::KItemListContainer(KItemListController *controller, QWidget *parent) + : QAbstractScrollArea(parent) + , m_controller(controller) + , m_horizontalSmoothScroller(nullptr) + , m_verticalSmoothScroller(nullptr) + , m_scroller(nullptr) { - initialize(); + Q_ASSERT(controller); + controller->setParent(this); + + QGraphicsView *graphicsView = new KItemListContainerViewport(new QGraphicsScene(this), this); + setViewport(graphicsView); + + m_horizontalSmoothScroller = new KItemListSmoothScroller(horizontalScrollBar(), this); + m_verticalSmoothScroller = new KItemListSmoothScroller(verticalScrollBar(), this); + + if (controller->model()) { + slotModelChanged(controller->model(), nullptr); + } + if (controller->view()) { + slotViewChanged(controller->view(), nullptr); + } + + connect(controller, &KItemListController::modelChanged, this, &KItemListContainer::slotModelChanged); + connect(controller, &KItemListController::viewChanged, this, &KItemListContainer::slotViewChanged); + + m_scroller = QScroller::scroller(viewport()); + m_scroller->grabGesture(viewport()); + connect(controller, &KItemListController::scrollerStop, this, &KItemListContainer::stopScroller); + connect(m_scroller, &QScroller::stateChanged, controller, &KItemListController::slotStateChanged); } KItemListContainer::~KItemListContainer() { + // Don't rely on the QObject-order to delete the controller, otherwise + // the QGraphicsScene might get deleted before the view. + delete m_controller; + m_controller = nullptr; } -KItemListController* KItemListContainer::controller() const +KItemListController *KItemListContainer::controller() const { return m_controller; } -void KItemListContainer::keyPressEvent(QKeyEvent* event) +void KItemListContainer::setEnabledFrame(bool enable) +{ + QGraphicsView *graphicsView = qobject_cast(viewport()); + if (enable) { + setFrameShape(QFrame::StyledPanel); + graphicsView->setPalette(palette()); + graphicsView->viewport()->setAutoFillBackground(true); + } else { + setFrameShape(QFrame::NoFrame); + // Make the background of the container transparent and apply the window-text color + // to the text color, so that enough contrast is given for all color + // schemes + QPalette p = graphicsView->palette(); + p.setColor(QPalette::Active, QPalette::Text, p.color(QPalette::Active, QPalette::WindowText)); + p.setColor(QPalette::Inactive, QPalette::Text, p.color(QPalette::Inactive, QPalette::WindowText)); + p.setColor(QPalette::Disabled, QPalette::Text, p.color(QPalette::Disabled, QPalette::WindowText)); + graphicsView->setPalette(p); + graphicsView->viewport()->setAutoFillBackground(false); + } +} + +bool KItemListContainer::enabledFrame() const +{ + const QGraphicsView *graphicsView = qobject_cast(viewport()); + return graphicsView->autoFillBackground(); +} + +void KItemListContainer::keyPressEvent(QKeyEvent *event) { // TODO: We should find a better way to handle the key press events in the view. // The reasons why we need this hack are: @@ -95,19 +135,34 @@ void KItemListContainer::keyPressEvent(QKeyEvent* event) // 2. By default, the KItemListView does not have the keyboard focus in the QGraphicsScene, so // simply sending the event to the QGraphicsView which is the KItemListContainer's viewport // does not work. - KItemListView* view = m_controller->view(); + KItemListView *view = m_controller->view(); + if (view) { + QApplication::sendEvent(view, event); + } +} + +void KItemListContainer::contextMenuEvent(QContextMenuEvent *event) +{ + // Note copied from the keyPressEvent() method above because the same reasons probably also apply here. + // TODO: We should find a better way to handle the context menu events in the view. + // The reasons why we need this hack are: + // 1. Without reimplementing contextMenuEvent() here, the event would not reach the QGraphicsView. + // 2. By default, the KItemListView does not have the keyboard focus in the QGraphicsScene, so + // simply sending the event to the QGraphicsView which is the KItemListContainer's viewport + // does not work. + KItemListView *view = m_controller->view(); if (view) { QApplication::sendEvent(view, event); } } -void KItemListContainer::showEvent(QShowEvent* event) +void KItemListContainer::showEvent(QShowEvent *event) { QAbstractScrollArea::showEvent(event); updateGeometries(); } -void KItemListContainer::resizeEvent(QResizeEvent* event) +void KItemListContainer::resizeEvent(QResizeEvent *event) { QAbstractScrollArea::resizeEvent(event); updateGeometries(); @@ -115,255 +170,284 @@ void KItemListContainer::resizeEvent(QResizeEvent* event) void KItemListContainer::scrollContentsBy(int dx, int dy) { - KItemListView* view = m_controller->view(); - if (!view) { + m_horizontalSmoothScroller->scrollContentsBy(dx); + m_verticalSmoothScroller->scrollContentsBy(dy); +} + +void KItemListContainer::wheelEvent(QWheelEvent *event) +{ + if (event->modifiers().testFlag(Qt::ControlModifier)) { + event->ignore(); return; } - const QScrollBar* scrollBar = (view->scrollOrientation() == Qt::Vertical) - ? verticalScrollBar() : horizontalScrollBar(); - const qreal currentOffset = view->offset(); - if (static_cast(currentOffset) == scrollBar->value()) { - // The current offset is already synchronous to the scrollbar + KItemListView *view = m_controller->view(); + if (!view) { + event->ignore(); return; } - qreal offsetDiff = (view->scrollOrientation() == Qt::Vertical) ? dy : dx; + const bool scrollHorizontally = (qAbs(event->angleDelta().y()) < qAbs(event->angleDelta().x())) || (!verticalScrollBar()->isVisible()); + KItemListSmoothScroller *smoothScroller = scrollHorizontally ? m_horizontalSmoothScroller : m_verticalSmoothScroller; - 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; + smoothScroller->handleWheelEvent(event); +} - 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); - } +void KItemListContainer::focusInEvent(QFocusEvent *event) +{ + KItemListView *view = m_controller->view(); + if (view) { + QApplication::sendEvent(view, event); - m_smoothScrollingAnimation->stop(); - m_smoothScrollingAnimation->setStartValue(startOffset); - m_smoothScrollingAnimation->setEndValue(endOffset); - m_smoothScrollingAnimation->setEasingCurve(animRunning ? QEasingCurve::OutQuad : QEasingCurve::InOutQuad); - m_smoothScrollingAnimation->start(); - view->setOffset(startOffset); - } else { - view->setOffset(endOffset); + // We need to set the focus to the view or accessibility software will only announce the container (which has no information available itself). + // For some reason actively setting the focus to the view needs to be delayed or the focus will immediately go back to this container. + QTimer::singleShot(0, this, [this, view]() { + if (!isAncestorOf(QApplication::focusWidget())) { + view->setFocus(); + } +#ifndef QT_NO_ACCESSIBILITY + static_cast(QAccessible::queryAccessibleInterface(view))->setAccessibleFocusAndAnnounceAll(); +#endif + }); } } -bool KItemListContainer::eventFilter(QObject* obj, QEvent* event) +void KItemListContainer::focusOutEvent(QFocusEvent *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; - } + KItemListView *view = m_controller->view(); + if (view) { + QApplication::sendEvent(view, event); } - - return QAbstractScrollArea::eventFilter(obj, event); } -void KItemListContainer::wheelEvent(QWheelEvent* event) +void KItemListContainer::slotScrollOrientationChanged(Qt::Orientation current, Qt::Orientation previous) { - KItemListView* view = m_controller->view(); - if (!view || event->orientation() != view->scrollOrientation()) { - return; - } - - 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; - - event->accept(); + Q_UNUSED(previous) + updateSmoothScrollers(current); } -void KItemListContainer::slotModelChanged(KItemModelBase* current, KItemModelBase* previous) +void KItemListContainer::slotModelChanged(KItemModelBase *current, KItemModelBase *previous) { - Q_UNUSED(current); - Q_UNUSED(previous); + Q_UNUSED(current) + Q_UNUSED(previous) } -void KItemListContainer::slotViewChanged(KItemListView* current, KItemListView* previous) +void KItemListContainer::slotViewChanged(KItemListView *current, KItemListView *previous) { - QGraphicsScene* scene = static_cast(viewport())->scene(); + QGraphicsScene *scene = static_cast(viewport())->scene(); if (previous) { scene->removeItem(previous); - disconnect(previous, SIGNAL(offsetChanged(qreal,qreal)), this, SLOT(updateScrollBars())); - disconnect(previous, SIGNAL(maximumOffsetChanged(qreal,qreal)), this, SLOT(updateScrollBars())); - disconnect(previous, SIGNAL(scrollTo(qreal)), this, SLOT(scrollTo(qreal))); - m_smoothScrollingAnimation->setTargetObject(0); + disconnect(previous, &KItemListView::scrollOrientationChanged, this, &KItemListContainer::slotScrollOrientationChanged); + disconnect(previous, &KItemListView::scrollOffsetChanged, this, &KItemListContainer::updateScrollOffsetScrollBar); + disconnect(previous, &KItemListView::maximumScrollOffsetChanged, this, &KItemListContainer::updateScrollOffsetScrollBar); + disconnect(previous, &KItemListView::itemOffsetChanged, this, &KItemListContainer::updateItemOffsetScrollBar); + disconnect(previous, &KItemListView::maximumItemOffsetChanged, this, &KItemListContainer::updateItemOffsetScrollBar); + disconnect(previous, &KItemListView::scrollTo, this, &KItemListContainer::scrollTo); + disconnect(m_horizontalSmoothScroller, &KItemListSmoothScroller::scrollingStopped, previous, &KItemListView::scrollingStopped); + disconnect(m_verticalSmoothScroller, &KItemListSmoothScroller::scrollingStopped, previous, &KItemListView::scrollingStopped); + m_horizontalSmoothScroller->setTargetObject(nullptr); + m_verticalSmoothScroller->setTargetObject(nullptr); } if (current) { scene->addItem(current); - connect(current, SIGNAL(offsetChanged(qreal,qreal)), this, SLOT(updateScrollBars())); - connect(current, SIGNAL(maximumOffsetChanged(qreal,qreal)), this, SLOT(updateScrollBars())); - connect(current, SIGNAL(scrollTo(qreal)), this, SLOT(scrollTo(qreal))); - m_smoothScrollingAnimation->setTargetObject(current); + connect(current, &KItemListView::scrollOrientationChanged, this, &KItemListContainer::slotScrollOrientationChanged); + connect(current, &KItemListView::scrollOffsetChanged, this, &KItemListContainer::updateScrollOffsetScrollBar); + connect(current, &KItemListView::maximumScrollOffsetChanged, this, &KItemListContainer::updateScrollOffsetScrollBar); + connect(current, &KItemListView::itemOffsetChanged, this, &KItemListContainer::updateItemOffsetScrollBar); + connect(current, &KItemListView::maximumItemOffsetChanged, this, &KItemListContainer::updateItemOffsetScrollBar); + connect(current, &KItemListView::scrollTo, this, &KItemListContainer::scrollTo); + connect(m_horizontalSmoothScroller, &KItemListSmoothScroller::scrollingStopped, current, &KItemListView::scrollingStopped); + connect(m_verticalSmoothScroller, &KItemListSmoothScroller::scrollingStopped, current, &KItemListView::scrollingStopped); + + m_horizontalSmoothScroller->setTargetObject(current); + m_verticalSmoothScroller->setTargetObject(current); + updateSmoothScrollers(current->scrollOrientation()); } } -void KItemListContainer::slotAnimationStateChanged(QAbstractAnimation::State newState, - QAbstractAnimation::State oldState) +void KItemListContainer::scrollTo(qreal offset) { - Q_UNUSED(oldState); - if (newState == QAbstractAnimation::Stopped && m_smoothScrolling && !m_scrollBarPressed) { - m_smoothScrolling = false; + const KItemListView *view = m_controller->view(); + if (view) { + if (view->scrollOrientation() == Qt::Vertical) { + m_verticalSmoothScroller->scrollTo(offset); + } else { + m_horizontalSmoothScroller->scrollTo(offset); + } } } - -void KItemListContainer::scrollTo(qreal offset) +void KItemListContainer::updateScrollOffsetScrollBar() { - const KItemListView* view = m_controller->view(); + const KItemListView *view = m_controller->view(); if (!view) { return; } - m_smoothScrolling = true; - QScrollBar* scrollBar = (view->scrollOrientation() == Qt::Vertical) - ? verticalScrollBar() : horizontalScrollBar(); - scrollBar->setValue(offset); + KItemListSmoothScroller *smoothScroller = nullptr; + QScrollBar *scrollOffsetScrollBar = nullptr; + int pageStep = 0; + int maximum = 0; + if (view->scrollOrientation() == Qt::Vertical) { + smoothScroller = m_verticalSmoothScroller; + if (smoothScroller->isAnimating()) { + return; + } + scrollOffsetScrollBar = verticalScrollBar(); + + // We cannot use view->size().height() because this height might + // include the header widget, which is not part of the scrolled area. + pageStep = view->verticalPageStep(); + + // However, the total height of the view must be considered for the + // maximum value of the scroll bar. Note that the view's scrollOffset() + // refers to the offset of the top part of the view, which might be + // hidden behind the header. + maximum = qMax(0, int(view->maximumScrollOffset() - view->size().height())); + } else { + smoothScroller = m_horizontalSmoothScroller; + if (smoothScroller->isAnimating()) { + return; + } + scrollOffsetScrollBar = horizontalScrollBar(); + pageStep = view->size().width(); + maximum = qMax(0, int(view->maximumScrollOffset() - view->size().width())); + } + + const int singleStep = view->scrollSingleStep(); + const int value = view->scrollOffset(); + if (smoothScroller->requestScrollBarUpdate(maximum)) { + const bool updatePolicy = (scrollOffsetScrollBar->maximum() > 0 && maximum == 0) || horizontalScrollBarPolicy() == Qt::ScrollBarAlwaysOn; + + scrollOffsetScrollBar->setSingleStep(singleStep); + scrollOffsetScrollBar->setPageStep(pageStep); + scrollOffsetScrollBar->setMinimum(0); + scrollOffsetScrollBar->setMaximum(maximum); + scrollOffsetScrollBar->setValue(value); + + if (updatePolicy) { + // Prevent a potential endless layout loop (see bug #293318). + updateScrollOffsetScrollBarPolicy(); + } + } } -void KItemListContainer::updateScrollBars() +void KItemListContainer::updateItemOffsetScrollBar() { - const KItemListView* view = m_controller->view(); + const KItemListView *view = m_controller->view(); if (!view) { return; } - QScrollBar* scrollBar = 0; + KItemListSmoothScroller *smoothScroller = nullptr; + QScrollBar *itemOffsetScrollBar = nullptr; int singleStep = 0; int pageStep = 0; - QScrollBar* otherScrollBar = 0; if (view->scrollOrientation() == Qt::Vertical) { - scrollBar = verticalScrollBar(); - singleStep = view->itemSize().height(); - pageStep = view->size().height(); - otherScrollBar = horizontalScrollBar(); - } else { - scrollBar = horizontalScrollBar(); - singleStep = view->itemSize().width(); + smoothScroller = m_horizontalSmoothScroller; + if (smoothScroller->isAnimating()) { + return; + } + itemOffsetScrollBar = horizontalScrollBar(); + singleStep = view->size().width() / 10; pageStep = view->size().width(); - otherScrollBar = verticalScrollBar(); - } - - const int value = view->offset(); - const int maximum = qMax(0, int(view->maximumOffset() - pageStep)); - if (m_smoothScrollingAnimation->state() == QAbstractAnimation::Running) { - if (maximum == 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. + } else { + smoothScroller = m_verticalSmoothScroller; + if (smoothScroller->isAnimating()) { 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(); + itemOffsetScrollBar = verticalScrollBar(); + singleStep = view->size().height() / 10; + pageStep = view->size().height(); } - scrollBar->setSingleStep(singleStep); - scrollBar->setPageStep(pageStep); - scrollBar->setMinimum(0); - scrollBar->setMaximum(maximum); - scrollBar->setValue(value); + const int value = view->itemOffset(); + const int maximum = qMax(0, int(view->maximumItemOffset()) - pageStep); + if (smoothScroller->requestScrollBarUpdate(maximum)) { + itemOffsetScrollBar->setSingleStep(singleStep); + itemOffsetScrollBar->setPageStep(pageStep); + itemOffsetScrollBar->setMinimum(0); + itemOffsetScrollBar->setMaximum(maximum); + itemOffsetScrollBar->setValue(value); + } +} - // Make sure that the other scroll bar is hidden - otherScrollBar->setMaximum(0); - otherScrollBar->setValue(0); +void KItemListContainer::stopScroller() +{ + m_scroller->stop(); } void KItemListContainer::updateGeometries() { QRect rect = geometry(); - int widthDec = frameWidth() * 2; - if (verticalScrollBar()->isVisible()) { - widthDec += style()->pixelMetric(QStyle::PM_ScrollBarExtent); + int extra = frameWidth() * 2; + QStyleOption option; + option.initFrom(this); + int scrollbarSpacing = 0; + if (style()->styleHint(QStyle::SH_ScrollView_FrameOnlyAroundContents, &option, this)) { + scrollbarSpacing = style()->pixelMetric(QStyle::PM_ScrollView_ScrollBarSpacing, &option, this); } - int heightDec = frameWidth() * 2; - if (horizontalScrollBar()->isVisible()) { - heightDec += style()->pixelMetric(QStyle::PM_ScrollBarExtent); - } + const int widthDec = verticalScrollBar()->isVisible() ? extra + scrollbarSpacing + style()->pixelMetric(QStyle::PM_ScrollBarExtent, &option, this) : extra; - rect.adjust(0, 0, -widthDec, -heightDec); + const int heightDec = + horizontalScrollBar()->isVisible() ? extra + scrollbarSpacing + style()->pixelMetric(QStyle::PM_ScrollBarExtent, &option, this) : extra; - m_controller->view()->setGeometry(QRect(0, 0, rect.width(), rect.height())); + const QRectF newGeometry(0, 0, rect.width() - widthDec, rect.height() - heightDec); + if (m_controller->view()->geometry() != newGeometry) { + m_controller->view()->setGeometry(newGeometry); - static_cast(viewport())->scene()->setSceneRect(0, 0, rect.width(), rect.height()); - static_cast(viewport())->viewport()->setGeometry(QRect(0, 0, rect.width(), rect.height())); + // Get the real geometry of the view again since the scrollbars + // visibilities and the view geometry may have changed in re-layout. + static_cast(viewport())->scene()->setSceneRect(m_controller->view()->geometry()); + static_cast(viewport())->viewport()->setGeometry(m_controller->view()->geometry().toRect()); - updateScrollBars(); + updateScrollOffsetScrollBar(); + updateItemOffsetScrollBar(); + } } -void KItemListContainer::initialize() +void KItemListContainer::updateSmoothScrollers(Qt::Orientation orientation) { - if (!m_controller) { - m_controller = new KItemListController(this); + if (orientation == Qt::Vertical) { + m_verticalSmoothScroller->setPropertyName("scrollOffset"); + m_horizontalSmoothScroller->setPropertyName("itemOffset"); + } else { + m_horizontalSmoothScroller->setPropertyName("scrollOffset"); + m_verticalSmoothScroller->setPropertyName("itemOffset"); } - connect(m_controller, SIGNAL(modelChanged(KItemModelBase*,KItemModelBase*)), - this, SLOT(slotModelChanged(KItemModelBase*,KItemModelBase*))); - connect(m_controller, SIGNAL(viewChanged(KItemListView*,KItemListView*)), - this, SLOT(slotViewChanged(KItemListView*,KItemListView*))); + const bool isRightToLeft = m_controller->view()->layoutDirection() == Qt::RightToLeft; + QScrollBar *hScrollBar = horizontalScrollBar(); + hScrollBar->setInvertedAppearance(isRightToLeft && orientation == Qt::Vertical); + hScrollBar->setInvertedControls(!isRightToLeft || orientation == Qt::Vertical); +} - QGraphicsView* graphicsView = new KItemListContainerViewport(new QGraphicsScene(this), this); - setViewport(graphicsView); +void KItemListContainer::updateScrollOffsetScrollBarPolicy() +{ + const KItemListView *view = m_controller->view(); + Q_ASSERT(view); + const bool vertical = (view->scrollOrientation() == Qt::Vertical); + + QStyleOption option; + option.initFrom(this); + const int scrollBarInc = style()->pixelMetric(QStyle::PM_ScrollBarExtent, &option, this); - m_smoothScrollingAnimation = new QPropertyAnimation(this, "offset"); - m_smoothScrollingAnimation->setDuration(300); - connect(m_smoothScrollingAnimation, SIGNAL(stateChanged(QAbstractAnimation::State,QAbstractAnimation::State)), - this, SLOT(slotAnimationStateChanged(QAbstractAnimation::State,QAbstractAnimation::State))); + QSizeF newViewSize = m_controller->view()->size(); + if (vertical) { + newViewSize.rwidth() += scrollBarInc; + } else { + newViewSize.rheight() += scrollBarInc; + } - horizontalScrollBar()->installEventFilter(this); - verticalScrollBar()->installEventFilter(this); + const Qt::ScrollBarPolicy policy = view->scrollBarRequired(newViewSize) ? Qt::ScrollBarAlwaysOn : Qt::ScrollBarAsNeeded; + if (vertical) { + setVerticalScrollBarPolicy(policy); + } else { + setHorizontalScrollBarPolicy(policy); + } } #include "kitemlistcontainer.moc" +#include "moc_kitemlistcontainer.cpp"