Selection.h

Go to the documentation of this file.

/*
 * Hydrogen
 * Copyright(c) 2002-2008 by Alex >Comix< Cominu [comix@users.sourceforge.net]
 * Copyright(c) 2008-2024 The hydrogen development team [hydrogen-devel@lists.sourceforge.net]
 *
 * http://www.hydrogen-music.org
 *
 * 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, see https://www.gnu.org/licenses
 *
 */
 
#ifndef SELECTION_H
#define SELECTION_H
 
#include <QtGui>
#include <QWidget>
#include <QMouseEvent>
#include <QApplication>
#include <QScrollArea>
#include <vector>
#include <set>
#include <QDebug>
#include <cassert>
#include <memory>
 
#include <core/Preferences/Preferences.h>
 
 
template <class Elem>
class SelectionWidget {
public:
 
        typedef Elem SelectionIndex;
 
        virtual std::vector<SelectionIndex> elementsIntersecting( QRect r ) = 0;
 
        virtual bool canDragElements() { return true; }
 
        virtual QRect getKeyboardCursorRect() = 0;
 
        virtual void validateSelection() = 0;
 
        virtual void updateWidget() = 0;
 
        virtual bool checkDeselectElements( std::vector<SelectionIndex> &elements ) {
                return true;
        }
 
 
        virtual void mouseClickEvent( QMouseEvent *ev ) = 0;
        virtual void mouseDragStartEvent( QMouseEvent *ev ) = 0;
        virtual void mouseDragUpdateEvent( QMouseEvent *ev ) = 0;
        virtual void mouseDragEndEvent( QMouseEvent *ev ) = 0;
        virtual void selectionMoveUpdateEvent( QMouseEvent *ev ) {};
        virtual void selectionMoveEndEvent( QInputEvent *ev ) = 0;
        virtual void selectionMoveCancelEvent() {};
 
        virtual void startMouseLasso( QMouseEvent *ev ) {}
        virtual void startMouseMove( QMouseEvent *ev ) {}
        virtual void endMouseGesture() {}
 
        virtual QScrollArea *findScrollArea() {
                QWidget *pThisWidget = dynamic_cast< QWidget *>( this );
                if ( pThisWidget ) {
                        QWidget *pParent = dynamic_cast< QWidget *>( pThisWidget->parent() );
                        if ( pParent ) {
                                QScrollArea *pScrollArea = dynamic_cast< QScrollArea *>( pParent->parent() );
                                if ( pScrollArea ) {
                                        return pScrollArea;
                                }
                        }
                }
                return nullptr;
        }
 
};
 
 
 
class DragScroller : public QObject {
        Q_OBJECT
        QTimer *m_pTimer;
        QScrollArea *m_pScrollArea;
        const int m_nInterval = 20; // ms
 
public:
        DragScroller( QScrollArea *pScrollArea ) {
                m_pTimer = nullptr;
                m_pScrollArea = pScrollArea;
        }
 
        ~DragScroller() {
                if ( m_pTimer != nullptr) {
                        delete m_pTimer;
                }
        }
 
        void startDrag() {
                if ( m_pTimer == nullptr ) {
                        m_pTimer = new QTimer( this );
                        m_pTimer->setInterval( m_nInterval );
                        connect( m_pTimer, &QTimer::timeout, this, &DragScroller::timeout );
                }
                m_pTimer->start();
        }
 
        void endDrag() {
                m_pTimer->stop();
        }
 
public slots:
        void timeout( void ) {
                QWidget *pWidget = m_pScrollArea->widget();
                QPoint pos = pWidget->mapFromGlobal( QCursor::pos() );
                m_pScrollArea->ensureVisible( pos.x(), pos.y(), 1, 1 );
        }
};
 
 
template<class Elem>
class Selection {
 
        struct SelectionGroup {
                std::set<Elem> m_selectedElements;
                std::set< SelectionWidget<Elem> *> m_selectionWidgets;
        };
 
        std::shared_ptr< SelectionGroup > m_pSelectionGroup;
 
 
private:
        SelectionWidget< Elem > *m_pWidget;
 
        enum MouseState { Up, Down, Dragging } m_mouseState;
        Qt::MouseButton m_mouseButton; 
        QMouseEvent *m_pClickEvent;        
 
 
        enum SelectionState { Idle, MouseLasso, MouseMoving, KeyboardLasso, KeyboardMoving } m_selectionState;
 
