qtau/editor/Events.h

/*
    This file is part of QTau
    Copyright (C) 2013-2018  Tobias "Tomoko" Platen <tplaten@posteo.de>
    Copyright (C) 2013       digited       <https://github.com/digited>
    Copyright (C) 2010-2013  HAL@ShurabaP  <https://github.com/haruneko>

    QTau 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 3 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.  If not, see <http://www.gnu.org/licenses/>.

    SPDX-License-Identifier: GPL-3.0+
*/

#ifndef EVENTS_H
#define EVENTS_H

#include <QObject>
#include <QStack>


class qtauEvent
{
    friend class qtauEventManager;

public:
    typedef enum {    // linking is sorta shortcut because I don't feel like making composite events
        single = 0,   // separate event
        linkedToNext, // requires applying next after this one
        linkedToPrev, // should be applied right after previous one
        linkedToBoth  // is in the middle of chain of events
    } EEventLink;

    qtauEvent(int type = 0, bool forward = true, EEventLink link = single) :
        _type(type), _forward(forward), _linkType(link), _isSavePoint(false) {}
    virtual ~qtauEvent()   {}

    int type()            const { return _type;     }
    bool isForward()      const { return _forward;  } // is event used to apply or to revert its changeset
    EEventLink isLinked() const { return _linkType; } // should event be applied with other(s)

    bool isSavePoint()                  { return _isSavePoint; }
    void setSavePoint(bool isSP = true) { _isSavePoint = isSP; }

protected:
    int  _type;
    bool _forward;
    EEventLink _linkType;

    bool _isSavePoint;


    virtual qtauEvent *allocCopy() const = 0; // should create exact copy of event object on heap

};


/// logic for any class that wants to use events
class qtauEventManager : public QObject
{
    Q_OBJECT

public:
    explicit qtauEventManager(QObject *parent = 0) : QObject(parent) {}
    virtual ~qtauEventManager() { clearHistory(); }

    virtual void storeEvent(const qtauEvent *e)
    {
        clearFuture();
        events.push(e->allocCopy());
        stackChanged();
    }

    virtual void undo()
    {
        if (canUndo())
        {
            futureEvents.push(events.pop());
            futureEvents.top()->_forward = false;
            processEvent(futureEvents.top());
            stackChanged();
            emit onEvent(futureEvents.top());
        }
    }

    virtual void redo()
    {
        if (canRedo())
        {
            events.push(futureEvents.pop());
            events.top()->_forward = true;
            processEvent(events.top());
            stackChanged();
            emit onEvent(events.top());
        }
    }

    virtual void clearHistory()   { clearPast(); clearFuture(); stackChanged(); }
    virtual int  historyDepth()   { return events.size();           }
    virtual bool isHistoryEmpty() { return events.isEmpty();        }
    virtual bool canUndo()        { return !events.isEmpty();       }
    virtual bool canRedo()        { return !futureEvents.isEmpty(); }

signals:
    void onEvent(qtauEvent*);

protected:
    QStack<qtauEvent*> events;
    QStack<qtauEvent*> futureEvents; // what was undo'ed

    // making those functions purely virtual crashes app at calling stackChange from clearHistory on destruction
    virtual bool processEvent(qtauEvent*) { return false; } // on undo/redo
    virtual void stackChanged() {} // on store (add) and clear (remove all)

    void clearPast()
    {
        while (!events.isEmpty())
            delete events.pop();
    }

    void clearFuture()
    {
        while (!futureEvents.isEmpty())
            delete futureEvents.pop();
    }

};

#endif // EVENTS_H