src/kitemviews/kitemlistcontroller.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 "kitemlistcontroller.h"
  24
  25 #include "kitemlistview.h"
  26 #include "kitemlistselectionmanager.h"
  27
  28 #include <QEvent>
  29 #include <QGraphicsSceneEvent>
  30 #include <QTransform>
  31
  32 #include <KDebug>
  33
  34 KItemListController::KItemListController(QObject* parent) :
  35     QObject(parent),
  36     m_selectionBehavior(NoSelection),
  37     m_model(0),
  38     m_view(0),
  39     m_selectionManager(new KItemListSelectionManager(this)),
  40     m_pressedIndex(-1)
  41 {
  42 }
  43
  44 KItemListController::~KItemListController()
  45 {
  46 }
  47
  48 void KItemListController::setModel(KItemModelBase* model)
  49 {
  50     if (m_model == model) {
  51         return;
  52     }
  53
  54     KItemModelBase* oldModel = m_model;
  55     m_model = model;
  56
  57     if (m_view) {
  58         m_view->setModel(m_model);
  59     }
  60
  61     m_selectionManager->setModel(m_model);
  62
  63     emit modelChanged(m_model, oldModel);
  64 }
  65
  66 KItemModelBase* KItemListController::model() const
  67 {
  68     return m_model;
  69 }
  70
  71 KItemListSelectionManager* KItemListController::selectionManager() const
  72 {
  73     return m_selectionManager;
  74 }
  75
  76 void KItemListController::setView(KItemListView* view)
  77 {
  78     if (m_view == view) {
  79         return;
  80     }
  81
  82     KItemListView* oldView = m_view;
  83     m_view = view;
  84
  85     if (m_view) {
  86         m_view->setController(this);
  87         m_view->setModel(m_model);
  88     }
  89
  90     emit viewChanged(m_view, oldView);
  91 }
  92
  93 KItemListView* KItemListController::view() const
  94 {
  95     return m_view;
  96 }
  97
  98 void KItemListController::setSelectionBehavior(SelectionBehavior behavior)
  99 {
 100     m_selectionBehavior = behavior;
 101 }
 102
 103 KItemListController::SelectionBehavior KItemListController::selectionBehavior() const
 104 {
 105     return m_selectionBehavior;
 106 }
 107
 108 bool KItemListController::showEvent(QShowEvent* event)
 109 {
 110     Q_UNUSED(event);
 111     return false;
 112 }
 113
 114 bool KItemListController::hideEvent(QHideEvent* event)
 115 {
 116     Q_UNUSED(event);
 117     return false;
 118 }
 119
 120 bool KItemListController::keyPressEvent(QKeyEvent* event)
 121 {
 122     const bool shiftPressed = event->modifiers() & Qt::ShiftModifier;
 123     const bool controlPressed = event->modifiers() & Qt::ControlModifier;
 124     const bool shiftOrControlPressed = shiftPressed || controlPressed;
 125
 126     int index = m_selectionManager->currentItem();
 127
 128     switch (event->key()) {
 129     case Qt::Key_Home:
 130         index = 0;
 131         break;
 132
 133     case Qt::Key_End:
 134         index = m_model->count() - 1;
 135         break;
 136
 137     case Qt::Key_Up:
 138         if (m_view->scrollOrientation() == Qt::Horizontal) {
 139             if (index > 0) {
 140                 index--;
 141             }
 142         }
 143         else {
 144             // TODO: Move to the previous row
 145         }
 146         break;
 147
 148     case Qt::Key_Down:
 149         if (m_view->scrollOrientation() == Qt::Horizontal) {
 150             if (index < m_model->count() - 1) {
 151                 index++;
 152             }
 153         }
 154         else {
 155             // TODO: Move to the next row
 156         }
 157         break;
 158
 159     case Qt::Key_Left:
 160         if (m_view->scrollOrientation() == Qt::Vertical) {
 161             if (index > 0) {
 162                 index--;
 163             }
 164         }
 165         else {
 166             // TODO: Move to the previous column
 167         }
 168         break;
 169
 170     case Qt::Key_Right:
 171         if (m_view->scrollOrientation() == Qt::Vertical) {
 172             if (index < m_model->count() - 1) {
 173                 index++;
 174             }
 175         }
 176         else {
 177             // TODO: Move to the next column
 178         }
 179         break;
 180
 181     case Qt::Key_Space:
 182         if (controlPressed) {
 183             m_selectionManager->endAnchoredSelection();
 184             m_selectionManager->setSelected(index, 1, KItemListSelectionManager::Toggle);
 185             m_selectionManager->beginAnchoredSelection(index);
 186         }
 187      default:
 188         break;
 189     }
 190
 191     if (m_selectionManager->currentItem() != index) {
 192         if (controlPressed) {
 193             m_selectionManager->endAnchoredSelection();
 194         }
 195
 196         m_selectionManager->setCurrentItem(index);
 197
 198         if (!shiftOrControlPressed || m_selectionBehavior == SingleSelection) {
 199             m_selectionManager->clearSelection();
 200             m_selectionManager->setSelected(index, 1);
 201         }
 202
 203         if (!shiftPressed) {
 204             m_selectionManager->beginAnchoredSelection(index);
 205         }
 206     }
 207     return true;
 208 }
 209
 210 bool KItemListController::inputMethodEvent(QInputMethodEvent* event)
 211 {
 212     Q_UNUSED(event);
 213     return false;
 214 }
 215
 216 bool KItemListController::mousePressEvent(QGraphicsSceneMouseEvent* event, const QTransform& transform)
 217 {
 218     const QPointF pos = transform.map(event->pos());
 219     m_pressedIndex = m_view->itemAt(pos);
 220
 221     if (m_view->isAboveExpansionToggle(m_pressedIndex, pos)) {
 222         return true;
 223     }
 224
 225     const bool shiftPressed = event->modifiers() & Qt::ShiftModifier;
 226     const bool controlPressed = event->modifiers() & Qt::ControlModifier;
 227     const bool shiftOrControlPressed = shiftPressed || controlPressed;
 228
 229     if (!shiftOrControlPressed || m_selectionBehavior == SingleSelection) {
 230         m_selectionManager->clearSelection();
 231     }
 232
 233     if (!shiftPressed) {
 234         // Finish the anchored selection before the current index is changed
 235         m_selectionManager->endAnchoredSelection();
 236     }
 237
 238     if (m_pressedIndex >= 0) {
 239         m_selectionManager->setCurrentItem(m_pressedIndex);
 240
 241         switch (m_selectionBehavior) {
 242         case NoSelection:
 243             return true;
 244         case SingleSelection:
 245             m_selectionManager->setSelected(m_pressedIndex);
 246             return true;
 247         case MultiSelection:
 248             if (controlPressed) {
 249                 m_selectionManager->setSelected(m_pressedIndex, 1, KItemListSelectionManager::Toggle);
 250                 m_selectionManager->beginAnchoredSelection(m_pressedIndex);
 251             }
 252             else {
 253                 if (shiftPressed && m_selectionManager->isAnchoredSelectionActive()) {
 254                     // The anchored selection is continued automatically by calling
 255                     // m_selectionManager->setCurrentItem(m_pressedIndex), see above -> nothing more to do here
 256                     return true;
 257                 }
 258
 259                 // Select the pressed item and start a new anchored selection
 260                 m_selectionManager->setSelected(m_pressedIndex, 1, KItemListSelectionManager::Select);
 261                 m_selectionManager->beginAnchoredSelection(m_pressedIndex);
 262             }
 263         }
 264
 265         return true;
 266     }
 267
 268     return false;
 269 }
 270
 271 bool KItemListController::mouseMoveEvent(QGraphicsSceneMouseEvent* event, const QTransform& transform)
 272 {
 273     Q_UNUSED(event);
 274     Q_UNUSED(transform);
 275     return false;
 276 }
 277
 278 bool KItemListController::mouseReleaseEvent(QGraphicsSceneMouseEvent* event, const QTransform& transform)
 279 {
 280     if (m_view) {
 281         const QPointF pos = transform.map(event->pos());
 282         const int index = m_view->itemAt(pos);
 283         const bool shiftOrControlPressed = event->modifiers() & Qt::ShiftModifier || event->modifiers() & Qt::ControlModifier;
 284
 285         if (index >= 0 && index == m_pressedIndex) {
 286             // The release event is done above the same item as the press event
 287             bool emitItemClicked = true;
 288             if (event->button() & Qt::LeftButton) {
 289                 if (m_view->isAboveExpansionToggle(index, pos)) {
 290                     emit itemExpansionToggleClicked(index);
 291                     emitItemClicked = false;
 292                 }
 293                 else if (shiftOrControlPressed) {
 294                     // The mouse click should only update the selection, not trigger the item
 295                     emitItemClicked = false;
 296                 }
 297             }
 298
 299             if (emitItemClicked) {
 300                 emit itemClicked(index, event->button());
 301             }
 302         } else if (!shiftOrControlPressed) {
 303             m_selectionManager->clearSelection();
 304         }
 305     }
 306
 307     m_pressedIndex = -1;
 308     return false;
 309 }
 310
 311 bool KItemListController::mouseDoubleClickEvent(QGraphicsSceneMouseEvent* event, const QTransform& transform)
 312 {
 313     Q_UNUSED(event);
 314     Q_UNUSED(transform);
 315     return false;
 316 }
 317
 318 bool KItemListController::dragEnterEvent(QGraphicsSceneDragDropEvent* event, const QTransform& transform)
 319 {
 320     Q_UNUSED(event);
 321     Q_UNUSED(transform);
 322     return false;
 323 }
 324
 325 bool KItemListController::dragLeaveEvent(QGraphicsSceneDragDropEvent* event, const QTransform& transform)
 326 {
 327     Q_UNUSED(event);
 328     Q_UNUSED(transform);
 329     return false;
 330 }
 331
 332 bool KItemListController::dragMoveEvent(QGraphicsSceneDragDropEvent* event, const QTransform& transform)
 333 {
 334     Q_UNUSED(event);
 335     Q_UNUSED(transform);
 336     return false;
 337 }
 338
 339 bool KItemListController::dropEvent(QGraphicsSceneDragDropEvent* event, const QTransform& transform)
 340 {
 341     Q_UNUSED(event);
 342     Q_UNUSED(transform);
 343     return false;
 344 }
 345
 346 bool KItemListController::hoverEnterEvent(QGraphicsSceneHoverEvent* event, const QTransform& transform)
 347 {
 348     Q_UNUSED(event);
 349     Q_UNUSED(transform);
 350     return false;
 351 }
 352
 353 bool KItemListController::hoverMoveEvent(QGraphicsSceneHoverEvent* event, const QTransform& transform)
 354 {
 355     // The implementation assumes that only one item can get hovered no matter
 356     // whether they overlap or not.
 357
 358     Q_UNUSED(transform);
 359     if (!m_model || !m_view) {
 360         return false;
 361     }
 362
 363     // Search the previously hovered item that might get unhovered
 364     KItemListWidget* unhoveredWidget = 0;
 365     foreach (KItemListWidget* widget, m_view->visibleItemListWidgets()) {
 366         if (widget->isHovered()) {
 367             unhoveredWidget = widget;
 368             break;
 369         }
 370     }
 371
 372     // Search the currently hovered item
 373     KItemListWidget* hoveredWidget = 0;
 374     foreach (KItemListWidget* widget, m_view->visibleItemListWidgets()) {
 375         const QPointF mappedPos = widget->mapFromItem(m_view, event->pos());
 376
 377         const bool hovered = widget->contains(mappedPos) &&
 378                              !widget->expansionToggleRect().contains(mappedPos) &&
 379                              !widget->selectionToggleRect().contains(mappedPos);
 380         if (hovered) {
 381             hoveredWidget = widget;
 382             break;
 383         }
 384     }
 385
 386     if (unhoveredWidget != hoveredWidget) {
 387         if (unhoveredWidget) {
 388             unhoveredWidget->setHovered(false);
 389             emit itemUnhovered(unhoveredWidget->index());
 390         }
 391
 392         if (hoveredWidget) {
 393             hoveredWidget->setHovered(true);
 394             emit itemHovered(hoveredWidget->index());
 395         }
 396     }
 397
 398     return false;
 399 }
 400
 401 bool KItemListController::hoverLeaveEvent(QGraphicsSceneHoverEvent* event, const QTransform& transform)
 402 {
 403     Q_UNUSED(event);
 404     Q_UNUSED(transform);
 405
 406     if (!m_model || !m_view) {
 407         return false;
 408     }
 409
 410     foreach (KItemListWidget* widget, m_view->visibleItemListWidgets()) {
 411         if (widget->isHovered()) {
 412             widget->setHovered(false);
 413             emit itemUnhovered(widget->index());
 414         }
 415     }
 416     return false;
 417 }
 418
 419 bool KItemListController::wheelEvent(QGraphicsSceneWheelEvent* event, const QTransform& transform)
 420 {
 421     Q_UNUSED(event);
 422     Q_UNUSED(transform);
 423     return false;
 424 }
 425
 426 bool KItemListController::resizeEvent(QGraphicsSceneResizeEvent* event, const QTransform& transform)
 427 {
 428     Q_UNUSED(event);
 429     Q_UNUSED(transform);
 430     return false;
 431 }
 432
 433 bool KItemListController::processEvent(QEvent* event, const QTransform& transform)
 434 {
 435     if (!event) {
 436         return false;
 437     }
 438
 439     switch (event->type()) {
 440     case QEvent::KeyPress:
 441         return keyPressEvent(static_cast<QKeyEvent*>(event));
 442     case QEvent::InputMethod:
 443         return inputMethodEvent(static_cast<QInputMethodEvent*>(event));
 444     case QEvent::GraphicsSceneMousePress:
 445         return mousePressEvent(static_cast<QGraphicsSceneMouseEvent*>(event), QTransform());
 446     case QEvent::GraphicsSceneMouseMove:
 447         return mouseMoveEvent(static_cast<QGraphicsSceneMouseEvent*>(event), QTransform());
 448     case QEvent::GraphicsSceneMouseRelease:
 449         return mouseReleaseEvent(static_cast<QGraphicsSceneMouseEvent*>(event), QTransform());
 450     case QEvent::GraphicsSceneWheel:
 451          return wheelEvent(static_cast<QGraphicsSceneWheelEvent*>(event), QTransform());
 452     case QEvent::GraphicsSceneDragEnter:
 453         return dragEnterEvent(static_cast<QGraphicsSceneDragDropEvent*>(event), QTransform());
 454     case QEvent::GraphicsSceneDragLeave:
 455         return dragLeaveEvent(static_cast<QGraphicsSceneDragDropEvent*>(event), QTransform());
 456     case QEvent::GraphicsSceneDragMove:
 457         return dragMoveEvent(static_cast<QGraphicsSceneDragDropEvent*>(event), QTransform());
 458     case QEvent::GraphicsSceneDrop:
 459         return dropEvent(static_cast<QGraphicsSceneDragDropEvent*>(event), QTransform());
 460     case QEvent::GraphicsSceneHoverEnter:
 461         return hoverEnterEvent(static_cast<QGraphicsSceneHoverEvent*>(event), QTransform());
 462     case QEvent::GraphicsSceneHoverMove:
 463         return hoverMoveEvent(static_cast<QGraphicsSceneHoverEvent*>(event), QTransform());
 464     case QEvent::GraphicsSceneHoverLeave:
 465         return hoverLeaveEvent(static_cast<QGraphicsSceneHoverEvent*>(event), QTransform());
 466     case QEvent::GraphicsSceneResize:
 467         return resizeEvent(static_cast<QGraphicsSceneResizeEvent*>(event), transform);
 468     default:
 469         break;
 470     }
 471
 472     return false;
 473 }
 474
 475 #include "kitemlistcontroller.moc"