src/kitemviews/kitemlistcontainer.cpp

   1 /***************************************************************************
   2  *   Copyright (C) 2011 by Peter Penz <peter.penz19@gmail.com>             *
   3  *                                                                         *
   4  *   Based on the Itemviews NG project from Trolltech Labs:                *
   5  *   http://qt.gitorious.org/qt-labs/itemviews-ng                          *
   6  *                                                                         *
   7  *   This program is free software; you can redistribute it and/or modify  *
   8  *   it under the terms of the GNU General Public License as published by  *
   9  *   the Free Software Foundation; either version 2 of the License, or     *
  10  *   (at your option) any later version.                                   *
  11  *                                                                         *
  12  *   This program is distributed in the hope that it will be useful,       *
  13  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
  14  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
  15  *   GNU General Public License for more details.                          *
  16  *                                                                         *
  17  *   You should have received a copy of the GNU General Public License     *
  18  *   along with this program; if not, write to the                         *
  19  *   Free Software Foundation, Inc.,                                       *
  20  *   51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA            *
  21  ***************************************************************************/
  22
  23 #include "kitemlistcontainer.h"
  24
  25 #include "kitemlistcontroller.h"
  26 #include "kitemlistselectionmanager.h"
  27 #include "kitemlistview.h"
  28 #include "kitemmodelbase.h"
  29
  30 #include "private/kitemlistsmoothscroller.h"
  31
  32 #include <QApplication>
  33 #include <QGraphicsScene>
  34 #include <QGraphicsView>
  35 #include <QPropertyAnimation>
  36 #include <QScrollBar>
  37 #include <QStyle>
  38 #include <QStyleOption>
  39
  40 #include <KDebug>
  41
  42 #include "kitemlistviewaccessible.h"
  43
  44 /**
  45  * Replaces the default viewport of KItemListContainer by a
  46  * non-scrollable viewport. The scrolling is done in an optimized
  47  * way by KItemListView internally.
  48  */
  49 class KItemListContainerViewport : public QGraphicsView
  50 {
  51 public:
  52     KItemListContainerViewport(QGraphicsScene* scene, QWidget* parent);
  53 protected:
  54     virtual void wheelEvent(QWheelEvent* event);
  55 };
  56
  57 KItemListContainerViewport::KItemListContainerViewport(QGraphicsScene* scene, QWidget* parent) :
  58     QGraphicsView(scene, parent)
  59 {
  60     setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
  61     setVerticalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
  62     setViewportMargins(0, 0, 0, 0);
  63     setFrameShape(QFrame::NoFrame);
  64 }
  65
  66 void KItemListContainerViewport::wheelEvent(QWheelEvent* event)
  67 {
  68     // Assure that the wheel-event gets forwarded to the parent
  69     // and not handled at all by QGraphicsView.
  70     event->ignore();
  71 }
  72
  73 QAccessibleInterface* accessibleContainerFactory(const QString &key, QObject *object)
  74 {
  75     Q_UNUSED(key)
  76     if (KItemListContainer*view = qobject_cast<KItemListContainer*>(object))
  77         return new KItemListContainerAccessible(view);
  78     if (KItemListView *view = qobject_cast<KItemListView*>(object))
  79         return new KItemListViewAccessible(view);
  80     return 0;
  81 }
  82
  83 KItemListContainer::KItemListContainer(KItemListController* controller, QWidget* parent) :
  84     QAbstractScrollArea(parent),
  85     m_controller(controller),
  86     m_horizontalSmoothScroller(0),
  87     m_verticalSmoothScroller(0)
  88 {
  89     Q_ASSERT(controller);
  90     controller->setParent(this);
  91
  92     QGraphicsView* graphicsView = new KItemListContainerViewport(new QGraphicsScene(this), this);
  93     setViewport(graphicsView);
  94
  95     m_horizontalSmoothScroller = new KItemListSmoothScroller(horizontalScrollBar(), this);
  96     m_verticalSmoothScroller = new KItemListSmoothScroller(verticalScrollBar(), this);
  97
  98     if (controller->model()) {
  99         slotModelChanged(controller->model(), 0);
 100     }
 101     if (controller->view()) {
 102         slotViewChanged(controller->view(), 0);
 103     }
 104
 105     connect(controller, SIGNAL(modelChanged(KItemModelBase*,KItemModelBase*)),
 106             this, SLOT(slotModelChanged(KItemModelBase*,KItemModelBase*)));
 107     connect(controller, SIGNAL(viewChanged(KItemListView*,KItemListView*)),
 108             this, SLOT(slotViewChanged(KItemListView*,KItemListView*)));
 109
 110     QAccessible::installFactory(accessibleContainerFactory);
 111 }
 112
 113 KItemListContainer::~KItemListContainer()
 114 {
 115     // Don't rely on the QObject-order to delete the controller, otherwise
 116     // the QGraphicsScene might get deleted before the view.
 117     delete m_controller;
 118     m_controller = 0;
 119
 120     QAccessible::removeFactory(accessibleContainerFactory);
 121 }
 122
 123 KItemListController* KItemListContainer::controller() const
 124 {
 125     return m_controller;
 126 }
 127
 128 void KItemListContainer::setEnabledFrame(bool enable)
 129 {
 130     QGraphicsView* graphicsView = qobject_cast<QGraphicsView*>(viewport());
 131     if (enable) {
 132         setFrameShape(QFrame::StyledPanel);
 133         graphicsView->setPalette(palette());
 134         graphicsView->viewport()->setAutoFillBackground(true);
 135     } else {
 136         setFrameShape(QFrame::NoFrame);
 137         // Make the background of the container transparent and apply the window-text color
 138         // to the text color, so that enough contrast is given for all color
 139         // schemes
 140         QPalette p = graphicsView->palette();
 141         p.setColor(QPalette::Active,   QPalette::Text, p.color(QPalette::Active,   QPalette::WindowText));
 142         p.setColor(QPalette::Inactive, QPalette::Text, p.color(QPalette::Inactive, QPalette::WindowText));
 143         p.setColor(QPalette::Disabled, QPalette::Text, p.color(QPalette::Disabled, QPalette::WindowText));
 144         graphicsView->setPalette(p);
 145         graphicsView->viewport()->setAutoFillBackground(false);
 146     }
 147 }
 148
 149 bool KItemListContainer::enabledFrame() const
 150 {
 151     const QGraphicsView* graphicsView = qobject_cast<QGraphicsView*>(viewport());
 152     return graphicsView->autoFillBackground();
 153 }
 154
 155 void KItemListContainer::keyPressEvent(QKeyEvent* event)
 156 {
 157     // TODO: We should find a better way to handle the key press events in the view.
 158     // The reasons why we need this hack are:
 159     // 1. Without reimplementing keyPressEvent() here, the event would not reach the QGraphicsView.
 160     // 2. By default, the KItemListView does not have the keyboard focus in the QGraphicsScene, so
 161     //    simply sending the event to the QGraphicsView which is the KItemListContainer's viewport
 162     //    does not work.
 163     KItemListView* view = m_controller->view();
 164     if (view) {
 165         QApplication::sendEvent(view, event);
 166     }
 167     QAccessible::updateAccessibility(view, m_controller->selectionManager()->currentItem()+1, QAccessible::Focus);
 168     QAccessible::updateAccessibility(view, m_controller->selectionManager()->currentItem()+1, QAccessible::LocationChanged);
 169 }
 170
 171 void KItemListContainer::showEvent(QShowEvent* event)
 172 {
 173     QAbstractScrollArea::showEvent(event);
 174     updateGeometries();
 175 }
 176
 177 void KItemListContainer::resizeEvent(QResizeEvent* event)
 178 {
 179     QAbstractScrollArea::resizeEvent(event);
 180     updateGeometries();
 181 }
 182
 183 void KItemListContainer::scrollContentsBy(int dx, int dy)
 184 {
 185     m_horizontalSmoothScroller->scrollContentsBy(dx);
 186     m_verticalSmoothScroller->scrollContentsBy(dy);
 187     QAccessible::updateAccessibility(m_controller->view(), m_controller->selectionManager()->currentItem()+1, QAccessible::Focus);
 188     QAccessible::updateAccessibility(m_controller->view(), m_controller->selectionManager()->currentItem()+1, QAccessible::LocationChanged);
 189 }
 190
 191 void KItemListContainer::wheelEvent(QWheelEvent* event)
 192 {
 193     if (event->modifiers().testFlag(Qt::ControlModifier)) {
 194         event->ignore();
 195         return;
 196     }
 197
 198     KItemListView* view = m_controller->view();
 199     if (!view) {
 200         event->ignore();
 201         return;
 202     }
 203
 204     const bool scrollHorizontally = (event->orientation() == Qt::Horizontal) ||
 205                                     (event->orientation() == Qt::Vertical && !verticalScrollBar()->isVisible());
 206     KItemListSmoothScroller* smoothScroller = scrollHorizontally ?
 207                                               m_horizontalSmoothScroller : m_verticalSmoothScroller;
 208
 209     const int numDegrees = event->delta() / 8;
 210     const int numSteps = numDegrees / 15;
 211
 212     const QScrollBar* scrollBar = smoothScroller->scrollBar();
 213     smoothScroller->scrollTo(scrollBar->value() - numSteps * scrollBar->pageStep() / 4);
 214
 215     event->accept();
 216 }
 217
 218 void KItemListContainer::slotScrollOrientationChanged(Qt::Orientation current, Qt::Orientation previous)
 219 {
 220     Q_UNUSED(previous);
 221     updateSmoothScrollers(current);
 222 }
 223
 224 void KItemListContainer::slotModelChanged(KItemModelBase* current, KItemModelBase* previous)
 225 {
 226     Q_UNUSED(current);
 227     Q_UNUSED(previous);
 228 }
 229
 230 void KItemListContainer::slotViewChanged(KItemListView* current, KItemListView* previous)
 231 {
 232     QGraphicsScene* scene = static_cast<QGraphicsView*>(viewport())->scene();
 233     if (previous) {
 234         scene->removeItem(previous);
 235         disconnect(previous, SIGNAL(scrollOrientationChanged(Qt::Orientation,Qt::Orientation)), this, SLOT(slotScrollOrientationChanged(Qt::Orientation,Qt::Orientation)));
 236         disconnect(previous, SIGNAL(scrollOffsetChanged(qreal,qreal)),        this, SLOT(updateScrollOffsetScrollBar()));
 237         disconnect(previous, SIGNAL(maximumScrollOffsetChanged(qreal,qreal)), this, SLOT(updateScrollOffsetScrollBar()));
 238         disconnect(previous, SIGNAL(itemOffsetChanged(qreal,qreal)),          this, SLOT(updateItemOffsetScrollBar()));
 239         disconnect(previous, SIGNAL(maximumItemOffsetChanged(qreal,qreal)),   this, SLOT(updateItemOffsetScrollBar()));
 240         disconnect(previous, SIGNAL(scrollTo(qreal)),                         this, SLOT(scrollTo(qreal)));
 241         m_horizontalSmoothScroller->setTargetObject(0);
 242         m_verticalSmoothScroller->setTargetObject(0);
 243     }
 244     if (current) {
 245         scene->addItem(current);
 246         connect(current, SIGNAL(scrollOrientationChanged(Qt::Orientation,Qt::Orientation)), this, SLOT(slotScrollOrientationChanged(Qt::Orientation,Qt::Orientation)));
 247         connect(current, SIGNAL(scrollOffsetChanged(qreal,qreal)),        this, SLOT(updateScrollOffsetScrollBar()));
 248         connect(current, SIGNAL(maximumScrollOffsetChanged(qreal,qreal)), this, SLOT(updateScrollOffsetScrollBar()));
 249         connect(current, SIGNAL(itemOffsetChanged(qreal,qreal)),          this, SLOT(updateItemOffsetScrollBar()));
 250         connect(current, SIGNAL(maximumItemOffsetChanged(qreal,qreal)),   this, SLOT(updateItemOffsetScrollBar()));
 251         connect(current, SIGNAL(scrollTo(qreal)),                         this, SLOT(scrollTo(qreal)));
 252         m_horizontalSmoothScroller->setTargetObject(current);
 253         m_verticalSmoothScroller->setTargetObject(current);
 254         updateSmoothScrollers(current->scrollOrientation());
 255     }
 256 }
 257
 258 void KItemListContainer::scrollTo(qreal offset)
 259 {
 260     const KItemListView* view = m_controller->view();
 261     if (view) {
 262         if (view->scrollOrientation() == Qt::Vertical) {
 263             m_verticalSmoothScroller->scrollTo(offset);
 264         } else {
 265             m_horizontalSmoothScroller->scrollTo(offset);
 266         }
 267     }
 268 }
 269
 270 void KItemListContainer::updateScrollOffsetScrollBar()
 271 {
 272     const KItemListView* view = m_controller->view();
 273     if (!view) {
 274         return;
 275     }
 276
 277     KItemListSmoothScroller* smoothScroller = 0;
 278     QScrollBar* scrollOffsetScrollBar = 0;
 279     int singleStep = 0;
 280     int pageStep = 0;
 281     if (view->scrollOrientation() == Qt::Vertical) {
 282         smoothScroller = m_verticalSmoothScroller;
 283         scrollOffsetScrollBar = verticalScrollBar();
 284         singleStep = view->itemSize().height();
 285         pageStep = view->size().height();
 286     } else {
 287         smoothScroller = m_horizontalSmoothScroller;
 288         scrollOffsetScrollBar = horizontalScrollBar();
 289         singleStep = view->itemSize().width();
 290         pageStep = view->size().width();
 291     }
 292
 293     const int value = view->scrollOffset();
 294     const int maximum = qMax(0, int(view->maximumScrollOffset() - pageStep));
 295     if (smoothScroller->requestScrollBarUpdate(maximum)) {
 296         const bool updatePolicy = (scrollOffsetScrollBar->maximum() > 0 && maximum == 0)
 297                                   || horizontalScrollBarPolicy() == Qt::ScrollBarAlwaysOn;
 298
 299         scrollOffsetScrollBar->setSingleStep(singleStep);
 300         scrollOffsetScrollBar->setPageStep(pageStep);
 301         scrollOffsetScrollBar->setMinimum(0);
 302         scrollOffsetScrollBar->setMaximum(maximum);
 303         scrollOffsetScrollBar->setValue(value);
 304
 305         if (updatePolicy) {
 306             // Prevent a potential endless layout loop (see bug #293318).
 307             updateScrollOffsetScrollBarPolicy();
 308         }
 309     }
 310 }
 311
 312 void KItemListContainer::updateItemOffsetScrollBar()
 313 {
 314     const KItemListView* view = m_controller->view();
 315     if (!view) {
 316         return;
 317     }
 318
 319     KItemListSmoothScroller* smoothScroller = 0;
 320     QScrollBar* itemOffsetScrollBar = 0;
 321     int singleStep = 0;
 322     int pageStep = 0;
 323     if (view->scrollOrientation() == Qt::Vertical) {
 324         smoothScroller = m_horizontalSmoothScroller;
 325         itemOffsetScrollBar = horizontalScrollBar();
 326         singleStep = view->size().width() / 10;
 327         pageStep = view->size().width();
 328     } else {
 329         smoothScroller = m_verticalSmoothScroller;
 330         itemOffsetScrollBar = verticalScrollBar();
 331         singleStep = view->size().height() / 10;
 332         pageStep = view->size().height();
 333     }
 334
 335     const int value = view->itemOffset();
 336     const int maximum = qMax(0, int(view->maximumItemOffset()) - pageStep);
 337     if (smoothScroller->requestScrollBarUpdate(maximum)) {
 338         itemOffsetScrollBar->setSingleStep(singleStep);
 339         itemOffsetScrollBar->setPageStep(pageStep);
 340         itemOffsetScrollBar->setMinimum(0);
 341         itemOffsetScrollBar->setMaximum(maximum);
 342         itemOffsetScrollBar->setValue(value);
 343     }
 344 }
 345
 346 void KItemListContainer::updateGeometries()
 347 {
 348     QRect rect = geometry();
 349
 350     int extra = frameWidth() * 2;
 351     QStyleOption option;
 352     option.initFrom(this);
 353     if (style()->styleHint(QStyle::SH_ScrollView_FrameOnlyAroundContents, &option, this)) {
 354         extra += style()->pixelMetric(QStyle::PM_ScrollView_ScrollBarSpacing, &option, this);
 355     }
 356
 357     const int widthDec = verticalScrollBar()->isVisible()
 358                          ? extra + style()->pixelMetric(QStyle::PM_ScrollBarExtent, &option, this)
 359                          : extra;
 360
 361     const int heightDec = horizontalScrollBar()->isVisible()
 362                           ? extra + style()->pixelMetric(QStyle::PM_ScrollBarExtent, &option, this)
 363                           : extra;
 364
 365     rect.adjust(0, 0, -widthDec, -heightDec);
 366
 367     const QRectF newGeometry(0, 0, rect.width(), rect.height());
 368     if (m_controller->view()->geometry() != newGeometry) {
 369         m_controller->view()->setGeometry(newGeometry);
 370
 371         static_cast<KItemListContainerViewport*>(viewport())->scene()->setSceneRect(0, 0, rect.width(), rect.height());
 372         static_cast<KItemListContainerViewport*>(viewport())->viewport()->setGeometry(QRect(0, 0, rect.width(), rect.height()));
 373
 374         updateScrollOffsetScrollBar();
 375         updateItemOffsetScrollBar();
 376         QAccessible::updateAccessibility(m_controller->view(), 0, QAccessible::LocationChanged);
 377         QAccessible::updateAccessibility(m_controller->view(), m_controller->selectionManager()->currentItem()+1, QAccessible::LocationChanged);
 378         QAccessible::updateAccessibility(m_controller->view(), m_controller->selectionManager()->currentItem()+1, QAccessible::Focus);
 379     }
 380 }
 381
 382 void KItemListContainer::updateSmoothScrollers(Qt::Orientation orientation)
 383 {
 384     if (orientation == Qt::Vertical) {
 385         m_verticalSmoothScroller->setPropertyName("scrollOffset");
 386         m_horizontalSmoothScroller->setPropertyName("itemOffset");
 387     } else {
 388         m_horizontalSmoothScroller->setPropertyName("scrollOffset");
 389         m_verticalSmoothScroller->setPropertyName("itemOffset");
 390     }
 391 }
 392
 393 void KItemListContainer::updateScrollOffsetScrollBarPolicy()
 394 {
 395     const KItemListView* view = m_controller->view();
 396     Q_ASSERT(view);
 397     const bool vertical = (view->scrollOrientation() == Qt::Vertical);
 398
 399     QStyleOption option;
 400     option.initFrom(this);
 401     const int scrollBarInc = style()->pixelMetric(QStyle::PM_ScrollBarExtent, &option, this);
 402
 403     QSizeF newViewSize = m_controller->view()->size();
 404     if (vertical) {
 405         newViewSize.rwidth() += scrollBarInc;
 406     } else {
 407         newViewSize.rheight() += scrollBarInc;
 408     }
 409
 410     const Qt::ScrollBarPolicy policy = view->scrollBarRequired(newViewSize)
 411                                        ? Qt::ScrollBarAlwaysOn : Qt::ScrollBarAsNeeded;
 412     if (vertical) {
 413         setVerticalScrollBarPolicy(policy);
 414     } else {
 415         setHorizontalScrollBarPolicy(policy);
 416     }
 417 }
 418
 419 #include "kitemlistcontainer.moc"