TimeLineWidget.h

Go to the documentation of this file.

/*
 * TimeLineWidget.h - class timeLine, representing a time-line with position marker
 *
 * Copyright (c) 2004-2008 Tobias Doerffel <tobydox/at/users.sourceforge.net>
 *
 * This file is part of LMMS - https://lmms.io
 *
 * 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 (see COPYING); if not, write to the
 * Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
 * Boston, MA 02110-1301 USA.
 *
 */
 
#ifndef LMMS_GUI_TIMELINE_WIDGET_H
#define LMMS_GUI_TIMELINE_WIDGET_H
 
#include <array>
 
#include <QSize>
#include <QWidget>
 
#include "Song.h"
#include "embed.h"
 
 
class QToolBar;
 
namespace lmms {
 
class Timeline;
 
} // namespace lmms
 
namespace lmms::gui
{
 
class TextFloat;
 
 
 
 
class TimeLineWidget : public QWidget
{
        Q_OBJECT
public:
        Q_PROPERTY( QColor barLineColor READ getBarLineColor WRITE setBarLineColor )
        Q_PROPERTY( QColor barNumberColor READ getBarNumberColor WRITE setBarNumberColor )
        Q_PROPERTY( QColor inactiveLoopColor READ getInactiveLoopColor WRITE setInactiveLoopColor )
        Q_PROPERTY( QBrush inactiveLoopBrush READ getInactiveLoopBrush WRITE setInactiveLoopBrush )
        Q_PROPERTY( QColor inactiveLoopInnerColor READ getInactiveLoopInnerColor WRITE setInactiveLoopInnerColor )
        Q_PROPERTY(QColor inactiveLoopHandleColor MEMBER m_inactiveLoopHandleColor)
        Q_PROPERTY( QColor activeLoopColor READ getActiveLoopColor WRITE setActiveLoopColor )
        Q_PROPERTY( QBrush activeLoopBrush READ getActiveLoopBrush WRITE setActiveLoopBrush )
        Q_PROPERTY( QColor activeLoopInnerColor READ getActiveLoopInnerColor WRITE setActiveLoopInnerColor )
        Q_PROPERTY(QColor activeLoopHandleColor MEMBER m_activeLoopHandleColor)
        Q_PROPERTY( int loopRectangleVerticalPadding READ getLoopRectangleVerticalPadding WRITE setLoopRectangleVerticalPadding )
        Q_PROPERTY(int loopHandleWidth MEMBER m_loopHandleWidth)
        Q_PROPERTY(QSize mouseHotspotSelLeft READ mouseHotspotSelLeft WRITE setMouseHotspotSelLeft)
        Q_PROPERTY(QSize mouseHotspotSelRight READ mouseHotspotSelRight WRITE setMouseHotspotSelRight)
 
        static constexpr const char* AutoScrollDisabledString = "disabled";
        static constexpr const char* AutoScrollSteppedString = "stepped";
        static constexpr const char* AutoScrollContinuousString = "continuous";
 
        enum class AutoScrollState
        {
                Stepped,
                Continuous,
                Disabled
        };
 
        TimeLineWidget(int xoff, int yoff, float ppb, Timeline& timeline,
                                const TimePos& begin, QWidget* parent);
        ~TimeLineWidget() override;
 
        inline QColor const & getBarLineColor() const { return m_barLineColor; }
        inline void setBarLineColor(QColor const & barLineColor) { m_barLineColor = barLineColor; }
 
        inline QColor const & getBarNumberColor() const { return m_barNumberColor; }
        inline void setBarNumberColor(QColor const & barNumberColor) { m_barNumberColor = barNumberColor; }
 
        inline QColor const & getInactiveLoopColor() const { return m_inactiveLoopColor; }
        inline void setInactiveLoopColor(QColor const & inactiveLoopColor) { m_inactiveLoopColor = inactiveLoopColor; }
 
        inline QBrush const & getInactiveLoopBrush() const { return m_inactiveLoopBrush; }
        inline void setInactiveLoopBrush(QBrush const & inactiveLoopBrush) { m_inactiveLoopBrush = inactiveLoopBrush; }
 
        inline QColor const & getInactiveLoopInnerColor() const { return m_inactiveLoopInnerColor; }
        inline void setInactiveLoopInnerColor(QColor const & inactiveLoopInnerColor) { m_inactiveLoopInnerColor = inactiveLoopInnerColor; }
 
        inline QColor const & getActiveLoopColor() const { return m_activeLoopColor; }
        inline void setActiveLoopColor(QColor const & activeLoopColor) { m_activeLoopColor = activeLoopColor; }
 
        inline QBrush const & getActiveLoopBrush() const { return m_activeLoopBrush; }
        inline void setActiveLoopBrush(QBrush const & activeLoopBrush) { m_activeLoopBrush = activeLoopBrush; }
 
        inline QColor const & getActiveLoopInnerColor() const { return m_activeLoopInnerColor; }
        inline void setActiveLoopInnerColor(QColor const & activeLoopInnerColor) { m_activeLoopInnerColor = activeLoopInnerColor; }
 