        QRect m_lasso;                          
        QPoint m_movingOffset;          
        QRect m_keyboardCursorStart; 
 
        std::set< Elem > m_checkpointSelectedElements;
 
        DragScroller *m_pDragScroller;
 
 
public:
 
        Selection( SelectionWidget<Elem> *w ) {
 
                m_pWidget = w;
                m_mouseButton = Qt::NoButton;
                m_mouseState = Up;
                m_pClickEvent = nullptr;
                m_selectionState = Idle;
                m_pSelectionGroup = std::make_shared< SelectionGroup >();
                m_pSelectionGroup->m_selectionWidgets.insert( w );
                m_pDragScroller = nullptr;
 
        }
 
        void merge( Selection *pOther ) {
                if ( pOther != this ) {
                        pOther->m_pSelectionGroup->m_selectionWidgets.insert
                                ( m_pSelectionGroup->m_selectionWidgets.begin(),
                                  m_pSelectionGroup->m_selectionWidgets.end() );
                }
                m_pSelectionGroup = pOther->m_pSelectionGroup;
        }
 
        void dump() {
 
                qDebug() << "Mouse state: " << ( m_mouseState == Up ? "Up" :
                                                                                 m_mouseState == Down ? "Down" :
                                                                                 m_mouseState == Dragging ? "Dragging" : "-" )
                                 << "\n"
                                 << "button: " << m_mouseButton << "\n"
                                 << "Selection state: " << ( m_selectionState == Idle ? "Idle" :
                                                                                         m_selectionState == MouseLasso ? "MouseLasso" :
                                                                                         m_selectionState == MouseMoving ? "MouseMoving" :
                                                                                         m_selectionState == KeyboardLasso ? "KeyboardLasso" :
                                                                                         m_selectionState == KeyboardMoving ? "KeyboardMoving" :
                                                                                         "-")
                                 << "";
 
        }
 
 
        bool isMoving() const {
                return m_selectionState == MouseMoving || m_selectionState == KeyboardMoving;
        }
 
        bool isMouseGesture() const {
                return m_selectionState == MouseMoving || m_selectionState == MouseLasso;
        }
 
        QPoint movingOffset() const {
                return m_movingOffset;
        }
 
        bool isLasso() const {
                return m_selectionState == MouseLasso || m_selectionState == KeyboardLasso;
        }
 
        bool isSelected( Elem e ) const {
                return m_pSelectionGroup->m_selectedElements.find( e ) != m_pSelectionGroup->m_selectedElements.end();
        }
 
        void removeFromSelection( Elem e, bool bCheck = true ) {
                std::vector<Elem> v { e };
                if ( !bCheck || m_pWidget->checkDeselectElements( v ) ) {
                        m_pSelectionGroup->m_selectedElements.erase( e );
                }
        }
 
        void addToSelection( Elem e ) {
                m_pSelectionGroup->m_selectedElements.insert( e );
        }
 
        void clearSelection( bool bCheck = true ) {
                std::vector<Elem> v ( m_pSelectionGroup->m_selectedElements.begin(),
                                                          m_pSelectionGroup->m_selectedElements.end() );
                if ( !bCheck || m_pWidget->checkDeselectElements( v ) ) {
                        m_pSelectionGroup->m_selectedElements.clear();
                }
        }
 
        typedef typename std::set<Elem>::iterator iterator;
 
        iterator begin() { return m_pSelectionGroup->m_selectedElements.begin(); }
        iterator end() { return m_pSelectionGroup->m_selectedElements.end(); }
 
        void updateWidgetGroup() {
                for ( auto pW : m_pSelectionGroup->m_selectionWidgets ) {
                        pW->updateWidget();
                }
        }
 
        void cancelGesture() {
                if ( m_mouseState == Dragging ) {
                        mouseDragEnd();
                }
                m_mouseState = Up;
                if ( m_pClickEvent ) {
                        delete m_pClickEvent;
                        m_pClickEvent = nullptr;
                }
                if ( m_selectionState == MouseMoving || m_selectionState == MouseLasso ) {
                        m_pWidget->endMouseGesture();
                        m_pWidget->selectionMoveCancelEvent();
                }
                m_selectionState = Idle;
                updateWidgetGroup();
        }
 
        // -------------------------------------------------------------------------------------------------------
 
