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 _DOCUMENT_H_
#define _DOCUMENT_H_

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

#include <map>
#include <set>

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

class Document : public QObject,
                 public XmlExportable
{
    Q_OBJECT

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

    Layer *createLayer(LayerFactory::LayerType);

    Layer *createMainModelLayer(LayerFactory::LayerType);

    Layer *createImportedLayer(Model *);

    Layer *createEmptyLayer(LayerFactory::LayerType);

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

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

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

    void setMainModel(WaveFileModel *);

    WaveFileModel *getMainModel() { return m_mainModel; }

    const WaveFileModel *getMainModel() const { return m_mainModel; }

    std::vector<Model *> getTransformInputModels();

    bool isKnownModel(const Model *) const;

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

    void addDerivedModel(const Transform &transform,
                         const ModelTransformer::Input &input,
                         Model *outputModelToAdd);

    void addImportedModel(Model *);

    void setModel(Layer *, Model *);

    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 toXml(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(Model *);
    void mainModelChanged(WaveFileModel *); // emitted after modelAdded
    void modelAboutToBeDeleted(Model *);

    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 alignmentFailed(QString transformName, QString message);

protected:
    void releaseModel(Model *model);

    void alignModel(Model *);

    /*
     * 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.
     */

    WaveFileModel *m_mainModel;

    struct ModelRecord
    {
        // Information associated with a non-main model.  If this
        // model is derived from another, then source will be non-NULL
        // and the transform name will be set appropriately.  If the
        // transform name is set but source is NULL, 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 NULL
        // models in them.

        const Model *source;
        int channel;
        Transform transform;

        // Count of the number of layers using this model.
        int refcount;
    };

    typedef std::map<Model *, ModelRecord> ModelMap;
    ModelMap m_models;

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

    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();
        
        virtual void execute();
        virtual void unexecute();
        virtual QString getName() const { return m_name; }

    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;
    };

    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, Model *,
                                           const ModelRecord &) const;

    static TransformId getAlignmentTransformName();
    
    typedef std::set<Layer *> LayerSet;
    LayerSet m_layers;

    bool m_autoAlignment;
};

#endif

---