ViewManager.h

Go to the documentation of this file.

/* -*- c-basic-offset: 4 indent-tabs-mode: nil -*-  vi:set ts=8 sts=4 sw=4: */

/*
    Sonic Visualiser
    An audio file viewer and annotation editor.
    Centre for Digital Music, Queen Mary, University of London.
    This file copyright 2006 Chris Cannam and QMUL.
    
    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.  See the file
    COPYING included with this distribution for more information.
*/

#ifndef SV_VIEW_MANAGER_H
#define SV_VIEW_MANAGER_H

#include <QObject>
#include <QTimer>
#include <QPalette>

#include <map>

#include "base/ViewManagerBase.h"
#include "base/Selection.h"
#include "base/Command.h"
#include "base/Clipboard.h"
#include "base/BaseTypes.h"
#include "base/ZoomLevel.h"

#include "data/model/Model.h"

class AudioPlaySource;
class AudioRecordTarget;
class Model;

enum PlaybackFollowMode {

    PlaybackScrollContinuous,

    PlaybackScrollPageWithCentre,

    PlaybackScrollPage,

    PlaybackIgnore
};

class View;

class ViewManager : public ViewManagerBase
{
    Q_OBJECT

public:
    ViewManager();
    virtual ~ViewManager();

    void setAudioPlaySource(AudioPlaySource *source) override;
    void setAudioRecordTarget(AudioRecordTarget *target) override;

    bool isPlaying() const;
    bool isRecording() const;

    sv_frame_t getGlobalCentreFrame() const; // the set method is a slot
    ZoomLevel getGlobalZoom() const;

    sv_frame_t getPlaybackFrame() const; // the set method is a slot

    // Only meaningful in solo mode, and used for optional alignment feature
    ModelId getPlaybackModel() const;
    void setPlaybackModel(ModelId);

    sv_frame_t alignPlaybackFrameToReference(sv_frame_t) const override;
    sv_frame_t alignReferenceToPlaybackFrame(sv_frame_t) const override;

    bool haveInProgressSelection() const;
    const Selection &getInProgressSelection(bool &exclusive) const;
    void setInProgressSelection(const Selection &selection, bool exclusive);
    void clearInProgressSelection();

    const MultiSelection &getSelection() const override;

    const MultiSelection::SelectionList &getSelections() const override;
    void setSelection(const Selection &selection);
    void addSelection(const Selection &selection);
    void removeSelection(const Selection &selection);
    void clearSelections();
    sv_frame_t constrainFrameToSelection(sv_frame_t frame) const override;

    void addSelectionQuietly(const Selection &selection);

    Selection getContainingSelection(sv_frame_t frame, bool defaultToFollowing) const override;

    Clipboard &getClipboard() { return m_clipboard; }

    enum ToolMode {
        NavigateMode,
        SelectMode,
        EditMode,
        DrawMode,
        EraseMode,
        MeasureMode,
        NoteEditMode //GF: Tonioni: this tool mode will be context sensitive.
    };
    ToolMode getToolMode() const { return m_toolMode; }
    void setToolMode(ToolMode mode);

    void setToolModeFor(const View *v, ToolMode mode);
    ToolMode getToolModeFor(const View *v) const;
    void clearToolModeOverrides();

    bool getPlayLoopMode() const override { return m_playLoopMode; }
    void setPlayLoopMode(bool on);

    bool getPlaySelectionMode() const override { return m_playSelectionMode; }
    void setPlaySelectionMode(bool on);

    bool getPlaySoloMode() const override { return m_playSoloMode; }
    void setPlaySoloMode(bool on);

    bool getAlignMode() const override { return m_alignMode; }
    void setAlignMode(bool on);

    void setIlluminateLocalFeatures(bool i) { m_illuminateLocalFeatures = i; }
    void setShowWorkTitle(bool show) { m_showWorkTitle = show; }
    void setShowDuration(bool show) { m_showDuration = show; }

    sv_samplerate_t getPlaybackSampleRate() const;

    sv_samplerate_t getDeviceSampleRate() const;

    sv_samplerate_t getMainModelSampleRate() const { return m_mainModelSampleRate; }

    void setMainModelSampleRate(sv_samplerate_t sr) { m_mainModelSampleRate = sr; }

    static int scalePixelSize(int pixels);
    
    enum OverlayMode {
        NoOverlays,
        GlobalOverlays,
        StandardOverlays,
        AllOverlays
    };
    void setOverlayMode(OverlayMode mode);
    OverlayMode getOverlayMode() const { return m_overlayMode; }

    void setShowCentreLine(bool show);
    bool shouldShowCentreLine() const { return m_showCentreLine; }