        void mousePressEvent( QMouseEvent *ev ) {
 
                // macOS ctrl+left-click is reported as a
                // right-click. However, only the 'press' event is reported,
                // there are no move or release events. This is enough for
                // opening context menus, but not enough for drag gestures.
                if ( m_mouseState == Up
                         && ev->button() == Qt::RightButton
                         && ev->buttons() == Qt::LeftButton
                         && ev->modifiers() & Qt::MetaModifier) {
                        // Deliver the event as a transient click with no effect on state
                        mouseClick( ev );
                        return;
                }
 
                // Check for inconsistent state. If there was a gesture in progress, abandon it.
                if ( !( m_mouseButton & ev->buttons() ) && m_mouseState != Up ) {
                        delete m_pClickEvent;
                        m_pClickEvent = nullptr;
                        m_mouseState = Up;
                }
 
                // Detect start of click or drag event
                if ( m_mouseState == Up ) {
                        m_mouseState = Down;
                        m_mouseButton = ev->button();
                        assert( m_pClickEvent == nullptr );
#if (QT_VERSION >= QT_VERSION_CHECK(5, 6, 0))
                        m_pClickEvent = new QMouseEvent(QEvent::MouseButtonPress,
                                                                                        ev->localPos(), ev->windowPos(), ev->screenPos(),
                                                                                        m_mouseButton, ev->buttons(), ev->modifiers(),
                                                                                        Qt::MouseEventSynthesizedByApplication);
#else
                        m_pClickEvent = new QMouseEvent(QEvent::MouseButtonPress,
                                                                                        ev->localPos(), ev->windowPos(), ev->screenPos(),
                                                                                        m_mouseButton, ev->buttons(), ev->modifiers());
#endif
                        m_pClickEvent->setTimestamp( ev->timestamp() );
                }
        }
 
        void mouseMoveEvent( QMouseEvent *ev ) {
 
                if ( m_mouseState == Down ) {
                        if ( (ev->pos() - m_pClickEvent->pos() ).manhattanLength() > QApplication::startDragDistance()
                                 || (ev->timestamp() - m_pClickEvent->timestamp()) > QApplication::startDragTime() ) {
                                // Mouse has moved far enough to consider this a drag rather than a click.
                                m_mouseState = Dragging;
                                mouseDragStart( m_pClickEvent );
                        }
                } else if ( m_mouseState == Dragging ) {
                        mouseDragUpdate( ev );
                }
        }
 
        void mouseReleaseEvent( QMouseEvent *ev ) {
                if ( m_mouseState != Up && !( ev->buttons() & m_mouseButton) ) {
                        if ( m_mouseState == Down ) {
                                mouseClick( ev );
                        } else if ( m_mouseState == Dragging ) {
                                mouseDragEnd( ev );
                        }
                        m_mouseState = Up;
                        delete m_pClickEvent;
                        m_pClickEvent = nullptr;
 
                } else {
                        // Other mouse buttons may have been pressed since the
                        // last click was started, and may have been released to
                        // cause this event.
                }
        }
 
 
 
        void paintSelection( QPainter *painter ) {
                if ( m_selectionState == MouseLasso || m_selectionState == KeyboardLasso ) {
                        QPen pen( H2Core::Preferences::get_instance()->getColorTheme()
                                          ->m_selectionHighlightColor );
                        pen.setStyle( Qt::DotLine );
                        pen.setWidth(2);
                        painter->setPen( pen );
                        painter->setBrush( Qt::NoBrush );
 
                        painter->drawRect( m_lasso );
                }
        }
 
 
        // -------------------------------------------------------------------------------------------------------
 
        void mouseClick( QMouseEvent *ev ) {
                if ( ev->modifiers() & Qt::ControlModifier ) {
                        // Ctrl+click to add or remove element from selection.
                        QRect r = QRect( ev->pos(), ev->pos() );
                        std::vector<Elem> elems = m_pWidget->elementsIntersecting( r );
                        for ( Elem e : elems) {
                                if ( m_pSelectionGroup->m_selectedElements.find( e )
                                         == m_pSelectionGroup->m_selectedElements.end() ) {
                                        addToSelection( e );
                                } else {
                                        removeFromSelection( e );
                                }
                        }
                        updateWidgetGroup();
                } else {
                        if ( ev->button() != Qt::RightButton && !m_pSelectionGroup->m_selectedElements.empty() ) {
                                // Click without control or right button, and
                                // non-empty selection, will just clear selection
                                clearSelection();
                                updateWidgetGroup();
                        } else if ( ev->button() == Qt::RightButton && m_pSelectionGroup->m_selectedElements.empty() ) {
                                // Right-clicking with an empty selection will first attempt to select anything at the click
                                // position before passing the click through to the client.
                                QRect r = QRect( ev->pos(), ev->pos() );
                                std::vector<Elem> elems = m_pWidget->elementsIntersecting( r );
                                for ( Elem e : elems) {
                                        addToSelection( e );
                                }
                                m_pWidget->mouseClickEvent( ev );
                        } else {
                                m_pWidget->mouseClickEvent( ev );
                        }
                }
        }
 
