ClipView.h

Go to the documentation of this file.

/*
 * ClipView.h - declaration of ClipView class
 *
 * Copyright (c) 2004-2014 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_CLIP_VIEW_H
#define LMMS_GUI_CLIP_VIEW_H
 
#include <optional>
 
#include <QVector>
 
#include "ModelView.h"
#include "Rubberband.h"
#include "Clip.h"
 
 
class QMenu;
 
namespace lmms
{
 
class DataFile;
 
namespace gui
{
 
class TextFloat;
class TrackView;
 
 
class ClipView : public selectableObject, public ModelView
{
    Q_OBJECT
 
// theming qproperties
    Q_PROPERTY( QColor mutedColor READ mutedColor WRITE setMutedColor )
    Q_PROPERTY( QColor mutedBackgroundColor READ mutedBackgroundColor WRITE setMutedBackgroundColor )
    Q_PROPERTY( QColor selectedColor READ selectedColor WRITE setSelectedColor )
    Q_PROPERTY( QColor textColor READ textColor WRITE setTextColor )
    Q_PROPERTY( QColor textBackgroundColor READ textBackgroundColor WRITE setTextBackgroundColor )
    Q_PROPERTY( QColor textShadowColor READ textShadowColor WRITE setTextShadowColor )
    Q_PROPERTY( QColor patternClipBackground READ patternClipBackground WRITE setPatternClipBackground )
    Q_PROPERTY( bool gradient READ gradient WRITE setGradient )
    Q_PROPERTY(QColor markerColor READ markerColor WRITE setMarkerColor)
 
public:
    const static int BORDER_WIDTH = 2;

    ClipView(Clip* clip, TrackView* tv);

    ~ClipView() override;

    bool fixedClips();
 
    inline Clip * getClip()
    {
        return m_clip;
    }
 
    inline TrackView * getTrackView()
    {
        return m_trackView;
    }
 
    // qproperty access functions, to be inherited & used by Clipviews
    QColor mutedColor() const { return m_mutedColor; }
    QColor mutedBackgroundColor() const { return m_mutedBackgroundColor; }
    QColor selectedColor() const { return m_selectedColor; }
    QColor textColor() const { return m_textColor; }
    QColor textBackgroundColor() const { return m_textBackgroundColor; }
    QColor textShadowColor() const { return m_textShadowColor; }
    QColor patternClipBackground() const { return m_patternClipBackground; }
    bool gradient() const { return m_gradient; }
    QColor markerColor() const { return m_markerColor; }
    void setMutedColor(const QColor& c) { m_mutedColor = QColor(c); }
    void setMutedBackgroundColor(const QColor& c) { m_mutedBackgroundColor = QColor(c); }
    void setSelectedColor(const QColor& c) { m_selectedColor = QColor(c); }
    void setTextColor(const QColor& c) { m_textColor = QColor(c); }
    void setTextBackgroundColor(const QColor& c) { m_textBackgroundColor = QColor(c); }
    void setTextShadowColor(const QColor& c) { m_textShadowColor = QColor(c); }
    void setPatternClipBackground(const QColor& c) { m_patternClipBackground = QColor(c); }
    void setGradient(const bool& b) { m_gradient = b; }
    void setMarkerColor(const QColor& c) { m_markerColor = QColor(c); }
 
    bool needsUpdate() const { return m_needsUpdate; }
    void setNeedsUpdate(bool b) { m_needsUpdate = b; }
 
    // Method to get a QVector of Clips to be affected by a context menu action
    QVector<ClipView *> getClickedClips();
 
    // Methods to remove, copy, cut, paste and mute a QVector of Clip views
    void copy( QVector<ClipView *> clipvs );
    void cut( QVector<ClipView *> clipvs );
    void paste();
    // remove and toggleMute are static because they don't depend
    // being called from a particular Clip view, but can be called anywhere as long
    // as a valid Clip view list is given, while copy/cut require an instance for
    // some metadata to be written to the clipboard.
    static void remove( QVector<ClipView *> clipvs );
    static void toggleMute( QVector<ClipView *> clipvs );
 
    void toggleSelectedAutoResize();
 
    QColor getColorForDisplay( QColor );
 
    void inline setMarkerPos(int x) { m_markerPos = x; }
    void inline setMarkerEnabled(bool e) { m_marker = e; }
 
public slots:

    virtual bool close();

    void remove();

    void update() override;
 
    void selectColor();
    void randomizeColor();
    void resetColor();
 
protected:
    enum class ContextMenuAction
    {
        Remove,
        Cut,
        Copy,
        Paste,
        Mute
    };
 
    TrackView * m_trackView;
    TimePos m_initialClipPos;
    TimePos m_initialClipEnd;
 
    bool m_marker = false;
    int m_markerPos = 0;
 
    virtual void constructContextMenu( QMenu * )
    {
    }

    void contextMenuEvent( QContextMenuEvent * cme ) override;
 
    void contextMenuAction( ContextMenuAction action );

    void dragEnterEvent(QDragEnterEvent* dee) override;

    void dropEvent( QDropEvent * de ) override;

    void mousePressEvent(QMouseEvent* me) override;

    void mouseMoveEvent(QMouseEvent* me) override;

    void mouseReleaseEvent(QMouseEvent* me) override;
 
    void resizeEvent( QResizeEvent * re ) override
    {
        m_needsUpdate = true;
        selectableObject::resizeEvent( re );
    }
 
    bool unquantizedModHeld( QMouseEvent * me );
    TimePos quantizeSplitPos(TimePos);

    float pixelsPerBar() const;

    DataFile createClipDataFiles(const QVector<ClipView *> & clips) const;
 
    virtual void paintTextLabel(QString const & text, QPainter & painter);
 
    auto hasCustomColor() const -> bool;
 
protected slots:
    void updateLength();

    void updatePosition();
 
private:
    enum class Action
    {
        None,
        Move,
        MoveSelection,
        Resize,
        ResizeLeft,
        Split,
        CopySelection,
        ToggleSelected
    } ;

    static TextFloat* s_textFloat;
 
    Clip * m_clip;
    Action m_action;
    QPoint m_initialMousePos;
    QPoint m_initialMouseGlobalPos;
    QVector<TimePos> m_initialOffsets;
 
    TextFloat * m_hint;
 
// qproperty fields
    QColor m_mutedColor;
    QColor m_mutedBackgroundColor;
    QColor m_selectedColor;
    QColor m_textColor;
    QColor m_textBackgroundColor;
    QColor m_textShadowColor;
    QColor m_patternClipBackground;
    bool m_gradient;
    QColor m_markerColor;
 
    bool m_needsUpdate;
    inline void setInitialPos( QPoint pos )
    {
        m_initialMousePos = pos;
        m_initialMouseGlobalPos = mapToGlobal( pos );
        m_initialClipPos = m_clip->startPosition();
        m_initialClipEnd = m_initialClipPos + m_clip->length();
    }

    void setInitialOffsets();

    bool mouseMovedDistance(QMouseEvent* me, int distance);

    TimePos draggedClipPos(QMouseEvent* me);
 
    int knifeMarkerPos( QMouseEvent * me );

    void setColor(const std::optional<QColor>& color);

    int resizeGripWidth() const;
    
    virtual bool isResizableBeforeStart() { return true; };
 
    
    bool splitClip(const TimePos pos);

    virtual bool destructiveSplitClip(const TimePos pos)
    {
        return splitClip(pos);
    }

    void updateCursor(QMouseEvent* me);
} ;
 
 
} // namespace gui
 
} // namespace lmms
 
#endif // LMMS_GUI_CLIP_VIEW_H