    bool shouldShowDuration() const {
        return m_overlayMode != NoOverlays && m_showDuration;
    }
    bool shouldShowFrameCount() const {
        return m_showCentreLine && shouldShowDuration();
    }
    bool shouldShowVerticalScale() const {
        return m_overlayMode != NoOverlays;
    }
    bool shouldShowVerticalColourScale() const {
        return m_overlayMode == AllOverlays;
    }
    bool shouldShowHorizontalValueScale() const { // for layers where x != time
        return m_overlayMode != NoOverlays;
    }
    bool shouldShowSelectionExtents() const {
        return m_overlayMode != NoOverlays && m_overlayMode != GlobalOverlays;
    }
    bool shouldShowLayerNames() const {
        return m_overlayMode == AllOverlays;
    }
    bool shouldShowScaleGuides() const {
        return m_overlayMode != NoOverlays;
    }
    bool shouldShowWorkTitle() const {
        return m_showWorkTitle;
    }
    bool shouldIlluminateLocalFeatures() const {
        return m_illuminateLocalFeatures;
    }
    bool shouldShowFeatureLabels() const {
        return m_overlayMode != NoOverlays && m_overlayMode != GlobalOverlays;
    }

    void setZoomWheelsEnabled(bool enable);
    bool getZoomWheelsEnabled() const { return m_zoomWheelsEnabled; }

    void setOpportunisticEditingEnabled(bool enable);
    bool getOpportunisticEditingEnabled() const {
        return m_opportunisticEditingEnabled;
    }

    void setGlobalDarkBackground(bool dark);
    bool getGlobalDarkBackground() const;

signals:
    void globalCentreFrameChanged(sv_frame_t frame);

    void viewCentreFrameChanged(View *v, sv_frame_t frame);

    void viewZoomLevelChanged(View *v, ZoomLevel zoom, bool locked);

    void playbackFrameChanged(sv_frame_t frame);

    void monitoringLevelsChanged(float left, float right);

    void selectionChanged();

    void selectionChangedByUser();

    void inProgressSelectionChanged();

    void toolModeChanged();

    void playLoopModeChanged();
    void playLoopModeChanged(bool);

    void playSelectionModeChanged();
    void playSelectionModeChanged(bool);

    void playSoloModeChanged();
    void playSoloModeChanged(bool);

    void alignModeChanged();
    void alignModeChanged(bool);

    void overlayModeChanged();

    void showCentreLineChanged();

    void zoomWheelsEnabledChanged();

    void opportunisticEditingEnabledChanged();
    
    void activity(QString);

public slots:
    void viewCentreFrameChanged(sv_frame_t, bool, PlaybackFollowMode);
    void viewZoomLevelChanged(ZoomLevel, bool);
    void setGlobalCentreFrame(sv_frame_t);
    void setPlaybackFrame(sv_frame_t);
    void playStatusChanged(bool playing);
    void recordStatusChanged(bool recording);

protected slots:
    void checkPlayStatus();
    void seek(sv_frame_t);

protected:
    AudioPlaySource *m_playSource;
    AudioRecordTarget *m_recordTarget;
    
    sv_frame_t m_globalCentreFrame;
    ZoomLevel m_globalZoom;
    mutable sv_frame_t m_playbackFrame;
    ModelId m_playbackModel;
    sv_samplerate_t m_mainModelSampleRate;

    float m_lastLeft;
    float m_lastRight;

    MultiSelection m_selections;
    Selection m_inProgressSelection;
    bool m_inProgressExclusive;

    Clipboard m_clipboard;

    ToolMode m_toolMode;
    std::map<const View *, ToolMode> m_toolModeOverrides;

    bool m_playLoopMode;
    bool m_playSelectionMode;
    bool m_playSoloMode;
    bool m_alignMode;

    void setSelections(const MultiSelection &ms, bool quietly = false);
    void signalSelectionChange();

    class SetSelectionCommand : public Command
    {
    public:
        SetSelectionCommand(ViewManager *vm, const MultiSelection &ms);
        virtual ~SetSelectionCommand();
        void execute() override;
        void unexecute() override;
        QString getName() const override;

    protected:
        ViewManager *m_vm;
        MultiSelection m_oldSelection;
        MultiSelection m_newSelection;
    };

    OverlayMode m_overlayMode;
    bool m_zoomWheelsEnabled;
    bool m_opportunisticEditingEnabled;
    bool m_showCentreLine;
    bool m_illuminateLocalFeatures;
    bool m_showWorkTitle;
    bool m_showDuration;

    QPalette m_lightPalette;
    QPalette m_darkPalette;
};

#endif