        void mouseDragStart( QMouseEvent *ev ) {
 
                if ( m_pDragScroller == nullptr ) {
                        m_pDragScroller = new DragScroller( m_pWidget->findScrollArea() );
                }
                m_pDragScroller->startDrag();
 
                if ( ev->button() == Qt::LeftButton) {
                        QRect r = QRect( m_pClickEvent->pos(), ev->pos() );
                        std::vector<Elem> elems = m_pWidget->elementsIntersecting( r );
 
                        /* Did the user start dragging a selected element, or an unselected element?
                         */
                        bool bHitSelected = false, bHitAny = false;
                        for ( Elem elem : elems ) {
                                bHitAny = true;
                                if ( isSelected( elem ) ) {
                                        bHitSelected = true;
                                        break;
                                }
                        }
 
                        if ( bHitSelected ) {
                                /* Move selection */
                                if ( bHitSelected ) {
                                        m_selectionState = MouseMoving;
                                        m_movingOffset = ev->pos() - m_pClickEvent->pos();
                                        m_pWidget->startMouseMove( ev );
                                }
                        } else if ( bHitAny && m_pWidget->canDragElements() ) {
                                // Allow mouseDragStartEvent to handle anything
 
                        } else {
                                //  Didn't hit anything. Start new selection drag.
                                m_checkpointSelectedElements = m_pSelectionGroup->m_selectedElements;
                                m_selectionState = MouseLasso;
                                m_lasso.setTopLeft( m_pClickEvent->pos() );
                                m_lasso.setBottomRight( ev->pos() );
                                m_pWidget->startMouseLasso( ev );
                                m_pWidget->updateWidget();
 
                        }
 
                }
                m_pWidget->mouseDragStartEvent( ev );
        }
 
        void mouseDragUpdate( QMouseEvent *ev ) {
 
                if ( m_selectionState == MouseLasso) {
                        m_lasso.setBottomRight( ev->pos() );
 
                        if ( ev->modifiers() & Qt::ControlModifier ) {
                                // Start with previously selected elements
                                m_pSelectionGroup->m_selectedElements = m_checkpointSelectedElements;
                        } else {
                                // Clear and rebuild selection
                                m_checkpointSelectedElements.clear();
                                clearSelection();
                        }
                        auto selected = m_pWidget->elementsIntersecting( m_lasso );
                        for ( auto s : selected ) {
                                if ( m_checkpointSelectedElements.find( s ) == m_checkpointSelectedElements.end() ) {
                                        addToSelection( s );
                                }
                        }
                        updateWidgetGroup();
 
                } else if ( m_selectionState == MouseMoving ) {
                        m_movingOffset = ev->pos() - m_pClickEvent->pos();
                        m_pWidget->selectionMoveUpdateEvent( ev );
                        updateWidgetGroup();
 
                } else {
                        // Pass drag update to widget
                        m_pWidget->mouseDragUpdateEvent( ev );
                }
        }
 
        void mouseDragEnd( QMouseEvent *ev = nullptr ) {
 
                m_pDragScroller->endDrag();
 
                if ( m_selectionState == MouseLasso) {
                        m_checkpointSelectedElements.clear();
                        m_selectionState = Idle;
                        m_pWidget->endMouseGesture();
                        updateWidgetGroup();
 
                } else if ( m_selectionState == MouseMoving ) {
                        m_selectionState = Idle;
                        m_pWidget->endMouseGesture();
                        m_pWidget->selectionMoveEndEvent( ev );
                        updateWidgetGroup();
 
                } else {
                        // Pass drag end to widget
                        m_pWidget->mouseDragEndEvent( ev );
                }
        }
 
 
 
