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     const int itemCount = m_model->count();
 128     const int itemsPerRow = m_view->itemsPerOffset();
 129
 130     // For horizontal scroll orientation, transform
 131     // the arrow keys to simplify the event handling.
 132     int key = event->key();
 133     if (m_view->scrollOrientation() == Qt::Horizontal) {
 134         switch (key) {
 135         case Qt::Key_Up:    key = Qt::Key_Left; break;
 136         case Qt::Key_Down:  key = Qt::Key_Right; break;
 137         case Qt::Key_Left:  key = Qt::Key_Up; break;
 138         case Qt::Key_Right: key = Qt::Key_Down; break;
 139         default:            break;
 140         }
 141     }
 142
 143     switch (key) {
 144     case Qt::Key_Home:
 145         index = 0;
 146         break;
 147
 148     case Qt::Key_End:
 149         index = itemCount - 1;
 150         break;
 151
 152     case Qt::Key_Left:
 153         if (index > 0) {
 154             index--;
 155         }
 156         break;
 157
 158     case Qt::Key_Right:
 159         if (index < itemCount - 1) {
 160             index++;
 161         }
 162         break;
 163
 164     case Qt::Key_Up:
 165         if (index >= itemsPerRow) {
 166             index -= itemsPerRow;
 167         }
 168         break;
 169
 170     case Qt::Key_Down:
 171         if (index + itemsPerRow < itemCount) {
 172             // We are not in the last row yet.
 173             index += itemsPerRow;
 174         }
 175         else {
 176             // We are either in the last row already, or we are in the second-last row,
 177             // and there is no item below the current item.
 178             // In the latter case, we jump to the very last item.
 179             const int currentColumn = index % itemsPerRow;
 180             const int lastItemColumn = (itemCount - 1) % itemsPerRow;
 181             const bool inLastRow = currentColumn < lastItemColumn;
 182             if (!inLastRow) {
 183                 index = itemCount - 1;
 184             }
 185         }
 186         break;
 187
 188     case Qt::Key_Space:
 189         if (controlPressed) {
 190             m_selectionManager->endAnchoredSelection();
 191             m_selectionManager->setSelected(index, 1, KItemListSelectionManager::Toggle);
 192             m_selectionManager->beginAnchoredSelection(index);
 193         }
 194
 195     default:
 196         break;
 197     }
 198
 199     if (m_selectionManager->currentItem() != index) {
 200         if (controlPressed) {
 201             m_selectionManager->endAnchoredSelection();
 202         }
 203
 204         m_selectionManager->setCurrentItem(index);
 205
 206         if (!shiftOrControlPressed || m_selectionBehavior == SingleSelection) {
 207             m_selectionManager->clearSelection();
 208             m_selectionManager->setSelected(index, 1);
 209         }
 210
 211         if (!shiftPressed) {
 212             m_selectionManager->beginAnchoredSelection(index);
 213         }
 214     }
 215     return true;
 216 }
 217
 218 bool KItemListController::inputMethodEvent(QInputMethodEvent* event)
 219 {
 220     Q_UNUSED(event);
 221     return false;
 222 }
 223
 224 bool KItemListController::mousePressEvent(QGraphicsSceneMouseEvent* event, const QTransform& transform)
 225 {
 226     const QPointF pos = transform.map(event->pos());
 227     m_pressedIndex = m_view->itemAt(pos);
 228
 229     if (m_view->isAboveExpansionToggle(m_pressedIndex, pos)) {
 230         return true;
 231     }
 232
 233     const bool shiftPressed = event->modifiers() & Qt::ShiftModifier;
 234     const bool controlPressed = event->modifiers() & Qt::ControlModifier;
 235     const bool shiftOrControlPressed = shiftPressed || controlPressed;
 236
 237     if (!shiftOrControlPressed || m_selectionBehavior == SingleSelection) {
 238         m_selectionManager->clearSelection();
 239     }
 240
 241     if (!shiftPressed) {
 242         // Finish the anchored selection before the current index is changed
 243         m_selectionManager->endAnchoredSelection();
 244     }
 245
 246     if (m_pressedIndex >= 0) {
 247         m_selectionManager->setCurrentItem(m_pressedIndex);
 248
 249         switch (m_selectionBehavior) {
 250         case NoSelection:
 251             return true;
 252         case SingleSelection:
 253             m_selectionManager->setSelected(m_pressedIndex);
 254             return true;
 255         case MultiSelection:
 256             if (controlPressed) {
 257                 m_selectionManager->setSelected(m_pressedIndex, 1, KItemListSelectionManager::Toggle);
 258                 m_selectionManager->beginAnchoredSelection(m_pressedIndex);
 259             }
 260             else {
 261                 if (shiftPressed && m_selectionManager->isAnchoredSelectionActive()) {
 262                     // The anchored selection is continued automatically by calling
 263                     // m_selectionManager->setCurrentItem(m_pressedIndex), see above -> nothing more to do here
 264                     return true;
 265                 }
 266
 267                 // Select the pressed item and start a new anchored selection
 268                 m_selectionManager->setSelected(m_pressedIndex, 1, KItemListSelectionManager::Select);
 269                 m_selectionManager->beginAnchoredSelection(m_pressedIndex);
 270             }
 271         }
 272
 273         return true;
 274     }
 275
 276     return false;
 277 }
 278
 279 bool KItemListController::mouseMoveEvent(QGraphicsSceneMouseEvent* event, const QTransform& transform)
 280 {
 281     Q_UNUSED(event);
 282     Q_UNUSED(transform);
 283     return false;
 284 }
 285
 286 bool KItemListController::mouseReleaseEvent(QGraphicsSceneMouseEvent* event, const QTransform& transform)
 287 {
 288     if (m_view) {
 289         const QPointF pos = transform.map(event->pos());
 290         const int index = m_view->itemAt(pos);
 291         const bool shiftOrControlPressed = event->modifiers() & Qt::ShiftModifier || event->modifiers() & Qt::ControlModifier;
 292
 293         if (index >= 0 && index == m_pressedIndex) {
 294             // The release event is done above the same item as the press event
 295             bool emitItemClicked = true;
 296             if (event->button() & Qt::LeftButton) {
 297                 if (m_view->isAboveExpansionToggle(index, pos)) {
 298                     emit itemExpansionToggleClicked(index);
 299                     emitItemClicked = false;
 300                 }
 301                 else if (shiftOrControlPressed) {
 302                     // The mouse click should only update the selection, not trigger the item
 303                     emitItemClicked = false;
 304                 }
 305             }
 306
 307             if (emitItemClicked) {
 308                 emit itemClicked(index, event->button());
 309             }
 310         } else if (!shiftOrControlPressed) {
 311             m_selectionManager->clearSelection();
 312         }
 313     }
 314
 315     m_pressedIndex = -1;
 316     return false;
 317 }
 318
 319 bool KItemListController::mouseDoubleClickEvent(QGraphicsSceneMouseEvent* event, const QTransform& transform)
 320 {
 321     Q_UNUSED(event);
 322     Q_UNUSED(transform);
 323     return false;
 324 }
 325
 326 bool KItemListController::dragEnterEvent(QGraphicsSceneDragDropEvent* event, const QTransform& transform)
 327 {
 328     Q_UNUSED(event);
 329     Q_UNUSED(transform);
 330     return false;
 331 }
 332
 333 bool KItemListController::dragLeaveEvent(QGraphicsSceneDragDropEvent* event, const QTransform& transform)
 334 {
 335     Q_UNUSED(event);
 336     Q_UNUSED(transform);
 337     return false;
 338 }
 339
 340 bool KItemListController::dragMoveEvent(QGraphicsSceneDragDropEvent* event, const QTransform& transform)
 341 {
 342     Q_UNUSED(event);
 343     Q_UNUSED(transform);
 344     return false;
 345 }
 346
 347 bool KItemListController::dropEvent(QGraphicsSceneDragDropEvent* event, const QTransform& transform)
 348 {
 349     Q_UNUSED(event);
 350     Q_UNUSED(transform);
 351     return false;
 352 }
 353
 354 bool KItemListController::hoverEnterEvent(QGraphicsSceneHoverEvent* event, const QTransform& transform)
 355 {
 356     Q_UNUSED(event);
 357     Q_UNUSED(transform);
 358     return false;
 359 }
 360
 361 bool KItemListController::hoverMoveEvent(QGraphicsSceneHoverEvent* event, const QTransform& transform)
 362 {
 363     // The implementation assumes that only one item can get hovered no matter
 364     // whether they overlap or not.
 365
 366     Q_UNUSED(transform);
 367     if (!m_model || !m_view) {
 368         return false;
 369     }
 370
 371     // Search the previously hovered item that might get unhovered
 372     KItemListWidget* unhoveredWidget = 0;
 373     foreach (KItemListWidget* widget, m_view->visibleItemListWidgets()) {
 374         if (widget->isHovered()) {
 375             unhoveredWidget = widget;
 376             break;
 377         }
 378     }
 379
 380     // Search the currently hovered item
 381     KItemListWidget* hoveredWidget = 0;
 382     foreach (KItemListWidget* widget, m_view->visibleItemListWidgets()) {
 383         const QPointF mappedPos = widget->mapFromItem(m_view, event->pos());
 384
 385         const bool hovered = widget->contains(mappedPos) &&
 386                              !widget->expansionToggleRect().contains(mappedPos) &&
 387                              !widget->selectionToggleRect().contains(mappedPos);
 388         if (hovered) {
 389             hoveredWidget = widget;
 390             break;
 391         }
 392     }
 393
 394     if (unhoveredWidget != hoveredWidget) {
 395         if (unhoveredWidget) {
 396             unhoveredWidget->setHovered(false);
 397             emit itemUnhovered(unhoveredWidget->index());
 398         }
 399
 400         if (hoveredWidget) {
 401             hoveredWidget->setHovered(true);
 402             emit itemHovered(hoveredWidget->index());
 403         }
 404     }
 405
 406     return false;
 407 }
 408
 409 bool KItemListController::hoverLeaveEvent(QGraphicsSceneHoverEvent* event, const QTransform& transform)
 410 {
 411     Q_UNUSED(event);
 412     Q_UNUSED(transform);
 413
 414     if (!m_model || !m_view) {
 415         return false;
 416     }
 417
 418     foreach (KItemListWidget* widget, m_view->visibleItemListWidgets()) {
 419         if (widget->isHovered()) {
 420             widget->setHovered(false);
 421             emit itemUnhovered(widget->index());
 422         }
 423     }
 424     return false;
 425 }
 426
 427 bool KItemListController::wheelEvent(QGraphicsSceneWheelEvent* event, const QTransform& transform)
 428 {
 429     Q_UNUSED(event);
 430     Q_UNUSED(transform);
 431     return false;
 432 }
 433
 434 bool KItemListController::resizeEvent(QGraphicsSceneResizeEvent* event, const QTransform& transform)
 435 {
 436     Q_UNUSED(event);
 437     Q_UNUSED(transform);
 438     return false;
 439 }
 440
 441 bool KItemListController::processEvent(QEvent* event, const QTransform& transform)
 442 {
 443     if (!event) {
 444         return false;
 445     }
 446
 447     switch (event->type()) {
 448     case QEvent::KeyPress:
 449         return keyPressEvent(static_cast<QKeyEvent*>(event));
 450     case QEvent::InputMethod:
 451         return inputMethodEvent(static_cast<QInputMethodEvent*>(event));
 452     case QEvent::GraphicsSceneMousePress:
 453         return mousePressEvent(static_cast<QGraphicsSceneMouseEvent*>(event), QTransform());
 454     case QEvent::GraphicsSceneMouseMove:
 455         return mouseMoveEvent(static_cast<QGraphicsSceneMouseEvent*>(event), QTransform());
 456     case QEvent::GraphicsSceneMouseRelease:
 457         return mouseReleaseEvent(static_cast<QGraphicsSceneMouseEvent*>(event), QTransform());
 458     case QEvent::GraphicsSceneWheel:
 459          return wheelEvent(static_cast<QGraphicsSceneWheelEvent*>(event), QTransform());
 460     case QEvent::GraphicsSceneDragEnter:
 461         return dragEnterEvent(static_cast<QGraphicsSceneDragDropEvent*>(event), QTransform());
 462     case QEvent::GraphicsSceneDragLeave:
 463         return dragLeaveEvent(static_cast<QGraphicsSceneDragDropEvent*>(event), QTransform());
 464     case QEvent::GraphicsSceneDragMove:
 465         return dragMoveEvent(static_cast<QGraphicsSceneDragDropEvent*>(event), QTransform());
 466     case QEvent::GraphicsSceneDrop:
 467         return dropEvent(static_cast<QGraphicsSceneDragDropEvent*>(event), QTransform());
 468     case QEvent::GraphicsSceneHoverEnter:
 469         return hoverEnterEvent(static_cast<QGraphicsSceneHoverEvent*>(event), QTransform());
 470     case QEvent::GraphicsSceneHoverMove:
 471         return hoverMoveEvent(static_cast<QGraphicsSceneHoverEvent*>(event), QTransform());
 472     case QEvent::GraphicsSceneHoverLeave:
 473         return hoverLeaveEvent(static_cast<QGraphicsSceneHoverEvent*>(event), QTransform());
 474     case QEvent::GraphicsSceneResize:
 475         return resizeEvent(static_cast<QGraphicsSceneResizeEvent*>(event), transform);
 476     default:
 477         break;
 478     }
 479
 480     return false;
 481 }
 482
 483 #include "kitemlistcontroller.moc"