Document.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_DOCUMENT_H
#define SV_DOCUMENT_H

#include "layer/LayerFactory.h"
#include "transform/Transform.h"
#include "transform/ModelTransformer.h"
#include "transform/FeatureExtractionModelTransformer.h"
#include "base/Command.h"

#include <map>
#include <set>

class Model;
class Layer;
class View;
class WaveFileModel;
class AggregateWaveModel;

class AdditionalModelConverter;

class Align;

class Document : public QObject,
                 public XmlExportable
{
    Q_OBJECT

public:
    Document();
    virtual ~Document();

    Layer *createLayer(LayerFactory::LayerType);

    Layer *createMainModelLayer(LayerFactory::LayerType);

    Layer *createImportedLayer(ModelId);

    Layer *createEmptyLayer(LayerFactory::LayerType);

    Layer *createDerivedLayer(LayerFactory::LayerType, TransformId);

    Layer *createDerivedLayer(const Transform &,
                              const ModelTransformer::Input &);

    std::vector<Layer *> createDerivedLayers(const Transforms &,
                                             const ModelTransformer::Input &);

    typedef void *LayerCreationAsyncHandle;

    class LayerCreationHandler {
    public:
        virtual ~LayerCreationHandler() { }

        virtual void layersCreated(LayerCreationAsyncHandle handle,
                                   std::vector<Layer *> primary,
                                   std::vector<Layer *> additional) = 0;
    };

    LayerCreationAsyncHandle createDerivedLayersAsync(const Transforms &,
                                                      const ModelTransformer::Input &,
                                                      LayerCreationHandler *handler);

    void cancelAsyncLayerCreation(LayerCreationAsyncHandle handle);

    void deleteLayer(Layer *, bool force = false);

    void setMainModel(ModelId); // a WaveFileModel

    ModelId getMainModel() { return m_mainModel; }
    
    std::vector<ModelId> getTransformInputModels();

    bool isKnownModel(ModelId) const;

    ModelId addDerivedModel(const Transform &transform,
                            const ModelTransformer::Input &input,
                            QString &returnedMessage);

    friend class AdditionalModelConverter;
    std::vector<ModelId> addDerivedModels(const Transforms &transforms,
                                          const ModelTransformer::Input &input,
                                          QString &returnedMessage,
                                          AdditionalModelConverter *);

    void addAlreadyDerivedModel(const Transform &transform,
                                const ModelTransformer::Input &input,
                                ModelId outputModelToAdd);

    void addNonDerivedModel(ModelId);

    void setModel(Layer *, ModelId);

    void setChannel(Layer *, int);

    void addLayerToView(View *, Layer *);

    void removeLayerFromView(View *, Layer *);

    static bool canAlign();

    void setAutoAlignment(bool on) { m_autoAlignment = on; }

    void alignModels();

    void realignModels();

    bool isIncomplete() const { return m_isIncomplete; }

    void setIncomplete(bool i) { m_isIncomplete = i; }

    void toXml(QTextStream &, QString indent, QString extraAttributes) const override;
    void toXmlAsTemplate(QTextStream &, QString indent, QString extraAttributes) const;

signals:
    void layerAdded(Layer *);
    void layerRemoved(Layer *);
    void layerAboutToBeDeleted(Layer *);

    // Emitted when a layer is first added to a view, or when it is
    // last removed from a view
    void layerInAView(Layer *, bool);

    void modelAdded(ModelId);
    void mainModelChanged(ModelId); // a WaveFileModel; emitted after modelAdded

    void modelGenerationFailed(QString transformName, QString message);
    void modelGenerationWarning(QString transformName, QString message);
    void modelRegenerationFailed(QString layerName, QString transformName,
                                 QString message);
    void modelRegenerationWarning(QString layerName, QString transformName,
                                  QString message);

    void alignmentComplete(ModelId); // an AlignmentModel
    void alignmentFailed(ModelId, QString message); // an AlignmentModel

    void activity(QString);

protected slots:
    void performDeferredAlignment(ModelId);
    
protected:
    void releaseModel(ModelId model);

    void alignModel(ModelId, bool forceRecalculate = false);

    /*
     * Every model that is in use by a layer in the document must be
     * found in either m_mainModel or m_models.  We own and control
     * the lifespan of all of these models.
     */

    ModelId m_mainModel; // a WaveFileModel

    struct ModelRecord
    {
        // Information associated with a non-main model.  If this
        // model is derived from another, then source will be
        // something other than None and the transform name will be
        // set appropriately.  If the transform is set but source is
        // None, then there was a transform involved but the (target)
        // model has been modified since being generated from it.
        
        // This does not use ModelTransformer::Input, because it would
        // be confusing to have Input objects hanging around with None
        // models in them.

        ModelId source; // may be None
        int channel;
        Transform transform;
        bool additional;
    };

    // These must be stored in increasing order of id (as in the
    // ordered std::map), to ensure repeatability for automated tests
    std::map<ModelId, ModelRecord> m_models;

    std::set<ModelId> m_aggregateModels;
    std::set<ModelId> m_alignmentModels;
    
    void addAdditionalModel(ModelId);

    class AddLayerCommand : public Command
    {
    public:
        AddLayerCommand(Document *d, View *view, Layer *layer);
        virtual ~AddLayerCommand();
        
        void execute() override;
        void unexecute() override;
        QString getName() const override;

    protected:
        Document *m_d;
        View *m_view; // I don't own this
        Layer *m_layer; // Document owns this, but I determine its lifespan
        QString m_name;
        bool m_added;
    };

    class RemoveLayerCommand : public Command
    {
    public:
        RemoveLayerCommand(Document *d, View *view, Layer *layer);
        virtual ~RemoveLayerCommand();
        
        void execute() override;
        void unexecute() override;
        QString getName() const override;

    protected:
        Document *m_d;
        View *m_view; // I don't own this
        Layer *m_layer; // Document owns this, but I determine its lifespan
        bool m_wasDormant;
        QString m_name;
        bool m_added;
    };

    typedef std::map<Layer *, std::set<View *> > LayerViewMap;
    LayerViewMap m_layerViewMap;

    void addToLayerViewMap(Layer *, View *);
    void removeFromLayerViewMap(Layer *, View *);

    QString getUniqueLayerName(QString candidate);
    void writeBackwardCompatibleDerivation(QTextStream &, QString, ModelId,
                                           const ModelRecord &) const;

    void toXml(QTextStream &, QString, QString, bool asTemplate) const;
    void writePlaceholderMainModel(QTextStream &, QString) const;

    std::vector<Layer *> createLayersForDerivedModels(std::vector<ModelId>,
                                                      QStringList names);

    typedef std::vector<Layer *> LayerList;
    LayerList m_layers;

    bool m_autoAlignment;
    Align *m_align;

    bool m_isIncomplete;
};

#endif