        // -------------------------------------------------------------------------------------------------------
 
 
        bool keyPressEvent( QKeyEvent *ev ) {
 
                if ( ev->matches( QKeySequence::SelectNextChar )
                         || ev->matches( QKeySequence::SelectPreviousChar )
                         || ev->matches( QKeySequence::SelectNextLine )
                         || ev->matches( QKeySequence::SelectPreviousLine )
                         || ev->matches( QKeySequence::SelectStartOfLine)
                         || ev->matches( QKeySequence::SelectEndOfLine )
                         || ev->matches( QKeySequence::SelectStartOfDocument )
                         || ev->matches( QKeySequence::SelectEndOfDocument ) ) {
                        // Selection keys will start or continue a selection lasso
 
                        if ( m_selectionState == KeyboardLasso ) {
                                // Already in keyboard lasso state, just moving the
                                // current selection. Wait for Widget to update
                                // keyboard cursor position before updating lasso
                                // dimensions.
                        } else {
                                // Begin keyboard cursor lasso.
                                m_selectionState = KeyboardLasso;
                                m_keyboardCursorStart = m_pWidget->getKeyboardCursorRect();
                                m_lasso = m_keyboardCursorStart;
                        }
 
                } else if ( ev->key() == Qt::Key_Enter || ev->key() == Qt::Key_Return ) {
 
                        // Key: Enter/Return: start or end a move or copy
                        if ( m_selectionState == Idle ) {
 
                                bool bHitselected = false;
                                for ( Elem e : m_pWidget->elementsIntersecting( m_pWidget->getKeyboardCursorRect() ) ) {
                                        if ( m_pSelectionGroup->m_selectedElements.find( e )
                                                 != m_pSelectionGroup->m_selectedElements.end() ) {
                                                bHitselected = true;
                                                break;
                                        }
                                }
                                if ( bHitselected ) {
                                        // Hit "Enter" over a selected element. Begin move.
                                        m_keyboardCursorStart = m_pWidget->getKeyboardCursorRect();
                                        m_selectionState = KeyboardMoving;
                                        updateWidgetGroup();
                                        return true;
                                }
 
                        } else if ( m_selectionState == KeyboardLasso ) {
                                // If we hit 'Enter' from lasso mode, go directly to move
                                m_keyboardCursorStart = m_pWidget->getKeyboardCursorRect();
                                m_selectionState = KeyboardMoving;
                                updateWidgetGroup();
                                return true;
 
                        } else if ( m_selectionState == KeyboardMoving ) {
                                // End keyboard move
                                m_selectionState = Idle;
                                m_pWidget->selectionMoveEndEvent( ev );
                                return true;
 
                        } else if ( m_selectionState == KeyboardLasso ) {
                                // end keyboard lasso
                                m_selectionState = Idle;
                                return true;
                        }
 
                } else if ( ev->key() == Qt::Key_Escape ) {
 
                        // Key: Escape: cancel any lasso or move/copy in progress; or clear any selection.
                        if ( m_selectionState == Idle ) {
                                if ( !m_pSelectionGroup->m_selectedElements.empty() ) {
                                        clearSelection();
                                        updateWidgetGroup();
                                        return true;
                                }
                        } else {
                                if ( m_selectionState == MouseMoving || m_selectionState == MouseLasso ) {
                                        m_pWidget->endMouseGesture();
                                        m_pWidget->selectionMoveCancelEvent();
                                }
                                m_selectionState = Idle;
                                updateWidgetGroup();
                                return true;
                        }
 
                } else {
                        // Other keys should probably also cancel lasso, but not move?
                        if ( m_selectionState == KeyboardLasso ) {
                                m_selectionState = Idle;
                                updateWidgetGroup();
                        }
                }
                return false;
        }
 
 
        void updateKeyboardCursorPosition( QRect cursor ) {
                if ( m_selectionState == KeyboardLasso ) {
                        m_lasso = m_keyboardCursorStart.united( m_pWidget->getKeyboardCursorRect() );
 
                        // Clear and rebuild selection
                        clearSelection();
                        auto selected = m_pWidget->elementsIntersecting( m_lasso );
                        for ( auto s : selected ) {
                                m_pSelectionGroup->m_selectedElements.insert( s );
                        }
 
                } else if ( m_selectionState == KeyboardMoving ) {
                        QRect cursorPosition = m_pWidget->getKeyboardCursorRect();
                        m_movingOffset = cursorPosition.topLeft() - m_keyboardCursorStart.topLeft();
 
                }
        }
 
 
};
 
#endif // SELECTION_H