Differential D12162 Diff 46337 src/kitemviews/kitemlistcontroller.cpp

Changeset View

Standalone View

View Options

src/kitemviews/kitemlistcontroller.cpp

Show All 37 Lines
38#include <QMimeData> 38​#include <QMimeData>
39#include <QTimer> 39​#include <QTimer>
40 40​
41KItemListController::KItemListController(KItemModelBase* model, KItemListView* view, QObject* parent) : 41​KItemListController::KItemListController(KItemModelBase* model, KItemListView* view, QObject* parent) :
42 QObject(parent), 42​ QObject(parent),
43 m_singleClickActivationEnforced(false), 43​ m_singleClickActivationEnforced(false),
44 m_selectionTogglePressed(false), 44​ m_selectionTogglePressed(false),
45 m_clearSelectionIfItemsAreNotDragged(false), 45​ m_clearSelectionIfItemsAreNotDragged(false),
46​ m_cancelTouchOnRelease(false),
47​ m_touchDoubleClickInProgress(false),
46 m_selectionBehavior(NoSelection), 48​ m_selectionBehavior(NoSelection),
47 m_autoActivationBehavior(ActivationAndExpansion), 49​ m_autoActivationBehavior(ActivationAndExpansion),
48 m_mouseDoubleClickAction(ActivateItemOnly), 50​ m_mouseDoubleClickAction(ActivateItemOnly),
49 m_model(nullptr), 51​ m_model(nullptr),
50 m_view(nullptr), 52​ m_view(nullptr),
51 m_selectionManager(new KItemListSelectionManager(this)), 53​ m_selectionManager(new KItemListSelectionManager(this)),
52 m_keyboardManager(new KItemListKeyboardSearchManager(this)), 54​ m_keyboardManager(new KItemListKeyboardSearchManager(this)),
53 m_pressedIndex(-1), 55​ m_pressedIndex(-1),
54 m_pressedMousePos(), 56​ m_pressedMousePos(),
55 m_autoActivationTimer(nullptr), 57​ m_autoActivationTimer(nullptr),
56 m_oldSelection(), 58​ m_oldSelection(),
57 m_keyboardAnchorIndex(-1), 59​ m_keyboardAnchorIndex(-1),
58 m_keyboardAnchorPos(0) 60​ m_keyboardAnchorPos(0)
59{ 61​{
60 connect(m_keyboardManager, &KItemListKeyboardSearchManager::changeCurrentItem, 62​ connect(m_keyboardManager, &KItemListKeyboardSearchManager::changeCurrentItem,
61 this, &KItemListController::slotChangeCurrentItem); 63​ this, &KItemListController::slotChangeCurrentItem);
62 connect(m_selectionManager, &KItemListSelectionManager::currentChanged, 64​ connect(m_selectionManager, &KItemListSelectionManager::currentChanged,
63 m_keyboardManager, &KItemListKeyboardSearchManager::slotCurrentChanged); 65​ m_keyboardManager, &KItemListKeyboardSearchManager::slotCurrentChanged);
64 66​
65 m_autoActivationTimer = new QTimer(this); 67​ m_autoActivationTimer = new QTimer(this);
66 m_autoActivationTimer->setSingleShot(true); 68​ m_autoActivationTimer->setSingleShot(true);
67 m_autoActivationTimer->setInterval(-1); 69​ m_autoActivationTimer->setInterval(-1);
68 connect(m_autoActivationTimer, &QTimer::timeout, this, &KItemListController::slotAutoActivationTimeout); 70​ connect(m_autoActivationTimer, &QTimer::timeout, this, &KItemListController::slotAutoActivationTimeout);
69 71​
72​ m_touchDoubleClickTimer.setSingleShot(true);
73​ connect(&m_touchDoubleClickTimer, &QTimer::timeout, [this]() {
elvisangelaccioAuthorUnsubmitted
Not Done

Please add this as receiver, otherwise this connection can lead to crashes.

elvisangelaccio: Please add `this` as receiver, otherwise this connection can lead to crashes.
abalajiUnsubmitted
Not Done

I'm sorry can you elaborate on this a little bit?

abalaji: I'm sorry can you elaborate on this a little bit?
elvisangelaccioAuthorUnsubmitted
Not Done

Basically Qt could call the lambda slot after the object has been already destroyed.

More details here: https://medium.com/genymobile/how-c-lambda-expressions-can-improve-your-qt-code-8cd524f4ed9f

elvisangelaccio: Basically Qt could call the lambda slot after the object has been already destroyed. More…
abalajiUnsubmitted
Not Done

Ahh, of course! This makes so much sense. I've experienced weird crashes with connect and lambda's before and never knew this was a thing. Thanks for pointing it out!

abalaji: Ahh, of course! This makes so much sense. I've experienced weird crashes with `connect` and…
74​ m_touchDoubleClickInProgress = false;
75​ });
70 setModel(model); 76​ setModel(model);
71 setView(view); 77​ setView(view);
72} 78​}
73 79​
74KItemListController::~KItemListController() 80​KItemListController::~KItemListController()
75{ 81​{
76 setView(nullptr); 82​ setView(nullptr);
77 Q_ASSERT(!m_view); 83​ Q_ASSERT(!m_view);
▲ Show 20 Lines • Show All 462 Lines • ▼ Show 20 Line(s)
540bool KItemListController::mousePressEvent(QGraphicsSceneMouseEvent* event, const QTransform& transform) 546​bool KItemListController::mousePressEvent(QGraphicsSceneMouseEvent* event, const QTransform& transform)
541{ 547​{
542 if (!m_view) { 548​ if (!m_view) {
543 return false; 549​ return false;
544 } 550​ }
545 551​
546 m_pressedMousePos = transform.map(event->pos()); 552​ m_pressedMousePos = transform.map(event->pos());
547 m_pressedIndex = m_view->itemAt(m_pressedMousePos); 553​ m_pressedIndex = m_view->itemAt(m_pressedMousePos);
548 emit mouseButtonPressed(m_pressedIndex, event->buttons()); 554​ const Qt::MouseButtons buttons = event->buttons();
555​ emit mouseButtonPressed(m_pressedIndex, buttons);
549 556​
550 if (event->buttons() & (Qt::BackButton | Qt::ForwardButton)) { 557​ if (buttons & (Qt::BackButton | Qt::ForwardButton)) {
551 // Do not select items when clicking the back/forward buttons, see 558​ // Do not select items when clicking the back/forward buttons, see
552 // https://bugs.kde.org/show_bug.cgi?id=327412. 559​ // https://bugs.kde.org/show_bug.cgi?id=327412.
553 return true; 560​ return true;
554 } 561​ }
555 562​
556 if (m_view->isAboveExpansionToggle(m_pressedIndex, m_pressedMousePos)) { 563​ if (!onPress(event->screenPos(), event->modifiers(), buttons)) {
557 m_selectionManager->endAnchoredSelection(); ​
558 m_selectionManager->setCurrentItem(m_pressedIndex); ​
559 m_selectionManager->beginAnchoredSelection(m_pressedIndex); ​
560 return true; ​
561 } ​
562 ​
563 m_selectionTogglePressed = m_view->isAboveSelectionToggle(m_pressedIndex, m_pressedMousePos); ​
564 if (m_selectionTogglePressed) { ​
565 m_selectionManager->setSelected(m_pressedIndex, 1, KItemListSelectionManager::Toggle); ​
566 // The previous anchored selection has been finished already in ​
567 // KItemListSelectionManager::setSelected(). We can safely change ​
568 // the current item and start a new anchored selection now. ​
569 m_selectionManager->setCurrentItem(m_pressedIndex); ​
570 m_selectionManager->beginAnchoredSelection(m_pressedIndex); ​
571 return true; ​
572 } ​
573 ​
574 const bool shiftPressed = event->modifiers() & Qt::ShiftModifier; ​
575 const bool controlPressed = event->modifiers() & Qt::ControlModifier; ​
576 ​
577 // The previous selection is cleared if either ​
578 // 1. The selection mode is SingleSelection, or ​
579 // 2. the selection mode is MultiSelection, and *none* of the following conditions are met: ​
580 // a) Shift or Control are pressed. ​
581 // b) The clicked item is selected already. In that case, the user might want to: ​
582 // - start dragging multiple items, or ​
583 // - open the context menu and perform an action for all selected items. ​
584 const bool shiftOrControlPressed = shiftPressed || controlPressed; ​
585 const bool pressedItemAlreadySelected = m_pressedIndex >= 0 && m_selectionManager->isSelected(m_pressedIndex); ​
586 const bool clearSelection = m_selectionBehavior == SingleSelection || ​
587 (!shiftOrControlPressed && !pressedItemAlreadySelected); ​
588 if (clearSelection) { ​
589 m_selectionManager->clearSelection(); ​
590 } else if (pressedItemAlreadySelected && !shiftOrControlPressed && (event->buttons() & Qt::LeftButton)) { ​
591 // The user might want to start dragging multiple items, but if he clicks the item ​
592 // in order to trigger it instead, the other selected items must be deselected. ​
593 // However, we do not know yet what the user is going to do. ​
594 // -> remember that the user pressed an item which had been selected already and ​
595 // clear the selection in mouseReleaseEvent(), unless the items are dragged. ​
596 m_clearSelectionIfItemsAreNotDragged = true; ​
597 ​
598 if (m_selectionManager->selectedItems().count() == 1 && m_view->isAboveText(m_pressedIndex, m_pressedMousePos)) { ​
599 emit selectedItemTextPressed(m_pressedIndex); ​
600 } ​
601 } ​
602 ​
603 if (!shiftPressed) { ​
604 // Finish the anchored selection before the current index is changed ​
605 m_selectionManager->endAnchoredSelection(); ​
606 } ​
607 ​
608 if (m_pressedIndex >= 0) { ​
609 m_selectionManager->setCurrentItem(m_pressedIndex); ​
610 ​
611 switch (m_selectionBehavior) { ​
612 case NoSelection: ​
613 break; ​
614 ​
615 case SingleSelection: ​
616 m_selectionManager->setSelected(m_pressedIndex); ​
617 break; ​
618 ​
619 case MultiSelection: ​
620 if (controlPressed && !shiftPressed) { ​
621 m_selectionManager->setSelected(m_pressedIndex, 1, KItemListSelectionManager::Toggle); ​
622 m_selectionManager->beginAnchoredSelection(m_pressedIndex); ​
623 } else if (!shiftPressed || !m_selectionManager->isAnchoredSelectionActive()) { ​
624 // Select the pressed item and start a new anchored selection ​
625 m_selectionManager->setSelected(m_pressedIndex, 1, KItemListSelectionManager::Select); ​
626 m_selectionManager->beginAnchoredSelection(m_pressedIndex); ​
627 } ​
628 break; ​
629 ​
630 default: ​
631 Q_ASSERT(false); ​
632 break; ​
633 } ​
634 ​
635 if (event->buttons() & Qt::RightButton) { ​
636 emit itemContextMenuRequested(m_pressedIndex, event->screenPos()); ​
637 } ​
638 ​
639 return true; ​
640 } ​
641 ​
642 if (event->buttons() & Qt::RightButton) { ​
643 const QRectF headerBounds = m_view->headerBoundaries(); ​
644 if (headerBounds.contains(event->pos())) { ​
645 emit headerContextMenuRequested(event->screenPos()); ​
646 } else { ​
647 emit viewContextMenuRequested(event->screenPos()); ​
648 } ​
649 return true; ​
650 } ​
651 ​
652 if (m_selectionBehavior == MultiSelection) { 564​ if (m_selectionBehavior == MultiSelection) {
653 QPointF startPos = m_pressedMousePos; 565​ QPointF startPos = m_pressedMousePos;
654 if (m_view->scrollOrientation() == Qt::Vertical) { 566​ if (m_view->scrollOrientation() == Qt::Vertical) {
655 startPos.ry() += m_view->scrollOffset(); 567​ startPos.ry() += m_view->scrollOffset();
656 if (m_view->itemSize().width() < 0) { 568​ if (m_view->itemSize().width() < 0) {
657 // Use a special rubberband for views that have only one column and 569​ // Use a special rubberband for views that have only one column and
658 // expand the rubberband to use the whole width of the view. 570​ // expand the rubberband to use the whole width of the view.
659 startPos.setX(0); 571​ startPos.setX(0);
Show All 9 Lines
669 rubberBand->setActive(true); 581​ rubberBand->setActive(true);
670 connect(rubberBand, &KItemListRubberBand::endPositionChanged, this, &KItemListController::slotRubberBandChanged); 582​ connect(rubberBand, &KItemListRubberBand::endPositionChanged, this, &KItemListController::slotRubberBandChanged);
671 m_view->setAutoScroll(true); 583​ m_view->setAutoScroll(true);
672 } 584​ }
673 585​
674 return false; 586​ return false;
675} 587​ }
676 588​
589​ return true;
590​}
591​
677bool KItemListController::mouseMoveEvent(QGraphicsSceneMouseEvent* event, const QTransform& transform) 592​bool KItemListController::mouseMoveEvent(QGraphicsSceneMouseEvent* event, const QTransform& transform)
678{ 593​{
679 if (!m_view) { 594​ if (!m_view) {
680 return false; 595​ return false;
681 } 596​ }
682 597​
683 if (m_pressedIndex >= 0) { 598​ onMove(transform.map(event->pos()), event->buttons());
684 // Check whether a dragging should be started ​
685 if (event->buttons() & Qt::LeftButton) { ​
686 const QPointF pos = transform.map(event->pos()); ​
687 if ((pos - m_pressedMousePos).manhattanLength() >= QApplication::startDragDistance()) { ​
688 if (!m_selectionManager->isSelected(m_pressedIndex)) { ​
689 // Always assure that the dragged item gets selected. Usually this is already ​
690 // done on the mouse-press event, but when using the selection-toggle on a ​
691 // selected item the dragged item is not selected yet. ​
692 m_selectionManager->setSelected(m_pressedIndex, 1, KItemListSelectionManager::Toggle); ​
693 } else { ​
694 // A selected item has been clicked to drag all selected items ​
695 // -> the selection should not be cleared when the mouse button is released. ​
696 m_clearSelectionIfItemsAreNotDragged = false; ​
697 } ​
698 ​
699 startDragging(); ​
700 } ​
701 } ​
702 } else { ​
703 KItemListRubberBand* rubberBand = m_view->rubberBand(); ​
704 if (rubberBand->isActive()) { ​
705 QPointF endPos = transform.map(event->pos()); ​
706 ​
707 // Update the current item. ​
708 const int newCurrent = m_view->itemAt(endPos); ​
709 if (newCurrent >= 0) { ​
710 // It's expected that the new current index is also the new anchor (bug 163451). ​
711 m_selectionManager->endAnchoredSelection(); ​
712 m_selectionManager->setCurrentItem(newCurrent); ​
713 m_selectionManager->beginAnchoredSelection(newCurrent); ​
714 } ​
715 ​
716 if (m_view->scrollOrientation() == Qt::Vertical) { ​
717 endPos.ry() += m_view->scrollOffset(); ​
718 if (m_view->itemSize().width() < 0) { ​
719 // Use a special rubberband for views that have only one column and ​
720 // expand the rubberband to use the whole width of the view. ​
721 endPos.setX(m_view->size().width()); ​
722 } ​
723 } else { ​
724 endPos.rx() += m_view->scrollOffset(); ​
725 } ​
726 rubberBand->setEndPosition(endPos); ​
727 } ​
728 } ​
729 ​
730 return false; 599​ return false;
731} 600​}
732 601​
733bool KItemListController::mouseReleaseEvent(QGraphicsSceneMouseEvent* event, const QTransform& transform) 602​bool KItemListController::mouseReleaseEvent(QGraphicsSceneMouseEvent* event, const QTransform& transform)
734{ 603​{
735 if (!m_view) { 604​ if (!m_view) {
736 return false; 605​ return false;
737 } 606​ }
738 607​
739 emit mouseButtonReleased(m_pressedIndex, event->buttons()); 608​ emit mouseButtonReleased(m_pressedIndex, event->buttons());
740 609​
741 const bool isAboveSelectionToggle = m_view->isAboveSelectionToggle(m_pressedIndex, m_pressedMousePos); 610​ return onRelease(transform.map(event->pos()), event->modifiers(), event->button());
742 if (isAboveSelectionToggle) { ​
743 m_selectionTogglePressed = false; ​
744 return true; ​
745 } ​
746 ​
747 if (!isAboveSelectionToggle && m_selectionTogglePressed) { ​
748 m_selectionManager->setSelected(m_pressedIndex, 1, KItemListSelectionManager::Toggle); ​
749 m_selectionTogglePressed = false; ​
750 return true; ​
751 } ​
752 ​
753 const bool shiftOrControlPressed = event->modifiers() & Qt::ShiftModifier || ​
754 event->modifiers() & Qt::ControlModifier; ​
755 ​
756 KItemListRubberBand* rubberBand = m_view->rubberBand(); ​
757 if (rubberBand->isActive()) { ​
758 disconnect(rubberBand, &KItemListRubberBand::endPositionChanged, this, &KItemListController::slotRubberBandChanged); ​
759 rubberBand->setActive(false); ​
760 m_oldSelection.clear(); ​
761 m_view->setAutoScroll(false); ​
762 } ​
763 ​
764 const QPointF pos = transform.map(event->pos()); ​
765 const int index = m_view->itemAt(pos); ​
766 ​
767 if (index >= 0 && index == m_pressedIndex) { ​
768 // The release event is done above the same item as the press event ​
769 ​
770 if (m_clearSelectionIfItemsAreNotDragged) { ​
771 // A selected item has been clicked, but no drag operation has been started ​
772 // -> clear the rest of the selection. ​
773 m_selectionManager->clearSelection(); ​
774 m_selectionManager->setSelected(m_pressedIndex, 1, KItemListSelectionManager::Select); ​
775 m_selectionManager->beginAnchoredSelection(m_pressedIndex); ​
776 } ​
777 ​
778 if (event->button() & Qt::LeftButton) { ​
779 bool emitItemActivated = true; ​
780 if (m_view->isAboveExpansionToggle(index, pos)) { ​
781 const bool expanded = m_model->isExpanded(index); ​
782 m_model->setExpanded(index, !expanded); ​
783 ​
784 emit itemExpansionToggleClicked(index); ​
785 emitItemActivated = false; ​
786 } else if (shiftOrControlPressed) { ​
787 // The mouse click should only update the selection, not trigger the item ​
788 emitItemActivated = false; ​
789 } else if (!(m_view->style()->styleHint(QStyle::SH_ItemView_ActivateItemOnSingleClick) || m_singleClickActivationEnforced)) { ​
790 emitItemActivated = false; ​
791 } ​
792 if (emitItemActivated) { ​
793 emit itemActivated(index); ​
794 } ​
795 } else if (event->button() & Qt::MidButton) { ​
796 emit itemMiddleClicked(index); ​
797 } ​
798 } ​
799 ​
800 m_pressedMousePos = QPointF(); ​
801 m_pressedIndex = -1; ​
802 m_clearSelectionIfItemsAreNotDragged = false; ​
803 return false; ​
804} 611​}
805 612​
806bool KItemListController::mouseDoubleClickEvent(QGraphicsSceneMouseEvent* event, const QTransform& transform) 613​bool KItemListController::mouseDoubleClickEvent(QGraphicsSceneMouseEvent* event, const QTransform& transform)
807{ 614​{
808 const QPointF pos = transform.map(event->pos()); 615​ const QPointF pos = transform.map(event->pos());
809 const int index = m_view->itemAt(pos); 616​ const int index = m_view->itemAt(pos);
810 617​
811 // Expand item if desired - See Bug 295573 618​ return onDoubleClick(pos, event->screenPos(), index, event->button());
812 if (m_mouseDoubleClickAction != ActivateItemOnly) { ​
813 if (m_view && m_model && m_view->supportsItemExpanding() && m_model->isExpandable(index)) { ​
814 const bool expanded = m_model->isExpanded(index); ​
815 m_model->setExpanded(index, !expanded); ​
816 } ​
817 } ​
818 ​
819 if (event->button() & Qt::RightButton) { ​
820 m_selectionManager->clearSelection(); ​
821 if (index >= 0) { ​
822 m_selectionManager->setSelected(index); ​
823 emit itemContextMenuRequested(index, event->screenPos()); ​
824 } else { ​
825 const QRectF headerBounds = m_view->headerBoundaries(); ​
826 if (headerBounds.contains(event->pos())) { ​
827 emit headerContextMenuRequested(event->screenPos()); ​
828 } else { ​
829 emit viewContextMenuRequested(event->screenPos()); ​
830 } ​
831 } ​
832 return true; ​
833 } ​
834 ​
835 bool emitItemActivated = !(m_view->style()->styleHint(QStyle::SH_ItemView_ActivateItemOnSingleClick) || m_singleClickActivationEnforced) && ​
836 (event->button() & Qt::LeftButton) && ​
837 index >= 0 && index < m_model->count(); ​
838 if (emitItemActivated) { ​
839 emit itemActivated(index); ​
840 } ​
841 return false; ​
842} 619​}
843 620​
844bool KItemListController::dragEnterEvent(QGraphicsSceneDragDropEvent* event, const QTransform& transform) 621​bool KItemListController::dragEnterEvent(QGraphicsSceneDragDropEvent* event, const QTransform& transform)
845{ 622​{
846 Q_UNUSED(event); 623​ Q_UNUSED(event);
847 Q_UNUSED(transform); 624​ Q_UNUSED(transform);
848 625​
849 DragAndDropHelper::clearUrlListMatchesUrlCache(); 626​ DragAndDropHelper::clearUrlListMatchesUrlCache();
▲ Show 20 Lines • Show All 180 Lines • ▼ Show 20 Line(s)
1030 807​
1031bool KItemListController::resizeEvent(QGraphicsSceneResizeEvent* event, const QTransform& transform) 808​bool KItemListController::resizeEvent(QGraphicsSceneResizeEvent* event, const QTransform& transform)
1032{ 809​{
1033 Q_UNUSED(event); 810​ Q_UNUSED(event);
1034 Q_UNUSED(transform); 811​ Q_UNUSED(transform);
1035 return false; 812​ return false;
1036} 813​}
1037 814​
815​bool KItemListController::touchBeginEvent(QTouchEvent* event, const QTransform& transform)
816​{
817​ if (!m_view) {
818​ return false;
819​ }
820​
821​ const QTouchEvent::TouchPoint& touchPoint = event->touchPoints()[0];
822​
823​ m_pressedMousePos = transform.map(touchPoint.pos());
824​ m_pressedIndex = m_view->itemAt(m_pressedMousePos);
825​ onPress(touchPoint.screenPos().toPoint(), event->modifiers());
826​ return true;
827​}
828​
829​bool KItemListController::touchUpdateEvent(QTouchEvent* event, const QTransform& transform)
830​{
831​ if (!m_view) {
832​ return false;
833​ }
834​
835​ const auto touchState = event->touchPointStates();
836​
837​ if (event->touchPoints().length() > 1) {
838​ return true;
839​ }
840​ if (touchState & Qt::TouchPointMoved) {
841​ if (!m_cancelTouchOnRelease) {
842​ const QPointF& pos = transform.map(event->touchPoints()[0].pos());
843​ // allow finger to fumble about a bit, but beyond the threshold suppress on release action
844​ if ((m_pressedMousePos - pos).manhattanLength() >= QApplication::startDragDistance()) {
845​ m_cancelTouchOnRelease = true;
846​ }
847​ }
848​ }
849​ return true;
850​}
851​
852​bool KItemListController::touchEndEvent(QTouchEvent* event, const QTransform& transform)
853​{
854​ if (!m_view) {
855​ return false;
856​ }
857​
858​ if (m_cancelTouchOnRelease) {
859​ m_cancelTouchOnRelease = false;
860​ return true;
861​ }
862​
863​ const QTouchEvent::TouchPoint& touchPoint = event->touchPoints()[0];
864​ const QPointF pos = transform.map(touchPoint.pos());
865​ const int index = m_view->itemAt(pos);
866​ if (m_touchDoubleClickInProgress) {
867​ if (
868​ (index >= 0 && index == m_touchDoubleClickStartIndex) ||
869​ (pos - m_touchDoubleClickStartPos).manhattanLength() < 20
870​ ) {
871​ onDoubleClick(pos, touchPoint.screenPos().toPoint(), m_pressedIndex, Qt::LeftButton);
872​ }
873​ } else {
874​ m_touchDoubleClickInProgress = true;
875​ }
876​ m_touchDoubleClickStartPos = pos;
877​ m_touchDoubleClickStartIndex = index;
878​ m_touchDoubleClickTimer.start(QApplication::doubleClickInterval());
879​
880​ onRelease(pos, event->modifiers(), Qt::LeftButton);
881​ return true;
882​}
883​
1038bool KItemListController::processEvent(QEvent* event, const QTransform& transform) 884​bool KItemListController::processEvent(QEvent* event, const QTransform& transform)
1039{ 885​{
1040 if (!event) { 886​ if (!event) {
1041 return false; 887​ return false;
1042 } 888​ }
1043 889​
1044 switch (event->type()) { 890​ switch (event->type()) {
1045 case QEvent::KeyPress: 891​ case QEvent::KeyPress:
Show All 21 Lines
1067 case QEvent::GraphicsSceneHoverEnter: 913​ case QEvent::GraphicsSceneHoverEnter:
1068 return hoverEnterEvent(static_cast<QGraphicsSceneHoverEvent*>(event), QTransform()); 914​ return hoverEnterEvent(static_cast<QGraphicsSceneHoverEvent*>(event), QTransform());
1069 case QEvent::GraphicsSceneHoverMove: 915​ case QEvent::GraphicsSceneHoverMove:
1070 return hoverMoveEvent(static_cast<QGraphicsSceneHoverEvent*>(event), QTransform()); 916​ return hoverMoveEvent(static_cast<QGraphicsSceneHoverEvent*>(event), QTransform());
1071 case QEvent::GraphicsSceneHoverLeave: 917​ case QEvent::GraphicsSceneHoverLeave:
1072 return hoverLeaveEvent(static_cast<QGraphicsSceneHoverEvent*>(event), QTransform()); 918​ return hoverLeaveEvent(static_cast<QGraphicsSceneHoverEvent*>(event), QTransform());
1073 case QEvent::GraphicsSceneResize: 919​ case QEvent::GraphicsSceneResize:
1074 return resizeEvent(static_cast<QGraphicsSceneResizeEvent*>(event), transform); 920​ return resizeEvent(static_cast<QGraphicsSceneResizeEvent*>(event), transform);
921​ case QEvent::TouchBegin:
922​ return touchBeginEvent(static_cast<QTouchEvent*>(event), QTransform());
923​ case QEvent::TouchUpdate:
924​ return touchUpdateEvent(static_cast<QTouchEvent*>(event), QTransform());
925​ case QEvent::TouchEnd:
926​ return touchEndEvent(static_cast<QTouchEvent*>(event), QTransform());
1075 default: 927​ default:
1076 break; 928​ break;
1077 } 929​ }
1078 930​
1079 return false; 931​ return false;
1080} 932​}
1081 933​
1082void KItemListController::slotViewScrollOffsetChanged(qreal current, qreal previous) 934​void KItemListController::slotViewScrollOffsetChanged(qreal current, qreal previous)
▲ Show 20 Lines • Show All 264 Lines • ▼ Show 20 Line(s)1197 if (m_view) {
1347 KItemListStyleOption option = m_view->styleOption(); 1199​ KItemListStyleOption option = m_view->styleOption();
1348 if (option.extendedSelectionRegion != extend) { 1200​ if (option.extendedSelectionRegion != extend) {
1349 option.extendedSelectionRegion = extend; 1201​ option.extendedSelectionRegion = extend;
1350 m_view->setStyleOption(option); 1202​ m_view->setStyleOption(option);
1351 } 1203​ }
1352 } 1204​ }
1353} 1205​}
1354 1206​
1207​bool KItemListController::onPress(const QPoint& screenPos, const Qt::KeyboardModifiers modifiers, const Qt::MouseButtons buttons)
1208​{
1209​ if (m_view->isAboveExpansionToggle(m_pressedIndex, m_pressedMousePos)) {
1210​ m_selectionManager->endAnchoredSelection();
1211​ m_selectionManager->setCurrentItem(m_pressedIndex);
1212​ m_selectionManager->beginAnchoredSelection(m_pressedIndex);
1213​ return true;
1214​ }
1215​
1216​ m_selectionTogglePressed = m_view->isAboveSelectionToggle(m_pressedIndex, m_pressedMousePos);
1217​ if (m_selectionTogglePressed) {
1218​ m_selectionManager->setSelected(m_pressedIndex, 1, KItemListSelectionManager::Toggle);
1219​ // The previous anchored selection has been finished already in
1220​ // KItemListSelectionManager::setSelected(). We can safely change
1221​ // the current item and start a new anchored selection now.
1222​ m_selectionManager->setCurrentItem(m_pressedIndex);
1223​ m_selectionManager->beginAnchoredSelection(m_pressedIndex);
1224​ return true;
1225​ }
1226​
1227​ const bool shiftPressed = modifiers & Qt::ShiftModifier;
1228​ const bool controlPressed = modifiers & Qt::ControlModifier;
1229​
1230​ // The previous selection is cleared if either
1231​ // 1. The selection mode is SingleSelection, or
1232​ // 2. the selection mode is MultiSelection, and *none* of the following conditions are met:
1233​ // a) Shift or Control are pressed.
1234​ // b) The clicked item is selected already. In that case, the user might want to:
1235​ // - start dragging multiple items, or
1236​ // - open the context menu and perform an action for all selected items.
1237​ const bool shiftOrControlPressed = shiftPressed || controlPressed;
1238​ const bool pressedItemAlreadySelected = m_pressedIndex >= 0 && m_selectionManager->isSelected(m_pressedIndex);
1239​ const bool clearSelection = m_selectionBehavior == SingleSelection ||
1240​ (!shiftOrControlPressed && !pressedItemAlreadySelected);
1241​ if (clearSelection) {
1242​ m_selectionManager->clearSelection();
1243​ } else if (pressedItemAlreadySelected && !shiftOrControlPressed && (buttons & Qt::LeftButton)) {
1244​ // The user might want to start dragging multiple items, but if he clicks the item
1245​ // in order to trigger it instead, the other selected items must be deselected.
1246​ // However, we do not know yet what the user is going to do.
1247​ // -> remember that the user pressed an item which had been selected already and
1248​ // clear the selection in mouseReleaseEvent(), unless the items are dragged.
1249​ m_clearSelectionIfItemsAreNotDragged = true;
1250​
1251​ if (m_selectionManager->selectedItems().count() == 1 && m_view->isAboveText(m_pressedIndex, m_pressedMousePos)) {
1252​ emit selectedItemTextPressed(m_pressedIndex);
1253​ }
1254​ }
1255​
1256​ if (!shiftPressed) {
1257​ // Finish the anchored selection before the current index is changed
1258​ m_selectionManager->endAnchoredSelection();
1259​ }
1260​
1261​ if (m_pressedIndex >= 0) {
1262​ m_selectionManager->setCurrentItem(m_pressedIndex);
1263​
1264​ switch (m_selectionBehavior) {
1265​ case NoSelection:
1266​ break;
1267​
1268​ case SingleSelection:
1269​ m_selectionManager->setSelected(m_pressedIndex);
1270​ break;
1271​
1272​ case MultiSelection:
1273​ if (controlPressed && !shiftPressed) {
1274​ m_selectionManager->setSelected(m_pressedIndex, 1, KItemListSelectionManager::Toggle);
1275​ m_selectionManager->beginAnchoredSelection(m_pressedIndex);
1276​ } else if (!shiftPressed || !m_selectionManager->isAnchoredSelectionActive()) {
1277​ // Select the pressed item and start a new anchored selection
1278​ m_selectionManager->setSelected(m_pressedIndex, 1, KItemListSelectionManager::Select);
1279​ m_selectionManager->beginAnchoredSelection(m_pressedIndex);
1280​ }
1281​ break;
1282​
1283​ default:
1284​ Q_ASSERT(false);
1285​ break;
1286​ }
1287​
1288​ if (buttons & Qt::RightButton) {
1289​ emit itemContextMenuRequested(m_pressedIndex, screenPos);
1290​ }
1291​
1292​ return true;
1293​ }
1294​
1295​ if (buttons & Qt::RightButton) {
1296​ const QRectF headerBounds = m_view->headerBoundaries();
1297​ if (headerBounds.contains(m_pressedMousePos)) {
1298​ emit headerContextMenuRequested(screenPos);
1299​ } else {
1300​ emit viewContextMenuRequested(screenPos);
1301​ }
1302​ return true;
1303​ }
1304​
1305​ return false;
1306​}
1307​
1308​void KItemListController::onMove(const QPointF& pos, const Qt::MouseButtons buttons)
1309​{
1310​ if (m_pressedIndex >= 0) {
1311​ // Check whether a dragging should be started
1312​ if (buttons & Qt::LeftButton) {
1313​ if ((pos - m_pressedMousePos).manhattanLength() >= QApplication::startDragDistance()) {
1314​ if (!m_selectionManager->isSelected(m_pressedIndex)) {
1315​ // Always assure that the dragged item gets selected. Usually this is already
1316​ // done on the mouse-press event, but when using the selection-toggle on a
1317​ // selected item the dragged item is not selected yet.
1318​ m_selectionManager->setSelected(m_pressedIndex, 1, KItemListSelectionManager::Toggle);
1319​ } else {
1320​ // A selected item has been clicked to drag all selected items
1321​ // -> the selection should not be cleared when the mouse button is released.
1322​ m_clearSelectionIfItemsAreNotDragged = false;
1323​ }
1324​
1325​ startDragging();
1326​ }
1327​ }
1328​ } else {
1329​ KItemListRubberBand* rubberBand = m_view->rubberBand();
1330​ if (rubberBand->isActive()) {
1331​ // Update the current item.
1332​ QPointF endPos(pos);
1333​ const int newCurrent = m_view->itemAt(endPos);
1334​ if (newCurrent >= 0) {
1335​ // It's expected that the new current index is also the new anchor (bug 163451).
1336​ m_selectionManager->endAnchoredSelection();
1337​ m_selectionManager->setCurrentItem(newCurrent);
1338​ m_selectionManager->beginAnchoredSelection(newCurrent);
1339​ }
1340​
1341​ if (m_view->scrollOrientation() == Qt::Vertical) {
1342​ endPos.ry() += m_view->scrollOffset();
1343​ if (m_view->itemSize().width() < 0) {
1344​ // Use a special rubberband for views that have only one column and
1345​ // expand the rubberband to use the whole width of the view.
1346​ endPos.setX(m_view->size().width());
1347​ }
1348​ } else {
1349​ endPos.rx() += m_view->scrollOffset();
1350​ }
1351​ rubberBand->setEndPosition(endPos);
1352​ }
1353​ }
1354​}
1355​
1356​bool KItemListController::onRelease(const QPointF& pos, const Qt::KeyboardModifiers modifiers, const Qt::MouseButtons button)
1357​{
1358​ const bool isAboveSelectionToggle = m_view->isAboveSelectionToggle(m_pressedIndex, m_pressedMousePos);
1359​ if (isAboveSelectionToggle) {
1360​ m_selectionTogglePressed = false;
1361​ return true;
1362​ }
1363​
1364​ if (!isAboveSelectionToggle && m_selectionTogglePressed) {
1365​ m_selectionManager->setSelected(m_pressedIndex, 1, KItemListSelectionManager::Toggle);
1366​ m_selectionTogglePressed = false;
1367​ return true;
1368​ }
1369​
1370​ const bool shiftOrControlPressed = modifiers & Qt::ShiftModifier ||
1371​ modifiers & Qt::ControlModifier;
1372​
1373​ KItemListRubberBand* rubberBand = m_view->rubberBand();
1374​ if (rubberBand->isActive()) {
1375​ disconnect(rubberBand, &KItemListRubberBand::endPositionChanged, this, &KItemListController::slotRubberBandChanged);
1376​ rubberBand->setActive(false);
1377​ m_oldSelection.clear();
1378​ m_view->setAutoScroll(false);
1379​ }
1380​
1381​ const int index = m_view->itemAt(pos);
1382​
1383​ if (index >= 0 && index == m_pressedIndex) {
1384​ // The release event is done above the same item as the press event
1385​
1386​ if (m_clearSelectionIfItemsAreNotDragged) {
1387​ // A selected item has been clicked, but no drag operation has been started
1388​ // -> clear the rest of the selection.
1389​ m_selectionManager->clearSelection();
1390​ m_selectionManager->setSelected(m_pressedIndex, 1, KItemListSelectionManager::Select);
1391​ m_selectionManager->beginAnchoredSelection(m_pressedIndex);
1392​ }
1393​
1394​ if (button & Qt::LeftButton) {
1395​ if (m_view->isAboveExpansionToggle(index, pos)) {
1396​ const bool expanded = m_model->isExpanded(index);
1397​ m_model->setExpanded(index, !expanded);
1398​
1399​ emit itemExpansionToggleClicked(index);
1400​ } else if (
1401​ !shiftOrControlPressed && (
1402​ m_view->style()->styleHint(QStyle::SH_ItemView_ActivateItemOnSingleClick) ||
1403​ m_singleClickActivationEnforced
1404​ )
1405​ ) {
1406​ emit itemActivated(index);
1407​ }
anthonyfieroniUnsubmitted
Done

emitItemActivated increases complexity, so just remove it

if (m_view->isAboveExpansionToggle(index, pos)) {
    const bool expanded = m_model->isExpanded(index);
    m_model->setExpanded(index, !expanded);
    emit itemExpansionToggleClicked(index);
} else if (shiftOrControlPressed || m_singleClickActivationEnforced
|| !(m_view->style()->styleHint(QStyle::SH_ItemView_ActivateItemOnSingleClick))) {
    // The mouse click should only update the selection, not trigger the item
} else {
    emit itemActivated(index);
}
anthonyfieroni: emitItemActivated increases complexity, so just remove it ``` if (m_view…
1408​ } else if (button & Qt::MidButton) {
1409​ emit itemMiddleClicked(index);
1410​ }
1411​ }
1412​
1413​ m_pressedMousePos = QPointF();
1414​ m_pressedIndex = -1;
1415​ m_clearSelectionIfItemsAreNotDragged = false;
1416​ return false;
1417​}
1418​
1419​bool KItemListController::onDoubleClick(const QPointF& pos, const QPoint& screenPos, const int index, const Qt::MouseButton button)
1420​{
1421​ // Expand item if desired - See Bug 295573
1422​ if (m_mouseDoubleClickAction != ActivateItemOnly) {
1423​ if (m_view && m_model && m_view->supportsItemExpanding() && m_model->isExpandable(index)) {
1424​ const bool expanded = m_model->isExpanded(index);
1425​ m_model->setExpanded(index, !expanded);
1426​ }
1427​ }
1428​
1429​ if (button & Qt::RightButton) {
1430​ m_selectionManager->clearSelection();
1431​ if (index >= 0) {
1432​ m_selectionManager->setSelected(index);
1433​ emit itemContextMenuRequested(index, screenPos);
1434​ } else {
1435​ const QRectF headerBounds = m_view->headerBoundaries();
1436​ if (headerBounds.contains(pos)) {
1437​ emit headerContextMenuRequested(screenPos);
1438​ } else {
1439​ emit viewContextMenuRequested(screenPos);
1440​ }
1441​ }
1442​ return true;
1443​ }
1444​
1445​ bool emitItemActivated = !(m_view->style()->styleHint(QStyle::SH_ItemView_ActivateItemOnSingleClick) || m_singleClickActivationEnforced) &&
1446​ (button & Qt::LeftButton) &&
1447​ index >= 0 && index < m_model->count();
1448​ if (emitItemActivated) {
1449​ emit itemActivated(index);
1450​ }
1451​ return false;
1452​}