        inline int const & getLoopRectangleVerticalPadding() const { return m_loopRectangleVerticalPadding; }
        inline void setLoopRectangleVerticalPadding(int const & loopRectangleVerticalPadding) { m_loopRectangleVerticalPadding = loopRectangleVerticalPadding; }
 
        auto mouseHotspotSelLeft() const -> QSize
        {
                const auto point = m_cursorSelectLeft.hotSpot();
                return QSize{point.x(), point.y()};
        }
 
        void setMouseHotspotSelLeft(const QSize& s)
        {
                m_cursorSelectLeft = QCursor{m_cursorSelectLeft.pixmap(), s.width(), s.height()};
        }
 
        auto mouseHotspotSelRight() const -> QSize
        {
                const auto point = m_cursorSelectRight.hotSpot();
                return QSize{point.x(), point.y()};
        }
 
        void setMouseHotspotSelRight(const QSize& s)
        {
                m_cursorSelectRight = QCursor{m_cursorSelectRight.pixmap(), s.width(), s.height()};
        }
 
        static AutoScrollState defaultAutoScrollState();
        AutoScrollState autoScroll() const { return m_autoScroll; }
        void setAutoScroll(AutoScrollState state) { m_autoScroll = state; }
 
        inline void setPixelsPerBar( float ppb )
        {
                m_ppb = ppb;
                update();
        }
 
        void setXOffset(const int x);
 
        void addToolButtons(QToolBar* _tool_bar );
 
        inline int markerX( const TimePos & _t ) const
        {
                return m_xOffset + static_cast<int>( ( _t - m_begin ) *
                                        m_ppb / TimePos::ticksPerBar() );
        }
 
        Timeline* timeline()
        {
                return m_timeline;
        }
 
        bool isRecording() const { return m_isRecording; }
        void setRecording(bool recording) { m_isRecording = recording; }
 
        bool isPlayheadVisible() const { return m_isPlayheadVisible; }
        void setPlayheadVisible(bool visible) { m_isPlayheadVisible = visible; }
 
signals:
        void regionSelectedFromPixels( int, int );
        void selectionFinished();
 
public slots:
        void setSnapSize( const float snapSize )
        {
                m_snapSize = snapSize;
        }
        void toggleAutoScroll( int _n );
 
protected:
        void paintEvent( QPaintEvent * _pe ) override;
        void mousePressEvent( QMouseEvent * _me ) override;
        void mouseMoveEvent( QMouseEvent * _me ) override;
        void mouseReleaseEvent( QMouseEvent * _me ) override;
        void contextMenuEvent(QContextMenuEvent* event) override;
 
private:
        enum class Action
        {
                NoAction,
                MovePositionMarker,
                MoveLoopBegin,
                MoveLoopEnd,
                MoveLoop,
                SelectSongClip,
        };
 
        auto getClickedTime(int xPosition) const -> TimePos;
        auto getLoopAction(QMouseEvent* event) const -> Action;
        auto actionCursor(Action action) const -> QCursor;
 
        QPixmap m_posMarkerPixmap = embed::getIconPixmap("playpos_marker");
        QPixmap m_recordingPosMarkerPixmap = embed::getIconPixmap("recording_playpos_marker");
 
        QColor m_inactiveLoopColor = QColor{52, 63, 53, 64};
        QBrush m_inactiveLoopBrush = QColor{255, 255, 255, 32};
        QColor m_inactiveLoopInnerColor = QColor{255, 255, 255, 32};
        QColor m_inactiveLoopHandleColor = QColor{255, 255, 255, 32};
 
        QColor m_activeLoopColor = QColor{52, 63, 53, 255};
        QBrush m_activeLoopBrush = QColor{55, 141, 89};
        QColor m_activeLoopInnerColor = QColor{74, 155, 100, 255};
        QColor m_activeLoopHandleColor = QColor{74, 155, 100, 255};
 
        int m_loopRectangleVerticalPadding = 1;
        int m_loopHandleWidth = 5;
 
        QColor m_barLineColor = QColor{192, 192, 192};
        QColor m_barNumberColor = m_barLineColor.darker(120);
 
        QCursor m_cursorSelectLeft = QCursor{embed::getIconPixmap("cursor_select_left"), 0, 16};
        QCursor m_cursorSelectRight = QCursor{embed::getIconPixmap("cursor_select_right"), 32, 16};
 
        // Width of the unused region on the widget's left (above track labels or piano)
        int m_xOffset;
        float m_ppb;
        float m_snapSize = 1.f;
        Timeline* m_timeline;
        // Leftmost position visible in parent editor
        const TimePos & m_begin;
 
        AutoScrollState m_autoScroll = defaultAutoScrollState();
 
        // When in MoveLoop mode we need the initial positions. Storing only the latest
        // position allows for unquantized drag but fails when toggling quantization.
        std::array<TimePos, 2> m_oldLoopPos;
        TimePos m_dragStartPos;
 
        bool m_isRecording = false;
        bool m_isPlayheadVisible = true;
 
        TextFloat* m_hint = nullptr;
        int m_initalXSelect;
 
        Action m_action = Action::NoAction;
};
 
} // namespace lmms::gui
 
#endif // LMMS_GUI_TIMELINE_WIDGET_H