layer.h

/*
 
Pencil2D - Traditional Animation Software
Copyright (C) 2005-2007 Patrick Corrieri & Pascal Naidon
Copyright (C) 2012-2020 Matthew Chiawen Chang
 
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; version 2 of the License.
 
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.
 
*/
#ifndef LAYER_H
#define LAYER_H
 
#include <map>
#include <functional>
#include <QObject>
#include <QString>
#include <QDomElement>
#include "pencilerror.h"
 
class KeyFrame;
class Status;
 
typedef std::function<void()> ProgressCallback;
 
class Layer
{
    Q_DECLARE_TR_FUNCTIONS(Layer)
public:
    enum LAYER_TYPE
    {
        UNDEFINED = 0,
        BITMAP = 1,
        VECTOR = 2,
        MOVIE = 3, // not supported yet
        SOUND = 4,
        CAMERA = 5,
    };
 
    explicit Layer(int id, LAYER_TYPE eType);
    virtual ~Layer();
 
    int id() const { return mId; }
    void setId(int layerId) { mId = layerId; }
    LAYER_TYPE type() const { return meType; }
 
    void setName(QString name) { mName = name; }
    QString name() const { return mName; }
 
    void switchVisibility() { mVisible = !mVisible; }
 
    bool visible() const { return mVisible; }
    void setVisible(bool b) { mVisible = b; }
 
    QList<int> selectedKeyFramesPositions() const { return mSelectedFrames_byPosition; }
 
    QList<int> selectedKeyFramesByLast() const { return mSelectedFrames_byLast; }
 
    virtual Status saveKeyFrameFile(KeyFrame*, QString dataPath) = 0;
    virtual void loadDomElement(const QDomElement& element, QString dataDirPath, ProgressCallback progressForward) = 0;
    virtual QDomElement createDomElement(QDomDocument& doc) const = 0;
    QDomElement createBaseDomElement(QDomDocument& doc) const;
    void loadBaseDomElement(const QDomElement& elem);
 
    // KeyFrame interface
    int getMaxKeyFramePosition() const;
    int firstKeyFramePosition() const;
 
    bool keyExists(int position) const;
    int  getPreviousKeyFramePosition(int position) const;
    int  getNextKeyFramePosition(int position) const;
    int  getPreviousFrameNumber(int position, bool isAbsolute) const;
    int  getNextFrameNumber(int position, bool isAbsolute) const;
 
    int keyFrameCount() const { return static_cast<int>(mKeyFrames.size()); }
    int selectedKeyFrameCount() const { return mSelectedFrames_byPosition.count(); }
    bool hasAnySelectedFrames() const { return !mSelectedFrames_byLast.empty() && !mSelectedFrames_byPosition.empty(); }
 
    bool insertExposureAt(int position);
 
    bool addNewKeyFrameAt(int position);
    void addOrReplaceKeyFrame(int position, KeyFrame* pKeyFrame);
    virtual bool addKeyFrame(int position, KeyFrame* pKeyFrame);
    virtual bool removeKeyFrame(int position);
    virtual void replaceKeyFrame(const KeyFrame* pKeyFrame) = 0;
 
    bool swapKeyFrames(int position1, int position2);
    bool moveKeyFrame(int position, int offset);
    KeyFrame* getKeyFrameAt(int position) const;
    KeyFrame* getLastKeyFrameAtPosition(int position) const;
    bool keyExistsWhichCovers(int frameNumber);
    KeyFrame *getKeyFrameWhichCovers(int frameNumber) const;
 
    void foreachKeyFrame(std::function<void(KeyFrame*)>) const;
 
    void setModified(int position, bool isModified) const;
 
    // Handle selection
    bool isFrameSelected(int position) const;
    void setFrameSelected(int position, bool isSelected);
    void toggleFrameSelected(int position, bool allowMultiple = false);
    void extendSelectionTo(int position);
    void selectAllFramesAfter(int position);
 
    bool newSelectionOfConnectedFrames(int position);
 
    void setExposureForSelectedFrames(int offset);
 
    bool reverseOrderOfSelection();
 
    void deselectAll();
 
    bool moveSelectedFrames(int offset);
    QList<int> getSelectedFramesByPos() const { return mSelectedFrames_byPosition; }
 
    bool canMoveSelectedFramesToOffset(int offset) const;
 
    Status save(const QString& sDataFolder, QStringList& attachedFiles, ProgressCallback progressStep);
    virtual Status presave(const QString& sDataFolder) { Q_UNUSED(sDataFolder); return Status::SAFE; }
 
    bool isPaintable() const;
 
    QList<int> dirtyFrames() const { return mDirtyFrames; }
 
    void markFrameAsDirty(const int frameNumber) { mDirtyFrames << frameNumber; }
 
    void clearDirtyFrames() { mDirtyFrames.clear(); }
 
protected:
    virtual KeyFrame* createKeyFrame(int position) = 0;
    bool loadKey(KeyFrame*);
 
private:
    void removeFromSelectionList(int position);
 
    LAYER_TYPE meType = UNDEFINED;
    int        mId = 0;
    bool       mVisible = true;
    QString    mName;
 
    std::map<int, KeyFrame*, std::greater<int>> mKeyFrames;
 
    // We need to keep track of selected frames ordered by last selected
    // and by position.
    // Both should be pre-sorted on each selection for optimization purpose when moving frames.
    //
    QList<int> mSelectedFrames_byLast; // Used to handle selection range (based on last selected
    QList<int> mSelectedFrames_byPosition; // Used to handle frames movements on the timeline
 
    // Used for clearing cache for modified frames.
    QList<int> mDirtyFrames;
};
 
#endif